面向对象程序设计第12-15周内容总结

前言

本次PTA题目集09-11主要围绕电信计费系统展开，涉及到的知识点包括继承与多态、对象容器、正则表达式等多方面的内容。每个题目集均以1+N的模式，即1道电信计费系统+N道基础题型，题量适中，其中电信计费系统难度较高，基础题型难度较低。

设计与分析

题目集09

关于整个系统的设计，我将其分为Main、用户端、计费方式、通讯记录四个板块。

1.Main

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

public class Main {

    public static Scanner input = new Scanner(System.in);
    public static String uPattern = "[u]-0791[0-9]{7,8}\\s[0-2]";
    public static String tPattern = "[t]-0791[0-9]{7,8}\\s" + "0[0-9]{9,11}\\s" +
            "((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.(((0?[13578]|1[02])\\.(0?" +
            "[1-9]|[12][0-9]|3[01]))|(([469]|11)\\.([1-9]|[12][0-9]|30))|(2\\.([1-9]|[1][0-9]|2[0-8]))))|(((" +
            "[0-9]{2})([48]|[2468][048]|[13579][26])|(([48]|[2468][048]|[3579][26])00))\\.2\\.29))" +
            "\\s([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])\\s" +
            "((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.((([13578]|1[02])\\.(" +
            "[1-9]|[12][0-9]|3[01]))|(([469]|11)\\.([1-9]|[12][0-9]|30))|(2\\.([1-9]|[1][0-9]|2[0-8]))))|(((" +
            "[0-9]{2})([48]|[2468][048]|[13579][26])|(([48]|[2468][048]|[3579][26])00))\\.2\\.29))" +
            "\\s([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])";
    
    public static String exitPattern = "end";
    public static SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
    
    public static void main(String[] args) {
        
        ArrayList<User> users = new ArrayList<User>();
        boolean isT = false;
        
        while(true) {
            String string = input.nextLine();
            String[] strings = string.split(" ");
            if (string.matches(uPattern) && !isT) {
                User user = new User(strings);
                if (!users.contains(user)) {
                    users.add(user);
                }
            } else if (string.matches(tPattern)) {
                String userNumber = strings[0].substring(2);
                for (User each:users) {
                    if (each.getNumber().equals(userNumber)) {
                        CallRecord callRecord = new CallRecord();
                        String startDateString = strings[2] + " " + strings[3];
                        String endDateString = strings[4] + " " + strings[5];
                        Date startDate;
                        Date endDate;
                        try {
                            startDate = sdf.parse(startDateString);
                        } catch (ParseException e) {
                            continue;
                        }
                        try {
                            endDate = sdf.parse(endDateString);
                        } catch (ParseException e) {
                            continue;
                        }
                        callRecord.setCallingNumber(strings[0].substring(2));
                        callRecord.setAnswerNumber(strings[1]);
                        callRecord.setStartTime(startDate);
                        callRecord.setEndTime(endDate);
                        callRecord.setCallingAddressAreaCode("0791");
                        if (strings[1].substring(0, 4).matches("0791")) {
                            callRecord.setAnswerAddressAreaCode("0791");
                            each.getUserRecords().addCallingInCityRecords(callRecord);
                        } else if (strings[1].substring(0, 4).matches("07(9[0-9]{1}|01)")) {
                            callRecord.setAnswerAddressAreaCode(strings[1].substring(0, 4));
                            each.getUserRecords().addCallingInProvinceRecords(callRecord);
                        } else {
                            callRecord.setAnswerAddressAreaCode(strings[1].substring(0, 4));
                            each.getUserRecords().addCallingInLandRecords(callRecord);
                        }
                        isT = true;
                    }
                }
            } else if (string.matches(exitPattern)) {
                break;
            }
        }
        Collections.sort(users, new Comparator<User>() {
            public int compare(User user1, User user2) {
                return user1.getNumber().compareTo(user2.getNumber());
            }
        });
        for (User each:users) {
            System.out.println(each.getNumber() + " " + String.format("%.1f", each.calCost()) + " " + String.format("%.1f", each.calBalance()));
        }

    }

}

我选择将信息输入工作放在Main函数中完成；

如源码第32-33行所示，我在Main中先一行行读入输入数据，当数据读入成功时，我通过split函数将接收到的数据分割，这样可以更方便的提取需要的信息；

