构造器

public class Test2 {
	/**
	 * 创建一个类，他包含了一个在定义时就被初始化了的string域， 以及另一个通过构造器初始化了的string域，这两种的方式有何差异
	 */
	String st1 = new String("你好");
	Test2() {

	}

	Test2(String i) {
		this.st1 = new String("我爱你");
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
Test2 ts1=new Test2();
System.out.println(ts1.st1);
Test2 ts2=new Test2("我爱你");
System.out.println(ts2.st1);
	}

}

创建一个类，他包含了一个在定义时就被初始化了的string域， 以及另一个通过构造器初始化了的string域，这两种的方式有何差异？

当我们创建了构造器时，系统是不会再为我们创建默认构造器的。所以如果我们还需要使用默认构造器（无参构造器）时一定需要我们自己来创建。构造函数是在对象创建时调用，它会覆盖类定义初始化的String

此方法应根据不同的基本数据类型（作为参数列表）进行重载，根据被调用的版本，它打印出不同类型的狗吠(barking)、咆哮(howling)等信息。在测试类里编写main()方法来调用所有不同版本的方法。

public class Dog{
	 public static void main(String[] args) {
	  barking();
	  barking("汪汪汪");
	  barking(5);
	  howling();
	  howling("老虎");
	  howling("老虎",10);
	 }

	public static void barking(){
	  System.out.println("狗吠");
	 }
	 
	 public static void barking(String str){
	  System.out.println("狗吠"+str);
	 }
	 
	 public static void barking(int number){
	  System.out.println(number+"只狗在吠");;
	 }
	 
	 public static void howling(){
	  System.out.println("咆哮");
	 }
	 
	 public static void howling(String animal,int number){
	  System.out.println(number+"只"+animal+"在咆哮");
	 }
	 
	 public static void howling(String animal){
	  System.out.println(animal+"在咆哮");
	 }
	}

编写一个类，拥有两个静态字符串域，其中一个在第一处初始化，另一个在静态块中初始化。现在，加入一个静态方法用以打印出两个字段值。请证明它们都会被使用之前完成初始化动作

public class Test5 {
	String str = new String("我爱你");
	Test5(String str) {
		System.out.print(str);
	}

	static void print() {
		Test5 test = new Test5("你好");
		System.out.println(test.str);
	}
	public static void main(String[] args) {
		print();
	}
}

/**
 * 请证明加载类的动作仅发生一次，证明该类的第一个实体
 * 的创建或者对static成员的访问都有可能引起加载*/
class A {
	static int j = printInit("A.j initialized");

	static int printInit(String s) {
		System.out.println(s);
		return 1;
	}

	A() {
		System.out.println("A() constructor");
	}
}

class B extends A {
	static int k = printInit("B.k initialized");

	B() {
		System.out.println("B() constructor");
	}
}

class C {
	static int n = printInitC("C.n initialized");
	static A a = new A();

	C() {
		System.out.println("C() constructor");
	}

	static int printInitC(String s) {
		System.out.println(s);
		return 1;
	}
}

class D {
	D() {
		System.out.println("D() constructor");
	}
}

public class LoadClass extends B {
	static int i = printInit("LoadClass.i initialized");

	LoadClass() {
		System.out.println("LoadClass() constructor");
	}

	public static void main(String[] args) {
		// accessing static main causes loading (and initialization)
		// of A, B, & LoadClass
		System.out.println("hi");
		// call constructors from loaded classes:
		LoadClass lc = new LoadClass();
		// call to static field loads & initializes C:
		System.out.println(C.a);
		// call to constructor loads D:
		//D d = new D();
	}
}