在讨论向上转型和向下转型之前，先复习下多态。如果有错误的地方，希望能够指出，大家共同进步！
什么是多态？
多态（Polymorphism）即同一操作作用于不同的对象，可以有不同的解释，产生不同的结果。
多态的分类
多态一般分为两种：
-
重载式多态
- 重载式多态，也叫编译时多态。也就是说这种多态在编译时已经确定好了。方法名相同而参数列表不同的一组方法就是重载。在调用这种重载的方法时，通过传入不同的参数最后得到不同的结果。
-
重写式多态
- 重写式多态，也叫运行时多态。这种多态通过动态绑定（dynamic binding）技术来实现，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。也就是说，只有程序运行起来，你才知道调用的是哪个子类的方法。这种多态通过函数的重写以及向上转型来实现。
多态实现的必要条件
-
继承或实现接口
- 在多态中必须存在有继承关系的子类和父类或者接口及其实现类
-
重写
- 子类对父类中某些方法进行重新定义，再调用这些方法时就会调用子类的方法
-
向上转型
- 父类引用指向子类对象叫做向上转型。
向上转型与向下转型
向上转型，上面已经说了，向下转型是子类引用指向父类对象（父类型，实例是子类的实例化），通常需要进行强制类型转换
案例
//水果类，拥有一个show()方法
class Fruits {
public void show() {
System.out.println("我水果之父，打钱!");
}
}
// 苹果类，实现父类水果，并重写show()方法
class Apple extends Fruits {
@Override
public void show() {
System.out.println("我苹果，打钱!");
}
public void color() {
System.out.println("我是红色的苹果。");
}
}
// 香蕉类，实现父类水果，并重写show()方法
class Banana extends Fruits {
@Override
public void show() {
System.out.println("我香蕉，打钱!");
}
public void color() {
System.out.println("我是黄色的香蕉。");
}
}
//测试类
public class Test {
public static void main(String[] args) {
//向上转型
Fruits fruit = new Apple();
fruit.show();
fruit = new Banana();
fruit.show();
}
}
/**
运行结果：
我苹果，打钱!
我香蕉，打钱!
*/
这就是向上转型，Fruits fruit = new Apple();将子类对象Apple转化为父类对象Fruits，这个时候fruit引用指向的是子类对象，所以调用的方法是子类方法。
向上转型的好处
- 减少重复代码
- 提高代码扩展性
向上转型需要注意的问题
向上转型时，子类单独定义的方法会丢失。比如，上面案例中的Apple类和Banana类都定义了自己的color方法，当进行了向上转型后，fruit引用指向Apple类的实例时是访问不到color方法的，fruit.color()会报错。
向下转型
子类引用指向父类对象（父类型，实例是子类的实例化），通常需要进行强制类型转换，但是这里有个需要注意的问题。
//还是上面的Fruits、Apple、Banana
Fruits fruit = new Apple(); //向上转型
Apple apple = (Apple)fruit; //向下转型，强制类型转换
apple.color(); //输出：我是红色的苹果。
Banana banana = (Banana) fruit; //报错：java.lang.ClassCastException
Fruits f1 = new Fruits();
Apple a1 = (Apple) f1; //报错：java.lang.ClassCastException
为什么Apple apple = (Apple)fruit;没有报错可以转换成功呢？因为apple本身就是Apple对象，所以理所当然可以向下转型为Apple，所以自然也就不能转换成Banana，人可以干出指鹿为马的事情，但是编译器不行，不会指着苹果说是香蕉。
而f1是Fruits对象，它也不能被向下转型为任何子类对象，就好比你买了一个不知名的水果，你只知道它是一种水果，但是你不能直接说这个水果是苹果或者香蕉。
向下转型需要注意的问题
- 向下转型的前提是父类引用指向的是子类对象，也就是说，向下转型之前，它得先进行过向上转型。
- 向下转型只能转型为本类对象（苹果是不能变成香蕉的）。
多态的经典案例
简单的多态和转型，相信大家都会，最后来个复杂的，一个经典案例：
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
*/
结果1、2、3还好理解，从4开始就糊涂了，4为什么不是“B and B”呢？
这里我们先看一句话：当父类对象引用变量引用子类对象时，被引用对象的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在父类中定义过的，也就是说被子类覆盖的方法。这句话对多态进行了一个概括，其实在继承中对象方法的调用存在一个优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。
现在来分析一下4，a2.show(b)：
- a2是A类型的引用变量，this就代表了A，但是a2所引用的是B对象（new B()），那么按照上面那句话的意思，
a2.show(b)就应该要调用B类中的show(B obj)，产生的结果就是”B and B“，但是运行结果明显不是，别忘了上面的话后面还有一句，必须是父类中定义过的方法才行，然而B的父类A中并没有show(B obj)，难道上面的话是错误的？其实不是，因为它仍然要按照继承链中调用方法的优先级来确定，所以它才会在A类中找到show(A obj)，由于B中重写了该方法，所以才会调用B类中的方法，所以得到的结果是B and A。 - 上面的解释可能有点绕，很多大佬在博客中也是这么写的，现在我来说说自己的理解。
A a2 = new B();这行代码进行了向上转型，前面说过向上转型之后，子类单独定义的方法会丢失（不能被调用），那么这个时候a2可以调用的方法就剩下A类中的show(D obj)、show(A obj)以及B类中的show(A obj)，那么按照继承链中调用方法的优先级来判断，先到类A中找到show(A obj)，由于B类中进行了重写 ，所以调用的是B类中的show(A obj)。
那么按照我的理解，来分析下5，a2.show(c)。
- 首先
A a2 = new B();进行向上转型，那么，a2能调用的方法还是A类中的show(D obj)、show(A obj)以及B类中的show(A obj)，按照继承链中调用方法的优先级，a2是A类型的引用变量，所以继承链方法调用优先级中this.show(O)的this就代表了A，显然A类中的方法不满足这个要求，跳过，所以接下来是super.show(O)，A类没有父类（除了Object类），再次跳过，然后是this.show((super)O)，C继承于B，B继承于A，所以show(A obj)满足要求，由于a2变量引用的对象类型是B类型，而B类型又重写了该方法，所以最终调用的是B类中的show(A obj)，所以最后输出为B and A。
能够分析出4和5，那么接下来的就很简单了，看到这篇文章的话，可以自己试着分析下。如果有错误的地方，希望能够指出，大家共同进步！
如果对你有帮助，点击链接，关注一下吧！
网友评论