二十二、SpringCloud分散式微服務雲架構之Java 重寫(Override)與過載(Overload)

JIAN2發表於2021-10-19
SpringGCCloud分散式微服務架構JavaIDE

重寫(Override)

重寫是子類對父類的允許訪問的方法的實現過程進行重新編寫, 返回值和形參都不能改變。 即外殼不變，核心重寫！

重寫的好處在於子類可以根據需要，定義特定於自己的行為。 也就是說子類能夠根據需要實現父類的方法。推薦分散式架構

二十二、SpringCloud分散式微服務雲架構之Java 重寫(Override)與過載(Overload)

 

重寫方法不能丟擲新的檢查異常或者比被重寫方法申明更加寬泛的異常。例如： 父類的一個方法申明瞭一個檢查異常 IOException，但是在重寫這個方法的時候不能丟擲 Exception 異常，因為 Exception 是 IOException 的父類，只能丟擲 IOException 的子類異常。

在物件導向原則裡，重寫意味著可以重寫任何現有方法。例項如下：

TestDog.java 檔案程式碼：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class  Animal{
    public  void  move(){
       System.out.println( "動物可以移動" );
    }
}
  
class  Dog  extends  Animal{
    public  void  move(){
       System.out.println( "狗可以跑和走" );
    }
}
  
public  class  TestDog{
    public  static  void  main(String args[]){
       Animal a =  new  Animal();  // Animal 物件
       Animal b =  new  Dog();  // Dog 物件
  
       a.move(); // 執行 Animal 類的方法
  
       b.move(); //執行 Dog 類的方法
    }
}

以上例項編譯執行結果如下：

1
2
動物可以移動
狗可以跑和走

在上面的例子中可以看到，儘管 b 屬於 Animal 型別，但是它執行的是 Dog 類的 move方法。

這是由於在編譯階段，只是檢查引數的引用型別。

然而在執行時，Java 虛擬機器(JVM)指定物件的型別並且執行該物件的方法。

因此在上面的例子中，之所以能編譯成功，是因為 Animal 類中存在 move 方法，然而執行時，執行的是特定物件的方法。

思考以下例子：

TestDog.java 檔案程式碼：

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
class  Animal{
    public  void  move(){
       System.out.println( "動物可以移動" );
    }
}
  
class  Dog  extends  Animal{
    public  void  move(){
       System.out.println( "狗可以跑和走" );
    }
    public  void  bark(){
       System.out.println( "狗可以吠叫" );
    }
}
  
public  class  TestDog{
    public  static  void  main(String args[]){
       Animal a =  new  Animal();  // Animal 物件
       Animal b =  new  Dog();  // Dog 物件
  
       a.move(); // 執行 Animal 類的方法
       b.move(); //執行 Dog 類的方法
       b.bark();
    }
}

以上例項編譯執行結果如下：

1
2
3
4
5
TestDog.java: 30 : cannot find symbol
symbol  : method bark()
location:  class  Animal
                 b.bark();
                  ^

該程式將丟擲一個編譯錯誤，因為b的引用型別Animal沒有bark方法。

方法的重寫規則

  • 引數列表與被重寫方法的引數列表必須完全相同。

  • 返回型別與被重寫方法的返回型別可以不相同，但是必須是父類返回值的派生類（java5 及更早版本返回型別要一樣，java7 及更高版本可以不同）。

  • 訪問許可權不能比父類中被重寫的方法的訪問許可權更低。例如：如果父類的一個方法被宣告為 public，那麼在子類中重寫該方法就不能宣告為 protected。

  • 父類的成員方法只能被它的子類重寫。

  • 宣告為 final 的方法不能被重寫。

  • 宣告為 static 的方法不能被重寫，但是能夠被再次宣告。

  • 子類和父類在同一個包中，那麼子類可以重寫父類所有方法，除了宣告為 private 和 final 的方法。

  • 子類和父類不在同一個包中，那麼子類只能夠重寫父類的宣告為 public 和 protected 的非 final 方法。

  • 重寫的方法能夠丟擲任何非強制異常，無論被重寫的方法是否丟擲異常。但是，重寫的方法不能丟擲新的強制性異常，或者比被重寫方法宣告的更廣泛的強制性異常，反之則可以。

  • 構造方法不能被重寫。

  • 如果不能繼承一個類，則不能重寫該類的方法。

Super 關鍵字的使用

當需要在子類中呼叫父類的被重寫方法時，要使用 super 關鍵字。

TestDog.java 檔案程式碼：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class  Animal{
    public  void  move(){
       System.out.println( "動物可以移動" );
    }
}
  
class  Dog  extends  Animal{
    public  void  move(){
       super .move();  // 應用super類的方法
       System.out.println( "狗可以跑和走" );
    }
}
  
public  class  TestDog{
    public  static  void  main(String args[]){
  
       Animal b =  new  Dog();  // Dog 物件
       b.move();  //執行 Dog類的方法
  
    }
}

以上例項編譯執行結果如下：

1
2
動物可以移動
狗可以跑和走

過載(Overload)

過載(overloading) 是在一個類裡面，方法名字相同，而引數不同。返回型別可以相同也可以不同。

每個過載的方法（或者建構函式）都必須有一個獨一無二的引數型別列表。

最常用的地方就是構造器的過載。

過載規則:

  • 被過載的方法必須改變引數列表(引數個數或型別不一樣)；
  • 被過載的方法可以改變返回型別；
  • 被過載的方法可以改變訪問修飾符；
  • 被過載的方法可以宣告新的或更廣的檢查異常；
  • 方法能夠在同一個類中或者在一個子類中被過載。
  • 無法以返回值型別作為過載函式的區分標準。

例項

Overloading.java 檔案程式碼：

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
public  class  Overloading {
     public  int  test(){
         System.out.println( "test1" );
         return  1 ;
     }
  
     public  void  test( int  a){
         System.out.println( "test2" );
     }   
  
     //以下兩個引數型別順序不同
     public  String test( int  a,String s){
         System.out.println( "test3" );
         return  "returntest3" ;
     }   
  
     public  String test(String s, int  a){
         System.out.println( "test4" );
         return  "returntest4" ;
     }   
  
     public  static  void  main(String[] args){
         Overloading o =  new  Overloading();
         System.out.println(o.test());
         o.test( 1 );
         System.out.println(o.test( 1 , "test3" ));
         System.out.println(o.test( "test4" , 1 ));
     }
}

重寫與過載之間的區別

總結

方法的重寫(Overriding)和過載(Overloading)是java多型性的不同表現，重寫是父類與子類之間多型性的一種表現，過載可以理解成多型的具體表現形式。

  • (1)方法過載是一個類中定義了多個方法名相同,而他們的引數的數量不同或數量相同而型別和次序不同,則稱為方法的過載(Overloading)。
  • (2)方法重寫是在子類存在方法與父類的方法的名字相同,而且引數的個數與型別一樣,返回值也一樣的方法,就稱為重寫(Overriding)。
  • (3)方法過載是一個類的多型性表現,而方法重寫是子類與父類的一種多型性表現。


來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/70006413/viewspace-2838066/，如需轉載，請註明出處，否則將追究法律責任。

相關文章