第三次部落格

阿新 • • 發佈：2022-12-09

第三次部落格電信計費

第三次部落格電信計費

一、前言

這幾次大作業的目的是實現電信計費，使用多型的方式，使用者可以是座機、手機，座機和手機可以進行通話，並且手機可以傳送簡訊，在不同的地區使用不同的方式撥打電話的計費方式不同，手機發送簡訊根據資訊的長短有不同的計費方式。總體來說，這幾次大作業的難度較大，但是老師給出了類圖，我們只需要根據類圖完成相應的方法即可。每一次大作業都是有關聯的，下一次大作業是在上一次的大作業的基礎上進行略微的修改，並增加相應的功能，因此題量相對於之前的多邊形的計算更少一些。

二、設計與分析

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元。
每條通訊資訊單獨計費後累加，不是將所有時間累計後統一計費。
格式：號碼+英文空格符+總的話費+英文空格符+餘額
每個使用者一行，使用者之間按號碼字元從小到大排序。

錯誤處理：
輸入資料中出現的不符合格式要求的行一律忽略。

題目給出的類圖如下：

圖中User是使用者類，包括屬性：
userRecords （使用者記錄）、balance（餘額）、chargeMode（計費方式）、number（號碼）。

ChargeMode是計費方式的抽象類：
chargeRules是計費方式所包含的各種計費規則的集合，ChargeRule類的定義見圖3。
getMonthlyRent（）方法用於返回月租（monthlyRent）。

UserRecords是使用者記錄類，儲存使用者各種通話、簡訊的記錄，    
各種計費規則將使用其中的部分或者全部記錄。
其屬性從上到下依次是：
市內撥打電話、省內（不含市內）撥打電話、省外撥打電話、
市內接聽電話、省內（不含市內）接聽電話、省外接聽電話的記錄
以及傳送簡訊、接收簡訊的記錄。

圖中CommunicationRecord是抽象的通訊記錄類：
包含callingNumber撥打號碼、answerNumber接聽號碼兩個屬性。
CallRecord（通話記錄）、MessageRecord（簡訊記錄）是它的子類。

CallRecord（通話記錄類）包含屬性：
通話的起始、結束時間以及
撥號地點的區號（callingAddressAreaCode）、接聽地點的區號（answerAddressAreaCode）。
區號用於記錄在哪個地點撥打和接聽的電話。座機無法移動，就是本機區號，如果是手機號，則會有差異。

上圖是計費規則的相關類，這些類的核心方法是：
calCost（ArrayList callRecords）。
該方法針根據輸入引數callRecords中的所有記錄計算某使用者的某一項費用；如市話費。
輸入引數callRecords的約束條件：必須是某一個使用者的符合計費規則要求的所有記錄。
SendMessageRule是傳送簡訊的計費規則類，用於計算髮送簡訊的費用。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三個類分別是座機撥打市內、省內、省外電話的計費規則類，用於實現這三種情況的費用計算。

程式碼如下（點選展開）



import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

public class Main {
    public static void main(String[] args) throws ParseException {
        ArrayList<user> users=new ArrayList<>();
        Solve solve=new Solve();
        Scanner input=new Scanner(System.in);
        String s=input.nextLine();
        while(!s.equals("end")){
            if(s.length()!=0){
                int cout= Solve.problem(s);
                if(cout==1){
                    user us=null;
                    String[] s0=s.substring(2).split(" ");
                    for(user i:users){
                        if(i.getNumber().equals(s0[0])){
                            us=i;
                        }
                    }
                    if(us==null){
                        user user1=new user();
                        user1.setNumber(s0[0]);
                        if(s0[1].equals("0")){
                            user1.setChargeMode(new LandlinePhoneCharging());
                        }
                        users.add(user1);
                    }
                }
                else if(cout==2){
                    String[] s0=s.substring(2).split(" ");
                    solve.input_callRecond(users,s0);
                }
            }
            s=input.nextLine();
        }
        Collections.sort(users,new MyComparator());
        for(user i:users){
            System.out.println(i.getNumber()+" "+sishewuru_2(i.calCost())+" "+sishewuru_2(i.calBalance()));
        }
    }
    public static double sishewuru_2(double x){
        String str = String.format("%.2f",x);
        Double s = Double.parseDouble(str);
        return s;
    }
}

class MyComparator implements Comparator<user>{

    @Override
    public int compare(user o1, user o2) {
        return o1.getNumber().compareTo(o2.getNumber());
    }
}
class Solve{
    public static int problem(String s){
        char s0=s.charAt(0);
        String s1=s.substring(1);
        if(s0=='u'){
            if(format_u(s1)){
                return 1;
            }
        }
        else if(s0=='t'){
            if(format_t(s1)){
                return 2;
            }
        }
        return 0;
    }

