接口详细介绍与实例

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 }

三、接口实例

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 */