image.png

1、业务类

  1. import java.util.Scanner;
  3. import Lianxi.entityClass.MobileCard;
  4. import Lianxi.entityClass.ServicePackage;
  5. import Lianxi.utils.CardUtil;
  7. //业务类
  8. public class Soso {
  9.      Scanner input = new Scanner(System.in);
  10.         CardUtil utils = new CardUtil();
  12.         public static void main(String[] args) {
  13.             Soso soso = new Soso();
  14.             soso.mainMenu();
  15.             System.out.println("谢谢使用！");
  16.         }
  18.         /**
  19.          * 主流程
  20.          */
  21.         public void mainMenu() {
  22.             int menuChoose = 0;
  23.             String mobileNumber= "";
  24.             String password = "";
  25.             utils.init();
  26.             utils.initScenes();
  27.             //Common.typesInit();
  28.             do {
  29.                 System.out.println("\n*************欢迎使用嗖嗖移动业务大厅***************");
  30.                 System.out.println("1.用户登录   2.用户注册   3.使用嗖嗖   4.话费充值  5.资费说明  6.退出系统");
  31.                 System.out.print("请选择：");
  32.                 menuChoose = input.nextInt();
  33.                 // 分支语句：根据功能编号执行相应功能
  34.                 switch (menuChoose) {
  35.                 case 1:
  36.                     //用户登录
  37.                     System.out.print("请输入手机卡号：");
  38.                     mobileNumber = input.next();
  39.                     System.out.print("请输入密码：");
  40.                     password = input.next();
  41.                     if (utils.isExistCard(mobileNumber, password)) {
  42.                         cardMenu(mobileNumber);
  43.                     }else{
  44.                         System.out.println("对不起，您输入的信息有误，无法登录！");
  45.                     }
  46.                     continue;
  47.                 case 2:
  48.                     //用户注册
  49.                     registCard();
  50.                     continue;
  51.                 case 3:
  53.                     //使用嗖嗖
  54.                     System.out.print("请输入手机卡号：");
  55.                      mobileNumber = input.next();
  57.                     if (utils.isExistCard(mobileNumber)) {
  58.                         try {
  59.     /*                        System.out.println("****使用之前****");
  60.                             utils.showRemainDetail(mobileNumber);
  61.                             utils.showAmountDetail(mobileNumber);*/
  62.                             utils.userSoso(mobileNumber);
  63.                         } catch (Exception e) {
  64.                             System.err.println(e.getMessage());
  65.                         }
  66.                     }else{
  67.                         System.out.println("对不起，该卡号未注册，不能使用！");
  68.                     }
  70.                     /*System.out.println("****使用之后****");
  71.                     utils.showRemainDetail(mobileNumber);
  72.                     utils.showAmountDetail(mobileNumber);*/
  73.                     continue;
  74.                 case 4:
  75.                     //话费充值
  76.                     System.out.print("请输入充值卡号：");
  77.                     mobileNumber = input.next();
  78.                     if (utils.isExistCard(mobileNumber)) {
  79.                     System.out.print("请输入充值金额：");
  80.                     double money = input.nextDouble();
  81.                     utils.chargeMoney(mobileNumber, money);
  82.                     }else{
  83.                         System.out.println("对不起，要充值的卡号未注册，无法充值！");
  84.                     }
  85.                     continue;
  86.                 case 5:
  87.                     System.out.println("\n*****资费说明******");
  88.                     utils.showDescription();
  89.                     continue;
  90.                 case 6:
  91.                     //退出系统
  92.                     break;
  93.                 default:
  94.                     //选择其他数字退出系统
  95.                     break;
  96.                 }
  97.                 break;
  98.             } while (true);
  99.         }
  101.         /**
  102.          * 手机卡功能菜单
  103.          *
  104.          * @param number
  105.          * @return
  106.          */
  107.         public int cardMenu(String mobileNumber) {
  108.                int menuChoose = 0;
  109.             do {
  110.                 System.out.println("\n*****嗖嗖移动用户菜单*****");
  111.                 System.out.println("1.本月账单查询");
  112.                 System.out.println("2.套餐余量查询");
  113.                 System.out.println("3.打印消费详单");
  114.                 System.out.println("4.套餐变更");
  115.                 System.out.println("5.办理退网");
  116.                 System.out.print("请选择(输入1~5选择功能，其他键返回上一级)：");
  117.                  menuChoose = input.nextInt();
  118.                 switch (menuChoose) {
  119.                 case 1:
  120.                     System.out.println("\n*****本月账单查询******");
  121.                     utils.showAmountDetail(mobileNumber);
  122.                     continue;
  123.                 case 2:
  124.                     System.out.println("\n*****套餐余量查询******");
  125.                     utils.showRemainDetail(mobileNumber);
  126.                     continue;
  127.                 case 3:
  128.                     System.out.println("\n*****消费详单查询******");
  129.                     utils.printConsumInfo(mobileNumber);
  130.                     continue;
  131.                 case 4:
  132.                     System.out.println("\n*****套餐变更******");
  133.                     System.out.print("1.话唠套餐  2.网虫套餐  3.超人套餐  请选择（序号）：");
  134.                     utils.changingPack(mobileNumber, input.next());
  135.                     continue;
  136.                 case 5:
  137.                     System.out.println("\n*****办理退网******");
  138.                     utils.delCard(mobileNumber);
  139.                     System.out.println("谢谢使用！");
  140.                     System.exit(1);     //办理退网后退出系统
  142.                 }
  144.                 break;
  145.             } while (true);
  146.             return menuChoose;
  147.         }
  149.         /**
  150.          * 注册新卡流程
  151.          */
  152.         public void registCard(){
  153.             String[] newNumbers = utils.getNewNumbers(9);
  154.             //显示可供选择的手机号列表
  155.             System.out.println("*****可选择的卡号*****");
  157.             for(int i=0;i<9;i++){
  158.                 System.out.print((i+1)+"."+newNumbers[i]+"\t\t");
  159.                 if((i+1)%3==0){
  160.                     System.out.println();
  161.                 }
  162.             }
  163.             //选择手机号
  164.             System.out.print("请选择卡号（输入1~9的序号）：");
  165.             String number = newNumbers[input.nextInt()-1];
  167.             //选择套餐类型
  168.             System.out.print("1.话唠套餐  2.网虫套餐  3.超人套餐，  ");
  169.             System.out.print("请选择套餐(输入序号)：");
  170.             //utils.getPackList();
  171.             //获取套餐对象
  172.             ServicePackage pack = utils.createPack(input.nextInt());
  174.             //输入用户名
  175.             System.out.print("请输入姓名：");
  176.             String name = input.next();
  178.             //输入密码
  179.             System.out.print("请输入密码：");
  180.             String password = input.next();
  182.             //输入预存话费金额
  183.             double money = 0;
  184.             System.out.print("请输入预存话费金额：");
  185.              money = input.nextDouble();
  186.             while(money<pack.getPrice()){
  187.                 System.out.print("您预存的话费金额不足以支付本月固定套餐资费，请重新充值：");
  188.                 money = input.nextDouble();
  189.             }
  191.             //创建新卡对象并添加
  192.             MobileCard newCard = new MobileCard(number,name,password,pack,pack.getPrice(),money-pack.getPrice());
  193.             utils.addCard(newCard);
  194.         }
  195. }

