Android 几种行为型设计模式

目录

6.策略模式

7.状态模式

8.责任链模式

9.解释器模式 (略)

10.命令模式

---

6.策略模式

//业务 : 梨子1单位2块钱 橙子1单位5 苹果1单位8000 计算价格

//价格计算类
public class PriceCalculator {

    private static final int PEAR = 1;
    private static final int ORANGE = 2;
    private static final int APPLE = 3;

    /**
     * @param number 数量
     * @return 数量*单价 = 总价
     */
    private static int pearPrice(int number) {
        return number * 2;
    }

    private static int orangePrice(int number) {
        return number * 5;
    }

    private static int applePrice(int number) {
        return number * 8000;
    }

    public static int calculatePrice(int number, int type) {
        switch (type) {
            case PEAR:
                return pearPrice(number);
            case ORANGE:
                return orangePrice(number);
            case APPLE:
                return applePrice(number);
            default:
                return -1;
        }
    }
}

//使用:计算10个梨子的价格
PrceCalculator.calculatePrice(10,PriceCalculator.PEAR);

//分析:PriceCalculator类同时承担了计算梨子橙子苹果的职责，违背了单一职责原则。并且，通过
//switch case的形式来判断使用哪一种水果的计算方式，如果，此时我们需要再增加一种水果-西瓜的计算,
//那么就需要在calculatePrice(int number, int type)函数增加判断。
//不断的增加或者修改会使这个类臃肿混乱难以维护
public class PriceCalculator {
    
    private static final int WATERMELON = 4;

    private static int watermelonPrice(int number) {
        return number * 10;
    }

    public static int calculatePrice(int number, int type) {
        switch (type) {
            case PEAR:
                return pearPrice(number);
            case ORANGE:
                return orangePrice(number);
            case APPLE:
                return applePrice(number);
            case WATERMELON:
                return watermelonPrice(number);
            default:
                return -1;
        }
    }
}


//-----------------------策略模式------------------------------

public interface CalculateStrategy {
    /**
     * 计算接口 按数量计算价格
     * @param number 数量
     * @return 总价
     */
    int calculatePrice(int number);
}

//梨子计算策略
public class PearStrategy implements CalculateStrategy{
    @Override
    public int calculatePrice(int number) {
        return number * 2;
    }
}

//橙子计算策略
public class OrangeStrategy implements CalculateStrategy {
    @Override
    public int calculatePrice(int number) {
        return number * 5;
    }
}

//苹果计算策略
public class AppleStrategy implements CalculateStrategy{
    @Override
    public int calculatePrice(int number) {
        return number * 8000;
    }
}

//价格计算类
public class PriceCalculator {

    public static int calculatePrice(int number,CalculateStrategy strategy) {
        return strategy.calculatePrice(number);
    }
}

//使用:计算10个梨子的价格
PriceCalculator.calculatePrice(10,new PearStrategy());

//同样,如果此时我们需要再增加一种水果-西瓜的计算，那么只需新增西瓜的计算策略
public class WatermelonStrategy implements CalculateStrategy {
    @Override
    public int calculatePrice(int number) {
        return number * 10;
    }
}

7.状态模式

状态模式与策略模式结构几乎是一样的,但它们的目的、本质完全不一样,状态模式的行为是平行的,不可替换的。策略模式的行为是彼此独立的,可相互替换的。

//订单类 每一个订单有多个按钮 不同的订单状态对应不同的操作
public class OrderState {

    //未付款 -> 付款 取消 申请众筹
    public final static int UNPAID = 1;
    //已付款 -> 退款 确认收货
    public final static int PAID = 2;
    //已完成 -> 评价 删除
    public final static int COMPLETED = 3;

    private int mState = UNPAID;


    public void setmState(int mState) {
        this.mState = mState;
    }

    /**
     * 按钮A的操作
     */
    public void buttonA() {
        switch (mState) {
            case UNPAID:
                System.out.println("执行付款操作");
                break;
            case PAID:
                System.out.println("执行退款操作");
                break;
            case COMPLETED:
                System.out.println("执行评价操作");
                break;
        }
    }

    /**
     * 按钮B的操作
     */
    public void buttonB() {
        if (mState == UNPAID) {
            System.out.println("执行取消操作");
        } else if (mState == PAID) {
            System.out.println("执行确认收货操作");
        } else if (mState == COMPLETED) {
            System.out.println("执行删除操作");
        }
    }

    /**
     * 按钮C的操作
     */
    public void buttonC() {
        if (mState == UNPAID) {
            System.out.println("执行申请众筹操作");
        } else if (mState == PAID) {
            System.out.println("按钮无对应操作,恭喜发财");
        } else if (mState == COMPLETED) {
            System.out.println("按钮隐藏,恭喜发财");
        }
    }
}

