2. 程式人生 > >菜雞的Java課筆記 第二十二 物件多型性

菜雞的Java課筆記 第二十二 物件多型性

阿新 • • 發佈：2018-12-10

本次只是圍繞著多型性的概念來進行講解，但是所講解的程式碼與實際的開發幾乎沒有關係，而且多型一定是在繼承性的基礎上才可以操作的，
        而本次將使用類繼承的關係來描述多型的性質，實際的開發中不會出現普通類的繼承關係（一個已經完善的類不應該再被繼承），開發中都要求繼承抽象類和介面       
        多型性要想實現有兩個前提：繼承，覆寫       
        範例：引出程式碼

class A {
    public void print(){
        System.out.println("hello");
    }
}
class B extends A{
    public void print(){
        System.out.println("你好！");
    }
}
public class polymorphism{
    public static void main(String args[]){
        B b = new B();
        b.print();     
    }
}

        覆寫呼叫的前提：看new 的是那個類的物件，而後看方法是否被子類所覆寫
        在java中多型性主要由兩個方面組成：
            方法的多型性：
                方法過載：方法呼叫時根據不同的引數個數及型別可以實現不同的功能
                方法覆寫：不同的子類針對於同樣的一個方法可以有不同的實現
            物件的多型性：父類與子類物件間的轉換操作；發生在繼承關係之中
                【自動】物件的向上轉型：子類物件變為父類物件  父類 父類物件 = 子類例項，自動完成的
                【強制】物件的向下轉型；父類物件變為子類物件  子類 子類物件 = (子類)父類例項，強制轉換
            除了轉型之外，還有一些操作是不轉型的，例如：String

物件多型性基礎實現
        觀察一道程式      
        範例：

class Member{
    public String getInfo(){
        return "Member:我是一個會員";
    }
}
class VIPMember extends Member{  // 產生繼承
    public String getInfo(){
        return "VIPMember:我是一個貴賓會員";
    }
}
public class polymorphism{
    public static void main(String args[]){
        VIPMember mam = new VIPMember();
        System.out.println(mem.getInfo());
    }
}

           
            方法覆寫觀察：
                觀察現在 new 的是那個子類
                觀察這個子類呼叫的方法是否被覆寫，如果被覆寫了則呼叫的就是被覆寫過的方法
        
        範例：物件的向上轉型

class A {
    public void print(){
        System.out.println("hello");
    }
}
class B extends A{
    public void print(){
        System.out.println("你好！");
    }
}
public class polymorphism{
    public static void main(String args[]){
        A a = new B();  // 向上轉型
        a.print();     
    }
}           

        可以發現向上轉型是自動完成的，除了向上轉型之外，也可以實現物件的向下轉型操作
向上轉型最大的特點在於：所有的子類物件按照統一的父類型別進行接收，但是由於例項化子類的不同，有可能同一個父類的方法會有不同的呼叫實現
為了更好的理解物件的向上轉型問題就做一個簡單的分析：要求設計一個方法，這個方法可以接收使用者的引數資訊
        如果這個時候採用原始的技術：方法過載
        
        範例：

class Member{
    public String getInfo(){
        return "Member:我是一個會員";
    }
}
class VIPMember extends Member{  // 產生繼承
    public String getInfo(){
        return "VIPMember:我是一個貴賓會員";
    }
}
class CIPMember extends Member{  // 產生繼承
    public String getInfo(){
        return "CIPMember:我是一個商務會員";
    }
}
public class polymorphism{
    public static void main(String args[]){
        income(new Member());
        income(new VIPMember());
        income(new CIPMember());
    }
    public static void income(Member mem){
        System.out.println(mem.getInfo());
    }
    public static void income(VIPMember mem){
        System.out.println(mem.getInfo());
    }
    public static void income(CIPMember mem){
        System.out.println(mem.getInfo());
    }
}

            缺點：
                如果突然有一天你的使用者型別分為了十萬種，那麼就需要有十萬個 Member 子類，這個方法會過載十萬次
                所有的方法體執行的功能都一樣，那麼這樣是一個明顯重複
            當子類眾多又需要考慮引數統一的時候，按惡魔最好用的做法就是進行物件的向上轉型（自動，呼叫被覆寫過的方法）
            

