苏州企业网站建设,东营建设工程信息网站,门户网站建设兴田德润,wordpress 插件 销量一、设计模式核心分类
设计模式分为 3 大类#xff0c;共 23 种模式#xff08;考试常考约 10-15 种#xff09;#xff1a;
分类核心模式考试重点创建型模式工厂方法、抽象工厂、单例、生成器、原型单例模式的实现#xff08;懒汉、饿汉#xff09;、工厂模式的应用场…一、设计模式核心分类
设计模式分为 3 大类共 23 种模式考试常考约 10-15 种
分类核心模式考试重点创建型模式工厂方法、抽象工厂、单例、生成器、原型单例模式的实现懒汉、饿汉、工厂模式的应用场景结构型模式适配器、代理、装饰器、组合、外观、桥接适配器与代理的区别、装饰器模式的动态扩展特性行为型模式观察者、策略、模板方法、职责链、状态、迭代器、备忘录、中介者、解释器观察者模式的事件驱动、策略模式的算法替换、模板方法的流程固定步骤可扩展特性 二、设计模式分类GoF 23种模式
考试重点通常集中在以下分类及典型模式
1. 创建型模式
核心对象实例化的灵活控制。
1. 工厂方法模式Factory Method 定义 定义一个创建对象的接口但由子类决定具体实例化的类。 类图结构 抽象工厂类Creator声明工厂方法如createProduct()。 具体工厂类ConcreteCreator实现工厂方法返回具体产品对象。 抽象产品类Product定义产品的接口。 具体产品类ConcreteProduct实现产品接口。 应用场景 日志记录器不同格式的日志文件、数据库。 数据库连接不同数据库驱动MySQL、Oracle。 优点 符合开闭原则新增产品只需扩展子类。 客户端代码与具体产品解耦。 代码示例Java interface Product { void use(); }
class ConcreteProductA implements Product { public void use() { /*...*/ } }
abstract class Creator {public void operation() {Product p createProduct();p.use();}abstract Product createProduct();
}
class ConcreteCreatorA extends Creator {public Product createProduct() { return new ConcreteProductA(); }
} 2. 抽象工厂模式Abstract Factory 定义 提供一个接口用于创建相关或依赖对象的家族而无需指定具体类。 类图结构 抽象工厂接口AbstractFactory声明一组创建产品的方法如createButton(), createTextBox()。 具体工厂类ConcreteFactory实现接口生成同一产品族的具体对象。 抽象产品接口Button, TextBox定义产品的功能。 具体产品类WindowsButton, MacButton实现不同平台的组件。 与工厂方法的区别 工厂方法针对单一产品等级结构。 抽象工厂针对多个产品等级结构产品族。 缺点 扩展新产品族困难需修改抽象工厂接口。
3. 单例模式Singleton 定义 保证一个类只有一个实例并提供它的全局访问点。 实现要点 私有构造函数。 静态成员变量保存唯一实例。 提供静态方法获取实例如getInstance()。 线程安全实现 双重检查锁DCL适用于Java/C# public class Singleton {private static volatile Singleton instance;private Singleton() {}public static Singleton getInstance() {if (instance null) {synchronized (Singleton.class) {if (instance null) {instance new Singleton();}}}return instance;}
} 静态内部类延迟加载且线程安全 public class Singleton {private Singleton() {}private static class Holder {static final Singleton INSTANCE new Singleton();}public static Singleton getInstance() {return Holder.INSTANCE;}
}
4. 生成器模式Builder 定义 将一个复杂对象的构造过程与表示分离使得同样的构建过程可以创建不同的表示。 类图结构 抽象建造者Builder定义构建步骤的抽象接口如buildPartA(), buildPartB()。 具体建造者ConcreteBuilder实现构建步骤提供获取结果的接口。 指挥者Director构造一个使用Builder接口的对象。 产品Product最终构建的复杂对象。 应用场景 生成复杂对象如XML文档、HTML报表。 创建具有多个可选参数的对象避免构造函数参数爆炸。 代码示例简化版 class Computer {private String cpu;private String ram;// 构造函数私有只能通过Builder创建private Computer(Builder builder) { /*...*/ }static class Builder {private String cpu;private String ram;public Builder setCpu(String cpu) { this.cpu cpu; return this; }public Builder setRam(String ram) { this.ram ram; return this; }public Computer build() { return new Computer(this); }}
}
// 使用方式
Computer computer new Computer.Builder().setCpu(i7).setRam(16GB).build();
5. 原型模式Prototype 定义 用原型实例指定创建对象的种类并且通过复制这些原型创建新的对象。 实现要点 实现Cloneable接口Java或深拷贝逻辑。 提供clone()方法浅拷贝需谨慎处理引用类型。 应用场景 对象创建成本较高如数据库查询结果缓存后复制。 需要动态配置对象属性如游戏中的敌人克隆。 深拷贝 vs 浅拷贝 浅拷贝复制基本类型字段引用类型字段共享同一对象。 深拷贝引用类型字段也递归复制。 代码示例Java class Prototype implements Cloneable {private ListString list new ArrayList();Overridepublic Prototype clone() {try {Prototype copy (Prototype) super.clone();copy.list new ArrayList(this.list); // 深拷贝listreturn copy;} catch (CloneNotSupportedException e) {return null;}}
} 2. 结构型模式
核心通过组合类或对象形成更大结构。
1. 适配器模式Adapter 定义将一个类的接口转换成客户希望的另一个接口。 实现方式 类适配器通过继承适配者类实现目标接口。 对象适配器通过组合适配者对象实现目标接口。 应用场景 整合第三方库如不同格式的日志接口转换。 旧系统接口升级兼容。 代码示例 // 目标接口
interface Target { void request(); }// 适配者类
class Adaptee { void specificRequest() { /*...*/ } }// 对象适配器
class Adapter implements Target {private Adaptee adaptee;public Adapter(Adaptee adaptee) { this.adaptee adaptee; }public void request() { adaptee.specificRequest(); }
} 2. 装饰器模式Decorator 定义动态地为对象添加额外职责避免子类膨胀。 结构 组件接口Component定义一个对象接口可以对这些对象动态地添加职责。 具体组件ConcreteComponent定义一个对象可以对这个对象添加一些职责。 装饰器基类Decorator继承组件接口持有组件实例。 具体装饰器ConcreteDecorator添加附加功能。 应用场景 Java I/O流如BufferedInputStream装饰FileInputStream。 动态扩展对象行为如为订单添加折扣、税费计算。 代码示例 interface Coffee { double getCost(); }
class SimpleCoffee implements Coffee { public double getCost() { return 10; } }abstract class CoffeeDecorator implements Coffee {protected Coffee coffee;public CoffeeDecorator(Coffee coffee) { this.coffee coffee; }
}class MilkDecorator extends CoffeeDecorator {public MilkDecorator(Coffee coffee) { super(coffee); }public double getCost() { return coffee.getCost() 2; }
} 3. 代理模式Proxy 定义为其他对象提供一种代理以控制对这个对象的访问。 类型 虚拟代理延迟加载如图片懒加载。 保护代理控制访问权限。 远程代理跨网络访问对象如RPC。 应用场景 Spring AOP中的动态代理JDK动态代理、CGLIB。 访问敏感资源时的权限校验。 代码示例 interface Image { void display(); }class RealImage implements Image {public RealImage(String filename) { loadFromDisk(); }private void loadFromDisk() { /* 耗时操作 */ }public void display() { /* 显示图片 */ }
}class ProxyImage implements Image {private RealImage realImage;private String filename;public ProxyImage(String filename) { this.filename filename; }public void display() {if (realImage null) realImage new RealImage(filename);realImage.display();}
} 4. 组合模式Composite 定义将对象组合成树形结构以表示“部分-整体”层次使客户端统一处理单个对象和组合对象。 结构 组件接口Component定义叶子节点和容器的公共操作如add(), remove()。 叶子节点Leaf无子节点实现基础操作。 复合节点Composite包含子组件管理子组件集合。 应用场景 文件系统文件与文件夹的统一操作。 GUI容器控件如Panel包含Button、Label等。 代码示例 interface FileSystemComponent {void display();
}class File implements FileSystemComponent {public void display() { System.out.println(显示文件); }
}class Folder implements FileSystemComponent {private ListFileSystemComponent children new ArrayList();public void add(FileSystemComponent cmp) { children.add(cmp); }public void display() {for (FileSystemComponent cmp : children) cmp.display();}
} 5. 外观模式Facade 定义为子系统中的一组接口提供一个一致的界面简化客户端调用。 应用场景 复杂API的简化封装如支付系统的统一入口。 微服务网关聚合多个服务接口。 代码示例 class SubsystemA { void operationA() { /*...*/ } }
class SubsystemB { void operationB() { /*...*/ } }class Facade {private SubsystemA a new SubsystemA();private SubsystemB b new SubsystemB();public void simplifiedOperation() {a.operationA();b.operationB();}
} 6. 享元模式Flyweight 定义运用共享技术有效地支持大量细粒度的对象。 关键点 内部状态可共享的部分如字符的Unicode值。 外部状态不可共享的部分如字符的位置、颜色。 应用场景 文本编辑器中的字符对象池。 游戏中的粒子系统共享粒子类型外部传入位置和速度。 代码示例 class Flyweight {private String intrinsicState; // 内部状态public Flyweight(String intrinsicState) { this.intrinsicState intrinsicState; }public void operation(String extrinsicState) { /*...*/ }
}class FlyweightFactory {private MapString, Flyweight pool new HashMap();public Flyweight getFlyweight(String key) {if (!pool.containsKey(key)) pool.put(key, new Flyweight(key));return pool.get(key);}
} 7. 桥接模式Bridge 定义将抽象部分与实现部分分离使它们可以独立变化。 结构 抽象化Abstraction定义高层控制逻辑。 扩展抽象化RefinedAbstraction扩展抽象逻辑。 实现者Implementor定义底层实现接口。 具体实现者ConcreteImplementor实现具体功能。 应用场景 跨平台图形渲染如不同操作系统的绘图API。 消息发送方式邮件、短信与内容类型的解耦。 代码示例 interface Renderer { void renderCircle(float radius); }
class VectorRenderer implements Renderer { /* 矢量渲染 */ }
class RasterRenderer implements Renderer { /* 栅格渲染 */ }abstract class Shape {protected Renderer renderer;public Shape(Renderer renderer) { this.renderer renderer; }abstract void draw();
}class Circle extends Shape {private float radius;public Circle(Renderer renderer, float radius) { super(renderer); this.radius radius; }void draw() { renderer.renderCircle(radius); }
}
3. 行为型模式
核心对象间的通信与职责分配。
1. 模板方法模式Template Method 定义 定义算法的骨架将某些步骤延迟到子类实现使得子类可以不改变算法结构即可重定义某些步骤。 结构 抽象类AbstractClass定义模板方法final修饰和抽象步骤方法如primitiveStep1()。 具体子类ConcreteClass实现抽象步骤。 应用场景 框架设计如Spring的JdbcTemplate。 统一流程控制如订单处理流程验证→支付→发货。 代码示例 abstract class AbstractClass {public final void templateMethod() { // 模板方法step1();step2(); // 抽象步骤}void step1() { /* 默认实现 */ }abstract void step2();
}class ConcreteClass extends AbstractClass {void step2() { /* 子类实现 */ }
} 2. 策略模式Strategy 定义定义算法族封装每个算法使其可互相替换让算法的变化独立于使用它的客户端。 结构 策略接口Strategy定义算法方法如execute()。 具体策略类ConcreteStrategy实现不同算法。 上下文类Context持有策略对象并调用其算法。 应用场景 支付方式选择支付宝、微信支付等。 排序算法切换冒泡排序、快速排序。 代码示例 interface PaymentStrategy { void pay(int amount); }class AlipayStrategy implements PaymentStrategy {public void pay(int amount) { /* 支付宝支付逻辑 */ }
}class Context {private PaymentStrategy strategy;public void setStrategy(PaymentStrategy strategy) { this.strategy strategy; }public void executePay(int amount) { strategy.pay(amount); }
} 3. 观察者模式Observer 定义定义对象间的一对多依赖关系当一个对象主题状态改变时所有依赖它的对象观察者自动收到通知并更新。 结构 主题接口Subject提供注册、删除、通知观察者的方法。 具体主题ConcreteSubject维护观察者列表状态改变时通知所有观察者。 观察者接口Observer定义更新方法如update()。 具体观察者ConcreteObserver实现更新逻辑。 应用场景 事件驱动系统如GUI按钮点击事件。 发布-订阅模型如消息队列。 代码示例 interface Observer { void update(String message); }class ConcreteObserver implements Observer {public void update(String message) { /* 处理消息 */ }
}class Subject {private ListObserver observers new ArrayList();public void addObserver(Observer o) { observers.add(o); }public void notifyObservers(String message) {for (Observer o : observers) o.update(message);}
} 4. 责任链模式Chain of Responsibility 定义使多个对象有机会处理请求从而避免请求的发送者和接受者之前的耦合关系。将这些对象连成一条链并沿着这条链传递该请求直到有一个对象处理它为止。 结构 处理器接口Handler定义处理请求的方法和设置下一个处理器的链接方法。 具体处理器ConcreteHandler实现处理逻辑决定是否处理请求或传递给下一个处理器。 应用场景 审批流程如请假审批组长→经理→CEO。 异常处理链如Spring MVC的拦截器。 代码示例 abstract class Handler {protected Handler next;public void setNext(Handler next) { this.next next; }public abstract void handleRequest(Request request);
}class ManagerHandler extends Handler {public void handleRequest(Request request) {if (canHandle(request)) { /* 处理 */ } else if (next ! null) next.handleRequest(request);}
} 5. 命令模式Command 定义将请求封装为对象以便支持请求的排队、记录、撤销等操作。 结构 命令接口Command声明执行方法如execute()。 具体命令ConcreteCommand绑定接收者对象并调用其方法。 调用者Invoker触发命令执行如按钮点击。 接收者Receiver实际执行操作的对象。 应用场景 图形界面菜单操作撤销、重做。 任务队列调度如线程池任务提交。 代码示例 interface Command { void execute(); }class LightOnCommand implements Command {private Light light;public LightOnCommand(Light light) { this.light light; }public void execute() { light.on(); }
}class RemoteControl { // Invokerprivate Command command;public void setCommand(Command cmd) { this.command cmd; }public void pressButton() { command.execute(); }
} 6. 状态模式State 定义允许对象在其内部状态改变时改变行为将状态相关的逻辑封装到独立的状态类中。 结构 状态接口State定义状态行为方法如handle()。 具体状态类ConcreteState实现不同状态下的行为。 上下文类Context持有状态对象委托状态处理请求。 应用场景 订单状态流转待支付→已发货→已完成。 游戏角色状态正常、中毒、眩晕。 代码示例 interface State { void handle(Context context); }class ConcreteStateA implements State {public void handle(Context context) { context.setState(new ConcreteStateB());}
}class Context {private State state;public void setState(State state) { this.state state; }public void request() { state.handle(this); }
} 7.解释器模式Interpreter 定义给定一个语言定义它的文法的一种表示并定义一个解释器这个解释器使用该表示来解释语言中的句子。代码示例 // 抽象表达式
interface Expression {int interpret(Context context);
}// 终结符表达式数字
class Number implements Expression {private int value;public Number(int value) { this.value value; }public int interpret(Context context) { return value; }
}// 非终结符表达式加法
class Add implements Expression {private Expression left;private Expression right;public Add(Expression left, Expression right) {this.left left;this.right right;}public int interpret(Context context) {return left.interpret(context) right.interpret(context);}
}// 非终结符表达式乘法
class Multiply implements Expression {private Expression left;private Expression right;public Multiply(Expression left, Expression right) {this.left left;this.right right;}public int interpret(Context context) {return left.interpret(context) * right.interpret(context);}
}// 上下文此处简单实现无额外状态
class Context {}// 客户端构建语法树并解释
public class Client {public static void main(String[] args) {// 表达式1 2 * 3Expression expr new Add(new Number(1),new Multiply(new Number(2), new Number(3)));Context context new Context();System.out.println(expr.interpret(context)); // 输出7}
} 8. 中介者模式Mediator Pattern 定义 中介者模式通过引入一个中介对象来封装一组对象之间的交互减少对象间的直接依赖使交互变得松散耦合。 结构 Mediator中介者接口定义对象间通信的接口。 ConcreteMediator具体中介者协调各对象间的交互维护对同事对象的引用。 Colleague同事类接口定义同事对象的通用接口每个同事对象知道其中介者。 ConcreteColleague具体同事类实现同事接口通过中介者与其他同事通信。 对象间存在复杂的网状依赖关系如GUI组件间的交互。 需要集中控制多个对象间的通信逻辑。
代码示例Java
interface Mediator {void notify(Colleague sender, String event);
}class ChatRoom implements Mediator {private ListColleague users new ArrayList();public void addUser(Colleague user) { users.add(user); }Overridepublic void notify(Colleague sender, String message) {for (Colleague user : users) {if (user ! sender) user.receive(message);}}
}abstract class Colleague {protected Mediator mediator;public Colleague(Mediator mediator) { this.mediator mediator; }abstract void send(String message);abstract void receive(String message);
}class User extends Colleague {public User(Mediator mediator) { super(mediator); }Overridepublic void send(String message) {System.out.println(发送消息: message);mediator.notify(this, message);}Overridepublic void receive(String message) {System.out.println(接收消息: message);}
}// 客户端使用
public class Client {public static void main(String[] args) {ChatRoom chatRoom new ChatRoom();User alice new User(chatRoom);User bob new User(chatRoom);chatRoom.addUser(alice);chatRoom.addUser(bob);alice.send(你好); // Bob接收消息}
}
9.备忘录模式Memento Pattern
定义 备忘录模式在不破坏封装性的前提下捕获对象的内部状态并保存以便后续恢复。
结构 Originator原发器需要保存状态的对象提供创建备忘录和恢复状态的方法。 Memento备忘录存储原发器的状态通常为不可变对象。 Caretaker管理者负责保存和恢复备忘录但不操作其内容。
适用场景 需要实现撤销/重做功能如文本编辑器的撤销操作。 保存对象的历史状态用于回滚如游戏存档。
代码示例Java
// 原发器
class TextEditor {private String content;public void setContent(String content) { this.content content; }public String getContent() { return content; }public Memento save() { return new Memento(content); }public void restore(Memento memento) { this.content memento.getContent(); }
}// 备忘录
class Memento {private final String content;public Memento(String content) { this.content content; }public String getContent() { return content; }
}// 管理者
class History {private ListMemento mementos new ArrayList();public void push(Memento memento) { mementos.add(memento); }public Memento pop() { return mementos.remove(mementos.size() - 1); }
}// 客户端使用
public class Client {public static void main(String[] args) {TextEditor editor new TextEditor();History history new History();editor.setContent(Version 1);history.push(editor.save());editor.setContent(Version 2);history.push(editor.save());editor.restore(history.pop()); // 回退到Version 1System.out.println(editor.getContent());}
}
10.访问者模式Visitor Pattern
定义 访问者模式将作用于对象结构的操作与对象本身分离允许在不修改对象结构的前提下定义新操作。
结构 Visitor访问者接口声明访问对象结构中各元素的方法如visitElementA()。 ConcreteVisitor具体访问者实现访问者接口定义具体操作。 Element元素接口定义接受访问者的方法accept(Visitor visitor)。 ConcreteElement具体元素实现元素接口调用访问者的对应方法。 ObjectStructure对象结构维护元素集合提供遍历接口。
适用场景 需要对复杂对象结构进行多种独立操作如编译器语法树分析。 避免污染元素类的代码如统计功能与业务逻辑分离。
代码示例Java
interface Visitor {void visit(ElementA element);void visit(ElementB element);
}class ConcreteVisitor implements Visitor {Overridepublic void visit(ElementA element) {System.out.println(处理ElementA: element.operationA());}Overridepublic void visit(ElementB element) {System.out.println(处理ElementB: element.operationB());}
}interface Element {void accept(Visitor visitor);
}class ElementA implements Element {public String operationA() { return 操作A; }Overridepublic void accept(Visitor visitor) { visitor.visit(this); }
}class ElementB implements Element {public String operationB() { return 操作B; }Overridepublic void accept(Visitor visitor) { visitor.visit(this); }
}// 客户端使用
public class Client {public static void main(String[] args) {ListElement elements Arrays.asList(new ElementA(), new ElementB());Visitor visitor new ConcreteVisitor();for (Element element : elements) {element.accept(visitor);}}
}
11.迭代器模式Iterator Pattern
定义迭代器模式是一种行为型设计模式提供一种方法顺序访问聚合对象中的元素而无需暴露其底层表示。核心思想是将遍历逻辑从聚合对象中分离实现数据存储与遍历解耦。 Aggregate聚合接口声明createIterator()方法返回一个迭代器对象。 ConcreteAggregate具体聚合类实现聚合接口返回与自身数据结构匹配的具体迭代器实例如new ConcreteIterator(this)。 Iterator迭代器接口定义遍历方法 hasNext()判断是否还有下一个元素。 next()移动游标并返回当前元素。 currentItem()可选直接获取当前元素不移动游标。 ConcreteIterator具体迭代器实现迭代器接口维护当前遍历位置如currentIndex并与聚合对象交互以访问元素。
