JAVA基础篇--设计模式

模式1：单例模式（Singleton）
为什么需要使用Singleton:单态模式是保证一个类有且仅有一个对象实例。
单态模式经常使用在控制资源的访问上。例如配置文件管理类、数据工具类或Socket连接等。单态模式可以控制在某个时刻只有一个线程访问资源。

public  class SingletonOne {
    private static SingletonOne instance=new SingletonOne();
    // 构造方法私有化
    private SingletonOne(){}
    public static SingletonOne getInstance(){
        return instance;

    }

}

测试：

public class SingletonTest {
    public static void main(String[] args) {
        for (int i=0 ;i<10;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j=0;j<10;j++){

                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        SingletonOne singleton = SingletonOne.getInstance();
                        System.out.println(singleton.toString());

                    }
                }
            }).start();

        }

    }
}

模式2：简单工厂模式（Simple Factory Pattern）
简单工厂模式符合设计开闭原则的第一个原则，对扩展开发，但不符合第二个原则，如果再增加一个产品，则在工厂里增加相应的业务逻辑和判断逻辑。

public interface SimpleFactoryAB {
    public void drive();
}
class  SimpleFactoryA implements  SimpleFactoryAB{

    @Override
    public void drive() {
        System.out.println("my is A");
    }
}
class SimpleFactoryB implements  SimpleFactoryAB {

    @Override
    public void drive() {
        System.out.println("my is B");
    }
}
// 简单工厂模式 实现1
class FactoryAB{
    public  static SimpleFactoryAB createFactory(int i){
        switch (i){
            case 1:
                return new SimpleFactoryA();
            case 2:
                return new SimpleFactoryB();
            default:
                return null;
        }
    }
    public static void main(String[] args) {
        SimpleFactoryAB ab1 = FactoryAB.createFactory(1);
        ab1.drive();

        SimpleFactoryAB ab2 = FactoryAB.createFactory(2);
        ab2.drive();
    }
}
// 简单工厂模式 实现2
// 改进版，通过类的反射机制来实现
// 工厂方法模式(Abstract Factory Pattern)：当添加一个操作时，需要修改静态工厂方法不符合开闭原则（对扩展开放，对修改封闭)
class  ReflectFactoryAB{
    public  static SimpleFactoryAB createFactory(String calssName) throws ClassNotFoundException,
            IllegalAccessException, InstantiationException {
        Class c = Class.forName(calssName);
        SimpleFactoryAB ab = (SimpleFactoryAB)c.newInstance();
        return ab;
    }
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
        SimpleFactoryAB ab1 = ReflectFactoryAB.createFactory("org.lgx.bluegrass.bluegrasscoree.design.factory.SimpleFactoryA");
        ab1.drive();

        SimpleFactoryAB ab2 = ReflectFactoryAB.createFactory("org.lgx.bluegrass.bluegrasscoree.design.factory.SimpleFactoryB");
        ab2.drive();
    }
}

// 简单工厂模式 实现3:
// 把工厂里的静态工厂方法由不同的工厂子类来分担。
interface  CreateAbstractorFactory{
   public  SimpleFactoryAB createFactory();
}
class CreateAbstractorFactoryA implements CreateAbstractorFactory{

    @Override
    public SimpleFactoryAB createFactory() {
        return new SimpleFactoryA();
    }
}
class CreateAbstractorFactoryB implements CreateAbstractorFactory{

    @Override
    public SimpleFactoryAB createFactory() {
        return new SimpleFactoryB();
    }
}
class  TractorFactoryAB{
    public static void main(String[] args) {
        CreateAbstractorFactory factoryA = new CreateAbstractorFactoryA();
        SimpleFactoryAB a = factoryA.createFactory();
        a.drive();


        CreateAbstractorFactory factoryB = new CreateAbstractorFactoryB();
        SimpleFactoryAB b = factoryB.createFactory();
        b.drive();
    }
}

模式3：建造者模式
定义建造产品的步骤，然后一步步完成产品的制造。

// 最终的产品
@Data
class  Product{
    private String buildA;
    private String buildB;
    private String buildC;

    @Override
    public String toString() {
        return "Product 建造完成{" +
                "buildA='" + buildA + '\'' +
                ", buildB='" + buildB + '\'' +
                ", buildC='" + buildC + '\'' +
                '}';
    }
}
// 对象建造的部分
public interface Builder {
    public void buildPart1();

