super 关键字

super

super是直接对父类的引用，可通过super来访问父类中被子类覆盖的方法或属性

import java.util.Objects;

public class Wang {
    public static void main(String[] args){
       new User1().f();

    }

}
class User{
    public int value=100;
    public void f(){
        System.out.println("父类value的值："+value);
    }
}
class User1 extends User{
    public int value;//若注释到这一行，则super.value值为子类value的值
    public void f(){
        super.f();//调用父类对象的普通方法
        value=200;
        System.out.println("子类value的值"+value);//200
        System.out.println(super.value);//100
    }
}

构造方法的第一句总是super()来调用父类的构造方法。

流程为先向上追溯到Object，然后在依次向下执行类的初始化块和构造方法，直到子类为止。 

import java.util.Objects;

public class Wang {
    public static void main(String[] args){
        new ChildClass();
    }
}


class FatherClass{
    super();
    public FatherClass(){
        System.out.println("父类");
    }
}
class ChildClass extends FatherClass{
    super();
    public ChildClass(){
        System.out.println("子类");
    }
}

运行结果见下 

父类

子类 

注意：

父类中有的属性，在子类中不必再次声明。否则该子类将会有一份父类属性，一份子类属性，且互不影响。

在继承中，子类对象的堆区内存里，既会有子类自身实例

变量，也会有父类继承来的实例变量。如果子类和父类有

同名的变量，堆内存会有 2 个变量。

子类不可以直接通过super.属性名和 super.方法名（）访问父类的私有属性、私有方法

但是子类可以通过get方法使用父类的私有属性

通过调用父类的公有方法调用父类的私有方法（在公有方法中调用私有方法）

package com.lanou.superTest;

public class Father {
     int a;
    private int b;
    

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }

    public Father() {
    }

    public Father(int a, int b) {
        this.a = a;
        this.b = b;
    }

    public void showInfo(){
        System.out.println("a="+a+",b="+b);
    }


    //私有方法---私有方法只能在类内部供类中别的方法调用，
    //例如在publicMethod方法中访问
    private void privateMethod(){
        System.out.println("这是私有方法");
    }

    public void publicMethod(){
        System.out.print("这是公开方法+");
        privateMethod();
    }
}

package com.lanou.superTest;

public class Son extends Father{
    private int a;
    private int c;

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getC() {
        return c;
    }

    public void setC(int c) {
        this.c = c;
    }
    public Son(){
        super();
    }

    public Son(int a, int b) {
        super(a,b);
    }

    public Son(int a, int b,  int c) {
        super(a, b);
        this.c = c;
    }

    public void showInfo(){
        System.out.println("a="+a+",b="+this.getB()+",c="+c);
    }

    //用super调用父类方法
    public void testSuperMethod(){
        super.showInfo();
    }


    //调用父类属性
    public void testSuperProperty(){
        System.out.println(a);              //0
        System.out.println(this.a);         //0
        System.out.println(super.a);        //10
        System.out.println(super.getB());   //20
    }

    public void testSuperPrivateMethod(){
        //父类的私有方法不能直接访问，但可以通过在父类中的公有方法调用私有方法，然后子类调用父类的公有方法
        //super.privateMethod();
        super.publicMethod();
    }
}

package com.lanou.superTest;

public class Test {
    public static void main(String[] args) {
        Son son=new Son(10,20,30);

        //子类和父类有同名方法，调用的是子类的方法
        son.showInfo();//a=0,b=20,c=30
        son.testSuperMethod();//a=10,b=20
        son.testSuperProperty();
        son.testSuperPrivateMethod();
        son.publicMethod();

        /*
        子类可以通过get方法使用父类的私有属性
              通过调用父类的公有方法调用父类的私有方法（在公有方法中调用私有方法）
         */
    }
}