第三次博客作业

前言：这是本学期最后一次blog作业，最后一次的pta作业也降低了许多难度。

这三次作业主要是写电信计费功能，考察的知识点有很多。例如：lamda表达式的

运用，SimpleDate类的运用。相比之前难度降低，所以对我来说相对简单。

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

 

 

以下是源码：

import java.util.Scanner;
import java.util.ArrayList;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Collections;

public class Main {
    public static void main(String[] args)throws Exception{
        Scanner input = new Scanner(System.in);
        ArrayList<User> user = new ArrayList<>();
        ParseInput parseInput = new ParseInput();
        String s = input.nextLine();
        String regex = "[u][-]0791[0-9]{7,8}[ ][0]";
        String regex_ = "";
        int i = 0;
        boolean flag = false;
        while (!s.equals("end")){
            if(s.matches(regex)) {
                for (int l = 0; l<user.size(); l++) {
                    if (parseInput.ParseInputNumber(s).equals(user.get(l).getNumber())) {
                        flag = true;
                    }
                }
                if (!flag) {
                    user.add(new User(parseInput.ParseInputNumber(s)));
                    user.get(i).setUsersRecords(new UsersRecords());
                    i++;
                    regex_ = "[t][-]0791[0-9]{7,8}[ ][0-9]{10,12}[ ]([1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9])[\\.]([1-9]|[1-9][0-9])[\\.]([1-9]|[1-9][0-9])[ ]([0-1][0-9]|2[0-3])[:][0-5][0-9][:][0-5][0-9][ ]([1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9])[\\.]([1-9]|[1-9][0-9])[\\.]([1-9]|[1-9][0-9])[ ]([0-1][0-9]|2[0-3])[:][0-5][0-9][:][0-5][0-9]";
                }
            }
            else if(s.matches(regex_)) {
                if (parseInput.ParseTimeFormat(s)) {
                    int j = 0;
                    for (; j<user.size(); j++) {
                        if (user.get(j).getNumber().equals(parseInput.ParseInputCalNumber(s))) {
                            CallRecord callRecord = new CallRecord();
                            callRecord.setStartTime(parseInput.ParseInputStartDate(s));
                            callRecord.setEndTime(parseInput.ParseInputEndData(s));
                            callRecord.setCallingNumber(parseInput.ParseInputCalNumber(s));
                            callRecord.setAnswerNumber(parseInput.ParseInputAnswerNumber(s));
                            if (parseInput.ParseNumberArea(callRecord.getAnswerNumber()) == 1) {
                                user.get(j).getUsersRecords().addCallingInCityRecords(callRecord);
                            } else if (parseInput.ParseNumberArea(callRecord.getAnswerNumber()) == 2) {
                                user.get(j).getUsersRecords().addCallingInProvinceRecords(callRecord);
                            } else if(parseInput.ParseNumberArea(callRecord.getAnswerNumber())==0){
                                user.get(j).getUsersRecords().addCallingInLandRecords(callRecord);
                            }
                        }
                    }
                }
            }
            s = input.nextLine();
        }

        Collections.sort(user);

        for (i = 0;i< user.size();i++){
            System.out.println(user.get(i).getNumber()+" "+String.format("%.1f",user.get(i).CalCost())+" "+String.format("%.1f",user.get(i).CalBalance()));
        }
    }
}
abstract class CallChargeRule extends ChargeRule{
    public abstract double calCost(ArrayList<CallRecord> callRecords) throws Exception;

}
class CallRecord extends CommunicationRecord {
    private Date startTime;
    private Date endTime;

    private String callingAddressAreaCode;
    private 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;
    }

    public int getTimeOf() throws Exception {
        SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        String start = simpleFormat.format(startTime);
        String end = simpleFormat.format(endTime);
        Date fromM = simpleFormat.parse(start.substring(0, 16));
        Date toM = simpleFormat.parse(end.substring(0, 16));

        simpleFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        start = simpleFormat.format(startTime);
        end = simpleFormat.format(endTime);
        int secondStart = Integer.parseInt(start.substring(17, 19));
        int secondEnd = Integer.parseInt(end.substring(17, 19));

        long from = fromM.getTime();
        long to = toM.getTime();
        int gap = (int) ((to - from) / (1000 * 60));

        if (secondEnd > secondStart) {
            gap++;
        }

        if (gap > 0) {
            return gap;
        } else return 0;
    }
}
abstract class ChargeMode {
    public ArrayList<ChargeRule> getChargeRules() {
        return chargeRules;
    }

    public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
        this.chargeRules = chargeRules;
    }

    private ArrayList<ChargeRule> chargeRules = new ArrayList<ChargeRule>();

    public abstract double CalCost(UsersRecords usersRecords) throws Exception;

    public abstract double getMonthlyRent();
}
abstract class ChargeRule {
}
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 DateUtil {

    private int year;
    private int month;
    private int day;

    public DateUtil(){

    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    public DateUtil(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public boolean checkInputValidity(){
        if (month > 0 && month < 13 && day > 0 && day < 32) {
            if (isLeapYear(year)) {
                if ((day>29&&month==2)||(day>30&&month==4)||(day>30&&month==6)||(day>30&&month==9)||(day>30&&month==11)){
                    return false;
                } else {
                    return true;
                }
            }
            else {
                if ((day>28&&month==2)||(day>30&&month==4)||(day>30&&month==6)||(day>30&&month==9)||(day>30&&month==11)) {
                    return false;
                } else {
                    return true;
                }
            }
        }
        else {
            return false;
        }
    }//检测输入的年、月、日是否合法
    public boolean isLeapYear(int year){
        if(year%400==0){
            return true;
        }
        else if(year%4==0&&year%100!=0){
            return true;
        }
        else {
            return false;
        }
    }//判断year是否为闰年
}
class LandingPhoneCharging extends ChargeMode{

    CallChargeRule city = new LandPhoneInCityRule();
    CallChargeRule province = new LandPhoneInProvinceRule();
    CallChargeRule land = new LandPhoneInLandRule();

    @Override
    public double CalCost(UsersRecords usersRecords) throws Exception{
        double sum = 0;
        sum += city.calCost(usersRecords.getCallingInCityRecords());
        sum += province.calCost(usersRecords.getCallingInProvinceRecords());
        sum += land.calCost(usersRecords.getCallingInLandRecords());
        return sum;
    }

    @Override
    public double getMonthlyRent() {
        return monthlyRent;
    }

    private double monthlyRent = 20;
}
class LandPhoneInCityRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords)throws Exception{
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.1;
        }
        return sum;
    }
}
class LandPhoneInLandRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords)throws Exception {
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.6;
        }
        return sum;
    }
}
class LandPhoneInProvinceRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords)throws Exception {
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.3;
        }
        return sum;
    }
}
class MessageRecord extends CommunicationRecord{
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}
class ParseInput {