    public void  buildPart2();

    public void buildPart3();

    public Product getProduct();
}
// 具体的建筑方法
class CreateBuilder implements Builder{
    private  Product product ;

    public CreateBuilder(){
        product = new Product();
    }

    @Override
    public void buildPart1() {
        product.setBuildA("建造第一部分！");
    }

    @Override
    public void buildPart2() {
        product.setBuildB("建造第二部分！");
    }

    @Override
    public void buildPart3() {
        product.setBuildC("建造第三部分！");
    }

    @Override
    public Product getProduct() {
        // 返回建造结果
        return product;
    }
}
/**
 * 指挥者，知会建筑的过程
 */
class Director{
    // 定义建造的步骤
    public Product construct(Builder build){

        //
        build.buildPart1();

        build.buildPart2();

        build.buildPart3();

        return build.getProduct();
    }

}
class  Test{
    public static void main(String[] args) {
        Director director = new Director();
        Product product = director.construct(new CreateBuilder());
        System.out.println(product);
    }
}

模式3：适配器模式

public interface Socket {
    /**
     * 三孔插头
     */
    void threePlug();
}
class  Twoplug{
    public  void chagePlug(){
        System.out.println("适配器：转换成二插头");
    }
}
class AdapterClass extends  Twoplug implements  Socket{

    @Override
    public void threePlug() {
        this.chagePlug();
    }
}
class Adapter implements  Socket{
    private  Twoplug twoplug;
    public  Adapter( Twoplug twoplug) {
        this.twoplug = twoplug;
    }
    @Override
    public void threePlug() {
        twoplug.chagePlug();
    }
}
class Test {
    public static void main(String[] args) {
        // 类适配器
        AdapterClass adapterClass = new AdapterClass();
        adapterClass.threePlug();

        // 对象适配器
        Adapter adapter = new Adapter(new Twoplug());
        adapter.threePlug();
    }
}

模式5：桥接模式

// 桥
public interface Qiao {
    // 到达目的地
    void toTargetPlace();
}
// 目的地A
class TargetPalceA implements Qiao{

    @Override
    public void toTargetPlace() {
        System.out.println("到达目的地A");
    }
}
// 目的地B
class TargetPalceB implements Qiao{

    @Override
    public void toTargetPlace() {
        System.out.println("到达目的地B");
    }
}
// 架桥
abstract  class SourcePlace{
    public Qiao qiao;
    public  abstract  void fromPlace();
}
// 出发地
class SourcePlaceA extends SourcePlace{
    public SourcePlaceA (Qiao qiao) {
        this.qiao = qiao;
    }
    @Override
    public void fromPlace() {
        System.out.println("从出发地A出发");
    }
}
// 出发地
class SourcePlaceB extends SourcePlace{
    public SourcePlaceB (Qiao qiao) {
        this.qiao = qiao;
    }
    @Override
    public void fromPlace() {
        System.out.println("从出发地B出发");
    }
}
class  Test {
    public static void main(String[] args) {
        SourcePlaceA sourcePlaceA = new SourcePlaceA(new TargetPalceA());
        sourcePlaceA.fromPlace();
        sourcePlaceA.qiao.toTargetPlace();

        SourcePlaceB sourcePlaceB = new SourcePlaceB(new TargetPalceB());
        sourcePlaceB.fromPlace();
        sourcePlaceB.qiao.toTargetPlace();
    }
}

模式6：组合模式：多个对象可以组合在一起

import java.util.ArrayList;
import java.util.List;

/**
 * 组合模式1
 * @Description TODO
 * @Date 2022/1/24 15:48
 * @Author lgx
 * @Version 1.0
 */
public interface Combination {
  void printStruct(String preStr);
}
// 叶子节点
class Leaf implements  Combination{
    private String name;

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

    @Override
    public void printStruct(String preStr) {
        System.out.println(preStr + "-" + name);
    }
}
// 树枝节点
class Branch implements  Combination{
    private String name;
    private List<Combination> childComponents = new ArrayList<>();

    public Branch(String name) {
        this.name = name;
    }
    public void addChild (Combination child) {
        this.childComponents.add(child);
    }

