引入

在Java編程語言中，類型轉換（無論是強制類型轉換還是自動類型轉換）的方向并不是簡單地基于“高位”和“低位”的概念，而是基于數(shù)據(jù)類型的范圍和精度。

基本類型強制轉換

1.數(shù)字之間

short s = 100;
int i = s; // 自動類型轉換，安全

int j = 30000; // 一個大于short類型能表示的最大值的int
short k = (short) j; // 強制類型轉換，可能導致數(shù)據(jù)丟失

上面給出了兩種數(shù)值轉換的概念，第一種是short轉成int類型，由于short是16位的，int是32位的，此時就是低精度轉為高精度，所以編譯器會自動進行類型轉換，是安全的，不用強轉（因為這種轉換是安全的，不會丟失任何信息，只是簡單地擴展了符號位）

而第二種則是讓int類型轉成short，高精度轉低精度，不安全，強制類型轉換，short只能存儲低16位的數(shù)據(jù)，高16位的位置就舍棄了，所但凡int的高16位存有數(shù)據(jù)，此時的強轉就會發(fā)生數(shù)據(jù)丟失。

所以通常而言，這種高精度強轉低精度是沒有意義的。

2.數(shù)字字符之間

引入

以前有涉及過steam，buffer的概念，并且它們本質都是數(shù)組。

int c=23456;
char d=(char) c; //將int類型的c強轉成char類型的d
System.out.println(d); //并且能夠解析輸出

steam就是類似如下的一串二進制數(shù)字，在解析時以8位或32位等解析成十進制，就可以得到不同的結果：

 int[] arr={23456,23457,34567,23876,32447};
 for(int x:arr){//解析輸出
      char e=(char) x;
      System.out.println(e);        
 }                             

【以上就是兩個基本類型強制轉換的例子，而且基本類型之間都可以進行強轉，只是有的沒有意義?！?/p>

引用類型的強制轉換

引入多態(tài)概念前提

e.g.首先，我們定義一個父類Animal，并在其中聲明一個方法makeSound，但不在父類中實現(xiàn)它（可以將它設為抽象方法，但在這個例子中，我們?yōu)榱撕喕屗祷匾粋€默認字符串）。然后，我們創(chuàng)建兩個子類Dog和Cat，它們都繼承自Animal類，并各自實現(xiàn)了makeSound方法。

// 父類 Animal
class Animal {
    // 可以是一個抽象方法，但這里為了簡化，我們提供一個默認實現(xiàn)
    public String makeSound() {
        return "Some generic animal sound";
    }
}

// 子類 Dog 繼承自 Animal
class Dog extends Animal {
    @Override
    public String makeSound() {
        return "Woof! Woof!";
    }
}

// 子類 Cat 繼承自 Animal
class Cat extends Animal {
    @Override
    public String makeSound() {
        return "Meow! Meow!";
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        // 使用父類類型的引用來指向子類對象
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        // 調用被重寫的方法，將展示多態(tài)性
        System.out.println(myDog.makeSound()); // 輸出: Woof! Woof!
        System.out.println(myCat.makeSound()); // 輸出: Meow! Meow!

        // 盡管 myDog 和 myCat 都是 Animal 類型的引用，
        // 但它們實際上指向的是 Dog 和 Cat 對象，
        // 因此調用 makeSound 方法時會執(zhí)行子類中的實現(xiàn)。
    }
}

在這個例子中，展示了多態(tài)性的兩個關鍵方面：

父類引用指向子類對象：myDog是一個Animal類型的引用，但它實際上指向了一個Dog對象。同樣，myCat是一個Animal類型的引用，但它指向了一個Cat對象。

方法重寫：Dog和Cat類都重寫了Animal類中的makeSound方法。因此，當通過myDog和myCat引用調用makeSound方法時，會分別調用Dog和Cat類中的實現(xiàn)。

以上例子展示了多態(tài)所遵守的兩項，下面是完整的多態(tài)遵循條件：

要符合多態(tài)，通常需要滿足以下幾個條件：

繼承：多態(tài)通常依賴于繼承關系。在面向對象編程中，子類繼承父類，從而可以重用父類的代碼并擴展新的功能。多態(tài)性允許我們使用父類類型的引用來引用子類對象。

方法重寫（Override）：子類需要重寫父類中的某些方法，以便在調用這些方法時能夠表現(xiàn)出不同的行為。方法重寫是多態(tài)性的關鍵所在，它允許子類提供父類方法的具體實現(xiàn)。

父類引用指向子類對象：這是多態(tài)性的另一個重要方面。我們可以創(chuàng)建一個父類類型的引用，并將其指向一個子類對象。當通過這個引用調用一個被重寫的方法時，將調用子類中的該方法實現(xiàn)，而不是父類中的實現(xiàn)。

接口或抽象類：雖然多態(tài)性不一定需要接口或抽象類，但它們?yōu)槎鄳B(tài)性提供了強大的支持。接口和抽象類可以定義方法簽名，而不提供具體實現(xiàn)。子類可以實現(xiàn)這些接口或繼承這些抽象類，并提供具體的方法實現(xiàn)。這樣，當使用接口或抽象類類型的引用來引用子類對象時，就可以實現(xiàn)多態(tài)性。

運行時類型識別（RTTI, Run-Time Type Identification）：在Java等語言中，運行時類型識別是多態(tài)性的基礎之一。它允許程序在運行時確定對象的實際類型，并根據(jù)這個類型來調用相應的方法。這是通過方法重寫和父類引用指向子類對象來實現(xiàn)的。

【注意：雖然給出了這么多條件，但是多態(tài)性的核心在于方法重寫和父類引用指向子類對象（句柄可以指向自己類的對象或者自己的子孫后代類的對象）這兩個方面?！?/strong>

class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        //Animal myDog = new Dog(); 創(chuàng)建了一個 Dog 類的實例，并將其引用賦值給 Animal 類型的變量 myDog。這意味著 myDog 指向的是一個 Dog 對象，但它在編譯時被視為 Animal 類型。
        Animal myCat = new Cat();
       // Animal myCat = new Cat(); 類似地，創(chuàng)建了一個 Cat 類的實例，并將其引用賦值給 Animal 類型的變量 myCat。
        System.out.println(myDog instanceof Dog);    // 輸出 true
        System.out.println(myDog instanceof Animal); // 輸出 true
        System.out.println(myDog instanceof Cat);    // 輸出 false
        System.out.println(myDog instanceof Object); // 輸出 true

        System.out.println(null instanceof Animal);  // 輸出 false
    }
}

public class Test{
    public static void main(String[] mmm) throws Exception{
        Child2 x=new Child2();
        //Child2 x = new Child2(); 創(chuàng)建了一個 Child2 類的實例，并將其引用賦值給 Child2 類型的變量 x。
        Child3 w=new Child3();
        //Child3 w = new Child3(); 創(chuàng)建了一個 Child3 類的實例，并將其引用賦值給 Child3 類型的變量 w。

        //句柄可以指向自己類的對象或者自己的子孫后代類的對象
        Person s=x; //父類指子類child2
        m1(s);
        
        s=w;
        m1(s);
        
        public static void m1(Person s){
            Child3 w=null;
            if(s instanceof Child3){
            //?使用instanceof關鍵字檢查s是否是Child3的實例,如果是true，才進行下面的強轉代碼
               //?用instanceof來驗證強轉?
                 w=(Child3) s;            
            }
                   
        }                                                           
    }
}