# 设计模式

Posted 2021-06-26 MarlonBrando1998

---

• 图来自百度：
  

单例模式

• 见博客：https://blog.csdn.net/qq_37248504/article/details/107500139

工厂模式

• 见博客：https://blog.csdn.net/qq_37248504/article/details/107500139

代理模式

• 见博客：https://blog.csdn.net/qq_37248504/article/details/115312401

适配器模式

• 见博客：https://blog.csdn.net/qq_37248504/article/details/110728398

---

观察者模式

简单理解

• 观察者模式是一种行为性模式，定义对象之间的一对多的依赖关系，当一个对象状态改变时候依赖于它的对象的状态会相应的更新。

使用场景

• 关联行为场景，关联行为是可拆分的，事件多级触发。
• 消息队列、时间总线处理机制。

实例代码

• 接口定义观察者共同的方法

  public interface Observer {
  
      void update(int state);
  }
  

• 定义具体的观察者

public class ObserverImpl implements Observer {

    private static final Logger logger = LoggerFactory.getLogger(ObserverImpl.class);

    // 具体观察者的属性
    private int myState;

    @Override
    public void update(int state) {
        myState = state;
        logger.info("收到消息,myState:{}", myState);
    }

    public int getMyState() {
        return myState;
    }
}

• 定义主题

public class Subject {

    private static final Logger logger = LoggerFactory.getLogger(Subject.class);

    // 定义观察者的集合 使用vector 线程安全
    private Vector<Observer> list = new Vector<>();

    /**
     * 注册观察者
     *
     * @param observer
     */
    public void registerObserver(Observer observer) {
        list.add(observer);
    }

    /**
     * 删除观察者方法
     *
     * @param observer
     */
    public void removeObserver(Observer observer) {
        list.remove(observer);
    }

    /**
     * 通知所有的观察者更新
     *
     * @param state
     */
    public void notifyAllObserver(int state) {
        for (Observer observer : list) {
            observer.update(state);
        }
    }
}

• 定义继承主题的具体观察者

public class RealObserver extends Subject {

    // 被观察对象的属性
    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        //主题对象值发生改变
        this.notifyAllObserver(state);
    }
}

• 测试代码

public class ObserverTest {

    private static final Logger logger = LoggerFactory.getLogger(ObserverTest.class);

    @Test
    public void test() {
        // 目标对象
        RealObserver realObserver = new RealObserver();

        // 创建多个观察者
        ObserverImpl observerOne = new ObserverImpl();
        ObserverImpl observerTwo = new ObserverImpl();
        ObserverImpl observerThree = new ObserverImpl();

        // 注册到观察者 vector中
        realObserver.registerObserver(observerOne);
        realObserver.registerObserver(observerTwo);
        realObserver.registerObserver(observerThree);

        // 改变目标对象的状态
        realObserver.setState(200);
        logger.info("observerOne 的state:{}", observerOne.getMyState());
        logger.info("observerTwo 的state:{}", observerTwo.getMyState());
        logger.info("observerThree 的state:{}", observerThree.getMyState());
    }
}

---

策略模式

简单理解

• 在接口中定义方法，不同的实现类在重写的方法中做出不同的操作。

使用场景

• 当符合场景时候可以替换if、else

实例代码

public interface CaculateData {
	// 计算
    int caculate(int num1,int num2);
}

public class CaculateAdd implements CaculateData {

    @Override
    public int caculate(int num1, int num2) {
        return num1 + num2;
    }

}

public class CaculateSub implements CaculateData {

    @Override
    public int caculate(int num1, int num2) {
        return num1 - num2;
    }

}

---

模板方法模式

简单理解

• 使用继承关系：父类中定义相关的一系列行为，不同的子类通过继承抽象父类，在重写的方法中，不同的子类实现不同的业务逻辑。

实例代码

• 抽象父类

public abstract class AbstractCookMeal {

    // 去市场
    abstract void moveToMarket();

    // 购买蔬菜
    abstract void buyVegetables();

    // 回家
    abstract void goHome();

    // 做饭
    abstract void cookMeal();


    public void doCooking(){
        moveToMarket();
        buyVegetables();
        goHome();
        cookMeal();
    }
    
}

• 子类

public class PeopOneCookMeal extends AbstractCookMeal {

    private static final Logger logger = LoggerFactory.getLogger(PeopOneCookMeal.class);

    private String name;

    public PeopOneCookMeal(String name) {
        this.name = name;
    }

    @Override
    void moveToMarket() {
        logger.info(this.name + "去超市！");
    }

    @Override
    void buyVegetables() {
        logger.info(this.name + "买蔬菜！");
    }

    @Override
    void goHome() {
        logger.info(this.name + "回家！");
    }

    @Override
    void cookMeal() {
        logger.info(this.name + "做饭！");
    }
}

• 测试

/**
  * 模板模式
  * <p>
  * 使用继承关系：父类中定义相关的一系列行为，不同的子类通过继承抽象父类实现不同的行为
  */
@Test
public void test() {
    PeopOneCookMeal oneCookMeal = new PeopOneCookMeal("张三");
    oneCookMeal.doCooking();
}