class Member{
    public String getInfo(){
        return "Member:我是一個會員";
    }
}
class VIPMember extends Member{  // 產生繼承
    public String getInfo(){
        return "VIPMember:我是一個貴賓會員";
    }
}
class CIPMember extends Member{  // 產生繼承
    public String getInfo(){
        return "CIPMember:我是一個商務會員";
    }
}
public class polymorphism{
    public static void main(String args[]){
        income(new Member());
        income(new VIPMember());
        income(new CIPMember());
    }
    public static void income(Member mem){
        System.out.println(mem.getInfo());
    }
    
}           

            發現利用物件的向上轉型可以有效的實現引數的統一處理。這一點在程式中至關重要
        
物件向下轉型

        範例：物件的向下轉型

class A {
    public void print(){
        System.out.println("hello");
    }
}
class B extends A{
    public void print(){
        System.out.println("你好！");
    }
}
public class polymorphism{
    public static void main(String args[]){
        A a = new B();  // 向上轉型
        B b = (B)a;  // 向下轉型
        b.print();     
    }
}           

        具體的轉型的概念沒有什麼難理解，那麼程式的執行結果也很好理解，但是這樣做有什麼意義呢？
        
        分析：向上轉型的意義
            現在要求定義一個 fun（）方法，這個方法要求可以接收A以及A類所有子類的例項化物件
            於是根據這樣的描述可以有兩種實現方案
                方案一：使用方法過載的概念來完成

class A {
    public void print(){
        System.out.println("hello");
    }
}
class B extends A{
    public void print(){
        System.out.println("你好！");
    }
}
class C extends A{
    public void print(){
        System.out.println("不好！");
    }
}
public class polymorphism{
    public static void main(String args[]){
        fun(new A());
        fun(new B());
        fun(new C());
    }
    public static void fun(A a){
        a.print();
    }
    public static void fun(B b){
        b.print();
    }
    public static void fun(C c){
        c.print();
    }
}
/*
結果：
Hello
你好!
不好
*/                

                如果說這個時候A類有3000W個子類，並且這個子類還在以倍數的方式增長
                那麼就表示：在設計之初此方法就需要過載3000W次，並且隨著子類的追加，此方法繼續過載，繼續不斷的修改類，於是你就瘋了......
                
                方案二：發現所有的子類呼叫的方法實際上都只是println（）一個，那麼現在可以利用物件自動向上轉型的概念就直接使用A類接收

class A {
    public void print(){
        System.out.println("hello");
    }
}
class B extends A{
    public void print(){
        System.out.println("你好！");
    }
}
class C extends A{
    public void print(){
        System.out.println("不好！");
    }
}
public class polymorphism{
    public static void main(String args[]){
        fun(new A());
        fun(new B());
        fun(new C());
    }
    public static void fun(A a){
        a.print();
    }
}
/*
結果：
Hello
你好!
不好
*/

                所以物件的向上轉型給開發者最大的幫助在於其資料操作的統一性上
        
        分析：向下轉型的意義
        範例：觀察問題

class A {
    public void print(){
        System.out.println("hello");
    }
}
class B extends A{
    public void print(){
        System.out.println("你好！");
    }
    public void funB(){ // 子類自己擴充的新方法
        System.out.println("********************");
    }
}
public class polymorphism{
    public static void main(String args[]){
        A a = new B();  // 向上轉型
        a.print();     
        a.funB();// 不能夠呼叫
    }
}
//結果：出錯           

        一旦發生了向上轉型之後，父類物件是不可能呼叫子類中新建的方法的，只能夠呼叫父類自己本身所定義的方法名稱，也就是說向上轉型之後犧牲的是子類的個性化特徵
        但是如果說現在要想呼叫子類定義的特殊方法，那麼就必須採用向下轉型

