AJPFX关于多态的应用

要求设计一个方法，要求此方法可以接受A类的任意子类对象，并调用方法，此时，如果不使用对象多态性，那代码肯定会类似如下

1. class A{                    // 定义类A
2. public void Run1(){     // 定义Run1()方法
3. System.out.println("A类----Run1方法") ;
4. }
5. public void Run2(){
6. Run1() ;        // 调用父类的Run1()方法
7. }
8. }
9. class B extends A{
10. public void Run1(){     // 覆写父类中的Run1方法
11. System.out.println("B类----Run1方法") ;
12. }
13. public void Run3(){     // B类特有的方法
14. System.out.println("B类----Run3方法") ;
15. }
16. }
17. class C extends A{
18. public void Run1(){     // 覆写父类中的Run1方法
19. System.out.println("C类----Run1方法") ;
20. }
21. public void Run5(){     // C类特有的方法
22. System.out.println("C类----Run5方法") ;
23. }
24. }
25. public class Demo6{
26. public static void main(String asrgs[]){
27. Run(new B()) ;  // 传递B类的实例    B b = new B();
28. Run(new C()) ;  // 传递C类的实例    C c = new C();
29. }
30. public static void Run(B b){
31. b.Run1() ;      // 调用覆写父类中的Run1()方法
32. }
33. public static void Run(C c){
34. c.Run1() ;      // 调用覆写父类中的Run1()方法
35. }
36. }

复制代码

以代码虽然实现要求，但可以发现：如果按照如上方式完成程序，这就相当于产生了一个A类的子类时，Run()方法就要重载一次，则每一次扩充子类都要修改类本身，这样肯定不太好，那么如果使用对象多态性完成呢？具体代码如下

1. class A{                    // 定义类A
2. public void Run1(){     // 定义Run1()方法
3. System.out.println("A类----Run1方法") ;
4. }
5. public void Run2(){
6. Run1() ;        // 调用父类的Run1()方法
7. }
8. }
9. class B extends A{
10. public void Run1(){     // 覆写父类中的Run1方法
11. System.out.println("B类----Run1方法") ;
12. }
13. public void Run3(){     // B类特有的方法
14. System.out.println("B类----Run3方法") ;
15. }
16. }
17. class C extends A{
18. public void Run1(){     // 覆写父类中的Run1方法
19. System.out.println("C类----Run1方法") ;
20. }
21. public void Run5(){     // C类特有的方法
22. System.out.println("C类----Run5方法") ;
23. }
24. }
25. public class Demo6{
26. public static void main(String asrgs[]){
27. Run(new B()) ;  // 传递B类的实例，产生向上转移
28. Run(new C()) ;  // 传递C类的实例，产生向上转移
29. }
30. //接收父类对象
31. public static void Run(A a){//相当于 A a = new B() & A a = new C()
32. a.Run1() ;      // 调用覆写父类中的Run1()方法
33. }
34. }

复制代码

上代码中在Run()方法中使用了对象的多态性，所以可以接收任何子类的对象，这样无论子类如何增加，Run()方法都不用做任何的改变，因为发生了对象的向上转型关系后，调用的方法一定是被子类覆写过的方法。