一、封装（Encapsulation）—— 隐藏细节，暴露契约
1.1 什么是封装？
封装是将数据（属性）和操作数据的方法（行为）捆绑在一起，并对外部隐藏内部实现细节的过程。它通过访问修饰符（如 private、protected、public）控制访问权限，仅暴露必要的公共接口。封装的核心目标有两个：
数据保护：防止外部直接修改对象的内部状态，从而维持数据的一致性。
降低耦合：调用方只需依赖稳定的接口，内部实现可以自由变更而不影响外部代码。
1.2 封装的实现手段
在 Java 中，我们通常将字段设为 private，通过 public 的 getter/setter 方法（或业务方法）进行受控访问。此外，包级私有（default）和 protected 也用于不同粒度的封装。
1.3 项目实例：订单实体类的封装
在电商系统中，Order 对象包含大量敏感信息（订单金额、状态、用户ID等）。我们设计如下：
public class Order {
private String orderId;
private String userId;
private BigDecimal totalAmount;
private OrderStatus status; // 枚举：PENDING, PAID, SHIPPED, COMPLETED, CANCELLED
private List<OrderItem> items;
private LocalDateTime createTime;
// 构造器（不提供无参构造，强制必填字段）
public Order(String orderId, String userId, List<OrderItem> items) {
this.orderId = orderId;
this.userId = userId;
this.items = Collections.unmodifiableList(new ArrayList<>(items)); // 防御性复制
this.totalAmount = calculateTotal(); // 内部计算
this.status = OrderStatus.PENDING;
this.createTime = LocalDateTime.now();
}
// 只读 getter（不暴露内部可变集合的引用）
public String getOrderId() { return orderId; }
public String getUserId() { return userId; }
public BigDecimal getTotalAmount() { return totalAmount; }
public OrderStatus getStatus() { return status; }
public List<OrderItem> getItems() { return items; } // 返回不可变列表
public LocalDateTime getCreateTime() { return createTime; }
// 业务方法：修改状态（封装了状态流转逻辑）
public void pay() {
if (this.status != OrderStatus.PENDING) {
throw new IllegalStateException("只有待支付订单才能支付");
}
this.status = OrderStatus.PAID;
// 可能触发支付成功事件…
}
public void ship() {
if (this.status != OrderStatus.PAID) {
throw new IllegalStateException("只有已支付订单才能发货");
}
this.status = OrderStatus.SHIPPED;
}
// 私有方法，不对外暴露
private BigDecimal calculateTotal() {
return items.stream()
.map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())))
.reduce(BigDecimal.ZERO, BigDecimal::add);
}
}
封装要点：
所有字段 private，没有 setter（订单核心字段一旦创建不可变）。
状态变更通过 pay()、ship() 等业务方法，内部校验合法性，避免无效状态。
getItems() 返回不可变集合，防止外部修改订单项列表。
计算总价的方法被私有化，外部无法感知计算逻辑。
这种封装方式使得订单对象始终处于一致状态，任何状态跃迁都经过显式业务方法，便于审计和扩展。
二、继承（Inheritance）—— 复用与扩展的利器
2.1 继承的本质
继承是一种“is-a”关系，子类继承父类的非私有属性和方法，并可以添加新的字段和方法，或重写父类方法。继承主要解决代码复用和多态基础的问题，但过度使用会导致类层次过深、耦合增强，因此应遵循“组合优于继承”的原则。
2.2 项目实例：支付方式的继承体系
在电商系统中，支付方式多种多样（支付宝、微信、银行卡、积分支付等）。我们抽取一个抽象基类 Payment，定义支付流程的通用骨架。
public abstract class Payment {
protected String paymentId;
protected BigDecimal amount;
protected PaymentStatus status; // 枚举：INIT, PROCESSING, SUCCESS, FAILED
public Payment(BigDecimal amount) {
this.paymentId = UUID.randomUUID().toString();
this.amount = amount;
this.status = PaymentStatus.INIT;
}
// 模板方法：定义支付流程的骨架
public final PaymentResult process() {
try {
this.status = PaymentStatus.PROCESSING;
// 调用子类实现的特定支付渠道逻辑
boolean success = doPay();
if (success) {
this.status = PaymentStatus.SUCCESS;
return PaymentResult.success(this.paymentId);
} else {
this.status = PaymentStatus.FAILED;
return PaymentResult.fail("支付渠道返回失败");
}
} catch (Exception e) {
this.status = PaymentStatus.FAILED;
return PaymentResult.fail("支付异常: " + e.getMessage());
}
}
// 抽象方法，由子类具体实现
protected abstract boolean doPay();
// 公共 getter
public String getPaymentId() { return paymentId; }
public PaymentStatus getStatus() { return status; }
}
子类 AlipayPayment 和 WechatPayment 分别实现 doPay()：
public class AlipayPayment extends Payment {
private String alipayAccount;
public AlipayPayment(BigDecimal amount, String alipayAccount) {
super(amount);
this.alipayAccount = alipayAccount;
}
@Override
protected boolean doPay() {
// 调用支付宝 SDK 发起支付
System.out.println("使用支付宝账户 " + alipayAccount + " 支付 " + amount + " 元");
// 模拟成功/失败
return true;
}
}
public class WechatPayment extends Payment {
private String openId;
public WechatPayment(BigDecimal amount, String openId) {
super(amount);
this.openId = openId;
}
@Override
protected boolean doPay() {
System.out.println("使用微信 openId " + openId + " 支付 " + amount + " 元");
return true;
}
}
继承带来的好处：
公共字段（paymentId, amount, status）和公共流程（process()）在基类统一维护，子类只需关注差异化的支付逻辑。
process() 使用 final 修饰，保证流程不被篡改，符合“模板方法”设计模式。
未来新增 CreditCardPayment 只需继承 Payment 并实现 doPay()，无需修改现有代码，符合开闭原则。
三、多态（Polymorphism）—— 同一接口，不同形态
3.1 多态的定义与类型
多态允许不同类的对象对同一消息做出不同的响应。在 Java 中，多态分为两类：
编译时多态（静态多态）：通过方法重载实现，在编译期根据参数列表决定调用哪个方法。
运行时多态（动态多态）：通过继承 + 方法重写实现，在运行时根据实际对象类型决定调用哪个方法。
多态依赖于三个条件：继承、重写、父类引用指向子类对象。
3.2 项目实例：订单支付中的多态运用
在订单处理中，我们使用 Payment 父类引用来统一处理不同支付方式，这就是运行时多态。
public class OrderService {
public void processOrderPayment(Order order, Payment payment) {
// 此处 payment 的实际类型可能是 AlipayPayment 或 WechatPayment
PaymentResult result = payment.process(); // 多态调用
if (result.isSuccess()) {
order.pay(); // 更新订单状态
System.out.println("订单 " + order.getOrderId() + " 支付成功，支付ID: " + result.getPaymentId());
} else {
System.out.println("支付失败: " + result.getErrorMessage());
}
}
}
调用端：
public class Client {
public static void main(String[] args) {
Order order = new Order("O2026001", "U1001", createItems());
Payment alipay = new AlipayPayment(order.getTotalAmount(), "alice@alipay.com");
Payment wechat = new WechatPayment(order.getTotalAmount(), "wx_openid_123");
OrderService service = new OrderService();
service.processOrderPayment(order, alipay); // 支付宝支付
// service.processOrderPayment(order, wechat); // 微信支付
}
}
在 processOrderPayment 中，payment.process() 到底执行哪个类的 process()？由于 process() 是基类的非抽象方法（且 final），实际上调用的是基类的 process()，但基类的 process() 内部调用了 doPay()，而 doPay() 被子类重写，因此最终执行的是子类的 doPay()。这是多态的典型体现——父类方法中调用抽象方法，动态绑定到子类实现。
更进一步，如果我们在基类中也将 process() 定义为抽象（或非 final），则可以直接重写整个流程，但当前设计更符合模板方法模式。
四、重载（Overload）与重写（Override）—— 一字之差，天壤之别
这两个概念常被混淆，但它们在语法、绑定时机、应用场景上截然不同。下面通过对比表格和实例彻底厘清。
4.1 对比表格
4.2 重载实例 —— 订单查询服务
在订单管理模块中，我们可能需要多种查询方式：
public class OrderQueryService {
// 根据订单ID查询
public Order getOrder(String orderId) {
// 查询数据库
return new Order(orderId, …);
}
// 根据用户ID和状态查询（重载）
public List<Order> getOrder(String userId, OrderStatus status) {
// 查询用户某状态订单
return Collections.emptyList();
}
// 根据时间段查询（重载，参数类型不同）
public List<Order> getOrder(LocalDateTime start, LocalDateTime end) {
return Collections.emptyList();
}
// 注意：以下写法编译错误，因为返回值不同不足以区分
// public int getOrder(String orderId) { return 0; }
}
调用时，编译器根据参数类型自动选择：
OrderQueryService service = new OrderQueryService();
Order order = service.getOrder("O2026001"); // 调用第一个
List<Order> pending = service.getOrder("U1001", OrderStatus.PENDING); // 调用第二个
List<Order> range = service.getOrder(LocalDateTime.now().minusDays(1), LocalDateTime.now()); // 调用第三个
4.3 重写实例 —— 扩展支付渠道的验证逻辑
假设我们想在支付宝支付前增加一个账户余额检查，可以重写父类的 process() 方法（但父类 process() 是 final 的，我们改为非 final 来演示）：
// 修改父类：移除 final
public abstract class Payment {
// …
public PaymentResult process() {
// … 原逻辑
}
}
public class AlipayPayment extends Payment {
// …
@Override
public PaymentResult process() {
// 前置校验
if (!checkBalance()) {
return PaymentResult.fail("余额不足");
}
// 调用父类通用流程
return super.process();
}
private boolean checkBalance() {
// 调用支付宝余额查询
return true;
}
}
这里 process() 被重写，但子类仍然复用了父类的流程。注意：重写时方法签名必须完全匹配，加上 @Override 注解可防止拼写错误。
五、综合项目案例 —— 电商订单处理系统
为了将三大特性与重载重写融会贯通，我们构建一个简化但完整的订单处理流程，展示它们如何协同工作。
5.1 系统模块划分
订单模块：Order（封装）、OrderService（订单业务）
支付模块：Payment 抽象基类（继承）、子类（重写）、PaymentFactory（工厂）
优惠模块：Discount 接口（多态），支持不同优惠策略
日志模块：重载日志方法
5.2 代码实现
5.2.1 订单类（封装增强）
在原有基础上增加优惠金额字段，并提供应用优惠的方法：
public class Order {
// … 原有字段
private BigDecimal discountAmount = BigDecimal.ZERO;
private BigDecimal finalAmount; // 实际支付金额
public void applyDiscount(Discount discount) {
if (this.status != OrderStatus.PENDING) {
throw new IllegalStateException("只有待支付订单可应用优惠");
}
this.discountAmount = discount.calculate(this);
this.finalAmount = this.totalAmount.subtract(this.discountAmount);
if (this.finalAmount.compareTo(BigDecimal.ZERO) < 0) {
this.finalAmount = BigDecimal.ZERO;
}
}
public BigDecimal getFinalAmount() { return finalAmount != null ? finalAmount : totalAmount; }
}
5.2.2 优惠策略接口（多态）
public interface Discount {
BigDecimal calculate(Order order);
}
// 满减优惠
public class FullReductionDiscount implements Discount {
private BigDecimal threshold;
private BigDecimal reduction;
public FullReductionDiscount(BigDecimal threshold, BigDecimal reduction) {
this.threshold = threshold;
this.reduction = reduction;
}
@Override
public BigDecimal calculate(Order order) {
if (order.getTotalAmount().compareTo(threshold) >= 0) {
return reduction;
}
return BigDecimal.ZERO;
}
}
// 会员折扣
public class MemberDiscount implements Discount {
private double ratio; // 0.9 表示九折
public MemberDiscount(double ratio) {
this.ratio = ratio;
}
@Override
public BigDecimal calculate(Order order) {
return order.getTotalAmount().multiply(BigDecimal.valueOf(1 – ratio));
}
}
5.2.3 支付工厂（结合继承与多态）
public class PaymentFactory {
public static Payment createPayment(String type, BigDecimal amount, Map<String, String> params) {
switch (type) {
case "alipay":
return new AlipayPayment(amount, params.get("account"));
case "wechat":
return new WechatPayment(amount, params.get("openId"));
default:
throw new IllegalArgumentException("不支持的支付类型");
}
}
}
5.2.4 订单服务（重载的日志方法）
public class OrderService {
private static final Logger logger = LoggerFactory.getLogger(OrderService.class);
// 重载日志方法，方便不同场景
private void logPayment(String orderId, String paymentId) {
logger.info("订单 {} 支付成功，支付ID: {}", orderId, paymentId);
}
private void logPayment(String orderId, String paymentId, BigDecimal amount) {
logger.info("订单 {} 支付成功，金额 {}, 支付ID: {}", orderId, amount, paymentId);
}
public void processOrderPayment(Order order, String paymentType, Map<String, String> params) {
// 先应用默认优惠（此处可以扩展）
// 创建支付对象（多态）
Payment payment = PaymentFactory.createPayment(paymentType, order.getFinalAmount(), params);
PaymentResult result = payment.process();
if (result.isSuccess()) {
order.pay();
logPayment(order.getOrderId(), result.getPaymentId(), order.getFinalAmount()); // 调用重载方法
} else {
// 重载日志的另一种调用
logger.error("支付失败: {}", result.getErrorMessage());
}
}
}
5.2.5 主流程演示
public class ECommerceApp {
public static void main(String[] args) {
// 1. 创建订单（封装）
List<OrderItem> items = Arrays.asList(
new OrderItem("P001", "手机", BigDecimal.valueOf(2999), 1),
new OrderItem("P002", "耳机", BigDecimal.valueOf(199), 2)
);
Order order = new Order("O20260718", "U1001", items);
// 2. 应用优惠（多态）
Discount discount = new FullReductionDiscount(BigDecimal.valueOf(3000), BigDecimal.valueOf(200));
order.applyDiscount(discount);
System.out.println("应付金额: " + order.getFinalAmount());
// 3. 支付（继承+多态+重写）
Map<String, String> alipayParams = new HashMap<>();
alipayParams.put("account", "test@alipay.com");
OrderService service = new OrderService();
service.processOrderPayment(order, "alipay", alipayParams);
}
}
5.3 运行结果与分析
输出类似：
应付金额: 2998.00
使用支付宝账户 test@alipay.com 支付 2998.00 元
订单 O20260718 支付成功，金额 2998.00，支付ID: 123e4567…
流程中三大特性与重载重写的体现：
封装：Order 隐藏内部状态，通过 applyDiscount 和 pay 方法修改，保证了状态合法性。
继承：AlipayPayment 继承 Payment，复用了 paymentId、amount、status 和 process() 骨架。
多态：PaymentFactory 返回 Payment 引用，processOrderPayment 中调用 payment.process() 动态绑定到具体子类；Discount 接口的不同实现也在 applyDiscount 中展现了多态。
重载：OrderService 中的 logPayment 方法有两个重载版本，根据参数个数决定调用哪一个。
重写：AlipayPayment 和 WechatPayment 重写了 doPay() 抽象方法；若扩展 process()，则覆盖父类实现。
六、设计原则与最佳实践总结
封装：尽量将字段设为 private，提供有意义的业务方法，而不是一味增加 getter/setter。对于集合字段，返回不可变副本。
继承：仅在有明确的“is-a”关系时使用，层次不宜过深。优先使用组合（如 Order 包含 List<OrderItem>）。父类应为抽象类，定义模板方法。
多态：面向接口/抽象编程，降低调用方对具体实现的依赖。工厂模式配合多态是解耦的经典组合。
重载：用于提供相似功能的不同参数版本，但参数数量或类型必须有明显区别。避免过度重载导致混淆。
重写：必须遵守“里氏替换原则”，子类重写方法不能修改父类的意图（如不能抛出更宽泛的异常）。始终使用 @Override 注解。
区分：牢记重载是编译期行为，重写是运行期行为；重载看参数，重写看对象。
结语
封装、继承、多态并非孤立的知识点，它们相互支撑，共同构建出可维护、可扩展的软件系统。而重载与重写虽然名字相近，却分属不同的维度——一个服务于代码便捷性，一个服务于行为定制性。通过本文的电商项目实例，希望大家不仅能理解其概念，更能体会它们在真实项目中的协作方式。在日常编码中，有意识地运用这些特性，并时刻警惕滥用，才能写出优雅、健壮的面向对象代码。
