Java 继承

最新推荐文章于 2024-10-10 09:56:47 发布

楠枬

最新推荐文章于 2024-10-10 09:56:47 发布

阅读量1k

点赞数 76

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/2301_76161469/article/details/142621979

版权

Java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

什么是继承

在 Java 中，使用类来对现实中的实体进行描述，例如

定义一个 Cat 类来描述猫：

public class Cat {
    String name;
    int age;
    public void eat() {
        System.out.println("吃饭");
    }
}

定义一个 Dog 类来描述狗：

public class Dog {
    String name;
    int age;
    public void eat() {
        System.out.println("吃饭");
    }
}

而上述代码中的 name、age 以及 eat 方法，都是重复的

此时，就可以对这些共性进行抽取

而在面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用

继承（inhertance）：是面向对象编程的特征，它允许在保持原有类的基础上进行扩展，增加新的功能，这样产生的新类，称之为派生类。通过继承，能够实现共性的抽取，从而实现代码的复用

我们将上述 Cat 和 Dog 的共性进行抽取，使用继承的思想来达到复用效果：

如上图所示，Dog 和 Cat 都继承了 Animal 类，其中，Animal 称为 父类（或超类、基类），Dog 和 Cat 称之为 Animal 的 子类（或派生类），继承之后，子类可以复用父类中的成员，子类在实现时只需关心自己新增的成员即可

继承的语法

在 Java 中若要表示类之间的继承关系，需要使用 extends 关键字：

修饰符 class 子类 extends 父类{

...

}

public class Animal {
    String name;
    int age;

    public void eat() {
        System.out.println("吃饭");
    }
}

Cat 类继承 Animal，还可以新增需要的成员变量或方法

public class Cat extends Animal{
    public void miaow() {
        System.out.println("喵喵叫");
    }
}

子类会将父类中的成员变量或成员方法继承到子类中

子类在继承父类之后，可以添加自己特有的成员

父类成员的访问

子类将父类中的方法和变量继承之后，那么，子类中能否直接访问父类中继承下来的成员呢？

访问父类的成员变量

当子类和父类不存在同名对象时

public class A {
    int a = 10;
}

public class B extends A {
    int b = 20;

    public static void main(String[] args) {
        B b = new B();
        System.out.println(b.a);
        System.out.println(b.b);
        // System.out.println(b.c); // 编译失败，子类和父类中都不存在 c 
        b.method();
    }
}

运行结果：

子类自己有就访问自己的成员变量，若没有，就访问父类的成员变量

当子类和父类存在同名对象时

public class A {
    int a = 10;
    int b = 20;
}

public class B extends A {
    int a = 100; // 与父类中的成员同名，且类型相同
    char b = 'b'; // 与父类中的成员同名，但类型不同
    public void method() {
        System.out.println("a: " + a + " b: " + b);
    }

    public static void main(String[] args) {
        B b = new B();
        b.method();
    }
}

运行结果：

存在同名变量时，优先访问子类的成员变量

从上述两个示例中，可以看出：

若访问的成员变量子类中有，则访问子类自己的成员变量

若访问的成员变量子类中没有，则访问父类中继承下来的，若父类中也没有，则会编译报错

若访问的成员变量，父类子类中都有，则优先访问自己的成员变量

即 自己有就优先自己的，若没有再向父类中找

访问父类的成员方法

成员方法名不同

public class A {
    int a = 10;
    int b = 20;
    public void methodA() {
        System.out.println("methodA...");
    }
}

public class B extends A {
    int a = 100; // 与父类中的成员同名，且类型相同
    char b = 'b'; // 与父类中的成员同名，但类型不同
    public void methodB() {
        System.out.println("methodB...");
    }

    public static void main(String[] args) {
        B b = new B();
        b.methodA();
        b.methodB();
//        b.methodC(); // 编译失败，在继承体系中没有发现 methodC()
    }
}

运行结果：

当成员方法没有同名时，在子类方法中或通过子类对象访问方法时，若自己有，访问自己的，若自己没有，则在父类中找，若父类中也没有，则报错

成员方法名相同

public class B extends A {
    int a = 100; // 与父类中的成员同名，且类型相同
    char b = 'b'; // 与父类中的成员同名，但类型不同
    public void methodA(int a) {
        System.out.println("methodA..." + a);
    }

