设计模式

GOF<设计模式>对设计模式的分类如下图：

创建型模式

　　创建型模式主要用来创建对象，可以理解为对象的工厂，这种设计模式主要是为了方便后续对象的创建和使用。

结构型模式

　　将类和对象以一种关系结构的形式组合在一起，这种关系结构可以形象的理解为日常见到的事物关系。比如代理模式：两个对象之间存在的代理关系和艺人和经纪人之间的代理关系一样。结构型模式主要是从现实的结构中获取优点构建代码中同样的结构。

行为型模式

　　行为型模式可以理解为现实世界中的一种优秀行为模式的借鉴。比如观察者模式：我们对一件事情感兴趣，可以告诉这件事情的负责人，让他告诉这件事情的最新消息。

类模式和对象模式

　　这个就好理解。类模式就是处理类之间的关系的模式，对象模式就是处理对象之间的关系。

设计模式六大原则：

其中最重要的是开闭原则（open close Principle）：这是基础（开闭原则指的是对扩展开放，对修改关闭）。在程序需要扩展的时候不能去修改原本类，而是要扩展原有的代码，实现这一功能，就要可扩展的的实现由子类自己去实现，而定义抽象类去实现公共功能，避免重复的造轮子，所以这一步很重要。这样不同的子类可以实现不同的功能，且不影响原本的程序代码。在开闭原则之上又延申出下面六个原则。

1. 单一职责原则：这样做的好处是类之间的结构界限清晰，方便后续扩展，且方便开发。

2. 里氏替换原则（Liskov Substitution Principle  LSP）：任何子类可以出现的地方，基类也可以出现。里氏替换原则是对开闭原则的补充，实现开闭原则的关键步骤是抽象化，可以说里氏替换原则是对开闭原则中抽象化步骤的另一种形式的描述。历史替换原则中，子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它。

3. 依赖倒转原则（Dependence Inversion Principle）:开闭原则的基础，依赖接口不依赖实现类，所以依赖的应该是子类但是实际上依赖的是抽象接口。

4. 接口隔离原则（Interfaces Segregation Principle）：一个接口一个功能，否则另起一个接口。

5. 迪米特法则（最少知道原则 Demeter Principle）：调用者和被调用者之间最好是只存在调用关系，不存在逻辑交互关系，这样被调用者变化时才能最小的影响调用者。

6. 合称复用原则（Composite Reuse Principle）：优先使用持有依赖的方式组合对象关系，而不是继承这个对象的能力来组合对象关系。

*************************创建型模式

工厂方法模式：

　　工厂就是制造东西的地方，在Java中引申为创造对象的工具类，设计模式中的工厂方法模式基于设计模式原则-上述来进行设计。具体内容就是设计一个工厂接口，根据需要实现不同的工厂类，实际开发中依赖的是接口而非子类。

package org.yang.get;

public interface interfaces {

    interface entity{
        String say();
    }

    class entity1 implements entity{

        @Override
        public String say() {
            return "im entity1";
        }
    }
    class entity2 implements entity{

        @Override
        public String say() {
            return "im entity2";
        }
    }

    interface factoryBean{
        entity getBean();
    }

    class factoryBean1 implements  factoryBean{

        @Override
        public entity getBean() {
            return new entity1();
        }
    }
    class factoryBean2 implements  factoryBean{

        @Override
        public entity getBean() {
            return new entity2();
        }
    }

    static void main(String[] args) {
        factoryBean factoryBean1 = new factoryBean1();
        entity entity1 = factoryBean1.getBean();
        System.out.println(entity1.say());
        factoryBean factoryBean2 = new factoryBean2();
        entity entity2 = factoryBean2.getBean();
        System.out.println(entity2.say());
    }
}

抽象工厂模式：

 　　抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

大致的思路是：

