用Java做项目：移动大厅业务工作

本文主要是介绍用Java做项目：移动大厅业务工作，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

import onr.*;

import java.io.*;
import java.text.DecimalFormat;
import java.util.*;

/**
 * @author -Wh-
 * @date 2022/2/21 16:26
 * @descripition
 */
public class Text {
    Scanner sc= new Scanner(System.in);
    Set<String> set = new HashSet<>();
    Map<String, MobileCard> cardMap = new HashMap<>();
    Map<String, List<ConsumInfo>> consumlnfos = new HashMap<>();
    List<ConsumInfo> list = new ArrayList<>();
    MobileCard mc = new MobileCard();
    ConsumInfo ci = new ConsumInfo();
    int time,type,flow,i=0;

    //套餐
    //初始化话唠套餐
    TalkPackage tp = new TalkPackage(58,500,30);
    //初始化网虫套餐
    NetPackage ns = new NetPackage(68,3);
    //初始化超人套餐
    SuperPackage sp = new SuperPackage(78,20,50,1);
    //初始化使用场景
    //初始化六种情况
    String s1 = "快递丢失，与快递小哥争论不休。通话90分钟";
    String s2 = "和女朋友吵架，被拉黑，发短信30条进行解释";
    String s3 = "直播打游戏，使用流量1个G";
    String s4 = "去远方，刚下飞机，给家人报平安。发送短信10条";
    String s5 = "通知好友们将要结婚。通话10分钟";
    String s6 = "放假在家，上网冲浪，使用流量2个G";

