当前位置： 首页 > news >正文

设计模式代码总结

news 2025/7/25 16:55:58
1. 抽象工厂模式 (Abstract Factory)

设计思路

  • 创建多组风格统一的产品族（如Mode1/Mode2风格）

  • 抽象工厂定义生产接口，具体工厂实现产品创建

  • 客户端通过抽象工厂获取产品，无需关心具体实现

流程图

完整代码实现

package cn.edu.cqupt.demo.designmode;public class AbstractFactory {public static void main(String[] args) {ABF fc1 = new Mode1F();ProductA mode1A = fc1.getProductA();mode1A.getA();ABF fc2 = new Mode2F();ProductA mode2A = fc2.getProductA();mode2A.getA();}
}// 1.抽象产品接口
interface ProductA { abstract void getA(); }
interface ProductB { abstract void getB(); }// 2.具体产品实现
class Mode1A implements ProductA {@Overridepublic void getA() { System.out.println("mode1A"); }
}
class Mode1B implements ProductB {@Overridepublic void getB() { System.out.println("mode1B"); }
}class Mode2A implements ProductA {@Overridepublic void getA() { System.out.println("mode2A"); }
}
class Mode2B implements ProductB {@Overridepublic void getB() { System.out.println("mode2B"); }
}// 3.抽象工厂接口
interface ABF {abstract ProductA getProductA();abstract ProductB getProductB();
}// 4.具体工厂实现
class Mode1F implements ABF {@Overridepublic ProductA getProductA() { return new Mode1A(); }@Overridepublic ProductB getProductB() { return new Mode1B(); }
}class Mode2F implements ABF {@Overridepublic ProductA getProductA() { return new Mode2A(); }@Overridepublic ProductB getProductB() { return new Mode2B(); }
}
2. 建造者模式 (Builder)

设计思路

  • 分离复杂对象的构建与表示

  • Director 控制构建流程，Builder 实现部件创建

  • 逐步构建最终产品，支持灵活配置

流程图

完整代码实现

package cn.edu.cqupt.demo.designmode;public class Builder {public static void main(String[] args) {AbstractBuilder ab = new ConcreteBuilder();Diretory dr = new Diretory();Product product = dr.getProduct(ab);product.useProduct();}
}// 1.产品类
class Product {private String partA;private String partB;public void setPartA(String partA) {this.partA = partA;System.out.println("创建好了partA");}public void setPartB(String partB) {this.partB = partB;System.out.println("创建好了partB");}public void useProduct() {System.out.println("我使用" + partA + "和" + partB + "创建了Product");}
}// 2.抽象建造者接口
interface AbstractBuilder {abstract void builderPartA(String partA);abstract void builderPartB(String partB);abstract Product getProduct();
}// 3.具体建造者
class ConcreteBuilder implements AbstractBuilder {Product product; // 核心产品对象ConcreteBuilder() { product = new Product(); }@Overridepublic void builderPartA(String partA) {product.setPartA(partA);}@Overridepublic void builderPartB(String partB) {product.setPartB(partB);}@Overridepublic Product getProduct() {return product;}
}// 4.指挥者类
class Diretory {public Product getProduct(AbstractBuilder ab) {ab.builderPartA("Directory 创建了a");ab.builderPartB("Directory 创建了b");return ab.getProduct();}
}
3. 装饰器模式 (Decorator)

设计思路

  • 动态扩展对象功能，无需继承

  • 核心：装饰器持有组件对象，在调用前后添加新行为

  • 支持多层嵌套装饰

流程图

完整代码实现

