Soso(嗖嗖)移動 java 項目

1。接口 通話服務

package Soso;

// 接口 通話服務

    public interface CallService {
        
    public abstract int call(int minCount, MobileCard card) throws Exception;
}

2.公共類

public class Common {

    // 實例化話嘮套餐
    static TalkPackage talkPackage = new TalkPackage(58, 500, 30);
    // 實例化網蟲套餐
    static NetPackage netPackage = new NetPackage(68, 3 * 1024);
    // 實例化超人套餐
    static SuperPackage superPackage = new SuperPackage(78, 200, 50, 1 * 1024);
}

3.消費信息類

//消費信息類

public class ConsumInfo {
    private String cardNumber; // 卡號
    private String type; // 消費類型
    private int consumData; // 消費數據

    public ConsumInfo() {
        super();
    }

    public ConsumInfo(String cardNumber, String type, int consumData) {
        super();
        this.cardNumber = cardNumber;
        this.type = type;
        this.consumData = consumData;
    }

    public String getCardNumber() {
        return cardNumber;
    }

    public void setCardNumber(String cardNumber) {
        this.cardNumber = cardNumber;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public int getConsumData() {
        return consumData;
    }

    public void setConsumData(int consumData) {
        this.consumData = consumData;
    }

}

4.嗖嗖移動卡類

public class MobileCard {
    private String cardNumber;// 卡號
    private String userName; // 用戶名
    private String passWord; // 密碼
    private ServicePackage serPackage; // 所屬套餐
    private double consumAmount; // 當月消費金額
    private double money; // 當月余額
    private int realTalkTime; // 當月實際通話時長
    private int realSMSCount; // 當月實際發送短信條數
    private int realFlow; // 當月實際上網流量

    public MobileCard() {
        super();
    }

    public MobileCard(String cardNumber, String userName, String passWord, ServicePackage serPackage,
            double consumAmount, double money, int realTalkTime, int realSMSCount, int realFlow) {
        super();
        this.cardNumber = cardNumber;
        this.userName = userName;
        this.passWord = passWord;
        this.serPackage = serPackage;
        this.consumAmount = consumAmount;
        this.money = money;
        this.realTalkTime = realTalkTime;
        this.realSMSCount = realSMSCount;
        this.realFlow = realFlow;
    }

    public String getCardNumber() {
        return cardNumber;
    }