    public void input_callRecond(ArrayList<user> users, String[] s) throws ParseException {
        if(s[0].equals(s[1])){
            return;
        }
        CallRecord c=new CallRecord();
        SimpleDateFormat formatter=new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
        user call=null;
        int callf,answerf;
        c.setCallingNumber(s[0]);
        c.setAnswerNumber(s[1]);
        Date startTime=formatter.parse(s[2]+" "+s[3]);
        Date endTime=formatter.parse(s[4]+" "+s[5]);
        c.setCallingAddressAreaCode(s[0].substring(0,4));
        c.setAnswerAddressAreaCode(s[1].substring(0,4));
        c.setStartTime(startTime);
        c.setEndTime(endTime);
        for(user i:users){
            if(i.getNumber().equals(c.getCallingNumber())){
                call=i;
            }
        }
        callf=City_Province_Land(c.getCallingAddressAreaCode());
        answerf=City_Province_Land(c.getAnswerAddressAreaCode());
        if(call!=null){
            if(callf==answerf){
                call.getUserRecords().addCallingInCityRecords(c);
            }
            else if(callf==0&&answerf==1||callf==1&&answerf==0){
                call.getUserRecords().addCallingInProvinceRecords(c);
            }
            else{
                call.getUserRecords().addCallingInLandRecords(c);
            }
        }
    }

    public static long lengthofTime(Date startTime,Date endTime){
        long minute,second;
        second = (endTime.getTime()-startTime.getTime())/1000;
        if(second%60==0){
            return second/60;
        }
        else return second/60+1;
    }

    public static int City_Province_Land(String Area){
        if(Area.matches("^0791")){
            return 0;
        }
        else if(Area.matches("^079[0-9]|0701")){
            return 1;
        }
        else return 2;
    }

    public static boolean zuoji(String s){
        return s.matches("^0[0-9]{9,11}");
    }

    public static boolean riqi(String s){
        String[] s0=s.split("\\.");
        if(s0.length==3){
            if(s0[0].matches("^[0-9]{4}")&&s0[1].matches("^([1-9])|(1[0-2])")){
                if(s0[1].matches("^([13578]|1[02])")){
                    return s0[2].matches("^[1-2][0-9]|[1-9]|3[01]");
                }
                else if(s0[1].matches("^[469]|11")){
                    return s0[2].matches("^[1-2][0-9]|[1-9]|30");
                }
                else if(s0[1].matches("^2")){
                    int nian=Integer.parseInt(s0[0]);
                    if(nian%4==0){
                        return s0[2].matches("^[1-2][0-9]|[0-9]");
                    }
                    else{
                        return s0[2].matches("^1[0-9]|[0-9]|2[0-8]");
                    }
                }
            }
        }
        return false;
    }

    public static boolean shijian(String s){
        String[] s0=s.split(":");
        if(s0.length==3){
            if(s0[0].matches("^[0-1][0-9]|2[0-3]")){
                if(s0[1].matches("^[0-5][0-9]")){
                    return s0[2].matches("^[0-5][0-9]");
                }
            }
        }
        return false;
    }

    public static boolean format_u(String s){
        String[] s0=s.split(" ");
        if(s0.length==2){
            String s1=s0[0].substring(1);
            return s0[0].charAt(0) == '-' && zuoji(s1) && s0[1].matches("^0") && s1.matches("^0791[0-9]{7,8}");
        }
        return false;
    }

    public static boolean format_t(String s){
        String[] s0=s.split(" ");
        if(s0.length==6){
            String s1=s0[0].substring(1);
            if(s0[0].charAt(0)=='-'&&zuoji(s1)&&zuoji(s0[1])&&riqi(s0[2])&&shijian(s0[3])&&riqi(s0[4])&&shijian(s0[5])){
                return true;
            }
        }
        return false;
    }
}


abstract class CallChargeRule extends ChargeRule{

}

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

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

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

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

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

    public Date getEndTime() {
        return endTime;
    }

    public Date getStartTime() {
        return startTime;
    }

    public String getAnswerAddressAreaCode() {
        return answerAddressAreaCode;
    }

    public String getCallingAddressAreaCode() {
        return callingAddressAreaCode;
    }
}

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

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

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

    abstract double calCost(UserRecords userRecords);
    abstract double getMonthlyRent();
}

abstract class ChargeRule {
    abstract public double calCost(UserRecords userRecords);
}

abstract class CommunicationRecord {

    private String callingNumber;
    private String answerNumber;

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

    public String getAnswerNumber() {
        return answerNumber;
    }

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

    public String getCallingNumber() {
        return callingNumber;
    }
}

class LandlinePhoneCharging extends ChargeMode{
    private double monthlyRent=20;

    public LandlinePhoneCharging(){
        super();
        getChargeRules().add(new LandPhoneInCityRule());
        getChargeRules().add(new LandPhoneInProvinceRule());
        getChargeRules().add(new LandPhoneInlandRule());
    }

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

    @Override
    public double calCost(UserRecords userRecords) {
        double ans=0;
        for(ChargeRule i:getChargeRules()){
            ans+=i.calCost(userRecords);
        }
        return ans;
    }
}

class LandPhoneInCityRule extends CallChargeRule {

