嗖嗖移动大厅 源代码 Java初级小项目

　　今天再给大家分享一个小项目：嗖嗖移动业务大厅。用的是Java语言开发的，代码很多，概括的功能也很全面。系统是模拟移动、联通、电信国内三大通信运营商的功能，有用户登录、用户注册、话费充值、使用嗖嗖、资费说明、退出系统、本月账单查询、套餐余量查询、打印消费详单、套餐变更、办理退网等功能（后附源代码）！　　

---

一 、 项目概述

　　技能要求

　　 使用面向对象设计的思想
　　 合理运用异常处理
　　 使用集合框架存储数据，不使用数据库
　　 使用 I/O 操作实现对文件的读写

---

 　　开发工具

　　JDK 7.0、MyEclipse。

---

 　　需求概述

　　移动、联通、电信是国内三大通信运营商，每个运营商提供了不同的品牌套餐来应对不同的用户群，例如北京移动，主要有全球通、神州行、动感地带三大品牌套餐，每种套餐的内容和资费不同。现嗖嗖移动是一拟定的通信运营商，提供了话唠套餐、网虫套餐、超人套餐，各种套餐所包含的服务内容及资费如表 1 所示。

 　　如实际使用中，超出套餐内包含的通话时长、短信条数或上网流量时，按以下规则计费：

　　 超出的通话：0.2 元/分钟
　　 超出的短信：0.1 元/分钟
　　 超出的上网流量：0.1 元/MB
　　本项目嗖嗖移动业务大厅提供了嗖嗖移动用户的日常常用功能，包括新用户注册、本月账单查询、套餐余量查询、打印消费详单、套餐变更、办理退网、话费充值、查看消费记录、查看资费说明功能，另外，还可以模拟用户通话、上网、发短信的场景进行相应的扣费并记录消费信息。各功能介绍如表 2 所示。

 二 、 项目业务流程描述

1.整体业务流程

嗖嗖移动项目的各个功能实际都是挂在功能菜单上的，其中主菜单包含 6 个功能，当用户输入 1~5 之间的功能编号后，验证卡号，如果该卡号已注册，执行相应功能后返回主菜单，否则，退出系统。如图 1 所示。

 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图 1 主菜单

　　当使用已注册用户登录并通过验证后，即显示二级菜单，包含 5 个功能，如图 2 所示。当输入 1~5 之外的功能编号时，返回主菜单。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 图 2 二级菜单

2. 用户注册

该功能可以看作是去营业厅办理新卡的过程。主要分成以下几个步骤：
1) 选择卡号（从随机生成的 9 个以“139”开头的卡号中选择一个，输入序号即可）。
2) 选择套餐（共 3 类套餐，选择其中一个，输入所对应的序号即可）。
3) 输入用户名、密码信息（相当于现在各营业厅的实名登录，输入用户名和密码即可）。
4) 输入预存话费金额：这里需保存预存的金额足以支付一个月的套餐费用，否则给出信息提示“您预存的话费金额不足以支付本月固定套餐资费，请重新充值！”。

5) 注册新卡
实现效果如图 3 所示。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图 3 用户注册

3. 本月账单查询

本月账单可以显示以下信息：
 卡号。
 套餐月资费。
 合计（是套餐固定资费和超出套餐使用费用总和）。
 账户余额。
运行效果如图 4 所示。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图 4 本月账单查询

4. 套餐余量查询

本功能用来显示该卡所属套餐内所剩余的免费通话时长、短信条数、上网流量，不同品牌套餐所支持的服务不同，因此显示的内容不同。运行效果如图 5 所示。

 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图 5 套餐余量查询

5. 添加和打印消费清单

实现向消费记录中添加一条该卡的消费记录（该功能可在使用嗖嗖功能中调用），并实现打印该卡的消费记录，打印前先从消费记录中查找是否存在此卡的消费记录，如存在则提示“已添加一条消费记录。”，将消费记录输出到文本文件中，格式如图 5 所示。如不存在，提示用户相应信息，如图 6 所示。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图 5 消费记录

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图 6 该卡不存在消费记录

