Java項目—嗖嗖移動業務大廳

時間 2019-12-02

標籤 java 項目嗖嗖移動業務大廳欄目 Java 简体版

原文原文鏈接

嗖嗖移動業務大廳包類（以下圖）：java

SosoMgr:

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

Common:微信

 1 package cn.common;
 2 
 3 import java.text.DecimalFormat;
 4 import java.util.HashMap;
 5 import java.util.Map;
 6 
 7 /**
 8  * 公共類
 9  */
10 @SuppressWarnings("unused")
11 public class Common {
12     /**
13      * double類型格式化
14      * @param data
15      * @return
16      */
17     public static String dataFormat(double data) {
18         DecimalFormat formatData = new DecimalFormat("#.0");
19         return formatData.format(data);
20     }
21     
22     /**
23      * double類型兩數相減
24      * @param num1
25      * @param num2
26      * @return
27      */
28     public static double sub(double num1,double num2){
29         return (num1*10-num2*10)/10;
30     }
31 }

ConsumType:app

1 package cn.common;
2 
3 /**
4  * 消費類型
5  */
6 public enum ConsumType {
7    TALK,SMS,NETWORK
8 }

ConsumInfo:dom

 1 package cn.entity;
 2 
 3 import cn.common.ConsumType;
 4 
 5 /**
 6  * 消費信息
 7  */
 8 @SuppressWarnings("unused")
 9 public class ConsumInfo {
10     private String cardNumber;  //卡號
11     private String type;  //消費類型：通話、發短信、上網
12     private int consumData;   //消費數據   通話：分鐘   發短信：條   上網：MB
13     
14     public ConsumInfo(){}
15     public ConsumInfo(String cardNumber, String type, int consumData) {
16         super();
17         this.cardNumber = cardNumber;
18         this.type = type;
19         this.consumData = consumData;
20     }
21     public String getCardNumber() {
22         return cardNumber;
23     }
24     public void setCardNumber(String cardNumber) {
25         this.cardNumber = cardNumber;
26     }
27     public String getType() {
28         return type;
29     }
30     public void setType(String type) {
31         this.type = type;
32     }
33     public int getConsumData() {
34         return consumData;
35     }
36     public void setConsumData(int consumData) {
37         this.consumData = consumData;
38     }    
39 }

MobileCard:ide

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

NetPackage:工具

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

Scene:this

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

ServicePackage:spa

 1 package cn.entity;
 2 
 3 /**
 4  * 嗖嗖移動卡套餐
 5  */
 6 public abstract class ServicePackage {    
 7     protected double price;  //套餐月資費(元)
 8      
 9     public double getPrice() {
10         return price;
11     }
12 
13     public void setPrice(double price) {
14         this.price = price;
15     }
16 
17     //顯示套餐數據
18     public abstract void showInfo();
19 }

SuperPackage:.net

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

TalkPackage:code

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

CallService:

 1 package cn.service;
 2 
 3 import cn.entity.MobileCard;
 4 
 5 /**
 6  * 通話服務接口
 7  */
 8 public interface CallService {
 9       //打電話
10       public int call(int minCount,MobileCard card) throws Exception;
11 }

NetService:

 1 package cn.service;
 2 
 3 import cn.entity.MobileCard;
 4 
 5 /**
 6  * 上網服務
 7  */
 8 public interface NetService {
 9     //上網
10      public int netPlay(int flow,MobileCard card) throws Exception;
11 }

SendService:

 1 package cn.service;
 2 
 3 import cn.entity.MobileCard;
 4 
 5 /**
 6  * 短信服務
 7  */
 8 public interface SendService {
 9     //發短信
10      public int sendMessage(int count,MobileCard card) throws Exception;
11 }

CardUtil:

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