Java进阶篇之继承的概念

引言

在前面的文章中，我们较为完整的捋了捋Java的基础知识（Java基础篇合集）在面向对象编程（OOP）中，继承（Inheritance）是一个核心概念。通过继承，子类可以获取父类的属性和方法，从而实现代码的复用和扩展。继承不仅提高了代码的可维护性，还使得代码结构更加清晰。在本篇文章中，我们将详细探讨Java中的继承概念，包括其定义、语法规则、使用方法和相关注意事项。

文章目录

- - - 引言
    - 一、继承的基本概念
    - 二、继承的实际应用
    - - [1. 创建父类和子类](#1. 创建父类和子类)
      - [2. 重写方法（Override）](#2. 重写方法（Override）)
    - 三、继承的层次结构和多级继承
    - 四、继承中的访问修饰符
    - 五、继承中的注意事项
    - 六、继承的优势与局限
    - 七、知识结构图解
    - 八、总结

一、继承的基本概念

继承是面向对象编程中用于创建新类的技术，通过继承，新类（子类）可以继承现有类（父类）的属性和方法。子类不仅可以复用父类的代码，还可以在其基础上添加新的属性和方法，甚至重写父类的方法。

继承的核心特点：

代码复用：子类可以复用父类的代码，避免重复编写相同的功能。
扩展性：子类可以在父类的基础上扩展新的功能。
层次结构：继承可以形成类的层次结构，有助于代码组织和管理。

继承的基本语法：

java 复制代码

class ParentClass {
    // 父类的属性和方法
}

class ChildClass extends ParentClass {
    // 子类的属性和方法
}

在上面的代码中，ChildClass继承自ParentClass，这意味着ChildClass拥有ParentClass的所有属性和方法。

二、继承的实际应用

1. 创建父类和子类

以下是一个简单的继承示例，展示了如何创建一个父类和一个子类：

java 复制代码

// 定义父类
class Animal {
    String name;
    
    void eat() {
        System.out.println(name + " is eating.");
    }
}

// 定义子类
class Dog extends Animal {
    void bark() {
        System.out.println(name + " is barking.");
    }
}

// 使用子类
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "Buddy";
        dog.eat(); // 调用父类的方法
        dog.bark(); // 调用子类的方法
    }
}

在这个例子中，Dog类继承了Animal类，因此Dog对象可以调用Animal类的eat方法。此外，Dog类还增加了一个bark方法，展示了子类在继承父类的基础上如何扩展新的功能。

2. 重写方法（Override）

在继承中，子类可以重写父类的方法，这称为方法重写（Method Overriding）。重写的方法必须具有与父类方法相同的签名（方法名和参数列表）。

java 复制代码

class Animal {
    void makeSound() {
        System.out.println("Animal is making a sound.");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound(); // 输出: Animal is making a sound.

        Dog dog = new Dog();
        dog.makeSound(); // 输出: Dog is barking.
    }
}

在这个例子中，Dog类重写了Animal类的makeSound方法，当调用dog.makeSound()时，输出的是子类的实现内容。

三、继承的层次结构和多级继承

继承可以形成类的层次结构，使得类之间具有清晰的关系。在Java中，继承是单一继承，即一个类只能继承一个父类，但可以通过多级继承实现更复杂的层次结构。

java 复制代码

class Animal {
    void move() {
        System.out.println("Animal is moving.");
    }
}

class Mammal extends Animal {
    void breastfeed() {
        System.out.println("Mammal is breastfeeding.");
    }
}

class Dog extends Mammal {
    void bark() {
        System.out.println("Dog is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.move(); // 调用 Animal 类的方法
        dog.breastfeed(); // 调用 Mammal 类的方法
        dog.bark(); // 调用 Dog 类的方法
    }
}

在这个例子中，Dog类通过多级继承（继承自Mammal，而Mammal又继承自Animal），得到了Animal和Mammal类的所有方法。

四、继承中的访问修饰符

在继承中，访问修饰符（如private、protected、public、默认）决定了子类是否可以访问父类的成员变量和方法。

private ：子类无法访问父类的private成员。
protected ：子类可以访问父类的protected成员，且在子类中可见。
public ：子类可以访问父类的public成员。
默认（无修饰符）：子类可以访问同包内父类的成员，但不能访问不同包内的父类成员。

java 复制代码

class Parent {
    private String secret = "secret";
    protected String familyName = "Smith";
    public String publicInfo = "Public Information";
    
    public String getSecret() {
        return secret;
    }
}

class Child extends Parent {
    void showInfo() {
        // System.out.println(secret); // 错误: 无法访问private成员
        System.out.println(familyName); // 正确: 可以访问protected成员
        System.out.println(publicInfo); // 正确: 可以访问public成员
        System.out.println(getSecret()); // 正确: 通过公有方法访问private成员
    }
}

在这个示例中，Child类可以访问familyName和publicInfo，但不能直接访问secret，需要通过getSecret方法来获取。

五、继承中的注意事项

重要注意事项：

构造方法 ：子类不能继承父类的构造方法，但可以通过super()调用父类的构造方法。子类的构造方法会首先调用父类的构造方法。
final关键字 ：使用final关键字修饰的类不能被继承，使用final修饰的方法不能被重写。
多重继承：Java不支持多重继承（一个类不能有多个直接父类），但可以通过接口实现类似的功能。

六、继承的优势与局限

优势：

代码复用：继承允许子类复用父类的代码，减少了重复代码。
层次结构：继承可以形成清晰的类层次结构，有助于代码的组织和维护。

局限：

耦合度增加：继承会增加类之间的耦合度，子类依赖于父类的实现，这可能导致代码的灵活性降低。
继承深度：如果继承层次过深，代码结构可能变得复杂难以理解。

七、知识结构图解

以下是本文的知识结构图示：
继承的基本概念代码复用扩展性层次结构继承的实际应用创建父类和子类重写方法继承的层次结构和多级继承继承中的访问修饰符 private protected public 默认继承中的注意事项构造方法 final关键字多重继承继承的优势与局限代码复用层次结构耦合度增加继承深度

八、总结

继承是面向对象编程的核心特性之一，它通过让子类继承父类的属性和方法，实现了代码的复用和扩展。然而在使用继承时，开发者需要注意类之间的耦合度和继承层次的深度，以保持代码的简洁和可维护性。

在后续的进阶篇中，我们将继续深入探讨Java继承中的super关键字以及其他重要概念，帮助你更好地掌握Java的高级特性，敬请期待！