JAVA中方法和變量在繼承中的覆寫和隐藏

出處：http://renyanwei.iteye.com/blog/258304

我們知道，在JAVA中，子類可以繼承父類，如果子類聲明的方法與父類有重名的情況怎麼辦，大夥兒都知道要是重寫，但是實際上這又分為兩種 情況，就是方法和變量在繼承時的覆寫和隐藏問題，這些概念性的東西看似無聊，但是在面試或者是SCJP認證題中圍繞這些是會經常碰到的，是以這裡來讨論下

首先我們來看幾個概念

隐藏 ：child隐藏了parent的變量和方法，那麼，child不能通路parent被隐藏的變量或者方法，但是，講B轉換成A中，可以通路A被隐藏的變量或者方法

覆寫 ：child覆寫了parent的變量或者方法，那麼，child不能通路parent被覆寫的變量或者方法，将child轉換成parent後同樣不能通路parent被覆寫的變量或者方法

首先看一下JAVA中方法和變量在繼承時的覆寫和隐藏規則

1.父類的執行個體變量和靜态變量能被子類的同名變量隐藏

2.父類的靜态方法被子類的同名靜态方法隐藏

3.父類的執行個體方法被子類的同名執行個體變量覆寫

還有幾點需要注意的是

1.不能用子類的靜态方法隐藏 父類中同樣标示（也就是傳回值 名字 參數都一樣）的執行個體方法

2.不能用子類的執行個體方法覆寫 父類中同樣标示的靜态方法

3.這點兒請注意，就是變量隻會被隐藏 不會被覆寫 ，無論他是執行個體變量還是靜态變量，而且，子類的靜态變量可以隐藏 父類的執行個體變量，子類的執行個體變量可以隐藏 父類的靜态變量

O(∩_∩)O哈哈~ 是不是有點兒繞口，沒關系 我們看一個執行個體

建立兩個父子類關系的類

Java代碼  

1. //父類  
2. class Parent  
3. {  
4.     public static String kind="javastudy.extendsstudy.parent";  
5.     public static int age=50;  
6.     public String name="Parent";  
7.     //靜态方法，傳回包名  
8.     public static String getKind()  
9.     {  
10.         System.out.println("parent的getKind()方法被調用了");  
11.         return kind;  
12.     }  
13.     //靜态方法，傳回年齡  
14.     public static int getAge()  
16.         System.out.println("Parent的getAge()方法被調用了");  
17.         return age;  
19.     //執行個體方法，傳回姓名  
20.     public String getName()  
22.         System.out.println("Parent的getName()方法被調用了");  
23.         return this.name;  
25. }  
26. //子類  
27. class Child extends Parent  
29.     public static String kind="javastudy.extendsstudy.child";  
30.     public int age=25;  
31.     public String name="child";  
32.     //隐藏父類靜态方法  
35.         System.out.println("child的getkind()方法被調用了");  
38.     //擷取父類包名  
39.     public static String getParentKind()  
41.         return Parent.kind;  
43.     //覆寫父類執行個體方法  
46.         System.out.println("child的getName()被調用了");  
49.     //擷取父類名稱  
50.     public String getParentName()  
52.         return super.name;  
54.     /* 
55.      *錯誤，執行個體方法不能覆寫父類的靜态方法 
56.     public int getAge() 
57.     { 
58.         return this.age; 
59.     } 
60.     */  

 然後測試下

1. class Test   
3.     public static void main(String[] args)   
5.         Child child=new Child();  
6.         System.out.printf("子類名稱：%s,年齡：%d,包名:%s%n",child.name,child.age,child.kind);  
7.         //輸出：子類名稱：child,年齡：25,包:javastudy.extendsstudy.child  
8.         //把child轉換成parent對象  
9.         Parent parent=child;  
10.         System.out.printf("轉換後的名稱:%s,年齡：%d,包名：%s%n",parent.name,parent.age,parent.kind);  
11.         //輸出：轉換後的名稱:Parent,年齡：50,包：javastudy.extendsstudy.parent  
12.         System.out.printf("子類通路父類被隐藏的執行個體變量name:%s%n",child.getParentName());  
13.         //輸出：子類通路父類被隐藏的執行個體變量name:Parent  
14.         System.out.printf("子類通路父類被隐藏的靜态變量kind:%s",child.getParentKind());  
15.         //輸出：子類通路父類被隐藏的靜态變量kind:javastudy.extendsstudy.parent  
16.         child.getName();  
17.         //輸出：child的getName()被調用了  
18.         //**************注意看這個方法，傳回的還是子類的getName  
19.         parent.getName();  
21.         child.getKind();  
22.         //輸出：child的getkind()方法被調用了  
23.         parent.getKind();  
24.         //輸出：parent的getKind()方法被調用了  

 好了，看了結果後總結下吧

1.同名的執行個體方法被覆寫 ，同名的靜态方法被隐藏 ，child類的getName執行個體方法覆寫 了parent的getName執行個體方法,chind的getKind方法隐藏 了parent類的getKind方法

2.隐藏 和覆寫 的差別在于，子類對象轉換成父類對象後，能夠通路父類被隐藏 的變量和方法，而不能通路父類被覆寫 的方法

3.如果需要通路父類被隐藏

的執行個體變量，加上super就好了，比如通路父類的name，寫上super.name就好了

本文不是教會大家重寫父類變量的，而是重點說明方法和變量的隐藏和覆寫，這些個小知識點雖然在做項目的時候不怎麼會用到，但是一定要記住，不然的話很多錯誤會感到莫名其妙，還有就是SCJP的題庫裡這類題大大存在，是以本人覺得這些細小的知識還是記住為好