分享一个嗖嗖移动管理系统

package com.bdqn.sousou;
/**
* 服务接口
* @author 通话接口
*
*/
public interface CallService {
public int call(int minCount,MobileCard card) throws Exception;
}

package com.bdqn.sousou;
import java.awt.SystemTray;
import java.io.*;
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;

/**
* 工具类
*
*
*/
public class CardUtil {
Scanner input = new Scanner(System.in);
// 已注册嗖嗖移动用户列表
public static Map<String, MobileCard> cards = new HashMap<String, MobileCard>();
// 所有卡号的消费记录列表
public static Map<String, List<ConsumInfo>> consumInfos = new HashMap<String, List<ConsumInfo>>();
// 使用场景列表
Map<Integer, Scene> scenes = new HashMap<Integer, Scene>();

Scene scene0 = new Scene("通话", 90, "问候客户，谁知其如此难缠，通话90分钟");
Scene scene1 = new Scene("通话", 30, "询问妈妈身体状况，本地通话30分钟");
Scene scene2 = new Scene("短信", 5, "参与环境保护实施方案问卷调查，发送短信5条");
Scene scene3 = new Scene("短信", 50, "通知朋友手机换号，发送短信50条");
Scene scene4 = new Scene("上网", 1024, "和女朋友用微信视频聊天，使用流量1GB");
Scene scene5 = new Scene("上网", 2 * 1024, "晚上手机在线看韩剧，不留神睡着啦！使用2GB");

/**
* 用户初始化
*/
public void intitScene() {
MobileCard hl = new MobileCard("15815891967", "特斯拉", "123456", new TalkPackage(), 88, 100, 89, 88, 90); // 话唠套餐
MobileCard wc = new MobileCard("12345678910", "特斯拉", "123456", new NetPackage(), 99, 200, 200, 60, 20); // 网虫套餐
MobileCard cr = new MobileCard("13812345678", "特斯拉", "123456", new SuperPackage(), 100, 300, 50, 20, 900); // 超人套餐

CardUtil.cards.put("15815891967", hl); // 添加到集合里
CardUtil.cards.put("12345678910", wc); // 添加到集合里
CardUtil.cards.put("13812345678", cr); // 添加到集合里

ConsumInfo info = new ConsumInfo("12345678910", "电话", 500);

List<ConsumInfo> list = new ArrayList<ConsumInfo>();
list.add(info);
consumInfos.put(info.getNumber(), list);

}

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

/**
* 话费充值
*
* @param number
* @param money
*/
public void chargeMoney(String number, double money) {
cards.get(number).setMoney(cards.get(number).getMoney() + money);
}

/**
* 使用搜搜
*
* @param number
*/
public void userSoso(String number) {

// 添加场景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);

MobileCard card = cards.get(number); // 获取此卡对象
ServicePackage pack = card.getSerPackage(); // 获取此卡所属套餐
Random random = new Random();
int ranNum = 0;
int temp = 0; // 记录个场景中实际消费
do {
ranNum = random.nextInt(6);
Scene scene = scenes.get(ranNum); // 获取该序号所对应的场景
switch (ranNum) {
case 0:
case 1:
// 序号为0或1为通话场景
// 判断该卡所属套餐是否支持通话功能
if (pack instanceof CallService) {
// 执行通话方法
System.out.println(scene.getDescription());
CallService callService = (CallService) pack;
try {
temp = callService.call(scene.getData(), card);
} catch (Exception e) {
e.printStackTrace();
}
// 添加一条消费记录
addConsumInfo(number, new ConsumInfo(number, scene.getType(), temp));
break;
} else {
// 如果该卡套餐不支持通话功能，则重新生成随机数选择其他场景
continue;
}
case 2:
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) {
e.printStackTrace();
}
// 添加一条消费记录
addConsumInfo(number, new ConsumInfo(number, scene.getType(), temp));
break;
} else {
// 如果该卡套餐不支持通话功能，则重新生成随机数选择其他场景
continue;
}
case 4:
case 5:
// 判断该卡所属套餐是否支持上网功能
if (pack instanceof NetPackage) {
// 执行上网方法
System.out.println(scene.getDescription());
NetPackage netPackage = (NetPackage) pack;
try {
temp = netPackage.netPlay(scene.getData(), card);
} catch (Exception e) {
e.printStackTrace();
}
// 添加一条消费记录
addConsumInfo(number, new ConsumInfo(number, scene.getType(), temp));
break;
} else {
// 如果该卡套餐不支持通话功能，则重新生成随机数选择其他场景
continue;
}
}
break;
} while (true);

}