2、实体类

（1）、消费记录

  1. //消费记录
  2. public class ConsumInfo {
  3.         private String cardNumber;  //卡号
  4.         private String type;  //消费类型：通话、发短信、上网
  5.         private int consumData;   //消费数据   通话：分钟   发短信：条   上网：MB
  7.         public ConsumInfo(){
  9.         }
  10.         public ConsumInfo(String cardNumber, String type, int consumData) {
  11.             super();
  12.             this.cardNumber = cardNumber;
  13.             this.type = type;
  14.             this.consumData = consumData;
  15.         }
  16.         public String getCardNumber() {
  17.             return cardNumber;
  18.         }
  19.         public void setCardNumber(String cardNumber) {
  20.             this.cardNumber = cardNumber;
  21.         }
  22.         public String getType() {
  23.             return type;
  24.         }
  25.         public void setType(String type) {
  26.             this.type = type;
  27.         }
  28.         public int getConsumData() {
  29.             return consumData;
  30.         }
  31.         public void setConsumData(int consumData) {
  32.             this.consumData = consumData;
  33.         }
  34. }

（2）、嗖嗖移动卡

  1. //嗖嗖移动卡
  2. public class MobileCard {
  4.      private String cardNumble;//卡号
  5.      private String uesrName;//姓名
  6.      private String passWord;//密码
  7.      private ServicePackage setPackage;//选择的套餐
  8.      private double consumAmount;//消费金额=套餐费+实际消费金额
  9.      private double money;//当前余额=充值钱数-consumAmount（消费金额）
  10.      private int realTalkTime;//通话时长
  11.      private int realSMSCount;//短信条数
  12.      private int realFlow;//流量
  14.      public MobileCard(){
  16.      }
  17.      public MobileCard(String cardNumble, String uesrName, String passWord, ServicePackage setPackage,
  18.             double consumAmount, double money) {
  19.         super();
  20.         this.cardNumble = cardNumble;
  21.         this.uesrName = uesrName;
  22.         this.passWord = passWord;
  23.         this.setPackage = setPackage;
  24.         this.consumAmount = consumAmount;
  25.         this.money = money;
  26.         this.realTalkTime = realTalkTime;
  27.         this.realSMSCount = realSMSCount;
  28.         this.realFlow = realFlow;
  29.     }
  30.     public String getCardNumble() {
  31.         return cardNumble;
  32.     }
  33.     public void setCardNumble(String cardNumble) {
  34.         this.cardNumble = cardNumble;
  35.     }
  36.     public String getUesrName() {
  37.         return uesrName;
  38.     }
  39.     public void setUesrName(String uesrName) {
  40.         this.uesrName = uesrName;
  41.     }
  42.     public String getPassWord() {
  43.         return passWord;
  44.     }
  45.     public void setPassWord(String passWord) {
  46.         this.passWord = passWord;
  47.     }
  48.     public ServicePackage getSetPackage() {
  49.         return setPackage;
  50.     }
  51.     public void setSetPackage(ServicePackage setPackage) {
  52.         this.setPackage = setPackage;
  53.     }
  54.     public double getConsumAmount() {
  55.         return consumAmount;
  56.     }
  57.     public void setConsumAmount(double consumAmount) {
  58.         this.consumAmount = consumAmount;
  59.     }
  60.     public double getMoney() {
  61.         return money;
  62.     }
  63.     public void setMoney(double money) {
  64.         this.money = money;
  65.     }
  66.     public int getRealTalkTime() {
  67.         return realTalkTime;
  68.     }
  69.     public void setRealTalkTime(int realTalkTime) {
  70.         this.realTalkTime = realTalkTime;
  71.     }
  72.     public int getRealSMSCount() {
  73.         return realSMSCount;
  74.     }
  75.     public void setRealSMSCount(int realSMSCount) {
  76.         this.realSMSCount = realSMSCount;
  77.     }
  78.     public int getRealFlow() {
  79.         return realFlow;
  80.     }
  81.     public void setRealFlow(int realFlow) {
  82.         this.realFlow = realFlow;
  83.     }
  85.     public void showMeg(){
  86.         System.err.println("卡号："+this.cardNumble+",用户名："+
  87.                             this.uesrName+",当前余额："+this.money+
  88.                             "元");
  89.     }
  91. }

