第三次博客作业

前言：

　　在上一个月的课程学习中，我吸收掌握了很多具有拓展性、延申性的知识，其中包含类与对象的构造、组成，以及在封装、继承、多态原则优化后的代码结构基础上，进行抽象类、抽象方法的联系与应用。在第六次至第八次PTA大作业中，我们接触并实现了以类与对象为基础的电信计费系列的编程，三次的题目分别从座机计费、手机座机计费、短信计费出发,对关于构造类知识的掌握、类图的分析与理解做出了考察。三次大作业中，电信计费系列的题目难度偏大，但主要原因在于代码量大、涉及的类与继承关系复杂。不过只要我们能够读懂类图，分析清楚题目的要求，加之对不同信息格式的严格判断，写出符合要求的代码是完全可行的。

设计与分析：

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中User是用户类，包括属性：
userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。

ChargeMode是计费方式的抽象类：
chargeRules是计费方式所包含的各种计费规则的集合，ChargeRule类的定义见图3。
getMonthlyRent（）方法用于返回月租（monthlyRent）。

UserRecords是用户记录类，保存用户各种通话、短信的记录，
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是：
市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。

 

图2中CommunicationRecord是抽象的通讯记录类：
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。

CallRecord（通话记录类）包含属性：
通话的起始、结束时间以及
拨号地点的区号（callingAddressAreaCode）、接听地点的区号（answerAddressAreaCode）。
区号用于记录在哪个地点拨打和接听的电话。座机无法移动，就是本机区号，如果是手机号，则会有差异。

图3是计费规则的相关类，这些类的核心方法是：
calCost（ArrayList<CallRecord> callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。

LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是
座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。
（提示：可以从UserRecords类中获取各种类型的callRecords）。

后续扩展说明：
后续题目集将增加手机用户，手机用户的计费方式中除了与座机计费类似的主叫通话费之外，还包含市外接听电话的漫游费以及发短信的费用。在本题的设计时可统一考虑。
通话记录中，手机需要额外记录拨打/接听的地点的区号，比如：
座机打手机：t-主叫号码 接听号码 接听地点区号 起始时间 结束时间
t-079186330022 13305862264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
手机互打：t-主叫号码 拨号地点 接听号码 接听地点区号 起始时间 结束时间
t-18907910010 0791 13305862264 0371 2022.1.3 10:00:25 2022.1.3 10:05:11
短信的格式：m-主叫号码，接收号码，短信内容
m-18907910010 13305862264 welcome to jiangxi
m-13305862264 18907910010 thank you

输入样例:

在这里给出一组输入。例如：

u-079186300001 0
t-079186300001 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:25
end

输出样例:

在这里给出相应的输出。例如：

079186300001 3.0 77.0

其余参考样例详见附件，未尽事宜以附件样例为准：

电信计费简化版-座机计费说明.pdf

全码展示：

复制代码
import java.text.DecimalFormat;
import java.util.*;
import java.util.ArrayList;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        ArrayList<User> Array = new ArrayList<>();
        boolean flag = false;
        while (!str.equals("end")) {
            if (str.matches("u\\-0791\\d{7,8}\\s0")) {
                String str1[] = str.split("-");
                String str2[] = str1[1].split(" ");
                for (int i = 0; i < Array.size(); i++) {
                    if (Array.get(i).number.equals(str2[0])) {
                        flag = true;
                        break;
                    }
                }
                if (flag == false) {
                    Array.add(new User(str2[0]));
                }
            }
            if (str.matches("t\\-(\\d{10,12})\\s(\\d{10,12})\\s(\\d{4}.([1-9]{1}|1[0-2]).([1-9]{1}|1[0-9]|2[0-9]|3[0-1])\\s(0[0-9]|1[0-9]|2[0-3]):([0-5]{1}[0-9]):([0-5]{1}[0-9]))\\s([0-9]{4}.([1-9]{1}|1[0-2]).([1-9]{1}|1[0-9]|2[0-9]|3[0-1])\\s(0[0-9]|1[0-9]|2[0-3]):([0-5]{1}[0-9]):([0-5]{1}[0-9]))")) {
                String str3[] = str.split("-");
                String str4[] = str3[1].split(" ");
                for (int i = 0; i < Array.size(); i++) {
                    if (Array.get(i).number.equals(str4[0])) {
                        if (str4[1].substring(0, 4).matches("0791")) {
                            Array.get(i).getUserRecords().addgetCallingInCityRecords(new CallRecord(str4[2] + " " + str4[3], str4[4] + " " + str4[5]));
                            Array.get(i).setUserRecords(Array.get(i).getUserRecords());
                        } else if (str4[1].substring(0, 4).matches("079\\d|0701")) {
                            Array.get(i).getUserRecords().addgetCallingInProvinceRecords(new CallRecord(str4[2] + " " + str4[3], str4[4] + " " + str4[5]));
                            Array.get(i).setUserRecords(Array.get(i).getUserRecords());
                        } else {
                            Array.get(i).getUserRecords().addgetCallingInLandRecords(new CallRecord(str4[2] + " " + str4[3], str4[4] + " " + str4[5]));
                            Array.get(i).setUserRecords(Array.get(i).getUserRecords());
                        }
                    }
                }
            }
            str = sc.nextLine();
        }
        
        Collections.sort(Array,new Comparator<User>(){
            public int compare(User u1,User u2){
                int num = Math.toIntExact(Long.parseLong(u1.getNumber()) - Long.parseLong(u2.getNumber()));
                return num;
            }
        });

        for (int i = 0; i < Array.size(); i++) {
            System.out.println(Array.get(i).number + " " + new DecimalFormat("0.0#").format(Array.get(i).calCost()) + " " + new DecimalFormat("0.0#").format(Array.get(i).getBalance() - Array.get(i).calCost() - 20));
        }
    }
}

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