　　你是个开小卖铺的老板你开张了。首先把你要卖的商品种类ABCD制成招牌放在不同的四个货架上，ABCD下面又各有四种产品，比如A下面有A1A2A3A4四款产品，你会有个记账本S，S里面记录了这16种产品在货架上的具体存货量，采购员会和你每天都核对一遍库存，S里面有四页，分别叫abcd，a里面记录了A1A2A3A4四款产品的记录，找到a就可以得到A1A2A3A4这四款产品了，但首先你要找到S。

　　类比到抽象工厂模式中可以理解为：你就是一个对外开放的获得工厂的工具类，告诉你想核对什么商品，你可以快速的定位到S中的每一个具体的页并得到需要的信息；S就是抽象工厂；abcd就是具体的工厂类，A1A2A3A4就是四种具体的产品，ABCD是四种产品的分类；这三种信息都会在S中进行处理，最终得到产品的具体信息。

package org.yang.get;

public interface abstractFactoryDemo {
    interface A{
        String WHO();
    }

    class A1 implements  A{

        @Override
        public String WHO() {
            return "im a1";
        }
    }

    interface B{
        String WHO();
    }

    class B1 implements  B{

        @Override
        public String WHO() {
            return "im b1";
        }
    }

    abstract class abstractFactory{
        abstract A getA(String name);
        abstract B getB(String name);
    }

    class factoryA extends abstractFactory{

        @Override
        A getA(String name) {
            return name.equals("A1") ? new A1() : new A1();
        }

        @Override
        B getB(String name) {
            return null;
        }
    }

    class factoryB extends abstractFactory{

        @Override
        A getA(String name) {
            return null;
        }

        @Override
        B getB(String name) {
            return name.equals("B1") ? new B1() : new B1();
        }
    }

    class tools{
        abstractFactory get(String name){
            abstractFactory factory;
             switch (name){
                 case "A" : {
                     factory = new factoryA(); break;
                 }
                 case "B" :{
                     factory = new factoryB(); break;
                 }
                 default: {
                     factory = null; break;
                 }
             }
             return factory;
        }
    }

    public static void main(String[] args) {
        tools tools = new tools();
        abstractFactory Factory = tools.get("A");
        A a1 = Factory.getA("A1");
        System.out.println(a1.WHO());
    }
}

建造者模式：

　　创建者模式Builder Pattern，使用多个简单的对象一步一步构建成一个复杂的对象。这种模式属于创建型模式，它提供了一种创建对象的最佳方式。一个Builder类会一步一步构造最终的对象。该Buildler类是独立与其他对象的。

package org.yang.get;

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

public interface builderDemo {
    interface car{
        String name();
        String description();
    }

    abstract class truckCar implements car{
        @Override
        public String description() {
            return "this is a truckCar!";
        }
    }

    abstract class smallCar implements car{
        @Override
        public String description() {
            return "this is a smallCar!";
        }
    }

    class redTruckCar extends truckCar{
        @Override
        public String name() {
            return "my name is redTruckCar";
        }
    }

    class blueTruckCar extends truckCar{
        @Override
        public String name() {
            return "my name is blueTruckCar";
        }
    }

    class blackSmallCar extends smallCar{
        @Override
        public String name() {
            return "my name is blackSmallCar";
        }
    }

    class whiteSmallCar extends smallCar{
        @Override
        public String name() {
            return "my name is whiteSmallCar";
        }
    }

    class meal{
        private List<car> list = new ArrayList<>();

        void add(car car){
            list.add(car);
        }

        String showMe(){
            String CAR = "";
            for(car car : list){
                CAR = CAR + " " +car.name();
            }
            return CAR;
        }
    }

    class carBuilder{
        public meal meal1(){
            meal meal = new meal();
            meal.add(new redTruckCar());
            meal.add(new blackSmallCar());
            return meal;
        }

        public meal meal2(){
            meal meal = new meal();
            meal.add(new blackSmallCar());
            meal.add(new whiteSmallCar());
            meal.add(new redTruckCar());
            return meal;
        }
    }

    public static void main(String[] args) {
        carBuilder carBuilder = new carBuilder();
        meal meal = carBuilder.meal1();
        System.out.println(meal.showMe());
    }
}

