Java笔记 —— 初始化

父类不含构造器

	
package com.example;

public class T{
	public T(int i){
		System.out.println("T" + "(" + i + ")");
	}
}
	

	
package com.example;

public class Person{ // 父类
	public static T t4 = new T(4);
	public T t5 = new T(5);
	public static T t6 = new T(6);
}
	

	
package com.example;

public class Man extends Person{ // 子类
	public static T t1 = new T(1);
	public T t2 = new T(2);
	public static T t3 = new T(3);
	
	public Man(){
		System.out.println("Man()");
	}
}
	

	
package com.example;

public class Test{
	public static void main(String[] args){
		new Man();							
	}
}
	

	
运行结果：

T(4)
T(6)
T(1)
T(3)
T(5)
T(2)
Man()
	

• 某个类不含构造器时，编译器会为这个类生成一个默认构造器，该生成的默认构造器是一个无参构造器。这些操作是在编译时完成的，所以我们看不见
• 当父类含有默认构造器时，编译器会自动在子类的构造器中调用父类的构造器来对父类进行初始化。这个过程也是在编译时完成的，所以我们看不见
• 初始化的顺序：父类静态属性 -> 子类静态属性 -> 父类非静态属性 -> 子类非静态属性 -> 调用子类构造器

父类含有无参构造器

	
package com.example;

public class T{
	public T(int i){
		System.out.println("T" + "(" + i + ")");
	}
}
	

	
package com.example;

public class Person{ // 父类
	public static T t4 = new T(4);
	public T t5 = new T(5);
	public static T t6 = new T(6);
	
	public Person(){ // 无参构造器
		System.out.println("Person()");
	}
}
	

	
package com.example;

public class Man extends Person{ // 子类
	public static T t1 = new T(1);
	public T t2 = new T(2);
	public static T t3 = new T(3);
	
	public Man(){
		System.out.println("Man()");
	}
}
	

	
package com.example;

public class Test{
	public static void main(String[] args){
		new Man();							
	}
}
	

	
运行结果：

T(4)
T(6)
T(1)
T(3)
T(5)
Person()
T(2)
Man()
	

• 父类含有无参构造器时和父类含有默认构造器时差不多，编译器会自动在子类的构造器中调用父类的构造器来对父类进行初始化
• 不同的是，当我们创建了构造器之后，编译器就不会再为类创建一个默认构造器了
• 初始化顺序：父类静态属性 -> 子类静态属性 -> 父类非静态属性 -> 父类构造器调用 -> 子类非静态属性 -> 子类构造器调用

父类只含有有参构造器

	
package com.example;

public class T{
	public T(int i){
		System.out.println("T" + "(" + i + ")");
	}
}
	

	
package com.example;

public class Person{ // 父类
	public static T t4 = new T(4);
	public T t5 = new T(5);
	public static T t6 = new T(6);
	
	public Person(int i){
	System.out.println("Person" + "(" + i + ")"); // 有参构造器
	}
}
	

	
package com.example;

public class Man extends Person{ // 子类
	public static T t1 = new T(1);
	public T t2 = new T(2);
	public static T t3 = new T(3);
	
	public Man(){
		super(1); // super 关键字表示调用父类构造器，且必须位于子类构造器的第一行，每个子类的构造器只能调用父类构造器一次
		System.out.println("Man()");
	}
}
	

	
package com.example;

public class Test{
	public static void main(String[] args){
		new Man();							
	}
}
	

	
运行结果：

T(4)
T(6)
T(1)
T(3)
T(5)
Person(1)
T(2)
Man()
	

• 当父类只有有参构造器时，子类构造器中必须使用 super 关键字调用父类构造器，否则会报错。
• 当子类有多个构造器时，子类中的每个构造器都必须要调用父类构造器（如果父类有多个构造器，那么子类构造器只需挑父类构造器的其中一个来调用即可，不过一定要保证子类的每个构造器都有调用父类构造器）

父类既含有无参构造器，也含有有参构造器

	
package com.example;

public class T{
	public T(int i){
		System.out.println("T" + "(" + i + ")");
	}
}
	

	
package com.example;

public class Person{ // 父类
	public static T t4 = new T(4);
	public T t5 = new T(5);
	public static T t6 = new T(6);
	
	public Person(){ // 无参构造器
		System.out.println("Person()");
	}
	public Person(int i){
	System.out.println("Person" + "(" + i + ")"); // 有参构造器
	}
}
	

	
package com.example;

public class Man extends Person{ // 子类
	public static T t1 = new T(1);
	public T t2 = new T(2);
	public static T t3 = new T(3);
	
	public Man(){ // 子类无参构造器
		System.out.println("Man()");
	}
	public Man(int i){ // 子类有参构造器
		System.out.println("Man" + "(" + i + ")");
	}
}
	

	
package com.example;

public class Test{
	public static void main(String[] args){
		System.out.println("调用子类的无参构造器");
		new Man();
		System.out.println("调用子类的有参构造器");
		new Man(1);
	}
}
	

	
运行结果：

调用子类的无参构造器
T(4)
T(6)
T(1)
T(3)
T(5)
Person()
T(2)
Man()
调用子类的有参构造器
T(5)
Person()
T(2)
Man(1)
	

• 当父类含有无参构造器时，即使子类有多个构造器，这些构造器也无需显式地通过 super 关键字调用父类构造器，因为编译器会自动为每个子类的构造器都调用父类的无参构造器，例如：例子中运行结果打印了两次 Person()，这是两次创建子类对象时，编译器自动调用父类中无参构造器的结果

例1：

	
package com.example;
import java.util.Arrays;

public class Test{
	public static void main(String[] args){
		int[] a;
		a = new int[]{1,2,3,4,5};
		System.out.println(Arrays.toString(a));
	}
}
	

	
运行结果：

[1, 2, 3, 4, 5]
	

例2（这种方式的用途）：

	
package com.example;
import java.util.Arrays;

public class T{
	public void show(Integer[] i){ //必须为 Integer 类型，不能是 int 这些基本类型
		System.out.println(Arrays.toString(i));
	}
	public void show(String[] str){
		System.out.println(Arrays.toString(str));
	}
}
	

	
package com.example;

public class Test{
	public static void main(String[] args){
		T t1 = new T();
		t1.show(new Integer[]{5,4,3,2,1}); // 必须为 Integer 类型，不能是 int 这些基本类型
		t1.show(new String[]{"张三", "李四", "王五"});
	}
}
	

	
运行结果：

[5, 4, 3, 2, 1]
[张三, 李四, 王五]
	

• 很明显这种方式的优点是无需额外定义一个数组变量 int[] a