class CallRecord extends CommunicationRecord{
    private Date startTime;
    private Date endTime;
    private String callingAddressAreaCode;
    private String answerAddressAreaCode;

    public CallRecord(String startTime, String endTime)  {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
        try {
            this.startTime = simpleDateFormat.parse(startTime);
        } catch (ParseException e) {
        }
        try {
            this.endTime = simpleDateFormat.parse(endTime);
        } catch (ParseException e) {
        }
    }

    public Date getStartTime() {
        return startTime;
    }

    public void setStartTime(Date startTime) {
        this.startTime = startTime;
    }

    public String getCallingAddressAreaCode() {
        return callingAddressAreaCode;
    }

    public void setCallingAddressAreaCode(String callingAddressAreaCode) {
        this.callingAddressAreaCode = callingAddressAreaCode;
    }

    public Date getEndTime() {
        return endTime;
    }

    public void setEndTime(Date endTime) {
        this.endTime = endTime;
    }

    public String getAnswerAddressAreaCode() {
        return answerAddressAreaCode;
    }

    public void setAnswerAddressAreaCode(String answerAddressAreaCode) {
        this.answerAddressAreaCode = answerAddressAreaCode;
    }
}

abstract class ChargeMode {
    ArrayList<ChargeRule> chargeRules = new ArrayList<>();

    public ArrayList<ChargeRule> getChargeRules() {
        return this.chargeRules;
    }

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

    public abstract double calCost(UserRecords userRecords);

    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 LandlinePhoneCharging extends ChargeMode{
    private double monthlyRent = 20;

    @Override
    public double calCost(UserRecords userRecords) {
        return 0;
    }

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

class LandPhoneInCityRule extends CallChargeRule {
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double cost = 0;
        double minutes = 0;
        for (CallRecord e : callRecords) {
            long diff = e.getEndTime().getTime() - e.getStartTime().getTime();
            minutes = (int) Math.ceil((double) diff / (double) 60000);
            cost += 0.1 * minutes;
        }
        return cost;
    }
}

class LandPhoneInLandRule extends CallChargeRule {
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double cost = 0;
        double minutes;
        for(CallRecord e:callRecords){
            long diff = e.getEndTime().getTime() - e.getStartTime().getTime();
            minutes = (int) Math.ceil((double) diff / (double) 60000);
            cost += 0.6*minutes;
        }
        return cost;
    }
}

class LandPhoneInProvinceRule extends CallChargeRule {
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double cost = 0;
        double minutes;
        for (CallRecord e : callRecords) {
            long diff = e.getEndTime().getTime() - e.getStartTime().getTime();
            minutes = (int) Math.ceil((double) diff / (double) 60000);
            cost += 0.3 * minutes;
        }
        return cost;
    }
}

class MessageRecord extends CommunicationRecord{
    private String message;

    public String getMessage() {
        return message;
    }

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

class User {
    private UserRecords userRecords = new UserRecords();
    double balance = 100;
    String number;
    ChargeMode chargeMode;

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

    public double CalBalance(){
        //return 0;
        return balance - calCost();
    }

    public double calCost(){
        LandPhoneInCityRule landPhoneInCityRule = new LandPhoneInCityRule();
        LandPhoneInLandRule landPhoneInLandRule = new LandPhoneInLandRule();
        LandPhoneInProvinceRule landPhoneInProvinceRule = new LandPhoneInProvinceRule();
        return landPhoneInLandRule.calCost(userRecords.getCallingInLandRecords())+landPhoneInCityRule.calCost(userRecords.getCallingInCityRecords())+landPhoneInProvinceRule.calCost(userRecords.getCallingInProvinceRecords());
    }

    public UserRecords getUserRecords() {
        return userRecords;
    }

    public void setUserRecords(UserRecords userRecords) {
        this.userRecords = userRecords;
    }

    public double getBalance() {
        return balance;
    }

    public String getNumber() {
        return number;
    }

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

    public ChargeMode getChargeMode() {
        return chargeMode;
    }

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

class UserRecords {
    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 addgetCallingInCityRecords(CallRecord callRecord) {
        getCallingInCityRecords().add(callRecord);
    }

    public void addgetCallingInProvinceRecords(CallRecord callRecord) {
        getCallingInProvinceRecords().add(callRecord);
    }

    public void addgetCallingInLandRecords(CallRecord callRecord) {
        getCallingInLandRecords().add(callRecord);
    }

    public void addAnswerInCityRecords(CallRecord answerRecord) {
        answerInCityRecords.add(answerRecord);
    }

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

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

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

    public void addReceiveMessageRecords(MessageRecord receiveMessageRecord) {
        receiveMessageRecords.add(receiveMessageRecord);
    }
}
View Code
复制代码

 SourceMonitor分析图：

 

 IDEA生成程序类图：

 

