java构造器与this,super关键字介绍

在Java与C语言的编程中，必须对创建的对象进行对象初始化，Java采用C++所引入的构造器对对象进行初始化，这是一个在创建对象时被自动调用的特殊方法。

注意：构造器的名称必须与类名完全相同

class Constructor{                                //cover from Mr.Summer
Constructor(){  //this is a constructor.
  System.out.println("Constructor");}
}

public class Text{
    public static void main(String[] args){
        for(int i=0;i<3;i++)
            new Constructor();}
}/*Output: Constructor Constructor Constructor*/

在创建对象时：

new Constructor( )；

将会为对象自动分配存储空间，并调用对应的构造器，这样就能确保在使用之前已经初始化了。

构造器有两种：

①不含任何参数的构造器，即默认构造器；

②含有参数的构造器，如下所示：

class Constructor2{
Constructor2(int i){
    System.out.println("Constructor "+i+" ");  }
}

public class Text2{
    public static void main(String[] args){
        for(int i=0;i<3;i++)
            new Constructor2(i);}
}/*Output:  Constructor 0 Constructor 1 Constructor 2*/

构造器的重载：

前面已经说明了构造器的名称必须与类名相同，如果想用多种方式创建一个对象该怎么办？假设你创建一个类，既可以用标准方式进行初始化，又可以从文件中读取所需要的信息来初始化，这就需要两个构造器：一个默认构造器，一个带变量的构造器。这就必须用到构造器的重载。

下面这个例子同时示范了重载的构造器和重载的方法：

class Tree{                                        //cover from Thinking in Java
    int height;
    Tree(){
        System.out.println("Planting a seedling");
        height = 0;}

    Tree(int i){
        height = i;
        System.out.println("Creating new Tree that is " + height + " feet tall");}

    void info(){
        System.out.println("Tree is " + height + " feet tall");}
    
    void info(String s){
        System.out.println(s+":Tree is " + height + " feet tall");}

}

public class Test{
    public static void main(String[] args){
        for(int i = 0 ; i < 3 ; i++) {
            Tree t = new Tree(i);
            t.info();
            t.info("overloaded method");}
        new Tree();
}
}/*Output
Creating new Tree that is 0 feet tall
Tree is 0 feet tall
overloaded method:Tree is 0 feet tall
Creating new Tree that is 1 feet tall
Tree is 1 feet tall
overloaded method:Tree is 1 feet tall
Creating new Tree that is 2 feet tall
Tree is 2 feet tall
overloaded method:Tree is 2 feet tall
Planting a seedling*/

创建Tree对象的时候，既可以不含参数，也可以用树的高度当参数。前者表示一颗树苗，后者表示已经有一定高度的树木。要支持这种创建方式，得有一个默认构造器和一个采用高度为参数的构造器。

重载构造器还能够通过参数进行区分，规则很简单，因为在Java中，任何重载的方法都必须有一个独一无二的参数类型列表，例如：

Tree（int，string）与Tree（string，int）是两个不同的重载构造器

this 在构造器中的用法

public class Money{
    int i = 0;
    String s = "hello";
    
Money(int i){
    System.out.println("you have "+i+" dollar.");}

Money(String ss){
    System.out.println(ss+" ,nice to meet you.");
    s = ss;}

Money(String s,int i){
    this(i);
    this.s=s;
    System.out.println("go Money(String s,int i)");}

Money(){
    this("hi" , 10);
    System.out.println("go Money( )");}

public static void main(String[] args){
    Money m = new Money();} 

}/*Output 
you have 10 dollar.
Go Money(String s, int i)
Go Money( )*/

主函数中创建一个对象，对象首先调用Money（）函数，因为Money（）函数中的this( " hi " , " 10 " )是指向Money(s , i )类型的构造器，在该构造器中又有一个指向Money（i）类型的构造器，所以先执行Money（i），再执行Money(s , i )，最后执行Money（）。

this再这里的的用法就是明确指向某个构造器，方便调用

super 在构造器中的用法

super( )函数在构造器中的调用指的是在子类中调用父类的构造器函数。this则不同，this不能用于子类调用父类的构造器，只能调用同一个类中的构造器。

class Super {
	Super(String a){
		System.out.println("参数为a的构造器");
	}
		
	Super() {
		System.out.println("empty 参数");
	}
	public static class classa extends Super{
		classa() {
		super();
		}
		classa(String a){
			super(a);
		}
	}
	
	public static void main(String[] args) {
				classa a = new classa();
				a=new classa();
				a=new classa("a");			
	}
}/*empty 参数
empty 参数
参数为a的构造器*/

可以看到在classa中调用 super( )与super(a) 两个构造器,在创建classa对象时调用classa（），classa（）又使用super（）调用父类中无参数构造器Super( )，同样的classa（"a"）则利用super（a）调用父类中的Super(String a)构造器。

初始化的顺序是先静态（static）对象，再非静态对象，只是初始化，并不执行静态函数！