【软件设计】23 种设计模式解析与实践指南

引言

        设计模式（Design Pattern）是软件开发中反复出现的问题的解决方案，由 Erich Gamma 等四人组（GoF）在 1994 年系统化提出。

        在软件开发领域，设计模式是解决常见软件设计问题的可复用方案。它们就像是建筑师手中的蓝图，帮助开发者构建高效、可维护和可扩展的软件系统。掌握多种设计模式，能够让开发者在面对不同的项目需求时，灵活地选择合适的模式，从而提高软件的质量和开发效率。

一、设计模式分类

二、定义与描述

三、综合对比

 四、综合应用

(一)、文档编辑器

 场景：组合模式 + 装饰器模式 + 策略模式 + 观察者模式

 文档编辑器（树形结构管理 + 格式装饰 + 保存策略 + 实时预览）

// 组合模式：文档结构
interface DocumentComponent {
    void print();
    void accept(Visitor visitor);
}

class TextElement implements DocumentComponent {
    private String content;
    public TextElement(String content) { this.content = content; }
    public void print() { System.out.println(content); }
    public void accept(Visitor visitor) { visitor.visit(this); }
}

class CompositeElement implements DocumentComponent {
    private List<DocumentComponent> children = new ArrayList<>();
    public void add(DocumentComponent component) { children.add(component); }
    public void print() { children.forEach(DocumentComponent::print); }
    public void accept(Visitor visitor) { visitor.visit(this); }
}

// 装饰器模式：格式增强
abstract class FormatDecorator implements DocumentComponent {
    protected DocumentComponent component;
    public FormatDecorator(DocumentComponent component) { this.component = component; }
    public abstract void print();
    public void accept(Visitor visitor) { component.accept(visitor); }
}

class BoldDecorator extends FormatDecorator {
    public BoldDecorator(DocumentComponent component) { super(component); }
    public void print() { System.out.printf("<b>%s</b>", component); }
}

// 策略模式：保存策略
interface SaveStrategy {
    void save(DocumentComponent doc);
}

class HtmlSaveStrategy implements SaveStrategy {
    public void save(DocumentComponent doc) {
        System.out.println("Saving as HTML...");
        doc.accept(new HtmlVisitor());
    }
}

// 观察者模式：实时预览
interface Observer {
    void update(DocumentComponent doc);
}

class PreviewWindow implements Observer {
    public void update(DocumentComponent doc) {
        System.out.println("Preview updated:");
        doc.print();
    }
}

class DocumentManager implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private DocumentComponent document;
    
    public void attach(Observer observer) { observers.add(observer); }
    public void notifyObservers() { observers.forEach(o -> o.update(document)); }
    
    public void setDocument(DocumentComponent doc) {
        this.document = doc;
        notifyObservers();
    }
}

 类图：

时序图： 

 典型组合方案：

        树形结构 + 动态扩展：组合模式 + 装饰器模式

        流程控制 + 算法选择：责任链模式 + 策略模式

        数据遍历 + 操作分离：迭代器模式 + 访问者模式

 (二)、电商订单处理

  场景：组合模式 + 责任链模式 + 策略模式

  电商订单处理（订单拆分 → 多级审批 → 支付方式选择）

// 组合模式：订单结构
class OrderComponent {
    protected double amount;
    public abstract void process();
}

class CompositeOrder extends OrderComponent {
    private List<OrderComponent> children = new ArrayList<>();
    public void add(OrderComponent child) { children.add(child); }
    public void process() {
        children.forEach(OrderComponent::process);
    }
}

// 责任链模式：审批链
abstract class Approver {
    protected Approver successor;
    public void setSuccessor(Approver successor) { this.successor = successor; }
    public abstract void approve(OrderComponent order);
}

class ManagerApprover extends Approver {
    public void approve(OrderComponent order) {
        if (order.amount < 1000) {
            System.out.println("Manager approved");
        } else if (successor != null) {
            successor.approve(order);
        }
    }
}

// 策略模式：支付方式
interface PaymentStrategy {
    void pay(double amount);
}

class CreditCardStrategy implements PaymentStrategy {
    public void pay(double amount) {
        System.out.printf("Paid $%.2f via Credit Card%n", amount);
    }
}

 类图：

时序图： 

(三)、文件系统遍历

 场景：组合模式 + 迭代器模式 + 访问者模式

文件系统遍历（目录结构 → 迭代访问 → 统计文件信息）

// 组合模式：文件系统节点
interface FileSystemNode {
    void accept(FileVisitor visitor);
}

class File implements FileSystemNode {
    private String name;
    public void accept(FileVisitor visitor) { visitor.visit(this); }
}

class Directory implements FileSystemNode {
    private List<FileSystemNode> children = new ArrayList<>();
    public void add(FileSystemNode node) { children.add(node); }
    public void accept(FileVisitor visitor) {
        visitor.visit(this);
        children.forEach(n -> n.accept(visitor));
    }
}

// 迭代器模式：遍历器
class FileSystemIterator implements Iterator<FileSystemNode> {
    private Stack<FileSystemNode> stack = new Stack<>();
    
    public FileSystemIterator(FileSystemNode root) {
        stack.push(root);
    }
    
    public boolean hasNext() {
        return !stack.isEmpty();
    }
    
    public FileSystemNode next() {
        FileSystemNode node = stack.pop();
        if (node instanceof Directory) {
            ((Directory) node).getChildren().forEach(stack::push);
        }
        return node;
    }
}

// 访问者模式：文件统计
class FileVisitor {
    public void visit(File file) {
        System.out.println("File: " + file.getName());
    }
    
    public void visit(Directory directory) {
        System.out.println("Directory: " + directory.getName());
    }
}

类图：

时序图：

典型组合方案：

        树形结构 + 动态扩展：组合模式 + 装饰器模式

        流程控制 + 算法选择：责任链模式 + 策略模式

        数据遍历 + 操作分离：迭代器模式 + 访问者模式