设计模式自学笔记006_Real（责任链设计模式、模板方法设计模式、享元设计模式）

设计模式自学笔记006_Real（责任链设计模式、模板方法设计模式、享元设计模式）

一、责任链设计模式

为请求创建一个接收者对象的链，这种模式对请求的发送者和接收者进行解耦。通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么他就会把相同的请求传给下一个接收者，以此类推。

那么假设现在有公司要采购办公椅，负责人是张三，他将采购计划报给自己的主管，主管以看数目太大不能自作主张，就提交给了老板，让老板决定是否购买。代码实现如下：

//接收链条的抽象类
public abstract class Handler {
    protected Handler nextHandler;
    public void setNextHandler(Handler nextHandler){
        this.nextHandler = nextHandler;
    }
    public abstract void process(Integer info);
}
//Leader类
public class Leader extends Handler{
    @Override
    public void process(Integer info) {
        if(info > 0 && info < 20000){
            System.out.println("Leader处理，批准采购计划");
        }else{
            nextHandler.process(info);
        }
    }
}
//Boss类
public class Boss extends Handler{
    @Override
    public void process(Integer info) {
        System.out.println("Boss处理，批准采购计划");
    }
}

//应用
public class ChainResponsibility {
    public static void main(String[] args) {
        Handler leader = new Leader();
        Handler boss = new Boss();
        leader.setNextHandler(boss);
        leader.process(30000);
        leader.process(10000);
    }
}
输出结果：
Boss处理，批准采购计划
Leader处理，批准采购计划

优点就是将请求和处理分开，请求者不需要知道谁去处理，矗立着也不需要知道请求者的全貌，并且可以提高系统的灵活性。但是缺点就是会增加系统的负担，每一次请求都要讲整个链条走一遍，不能越级请求。

二、模板方法模式

在程序设计中，有的一组程序需要按照固定的步骤运行，但是步骤的内容会有不同，相当于有一套固定的模板，梅一段程序套用固定的模板，根据自身的需求来实现不同的内容。

模板方法模式是建立一个模板抽象类，里面有每个步骤的抽象方法，然后最重要的有一个模板方法，里面每一个步骤都按照顺序进行，并且还有一些固定不变的其他程序，然后当我们在使用的时候，新建类，然后继承该模板抽象类，重写其中的每一个步骤随营的方法，然后调用抽象类中的模板方法就可以实现我们需要的功能。代码实现如下：

public class TempleDesignPattern1 {
    public static void main(String[] args) {
        Temple function = new Function();
        function.TempleFun();
    }
}

abstract class Temple{
    public abstract void Step1();
    public abstract void Step2();
    public abstract void Step3();
    public void TempleFun(){
        System.out.println("程序开始");
        System.out.println("不需要改变的代码");
        Step1();
        Step2();
        Step3();
        System.out.println("不需要改变的代码");
        System.out.println("程序结束");
    }
}

class Function extends Temple{
    @Override
    public void Step1() {
        System.out.println("步骤1");
    }

    @Override
    public void Step2() {
        System.out.println("步骤2");
    }

    @Override
    public void Step3() {
        System.out.println("步骤3");
    }
}
输出结果：
程序开始
不需要改变的代码
步骤1
步骤2
步骤3
不需要改变的代码
程序结束

三、享元设计模式

享元，即共享单元，类似于共享经济的概念，程序运行的时候往往会有一些对象需要重复利用，而且相同类型的对象可能内容不同，被其他程序反复利用，如果每次都重新创建实例化对象就太浪费资源了，那么我们可以使用享元设计模式，建立一个共享单元，里面事先创建一些需要用到的对象，然后共享给其他程序使用，而且事先创建的对象在同一时间只能被一个进程所拥有。

那么我们来举一个共享单车的例子，假设现在又两辆共享单车，有三个人想骑车，那么张三骑一辆，王五骑一辆，赵四只能在另两个人中一个人还车之后才能骑到自行车。代码如下：

public abstract class BikeFlyWeight {
    //内部状态
    protected Integer state = 0; //0表示自行车没人骑，1表示自行车有人骑

    //userName外部状态
    abstract void ride(String userName);
    abstract void back(); //还车

    public Integer getState(){
        return state;
    }
}

public class MoBikeFlyWeight extends BikeFlyWeight{
    //定义新的额内部状态，车架号
    private String bikeID;

    public MoBikeFlyWeight(String bikeID) {
        this.bikeID = bikeID;
    }
    //骑车
    @Override
    void ride(String userName) {
        state = 1;
        System.out.println(userName + "正在骑"+bikeID+"号自行车");
    }
    //还车
    @Override
    void back() {
        state = 0;
    }
}

public class BikeFlyWeightFactory {
    private static BikeFlyWeightFactory instance = new BikeFlyWeightFactory();
    private Set<BikeFlyWeight> pool = new HashSet<>();

    public static BikeFlyWeightFactory getInstance(){
        return instance;
    }

    private BikeFlyWeightFactory(){
        for(int i = 0; i < 2; i++){
            pool.add(new MoBikeFlyWeight(i+""));
        }
    }
    public BikeFlyWeight getBike(){
        for(BikeFlyWeight bike : pool){
            if(bike.getState() == 0) {
                return bike;
            }
        }
        return null;
    }
}

public class FlyWeightDesign01 {
    public static void main(String[] args) {
        BikeFlyWeight bike1 = BikeFlyWeightFactory.getInstance().getBike();
        bike1.ride("张三");

        BikeFlyWeight bike2 = BikeFlyWeightFactory.getInstance().getBike();
        bike2.ride("王五");
        bike2.back();

        BikeFlyWeight bike3 = BikeFlyWeightFactory.getInstance().getBike();
        bike3.ride("赵四");

        System.out.println(bike1 == bike2);
        System.out.println(bike2 == bike3);

    }
}

（1）享元设计模式也叫做蝇量设计模式，运用共享技术有效的 支持大量细粒度的对象。
（2）常用于系统底层开发，解决系统的性能问题，像数据库连接池，里面都是创建好的连接对象，在这些连接对象中有我们需要的则直接拿来使用，避免重新创建，如果没有我们需要的，则创建一个
（3）享元模式能够解决重复对象的内存浪费问题。当系统中有大量相似对象，需要缓冲池的时候，不需要创建新的对象，可以从缓冲池里面直接拿，这样就可以降低系统的内存，同时提高效率。
（4）享元设计模式典型的应用就是各种池技术，String常量池，数据库连接池，缓冲等都是享元模式的应用，享元模式是池技术的重要实现方式。