Blog-3 电信计费

一、前言：

　　这三次大作业相对于，前面的pta大作业算法上比较简单，但是后面三次大作业逻辑上比较难，但是经过后面三次的大作业的完成，知道了怎么面向对象，虽然要建立很多类，但是这样管理起来更方便，修改起来，或者添加功能也更加的方便，不用去大段的修改代码，也避免了大量的代码重复。同时，对于其他那些看代码的人也可以很好的看懂，也更直观。电信系列的大作业主要涉及了容器的知识，对信息的储存和便利，同时还考了容器内部排序，通过Collections函数进行排序，也通过对不同的用户进行不同的分类，放在不同的容器中。当然，其中也还涉及到子类、父类，分类，类的创建，类的管理，正则表达式等等。

　　难度相对于前几次的大作业来说，这三次的大作业难度还是相对比较低的，因为老师需要捞我们，所以pta的难度出的不大，但是前两次没有拿到满分，主要是正则表达式出问题了，但是一直找不到问题出现在哪里。

　　这三次大作业也涉及到了Data的应用，对于Data的应用对我来说当时是一片空白，但是我通过查找资料，来找到相应的方法。

二、设计与分析：

　　类图：

 

 

 

 代码：

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

public class Main {
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        ArrayList<User> users1 = new ArrayList<User>();
        ArrayList<User> users2 = new ArrayList<User>();
        ChargeMode chargeMode;
        ArrayList<CallRecord> callRecords = new ArrayList<CallRecord>();
        SimpleDateFormat df = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
        
