类与对象(十八)----super关键字

super关键字

• super代表父类的引用，可以用于访问父类的属性，方法，构造器。

super使用

• 使用super访问父类的属性：权限内的才可以访问。使用语法----super.属性名

public class A {
   public int n1 = 12;
   protected int n2 = 12;
   int n3 = 12;
   private int n4 = 12;
}
class B extends A{
   public void printA(){
       System.out.println(super.n1+""+super.n2+""+super.n3);
   }
}
class Test05{
   public static void main(String[] args) {
       B b = new B();
       b.printA();
       b.n1 = 99;
       System.out.println("B的n1="+b.n1);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 使用super访问父类的方法：权限内的才可以访问。使用语法----super.方法名

public class A {
    public int n1 = 12;
    protected int n2 = 12;
    int n3 = 12;
    private int n4 = 12;
    public void printm(){
  	System.out.println(n1+""+n2+""+n3);
    }
}
class B extends A{
   public void printA(){
   	super.printm
   	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 使用super访问父类的构造器，只能写在子类的构造器第一行。使用语法----super(参数列表);

public class A {
    A(String name){
        
    }
}
class B extends A{
    B(){
        super("jac");
    }
}
1
2
3
4
5
6
7
8
9
10

super细节一：super的作用

作用一：调用父类的构造器可以使分工明确，父类的属性由父类初始化，子类的属性由子类初始化
作用二：区分子类和父类有同名属性或方法，为了访问父类的成员，只能通过super。如果没有重名那么super/this是一样的效果。
例如：

 public class A {
    public int n1 = 12;
}
class B extends A{
    public void printA(){
        System.out.println(super.n1+"");
    }
}
class Test05{
    public static void main(String[] args) {
        B b = new B();
        b.n1 = 99;
        b.printA();
        System.out.println("B的n1="+b.n1);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

这里的代码输出结果为：
99
99
这里就是因为只有父类有n1这个变量，所以在这个对象中只有一个n1，将b.n1改成99后，printA就算是使用super.n1，那么其实两个找到的n1是一个地方的。
但如果 B类子类中也有一个 n1 变量 那么b.n1默认就是从子类开始找。
例如：

 public class A {
    public int n1 = 12;
}
class B extends A{
	public int n1 = 12;
    public void printA(){
        System.out.println(super.n1+"");
    }
}
class Test05{
    public static void main(String[] args) {
        B b = new B();
        b.n1 = 99;
        b.printA();
        System.out.println("B的n1="+b.n1);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

那么这里的输出结果就是
12
99
因为，分别指向的是不同区域的n1。
当在子类或者用实例化的对象没有写任何前缀时，例如 b.n1或者this.n1.他会从子类里开始找这个变量，如果子类没有找到，就去父类找，父类没有继续往上，直到Object。找到则返回，找到但没有权限访问则报错

如果是super.属性则跳过本类，直接从父类开始找，找到就返回，找到没有权限访问就报错。

方法的访问和属性相同：
无前缀和this.方法名从子类开始找，找到即返回，找不到或找到无法访问报错。
super.方法名跳过子类，直接从父类开始找，找到即返回，找不到或找到无法访问报错。

这段代码就是因为子类没有n1，只有父类有，所以不管使用super还是this还是没前缀找到的都是父类区域中的n1，更改的也是同一个，导致两次输出都是 99

super在多个基类（上级类）有同名属性/方法时的调用原则

现有 C类继承B类继承A类，这三个类中都有一个属性叫num。
当在C类中使用super.num时，会遵循就近原则，先在B类中找，B类没有再去A类找，一旦找到且可以访问就返回。

所以根据super的查找规则，会直接在B类中找到num，返回值 55.假设B类没有再去A类找到返回99…

super和this的区别

---