    public String ParseInputNumber(String s){
        String ss[]=s.split("-");
        String sss[] =ss[1].split(" ");
        return sss[0];
    }

    public Date ParseInputStartDate(String s){
        String ss[]=s.split("-");
        String sss[] =ss[1].split(" ");
        String ssss[] = sss[2].split("\\.");
        String time[] = sss[3].split(":");
        int year = Integer.parseInt(ssss[0]);
        int month = Integer.parseInt(ssss[1]);
        int day = Integer.parseInt(ssss[2]);
        int hour = Integer.parseInt(time[0]);
        int minute = Integer.parseInt(time[1]);
        int second = Integer.parseInt(time[2]);
        Date date = new Date(year,month,day,hour,minute,second);
        return date;
    }

    public Date ParseInputEndData(String s){
        String ss[]=s.split("-");
        String sss[] =ss[1].split(" ");
        String ssss[] = sss[4].split("\\.");
        String time[] = sss[5].split(":");
        int year = Integer.parseInt(ssss[0]);
        int month = Integer.parseInt(ssss[1]);
        int day = Integer.parseInt(ssss[2]);
        int hour = Integer.parseInt(time[0]);
        int minute = Integer.parseInt(time[1]);
        int second = Integer.parseInt(time[2]);
        Date date = new Date(year,month,day,hour,minute,second);
        return date;
    }

    public String ParseInputCalNumber(String s){
        String ss[]=s.split("-");
        String sss[] = ss[1].split(" ");
        return sss[0];
    }

    public String ParseInputAnswerNumber(String s){
        String ss[]=s.split("-");
        String sss[] = ss[1].split(" ");
        return sss[1];
    }

    public int ParseNumberArea(String s){
        String regex1 = "0791[0-9]{7,8}";
        String regex2 = "079[023456789][0-9]{7,8}";
        String regex3 = "0701[0-9]{7,8}";
        if(s.matches(regex1)) {
            return 1;
        }
        else if(s.matches(regex2)||s.matches(regex3)) {
            return 2;
        }
        return 0;
    }

    public boolean ParseTimeFormat(String s){
        String ss[]=s.split("-");
        String sss[] =ss[1].split(" ");
        String startDate[] = sss[2].split("\\.");
        String endDate[] = sss[4].split("\\.");


        DateUtil dateUtilStart = new DateUtil(Integer.parseInt(startDate[0]), Integer.parseInt(startDate[1]), Integer.parseInt(startDate[2]));
        DateUtil dateUtilEnd = new DateUtil(Integer.parseInt(endDate[0]),Integer.parseInt(endDate[1]),Integer.parseInt(endDate[2]));


        return dateUtilEnd.checkInputValidity()&&dateUtilStart.checkInputValidity();
    }
}
class User implements Comparable<User>{

    private UsersRecords usersRecords = new UsersRecords();
    private double balance = 100;
    private ChargeMode chargeMode;
    private String number;

    public User(String number){
        this.number = number;
    }

    public User() {

    }

    public double CalCost()throws Exception{
        chargeMode = new LandingPhoneCharging();
        return chargeMode.CalCost(getUsersRecords());
    }

    public double CalBalance()throws Exception{
        this.balance = balance - CalCost() - chargeMode.getMonthlyRent();
        return balance;
    }

    public double getBalance() {
        return balance;
    }

    public UsersRecords getUsersRecords() {
        return usersRecords;
    }

    public void setUsersRecords(UsersRecords usersRecords) {
        this.usersRecords = usersRecords;
    }

    public ChargeMode getChargeMode() {
        return chargeMode;
    }

    public void setChargeMode(ChargeMode chargeMode) {
        this.chargeMode = chargeMode;
    }

    public String getNumber() {
        return number;
    }

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

    @Override
    public int compareTo(User o) {
        return this.getNumber().compareTo(o.getNumber());
    }
}
class UsersRecords {

    private ArrayList<CallRecord> callingInCityRecords = new ArrayList<CallRecord>();//市内拨打电话
    private ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<CallRecord>();//省内拨打电话
    private ArrayList<CallRecord> callingInLandRecords = new ArrayList<CallRecord>();//国内拨打电话
    private ArrayList<CallRecord> answerInCityRecords = new ArrayList<CallRecord>();//市内接听电话
    private ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<CallRecord>();//省内接听电话
    private ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();//国内接听电话
    private ArrayList<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();//发出短信
    private ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<MessageRecord>();//接收短信

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

    public ArrayList<MessageRecord> getSendMessageRecords() {
        return sendMessageRecords;
    }

    public ArrayList<MessageRecord> getReceiveMessageRecords() {
        return receiveMessageRecords;
    }

    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 callRecord){
        answerInCityRecords.add(callRecord);
    }

    public void addAnswerInProvinceRecords(CallRecord callRecord){
        answerInProvinceRecords.add(callRecord);
    }

    public void addAnswerInLandRecords(CallRecord callRecord){
        answerInLandRecords.add(callRecord);
    }

    public void addSendMessageRecords(MessageRecord messageRecord){
        sendMessageRecords.add(messageRecord);
    }

    public void addReceiveMessageRecords(MessageRecord messageRecord){
        receiveMessageRecords.add(messageRecord);
    }
}

 

这是类图

分析：

这道题要先判断电话号码的区域从而再将通话记录给分成不同的类型

最后在进行对话费的计算。

要注意的点：对于输入的通话记录进行格式判断。

对于输入的通话记录中的时间也要进行判断

