题目集6-8（电信计费）
前言：
这几次是电信计费系列的问题，主要是让我们熟悉抽象类、父类继承、接口和容器等方面的知识，同时也考察了我们将类图转化为代码的能力。这个系列的问题比较贴近我们的生活，让我们能联系实际来考虑问题，同时也提高了我们对问题设计的能力。本系列题目总体来说难度不是特别大，只要能弄清楚各个类代表什么并且理清各个类之间的关系，后续只需添加方法即可。
设计与分析：
题目6.7-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
图3是计费规则的相关类，这些类的核心方法是：
calCost（ArrayList<CallRecord> callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是
座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。
（提示：可以从UserRecords类中获取各种类型的callRecords）。
源代码（类图中给出的部分不做具体展示）：
市内通话计费规则
class LandPhoneInCityRule extends CallChargeRule{ @Override public double calCost (ArrayList<CallRecord> callRecords){ double sum = 0; for(CallRecord c : callRecords){ sum += 0.1 * ( (((c.getEndTime().getTime()-c.getStartTime().getTime())/1000)+59) / 60); } return sum; } }
省内通话计费规则
class LandPhoneInProvinceRule extends CallChargeRule{ @Override public double calCost (ArrayList<CallRecord> callRecords){ double sum = 0; for(CallRecord c : callRecords){ sum += 0.3 * ( (((c.getEndTime().getTime()-c.getStartTime().getTime())/1000)+59) / 60); } return sum; } }
国内通话计费规则
class LandPhoneInlandRule extends CallChargeRule{ @Override public double calCost (ArrayList<CallRecord> callRecords){ double sum = 0; for(CallRecord c : callRecords){ sum += 0.6 * ( (((c.getEndTime().getTime()-c.getStartTime().getTime())/1000)+59) / 60); } return sum; } }
判断输入的信息属于哪种类型
public static int select(String s){ if(s.matches("u-079[0-9][0-9]{7,8}\\s0") || s.matches("u-0701[0-9]{7,8}\\s0")) return 0; else if(s.matches("t-[0-9]{10,12}\\s[0-9]{10,12}\\s[0-9]{4}.([1-9]||1[0-2]).([1-9]||[1-2][0-9]||3[01])\\s[0-9]{2}.[0-9]{2}.[0-9]{2}\\s[0-9]{4}.([1-9]||1[0-2]).([1-9]||[1-2][0-9]||3[01])\\s[0-9]{2}.[0-9]{2}.[0-9]{2}")) return 1; else return 2; }
确认日期
public static boolean riQiCheck(String str){ SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss"); sdf.setLenient(false); try{ sdf.parse(str); }catch(Exception e){ return false; } return true; }
写入用户
public static void writeUser(ArrayList<User> list, String s){ User newuser = new User(); String tokens[] = s.split(" "); newuser.setNumber(tokens[0].substring(2)); int count = 0; for(User u : list){ if(u.getNumber().equals(newuser.getNumber())){ count++; break; } } if(count==0){ list.add(newuser); } }
写入记录
public static void writeRecords(ArrayList<User> list, String s){ String tokens[] = s.split(" "); String startTime = tokens[2]+" "+tokens[3]; String endTime = tokens[4]+" "+tokens[5]; Date startTime1 = new Date(); Date endTime1 = new Date(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss"); sdf.setLenient(false); try{ startTime1 = sdf.parse(startTime); endTime1 = sdf.parse(endTime); }catch(Exception e){} if(riQiCheck(startTime) && riQiCheck(endTime)){ for(User u : list){ if(u.getNumber().equals(tokens[0].substring(2))){ if(tokens[1].matches("0791[0-9]{7,8}")){ CallRecord callRecord = new CallRecord(startTime1, endTime1, tokens[0].substring(2), tokens[1]); u.getUserRecords().addCallingInCityRecords(callRecord); } else if(tokens[1].matches("0701[0-9]{7,8}") || tokens[1].matches("079[0-9][0-9]{7,8}")){ CallRecord callRecord = new CallRecord(startTime1, endTime1, tokens[0].substring(2), tokens[1]); u.getUserRecords().addCallingInProvinceRecords(callRecord); } else{ CallRecord callRecord = new CallRecord(startTime1, endTime1, tokens[0].substring(2), tokens[1]); u.getUserRecords().addCallingInLandRecords(callRecord); } } } } }
主函数
public static void main(String[] args){ Scanner input = new Scanner(System.in); ArrayList<User> list = new ArrayList<>(); String s = input.nextLine(); while(!s.equals("end")){ if(select(s)==0){ writeUser(list,s); } else if(select(s)==1){ writeRecords(list,s); } s = input.nextLine(); } for(User u : list){ u.calCost(); u.calBalance(); } for(int i=0;i<list.size();i++){ for(int j=0;j<list.size()-1;j++){ if(list.get(j).getNumber().compareTo(list.get(j+1).getNumber()) > 0){ Collections.swap(list, j, j+1); } } } for(User u : list){ System.out.println(u.getNumber()+" "+String.format("%.1f",u.calCost())+" "+String.format("%.1f",u.getBalance())); } }
代码分析
本题主要考虑的是座机计费，只需将各种类型的通话计费规则补充填写完整即可。但首先需要将用户以及通话记录写入，故需要补充相应的函数。本题还需要注意对时间和格式非法的判断，对错误的时间不能进行计算。
题目7.7-1
实现南昌市电信分公司的计费程序，假设该公司针对手机和座机用户分别采取了两种计费方案，分别如下：
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）。
注意：以上图中所定义的类不是限定要求，根据实际需要自行补充或修改。
源代码（类图中给出的部分不做具体展示）：
主函数
public static void main(String[] args) { Outputtool outputtool = new Outputtool(); Inputdeal inputdeal = new Inputdeal(); ArrayList<User> users = new ArrayList<>(); Scanner in = new Scanner(System.in); String input = in.nextLine(); while (!input.equals("end")) { if (1 == inputdeal.check(input)) { inputdeal.writeUser(users, input); } else if (2 == inputdeal.check(input)) { inputdeal.writeRecord(users, input); } input = in.nextLine(); } users.sort(new Comparator<User>() { @Override public int compare(User u1, User u2) { if (u1.getNumber().charAt(0) == '0' && u2.getNumber().charAt(0) != '0') { return -1; } else if (u1.getNumber().charAt(0) != '0' && u2.getNumber().charAt(0) == '0') { return 1; } if (Double.parseDouble(u1.getNumber()) > Double.parseDouble(u2.getNumber())) { return 1; } else { return -1; } } }); for (User u : users) { System.out.print(u.getNumber() + " "); outputtool.output(u.calCost()); System.out.print(" "); outputtool.output(u.calBalance()); System.out.println(); } }
市内座机计费方式
class LandlinePhoneCharging extends ChargeMode { private double monthlyRent = 20; public LandlinePhoneCharging() { super(); chargeRules.add(new LandPhoneInCityRule()); chargeRules.add(new LandPhoneInProvinceRule()); chargeRules.add(new LandPhoneInlandRule()); } @Override public double calCost(UserRecords userRecords) { double sumCost = 0; for (ChargeRule rule : chargeRules) { sumCost += rule.calCost(userRecords); } return sumCost; } @Override public double getMonthlyRent() { return monthlyRent; } }
手机用户计费方式
class MobilePhoneCharging extends ChargeMode { private double monthlyRent = 15; public MobilePhoneCharging() { super(); chargeRules.add(new MobilePhoneInCityRule()); chargeRules.add(new MobilePhoneInProvinceRule()); chargeRules.add(new MobilePhoneInlandRule()); } @Override public double calCost(UserRecords userRecords) { double sumCost = 0; for (ChargeRule rule : chargeRules) { sumCost += rule.calCost(userRecords); } return sumCost; } @Override public double getMonthlyRent() { return monthlyRent; } }
通话记录
class CallRecord extends CommunicationRecord { private Date startTime; private Date endTime; private String callingAddressAreaCode; private String answerAddressAreaCode; public String getCallType() { String type = ""; if (callingAddressAreaCode.equals("0791")) { type = type.concat("1"); } else if (callingAddressAreaCode.matches("^079[023456789]$") || callingAddressAreaCode.equals("0701")) { type = type.concat("2"); } else { type = type.concat("3"); } if (answerAddressAreaCode.equals("0791")) { type = type.concat("1"); } else if (answerAddressAreaCode.matches("^079[023456789]$") || answerAddressAreaCode.equals("0701")) { type = type.concat("2"); } else { type = type.concat("3"); } return type; } public CallRecord(String[] inputs) { super(); char type = inputs[0].charAt(0); inputs[0] = inputs[0].substring(2); String sd = null, st = null, ed = null, et = null; if (type == 't') { if (inputs.length == 6) { sd = inputs[2]; st = inputs[3]; ed = inputs[4]; et = inputs[5]; callingAddressAreaCode = inputs[0].substring(0, 4); answerAddressAreaCode = inputs[1].substring(0, 4); } else if (inputs.length == 7) { sd = inputs[3]; st = inputs[4]; ed = inputs[5]; et = inputs[6]; if (inputs[0].charAt(0) != '0') { if (inputs[2].length() == 10) { answerAddressAreaCode = inputs[2].substring(0, 3); } else { answerAddressAreaCode = inputs[2].substring(0, 4); } callingAddressAreaCode = inputs[1]; } else { if (inputs[0].length() == 10) { callingAddressAreaCode = inputs[0].substring(0, 3); } else { callingAddressAreaCode = inputs[0].substring(0, 4); } answerAddressAreaCode = inputs[2]; } } else if (inputs.length == 8) { sd = inputs[4]; st = inputs[5]; ed = inputs[6]; et = inputs[7]; callingAddressAreaCode = inputs[1]; answerAddressAreaCode = inputs[3]; } } else if (type == 'm') { } SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss", Locale.getDefault()); try { startTime = simpleDateFormat.parse(sd + " " + st); endTime = simpleDateFormat.parse(ed + " " + et); } catch (ParseException e) { } } public CallRecord(Date startTime, Date endTime, String callingAddressAreaCode, String answerAddressAreaCode) { super(); this.startTime = startTime; this.endTime = endTime; this.callingAddressAreaCode = callingAddressAreaCode; this.answerAddressAreaCode = 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; } }
手机市内通话计费
class MobilePhoneInCityRule extends CallChargeRule {
@Override
public double calCost(UserRecords userRecords) {
double sumCost = 0;
for (CallRecord call : userRecords.getCallingInCityRecords()) {
double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (distanceS < 0) {
continue;
}
double distanceM = (int) distanceS / 60;
if (distanceS % 60 != 0) {
distanceM += 1;
}
if (call.getCallType().equals("11")) {
sumCost += distanceM * 0.1;
} else if (call.getCallType().equals("12")) {
sumCost += distanceM * 0.2;
} else if (call.getCallType().equals("13")) {
sumCost += distanceM * 0.3;
}
}
return sumCost;
}
}
手机国内通话计费
class MobilePhoneInlandRule extends CallChargeRule {
@Override
public double calCost(UserRecords userRecords) {
double sumCost = 0;
for (CallRecord call : userRecords.getCallingInLandRecords()) {
double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (distanceS < 0) {
continue;
}
double distanceM = (int) distanceS / 60;
if (distanceS % 60 != 0) {
distanceM += 1;
}
sumCost += distanceM * 0.6;
}
for (CallRecord call : userRecords.getAnswerInLandRecords()) {
double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (distanceS < 0) {
continue;
}
double distanceM = (int) distanceS / 60;
if (distanceS % 60 != 0) {
distanceM += 1;
}
sumCost += distanceM * 0.3;
}
return sumCost;
}
}
手机省内通话计费
class MobilePhoneInProvinceRule extends CallChargeRule { @Override public double calCost(UserRecords userRecords) { double sumCost = 0; for (CallRecord call : userRecords.getCallingInProvinceRecords()) { double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000; if (distanceS < 0) { continue; } double distanceM = (int) distanceS / 60; if (distanceS % 60 != 0) { distanceM += 1; } if (call.getCallType().equals("21")) { sumCost += distanceM * 0.3; } else if (call.getCallType().equals("22")) { sumCost += distanceM * 0.3; } else if (call.getCallType().equals("23")) { sumCost += distanceM * 0.3; } } return sumCost; } }
代码分析
本题与上题区别没有很大，只是增加了手机用户的计费规则。需要注意的是市内、省内和国内通话的判断，需要由接听地区的接听号判断，此时呼叫用户和接听用户的判断结果应是一致的。
题目8.7-1
实现一个简单的电信计费程序，针对手机的短信采用如下计费方式：
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）。
注意：以上图中所定义的类不是限定要求，根据实际需要自行补充或修改。
源代码（类图中给出的部分不做具体展示）：
主函数
public static void main(String[] args) throws ParseException { ArrayList<User> User1List = new ArrayList<>(); ArrayList<MessageChargeRule> messageChargeRules = new ArrayList<>(); SendMessageRule sendMessageRule = new SendMessageRule(); MessageCharging messageCharging = new MessageCharging(); messageCharging.getMessageChargeRules().add(sendMessageRule); Scanner in = new Scanner(System.in); String m = in.nextLine(); int flag; while (!m.equals("end")) { Judge judge = new Judge(); if (judge.isUser1Information(m)) { String regex = "[1][\\d]{10}"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(m); while (matcher.find()) { flag = 0; for (User user : User1List ) { if (user.getNumber().equals(matcher.group(0))) { flag = 1; break; } } if (flag == 0) { User1List.add(new User(matcher.group(0))); } } } if (judge.isMessageInformation(m)){ for (User user:User1List ) { if (user.getNumber().equals(m.substring(2,13))){ user.getUserRecords().addSendMessageRecords(new MessageRecord(m.substring(26))); } } } m = in.nextLine(); } for (User user:User1List ) { user.setChargeMode(messageCharging); } for (int i = 0; i < User1List.size(); i++) { int index = -1; Double min = Double.parseDouble(User1List.get(i).getNumber()); for (int j = i + 1; j < User1List.size(); j++) { if (Double.parseDouble(User1List.get(j).getNumber()) < min) { min = Double.parseDouble(User1List.get(j).getNumber()); index = j; } } if (min != Double.parseDouble(User1List.get(i).getNumber())) { User user = User1List.get(i); User1List.set(i, User1List.get(index)); User1List.set(index, user); } } for (User user:User1List ) { System.out.printf("%s %.1f %.1f\n",user.getNumber(),user.getChargeMode().calCost(user.getUserRecords()),user.getMessageBalance()); } }
发送短信计费规则
class SendMessageRule extends MessageChargeRule{ public double calCost(ArrayList<MessageRecord> messageRecords){ int count = 0; double sum; for (MessageRecord messageRecord:messageRecords ) { if (messageRecord.getMessage().length()%10!=0){ count+=messageRecord.getMessage().length()/10+1; } else { count+=messageRecord.getMessage().length()/10; } } if (count<=3){ sum=count*0.1; } else if (count>3&&count<=5){ sum=0.3+(count-3)*0.2; } else { sum=0.3+0.4+(count-5)*0.3; } return sum; } }
代码分析
本题主要针对的是短信的计费方式，难点是需要对发送短信的数量以及发送短信的字符进行判断，但是把需要判断的内容分别进行计算后其实并不难。还需要注意的是对时间的判断，以及最后输出格式的要求。
踩坑心得
本次的电信计费系列看似计费不难，但是其中具体的类之间的关系还是有些许的复杂，只有理清了这些我们对题目的编写才会更加有条理性。本题考验了我们的综合能力，从最初的输入格式判断，到具体的存储及计费规则等，再到时间判断和输出结果，这些都需要我们对java十分熟练，能将它应用在具体的程序中。本题其实考虑的并没有实际生活中那么多，由此可见实际生活中的程序更加复杂，需要我们更进一步的学习和思考，这样才能完成一个更加完美的程序。
总结
经过本阶段的学习后，我对java有了进一步的认识，学会了如何对程序进行设计，学会了如何使用面向对象的思维方式进行思考。在这几次的大作业和实验中，我们一步步对各系列的题目进行深化改善，并且到现在能够自己做出一个简单的小游戏，在这个过程中，我逐渐学会了思考问题的方向，找到了面对困难时的思路。在今后的学习中，我仍需要对java进行更深入的学习，逐渐巩固和加深自己学到的知识，并且善于思考问题，学会从身边的小事观察，或许就会在日后给我偌大的帮助。
