精华内容
下载资源
问答
  • 嗖嗖移动业务大厅

    2018-12-05 09:58:14
    嗖嗖移动业务大厅,完整的项目工程文件。直接导入即可使用。
  • ACCP8.0S2嗖嗖移动业务大厅ACCP8.0S2嗖嗖移动业务大厅ACCP8.0S2嗖嗖移动业务大厅
  • 实现嗖嗖移动业务大厅java代码实现嗖嗖移动业务大厅java代码
  • 嗖嗖移动业务大厅源码实例,及供参考~~~~~~~~~~~~~~~~~~~~~~~~~~~有什么不懂:联系微信 dzl-wx
  • 嗖嗖移动业务大厅,Java初级控制台小程序
  • JAVA小项目 嗖嗖移动业务大厅 为什么要我写大于50个字节
  • 嗖嗖移动业务大厅(源码下载+注释全 值得收藏)

    万次阅读 多人点赞 2018-10-20 05:48:26
    嗖嗖移动业务大厅项目(代码+注释全) package info; /* * 消费记录 * @author 苍何 */ public class ConsumInfo { public String cardNumber; public String type;//类型(童话、短信、上网) ...

    嗖嗖移动业务大厅项目(源码+下载+注释全)

    鉴于很多同学找我要源码,特意将源码放在了微信公众号上面,直接就可以下载获取源码,还能获得很多我亲自整理的学习笔记,欢迎关注公众号——苍何之旅,点击下方的菜单栏““嗖嗖源码””
    “”

    源码下载:点我下载
    项目整体框架

    package info;
    /*
     * 消费记录
     * @author 苍何
     */
    public class ConsumInfo {
    	public String cardNumber;
    	public String type;//类型(童话、短信、上网)
    	public int consumDate;//当前消费量 
    	
    	public ConsumInfo() {
    	}
    	public ConsumInfo(String cardNumber, String type, int consumDate) {
    		super();
    		this.cardNumber = cardNumber;
    		this.type = type;
    		this.consumDate = consumDate;
    	}
    }
    `
    
    package info;
    
    import myPackage.ServicePackage;
    
    /*
     * 卡号类
     * @author 苍何
     */
    public class MobileCard {
    	 public String cardNumble;//卡号
    	 public String uesrName;//姓名
    	 public String passWord;//密码
    	 public ServicePackage setPackage;//选择的套餐
    	 public double consumAmount;//消费金额=套餐费+实际消费金额
    	 public double money;//当前余额=充值钱数-consumAmount(消费金额)
    	 public int realTalkTime;//通话时长
    	 public int realSMSCount;//短信条数
    	 public int realFlow;//流量
    	
    	 
    	 public MobileCard() {
    	}
    	 
    
    	public MobileCard(String cardNumble, String uesrName, String passWord,
    			ServicePackage setPackage, double consumAmount, double money,
    			int realTalkTime, int realSMSCount, int realFlow) {
    		super();
    		this.cardNumble = cardNumble;
    		this.uesrName = uesrName;
    		this.passWord = passWord;
    		this.setPackage = setPackage;
    		this.consumAmount = consumAmount;
    		this.money = money;
    		this.realTalkTime = realTalkTime;
    		this.realSMSCount = realSMSCount;
    		this.realFlow = realFlow;
    	}
    
    
    	public void showMeg() {
    		 System.out.println("卡号:" + this.cardNumble + "   用户名:" + this.uesrName + "  当前余额:" + this.money+"元");
    	 }
    	
    }         
    
    
    package info;
    
    import java.util.Random;
    
    /*
     * 使用场景
     * @author 苍何
     */
    public class Scene {
    	public String type;//场景类型
    	public int data;//场景消费数据
    	public String description;//场景描述
    	
    	public Scene() {
    		super();
    	}
    	public Scene(String type, int data, String description) {
    		super();
    		this.type = type;
    		this.data = data;
    		this.description = description;
    	}
    }
    
    
    
    package myPackage;
    
    import info.MobileCard;
    import Service.NetSevice;
    
    /*
     * 网虫套餐
     * @author 苍何
     */
    public class NetPackage extends ServicePackage implements NetSevice {
    	/*
    	 * 上网流量3GB(3*1024M) 
    	 * 资费68元
    	 */
    	public int talkTime = 0;
    	public int smsCount = 0;
    	public int flow=3072;
    	
    	
    	public NetPackage() {
    		super();
    		super.price=68;
    	}
    	
    	public NetPackage(int talkTime, int smsCount, int flow) {
    		super();
    		this.talkTime = talkTime;
    		this.smsCount = smsCount;
    		this.flow = flow;
    	}
    
    	public void showInfo() {
    		System.out.println("网虫套餐:上网流量为3GB/月,资费为68.0元/月。");
    	}
    
    
    	@Override
    	public int netPlay(int flow, MobileCard card)throws Exception {
    		int temp=flow;
    		for(int i=0;i<flow;i++){
    			if(this.flow-card.realFlow>=1){
    				card.realFlow++;
    			}else if(card.money>=0.1){
    				card.realFlow++;
    				//账户余额增加0.1元,消费金额也增加0。1
    				 card.money-=0.1;
    				 card.consumAmount+=0.1;
    			}else{
    				temp=i;
    				throw new Exception("本次上网"+i+"分钟,您的余额不足,请充值后再使用!");
    			}
    		}
    		return temp;
    
    	}
    }
    
    
    package myPackage;
    
    /*
     * 套餐类(父类)
     * @author 苍何
     */
    public abstract class ServicePackage {
    	//套餐月资费
    	public double price;
    	//显示套餐信息
    	public abstract void showInfo();
    }
    
    
    package myPackage;
    
    import info.MobileCard;
    import Service.CallService;
    import Service.NetSevice;
    import Service.SendService;
    
    /*
     * 超人套餐
     * @author 苍何
     */
    public class SuperPackage extends ServicePackage implements CallService,SendService,NetSevice{
    	/*
    	 * 通话时长200分钟
    	 * 上网流量1024MB
    	 * 短信50条
    	 * 资费78元
    	 */
    	public int talkTime=200;
    	public int smsCount=50;
    	public int flow=1024;
    	
    	public SuperPackage(){
    		super();
    		super.price=78;
    	}
    	public SuperPackage(int talkTime, int smsCount, int flow) {
    		super();
    		this.talkTime = talkTime;
    		this.smsCount = smsCount;
    		this.flow = flow;
    	}
    
    
    	public void showInfo() {
    		System.out.println("超人套餐:通话时长为200分钟/月,上网流量为1GB/月,短信条数为50条/月,资费为78.0元/月。");
    	}
    	public int send(int count, MobileCard card) throws Exception{
    		int temp=count;
    		for(int i=0;i<count;i++){
    			if(this.smsCount-card.realSMSCount>=1){
    				card.realSMSCount++;
    			}else if(card.money>=0.1){
    				card.realSMSCount++;
    				//账户余额增加0.1元,消费金额也增加0。1
    				 card.money-=0.1;
    				 card.consumAmount+=0.1;
    			}else{
    				temp=i;
    				throw new Exception("本次发短信"+i+"分钟,您的余额不足,请充值后再使用!");
    			}
    		}
    		return temp;
    		
    	}
    
    	@Override
    	public int call(int miniCount, MobileCard card) throws Exception {
    		int temp=miniCount;
    		for(int i=0;i<miniCount;i++){
    			if(this.talkTime-card.realTalkTime>=1){
    				card.realTalkTime++;
    			}else if(card.money>=0.2){
    				card.realTalkTime++;
    				//账户余额增加0.2元,消费金额也增加0。2
    				 card.money-=0.2;
    				 card.consumAmount+=0.2;
    			}else{
    				temp=i;
    				throw new Exception("本次通话"+i+"分钟,您的余额不足,请充值后再使用!");
    			}
    		}
    		return temp;
    	}
    
    	@Override
    	public int netPlay(int flow, MobileCard card)throws Exception {
    		int temp=flow;
    		for(int i=0;i<flow;i++){
    			if(this.flow-card.realFlow>=1){
    				card.realFlow++;
    			}else if(card.money>=0.1){
    				card.realFlow++;
    				//账户余额增加0.1元,消费金额也增加0。1
    				 card.money-=0.1;
    				 card.consumAmount+=0.1;
    			}else{
    				temp=i;
    				throw new Exception("本次上网"+i+"分钟,您的余额不足,请充值后再使用!");
    			}
    		}
    		return temp;
    		
    	}
    
    	
    	
    }
    
    
    package myPackage;
    
    import info.MobileCard;
    import Service.CallService;
    import Service.SendService;
    
    /*
     * 话唠套餐
     * @author 苍何
     */
    public class TalkPackage extends ServicePackage implements CallService,SendService{
    	/*
    	 * 通话时长500分钟
    	 * 短信30条
    	 * 资费58
    	 */
    	public int talkTime=500;//通话时长
    	public int smsCount=30;//短信
    	public int flow=0;//上网
    	
    	public TalkPackage() {
    		super();
    		super.price=58;
    	}
    	
    	public TalkPackage(int talkTime, int smsCount, int flow) {
    		super();
    		this.talkTime = talkTime;
    		this.smsCount = smsCount;
    		this.flow = flow;
    	}
    
    	public void showInfo() {
    		System.out.println("话唠套餐:通话时长为500分钟/月,短信条数为30条/月,资费为58.0元/月。");
    	}
    	public int send(int count, MobileCard card)throws Exception {
    		int temp=count;
    		for(int i=0;i<count;i++){
    			if(this.smsCount-card.realSMSCount>=1){
    				card.realSMSCount++;
    			}else if(card.money>=0.1){
    				card.realSMSCount++;
    				//账户余额增加0.1元,消费金额也增加0。1
    				 card.money-=0.1;
    				 card.consumAmount+=0.1;
    			}else{
    				temp=i;
    				throw new Exception("本次发短信"+i+"分钟,您的余额不足,请充值后再使用!");
    			}
    		}
    		return temp;
    	}
    	@Override
    	public int call(int miniCount, MobileCard card) throws Exception{
    		int temp=miniCount;
    		for(int i=0;i<miniCount;i++){
    			if(this.talkTime-card.realTalkTime>=1){
    				card.realTalkTime++;
    			}else if(card.money>=0.2){
    				card.realTalkTime++;
    				//账户余额增加0.2元,消费金额也增加0。2
    				 card.money-=0.2;
    				 card.consumAmount+=0.2;
    			}else{
    				temp=i;
    				throw new Exception("本次通话"+i+"分钟,您的余额不足,请充值后再使用!");
    			}
    		}
    		return temp;
    	}
    }
    
    
    package Service;
    
    import info.MobileCard;
    
    /*
     * 打电话(接口)
     * @author 苍何
     */
    public interface CallService {
    	/**
    	 * 套餐内通话免费
    	 * 套餐外通话每分钟0.2元
    	 * 超出电话余额抛出异常提示余额不足
    	 * @param miniCount
    	 * @param card
    	 * @throws Exception 
    	 */
    	public  int call(int miniCount,MobileCard card) throws Exception;
    }
    
    
    package Service;
    
    import info.MobileCard;
    
    /*
     * 上网(接口)
     * @author 苍何
     */
    public interface NetSevice {
    	/**
    	 * 套餐内上网流量免费
    	 * 套餐外每MB0.1元
    	 * 余额不足抛出异常提示余额不足
    	 * @return 
    	 * @throws Exception 
    	 */
    	public int netPlay(int flow,MobileCard card) throws Exception;
    		
    }
    
    
    package Service;
    
    import info.MobileCard;
    
    public interface SendService {
    	/**
    	 * 套餐内短信免费
    	 * 套餐外短信每条1毛
    	 * 余额不足抛出异常
    	 * @author 苍何
    	 * @return 
    	 */
    	public  int send(int count,MobileCard card)throws Exception;
    }
    
    
    package start;
    
    import java.util.Scanner;
    
    /*
     * 管理类
     * @author 苍何
     */
    public class Manage {
    	
    	/**
    	 * 启动(主菜单)
    	 */
    	public void start(){
    		Scanner input = new Scanner(System.in);
    		Util util = new Util();
    		boolean iscontinue = true;// 是否继续
    		do {
    			System.out.println();
    			System.out.println("*************欢迎使用嗖嗖移动业务大厅***************");
    			System.out.println("1.用户登录   2.用户注册   3.使用嗖嗖   4.话费充值  5.资费说明  6.退出系统");
    			System.out.print("请选择:");
    			int option = input.nextInt();
    			switch (option) {
    			case 1:
    				util.login();
    				break;
    			case 2:
    				util.signIn();
    				break;
    			case 3:
    				util.uesSoso();
    				break;
    			case 4:
    				util.addPayMoney();
    				break;
    			case 5:
    				util.ziFei();
    				break;
    			case 6:
    				System.out.println("欢迎您下次继续使用!");
    				iscontinue=false;
    				break;
    			default:
    				System.out.println("输入有误!请重新输入");
    				break;
    			}
    		} while (iscontinue);
    	}
    
    }
    
    
    package start;
    
    public class Start {
    
    	/**
    	 * 启动系统
    	 * @author 苍何
    	 */
    	public static void main(String[] args) {
    		Manage manage=new Manage();
    		manage.start();
    	}
    
    }
    
    
    package start;
    
    import info.ConsumInfo;
    import info.MobileCard;
    import info.Scene;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.io.UnsupportedEncodingException;
    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.Scanner;
    import java.util.Set;
    
    import Service.CallService;
    import Service.NetSevice;
    import Service.SendService;
    
    import myPackage.NetPackage;
    import myPackage.ServicePackage;
    import myPackage.SuperPackage;
    import myPackage.TalkPackage;
    
    /*
     * 业务类(工具类)
     * @author 苍何
     */
    public class Util {
    
    	private static final ServicePackage TalkPackage = null;
    	private static final ServicePackage NetPackage = null;
    	private static final ServicePackage SuperPackage = null;
    	Scanner input = new Scanner(System.in);
    	ServicePackage sp;
    	MobileCard card = new MobileCard();
    	// map集合储存卡号信息,并通过卡号查到对应的姓名等信息
    	Map<String, MobileCard> map = new HashMap<String, MobileCard>();
    	// 所有卡号的消费记录列表
    	Map<String, List<ConsumInfo>> consumInfo = new HashMap<String, List<ConsumInfo>>();
    	// 储存一个卡号的所有消费记录用list集合
    	List<ConsumInfo> list = new ArrayList<ConsumInfo>();
    	// 储存场景列表
    	Map<Integer, Scene> scenes = new HashMap<Integer, Scene>();
    	// 构造6个使用场景
    	Scene scene0 = new Scene("通话", 90, "问候客户,怎知其如此慢,通话90分钟");
    	Scene scene1 = new Scene("通话", 600, "给老婆打电话,问问工作和生活情况,通话600分钟");
    	Scene scene2 = new Scene("短信", 7, "给10086发短信查询相关业务,发送短信7条");
    	Scene scene3 = new Scene("短信", 40, "给妈妈发短信问最近身体状况,发送短信40条");
    	Scene scene4 = new Scene("上网", 2048, "用手机在线观看视频,使用流量2GB");
    	Scene scene5 = new Scene("上网", 1024, "和老婆语音童话,通宵一晚,使用流量1GB");
    
    	/**
    	 * 用户数据初始化
    	 */
    	public void initData() {
    		// 初始化三张手机卡,并添加进集合
    		MobileCard card1 = new MobileCard("13979387057", "大大", "1234",
    				new TalkPackage(), 68, 32, 200, 20, 300);// 话痨套餐
    		MobileCard card2 = new MobileCard("13979387058", "发阿萨德", "12345",
    				new NetPackage(), 78, 22, 100, 10, 3000);// 网虫套餐
    		MobileCard card3 = new MobileCard("13979387059", "当阿萨德", "123456",
    				new SuperPackage(), 88, 12, 200, 20, 500);// 超人套餐
    		map.put("13979387057", card1);
    		map.put("13979387058", card2);
    		map.put("13979387059", card3);
    		// 消费记录初始化
    		ConsumInfo info = new ConsumInfo("13979387057", "通话", 200);
    		list.add(info);
    		consumInfo.put("13979387057", list);
    	}
    
    	/**
    	 * 产生随机的电话号码,返回数组
    	 */
    	public String[] getNum(int count) {// 传入产生几个随机的电话号码
    		String[] nums = new String[9];
    		String number = null;
    		for (int i = 0; i < count; i++) {// count代表循环count次,产生count个随机号码
    			number = "139";// 定义电话号码以139开头
    			Random random = new Random();// 定义random,产生随机数
    			for (int j = 0; j < 8; j++) {
    				// 生成0~9 随机数
    				number += random.nextInt(9);
    			}
    			nums[i] = number;
    		}
    		return nums;
    	}
    
    	/**
    	 * 注册
    	 */
    	public void signIn() {
    		System.out.println("*****可选择的卡号*****");
    		String[] nums = getNum(9);// 产生9个随机号码
    		// 遍历数组
    		for (int i = 0; i < nums.length; i++) {
    			System.out.print((i + 1) + "、" + nums[i] + "\t");
    			// 保证每一行只显示三个号码
    			if ((i + 1) % 3 == 0) {
    				System.out.println();
    			}
    		}
    		System.out.print("请选择卡号(输入1~9的序号):");
    		int cardChose = input.nextInt();
    		if (cardChose < 1 || cardChose > 9) {
    			System.out.println("输入错误!");
    		} else if (!map.containsKey(nums[cardChose - 1])) {
    			card.cardNumble = nums[cardChose - 1];
    		} else {
    			System.out.println("对不起,此号码已被注册,请重新选择");
    		}
    
    		System.out.print("1.话唠套餐  2.网虫套餐  3.超人套餐,  请选择套餐(输入序号):");
    		int packageChose = input.nextInt();
    		System.out.print("请输入姓名:");
    		card.uesrName = input.next();
    		System.out.print("请输入密码:");
    		card.passWord = input.next();
    		System.out.print("请输入预存话费金额:");
    		double pay = input.nextInt();
    		switch (packageChose) {
    		case 1:
    			sp = new TalkPackage();
    			break;
    		case 2:
    			sp = new NetPackage();
    			break;
    		case 3:
    			sp = new SuperPackage();
    			break;
    		default:
    			System.out.println("输入有误!");
    			break;
    		}
    		card.setPackage = sp;
    		card.consumAmount = sp.price;
    		card.money = pay - card.consumAmount;
    
    		// 判断存入的金额是否够叫月租费,如果不够交要循坏让其充值金额。直到金额符合标准方可
    		while (card.money < 0) {
    			System.out.print("您预存的话费金额不足以支付本月固定套餐资费,请重新充值:");
    			pay = input.nextInt();
    			card.money = pay - card.consumAmount;
    		}
    		// 将信息放入集合
    		map.put(card.cardNumble, card);
    		if (map.containsKey(card.cardNumble)) {
    			card.showMeg();
    			sp.showInfo();
    			System.out.println("注册成功!");
    		} else {
    			System.out.println("注册失败,请重新注册!");
    		}
    	}
    
    	/**
    	 * 登陆
    	 */
    	public void login() {
    		System.out.print("请输入手机卡号:");
    		String yourNumber = input.next();
    		System.out.print("请输入密码:");
    		String yourPassWord = input.next();
    		if (map.containsKey(yourNumber)) {
    			if (map.get(yourNumber).passWord.equals(yourPassWord)) {
    				boolean flag = true;// 循环标记
    				do {
    					System.out.println();
    					System.out.println("*****嗖嗖移动用户菜单*****");
    					System.out
    							.print("1.本月账单查询\n2.套餐余量查询\n3.打印消费详单\n4.套餐变更\n5.办理退网\n请选择(输入1~5选择功能,其他键返回上一级):");
    					int functionChose = input.nextInt();
    					switch (functionChose) {
    					case 1:
    						// 本月账单查询
    						showAmountDetail(yourNumber);
    						break;
    					case 2:
    						// 套餐余量查询
    						showRemaiDetail(yourNumber);
    						break;
    					case 3:
    						// 打印消费详单
    						printAmountDetail(yourNumber);
    						break;
    					case 4:
    						// 套餐变更
    						changePackage(yourNumber);
    						break;
    					case 5:
    						// 办理退网
    						delateCard(yourNumber);
    						break;
    					default:
    						// 退出二级菜单
    						flag = false;
    						break;
    					}
    				} while (flag);
    
    			} else {
    				System.out.println("密码输入错误!");
    			}
    
    		} else {
    			System.out.println("对不起,您输入的信息有误,无法登录!");
    		}
    
    	}
    
    	/**
    	 * 当月账单查询
    	 */
    	public void showAmountDetail(String yourNumber) {
    		// 本月账单查询
    		System.out.println();
    		System.out.println("*****本月账单查询******");
    		System.out.println("您的卡号:" + yourNumber + ",当月账单:");
    		System.out.println("套餐资费:" + sp.price + "元");
    		System.out.println("合计:" + dataFormat(map.get(yourNumber).consumAmount)
    				+ "元");
    		System.out.println("账户余额:" + dataFormat(map.get(yourNumber).money)
    				+ "元");
    	}
    
    	/**
    	 * 套餐余量查询
    	 */
    	public void showRemaiDetail(String yourNumber) {
    		System.out.println();
    		System.out.println("*****套餐余量查询******");
    		System.out.println("您的卡号:" + yourNumber + ",套餐内剩余:");
    		StringBuffer meg = new StringBuffer();
    		int remainTalkTime;
    		int remainSmsCount;
    		int remainFlow;
    		if (map.get(yourNumber).setPackage instanceof TalkPackage) {
    			TalkPackage cardPackage = (TalkPackage) (map.get(yourNumber).setPackage);
    			// 若是话痨套餐,若套餐内通话时间比实际通话时间大。则用套餐内通话时间-实际通话时间。否则返回0.
    			remainTalkTime = cardPackage.talkTime > map.get(yourNumber).realTalkTime ? cardPackage.talkTime
    					- card.realTalkTime
    					: 0;
    			meg.append("童话时长:" + remainTalkTime + "分钟\n");
    			remainSmsCount = cardPackage.smsCount > map.get(yourNumber).realSMSCount ? cardPackage.smsCount
    					- map.get(yourNumber).realSMSCount
    					: 0;
    			meg.append("短信条数:" + remainSmsCount + "条\n");
    		} else if (map.get(yourNumber).setPackage instanceof NetPackage) {
    			NetPackage cardPackage = (NetPackage) (map.get(yourNumber).setPackage);
    			remainFlow = cardPackage.flow > map.get(yourNumber).realFlow ? cardPackage.flow
    					- map.get(yourNumber).realFlow
    					: 0;
    			meg.append("上网流量:" + remainFlow + "M\n");
    		} else if (map.get(yourNumber).setPackage instanceof SuperPackage) {
    			SuperPackage cardPackage = (SuperPackage) (map.get(yourNumber).setPackage);
    			remainTalkTime = cardPackage.talkTime > map.get(yourNumber).realTalkTime ? cardPackage.talkTime
    					- map.get(yourNumber).realTalkTime
    					: 0;
    			meg.append("童话时长:" + remainTalkTime + "分钟\n");
    			remainSmsCount = cardPackage.smsCount > map.get(yourNumber).realSMSCount ? cardPackage.smsCount
    					- map.get(yourNumber).realSMSCount
    					: 0;
    			meg.append("短信条数:" + remainSmsCount + "条\n");
    			remainFlow = cardPackage.flow > map.get(yourNumber).realFlow ? cardPackage.flow
    					- map.get(yourNumber).realFlow
    					: 0;
    			meg.append("上网流量:" + remainFlow + "M\n");
    		}
    		System.out.println(meg);
    	}
    
    	/**
    	 * 打印消费详单
    	 */
    	public void printAmountDetail(String yourNumber) {
    		Set<String> numbles = consumInfo.keySet();// 获取所有的消费记录map集合中的号码
    		// 遍历set集合,判断次卡号是否存在消费记录
    		Iterator<String> it = numbles.iterator();
    		// 判断消费列表中是否有此卡的消费记录
    		boolean isExist = false;// false不存在
    		while (it.hasNext()) {
    			String numbleKey = it.next();
    			if (numbleKey.equals(yourNumber)
    					&& consumInfo.get(yourNumber).size() != 0) {
    				isExist = true;
    			}
    		}
    		// 如果存在此卡消费记录,则打印,不存在则说明
    		if (isExist) {
    			StringBuffer brf = new StringBuffer("*******" + yourNumber
    					+ "消费记录*******\n");
    			brf.append("序号\t类型\t数据(通话(分钟)/上网(M)/短信(条)\n");
    			List<ConsumInfo> infos = consumInfo.get(yourNumber);
    			// 遍历消费记录列表
    			for (int i = 0; i < infos.size(); i++) {
    				brf.append((i + 1) + "\t" + infos.get(i).type + "\t"
    						+ infos.get(i).consumDate + "\n");
    			}
    			// 采用字符输出流打印
    			Writer os = null;
    			BufferedWriter bw = null;
    			try {
    				os = new FileWriter("消费记录.txt");
    				bw = new BufferedWriter(os);
    				bw.write(brf.toString());
    				bw.flush();
    				System.out.println("消费记录打印完毕!");
    			} catch (IOException e) {
    				e.printStackTrace();
    			} finally {
    				try {
    					bw.close();
    					os.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		} else {
    			System.out.println("对不起,不存在此卡的消费记录,不能打印!");
    		}
    	}
    
    	/**
    	 * 套餐变更
    	 */
    	public void changePackage(String yourNumber) {
    		boolean isCoreact = true;// 标记,套餐是否正确变更
    		System.out.print("1.话唠套餐  2.网虫套餐  3.超人套餐,  请重新选择套餐(输入序号):");
    		int optionrevie = input.nextInt();
    		switch (optionrevie) {
    		case 1:
    			sp = new TalkPackage();
    			if (map.get(yourNumber).setPackage instanceof TalkPackage) {
    				System.out.println("您已是此套餐,无需变更!");
    			} else {
    				map.get(yourNumber).setPackage = TalkPackage;
    				System.out.println("套餐更改成功!");
    			}
    
    			break;
    		case 2:
    			sp = new NetPackage();
    			if (map.get(yourNumber).setPackage instanceof NetPackage) {
    				System.out.println("您已是此套餐,无需变更!");
    			} else {
    				map.get(yourNumber).setPackage = NetPackage;
    				System.out.println("套餐更改成功!");
    			}
    			break;
    		case 3:
    			sp = new SuperPackage();
    			if (map.get(yourNumber).setPackage instanceof SuperPackage) {
    				System.out.println("您已是此套餐,无需变更!");
    			} else {
    				map.get(yourNumber).setPackage = SuperPackage;
    				System.out.println("套餐更改成功!");
    			}
    
    			break;
    		default:
    			System.out.println("请输入正确的序号!");
    			break;
    		}
    
    	}
    
    	/**
    	 * 办理退网
    	 */
    	public void delateCard(String yourNumber) {
    		// 加个判断防止用户手误输入错误
    		System.out.print("您确定注销此手机号码吗?Y/N:");
    		String chouseyes = input.next();
    		if (chouseyes.equalsIgnoreCase("Y")) {
    			map.remove(yourNumber);
    			System.out.println("您已成功注销该手机号!");
    		}
    	}
    
    	/**
    	 * 使用嗖嗖
    	 */
    	public void uesSoso() {
    		// 将初始化的场景放入map集合中,通过手机号键值对应起来
    		scenes.put(0, scene0);
    		scenes.put(1, scene1);
    		scenes.put(2, scene2);
    		scenes.put(3, scene3);
    		scenes.put(4, scene4);
    		scenes.put(5, scene5);
    
    		System.out.print("请输入手机卡号:");
    		String yourNumber = input.next();
    		System.out.print("请输入密码:");
    		String yourPassWord = input.next();
    		if (map.containsKey(yourNumber)) {
    			if (map.get(yourNumber).passWord.equals(yourPassWord)) {
    				card = map.get(yourNumber);
    				ServicePackage pack = card.setPackage;
    				Random random = new Random();
    				int ranNum = 0;
    				int temp = 0;// 记录每个场景中的实际消费
    				boolean iscontinued = true;// 停下
    				do {
    					ranNum = random.nextInt(6);// 随机产生0-5的随机数
    					Scene scene = scenes.get(ranNum);// 随机产生的一个值对应一个场景scene
    					switch (ranNum) {
    					case 0:
    					case 1:
    						// 判断卡所属的套餐是否有打电话的功能
    						if (pack instanceof CallService) {
    							System.out.println(scene.description);
    							try {
    								temp = ((CallService) pack).call(scene.data,
    										card);
    							} catch (Exception e) {
    								// TODO Auto-generated catch block
    								e.printStackTrace();
    							}
    							// 添加一条消费记录
    							list.add(new ConsumInfo(yourNumber, scene.type,
    									temp));
    							iscontinued = false;
    							break;
    
    						} else {
    							// 如果该卡套餐不支持通话功能,则重新生成随机数选择其他场景
    							continue;
    						}
    
    					case 2:
    					case 3:
    						// 判断卡所属的套餐是否有发短信的功能
    						if (pack instanceof SendService) {
    							System.out.println(scene.description);
    							try {
    								temp = ((SendService) pack).send(scene.data,
    										card);
    							} catch (Exception e) {
    								e.printStackTrace();
    							}
    							// 添加一条消费记录
    							list.add(new ConsumInfo(yourNumber, scene.type,
    									temp));
    							iscontinued = false;
    							break;
    						} else {
    							// 如果该卡套餐不支持发短信功能,则重新生成随机数选择其他场景
    							continue;
    						}
    					case 4:
    					case 5:
    						// 判断卡所属的套餐是否有上网的功能
    						if (pack instanceof NetSevice) {
    							System.out.println(scene.description);
    							try {
    								temp = ((NetSevice) pack).netPlay(scene.data,
    										card);
    							} catch (Exception e) {
    								e.printStackTrace();
    							}
    							// 添加一条消费记录
    							list.add(new ConsumInfo(yourNumber, scene.type,
    									temp));
    							iscontinued = false;
    							break;
    						} else {
    							// 如果该卡套餐不支持上网功能,则重新生成随机数选择其他场景
    							continue;
    						}
    					}
    					System.out.println("添加一条消费记录!");
    					consumInfo.put(yourNumber, list);
    				} while (iscontinued);
    			} else {
    				System.out.println("密码输入错误!");
    			}
    
    		} else {
    			System.out.println("对不起,您输入的信息有误,无法登录!");
    		}
    
    	}
    
    	/**
    	 * 话费充值
    	 */
    	public void addPayMoney() {
    		System.out.print("请输入您要充值的手机号码:");
    		String yourNumber = input.next();
    		System.out.print("请输入您要充值手机号码的密码:");
    		String yourPassWord = input.next();
    		if (map.containsKey(yourNumber)) {
    			if (map.get(yourNumber).passWord.equals(yourPassWord)) {
    				System.out.print("请输入您要充值的金额:");
    				double payMoney = input.nextDouble();
    				map.get(yourNumber).money += payMoney;
    				System.out.println("话费充值成功,您当前话费余额" + map.get(yourNumber).money
    						+ "元");
    			} else {
    				System.out.println("密码输入错误!");
    			}
    		} else {
    			System.out.println("对不起,您输入的信息有误,无法登录!");
    		}
    
    	}
    
    	/**
    	 * 资费说明
    	 */
    	public void ziFei() {
    		System.out.println();
    		InputStream is = null;
    		InputStreamReader isr = null;
    		BufferedReader br = null;
    		try {
    			is = new FileInputStream("资费说明.txt");
    			isr = new InputStreamReader(is, "GBK");
    			br = new BufferedReader(isr);
    			String info =null;
    			while((info=br.readLine())!=null){
    				System.out.println(info);
    			}
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (UnsupportedEncodingException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally{
    			try {
    				br.close();
    				isr.close();
    				is.close();
    			} catch (IOException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    
    	}
    
    	/**
    	 * 数学计算科学计数法转换格式(保留两位小数的方法)
    	 */
    	public String dataFormat(double data) {
    		DecimalFormat format = new DecimalFormat("##.00");
    		return format.format(data);
    	}
    
    	/**
    	 * 两位数相减保留一位小数的方法
    	 */
    	public double sub(double num1, double num2) {
    		return (num1 * 10 - num2 * 10) / 10;
    	}
    }
    
    
    *****资费说明******
    套餐类型:话唠套餐
    通话时长:200分钟 
    短信条数:50条
    月资费:58元
    ——————————————
    套餐类型:网虫套餐
    上网流量:5GB
    月资费:68元
    ——————————————
    套餐类型:超人套餐
    通话时长:200分钟 
    短信条数:100条
    上网流量:1GB
    月资费:78元
    ——————————————
    超出套餐计费:
    通话时长:0.2/分钟
    短信条数:0.1/分钟
    上网流量:0.1/分钟
    
    
    *******13948368681消费记录*******
    序号	类型	数据(通话(分钟)/上网(M)/短信(条)
    1	短信	40
    2	通话	600
    3	通话	0
    
    

    ``欢迎来我的GitHub下载源码,是开源免费的!
    鉴于有些同学找不到我的项目在GitHub位置,直接点击此链接就可以下载,这样下载:https://github.com/freestylefly/SOSO

    在这里插入图片描述

    顺便帮忙点击一波关注哈,万分感谢:
    在这里插入图片描述
    GitHub如果你不熟悉,可以点击这个:
    https://blog.csdn.net/qq_43270074/article/details/83445607


    本文章已同步至我的GitHub仓库:Javastudy,期待您的加入😊

    本文章已同步至苍何的个人博客,可以直接在博客上留言哦😊

    来我的微信公众号玩耍呗😊

    扫码无套路关注我的CSDN博客😊

    展开全文
  • JavaOOP项目 - 嗖嗖移动业务大厅 项目目录结构 服务接口 通讯服务接口 package ServicePackage; //通讯服务 public interface CallService { int call(int minCount); } 短信服务接口 package Service...

    JavaOOP项目 - 嗖嗖移动业务大厅


    项目目录结构

    在这里插入图片描述


    服务接口

    • 通讯服务接口
    package ServicePackage;
    //通讯服务
    public interface CallService {
        int call(int minCount);
    }
    
    • 短信服务接口
    package ServicePackage;
    //短信服务
    public interface SendService {
        int sendMessage(int count);
    }
    
    
    • 网络服务接口
    package ServicePackage;
    //上网服务
    public interface NetService {
        int netPlay(int flow);
    }
    

    套餐类

    • 基本套餐类
    package ServicePackage;
    //套餐类
    public abstract class ServicePackage implements NetService,CallService,SendService{
        private String type;//套餐类型
        private double price;//资费
        private int flow;//流量
        private int talkTime;//通话时长
        private int smsCount;//短信条数
        int Sjs;//随机数
    
        public ServicePackage() { }
    
        public String getType() {
            return type;
        }
    
        void setType(String type) {
            this.type = type;
        }
    
        public double getPrice() {
            return price;
        }
    
        void setPrice(double price) {
            this.price = price;
        }
    
        public int getFlow() {
            return flow;
        }
    
        public void setFlow(int flow) {
            this.flow = flow;
        }
    
        public int getTalkTime() {
            return talkTime;
        }
    
        public void setTalkTime(int talkTime) {
            this.talkTime = talkTime;
        }
    
        public int getSmsCount() {
            return smsCount;
        }
    
        public void setSmsCount(int smsCount) {
            this.smsCount = smsCount;
        }
    
        public int getSjs() {
            return Sjs;
        }
    
        public abstract void showInfo();//资费信息
    
        //生成使用数据
        public void showSjs(){
            Sjs =  (int)((Math.random()*9)+1);
        }
    
        @Override
        public int call(int minCount) {
            showSjs();
            System.out.println("打了个电话,使用了"+Sjs+"分钟通话时长");
            return minCount - Sjs;//返回使用后的剩余数据
        }
    
        @Override
        public int netPlay(int flow) {
            showSjs();
            System.out.println("上了个网,使用了"+Sjs+"G流量");
            return flow - Sjs;
        }
    
        @Override
        public int sendMessage(int count) {
            showSjs();
            System.out.println("发了一手短信,使用了"+Sjs+"条短信");
            return count - Sjs;
        }
    }
    
    • 网虫套餐
    package ServicePackage;
    //网虫套餐
    public class NetPackage extends ServicePackage implements NetService{
    
        public NetPackage(){
            setType("网虫套餐");//套餐类型
            setFlow(40);//流量
            setPrice(19);//费用
        }
    
        @Override
        public void showInfo() {
            System.out.println("套餐类型:" + getType());
            System.out.println("上网流量:" + getFlow() + "G/月");
            System.out.println("月租:" + getPrice() + "元/月");
        }
    
        @Override
        public int netPlay(int flow) {
            showSjs();
            System.out.println("网上冲浪看mm,使用了"+Sjs+"G流量");
            return flow - Sjs;
        }
    }
    
    • 话痨套餐
    package ServicePackage;
    //话痨套餐
    public class TalkPackage extends ServicePackage implements CallService,SendService{
    
        public TalkPackage() {
            setType("话痨套餐");//套餐类型
            setTalkTime(300);//通话时长
            setSmsCount(100);//短信条数
            setPrice(66);//资费信息
        }
    
        @Override
        public void showInfo() {
            System.out.println("套餐类型:" + getType());
            System.out.println("通话时长:" + getTalkTime() + "分钟/月");
            System.out.println("短信条数:" + getSmsCount() + "条/月");
            System.out.println("月租:" + getPrice() + "元/月");
        }
    
        @Override
        public int call(int minCount) {
            showSjs();
            System.out.println("和好老表唠了会嗑,使用了"+Sjs+"分钟通话时间");
            return minCount - Sjs;
        }
    
        @Override
        public int sendMessage(int count) {
            showSjs();
            System.out.println("给MZ发短信,使用了"+Sjs+"条短信");
            return count - Sjs;
        }
    }
    
    • 超人套餐
    package ServicePackage;
    //超人套餐
    public class SuperPackage extends ServicePackage implements CallService,NetService,SendService{
    
        public SuperPackage() {
            setType("超人套餐");//套餐类型
            setTalkTime(500);//通话时长
            setSmsCount(200);//短信条数
            setFlow(80);//流量
            setPrice(199);//资费信息
        }
    
        @Override
        public void showInfo() {
            System.out.println("套餐类型:" + getType());
            System.out.println("通话时长:" + getTalkTime() + "分钟/月");
            System.out.println("短信条数:" + getSmsCount() + "条/月");
            System.out.println("上网流量:" + getFlow() + "G/月");
            System.out.println("月租:" + getPrice() + "元/月");
        }
    
        @Override
        public int call(int minCount) {
            showSjs();
            System.out.println("和好老表唠了会嗑,使用了"+Sjs+"分钟通话时间");
            return minCount - Sjs;
        }
    
        @Override
        public int netPlay(int flow) {
            showSjs();
            System.out.println("网上冲浪看抖音,使用了"+Sjs+"G流量");
            return flow - Sjs;
        }
    
        @Override
        public int sendMessage(int count) {
            showSjs();
            System.out.println("给MZ发短信,使用了"+Sjs+"条短信");
            return count - Sjs;
        }
    }
    

    手机卡类

    package SosoMgr;
    
    import ServicePackage.ServicePackage;
    
    //手机卡,用户
    public class MobileCard {
        private String UserName;//用户名
        private String Password;//用户密码
        private String CardNum;//卡号
        private ServicePackage SerPackage;//套餐
        private double consumAmount;//累计消费金额
        private double money;//余额(可用)
        private int realTalkTime;//语言时长(可用)
        private int realSMSCount;//短信条数(可用)
        private int realFlow;//流量(可用)
    
        public MobileCard() {}
    
        public String getUserName() {
            return UserName;
        }
    
        public void setUserName(String userName) {
            UserName = userName;
        }
    
        public String getPassword() {
            return Password;
        }
    
        public void setPassword(String password) {
            Password = password;
        }
    
        public String getCardNum() {
            return CardNum;
        }
    
        public void setCardNum(String cardNum) {
            CardNum = cardNum;
        }
    
        public ServicePackage getSerPackage() {
            return SerPackage;
        }
    
        public void setSerPackage(ServicePackage serPackage) {
            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;
        }
    }
    

    消费信息

    package SosoMgr;
    
    //消费信息
    public class ConsumInfo {
        private String cardNumber;//卡号
        private String type;//套餐类型
        private String consumData;//消费数据
    
        public ConsumInfo() {}
    
        public ConsumInfo(String cardNumber, String type, String consumData) {
            this.cardNumber = cardNumber;
            this.type = type;
            this.consumData = consumData;
        }
    
        public String getCardNumber() {
            return cardNumber;
        }
    
        public void setCardNumber(String cardNumber) {
            this.cardNumber = cardNumber;
        }
    
        public String getType() {
            return type;
        }
    
        public void setType(String type) {
            this.type = type;
        }
    
        public String getConsumData() {
            return consumData;
        }
    
        public void setConsumData(String consumData) {
            this.consumData = consumData;
        }
    }
    

    注册系统

    package SosoMgr;
    
    import ServicePackage.ServicePackage;
    
    import java.util.*;
    
    //注册系统
    public class RegistSystem {
        private String CardNumber;//所选卡号
        private ServicePackage tcSP;//所选套餐
        private String UserName;//用户名
        private String Password;//用户密码
        private double money;//预存话费
    
        private RegistSystem(){}
    
        static MobileCard RegistSys(List<ServicePackage> SerPack){
            Scanner SR = CardUtil.SR;
            RegistSystem rs = new RegistSystem();
            System.out.println("******************可选择卡号******************");
            List<String> cards = new ArrayList<>(rs.cardSJ());//生成可用卡号
            for(int i = 0;i < cards.size();i++){//遍历可用卡号集
                System.out.print((i+1)+"、"+cards.get(i)+"\t");//输出可用卡号
                if((i+1)%3==0){//每打印三次后换行
                    System.out.print("\n");
                }
            }
            do{
                String Z_card = "[1-9]";
                System.out.print("请选择卡号(输入1-9的序号):");
                String xzCard = SR.next();//选择卡号序号
                if(xzCard.matches(Z_card)){
                    int xzCardI = Integer.parseInt(xzCard);
                    rs.CardNumber = cards.get(xzCardI-1);//获取对应序号的号码
                    break;
                }else{
                    System.out.println("输入错误,无此选项!");
                }
            }while(true);
    
            System.out.println("******************可选套餐******************");
            for(int i = 0;i < SerPack.size();i++){//遍历套餐集
                System.out.print((i+1)+"、"+SerPack.get(i).getType()+"\n");
            }
            do{
                String Z_card = "[1-"+ SerPack.size() +"]";
                System.out.print("请选择套餐:");
                String xzTaoCan = SR.next();//选择套餐
                if(xzTaoCan.matches(Z_card)){
                    int tcI = Integer.parseInt(xzTaoCan);
                    rs.tcSP = SerPack.get(tcI-1);//获取对应序号的套餐
                    break;
                }else{
                    System.out.println("输入错误,无此选项!");
                }
            }while(true);
            System.out.println("-----------------------------------------------");
            do{
                System.out.print("请设置姓名:");
                String Z_Name = "[\\D&&\\S]{2,6}";
                String userName = SR.next();//设置名字
                if(userName.matches(Z_Name)){
                    rs.UserName = userName;//保存名字
                    break;
                }else{
                    System.out.println("名字不符合规范!\n名字中不能含有数字,并大于2个不大于6个字符");
                }
            }while(true);
    
            do{
                System.out.print("请设置密码:");
                String Z_password = "\\S{6,16}";
                String password = SR.next();//设置密码
                if(password.matches(Z_password)){
                    rs.Password = password;//保存密码
                    break;
                }else{
                    System.out.println("密码不符合规范!\n密码要大于6位不大于16位");
                }
            }while(true);
    
            do{
                System.out.print("预存话费金额:");
                String Z_money = "\\d*";
                String S_money = SR.next();//输入存入话费
                if(S_money.matches(Z_money)){
                    double mon = Double.parseDouble(S_money);
                    if(mon > rs.tcSP.getPrice()){//判断存入话费是否大于所选套餐资费
                        rs.money = mon;//保存存入话费
                        break;
                    }else{
                        System.out.println("存入的话费必须大于套餐月租!");
                    }
                }else{
                    System.out.println("输入错误!请输入数字!");
                }
            }while(true);
    
            MobileCard mCard = rs.caedSet();//制作手机卡,并接收制作好的手机卡
            System.out.println("注册成功!\n卡号:"+mCard.getCardNum()
                    +" 、用户名:"+mCard.getUserName()
                    +" 、余额(已扣除月租):"+mCard.getMoney());//打印客户信息
            rs.tcSP.showInfo();//打印套餐信息
            return mCard;//返回制作完成的手机卡
        }
    
        //手机卡制作系统,将数据刻录入手机卡,并返回制作好的手机卡
        private MobileCard caedSet(){
            MobileCard mCard = new MobileCard();//获取初始(空白)手机卡
            mCard.setCardNum(CardNumber);//给手机卡设置号码
            mCard.setUserName(UserName);//给手机卡设置名字
            mCard.setPassword(Password);//给手机卡设置密码
            mCard.setSerPackage(tcSP);//给手机卡设置套餐
            //设置手机卡初始余额,扣除套餐月租
            double price = mCard.getSerPackage().getPrice();//获取手机卡套餐月租
            mCard.setMoney(money-price);//将月租扣除,并设置余额
            mCard.setConsumAmount(price);//记录已扣除费用
            mCard.setRealTalkTime(mCard.getSerPackage().getTalkTime());//设置手机卡初始语音时长
            mCard.setRealSMSCount(mCard.getSerPackage().getSmsCount());//设置手机卡初始短信条数
            mCard.setRealFlow(mCard.getSerPackage().getFlow());//设置手机卡初始流量
    
            //返回用户信息
            return mCard;
        }
    
        //卡号生成系统
        private Set cardSJ(){
            CardUtil cu = CardUtil.cuObject();//工具类对象
            Set<String> Cards = new HashSet<>();//可用卡号集
            for(int a = 0;a<9;a++){//生成9个可用号码
                String cardnum = "199";//初始卡号开头
                for(int i = 0;i<8;i++){//随机生成8位整数
                    cardnum += (int)(Math.random()*10);
                }
                boolean ja = false;
                if(!cu.cards.containsKey(cardnum)){//判断新生成的手机号是否已存在
                    ja = Cards.add(cardnum);//将手机号添加进集合
                }
                if(!ja){//若手机号添加失败,则重新进行添加
                    a--;
                }
            }
            return Cards;
        }
    }
    

    工具类

    package SosoMgr;
    
    import ServicePackage.*;
    import java.io.*;
    import java.util.*;
    
    //工具类
    public class CardUtil {
        public static Scanner SR = new Scanner(System.in);
        List<ServicePackage> SerPack = new ArrayList<>();//套餐集
        Map<String,MobileCard> cards = new HashMap<>();//手机卡集、手机号 对应 手机卡
        Map<String,List<ConsumInfo>> ConsumInfos = new HashMap<>();//消费信息集、手机号 对应 消费信息
        {
            //将套餐存入套餐集
            SerPack.add(new NetPackage());
            SerPack.add(new TalkPackage());
            SerPack.add(new SuperPackage());
        }
        private CardUtil(){}
        private static CardUtil cu = new CardUtil();//工具类对象
        public static CardUtil cuObject(){
            return cu;//返回工具类对象
        }
    
        //注册,将手机卡存入手机卡集
        void registCard(){
            MobileCard mCard = RegistSystem.RegistSys(SerPack);//启动注册系统,传入套餐集,并接收制作好的手机卡
            cards.put(mCard.getCardNum(),mCard);//将手机号与对应的手机卡存入集合
            //给手机号绑定消费记录集
            List<ConsumInfo> consumInfos = new ArrayList<>();//消费信息集
            ConsumInfos.put(mCard.getCardNum(),consumInfos);//将手机号与与消费信息集存入集合
        }
    
        //登录
        MobileCard LoginMenu(String monbileNumber){//传入手机号
            boolean Pcn = cards.containsKey(monbileNumber);//判断手机卡集中是否存在此手机号
            if(Pcn){
                MobileCard card = cards.get(monbileNumber);//获取指定手机号对应的手机卡
                System.out.print("请输入密码:");
                String passwd = SR.next();
                if(card.getPassword().equals(passwd)){
                    return card;//密码输入正确后返回对应手机卡
                }else{
                    System.out.println("密码错误!");
                }
            }else{
                System.out.println("此号码不存在!");
            }
            return null;
        }
    
        //充值话费
        public void InputMoney(String monbileNumber){
            if(cards.containsKey(monbileNumber)){//判断手机卡集中是否存在此手机号
                System.out.print("请输入充值金额:");
                double inputMoney = 0;
                try {
                    Scanner s = new Scanner(System.in);
                    inputMoney = s.nextDouble();
                    //s.close();
                }catch(Exception e){}
                if(inputMoney > 0){
                    MobileCard card = cards.get(monbileNumber);//获取指定手机号对应的手机卡
                    card.setMoney(card.getMoney() + inputMoney);//将充值金额加入余额
                    System.out.println("卡号:"+monbileNumber+"的用户,充值成功!\n余额:"+card.getMoney());
                }else{
                    System.out.println("充值失败!");
                }
            }else{
                System.out.println("此号码不存在!");
            }
        }
    
        //使用嗖嗖
        public void RunSoso(String monbileNumber){
            //调用功能传入剩余用量,使用功能后扣除使用量,返回剩余用量
            boolean Pcn = cards.containsKey(monbileNumber);//判断手机卡集中是否存在此手机号
            if(Pcn){
                MobileCard card = cards.get(monbileNumber);//获取传入手机号对应手机卡
                ServicePackage SerPac = card.getSerPackage();//获取手机卡的套餐
                if(card.getMoney() > 0){//判断是否还有余额
                    //记录消费信息
                    List<ConsumInfo> coninf = ConsumInfos.get(monbileNumber);//获取对应手机号的消费记录集
                    ConsumInfo Con = new ConsumInfo(monbileNumber,SerPac.getType(),"");
                    coninf.add(Con);
                    System.out.println("\t1.拨打电话");
                    System.out.println("\t2.发送短信");
                    System.out.println("\t3.网上冲浪");
                    System.out.println("**********************************");
                    System.out.print("请输入:");
                    String xzSo = SR.next();
                    switch(xzSo){
                        case "1":
                            int TalkTime = SerPac.call(card.getRealTalkTime());//调用通话方法,传入可用通话时长,返回使用后的时长
                            int T = SerPac.getSjs();//消耗的时长
                            if(TalkTime < 0){//判断是否还有剩余用量
                                double M = T * 0.2;//用超出的时长 乘以 每次超出1的费用 得出超出的费用
                                card.setConsumAmount(card.getConsumAmount() + M);//记录消费金额
                                card.setMoney(card.getMoney() - M);//用原有的钱扣除使用的钱,得出余额
                            }
                            card.setRealTalkTime(TalkTime);//更改使用后的时长
    
                            Con.setConsumData("号码:"+Con.getCardNumber()+" 套餐:"+Con.getType()+" 使用了电话功能 使用时长:"+T+"分钟");
                            break;
                        case "2":
                            int SMSCount = SerPac.sendMessage(card.getRealSMSCount());
                            int S = SerPac.getSjs();
                            if(SMSCount < 0){
                                double M = S * 0.1;
                                card.setConsumAmount(card.getConsumAmount() + M);//记录消费金额
                                card.setMoney(card.getMoney() - M);
                            }
                            card.setRealSMSCount(SMSCount);
    
                            Con.setConsumData("号码:"+Con.getCardNumber()+" 套餐:"+Con.getType()+" 使用了短信功能 使用条数:"+S+"条");
                            break;
                        case "3":
                            int Flow = SerPac.netPlay(card.getRealFlow());
                            int F = SerPac.getSjs();
                            if(Flow < 0){
                                double M = F * 3;
                                card.setConsumAmount(card.getConsumAmount() + M);//记录消费金额
                                card.setMoney(card.getMoney() - M);
                            }
                            card.setRealFlow(Flow);
    
                            Con.setConsumData("号码:"+Con.getCardNumber()+" 套餐:"+Con.getType()+" 使用了上网功能 使用流量:"+F+"G");
                            break;
                        default:
                            System.out.println("返回上一级...");
                    }
                }else{
                    System.out.println("余额不足!请尽快缴费!");
                }
            }else{
                System.out.println("此号码不存在!");
            }
        }
    
        //打印消费详单
        public void OutXF(String cardNum){
            List<ConsumInfo> Conl = ConsumInfos.get(cardNum);//获取手机号对应的套餐集
            if(!Conl.isEmpty()){
                File fi = new File("消费记录");
                fi.mkdirs();
                File f = new File(fi , cardNum +"消费记录单.txt");
                try {
                    Writer w = new FileWriter(f);
                    for(ConsumInfo i : Conl){
                        w.write(i.getConsumData()+"\n");
                        w.flush();//强制让输出流输出数据
                    }
                    System.out.println("打印成功,请在消费记录目录下查看详单");
                    w.close();
                } catch (IOException e) {
                    System.out.println("出错,打印失败!");
                }
            }else{
                System.out.println("暂无消费记录,无法打印!");
            }
        }
    
        //资费说明
        public void PriceInfo(){
            System.out.println("\n*****************资费说明*****************");
            for(ServicePackage ser : SerPack){
                ser.showInfo();
                System.out.println("-----------------------");
            }
            System.out.println("超出套餐计费:");
            System.out.println("通话时长:0.2元/分钟");
            System.out.println("短信条数:0.1元/条");
            System.out.println("上网流量:3元/G");
        }
    
        //手机号判断
        public Object[] cardNumIf(){
            Object[] StrBoo = new Object[2];//Object类型数组,储存手机号与布尔值
            String Z_cardNum = "[0-9]{11}";//11位并只能为0-9中的数字
            System.out.print("请输入手机卡号:");
            String cardNum = SR.next();
            if(cardNum.matches(Z_cardNum)){
                StrBoo[0] = cardNum;//存入手机号
                StrBoo[1] = true;
            }else{
                StrBoo[0] = "手机号必须为11位整数";
                StrBoo[1] = false;
            }
            return StrBoo;
        }
    }
    

    业务大厅

    package SosoMgr;
    
    import ServicePackage.ServicePackage;
    
    import java.util.Scanner;
    
    //嗖嗖移动业务大厅
    public class SosoMgr {
        Scanner SR = CardUtil.SR;
        CardUtil cu = CardUtil.cuObject();//工具类对象
        public static void main(String[] args) {
            SosoMgr sm = new SosoMgr();
            boolean FH_SouYie = false;//用于判断是否返回大厅首页
            do{
                FH_SouYie = sm.mainMenu();//启动主菜单
            }while(FH_SouYie);
            sm.SR.close();
        }
    
        //主菜单
        private boolean mainMenu() {
            System.out.println("\n******************欢迎使用嗖嗖移动业务大厅******************");
            System.out.println("\t1.用户登录");
            System.out.println("\t2.用户注册");
            System.out.println("\t3.使用嗖嗖");
            System.out.println("\t4.话费充值");
            System.out.println("\t5.资费说明");
            System.out.println("\t6.退出系统");
            System.out.println("*********************************************************");
            System.out.print("请选择:");
            String SY_XuanZe = SR.next();
            //首页选择
            switch (SY_XuanZe){
                case "1"://用户登录
                    Object[] StrBoo = cu.cardNumIf();
                    String Card_Ts = (String)StrBoo[0];
                    boolean bool = (boolean)StrBoo[1];
                    if(bool){
                        MobileCard card = cu.LoginMenu(Card_Ts);
                        if(card != null){
                            cardMenu(card);
                        }
                    }else{
                        System.out.println(Card_Ts);
                    }
                    return true;
                case "2"://用户注册
                    cu.registCard();//调用工具类中注册系统
                    return true;
                case "3"://使用嗖嗖
                    System.out.println("\n*****************使用嗖嗖*****************");
                    Object[] StrBoo3 = cu.cardNumIf();
                    String Card_Ts3 = (String)StrBoo3[0];
                    boolean bool3 = (boolean)StrBoo3[1];
                    if(bool3){
                        cu.RunSoso(Card_Ts3);
                    }else{
                        System.out.println(Card_Ts3);
                    }
                    return true;
                case "4"://话费充值
                    Object[] StrBoo4 = cu.cardNumIf();
                    String Card_Ts4 = (String)StrBoo4[0];
                    boolean bool4 = (boolean)StrBoo4[1];
                    if(bool4){
                        cu.InputMoney(Card_Ts4);
                    }else{
                        System.out.println(Card_Ts4);
                    }
                    return true;
                case "5"://资费说明
                    cu.PriceInfo();
                    return true;
                case "6"://退出系统
                    System.out.println("感谢您使用嗖嗖移动业务");
                    return false;
                default:
                    System.out.println("无此选项!");
                    return true;
            }
        }
    
        //登录菜单
        private void cardMenu(MobileCard card){
            boolean xzPD = false;
            String cardNum = card.getCardNum();//手机号
            String Uname = card.getUserName();//用户名
            do{
                System.out.println("*******嗖嗖移动用户菜单*******");
                System.out.println("\t1.本月账单查询");
                System.out.println("\t2.套餐余量查询");
                System.out.println("\t3.打印消费详单");
                System.out.println("\t4.套餐更变");
                System.out.println("\t5.办理退网");
                System.out.println("*****************************");
                System.out.print("请选择:");
                String loginXZ = SR.next();
                switch(loginXZ){
                    case "1":
                        System.out.println("******本月账单查询******");
                        System.out.println("卡号:" + cardNum + "的用户:" + Uname + "你好!");
                        System.out.println("当月账单:");
                        System.out.println("\t套餐资费:" + card.getSerPackage().getPrice() + "元");
                        System.out.println("\t累计消费:" + Double.valueOf(String.format("%.1f" , card.getConsumAmount())) + "元");
                        System.out.println("\t账户余额:" + Double.valueOf(String.format("%.1f",card.getMoney())) + "元");
                        xzPD = true;
                        break;
                    case "2":
                        System.out.println("******套餐余量查询******");
                        System.out.println("卡号:" + cardNum + "的用户:" + Uname + "你好!");
                        System.out.println("套餐内剩余(负数代表超出):");
                        System.out.println("\t通话时长:" + card.getRealTalkTime() + "分钟");
                        System.out.println("\t短信条数:" + card.getRealSMSCount() + "条");
                        System.out.println("\t可用流量:" + card.getRealFlow() + "G");
                        xzPD = true;
                        break;
                    case "3":
                        System.out.println("******打印消费详单******");
                        cu.OutXF(cardNum);
                        xzPD = true;
                        break;
                    case "4":
                        System.out.println("******套餐更变******");
                        for(int i = 0;i<cu.SerPack.size();i++){//遍历套餐集
                            System.out.print((i+1)+"、"+cu.SerPack.get(i).getType()+"  ");
                        }
                        System.out.println("\n********************");
                        System.out.print("请选择:");
                        String Z_card = "[1-"+ cu.SerPack.size() +"]";
                        String xzGBs = SR.next();
                        if(xzGBs.matches(Z_card)){
                            int xzGB = Integer.parseInt(xzGBs);
                            String YcardT = card.getSerPackage().getType();//获取现套餐类型
                            ServicePackage SerPac = cu.SerPack.get(xzGB-1);//获取所选套餐
                            if(card.getMoney() >= SerPac.getPrice()){//判断当前手机卡余额,是否可抵扣要更换套餐的月租
                                card.setSerPackage(SerPac);//更改套餐
                                card.setRealTalkTime((card.getRealTalkTime()<0?0:card.getRealTalkTime()) + card.getSerPackage().getTalkTime());//加入更改套餐的语音时长
                                card.setRealSMSCount((card.getRealSMSCount()<0?0:card.getRealSMSCount()) + card.getSerPackage().getSmsCount());//加入更改套餐的短信条数
                                card.setRealFlow((card.getRealFlow()<0?0:card.getRealFlow()) + card.getSerPackage().getFlow());//加入更改套餐的流量
                                card.setMoney(card.getMoney() - card.getSerPackage().getPrice());//扣除更改套餐的月租
                                System.out.println("更变套餐成功!" + YcardT + " --> " + card.getSerPackage().getType());
                            }else{
                                System.out.println("套餐更变失败!可用余额不足以抵扣月租");
                            }
                        }else{
                            System.out.println("无此套餐!");
                        }
                        xzPD = true;
                        break;
                    case "5":
                        System.out.println("******办理退网******");
                        cu.cards.remove(cardNum);//删除指定手机号与对应手机卡
                        System.out.println("卡号:"+cardNum+"的用户,办理退网成功!\n谢谢使用");
                        xzPD = false;
                        break;
                    default:
                        System.out.println("返回上级菜单...");
                        xzPD = false;
                }
            }while(xzPD);
        }
    }
    
    展开全文
  • 嗖嗖移动业务大厅,包含老师的讲解和附加功能,将注册的账号保存为文本格式,下次运行时输入流读入,可以运用上次注册的账号
  • 本项目嗖嗖移动移动大厅提供了嗖嗖移动用户的常用功能,包括新用户注册、本月账单查询、套餐余量查询,打印消费详单,套餐变更,办理退网、话费充值、、查看消费记录、查看资费说明。另外,还可以模拟用户通话、上网...
  • 测试类 业务类 @author Chen HuiHong @author 2020年6月6日{time} @Tel 18073799961 */ public class TestSosoMgr { public static Scanner se = new Scanner(System.in); public static CardUtil cardUtil=...

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    /**

    • 测试类 业务类

    • @author Chen HuiHong

    • @author 2020年6月6日{time}

    • @Tel 18073799961
      */
      public class TestSosoMgr {
      public static Scanner se = new Scanner(System.in);
      public static CardUtil cardUtil=new CardUtil();
      public static MobileCard mobileCard = new MobileCard();
      public static Cousumlnfo cousumlnfo = new Cousumlnfo();
      public static Scene scene = new Scene();
      public static void main(String[] args) {
      // TODO Auto-generated method stub
      start();
      }
      public static void start() {//一级菜单
      do {
      System.out.println("**欢迎使用橙橙 移动业务大厅");
      System.out.println(“1.用户登录 2.用户注册 3.使用橙橙 4.话费充值 5.资费说明 6.退出系统”);

       	System.out.println("请选择--");
       	int num = se.nextInt();
       	
       	switch (num) {
       	case 1:
       		System.out.println("******用户登录*****");
       		System.out.print("请输入手机号:");
       		String number = se.next();
       		System.out.print("请输入密码:");
       		String passWord = se.next();
       		boolean bos = cardUtil.isExistCard(number, passWord);
       		if (bos) {
       			cardMenu(number);
       		}
       		break;
       	case 2:
       		System.out.println("******可选者卡号*****");
       		registCard();
       		 
       		break;
       	case 3:
       		System.out.println("******使用橙橙*****");
       		System.out.print("请输入手机号:");
       		String number2 = se.next();
       		cardUtil.userSoso(number2);
       		break;
       	case 4:
       		System.out.println("******话费充值*****");
       		System.out.print("请输入手机号:");
       		String number3 = se.next();
       		System.out.print("请输入充值金额:");
       		double money = se.nextDouble();
       		cardUtil.chargeMoney(number3,money);
       		break;
       	case 5:
       		System.out.println("******资费说明*****");
       		cardUtil.showDescription();
       		break;
       	case 6:
       		System.out.println("******退出系统*****");
       		System.exit(0);
       		break;
       	default:
       		System.out.println("******输入的选项不正确,请重新输入*****");
       		break;
       	}
       } while (true);
      

      }
      public static void cardMenu(String number) {//二级菜单
      boolean bbs = true;
      do {
      System.out.println(“嗖嗖移动用户菜单”);
      System.out.println(“1.本月账单查询 2.套餐余量查询 3.打印消费详单 4.套餐变跟 5.办理退网 请输入(1~5选择功能,其他键返回上一级)”);

       	int num = se.nextInt();
       	switch (num) {
       	case 1:
       		System.out.println("******本月账单查询*****");
       		cardUtil.showAmountDetail(number);
       		break;
       	case 2:
       		System.out.println("******套餐余量查询*****");
       		cardUtil.showRemainDetail(number);
       		break;
       	case 3:
       		System.out.println("******打印消费详单*****");
       		cardUtil.prinConsumlnfo(number);;
       		break;
       	case 4:
       		System.out.println("******套餐变更*****");
       		System.out.print("请输入要变更的套餐类型:");
       		System.out.print("1.话痨套餐  2.网虫套餐  3.超人套餐\t请选择序号");
       		int packNum = se.nextInt();
       		cardUtil.changingPack(number, packNum);
       		break;
       	case 5:
       		System.out.println("******办理退网*****");
       		cardUtil.delCard(number);
       		break;
       	default:
       		bbs = false;
       		
       	}
       } while (bbs);
       System.out.println("谢谢使用***");
      

      }
      //用户注册流程
      public static void registCard() {
      String[] cardNumber = cardUtil.getNewNumbers(9);
      System.out.println(“请选择卡号(输入1~9的序号)”);
      int num2 =se.nextInt();
      mobileCard.setCardNumber(cardNumber[num2]);
      cardUtil.addCard(mobileCard);
      System.out.print(“1.话痨套餐 2.网虫套餐 3.超人套餐\t请选择序号”);
      int num = se.nextInt();
      ServicePackage talkPackage = cardUtil.createPack(num);
      if (talkPackage instanceof TalkPackage) {
      talkPackage = (TalkPackage)talkPackage;
      mobileCard.setSerPackage(talkPackage);
      System.out.print(“请输入姓名:”);
      String name = se.next();
      mobileCard.setUserName(name);
      System.out.print(“请输入密码:”);
      String passWord= se.next();
      mobileCard.setPassWord(passWord);
      double money;
      System.out.println(“请输入预存话费金额:”);
      do {
      money = se.nextDouble();
      if (money<talkPackage.price) {
      System.out.print("您预存的话费金额不足以支付本月固定套餐费,请重新输入: ");
      }
      } while (money < talkPackage.price);
      cardUtil.chargeMoney(cardNumber[num2], money);
      cousumlnfo.setCardNumber(cardNumber[num2]);

       	//mobileCard.setMoney(money);
       	boolean bos = cardUtil.isExistCard(cardNumber[num2]);
       	if (bos) {
       		System.out.println("注册成功:");
       		mobileCard.setMoney(money-talkPackage.price);
       		cardUtil.printAmountDetail(cardNumber[num2]);
       		talkPackage.shownlfo();
       	}
       }
       if (talkPackage instanceof Netpackage) {
       	talkPackage = (Netpackage)talkPackage;
       	mobileCard.setSerPackage(talkPackage);
       	System.out.print("请输入姓名:");
       	String name = se.next();
       	mobileCard.setUserName(name);
       	System.out.print("请输入密码:");
       	String passWord= se.next();
       	mobileCard.setPassWord(passWord);
       	double money;
       	System.out.println("请输入预存话费金额:");
       	do {
       		money = se.nextDouble();
       		if (money<talkPackage.price) {
       			System.out.print("您预存的话费金额不足以支付本月固定套餐费,请重新输入: ");
       		}
       	} while (money < talkPackage.price);
       	cardUtil.chargeMoney(cardNumber[num2], money);
       	cousumlnfo.setCardNumber(cardNumber[num2]);
       	//mobileCard.setMoney(money);
       	boolean bos = cardUtil.isExistCard(cardNumber[num2]);
       	if (bos) {
       		System.out.println("注册成功:");
       		mobileCard.setMoney(money-talkPackage.price);
       		cardUtil.printAmountDetail(cardNumber[num2]);
       		talkPackage.shownlfo();
       	}
       }
       if (talkPackage instanceof SuperPackage) {
       	talkPackage =(SuperPackage)talkPackage;
       	mobileCard.setSerPackage(talkPackage);
       	System.out.print("请输入姓名:");
       	String name = se.next();
       	mobileCard.setUserName(name);
       	System.out.print("请输入密码:");
       	String passWord= se.next();
       	mobileCard.setPassWord(passWord);
       	double money;
       	System.out.println("请输入预存话费金额:");
       	do {
       		money = se.nextDouble();
       		if (money<talkPackage.price) {
       			System.out.print("您预存的话费金额不足以支付本月固定套餐费,请重新输入: ");
       		}
       	} while (money < talkPackage.price);
       	cardUtil.chargeMoney(cardNumber[num2], money);
       	cousumlnfo.setCardNumber(cardNumber[num2]);
       	//mobileCard.setMoney(money);
       	boolean bos = cardUtil.isExistCard(cardNumber[num2]);
       	if (bos) {
       		System.out.println("注册成功:");
       		mobileCard.setMoney(money-talkPackage.price);
       		cardUtil.printAmountDetail(cardNumber[num2]);
       		talkPackage.shownlfo();
       	}
       }
      

      }

    }

    /**

    • 工具类

    • @author Chen HuiHong

    • @author 2020年6月6日{time}

    • @Tel 18073799961
      */
      public class CardUtil {
      //存放用户列表
      public static Map<String , MobileCard> cards =new HashMap<String, MobileCard>() ;

      //存放卡号消费记录
      public static Map<String , List> consumlnfos = new HashMap<String, List>();

      Scene scene = new Scene();
      Cousumlnfo cousumlnfo = new Cousumlnfo();
      //初始化场景
      public String initScenes(int key) {

       String type = null;
       switch (key) {
       case 1:
       	type = "通话 ,问候客户,谁知其如此难缠,通话90分钟"; 
       	scene.setDescription(type);
       	cousumlnfo.setType("通话");
       	scene.setData(90);
       	scene.setType("通话");
       	break;
       case 2:
       	type = "通话 ,询问妈妈身体状况,本地通话30分钟"; 
       	scene.setDescription(type);
       	cousumlnfo.setType("通话");
       	scene.setData(30);
       	scene.setType("通话");
       	break;
       
       case 3:
       	type = "短信 ,参与环境保护实施方案问卷调查,发送短信5条";
       	scene.setDescription(type);
       	cousumlnfo.setType("短信");
       	scene.setData(5);
       	scene.setType("短信");
       	break;
       case 4:
       	type = "短信 ,通知朋友换手机,发送短信50条"; 
       	scene.setDescription(type);
       	cousumlnfo.setType("短信");
       	scene.setData(50);
       	scene.setType("短信");
       	break;
       case 5:
       	type = "上网 ,和女友微信视屏聊天,使用流量1GB"; 
       	scene.setDescription(type);
       	cousumlnfo.setType("上网");
       	scene.setData(1024);
       	scene.setType("上网");
       	break;
       case 6:
       	type = "上网,晚上手机在线看亮剑,看得过瘾,使用流量2GB,剩下的日子干瞪眼~~"; 
       	scene.setDescription(type);
       	cousumlnfo.setType("上网");
       	scene.setData(1024*2);
       	scene.setType("上网");
       	break;
       }
       return type;
      

      }
      //注册新卡
      public void addCard(MobileCard card) {
      cards.put(card.getCardNumber(),card );
      }

      //话费充值
      public void chargeMoney(String number,double money){
      cards.get(number).setMoney( cards.get(number).getMoney() +money);
      System.out.println(“账户余额:” + cards.get(number).getMoney()
      );

      }

      //使用嗖嗖
      public void userSoso(String number) {
      MobileCard card = cards.get(number);//获取卡号对象
      ServicePackage pack = card.getSerPackage();//获取持卡所属套餐
      Random random = new Random();
      int ranNum = 0;
      int temp = 0;//记录各场景中的实际消费数据
      boolean bos = true;//定位有没有使用成功
      do {

       	ranNum = random.nextInt(6)+1;
       	
       	//Scene scene = new Scene();
       	scene.setType(initScenes(ranNum));
       	switch (ranNum) {
       	case 1:
       		if (pack instanceof CallServixe) {
       			//执行通话方法
       			System.out.println(scene.getDescription());
       			CallServixe callServixe = (CallServixe)pack;
       			try {
       				temp = callServixe.call(scene.getData(), card);
       				
       			} catch (Exception e) {
       				// TODO Auto-generated catch block
       				e.printStackTrace();
       			}
       			//添加一条记录
       			addConsuminfo(number, new Cousumlnfo(number,scene.getType(),temp));
       			bos = false;
       			break;
       		}else {
       			//如果该卡套餐不支持通话功能,则重新生成随机数选择其他场景
       			continue;
       		}
       		
       	case 2:
       		if (pack instanceof CallServixe) {
       			//执行通话方法
       			System.out.println(scene.getDescription());
       			CallServixe callServixe = (CallServixe)pack;
       			try {
       				temp = callServixe.call(scene.getData(), card);
       			} catch (Exception e) {
       				// TODO Auto-generated catch block
       				e.printStackTrace();
       			}
       			//添加一条记录
       			addConsuminfo(number, new Cousumlnfo(number,scene.getType(),temp));
       			bos = false;
       			break;
       		}else {
       			//如果该卡套餐不支持通话功能,则重新生成随机数选择其他场景
       			continue;
       		}
       	
       	case 3:
       		if (pack instanceof SendService) {
       			//执行发短信方法
       			System.out.println(scene.getDescription());
       			SendService sendService = (SendService)pack;
       			try {
       				temp = sendService.send(scene.getData(), card);
       			} catch (Exception e) {
       				// TODO Auto-generated catch block
       				e.printStackTrace();
       			}
       			//添加一条记录
       			addConsuminfo(number, new Cousumlnfo(number,scene.getType(),temp));
       			bos = false;
       			break;
       		}else {
       			//如果该卡套餐不支持短信功能,则重新生成随机数选择其他场景
       			continue;
       		}
       		
       	case 4:
       		if (pack instanceof SendService) {
       			//执行发短信方法
       			System.out.println(scene.getDescription());
       			SendService sendService = (SendService)pack;
       			try {
       				temp = sendService.send(scene.getData(), card);
       			} catch (Exception e) {
       				// TODO Auto-generated catch block
       				e.printStackTrace();
       			}
       			//添加一条记录
       			addConsuminfo(number, new Cousumlnfo(number,scene.getType(),temp));
       			bos = false;
       			break;
       		}else {
       			//如果该卡套餐不支持短信功能,则重新生成随机数选择其他场景
       			continue;
       		} 
       		
       	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) {
       				// TODO Auto-generated catch block
       				e.printStackTrace();
       			}
       			//添加一条记录
       			addConsuminfo(number, new Cousumlnfo(number,scene.getType(),temp));
       			bos = false;
       			break;
       		}else {
       			//如果该卡套餐不支持上网功能,则重新生成随机数选择其他场景
       			continue;
       		} 
       		
       	case 6:
       		if (pack instanceof NetService) {
       			//执行上网方法
       			System.out.println(scene.getDescription());
       			NetService netService = (NetService)pack;
       			try {
       				temp = netService.netPlay(scene.getData(), card);
       			} catch (Exception e) {
       				// TODO Auto-generated catch block
       				e.printStackTrace();
       			}
       			//添加一条记录
       			addConsuminfo(number, new Cousumlnfo(number,scene.getType(),temp));
       			bos = false;
       			break;
       		}else {
       			//如果该卡套餐不支持上网功能,则重新生成随机数选择其他场景
       			continue;
       		} 				
       	}
       } while (bos);
      

      }

      //资费说明
      public void showDescription() {
      System.out.println(“品牌套餐\t\t话痨套餐\t网虫套餐\t超人套餐”);
      System.out.println(“通话时长(分钟)\t500mim\t\t200mim”);
      System.out.println(“上网流量(GB)\t\t3GB\t1GB”);
      System.out.println(“短信条数(条)\t30条\t\t50条”);
      System.out.println(“资费(元/月)\t58\t68\t78”);
      System.err.println(“超出通话:0.2元/分钟”);
      System.err.println(“超出短信:0.1元/条”);
      System.err.println(“超出流量:0.1元/M”);

      }

      //本月账单查询
      public void showAmountDetail(String number) {
      System.out.println("=====================================================");

       System.out.println("您的卡号:" + number );
       	System.out.println("套餐资费:" + cards.get(number).serPackage.price );
       	System.out.println("合计==:" + cards.get(number).serPackage.price 
       			+ cards.get(number).getConsumAmount()  );
       	System.out.println("账户余额:" + cards.get(number).getMoney()
       			);
       System.out.println("=====================================================");
       MobileCard card;//要查询的卡
       card = cards.get(number);//获取集合中一个元素
       StringBuffer meg = new StringBuffer();
       meg.append("您的卡号:" + card.getCardNumber() +"单月账单");
       meg.append("套餐资费:" + card.getSerPackage().getPrice()+"元\n");
       meg.append("合计:" + Common.dataFormat(card.getConsumAmount())+"元\t");
       meg.append("账户余额:" +Common.dataFormat(card.getMoney()) + "元");
      

      System.out.println(meg);

      }

      //套餐余流量查询 instanceof 判断属于哪个套餐的卡
      public void showRemainDetail(String number){
      if (cards.get(number).serPackage instanceof SuperPackage) {
      SuperPackage superPackage = (SuperPackage)cards.get(number).serPackage;
      System.out.println(“您的卡号:” + number );
      System.out.println(“通话时长:” + superPackage.getTalkTime()+“分钟” );
      System.out.println(“短信条数:” + superPackage.getSmsCount()+ “条” );
      System.out.println(“上网流量:” + superPackage.getFlow()/1024 + “,GB”);
      }
      if (cards.get(number).serPackage instanceof Netpackage) {
      Netpackage superPackage = (Netpackage)cards.get(number).serPackage;
      System.out.println(“您的卡号:” + number );
      //System.out.println(“通话时长:” + cards.get(number).realTalkTime );
      //System.out.println(“短信条数:” + superPackage.getSmsCount() );
      System.out.println(“上网流量:” + superPackage.getFlow()/1024 + “,GB”);
      }
      if (cards.get(number).serPackage instanceof TalkPackage) {
      TalkPackage superPackage = (TalkPackage)cards.get(number).serPackage;
      System.out.println(“您的卡号:” + number );
      System.out.println(“通话时长:” + cards.get(number).realTalkTime +“分钟” );
      System.out.println(“短信条数:” + superPackage.getSmsCount() + “条”);
      //System.out.println(“上网流量:” + superPackage.getFlow());
      }

      }

      //打印消费详单
      public void printAmountDetail(String number){
      System.out.println(“卡号:” + number + “用户名:”

      • cards.get(number).userName +",当前余额:" + cards.get(number).getMoney());
        }
        //打印消费信息
        public void prinConsumlnfo(String number) {
        File file = new File(“消费信息.txt”);
        try {
        file.createNewFile();
        } catch (IOException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
        }
        //Writer fileWriter = null;
        try(Writer fileWriter = new FileWriter(number + file);
        ) {
        /*
        * Set numberS= consumlnfos.keySet(); ArrayList< String> arrayList = new
        * ArrayList(); for (String string : numberS) { arrayList.add(string); }
        * List info = new ArrayList();
        /
        //储存指定卡的所有消费记录
        //现有消费列表中是否存在此卡号消费记录,
        boolean isExist =false;
        //String lengString ="";
        List infos= new ArrayList();
        for (String cousumlnfo : consumlnfos.keySet()) {
        if (cousumlnfo.equals(number)) {
        infos=consumlnfos.get(cousumlnfo);
        System.err.println(“我的标记”);
        isExist =true;
        }
        }
        if (isExist) {
        StringBuffer contentBuffer = new StringBuffer("
        *****"+ number +“消费记录” + “******\n”);
        contentBuffer.append(“序号\t类型\t数据\t(通话(分钟)/上网(MB)/短信(条)\n)”);
        for (int i = 0; i < infos.size(); i++) {
        Cousumlnfo cousumlnfo = infos.get(i);
        contentBuffer.append((i+1)+"\t"+cousumlnfo.getType()+
        “\t”+cousumlnfo.getConsumData()+"\n" );
        System.err.println(“我的标记2”);
        }
        fileWriter.write(contentBuffer.toString());
        fileWriter.flush();
        System.out.println(“消费记录打印完毕”);
        }else {
        System.out.println(“对不起,不存在此号码的消费记录,不能打印!”);
        }
        } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        }

      }

      //套餐变更
      public void changingPack(String number,int packNum){
      //如果剩余费用不够支持新的套餐费用
      if (cards.get(number).getMoney() < cards.get(number).getSerPackage().getPrice()) {
      System.out.println(“余额不足,请充值”);
      }else {
      cards.get(number).setRealTalkTime(0);
      cards.get(number).setRealFlow(0);
      cards.get(number).setRealSMSCount(0);
      cards.get(number).setSerPackage(createPack(packNum));
      cards.get(number).setMoney(cards.get(number).getMoney()-cards.get(number).getSerPackage().getPrice());
      System.out.println(“套餐更换完成”);
      cards.get(number).getSerPackage().shownlfo();
      }

      }

      //办理退网
      public void delCard(String number){
      System.out.println(“账户可退余额为:”+cards.get(number).getMoney());
      cards.get(number).setRealTalkTime(0);
      cards.get(number).setRealFlow(0);
      cards.get(number).setRealSMSCount(0);
      System.err.println("====账号删除");
      cards.remove(number);
      consumlnfos.remove(number);

      }

      //根据卡号和密码查看是否注册
      public boolean isExistCard(String number,String passWord) {
      Set numbers = cards.keySet();
      for (String string : numbers) {
      String searString = string;
      if (searString.equals(number) && (cards.get(searString).getPassWord().equals(passWord))) {
      return true;
      }
      }
      return false;
      }

      //根据卡号查验证是否注册
      public Boolean isExistCard(String number){
      Set numbers = cards.keySet();
      for (String string : numbers) {
      String searString = string;
      if (searString.equals(number)) {
      return true;
      }
      }
      return false;
      }

      //随机生成卡号
      public String createNumber() {
      Random random = new Random();
      boolean dis = false;
      String number = “”;
      int temp = 0;
      do {
      dis = false;//标志位重置为false,用于控制外层循环
      do {
      temp = random.nextInt(100000000);
      } while (temp < 10000000);
      //生成之前,前面加 139
      number = “139” + temp;

       	//和现有用户的卡号比较,不能重复
       		Set<String> cardNumder = cards.keySet();
       		for (String cardNumders : cardNumder) {
       			if (number.equals(cardNumders)) {
       				dis =true;
       				break;
       			}
       		}
       } while (dis);
       
       return number;
      

      }

      //生成指定个数卡号列表
      public String[] getNewNumbers(int count) {
      String[] num = new String[count];
      for (int i = 1; i < 10; i++) {
      try {
      num[i-1] = createNumber();
      System.out.print( i+"."+num[i-1] + “\t”);
      } catch (Exception e) {
      System.out.println(“用户注册异常了”);
      e.printStackTrace();
      }
      if (i%3==0) {
      System.out.println();
      }
      }
      return num;
      }

      //添加指定卡号的消费记录
      public void addConsuminfo(String number ,Cousumlnfo info) {
      if (consumlnfos.containsKey(number)) {
      consumlnfos.get(number).add(info);
      }else {
      List cousumlnfo =new ArrayList();
      try {
      cousumlnfo.add(info);
      } catch (Exception e) {
      System.out.println(e.getMessage());

       		e.printStackTrace();
       	}
       	consumlnfos.put(number, cousumlnfo);
       }
      

      }

      //根据用户选择的套餐序号返回套餐对象
      public ServicePackage createPack(int packlf) {
      ServicePackage servicePackage = null;
      switch (packlf) {
      case 1:
      servicePackage = new TalkPackage();
      break;
      case 2:
      servicePackage = new Netpackage();
      break;
      case 3:
      servicePackage = new SuperPackage();
      break;

       default:
       	break;
       }
       return servicePackage;
      

      }
      }
      /**

    • 接口 通话

    • @author Chen HuiHong

    • @author 2020年6月6日{time}

    • @Tel 18073799961
      /
      public interface CallServixe {
      public int call(int minCount,MobileCard card) throws Exception;
      //通话方法 minCount 通话时长 MobileCard 超出套餐内的通话时长需要消费那张卡的余额
      }
      /
      *

    • 上网 接口

    • @author Chen HuiHong

    • @author 2020年6月6日{time}

    • @Tel 18073799961
      /
      public interface NetService {
      public int netPlay(int flaw,MobileCard card) throws Exception;
      //flaw上网流量大小 MobileCard 超出流量后的收费
      }
      /
      *

    • 接口 短信

    • @author Chen HuiHong

    • @author 2020年6月6日{time}

    • @Tel 18073799961
      /
      public interface SendService {
      public int send(int count,MobileCard card) throws Exception;
      //count发送短信条数 MobileCard 超出后的收费
      }
      /
      *

    • 公共类

    • @author Chen HuiHong

    • @author 2020年6月7日{time}

    • @Tel 18073799961
      /
      public class Common {
      public static String dataFormat(double data) {
      DecimalFormat format = new DecimalFormat("#.0");
      return format.format(data);
      }
      public static double sub(double money ,double num) {
      return money-num;
      }
      }
      /
      *

    • 消费记录

    • @author Chen HuiHong

    • @author 2020年6月6日{time}

    • @Tel 18073799961
      */
      public class Cousumlnfo {
      public String cardNumber;//卡号
      public String type;// 消费类型
      public int consumData;//消费数据

      public Cousumlnfo() {
      super();
      }
      public Cousumlnfo(String cardNumber, String type, int consumData) {
      super();
      this.cardNumber = cardNumber;
      this.type = type;
      this.consumData = consumData;
      }
      public String getCardNumber() {
      return cardNumber;
      }
      public void setCardNumber(String cardNumber) {
      this.cardNumber = cardNumber;
      }
      public String getType() {
      return type;
      }
      public void setType(String type) {
      this.type = type;
      }
      public int getConsumData() {
      return consumData;
      }
      public void setConsumData(int consumData) {
      this.consumData = consumData;
      }

    }

    • 移动卡类

    • @author Chen HuiHong

    • @author 2020年6月6日{time}

    • @Tel 18073799961
      */
      public class MobileCard {
      public String cardNumber;//卡号
      public String userName;//用户民
      public String passWord ;//密码
      public double consumAmount;//消费金额
      public double money;//账户余额
      public int realTalkTime ;//当月实际通话时长
      public int realSMSCount ;//当月实际发送短信条数
      public int realFlow;//当月实际上网流量
      public ServicePackage serPackage;//

      public String getCardNumber() {
      return cardNumber;
      }

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

      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 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 ServicePackage getSerPackage() {
      return serPackage;
      }

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

      public void showMeg() {

      }

    }
    /**

    • 网虫套餐

    • @author Chen HuiHong

    • @author 2020年6月6日{time}

    • @Tel 18073799961
      */
      public class Netpackage extends ServicePackage implements NetService{
      public int flow;//上网流量

      public Netpackage() {
      this.flow =3*1024;
      super.price = 68;
      }

      public int getFlow() {
      return flow;
      }

      public void setFlow(int flow) {
      this.flow = flow;

      }

      @Override
      public void shownlfo() {
      // TODO Auto-generated method stub
      super.shownlfo();
      System.out.println(“网虫套餐:”
      + “上网流量为:”+this.flow/1024 +“GB/月。”
      );
      }

      @Override
      //flaw上网流量大小 MobileCard 超出流量后的收费
      public int netPlay(int flaw, MobileCard card) throws Exception {
      int temp = flaw;
      for (int i = 0; i < flaw; i++) {
      if (this.flow- card.getRealFlow() >= 1) {
      //第一种情况:套餐剩余通话时长可以支持1分钟通话
      card.setRealFlow(card.getRealFlow() +1); //实际通话时长加1

       	}else if (card.getMoney() >=0.1) {
       		//第二种情况: 套餐通话时长已用完,账户余额可以支付1分钟通话,使用账户余额支付
       		card.setRealFlow(card.getRealFlow() +1);//实际通话时长加1 
       		//账户余额消费0.1元(一分钟额外电话)
       		card.setMoney(Common.sub(card.getMoney(), 0.1));
       		card.setConsumAmount(card.getConsumAmount() + 0.1);
       	} else {
       		temp = i;
       		throw new Exception("本次已用流量" +i+"M,您的余额不足,请充值后在使用!");
       		
       	}
       }
       this.setFlow(this.getFlow()-temp);
       return temp;
      

      }

    }
    /**

    • 超人套餐

    • @author Chen HuiHong

    • @author 2020年6月6日{time}

    • @Tel 18073799961
      */
      public class SuperPackage extends ServicePackage implements CallServixe,SendService,NetService{
      public int talkTime;//通话时长
      public int smsCount;//短信条数
      public int flow;//流量

      public SuperPackage() {
      this.talkTime = 200;
      this.smsCount = 50;
      this.flow = 1*1024;
      super.price=78;
      }

      public int getFlow() {
      return flow;
      }

      public void setFlow(int flow) {
      this.flow = flow;
      }

      public int getTalkTime() {
      return talkTime;
      }

      public void setTalkTime(int talkTime) {
      this.talkTime = talkTime;
      }

      public int getSmsCount() {
      return smsCount;
      }

      public void setSmsCount(int smsCount) {
      this.smsCount = smsCount;
      }

      @Override
      public void shownlfo() {
      // TODO Auto-generated method stub
      super.shownlfo();
      System.out.println(“超人套餐:通话时长为” + this.talkTime + “分钟/月,”
      + “短信条数为”+this.smsCount
      + “条/月,上网流量为:”+this.flow/1024 +“GB/月。”
      );
      }

      @Override
      //通话方法 minCount 通话时长 MobileCard 超出套餐内的通话时长需要消费那张卡的余额
      public int call(int minCount, MobileCard card) throws Exception {
      int temp = minCount;
      for (int i = 0; i < minCount; i++) {
      if (this.talkTime - card.getRealTalkTime() >= 1) {
      //第一种情况:套餐剩余通话时长可以支持1分钟通话
      card.setRealTalkTime(card.getRealTalkTime() +1); //实际通话时长加1

       	}else if (card.getMoney() >=0.2) {
       		//第二种情况: 套餐通话时长已用完,账户余额可以支付1分钟通话,使用账户余额支付
       		card.setRealTalkTime(card.getRealTalkTime() +1);//实际通话时长加1 
       		//账户余额消费0.2元(一分钟额外电话)
       		card.setMoney(Common.sub(card.getMoney(), 0.2));
       		card.setConsumAmount(card.getConsumAmount() + 0.2);
       	} else {
       		temp = i;
       		throw new Exception("本次已通话" +i+"分钟,您的余额不足,请充值后在使用!");
       		
       	}
       }
       this.setTalkTime(this.getTalkTime()-temp);
       return temp;
      

      }

      @Override
      //count发送短信条数 MobileCard 超出后的收费
      public int send(int count, MobileCard card) throws Exception{
      int temp = count;
      for (int i = 0; i < count; i++) {
      if (this.smsCount- card.getRealSMSCount() >= 1) {
      //第一种情况:套餐剩余通话时长可以支持1分钟通话
      card.setRealSMSCount(card.getRealSMSCount() +1); //实际短信条数加1

       	}else if (card.getMoney() >=0.1) {
       		//第二种情况: 套餐通话时长已用完,账户余额可以支付1条短信,使用账户余额支付
       		card.setRealSMSCount(card.getRealSMSCount() +1);//实际短信条数加1
       		//账户余额消费0.1元(一条额外短信)
       		card.setMoney(Common.sub(card.getMoney(), 0.1));
       		card.setConsumAmount(card.getConsumAmount() + 0.1);
       	} else {
       		temp = i;
       		throw new Exception("本次已发短信" +i+"条,您的余额不足,请充值后在使用!");
       		
       	}
       }
       this.setSmsCount(this.getSmsCount()-temp);
       return temp;
      

      }

      @Override
      //flaw上网流量大小 MobileCard 超出流量后的收费
      public int netPlay(int flaw, MobileCard card) throws Exception {
      int temp = flaw;
      for (int i = 0; i < flaw; i++) {
      if (this.flow- card.getRealFlow() >= 1) {
      //第一种情况:套餐剩余通话时长可以支持1分钟通话
      card.setRealFlow(card.getRealFlow() +1); //实际通话时长加1

       	}else if (card.getMoney() >=0.1) {
       		//第二种情况: 套餐通话时长已用完,账户余额可以支付1分钟通话,使用账户余额支付
       		card.setRealFlow(card.getRealFlow() +1);//实际通话时长加1 
       		//账户余额消费0.1元(一分钟额外电话)
       		card.setMoney(Common.sub(card.getMoney(), 0.1));
       		card.setConsumAmount(card.getConsumAmount() + 0.1);
       	} else {
       		temp = i;
       		throw new Exception("本次已用流量" +i+"M,您的余额不足,请充值后在使用!");
       		
       	}
       }
       this.setFlow(this.getFlow()-temp);
       return temp;
      

      }

    }
    /**

    • 话痨套餐

    • @author Chen HuiHong

    • @author 2020年6月6日{time}

    • @Tel 18073799961
      */
      public class TalkPackage extends ServicePackage implements CallServixe,SendService{
      public int talkTime;//通话时长
      public int smsCount;//短信条数

      public TalkPackage() {
      this.talkTime = 500;
      this.smsCount = 30;
      super.price = 58;
      }

      public int getTalkTime() {
      return talkTime;
      }

      public void setTalkTime(int talkTime) {
      this.talkTime = talkTime;
      }

      public int getSmsCount() {
      return smsCount;
      }

      public void setSmsCount(int smsCount) {
      this.smsCount = smsCount;
      }

      @Override
      public void shownlfo() {
      // TODO Auto-generated method stub
      super.shownlfo();
      System.out.println(“话痨套餐:通话时长为” + this.talkTime + “分钟/月,”
      + “短信条数为”+this.smsCount
      + “条/月。”
      );
      }

      @Override
      //count发送短信条数 MobileCard 超出后的收费
      public int send(int count, MobileCard card) throws Exception{
      int temp = count;
      for (int i = 0; i < count; i++) {
      if (this.smsCount- card.getRealSMSCount() >= 1) {
      //第一种情况:套餐剩余通话时长可以支持1分钟通话
      card.setRealSMSCount(card.getRealSMSCount() +1); //实际短信条数加1

       	}else if (card.getMoney() >=0.1) {
       		//第二种情况: 套餐通话时长已用完,账户余额可以支付1条短信,使用账户余额支付
       		card.setRealSMSCount(card.getRealSMSCount() +1);//实际短信条数加1
       		//账户余额消费0.1元(一条额外短信)
       		card.setMoney(Common.sub(card.getMoney(), 0.1));
       		card.setConsumAmount(card.getConsumAmount() + 0.1);
       	} else {
       		temp = i;
       		throw new Exception("本次已发短信" +i+"条,您的余额不足,请充值后在使用!");
       		
       	}
       }
       this.setSmsCount(this.getSmsCount()-temp);
       return temp;
      

      }

      @Override
      //通话方法 minCount 通话时长 MobileCard 超出套餐内的通话时长需要消费那张卡的余额
      public int call(int minCount, MobileCard card) throws Exception{
      int temp = minCount;
      for (int i = 0; i < minCount; i++) {
      if (this.talkTime - card.getRealTalkTime() >= 1) {
      //第一种情况:套餐剩余通话时长可以支持1分钟通话
      card.setRealTalkTime(card.getRealTalkTime() +1); //实际通话时长加1

       	}else if (card.getMoney() >=0.2) {
       		//第二种情况: 套餐通话时长已用完,账户余额可以支付1分钟通话,使用账户余额支付
       		card.setRealTalkTime(card.getRealTalkTime() +1);//实际通话时长加1 
       		//账户余额消费0.2元(一分钟额外电话)
       		card.setMoney(Common.sub(card.getMoney(), 0.2));
       		card.setConsumAmount(card.getConsumAmount() + 0.2);
       	} else {
       		temp = i;
       		throw new Exception("本次已通话" +i+"分钟,您的余额不足,请充值后在使用!");
       		
       	}
       }
       this.setTalkTime(this.getTalkTime()-temp);
       return temp;
      

      }

    }
    /**

    • 使用场景

    • @author Chen HuiHong

    • @author 2020年6月6日{time}

    • @Tel 18073799961
      */
      public class Scene {
      public String type;//场景类型
      public int data ;//场景消费数据
      public String description;//场景描述

      public Scene() {
      super();
      }
      public Scene(String type, int data, String description) {
      super();
      this.type = type;
      this.data = data;
      this.description = description;
      }
      public String getType() {
      return type;
      }
      public void setType(String type) {
      this.type = type;
      }
      public int getData() {
      return data;
      }
      public void setData(int data) {

       this.data = data;
      

      }
      public String getDescription() {

       return description;
      

      }
      public void setDescription(String description) {

       this.description = description;
      

      }

    }
    /**

    • 抽取得公有属性和方法的接口 )品牌套餐类 父类

    • @author Chen HuiHong

    • @author 2020年6月6日{time}

    • @Tel 18073799961
      */
      public class ServicePackage {
      public double price;//套餐月资费

      public double getPrice() {
      return price;
      }

      public ServicePackage() {
      super();
      }

      public void shownlfo() {//显示信息

      }

    }

    运行效果为
    **欢迎使用橙橙 移动业务大厅
    1.用户登录 2.用户注册 3.使用橙橙 4.话费充值 5.资费说明 6.退出系统
    请选择–
    2
    *可选者卡号
    1.13998648298 2.13951284793 3.13967113639
    4.13994561375 5.13964815529 6.13994190607
    7.13954211280 8.13972749893 9.13916332613
    请选择卡号(输入1~9的序号)
    2
    1.话痨套餐 2.网虫套餐 3.超人套餐 请选择序号2
    请输入姓名:橙橙
    请输入密码:123456
    请输入预存话费金额:
    100
    账户余额:100.0
    注册成功:
    卡号:13967113639用户名:橙橙,当前余额:32.0
    网虫套餐:上网流量为:3GB/月。
    **欢迎使用橙橙 移动业务大厅
    1.用户登录 2.用户注册 3.使用橙橙 4.话费充值 5.资费说明 6.退出系统
    请选择–
    3
    *使用橙橙
    请输入手机号:13967113639
    上网,晚上手机在线看亮剑,看得过瘾,使用流量2GB,剩下的日子干瞪眼~~
    **欢迎使用橙橙 移动业务大厅
    1.用户登录 2.用户注册 3.使用橙橙 4.话费充值 5.资费说明 6.退出系统
    请选择–
    5
    *资费说明
    品牌套餐 话痨套餐 网虫套餐 超人套餐
    通话时长(分钟) 500mim 200mim
    上网流量(GB) 3GB 1GB
    超出通话:0.2元/分钟
    超出短信:0.1元/条
    超出流量:0.1元/M
    短信条数(条) 30条 50条
    资费(元/月) 58 68 78
    **欢迎使用橙橙 移动业务大厅
    1.用户登录 2.用户注册 3.使用橙橙 4.话费充值 5.资费说明 6.退出系统
    请选择–
    1
    *用户登录
    请输入手机号:13967113639
    请输入密码:123456
    嗖嗖移动用户菜单
    1.本月账单查询 2.套餐余量查询 3.打印消费详单 4.套餐变跟 5.办理退网 请输入(1~5选择功能,其他键返回上一级)
    1
    *本月账单查询

    您的卡号:13967113639
    套餐资费:68.0
    合计==:68.00.0
    账户余额:32.0

    您的卡号:13967113639单月账单套餐资费:68.0元
    合计:.0元 账户余额:32.0元
    嗖嗖移动用户菜单
    1.本月账单查询 2.套餐余量查询 3.打印消费详单 4.套餐变跟 5.办理退网 请输入(1~5选择功能,其他键返回上一级)
    2
    套餐余量查询
    您的卡号:13967113639
    上网流量:1,GB
    嗖嗖移动用户菜单
    1.本月账单查询 2.套餐余量查询 3.打印消费详单 4.套餐变跟 5.办理退网 请输入(1~5选择功能,其他键返回上一级)
    3
    打印消费详单
    我的标记
    消费记录打印完毕
    嗖嗖移动用户菜单
    1.本月账单查询 2.套餐余量查询 3.打印消费详单 4.套餐变跟 5.办理退网 请输入(1~5选择功能,其他键返回上一级)
    我的标记2
    4
    套餐变更
    请输入要变更的套餐类型:1.话痨套餐 2.网虫套餐 3.超人套餐 请选择序号3
    余额不足,请充值
    嗖嗖移动用户菜单
    1.本月账单查询 2.套餐余量查询 3.打印消费详单 4.套餐变跟 5.办理退网 请输入(1~5选择功能,其他键返回上一级)
    123
    谢谢使用

    **欢迎使用橙橙 移动业务大厅
    1.用户登录 2.用户注册 3.使用橙橙 4.话费充值 5.资费说明 6.退出系统
    请选择–
    4
    *话费充值
    请输入手机号:13967113639
    请输入充值金额:1000
    账户余额:1032.0
    **欢迎使用橙橙 移动业务大厅
    1.用户登录 2.用户注册 3.使用橙橙 4.话费充值 5.资费说明 6.退出系统
    请选择–
    3
    *使用橙橙
    请输入手机号:13967113639
    上网 ,和女友微信视屏聊天,使用流量1GB
    **欢迎使用橙橙 移动业务大厅
    1.用户登录 2.用户注册 3.使用橙橙 4.话费充值 5.资费说明 6.退出系统
    请选择–
    1
    *用户登录
    请输入手机号:13967113639
    请输入密码:123456
    嗖嗖移动用户菜单
    1.本月账单查询 2.套餐余量查询 3.打印消费详单 4.套餐变跟 5.办理退网 请输入(1~5选择功能,其他键返回上一级)
    4
    *套餐变更
    请输入要变更的套餐类型:1.话痨套餐 2.网虫套餐 3.超人套餐 请选择序号3
    套餐更换完成
    超人套餐:通话时长为200分钟/月,短信条数为50条/月,上网流量为:1GB/月。
    嗖嗖移动用户菜单
    1.本月账单查询 2.套餐余量查询 3.打印消费详单 4.套餐变跟 5.办理退网 请输入(1~5选择功能,其他键返回上一级)
    1
    *本月账单查询

    您的卡号:13967113639
    套餐资费:78.0
    合计==:78.0102.39999999999846
    账户余额:851.5999999999858

    您的卡号:13967113639单月账单套餐资费:78.0元
    合计:102.4元 账户余额:851.6元
    嗖嗖移动用户菜单
    1.本月账单查询 2.套餐余量查询 3.打印消费详单 4.套餐变跟 5.办理退网 请输入(1~5选择功能,其他键返回上一级)
    2
    套餐余量查询
    您的卡号:13967113639
    通话时长:200分钟
    短信条数:50条
    上网流量:1,GB
    嗖嗖移动用户菜单
    1.本月账单查询 2.套餐余量查询 3.打印消费详单 4.套餐变跟 5.办理退网 请输入(1~5选择功能,其他键返回上一级)
    123
    谢谢使用
    **
    **欢迎使用橙橙 移动业务大厅
    1.用户登录 2.用户注册 3.使用橙橙 4.话费充值 5.资费说明 6.退出系统
    请选择–
    3
    *使用橙橙
    请输入手机号:13967113639
    短信 ,参与环境保护实施方案问卷调查,发送短信5条
    **欢迎使用橙橙 移动业务大厅
    1.用户登录 2.用户注册 3.使用橙橙 4.话费充值 5.资费说明 6.退出系统
    请选择–
    3
    *使用橙橙
    请输入手机号:13967113639
    短信 ,通知朋友换手机,发送短信50条
    **欢迎使用橙橙 移动业务大厅
    1.用户登录 2.用户注册 3.使用橙橙 4.话费充值 5.资费说明 6.退出系统
    请选择–
    1
    *用户登录
    请输入手机号:13967113639
    请输入密码:123465
    **欢迎使用橙橙 移动业务大厅
    1.用户登录 2.用户注册 3.使用橙橙 4.话费充值 5.资费说明 6.退出系统
    请选择–
    1
    *用户登录
    请输入手机号:13967113639
    请输入密码:123456
    嗖嗖移动用户菜单
    1.本月账单查询 2.套餐余量查询 3.打印消费详单 4.套餐变跟 5.办理退网 请输入(1~5选择功能,其他键返回上一级)
    5
    *办理退网
    ====账号删除
    账户可退余额为:850.5999999999856
    嗖嗖移动用户菜单
    1.本月账单查询 2.套餐余量查询 3.打印消费详单 4.套餐变跟 5.办理退网 请输入(1~5选择功能,其他键返回上一级)

    展开全文
  • 10.嗖嗖移动业务大厅

    2017-07-27 18:09:00
    3.嗖嗖移动卡套餐 4.手机卡 5.通话服务接口 6.短信服务 7.话唠套餐 8.上网服务 9.网虫套餐 10.超人套餐 11.公共类 12.消费类型 ...

    1.1.消费信息类

     

    2.消费使用场景

    3.嗖嗖移动卡套餐

     4.手机卡

    5.通话服务接口

     

     

     6.短信服务

     

    7.话唠套餐

     

     8.上网服务

     

    9.网虫套餐

     

    10.超人套餐

     

    11.公共类

    12.消费类型

    13.手机卡工具类

     

    14.业务类

     

     

     

    转载于:https://www.cnblogs.com/holly8/p/7246388.html

    展开全文
  • *****************不要问我是谁,请叫我雷锋!************

空空如也

空空如也

1 2 3 4
收藏数 70
精华内容 28
关键字:

嗖嗖移动业务大厅