设计模式系统回顾（21）状态模式

其核心就是给每一种状态绑定一种行为
订单例子

public abstract class AbstractOrderState {
    protected OrderContext orderContext;//订单上下文，用来负责状态切换

    public AbstractOrderState(OrderContext orderContext) {
        this.orderContext = orderContext;
    }

    public abstract void payOrder();//待支付状态订单对应的行为：支付

    public abstract void deliver();//已支付状态订单对应的行为：发货

    public abstract void receiveGoods();//已收货状态订单对应的行为：收货
}
//待支付
public class WaitPaidOrderState extends AbstractOrderState {
    public WaitPaidOrderState(OrderContext orderContext) {
        super(orderContext);
    }

    @Override
    public void payOrder() {//相当于待支付的状态绑定了支付行为
        System.out.println("支付成功");
        this.orderContext.setState(this.orderContext.waitDeliver);//切换状态
    }

    @Override
    public void deliver() {//不是待支付状态订单的行为
        System.out.println("对不起，请先付钱");
    }

    @Override
    public void receiveGoods() {//不是待支付状态订单的行为
        System.out.println("对不起，请先付钱");
    }
}
//待发货状态类
public class WaitDeliverOrderState extends AbstractOrderState {
    public WaitDeliverOrderState(OrderContext orderContext) {
        super(orderContext);
    }

    @Override
    public void payOrder() {//不是待发货状态订单的行为
        System.out.println("你已经付过钱了");
    }

    @Override
    public void deliver() {
        System.out.println("商品已发货并送达目的地");
        this.orderContext.setState(this.orderContext.receiveGoods);//切换状态
    }

    @Override
    public void receiveGoods() {//不是待发货状态订单的行为
        System.out.println("请稍等，商品即将发货");
    }
}

//待收货
public class ReceiveGoodsOrderState extends AbstractOrderState{
    public ReceiveGoodsOrderState(OrderContext orderContext) {
        super(orderContext);
    }

    @Override
    public void payOrder() {//不是待收货状态订单的行为
        System.out.println("您已经付过钱啦，不要重复付钱哦");
    }

    @Override
    public void deliver() {//不是待收货状态订单的行为
        System.out.println("商品已发货并送达，请不要重复发货");
    }

    @Override
    public void receiveGoods() {
        System.out.println("用户已收到商品，此次交易结束");
    }
}

public class OrderContext {
    AbstractOrderState waitPaid;//待支付状态
    AbstractOrderState waitDeliver;//待发货状态
    AbstractOrderState receiveGoods;//待收货状态

    AbstractOrderState currState;//当前状态

    public OrderContext() {
        this.waitPaid = new WaitPaidOrderState(this);//初始化待支付状态订单
        this.waitDeliver = new WaitDeliverOrderState(this);//初始化待发货状态订单
        this.receiveGoods = new ReceiveGoodsOrderState(this);//初始化待收货状态订单
        currState = waitPaid;//当前状态，默认待支付
    }

    void setState(AbstractOrderState state){
        this.currState = state;
    }

    public void payOrder(){//支付
        currState.payOrder();
    }


    public void deliver(){//发货
        currState.deliver();
    }

    public void receiveGoods(){//收货
        currState.receiveGoods();
    }
}

public class TestState {
    public static void main(String[] args) {
        OrderContext orderContext = new OrderContext();//创建订单上下文，默认待支付状态
        orderContext.payOrder();//支付，支付完成之后状态自动切换到待发货
        orderContext.deliver();//发货，发货之后状态自动切换到待收货
        orderContext.receiveGoods();//收货
    }
}

状态模式和责任链模式
1.状态模式是对下一个节点了解的，责任链不知道
状态模式和策略模式
1.策略之前相互可以替换，状态不可以
优点：
每个状态都是独立的对象，易于维护
每个状态类职责单一
缺点：
容易类膨胀