项目开发报告
课程名称： java项目实践
2023年 10 月 22 日
目录
4.1.2业务套餐类（ServicePackage）... 10
第一章 系统的可行性分析报告
1.1 引言
1.1.1 课题题目。
本次课程设计的课题为：移动大厅业务系统
1.1.2 设计目的和意义
1、设计目的
移动大厅业务系统的设计目的是提供一个便捷、高效和个性化的移动服务平台，以满足用户在移动大厅办理业务的需求。该系统旨在简化用户在移动大厅的办理流程，提供办理业务、查询信息等功能，以提升用户体验和效率。通过该系统，用户可以通过移动设备随时随地办理各类业务，包括充值、缴费、办理手机号码业务、查询账单、办理套餐变更等。同时，该系统还可以帮助运营商收集用户行为数据，提供个性化的推荐和定制服务，从而提高用户黏性和满意度。总之，移动大厅业务系统的设计目的是为了提供更便捷、快速和个性化的移动服务，以满足用户的需求。
2、设计意义
移动大厅业务系统的设计意义在于提升用户的移动服务体验，并提高运营商的效率和服务质量。通过该系统，用户可以通过移动设备随时随地办理各类业务，无需亲自前往实体大厅，从而节省时间和精力。系统的功能可以减少用户等待时间，提高办理效率。此外，系统还提供了查询信息、办理业务、缴费等功能，使用户可以方便地获取所需的移动服务。同时，系统还能够收集用户行为数据，为用户提供个性化的推荐和定制服务，增强用户的满意度和忠诚度。
对于运营商来说，移动大厅业务系统可以减轻实体大厅的压力，降低人力成本，并提高业务处理的效率和准确性。系统可以自动化处理一部分常规业务，减少人工干预，从而减少出错的《《《《《性。此外，系统还提供了数据统计和分析功能，帮助运营商了解用户需求、优化服务，并进行精细化的运营管理。
综上所述，移动大厅业务系统的设计意义在于提升用户体验、提高运营商效率，并支持个性化服务和精细化运营管理。
1.2 要求和目标
1.2.1 基本要求
1、性能
移动大厅业务系统是一个模拟移动营业厅一些常用在线功能的手机用户管理系统。
2、功能
具体功能如下：用户注册、用户登陆、话费充值、查询账单、打印账单、使用场景、资费说明、办理退网等功能。
第二章 需求分析说明书
2.1 引言
2.1.1 编写目的
移动大厅业务系统的编写目的是为了实现系统设计目的所述的功能和特性。具体来说，编写该系统的目的包括但不限于：
- 提供便捷的移动服务：通过移动大厅业务系统，用户可以方便地使用移动设备进行各类业务办理，无需到实体营业厅排队等待，节省了时间和精力。
- 提高办理效率：该系统简化了用户在移动大厅的办理流程，通过优化界面设计和流程，使用户可以更快速地完成业务办理，提高了办理效率。
- 提供个性化服务：移动大厅业务系统可以根据用户的行为数据和偏好，提供个性化的推荐和定制服务。例如，根据用户的通信消费情况，系统可以推荐适合用户的套餐和优惠活动，提供更加个性化的服务体验。
- 收集用户行为数据：该系统可以收集用户在移动大厅的行为数据，例如办理的业务类型、频率等，用于运营商的市场调研和决策分析。这些数据可以帮助运营商更好地了解用户需求，优化产品和服务策略。
2.2 规划程序结构图
|
图2.2 移动大厅业务系统的系统类图 |
第三章 程序设计描述
3.1 创建类
3.1.1手机卡类（MobileCard）
代码：
| package BaiXu.entity; import BaiXu.service.ServicePackage; /** * 嗖嗖移动卡 */ public class MobileCard { private String cardNumber; //卡号 private String userName; //用户名 private String passWord; //密码 private ServicePackage serPackage; //所属套餐 private double consumAmount; //当月消费金额 private double money; //账户余额 private int realTalkTime; //当月实际通话时长 private int realSMSCount; //当月实际发送短信条数 private int realFlow; //当月实际上网流量 public MobileCard(String cardNumber, String userName, String passWord, ServicePackage serPackage, double consumAmount) { this.cardNumber = cardNumber; this.userName = userName; this.passWord = passWord; this.serPackage = serPackage; this.consumAmount = consumAmount; this.money = money; this.realTalkTime = realTalkTime; this.realSMSCount = realSMSCount; this.realFlow = realFlow; } public MobileCard() { } 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 ServicePackage getSerPackage() { return serPackage; } public void setSerPackage(ServicePackage serPackage) { this.serPackage = serPackage; } public double getConsumAmount() { return consumAmount; } public void setConsumAmount(double consumAmount) { this.consumAmount = consumAmount; } public double getMoney() { return money; } public void setMoney(double money) { this.money = money; } public int getRealTalkTime() { return realTalkTime; } public void setRealTalkTime(int realTalkTime) { this.realTalkTime = realTalkTime; } public int getRealSMSCount() { return realSMSCount; } public void setRealSMSCount(int realSMSCount) { this.realSMSCount = realSMSCount; } public int getRealFlow() { return realFlow; } public void setRealFlow(int realFlow) { this.realFlow = realFlow; } //展示卡号信息 public void showMeg() { System.out.println(‘卡号： + this.cardNumber + ‘，用户名： + this.userName + ‘，当前余额： + this.money + ‘元); this.serPackage.showInfo(); } } |
分析：
这段代码定义了一个名为MobileCard的实体类，用于表示嗖嗖移动卡。该类包含了以下属性和方法：
- cardNumber（卡号）：表示移动卡的卡号。
- userName（用户名）：表示移动卡的用户名。
- passWord（密码）：表示移动卡的密码。
- serPackage（所属套餐）：表示移动卡所使用的业务套餐，类型为ServicePackage。
- consumAmount（当月消费金额）：表示移动卡当月的消费金额。
- money（账户余额）：表示移动卡的账户余额。
- realTalkTime（当月实际通话时长）：表示移动卡当月的实际通话时长。
- realSMSCount（当月实际发送短信条数）：表示移动卡当月的实际发送短信条数。
- realFlow（当月实际上网流量）：表示移动卡当月的实际上网流量。
MobileCard类具有以下特点：
- 构造方法：类中定义了两个构造方法，一个是带有各个属性参数的构造方法，用于初始化移动卡的属性；另一个是无参构造方法。
- getter和setter方法：用于访问和设置移动卡的各个属性。
- showMeg()方法：用于展示移动卡的信息，包括卡号、用户名、当前余额等。在该方法中，还调用了serPackage对象的showInfo()方法，以展示套餐的详细信息。
`代码中的serPackage属性是一个ServicePackage类型的对象，表示移动卡所使用的业务套餐。在实例化MobileCard对象时，需要将对应的ServicePackage对象传入构造方法进行初始化。
根据代码中的逻辑，可以通过MobileCard对象调用showMeg()方法来展示移动卡的信息，包括套餐的详细信息。
3.1.2业务套餐类（ServicePackage）
代码：
| package BaiXu.service; /** * 业务套餐 抽象类 包含网虫套餐，话痨套餐，超人套餐 */ public abstract class ServicePackage { private double price; //套餐月资费 public ServicePackage(double price) { this.price = price; } public ServicePackage() { } public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } //展示套餐信息 public abstract void showInfo(); } |
分析：
这段代码是一个名为ServicePackage的抽象类的定义。这个类是一个业务套餐的抽象表示，它包含了一个表示套餐月资费的属性price。
ServicePackage类具有以下特点：
- 构造方法：类中定义了两个构造方法，一个是带有price参数的构造方法，用于初始化套餐月资费；另一个是无参构造方法。
- price属性：表示套餐的月费用，使用private修饰，只能在类内部访问。通过getter和setter方法来访问和设置该属性的值。
- showInfo()方法：这是一个抽象方法，没有具体的实现，在子类中需要实现该方法。该方法用于展示套餐的详细信息。
由于ServicePackage是一个抽象类，不能直接实例化，而是需要通过具体的套餐子类来实现和使用。在后面的代码中有名为网虫套餐、话痨套餐和超人套餐的具体套餐类，它们会继承ServicePackage类并实现各自的showInfo()方法，以展示具体套餐的信息。在提供具体实现之前，抽象类本身并不能完成展示套餐信息的功能，它只提供了一个通用的套餐框架，具体的展示逻辑需要在子类中完成。
3.1.3消费信息类（ConsumInfo）
代码：
| package BaiXu.entity; /** * 消费记录 */ public class ConsumInfo { private String cardNumber; //卡号 private String type; //消费类型 private int 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; } public ConsumInfo() { } public ConsumInfo(String cardNumber, String type, int consumData) { this.cardNumber = cardNumber; this.type = type; this.consumData = consumData; } } |
分析：
这是一个名为ConsumInfo的Java类，用于表示消费记录。它具有以下属性：
- cardNumber（卡号）：表示消费记录所关联的卡号，类型为String。
- type（消费类型）：表示消费的类型，类型为String。
- consumData（消费数据）：表示消费的数据，类型为int。
该类还提供了相应的getter和setter方法，用于访问和设置这些属性的值。此外，还提供了两个构造函数，一个无参数的构造函数和一个带有卡号、消费类型和消费数据参数的构造函数。
3.1.4使用场景类（Scene）
代码：
| package BaiXu.entity; /** * 使用场景 */ public class Scene { private String type; //场景类型 private int data; //场景消费数据 private String description; //场景描述 public Scene(String type, int data, String description) { this.type = type; this.data = data; this.description = description; } public Scene() { } 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; } } |
分析：
这段代码表示一个场景（Scene）的实体。
类中包含以下属性：
- type（场景类型）：表示场景的类型。
- data（场景消费数据）：表示场景的消费数据。
- description（场景描述）：表示场景的描述信息。
类中还包含了构造方法和属性的Getter和Setter方法，用于创建场景对象和设置/获取属性的值。
3.2创建接口
3.2.1通话接口(CallService)
代码：
| package service; import entity.MobileCard; //通话服务 public interface CallService { /** * 通话 * @param minCount 通话分钟数 * @param card 超出套餐内的通话时长时需消费哪张卡的余额 */ int call(int minCount, MobileCard card)throws Exception; } |
分析：
这段代码是一个名为CallService的接口，用于定义通话服务的功能。接口中声明了一个call方法，该方法接收两个参数：
- minCount：表示通话的分钟数。
- card：表示超出套餐内通话时长时需要使用哪张卡进行余额消费。
该方法声明了一个int类型的返回值，表示成功通话的分钟数或其他相关信息。同时，方法的声明中使用了throws Exception，表示在方法执行过程中可能会抛出异常。
3.2.2短信接口(SendService)
代码：
| package BaiXu.service; import BaiXu.entity.MobileCard; //短信服务 public interface SendService { /** * 发短信 * @param count 短信数 * @param card 超过套餐范围短信需要使用哪张卡付费 */ int send(int count, MobileCard card)throws Exception; } |
分析：
这段代码是一个名为的接口，用于处理短信服务。该接口定义了一个方法，它接受两个参数：SendServicesend
- count：表示短信数量。
- card：表示超过套餐范围的短信需要使用哪张卡进行付费。
该方法声明了一个类型的返回值，表示发送成功的短信数量或其他相关信息。由于方法声明中使用了，这表明在方法执行过程中可能会抛出异常。intthrows Exception
3.2.3上网接口(NetService)
代码：
| package BaiXu.service; import BaiXu.entity.MobileCard; //上网服务 public interface NetService { /** * 上网 * @param flow 上网流量 * @param card 超出套餐流量部分需要使用哪张卡余额 */ int netPlay(int flow, MobileCard card)throws Exception; } |
分析：
这是一个名为NetService的接口，位于BaiXu.service包中。该接口定义了一个上网服务的方法netPlay，该方法接受一个整数参数flow表示上网流量，和一个MobileCard类型的参数card表示超出套餐流量部分需要使用哪张卡的余额。
根据方法签名，netPlay方法返回一个整数值，需要抛出异常（throws Exception）。
3.3创建业务套餐实体类的子类
3.3.1话痨套餐类(TalkPackage)
代码：
| package BaiXu.service.imp; import BaiXu.entity.MobileCard; import BaiXu.service.ServicePackage; import BaiXu.service.CallService; import BaiXu.service.SendService; /** * 话痨套餐 */ public class TalkPackage extends ServicePackage implements CallService, SendService { private int talkTime; //通话时长 private int smsCount; //可发送短信条数 //构造方法设置卡套餐内容 public TalkPackage() { this.talkTime=200; this.smsCount=50; super.setPrice(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 showInfo() { System.out.println(‘话痨套餐: 通话时长为+this.talkTime+分钟/月,短信条数为+this.smsCount+条/月,上网流量为+0+GB/月); } @Override public int call(int minCount, MobileCard card) throws Exception { // 重写通话接口功能 获得套餐使用详情 int temp = 0;// 实际消耗分钟数 // 循环判断使用详情 for (int i = 0; i < minCount; i++) { // 第一种情况 套餐余额充足还可支持1分钟通话 if (this.getTalkTime() - card.getRealTalkTime() >= 1) { card.setRealTalkTime(card.getRealTalkTime() + 1);// 实际通话数据+1 temp++; } else if (card.getMoney() >= 0.2) { // 情况二：套餐通话时长已经用完，但是账户余额还可以支持1分钟通话，直接使用账户余额支付 card.setRealTalkTime(card.getRealTalkTime() + 1);// 实际使用通话时长分钟+1 temp++; // 剩余金额减少0.2元 card.setMoney(card.getMoney() - 0.2); // 总消费增加0.2元 card.setConsumAmount(card.getConsumAmount() + 0.2); } else { try { throw new Exception(‘本次已通话 + temp + ‘分钟，您的余额已不足，请充值后在使用！); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { // 报错结束返回一个实际通话时长 return temp; } } } return temp;// 返回一个实际通话时长s } @Override public int send(int count, MobileCard card) throws Exception { // 重写短信接口功能 获得套餐使用详情 int temp = 0;// 实际消耗短信次数 // 循环判断使用详情 for (int i = 0; i < count; i++) { // 第一种情况 套餐余额充足还可支持发送1次短信 if (this.getSmsCount() - card.getRealSMSCount() >= 1) { card.setRealSMSCount(card.getRealSMSCount() + 1);// 实际短信数据+1 temp++; } else if (card.getMoney() >= 0.1) { // 情况二：套餐短信次数已经用完，但是账户余额还可以支持发一次短信，直接使用账户余额支付 card.setRealSMSCount(card.getRealSMSCount() + 1);// 实际短信数据+1 temp++; // 剩余金额减少0.1元 card.setMoney(card.getMoney() - 0.1); // 总消费增加0.1元 card.setConsumAmount(card.getConsumAmount() + 0.1); } else { try { throw new Exception(‘本次已发送 + temp + ‘次短信，您的余额已不足，请充值后在使用！); } catch (Exception e) { e.printStackTrace(); } finally { // 报错结束返回一个实际短信次数 return temp; } } } return temp;// 返回一个实际短信次数 } } |
分析：
这是一个名为TalkPackage的类，位于BaiXu.service.imp包中。该类是ServicePackage类的子类，并实现了CallService和SendService接口。
TalkPackage类表示一个话痨套餐，具有通话和发送短信的功能。它包含了通话时长和可发送短信条数的属性，并通过构造方法设置了套餐内容。
该类重写了showInfo方法，用于显示套餐的信息。
在TalkPackage类中，还实现了CallService接口的call方法和SendService接口的send方法。这些方法提供了具体的功能实现。
在call方法中，根据传入的通话时长和卡片对象，判断套餐余量和账户余额，进行相应的通话处理。如果套餐余量足够，直接使用套餐通话时长；如果套餐通话时长已用完但账户余额足够，使用账户余额支付并增加实际通话时长；如果套餐通话时长和账户余额都不足，抛出异常。
在send方法中，根据传入的短信条数和卡片对象，判断套餐余量和账户余额，进行相应的短信发送处理。如果套餐余量足够，直接使用套餐短信条数；如果套餐短信条数已用完但账户余额足够，使用账户余额支付并增加实际发送短信次数；如果套餐短信条数和账户余额都不足，抛出异常。
总体来说，TalkPackage类实现了话痨套餐的功能，包括通话和发送短信，并提供了相应的处理逻辑。
4.3.2网虫套餐类(NetPackage)
代码：
| package BaiXu.service.imp; import BaiXu.entity.MobileCard; import BaiXu.service.ServicePackage; import BaiXu.service.NetService; /** * 网虫套餐 */ public class NetPackage extends ServicePackage implements NetService{ private int flow; //上网流量 public NetPackage() { this.flow=5*1024; super.setPrice(68); } public int getFlow() { return flow; } public void setFlow(int flow) { this.flow = flow; } @Override public void showInfo() { System.out.println(‘话痨套餐: 通话时长为+0+分钟/月,短信条数为+0+条/月,上网流量为+(this.flow/1024.0)+GB/月); } @Override public int netPlay(int flow, MobileCard card) throws Exception { // 重写上网接口功能 获得套餐使用详情 int temp = 0;// 实际消耗流量数据 // 循环判断使用详情 for (int i = 0; i < flow; i++) { // 第一种情况 套餐余额充足还可以使用1MB的流量 if (this.getFlow() - card.getRealFlow() >= 1) { card.setRealFlow(card.getRealFlow() + 1); ;// 实际流量数据+1 temp++; } else if (card.getMoney() >= 0.1) { // 情况二：套餐剩余流量已经用完，但是账户余额还可以支持使用1MB流量，直接使用账户余额支付 card.setRealSMSCount(card.getRealSMSCount() + 1);// 实际流量数据+1 temp++; // 剩余金额减少0.1元 card.setMoney(card.getMoney() - 0.1); // 总消费增加0.1元 card.setConsumAmount(card.getConsumAmount() + 0.1); } else { try { throw new Exception(‘本次已使用 + temp + ‘MB的流量，您的余额已不足，请充值后在使用！); } catch (Exception e) { e.printStackTrace(); } finally { // 报错结束返回一个实际流量数据 return temp; } } } return temp;// 返回一个实际流量数据 } } |
分析：
这段代码是一个名为NetPackage的类，它是一个具体实现了ServicePackage和NetService接口的套餐类，用于提供上网服务。
该类有一个私有属性flow，表示上网流量。在构造函数中，流量被初始化为5*1024，即5GB，价格被设置为68。
类中实现了showInfo()方法，用于展示套餐的信息，包括通话时长、短信条数和上网流量。
另外还重写了netPlay()方法，该方法用于实现上网功能。它接受一个流量参数和一个MobileCard对象作为输入，并返回实际消耗的流量数据。在方法中，根据不同的情况进行流量消耗的判断和处理：如果套餐余额充足，则可以继续使用1MB的流量；如果套餐剩余流量已经用完但账户余额足够支付1MB流量，则使用账户余额支付；如果套餐剩余流量和账户余额都不足以支付1MB流量，则抛出异常并提示用户余额不足。
总的来说，该类是一个网虫套餐的实现，提供了上网流量和相应的计费功能。
4.3.3超人套餐类(SuperPackage)
代码：
| package BaiXu.service.imp; import BaiXu.entity.MobileCard; import BaiXu.service.ServicePackage; import BaiXu.service.CallService; import BaiXu.service.NetService; import BaiXu.service.SendService; /** * 超人套餐 */ public class SuperPackage extends ServicePackage implements CallService, SendService , NetService { private int talkTime; //通话时长 private int smsCount; //可发送短信条数 private int flow; //上网流量 public SuperPackage() { this.talkTime=200; this.smsCount=100; this.flow=1*1024; super.setPrice(78); } 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 getFlow() { return flow; } public void setFlow(int flow) { this.flow = flow; } @Override public void showInfo() { System.out.println(‘超人套餐：通话时长为+this.talkTime+分钟/月,短信条数为：+this.smsCount+条/月，上网流量为+(this.flow/1024)+GB/月); } @Override public int call(int minCount, MobileCard card) throws Exception { // 重写通话接口功能 获得套餐使用详情 int temp = 0;// 实际消耗分钟数 // 循环判断使用详情 for (int i = 0; i < minCount; i++) { // 第一种情况 套餐余额充足还可支持1分钟通话 if (this.getTalkTime() - card.getRealTalkTime() >= 1) { card.setRealTalkTime(card.getRealTalkTime() + 1);// 实际通话数据+1 temp++; } else if (card.getMoney() >= 0.2) { // 情况二：套餐通话时长已经用完，但是账户余额还可以支持1分钟通话，直接使用账户余额支付 card.setRealTalkTime(card.getRealTalkTime() + 1);// 实际使用通话时长分钟+1 temp++; // 剩余金额减少0.2元 card.setMoney(card.getMoney() - 0.2); // 总消费增加0.2元 card.setConsumAmount(card.getConsumAmount() + 0.2); } else { try { throw new Exception(‘本次已通话 + temp + ‘分钟，您的余额已不足，请充值后在使用！); } catch (Exception e){ e.printStackTrace(); } finally { // 报错结束返回一个实际通话时长 return temp; } } } return temp;// 返回一个实际通话时长 } @Override public int netPlay(int flow, MobileCard card) throws Exception { // 重写上网接口功能 获得套餐使用详情 int temp = 0;// 实际消耗流量数据 // 循环判断使用详情 for (int i = 0; i < flow; i++) { // 第一种情况 套餐余额充足还可以使用1MB的流量 if (this.getFlow() - card.getRealFlow() >= 1) { card.setRealFlow(card.getRealFlow() + 1); ;// 实际流量数据+1 temp++; } else if (card.getMoney() >= 0.1) { // 情况二：套餐剩余流量已经用完，但是账户余额还可以支持使用1MB流量，直接使用账户余额支付 card.setRealSMSCount(card.getRealSMSCount() + 1);// 实际流量数据+1 temp++; // 剩余金额减少0.1元 card.setMoney(card.getMoney() - 0.1); // 总消费增加0.1元 card.setConsumAmount(card.getConsumAmount() + 0.1); } else { try { throw new Exception(‘本次已使用 + temp + ‘MB的流量，您的余额已不足，请充值后在使用！); } catch (Exception e) { e.printStackTrace(); } finally { // 报错结束返回一个实际流量数据 return temp; } } } return temp;// 返回一个实际流量数据 } @Override public int send(int count, MobileCard card) throws Exception { // 重写短信接口功能 获得套餐使用详情 int temp = 0;// 实际消耗短信次数 // 循环判断使用详情 for (int i = 0; i < count; i++) { // 第一种情况 套餐余额充足还可支持发送1次短信 if (this.getSmsCount() - card.getRealSMSCount() >= 1) { card.setRealSMSCount(card.getRealSMSCount() + 1);// 实际短信数据+1 temp++; } else if (card.getMoney() >= 0.1) { // 情况二：套餐短信次数已经用完，但是账户余额还可以支持发一次短信，直接使用账户余额支付 card.setRealSMSCount(card.getRealSMSCount() + 1);// 实际短信数据+1 temp++; // 剩余金额减少0.1元 card.setMoney(card.getMoney() - 0.1); // 总消费增加0.1元 card.setConsumAmount(card.getConsumAmount() + 0.1); } else { try { throw new Exception(‘本次已发送 + temp + ‘次短信，您的余额已不足，请充值后在使用！); } catch (Exception e) { e.printStackTrace(); } finally { // 报错结束返回一个实际短信次数 return temp; } } } return temp;// 返回一个实际短信次数 } } |
分析：
这段代码是一个Java类，名为`SuperPackage`，它继承了`ServicePackage`类，并实现了`CallService`、`SendService`和`NetService`接口。
该类表示一个超人套餐，具有通话、短信和上网的功能。它包含了通话时长（`talkTime`）、可发送短信条数（`smsCount`）和上网流量（`flow`）等属性。构造函数初始化了这些属性，并设置了套餐价格（`price`）为78。
类中的`showInfo()`方法用于展示超人套餐的信息。
此外，类中还实现了`call()`、`netPlay()`和`send()`方法，分别用于处理通话、上网和发送短信的逻辑。这些方法根据套餐余量和账户余额判断是否可以进行通话、上网或发送短信，并根据实际消耗更新套餐余量和账户余额。
如果套餐余量或账户余额不足以支持通话、上网或发送短信，则会抛出异常并提示用户进行充值。
总体来说，`SuperPackage`类提供了超人套餐的功能实现，并对通话、上网和发送短信的逻辑进行了处理。
3.4创建工具类
3.4.1工具类
代码：
| ** * 工具类 */ public class CardUtil { //已注册用户列表 private Map<String, MobileCard> cards=new HashMap<>(); //所有卡号消费记录列表 private Map<String, List<ConsumInfo>> consumInfos=new HashMap<>(); //使用场景列表 private List<Scene> scenes = new ArrayList<>(); Scanner sc=new Scanner(System.in); |
分析：
这段代码定义了一个名为CardUtil的工具类，其中包含了一些成员变量和方法。
该工具类包括以下成员变量：
- cards: 一个Map对象，用于存储已注册用户的列表，其中键是用户的字符串标识，值是MobileCard对象。
- consumInfos: 一个Map对象，用于存储所有卡号的消费记录列表，其中键是卡号的字符串标识，值是ConsumInfo对象的列表。
- scenes: 一个List对象，用于存储使用场景列表，其中每个元素是一个Scene对象。
- sc: 一个Scanner对象，用于接收从系统输入中获取的数据。
4.4.2初始化场景
代码：
| /** * 初始化场景 * */ public void initScene(){ //初始化场景 scenes.add(new Scene(‘通话, 90, ‘问候客户，谁知其如此难缠，通话90分钟)); scenes.add(new Scene(‘通话, 30, ‘询问妈妈身体状况，本地通话30分钟)); scenes.add(new Scene(‘短信, 5, ‘参与环境保护实施方案问卷调查，发送短信5条)); scenes.add(new Scene(‘短信, 50, ‘通知朋友手机换号，发送短信50条)); scenes.add(new Scene(‘上网, 1024, ‘和女朋友用微信视频聊天，使用流量1GB)); scenes.add(new Scene(‘上网, 2 * 1024, ‘晚上手机在线看韩剧，不留神睡着啦！使用2GB)); } |
分析：
这是一个名为CardUtil的工具类中的一个方法。该方法名为initScene()，用于初始化场景。
在该方法中，会向scenes列表中添加多个场景对象，每个场景对象表示一个特定的使用场景。每个场景对象包括以下属性：
- name: 场景名称，表示通话、短信或上网。
- usage: 使用量，表示通话时长（分钟）或短信条数或上网流量（MB/GB）。
- description: 场景描述，表示具体的使用情况。
通过调用initScene()方法，可以初始化场景，并将这些场景对象添加到scenes列表中，以供后续使用。
4.4.3初始化
代码：
| /** * 初始化 * 电话卡 使用记录 */ public void init(){ //话痨 MobileCard card1=new MobileCard(‘13901234567, ‘小陈, ‘123456, new TalkPackage(), 58); //网虫 MobileCard card2=new MobileCard(‘13908765431, ‘小许, ‘987654, new NetPackage(), 68); //超级 MobileCard card3=new MobileCard(‘13092322791, ‘小薛, ‘123123, new SuperPackage(), 78); cards.put(card1.getCardNumber(),card1); cards.put(card2.getCardNumber(),card2); cards.put(card3.getCardNumber(),card3); //初始化消费记录列表 //卡1消费记录 List<ConsumInfo> c1= new ArrayList<>(); c1.add(new ConsumInfo(card1.getCardNumber(),通话,100)); card1.setRealTalkTime(card1.getRealTalkTime()+100); consumInfos.put(card1.getCardNumber(),c1); //卡2消费记录 List<ConsumInfo> c2= new ArrayList<>(); c2.add(new ConsumInfo(card2.getCardNumber(),上网,1024)); card2.setRealFlow(card2.getRealFlow()+1024); consumInfos.put(card2.getCardNumber(),c2); //消费记录卡3 List<ConsumInfo> c3= new ArrayList<>(); c3.add(new ConsumInfo(card3.getCardNumber(),通话,100)); c3.add(new ConsumInfo(card3.getCardNumber(),上网,1024)); c3.add(new ConsumInfo(card3.getCardNumber(),发短信,20)); card3.setRealTalkTime(card3.getRealTalkTime()+100); card3.setRealFlow(card3.getRealFlow()+1024); card3.setRealSMSCount(card3.getRealSMSCount()+20); consumInfos.put(card3.getCardNumber(),c3); } |
分析：
这是一个名为CardUtil的工具类中的一个方法。该方法名为init()，用于初始化电话卡和使用记录。
在该方法中，首先创建了三个MobileCard对象，分别表示三个不同的电话卡用户。每个电话卡对象包括以下属性：
- cardNumber: 电话卡号码
- userName: 用户名
- password: 密码
- package: 所属套餐，表示电话卡的套餐类型（TalkPackage、NetPackage或SuperPackage）
- balance: 余额
接下来，将这三个电话卡对象添加到cards列表中，其中键是电话卡号码，值是对应的电话卡对象。
然后，初始化消费记录列表。对于每个电话卡对象，创建一个消费记录列表，并向其中添加消费记录。每条消费记录包括以下属性：
- cardNumber: 电话卡号码
- type: 消费类型，表示通话、上网或发短信。
- amount: 消费数量，表示通话时长（分钟）、上网流量（MB/GB）或短信条数。
同时，根据消费记录更新相应电话卡对象的实际通话时长、实际上网流量和实际短信条数。
通过调用init()方法，可以初始化电话卡和使用记录，以便后续对它们进行操作和管理。
4.4.4注册新卡
代码：
| /** * 注册新卡 * @param card 注册卡号 */ public void addCard(MobileCard card){ //创建选择业务对象 抽象类不能new ServicePackage sp; //创造数组接收随机生成的手机号 String counts[]=getNewNumbers(9); System.out.println(‘************可选择的卡号**************); //打印随机手机号 for (int i = 0; i < counts.length; i++) { System.out.print((i+1)+.+counts[i]+\t\t); //输出三次换行 if((i+1)%3==0){ System.out.println(); } } System.out.print(‘请选择卡号:); int cardNum=sc.nextInt(); //判断选择正确性 while ((cardNum-1)>=counts.length||(cardNum-1)<0){ System.out.print(‘请输入正确的序号:); cardNum=sc.nextInt(); } System.out.println(‘请选择套餐:1.话痨套餐(58元/月) 2.网虫套餐(68元/月) 3.超人套餐(78元/月)(请输入序号):); int choice=sc.nextInt(); //判断选择正确性 while (choice<=0||choice>3){ System.out.println(‘请输入正确的套餐序号); choice=sc.nextInt(); } //获取指定套餐 1.话痨套餐 2.网虫套餐 3.超人套餐 switch (choice){ case 1: sp=new TalkPackage(); break; case 2: sp=new NetPackage(); break; case 3: sp=new SuperPackage(); break; default: throw new IllegalStateException(‘Unexpected value: ‘ + choice); } System.out.print(‘请输入姓名:); String name=sc.next(); System.out.print(‘请输入密码:); String password=sc.next(); System.out.print(‘请输入预存话费金额:); double money=sc.nextDouble(); //将基本信息添加到手机卡对象中 //卡号 用户名 密码 所属套餐 账户余额 card=new MobileCard(counts[cardNum - 1], name, password, sp, sp.getPrice()); //循环判断预存金额是否充足 不足则重新赋值 while(money<card.getSerPackage().getPrice()){ System.out.print(‘您预存的话费金额不足以支付本月固定套餐资费,请重新充值:); money=sc.nextDouble(); card.setMoney(money-sp.getPrice()); } System.out.println(‘注册成功!); //展示信息 card.showMeg(); //添加到集合中 cards.put(card.getCardNumber(),card); } |
分析：
这段代码是一个注册新卡的方法。根据用户的选择，它会创建一个新的手机卡对象，并将基本信息添加到该对象中。下面是代码的执行流程：
- 生成一组随机的手机号码。
- 显示可供选择的手机号码列表。
- 用户选择一个手机号码。
- 用户选择一个套餐（1.话痨套餐，2.网虫套餐，3.超人套餐）。
- 根据用户选择的套餐，创建相应的套餐对象。
- 用户输入姓名、密码和预存话费金额。
- 将用户输入的信息和套餐信息添加到手机卡对象中。
- 检查预存金额是否足够支付套餐费用，如果不足，则要求用户重新充值。
- 注册成功，显示手机卡信息。
- 将手机卡对象添加到集合中。
4.4.5话费充值
代码：
| /** * 话费充值 * @param number 卡号 * @param money 充值金额 */ public void chargeMoney(String number,double money){ //判断卡号是否存在 if(cards.get(number)!=null){ if(money>0){ cards.get(number).setMoney(cards.get(number).getMoney()+money); System.out.println(‘充值成功!当前的话费余额为:+cards.get(number).getMoney()+元); }else System.out.println(‘该手机号不存在); } } |
分析：
这段代码是一个话费充值的方法。根据用户提供的卡号和充值金额，它会检查卡号是否存在，并判断充值金额是否达到最低要求。如果满足条件，将充值金额添加到指定卡号的话费余额中，并显示充值成功后的余额；如果卡号不存在，将显示该手机号不存在的提示。
4.4.6使用嗖嗖（模拟手机消费）
代码：
| /** * 使用嗖嗖(模拟手机消费) * @param number * @throws Exception */ public void userSoso(String number)throws Exception{ //通过手机号获取手机卡对象 MobileCard card=cards.get(number); //随机产生场景 Random rand=new Random(); int temp=0; //各场景的实际消费数据 //遍历判断手机卡所有场景的功能类型 while(true){ //获取0-5的随机数 int randNum=rand.nextInt(6); //根据随机数创建场景(场景在上面已初始化) Scene scene=scenes.get(randNum); switch (randNum){ case 0: case 1: //通话 判断该手机卡是否包含语音套餐(网虫套餐无) if(card.getSerPackage() instanceof CallService){ //展示场景 System.out.println(scene.getDescription()+\t); //获得实际消费数据 scene中data消费数据即为call方法的通话分钟数 temp=((CallService) card.getSerPackage()).call(scene.getData(),card); //添加消费记录 //创建消费记录对象,数据是实际消费数据(不是场景中消费数据) ConsumInfo info=new ConsumInfo(number,scene.getType(),temp); //修改电话卡当月实际通话数据 card.setRealTalkTime(card.getRealTalkTime()+temp); //添加消费记录 addConsumInfo(number,info); break; } continue; case 2: case 3: //短信场景 判断手机卡对象的套餐是否包含短信业务 if(card.getSerPackage() instanceof SendService){ //展示场景 System.out.println(scene.getDescription()+\t); //获得实际消费记录 scene中data为send中短信条数 temp=((SendService) card.getSerPackage()).send(scene.getData(),card); //添加消费记录 //创建消费记录对象,数据是实际消费数据(不是场景中消费数据) ConsumInfo info=new ConsumInfo(number,scene.getType(),temp); //修改电话卡当月实际短信条数 card.setRealSMSCount(card.getRealSMSCount()+temp); addConsumInfo(number,info); break; } continue; case 4: case 5: //上网 判断手机卡对象的套餐是否包含上网业务 if(card.getSerPackage() instanceof NetService){ //展示场景 System.out.println(scene.getDescription()+\t); //获得实际消费数据 此时scene中data为netplay的流量 temp=((NetService)card.getSerPackage()).netPlay(scene.getData(),card); //添加消费记录 ConsumInfo info=new ConsumInfo(number,scene.getType(),temp); //修改电话卡当月实际上午数据 card.setRealFlow(card.getRealFlow()+temp); addConsumInfo(number,info); break; } continue; } //退出while循环 break; } } |
分析：
是一个Java方法的实现，用于模拟手机消费。该方法接受一个手机号作为参数，并根据不同的场景进行消费。
根据代码逻辑，该方法首先通过手机号获取对应的手机卡对象，然后随机选择一个场景。根据场景的类型，判断手机卡是否包含相应的套餐功能，然后执行相应的消费操作，并记录实际消费数据。
具体来说：
- 如果场景类型是通话（0或1），则判断手机卡是否包含语音套餐，如果是，则调用call方法进行通话消费，并记录实际消费数据（通话分钟数）。
- 如果场景类型是短信（2或3），则判断手机卡是否包含短信套餐，如果是，则调用send方法进行短信消费，并记录实际消费数据（短信条数）。
- 如果场景类型是上网（4或5），则判断手机卡是否包含上网套餐，如果是，则调用netPlay方法进行上网消费，并记录实际消费数据（流量）。
在每种消费场景下，会创建一个消费记录对象，并根据消费类型（通话、短信、上网）将实际消费数据添加到相应的消费记录中。然后，会更新手机卡对象的相应统计数据（实际通话时间、实际短信条数、实际上网流量）。
4.4.7资费说明 创建套餐资费说明文件
代码：
| /** * 资费说明 创建套餐资费说明文件 * @throws IOException */ public void showDescription()throws IOException { //创建FileWriter对象 FileWriter fw=new FileWriter(‘src/serviceInfo.txt); //创建StringBuffer接收需要写入的信息 StringBuffer sb=new StringBuffer(); sb.append(‘套餐类型：话唠套餐\r\n + ‘通话时长：500分钟 \r\n + ‘短信条数：30条\r\n + ‘月资费：58元\r\n + ‘——————————————\r\n + ‘套餐类型：网虫套餐\r\n + ‘上网流量：3GB\r\n + ‘月资费：68元\r\n + ‘——————————————\r\n + ‘套餐类型：超人套餐\r\n + ‘通话时长：200分钟 \r\n + ‘短信条数：50条\r\n + ‘上网流量：1GB\r\n + ‘月资费：78元\r\n + ‘——————————————\r\n + ‘超出套餐计费：\r\n + ‘通话时长：0.2元/分钟\r\n + ‘短信条数：0.1元/分钟\r\n + ‘上网流量：0.1元/分钟\r\n + ‘————————————————\r\n); fw.write(sb.toString()); fw.flush(); //创建FileReader对象 FileReader fr=new FileReader(‘src/serviceInfo.txt); //创建BufferReader对象接收字符串 BufferedReader br=new BufferedReader(fr); //循环打印到控制台 String line=br.readLine(); while(line!=null){ System.out.println(line); line=br.readLine(); } try { br.close(); fr.close(); fw.close(); } catch (IOException e) { e.printStackTrace(); } } |
分析：
这段代码是一个Java方法的实现，用于创建套餐资费说明文件并将其内容打印到控制台。
具体来说：
首先，它创建了一个FileWriter对象，用于向文件写入信息。
然后，创建一个StringBuffer对象sb，用于存储需要写入文件的信息，包括不同套餐类型的详细资费说明和超出套餐计费信息。
接下来，使用FileWriter将sb中的信息写入文件。
创建一个FileReader对象和一个BufferedReader对象，用于读取文件的内容。
循环读取文件中的每一行，并将其打印到控制台。
最后，关闭打开的文件流，即BufferedReader、FileReader和FileWriter。
4.4.8套餐余量查询
代码：
| /** * 套餐余量查询 * @param number */ public void showRemainDetail(String number){ //根据手机号查找 MobileCard card=cards.get(number); //判断是否存在 if(card!=null) { //创建StringBuffer类 便于字符串拼接 StringBuffer sb = new StringBuffer(‘您的卡号是： + number + ‘\n套餐内剩余：); // 获取卡中的真实消费数据和业务数据比较，判定 ServicePackage serPackage = card.getSerPackage(); // 判断是哪种套餐 if (serPackage instanceof SuperPackage) { //向下转型获取超人套餐信息和功能 SuperPackage pack = (SuperPackage) serPackage; //获取套餐余量 int minusTalkData = pack.getTalkTime() - card.getRealTalkTime(); int minusSMSData = pack.getSmsCount() - card.getRealSMSCount(); int minusFlowData = pack.getFlow() - card.getRealFlow(); sb.append(‘\n通话时长: + (minusTalkData > 0 ? minusTalkData + ‘分钟 : ‘0分钟)); sb.append(‘\n短信条数: + (minusSMSData > 0 ? minusSMSData + ‘条 : ‘0条)); sb.append(‘\n上网流量: + (minusFlowData > 0 ? minusFlowData/1024 + ‘GB : ‘0GB)); } else if (serPackage instanceof TalkPackage) { // 向下转型获取话痨套餐信息和功能 TalkPackage pack = (TalkPackage) serPackage; // 获取套餐余量 int minusTalkData = pack.getTalkTime() - card.getRealTalkTime(); int minusSMSData = pack.getSmsCount() - card.getRealSMSCount(); sb.append(‘\n通话时长： + (minusTalkData > 0 ? minusTalkData + ‘分钟 : ‘0分钟)); sb.append(‘\n短信条数： + (minusSMSData > 0 ? minusSMSData + ‘条 : ‘0条)); } else if (serPackage instanceof NetPackage) { // 向下转型获取话痨套餐信息和功能 NetPackage pack = (NetPackage) serPackage; /// 获取套餐余量 int minusFlowData = pack.getFlow() - card.getRealFlow(); sb.append(‘\n上网流量： + (minusFlowData > 0 ? minusFlowData / 1024 + ‘GB :0GB)); } System.out.println(sb); } else { System.out.println(‘该手机卡号不存在！); } } |
分析：
这是一个用于查询套餐余量的方法。根据给定的手机号码（number），该方法会查找对应的手机卡信息，并返回套餐余量详情。
如果找到了对应的手机卡（card != null），方法会创建一个 StringBuffer 对象，并将套餐余量信息拼接到该对象中。根据不同的套餐类型，套餐余量信息《《《《《包括通话时长、短信条数和上网流量。
如果是超人套餐（SuperPackage），会获取套餐中的通话时长、短信条数和上网流量，并计算剩余的套餐余量。如果是话痨套餐（TalkPackage），会获取套餐中的通话时长和短信条数，并计算剩余的套餐余量。如果是上网套餐（NetPackage），会获取套餐中的上网流量，并计算剩余的套餐余量。
最后，将拼接好的套餐余量信息打印出来。
如果找不到对应的手机卡（card == null），则会打印出该手机卡号不存在!的提示信息。
4.4.9打印消费账单
代码：
| /** * 打印消费账单 * @param number */ public void printAmountDetail(String number){ //判断手机号是否存在 if(cards.get(number)!=null){ //打印消费记录到文本文件中 文件名:手机号+消费记录 try { FileWriter fw=new FileWriter(number+消费记录.txt); //创建StringBuffer写入消费记录 StringBuffer sb=new StringBuffer(‘***********************+number+的消费记录***********************); sb.append(‘\n序号\t类型\t数据(通话(分钟)/上网(MB)/短信(条))\n); // 获取消费记录集合 List<ConsumInfo> infoList=consumInfos.get(number); //判断集合是否为空 if(infoList!=null){ //遍历消费记录 for (int i = 0; i < infoList.size(); i++) { sb.append((i+1)+.\t+infoList.get(i).getType()+\t+infoList.get(i).getConsumData()+\n); } System.out.println(‘打印完成); }else{ System.out.println(‘该卡暂无消费记录); } // 写入文件 fw.write(sb.toString()); fw.flush(); fw.close(); }catch (IOException e) { e.printStackTrace(); } }else { System.out.println(‘改手机号不存在); } } |
分析：
这段代码是一个打印消费账单的方法。根据传入的手机号码（number），方法会检查该手机号码是否存在于一个名为cards的集合中。如果存在，方法会将消费记录打印到一个文本文件中，文件名是手机号码加上消费记录.txt。消费记录包括序号、类型和数据（通话时长、上网流量或短信条数）。
代码首先创建一个FileWriter对象来写入文件。然后，创建一个StringBuffer对象来构建消费记录的字符串。字符串的开头是一个包含手机号码的标题，然后是表头，接着是消费记录的内容。消费记录是从名为consumInfos的集合中获取的，该集合是根据手机号码进行索引的。
如果消费记录集合不为空，代码会遍历记录并将其添加到StringBuffer对象中。最后，将StringBuffer对象的内容写入文件，并关闭FileWriter对象。
如果传入的手机号码在集合中不存在，代码会输出该手机号不存在的消息。
4.4.10套餐变更
代码：
| /** * 套餐变更 * @param number 卡号 */ public void changingPack(String number){ //创建一个业务套餐对象 抽象类无法实例化(判断卡号类型向下转型) ServicePackage sp; //判断卡号是否存在 if(cards.get(number)!=null){ System.out.println(‘**********************); System.out.println(‘1、话痨套餐\t2、网虫套餐\t3、超人套餐 请选择(序号):); int choice=sc.nextInt(); //判断输入正误 while (choice<=0||choice>3){ System.out.print(‘请输入正确的序号); choice=sc.nextInt(); } //判断项目类型 switch (choice){ case 1: //话痨套餐 sp=new TalkPackage(); //判断现有套餐是否与要更改套餐相同 if(cards.get(number).getSerPackage() instanceof TalkPackage){ System.out.println(‘对不起,您已经是改套餐用户,无需更改); }else{ //判断剩余金额是否足以支付套餐费用 if(cards.get(number).getMoney()>sp.getPrice()){ //更改套餐 cards.get(number).setSerPackage(sp); //余额减去套餐费用 cards.get(number).setMoney(cards.get(number).getMoney()-sp.getPrice()); //当月消费金额加上套餐费 cards.get(number).setConsumAmount(cards.get(number).getConsumAmount() + sp.getPrice()); System.out.println(‘更改套餐成功!); //展示套餐信息 sp.showInfo(); }else { System.out.println(‘余额不足,无法更改套餐); } } break; case 2: //网虫套餐 sp=new NetPackage(); //判断现有套餐和要更改套餐是否相同 if(cards.get(number).getSerPackage() instanceof NetService){ System.out.println(‘您已经是改套餐用户,无需更改); }else{ //判断余额要大于套餐费用 if(cards.get(number).getMoney()>sp.getPrice()){ //更改套餐 cards.get(number).setSerPackage(sp); //余额减去套餐费 cards.get(number).setMoney(cards.get(number).getMoney()-sp.getPrice()); //月消费加上套餐费 cards.get(number).setConsumAmount(cards.get(number).getConsumAmount()+sp.getPrice()); System.out.println(‘套餐修改成功); }else{ System.out.println(‘余额不足,无法更改套餐); } } break; case 3: //超人套餐 sp=new SuperPackage(); //判断已有套餐和要修改套餐是否相同 if(cards.get(number).getSerPackage() instanceof SuperPackage){ System.out.println(‘您已经是该套餐用户,无法修改); }else { //判断余额是否足以修改套餐 if(cards.get(number).getMoney()>sp.getPrice()){ //更改套餐 cards.get(number).setSerPackage(sp); //更改余额 cards.get(number).setMoney(cards.get(number).getMoney()-sp.getPrice()); //更改月消费 cards.get(number).setConsumAmount(cards.get(number).getConsumAmount()+sp.getPrice()); }else{ System.out.println(‘余额不足,无法更改套餐); } } break; } }else{ System.out.println(‘该手机号不存在); } } |
分析：
这段代码是一个套餐变更的方法。根据传入的卡号（number），方法会检查该卡号是否存在于一个名为cards的集合中。如果存在，方法会提示用户选择不同的套餐类型（1、话痨套餐；2、网虫套餐；3、超人套餐），并根据用户的选择进行相应的套餐变更操作。
代码首先创建一个抽象类的对象，用于表示业务套餐。然后，判断卡号是否存在于集合中。如果存在，代码会提示用户选择套餐类型，并进行输入的验证。根据用户的选择，使用switch语句判断套餐类型，然后执行相应的逻辑。
对于每种套餐类型，代码首先检查当前用户是否已经是该套餐的用户，如果是则输出提示信息，无需进行套餐变更。如果不是该套餐的用户，则判断用户的余额是否足够支付套餐费用。如果余额足够，代码会进行套餐变更操作，即将用户的套餐设置为选择的套餐类型，并扣除相应的套餐费用。同时，将用户的月消费金额增加相应的套餐费用。
如果用户的余额不足以支付套餐费用，代码会输出余额不足，无法更改套餐的消息。
如果传入的卡号在集合中不存在，代码会输出该手机号不存在的消息。
4.4.11办理退网
代码：
| /** * 办理退网 * @param number 卡号 */ public void delCard(String number){ //判断集合中卡号是否存在 if(cards.get(number)!=null){ System.out.println(‘*********办理退网**********); //二次确定 System.out.print(‘您确定注销此手机号吗?(Y/N):); String choice=sc.next(); if(choice.equalsIgnoreCase(‘Y)){ //通过 key手机号删除 cards.remove(number); System.out.println(‘卡号:+number+退网成功!\n感谢使用); } }else{ System.out.println(‘该手机卡号不存在!); } } |
分析：
这段代码是一个Java方法，用于办理退网操作。以下是对代码的解释：
该方法名为delCard，接受一个名为number的参数，该参数表示卡号。
代码首先通过判断集合中是否存在给定的卡号来检查卡号是否有效。如果卡号存在于集合中，程序将输出办理退网*，然后要求用户再次确认是否注销该手机号。用户需要输入Y或N来表示确认或取消操作。
如果用户输入Y（不区分大小写），则程序将从集合中删除该卡号，并输出卡号: [number] 退网成功！感谢使用。
如果用户输入N或其他无效的选项，程序将结束。
如果卡号不存在于集合中，程序将输出该手机卡号不存在！。
4.4.12根据卡密验证该卡是否已注册(登录验证)
代码：
| /** * 根据卡密验证该卡是否已注册(登录验证) * @param number * @param passWord * @return */ public boolean isExistCard(String number,String passWord){ Set<String> numbers = cards.keySet(); Iterator<String> it = numbers.iterator(); boolean flag=false; while (it.hasNext()){ String searchNum = it.next(); if(searchNum.equals(number) && (cards.get(searchNum)).getPassWord().equals(passWord)){ flag=true; } } return flag; } /** * //根据卡号验证卡号是否注册 * @param number * @return */ public boolean isExistCard(String number){ Set<String> numbers = cards.keySet(); Iterator<String> it = numbers.iterator(); boolean flag=false; while (it.hasNext()){ String searchNum = it.next(); if(searchNum.equals(number)){ flag=true; } } return flag; } |
分析：
这段代码是一个Java类中的两个方法。
第一个方法名为isExistCard，接受两个参数：number和passWord，用于根据卡密验证卡是否已注册（登录验证）。该方法通过遍历集合中的卡号，检查是否存在与给定的卡号和密码匹配的卡。如果存在匹配的卡，则将flag标志设置为true。最后，该方法返回flag的值，表示卡是否存在和验证是否通过。
第二个方法名也为isExistCard，接受一个参数：number，用于根据卡号验证卡号是否已注册。该方法同样通过遍历集合中的卡号，检查是否存在与给定的卡号匹配的卡。如果存在匹配的卡，则将flag标志设置为true。最后，该方法返回flag的值，表示卡是否存在。
4.4.13生成随机卡号
代码：
| /** * //生成随机卡号 * @return */ public String createNumber(){ String fixedNum=‘178; String cardNumber=‘‘; Random rand=new Random(); String randNumber=‘‘; //随机生成八位数字 for (int i = 0; i < 8; i++) { randNumber+=rand.nextInt(10); } cardNumber=fixedNum+randNumber; return cardNumber; } |
分析：
这段代码是一个Java方法，用于生成随机的卡号。
方法名为createNumber，不接受任何参数。
代码首先定义了一个字符串变量fixedNum，初始化为178。然后定义了一个空字符串变量cardNumber。
接下来，代码创建了一个Random对象rand，用于生成随机数。然后使用一个循环生成八位随机数字，将其添加到randNumber字符串中。
最后，将fixedNum和randNumber拼接在一起，赋值给cardNumber，作为生成的随机卡号。
最终，方法返回生成的随机卡号cardNumber。
使用该方法可以生成一个以178开头的随机八位数字卡号。
4.4.14生成指定个数的卡号列表
代码：
| /** * 生成指定个数的卡号列表 * @param count 返回手机号码数量 * @return */ public String[] getNewNumbers(int count){ //创建一个数组接收随机生成卡号 String[] numbers=new String[count]; //遍历赋值 for (int i = 0; i < numbers.length; i++) { numbers[i]=createNumber(); //判断是否注册 if(isExistCard(numbers[i])){ //如果被注册就重新赋值 i--; } //判断生成是否有重复 for (int j = 0; j < i; j++) { //判断新生成的号码与之前生成的号码是否有重复,如果有重新生成 if(numbers[i].equals(numbers[j])){ //有重复重新赋值 i--; break; } } } return numbers; } |
分析：
编写一个方法来生成指定数量的卡号列表。代码中的逻辑如下：
- 创建一个长度为count的字符串数组numbers，用于存储生成的卡号。
- 使用循环遍历数组，每次循环生成一个新的卡号并赋值给numbers[i]。
- 在赋值之后，通过调用isExistCard()方法来检查该卡号是否已被注册。
- 如果卡号已被注册，则重新赋值，将i减1，以便重新生成一个新的卡号。
- 在生成新的卡号后，通过嵌套循环遍历已生成的卡号（从0到i-1），检查新生成的卡号是否与之前的卡号有重复。
- 如果有重复，则重新赋值，将i减1，以便重新生成一个新的卡号。
- 循环结束后，返回生成的卡号数组numbers。
根据以上代码逻辑，这个方法主要用于生成指定数量的不重复卡号列表。
4.4.15添加指定卡号的消费记录
代码：
| /** * 添加指定卡号的消费记录 * @param number 手机卡号 * @param info 一条消费记录 */ public void addConsumInfo(String number,ConsumInfo info){ //创建消费对象集合 List<ConsumInfo> consumList=null; //有消费记录(集合已存在) if(consumInfos.containsKey(number)){ consumList=consumInfos.get(number); consumList.add(info); System.out.println(‘添加消费记录成功); }else { //没有消费记录(该卡号不存在集合中) consumList=new ArrayList<>(); consumList.add(info); //添加到map中 consumInfos.put(number,consumList); System.out.println(‘该卡还未进行消费,新增一条消费记录); } } } |
分析：
这是一个用于添加消费记录的方法。根据传入的手机卡号和消费记录信息，该方法将消费记录添加到对应的消费对象集合中。
如果传入的手机卡号已存在消费记录集合中，那么该消费记录将被添加到现有集合中，并输出添加消费记录成功的提示。
如果传入的手机卡号不存在消费记录集合中，那么将创建一个新的消费记录集合，并将消费记录添加到该集合中。然后，将该消费记录集合与手机卡号关联，并输出该卡还未进行消费，新增一条消费记录的提示。
这个方法的作用是维护一份消费记录，可以根据不同的手机卡号来添加对应的消费记录。
4.4.16本月账单查询
代码：
| /** * 本月账单查询 * @param number */ public void showAmountDetail(String number){ //根据手机号查找 MobileCard card=cards.get(number); //判断是否存在 if(card!=null){ //创建StringBuffer类 便于字符串拼接 StringBuffer sb = new StringBuffer(‘您的卡号: + number + ‘的当月账单:\n); sb.append(‘套餐资费:+card.getSerPackage().getPrice()+元\n); sb.append(‘合计:+card.getConsumAmount()+元\n); sb.append(‘账户余额:+card.getMoney()+元。); System.out.println(sb); }else{ System.out.println(‘该手机卡号不存在!); } } |
分析：
这是一个用于查询本月账单的方法。根据给定的手机号码（number），该方法会查找对应的手机卡信息，并返回账单详情。
如果找到了对应的手机卡（card != null），方法会创建一个 StringBuffer 对象，并将账单信息拼接到该对象中。账单信息包括卡号、套餐资费、合计消费金额和账户余额。最后，将拼接好的账单信息打印出来。
如果找不到对应的手机卡（card == null），则会打印出该手机卡号不存在!的提示信息。
根据这个方法的设计，您可以调用该方法并传入要查询账单的手机号码，然后获取该手机号码对应手机卡的当月账单信息。
3.5创建菜单类
代码：
| package BaiXu.manager; import BaiXu.entity.MobileCard; import BaiXu.util.CardUtil; import java.io.IOException; import java.util.Scanner; public class Business { private Scanner sc=new Scanner(System.in); private CardUtil cardUtil=new CardUtil(); /** * 启动 */ public void start(){ //初始化 cardUtil.init(); cardUtil.initScene(); int choose; //用户选择 boolean isExit=false;// 标记用户是否退出系统，true为退出 String cardNum=null; //手机卡号 //遍历菜单 do { mainMenu(); choose=sc.nextInt(); switch (choose){ case 1: System.out.println(‘***用户登录***); System.out.print(‘请输入手机号:); cardNum = sc.next(); System.out.print(‘请输入密码:); String passWord=sc.next(); //判断注册状态 if (cardUtil.isExistCard(cardNum,passWord)){ cardMenu(cardNum); }else{ System.out.println(‘账号或密码输入错误); } break; case 2: System.out.println(‘***用户注册***); MobileCard card=null; cardUtil.addCard(card); break; case 3: System.out.println(‘***使用嗖嗖***); System.out.print(‘请输入手机卡号); cardNum=sc.next(); if(cardUtil.isExistCard(cardNum)){ try { cardUtil.userSoso(cardNum); } catch (Exception e) { e.printStackTrace(); } }else { System.out.println(‘该手机号不存在); } break; case 4: System.out.println(‘***话费充值***); System.out.print(‘请输入要充值的手机号:); cardNum=sc.next(); System.out.print(‘请输入充值金额:); double money=sc.nextDouble(); cardUtil.chargeMoney(cardNum,money); break; case 5: System.out.println(‘***资费说明***); try { cardUtil.showDescription(); } catch (IOException e) { e.printStackTrace(); } break; case 6: System.out.println(‘退出系统); isExit=true; break; default: System.out.println(‘业务开发中...); System.out.println(‘欢迎下次光临嗖嗖移动服务大厅); break; } } while (true); } //主菜单 public static void mainMenu(){ System.out.println(‘******欢迎使用嗖嗖移动业务大厅******); System.out.println(‘1.用户登录\t2.用户注册\t3.使用嗖嗖\t4.话费充值\t5.资费说明\t6.退出系统); System.out.println(‘请选择(输入1-6选择功能,其他键返回主菜单):); } //二级菜单 public void cardMenu(String number){ do { int choice; System.out.println(‘******嗖嗖移动用户菜单******); System.out.println(‘1.本月账单查询\t2.套餐余量查询\t3.打印消费详单\t4.套餐变更\t5.办理退网); System.out.println(‘请选择(输入1-5选择功能,其他键返回上一级):); choice=sc.nextInt(); switch (choice) { case 1: System.out.println(‘1、本月账单查询); cardUtil.showAmountDetail(number); break; case 2: System.out.println(‘2、套餐余量查询); cardUtil.showRemainDetail(number); break; case 3: System.out.println(‘3、打印消费祥单); cardUtil.printAmountDetail(number); break; case 4: System.out.println(‘4、套餐变更); cardUtil.changingPack(number); break; case 5: System.out.println(‘5、办理退网); cardUtil.delCard(number); break; default: System.out.println(‘返回主菜单); return; } }while (true); } } |
分析：
这段代码是一个名为Business的Java类，位于BaiXu.manager包中。它是一个移动业务管理系统的主要逻辑类，包含了用户登录、注册、使用嗖嗖移动服务、话费充值、资费说明等功能。
在start()方法中，程序会初始化并显示主菜单，然后根据用户的选择执行相应的操作。其中，用户登录和注册会调用cardUtil对象的方法进行账号验证和添加新卡的操作。使用嗖嗖移动服务会调用cardUtil对象的userSoso()方法。话费充值会调用cardUtil对象的chargeMoney()方法。资费说明会调用cardUtil对象的showDescription()方法。退出系统会将isExit标记设置为true，结束程序的执行。
mainMenu()方法用于显示主菜单的选项。
cardMenu()方法用于显示用户菜单的选项，并根据用户选择执行相应的功能。其中，本月账单查询、套餐余量查询、打印消费详单、套餐变更、办理退网等功能会调用cardUtil对象的相应方法进行处理。
这段代码依赖于BaiXu.entity.MobileCard类和BaiXu.util.CardUtil类，通过import语句引入这两个类的相关功能。
3.6创建测试类
代码：
| package BaiXu.manager; public class Test { public static void main(String[] args) { Business soso=new Business(); soso.start(); } } |
分析：
这是一个名为Test的类，其中包含一个main方法。在main方法中，创建了一个Business对象，并调用了它的start方法。
根据代码的命名和结构，Business类是一个业务类或管理类，其中包含了一些业务逻辑或管理操作。通过调用start方法，会启动整个业务流程。
第四章 总结
关于嗖嗖移动业务大厅的设计总结分析：
嗖嗖移动业务大厅的设计总结分析应该包括以下几个方面：
1. 用户体验：嗖嗖移动业务大厅的设计应该注重用户体验，使用户能够方便、快捷地完成各种业务办理。界面设计应简洁明了，操作流程应流畅自然，确保用户在使用过程中能够轻松找到所需的功能，提供良好的使用体验。
2. 功能完善：嗖嗖移动业务大厅应提供全面的业务功能，包括用户账号管理、套餐选择、话费充值、流量查询、业务办理等。同时，还可以考虑加入一些增值服务，如积分兑换、特惠活动等，以提升用户黏性和满意度。
3. 多渠道接入：嗖嗖移动业务大厅应该支持多渠道接入，包括网页版、手机APP、微信公众号等。这样用户可以根据自己的需求选择最方便的方式进行业务办理，增加用户的选择性和便利性。
4. 数据安全性：在设计嗖嗖移动业务大厅时，要充分考虑数据安全性。采取必要的安全措施，保护用户的个人信息和交易数据，确保用户信息不被泄露或滥用。同时，要建立健全的安全机制和风险控制体系，及时发现和应对《《《《《存在的安全风险。
5. 用户反馈和改进：嗖嗖移动业务大厅应该设立用户反馈机制，及时收集用户的意见和建议。根据用户的反馈，及时进行改进和优化，提升用户体验和满意度。
所以如果要更完善这个项目，就得以嗖嗖移动业务大厅的设计总结分析，关注用户体验、功能完善、多渠道接入、数据安全性以及用户反馈和改进。这些方面的综合考虑将有助于提升嗖嗖移动业务大厅的质量和用户满意度。
3676
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