    @Override
    public double calCost(UserRecords userRecords) {
        double res=0;
        for(CallRecord i:userRecords.getCallingInCityRecords()){
            long minute=Solve.lengthofTime(i.getStartTime(),i.getEndTime());
            if(minute>0)
                res+=(minute*0.1);
        }
        return res;
    }
}

class LandPhoneInlandRule extends CallChargeRule{

    @Override
    public double calCost(UserRecords userRecords) {
        double res=0;
        for(CallRecord i:userRecords.getCallingInLandRecords()){
            long minute=Solve.lengthofTime(i.getStartTime(),i.getEndTime());
            if(minute>0)
                res+=(minute*0.6);
        }
        return res;
    }
}

class LandPhoneInProvinceRule extends CallChargeRule{

    @Override
    public double calCost(UserRecords userRecords) {
        double res=0;
        for(CallRecord i:userRecords.getCallingInProvinceRecords()){
            long minute=Solve.lengthofTime(i.getStartTime(),i.getEndTime());
            if(minute>0)
                res+=(minute*0.3);
        }
        return res;
    }
}

class MessageRecond 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();
    private double balance=100;
    private ChargeMode chargeMode;
    private String number;

    public double calBalance(){
        return balance-calCost()-chargeMode.getMonthlyRent();
    }

    public double calCost(){
        return chargeMode.calCost(userRecords);
    }

    public double getBalance() {
        return balance;
    }

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

    public ChargeMode getChargeMode() {
        return chargeMode;
    }

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

    public String getNumber() {
        return number;
    }

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

    public UserRecords getUserRecords() {
        return userRecords;
    }
}

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<MessageRecond>sendMessageRecords=new ArrayList<MessageRecond>();
    private ArrayList<MessageRecond>receiveMessageRecords=new ArrayList<MessageRecond>();

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

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

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

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

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

    public ArrayList<CallRecord> getAnswerInCityRecords() {
        return answerInCityRecords;
    }

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

    public ArrayList<CallRecord> getAnswerInProvinceRecords() {
        return answerInProvinceRecords;
    }

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

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

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

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

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

思路總結

解決問題先考慮解決問題的架構，這次大作業我們只需要根據題目給出的類圖依次實現。首先對輸入的資料進行判斷，建立使用者返回1，使用者打電話返回2，對資料的處理返回大於2即可說明資料輸入錯誤，丟棄資料不對其進行處理，當返回1時，需要比較該使用者是否已經註冊，如果沒有註冊就加入列表中，否則不處理，當返回2時，需要講該資料根據號碼加入到電話列表；當輸入end結束，根據號碼進行排序輸出本月的話費以及餘額。資料錯誤的情況是座機號碼不對，因為我國的地區號可能為3位或4位，因此座機號碼的長度為10到12，而不是11到12，（這個點如果不清楚會卡住）；在加入電話列表時，需要判斷打電話和接電話所在區域，可分為市內、省內、國內，根據區域號進行判斷加入到不同的列表中，計算話費時，根據列表中的資訊進行計算。

類圖如下：

程式碼複雜度分析：

改進建議

此題的結構是根據該類問題最終的結構所設計的，因此有些類沒有使用到！

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

程式碼如下（點選展開）


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

public class Main {
    public static void main(String[] args) throws ParseException {
        ArrayList<user> users=new ArrayList<>();
        Solve solve=new Solve();
        Scanner input=new Scanner(System.in);
        String s=input.nextLine();
        while(!s.equals("end")){
            if(s.length()!=0){
                int cout= Solve.problem(s);
                if(cout==1||cout==2){
                    user us=null;
                    String[] s0=s.substring(2).split(" ");
                    for(user i:users){
                        if(i.getNumber().equals(s0[0])){
                            us=i;
                        }
                    }
                    if(us==null){
                        user user1=new user();
                        user1.setNumber(s0[0]);
                        if(s0[1].equals("0")){
                            user1.setChargeMode(new LandlinePhoneCharging());
                        }
                        else if(s0[1].equals("1")){
                            user1.setChargeMode(new MobellinePhoneCharging());
                        }
                        users.add(user1);
                    }
                }
                else if(cout>2){
                    String[] s0=s.substring(2).split(" ");
                    solve.input_callRecond(users,s0,cout);
                }
            }
            s=input.nextLine();
        }
        users.sort(new MyComparator());
        for(user i:users){
            System.out.println(i.getNumber()+" "+sishewuru_2(i.calCost())+" "+sishewuru_2(i.calBalance()));
        }
    }
    public static double sishewuru_2(double x){
        String str = String.format("%.2f",x);
        return Double.parseDouble(str);
    }
}

class MyComparator implements Comparator<user>{

    @Override
    public int compare(user o1, user o2) {
        return o1.getNumber().compareTo(o2.getNumber());
    }
}
class Solve{
    public static int problem(String s){
        char s0=s.charAt(0);
        String s1=s.substring(1);
        if(s0=='u'){
            return format_u(s1);
        }
        else if(s0=='t'){
            return format_t(s1);
        }
        return 0;
    }

