Java中的 super和this

super关键字

在子类中用于表示父类对象的引用，可以在子类中调用父类中的方法的属性。

super语句 --- 子类在继承父类之后，子类的构造方法中会含有一个super语句。

如果没有手动指定super语句，那么默认使用super()调用父类无参的构造；

如果父类只提供了含参构造，那么子类就必须手动提供对应形式的super语句

注意： super语句必须在子类构造方法的首行

super的使用

super 可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。

super 也有三种用法：

1.普通的直接引用

与 this 类似，super 相当于是指向当前对象的父类，这样就可以用 super.xxx 来引用父类的成员。

2.子类中的成员变量或方法与父类中的成员变量或方法同名

class Country {
    String name;
    void value() {
       name = "China";
    }
}
  
class City extends Country {
    String name;
    void value() {
    name = "Shanghai";
    super.value();      //调用父类的方法
    System.out.println(name);
    System.out.println(super.name);
    }
  
    public static void main(String[] args) {
       City c=new City();
       c.value();
       }
}

运行结果：

Shanghai
China

可以看到，这里既调用了父类的方法，也调用了父类的变量。若不调用父类方法 value()，只调用父类变量 name 的话，则父类 name 值为默认值 null。

实例：

Animal.class

class Animal {//父类
    public int age = 11;
    
    public Animal() {
        System.out.println("父类构造函数！");
    }
    
    public void eat() {
        System.out.println("动物需要吃东西~~");
    }

}

Dog.class

public class Dog extends Animal{ // 子类
    int age = 20;
    
    public Dog() {
        System.out.println("子类构造方法！");
    }
    
    public void eat() {
        System.out.println("狗需要吃东西~~");
    }
    
    public void method() {
        super.eat(); //调用父类的eat方法
        System.out.println(super.age);//获得父类的age属性
        System.out.println(age); //获得子类的age属性
        
    }
}

Intail.class

public class Intail {
    public static void main(String[] args) {
        Dog d = new Dog(); //实例化
        d.eat(); // 调用子类的构造方法
        d.method();
        
    }
}

运行结果：

父类构造函数！
子类构造方法！
狗需要吃东西~~
动物需要吃东西~~
11
20

我们发现父类的构造方法在实例化子类的构造方法的时候进行了实例化，为什么呢？

那是因为在子类的构造函数中隐式的调用了父类的无参构造方法；

但是如果子子类里只有一个有参的构造方法，那么需要自己写super(参数，参数)，以此来调用父类的构造方法。

3.引用构造函数

super(参数)：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。
this(参数)：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）

class Person { 
    public static void prt(String s) { 
       System.out.println(s); 
    } 
   
    Person() { 
       prt("父类·无参数构造方法： "+"A Person."); 
    }//构造方法(1) 
    
    Person(String name) { 
       prt("父类·含一个参数的构造方法： "+"A person's name is " + name); 
    }//构造方法(2) 
} 
    
public class Chinese extends Person { 
    Chinese() { 
       super(); // 调用父类构造方法（1） 
       prt("子类·调用父类无参数构造方法： "+"A chinese coder."); 
    } 
    
    Chinese(String name) { 
       super(name);// 调用父类具有相同形参的构造方法（2） 
       prt("子类·调用父类含一个参数的构造方法： "+"his name is " + name); 
    } 
    
    Chinese(String name, int age) { 
       this(name);// 调用具有相同形参的构造方法（3） 
       prt("子类：调用子类具有相同形参的构造方法：his age is " + age); 
    } 
    
    public static void main(String[] args) { 
       Chinese cn = new Chinese(); 
       cn = new Chinese("cjj"); 
       cn = new Chinese("cjj", 22); 
    } 
}

运行结果：

父类·无参数构造方法： A Person.
子类·调用父类无参数构造方法： A chinese coder.

父类·含一个参数的构造方法： A person's name is cjj
子类·调用父类含一个参数的构造方法： his name is cjj

父类·含一个参数的构造方法： A person's name is cjj
子类·调用父类含一个参数的构造方法： his name is cjj
子类：调用子类具有相同形参的构造方法：his age is 22

super 和 this的异同

super(参数)：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）
this(参数)：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）
super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参） this：它代表当前对象名（在程序中易产生二义性之处，应使用 this 来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用 this 来指明成员变量名）
调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用 super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
super() 和 this() 类似,区别是，super() 从子类中调用父类的构造方法，this() 在同一类内调用其它方法。
super() 和 this() 均需放在构造方法内第一行。
尽管可以用this调用一个构造器，但却不能调用两个。
this 和 super 不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有 super 语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
this() 和 super() 都指的是对象，所以，均不可以在 static 环境中使用。包括：static 变量,static 方法，static 语句块。
从本质上讲，this 是一个指向本对象的指针, 然而 super 是一个 Java 关键字。