继承1

一.super关键字

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

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

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

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

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

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

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

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

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

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

二.转型

    1.向上转型

       子类转成父类；

       特点：

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

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

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

    2.向下转型

        父类转成子类；

        特点：

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

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

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

父子类：

package org.hanqi.pn0120;

public class Father {

    
    private String name;
    
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
//    public Father()
//    {
//        System.out.println("父亲的构造方法");
//    }
    
    public  Father(String name)
    {
        System.out.println("父亲的有参的构造方法");
        
        this.name=name;
    }
    //工作
    public void work()
    {
        System.out.println("我劳动我光荣");
    }
}

package org.hanqi.pn0120;

public class Son extends Father {
    
      //Object a;所说类的父类
    
      public Son()
      {
//          System.out.println("子类的构造方法");

          //super 表示父类
          super("儿子");
          
          System.out.println("子类的构造方法");
      }
      
      public void sing()
      {
          System.out.println("我喜欢唱歌");
      }
      
      //覆盖（重写）
      public void work()
      {
          //调用父类的方法
          //super.work();
          
//          System.out.println("我不喜欢上班，我要去参加海选");
          
          System.out.println("我边上班边练歌");
      }
      
      public static Object getDate(int i)
      {
          Object rtn=null;
          
          //获取数据
          if(i==1)
          {
          //1  father
          
          Father  f=new Father("向上转型的父类");
          
          //向上
          rtn=f;
          }
          else
          {
          //2 Son
          Son s=new Son();
          
          rtn=s;
          }
          
          return  rtn;
      }
 
      
}

package org.hanqi.pn0120;

public class TestJiCheng {

    public static void main(String[] args) {
        
        //
        Father f=new Father("父亲");
        
//        f.setName("父亲");
        
        f.setAge(50);
        
        System.out.println("名字是 "+  f.getName()+"  年龄是 "+  f.getAge());
        
        f.work();
        
        System.out.println();
        
        Son s=new Son();
        
//        s.setName("儿子");
        
        s.setAge(20);
        
        System.out.println("名字是 "+s.getName()+"  年龄是 "+  s.getAge());
        
        s.work();
        
        s.sing();
        
        System.out.println();
        
        //转型
        //向上转型  子类转成父类
        Father f1=new Son();
        
        System.out.println("名字是 "+s.getName());
        
        f1.work();//如果被子类重写了，调用子类的方法
        
        //f1.sing
        
        System.out.println("向下转型");
        
        
        //向下转型  父类转成子类
        //Son s1=(Son) new  Father("父亲");
        
        Son s1=(Son) f1;
        
        s1.work();
        
        System.out.println();
        
        Father f2=(Father) Son.getDate(1);
        
        f2.work();
        
    
        
        

    }

}