目录
0 小结在先
1 super用于引用直接父类实例变量
2. 通过super 来调用父类方法
3. 使用 super 来调用父类构造函数

0 小结在先
java中的super关键字是一个引用变量，用于引用直接父类对象。

每当创建子类的实例时，父类的实例被隐式创建，由super关键字引用变量引用。

java super关键字的用法如下：

super可以用来引用直接父类的实例变量。
super可以用来调用直接父类方法。
super()可以用于调用直接父类构造函数。

1 super用于引用直接父类实例变量
可以使用super关键字来访问父类的数据成员或字段。 如果父类和子类具有相同的字段，则使用super来指定为父类数据成员或字段。
class Animal {
    String color = "white";
}

class Dog extends Animal {
    String color = "black";

    void printColor() {
        System.out.println(color);// prints color of Dog class
        System.out.println(super.color);// prints color of Animal class
    }
}

class TestSuper1 {
    public static void main(String args[]) {
        Dog d = new Dog();
        d.printColor();
    }
}

执行上面代码，输出结果如下 -
black
white

在上面的例子中，Animal和Dog都有一个共同的属性：color。 如果我们打印color属性，它将默认打印当前类的颜色。 要访问父属性，需要使用super关键字指定。
2. 通过super 来调用父类方法
uper关键字也可以用于调用父类方法。 如果子类包含与父类相同的方法，则应使用super关键字指定父类的方法。 换句话说，如果方法被覆盖就可以使用 super 关键字来指定父类方法。
class Animal {
    void eat() {
        System.out.println("eating...");
    }
}

class Dog extends Animal {
    void eat() {
        System.out.println("eating bread...");
    }

    void bark() {
        System.out.println("barking...");
    }

    void work() {
        super.eat();
        bark();
    }
}

class TestSuper2 {
    public static void main(String args[]) {
        Dog d = new Dog();
        d.work();
    }
}

执行上面代码输出结果如下
eating...
barking...

3. 使用 super 来调用父类构造函数
super关键字也可以用于调用父类构造函数。下面来看一个简单的例子：
class Animal {
    Animal() {
        System.out.println("animal is created");
    }
}

class Dog extends Animal {
    Dog() {
        super();
        System.out.println("dog is created");
    }
}

class TestSuper3 {
    public static void main(String args[]) {
        Dog d = new Dog();
    }
}


注意：如果没有使用super()或this()，则super()在每个类构造函数中由编译器自动添加。



我们知道，如果没有构造函数，编译器会自动提供默认构造函数。 但是，它还添加了super()作为第一个语句。

下面是super关键字的另一个例子，这里super()由编译器隐式提供。

class Animal {
    Animal() {
        System.out.println("animal is created");
    }
}

class Dog extends Animal {
    Dog() {
        System.out.println("dog is created");
    }
}

class TestSuper4 {
    public static void main(String args[]) {
        Dog d = new Dog();
    }
}

执行上面代码，输出结果如下 -
animal is created
dog is created

super实际使用示例

下面来看看super关键字的实际用法。 在这里，Emp类继承了Person类，所以Person的所有属性都将默认继承到Emp。 要初始化所有的属性，可使用子类的父类构造函数。 这样，我们重用了父类的构造函数。
class Person {
    int id;
    String name;

    Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

class Emp extends Person {
    float salary;

    Emp(int id, String name, float salary) {
        super(id, name);// 这里很关键！！！reusing parent constructor
        this.salary = salary;
    }