 总结：

　　本题作为电信计费系列的第一道题，需要我们将题干中给出的类图进行详细的分析，从中提取关键信息组成完成的可运行代码。对于本题我的思路和解题步骤可总结如下：首先构造出电信计费系列的基本框架，即弄清楚都有些什么具体的类，类与类之间的继承关系是怎样的。比如通过第一张类图，我们可以认为它是用来讲用户的，其讲清楚了三个类：用户类User，用户记录类UserRecords，以及计费方式ChargeMode。其中ChargeMode是抽象类，我们可以同时确定继承ChargeMode的是哪些类，以及三种类之间的联系。按照同样的方式分析类图2与类图3，我们可以认为它们分别是通讯记录类和计费规则相关类，之再后向类中填入方法，同时注意抽象类的抽象方法，以及继承时对方法的引用做出相应的改变。

 

7-2 电信计费系列2-手机+座机计费

实现南昌市电信分公司的计费程序，假设该公司针对手机和座机用户分别采取了两种计费方案，分别如下：
1、针对市内座机用户采用的计费方式（与电信计费系列1内容相同）：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
假设本市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。
2、针对手机用户采用实时计费方式：
月租15元，市内省内接电话均免费，市内拨打市内电话0.1元/分钟，市内拨打省内电话0.2元/分钟，市内拨打省外电话0.3元/分钟，省内漫游打电话0.3元/分钟，省外漫游接听0.3元/分钟，省外漫游拨打0.6元/分钟；
注：被叫电话属于市内、省内还是国内由被叫电话的接听地点区号决定，比如以下案例中，南昌市手机用户13307912264在区号为020的广州接听了电话，主叫号码应被计算为拨打了一个省外长途，同时，手机用户13307912264也要被计算省外接听漫游费：
u-13307912264 1
t-079186330022 13307912264 020 2022.1.3 10:00:25 2022.1.3 10:05:11

输入：
输入信息包括两种类型
1、逐行输入南昌市用户开户的信息，每行一个用户，含手机和座机用户
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐）
例如：u-079186300001 0
座机号码由区号和电话号码拼接而成，电话号码包含7-8位数字，区号最高位是0。
手机号码由11位数字构成，最高位是1。
本题在电信计费系列1基础上增加类型1-手机实时计费。
手机设置0或者座机设置成1，此种错误可不做判断。
2、逐行输入本月某些用户的通讯信息，通讯信息格式：
座机呼叫座机：t-主叫号码 接听号码 起始时间 结束时间
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四项内容之间以一个英文空格分隔，
时间必须符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat类。
输入格式增加手机接打电话以及收发短信的格式，手机接打电话的信息除了号码之外需要额外记录拨打/接听的地点的区号，比如：
座机打手机：
t-主叫号码 接听号码 接听地点区号 起始时间 结束时间
t-079186330022 13305862264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
手机互打：
t-主叫号码 拨号地点 接听号码 接听地点区号 起始时间 结束时间
t-18907910010 0791 13305862264 0371 2022.1.3 10:00:25 2022.1.3 10:05:11

注意：以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。

输出：
根据输入的详细通讯信息，计算所有已开户的用户的当月费用（精确到小数点后2位，单位元）。假设每个用户初始余额是100元。
每条通讯、短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。

本题只做格式的错误判断，无需做内容上不合理的判断，比如同一个电话两条通讯记录的时间有重合、开户号码非南昌市的号码等，此类情况都当成正确的输入计算。但时间的输入必须符合要求，比如不能输入2022.13.61 28:72:65。

建议类图：
参见图1、2、3：

图1中User是用户类，包括属性：
userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。
ChargeMode是计费方式的抽象类：
chargeRules是计费方式所包含的各种计费规则的集合，ChargeRule类的定义见图3。
getMonthlyRent（）方法用于返回月租（monthlyRent）。
UserRecords是用户记录类，保存用户各种通话、短信的记录，
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是：
市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。

图2中CommunicationRecord是抽象的通讯记录类：
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。CallRecord（通话记录类）包含属性：
通话的起始、结束时间以及
拨号地点的区号（callingAddressAreaCode）、接听地点的区号（answerAddressAreaCode）。
区号用于记录在哪个地点拨打和接听的电话。座机无法移动，就是本机区号，如果是手机号，则会有差异。

图3是计费规则的相关类，这些类的核心方法是：
calCost（ArrayList<CallRecord> callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。
SendMessageRule是发送短信的计费规则类，用于计算发送短信的费用。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。

（提示：可以从UserRecords类中获取各种类型的callRecords）。
注意：以上图中所定义的类不是限定要求，根据实际需要自行补充或修改。

输入样例:

在这里给出一组输入。例如：

u-13811111111 1
t-13811111111 0791 13811111110 020 2022.1.3 08:00:00 2022.1.3 08:09:20
end

输出样例:

在这里给出相应的输出。例如：

13811111111 3.0 82.0

更多内容详见附件：

电信计费简化版-座机计费说明.pdf

全码如下：

复制代码
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        ArrayList<User> Array = new ArrayList<>();
        boolean flag = false;
        while (!str.equals("end")) {
            flag = false;
            if (str.matches("u\\-0791\\d{7,8}\\s0") || str.matches("u\\-1\\d{10}\\s1")) {
                String str1[] = str.split("-");
                String str2[] = str1[1].split(" ");
                for (int i = 0; i < Array.size(); i++) {
                    if (Array.get(i).getNumber().equals(str2[0])) {
                        flag = true;
                        break;
                    }
                }
                if (flag == false) {
                    User user = new User(str2[0]);
                    if (str.matches("u\\-0791\\d{7,8}\\s0")) {
                        LandLinePhoneCharging landLinePhoneCharging = new LandLinePhoneCharging();
                        user.setChargeMode(landLinePhoneCharging);
                    } else if (str.matches("u\\-1\\d{10}\\s1")) {
                        MobilePhoneCharging mobilePhoneCharging = new MobilePhoneCharging();
                        user.setChargeMode(mobilePhoneCharging);
                    }
                    Array.add(user);
                }
            }

            //座机打座机
            if (str.matches("t-0\\d{9,11}\\s0\\d{9,11}\\s([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3}\\.(1[0-2]|[1-9])\\.([1-9]|(1|2)[0-9]|(30|31)) ([0|1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}")) {
                String str3[] = str.split("-");
                String str4[] = str3[1].split(" ");
                for (int i = 0; i < Array.size(); i++) {
                    if (Array.get(i).getNumber().equals(str4[0])) {
                        if (str4[1].substring(0, 4).matches("0791")) {
                            Array.get(i).getUserRecords().addCallingInCityRecords(new CallRecord(str4[2] + " " + str4[3], str4[4] + " " + str4[5]));
                        } else if (str4[1].substring(0, 4).matches("079\\d|0701")) {
                            Array.get(i).getUserRecords().addCallingInProvinceRecords(new CallRecord(str4[2] + " " + str4[3], str4[4] + " " + str4[5]));
                        } else {
                            Array.get(i).getUserRecords().addCallingInLandRecords(new CallRecord(str4[2] + " " + str4[3], str4[4] + " " + str4[5]));
                        }
                    }
                }//座机打手机
            } else if (str.matches("t-\\d{10,12}\\s1\\d{10}\\s\\d{3,4}\\s([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3}\\.(1[0-2]|[1-9])\\.([1-9]|(1|2)[0-9]|(30|31)) ([0|1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}")) {
                String str3[] = str.split("-");
                String str4[] = str3[1].split(" ");
                for (int i = 0; i < Array.size(); i++) {
                    if (Array.get(i).getNumber().equals(str4[0])) {
                        if (str4[2].matches("0791")) {
                            Array.get(i).getUserRecords().addCallingInCityRecords(new CallRecord(str4[3] + " " + str4[4], str4[5] + " " + str4[6]));
                        } else if (str4[2].matches("079\\d|0701")) {
                            Array.get(i).getUserRecords().addCallingInProvinceRecords(new CallRecord(str4[3] + " " + str4[4], str4[5] + " " + str4[6]));
                        } else {
                            Array.get(i).getUserRecords().addCallingInLandRecords(new CallRecord(str4[3] + " " + str4[4], str4[5] + " " + str4[6]));
                        }
                    }
                    if (Array.get(i).getNumber().equals(str4[1])) {
                        if (!str4[2].matches("0791|079\\d|0701")) {
                            Array.get(i).getUserRecords().addanswerInLandRecords(new CallRecord(str4[3] + " " + str4[4], str4[5] + " " + str4[6]));
                        }
                    }
                }//手机打手机
            } else if (str.matches("t-\\d{11}\\s\\d{3,4}\\s\\d{11}\\s\\d{3,4}\\s([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3}\\.(1[0-2]|[1-9])\\.([1-9]|(1|2)[0-9]|(30|31)) ([0|1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}")) {
                String str3[] = str.split("-");
                String str4[] = str3[1].split(" ");
                for (int i = 0; i < Array.size(); i++) {
                    if (Array.get(i).getNumber().equals(str4[0])) {
                        if (str4[1].matches("0791")) {
                            if (str4[3].matches("0791")) {
                                Array.get(i).getUserRecords().addCityCallingInCityRecords(new CallRecord(str4[4] + " " + str4[5], str4[6] + " " + str4[7]));
                            } else if (str4[3].matches("079\\d|0701")) {
                                Array.get(i).getUserRecords().addCityCallingInProvinceRecords(new CallRecord(str4[4] + " " + str4[5], str4[6] + " " + str4[7]));
                            } else {
                                Array.get(i).getUserRecords().addCityCallingInLandRecords(new CallRecord(str4[4] + " " + str4[5], str4[6] + " " + str4[7]));
                            }
                        } else if (str4[1].matches("079\\d|0701")) {
                            Array.get(i).getUserRecords().addProvinceCallingRecords(new CallRecord(str4[4] + " " + str4[5], str4[6] + " " + str4[7]));
                        } else {
                            Array.get(i).getUserRecords().addLandCallingRecords(new CallRecord(str4[4] + " " + str4[5], str4[6] + " " + str4[7]));
                        }
                    }
                    if (Array.get(i).getNumber().equals(str4[2])) {
                        if (!str4[3].matches("0791|079\\d|0701")) {
                            Array.get(i).getUserRecords().addanswerInLandRecords(new CallRecord(str4[4] + " " + str4[5], str4[6] + " " + str4[7]));
                        }
                    }
                }//手机打座机
            } else if (str.matches("t-\\d{11}\\s\\d{3,4}\\s\\d{10,12}\\s([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3}\\.(1[0-2]|[1-9])\\.([1-9]|(1|2)[0-9]|(30|31)) ([0|1][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}")) {
                String str3[] = str.split("-");
                String str4[] = str3[1].split(" ");
                for (int i = 0; i < Array.size(); i++) {
                    if (Array.get(i).getNumber().equals(str4[0])) {
                        if (str4[1].matches("0791")) {
                            if (str4[2].substring(0, 4).matches("0791")) {
                                Array.get(i).getUserRecords().addCityCallingInCityRecords(new CallRecord(str4[3] + " " + str4[4], str4[5] + " " + str4[6]));
                            } else if (str4[2].substring(0, 4).matches("079\\d|0701")) {
                                Array.get(i).getUserRecords().addCityCallingInProvinceRecords(new CallRecord(str4[3] + " " + str4[4], str4[5] + " " + str4[6]));
                            } else {
                                Array.get(i).getUserRecords().addCityCallingInLandRecords(new CallRecord(str4[3] + " " + str4[4], str4[5] + " " + str4[6]));
                            }
                        } else if (str4[1].matches("079\\d|0701")) {
                            Array.get(i).getUserRecords().addProvinceCallingRecords(new CallRecord(str4[3] + " " + str4[4], str4[5] + " " + str4[6]));
                        } else {
                            Array.get(i).getUserRecords().addLandCallingRecords(new CallRecord(str4[3] + " " + str4[4], str4[5] + " " + str4[6]));
                        }
                    }
                }
            }
            str = sc.nextLine();
        }

