在 Java 中实现封装主要通过 访问修饰符 和 getter/setter 方法 来实现，核心步骤是"隐藏属性、暴露接口"。具体实现方式如下：
一、使用访问修饰符隐藏类的成员
Java 提供了 4 种访问修饰符，用于控制类成员（属性和方法）的访问范围，从而实现隐藏：
| 修饰符 | 访问范围 | 封装用途 |
|---|---|---|
private |
仅当前类内部可访问 | 完全隐藏核心属性/方法 |
default |
同一包内可访问（无修饰符时默认） | 包内可见，对外隐藏 |
protected |
同一包内或子类可访问 | 允许子类访问，对外隐藏 |
public |
任何地方可访问 | 暴露公共接口（如 getter/setter） |
封装的核心原则：
将类的属性（数据）声明为 private（私有），禁止外部直接访问；
将操作属性的方法声明为 public（公开），作为外部交互的接口。
二、通过 getter/setter 方法暴露访问接口
对于私有属性，提供公共的 getXxx() 方法（获取属性值）和 setXxx() 方法（设置属性值），在方法中可以添加校验逻辑，确保数据合法性。
实例：封装一个 Student 类
public class Student {
// 1. 将属性声明为 private（隐藏数据）
private String name; // 姓名
private int age; // 年龄
private double score; // 成绩
// 2. 提供 public 的 getter 方法（获取属性值）
public String getName() {
return name;
}
// 3. 提供 public 的 setter 方法（设置属性值，可添加校验）
public void setName(String name) {
// 例如：限制姓名不能为 null 或空字符串
if (name != null && !name.trim().isEmpty()) {
this.name = name;
} else {
System.out.println("姓名不能为空！");
}
}
public int getAge() {
return age;
}
public void setAge(int age) {
// 例如：限制年龄在 0-150 之间
if (age >= 0 && age <= 150) {
this.age = age;
} else {
System.out.println("年龄必须在 0-150 之间！");
}
}
public double getScore() {
return score;
}
public void setScore(double score) {
// 例如：限制成绩在 0-100 之间
if (score >= 0 && score <= 100) {
this.score = score;
} else {
System.out.println("成绩必须在 0-100 之间！");
}
}
// 4. 其他业务方法（也可封装内部逻辑）
public void showInfo() {
System.out.println("姓名：" + name + "，年龄：" + age + "，成绩：" + score);
}
}
三、使用封装后的类
外部只能通过 setXxx() 方法修改属性，通过 getXxx() 方法获取属性，无法直接操作私有属性：
public class TestStudent {
public static void main(String[] args) {
Student s = new Student();
// 错误：无法直接访问 private 属性
// s.name = "张三";
// 正确：通过 setter 方法设置属性（会触发校验）
s.setName("张三"); // 合法
s.setAge(200); // 触发错误提示：年龄必须在 0-150 之间
s.setAge(18); // 合法
s.setScore(95.5); // 合法
// 通过 getter 方法获取属性
System.out.println("姓名：" + s.getName()); // 输出：张三
// 调用业务方法
s.showInfo(); // 输出：姓名：张三，年龄：18，成绩：95.5
}
}
四、封装的进阶：隐藏方法实现
除了属性，方法也可以被封装。例如，将类内部的辅助方法声明为 private，只暴露必要的 public 方法给外部使用：
public class Calculator {
// 公开方法：对外暴露的接口
public int add(int a, int b) {
return calculate(a, b, "+");
}
public int subtract(int a, int b) {
return calculate(a, b, "-");
}
// 私有方法：内部实现细节，对外隐藏
private int calculate(int a, int b, String operator) {
switch (operator) {
case "+": return a + b;
case "-": return a - b;
default: throw new IllegalArgumentException("不支持的运算符");
}
}
}
外部只能调用 add() 和 subtract()，无需关心 calculate() 的实现，即使未来修改 calculate() 的逻辑，也不会影响外部调用。
总结
Java 实现封装的核心步骤：
- 用
private修饰属性，禁止外部直接访问； - 提供
public的getter/setter方法，控制属性的读写逻辑； - 用访问修饰符隐藏内部方法实现，只暴露必要的公共接口。
通过这种方式，既能保证数据安全，又能降低代码耦合度，使程序更易于维护。