（3）、网虫套餐

  1. import Lianxi.GongG.Common;
  2. import Lianxi.service.NetService;
  4. //网虫套餐
  5. public class NetPackage extends ServicePackage implements NetService {
  6.     private int flow;//上网流量（MB）
  8.     public NetPackage(){
  9.         //套餐数据初始化
  10.         this.flow = 1024 * 3;
  11.         this.price = 68.0;
  12.     }
  13.     public NetPackage(int flow) {
  14.         super();
  15.         this.flow = flow;
  16.     }
  18.     public int getFlow() {
  19.         return flow;
  20.     }
  22.     public void setFlow(int flow) {
  23.         this.flow = flow;
  24.     }
  25.     @Override
  26.     public int netPlay(int folw, MobileCard card) {
  27.         // TODO Auto-generated method stub
  28.         return 0;
  29.     }
  30.     @Override
  31.     public void showInfo() {
  32.         System.out.println("网虫套餐：上网流量是"+flow/1024+
  33.                 "GB/月，月资费是："+this.getPrice()+"元/月。");
  34.     }
  35.     //上网服务2
  36.     public void netPlay2(int flow, MobileCard card)throws Exception {
  37. //        int reminFlow = this.flow - card.getRealFlow();  //卡中可支付的免费流量
  38. //        // 判断套餐中的上网流量是否足够支付本次上网服务
  39. //        if (this.flow <= reminFlow) {
  40. //            // 套餐中上网流量足够：修改该卡实际上网流量数据
  41. //            card.setRealFlow(card.getRealFlow() + flow);
  42. //        }else {
  43. //             // 套餐中上网流量不够：额外消费需按0.1元/条付费，额外消费金额=0.1*（该卡实际消费上网流量+本次消费上网流量-套餐包含的上网流量）
  44. //            double consumeMoney = 0.1 * (flow-reminFlow);
  45. //            // 该卡账户余额足够支付：修改该卡实际使用的上网流量、账户余额、当月消费金额
  46. //            if (card.getMoney() >= consumeMoney) {
  47. //                //消耗的流量增加
  48. //                card.setRealFlow(card.getRealFlow() + flow);
  49. //                // 当前账户余额＝当前账户余额－额外消费金额
  50. //                card.setMoney(card.getMoney() - consumeMoney);
  51. //                // 当月消费金额＝当月消费金额＋额外消费金额
  52. //                card.setConsumAmount(card.getConsumAmount() + consumeMoney);
  53. //            }else {
  54. //                int temp = (int)(card.getMoney()/0.1); //当前余额够大
  55. //                System.out.println("您的余额不足，请充值后再使用！");
  56. //            }
  57. //        }
  58. //        return reminFlow;
  60.     }
  61.     //上网服务
  62.     public int netPlay1(int flow, MobileCard card) throws Exception {
  63.         for(int i=0;i<flow;i++){
  64.             if(this.flow-card.getRealFlow()>=1){
  65.                 //第一种情况：套餐剩余流量可以支持使用1M流量
  66.                  card.setRealFlow(card.getRealFlow()+1); //实际使用流量加1MB      
  67.             }else if(card.getMoney()>=0.1){
  68.                 //第二种情况:套餐流量已用完，账户余额可以支付1M流量，使用账户余额支付
  69.                  card.setRealFlow(card.getRealFlow()+1); //实际使用流量加1MB
  70.                  card.setMoney(Common.sub(card.getMoney(),0.1)); //账户余额消费0.1元（1M流量费用）
  71.                  card.setConsumAmount(card.getConsumAmount() + 0.1); 
  72.             }else{
  73.                 flow=i;
  74.                 System.out.println("本次已使用流量"+i+"MB,您的余额不足，请充值后再使用！");
  75.             }
  76.         }
  77.         return flow;
  79.     } 
  81. }

（4）、使用场景

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

（5）、品牌套餐——————父类）

  1. //品牌套餐-----父类
  2. public abstract class ServicePackage {
  3.     //嘟嘟卡移动套餐
  4.     protected double price;
  6.     public double getPrice() {
  7.         return price;
  8.     }
  10.     public void setPrice(double price) {
  11.         this.price = price;
  12.     }
  13.     public abstract void showInfo();
  14. }

