封装

引语：HR 总监大翔找到架构师白歌："我们系统的员工信息表里，有人把薪资字段直接改成了负数，还有人把工龄设成了 300 年！你能不能加个保护？"白歌笑了笑："这就是封装——字段私有化，访问走门禁。我给你装上'安检系统'。"

什么是封装

封装（Encapsulation） 是面向对象编程的三大基本特征之一，指将数据（字段）和操作数据的方法绑定在一起，对外隐藏内部实现细节，仅通过受控的接口（方法）暴露必要的访问能力。

封装的核心可以概括为八个字：数据隐藏，接口暴露。

类比理解：封装就像一台自动售货机。你不需要知道内部如何识别纸币、如何出饮料——你只需要通过投币口（setter）放入钱，通过取物口（getter）拿到饮料。内部电路板（private 字段）对你是完全隐藏的。

封装的三大意义

1. 数据隐藏（Data Hiding）

将字段声明为 private，杜绝外部直接访问，防止数据被意外或恶意篡改。

// ❌ 无封装：任何人都可以直接修改 salary
public class Employee {
    public double salary;  // 危险！外部可以随意赋值为负数
}

// 外部代码可以这样搞破坏：
Employee emp = new Employee();
emp.salary = -99999.99;  // 毫无阻拦！

2. 解耦（Decoupling）

封装将"做什么"与"怎么做"分离。调用者只依赖公开接口，不关心内部实现。当内部实现变更时，只要接口不变，调用者代码无需修改。

飞翔科技案例：薪资计算方式从"基本工资 × 12"变成"基本工资 × 13 + 绩效奖金"，外部调用 getAnnualSalary() 不受影响。

3. 可维护性（Maintainability）

所有对字段的修改都经过 setter 方法，可以在一个地方集中添加校验逻辑、日志记录、权限检查等横切关注点。

JavaBean 规范

JavaBean 是 Java 中一种可重用组件的编码约定，其核心规范可以总结为以下三点：

规范条目要求说明
字段私有化所有属性字段用 private 修饰外部不能直接访问
公开 getter提供 public 的 getter 方法命名规则：getXxx() / isXxx()
公开 setter提供 public 的 setter 方法命名规则：setXxx()
无参构造必须提供无参构造方法框架反射创建对象的前提
实现 Serializable(可选) 实现 java.io.Serializable支持序列化传输

getter / setter 命名规范

JavaBean 的 getter 和 setter 遵循严格的命名规范，这是 Java 反射机制和众多框架（Spring、MyBatis、Jackson 等）识别属性的基础。

属性类型getter 命名setter 命名示例
普通类型 Type xxxgetXxx()setXxx(Type xxx)getName() / setName(String name)
boolean boolean xxxisXxx()setXxx(boolean xxx)isMarried() / setMarried(boolean married)
Boolean 包装类 Boolean xxxgetXxx()setXxx(Boolean xxx)getActive() / setActive(Boolean active)

关键区分：boolean 基本类型用 isXxx()，Boolean 包装类仍用 getXxx()。这是因为 Boolean 有三个状态（true / false / null），而 is 前缀隐含二值语义。

完整示例一：飞翔科技员工类（JavaBean 标准写法）

场景

HR 总监大翔需要管理公司员工信息。白歌要求所有实体类必须遵循 JavaBean 规范，确保数据安全。

代码

package com.feixiang.hr;

import java.io.Serializable;

/**
 * 飞翔科技员工实体类 —— 严格遵循 JavaBean 规范
 * 
 * @author 白歌（架构师）
 * @version 1.0
 */
public class Employee implements Serializable {

    private static final long serialVersionUID = 1L;

    // ========== 私有字段 ==========
    private String  empId;        // 工号：FX-0001
    private String  name;         // 姓名
    private int     age;          // 年龄
    private double  salary;       // 月薪
    private String  department;   // 部门
    private boolean married;      // 婚否（boolean → isXxx）

    // ========== 无参构造（JavaBean 必需） ==========
    public Employee() {
    }

    // ========== 带参构造（便利方法） ==========
    public Employee(String empId, String name, int age, double salary, String department, boolean married) {
        this.empId = empId;
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.department = department;
        this.married = married;
    }

    // ========== Getter & Setter ==========

    public String getEmpId() {
        return empId;
    }

    public void setEmpId(String empId) {
        if (empId == null || empId.trim().isEmpty()) {
            throw new IllegalArgumentException("工号不能为空");
        }
        this.empId = empId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (name == null || name.trim().isEmpty()) {
            throw new IllegalArgumentException("姓名不能为空");
        }
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < 18 || age > 65) {
            throw new IllegalArgumentException("年龄必须在 18~65 之间，传入值：" + age);
        }
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        if (salary < 0) {
            throw new IllegalArgumentException("薪资不能为负数，传入值：" + salary);
        }
        this.salary = salary;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    // boolean 类型使用 isXxx()
    public boolean isMarried() {
        return married;
    }

    public void setMarried(boolean married) {
        this.married = married;
    }

