嗖嗖移動大廳業務的整體架構思路和代碼實現

本文轉載自查看原文 2019-12-18 17:37 899

整體架構思路：
分為6個功能區，使用switch case結構包圍，分別是：
1.用戶登錄
2.用戶注冊
3.使用嗖嗖
4.話費充值
5.資費說明
6.退出系統

功能區模塊：
1.用戶登錄：用if else結構整體判斷是否存在該用戶
如果存在：調用用戶登錄的方法：
此時有5個業務分支，用switch case結構：
1.本月賬單查詢
輸出本月消費詳細信息
2.套餐余量查詢
分別判斷用戶屬於三種套餐的哪一種，
然后輸出套餐余量
3.打印消費詳單
用到字符流寫出的技能；
判斷是否存在消費記錄，如果不存在，則提示不存在此卡的消費記錄；
如果存在，則利用Filewriter字符流寫出記錄，
4.套餐變更
判斷用戶是哪個套餐，如果是本套餐：
提示用戶已經是本套餐，不需要換；
如果是其他套餐：
判斷用戶余額是否大於要換的套餐，如果余額不夠，提示用戶余額不足以支付新套餐的費用，讓其充值，如果余額夠，則用card.set屬性接收新套餐。
5.辦理退網
判斷卡號是否存在，如果不存在，提示用戶卡號不存在，不能退網！
如果存在使用remove（）方法移除卡號

如果不存在：輸入：對不起您輸入的信息有誤

2.用戶注冊
1.使用集合存放9個號碼，通過下標定位用戶選擇的號碼
根據需求，9個號碼每行三列，用數組下標對3取余的方式實現換行
2.選擇套餐類型，三個類型，話癆，網蟲，超人，（三個套餐各建一個類來實現具體方法）
3.輸入用戶名，密碼，並接收
4.輸入預存話費金額，此時要判斷用戶存的錢是否小於月套餐資費，如果小於月套餐資費，提示用戶預存的話費金額不足，讓用戶繼續充值。
5.最后創建新卡，並提示用戶卡號，用戶名，當前余額等信息。

3.使用嗖嗖
也要先判斷用戶是否存在，存在的話，開始實現搜搜功能，此時利用生成隨機數1-5，生成5個不同場景。

如果不存在提示用戶注冊

4.話費充值

判斷卡號是否存在，如果存在，開始充話費，此卡的金額信息接收存入的金額，這里面可以細化，判斷用戶沖多少錢，如果小於50，提示用戶重新充值，必須大於50元起充。
如果不存在，提示用戶注冊

5.資費說明
此功能塊，用到文檔的讀寫相關技能，使用字符流FileReader讀入資費說明的txt文檔。

