本篇文章为你整理了PTA作业6（PTA作业复制粘贴老师能看出来吗）的详细内容，包含有PTA作业怎么提交 PTA作业复制粘贴老师能看出来吗 PTA作业输入杨辉三角 PTA作业场所防爆要求 PTA作业6，希望能帮助你了解 PTA作业6。
一、6-8作业总结
（1）第六次作业：第一次作业分了两个题，一个电信1题目非常长，给出了类图，类很多工作量很大。还一个题以容器类为例展现了接口，多态的用处和效果，题目给出的提示非常多，按照题目来，再加上一些测试代码，可以运用equals类实现。
（2）第七次作业：第二次作业分了三个小题，第一个还是电信系列，在第六次作业的电信1基础上加了手机计费，代码将会更复杂。第二、三题比较简单，题目都给出了大部分代码，只需要修改，看仔细点就行。主要用到了Collection ，ArrayList，hash这些常用类，使用sort方法实现排序，其实电信系列也用到了这些类。
（3）第八次作业：也是分为三个小题，还是电信系列，不过这次是手机接收短信计费，比较简单，在之前的代码上加上短信计费的具体计费方式就行。第二小题主要考察内部类，第三个小题题目就叫动物声音模拟器，和第六次作业中的容器类类似，考察多态，没有什么复杂的算法，掌握了多态的思想就会比较简单。
二、设计与分析
1.第6次作业：7-1 电信计费系列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）。
后续扩展说明：
后续题目集将增加手机用户，手机用户的计费方式中除了与座机计费类似的主叫通话费之外，还包含市外接听电话的漫游费以及发短信的费用。在本题的设计时可统一考虑。
通话记录中，手机需要额外记录拨打/接听的地点的区号，比如：
座机打手机：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
分析：本题要求比较多，但给出了类图，需要先根据类图建立好这些类，在考虑如何实现，最后测试，根据结果作出适当调整。不过需要注意，最后输出的通信记录需要按电话这串字符从小到大排序的，还要写一个类用来判断格式，需要判断闰年。
代码如下：（代码很长已全部折叠）
1 import java.math.RoundingMode;
2 import java.util.*;
3 import java.text.SimpleDateFormat;
4 import java.text.ParseException;
5 import java.math.BigDecimal;
7 public class Main {
9 public static void main(String[] args) {
11 InputDeal inputdeal = new InputDeal();
13 ArrayList User users = new ArrayList ();
15 Scanner in = new Scanner(System.in);
17 String input = in.nextLine();
18 //格式正确，格式错误不管 0791，江西省内各地市区号包括：0790~0799以及0701
19 // t-079186300001 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:25
20 while (!input.equals("end")) {
21 if (1 == inputdeal.check(input)) {
22 writeUser(users, input);
23 } else if (2 == inputdeal.check(input)) {
24 writeRecord(users, input);
25 }
26 input = in.nextLine();
27 }
28 users.sort(new Comparator User () {
29 @Override
30 public int compare(User u1, User u2) {
31 if (Double.parseDouble(u1.getNumber()) Double.parseDouble(u2.getNumber())) {
32 return 1;
33 } else {
34 return -1;
35 }
36 }
37 });
38 for (User u : users) {
39 System.out.print(u.getNumber() + " ");
41 double tip = u.calCost();
42 output(u.calCost());
43 System.out.print(" ");
44 //System.out.printf("%.2f ",tip);
45 double bal = u.calBalance();
46 output(u.calBalance());
48 }
50 }
51 public static void output(double out) {
53 BigDecimal numb = new BigDecimal(out);
54 out = numb.setScale(2, RoundingMode.HALF_UP).doubleValue();
55 System.out.print(out);
56 }
57 public static void writeUser(ArrayList User users, String input) {
58 User user1 = new User();
59 String[] inputs = input.split(" ");
60 String num = inputs[0].substring(2);
61 for (User i : users) {
62 if (i.getNumber().equals(num)) {
63 return;
64 }
65 }
66 user1.setNumber(num);
67 int mode = Integer.parseInt(inputs[1]);
68 if (mode == 0) {
69 user1.setChargeMode(new LandlinePhoneCharging());
70 }
71 users.add(user1);
72 }
74 public static void writeRecord(ArrayList User users, String input) {
75 String[] inputs = input.split(" ");
76 inputs[0] = inputs[0].replace("t-", "");
78 User callu = null, answeru = null;
79 CallRecord callrecord = new CallRecord(inputs);
81 for (User i : users) {
82 if (i.getNumber().equals(inputs[0])) {
83 callu = i;
84 }
85 if (i.getNumber().equals(inputs[1])) {
86 answeru = i;
87 }
88 if (callu != null answeru != null) {
89 break;
90 }
91 }
93 if (callu != null) {
94 if (callrecord.getCallType() == 1) {
95 callu.getUserRecords().addCallingInCityRecords(callrecord);
96 } else if (callrecord.getCallType() == 2) {
97 callu.getUserRecords().addCallingInProvinceRecords(callrecord);
98 } else {
99 callu.getUserRecords().addCallingInLandRecords(callrecord);
100 }
101 }
103 if (answeru != null) {
104 if (callrecord.getCallType() == 1) {
105 answeru.getUserRecords().addAnswerInCityRecords(callrecord);
106 } else if (callrecord.getCallType() == 2) {
108 answeru.getUserRecords().addAnswerInProvinceRecords(callrecord);
109 } else {
110 answeru.getUserRecords().addAnswerInLandRecords(callrecord);
111 }
112 }
114 }
115 }
117 abstract class ChargeMode {
118 protected ArrayList ChargeRule chargeRules = new ArrayList ();
120 public abstract double calCost(UserRecords userRecords);
122 public abstract double getMonthlyRent();
124 public ArrayList ChargeRule getChargeRules() {
125 return chargeRules;
126 }
128 public void setChargeRules(ArrayList ChargeRule chargeRules) {
129 this.chargeRules = chargeRules;
130 }
131 }
132 /*
133 * 类：用户通讯所有信息记录
134 * 属性：市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
135 * 市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
136 * 以及发送短信、接收短信的记录
137 * 功能：按地址分别记录通话信息
138 * */
139 class UserRecords {
141 private ArrayList CallRecord callingInCityRecords = new ArrayList CallRecord ();
142 private ArrayList CallRecord callingInProvinceRecords = new ArrayList CallRecord ();
143 private ArrayList CallRecord callingInLandRecords = new ArrayList CallRecord ();
144 private ArrayList CallRecord answerInCityRecords = new ArrayList CallRecord ();
145 private ArrayList CallRecord answerInProvinceRecords = new ArrayList CallRecord ();
146 private ArrayList CallRecord answerInLandRecords = new ArrayList CallRecord ();
147 private ArrayList MessageRecord sendMessageRecords = new ArrayList MessageRecord ();
148 private ArrayList MessageRecord receiveMessageRecords = new ArrayList MessageRecord ();
150 public void addCallingInCityRecords(CallRecord callRecord) {
151 callingInCityRecords.add(callRecord);
152 }
154 public void addCallingInProvinceRecords(CallRecord callRecord) {
155 callingInProvinceRecords.add(callRecord);
156 }
158 public void addCallingInLandRecords(CallRecord callRecord) {
159 callingInLandRecords.add(callRecord);
160 }
162 public void addAnswerInCityRecords(CallRecord callRecord) {
163 answerInCityRecords.add(callRecord);
164 }
166 public void addAnswerInProvinceRecords(CallRecord callRecord) {
167 answerInProvinceRecords.add(callRecord);
168 }
170 public void addAnswerInLandRecords(CallRecord callRecord) {
171 answerInLandRecords.add(callRecord);
172 }
174 public void addSendMessageRecords(MessageRecord callRecord) {
175 sendMessageRecords.add(callRecord);
176 }
178 public void addReceiveMessageRecords(MessageRecord callRecord) {
179 receiveMessageRecords.add(callRecord);
180 }
182 public ArrayList CallRecord getCallingInCityRecords() {
183 return callingInCityRecords;
184 }
186 public void setCallingInCityRecords(ArrayList CallRecord callingInCityRecords) {
187 this.callingInCityRecords = callingInCityRecords;
188 }
190 public ArrayList CallRecord getCallingInProvinceRecords() {
191 return callingInProvinceRecords;
192 }
194 public void setCallingInProvinceRecords(ArrayList CallRecord callingInProvinceRecords) {
195 this.callingInProvinceRecords = callingInProvinceRecords;
196 }
198 public ArrayList CallRecord getCallingInLandRecords() {
199 return callingInLandRecords;
200 }
202 public void setCallingInLandRecords(ArrayList CallRecord callingInLandRecords) {
203 this.callingInLandRecords = callingInLandRecords;
204 }
206 public ArrayList CallRecord getAnswerInCityRecords() {
207 return answerInCityRecords;
208 }
210 public void setAnswerInCityRecords(ArrayList CallRecord answerInCityRecords) {
211 this.answerInCityRecords = answerInCityRecords;
212 }
214 public ArrayList CallRecord getAnswerInProvinceRecords() {
215 return answerInProvinceRecords;
216 }
218 public void setAnswerInProvinceRecords(ArrayList CallRecord answerInProvinceRecords) {
219 this.answerInProvinceRecords = answerInProvinceRecords;
220 }
222 public ArrayList CallRecord getAnswerInLandRecords() {
223 return answerInLandRecords;
224 }
226 public void setAnswerInLandRecords(ArrayList CallRecord answerInLandRecords) {
227 this.answerInLandRecords = answerInLandRecords;
228 }
230 public ArrayList MessageRecord getSendMessageRecords() {
231 return sendMessageRecords;
232 }
234 public void setSendMessageRecords(ArrayList MessageRecord sendMessageRecords) {
235 this.sendMessageRecords = sendMessageRecords;
236 }
238 public ArrayList MessageRecord getReceiveMessageRecords() {
239 return receiveMessageRecords;
240 }
242 public void setReceiveMessageRecords(ArrayList MessageRecord receiveMessageRecords) {
243 this.receiveMessageRecords = receiveMessageRecords;
244 }
246 }
247 /*
248 * 座机计费方式
249 *
250 * */
251 class LandlinePhoneCharging extends ChargeMode {
253 final double monthlyRent = 20;
255 public LandlinePhoneCharging() {
256 super();
257 chargeRules.add(new LandPhoneInCityRule());
258 chargeRules.add(new LandPhoneInProvinceRule());
259 chargeRules.add(new LandPhoneInlandRule());
260 }
262 @Override
263 public double calCost(UserRecords userRecords) {
264 double sumCost = 0;
265 for (ChargeRule rule : chargeRules) {
266 sumCost += rule.calCost(userRecords);
267 }
268 return sumCost;
269 }
271 @Override
272 public double getMonthlyRent() {
273 return monthlyRent;
274 }
276 }
277 /* 类：输入格式判断InputDeal
278 * 功能：判断输入格式是否正确，时间是否合理
279 *
280 * */
281 class InputDeal {
283 public int check(String input) {
284 String[] inputs = input.split(" ");
285 if (inputs.length == 2) {
286 if (inputs[0].matches("^u-\\d{11,13}$")) {
287 if (Integer.parseInt(inputs[1]) = 0 Integer.parseInt(inputs[1]) = 2) {
288 return 1;
289 }
290 }
291 } else if (inputs.length == 6) {
292 if (check1(inputs[2]) check1(inputs[4]))
293 if (check2(inputs[3]) check2(inputs[5]))
294 if (inputs[0].matches("[t]-0791\\d{7,8}") inputs[1].matches(".\\d{9,11}"))
295 return 2;
297 }
298 return 0;
299 }
301 private boolean check2(String string) {
302 return string.matches("^([0-1]?\\d2[0-3]):([0-5]\\d):([0-5]\\d)$");
303 }
305 public static boolean check1(String dateString) {
306 // 使用正则表达式 测试 字符 符合 dddd.dd.dd 的格式(d表示数字)
307 if (!dateString.matches("\\d{4}+.\\d{1,2}+.\\d{1,2}+")) {
308 return false;
309 }
310 // 得到年月日
311 String[] array = dateString.split("\\.");
312 int year = Integer.parseInt(array[0]);
313 int month = Integer.parseInt(array[1]);
314 int day = Integer.parseInt(array[2]);
316 if (month 1 month 12) {
317 return false;
318 }
319 int[] monthLengths = new int[] { 0, 31, -1, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
320 if (isLeapYear(year)) {
321 monthLengths[2] = 29;
322 } else {
323 monthLengths[2] = 28;
324 }
325 int monthLength = monthLengths[month];
326 return day = 1 day = monthLength;
327 }
329 /** 是否是闰年 */
330 private static boolean isLeapYear(int year) {
331 return ((year % 4 == 0 year % 100 != 0) year % 400 == 0);
332 }
334 }
335 /*
336 * 抽象类：通讯记录
337 * 属性：callingNumber拨打号码、answerNumber接听号码
338 *
339 * */
340 abstract class CommunicationRecord {
341 protected String callingNumber;
342 protected String answerNumber;
344 public String getCallingNumber() {
345 return callingNumber;
346 }
348 public void setCallingNumber(String callingNumber) {
349 this.callingNumber = callingNumber;
350 }
352 public String getAnswerNumber() {
353 return answerNumber;
354 }
356 public void setAnswerNumber(String answerNumber) {
357 this.answerNumber = answerNumber;
358 }
360 }
362 abstract class ChargeRule {
364 abstract public double calCost(UserRecords userRecords);
366 }
367 /*
368 * 类：通话记录
369 * 属性：通话起始、结束时间；拨号人地址，接听人地址
370 * 功能：记录打电话双方的地址和通话时间
371 *
372 */
373 class CallRecord extends CommunicationRecord {
374 private Date startTime;
375 private Date endTime;
376 private String callingAddressAreaCode;
377 private String answerAddressAreaCode;
378 //
379 public double getCallTime(){
380 return endTime.getTime() - startTime.getTime();
381 }
382 public int getCallType() {
383 if (callingAddressAreaCode.equals(answerAddressAreaCode)) {
384 return 1;
385 }
386 if (callingAddressAreaCode.matches("^079\\d$") callingAddressAreaCode.equals("0701")) {
387 if (answerAddressAreaCode.matches("^079\\d$") answerAddressAreaCode.equals("0701")) {
388 return 2;
389 }
390 }
391 return 3;
392 }
394 public CallRecord(String[] in) {
395 super();
396 if (in[0].length() == 10) {
397 callingAddressAreaCode = in[0].substring(0, 3);
398 } else {
399 callingAddressAreaCode = in[0].substring(0, 4);
400 }
401 if (in[1].length() == 10) {
402 answerAddressAreaCode = in[1].substring(0, 3);
403 } else {
404 answerAddressAreaCode = in[1].substring(0, 4);
405 }
406 SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss", Locale.getDefault());
407 try {
408 startTime = simpleDateFormat.parse(in[2] + " " + in[3]);
409 endTime = simpleDateFormat.parse(in[4] + " " + in[5]);
410 } catch (ParseException e) {
411 throw new RuntimeException(e);
412 }
414 }
416 public Date getStartTime() {
417 return startTime;
418 }
420 public void setStartTime(Date startTime) {
421 this.startTime = startTime;
422 }
424 public Date getEndTime() {
425 return endTime;
426 }
428 public void setEndTime(Date endTime) {
429 this.endTime = endTime;
430 }
432 public String getCallingAddressAreaCode() {
433 return callingAddressAreaCode;
434 }
436 public void setCallingAddressAreaCode(String callingAddressAreaCode) {
437 this.callingAddressAreaCode = callingAddressAreaCode;
438 }
440 public String getAnswerAddressAreaCode() {
441 return answerAddressAreaCode;
442 }
444 public void setAnswerAddressAreaCode(String answerAddressAreaCode) {
445 this.answerAddressAreaCode = answerAddressAreaCode;
446 }
447 }
449 abstract class CallChargeRule extends ChargeRule {}
451 /*
452 * 市内
453 * */
454 class LandPhoneInCityRule extends CallChargeRule {
456 @Override
457 public double calCost(UserRecords userRecords) {
458 double sumCost = 0;
459 for (CallRecord call : userRecords.getCallingInCityRecords()) {
460 long distanceS = (call.getEndTime().getTime() - call.getStartTime().getTime()) / 1000;
461 if (distanceS 0) {
462 continue;
463 }
464 long distanceM = (int) distanceS / 60;
465 if (distanceS % 60 != 0) {
466 distanceM += 1;
467 }
468 sumCost += distanceM * 0.1;
469 }
470 return sumCost;
471 }
473 }
474 /*
475 * 国内
476 * */
477 class LandPhoneInlandRule extends CallChargeRule {
479 @Override
480 public double calCost(UserRecords userRecords) {
481 double sumCost = 0;
482 for (CallRecord call : userRecords.getCallingInLandRecords()) {
483 long distanceS = (call.getEndTime().getTime() - call.getStartTime().getTime()) / 1000;
484 if (distanceS 0) {
485 continue;
486 }
487 long distanceM = (int) distanceS / 60;
488 if (distanceS % 60 != 0) {
489 distanceM += 1;
490 }
491 sumCost += distanceM * 0.6;
492 }
493 return sumCost;
494 }
496 }
497 /*
498 * 省内
499 */
500 class LandPhoneInProvinceRule extends CallChargeRule {
502 @Override
503 public double calCost(UserRecords userRecords) {
504 double sumCost = 0;
505 for (CallRecord call : userRecords.getCallingInProvinceRecords()) {
506 long distanceS = (call.getEndTime().getTime() - call.getStartTime().getTime()) / 1000;
507 if (distanceS 0) {
508 continue;
509 }
510 long distanceM = (int) distanceS / 60;
511 if (distanceS % 60 != 0) {
512 distanceM += 1;
513 }
514 sumCost += distanceM * 0.3;
515 }
516 return sumCost;
517 }
519 }
520 /*
521 * 类：短信记录
522 * 属性：短信内容
523 *
524 * */
525 class MessageRecord extends CommunicationRecord {
527 private String message;
529 public String getMessage() {
530 return message;
531 }
533 public void setMessage(String message) {
534 this.message = message;
535 }
536 }
537 /*
538 * 类：用户
539 * 属性：用户通讯详细信息记录userRecords，话费余额，电话付费方式，电话号码
540 *
541 * */
542 class User {
543 private UserRecords userRecords = new UserRecords();
544 double balance = 100;
545 private ChargeMode chargeMode;
546 private String number;
548 public double calCost() {
549 return chargeMode.calCost(userRecords);
550 }
552 public double calBalance() {
553 return balance - chargeMode.getMonthlyRent() - calCost();
554 }
556 public UserRecords getUserRecords() {
557 return userRecords;
558 }
560 public void setUserRecords(UserRecords userRecords) {
561 this.userRecords = userRecords;
562 }
564 public ChargeMode getChargeMode() {
565 return chargeMode;
566 }
568 public void setChargeMode(ChargeMode chargeMode) {
569 this.chargeMode = chargeMode;
570 }
572 public String getNumber() {
573 return number;
574 }
576 public void setNumber(String number) {
577 this.number = number;
578 }
580 }
View Code
结果：
分析：电信1的得分点最后还有一个没有过，但测试了很多输入样例都没有测出来。由上图可知，最后的代码平均深度，平均复杂度和最大深度差不多，不是很高，最大复杂度比较高，信息量实在是太多了，不过总体来说圈复杂度还是可以的。注释我都做了类的注释，但好像还是有点少了。
2.第7次作业：7-2 电信计费系列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元。
每条通讯、短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
类图同上题，直接省略。
分析：上次题目中只写了座机的计费，本次需要再加上有关手机计费的类，同座机一样，分为市内，省内，国内三种计费方式。
代码如下：
1 import java.util.*;
2 import java.util.regex.Matcher;
3 import java.util.regex.Pattern;
4 import java.math.BigDecimal;
5 import java.text.SimpleDateFormat;
6 import java.text.ParseException;
8 public class Main {
9 public static void main(String[] args) {
10 Outputtool outputtool = new Outputtool();
11 Inputdeal inputdeal = new Inputdeal();
12 ArrayList User users = new ArrayList ();
13 Scanner in = new Scanner(System.in);
14 String input = in.nextLine();
15 while (!input.equals("end")) {
16 if (1 == inputdeal.check(input)) {
17 inputdeal.writeUser(users, input);
18 } else if (2 == inputdeal.check(input)) {
19 inputdeal.writeRecord(users, input);
20 }
21 input = in.nextLine();
22 }
23 //排序
24 users.sort(new Comparator User () {
26 @Override
27 public int compare(User u1, User u2) {
28 if (u1.getNumber().charAt(0) == 0 u2.getNumber().charAt(0) != 0) {
29 return -1;
30 } else if (u1.getNumber().charAt(0) != 0 u2.getNumber().charAt(0) == 0) {
31 return 1;
32 }
33 if (Double.parseDouble(u1.getNumber()) Double.parseDouble(u2.getNumber())) {
34 return 1;
35 } else {
36 return -1;
37 }
38 }
39 });
40 for (User u : users) {
41 System.out.print(u.getNumber() + " ");
42 outputtool.output(u.calCost());
43 System.out.print(" ");
44 outputtool.output(u.calBalance());
45 System.out.println();
46 }
47 }
48 }
50 abstract class ChargeMode {
51 protected ArrayList ChargeRule chargeRules = new ArrayList ();
53 public abstract double calCost(UserRecords userRecords);
55 public abstract double getMonthlyRent();
57 public ArrayList ChargeRule getChargeRules() {
58 return chargeRules;
59 }
61 public void setChargeRules(ArrayList ChargeRule chargeRules) {
62 this.chargeRules = chargeRules;
63 }
64 }
65 /*
66 * 类：用户
67 * 属性：用户通讯详细信息记录userRecords，话费余额，电话付费方式，电话号码
68 *
69 * */
70 class User {
72 private UserRecords userRecords = new UserRecords();
73 private double balance = 100;
74 private ChargeMode chargeMode;
75 private String number;
77 public double calCost() {
78 return chargeMode.calCost(userRecords);
79 }
81 public double calBalance() {
82 return balance - chargeMode.getMonthlyRent() - chargeMode.calCost(userRecords);
83 }
85 public UserRecords getUserRecords() {
86 return userRecords;
87 }
89 public void setUserRecords(UserRecords userRecords) {
90 this.userRecords = userRecords;
91 }
93 public ChargeMode getChargeMode() {
94 return chargeMode;
95 }
97 public void setChargeMode(ChargeMode chargeMode) {
98 this.chargeMode = chargeMode;
99 }
101 public String getNumber() {
102 return number;
103 }
105 public void setNumber(String number) {
106 this.number = number;
107 }
109 }
110 /*
111 * 类：用户通讯所有信息记录
112 * 属性：市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
113 * 市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
114 * 以及发送短信、接收短信的记录
115 * 功能：按地址分别记录通话信息
116 * */
117 class UserRecords {
119 private ArrayList CallRecord callingInCityRecords = new ArrayList CallRecord ();
120 private ArrayList CallRecord callingInProvinceRecords = new ArrayList CallRecord ();
121 private ArrayList CallRecord callingInLandRecords = new ArrayList CallRecord ();
122 private ArrayList CallRecord answerInCityRecords = new ArrayList CallRecord ();
123 private ArrayList CallRecord answerInProvinceRecords = new ArrayList CallRecord ();
124 private ArrayList CallRecord answerInLandRecords = new ArrayList CallRecord ();
125 private ArrayList MessageRecord sendMessageRecords = new ArrayList MessageRecord ();
126 private ArrayList MessageRecord receiveMessageRecords = new ArrayList MessageRecord ();
128 //记录信。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。