封装

封装是一种隐藏类的内部实现细节的方法。它通过将数据和操作封装在一个单元（类）中来保护数据完整性。在 Java 中，封装是通过访问修饰符（如 private、protected 和 public）来实现的。

private：仅在类内部可见。
protected：在类及其子类和同一包中的类中可见。
public：在任何类中都可以访问。
封装的好处包括：

数据隐藏：保护数据不被外部代码修改，确保数据一致性。
代码重用：允许通过在不同的类中使用相同的封装机制来重用代码。
提高安全性：防止恶意代码访问和修改敏感数据。
继承

继承是一种允许一个类（子类）继承另一个类（父类）的属性和方法的能力。这提供了代码重用并有助于创建分层类结构。在 Java 中，继承使用 extends 关键字。

子类继承父类的以下方面：

字段：父类的所有 non-private 字段。
方法：父类的所有 non-private 方法。
构造函数：无。
继承的好处包括：

代码重用：子类无需重新实现父类中已经存在的方法和字段。
多态性：父类和子类对象可以被视为同一类型，允许在运行时进行对象替换。
扩展性：通过创建新子类，可以轻松扩展现有类。
封装和继承的交互

封装和继承在 OOP 中相互作用。封装保护类的内部实现，而继承允许子类访问父类的受保护和公共成员。这使子类能够重用和扩展父类的功能，同时保持数据隐藏和代码组织性。

在 Java 中，访问修饰符与继承规则相结合，以控制子类对父类成员的访问：

子类可以访问父类的 public 和 protected 字段和方法。
子类无法访问父类的 private 字段和方法。
示例

考虑以下 Java 代码片段，展示了封装和继承的原理：

// Person 类（父类）
class Person {
    private String name;
    protected int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    protected void printAge() {
        System.out.println("Age: " + age);
    }
}

// Student 类（子类）继承 Person 类
class Student extends Person {
    private int studentNumber;

    public Student(String name, int age, int studentNumber) {
        super(name, age);  // 调用父类构造函数
        this.studentNumber = studentNumber;
    }

    public int getStudentNumber() {
        return studentNumber;
    }

    @Override
    protected void printAge() {
        System.out.println("Student"s age: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Student student = new Student("John Doe", 20, 12345);

        System.out.println("Student name: " + student.getName());  // public 方法，可从子类访问
        student.printAge();  // protected 方法，可从子类访问
        // System.out.println(student.age);  // 无法访问 private 字段
    }
}
在这个示例中，Person 类封装了 name 和 age 数据，并通过访问修饰符控制对它们的访问。Student 类继承了 Person 类，并可以访问其受保护的 age 字段和 printAge() 方法。同时，Student 类定义了一个 private 字段 studentNumber，它仅在自身内部可见。