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

最新推荐文章于 2024-09-15 22:03:14 发布

hyz8884

最新推荐文章于 2024-09-15 22:03:14 发布

阅读量287

点赞数

分类专栏：读书笔记文章标签：设计模式原型模式中介者模式命令模式责任链模式

本文链接：https://blog.csdn.net/hyz8884/article/details/54095472

版权

读书笔记专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一.原型模式

原型模式（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;
    }
}