实现南昌市电信分公司的计费程序，假设该公司针对手机和座机用户分别采取了两种计费方案，分别如下：
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.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Main {
    public static void main(String[] args)throws Exception {
        Scanner input = new Scanner(System.in);
        ArrayList<User> user = new ArrayList<>();
        ParseInput parseInput = new ParseInput();
        String s = input.nextLine();
        String regex = "[u][-]0791[0-9]{7,8}[ ][0]";
        String regex2 = "[u][-][1][0-9]{10}[ ][1]";
        String regex_ = "";
        String regex2_ = " ";
        int i = 0;
        boolean flag = false;
        while (!s.equals("end")) {
            if (s.matches(regex)) {
                for (int l = 0; l < user.size(); l++) {
                    if (parseInput.ParseInputNumber(s).equals(user.get(l).getNumber())) {
                        flag = true;
                    }
                }
                if (!flag) {
                    user.add(new User(parseInput.ParseInputNumber(s)));
                    user.get(i).setUsersRecords(new UsersRecords());
                    i++;
                    regex_ = "[t][-]0791[0-9]{7,8}[ ][0-9]{10,12}[ ]([1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9])[\\\\.]([1-9]|[1-9][0-9])[\\\\.]([1-9]|[1-9][0-9])[ ]([0-1][0-9]|2[0-3])[:][0-5][0-9][:][0-5][0-9][ ]([1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9])[\\\\.]([1-9]|[1-9][0-9])[\\\\.]([1-9]|[1-9][0-9])[ ]([0-1][0-9]|2[0-3])[:][0-5][0-9][:][0-5][0-9]";
                    regex2_ = "[t][-]([0-9]{10,12}|1[0-9]{10}[ ][0-9]{3,4})[ ](1[0-9]{10}[ ][0-9]{3,4}|[0-9]{10,12})[ ]([1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9])[\\\\.]([1-9]|[1-9][0-9])[\\\\.]([1-9]|[1-9][0-9])[ ]([0-1][0-9]|2[0-3])[:][0-5][0-9][:][0-5][0-9][ ]([1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9])[\\\\.]([1-9]|[1-9][0-9])[\\\\.]([1-9]|[1-9][0-9])[ ]([0-1][0-9]|2[0-3])[:][0-5][0-9][:][0-5][0-9]";
                }
                flag = false;
            } else if (s.matches(regex2)) {
                for (int l = 0; l < user.size(); l++) {
                    if (parseInput.ParseInputNumber(s).equals(user.get(l).getNumber())) {
                        flag = true;
                    }
                }
                if (!flag) {
                    user.add(new User(parseInput.ParseInputNumber(s)));
                    user.get(i).setUsersRecords(new UsersRecords());
                    i++;
                }
                flag =false;
            } else if (s.matches("t-0791\\d{7,8} 0\\d{9,11} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2}")) {
                if (parseInput.ParseTimeFormat(s)) {
                    int j = 0;
                    for (; j < user.size(); j++) {
                        if (user.get(j).getNumber().equals(parseInput.ParseInputCalNumber(s))) {
                            CallRecord callRecord = new CallRecord();
                            callRecord.setStartTime(parseInput.ParseInputStartDate(s));
                            callRecord.setEndTime(parseInput.ParseInputEndData(s));
                            callRecord.setCallingNumber(parseInput.ParseInputCalNumber(s));
                            callRecord.setAnswerNumber(parseInput.ParseInputAnswerNumber(s));
                            callRecord.setAnswerAddressAreaCode(parseInput.EndParseArea(s));
                            callRecord.setCallingAddressAreaCode(parseInput.StartParseArea(s));
                            if (parseInput.ParseNumberArea(callRecord.getAnswerNumber()) == 1) {
                                user.get(j).getUsersRecords().addCallingInCityRecords(callRecord);
                            } else if (parseInput.ParseNumberArea(callRecord.getAnswerNumber()) == 2) {
                                user.get(j).getUsersRecords().addCallingInProvinceRecords(callRecord);
                            } else if (parseInput.ParseNumberArea(callRecord.getAnswerNumber()) == 0) {
                                user.get(j).getUsersRecords().addCallingInLandRecords(callRecord);
                            }
                        }
                    }
                }

            }
            else if(s.matches("t-0791\\d{7,8} 1\\d{10} 0\\d{2,3} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2}")) {
                if (parseInput.ParseTimeFormat(s)) {
                    int j = 0;
                    for (; j < user.size(); j++) {
                        if (user.get(j).getNumber().equals(parseInput.ParseInputCalNumber(s))) {
                            CallRecord callRecord = new CallRecord();
                            callRecord.setStartTime(parseInput.ParseInputStartDate(s));
                            callRecord.setEndTime(parseInput.ParseInputEndData(s));
                            callRecord.setCallingNumber(parseInput.ParseInputCalNumber(s));
                            callRecord.setAnswerNumber(parseInput.ParseInputAnswerNumber(s));
                            callRecord.setAnswerAddressAreaCode(parseInput.EndParseArea(s));
                            callRecord.setCallingAddressAreaCode(parseInput.StartParseArea(s));
                            if (callRecord.getAnswerAddressAreaCode().matches("0791")) {
                                user.get(j).getUsersRecords().addCallingInCityRecords(callRecord);
                            } else if (callRecord.getAnswerAddressAreaCode().matches("[0][7][9][234567890]|[0][7][0][1]")) {
                                user.get(j).getUsersRecords().addCallingInProvinceRecords(callRecord);
                            } else user.get(j).getUsersRecords().addCallingInLandRecords(callRecord);
                        }
                    }
                    int k = 0;
                    for (; k < user.size(); k++) {
                        if (user.get(k).getNumber().equals(parseInput.ParseInputAnswerNumber(s))) {
                            CallRecord callRecord = new CallRecord();
                            callRecord.setStartTime(parseInput.ParseInputStartDate(s));
                            callRecord.setEndTime(parseInput.ParseInputEndData(s));
                            callRecord.setCallingNumber(parseInput.ParseInputCalNumber(s));
                            callRecord.setAnswerNumber(parseInput.ParseInputAnswerNumber(s));
                            callRecord.setAnswerAddressAreaCode(parseInput.EndParseArea(s));
                            callRecord.setCallingAddressAreaCode(parseInput.StartParseArea(s));
                            if (callRecord.getAnswerAddressAreaCode().matches("0791")) {
                                user.get(k).getUsersRecords().addAnswerInCityRecords(callRecord);
                            } else if (callRecord.getAnswerAddressAreaCode().matches("[0][7][9][234567890]|[0][7][0][1]")) {
                                user.get(k).getUsersRecords().addAnswerInProvinceRecords(callRecord);
                            } else user.get(k).getUsersRecords().addAnswerInLandRecords(callRecord);
                        }
                    }
                }

            }
            else if(s.matches("t-1\\d{10} 0\\d{2,3} 0\\d{9,11} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2}")){
                int j = 0;
                for (; j < user.size(); j++) {
                    if (user.get(j).getNumber().equals(parseInput.ParseInputCalNumber(s))) {
                        CallRecord callRecord = new CallRecord();
                        callRecord.setStartTime(parseInput.ParseInputStartDate(s));
                        callRecord.setEndTime(parseInput.ParseInputEndData(s));
                        callRecord.setCallingNumber(parseInput.ParseInputCalNumber(s));
                        callRecord.setAnswerNumber(parseInput.ParseInputAnswerNumber(s));
                        callRecord.setAnswerAddressAreaCode(parseInput.EndParseArea(s));
                        callRecord.setCallingAddressAreaCode(parseInput.StartParseArea(s));
                        if (callRecord.getCallingAddressAreaCode().matches("0791")){
                            if(callRecord.getAnswerAddressAreaCode().matches("0791")){
                                user.get(j).getUsersRecords().addCallingInCityRecords(callRecord);
                            }
                            else if(callRecord.getAnswerAddressAreaCode().matches("[0][7][9][234567890]|[0][7][0][1]")){
                                user.get(j).getUsersRecords().addCallingInProvinceRecords(callRecord);
                            }
                            else user.get(j).getUsersRecords().addCallingInLandRecords(callRecord);
                        }
                        else if(callRecord.getCallingAddressAreaCode().matches("[0][7][9][234567890]|[0][7][0][1]")){
                            user.get(j).getUsersRecords().addCallingProvinceRecords(callRecord);
                        }
                        else user.get(j).getUsersRecords().addCallingLandRecords(callRecord);
                    }
                }
            }
            else if(s.matches("t-1\\d{10} 0\\d{2,3} 1\\d{10} 0\\d{2,3} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2}")){
                int j = 0;
                for (; j < user.size(); j++) {
                    if (user.get(j).getNumber().equals(parseInput.ParseInputCalNumber(s))) {
                        CallRecord callRecord = new CallRecord();
                        callRecord.setStartTime(parseInput.ParseInputStartDate(s));
                        callRecord.setEndTime(parseInput.ParseInputEndData(s));
                        callRecord.setCallingNumber(parseInput.ParseInputCalNumber(s));
                        callRecord.setAnswerNumber(parseInput.ParseInputAnswerNumber(s));
                        callRecord.setAnswerAddressAreaCode(parseInput.EndParseArea(s));
                        callRecord.setCallingAddressAreaCode(parseInput.StartParseArea(s));
                        if (callRecord.getCallingAddressAreaCode().matches("0791")){
                            if(callRecord.getAnswerAddressAreaCode().matches("0791")){
                                user.get(j).getUsersRecords().addCallingInCityRecords(callRecord);
                            }
                            else if(callRecord.getAnswerAddressAreaCode().matches("[0][7][9][234567890]|[0][7][0][1]")){
                                user.get(j).getUsersRecords().addCallingInProvinceRecords(callRecord);
                            }
                            else user.get(j).getUsersRecords().addCallingInLandRecords(callRecord);
                        }
                        else if(callRecord.getCallingAddressAreaCode().matches("[0][7][9][234567890]|[0][7][0][1]")){
                            user.get(j).getUsersRecords().addCallingProvinceRecords(callRecord);
                        }
                        else user.get(j).getUsersRecords().addCallingLandRecords(callRecord);
                    }
                }
                int k = 0;
                for (; k < user.size(); k++) {
                    if (user.get(k).getNumber().equals(parseInput.ParseInputAnswerNumber(s))) {
                        CallRecord callRecord = new CallRecord();
                        callRecord.setStartTime(parseInput.ParseInputStartDate(s));
                        callRecord.setEndTime(parseInput.ParseInputEndData(s));
                        callRecord.setCallingNumber(parseInput.ParseInputCalNumber(s));
                        callRecord.setAnswerNumber(parseInput.ParseInputAnswerNumber(s));
                        callRecord.setAnswerAddressAreaCode(parseInput.EndParseArea(s));
                        callRecord.setCallingAddressAreaCode(parseInput.StartParseArea(s));
                        if (callRecord.getAnswerAddressAreaCode().matches("0791")) {
                            user.get(k).getUsersRecords().addAnswerInCityRecords(callRecord);
                        } else if (callRecord.getAnswerAddressAreaCode().matches("[0][7][9][234567890]|[0][7][0][1]")) {
                            user.get(k).getUsersRecords().addAnswerInProvinceRecords(callRecord);
                        } else user.get(k).getUsersRecords().addAnswerInLandRecords(callRecord);
                    }
                }

            }
                s = input.nextLine();
        }

        Collections.sort(user);

        for (i = 0;i< user.size();i++){
            System.out.println(user.get(i).getNumber()+" "+String.format("%.1f",user.get(i).CalCost())+" "+String.format("%.1f",user.get(i).CalBalance()));
        }
    }
}