class A {
    public void print(){
        System.out.println("hello");
    }
}
class B extends A{
    public void print(){
        System.out.println("你好！");
    }
    public void funB(){ // 子類自己擴充的新方法
        System.out.println("********************");
    }
}
public class polymorphism{
    public static void main(String args[]){
        A a = new B();  // 向上轉型 （把A改為B？？）
        a.print();     
        B b = (B)a;
        b.funB();
    }
}
/*
結果：
你好！
******************  
*/

           
        解釋：為什麼現在你的程式碼裡面需要先向上轉型，在進行向下轉型，囉嗦

class A {
    public void print(){
        System.out.println("hello");
    }
}
class B extends A{
    public void print(){
        System.out.println("你好！");
    }
    public void funB(){ // 子類自己擴充的新方法
        System.out.println("********************");
    }
}
class C extends A{
    public void print(){
        System.out.println("不好！");
    }
    public void funC(){ // 子類自己擴充的新方法
        System.out.println("###################");
    }
}
public class polymorphism{
    public static void main(String args[]){
        fun(new B());
        fun(new C());
    }
    public static void fun(A a){
        a.print()
        // 由於某種特殊需求必須呼叫B類中的funB（）方法，所以要進行向下轉型
        B b = (B)a;
        b.funB();
    }
}
/*
結果：
你好！
不好
*/

           
        現在如果使用了向下轉型，那麼在之前好不容易建立起來的引數統一的局面就被打破了，所以這樣的操作就屬於不合理的操作形式
        但是轉型的意義卻可以更加明確了：為了呼叫子類自己的特殊支援
        
        但是在進行物件向下轉型前也需要有一個注意點：
        範例：錯誤的向下轉型

class A {
    public void print(){
        System.out.println("hello");
    }
}
class B extends A{
    public void print(){
        System.out.println("你好！");
    }
    public void funB(){ // 子類自己擴充的新方法
        System.out.println("********************");
    }
}
public class polymorphism{
    public static void main(String args[]){
        A a == new A(); // 父類物件
        B b = (B)a;// 強制轉換
        b.print()
    }
}
//結果：出錯           

        此時出現了“java.langClassException”異常資訊，，表示的是類轉換異常，本質指的是兩個沒有關係的類物件發生了強制轉換所帶來的問題
        所以要想進行向下轉型操作之前一定要首先保證發生了向上轉型，這樣才可以建立父子物件的關係
        但是可以發現這樣的轉型本身是會存在有安全隱患的，所以正在java中提供有一個關鍵字：instanceof，利用此關鍵字可以判斷某一個物件是否是指定類的例項
            物件 instanceof 類  返回boolean型別
        範例：觀察instanceof關鍵字的使用

class A {
    public void print(){
        System.out.println("hello");
    }
}
class B extends A{
    public void print(){
        System.out.println("你好！");
    }
    public void funB(){ // 子類自己擴充的新方法
        System.out.println("********************");
    }
}
public class polymorphism{
    public static void main(String args[]){
        A a == new A(); // 父類物件
        System.out.println(a instanceof A);
        System.out.println(a instanceof B);
        //B b = (B)a;// 強制轉換
        //b.print()
    }
}
/*
結果：
true
false
*/           

 

        範例：如果發生了向上轉型之後的判斷

class A {
    public void print(){
        System.out.println("hello");
    }
}
class B extends A{
    public void print(){
        System.out.println("你好！");
    }
    public void funB(){ // 子類自己擴充的新方法
        System.out.println("********************");
    }
}
public class polymorphism{
    public static void main(String args[]){
        A a == new B(); // 父類物件
        System.out.println(a instanceof A);
        System.out.println(a instanceof B);
        //B b = (B)a;// 強制轉換
        //b.print()
    }
}
/*
結果：
true
true
*/

               
        範例：利用 instanceof 保證轉型的正確性