6.退出系統
輸入“謝謝使用！”

  1 public class SosoMgr {
  2     Scanner input = new Scanner(System.in);
  3     CardUtil utils = new CardUtil();
  4     
  5     public static void main(String[] args) {
  6         SosoMgr soso = new SosoMgr();
  7         soso.mainMenu();
  8         System.out.println("謝謝使用！");
  9     }
 10 
 11     /**
 12      * 主流程
 13      */
 14     public void mainMenu() {
 15         int menuChoose = 0;
 16         String mobileNumber= "";
 17         String password = "";
 18         utils.init();
 19         utils.initScenes();
 20         //Common.typesInit();
 21         do {
 22             System.out.println("\n*************歡迎使用嗖嗖移動業務大廳***************");
 23             System.out.println("1.用戶登錄   2.用戶注冊   3.使用嗖嗖   4.話費充值  5.資費說明  6.退出系統");
 24             System.out.print("請選擇：");
 25             menuChoose = input.nextInt();
 26             // 分支語句：根據功能編號執行相應功能
 27             switch (menuChoose) {
 28             case 1:
 29                 //用戶登錄
 30                 System.out.print("請輸入手機卡號：");
 31                 mobileNumber = input.next();
 32                 System.out.print("請輸入密碼：");
 33                 password = input.next();
 34                 if (utils.isExistCard(mobileNumber, password)) {
 35                     cardMenu(mobileNumber);
 36                 }else{
 37                     System.out.println("對不起，您輸入的信息有誤，無法登錄！");
 38                 }
 39                 continue;
 40             case 2:
 41                 //用戶注冊
 42                 registCard();
 43                 continue;
 44             case 3:
 45                 //使用嗖嗖
 46                 System.out.print("請輸入手機卡號：");
 47                 mobileNumber = input.next();                
 48                 if (utils.isExistCard(mobileNumber)) {
 49                     try {
 50                         utils.userSoso(mobileNumber);
 51                     } catch (Exception e) {
 52                         System.err.println(e.getMessage());
 53                     }
 54                 }else{
 55                     System.out.println("對不起，該卡號未注冊，不能使用！");
 56                 }
 57                 continue;
 58             case 4:
 59                 //話費充值
 60                 System.out.print("請輸入充值卡號：");
 61                 mobileNumber = input.next();
 62                 if (utils.isExistCard(mobileNumber)) {
 63                 System.out.print("請輸入充值金額：");
 64                 double money = input.nextDouble();                
 65                 utils.chargeMoney(mobileNumber, money);
 66                 }else{
 67                     System.out.println("對不起，要充值的卡號未注冊，無法充值！");
 68                 }
 69                 continue;                
 70             case 5:
 71                 //System.out.println("\n*****資費說明******");
 72                 utils.showDescription();
 73                 continue;    
 74             case 6:
 75                 //退出系統
 76                 break;
 77             default:
 78                 //選擇其他數字退出系統
 79                 break;
 80             }
 81             break;
 82         } while (true);
 83     }
 84 
 85     /**
 86      * 手機卡功能菜單
 87      */
 88     public int cardMenu(String mobileNumber) {
 89            int menuChoose = 0;
 90         do {
 91             System.out.println("\n*****嗖嗖移動用戶菜單*****");
 92             System.out.println("1.本月賬單查詢");
 93             System.out.println("2.套餐余量查詢");
 94             System.out.println("3.打印消費詳單");
 95             System.out.println("4.套餐變更");
 96             System.out.println("5.辦理退網");
 97             System.out.print("請選擇(輸入1~5選擇功能，其他鍵返回上一級)：");
 98              menuChoose = input.nextInt();
 99             switch (menuChoose) {
100             case 1:
101                 System.out.println("\n*****本月賬單查詢******");
102                 utils.showAmountDetail(mobileNumber);
103                 continue;
104             case 2:
105                 System.out.println("\n*****套餐余量查詢******");
106                 utils.showRemainDetail(mobileNumber);
107                 continue;
108             case 3:
109                 System.out.println("\n*****消費詳單查詢******");
110                 utils.printConsumInfo(mobileNumber);
111                 continue;
112             case 4:
113                 System.out.println("\n*****套餐變更******");
114                 System.out.print("1.話嘮套餐  2.網蟲套餐  3.超人套餐  請選擇（序號）：");                
115                 utils.changingPack(mobileNumber, input.nextInt());
116                 continue;
117             case 5:
118                 System.out.println("\n*****辦理退網******");
119                 utils.delCard(mobileNumber);
120                 System.out.println("謝謝使用！");
121                 System.exit(1);     //辦理退網后退出系統    
122                         
123             }
124             
125             break;
126         } while (true);
127         return menuChoose;
128     }
129     
130     /**
131      * 注冊新卡流程
132      */
133     public void registCard(){
134         //1.獲取卡號信息集合
135         String[] newNumbers = utils.getNewNumbers(9);
136         
137         //2.(每行三列)顯示可供選擇的手機號列表
138         System.out.println("*****可選擇的卡號*****");
139         for(int i=0;i<9;i++){
140             System.out.print((i+1)+"."+newNumbers[i]+"\t\t");
141             if((i+1)%3==0){
142                 System.out.println();
143             }
144         }
145         
146         //3.選擇手機號
147         System.out.print("請選擇卡號（輸入1~9的序號）：");        
148         String number = newNumbers[input.nextInt()-1];
149         
150         //4.選擇套餐類型
151         System.out.print("1.話嘮套餐  2.網蟲套餐  3.超人套餐，  ");
152         System.out.print("請選擇套餐(輸入序號)：");
153         ServicePackage pack = utils.createPack(input.nextInt());
154         
155         //5.輸入用戶名
156         System.out.print("請輸入姓名：");
157         String name = input.next();
158         
159         //6.輸入密碼
160         System.out.print("請輸入密碼：");
161         String password = input.next();
162         
163         //7.輸入預存話費金額
164         double money = 0;
165         System.out.print("請輸入預存話費金額：");
166          money = input.nextDouble();
167         while(money<pack.getPrice()){
168             System.out.print("您預存的話費金額不足以支付本月固定套餐資費，請重新充值：");
169             money = input.nextDouble();
170         }
171                 
172         //8.創建新卡對象並添加一條數據
173         MobileCard newCard = new MobileCard(name,password,number,pack,pack.getPrice(),money-pack.getPrice());
174         utils.addCard(newCard);        
175     }
176 }

 1 public class Common {
 2     /**
 3      * double類型格式化
 4      */
 5     public static String dataFormat(double data) {
 6         DecimalFormat formatData = new DecimalFormat("#.0");
 7         return formatData.format(data);
 8     }
 9     
10     /**
11      * double類型兩數相減
12      */
13     public static double sub(double num1,double num2){
14         return (num1*10-num2*10)/10;
15     }
16 }

