一，前言
1，第六次作业（针对电信计费）
本次作业主要是对类的操作，题目已经给出类图，类图里面已经给了各种方法以及属性。此次作业涉及了座机的计费方式，市内省内省外怎么计费。难度偏难，主要是各类之间怎么实现连接，类的编写复杂，工程量巨大，需要弄清楚逻辑方可计算。
2，第七次作业（针对电信计费）
再上一次的基础上增加了一个手机计费方式，座机对座机，座机对手机，手机对座机，手机对手机，需要考虑的方面还是很多的，很多的测试点。难度偏难，难度在于情况多，难以考虑到全部。
3，第八次作业（针对电信计费）
本次是最简单的一次作业，电信计费只需要短信，在以前的类图中增加短信的类，难度偏低。考察的还是类之间的连接。
二，设计与分析（代码部分已折叠）
1，第六次作业（针对电信计费）
实现一个简单的电信计费程序：
假设南昌市电信分公司针对市内座机用户采用的计费方式：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
南昌市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。
输入格式:
输入信息包括两种类型
1、逐行输入南昌市用户开户的信息，每行一个用户，
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐）
例如：u-079186300001 0
座机号码除区号外由是7-8位数字组成。
本题只考虑计费类型0-座机计费，电信系列2、3题会逐步增加计费类型。
2、逐行输入本月某些用户的通讯信息，通讯信息格式：
座机呼叫座机：t-主叫号码 接听号码 起始时间 结束时间
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四项内容之间以一个英文空格分隔，
时间必须符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat类。
以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
注意：
本题非法输入只做格式非法的判断，不做内容是否合理的判断（时间除外，否则无法计算），比如：
1、输入的所有通讯信息均认为是同一个月的通讯信息，不做日期是否在同一个月还是多个月的判定，直接将通讯费用累加，因此月租只计算一次。
2、记录中如果同一电话号码的多条通话记录时间出现重合，这种情况也不做判断，直接 计算每条记录的费用并累加。
3、用户区号不为南昌市的区号也作为正常用户处理。
输出格式:
根据输入的详细通讯信息，计算所有已开户的用户的当月费用（精确到小数点后2位，
单位元）。假设每个用户初始余额是100元。
每条通讯信息单独计费后累加，不是将所有时间累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
建议类图：
参见图1、2、3，可根据理解自行调整：
图1
图1中User是用户类，包括属性：
userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。
ChargeMode是计费方式的抽象类：
chargeRules是计费方式所包含的各种计费规则的集合，ChargeRule类的定义见图3。
getMonthlyRent（）方法用于返回月租（monthlyRent）。
UserRecords是用户记录类，保存用户各种通话、短信的记录，
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是：
市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。
图2
图2中CommunicationRecord是抽象的通讯记录类：
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。
CallRecord（通话记录类）包含属性：
通话的起始、结束时间以及
拨号地点的区号（callingAddressAreaCode）、接听地点的区号（answerAddressAreaCode）。
区号用于记录在哪个地点拨打和接听的电话。座机无法移动，就是本机区号，如果是手机号，则会有差异。
图3是计费规则的相关类，这些类的核心方法是：
calCost（ArrayList<CallRecord> callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是
座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。
（提示：可以从UserRecords类中获取各种类型的callRecords）。
后续扩展说明：
后续题目集将增加手机用户，手机用户的计费方式中除了与座机计费类似的主叫通话费之外，还包含市外接听电话的漫游费以及发短信的费用。在本题的设计时可统一考虑。
通话记录中，手机需要额外记录拨打/接听的地点的区号，比如：
座机打手机：t-主叫号码 接听号码 接听地点区号 起始时间 结束时间
t-079186330022 13305862264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
手机互打：t-主叫号码 拨号地点 接听号码 接听地点区号 起始时间 结束时间
t-18907910010 0791 13305862264 0371 2022.1.3 10:00:25 2022.1.3 10:05:11
短信的格式：m-主叫号码，接收号码，短信内容
m-18907910010 13305862264 welcome to jiangxi
m-13305862264 18907910010 thank you
设计：
先按照类图写出各个类，类的属性方法。
计费方式分为三个方式，然后这三个方式归属于收费方式类，需要添加在记录数组里面。通讯记录又分为电话记录和短信记录，电话记录中有一些数组，例如座机市内通话记录，省内通话记录，我们需要根据输入的记录放进不同的数组，根据全部数组在计算是调用不同的收费方式算钱。输入用户时我们需要在主函数创建user数组，存放注册的用户，再在对应的用户记录数组里面添加记录，最后算出费用。这里难度就在于刚开始的类的逻辑怎么连起来，连起来之后就比较简单了，只需要在主函数记录。
剩下的只需要考虑的全面，拿分还是挺简单的。
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Objects;
import java.util.Scanner;
public class Main {
public static void Print(double data) { //保留1位小数
System.out.print((float)(data));
}
public static void main(String[] args) {
String gre = "t-0791[0-9]{7,8}\\s" + "0[0-9]{9,11}\\s" +
"([1-9][0-9]{3}\\.([1-9]|1[0-2])\\.([1-9]|(2[0-9]|3[0-1])) ([0|1]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}";
String gre1 = "u-0791[0-9]{7,8}\\s[0-2]";
ArrayList<User> user = new ArrayList<>();
Scanner in = new Scanner(System.in);
while (true) {
String str = in.nextLine();
if (str.equals("end")) break;
if (str.matches(gre1)) {
String[] array = str.split("-", 2);
String[] array1 = array[1].split(" ", 2);
String phone_number = array1[0];
boolean has_found = false;
for (User value : user) {
if (phone_number.equals(value.getNumber())) {
has_found = true;
break;
}
}
if (has_found) continue;
User u = new User();
u.setNumber(phone_number);
if (Objects.equals(array1[1], "0")) {
u.setChargeMode(new LandlinePhoneCharging());
}
user.add(u);
} else if (str.matches(gre)) {
String[] array = str.split("-", 2);
String[] array1 = array[1].split(" ");
String phone_number = array1[0];
String phone_number1 = array1[1];
String start_time = array1[2] + " " + array1[3];
String end_time = array1[4] + " " + array1[5];
SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
Date date = null, date1 = null;
try {
date = sdf.parse(start_time);
} catch (ParseException e) {
e.printStackTrace();
}
try {
date1 = sdf.parse(end_time);
} catch (ParseException e) {
e.printStackTrace();
}
for (int i = 0; i < user.size(); i++) {
if (phone_number.equals(user.get(i).getNumber())) {
CallRecord callRecord = new CallRecord();
callRecord.setStartTime(date);
callRecord.setEndTime(date1);
callRecord.setCallingAddressAreaCode(phone_number.substring(0, 4));
callRecord.setAnswerAddressAreaCode(phone_number1.substring(0, 4));
if (Objects.equals(callRecord.getAnswerAddressAreaCode(), callRecord.getCallingAddressAreaCode())) {
user.get(i).userRecords.addCallingInCityRecords(callRecord);
} else if (callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)")) {
user.get(i).userRecords.addCallingInProvinceRecords(callRecord);
} else {
user.get(i).userRecords.addCallingInLandRecords(callRecord);
}
}
}
}
}
user.sort((user1,user2)->user1.getNumber().compareTo(user2.getNumber()));
for (int i = 0; i < user.size(); i++) {
System.out.print(user.get(i).getNumber() + " ");
Print(user.get(i).calCost());
System.out.print(" ");
Print(user.get(i).calBalance());
System.out.println();
}
}
}
abstract class CallChargeRule extends ChargeRule{
}
class CallRecord extends CommunicationRecord{
Date startTime;
Date endTime;
String callingAddressAreaCode;
String answerAddressAreaCode;
public Date getStartTime(){
return startTime;
}
public void setStartTime(Date startTime){
this.startTime=startTime;
}
public Date getEndTime(){
return endTime;
}
public void setEndTime(Date endTime){
this.endTime=endTime;
}
public String getCallingAddressAreaCode(){
return callingAddressAreaCode;
}
public void setCallingAddressAreaCode(String callingAddressAreaCode){
this.callingAddressAreaCode=callingAddressAreaCode;
}
public String getAnswerAddressAreaCode(){
return answerAddressAreaCode;
}
public void setAnswerAddressAreaCode(String answerAddressAreaCode){
this.answerAddressAreaCode=answerAddressAreaCode;
}
}
abstract class ChargeMode {
ArrayList<ChargeRule> ChargeRules=new ArrayList<>();
public ArrayList<ChargeRule> getChargeRules(){
return ChargeRules;
}
public void setChargeRules(ArrayList<ChargeRule> ChargeRules){
this.ChargeRules=ChargeRules;
}
public abstract double calCost(UserRecords userRecords);
public abstract double getMonthlyRent();
}
abstract class ChargeRule {
public abstract double calCost(ArrayList<CallRecord> callRecords);
}
abstract class CommunicationRecord {
protected String callingNumber;
protected String answerNumber;
public String getCallingNumber(){
return callingNumber;
}
public void setCallingNumber(String callingNumber){
this.callingNumber=callingNumber;
}
public String getAnswerNumber(){
return answerNumber;
}
public void setAnswerNumber(String answerNumber){
this.answerNumber=answerNumber;
}
}
class LandlinePhoneCharging extends ChargeMode{
double monthlyRent=20;
public LandlinePhoneCharging(){
ChargeRules.add(new LandPhoneInCityRule());
ChargeRules.add(new LandPhoneInProvinceRule());
ChargeRules.add(new LandPhoneInLandRule());
}
@Override
public double calCost(UserRecords userRecords){//三种收费方式加起来的钱
double sum_cost=0;
sum_cost += ChargeRules.get(0).calCost(userRecords.callingInCityRecords);
sum_cost += ChargeRules.get(1).calCost(userRecords.callingInProvinceRecords);
sum_cost += ChargeRules.get(2).calCost(userRecords.callingInLandRecords);
return sum_cost;
}
@Override
public double getMonthlyRent(){
return monthlyRent;
}
}
class LandPhoneInCityRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return sum*0.1;
}
}
class LandPhoneInLandRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return sum*0.6;
}
}
class LandPhoneInProvinceRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return sum*0.3;
}
}
class MessageRecord extends CommunicationRecord{
String message;
public String getMessage(){
return null;
}
public void setMessage(String message){
};
}
class User {
UserRecords userRecords=new UserRecords();
private final double balance=100;
private ChargeMode chargeMode;
private String number;
public double calBalance(){
return this.balance-this.calCost()-chargeMode.getMonthlyRent();
}
public double calCost(){
return chargeMode.calCost(userRecords);
}
public UserRecords getUserRecords(){
return this.userRecords;
}
public void setUserRecord(UserRecords userRecords){
this.userRecords=userRecords;
}
public ChargeMode getChargeMode(){
return chargeMode;
}
public double getBalance(){
return this.balance;
}
public void setChargeMode(ChargeMode chargeMode){
this.chargeMode=chargeMode;
}
public String getNumber(){
return this.number;
}
public void setNumber(String number){
this.number=number;
}
}
class UserRecords {
ArrayList<CallRecord> callingInCityRecords=new ArrayList<CallRecord>();
ArrayList<CallRecord> callingInProvinceRecords=new ArrayList<CallRecord>();
ArrayList<CallRecord> callingInLandRecords=new ArrayList<CallRecord>();
ArrayList<CallRecord> answerInCityRecords=new ArrayList<CallRecord>();
ArrayList<CallRecord> answerInProvinceRecords=new ArrayList<CallRecord>();
ArrayList<CallRecord> answerInLandRecords=new ArrayList<CallRecord>();
ArrayList<MessageRecord> sendMessageRecords=new ArrayList<MessageRecord>();
ArrayList<MessageRecord> receiveMessageRecords=new ArrayList<MessageRecord>();
public void addCallingInCityRecords(CallRecord callRecord){
callingInCityRecords.add(callRecord);
}
public void addCallingInProvinceRecords(CallRecord callRecord){
callingInProvinceRecords.add(callRecord);
}
public void addCallingInLandRecords(CallRecord callRecord){
callingInLandRecords.add(callRecord);
}
public void addAnswerInCityRecords(CallRecord answerRecord){
answerInCityRecords.add(answerRecord);
}
public void addAnswerInProvinceRecords(CallRecord answerRecord){
answerInProvinceRecords.add(answerRecord);
}
public void addAnswerInLandRecords(CallRecord answerRecord){
answerInLandRecords.add(answerRecord);
}
public void addSentMessageRecords(MessageRecord sendMessageRecords){}
public void addReceiveMessageRecords(MessageRecord receiveMessageRecords){}
public ArrayList<MessageRecord> getSendMessageRecords(){return sendMessageRecords;}
public ArrayList<MessageRecord> getReceiveMessageRecords(){return receiveMessageRecords;}
public ArrayList<CallRecord> getCallingInCityRecords(){return callingInCityRecords;}
public ArrayList<CallRecord> getCallingInProvinceRecords(){return callingInProvinceRecords;}
public ArrayList<CallRecord> getCallingInLandRecords(){return callingInLandRecords;}
public ArrayList<CallRecord> getAnswerInCityRecords(){return answerInCityRecords;}
public ArrayList<CallRecord> getAnswerInProvinceRecords(){return answerInProvinceRecords;}
public ArrayList<CallRecord> getAnswerInLandRecords(){return answerInLandRecords;}
}
View Code
大部分代码都是类图里面给出的，来看看类图吧
代码质量：
293行
报表 220
百分比分支报表 8.6
方法调用语句 76
带注释的百分比行 0.7
类和接口 13
每个类的方法 3.77
每个方法的平均语句数 2.43
最复杂方法的行号 15
最复杂方法的名称 main.main（）
最大复杂度 17
最深块的行号 69
最大区块深度 7
平均区块深度 2.05
平均复杂度 1.39
2，第七次作业（针对电信计费）
实现南昌市电信分公司的计费程序，假设该公司针对手机和座机用户分别采取了两种计费方案，分别如下：
1、针对市内座机用户采用的计费方式（与电信计费系列1内容相同）：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
假设本市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。
2、针对手机用户采用实时计费方式：
月租15元，市内省内接电话均免费，市内拨打市内电话0.1元/分钟，市内拨打省内电话0.2元/分钟，市内拨打省外电话0.3元/分钟，省内漫游打电话0.3元/分钟，省外漫游接听0.3元/分钟，省外漫游拨打0.6元/分钟；
注：被叫电话属于市内、省内还是国内由被叫电话的接听地点区号决定，比如以下案例中，南昌市手机用户13307912264在区号为020的广州接听了电话，主叫号码应被计算为拨打了一个省外长途，同时，手机用户13307912264也要被计算省外接听漫游费：
u-13307912264 1
t-079186330022 13307912264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
输入：
输入信息包括两种类型
1、逐行输入南昌市用户开户的信息，每行一个用户，含手机和座机用户
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐）
例如：u-079186300001 0
座机号码由区号和电话号码拼接而成，电话号码包含7-8位数字，区号最高位是0。
手机号码由11位数字构成，最高位是1。
本题在电信计费系列1基础上增加类型1-手机实时计费。
手机设置0或者座机设置成1，此种错误可不做判断。
2、逐行输入本月某些用户的通讯信息，通讯信息格式：
座机呼叫座机：t-主叫号码 接听号码 起始时间 结束时间
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四项内容之间以一个英文空格分隔，
时间必须符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat类。
输入格式增加手机接打电话以及收发短信的格式，手机接打电话的信息除了号码之外需要额外记录拨打/接听的地点的区号，比如：
座机打手机：
t-主叫号码 接听号码 接听地点区号 起始时间 结束时间
t-079186330022 13305862264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
手机互打：
t-主叫号码 拨号地点 接听号码 接听地点区号 起始时间 结束时间
t-18907910010 0791 13305862264 0371 2022.1.3 10:00:25 2022.1.3 10:05:11
注意：以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
输出：
根据输入的详细通讯信息，计算所有已开户的用户的当月费用（精确到小数点后2位，单位元）。假设每个用户初始余额是100元。
每条通讯、短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
本题只做格式的错误判断，无需做内容上不合理的判断，比如同一个电话两条通讯记录的时间有重合、开户号码非南昌市的号码等，此类情况都当成正确的输入计算。但时间的输入必须符合要求，比如不能输入2022.13.61 28:72:65。
建议类图：
参见图1、2、3：
图1
图1中User是用户类，包括属性：
userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。
ChargeMode是计费方式的抽象类：
chargeRules是计费方式所包含的各种计费规则的集合，ChargeRule类的定义见图3。
getMonthlyRent（）方法用于返回月租（monthlyRent）。
UserRecords是用户记录类，保存用户各种通话、短信的记录，
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是：
市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。
图2
图2中CommunicationRecord是抽象的通讯记录类：
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。CallRecord（通话记录类）包含属性：
通话的起始、结束时间以及
拨号地点的区号（callingAddressAreaCode）、接听地点的区号（answerAddressAreaCode）。
区号用于记录在哪个地点拨打和接听的电话。座机无法移动，就是本机区号，如果是手机号，则会有差异。
图3
图3是计费规则的相关类，这些类的核心方法是：
calCost（ArrayList<CallRecord> callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。
SendMessageRule是发送短信的计费规则类，用于计算发送短信的费用。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。
（提示：可以从UserRecords类中获取各种类型的callRecords）。
注意：以上图中所定义的类不是限定要求，根据实际需要自行补充或修改。
设计：
这次作业增加了手机计费，可以为座机打手机，座机打座机，手机打座机，手机打手机。从判断来看就需要考虑的异常全面，计费方式也增加了，手机增加了省内漫游和省外漫游，题目较复杂。从获取用户信息方面来看，需要设计五个正则表达式，分别为用户注册的，座机打手机，座机打座机，手机打座机，手机打手机（好像这样比较复杂，我看别人都是一部到位，通话记录一步到位）。我这样写代码很长，不建议分五个步骤，因为每个步骤里面有重复的东西，就是对在省内省外的判断，以及计算，冗长复杂，容易出错。对于类而言，我还增加了手机的计费规则，不用说也明白，这样又更麻烦了一些，搞得又要添加数组，又要添加规则，类图错综复杂，还不如放在上次的计费计算里面。
我这种复杂的方法经过漫长的编写还是拿到了分数
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Objects;
import java.util.Scanner;
public class Main {
public static void Print(double data) { //保留1位小数
DecimalFormat df = new DecimalFormat("0.0#");
df.setRoundingMode(RoundingMode.HALF_UP);
System.out.print(df.format(data));
}
public static void main(String[] args) {
String l_l = "t-0[0-9]{9,11}\\s" + "0[0-9]{9,11}\\s" +
"[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) " +
"(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) " +
"[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) " +
"(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$";
String l_m ="t-0[0-9]{9,11}\\s" + "1[0-9]{10}\\s" +"0[0-9]{2,3}\\s"+
"[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) " +
"(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) " +
"[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) " +
"(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$";
String m_m ="t-1[0-9]{10}\\s" + "0[0-9]{2,3}\\s" + "1[0-9]{10}\\s" +"0[0-9]{2,3}\\s"+
"[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) " +
"(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) " +
"[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) " +
"(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$";
String m_l ="t-1[0-9]{10}\\s"+ "0[0-9]{2,3}\\s" + "0[0-9]{9,11}\\s"+
"[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) " +
"(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) " +
"[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) " +
"(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$";
String gre1 = "u-[0-9]{10,12}\\s[0-2]";
ArrayList<User> user = new ArrayList<>();
Scanner in = new Scanner(System.in);
while (true) {
String str = in.nextLine();
if (str.equals("end")) break;
if (str.matches(gre1)) {
String[] array = str.split("-", 2);
String[] array1 = array[1].split(" ", 2);
String phone_number = array1[0];
boolean has_found = false;
for (User value : user) {
if (phone_number.equals(value.getNumber())) {
has_found = true;
break;
}
}
if (has_found) continue;
User u = new User();
u.setNumber(phone_number);
if (array1[1].equals("0")) {
u.setChargeMode(new LandlinePhoneCharging());
} else if (array1[1].equals("1")) {
u.setChargeMode(new MobilePhoneCharging());
}
user.add(u);
} else if (str.matches(l_l)) {
String[] array = str.split("-", 2);
String[] array1 = array[1].split(" ");
String phone_number = array1[0];
String phone_number1 = array1[1];
String start_time = array1[2] + " " + array1[3];
String end_time = array1[4] + " " + array1[5];
SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
Date date = null, date1 = null;
try {
date = sdf.parse(start_time);
} catch (ParseException e) {
e.printStackTrace();
}
try {
date1 = sdf.parse(end_time);
} catch (ParseException e) {
e.printStackTrace();
}
for (int i = 0; i < user.size(); i++) {
if (phone_number.equals(user.get(i).getNumber())) {
CallRecord callRecord = new CallRecord();
callRecord.setStartTime(date);
callRecord.setEndTime(date1);
callRecord.setCallingAddressAreaCode(phone_number.substring(0, 4));
callRecord.setAnswerAddressAreaCode(phone_number1.substring(0, 4));
if (callRecord.getAnswerAddressAreaCode().matches("0791")&&
callRecord.getCallingAddressAreaCode().matches("0791")) {
user.get(i).userRecords.addCallingInCityRecords(callRecord);
} else if (callRecord.getCallingAddressAreaCode().matches("0791")&&
callRecord.getAnswerAddressAreaCode().matches("(079[2-9]|(0701|0790))")) {
user.get(i).userRecords.addCallingInProvinceRecords(callRecord);
} else if(callRecord.getCallingAddressAreaCode().matches("0791")&&
!callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)")){
user.get(i).userRecords.addCallingInLandRecords(callRecord);
}
}
}
}else if(str.matches(l_m))
{
boolean flag=false;
String[] array = str.split("-", 2);
String[] array1 = array[1].split(" ");
String phone_number = array1[0];
String phone_number1 = array1[1];
String Pickup_location_area_code = array1[2];
String start_time = array1[3] + " " + array1[4];
String end_time = array1[5] + " " + array1[6];
SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
Date date = null, date1 = null;
try {
date = sdf.parse(start_time);
} catch (ParseException e) {
e.printStackTrace();
}
try {
date1 = sdf.parse(end_time);
} catch (ParseException e) {
e.printStackTrace();
}
CallRecord callRecord = new CallRecord();
callRecord.setStartTime(date);
callRecord.setEndTime(date1);
callRecord.setCallingAddressAreaCode(phone_number.substring(0, 4));
callRecord.setAnswerAddressAreaCode(Pickup_location_area_code);
for (int i = 0; i < user.size(); i++) {//添加通话记录
if (phone_number.equals(user.get(i).getNumber())) {
if (callRecord.getAnswerAddressAreaCode().matches("0791")&&
callRecord.getCallingAddressAreaCode().matches("0791")) {
user.get(i).userRecords.addCallingInCityRecords(callRecord);flag=true;
} else if (callRecord.getCallingAddressAreaCode().matches("0791")&&
callRecord.getAnswerAddressAreaCode().matches("(079[2-9]|(0701|0790))")) {
user.get(i).userRecords.addCallingInProvinceRecords(callRecord);flag=true;
} else if(callRecord.getCallingAddressAreaCode().matches("0791")&&
!callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)")){
for(int j=0;j<user.size();j++)
if(user.get(j).getNumber().equals(phone_number1))
user.get(j).userRecords.addCallingInLandRoamingAnswerRecords(callRecord);
user.get(i).userRecords.addCallingInLandRecords(callRecord);flag=true;
}
}
}
if(flag)continue;
for (int j=0;j<user.size();j++)
{
if(phone_number1.equals(user.get(j).getNumber())) {
if(!callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)"))
{
for(int k=0;k<user.size();k++)
if(user.get(k).getNumber().equals(phone_number1))
user.get(k).userRecords.addCallingInLandRoamingAnswerRecords(callRecord);
}
}
}
} else if (str.matches(m_l)) {
String[] array = str.split("-", 2);
String[] array1 = array[1].split(" ");
String phone_number = array1[0];
String Pickup_location_area_code= array1[1];
String phone_number1 = array1[2];
String start_time = array1[3] + " " + array1[4];
String end_time = array1[5] + " " + array1[6];
SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
Date date = null, date1 = null;
try {
date = sdf.parse(start_time);
} catch (ParseException e) {
e.printStackTrace();
}
try {
date1 = sdf.parse(end_time);
} catch (ParseException e) {
e.printStackTrace();
}
CallRecord callRecord = new CallRecord();
callRecord.setStartTime(date);
callRecord.setEndTime(date1);
callRecord.setCallingAddressAreaCode(Pickup_location_area_code);
callRecord.setAnswerAddressAreaCode(phone_number1.substring(0, 4));
for (int i = 0; i < user.size(); i++) {//添加通话记录
if (phone_number.equals(user.get(i).getNumber())) {
if (callRecord.getAnswerAddressAreaCode().matches("0791")&&
callRecord.getCallingAddressAreaCode().matches("0791")) {
user.get(i).userRecords.addCallingInCityRecords(callRecord);
} else if (callRecord.getCallingAddressAreaCode().matches("0791")&&
callRecord.getAnswerAddressAreaCode().matches("(079[2-9]|(0701|0790))")) {
user.get(i).userRecords.addCallingInProvinceRecords(callRecord);
} else if (callRecord.getCallingAddressAreaCode().matches("0791")&&
!callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)")){
user.get(i).userRecords.addCallingInLandRecords(callRecord);
} else if (callRecord.getCallingAddressAreaCode().matches("(079[2-9]|(0701|0790))")) {
user.get(i).userRecords.addCallingInProvinceRoamingDialRecords(callRecord);
}else if (!callRecord.getCallingAddressAreaCode().matches("(079[0-9]|0701)")) {
user.get(i).userRecords.addCallingInLandRoamingDialRecords(callRecord);
}
}
}
} else if (str.matches(m_m)) {
boolean flag=false;
String[] array = str.split("-", 2);
String[] array1 = array[1].split(" ");
String phone_number = array1[0];
String Pickup_location_area_code =array1[1];
String phone_number1 = array1[2];
String Pickup_location_area_code1 =array1[3];
String start_time = array1[4] + " " + array1[5];
String end_time = array1[6] + " " + array1[7];
SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
Date date = null, date1 = null;
try {
date = sdf.parse(start_time);
} catch (ParseException e) {
e.printStackTrace();
}
try {
date1 = sdf.parse(end_time);
} catch (ParseException e) {
e.printStackTrace();
}
CallRecord callRecord = new CallRecord();
callRecord.setStartTime(date);
callRecord.setEndTime(date1);
callRecord.setCallingAddressAreaCode(Pickup_location_area_code);
callRecord.setAnswerAddressAreaCode(Pickup_location_area_code1);
for (int i = 0; i < user.size(); i++) {//添加通话记录
if (phone_number.equals(user.get(i).getNumber())) {
if (callRecord.getAnswerAddressAreaCode().matches("0791")&&
callRecord.getCallingAddressAreaCode().matches("0791")) {
user.get(i).userRecords.addCallingInCityRecords(callRecord);flag=true;
} else if (callRecord.getCallingAddressAreaCode().matches("0791")&&
callRecord.getAnswerAddressAreaCode().matches("(079[2-9]|(0701|0790))")) {
user.get(i).userRecords.addCallingInProvinceRecords(callRecord);flag=true;
} else if(callRecord.getCallingAddressAreaCode().matches("0791")&&
!callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)")){
for(int j=0;j<user.size();j++)
if(user.get(j).getNumber().equals(phone_number1))
user.get(j).userRecords.addCallingInLandRoamingAnswerRecords(callRecord);
user.get(i).userRecords.addCallingInLandRecords(callRecord);flag=true;
} else if (callRecord.getCallingAddressAreaCode().matches("(079[2-9]|(0701|0790))")) {
if(!callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)"))
{
for(int j=0;j<user.size();j++)
if(user.get(j).getNumber().equals(phone_number1))
user.get(j).userRecords.addCallingInLandRoamingAnswerRecords(callRecord);
}
user.get(i).userRecords.addCallingInProvinceRoamingDialRecords(callRecord);flag=true;
} else if (!callRecord.getCallingAddressAreaCode().matches("(079[0-9]|0701)")) {
if(!callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)"))
{
for(int j=0;j<user.size();j++)
if(user.get(j).getNumber().equals(phone_number1))
user.get(j).userRecords.addCallingInLandRoamingAnswerRecords(callRecord);
}
user.get(i).userRecords.addCallingInLandRoamingDialRecords(callRecord);flag=true;
}
}
}
if(flag)continue;
for (int j=0;j<user.size();j++)
{
if(phone_number1.equals(user.get(j).getNumber())) {
if(!callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)"))
{
for(int k=0;k<user.size();k++)
if(user.get(k).getNumber().equals(phone_number1))
user.get(k).userRecords.addCallingInLandRoamingAnswerRecords(callRecord);
}
}
}
}
}
user.sort((user1,user2)->user1.getNumber().compareTo(user2.getNumber()));
for (int i = 0; i < user.size(); i++) {
System.out.print(user.get(i).getNumber() + " ");
Print(user.get(i).calCost());
System.out.print(" ");
Print(user.get(i).calBalance());
System.out.println();
}
}
}
abstract class CallChargeRule extends ChargeRule{
}
class CallRecord extends CommunicationRecord{
Date startTime;
Date endTime;
String callingAddressAreaCode;
String answerAddressAreaCode;
public Date getStartTime(){
return startTime;
}
public void setStartTime(Date startTime){
this.startTime=startTime;
}
public Date getEndTime(){
return endTime;
}
public void setEndTime(Date endTime){
this.endTime=endTime;
}
public String getCallingAddressAreaCode(){
return callingAddressAreaCode;
}
public void setCallingAddressAreaCode(String callingAddressAreaCode){
this.callingAddressAreaCode=callingAddressAreaCode;
}
public String getAnswerAddressAreaCode(){
return answerAddressAreaCode;
}
public void setAnswerAddressAreaCode(String answerAddressAreaCode){
this.answerAddressAreaCode=answerAddressAreaCode;
}
}
abstract class ChargeMode {
ArrayList<ChargeRule> ChargeRules=new ArrayList<>();
public ArrayList<ChargeRule> getChargeRules(){
return ChargeRules;
}
public void setChargeRules(ArrayList<ChargeRule> ChargeRules){
this.ChargeRules=ChargeRules;
}
public abstract double calCost(UserRecords userRecords);
public abstract double getMonthlyRent();
}
abstract class ChargeRule {
public abstract double calCost(ArrayList<CallRecord> callRecords);
}
abstract class CommunicationRecord {
protected String callingNumber;
protected String answerNumber;
public String getCallingNumber(){
return callingNumber;
}
public void setCallingNumber(String callingNumber){
this.callingNumber=callingNumber;
}
public String getAnswerNumber(){
return answerNumber;
}
public void setAnswerNumber(String answerNumber){
this.answerNumber=answerNumber;
}
}
class LandlinePhoneCharging extends ChargeMode{
double monthlyRent=20;
public LandlinePhoneCharging(){
ChargeRules.add(new LandPhoneInCityRule());
ChargeRules.add(new LandPhoneInProvinceRule());
ChargeRules.add(new LandPhoneInLandRule());
}
@Override
public double calCost(UserRecords userRecords){//三种收费方式加起来的钱
double sum_cost=0;
sum_cost += ChargeRules.get(0).calCost(userRecords.callingInCityRecords);
sum_cost += ChargeRules.get(1).calCost(userRecords.callingInProvinceRecords);
sum_cost += ChargeRules.get(2).calCost(userRecords.callingInLandRecords);
return sum_cost;
}
@Override
public double getMonthlyRent(){
return monthlyRent;
}
}
class LandPhoneInCityRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.1;
}
}
class LandPhoneInLandRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.6;
}
}
class LandPhoneInProvinceRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
//System.out.println(Math.ceil(sum)*0.3);
return sum*0.3;
}
}
class MessageRecord extends CommunicationRecord{
String message;
public String getMessage(){
return null;
}
public void setMessage(String message){
};
}
class MobilePhoneCharging extends ChargeMode{
double monthlyRent=15;
public MobilePhoneCharging(){
ChargeRules.add(new MobilePhoneInCityRule());
ChargeRules.add(new MobilePhoneInProvinceRule());
ChargeRules.add(new MobilePhoneInLandRule());
ChargeRules.add(new MobilePhoneInProvinceRoamingDials());
ChargeRules.add(new MobilePhoneInLandRoamingAnswering());
ChargeRules.add(new MobilePhoneInLandRoamingDials());
}
@Override
public double calCost(UserRecords userRecords) {
double sum_cost=0;
sum_cost += ChargeRules.get(0).calCost(userRecords.callingInCityRecords);
sum_cost += ChargeRules.get(1).calCost(userRecords.callingInProvinceRecords);
sum_cost += ChargeRules.get(2).calCost(userRecords.callingInLandRecords);
sum_cost += ChargeRules.get(3).calCost(userRecords.callingInProvinceRoamingDialRecords);
sum_cost += ChargeRules.get(4).calCost(userRecords.callingInLandRoamingAnswerRecords);
sum_cost += ChargeRules.get(5).calCost(userRecords.callingInLandRoamingDialRecords);
return sum_cost;
}
@Override
public double getMonthlyRent() {
return this.monthlyRent;
}
}
class MobilePhoneInCityRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.1;
}
}
class MobilePhoneInLandRoamingAnswering extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.3;
}
}
class MobilePhoneInLandRoamingDials extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.6;
}
}
class MobilePhoneInLandRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.3;
}
}
class MobilePhoneInProvinceRoamingDials extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.3;
}
}
class MobilePhoneInProvinceRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.2;
}
}
class User {
UserRecords userRecords=new UserRecords();
private final double balance=100;
private ChargeMode chargeMode;
private String number;
public double calBalance(){
return this.balance-this.calCost()-chargeMode.getMonthlyRent();
}
public double calCost(){
return chargeMode.calCost(userRecords);
}
public UserRecords getUserRecords(){
return this.userRecords;
}
public void setUserRecord(UserRecords userRecords){
this.userRecords=userRecords;
}
public ChargeMode getChargeMode(){
return chargeMode;
}
public double getBalance(){
return this.balance;
}
public void setChargeMode(ChargeMode chargeMode){
this.chargeMode=chargeMode;
}
public String getNumber(){
return this.number;
}
public void setNumber(String number){
this.number=number;
}
}
class UserRecords {
ArrayList<CallRecord> callingInCityRecords=new ArrayList<CallRecord>();//市对市记录
ArrayList<CallRecord> callingInProvinceRecords=new ArrayList<CallRecord>();//市对省内记录
ArrayList<CallRecord> callingInLandRecords=new ArrayList<CallRecord>();//市对省外记录
ArrayList<CallRecord> answerInCityRecords=new ArrayList<CallRecord>();
ArrayList<CallRecord> answerInProvinceRecords=new ArrayList<CallRecord>();
ArrayList<CallRecord> answerInLandRecords=new ArrayList<CallRecord>();
ArrayList<MessageRecord> sendMessageRecords=new ArrayList<MessageRecord>();
ArrayList<MessageRecord> receiveMessageRecords=new ArrayList<MessageRecord>();
ArrayList<CallRecord> callingInProvinceRoamingDialRecords=new ArrayList<CallRecord>();//省内漫游拨打记录
ArrayList<CallRecord> callingInLandRoamingAnswerRecords=new ArrayList<CallRecord>();//省外漫游接听记录
ArrayList<CallRecord> callingInLandRoamingDialRecords=new ArrayList<CallRecord>();//省外漫游拨打记录
public void addCallingInLandRoamingDialRecords(CallRecord callRecord){
callingInLandRoamingDialRecords.add(callRecord);
}
public void addCallingInLandRoamingAnswerRecords(CallRecord callRecord){
callingInLandRoamingAnswerRecords.add(callRecord);
}
public void addCallingInProvinceRoamingDialRecords(CallRecord callRecord){
callingInProvinceRoamingDialRecords.add(callRecord);
}
public void addCallingInCityRecords(CallRecord callRecord){
callingInCityRecords.add(callRecord);
}
public void addCallingInProvinceRecords(CallRecord callRecord){
callingInProvinceRecords.add(callRecord);
}
public void addCallingInLandRecords(CallRecord callRecord){
callingInLandRecords.add(callRecord);
}
public void addAnswerInCityRecords(CallRecord answerRecord){
answerInCityRecords.add(answerRecord);
}
public void addAnswerInProvinceRecords(CallRecord answerRecord){
answerInProvinceRecords.add(answerRecord);
}
public void addAnswerInLandRecords(CallRecord answerRecord){
answerInLandRecords.add(answerRecord);
}
public void addSentMessageRecords(MessageRecord sendMessageRecords){}
public void addReceiveMessageRecords(MessageRecord receiveMessageRecords){}
public ArrayList<MessageRecord> getSendMessageRecords(){return sendMessageRecords;}
public ArrayList<MessageRecord> getReceiveMessageRecords(){return receiveMessageRecords;}
public ArrayList<CallRecord> getCallingInCityRecords(){return callingInCityRecords;}
public ArrayList<CallRecord> getCallingInProvinceRecords(){return callingInProvinceRecords;}
public ArrayList<CallRecord> getCallingInLandRecords(){return callingInLandRecords;}
public ArrayList<CallRecord> getAnswerInCityRecords(){return answerInCityRecords;}
public ArrayList<CallRecord> getAnswerInProvinceRecords(){return answerInProvinceRecords;}
public ArrayList<CallRecord> getAnswerInLandRecords(){return answerInLandRecords;}
}
View Code
类图：
代码质量：
595行
报表 447
分支报表百分比 17.0
方法调用语句 267
带注释的百分比行 1.8
类和接口 20
每个类的方法 3.05
每个方法的平均语句数 5.18
最复杂方法的行号 17
最复杂方法的名称 main.main（）
最大复杂度 80
最深块线号 246
最大区块深度 9+
平均区块深度 3.01
平均复杂度 2.44
3，第八次作业（针对电信计费）
实现一个简单的电信计费程序，针对手机的短信采用如下计费方式：
1、接收短信免费，发送短信0.1元/条，超过3条0.2元/条，超过5条0.3元/条。
2、如果一次发送短信的字符数量超过10个，按每10个字符一条短信进行计算。
输入：
输入信息包括两种类型
1、逐行输入南昌市手机用户开户的信息，每行一个用户。
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐 3-手机短信计费）
例如：u-13305862264 3
座机号码由区号和电话号码拼接而成，电话号码包含7-8位数字，区号最高位是0。
手机号码由11位数字构成，最高位是1。
本题只针对类型3-手机短信计费。
2、逐行输入本月某些用户的短信信息，短信的格式：
m-主叫号码，接收号码，短信内容 （短信内容只能由数字、字母、空格、英文逗号、英文句号组成）
m-18907910010 13305862264 welcome to jiangxi.
m-13305862264 18907910010 thank you.
注意：以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
输出：
根据输入的详细短信信息，计算所有已开户的用户的当月短信费用（精确到小数点后2位，单位元）。假设每个用户初始余额是100元。
每条短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
本题只做格式的错误判断，无需做内容上不合理的判断，比如同一个电话两条通讯记录的时间有重合、开户号码非南昌市的号码、自己给自己打电话等，此类情况都当成正确的输入计算。但时间的输入必须符合要求，比如不能输入2022.13.61 28:72:65。
本题只考虑短信计费，不考虑通信费用以及月租费。
建议类图：
参见图1、2、3：
图1
图1中User是用户类，包括属性：
userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。
ChargeMode是计费方式的抽象类：
chargeRules是计费方式所包含的各种计费规则的集合，ChargeRule类的定义见图3。
getMonthlyRent（）方法用于返回月租（monthlyRent）。
UserRecords是用户记录类，保存用户各种通话、短信的记录，
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是：
市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。
图2
图2中CommunicationRecord是抽象的通讯记录类：
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。
图3
图3是计费规则的相关类，这些类的核心方法是：
calCost（ArrayList callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。
SendMessageRule是发送短信的计费规则类，用于计算发送短信的费用。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。
（提示：可以从UserRecords类中获取各种类型的callRecords）。
注意：以上图中所定义的类不是限定要求，根据实际需要自行补充或修改。
设计：
这题比较简单，只有短信计费，十个字记一次钱，发送短信0.1元/条，超过3条0.2元/条，超过5条0.3元/条，如果一次发送短信的字符数量超过10个，按每10个字符一条短信进行计算。加一个短信计费类型，在里面算出字符的个数再进行算钱，思路大概就是这样。然后在主函数里面把之前的删掉，改为一个短信计费的正则表达式即可。记录为短信记录。
相比于前两题还是很简单的
源码
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Objects;
import java.util.Scanner;
public class Main {
public static void Print(double data) { //保留1位小数
DecimalFormat df = new DecimalFormat("0.0#");
df.setRoundingMode(RoundingMode.HALF_UP);
System.out.print(df.format(data));
}
public static void main(String[] args) {
String message ="m-1[0-9]{10}\\s"+"1[0-9]{10}\\s"+"[\\w\\s\\.,]+";
String gre1 = "u-1[0-9]{10}\\s3";
ArrayList<User> user = new ArrayList<>();
Scanner in = new Scanner(System.in);
while (true) {
String str = in.nextLine();
if (str.equals("end")) break;
if (str.matches(gre1)) {
String[] array = str.split("-", 2);
String[] array1 = array[1].split(" ", 2);
String phone_number = array1[0];
boolean has_found = false;
for (User value : user) {
if (phone_number.equals(value.getNumber())) {
has_found = true;
break;
}
}
if (has_found) continue;
User u = new User();
u.setNumber(phone_number);
if (array1[1].equals("0")) {
u.setChargeMode(new LandlinePhoneCharging());
} else if (array1[1].equals("1")) {
u.setChargeMode(new MobilePhoneCharging());
}else if (array1[1].equals("3")) {
u.setChargeMode(new SendMessageCharging());
}
user.add(u);
}else if (str.matches(message)){
String[] array = str.split("-", 2);
String[] array1 = array[1].split(" ",3);
String phone_number = array1[0];
String phone_number1 = array1[1];
String Message = array1[2];
MessageRecord messageRecord = new MessageRecord();
messageRecord.setMessage(Message);
for (int i = 0; i < user.size(); i++)
{
if (phone_number.equals(user.get(i).getNumber()))
{
user.get(i).userRecords.addSentMessageRecords(messageRecord);
}
}
}
}
user.sort((user1,user2)->user1.getNumber().compareTo(user2.getNumber()));
for (int i = 0; i < user.size(); i++) {
System.out.print(user.get(i).getNumber() + " ");
Print(user.get(i).calCost());
System.out.print(" ");
Print(user.get(i).calBalance());
System.out.println();
}
}
}
abstract class CallChargeRule extends ChargeRule{
}class CallRecord extends CommunicationRecord{
Date startTime;
Date endTime;
String callingAddressAreaCode;
String answerAddressAreaCode;
public Date getStartTime(){
return startTime;
}
public void setStartTime(Date startTime){
this.startTime=startTime;
}
public Date getEndTime(){
return endTime;
}
public void setEndTime(Date endTime){
this.endTime=endTime;
}
public String getCallingAddressAreaCode(){
return callingAddressAreaCode;
}
public void setCallingAddressAreaCode(String callingAddressAreaCode){
this.callingAddressAreaCode=callingAddressAreaCode;
}
public String getAnswerAddressAreaCode(){
return answerAddressAreaCode;
}
public void setAnswerAddressAreaCode(String answerAddressAreaCode){
this.answerAddressAreaCode=answerAddressAreaCode;
}
}
abstract class ChargeMode {
ArrayList<ChargeRule> ChargeRules=new ArrayList<>();
public ArrayList<ChargeRule> getChargeRules(){
return ChargeRules;
}
public void setChargeRules(ArrayList<ChargeRule> ChargeRules){
this.ChargeRules=ChargeRules;
}
public abstract double calCost(UserRecords userRecords);
public abstract double getMonthlyRent();
}
abstract class ChargeRule {
public abstract double calCost(ArrayList<CallRecord> callRecords);
public abstract double calCost1(ArrayList<MessageRecord> messageRecords);
}
abstract class CommunicationRecord {
protected String callingNumber;
protected String answerNumber;
public String getCallingNumber(){
return callingNumber;
}
public void setCallingNumber(String callingNumber){
this.callingNumber=callingNumber;
}
public String getAnswerNumber(){
return answerNumber;
}
public void setAnswerNumber(String answerNumber){
this.answerNumber=answerNumber;
}
}
class LandlinePhoneCharging extends ChargeMode{
double monthlyRent=20;
public LandlinePhoneCharging(){
ChargeRules.add(new LandPhoneInCityRule());
ChargeRules.add(new LandPhoneInProvinceRule());
ChargeRules.add(new LandPhoneInLandRule());
}
@Override
public double calCost(UserRecords userRecords){//三种收费方式加起来的钱
double sum_cost=0;
sum_cost += ChargeRules.get(0).calCost(userRecords.callingInCityRecords);
sum_cost += ChargeRules.get(1).calCost(userRecords.callingInProvinceRecords);
sum_cost += ChargeRules.get(2).calCost(userRecords.callingInLandRecords);
return sum_cost;
}
@Override
public double getMonthlyRent(){
return monthlyRent;
}
}
class LandPhoneInCityRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.1;
}
@Override
public double calCost1(ArrayList<MessageRecord> messageRecords) {
return 0;
}
}class LandPhoneInLandRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.6;
} @Override
public double calCost1(ArrayList<MessageRecord> messageRecords) {
return 0;
}
}
class LandPhoneInProvinceRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
//System.out.println(Math.ceil(sum)*0.3);
return sum*0.3;
} @Override
public double calCost1(ArrayList<MessageRecord> messageRecords) {
return 0;
}
} abstract class MessageChargeRule extends ChargeRule{
} class MessageRecord extends CommunicationRecord{
String message;
public String getMessage(){
return message;
}
public void setMessage(String message){
this.message=message;
};
}
class MobilePhoneCharging extends ChargeMode{
double monthlyRent=15;
public MobilePhoneCharging(){
ChargeRules.add(new MobilePhoneInCityRule());
ChargeRules.add(new MobilePhoneInProvinceRule());
ChargeRules.add(new MobilePhoneInLandRule());
ChargeRules.add(new MobilePhoneInProvinceRoamingDials());
ChargeRules.add(new MobilePhoneInLandRoamingAnswering());
ChargeRules.add(new MobilePhoneInLandRoamingDials());
}
@Override
public double calCost(UserRecords userRecords) {
double sum_cost=0;
sum_cost += ChargeRules.get(0).calCost(userRecords.callingInCityRecords);
sum_cost += ChargeRules.get(1).calCost(userRecords.callingInProvinceRecords);
sum_cost += ChargeRules.get(2).calCost(userRecords.callingInLandRecords);
sum_cost += ChargeRules.get(3).calCost(userRecords.callingInProvinceRoamingDialRecords);
sum_cost += ChargeRules.get(4).calCost(userRecords.callingInLandRoamingAnswerRecords);
sum_cost += ChargeRules.get(5).calCost(userRecords.callingInLandRoamingDialRecords);
return sum_cost;
}
@Override
public double getMonthlyRent() {
return this.monthlyRent;
}
}
class MobilePhoneInCityRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.1;
} @Override
public double calCost1(ArrayList<MessageRecord> messageRecords) {
return 0;
}
}
class MobilePhoneInLandRoamingAnswering extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.3;
} @Override
public double calCost1(ArrayList<MessageRecord> messageRecords) {
return 0;
}
}
class MobilePhoneInLandRoamingDials extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.6;
} @Override
public double calCost1(ArrayList<MessageRecord> messageRecords) {
return 0;
}
}
class MobilePhoneInLandRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.3;
} @Override
public double calCost1(ArrayList<MessageRecord> messageRecords) {
return 0;
}
}
class MobilePhoneInProvinceRoamingDials extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.3;
} @Override
public double calCost1(ArrayList<MessageRecord> messageRecords) {
return 0;
}
}
class MobilePhoneInProvinceRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double sum=0;
for (int i=0;i<callRecords.size();i++) {
sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
sum=Math.ceil(sum);
}
return Math.ceil(sum)*0.2;
} @Override
public double calCost1(ArrayList<MessageRecord> messageRecords) {
return 0;
}
}
class SendMessageCharging extends ChargeMode{
public SendMessageCharging() {
ChargeRules.add(new SendMessageRule());
}
@Override
public double calCost(UserRecords userRecords) {
double sum_cost=0;
sum_cost += ChargeRules.get(0).calCost1(userRecords.sendMessageRecords);
return sum_cost;
}
@Override
public double getMonthlyRent() {
return 0;
}
}
class SendMessageRule extends MessageChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
return 0;
}
@Override
public double calCost1(ArrayList<MessageRecord> messageRecords) {
int messageNumber=0;
for(int i=0;i<messageRecords.size();i++)
messageNumber+=Math.ceil(messageRecords.get(i).getMessage().length()/10.0);
if(messageNumber<=3)
{
return messageNumber*0.1;
} else if (messageNumber<=5) {
return 0.3+(messageNumber-3)*0.2;
}else {
return 0.3+2*0.2+(messageNumber-5)*0.3;
}
}
}
class User {
UserRecords userRecords=new UserRecords();
private final double balance=100;
private ChargeMode chargeMode;
private String number;
public double calBalance(){
return this.balance-this.calCost()-chargeMode.getMonthlyRent();
}
public double calCost(){
return chargeMode.calCost(userRecords);
}
public UserRecords getUserRecords(){
return this.userRecords;
}
public void setUserRecord(UserRecords userRecords){
this.userRecords=userRecords;
}
public ChargeMode getChargeMode(){
return chargeMode;
}
public double getBalance(){
return this.balance;
}
public void setChargeMode(ChargeMode chargeMode){
this.chargeMode=chargeMode;
}
public String getNumber(){
return this.number;
}
public void setNumber(String number){
this.number=number;
}
}
class UserRecords {
ArrayList<CallRecord> callingInCityRecords=new ArrayList<CallRecord>();//市对市记录
ArrayList<CallRecord> callingInProvinceRecords=new ArrayList<CallRecord>();//市对省内记录
ArrayList<CallRecord> callingInLandRecords=new ArrayList<CallRecord>();//市对省外记录
ArrayList<CallRecord> answerInCityRecords=new ArrayList<CallRecord>();
ArrayList<CallRecord> answerInProvinceRecords=new ArrayList<CallRecord>();
ArrayList<CallRecord> answerInLandRecords=new ArrayList<CallRecord>();
ArrayList<MessageRecord> sendMessageRecords=new ArrayList<MessageRecord>();
ArrayList<MessageRecord> receiveMessageRecords=new ArrayList<MessageRecord>();
ArrayList<CallRecord> callingInProvinceRoamingDialRecords=new ArrayList<CallRecord>();//省内漫游拨打记录
ArrayList<CallRecord> callingInLandRoamingAnswerRecords=new ArrayList<CallRecord>();//省外漫游接听记录
ArrayList<CallRecord> callingInLandRoamingDialRecords=new ArrayList<CallRecord>();//省外漫游拨打记录
public void addCallingInLandRoamingDialRecords(CallRecord callRecord){
callingInLandRoamingDialRecords.add(callRecord);
}
public void addCallingInLandRoamingAnswerRecords(CallRecord callRecord){
callingInLandRoamingAnswerRecords.add(callRecord);
}
public void addCallingInProvinceRoamingDialRecords(CallRecord callRecord){
callingInProvinceRoamingDialRecords.add(callRecord);
}
public void addCallingInCityRecords(CallRecord callRecord){
callingInCityRecords.add(callRecord);
}
public void addCallingInProvinceRecords(CallRecord callRecord){
callingInProvinceRecords.add(callRecord);
}
public void addCallingInLandRecords(CallRecord callRecord){
callingInLandRecords.add(callRecord);
}
public void addAnswerInCityRecords(CallRecord answerRecord){
answerInCityRecords.add(answerRecord);
}
public void addAnswerInProvinceRecords(CallRecord answerRecord){
answerInProvinceRecords.add(answerRecord);
}
public void addAnswerInLandRecords(CallRecord answerRecord){
answerInLandRecords.add(answerRecord);
}
public void addSentMessageRecords(MessageRecord MessageRecords){
sendMessageRecords.add(MessageRecords);
}
public void addReceiveMessageRecords(MessageRecord receiveMessageRecords){}
public ArrayList<MessageRecord> getSendMessageRecords(){return sendMessageRecords;}
public ArrayList<MessageRecord> getReceiveMessageRecords(){return receiveMessageRecords;}
public ArrayList<CallRecord> getCallingInCityRecords(){return callingInCityRecords;}
public ArrayList<CallRecord> getCallingInProvinceRecords(){return callingInProvinceRecords;}
public ArrayList<CallRecord> getCallingInLandRecords(){return callingInLandRecords;}
public ArrayList<CallRecord> getAnswerInCityRecords(){return answerInCityRecords;}
public ArrayList<CallRecord> getAnswerInProvinceRecords(){return answerInProvinceRecords;}
public ArrayList<CallRecord> getAnswerInLandRecords(){return answerInLandRecords;}
}
View Code
类图：
代码质量：
449行
报表 342
分支报表百分比 7.6
方法调用语句 109
带注释的百分比行 1.8
类和接口 23
每个类的方法 3.26
每个方法的平均语句数 2.40
最复杂方法的行号 17
最复杂方法的名称 main.main（）
最大复杂度 14
最深块线号 32
最大块深度 6
平均区块深度 1.70
平均复杂度 1.35
三，采坑心得
这三次作业里面好像也没有特别阴间的地方，只需要按照类图来写就可以
在我第二次电信计费的时候有一个点一直过不去，
就是这里，这里是省内漫游的一个点，主要是我对省内漫游理解错了，省内漫游就是省内打拨号者打给任意的地方即为省内漫游，而我一来的是省内对省内的理解为漫游，所以这个点一直过不去。后面发现错误改正过来了。
然后就是第三次作业，写完代码之后有几个点一直过不去，起初以为是在正则表达式没有判断全面
但是后来发现是自己算错了，好离谱，计算超过5条的，没有减去之前5条以内的，后面改正过来了。
四，改进建议
我觉得最需要改进的地方是这里
采用大量正则表达式区分每一种情况，然后就是区分完每一种情况之后呢，又发现每一种情况判断在省内省外有相同之处，所以说还是采用一步到位的正则表达式比较好
这些步骤真的有好多重复的地方，可以写到一个方法里面
五，总结
经过了一个一个学期的学习，Java的学习到这里也就结束了，最后三次大作业让我编写类的思维更加清晰，更懂得如何把类直接连在一起
在学习Java的过程中我得出这样的结论：1. 学习中，要养成良好的习惯（写括号时要成对，字母大小写要区分，单词拼写要准确）。
2． 在学习的过程中，最好不是仅仅停留在java表层，不是抄书上的例子运行出结果就可以。要注意，即便对一个简单的例子也要有耐心去琢磨、调试、改动。
3． 在学习的过程中一定要动手做、试着写代码，而不是抱着老师的讲义看看就行。很多东西和体会必须自己动手才能真正属于自己。
4. 课程收获。学习Java这一学期以来，最大的感受是痛苦并快乐着(以后可能更痛苦。。)，痛苦是写不出来啊！狂抓也没用的那种！快乐是代码这种东西写出来运行一下，结果正确，那种成就感真的没法表达，还有一个意想不到收获就是CSDN，自己敲出来的代码有那么多的阅读量，真的很开心（虽然是照着老师的讲义敲的）
5. 在 Java 的学习过程中，可能会遇到形形色色的问题不容易解决，应多去专业论坛了解相关的知识，书本上的知识有限。要会从网上搜索有用的信息 加以整理，促进学习的深入和知识水平的提高。
看了好多网上课程，说学到一定程度要尝试着自己做东西，但觉得自己仅仅经过一学期的学习，还远远不够，希望自己在以后学习中继续努力，能够真真正正拥有一门编程语言，对自己今后的发展起到作用。在学习java语言的同时，也让我学会了如何来发现问题，如何解决问题，怎样有效的学习等等，相信会对我一生都有帮助。
标签：总结,题目,String,ArrayList,callRecord,PTA,计费,new,public From： https://www.cnblogs.com/song-lin/p/16972089.html