如源码第34、39、76行所示，我将每次读到的行数据进行格式比对，如果遇到格式错误就直接跳过后续步骤，开始读入下一行数据；

如源码第34-38行所示，此时如果模式为u（开通），则程序会在用户库中检索号码是否已被开通，如果没开通，程序将会通过分割后所得的数据实例化一个带参的User对象，并将之写入到用户库中；如果未被开通，则会直接跳过后续步骤，开始读入下一行数据；

附：User的有参构造函数：

public User(String[] strings) {
    number = strings[0].substring(2);
    if (strings[1].equals("0")) {
        chargeMode = new LandlinePhoneCharging();
    }
        balance = 100;
}

 

 

如源码第39-75行所示，此时如果模式为t（通讯），程序会在用户库中检索主叫号码是否已被开通；

如源码第42-72行所示，如果已开通，程序会实例化一个带参的CallRecord对象，根据分割后所得的数据完善这个对象的所有信息，并通过if判断，将它写入主叫号码的对应通话记录中，然后将输入模式修改为t输入模式（源码第73行），此后若读入u模式数据也会被判定为格式错误；如果未被开通，则会直接跳过后续步骤，开始读入下一行数据；

如源码第80-87行所示，当信息完全录入完毕后，程序通过Collection.sort（）函数将用户库中的用户按照号码大小排序，然后依次计算当月资费信息并输出。

 

2.通讯记录

通讯记录类的作用仅为保存通讯信息，故只需要完成数据的写入和输出，即完成getters与setters方法便可，不多做赘述。

 

3.计费方式

计费方式的核心便是calCost（）函数，其中CallChargeRule类与其下属类的calCost（）均是对ChargeRule中的复写；

我对于calCost（）函数的设计为，传入一个泛型为通讯记录类的容器，然后分别计算容器中所有通讯记录的资费并累加后传回，对于不同的计费类型（如LandPhoneInlandRule、LandPhoneInProvinceRule等），计算资费的方式会有所不同；

以下是LandPhoneInCityRule类的源码，仅供参考：

import java.util.ArrayList;

public class LandPhoneInCityRule extends CallChargeRule{

    public LandPhoneInCityRule() {
        // TODO Auto-generated constructor stub
    }
    
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double cost = 0;
        for (CallRecord each:callRecords) {
            long startTime = each.getStartTime().getTime();
            long endTime = each.getEndTime().getTime();
            int minute = (int)(endTime - startTime) / 60000;
            int Second = (int)(endTime - startTime) % 60000 / 1000;
            if (Second > 0) {
                minute ++;
            }
            cost += minute * 0.1;
        }
        return cost;
    }

}

 

4.用户端

用户端的主要作用为储存通讯数据，统计并输出资费信息，其中最为关键的内容为ChargeMode类；

关于chargeMode类，我的设计为：

其私有属性ArrayList<ChargeRule>用于存储相关的具体计费模式，这一步我将它放在实例化时实现；

其calCost（）方法需要传入一个UserRecord对象，然后对于该对象中的不同类型的通话记录采用对应的ChargeRule进行资费计算；

以LandlinePhoneCharging为例，以下是其源码与相应说明：

public class LandlinePhoneCharging extends ChargeMode {
    
    private double monthlyRent = 20;

    public LandlinePhoneCharging() {
        super.getChargeRules().add(new LandPhoneInCityRule());
        super.getChargeRules().add(new LandPhoneInProvinceRule());
        super.getChargeRules().add(new LandPhoneInlandRule());
    }
    
    @Override
    public double calCost(UserRecords userRecords) {
        double cost = 0;
        cost += super.getChargeRules().get(0).calCost(userRecords.getCallingInCityRecords());
        cost += super.getChargeRules().get(1).calCost(userRecords.getCallingInProvinceRecords());
        cost += super.getChargeRules().get(2).calCost(userRecords.getCallingInLandRecords());
        return cost;
    }
    
    @Override
    public double getMonthlyRent() {
        return monthlyRent;
    }

}

如源码第5-9行，当LandlinePhoneCharging类实例化时，程序将会将LandPhoneInCityRule等计费方式写入父类中的ArrayList<ChargeRule>；

如源码第12-18行，程序提取出userRecords中的通讯记录，并调用ArrayList<ChargeRule>中的计费方式对其进行资费计算并累加后传回。

 

题目集10