    /**
     * 树枝下的所有叶子节点
     * @param preStr
     */
    @Override
    public void printStruct(String preStr) {
        //首先输出自身
        System.out.println(preStr + '+' + this.name);

        //如果还包含有子组件，那么就输出这些子组件对象
        if (this.childComponents != null) {
            //添加前缀空格，表示向后缩进
            preStr += "  ";

            //循环递归输出每个子对象
            for (Combination component : childComponents) {
                component.printStruct(preStr);
            }
        }
    }
}
class  Test{
    public static void main(String[] args) {
        Branch root = new Branch("服装");
        Branch c1 = new Branch("男装");
        Branch c2 = new Branch("女装");

        Leaf leaf1 = new Leaf("衬衫");
        Leaf leaf2 = new Leaf("夹克");
        Leaf leaf3 = new Leaf("裙子");
        Leaf leaf4 = new Leaf("套装");

        root.addChild(c1);
        root.addChild(c2);
        c1.addChild(leaf1);
        c1.addChild(leaf2);
        c2.addChild(leaf3);
        c2.addChild(leaf4);

        root.printStruct("");
    }
}

模式7：允许向一个现有的对象添加新的功能，同时又不改变其结构

public interface Milk {
    //返回奶茶描述
     String getDescription();
    //返回价格
     double getPrice();
}
class  ChocolateMT  implements Milk{

    @Override
    public String getDescription() {
        return "点了一杯巧克力奶茶";
    }

    @Override
    public double getPrice() {
        System.out.println("原价格:15,现在价格："+15);
        return 15;
    }
}
class QQMT  implements  Milk{

    @Override
    public String getDescription() {
        return "点了一杯qq奶茶";
    }

    @Override
    public double getPrice() {
        return 20;
    }
}

/**
 * 装饰器
 */
class  Decorator implements  Milk{
    private String description = "我只是装饰器，不知道是哪种奶茶";
    @Override
    public String getDescription() {
        return null;
    }

    @Override
    public double getPrice() {
        return 0;
    }
}
class  Coconut extends Decorator {
    private static String description = "加了椰果！";
    private Milk milk;

    public  Coconut (Milk milk){
        this.milk = milk;
    }
    @Override
    public String getDescription(){
        return milk.getDescription()+"\n"+description;
    }
    @Override
    public double getPrice(){
        // System.out.println("加了椰果:3,现在价格："+(milk.getPrice()+3));
        return milk.getPrice()+3;    //3表示椰果的价格
    }

}
class Pudding extends Decorator{
    private String description = "加了布丁！";
    private Milk milkTea = null;

    public Pudding(Milk milkTea){
        this.milkTea = milkTea;
    }
    @Override
    public String getDescription(){
        return milkTea.getDescription()+"\n"+description;
    }
    @Override
    public double getPrice(){
        // System.out.println("加了布丁:5,现在价格："+( milkTea.getPrice()+5));
        return milkTea.getPrice()+5;    //5表示布丁的价格
    }
}
class  Test{
    public static void main(String[] args) {
        Milk milkTea = new ChocolateMT();    //选择了巧克力奶茶
        milkTea = new Pudding(milkTea);     //为巧克力奶茶添加布丁
        milkTea = new Coconut(milkTea);     //为巧克力奶茶添加椰果
        // System.out.println(milkTea.getDescription()+"\n加了布丁和椰果的巧克力奶茶价格："+milkTea.getPrice());
        System.out.println("加了布丁和椰果的巧克力奶茶价格："+milkTea.getPrice());

    }
}

模式8：门面模式

public interface Good {
    public void buy();
}
class Clothing implements Good{

    @Override
    public void buy() {
        System.out.println("买衣服");
    }
}
class Shoe implements  Good{

    @Override
    public void buy() {
        System.out.println("买鞋子");
    }
}
class FacadeShop{
    void buyClothing(){
        Clothing clothing = new Clothing();
        clothing.buy();
    }
    void buyShoe(){
        Shoe shoe = new Shoe();
        shoe.buy();
    }
}
class  Test {
    public static void main(String[] args) {
        FacadeShop shop = new FacadeShop();
        shop.buyClothing();
        shop.buyShoe();
    }
}

模式9：代理模式

public interface RailwayStationInterface {
    void buyTrip();
}
class  RailwayStation implements  RailwayStationInterface{

    @Override
    public void buyTrip() {
        System.out.println("买票");
    }
}
class Scalpers implements  RailwayStationInterface {
    private RailwayStation railwayStation;