    // ========== 业务方法 ==========

    /**
     * 计算年薪（13薪 + 可能含绩效奖金）
     * 外部只需调用此方法，不关心内部计算逻辑
     */
    public double getAnnualSalary() {
        return this.salary * 13;  // 未来可改为 salary * 12 + bonus
    }

    @Override
    public String toString() {
        return "Employee{" +
                "empId='" + empId + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                ", department='" + department + '\'' +
                ", married=" + married +
                '}';
    }
}

测试代码

package com.feixiang.hr;

/**
 * 测试 Employee 类的封装效果
 */
public class EmployeeTest {
    public static void main(String[] args) {
        // 1. 正常创建员工
        Employee emp = new Employee("FX-1001", "大翔", 35, 25000.00, "人力资源部", true);
        System.out.println("=== 员工信息 ===");
        System.out.println(emp);

        // 2. 通过 getter 读取数据
        System.out.println("\n=== 通过 getter 读取 ===");
        System.out.println("姓名：" + emp.getName());
        System.out.println("月薪：" + emp.getSalary());
        System.out.println("年薪：" + emp.getAnnualSalary());
        System.out.println("婚否：" + emp.isMarried());  // boolean 用 isXxx()

        // 3. 通过 setter 安全修改数据
        System.out.println("\n=== 通过 setter 修改薪资 ===");
        emp.setSalary(30000.00);
        System.out.println("调薪后月薪：" + emp.getSalary());
        System.out.println("调薪后年薪：" + emp.getAnnualSalary());

        // 4. 尝试设置非法年龄 —— setter 拦截
        System.out.println("\n=== 尝试非法年龄 ===");
        try {
            emp.setAge(150);  // 超出范围
        } catch (IllegalArgumentException e) {
            System.out.println("捕获异常：" + e.getMessage());
        }

        // 5. 尝试设置负数薪资
        System.out.println("\n=== 尝试负数薪资 ===");
        try {
            emp.setSalary(-5000.00);
        } catch (IllegalArgumentException e) {
            System.out.println("捕获异常：" + e.getMessage());
        }
    }
}

运行输出

=== 员工信息 ===
Employee{empId='FX-1001', name='大翔', age=35, salary=25000.0, department='人力资源部', married=true}

=== 通过 getter 读取 ===
姓名：大翔
月薪：25000.0
年薪：325000.0
婚否：true

=== 通过 setter 修改薪资 ===
调薪后月薪：30000.0
调薪后年薪：390000.0

=== 尝试非法年龄 ===
捕获异常：年龄必须在 18~65 之间，传入值：150

=== 尝试负数薪资 ===
捕获异常：薪资不能为负数，传入值：-5000.0

关键观察：所有非法数据在 setter 入口处被拦截，数据从未进入对象内部。这就是封装的"门禁"作用。

完整示例二：部门类（封装内部集合）

场景

技术部每个部门下有多个员工。小崔实现 Department 类时，需要防止外部直接操作内部 List，而是通过受控的方法添加/删除员工。

代码

package com.feixiang.tech;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 飞翔科技部门类 —— 封装内部集合，防止外部直接修改
 */
public class Department {

    private String deptName;                 // 部门名称
    private List<String> memberNames;        // 成员姓名列表（私有集合）

    public Department(String deptName) {
        this.deptName = deptName;
        this.memberNames = new ArrayList<>();
    }

    // ✅ 返回不可修改的视图，防止外部直接 add/remove
    public List<String> getMemberNames() {
        return Collections.unmodifiableList(memberNames);
    }

    // ✅ 通过专用方法添加成员
    public void addMember(String name) {
        if (name == null || name.trim().isEmpty()) {
            throw new IllegalArgumentException("成员姓名不能为空");
        }
        if (memberNames.contains(name)) {
            System.out.println("【警告】" + name + " 已是 " + deptName + " 成员，跳过重复添加");
            return;
        }
        memberNames.add(name);
        System.out.println("【" + deptName + "】新成员加入：" + name);
    }

    // ✅ 通过专用方法移除成员
    public boolean removeMember(String name) {
        boolean removed = memberNames.remove(name);
        if (removed) {
            System.out.println("【" + deptName + "】成员离职：" + name);
        }
        return removed;
    }

    public String getDeptName() {
        return deptName;
    }

    public int getMemberCount() {
        return memberNames.size();
    }

    public void printRoster() {
        System.out.println("\n===== " + deptName + " 花名册（共 " + memberNames.size() + " 人）=====");
        for (int i = 0; i < memberNames.size(); i++) {
            System.out.println("  " + (i + 1) + ". " + memberNames.get(i));
        }
    }
}

测试代码

package com.feixiang.tech;