题目集10中的电信计费问题相比于题目集9新增了手机号码开通与手机主叫功能，对此我仅在题目集9中代码的基础上修改了Main，同时新增了与手机相关的几种计费方式，因此本部分对于题目集9中已有的内容不再赘述。

1.Main

 

 

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

public class Main {

    public static Scanner input = new Scanner(System.in);
    public static String uPattern0 = "[u]-0791[0-9]{7,8}\\s[0]";
    public static String uPattern1 = "[u]-1[0-9]{10}\\s[1]";
    public static String tPattern00 = "[t]-0791[0-9]{7,8}\\s" + "0[0-9]{9,11}\\s";
    public static String tPattern01 = "[t]-0791[0-9]{7,8}\\s" + "1[0-9]{10}\\s" + "0[0-9]{2,3}\\s";
    public static String tPattern10 = "[t]-1[0-9]{10}\\s" + "0[0-9]{2,3}\\s" + "0[0-9]{9,11}\\s";
    public static String tPattern11 = "[t]-1[0-9]{10}\\s" + "0[0-9]{2,3}\\s" + "1[0-9]{10}\\s" + "0[0-9]{2,3}\\s";
    public static String timePattern = "" + 
            "((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.(((0?[13578]|1[02])\\.(0?" +
            "[1-9]|[12][0-9]|3[01]))|(([469]|11)\\.([1-9]|[12][0-9]|30))|(2\\.([1-9]|[1][0-9]|2[0-8]))))|(((" +
            "[0-9]{2})([48]|[2468][048]|[13579][26])|(([48]|[2468][048]|[3579][26])00))\\.2\\.29))" +
            "\\s([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])\\s" +
            "((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.((([13578]|1[02])\\.(" +
            "[1-9]|[12][0-9]|3[01]))|(([469]|11)\\.([1-9]|[12][0-9]|30))|(2\\.([1-9]|[1][0-9]|2[0-8]))))|(((" +
            "[0-9]{2})([48]|[2468][048]|[13579][26])|(([48]|[2468][048]|[3579][26])00))\\.2\\.29))" +
            "\\s([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])";
    
    public static String exitPattern = "end";
    public static SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
    