//按钮点击
public void buttonClick() {
    OrderState order = new OrderState();
    order.setmState(OrderState.UNPAID);
    order.buttonA();
    order.buttonB();
    order.buttonC();
}

//分析:通过mState标识订单状态,并且根据mState订单按钮会对应不同的操作，
//导致了每个功能中都需要使用switch-case/if-else,
//当有更多的订单状态及按钮的时候,代码将更为复杂混乱

//--------------------------状态模式---------------------------

//通多对态去除重复，杂乱的switch-case/if-else是状态模式的精髓所在，但同时，也增加了系统类及对象。。。

//按钮接口 定义按钮操作函数 根据不同的订单状态函数操作也不一样
public interface IButtonState {

    void buttonA();

    void buttonB();

    void buttonC();
}

//具体订单状态实现操作函数
public class UnpaidState implements IButtonState {
    @Override
    public void buttonA() {
        System.out.println("执行付款操作");
    }

    @Override
    public void buttonB() {
        System.out.println("执行付款操作");
    }

    @Override
    public void buttonC() {
        System.out.println("执行申请众筹操作");
    }
}

public class PaidState implements IButtonState {
    @Override
    public void buttonA() {
        System.out.println("执行退款操作");
    }

    @Override
    public void buttonB() {
        System.out.println("执行确认收货操作");
    }

    @Override
    public void buttonC() {
        System.out.println("按钮无对应操作,恭喜发财");
    }
}

public class CompletedState implements IButtonState {
    @Override
    public void buttonA() {
        System.out.println("执行评价操作");
    }

    @Override
    public void buttonB() {
        System.out.println("执行删除操作");
    }

    @Override
    public void buttonC() {
        System.out.println("按钮隐藏,恭喜发财");
    }
}

//订单状态接口
public interface IOrderState {

    void unpaid();

    void paid();

    void completed();
}

//订单类
public class OrderState implements IOrderState {

    private IButtonState mButtonState;

    public void setmButtonState(IButtonState mButtonState) {
        this.mButtonState = mButtonState;
    }

    public void buttonA() {
        mButtonState.buttonA();
    }

    public void buttonB() {
        mButtonState.buttonB();
    }

    public void buttonC() {
        mButtonState.buttonC();
    }

    @Override
    public void unpaid() {
        setmButtonState(new PaidState());
    }

    @Override
    public void paid() {
        setmButtonState(new PaidState());
    }

    @Override
    public void completed() {
        setmButtonState(new CompletedState());
    }
}

//按钮点击
public void buttonClick() {
    OrderState order = new OrderState();
    order.paid();
    order.buttonA();
    order.buttonB();
    order.buttonC();
}

打印日志:
执行退款操作
执行确认收货操作
按钮无对应操作,恭喜发财

PS:状态模式用在需要根据不同的登录状态对应不同操作的事件上挺不错的

8.责任链模式

多个对象可以处理同一请求,将这些对象连成一条链,并沿着这条链传递该请求,直到有对象处理它为止。(与view的事件分发机制类似)

// 抽象请求者
public abstract class AbstractRequest {
    private Object object;

    public AbstractRequest(Object object) {
        this.object = object;
    }

    /**
     * 获取处理对象内容
     * @return
     */
    public Object getContent() {
        return object;
    }

    /**
     * 获取处理对象请求级别
     * @return
     */
    public abstract int getRequestLevel();
}

//抽象处理者
public abstract class AbstractHandler {
    //下一节点上的处理者对象
    protected AbstractHandler nextHandler;

    public final void handleRequest(AbstractRequest request) {
        //判断当前处理者对象的处理级别是否与处理者的处理级别一致
        if (getHandleLevel() == request.getRequestLevel()) {
            handle(request);
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                System.out.println("所有处理者对象均不能处理该请求");
            }
        }
    }

    /**
     * 获取处理者对象的处理级别
     *
     * @return 处理级别
     */
    protected abstract int getHandleLevel();

    /**
     * 每个处理者对象的具体处理方式
     *
     * @param request
     */
    protected abstract void handle(AbstractRequest request);
}

//具体请求者
public class Request1 extends AbstractRequest{

    public Request1(Object object) {
        super(object);
    }

    @Override
    public int getRequestLevel() {
        return 1;
    }
}

public class Request2 extends AbstractRequest{

    public Request2(Object object) {
        super(object);
    }

    @Override
    public int getRequestLevel() {
        return 2;
    }
}

public class Request3 extends AbstractRequest {

    public Request3(Object object) {
        super(object);
    }

    @Override
    public int getRequestLevel() {
        return 3;
    }
}

//具体处理者
public class Handler1 extends AbstractHandler {
    @Override
    protected int getHandleLevel() {
        return 1;
    }

    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("Handler1：" + request.getRequestLevel() + " 内容:" + request.getContent());
    }
}

