Java SE知识点五：面向对象之：继承

最新推荐文章于 2024-09-10 10:21:38 发布

无限进步的Wilbur

最新推荐文章于 2024-09-10 10:21:38 发布

阅读量1.1k

点赞数 28

分类专栏： Java SE知识点文章标签： java 开发语言改行学it idea intellij idea 后端

本文链接：https://blog.csdn.net/Wilburli99/article/details/140905867

版权

Java SE知识点专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1. 什么是继承

1.1 继承的概念

Java中的类是对事物的抽象描述，但有时候一个类与其他类有许多的共性，比如猫和狗都是动物，那么猫和狗这两个类就难免会有许多相似之处：

class Dog{
    public String name;
    public int age;
    public String color;

    public void eat(){
    
    }

    public void sleep(){

    }
}

class Cat{
    public String name;
    public int age;
    public String color;

    public void eat(){
    
    }

    public void sleep(){

    }
}

可以看到，这两个类的成员变量和方法都可以有许多相似之处。

那么，是不是可以将这些共性的东西提取出来，形成一个动物类，让猫和狗之间使用呢？这就要说到Java中的继承了。所以，可以定义一个动物类，然后让猫类和狗类继承这些共性。

1.2 继承的语法

继承使用的是 extends 关键字：

class Animal{
    String name;
    int age;
    public void eat(){
        System.out.println(name + "eating");
    }
    public void sleep(){
        System.out.println(name + "sleeping");
    }
}


class Dog extends Animal{
    //继承后，狗类就可以使用动物类的成员变量和方法
    void bark(){
        System.out.println(name + "barking");
    }
}

public class TestExtend {
    public static void main(String[] args) {
        Dog dog = new Dog();
        // name和age属性肯定是从父类Animal中继承下来的
        System.out.println(dog.name);
        System.out.println(dog.age);
        // 方法也是从Animal中继承下来的
        dog.eat();
        dog.sleep();
        dog.bark(); //子类自己的方法
    }
}

我们称被继承的类为父类或基类，继承者称为子类。

子类可以在自己的类中添加特有的方法和变量，以区分共性和特性。

2. 父类与子类

2.1 子类访问父类成员变量

当子类中的成员变量与父类当中的成员变量不同时，子类可以直接访问父类的成员变量。

class Base {
    int a;
    int b;
}

class Derived extends Base{
    int c;
    public void method(){
        a = 10; // 访问从父类中继承下来的a
        b = 20; // 访问从父类中继承下来的b
        c = 30; // 访问子类自己的c
    }
}

因为子类继承了父类的成员变量，所以当变量名称不同时，可以区分出父类和子类的成员变量。

而当子类中的成员变量与父类中的成员变量名称相同时呢？

class Base {
    int a;
    int b;
}

class Derived extends Base{
    int c;
    int a; //子类中有同名变量

    public void method(){
        a = 10; // 访问的是谁的 a ？
        b = 20; // 访问从父类中继承下来的b
        c = 30; // 访问子类自己的c
    }
}

这个情况下，会访问父类的变量 a 还是子类的呢？

答案是会访问子类的成员变量，因为遵循以下规律：

如果访问的成员变量子类中有，优先访问子类自己的；
如果访问的成员变量子类中没有，则访问从父类中继承下来的，如果父类也没有，则报错；
如果访问的成员变量子类和父类中都有且同名，则优先访问子类自己的。

2.2 子类访问父类成员方法

访问成员方法的情况与成员变量相同，如果成员方法名称不同，则访问父类继承的。

class Base {
    public void methodA(){
        System.out.println("Base中方法");
    }
}


class Derived extends Base{
    public void methodB(){
        System.out.println("Derived中的方法");
    }
    public void methodC(){
        methodB(); // 访问子类自己的methodB()
        methodA(); // 访问父类继承的methodA()
    }
}

那么当子类中的成员方法和父类中的相同时，怎么访问呢？

class Base {
    public void methodA(){
        System.out.println("Base中的A方法");
    }
    public void methodB(){
        System.out.println("Base中的B方法");
    }
}