    public void input_callRecond(ArrayList<user> users, String[] s,int choice) throws ParseException {
        if(s[0].equals(s[1])){
            return;
        }
        CallRecord c=new CallRecord();
        SimpleDateFormat formatter=new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
        user call=null,answer=null;
        int callf,answerf;
        if(choice==3){
            c.setCallingNumber(s[0]);
            c.setAnswerNumber(s[1]);
            Date startTime=formatter.parse(s[2]+" "+s[3]);
            Date endTime=formatter.parse(s[4]+" "+s[5]);
            c.setCallingAddressAreaCode(s[0].substring(0,4));
            c.setAnswerAddressAreaCode(s[1].substring(0,4));
            c.setStartTime(startTime);
            c.setEndTime(endTime);
        }
        else if(choice==4){
            c.setCallingNumber(s[0]);
            c.setAnswerNumber(s[1]);
            Date startTime=formatter.parse(s[3]+" "+s[4]);
            Date endTime=formatter.parse(s[5]+" "+s[6]);
            c.setCallingAddressAreaCode(s[0].substring(0,4));
            c.setAnswerAddressAreaCode(s[2]);
            c.setStartTime(startTime);
            c.setEndTime(endTime);
        }
        else if(choice==5){
            c.setCallingNumber(s[0]);
            c.setAnswerNumber(s[2]);
            Date startTime=formatter.parse(s[3]+" "+s[4]);
            Date endTime=formatter.parse(s[5]+" "+s[6]);
            c.setCallingAddressAreaCode(s[1]);
            c.setAnswerAddressAreaCode(s[2].substring(0,4));
            c.setStartTime(startTime);
            c.setEndTime(endTime);
        }
        else if(choice==6){
            c.setCallingNumber(s[0]);
            c.setAnswerNumber(s[2]);
            Date startTime=formatter.parse(s[4]+" "+s[5]);
            Date endTime=formatter.parse(s[6]+" "+s[7]);
            c.setCallingAddressAreaCode(s[1]);
            c.setAnswerAddressAreaCode(s[3]);
            c.setStartTime(startTime);
            c.setEndTime(endTime);
        }
        for(user i:users){
            if(i.getNumber().equals(c.getCallingNumber())){
                call=i;
            }
            if(i.getNumber().equals(c.getAnswerNumber())){
                answer=i;
            }
        }
        callf=City_Province_Land(c.getCallingAddressAreaCode());
        answerf=City_Province_Land(c.getAnswerAddressAreaCode());
        if(call!=null){
            if(callf==0){
                call.getUserRecords().addCallingInCityRecords(c);
            }
            else if(callf==1){
                call.getUserRecords().addCallingInProvinceRecords(c);
            }
            else{
                call.getUserRecords().addCallingInLandRecords(c);
            }
        }
        if(answer!=null){
            if(answerf==0){
                answer.getUserRecords().addAnswerInCityRecords(c);
            }
            else if(answerf==1){
                answer.getUserRecords().addAnswerInProvinceRecords(c);
            }
            else{
                answer.getUserRecords().addAnswerInLandRecords(c);
            }
        }
    }

    public static long lengthofTime(Date startTime,Date endTime){
        long minute,second;
        second = (endTime.getTime()-startTime.getTime())/1000;
        if(second%60==0){
            return second/60;
        }
        else return second/60+1;
    }

    public static int City_Province_Land(String Area){
        if(Area.matches("^0791")){
            return 0;
        }
        else if(Area.matches("^079[0-9]|0701")){
            return 1;
        }
        else return 2;
    }

    public static boolean zuoji(String s){
        return s.matches("^0[0-9]{9,11}");
    }

    public static boolean areaCode(String s){
        return s.matches("0[0-9]{2,3}");
    }

    public static boolean mobelPhone(String s){
        return s.matches("^1[0-9]{10}");
    }

    public static boolean riqi(String s){
        String[] s0=s.split("\\.");
        if(s0.length==3){
            if(s0[0].matches("^[0-9]{4}")&&s0[1].matches("^([1-9])|(1[0-2])")){
                if(s0[1].matches("^([13578]|1[02])")){
                    return s0[2].matches("^[1-2][0-9]|[1-9]|3[01]");
                }
                else if(s0[1].matches("^[469]|11")){
                    return s0[2].matches("^[1-2][0-9]|[1-9]|30");
                }
                else if(s0[1].matches("^2")){
                    int nian=Integer.parseInt(s0[0]);
                    if(nian%4==0){
                        return s0[2].matches("^[1-2][0-9]|[0-9]");
                    }
                    else{
                        return s0[2].matches("^1[0-9]|[0-9]|2[0-8]");
                    }
                }
            }
        }
        return false;
    }

    public static boolean shijian(String s){
        String[] s0=s.split(":");
        if(s0.length==3){
            if(s0[0].matches("^[0-1][0-9]|2[0-3]")){
                if(s0[1].matches("^[0-5][0-9]")){
                    return s0[2].matches("^[0-5][0-9]");
                }
            }
        }
        return false;
    }

