2、设计模式
（2.1）六大设计原则
（2.2）创建类模式
（2.3）结构类模式
（2.4）行为类模式

2.1       6大设计原则
单一职责、里氏替换、依赖倒置、接口隔离、迪米特法则（说的是耦合性要低的问题，一个对象应该尽量对其他对象有最少的了解）、开闭原则（对修改关闭，对扩展开发）

2.2       创建类模式(5)

单例模式

工厂模式抽象工厂模式

public class Client {
    public static void main(String[] args) {

    Creator creator = new ConcreteCreator();
    Product product = creator.createProduct(ConcreteProduct1.class);
    /*
         * 继续业务处理
         */
        
    }
}

public class Client {
  public static void main(String[] args) {
    //定义出两个工厂
    AbstractCreator creator1 = new Creator1();
    AbstractCreator creator2 = new Creator2();
    //产生A1对象
    AbstractProductA a1 = creator1.createProductA();
    //产生A2对象
    AbstractProductA a2 = creator2.createProductA();
    //产生B1对象
    AbstractProductB b1 = creator1.createProductB();
    //产生B2对象
    AbstractProductB b2 = creator2.createProductB();
    /*
     * 然后在这里就可以为所欲为了...
     */
  }
}

建造者模式

public class Director {

private Builder builder = new ConcreteProduct();

//构建不同的产品

public Product getAProduct(){

builder.setPart();

/*

* 设置不同的零件，产生不同的产品

*/

return builder.buildProduct();

}

}

原型模式

public class Client {

public static void main(String[] args) {

//产生一个对象

Thing thing = new Thing();

//拷贝一个对象

Thing cloneThing = thing.clone();

}

}

1.2.3       结构类模式（7）

代理模式

public class Proxy implements Subject {

//要代理哪个实现类

private Subject subject = null;

//默认被代理者

public Proxy(){

this.subject = new Proxy();

}

//通过构造函数传递代理者

public Proxy(Object...objects ){

}

//实现接口中定义的方法

public void request() {

this.before();

this.subject.request();

this.after();

}

//预处理

private void before(){

//do something

}

//善后处理

private void after(){

//do something

}

}

适配器模式

public class Client {

public static void main(String[] args) {

//原有的业务逻辑

Target target = new ConcreteTarget();

target.request();

//现在增加了适配器角色后的业务逻辑

Target target2 = new Adapter();

target2.request();

}

}

装饰模式

public class Client {

public static void main(String[] args) {

Component component = new ConcreteComponent();

//第一次修饰

component = new ConcreteDecorator1(component);

//第二次修饰

component = new ConcreteDecorator2(component);

//修饰后运行

component.operate();

}

}

门面模式

public class Facade {

//被委托的对象

private ClassA a = new ClassA();

private ClassB b = new ClassB();

private ClassC c = new ClassC();

//提供给外部访问的方法

public void methodA(){

this.a.doSomethingA();

}

public void methodB(){

this.b.doSomethingB();

}

public void methodC(){

this.c.doSomethingC();

}

}

桥梁模式

组合模式

享元模式

1.2.4       行为类模式（11）

1、责任链模式
将多个对象连成一条链，请求沿着这条链传递，直到有对象处理它为止。链上每个对象都有机会处理这个请求，从而避免了请求的发送者和接受者之间的一对一直接耦合关系。

public class Client {
  public static void main(String[] args) {
    //声明所有的处理节点
    Handler handler1 = new ConcreteHandler1();
    Handler handler2 = new ConcreteHandler2();
    Handler handler3 = new ConcreteHandler3();
    //设置链中的阶段顺序1-->2-->3
    handler1.setNext(handler2);
    handler2.setNext(handler3);
    //提交请求，返回结果
    Response response = handler1.handlerMessage(new Request());
  }
}

命令模式

public class Client {

public static void main(String[] args) {

//首先声明调用者Invoker

Invoker invoker = new Invoker();

//定义接收者

Receiver receiver = new ConcreteReciver1();

//定义一个发送给接收者的命令

Command command = new ConcreteCommand1(receiver);

//把命令交给调用者去执行

invoker.setCommand(command);

invoker.action();

}

}

策略模式

public class Client {

public static void main(String[] args) {

//声明一个具体的策略

Strategy strategy = new ConcreteStrategy1();

//声明上下文对象

Context context = new Context(strategy);

//执行封装后的方法

context.doAnythinig();

}

}

观察者模式
Observer Pattern 也叫发布订阅模式（Publish/subscribe），定义对象间一种一对多的依赖关系，当这个对象改变状态，则所有依赖它的对象都会得到通知并被自动更新（执行相应操作）。

public class Client {
  public static void main(String[] args) {
    //创建一个被观察者
    ConcreteSubject subject = new ConcreteSubject();
    //定义一个观察者
    Observer obs= new ConcreteObserver();
    //观察者观察被观察者
    subject.addObserver(obs);
    //被观察者开始活动了
    subject.doSomething();
  }
}

相关：Tomcat实现中控制组件生命周期的Lifecycle

模板方法模式
抽象父类定义主体执行流程，而由子类去实现这个过程中的单个步骤。
定义一个操作的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法发某些特定步骤。模板方法模式其实很简单，仅仅使用了Java的继承机制

抽象模板类

public abstract class AbstractClass {
  //基本方法
  protected abstract void doSomething();
  //基本方法
  protected abstract void doAnything();
  //模板方法
  public void templateMethod(){
    /*
     * 调用基本方法，完成相关的逻辑
     */
    this.doAnything();
    this.doSomething();
  }
}

具体模板类

public class ConcreteClass1 extends AbstractClass {
  //实现基本方法
  protected void doAnything() {
    //业务逻辑处理
  }
  protected void doSomething() {
    //业务逻辑处理
  }
}
public class ConcreteClass2 extends AbstractClass {
  //实现基本方法
  protected void doAnything() {
    //业务逻辑处理
  }
  protected void doSomething() {
    //业务逻辑处理
  }
}
public class Client {
  public static void main(String[] args) {
    AbstractClass class1 = new ConcreteClass1();
    AbstractClass class2 = new ConcreteClass2();
    //调用模板方法
    class1.templateMethod();
    class2.templateMethod();
  }
}

 SpringMVC中的View设计，使用模板模式
View只定义了接口方法，AbstractView类实现了View中定义的所有方法，并留了一个抽象方法renderMergedOutputModel。越往下面的子类需要实现的功能越少，整个模板已经建立，所以模板模式能加快整个程序的开发进度。
1、封装不变，，扩展可变；提取公共代码，便于维护；行为由父类控制，子类实现。

解释器模式

迭代器模式

中介者模式

备忘录模式

状态模式

当一个对象内在状态改变时允许其改变行为。状态模式的核心是封装，状态的变更引起了行为的变更。

public class Client{
  public static void main(String[] args){
    //定义环境角色
    Context context = new Context();
    //初始化状态
    context.setCurrentState(new ConcreteState1());
    // 执行行为
    context.handle1();
    context.handle2();
  }
}

public class Context{
  //定义状态
  public final static State STATE1 = new ConcreteState1();
  public final static State STATE2 = new ConcreteState2();
  private State currentState;
  
  get方法...
  set方法...
    
  // 行为委托
  public void handle(){
      this.currentState.handle1();
  }
  public void handle2(){
   this.currnetState.handle2();
  }
}

访问这模式