Java 类的初始化时机

1.单个类的初始化顺序

 

/**
 * 
 * @author long 单个类的初始化顺序 1.父>子 2.静态的初始化顺序大于非静态 3.属性大于构造器
 * 
 *         注意虽然非静态变量不能向后引用非静态变量<br>
 *         因为先初始化静态变量,所以非静态变量可以向后引用静态变量
 * 
 */

class Person {
	public int name, age;
	public static int legs;

	public Person(final int name, final int age) {
		this.name = name;
		this.age = age;
	}

	public void info() {
		System.out.println(name + "," + age);
	}
}

public class InitClass01 {

	int num1 = num2 + 20;
	// static int num1=num2+20;
	// int num2=10;
	static int num2 = 20;

	/**
	 * 分清类对象 实例对象 一个jvm中只有一个类对象存储静态变量等 实例对象可以有多个
	 */
	public void test1() {
		Person.legs = 2; // 类对象初始化完成
		final Person p1 = new Person(1, 2);
		System.out.println(Person.legs);
		p1.info();

		new Person(3, 4);
		Person.legs = 4;

		System.out.println(Person.legs);
		System.out.println(Person.legs);
		System.out.println(Person.legs);
	}

	public static void main(final String[] args) {
		new InitClass01().test1();
	}

}

 2.单个类非静态变量的初始化顺序

/**
 * 对象实例变量的初始化时机 1,2种方式比第三种更早执行,但是1,2种对比则看他们的顺序<br>
 * 1.定义变量时候指定值 2.非静态块 3.构造函数
 * 
 */

// 判断weight的值
class Cat {
	String name;
	int age;
	double weight = 2.3;

	public Cat(final String name, final int age) {
		this.name = name;
		this.age = age;
	}

	{
		weight = 2.0;
	}

	// double weight=2.3;

	public void info() {
		System.out.println(name + "," + age + "," + weight);
	}
}

public class InitClass02 {
	public static void main(final String[] args) {
		final Cat cat1 = new Cat("cat1", 10);
		cat1.info();
	}

}

 

3.单个类的静态变量的初始化顺序

/**
 * 
 * @author long 类的静态变量初始化时机 1,2是根据其出现的先后顺序进行初始化的。类似于非静态变量和非静态块<br>
 *         1.定义变量的时候赋值 2.静态块中初始化
 * 
 */

/**
 * 1.为类变量分配内存空间 2.初始化属性
 */
class Price {
	final static Price INSTANCE = new Price(2.8);
	static double initPrice = 20;
	double currentPrice;

	public Price(final double discount) {
		currentPrice = initPrice - discount;
	}
}

public class InitClass03 {

	static {
		count = 3;
	}
	static int count = 2;

	public void test1() {
		System.out.println(InitClass03.count);
	}

	// 解释结果
	public void test2() {
		System.out.println(Price.INSTANCE.currentPrice);
		final Price p = new Price(2.8);
		System.out.println(p.currentPrice);
	}

	public static void main(final String[] args) {
		new InitClass03().test1();
	}

}

 4.父子类的各个属性的初始化顺序

/**
 * 
 * @author long 父子类的初始化顺序 1.初始化父类的静态属性和静态块 2.初始化子类的静态属性和静态块 3.初始化父类的非静态块
 *         4.初始化父类的构造器 5.初始化子类的非静态块 6.初始化子类的构造器
 * 
 *         初始化父类的静态属性和静态块是肯定的 比较父类的构造器和子类的静态块哪个先执行 如果先执行父类的构造器说明已经执行了子类的构造器
 *         但是静态属性和静态块在构造器之前执行 所以应该先执行子类的静态属性和静态块
 * 
 *         为甚么要先执行静态块而不是构造器 因为对象就算为空也引用静态变量 所以在构造器之前先初始化静态块和静态属性
 * 
 *         构造器可以看成三块 1.super(Obj);可以省略参数 2.非静态块 3.构造器代码
 */
// 总是先执行父类的非静态初始化块 父类的构造器
class Creature {
	static {
		System.out.println("creature静态块");
	}

	{
		System.out.println("creature 的非静态初始化块");
	}

	public Creature() {
		System.out.println("creature 的无参构造器");
	}

	public Creature(final String name) {
		System.out.println("creature 的一个有参构造器");
	}
}

class Animal extends Creature {
	static {
		System.out.println("animal 的静态初始化块");
	}
	{
		System.out.println("animal的非静态初始化块");
	}

	public Animal() {
		System.out.println("animal的无参构造器");
	}

	public Animal(final String name) {
		super(name);
		System.out.println("animal的一个有参构造器");
	}

	public Animal(final String name, final int age) {
		this(name);
		System.out.println("animal的两个有参数构造器");
	}
}

public class InitClass04 {
	public static void main(final String[] args) {
		new Animal();
	}
}