ava super的定義

本章節目標：

掌握super都可以用在哪裡？理解super在記憶體方面的儲存位置。掌握怎麼通過子類的構造方法呼叫父類的構造方法。super什麼時候可以省略，什麼時候不能省略

知識框架：

​

super和this可以對比著學習：

this

● this是一個引用，儲存記憶體地址指向自己。

● this出現在例項方法中，誰呼叫這個例項方法，this就代表誰，this代表當前正在執行這個動作的物件。

● this不能出現在靜態方法中。

● this大部分情況下可以省略，在方法中區分例項變數和區域性變數的時候不能省略。

●“this(實際引數列表)”出現在構造方法第一行，通過當前的構造方法去呼叫本類當中其它的構造方法。

super

嚴格來說，super其實並不是一個引用，它只是一個關鍵字，super代表了當前物件中從父類繼承過來的那部分特徵。this指向一個獨立的物件，super並不是指向某個“獨立”的物件，假設張大明是父親，張小明是兒子，有這樣一句話：大家都說張小明的眼睛、鼻子和父親的很像。那麼也就是說兒子繼承了父親的眼睛和鼻子特徵，那麼眼睛和鼻子肯定最終還是長在兒子的身上。假設this指向張小明，那麼super就代表張小明身上的眼睛和鼻子。換句話說super其實是this的一部分。如下圖所示：張大明和張小明其實是兩個獨立的物件，兩個物件記憶體方面沒有聯絡，super只是代表張小明物件身上的眼睛和鼻子，因為這個是從父類中繼承過來的，在記憶體方面使用了super關鍵字進行了標記，對於下圖來說“this.眼睛”和“super.眼睛”都是訪問的同一塊記憶體空間。

​

圖14-1：super記憶體圖

● super和this都可以使用在例項方法當中。

● super不能使用在靜態方法當中，因為super代表了當前物件上的父型別特徵，靜態方法中沒有this，肯定也是不能使用super的。

● super也有這種用法：“super(實際引數列表);”，這種用法是通過當前的構造方法呼叫父類的構造方法。

接下來，我們來測試一下：

1. public class SuperTest01 extends Object{

2. //例項方法

3. public void doSome(){

4. System.out.println(this);

5. System.out.println(super);

6. }

7. }

編譯報錯了：

​

圖14-2：this可以單獨輸出，super不能

通過以上的測試，可以看出this是可以單獨使用的引用，但super無法輸出，編譯器提示super要使用必須是“super.xxx”，顯然super並不指向獨立的物件，並不是儲存某個物件的記憶體地址。

再來看另外的一個測試：

1. public class SuperTest02 extends Object{

2. //靜態方法

3. public static void doSome(){

4. System.out.println(this);

5. System.out.println(super.toString());

6. }

7. }

編譯報錯了：

​

圖14-3：this和super都不能使用在靜態方法中

通過以上的測試，可以看出this和super都是無法使用在靜態方法當中的。

Java中super關鍵字的使用（在構造方法中）

super使用在構造方法中，語法格式為：super(實際引數列表)，這行程式碼和“this(實際引數列表)”都是隻允許出現在構造方法第一行（這一點記住就行了），所以這兩行程式碼是無法共存的。“super(實際引數列表)”這種語法表示子類構造方法執行過程中呼叫父類的構造方法。我們來看一段程式碼：

1. public class People {

2. String idCard;

3. String name;

4. boolean sex;

5. public People(){

6. }

7. public People(String idCard,String name,boolean sex){

8. this.idCard = idCard;

9. this.name = name;

10. this.sex = sex;

11. }

12. }

​​

1. public class Student extends People{

2. //學號是子類特有的

3. int sno;

4. public Student(){

6. }

7. public Student(String idCard,String name,boolean sex,int sno){

8. this.idCard = idCard;

9. this.name = name;

10. this.sex = sex;

11. this.sno = sno;

12. }

13. }

​​

1. public class StudentTest {

2. public static void main(String[] args) {

3. Student s = new Student("12345x","jack",true,100);

4. System.out.println("身份證號" + s.idCard);

5. System.out.println("姓名" + s.name);

6. System.out.println("性別" + s.sex);

7. System.out.println("學號" + s.sno);

8. }

9. }

​​

執行結果如下圖所示：

​

圖14-4：執行結果

我們把上面的程式碼片段拿過來放在一起看看：

父類的構造方法：