    public static void main(String[] args) {
        
        ArrayList<User> users = new ArrayList<User>();
        boolean isT = false;
        
        while(true) {
            String string = input.nextLine();
            String[] strings = string.split(" ");
            if ((string.matches(uPattern0) || string.matches(uPattern1)) && !isT) {
                User user = new User(string);
                if (!users.contains(user)) {
                    users.add(user);
                }
            } else if (string.matches(tPattern00 + timePattern)) {
                String userNumber = strings[0].substring(2);
                for (User each:users) {
                    if (each.getNumber().equals(userNumber)) {
                        CallRecord callRecord = new CallRecord();
                        String startDateString = strings[2] + " " + strings[3];
                        String endDateString = strings[4] + " " + strings[5];
                        Date startDate;
                        Date endDate;
                        try {
                            startDate = sdf.parse(startDateString);
                        } catch (ParseException e) {
                            continue;
                        }
                        try {
                            endDate = sdf.parse(endDateString);
                        } catch (ParseException e) {
                            continue;
                        }
                        callRecord.setCallingNumber(strings[0].substring(2));
                        callRecord.setAnswerNumber(strings[2]);
                        callRecord.setStartTime(startDate);
                        callRecord.setEndTime(endDate);
                        callRecord.setCallingAddressAreaCode("0791");
                        if (strings[1].substring(0, 4).matches("0791")) {
                            callRecord.setAnswerAddressAreaCode("0791");
                            each.getUserRecords().addCallToCityRecords(callRecord);
                        } else if (strings[1].substring(0, 4).matches("07(9[0-9]{1}|01)")) {
                            callRecord.setAnswerAddressAreaCode(strings[1].substring(0, 4));
                            each.getUserRecords().addCallToProvinceRecords(callRecord);
                        } else {
                            callRecord.setAnswerAddressAreaCode(strings[1].substring(0, 4));
                            each.getUserRecords().addCallToLandRecords(callRecord);
                        }
                        isT = true;
                    }
                }
            } else if (string.matches(tPattern01 + timePattern)) {
                String userNumber = strings[0].substring(2);
                String answerNumber = strings[1];
                for (User each:users) {
                    if (each.getNumber().equals(userNumber)) {
                        CallRecord callRecord = new CallRecord();
                        String startDateString = strings[3] + " " + strings[4];
                        String endDateString = strings[5] + " " + strings[6];
                        Date startDate;
                        Date endDate;
                        try {
                            startDate = sdf.parse(startDateString);
                        } catch (ParseException e) {
                            continue;
                        }
                        try {
                            endDate = sdf.parse(endDateString);
                        } catch (ParseException e) {
                            continue;
                        }
                        callRecord.setCallingNumber(strings[0].substring(2));
                        callRecord.setAnswerNumber(answerNumber);
                        callRecord.setStartTime(startDate);
                        callRecord.setEndTime(endDate);
                        callRecord.setCallingAddressAreaCode("0791");
                        callRecord.setAnswerAddressAreaCode(strings[2]);
                        if (callRecord.getAnswerAddressAreaCode().matches("0791")) {
                            each.getUserRecords().addCallToCityRecords(callRecord);
                        } else if (callRecord.getAnswerAddressAreaCode().matches("07(9[0-9]{1}|01)")) {
                            each.getUserRecords().addCallToProvinceRecords(callRecord);
                        } else {
                            each.getUserRecords().addCallToLandRecords(callRecord);
                        }
                        isT = true;
                    }
                    if (each.getNumber().equals(answerNumber)) {
                        CallRecord callRecord = new CallRecord();
                        String startDateString = strings[3] + " " + strings[4];
                        String endDateString = strings[5] + " " + strings[6];
                        Date startDate;
                        Date endDate;
                        try {
                            startDate = sdf.parse(startDateString);
                        } catch (ParseException e) {
                            continue;
                        }
                        try {
                            endDate = sdf.parse(endDateString);
                        } catch (ParseException e) {
                            continue;
                        }
                        callRecord.setCallingNumber(strings[0].substring(2));
                        callRecord.setAnswerNumber(answerNumber);
                        callRecord.setStartTime(startDate);
                        callRecord.setEndTime(endDate);
                        callRecord.setCallingAddressAreaCode("0791");
                        callRecord.setAnswerAddressAreaCode(strings[2]);
                        if (!callRecord.getAnswerAddressAreaCode().matches("07(9[0-9]{1}|01)")) {
                            each.getUserRecords().addAnswerOutOfProvinceRecords(callRecord);
                        }
                        isT = true;
                    }
                }
            } else if (string.matches(tPattern10 + timePattern)) {
                String userNumber = strings[0].substring(2);
                String answerNumber = strings[1];
                for (User each:users) {
                    if (each.getNumber().equals(userNumber)) {
                        CallRecord callRecord = new CallRecord();
                        String startDateString = strings[3] + " " + strings[4];
                        String endDateString = strings[5] + " " + strings[6];
                        Date startDate;
                        Date endDate;
                        try {
                            startDate = sdf.parse(startDateString);
                        } catch (ParseException e) {
                            continue;
                        }
                        try {
                            endDate = sdf.parse(endDateString);
                        } catch (ParseException e) {
                            continue;
                        }
                        callRecord.setCallingNumber(strings[0].substring(2));
                        callRecord.setAnswerNumber(answerNumber);
                        callRecord.setStartTime(startDate);
                        callRecord.setEndTime(endDate);
                        callRecord.setCallingAddressAreaCode(strings[1]);
                        callRecord.setAnswerAddressAreaCode(strings[2].substring(0, 4));
                        if (callRecord.getCallingAddressAreaCode().matches("0791")) {
                            if (callRecord.getAnswerAddressAreaCode().matches("0791")) {
                                each.getUserRecords().addCallToCityRecords(callRecord);
                            } else if (callRecord.getAnswerAddressAreaCode().matches("07(9[0-9]{1}|01)")) {
                                each.getUserRecords().addCallToProvinceRecords(callRecord);
                            } else {
                                each.getUserRecords().addCallToLandRecords(callRecord);
                            }
                        } else if (callRecord.getCallingAddressAreaCode().matches("07(9[0-9]{1}|01)")) {
                            each.getUserRecords().addCallOutOfCityRecords(callRecord);
                        } else {
                            each.getUserRecords().addCallOutOfProvinceRecords(callRecord);
                        }
                        isT = true;
                    }
                }
            } else if (string.matches(tPattern11 + timePattern)) {
                String userNumber = strings[0].substring(2);
                String answerNumber = strings[2];
                for (User each:users) {
                    if (each.getNumber().equals(userNumber)) {
                        CallRecord callRecord = new CallRecord();
                        String startDateString = strings[4] + " " + strings[5];
                        String endDateString = strings[6] + " " + strings[7];
                        Date startDate;
                        Date endDate;
                        try {
                            startDate = sdf.parse(startDateString);
                        } catch (ParseException e) {
                            continue;
                        }
                        try {
                            endDate = sdf.parse(endDateString);
                        } catch (ParseException e) {
                            continue;
                        }
                        callRecord.setCallingNumber(strings[0].substring(2));
                        callRecord.setAnswerNumber(answerNumber);
                        callRecord.setStartTime(startDate);
                        callRecord.setEndTime(endDate);
                        callRecord.setCallingAddressAreaCode(strings[1]);
                        callRecord.setAnswerAddressAreaCode(strings[3]);
                        if (callRecord.getCallingAddressAreaCode().matches("0791")) {
                            if (callRecord.getAnswerAddressAreaCode().matches("0791")) {
                                each.getUserRecords().addCallToCityRecords(callRecord);
                            } else if (callRecord.getAnswerAddressAreaCode().matches("07(9[0-9]{1}|01)")) {
                                each.getUserRecords().addCallToProvinceRecords(callRecord);
                            } else {
                                each.getUserRecords().addCallToLandRecords(callRecord);
                            }
                        } else if (callRecord.getCallingAddressAreaCode().matches("07(9[0-9]{1}|01)")) {
                            each.getUserRecords().addCallOutOfCityRecords(callRecord);
                        } else {
                            each.getUserRecords().addCallOutOfProvinceRecords(callRecord);
                        }
                        isT = true;
                    }
                    if (each.getNumber().equals(answerNumber)) {
                        CallRecord callRecord = new CallRecord();
                        String startDateString = strings[4] + " " + strings[5];
                        String endDateString = strings[6] + " " + strings[7];
                        Date startDate;
                        Date endDate;
                        try {
                            startDate = sdf.parse(startDateString);
                        } catch (ParseException e) {
                            continue;
                        }
                        try {
                            endDate = sdf.parse(endDateString);
                        } catch (ParseException e) {
                            continue;
                        }
                        callRecord.setCallingNumber(strings[0].substring(2));
                        callRecord.setAnswerNumber(answerNumber);
                        callRecord.setStartTime(startDate);
                        callRecord.setEndTime(endDate);
                        callRecord.setCallingAddressAreaCode(strings[1]);
                        callRecord.setAnswerAddressAreaCode(strings[3]);
                        if (!callRecord.getAnswerAddressAreaCode().matches("0791") && !callRecord.getAnswerAddressAreaCode().matches("07(9[0-9]{1}|01)")) {
                            each.getUserRecords().addAnswerOutOfProvinceRecords(callRecord);
                        }
                        isT = true;
                    }
                }
            } else if (string.matches(exitPattern)) {
                break;
            }
        }
        Collections.sort(users, new Comparator<User>() {
            public int compare(User user1, User user2) {
                return user1.getNumber().compareTo(user2.getNumber());
            }
        });
        for (User each:users) {
            System.out.println(each.getNumber() + " " + String.format("%.1f", each.calCost()) + " " + String.format("%.1f", each.calBalance()));
        }

    }

}

