设计模式学习总结

一、概览

设计模式.jpg

二、程序示例

1. 六大设计原则

(1) 单一职责原则(Single Responsibility)

//电话连接接口
public interface IConnectionManager {
    void dial(String phoneNumber);
    void hangUp();
}
//数据传输接口
public interface IDataTransfer {
    void transferData(IConnectionManager connectionManager);
}
//电话类
public class Phone implements IConnectionManager, IDataTransfer {
    @Override
    public void dial(String phoneNumber) {
        System.out.println("拨打电话...");
    }

    @Override
    public void hangUp() {
        System.out.println("挂断电话...");
    }

    @Override
    public void transferData(IConnectionManager connectionManager) {
        System.out.println("通话中...");
    }
}

/*
* Simple Responsibility Principle(SRP)
* 单一职责原则要求一个接口或类只有一个原因引起变化，也就是一个接口或类只有一个职责，
* 他就负责一件事。
* */
public class Main {
    public static void main(String[] args){
        Phone phone = new Phone();
        phone.dial("123456");
        phone.transferData(phone);
        phone.hangUp();
    }
}

(2) 里氏替换原则(Liskov Substitution)

//父类
import java.util.Collection;
import java.util.HashMap;

public class Father {
    public Collection  doSomething(HashMap  map){
        System.out.println("Father do something...");
        return map.values();
    }
}
//子类
import java.util.*;

public class Son extends Father {

    public Collection doSomething(Map map) {
        System.out.println("Son do something...");
        return map.values();
    }

    @Override
    public List doSomething(HashMap map) {
        System.out.println("Son do something...");
        return new ArrayList(map.values());
    }
import java.util.HashMap;
/*
* 里式替换原则：只要父类能够出现的地方子类就可以出现，而且替换为子类也不会出现任何错误和异常，
* 使用者可能根本不需要知道是父类还是子类。但是，子类出现的地方，父类未必能够适应。
* 1. 子类必须完全实现父类的方法
* 2. 子类可以有自己的个性
* 3. 重载或者实现父类方法时输入参数范围可以放大
* 4. 复写或者实现父类方法时输出结果范围可以被缩小
* */
public class Main {
    public static void main(String[] args){
        Father father = new Father();
        HashMap map = new HashMap();
        Son son = new Son();
        son.doSomething(map);
    }
}

(3) 依赖倒置原则(Dependency Inversion)

//汽车接口
public interface ICar {
    void run();
}
//IDriver1接口
public interface IDriver1 {
    void drive(ICar car);
}
//IDriver2 接口
public interface IDriver2 {
    void drive();
}
//IDriver3接口
public interface IDriver3 {
    void setCar(ICar car);
    void drive();
}
/*
* 接口声明注入
* */
public class Driver1 implements IDriver1 {
    @Override
    public void drive(ICar car) {
        car.run();
    }
}
/*
* 构造函数注入
* */
public class Driver2 implements IDriver2 {
    private ICar car;
    public Driver2(ICar car){
        this.car = car;
    }
    @Override
    public void drive() {
        this.car.run();
    }
}
/*
* Setter方法传递依赖对象
* */
public class Driver3 implements IDriver3 {
    private ICar car;
    @Override
    public void setCar(ICar car) {
        this.car = car;
    }

    @Override
    public void drive() {
        this.car.run();
    }
}
//奔驰车
public class Benz implements ICar {
    @Override
    public void run() {
        System.out.println("奔驰车在跑...");
    }
}
//宝马车
public class Bmw implements ICar {
    @Override
    public void run() {
        System.out.println("宝马车在跑...");
    }
}
/*
* 依赖倒置原则：
* 高层模型不应该依赖底层模块，两者都应该依赖其抽象；
* 抽象不应该依赖细节；
* 细节应该依赖抽象。
* 依赖的三种写法：
* 1. 构造函数传递依赖对象
* 2. Setter方法传递依赖对象
* 3. 接口声明传递依赖对象
* */
public class Main {
    public static void main(String[] args){
        IDriver1 driver1 = new Driver1();
        ICar car = new Benz();
        driver1.drive(car);
        IDriver2 driver2 = new Driver2(new Benz());
        driver2.drive();
        IDriver3 driver3 = new Driver3();
        driver3.setCar(new Bmw());
        driver3.drive();
    }
}

(4) 接口隔离原则(Interface Segregation)

//IGoodBodyGirl接口
public interface IGoodBodyGirl {
    void goodLooking();
    void niceFigure();
}
//IGreatTemperamentGirl接口
public interface IGreatTemperamentGirl {
    void greatTemperament();
}
//PettyGirl类
public class PettyGirl implements IGoodBodyGirl, IGreatTemperamentGirl {

    private String name;

    public PettyGirl(String name){
        this.name = name;
    }
    @Override
    public void goodLooking() {
        System.out.println(this.name+"---脸蛋很漂亮!");
    }

    @Override
    public void niceFigure() {
        System.out.println(this.name+"---身材非常棒!");
    }

    @Override
    public void greatTemperament() {
        System.out.println(this.name+"---气质非常好!");
    }
}
/*
* 接口隔离原则：
* 1. 接口要尽量小，不出现臃肿的接口，但是细分接口时需要考虑单一职责原则，不能无限细分下去。
* 2. 接口要高内聚，提高接口、类、模块的处理能力，减少对外的交互。
* 接口尽量少公布public方法，接口是对外的承诺。
* 3. 定制服务，系统间或者系统内相互有耦合，定制即为单独为一个个体提供服务，只提供访问者必要的方法。
* 4. 接口设计是有限度的。
* */
public class Main {
}

(5) 迪米特法则(Law of Demeter)

//女孩类
public class Girl {
}
//班干部类
import java.util.List;

public class GroupLeader {
    private List<Girl> girlList;
    public GroupLeader(List<Girl> girlList){
        this.girlList = girlList;
    }
    public void countGirls(){
        System.out.println("女生数量是："+girlList.size());
    }
}
//老师类
public class Teacher {
    public void command(GroupLeader groupLeader){
        groupLeader.countGirls();
    }
}
import java.util.ArrayList;
import java.util.List;

/*
* 迪米特法则(最少知识法则)：一个对象应该对其他对象有最少的了解，一个类对自己需要调用的类知道得最少。
* 1. 只和朋友交流，朋友类指出现在成员变量、方法输入参数中的类称为成员朋友类，而出现在方法体内的类不属于朋友类。
* 2. 朋友之间也是有距离的，朋友之间只暴露必要的方法。
* 3. 是自己的就是自己的，如果一个方法放在本类里，既不增加类间关系，也不对本类产生负面影响，就放在本类中。
* 4. 谨慎使用Serializable
* */
public class Main {
    public static void main(String[] args){
        List<Girl> girlList = new ArrayList<>();
        Teacher teacher = new Teacher();
        teacher.command(new GroupLeader(girlList));
    }

}

(6) 开闭原则(Open Closed Principle)

//IBook接口
public interface IBook {
    String getName();
    int getPrice();
    String getAuthor();
}
//小说书类
public class NovelBook implements IBook {
    private String name;
    private String author;
    private int price;
    public NovelBook(String name, String author, int price){
        this.name = name;
        this.author = author;
        this.price = price;
    }
    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public int getPrice() {
        return this.price;
    }

