设计模式精炼(四): 行为型00

点击上方"淼淼之森"，选择"关注"公众号

优秀文章，第一时间收到！

KS

Knowledge Sharing

知识分享

    现在是资源共享的时代，同样也是知识分享的时代，如果你觉得本文有用，希望你能将它分享，让更多的人看到。

推荐阅读

行为型00

责任链模式

请求以链式传递，具体哪个类处理客户端不知。Tomcat的Filter处理过程便是责任链模式。
|- 抽象处理者：定义接口，并且持有下一个处理类的对象。
|- 具体处理者：可以根据条件判断是否处理或者移交给下一个处理类处理。
例：

//抽象处理角色
public abstract class Handler {
    //持有的后继责任对象
    protected Handler successor;
    //处理请求的方法
    public abstract void handlerRequest();
    public Handler getSuccessor() {
        return successor;
    }

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
}
//具体处理角色
public class ConcreteHandler extends Handler {
    @Override
    public void handlerRequest() {
        if (getSuccessor() != null) {
            System.out.println("放过请求");
            getSuccessor().handlerRequest();
        }else{
            System.out.println("处理请求");
        }
    }
}
//客户端
public class Client {
    public static void main(String[] args) {
        //组装责任链
        Handler handler1 = new ConcreteHandler();
        Handler handler2 = new ConcreteHandler();
        handler1.setSuccessor(handler2);
        //提交请求
        handler1.handlerRequest();
    }
}

命令模式

把发出命令的责任和执行命令的责任分离，委派给不同的对象。每一个命令都是一个操作：请求的一方发出请求要求执行一个操作；接收的一方收到请求，并执行操作。
例：

//接收者
public class Receiver {
    public void action(){
        //真正执行命令的操作
        System.out.println("执行操作");
    }
}
//抽象命令接口
public interface Command {
    //执行方法
    void excute();
}
//具体命令
public class ConcreteCommand implements Command {
    //持有相应的接收者对象
    private Receiver receiver = null;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }
    @Override
    public void excute() {
        receiver.action();
    }
}
//请求者
public class Invoker {
    private Command command= null;

    public Invoker(Command command) {
        this.command = command;
    }
    public void action(){
        command.excute();
    }
}
//客户端
public class Client {
    public static void main(String[] args) {
        //创建接收者
        Receiver receiver = new Receiver();
        //创建命令对象，设置它的接收者
        Command command = new ConcreteCommand(receiver);
        //创建请求者，把命令设置进去
        Invoker invoker = new Invoker(command);
        //执行方法
        invoker.action();
    }
}

注：命令模式使得客户端和具体实现命令的接收者对象完全解耦。

解释器模式

给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
|- 通俗来讲就是定义一些规则，用你自己的方式来实现这些规则，并且调用此规则来完成一些功能。
例：

/**
 * 表达式接口
 */
public interface Expression {
    boolean interpret(String context);
}
public class TerminalExpression implements Expression {
    private String data;

    public TerminalExpression(String data) {
        this.data = data;
    }

    @Override
    public boolean interpret(String context) {
        return context.contains(data);
    }
}
/**
 * 与表达式
 */
public class AndExpression implements Expression {
    private Expression expression1 = null;
    private Expression expression2 = null;

    public AndExpression(Expression expression1, Expression expression2) {
        this.expression1 = expression1;
        this.expression2 = expression2;
    }

    @Override
    public boolean interpret(String context) {
        return expression1.interpret(context)&& expression2.interpret(context);
    }
}
/**
 * 或表达式
 */
public class OrExpression implements Expression {
    private Expression expression1 = null;
    private Expression expression2 = null;

    public OrExpression(Expression expression1,Expression expression2) {
        this.expression1 = expression1;
        this.expression2 = expression2;
    }

    @Override
    public boolean interpret(String context) {
        boolean flag1 = expression1.interpret(context);
        boolean flag2 = expression2.interpret(context);
        return flag1|| flag2;
    }
}
//客户端
public class Client {
    //规则：Robert 和 John 是男性
    public static Expression getMaleExpression(){
        Expression robert = new TerminalExpression("Robert");
        Expression john = new TerminalExpression("john");
        return new OrExpression(robert,john);
    }
    //规则：Julie 是一个已婚的女性
    public static Expression getMarriedWomanExpression(){
        Expression julie = new TerminalExpression("Julie");
        Expression married = new TerminalExpression("Married");
        return new AndExpression(julie, married);
    }

    public static void main(String[] args) {
        Expression isMale = getMaleExpression();
        Expression isMarriedWoman = getMarriedWomanExpression();

        System.out.println("John is male? " + isMale.interpret("john"));
        System.out.println("Julie is a married women? "
                + isMarriedWoman.interpret("Married Julie"));
    }
}