class Derived extends Base{
    public void methodA(int a) {
        System.out.println("Derived中的int A方法");
    }
    public void methodB(){
        System.out.println("Derived中的B方法");
    }

    public void methodC(){
        methodA(); // 没有传参，访问父类中的methodA()
        methodA(20); // 传递int参数，访问子类中的methodA(int)
        methodB(); // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
    }
}

这里也会遵循以下规则：

通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错

那么就会引出一个问题，当子类中的成员名称和父类中的相同时，怎么访问父类的成员呢？

这就要引出 super 关键字了。

3. super关键字

3.1 super 的用法

有时候，会出现子类和父类存在相同名称的成员，那么这种情况下如何访问父类的成员呢，Java中的 super 关键字可以在子类中访问父类成员。

class Base {
    int a;
    int b;
    public void methodA(){
        System.out.println("Base中的A方法");
    }
    public void methodB(){
        System.out.println("Base中的B方法");
    }
}

class Derived extends Base{
    int a; // 与父类中成员变量同名且类型相同
    char b; // 与父类中成员变量同名但类型不同

    // 与父类中methodA()构成重载
    public void methodA(int a) {
        System.out.println("Derived中的int A方法");
    }

    // 与基类中methodB()构成重写(即原型一致)
    public void methodB(){
        System.out.println("Derived中的B方法");
    }

    public void methodC(){
        // 对于同名的成员变量，直接访问时，默认访问的都是子类的
        a = 100; // 等价于： this.a = 100;
        b = 101; // 等价于： this.b = 101;
        // 注意：this是当前对象的引用

        // 访问父类的成员变量时，需要借助super关键字
        // super是获取到子类对象中从父类继承下来的部分
        super.a = 200;
        super.b = 201;

        // 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
        methodA(); // 没有传参，访问父类中的methodA()
        methodA(20); // 传递int参数，访问子类中的methodA(int)

        // 如果在子类中要访问重写的基类方法，则需要借助super关键字
        super.methodB(); // 访问父类的methodB()
    }
}

从上述代码中可以总结一下：

当成员变量同名时，在子类中，this. 访问子类自己的成员，super. 访问父类的；
当成员方法同名时（不是方法的重载），构成方法的重写（即返回值相同，参数相同，名称相同），这时，使用 super. 访问父类的成员方法；

需要注意的是：1. this访问的时候，不仅可以访问子类的，也可以访问父类的
2. 当使用this访问父类和子类同名的成员变量时，优先访问子类
3. super只能访问从父类继承过来的成员变量

3.2 子类的构造方法

构造方法前面也提到过，和成员方法的区别是，成员方法有 void ，而构造方法没有。

当父类中存在构造方法时，无论有无参数，子类在继承时，都要和父类一样存在构造方法且参数相同。而且，在执行子类中的构造方法时，会先执行父类的构造方法。

使用 IntelliJ IDEA 写代码时，可以鼠标右键--生成，一键生成构造方法，还是很方便的。

class Animals{
    String name;
    int age;

    public Animals(String name) { //一个参数的构造方法
        this.name = name;
    }

    public void eat(){  //子类重写父类的成员方法
        System.out.println(name + "正在吃饭");
    }
    public void sleep(){
        System.out.println(name + "正在睡觉");
    }
}

//子类dog
class Dog extends Animals{

    public Dog(String name) { //子类中可以创造匹配super的构造方法
        super(name);
    }
    public void eat(){
        System.out.println(name + "正在吃狗粮");
    }

    public void bark(){
        System.out.println(name + "汪汪汪~~~");
    }
}

需要注意的是：

若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法
如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。
super(...)只能在子类构造方法中出现一次，并且不能和 this 同时出现，因为都只能在第一行

3.3 super 与 this

super和this都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那他们之间有什么区别呢？

相同点：

都是Java中的关键字
只能在类的非静态方法中使用，用来访问非静态成员方法和字段
在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

不同点：

this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用
在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
在构造方法中，this(...) 用于调用本类构造方法，super(...) 用于调用父类构造方法，两种调用不能同时在构造方法中出现
构造方法中一定会存在 super(...) 的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有