    public static int format_u(String s){
        String[] s0=s.split(" ");
        if(s0.length==2){
            String s1=s0[0].substring(1);
            if(s0[0].charAt(0) == '-' && zuoji(s1) && s0[1].matches("^0") && s1.matches("^0791[0-9]{7,8}"))
                return 1;
            else if(s0[0].charAt(0) == '-' && mobelPhone(s1) && s0[1].matches("^1"))
                return 2;
        }
        return 0;
    }

    public static int format_t(String s){
        String[] s0=s.split(" ");
        if(s0.length==6){
            String s1=s0[0].substring(1);
            if(s0[0].charAt(0) == '-' && zuoji(s1) && zuoji(s0[1]) && riqi(s0[2]) && shijian(s0[3]) && riqi(s0[4]) && shijian(s0[5]))
                return 3;
        }
        else if(s0.length==7){
            String s1=s0[0].substring(1);
            if(s0[0].charAt(0)=='-'&&zuoji(s1)&&mobelPhone(s0[1])&&areaCode(s0[2])&&riqi(s0[3])&&shijian(s0[4])&&riqi(s0[5])&&shijian(s0[6]))
                return 4;
            else if(s0[0].charAt(0)=='-'&&zuoji(s0[2])&&mobelPhone(s1)&&areaCode(s0[1])&&riqi(s0[3])&&shijian(s0[4])&&riqi(s0[5])&&shijian(s0[6]))
                return 5;
        }
        else if(s0.length==8){
            String s1=s0[0].substring(1);
            if(s0[0].charAt(0)=='-'&&mobelPhone(s1)&&areaCode(s0[1])&&mobelPhone(s0[2])&&areaCode(s0[3])&&riqi(s0[4])&&shijian(s0[5])&&riqi(s0[6])&&shijian(s0[7]))
                return 6;
        }
        return 0;
    }
}


abstract class CallChargeRule extends ChargeRule {

}

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

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

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

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

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

    public Date getEndTime() {
        return endTime;
    }

    public Date getStartTime() {
        return startTime;
    }

    public String getAnswerAddressAreaCode() {
        return answerAddressAreaCode;
    }

    public String getCallingAddressAreaCode() {
        return callingAddressAreaCode;
    }
}

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

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

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

    abstract double calCost(UserRecords userRecords);
    abstract double getMonthlyRent();
}

abstract class ChargeRule {
    abstract public double calCost(UserRecords userRecords);
}

abstract class CommunicationRecord {

    private String callingNumber;
    private String answerNumber;

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

    public String getAnswerNumber() {
        return answerNumber;
    }

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

    public String getCallingNumber() {
        return callingNumber;
    }
}

class LandlinePhoneCharging extends ChargeMode {
    private double monthlyRent=20;

    public LandlinePhoneCharging(){
        super();
        getChargeRules().add(new LandPhoneInCityRule());
        getChargeRules().add(new LandPhoneInProvinceRule());
        getChargeRules().add(new LandPhoneInlandRule());
    }

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

    @Override
    public double calCost(UserRecords userRecords) {
        double ans=0;
        for(ChargeRule i:getChargeRules()){
            ans+=i.calCost(userRecords);
        }
        return ans;
    }
}

class LandPhoneInCityRule extends CallChargeRule {

    @Override
    public double calCost(UserRecords userRecords) {
        double res=0;
        for(CallRecord i:userRecords.getCallingInCityRecords()){
            long minute= Solve.lengthofTime(i.getStartTime(),i.getEndTime());
            int answerf;
            answerf=Solve.City_Province_Land(i.getAnswerAddressAreaCode());
            if(answerf==0)
                res+=(minute*0.1);
            else if(answerf==1)
                res+=(minute*0.3);
            else if(answerf==2)
                res+=(minute*0.6);
        }
        return res;
    }
}

class LandPhoneInlandRule extends CallChargeRule {

    @Override
    public double calCost(UserRecords userRecords) {
        double res=0;
        for(CallRecord i:userRecords.getCallingInLandRecords()){
            long minute= Solve.lengthofTime(i.getStartTime(),i.getEndTime());
            if(minute>0)
                res+=(minute*0.6);
        }
        return res;
    }
}

class LandPhoneInProvinceRule extends CallChargeRule {

    @Override
    public double calCost(UserRecords userRecords) {
        double res=0;
        for(CallRecord i:userRecords.getCallingInProvinceRecords()){
            long minute= Solve.lengthofTime(i.getStartTime(),i.getEndTime());
            if(minute>0)
                res+=(minute*0.3);
        }
        return res;
    }
}

class MobellinePhoneCharging extends ChargeMode {
    private double monthlyRent=15;

    public MobellinePhoneCharging(){
        super();
        getChargeRules().add(new MobelPhoneInCityRule());
        getChargeRules().add(new MobelPhoneInProvinceRule());
        getChargeRules().add(new MobelPhoneInlandRule());
    }

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

