Java设计模式期末——网络商城系统_java设计模式期末网络商城系统

写在前面：本人为初学者，该代码仅供参考，如有不对的地方，欢迎各位大佬评论区指正批评。本菜鸟当不胜感激！

题目描述：现假设要实现一个网络商城系统的部分功能

1、商品状态的订阅：网络商城中的每一种商品，供应商和用户都可以对其进行订阅关注。对供应商来说，当商品缺货的时候，提醒供应商补货。对于用户来说，当商品价格变动的时候，或商品由缺货变成有货的时候，可以自动通知用户。请使用观察者模式，实现这种效果。

2、订单状态的管理：当用户在商城中下了订单后，订单存在着几种状态：下单状态（下订单未付款），已付款状态（付款未发货），已发货状态（发货未确认），已完成状态（用户确认或售后完成），已取消状态（用户未付款或用户取消），售后状态（用户收货确认后有退换货问题）。状态之间存在行为转换，请用状态模式，实现订单状态的转换。

3、订单发货的管理：该商城在全国有西南、西北、东南、东北4个物流中心，订单会根据收货地的范围不同，确定应该由那个物流中心发货。请使用代理模式，实现订单发货的物流管理。

具体代码：

商品实例

package FinalAssignment.entity;
 
/**
 * 商品类
 */
public class Goods {
    private String goodName;//商品名称
    private float price;//商品价格
    private int count;//商品数量
 
    public Goods(String goodName, float price, int count) {
        this.goodName = goodName;
        this.price = price;
        this.count = count;
    }
 
    public String getGoodName() {
        return goodName;
    }
 
    public void setGoodName(String goodName) {
        this.goodName = goodName;
    }
 
    public float getPrice() {
        return price;
    }
 
    public void setPrice(float price) {
        this.price = price;
    }
 
    public int getCount() {
        return count;
    }
 
    public void setCount(int count) {
        this.count = count;
    }
}

观察者模式部分

package FinalAssignment.observer.observer;
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.subject.Subject;
 
/**
 * 观察者接口
 */
public interface Observer {
    void upData(Subject subject, Goods good);
    float getMoney();
    void setMoney(float Money);
    String  getAddr();
    void  setAddr(String addr);
    String  getName();
     void setName(String name);
}
//-----------------------------------------------------------------------------
 
package FinalAssignment.observer.observer.impl;
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.observer.Observer;
import FinalAssignment.observer.subject.Subject;
import FinalAssignment.observer.subject.impl.Food;
 
/**
 * 消费者（观察者）
 */
public class Consumer implements Observer {
    private String name;//消费者的姓名
    private float money;//金钱
    private String addr;//顾客收货地址
 
    @Override
    public String getName() {
        return name;
    }
 
    @Override
    public void setName(String name) {
        this.name=name;
    }
 
 
    public Consumer(String name, float money, String addr) {
        this.name = name;
        this.money=money;
        this.addr = addr;
    }
    public float getMoney() {
        return money;
    }
    public void setMoney(float money) {
        this.money = money;
    }
 
    @Override
    public String getAddr() {
        return addr;
    }
 
    @Override
    public void setAddr(String addr) {
        this.addr=addr;
    }
 
    @Override
    public void upData(Subject subject, Goods good) {
        System.out.println(name+subject.getNotice());
    }
}
//-----------------------------------------------------------------------------
package FinalAssignment.observer.observer.impl;
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.observer.Observer;
import FinalAssignment.observer.subject.Subject;
import FinalAssignment.observer.subject.impl.Food;
 
/**
 * 供应商（观察者）
 */
public class Supplier implements Observer {
    private String name;//供应商姓名
 
    public Supplier(String name) {
        this.name = name;
    }
 
