09 继承

Posted 2022-06-01 meizhoulqp

  1 继承(1)   
  2  类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实世界更好的建模。
  3 提高代码的复用性！
  4 extends的意思是“扩展”。子类是父类的扩展
  5 
  6 父类：超类、基类、 子类：派生类
  7  小结：
  8 继承的作用：通过继承可以简化类的定义，实现代码的重用
  9 
 10 子类继承父类的成员变量和成员方法，但不继承父类的构造方法
 11 
 12 –java中只有单继承 ，没有像c++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。就像我们现实中，如果你有多个父母亲，那是一个多么混乱的世界啊。多继承，就是为了实现代码的复用性，却引入了复杂性，使得系统类之间的关系混乱。
 13 –java中的多继承，可以通过接口来实现
 14 –
 15 如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object继继承(1) 
 16 
 17 
 18   子类可以继承父类的所有资源吗？
 19 不能，不能被继承的父类成员有  1、private成员  2、子类和父类不再同包，使用默认访问权限的成员       3、构造方法
 20 
 21                   本类                    同包        子类           所有类
 22 public               √                       √           √                   √            
 23 Protected         √                   √           √                   ×            
 24 默认                    √                   √            ×                    ×            
 25 Private            √                   ×            ×                     ×    
 26 package finaldemo;
 27 /**
 28  * 1,用final来修饰一个变量， 则该变量就变成了一个常量
 29  * 2,用final来修饰一个类，则该类就不能被作为父类继承
 30  * 3,用final来修饰一个方法，则该方法就不能被重写
 31  * @author tang
 32  *
 33  */
 34 public class Test 
 35     public static void main(String[] args) 
 36         final int AGE;
 37         AGE = 10;
 38         
 39     
 40     
 41 
 42 
 43 方法的重写（override） 
 44 在子类中可以根据需要对从基类中继承来的方法进行重写。
 45  重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型。
 46 重写方法不能使用比被重写方法更严格的访问权限。（由于多态）
 47 package overwriter;
 48 
 49 public class Pet 
 50     private String name;
 51     private int health;
 52     private int love;
 53     
 54     public Pet() 
 55         
 56     
 57     
 58     public Pet(String name, int health, int love) 
 59         super();
 60         this.name = name;
 61         this.health = health;
 62         this.love = love;
 63     
 64     public void print() 
 65         System.out.println(name + health + love);
 66     
 67     
 68     public String getName() 
 69         return name;
 70     
 71     public void setName(String name) 
 72         this.name = name;
 73     
 74     public int getHealth() 
 75         return health;
 76     
 77     public void setHealth(int health) 
 78         this.health = health;
 79     
 80     public int getLove() 
 81         return love;
 82     
 83     public void setLove(int love) 
 84         this.love = love;
 85     
 86 
 87 
 88 package overwriter;
 89 public class Cat extends Pet
 90     private String color;    
 91     public Cat(String name, int health, int love, String color) 
 92         super(name, health, love);
 93         this.color = color;
 94     
 95     public Cat() 
 96         super();
 97         // TODO Auto-generated constructor stub
 98     
 99     @Override