　　从上面的例子可以看出，构造者模式就是将复杂的对象集合以一个构造类builder的形式对外展示，构造类是我们已经实现按照需求完成的工具类，这样我们只需要调用builder的一个方法就可以完成复杂的对象集合创建。

原型模式：

　　原型模式（Prototype Pattern），将消耗资源大的对象放入缓存中，使用的时候创建，后面获得的是缓存中的副本，避免重复创建，类似数据源。

package org.yang.get;

import java.util.HashMap;
import java.util.Map;

public interface PrototypeDemo {
    abstract class abstractDataSource{
        HashMap hashMap = new HashMap();
        String getOne(){
            return  (String)hashMap.get("0");
        }
        abstract String getName();
    }

    class druid extends abstractDataSource{

        @Override
        String getName() {
            return "druid";
        }
    }

    class c3p0 extends abstractDataSource{

        @Override
        String getName() {
            return "c3p0";
        }
    }

    class cacheUtil{
        static Map abstractDataSources = new HashMap();

        static void loadDataSources(){
            abstractDataSources.put("0",new druid());
            abstractDataSources.put("1",new c3p0());
        }

        static abstractDataSource get(String name){
            return  (abstractDataSource)abstractDataSources.get(name);
        }
    }

    public static void main(String[] args) {
        cacheUtil.loadDataSources();
        abstractDataSource dataSource = cacheUtil.get("0");
        System.out.println(dataSource.getName());
    }
}

单例模式：

　　单例模式是 Java 中最简单的设计模式之一，像下面这样：

public class singleton {

    private static singleton singleton = new singleton() ;
    public String message = "im a singleton Object";

    private singleton(){}
    
    public static singleton get(){
        return singleton;
    }
}

上面的属于饿汉式单例，因为没有加锁，且没有判断在多线程下会有问题，所以如果是多线程下的代码需要加上同步命令。

*********结构模式

适配器模式：

　　适配器模式是作为两个不兼容接口的桥梁存在的，这种设计模式属于结构型设计模式，它结合了两个独立接口的功能。这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。类似驱动。

package org.yang.get;

public interface adapterDemo {

    interface product{
        String name = null;
        String getName();
        String doWhat();
    }

    class car implements product{
        @Override
        public String getName() {
            return "im a car product";
        }

        @Override
        public String doWhat() {
            return "i can run";
        }
    }

    class aircraft implements product{

        @Override
        public String getName() {
            return "im a aircraft product";
        }

        @Override
        public String doWhat() {
            return "i can fly";
        }
    }

    interface Vehicle{
        String description();
        String go();
    }

    class VehicleAdapter implements Vehicle{
        product product ;

        VehicleAdapter(String type){
            switch (type){
                case "run": product = new car(); break;
                case "fly": product = new aircraft(); break;
            }
        }

        @Override
        public String description() {
            return product.getName();
        }

        @Override
        public String go() {
            return product.doWhat();
        }
    }

    /***
     * 外星人不会使用交通工具，提供一个适配器
     */
    class Alien implements Vehicle{

        VehicleAdapter VehicleAdapter;

        Alien(String type){
            VehicleAdapter = new VehicleAdapter("fly");
        }

        @Override
        public String description() {
            return VehicleAdapter.description();
        }

        @Override
        public String go() {
            return VehicleAdapter.go();
        }
    }
}

 桥接模式：

　　对于有几个变化的维度，一般不会使用继承的形式实现而是通过不同类的组合的形式，这样除了减少系统中的类个数，也利于系统扩展。这种形式称之为桥接模式。

package org.yang.get;

/***
 * 桥接模式
 */
public interface bridging {
    abstract class team{
        String message = null;
        abstract void set(String message);
    }

   abstract class boss{
        team team;

        void setTeam(team team){
            this.team = team;
        }

        abstract String speak();
    }

    class bigBoss extends boss{

