设计模式

一、责任链模式：一个对象在一条链上被多个拦截器拦截处理（拦截器可以选择处理或不处理）。

      请假申请单--->项目经理--->部门经理--->人事部

　　对象                 拦截器1       拦截器2        拦截器3　

【拦截器3】before方法
【拦截器2】before方法
【拦截器1】before方法
 Hello World!
【拦截器1】before方法
【拦截器2】before方法
【拦截器3】before方法

二、观察者模式：多个观察者对象同时监察被观察者的状态，一旦被观察者转态发生变化，会通知所有观察者，并让其自动更新自己。

　  产品 -- 京东、淘宝、唯品会

（1）java.util.Observable ：被观察者继承Observable类

• 此类表示可观察对象或模型视图范例中的“数据”。 它可以被子类化以表示应用程序想要观察到的对象。可观察对象可以有一个或多个观察者。
• 观察者可以是实现接口Observer的任何对象。 在可观察到的实例发生变化setChanged()
  之后，调用Observable的notifyObservers方法的应用程序会使其所有观察者通过调用其update方法通知更改。
• 通知的发送顺序是未指定的。 Observable类中提供的默认实现将以注册感兴趣的顺序通知Observers，但子类可能会更改此顺序，不使用保证的顺序，在单独的线程上发送通知，或者可以保证其子类遵循此顺序，因为它们选择。

　　方法：其他方法查API　

　　　　public void addObserver(Observer o)

　　 　　将一个观察者添加到该对象的观察者组中，前提是它与集合中已有的一些观察者不一样。 未指定通知发送给多个观察者的顺序。 参数 o - 要添加的观察者。 

　　　　public void notifyObservers(Object arg)

　　　　如果该对象发生了变化，由所示hasChanged方法，则通知其所有观察者，并调用clearChanged方法来指示该对象不再改变。每个观察者都有其update方法调用两个参数：这 个可观察对象和arg参数。

　　　　protected void setChanged()：将此Observable对象标记为已更改; hasChanged方法现在将返回true 。

　（2）　public interface Observer ： 当它想要被通知可观察对象的变化时，类可以实现 Observer接口。

　　　　  接口方法：

void update(Observable o,Object arg)

　　　　  每当观察到的对象发生变化时，都会调用此方法。 一个应用程序调用一个Observable对象的notifyObservers方法，让所有对象的观察者通知更改。　  

（3）代码实现

　　1）观察者1：京东商城　

public class JingDongObserver implements Observer{
    @Override
    public void update(Observable o, Object product) {
        String newProduct = (String)product;
        System.out.println("发送新产品"+newProduct+"到京东商城");        
    }
    
}

　　2）观察者2：淘宝商城

public class TaoBaoObserver implements Observer {

    @Override
    public void update(Observable o, Object product) {
        String newProduct = (String)product;
        System.out.println("发送新产品"+newProduct+"到淘宝商城");        
    }

}

　　3）观察者n：可以自己加

　　4）被观察者：只有一个，使用单例模式创建 https://www.cnblogs.com/tangxiao1996/p/7899393.html　

package ObservbleModel;

import static org.hamcrest.CoreMatchers.instanceOf;

import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;

import org.junit.Test;

public class ProductList extends Observable {
    private List<String> productList = null;
    private static ProductList instance;
    
    /*
     * 通过单例模式获取对象，而不是通过new
     * 通过单例模式可以保证系统中，应用该模式的一个类只有一个实例。即一个类只有一个对象实例。
     */
    public static ProductList getInstance() {
        if(instance==null) {
            instance = new ProductList();
            instance.productList = new ArrayList<String>();
        }
        return instance;        
    }
    
    /*
     * 增加观察者
     */
    public void addProductListObserver(Observer observer) {
        this.addObserver(observer);
    }
    
    /*
     * 新增产品
     */
    public void addProduct(String newProduct) {
        productList.add(newProduct);
        System.out.println("新增了产品: "+newProduct);
        //产品改变
        this.setChanged();
        //通知观察者
        this.notifyObservers(newProduct);
    }
    
    @Test
    public void testProductList() {
        ProductList observable = ProductList.getInstance();
        JingDongObserver jingDongObserver = new JingDongObserver();
        TaoBaoObserver taoBaoObserver = new TaoBaoObserver();
        observable.addObserver(jingDongObserver);
        observable.addObserver(taoBaoObserver);
        observable.addProduct("新产品1");
        
    }
}

三、工厂模式

1、概述（原文：https://blog.csdn.net/fmyzc/article/details/79614944） 　　

　　首先，工厂模式是为了解耦：把对象的创建和使用的过程分开。就是Class A 想调用 Class B ，那么A只是调用B的方法，而至于B的实例化，就交给工厂类。

　　其次，工厂模式可以降低代码重复。如果创建对象B的过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。我们可以这些创建对象B的代码放到工厂里统一管理。既减少了重复代码，也方便以后对B的创建过程的修改维护。（当然，我个人觉得也可以把这些创建过程的代码放到类的构造函数里，同样可以降低重复率，而且构造函数本身的作用也是初始化对象。不过，这样也会导致构造函数过于复杂，做的事太多，不符合java 的设计原则。）

　　由于创建过程都由工厂统一管理，所以发生业务逻辑变化，不需要找到所有需要创建B的地方去逐个修正，只需要在工厂里修改即可，降低维护成本。同理，想把所有调用B的地方改成B的子类B1，只需要在对应生产B的工厂中或者工厂的方法中修改其生产的对象为B1即可，而不需要找到所有的new B（）改为new B1()。

　　另外，因为工厂管理了对象的创建逻辑，使用者并不需要知道具体的创建过程，只管使用即可，减少了使用者因为创建逻辑导致的错误。
2、工厂分为普通工厂和抽象工厂，看下面图应该一目了然了：

　　我认为：抽象工厂里面包含了普通工厂

　　

3、代码

//产品类
public class Product {
　　
}
//工厂1对产品的增强
public class ProductFactory1Enhancer extends Product {
    private Product product;
　　 ...
}
//抽象工厂
public interface ProductFactory {
    public Product createProduct(String product);
}
//工厂1
public class ProductFactory1 implements ProductFactory{

    @Override
    public Product createProduct(String productNum) {
        Product product = new ProductFactoryEnhancer();
        return product;
    }

}

四、建造者模式

1、概述：属于对象的创建模式。可以将一个产品的内部属性与产品的生成过程分割开来，从而使一个建造过程生成具体不同的内部属性的产品对象。

2、Builder模式是一种分布构造对象的模式，适合比较复杂的对象创建。

　　例如：票：分为成年人票、儿童票、老人票、军人票、残疾人票..所以要一次构建一个票对象比较麻烦。

3、实现：

　　（1）创建一个配置类对象：用来添加一个个属性（老人、儿童、军人）信息。

　　（2）通过配置类一次性构建一种票

　　（3）通过构造器添加配置类的类对象即可完成票的构建

//配置类
public class TicketHelper {
    public void addAdult(String info) {
        System.out.println("构建成年人票逻辑"+info);
    }    
    public void addChildren(String info) {
        System.out.println("构建儿童票逻辑"+info);
    }
    public void addSoldier(String info) {
        System.out.println("构建军人票逻辑"+info);
    }

}
//构造器
public class TicketBuilder {
    public static Object builder(TicketHelper helper) {
        System.out.println("通过TicketHelper构造票信息");
        return null;
    }
    public static void main(String[] args) {
        TicketHelper helper = new TicketHelper();
        helper.addAdult("xxx");
        helper.addChildren("XXX");
        Object ticket = TicketBuilder.builder(helper);
    }
}