《设计模式之禅》读书笔记（四）

一.原型模式

原型模式（Prototype Pattern）:用原型实例指定创建对象的种类，并且通过拷贝这个原型创建新的对象。

其核心是一个 clone方法，通过该方法进行对象拷贝，java提供一个Cloneable接口来标识这个对象可拷贝。

优点：

1.性能优良，原型模式是在内存二进制流中拷贝，要比直接new一个对象性能好很多；

2.逃避构造函数的约束，直接在内存中拷贝，构造函数是不回执行的

注意：使用原型模式时，引用的成员变量必须满足两个条件才不会拷贝：

1.类的成员变量，而不是方法内的变量；

2.必须是一个可变的引用对象，而不是一个原始类型或不可变对象。

要使用clone方法，类的成员变量上不要增加final关键字

上代码：

public class PrototypePattern {
    /**
     * 基本用法
     */
    public class PrototypeClass implements Cloneable{
        @Override
        public PrototypeClass clone() throws CloneNotSupportedException {
            PrototypeClass prototypeClass =null;
            try{
                prototypeClass =(PrototypeClass)  super.clone();
            }catch (Exception e){
                e.printStackTrace();
            }
            return prototypeClass;
        }
    }
/****************浅拷贝**********************/
    /**
     * 浅拷贝
     */
    public class PrototypeDemo implements Cloneable {
        private ArrayList<String> mArrayList = new ArrayList<>();
        @Override
        public com.sh.lynn.hz.deginpattern.prototype.PrototypeDemo clone() throws CloneNotSupportedException {
            com.sh.lynn.hz.deginpattern.prototype.PrototypeDemo paper =null;
            try{
                paper =(com.sh.lynn.hz.deginpattern.prototype.PrototypeDemo)  super.clone();
            }catch (Exception e){
                e.printStackTrace();
            }
            return paper;
        }
        public void setValue(String text){
            mArrayList.add(text);
        }
        public ArrayList<String> getValue(){
            return   mArrayList;
        }
    }
    /**
     *
     * @return
     */
    public String getCloneText (){
        PrototypeDemo prototypeDemo = new PrototypeDemo();
        prototypeDemo.setValue("Hello!");
        try {
            PrototypeDemo prototypeDemoClone = prototypeDemo.clone();
            prototypeDemoClone.setValue("World!");
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        StringBuffer stringBuffer = new StringBuffer();

        ArrayList<String>  list= prototypeDemo.getValue();
        for (String text:list){
            stringBuffer.append(text+"  ");
        }
        return stringBuffer.toString();
    }
/****************深拷贝**********************/
public class PrototypeDemoDeep implements Cloneable {

    private ArrayList<String> mArrayList = new ArrayList<>();
    @Override
    public com.sh.lynn.hz.deginpattern.prototype.PrototypeDemoDeep clone() throws CloneNotSupportedException {
        com.sh.lynn.hz.deginpattern.prototype.PrototypeDemoDeep paper =null;
        try{
            paper =(com.sh.lynn.hz.deginpattern.prototype.PrototypeDemoDeep)  super.clone();
            paper.mArrayList =(ArrayList<String>)this.mArrayList.clone();
        }catch (Exception e){
            e.printStackTrace();
        }
        return paper;
    }
    public void setValue(String text){
        mArrayList.add(text);
    }
    public ArrayList<String> getValue(){
        return   mArrayList;
    }
}
    /**
     * 深拷贝
     * @return
     */
    public String getCloneTextDeep (){
        PrototypeDemoDeep prototypeDemo = new PrototypeDemoDeep();
        prototypeDemo.setValue("Hello!");
        try {
            PrototypeDemoDeep prototypeDemoClone = prototypeDemo.clone();
            prototypeDemoClone.setValue("World!");
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        StringBuffer stringBuffer = new StringBuffer();

        ArrayList<String>  list= prototypeDemo.getValue();
        for (String text:list){
            stringBuffer.append(text+"  ");
        }
        return stringBuffer.toString();
    }
}

二.中介者模式

定义：用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示相互作用，

从而使其耦合松散，而且可以独立地改变它们之间的交互。

中介者模式的组成部分：

1.Mediator 抽象中介者角色定义统一的接口，用于各同事角色之间的通信。

2.Concrete Mediator 具体中介者角色通过协调各同事角色实现协作行为

3.Colleague 同事角色

每一个同事角色都知道中介者角色，而且与其它的同事角色通信时候，一定通过中介者角色协作。

同事类行为：

（1）.同事类本身行为，比如改变对象本身的状态，处理自己的行为等，自有方法

（2）.必须依赖中介者才能完成的行为，依赖方法

上代码：

//抽象中介者
public abstract class Mediator {
    //定义同事类
    protected ConcreteColleague1 mColleague1;
    protected ConcreteColleague2 mColleague2;

    public ConcreteColleague1 getColleague1() {
        return mColleague1;
    }

    public void setColleague1(ConcreteColleague1 colleague1) {
        mColleague1 = colleague1;
    }

    public ConcreteColleague2 getColleague2() {
        return mColleague2;
    }

    public void setColleague2(ConcreteColleague2 colleague2) {
        mColleague2 = colleague2;
    }
    //中介者模式的业务逻辑
    public abstract void doSomething1();
    public abstract void doSomething2();
}
//具体中介者
public class ConcreteMediator extends Mediator {
    @Override
    public void doSomething1() {
        super.mColleague1.selfMethod1();
        super.mColleague2.selfMethod2();
    }

    @Override
    public void doSomething2() {
        super.mColleague1.selfMethod1();
        super.mColleague2.selfMethod2();
    }
}
//抽象同事类
public abstract class Colleague {
    protected Mediator mMediator;
    public Colleague(Mediator _mediator){
        this.mMediator=_mediator;
    }
}
//同事类
public class ConcreteColleague1 extends Colleague {
    public ConcreteColleague1(Mediator _mediator) {
        super(_mediator);
    }
    //自有方法
    public void selfMethod1(){
        //处理自身业务逻辑
    }
    //依赖方法 dep-method
    public void depMethod1(){
        //处理自己的业务逻辑
        //自己不能处理的业务逻辑，委托中介者处理
        super.mMediator.doSomething1();
    }
}
//同事类
public class ConcreteColleague2 extends Colleague {
    public ConcreteColleague2(Mediator _mediator) {
        super(_mediator);
    }
    //自有方法
    public void selfMethod2(){
        //处理自身业务逻辑
    }
    //依赖方法 dep-method
    public void depMethod2(){
        //处理自己的业务逻辑
        //自己不能处理的业务逻辑，委托中介者处理
        super.mMediator.doSomething2();
    }
}

三.命令模式

命令模式：将一个请求封装成一个对象，从而让你使用不同的请求把客户端参数化，

对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。

命令模式三个角色：

Receive 接收者角色

Command 命令角色

Invoker 调用者角色

上代码：

public class CommandPattern {


    public String doSomething(){
        //声明调用者Invoker
        Invoker invoker  = new Invoker();
        //定义接收者
        Receiver receiver1 = new ConcreteReceiver1();
        //定义一个发送给接收者的命令
        Command command1 = new ConcreteCommand1(receiver1);
        invoker.setCommand(command1);
        String result1 = invoker.action();
        //定义接收者
        Receiver receiver2 = new ConcreteReceiver2();
        //定义一个发送给接收者的命令
        Command command2 = new ConcreteCommand2(receiver2);
        invoker.setCommand(command2);
        String result2 =  invoker.action();
        return result1+"\n"+result2;
    }
}

public abstract class Receiver {
    //抽象接收者，定义每个接收者都必须完成的业务
    public abstract String doSomething();
}
public class ConcreteReceiver1 extends Receiver {
    @Override
    public String doSomething() {
        return "ConcreteReceiver1 doSomething ";
    }
}
public class ConcreteReceiver2 extends Receiver {
    @Override
    public String doSomething() {
        return "ConcreteReceiver2 doSomething ";
    }
}
public abstract class Command {
    //每个命令类都必须有个执行命令的方法
    public abstract String execute();
}
public class ConcreteCommand1 extends Command {
    //对哪个Receiver类进行命令处理
    private Receiver receiver;

    public ConcreteCommand1(Receiver _receiver){
        receiver = _receiver;
    }

    @Override
    public String execute() {
        return this.receiver.doSomething();
    }
}
public class ConcreteCommand2 extends com.sh.lynn.hz.deginpattern.commandpattern.Command {
    //对哪个Receiver类进行命令处理
    private com.sh.lynn.hz.deginpattern.commandpattern.Receiver receiver;

    public ConcreteCommand2(com.sh.lynn.hz.deginpattern.commandpattern.Receiver _receiver){
        receiver = _receiver;
    }

    @Override
    public String execute() {
        return  this.receiver.doSomething();
    }
}

public class Invoker {
    private Command mCommand;
    //接收命令
    public void setCommand(Command _command){
        this.mCommand=_command;
    }

    public String action(){
        return this.mCommand.execute();
    }
}

四.责任链模式

责任链模式：使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。

将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

public class ChainPattern {

    public String doSomething(){
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();
        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);
//注意这里的调用 都是handle1
        Response response1 = handler1.handleMessage(new Request(Level.HIGHT,"hight request"));
        Response response2 = handler1.handleMessage(new Request(Level.LOW,"low request"));
        Response response3 = handler1.handleMessage(new Request(Level.MID,"mid request"));
        return response1.getResult()+"\n"+response2.getResult()+"\n"+response3.getResult();
    }
}

public class Request {
    private Level mLevel;
    private String msg ;
    public Request(Level _level,String _msg){
        mLevel=_level;
        msg=_msg;
    }
    public Level getRequestLevel(){
        return mLevel;
    }

