面向对象--继承--继承中构造方法的关系

继承中构造方法的关系

要想初始化子类，就必须初始化父类，而初始化调用的是构造方法

子类中所有的构造方法默认都会访问父类中空参数的构造方法，

因为子类中所有的构造方法的第一条语句都会默认含有一个访问父类的无参构造方法的super()

要想初始化子类，就必须初始化父类，为什么呢?

因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。 

当父类没有提供无参构造方法的时候，如何解决？

• 父类提供一个无参构造方法
• 在子类的构造方法中第一句话上使用super访问父类中其他的构造方法，完成父类的初始化
• 在无参构造方法中使用this关键字调用自身的其他含有super（...）的构造方法

注意事项：

• 对构造方法的调用必须是构造器中的第一个语句
• 同一个类只能被初始化一次

程序示例：

• 要想初始化子类，就必须初始化父类

/*
       要想初始化子类，就必须初始化父类，而初始化调用的是构造方法
       
       子类中所有的构造方法中都会默认含有一个访问父类的无参构造方法的super()
*/

class Father {

    Father(){
        System.out.println("这是父类的无参构造方法");
    }

    Father(String s){
        System.out.println("这是父类的带参构造方法 ---"+ s);
    }
}

class Son extends Father {

    Son(){
      //JVM会默认在调用子类构造方法的时候，这里会有一个访问父类无参构造方法的super()
      
        super() //如果不单独写出super()，JVM会默认有super() 
         
        System.out.println("这是子类中无参构造方法"); 
    }

    Son(String s){
      
      //当然你也可以将父类无参构造方法的super()，修改成为有参的构造方法
      
        super("hello");
      
        System.out.println("这是子类中带参数的构造方法---"+s); 
    }
}

public class ExtendsDemo2 {
  
    public static void main(String[] args) {
      //调用Son的无参构造方法创建Son的对象s
        Son s = new Son();
    }
}
/*
输出结果为：

这是父类的无参构造方法➡这是子类中无参构造方法

*/

• 当父类没有提供无参构造方法的时候，如何解决？

/*
  当父类没有提供无参构造方法的时候，如何解决？
      1、父类提供一个无参构造方法
      2、在子类的构造方法中第一句话上使用super访问父类中其他的构造方法，完成父类的初始化
         3、在无参构造方法中使用this关键字调用自身的其他含有super（...）的构造方法
*/

//--------------------父类提供一个无参构造方法--------------------

class Father {
  
  //自己提供的父类无参构造方法
    Father(){
        System.out.println("这是父类的无参构造方法");
    }

    Father(String s){
        System.out.println("这是父类的带参构造方法 ---"+ s);
    }
}

class Son extends Father {
  
    Son(){
        System.out.println("这是子类中无参构造方法");
    }

    Son(String s){
        System.out.println("这是子类中带参数的构造方法---"+s);
    }
}

public class ExtendsDemo2 {
    public static void main(String[] args) {
      
        Son s = new Son();
    }
}


//--------------------在子类的构造方法中第一句话上使用super访问父类中其他的构造方法，完成父类的初始化--------------------

class Father {
  
    //父类中没有提供无参构造方法
//    Father(){
//        System.out.println("这是父类的无参构造方法");
//    }

    Father(String s){
        System.out.println("这是父类的带参构造方法 ---"+ s);
    }
}

class Son extends Father {

    Son(){
//在子类的构造方法中第一句话上使用super访问父类中其他的构造方法，完成父类的初始化
        super("hello");
        System.out.println("这是子类中无参构造方法");
    }

    Son(String s){
        super("hello");
        System.out.println("这是子类中带参数的构造方法---"+s);
    }
}

public class ExtendsDemo2 {
    public static void main(String[] args) {
      
        Son s = new Son();
    }
}
/*
执行顺序：
这是父类的带参构造方法 ---hello ➡ 这是子类中无参构造方法
*/


//--------------------在无参构造方法中使用this关键字调用自身的其他含有super（...）的构造方法--------------------

class Father {
  
    //父类中没有提供无参构造方法
//    Father(){
//        System.out.println("这是父类的无参构造方法");
//    }

    Father(String s){
        System.out.println("这是父类的带参构造方法 ---"+ s);
    }
}

class Son extends Father {
  
//只在某一个构造方法中加了super，其他构造方法中不加super
    Son(){
//在无参构造方法中使用this关键字调用自身的其他含有super（...）的构造方法      
            this("world");
        System.out.println("这是子类中无参构造方法");
    }

    Son(String s){
        super("hello");
        System.out.println("这是子类中带参数的构造方法---"+s);
    }
}

public class ExtendsDemo2 {
    public static void main(String[] args) {
      
        Son s = new Son();
    }
}
/*
执行顺序：
这是父类的带参构造方法 ---hello ➡ 这是子类中带参数的构造方法---world ➡ 这是子类中无参构造方法
*/

• 注意事项：

/*
注意事项：
    1、对构造方法的调用必须是构造器中的第一个语句
    2、同一个类只能被初始化一次
*/

//--------------------对构造方法的调用必须是构造器中的第一个语句--------------------

class Father {

//    Father(){
//        System.out.println("这是父类的无参构造方法");
//    }

    Father(String s){
        System.out.println("这是父类的带参构造方法 ---"+ s);
    }
}

class Son extends Father {

    Son(){
//在无参构造方法中使用this关键字调用自身的其他含有super（...）的构造方法      
            this("world");
        System.out.println("这是子类中无参构造方法");     
        //如果在调用this("world")之后再来一个
        //  super("a");
        //这时候会报错：对构造方法的调用必须是构造器中的第一个语句      
    }

    Son(String s){
        super("hello");
        System.out.println("这是子类中带参数的构造方法---"+s);
    }
}

public class ExtendsDemo2 {
    public static void main(String[] args) {
      
        Son s = new Son();
    }
}


//--------------------同一个类只能被初始化一次--------------------

class Father {

//    Father(){
//        System.out.println("这是父类的无参构造方法");
//    }

    Father(String s){
        System.out.println("这是父类的带参构造方法 ---"+ s);
    }
}

class Son extends Father {

    Son(){
         //如果我在this("world")之前加上super("a")
         //这个时候还会报错因为执行完super("a")后执行this("world")
         //而在this("world")调用的Son的有参构造方法里面第一句也有super("hello");
         //同一个类只能被初始化一次，所以报错。
            super("a");
         // this("world"); //调用的是Son的有参构造方法
        System.out.println("这是子类中无参构造方法");          
    }

    Son(String s){
        super("hello"); // 而Son的有参构造方法中的第一句是父类的有参构造方法
        System.out.println("这是子类中带参数的构造方法---"+s);
    }
}

public class ExtendsDemo2 {
    public static void main(String[] args) {
      
        Son s = new Son();
    }
}