深入理解设计模式：23种经典模式全解析与应用示例
一、设计模式简介
设计模式是一组用于解决特定类型软件设计问题的解决方案。它们提供了一种抽象的方式来表达应用程序中常见问题的解决方案，帮助开发者更有效地解决问题，提高开发效率，降低开发成本，提高代码质量和可维护性，以及更好地管理和理解复杂的系统。
二、设计模式的六大原则
-
开闭原则（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); } } }
五、总结
设计模式是解决特定类型软件设计问题的解决方案，它们提供了一种抽象的方式来表达应用程序中常见问题的解决方案。通过遵循设计模式的六大原则，可以提高代码的可维护性、灵活性和可扩展性。设计模式分为创建型、结构型和行为型三大类，每种设计模式都有其特定的应用场景和实现方式。通过实际的示例代码，可以更好地理解和应用这些设计模式。
浙公网安备 33010602011771号