    //菜单
    public int caiDan(){
        System.out.println("********************欢迎使用嗖嗖移动业务大厅********************");
        System.out.println("1.用户登录，2.用户注册，3.使用嗖嗖，4.话费充值，5.资费说明，6退出系统");
        System.out.println("请选择：");
        int i = sc.nextInt();
        return i;
    }
    //二级菜单
    public int erCaiDan(){
        System.out.println("******嗖嗖移动用户菜单******");
        System.out.println("1.本月账单查询");
        System.out.println("2.套餐余量查询");
        System.out.println("3.打印消费详单");
        System.out.println("4.套餐变更");
        System.out.println("5.办理退网");
        System.out.println("请选择（输入1~5选择功能，其他键返回上一级）：");
        int i = sc.nextInt();
        return i;
    }
    //超出套餐的计费
    public void chaoJiFei(){
        System.out.println("超出套餐计费如下：");
        System.out.println("通话：0.2元/分钟");
        System.out.println("短信：0.1元/分钟");
        System.out.println("上网流量：0.1元/MB（1GB=1024MB）");
    }
    //电话号码
    public String dianHuaNum(){
        //初始化电话号码和set（j，z）的下标
        String str1 = "";
        int j = 0,z= 1;
        //循环录入手机号
        for (int i = 0; set.size() < 9; i++) {
            //随机产生8位数的随机数
            int num=(int)(Math.random()*100000000);
            //如果随机数小于八位数就重新生成，直到随机数为八位数
            while (num<10000000){
                num=(int)(Math.random()*100000000);
            }
            if (!cardMap.containsKey("139"+num)){
                //将随机的八位数存到set集合中
                set.add("139"+num);
            }
        }
        //遍历set集合显示九个手机号码
        for (String str : set) {
            //每三个为一行
            if (j%3==0&&j!=0){
                System.out.println();
            }
            //输出手机号
            System.out.print((j+1)+"."+str+"\t");
            //递增来进行序号与三个一行的运算
            j++;
        }
        System.out.println();
        //让客户输入序号来获取手机号
        System.out.print("请选择卡号（输入1~9的序号）：");
        int i = sc.nextInt();
        //遍历集合来判断客户输入的序号与set集合中的的位置一致则返回该索引的电话号码
        for (String str : set) {
            if (z==i){
                str1= str;
            }
            z++;
        }
        return str1;
    }
    //用户登录
    public boolean dengLu(){
        //用户录入手机卡号和密码
        System.out.println("请输入手机卡号：");
        String carkNum = sc.next();
        if (cardMap.isEmpty()){
            System.out.println("未注册，请先注册");
        }else {
            System.out.println("请输入密码：");
            String pass = sc.next();
            //将map集合的键值存在set集合中来进行遍历
            Set<String> str = cardMap.keySet();
            //遍历数组得到键值对应的对象
            for (String key : str) {
                mc = cardMap.get(key);
                //进行手机号和密码的匹配，正确返回true，不正确返回flase
                if (mc.getCardNumber().equals(carkNum)&&mc.getPassWord().equals(pass)){
                    return true;
                }else {
                    System.out.println("登录失败，账号密码错误");
                }
            }
        }
        return false;
    }
    //用户注册
    public void zhuCe(){
        //实例化手机号输出进行选择
        String shouJiNum = dianHuaNum();
        System.out.println("1.话唠套餐，2.网虫套餐，3.超人套餐，请输入套餐（输入序号）：");
        int i = sc.nextInt();
        //用户录入姓名和密码以及预存话费余额
        System.out.print("请输入姓名：");
        String name = sc.next();
        System.out.print("请输入密码：");
        String pass = sc.next();
        System.out.print("请输入预存话费余额：");
        double yuE = sc.nextDouble();
        //选择话唠套餐
        if (i==1){
            //判断预存话费如果小于套餐费就重新录入预存话费
            while (yuE<tp.getPrice()){
                System.out.print("您预存的话费余额不足以支付本月固定套餐资费，请重新充值：");
                yuE = sc.nextDouble();
            }
            //计算减去套餐费之后的余额
            double moeny = yuE-tp.getPrice();
            //输出套餐信息
            String s = tp.showInfo();
            System.out.println("注册成功！卡号"+shouJiNum+"，用户名："+name+"，当前余额："+moeny);
            System.out.println(s);
            //将用户信息存到list集合中
            mc = new MobileCard(shouJiNum,name,pass,tp,tp.getPrice(),moeny,tp.getTalkTime(),tp.getSmsCount(),0);
            //将信息存到map集合中，手机号为键值
            cardMap.put(shouJiNum,mc);
            set.clear();
            //选择网虫套餐
        }else if (i==2){
            //判断预存话费如果小于套餐费就重新录入预存话费
            while (yuE<ns.getPrice()){
                System.out.println("您预存的话费余额不足以支付本月固定套餐资费，请重新充值：");
                yuE = sc.nextDouble();
            }
            //计算减去套餐费之后的余额
            double moeny = yuE-ns.getPrice();
            //输出套餐信息
            String s = ns.showInfo();
            System.out.println("注册成功！卡号"+shouJiNum+"，用户名："+name+"，当前余额："+moeny);
            System.out.println(s);
            //将用户信息存到list集合中
            mc = new MobileCard(shouJiNum,name,pass,ns,ns.getPrice(),moeny,0,0,ns.getFlow());
            //将信息存到map集合中，手机号为键值
            cardMap.put(shouJiNum,mc);
            set.clear();
            //选择超人套餐
        }else if (i==3){
            //判断预存话费如果小于套餐费就重新录入预存话费
            while (yuE<sp.getPrice()){
                System.out.println("您预存的话费余额不足以支付本月固定套餐资费，请重新充值：");
                yuE = sc.nextDouble();
            }
            //计算减去套餐费之后的余额
            double moeny = yuE-sp.getPrice();
            String s = sp.showInfo();
            System.out.println("注册成功！卡号"+shouJiNum+"，用户名："+name+"，当前余额："+moeny);
            System.out.println(s);
            //将用户信息存到list集合中
            mc = new MobileCard(shouJiNum,name,pass,sp,sp.getPrice(),moeny,sp.getTalkTime(),sp.getSmsCount(),sp.getFlow());
            //将信息存到map集合中，手机号为键值
            cardMap.put(shouJiNum,mc);
            set.clear();
        }

    }
    //使用嗖嗖
    public String yong(){
        i=1;
        //随机0~6之间的数来判断
        int ran = (int)(Math.random()*6);
        System.out.println("请输入手机号：");
        //录入手机号来进行使用搜搜
        String carkNum = sc.next();

        Set<String> str = cardMap.keySet();
        //遍历数组得到键值对应的对象
        for (String key : str) {
            mc = cardMap.get(key);
        }

        //获取map键值
        Set<String> str1 = consumlnfos.keySet();
        //遍历数组得到键值对应的对象
        for (String key : str1) {
            //获取键值所对应的list集合
            if (key.equals(carkNum)){
                List<ConsumInfo> consum = consumlnfos.get(key);
                //遍历list集合来获取消费记录的对象
                for (ConsumInfo coi : consum){
                    //当存在消费记录里的手机号与登录的手机号一致时得到所对应的对象
                    if (coi.getNumber().equals(carkNum)){
                        ci = coi;
                    }
                }
            }
        }
        //进行手机号匹配，
        if (mc.getCardNumber().equals(carkNum)) {
            //判断是否该消费记录的手机号是否存在
            if ((ci.getNumber() == null)){
                //根据随机到的数字来进行选择那个情况
                switch (ran) {
                    case 0:
                        //第一种
                        System.out.println(s1);
                        //实例化消费记录对象
                        ci = new ConsumInfo(carkNum, 90, 0, 0,1,s1,s1);
                        //先存入list集合中
                        list.add(ci);
                        //再存入map集合中
                        consumlnfos.put(carkNum, list);
                        break;
                    case 1:
                        //第二种
                        System.out.println(s2);
                        //实例化消费记录对象
                        ci = new ConsumInfo(carkNum, 0, 30, 0,1,s2,s2);
                        //先存入list集合中
                        list.add(ci);
                        //再存入map集合中
                        consumlnfos.put(carkNum, list);
                        break;
                    case 2:
                        //第三种
                        System.out.println(s3);
                        //实例化消费记录对象
                        ci = new ConsumInfo(carkNum, 0, 0, 1024,1,s3,s3);
                        //先存入list集合中
                        list.add(ci);
                        //再存入map集合中
                        consumlnfos.put(carkNum, list);
                        break;
                    case 3:
                        //第四种
                        System.out.println(s4);
                        //实例化消费记录对象
                        ci = new ConsumInfo(carkNum, 0, 10, 0,1,s4,s4);
                        //先存入list集合中
                        list.add(ci);
                        //再存入map集合中
                        consumlnfos.put(carkNum, list);
                        break;
                    case 4:
                        //第五种
                        System.out.println(s5);
                        //实例化消费记录对象
                        ci = new ConsumInfo(carkNum, 10, 0, 0,1,s5,s5);
                        //先存入list集合中
                        list.add(ci);
                        //再存入map集合中
                        consumlnfos.put(carkNum, list);
                        break;
                    case 5:
                        //第六种
                        System.out.println(s6);
                        //实例化消费记录对象
                        ci = new ConsumInfo(carkNum, 0, 0, 2048,1,s6,s6);
                        //先存入list集合中
                        list.add(ci);
                        //再存入map集合中
                        consumlnfos.put(carkNum, list);
                        break;
                }
            }else {
                if (ci.getNumber().equals(carkNum)) {
                    //根据随机到的数字来进行选择那个情况
                    switch (ran) {
                        case 0:
                            //第一种
                            System.out.println(s1);
                            //在原基础上更改
                            ci.setCardNumber(ci.getCardNumber() + 90);
                            ci.setNum(ci.getNum()+1);
                            ci.setXiaoF(ci.getXiaoF()+","+s1);
                            ci.setXiao(s1);
                            break;
                        case 1:
                            //第二种
                            System.out.println(s2);
                            //在原基础上更改
                            ci.setType(ci.getType() + 25);
                            ci.setNum(ci.getNum()+1);
                            ci.setXiaoF(ci.getXiaoF()+","+s2);
                            ci.setXiao(s2);
                            break;
                        case 2:
                            //第三种
                            System.out.println(s3);
                            //在原基础上更改
                            ci.setConsumData(ci.getConsumData() + 1024);
                            ci.setNum(ci.getNum()+1);
                            ci.setXiaoF(ci.getXiaoF()+","+s3);
                            ci.setXiao(s3);
                            break;
                        case 3:
                            //第四种
                            System.out.println(s4);
                            //在原基础上更改
                            ci.setType(ci.getType() + 10);
                            ci.setNum(ci.getNum()+1);
                            ci.setXiaoF(ci.getXiaoF()+","+s4);
                            ci.setXiao(s4);
                            break;
                        case 4:
                            //第五种
                            System.out.println(s5);
                            //在原基础上更改
                            ci.setCardNumber(ci.getCardNumber() + 10);
                            ci.setNum(ci.getNum()+1);
                            ci.setXiaoF(ci.getXiaoF()+","+s5);
                            ci.setXiao(s5);
                            break;
                        case 5:
                            //第六种
                            System.out.println(s6);
                            //在原基础上更改
                            ci.setConsumData(ci.getConsumData() + 2048);
                            ci.setNum(ci.getNum()+1);
                            ci.setXiaoF(ci.getXiaoF()+","+s6);
                            ci.setXiao(s6);
                            break;
                    }
                }
            }
        }
        return carkNum;
    }
    //话费充值
    public void chongHuaFei(){
        //用户录入手机号进行判断以及充值的金额
        System.out.println("请输入要充值的手机号：");
        String shouJiHao = sc.next();
        System.out.println("请输入充值金额：");
        double Cmoeny = sc.nextDouble();
        //获取map的键值
        Set<String> str = cardMap.keySet();
        //遍历map集合得到用户对象
        for (String key:str) {
            //判断键值与手机号是否相等
            if (key.equals(shouJiHao)){
                 mc = cardMap.get(key);
            }
        }
        //更改用户账户余额
        i=1;
        mc.setMoney(mc.getMoney()+Cmoeny);
    }
    //资费说明
    public void shuoMing(){
        //话唠套餐的费用说明
        System.out.println(tp.showInfo());
        //网虫套餐的费用说明
        System.out.println(ns.showInfo());
        //超人套餐的说明
        System.out.println(sp.showInfo());
        //超出部分的计费要求
        chaoJiFei();
    }
    //本月账单查询
    public void chaBenYue(){
        if(mc.getMoney()-mc.getConsumAmount()>=0){

            //保留两位小数
            DecimalFormat df =new DecimalFormat("#.00");
            System.out.println("*****本月账单查询*****");
            System.out.println("您的卡号："+mc.getCardNumber()+"，当月账单：");
            System.out.println("套餐资费："+mc.getSerPackage().getPrice()+"元。");
            System.out.println("合计："+df.format(mc.getConsumAmount())+"元。");
            System.out.println("账户余额："+df.format(mc.getMoney()-mc.getConsumAmount())+"元(当前合计消费已扣除)。");
        }else {
            if (i==1){
                mc.setMoney(mc.getMoney()-mc.getConsumAmount());
            }
            i++;
            System.out.println("当前账户余额不足以扣除月费（套餐费用加超出费用）。");
        }
    }
    //套餐余量查询
    public void chaYuE(){
        System.out.println("*****套餐余量查询*****");
        System.out.println("剩余通话时长："+mc.getRealTalkTime());
        System.out.println("剩余流量："+mc.getRealFlow());
        System.out.println("剩余短信数："+mc.getRealSMSCount());
    }
    //打印消费详单
    public void daYin() {
        //获取登录的手机号
        String numder = mc.getCardNumber();
        //获取map键值
        Set<String> str = consumlnfos.keySet();
        //遍历数组得到键值对应的对象
        for (String key : str) {
            //获取键值所对应的list集合
            if (key.equals(numder)){
                List<ConsumInfo> consum = consumlnfos.get(key);
                //遍历list集合来获取消费记录的对象
                for (ConsumInfo coi : consum){
                    //当存在消费记录里的手机号与登录的手机号一致时得到所对应的对象
                    if (coi.getNumber().equals(numder)){
                        ci = coi;
                    }
                }
            }
        }
        //打印消费详单，并将异常处理
        OutputStream os= null;
        try {
            os = new FileOutputStream("D:\\bb\\"+mc.getCardNumber()+".txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        Writer writer= null;
        try {
            writer = new OutputStreamWriter(os,"UTF-8");
        } catch (UnsupportedEncodingException e) { e.printStackTrace(); }
        BufferedWriter bw=new BufferedWriter(writer);
        try {
            bw.write("*****消费账单*****"+"\n");
        } catch (IOException e) { e.printStackTrace(); }
        try {
            bw.write("机主："+mc.getUserNumber());
        } catch (IOException e) { e.printStackTrace(); }
        try {
            bw.write("手机号"+mc.getCardNumber()+"\n");
        } catch (IOException e) { e.printStackTrace(); }
        try {
            bw.write("通话时长："+ci.getCardNumber()+"分钟"+"\n");
        } catch (IOException e) { e.printStackTrace(); }
        try {
            bw.write("短信数："+ci.getType()+"条"+"\n");
        } catch (IOException e) { e.printStackTrace(); }
        try {
            bw.write("流量："+(ci.getConsumData()/1024)+"GB"+"\n");
        } catch (IOException e) { e.printStackTrace(); }
        try {
            bw.write("使用场景："+ci.getXiaoF());
        } catch (IOException e) { e.printStackTrace(); }
        try {
            bw.flush();
        } catch (IOException e) { e.printStackTrace(); }
        try {
            bw.close();
        } catch (IOException e) { e.printStackTrace(); }

        System.out.println("卡号："+mc.getCardNumber());
        System.out.println("通话时长："+ci.getCardNumber()+"分钟");
        System.out.println("短信数："+ci.getType()+"条");
        System.out.println("流量："+(ci.getConsumData()/1024)+"GB");
        System.out.println("具体使用情况请查看打印的文档！");
    }
    //套餐变更
    public void gai() {
        if (mc.getMoney() - mc.getConsumAmount() >= 0) {
            //选择要更改的套餐
            System.out.println("1.话唠套餐，2.网虫套餐，3.超人套餐，请输入套餐（输入序号）：");
            int i = sc.nextInt();
            switch (i) {
                //话唠套餐
                case 1:
                    //判断该手机号是否是该套餐
                    if (mc.getSerPackage() instanceof TalkPackage) {
                        System.out.println("您已是该套餐，不用进行更改");
                    } else {
                        //判断是否够扣除该费用的套餐
                        if (mc.getMoney() <= tp.getPrice()) {
                            System.out.println("您的余额不够扣除改套餐费用");
                        } else {
                            //更改原套餐的价格，通话时长，短信数，流量
                            mc.setConsumAmount(tp.getPrice());
                            mc.setRealTalkTime(tp.getTalkTime());
                            mc.setRealSMSCount(tp.getSmsCount());
                            mc.setSerPackage(tp);
                            mc.setRealFlow(0);
                            if (mc.getMoney()-mc.getConsumAmount() > mc.getMoney()){
                                mc.setMoney(mc.getMoney()-mc.getConsumAmount());
                            }
                            System.out.println("套餐更改成功");
                        }
                    }
                    break;
                case 2:
                    //判断该手机号是否是该套餐
                    if (mc.getSerPackage() instanceof NetPackage) {
                        System.out.println("您已是该套餐，不用进行更改");
                    } else {
                        //判断是否够扣除该费用的套餐
                        if (mc.getMoney() <= ns.getPrice()) {
                            System.out.println("您的余额不够扣除改套餐费用");
                        } else {
                            //更改原套餐的价格，通话时长，短信数，流量
                            mc.setConsumAmount(ns.getPrice());
                            mc.setRealTalkTime(0);
                            mc.setRealSMSCount(0);
                            mc.setSerPackage(ns);
                            mc.setRealFlow(ns.getFlow());
                            if (mc.getMoney()-mc.getConsumAmount() > mc.getMoney()){
                                mc.setMoney(mc.getMoney()-mc.getConsumAmount());
                            }
                            System.out.println("套餐更改成功");
                        }
                    }
                    break;
                case 3:
                    //判断该手机号是否是该套餐
                    if (mc.getSerPackage() instanceof SuperPackage) {
                        System.out.println("您已是该套餐，不用进行更改");
                    } else {
                        //判断是否够扣除该费用的套餐
                        if (mc.getMoney() <= sp.getPrice()) {
                            System.out.println("您的余额不够扣除改套餐费用");
                        } else {
                            //更改原套餐的价格，通话时长，短信数，流量
                            mc.setConsumAmount(sp.getPrice());
                            mc.setRealTalkTime(sp.getTalkTime());
                            mc.setRealSMSCount(sp.getSmsCount());
                            mc.setRealFlow(sp.getFlow());
                            mc.setSerPackage(sp);
                            if (mc.getMoney()-mc.getConsumAmount() > mc.getMoney()){
                                mc.setMoney(mc.getMoney()-mc.getConsumAmount());
                            }
                            System.out.println("套餐更改成功");
                        }
                    }
                    break;
            }
            }else{
            System.out.println("当前账户余额不足以扣除月费（套餐费用加超出费用）,请充值后使用。");
        }
    }
    //办理退网
    public void tui(){
        System.out.println("退网成功");
        cardMap.remove(mc.getCardNumber());
    }
    //计算使用的嗖嗖之后的套餐
    public void suan(String carkNum){
        //获取map键值
        Set<String> str = consumlnfos.keySet();
        //遍历数组得到键值对应的对象
        for (String key : str) {
            //获取键值所对应的list集合
            if (key.equals(carkNum)){
                List<ConsumInfo> consum = consumlnfos.get(key);
                //遍历list集合来获取消费记录的对象
                for (ConsumInfo coi : consum){
                    //当存在消费记录里的手机号与登录的手机号一致时得到所对应的对象
                    if (coi.getNumber().equals(carkNum)){
                        ci = coi;
                    }
                }
            }
        }
        //获取用户对象的键值
        Set<String> str1 = cardMap.keySet();
        //遍历map集合得到用户对象
        for (String key:str1) {
            //判断键值与手机号是否相等
            if (key.equals(carkNum)){
                //得到对应的用户对象
                mc = cardMap.get(key);
            }
        }

        if (ci.getXiao().equals(s1)||ci.getXiao().equals(s5)){
            //判断用户对象通话时长是否大于消费的通话时长
            if (mc.getRealTalkTime()>=ci.getCardNumber()){

                //大于之后用用户对象通话时长减去消费时长
                time = mc.getRealTalkTime()-ci.getCardNumber();
                //更改用户对象的通话时长
                mc.setRealTalkTime(time);

            }else {
                //当不大于时，抛出通话时长已用完的异常
                if (mc.getRealTalkTime()-ci.getCardNumber()<0){
                    try {
                        throw new Exception("通话时长已用完，您只剩下"+mc.getRealTalkTime()+"分钟的通话时长，请尽快充值话费余额");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
                //计算超出的时长
                time = ci.getCardNumber()-mc.getRealTalkTime();
                //更改用户对象套餐中的余量
                mc.setRealTalkTime(0);
                //计算合计费用，套餐费用加超出的费用
                double moeny=mc.getConsumAmount()+(time*0.2);
                //更改消费包
                mc.setConsumAmount(moeny);
            }
        }


        if (ci.getXiao().equals(s3)||ci.getXiao().equals(s6)){
            //判断用户对象流量是否大于消费的流量
            if ((mc.getRealFlow()*1024)>=ci.getConsumData()){

                //大于之后用用户对象通话时长减去消费时长
                time = mc.getRealFlow()-ci.getConsumData();
                //更改用户对象的通话时长
                mc.setRealFlow(time);

            }else {
                //当不大于时，抛出流量已用完的异常
                if ((mc.getRealFlow()*1024)-ci.getConsumData()<0){
                    try {
                        throw new Exception("流量已用完，您只剩下"+mc.getRealFlow()+"GB的流量，请尽快充值话费余额");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
                //计算超出的流量
                flow= ci.getConsumData()-mc.getRealFlow();
                //更改用户对象套餐中的流量
                mc.setRealFlow(0);
                //计算合计费用，套餐费用加超出的费用
                double moeny=mc.getConsumAmount()+(flow*0.1);
                //更改消费包
                mc.setConsumAmount(moeny);
            }
        }


        if (ci.getXiao().equals(s2)||ci.getXiao().equals(s4)){
            //判断用户对象短信数是否大于消费的短信数
            if (mc.getRealSMSCount()>=ci.getType()){

                //大于之后用用户对象通话时长减去消费时长
                time = mc.getRealSMSCount()-ci.getType();
                //更改用户对象的通话时长
                mc.setRealSMSCount(time);

            }else {
                //当不大于时，抛出短信数已用完的异常
                if (mc.getRealSMSCount()-ci.getType()<0){
                    try {
                        throw new Exception("短信数已用完，您只剩下"+mc.getRealSMSCount()+"条短信数，请尽快充值话费余额");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
                //计算超出的短信
                type = ci.getType() - mc.getRealSMSCount();
                //更改用户对象套餐中的短信数
                mc.setRealSMSCount(0);
                计算合计费用，套餐费用加超出的费用
                double moeny=mc.getConsumAmount()+(time*0.1);
                //更改消费包
                mc.setConsumAmount(moeny);
            }
        }
    }
}

这篇关于用Java做项目：移动大厅业务工作的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！