（6）、超人套餐 

  1. import Lianxi.GongG.Common;
  2. import Lianxi.service.CallService;
  3. import Lianxi.service.NetService;
  4. import Lianxi.service.SendService;
  6. //超人套餐
  7. public class SuperPackage extends ServicePackage implements CallService,SendService,NetService {
  8.      private int talkTime;   //通话时长(分钟)
  9.      private int smsCount;   //短信条数（条）
  10.      private int flow;  //上网流量（MB）
  12.      public SuperPackage(){
  13.          //套餐数据初始化
  14.          this.talkTime = 200;
  15.          this.smsCount = 50;
  16.          this.flow = 1*1024;  
  17.          this.price = 78.0;
  18.      }
  20.     public SuperPackage(int talkTime, int smsCount, int flow) {
  21.         super();
  22.         this.talkTime = talkTime;
  23.         this.smsCount = smsCount;
  24.         this.flow = flow;
  25.     }
  27.     public int getTalkTime() {
  28.         return talkTime;
  29.     }
  31.     public void setTalkTime(int talkTime) {
  32.         this.talkTime = talkTime;
  33.     }
  35.     public int getSmsCount() {
  36.         return smsCount;
  37.     }
  39.     public void setSmsCount(int smsCount) {
  40.         this.smsCount = smsCount;
  41.     }
  43.     public int getFlow() {
  44.         return flow;
  45.     }
  47.     public void setFlow(int flow) {
  48.         this.flow = flow;
  49.     }
  50.     @Override
  51.     public void showInfo() {
  52.         System.out.println("超人套餐：通话时长为"+this.talkTime+"分钟/月，短信条数为"+this.smsCount+"条/月，上网流量为"+this.flow/1024+"GB/月。");
  54.     }
  56.     @Override
  57.     public int netPlay(int folw, MobileCard card) {
  58.         for(int i=0;i<flow;i++){
  59.               if(this.flow-card.getRealFlow()>=1){
  60.                 //第一种情况：套餐剩余流量可以支持使用1M流量
  61.                   card.setRealFlow(card.getRealFlow()+1); //实际使用流量加1MB  
  63.               }else if(card.getMoney()>=0.1){
  64.                 //第二种情况:套餐流量已用完，账户余额可以支付1M流量，使用账户余额支付
  65.                   card.setRealFlow(card.getRealFlow()+1); //实际使用流量加1MB
  66.                   card.setMoney(Common.sub(card.getMoney(),0.1)); //账户余额消费0.1元（1M流量费用）
  67.                   card.setConsumAmount(card.getConsumAmount() + 0.1);
  69.               } else{
  70.                   folw=i;
  71.                   System.out.println("本次已使用流量"+i+"MB,您的余额不足，请充值后再使用！");
  72.               }
  73.         }
  74.         return folw;
  76.     }
  78.     @Override
  79.     public int send(int count, MobileCard card) {
  80.          for(int i=0;i<smsCount;i++){
  81.              if(this.smsCount-card.getRealSMSCount()>=1){
  82.                 //第一种情况：套餐剩余短信条数可以付1条短信 
  83.                  card.setRealSMSCount(card.getRealSMSCount()+1); //实际使用短信条数加1
  85.              }else if(card.getMoney()>=0.1){
  86.                 //第二种情况:套餐短信条数已用完，账户余额可以支付1条短信，使用账户余额支付
  87.                  card.setRealSMSCount(card.getRealSMSCount()+1);
  88.                  card.setMoney(Common.sub(card.getMoney(),0.1)); //账户余额消费0.1元（1条短信费用）
  89.                  card.setConsumAmount(card.getConsumAmount() + 0.1);
  91.              }else{
  92.                  count=i;
  93.                  System.out.println("本次已发送短信"+i+"条,您的余额不足，请充值后再使用！");
  94.              }
  95.          }
  97.         return count;
  98.     }
  100.     @Override
  101.     public int call(int minCount, MobileCard card) throws Exception {
  102.         for(int i=0;i<minCount;i++){
  103.             if(this.talkTime-card.getRealTalkTime()>=1){
  104.                 //第一种情况：套餐剩余通话时长可以付1分钟通话 
  105.                 card.setRealTalkTime(card.getRealTalkTime()+1); //实际通话数据加1
  107.             }else if(card.getMoney()>=0.2){
  108.                 //第二种情况:套餐通话时长已用完，账户余额可以支付1分钟通话，使用账户余额支付
  109.                  card.setRealTalkTime(card.getRealTalkTime()+1); //实际使用通话时长1分钟 
  110.                  card.setMoney(Common.sub(card.getMoney(),0.2)); //账户余额消费0.2元（1分钟额外通话）
  111.                  card.setConsumAmount(card.getConsumAmount() + 0.2);
  113.             }else{
  114.                 minCount=i;//记录实现通话分钟数
  115.                 System.out.println("本次已通话"+i+"分钟,您的余额不足，请充值后再使用！");
  116.             }
  117.         }
  119.         return minCount;
  120.     }
  124. }

（7）、话唠套餐

  1. import Lianxi.service.CallService;
  2. import Lianxi.service.SendService;
  4. //话唠套餐
  5. public class TalkPackage extends ServicePackage implements CallService,SendService {
  6.     private int talkTime;// 通话时长(分钟)
  7.     private int smsCount;// 短信条数（条）
  10.     public TalkPackage(){
  11.         //套餐数据初始化
  12.         this.talkTime = 500;
  13.         this.smsCount = 30;
  14.         this.price = 58.0;
  15.     }
  17.     public TalkPackage(int talkTime, int smsCount) {
  18.         super();
  19.         this.talkTime = talkTime;
  20.         this.smsCount = smsCount;
  21.     }
  22.     public int getTalkTime() {
  23.         return talkTime;
  24.     }
  25.     public void setTalkTime(int talkTime) {
  26.         this.talkTime = talkTime;
  27.     }
  28.     public int getSmsCount() {
  29.         return smsCount;
  30.     }
  31.     public void setSmsCount(int smsCount) {
  32.         this.smsCount = smsCount;
  33.     }
  34.     //显示套餐详情
  35.     public void showInfo(){
  36.          System.out.println("话唠套餐：通话时长为" + this.talkTime + "分钟/月，短信条数为"
  37.                                  + this.smsCount + "条/月，资费为" + this.price + "元/月。");
  38.     }
  40.     @Override
  41.     public int call(int minCount, MobileCard card) throws Exception {
  43.         for (int i = 0; i < minCount; i++) {
  44.             if(this.talkTime-card.getRealTalkTime()>=1){
  45.                 //第一种情况：套餐剩余通话时长可以付1分钟通话
  46.                 int thTime=card.getRealTalkTime()+1;
  47.                 card.setRealTalkTime(thTime);
  48.             }else if(card.getMoney()>=0.2){
  49.                 //第二种情况:套餐通话时长已用完，账户余额可以支付1分钟通话，使用账户余额支付
  50.                   card.setRealTalkTime(card.getRealTalkTime()+1); //实际使用通话时长1分钟 
  51.                 //账户余额增加0.2元,消费金额也增加0。2
  52.                   double money1=card.getMoney()-0.2;
  53.                   card.setMoney(money1);
  54.                   double amount=card.getConsumAmount()+0.2;
  55.                   card.setConsumAmount(amount);
  56.             }else{
  57.                 minCount=i; //记录实现通话分钟数
  58.                 System.out.println("本次通话"+i+"分钟，您的余额不足，请充值后再使用");
  60.             }
  61.         }
  62.         return minCount;
  63.     }
  65.     @Override
  66.     public int send(int count, MobileCard card) {
  67.         for (int i = 0; i < count; i++) {
  68.             if(this.smsCount-card.getRealSMSCount()>=1){
  69.                 int sc=card.getRealSMSCount()+1;
  70.                 card.setRealSMSCount(sc);
  71.             }else if(card.getMoney()>=0.1){
  72.                 int sc=card.getRealSMSCount()+1;
  73.                 card.setRealSMSCount(sc);
  74.                 double money1=card.getMoney()-0.1;
  75.                 card.setMoney(money1);
  76.                 double amount=card.getConsumAmount()+0.1;;
  77.                 card.setConsumAmount(amount);
  78.             }else{
  79.                 count=i; //记录实现通话分钟数
  80.                 System.out.println("本次发短信"+i+"分钟，您的余额不足，请充值后再使用");
  82.             }
  83.         }
  85.         return count;
  86.     }
  87. }

