再学Java 基础（3）类与对象【构造函数以及其执行顺序----经典讲解】重点!!!

类 与 对 象
类与对象的概念:程序设计所面对的问题域——客观世界，是由许多事物构成的，这些事物既可以是有形的(比如一辆汽车)，也可以是无形的(比如一次会议)。把客观世界中的事物映射到面向对象的程序设计中就是对象。对象是面向对象程序设计中用来描述客观事物的程序单位。客观世界中的许多对象，无论其属性还是其行为常常有许多共同性，抽象出这些对象的共同性便可以构成类。所以，类是对象的抽象和归纳，对象是类的实例。

抽象原则
所谓抽象(abstraction)，就是从被研究对象中舍弃个别的、非本质的、或与研究主旨无关的次要特征，而抽取与研究工作有关的实质性内容加以考察，形成对所研究问题正确的、简明扼要的认识。例如，“马”就是一个抽象的概念，实际上没有任何两匹马是完全相同的，但是我们舍弃了每匹马个体之间的差异，抽取其共同的、本质性的特征，就形成了“马”这个概念。抽象是科学研究中经常使用的一种方法，是形成概念的必要手段。在计算机软件开发领域，抽象原则的运用非常广泛，概括起来，可分为过程抽象和数据抽象两类。

过程抽象
过程抽象是指：软件开发者可以把任何一个完成确定功能的操作序列都看作是一个单一的实体，尽管它实际上可能是由一系列更低级的操作完成的。运用过程抽象，软件开发者可以把一个复杂的功能分解为一些子功能(模块)，如果子功能仍比较复杂，则可以进一步分解。这使得开发者可以在不同的抽象层次上考虑问题，在较高层次上思考时可以不关心较低层次的实现细节。面向过程的程序设计采用的是过程抽象方法。使用过程抽象有利于控制、降低整个程序的复杂度，但是，这种方法允许在全系统的范围内进行功能的描述，本身自由度大，难于规范化和标准化，不易保证软件的质量，而且操作起来也有一定难度。
数据抽象:
数据抽象把系统中需要处理的数据和施加于这些数据之上的操作结合在一起，根据功能、性质、作用等因素抽象成不同的抽象数据类型。每个抽象数据类型既包含了数据，也包含了针对这些数据的授权操作，并限定数据的值只能由这些操作来观察和修改。因此，数据抽象是相对于过程抽象更为严格、更为合理的抽象方法。面向对象的程序设计就是采用数据抽象这一方法来构建程序中的类和对象的。它强调把数据和操作结合为一个不可分的系统单位——对象，对象的外部只需要知道这个对象能做什么，而不必知道它是如何做的。
对象:
只要仔细研究程序设计所面对的问题域——客观世界，我们就可以看到：客观世界是由一些具体的事物构成的，每个事物都具有自己的一组静态特征(属性)和一组动态特征(行为)。例如，一辆汽车有颜色、型号、马力、生产厂家等静态特征，又具有行驶、转弯、停车等动态特征。把客观世界的这一事实映射到面向对象的程序设计中，则把问题域中的事物抽象成了对象(Object)，事物的静态特征(属性)用一组数据来描述，事物的动态特征(行为)则用一组方法来刻画。因此，对象具有下述特征：
(1) 对象标识：即对象的名字，是用户和系统识别它的唯一标志。例如，汽车的牌照可作为每一辆汽车对象的标识。对象标识有“外部标识”和“内部标识”之分。外部标识供对象的定义者或使用者用，内部标识供系统内部唯一地识别每一个对象。在计算机世界中，我们可以把对象看成计算机存储器中一块可标识的区域，它能保存固定或可变数目的数据(或数据的集合)。
(2) 属性：即一组数据，用来描述对象的静态特征。例如，汽车的颜色、型号、马力、生产厂家等。在Java程序中，把这一组数据称为数据成员。
(3) 方法：也称为服务或操作，它是对象动态特征(行为)的描述。每一个方法确定对象的一种行为或功能。例如，汽车的行驶、转弯、停车等动作可分别用move( )、rotate( )、stop( )等方法来描述。为避免混淆，本书中把方法称为成员方法。在Java程序中，类是创建对象的模板，对象是类的实例，任
何一个对象都是隶属于某个类的。Java程序设计是从类的设计开始的，所以，在进一步讲述对象的知识之前，必须先掌握类的概念。