abstract class CallChargeRule extends ChargeRule{
    public abstract double calCost(ArrayList<CallRecord> callRecords) throws Exception;

}
class CallRecord extends CommunicationRecord {
    private Date startTime;
    private Date endTime;

    private String callingAddressAreaCode;
    private 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;
    }

    public int getTimeOf() throws Exception {
        SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        String start = simpleFormat.format(startTime);
        String end = simpleFormat.format(endTime);
        Date fromM = simpleFormat.parse(start.substring(0, 16));
        Date toM = simpleFormat.parse(end.substring(0, 16));

        simpleFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        start = simpleFormat.format(startTime);
        end = simpleFormat.format(endTime);
        int secondStart = Integer.parseInt(start.substring(17, 19));
        int secondEnd = Integer.parseInt(end.substring(17, 19));

        long from = fromM.getTime();
        long to = toM.getTime();
        int gap = (int) ((to - from) / (1000 * 60));

        if (secondEnd > secondStart) {
            gap++;
        }

        if (gap > 0) {
            return gap;
        } else return 0;
    }
}
abstract class ChargeMode {
    public ArrayList<ChargeRule> getChargeRules() {
        return chargeRules;
    }

    public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
        this.chargeRules = chargeRules;
    }

    private ArrayList<ChargeRule> chargeRules = new ArrayList<ChargeRule>();

    public abstract double CalCost(UsersRecords usersRecords) throws Exception;

    public abstract double getMonthlyRent();
}
abstract class ChargeRule {
}
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 DateUtil {

    private int year;
    private int month;
    private int day;

    public DateUtil(){

    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    public DateUtil(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public boolean checkInputValidity(){
        if (month > 0 && month < 13 && day > 0 && day < 32) {
            if (isLeapYear(year)) {
                if ((day>29&&month==2)||(day>30&&month==4)||(day>30&&month==6)||(day>30&&month==9)||(day>30&&month==11)){
                    return false;
                } else {
                    return true;
                }
            }
            else {
                if ((day>28&&month==2)||(day>30&&month==4)||(day>30&&month==6)||(day>30&&month==9)||(day>30&&month==11)) {
                    return false;
                } else {
                    return true;
                }
            }
        }
        else {
            return false;
        }
    }//检测输入的年、月、日是否合法
    public boolean isLeapYear(int year){
        if(year%400==0){
            return true;
        }
        else if(year%4==0&&year%100!=0){
            return true;
        }
        else {
            return false;
        }
    }//判断year是否为闰年
}
class LandingPhoneCharging extends ChargeMode{

    CallChargeRule city = new LandPhoneInCityRule();
    CallChargeRule province = new LandPhoneInProvinceRule();
    CallChargeRule land = new LandPhoneInLandRule();

    @Override
    public double CalCost(UsersRecords usersRecords) throws Exception{
        double sum = 0;
        sum += city.calCost(usersRecords.getCallingInCityRecords());
        sum += province.calCost(usersRecords.getCallingInProvinceRecords());
        sum += land.calCost(usersRecords.getCallingInLandRecords());

        return sum;
    }

    @Override
    public double getMonthlyRent() {
        return monthlyRent;
    }

    private double monthlyRent = 20;
}
class LandPhoneInCityRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords)throws Exception{
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.1;
        }
        return sum;
    }
}
class LandPhoneInLandRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords)throws Exception {
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.6;
        }
        return sum;
    }
}
class LandPhoneInProvinceRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords)throws Exception {
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.3;
        }
        return sum;
    }
}
class MessageRecord extends CommunicationRecord{
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}
class MobilePhoneAnswerProvince extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) throws Exception {
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.3;
        }
        return sum;
    }
}
class MobilePhoneCharging extends ChargeMode{
    private double monthlyRent = 15;