    public void setCardNumber(String cardNumber) {
        this.cardNumber = cardNumber;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    public ServicePackage getSerPackage() {
        return serPackage;
    }

    public void setSerPackage(ServicePackage serPackage) {
        this.serPackage = serPackage;
    }

    public double getConsumAmount() {
        return consumAmount;
    }

    public void setConsumAmount(double consumAmount) {
        this.consumAmount = consumAmount;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public int getRealTalkTime() {
        return realTalkTime;
    }

    public void setRealTalkTime(int realTalkTime) {
        this.realTalkTime = realTalkTime;
    }

    public int getRealSMSCount() {
        return realSMSCount;
    }

    public void setRealSMSCount(int realSMSCount) {
        this.realSMSCount = realSMSCount;
    }

    public int getRealFlow() {
        return realFlow;
    }

    public void setRealFlow(int realFlow) {
        this.realFlow = realFlow;
    }

    // 顯示嗖嗖移動卡的信息
    public void showMeg() {

    }

5.話癆套餐

//話嘮套餐
public class NetPackage extends ServicePackage implements NetService {
    private int flow; // 上網流量

    public NetPackage() {
        super();
    }

    public NetPackage(double price, int flow) {
        super(price);
        this.flow = flow;
    }

    public int getFlow() {
        return flow;
    }

    public void setFlow(int flow) {
        this.flow = flow;
    }

    @Override
    // 返回使用流量數
    public int netPlay(int flow, MobileCard card) throws Exception {
        int temp = flow;
        for (int i = 0; i < flow; i++) {
            if (this.flow - card.getRealFlow() >= 1) {
                // 第一種情況：流量剩余夠 1 MB
                card.setRealFlow(card.getRealFlow() + 1);
            } else if (card.getMoney() >= 0.1) {
                // 第二種情況：套餐內流量已經用完，剩下話費夠支付 1 MB的流量
                card.setRealFlow(card.getRealFlow() + 1); // 實際短信數加 1 條
                // 賬戶余額消費0.1元，（1MB流量）
                card.setMoney(card.getMoney() - 0.1);
                card.setConsumAmount(card.getConsumAmount() + 0.1); // 當月消費金額 +
                                                                    // 0.1
            } else {
                temp = i; // 記錄使用流量多少MB
                throw new Exception("流量已經使用" + i + "MB，您的余額不足，請充值后再使用！");
                // System.err.println("流量已經使用" + i + "MB，您的余額不足，請充值后再使用！");
            }
        }
        return temp;
    }

    @Override
    public void showInfo() {
        System.out.println("網蟲套餐：上網流量為：" + (this.flow * 1.0 / 1024) + "GB/月," + "資費為：" + super.getPrice() + "元/月");
    }

6.接口 上網服務

public interface NetService {
    public abstract int netPlay(int flow, MobileCard card) throws Exception;
}

7.使用場景類

public class Scene {
    private String type; // 場景類型
    private int data; // 場景消費數據
    private String description; // 場景描述

    public Scene() {
        super();
    }

    public Scene(String type, int data, String description) {
        super();
        this.type = type;
        this.data = data;
        this.description = description;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

}

8.接口 短信服務

public interface SendService {
    public abstract int send(int count, MobileCard card) throws Exception;
}

9. 資費套餐類 ,是話嘮、網蟲、超人套餐的父類

public abstract class ServicePackage {
    private double price; // 月資費

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public ServicePackage() {
        super();
        // TODO Auto-generated constructor stub
    }

    public ServicePackage(double price) {
        super();
        this.price = price;
    }

    public abstract void showInfo();

}

10.

public class SuperPackage extends ServicePackage implements SendService, NetService, CallService {
    private int talkTime; // 通話時長
    private int smsCount; // 短信條數
    private int flow; // 上網流量
    private int price = 78;//價格

    public SuperPackage() {
        super();
    }

    public SuperPackage(double price, int talkTime, int smsCount, int flow) {
        super(price);
        this.talkTime = talkTime;
        this.smsCount = smsCount;
        this.flow = flow;
    }

    public int getTalkTime() {
        return talkTime;
    }

    public void setTalkTime(int talkTime) {
        this.talkTime = talkTime;
    }

    public int getSmsCount() {
        return smsCount;
    }

    public void setSmsCount(int smsCount) {
        this.smsCount = smsCount;
    }

    public int getFlow() {
        return flow;
    }

    public void setFlow(int flow) {
        this.flow = flow;
    }

    @Override
    // 返回通話時長
    public int call(int minCount, MobileCard card) throws Exception {
        int temp = minCount;
        for (int i = 0; i < minCount; i++) {
            if (this.talkTime - card.getRealTalkTime() >= 1) {
                // 第一種情況：套餐剩余通話時長可以支持1分鍾通話
                card.setRealTalkTime(card.getRealTalkTime() + 1);
            } else if (card.getMoney() >= 0.2) {
                // 第二種情況：套餐通話時長已用完，賬戶余額可以支付1分鍾通話，使用賬戶余額支付
                card.setRealTalkTime(card.getRealTalkTime() + 1); // 實際使用通話時長1分鍾
                // 賬戶余額消費0.2元（1分鍾 額外通話）
                card.setMoney(card.getMoney() - 0.2);
                card.setConsumAmount(card.getConsumAmount() + 0.2); // 當月消費金額 +
                                                                    // 0.2
            } else {
                temp = i; // 記錄實際通話分鍾數
                throw new Exception("本次已經通話" + i + "分鍾，您的余額不足，請充值后再使用！");
                // System.err.println("本次已經通話" + i + "分鍾，您的余額不足，請充值后再使用！");
            }
        }
        return temp;
    }

    @Override
    // 返回使用流量數
    public int netPlay(int flow, MobileCard card) throws Exception {
        int temp = flow;
        for (int i = 0; i < flow; i++) {
            if (this.flow - card.getRealFlow() >= 1) {
                // 第一種情況：流量剩余夠 1 MB
                card.setRealFlow(card.getRealFlow() + 1);
            } else if (card.getMoney() >= 0.1) {
                // 第二種情況：套餐內流量已經用完，剩下話費夠支付 1 MB的流量
                card.setRealFlow(card.getRealFlow() + 1); // 實際短信數加 1 條
                // 賬戶余額消費0.1元，（1MB流量）
                card.setMoney(card.getMoney() - 0.1);
                card.setConsumAmount(card.getConsumAmount() + 0.1); // 當月消費金額 +
                                                                    // 0.1
            } else {
                temp = i; // 記錄使用流量多少MB
                throw new Exception("流量已經使用" + i + "MB，您的余額不足，請充值后再使用！");
            }
        }
        return temp;
    }

    @Override
    // 返回實際發送短信條數
    public int send(int count, MobileCard card) throws Exception {
        int temp = count;
        for (int i = 0; i < count; i++) {
            if (this.smsCount - card.getRealSMSCount() >= 1) {
                // 第一種情況：套餐剩余短信數能夠發送一個短信
                card.setRealSMSCount(card.getRealSMSCount() + 1);
            } else if (card.getMoney() >= 0.1) {
                // 第二種情況：套餐內短信已經用完，剩下話費能夠允許發一條短信
                card.setRealSMSCount(card.getRealSMSCount() + 1); // 實際短信數加 1 條
                // 賬戶余額消費0.1元，（一條短信）
                card.setMoney(card.getMoney() - 0.1);
                card.setConsumAmount(card.getConsumAmount() + 0.1); // 當月消費金額 +
                                                                    // 0.1
            } else {
                temp = i; // 記錄發短信條數
                throw new Exception("短信已經發送" + i + "條，您的余額不足，請充值后再使用！");
            }
        }
        return temp;
    }

    @Override
    public void showInfo() {
        System.out.println("超人套餐：通話時長為：" + this.talkTime + "分鍾/月," + "短信條數為：" + this.smsCount + "條/每月," + "上網流量為："
                + (this.flow * 1.0 / 1024) + "GB/月," + "資費為:" + super.getPrice() + "元/月");
    }

 

11

public class TalkPackage extends ServicePackage implements CallService, SendService {
    private int talkTime;// 通話時長
    private int smsCount;// 短信條數

    public TalkPackage() {
        super();
    }

    public TalkPackage(double price, int talkTime, int smsCount) {
        super(price);
        this.talkTime = talkTime;
        this.smsCount = smsCount;
    }

    public int getTalkTime() {
        return talkTime;
    }

    public void setTalkTime(int talkTime) {
        this.talkTime = talkTime;
    }

    public int getSmsCount() {
        return smsCount;
    }

    public void setSmsCount(int smsCount) {
        this.smsCount = smsCount;
    }

    @Override
    // 返回通話時長
    public int call(int minCount, MobileCard card) throws Exception {
        int temp = minCount;
        for (int i = 0; i < minCount; i++) {
            if (this.talkTime - card.getRealTalkTime() >= 1) {
                // 第一種情況：套餐剩余通話時長可以支持1分鍾通話
                card.setRealTalkTime(card.getRealTalkTime() + 1);
            } else if (card.getMoney() >= 0.2) {
                // 第二種情況：套餐通話時長已用完，賬戶余額可以支付1分鍾通話，使用賬戶余額支付
                card.setRealTalkTime(card.getRealTalkTime() + 1); // 實際使用通話時長1分鍾
                // 賬戶余額消費0.2元（1分鍾 額外通話）
                card.setMoney(card.getMoney() - 0.2);
                card.setConsumAmount(card.getConsumAmount() + 0.2); // 當月消費金額 +
                                                                    // 0.2
            } else {
                temp = i; // 記錄實際通話分鍾數
                throw new Exception("本次已經通話" + i + "分鍾，您的余額不足，請充值后再使用！");
            }
        }
        return temp;
    }

    @Override
    // 返回實際發送短信條數
    public int send(int count, MobileCard card) throws Exception {
        int temp = count;
        for (int i = 0; i < count; i++) {
            if (this.smsCount - card.getRealSMSCount() >= 1) {
                // 第一種情況：套餐剩余短信數能夠發送一個短信
                card.setRealSMSCount(card.getRealSMSCount() + 1);
            } else if (card.getMoney() >= 0.1) {
                // 第二種情況：套餐內短信已經用完，剩下話費能夠允許發一條短信
                card.setRealSMSCount(card.getRealSMSCount() + 1); // 實際短信數加 1 條
                // 賬戶余額消費0.1元，（一條短信）
                card.setMoney(card.getMoney() - 0.1);
                card.setConsumAmount(card.getConsumAmount() + 0.1); // 當月消費金額 +
                                                                    // 0.1
            } else {
                temp = i; // 記錄發短信條數
                throw new Exception("短信已經發送" + i + "條，您的余額不足，請充值后再使用！");
                // System.err.println("短信已經發送" + i + "條，您的余額不足，請充值后再使用！");
            }
        }
        return temp;
    }

    @Override
    public void showInfo() {
        System.out.println(
                "話嘮套餐：通話時長為：" + this.talkTime + "分鍾/月,短信條數為：" + this.smsCount + "條/月,資費為：" + super.getPrice() + "元/月");
    }

}

12

package Soso;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;

//工具類

public class CardUtil {

    protected static Map<String, MobileCard> cards = new HashMap<String, MobileCard>(); // 已注冊嗖嗖移動用戶列表

    protected static Map<String, List<ConsumInfo>> consumInfos = new HashMap<String, List<ConsumInfo>>(); // 所有卡號的消費記錄列表

    protected static Map<Integer, Scene> scenes = new HashMap<Integer, Scene>();// 使用場景列表

    protected static Scene scene0 = new Scene("通話", 90, "把領導罵了一頓非常過癮，通話90分鍾");
    protected static Scene scene1 = new Scene("通話", 30, "打電話給金沂，通話30分鍾");
    protected static Scene scene2 = new Scene("短信", 5, "沒事閑的發短信玩，發送短信5條");
    protected static Scene scene3 = new Scene("短信", 50, "通知朋友手機換號，發送短信50條");
    protected static Scene scene4 = new Scene("上網", 1024, "晚上偷看小視頻，使用流量1GB");
    protected static Scene scene5 = new Scene("上網", 2 * 1024, "晚上偷看小視頻，不留神睡着啦！使用2GB");
    protected static Scanner input = new Scanner(System.in);

    public CardUtil() {
        super();
    }

    // 注冊新卡
    public static void addCard(MobileCard card) {
        cards.put(card.getCardNumber(), card);
    }

    // 話費充值
    public static void chargeMoney(String number) {
        System.out.println("請輸入要充值的金額(不少於50元)：");
        while (true) {
            double money = 0.0;
            while (true) {
                Scanner input = new Scanner(System.in);
                if (input.hasNextDouble() == true) {
                    money = input.nextDouble();
                    break;
                } else {
                    System.out.print("輸入錯誤！請重新輸入:");

                }
            }
            if (money < 50) {
                System.out.println("輸入金額少於50元請重新輸入：");
                continue;
            } else {
                cards.get(number).setMoney(cards.get(number).getMoney() + money);
                System.out.println("充值成功，當前話費余額為" + dataFormat(cards.get(number).getMoney()));
                break;
            }
        }

    }

    // 使用嗖嗖
    public static void userSoso(String number) {
        // 添加場景Map集合的鍵值對
        scenes.put(0, scene0);
        scenes.put(1, scene1);
        scenes.put(2, scene2);
        scenes.put(3, scene3);
        scenes.put(4, scene4);
        scenes.put(5, scene5);

        MobileCard card = cards.get(number); // 獲取此卡對象
        ServicePackage pack = card.getSerPackage(); // 獲取此卡所屬套餐
        Random random = new Random();
        int ranNum = 0;
        int temp = 0; // 記錄各場景中的實際消費數據
        do {
            ranNum = random.nextInt(6);
            Scene scene = scenes.get(ranNum); // 獲取該序號所有對應的場景
            switch (ranNum) {
            case 0:
            case 1:
                // 序號為0或1的通話場景
                // 獲取該卡所屬套餐是否支持通話功能
                if (pack instanceof CallService) {
                    // 執行通話方法
                    System.out.println(scene.getDescription());
                    CallService callService = (CallService) pack;
                    try {
                        temp = callService.call(scene.getData(), card);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    // 添加一條消費記錄
                    addConsumInfo(number, new ConsumInfo(number, scene.getType(), temp));
                    break;
                } else {
                    // 如果該卡套餐不支持通話功能，則重新生成隨機數選擇其他場景
                    continue;
                }
            case 2:
            case 3:
                // 序號2或3發短信場景
                // 獲取該卡所屬套餐是否支持短信
                if (pack instanceof SendService) {
                    // 執行短信方法
                    System.out.println(scene.getDescription());
                    SendService sendService = (SendService) pack;
                    try {
                        temp = sendService.send(scene.getData(), card);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    // 添加一條消費記錄
                    addConsumInfo(number, new ConsumInfo(number, scene.getType(), temp));
                    break;
                } else {
                    // 如果該卡套餐不支持短信功能，則重新生成隨機數選擇其他場景
                    continue;
                }
            case 4:
            case 5:
                // 獲取該卡所屬套餐是否支持上網
                if (pack instanceof NetService) {
                    // 執行上網方法
                    System.out.println(scene.getDescription());
                    NetService netService = (NetService) pack;
                    try {
                        temp = netService.netPlay(scene.getData(), card);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    // 添加一條消費記錄
                    addConsumInfo(number, new ConsumInfo(number, scene.getType(), temp));
                    break;
                } else {
                    // 如果該卡套餐不支持上網功能，則重新生成隨機數選擇其他場景
                    continue;
                }
            }
            break;
        } while (true);
    }

    // 資費說明
    public static void showDescription() {
        FileReader fr = null;
        BufferedReader br = null;
        try {
            // 創建一個FileReader對象
            fr = new FileReader("e:/套餐資費說明.txt");
            // 創建一個BufferedReader對象
            br = new BufferedReader(fr);
            // 讀取一行數據
            String line = null;

            while ((line = br.readLine()) != null) {

                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
                if (fr != null) {
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 本月賬單查詢
    public static void showAmountDetail(String number) {
        MobileCard mobileCard = cards.get(number);
        System.out.println("您的卡號為：" + mobileCard.getCardNumber());
        System.out.println("當月賬單如下：");
        System.out.println("套餐資費：" + dataFormat(mobileCard.getSerPackage().getPrice()) + "元" + "\t合計消費："
                + dataFormat(mobileCard.getConsumAmount()) + "元" + "\t賬戶余額：" + dataFormat(mobileCard.getMoney()) + "元");
    }

    // 套餐余量查詢
    public static void showRemainDetail(String searchNumber) {
        MobileCard mobileCard = cards.get(searchNumber);
        int remainTalkTime;
        int remainSmsCount;
        int remainFlow;
        StringBuffer meg = new StringBuffer();
        meg.append("您的卡號是" + searchNumber + ",套餐內剩余：\n");
        ServicePackage pack = mobileCard.getSerPackage();
        if (pack instanceof TalkPackage) {
            // 向下轉型為話嘮對象
            TalkPackage cardPack = (TalkPackage) pack;
            // 話嘮套餐,查詢套餐內剩余的通話時長和短信數
            remainTalkTime = cardPack.getTalkTime() > mobileCard.getRealTalkTime()
                    ? cardPack.getTalkTime() - mobileCard.getRealTalkTime() : 0;
            meg.append("通話時長：" + remainTalkTime + "分鍾\n");
            remainSmsCount = cardPack.getSmsCount() > mobileCard.getRealSMSCount()
                    ? cardPack.getSmsCount() - mobileCard.getRealSMSCount() : 0;
            meg.append("短信條數：" + remainSmsCount + "條");
        } else if (pack instanceof NetPackage) {
            // 向下轉型為網蟲對象
            NetPackage cardPack = (NetPackage) pack;
            // 網蟲套餐查詢上網流量
            remainFlow = cardPack.getFlow() > mobileCard.getRealFlow() ? cardPack.getFlow() - mobileCard.getRealFlow()
                    : 0;
            meg.append("上網流量：" + dataFormat(remainFlow * 1.0 / 1024) + "GB");
        } else if (pack instanceof SuperPackage) {
            // 向下轉型為超人對象
            SuperPackage cardPack = (SuperPackage) pack;
            // 超人套餐查詢通話時長、上網流量、短信條數。
            remainTalkTime = cardPack.getTalkTime() > mobileCard.getRealTalkTime()
                    ? cardPack.getTalkTime() - mobileCard.getRealTalkTime() : 0;
            meg.append("通話時長：" + remainTalkTime + "分鍾\n");
            remainFlow = cardPack.getFlow() > mobileCard.getRealFlow() ? cardPack.getFlow() - mobileCard.getRealFlow()
                    : 0;
            meg.append("上網流量：" + dataFormat(remainFlow * 1.0 / 1024) + "GB");
            remainSmsCount = cardPack.getSmsCount() > mobileCard.getRealSMSCount()
                    ? cardPack.getSmsCount() - mobileCard.getRealSMSCount() : 0;
            meg.append("短信條數：" + remainSmsCount + "條");
        }
        System.out.println(meg);

    }

    // 打印消費詳單
    public static void printAmountDetail(String number) {
        Writer fileWriter = null;

        try {

            fileWriter = new FileWriter(number + "消費記錄.txt");
            Set<String> numbers = consumInfos.keySet();
            Iterator<String> it = numbers.iterator();
            List<ConsumInfo> infos = new ArrayList<ConsumInfo>();
            infos = consumInfos.get(number);
            // 存儲指定卡的所有消費記錄
            // 現有消費列表中是否存在此卡號的消費記錄，是：true 否：false
            boolean isExist = false;
            while (it.hasNext()) {
                String numberKey = it.next();
                if (number.equals(numberKey)) {
                    isExist = true;
                }
            }
            if (isExist) {
                StringBuffer content = new StringBuffer("***********" + number + "消費記錄************\n");
                content.append("序號\t類型\t數據（通話（分鍾）/上網（MB）/短信（條））\n");
                for (int i = 0; i < infos.size(); i++) {
                    ConsumInfo info = infos.get(i);
                    content.append((i + 1) + ".\t" + info.getType() + "\t" + info.getConsumData() + "\n");
                }

                fileWriter.write(content.toString());
                fileWriter.flush();
                System.out.println("消息記錄打印完畢！");
            } else {
                System.out.println("對不起，不存在此號碼的消費記錄，不能夠打印！");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 套餐變更
    public static void changingPack(String number) {
        System.out.println("1.話嘮套餐 2.網蟲套餐 3.超人套餐 ：請選擇(序號)：");
        int packNum = input.nextInt();
        switch (packNum) {
        case 1: // 選擇變更的套餐為話嘮套餐
            if (cards.get(number).getSerPackage() instanceof TalkPackage) {
                System.out.println("對不起，您已經是該套餐用戶，無需換套餐！");
            } else {
                if (cards.get(number).getMoney() < cards.get(number).getSerPackage().getPrice()) {// 如果剩余費用不夠支持新的套餐費用

                    System.out.println("對不起,您的的余額不足以支付新的套餐本月資費，請充值后再辦理業務！");

                } else {

                    cards.get(number).setRealSMSCount(0);
                    cards.get(number).setRealTalkTime(0);
                    cards.get(number).setRealFlow(0);
                    cards.get(number).setSerPackage(Common.talkPackage);
                    System.out.println("套餐更換成功！");
                    Common.talkPackage.showInfo();

                }
            }

            break;

        case 2: // 選擇變更的套餐為網蟲套餐
            if (cards.get(number).getSerPackage() instanceof NetPackage) {
                System.out.println("對不起，您已經是該套餐用戶，無需換套餐！");
            } else {
                if (cards.get(number).getMoney() < cards.get(number).getSerPackage().getPrice()) {// 如果剩余費用不夠支持新的套餐費用
                    System.out.println("對不起,您的的余額不足以支付新的套餐本月資費，請充值后再辦理業務！");
                } else {
                    cards.get(number).setRealSMSCount(0);
                    cards.get(number).setRealTalkTime(0);
                    cards.get(number).setRealFlow(0);
                    cards.get(number).setSerPackage(Common.netPackage);
                    System.out.println("套餐更換成功！");
                    Common.netPackage.showInfo();

                }
            }

            break;

        case 3:// 選擇變更的套餐為超人套餐
            if (cards.get(number).getSerPackage() instanceof SuperPackage) {
                System.out.println("對不起，您已經是該套餐用戶，無需換套餐！");
            } else {
                if (cards.get(number).getMoney() < cards.get(number).getSerPackage().getPrice()) {// 如果剩余費用不夠支持新的套餐費用
                    System.out.println("對不起,您的的余額不足以支付新的套餐本月資費，請充值后再辦理業務！");
                } else {
                    cards.get(number).setRealSMSCount(0);
                    cards.get(number).setRealTalkTime(0);
                    cards.get(number).setRealFlow(0);
                    cards.get(number).setSerPackage(Common.superPackage);
                    System.out.println("套餐更換成功！");
                    Common.superPackage.showInfo();

                }
            }
            break;
        }
    }

    // 辦理退網
    public static void delCard(String number) {
        Set<String> numberKeys = cards.keySet();
        Iterator<String> it = numberKeys.iterator();
        while (it.hasNext()) {
            String numberKey = it.next();
            if (numberKey.equals(number)) {
                cards.remove(numberKey);
                // 下面這這句話可能會報異常標記*
                System.out.println("卡號" + number + "辦理退網成功\n謝謝使用！");
            } else {
                System.out.println("辦理退卡失敗！");
            }
        }
    }

    // 根據卡號和密碼驗證該卡是否注冊
    public static boolean isExistCard(String number, String passWord) {
        if (cards.size() != 0) {
            Set<String> numberKeys = cards.keySet();
            // System.out.println(numberKeys);
            Iterator<String> its = numberKeys.iterator();
            while (its.hasNext()) {
                String numberKey = its.next();
                MobileCard mobileCard = cards.get(numberKey); // 根據key取出對應的值
                if (number.trim().equals(numberKey.trim()) && passWord.trim().equals(mobileCard.getPassWord().trim())) {
                    System.out.println("該用戶存在，且帳號密碼都正確");
                    return true;
                } else if (number.trim().equals(numberKey.trim()) == true
                        && passWord.trim().equals(mobileCard.getPassWord().trim()) == false) {
                    System.out.println("該用戶存在，但密碼錯誤");
                    return false;
                }

            }
            System.out.println("該用戶不存在");
            return false;
        } else {
            System.out.println("cards集合為空，不存在用戶！");
            return false;
        }

    }

    // 根據卡號驗證該卡號是否注冊
    public static boolean isExistCard(String number) {
        if (cards.size() != 0) {
            Set<String> numberKeys = cards.keySet();
            Iterator<String> its = numberKeys.iterator();
            while (its.hasNext()) {
                if (number.equals(its.next())) {
                    // System.out.println("該用戶已經注冊！");
                    return true;
                }

            }
            System.out.println("該用戶不存在！");
            return false;
        } else {
            System.out.println("cards集合為空，不存在用戶！");
            return false;
        }
    }

    // 生成隨機卡號
    public static String createNumber() {
        Random random = new Random();
        // 記錄現有用戶中是否存在此卡號用戶 是：true 否：false
        boolean isExist = false;
        String number = "";
        int temp = 0;
        do {
            isExist = false;// 標志位重置為false,用於控制外重循環
            // 生成的隨機數是8位，不能小於10000000，否則重新生成
            // 回頭重寫這段代碼，執行效率太低
            do {
                temp = random.nextInt(100000000);
            } while (temp < 10000000);
            // 生成之前，前面加“139”
            number = "139" + temp;
            // 和現有用戶的卡號比較，不能是重復的
            if (cards != null) { // 價格判斷 否則 下方的一句會報空指針異常
                Set<String> cardNumbers = cards.keySet();
                for (String cardNumber : cardNumbers) {
                    if (number.equals(cardNumber)) {
                        isExist = true;
                        break;
                    }
                }
            }

        } while (isExist);
        return number;
    }

    // 生成指定個數的卡號列表 (回頭嘗試是否可以通過返回集合列表的方式顯示)
    public static String[] getNewNumbers(int count) {
        String[] strs = new String[count];
        for (int i = 0; i < count; i++) {
            strs[i] = createNumber(); // 通過隨機生成給strs[i]賦值
        }
        return strs;
    }

    // 添加指定卡號的消費記錄
    public static void addConsumInfo(String number, ConsumInfo info) {
        if (consumInfos.containsKey(number)) {
            consumInfos.get(number).add(info);
        } else {
            List<ConsumInfo> list = new ArrayList<ConsumInfo>();
            list.add(info);
            consumInfos.put(number, list);
        }
    }

    // 將double數據格式化輸出
    public static String dataFormat(double data) {
        DecimalFormat formatData = new DecimalFormat("#0.0");
        return formatData.format(data);
    }
}

13

package Soso;

// 超人套餐類

public class SuperPackage extends ServicePackage implements SendService, NetService, CallService {
    private int talkTime; // 通話時長
    private int smsCount; // 短信條數
    private int flow; // 上網流量
    private int price = 78;//價格

    public SuperPackage() {
        super();
    }

    public SuperPackage(double price, int talkTime, int smsCount, int flow) {
        super(price);
        this.talkTime = talkTime;
        this.smsCount = smsCount;
        this.flow = flow;
    }

    public int getTalkTime() {
        return talkTime;
    }

    public void setTalkTime(int talkTime) {
        this.talkTime = talkTime;
    }

    public int getSmsCount() {
        return smsCount;
    }

    public void setSmsCount(int smsCount) {
        this.smsCount = smsCount;
    }

    public int getFlow() {
        return flow;
    }

    public void setFlow(int flow) {
        this.flow = flow;
    }

    @Override
    // 返回通話時長
    public int call(int minCount, MobileCard card) throws Exception {
        int temp = minCount;
        for (int i = 0; i < minCount; i++) {
            if (this.talkTime - card.getRealTalkTime() >= 1) {
                // 第一種情況：套餐剩余通話時長可以支持1分鍾通話
                card.setRealTalkTime(card.getRealTalkTime() + 1);
            } else if (card.getMoney() >= 0.2) {
                // 第二種情況：套餐通話時長已用完，賬戶余額可以支付1分鍾通話，使用賬戶余額支付
                card.setRealTalkTime(card.getRealTalkTime() + 1); // 實際使用通話時長1分鍾
                // 賬戶余額消費0.2元（1分鍾 額外通話）
                card.setMoney(card.getMoney() - 0.2);
                card.setConsumAmount(card.getConsumAmount() + 0.2); // 當月消費金額 +
                                                                    // 0.2
            } else {
                temp = i; // 記錄實際通話分鍾數
                throw new Exception("本次已經通話" + i + "分鍾，您的余額不足，請充值后再使用！");
                // System.err.println("本次已經通話" + i + "分鍾，您的余額不足，請充值后再使用！");
            }
        }
        return temp;
    }

    @Override
    // 返回使用流量數
    public int netPlay(int flow, MobileCard card) throws Exception {
        int temp = flow;
        for (int i = 0; i < flow; i++) {
            if (this.flow - card.getRealFlow() >= 1) {
                // 第一種情況：流量剩余夠 1 MB
                card.setRealFlow(card.getRealFlow() + 1);
            } else if (card.getMoney() >= 0.1) {
                // 第二種情況：套餐內流量已經用完，剩下話費夠支付 1 MB的流量
                card.setRealFlow(card.getRealFlow() + 1); // 實際短信數加 1 條
                // 賬戶余額消費0.1元，（1MB流量）
                card.setMoney(card.getMoney() - 0.1);
                card.setConsumAmount(card.getConsumAmount() + 0.1); // 當月消費金額 +
                                                                    // 0.1
            } else {
                temp = i; // 記錄使用流量多少MB
                throw new Exception("流量已經使用" + i + "MB，您的余額不足，請充值后再使用！");
            }
        }
        return temp;
    }

    @Override
    // 返回實際發送短信條數
    public int send(int count, MobileCard card) throws Exception {
        int temp = count;
        for (int i = 0; i < count; i++) {
            if (this.smsCount - card.getRealSMSCount() >= 1) {
                // 第一種情況：套餐剩余短信數能夠發送一個短信
                card.setRealSMSCount(card.getRealSMSCount() + 1);
            } else if (card.getMoney() >= 0.1) {
                // 第二種情況：套餐內短信已經用完，剩下話費能夠允許發一條短信
                card.setRealSMSCount(card.getRealSMSCount() + 1); // 實際短信數加 1 條
                // 賬戶余額消費0.1元，（一條短信）
                card.setMoney(card.getMoney() - 0.1);
                card.setConsumAmount(card.getConsumAmount() + 0.1); // 當月消費金額 +
                                                                    // 0.1
            } else {
                temp = i; // 記錄發短信條數
                throw new Exception("短信已經發送" + i + "條，您的余額不足，請充值后再使用！");
            }
        }
        return temp;
    }

    @Override
    public void showInfo() {
        System.out.println("超人套餐：通話時長為：" + this.talkTime + "分鍾/月," + "短信條數為：" + this.smsCount + "條/每月," + "上網流量為："
                + (this.flow * 1.0 / 1024) + "GB/月," + "資費為:" + super.getPrice() + "元/月");
    }
}