    public Scalpers (RailwayStation railwayStation){
        this.railwayStation = railwayStation;
    }
    @Override
    public void buyTrip() {
        System.out.println("begin");
        railwayStation.buyTrip();
        System.out.println("end");
    }
}
class MyInvocatioHandler implements InvocationHandler {
    private Object target;

    public MyInvocatioHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("-----before-----");
        Object result = method.invoke(target, args);
        System.out.println("-----end-----");
        return result;
    }

    // 生成代理对象
    public Object getProxy() {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        return Proxy.newProxyInstance(loader, interfaces, this);
    }
}
class  Test{
    public static void main(String[] args) {
        // 静态代理
        RailwayStation railwayStation = new RailwayStation();
        Scalpers scalpers = new Scalpers(railwayStation);
        scalpers.buyTrip();
        // 动态代理
        RailwayStationInterface railwayStationInterface = new RailwayStation();
        MyInvocatioHandler handler = new MyInvocatioHandler(railwayStationInterface);
        RailwayStationInterface serviceProxy = (RailwayStationInterface)handler.getProxy();
        serviceProxy.buyTrip();
    }
}

模式10：享元模式: 根据某个标识先判断改对象是否存在，如果存在不创建，直接返回；没有创建新的并返回

public interface FlyWeight {
    void operator();
}
class  FlyWeightImpl implements  FlyWeight{
    private String str;

    public FlyWeightImpl(String str){
        this.str = str;
    }

    @Override
    public void operator() {
        System.out.println("create str:"+str);
    }
}
class  FlyWeightFactory {
    private static Map<String,FlyWeight> map = new HashMap<>();

    public static FlyWeight getFlyWeight(String str){
        FlyWeight flyWeight = map.get(str);
        if (null  == flyWeight){
            flyWeight = new FlyWeightImpl(str);
            map.put(str,flyWeight);
        }
        return flyWeight;
    }
}
class Test{
    public static void main(String[] args) {
        FlyWeight flyWeight1 = FlyWeightFactory.getFlyWeight("苹果");
        FlyWeight flyWeight2 = FlyWeightFactory.getFlyWeight("梨");
        FlyWeight flyWeight3 = FlyWeightFactory.getFlyWeight("香蕉");
        FlyWeight flyWeight4= FlyWeightFactory.getFlyWeight("苹果");
        flyWeight1.operator();
        flyWeight2.operator();
        flyWeight3.operator();
        flyWeight4.operator();
        // 在Java中，如果是基本数据类型，则 == 比较的是值；如果是对象类型，则 == 比较的是对象的地址
        System.out.println("flyWeight1 == flyWeight4 = " + (flyWeight1 == flyWeight4));
    }
}

模式11：责任链
责任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下个的引用而连接起来形成一条链式结构。 请求在这个链上传递，直到链上的某一个对象有权处理该请求。请求的客户端不知道链上的哪个对象处理该请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任对象

public abstract class Handler {
    private Handler nextHadler;

    public void setNextHadler(Handler nextHadler) {
        this.nextHadler = nextHadler;
    }
    public Handler getNextHadler(){
        return this.nextHadler;
    }
    public abstract void handleLeaveDay (String user,Integer day);
}
/**
 * 项目经理审批
 */
class ProjectManger extends Handler{

    @Override
    public void handleLeaveDay(String user, Integer day) {
        if (day <= 3){
            System.out.println("项目经理审批：同意【"+user+"】,请假【"+day+"】天");
        } else {
            System.out.println("项目经理无权审批");
            if (getNextHadler() != null){
                getNextHadler().handleLeaveDay(user,day);
            }
        }
    }
}
/**
 * 部门经理审批
 */
class DeptManger extends Handler{
    @Override
    public void handleLeaveDay(String user, Integer day) {
        if (day > 3 && day <= 5){
            System.out.println("部门经理审批：同意【"+user+"】,请假【"+day+"】天");
        } else {
            System.out.println("部门经理无权审批");
            if (getNextHadler() != null){
                getNextHadler().handleLeaveDay(user,day);
            }
        }
    }
}
/**
 * CEO审批
 */
