Java中多态的表现形式

概念：同一个类实例的相同方法在不同情形下有不同的表现形式

在Java中，对于多态的核心表现主要有以下两点：

1. 方法多态：

① 方法重载：同一个方法名称可以根据参数的类型或个数不同调用不同的方法体

② 方法覆写：同一个父类的方法可以根据实例化子类的不同也有不同的实现

方法多态之前的文章里面详细阐述过，在此不再赘述。

2. 对象多态：

① 向上转型(90%)：

天然发生，认爹过程，指的是将子类对象变成父类对象

语法：父类父类引用 = 子类实例;，例如Person per = new Student();

class Person {public void print() {System.out.println("父类");}
}
class Student extends Person {public void print() {System.out.println("子类");}
}
public class XiangShangZhuanXing {public static void main(String[] args) {Person per = new Student();per.print();}
}

结论：不管是否发生了向上转型，核心本质还是在于：你使用的是哪一个子类(new在哪里)，而且调用的方法是否被子类所覆写了。

应用场景：参数统一化

例如：要求定义一个方法，这个方法可以接收Person类的所有子类实例，并调用Person类的方法。

class Person {public void print() {System.out.println("1.我是人类！");}
}
class Student extends Person {public void print() {System.out.println("2.我是学生！");}
}
class Worker extends Person {public void print() {System.out.println("3.我是工人！");}
}
public class CanShuTongYiHua {public static void main(String[] args) {//Person per = new Student();WhoYouAre(new Student());//Person per = new Worker();WhoYouAre(new Worker());}public static void WhoYouAre(Person per) {per.print();}
}

② 向下转型(1%)：

需要强转，指的是将父类对象变成子类对象

语法：子类子类实例 = (子类)父类实例;，例如Student stu = (Student) per;

问题：向下转型存在的意义或者为什么我们需要向下转型？

class Person {public void print() {System.out.println("父类");}
}
class Student extends Person {public void print() {System.out.println("子类");}public void fun() {System.out.println("只有子类有");}
}
public class XiangXiaZhuanXing {public static void main(String[] args) {Person per = new Student();per.print();System.out.println("==========");Student stu = (Student) per;stu.fun();}
}

结论：在上述代码中父类能调用的就只有本类定义好的方法，并没有Student类中的fun()方法，如果父类要想调用fun()方法就只能进行向下转型处理，总的来说就是当需要子类扩充操作的时候就要采用向下转型。

应用场景：发生在父类引用需要调用子类扩充方法时，才发生向下转型变为子类引用调用其扩充方法

注意：并不是所有的父类对象都可以向下转型，如果要想进行向下操作之前，前提是一定要首先发生向上转型，否则在转型时会出现ClassCastException(运行时异常，类型转换异常，发生在两个毫无关系的两个类之间的强转时)

观察错误转型：

class Person {public void print() {System.out.println("父类");}
}
class Student extends Person {public void print() {System.out.println("子类");}public void fun() {System.out.println("只有子类有");}
}
public class XiangXiaZhuanXing {public static void main(String[] args) {Person per = new Person();per.print();System.out.println("==========");Student stu = (Student) per;stu.fun();}
}

结论：上述代码进行向下转型之前Person per = new Person();没有先进行向上转型，所以出现类型转换异常这个错误。
问题：如果向下转型存在安全隐患，那么如何转型才靠谱呢？

最好的做法就是先进行判断，而后再进行转型，那么就可以依靠关键字instanceof实现。

引用对象 instanceof 类：表示该引用能指向该类，返回true表示可以指向，返回flase表示不能指向。

因此，向下转型的标准格式为：

if(!(per instanceof Student)) {per = new Student();   // 先建立起联系
}
Student stu = (Student) per;

观察instanceof操作：

class Person {public void print() {System.out.println("父类");}
}
class Student extends Person {public void print() {System.out.println("子类");}public void fun() {System.out.println("只有子类有");}
}
public class XiangXiaZhuanXing {public static void main(String[] args) {Person per = new Person();//避免ClassCastExceptionif(!(per instanceof Student)) {per = new Student();}Student stu = (Student) per;stu.fun();}
}

结论：我们可以看到加上instanceof之后就算没有先向上转型，向下转型依然是可以进行的。

总结：

对象的多态性(向上转型或向下转型)本质在于方法的覆写。
通过对象的向上转型可以实现接收参数的统一，向下转型可以实现子类扩充方法的调用(一般不操作向下转型，有安全隐患)。
两个没有关系的类对象是不能够进行转型的，一定会出现ClassCastException。