public class DepartmentTest {
    public static void main(String[] args) {
        Department techDept = new Department("技术部");

        // 1. 通过 addMember 添加成员
        techDept.addMember("白歌");
        techDept.addMember("小崔");
        techDept.addMember("黄俪");
        techDept.addMember("小崔");  // 重复添加，触发警告

        // 2. 通过 getMemberNames() 获取只读视图
        System.out.println("\n获取成员列表（只读视图）：");
        List<String> members = techDept.getMemberNames();
        System.out.println(members);

        // 3. 尝试直接修改返回的列表 —— 将抛出异常
        System.out.println("\n尝试直接修改返回的列表：");
        try {
            members.add("黑客");  // UnsupportedOperationException!
        } catch (UnsupportedOperationException e) {
            System.out.println("捕获异常：" + e.getClass().getSimpleName() +
                               " —— 不允许外部直接修改内部集合！");
        }

        // 4. 正确删除
        System.out.println();
        techDept.removeMember("小崔");

        // 5. 打印最终花名册
        techDept.printRoster();
    }
}

运行输出

【技术部】新成员加入：白歌
【技术部】新成员加入：小崔
【技术部】新成员加入：黄俪
【警告】小崔 已是 技术部 成员，跳过重复添加

获取成员列表（只读视图）：
[白歌, 小崔, 黄俪]

尝试直接修改返回的列表：
捕获异常：UnsupportedOperationException —— 不允许外部直接修改内部集合！

【技术部】成员离职：小崔

===== 技术部 花名册（共 2 人）=====
  1. 白歌
  2. 黄俪

封装与不变性（Immutability）

封装的进阶用法是创建不可变类（Immutable Class）——对象创建后状态不可改变。JDK 中的 String、Integer、LocalDate 都是不可变类。

不可变类的设计原则：

原则说明
字段全部 private final字段不可变且不可直接访问
不提供 setter杜绝外部修改
类声明 final 或构造私有防止子类覆盖方法破坏不可变性
返回防御性拷贝若字段是可变对象（如 Date、List），getter 返回拷贝而非原对象

封装的好处总结

好处说明飞翔科技场景
防止非法数据setter 入口做校验，非法数据直接拒绝工资不能为负、年龄不能超范围
内部实现可变更接口不变，内部随便改年薪计算从 12 薪改为 13 薪+绩效
控制访问粒度只读（仅 getter）、只写、读写可控员工花名册对外只读
便于加日志/权限集中在方法入口加代码修改薪资时自动记录审计日志
降低耦合调用者只依赖接口而非内部结构前端只需要 getName()，不关心 name 字段类型

易错场景

反例一：返回可变对象的引用

小崔写了一个 getter 返回内部 Date 对象，结果被外部修改了：

// ❌ 错误：直接返回可变对象的引用
public class SalaryRecord {
    private Date payDate;

    public Date getPayDate() {
        return payDate;  // 外部拿到引用后可以直接修改！
    }
}

// 外部攻击代码：
SalaryRecord record = new SalaryRecord();
Date d = record.getPayDate();
d.setTime(0);  // 把发薪日期改成了 1970 年！

纠正：返回防御性拷贝：

// ✅ 正确：返回新对象，原对象不受影响
public Date getPayDate() {
    return new Date(payDate.getTime());  // 防御性拷贝
}

反例二：数组字段的 getter 泄露

// ❌ 错误：数组是可变对象，直接返回引用
public class Payroll {
    private double[] monthlySalaries;

    public double[] getMonthlySalaries() {
        return monthlySalaries;  // 泄露！外部可修改数组元素
    }
}

纠正：

// ✅ 正确：返回克隆
public double[] getMonthlySalaries() {
    return monthlySalaries.clone();
}

面试考点

Q1：为什么要用 private 修饰字段，而不是直接 public？

private 字段 + public getter/setter 实现了对字段的受控访问。直接 public 字段有三大问题：① 无法在字段被访问时添加校验逻辑；② 内部字段改名或类型变更时，所有调用方代码都要修改；③ 违反了面向对象的"信息隐藏"原则。封装允许你在不改变接口的情况下自由调整内部实现。

Q2：为什么 boolean 用 isXxx() 而 Boolean 用 getXxx()？

这是 JavaBean 规范的规定。boolean 是基本类型，只有 true/false，is 前缀具有自然的二值语义。Boolean 是包装类，多了一个 null 状态（true/false/null），用 get 前缀更符合"获取一个可能为 null 的对象"的语义。此外，许多框架（如 Jackson、MyBatis）在序列化/反序列化时严格区分 is 和 get——用错前缀会导致属性无法正确映射。

Q3：封装和"不可变类"有什么关系？

不可变类是封装的极致形式——连 setter 都不提供，对象一旦创建就无法修改。封装是实现不可变类的技术手段（private final 字段 + 无 setter + 防御性拷贝）。JDK 中的 String、Integer、LocalDate 都是不可变类的典范。不可变类天然线程安全，是函数式编程和并发编程的重要基础。

Q4：getter 里可以直接返回 List 字段吗？

不可以。如果 List 字段是可变对象（如 ArrayList），直接返回会给外部调用者修改内部状态的能力。应当返回 Collections.unmodifiableList() 包装的只读视图，或返回一个新的副本。这被称为"防御性编程（Defensive Programming）"。