类
对象是对事物的抽象，而类是对对象的抽象和归纳。人类在认识客观世界时经常采用的思维方法就是把众多的事物归纳成一些类。分类所依据的原则是抽象，即抽象出与当前目标有关的本质特征，而忽略那些与当前目标无关的非本质特征，从而找出事物的共性，把具有共同性质的事物归结为一类，得出一个抽象的.

在面向对象的编程语言中，类是一个独立的程序单位，是具有相同属性和方法的一组对象的集合。类的概念使我们能对属于该类的全部对象进行统一的描述。例如，“树具有树根、树干、树枝和树叶，它能进行光合作用”。这个描述适合于所有的树，从而不必对每棵具体的树都进行一次这样的描述。因此，在定义对象之前应先定义类。描述一个类需要指明下述三个方面内容：
(1)
类标识：类的一个有别于其他类的名字，这是必不可少的。
(2)
属性说明：用来描述相同对象的静态特征。
(3)
方法说明：用来描述相同对象的动态特征。

====================================================================================

1,

JAVA构造函数特点:http://www.chinaret.com/user/topic_view.aspx?id=ea55a380-b0b8-437a-8215-9a313806bc3f

              每创建一个类的实例都去初始化它的所有变量是乏味的。如果一个对象在被创建时就完成了所有的初始工作，将是简单的和简洁的。因此，Java在类里提供了一个特殊的成员函数，叫做构造函数（Constructor）。 

             一个构造函数是对象被创建时初始对象的成员函数。它具有和它所在的类完全一样的名字。一旦定义好一个构造函数，创建对象时就会自动调用它。构造函数没有返回类型，即使是void类型也没有。这是因为一个类的构造函数的返回值的类型就是这个类本身。构造函数的任务是初始化一个对象的内部状态，所以用new操作符创建一个实例后，立刻就会得到一个清楚、可用的对象。

构造方法是一种特殊的方法，具有以下特点。 

（1）构造方法的方法名必须与类名相同。 

（2）构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。 

（3）构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的参数传给对象的域。 

（4）构造方法不能由编程人员调用，而要系统调用。 

（5）一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造器，这个构造器不执行任何代码。 

（6）构造方法可以重载，以参数的个数，类型，或排列顺序区分。

               一般地类里面都会声明一些成员变量，在生成类的实例时要为这些成员变量赋初值，构造函数在生成类的实例时自动调用，为成员变量赋初值。构造函数就是当你声明一个新的变量的时候，自动执行的函数，通常构造函数都是做一些初始化的工作。你也可以自己编写构造函数。构造函数可以有多个，通过参数列表区分，就是参数的个数，类型和顺序。当你没有为一个类写构造函数，而有用这个类声明了一个变量，系统会自动给你的类加一个构造函数，通常会继承自父类的构造函数。所有类的祖宗类是object类。

=================================构造函数的执行顺序===================================================

http://blog.csdn.net/yidinghe/article/details/3839483

     Java 在创建对象的时候会要执行它的构造函数。不仅如此，Java 还要执行父类的构造函数，往上一级一级直到没有父类为止。对于初学者来说，有三个问题不容易搞懂：

1、父类的构造函数是否一定会执行？

2、是先执行子类的构造函数还是先执行父类的构造函数？

3、如果父类有多个构造函数，那么 Java 会选择哪一个？

 

- 父类的构造函数是否一定会执行？

             是的，父类的构造函数一定会执行。所以如果某个类的层次很深，那么它创建对象时就会要执行一大堆的构造函数。

 

- 是先执行子类的构造函数还是先执行父类的构造函数？

              Java 会顺着继承结构往上一直找到 Object，然后从 Object 开始往下依次执行构造函数。先执行父类的构造函数，那么子类的构造函数执行的时候就不需要担心父类的成员是否初始化好了。

 