    @Override
    public String getAuthor() {
        return this.author;
    }
}
//打折小说书类
public class OffNovelBook extends NovelBook {

    public OffNovelBook(String name, String author, int price) {
        super(name, author, price);
    }

    @Override
    public int getPrice() {
        int selfPrice = super.getPrice();
        int offPrice = 0;
        if(selfPrice > 4000){
            offPrice = selfPrice * 90/100;
        }else{
            offPrice = selfPrice * 80/100;
        }
        return offPrice;
    }

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

/*
* 开闭原则：对扩展开发，对修改关闭。
* */
public class Main {

    public static void main(String[] args){
        List<IBook> bookList = new ArrayList<>();
        bookList.add(new OffNovelBook("天龙八部","金庸",4000));
        bookList.add(new OffNovelBook("神雕侠侣","金庸",3000));
        for(IBook book: bookList){
            System.out.println("书籍名称:"+book.getName()+" 作者:"+book.getAuthor()+" 价格:"+book.getPrice()
            );
        }
    }
}

2. 二十三种设计模式

(1) 单例模式(Singleton Pattern)

① 使用静态常量的饿汉模式(线程安全)

/*
* 优点：写法简单，在类装载的时候就完成实例化，避免线程同步问题。
* 缺点：在类初始化的时候就完成实例化，没有达到Lazy Loading的效果，如果该实例没有使用，则会造成内存浪费。
* */
public class StarvingModelUsingStaticConst {
        private static final StarvingModelUsingStaticConst INSTANCE = new StarvingModelUsingStaticConst();
        private StarvingModelUsingStaticConst(){}
        public static StarvingModelUsingStaticConst getInstance(){
            return INSTANCE;
    }
}

② 使用静态块的饿汉模式(线程安全)

/*
* 缺点和优点与使用静态常量一样。
* */
public class StarvingModelUsingStaticCode {
    private static StarvingModelUsingStaticCode instance;
    private StarvingModelUsingStaticCode(){}
    static{
        instance = new StarvingModelUsingStaticCode();
    }
    public static StarvingModelUsingStaticCode getInstance(){
        return instance;
    }
}

③ 懒汉模式不加锁(线程不安全)

/*
* 优点：起到了lazy loading的效果，但是只能在单线程的情况下使用。
* 缺点：如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，
* 另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。
*
* */
public class SlackerUnSafeThread {
    private static SlackerUnSafeThread instance;
    private SlackerUnSafeThread(){}
    public static SlackerUnSafeThread getInstance(){
        if(instance == null){
            instance = new SlackerUnSafeThread();
        }
        return instance;
    }
}

④ 懒汉模式加方法锁(线程安全)

/*
* 优点：通过加锁对getInstance()方法进行了线程同步，最终多线程情况下只有一个实例。
* 缺点：每次去获取实例都需要等待其他线程将锁释放，严重影响效率。
* */
public class SlackerSynchronizedMethod {
    private static SlackerSynchronizedMethod instance;
    private SlackerSynchronizedMethod(){}
    public static synchronized SlackerSynchronizedMethod getInstance(){
        if(instance == null){
            instance = new SlackerSynchronizedMethod();
        }
        return instance;
    }
}

⑤ 懒汉模式加同步块锁(线程不安全)

/*
* 在实例化的时候加入了同步锁，但是效果还是和SlackerUnSafeThread一样，在多线程情况下还是会产生多个实例。
* */
public class SlackerSynchronizedCode {
    private static SlackerSynchronizedCode instance;
    private SlackerSynchronizedCode(){}
    public static SlackerSynchronizedCode getInstance(){
        if(instance == null){
            synchronized(SlackerSynchronizedCode.class){
                instance = new SlackerSynchronizedCode();
            }
        }
        return instance;
    }
}

⑥ 懒汉模式双重检测(线程安全)

/*
* 双重检测进行了两次检测，保证线程安全性，最终只产生一个实例。
* */
public class SlackerDoubleCheck {
    private static volatile SlackerDoubleCheck instance; //防止指令重排
    private SlackerDoubleCheck(){}
    public static SlackerDoubleCheck getInstance(){
        if(instance == null){
            synchronized(SlackerDoubleCheck.class){
                if(instance == null){
                    instance = new SlackerDoubleCheck();
                }
            }
        }
        return instance;
    }
}

⑦ 内部类方式(线程安全)

/*
*这种方式跟饿汉式方式采用的机制类似，但又有不同。
* 两者都是采用了类装载的机制来保证初始化实例时只有一个线程。
* 不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，
* 没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，
* 而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，
* 从而完成Singleton的实例化。类的静态属性只会在第一次加载类的时候初始化，
* 所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
* */
public class StaticInnerClass {
    private StaticInnerClass() {}

    private static class SingletonInstance {
        private static final StaticInnerClass INSTANCE = new StaticInnerClass();
    }

