一、单例模式
一般有八种写法，这里简单记录一下思路，首先单例需要构造器是private，然后一般有个static方法获得这个类的实例。
饿汉式：
所谓饿汉式其实应该是相对于懒汉式，懒汉式就是当你用到这个类的时候，才初始化实例并给你，所以这个饿汉式就是在类加载的时候就初始化了这个对象，所以有两种方法，一种是
private final static Singleton INSTANCE = new Singleton(); public static Singleton getInstance(){ return INSTANCE; }
还有就是利用static块，
private static Singleton instance; static { instance = new Singleton(); } public static Singleton getInstance() { return instance; }
懒汉就是要用到的时候，才去初始化或者说new这个对象。
这就有线程安全的问题了，所以懒汉这里有
线程不安全的情况；
线程安全getInstance同步方法的情况；
采用同步块，只判断一次instance==null所以还是线程不安全的情况；
采用同步块但双重检查的情况；
然后还有两种分别是静态内部类和枚举的写法。
静态内部类：
public class Singleton { private Singleton() {} private static class SingletonInstance { private static final Singleton INSTANCE = new Singleton(); } public static Singleton getInstance() { return SingletonInstance.INSTANCE; } }
种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
枚举：
public enum Singleton { INSTANCE; public void whateverMethod() { } }
单例模式的写法可以参考：https://www.cnblogs.com/zhaoyan001/p/6365064.html——《单例模式的八种写法比较 》
二、工厂模式
有三种，简单工厂模式，工厂模式，抽象工厂模式。
简单工厂模式：
1. 产品有个接口。
2. 有一个工厂类，提供这个接口的产品。
常见模式就是，工厂类一个switch块，有个方法根据你传进去的String值来返回相应的产品实例。
public interface Product { } public class easyProductFactory { public static Product getProduct(String name) { switch(name) { case "xxx": return new ProductImplA(); ....... } } }
但这种版本的话，如果你传进去的字符串出错了，就得不到正确的产品，所以有个改良版的，其实就是把switch改成直接调用一个getXXXProduct的方法
public class EasyProductFactory { public Product getAProduct() { return new ProductAImpl(); } } //用的时候就easyProductFactory.getAProduct();
还有个改版就：静态方法版的：
public class EasyProductFactory { public static Product getProductA(){ return new productAImpl(); } } //用的时候不用new工厂类了，直接EasyProductFactory.getProductA()；就好
然后是工厂方法模式或者说是工厂模式
1. 有个产品接口
2. 有个工厂接口
工厂方法模式是对简单工厂模式进一步的解耦，因为在工厂方法模式中是一个子类对应一个工厂类，而这些工厂类都实现于一个抽象接口。这相当于是把原本会因为业务代码而庞大的简单工厂类，拆分成了一个个的工厂类，这样代码就不会都耦合在同一个类里了。
所以其实就从原来的单一的一个生产产品的固定类，变成了一个或者多个实现了Factory接口的工厂是实现类那样咯。
抽象工厂方法
1. 有大于等于一类个产品接口
2. 有个工厂接口
3. 工厂接口中提供不止一种产品
就为什么要有这个抽象工厂呢，就之前的情况呢，一个Product接口是可以抽象出所有的产品的共性的，但如果不能的话，或者说我们需要多个产品的话，就要用这个模式了。
比如说水果接口和玩具接口，这就是两个完全不同的产品了，你无法只用一个Product来抽象吧，那么这个时候的大概形式就是：
public interface Fruit { } public interface Toy { } public interface ProductFactory { Fruit getFruit(); Tou getToy(); } //然后再分别有水果的实现类，玩具的实现类还有工厂的实现类，工厂的实现类需要提供两种产品。
工厂模式的例子或者说是说明可以参考这两篇文章：
https://www.cnblogs.com/zailushang1996/p/8601808.html——《java 三种工厂模式 》
https://blog.csdn.net/u012156116/article/details/80857255——《简单工厂模式、工厂模式以及抽象工厂模式（具体）》这个可以只看它对抽象工厂模式的介绍
三、模板方法模式
一般就是有个抽象类，里面有很多可以重用的方法，你不想实现那么多次，就把它都放在抽象的父类中，然后留下几个protected的abstract方法或者是普通的方法给子类去实现。
比如一个JDBC的实现，如果每个请求都完整走一遍的话，你会发现有很多的代码都是重复写的。
我们先来看看使用JDBC操作数据库需要经过哪些步骤：
1. 获取数据库连接
2. 通过数据库连接得到Statement对象
3. 使用Statement对象进行增删改查
4. 处理异常
5. 关闭连接释放资源
我们再来区分一下这些步骤中，哪些是可变部分，哪些是不可变部分：
1. 获取数据库连接（不可变）
2. 通过数据库连接得到Statement对象（不可变）
3. 使用Statement对象进行增删改查（可变）
4. 处理异常（不可变）
5. 关闭连接释放资源（不可变）
我们可以看到，在5个步骤中，4个是不可变的，只有一个步骤是可变的
所以我们其实可以用一个模板abstract类来封装这些不变的方法，然后JDBC具体的类就继承这个模板类，重写CRUD方法就好了。
典型的模板方法设计模式还有：
HttpServlet中的doGet、doPost方法；
Lock的底层实现AQS也就是抽象队列同步器。
四、观察者模式
定义：
在对象之间定义了一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象会收到通知并自动更新。
说人话就是：
其实就是发布订阅模式，发布者发布信息，订阅者获取信息，订阅了就能收到信息，没订阅就收不到信息。
这个模式的一个结构图：
可以看到，该模式包含四个角色
- 抽象被观察者角色：也就是一个抽象主题，它把所有对观察者对象的引用保存在一个集合中，每个主题都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。
- 抽象观察者角色：为所有的具体观察者定义一个接口，在得到主题通知时更新自己。
- 具体被观察者角色：也就是一个具体的主题，在集体主题的内部状态改变时，所有登记过的观察者发出通知。
- 具体观察者角色：实现抽象观察者角色所需要的更新接口，一边使本身的状态与制图的状态相协调。
可以类比一个微信公众服务号，不定时发布一些消息，关注公众号就可以收到推送消息，取消关注就收不到推送消息。
具体的例子和代码见博客：https://www.cnblogs.com/luohanguo/p/7825656.html——《JAVA设计模式之观察者模式 》
五、装饰器模式和代理模式
先主要讲一下装饰器模式的思路吧。
装饰器模式，顾名思义，就是对已经存在的某些类进行装饰，以此来扩展一些功能。
一个很简单的例子就是，咖啡，牛奶咖啡，牛奶咖啡加冰块。
一般的样子就是：
- 有个接口，比如饮料接口Drink
- 然后有个接口的实现类，比如Coffee
- 然后有个抽象类也去实现Drink接口，里面维护着一个被装饰的类的对象，像Coffee coffee。
- 然后是真正实现装饰的类，就上面那个抽象类的子类——这些类在普通的Coffee上装饰了些东西上去
看完会发现，卧槽这东西和代理模式怎么这么像——代理模式，和被代理类实现同一个接口，然后就可以代替被代理类去接受用户的请求，而代理类里面是包装着真正类的，在调用真正类的某个请求方法的过程中，可以另外做点其他的事情。
那么这两者有什么区别呢？其实我觉得大体上是差不多的了，要说区别就是思维还有用法，比如这里我们用两种设计模式去做同一件事情——在一个方法调用之前调用before()，调用只有调用after()。
这是个很常见的前置增强和后置增强，所以代理模式显然就是在代理类中类似这样的代码：
@Override public void sayHello(String name) { before(); greetingImpl.sayHello(name); after(); }
而如果是装饰者模式的话，就是这样的设计结构：
然后用起来是这个样子的：
public static void main(String[] args) { Greeting greeting = new GreetingAfter(new GreetingBefore(new GreetingImpl())); greeting.sayHello("Jack"); }
有没有像我们的IO模型的样子，就这样理解吧hh
关于装饰器模式的介绍可以看——https://blog.csdn.net/smy_0114/article/details/80653127——《设计模式之-装饰器模式》
关于装饰器模式和代理模式的差别，还有上面我的例子的详细代码可以看——https://blog.csdn.net/andong154564667/article/details/80258061——《代理模式和装饰器模式区别》