以上代码运行结果为：
John is male? true
Julie is a married women? true

中介者模式

为了减少同事类之间的耦合，独立改变他们之间的交互。
|- 同事类：如果一个对象会影响其他的对象，同时也会被其他对象影响，那么这两个对象称为同事类。
|- 情景：类A和类B都持有一个数，要保证A中的数字改变的时候B中的数字乘以100，B中的数字改变的时候，A中的数字除以100。
例（传统方式）：

public abstract AbstractColleague{
    protected int number;
    public void setNumber(int number){
        this.number = number;
    }
    public int getNumber(){
        return number;
    }
    public abstract void setNumber(int number,AbstractColleague colleague);
}
public class ColleagueA extends AbstractColleague{
    @Override
    public void setNumber(int number,AbstractColleague colleague){
        this.number = number;
        colleague.setNumber(number * 100);
    }
}
public class ColleagueB extends AbstractColleague{
    @Override
    public void setNumber(int number,AbstractColleague colleague){
        this.number = number;
        colleague.setNumber(number / 100);
    }
}
public class Client(){
    public static void main(String[] args){
        AbstractColleague colleagueA = new ColleagueA();
        AbstractColleague colleagueB = new ColleagueB();
        colleagueA.setNumber(500,colleagueB);
        System.out.println("---------设置A影响B---------");
        System.out.println("collA的值 :"+colleagueA.getNumber());
        System.out.println("collB的值 :"+colleagueB.getNumber());
        colleagueB.setNumber(2500600,colleagueA);
        System.out.println("---------设置B影响A---------");
        System.out.println("collA的值 :"+colleagueA.getNumber());
        System.out.println("collB的值 :"+colleagueB.getNumber());     
    }
}

运行结果：
---------设置A影响B---------
collA的值 :500
collB的值 :50000
---------设置B影响A---------
collA的值 :25006
collB的值 :2500600

例（中介者模式：让中介类参与其中，避免A和B的直接交互）：

/**
 * 中介者模式
 */
public abstract class AbstractColleague {
    protected int number;

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }
    //这里传入的是一个中介类
    public abstract void setNumber(int number,AbstractMediator media);
    public void test(){
    }
}
public class ColleagueA extends AbstractColleague {
    @Override
    public void setNumber(int number, AbstractMediator mediator) {
        this.number = number;
        //让中介类来完成功能
        mediator.affectB();
    }
}
public class ColleagueB extends AbstractColleague {
    @Override
    public void setNumber(int number, AbstractMediator mediator) {
        this.number = number;
        mediator.affectA();
    }
}
public abstract class AbstractMediator {
    //持有两个实际对象的目的是让他们的状态随着改变。
    protected AbstractColleague A;
    protected AbstractColleague B;
    //构造方法通常是一种非常好的做法，可以让类的状态一直保持着传递状态。
    public AbstractMediator(AbstractColleague a, AbstractColleague b) {
        A = a;
        B = b;
    }
    public abstract void affectB();

    public abstract void affectA();
}
public class Mediator extends AbstractMediator {
    public Mediator(AbstractColleague colleagueA,AbstractColleague colleagueB) {
        super(colleagueA,colleagueB);
    }

    @Override
    public void affectB() {
        int number = A.getNumber();
        B.setNumber(number * 100);
    }

    @Override
    public void affectA() {
        int number = B.getNumber();
        A.setNumber(number / 100);
    }
}
//Client
public class Client {
    public static void main(String[] args) {
        AbstractColleague colleagueA = new ColleagueA();
        AbstractColleague colleagueB = new ColleagueB();
        AbstractMediator mediator = new Mediator(colleagueA,colleagueB);
        colleagueA.setNumber(500,mediator);
        System.out.println("---------设置A影响B---------");
        System.out.println("collA的值 :"+colleagueA.getNumber());
        System.out.println("collB的值 :"+colleagueB.getNumber());
        colleagueB.setNumber(2500600,mediator);
        System.out.println("---------设置B影响A---------");
        System.out.println("collA的值 :"+colleagueA.getNumber());
        System.out.println("collB的值 :"+colleagueB.getNumber());
    }
}

运行结果如下：
---------设置A影响B---------
collA的值 :500
collB的值 :50000
---------设置B影响A---------
collA的值 :25006
collB的值 :2500600

注：一般来说，只有对于那种同事类之间是网状结构的关系，才会考虑使用中介者模式。可以将网状结构变为星状结构，使同事类之间的关系变的清晰一些。
|- 网状结构：类与类之间是多对多的关系，牵一发而动全身。
|- 星状结构：各类都与中介类单独联系，不与其他的类牵连。

-END-

目前3000+人已关注加入我们

关注公众号"淼淼之森"获取更多精彩信息：

据说幸运的人都会第一时间关注哦！