    CallChargeRule city = new MobilePhoneCityRule();
    CallChargeRule province = new MobilePhoneProvinceRule();
    CallChargeRule land = new MobilePhoneLandRule();
    CallChargeRule answer = new MobilePhoneAnswerProvince();
    CallChargeRule province_ = new MobilePhoneProvince();
    CallChargeRule land_ = new MobilePhoneLand();

    @Override
    public double CalCost(UsersRecords usersRecords) throws Exception {
        double sum = 0;
        sum+=city.calCost(usersRecords.getCallingInCityRecords());
        sum+=province.calCost(usersRecords.getCallingInProvinceRecords());
        sum+=land.calCost(usersRecords.getCallingInLandRecords());
        sum+=province_.calCost(usersRecords.getCallingProvinceRecords());
        sum+=land_.calCost(usersRecords.getCallingLandRecords());
        sum+=answer.calCost(usersRecords.getAnswerInLandRecords());
        return sum;
    }

    @Override
    public double getMonthlyRent() {
        return monthlyRent;
    }
}
class MobilePhoneCityRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) throws Exception {
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.1;
        }
        return sum;
    }
}
class MobilePhoneLand extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) throws Exception {
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.6;
        }
        return sum;
    }
}
class MobilePhoneLandRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) throws Exception {
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.3;
        }
        return sum;
    }
}
class MobilePhoneProvince extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) throws Exception {
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.3;
        }
        return sum;
    }
}
class MobilePhoneProvinceRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) throws Exception {
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.2;
        }
        return sum;
    }
}
class ParseInput {

    public String ParseInputNumber(String s){
        String ss[]=s.split("-");
        String sss[] =ss[1].split(" ");
        return sss[0];
    }

    public Date ParseInputStartDate(String s){
        String ss[]=s.split("-");
        String sss[] =ss[1].split(" ");
        String ssss[] = sss[sss.length-4].split("\\.");
        String time[] = sss[sss.length-3].split(":");
        int year = Integer.parseInt(ssss[0]);
        int month = Integer.parseInt(ssss[1]);
        int day = Integer.parseInt(ssss[2]);
        int hour = Integer.parseInt(time[0]);
        int minute = Integer.parseInt(time[1]);
        int second = Integer.parseInt(time[2]);
        Date date = new Date(year-1900,month-1,day,hour,minute,second);
        return date;
    }

    public Date ParseInputEndData(String s){
        String ss[]=s.split("-");
        String sss[] =ss[1].split(" ");
        String ssss[] = sss[sss.length-2].split("\\.");
        String time[] = sss[sss.length-1].split(":");
        int year = Integer.parseInt(ssss[0]);
        int month = Integer.parseInt(ssss[1]);
        int day = Integer.parseInt(ssss[2]);
        int hour = Integer.parseInt(time[0]);
        int minute = Integer.parseInt(time[1]);
        int second = Integer.parseInt(time[2]);
        Date date = new Date(year-1900,month-1,day,hour,minute,second);
        return date;
    }

    public String ParseInputCalNumber(String s){
        String ss[]=s.split("-");
        String sss[] = ss[1].split(" ");
        return sss[0];
    }

    public String ParseInputAnswerNumber(String s){
        String ss[] = s.split(" ");
        if(ss[1].length()==4||ss[1].length()==3){
            return ss[2];
        }
        return ss[1];
    }

    public int ParseNumberArea(String s){
        String regex1 = "0791[0-9]{7,8}";
        String regex2 = "079[023456789][0-9]{7,8}";
        String regex3 = "0701[0-9]{7,8}";
        if(s.matches(regex1)) {
            return 1;
        }
        else if(s.matches(regex2)||s.matches(regex3)) {
            return 2;
        }
        return 0;
    }

    public String StartParseArea(String s){
        String ss[]=s.split(" ");
        if(ss[1].length()==4||ss[1].length()==3){
            return ss[1];
        }
        else {
            String sss[] = ss[0].split("-");
            return sss[1].substring(0,4);
        }
    }

