码迷,mamicode.com
首页 > 其他好文 > 详细

09 继承

时间:2019-08-01 09:34:47      阅读:77      评论:0      收藏:0      [点我收藏+]

标签:int   sys   protected   比较   etl   模版   建模   基础   两种   

  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 }

 

09 继承

标签:int   sys   protected   比较   etl   模版   建模   基础   两种   

原文地址:https://www.cnblogs.com/meizhoulqp/p/11280448.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!