1 public enum ConsumType {
2    TALK,SMS,NETWORK
3 }

 1 public class ConsumInfo {
 2     private String cardNumber;  //卡號
 3     private String type;  //消費類型：通話、發短信、上網
 4     private int consumData;   //消費數據   通話：分鍾   發短信：條   上網：MB
 5     
 6     public ConsumInfo(){}
 7     public ConsumInfo(String cardNumber, String type, int consumData) {
 8         super();
 9         this.cardNumber = cardNumber;
10         this.type = type;
11         this.consumData = consumData;
12     }
13     public String getCardNumber() {
14         return cardNumber;
15     }
16     public void setCardNumber(String cardNumber) {
17         this.cardNumber = cardNumber;
18     }
19     public String getType() {
20         return type;
21     }
22     public void setType(String type) {
23         this.type = type;
24     }
25     public int getConsumData() {
26         return consumData;
27     }
28     public void setConsumData(int consumData) {
29         this.consumData = consumData;
30     }    
31 }

  1 public class MobileCard {
  2     private String cardNumber;  //卡號
  3     private String userName;  //用戶名
  4     private String passWord;  //密碼    
  5     private ServicePackage serPackage;  //所屬套餐
  6     private double consumAmount;  //當月消費金額
  7     private double money;  //賬戶余額
  8     private int realTalkTime;  //實際通話時長（分鍾）
  9     private int realSMSCount;  //實際發送短信條數（條）
 10     private int realFlow;  //實際上網流量
 11     
 12     public MobileCard(){}
 13 
 14     public MobileCard(String userName, String passWord, String cardNumber,
 15             ServicePackage serPackage, double consumAmount, double money) {
 16         super();
 17         this.userName = userName;
 18         this.passWord = passWord;
 19         this.cardNumber = cardNumber;
 20         this.serPackage = serPackage;
 21         this.consumAmount = consumAmount;
 22         this.money = money;
 23     }
 24 
 25     public String getUserName() {
 26         return userName;
 27     }
 28 
 29     public void setUserName(String userName) {
 30         this.userName = userName;
 31     }
 32 
 33     public String getPassWord() {
 34         return passWord;
 35     }
 36 
 37     public void setPassWord(String passWord) {
 38         this.passWord = passWord;
 39     }
 40 
 41     public String getCardNumber() {
 42         return cardNumber;
 43     }
 44 
 45     public void setCardNumber(String cardNumber) {
 46         this.cardNumber = cardNumber;
 47     }
 48 
 49     public ServicePackage getSerPackage() {
 50         return serPackage;
 51     }
 52 
 53     public void setSerPackage(ServicePackage serPackage) {
 54         this.serPackage = serPackage;
 55     }
 56 
 57     public double getConsumAmount() {
 58         return consumAmount;
 59     }
 60 
 61     public void setConsumAmount(double consumAmount) {
 62         this.consumAmount = consumAmount;
 63     }
 64 
 65     public double getMoney() {
 66         return money;
 67     }
 68 
 69     public void setMoney(double money) {
 70         this.money = money;
 71     }
 72 
 73     public int getRealTalkTime() {
 74         return realTalkTime;
 75     }
 76 
 77     public void setRealTalkTime(int realTalkTime) {
 78         this.realTalkTime = realTalkTime;
 79     }
 80 
 81     public int getRealSMSCount() {
 82         return realSMSCount;
 83     }
 84 
 85     public void setRealSMSCount(int realSMSCount) {
 86         this.realSMSCount = realSMSCount;
 87     }
 88 
 89     public int getRealFlow() {
 90         return realFlow;
 91     }
 92 
 93     public void setRealFlow(int realFlow) {
 94         this.realFlow = realFlow;
 95     }
 96     
 97     /**
 98      * 顯示卡信息
 99      */
100     public void showMeg(){
101         System.out.println("卡號："+this.cardNumber+" 用戶名："+this.userName+" 當前余額："+this.money+"元。");
102         this.serPackage.showInfo();
103     }    
104 }

 1 public class NetPackage extends ServicePackage implements NetService {
 2     private int flow; // 上網流量（MB）
 3     
 4     public NetPackage() {
 5         //套餐數據初始化
 6         this.flow = 1024 * 3;
 7         this.price = 68.0;
 8     }
 9 
10     public NetPackage(int flow) {
11         super();
12         this.flow = flow;
13     }
14     
15     public int getFlow() {
16         return flow;
17     }
18 
19     public void setFlow(int flow) {
20         this.flow = flow;
21     }
22 
23     
24 
25     @Override
26     public void showInfo() {
27         System.out.println("網蟲套餐：上網流量是" + flow / 1024 + "GB/月,月資費是"
28                 + this.price + "元/月。");
29     }
30 
31     /**
32      * 提供上網服務
33      */
34     public void netPlay2(int flow, MobileCard card) throws Exception {
35         int reminFlow = this.flow - card.getRealFlow();  //卡中可支付的免費流量
36         // 判斷套餐中的上網流量是否足夠支付本次上網服務
37         if (this.flow <= reminFlow) {
38             // 套餐中上網流量足夠：修改該卡實際上網流量數據
39             card.setRealFlow(card.getRealFlow() + flow);
40         } else {
41             // 套餐中上網流量不夠：額外消費需按0.1元/條付費，額外消費金額=0.1*（該卡實際消費上網流量+本次消費上網流量-套餐包含的上網流量）
42             double consumeMoney = 0.1 * (flow-reminFlow);
43             // 該卡賬戶余額足夠支付：修改該卡實際使用的上網流量、賬戶余額、當月消費金額
44             if (card.getMoney() >= consumeMoney) {
45                 //消耗的流量增加
46                 card.setRealFlow(card.getRealFlow() + flow);
47                 // 當前賬戶余額＝當前賬戶余額－額外消費金額
48                 card.setMoney(card.getMoney() - consumeMoney);
49                 // 當月消費金額＝當月消費金額＋額外消費金額
50                 card.setConsumAmount(card.getConsumAmount() + consumeMoney);
51             } else {
52                 
53                 int temp = (int)(card.getMoney()/0.1); //當前余額夠大
54                 throw new Exception("您的余額不足，請充值后再使用！");
55             }
56         }
57     }
58     
59     /**
60      * 提供上網服務
61      */
62     public int netPlay(int flow, MobileCard card) throws Exception {
63         int temp = flow;
64         for(int i=0;i<flow;i++){
65             if(this.flow-card.getRealFlow()>=1){
66                 //第一種情況：套餐剩余流量可以支持使用1M流量            
67                 card.setRealFlow(card.getRealFlow()+1); //實際使用流量加1MB                
68             }else if(card.getMoney()>=0.1){
69                 //第二種情況:套餐流量已用完，賬戶余額可以支付1M流量，使用賬戶余額支付
70                 card.setRealFlow(card.getRealFlow()+1); //實際使用流量加1MB
71                 card.setMoney(Common.sub(card.getMoney(),0.1)); //賬戶余額消費0.1元（1M流量費用）
72                 card.setConsumAmount(card.getConsumAmount() + 0.1);
73             }else{
74                 temp = i;
75                 throw new Exception("本次已使用流量"+i+"MB,您的余額不足，請充值后再使用！");
76             }
77         }
78         return temp;
79     }
80 }

 1 public class Scene {
 2     private String type;  //場景消費類型
 3     private int data;  //消費數據
 4     private String description;//場景描述
 5     
 6     public Scene(){}
 7     public Scene(String type,int data,String description){
 8         this.type = type;
 9         this.data = data;
10         this.description = description;
11     }  
12     
13     public String getType() {
14         return type;
15     }
16     public void setType(String type) {
17         this.type = type;
18     }
19     public int getData() {
20         return data;
21     }
22     public void setData(int data) {
23         this.data = data;
24     }
25     public String getDescription() {
26         return description;
27     }
28     public void setDescription(String description) {
29         this.description = description;
30     }
31     
32 }

 1 public abstract class ServicePackage {    
 2     protected double price;  //套餐月資費(元)
 3      
 4     public double getPrice() {
 5         return price;
 6     }
 7 
 8     public void setPrice(double price) {
 9         this.price = price;
10     }
11 
12     //顯示套餐數據
13     public abstract void showInfo();
14 }

  1 public class SuperPackage extends ServicePackage implements CallService,
  2 SendService,NetService {
  3     private int talkTime;   //通話時長(分鍾)
  4     private int smsCount;   //短信條數（條）
  5     private int flow;  //上網流量（MB）
  6        
  7     public int getTalkTime() {
  8         return talkTime;
  9     }
 10 
 11 
 12     public void setTalkTime(int talkTime) {
 13         this.talkTime = talkTime;
 14     }
 15 
 16 
 17     public int getSmsCount() {
 18         return smsCount;
 19     }
 20 
 21 
 22     public void setSmsCount(int smsCount) {
 23         this.smsCount = smsCount;
 24     }
 25     
 26     public int getFlow() {
 27         return flow;
 28     }
 29 
 30     public void setFlow(int flow) {
 31         this.flow = flow;
 32     }
 33     
 34     public SuperPackage(){
 35         //套餐數據初始化
 36         this.talkTime = 200;
 37         this.smsCount = 50;
 38         this.flow = 1*1024;  
 39         this.price = 78.0;
 40     }
 41     @Override
 42     public void showInfo() {
 43         System.out.println("超人套餐：通話時長為"+this.talkTime+"分鍾/月，短信條數為"+this.smsCount+"條/月，上網流量為"+this.flow/1024+"GB/月。");
 44     }
 45 
 46 
 47     /**
 48      * 提供上網服務
 49      */
 50     public int netPlay(int flow, MobileCard card) throws Exception {
 51         int temp = flow;
 52         for(int i=0;i<flow;i++){
 53             if(this.flow-card.getRealFlow()>=1){
 54                 //第一種情況：套餐剩余流量可以支持使用1M流量            
 55                 card.setRealFlow(card.getRealFlow()+1); //實際使用流量加1MB                
 56             }else if(card.getMoney()>=0.1){
 57                 //第二種情況:套餐流量已用完，賬戶余額可以支付1M流量，使用賬戶余額支付
 58                 card.setRealFlow(card.getRealFlow()+1); //實際使用流量加1MB
 59                 card.setMoney(Common.sub(card.getMoney(),0.1)); //賬戶余額消費0.1元（1M流量費用）
 60                 card.setConsumAmount(card.getConsumAmount() + 0.1);
 61             }else{
 62                 temp = i;
 63                 throw new Exception("本次已使用流量"+i+"MB,您的余額不足，請充值后再使用！");
 64             }
 65         }
 66         return temp;
 67     }
 68 
 69     /**
 70      * 提供通話服務
 71      */
 72     public int call(int minCount, MobileCard card) throws Exception{
 73         int temp = minCount; 
 74         for(int i=0;i<minCount;i++){
 75             if(this.talkTime-card.getRealTalkTime()>=1){
 76                 //第一種情況：套餐剩余通話時長可以付1分鍾通話            
 77                 card.setRealTalkTime(card.getRealTalkTime()+1); //實際通話數據加1                
 78             }else if(card.getMoney()>=0.2){
 79                 //第二種情況:套餐通話時長已用完，賬戶余額可以支付1分鍾通話，使用賬戶余額支付
 80                 card.setRealTalkTime(card.getRealTalkTime()+1); //實際使用通話時長1分鍾 
 81                 card.setMoney(Common.sub(card.getMoney(),0.2)); //賬戶余額消費0.2元（1分鍾額外通話）
 82                 card.setConsumAmount(card.getConsumAmount() + 0.2);
 83             }else{
 84                 temp = i; //記錄實現通話分鍾數
 85                 throw new Exception("本次已通話"+i+"分鍾,您的余額不足，請充值后再使用！");                
 86             }
 87         }
 88         return temp;
 89     }
 90     
 91     /**
 92      * 提供短信服務
 93      */
 94     public int sendMessage(int smsCount, MobileCard card) throws Exception {
 95         int temp = smsCount;
 96         for(int i=0;i<smsCount;i++){
 97             if(this.smsCount-card.getRealSMSCount()>=1){
 98                 //第一種情況：套餐剩余短信條數可以付1條短信            
 99                 card.setRealSMSCount(card.getRealSMSCount()+1); //實際使用短信條數加1                
100             }else if(card.getMoney()>=0.1){
101                 //第二種情況:套餐短信條數已用完，賬戶余額可以支付1條短信，使用賬戶余額支付
102                 card.setRealSMSCount(card.getRealSMSCount()+1); 
103                 card.setMoney(Common.sub(card.getMoney(),0.1)); //賬戶余額消費0.1元（1條短信費用）
104                 card.setConsumAmount(card.getConsumAmount() + 0.1);
105             }else{
106                 temp = i;
107                 throw new Exception("本次已發送短信"+i+"條,您的余額不足，請充值后再使用！");
108             }
109         }
110         return temp;
111     }
112 
113 }

 1 public class TalkPackage extends ServicePackage implements CallService,
 2         SendService {
 3     private int talkTime; // 通話時長(分鍾)
 4     private int smsCount; // 短信條數（條）
 5 
 6     public int getTalkTime() {
 7         return talkTime;
 8     }
 9 
10     public void setTalkTime(int talkTime) {
11         this.talkTime = talkTime;
12     }
13 
14     public int getSmsCount() {
15         return smsCount;
16     }
17 
18     public void setSmsCount(int smsCount) {
19         this.smsCount = smsCount;
20     }
21 
22     public TalkPackage() {
23         //套餐數據初始化
24         this.talkTime = 500;
25         this.smsCount = 30;
26         this.price = 58.0;
27     }
28 
29     public TalkPackage(int talkTime, int smsCount) {
30         super();
31         this.talkTime = talkTime;
32         this.smsCount = smsCount;
33     }
34 
35     /**
36      * 顯示套餐詳情
37      */
38     public void showInfo() {
39         System.out.println("話嘮套餐：通話時長為" + this.talkTime + "分鍾/月，短信條數為"
40                 + this.smsCount + "條/月，資費為" + this.price + "元/月。");
41     }
42     
43     public int call(int minCount, MobileCard card) throws Exception{
44         int temp = minCount; 
45         for(int i=0;i<minCount;i++){
46             if(this.talkTime-card.getRealTalkTime()>=1){
47                 //第一種情況：套餐剩余通話時長可以付1分鍾通話            
48                 card.setRealTalkTime(card.getRealTalkTime()+1); //實際使用流量加1MB                
49             }else if(card.getMoney()>=0.2){
50                 //第二種情況:套餐通話時長已用完，賬戶余額可以支付1分鍾通話，使用賬戶余額支付
51                 card.setRealTalkTime(card.getRealTalkTime()+1); //實際使用通話時長1分鍾 
52                 card.setMoney(Common.sub(card.getMoney(),0.2)); //賬戶余額消費0.2元（1M流量費用）
53                 card.setConsumAmount(card.getConsumAmount() + 0.2);
54             }else{
55                 temp = i; //記錄實現通話分鍾數
56                 throw new Exception("本次已通話"+i+"分鍾,您的余額不足，請充值后再使用！");                
57             }
58         }
59         return temp;
60     }
61         
62     public int sendMessage(int smsCount, MobileCard card) throws Exception {
63         int temp = smsCount;
64         for(int i=0;i<smsCount;i++){
65             if(this.smsCount-card.getRealSMSCount()>=1){
66                 //第一種情況：套餐剩余短信條數可以付1條短信            
67                 card.setRealSMSCount(card.getRealSMSCount()+1); //實際使用短信條數加1                
68             }else if(card.getMoney()>=0.1){
69                 //第二種情況:套餐短信條數已用完，賬戶余額可以支付1條短信，使用賬戶余額支付
70                 card.setRealSMSCount(card.getRealSMSCount()+1); 
71                 card.setMoney(Common.sub(card.getMoney(),0.1)); //賬戶余額消費0.1元（1條短信費用）
72                 card.setConsumAmount(card.getConsumAmount() + 0.1);
73             }else{
74                 temp = i;
75                 throw new Exception("本次已發送短信"+i+"條,您的余額不足，請充值后再使用！");
76             }
77         }
78         return temp;
79     }
80     
81 }