如源码12-17行所示，本次迭代后的Main的输入模式在原有的座机开通、座机主叫的基础上新增了手机开通、手机主叫，同时座机主叫和手机主叫又被细分为了座机呼叫座机（tPattern00）、座机呼叫手机（tPattern01）、手机呼叫座机（tPattern10）和手机呼叫手机（tPattern11）；

在不同的模式下，程序会采用不同的方式处理输入数据（座机呼叫座机（44-80行）、座机呼叫手机（81-143行）、手机呼叫座机（144-185行）和手机呼叫手机（185-251行）），使之能正确地构造出User类，同时构造CallRecord的方式也会略有改变。

附：User的新的有参构造函数：

public User(String string) {
    if (string.matches(Main.uPattern0)) {
        String[] strings = string.split("\\s");
        number = strings[0].substring(2);
        chargeMode = new LandLinePhoneCharging();
    } else if (string.matches(Main.uPattern1)) {
        number = string.substring(2, 13);
        if (string.charAt(14) == '1') {
            chargeMode = new MobilePhoneCharging();
        }
    }
}

2.计费方式

 

 

本次迭代新增了上图中与“MobilePhone”相关的类，同时重命名了LandPhoneInCityRule等原有类；

MobilePhoneCallOutOfCityRule等类的格式与内容与先前的LandPhoneInCityRule等类区别不大，故不多做展示；

