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

设计模式代码总结

news 2025/7/26 9:08:48

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.dtcms.com/a/293935.html