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     //靜態方法，返回包名  
  9     public static String getKind()  
 10     {  
 11         System.out.println("parent的getKind()方法被呼叫了");  
 
 12         return kind;  
 13     }  
 14   
 15     //靜態方法，返回年齡  
 16     public static int getAge()  
 17     {  
 18         System.out.println("Parent的getAge()方法被呼叫了");  
 19         return age;  
 20     }  
 21   
 22     //例項方法，返回姓名  
 23     public String getName()  
 24     {  
 25         System.out.println("Parent的getName()方法被呼叫了");  
 
 26         return this.name;  
 27     }  
 28   
 29 }  
 30   
 31   
 32 //子類  
 33 class Child extends Parent  
 34 {  
 35     public static String kind="javastudy.extendsstudy.child";  
 36     public int age=25;  
 37     public String name="child";  
 38   
 39     //隱藏父類靜態方法  
 40     public static
 
 String getKind()  
 41     {  
 42         System.out.println("child的getkind()方法被呼叫了");  
 43         return kind;  
 44     }  
 45       
 46     //獲取父類包名  
 47     public static String getParentKind()  
 48     {  
 49         return Parent.kind;  
 50     }  
 51       
 52     //覆蓋父類例項方法  
 53     public String getName()  
 54     {  
 55         System.out.println("child的getName()被呼叫了");  
 56         return this.name;  
 57     }  
 58       
 59     //獲取父類名稱  
 60     public String getParentName()  
 61     {  
 62         return super.name;  
 63     }  
 64     /* 
 65      *錯誤，例項方法不能覆蓋父類的靜態方法 
 66     public int getAge() 
 67     { 
 68         return this.age; 
 69     } 
 70     */  
 71 }  
 72 
 73 
 74 public class Tianyi   
 75 {  
 76     public static void main(String[] args)   
 77     {  
 78         Child child=new Child();
 79        //建立Child類物件child  
 80     
 81         Parent parent=child;
 82         //用parent引用child物件  
 83         
 84         Child b = (Child) parent;
 85         //將parent引用強制轉換為Child物件child
 86  
 87         System.out.printf("子類child名稱：%s,年齡：%d,包名:%s%n",child.name,child.age,child.kind);  
 88         //輸出：子類名稱：child,年齡：25,包:javastudy.extendsstudy.child   
 89   
 90         System.out.printf("超類的名稱:%s,年齡：%d,包名：%s%n",parent.name,parent.age,parent.kind);  
 91         //輸出：轉換後的名稱:Parent,年齡：50,包：javastudy.extendsstudy.parent
 92 
 93         System.out.printf("子類b名稱：%s,年齡：%d,包名:%s%n",b.name,b.age,b.kind);  
 94          
 95   
 96         System.out.printf("子類child訪問父類被隱藏的例項變數name:%s%n",child.getParentName());  
 97         //輸出：子類訪問父類被隱藏的例項變數name:Parent
 98    
 99         System.out.printf("子類b訪問父類被隱藏的例項變數name:%s%n",b.getParentName());  
100        
101   
102           
103         System.out.printf("子類child訪問父類被隱藏的靜態變數kind:%s%n",child.getParentKind());  
104         //輸出：子類訪問父類被隱藏的靜態變數kind:javastudy.extendsstudy.parent  
105   
106         System.out.printf("子類b訪問父類被隱藏的靜態變數kind:%s%n",b.getParentKind());
107 
108         child.getName();  
109         //輸出：child的getName()被呼叫了
110            
111          b.getName();
112           
113   
114         //**************注意看這個方法，返回的還是子類的getName  
115          parent.getName();  
116         //輸出：child的getName()被呼叫了  
117   
118         child.getKind();  
119         //輸出：child的getkind()方法被呼叫了
120          
121         b.getKind();  
122   
123         parent.getKind();  
124         //輸出：parent的getKind()方法被呼叫了  
125     }  
126 }