        @Override
        String speak() {
            return "i am bigBoss and i have a team named " + team.message;
        }
    }

    class teamA extends team{

        @Override
        public void set(String message) {
            this.message = message;
        }
    }

    public static void main(String[] args) {
        boss boss = new bigBoss();
        team team = new teamA();
        team.set("teamA");
        boss.setTeam(team);
        System.out.println(boss.speak());
    }
}

这里不同变化的维度指的是不同的组合的可能，比如bossa和teama以及teamb可以组合为两种组合，如果一一列举太麻烦，可以使用桥接模式进行组合减少重复工作。

组合模式：

　　又叫部分整体模式，强调部分和整体的区别。

package org.yang.get;

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

/***
 * 组合模式
 */
public interface Composite {
    class Employee{
        private String name;
        private String salary;
        private List<Employee> list;

        Employee(String name,String salary){
            this.name = name;
            this.salary = salary;
            this.list = new ArrayList<>();
        }

        void setEmployee(Employee e){
            this.list.add(e);
        }

        void removeEmployee(Employee e){
            this.list.remove(e);
        }

        @Override
        public String toString() {
            return "Employee{" +
                    "name='" + name + '\'' +
                    ", salary='" + salary + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) {
        Employee CEO = new Employee("zs","2000000");
        Employee gl1 = new Employee("ww","200000");
        Employee gl2 = new Employee("ls","200000");
        Employee worker1 = new Employee("xm","20000");
        Employee worker2 = new Employee("za","20000");

        gl1.setEmployee(worker1);
        gl2.setEmployee(worker2);

        CEO.setEmployee(gl1);
        CEO.setEmployee(gl2);

        System.out.println(CEO.toString());
        System.out.println("-----");
        for(Employee e: CEO.list){
            System.out.println(e.toString());
            for(Employee ee : e.list){
                System.out.println(ee.toString());
            }
            System.out.println("****");
        }
    }
}

 装饰模式：

　　装饰模式就是将使用装饰类隐藏被装饰类。

package org.yang.get;

/***
 * 装饰模式
 */
public interface decorate {

    interface decoratePattern{
        String doSth();
    }

    class son implements decoratePattern{
        @Override
        public String doSth() {
            return "i want play";
        }
    }

    class decorator implements decoratePattern{
        decoratePattern decoratePattern;

        decorator(decoratePattern decoratePattern){
            this.decoratePattern = decoratePattern;
        }

        @Override
        public String doSth() {
            this.Enhance();
            return this.decoratePattern.doSth();
        }

        void Enhance(){
            System.out.println("extra do");
        }
    }

    public static void main(String[] args) {
        decorator decorator = new decorator(new son());
        System.out.println(decorator.doSth());
    }
}

外观模式：

　　Facade Pattern，隐藏系统的复杂内容，只展示客户需要的内容。　

package org.yang.get;


/***
 * 外观模式
 */
public interface Facade {
    
    class project{
        String message1;
        String message2;
        String message3;

        public void set(String message1,String message2,String message3){
            this.message1 = message1;
            this.message2 = message2;
            this.message3 = message3;
        }

        public String getMessage1() {
            return message1;
        }

        public String getMessage2() {
            return message2;
        }

        public String getMessage3() {
            return message3;
        }
    }

    class facade{
        private project project;
        facade(project project){
            this.project = project;
        }

        String getMessage(String name){
            if(name.equals("VP"))
                return this.project.message1;
            return project.message2;
        }
    }
}

享元模式：

　　享元模式有个很具体的例子就是常量池和数据库连接池，可重复利用的对象不需要重复构造，直接复用，这样达到节省资源的效果，这有个好的文章是讲享元模式的：https://www.cnblogs.com/adamjwh/p/9070107.html

package org.yang.get;

import java.util.HashMap;
import java.util.Map;

/***
 * 享元模式
 */
public interface FLYWEIGHT {
    interface Mode{
        String getMessage();
    }

    class PublicMode implements Mode{
        String message;
        PublicMode(String message){
            this.message = message;
        }