        //按照号码顺序排列
        Collections.sort(Array, new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o1.getNumber().compareTo(o2.getNumber());
            }
        });

        for (int i = 0; i < Array.size(); i++) {
            System.out.println(Array.get(i).getNumber() + " " + new DecimalFormat("0.0#").format(Array.get(i).getChargeMode().calCost(Array.get(i).getUserRecords())) + " " + new DecimalFormat("0.0#").format(Array.get(i).getBalance() - Array.get(i).getChargeMode().calCost(Array.get(i).getUserRecords()) - Array.get(i).getChargeMode().getMonthlyRent()));
        }
    }
}

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

class CallRecord extends CommunicationRecord {
    private Date startTime;
    private Date endTime;
    private String callingAddressAreaCode;
    private String answerAddressAreaCode;

    public CallRecord() {

    }

    public CallRecord(String startTime, String endTime) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
        try {
            this.startTime = simpleDateFormat.parse(startTime);
        } catch (ParseException e) {
        }

        try {
            this.endTime = simpleDateFormat.parse(endTime);
        } catch (ParseException e) {
        }

    }

    public Date getStartTime() {
        return startTime;
    }

    public void setStartTime(Date startTime) {
        this.startTime = startTime;
    }

    public String getCallingAddressAreaCode() {
        return callingAddressAreaCode;
    }

    public void setCallingAddressAreaCode(String callingAddressAreaCode) {
        this.callingAddressAreaCode = callingAddressAreaCode;
    }

    public Date getEndTime() {
        return endTime;
    }

    public void setEndTime(Date endTime) {
        this.endTime = endTime;
    }

    public String getAnswerAddressAreaCode() {
        return answerAddressAreaCode;
    }

    public void setAnswerAddressAreaCode(String answerAddressAreaCode) {
        this.answerAddressAreaCode = answerAddressAreaCode;
    }
}

