Java学习第九章 之 接口，多态

  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 }