多态性，是面向对象的最后一个特征，也是最重要的特征，掌握多态性可以设计更好的程序结构。
实际上方法的重载就是一种多态性的体现：
方法名称相同，根据传入参数的类型或个数的不同完成的功能也不同。
另外一种多态性就是指的对象的多态性：
· 子类对象向父类对象转型（向上转型）
· 父类对象向子类对象转型（向下转型）
· 对象间的互相转型问题
强调：
一个类绝对不能继承一个已经实现好了的类。此处讲解的时候只是为了阐述概念，才使用了类与类的直接继承，但是开发中此种类型的代码肯定不存在。
观察以下程序，初步认识对象的转型：
|
class A{
public void fun1(){
System.out.println("A --> public void fun1(){}") ;
}
public void fun2(){
this.fun1() ;
}
};
class B extends A{
public void fun1(){
System.out.println("B --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B --> public void fun3(){}") ;
}
}; |
以上代码可以发现，子类B，继承了父类A，同时在子类中覆写了类A中的fun1方法，也增加了自己新的fun3方法。
|
class A{
public void fun1(){
System.out.println("A1 --> public void fun1(){}") ;
}
public void fun2(){
this.fun1() ;
}
};
class B extends A{
public void fun1(){
System.out.println("B1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B2 --> public void fun3(){}") ;
}
};
public class Demo10{
public static void main(String args[]){
A a = new B() ;
a.fun1() ;
a.fun2() ;
}
}; |
以上代码，无论是直接使用子类，还是子类向父类转型，发现最终结果调用的都是被子类覆写过的方法。
向上转型的关系：只要发生了向上转型，则一切的操作方法以子类为标准。
如果向上转型完成之后，那么一定可以把父类对象变为子类对象。但是此时就需要强制了。
|
class A{
public void fun1(){
System.out.println("A1 --> public void fun1(){}") ;
}
public void fun2(){
this.fun1() ;
}
};
class B extends A{
public void fun1(){
System.out.println("B1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B2 --> public void fun3(){}") ;
}
};
public class Demo10{
public static void main(String args[]){
A a = new B() ;
B b = (B)a ;
b.fun1() ;
b.fun2() ;
}
}; |
现在观察以下代码：
|
class A{
public void fun1(){
System.out.println("A1 --> public void fun1(){}") ;
}
public void fun2(){
this.fun1() ;
}
};
class B extends A{
public void fun1(){
System.out.println("B1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B2 --> public void fun3(){}") ;
}
};
public class Demo11{
public static void main(String args[]){
A a = new A() ;
B b = (B)a ;
b.fun2() ;
}
}; |
java.lang.ClassCastException：
为类型转换异常。两个没有任何关系的对象直接进行转型了，就出现此错误。
注意：
如果要进行向下转型之前，首先必须建立关系，即：必须先发生向上转型之后，才可以进行向下转型。为了建立关系。
对象多态性所带来的好处？
对象多态性在传递参数上可以体现出其优点，下面看两组代码，第一组是没有使用对象多态性的时候：
|
class A{
public void fun1(){
System.out.println("A1 --> public void fun1(){}") ;
}
public void fun2(){
this.fun1() ;
}
};
class B extends A{
public void fun1(){
System.out.println("B1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B2 --> public void fun3(){}") ;
}
};
class C extends A{
public void fun1(){
System.out.println("C1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("C2 --> public void fun3(){}") ;
}
};
public class Demo12{
public static void main(String args[]){
fun(new B()) ;
fun(new C()) ;
}
// 定义一个方法，此方法可以接收A的子类对象
public static void fun(B b){
b.fun2() ;
}
public static void fun(C c){
c.fun2() ;
}
}; |
如果代码按以上格式编写会有那些问题？
· 每增加一个子类，就要增加一个方法，所以可以发现代码重复修改。
如果此时使用了对象多态性的概念，则代码可以修改为以下结构（所有的操作方法以被子类覆写过的方法为标准操作）：
|
class A{
public void fun1(){
System.out.println("A1 --> public void fun1(){}") ;
}
public void fun2(){
this.fun1() ;
}
};
class B extends A{
public void fun1(){
System.out.println("B1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B2 --> public void fun3(){}") ;
}
};
class C extends A{
public void fun1(){
System.out.println("C1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("C2 --> public void fun3(){}") ;
}
};
public class Demo13{
public static void main(String args[]){
fun(new B()) ;
fun(new C()) ;
}
// 不管有多少个子类，都用父类对象接收，因为可以自动发生向上转型关系
public static void fun(A a){
a.fun2() ;
}
}; |
感觉到一点：在继承关系中，父类的设计是最重要的，只要父类把功能定义好了，则所有代码都好写。
新的要求：
现在希望可以对程序的功能稍微有一些扩充，判断，如果传入的是B类对象，则可以调用fun3方法，如果传入的是C类对象，也可以调用C类的fun3方法。
要完成此功能，肯定要使用向上转型。
要完成此功能，必须对传入对象的类型进行判断，判断此对象到底是属于那个类的实例。
instanceof关键字完成：
· 功能：判断一个对象是否是某个类的实例，返回boolean
· 语法：对象 instanceof 类
|
class A{
public void fun1(){
System.out.println("A1 --> public void fun1(){}") ;
}
public void fun2(){
this.fun1() ;
}
};
class B extends A{
public void fun1(){
System.out.println("B1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B2 --> public void fun3(){}") ;
}
};
class C extends A{
public void fun1(){
System.out.println("C1 --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("C2 --> public void fun3(){}") ;
}
};
public class Demo14{
public static void main(String args[]){
fun(new B()) ;
fun(new C()) ;
}
// 不管有多少个子类，都用父类对象接收，因为可以自动发生向上转型关系
public static void fun(A a){
a.fun2() ;
if(a instanceof B){
B b = (B)a ;
b.fun3() ;
}
if(a instanceof C){
C c = (C)a ;
c.fun3() ;
}
}
}; |
转型原则：
在转型之前最好先判断一下一个对象是否是某个类的实例，判断通过之后在进行向下转型操作。
转型概念清楚之后就可以利用此概念完善抽象类与接口。