在java中多态只要有两种表现：方法的重载与覆写 对象的多态性
对象的多态性主要分为以下两种类型：
向上转型：子类对象-->父类对象 子类的实例化对象用父类的对象接受
对于向上转型，程序会自动完成，格式如下：
对象向上转型：父类名 父类对象 = 子类对象
例如 ：
|
File file1 = new File("e:"+File.separator+"test2.txt"); FileInputStream inputStream = new FileInputStream(file); InputStream input = inputStream;
|
向下转型：父类对象-->子类对象
对于向下转型的时候，必须明确的指明要转型的子类类型，格式如下：
对象向下转型：子类名称 子类对象 = （子类）父类实例
如果方法被覆写，则调用覆写后的方法
|
class A{ // 定义类A public void fun1(){ // 定义fun1()方法 System.out.println("A --> public void fun1(){}") ; } public void fun2(){ this.fun1() ; // 调用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(){}") ; } }; public class PolDemo01{ public static void main(String asrgs[]){ B b = new B() ; // 实例化子类对象 A a = b ; // 向上转型关系 a.fun1() ; // 此方法被子类覆写过,调用覆写过的方法
a.fun3() ; } }; |
对于以上的程序：是通过其子类进行父类的实例化操作的，则如果调用的方法被子类覆写过，则肯定调用被覆写过的方法。
但是，转型之后，因为操作的是父类对象，所以本程序是无法找到子类中的新方法，但是可以找到被覆写的方法
向下转型：将父类对象变为子类对象，称为向下转型，向下转型需要采用强制的手段
|
class A{ // 定义类A public void fun1(){ // 定义fun1()方法 System.out.println("A --> public void fun1(){}") ; } public void fun2(){ this.fun1() ; // 调用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(){}") ; } }; public class PolDemo02{ public static void main(String asrgs[]){ A a = new B() ; // 向上转型关系 B b = (B)a ; // 发生了向下转型关系 b.fun1() ; b.fun2() ; b.fun3() ; } }; |
此时B类中存在三个方法，所以全部可以调用
但是在对象转型的时候，如果两个没有关系的对象之间发生了依赖关系，则肯定出现异常
|
class A{ // 定义类A public void fun1(){ // 定义fun1()方法 System.out.println("A --> public void fun1(){}") ; } public void fun2(){ this.fun1() ; // 调用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(){}") ; } }; public class PolDemo03{ public static void main(String asrgs[]){ A a = new A() ; // 实例化了一个父类对象但是a对象并不知道b对象的类继承a对象的类 B b = (B)a ; // 发生了向下转型关系 b.fun1() ; b.fun2() ; b.fun3() ; } }; |
如果想产生对象的向下转型，则肯定必须先产生一个向上转型：A a = new B() ;表示建立关系
对象的多态性的应用：
要求，设计一个方法，此方法可以接受A类的任意子类对象，并调用方法
方法一：不使用多态则只能重载
|
class A{ // 定义类A public void fun1(){ // 定义fun1()方法 System.out.println("A --> public void fun1(){}") ; } public void fun2(){ this.fun1() ; // 调用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(){}") ; } }; class C extends A{ public void fun1(){ // 此方法被子类覆写了 System.out.println("C --> public void fun1(){}") ; } public void fun5(){ System.out.println("C --> public void fun5(){}") ; } }; public class PolDemo04{ public static void main(String asrgs[]){ fun(new B()) ; // 传递B的实例 fun(new C()) ; // 传递B的实例 } public static void fun(B b){ b.fun1() ; // 调用覆写父类中的fun1()方法 } public static void fun(C c){ c.fun1() ; // 调用覆写父类中的fun1()方法 } }; |
如果按照以上的设计思路，每增加一个子类，则fun（）方法就必须重载一次，如果A有很多子类，则
会重载很多方法，显然不合理
此时使用多态，向上转型
|
class A{ // 定义类A public void fun1(){ // 定义fun1()方法 System.out.println("A --> public void fun1(){}") ; } public void fun2(){ this.fun1() ; // 调用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(){}") ; } }; class C extends A{ public void fun1(){ // 此方法被子类覆写了 System.out.println("C --> public void fun1(){}") ; } public void fun5(){ System.out.println("C --> public void fun5(){}") ; } }; public class PolDemo05{ public static void main(String asrgs[]){ fun(new B()) ; // 传递B的实例 fun(new C()) ; // 传递C的实例 } public static void fun(A a){ a.fun1() ; // 调用覆写父类中的fun1()方法 } }; |