    public String EndParseArea(String s){
        String ss[] = s.split(" ");
        if(ss[1].length()==4||ss[1].length()==3){
            if(ss[3].length()==4||ss[3].length()==3){
                return ss[3];
            }
            else {
                return ss[2].substring(0,4);
            }
        }
        else {
            if(ss[2].length()==4||ss[2].length()==3){
                return ss[2];
            }
            else {
                return ss[1].substring(0,4);
            }
        }
    }

    public boolean ParseTimeFormat(String s){
        String ss[]=s.split("-");
        String sss[] =ss[1].split(" ");
        String startDate[] = sss[sss.length-4].split("\\.");
        String endDate[] = sss[sss.length-2].split("\\.");


        DateUtil dateUtilStart = new DateUtil(Integer.parseInt(startDate[0]), Integer.parseInt(startDate[1]), Integer.parseInt(startDate[2]));
        DateUtil dateUtilEnd = new DateUtil(Integer.parseInt(endDate[0]),Integer.parseInt(endDate[1]),Integer.parseInt(endDate[2]));


        return dateUtilEnd.checkInputValidity()&&dateUtilStart.checkInputValidity();
    }
}
class User implements Comparable<User>{

    private UsersRecords usersRecords = new UsersRecords();
    private double balance = 100;
    private ChargeMode chargeMode;
    private String number;

    public User(String number){
        this.number = number;
        if (!number.matches("[1][0-9]{10}"))
            chargeMode = new LandingPhoneCharging();
        else chargeMode = new MobilePhoneCharging();
    }

    public User() {

    }

    public double CalCost()throws Exception{
        return chargeMode.CalCost(getUsersRecords());
    }

    public double CalBalance()throws Exception{
        this.balance = balance - CalCost() - chargeMode.getMonthlyRent();
        return balance;
    }

    public double getBalance() {
        return balance;
    }

    public UsersRecords getUsersRecords() {
        return usersRecords;
    }

    public void setUsersRecords(UsersRecords usersRecords) {
        this.usersRecords = usersRecords;
    }

    public ChargeMode getChargeMode() {
        return chargeMode;
    }

    public void setChargeMode(ChargeMode chargeMode) {
        this.chargeMode = chargeMode;
    }

    public String getNumber() {
        return number;
    }

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

    @Override
    public int compareTo(User o) {
        return this.getNumber().compareTo(o.getNumber());
    }
}

class UsersRecords {

    private ArrayList<CallRecord> callingInCityRecords = new ArrayList<CallRecord>();//市内拨打电话
    private ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<CallRecord>();//省内拨打电话
    private ArrayList<CallRecord> callingInLandRecords = new ArrayList<CallRecord>();//国内拨打电话
    private ArrayList<CallRecord> callingProvinceRecords = new ArrayList<CallRecord>();//在省内拨打电话
    private ArrayList<CallRecord> callingLandRecords = new ArrayList<CallRecord>();//在省外拨打电话
    private ArrayList<CallRecord> answerInCityRecords = new ArrayList<CallRecord>();//市内接听电话
    private ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<CallRecord>();//省内接听电话
    private ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();//国内接听电话
    private ArrayList<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();//发出短信
    private ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<MessageRecord>();//接收短信

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

    public ArrayList<MessageRecord> getSendMessageRecords() {
        return sendMessageRecords;
    }

    public ArrayList<MessageRecord> getReceiveMessageRecords() {
        return receiveMessageRecords;
    }

    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 callRecord){
        answerInCityRecords.add(callRecord);
    }

    public void addAnswerInProvinceRecords(CallRecord callRecord){
        answerInProvinceRecords.add(callRecord);
    }

    public void addAnswerInLandRecords(CallRecord callRecord){
        answerInLandRecords.add(callRecord);
    }

    public void addSendMessageRecords(MessageRecord messageRecord){
        sendMessageRecords.add(messageRecord);
    }

    public void addReceiveMessageRecords(MessageRecord messageRecord){
        receiveMessageRecords.add(messageRecord);
    }

    public ArrayList<CallRecord> getCallingProvinceRecords() {
        return callingProvinceRecords;
    }

    public void addCallingProvinceRecords(CallRecord callRecord) {
        callingProvinceRecords.add(callRecord);
    }

    public ArrayList<CallRecord> getCallingLandRecords() {
        return callingLandRecords;
    }

    public void addCallingLandRecords(CallRecord callRecord) {
        callingLandRecords.add(callRecord);
    }
}

类图如下：和上图差不多

分析：

这次作业和上次相比增加了手机号码的用户，这对正则表达式的要求会变得更加高的

并且手机用户接听电话也会收费，所以在第一题的基础之上还要加上这个。

对于第一题已经完成的也用不了多久。

实现一个简单的电信计费程序，针对手机的短信采用如下计费方式：
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）。

 

注意：以上图中所定义的类不是限定要求，根据实际需要自行补充或修改。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Main {
    public static void main(String[] args)throws Exception {
        Scanner input = new Scanner(System.in);
        ArrayList<User> user = new ArrayList<>();
        ParseInput parseInput = new ParseInput();
        String s = input.nextLine();
        String regex = "[u][-]0791[0-9]{7,8}[ ][0]";
        String regex2 = "[u][-][1][0-9]{10}[ ][1]";
        String regex3 = "[u][-][1][0-9]{10}[ ][3]";
        String regex_ = "";
        String regex2_ = " ";
        int i = 0;
        boolean flag = false;
        while (!s.equals("end")) {
           
            if(s.matches(regex3)){
                for (int l = 0; l < user.size(); l++) {
                    if (parseInput.ParseInputNumber(s).equals(user.get(l).getNumber())) {
                        flag = true;
                    }
                }
                if (!flag) {
                    user.add(new User(parseInput.ParseInputNumber(s)));
                    user.get(i).setUsersRecords(new UsersRecords());
                    i++;
                }
                flag =false;
            }
            //座机打座机
           
            //手机拨打座机
           
            else if(s.matches("m-1[3-9]\\d{9} 1[3-9]\\d{9} [a-z|0-9| |,|.]+")) {
                int j = 0;
                for (; j < user.size(); j++) {
                    if (user.get(j).getNumber().equals(parseInput.ParseInputCalNumber(s))) {
                        MessageRecord messageRecord = new MessageRecord();
                        String message = parseInput.getMessage(s);
                        int l = parseInput.getMessage(s).length();
                        int k = 0;
                        while (l>10){
                            messageRecord.setMessage(message.substring(k,k+10));
                            user.get(j).getUsersRecords().addSendMessageRecords(messageRecord);
                            messageRecord = new MessageRecord();
                            l-=10;
                        }
                        messageRecord.setMessage(message.substring(k));
                        user.get(j).getUsersRecords().addSendMessageRecords(messageRecord);
                    }
                }
            }
                s = input.nextLine();
        }

        Collections.sort(user);

        for (i = 0;i< user.size();i++){
            System.out.println(user.get(i).getNumber()+" "+String.format("%.1f",user.get(i).CalCost())+" "+String.format("%.1f",user.get(i).CalBalance()));
        }
    }
}
abstract class CallChargeRule extends ChargeRule{
    public abstract double calCost(ArrayList<CallRecord> callRecords) throws Exception;

}
class CallRecord extends CommunicationRecord {
    private Date startTime;
    private Date endTime;