abstract class ChargeMode {
    ArrayList<ChargeRule> chargeRules = new ArrayList<>();

    public ArrayList<ChargeRule> getChargeRules() {
        return this.chargeRules;
    }

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

    public abstract double calCost(UserRecords userRecords);

    public abstract double getMonthlyRent();
}

abstract class ChargeRule {
}

abstract class CommunicationRecord {
    protected String callingNumber;
    protected String answerNumber;

    public CommunicationRecord(){

    }

    public CommunicationRecord(String callingNumber, String answerNumber) {
        this.callingNumber = callingNumber;
        this.answerNumber = answerNumber;
    }

    public String getCallingNumber() {
        return callingNumber;
    }

    public void setCallingNumber(String callingNumber) {
        this.callingNumber = callingNumber;
    }

    public String getAnswerNumber() {
        return answerNumber;
    }

    public void setAnswerNumber(String answerNumber) {
        this.answerNumber = answerNumber;
    }
}

class LandLinePhoneCharging extends ChargeMode {
    private double monthlyRent = 20;

    public LandLinePhoneCharging() {

    }

    @Override
    public double calCost(UserRecords userRecords) {
        double cost1 = new LandPhoneInCityRule().calCost(userRecords.getCallingInCityRecords());
        double cost2 = new LandPhoneInProvinceRule().calCost(userRecords.getCallingInProvinceRecords());
        double cost3 = new LandPhoneInLandRule().calCost(userRecords.getCallingInLandRecords());
        return cost1 + cost2 + cost3;
    }

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

class LandPhoneInCityRule extends CallChargeRule {
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double cost = 0;
        double minutes = 0;
        for (CallRecord e : callRecords) {
            long diff = e.getEndTime().getTime() - e.getStartTime().getTime();
            //System.out.println(diff);
            minutes = (int) Math.ceil((double) diff / (double) 60000);
            cost += 0.1 * minutes;
        }
        return cost;
    }
}

class LandPhoneInLandRule extends CallChargeRule {
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double cost = 0;
        double minutes;
        for(CallRecord e:callRecords){
            long diff = e.getEndTime().getTime() - e.getStartTime().getTime();
            // System.out.println(diff);
            minutes = (int) Math.ceil((double) diff / (double) 60000);
            cost += 0.6*minutes;
        }
        return cost;
    }
}

class LandPhoneInProvinceRule extends CallChargeRule {
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double cost = 0;
        double minutes;
        for (CallRecord e : callRecords) {
            long diff = e.getEndTime().getTime() - e.getStartTime().getTime();
            //System.out.println(diff);
            minutes = (int) Math.ceil((double) diff / (double) 60000);
            cost += 0.3 * minutes;
        }
        return cost;
    }
}

class MobilePhoneAnswerInLand extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double cost = 0;
        double minutes = 0;
        for (CallRecord e : callRecords) {
            long diff = e.getEndTime().getTime() - e.getStartTime().getTime();
            //System.out.println(diff);
            minutes = (int) Math.ceil((double) diff / (double) 60000);
            cost += 0.3 * minutes;
        }
        return cost;
    }
}

class MobilePhoneCallingInLand extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double cost = 0;
        double minutes = 0;
        for (CallRecord e : callRecords) {
            long diff = e.getEndTime().getTime() - e.getStartTime().getTime();
            //System.out.println(diff);
            minutes = (int) Math.ceil((double) diff / (double) 60000);
            cost += 0.6 * minutes;
        }
        return cost;
    }
}

class MobilePhoneCallingInProvince extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double cost = 0;
        double minutes = 0;
        for (CallRecord e : callRecords) {
            long diff = e.getEndTime().getTime() - e.getStartTime().getTime();
            //System.out.println(diff);
            minutes = (int) Math.ceil((double) diff / (double) 60000);
            cost += 0.3 * minutes;
        }
        return cost;
    }
}

class MobilePhoneCharging extends ChargeMode {
    private double MonthlyRent = 15;

    @Override
    public double calCost(UserRecords userRecords) {
        double cost1 = new MobilePhoneCityToCity().calCost(userRecords.getCityCallingInCityRecords());
        double cost2 = new MobilePhoneCityToProvince().calCost(userRecords.getCityCallingInProvinceRecords());
        double cost3 = new MobilePhoneCityToLand().calCost(userRecords.getCityCallingInLandRecords());
        double cost4 = new MobilePhoneCallingInProvince().calCost(userRecords.getProvinceCallingRecords());
        double cost5 = new MobilePhoneCallingInLand().calCost(userRecords.getLandCallingRecords());
        double cost6 = new MobilePhoneAnswerInLand().calCost(userRecords.getAnswerInLandRecords());
        return cost1 + cost2 + cost3 + cost4 + cost5 + cost6;
    }

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

class MobilePhoneCityToCity extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double cost = 0;
        double minutes = 0;
        for (CallRecord e : callRecords) {
            long diff = e.getEndTime().getTime() - e.getStartTime().getTime();
            minutes = (int) Math.ceil((double) diff / (double) 60000);
            cost += 0.1 * minutes;
        }
        return cost;
    }
}

