设计模式代码总结

xzkyd outpaper2025-07-24 19:38
1. 抽象工厂模式 (Abstract Factory)

设计思路

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

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

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

流程图

完整代码实现

java 复制代码 
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 {
    @Override
    public void getA() { System.out.println("mode1A"); }
}
class Mode1B implements ProductB {
    @Override
    public void getB() { System.out.println("mode1B"); }
}

class Mode2A implements ProductA {
    @Override
    public void getA() { System.out.println("mode2A"); }
}
class Mode2B implements ProductB {
    @Override
    public void getB() { System.out.println("mode2B"); }
}

// 3.抽象工厂接口
interface ABF {
    abstract ProductA getProductA();
    abstract ProductB getProductB();
}

// 4.具体工厂实现
class Mode1F implements ABF {
    @Override
    public ProductA getProductA() { return new Mode1A(); }
    @Override
    public ProductB getProductB() { return new Mode1B(); }
}

class Mode2F implements ABF {
    @Override
    public ProductA getProductA() { return new Mode2A(); }
    @Override
    public ProductB getProductB() { return new Mode2B(); }
}
2. 建造者模式 (Builder)

设计思路

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

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

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

流程图

完整代码实现

java 复制代码 
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(); }

    @Override
    public void builderPartA(String partA) {
        product.setPartA(partA);
    }

    @Override
    public void builderPartB(String partB) {
        product.setPartB(partB);
    }

    @Override
    public 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)

设计思路

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

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

  • 支持多层嵌套装饰

流程图

完整代码实现

java 复制代码 
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 {
    @Override
    public void makeCoffee() { System.out.println("我做咖啡"); }
}

// 3.装饰器基类
class DecoratorMakeCoffee implements MakeCoffee {
    protected MakeCoffee coffeeMaker; // 核心：持有组件对象
    
    public DecoratorMakeCoffee(MakeCoffee coffeeMaker) {
        this.coffeeMaker = coffeeMaker;
    }

    @Override
    public void makeCoffee() {
        coffeeMaker.makeCoffee(); // 调用被装饰对象的方法
    }
}

// 4.具体装饰器1
class Ext1 extends DecoratorMakeCoffee {
    public Ext1(MakeCoffee coffeeMaker) { super(coffeeMaker); }
    
    @Override
    public void makeCoffee() {
        System.out.println("先做a");
        super.makeCoffee();
    }
}

// 5.具体装饰器2
class Ext2 extends DecoratorMakeCoffee {
    public Ext2(MakeCoffee coffeeMaker) { super(coffeeMaker); }
    
    @Override
    public void makeCoffee() {
        System.out.println("先做b");
        super.makeCoffee();
    }
}
4. 观察者模式 (Observer)

设计思路

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

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

  • 适用于事件驱动系统

流程图

完整代码实现

java 复制代码 
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<>();

    @Override
    public void register(AbstractObserver ao) { list.add(ao); }
    
    @Override
    public void delete(AbstractObserver ao) { list.remove(ao); }
    
    @Override
    public 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 {
    @Override
    public void method() { 
        System.out.println("变化了请通知老子"); 
    }
}
5. 代理模式 (Proxy)

设计思路

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

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

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

完整代码实现

java 复制代码 
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 {
    @Override
    public void meathod() { 
        System.out.println("活都是我干的"); 
    }
}

// 3.代理类
class ProxyImpl extends AbstractProxy {
    ConcreteImpl ci; // 核心：持有具体实现对象

    @Override
    public void meathod() {
        if (ci == null) {
            ci = new ConcreteImpl();
        }
        System.out.println("我把接口封装了");
        ci.meathod(); // 委托给具体实现
    }
}
6. 单例模式 (Singleton)

设计思路

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

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

  • volatile防止指令重排序

完整代码实现

java 复制代码 
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）

完整代码实现

java 复制代码 
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 {
        @Override
        public void useStrategy() { 
            System.out.println("策略1"); 
        }
    }
    
    static class strategy2 implements abstractStrategy {
        @Override
        public 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方法固定流程，防止子类修改

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

完整代码实现

java 复制代码 
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 {
    @Override
    void step1() { 
        System.out.println("自己的step1"); 
    }
    
    @Override
    void step2() { 
        System.out.println("自己的step2"); 
    }
    
    @Override
    void step3() { 
        System.out.println("不用默认step3,我要自己实现"); 
    }
}
相关推荐
使一颗心免于哀伤44 分钟前
《设计模式之禅》笔记摘录 - 10.装饰模式
笔记·设计模式
IT小白架构师之路12 小时前
常用设计模式系列（九）—桥接模式
设计模式·桥接模式
CHEN5_0216 小时前
设计模式——责任链模式
java·设计模式·责任链模式
前端拿破轮17 小时前
平衡二叉树的判断——怎么在O(n)的时间复杂度内实现？
前端·算法·设计模式
牛奶咖啡1318 小时前
学习设计模式《十九》——享元模式
学习·设计模式·享元模式·认识享元模式·享元模式的优缺点·何时选用享元模式·享元模式的使用示例
讨厌吃蛋黄酥18 小时前
🌟 弹窗单例模式：防止手抖党毁灭用户体验的终极方案！
前端·javascript·设计模式
前端拿破轮20 小时前
二叉树的最小深度——和最大深度一样的逻辑？
算法·设计模式·面试
未既1 天前
java设计模式 -【策略模式】
java·设计模式·策略模式
未既1 天前
java设计模式 -【装饰器模式】
java·设计模式·装饰器模式
Amagi.1 天前
Java设计模式-适配器模式
java·设计模式·适配器模式
热门推荐
01Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code02全球最强模型Grok4，国内已可免费使用！（附教程）03vue数据变化但页面不变04【2025.7.18】更新vscode后所有.vue文件template标签后报红的临时解决办法，Vue - Official 插件3.0.2导致05KGG转MP3工具|非KGM文件|解密音频06这次领先Cursor！体验了Trae 2.0 SOLO 模式，超酷！07Cursor Claude 模型无法使用的解决方法08Claude Code用不了？来试下Qwen3-Coder加持的Qwen Code吧09ChatGPT Agent 完全使用指南：2025年7月最新功能详解10《魔兽世界》提示lua警告的含义及解决方法