23种设计模式.txt

intell ideal 破解安装 https://blog.csdn.net/qq_30182413/article/details/91041715
初始化多模块maven springboot项目  https://baijiahao.baidu.com/s?id=1632687280256687825&wfr=spider&for=pc
                            https://www.cnblogs.com/a8457013/p/9254917.html
springboot项目部署      https://blog.csdn.net/weixin_40331613/article/details/81329277

设计模式的原则
        1. 开闭原则：   对扩展开放，对修改关闭
        2. 单一职责：   每个类应该实现单一的职责，不然就该拆分
        3. 里氏替换原则
        4. 依赖倒转：   面向接口编程，依赖抽象而非具体，用到具体类时，不与具体类交互，而与具体类上层接口交互
        5. 接口隔离：   接口中不应存在子类用不到却必须实现的方法
        6. 迪米特法则：
        7. 合成复用：   尽量首先使用合成/聚合的方式，而非使用继承

总分三大类
    1. 创建型模式
            工厂方法模式
                    通常采用静态工厂方法模式
                    public interface Sender{
                        public void Send();
                    }

                    public class MailSender implemnets Sender{
                        @Override
                        public void Send(){
                            System.out.println("this is mailSender");
                        }
                    }

                    public class SendFactory{
                        public static Sender produceMail(){
                            return new MailSender()
                        }
                    }

                    使用：
                        Sender sender = SendFactory.produceMail();

            抽象工厂模式
                    同工厂模式的区别：  ......
                    对java来说，能见到的大部分抽象工厂模式都是：
                            里面是一堆工厂方法，每个工厂方法返回某种类型的对象

            单例模式
                    常用设计模式，单例对象能保证在一个JVM中，该对象只有一个实例存在。
                    好处：
                            1. 对一些大型对象，节省开销
                            2. 省去new操作，降低系统内存的使用频率
                            3. 有些类 如交易所的核心交易引擎，控制交易流程，即不能创建多个实例
                    注意的点：
                            多线程情况下 被多次创建

                    public class Singleton{

                        /* 私有构造方法，防止被实例化 */
                        private Singleton(){
                        }

                        /* 此处使用一个内部类来维护单例 */
                        private static class SingletonFactory{
                            private static Singleton instance = new Singleton();
                        }

                        /* 获取实例 */
                        public static Singleton getInstance(){
                            return SingletonFactory.instance;
                        }

                        /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
                        public Object readResolve(){
                            return instance
                        }
                    }

                    注意：以上方式如果在构造函数中抛出异常，实例将永远得不到创建，也会出错；

                    另一种方式
                            将创建和getInstance()分开，单独为创建加synchronized关键字
                            public class SingletonTest{

                                private static SingletonTest instance = null;

                                /* ==采用影子实例的办法为单例对象的属性同步更新== */
                                private Vector properties = null;

                                public Vector getProperties(){
                                    return properties;
                                }

                                public void updateProperties(){
                                    SingletonTest shadow = new SingletonTest();
                                    properties = shadow.getProperties();
                                }
                                /* ========================================= */

                                private SingletonTest(){ }

                                private static synchronized void syncInit(){
                                    if( instance === null){
                                        instance = new SingletonTest();
                                    }
                                }

                                public static SingletonTest getInstance(){
                                    if(instance === null){
                                        syncInit();
                                    }
                                    return instance;
                                }
                            }

            建造者模式
                    文章未讲

            原型模式
                    思想： 将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象
                    原型类：
                        public class Prototype implemnets Cloneable, Serializable{

                            private static final long serialVersionUID = 1L;
                            private String string;
                            private SerializableObject obj;

                            /* 浅复制 */
                            public Object clone() throws CloneNotSupportedException{
                                Prototype proto = (Prototype) super.clone();
                                return proto;
                            }

                            /* 深复制 */
                            public Object deepClone() throws IOException, ClassNotFoundException{
                                /* 写入当前对象的二进制流 */
                                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                                ObjectOutputStream oos = new ObjectOutputStream(bos);
                                oos.writeObject(this);

                                /* 读出二进制流产生的新对象 */
                                ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
                                ObjectInputStream ois = new ObjectInputStream(bis);
                                return ois.readObject();
                            }

                            public String getString(){ return string; }
                            public void setString(String string){ this.string = string; }
                            public SerializableObject getObj() { return obj; }
                            public void setObj(SerializableObject obj) { this.obj = obj; }
                        }

                        class SerializableObject implements Serializable {
                            private static final long serialVersionUID = 1L;
                        }

    2. 结构型模式
            对象的适配器模式是各种模式的起源
                    1. 适配器模式
                            类的适配器模式 -> 对象的适配器模式 -> 接口的适配器模式
                                                    |                   |
                                            2. 装饰模式            5. 桥接模式
                                            3. 代理模式            6. 组合模式
                                            4. 外观模式            7. 享元模式

            适配器模式
                    定义：将某个类的接口转换成客户端期望的另一个接口表示
                    目的：消除接口不匹配所造成的类的兼容性问题
                    应用场景：希望将一个类转换成满足另一个新接口的类时
                    1. 类的适配器模式
                            public class Source{
                                public void method1(){
                                    System.out.println('this is a orginal method');
                                }
                            }

                            public interface Targetable{
                                /* 与原类相同的方法 */
                                public void method1();
                                /* 新类的方法 */
                                public void method2();
                            }
                            /* 适配器 */
                            public class Adapter extends Source implements Targetable{
                                @Override
                                public void method2(){
                                    System.out.println('this is a Targetable method');
                                }
                            }

                    2. 对象的适配器模式
                            思路： 与类的适配器模式相同，只是将Adapter类做修改，不继承Source类，而是持有Source类的实例
                            应用场景：希望将一个对象转换成满足另一个新接口的对象时，创建一个Wrapper类，持有原类的一个实例，在wrapper类方法中，调用实例方法即可

                            public class Wrapper implements Targetable{
                                private Source source;
                                public Wrapper(Source source){
                                    super();
                                    this.source = source;
                                }
                                @Override
                                public method2(){ ... }
                                @Override
                                public method1(){ source.method1(); }
                            }

                    3. 接口的适配器模式
                            应用场景：不希望实现一个接口所有的方法时，创建一个抽象类Wrapper，实现所有方法，具体类继承抽象类即可

                            /* 原始接口 */
                            public interface Sourceable{
                                public void method1();
                                public void method2();
                            }
                            /* 抽象类 */
                            public abstract class Wrapper2 implements Sourceable{
                                public void method1(){}
                                public void method2(){}
                            }
                            /* 具体实现类 */
                            public class SourceSub1 extends Wrapper2{
                                public void method1(){
                                    System.out.println('first sub');
                                }
                            }
                            public class SourceSub2 extends Wrapper2{
                                public void method2(){
                                    System.out.println('second sub');
                                }
                            }

            装饰器模式
                    定义：给一个对象增加一些新功能，且是动态的，要求装饰对象和被装饰对象实现同一接口，装饰对象持有被装饰对象的实例
                    public interface Sourceable{
                        public void method();
                    }
                    public class Source implements Sourceable{
                        @Override
                        public void method(){ System.out.println('orginal method') }
                    }
                    public class Decorator implements Sourceable{
                        private Sourceable source;
                        public Decorator(Sourceable source){
                            super();
                            this.source = source;
                        }
                        @Override
                        public void method(){
                            System.out.println('before decorator');
                            source.method();
                            System.out.println('after decorator' );
                        }
                    }

                    Test:   Sourceable source = new Source(); Sourceable obj = new Decorator(source); obj.method();

            代理模式
                    同装饰器模式区别：
                            代理模式的重心是为了借用对象的功能完成某一流程，而非对象功能如何；
                            装饰模式的重心是对 对象功能的扩展，不关心外界如何调用，只注重对象功能的加强，装饰后还是对象本身。
                    public interface Sourceable{
                        public void method();
                    }
                    public class Source implements Sourceable{
                        @Override
                        public void method(){ System.out.println('orginal method') }
                    }
                    public class Proxy implements Sourceable{
                        private Source source;
                        public Proxy(){ super(); this.source = new Source(); }

                        @Override
                        public void method(){
                            before();
                            source.method();
                            after();
                        }
                        private void before(){ ... }
                        private void after(){ ... }
                    }

                    Test: Sourceable source = new Proxy(); source.method();

            外观模式
                    目的：解决类与类之间的依赖关系，降低类间的耦合度，该模式不涉及到接口
                    public class CPU{
                        public void startup(){ System.out.println('cpu start') }
                        public void shutdown(){ System.out.println('cpu shutdown') }
                    }
                    public class Memory{
                        public void startup(){ System.out.println('Memory start') }
                        public void shutdown(){ System.out.println('Memory shutdown') }
                    }
                    public class Disk{
                        public void startup(){ System.out.println('Disk start') }
                        public void shutdown(){ System.out.println('Disk shutdown') }
                    }
                    public class Computer{
                        private CPU cpu;
                        private Memory memory;
                        private Disk disk;
                        public Computer(){
                            cpu = new CPU(); memory = new Memory(); disk = new Disk();
                        }
                        public void startup(){
                            cpu.start(); memory.start(); disk.start();
                        }
                        public void shutdown(){
                            cpu.shutdown(); memory.shutdown(); disk.shutdown();
                        }
                    }

            桥接模式
                    目的：把事物和其具体实现分开，将抽象化与实例化解耦，使得二者可以独立变化，如JDBC那样
                    public interface Sourceable{ public void method(); }

                    public class SourceSub1 implements Sourceable{
                        @Override
                        public void method(){ System.out.println('first sub'); }
                    }
                    public class SourceSub2 implements Sourceable{
                        @Override
                        public void method(){ System.out.println('second sub'); }
                    }

                    /* 定义一个桥，持有Sourceable的一个实例 */
                    public abstract class Bridge{
                        private Sourceable source;

                        public void method(){ source.method(); }

                        public Sourceable getSource(){ return source; }

                        public void setSource(Sourceable source){ this.source = source; }
                    }

                    public class MyBridge extends Bridge(){
                        public void method(){ getSource().method(); }
                    }

                    Test:
                        Bridge bridge = new MyBridge();
                        /* 调用第一个对象 */
                        Sourceable source1 = new SourceSub1();
                        bridge.setSource(source1);
                        bridge.method();
                        /* 调用第二个对象 */
                        Sourceable source2 = new SourceSub2();
                        bridge.setSource(source2);
                        bridge.method();

            组合模式
                    场景：处理类似树形结构的问题时较为方便;多个对象组合在一起进行工作，常用于树形结构，如二叉树 树等。
                    public class TreeNode{
                        private String name;
                        private TreeNode parent;
                        private Vector<TreeNode> children = new Vector<TreeNode>();

                        public TreeNode(String name){ this.name = name; }
                        public String getName(){ return name; }
                        public String setName(String name){ this.name = name; }
                        public TreeNode getParent(){ ... }
                        public void setParent(TreeNode parent){ ... }

                        public void add(TreeNode node){ children.add(node); }                       /* 添加子节点 */
                        public void remove(TreeNode node){ children.remove(node); }                 /* 删除子节点 */
                        public Enumeration<TreeNode> getChildren(){ return children.elements(); }   /* 取子节点 */
                    }
                    public class Tree{
                        TreeNode root = null;
                        public Tree(String name){ root = new TreeNode(name); }
                        public static void main(String[] args){
                            Tree tree = new Tree("A");
                            TreeNode nodeB = new TreeNode("B");
                            TreeNode nodeC = new TreeNode("C");
                            nodeB.add(nodeC);
                            tree.root.add(nodeB);
                            System.out.println('build the tree finished');
                        }
                    }

            享元模式
                    实现对象共享，即共享池，通常与工厂模式一起使用 举例：数据库连接池
                        public class ConnectionPool{
                            private Vector<Connection> pool;
                            /* 共有属性 */
                            private String url = 'jdbc:mysql://localhost:3306/test';
                            private String username = 'root';
                            private String password = 'root';
                            private String driverClassName = 'com.mysql.jdbc.Driver';
                            private int poolSize = 100;
                            private static ConnectionPool instance = null;
                            Connection conn = null;

                            private ConnectionPool(){
                                pool = new Vector<Connection>(poolSize);
                                for(int i = 0; i < poolSize; i++){
                                    try{
                                        Class.forName(driverClassName);
                                        conn = DriverManager.getConnection(url, username, password);
                                        pool.add(conn);
                                    }catch(ClassNotFoundException e){ e.printStackTrace(); }
                                     catch(SQLExecption e){ e.printStackTrace(); }
                                }
                            }

                            /* 返回链接到连接池 */
                            public synchronized void release(){ pool.add(conn); }
                            /* 返回连接池中的一个数据库连接 */
                            public synchronized Connection getConnection(){
                                if(pool.size()>0){
                                    Connection conn = pool.get(0);
                                    pool.remove(conn);
                                    return conn;
                                }else{ return null; }
                            }
                        }

    3. 行为型模式                   也称为关系模式
            第一类：    通过父类与子类的关系实现
                    1. 策略模式     2. 模版方法模式
            第二类：    两个类之间
                    1. 观察者模式   2. 迭代子模式   3. 责任链模式   4. 命令模式
            第三类：    类的状态
                    1. 备忘录模式   2. 状态模式
            第四类：    通过中间类
                    1. 访问者模式   2. 中介者模式   3. 解释器模式


            策略模式
                    定义：封装每个算法，使之可相互替换且不影响到使用

                    /* 统一接口 */
                    public interface ICalculator{ public int calculate(String exp); }

                    /* 辅助类 */
                    public abstract class AbstractCalculator{
                        public int[] split(String exp, String opt){
                            String array[] = exp.split(opt);
                            int arrayInt[] = new Int[2];
                            arrayInt[0] = Integer.parseInt(array[0]);
                            arrayInt[1] = Integer.parseInt(array[1]);
                            return arrayInt;
                        }
                    }

                    /* 三个实现类 */
                    public class Plus extends AbstractCalculator implements ICalculator{
                        @Override
                        public int calculate(String exp){
                            int arrayInt[] = split(exp, '\\+'); return arrayInt[0] + arrayInt[1];
                        }
                    }
                    public class Minus extends AbstractCalculator implements ICalculator{
                        @Override
                        public int calculate(String exp){
                            int arrayInt[] = split(exp, '\\-'); return arrayInt[0] - arrayInt[1];
                        }
                    }
                    public class Multiply extends AbstractCalculator implements ICalculator{
                        @Override
                        public int calculate(String exp){
                            int arrayInt[] = split(exp, '\\*'); return arrayInt[0] * arrayInt[1];
                        }
                    }

                    Test:   ICalculator cal = new Plus(); int result = cal.calculate(exp);

            模版方法模式
                    定义：通过调用抽象类，实现对子类的调用
                    public abstract class AbstractCalculator{
                        /* 主方法 实现对本类其他方法的调用 */
                        public final int calculate(String exp, String opt){
                            int array[] = split(exp, opt); return calculate(array[0], array[1]);
                        }

                        /* 被子类重写的方法 */
                        abstract public int calculate(int num1, int num2);

                        public int[] split(String exp, String opt){
                            String array[] = exp.split(opt);
                            int arrayInt[] = new Int[2];
                            arrayInt[0] = Integer.parseInt(array[0]);
                            arrayInt[1] = Integer.parseInt(array[1]);
                            return arrayInt;
                        }
                    }

                    public class Plus extends AbstractCalculator{
                        @Override
                        public int calculate(int num1, int num2){ return num1 + num2; }
                    }

                    Test: AbstractCalculator cal = new Plus(); int result = cal.calculate(exp, '\\+');


        以下几个都是类和类之间的关系
            观察者模式
                    定义：不涉及继承，类似于邮件订阅和RSS订阅，当一个对象变化时，其他依赖该对象的对象会收到通知，且随之变化
                    public interface Observer{ public void update(); }

                    public class Observer1 implements Observer{
                        @Override
                        public void update(){ System.out.println('Observer1 received') }
                    }
                    public class Observer2 implements Observer{
                        @Override
                        public void update(){ System.out.println('Observer2 received') }
                    }

                    public interface Subject{
                        public void add(Observer observer);     /* 增加观察者 */
                        public vodi del(Observer observer);     /* 删除观察者 */
                        public void notifyObservers();          /* 通知所有观察者 */
                        public void operation();                /* 自身操作 */
                    }

                    public abstract class AbstractSubject implements Subject{
                        private Vector<Observer> vector = new Vector<Observer>();
                        @Override
                        public void add(Observer o){ vector.add(o); }
                        @Override
                        public void del(Observer o){ vector.remove(o); }
                        @Override
                        public void notifyObservers(){
                            Enumeration<Observer> enumo = vector.elements();
                            while(enumo.hasMoreElements()){
                                enumo.nextElement().update();
                            }
                        }
                    }

                    public class MySubject extends AbstractSubject{
                        @Override
                        public void operation(){
                            System.out.println('update self'); notifyObservers();
                        }
                    }

            迭代子模式
                    定义：顺序访问聚集中的对象，一是需要遍历的对象，二是迭代器对象；集合中常见
                    思路：MyCollection定义了集合的操作，MyIterator中定义了迭代操作，且持有Collection实例

                    public interface Collection{
                        public Iterator iterator();
                        public Object get(int i);           /* 取得集合对象 */
                        public int size();                  /* 取得集合大小 */
                    }

                    public interface Iterator{
                        public Object previous();           //前移
                        public Object next();               //后移
                        public boolean hasNext();
                        public Object first();              //取得第一个元素
                    }

                    public class MyCollection implements Collection{
                        public String string[] = {"A","B","C"};
                        @Override
                        public Iterator iterator(){ return new MyIterator(this); }
                        @Override
                        public Object get(int i){ return string[i]; }
                        @Override
                        public int size(){ return string.length; }
                    }

                    public class MyIterator implements Iterator{
                        pirvate MyCollection myCollection;
                        private int pos = -1;

                        public MyIterator(Collection collection){ this.myCollection = collection; }
                        @Override
                        public Object previous(){
                            if(pos>0){ pos-- }
                            return collection.get(pos);
                        }
                        @Override
                        public Object next(){
                            if(pos < collection.size() -1 ){ pos++ }
                            return collection.get(pos);
                        }
                        @Override
                        public bool hasNext(){
                            return !!(pos < collection.size()-1)
                        }
                        @Override
                        public Object first(){
                            pos = 0;
                            return collection.get(pos);
                        }

                    }

                    Test: Collection collection = new MyCollection();
                    Iterator it = collection.iterator();
                    while(it.hasNext()){ System.out.println(it.next()); }

            责任链模式
                    定义：多个对象，每个对象持有下一个对象的引用，形成链
                    强调：链接上的请求可以是链 亦可是树 或者环 需要自己实现，只能一对一传，而不能一对多
                    public interface Handler{
                        public void operator();
                    }

                    public abstract class AbstractHandler{
                        private Handler handler;
                        public Handler getHandler(){ return handler; }
                        public void setHandler(Handler handler){ this.handler = handler; }
                    }

                    public class myHandler extends AbstractHandler implements Handler{
                        private String name;
                        public MyHandler(String name ){ this.name = name; }
                        @Override
                        public void operator(){
                            System.out.println( name + "deal";)
                            if(getHandler()!=null){ getHandler().operator(); }
                        }
                    }

                    Test:   MyHandler h1 = new MyHandler("h1");
                            MyHandler h2 = new MyHandler("h2");
                            MyHandler h3 = new MyHandler("h3");
                            h1.setHandler(h2); h2.setHandler(h3);
                            h1.operator();

            命令模式
                    定位：对象解耦，司令(Invoker)->命令(MyCommand)->士兵(Receiver)执行 三者独立

                    public interface Command{ public void exe(); }

                    public class MyCommand implements Command{
                        private Receiver receiver;
                        public MyCommand(Receiver receiver){ this.receiver = receiver; }
                        @Override
                        public void exe(){ receiver.action(); }
                    }

                    public class Receiver{
                        public void action(){ System.out.println('received'); }
                    }

                    public class Invoker{
                        private Command command;
                        public Invoker(Command command){ this.command = command; }
                        public void action(){ command.exe(); }
                    }

                    Test:   Receiver receiver = new Receiver();
                            Command cmd = new MyCommand(receiver);
                            Invoker invoker = new Invoker(cmd);
                            invoker.action();

        类的状态
            备忘录模式
                    目的：保存一个对象的某种状态，以便适当时候恢复对象
                    举例：原始类A及其属性，A决定需备份属性，类B用来存储A内部状态，类C存储备忘录，且只能存储

                    public class Original{
                        private String value;
                        public String getValue(){ retunr value; }
                        public void setValue(String value){ this.value = value; }
                        public Original(String value){ this.value = value; }
                        public Memento createMemento(){ return new Memento(value); }
                        public void restoreMemento(Memento memento){
                            this.value = memento.getValue();
                        }
                    }

                    public class Memento{
                        private String value;
                        public Memento(String value){ this.value = value; }
                        public String getValue(){ return value; }
                        public void setValue(String value){ this.value = value; }
                    }

                    public class Storage{
                        private Memento memento;
                        public Storage(Memento memento){ this.memento = memento; }
                        public Memento getMemento(){ return memento; }
                        public void setMemento(Memento memento){ this.memento = memento; }
                    }

                    Original origi = new Original('egg');                   /* 创建原始类 */
                    Storage storage = new Storage(Origi.createMemento());   /* 创建备忘录 */
                    origi.setValue('new');                                  /* 重新赋值 */
                    origi.restoreMemento(storage.getMemento());             /* 恢复状态 */

            状态模式
                    核心思想：对象的状态改变时，同时改变其行为

                    /* 状态类的核心类 */
                    public class State{
                        private String value;
                        public String getValue(){ return value; }
                        public void setValue(String string){ this.value = string; }
                        public void method1(){ System.out.println("first opt"); }
                        public void method2(){ System.out.println("second opt"); }
                    }

                    /* 状态类的切换类 */
                    public class Context{
                        private State state;
                        public Context(State state){ this.state = state; }
                        public State getState(){ return state; }
                        public void setState(){ this.state = state; }
                        public void method(){
                            if(state.getValue().equals('state1')){ state.method1();}
                            else if(state.getValue().equals('state2')){ state.method2();}
                        }
                    }

                    Test:   State state = new State();
                            Context contenxt = new Context(state);
                            state.setValue("state1");   contenxt.method();
                            state.setValue("state2");   contenxt.method();

        通过中间类
            访问者模式
                    定位：分离数据结构与行为的方法，通过分离，可达到为一个被访问者动态添加新的操作而无需做其他的修改的效果
                        把数据结构给和作用于结构上的操作解耦合，若数据结构对象易于变化，则不合适；适用场景，数据结构相对稳定的系统

                    /* Visitor类 存放要访问的对象 */
                    public interface Visitor{ public void visit(Subject sub); }
                    public class MyVisitor implements Visitor{
                        @Override
                        public void visit(Subject sub){
                            System.out.println('visit the subject' + sub.getSubject());
                        }
                    }

                    /* Subject类，accept方法 接受要访问他的对象，getSubject()获取要被访问的属性 */
                    public interface Subject{
                        public void accept(Visitor visitor);
                        public String getSubject();
                    }
                    public class MySubject implements Subject{
                        @Override
                        public void accept(Visitor visitor){ visitor.visit(this); }
                        @Override
                        public String getSubject(){ return 'love'; }
                    }

                    Test:   Visitor visitor = new MyVisitor();
                            Subject sub = new MySubject();
                            sub.accept(visitor);

            中介者模式
                    降低类类间耦合
                    User1和User2对象间有关联，不采用中介者模式 会导致互相持有 耦合增高，引入Mediator类 提供统一接口

                    public interface Mediator{
                        public void createMediator();
                        public void workAll();
                    }
                    public class MyMediator implements Mediator{
                        private User user1;
                        private User user2;
                        public User getUser1(){ return user1; }
                        public User getUser2(){ return user2; }
                        @Override void createMediator(){ user1 = new User1(this); user2 = new User2(this); }
                        @Override void workAll(){ user1.work(); user2.work(); }
                    }

                    public abstract class User{
                        private Mediator mediator;
                        public Mediator getMediator(){ return mediator; }
                        public User(Mediator mediator){ this.mediator = mediator; }
                        public abstract void work();
                    }

                    public class User1 extends User{
                        public User1(Mediator mediator){
                            super(mediator);
                        }
                        @Override
                        public void work(){ System.out.println("user1 exe");}
                    }
                    public class User2 extends User{
                        public User2(Mediator mediator){
                            super(mediator);
                        }
                        @Override
                        public void work(){ System.out.println("user2 exe");}
                    }

                    Test:   Mediator mediator = new Mediator();
                            mediator.createMediator();
                            mediator.workAll();

            解释器模式
                    主要应用：OOP开发中的编译器的开发中，适用面较窄

                    public interface Expression{
                        public int interpret(Context contenxt);
                    }
                    public class Plus implements Expression{
                        @Override int interpret(Context context){
                            return context.getNum1() + contenxt.getNum2();
                        }
                    }
                    public class Minus implements Expression{
                        @Override int interpret(Context context){
                            return context.getNum1() - contenxt.getNum2();
                        }
                    }
                    public class Context{
                        private int num1; private int num2;
                        public Context(int num1, int num2){
                            this.num1 = num1;
                            this.num2 = num2;
                        }

                        public int getNum1(){ return num1; }
                        pblicc void setNum1(int num1){ this.num2 = num2; }
                        public int getNum2(){ return num2; }
                        pblicc void setNum2(int num2){ this.num2 = num2; }
                    }

                    Test:   int result = new Minus().interpret((new Context(new Plus()
                                        .interpret(new Context(9,2)),8)));
                            System.out.println(result);

    4. 并发者模式 和 线程池模式