public class Handler2 extends AbstractHandler {
    @Override
    protected int getHandleLevel() {
        return 2;
    }

    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("Handler2：" + request.getRequestLevel() + " 内容:" + request.getContent());
    }
}

public class Handler3 extends AbstractHandler {
    @Override
    protected int getHandleLevel() {
        return 3;
    }

    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("Handler3：" + request.getRequestLevel() + " 内容:" + request.getContent());
    }
}

//请求者发起请求
public void request() {
    
    //处理者对象
    AbstractHandler handler1 = new Handler1();
    AbstractHandler handler2 = new Handler2();
    AbstractHandler handler3 = new Handler3();

    //设置当前处理者的下一个节点的处理者对象
    handler1.nextHandler = handler2;
    handler2.nextHandler = handler3;

    //请求者
    AbstractRequest request1 = new Request1("Request1");
    AbstractRequest request2 = new Request2("Request2");
    AbstractRequest request3 = new Request3("Request3");

    //总是从链式的首端handler1发起请求
    handler1.handleRequest(request1);
    handler1.handleRequest(request2);
    handler1.handleRequest(request3);
}

//日志打印
Handler1：1 内容:Request1
Handler2：2 内容:Request2
Handler3：3 内容:Request3

9.解释器模式 (略)

10.命令模式

更弱的耦合性,更灵活的控制性,更好的扩展性，但同时也大量衍生类产生。

业务: 男朋友命令女朋友 (在正常情况下想都不要想)

//接收者角色 （你的女朋友）
//命令模式中唯一处理代码逻辑的地方
public class GirlFriend {

    public void cooking() {
        System.out.println("做饭");
    }

    public void sweeping() {
        System.out.println("清扫");
    }

    public void sleeping() {
        System.out.println("暖床");
    }
}

//通常情况下会这样写：
public void command() {
        
    GirlFriend girlFriend = new GirlFriend();
    girlFriend.sleeping();
    girlFriend.sweeping();
    girlFriend.cooking();
}

//------------------------命令模式-----------------------------

//命令者抽象 定义执行方法
public interface Command {

    /**
     * 命令执行方法
     */
    void execute();
}

//具体命令者命令  (发布的命令,谁执行命令)
public class CookingCommand implements Command{

    private GirlFriend girlFriend;

    public CookingCommand(GirlFriend girlFriend) {
        this.girlFriend = girlFriend;
    }

    @Override
    public void execute() {
        girlFriend.cooking();
    }
}

public class SleepingCommand implements Command{

    private GirlFriend girlFriend;

    public SleepingCommand(GirlFriend girlFriend) {
        this.girlFriend = girlFriend;
    }

    @Override
    public void execute() {
        girlFriend.sleeping();
    }
}

public class SweepingCommand implements Command{

    private GirlFriend girlFriend;

    public SweepingCommand(GirlFriend girlFriend) {
        this.girlFriend = girlFriend;
    }

    @Override
    public void execute() {
        girlFriend.sweeping();
    }
}

//请求者类 命令发起者
public class BoyFriend {
    private CookingCommand cookingCommand ;
    private SweepingCommand sweepingCommand;
    private SleepingCommand sleepingCommand;

    public void setCookingCommand(CookingCommand cookingCommand) {
        this.cookingCommand = cookingCommand;
    }

    public void setSweepingCommand(SweepingCommand sweepingCommand) {
        this.sweepingCommand = sweepingCommand;
    }

    public void setSleepingCommand(SleepingCommand sleepingCommand) {
        this.sleepingCommand = sleepingCommand;
    }

    public void letSheGoToCooking() {
        //命令执行
        cookingCommand.execute();
    }

    public void letSheGoToSweeping() {
        sweepingCommand.execute();
    }

    public void letSheGoToSleeping() {
        sleepingCommand.execute();
    }
}

//使用：他命令她
public void command() {

    //首先要有一个女朋友
    GirlFriend girlFriend = new GirlFriend();

    //根据女朋友的作用构建命令
    CookingCommand cookingCommand = new CookingCommand(girlFriend);
    SweepingCommand sweepingCommand = new SweepingCommand(girlFriend);
    SleepingCommand sleepingCommand = new SleepingCommand(girlFriend);

    //确认男朋友可以让女朋友执行哪些不同的命令
    BoyFriend boyFriend = new BoyFriend();
    boyFriend.setCookingCommand(cookingCommand);
    boyFriend.setSweepingCommand(sweepingCommand);
    boyFriend.setSleepingCommand(sleepingCommand);

    //接下来具体要让女朋友干啥男朋友说了算
    boyFriend.letSheGoToSleeping();
    boyFriend.letSheGoToSweeping();
    boyFriend.letSheGoToCooking();
}

//使用日志打印:
暖床
清扫
做饭

PS ：Android 几种创建型设计模式通道