1. 
   
2. /**
   
3. * 多态：可以理解为事物存在的多种体验形态。
   
4. *                 多态自始至终都是子类对象在做着变化。
   
5. * 1.多态的体现
   
6. *         父类的引用指向了自己的子类对象。
   
7. *         父类的引用也可以接收自己的子类对象。
   
8. * 2.多态的前提
   
9. *         必须是类与类之间有继承或实现关系。
   
10. *         存在覆盖。
    
11. * 3.多态的好处
    
12. *         提高了程序的扩展性。
    
13. * 4.弊端
    
14. *        只能使用父类的引用访问父类的成员。
    
15. * 5.多态的应用
    
16. *         
    
17. * 在多态中成员函数（非静态）的特点：
    
18. * 在编译时期，参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，没有则失败。
    
19. * 在运行时期，参阅对象所属的类中是否有调用的方法。
    
20. * 总结：成员函数在调用时，编译看左边，运行看右边。
    
21. *
    
22. * 在多态中成员变量的特点：
    
23. * 无论编译和运行，都参考左边（引用型变量所属的类）。
    
24. *
    
25. * 在多态中静态成员函数的特点：
    
26. * 无论编译和运行，都参考左边。
    
27. * @author Qihuan
    
28. *
    
29. */
    
30. 
    
31. abstract class Animal {
    
32.         abstract void eat();
    
33. }
    
34. 
    
35. class Cat extends Animal {
    
36.         void eat() {
    
37.                 System.out.println("eat fish");
    
38.         }
    
39.         
    
40.         void catchMouse() {
    
41.                 System.out.println("catch mouse");
    
42.         }
    
43. }
    
44. 
    
45. class Dog extends Animal {
    
46.         void eat() {
    
47.                 System.out.println("eat bone");
    
48.         }
    
49.         
    
50.         void watchDoor() {
    
51.                 System.out.println("watch door");
    
52.         }
    
53. }
    
54. 
    
55. public class PolyPractice {
    
56.         public static void main(String[] args) {
    
57. //                Animal cat = new Cat();//类型提升，向上转型
    
58. //                cat.eat();
    
59. //                Cat c = (Cat) cat;//强制将父类引用转成子类类型。向下转型。
    
60. //                c.catchMouse();
    
61.                
    
62.                 function(new Dog());
    
63.         }
    
64.         
    
65.         public static void function(Animal a) {
    
66.                 a.eat();
    
67.                 if(a instanceof Cat){
    
68.                         Cat c = (Cat) a;
    
69.                         c.catchMouse();
    
70.                 }else if(a instanceof Dog){
    
71.                         Dog d = (Dog) a;
    
72.                         d.watchDoor();
    
73.                 }
    
74.         }
    
75. }
    

复制代码

1. package practice;
   
2. 
   
3. /**
   
4. * 多态练习2
   
5. * 需求：电脑运行实例。
   
6. * @author Qihuan
   
7. *
   
8. */
   
9. 
   
10. //PCI
    
11. interface PCI {
    
12.         public void open();
    
13. }
    
14. 
    
15. //主板类
    
16. class MainBoard {
    
17.         public void run() {
    
18.                 System.out.println("mainboard running");
    
19.         }
    
20.         public void usePCI(PCI p) {
    
21.                 if (p != null) {
    
22.                         p.open();
    
23.                 }
    
24.         }
    
25. }
    
26. 
    
27. //网卡类
    
28. class NetCard implements PCI{
    
29.         public void open() {
    
30.                 System.out.println("netcard running");
    
31.         }
    
32. }
    
33. 
    
34. //声卡类
    
35. class SoundCard implements PCI{
    
36.         public void open() {
    
37.                 System.out.println("soundcard running");
    
38.         }
    
39. }
    
40. 
    
41. public class PolyPractice1 {
    
42.         public static void main(String[] args) {
    
43.                 MainBoard mb = new MainBoard();
    
44.                 mb.run();
    
45.                 mb.usePCI(null);
    
46.                 mb.usePCI(new NetCard());
    
47.                 mb.usePCI(new SoundCard());
    
48.         }
    
49. }
    

复制代码

谢谢分享