        @Override
        public String getMessage() {
            return this.message;
        }

        @Override
        public String toString() {
            return "PublicMode{" +
                    "message='" + message + '\'' +
                    '}';
        }
    }

    class factory{
        private Map pool = new HashMap();

        public Mode getMode(String key){
            Object o = this.pool.get(key);
            if(o!=null)
                return (Mode)o;
            Mode mode = new PublicMode(key);
            this.pool.put(key,mode);
            return mode;
        }
    }

    static void main(String[] args) {
        factory factory = new factory();
        Mode mode = factory.getMode("ap");
        System.out.println(mode.toString());
    }
}

代理模式：

　　Proxy Pattern，一个类代理了另一个类的功能，最常见到的介绍代理模式的就是艺人和经纪人的例子。例子很简单，但能说明问题。

package org.yang.get;

/***
 * 代理模式
 */
public interface proxy {

    interface proxyInterface{
        void play();
        void takeMoney();
    }

    class star implements proxyInterface{
        @Override
        public void play() {
            System.out.println("吼吼，苍茫的天涯是我的爱");
        }

        @Override
        public void takeMoney() {
            System.out.println("我要买兰博基尼");
        }
    }

    class Agent implements proxyInterface{
        
        private star star;
        
        Agent(star star){
            this.star = star;
        }
        
        @Override
        public void play() {
            this.star.play();
            System.out.println("演出结束");
        }

        @Override
        public void takeMoney() {
            this.star.takeMoney();
            System.out.println("我去买");
        }
    }
}

**********行为模式

解释器模式：

　　这种模式实现了一个表达式接口，该接口解释了一个特点的上下文。

package org.yang.get;

/***
 * 解释器模式
 */
public interface InterpreterDemo {
    interface Interpreter{
        String Interpreter(String messageExpression);
    }

    class terminalExpression implements Interpreter{

        private String message;

        terminalExpression(String message){
            this.message = message;
        }

        @Override
        public String Interpreter(String messageExpression) {
            return messageExpression!=null&&messageExpression.startsWith(message)?messageExpression+"end":null;
        }
    }
}

模板方法模式：

　　模板方法就比较常见了，就是抽象类定义骨架流程，子类实现具体的细节。

package org.yang.get;

/***
 * 模板方法模式
 */
public interface templateDemo {
    interface template{
        void method1();
        void method2();
        void method3();
    }

    /***
     * 模板
     */
    abstract class example implements template{
        
        boolean start(){
            this.method1();
            this.method2();
            this.method3();
            return true;
        }
    }

    /***
     * 具体的子类
     */
    class entity extends example{
        @Override
        public void method1() {
            System.out.println("my method1");
        }

        @Override
        public void method2() {
            System.out.println("my method1");
        }

        @Override
        public void method3() {
            System.out.println("my method1");
        }
    }
}

职责链模式：

　　顾名思义就是一个处理流链，在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推，知道找到处理这个请求的对象。

package org.yang.get;

/***
 * 责任链模式
 */
public interface ChainOfResponsibilityPattern {
    interface Chain{
        boolean deal(String message);
    }
    
    abstract class abstractChain implements Chain{
        protected Chain chain;
        abstract void setChain(Chain chain);
    }
    
    class chainTemplate extends abstractChain{
        @Override
        public boolean deal(String message) {
            if(message.startsWith("1"))
                return true;
            return this.chain.deal(message);
        }

        @Override
        void setChain(Chain chain) {
            this.chain = chain;
        }
    }
}

命令模式：

　　简单的讲命令模式中包含四个部分：invoker调用者；command命令；concreteCommand具体命令；Receiver命令执行者。

package org.yang.get;

/***
 * ，命令模式
 */
public interface commandDemo {
    /***
     * 命令执行者1
     */
    class Infantry {
        boolean run(){
            System.out.println("ready to run");
            return true;
        }
    }

