面向对象三大特性之多态性

这篇文章主要介绍面向对象三大特性中的多态性，内容主要包括：

• 什么是多态
• 多态的实现
• 向下转型与instanceof操作符

什么是多态

多态这个词的字面意思就是多种形态，例如在实际的生活中一个大学生jone，他在校园内是一个学生，可以享受学校的政策，但他同时也是一个人，需要受到宪法制约。jone有学生和人两种形态，jone具体表现为那种形态需要根据jone所处的环境而定了。
这个属性在操作电脑的快捷键时也得到了体现。我们平时在一个软件中按ctrl+s保存，保存的时当前正在操作的软件的文件，而不是其他程序中的文件。
在Java中也是这样，程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编译时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。即如果在创建一个父类的对象，在编译阶段会表现为这个父类，但是在程序运行的时候可能运行的是它的某一个子类。
这样做的好处就是可以增加代码的复用性，减少子类之间的耦合，同时也使得编程更加的灵活。

多态的使用

下面这条语句表现了java中多态性的常见使用：

父类 变量名 = new 子类()

例如

animal dog = new Dog();

这时父类的引用指向的子类的对象（animal类型的引用指向了它的子类Dog），也就是说，在编阶段Java依然会认为dog是一个animal类，但是在实际运行的时候将运行的是Dog类中重写的方法，这就表现了java的动态绑定特性。这时调用方法称为虚拟方法调用。
在使用多态性或者说虚拟方法调用时，需要注意以下几点：

• 需要有类的继承关系
• 要有方法的重写
• 多态性只适用于方法，不适用于属性

在Java中方法调用的优先级为：

• this.show(O)
• super.show(O)
• this.show((super)O)
• super.show((super)O)

即优先在自己的子类中查找符合调用条件的方法，如果没有就在自己的超类中找，如果依然没有就将形参引用提升为其父类，在进行查找。

经典例题

接下来看一个网上比较经典的例子：

//假设又以下的类及其之间的关系
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...{}

进行实例化

A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C(); 
D d = new D();

以下输出的时什么

System.out.println(a1.show(b)); 
/*
这里a1是一个类A的引用，A类是这里所有类的超类，且引用的对象也是一个A类，所以将会在A类中查找适合的方法。但是发现A类中没有形参是B类的引用，所以将B类"升级"为其父类A，这是符合调用方法：public String show(A obj)的方法，所以将会打印：A and A。
*/

System.out.println(a1.show(c));
 /*
 这里c是一个C类的引用且其引用的对象也是C类，但是在A中没有适合的方法，所以将c'提升'至它的父类A，这是发现public String show(A obj)的方法符合，所以打印：A and A
 */

System.out.println(a1.show(d)); 
/*
这里d是一个D类的引用，且引用的对象也是一个D类，A类中也恰好又适合的方法：public String show(D obj)，所以将会打印：A and D
*/

System.out.println(a2.show(b));
/*
这里a2是一个类A的引用，但是其引用的对象是其子类B，所以执行的将会值B类中的方法，这是传入的b是一个A类的引用，所以将会执行B类的public String show(A obj)方法，打印：B and A
*/

System.out.println(a2.show(c));
/*
这里同样执行的是B类的方法，传入的c是一个C类的引用，但是B类中没有合适的方法，A类中也没有,所以将会将c'提升'为A类，执行public String show(A obj)方法，打印：B and A
*/

System.out.println(a2.show(d));
/*
这里同样执行的是B类的方法，但是没有引用D类的方法，于是查找A类中的方法，将执行public String show(D obj)方法，打印：A and D
*/

向下转型

再多态的概念中提到，虽然在多态性中内存中加载了子类的属性和方法，但是由于变量声明为父类类型，导致编译时只能调用父类的属性和已经被子类重写方法。
为了解决这个问题，我们可以将相应的引用强制转换成其子类。格式如下:

子类 变量名 = (子类)父类变量名

这就是将一个超类直接指定为他的某一个子类，也就是向下转型。(多态可以理解为向上转型)

但是如果直接这这样写会带来一些问题：

假设Person类是Man类和Women类的超类
例一：

//编译可以通过，但不能成功运行
Person p1 = new Women();
Man m1 = (Man)p1//这里的p1实例化的是women类，强制转换成men类显然不行

Person p2 = new Person();
Man m2 = (Man)p2//Person类是Man类的超类，不能将一个子类强制转换成他的超类。

例二：

//编译和运行都能通过，但是当调用时会出问题
Object obj = new Woman(); 
Person p  = (Person)obj;//因为你Object类时一切类的超类，所以这里的语法没有问题，但是Women类时Person类的子类
//这里实际上也是将子类强制转换为了他的超类，所以也是不行的

正确的转换因该如下

Person p1 = new Man();
Man m1 = (Man)p1;//这里强制转换的必须时p1实际引用的子类对象

为了避免出现上面的问题，一般在进行强制转换前用instanceof判断一下

instanceof运算符的前一个操作符是一个引用变量，后一个操作数通常是一个类（可以是接口），用于判断前面的对象是否是后面的类，或者其子类、实现类的实例。如果是返回true，否则返回false。

Person p1 = new Person();
Person p2 = new Men();
Men m = new Men();
Women w = new Women();

System.out.println(p1 instanceof Men);//将会返回true，因为Person是Men的超类，但是进行强制转换之后会出错
System.out.println(p2 instanceof Men);//将会返回true
System.out.println(p2 instanceof Women);//将会返回false，因为p2指向的是一个Men类型的对象
System.out.println(w instanceof Men);//将会报错，因为Men类和Women类直接没有继承关系

思维导图版笔记点击此处

本文作者： CodeWhat
本文链接： https://quandongli.github.io/post/6eaacac6.html
版权声明： 本作品采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可。转载请注明出处！

赏

谢谢你请我吃糖果

支付宝

微信