JAVA面向对象 - 继承

继承可以解决代码的复用，让我们的编程更加靠近人类思维，当多个类存在相同的属性和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends语句来声明继承。

 

注意事项

Ⅰ.java 中支持单继承，不直接支持多继承，但对c++中的多继承机制进行改良。

Ⅱ.ava支持多层（多重）继承

Ⅲ.Java所有类都是Object类的子类

Ⅳ.JDK中有202个包3777个类、接口、异常、枚举、注释和错误

实例

package com.beekc.www;

public class Beekc {
    public static void main(String[] args) {
        Pupil stu1 = new Pupil();
        stu1.pay(500);
        stu1.printName();
        stu1.printFee();

        MiddleStu stu2 = new MiddleStu();
        stu2.pay(500);
        stu2.printName();
        stu2.printFee();

        ColStu stu3 = new ColStu();
        stu3.pay(500);
        stu3.printName();
        stu3.printFee();
    }
}

//将学生的共有属性提出，做一个父类
class Stu
{
    protected int age;
    public String name;
    public float fee;
    //编程中，如果你不希望子类继承某个属性或者方法
    //将其声明为private
    private String job;

    public void printName()
    {
        System.out.printf("名字:" + this.name + "\t");
    }
    public void printFee()
    {
        System.out.println("交费" + this.fee + "￥");
    }
}

//小学生类
class Pupil extends Stu
{
    public Pupil()
    {
        name = "小学生";
    }
    //交费
    public void pay(float fee)
    {
        this.fee = fee;
    }
}

//中学生类
class MiddleStu extends Stu
{
    public MiddleStu()
    {
        name = "中学生";
    }
    //交费
    public void pay(float fee)
    {
        this.fee = fee * 0.8f;
    }
}

//大学生类
class ColStu extends Stu
{
    public ColStu()
    {
        name = "大学生";
    }
    //交费
    public void pay(float fee)
    {
        this.fee = fee * 0.6f;
    }
}

运行结果

 

 

 

继承的细节

//第一种情况：当子类与父类的变量的名称相同时，在子类里想用父类的变量时用super关键字
public class Father {
    int num = 4;
}

public class Son extends Father {
    int num = 5;
    public void show()
    {
        System.out.println(this.num + "..." + super.num);
    }
}

public class ExtendsDemo {
    public static void main(String[] args)
    {
        Son son = new Son();
        son.show();

    }
}

 

//第二种情况：当父类的方法与子类的方法想同时，子类的方法会去覆盖父类的方法，这里会去输出子的内容，想要用父类的方法用super关键字
public class Father {
    public void show()
    {
        System.out.println("Father run ...");
    }
}

public class Son extends Father {
    public void show()
    {
        System.out.println("Son run ...");
    }
}

public class ExtendsDemo {
    public static void main(String[] args)
    {
        new Son().show();
    }
}

 

//第三种情况：子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限
//这个程序会报错
public class Father {
    public void show() //这里权限是public
    {
        System.out.println("Father run ...");
    }
}

public class Son extends Father {
    private void show()//这里权限是private
    {
        System.out.println("Son run ...");
    }
}

public class ExtendsDemo {
    public static void main(String[] args)
    {
        new Son().show();
    }
}

//会报错的程序:静态方法只能覆盖静态方法，或被静态覆盖
class Father
{
    public static void show()
    {
        System.out.println("run show");
    }
}

class Son extends Father
{
     public void show()
    {
        System.out.println("run show");
    }
}

class ExtendsDome
{
    public static void main(String[] args)
    {
        Son son = new Son();
        son.show();
    }
}

 

//第四种情况：会报错的程序:静态方法只能覆盖静态方法，或被静态覆盖
class Father
{
    public static void show()
    {
        System.out.println("run show");
    }
}

class Son extends Father
{
     public void show()
    {
        System.out.println("run show");
    }
}

class ExtendsDome
{
    public static void main(String[] args)
    {
        Son son = new Son();
        son.show();
    }
}

什么时候使用覆盖操作？
当对一个类进行子类的扩展时，子类需要保留父类的功能声明。但是要定义子类中该功能的特有内容时，就使用覆盖操作完成。

 

子父类中的构造函数的特点

在子类构造对象时，发现，访问子类构造函数时，父类也运行。为什么呢？原因是：在子类的构造函数中第一行有一个默认的隐式语句。super();

子类的实例化过程,子类中的构造函数默认都会访问父类中的空参数构造函数.

class Father
{
    Father()
    {
        System.out.println("Father run");
    }
}

class Son extends Father
{
    Son()
    {
        //super(); //隐藏的语句，此语句是调用父类的空参数构造函数
        System.out.println("Son run");
        //return;
    }
}

class ExtendsDome
{
    public static void main(String[] args)
    {
        new Son();
    }
}

//运行结果
//Father run
//Son run

 

为什么子类实例化的时候要访问父类的构造函数呢？

那是因为子类继承了父类，获取到了父类的内容（属性），所以在使用父亲内容之前，要先看父类如何对自己的内容进行初始化的。所以子类在构造对象时，必须访问父类中的构造函数。为什么完成这个必须的动作，就在子类的构造函数中加入了super（）语句。 如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要掉调用父类中哪个构造函数.同时子类构造函数中如果使用this调用了本类构造函数时，那么super就没有被替换了，因为super和this只能定义在第一行，所以只能有一个。但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。注意的是super语句必须要定义在子类构造函数的第一行，因为父类的初始化动作要先完成。

class Father
{
    Father()
    {
        System.out.println("Father run");
    }
    Father(int x)
    {
        System.out.println("Father run ..." + x);
    }
}

class Son extends Father
{
    Son()
    {
        //super();//这里回去初始化父类的构造函数
        System.out.println("Son run");
        return;
    }
    Son(int x)
    {
        this();
        //super();//这里的super()会被替换，因为this()与super()只能写在第一行。
        System.out.println("Son run ..." + x);
        return;
    }
}

class ExtendsDome
{
    public static void main(Sring[] args)
    {
        new Son(6);
    }
}

//运行结果
//Father run
//Son run
//Son run ...6

 

class Father
{
    Father()
    {
        super();
        show();
        return;
    }
    
    public void show()
    {
        System.out.println("Father show");
    }
}

class Son extends Father
{
    int num = 8;
    
    Son()
    {
        super();
        //通过super初始化父类时，子类的成员变量并未显示初始化。等super()父类初始化完毕后，才进行子类的成员变量显示初始化。
        show();
        return;
    }
    public void show()
    {
        System.out.println("Son show ..." + num);
    }
}

class ExtendsDome
{
    public static viod main(String[] args)
    {
        Son son = new Son();
        son.show();
    }
}

//运行结果
//Son show ...0
//Son show ...8