100     public void print() 
101         
102         System.out.println();
103         super.print();
104     
105     
106     public String getColor() 
107         return color;
108     
109 
110     public void setColor(String color) 
111         this.color = color;
112     
113 
114 
115 package overwriter;
116 public class Dog extends Pet     
117     //成员变量在最上面
118     private String strain;
119     //成员变量下面写构造方法
120     public Dog() 
121         
122     
123     public Dog(String name, int health, int love, String strain) 
124         super(name, health, love);
125         this.strain = strain;
126     
127     public String getStrain() 
128         return strain;
129     
130     public void setStrain(String strain) 
131         this.strain = strain;
132         
133 
134 
135 package overwriter;
136 
137 public class Test 
138     public static void main(String[] args) 
139         Dog wangcai = new Dog("旺财", 100, 100, "哈士奇");
140         wangcai.print();
141         
142         Cat cat = new Cat("小黑", 100, 90, "黑色");
143         cat.print();
144     
145 
146 
147 需要改写父类中方法的代码
148 package overwriter02;
149 
150 public class Pet extends Object
151     private String name;
152     private int health;
153     private int love;
154     
155     public Pet() 
156         
157     
158     public Pet(String name, int health, int love) 
159         super();
160         this.name = name;
161         this.health = health;
162         this.love = love;
163     
164     //宠物发出叫声的方法
165     public void bark() 
166         
167     
168     
169     public String getName() 
170         return name;
171     
172     public void setName(String name) 
173         this.name = name;
174     
175     public int getHealth() 
176         return health;
177     
178     public void setHealth(int health) 
179         this.health = health;
180     
181     public int getLove() 
182         return love;
183     
184     public void setLove(int love) 
185         this.love = love;
186     
187 
188 
189 package overwriter02;
190 
191 public class Cat extends Pet
192     private String color;
193     
194     public Cat(String name, int health, int love, String color) 
195         super(name, health, love);
196         this.color = color;
197     
198     public Cat() 
199         super();
200         // TODO Auto-generated constructor stub
201     
202 
203     @Override
204     public void bark() 
205         System.out.println("miao miao ...");
206     
207     
208     public String getColor() 
209         return color;
210     
211 
212     public void setColor(String color) 
213         this.color = color;
214     
215     
216 
217 
218 
219 public class Dog extends Pet 
220     
221     //成员变量在最上面
222     private String strain;
223     //成员变量下面写构造方法
224     public Dog() 
225         
226     
227     public Dog(String name, int health, int love, String strain) 
228         super(name, health, love);
229         this.strain = strain;
230     
231 
232     @Override
233     public void bark() 
234         super.bark();
235         System.out.println("won won ...");
236     
237     
238     public String getStrain() 
239         return strain;
240     
241     public void setStrain(String strain) 
242         this.strain = strain;
243     
244 
245 
246 package overwriter02;
247 
248 public class Test 
249     public static void main(String[] args) 
250         
251     
252 
253 
254 
255 
256 为什么需要重写父类的方法?
257 父类实现的方法不符合子类的逻辑
258 父类已经实现了80%,但是子类又必须要使用剩下的20%,所以可以重写父类方法,在方法内用super关键字调用父类的方法,再去完成剩下的20%工作
259 
260 super关键字 
261 定义：super是直接父类对象的引用。
262 用法：可以通过super来访问父类中被子类覆盖的方法或属性。
263 普通方法：
264 没有顺序限制。可以随便调用。
265 构造函数中： 
266 任何类的构造函数中，若是构造函数的第一行代码没有显式的调用super(...);那么Java默认都会调用super();作为父类的初始化函数。 所以你这里的super();加不加都无所谓。
267 
268 final关键字  
269 定义：final可以用来修饰变量，方法，类。
270 修饰变量   变量一旦被初始化便不可改变 相当于定义了一个常量
271              修饰引用数据类型  引用不能被赋值 但属性可以被赋值
272 修饰方法   final方法是在子类中不能被覆盖的方法
273 修饰类  final类是无法被任何类继承的
274 package finaldemo;
275 /**
276  * 1,用final来修饰一个变量， 则该变量就变成了一个常量
277  * 2,用final来修饰一个类，则该类就不能被作为父类继承
278  * 3,用final来修饰一个方法，则该方法就不能被重写
279  * @author tang
280  *
281  */
282 public class Test 
283     public static void main(String[] args) 
284         final int AGE;
285         AGE = 10;
286         
287     
288     
289 package finaldemo;
290 
291 public  class Pet 
292     public final void test() 
293         System.out.println("test");
294     
295 
296 package finaldemo;
297 
298 public class Dog extends Pet
299     
300 
301 
302 
303 Object类    
304 object类是所有java类的根基
305 如果在类的声明中未使用extends关键字指明其基类，则默认基类为object类
306 public class Person 
307     ...
308 
309 public class Person extends Object 
310     ...
311 
312 package objectdemo;
313 
314 public class Dog 
315     private String name;
316     private int age;
317     
318     public Dog(String name, int age) 
319         super();
320         this.name = name;
321         this.age = age;
322     
323     public Dog() 
324         super();
325         // TODO Auto-generated constructor stub
326     
327     
328     
329     @Override
330     public boolean equals(Object dog) 
331         //做类型转换  将Object类型的参数转换为Dog类型的参数
332         Dog dahuang = (Dog)dog;
333         //如果两个对象的名字是相同的，则认为是相同的对象
334         boolean b = this.name.equals(dahuang.name);
335         return b;
336     
337 
338     //当使用system.out.println 来打印一个对象的时候   就是在答应对象toString方法的返回值
339     @Override
340     public String toString() 
341         return "Dog [name=" + name + ", age=" + age + "]";
342     
343     public String getName() 
344         return name;
345     
346     public void setName(String name) 
347         this.name = name;
348     
349     public int getAge() 
350         return age;
351     
352     public void setAge(int age) 
353         this.age = age;
354     
355 
356 package objectdemo;
357 public class Test 
358     public static void main(String[] args) 
359         Dog wangcai = new Dog("旺财",11);
360         Dog dahuang = new Dog("旺财", 10);
361         
362         System.out.println(wangcai.equals(dahuang));
363         System.out.println(wangcai.toString());
364     
365 
366 
367 
368 重写： toString 方法：
369 默认返回：包名+类名+@+哈希码
370 可以重写！
371 
372 抽象类
373 定义：是一种模版模式。抽象类为所有子类提供了一个通用模版，子类可以在这个模版基础上进行扩展。
374 作用： 通过抽象类，可以避免子类设计的随意性。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。
375 package 抽象类;
376 /**
377  * class 前加abstract 该类就成为了一个抽象类
378  * 1，抽象类不能创建对象
379  * 2，抽象类一般是一个父类，该父类没有什么存在的意义，就是用来被子类继承 
380  * 3，抽象类中可以有抽象方法，也可以有非抽象方法
381  * 4，一个类继承了一个抽象类，则该类必须要实现该抽象类中的所有抽象方法
382  * 5，如果子类也是抽象类，则可以不实现父类的抽象方法
383  * 6，抽象方法必须定义在抽象类中
384  * 
385  * 
386  * 为什么要使用抽象类
387  * 
388  * @author tang
389  *
390  */
391 public abstract class Pet 
392     private String name;
393     //抽象方法
394     //如果一个方法 每个子类实现的逻辑都不一样   则把该方法定义成抽象方法，
395     //让每个子类去根据自己的逻辑实现该方法
396     public abstract void bark();
397     public abstract void eat();
398     public abstract void sleep();
399     public abstract void play();
400     
401     //如果一个方法，每个子类实现的逻辑都一样  则该方法直接在父类中实现，子类直接调用
402     public String getName() 
403         return name;
404     
405     public void setName(String name) 
406         this.name = name;
407     
408     
409 
410 
411 package 抽象类;
412 
413 public class Dog extends Pet
414 
415     @Override
416     public void bark() 
417         System.out.println("won won won...");
418     
419 
420     @Override
421     public void eat() 
422         System.out.println("狗喜欢吃骨头");
423     
424 
425     @Override
426     public void sleep() 
427         System.out.println("狗在睡觉。。。");
428     
429 
430     @Override
431     public void play() 
432         System.out.println("狗在玩飞盘。。。");
433     
434 
435 
436 package 抽象类;
437 
438 public class Cat extends Pet
439 
440     @Override
441     public void bark() 
442         System.out.println("maio miao ...");
443     
444 
445     @Override
446     public void eat() 
447         System.out.println("猫在吃鱼。。。");
448         
449     
450 
451     @Override
452     public void sleep() 
453         System.out.println("猫在晒太阳。。。");
454     
455 
456     @Override
457     public void play() 
458         System.out.println("猫在玩老鼠。。。");
459     
460 
461 
462 
463 总结：
464 抽象方法和抽象类均必须用abstract来修饰。
465 抽象方法没有方法体，只需要声明不需实现。
466 有抽象方法的类只能定义能抽象类
467 相反抽象类里面的方法不一定全是抽象方法，也可能没有抽象方法。
468 抽象类可以包含属性、方法、构造方法。
469 抽象类不能实例化，及不能用new来实例化抽象类，只能用来被子类调用。 
470 抽象类只能用来继承。
471 抽象方法必须被子类实现。抽象类的子类必须覆盖所有的抽象方法才能被实例化，否则还是抽象类
472 构造方法调用顺序：
473 根据super的说明，构造方法第一句 总是：super(…)来调用父类对应的构造方法。
474 先向上追溯到Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止
475 
476 对象的比较—==和equals()
477 ==：
478 比较两基本类型变量的值是否相等
479 比较两个引用类型的值即内存地址是否相等，即是否指向同一对象
480 equals() ：
481 两对象的内容是否一致
482 
483 自定义类须重写equals()，否则其对象比较结果总是false。
484 package equalsdemo;
485 /**
486  * 判断相等的两种方式
487  *
488  *1， == 
489  *    用来判断基本数据类型的数据是否相等
490  *  也可以用来判断引用数据类型   判断两个引用是否相等  当且仅当两个引用指向的是同一个对象  == 判断才返回true
491  *  
492  *  
493  *2，equals  
494  *    判断引用数据类型的对象是否相等
495  *    如果一个类没有重写该方法，则自动调用到Object中的equals  判断规则跟 == 一样
496  *    如果要自定义判断相等的规则，则在本类中重写equals 方法，在方法内定义比较规则
497  * @author tang
498  *
499  */
500 public class Test 
501     public static void main(String[] args) 
502         String str01 = "abc";
503         String str02 = new String("abc");
504         
505         System.out.println(str01 == str02);
506         System.out.println(str01.equals(str02));
507         
508     
509