3、公共类

  1. import java.text.DecimalFormat;
  3. public class Common {
  4.     /**
  5.      * double类型格式化
  6.      * @param data
  7.      * @return
  8.      */
  9.     public static String dataFormat(double data) {
  10.         DecimalFormat formatData = new DecimalFormat("#.0");
  11.         return formatData.format(data);
  12.          }
  14.      /**
  15.       * double类型两数相减
  16.       * @param num1
  17.       * @param num2
  18.       * @return
  19.       */
  20.     public static double sub(double num1,double num2){
  21.        return (num1*10-num2*10)/10;
  22.      }
  23. }
  1. //消费类型
  2. public enum ConsumType {
  3.      TALK,SMS,NETWORK
  4. }

4、服务接口

  1. import Lianxi.entityClass.MobileCard;
  3. //通话服务接口
  4. public interface CallService {
  5.     //打电话
  6.     public int call(int minCount,MobileCard card) throws Exception;
  7. }
  1. import Lianxi.entityClass.MobileCard;
  3. public interface NetService {
  4.     //上网服务
  5.     //上网
  6.     public int netPlay(int folw,MobileCard card);
  7. }
  1. import Lianxi.entityClass.MobileCard;
  3. public interface SendService {
  4.     //短信服务接口
  5.     //发短信
  6.     public int send(int count,MobileCard card);
  9. }

