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

阳光穿透心脏的1/2处 2022-05-27 07:09 146阅读 0赞

在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）对象，再非静态对象，只是初始化，并不执行静态函数！