设计模式的学习笔记（持续更新中……）

构建型模式

工厂模式

简单工厂模式

用switch-case根据传入的type新建不同的对象
	缺点：
1、	如果生产产品过多，会变成超级类，且一个产品的修改都要修改工厂，违背单一职责原则；
2、	如果要增加新产品，要在工厂里添加新的分支，违背了开闭原则，应该避免修改现有类而应该新增类。

工厂方法模式

建多个工厂类分别创建对象，弥补了简单工厂模式的两个缺点
缺点：如果生产产品过多，工厂不会变成超级类，但是工厂类会越来越多，使用者生产不同产品需要使用不同工厂

抽象工厂模式

建一个工厂接口，所有工厂继承该接口，新增的产品工厂也继承该接口，解决了工厂方法模式的缺陷，使用者无需关
心工厂类了，只需要只用工厂接口的方法即可。
缺点：抽象工厂模式比较重，如果要新增工厂接口方法，则所有工厂都要跟着改动，适合横向扩展，不适合纵向扩展

单例模式

饿汉式

变量在声明时直接初始化，getInstance方法直接做调用即可，适合构建简单且使用频率很高的对象。

懒汉式

变量声明为空，调用getInstance方法时才生成，需要用双检锁或者静态内部类来解决线程安全问题，适合构建复
杂，并且使用频率不高的对象。

建造者模式

通过Builder和build方法来构造对象，好处是不需要担心忘记某个配置，使整个构造过程的稳定性得到保证。

原型模式

复制一个对象的值给另一个对象，实现Cloneable接口就有java自带的clone方法，需要注意的是默认只会复制基
本类型，引用类型需要重写clone方法。

结构型模式

适配器模式

vo转entity的方法就是适配器模式，通过建立适配器将两个对象实现互转。

桥接模式

在形状接口的实现类里加入颜色接口，就可以实现两个或多个同等级接口间的桥接。

组合模式

透明模式

所有子类需要的方法都写在父类里面，使用者可以一视同仁的调用
缺点：如果子类不含父类的部分方法功能，可能导致程序出错，安全性稍差

安全模式

父类只保留公共的方法，各自子类再写各自的功能方法
缺点：不能统一声明为父类了，需要声明为子类，使用上不便利

装饰模式

透明装饰模式（增强功能）

主类和装饰类都继承同一个base接口，装饰类添加主类为属性，透明装饰模式可以无限装饰。

半透明装饰模式（新增功能）

新增装饰器接口继承主接口，装饰类实现装饰器接口并声明主接口、新增装饰（功能）方法，声明时声明为装饰器接
口并传入主对象，主对象即可使用装饰类新增的功能，半透明装饰可以和透明装饰模式共用，但是无论是否共用，都
只能装饰一次。java的IO流就是通过装饰模式实现的。

外观模式

其实就是封装思想，将多个类的方法封装到一个外观类里，实现一行代码可以完成一套组合操作。

享元模式

提高对象的复用性，比如在一个基础对象上加上新属性和新方法变为另一个对象，如各种base类。

代理模式

静态代理

通过新建代理类来实现和原类一模一样的方法，应用场景有打印日志、权限管理等。

动态代理

记住固定写法即可

public class HttpProxy implements InvocationHandler{
	private HttpUtil httpUtil;
	
	public IHttp getInstance(HttpUtil httpUtil){
		this.httpUtil=httpUtil;
		return (IHttp)Proxy.newProxyInstance(httpUtil.getClass().getClassLoader(),httpUtil.getClass().getInterfaces(),this);
	}

	// 调用 httpUtil 的任意方法时，都要通过这个方法调用
	@Ovveride
	public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
		Object result=null;
		if(method.getName().equals(“request”)){
			// 如果方法名是 request，打印日志，并调用 request 方法
			System.out.println(“发送数据：”+args[0]);
			result=method.invoke(httpUtil,args);
		}else if(method.getName().equals(“onSuccess”)){
			// 如果方法名是 onSuccess，打印日志，并调用 onSuccess 方法
			System.out.println(“收到数据：”+args[0]);
			result=method.invoke(httpUtil,args)
		}
		return result;
	}
} 

行为型模式

责任链模式

新建一个程序员抽象类：

public abstract class Programmer {
    protected Programmer next;

    public void setNext(Programmer next) {
        this.next = next;
    }

    abstract void handle(Bug bug);
}

新建菜鸟程序员类：

public class NewbieProgrammer extends Programmer {

    @Override
    public void handle(Bug bug) {
        if (bug.value > 0 && bug.value <= 20) {
            solve(bug);
        } else if (next != null) {
            next.handle(bug);
        }
    }

    private void solve(Bug bug) {
        System.out.println("菜鸟程序员解决了一个难度为 " + bug.value + " 的 bug");
    }
}

新建普通程序员类：

public class NormalProgrammer extends Programmer {

    @Override
    public void handle(Bug bug) {
        if (bug.value > 20 && bug.value <= 50) {
            solve(bug);
        } else if (next != null) {
            next.handle(bug);
        }
    }

    private void solve(Bug bug) {
        System.out.println("普通程序员解决了一个难度为 " + bug.value + " 的 bug");
    }
}

新建优秀程序员类：

public class GoodProgrammer extends Programmer {

    @Override
    public void handle(Bug bug) {
        if (bug.value > 50 && bug.value <= 100) {
            solve(bug);
        } else if (next != null) {
            next.handle(bug);
        }
    }

    private void solve(Bug bug) {
        System.out.println("优秀程序员解决了一个难度为 " + bug.value + " 的 bug");
    }
}

客户端测试：

import org.junit.Test;

public class Client4 {
    @Test
    public void test() {
        NewbieProgrammer newbie = new NewbieProgrammer();
        NormalProgrammer normal = new NormalProgrammer();
        GoodProgrammer good = new GoodProgrammer();

        Bug easy = new Bug(20);
        Bug middle = new Bug(50);
        Bug hard = new Bug(100);

        // 组成责任链
        newbie.setNext(normal);
        normal.setNext(good);

        // 从菜鸟程序员开始，沿着责任链传递
        newbie.handle(easy);
        newbie.handle(middle);
        newbie.handle(hard);
    }
}

在客户端中，我们通过 setNext() 方法将三个程序员组成了一条责任链，由菜鸟程序员接收所有的 bug，发现自
己不能处理的 bug，就传递给普通程序员，普通程序员收到 bug 后，如果发现自己不能解决，则传递给优秀程序
员。

责任链思想在生活中有很多应用，比如假期审批、加薪申请等，在员工提出申请后，从经理开始，由你的经理决定自
己处理或是交由更上一层的经理处理。

再比如处理客户投诉时，从基层的客服人员开始，决定自己回应或是上报给领导，领导再判断是否继续上报。

命令模式

解释器模式

待补充

迭代器模式

待补充

中介者模式

待补充

备忘录模式

待补充

观察者模式

待补充

状态模式

待补充

策略模式

待补充

模板方法模式

待补充

访问者模式

待补充