5、utils运行起来

  1. import java.io.FileReader;
  2. import java.io.FileWriter;
  3. import java.io.IOException;
  4. import java.io.Reader;
  5. import java.io.Writer;
  6. import java.util.ArrayList;
  7. import java.util.HashMap;
  8. import java.util.Iterator;
  9. import java.util.List;
  10. import java.util.Map;
  11. import java.util.Random;
  12. import java.util.Set;
  14. import Lianxi.GongG.Common;
  15. import Lianxi.entityClass.ConsumInfo;
  16. import Lianxi.entityClass.MobileCard;
  17. import Lianxi.entityClass.NetPackage;
  18. import Lianxi.entityClass.Scene;
  19. import Lianxi.entityClass.ServicePackage;
  20. import Lianxi.entityClass.SuperPackage;
  21. import Lianxi.entityClass.TalkPackage;
  22. import Lianxi.service.CallService;
  23. import Lianxi.service.NetService;
  24. import Lianxi.service.SendService;
  26. public class CardUtil {
  27.      Map<String, MobileCard> cards = new HashMap<String, MobileCard>(); // 所有手机卡的列表
  28.         Map<String, List<ConsumInfo>> consumInfos = new HashMap<String, List<ConsumInfo>>(); // 所有手机卡消费记录的列表
  29.         List<Scene> scenes = new ArrayList<Scene>();
  31.         // 初始化用户
  32.         public void init() {
  33.             MobileCard card1 = new MobileCard("何玲玲", "123", "13965756432",
  34.                     new TalkPackage(), 58.0, 42.0);
  35.             MobileCard card2 = new MobileCard("黄露露", "123", "13956712467",
  36.                     new NetPackage(), 68.0, 32.0);
  37.             MobileCard card3 = new MobileCard("朱蓉蓉", "123", "13911568956",
  38.                     new SuperPackage(), 78.0, 22.0);
  39.             MobileCard card4 = new MobileCard("桃跑跑", "123", "13924221868",
  40.                     new TalkPackage(), 78.0, 2.0);
  41.             card4.setConsumAmount(98.0);
  42.             card4.setRealTalkTime(500);
  43.             card4.setRealSMSCount(100);
  44.             cards.put("13965756432", card1);
  45.             cards.put("13956712467", card2);
  46.             cards.put("13911568956", card3);
  47.             cards.put("13924221868", card4);
  48.         }
  50.         /**
  51.          * 使用场景初始化
  52.          */
  53.         public void initScenes(){
  54.             scenes.add(new Scene("通话",90,"问候客户，谁知其如此难缠 通话90分钟"));
  55.             scenes.add(new Scene("通话",30,"询问妈妈身体状况 本地通话30分钟"));
  56.             scenes.add(new Scene("短信",5,"参与环境保护实施方案问卷调查 发送短信5条"));
  57.             scenes.add(new Scene("短信",50,"通知朋友手机换号，发送短信50条"));
  58.             scenes.add(new Scene("上网",1*1024,"和女友微信视频聊天   使用流量1G"));
  59.             scenes.add(new Scene("上网",2*1024,"晚上手机在线看韩剧，不留神睡着啦！ 使用流量 2G"));
  60.         }
  62.         /**
  63.          * 是否存在此卡用户
  65.          *
  66.          * @param number
  67.          * @param passWord
  68.          * @return
  69.          */
  70.         public boolean isExistCard(String number, String passWord) {
  71.             Set<String> numbers = cards.keySet();
  72.             Iterator<String> it = numbers.iterator();
  73.             while (it.hasNext()) {
  74.                 String searchNum = it.next();
  75.                 if (searchNum.equals(number)
  76.                         && (cards.get(searchNum)).getPassWord().equals(passWord)) {
  77.                     return true;
  78.                 }
  79.             }
  80.             return false;
  81.         }
  83.         /**
  84.          * 查找指定卡号是否已注册
  85.          *
  86.          * @param searchNumber
  87.          * @return 未注册：false 已注册：true
  88.          */
  89.         public boolean isExistCard(String searchNumber) {
  90.             Set<String> numbers = cards.keySet();
  91.             for (String number : numbers) {
  92.                 if (number.equals(searchNumber)) {
  93.                     return true;
  94.                 }
  95.             }
  96.             return false;
  97.         }
  99.         /**
  100.          * 创建卡号（以139开头 11位）
  101.          *
  102.          * @return 生成的随机手机卡号
  103.          */
  104.         public String createNumber() {
  105.             Random random = new Random();
  106.             boolean isExist = false; // 记录现有用户中是否存在此卡号用户 是：true 否：false
  107.             String number = "";
  108.             int temp = 0;
  109.             do {
  110.                 isExist = false; // 标志位重置为false,用于控制外重循环，当生成了
  111.                 // 生成的随机数是8位 不能小于10000000，否则重新生成
  112.                 do {
  113.                     temp = random.nextInt(100000000);
  114.                 } while (temp < 10000000);
  115.                 // 生成之前，前面加“139”
  116.                 number = "139" + temp;
  117.                 // 和现有用户的卡号比较，不能是重复
  118.                 Set<String> cardNumbers = cards.keySet();
  119.                 for (String cardNumber : cardNumbers) {
  120.                     if (number.equals(cardNumber)) {
  121.                         isExist = true;
  122.                         break;
  123.                     }
  124.                 }
  125.             } while (isExist);
  126.             return number;
  127.         }
  129.         /**
  130.          * 生成指定个数的新卡号列表
  131.          *
  132.          * @param count
  133.          *            指定个数
  134.          * @return 卡号列表
  135.          */
  136.         public String[] getNewNumbers(int count) {
  138.             String[] numbers = new String[count];
  139.             for (int i = 0; i < count; i++) {
  140.                 numbers[i] = createNumber();
  141.             }
  142.             return numbers;
  143.         }
  145.         /**
  146.          * 添加新卡
  147.          *
  148.          * @param card
  149.          *            新卡
  150.          */
  151.         public void addCard(MobileCard card) {
  152.             cards.put(card.getCardNumble(), card);
  153.             System.out.print("注册成功！");
  154.             card.showMeg();
  155.         }
  157.         /**
  158.          * 指定卡号办理退网
  159.          *
  160.          * @param card
  161.          */
  162.         public void delCard(String delNumber) {
  163.             if (isExistCard(delNumber)) {
  164.                 cards.remove(delNumber);
  165.                 System.out.println("卡号" + delNumber + "办理退网成功！");
  166.             } else {
  167.                 System.out.println("对不起，该卡号未注册，不能办退退网！");
  168.             }
  169.         }
  171.         /**
  172.          * 查询指定卡套餐余量
  173.          *
  174.          * @param number
  175.          */
  176.         public void showRemainDetail(String searchNumber) {
  177.             MobileCard card; // 要查询的卡
  178.             int remainTalkTime;
  179.             int remainSmsCount;
  180.             int remainFlow;
  181.             StringBuffer meg = new StringBuffer();
  182.                 card = cards.get(searchNumber);
  183.                 meg.append("您的卡号是" + searchNumber + "，套餐内剩余：\n");
  184.                 ServicePackage pack = card.getSetPackage();
  185.                 if (pack instanceof TalkPackage) {
  186.                     //向下转型为话唠套餐对象
  187.                     TalkPackage cardPack = (TalkPackage) pack;
  188.                     // 话唠套餐，查询套餐内剩余的通话时长和短信条数
  189.                     remainTalkTime = cardPack.getTalkTime() > card
  190.                             .getRealTalkTime() ? cardPack.getTalkTime()
  191.                             - card.getRealTalkTime() : 0;
  192.                     meg.append("通话时长：" + remainTalkTime + "分钟\n");
  193.                     remainSmsCount = cardPack.getSmsCount() > card
  194.                             .getRealSMSCount() ? cardPack.getSmsCount()
  195.                             - card.getRealSMSCount() : 0;
  196.                     meg.append("短信条数：" + remainSmsCount + "条");
  197.                 } else if (pack instanceof NetPackage) {
  198.                     //向下转型为网虫套餐对象
  199.                     NetPackage cardPack = (NetPackage) pack;
  200.                     // 网虫套餐：查询套餐内剩余的上网流量
  201.                     remainFlow = cardPack.getFlow() > card.getRealFlow() ? cardPack
  202.                             .getFlow() - card.getRealFlow() : 0;
  203.                     meg.append("上网流量：" + Common.dataFormat(remainFlow * 1.0 / 1024)
  204.                             + "GB");
  205.                 } else if (pack instanceof SuperPackage) {
  206.                     //向下转型为超人套餐对象
  207.                     SuperPackage cardPack = (SuperPackage) pack;
  208.                     // 超人套餐：查询套餐内剩余的通话时长、短信条数、上网流量
  209.                     remainTalkTime = cardPack.getTalkTime() > card
  210.                             .getRealTalkTime() ? cardPack.getTalkTime()
  211.                             - card.getRealTalkTime() : 0;
  212.                     meg.append("通话时长：" + remainTalkTime + "分钟\n");
  213.                     remainSmsCount = cardPack.getSmsCount() > card
  214.                             .getRealSMSCount() ? cardPack.getSmsCount()
  215.                             - card.getRealSMSCount() : 0;
  216.                     meg.append("短信条数：" + remainSmsCount + "条\n");
  217.                     remainFlow = cardPack.getFlow() > card.getRealFlow() ? cardPack
  218.                             .getFlow() - card.getRealFlow() : 0;
  219.                     meg.append("上网流量：" + Common.dataFormat(remainFlow * 1.0 / 1024)
  220.                             + "GB");
  221.                 }
  222.                 System.out.println(meg);
  223.         }
  225.         /**
  226.          * 查询指定卡当月消费详单
  227.          *
  228.          * @param searchNumber
  229.          */
  230.         public void showAmountDetail(String searchNumber) {
  231.             MobileCard card; // 要查询的卡
  232.             StringBuffer meg = new StringBuffer();
  233.             card = cards.get(searchNumber);
  234.             meg.append("您的卡号：" + card.getCardNumble() + ",当月账单：\n");
  235.             meg.append("套餐资费：" + card.getSetPackage().getPrice() + "元\n");
  236.             meg.append("合计：" + Common.dataFormat(card.getConsumAmount()) + "元\n");
  237.             meg.append("账户余额：" + Common.dataFormat(card.getMoney()) + "元");
  238.             // 显示本月消费详细信息
  239.             System.out.println(meg);
  240.         }
  243.         /**
  244.          * 指定卡号换套餐
  245.          *
  246.          * @param number
  247.          * @param packType
  248.          */
  249.         public void changingPack(String number, String packNum) {
  250.             MobileCard card; // 指定的手机卡
  251.             ServicePackage pack; // 要换的套餐
  252.             if (isExistCard(number)) {
  253.                 card = cards.get(number);
  254.                 // 获取要换的套餐对象
  255.                 switch (packNum) {
  256.                 case "1":
  257.                     pack = new TalkPackage();
  258.                     break;
  259.                 case "2":
  260.                     pack = new NetPackage();
  261.                     break;
  262.                 default:
  263.                     pack = new SuperPackage();
  264.                     break;
  265.                 }
  266.                 if (!(card.getSetPackage().getClass().getName().equals(pack.getClass().getName()))) {
  267.                     // 该卡余额中减去当月套餐资费
  268.                     if (card.getMoney() >= pack.getPrice()) {
  269.                         card.setMoney(card.getMoney() - pack.getPrice());
  270.                         // 换套餐
  271.                         card.setSetPackage(pack);
  272.                         // 当月实际使用数据清零
  273.                         card.setRealTalkTime(0);
  274.                         card.setRealFlow(0);
  275.                         card.setRealSMSCount(0);
  276.                         // 当月消费金额设置为新套餐月资费
  277.                         card.setConsumAmount(pack.getPrice());
  278.                         System.out.print("更换套餐成功！");
  279.                         pack.showInfo();
  280.                     } else {
  281.                         System.out.println("对不起，您的余额不足以支付新套餐本月资费，请充值后再办理更换套餐业务！");
  282.                         return;
  283.                     }
  284.                 } else {
  285.                     System.out.println("对不起，您已经是该套餐用户，无需换套餐！");
  286.                 }
  288.             } else {
  289.                 System.out.println("对不起，该卡号未注册，不能换套餐！");
  290.             }
  291.         }
  293.         /**
  294.          * 为指定手机卡充值
  295.          *
  296.          * @param number
  297.          *            指定充值的卡号
  298.          * @param money
  299.          *            充值金额
  300.          */
  301.         public void chargeMoney(String number, double money) {
  302.             MobileCard card; // 指定的手机卡
  303.             if (money < 50) {
  304.                 System.out.println("对不起，最低充值金额为50元！");
  305.                 return;
  306.             }
  307.                 card = cards.get(number);
  308.                 card.setMoney(card.getMoney() + money);
  309.                 System.out.println("充值成功，当前话费余额为" + Common.dataFormat(card.getMoney()) + "元。");
  310.         }
  312.         /**
  313.          * 添加一条指定卡的消费记录
  314.          *
  315.          * @param number
  316.          *            要添加消费记录的卡
  317.          * @param info
  318.          *            要添加的消费记录
  319.          */
  320.         public void addConsumInfo(String number, ConsumInfo info) {
  321.             Set<String> numbers = consumInfos.keySet();
  322.             Iterator<String> it = numbers.iterator();
  323.             List<ConsumInfo> infos = new ArrayList<ConsumInfo>();
  324.             boolean isExist = false; // 现有消费列表中是否存在此卡号消费记录，是：true 否：false
  325.             while (it.hasNext()) {
  326.                 if (it.next().equals(number)) {
  327.                     // 消费集合中已有该卡号消费记录，则找到该卡号的消费记录集合，添加一条即可
  328.                     infos = consumInfos.get(number);
  329.                     infos.add(info);
  330.                     isExist = true;
  331.                     System.out.println("已添加一条消费记录。");
  332.                     break;
  333.                 }
  334.             }
  335.             // 该集合中没有此卡号消费记录，则添加
  336.             if (!isExist) {
  337.                 infos.add(info);
  338.                 consumInfos.put(number, infos);
  339.                 System.out.println("不存在此卡的消费记录，已添加一条消费记录。");
  340.             }
  341.         }
  343.         //打印消费记录
  344.         public void printConsumInfo(String number){
  345.             Writer fileWriter = null;
  346.             try {
  347.                  fileWriter = new FileWriter(number+"消费记录.txt");
  348.                 Set<String> numbers = consumInfos.keySet();
  349.                 Iterator<String> it = numbers.iterator();
  350.                 List<ConsumInfo> infos = new ArrayList<ConsumInfo>();//存储指定卡所有消费记录
  351.                 boolean isExist = false; // 现有消费列表中是否存在此卡号消费记录，是：true 否：false
  352.                 while (it.hasNext()) {
  353.                     if (it.next().equals(number)) {
  354.                         infos = consumInfos.get(number);
  355.                         isExist = true;
  356.                         break;
  357.                     }
  358.                 }
  359.                 if(isExist){
  360.                     //存在 此卡消费记录，写入文本文件
  361.                     StringBuffer content = new StringBuffer("******"+number+"消费记录******\n");
  362.                     content.append("序号\t类型\t数据（通话（条）/上网（MB）/短信（条））\n");
  363.                     for(int i=0;i<infos.size();i++){
  364.                         ConsumInfo info = infos.get(i);
  365.                         content.append((i+1)+".\t"+info.getType()+"\t"+info.getConsumData()+"\n");
  366.                     }
  367.                     fileWriter.write(content.toString());
  368.                     fileWriter.flush();
  370.                     System.out.println("消费记录打印完毕！");
  371.                 }else{
  372.                     System.out.println("对不起，不存在此号码的消费记录，不能打印！");
  373.                 }
  374.             } catch (IOException e) {
  375.                 e.printStackTrace();
  376.             }finally{
  377.                 if(fileWriter!=null){
  378.                     try {
  379.                         fileWriter.close();
  380.                     } catch (IOException e) {
  381.                         e.printStackTrace();
  382.                     }
  383.                 }
  384.             }
  385.         }
  387.         /**
  388.          * 使用嗖嗖
  389.          * @param number 当前卡号
  390.          * @throws Exception
  391.          */
  392.         public void userSoso(String number)  {
  393.             MobileCard card = cards.get(number); // 获取此卡对象
  394.             ServicePackage pack = card.getSetPackage(); // 获取此卡所属套餐
  395.             Random random = new Random();
  396.             int ranNum = 0;
  397.             int temp = 0;  //记录各场景中实际消费数据
  398.             do{
  400.                 ranNum = random.nextInt(6);// 生成一个0~5之前的随机数
  401.                 Scene scene = scenes.get(ranNum); //获取该序号所对应的场景
  402.                 switch (ranNum) {
  403.                 //序号为0或1为通话场景
  404.                 case 0:
  405.                 case 1:
  406.                     // 判断该卡所属套餐是否支持通话功能
  407.                     if (pack instanceof CallService) {
  408.                         // 执行通话方法
  409.                         System.out.println(scene.getDescription());
  410.                         CallService callService = (CallService) pack;
  411.                         try {
  412.                             temp = callService.call(scene.getData(), card);
  413.                         } catch (Exception e) {
  414.                             e.printStackTrace();
  415.                         }
  416.                         // 添加一条消费记录
  417.                         addConsumInfo(number, new ConsumInfo(number,
  418.                                 scene.getType(), temp));
  419.                         break;
  420.                     } else {
  421.                         // 如果该卡套餐不支持通话功能，则重新生成随机数选择其他场景
  422.                         continue;
  423.                     }
  424.                     //序号为2或3为发短信场景
  425.                 case 2:
  426.                 case 3:
  427.                     // 判断该卡所属套餐是否支持短信功能
  428.                     if (pack instanceof SendService) {
  429.                         // 执行发短信方法
  430.                         System.out.println(scene.getDescription());
  431.                         SendService sendService = (SendService) pack;
  432.                         try {
  433.                             temp = sendService.send(scene.getData(), card);
  434.                         } catch (Exception e) {
  435.                             e.printStackTrace();
  436.                         }
  437.                         // 添加一条消费记录
  438.                         addConsumInfo(number, new ConsumInfo(number,
  439.                                 scene.getType(), temp));
  440.                         break;
  441.                     } else {
  442.                         // 如果该卡套餐不支持发短信功能，则重新生成随机数选择其他场景
  443.                         continue;
  444.                     }
  445.                     //序号为4或5为发上网场景
  446.                 case 4:
  447.                 case 5:
  448.                     // 判断该卡所属套餐是否支持上网功能
  449.                     if (pack instanceof NetService) {
  450.                         System.out.println(scene.getDescription());
  451.                         NetService netService = (NetService) pack;
  452.                         // 执行上网方法
  453.                         try {
  454.                             temp = netService.netPlay(scene.getData(), card);
  455.                         } catch (Exception e) {
  456.                             e.printStackTrace();
  457.                         }
  458.                         // 添加一条消费记录
  459.                         addConsumInfo(number, new ConsumInfo(number,
  460.                                 scene.getType(), temp));
  461.                         break;
  462.                     } else {
  463.                         // 如果该卡套餐不支持上网功能，则重新生成随机数选择其他场景
  464.                         continue;
  465.                     }
  466.                 }
  467.                 break;
  468.             }while(true);
  469.         }
  471.         /**
  472.          * 根据套餐序号返回套餐对象
  473.          *
  474.          * @param packNum
  475.          *            套餐序号
  476.          * @return 套餐对象
  477.          */
  478.         public ServicePackage createPack(int packId) {
  479.             ServicePackage pack = null;
  480.             switch (packId) {
  481.             case 1:
  482.                 pack = new TalkPackage();
  483.                 break;
  484.             case 2:
  485.                 pack = new NetPackage();
  486.                 break;
  487.             case 3:
  488.                 pack = new SuperPackage();
  489.                 break;
  490.             }
  491.             return pack;
  492.         }
  494.         /**
  495.          * 显示资费说明
  496.          */
  497.         public void showDescription(){
  498.             Reader rd = null;
  499.             try {
  500.                 rd = new FileReader("套餐资费说明.txt");
  501.                  char[] content = new char[1024];
  502.                  int len = 0;
  503.                  StringBuffer sb = new StringBuffer();
  504.                     while((len=rd.read(content))!=-1){
  505.                         sb.append(content,0,len);  //拼接字符串
  506.                     }
  507.                     System.out.println(sb);
  508.             } catch (IOException e) {
  509.                 // TODO Auto-generated catch block
  510.                 e.printStackTrace();
  511.             }
  512.         }
  513. }