    private String callingAddressAreaCode;
    private 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;
    }

    public int getTimeOf() throws Exception {
        SimpleDateFormat simpleFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        String start = simpleFormat.format(startTime);
        String end = simpleFormat.format(endTime);
        Date fromM = simpleFormat.parse(start.substring(0, 16));
        Date toM = simpleFormat.parse(end.substring(0, 16));

        simpleFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        start = simpleFormat.format(startTime);
        end = simpleFormat.format(endTime);
        int secondStart = Integer.parseInt(start.substring(17, 19));
        int secondEnd = Integer.parseInt(end.substring(17, 19));

        long from = fromM.getTime();
        long to = toM.getTime();
        int gap = (int) ((to - from) / (1000 * 60));

        if (secondEnd > secondStart) {
            gap++;
        }

        if (gap > 0) {
            return gap;
        } else return 0;
    }
}
abstract class ChargeMode {
    public ArrayList<ChargeRule> getChargeRules() {
        return chargeRules;
    }

    public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
        this.chargeRules = chargeRules;
    }

    private ArrayList<ChargeRule> chargeRules = new ArrayList<ChargeRule>();

    public abstract double CalCost(UsersRecords usersRecords) throws Exception;

    public abstract double getMonthlyRent();
}
abstract class ChargeRule {
}
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 DateUtil {

    private int year;
    private int month;
    private int day;

    public DateUtil(){

    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    public DateUtil(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public boolean checkInputValidity(){
        if (month > 0 && month < 13 && day > 0 && day < 32) {
            if (isLeapYear(year)) {
                if ((day>29&&month==2)||(day>30&&month==4)||(day>30&&month==6)||(day>30&&month==9)||(day>30&&month==11)){
                    return false;
                } else {
                    return true;
                }
            }
            else {
                if ((day>28&&month==2)||(day>30&&month==4)||(day>30&&month==6)||(day>30&&month==9)||(day>30&&month==11)) {
                    return false;
                } else {
                    return true;
                }
            }
        }
        else {
            return false;
        }
    }//检测输入的年、月、日是否合法
    public boolean isLeapYear(int year){
        if(year%400==0){
            return true;
        }
        else if(year%4==0&&year%100!=0){
            return true;
        }
        else {
            return false;
        }
    }//判断year是否为闰年
}
class LandingPhoneCharging extends ChargeMode{

    CallChargeRule city = new LandPhoneInCityRule();
    CallChargeRule province = new LandPhoneInProvinceRule();
    CallChargeRule land = new LandPhoneInLandRule();

    @Override
    public double CalCost(UsersRecords usersRecords) throws Exception{
        double sum = 0;
        sum += city.calCost(usersRecords.getCallingInCityRecords());
        sum += province.calCost(usersRecords.getCallingInProvinceRecords());
        sum += land.calCost(usersRecords.getCallingInLandRecords());

        return sum;
    }

    @Override
    public double getMonthlyRent() {
        return monthlyRent;
    }

    private double monthlyRent = 20;
}
class LandPhoneInCityRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords)throws Exception{
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.1;
        }
        return sum;
    }
}
class LandPhoneInLandRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords)throws Exception {
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.6;
        }
        return sum;
    }
}
class LandPhoneInProvinceRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords)throws Exception {
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.3;
        }
        return sum;
    }
}
abstract class MessageChargeRule extends ChargeRule{
    public abstract double calCost(ArrayList<MessageRecord> messageRecords) throws Exception;
}
class MessageRecord extends CommunicationRecord{
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}
class MobilePhoneAnswerProvince extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) throws Exception {
        int i = 0;
        double sum = 0;
        for(;i<callRecords.size();i++){
            sum += callRecords.get(i).getTimeOf()*0.3;
        }
        return sum;
    }
}
class MobilePhoneMessageCharging extends ChargeMode{

    private double monthlyRent = 0;
    MobilePhoneMessageRule mobilePhoneMessageRule = new MobilePhoneMessageRule();
    @Override
    public double CalCost(UsersRecords usersRecords) throws Exception {
        double sum = 0;
        sum=mobilePhoneMessageRule.calCost(usersRecords.getSendMessageRecords());
        return sum;
    }

    @Override
    public double getMonthlyRent() {
        return this.monthlyRent;
    }
}
class MobilePhoneMessageRule extends MessageChargeRule{

    @Override
    public double calCost(ArrayList<MessageRecord> messageRecords) throws Exception {
        int l = messageRecords.size();
        if(l<=3){
            return 0.1*l;
        }
        else if(l>3&&l<=5){
            return 0.3+0.2*(l-3);
        }
        else
            return 0.7+0.3*(l-5);
    }
}

class ParseInput {

    public String ParseInputNumber(String s){
        String ss[]=s.split("-");
        String sss[] =ss[1].split(" ");
        return sss[0];
    }

    public Date ParseInputStartDate(String s){
        String ss[]=s.split("-");
        String sss[] =ss[1].split(" ");
        String ssss[] = sss[sss.length-4].split("\\.");
        String time[] = sss[sss.length-3].split(":");
        int year = Integer.parseInt(ssss[0]);
        int month = Integer.parseInt(ssss[1]);
        int day = Integer.parseInt(ssss[2]);
        int hour = Integer.parseInt(time[0]);
        int minute = Integer.parseInt(time[1]);
        int second = Integer.parseInt(time[2]);
        Date date = new Date(year-1900,month-1,day,hour,minute,second);
        return date;
    }

