深入理解设计模式：23种经典模式全解析与应用示例

jack.yang

发布于 2025-04-10 08:31:51

8850

文章被收录于专栏：设计模式系列设计模式系列

一、设计模式简介

设计模式是一组用于解决特定类型软件设计问题的解决方案。它们提供了一种抽象的方式来表达应用程序中常见问题的解决方案，帮助开发者更有效地解决问题，提高开发效率，降低开发成本，提高代码质量和可维护性，以及更好地管理和理解复杂的系统。

二、设计模式的六大原则

开闭原则（Open Close Principle）
- 实体应该对扩展开放，对修改关闭。
- 应用时注意点：充分利用抽象类和接口、多态等特性，将可变部分封装起来，提高系统的灵活性和可维护性。
单一职责原则
- 一个类应该只负责一项职责，不要存在多于一个的非本职责原因引起类的变更。
- 应用时注意点：在设计时尽量把类的职责划分清楚，把功能模块化，提高系统的灵活性和可维护性。
里氏替换原则（Liskov Substitution Principle）
- 任何基类可以出现的地方，子类一定可以出现。
- 应用时注意点：在设计时应让父类和子类之间有一个共同的抽象层，以便子类可以重写父类的抽象方法，并在子类中实现这些抽象方法。
依赖倒转原则（Dependence Inversion Principle）
- 面向接口编程，依赖于抽象而不依赖于具体。
- 应用时注意点：在设计时以抽象为基础，尽量将细节层次降低，使系统可以更灵活地应对变化。
接口隔离原则（Interface Segregation Principle）
- 每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。
- 应用时注意点：把接口进行分解，使用多个小接口，以便更好地实现功能的模块化管理，提高系统的灵活性和可维护性。
迪米特法则（最少知道原则）（Demeter Principle）
- 一个类对自己依赖的类知道的越少越好。
- 应用时注意点：尽量减少类与类之间的耦合，提高系统的灵活性和可维护性。
合成复用原则（Composite Reuse Principle）
- 尽量使用组合/聚合的方式，而不是使用继承关系来达到复用的目的。
- 应用时注意点：尽量使用组合/聚合的方式，使用继承可能带来的耦合性太强，从而影响系统的灵活性和可维护性。

三、设计模式的分类

设计模式分为三大类：

创建型设计模式
- 工厂方法设计模式
- 抽象工厂设计模式
- 单例设计模式
- 建造者设计模式
- 原型设计模式
结构型设计模式
- 适配器设计模式
- 装饰器设计模式
- 代理设计模式
- 外观设计模式
- 桥接设计模式
- 组合设计模式
- 享元设计模式
行为型设计模式
- 策略设计模式
- 模板方法设计模式
- 观察者设计模式
- 迭代子设计模式
- 责任链设计模式
- 命令设计模式
- 备忘录设计模式
- 状态设计模式
- 访问者设计模式
- 中介者设计模式
- 解释器设计模式

四、常用设计模式示例

以下是一些常用设计模式的Java实现示例：

工厂方法设计模式

abstract class Order {
    public abstract void process();
}

class OnlineOrder extends Order {
    @Override
    public void process() {
        System.out.println("Processing online order.");
    }
}

class OfflineOrder extends Order {
    @Override
    public void process() {
        System.out.println("Processing offline order.");
    }
}

class OrderFactory {
    public static Order createOrder(String type) {
        switch (type) {
            case "online":
                return new OnlineOrder();
            case "offline":
                return new OfflineOrder();
            default:
                throw new IllegalArgumentException("Invalid order type: " + type);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Order onlineOrder = OrderFactory.createOrder("online");
        onlineOrder.process();
        Order offlineOrder = OrderFactory.createOrder("offline");
        offlineOrder.process();
    }
}

抽象工厂设计模式

public abstract class AbstractCouponFactory {
    public abstract Coupon createCoupon();
    public abstract Promotion createPromotion();
}

public abstract class Coupon {
    public abstract void useCoupon();
}

public class NewUserCoupon extends Coupon {
    public void useCoupon() {
        System.out.println("使用新用户优惠券");
    }
}

public abstract class Promotion {
    public abstract void startPromotion();
}

public class DoubleElevenPromotion extends Promotion {
    public void startPromotion() {
        System.out.println("开始双十一活动");
    }
}

public class MotherAndBabyCouponFactory extends AbstractCouponFactory {
    public Coupon createCoupon() {
        return new NewUserCoupon();
    }
    public Promotion createPromotion() {
        return new DoubleElevenPromotion();
    }
}

public class Client {
    public static void main(String[] args) {
        AbstractCouponFactory factory = new MotherAndBabyCouponFactory();
        Coupon coupon = factory.createCoupon();
        Promotion promotion = factory.createPromotion();
        coupon.useCoupon();
        promotion.startPromotion();
    }
}

单例设计模式

public class OrderService {
    private OrderService() {}