    /***
     * 命令执行者2
     */
    class navy{
        boolean swim(){
            System.out.println("ready to swim");
            return true;
        }
    }

    /***
     * 命令接口
     */
    interface command{
        boolean go();
    }

    /***
     * 具体的命令1
     */
    class InfantryCommand implements command{
        Infantry infantry;

        InfantryCommand(Infantry infantry){
            this.infantry = infantry;
        }

        @Override
        public boolean go() {
            return this.infantry.run();
        }
    }

    /***
     * 具体的命令2
     */
    class navyCommand implements command{
        navy navy;

        navyCommand(navy navy){
            this.navy = navy;
        }

        @Override
        public boolean go() {
            return this.navy.swim();
        }
    }

    /***
     * 调用者
     */
    class invoker{
        void invoke(command command){
            command.go();
        }
    }
}

 迭代器模式：

　　迭代器最典型的例子就是迭代器，我们知道集合类都是实现了Iterable接口的，这个接口的功能就是实现迭代器的功能，所以所有集合类都可以进行迭代。下面看下ArrayList的迭代器：

/**
     * An optimized version of AbstractList.Itr
     */
    private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        Itr() {}

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

 中介者模式：

　　中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。提到通信很容易就会想到聊天室，因为聊天软件本身上不复杂，但是处理用户的复杂聊天关系和维持这种关系是最重要的，这个有点远，中介者模式就是复杂关系的维护者。

package org.yang.get;

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

/***
 * 中介者模式
 */
public interface MediatorPattern {
    /***
     * 通信单元
     */
    class user{
        String name;
        chatRoom chatRoom;
        user(String name,chatRoom chatRoom){
            this.name = name;
            this.chatRoom = chatRoom;
            this.chatRoom.loginOn(this);
        }
        boolean sendMessage(String name,String message){
            return this.chatRoom.sendMessage(new user(name,chatRoom),message);
        }

        void receiveMessage(String message){
            System.out.println("my name is:"+name+" i received a message:"+message);
        }
    }

    /***
     * 中介者
     */
    class chatRoom{
        private List<user> room = new ArrayList<>();

        void loginOn(user user){
            this.room.add(user);
        }

        boolean sendMessage(user user,String message){
            this.room.get(this.room.indexOf(user)).receiveMessage(message);
            return true;
        }
    }

    public static void main(String[] args) {
        chatRoom chatRoom = new chatRoom();
        user user1 = new user("张三",chatRoom);
        new user("里斯",chatRoom);
        user1.sendMessage("里斯","hai friend");
    }
}

 备忘录模式：

　　　备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。备忘录模式属于行为型模式。很多时候我们总是需要记录一个对象的内部状态，这样做的目的就是为了允许用户取消不确定或者错误的操作，能够恢复到他原先的状态，使得他有"后悔药"可吃。

　　备忘录模式使用三个类 Memento、Originator 和 CareTaker。Memento 包含了要被恢复的对象的状态。Originator 创建并在 Memento 对象中存储状态。Caretaker 对象负责从 Memento 中恢复对象的状态。

package org.yang.get;

import java.util.HashMap;
import java.util.Map;

/***
 * 备忘录模式
 */
public interface MementoPatternDemo {
    /***
     * 实体类
     */
    class Originator{
        String message;
        String name;/*这个字段是可以通过其他手段获得的，或者说这个不会被遗忘,就像你会忘了密码，但不会忘了你的名字*/
        Originator(String message,String name){
            this.message = message;
            this.name = name;
        }
    }

    /***
     * 从遗忘中恢复
     */
    interface util{
        Originator recover(String name);
    }

    /***
     * 存储状态的对象
     */
    class Memento implements util{
        Map pool = new HashMap();
        Memento(Originator originator){
            this.pool.put(originator.name,originator.message);
        }

        @Override
        public Originator recover(String name) {
            return new Originator(name,(String) this.pool.get(name));
        }
    }
}

 观察者模式：

　　当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

package org.yang.get;

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

/***
 * 观察者模式
 */
public interface ObserverPatternDemo {
    interface Observer{
        void doSth(String name);
    }

