以下是关于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的子类）。
- 优先使用组合（通过
通过合理运用访问修饰符和封装方法，可以构建出高内聚、低耦合的Java组件，提高代码的可维护性和安全性。
Java, 访问修饰符，public,private,protected,default, 组件封装，封装方法，类封装，成员变量封装，方法封装，访问控制，面向对象，Java 开发，编程关键字
准备了一些面试资料，请在以下链接中获取
https://pan.quark.cn/s/4459235fee85
