继承和多态

Posted 2020-10-18 海洋初光

　　学习目标

　　1.了解继承的目的

　　2.了解继承和多态的关系

　　3.知道如何重新定义方法

　　4.认识java.lang.Object

　　5.简单介绍垃圾回收机制

一.何谓继承

　　　　子类继承（Inherit）父类，避免重复的行为定义，不过并非为了重复定义就滥用继承，滥用继承会导致程序维护问题。

　　　　1.继承共同行为

　　　　　　在一款游戏中所有的角色共同拥有角色等级角色名称角色血量等则可以定义一个角色类实现来实现共有的方法。每种角色通过extends关键字来继承。　　

 1 package Learn;
 2 
 3 public class SwordMan extends role {
 4     public void fight(){
 5         System.out.println("挥剑攻击");
 6     }
 7 
 8 }
 9 package Learn;
10 
11 public class role {
12     private String name;
13     private int level;
14     private int blood;
15     public String getName() {
16         return name;
17     }
18     public void setName(String name) {
19         this.name = name;
20     }
21     public int getLevel() {
22         return level;
23     }
24     public void setLevel(int level) {
25         this.level = level;
26     }
27     public int getBlood() {
28         return blood;
29     }
30     public void setBlood(int blood) {
31         this.blood = blood;
32     }
33     
34 
35 }

View Code

　　　　2.多态与is-a

　　　　　　子类和父类是由is-a的关系由上面的例子可以发现swordman是一种role

1     role r1=new SwordMan();
2         SwordMan s1=(SwordMan) r1;//部强制转换编译会错误
3         SwordMan s2=new SwordMan();
4         role r2=s2;

View Code

　　　　　　多态的作用是什么呢。不用一种一种的去实现显示血量的方法，在测试统计等等方面的作用是非常的实用的。

 1 package Learn;
 2 
 3 public class Test {
 4     public static void main(String[] args) {
 5         role[] r=new role[]{new SwordMan(),new SwordMan(),new SuperWomen(),new SuperWomen()};
 6         for (int i=0;i<3;i++) {
 7             ShowBlood(r[i]);
 8         }
 9     }
10     public static void ShowBlood(role r){
11         System.out.println(r.toString()+""+r.getBlood());
12     }
13 }

View Code

 

 　　　　3.重新定义行为

　　　　　　role中有fight的方法但是每个不同的role SuperWomen或SwordMan中实现的内容不同。子类可以重新定义fight的方法

 1 package Learn;
 2 
 3 public class Test {
 4     public static void main(String[] args) {
 5         role[] r=new role[]{new SwordMan(),new SwordMan(),new SuperWomen(),new SuperWomen()};
 6         for (int i=0;i<4;i++) {
 7             Showfight(r[i]);
 8         }
 9     }
10     public static  void Showfight(role r){
11         r.fight();
12     }
13 }
14 
15 package Learn;
16 
17 public class SwordMan extends role {
18     public void fight(){
19         System.out.println("挥剑攻击");
20     }
21 
22 }
23 
24 package Learn;
25 
26 public class SuperWomen extends role {
27     public  void fight(){
28         System.out.println("我是超级女王我可以出击");
29     }
30     
31 
32 }
33 
34 package Learn;
35 
36 public class role {
37     private String name;
38     private int level;
39     private int blood;
40     public void fight(){}
41     public String getName() {
42         return name;
43     }
44     public void setName(String name) {
45         this.name = name;
46     }
47     public int getLevel() {
48         return level;
49     }
50     public void setLevel(int level) {
51         this.level = level;
52     }
53     public int getBlood() {
54         return blood;
55     }
56     public void setBlood(int blood) {
57         this.blood = blood;
58     }
59     
60 
61 }

View Code

结果：

挥剑攻击
挥剑攻击
我是超级女王我可以出击
我是超级女王我可以出击

　　　　　　　   3.1重新定义的细节

　　　　　　　　子类重新定义了方法之后想要取得父类的方法可以在调用的方法之前加上super关键字。super关键字调用的方法不能定义为private，重新定义的方法是对于父类

　　　　　　　　的权限只能扩大不能缩小。重新定义是除了可以定义权限较大的关键字除外，其他部分必须与父类中一致。static属于类拥有，如果子类定义了相同的static成员，

　　　　　　　　该成员属于子类所有而不是重新定义。

　　　　　　　　3.2 构造函数

　　　　　　　　如果类有继承的关系，创建子类实例值后，会先进行父类定义的初始化流程，在进行子类的初始化流程。，也就是创建子类实例之后，会先执行父类的构造

　　　　　　　　方法在执行子类的构造方法。。如果子类中的构造方法中没有指定父类构造方法会默认调用父类的无参数构造函数。

　　　　4.认识Java.lang.object

　　　　　　任何类追溯至最上层的父类一定是Java.lang.Object。者有一个好处就是如果有需求是使用数组收集各种的对象，那就可以通过Object[]来收集。

　　　　　　Object[] objs={"monica",new Date();new role()}.所有对象都继承了Object类所以Object所有的方法都可以被重新定义，toString(),equals()等等。

　　　　5.关于垃圾收集

　　　　　　无法再使用的某个对象，该对象便是只会消耗内存的垃圾。JVM有垃圾收集（Garbage Collection，GC）机制，收集到的垃圾对象所占的内存空间，会被

　　　　　　垃圾收集齐释放。

　　　　　　some[] somes={new some(),new some(),new some()}

　　　　　　some=null;

　　　　　    则所有参考的对象被回收。