package cn.edu.cqupt.demo.designmode;import java.util.Scanner;public class Decorator {public static void main(String[] args) {MakeCoffee coffee = new ConcreteMakeCoffee();Scanner sc = new Scanner(System.in);int type = sc.nextInt();DecoratorMakeCoffee d1;if(type == 1) {d1 = new Ext1(coffee);} else {d1 = new Ext2(coffee);}d1.makeCoffee();}
}// 1.抽象接口
interface MakeCoffee { abstract void makeCoffee(); }// 2.具体实现类
class ConcreteMakeCoffee implements MakeCoffee {@Overridepublic void makeCoffee() { System.out.println("我做咖啡"); }
}// 3.装饰器基类
class DecoratorMakeCoffee implements MakeCoffee {protected MakeCoffee coffeeMaker; // 核心：持有组件对象public DecoratorMakeCoffee(MakeCoffee coffeeMaker) {this.coffeeMaker = coffeeMaker;}@Overridepublic void makeCoffee() {coffeeMaker.makeCoffee(); // 调用被装饰对象的方法}
}// 4.具体装饰器1
class Ext1 extends DecoratorMakeCoffee {public Ext1(MakeCoffee coffeeMaker) { super(coffeeMaker); }@Overridepublic void makeCoffee() {System.out.println("先做a");super.makeCoffee();}
}// 5.具体装饰器2
class Ext2 extends DecoratorMakeCoffee {public Ext2(MakeCoffee coffeeMaker) { super(coffeeMaker); }@Overridepublic void makeCoffee() {System.out.println("先做b");super.makeCoffee();}
}
4. 观察者模式 (Observer)

设计思路

  • 主题（Subject）状态变化时自动通知观察者

  • 观察者注册/解耦主题，实现松耦合通信

  • 适用于事件驱动系统

流程图

完整代码实现

package cn.edu.cqupt.demo.designmode;import java.util.ArrayList;
import java.util.List;public class Observer {public static void main(String[] args) {int n = 8;int v = 4;ConcreteSubject cs = new ConcreteSubject();for (int i = 0; i < n; i++) {cs.register(new ConcreteObserver());}for (int i = 0; i < v; i++) {cs.setState(i);}}
}// 1.抽象主题接口
interface Subject {abstract void register(AbstractObserver ao);abstract void delete(AbstractObserver ao);abstract void notifies();
}// 2.具体主题实现
class ConcreteSubject implements Subject {private int state;private List<AbstractObserver> list = new ArrayList<>();@Overridepublic void register(AbstractObserver ao) { list.add(ao); }@Overridepublic void delete(AbstractObserver ao) { list.remove(ao); }@Overridepublic void notifies() {for (AbstractObserver ao : list) {ao.method();}}// 核心：状态变化触发通知public void setState(int state) {this.state = state;System.out.println("state:" + state);notifies();}
}// 3.抽象观察者接口
interface AbstractObserver { abstract void method(); }// 4.具体观察者实现
class ConcreteObserver implements AbstractObserver {@Overridepublic void method() { System.out.println("变化了请通知老子"); }
}
5. 代理模式 (Proxy)

设计思路

  • 代理类控制对真实对象的访问

  • 代理与真实对象实现相同接口，客户端无感知

  • 常用于权限控制、延迟加载等场景

完整代码实现

package cn.edu.cqupt.demo.designmode;public class Proxy {public static void main(String[] args) {ProxyImpl pi = new ProxyImpl();pi.meathod();}
}// 1.抽象类
abstract class AbstractProxy {public abstract void meathod();
}// 2.具体实现类
class ConcreteImpl extends AbstractProxy {@Overridepublic void meathod() { System.out.println("活都是我干的"); }
}// 3.代理类
class ProxyImpl extends AbstractProxy {ConcreteImpl ci; // 核心：持有具体实现对象@Overridepublic void meathod() {if (ci == null) {ci = new ConcreteImpl();}System.out.println("我把接口封装了");ci.meathod(); // 委托给具体实现}
}
6. 单例模式 (Singleton)

设计思路

  • 确保全局只存在一个实例

  • 双重检测锁定（DCL）解决线程安全问题

  • volatile防止指令重排序

完整代码实现

package cn.edu.cqupt.demo.designmode;public class Singleton {// 1.私有化构造函数private Singleton() {}// 2.volatile保证可见性和禁止指令重排private static volatile Singleton instance;// 3.双重检查锁定获取实例public static Singleton getInstance() {if (instance == null) {synchronized (Singleton.class) {if (instance == null) {instance = new Singleton();}}}return instance;}
}
7. 策略模式 (Strategy)

