参考

https://www.cnblogs.com/chenpi/p/5222597.html
http://www.hollischuang.com/archives/1401
http://wiki.jikexueyuan.com/project/java-design-pattern/singleton-pattern.html
https://blog.csdn.net/hguisu/article/details/7533759
https://www.cnblogs.com/qifengshi/p/6566752.html
https://blog.csdn.net/zhengzhb/article/details/7471978

分类及使用排序

创建型模式（5）

工厂方法模式：★★★★★

image.png

服务端

//工厂接口
public interface IFactory {
    Operation CreateOption();
}

//加法类工厂
public class AddFactory implements IFactory {

    public Operation CreateOption() {
        return new OperationAdd();
    }
}

//除法类工厂
public class DivFactory implements IFactory {

    public Operation CreateOption() {
        return new OperationDiv();
    }
}

//除法类工厂
public class MulFactory implements IFactory {

    public Operation CreateOption() {
        return new OperationMul();
    }
}

//减法类工厂
public class SubFactory implements IFactory {

    public Operation CreateOption() {
        return new OperationSub();
    }
}

客户端

public class Main {
    public static void main(String[] args) {
        IFactory factory = new AddFactory();
        Operation operationAdd =  factory.CreateOption();
        operationAdd.setValue1(10);
        operationAdd.setValue2(5);
        System.out.println(operationAdd.getResult());
    }
}

抽象工厂模式：★★★★★
抽象工厂模式较工厂模式的不同在于工厂模式只实现一个方法，抽象工厂集合了一些方法。
抽象工厂模式提供了一种方式，可以将同一产品族的单独的工厂封装起来。在正常使用中，客户端程序需要创建抽象工厂的具体实现，然后使用抽象工厂作为接口来创建这一主题的具体对象。客户端程序不需要知道（或关心）它从这些内部的工厂方法中获得对象的具体类型，因为客户端程序仅使用这些对象的通用接口。抽象工厂模式将一组对象的实现细节与他们的一般使用分离开来。
抽象工厂模式和工厂方法模式一样，都符合开放-封闭原则。但是不同的是，工厂方法模式在增加一个具体产品的时候，都要增加对应的工厂。但是抽象工厂模式只有在新增一个类型的具体产品时才需要新增工厂。也就是说，工厂方法模式的一个工厂只能创建一个具体产品。而抽象工厂模式的一个工厂可以创建属于一类类型的多种具体产品。工厂创建产品的个数介于简单工厂模式和工厂方法模式之间。

抽象产品

public interface BenzCar {
    //加汽油
    public void gasUp();
}
public interface TeslaCar {
    //充电
    public void charge();
}

下面是具体产品，奔驰跑车、奔驰商务车、特斯拉跑车、特斯拉商务车：

public class BenzSportCar implements BenzCar {
    public void gasUp() {
        System.out.println("给我的奔驰跑车加最好的汽油");
    }
}

public class BenzBusinessCar implements BenzCar{
    public void gasUp() {
        System.out.println("给我的奔驰商务车加一般的汽油");
    }
}

public class TeslaSportCar implements TeslaCar {
    public void charge() {
        System.out.println("给我特斯拉跑车冲满电");
    }
}

public class TeslaBusinessCar implements TeslaCar {
    public void charge() {
        System.out.println("不用给我特斯拉商务车冲满电");
    }
}

下面是抽象工厂：

public interface CarFactory {

    public BenzCar getBenzCar();
    public TeslaCar getTeslaCar();
}

下面是具体工厂：

public class SportCarFactory implements CarFactory {
    public BenzCar getBenzCar() {
        return new BenzSportCar();
    }
    public TeslaCar getTeslaCar() {
        return new TeslaSportCar();
    }
}
public class BusinessCarFactory implements CarFactory {
    public BenzCar getBenzCar() {
        return new BenzBusinessCar();
    }
    public TeslaCar getTeslaCar() {
        return new TeslaBusinessCar();
    }
}

单例模式：★★★★☆
单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点。通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象。一个最好的方法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法。

image.png

饿汉式单例

    public class Singleton {
        private static Singleton singleton = new Singleton();
        private Singleton(){}
        public static Singleton getInstance(){
            return singleton;
        }
    }