class A {
    public void print(){
        System.out.println("hello");
    }
}
class B extends A{
    public void print(){
        System.out.println("你好！");
    }
    public void funB(){ // 子類自己擴充的新方法
        System.out.println("********************");
    }
}
public class polymorphism{
    public static void main(String args[]){
        A a == new B(); // 父類物件
        System.out.println(a instanceof A);
        System.out.println(a instanceof B);
        if(a instanceof B){
            B b = (B)a;// 強制轉換
            b.print()
        }
    }
}
/*
結果：
true
true
你好
*/

           
    總結
        向上轉型（90%）：為了實現引數型別的統一，但是向上轉型一定要與方法覆寫產生關聯
        向上轉型（1%）：為了呼叫子類特殊的方法實現，但是向下轉型前必須要首先發生向上轉型，會存在操作的安全性隱患，可以使用 instanceof 進行判斷，但是不推薦這樣使用
        不轉型（9%）：為了方便操作直接使用系統類或者是一些功能類，例如String 簡單java類


相關推薦

菜雞的Java課筆記 第二十二 物件多型性

本次只是圍繞著多型性的概念來進行講解，但是所講解的程式碼與實際的開發幾乎沒有關係，而且多型一定是在繼承性的基礎上才可以操作的，        而本次將使用類繼承的關係來描述多型的性質，實際的開發中不會出現普通類的繼承關係（一個已經完善的類不應該再被繼

菜雞的Java課筆記 第二十 方法的覆寫

