java面向对象05：super详解

super

1. 什么是super

由于子类不能继承父类的构造方法，因此，如果要调用父类的构造方法，可以使用 super 关键字。super 可以用来访问父类的构造方法、普通方法和属性。

2. super的使用实例

• super调用父类属性

//父类
public class Person {
   private int money=10000;
   public int age;
   public int weight=100;
 
}
//子类

public class Student extends Person {
    public int weight=90;
  }
  public void a(int weight){
      System.out.println(weight);
      //这里输出80是值传递，传给weight这个形式参数
       System.out.println(this.weight);
       //这里输出90，是输出本类的属性weight
        System.out.println(super.weight);
        //这里输出100，是输出父类的属性weight
        //System.out.println(super.age);这样会报错因为super不调用父类的私有属性
  }
    
}
//测试类
public class Test {
    public static void main(String[] args) {
    Student student = new Student();
      student.a(80);
      //发现输出
      //80
      //90
      //100  
    }
}

• super调用父类方法

//父类
public class Person {
      public void talk(){
         System.out.println("person");
  }
 
}
//子类

public class Student extends Person {
   
     public void talk(){
         System.out.println("student");
  }
  public void a(){
     talk();
     //这里调用本类的talk方法
     this.talk();
     //这里也是调用本类的talk方法
     super.talk();
     //这里调用的是父类的talk方法
  }
    
}
//测试类
public class Test {
    public static void main(String[] args) {
    Student student = new Student();
      student.a();
      //发现输出
     // student
     // student
     // person
   
    }

• super调用父类的构造方法

注意点是：

1. super();这个调用父类的无参构造语句如果显示定义出来必须放在方法体的最前面.
2. 如果一个类中没有写任何的构造方法，JVM 会生成一个默认的无参构造方法。在继承关系中，由于在子类的构造方法中，第一条语句默认为调用父类的无参构造方法（即默认为 super()，一般这行代码省略了）。所以当在父类中定义了有参构造方法，但是没有定义无参构造方法时，编译器会强制要求我们定义一个相同参数类型的构造方法。
3. 我们不能同时调用父类的构造器又去调用子类的构造器，列如如果我在super();语句下写this(10);去调用本类的有参构造，就会发现编译器报错提醒我们这个this(10);必须放在语句的第一行，但是super();也必须放在第一行，所以我们只能调用一个构造方法（当我们只写了this()时，隐式的super就会被注销了，也不能写两个super语句即不能调用父类的无参构造又调用父类的有参构造）
4. 当父类只写了有参构造时子类如果定义了无参构造就必须在子类的无参构造中调用父类的有参构造，因为当父类写了有参构造时，隐式的无参构造就会被注销，我们如果不去在子类中调用父类的有参构造，子类的无参构造中就会隐式的去调用父类的无参，此时就会报错，所以我们一般写了有参就会在有参前定义一个无参构造

//父类
public class Person {
      public person(){
         System.out.println("person无参执行");
     }
  }
 
}
//子类

public class Student extends Person {
   
     public student(){
        super();//这个super是隐式的看不见的
        System.out.println("student无参执行");
        //我们发现会先输出person无参执行再输出student无参执行
        //这说明，在输出student无参执行语句之前还有一个隐式的语句
        //去调用父类的无参构造
     }
      public student(int age){
        this.age=age;
     }
    
}
//测试类
public class Test {
    public static void main(String[] args) {
    //我们在这里直接执行发现输出了无参构造中的内容
    //因为当我调用一个对象的时候会先走无参构造器，平常是隐式的所以看不见
    Student student = new Student();
   //输出发现
   //person无参执行
   //student无参执行
    }