存在繼承關係的Java類對象之間的類型轉換(一)

時間 2019-11-14

原文原文鏈接

相似於基本數據類型之間的強制類型轉換。
存在繼承關係的父類對象和子類對象之間也能夠
在必定條件之下相互轉換。
這種轉換須要遵照如下原則：
1.子類對象能夠被視爲是其父類的一個對象
2.父類對象不能被看成是某一個子類的對象。
3.若是一個方法的形式參數定義的是父類對象,那麼調用這個方法時,可使用子類對象做爲實際參數。
4.若是父類對象與引用指向的實際是一個子類對象,那麼這個父類對象的引用能夠用強制類型轉換轉化成子類對象的引用。java

方法一：函數

1. Child a = new Child();this

2. Parent b = a;spa

3. Child c = (Child) b;3d

該方法的步驟是： 1.建立1個子類對象 code

2.用超類引用該子類對象對象

3.另外1個子類引用將該超類引用強制的轉換。blog

採用該方法的過程當中：因爲超類引用的是1個子類對象（引用的該子類對象的內存空間），所以該超類引用具有子類對象的特色，再將該超類引用強制轉化爲另外1個子類對象。繼承

採用該方法能夠實現對象類型由超類向子類的轉化，而且在程序的編譯和運行均不會出現異常。內存

方法二：（錯誤方法）

1.Parent b = new parent();

2.Child c = (Child) b ;

採用該方法不能實現對象類型由超類向子類的轉化，以上源程序編譯正常，可是運行時會拋出class castException異常。

這是由於：能夠執行類型轉換「子＝（子）父」，但須要運行時進行檢查。若是父類變量引用的是正確的子類型（這句話的意思即爲描述1中的內容：即父類對象要想造型轉換後賦給子類對象，其自己引用的是子類型的內存空間），賦值將執行。若是父類變量引用的是不相關的子類型，將會生成class castException異常。

在java中，作強制類型轉換時
父類與子類對象之間，同一父類的兄弟類對象之間如何強制轉換？
例如：
class a
{ ... }
class b extends a
{...}
class c extends a
{...}
....
a a1=new a();
b b1=new b();
c c1=new c();
a1=b1 //合法
b1=a1 //不合法（理論上是合法的？）
b1=(b)c1//不合法（理論上是合法的？）

解答：

說明如下幾點:
1.類型轉換必須在繼承層次類轉換,即超類與子類之間.
2.兄弟類之間不存在繼承,所以也不存在類型轉換.

對類進行類型轉換的通常原則以下：
1.老是能夠「父＝子」賦值。此時不須要類型轉換。由於特定的子類也屬於它的通常父類。也能夠執行跨級跨層次的賦值，即父類能夠式更高級別的父類。
2.能夠執行類型轉換「子＝（子）父」，但須要運行時進行檢查。若是父類變量引用的是正確的子類型，賦值將執行。若是父類變量引用的是不相關的子類型，將會生成class castException異常。
3.決不能在不相關的任何類之間執行類的賦值或者類型轉換。
若是把摟主的a1看成動物，把b1看成狗，c1看成貓
a1=b1 //合法———也就是說狗是動物，固然成立
b1=a1 //不合法（理論上是合法的？）———就是說動物是狗，這固然不對了
b1=(b)c1//不合法（理論上是合法的？）———就是說狗是貓，這固然也不對了

對象在繼承關係中的改變

對象的賦值是地址標識的傳遞，即兩個對象名共同使用同一段內存地址。在Java中，對父類與子類對象之間的賦值做了以下規定：

一、子類對象名能夠賦值給父類對象名；但父類對象名不能夠賦值給子類對象名。

即：父類對象名=子類對象名;

二、若是一個父類對象名已經被子類對象名所賦值，那能夠將父類對象名經強制轉換賦值給子類對象名。

即：子類對象名=(子類類名)父類對象名;

經常使用的一種形式：方法中形參用父類型，實參用子類的對象名.

總結：

對類進行造型轉換的應參考如下原則：
1.老是能夠「父＝子」賦值。此時不須要類型轉換。
2.能夠執行類型轉換「子＝（子）父」，但須要運行時進行檢查。若是父類變量引用的是正確的子類型，賦值將執行。若是父類變量引用的是不相關的子類型，將會生成class castException異常。
即：若是父類的實例是在子類的實例上塑造的，「子＝（子）父」時就不會拋出異常。
如：
A 是B的父類。
A a= new B(); //父類A的對象a是在子類B的對象上塑造的。
就能夠：
B b= (B)a;
3.決不能在不相關的任何類之間執行類的賦值或者類型轉換。即類的造型轉換僅限於有繼承關係的倆個類的對象之間。

  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 }