Java基础十--接口

Java基础十--接口

一、接口的定义和实例

  1 /*
  2 abstract class AbsDemo
  3 {
  4     abstract void show1();
  5     abstract void show2();
  6 }
  7 
  8 当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用
  9 另一种形式定义和表示，就是 接口 interface。
 10 */
 11 
 12 //定义接口使用的关键字不是class，是interface.
 13 //interface编译后还是.class文件，其实本质上还是class.
 14 
 15 /*
 16 接口和类中是实现，接口和接口之间是多继承，为什么可以多继承，因为没有方法体，能否多继承的实质看有没有方法体
 17 */
 18 
 19 /*
 20 对于接口当中常见的成员：而且这些成员都有固定的修饰符。
 21 1，全局常量: public  static final 
 22 
 23 2，抽象方法。public abstract
 24  
 25 修饰词你自己不写的话程序给你加上。所以我们都写上，那样阅读性强。
 26 
 27 由此得出结论，接口中的成员都是公共的权限.
 28 
 29 继承没有实现成员变量，方法也是抽象方法，没有函数体的方法，所以实现接口和继承类不冲突，因为接口和类里面的东西不一样
 30 */
 31 interface Demo
 32 {
 33     public static final int NUM = 4;//static和final和public你不写程序会给你默认加上
 34 
 35     public abstract void show1();//public和abstract你不写程序会给你默认加上
 36     public abstract void show2();
 37 }
 38 //类与类之间是继承关系，类与接口直接是实现关系。 
 39 /*
 40 接口不可以实例化。
 41 
 42 只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。
 43 否则，这个子类就是一个抽象类。
 44 
 45 */
 46 
 47 
 48 class DemoImpl implements /*实现*/Demo
 49 {
 50     public void show1()
 51     {}
 52 
 53     public void show2()
 54     {
 55     
 56     }
 57 }
 58 
 59 
 60 /*
 61 在java中不直接支持多继承，因为会出现调用的不确定性。
 62 所以java将多继承机制进行改良，在java中变成了多实现。
 63 
 64 一个类可以实现多个接口。 
 65 
 66 */
 67 
 68 interface A
 69 {
 70     public void show();
 71 }
 72 
 73 interface Z
 74 {
 75     public int add(int a,int b);
 76 }
 77 
 78 
 79 
 80 
 81 class Test implements A,Z//多实现
 82 {
 83     
 84     public int add(int a,int b)
 85     {
 86         return a+b+3;    
 87     }
 88     /**/
 89     public void show(){}
 90     
 91 }
 92 
 93 
 94 
 95 
 96 
 97 /*
 98 一个类在继承另一个类的同时，还可以实现多个接口。
 99 
100 
101 
102 */
103 class Q
104 {
105     public void method()
106     {}
107 }
108 
109 abstract class Test2 extends Q implements A,Z
110 {
111 
112 }
113 /*
114 接口的出现避免了单继承的局限性。
115 
116 */
117 
118 
119 interface CC
120 {
121     void show();
122 }
123 interface MM
124 {
125     void method();
126 }
127 
128 interface QQ extends  CC,MM//接口与接口之间是继承关系，而且接口可以多继承。 
129 {
130     void function();
131 }
132 
133 class WW implements QQ
134 {
135 //覆盖3个方法。
136     public void show(){}
137     public void method(){}
138     public void function(){}
139 }
140 
141 
142 class InterfaceDemo 
143 {
144     public static void main(String[] args) 
145     {
146 
147         Test t = new Test();
148         t.show();
149 
150 //        DemoImpl d = new DemoImpl();    
151 //        System.out.println(d.NUM);
152 //        System.out.println(DemoImpl.NUM);
153 //        System.out.println(Demo.NUM);
154     }
155 }

 

二、接口和抽象类的区别

 1 /*
 2 抽象类和接口的异同点：
 3 
 4 相同点：
 5     都是不断向上抽取而来的。
 6 
 7 
 8 不同点：
 9     1，抽象类需要被继承，而且只能单继承。
10        接口需要被实现，而且可以多实现。 
11     2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
12        接口中只能定义抽象方法，必须由子类去实现。 
13     3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。
14        接口的实现是 like a 关系，在定义体系额外功能。
15 
16 
17 
18 
19 犬按功能分：有导盲犬，搜爆犬。
20 
21 
22 abstract class 犬
23 {
24     abstract void 吼叫();
25 }
26 
27 //abstract class 导盲
28 interface 导盲
29 {
30     abstract void 导盲();
31 }
32 
33 
34 class 导盲犬 extends 犬 implements 导盲
35 {
36     public void 吼叫()
37     {
38     }
39     public void 导盲(){}
40 }
41 
42 
43 
44 //在不同的问题领域中，有不同的分析方式。
45 学员：
46     学习。
47     抽烟学员
48 
49 
50 
51 
52 烟民。
53     
54 
55 
56 
57 
58 
59 
60 
61 */
62 
63 class InterfaceDemo 
64 {
65     public static void main(String[] args) 
66     {
67         System.out.println("Hello World!");
68     }
69 }

 

三、接口实例

usb接口实例

 1 /*
 2 笔记本电脑使用。
 3 为了扩展笔记本的功能，但日后出现什么功能设备不知道。
 4 
 5 定义一个规则，只要日后出现的设备都符合这个规则就可以了。
 6 规则在java中就是接口。
 7 
 8 */
 9 interface USB// 暴露的规则。
10 {
11     public void open();
12     public void close();
13 }
14 
15 
16 class BookPC
17 {
18     public static void main(String[] args)
19     {
20         useUSB(new UPan());//功能扩展了。
21         useUSB(new UsbMouse());
22     }
23 
24     //使用规则。
25     public static void useUSB(USB u)//接口类型的引用，用于接收(指向)接口的子类对象。//USB u= new UPan();
26     {
27         if(u!=null)
28         {
29             u.open();
30             u.close();
31         }
32     }
33 }
34 //一年后。------------------------------
35 //实现规则。也就是连接接口
36 
37 //这些设备和电脑的耦合性降低了。
38 
39 class UPan implements USB
40 {
41     public void open()
42     {
43         System.out.println("upan open");
44     }
45     public void close()
46     {
47         System.out.println("upan close");
48     }
49 
50 }
51 
52 
53 class UsbMouse implements USB
54 {
55     public void open()
56     {
57         System.out.println("UsbMouse open");
58     }
59     public void close()
60     {
61         System.out.println("UsbMouse close");
62     }
63 
64 }
65 
66 
67 
68 
69 
70 
71 
72 
73 /*
74 class Mouse
75 {
76 }
77 
78 class BookPC
79 {
80     public static void main(String[] args)
81     {
82         useMouse(new Mouse());
83     }
84     public static void useMOuse(Mouse m)
85     {
86         m.open();
87     }
88     public static void useMOuse(Mouse m)
89     {
90         m.open();
91     }
92 }
93 */

 先暴露接口，使用接口的时候再实现接口，就可以做到功能的扩展。