    public static StaticInnerClass getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

⑧ 枚举类方式(线程安全)

/**
当一个Java类第一次被真正使用到的时候静态资源被初始化、Java类的加载和初始化过程都是线程安全的（因为虚拟机在加载枚举的类的时候，会使用ClassLoader的loadClass方法，而这个方法使用同步代码块保证了线程安全）。所以，创建一个enum类型是线程安全的。
**/
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class EnumModel {
    private enum MyEnum{
        ENUM_FACTORY;
        private Connection connection;
        MyEnum(){
            try {
                Class.forName("");
                connection = DriverManager.getConnection("","","");
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        private Connection getConnection(){
            return connection;
        }
    }
    public static Connection getConnection(){
        return MyEnum.ENUM_FACTORY.getConnection();
    }
}

(2) 工厂方法模式(Factory Pattern)

public interface Creator{

    <T extends Product> T create(Class<T> clazz);
}

public interface Product {
    void method();
}

public class ConcreteCreator implements Creator {
    @Override
    public <T extends Product> T create(Class<T> clazz) {
        Product product = null;
        T productT = null;
        try {
            product  = clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        if(product != null){
            productT = (T)product;
        }
        return productT;
    }
}

public class Product1 implements Product {
    @Override
    public void method() {
        System.out.println("产品1运行...");
    }
}

public class Product2 implements Product {
    @Override
    public void method() {
        System.out.println("产品2运行...");
    }
}

/*
* 工厂模式：定义一个用于创建对象的接口，让子类决定实例化哪个类。
* 工厂方法使一个类的实例化延迟到其子类。
*
* */
public class Main {
    public static void main(String[] args){
        Product product = new ConcreteCreator().create(Product1.class);
        product.method();
    }
}

(3) 抽象工厂模式(Abstract Factory Pattern)

public interface AbstractProductA {
}

public interface AbstractProductB {
}

public interface AbstractCreator {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

public class ProductA1 implements AbstractProductA {
}

public class ProductA2 implements AbstractProductA {
}

public class ProductB1 implements AbstractProductB {
}

public class ProductB2 implements AbstractProductB {
}

public class Creator1 implements  AbstractCreator {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}

public class Creator2 implements AbstractCreator {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

/*
*抽象工厂模式：为创建一组相关或者相互依赖的的对象提供一个接口，而且无需指定它们的具体类。
*
* */
public class Main {
    public static void main(String[] args){
        AbstractProductA productA = new Creator1().createProductA();
    }

}

(4) 模板方法模式(Template method Pattern)

public abstract class AbstractClass {
    protected abstract void doSomething();
    protected abstract void doAnything();
    protected boolean isDoAnything(){
        return true;
    }
    public  final void templateMethod(){
        if(isDoAnything()){
            doAnything();
        }
        doSomething();
    }
}
public class ConcreteClass1 extends AbstractClass {

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    private boolean flag;
    @Override
    protected void doSomething() {
        System.out.println("Class1 do something...");
    }

    @Override
    protected void doAnything() {
        System.out.println("Class1 do anything...");
    }

    @Override
    public boolean isDoAnything(){
        return this.flag;
    }
}
public class ConcreteClass2 extends AbstractClass {
    @Override
    protected void doSomething() {
        templateMethod();
        System.out.println("Class2 do something...");
    }

    @Override
    protected void doAnything() {
        System.out.println("Class2 do anything...");
    }
}
/*
* 定义一个操作中的算法的框架，而将一些步骤延迟到子类中。
* 使得子类可以不改变算法结构即可重定义算法的某些特定步骤。
*
* */
public class Main {
    public static void main(String[] args){
        AbstractClass class1 = new ConcreteClass1();
        ((ConcreteClass1) class1).setFlag(true);
        class1.templateMethod();
    }

}

(5) 建造者模式(Builder Pattern)

//产品类
public class Product {
    public void doSomething(){}
}
//抽象建造者
public abstract class Builder {
    public abstract void setPart();
    public abstract Product buildProduct();
}
//具体建造者，多个产品类就有几个具体的建造者，这几个产品类具有相同的接口或者抽象类。
public class ConcreteBuilder extends Builder {
    Product product = new Product();
    @Override
    public void setPart() {

    }

    @Override
    public Product buildProduct() {
        return product;
    }
}
//导演类，起到封装的作用，避免高层模块深入到建造者内部的实现类。
public class Director {
    private Builder builder = new ConcreteBuilder();
    public Product getProduct(){
        builder.setPart();
        return builder.buildProduct();
    }
}
/*
* 建造者模式(生成器模式)：将一个复杂对象的创建和表示分离，使得同样的构建过程可以创建不同的表示。
*
* */
public class Main {
    public static void main(String[] args){
        Director director = new Director();
        director.getProduct();
    }
}

(6) 代理模式(Proxy Pattern)

① 普通代理

//公共接口
package generalproxy;

public interface IGamePlayer {
    void login();
    void killBoss();
    void upgrade();
}

//被代理者
package generalproxy;

public class GamePlayer implements IGamePlayer {
    private String name;
    public GamePlayer(IGamePlayer gamePlayerProxy, String name) throws Exception {
        if(gamePlayerProxy == null){
             throw new Exception("不能创建真实角色");
        }else{
            this.name = name;
        }

    }
    @Override
    public void login() {
        System.out.println(this.name+"登录...");
    }

    @Override
    public void killBoss() {
        System.out.println(this.name+"打怪...");
    }

    @Override
    public void upgrade() {
        System.out.println(this.name+"升级...");
    }
}
//代理者
package generalproxy;

public class GamePlayerProxy implements IGamePlayer {

    private IGamePlayer gamePlayer;
    public GamePlayerProxy(String name){
        try {
            gamePlayer = new GamePlayer(this,name);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @Override
    public void login() {
        this.gamePlayer.login();
    }

    @Override
    public void killBoss() {
        this.gamePlayer.killBoss();
    }

    @Override
    public void upgrade() {
        this.gamePlayer.upgrade();
    }
}
package generalproxy;
/*
* 普通代理：客户端只能访问代理角色，不能访问真实角色。在该模式下，
* 调用者不用知道真实的角色是谁，屏蔽了真实角色的变更对高层的影响。
* */
public class Main {
    public static void main(String[] args){
        IGamePlayer gamePlayer = new GamePlayerProxy("张三");
        gamePlayer.login();
        gamePlayer.killBoss();
        gamePlayer.upgrade();
    }

}

② 强制代理

//公共接口
package forceproxy;

public interface IGamePlayer {
    void login();
    void killBoss();
    void upgrade();
    IGamePlayer getGameProxy();
}

//被代理者
package forceproxy;

public class GamePlayer implements IGamePlayer {
    private String name;
    private IGamePlayer playerProxy;
    public GamePlayer(String name){
        this.name = name;
    }
    @Override
    public void login() {
        if(isProxy()){
            System.out.println(this.name+"登录...");
        }else{
            System.out.println("请使用指定代理访问...");
        }
    }

    @Override
    public void killBoss() {
        if(isProxy()){
            System.out.println(this.name+"打怪...");
        }else{
            System.out.println("请使用指定代理访问...");
        }
    }

    @Override
    public void upgrade() {
        if(isProxy()){
            System.out.println(this.name+"升级...");
        }else{
            System.out.println("请使用指定代理访问...");
        }
    }

    @Override
    public IGamePlayer getGameProxy() {
        this.playerProxy = new GamePlayerProxy(this);
        return this.playerProxy;
    }

    private boolean isProxy(){
        if(this.playerProxy == null){
            return false;
        }else{
            return true;
        }
    }
}
//代理者
package forceproxy;

public class GamePlayerProxy implements IGamePlayer {
    private IGamePlayer gamePlayer;
    public GamePlayerProxy(IGamePlayer gamePlayer){
        this.gamePlayer = gamePlayer;
    }
    @Override
    public void login() {
        this.gamePlayer.login();
    }

    @Override
    public void killBoss() {
        this.gamePlayer.killBoss();
    }

    @Override
    public void upgrade() {
        this.gamePlayer.upgrade();
    }

    @Override
    public IGamePlayer getGameProxy() {
        return this;
    }
}
package forceproxy;
/*
* 强制代理：必须通过真实角色才能查找到代理角色，否则不能访问。
* 只有通过真实角色指定的代理类才可以访问，也就是说由真实角色管理代理角色。
* */
public class Main {
    public static void main(String[] args){
        IGamePlayer gamePlayer = new GamePlayer("张三");
        IGamePlayer gamePlayerProxy = gamePlayer.getGameProxy();
        gamePlayerProxy.login();
        gamePlayerProxy.killBoss();
        gamePlayerProxy.upgrade();
    }
}

③ 虚拟代理

//公共接口
package virualproxy;

public interface Subject {
    void request();
}
//被代理类
package virualproxy;

public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("真实主题...");
    }
}
//代理类
package virualproxy;

public class Proxy implements Subject {
    private Subject subject;
    @Override
    public void request() {
        if(subject == null){
            subject = new RealSubject();
        }
        subject.request();
    }
}

④ 动态代理

//通知接口
package dynamicproxy;

public interface IAdvice {
    void exec();
}
//主题接口
package dynamicproxy;

public interface Subject {
    void doSomething();
}
//前置通知
package dynamicproxy;

public class BeforeAdvice implements IAdvice {
    @Override
    public void exec() {
        System.out.println("执行前置通知...");
    }
}
//真实主题
package dynamicproxy;

public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("RealSubject do something...");
    }
}
//动态代理Handler类
package dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInvocationHandler implements InvocationHandler {
    private Object obj;
    public MyInvocationHandler(Object obj){
        this.obj = obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        new BeforeAdvice().exec();
        return method.invoke(obj, args);
    }
}
//动态代理类
package dynamicproxy;

import java.lang.reflect.InvocationHandler;

public class SubjectDynamicProxy extends DynamicProxy {

    public static <T> T newProxyInstance(Subject subject){
        ClassLoader classLoader = subject.getClass().getClassLoader();
        Class<?>[] interfaces = subject.getClass().getInterfaces();
        InvocationHandler handler = new MyInvocationHandler(subject);
        return newProxyInstance(classLoader, interfaces, handler);
    }
}
//动态代理场景类
package dynamicproxy;
/*
* 动态代理：动态代理在实现阶段不必关心代理谁，而在运行阶段才指定代理哪个对象。
* 其中invoke方法是接口InvocationHandler定义必须实现的，它完成对真实方法的调用。
* 通过InvocationHandler接口，所有方法都由该Handler来进行处理，即所有被代理的
* 方法都由InvocationHandler接管实际的处理任务。
* */
public class Main {
    public static void main(String[] args){
        Subject subject = new RealSubject();
        Subject proxy = SubjectDynamicProxy.newProxyInstance(subject);
        proxy.doSomething();
    }
}

(7) 原型模式(Prototype Pattern)

//原型类
import java.util.ArrayList;
import java.util.List;

public class Thing implements Cloneable {

    private ArrayList<String> arrayList = new ArrayList<>();
    @Override
    public Thing clone() throws CloneNotSupportedException {
        Thing thing = (Thing)super.clone();
        thing.arrayList = (ArrayList<String> )this.arrayList.clone();
        return thing;
    }
}
/*
* 原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
* */
public class Main {
    public static void main(String[] args){
        Thing thing1 = new Thing();
        try {
            Thing thing2 = thing1.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

(8) 中介者模式(Mediator Pattern)

//通用抽象中介者
public abstract class Mediator {
    private ConcreteColleague1 colleague1;
    private ConcreteColleague2 colleague2;

    public Mediator(){
        colleague1 = new ConcreteColleague1(this);
        colleague2 = new ConcreteColleague2(this);
    }

    public ConcreteColleague1 getColleague1() {
        return colleague1;
    }

    public ConcreteColleague2 getColleague2() {
        return colleague2;
    }
    public abstract void doSomething1();
    public abstract void doSomething2();
}
//通用中介者
public class ConcreteMediator extends Mediator {

    @Override
    public void doSomething1() {
        super.getColleague1().selfMethod();
    }

    @Override
    public void doSomething2() {
        super.getColleague1().selfMethod();
        super.getColleague2().selfMethod();
    }
}

//抽象同事类
public abstract class Colleague {
    protected Mediator mediator;
    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }
}
//具体同事类
public class ConcreteColleague1 extends Colleague {

    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    public  void selfMethod(){
        System.out.println("ConcreteColleague1 do something...");
    }

    public void depMethod(){
        super.mediator.doSomething2();
    }
}
public class ConcreteColleague2 extends Colleague {
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    public void selfMethod(){
        System.out.println("ConcreteColleague2 do something...");
    }
}

(9) 命令模式(Command Pattern)

//抽象命令接收者
 public abstract class  Receiver {
    public abstract void doSomething();
}
//具体命令接收者
public class ConcreteReceiver1 extends Receiver {
    @Override
    public void doSomething() {
        System.out.println("ConcreteReceiver1 do something...");
    }
}
public class ConcreteReceiver2 extends Receiver {
    @Override
    public void doSomething() {
        System.out.println("ConcreteReceiver2 do something...");
    }
}
//抽象命令
public abstract class Command {
    public abstract void execute();
}
//具体命令
public class ConcreteCommand1 extends Command {
    private Receiver receiver;
    public ConcreteCommand1(Receiver receiver){
        this.receiver = receiver;
    }
    @Override
    public void execute() {
        receiver.doSomething();
    }
}
public class ConcreteCommand2 extends Command {
    private Receiver receiver;
    public ConcreteCommand2(Receiver receiver){
        this.receiver = receiver;
    }
    @Override
    public void execute() {
        this.receiver.doSomething();
    }
}
//调用者
public class Invoker {
    private Command command;
    public Invoker(Command command){
        this.command = command;
    }
    public void action(){
        this.command.execute();
    }
}
/*
* 命令模式：一种高内聚模式，将一个请求封装为一个对象，从而让你使用不同的请求把客户端参数化，
* 对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。
* */
public class Main {
    public static void main(String[] args){
        Receiver receiver = new ConcreteReceiver2();
        Command command = new ConcreteCommand1(receiver);
        Invoker invoker = new Invoker(command);
        invoker.action();
    }
}

(10) 责任链模式(Responsibility Chain)

//抽象处理者
public abstract class Handler {
    private Handler nextHandler;
    public final Response handleMessage(Request request){
        Response response = null;
        if(this.getHandlerLevel().equals(request.getLevel())){
            response = this.echo();
        }else{
            if(this.nextHandler != null){
                response =  this.nextHandler.handleMessage(request);
            }else{
                System.out.println("No next handler...");
            }
        }
        return response;
    }
    public void setNextHandler(Handler handler){
        this.nextHandler = handler;
    }
    protected abstract Level getHandlerLevel();
    protected abstract Response echo();
}
//具体处理者
public class ConcreteHandler1 extends Handler {
    @Override
    protected Level getHandlerLevel() {
        return Level.FIRST;
    }

    @Override
    protected Response echo() {
        System.out.println("ConcreteHandler1 echo...");
        return null;
    }
}
public class ConcreteHandler2 extends Handler {
    @Override
    protected Level getHandlerLevel() {
        return Level.SECOND;
    }

    @Override
    protected Response echo() {
        System.out.println("ConcreteHandler2 echo...");
        return null;
    }
}
public class ConcreteHandler3 extends Handler {
    @Override
    protected Level getHandlerLevel() {
        return Level.THREE;
    }

    @Override
    protected Response echo() {
        System.out.println("ConcreteHandler3 echo...");
        return null;
    }
}
//模式中的有关框架代码
public enum Level {
    FIRST,SECOND,THREE;
}
public class Request {
    private Level level;

    public Level getLevel() {
        return level;
    }

    public void setLevel(Level level) {
        this.level = level;
    }
}
public class Response {

    private String code;
    private String message;
    private String content;

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }


}
//场景类
public class Client {

    public Response echoRequest(Request request){
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();
        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);
        return handler1.handleMessage(request);
    }
}
/*
* 责任链模式：使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合的关系。
* 将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。
* */
public class Main {
    public static void main(String[] args){
        Request request = new Request();
        request.setLevel(Level.THREE);
        new Client().echoRequest(request);
    }
}

(11) 装饰模式(Decorator Pattern)

//抽象构件
public abstract class Component {
    public abstract void operate();
}
//具体构件
public class ConcreteComponent extends Component {
    @Override
    public void operate() {
        System.out.println("ConcreteComponent do something...");
    }
}
//抽象装饰者
public abstract class Decorator extends Component{
    private Component component;
    public Decorator(Component component){
        this.component = component;
    }
    @Override
    public void operate(){
        this.component.operate();
    }
}
//具体装饰者
public class ConcreteDecorator1 extends Decorator {
    public ConcreteDecorator1(Component component) {
        super(component);
    }
    @Override
    public void operate(){
        super.operate();
        operate1();
    }
    private void operate1(){
        System.out.println("ConcreteDecorator1 do something...");
    }
}
public class ConcreteDecorator2 extends Decorator {
    public ConcreteDecorator2(Component component) {
        super(component);
    }
    @Override
    public void operate(){
        super.operate();
        operate1();
    }
    private void operate1(){
        System.out.println("ConcreteDecorator2 do something...");
    }
}
/*
* 装饰模式：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活。
* */
public class Main {
    public static void main(String[] args){
        Component component = new ConcreteComponent();
        component = new ConcreteDecorator1(component);
        component = new ConcreteDecorator2(component);
        component.operate();
    }
}

(14) 策略模式(Strategy Pattern)

① 普通策略模式

//抽象的策略模式
public interface Strategy {
    void doSomething();
}
//具体策略模式
public class ConcreteStrategy1 implements Strategy {
    @Override
    public void doSomething() {
        System.out.println("ConcreteStrategy1 do something...");
    }
}
public class ConcreteStrategy2 implements Strategy {
    @Override
    public void doSomething() {
        System.out.println("ConcreteStrategy2 do something...");
    }
}
//具体角色
public class Context {
    private Strategy strategy;
    public Context(Strategy strategy){
        this.strategy = strategy;
    }
    public void doAnything(){
        strategy.doSomething();
    }
}
/*
* 策略模式：定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。
* */
public class Main {
    public static void main(String[] args){
        Strategy strategy = new ConcreteStrategy1();
        Context context = new Context(strategy);
        context.doAnything();
    }
}

② 枚举策略模式

public enum Calculator {

    ADD("+"){
        public int exec(int a,int b){
            return a + b;
        }
    },
    SUB("-"){
       public int exec(int a,int b){
           return a - b;
       }
    };
    private String value;
    Calculator(String value){
        this.value = value;
    }

    public abstract int exec(int a,int b);
}

(13) 适配器模式

① 对象适配器

//用户信息接口
package objectadapter;

import java.util.Map;

public interface IUserInfo {
    Map getUserInfo();
}
//家庭信息接口
package objectadapter;

import java.util.Map;

public interface IOuterUserHomeInfo {
    Map getUserHomeInfo();
}
//基本信息接口
package objectadapter;

import java.util.Map;

public interface IOuterUserBaseInfo {
    Map getUserBaseInfo();
}
//基本信息
package objectadapter;

import java.util.Map;

public class OuterUserBaseInfo implements IOuterUserBaseInfo {
    @Override
    public Map getUserBaseInfo() {
        return null;
    }
}
//家庭信息
package objectadapter;

import java.util.Map;

public class OuterUserHomeInfo implements IOuterUserHomeInfo {
    @Override
    public Map getUserHomeInfo() {
        return null;
    }
}
//用户信息
package objectadapter;

import java.util.Map;

public class OuterUserInfo implements IUserInfo{
    IOuterUserHomeInfo outerUserHomeInfo;
    IOuterUserBaseInfo outerUserBaseInfo;
    public OuterUserInfo(IOuterUserHomeInfo outerUserHomeInfo, IOuterUserBaseInfo outerUserBaseInfo){
        this.outerUserBaseInfo = outerUserBaseInfo;
        this.outerUserHomeInfo = outerUserHomeInfo;
    }

    @Override
    public Map getUserInfo() {
        return null;
    }
}
package objectadapter;
/*
* 对象适配器：把原有的继承关系变为关联关系，类适配器是类间继承，对象适配器是对象的合成关系。
*
* */
public class Main {
    public static void main(String[] args){

    }
}

② 类适配器

//目标角色
package classadapter;

public interface Target {
    void doSomething();
}
//目标角色实现类
package classadapter;

public class ConcreteTarget implements Target {
    @Override
    public void doSomething() {
        System.out.println("ConcreteTarget do something...");
    }
}
//源角色
package classadapter;

public class Adaptee {
    public void request(){
        System.out.println("Adaptee do something...");
    }
}
//适配器角色
package classadapter;

public class Adapter extends Adaptee implements Target {
    @Override
    public void doSomething() {
        super.request();
    }
}

//被适配类
package classadapter;

public class Adaptee {
    public void request(){
        System.out.println("Adaptee do something...");
    }
}
//场景类
package classadapter;
/*
*类适配器：将一个类的接口变换成客户端所期待的另一种接口，
* 从而使原本因接口不匹配而无法在一起工作的两个类可以一起工作。
* */
public class Main {

    public static void main(String[] args){
        Target target = new Adapter();
        target.doSomething();
    }
}

(14) 迭代器模式(Iterator Pattern)

//抽象迭代器
public interface Iterator<T> {
    T next();
    boolean hasNext();
    boolean remove();
}
//具体迭代器
import java.util.List;

public class ConcreteIterator<T> implements Iterator<T>{
    private List<T> list;
    private int cursor = 0;
    public ConcreteIterator(List<T> list){
        this.list = list;
    }
    @Override
    public T next() {
        T result;
        if(this.hasNext()){
            result = this.list.get(this.cursor++);
        }else{
            result = null;
        }
        return result;
    }

    @Override
    public boolean hasNext() {
        if(this.cursor == this.list.size()){
            return false;
        }else{
            return true;
        }
    }

    @Override
    public boolean remove() {
        this.list.remove(this.cursor);
        return true;
    }
}
//抽象容器
public interface Aggregate<T> {
    void  add(T t);
    void remove(T t);
    Iterator<T> iterator();
}
//具体容器
import java.util.ArrayList;
import java.util.List;

public class ConcreteAggregate<T> implements Aggregate<T>{
    private List<T> list = new ArrayList<>();
    @Override
    public  void  add(T t) {
        this.list.add(t);
    }

    @Override
    public void remove(T t) {
        this.remove(t);
    }

    @Override
    public Iterator<T> iterator() {
        return new ConcreteIterator(this.list);
    }
}
/*
* 迭代器模式：提供一种方法访问一个容器对象中各个元素，而不需要暴露该对象的内部细节。
* */
public class Main {
    public static void main(String[] args){
        Aggregate<Integer> aggregate = new ConcreteAggregate();
        aggregate.add(1);
        aggregate.add(2);
        aggregate.add(3);
        Iterator iterator = aggregate.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

(15) 组合模式(Composite Pattern)

//抽象构件
public abstract class Component {
    public void doSomething(){
        System.out.println("Component do something...");
    }
}
//树枝构件
import java.util.ArrayList;
import java.util.List;

public class Composite extends Component {
    private List<Component> componentList = new ArrayList<>();
    public void add(Component component){
        this.componentList.add(component);
    }
    public void remove(Component component){
        this.componentList.remove(component);
    }
    public List<Component> getChildren(){
        return this.componentList;
    }
}
//叶子构件
public class Leaf extends Component {

    @Override
    public void doSomething(){
        System.out.println("Leaf do something...");
    }
}
/*
* 组合模式：将对象组合成树型结构以表示“部分—整体”的层次结构，
* 使得用户对单个对象和组合对象的使用具有一致性。
* */
public class Main {
    public static void main(String[] args){
        Composite root = new Composite();
        Composite branch = new Composite();
        root.add(branch);
        Leaf leaf = new Leaf();
        branch.add(leaf);
        disPlay(root);
    }

    public static void disPlay(Composite root){
        for(Component c : root.getChildren()){
            if(c instanceof Leaf){
                c.doSomething();
            }else{
                disPlay((Composite) c);
            }
        }
    }

}

(16) 观察者模式(Observer Pattern)

//被观察者
import java.util.ArrayList;
import java.util.List;

public abstract class Subject {
    List<Observer> observerList = new ArrayList<>();
    public void addObserver(Observer observer){
        this.observerList.add(observer);
    }
    public void removeObserver(Observer observer){
        this.observerList.remove(observer);
    }
    public void notifyObservers(){
        for(Observer observer : observerList){
            observer.update();
        }
    }
}
//具体被观察者
public class ConcreteSubject extends Subject {
    public void doSomething(){
        System.out.println("ConcreteSubject do something...");
        super.notifyObservers();
    }
}
//观察者
public interface Observer {
    void update();
}
//具体观察者
public class ConcreteObserver implements Observer {
    @Override
    public void update() {
        System.out.println("Notice has been received...");
    }
}
/*
* 观察者模式(发布订阅模式)：定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，
* 则所有依赖于它的对象都会得到通知并被自动更新。
* */
public class Main {
    public static void main(String[] args){
        ConcreteSubject subject = new ConcreteSubject();
        Observer observer = new ConcreteObserver();
        subject.addObserver(observer);
        subject .doSomething();
    }
}

(17) 门面模式(Facade Pattern)

//子系统
public class ClassA {
    public void doSomething(){
        System.out.println("ClassA do something...");
    }
}
public class ClassB {
    public void doSomething(){
        System.out.println("ClassB do something...");
    }
}
public class ClassC {
    public void doSomething(){
        System.out.println("ClassC do something...");
    }
}
//门面对象
public class Facade {
    private ClassA a = new ClassA();
    private ClassB b = new ClassB();
    private ClassC c = new ClassC();

    public void methodA(){
        this.a.doSomething();
    }
    public void methodB(){
        this.b.doSomething();
    }
    public void methodC(){
        this.c.doSomething();
    }
}
/*
* 门面模式：要求一个子系统的外部与其内部的通信必须通过一个统一的对象进行，
* 门面模式提供一个高层次的接口，使得子系统更易于使用。
* */
public class Main {
    public static void main(String[] args){
        Facade facade = new Facade();
        facade.methodA();
    }
}

(18) 备忘录模式(Memento Pattern)

①一般备忘录模式

//发起人角色
package general;

public class Originator {
    private String state = "";
    public String getState() {
        return state;
    }
    public void setState(String state){
        this.state = state;
    }
    public Memento createMemento(){
        return new Memento(this.state);
    }
    public void restoreMemento(Memento memento){
        this.setState(memento.getState());
    }
}
//备忘录角色
package general;

public class Memento {
    private String state;
    public Memento(String state){
        this.state = state;
    }
    public String getState(){
        return this.state;
    }
    public void setState(String state){
        this.state = state;
    }
}
//备忘录管理员角色
package general;

public class Caretaker {
    private Memento memento;

    public Memento getMemento() {
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}
package general;

/*
* 备忘录模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，
* 这样以后就可以将该对象恢复到原先保存的状态。
* */
public class Main {
    public static void main(String[] args){
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();
        caretaker.setMemento(originator.createMemento());
        originator.restoreMemento(caretaker.getMemento());
    }
}

② 多状态备忘录模式

//发起人角色
package multistatus;

public class Originator {
    private String state1;
    private String state2;
    private String state3;
    public String getState1() {
        return state1;
    }

    public void setState1(String state1) {
        this.state1 = state1;
    }

    public String getState2() {
        return state2;
    }

    public void setState2(String state2) {
        this.state2 = state2;
    }

    public String getState3() {
        return state3;
    }

    public void setState3(String state3) {
        this.state3 = state3;
    }
    public Memento getMemento(){
        return new Memento(BeanUtils.backup(this));
    }

    public void restoreMemento(Memento memento){
        BeanUtils.restoreProp(this, memento.getStateMap());
    }

}
//BeanUtils工具类
package multistatus;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.HashMap;

public class BeanUtils {
    public static HashMap<String, Object> backup(Object bean){
        HashMap<String, Object> result = new HashMap<>();
        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
            PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
            for(PropertyDescriptor descriptor: descriptors){
                String fieldName = descriptor.getName();
                Method getter = descriptor.getReadMethod();
                Object value = getter.invoke(bean, new Object[]{});
                if(!fieldName.equalsIgnoreCase("class")){
                        result.put(fieldName, value);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    public static void restoreProp(Object bean, HashMap<String, Object> propMap){
        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
            PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
            for(PropertyDescriptor descriptor: descriptors){
                String fieldName = descriptor.getName();
                if(propMap.containsKey(fieldName)){
                    Method setter = descriptor.getWriteMethod();
                    setter.invoke(bean, propMap.get(fieldName));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//备忘录角色
package multistatus;

import java.util.HashMap;

public class Memento {
    private HashMap<String, Object> stateMap;
    public Memento(HashMap<String, Object> stateMap){
        this.stateMap = stateMap;
    }
    public HashMap<String, Object> getStateMap(){
        return this.stateMap;
    }
    public void setStateMap(HashMap<String, Object> stateMap){
        this.stateMap = stateMap;
    }
}
//场景类
package multistatus;

public class Main {
    public static void main(String[] args){
        Originator originator = new Originator();
        Memento memento = originator.getMemento();
        originator.restoreMemento(memento);
    }
}

③ 克隆方式的备忘录

//发起人
package clone;

public class Originator implements Cloneable{
    private String state = "";
    public String getState() {
        return state;
    }
    public void setState(String state){
        this.state = state;
    }

    @Override
    public Originator clone(){
        try {
            return (Originator) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
    public Originator createMemento(){
        return this.clone();
    }
    public void restoreMemento(Originator originator){
        this.setState(originator.getState());
    }
}
//业务类
package clone;

public class Main {
    public static void main(String[] args){
        Originator originator = new Originator();
        Originator backup = originator.createMemento();
        originator.restoreMemento(backup);
    }
}

(19) 访问者模式(Visitor Pattern)

//抽象元素
public abstract class Element {
    public abstract void doSomething();
    public abstract void accept(IVisitor visitor);
}
//具体元素
public class ConcreteElement1 extends Element {
    @Override
    public void doSomething() {
        System.out.println("ConcreteElement1 do something...");
    }

    @Override
    public void accept(IVisitor visitor) {
        visitor.visit(this);
    }
}
public class ConcreteElement2 extends Element {
    @Override
    public void doSomething() {
        System.out.println("ConcreteElement2 do something...");
    }

    @Override
    public void accept(IVisitor visitor) {
            visitor.visit(this);
    }
}
//抽象访问者
public interface IVisitor {
    void visit(ConcreteElement1 concreteElement1);
    void visit(ConcreteElement2 concreteElement2);
}
//具体访问者
public class Visitor implements IVisitor {
    @Override
    public void visit(ConcreteElement1 concreteElement1) {
        concreteElement1.doSomething();
    }

    @Override
    public void visit(ConcreteElement2 concreteElement2) {
        concreteElement2.doSomething();
    }

}
//结构对象
import java.util.Random;

public class ObjectStructure {
    public static Element createElement(){
        Random random = new Random();
        if(random.nextInt(100) > 50){
            return new ConcreteElement1();
        }else{
            return new ConcreteElement2();
        }
    }
}
/*
* 访问者模式：封装一些作用于某种数据结构中的各元素的操作，它可以在不改变数据结构的前提下
* 定义作用于这些元素的新的操作。
*
* */
public class Main {
    public static void main(String[] args){
        for(int i = 0; i < 10; i++){
            Element el = ObjectStructure.createElement();
            el.accept(new Visitor());
        }
    }
}

(20) 状态模式(State Pattern)

//抽象状态角色
public abstract class State {
    protected Context context;
    public void setContext(Context context){
        this.context = context;
    }
    public abstract void handle1();
    public abstract void handle2();
}
//状态角色
public class ConcreteState1 extends State {
    @Override
    public void handle1() {
        System.out.println("ConcreteState1 do something...");
    }

    @Override
    public void handle2() {
        this.context.setCurrentState(Context.STATE2);
        super.context.handle2();

    }
}
public class ConcreteState2 extends State {
    @Override
    public void handle1() {
        this.context.setCurrentState(Context.STATE1);
        super.context.handle1();
    }

    @Override
    public void handle2() {
        System.out.println("ConcreteState2 do something...");
    }
}
//具体环境角色
public class Context {
    public static final State STATE1 = new ConcreteState1();
    public static final State STATE2 = new ConcreteState2();
    private State currentState;
    public State getCurrentState(){
        return currentState;
    }
    public void setCurrentState(State state){
        this.currentState = state;
        this.currentState.setContext(this);
    }
    public void handle1(){
        this.currentState.handle1();
    }
    public void handle2(){
        this.currentState.handle2();
    }
}
/*
* 状态模式：当一个对象内在状态改变时允许其改变行为，这个对象看起来像是改变了其类。
* */
public class Main {
    public static void main(String[] args){
        Context context = new Context();
        context.setCurrentState(new ConcreteState2());
        context.handle1();
        context.handle2();
    }
}

(21) 解释器模式(Interpreter Pattern)

//环境角色
public class Context {
}
//抽象表达式
public abstract class Expression {
    public Object interpreter(Context ctx){
        return null;
    }
}
//终结符表达式
public class TerminalExpression extends Expression {
    @Override
    public Object interpreter(Context context){
        return null;
    }
}
//非终结符表达式
public class NonterminalExpression extends Expression {
    public NonterminalExpression(Expression... expressions){}

    @Override
    public Object interpreter(Context context){
        return null;
    }
}
import java.util.Stack;

/*
*
* 解释器模式：给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示
* 来解释语言中的句子。
* */
public class Main {
    public static void main(String[] args){
         Context context = new Context();
         //定义一个语法容器，容纳一个具体的表达式，通常为List、Stack等类型
         Stack<Expression> stack = new Stack<>();
         for(;;){
             //进行语法判断产生递归调用
             if(false){
                 break;
             }
         }
         Expression expression = stack.pop();
         expression.interpreter(context);

    }
}

(22) 享元模式(Flyweight Pattern)

//抽象享元角色
public abstract class Flyweight {
    private String intrinsic;
    protected final String  extrinsic;
    public String getIntrinsic() {
        return intrinsic;
    }
    public abstract void operate();
    public void setIntrinsic(String intrinsic) {
        this.intrinsic = intrinsic;
    }
    public Flyweight(String extrinsic){
        this.extrinsic = extrinsic;
    }

}
//具体享元角色
public class ConcreteFlyweight1 extends Flyweight {

    public ConcreteFlyweight1(String extrinsic) {
        super(extrinsic);
    }

    @Override
    public void operate() {

    }
}
public class ConcreteFlyweight2 extends Flyweight{
    public ConcreteFlyweight2(String extrinsic) {
        super(extrinsic);
    }

    @Override
    public void operate() {

    }
}
//享元工厂
public class ConcreteFlyweight2 extends Flyweight{
    public ConcreteFlyweight2(String extrinsic) {
        super(extrinsic);
    }

    @Override
    public void operate() {

    }
}
/*
* 享元模式：使用共享对象可有效地支持大量的细粒度对象。
* */
public class Main {
    public static void main(String[] args){

    }
}

(23) 桥梁模式(Bridge Pattern)

//实现化角色
public interface Implementor {
     void doSomething();
     void doAnything();
}
//具体实现化角色
public class ConcreteImplementor1 implements Implementor {
    @Override
    public void doSomething() {
        System.out.println("ConcreteImplementor1 do something...");
    }

    @Override
    public void doAnything() {
        System.out.println("ConcreteImplementor1 do anything...");
    }
}
public class ConcreteImplementor2 implements Implementor {
    @Override
    public void doSomething() {
        System.out.println("ConcreteImplementor2 do something...");
    }

    @Override
    public void doAnything() {
        System.out.println("ConcreteImplementor2 do anything...");
    }
}
//抽象化角色
public abstract class Abstraction {
    private Implementor imp;
    public Abstraction(Implementor imp){
        this.imp = imp;
    }
    public void request(){
        this.imp.doAnything();
    }
    public Implementor getImp(){
        return imp;
    }
}
//具体抽象化角色
public class RefinedAbstraction extends Abstraction {
    public RefinedAbstraction(Implementor imp) {
        super(imp);
    }
    @Override
    public void request(){
        /*
        * 业务逻辑
        * */
        super.request();
        super.getImp().doAnything();
    }
}
/*
* 桥梁模式(桥接模式)：将抽象和实现解耦，使得两者可以独立地变化。
* */
public class Main {
    public static void main(String[] args){
        Implementor imp = new ConcreteImplementor1();
        Abstraction abs = new RefinedAbstraction(imp);
        abs.request();
    }
}