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

 

 

類似於基本數據類型之間的強制類型轉換。 
存在繼承關系的父類對象和子類對象之間也可以 
在一定條件之下相互轉換。 
這種轉換需要遵守以下原則： 
1.子類對象可以被視為是其父類的一個對象
2.父類對象不能被當作是某一個子類的對象。
3.如果一個方法的形式參數定義的是父類對象,那么調用這個方法時,可以使用子類對象作為實際參數。 
4.如果父類對象與引用指向的實際是一個子類對象,那么這個父類對象的引用可以用強制類型轉換轉化成子類對象的引用。

 方法一：

 1.  Child a = new Child();

 2.  Parent b = a;

 3.  Child c = (Child) b;

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

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

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

 采用該方法的過程中：由於超類引用的是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、如果一個父類對象名已經被子類對象名所賦值，那可以將父類對象名經強制轉換賦值給子類對象名。

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

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

 

總結：

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

 

 

 

 

//父類  
class Parent  
{  
    public static String kind="javastudy.extendsstudy.parent";  
    public static int age=50;  
    public String name="Parent";  
  
    //靜態方法，返回包名  
    public static String getKind()  
    {  
        System.out.println("parent的getKind()方法被調用了");  
        return kind;  
    }  
  
    //靜態方法，返回年齡  
    public static int getAge()  
    {  
        System.out.println("Parent的getAge()方法被調用了");  
        return age;  
    }  
  
    //實例方法，返回姓名  
    public String getName()  
    {  
        System.out.println("Parent的getName()方法被調用了");  
        return this.name;  
    }  
  
}  
  
  
//子類  
class Child extends Parent  
{  
    public static String kind="javastudy.extendsstudy.child";  
    public int age=25;  
    public String name="child";  
  
    //隱藏父類靜態方法  
    public static String getKind()  
    {  
        System.out.println("child的getkind()方法被調用了");  
        return kind;  
    }  
      
    //獲取父類包名  
    public static String getParentKind()  
    {  
        return Parent.kind;  
    }  
      
    //覆蓋父類實例方法  
    public String getName()  
    {  
        System.out.println("child的getName()被調用了");  
        return this.name;  
    }  
      
    //獲取父類名稱  
    public String getParentName()  
    {  
        return super.name;  
    }  
    /* 
     *錯誤，實例方法不能覆蓋父類的靜態方法 
    public int getAge() 
    { 
        return this.age; 
    } 
    */  
}  


public class Tianyi   
{  
    public static void main(String[] args)   
    {  
        Child child=new Child();
       //創建Child類對象child  
    
        Parent parent=child;
        //用parent引用child對象  
        
        Child b = (Child) parent;
        //將parent引用強制轉換為Child對象child
 
        System.out.printf("子類child名稱：%s,年齡：%d,包名:%s%n",child.name,child.age,child.kind);  
        //輸出：子類名稱：child,年齡：25,包:javastudy.extendsstudy.child   
  
        System.out.printf("超類的名稱:%s,年齡：%d,包名：%s%n",parent.name,parent.age,parent.kind);  
        //輸出：轉換后的名稱:Parent,年齡：50,包：javastudy.extendsstudy.parent

        System.out.printf("子類b名稱：%s,年齡：%d,包名:%s%n",b.name,b.age,b.kind);  
         
  
        System.out.printf("子類child訪問父類被隱藏的實例變量name:%s%n",child.getParentName());  
        //輸出：子類訪問父類被隱藏的實例變量name:Parent
   
        System.out.printf("子類b訪問父類被隱藏的實例變量name:%s%n",b.getParentName());  
       
  
          
        System.out.printf("子類child訪問父類被隱藏的靜態變量kind:%s%n",child.getParentKind());  
        //輸出：子類訪問父類被隱藏的靜態變量kind:javastudy.extendsstudy.parent  
  
        System.out.printf("子類b訪問父類被隱藏的靜態變量kind:%s%n",b.getParentKind());

        child.getName();  
        //輸出：child的getName()被調用了
           
         b.getName();
          
  
        //**************注意看這個方法，返回的還是子類的getName  
         parent.getName();  
        //輸出：child的getName()被調用了  
  
        child.getKind();  
        //輸出：child的getkind()方法被調用了
         
        b.getKind();  
  
        parent.getKind();  
        //輸出：parent的getKind()方法被調用了  
    }  
}

 運行結果如下：

 

 超類和子類均具備的實例方法getName,超類調用該函數時，被子類的的該函數覆蓋了。