calCost（）函数新增了计算省外被叫资费的功能（其实就是多加了两行代码）；

题目集11

本题中的电信计费系统省略了原有的内容，仅保留了新增的短信功能其实现方式与原来并无不同，故此处仅展示改动后的Main与短信计费模式示例SendMessageRule的源码

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;

public class Main {

    public static Scanner input = new Scanner(System.in);
    public static String uPattern = "[u]-1[0-9]{10}\\s[3]";
    public static String tPattern = "[m]-1[0-9]{10}\\s" + "1[0-9]{10}\\s" + "(\\d|\\s|[a-z]|[A-Z]|,|.){1,}";
    
    public static String exitPattern = "end";
    
    public static void main(String[] args) {
        
        ArrayList<User> users = new ArrayList<User>();
        boolean isT = false;
        
        while(true) {
            String string = input.nextLine();
            if (string.matches(uPattern) && !isT) {
                User user = new User(string);
                if (!users.contains(user)) {
                    users.add(user);
                }
            } else if (string.matches(tPattern)) {
                String userNumber = string.substring(2, 13);
                String answerNumber = string.substring(14, 25);
                for (User each:users) {
                    if (each.getNumber().equals(userNumber)) {
                        MessageRecord messageRecord = new MessageRecord();
                        messageRecord.setCallingNumber(userNumber);
                        messageRecord.setAnswerNumber(answerNumber);
                        messageRecord.setMessage(string.substring(26));
                        each.getUserRecords().addSendMessageRecords(messageRecord);
                        isT = true;
                    }
                }
            } else if (string.matches(exitPattern)) {
                break;
            }
        }
        Collections.sort(users, new Comparator<User>() {
            public int compare(User user1, User user2) {
                return user1.getNumber().compareTo(user2.getNumber());
            }
        });
        for (User each:users) {
            System.out.println(each.getNumber() + " " + String.format("%.1f", each.calCost()) + " " + String.format("%.1f", each.calBalance()));
        }

    }

}

import java.util.ArrayList;

public class SendMessageRule extends MessageChargeRule{

    public SendMessageRule() {
        // TODO Auto-generated constructor stub
    }
    
    @Override
    public double calCost(ArrayList<MessageRecord> messageRecords) {
        double cost = 0;
        int num = 0;
        for (MessageRecord each:messageRecords) {
            int length = each.getMessage().length();
            num += length / 10;
            if (length / 10.0 != 0) {
                num += 1;
            }
        }
        if (num <= 3) {
            cost = num * 0.1;
        } else if (num <= 5) {
            cost = num * 0.2 - 0.3;
        } else {
            cost = num * 0.3 - 0.8;
        }
        return cost;
    }

}

注：我设计的短信计费方式为先计算所有短信经过换算后的实际条数，然后再按照总信息条数所在区间计算资费。

采坑心得

由于我的设计风格为先在脑中构建出整个程序的架构，并且设计较为严谨，故我的程序大多为一遍过，所能分享的坑点不多；

1.正则表达式对于程序运行结果的影响可以说是决定性的，绝对不能出错；

2.程序设计需要贴合实际，如电信计费系统在开通号码时需要检测号码是否已存在，这类附加功能往往会在PTA评分时占有多个测点；

3.题目集9和题目集10中的电信通讯系统有1个大坑：固话区号可能为3或4位，算上号码也就是11或12位。为了方便从输入流中提取各项数据，我们需要对输入数据进行分割，但由于String.substract（）需要通过下标号精准切割，而固话号码位数不定，所以我使用split（" "）的方式直接切割字符串，这样便不用考虑固话号码的位数问题。

 

改进建议

测试样例太少，建议增加一些困难测点的测试样例

总结

1.作为一个合格的程序员需要熟练掌握正则表达式。正则的使用率在程序设计工作中非常高，熟练掌握后可以大大减轻一些格式判定方面的工作量；

2.在进行代码的编写之前做好预设计工作。预设计工作是程序编写过程中非常重要的一环，就像建房子前先画图纸一样，在打开IDE前预先构想好各种类之间的关联关系，可以帮助减少可能出现的逻辑问题，同时在编写时事半功倍。