詳解Java物件導向之多型的原理與實現

2022-05-28 18:01:50

何為多型

定義：

多型是指不同的子類在繼承父類別後分別都重寫覆蓋了父類別的方法，即父類別同一個方法，在繼承的子類中表現出不同的形式。系統在執行時（而非編譯時），能夠根據其型別確定呼叫哪個過載的成員函數的能力，稱為多型性。

特點：

（1）多型是物件導向的重要特性，簡單點說:“一個介面，多種實現”，就是同一種事物表現出的多種形態。

（2）多型就是抽象化的一種體現，把一系列具體事物的共同點抽象出來, 再通過這個抽象的事物, 與不同的具體事物進行對話。

（3）對不同類的物件發出相同的訊息將會有不同的行為。

（4）多型允許將子類的物件當作父類別的物件使用，某父類別型的參照指向其子型別的物件,呼叫的方法是該子型別的方法。這裡參照和呼叫方法的程式碼編譯前就已經決定了,而參照所指向的物件可以在執行期間動態繫結。

（5）多型分為編譯時多型（函數引數個數不同或者引數型別不同）和執行時多型（虛擬函式和純虛擬函式）。

作用：

（1）應用程式不必為每一個派生類編寫功能呼叫，只需要對抽象基礎類別進行處理即可。大大提高程式的可複用性。//繼承

（2）派生類的功能可以被基礎類別的方法或參照變數所呼叫，這叫向後相容，可以提高可擴充性和可維護性。

（3）隱藏實現細節，使得程式碼能夠模組化（虛擬函式）。

程式碼實現

運算類：

/**
 * @author : [LiuYanQiang]
 * @version : [v1.0]
 * @className : Operation
 * @description : [運算類]
 * @createTime : [2022/5/27 20:04]
 * @updateUser : [LiuYanQiang]
 * @updateTime : [2022/5/27 20:04]
 * @updateRemark : [描述說明本次修改內容]
 */
public abstract class Operation {
 
    private double _numberA;
    private double _numberB;
 
    public double get_numberA() {
        return _numberA;
    }
 
    public void set_numberA(double _numberA) {
        this._numberA = _numberA;
    }
 
    public double get_numberB() {
        return _numberB;
    }
 
    public void set_numberB(double _numberB) {
        this._numberB = _numberB;
    }
 
    public abstract double getResult();
}

加法類：

/**
 * @author : [LiuYanQiang]
 * @version : [v1.0]
 * @className : OperationAdd
 * @description : [加法類]
 * @createTime : [2022/5/27 20:13]
 * @updateUser : [LiuYanQiang]
 * @updateTime : [2022/5/27 20:13]
 * @updateRemark : [描述說明本次修改內容]
 */
public class OperationAdd extends Operation {
    @Override
    public double getResult() {
        double result = 0;
        result = super.get_numberA() + super.get_numberB();
        return result;
    }
}

減法類：

/**
 * @author : [LiuYanQiang]
 * @version : [v1.0]
 * @className : OperationSub
 * @description : [減法類]
 * @createTime : [2022/5/27 20:13]
 * @updateUser : [LiuYanQiang]
 * @updateTime : [2022/5/27 20:13]
 * @updateRemark : [描述說明本次修改內容]
 */
public class OperationSub extends Operation {
    @Override
    public  double getResult() {
        double result = 0;
        result = super.get_numberA() - super.get_numberB();
        return result;
    }
}

乘法類：

/**
 * @author : [LiuYanQiang]
 * @version : [v1.0]
 * @className : OperationMul
 * @description : [乘法類]
 * @createTime : [2022/5/27 20:15]
 * @updateUser : [LiuYanQiang]
 * @updateTime : [2022/5/27 20:15]
 * @updateRemark : [描述說明本次修改內容]
 */
public class OperationMul extends Operation {
    @Override
    public double getResult() {
        double result = 0;
        result = super.get_numberA() * super.get_numberB();
        return result;
    }
}

除法類：

/**
 * @author : [LiuYanQiang]
 * @version : [v1.0]
 * @className : OperationDiv
 * @description : [除法類]
 * @createTime : [2022/5/27 20:16]
 * @updateUser : [LiuYanQiang]
 * @updateTime : [2022/5/27 20:16]
 * @updateRemark : [描述說明本次修改內容]
 */
public class OperationDiv extends Operation {
    @Override
    public double getResult() {
        double result = 0;
        if (super.get_numberB() == 0) {
            System.out.println("除數不能為0");
        } else {
            result = super.get_numberA() / super.get_numberB();
        }
        return result;
    }
}

簡單工廠類：

/**
 * @author : [LiuYanQiang]
 * @version : [v1.0]
 * @className : OperationFactory
 * @description : [簡單工廠類]
 * @createTime : [2022/5/27 20:16]
 * @updateUser : [LiuYanQiang]
 * @updateTime : [2022/5/27 20:16]
 * @updateRemark : [描述說明本次修改內容]
 */
public class OperationFactory {
    public static Operation createOperation(String operate) {
        Operation operation = null;
        switch (operate) {
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
                break;
            case "*":
                operation = new OperationMul();
                break;
            case "/":
                operation = new OperationDiv();
                break;
        }
        return operation;
    }
}

使用者端主方法類：

/**
 * @author : [LiuYanQiang]
 * @version : [v1.0]
 * @className : Main
 * @description : [使用者端]
 * @createTime : [2022/5/27 20:18]
 * @updateUser : [LiuYanQiang]
 * @updateTime : [2022/5/27 20:18]
 * @updateRemark : [描述說明本次修改內容]
 */
public class Main {
    public static void main(String[] args) {
        Operation operation;
        operation=OperationFactory.createOperation("+");
        operation.set_numberA(1);
        operation.set_numberB(2);
        System.out.println(operation.getResult());
    }
}

多型理解

我們都知道封裝是為了讓類的呼叫者不需要知道類的實現細節，而多型能讓類的呼叫者連這個類的型別是什麼都不必知道，只需要知道這個物件具有某個方法即可。

因此，多型可以理解成是封裝的更進一步，讓類呼叫者對類的使用成本進一步降低，提高程式的可擴充性、可維護性、可複用性。

以上就是詳解Java物件導向之多型的原理與實現的詳細內容，更多關於Java多型的資料請關注it145.com其它相關文章！

詳解Java物件導向之多型的原理與實現

目錄

何為多型

程式碼實現

多型理解

熱門文章