class MobilePhoneCityToLand extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double cost = 0;
        double minutes = 0;
        for (CallRecord e : callRecords) {
            long diff = e.getEndTime().getTime() - e.getStartTime().getTime();
            //System.out.println(diff);
            minutes = (int) Math.ceil((double) diff / (double) 60000);
            cost += 0.3 * minutes;
        }
        return cost;
    }
}

class MobilePhoneCityToProvince extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double cost = 0;
        double minutes = 0;
        for (CallRecord e : callRecords) {
            long diff = e.getEndTime().getTime() - e.getStartTime().getTime();
            //System.out.println(diff);
            minutes = (int) Math.ceil((double) diff / (double) 60000);
            cost += 0.2 * minutes;
        }
        return cost;
    }
}

class User {
    private UserRecords userRecords = new UserRecords();
    private double balance = 100;
    private String number;
    private ChargeMode chargeMode;

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

    public double CalBalance() {
        //return 0;
        return balance - calCost() - chargeMode.getMonthlyRent();
    }

    public double calCost() {
        LandPhoneInCityRule landPhoneInCityRule = new LandPhoneInCityRule();
        LandPhoneInLandRule landPhoneInLandRule = new LandPhoneInLandRule();
        LandPhoneInProvinceRule landPhoneInProvinceRule = new LandPhoneInProvinceRule();
        return landPhoneInLandRule.calCost(userRecords.getCallingInLandRecords()) + landPhoneInCityRule.calCost(userRecords.getCallingInCityRecords()) + landPhoneInProvinceRule.calCost(userRecords.getCallingInProvinceRecords());
    }

    public UserRecords getUserRecords() {
        return userRecords;
    }

    public void setUserRecords(UserRecords userRecords) {
        this.userRecords = userRecords;
    }

    public double getBalance() {
        return balance;
    }

    public String getNumber() {
        return number;
    }

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

    public ChargeMode getChargeMode() {
        return chargeMode;
    }

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

class UserRecords {
    private ArrayList<CallRecord> CallingInCityRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> CallingInProvinceRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> CallingInLandRecords = new ArrayList<CallRecord>();

    private ArrayList<CallRecord> CityCallingInCityRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> CityCallingInProvinceRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> CityCallingInLandRecords = new ArrayList<CallRecord>();

    private ArrayList<CallRecord> ProvinceCallingRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> LandCallingRecords = new ArrayList<CallRecord>();

    private ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();
    
    public void addCityCallingInCityRecords(CallRecord callRecord){
        CityCallingInCityRecords.add(callRecord);
    }
    public void addCityCallingInProvinceRecords(CallRecord callRecord){
        CityCallingInProvinceRecords.add(callRecord);
    }
    public void addCityCallingInLandRecords(CallRecord callRecord){
        CityCallingInLandRecords.add(callRecord);
    }

    public ArrayList<CallRecord> getCityCallingInCityRecords() {
        return CityCallingInCityRecords;
    }

    public ArrayList<CallRecord> getCityCallingInProvinceRecords() {
        return CityCallingInProvinceRecords;
    }

    public ArrayList<CallRecord> getCityCallingInLandRecords() {
        return CityCallingInLandRecords;
    }

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

    public void addLandCallingRecords(CallRecord callRecord) {
        LandCallingRecords.add(callRecord);
    }

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

    public ArrayList<CallRecord> getCallingInCityRecords() {
        return CallingInCityRecords;
    }

    public ArrayList<CallRecord> getCallingInProvinceRecords() {
        return CallingInProvinceRecords;
    }

    public ArrayList<CallRecord> getCallingInLandRecords() {
        return CallingInLandRecords;
    }

    public ArrayList<CallRecord> getProvinceCallingRecords() {
        return ProvinceCallingRecords;
    }

    public ArrayList<CallRecord> getLandCallingRecords() {
        return LandCallingRecords;
    }

    public ArrayList<CallRecord> getAnswerInLandRecords() {
        return answerInLandRecords;
    }
}
View Code
复制代码

 SourceMonitor分析图：

 

