这里不做详细介绍，而是自己归纳总结的精炼（从代码角度）：
观察着模式：观察者持有订阅者的引用，当观察者察觉到异常的时候，通知自己的持有对象作出相应的动作。
Build模式：真正要构造的类通过一个中间类来实现（真正要构造的类的构造方法入参是这个中间类对象），中间类是静态类，它与真正类的变量一模一样（这样就能将这个中间类的变量一一赋值给真正类的变量），中间类修改变量的方法都是静态的，并且返回自己本身（这样就可以实现链式构造），最后通过一个build()方法去new真正类，并将自己本身当入参传进去，并返回这个真正类。真正类持有这个中间类的对象后，就可以取出这个中间类的对象的变量一一赋值给它自己变量。
好处：由于这个中间类修改变量的方法都是静态的，这样就可以传入你需要的参数，并且代码可读性增强（相比传统的构造方法，入参可能需要你点开去看对应的变量，build模式直接调用方法去赋值，只要方法名适当就可以见名知意）策略模式：最简单的策略模式，if..else..我们将每个if条件抽象成一个具体的类，这些类实现统一的接口，每个类管理自己统一的功能，实现解耦。
-
代理模式
- 静态代理
代理类持有被代理对象，当执行代理对象方法时，可以调用被代理对象的方法，并在被代理对象方法执行前后做一些操作 - 动态代理
上代码：
- 静态代理
public interface IUserService{
void login(String username, String password);
}
public class Test{
public static void main(String[] args){
//动态代理实现方法
IUserService userService = (IUserService) Proxy.newProxyInstance(IUserService.class.getClassLoader(),
new Class[]{IUserService.class},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("method = " + method.getName() +" , args = " + Arrays.toString(args));
return null;
}
});
System.out.println(userService.getClass());
//在调用这个方法时，最后会调用InvocationHandler对象的invoke方法，并将被代理对象的方法及方法参数传进去
userService.login("zhy","123");
}
}
代码中通过动态代理生成的UserService对象其实是一个代理对象：com.sun.proxy.$Proxy0
package com.sun.proxy;
import IUserService;
import java.lang.reflect.*;
public final class $Proxy0 extends Proxy
implements IUserService
{
public $Proxy0(InvocationHandler invocationhandler)
{
super(invocationhandler);
}
public final void login(String s, String s1)
{
//这里的super.h就是InvocationHandler 对象
super.h.invoke(this, m3, new Object[] {
s, s1
});
}
private static Method m3;
static
{
//通过反射得到对应的method
m3 = Class.forName("IUserService").getMethod("login", new Class[] {
Class.forName("java.lang.String"), Class.forName("java.lang.String")
});
}
}
