何为多态
定义：
多态是指不同的子类在继承父类后分别都重写覆盖了父类的方法，即父类同一个方法，在继承的子类中表现出不同的形式。系统在运行时（而非编译时），能够根据其类型确定调用哪个重载的成员函数的能力，称为多态性。
特点：
（1）多态是面向对象的重要特性，简单点说:[一个接口，多种实现]，就是同一种事物表现出的多种形态。
（2）多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。
（3）对不同类的对象发出相同的消息将会有不同的行为。
（4）多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定。
（5）多态分为编译时多态（函数参数个数不同或者参数类型不同）和运行时多态（虚函数和纯虚函数）。
作用：
（1）应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承
（2）派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。
（3）隐藏实现细节，使得代码能够模块化（虚函数）。
代码实现
运算类：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
/** * @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(); } |
加法类：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
/** * @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; } } |
减法类：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
/** * @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; } } |
乘法类：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
/** * @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; } } |
除法类：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
/** * @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; } } |
简单工厂类：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
/** * @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; } } |
客户端主方法类：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
/** * @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多态的资料请关注其它相关文章！
原文链接：https://blog.csdn.net/weixin_44684272/article/details/125011881
查看更多关于详解Java面向对象之多态的原理与实现的详细内容...