 IDEA生成程序类图：

 

总结：

　　本题是电信计费系列的第二题，在上一题座机计费的基础上添加了手机计费的功能和计费准则，本题关键点在于添加新继承在原抽象类下的子类。举个例子，CallChargeRule是电信计费的抽象规则类，但是在手机座机并列计费的情况下，对于抽象规则类我们要添加继承在它之下的子类。本题中还加入了更多非常复杂的格式判定，对正则表达式的理解和掌握程度有非常大的考察力度。

 

7-3 电信计费系列3-短信计费

实现一个简单的电信计费程序，针对手机的短信采用如下计费方式：
1、接收短信免费，发送短信0.1元/条，超过3条0.2元/条，超过5条0.3元/条。
2、如果一次发送短信的字符数量超过10个，按每10个字符一条短信进行计算。

输入：
输入信息包括两种类型
1、逐行输入南昌市手机用户开户的信息，每行一个用户。
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐 3-手机短信计费）
例如：u-13305862264 3
座机号码由区号和电话号码拼接而成，电话号码包含7-8位数字，区号最高位是0。
手机号码由11位数字构成，最高位是1。
本题只针对类型3-手机短信计费。
2、逐行输入本月某些用户的短信信息，短信的格式：
m-主叫号码，接收号码，短信内容 （短信内容只能由数字、字母、空格、英文逗号、英文句号组成）
m-18907910010 13305862264 welcome to jiangxi.
m-13305862264 18907910010 thank you.

注意：以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
输出：
根据输入的详细短信信息，计算所有已开户的用户的当月短信费用（精确到小数点后2位，单位元）。假设每个用户初始余额是100元。
每条短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
本题只做格式的错误判断，无需做内容上不合理的判断，比如同一个电话两条通讯记录的时间有重合、开户号码非南昌市的号码、自己给自己打电话等，此类情况都当成正确的输入计算。但时间的输入必须符合要求，比如不能输入2022.13.61 28:72:65。

本题只考虑短信计费，不考虑通信费用以及月租费。

建议类图：
参见图1、2、3：

图1中User是用户类，包括属性：
userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。
ChargeMode是计费方式的抽象类：
chargeRules是计费方式所包含的各种计费规则的集合，ChargeRule类的定义见图3。
getMonthlyRent（）方法用于返回月租（monthlyRent）。
UserRecords是用户记录类，保存用户各种通话、短信的记录，
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是：
市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。

图2中CommunicationRecord是抽象的通讯记录类：
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。

图3是计费规则的相关类，这些类的核心方法是：
calCost（ArrayList callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。
SendMessageRule是发送短信的计费规则类，用于计算发送短信的费用。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。

（提示：可以从UserRecords类中获取各种类型的callRecords）。

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

输入样例:

在这里给出一组输入。例如：

u-18907910010 3
m-18907910010 13305862264 aaaaaaaaaaaaaaaaaaaaaaa
end

输出样例:

在这里给出相应的输出。例如：

18907910010 0.3 99.7

在这里给出一组输入。例如：

u-18907910010 3
m-18907910010 13305862264 aaaaaaaaaaaa
m-18907910010 13305862264 aaaaaaa.
m-18907910010 13305862264 bb,bbbb
end

输出样例1:

在这里给出相应的输出。例如：

18907910010 0.5 99.5

全码如下：

复制代码
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        ArrayList<User> Array = new ArrayList<>();
        boolean flag = false;
        while (!str.equals("end")) {
           // flag = false;
            if (str.matches("u\\-1\\d{10}\\s3")) {
                String str1[] = str.split("-");
                String str2[] = str1[1].split(" ");
                for (int i = 0; i < Array.size(); i++) {
                    if (Array.get(i).getNumber().equals(str2[0])) {
                        flag = true;
                        break;
                    }
                }
                if (flag == false) {
                    User user = new User(str2[0]);
                    MessagePhoneCharging messagePhoneCharging = new MessagePhoneCharging();
                    user.setChargeMode(messagePhoneCharging);
                    Array.add(user);
                }
            }

            if(str.matches("m\\-1\\d{10}\\s1\\d{10}\\s[0-9a-zA-Z\\s\\.\\,]+")){
                String str3[] = str.split("-");
                String str4[] = str3[1].split(" ");
                String str5 = str3[1].substring(24);
                for (int i = 0; i < Array.size(); i++) {
                    if(Array.get(i).getNumber().equals(str4[0])){
                        Array.get(i).getUserRecords().addSendMessageRecords(new MessageRecord(str5));
                    }
                }
            }
            str = sc.nextLine();
        }

        //按照号码顺序排列
        Collections.sort(Array, new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o1.getNumber().compareTo(o2.getNumber());
            }
        });

        for (int i = 0; i < Array.size(); i++) {
            System.out.println(Array.get(i).getNumber() + " " + new DecimalFormat("0.0#").format(Array.get(i).getChargeMode().calCost(Array.get(i).getUserRecords())) + " " + new DecimalFormat("0.0#").format(Array.get(i).getBalance() - Array.get(i).getChargeMode().calCost(Array.get(i).getUserRecords()) - Array.get(i).getChargeMode().getMonthlyRent()));
        }
    }
}

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

class CallRecord extends CommunicationRecord {
    private Date startTime;
    private Date endTime;
    private String callingAddressAreaCode;
    private String answerAddressAreaCode;

    public CallRecord() {

    }

    public CallRecord(String startTime, String endTime) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
        try {
            this.startTime = simpleDateFormat.parse(startTime);
        } catch (ParseException e) {
        }

        try {
            this.endTime = simpleDateFormat.parse(endTime);
        } catch (ParseException e) {
        }

    }

    public Date getStartTime() {
        return startTime;
    }

    public void setStartTime(Date startTime) {
        this.startTime = startTime;
    }

    public String getCallingAddressAreaCode() {
        return callingAddressAreaCode;
    }

    public void setCallingAddressAreaCode(String callingAddressAreaCode) {
        this.callingAddressAreaCode = callingAddressAreaCode;
    }

    public Date getEndTime() {
        return endTime;
    }

    public void setEndTime(Date endTime) {
        this.endTime = endTime;
    }

    public String getAnswerAddressAreaCode() {
        return answerAddressAreaCode;
    }

    public void setAnswerAddressAreaCode(String answerAddressAreaCode) {
        this.answerAddressAreaCode = answerAddressAreaCode;
    }
}

abstract class ChargeMode {
    ArrayList<ChargeRule> chargeRules = new ArrayList<>();

    public ArrayList<ChargeRule> getChargeRules() {
        return this.chargeRules;
    }

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

    public abstract double calCost(UserRecords userRecords);

    public abstract double getMonthlyRent();
}

abstract class ChargeRule {
}

abstract class CommunicationRecord {
    protected String callingNumber;
    protected String answerNumber;

    public CommunicationRecord(){

    }

    public CommunicationRecord(String callingNumber, String answerNumber) {
        this.callingNumber = callingNumber;
        this.answerNumber = 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;
    }
}

abstract class MessageChargeRule extends ChargeRule{
    public abstract double calCost(ArrayList<MessageRecord> messageRecord);
}

class MessagePhoneCharging extends ChargeMode {
    @Override
    public double calCost(UserRecords userRecords) {
        double cost = new SendMessageRule().calCost(userRecords.getSendMessageRecords());
        return cost;
    }

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

class MessageRecord extends CommunicationRecord {
    private String message;