- 如果父类有多个构造函数，那么 Java 会选择哪一个？

               如果父类有多个构造函数，那么子类可以在构造函数中选择其中一个（且最多只能选择一个）来执行。如果子类没有选择，那么 Java 将会执行父类的缺省构造函数。下面是一个例子：

 

父类：

[java] view plaincopy

1. public class SuperClass {  
2.     public SuperClass() {  
3.         System.out.println("super class constructed.");  
4.     }  
5.     public SuperClass(String name) {  
6.         System.out.println("super class constructed with name: " + name);  
7.     }  
8. }  

 

子类：

[java] view plaincopy

1. public class SubClass extends SuperClass {  
2.     public SubClass() {  
3.         System.out.println("sub class constructed.");  
4.     }  
5.     public SubClass(String name) {  
6.         super(name);  
7.         System.out.println("sub class constructed with name: " + name);  
8.     }  
9.     public static void main(String[] args) {  
10.         new SubClass();  
11.         new SubClass("world");  
12.     }  
13. }  

  java构造方法
    重载构造方法 、默认构造方法、子类调用父类的构造方法、构造方法的作用域、构造方法的访问级别
在多数情况下，初始化一个对象的最终步骤是去调用这个对象的构造方法。
构造方法负责对象的初始化工作，为实例变量赋予合适的初始值。


构造方法必须满足以下语法规则：
(1) 方法名必须与类名相同。
(2)不要声明返回类型。
(3)不能被static、final、synchronized、abstract和native修饰。构造方法不能被子类继承，所以用final和
abstract修饰没有意义。


构造方法用于初始化一个新建的对象，所以用static修饰没有意义。多个线程不会同时创建内存地址相同的同一个对象，因此用synchronized修饰没有必要。


此外，Java语言不支持native类型的构造方法。

在以下Sample类中，具有int返回类型的Sample(int x)方法只是个普通的实例方法，不能作为构造方法：

[java] view plaincopy

1. public class Sample {  
2. private int x;  
3. public Sample() { // 不带参数的构造方法  
4. this(1);  
5. }  
6. public Sample(int x) { //带参数的构造方法  
7. this.x=x;  
8. }  
9. public int Sample(int x) { //不是构造方法  
10. return x++;  
11. }  
12. }  

以上例子尽管能编译通过，但是把实例方法和构造方法同名，不是好的编程习惯，容易引起混淆。


例如以下Mystery类的Mystery()方法有void返回类型，因此是普通的实例方法：

[java] view plaincopy

1. public class Mystery {  
2. private String s;  
3. public void Mystery() { //不是构造方法  
4. s = "constructor";  
5. }  
6. void go() {  
7. System.out.println(s);  
8. }  
9. public static void main(String[] args) {  
10. Mystery m = new Mystery();  
11. m.go();  
12. }  
13. }  

以上程序的打印结果为null。因为用new语句创建Mystery实例时，调用的是Mystery类的默认构造方法，而不是以上有void返回类型的Mystery()方法。




 重载构造方法
当通过new语句创建一个对象时，在不同的条件下，对象可能会有不同的初始化行为。


例如对于公司新进来的一个雇员，在一开始的时候，有可能他的姓名和年龄是未知的，也有可能仅仅他的姓名是已知的，也有可能姓名和年龄都是已知的。
如果姓名是未知的，就暂且把姓名设为"无名氏"，如果年龄是未知的，就暂且把年龄设为-1。
可通过重载构造方法来表达对象的多种初始化行为。


以下例程的Employee类的构造方法有三种重载形式。在一个类的多个构造方法中，可能会出现一些重复操作。


为了提高代码的可重用性，Java语言允许在一个构造方法中，用this语句来调用另一个构造方法。

例程 Employee.java

[java] view plaincopy

