深入理解设计模式：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
public Order(String orderId, List
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
public OrderBuilder setOrderId(String orderId) {
this.orderId = orderId;
return this;
}
public OrderBuilder setItems(List
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
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
}
代理设计模式
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
return cart.getItems();
}
}
组合设计模式
public class CartComposite extends CartComponent {
private List
@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
public Mediator(List
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
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
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);
}
}
}
五、总结
设计模式是解决特定类型软件设计问题的解决方案，它们提供了一种抽象的方式来表达应用程序中常见问题的解决方案。通过遵循设计模式的六大原则，可以提高代码的可维护性、灵活性和可扩展性。设计模式分为创建型、结构型和行为型三大类，每种设计模式都有其特定的应用场景和实现方式。通过实际的示例代码，可以更好地理解和应用这些设计模式。