6.使用嗖嗖

（1）随机进入某个场景

模拟嗖嗖用户使用卡的过程。选择该功能后，输入当前卡号，通过验证后，可随机进入表 3 所示的 6 个场景（当然还可以再设计其他场景），要求所进入的场景的服务类型是该卡所属套餐所支持的（例如网虫套餐只能进入服务类型为“上网”的场景）。

（2）模拟消费
进入该场景这之后，将按场景的描述要求消耗套餐余量，如套餐余量不足，需按套餐外的资费规则扣费，成功消费后，添加一条消费记录。效果如图 7 所示。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 图 7 使用嗖嗖成功

余额不足时，提示信息。如本场景通话时长为 30 分钟，当通话至 10 分钟时余额不足，抛出异常，并提示用户“本次已通话 10 分钟，您的余额不足，请充值后再使用！”如图 8所示

 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图 8 余额不足的情况

（3）消费结束，添加消费记录
消费完毕，在消费列表中添加一条消费记录。并提示用户“已添加一条消费记录！”。按实际消费添加消费记录，除非没有消费。如图 8 的情况，则此条消费记录只需记录实际通话时长 10 分钟。

7. 办理退网
本功能可实现将当前卡用户从已注册用户列表中删除，删除后直接退出系统。运行效果如图 9 所示。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图 9 办理退网

8. 套餐变更
本功能类似我们去营业厅变量套餐，可以充分体会到使用面向对象后，代码更加灵活，可维护性更强。
本项目中没有引入对日期的记录和处理，因此，这里默认套餐变更时间为本月的开始，选择变量后的套餐为当前套餐之外的其他类型，否则显示信息提示。如图 10 所示。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 图 10 选择套餐错误

选择套餐正确之后，还需判断当前余额是否足以支付一个月的套餐资费，如不足，提示错误信息。如图 11 所示。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图 11 变更套餐余额不足

如上述两个条件都满足时，套餐变量成功，显示相应信息，如图 12 所示。当前卡实际使用数据清零，当前卡所属套餐修改为变量后的套餐类型，当前卡余额减去新套餐月资费，本月消费金额修改为新套餐月资费。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 图 12 套餐变更成功

9. 话费充值
可为指定卡号充值，要求充值金额最少 50 元。充值成功后提示信息。运行效果如图 13所示。

 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图 13 充值成功

通过最少充值金额验证后，修改当前卡余额即可。

10. 查看资费说明
此功能需实现将文本文件（套餐资费说明.txt）中的信息显示到控制台。本功能需使用 I/O 操作实现文本文件的写入。

---

　　以上是嗖嗖项目的整体需求概述，下面介绍如何搭建嗖嗖项目的框架结构：

一、 实体类(Entity)

 二、工具类 (utils)

 

---

 　　下面是项目的整体代码结构：

 实体类中的其中一个手机卡类：

package cn.soso.entity;
/**
 * 手机卡
 *
 */
public class MobileCard {
    private String cardNumber;  //卡号
    private String userName;  //用户名
    private String passWord;  //密码    
    private ServicePackage serPackage;  //所属套餐
    private double consumAmount;  //当月消费金额
    private double money;  //账户余额
    private int realTalkTime;  //实际通话时长（分钟）
    private int realSMSCount;  //实际发送短信条数（条）
    private int realFlow;  //实际上网流量
    
    public MobileCard(){}

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

    public String getUserName() {
        return userName;
    }

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

    public String getPassWord() {
        return passWord;
    }

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

    public String getCardNumber() {
        return cardNumber;
    }

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

    public ServicePackage getSerPackage() {
        return serPackage;
    }

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

    public double getConsumAmount() {
        return consumAmount;
    }

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

    public double getMoney() {
        return money;
    }

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

    public int getRealTalkTime() {
        return realTalkTime;
    }

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

    public int getRealSMSCount() {
        return realSMSCount;
    }

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