    private volatile static OrderService instance;

    public static OrderService getInstance() {
        if (instance == null) {
            synchronized (OrderService.class) {
                if (instance == null) {
                    instance = new OrderService();
                }
            }
        }
        return instance;
    }

    public void placeOrder(Order order) {
        // ...
    }
}

原型设计模式

public class Order implements Cloneable {
    private String orderId;
    private List<String> items;

    public Order(String orderId, List<String> items) {
        this.orderId = orderId;
        this.items = items;
    }

    public Order clone() {
        try {
            return (Order) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}

建造者设计模式

public class OrderBuilder {
    private String orderId;
    private List<String> items;

    public OrderBuilder setOrderId(String orderId) {
        this.orderId = orderId;
        return this;
    }

    public OrderBuilder setItems(List<String> items) {
        this.items = items;
        return this;
    }

    public Order build() {
        return new Order(orderId, items);
    }
}

适配器设计模式

interface Product {
    String getName();
    double getPrice();
}

class LegacyProduct {
    private final String title;
    private final double cost;

    public LegacyProduct(String title, double cost) {
        this.title = title;
        this.cost = cost;
    }

    public String getTitle() {
        return this.title;
    }

    public double getCost() {
        return this.cost;
    }
}

class ProductAdapter implements Product {
    private final LegacyProduct legacyProduct;

    public ProductAdapter(LegacyProduct legacyProduct) {
        this.legacyProduct = legacyProduct;
    }

    @Override
    public String getName() {
        return legacyProduct.getTitle();
    }

    @Override
    public double getPrice() {
        return legacyProduct.getCost();
    }
}

public class AdapterDemo {
    public static void main(String[] args) {
        LegacyProduct legacyProduct = new LegacyProduct("Product A", 12.34);
        Product product = new ProductAdapter(legacyProduct);
        System.out.println(product.getName()); // 输出：Product A
        System.out.println(product.getPrice()); // 输出：12.34
    }
}

装饰者设计模式

public class OrderDecorator {
    private Order order;

    public OrderDecorator(Order order) {
        this.order = order;
    }

    public void setDiscount(double discount) {
        order.setDiscount(discount);
    }

    public double getDiscount() {
        return order.getDiscount();
    }
}

外观设计模式

public class OrderFacade {
    private OrderService orderService;
    private OrderBuilder orderBuilder;
    private OrderAdapter orderAdapter;
    private OrderDecorator orderDecorator;

    public OrderFacade() {
        orderService = OrderService.getInstance();
        orderBuilder = new OrderBuilder();
        orderAdapter = new OrderAdapter();
        orderDecorator = new OrderDecorator();
    }

    public void placeOrder(Order order) {
        orderService.placeOrder(order);
    }

    public Order buildOrder(String orderId, List<String> items) {
        return orderBuilder.setOrderId(orderId).setItems(items).build();
    }

    public OrderAdapter getOrderAdapter(Order order) {
        return new OrderAdapter(order);
    }

    public OrderDecorator getOrderDecorator(Order order) {
        return new OrderDecorator(order);
    }
}

桥接设计模式 public abstract class Cart { protected CartImplementor implementor; public Cart(CartImplementor implementor) { this.implementor = implementor; } public abstract void addItem(String item); public abstract void removeItem(String item); public abstract List<String> getItems(); }
代理设计模式

public class CartProxy implements Cart {
    private Cart cart;

    public CartProxy(Cart cart) {
        this.cart = cart;
    }

    @Override
    public void addItem(String item) {
        cart.addItem(item);
    }

    @Override
    public void removeItem(String item) {
        cart.removeItem(item);
    }

    @Override
    public List<String> getItems() {
        return cart.getItems();
    }
}

组合设计模式

public class CartComposite extends CartComponent {
    private List<CartComponent> components = new ArrayList<>();

    @Override
    public void add(CartComponent component) {
        components.add(component);
    }

    @Override
    public void remove(CartComponent component) {
        components.remove(component);
    }

    @Override
    public int getTotalPrice() {
        int totalPrice = 0;
        for (CartComponent component : components) {
            totalPrice += component.getTotalPrice();
        }
        return totalPrice;
    }
}

责任链设计模式

public abstract class CartHandler {
    protected CartHandler nextHandler;

    public void setNextHandler(CartHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract void handle(Cart cart);
}

命令设计模式

public interface Command {
    void execute(Cart cart);
}

public class AddItemCommand implements Command {
    private String item;

    public AddItemCommand(String item) {
        this.item = item;
    }

    @Override
    public void execute(Cart cart) {
        cart.addItem(item);
    }
}

解释器设计模式

public class CartExpressionParser {
    public void parse(String expression, Cart cart) {
        String[] tokens = expression.split(" ");
        for (String token : tokens) {
            if (token.equals("add")) {
                String item = tokens[1];
                cart.addItem(item);
            } else if (token.equals("remove")) {
                String item = tokens[1];
                cart.removeItem(item);
            }
        }
    }
}

迭代器设计模式

public interface Iterator {
    boolean hasNext();
    Object next();
}

public class PaymentIterator implements Iterator {
    private Payment[] payments;
    private int index;

    public PaymentIterator(Payment[] payments) {
        this.payments = payments;
    }

    @Override
    public boolean hasNext() {
        if (index >= payments.length || payments[index] == null) {
            return false;
        } else {
            return true;
        }
    }

    @Override
    public Object next() {
        Payment payment = payments[index];
        index++;
        return payment;
    }
}

中介者设计模式

public class Mediator {
    private List<Payment> payments;

    public Mediator(List<Payment> payments) {
        this.payments = payments;
    }

    public void makePayment(Payment payment) {
        payments.forEach(p -> { if (p != payment) { p.receivePayment(payment); } });
    }
}

观察者设计模式

public interface Observer {
    void update(Payment payment);
}

public class PaymentSubject {
    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers(Payment payment) {
        for (Observer observer : observers) {
            observer.update(payment);
        }
    }
}

状态设计模式

public interface PaymentState {
    void doAction(PaymentContext context);
}

public class PaymentContext {
    private PaymentState paymentState;

    public PaymentContext() {
        paymentState = null;
    }

    public void setState(PaymentState state) {
        this.paymentState = state;
    }

    public PaymentState getState() {
        return paymentState;
    }

    public void doAction() {
        paymentState.doAction(this);
    }
}

策略设计模式

public interface PaymentStrategy {
    void pay(int amount);
}

public class CreditCardStrategy implements PaymentStrategy {
    private String name;
    private String cardNumber;
    private String cvv;
    private String dateOfExpiry;

    public CreditCardStrategy(String name, String cardNumber, String cvv, String dateOfExpiry) {
        this.name = name;
        this.cardNumber = cardNumber;
        this.cvv = cvv;
        this.dateOfExpiry = dateOfExpiry;
    }

    @Override
    public void pay(int amount) {
        System.out.println(amount + " paid with credit/debit card");
    }
}

模板方法设计模式

public abstract class PaymentTemplate {
    protected abstract void doPayment();

    public void payment() {
        doPayment();
    }
}

public class CreditCardPayment extends PaymentTemplate {
    private String name;
    private String cardNumber;
    private String cvv;
    private String dateOfExpiry;

    public CreditCardPayment(String name, String cardNumber, String cvv, String dateOfExpiry) {
        this.name = name;
        this.cardNumber = cardNumber;
        this.cvv = cvv;
        this.dateOfExpiry = dateOfExpiry;
    }

    @Override
    protected void doPayment() {
        System.out.println("Paid with credit/debit card");
    }
}

备忘录设计模式

public class Memento {
    private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }
}

public class CouponService {
    private Memento memento;

    public void saveMemento(Memento memento) {
        this.memento = memento;
    }

    public void restoreMemento(Memento memento) {
        this.memento = memento;
    }
}

访问者设计模式

public class CouponVisitor {
    public void visit(DiscountCoupon coupon) {
        // do something
    }

    public void visit(CashCoupon coupon) {
        // do something
    }
}

解释器设计模式

public abstract class AbstractExpression {
    public abstract boolean interpret(String context);
}

public class TerminalExpression extends AbstractExpression {
    private String data;

    public TerminalExpression(String data) {
        this.data = data;
    }

    @Override
    public boolean interpret(String context) {
        if (context.contains(data)) {
            return true;
        }
        return false;
    }
}

调停者设计模式

public class CouponMediator {
    private List<CouponUser> users;

    public CouponMediator() {
        this.users = new ArrayList<>();
    }

    public void addUser(CouponUser user) {
        this.users.add(user);
    }

    public void distributeCoupon(Coupon coupon) {
        for (CouponUser user : users) {
            user.receiveCoupon(coupon);
        }
    }

    public void redeemCoupon(Coupon coupon) {
        for (CouponUser user : users) {
            user.redeemCoupon(coupon);
        }
    }
}

五、总结

设计模式是解决特定类型软件设计问题的解决方案，它们提供了一种抽象的方式来表达应用程序中常见问题的解决方案。通过遵循设计模式的六大原则，可以提高代码的可维护性、灵活性和可扩展性。设计模式分为创建型、结构型和行为型三大类，每种设计模式都有其特定的应用场景和实现方式。通过实际的示例代码，可以更好地理解和应用这些设计模式。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-04-09，如有侵权请联系 cloudcommunity@tencent.com 删除

public