class CeoManger extends Handler{
    @Override
    public void handleLeaveDay(String user, Integer day) {
        if (day > 5){
            System.out.println("CEO审批：同意【"+user+"】,请假【"+day+"】天");
        } else {
            if (getNextHadler() != null){
                getNextHadler().handleLeaveDay(user,day);
            }
        }
    }
}
class  Test{
    public static void main(String[] args) {
        Handler Handler = new ProjectManger();

        Handler HandlerDept = new DeptManger();
        Handler.setNextHadler(HandlerDept);

        Handler HandlerCeo = new CeoManger();
        HandlerDept.setNextHadler(HandlerCeo);
        /**
         * 项目经理审批：同意【张三】,请假【3】天
         * 项目经理无权审批
         * 部门经理审批：同意【张三】,请假【4】天
         * 项目经理无权审批
         * 部门经理审批：同意【张三】,请假【5】天
         */
        Handler.handleLeaveDay("张三",3);
        Handler.handleLeaveDay("张三",4);
        Handler.handleLeaveDay("张三",5);
    }
}

模式12：解释器模式

public abstract class Expression {
    /**
     * 以环境为准，本方法解释给定的任何一个表达式
     *
     * @param ctx
     * @return
     */
    public abstract boolean interpret(Context ctx);

    /**
     * 校验两个表达式在结构上是否相同
     */
    @Override
    public abstract boolean equals(Object obj);

    /**
     * 返回表达式的hashCode
     */
    @Override
    public abstract int hashCode();

    /**
     * 将表达式转换成字符串
     */
    @Override
    public abstract String toString();
}

class Constant extends Expression {
    private boolean value;

    public Constant(boolean value) {
        this.value = value;
    }

    @Override
    public boolean interpret(Context ctx) {
        return value;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj != null && obj instanceof Constant) {
            return this.value == ((Constant) obj).value;
        }
        return false;
    }

    @Override
    public int hashCode() {
        return this.toString().hashCode();
    }

    @Override
    public String toString() {
        return new Boolean(value).toString();
    }
}

class Context {
    private Map<Variable, Boolean> map = new HashMap<>();

    public void assign(Variable var, boolean value) {
        map.put(var, new Boolean(value));
    }

    public boolean lookup(Variable var) throws IllegalArgumentException {
        Boolean value = map.get(var);
        if (value == null) {
            throw new IllegalArgumentException();
        }
        return value.booleanValue();
    }
}

class Variable extends Expression {
    private String name;

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

    @Override
    public boolean interpret(Context ctx) {
        return ctx.lookup(this);
    }

    @Override
    public boolean equals(Object obj) {
        if (obj != null && obj instanceof Variable) {
            return this.name.equals(((Variable) obj).name);
        }
        return false;
    }

    @Override
    public int hashCode() {
        return this.toString().hashCode();
    }

    @Override
    public String toString() {
        return this.name;
    }
}

class Test {
    public static void main(String[] args) {
        Context context = new Context();
        Variable xVariable = new Variable("X");
        Variable yVariable = new Variable("Y");
        Constant constant = new Constant(true);
        context.assign(xVariable, false);
        context.assign(yVariable, true);

        System.out.println("X = " + xVariable.interpret(context));
        System.out.println("Y = " + yVariable.interpret(context));
    }
}

模式13：状态模式
封装了转换规则。缺点：状态类之间的耦合性比较强

public class Context {
    private State state;

    public void process(int month) {
        state.handle(month, this);
    }

    public void setState(State state) {
        this.state = state;
    }
}

interface State {
    void handle(int month, Context ctx);
}

class Spring implements State {

    @Override
    public void handle(int month, Context ctx) {
        System.out.println("Spring: Green");
        if (month >= SeasonDefine.SUMMER_BEGIN_MONTH - 1) {
            System.out.println("Change State: Spring -> Summer, Sweet Flower and SunShine");
            ctx.setState(new Summer());
        }
    }
}

class Summer implements State {
    @Override
    public void handle(int month, Context ctx) {
        System.out.println("Summer: Red");
        if (month >= SeasonDefine.AUTUMN_BEGIN_MONTH - 1) {
            System.out.println("Change State: Summer -> Autumn, Bright Colors");
            ctx.setState(new Autumn());
        }
    }
}

class Autumn implements State {
    @Override
    public void handle(int month, Context ctx) {
        System.out.println("autumn, yellow");
        if (month >= SeasonDefine.WINNER_BEGIN_MONTH - 1) {
            System.out.println("Change State: Autumn -> Winner, magic snow world");
            ctx.setState(new Winner());
        }
    }
}

