Java 访问修饰符使用方法与组件封装方法详细说明-优快云博客

本文链接：https://blog.youkuaiyun.com/xiaopengbc/article/details/148607671

以下是关于Java访问修饰符的使用方法和组件封装方法的详细说明，结合代码示例进行讲解：

一、访问修饰符的使用方法

1. `public` 的使用

场景：当需要让类或成员对所有类可见时使用。
示例：创建一个公共工具类 StringUtils

public class StringUtils {
    public static final String DEFAULT_SEPARATOR = ",";

    public static String join(String[] arr) {
        return String.join(DEFAULT_SEPARATOR, arr);
    }
}

使用方式：

// 任何包中的类都可以直接访问
String[] fruits = {"Apple", "Banana"};
String result = StringUtils.join(fruits);

2. `private` 的使用

场景：隐藏内部实现细节，防止外部直接访问。
示例：封装用户密码字段

class User {
    private String password;

    public void setPassword(String newPassword) {
        // 密码强度校验（内部逻辑）
        if (newPassword.length() < 8) {
            throw new IllegalArgumentException("密码长度不能少于8位");
        }
        this.password = newPassword;
    }
}

使用方式：

User user = new User();
user.setPassword("SecurePass123"); // 只能通过公共方法间接访问

3. `protected` 的使用

场景：允许子类访问父类的特定成员，但限制外部访问。
示例：创建一个可扩展的图形类

class Shape {
    protected double area;

    protected void calculateArea() {
        // 基础实现，子类可重写
        area = 0;
    }
}

class Circle extends Shape {
    private double radius;

    @Override
    protected void calculateArea() {
        area = Math.PI * radius * radius;
    }
}

使用方式：

Circle circle = new Circle();
circle.calculateArea(); // 子类可以直接调用受保护方法

4. 默认访问修饰符的使用

场景：限制访问范围在同一包内。
示例：创建包内共享的配置类

// 包：com.example.config
class AppConfig {
    static final String API_KEY = "12345";

    static void printConfig() {
        System.out.println("API Key: " + API_KEY);
    }
}

使用方式：

// 同一包中的类可以直接访问
AppConfig.printConfig();

二、组件封装方法

组件封装的核心是隐藏实现细节，暴露必要接口。以下是具体方法：

1. 数据封装（Encapsulation）

原则：使用 private 修饰字段，通过 public 方法提供访问。
示例：封装一个银行账户类

public class BankAccount {
    private double balance; // 私有字段

    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;
    }
}

2. 继承与扩展（使用 `protected`）

原则：父类通过 protected 暴露可扩展点，子类可重写或扩展。
示例：设计一个可扩展的日志系统

public abstract class Logger {
    protected void log(String level, String message) {
        // 基础日志格式
        System.out.println("[" + level + "] " + message);
    }

    public void info(String message) {
        log("INFO", message);
    }

    public void error(String message) {
        log("ERROR", message);
    }
}

public class FileLogger extends Logger {
    @Override
    protected void log(String level, String message) {
        // 扩展实现：写入文件
        System.out.println("写入文件: [" + level + "] " + message);
    }
}

3. 模块化设计（使用默认访问修饰符）

原则：将相关类放在同一包中，使用默认访问权限限制包外访问。
示例：创建一个数据库模块

// 包：com.example.db
class DatabaseConnection {
    private String url;

    void connect() {
        // 内部实现，不对外暴露
    }
}

public class DatabaseManager {
    private DatabaseConnection conn = new DatabaseConnection();

    public void executeQuery(String sql) {
        conn.connect();
        // 执行查询
    }
}

4. 接口隔离（使用 `public`）

原则：通过 public 接口定义组件契约，隐藏具体实现。
示例：设计一个缓存组件

public interface Cache {
    void put(String key, Object value);
    Object get(String key);
}

class InMemoryCache implements Cache {
    private Map<String, Object> cache = new HashMap<>();

    @Override
    public void put(String key, Object value) {
        cache.put(key, value);
    }

    @Override
    public Object get(String key) {
        return cache.get(key);
    }
}

三、最佳实践总结

最小权限原则：
- 除非必要，否则使用最严格的访问修饰符（如 private）。
- 仅通过 public 方法暴露必要的功能。
避免过度暴露：
- 避免使用 public 字段，始终使用 private 并提供访问器（getter/setter）。
- 慎用 protected，仅在确实需要子类访问时使用。
组件设计建议：
- 使用接口定义组件边界，实现类使用默认访问修饰符。
- 将相关类放在同一包中，形成内聚的模块。
继承与组合：
- 优先使用组合（通过 private 成员引用其他类）而非继承。
- 只有当子类确实是父类的“一种”时，才使用继承（如 Dog 是 Animal 的子类）。