        String[] tokens = null;
        Date time1=null,time2=null;
        while(true)
        {
            String number=in.nextLine();
            if(number.equals("end"))
                break;
            int f=0;
            f=JudgeFormat.judge(number);
            if(f!=0)
                {
                    for(int i=0;i<number.length();i++)
                    {
                        tokens=number.split("[- ]");
                    }
                    
                    if(tokens[0].equals("u")){//开户
                        CallRecord callRecord = new CallRecord();
                        String areaCode;
                        LandlinePhoneCharging m = new LandlinePhoneCharging();//座机
                        MobilePhoneCharging n =new MobilePhoneCharging();//手机
                        chargeMode = m;
                        chargeMode = n;
                        if(f==1)
                        {
                            boolean judge=true;
                            areaCode = tokens[1].substring(0, 4);
                            callRecord.setCallingAddressAreaCode(areaCode);//区号
                            for(User user : users1) 
                            {
                                if(user.getNumber().equals(tokens[1]))//判断是否已开户
                                    judge=false;
                            }
                            if(judge) {//如果没有就开户
                                User u = new User(m,tokens[1]);
                                users1.add(u);//开户
                            }
                        }
                        else if(f==2)
                        {
                            boolean judge=true;
                            for(User user : users2) 
                            {
                                if(user.getNumber().equals(tokens[1]))//判断是否已开户
                                    judge=false;
                            }
                            if(judge) {//如果没有就开户
                                User u = new User(n,tokens[1]);
                                users2.add(u);//开户
                            }
                        }
                    }
                    
                    
                    if(tokens[0].equals("t")) {
                        CallRecord callRecord = new CallRecord();
                        String anwserareaCode,callareaCode;
                        if(f==3)
                        {
                            callareaCode = tokens[1].substring(0, 4);//拨打区号
                            callRecord.setCallingAddressAreaCode(callareaCode);//传入拨打区号
                            callRecord.setCallingNumber(tokens[1]);//传入拨打号码
                            anwserareaCode = tokens[2].substring(0, 4);//接通地址
                            callRecord.setAnswerAddressAreaCode(anwserareaCode);//传入接通区号
                            callRecord.setAnswerNumber(tokens[2]);//传入接通号码
                            try {
                                time1 = df.parse(tokens[3]+" "+tokens[4]);
                            } catch (ParseException e1) {
                                e1.printStackTrace();
                            }
                            
                            try {
                                time2 = df.parse(tokens[5]+" "+tokens[6]);
                            } catch (ParseException e) {
                                e.printStackTrace();
                            }
                            
                            callRecord.setStartTime(time1);//开始时间
                            callRecord.setEndTime(time2);//结束时间
                            callRecords.add(callRecord);//添加用户记录
                        }
                        
                        if(f==4)
                        {
                            callareaCode = tokens[1].substring(0, 4);//拨打区号
                            callRecord.setCallingAddressAreaCode(callareaCode);//传入拨打区号
                            callRecord.setCallingNumber(tokens[1]);//传入拨打号码
                            anwserareaCode = tokens[3];//接通地址
                            callRecord.setAnswerAddressAreaCode(anwserareaCode);//传入接通区号
                            callRecord.setAnswerNumber(tokens[2]);//传入接通号码
                            try {
                                time1 = df.parse(tokens[4]+" "+tokens[5]);
                            } catch (ParseException e1) {
                                e1.printStackTrace();
                            }
                            
                            try {
                                time2 = df.parse(tokens[6]+" "+tokens[7]);
                            } catch (ParseException e) {
                                e.printStackTrace();
                            }
                            
                            callRecord.setStartTime(time1);//开始时间
                            callRecord.setEndTime(time2);//结束时间
                            callRecords.add(callRecord);//添加用户记录
                        }
                        
                        if(f==5)
                        {
                            callareaCode = tokens[2];//拨打区号
                            callRecord.setCallingAddressAreaCode(callareaCode);//传入拨打区号
                            callRecord.setCallingNumber(tokens[1]);//传入拨打号码
                            anwserareaCode = tokens[4];//接通地址
                            callRecord.setAnswerAddressAreaCode(anwserareaCode);//传入接通区号
                            callRecord.setAnswerNumber(tokens[3]);//传入接通号码
                            try {
                                time1 = df.parse(tokens[5]+" "+tokens[6]);
                            } catch (ParseException e1) {
                                e1.printStackTrace();
                            }
                            
                            try {
                                time2 = df.parse(tokens[7]+" "+tokens[8]);
                            } catch (ParseException e) {
                                e.printStackTrace();
                            }
                            
                            callRecord.setStartTime(time1);//开始时间
                            callRecord.setEndTime(time2);//结束时间
                            callRecords.add(callRecord);//添加用户记录
                        }
                        
                        if(f==6)
                        {
                            callareaCode = tokens[2];//拨打区号
                            callRecord.setCallingAddressAreaCode(callareaCode);//传入拨打区号
                            callRecord.setCallingNumber(tokens[1]);//传入拨打号码
                            anwserareaCode = tokens[3].substring(0,4);//接通地址
                            callRecord.setAnswerAddressAreaCode(anwserareaCode);//传入接通区号
                            callRecord.setAnswerNumber(tokens[3]);//传入接通号码
                            try {
                                time1 = df.parse(tokens[4]+" "+tokens[5]);
                            } catch (ParseException e1) {
                                e1.printStackTrace();
                            }
                            
                            try {
                                time2 = df.parse(tokens[6]+" "+tokens[7]);
                            } catch (ParseException e) {
                                e.printStackTrace();
                            }
                            
                            callRecord.setStartTime(time1);//开始时间
                            callRecord.setEndTime(time2);//结束时间
                            callRecords.add(callRecord);//添加用户记录
                        }
                        
                    }
                }
        }
//        for(int i=0;i<callRecords.size();i++) {
//            System.out.println(callRecords.get(i).getAnswerNumber()+" "+callRecords.get(i).getCallingNumber()+" "+callRecords.get(i).getCallingAddressAreaCode()+" "+callRecords.get(i).getAnswerAddressAreaCode());
//        }
//            

Collections.sort(users1,new Comparator<User>() {
    public int compare(User s1,User s2){
        double n1 = Double.parseDouble(s1.getNumber());
        double n2 = Double.parseDouble(s2.getNumber());
            if(n1 > n2) {
                return 1;
            }
            return -1;
    }

});
Collections.sort(users2,new Comparator<User>() {
    public int compare(User s1,User s2){
        double n1 = Double.parseDouble(s1.getNumber());
        double n2 = Double.parseDouble(s2.getNumber());
            if(n1 > n2) {
                return 1;
            }
            return -1;
    }

});

        
        for(int i=0; i<users1.size(); i++) {
            UserRecords userRecords = new UserRecords();//用户记录
            for(int j=0;j<callRecords.size();j++) {
                if(users1.get(i).getNumber().equals(callRecords.get(j).getCallingNumber())) {
                    if(callRecords.get(j).getAnswerAddressAreaCode().matches("0791"))//市内打电话
                        userRecords.addCallingInCityRecords(callRecords.get(j));
                    
                    else if(callRecords.get(j).getAnswerAddressAreaCode().matches("((079\\d)|0701)"))//省内打电话
                        userRecords.addCallingInProvinceRecords(callRecords.get(j));
                    
                    else//国内打电话
                        userRecords.addCallingInLandRecords(callRecords.get(j));
                }
                if(users1.get(i).getNumber().equals(callRecords.get(j).getAnswerNumber())) {
                    if(callRecords.get(j).getCallingAddressAreaCode().matches("0791"))//市内接电话
                        userRecords.addAnswerInCityRecords(callRecords.get(j));
                    else if(callRecords.get(j).getCallingAddressAreaCode().matches("((079\\d)|0701)"))//省内接电话
                        userRecords.addAnswerInProvinceRecords(callRecords.get(j));
                    else //国内接电话
                        userRecords.addAnswerInLandRecords(callRecords.get(j));
                }
            }
//            将用户记录存入对应用户中
            users1.get(i).setUserRecords(userRecords);
        }
        