    void display() {
        System.out.println(id + " " + name + " " + salary);
    }
}

class TestSuper5 {
    public static void main(String[] args) {
        Emp e1 = new Emp(1, "ankit", 45000f);
        e1.display();
    }
}

执行上面代码，输出结果如下 -
1 ankit 45000

super 关键字与 this 类似，this 用来表示当前类的实例，super 用来表示父类。
super 可以用在子类中，通过点号(.)来获取父类的成员变量和方法。super 也可以用在子类的子类中，Java 能自动向上层类追溯。
父类行为被调用，就好象该行为是本类的行为一样，而且调用行为不必发生在父类中，它能自动向上层类追溯。
super 关键字的功能：
调用父类中声明为 private 的变量。
点取已经覆盖了的方法。
作为方法名表示父类构造方法。
调用隐藏变量和被覆盖的方法
public class Demo{
public static void main(String[] args) {
Dog obj = new Dog();
obj.move();
}
}
class Animal{
private String desc = "Animals are human's good friends";
// 必须要声明一个 getter 方法
public String getDesc() { return desc; }
public void move(){
System.out.println("Animals can move");
}
}
class Dog extends Animal{
public void move(){
super.move();  // 调用父类的方法
System.out.println("Dogs can walk and run");
// 通过 getter 方法调用父类隐藏变量
System.out.println("Please remember: " + super.getDesc());
}
}
运行结果：
Animals can move
Dogs can walk and run
Please remember: Animals are human's good friends
move() 方法也可以定义在某些祖先类中，比如父类的父类，Java 具有追溯性，会一直向上找，直到找到该方法为止。
通过 super 调用父类的隐藏变量，必须要在父类中声明 getter 方法，因为声明为 private 的数据成员对子类是不可见的。
调用父类的构造方法
在许多情况下，使用默认构造方法来对父类对象进行初始化。当然也可以使用 super 来显示调用父类的构造方法。
public class Demo{
public static void main(String[] args) {
Dog obj = new Dog("花花", 3);
obj.say();
}
}
class Animal{
String name;
public Animal(String name){
this.name = name;
}
}
class Dog extends Animal{
int age;
public Dog(String name, int age){
super(name);
this.age = age;
}
public void say(){
System.out.println("我是一只可爱的小狗，我的名字叫" + name + "，我" + age + "岁了");
}
}
运行结果：
我是一只可爱的小狗，我的名字叫花花，我3岁了
注意：无论是 super() 还是 this()，都必须放在构造方法的第一行。
值得注意的是：
在构造方法中调用另一个构造方法，调用动作必须置于最起始的位置。
不能在构造方法以外的任何方法内调用构造方法。
在一个构造方法内只能调用一个构造方法。
如果编写一个构造方法，既没有调用 super() 也没有调用 this()，编译器会自动插入一个调用到父类构造方法中，而且不带参数。
最后注意 super 与 this 的区别：super 不是一个对象的引用，不能将 super 赋值给另一个对象变量，它只是一个指示编译器调用父类方法的特殊关键字。

super 关键字
1、super是一个关键字，全部小写。
2、super和this对比着学习。
this:
this能出现在实例方法和构造方法中。
this的语法是：“this.”、“this()”
this不能使用在静态方法中。
this. 大部分情况下是可以省略的。
this.什么时候不能省略呢？ 在区分局部变量和实例变量的时候不能省略。
public void setName(String name){
this.name = name;
}
this() 只能出现在构造方法第一行，通过当前的构造方法去调用“本类”中
其它的构造方法，目的是：代码复用。
super:
super能出现在实例方法和构造方法中。
super的语法是：“super.”、“super()”
super不能使用在静态方法中。
super. 大部分情况下是可以省略的。
super.什么时候不能省略呢？ ？？？？？？？
super() 只能出现在构造方法第一行，通过当前的构造方法去调用“父类”中
的构造方法，目的是：创建子类对象的时候，先初始化父类型特征。
3、super()
表示通过子类的构造方法调用父类的构造方法。
模拟现实世界中的这种场景：要想有儿子，需要先有父亲。
4、重要的结论：
当一个构造方法第一行：
既没有this()又没有super()的话，默认会有一个super();
表示通过当前子类的构造方法调用父类的无参数构造方法。
所以必须保证父类的无参数构造方法是存在的。
5、注意：
this()和super() 不能共存，它们都是只能出现在构造方法第一行。
6、无论是怎样折腾，父类的构造方法是一定会执行的。(百分百的。)
7、作用
1、举个例子：在恰当的时间使用：super(实际参数列表);
2、注意：在构造方法执行过程中一连串调用了父类的构造方法，父类的构造方法又继续向下调用它的父类的构造方法，
但是实际上对象只创建了一个。
3、思考：“super(实参)”到底是干啥的？
super(实参)的作用是：初始化当前对象的父类型特征。并不是创建新对象。实际上对象只创建了1个。
4、super关键字代表什么呀？
super关键字代表的就是“当前对象”的那部分父类型特征。
5、什么时候不能省略super
父中有，子中又有，如果想在子中访问“父的特征”，super. 不能省略。
java是怎么来区分子类和父类的同名属性的？
this.name：当前对象的name属性
super.name：当前对象的父类型特征中的name属性。
包括 覆盖的方法
6、什么时候不能用？
//编译错误: 需要'.'
//System.out.println(super);
// this和super不能使用在static静态方法中。
super 不是引用。super也不保存内存地址，super也不指向任何对象。
super 只是代表当前对象内部的那一块父类型的特征。
ps.
super.属性名 【访问父类的属性】
super.方法名(实参) 【访问父类的方法】
super(实参)  【调用父类的构造方法】

下面分享一下我对super关键字的使用总结。
super限定对象调用从父类继承的实例变量和方法。
子类继承父类，子类获得父类的成员变量和方法。
分以下几种情况使用super关键字。
一：限定子类对象使用父类被覆盖的方法。
子类继承父类，当父类方法不适合子类使用时，子类可以重写父类的方法，遵循“两同两小一大”的原则。
代码演示：
class Father {
public void test() {
System. out.println( "父类被覆盖的方法" );
}
}
public class Son extends Father {
// 重写父类的方法
public void test() {
System. out.println( "子类覆盖父类的方法" );
}
// super限定对象使用父类被覆盖的方法
public void testOne() {
super.test();
}
public static void main(String args[]) {
Son son = new Son();
son.test();
son.testOne();
}
}
使用super限定该对象调用父类被覆盖的方法。
二：限定子类对象使用父类被被隐藏的实例变量。
当子类中有一个和父类同名的实例变量时，父类的实例变量会被隐藏，如果想调用父类的实例变量则需要使用super限定该对象使用从父类继承得到的实例变量。
代码演示：
class Father {
public int a = 10;
}
public class Son extends Father {
public int a = 100;
public void test() {
System. out.println( super. a);
}
public static void main(String args[]) {
Son son = new Son();
// 调用实例变量，调用的是子类的实例变量
System. out.println(son. a);
// 调用父类被隐藏的实例变量
son.test();
}
}
三：调用父类的构造器
子类不能继承父类的构造器，可以通过super限定调用父类的构造器，一般情况下，子类构造器默认在第一行隐式调用父类的无参构造器，如果父类包含有形参的构造器，则需要在子类构造器第一行显示调用父类的构造器。
代码演示：
class Father {
public int age;
public Father( int age){
this. age=age;
}
}
public class Son extends Father {
public String name;
public Son(int age,String name){
//限定调用父类的构造器
super(age);
this. name=name;
}
public static void main(String args[]) {
Son son = new Son(10, "王某某");
System. out.println(son. age+son. name);
}
}
创建对象时子类构造器总会调用父类构造器一次，如果不使用super，则会隐式调用父类的无参构造器，如果使用super，则会显示提调用父类的构造器，父类构造构造器也会先调用父类的父类的构造器，依次类推，最会隐式调用java.lang.object的无参构造器，所以父类的构造器总比子类的构造器先执行(子类构造器不显示调用父类构造器，就会有一个隐式super调用父类的无参构造器)。
当通过this显示调用重载的构造器时，会先执行被重载的构造器。
代码演示：
class Father {
public Father() {
System.out.println("第一个被执行构造器");
}
}
class Son extends Father {
public int age;
public String name;
public Son(int age) {
System.out.println("第二个被执行的构造器");
}
public Son(int age, String name) {
this(age);
this.name = name;
System.out.println("第三个被执行的构造器");
}
}
public class Grandson extends Son {
public Grandson(int age, String name) {
super(age, name);
System.out.println("最后一个被执行的构造器");
}
public static void main(String args[]) {
Grandson w = new Grandson(10, "wang");
}
}
上面演示了super使用的三种情况，不足之处请大家指出，谢谢