Java中的继承

学习笔记

目录：
一、继承的实现
二、继承中成员变量、构造方法、成员方法访问特点
1、继承中成员变量访问的特点
2、继承中构造方法访问的特点：子类所有的构造方法都会访问父类的无参构造方法
3、继承中成员方法访问的特点
三、继承的特点
1、在继承时，子类会继承父类的所有结构。包括属性和方法
2、Java只允许单继承不允许多继承（一个子类继承一个父类）

参考文章：Java中继承的定义与使用

一、继承的实现

在Java中，继承用extends关键字来实现。

继承的格式：
public class 子类名 extends 父类名{}
范例：public class Zi extends Fu{}

继承的好处：

• 提高了代码的复用性（多个类相同的成员可以放到同一个类中）
• 提高了代码的维护性（如果方法的代码需要修改，修改一处即可）

二、继承中成员变量、构造方法、成员方法访问特点

1、继承中成员变量访问的特点

在子类方法中访问一个变量

• 先在子类局部范围找（方法内找）
• 在在子类成员范围找
• 最后在 父类找
• 如果都没有就会报错（不考虑父亲的父亲）

public class Fu {
    public int age = 20;
    public int height = 170;
    public String name = "fu";
}

public class Zi extends Fu {
    public int height = 175;
    public String name = "zi";

    public void show(){
        String name = "zi局部变量";
        System.out.println("age=" + age);//age是父类中的
        System.out.println("height=" + height);
        System.out.println("name=" + name);
    }
}

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

2、继承中构造方法访问的特点：子类所有的构造方法都会访问父类的无参构造方法

在下面范例中可以发现，子类在调用无参和带参构造方法时，结果都访问了父类的无参构造方法，并在结果中输出了父类的无参构造方法被调用

//父类
public class Fu {
    public Fu(){
        System.out.println("父类的无参构造方法被调用");
    }

    public Fu(int age){
        System.out.println("父类的带参构造方法被调用");
    }
}

//子类
public class Zi extends Fu {
    public Zi(){
        System.out.println("子类的无参构造方法被调用");
    }

    public Zi(int age){
        System.out.println("子类的带参构造方法被调用");
    }
}

//测试入口类
public class ExtendsDemo {
    public static void main(String[] args) {
        Zi z = new Zi();
        System.out.println("---------------");
        Zi z2 = new Zi(30);
    }

}

为什么子类所有的构造方法都会访问父类的无参构造方法呢？

• 因为子类会继承父类中的数据，可能还会使用父类的数据，所以子类初始化之前，一定要先完成父类数据的初始化
• 每一个子类构造方法的第一条语句默认都是super()，super()即访问父类的构造方法,super.变量名即访问父类的成员变量

如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

• 通过使用super关键字去显示的调用父类的带参构造方法
• 在父类中自己提供一种无参构造方法
• 推荐：自己给出无参构造方法
• 父类中没有无参构造方法---范例

public class Fu {
//    public Fu(){
//        System.out.println("父类的无参构造方法被调用");
//    }

    public Fu(int age){
        System.out.println("父类的带参构造方法被调用");
    }

}

public class Zi extends Fu {
    public Zi(){
        super(20);//通过使用super关键字去显示的调用父类的带参构造方法
        System.out.println("子类的无参构造方法被调用");
    }

    public Zi(int age){
        super(20);//通过使用super关键字去显示的调用父类的带参构造方法
        System.out.println("子类的带参构造方法被调用"+age);
    }
}

public class ExtendsDemo {
    public static void main(String[] args) {
        Zi z = new Zi();
        System.out.println("---------------");
        Zi z2 = new Zi(30);
    }

}

3、继承中成员方法访问的特点

• 通过子类对象访问一个方法，首先会在子类成员范围找（下面范例中method()方法在子类和父类中都有。在通过子类调用method()该方法时，输出的是子类的方法结果）
• 在去父类成员方法范围找
• 如果找不到就会报错（不考虑父亲的父亲）

public class Fu {
    public void method(){
        System.out.println("父类中的method方法被调用");
    }
    public void show(){
        System.out.println("父类中的show方法被调用");
    }
}

public class Zi extends Fu {
    public void method(){
        System.out.println("子类中的method方法被调用");
    }
}

public class ExtendsDemo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();
        z.show();
    }
}

三、继承的特点

1、在继承时，子类会继承父类的所有结构，包括属性和方法。

• 在进行继承的时候，子类会继承父类的所有结构（包括私有属性、构造方法、普通方法）
• 显示继承：所有非私有操作属于显示继承（可以直接调用）。
• 隐式继承：所有私有操作属于隐式继承（不可以直接调用，需要通过其它形式调用（get或者set））

public class Fu {
    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 Fu() {
        System.out.println("父类的构造方法");
    }

    public void fun() {
        System.out.println("父类的fun()方法");
    }
}

public class Zi extends Fu {
    private String schoolName;
    public String getSchoolName()
    {
        return schoolName;
    }
    public void setSchoolName(String schoolName)
    {
        this.schoolName=schoolName;
    }
    public Zi()
    {
        System.out.println("子类的构造方法");
    }
}

public class ExtendsDemo {
    public static void main(String[] args) {
        Zi Zi=new Zi();//调用构造方法时首先会访问父类的构造方法
        System.out.println("--------------------");
        Zi.setName("小明");
        Zi.setAge(18);
        //隐式继承
        System.out.println("姓名："+Zi.getName()+" 年龄："+Zi.getAge());
        System.out.println("--------------------");
        //显示继承
        Zi.fun();//子类没有的方法会去父类成员方法找
    }
}

此时父类中的属性以及方法均被子类所继承，但是发现子类能够使用的是所有非private操作，而所有的private操作无法被直接使用，所以称为隐式继承。

2、Java只允许单继承不允许多继承（一个子类继承一个父类）