    public static void main(String[] args) {
        B b = new B();
        b.methodA();
        b.methodA(10);
    }
}

运行结果：

当子类方法名和父类方法名相同，但其参数列表不同时，就构成了重载，根据调用方法时传递的参数选择合适的方法访问，若不存在该方法，则报错

public class B extends A {
    int a = 100; // 与父类中的成员同名，且类型相同
    char b = 'b'; // 与父类中的成员同名，但类型不同

    @Override
    public void methodA() {
        System.out.println("B methodA...");
    }

    public static void main(String[] args) {
        B b = new B();
        b.methodA();
    }
}

当子类方法名和父类方法名相同，且其参数列表也相同时，就构成了重写，此时，会访问子类的方法

那么，当子类中存在和父类相同的成员时，如何在子类中访问父类同名成员呢？

super 关键字

当子类和父类中存在相同名称的成员时，若要在子类方法中访问父类同名成员时，是不能直接访问的。Java 提供了 super 关键字，super 的主要作用：在子类方法中访问父类成员

访问父类成员变量

public class B extends A {
    int a = 100; // 与父类中的成员同名，且类型相同
    char b = 'b'; // 与父类中的成员同名，但类型不同

    public void methodB() {
        System.out.println(super.a);
        System.out.println(super.b);
    }

    public static void main(String[] args) {
        B b = new B();
        b.methodB();
    }
}

访问父类成员方法

public class B extends A {
    int a = 100; // 与父类中的成员同名，且类型相同
    char b = 'b'; // 与父类中的成员同名，但类型不同

    public void methodB() {
        super.methodA();
        System.out.println("methodB...");
    }

    public static void main(String[] args) {
        B b = new B();
        b.methodB();
    }
}

需要注意的是：只能在非静态方法中使用 super

访问父类构造方法

在子类对象构造时，会先调用父类构造方法，然后再执行子类构造方法

为 A 添加带一个参数的构造方法

public class A {
    int a = 10;
    int b = 20;
    public A(int a) {
        System.out.println("a");
    }
    public void methodA() {
        System.out.println("methodA...");
    }
}

编译报错：A 中没有可用的默认构造函数

为什么会报错呢？

这是因为在 A 中没有定义的构造方法时，编译器提供了默认的无参构造方法

子类 B 中也没有定义构造方法，编译器也提供了默认的无参构造方法，且在 B 的构造方法中第一行默认有隐含的 super() 调用父类的无参构造方法

当添加了带有一个参数的构造方法后，编译器也就不再提供无参的构造方法，此时也就会报错

我们可以在 A 中添加无参构造方法

或是在 B 的无参构造方法中调用 A 带有一个参数的构造方法

    public B(int a) {
        super(a);
    }

当父类中有多个构造方法时，就需要在子类构造方法中选择一个合适的父类构造方法调用，否则编译失败

为什么要先调用父类的构造方法呢？

子类对象中的成员是由两部分组成的：父类继承下来的成员 和 子类新增的成员

因此，在构造子类对象时，就需要先调用父类的构造方法，将从父类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增的成员初始化完整

在子类构造方法中，通过 super(...) 调用父类构造，且 super(...) 必须是子类构造函数中的第一条语句

因此，super(...) 只能在子类构造方法中出现一次，且必须在第一行

而若需要在构造方法中使用 this 关键字调用类中的其他构造方法，也必须在第一行使用，也就是说，super(...) 和 this(...) 不能同时出现

super 和 this

相同点

（1）都是 Java 中的关键字

（2）都可以在成员方法中用来访问成员变量和调用其他成员方法，都可以作为构造方法的第一条语句

（3）只能在类的非静态方法中使用，用来访问非静态成员方法和变量

（4）在构造方法中调用时，必须是构造方法的第一条语句，并且不能同时存在

不同点

（1）this 表示当前对象（实例方法的对象）的引用，而 super 表示子类对象重父类继承下来部分成员的引用

（2）在非静态成员方法中，this 用来访问本类的方法和属性，super 用来访问父类继承下来的方法和属性

（3）在构造方法中，this(...) 用于调用本类构造方法，super(...) 用于调用父类构造方法，两种调用不能同时在构造方法中出现

（4）构造方法中一定会存在 super(...) 的调用，但 this(...) 若没有写则没有

初始化