/**
* 资费说明
*/
public void showDescription() {
FileReader fr = null;
BufferedReader br = null;
try {
// 创建一个FileReader对象
fr = new FileReader("F:\\S2\\Javaoop\\OOP项目\\套餐资费说明.txt");
// 创建一个BufferedReader对象
br = new BufferedReader(fr);
// 读取一行数据
String line = null;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
if (br != null) {
br.close();
}
if (fr != null) {
fr.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

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

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

/**
* 打印消费详单
*
* @param number
*/
public void printAmountDetail(String number) {
Writer fileWriter = null;
try {
fileWriter = new FileWriter("F:\\S2\\Javaoop\\OOP项目\\打印.txt");
Set<String> numbers = consumInfos.keySet();
Iterator<String> it = numbers.iterator();
List<ConsumInfo> infos = new ArrayList<ConsumInfo>();
infos = consumInfos.get(number);
// 存储指定卡的所有消费记录
// 现有消费列表中是否存在此卡号的消费记录，是：true 否：false
boolean isExist = false;
while (it.hasNext()) {
String numberKey = it.next();
if (number.equals(numberKey)) {
isExist = true;
} /*
* else{ //如果 isExist = false; }
*/

}

if (isExist) {
StringBuffer content = new StringBuffer("***********" + number + "消费记录************\n");
content.append("序号\t类型\t数据（通话（分钟）/上网（MB）/短信（条））\n");
for (int i = 0; i < infos.size(); i++) {
ConsumInfo info = infos.get(i);
System.out.println((i + 1) + "\n" + info.getType() + "\n" + info.getConsumData() + "\n");
content.append((i + 1) + "\n" + info.getType() + "\n" + info.getConsumData() + "\n");
}
fileWriter.write(content.toString());
fileWriter.flush();
System.out.println("消息记录打印完毕！");
} else {
System.out.println("对不起，不存在此号码的消费记录，不能够打印！");
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

/**
* 套餐变更
*
* @param number
*/
public void chargeingPack(String number) {
System.out.println("1.话唠套餐 2.网虫套餐 3.超人套餐：请选择(序号)：");
int packNum = input.nextInt();
switch (packNum) {
case 1: // 选择变更的套餐为话唠套餐
if (cards.get(number).getSerPackage() instanceof TalkPackage) {
System.out.println("对不起，您已经是该套餐用户，无需换套餐！");
} else {
if (cards.get(number).getMoney() < cards.get(number).getSerPackage().getPrice()) {// 如果剩余费用不够支持新的套餐费用
System.out.println("对不起,您的的余额不足以支付新的套餐本月资费，请充值后再办理业务！");
} else {
cards.get(number).setRealSMSCount(0);
cards.get(number).setRealTakTime(0);
cards.get(number).setRealFlow(0);
cards.get(number).setSerPackage(createPackage(packNum));
System.out.println("套餐更换成功！");
// Common.talkPackage.showInfo();
createPackage(packNum).ShowInfo();
}
}
break;
case 2: // 选择变更的套餐为网虫套餐
if (cards.get(number).getSerPackage() instanceof NetPackage) {
System.out.println("对不起，您已经是该套餐用户，无需换套餐！");
} else {
if (cards.get(number).getMoney() < cards.get(number).getSerPackage().getPrice()) {// 如果剩余费用不够支持新的套餐费用
System.out.println("对不起,您的的余额不足以支付新的套餐本月资费，请充值后再办理业务！");
} else {
cards.get(number).setRealSMSCount(0);
cards.get(number).setRealTakTime(0);
cards.get(number).setRealFlow(0);
cards.get(number).setSerPackage(createPackage(packNum));
System.out.println("套餐更换成功！");
// Common.netPackage.showInfo();
createPackage(packNum).ShowInfo();
}
}
break;
case 3:// 选择变更的套餐为超人套餐
if (cards.get(number).getSerPackage() instanceof SuperPackage) {
System.out.println("对不起，您已经是该套餐用户，无需换套餐！");
} else {
if (cards.get(number).getMoney() < cards.get(number).getSerPackage().getPrice()) {// 如果剩余费用不够支持新的套餐费用
System.out.println("对不起,您的的余额不足以支付新的套餐本月资费，请充值后再办理业务！");
} else {
cards.get(number).setRealSMSCount(0);
cards.get(number).setRealTakTime(0);
cards.get(number).setRealFlow(0);
cards.get(number).setSerPackage(createPackage(packNum));
System.out.println("套餐更换成功！");
// Common.superPackage.showInfo();
createPackage(packNum).ShowInfo();
}
}
break;
}
}

/**
* 办理退网
*
* @param number
*/
public void delCard(String number) {
if (cards.containsKey(number)) {
cards.remove(number); // 移除手机号
System.out.println("卡号:" + number + "办理退网成功！");
System.out.println("谢谢使用！");
} else {
System.out.println("手机号码输入有误！");
}
}

/**
* 根据卡号和密码验证该卡是否验证
*
* @param number
* @param pwd
* @return
*/
public boolean isExistCard(String number, String pwd) {
if (cards.containsKey(number) && (cards.get(number).getPassWord().equals(pwd))) {
return true;
}
System.out.println("登录失败!");
return false;
}

/**
* 根据卡号验证该卡是否验证话费充值
*
* @param number
* @return
*/
public boolean isExistCard(String number) {
Set<String> numbers = cards.keySet();
Iterator<String> iterator = numbers.iterator();
while (iterator.hasNext()) {
String str = iterator.next();
if (str.equals(number))
return true;
}
return false;
}

/**
* 生成随机卡号
*
* @return 随机卡号
*/
public String createNumber() {
Random random = new Random();
// 记录现有用户中是否存在此卡号用户是：true 否：false
boolean isExist = false;
String number = "";
int temp = 0;
do {
isExist = false;// 标志位重置为false,用于控制外重循环
// 生成的随机数是8位，不能小于10000000，否则重新生成
// 回头重写这段代码，执行效率太低
do {
temp = random.nextInt(100000000);
} while (temp < 10000000);
// 生成之前，前面加“139”
number = "139" + temp;
// 和现有用户的卡号比较，不能是重复的
if (cards != null) { // 价格判断否则下方的一句会报空指针异常
Set<String> cardNumbers = cards.keySet();
for (String cardNumber : cardNumbers) {
if (number.equals(cardNumber)) {
isExist = true;
break;
}
}
}
} while (isExist);
return number;
}

/**
* 生成指定个数卡号列表
*
* @param count
* @return
*/
public String[] getNewNumber(int count) {
String[] strs = new String[count];
for (int i = 0; i < count; i++) {
strs[i] = createNumber(); // 通过随机生成给strs[i]赋值
}
return strs;
}

/**
* 添加指定卡号的消费记录
*
* @param number
* @param info
*/
public void addConsumInfo(String number, ConsumInfo info) {
if (consumInfos.containsKey(number)) {
consumInfos.get(number).add(info);
} else {
List<ConsumInfo> list = new ArrayList<ConsumInfo>();
list.add(info);
consumInfos.put(number, list);
}
}

/**
* 根据用户选择的套餐序列返回套餐对象
*
* @param packId
* 套餐序列号
* @return
*/
public ServicePackage createPackage(int packId) {
ServicePackage servicePackage = null;
switch (packId) {
case 1:
servicePackage = new TalkPackage();
break;
case 2:
servicePackage = new NetPackage();
break;
case 3:
servicePackage = new SuperPackage();
break;
default:
break;
}
return servicePackage;
}

}

package com.bdqn.sousou;

import java.text.DecimalFormat;

/**
* 公共类
* @author 公共类
*
*/
public class Common {
/**
* double类型格式化方法
* @param data
* @return
*/
public static String dataFormat(double data) {
DecimalFormat format=new DecimalFormat("#0.00");
return format.format(data);
}
/**
* 类型两数相减
* @param sum1
* @param sum2
* @return
*/
public static double sub(double sum1, double sum2) {
return (sum1*10-sum2*10)/10;
}

}

package com.bdqn.sousou;

/**
* 实体：消费信息类
*
* @author 消费信息
*
*/
public class ConsumInfo {
// 卡号
private String number;
// 消费类型
private String type;
// 短信条数上网(MB)
private int consumData;

public String getNumber() {
return number;
}

public void setNumber(String number) {
this.number = number;
}

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;
}

public ConsumInfo(String number, String type, int note) {
this.number = number;
this.type = type;
this.consumData = note;
}

}

package com.bdqn.sousou;

/**
* 初始化用户信息
*
* @param cardNumber
* 卡号
* @param userName
* 名字
* @param passWord
* 密码
* @param serPackage
* 所属套餐
* @param consumAmout
* 当月消费金额
* @param money
* 账户余额
* @param realTakTime
* 当月实际通话时长
* @param realSMSCount
* 当月实际发送短信条数
* @param realFlow
* 当月实际上网流量
*/
public class MobileCard {
// 卡号
private String cardNumber;
// 用户名
private String userName;
// 密码
private String passWord;
// 所属套餐
private ServicePackage serPackage;
// 当月消费金额
private double consumAmout;
// 账户余额
private double money;
// 当月实际通话时长
private int realTakTime;
// 当月实际发送短信条数
private int realSMSCount;
// 当月实际上网流量
private int realFlow;

public MobileCard() {
}

/**
* 有参构造
*
* @param cardNumber
* 卡号
* @param userName
* 名字
* @param passWord
* 密码
* @param serPackage
* 所属套餐
* @param consumAmout
* 当月消费金额
*/
public MobileCard(String cardNumber, String userName, String passWord, ServicePackage serPackage, double money) {
this.cardNumber = cardNumber;
this.userName = userName;
this.passWord = passWord;
this.serPackage = serPackage;
this.money = money;
}

public MobileCard(String cardNumber, String userName, String passWord, ServicePackage serPackage,
double consumAmout, double money, int realTakTime, int realSMSCount, int realFlow) {

this.cardNumber = cardNumber;
this.userName = userName;
this.passWord = passWord;
this.serPackage = serPackage;
this.consumAmout = consumAmout;
this.money = money;
this.realTakTime = realTakTime;
this.realSMSCount = realSMSCount;
this.realFlow = realFlow;
}

/**
* 卡号
*
* @return
*/
public String getCardNumber() {
return cardNumber;
}

/**
* 卡号
*
* @return
*/
public void setCardNumber(String cardNumber) {
this.cardNumber = cardNumber;
}

/**
* 用户名
*
* @return
*/
public String getUserName() {
return userName;
}

/**
* 用户名
*
* @return
*/
public void setUserName(String userName) {
this.userName = userName;
}

/**
* 密码
*
* @return
*/
public String getPassWord() {
return passWord;
}

/**
* 密码
*
* @return
*/
public void setPassWord(String passWord) {
this.passWord = passWord;
}

/**
* 所属套餐
*
* @return
*/
public ServicePackage getSerPackage() {
return serPackage;
}

/**
* 所属套餐
*
* @return
*/
public void setSerPackage(ServicePackage serPackage) {
this.serPackage = serPackage;
}

/**
* 当月消费金额
*
* @return
*/
public double getConsumAmout() {
return consumAmout;
}

/**
* 当月消费金额
*
* @return
*/
public void setConsumAmout(double consumAmout) {
this.consumAmout = consumAmout;
}

/**
* 账户余额
*
* @return
*/
public double getMoney() {
return money;
}

/**
* 账户余额
*
* @return
*/
public void setMoney(double money) {
this.money = money;
}

/**
* 当月实际通话时长
*
* @return
*/
public int getRealTakTime() {
return realTakTime;
}

/**
* 当月实际通话时长
*
* @return
*/
public void setRealTakTime(int realTakTime) {
this.realTakTime = realTakTime;
}

/**
* 当月实际发送短信条数
*
* @return
*/
public int getRealSMSCount() {
return realSMSCount;
}

/**
* 当月实际发送短信条数
*
* @return
*/
public void setRealSMSCount(int realSMSCount) {
this.realSMSCount = realSMSCount;
}

/**
* 当月实际上网流量
*
* @return
*/
public int getRealFlow() {
return realFlow;
}

/**
* 当月实际上网流量
*
* @param realFlow
* 上网流量
*/
public void setRealFlow(int realFlow) {
this.realFlow = realFlow;
}

/**
* 嗖嗖移动卡信息
*/
public void showMeg() {
System.out.println("卡号:" + this.getCardNumber() + "用户名:" + this.getUserName() + "当前余额:" + this.getMoney() + "元");
this.serPackage.ShowInfo();
}

}

package com.bdqn.sousou;

/**
* 实体：网虫套餐类
*
* @author 网虫套餐
*
*/
public class NetPackage extends ServicePackage implements NetService {
/**
* 上网流量
*/
private int flow;
/**
* 套餐月资费
*/
private double price;

/**
* 无参构造初始化
*/
public NetPackage() {
this.flow = 3;
this.price = 68;
}

/**
* 上网流量
*/
public int getFlow() {
return flow;
}

/**
* 上网流量
*/
public void setFlow(int flow) {
this.flow = flow;
}

/**
* 套餐月资费
*/
public double getPrice() {
return price;
}

/**
* 套餐月资费
*/
public void setPrice(double price) {
this.price = price;
}

/**
* 重写父类方法
*/
@Override
public void ShowInfo() {
System.out.println("网虫套餐：上网流量为：" + this.getFlow() + "GB/月," + "资费为：" + this.getPrice() + "元/月");

}

/**
* @throws Exception
*
*/
public int netPlay(int flow, MobileCard card) throws Exception {
int temp = flow;
for (int i = 0; i < flow; i++) {
if (this.flow - card.getRealFlow() >= 1) {
// 第一种情况：流量剩余够 1 MB
card.setRealFlow(card.getRealFlow() + 1);
} else if (card.getMoney() >= 0.1) {
// 第二种情况：套餐内流量已经用完，剩下话费够支付 1 MB的流量
card.setRealFlow(card.getRealFlow() + 1); // 实际短信数加 1 条
// 账户余额消费0.1元，（1MB流量）
card.setMoney(card.getMoney() - 0.1);
card.setConsumAmout(card.getConsumAmout() + 0.1); // 当月消费金额 +
// 0.1
} else {
temp = i; // 记录使用流量多少MB
throw new Exception("流量已经使用" + i + "MB，您的余额不足，请充值后再使用！");
// System.err.println("流量已经使用" + i + "MB，您的余额不足，请充值后再使用！");
}
}
return temp;
}

}

package com.bdqn.sousou;
/**
* 网络服务接口
* @author 上网接口
*
*/
public interface NetService {
public int netPlay(int flow,MobileCard card) throws Exception;
}

package com.bdqn.sousou;

/**
* 实体：使用场景类
*
* @author 模拟消费
*
*/
public class Scene {
private String type; // 场景类型
private int data; // 场景消费数据
private String description; // 场景描述

public Scene() {
super();
}

public Scene(String type, int data, String description) {
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;
}

}

package com.bdqn.sousou;
/**
* 发送服务接口
* @author 短信接口
*
*/
public interface SendService {
public int send(int count,MobileCard card) throws Exception;

}

package com.bdqn.sousou;
/**
* 实体父类：品牌套餐类
* @author 套餐父类
*
*/
public abstract class ServicePackage {
//月资费
private double price;
/**
* 月资费
* @return 月资费
*/
public double getPrice() {
return price;
}
/**
* 月资费
* @param price 月资费
*/
public void setPrice(double price) {
this.price = price;
}
public abstract void ShowInfo();
}

  package com.bdqn.sousou;

import java.util.Scanner;
/**
* 业务类
* @author Mr.微笑
*
*/
public class SosoMgr {
Scanner input=new Scanner(System.in);
//实例化工具类
CardUtil cardUtil=new CardUtil();
//实例化嗖嗖移动卡类
MobileCard mobileCard=new MobileCard();

ServicePackage service= null;

public static void main(String[] args) {
SosoMgr sosoMgr = new SosoMgr();
sosoMgr.start();
}

/**
* 主菜单
*/
public void start() {
cardUtil.intitScene(); //调用初始化方法
boolean isEsc=true; //循环操作
do {
System.err.println("\t\t\t\t 特斯拉科技有限公司\t\t\t");
System.out.println("*******************欢迎使用嗖嗖移动业务大厅*******************");
System.out.println("1.用户登录 2.用户注册 3.使用嗖嗖 4.话费充值 5.资费说明 6.退出系统");
System.out.print("请选择：");
int key=1;
try {
key = input.nextInt();
} catch (Exception e) {
System.out.println("输入有误，请注册后！重新输入！");
}
switch (key) {
case 1:
cardMenu();
continue;
case 2:
registCard();
continue;
case 3:
System.out.println("执行使用嗖嗖功能");
System.out.println("请输入手机卡号:");
String number=input.next();
cardUtil.userSoso(number); //调用使用soso
continue;
case 4:
moneyRecharge(); //调用话费充值
continue;
case 5:
cardUtil.showDescription();
// System.out.println("");
continue;
case 6:
System.out.println("谢谢使用！");
break;
default:
System.out.println("输入有误，请重新输入！");
continue;
}
} while (isEsc); //判断是否循环
}
/**
* 话费充值方法
*/
public void moneyRecharge() {
System.out.println("请输入手机卡号：");
String strNum=input.next();
boolean is=cardUtil.isExistCard(strNum);
if (is) {
System.out.println("请输入充值余额：");
double strMoney=input.nextDouble();
cardUtil.chargeMoney(strNum,strMoney);
System.out.println("充值成功,当前话费余额为"+CardUtil.cards.get(strNum).getMoney()+"元");
}else {
System.out.println("手机输入有误，请重新输入手机号：");
}
}

/**
* 二级菜单
*/
public void cardMenu() {
System.out.println("请输入手机卡号：");
String numberMoney=input.next();
System.out.println("请输入密码：");
String pwd=input.next();
if (cardUtil.isExistCard(numberMoney,pwd)) {
System.out.println("登录成功");
}else {
return;
}
boolean isEsc=true; //循环操作
do {
System.out.println("******嗖嗖移动用户菜单******");
System.out.println("1.本月账单查询");
System.out.println("2.套餐余量查询");
System.out.println("3.打印消费详单");
System.out.println("4.套餐变更");
System.out.println("5.办理退网");
System.out.print("请选择(输入1~5选择功能,其他键返回上一级)：");
int key=1;
try {
key = input.nextInt();
} catch (Exception e) {
new SosoMgr().start();
}
switch (key) {
case 1:
cardUtil.showAmountDetail(numberMoney); //调用本月账单查询
continue;
case 2:
cardUtil.showRemainDetail(numberMoney); //调用套餐余量查询
continue;
case 3:
cardUtil.printAmountDetail(numberMoney); //调用打印消费详单
continue;
case 4:
cardUtil.chargeingPack(numberMoney);
continue;
case 5:
cardUtil.delCard(numberMoney); //办理退网
continue;
default:
isEsc = false;
new SosoMgr().start();
}
} while (isEsc); // 判断是否循环
}

/**
* 用户注册流程
*/
public void registCard() {
System.out.println("************可选择的卡号************");
//通过超级循环遍历输出卡号
String[] cardNumbers = cardUtil.getNewNumber(9);
for (int i = 0; i <cardNumbers.length; i++) {
System.out.print((i+1)+":"+cardNumbers[i]+"\t");
if (2==i ||5==i||8==i) {
System.out.println();
}
}
System.out.println("请选择卡号(输入1~9的序号)：");
int key = input.nextInt();

if (key >= 1 && key <= 9) {
mobileCard.setCardNumber(cardNumbers[key - 1]);
System.out.println("1.话唠套餐 2.网虫套餐 3.超人套餐，请选择套餐（输入序号）:");
} else {
System.out.print("输入错误！请输入（1~9）的整数:");
}

boolean bol = true;

int packageNum = input.nextInt();
while (bol) {
if (packageNum<=3 && packageNum>=1) {
service= cardUtil.createPackage(packageNum);
mobileCard.setSerPackage(service); //
bol = false;
} else {
System.out.println("输入错误，请重新选择：");
packageNum = input.nextInt();
}
}

System.out.println("请输入姓名：");
String userName = input.next();
System.out.println("请输入密码：");
String passWord = input.next();
System.out.println("请输入预存话费：");
double money=input.nextInt();
while (money<service.getPrice()) {
System.out.println("您预存话费金额不足以支付本月固定套餐资费，请重新充值：");
money=input.nextInt();
}
//当前输入的余额减去月租
mobileCard.setMoney(money-service.getPrice());
//注册新用户添加到集合
MobileCard card=new MobileCard(mobileCard.getCardNumber(), userName, passWord,mobileCard.getSerPackage(),mobileCard.getMoney());
cardUtil.addCard(card);
card.showMeg();
}

}

package com.bdqn.sousou;
/**
* 实体：超人套餐类
* @author 超人
*
*/
public class SuperPackage extends ServicePackage implements CallService, SendService, NetService {
// 通话时长
private int talkTime;
// 短信条数
private int smsCount;
// 上网流量
private int flow;
// 套餐月资费
private double price;

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

/**
* 通话时长
*
* @return
*/
public int getTalkTime() {
return talkTime;
}

/**
* 通话时长
*
* @return
*/
public void setTalkTime(int talkTime) {
this.talkTime = talkTime;
}

/**
* 短信条数
*
* @return
*/
public int getSmsCount() {
return smsCount;
}

/**
* 短信条数
*
* @return
*/
public void setSmsCount(int smsCount) {
this.smsCount = smsCount;
}

/**
* 上网流量
*
* @return
*/
public int getFlow() {
return flow;
}

/**
* 上网流量
*
* @return
*/
public void setFlow(int flow) {
this.flow = flow;
}

/**
* 套餐月资费
*
* @return
*/
public double getPrice() {
return price;
}

/**
* 套餐月资费
*
* @return
*/
public void setPrice(double price) {
this.price = price;
}

/**
* 输出超人套餐信息
*/
@Override
public void ShowInfo() {
System.out.println("超人套餐：通话时长为" + this.getTalkTime() + "分钟/月," + "短信条数为" + this.getSmsCount() + "条/月,上网流量为"
+ this.getFlow() + "GB/月,资费" + this.getPrice() + "/月。");

}

@Override
// 返回通话时长
public int call(int minCount, MobileCard card) throws Exception {
int temp = minCount;
for (int i = 0; i < minCount; i++) {
if (this.talkTime - card.getRealTakTime() >= 1) {
// 第一种情况：套餐剩余通话时长可以支持1分钟通话
card.setRealTakTime(card.getRealTakTime() + 1);
} else if (card.getMoney() >= 0.2) {
// 第二种情况：套餐通话时长已用完，账户余额可以支付1分钟通话，使用账户余额支付
card.setRealTakTime(card.getRealTakTime() + 1); // 实际使用通话时长1分钟
// 账户余额消费0.2元（1分钟额外通话）
card.setMoney(card.getMoney() - 0.2);
card.setConsumAmout(card.getConsumAmout() + 0.2); // 当月消费金额 +
// 0.2
} else {
temp = i; // 记录实际通话分钟数
throw new Exception("本次已经通话" + i + "分钟，您的余额不足，请充值后再使用！");
// System.err.println("本次已经通话" + 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.getRealFlow() >= 1) {
// 第一种情况：流量剩余够 1 MB
card.setRealFlow(card.getRealFlow() + 1);
} else if (card.getMoney() >= 0.1) {
// 第二种情况：套餐内流量已经用完，剩下话费够支付 1 MB的流量
card.setRealFlow(card.getRealFlow() + 1); // 实际短信数加 1 条
// 账户余额消费0.1元，（1MB流量）
card.setMoney(card.getMoney() - 0.1);
card.setConsumAmout(card.getConsumAmout() + 0.1); // 当月消费金额 +
// 0.1
} else {
temp = i; // 记录使用流量多少MB
throw new Exception("流量已经使用" + i + "MB，您的余额不足，请充值后再使用！");
}
}
return temp;
}

@Override
// 返回实际发送短信条数
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) {
// 第一种情况：套餐剩余短信数能够发送一个短信
card.setRealSMSCount(card.getRealSMSCount() + 1);
} else if (card.getMoney() >= 0.1) {
// 第二种情况：套餐内短信已经用完，剩下话费能够允许发一条短信
card.setRealSMSCount(card.getRealSMSCount() + 1); // 实际短信数加 1 条
// 账户余额消费0.1元，（一条短信）
card.setMoney(card.getMoney() - 0.1);
card.setConsumAmout(card.getConsumAmout() + 0.1); // 当月消费金额 +
// 0.1
} else {
temp = i; // 记录发短信条数
throw new Exception("短信已经发送" + i + "条，您的余额不足，请充值后再使用！");
}
}
return temp;
}

}

package com.bdqn.sousou;

/**
* 实体：话唠套餐类
* @author 话唠
*
*/
public class TalkPackage extends ServicePackage implements CallService,SendService {
//通话时长
private int talkTime;
//短信条数
private int smsCount;
//套餐月资费
private double price;

public TalkPackage() {
this.talkTime = 500;
this.smsCount = 30;
this.price=58;
}
/**
* 通话时长
* @return
*/
public int getTalkTime() {
return talkTime;
}
/**
* 通话时长
* @return
*/
public void setTalkTime(int talkTime) {
this.talkTime = talkTime;
}
/**
* 短信条数
* @return
*/
public int getSmsCount() {
return smsCount;
}
/**
* 短信条数
* @return
*/
public void setSmsCount(int smsCount) {
this.smsCount = smsCount;
}
/**
* 套餐月资费
* @return
*/
public double getPrice() {
return price;
}
/**
* 套餐月资费
* @return
*/
public void setPrice(double price) {
this.price = price;
}
/**
* 输出话唠套餐信息
*/
@Override
public void ShowInfo() {
System.out.println("话唠套餐：通话时长为：" + this.getTalkTime() + "分钟/月,短信条数为："
+ this.getSmsCount() + "条/月,资费为："
+ this.getPrice() + "元/月" );
}

@Override
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){
card.setRealSMSCount(card.getRealSMSCount() + 1);
}else if(card.getMoney() >= 0.1){
card.setRealSMSCount(card.getRealSMSCount() + 1); //实际短信数加 1 条
//账户余额消费0.1元，（一条短信）
card.setMoney(card.getMoney() - 0.1);
card.setConsumAmout(card.getConsumAmout() + 0.1); //当月消费金额 + 0.1
}else{
temp = i; //记录发短信条数
throw new Exception("短信已经发送" + i + "条，您的余额不足，请充值后再使用！");
//System.err.println("短信已经发送" + i + "条，您的余额不足，请充值后再使用！");
}
}
return temp;
}
@Override
public int call(int minCount, MobileCard card) throws Exception{
int temp=minCount;
for (int i = 0; i < minCount; i++) {
if (this.talkTime-card.getRealTakTime()>=1) {
card.setRealTakTime(card.getRealTakTime()+1); //实际通话数据加1
}else if (card.getMoney()>=0.2) {
card.setRealTakTime(card.getRealTakTime()+1); // 实际通话时长1分钟
//账户余额消费0.2元（1分钟额外通话）
card.setMoney(Common.sub(card.getMoney(),0.2));
card.setConsumAmout(card.getConsumAmout()+0.2);
}else {
temp=i;
throw new Exception("本次通话"+i+"分钟，您的余额不足，请充值后再使用！");
}
}
return temp;
}

}

package com.bdqn.sousou;

public class Test {

public static void main(String[] args) {
SosoMgr so=new SosoMgr();
so.start();
}

}

分享一个嗖嗖移动管理系统

猜你喜欢