    @Override
    public double calCost(UserRecords userRecords) {
        double ans=0;
        for(ChargeRule i:getChargeRules()){
            ans+=i.calCost(userRecords);
        }
        return ans;
    }
}

class MobelPhoneInCityRule extends CallChargeRule {

    @Override
    public double calCost(UserRecords userRecords) {
        double res=0;
        for(CallRecord i:userRecords.getCallingInCityRecords()){
            long minute= Solve.lengthofTime(i.getStartTime(),i.getEndTime());
            int callf,answerf;
            callf=Solve.City_Province_Land(i.getCallingAddressAreaCode());
            answerf=Solve.City_Province_Land(i.getAnswerAddressAreaCode());
            if(callf==0&&answerf==0)
                res+=(minute*0.1);
            else if(callf==0&&answerf==1){
                res+=(minute*0.2);
            }
            else if(callf==0&&answerf==2){
                res+=(minute*0.3);
            }
        }
        return res;
    }
}

class MobelPhoneInlandRule extends CallChargeRule {

    @Override
    public double calCost(UserRecords userRecords) {
        double res=0;
        for(CallRecord i:userRecords.getCallingInLandRecords()){
            long minute= Solve.lengthofTime(i.getStartTime(),i.getEndTime());
            if(minute>0)
                res+=(minute*0.6);
        }
        for(CallRecord i:userRecords.getAnswerInLandRecords()){
            long minute= Solve.lengthofTime(i.getStartTime(),i.getEndTime());
            if(minute>0)
                res+=(minute*0.3);
        }
        return res;
    }
}

class MobelPhoneInProvinceRule extends CallChargeRule {

    @Override
    public double calCost(UserRecords userRecords) {
        double res=0;
        for(CallRecord i:userRecords.getCallingInProvinceRecords()){
            long minute= Solve.lengthofTime(i.getStartTime(),i.getEndTime());
            if(minute>0)
                res+=(minute*0.3);
        }
        return res;
    }
}

class MessageRecond 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();
    private double balance=100;
    private ChargeMode chargeMode;
    private String number;

    public double calBalance(){
        return balance-calCost()-chargeMode.getMonthlyRent();
    }

    public double calCost(){
        return chargeMode.calCost(userRecords);
    }

    public double getBalance() {
        return balance;
    }

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

    public ChargeMode getChargeMode() {
        return chargeMode;
    }

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

    public String getNumber() {
        return number;
    }

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

    public UserRecords getUserRecords() {
        return userRecords;
    }
}

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<MessageRecond>sendMessageRecords=new ArrayList<MessageRecond>();
    private ArrayList<MessageRecond>receiveMessageRecords=new ArrayList<MessageRecond>();

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

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

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

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

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

    public ArrayList<CallRecord> getAnswerInCityRecords() {
        return answerInCityRecords;
    }

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

    public ArrayList<CallRecord> getAnswerInProvinceRecords() {
        return answerInProvinceRecords;
    }

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

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

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

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

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

思路分析

此次大作業是在上一次大作業的基礎上進行修改完成的。題目增加了手機使用者，因此需要考慮手機號碼的判斷是否合理，判斷通話記錄是手機跟手機還是手機跟座機，需要比較輸入資訊的根據空格分割下來的長度大小，因為如果是手機號碼，需要附帶區號，而座機號碼不需要，因此輸入的資料分割長度為6即兩個座機號碼通訊，當長度為7說明有一個座機使用者和一個手機使用者，還需要詳細判斷撥打號碼是手機還是接聽號碼是手機，當長度為8時，說明兩個號碼為手機號碼，後面一個字元對應其區號，再根據區號選擇該通話記錄加入哪個列表中。

類圖如下：

程式碼複雜度分析：

改進建議

此次程式碼是在上一次作業的基礎上修改得到的，程式碼的複雜度還是比較高，但是對程式碼的增加比較方便，需要增加某一些功能不需要進行大幅度的修改，老師所設計的類圖很好。主函式還應該更簡單一些，將解決問題的步驟寫入類中。

3.第八次大作業

電信計費系列3-簡訊計費

實現一個簡單的電信計費程式，針對手機的簡訊採用如下計費方式：
1、接收簡訊免費，傳送簡訊0.1元/條，超過3條0.2元/條，超過5條0.3元/條。
2、如果一次傳送簡訊的字元數量超過10個，按每10個字元一條簡訊進行計算。
注意：簡訊內容只能由數字、字母、空格、英文逗號、英文句號組成，每條簡訊資訊均單獨計費後累加，不是將所有資訊累計後統一計費。

點選展開


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

