Java-面向对象（高级篇）--对象的多态性

对象多态性在面向对象中是一个最重要的概念，在Java中主要有两种体现形式：
1. 方法的重载和覆写
2. 对象的多态性
对于方法的重载和覆写在之前的讲解中，下面将重点介绍对象的的多态性。
对象的多态性主要分为以下两种类型：
（1） 向上转型：子类对象—》父类对象；
（2） 向下转型：父类对象—》子类对象；
对于向上转型，程序会自动完成，而对于向下转型时，必须明确的指明要转型的子类类型，格式如下：

对象向上转型：父类 父类对象 = 子类实例；对象向下转型：子类 子类对象 = （子类）父类对象；

下面进行对象向上转型的操作：
【对象向上转型】

class A{    public void fun1(){        System.out.println("A-->public void fun1()");    }    public void fun2(){        this.fun1();    }}class B extends A{    //覆写A中的方法    public void fun1(){        System.out.println("B-->public void fun()1");    }    //子类中自己定义的方法    public void fun3(){        System.out.println("B-->oublic void fun3()");    }}public class PolDemo01{    public static void main(String[] args){        B b=new B();//定义子类实例化对象        A a=b;//发生了向上转型的关系，子类--》父类        a.fun1();//此方法被子类覆盖    }}

程序运行结果：

B-->public void fun()1

以上程序就是一个对象向上转型的关系，从程序的运算结果中可以发现，此时虽然使用父类对象调用fun1()方法，但是实际上调用的方法是被子类覆写过的方法，也就是说，如果对象发生了向上转型关系后，所调用的方法一定是被子类覆写过的方法。但是在此时一定要注意，此时的对象a是无法调用B类中的fun3()方法的，因为此方法只在子类中定义而没有在父类中定义，如果要想调用子类中的自己定义的方法，则肯定要使用子类实例，所以此时可以将对象进行向下转型。
【对象向下转型】

class A{    public void fun1(){        System.out.println("A-->public void fun1()");    }    public void fun2(){        this.fun1();    }}class B extends A{    //覆写A中的方法    public void fun1(){        System.out.println("B-->public void fun()1");    }    //子类中自己定义的方法    public void fun3(){        System.out.println("B-->oublic void fun3()");    }}public class PolDemo01{    public static void main(String[] args){        A a=new B();//发生了向上转型关系，子类--》父类        B b=(B)a;//此时发生了向下转型关系        b.fun1();//调用方法被覆写的方法        b.fun2();//调用父类的方法        b.fun3();//调用子类定义的方法    }}

运行结果：

B-->public void fun()1B-->public void fun()1B-->oublic void fun3()

从以上程序中可以发现，如果要想调用子类自己的方法，则一定只能用子类的实例化对象，另外，在子类对象里调用从父类中继承过来的fun2()方法，fun2()方法要调用fun1()方法，由于此时fun1()方法已经被子类所覆写，所以此时调用的方法是被子类覆写过的方法。
对象向下转型的要求：
在对象向下转型前，必须首先发生对象向上转型，否则将出现对象转化异常。
了解了对象的多态性后，那么这个概念到底有什么用途哪？下面要求设计一个方法，要求此方法可以接收A类的任意子类对象，并调用方法，此时，如果不用对象的多态性，则肯定会使用以下形式的代码：
【不使用对象多态性实现功能】

class A{    public void fun1(){        System.out.println("A-->public void fun1()");    }    public void fun2(){        this.fun1();    }}class B extends A{    //覆写A中的方法    public void fun1(){        System.out.println("B-->public void fun1()");    }    //子类中自己定义的方法    public void fun3(){        System.out.println("B-->poublic void fun3()");    }}class C extends A{    public void fun1(){        System.out.println("C-->public void fun1()");    }    public void fun5(){        System.out.println("C-->public void fun3()");    }}public class PolDemo04{    public static void main(String[] args){        fun(new B());//传递B类实例        fun(new C());//传递C类实例    }    public static void fun(B b){//接收B类实例        b.fun1();    }     public static void fun(C c){//接收C类实例        c.fun1();    }}

运行结果：

B-->public void fun1()C-->public void fun1()

以上程序虽然实现了基本的要求，但是应该可以发现：如果按照以上的方式完成程序，则当产生一个A类的子类对象时，fun()方法就要被重载一次，则每一次扩充子类都必须修改类本身，这样肯定不方便，那么如果使用对象多态性完成可以很好地解决。
【使用对象的多态性】

class A{    public void fun1(){        System.out.println("A-->public void fun1()");    }    public void fun2(){        this.fun1();    }}class B extends A{    //覆写A中的方法    public void fun1(){        System.out.println("B-->public void fun1()");    }    //子类中自己定义的方法    public void fun3(){        System.out.println("B-->poublic void fun3()");    }}class C extends A{    public void fun1(){        System.out.println("C-->public void fun1()");    }    public void fun5(){        System.out.println("C-->public void fun3()");    }}public class PolDemo04{    public static void main(String[] args){        fun(new B());//传递B类实例，产生向上转型        fun(new C());//传递C类实例，产生向上转型    }    public static void fun(A a){//接收父类对象        a.fun1();    }}

运行结果：

B-->public void fun1()C-->public void fun1()

从上程序运行的结果发现，此时由于在fun()方法中使用了对象的多态性，所以可以接收任何的子类对象，这样无论子类如何增加，fun()方法都不用做任何的改变，因为一旦发生对象的向上转型关系之后，调用的方法一定是被子类覆写过的方法。