Java 中 protected 与 private 的深度剖析

简介

在 Java 编程中，访问修饰符是控制类、方法和变量访问权限的重要机制。protected 和 private 是其中两个关键的访问修饰符，它们在限制访问和封装数据方面起着重要作用。理解 protected 和 private 的区别、使用方法和最佳实践，对于编写高质量、安全且易于维护的 Java 代码至关重要。本文将详细探讨这两个访问修饰符，通过基础概念、使用方法、常见实践和最佳实践等方面的讲解，帮助读者深入掌握它们的应用。

基础概念

`private` 修饰符

private 是 Java 中访问限制最严格的修饰符。当一个类的成员（字段或方法）被声明为 private 时，它只能在声明该成员的类内部被访问。这意味着其他类，即使是该类的子类，也无法直接访问这些 private 成员。private 修饰符的主要目的是实现数据封装，保护类的内部状态不被外部随意访问和修改。

`protected` 修饰符

protected 修饰符提供了比 private 更宽松的访问权限。被 protected 修饰的成员可以在声明该成员的类内部、同一个包内的其他类以及该类的子类（无论子类是否在同一个包内）中被访问。protected 修饰符通常用于在类的继承体系中，允许子类访问父类的某些成员，同时限制其他无关类的访问。

使用方法

`private` 的使用

以下是一个使用 private 修饰符的简单示例：

class BankAccount {
    // 私有字段，用于存储账户余额
    private double balance;

    // 构造方法，初始化账户余额
    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    // 公共方法，用于获取账户余额
    public double getBalance() {
        return balance;
    }

    // 公共方法，用于存款
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    // 公共方法，用于取款
    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }
}

public class PrivateExample {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000);
        // 不能直接访问 balance 字段
        // System.out.println(account.balance); // 编译错误
        System.out.println("Initial balance: " + account.getBalance());
        account.deposit(500);
        System.out.println("Balance after deposit: " + account.getBalance());
        boolean success = account.withdraw(200);
        if (success) {
            System.out.println("Withdrawal successful. New balance: " + account.getBalance());
        } else {
            System.out.println("Withdrawal failed.");
        }
    }
}

在这个示例中，balance 字段被声明为 private，因此不能在 BankAccount 类外部直接访问。通过提供公共的访问方法（getBalance、deposit 和 withdraw），可以安全地操作账户余额。

`protected` 的使用

以下是一个使用 protected 修饰符的示例：

// 父类
class Shape {
    // 受保护的字段，用于存储形状的颜色
    protected String color;

    public Shape(String color) {
        this.color = color;
    }

    // 受保护的方法，用于获取形状的颜色
    protected String getColor() {
        return color;
    }
}

// 子类
class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    public double getArea() {
        // 子类可以访问父类的受保护字段和方法
        System.out.println("Circle color: " + getColor());
        return Math.PI * radius * radius;
    }
}

public class ProtectedExample {
    public static void main(String[] args) {
        Circle circle = new Circle("Red", 5);
        double area = circle.getArea();
        System.out.println("Circle area: " + area);
    }
}

在这个示例中，color 字段和 getColor 方法被声明为 protected。Circle 类作为 Shape 类的子类，可以直接访问这些受保护的成员。

常见实践

`private` 的常见场景

数据封装：将类的内部状态（字段）声明为 private，通过公共的访问方法（getter 和 setter）来控制对这些状态的访问。这样可以确保数据的完整性和安全性，防止外部类直接修改内部状态。
隐藏实现细节：将类的一些辅助方法声明为 private，这些方法只在类内部使用，不对外暴露。这样可以简化类的接口，提高代码的可维护性。

`protected` 的常见场景

继承体系中的访问控制：在父类中声明一些 protected 成员，允许子类访问这些成员，同时限制其他无关类的访问。这样可以在保证子类能够扩展父类功能的同时，保护父类的某些信息不被滥用。
模板方法模式：在父类中定义一些 protected 方法，作为模板方法的一部分，子类可以重写这些方法来实现特定的功能。

最佳实践

遵循封装原则

尽可能将类的字段声明为 private，通过公共的访问方法来控制对这些字段的访问。这样可以隐藏类的内部实现细节，提高代码的安全性和可维护性。
在设计类的接口时，只暴露必要的方法，将其他方法声明为 private 或 protected，以减少类的耦合度。

合理使用继承和访问权限

在设计继承体系时，合理使用 protected 修饰符，允许子类访问父类的某些成员，但要避免过度暴露父类的信息。
当子类需要访问父类的私有成员时，可以通过父类提供的公共或受保护的方法来间接访问，而不是修改父类的访问权限。

小结

private 和 protected 是 Java 中重要的访问修饰符，它们在控制类、方法和变量的访问权限方面起着关键作用。private 用于实现严格的数据封装，保护类的内部状态不被外部随意访问；protected 则在类的继承体系中提供了一种更灵活的访问控制机制，允许子类访问父类的某些成员。在编写 Java 代码时，应遵循封装原则，合理使用这两个访问修饰符，以提高代码的安全性、可维护性和可扩展性。

参考资料

《Effective Java》（第三版），作者：Joshua Bloch
《Java 核心技术》（卷 I），作者：Cay S. Horstmann