class Winner implements State {
    @Override
    public void handle(int month, Context ctx) {
        System.out.println("Winner, White");
        if (month >= SeasonDefine.WINNER_OVER_MONTH) {
            System.out.println("Change State: Winnder -> Spring, Happy New Year");
            ctx.setState(new Spring());
        }
    }
}

class SeasonDefine {
    public static final int SPRING_BEGIN_MONTH = 1;
    public static final int SUMMER_BEGIN_MONTH = 4;
    public static final int AUTUMN_BEGIN_MONTH = 7;
    public static final int WINNER_BEGIN_MONTH = 10;
    public static final int WINNER_OVER_MONTH = 12;
}

class StatePatternDemo {
    public static void main(String[] args) {
        Context ctx = new Context();
        ctx.setState(new Spring());
        for (int month = 1; month <= 12; month++) {
            System.out.println("month : " + month);
            ctx.process(month);
        }
    }
}

模式14：观察者模式

// 观察者的操作
public interface ObserverAction {
    //注册观察者
    void registerObserver(MyOberver o);

    //移除观察者
    void removeObserver(MyOberver o);

    //通知观察者
    void notifyObservers();
}

// 观察者的动作
interface MyOberver {
    //取奶
    void getMilk();

    // 放盛放奶的瓶子
    void putMilkBottle();
}

class ByObserver implements ObserverAction {
    //创建一个集合，管理观察者
    private List<MyOberver> observers = new ArrayList<>();
    private Integer state;

    public void setState(Integer state) {
        this.state = state;
        // 状态流转
        notifyObservers();
    }

    @Override
    public void registerObserver(MyOberver o) {
        //每注册一个观察者，将他加入观察者集合中
        observers.add(o);
    }

    @Override
    public void removeObserver(MyOberver o) {
        //获得观察者在集合中的索引，并移除
        int i = observers.indexOf(o);
        if (i >= 0) {
            observers.remove(i);
        }
    }

    @Override
    public void notifyObservers() {
        //遍历集合中的观察者，并通知他们取奶
        for (int i = 0; i < observers.size(); i++) {
            MyOberver oberver = observers.get(i);
            if (1 == state) {
                oberver.getMilk();
            } else if (2 == state) {
                oberver.putMilkBottle();
            }

        }
    }
}

// 观察者
class Observer implements MyOberver {
    private ObserverAction milkStuff;
    private String name;

    public Observer(ObserverAction milkStuff, String name) {
        this.milkStuff = milkStuff;
        //在构造方法中将当前对象注册当观察者集合中
        milkStuff.registerObserver(this);
        this.name = name;
    }

    @Override
    public void getMilk() {
        System.out.println("我是" + name + ",马上来取奶...");
    }

    @Override
    public void putMilkBottle() {
        System.out.println("我是" + name + ",送来取瓶子...");
    }
}

class Test {
    public static void main(String[] args) {
        ByObserver milkStuff = new ByObserver();
        MyOberver zs = new Observer(milkStuff, "张三");
        MyOberver ls = new Observer(milkStuff, "李四");
        MyOberver ww = new Observer(milkStuff, "王五");
        MyOberver ml = new Observer(milkStuff, "某六");
        milkStuff.setState(1);
        milkStuff.setState(2);
    }
}

模式15：备忘录模式
复制出来一个新的对象，方便后续对之前对象进行回复

@Data
public class Memento {
    /**
     * 需要备份的相关数据
     */
    private String state1;
    private String state2;

    /**
     * 创建备忘录时将相关数据导入
     * @param state1
     * @param state2
     */
    public Memento(String state1, String state2) {
        this.state1 = state1;
        this.state2 = state2;
    }
}
/**
 * 发起人类
 */
@Data
class Originator {
    //需要保存的属性
    private String state1;
    private String state2;

    /**
     * 创建备忘录，将当前需要保存的数据导入并创建一个备忘录对象
     * @return
     */
    public Memento createMemento(){
        return new Memento(state1, state2);
    }
    /**
     * 恢复数据，将备忘录导入并回复数据
     * @param memento
     */
    public void resetMemento(Memento memento){
        this.state1 = memento.getState1();
        this.state2 = memento.getState2();
    }
    public void show(){
        System.out.println("state1:" + state1);
        System.out.println("state2:" + state2);
    }
}