    class Observer1 implements Observer{
        @Override
        public void doSth(String name) {
            if(name.startsWith("1")){
                System.out.println("Observer1 deal");
            }
        }
    }

    class Observer2 implements Observer{
        @Override
        public void doSth(String name) {
            if(name.startsWith("1")){
                System.out.println("Observer2 deal");
            }
        }
    }

    class subject{
        List<Observer> list = new ArrayList<>();
        void addObserver(Observer observer){
            this.list.add(observer);
        }

        void myDo(String type){
            System.out.println("i want do sth");
            this.doType(type);
        }

        void doType(String type){
            for(Observer e:list){
                e.doSth(type);
            }
        }
    }

    public static void main(String[] args) {
       subject subject = new subject();
       subject.addObserver(new Observer1());
       subject.addObserver(new Observer2());
       subject.myDo("1");
    }
}

状态模式：

 　　当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。简单的理解就是对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为。

　　状态模式中共有三个角色，他们分别是上下文环境Context，抽象状态state，具体状态Concrete state。从模型中可以看出关键的两部分即环境和状态。

package org.yang.get;

/***
 * 状态模式
 */
public interface statePatternDemo {
    /***
     * 状态
     */
    class state{
        String info;
        state(String info){
            this.info = info;
        }
    }

    /***
     * 容器
     */
    class factory{
        private String name;
        state state;
        factory(state state){
            this.state = state;
        }

        void produce(){
            if(this.state.info.equals("Rifle")){//状态
                this.name = "Rifle";
                System.out.println("im a Rifle factory");//行为
            }else{
                this.name = "Sniper rifle";
                System.out.println("im a Sniper Rifle factory");
            }
        }
    }
}

策略模式：

　　策略模式是通过实现不同的策略实现类来完成灵活使用不同策略的目的。

package org.yang.get;

/***
 * 策略模式
 */
public interface strategyDemo {
    interface Strategy{
        void operation();
    }

    class Strategy1 implements Strategy{
        @Override
        public void operation() {
            System.out.println("策略1开始执行");
        }
    }

    class Strategy2 implements Strategy{
        @Override
        public void operation() {
            System.out.println("策略2开始执行");
        }
    }

    class lieBei{
        private Strategy strategy;
        lieBei(Strategy strategy){
            this.strategy=strategy;
        }
        
        void war(){
            this.strategy.operation();
        }
    } 
}

访问者模式：

　　最复杂的设计模式，并且使用频率不高，《设计模式》的作者评价为：大多情况下，你不需要使用访问者模式，但是一旦需要使用它时，那就真的需要使用了。访问者模式是一种将数据操作和数据结构分离的设计模式。

访问者模式的使用场景：

　　1.对象结构比较稳定，但经常需要在此对象结构上定义新的操作。

　　2.需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免这些操作“污染”这些对象的类，也不希望在增加新操作时修改这些类。

package org.yang.get;

/***
 * 访问者模式
 */
public interface VisitorPatternDemo {
    abstract class abstractAssembly{
        String name;
        void setName(String name){
            this.name = name;
        }

        abstract void work();
    }

    class mouse extends abstractAssembly{
        mouse(){
            this.setName("mouse");
        }
        @Override
        void work() {
            System.out.println("im working, im a :" + this.name);
        }
    }

    class Monitor extends abstractAssembly{
        Monitor(){
            this.setName("Monitor");
        }
        @Override
        void work() {
            System.out.println("im working, im a :" + this.name);
        }
    }

    /***
     * 访问接口
     */
    interface visit{
        void visit(abstractAssembly assembly);
    }

    /***
     * 访问器
     */
    class person implements visit{
        @Override
        public void visit(abstractAssembly assembly) {
            assembly.work();
        }
    }
}

参考文章：https://www.cnblogs.com/geek6/p/3951677.html https://www.runoob.com/design-pattern/design-pattern-tutorial.html