Java多态

涂凌z

已于 2024-08-24 11:37:09 修改

阅读量545

点赞数 24

文章标签： java 开发语言

于 2024-08-24 11:27:28 首次发布

本文链接：https://blog.csdn.net/Qster/article/details/141496172

版权

什么是多态？

多态（Polymorphism）是面向对象编程（OOP）中的一个核心概念，它允许同一个接口或方法在不同对象上具有不同的实现方式。Java作为一种面向对象的编程语言，广泛地利用了多态特性来提高代码的灵活性和可扩展性。

多态使同一个行为具有多个不同表现形式或形态的能力。

即，同一个接口，使用不同的实例而执行不同操作，Java的多态性就是对象多种表现形式的体现。

就比如：

现实中，比如我们按下 F1 键这个动作：

如果当前在 Word 下弹出的就是 Word 帮助；
在 Windows 下弹出的就是 Windows 帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

多态存在的三个必要条件

继承：必须有继承关系的的父子类
重写：子类对于父类的某些方法进行了重写
父类引用指向子类对象，如：Parent p = new Child();（Parent父类引用指向了子类Child对象）

多态需要进行重写操作，我们来回顾一下什么是Java的重写,并对比一下重写和重载的区别;

重载:

方法名称相同;
参数列表不同(数据类型, 顺序, 参数的个数);
返回值不做要求.

重写（发生在父类与子类当中）

方法名称相同;
返回值相同(返回值构成父类子关系也可以);
参数列表相同(数据类型, 参数个数, 顺序).

区别点	重写(override)	重载(override)
参数列表	一定不能修改	必须修改
返回类型	一定不能修改（除非可以构成父子类关系）	可以修改
访问限定符	一定不能做更严格的限制（可以降低限制）	可以修改

同时，上面提到了父类引用指向子类对象，这个时候我们需要了解到一个概念：

向上转型：

子类引用的对象转换为父类类型称为向上转型。通俗地说就是是将子类对象转为父类对象。此处父类对象可以是接口。

多态本身是子类向父类向上转换（自动转换）的过程，这个过程是默许的，当父类引用指向一个子类对象时，就是向上转型

使用格式：

父类类型对象名 = new 子类类型（）；

与向上转型相对的，还有一个概念为向下转型

向下转型

向下转型是父类向子类转换的过程，这个过程需要强制转换，一个可以将父类对象转换为子类对象，可以使用强制类型转换的格式，这便是向下转型。

使用格式：

子类类型子类对象名 = （子类类型）父类对象名

下面我们来看一个经典案例来更好地理解多态的概念；

class A {
    public String show(D obj) {
        return ("A and D");
    }
 
    public String show(A obj) {
        return ("A and A");
    }
 
}
 
class B extends A{
    public String show(B obj){
        return ("B and B");
    }
 
    public String show(A obj){
        return ("B and A");
    }
}
 
class C extends B{
 
}
 
class D extends B{
 
}
 
public class Demo {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
 
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));

        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));

        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));
    }
}
//输出结果：
//1--A and A
//2--A and A
//3--A and D

//4--B and A
//5--B and A
//6--A and D

//7--B and B
//8--B and B
//9--A and D

前三个我们来画一下内存图来分析一下：