详解Java面向对象之多态的原理与实现

多态是指不同的子类在继承父类后分别都重写覆盖了父类的方法,即父类同一个方法,在继承的子类中表现出不同的形式。本文将详解多态的原理与实现,感兴趣的可以学习一下

何为多态

定义:

多态是指不同的子类在继承父类后分别都重写覆盖了父类的方法,即父类同一个方法,在继承的子类中表现出不同的形式。系统在运行时(而非编译时),能够根据其类型确定调用哪个重载的成员函数的能力,称为多态性。

特点:

(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多态的资料请关注编程学习网其它相关文章!

本文标题为:详解Java面向对象之多态的原理与实现

基础教程推荐