【Java】封装：你的数据不该被随意触碰

封装：你的数据不该被随意触碰

从入门到面试，一篇就够了（真正完整版）

一、引言：一个“太开放”的惨痛教训

想象你开了一家银行，为了“方便客户”，你把金库的钥匙挂在门口，上面贴了张纸条：“请自行取用，用完放回”。

结果可想而知。这很荒唐，对吧？

但在编程世界里，很多初学者就在做同样荒唐的事：

BankAccountaccount=newBankAccount();account.balance=-1000;// 余额变成负数！account.owner="";// 账户名为空！

没有任何保护，数据可以被随意篡改成非法状态。

这就是为什么我们需要封装。

二、封装是什么？

官方定义：将数据（属性）和操作数据的方法（行为）捆绑在一起，并隐藏内部实现细节，对外提供受控的访问接口。

一句话人话：把数据锁进保险柜，只开一个小窗口让外部操作。

┌─────────────────────┐ │ 外部调用方 │ │ 只能通过窗口操作 │ └──────────┬──────────┘ │ ┌──────▼──────┐ │ public方法 │ ← 小窗口（可控） ├─────────────┤ │ private属性 │ ← 保险柜（隐藏） │ private方法 │ └─────────────┘

三、为什么需要封装？

3.1 保护数据完整性

没有封装 → 数据可以被随意篡改：

// 没有封装Students=newStudent();s.age=-5;// 编译通过，但数据非法

有了封装 → 加校验，阻止非法数据：

// 有封装publicvoidsetAge(intage){if(age<0||age>150){thrownewIllegalArgumentException("年龄非法");}this.age=age;}

3.2 隐藏内部实现，允许未来修改

// 外部只调用 getFullName()publicStringgetFullName(){returnfirstName+" "+lastName;}// 内部随便改，外部无感知publicStringgetFullName(){returnlastName+firstName;// 改成姓在前名在后}

3.3 控制访问权限

publicdoublegetBalance(){returnbalance;}// 人人可看publicvoiddeposit(doubleamount){...}// 人人可存privatevoidaudit(){...}// 只有内部能用

3.4 降低耦合

封装后，每个类是独立的黑盒。调用方只需要知道“能做什么”，不需要知道“怎么做的”。

四、怎么实现封装？

4.1 访问修饰符（一张表搞定）

最佳实践：

• 属性：几乎总是private（特例：public static final常量可以公开）
• 方法：public（对外）、private（内部辅助）、protected（给子类）
• 包级私有（默认）：用于同一包内的协作类，是一种被低估的封装手段

// package-private：同包可访问，对外隐藏classInternalHelper{voiddoPackageLevelWork(){...}}

4.2 Getter/Setter 不是万能的

坏习惯：给每个 private 字段无脑生成 getter/setter。

// 这样写等于把属性公开了，封装了个寂寞publicStringgetPassword(){returnpassword;}// 暴露密码！

好习惯：只暴露真正需要的。

