JAVA基础知识之继承

一、关于继承

        1、考虑某种特殊情况，现有学生类、老师类、校长类、三个类都有年龄、性别、姓名属性，若三个类中都设置一遍，等于是写了3遍重复代码

        2、若建立一个共用类，类中设置年龄、性别、姓名三个属性，然后学生类、老师类、校长类都继承这个类，则三个类都有了所需要的属性，同时代码只写了一遍，同时若后续还有其它共同点，可直接在共用类中添加，不需要三个类单独添加

        3、当多个类有多个共同的属性和方法时，则可以利用继承来处理，一遍代码即可

        4、继承是两个类之间的关系，如A继承B，B继承C，不能单独一个类提继承

二、实现继承

public class Rector extends Common
{
 
}

      1、利用关键字 extends 在类定义的时候设置继承

      2、我们称Rector类继承Common类，那么Rector类就称为子类，而Common类就成为父类（超类）

三、属性与方法的继承

     1、子类拥有父类的非私有的属性和方法，即父类private的属性只能通过父类的公开接口调用，而private方法子类却无法调用

     2、子类还可以扩展自己独特的属性和方法，但是父类没有子类扩展的属性和方法。因此子类也被称为是父类的扩展，

/**
 * 父类Common类
 * @author Administrator
 *
 */
public class Common
{

    private String name;
    
    private int age;

    public String sex="男"; //默认性别为男 
    
    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;
    }
    
    
    private void test()
    {
        
        System.out.println("年龄是"+this.age+"姓名是"+this.name+"性别是"+this.sex);
 
    }
    
    
}

/**
 * 子类继承父类Common类
 * 
 * @author Administrator
 * 
 */
public class Rector extends Common
{

    public String subsject; // 子类扩展自己的属性

    public static void main(String[] args)
    {
        Rector aRector=new Rector();
        
        aRector.sex="女";   //父类的public属性，子类直接拥有调用
        
        aRector.ag30;  //报错，父类的private属性，子类和父类都不能直接调用，必须通过公开的接口方法调用
        
        aRector.subsject="你好";  //子类public属性，子类直接调用
        
        aRector.setAge(20);  //可以，通过公开接口设置属性
        
        System.out.println(aRector.getAge()); //可以，子类通过公开接口调用属性
        
        
        Common bCommon=new Common();
        
        bCommon.subsject="我好"; //报错，父类没有子类的独特属性

        bCommon.setAge(20);  //可以，父类通过自己的接口设置属性
        
        System.out.println(bCommon.getAge()); //可以，父类通过公开接口调用属性
    }
}

     3、子类对象可以赋给父类变量，父类变量不一定能赋给子类对象（如人是父类，黄种人是子类。黄种人一定是人，但是人不一定是黄种人，有可能是白种人）

public class Rector extends Common
{

    public String subsject; 

    public static void main(String[] args)
    {
        Rector aRector=new Rector();
        
        Common bCommon=aRector;  //子类对象赋予给父类变量，没有任何问题
        

        Common cCommon=new Common();
        
        Rector dRector=(Rector) cCommon; //父类对象赋予给子类对象，即使强转后运行也会报错
        
        
    }
}

运行结果：Common(父类)不能转化为Rector(子类)

四、类继承是只允许单继承，不允许多继承，但可以多重继承

        1、类继承中不允许多个继承，如a extends b extends c

     2、但是支持多重继承如 a extends b, b extends c,这样a就可以拥有c的属性

/**
 * 子类继承父类Common类
 * 
 * @author Administrator
 * 
 */
public class Rector extends Common
{
    
    public String subsject; 
    
    public static void main(String[] args)
    {

        Rector rector=new Rector();
          
        rector.name="张三";    //父类属性子类拥有
                
        rector.age=20;        //父类属性子类拥有
        
        rector.sex="男";       //父类属性子类拥有
        
        rector.brithday="1月"; //父类的父类属性子类一样可以拥有
        
        rector.subsject="自然"; //子类扩展属性
        
        
    }
}

/**
 * 父类Common类
 * 
 * @author Administrator
 * 
 */
public class Common extends Teacher
{


    public String name;

    public int age;

    public String sex; 

    
}

/**
 * Common的父类
 * @author Administrator
 *
 */
public class Teacher 
{

    public String brithday;  //生日属性
    
}

五、构造器继承

        1、当父类中只存在无参构造器时，子类的构造器方法会隐式的调用父类的无参构造器对从父类继承的属性进行初始化