3.4 继承当中的初始化

上一章提到了使用代码块进行初始化，实例代码块和静态代码块的执行顺序是：静态>实例。

而出现构造方法后，它们的执行顺序会有什么变化：

静态代码块先执行，并且只执行一次，在类加载阶段执行
当有对象创建时，才会执行实例代码块，实例代码块执行完成后，最后构造方法执行

所以，它们三个点执行顺序是：静态代码块（只执行一次） > 实例代码块 > 构造方法。

以上是在非继承情况下，那么在继承情况下，它们的顺序呢：

父类静态代码块优先于子类静态代码块执行，且是最早执行
父类实例代码块和父类构造方法紧接着执行
子类的实例代码块和子类构造方法紧接着再执行
第二次实例化子类对象时，所有静态代码块都不执行

结论是，在继承环境下，首先：父类 > 子类，其次：静态 > 实例 > 构造。

4. protected关键字

我们前面提到的几个限定词：public，private，default，protected，其中protected提到了可以在不同包的子类中访问，这里，提到了子类，那父类中不同访问权限的成员，在子类中的可见性又是什么样子的呢?

// extend01包中
class B {
    private int a; 
    protected int b; 
    public int c;
    int d;
}

// extend01包中
// 同一个包中的子类 
class D extends B{
    public void method(){
        // super.a = 10;// 编译报错，父类private成员在相同包子类中不可见 
        super.b = 20; // 父类中protected成员在相同包子类中可以直接访问
        super.c = 30; // 父类中public成员在相同包子类中可以直接访问
        super.d = 40; // 父类中默认访问权限修饰的成员在相同包子类中可以直接访问
    } 
}

// extend02包中
// 不同包中的子类
class C extends B {
    public void method(){
        // super.a = 10; // 编译报错，父类中private成员在不同包子类中不可见
        super.b = 20; // 父类中protected修饰的成员在不同包子类中可以直接访问
        super.c = 30; // 父类中public修饰的成员在不同包子类中可以直接访问
        //super.d = 40; // 父类中默认访问权限修饰的成员在不同包子类中不能直接访问
    }
}

上述代码解释了protected限定词在不同包的子类中可以访问的情况。

很明显，如果在不同包的非子类，即其他类中则不能访问。

5. 继承的多种方式

继承的方式有很多种，像刚才提到的狗继承动物类，是单继承。

还有多层继承和不同类继承同一类。

多层继承：C 继承 B，B 继承 A。因此 C 也间接继承了 A。

不同类继承同一类：C 和 B 同时继承了 A，但 C 和 B直接没有继承关系。

需要注意，Java中不支持一个类继承多个类，但这种思想可以通过后面会提到的接口来实现。

6. final 关键字

final 关键字也是用来修饰成员变量和成员方法的：

修饰变量的时候就会把变量变成常量，不能修改：

final int a = 10;
a = 20; //error

修饰方法的时候也是同理。表示该方法不能被重写。

另外，final 关键字还可以用来修饰类，被 final 修饰的类表示不能被继承。我们平时使用的 String 字符串类就是被 final 修饰的，所以不能被修改（可以使用 StringBuilder）。

7. 继承与组合

看到这里，大家可能会对继承有了比较深的了解，就像字面意思中的关系：狗是动物，猫是动物。继承者与被继承者之间是 is - a 的关系。

而还有一种思想是组合，就像是汽车与部件之间的关系：汽车有轮胎。是一种 has - a 的关系。

下面举一个例子：

// 轮胎类 
class Tire{
    // ...
}
// 发动机类 
class Engine{
    // ...
}
// 车载系统类
class VehicleSystem{
    // ...
}

class Car{
    private Tire tire; // 可以复用轮胎中的属性和方法
    private Engine engine; // 可以复用发动机中的属性和方法
    private VehicleSystem vs; // 可以复用车载系统中的属性和方法
    // ...
}

上述代码就是一个组合的过程，组合没有什么特别的语法结构，是一种思想。

当然，组合可以和继承串联起来，上述的汽车类，就可以具体化一个宝马汽车，创建一个宝马汽车，然后继承汽车类。