publicclassUser{privateStringpassword;// 不提供 getter，只提供验证publicbooleancheckPassword(Stringinput){returnthis.password.equals(input);}// 修改需要原密码验证publicvoidchangePassword(StringoldPwd,StringnewPwd){if(checkPassword(oldPwd)){this.password=newPwd;}}}

4.3 防御性拷贝（面试常考）

当返回可变对象时，不要直接返回内部引用：

// 危险：外部可以修改内部数据publicDategetBirthday(){returnthis.birthday;}// 安全：返回副本publicDategetBirthday(){returnnewDate(this.birthday.getTime());}// 集合也同理——注意：unmodifiableList 只防结构修改，不防元素修改publicList<Item>getItems(){returnCollections.unmodifiableList(items);}// 如需深度防御，元素也应为不可变对象或返回深拷贝publicList<Item>getItemsDeepCopy(){returnitems.stream().map(Item::copy).collect(Collectors.toList());}

4.4 业务方法 > Setter

// 暴露了内部结构publicvoidsetItems(List<Item>items){...}publicvoidsetTotalPrice(doubleprice){...}// 提供业务方法publicvoidaddItem(Itemitem){items.add(item);totalPrice+=item.getPrice();}

五、完整案例：安全的银行账户

publicclassBankAccount{// 私有属性privateStringaccountNo;privatedoublebalance;// 注意：生产环境需考虑线程安全privateStringpassword;privateintfailCount;privatebooleanlocked;privatestaticfinalintMAX_FAIL=3;// 构造方法publicBankAccount(StringaccountNo,Stringpassword,doubleinitBalance){this.accountNo=accountNo;this.password=password;this.balance=initBalance;}// 只读属性（无setter）publicStringgetAccountNo(){returnaccountNo;}// 查看余额需要密码publicdoublegetBalance(Stringpassword){verify(password);returnbalance;}// 存款（公开）publicvoiddeposit(doubleamount){if(amount<=0)thrownewIllegalArgumentException("金额必须大于0");balance+=amount;resetFailCount();}// 取款（需要密码）publicvoidwithdraw(Stringpassword,doubleamount){verify(password);if(amount>balance)thrownewIllegalArgumentException("余额不足");balance-=amount;resetFailCount();}// 私有方法：密码验证privatevoidverify(Stringinput){if(locked)thrownewIllegalStateException("账户已锁定");if(!this.password.equals(input)){failCount++;if(failCount>=MAX_FAIL)locked=true;thrownewSecurityException("密码错误");}}privatevoidresetFailCount(){failCount=0;}}

💡生产环境进阶：上述balance在多线程下不安全。实际项目中可用AtomicLong或synchronized：

privatefinalAtomicLongbalance=newAtomicLong();publicvoiddeposit(longamount){balance.addAndGet(amount);}

使用示例：

BankAccountacc=newBankAccount("123456","1234",1000);acc.deposit(500);// 存款：不需要密码acc.withdraw("1234",200);// 取款：需要密码System.out.println(acc.getBalance("1234"));// 1300// acc.balance = -100; // 编译错误！private 不可访问

六、进阶：封装在真实项目中的样子

6.1 不可变对象（真正的终极封装）

不可变对象天然线程安全，是最彻底的封装形式：

publicfinalclassImmutablePerson{privatefinalStringname;privatefinalList<String>tags;publicImmutablePerson(Stringname,List<String>tags){this.name=name;// 防御性拷贝：不信任外部传入的集合this.tags=List.copyOf(tags);// Java 9+，返回不可变集合}publicStringgetName(){returnname;}publicList<String>getTags(){returntags;}// 已是不可变，无需再包装}

6.2 封装与单元测试

封装太好可能不利于测试。解决方案：

publicclassCalculator{privateintinternalState;// 提供 package-private 的测试钩子（仅测试代码可访问）intgetInternalStateForTest(){returninternalState;}}

// 测试代码（同包）可直接调用@TestvoidtestInternalState(){assertEquals(0,calculator.getInternalStateForTest());}

6.3 封装与常见框架

6.4 Java 9+ 模块化封装

// module-info.javamodulecom.example.banking{exportscom.example.banking.api;// 对外公开exportscom.example.banking.internaltocom.example.test;// 仅对测试模块公开}

七、常见误区

误区1：所有属性都要有 getter/setter

错。这等于把属性变相公开。只暴露真正需要的接口。

误区2：封装就是 private + getter/setter

错。这只是语法层面。真正的封装是把业务逻辑和数据放在一起，让外部“命令对象做什么”而不是“问对象要数据”。

// 坏：外部计算if(acc.getBalance()>=amount)acc.setBalance(acc.getBalance()-amount);// 好：对象自己处理acc.withdraw(amount);

误区3：封装让代码变长，没必要

错。多写的几行代码，换来的是可维护性和安全性。大型项目中，没有封装的代码最终会变成“意大利面条式代码”（指结构混乱难以维护的代码）。

误区4：常量也要 private

错。真正的常量（public static final）可以公开，因为它是不可变的：

publicstaticfinaldoublePI=3.1415926;// 公开没问题

八、面试高频题（背下来）

Q1：封装是什么？为什么要封装？

答：把数据和操作捆绑，隐藏内部细节。目的：①保护数据完整性 ②隔离变化 ③控制权限 ④降低耦合。

Q2：有 getter/setter 就算封装吗？

答：不算。那是“贫血模型”。真正封装应该提供业务方法，比如withdraw()而不是setBalance()。

Q3：反射能破坏封装吗？

答：能。setAccessible(true)可以绕过 private。但这是框架层面的后门，业务代码不应使用。封装防的是粗心，不是恶意。

Q4：封装影响性能吗？

答：现代 JVM 的 JIT 编译器会对 getter/setter 进行内联优化，最终性能与直接访问字段几乎无差别。不要为了微小的性能牺牲设计。

Q5：什么是防御性拷贝？

答：返回内部可变对象（Date、List）时，返回副本或只读视图，防止外部修改内部状态。

Q6：Collections.unmodifiableList就绝对安全了吗？

答：不是。它只防止增删改结构，但如果列表中的元素本身是可变的，外部仍可修改元素内容。需要元素也是不可变对象，或返回深拷贝。

九、思考题（含深度解析）

题1：下面代码有什么问题？

publicclassOrder{publicList<Item>items=newArrayList<>();publicvoidaddItem(Itemitem){items.add(item);}}

答案：

1. 属性是public，外部可以直接order.items.clear()破坏数据
2. 应改为private，并提供getItems()返回Collections.unmodifiableList(items)
3. 注意：unmodifiableList只防结构修改，如果Item可变，外部仍能order.getItems().get(0).setPrice(0)。如需完全保护，Item也应为不可变类

题2：设计 Temperature 类

要求：存储摄氏度，可获取华氏度，不能低于绝对零度（-273.15°C）。

参考答案：

publicclassTemperature{privatedoublecelsius;privatestaticfinaldoubleABSOLUTE_ZERO=-273.15;publicTemperature(doublecelsius){setCelsius(celsius);}publicdoublegetCelsius(){returncelsius;}publicdoublegetFahrenheit(){returncelsius*9/5+32;}publicvoidsetCelsius(doublec){if(c<ABSOLUTE_ZERO)thrownewIllegalArgumentException("低于绝对零度");this.celsius=c;}publicvoidsetFahrenheit(doublef){setCelsius((f-32)*5/9);// 复用校验逻辑}}

题3（进阶）：如何让一个类不能被继承且内部状态完全不可变？

答案：

publicfinalclassImmutableConfig{privatefinalMap<String,String>settings;publicImmutableConfig(Map<String,String>settings){this.settings=Map.copyOf(settings);// 防御 + 不可变}publicMap<String,String>getSettings(){returnsettings;// 已经是不可变Map，直接返回安全}}

关键点：final class+final字段 + 构造器防御性拷贝 + 不提供修改方法 + 返回不可变视图。

十、总结

记住：好的封装，是让别人用你的类时，想出错都难。