5.4面向对象（构造函数的重载和初始化顺序）

1重载

构造函数的重载：

即写多个参数不一样的构造函数。构造函数的重载是为了实现构造方法的重用

规则是：参数不一样。

例：

/*person类*/
class Person{
	//这些定义的变量就是Person类的静态属性
	String name;
	String sex;
	int age;
	
	//睡觉行为就是Person类的动态属性
	public void sleep(){
		System.out.println(name+"在睡觉");
	}
	
	//第一个构造函数
	public Person(String name){	
		this.name = name;
		this.sex = "男";
		this.age = 999;
	}
	
	//第二个构造函数
	public Person(int age){	//参数不一样
		this.name = "悟空";
		this.sex = "男";
		this.age = age;
		System.out.println(age+"岁的"+name+"在大闹天宫");
	}
	
	//第三个构造函数
	public Person(int age,String name){	//参数不一样
		this.name = name;
		this.sex = "男";
		this.age = age;
	}
}

调用时：只要输入相对应的参数就会用相对应的构造方法

	public static void main(String[] args) {
		Person p = new Person("唐僧");	//调用第一个构造函数
		Person p1 = new Person(999);		//调用第二个构造函数
	
		Person p2 = new Person(999, "八戒");//调用第三个构造函数
		
		p.sleep(); 		//输出：唐僧在睡觉
		p2.sleep(); 	//输出：八戒在睡觉
	}

这里输出顺序是：

999岁的悟空在大闹天宫
唐僧在睡觉
八戒在睡觉

2初始化顺序

对象的初始化顺序是：

先初始化属性  ->  在初始化构造方法

看栗子：school类：

class School{
	//实例化一个Student，第一个
	Student s = new Student(1);		//1，输出：student 1
	
	//带参数的构造方法
	public School(int i){
		System.out.println("school "+i);	//3，输出：school 1
	}
	
	//实例化一个Student，第二个
	Student s2 = new Student(2);		//2，输出：student 2
	
}

student类：

class Student{
	//构造方法
	public Student(int i){
		System.out.println("student "+i);
	}
}

main入口：

	public static void main(String[] args) {
		School sc = new School(1);		
	}

输出结果是：

student 1
student 2
school 1

解析：1，main方法中先new了一个school对象sc，所以就会去school中

2，school中先new了一个studen对象 s，所以又会去studen中

3，该类没有属性，直接执行构造函数后，执行里面的语句，输出：student 1

4，执行完后回到school类中，本来下一句应该执行构造函数输出school 1的，为什么会先输出student 2呢，因为对象的初始化是先初始化属性的，要先把属性初始化完，才初始化构造函数，所以往下又找到了studen对象s2，又进入了student

5，该类没有属性，直接执行构造函数后，执行里面的语句，输出：student 2

6，执行完后回到了school类，现在已经找不到没初始的属性，才会执行第6行的构造函数，输出：school 1。