构造代码块的执行顺序

1.编译器会把构造代码块插入到每一个构造函数中，如果构造函数中使用了this关键字调用其他构造函数，则该构造函数中就不会插入构造代码块，以免构造代码块被重复执行。

举例说明

public class Student {
	/**
	 * 
	 */
	private static final long serialVersionUID = 2205426314406978220L;

	/**
	 * 姓名
	 */
	private String name;

	/**
	 * 年龄
	 */
	private int age;

	{
		// 构造代码块
		System.out.println("我是构造代码块");
		this.name = "无名氏";
		this.age = 100;
	}

	/**
	 * 
	 */
	public Student() {
		System.out.println("我是无参构造函数：Student()");
	}

	public Student(String name, int age) {
		this();
		if (name != null && !name.trim().equals("")) {
			this.name = name;
		}
		if (age > 0) {
			this.age = age;
		}
		System.out.println("我是有参构造函数：Student(String name, int age)");
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "[name:" + this.name + " age:" + this.age + "]";
	}

	/**
	 * @see java.lang.Comparable#compareTo(java.lang.Object)
	 */
	public int compareTo(Student o) {
		if (this == o) {
			return 0;
		}
		if (o == null) {
			return 1;
		}
		return this.age - o.getAge();
	}

	public static Pair<Student> minmax(List<Student> list) {
		if (list == null || list.size() == 0) {
			return null;
		}
		Student min = list.get(0);
		Student max = list.get(0);
		for (Student p : list) {
			if (min.compareTo(p) > 0) {
				min = p;
			}
			if (max.compareTo(p) < 0) {
				max = p;
			}
		}

		return new Pair<Student>(min, max);
	}
}

测试类

public class Test {
	public static void main(String[] args) throws IOException {
		Student student = new Student();
		System.out.println("student:" + student.toString());
		System.out.println("------分割线------");
		Student student2 = new Student("李雷", 20);
		System.out.println("student2:" + student2.toString());
	}
}

执行结果如下：
我是构造代码块
我是无参构造函数：Student()
student:[name:无名氏 age:100]
------分割线------
我是构造代码块
我是无参构造函数：Student()
我是有参构造函数：Student(String name, int age)
student2:[name:李雷 age:20]

黑体字部分的构造代码块只打印了一次，且在无参构造函数之前，说明有参构造函数没有再次调用构造代码块。


2.子类的构造函数中调用父类的构造函数(调用super方法)，并不影响子类构造代码块的执行。编译器会将子类构造代码块插入到super方法之后执行。

举例说明

public class StudentLeader extends Student {

	/**
	 * 
	 */
	private static final long serialVersionUID = -4052233131592706287L;

	{
		System.out.println("我是学生领袖构造代码块");
	}

	/**
	 * 
	 */
	public StudentLeader() {
		super();
	}
}

测试类代码

public class Test {
	public static void main(String[] args) throws IOException {
		StudentLeader leader = new StudentLeader();
	}
}

执行结果如下：
我是构造代码块
我是无参构造函数：Student()
我是学生领袖构造代码块

可以看出，StudentLeader类的构造代码块在Student无参构造函数执行之后才执行。