    public int getRealFlow() {
        return realFlow;
    }

    public void setRealFlow(int realFlow) {
        this.realFlow = realFlow;
    }
    
    /**
     * 显示卡信息
     */
    public void showMeg(){
        System.out.println("卡号："+this.cardNumber+" 用户名："+this.userName+" 当前余额："+this.money+"元。");
        this.serPackage.showInfo();
    }    
}

---

 

 整体业务流程类：

package cn.soso.biz;

import java.util.Scanner;

import cn.soso.common.Common;
import cn.soso.entity.MobileCard;
import cn.soso.entity.ServicePackage;
import cn.soso.utils.CardUtil;

/**
 * 业务类
 * 
 * 
 */
public class SosoMgr {
    Scanner input = new Scanner(System.in);
    CardUtil utils = new CardUtil();
    
    public static void main(String[] args) {
        SosoMgr soso = new SosoMgr();
        soso.mainMenu();
        System.out.println("谢谢使用！");
    }

    /**
     * 主流程
     */
    public void mainMenu() {
        int menuChoose = 0;
        String mobileNumber= "";
        String password = "";
        utils.init();
        utils.initScenes();
        //Common.typesInit();
        do {
            System.out.println("\n*************欢迎使用嗖嗖移动业务大厅***************");
            System.out.println("1.用户登录   2.用户注册   3.使用嗖嗖   4.话费充值  5.资费说明  6.退出系统");
            System.out.print("请选择：");
            menuChoose = input.nextInt();
            // 分支语句：根据功能编号执行相应功能
            switch (menuChoose) {
            case 1:
                //用户登录
                System.out.print("请输入手机卡号：");
                mobileNumber = input.next();
                System.out.print("请输入密码：");
                password = input.next();
                if (utils.isExistCard(mobileNumber, password)) {
                    cardMenu(mobileNumber);
                }else{
                    System.out.println("对不起，您输入的信息有误，无法登录！");
                }
                continue;
            case 2:
                //用户注册
                registCard();
                continue;
            case 3:
                
                //使用嗖嗖
                System.out.print("请输入手机卡号：");
                 mobileNumber = input.next();                
                
                if (utils.isExistCard(mobileNumber)) {
                    try {
/*                        System.out.println("****使用之前****");
                        utils.showRemainDetail(mobileNumber);
                        utils.showAmountDetail(mobileNumber);*/
                        utils.userSoso(mobileNumber);
                    } catch (Exception e) {
                        System.err.println(e.getMessage());
                    }
                }else{
                    System.out.println("对不起，该卡号未注册，不能使用！");
                }
                
                /*System.out.println("****使用之后****");
                utils.showRemainDetail(mobileNumber);
                utils.showAmountDetail(mobileNumber);*/
                continue;
            case 4:
                //话费充值
                System.out.print("请输入充值卡号：");
                mobileNumber = input.next();
                if (utils.isExistCard(mobileNumber)) {
                System.out.print("请输入充值金额：");
                double money = input.nextDouble();                
                utils.chargeMoney(mobileNumber, money);
                }else{
                    System.out.println("对不起，要充值的卡号未注册，无法充值！");
                }
                continue;                
            case 5:
                System.out.println("\n*****资费说明******");
                utils.showDescription();
                continue;    
            case 6:
                //退出系统
                break;
            default:
                //选择其他数字退出系统
                break;
            }
            break;
        } while (true);
    }

