day08视频中的多态主板的例子。

1. /*
   
2.         需求：
   
3.         电脑运行实例
   
4.         电脑运行依赖于主板
   
5. */
   
6. 
   
7. interface PCI
   
8. {
   
9.         public void open();
   
10.         public void close();
    
11. }
    
12. 
    
13. class MainBoard
    
14. {
    
15.         public void run()
    
16.         {
    
17.                 System.out.println("maiboard run");
    
18.         }
    
19.         public void usePCI(PCI p)
    
20.         {
    
21.                 if ( p != null )
    
22.                 {
    
23.                          p.open();
    
24.                         p.close();
    
25.                 }
    
26.         }
    
27. }
    
28. 
    
29. class NetCard implements PCI
    
30. {
    
31.         public void open()
    
32.         {
    
33.                 System.out.println("netcard open");
    
34.         }
    
35.         public void close()
    
36.         {
    
37.                 System.out.println("netcard close");
    
38.         }
    
39. }
    
40. 
    
41. class SoundCard implements PCI
    
42. {
    
43.         public void open()
    
44.         {
    
45.                 System.out.println("soundcard open");
    
46.         }
    
47.         public void close()
    
48.         {
    
49.                 System.out.println("soundcard close");
    
50.         }
    
51. }
    
52. 
    
53. 
    
54. class DuoTai5
    
55. {
    
56.         public static void main(String[] args)
    
57.         {
    
58.                 MainBoard mb = new MainBoard();
    
59.                 mb.run();
    
60.                 mb.usePCI(null);
    
61.                 mb.usePCI(new NetCard());
    
62.                 mb.usePCI(new SoundCard());
    
63.         }
    
64. }
    

复制代码

例子中用接口实现。
对接口和抽象有些模糊
不知道这两种方式有何区别。
抽象

1. 
   
2. abstract class PCI
   
3. {
   
4.         public abstract void open();
   
5.         public abstract void close();
   
6. }
   
7. 
   
8. class MainBoard
   
9. {
   
10.         public void run()
    
11.         {
    
12.                 System.out.println("maiboard run");
    
13.         }
    
14.         public void usePCI(PCI p)
    
15.         {
    
16.                 if ( p != null )
    
17.                 {
    
18.                          p.open();
    
19.                         p.close();
    
20.                 }
    
21.         }
    
22. }
    
23. 
    
24. class NetCard extends PCI
    
25. {
    
26.         public void open()
    
27.         {
    
28.                 System.out.println("netcard open");
    
29.         }
    
30.         public void close()
    
31.         {
    
32.                 System.out.println("netcard close");
    
33.         }
    
34. }
    
35. 
    
36. class SoundCard extends PCI
    
37. {
    
38.         public void open()
    
39.         {
    
40.                 System.out.println("soundcard open");
    
41.         }
    
42.         public void close()
    
43.         {
    
44.                 System.out.println("soundcard close");
    
45.         }
    
46. }
    
47. 
    
48. 
    
49. class DuoTai5
    
50. {
    
51.         public static void main(String[] args)
    
52.         {
    
53.                 MainBoard mb = new MainBoard();
    
54.                 mb.run();
    
55.                 mb.usePCI(null);
    
56.                 mb.usePCI(new NetCard());
    
57.                 mb.usePCI(new SoundCard());
    
58.         }
    
59. }
    

复制代码

其实现在这个阶段没必要硬揪这两个的区别，等你学的深了，自然而然多久知道了，什么时候要定义接口，什么时候定义抽象方法
现在你就可以这么认为：接口是一种特殊的抽象类，因为接口中的方法都是抽象方法，而抽象类中可以定义实体方法。
学东西要灵活！！！

在你所定义的抽象类中所有的方法都是抽象的，跟接口几乎要一样了，而类要继承你编写的抽象类，只能继承一个，而接口可以实现多个，你所写的我感觉有点巧合，这样看问题确实看不出来有啥区别了，多练习，希望你早日明白