1 public interface CallService {
2     //打電話
3       public int call(int minCount,MobileCard card) throws Exception;
4 }

1 public interface NetService {
2     //上網
3      public int netPlay(int flow,MobileCard card) throws Exception;
4 }

1 public interface SendService {
2     //發短信
3      public int sendMessage(int count,MobileCard card) throws Exception;
4 }

  1 public class CardUtil {
  2     Map<String, MobileCard> cards = new HashMap<String, MobileCard>(); // 所有手機卡的列表
  3     Map<String, List<ConsumInfo>> consumInfos = new HashMap<String, List<ConsumInfo>>(); // 所有手機卡消費記錄的列表
  4     List<Scene> scenes = new ArrayList<Scene>();
  5 
  6     // 初始化用戶
  7     public void init() {
  8         MobileCard card1 = new MobileCard("何玲玲", "123", "13965756432",
  9                 new TalkPackage(), 58.0, 42.0);
 10         MobileCard card2 = new MobileCard("黃露露", "123", "13956712467",
 11                 new NetPackage(), 68.0, 32.0);
 12         MobileCard card3 = new MobileCard("朱蓉蓉", "123", "13911568956",
 13                 new SuperPackage(), 78.0, 22.0);
 14         MobileCard card4 = new MobileCard("桃跑跑", "123", "13924221868",
 15                 new TalkPackage(), 78.0, 2.0);
 16         card4.setConsumAmount(98.0);
 17         card4.setRealTalkTime(500);
 18         card4.setRealSMSCount(100);
 19         cards.put("13965756432", card1);
 20         cards.put("13956712467", card2);
 21         cards.put("13911568956", card3);
 22         cards.put("13924221868", card4);
 23     }
 24     
 25     /**
 26      * 使用場景初始化
 27      */
 28     public void initScenes(){    
 29         scenes.add(new Scene("通話",90,"問候客戶，誰知其如此難纏 通話90分鍾"));
 30         scenes.add(new Scene("通話",30,"詢問媽媽身體狀況 本地通話30分鍾"));
 31         scenes.add(new Scene("短信",5,"參與環境保護實施方案問卷調查 發送短信5條"));
 32         scenes.add(new Scene("短信",50,"通知朋友手機換號，發送短信50條"));
 33         scenes.add(new Scene("上網",1*1024,"和女友微信視頻聊天   使用流量1G"));
 34         scenes.add(new Scene("上網",2*1024,"晚上手機在線看韓劇，不留神睡着啦！ 使用流量 2G"));        
 35     }
 36 
 37     /**
 38      * 是否存在此卡用戶
 39      */
 40     public boolean isExistCard(String number, String passWord) {
 41         Set<String> numbers = cards.keySet();
 42         Iterator<String> it = numbers.iterator();
 43         while (it.hasNext()) {
 44             String searchNum = it.next();
 45             if (searchNum.equals(number)
 46                     && (cards.get(searchNum)).getPassWord().equals(passWord)) {
 47                 return true;
 48             }
 49         }
 50         return false;
 51     }
 52     
 53     /**
 54      * 查找指定卡號是否已注冊
 55      * 
 56      */
 57     public boolean isExistCard(String searchNumber) {
 58         Set<String> numbers = cards.keySet();
 59         for (String number : numbers) {
 60             if (number.equals(searchNumber)) {
 61                 return true;
 62             }
 63         }
 64         return false;
 65     }
 66 
 67     /**
 68      * 創建卡號（以139開頭 11位）
 69      */
 70     public String createNumber() {
 71         Random random = new Random();
 72         boolean isExist = false; // 記錄現有用戶中是否存在此卡號用戶 是：true 否：false
 73         String number = "";
 74         int temp = 0;
 75         do {
 76             isExist = false; // 標志位重置為false,用於控制外重循環，當生成了
 77             // 生成的隨機數是8位 不能小於10000000，否則重新生成
 78             do {
 79                 temp = random.nextInt(100000000);
 80             } while (temp < 10000000);
 81             // 生成之前，前面加“139”
 82             number = "139" + temp;
 83             // 和現有用戶的卡號比較，不能是重復
 84             Set<String> cardNumbers = cards.keySet();
 85             for (String cardNumber : cardNumbers) {
 86                 if (number.equals(cardNumber)) {
 87                     isExist = true;
 88                     break;
 89                 }
 90             }
 91         } while (isExist);
 92         return number;
 93     }
 94 
 95     /**
 96      * 生成指定個數的新卡號列表
 97      */
 98     public String[] getNewNumbers(int count) {
 99 
100         String[] numbers = new String[count];
101         for (int i = 0; i < count; i++) {
102             numbers[i] = createNumber();
103         }
104         return numbers;
105     }
106 
107     /**
108      * 添加新卡
109      */
110     public void addCard(MobileCard card) {
111         cards.put(card.getCardNumber(), card);
112         System.out.print("注冊成功！");
113         card.showMeg();
114     }
115 
116     /**
117      * 指定卡號辦理退網
118      */
119     public void delCard(String delNumber) {
120         if (isExistCard(delNumber)) {
121             cards.remove(delNumber);
122             System.out.println("卡號" + delNumber + "辦理退網成功！");
123         } else {
124             System.out.println("對不起，該卡號未注冊，不能辦退退網！");
125         }
126     }
127 
128     /**
129      * 查詢指定卡套餐余量
130      */
131     public void showRemainDetail(String searchNumber) {
132         MobileCard card; // 要查詢的卡
133         int remainTalkTime;
134         int remainSmsCount;
135         int remainFlow;
136         StringBuffer meg = new StringBuffer();
137             card = cards.get(searchNumber);
138             meg.append("您的卡號是" + searchNumber + "，套餐內剩余：\n");
139             ServicePackage pack = card.getSerPackage();
140             if (pack instanceof TalkPackage) {
141                 //向下轉型為話嘮套餐對象
142                 TalkPackage cardPack = (TalkPackage) pack;
143                 // 話嘮套餐，查詢套餐內剩余的通話時長和短信條數
144                 remainTalkTime = cardPack.getTalkTime() > card
145                         .getRealTalkTime() ? cardPack.getTalkTime()
146                         - card.getRealTalkTime() : 0;
147                 meg.append("通話時長：" + remainTalkTime + "分鍾\n");
148                 remainSmsCount = cardPack.getSmsCount() > card
149                         .getRealSMSCount() ? cardPack.getSmsCount()
150                         - card.getRealSMSCount() : 0;
151                 meg.append("短信條數：" + remainSmsCount + "條");
152             } else if (pack instanceof NetPackage) {
153                 //向下轉型為網蟲套餐對象
154                 NetPackage cardPack = (NetPackage) pack;
155                 // 網蟲套餐：查詢套餐內剩余的上網流量
156                 remainFlow = cardPack.getFlow() > card.getRealFlow() ? cardPack
157                         .getFlow() - card.getRealFlow() : 0;
158                 meg.append("上網流量：" + Common.dataFormat(remainFlow * 1.0 / 1024)
159                         + "GB");
160             } else if (pack instanceof SuperPackage) {
161                 //向下轉型為超人套餐對象
162                 SuperPackage cardPack = (SuperPackage) pack;
163                 // 超人套餐：查詢套餐內剩余的通話時長、短信條數、上網流量
164                 remainTalkTime = cardPack.getTalkTime() > card
165                         .getRealTalkTime() ? cardPack.getTalkTime()
166                         - card.getRealTalkTime() : 0;
167                 meg.append("通話時長：" + remainTalkTime + "分鍾\n");
168                 remainSmsCount = cardPack.getSmsCount() > card
169                         .getRealSMSCount() ? cardPack.getSmsCount()
170                         - card.getRealSMSCount() : 0;
171                 meg.append("短信條數：" + remainSmsCount + "條\n");
172                 remainFlow = cardPack.getFlow() > card.getRealFlow() ? cardPack
173                         .getFlow() - card.getRealFlow() : 0;
174                 meg.append("上網流量：" + Common.dataFormat(remainFlow * 1.0 / 1024)
175                         + "GB");
176             }
177             System.out.println(meg);
178     }
179 
180     /**
181      * 查詢指定卡當月消費詳單
182      */
183     public void showAmountDetail(String searchNumber) {
184         MobileCard card; // 要查詢的卡
185         StringBuffer meg = new StringBuffer();
186         card = cards.get(searchNumber);
187         meg.append("您的卡號：" + card.getCardNumber() + ",當月賬單：\n");
188         meg.append("套餐資費：" + card.getSerPackage().getPrice() + "元\n");
189         meg.append("合計：" + Common.dataFormat(card.getConsumAmount()) + "元\n");
190         meg.append("賬戶余額：" + Common.dataFormat(card.getMoney()) + "元");
191         // 顯示本月消費詳細信息
192         System.out.println(meg);
193     }
194 
195     
196     /**
197      * 指定卡號換套餐
198      */
199     public void changingPack(String number, int packNum) {
200         MobileCard card; // 指定的手機卡
201         ServicePackage pack; // 要換的套餐
202         if (isExistCard(number)) {
203             card = cards.get(number);
204             // 獲取要換的套餐對象
205             switch (packNum) {
206             case 1:
207                 pack = new TalkPackage();
208                 break;
209             case 2:
210                 pack = new NetPackage();
211                 break;
212             default:
213                 pack = new SuperPackage();
214                 break;
215             }        
216             if (!(card.getSerPackage().getClass().getName().equals(pack.getClass().getName()))) {
217                 // 該卡余額中減去當月套餐資費
218                 if (card.getMoney() >= pack.getPrice()) {
219                     card.setMoney(card.getMoney() - pack.getPrice());
220                     // 換套餐
221                     card.setSerPackage(pack);
222                     // 當月實際使用數據清零
223                     card.setRealTalkTime(0);
224                     card.setRealFlow(0);
225                     card.setRealSMSCount(0);
226                     // 當月消費金額設置為新套餐月資費
227                     card.setConsumAmount(pack.getPrice());
228                     System.out.print("更換套餐成功！");
229                     pack.showInfo();
230                 } else {
231                     System.out.println("對不起，您的余額不足以支付新套餐本月資費，請充值后再辦理更換套餐業務！");
232                     return;
233                 }
234             } else {
235                 System.out.println("對不起，您已經是該套餐用戶，無需換套餐！");
236             }
237 
238         } else {
239             System.out.println("對不起，該卡號未注冊，不能換套餐！");
240         }
241     }
242 
243     /**
244      * 為指定手機卡充值
245      */
246     public void chargeMoney(String number, double money) {
247         MobileCard card; // 指定的手機卡
248         if (money < 50) {
249             System.out.println("對不起，最低充值金額為50元！");
250             return;
251         }
252             card = cards.get(number);
253             card.setMoney(card.getMoney() + money);
254             System.out.println("充值成功，當前話費余額為" + Common.dataFormat(card.getMoney()) + "元。");
255     }
256 
257     /**
258      * 添加一條指定卡的消費記錄
259      */
260     public void addConsumInfo(String number, ConsumInfo info) {
261         Set<String> numbers = consumInfos.keySet();
262         Iterator<String> it = numbers.iterator();
263         List<ConsumInfo> infos = new ArrayList<ConsumInfo>();
264         boolean isExist = false; // 現有消費列表中是否存在此卡號消費記錄，是：true 否：false
265         while (it.hasNext()) {
266             if (it.next().equals(number)) {
267                 // 消費集合中已有該卡號消費記錄，則找到該卡號的消費記錄集合，添加一條即可
268                 infos = consumInfos.get(number);
269                 infos.add(info);
270                 isExist = true;
271                 System.out.println("已添加一條消費記錄。");
272                 break;
273             }
274         }
275         // 該集合中沒有此卡號消費記錄，則添加
276         if (!isExist) {
277             infos.add(info);
278             consumInfos.put(number, infos);
279             System.out.println("不存在此卡的消費記錄，已添加一條消費記錄。");
280         }
281     }
282     
283     //打印消費記錄
284     public void printConsumInfo(String number){
285         Writer fileWriter = null;
286         try {
287              fileWriter = new FileWriter(number+"消費記錄.txt");            
288             Set<String> numbers = consumInfos.keySet();
289             Iterator<String> it = numbers.iterator();
290             List<ConsumInfo> infos = new ArrayList<ConsumInfo>();//存儲指定卡所有消費記錄
291             boolean isExist = false; // 現有消費列表中是否存在此卡號消費記錄，是：true 否：false
292             while (it.hasNext()) {
293                 if (it.next().equals(number)) {
294                     infos = consumInfos.get(number);
295                     isExist = true;
296                     break;
297                 }
298             }
299             if(isExist){
300                 //存在 此卡消費記錄，寫入文本文件
301                 StringBuffer content = new StringBuffer("******"+number+"消費記錄******\n");
302                 content.append("序號\t類型\t數據（通話（條）/上網（MB）/短信（條））\n");
303                 for(int i=0;i<infos.size();i++){
304                     ConsumInfo info = infos.get(i);
305                     content.append((i+1)+".\t"+info.getType()+"\t"+info.getConsumData()+"\n");
306                 }
307                 fileWriter.write(content.toString());
308                 fileWriter.flush();
309                 
310                 System.out.println("消費記錄打印完畢！");
311             }else{
312                 System.out.println("對不起，不存在此號碼的消費記錄，不能打印！");
313             }            
314         } catch (IOException e) {            
315             e.printStackTrace();
316         }finally{
317             if(fileWriter!=null){
318                 try {
319                     fileWriter.close();
320                 } catch (IOException e) {                    
321                     e.printStackTrace();
322                 }
323             }
324         }
325     }
326     
327     /**
328      * 使用嗖嗖
329      */
330     public void userSoso(String number)  {        
331         MobileCard card = cards.get(number); // 獲取此卡對象
332         ServicePackage pack = card.getSerPackage(); // 獲取此卡所屬套餐
333         Random random = new Random();
334         int ranNum = 0;
335         int temp = 0;  //記錄各場景中實際消費數據
336         do{
337             
338             ranNum = random.nextInt(6);// 生成一個0~5之前的隨機數
339             Scene scene = scenes.get(ranNum); //獲取該序號所對應的場景
340             switch (ranNum) {
341             //序號為0或1為通話場景
342             case 0:
343             case 1:
344                 // 判斷該卡所屬套餐是否支持通話功能
345                 if (pack instanceof CallService) {
346                     // 執行通話方法
347                     System.out.println(scene.getDescription());
348                     CallService callService = (CallService) pack;
349                     try {
350                         temp = callService.call(scene.getData(), card);
351                     } catch (Exception e) {                            
352                         e.printStackTrace();
353                     }
354                     // 添加一條消費記錄
355                     addConsumInfo(number, new ConsumInfo(number,
356                             scene.getType(), temp));
357                     break;
358                 } else {
359                     // 如果該卡套餐不支持通話功能，則重新生成隨機數選擇其他場景
360                     continue;
361                 }
362                 //序號為2或3為發短信場景
363             case 2:
364             case 3:
365                 // 判斷該卡所屬套餐是否支持短信功能
366                 if (pack instanceof SendService) {
367                     // 執行發短信方法
368                     System.out.println(scene.getDescription());
369                     SendService sendService = (SendService) pack;
370                     try {
371                         temp = sendService.sendMessage(scene.getData(), card);
372                     } catch (Exception e) {                                                    
373                         e.printStackTrace();
374                     }
375                     // 添加一條消費記錄
376                     addConsumInfo(number, new ConsumInfo(number,
377                             scene.getType(), temp));
378                     break;
379                 } else {
380                     // 如果該卡套餐不支持發短信功能，則重新生成隨機數選擇其他場景
381                     continue;
382                 }
383                 //序號為4或5為發上網場景
384             case 4:
385             case 5:
386                 // 判斷該卡所屬套餐是否支持上網功能
387                 if (pack instanceof NetService) { 
388                     System.out.println(scene.getDescription());
389                     NetService netService = (NetService) pack;
390                     // 執行上網方法
391                     try {
392                         temp = netService.netPlay(scene.getData(), card);
393                     } catch (Exception e) {                        
394                         e.printStackTrace();
395                     }
396                     // 添加一條消費記錄
397                     addConsumInfo(number, new ConsumInfo(number,
398                             scene.getType(), temp));
399                     break;
400                 } else {
401                     // 如果該卡套餐不支持上網功能，則重新生成隨機數選擇其他場景
402                     continue;
403                 }                
404             }    
405             break;
406         }while(true);
407     }
408 
409     /**
410      * 根據套餐序號返回套餐對象
411      */
412     public ServicePackage createPack(int packId) {
413         ServicePackage pack = null;
414         switch (packId) {
415         case 1:
416             pack = new TalkPackage();
417             break;
418         case 2:
419             pack = new NetPackage();
420             break;
421         case 3:
422             pack = new SuperPackage();
423             break;
424         }
425         return pack;
426     }
427     
428     /**
429      * 顯示資費說明
430      */
431     public void showDescription(){
432         Reader rd = null;
433         try {
434             rd = new FileReader("套餐資費說明.txt");
435             int len = 0;
436              char[] content = new char[1024];
437              StringBuffer sb = new StringBuffer();
438                 while((len=rd.read(content))!=-1){
439                     sb.append(content,0,len);  //拼接字符串
440                 }
441                 System.out.println(sb);
442         } catch (IOException e) {
443             e.printStackTrace();
444         }
445     }
446     
447 }

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Java項目—嗖嗖移動業務大廳 10.嗖嗖移動業務大廳 Java項目——嗖嗖移動業務大廳嗖嗖移動大廳源代碼 Java初級小項目高性能服務器架構思路架構思考-業務快速增長時的容量問題分布式系統的架構思路阿里賣電影票架構思路 JAVA項目-嗖嗖移動搜搜移動大廳