    /**
     * 手机卡功能菜单
     * 
     * @param number
     * @return
     */
    public int cardMenu(String mobileNumber) {
           int menuChoose = 0;
        do {
            System.out.println("\n*****嗖嗖移动用户菜单*****");
            System.out.println("1.本月账单查询");
            System.out.println("2.套餐余量查询");
            System.out.println("3.打印消费详单");
            System.out.println("4.套餐变更");
            System.out.println("5.办理退网");
            System.out.print("请选择(输入1~5选择功能，其他键返回上一级)：");
             menuChoose = input.nextInt();
            switch (menuChoose) {
            case 1:
                System.out.println("\n*****本月账单查询******");
                utils.showAmountDetail(mobileNumber);
                continue;
            case 2:
                System.out.println("\n*****套餐余量查询******");
                utils.showRemainDetail(mobileNumber);
                continue;
            case 3:
                System.out.println("\n*****消费详单查询******");
                utils.printConsumInfo(mobileNumber);
                continue;
            case 4:
                System.out.println("\n*****套餐变更******");
                System.out.print("1.话唠套餐  2.网虫套餐  3.超人套餐  请选择（序号）：");                
                utils.changingPack(mobileNumber, input.next());
                continue;
            case 5:
                System.out.println("\n*****办理退网******");
                utils.delCard(mobileNumber);
                System.out.println("谢谢使用！");
                System.exit(1);     //办理退网后退出系统    
                        
            }
            
            break;
        } while (true);
        return menuChoose;
    }
    
    /**
     * 注册新卡流程
     */
    public void registCard(){
        String[] newNumbers = utils.getNewNumbers(9);
        //显示可供选择的手机号列表
        System.out.println("*****可选择的卡号*****");
        
        for(int i=0;i<9;i++){
            System.out.print((i+1)+"."+newNumbers[i]+"\t\t");
            if((i+1)%3==0){
                System.out.println();
            }
        }
        //选择手机号
        System.out.print("请选择卡号（输入1~9的序号）：");        
        String number = newNumbers[input.nextInt()-1];
        
        //选择套餐类型
        System.out.print("1.话唠套餐  2.网虫套餐  3.超人套餐，  ");
        System.out.print("请选择套餐(输入序号)：");
        //utils.getPackList();
        //获取套餐对象 
        ServicePackage pack = utils.createPack(input.nextInt());
        
        //输入用户名
        System.out.print("请输入姓名：");
        String name = input.next();
        
        //输入密码
        System.out.print("请输入密码：");
        String password = input.next();
        
        //输入预存话费金额
        double money = 0;
        System.out.print("请输入预存话费金额：");
         money = input.nextDouble();
        while(money<pack.getPrice()){
            System.out.print("您预存的话费金额不足以支付本月固定套餐资费，请重新充值：");
            money = input.nextDouble();
        }
                
        //创建新卡对象并添加
        MobileCard newCard = new MobileCard(name,password,number,pack,pack.getPrice(),money-pack.getPrice());
        utils.addCard(newCard);        
    }
}

---

 

 手机卡工具类：

package cn.soso.utils;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;

import cn.soso.common.Common;
import cn.soso.entity.ConsumInfo;
import cn.soso.entity.MobileCard;
import cn.soso.entity.NetPackage;
import cn.soso.entity.Scene;
import cn.soso.entity.ServicePackage;
import cn.soso.entity.SuperPackage;
import cn.soso.entity.TalkPackage;
import cn.soso.service.CallService;
import cn.soso.service.NetService;
import cn.soso.service.SendService;

/**
 * 手机卡工具类
 * 
 * 
 */
public class CardUtil {
    Map<String, MobileCard> cards = new HashMap<String, MobileCard>(); // 所有手机卡的列表
    Map<String, List<ConsumInfo>> consumInfos = new HashMap<String, List<ConsumInfo>>(); // 所有手机卡消费记录的列表
    List<Scene> scenes = new ArrayList<Scene>();

    // 初始化用户
    public void init() {
        MobileCard card1 = new MobileCard("何玲玲", "123", "13965756432",
                new TalkPackage(), 58.0, 42.0);
        MobileCard card2 = new MobileCard("黄露露", "123", "13956712467",
                new NetPackage(), 68.0, 32.0);
        MobileCard card3 = new MobileCard("朱蓉蓉", "123", "13911568956",
                new SuperPackage(), 78.0, 22.0);
        MobileCard card4 = new MobileCard("桃跑跑", "123", "13924221868",
                new TalkPackage(), 78.0, 2.0);
        card4.setConsumAmount(98.0);
        card4.setRealTalkTime(500);
        card4.setRealSMSCount(100);
        cards.put("13965756432", card1);
        cards.put("13956712467", card2);
        cards.put("13911568956", card3);
        cards.put("13924221868", card4);
    }
    
