Effective Java笔记：使类和成员的可访问性最小化

最新推荐文章于 2025-08-15 23:10:13 发布

Jooou

最新推荐文章于 2025-08-15 23:10:13 发布

阅读量780

点赞数 24

CC 4.0 BY-SA版权

文章标签： java 笔记 Effective Java

本文链接：https://blog.csdn.net/eclipseC/article/details/150390520

使类和成员的可访问性最小化

在软件工程中，有一个重要原则叫封装（Encapsulation），即通过隐藏实现细节，仅暴露必要的接口，来降低模块之间的耦合性。这不仅提高了代码的可维护性和灵活性，还能减少潜在的 bug 和安全隐患。为了实现封装，我们需要尽量最小化类和成员的可访问性，这是《Effective Java》书中提倡的一个重要规则。

1. 确定类或成员的访问级别：从最大限制开始

Java 提供了四种访问修饰符，用来控制类和成员的可访问性：

private：最小可见性，仅限于类内部。
无修饰符（package-private）：对同一包下的类可见。
protected：对同一包下的类以及子类可见。
public：最大可见性，对所有类可见。

规则：

在声明类和成员时，尽可能限制其访问权限，使其可见性最小化。只有当有充分的理由允许外部访问时，才逐步放宽可见性。

1.1 类级别的可访问性

顶级类的访问性

Java 中顶级类只能是**public或包私有（无修饰符）**。
优先选择包私有类：如果一个类不需要在包外使用，就应该将其声明为包私有类，而不是 public。

例子：包私有顶级类
以下代码展示了声明为包私有的 UtilityClass，它仅限于在自己的包内调用：

package com.example.util;

// 包私有顶级类
class UtilityClass {
    // 静态方法仅供同一包访问
    static void performTask() {
        // 核心逻辑
    }
}

公共顶级类 (`public`) 的使用

如果一个类是 public，任何地方都可以访问它。在设计公共类时，需要特别小心它的 API，因为一旦发布，修改它可能会破坏跟它交互的代码。

1.2 类成员的访问性

(1) `private`（首选）

默认应将类的字段和方法声明为 private。只有类自身可以访问它们，这将最大程度地保护实现细节。

public class User {
    private String name;   // 私有字段
    private int age;

    // 通过方法公开所需信息
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

(2) 包私有（无修饰符）

当一个成员只需在包内共享时，可以限制为包私有。例如，一个工具类只用作内部逻辑协助，但外部模块不需要使用它。

class Helper {
    static void performInternalTask() { // 仅供包内访问
        System.out.println("Internal task executed.");
    }
}

注意：包私有成员常导致两个类绑定过紧，建议优先选择更小的作用域。

(3) `protected`（谨慎使用）

protected 允许类的子类访问成员，无论子类是否在同一包中。
由于子类几乎可以任意修改父类的受保护成员，父类实现可能被强耦合到子类行为上。所以，应尽量避免使用 protected 修改成员。
通常建议通过合理设计的 public API 替代 protected 访问。

书中的例子
书中提到，protected 最常见的适用场景是 继承工具类的框架，允许子类复用父类的逻辑，但仍需谨慎设计受保护的成员。

(4) `public`（最后选择）

仅当逻辑和功能必须向所有代码开放时，才将字段或方法声明为 public。
一旦一个成员是 public，就需要承担 API 接口的维护成本，因为它通常被视为向外界承诺的一部分。

1.3 常见的成员访问性问题

问题 1：滥用 `public` 字段

public class User {
    public String name; // 公开的字段（问题点）
    public int age;
}

公开字段突破了封装，外部代码可以直接修改类字段，可能导致意外的状态变化。
改进方式：字段应声明为 private，并通过访问器方法（getter 和 setter）提供必要且有限的访问。

public class SafeUser {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        // 可加入额外校验逻辑
        this.name = name;
    }
}

问题 2：公共静态字段

public class Constants {
    public static final String ERROR_CODE = "ERROR"; // 不推荐
}

虽然 public static final 字段是不可变的，但它仍然破坏了封装，因为类的实现细节（如错误代码字符串）对外公开。

改进方式：提供一个访问方法代替直接暴露字段。

public class Constants {
    private static final String ERROR_CODE = "ERROR";

    public static String getErrorCode() {  // 只暴露方法
        return ERROR_CODE;
    }
}

2. 为什么要最小化可访问性？

2.1 安全性

如果实现细节暴露在公共 API 中，攻击者可能利用这些信息。
限制访问权限可以避免外部代码滥用或依赖实现的特定细节。

2.2 降低维护成本

可访问性更小的类和成员更容易重构：当成员未被外界依赖时，可以更灵活地修改类内部结构。
一旦类的 public API 提供给外界，修改时必须小心，因为可能会破坏依赖此 API 的代码。

2.3 降低耦合性

过大的访问权限会导致模块之间的强耦合性，违背了封装的核心思想。
限制访问性有助于让类的细节对外界保持不可见，减少交互复杂性。

3. 实施封装的策略

3.1 尽量让顶级类包私有

// 示例：仅包内使用的数据库连接工具类
package com.example.dbutil;

// 包私有类
class DatabaseHelper {
    static Connection getConnection() {
        // 数据库连接
        return DriverManager.getConnection("jdbc:mysql://localhost:3306/test");
    }
}

3.2 实现类应隐藏

实现类（如接口的具体实现）通常是特定于模块的细节，不应直接暴露给外部。

// 示例：限定外部只与接口交互
public interface List<E> {
    void add(E element);
}

class ArrayList<E> implements List<E> { // 具体实现私有化
    public void add(E element) {
        // 实现逻辑
    }
}

外界只能使用 List 接口，而无需了解 ArrayList 的实现。

4. 书中案例：提升封装性的设计

案例：防止不必要的可变性

书中提到，public 修饰的数组或集合使得对内部数据的修改权限不受控制，这是一个常见的过失设计。

错误设计

public class SensitiveData {
    public static final int[] VALUES = {1, 2, 3}; // 允许外部修改
}

外界代码可以通过 VALUES 引用直接修改内部数组的内容。

正确设计

通过访问方法返回数组的副本，确保安全性：

public class SensitiveData {
    private static final int[] VALUES = {1, 2, 3};

    public static int[] getValues() {  // 返回副本
        return VALUES.clone();
    }
}