设计思路

  • 封装可互换的算法族

  • 上下文类持有策略接口，动态切换行为

  • 消除条件分支语句（if-else）

完整代码实现

package cn.edu.cqupt.demo.designmode;public class Strategy {public static void main(String[] args) {// 根据不同策略创建上下文Context c1 = new Context(new strategy1());Context c2 = new Context(new strategy2());c1.implementStrategy();c2.implementStrategy();}// 1.抽象策略接口interface abstractStrategy {abstract void useStrategy();}// 2.具体策略实现static class strategy1 implements abstractStrategy {@Overridepublic void useStrategy() { System.out.println("策略1"); }}static class strategy2 implements abstractStrategy {@Overridepublic void useStrategy() { System.out.println("策略2"); }}// 3.上下文类static class Context {abstractStrategy strategy; // 持有策略对象public Context(abstractStrategy strategy) {this.strategy = strategy;}public void implementStrategy() {strategy.useStrategy(); // 执行当前策略}}
}
8. 模板模式 (Template)

设计思路

  • 父类定义算法骨架，子类实现具体步骤

  • 通过final方法固定流程，防止子类修改

  • 提供默认实现，子类可选择性重写

完整代码实现

package cn.edu.cqupt.demo.designmode;public class Template {public static void main(String[] args) {AbstractTemplate at = new ConcreteTemplate();at.method();}
}// 1.抽象模板类
abstract class AbstractTemplate {// final防止子类修改算法骨架final void method() {step1();step2();step3();}abstract void step1(); // 必须实现的步骤abstract void step2(); // 必须实现的步骤// 可选步骤（钩子方法）void step3() { System.out.println("默认的step3"); }
}// 2.具体模板实现
class ConcreteTemplate extends AbstractTemplate {@Overridevoid step1() { System.out.println("自己的step1"); }@Overridevoid step2() { System.out.println("自己的step2"); }@Overridevoid step3() { System.out.println("不用默认step3,我要自己实现"); }
}

http://www.lryc.cn/news/597330.html

相关文章：

  • 用 PyTorch 实现全连接网络识别 MNIST 手写数字
  • Android插件化实现方案深度分析
  • window下c++共享内存，进程互斥锁。
  • macOS配置maven及报错处理：zsh: permission denied: mvn
  • 大厂总结常用分析问题方法之CMMI-IDEAL模型
  • VRRP技术-设备备份技术
  • Modbus TCP转Devicenet：水泥厂PLC与多类仪表的自动化通信实践
  • 学习 Flutter（五）：玩安卓项目实战 - 下
  • 2025年7月一区SCI-投影迭代优化算法Projection Iterative Methods-附Matlab免费代码
  • Flutter学习笔记(四)---基础Widget
  • 如何解决pip安装报错ModuleNotFoundError: No module named ‘jupyter’问题
  • OSPF路由协议——上
  • 2025.7.15vlan作业
  • vscode怎么安装MINGW
  • Linux下SVN常用指令
  • VRRP虚拟路由器冗余协议
  • 民营医院如何突破技术与模式创新，迎来发展机遇？
  • 14.10 《24小时单卡训练！LoRA微调LLaMA2-7B全攻略，RTX 3090轻松跑》
  • Async/Await
  • translateZ数值大小变化
  • Python 程序设计讲义（7）：Python 的基本数据类型——整数类型
  • SpringMVC快速入门之请求与响应
  • JavaScript事件循环机制
  • 免费下载入户申请书，轻松办理登记手续——“文件扫描助手”网站介绍
  • 使用 piano_transcription_inference将钢琴录音转换为 MIDI
  • 开闭原则在C++中的实现
  • 基于Tornado的WebSocket实时聊天系统：从零到一构建与解析
  • 【js(5)原型与原型链】
  • 自由学习记录（72）
  • JavaEE Spring框架的概述与对比无框架下的优势