简单工厂模式：★★★★☆ //不属于gof-23
注意：图中依赖应为虚线

image.png

代码

public class OperationFactory {
    public static Operation createOperation(String operation) {
        Operation oper = null;
        switch (operation) {

            case "+":
                oper = new OperationAdd();
                break;

            case "-":
                oper = new OperationSub();
                break;

            case "*":
                oper = new OperationMul();
                break;

            case "/":
                oper = new OperationDiv();
                break;
            default:
                throw new UnsupportedOperationException("不支持该操作");
        }
        return oper;
    }
}

原型模式：★★★☆☆

生成器模式：★★☆☆☆

结构型模式（7）

外观模式：★★★★★
实际上就是为底层的接口再套上一层接口。书本定义：为了系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

image.png

代理模式：★★★★☆
为其他对象提供一种代理以控制对这个对象的访问

image.png

Subject接口的实现

public interface Subject {
    void visit();
}

实现subject的两个类

public class RealSubject implements Subject {

    private String name = "byhieg";
    @Override
    public void visit() {
        System.out.println(name);
    }
}

public class ProxySubject implements Subject{

    private Subject subject;

    public ProxySubject(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void visit() {
        subject.visit();
    }
}

调用

public class Client {

    public static void main(String[] args) {
        ProxySubject subject = new ProxySubject(new RealSubject());
        subject.visit();
    }
}

组合模式：★★★★☆

适配器模式：★★★★☆

桥接模式：★★★☆☆

装饰模式：★★★☆☆

享元模式：★☆☆☆☆

行为型模式（11）

迭代器模式：★★★★★
.NET迭代器实现
IEumerator
迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器来负责，这样既可以做发送不暴露集合的内部结构，又可以让外部代码透明地访问集合内部数据

观察者模式：★★★★★
定义了一种一对多的依赖关系，让多个观察者对象同时监听一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

image.png

四个角色阐述
观察者：从类图中可以看到，类中有一个用来存放观察者对象的Vector容器（之所以使用Vector而不使用List，是因为多线程操作时，Vector在是安全的，而List则是不安全的），这个Vector容器是被观察者类的核心，另外还有三个方法：attach方法是向这个容器中添加观察者对象；detach方法是从容器中移除观察者对象；notify方法是依次调用观察者对象的对应方法。这个角色可以是接口，也可以是抽象类或者具体的类，因为很多情况下会与其他的模式混用，所以使用抽象类的情况比较多。
观察者：观察者角色一般是一个接口，它只有一个update方法，在被观察者状态发生变化时，这个方法就会被触发调用。
具体的被观察者：使用这个角色是为了便于扩展，可以在此角色中定义具体的业务逻辑。
具体的观察者：观察者接口的具体实现，在这个角色中，将定义被观察者对象状态发生变化时所要处理的逻辑。

abstract class Subject {
    private Vector<Observer> obs = new Vector<Observer>();
    
    public void addObserver(Observer obs){
        this.obs.add(obs);
    }
    public void delObserver(Observer obs){
        this.obs.remove(obs);
    }
    protected void notifyObserver(){
        for(Observer o: obs){
            o.update();
        }
    }
    public abstract void doSomething();
}
 
class ConcreteSubject extends Subject {
    public void doSomething(){
        System.out.println("被观察者事件反生");
        this.notifyObserver();
    }
}
interface Observer {
    public void update();
}
class ConcreteObserver1 implements Observer {
    public void update() {
        System.out.println("观察者1收到信息，并进行处理。");
    }
}
class ConcreteObserver2 implements Observer {
    public void update() {
        System.out.println("观察者2收到信息，并进行处理。");
    }
}
 
public class Client {
    public static void main(String[] args){
        Subject sub = new ConcreteSubject();
        sub.addObserver(new ConcreteObserver1()); //添加观察者1
        sub.addObserver(new ConcreteObserver2()); //添加观察者2
        sub.doSomething();
    }
}

命令模式：★★★★☆

策略模式：★★★★☆

模板方法模式：★★★☆☆

责任链模式：★★★☆☆

状态模式：★★★☆☆

备忘录模式：★★☆☆☆

中介者模式：★★☆☆☆

解释器模式：★☆☆☆☆

访问者模式：★☆☆☆☆