父类代码如下：

/**
 * 父类Common类
 * 
 * @author Administrator
 * 
 */
public class Common
{

    public String name;

    public String sex;

    public int age;


    public Common()
    {
        this.name = "张三";
        
        this.sex = "女";

        this.age = 20;

    }

}

子类代码如下：

/**
 * 子类继承父类Common类
 * 
 * @author Administrator
 * 
 */
public class Rector extends Common
{

    public String subsject;
    
    
    /**
     * 子类无参构造器
     * @param args
     */
    public Rector()
    {

    }
    
    /**
     * 子类有参构造器
     * @param args
     */
    public Rector(String subsject)
    {
        this.subsject=subsject;
    }
    
    

    public static void main(String[] args)
    {
        
        Rector rector=new Rector(); //无参构造对象
        
        Rector rector2=new Rector("自然"); //有参构造对象
        
        System.out.println(rector.age);

        System.out.println(rector.name);

        System.out.println(rector.sex);

        System.out.println(rector.subsject);
        
        System.out.println("-------------分割线");
        
        System.out.println(rector2.age);

        System.out.println(rector2.name);

        System.out.println(rector2.sex);

        System.out.println(rector2.subsject);
        

    }

}

子类执行结果如下：

  

 可以看出子类中无参对象的属性和有参对象的属性都是按照父类的构造器进行初始化的，因此子类代码中的无参构造器和有参构造器本质上是调用了父类的构造器，子类构造器代码都隐藏了一行调用代码，实际应该如下：

/**
     * 子类无参构造器
     * @param args
     */
    public Rector()
    {
        super();
    }
    
    /**
     * 子类有参构造器
     * @param args
     */
    public Rector(String subsject)
    {
        super();
        this.subsject=subsject;
    }

        2、当父类中即存在无参构造器，也存在有参构造器时，子类构造器默认调用父类无参构造器对从父类继承的属性进行初始化

父类代码：

/**
 * 父类Common类
 * 
 * @author Administrator
 * 
 */
public class Common
{

    public String name;

    public String sex;

    public int age;

    /**
     * 无参构造
     */
    public Common()
    {
        this.name = "张三";

        this.sex = "女";

        this.age = 20;

    }

    /**
     * 有参构造
     */
    public Common(String name, String sex, int age)
    {
        this.name=name;
        
        this.sex=sex;
        
        this.age=age;
        
    }
}

子类代码：

/**
 * 子类继承父类Common类
 * 
 * @author Administrator
 * 
 */
public class Rector extends Common
{

    public String subsject;
    
    
    /**
     * 子类无参构造器
     * @param args
     */
    public Rector()
    {
        super();   //默认调用无参构造，实际可以不编写
    }
    
    /**
     * 子类有参构造器
     * @param args
     */
    public Rector(String subsject)
    {
        super();      //默认调用无参构造器，实际可以不编写
        this.subsject=subsject;
    }
    
    

    public static void main(String[] args)
    {
        
        Rector rector=new Rector(); //无参构造对象
        
        Rector rector2=new Rector("自然"); //有参构造对象
        
        System.out.println(rector.age);

        System.out.println(rector.name);

        System.out.println(rector.sex);

        System.out.println(rector.subsject);
        
        System.out.println("-------------分割线");
        
        System.out.println(rector2.age);

        System.out.println(rector2.name);

        System.out.println(rector2.sex);

        System.out.println(rector2.subsject);
        

    }

}

执行结果

      

    3、当父类中只存在有参构造器时，子类不能存在无参构造器，子类必须存在有参构造器，且在方法的第一行中显式的调用父类的有参构造器进行属性初始化

父类代码：

/**
 * 父类Common类
 * 
 * @author Administrator
 * 
 */
public class Common
{

    public String name;

    public String sex;

    public int age;

    /**
     * 有参构造
     */
    public Common(String name, String sex, int age)
    {
        this.name=name;
        
        this.sex=sex;
        
        this.age=age;
        
    }
}

子类代码：

/**
 * 子类继承父类Common类
 * 
 * @author Administrator
 * 
 */
public class Rector extends Common
{

   

    public String subsject;
     
    /**
     * 子类有参构造器
     * @param args
     */
    public Rector(String name, String sex, int age,String subsject)
    {
        super(name, sex, age);  //必须在第一行，且显式的调用父类构造器，否则编译不通过
        this.subsject=subsject;
    }
    

}