设计模式代码总结

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 {
    @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 实现部件创建

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

流程图

完整代码实现

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)

设计思路

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

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

• 支持多层嵌套装饰

流程图

完整代码实现

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）状态变化时自动通知观察者

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

• 适用于事件驱动系统

流程图

完整代码实现

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)

设计思路

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

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

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

完整代码实现

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防止指令重排序

完整代码实现

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 {
        @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方法固定流程，防止子类修改

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

完整代码实现

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,我要自己实现"); 
    }
}