為何Java中子類重寫方法的訪問權限不能低於父類中權限
因為 向上轉型及Java程序設計維護的原因
例:
假設一個父類A 擁有的方法public void setXXX(){}可以被其他任意對象調用這個方法被子類B 覆寫后 為void setXXX(){}即默認的訪問權限只能被本包極其子類 所訪問假設其他包中的對象 C調用 方法為：
get( A a){
a.setXXX();}
而此時傳入的對象為B類對象，假設為b此時b將轉型為a但是b中的setXXX() 調用權限
已經被縮小了這將造成錯誤。所以子類對象不能比父類對象訪問權限大
以上只是一個例子還有其他出於易維護、易代碼結構設計的設計思想原因
其他：子類中重寫的方法拋出的異常應該為父類中方法的子異常或相同異常，並且拋出的異常種類不能多於父類中的方法。
實際上是遵循里氏替換原則。
一、里氏替換原則的定義
1、里氏替換原則通俗的來講就是：子類可以擴展父類的功能，但不能改變父類原有的功能。
2、里氏代換原則告訴我們，在軟件中將一個基類對象替換成它的子類對象，程序將不會產生任何錯誤和異常，反過來則不成立，如果一個軟件實體使用的是一個子類對象的話，那么它不一定能夠使用基類對象。
3、里氏代換原則是實現開閉原則的重要方式之一，由於使用基類對象的地方都可以使用子類對象，因此在程序中盡量使用基類類型來對對象進行定義，而在運行時再確定其子類類型，用子類對象來替換父類對象。
二、里氏替換原則包含的含義
1、子類可以實現父類的抽象方法，但是不能覆蓋父類的非抽象方法
在我們做系統設計時，經常會設計接口或抽象類，然后由子類來實現抽象方法，這里使用的其實就是里氏替換原則。子類可以實現父類的抽象方法很好理解，事實上，子類也必須完全實現父類的抽象方法，哪怕寫一個空方法，否則會編譯報錯。
里氏替換原則的關鍵點在於不能覆蓋父類的非抽象方法。（盡量不要重寫）父類中凡是已經實現好的方法，實際上是在設定一系列的規范和契約，雖然它不強制要求所有的子類必須遵從這些規范，但是如果子類對這些非抽象方法任意修改，就會對整個繼承體系造成破壞。而里氏替換原則就是表達了這一層含義。
2、子類中可以增加自己特有的方法
在繼承父類屬性和方法的同時，每個子類也都可以有自己的個性，在父類的基礎上擴展自己的功能。前面其實已經提到，當功能擴展時，子類盡量不要重寫父類的方法，而是另寫一個方法。
3、當子類覆蓋或實現父類的方法時，方法的前置條件（即方法的形參）要比父類方法的輸入參數更寬松。
4、當子類覆蓋或實現父類的方法時，方法的后置條件（即方法的返回值）要比父類方法的返回值更嚴格。
現在我們可以對以上四層含義逐個講解。
子類可以實現父類的抽象方法，但是不能覆蓋父類的非抽象方法
在我們做系統設計時，經常會設計接口或抽象類，然后由子類來實現抽象方法，這里使用的其實就是里氏替換原則。子類可以實現父類的抽象方法很好理解，事實上，子類也必須完全實現父類的抽象方法，哪怕寫一個空方法，否則會編譯報錯。
里氏替換原則的關鍵點在於不能覆蓋父類的非抽象方法。父類中凡是已經實現好的方法，實際上是在設定一系列的規范和契約，雖然它不強制要求所有的子類必須遵從這些規范，但是如果子類對這些非抽象方法任意修改，就會對整個繼承體系造成破壞。而里氏替換原則就是表達了這一層含義。
在面向對象的設計思想中，繼承這一特性為系統的設計帶來了極大的便利性，但是由之而來的也潛在着一些風險。就像開篇所提到的那一場景一樣，對於那種情況最好遵循里氏替換原則，類C1繼承類C時，可以添加新方法完成新增功能，盡量不要重寫父類C的方法。否則可能帶來難以預料的風險，比如下面一個簡單的例子：
public class C {
public int func(int a, int b){
return a+b;
}
}
public class C1 extends C{
@Override
public int func(int a, int b) {
return a-b;
}
}
public class Client{
public static void main(String[] args) {
C c = new C1();
System.out.println("2+1=" + c.func(2, 1));
}
}
運行結果：2+1=1
上面的運行結果明顯是錯誤的。類C1繼承C，后來需要增加新功能，類C1並沒有新寫一個方法，而是直接重寫了父類C的func方法，違背里氏替換原則，引用父類的地方並不能透明的使用子類的對象，導致運行結果出錯。
子類中可以增加自己特有的方法
在繼承父類屬性和方法的同時，每個子類也都可以有自己的個性，在父類的基礎上擴展自己的功能。前面其實已經提到，當功能擴展時，子類盡量不要重寫父類的方法，而是另寫一個方法，所以對上面的代碼加以更改，使其符合里氏替換原則，代碼如下：
public class C {
public int func(int a, int b){
return a+b;
}
}
public class C1 extends C{
public int func2(int a, int b) {
return a-b;
}
}
public class Client{
public static void main(String[] args) {
C1 c = new C1();
System.out.println("2-1=" + c.func2(2, 1));
}
}
運行結果：2-1=1
當子類覆蓋或實現父類的方法時，方法的前置條件（即方法的形參）要比父類方法的輸入參數更寬松
import java.util.HashMap;
public class Father {
public void func(HashMap m){
System.out.println("執行父類...");
}
}
import java.util.Map;
public class Son extends Father{
public void func(Map m){//方法的形參比父類的更寬松
System.out.println("執行子類...");
}
}
import java.util.HashMap;
public class Client{
public static void main(String[] args) {
Father f = new Son();//引用基類的地方能透明地使用其子類的對象。
HashMap h = new HashMap();
f.func(h);
}
}
運行結果：執行父類...
注意Son類的func方法前面是不能加@Override注解的，因為否則會編譯提示報錯，因為這並不是重寫（Override）。
當子類的方法實現父類的抽象方法時，方法的后置條件（即方法的返回值）要比父類更嚴格
import java.util.Map;
public abstract class Father {
public abstract Map func();
}
import java.util.HashMap;
public class Son extends Father{
@Override
public HashMap func(){//方法的返回值比父類的更嚴格
HashMap h = new HashMap();
h.put("h", "執行子類...");
return h;
}
}
public class Client{
public static void main(String[] args) {
Father f = new Son();//引用基類的地方能透明地使用其子類的對象。
System.out.println(f.func());
}
}
執行結果：{h=執行子類...}
總結
繼承作為面向對象三大特性之一，在給程序設計帶來巨大便利的同時，也帶來了一些弊端，它增加了對象之間的耦合性。因此在系統設計時，遵循里氏替換原則，盡量避免子類重寫父類的方法，可以有效降低代碼出錯的可能性。
我們都知道面向對象有三大特性：封裝、繼承、多態。所以我們在實際開發過程中，子類在繼承父類后，根據多態的特性，可能是圖一時方便，經常任意重寫父類的方法，那么這種方式會大大增加代碼出問題的幾率。比如下面場景：類C實現了某項功能F1。現在需要對功能F1作修改擴展，將功能F1擴展為F，其中F由原有的功能F1和新功能F2組成。新功能F由類C的子類C1來完成，則子類C1在完成功能F的同時，有可能會導致類C的原功能F1發生故障。這時候里氏替換原則就閃亮登場了。