1.方法的覆寫    當子類定義了與父類中的完全一樣的方法時（方法名稱，引數型別以及個數，返回值型別）這樣的操作就稱為方法的覆寫    範例：觀察方法的覆寫 class A{ public void print(){

菜雞的Java課筆記 第二十一 final 關鍵字

使用final定義類，屬性，方法            final在一些書中被稱為終結器，意思是：利用final定義的類不能夠有子類，利用final定義的方法不能夠被覆寫，利用final定義的變數就成為了常量，常量無法修

java基礎筆記（十一）多型

概念： 同一個物件，在不同時刻體現出不同的狀態 舉例： 貓是貓。貓是動物 Animal cat1 = new Cat(); 多型前提： 要有繼承關係 要有方法重寫（多型的體現） 要有父類引用指向子類 Animal cat1 = new Ca

菜雞的Java課筆記 第十四 String 類常用方法

/*String 類常用方法    將所有String類的常用方法全部記下來，包括方法名稱，引數作用以及型別    一個成熟的程式語言，除了它的語法非常完善之外，那麼也需要提供有大量的開發類庫    而需要知道的java

菜雞的Java課筆記 第十五 this 關鍵字

this 關鍵字                對於this關鍵字有三種用法:表示本類屬性，呼叫本類方法，當前物件    &nbs

菜雞的Java課筆記 第十六 引用傳遞

referenceDelivery    引用傳遞是整個java 的精髓，也是所有初學者最難學的地方        引用的本質：同一塊堆記憶體可以被不同的棧記憶體所指向    下面

菜雞的Java課筆記 第十九 繼承

繼承性的主要目的，繼承的實現，繼承的限制                繼承是面向物件中的第二大主要特點，其核心的本質在於：可以將父類的功能一直沿用下去    

菜雞的Java課筆記 第二十三 抽象類的概念

abstractClass 抽象類的概念        1.抽象類的基本定義        2.抽象類的使用原則        &

學習筆記第二十二節課

作業shell介紹 shell是一個命令解釋器，提供用戶和機器之間的交互。 用戶配置的最後一個段 就是shell 創建的普通的用戶 它的shell是bin bash 每個用戶都可以有自己的shell sentos7 的shell 是bash 除此之外還有 zsh ksh ，用起來和bash 很像，

C++筆記 第二十二課 物件的銷燬---狄泰學院

如果在閱讀過程中發現有錯誤，望評論指正，希望大家一起學習，一起進步。 學習C++編譯環境：Linux 第二十二課 物件的銷燬 1.物件的銷燬 生活中的物件都是被初始化後才上市的 生活中的物件被銷燬前會做一些清理工作 問題：C++中如何清理需要銷燬的物件 一般而言，需要銷燬的物

Java開發筆記（十二）布林變數論道與或非

在程式語言的設計之初，它們除了可以進行數學計算，還常常用於邏輯推理和條件判斷。為了實現邏輯判斷的功能，Java引入了一種布林型別boolean，用來表示“真”和“假”。該型別的變數只允許兩個取值，即true和false，其中true對應真值，而false對應假值。 如同數值變數擁有加減乘

Java自學筆記（十二）

幾個關鍵字（final/static) final：可以用來修飾類，類的成員，以及區域性變數 注意：final修飾的類不能被繼承，但可以繼承其他類，俗稱“太監類”？           final修飾的方法不可

201711671103《JAVA程式設計》第十二章多執行緒機制學習筆記

教材學習內容總結 1.執行緒是依附於程序的，程序是分配資源的最小單位，執行緒是比程序更小的執行單位。一個程序可以產生多個執行緒，形成多條執行線索。每條線索，即每個執行緒也有它自身的產生，存在和消亡過程，也是一個動態的概念。 2.JAVA 中的多執行緒機制：多執行緒是指一個應用程式同時存在好幾

Java基礎語法<十二> 泛型程序設計

清除 extend 原生態 cast color 強制 方式 限定 只為 1 意義 泛型程序設計意味著編寫的代碼可以被很多不同類型的對象所重用。 常見應用 ： ArrayList 2 K T V E ? object等的含義 類型變量使用大寫形式 E &ndash

JAVA-初步認識-第十二章-多線好處與弊端

提高 有一個 多個 bsp log 運行 spa 時間片 es2017 一. 看著多線程技術很好，為什麽不全都用多線程來解決問題呢？ 多線程是有弊端的，在下圖當中真的是在同時執行嗎？ Windows本身就是一個多任務同時執行的操作系統，誰在負責程序的執行，cpu。Cpu在

JAVA-初步認識-第十二章-多線程創建方式一繼承

class post 問題解決 創建子類 可能 父類 顯示 sta body 一. 既然是創建線程，那麽線程應該怎麽創建？在沒有學習java之前，這些程序是誰在操作執行的呢？是由我們所在的操作系統來完成的。Windows裏面有個任務管理器，它來管理這些任務，它來創建這些進

CLR via C#學習筆記-第十二章-泛型

vat message 靜態 定義 泛型接口 void 失敗 internal 運行時 泛型是CLR和編程語言提供的一種特殊機制，他支持另一種形式的代碼重用，即算法重用。 CLR允許創建泛型引用類型和泛型值類型，但不允許創建泛型枚舉類型。 此外CLR還允許創建泛型接口和泛型

CLR via C#學習筆記-第十二章-泛型基礎結構

12.2 泛型基礎結構 12.2.1 開放型別和封閉型別 具有泛型型別引數的型別仍然是型別，CLR同樣會為他建立內部的型別物件。 然而具有泛型型別引數的型別稱為開放型別，CLR禁制構造開放型別的任何例項。類似於CLR禁止構造介面型別的例項。 程式碼引用泛型類時可指定一組泛型型別實參。為所有型

CLR via C#學習筆記-第十二章-泛型接口、委托

pre 類型安全 sealed 2.4 span 接口 triangle 泛型類 保持 12.3 泛型接口 泛型接口的意義 顯然，泛型的主要作用就是定義泛型的引用類型和值類型。 然而對泛型接口的支持對CLR來說也很重要。沒有泛型接口，每次用非泛型接口如IComparable