首页 > 基础教程 > 关键字 > super关键字

Java super关键字用法详解

1.普通的直接引用

与this类似，super相当于是指向当前对象的父类，这样就可以用super.xxx来引用父类的成员。

  1. public class Father {  
  2.     public String v = "Father";  
  3.     public String x = "输出了Father类的public成员变量x!!!";  
  4.     public Father() {  
  5.         System.out.println("Father构造方法被调用!");  
  6.     }  
  7.     public Father(String v) {  
  8.         this.v = "Father类的带参数构造方法!运行了.";  
  9.     }  
  10.     public void outinfo() {  
  11.         System.out.println("Father的outinfo方法被调用");  
  12.     }  
  13.   
  14.     public static void main(String[] args) {  
  15.         // TODO 自动生成方法存根  
  16.     }  
  17. }  
  18. public class Son extends Father {  
  19.     public String v = "Son";  
  20.   
  21.     public Son() {  
  22.         super(); // 调用超类的构造方法,只能放到第一行.  
  23.         System.out.println("Son无参数构造方法被调用!");  
  24.         // super(); //错误的,必须放到构造方法体的最前面.  
  25.     }  
  26.   
  27.     public Son(String str) {  
  28.         super(str);  
  29.         System.out.println("Son带参数构造方法被调用!");  
  30.     }  
  31.   
  32.     // 覆盖了超类成员方法outinfo()  
  33.     public void outinfo() {  
  34.         System.out.println("Son的outinfo()方法被调用");  
  35.     }  
  36.   
  37.     public void test() {  
  38.   
  39.         String v = "哈哈哈哈!"; // 局部变量v覆盖了成员变量v和超类变量v  
  40.   
  41.         System.out.println("------1-----");  
  42.         System.out.println(v); // 输出局部变量v  
  43.         System.out.println(this.v); // 输出(子类)成员变量v  
  44.         System.out.println(super.v); // 输出超类成员变量v  
  45.   
  46.         System.out.println("------2-----");  
  47.         System.out.println(x); // 输出超类成员变量v,子类继承而来  
  48.         System.out.println(super.x); // 输出超类成员变量v  
  49.   
  50.         System.out.println("------3-----");  
  51.         outinfo(); // 调用子类的outinfo()方法  
  52.         this.outinfo(); // 调用子类的outinfo()方法  
  53.         super.outinfo(); // 调用父类的outinfo()方法  
  54.     }  
  55.   
  56.     public static void main(String[] args) {  
  57.         new Son().test();  
  58.   
  59.     }  
  60. }  

子类Son运行结果：
Father构造方法被调用!
Son无参数构造方法被调用!
------1-----
哈哈哈哈!
Son
Father
------2-----
输出了Father类的public成员变量x!!!
输出了Father类的public成员变量x!!!
------3-----
Son的outinfo()方法被调用
Son的outinfo()方法被调用
Father的outinfo方法被调用
说明：次例子仅仅为了说明super的用法，实际在设计类的时候一般都尽可能私有(private)化。

2.子类中的成员变量或方法与父类中的成员变量或方法同名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Country {
    String name;
    void value() {
       name = "China";
    }
}
  
class City extends Country {
    String name;
    void value() {
    name = "Shanghai";
    super.value();      //调用父类的方法
    System.out.println(name);
    System.out.println(super.name);
    }
  
    public static void main(String[] args) {
       City c=new City();
       c.value();
       }
}

运行结果：

Shanghai
China

可以看到，这里既调用了父类的方法，也调用了父类的变量。若不调用父类方法value()，只调用父类变量name的话，则父类name值为默认值null。

3.引用构造函数

super（参数）：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。
this（参数）：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
class Person { 
    public static void prt(String s) { 
       System.out.println(s); 
    } 
   
    Person() { 
       prt("父类·无参数构造方法： "+"A Person."); 
    }//构造方法(1) 
    
    Person(String name) { 
       prt("父类·含一个参数的构造方法： "+"A person's name is " + name); 
    }//构造方法(2) 
} 
    
public class Chinese extends Person { 
    Chinese() { 
       super(); // 调用父类构造方法（1） 
       prt("子类·调用父类”无参数构造方法“： "+"A chinese coder."); 
    } 
    
    Chinese(String name) { 
       super(name);// 调用父类具有相同形参的构造方法（2） 
       prt("子类·调用父类”含一个参数的构造方法“： "+"his name is " + name); 
    } 
    
    Chinese(String name, int age) { 
       this(name);// 调用具有相同形参的构造方法（3） 
       prt("子类：调用子类具有相同形参的构造方法：his age is " + age); 
    } 
    
    public static void main(String[] args) { 
       Chinese cn = new Chinese(); 
       cn = new Chinese("codersai"); 
       cn = new Chinese("codersai", 18); 
    } 
}

运行结果：

父类·无参数构造方法： A Person.
子类·调用父类”无参数构造方法“： A chinese coder.
父类·含一个参数的构造方法： A person's name is codersai
子类·调用父类”含一个参数的构造方法“： his name is codersai
父类·含一个参数的构造方法： A person's name is codersai
子类·调用父类”含一个参数的构造方法“： his name is codersai
子类：调用子类具有相同形参的构造方法：his age is 18

版权声明：本文为JAVASCHOOL原创文章，未经本站允许不得转载。