public class Main {
    public static void main(String[] args) throws ParseException {
        ArrayList<user> users=new ArrayList<>();
        Solve solve=new Solve();
        Scanner input=new Scanner(System.in);
        String s=input.nextLine();
        while(!s.equals("end")){
            if(s.length()!=0){
                int cout= Solve.problem(s);
                if(cout==1||cout==2){
                    user us=null;
                    String[] s0=s.substring(2).split(" ");
                    for(user i:users){
                        if(i.getNumber().equals(s0[0])){
                            us=i;
                        }
                    }
                    if(us==null){
                        user user1=new user();
                        user1.setNumber(s0[0]);
                        if(s0[1].equals("3")){
                            user1.setChargeMode(new SendMessageCharging());
                        }
                        users.add(user1);
                    }
                }
                else if(cout == 7){
                    solve.input_message(users,s);
                }
            }
            s=input.nextLine();
        }
        users.sort(new MyComparator());
        for(user i:users){
            System.out.println(i.getNumber()+" "+sishewuru_2(i.calCost())+" "+sishewuru_2(i.calBalance()));
        }
    }
    public static double sishewuru_2(double x){
        String str = String.format("%.2f",x);
        return Double.parseDouble(str);
    }
}

class MyComparator implements Comparator<user>{

    @Override
    public int compare(user o1, user o2) {
        return o1.getNumber().compareTo(o2.getNumber());
    }
}

class Solve{
    public static int problem(String s){
        char s0=s.charAt(0);
        String s1=s.substring(1);
        if(s0=='u'){
            return format_u(s1);
        }
        else if(s0 == 'm'){
            return format_m(s1);
        }
        return 0;
    }

    public void input_message(ArrayList<user> users, String s){
        user send_user=null;
        String sendstr = s.substring(2,13);
        String Messages = s.substring(26);
        for(user u:users){
            if(u.getNumber().equals(sendstr)){
                send_user=u;
            }
        }
        MessageRecond mess = new MessageRecond();
        mess.setMessage(Messages);
        if(send_user!=null){
            send_user.getUserRecords().addSendMessageRecords(mess);
        }
    }

    public static long lengthofTime(Date startTime,Date endTime){
        long minute,second;
        second = (endTime.getTime()-startTime.getTime())/1000;
        if(second%60==0){
            return second/60;
        }
        else return second/60+1;
    }

    public static int City_Province_Land(String Area){
        if(Area.matches("^0791")){
            return 0;
        }
        else if(Area.matches("^079[0-9]|0701")){
            return 1;
        }
        else return 2;
    }

    public static boolean zuoji(String s){
        return s.matches("^0[0-9]{9,11}");
    }

    public static boolean areaCode(String s){
        return s.matches("0[0-9]{2,3}");
    }

    public static boolean mobelPhone(String s){
        return s.matches("^1[0-9]{10}");
    }

    public static boolean message(String s){
        return s.matches("[0-9a-zA-Z\\s\\.,]+");
    }

    public static boolean riqi(String s){
        String[] s0=s.split("\\.");
        if(s0.length==3){
            if(s0[0].matches("^[0-9]{4}")&&s0[1].matches("^([1-9])|(1[0-2])")){
                if(s0[1].matches("^([13578]|1[02])")){
                    return s0[2].matches("^[1-2][0-9]|[1-9]|3[01]");
                }
                else if(s0[1].matches("^[469]|11")){
                    return s0[2].matches("^[1-2][0-9]|[1-9]|30");
                }
                else if(s0[1].matches("^2")){
                    int nian=Integer.parseInt(s0[0]);
                    if(nian%4==0){
                        return s0[2].matches("^[1-2][0-9]|[0-9]");
                    }
                    else{
                        return s0[2].matches("^1[0-9]|[0-9]|2[0-8]");
                    }
                }
            }
        }
        return false;
    }

    public static boolean shijian(String s){
        String[] s0=s.split(":");
        if(s0.length==3){
            if(s0[0].matches("^[0-1][0-9]|2[0-3]")){
                if(s0[1].matches("^[0-5][0-9]")){
                    return s0[2].matches("^[0-5][0-9]");
                }
            }
        }
        return false;
    }

    public static int format_u(String s){
        String[] s0=s.split(" ");
        if(s0.length==2){
            String s1=s0[0].substring(1);
            if(s0[0].charAt(0) == '-' && zuoji(s1) && s0[1].matches("^0") && s1.matches("^0791[0-9]{7,8}"))
                return 1;
            else if(s0[0].charAt(0) == '-' && mobelPhone(s1) && s0[1].matches("^[13]"))
                return 2;
        }
        return 0;
    }

    public static int format_m(String s){
        String send = s.substring(1, 12);
        String recstr = s.substring(13, 24);
        String messages = s.substring(25);
        if(s.charAt(0)=='-'&&mobelPhone(send)&&mobelPhone(recstr)){
            if(message(messages)){
                return 7;
            }
        }
        return 0;
    }
}

abstract class CallChargeRule extends ChargeRule {

}

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

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

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

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

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

    public Date getEndTime() {
        return endTime;
    }

    public Date getStartTime() {
        return startTime;
    }

    public String getAnswerAddressAreaCode() {
        return answerAddressAreaCode;
    }

    public String getCallingAddressAreaCode() {
        return callingAddressAreaCode;
    }
}

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

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

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

    abstract double calCost(UserRecords userRecords);
    abstract double getMonthlyRent();
}