    /**
     * 使用场景初始化
     */
    public void initScenes(){    
        scenes.add(new Scene("通话",90,"问候客户，谁知其如此难缠 通话90分钟"));
        scenes.add(new Scene("通话",30,"询问妈妈身体状况 本地通话30分钟"));
        scenes.add(new Scene("短信",5,"参与环境保护实施方案问卷调查 发送短信5条"));
        scenes.add(new Scene("短信",50,"通知朋友手机换号，发送短信50条"));
        scenes.add(new Scene("上网",1*1024,"和女友微信视频聊天   使用流量1G"));
        scenes.add(new Scene("上网",2*1024,"晚上手机在线看韩剧，不留神睡着啦！ 使用流量 2G"));        
    }

    /**
     * 是否存在此卡用户

     * 
     * @param number
     * @param passWord
     * @return
     */
    public boolean isExistCard(String number, String passWord) {
        Set<String> numbers = cards.keySet();
        Iterator<String> it = numbers.iterator();
        while (it.hasNext()) {
            String searchNum = it.next();
            if (searchNum.equals(number)
                    && (cards.get(searchNum)).getPassWord().equals(passWord)) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * 查找指定卡号是否已注册
     * 
     * @param searchNumber
     * @return 未注册：false 已注册：true
     */
    public boolean isExistCard(String searchNumber) {
        Set<String> numbers = cards.keySet();
        for (String number : numbers) {
            if (number.equals(searchNumber)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 创建卡号（以139开头 11位）
     * 
     * @return 生成的随机手机卡号
     */
    public String createNumber() {
        Random random = new Random();
        boolean isExist = false; // 记录现有用户中是否存在此卡号用户 是：true 否：false
        String number = "";
        int temp = 0;
        do {
            isExist = false; // 标志位重置为false,用于控制外重循环，当生成了
            // 生成的随机数是8位 不能小于10000000，否则重新生成
            do {
                temp = random.nextInt(100000000);
            } while (temp < 10000000);
            // 生成之前，前面加“139”
            number = "139" + temp;
            // 和现有用户的卡号比较，不能是重复
            Set<String> cardNumbers = cards.keySet();
            for (String cardNumber : cardNumbers) {
                if (number.equals(cardNumber)) {
                    isExist = true;
                    break;
                }
            }
        } while (isExist);
        return number;
    }

    /**
     * 生成指定个数的新卡号列表
     * 
     * @param count
     *            指定个数
     * @return 卡号列表
     */
    public String[] getNewNumbers(int count) {

        String[] numbers = new String[count];
        for (int i = 0; i < count; i++) {
            numbers[i] = createNumber();
        }
        return numbers;
    }

    /**
     * 添加新卡
     * 
     * @param card
     *            新卡
     */
    public void addCard(MobileCard card) {
        cards.put(card.getCardNumber(), card);
        System.out.print("注册成功！");
        card.showMeg();
    }

    /**
     * 指定卡号办理退网
     * 
     * @param card
     */
    public void delCard(String delNumber) {
        if (isExistCard(delNumber)) {
            cards.remove(delNumber);
            System.out.println("卡号" + delNumber + "办理退网成功！");
        } else {
            System.out.println("对不起，该卡号未注册，不能办退退网！");
        }
    }

    /**
     * 查询指定卡套餐余量
     * 
     * @param number
     */
    public void showRemainDetail(String searchNumber) {
        MobileCard card; // 要查询的卡
        int remainTalkTime;
        int remainSmsCount;
        int remainFlow;
        StringBuffer meg = new StringBuffer();
            card = cards.get(searchNumber);
            meg.append("您的卡号是" + searchNumber + "，套餐内剩余：\n");
            ServicePackage pack = card.getSerPackage();
            if (pack instanceof TalkPackage) {
                //向下转型为话唠套餐对象
                TalkPackage cardPack = (TalkPackage) pack;
                // 话唠套餐，查询套餐内剩余的通话时长和短信条数
                remainTalkTime = cardPack.getTalkTime() > card
                        .getRealTalkTime() ? cardPack.getTalkTime()
                        - card.getRealTalkTime() : 0;
                meg.append("通话时长：" + remainTalkTime + "分钟\n");
                remainSmsCount = cardPack.getSmsCount() > card
                        .getRealSMSCount() ? cardPack.getSmsCount()
                        - card.getRealSMSCount() : 0;
                meg.append("短信条数：" + remainSmsCount + "条");
            } else if (pack instanceof NetPackage) {
                //向下转型为网虫套餐对象
                NetPackage cardPack = (NetPackage) pack;
                // 网虫套餐：查询套餐内剩余的上网流量
                remainFlow = cardPack.getFlow() > card.getRealFlow() ? cardPack
                        .getFlow() - card.getRealFlow() : 0;
                meg.append("上网流量：" + Common.dataFormat(remainFlow * 1.0 / 1024)
                        + "GB");
            } else if (pack instanceof SuperPackage) {
                //向下转型为超人套餐对象
                SuperPackage cardPack = (SuperPackage) pack;
                // 超人套餐：查询套餐内剩余的通话时长、短信条数、上网流量
                remainTalkTime = cardPack.getTalkTime() > card
                        .getRealTalkTime() ? cardPack.getTalkTime()
                        - card.getRealTalkTime() : 0;
                meg.append("通话时长：" + remainTalkTime + "分钟\n");
                remainSmsCount = cardPack.getSmsCount() > card
                        .getRealSMSCount() ? cardPack.getSmsCount()
                        - card.getRealSMSCount() : 0;
                meg.append("短信条数：" + remainSmsCount + "条\n");
                remainFlow = cardPack.getFlow() > card.getRealFlow() ? cardPack
                        .getFlow() - card.getRealFlow() : 0;
                meg.append("上网流量：" + Common.dataFormat(remainFlow * 1.0 / 1024)
                        + "GB");
            }
            System.out.println(meg);
    }

    /**
     * 查询指定卡当月消费详单
     * 
     * @param searchNumber
     */
    public void showAmountDetail(String searchNumber) {
        MobileCard card; // 要查询的卡
        StringBuffer meg = new StringBuffer();
        card = cards.get(searchNumber);
        meg.append("您的卡号：" + card.getCardNumber() + ",当月账单：\n");
        meg.append("套餐资费：" + card.getSerPackage().getPrice() + "元\n");
        meg.append("合计：" + Common.dataFormat(card.getConsumAmount()) + "元\n");
        meg.append("账户余额：" + Common.dataFormat(card.getMoney()) + "元");
        // 显示本月消费详细信息
        System.out.println(meg);
    }

    
    /**
     * 指定卡号换套餐
     * 
     * @param number
     * @param packType
     */
    public void changingPack(String number, String packNum) {
        MobileCard card; // 指定的手机卡
        ServicePackage pack; // 要换的套餐
        if (isExistCard(number)) {
            card = cards.get(number);
            // 获取要换的套餐对象
            switch (packNum) {
            case "1":
                pack = new TalkPackage();
                break;
            case "2":
                pack = new NetPackage();
                break;
            default:
                pack = new SuperPackage();
                break;
            }        
            if (!(card.getSerPackage().getClass().getName().equals(pack.getClass().getName()))) {
                // 该卡余额中减去当月套餐资费
                if (card.getMoney() >= pack.getPrice()) {
                    card.setMoney(card.getMoney() - pack.getPrice());
                    // 换套餐
                    card.setSerPackage(pack);
                    // 当月实际使用数据清零
                    card.setRealTalkTime(0);
                    card.setRealFlow(0);
                    card.setRealSMSCount(0);
                    // 当月消费金额设置为新套餐月资费
                    card.setConsumAmount(pack.getPrice());
                    System.out.print("更换套餐成功！");
                    pack.showInfo();
                } else {
                    System.out.println("对不起，您的余额不足以支付新套餐本月资费，请充值后再办理更换套餐业务！");
                    return;
                }
            } else {
                System.out.println("对不起，您已经是该套餐用户，无需换套餐！");
            }

        } else {
            System.out.println("对不起，该卡号未注册，不能换套餐！");
        }
    }

    /**
     * 为指定手机卡充值
     * 
     * @param number
     *            指定充值的卡号
     * @param money
     *            充值金额
     */
    public void chargeMoney(String number, double money) {
        MobileCard card; // 指定的手机卡
        if (money < 50) {
            System.out.println("对不起，最低充值金额为50元！");
            return;
        }
            card = cards.get(number);
            card.setMoney(card.getMoney() + money);
            System.out.println("充值成功，当前话费余额为" + Common.dataFormat(card.getMoney()) + "元。");
    }

    /**
     * 添加一条指定卡的消费记录
     * 
     * @param number
     *            要添加消费记录的卡
     * @param info
     *            要添加的消费记录
     */
    public void addConsumInfo(String number, ConsumInfo info) {
        Set<String> numbers = consumInfos.keySet();
        Iterator<String> it = numbers.iterator();
        List<ConsumInfo> infos = new ArrayList<ConsumInfo>();
        boolean isExist = false; // 现有消费列表中是否存在此卡号消费记录，是：true 否：false
        while (it.hasNext()) {
            if (it.next().equals(number)) {
                // 消费集合中已有该卡号消费记录，则找到该卡号的消费记录集合，添加一条即可
                infos = consumInfos.get(number);
                infos.add(info);
                isExist = true;
                System.out.println("已添加一条消费记录。");
                break;
            }
        }
        // 该集合中没有此卡号消费记录，则添加
        if (!isExist) {
            infos.add(info);
            consumInfos.put(number, infos);
            System.out.println("不存在此卡的消费记录，已添加一条消费记录。");
        }
    }
    
    //打印消费记录
    public void printConsumInfo(String number){
        Writer fileWriter = null;
        try {
             fileWriter = new FileWriter(number+"消费记录.txt");            
            Set<String> numbers = consumInfos.keySet();
            Iterator<String> it = numbers.iterator();
            List<ConsumInfo> infos = new ArrayList<ConsumInfo>();//存储指定卡所有消费记录
            boolean isExist = false; // 现有消费列表中是否存在此卡号消费记录，是：true 否：false
            while (it.hasNext()) {
                if (it.next().equals(number)) {
                    infos = consumInfos.get(number);
                    isExist = true;
                    break;
                }
            }
            if(isExist){
                //存在 此卡消费记录，写入文本文件
                StringBuffer content = new StringBuffer("******"+number+"消费记录******\n");
                content.append("序号\t类型\t数据（通话（条）/上网（MB）/短信（条））\n");
                for(int i=0;i<infos.size();i++){
                    ConsumInfo info = infos.get(i);
                    content.append((i+1)+".\t"+info.getType()+"\t"+info.getConsumData()+"\n");
                }
                fileWriter.write(content.toString());
                fileWriter.flush();
                
                System.out.println("消费记录打印完毕！");
            }else{
                System.out.println("对不起，不存在此号码的消费记录，不能打印！");
            }            
        } catch (IOException e) {            
            e.printStackTrace();
        }finally{
            if(fileWriter!=null){
                try {
                    fileWriter.close();
                } catch (IOException e) {                    
                    e.printStackTrace();
                }
            }
        }
    }
    
    /**
     * 使用嗖嗖
     * @param number 当前卡号
     * @throws Exception 
     */
    public void userSoso(String number)  {        
        MobileCard card = cards.get(number); // 获取此卡对象
        ServicePackage pack = card.getSerPackage(); // 获取此卡所属套餐
        Random random = new Random();
        int ranNum = 0;
        int temp = 0;  //记录各场景中实际消费数据
        do{
            
            ranNum = random.nextInt(6);// 生成一个0~5之前的随机数
            Scene scene = scenes.get(ranNum); //获取该序号所对应的场景
            switch (ranNum) {
            //序号为0或1为通话场景
            case 0:
            case 1:
                // 判断该卡所属套餐是否支持通话功能
                if (pack instanceof CallService) {
                    // 执行通话方法
                    System.out.println(scene.getDescription());
                    CallService callService = (CallService) pack;
                    try {
                        temp = callService.call(scene.getData(), card);
                    } catch (Exception e) {                            
                        e.printStackTrace();
                    }
                    // 添加一条消费记录
                    addConsumInfo(number, new ConsumInfo(number,
                            scene.getType(), temp));
                    break;
                } else {
                    // 如果该卡套餐不支持通话功能，则重新生成随机数选择其他场景
                    continue;
                }
                //序号为2或3为发短信场景
            case 2:
            case 3:
                // 判断该卡所属套餐是否支持短信功能
                if (pack instanceof SendService) {
                    // 执行发短信方法
                    System.out.println(scene.getDescription());
                    SendService sendService = (SendService) pack;
                    try {
                        temp = sendService.sendMessage(scene.getData(), card);
                    } catch (Exception e) {                                                    
                        e.printStackTrace();
                    }
                    // 添加一条消费记录
                    addConsumInfo(number, new ConsumInfo(number,
                            scene.getType(), temp));
                    break;
                } else {
                    // 如果该卡套餐不支持发短信功能，则重新生成随机数选择其他场景
                    continue;
                }
                //序号为4或5为发上网场景
            case 4:
            case 5:
                // 判断该卡所属套餐是否支持上网功能
                if (pack instanceof NetService) { 
                    System.out.println(scene.getDescription());
                    NetService netService = (NetService) pack;
                    // 执行上网方法
                    try {
                        temp = netService.netPlay(scene.getData(), card);
                    } catch (Exception e) {                        
                        e.printStackTrace();
                    }
                    // 添加一条消费记录
                    addConsumInfo(number, new ConsumInfo(number,
                            scene.getType(), temp));
                    break;
                } else {
                    // 如果该卡套餐不支持上网功能，则重新生成随机数选择其他场景
                    continue;
                }                
            }    
            break;
        }while(true);
    }

    /**
     * 根据套餐序号返回套餐对象
     * 
     * @param packNum
     *            套餐序号
     * @return 套餐对象
     */
    public ServicePackage createPack(int packId) {
        ServicePackage pack = null;
        switch (packId) {
        case 1:
            pack = new TalkPackage();
            break;
        case 2:
            pack = new NetPackage();
            break;
        case 3:
            pack = new SuperPackage();
            break;
        }
        return pack;
    }
    
    /**
     * 显示资费说明
     */
    public void showDescription(){
        Reader rd = null;
        try {
            rd = new FileReader("套餐资费说明.txt");
             char[] content = new char[1024];
             int len = 0;
             StringBuffer sb = new StringBuffer();
                while((len=rd.read(content))!=-1){
                    sb.append(content,0,len);  //拼接字符串
                }
                System.out.println(sb);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
}

---

　　 小伙伴可以多多互动，一起多交流交流！！！O(∩_∩)O

　　喜欢前端、后端java开发的 可以到我的知乎主页(更多详细内容等你关注呦)：https://www.zhihu.com/people/xing-chen-you-guang-pie-pie-pie，有详细视频、资料、教程，文档，值得拥有！！！希望可以一起努力，加油ヾ(◍°∇°◍)ﾉﾞ！！！　　

　　B站有上传的更多项目视频，从Java基础到面向对象、Java高级API，以及SSM等框架的视频，地址：https://www.bilibili.com/video/BV15a411w7Jh