继承1

Posted 2020-06-19 安然罒

一.super关键字

    子类可以继承父类的非私有成员变量和成员方法（不是以private关键字修饰的）作为自己的成员变量和成员方法。但是，如果子类中声明的成员变量与父类的成员变量同名，则子类不能继承父类的成员变量，此时称子类的成员变量隐藏了父类的成员变量。如果子类中声明的成员方法与父类的成员方法同名，并且方法的返回值及参数个数和类型也相同，则子类不能继承父类的成员方法，此时称子类的成员方法重写了父类的成员方法。这时，如果想在子类中访问父类中被子类隐藏的成员方法或变量，就可以使用super关键字。

    super关键字主要有以下两种用途：

     1.调用父类的构造方法；

        子类可以调用由父类声明的构造方法。但必须在子类的构造方法中使用super关键字来调用。

        语法格式为：    super（[参数列表]）；

        如果父类的构造方法中包括参数，则参数列表为必选项，用于指定父类构造方法的入口参数。

     2.在子类的构造方法里显式调用被隐藏的父类的构造方法，注意调用语句必须在第一行。

        如果想在子类中操作父类中被隐藏的成员变量和被重写的成员方法，也可以使用super关键字。

        语法格式为：    super.成员变量名

                             super.成员方法名（[参数列表]）

二.转型

    1.向上转型

       子类转成父类；

       特点：

               （1）不能调用子类的特有的成员

               （2）可以调用父类的成员

               （3）如果子类重写了，就调用子类的  

    2.向下转型

        父类转成子类；

        特点：

              （1）需要强制转换（子类的类型）

              （2）一般情况是先有向上转型，再有向下转型

              （3）常用方式：先向上转成Object，再向下转型；类似  泛型。

 

父子类：

 1 package org.hanqi.pn0120;
 2 
 3 public class Father {
 4 
 5     
 6     private String name;
 7     
 8     private int age;
 9 
10     public String getName() {
11         return name;
12     }
13 
14     public void setName(String name) {
15         this.name = name;
16     }
17 
18     public int getAge() {
19         return age;
20     }
21 
22     public void setAge(int age) {
23         this.age = age;
24     }
25     
26 //    public Father()
27 //    {
28 //        System.out.println("父亲的构造方法");
29 //    }
30     
31     public  Father(String name)
32     {
33         System.out.println("父亲的有参的构造方法");
34         
35         this.name=name;
36     }
37     //工作
38     public void work()
39     {
40         System.out.println("我劳动我光荣");
41     }
42 }

Father

 1 package org.hanqi.pn0120;
 2 
 3 public class Son extends Father {
 4     
 5       //Object a;所说类的父类
 6     
 7       public Son()
 8       {
 9 //          System.out.println("子类的构造方法");
10 
11           //super 表示父类
12           super("儿子");
13           
14           System.out.println("子类的构造方法");
15       }
16       
17       public void sing()
18       {
19           System.out.println("我喜欢唱歌");
20       }
21       
22       //覆盖（重写）
23       public void work()
24       {
25           //调用父类的方法
26           //super.work();
27           
28 //          System.out.println("我不喜欢上班，我要去参加海选");
29           
30           System.out.println("我边上班边练歌");
31       }
32       
33       public static Object getDate(int i)
34       {
35           Object rtn=null;
36           
37           //获取数据
38           if(i==1)
39           {
40           //1  father
41           
42           Father  f=new Father("向上转型的父类");
43           
44           //向上
45           rtn=f;
46           }
47           else
48           {
49           //2 Son
50           Son s=new Son();
51           
52           rtn=s;
53           }
54           
55           return  rtn;
56       }
57  
58       
59 }

Son

 1 package org.hanqi.pn0120;
 2 
 3 public class TestJiCheng {
 4 
 5     public static void main(String[] args) {
 6         
 7         //
 8         Father f=new Father("父亲");
 9         
10 //        f.setName("父亲");
11         
12         f.setAge(50);
13         
14         System.out.println("名字是 "+  f.getName()+"  年龄是 "+  f.getAge());
15         
16         f.work();
17         
18         System.out.println();
19         
20         Son s=new Son();
21         
22 //        s.setName("儿子");
23         
24         s.setAge(20);
25         
26         System.out.println("名字是 "+s.getName()+"  年龄是 "+  s.getAge());
27         
28         s.work();
29         
30         s.sing();
31         
32         System.out.println();
33         
34         //转型
35         //向上转型  子类转成父类
36         Father f1=new Son();
37         
38         System.out.println("名字是 "+s.getName());
39         
40         f1.work();//如果被子类重写了，调用子类的方法
41         
42         //f1.sing
43         
44         System.out.println("向下转型");
45         
46         
47         //向下转型  父类转成子类
48         //Son s1=(Son) new  Father("父亲");
49         
50         Son s1=(Son) f1;
51         
52         s1.work();
53         
54         System.out.println();
55         
56         Father f2=(Father) Son.getDate(1);
57         
58         f2.work();
59         
60     
61         
62         
63 
64     }
65 
66 }

TestJiCheng