    public String getMsg(){
        return  msg;
    }
}

public enum  Level {
    LOW ,MID,HIGHT
}
public class Response {
    private String result;

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }
}

public abstract class Handler {
    private Handler nextHandler;
    //每个处理者都必须对请求做出处理
    public final Response handleMessage(Request request) {
        Response response = null;
        //判断是否是自己的处理级别
        if (getHandlerLevel().equals(request.getRequestLevel())) {
            response = echo(request);
        } else {
            //下一个处理者
            if (this.nextHandler != null) {
                response = this.nextHandler.handleMessage(request);
            } else {

            }
        }
        return response;
    }
    //设置下一个处理者是谁
    public void setNextHandler(Handler _handler) {
        this.nextHandler = _handler;
    }
    //每个处理者都有一个处理级别
    protected abstract Level getHandlerLevel();
    //每个处理者都必须实现处理任务
    protected abstract Response echo(Request request);
}

public class ConcreteHandler1 extends Handler {
    @Override
    protected Level getHandlerLevel() {
        return Level.LOW;
    }

    @Override
    protected Response echo(Request request) {
        Response response = new Response();
        response.setResult(request.getMsg());
        return response;
    }
}

public class ConcreteHandler2 extends Handler {
    @Override
    protected Level getHandlerLevel() {
        return Level.MID;
    }

