super给编程带来的便利/细节

1.调用父类的构造器的好处（分工明确，父类的属性由父类初始化，子类的属性由子类初始化）

2.当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super、this、直接访问时一样的效果

3.super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类（上级类）中都有同名的成员，使用super访问遵循就近原则。A→B→C，当然也需要遵守访问权限的

package super_;

public class A extends Base {
    public int n1 = 100;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;

    public void cal(){
        System.out.println("这是A类的cal方法..");
    }
    public A() {
    }

    public A(String name) {
    }

    public A(String name, int age) {
    }

    public void test100() {
    }

    protected void test200() {
    }

    void test300() {
    }

    private void test400() {
    }

}

　　

package super_;

public class B extends A {

    public int n1 = 888;
    //编写测试方法
    public void test(){
        //super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；
        // 如果多个基类（上级类）中都有同名的成员，使用super访问遵循就近原则。A→B→C
        System.out.println("super.n1=" + super.n1);
        super.cal();
    }

    //访问父类的属性，但不能访问父类的private属性
    public void hi() {
        System.out.println(super.n1 + super.n2 + super.n3);
    }

    //访问父类的方法，不能访问父类的private方法
    public void ok() {
        super.test100();
        super.test200();
        super.test300();
        //super.test400();不能访问父类的私有方法
    }

    //访问父类的构造器，只能放在构造器的第一句，只能出现一句
    public B() {
        //super();调用父类的无参构造器
        // super("jack");调用父类的String name构造器
        super("jack", 18);//调用父类的String name int age构造器
    }

    public void cal() {
        System.out.println("这是B类的cal方法..");
    }

    public void sum() {
        System.out.println("B类的sum()");
        //希望调用父类-A的cal方法
        //这时，因为子类B没有cal方法，因此我们可以使用下面的三种方式


        //找cal方法时( cla()  和 this.cal() )，顺序是：
        // (1)先找本类，如果有，则调用
        // (2)如果没有，则找父类(如果有，并可以调用，则调用)
        // (3)如果父类没有，则继续找父类的父类，整个规则，都是一样的，直到Object类
        // 提示：如果查找方法的过程中，找到了，但是不能访问，则报错,cannot access
        //  如果查找方法的过程中，没有找到，则提示方法不存在

        //cal();
        //this.cal();//等价cal
        //super.cal();//找cal方法( super.cal() )的顺序是直接查找父类，其他的规则一样


        //演示访问属性的规则
        // n1 和this.n1 查找的规则是
        // (1)先找本类，如果有，则调用
        // (2)如果没有，则找父类(如果有，并可以调用，则调用)
        // (3)如果父类没有，则继续找父类的父类，整个规则，都是一样的，直到Object类
        // 提示：如果查找属性的过程中，找到了，但是不能访问，则报错,cannot access
        //  如果查找属性的过程中，没有找到，则提示属性不存在
        System.out.println(n1);
        System.out.println(this.n1);
        //super.n1;//找n1属性( super.n1 )的顺序是直接查找父类，其他的规则一样
        System.out.println(super.n1);

    }
}

　　

package super_;

public class Base {//父类Object

    public int n1 = 999;
    public int age = 111;

    public void eat() {
        System.out.println("Base类的eat()方法..");
    }

    public void cal() {
        System.out.println("这是Base类的cal方法..");
    }
}

　　

package super_;

public class super01 {
    public static void main(String[] args) {
        B b = new B();//子类对象
        b.sum();
        b.test();
    }
}