super

super

1、一个类当中，有变量，常量，方法，构造器，代码块（静态代码块等等）等，如果，此时，该类的子类来继承于该类

那么，除了构造器以外，其他的都可以被子类继承

但是，创建子类对象时候，却是要先执行，父类的构造器

与此同时，如果父类真的存在静态代码块等，那么也是会先执行父类的静态代码块的，也就是说，虽然创建的是子类的对象，但是程序执行的时候，会先从最原始的父类的类开始执行，具体可见：初始化块

2、重写与覆盖前提：发生在有继承关系的类上面

重写：

子类可以使用父类的成员变量和成员方法，当子类重新定义了和父类同名的方法，此时，

子类方法的功能会覆盖父类同名方法的功能

覆盖：

子类的成员变量与父类的成员变量同名时候，在子类当中隐藏父类同名的变量的值

覆盖是不是发生在方法身上，隐藏发生在成员变量身上

 

---

 

3、子类隐藏了超类的成员变量或者是覆盖了超类方法后，如果子类想引用超类的成员变量和被覆盖的方法，是不是可以使用super与this（this还能作为调用父类的父类当中的方法）

当方法的局部变量与成员变量同名时候，局部变量会覆盖成员变量，这时候想用成员变量就可以使用this

4、由于子类可以覆盖父类的实例方法、隐藏父类的类方法、隐藏父类的字段等,但是我们有时候需要引用到父类的一些方法,这时候需要借助关键字super.

5、B 继承 A ，B想调用A的方法，那么就可以 用super.A的方法。如果用中文解释：super就是父类的一个别名

super()行为就是使用父类的函数，与super类似的是，this()行为就是使用自己的

6、子类是不继承父类的构造器.因此,如果要初始化父类中的字段,

可以在子类的构造器中,通过关键字super调用父类的构造器，对父类的构造器的调用必须放在子类的构造器的第一行

 

---

 

super一般有三种使用情况：

 
1、使用super调用超类的构造方法（具体可见继承后，先调用父类的构造）

这个就不得不提到：

构造器链：

如果一个子类的构造器显式或隐式地调用其父类的一个构造器,而其父类会再显式或隐式地调用父类的父类的构造器，

形成一个完整的构造器链

 

class Book {
    private String ISBN;
    Book(String isbn){
			this.ISBN = isbn;
    }
    public String getISBN(){
			return this.ISBN;
    }
    public boolean equals(Object obj) {
        if (obj instanceof Book)
            return ISBN.equals(((Book)obj).getISBN()); 
        else
            return false;
    }
}
 
public class ExtendsDemo11{
    public static void main(String[] args) {
		Book firstBook  = new Book("0201914670"); 
		Book secondBook = new Book("0201914670");
		if (firstBook.equals(secondBook)) {
    			System.out.println("两个对象相等.");
		} else {
    			System.out.println("两个对象不相等.");
		}
    }
}

 

 

2、super调用超类被子类覆盖的方法

super.方法名()；直接访问并调用父类中的方法

super(); 调用父类的初始化方法，其实就是调用父类中的public xxx()方法
特殊情况：如果父类没有无参的构造函数，所以子类需要在自己的构造函数中显示的调用父类的构造函数，即不能使用系统默认的“super()”，而需要显性写出super(xxx)

 
 
3、super访问超类被子类隐藏的成员变量

super.变量/对象名；使用这种方法可以直接访问父类中的变量或对象，进行修改赋值等操作

 

public class A {
    int x;
    A(int inf){
        x = inf;
    }
    void method(){
        System.out.println("A类当中的方法，值是"+x);
    }
    int getX(){
        return x;
    }
}

class B extends A{
    double x; //子类与父类存在相同的属性名
    B(int a,double b){
        super(a); //调用A类的构造方法
        x = b;
    }

    @Override
    void method() {
        System.out.println("B类当中的方法，值是"+x);
    }


//    public static void main(String[] args) {
//        //正常各自创建各自的对象
//        A a = new A(2);
//        a.method(); //2
//        System.out.println(a.x);//2
//        System.out.println("___________________________");
//        B b = new B(1,2.3);
//        b.method();//2.3
//        System.out.println(b.x);//2.3
//    }
}


class C extends B{
    char x;
    C(int a,double b,char c){
        super(a,b);
        x = c;
    }

    @Override
    void method() {
        char ch = x;          //这里的x是C类当中定义的x
        double db = super.x;  //引用父类的成员变量，类B的x
        int ia = this.getX(); //不能用A.x  或者是super.super.x 通过当前对象this访问
        /**
         * 访问超类被子类隐藏的成员变量: super.变量/对象名
         * 访问超类被子类隐藏的成员方法: super.方法名()
         * 访问父类的父类的方法：this.方法名
         */
        super.method();
        System.out.println("C类当中的方法，值是"+x);
        System.out.println("ch="+ch+" db="+db+" ia="+ia);
    }

    public static void main(String[] args) {
        C c = new C(4,7.0,'中');
        c.method();
    }
}

 

/**
 * 访问超类被子类隐藏的成员变量: super.变量/对象名
 * 访问超类被子类隐藏的成员方法: super.方法名()
 * 访问父类的父类的方法：this.方法名
 */