1. public People(String idCard,String name,boolean sex){

2. this.idCard = idCard;

3. this.name = name;

4. this.sex = sex;

5. }

​​

子類的構造方法：

1. public Student(String idCard,String name,boolean sex,int sno){

2. this.idCard = idCard;

3. this.name = name;

4. this.sex = sex;

5. this.sno = sno;

​​

你有沒有察覺到子類的構造方法前三行程式碼和父類構造方法中的程式碼是一樣的？接下來把子類的構造方法修改一下，然後再執行測試程式：

1. public Student(String idCard,String name,boolean sex,int sno){

2. super(idCard,name,sex);

3. this.sno = sno;

4. }

​​

執行結果如下圖所示：

​

圖14-5：執行結果

通過以上程式碼的學習，“super(實際引數列表);”語法表示呼叫父類的構造方法，程式碼複用性增強了，另外一方面也是模擬現實世界當中的“要想有兒子，必須先有父親”的道理。不過這裡的“super(實際引數列表)”在呼叫父類構造方法的時候，從本質上來說並不是建立一個“獨立的父類物件”，而是為了完成當前物件的父型別特徵的初始化操作。（或者說通過子類的構造方法呼叫父類的構造方法，是為了讓張小明身上長出具有他父親特點的鼻子和眼睛，鼻子和眼睛初始化完畢之後，具有父親的特點，但最終還是長在張小明的身上）。

接下來，再來看一段程式碼：

1. public class A {

2. public A(){

3. System.out.println("A類的無引數構造方法執行");

4. }

5. }

​

1. public class B extends A {

2. public B(){

3. System.out.println("B類的無引數構造方法執行");

4. }

5. }

​​

1. public class C extends B {

2. public C(){

3. System.out.println("C類的無引數構造方法執行");

4. }

5. }

​​

1. public class Test {

2. public static void main(String[] args) {

3. new C();

4. }

5. }

​​

執行結果如下圖所示：

​

圖14-6：super()的測試

通過以上執行結果可以得出以下的等效程式碼：

1. public class A {

2. public A(){

3. //這裡呼叫的是Object類中的無引數構造方法

4. //因為A類的父類是Object

5. super();

6. System.out.println("A類的無引數構造方法執行");

7. }

8. }

​

1. public class B extends A {

2. public B(){

3. super();

4. System.out.println("B類的無引數構造方法執行");

5. }

6. }

​​

1. public class C extends B {

2. public C(){

3. super();

4. System.out.println("C類的無引數構造方法執行");

5. }

6. }

​​

執行結果如下圖所示：

​

圖14-7：super()的測試

通過以上程式碼的測試我們得出，當一個構造方法第一行沒有顯示的呼叫“super(實際引數列表)”的話，系統預設呼叫父類的無引數構造方法“super()”。當然前提是“this(實際引數列表)”也沒有顯示的去呼叫（因為super()和this()都只能出現在構造方法第一行，所以不能並存）。我們可以通過以下程式再次測試一下：

1. public class A {

2. //有引數構造方法定義之後

3. //系統則不再提供無引數構造方法

4. public A(String s){

5. }

6. }

​​

1. public class B extends A {

2. public B(){

3. }

4. }

​​

編譯報錯了：

​

圖14-8：編譯報錯資訊

以上程式為什麼會編譯報錯呢？原因是B類的構造方法第一行預設會呼叫“super()”，而super()會呼叫父類A的無引數構造方法，但由於父類A中提供了有引數構造方法，導致無引數構造方法不存在，從而編譯報錯了。所以在實際開發中還是建議程式設計師將無引數構造方法顯示的定義出來，這樣就可以避免物件的建立失敗了。

另外，通過以上內容的學習，還可以得出這樣的結論：在java語言當中無論是建立哪個java物件，老祖宗Object類中的無引數構造方法是必然執行的。

接下來我們再來看一下：一個java物件在建立過程中比較完整的記憶體圖是如何變化的，請先看以下程式碼：

1. public class People {

2. String name;

3. boolean sex;

4. public People(String name,boolean sex){

5. this.name = name;

6. this.sex = sex;

7. }

8. }

​​

1. public class Worker extends People {

2. //子類特有的工資屬性

3. double salary;

4. public Worker(String name,boolean sex,double salary){

5. super(name,sex);

6. this.salary = salary;

7. }

8. }

​​

1. public class WorkerTest {

2. public static void main(String[] args) {

3. Worker w = new Worker("jack",true,10000.0);

4. System.out.println("姓名：" + w.name);

5. System.out.println("性別：" + w.sex);

6. System.out.println("工資：" + w.salary);

7. }

8. }

​​

執行結果如下圖所示：

​

圖14-9：執行結果

以上程式建立Worker物件時構造方法的執行順序是：

● 先執行Object類的無引數構造方法；

● 再執行People類的構造方法；

● 最後執行Worker類的構造方法；

注意：雖然執行了三個構造方法，但是物件實際上只建立了一個Worker。

以上程式的記憶體結構圖是這樣變化的：

​

圖14-10：程式執行記憶體圖

通過以上內容的學習，super()的作用主要是：第一，呼叫父類的構造方法，使用這個構造方法來給當前子類物件初始化父型別特徵；第二，程式碼複用。

Java中super關鍵字的使用（在例項方法中）

super和this都可以使用在例項方法中，並且都不能使用在靜態方法當中，“this”大部分情況下都是可以省略的，只有在方法中區分區域性變數和例項變數的時候不能省略。那“super”什麼時候可以省略，什麼時候不能省略呢？

1. //書

2. public class Book {

3. //書名

4. String name;

5. //構造方法

6. public Book(){

7. super();

8. }

9. public Book(String name){

10. super();

11. this.name = name;

12. }

13. }

​​

1. //紙質書

2. public class PaperBook extends Book {

3. //構造方法

4. public PaperBook(){

5. super();

6. }

7. public PaperBook(String name){

8. super();

9. this.name = name;

10. }

11. //列印書名

12. public void printName(){

13. System.out.println("this.name->書名 ： " + this.name);

14. System.out.println("super.name->書名 ： " + super.name);

15. }

16. }

​​

1. public class BookTest {

2. public static void main(String[] args) {

3. PaperBook book1 = new PaperBook("零基礎學Java卷I");

4. book1.printName();

5. }

6. }

​​

執行結果如下圖所示：

​

圖14-11：super和this

我們發現printName()方法中的super.name和this.name最終輸出結果是一樣的，這是為什麼呢？請看以上程式執行的記憶體圖：

​

圖14-12：父類的構造方法執行結束之後的記憶體圖

​

圖14-13：子類的構造方法執行結束之後的記憶體圖

通過以上記憶體結構圖發現this.name和super.name實際上是同一塊記憶體空間，所以它們的輸出結果是完全一樣的。接下來，我們再把以上的PaperBook類修改一下：

1. //紙質書

2. public class PaperBook extends Book {

3. String name; //在子類中也定義了一個name屬性

4. //構造方法

5. public PaperBook(){

6. super();

7. }

8. public PaperBook(String name){

9. super();

10. this.name = name;//這裡的this.name代表子類的name

11. }

12. //列印書名

13. public void printName(){

14. System.out.println("this.name->書名 ： " + this.name);

15. System.out.println("super.name->書名 ： " + super.name);

16. }

17. }

​​

執行結果如下圖所示：

​

圖14-14：super和this的區別

為什麼super.name是null呢，我們一起來看看以上程式的記憶體圖：

​

圖14-15：父類Book的構造方法執行之後的記憶體圖

​

圖14-16：子類PaperBook的構造方法執行結束之後的記憶體圖

通過以上記憶體圖可以清楚的看到，父類Book的構造方法在執行的時候給super.name賦值null，子類PaperBook的構造方法在執行的時候給this.name賦值“零基礎學Java卷I”，由於在子類PaperBook中定義了重名的變數name導致在當前物件中有兩個name，一個是從父類中繼承過來的，一個是自己的，如果此時想訪問父類中繼承過來的name則必須使用super.name，當直接訪問name或者this.name都表示訪問當前物件自己的name。

通過以上的學習，大家知道super在什麼情況下不能省略了嗎？當父類中有該例項變數，子類中又重新定義了同名的例項變數，如果想在子類中訪問父類的例項變數，super不能省略。例項方法是這樣嗎？我們可以來測試一下，請看程式碼：

1. public class Vip {

2. //Vip預設繼承Object

3. //重寫從Object類中繼承過來的toString()方法

4. public String toString(){

5. return "我是金牌會員";

6. }

7. public void test(){

8. System.out.println(super.toString());

9. System.out.println(this.toString());

10. System.out.println(toString());

11. }

12. }

​

1. public class VipTest {

2. public static void main(String[] args) {

3. Vip vip = new Vip();

4. vip.test();

5. }

6. }

​想要了解更多請掃描下方二維碼

​