            for(int i=0; i<users2.size(); i++) {
                UserRecords userRecords =  new UserRecords();//用户记录
                for(int j=0; j<callRecords.size(); j++) {
                    if(users2.get(i).getNumber().equals(callRecords.get(j).getCallingNumber())) {
                        if(callRecords.get(j).getCallingAddressAreaCode().equals("0791")) {
                            if(callRecords.get(j).getAnswerAddressAreaCode().matches("0791")) {//市内打市内电话
                                userRecords.addCallingInCityRecords(callRecords.get(j));
                            }
                            else if(callRecords.get(j).getAnswerAddressAreaCode().matches("((079\\d)|0701)")) {//市内打省内电话
                                userRecords.addCallingInProvinceRecords(callRecords.get(j));
                            }
                            else {//市内打国内电话
                                userRecords.addCallingInLandRecords(callRecords.get(j));
                            }
                        }
                        else if(callRecords.get(j).getCallingAddressAreaCode().matches("((079\\d)|0701)")) {
                            userRecords.addPcallingRecords(callRecords.get(j));
                        }
                        else {
                            userRecords.addLcallingRecords(callRecords.get(j));
                        }
                    }
                    if(users2.get(i).getNumber().equals(callRecords.get(j).getAnswerNumber())) {
                        if(callRecords.get(j).getAnswerAddressAreaCode().matches("0791")) {//市内接电话
                            userRecords.addAnswerInCityRecords(callRecords.get(j));
                        }
                        else if(callRecords.get(j).getAnswerAddressAreaCode().matches("((079\\d)|0701)")) {//省内接电话
                            userRecords.addAnswerInProvinceRecords(callRecords.get(j));
                        }
                        else {//国内接电话
                            userRecords.addAnswerInLandRecords(callRecords.get(j));
                        }
                    }
                }
                users2.get(i).setUserRecords(userRecords);//将用户记录存入对应用户中
            }
            