    @Override
    protected Response echo(Request request) {
        Response response = new Response();
        response.setResult(request.getMsg());
        return response;
    }
}

public class ConcreteHandler3 extends Handler {
    @Override
    protected Level getHandlerLevel() {
        return Level.HIGH;
    }

    @Override
    protected Response echo(Request request) {
        Response response = new Response();
        response.setResult(request.getMsg());
        return response;
    }
}

《设计模式之禅》读书笔记（四）

一.原型模式

二.中介者模式

三.命令模式

四.责任链模式

继续阅读

吃透MVC，驯服烂代码吃透MVC，驯服烂代码

【读书笔记】【linux kernel development】【从内核出发】

《每日编程》----《设计模式》----《三》----bridge模式

原则-读书笔记-想要与事实的辨析和连接

一文掌握14个高大尚设计模式的适用场景(图例)！！！------1

一文掌握14个高大尚设计模式的适用场景(图例)！！！------2

《断舍离》笔记二

20条编程经验

【观点】风雨20年：我所积累的20条编程经验【观点】风雨20年：我所积累的20条编程经验

【转载】风雨20年：我所积累的20条编程经验

做Java开发2w月薪，需要技术水平达到什么程度？

Java程序员月薪三万，技术水平需要达到什么程度？

Java 程序员进入 BAT，技术需要达到什么水平？

投资学第二章 Asset Classes and Financial Instruments

投资学第一章 investments-introduction

工厂模式-三种类型