1. public class Employee {  
2. private String name;  
3. private int age;  
4. /** 当雇员的姓名和年龄都已知，就调用此构造方法 */  
5. public Employee(String name, int age) {  
6. this.name = name;  
7. this.age=age;  
8. }  
9. /** 当雇员的姓名已知而年龄未知，就调用此构造方法 */  
10. public Employee(String name) {  
11. this(name, -1);  
12. }  
13. /** 当雇员的姓名和年龄都未知，就调用此构造方法 */  
14. public Employee() {  
15. this( "无名氏" );  
16. }  
17. public void setName(String name){this.name=name; }  
18. public String getName(){return name; }  
19. public void setAge(int age){this.age=age;}  
20. public int getAge(){return age;}  
21. }  

以下程序分别通过三个构造方法创建了三个Employee对象：
Employee zhangsan=new Employee("张三",25);
Employee lisi=new Employee("李四");
Employee someone=new Employee();
在Employee(String name)构造方法中，this(name,-1)语句用于调用Employee(String name,int age)构造方法。
在Employee()构造方法中，this("无名氏")语句用于调用Employee(String name)构造方法。


用this语句来调用其他构造方法时，必须遵守以下语法规则：
（1）假如在一个构造方法中使用了this语句，那么它必须作为构造方法的第一条语句（不考虑注释语句）。
以下构造方法是非法的：
public Employee(){
String name="无名氏";
this(name); //编译错误，this语句必须作为第一条语句
}
（2）只能在一个构造方法中用this语句来调用类的其他构造方法，而不能在实例方法中用this语句来调用类的其他构造方法。
（3）只能用this语句来调用其他构造方法，而不能通过方法名来直接调用构造方法。




以下对构造方法的调用方式是非法的：
public Employee() {
String name= "无名氏";
Employee(name); //编译错误，不能通过方法名来直接调用构造方法
}

 默认构造方法
默认构造方法是没有参数的构造方法，可分为两种：

（1）隐含的默认构造方法

（2）程序显式定义的默认构造方法。

在Java语言中，每个类至少有一个构造方法。为了保证这一点，如果用户定义的类中没有提供任何构造方法，那么Java语言将自动提供一个隐含的默认构造方法。
该构造方法没有参数，用public 修饰，而且方法体为空，格式如下：
public ClassName(){} //隐含的默认构造方法
在程序中也可以显式的定义默认构造方法，它可以是任意的访问级别。例如：
protected Employee() { //程序显式定义的默认构造方法
this("无名氏");
}
如果类中显式定义了一个或多个构造方法，并且所有的构造方法都带参数，那么这个类就失去了默认构造方法。
在以下程序中，Sample1类有一个隐含的默认构造方法，Sample2类没有默认构造方法，Sample3类有一个显式定义的默认构造方法：

[java] view plaincopy

1. public class Sample1{}  
2. public class Sample2{  
3. public Sample2(int a){System.out.println("My Constructor");}  
4. }  
5. public class Sample3{  
6. public Sample3(){System.out.println("My Default Constructor");}  
7. }  

可以调用Sample1类的默认构造方法来创建Sample1对象：
Sample1 s=new Sample1(); //合法
Sample2类没有默认构造方法，因此以下语句会导致编译错误：
Sample2 s=new Sample2(); //编译出错
Sample3类显式定义了默认构造方法，因此以下语句是合法的。
Sample3 s=new Sample3();






子类调用父类的构造方法
（1）父类的构造方法不能被子类继承。以下MyException类继承了java.lang.Exception类：
public class MyException extends Exception{} // MyException类只有一个隐含的默认构造方法
尽管在Exception类中定义了如下形式的构造方法：
public Exception(String msg)
但MyException类不会继承以上Exception类的构造方法，因此以下代码是不合法的：
//编译出错，MyException类不存在这样的构造方法
Exception e=new MyException("Something is error");


（2）在子类的构造方法中，可以通过super语句调用父类的构造方法。例如：

[java] view plaincopy

1. public class MyException extends Exception{  
2. public MyException(){  
3. //调用Exception父类的Exception(String msg)构造方法  
4. super("Something is error");  
5. }  
6. public MyException(String msg){  
7. //调用Exception父类的Exception(String msg)构造方法  
8. super(msg);  
9. }  
10. }  