abstract class ChargeRule {
    abstract public double calCost(UserRecords userRecords);
}

abstract class CommunicationRecord {

    private String callingNumber;
    private String answerNumber;

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

    public String getAnswerNumber() {
        return answerNumber;
    }

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

    public String getCallingNumber() {
        return callingNumber;
    }
}

class MessageRecond extends CommunicationRecord {
    private String message;

    public String getMessage() {
        return message;
    }

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

class SendMessageCharging extends ChargeMode{
    private double monthlyRent = 0;

    public SendMessageCharging(){
        super();
        chargeRules.add(new SendMessageRule());
    }

    @Override
    double calCost(UserRecords userRecords) {
        double sum_cost = 0;
        for(ChargeRule i:chargeRules){
            sum_cost += i.calCost(userRecords);
        }
        return sum_cost;
    }

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

class SendMessageRule extends CallChargeRule{

    @Override
    public double calCost(UserRecords userRecords) {
        double sum = 0;
        int num = 0;
        for(MessageRecond m:userRecords.getSendMessageRecords()){
            int len = m.getMessage().length();
            if(len <= 10){
                num ++;
            }
            else{
                num += len/10;
                if(len % 10 != 0){
                    num ++;
                }
            }
        }
        if(num <= 3){
            sum = num*0.1;
        }
        else if(num <= 5){
            sum = 0.3 + (num - 3) * 0.2;
        }
        else {
            sum = 0.7 + (num - 5) * 0.3;
        }
        return sum;
    }
}

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

    public double calBalance(){
        return balance-calCost()-chargeMode.getMonthlyRent();
    }

    public double calCost(){
        return chargeMode.calCost(userRecords);
    }

    public double getBalance() {
        return balance;
    }

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

    public ChargeMode getChargeMode() {
        return chargeMode;
    }

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

    public String getNumber() {
        return number;
    }

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

    public UserRecords getUserRecords() {
        return userRecords;
    }
}

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<MessageRecond>sendMessageRecords=new ArrayList<MessageRecond>();
    private ArrayList<MessageRecond>receiveMessageRecords=new ArrayList<MessageRecond>();

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

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

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

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

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

    public ArrayList<CallRecord> getAnswerInCityRecords() {
        return answerInCityRecords;
    }

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

    public ArrayList<CallRecord> getAnswerInProvinceRecords() {
        return answerInProvinceRecords;
    }

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

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

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

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

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

思路分析

此次大作業是在上一次大作業的基礎上，增加使用者的操作--傳送簡訊。在上一次大作業的基礎上，需要在資料判斷的方法中增加判斷該資料是否為傳送簡訊，並且對於簡訊的內容我們不需要進行處理，只需要在計算話費時，統計簡訊的條數，以及簡訊內容的長度，再計算話費的多少。

類圖如下：

程式碼複雜度分析：

三、總結

這三次大作業，讓我明白了結構的重要性，解決問題要先考慮解決思路，並將問題分塊解決，一個好的結構能夠大大提高程式碼的複用性。這三次大作業循序漸進，大作業是在上一次的基礎上經過略微的修改和增加，即可實現需要增加的功能，而不需要重構。這幾次大作業涉及到了多型，多型的實現是java的特點，同一個介面，有多種不同的實現方式，一個介面有多種不同的狀態，方便了程式碼的書寫，提高了程式碼的複用性。通過這幾次大作業，我明白了我還需要改變解決問題的方式，先構思，將問題分塊處理，依次實現某一部分的功能，對於java的多型、繼承、介面等方法還需要多加練習，提高對這些方法的理解！

第三次部落格

第三次部落格電信計費

一、前言

二、設計與分析

1.第六次大作業

電信計費系列1-座機計費

思路總結

改進建議

2.第七次大作業

電信計費系列2-手機+座機計費

思路分析

改進建議

3.第八次大作業

電信計費系列3-簡訊計費

思路分析

三、總結

第三次部落格總結

oop第三次部落格總結

OO第三次部落格

第三次部落格

pta第三次部落格

黃金點第四次部落格

BUAA面向物件第四次部落格

面向物件第三單元部落格

c#程視覺化序設計（第二章第三次課）

第三次總結

Odoo從入門到精通 | 第三次課

python-面試第三次

2020 SDN第三次上機實驗

軟體定義網路第三次實驗

第三次結對

linux學習第三次打卡

21世紀科技生態面臨第三次全球標準

第三次安卓

第三次實驗

組合語言程式設計第三次實驗多個段的彙編源程式編寫與除錯

第三次部落格

第三次部落格 電信計費

一、前言

二、設計與分析

1.第六次大作業

電信計費系列1-座機計費

思路總結

改進建議

2.第七次大作業

電信計費系列2-手機+座機計費

思路分析

改進建議

3.第八次大作業

電信計費系列3-簡訊計費

思路分析

三、總結

相關推薦

第三次部落格電信計費