/**
 * 管理者，管理备忘录
 */
class Caretaker {
    private Memento memento;

    public Memento getMemento() {
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}
class  Test{
    public static void main(String[] args) {
        //创建一个发起人
        Originator originator = new Originator();
        originator.setState1("mjp");
        originator.setState2("rtt");
        originator.show();

        //创建一个管理者
        Caretaker caretaker = new Caretaker();
        caretaker.setMemento(originator.createMemento());

        //状态改变
        System.out.println("---状态改变---");
        originator.setState1("马俊鹏");
        originator.setState2("任婷婷");
        originator.show();
        //状态恢复
        System.out.println("---状态恢复---");
        originator.resetMemento(caretaker.getMemento());
        originator.show();
    }
}

模式16：调停者模式
类与类之间不直接进行交互，交由一个中间者的角色完成最终的调度

public interface Mediator {
    void change(String message, ZhiYuan zhiyuan, String nname);
}

/**
 * 职员接口
 */
abstract class ZhiYuan {
    String name;
    private Mediator mediator;

    public ZhiYuan(Mediator mediator, String name) {
        this.mediator = mediator;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    //被调停者调用的方法
    public void called(String message, String nname) {
        System.out.println(name + "接收到来自" + nname + "的需求：" + message);
    }

    //调用调停者
    public void call(String message, ZhiYuan zhiyuan, String nname) {
        System.out.println(nname + "发起需求：" + message);
        mediator.change(message, zhiyuan, nname);
    }
}

/**
 * 调停者：经理
 */
class Jingli implements Mediator {
    @Override
    public void change(String message, ZhiYuan zhiyuan, String nname) {
        System.out.println("经理收到" + nname + "的需求：" + message);
        System.out.println("经理将" + nname + "的需求发送给目标职员:" + zhiyuan.getName());
        zhiyuan.called(message, nname);
    }
}

/**
 * 职员A
 */
class ZhiyuanA extends ZhiYuan {
    public ZhiyuanA(Mediator mediator, String name) {
        super(mediator, name);
    }

    @Override
    public void called(String message, String nname) {
        System.out.println("职员A处理需求");
    }
}

/**
 * 职员B
 */
class ZhiyuanB extends ZhiYuan {
    public ZhiyuanB(Mediator mediator, String name) {
        super(mediator, name);
    }

    @Override
    public void called(String message, String nname) {
        System.out.println("职员B处理需求");
    }
}

class Test {
    public static void main(String[] args) {
        //分配职员与经理
        Mediator jingli = new Jingli();
        ZhiYuan zhiyuanA = new ZhiyuanA(jingli, "职员A");
        ZhiYuan zhiyuanB = new ZhiyuanB(jingli, "职员B");
        //职员A的需求
        String messageA = "这些资料需要B职员操作";
        zhiyuanA.call(messageA, zhiyuanB, zhiyuanA.name);

    }
}

模式16：命令模式
将命令组合串行执行

public abstract class  Command {
    abstract void execute() ;
}

class  NormalFontCommand  extends   Command{
    private Font font;
    private Integer param;

    public  NormalFontCommand(Font font,Integer param ){
        this.font = font;
        this.param = param;
    }

    @Override
    @SneakyThrows
    public void execute()  {
        System.out.println("设置字体大小 = " + param);
        font.setFontSize(param);
    }
}
@Data
class  Font {
    private Integer fontSize;

}
class BackGroundCommand extends  Command{
    private BackGround backGround;
    private String param;
    public  BackGroundCommand(BackGround backGround,String param){
        this.backGround = backGround;
        this.param = param;
    }
    @Override
    @SneakyThrows
    public void execute() {
        System.out.println("设置背景色 = " + param);
        backGround.setBackGround(param);
    }
}
@Data
class  BackGround {
    private String backGround;
}
@Data
class  CommandExcutes {
    private List<Command> commands = new ArrayList<>();

    public  void doExcute(){
        for (Command command : commands) {
            command.execute();
        }
    }
}
class Test{
    public static void main(String[] args) {
        CommandExcutes commandExcutes = new CommandExcutes();
        Command command1 = new NormalFontCommand(new Font(),100);
        commandExcutes.getCommands().add(command1);

        Command command2 = new BackGroundCommand(new BackGround(),"black");
        commandExcutes.getCommands().add(command2);

        commandExcutes.doExcute();
    }
}