用super语句来调用父类的构造方法时，必须遵守以下语法规则。
（1）在子类的构造方法中，不能直接通过父类方法名调用父类的构造方法，而是要使用super语句。
以下代码是非法的：
public MyException(String msg){
Exception(msg); //编译错误
}
（2）使用super语句时，必须放在最前面。
以下代码是非法的：
public MyException(){
String msg= "Something wrong";
super(msg); //编译错误，super语句必须作为构造方法的第一条语句
}




在创建子类的对象时，Java虚拟机首先执行父类的构造方法，然后再执行子类的构造方法。
在多级继承的情况下，将从继承树的最上层的父类开始，依次执行各个类的构造方法，
这可以保证子类对象从所有直接或间接父类中继承的实例变量都被正确的初始化。
例如以下Base父类和Sub子类分别有一个实例变量 a和b，当构造Sub实例时，这两个实例变量都会被初始化。

[java] view plaincopy

1. public class Base{  
2. private int a;  
3. public Base(int a){ this.a=a;}  
4. public int getA(){return a;}  
5. }  
6. public class Sub extends Base{  
7. private int b;  
8. public Base(int a,int b){super(a); this.b=b;}  
9. public int getB(){return b;}  
10. public static void main(String args[]){  
11. Sub sub=new Sub(1,2);  
12. System.out.println("a="+sub.getA()+" b="+sub.getB()); //打印a=1 b=2  
13. }  
14. }  

在以下例程（Son.java）中，Son类继承Father类，Father类继承Grandpa类。这三个类都显式定义了默认的构造方法，此外还定义了一个带参数的构造方法。
例程Son.java

[java] view plaincopy

1. class Grandpa{  
2. protected Grandpa(){  
3. System.out.println("default Grandpa");  
4. }  
5. public Grandpa(String name){  
6. System.out.println(name);  
7. }  
8. }  
9. class Father extends Grandpa{  
10. protected Father(){  
11. System.out.println("default Father");  
12. }  
13. public Father(String grandpaName,String fatherName){  
14. super(grandpaName);  
15. System.out.println(fatherName);  
16. }  
17. }  
18. public class Son extends Father{  
19. public Son(){  
20. System.out.println("default Son");  
21. }  
22. public Son(String grandpaName,String fatherName,String sonName){  
23. super(grandpaName,fatherName);  
24. System.out.println(sonName);  
25. }  
26. public static void main(String args[]){  
27. Son s1= new Son("My Grandpa", "My Father", "My Son"); //①  
28. Son s2=new Son(); //②  
29. }  
30. }  

执行以上main()方法的第①条语句，打印结果如下：
My Grandpa
My Father
My Son
 
当子类的构造方法没有用super语句显式调用父类的构造方法，那么通过这个构造方法创建子类对象时，
Java虚拟机会自动先调用父类的默认构造方法。执行以上Son类的main()方法的第②条语句，打印结果如下：
default Grandpa
default Father
default Son
 
当子类的构造方法没有用super语句显式调用父类的构造方法，而父类又没有提供默认构造方法时，将会出现编译错误。
例如把例程Son.java做适当修改，删除Grandpa类中显式定义的默认构造方法：
// protected Grandpa(){
// System.out.println("default GrandPa");
// }




这样，Grandpa类就失去了默认构造方法，这时，在编译Father类的默认构造方法时，因为找不到Grandpa类的默认构造方法而编译出错。
如果把Grandpa类的默认构造方法的protected访问级别改为private访问级别，也会导致编译错误，
因为Father类的默认构造方法无法访问Grandpa类的私有默认构造方法。
在以下例子中，子类Sub的默认构造方法没有通过super语句调用父类的构造方法，
而是通过this语句调用了自身的另一个构造方法Sub(int i)，而在Sub(int i)中通过super语句调用了父类Base的Base(int i)构造方法。
这样，无论通过Sub类的哪个构造方法来创建Sub实例，都会先调用父类Base的Base(int i)构造方法。

[java] view plaincopy