        for(User u : users1) {
            System.out.println(u.getNumber()+" "+String.format("%.1f", u.calCost())+" "+String.format("%.1f", u.getBalance()));
        }
        for(User u : users2) {
            System.out.println(u.getNumber()+" "+String.format("%.1f", u.calCost())+" "+String.format("%.1f", u.getBalance()));
        }
        
    }
    
}
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 Date getStartTime() {
        return startTime;
    }
    public void setStartTime(Date startTime) {
        this.startTime = startTime;
    }
    public Date getEndTime() {
        return endTime;
    }
    public void setEndTime(Date endTime) {
        this.endTime = endTime;
    }
    public String getCallingAddressAreaCode() {
        return callingAddressAreaCode;
    }
    public void setCallingAddressAreaCode(String callingAddressAreaCode) {
        this.callingAddressAreaCode = callingAddressAreaCode;
    }
    public String getAnswerAddressAreaCode() {
        return answerAddressAreaCode;
    }
    public void setAnswerAddressAreaCode(String answerAddressAreaCode) {
        this.answerAddressAreaCode = answerAddressAreaCode;
    }
    
    

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

    public ArrayList<ChargeRule> getChargeRules(){
        return 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 {
    private String callingNumber;//拨打电话
    private 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 JudgeFormat {
    public static int judge(String number) {
        if( number.matches("u-0791\\d{7,9} 0") )
            return 1;//座机开户
        else if( number.matches("u-1\\d{10} 1") )
            return 2;//手机开户
        else if( number.matches("t-\\d{11,13} \\d{10,13} [1-9]\\d{3}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1]) (2[0-3]|[0-1]\\d):[0-5]\\d:[0-5]\\d [1-9]\\d{3}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1]) (2[0-3]|[0-1]\\d):[0-5]\\d:[0-5]\\d") )
            return 3;//座机打座机
        else if ( number.matches("t-\\d{10,13} 1\\d{10} 0\\d{2,4} [1-9]\\d{3}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1]) (2[0-3]|[0-1]\\d):[0-5]\\d:[0-5]\\d [1-9]\\d{3}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1]) (2[0-3]|[0-1]\\d):[0-5]\\d:[0-5]\\d") )
            return 4;//座机打手机
        else if ( number.matches("t-1\\d{10} 0\\d{3,5} 1\\d{10} 0\\d{2,4} [1-9]\\d{3}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1]) (2[0-3]|[0-1]\\d):[0-5]\\d:[0-5]\\d [1-9]\\d{3}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1]) (2[0-3]|[0-1]\\d):[0-5]\\d:[0-5]\\d") )
            return 5;//手机互打
        else if( number.matches("t-1\\d{10} 0\\d{3,5} 0791\\d{7,9} [1-9]\\d{3}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1]) (2[0-3]|[0-1]\\d):[0-5]\\d:[0-5]\\d [1-9]\\d{3}\\.([1-9]|1[0-2])\\.([1-9]|[1-2][0-9]|3[0-1]) (2[0-3]|[0-1]\\d):[0-5]\\d:[0-5]\\d") )
            return 6;//手机打座机
        return 0;
        
    }

}
class LandlinePhoneCharging extends ChargeMode{
    private double monthlyRent=20;//月租

    @Override
    public double calCost(UserRecords userRecords) {//话费
        double rent = 0;
        ArrayList<CallRecord> callInCityRecords = userRecords.getCallingInCityRecords();//获取拨打市内电话记录
        ArrayList<CallRecord> callInProvinceRecords = userRecords.getCallingInProvinceRecords();//获取拨打省内电话记录
        ArrayList<CallRecord> callInLandRecords = userRecords.getCallingInLandRecords();//获取拨打国内电话记录
        CallChargeRule landPhoneInCityRule = new LandPhoneInCityRule();//市内主叫市内        
        CallChargeRule landPhoneInProvinceRule = new LandPhoneInProvinceRule();//市内主叫省内
        CallChargeRule landPhoneInLandRule = new LandPhoneInlandRule();//市内主叫国内
//        CallChargeRule callChargeRule = new LandPhoneInCityRule();
        rent+=landPhoneInCityRule.calCost(callInCityRecords);
        
//        callChargeRule = new LandPhoneInProvinceRule();
        rent+=landPhoneInProvinceRule.calCost(callInProvinceRecords);
        
//        callChargeRule = new LandPhoneInlandRule();
        rent+=landPhoneInLandRule.calCost(callInLandRecords);
        
        return rent;
    }

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

}
class LandPhoneInCityRule extends CallChargeRule{

    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum = 0;
        for(int i=0;i<callRecords.size();i++)
        {
            long min=((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000)/ 60;//转化时间
            if((((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000) % 60)!=0)
                min++;
            sum+=0.1*min;
        }
        return sum;
    }

}
class LandPhoneInlandRule extends CallChargeRule{

    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum = 0;
        for(int i=0;i<callRecords.size();i++)
        {

            long min=( (callRecords.get(i).getEndTime().getTime()-callRecords.get(i).getStartTime().getTime())/1000 )/60;//转化时间
            if((((callRecords.get(i).getEndTime().getTime() 
                    - callRecords.get(i).getStartTime().getTime()) / 1000) % 60)!=0) {
                min++;
            }
            sum+=0.6*min;
        }
        return sum;
    }

}
class LandPhoneInProvinceRule extends CallChargeRule{

    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum = 0;
        for(int i=0;i<callRecords.size();i++)
        {
            long min=((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000) / 60;//转化时间
            if((((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000) % 60)!=0)
                min++;
            sum+=0.3*min;
        }
        return sum;
    }

}
class MobilePhoneCharging extends ChargeMode{
    private double monthlyRent=15;//月租

    @Override
    public double calCost(UserRecords userRecords) {//话费
        double rent = 0;
        CallChargeRule callChargeRule = new MobilePhoneInCityRule();//市内打市内电话
        rent+=callChargeRule.calCost(userRecords.getCallingInCityRecords());
        
        callChargeRule = new MobilePhoneInProvinceRule();//市内打省内电话
        rent+=callChargeRule.calCost(userRecords.getCallingInProvinceRecords());
        
        callChargeRule = new MobilePhoneInlandRule();//市内打国内电话
        rent+=callChargeRule.calCost(userRecords.getCallingInLandRecords());
        
        callChargeRule = new MobilePhoneRoamingAnswerOutProvince();//省外接电话
        rent+=callChargeRule.calCost(userRecords.getAnswerInLandRecords());
        
        callChargeRule = new MobilePhoneRoamingCallOutProvince();//省外打电话
        rent+=callChargeRule.calCost(userRecords.getLcallingRecords());
        
        callChargeRule = new MobilePhoneRoamingCallsInProvince();//省内打电话
        rent+=callChargeRule.calCost(userRecords.getPcallingRecords());
        
        return rent;
        
        
    }

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

}
class MobilePhoneInCityRule extends CallChargeRule{

    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {//市内打市内
        double sum = 0;
        for(int i=0;i<callRecords.size();i++)
        {
            long min=((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000)/ 60;//转化时间
            if((((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000) % 60)!=0)
                min++;
            sum+=0.1*min;
        }
        return sum;
    }

}
class MobilePhoneInlandRule extends CallChargeRule{
    
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {//市内打省外
        double sum = 0;
        for(int i=0;i<callRecords.size();i++)
        {
            long min=((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000)/ 60;//转化时间
            if((((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000) % 60)!=0)
                min++;
            sum+=0.3*min;
        }
        return sum;
    }

}
class MobilePhoneInProvinceRule extends CallChargeRule{//市内拨打省内

    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum = 0;
        for(int i=0;i<callRecords.size();i++)
        {
            long min=((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000)/ 60;//转化时间
            if((((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000) % 60)!=0)
                min++;
            sum+=0.2*min;
        }
        return sum;
    }

}
class MobilePhoneRoamingAnswerOutProvince extends CallChargeRule{
    
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {//省外漫游接电话
        double sum = 0;
        for(int i=0;i<callRecords.size();i++)
        {
            long min=((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000)/ 60;//转化时间
            if((((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000) % 60)!=0)
                min++;
            sum+=0.3*min;
        }
        return sum;
    }

}
class MobilePhoneRoamingCallOutProvince extends CallChargeRule{
    
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {//省外漫游打电话
        double sum = 0;
        for(int i=0;i<callRecords.size();i++)
        {
            long min=((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000)/ 60;//转化时间
            if((((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000) % 60)!=0)
                min++;
            sum+=0.6*min;
        }
        return sum;
    }


}
class MobilePhoneRoamingCallsInProvince extends CallChargeRule{
    
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {//省内漫游打电话
        double sum = 0;
        for(int i=0;i<callRecords.size();i++)
        {
            long min=((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000)/ 60;//转化时间
            if((((callRecords.get(i).getEndTime().getTime() - callRecords.get(i).getStartTime().getTime()) / 1000) % 60)!=0)
                min++;
            sum+=0.3*min;
        }
        return sum;
    }


}
class User {
    private UserRecords userRecords;//用户记录
    private double balance=100;//用户余额
    private ChargeMode chargeMode;//计费方式
    private String number;//号码
    
    public double calCost() {
        double sum=chargeMode.calCost(userRecords);
        balance-=(sum+chargeMode.getMonthlyRent());
        return sum;
        
    }

    public UserRecords getUserRecords() {
        return userRecords;
    }

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

    public double getBalance() {
        return balance;
    }


    public ChargeMode getChargeMode() {
        return chargeMode;
    }

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

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    } 
    
    public User(ChargeMode chargeMode,String number) {
        this.chargeMode=chargeMode;
        this.number=number;
    }
    
}
class UserRecords {
    ArrayList<CallRecord> callingInCityRecords = new ArrayList<CallRecord>();//市内打电话
    ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<CallRecord>();//省内打电话
    ArrayList<CallRecord> callingInLandRecords = new ArrayList<CallRecord>();//国内打电话
    ArrayList<CallRecord> PcallingRecords = new ArrayList<CallRecord>();//省内打漫游
    ArrayList<CallRecord> LcallingRecords = new ArrayList<CallRecord>();//国内打漫游
    ArrayList<CallRecord> answerInCityRecords = new ArrayList<CallRecord>();//市内接电话
    ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<CallRecord>();//省内接电话
    ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();//国内接电话
    
    public ArrayList<CallRecord> getCallingInCityRecords() {
        return callingInCityRecords;
    }
    public void addCallingInCityRecords(CallRecord callRecord) {//添加市内打电话记录
        callingInCityRecords.add(callRecord);
    }
    
    public ArrayList<CallRecord> getCallingInProvinceRecords() {
        return callingInProvinceRecords;
    }
    public void addCallingInProvinceRecords(CallRecord callRecord) {//添加省内打电话记录
        callingInProvinceRecords.add(callRecord);
    }
    
    public ArrayList<CallRecord> getCallingInLandRecords() {
        return callingInLandRecords;
    }
    public void addCallingInLandRecords(CallRecord callRecord) {//添加国内打电话记录
        callingInLandRecords.add(callRecord);
    }
    
    public ArrayList<CallRecord> getAnswerInCityRecords() {
        return answerInCityRecords;
    }
    public void addAnswerInCityRecords(CallRecord answerRecord) {//添加市内接电话记录
        answerInCityRecords.add(answerRecord);
    }
    
    public ArrayList<CallRecord> getAnswerInProvinceRecords() {
        return answerInProvinceRecords;
    }
    public void addAnswerInProvinceRecords(CallRecord answerRecord) {//添加省内接电话记录
        answerInProvinceRecords.add(answerRecord);
    }
    
    public ArrayList<CallRecord> getAnswerInLandRecords() {
        return answerInLandRecords;
    }
    public void addAnswerInLandRecords(CallRecord answerRecord) {//添加国内接电话记录
        answerInLandRecords.add(answerRecord);
    }
    public void addPcallingRecords (CallRecord callRecord) {
        PcallingRecords.add(callRecord);
    }
    public ArrayList<CallRecord> getPcallingRecords() {
        return PcallingRecords;
    }
    public void addLcallingRecords (CallRecord callRecord) {
        LcallingRecords.add(callRecord);
    }
    public ArrayList<CallRecord> getLcallingRecords() {
        return LcallingRecords;
    }
    
    

}

三、踩坑心得：

　　这三周，我们写这个pta其中修复了很多bug，比如少写了添加的信息，导致有些东西传不进去或者报错，还有时候没有建立座机类导致一直会报错，有时候没有新建类导致有的信息没传，导致我会一直报错，就算我写完了都还有梳理很长时间的思路，当然这次的pta的作业让我知道了如何面向对象去设计实验，面向对象的好处，他的思路更清晰，修改起来更简单，代码耦合度小，代码复杂度低的优点。当我掌握这种方法后可以使代码复用度更高，可以使后面需要加什么代码直接可以加上去，不用再去另外写新的代码了。

四、改进建议：

　　这次的Main函数的代码太过于长了，导致很不好寻找，思路不清晰，耦合度有点高。

　　在设计架构方面，笔者感觉第二单元的架构会比第一单元清晰。第一单元每次作业笔者都进行了重构，而且每次都感觉是在面向过程编程，而第二单元后两次作业沿用的都是第一次的架构，并且第二单元完成三次作业的时间相比第一单元少很多，每次作业平均花费时间只有第一单元每次作业的一半左右。在正确性上，笔者实际上没有对自己第二单元的作业进行较多测试，因此，再次感觉一个良好的架构对编程的效率和正确性都提供了很好的保障。

五、总结：

　　对于自己写的程序来说bug还是有很多的，但形成的原因也是有很多的，比如类的混乱，还有随机数的产生导致有些点可以过，但随机数可能使那些点不能过。还有那些正则表达式超级长，看到就脑阔疼，今后我个人会尽量避免写出这样的代码，除非真的万不得已。

　　当然在写第五次大作业的时候7-1中的第3次情况写了一大段，但是当运行的时候就不能运行，一开始以为时是单纯的进不了循环，当测试几个样例的时候发现可以进入，那个时候就快崩溃了，当时代码写的太杂了，而且都是很混乱的，导致自己根本改不好，只能无奈的全删了，去骗分。当时就后悔了，应该讲那些代码写进一个类，在类里面进行判断，这样代码既不会写错，到时候改的时候也会更清晰明了一点。不会像这样气急败坏的删除了。

　　面向对象不一定比面向过程，面向结果优越，但是优秀的封装和类一定好太多了，第三次作业能写满分，我相信他的封装和代码一定比别人更清晰明了，也更容易看的懂。

　　展望：

　　经过这三个周的洗礼，我觉得我的代码能力有明显的提升，当然有些地方也有些不足，同时自我学习能力也会更强，因为那些正则表达式是自己在网络上找的资料学习的，当然大家的进步速度也是迅猛的，我也要加把劲。

　　在后面两次作业中，能明显感受到代码量增加，期中全部加起来都没有400行，但是第四五次大作业，一个题目就会有1000多行代码，因为里面包含很多算法和方法。

 　　期望：

　　在这三周我学到了很多东西，例如一些函数的运用，同时也吸取了教训，积累了经验。