Java面试中的设计模式：如何展示你的架构设计能力？

设计模式是Java面试中考察候选人架构设计能力的重要切入点。掌握设计模式不仅能解决复杂问题，更能体现开发者对代码可维护性、扩展性的思考。本文将深入探讨面试中常见的设计模式应用场景，通过典型代码示例展示如何在实际问题中运用设计模式，以及如何向面试官有效传达你的设计思路。

一、为什么设计模式是面试重点？

1.1 设计模式反映开发者经验

设计模式是前人经验的总结，熟练运用表明你：

• 熟悉常见问题的标准解决方案
• 关注代码的可维护性和扩展性
• 具备抽象和封装复杂逻辑的能力

1.2 架构设计能力的直接体现

面试官通过设计模式问题考察：

• 能否识别问题中的设计缺陷
• 能否选择合适模式进行优化
• 能否平衡过度设计和设计不足

二、面试高频设计模式实战

2.1 策略模式：消除条件分支

典型场景：支付系统需要支持多种支付方式（支付宝、微信、银行卡），且可能随时新增方式。

// 定义策略接口
public interface PaymentStrategy {
    void pay(double amount);
}

// 具体策略实现
public class AlipayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付：" + amount);
    }
}

public class WechatPayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用微信支付：" + amount);
    }
}

// 上下文类
public class PaymentContext {
    private PaymentStrategy strategy;
    
    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void executePayment(double amount) {
        strategy.pay(amount);
    }
}

// 使用示例
public class Client {
    public static void main(String[] args) {
        PaymentContext context = new PaymentContext();
        
        // 动态切换策略
        context.setStrategy(new AlipayStrategy());
        context.executePayment(100.0);
        
        context.setStrategy(new WechatPayStrategy());
        context.executePayment(200.0);
    }
}

面试回答要点：

1. 指出if-else/switch-case的维护性问题
2. 强调开闭原则（对扩展开放，对修改关闭）
3. 说明如何支持未来新增支付方式

2.2 观察者模式：解耦事件处理

典型场景：订单状态变更时需要通知用户、库存系统、物流系统等多个模块。

// 主题接口
public interface OrderSubject {
    void registerObserver(OrderObserver o);
    void removeObserver(OrderObserver o);
    void notifyObservers();
}

// 具体主题
public class Order implements OrderSubject {
    private List<OrderObserver> observers = new ArrayList<>();
    private String state;
    
    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }
    
    @Override
    public void registerObserver(OrderObserver o) {
        observers.add(o);
    }
    
    @Override
    public void removeObserver(OrderObserver o) {
        observers.remove(o);
    }
    
    @Override
    public void notifyObservers() {
        for (OrderObserver observer : observers) {
            observer.update(this.state);
        }
    }
}

// 观察者接口
public interface OrderObserver {
    void update(String state);
}

// 具体观察者
public class UserNotification implements OrderObserver {
    @Override
    public void update(String state) {
        System.out.println("用户通知：订单状态变更为 " + state);
    }
}

public class InventorySystem implements OrderObserver {
    @Override
    public void update(String state) {
        if ("SHIPPED".equals(state)) {
            System.out.println("库存系统：扣除库存");
        }
    }
}

// 使用示例
public class Client {
    public static void main(String[] args) {
        Order order = new Order();
        order.registerObserver(new UserNotification());
        order.registerObserver(new InventorySystem());
        
        order.setState("PAID");
        order.setState("SHIPPED");
    }
}

面试回答要点：

1. 对比直接调用和观察者模式的区别
2. 强调松耦合的设计优势
3. 讨论Java内置的Observer/Observable为何不推荐使用

三、高级设计模式应用

3.1 组合模式：处理树形结构

典型场景：组织架构管理（部门与员工的层级关系）

// 组件接口
public interface OrganizationComponent {
    void display();
    void add(OrganizationComponent component);
}

// 叶子节点
public class Employee implements OrganizationComponent {
    private String name;
    
    public Employee(String name) {
        this.name = name;
    }
    
    @Override
    public void display() {
        System.out.println("员工：" + name);
    }
    
    @Override
    public void add(OrganizationComponent component) {
        throw new UnsupportedOperationException();
    }
}

// 复合节点
public class Department implements OrganizationComponent {
    private String name;
    private List<OrganizationComponent> children = new ArrayList<>();
    
    public Department(String name) {
        this.name = name;
    }
    
    @Override
    public void display() {
        System.out.println("部门：" + name);
        for (OrganizationComponent component : children) {
            component.display();
        }
    }
    
    @Override
    public void add(OrganizationComponent component) {
        children.add(component);
    }
}

// 使用示例
public class Client {
    public static void main(String[] args) {
        Department company = new Department("总公司");
        
        Department devDept = new Department("研发部");
        devDept.add(new Employee("张三"));
        devDept.add(new Employee("李四"));
        
        Department salesDept = new Department("销售部");
        salesDept.add(new Employee("王五"));
        
        company.add(devDept);
        company.add(salesDept);
        
        company.display();
    }
}

面试回答要点：

1. 解释透明式和安全式组合模式的区别
2. 讨论组合模式与递归算法的关系
3. 举例说明JDK中哪些地方使用了组合模式（如AWT组件）

四、面试中如何展示设计能力

4.1 设计模式选择方法论

1. 先明确需求变化点（什么会变？什么不变？）
2. 评估模式带来的复杂度和收益
3. 考虑与其他模式的组合使用

4.2 避免常见误区

• 不要为了用模式而用模式
• 警惕过度设计（YAGNI原则）
• 能说清楚不使用某种模式的原因同样重要

4.3 回答框架示例

1. 分析当前设计的问题
2. 提出改进方案（选择特定模式）
3. 说明改进后的优势
4. 讨论可能的替代方案及取舍

五、总结

掌握设计模式的本质是培养良好的设计思维。面试中，展示你对模式的理解深度比简单罗列模式更重要。通过结合实际案例，说明你如何权衡各种设计选择，这将有效证明你的架构设计能力。记住，优秀的设计往往不是使用最复杂的设计模式，而是用最简单的方案优雅地解决问题。