1. class Base{  
2. Base(int i){System.out.println("call Base(int i)");}  
3. }  
4. public class Sub extends Base{  
5. Sub(){this(0); System.out.println("call Sub()");}  
6. Sub(int i){super(i); System.out.println("call Sub(int i)");}  
7. public static void main(String args[]){  
8. Sub sub=new Sub();  
9. }  
10. }  

执行以上Sub类的main()方法的new Sub()语句，打印结果如下：
call Base(int i)
call Sub(int i)
call Sub()
 
在下面的例子中，Base类中没有定义任何构造方法，它实际上有一个隐含的默认构造方法：
Base(){}
Sub类的Sub(int i)构造方法没有用super语句显式调用父类的构造方法，
因此当创建Sub实例时，会先调用Base父类的隐含默认构造方法。
class Base{} //具有隐含默认构造方法
public class Sub extends Base{
Sub(int i){System.out.println(i);}
public static void main(String args[]){
System.out.println(new Sub(1)); //打印1
}
}

 构造方法的作用域
构造方法只能通过以下方式被调用：
(1) 当前类的其他构造方法通过this语句调用它。
(2) 当前类的子类的构造方法通过super语句调用它。
(3)在程序中通过new语句调用它。
对于例程（Sub.java）的代码，请读者自己分析某些语句编译出错的原因。
例程 Sub.java

[java] view plaincopy

1. class Base{  
2. public Base(int i,int j){}  
3. public Base(int i){  
4. this(i,0); //合法  
5. Base(i,0); //编译出错  
6. }  
7. }  
8. class Sub extends Base{  
9. public Sub(int i,int j){  
10. super(i,0); //合法  
11. }  
12. void method1(int i,int j){  
13. this(i,j); //编译出错  
14. Sub(i,j); //编译出错  
15. }  
16. void method2(int i,int j){  
17. super(i,j); //编译出错  
18. }  
19. void method3(int i,int j){  
20. Base s=new Base(0,0); //合法  
21. s.Base(0,0); //编译出错  
22. }  
23. }  

 构造方法的访问级别
构造方法可以处于public、protected、默认和private这四种访问级别之一。本节着重介绍构造方法处于private级别的意义。
当构造方法为private级别，意味着只能在当前类中访问它：在当前类的其他构造方法中可以通过this语句调用它，此外还可以在当前类的成员方法中通过new语句调用它。
在以下场合之一，可以把类的所有构造方法都声明为private类型。

（1）在这个类中仅仅包含了一些供其他程序调用的静态方法，没有任何实例方法。其他程序无需创建该类的实例，就能访问类的静态方法。例如 java.lang.Math类就符合这种情况，在Math类中提供了一系列用于数学运算的公共静态方法，为了禁止外部程序创建Math类的实例， Math类的惟一的构造方法是private类型的：
private Math(){}
abstract类型的类也不允许实例化。也许你会问，把Math类定义为如下abstract类型，不是也能禁止Math类被实例化吗？
public abstract class Math{…}
如果一个类是抽象类，意味着它是专门用于被继承的类，可以拥有子类，而且可以创建具体子类的实例。而JDK并不希望用户创建Math类的子类，在这种情况下，把类的构造方法定义为private类型更合适。

（2）禁止这个类被继承。当一个类的所有构造方法都是private类型，假如定义了它的子类，那么子类的构造方法无法调用父类的任何构造方法，因此会导致编译错误。把一个类声明为final类型，也能禁止这个类被继承。这两者的区别是：
1)如果一个类允许其他程序用new语句构造它的实例，但不允许拥有子类，那就把类声明为final类型。
2)如果一个类既不允许其他程序用new语句构造它的实例，又不允许拥有子类，那就把类的所有构造方法声明为private类型。
由于大多数类都允许其他程序用new语句构造它的实例，因此用final修饰符来禁止类被继承的做法更常见。

（3）这个类需要把构造自身实例的细节封装起来，不允许其他程序通过new语句创建这个类的实例，这个类向其他程序提供了获得自身实例的静态方法，这种方法称为静态工厂方法。