在前面的文章 Java 代码块-CSDN博客中，我们学习了代码块，重点学习了 实例代码块 和 静态代码块，以及它们的执行顺序，接下来，我们就来看存在继承关系时，它们的执行顺序

public class A {
    int a;
    int b;
    {
        a = 10;
        b = 20;
        System.out.println("A 构造代码块执行...");
    }

    static {
        System.out.println("A 静态代码块执行...");
    }
    public A(int a) {
        System.out.println("A 构造方法执行...");
    }
    public void methodA() {
        System.out.println("methodA...");
    }
}

public class B extends A {
    int a = 100; // 与父类中的成员同名，且类型相同
    char b = 'b'; // 与父类中的成员同名，但类型不同

    static {
        System.out.println("B 静态代码块执行...");
    }

    {
        System.out.println("B 构造代码块执行...");
    }
    public B(int a) {
        super(a);
        System.out.println("B 构造方法执行...");
    }

    public void methodA() {
        System.out.println("methodB...");
    }

    public static void main(String[] args) {
        B b1 = new B(10);
        System.out.println("---------------------");
        B b2 = new B(20);
    }
}

运行结果：

通过运行结果，可以看到：

静态代码块先执行，并且只执行一次，在类加载阶段执行

父类静态代码块优先于子类静态代码块执行，且最早执行

当有对象创建时，才会执行实例代码块

父类实例代码块和父类构造方法先执行，然后再执行子类的实例代码块和子类的构造方法

访问限定符

为了实现封装性，Java 引入了访问限定符，主要限定：类或类中成员能否在类外或其他包中被访问

范围	private	default	protected	public
同一个包中的同一个类	√	√	√	√
同一个包中的不同类		√	√	√
不同包中的子类			√	√
不同包中的非子类				√

public：在任何类都可以访问

protected：在同一个包中的类或不同包中的子类可以访问

default：同一个包中的类可以访问

private：只有该类内部可以访问

当 A 和 B 位于同一个包中时：

public class A {
    public int a;
    int b;
    protected int c;
    private int d;
}

public class B extends A {
    public void method() {
        super.a = 10;
        super.b = 20;
        super.c = 30;
        super.d = 40;
    }
}

由于变量 d 是 A 私有的，即只能在 A 类中访问，因此，子类中不能直接访问

但是，父类中的 private 成员变量虽然不能在子类中直接访问，但是也继承到子类中了

子类可以通过父类提供的方法来进行修改

public class A {
    public int a;
    int b;
    protected int c;
    private int d;

    public int getD() {
        return d;
    }

    public void setD(int d) {
        this.d = d;
    }
}

public class B extends A {
    public void method() {
        super.a = 10;
        super.b = 20;
        super.c = 30;
        super.setD(40);
    }
}

当 A 和 B 位于不同包中：

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

继承方式

在 Java 中，支持的继承方式有：

（1）单继承

（2）多层继承

（3）不同类继承同一个类

（4）多继承（不支持）

Java 中不支持多继承

类是对现实事物的抽象，而当情况比较复杂时，涉及到的类也会比较多，类之间的关系也会比较复杂

但即使如此，我们并不希望类之间的继承层次太复杂，一般不希望出现超过三层的继承关系

此时，若想从语法上限制继承，就可以使用 final 关键字

final 关键字

final 可以用来修饰变量、成员方法以及类

当修饰变量时，表示该变量为常量（不可变）

当修饰方法时，表示该方法不能被重写

当修饰类时，表示该类不能被继承

继承和组合

与继承类似，组合也是一种表达类之间关系的方式，也能够达到代码重用的效果。

但组合并没有涉及到特殊的语法，仅仅是将一个类的实例作为另一个类的字段

继承表示的对象之间是 is a 的关系，如：猫是动物

组合表示的对象之间是 has a 的关系，如：电脑有键盘

组合：

public class Person {
    private Student[] students;
}

此时 Student 属于 Person 的一部分，在 Person 中，可以复用 Student 中的属性和方法

继承：

public class Student extends Person{

}

Student 是 Person 的子类，继承了父类的成员，能够复用父类中的属性和方法

组合和继承都可以实现代码复用，是使用组合还是继承，需要根据具体的情况来进行选择

楠枬

关注

76
点赞
踩
70

收藏

觉得还不错? 一键收藏
打赏
67
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录