1 /**
2
3 接口是什么？
4
5 接口是功能的集合，接口只描述所应该具备的方法，并没有具体实现
6
7 接口定义时需要 interface关键字，接口里的方法需要实现类来实现，implements关键字
8
9 接口中的方法均为公共访问的抽象方法，变量是被 public static final 修饰的，不可改变
10
11 接口可以多实现，可以定义方法，方法也可以有修饰符，public abstract
12
13 接口不可以创建对象，接口可以多继承，类继承类的同时，可以实现接口
14
15 */
16
17 /*
18
19 定义一个接口
20
21 */
22
23 public interface Animal{
24
25 public static void int a = 1; //a的值不能改变
26
27 public void eat();
28
29 }
30
31 /*
32
33 实现类
34
35 */
36
37 public class Cat implements Animal{
38
39 public void eat(){
40
41 }
42
43 }
44
45
46
47 /*
48
49 接口多实现
50
51 */
52
53 public interface Fu1{
54
55 public void show1();
56
57 }
58
59 public interface Fu2{
60
61 public void show2();
62
63 }
64
65 /*
66
67 实现类
68
69 */
70
71 public class Zi implements Fu1,Fu2{
72
73 public void show1(){
74
75 }
76
77 public void show2(){
78
79 }
80
81 }
82
83 /*
84
85 类继承类，同时实现接口
86
87 */
88
89 public class Fu{
90
91 public void show(){
92
93
94
95 }
96
97 }
98
99 public interface Fu2{
100
101 public abstract void show2();
102
103 }
104
105 public class Zi extends Fu1 implements Fu2{
106
107 public void show2(){
108
109
110
111 }
112
113 }
114
115 /*
116
117 接口多继承
118
119 */
120
121 public interface Fu1{
122
123 public void show1();
124
125 }
126
127 public interface Fu2{
128
129 public void show2();
130
131 }
132
133 public interface Fu3{
134
135 public void show3();
136
137 }
138
139 public interface Fu4 extends Fu1,Fu2,Fu3{
140
141 public void show4();
142
143 }
144
145
146
147 /**
148
149 多态：父类引用变量指向子类对象，必须是子父类关系和类实现接口关系，父类引用变量调用方法时，会直接调用子类重写后的方法
150
151 多态成员变量：
152
153 当父类子类中出现同名的变量是，多态调用该变量时：
154
155 编译时期：引用型变量所属类中是否有被调用的成员变量
156
157 运行时期：调用引用型变量所属类中的成员变量
158
159 多态成员方法：
160
161 编译时期：引用变量所属的类，如果类中没有调用的方法，编译失败
162
163 运行时期：引用变量所指的对象所属的类，并运行对象所属类中的成员方法
164
165 */
166
167 public class Fu{
168
169 int num = 1;
170
171 }
172
173 public class Zi extends Fu{
174
175 int num = 2;
176
177 }
178
179 public class Test{
180
181 public static void main (String[] args){
182
183 Fu f = new Zi();
184
185 System.out.println(f.num);
186
187 Zi z = new Zi();
188
189 System.out.println(z.num);
190
191 }
192
193 }
194
195
196
197 public class Fu{
198
199 int num = 1;
200
201 public void show(){
202
203 System.out.println("Fu");
204
205 }
206
207 }
208
209 public class Zi{
210
211 int num = 2;
212
213 public void show(){
214
215 System.out.println("Zi");
216
217 }
218
219 }
220
221 public class Test{
222
223 public static void main(String[] args){
224
225 Fu f = new Zi();
226
227 f.show();
228
229 }
230
231 }
232
233
234
235 /*
236
237 instanceof关键字 比较运算符
238
239 */
240
241 public interface Person{
242
243 public void eat();
244
245 }
246
247 public class Teacher implements Person{
248
249 public void eat(){
250
251 System.out.println("老师吃饭");
252
253 }
254
255 }
256
257 public class Student implements Person{
258
259 public void eat(){
260
261 System.out.println("学生吃饭");
262
263 }
264
265 public class Test{
266
267 public static void main(String[] args){
268
269 Person p = new Teacher();
270
271 Person p2 = new Student();
272
273 if(p instanceof Teacher){
274
275 p.eat();
276
277 }
278
279 if( p2 instanceof Student){
280
281 p2.eat();
282
283 }
284
285 }
286
287 }
288
289 }
290
291 /*
292
293 多态转型
294
295 */
296
297 public class Fu{
298
299 public void show(){
300
301 System.out.println("Fu");
302
303 }
304
305 }
306
307 public class Zi{
308
309 public void show(){
310
311 System.out.println("Zi");
312
313 }
314
315 }
316
317 public class Test{
318
319 public static void main(String[] args){
320
321 Fu f = new Zi();//向上造型
322
323 Zi z = (Zi)f;//向下造型
324
325 }
326
327 }