    public MessageRecord(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

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

class SendMessageRule extends MessageChargeRule {
    @Override
    public double calCost(ArrayList<MessageRecord> messageRecord) {
        double cost = 0;
        int cnt = 0;
        for (MessageRecord m : messageRecord) {
            if (m.getMessage().length() % 10 * 10 / 10 == 0) {
                cnt += m.getMessage().length() * 10 / 100;
            } else {
                cnt += m.getMessage().length() * 10 / 100 + 1;
            }
        }
        if (cnt > 5) {
            cost = 0.7 + (cnt - 5) * 0.3;
        } else if (cnt <= 5 && cnt > 3) {
            cost = 0.3 + 0.2 * (cnt - 3);
        } else {
            cost = 0.1 * cnt;
        }
        return cost;
    }
}

class User {
    private UserRecords userRecords = new UserRecords();
    private double balance = 100;
    private String number;
    private ChargeMode chargeMode;

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

    public double CalBalance() {
        //return 0;
        return balance - calCost() - chargeMode.getMonthlyRent();
    }

    public double calCost() {
        return 0;
    }

    public UserRecords getUserRecords() {
        return userRecords;
    }

    public void setUserRecords(UserRecords userRecords) {
        this.userRecords = userRecords;
    }

    public double getBalance() {
        return balance;
    }

    public String getNumber() {
        return number;
    }

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

    public ChargeMode getChargeMode() {
        return chargeMode;
    }

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

class UserRecords {
    private ArrayList<CallRecord> CallingInCityRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> CallingInProvinceRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> CallingInLandRecords = new ArrayList<CallRecord>();

    private ArrayList<CallRecord> CityCallingInCityRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> CityCallingInProvinceRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> CityCallingInLandRecords = new ArrayList<CallRecord>();

    private ArrayList<CallRecord> ProvinceCallingRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> LandCallingRecords = 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 void addCityCallingInCityRecords(CallRecord callRecord) {
        CityCallingInCityRecords.add(callRecord);
    }

    public void addCityCallingInProvinceRecords(CallRecord callRecord) {
        CityCallingInProvinceRecords.add(callRecord);
    }

    public void addCityCallingInLandRecords(CallRecord callRecord) {
        CityCallingInLandRecords.add(callRecord);
    }

    public ArrayList<CallRecord> getCityCallingInCityRecords() {
        return CityCallingInCityRecords;
    }

    public ArrayList<CallRecord> getCityCallingInProvinceRecords() {
        return CityCallingInProvinceRecords;
    }

    public ArrayList<CallRecord> getCityCallingInLandRecords() {
        return CityCallingInLandRecords;
    }

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

    public void addLandCallingRecords(CallRecord callRecord) {
        LandCallingRecords.add(callRecord);
    }

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

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

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

    public ArrayList<CallRecord> getCallingInCityRecords() {
        return CallingInCityRecords;
    }

    public ArrayList<CallRecord> getCallingInProvinceRecords() {
        return CallingInProvinceRecords;
    }

    public ArrayList<CallRecord> getCallingInLandRecords() {
        return CallingInLandRecords;
    }

    public ArrayList<CallRecord> getProvinceCallingRecords() {
        return ProvinceCallingRecords;
    }

    public ArrayList<CallRecord> getLandCallingRecords() {
        return LandCallingRecords;
    }

    public ArrayList<CallRecord> getAnswerInLandRecords() {
        return answerInLandRecords;
    }

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

    public ArrayList<MessageRecord> getReceiveMessageRecords() {
        return receiveMessageRecords;
    }
}
View Code
复制代码

SourceMonitor分析图：

 

 IDEA生成程序类图：

 总结：

　　本题是电信计费系列的第三题，本题的测试点仅有短信计费，和手机计费不同，我们可以像考虑座机计费的构成那样去思考，而无需进一步完善先前的体系。

 

踩坑心得

在过去一个月的学习中，我再次总结了如下几个自己容易犯的错误：

　　1、设计类的时候忘记添加构造函数。一般题目中其实很少用到构造函数，但作为学习的过程，添加构造函数也是创建一个完整类的一部分。以及设计父类的构造方法后忘记也要在子类的构造方法中添加super。

　　2、对正则表达式的理解匮乏。

　　3、对新知识的掌握尚未完全。在这个阶段的学习中，我们在类与对象、方法基本构建、继承、多态的使用的基础上，新学习并着重强化了对抽象类、抽象方法的构造，接口的加入（这个在实验里比较多）。

改进意见

　　　在看到题目时，首先要分析题目中蕴含的结构。比如电信计费都给了类图，相当于已经告知了基本结构，那我们就要分析都有哪些类，创建什么对象，继承关系是怎样的，子类的方法哪些可以直接继承抽象父类使用，哪些是自己独有的方法。其次，要扎实自己的基本功。思路清晰的同时，要学会根据不同的题干环境进行变通。比如第一题，建立了用户方面，还需要建立通讯记录，既然是电信计费，那就要建立对应的计费准则。第一题仅考虑电信计费中的座机，第二题就要学会在其基础上加入对手机的操作，第三题由于出题的原因可以简略很多。

总结

　　通过SourceMontior检测发现，自己写的部分代码各项数值的测量值和规定的范围相差甚远，说明还有很多的提升空间。Java是一门以面向对象为主的编程语言，所以对类和对象及其方法的要求十分看重。在对类的使用上还有所欠缺，相信在以后的学习中会越来越好。

posted @   Micellae  阅读(18)  评论(0)  编辑  收藏  举报
相关博文：
·  第一次博客作业
·  第二次博客作业
·  BLOG-3
·  blog-3
·  第三次博客作业
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· 阿里巴巴 QwQ-32B真的超越了 DeepSeek R-1吗？
· 【译】Visual Studio 中新的强大生产力特性
· 【设计模式】告别冗长if-else语句：使用策略模式优化代码结构
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
点击右上角即可分享
微信分享提示
SQL AI 助手