Java进阶篇之继承的概念

引言

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

一、继承的基本概念

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

继承的核心特点：

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

继承的基本语法：

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

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

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

二、继承的实际应用

1. 创建父类和子类

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

// 定义父类
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）。重写的方法必须具有与父类方法相同的签名（方法名和参数列表）。

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中，继承是单一继承，即一个类只能继承一个父类，但可以通过多级继承实现更复杂的层次结构。

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成员。
• 默认（无修饰符）：子类可以访问同包内父类的成员，但不能访问不同包内的父类成员。

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不支持多重继承（一个类不能有多个直接父类），但可以通过接口实现类似的功能。

六、继承的优势与局限

优势：

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

局限：

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

七、知识结构图解

以下是本文的知识结构图示：

八、总结

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

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