    public Date ParseInputEndData(String s){
        String ss[]=s.split("-");
        String sss[] =ss[1].split(" ");
        String ssss[] = sss[sss.length-2].split("\\.");
        String time[] = sss[sss.length-1].split(":");
        int year = Integer.parseInt(ssss[0]);
        int month = Integer.parseInt(ssss[1]);
        int day = Integer.parseInt(ssss[2]);
        int hour = Integer.parseInt(time[0]);
        int minute = Integer.parseInt(time[1]);
        int second = Integer.parseInt(time[2]);
        Date date = new Date(year-1900,month-1,day,hour,minute,second);
        return date;
    }

    public String ParseInputCalNumber(String s){
        String ss[]=s.split("-");
        String sss[] = ss[1].split(" ");
        return sss[0];
    }

    public String ParseInputAnswerNumber(String s){
        String ss[] = s.split(" ");
        if(ss[1].length()==4||ss[1].length()==3){
            return ss[2];
        }
        return ss[1];
    }

    public int ParseNumberArea(String s){
        String regex1 = "0791[0-9]{7,8}";
        String regex2 = "079[023456789][0-9]{7,8}";
        String regex3 = "0701[0-9]{7,8}";
        if(s.matches(regex1)) {
            return 1;
        }
        else if(s.matches(regex2)||s.matches(regex3)) {
            return 2;
        }
        return 0;
    }

    public String StartParseArea(String s){
        String ss[]=s.split(" ");
        if(ss[1].length()==4||ss[1].length()==3){
            return ss[1];
        }
        else {
            String sss[] = ss[0].split("-");
            return sss[1].substring(0,4);
        }
    }

    public String EndParseArea(String s){
        String ss[] = s.split(" ");
        if(ss[1].length()==4||ss[1].length()==3){
            if(ss[3].length()==4||ss[3].length()==3){
                return ss[3];
            }
            else {
                return ss[2].substring(0,4);
            }
        }
        else {
            if(ss[2].length()==4||ss[2].length()==3){
                return ss[2];
            }
            else {
                return ss[1].substring(0,4);
            }
        }
    }

    public boolean ParseTimeFormat(String s){
        String ss[]=s.split("-");
        String sss[] =ss[1].split(" ");
        String startDate[] = sss[sss.length-4].split("\\.");
        String endDate[] = sss[sss.length-2].split("\\.");


        DateUtil dateUtilStart = new DateUtil(Integer.parseInt(startDate[0]), Integer.parseInt(startDate[1]), Integer.parseInt(startDate[2]));
        DateUtil dateUtilEnd = new DateUtil(Integer.parseInt(endDate[0]),Integer.parseInt(endDate[1]),Integer.parseInt(endDate[2]));


        return dateUtilEnd.checkInputValidity()&&dateUtilStart.checkInputValidity();
    }

    public String getMessage(String s){
        return s.substring(26);
    }
}
class User implements Comparable<User>{

    private UsersRecords usersRecords = new UsersRecords();
    private double balance = 100;
    private ChargeMode chargeMode;
    private String number;

    public User(String number){
        this.number = number;
        if (!number.matches("[1][0-9]{10}"))
            chargeMode = new LandingPhoneCharging();
        else chargeMode = new MobilePhoneMessageCharging();
    }

    public User() {

    }

    public double CalCost()throws Exception{
        return chargeMode.CalCost(getUsersRecords());
    }

    public double CalBalance()throws Exception{
        this.balance = balance - CalCost() - chargeMode.getMonthlyRent();
        return balance;
    }

    public double getBalance() {
        return balance;
    }

    public UsersRecords getUsersRecords() {
        return usersRecords;
    }

    public void setUsersRecords(UsersRecords usersRecords) {
        this.usersRecords = usersRecords;
    }

    public ChargeMode getChargeMode() {
        return chargeMode;
    }

    public void setChargeMode(ChargeMode chargeMode) {
        this.chargeMode = chargeMode;
    }

    public String getNumber() {
        return number;
    }

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

    @Override
    public int compareTo(User o) {
        return this.getNumber().compareTo(o.getNumber());
    }
}
class UsersRecords {

    private ArrayList<CallRecord> callingInCityRecords = new ArrayList<CallRecord>();//市内拨打电话
    private ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<CallRecord>();//省内拨打电话
    private ArrayList<CallRecord> callingInLandRecords = new ArrayList<CallRecord>();//国内拨打电话
    private ArrayList<CallRecord> callingProvinceRecords = new ArrayList<CallRecord>();//在省内拨打电话
    private ArrayList<CallRecord> callingLandRecords = new ArrayList<CallRecord>();//在省外拨打电话
    private ArrayList<CallRecord> answerInCityRecords = new ArrayList<CallRecord>();//市内接听电话
    private ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<CallRecord>();//省内接听电话
    private ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();//国内接听电话
    private ArrayList<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();//发出短信
    private ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<MessageRecord>();//接收短信

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

    public ArrayList<MessageRecord> getSendMessageRecords() {
        return sendMessageRecords;
    }

    public ArrayList<MessageRecord> getReceiveMessageRecords() {
        return receiveMessageRecords;
    }

    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 callRecord){
        answerInCityRecords.add(callRecord);
    }

    public void addAnswerInProvinceRecords(CallRecord callRecord){
        answerInProvinceRecords.add(callRecord);
    }

    public void addAnswerInLandRecords(CallRecord callRecord){
        answerInLandRecords.add(callRecord);
    }

    public void addSendMessageRecords(MessageRecord messageRecord){
        sendMessageRecords.add(messageRecord);
    }

    public void addReceiveMessageRecords(MessageRecord messageRecord){
        receiveMessageRecords.add(messageRecord);
    }

    public ArrayList<CallRecord> getCallingProvinceRecords() {
        return callingProvinceRecords;
    }

    public void addCallingProvinceRecords(CallRecord callRecord) {
        callingProvinceRecords.add(callRecord);
    }

    public ArrayList<CallRecord> getCallingLandRecords() {
        return callingLandRecords;
    }

    public void addCallingLandRecords(CallRecord callRecord) {
        callingLandRecords.add(callRecord);
    }
}

 

类图与上图一样

分析：

这次只考察短信计费，所以这次的难点只有正则表达式。然后这次对代码长度进行了限制

所以需要对之前的代码进行删改

 

踩坑心得：

1.正则表达式在这三道题中有很大的作用，非常重要。

2.类的设计的完整性。

3.整个代码的耦合性。

 

改进建议：

在跨月时，对于月租这个属性应该也要考虑

 

总结：

一学期的Java课程结束了，感觉自己的编码能力还有待提高。