    @Override
    public String getName() {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public void setName(String name) {
 
    }
 
    @Override
    public void upData(Subject subject, Goods good) {
        System.out.println(subject.getNotice());
        System.out.println(name+"收到!");
        good.setCount(100);
        System.out.println("补货完成!");
        //补货完成后通过商城通知顾客
        subject.setNotice("你关注的商品有货了,快来购买吧!");
        subject.notifyObservers();
    }
 
    @Override
    public float getMoney() {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public void setMoney(float Money) {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public String getAddr() {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public void setAddr(String addr) {
        throw new UnsupportedOperationException();
    }
}
//-----------------------------------------------------------------------------
package FinalAssignment.observer.subject;
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.observer.Observer;
 
import java.util.List;
 
/**
 * 主题接口（商城）
 */
public interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
    void addGood(Goods good);
    void removeGood(Goods good);
    void addSupplier(Observer observer);
    void removeSupplier(Observer observer);
    List<Goods> getAllGoods();
    void changePrice(String goodName,float discount);
    void notifySuppliers();
    String getNotice();
    void setNotice(String msg);
}
 
//-----------------------------------------------------------------------------
package FinalAssignment.observer.subject.impl;
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.observer.Observer;
import FinalAssignment.observer.subject.Subject;
 
import java.util.ArrayList;
import java.util.List;
 
 
/**
 * 网络商城蔬菜区
 */
public class Vegetables implements Subject {
    //存储顾客
    private List<Observer> consumers;
    //存储供应商
    private List<Observer> suppliers;
    //存储该分区里面的商品
    private List<Goods> commodity;
    //存储通知信息
    String notice;
 
    public String getNotice() {
        return notice;
    }
 
    public void setNotice(String notice) {
        this.notice = notice;
    }
 
    public Vegetables() {
        //在构造函数中对集合初始化
        consumers=new ArrayList<>();
        suppliers=new ArrayList<>();
        commodity=new ArrayList<>();
    }
    //添加顾客方法
    @Override
    public void addObserver(Observer observer) {
        consumers.add(observer);
    }
    //移除顾客方法
    @Override
    public void removeObserver(Observer observer) {
        consumers.remove(observer);
    }
    //通知观察者方法
    @Override
    public void notifyObservers() {
        for (Observer consumer:consumers){
            consumer.upData(this,null);
        }
    }
    //通知供应商补货方法
    @Override
    public void notifySuppliers() {
        for(Goods good:commodity){
 
            if(good.getCount()<=0){
                setNotice(good.getGoodName()+"无货了，请快点补货!");
                for (Observer supplier:suppliers){
                    supplier.upData(this,good);
                }
            }
        }
    }
    //添加商品方法
    @Override
    public void addGood(Goods good) {
        commodity.add(good);
    }
    //下架商品方法
    @Override
    public void removeGood(Goods good) {
        commodity.remove(good);
    }
    //添加供应商方法
    @Override
    public void addSupplier(Observer observer) {
        suppliers.add(observer);
    }
    //移除供应商方法
    @Override
    public void removeSupplier(Observer observer) {
        suppliers.remove(observer);
    }
    //显示该区域所有商品
    @Override
    public  List<Goods> getAllGoods() {
        return commodity;
    }
    //改变商品价格
    public void changePrice(String goodName,float discount){
        for (Goods good:commodity){
            if(good.getGoodName().equals(goodName)){
                float tmp=good.getPrice();
                good.setPrice(good.getPrice()*discount);
                if(tmp>good.getPrice()) {
                    setNotice(goodName + "降价了，快来购买");
                    notifyObservers();
                }
            }
        }
 
    }
}
 
//-----------------------------------------------------------------------------
package FinalAssignment.observer.subject.impl;
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.observer.Observer;
import FinalAssignment.observer.subject.Subject;
 
import java.util.ArrayList;
import java.util.List;
 
 
/**
 * 网络商城食品区
 */
public class Food implements Subject {
    //存储顾客
    private List<Observer> consumers;
    //存储供应商
    private List<Observer> suppliers;
    //存储该分区里面的商品
    private List<Goods> commodity;
    //存储通知信息
    String notice;
    @Override
    public String getNotice() {
        return notice;
    }
 
    @Override
    public void setNotice(String msg) {
        this.notice = msg;
    }
    public Food() {
        //在构造函数中对集合初始化
        consumers=new ArrayList<>();
        suppliers=new ArrayList<>();
        commodity=new ArrayList<>();
    }
    //添加顾客方法
    @Override
    public void addObserver(Observer observer) {
        consumers.add(observer);
    }
    //移除顾客方法
    @Override
    public void removeObserver(Observer observer) {
        consumers.remove(observer);
    }
    //通知消费者方法
    @Override
    public void notifyObservers() {
        for (Observer consumer:consumers){
            consumer.upData(this,null);
        }
    }
    //通知供应商补货方法
    @Override
    public void notifySuppliers() {
        for(Goods good:commodity){
 
            if(good.getCount()<=0){
                setNotice(good.getGoodName()+"无货了，请快点补货!");
                for (Observer supplier:suppliers){
                    supplier.upData(this,good);
                }
            }
        }
    }
    //添加商品方法
    @Override
    public void addGood(Goods good) {
        commodity.add(good);
    }
    //下架商品方法
    @Override
    public void removeGood(Goods good) {
        commodity.remove(good);
    }
    //添加供应商方法
    @Override
    public void addSupplier(Observer observer) {
        suppliers.add(observer);
    }
    //移除供应商方法
    @Override
    public void removeSupplier(Observer observer) {
        suppliers.remove(observer);
    }
    //显示该区域所有商品
    @Override
    public  List<Goods> getAllGoods() {
        return commodity;
    }
    //改变商品价格
    public void changePrice(String goodName,float discount){
        for (Goods good:commodity){
            if(good.getGoodName().equals(goodName)){
                float tmp=good.getPrice();
                good.setPrice(good.getPrice()*discount);
                if(tmp>good.getPrice()) {
                    setNotice(goodName + "降价了，快来购买");
                    notifyObservers();
                }
            }
        }
 
    }
}
 
//-----------------------------------------------------------------------------
package FinalAssignment.observer.subject.impl;
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.observer.Observer;
import FinalAssignment.observer.subject.Subject;
 
import java.util.ArrayList;
import java.util.List;
 
 
/**
 * 网络商城日用品区
 */
 
public class DailyNecessities implements Subject {
    //存储顾客
    private List<Observer> consumers;
    //存储供应商
    private List<Observer> suppliers;
    //存储该分区里面的商品
    private List<Goods> commodity;
    //存储通知信息
    String notice;
 
    public String getNotice() {
        return notice;
    }
 
    public void setNotice(String notice) {
        this.notice = notice;
    }
 
    public DailyNecessities() {
        //在构造函数中对集合初始化
        consumers=new ArrayList<>();
        suppliers=new ArrayList<>();
        commodity=new ArrayList<>();
    }
    //添加顾客方法
    @Override
    public void addObserver(Observer observer) {
        consumers.add(observer);
    }
    //移除顾客方法
    @Override
    public void removeObserver(Observer observer) {
        consumers.remove(observer);
    }
    //通知观察者方法
    @Override
    public void notifyObservers() {
        for (Observer consumer:consumers){
            consumer.upData(this,null);
        }
    }
    //通知供应商补货方法
    @Override
    public void notifySuppliers() {
        for(Goods good:commodity){
 
            if(good.getCount()<=0){
                setNotice(good.getGoodName()+"无货了，请快点补货!");
                for (Observer supplier:suppliers){
                    supplier.upData(this,good);
                }
            }
        }
    }
    //添加商品方法
    @Override
    public void addGood(Goods good) {
        commodity.add(good);
    }
    //下架商品方法
    @Override
    public void removeGood(Goods good) {
        commodity.remove(good);
    }
    //添加供应商方法
    @Override
    public void addSupplier(Observer observer) {
        suppliers.add(observer);
    }
    //移除供应商方法
    @Override
    public void removeSupplier(Observer observer) {
        suppliers.remove(observer);
    }
    //显示该区域所有商品
    @Override
    public  List<Goods> getAllGoods() {
        return commodity;
    }
    //改变商品价格
    public void changePrice(String goodName,float discount){
        for (Goods good:commodity){
            if(good.getGoodName().equals(goodName)){
                float tmp=good.getPrice();
                good.setPrice(good.getPrice()*discount);
                if(tmp>good.getPrice()) {
                    setNotice(goodName + "降价了，快来购买");
                    notifyObservers();
                }
            }
        }
 
    }
}
 
 

创建一个超市类 将三个分区整合

package FinalAssignment.observer;
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.subject.Subject;
import FinalAssignment.observer.subject.impl.DailyNecessities;
import FinalAssignment.observer.subject.impl.Food;
import FinalAssignment.observer.subject.impl.Vegetables;
 
public class Supermarket {
    //创建商品分区
    Subject food;
    Subject vegetables;
    Subject dn;//日常生活用品区
 
    public Supermarket() {
        //在构造函数中初始化
        food=new Food();
        vegetables=new Vegetables();
        dn=new DailyNecessities();
        //给每个食品分区补货
        //零食区
        food.addGood(new Goods("火腿肠",1.5f,100));
        food.addGood(new Goods("方便面",3.5f,100));
        food.addGood(new Goods("泡鸡脚",13.5f,30));
        //蔬菜区
        vegetables.addGood(new Goods("西红柿",3f,0));
        vegetables.addGood(new Goods("黄瓜",2.5f,30));
        vegetables.addGood(new Goods("白菜",2f,20));
        //日常生活用品区
        dn.addGood(new Goods("抽纸",10f,100));
        dn.addGood(new Goods("洗衣机",450f,100));
        dn.addGood(new Goods("吹风机",188.88f,80));
    }
    //获取对应商品分区
    public Subject getFood() {
        return food;
    }
 
    public Subject getVegetables() {
        return vegetables;
    }
 
    public Subject getDn() {
        return dn;
    }
    //展示超市所有商品
    public void showAll(){
        System.out.println("欢迎来到Darker商城!");
        System.out.println("======食品区======");
        for (Goods good: food.getAllGoods()){
            System.out.println("商品:"+good.getGoodName()+" 价格:"+good.getPrice()+" 库存:"+good.getCount());
        }
        System.out.println("======蔬菜区======");
        for (Goods good: vegetables.getAllGoods()){
            System.out.println("商品:"+good.getGoodName()+" 价格:"+good.getPrice()+" 库存:"+good.getCount());
        }
        System.out.println("======日常用品区======");
        for (Goods good: dn.getAllGoods()){
            System.out.println("商品:"+good.getGoodName()+" 价格:"+good.getPrice()+" 库存:"+good.getCount());
        }
    }
    //修改商品价格
    public void changePrice(Subject subject,String goodName,float discount){
        subject.changePrice(goodName,discount);
    }
}

代理模式部分

package FinalAssignment.proxy;
 
import FinalAssignment.state.ShopAPP;
 
public interface Proxy extends Collective{
    String getAddr();
}
//------------------------------------------------------------------
package FinalAssignment.proxy;
 
/**
 * 物流和状态都要实现的接口
 */
public interface Collective {
    boolean deliver();//运输方法
}
 
//------------------------------------------------------------------
package FinalAssignment.proxy.impl;
 
import FinalAssignment.proxy.Proxy;
import FinalAssignment.state.ShopAPP;
import FinalAssignment.state.situation.State;
 
/**
 * 西南物流
 */
public class SouthwestLogistics implements Proxy {
    State state;
    private String[] addr;
 
    public SouthwestLogistics(State state) {
        this.state=state;
       addr=new String[]{"云南","贵州","四川","西藏","重庆"};
    }
//配送
    @Override
    public boolean deliver() {
        boolean flag = state.deliver();
        if(flag) {
            System.out.println("西南物流中心为你服务!");
            return true;
        }
        else
            return false;
    }
//获取地址
    @Override
    public String getAddr() {
        StringBuilder sb = new StringBuilder();
        for (int i=0;i<addr.length;i++){
            sb.append(addr[i]);
        }
        return sb.toString();
    }
}
 
//------------------------------------------------------------------
package FinalAssignment.proxy.impl;
 
import FinalAssignment.proxy.Proxy;
import FinalAssignment.state.ShopAPP;
import FinalAssignment.state.situation.State;
 
/**
 * 东南物流
 */
public class SoutheastLogistics implements Proxy {
    State state;
    private String[] addr;
 
    public SoutheastLogistics(State state) {
        this.state=state;
       addr=new String[]{"江苏","上海","浙江","福建","广东","广西"};
    }
//配送
    @Override
    public boolean deliver() {
        boolean flag = state.deliver();
        if(flag) {
            System.out.println("东南物流中心为你服务!");
            return true;
        }
        else
            return false;
    }
//获取地址
    @Override
    public String getAddr() {
        StringBuilder sb = new StringBuilder();
        for (int i=0;i<addr.length;i++){
            sb.append(addr[i]);
        }
        return sb.toString();
    }
}
 
//------------------------------------------------------------------
package FinalAssignment.proxy.impl;
 
import FinalAssignment.proxy.Proxy;
import FinalAssignment.state.ShopAPP;
import FinalAssignment.state.situation.State;
 
/**
 * 西北物流
 */
public class NorthwestLogistics implements Proxy {
    State state;
    private String[] addr;
 
    public NorthwestLogistics(State state) {
        this.state=state;
       addr=new String[]{"内蒙古","新疆","宁夏","甘肃"};
    }
//配送
    @Override
    public boolean deliver() {
        boolean flag = state.deliver();
        if(flag) {
            System.out.println("西北物流中心为你服务!");
            return true;
        }
        else
            return false;
    }
//获取地址
    @Override
    public String getAddr() {
        StringBuilder sb = new StringBuilder();
        for (int i=0;i<addr.length;i++){
            sb.append(addr[i]);
        }
        return sb.toString();
    }
}
 
//------------------------------------------------------------------
package FinalAssignment.proxy.impl;
 
import FinalAssignment.proxy.Proxy;
import FinalAssignment.state.ShopAPP;
import FinalAssignment.state.situation.State;
 
/**
 * 东北物流
 */
public class NortheastLogistics implements Proxy {
    State state;
    private String[] addr;
 
    public NortheastLogistics(State state) {
        this.state=state;
       addr=new String[]{"黑龙江","吉林","辽宁"};
    }
//配送
    @Override
    public boolean deliver() {
        boolean flag = state.deliver();
        if(flag) {
            System.out.println("东北物流中心为你服务!");
            return true;
        }
        else
            return false;
    }
//获取地址
    @Override
    public String getAddr() {
        StringBuilder sb = new StringBuilder();
        for (int i=0;i<addr.length;i++){
            sb.append(addr[i]);
        }
        return sb.toString();
    }
}

状态模式部分 

package FinalAssignment.state.situation;
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.observer.Observer;
import FinalAssignment.observer.subject.Subject;
import FinalAssignment.proxy.Collective;
 
/**
 * 状态接口
 */
public interface State extends Collective {
    Goods placeOrder(Subject subject,String goodName);//下单方法
    boolean pay(Goods good, Observer consumer);//支付
    void cancel(Goods goods);//取消
    void confirm();//确认收货
    boolean isNeedHelp();//是否需要售后服务
    void service();//售后
}
//--------------------------------------------------------------------
package FinalAssignment.state.situation.impl;
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.observer.Observer;
import FinalAssignment.observer.subject.Subject;
import FinalAssignment.state.ShopAPP;
import FinalAssignment.state.situation.State;
 
/**
 * 未下单状态
 */
public class NoPlaceOrderState implements State {
    ShopAPP app=null;
    public NoPlaceOrderState(ShopAPP app) {
        this.app=app;
    }
    @Override
    public Goods placeOrder(Subject subject,String goodName) {
        boolean flag=false;//标志是否包含欲查找的商品
        for(Goods good:subject.getAllGoods()){
            if(goodName.equals(good.getGoodName())){
                flag=true;//有该商品
                if(good.getCount()<=0){
                    //商品库存不足 通知供应商补货
                    subject.setNotice(good.getGoodName()+"无货了，请补货!");
                    subject.notifySuppliers();
                    placeOrder(subject,goodName);
                    return good;
                }else{
                    good.setCount(good.getCount()-1);//商品数量减少
                    System.out.println(good.getGoodName()+"下单成功!");
                    //下单成功，修改状态为待付款
                    app.setState(app.getCanPayState());
                    return good;
                }
            }
        }
        if(!flag){
            System.out.println("暂时没有该商品!");
        }
        return null;
    }
 
    @Override
    public boolean pay(Goods good, Observer consumer) {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public void cancel(Goods goods) {
        System.out.println("没有订单");
    }
 
    @Override
    public boolean deliver() {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public void confirm() {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public boolean isNeedHelp() {
        return false;
    }
 
    @Override
    public void service() {
        System.out.println("你没有待售后订单");
    }
}
 
//--------------------------------------------------------------------
package FinalAssignment.state.situation.impl;
/**
 * 已付款状态
 */
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.observer.Observer;
import FinalAssignment.observer.subject.Subject;
import FinalAssignment.state.ShopAPP;
import FinalAssignment.state.situation.State;
 
import java.util.Random;
 
public class CanPayState implements State {
    private int time=30;//订单付款倒计时
    ShopAPP app=null;
    boolean flag=false;//标记用户是否在规定时间付款
    Random random = new Random();//随机数种子  模拟用户在倒计时时间内付款
    int var;//接受随机产生的数字的临时变量
    public CanPayState(ShopAPP app) {
        this.app=app;
    }
 
 
    @Override
    public Goods placeOrder(Subject subject, String goodName) {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public boolean pay(Goods good, Observer consumer) {
        downTime();
        if(flag) {
            if (good.getPrice() > consumer.getMoney()) {
                System.out.println("你的余额不足!");
                return false;
            } else {
                consumer.setMoney(consumer.getMoney() - good.getPrice());
                //付款成功  设置状态为待发货状态
                System.out.println("支付成功!");
                app.setState(app.getWillShippedState());
            }
            return true;
        }else{
            //规定时间未付款  订单取消
            app.setState(app.getCancelledState());
            System.out.print("订单超时!");
        }
        return false;
    }
 
    @Override
    public void cancel(Goods goods) {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public boolean deliver() {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public void confirm() {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public boolean isNeedHelp() {
        return false;
    }
 
    @Override
    public void service() {
        System.out.println("你没有待售后订单");
    }
    //倒计时方法
    private  void downTime() {
        while (time > 0) {
            time--;
            try {
                var=random.nextInt(3);
                if (var==1){
                    flag=true;
                    //表示已付款
                    break;
                }
                Thread.sleep(1000);
                int hh = time / 60 / 60 % 60;
                int mm = time / 60 % 60;
                int ss = time % 60;
                System.out.println("还剩" + hh + "小时" + mm + "分钟" + ss + "秒将取消订单");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
 
//--------------------------------------------------------------------
package FinalAssignment.state.situation.impl;
/**
 * 待发货状态
 */
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.observer.Observer;
import FinalAssignment.observer.subject.Subject;
import FinalAssignment.state.ShopAPP;
import FinalAssignment.state.situation.State;
 
import java.util.Scanner;
 
public class WillShippedState implements State {
    ShopAPP app=null;
    public WillShippedState(ShopAPP app) {
        this.app=app;
    }
 
    @Override
    public Goods placeOrder(Subject subject, String goodName) {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public boolean pay(Goods good, Observer consumer) {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public void cancel(Goods good) {
        System.out.println("已发货，无法取消");
    }
 
    @Override
    public boolean deliver() {
        //还未发货之前用户可以选择是否取消订单
        System.out.println("是否取消订单?(0取消1不取消)");
        Scanner sc = new Scanner(System.in);
        if(sc.nextInt()==0){
            app.setState(app.getCancelledState());
            return false;
        }else {
            System.out.println("已发货");
            //改变状态为收货状态
            app.setState(app.getShippedState());
            return true;
        }
    }
 
    @Override
    public void confirm() {
        System.out.println("你还没有待处理订单");
    }
 
    @Override
    public boolean isNeedHelp() {
        return false;
    }
 
    @Override
    public void service() {
        System.out.println("你没有待售后订单");
    }
 
}
 
//--------------------------------------------------------------------
package FinalAssignment.state.situation.impl;
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.observer.Observer;
import FinalAssignment.observer.subject.Subject;
import FinalAssignment.state.ShopAPP;
import FinalAssignment.state.situation.State;
 
import java.util.Scanner;
 
/**
 * 已发货
 */
public class ShippedState implements State {
    private  int time = 3;//订单确认时间  超过该时间自动确认收货
    ShopAPP app=null;
    public ShippedState(ShopAPP app) {
        this.app=app;
    }
    @Override
    public Goods placeOrder(Subject subject,String goodName) {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public boolean pay(Goods good, Observer consumer) {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public void cancel(Goods goods) {
        System.out.println("已发货，无法取消");
    }
 
    @Override
    public boolean deliver() {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public void confirm() {
        //倒计时开始  结束自动确认收货
        downTime();
        //确认收货
        System.out.println("已确认收货!");
        app.setState(app.getCompletedState());
    }
 
    @Override
    public boolean isNeedHelp() {
        return false;
    }
 
    @Override
    public void service() {
        System.out.println("你没有待售后订单");
    }
    //倒计时方法
    private  void downTime() {
        while (time > 0) {
            time--;
            try {
                Thread.sleep(1000);
                int hh = time / 60 / 60 % 60;
                int mm = time / 60 % 60;
                int ss = time % 60;
                System.out.println("还剩" + hh + "小时" + mm + "分钟" + ss + "秒确认收货");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
 
//--------------------------------------------------------------------
package FinalAssignment.state.situation.impl;
/**
 * 售后状态
 */
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.observer.Observer;
import FinalAssignment.observer.subject.Subject;
import FinalAssignment.state.ShopAPP;
import FinalAssignment.state.situation.State;
 
public class AfterSaleState implements State {
    ShopAPP app=null;
    public AfterSaleState(ShopAPP app) {
        this.app=app;
    }
 
 
    @Override
    public Goods placeOrder(Subject subject, String goodName) {
       throw new UnsupportedOperationException();
    }
 
    @Override
    public boolean pay(Goods good, Observer consumer) {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public void cancel(Goods good) {
        System.out.println("已发货，无法取消");
    }
 
    @Override
    public boolean deliver() {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public void confirm() {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public boolean isNeedHelp() {
        return false;
    }
 
    @Override
    public void service() {
        System.out.println("已为你售后处理，请稍后为本次服务做出评价，欢迎你下次光临");
        //售后完成 本次订单完成  将状态设置为初始值
        app.setState(app.getNoPlaceOrderState());
    }
 
}
 
//--------------------------------------------------------------------
package FinalAssignment.state.situation.impl;
/**
 * 已完成订单状态
 */
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.observer.Observer;
import FinalAssignment.observer.subject.Subject;
import FinalAssignment.state.ShopAPP;
import FinalAssignment.state.situation.State;
 
import java.util.Scanner;
 
public class CompletedState implements State {
    Scanner sc = new Scanner(System.in);
    ShopAPP app=null;
    public CompletedState(ShopAPP app) {
        this.app=app;
    }
    @Override
    public Goods placeOrder(Subject subject,String goodName) {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public boolean pay(Goods good, Observer consumer) {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public void cancel(Goods goods) {
        System.out.println("已发货，无法取消");
    }
 
    @Override
    public boolean deliver() {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public void confirm() {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public boolean isNeedHelp(){
        System.out.println("是否需要售后服务?(0为取消，1为确认)");
        int flag = sc.nextInt();
        if (flag==0){
            System.out.println("恭喜你购物完成，欢迎你下次光临!");
            //本次订单完成  将状态设置为初始值
            app.setState(app.getNoPlaceOrderState());
            return false;
        }else if(flag==1){
            app.setState(app.getAfterSaleState());
            return true;
        }else {
            throw new UnsupportedOperationException();
        }
    }
 
    @Override
    public void service() {
 
    }
}
 
//--------------------------------------------------------------------
package FinalAssignment.state.situation.impl;
/**
 * 已取消状态
 */
 
import FinalAssignment.entity.Goods;
import FinalAssignment.observer.observer.Observer;
import FinalAssignment.observer.subject.Subject;
import FinalAssignment.state.ShopAPP;
import FinalAssignment.state.situation.State;
 
public class CancelledState implements State {
    ShopAPP app=null;
    public CancelledState(ShopAPP app) {
        this.app=app;
    }
    @Override
    public Goods placeOrder(Subject subject, String goodName) {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public boolean pay(Goods good, Observer consumer) {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public void cancel(Goods good) {
        System.out.println("订单已取消，已为你退款");
       good.setCount(good.getCount()+1);
        app.setState(app.getNoPlaceOrderState());
    }
 
    @Override
    public boolean deliver() {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public void confirm() {
        throw new UnsupportedOperationException();
    }
 
    @Override
    public boolean isNeedHelp() {
       throw new UnsupportedOperationException();
    }
 
    @Override
    public void service() {
        System.out.println("你没有待售后订单");
    }
}