6-8次PTA题目集总结

一，前言

1，第六次作业（针对电信计费）

本次作业主要是对类的操作，题目已经给出类图，类图里面已经给了各种方法以及属性。此次作业涉及了座机的计费方式，市内省内省外怎么计费。难度偏难，主要是各类之间怎么实现连接，类的编写复杂，工程量巨大，需要弄清楚逻辑方可计算。

2，第七次作业（针对电信计费）

再上一次的基础上增加了一个手机计费方式，座机对座机，座机对手机，手机对座机，手机对手机，需要考虑的方面还是很多的，很多的测试点。难度偏难，难度在于情况多，难以考虑到全部。

3，第八次作业（针对电信计费）

本次是最简单的一次作业，电信计费只需要短信，在以前的类图中增加短信的类，难度偏低。考察的还是类之间的连接。

二，设计与分析（代码部分已折叠）

1，第六次作业（针对电信计费）

实现一个简单的电信计费程序：
假设南昌市电信分公司针对市内座机用户采用的计费方式：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
南昌市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。

输入格式:

输入信息包括两种类型
1、逐行输入南昌市用户开户的信息，每行一个用户，
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐）
例如：u-079186300001 0
座机号码除区号外由是7-8位数字组成。
本题只考虑计费类型0-座机计费，电信系列2、3题会逐步增加计费类型。
2、逐行输入本月某些用户的通讯信息，通讯信息格式：
座机呼叫座机：t-主叫号码 接听号码 起始时间 结束时间
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四项内容之间以一个英文空格分隔，
时间必须符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat类。
以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
注意：
本题非法输入只做格式非法的判断，不做内容是否合理的判断（时间除外，否则无法计算），比如：
1、输入的所有通讯信息均认为是同一个月的通讯信息，不做日期是否在同一个月还是多个月的判定，直接将通讯费用累加，因此月租只计算一次。
2、记录中如果同一电话号码的多条通话记录时间出现重合，这种情况也不做判断，直接 计算每条记录的费用并累加。
3、用户区号不为南昌市的区号也作为正常用户处理。

输出格式:

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

错误处理：
输入数据中出现的不符合格式要求的行一律忽略。

建议类图：
参见图1、2、3，可根据理解自行调整：

图1
图1中User是用户类，包括属性：
userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。

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

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


 

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

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


 

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

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

 

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

设计：

先按照类图写出各个类，类的属性方法。

计费方式分为三个方式，然后这三个方式归属于收费方式类，需要添加在记录数组里面。通讯记录又分为电话记录和短信记录，电话记录中有一些数组，例如座机市内通话记录，省内通话记录，我们需要根据输入的记录放进不同的数组，根据全部数组在计算是调用不同的收费方式算钱。输入用户时我们需要在主函数创建user数组，存放注册的用户，再在对应的用户记录数组里面添加记录，最后算出费用。这里难度就在于刚开始的类的逻辑怎么连起来，连起来之后就比较简单了，只需要在主函数记录。

剩下的只需要考虑的全面，拿分还是挺简单的。

import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Objects;
import java.util.Scanner;

public class Main {
    public static void Print(double data) {          //保留1位小数
        System.out.print((float)(data));
    }
    public static void main(String[] args) {
        String gre = "t-0791[0-9]{7,8}\\s" + "0[0-9]{9,11}\\s" +
                "([1-9][0-9]{3}\\.([1-9]|1[0-2])\\.([1-9]|(2[0-9]|3[0-1])) ([0|1]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}";
        String gre1 = "u-0791[0-9]{7,8}\\s[0-2]";
        ArrayList<User> user = new ArrayList<>();
        Scanner in = new Scanner(System.in);
        while (true) {
            String str = in.nextLine();
            if (str.equals("end")) break;
            if (str.matches(gre1)) {
                String[] array = str.split("-", 2);
                String[] array1 = array[1].split(" ", 2);
                String phone_number = array1[0];
                boolean has_found = false;
                for (User value : user) {
                    if (phone_number.equals(value.getNumber())) {
                        has_found = true;
                        break;
                    }
                }
                if (has_found) continue;
                User u = new User();
                u.setNumber(phone_number);
                if (Objects.equals(array1[1], "0")) {
                    u.setChargeMode(new LandlinePhoneCharging());
                }
                user.add(u);
            } else if (str.matches(gre)) {
                String[] array = str.split("-", 2);
                String[] array1 = array[1].split(" ");
                String phone_number = array1[0];
                String phone_number1 = array1[1];
                String start_time = array1[2] + " " + array1[3];
                String end_time = array1[4] + " " + array1[5];
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
                Date date = null, date1 = null;
                try {
                    date = sdf.parse(start_time);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                try {
                    date1 = sdf.parse(end_time);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                for (int i = 0; i < user.size(); i++) {
                    if (phone_number.equals(user.get(i).getNumber())) {
                        CallRecord callRecord = new CallRecord();
                        callRecord.setStartTime(date);
                        callRecord.setEndTime(date1);
                        callRecord.setCallingAddressAreaCode(phone_number.substring(0, 4));
                        callRecord.setAnswerAddressAreaCode(phone_number1.substring(0, 4));
                        if (Objects.equals(callRecord.getAnswerAddressAreaCode(), callRecord.getCallingAddressAreaCode())) {
                            user.get(i).userRecords.addCallingInCityRecords(callRecord);
                        } else if (callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)")) {
                            user.get(i).userRecords.addCallingInProvinceRecords(callRecord);
                        } else {
                            user.get(i).userRecords.addCallingInLandRecords(callRecord);
                        }
                    }
                }
            }
        }
        user.sort((user1,user2)->user1.getNumber().compareTo(user2.getNumber()));
        for (int i = 0; i < user.size(); i++) {
            System.out.print(user.get(i).getNumber() + " ");
            Print(user.get(i).calCost());
            System.out.print(" ");
            Print(user.get(i).calBalance());
            System.out.println();
        }
    }
}

abstract class CallChargeRule extends ChargeRule{
}
class CallRecord extends CommunicationRecord{
    Date startTime;
    Date endTime;
    String callingAddressAreaCode;
    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 {
    ArrayList<ChargeRule> ChargeRules=new ArrayList<>();
    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 {
    public abstract double calCost(ArrayList<CallRecord> callRecords);
}
abstract class CommunicationRecord {
    protected String callingNumber;
    protected String answerNumber;

    public String getCallingNumber(){
        return callingNumber;
    }
    public void setCallingNumber(String callingNumber){
        this.callingNumber=callingNumber;
    }
    public String getAnswerNumber(){
        return answerNumber;
    }
    public void setAnswerNumber(String answerNumber){
        this.answerNumber=answerNumber;
    }
}
class LandlinePhoneCharging extends ChargeMode{
    double monthlyRent=20;
    public LandlinePhoneCharging(){
        ChargeRules.add(new LandPhoneInCityRule());
        ChargeRules.add(new LandPhoneInProvinceRule());
        ChargeRules.add(new LandPhoneInLandRule());
    }
    @Override
    public double calCost(UserRecords userRecords){//三种收费方式加起来的钱
        double sum_cost=0;
        sum_cost += ChargeRules.get(0).calCost(userRecords.callingInCityRecords);
        sum_cost += ChargeRules.get(1).calCost(userRecords.callingInProvinceRecords);
        sum_cost += ChargeRules.get(2).calCost(userRecords.callingInLandRecords);
        return sum_cost;
    }
    @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++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
        sum=Math.ceil(sum);
        }
        return sum*0.1;
    }
}
class LandPhoneInLandRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
        sum=Math.ceil(sum);
        }
        return sum*0.6;
    }
}
class LandPhoneInProvinceRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
        sum=Math.ceil(sum);
        }
        return sum*0.3;
    }
}
class MessageRecord extends CommunicationRecord{
    String message;

    public String getMessage(){
        return null;
    }
    public void setMessage(String message){

    };
}
 class User {
    UserRecords userRecords=new UserRecords();
    private final double balance=100;
    private ChargeMode chargeMode;
    private String number;
    public double calBalance(){
        return this.balance-this.calCost()-chargeMode.getMonthlyRent();
    }
    public double calCost(){
        return chargeMode.calCost(userRecords);
    }
    public UserRecords getUserRecords(){
        return this.userRecords;
    }
    public void setUserRecord(UserRecords userRecords){
        this.userRecords=userRecords;
    }
    public ChargeMode getChargeMode(){
        return chargeMode;
    }
    public double getBalance(){
        return this.balance;
    }
    public void setChargeMode(ChargeMode chargeMode){
        this.chargeMode=chargeMode;
    }
    public String getNumber(){
        return this.number;
    }
    public void setNumber(String number){
        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> answerInCityRecords=new ArrayList<CallRecord>();
    ArrayList<CallRecord> answerInProvinceRecords=new ArrayList<CallRecord>();
    ArrayList<CallRecord> answerInLandRecords=new ArrayList<CallRecord>();
    ArrayList<MessageRecord> sendMessageRecords=new ArrayList<MessageRecord>();
    ArrayList<MessageRecord> receiveMessageRecords=new ArrayList<MessageRecord>();

    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 addSentMessageRecords(MessageRecord sendMessageRecords){}
    public void addReceiveMessageRecords(MessageRecord receiveMessageRecords){}

    public ArrayList<MessageRecord> getSendMessageRecords(){return sendMessageRecords;}
    public ArrayList<MessageRecord> getReceiveMessageRecords(){return receiveMessageRecords;}
    public ArrayList<CallRecord> getCallingInCityRecords(){return callingInCityRecords;}
    public ArrayList<CallRecord> getCallingInProvinceRecords(){return callingInProvinceRecords;}
    public ArrayList<CallRecord> getCallingInLandRecords(){return callingInLandRecords;}
    public ArrayList<CallRecord> getAnswerInCityRecords(){return answerInCityRecords;}
    public ArrayList<CallRecord> getAnswerInProvinceRecords(){return answerInProvinceRecords;}
    public ArrayList<CallRecord> getAnswerInLandRecords(){return answerInLandRecords;}

}

大部分代码都是类图里面给出的，来看看类图吧

代码质量：

293行
报表 220
百分比分支报表 8.6
方法调用语句 76
带注释的百分比行 0.7
类和接口 13
每个类的方法 3.77
每个方法的平均语句数 2.43
最复杂方法的行号 15
最复杂方法的名称 main.main（）
最大复杂度 17
最深块的行号 69
最大区块深度 7
平均区块深度 2.05
平均复杂度 1.39

2，第七次作业（针对电信计费）

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

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

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

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

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

 

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

图1

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

 

图2

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

 

图3

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

 

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

设计：

这次作业增加了手机计费，可以为座机打手机，座机打座机，手机打座机，手机打手机。从判断来看就需要考虑的异常全面，计费方式也增加了，手机增加了省内漫游和省外漫游，题目较复杂。从获取用户信息方面来看，需要设计五个正则表达式，分别为用户注册的，座机打手机，座机打座机，手机打座机，手机打手机（好像这样比较复杂，我看别人都是一部到位，通话记录一步到位）。我这样写代码很长，不建议分五个步骤，因为每个步骤里面有重复的东西，就是对在省内省外的判断，以及计算，冗长复杂，容易出错。对于类而言，我还增加了手机的计费规则，不用说也明白，这样又更麻烦了一些，搞得又要添加数组，又要添加规则，类图错综复杂，还不如放在上次的计费计算里面。

我这种复杂的方法经过漫长的编写还是拿到了分数

import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Objects;
import java.util.Scanner;

public class Main {
    public static void Print(double data) {          //保留1位小数
        DecimalFormat df = new DecimalFormat("0.0#");
        df.setRoundingMode(RoundingMode.HALF_UP);
        System.out.print(df.format(data));
    }
    public static void main(String[] args) {
        String l_l = "t-0[0-9]{9,11}\\s" + "0[0-9]{9,11}\\s" +
                "[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) " +
                "(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) " +
                "[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) " +
                "(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$";
        String l_m ="t-0[0-9]{9,11}\\s" + "1[0-9]{10}\\s" +"0[0-9]{2,3}\\s"+
                "[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) " +
                "(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) " +
                "[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) " +
                "(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$";
        String m_m ="t-1[0-9]{10}\\s" + "0[0-9]{2,3}\\s" + "1[0-9]{10}\\s" +"0[0-9]{2,3}\\s"+
                "[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) " +
                "(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) " +
                "[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) " +
                "(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$";
        String m_l ="t-1[0-9]{10}\\s"+ "0[0-9]{2,3}\\s" + "0[0-9]{9,11}\\s"+
                "[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|(3[0-1])) " +
                "(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9]) " +
                "[0-9]{4}[.](([1-9]{1})|([1]{1}[0-2]{1}))[.]([1-9]|([1-2]{1}[0-9]{1})|3[0-1]) " +
                "(([0-1][0-9])|(2[0-3]))[:]([0-5][0-9])[:]([0-5][0-9])$";
        String gre1 = "u-[0-9]{10,12}\\s[0-2]";
        ArrayList<User> user = new ArrayList<>();
        Scanner in = new Scanner(System.in);
        while (true) {
            String str = in.nextLine();
            if (str.equals("end")) break;
            if (str.matches(gre1)) {
                String[] array = str.split("-", 2);
                String[] array1 = array[1].split(" ", 2);
                String phone_number = array1[0];
                boolean has_found = false;
                for (User value : user) {
                    if (phone_number.equals(value.getNumber())) {
                        has_found = true;
                        break;
                    }
                }
                if (has_found) continue;
                User u = new User();
                u.setNumber(phone_number);
                if (array1[1].equals("0")) {
                    u.setChargeMode(new LandlinePhoneCharging());
                } else if (array1[1].equals("1")) {
                    u.setChargeMode(new MobilePhoneCharging());
                }
                user.add(u);
            } else if (str.matches(l_l)) {
                String[] array = str.split("-", 2);
                String[] array1 = array[1].split(" ");
                String phone_number = array1[0];
                String phone_number1 = array1[1];
                String start_time = array1[2] + " " + array1[3];
                String end_time = array1[4] + " " + array1[5];
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
                Date date = null, date1 = null;
                try {
                    date = sdf.parse(start_time);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                try {
                    date1 = sdf.parse(end_time);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                for (int i = 0; i < user.size(); i++) {
                    if (phone_number.equals(user.get(i).getNumber())) {
                        CallRecord callRecord = new CallRecord();
                        callRecord.setStartTime(date);
                        callRecord.setEndTime(date1);
                        callRecord.setCallingAddressAreaCode(phone_number.substring(0, 4));
                        callRecord.setAnswerAddressAreaCode(phone_number1.substring(0, 4));
                        if (callRecord.getAnswerAddressAreaCode().matches("0791")&&
                                callRecord.getCallingAddressAreaCode().matches("0791")) {
                            user.get(i).userRecords.addCallingInCityRecords(callRecord);
                        } else if (callRecord.getCallingAddressAreaCode().matches("0791")&&
                                callRecord.getAnswerAddressAreaCode().matches("(079[2-9]|(0701|0790))")) {
                            user.get(i).userRecords.addCallingInProvinceRecords(callRecord);
                        } else if(callRecord.getCallingAddressAreaCode().matches("0791")&&
                                !callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)")){
                            user.get(i).userRecords.addCallingInLandRecords(callRecord);
                        }
                    }
                }
            }else if(str.matches(l_m))
            {
                boolean flag=false;
                String[] array = str.split("-", 2);
                String[] array1 = array[1].split(" ");
                String phone_number = array1[0];
                String phone_number1 = array1[1];
                String Pickup_location_area_code = array1[2];
                String start_time = array1[3] + " " + array1[4];
                String end_time = array1[5] + " " + array1[6];
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
                Date date = null, date1 = null;
                try {
                    date = sdf.parse(start_time);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                try {
                    date1 = sdf.parse(end_time);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                CallRecord callRecord = new CallRecord();
                callRecord.setStartTime(date);
                callRecord.setEndTime(date1);
                callRecord.setCallingAddressAreaCode(phone_number.substring(0, 4));
                callRecord.setAnswerAddressAreaCode(Pickup_location_area_code);
                for (int i = 0; i < user.size(); i++) {//添加通话记录
                    if (phone_number.equals(user.get(i).getNumber())) {
                        if (callRecord.getAnswerAddressAreaCode().matches("0791")&&
                                callRecord.getCallingAddressAreaCode().matches("0791")) {
                            user.get(i).userRecords.addCallingInCityRecords(callRecord);flag=true;
                        } else if (callRecord.getCallingAddressAreaCode().matches("0791")&&
                                callRecord.getAnswerAddressAreaCode().matches("(079[2-9]|(0701|0790))")) {
                            user.get(i).userRecords.addCallingInProvinceRecords(callRecord);flag=true;
                        } else if(callRecord.getCallingAddressAreaCode().matches("0791")&&
                                !callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)")){
                            for(int j=0;j<user.size();j++)
                                if(user.get(j).getNumber().equals(phone_number1))
                                    user.get(j).userRecords.addCallingInLandRoamingAnswerRecords(callRecord);
                            user.get(i).userRecords.addCallingInLandRecords(callRecord);flag=true;
                        }
                    }
                }
                if(flag)continue;
                for (int j=0;j<user.size();j++)
                {
                    if(phone_number1.equals(user.get(j).getNumber())) {
                        if(!callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)"))
                        {
                            for(int k=0;k<user.size();k++)
                                if(user.get(k).getNumber().equals(phone_number1))
                                    user.get(k).userRecords.addCallingInLandRoamingAnswerRecords(callRecord);
                        }
                    }
                }
            } else if (str.matches(m_l)) {
                String[] array = str.split("-", 2);
                String[] array1 = array[1].split(" ");
                String phone_number = array1[0];
                String  Pickup_location_area_code= array1[1];
                String phone_number1 = array1[2];
                String start_time = array1[3] + " " + array1[4];
                String end_time = array1[5] + " " + array1[6];
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
                Date date = null, date1 = null;
                try {
                    date = sdf.parse(start_time);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                try {
                    date1 = sdf.parse(end_time);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                CallRecord callRecord = new CallRecord();
                callRecord.setStartTime(date);
                callRecord.setEndTime(date1);
                callRecord.setCallingAddressAreaCode(Pickup_location_area_code);
                callRecord.setAnswerAddressAreaCode(phone_number1.substring(0, 4));
                for (int i = 0; i < user.size(); i++) {//添加通话记录
                    if (phone_number.equals(user.get(i).getNumber())) {
                        if (callRecord.getAnswerAddressAreaCode().matches("0791")&&
                                callRecord.getCallingAddressAreaCode().matches("0791")) {
                            user.get(i).userRecords.addCallingInCityRecords(callRecord);
                        } else if (callRecord.getCallingAddressAreaCode().matches("0791")&&
                                callRecord.getAnswerAddressAreaCode().matches("(079[2-9]|(0701|0790))")) {
                            user.get(i).userRecords.addCallingInProvinceRecords(callRecord);
                        } else if (callRecord.getCallingAddressAreaCode().matches("0791")&&
                                !callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)")){
                            user.get(i).userRecords.addCallingInLandRecords(callRecord);
                        } else if (callRecord.getCallingAddressAreaCode().matches("(079[2-9]|(0701|0790))")) {
                            user.get(i).userRecords.addCallingInProvinceRoamingDialRecords(callRecord);
                        }else if (!callRecord.getCallingAddressAreaCode().matches("(079[0-9]|0701)")) {
                            user.get(i).userRecords.addCallingInLandRoamingDialRecords(callRecord);
                        }
                    }
                }
            } else if (str.matches(m_m)) {
                boolean flag=false;
                String[] array = str.split("-", 2);
                String[] array1 = array[1].split(" ");
                String phone_number = array1[0];
                String Pickup_location_area_code =array1[1];
                String phone_number1 = array1[2];
                String Pickup_location_area_code1 =array1[3];
                String start_time = array1[4] + " " + array1[5];
                String end_time = array1[6] + " " + array1[7];
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
                Date date = null, date1 = null;
                try {
                    date = sdf.parse(start_time);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                try {
                    date1 = sdf.parse(end_time);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                CallRecord callRecord = new CallRecord();
                callRecord.setStartTime(date);
                callRecord.setEndTime(date1);
                callRecord.setCallingAddressAreaCode(Pickup_location_area_code);
                callRecord.setAnswerAddressAreaCode(Pickup_location_area_code1);
                for (int i = 0; i < user.size(); i++) {//添加通话记录
                    if (phone_number.equals(user.get(i).getNumber())) {
                        if (callRecord.getAnswerAddressAreaCode().matches("0791")&&
                                callRecord.getCallingAddressAreaCode().matches("0791")) {
                            user.get(i).userRecords.addCallingInCityRecords(callRecord);flag=true;
                        } else if (callRecord.getCallingAddressAreaCode().matches("0791")&&
                                       callRecord.getAnswerAddressAreaCode().matches("(079[2-9]|(0701|0790))")) {
                            user.get(i).userRecords.addCallingInProvinceRecords(callRecord);flag=true;
                        } else if(callRecord.getCallingAddressAreaCode().matches("0791")&&
                                !callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)")){
                            for(int j=0;j<user.size();j++)
                                if(user.get(j).getNumber().equals(phone_number1))
                                    user.get(j).userRecords.addCallingInLandRoamingAnswerRecords(callRecord);
                            user.get(i).userRecords.addCallingInLandRecords(callRecord);flag=true;
                        } else if (callRecord.getCallingAddressAreaCode().matches("(079[2-9]|(0701|0790))")) {
                            if(!callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)"))
                            {
                                for(int j=0;j<user.size();j++)
                                    if(user.get(j).getNumber().equals(phone_number1))
                                        user.get(j).userRecords.addCallingInLandRoamingAnswerRecords(callRecord);
                            }
                            user.get(i).userRecords.addCallingInProvinceRoamingDialRecords(callRecord);flag=true;
                        } else if (!callRecord.getCallingAddressAreaCode().matches("(079[0-9]|0701)")) {
                            if(!callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)"))
                            {
                                for(int j=0;j<user.size();j++)
                                    if(user.get(j).getNumber().equals(phone_number1))
                                        user.get(j).userRecords.addCallingInLandRoamingAnswerRecords(callRecord);
                            }
                            user.get(i).userRecords.addCallingInLandRoamingDialRecords(callRecord);flag=true;
                        }
                    }
                }
                if(flag)continue;
                for (int j=0;j<user.size();j++)
                {

                    if(phone_number1.equals(user.get(j).getNumber())) {
                        if(!callRecord.getAnswerAddressAreaCode().matches("(079[0-9]|0701)"))
                        {
                            for(int k=0;k<user.size();k++)
                                if(user.get(k).getNumber().equals(phone_number1))
                                    user.get(k).userRecords.addCallingInLandRoamingAnswerRecords(callRecord);
                        }
                    }
                }
            }
        }
        user.sort((user1,user2)->user1.getNumber().compareTo(user2.getNumber()));
        for (int i = 0; i < user.size(); i++) {
            System.out.print(user.get(i).getNumber() + " ");
            Print(user.get(i).calCost());
            System.out.print(" ");
            Print(user.get(i).calBalance());
            System.out.println();
        }

    }
}

abstract class CallChargeRule extends ChargeRule{
}
class CallRecord extends CommunicationRecord{
    Date startTime;
    Date endTime;
    String callingAddressAreaCode;
    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 {
    ArrayList<ChargeRule> ChargeRules=new ArrayList<>();
    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 {
    public abstract double calCost(ArrayList<CallRecord> callRecords);
}
abstract class CommunicationRecord {
    protected String callingNumber;
    protected String answerNumber;

    public String getCallingNumber(){
        return callingNumber;
    }
    public void setCallingNumber(String callingNumber){
        this.callingNumber=callingNumber;
    }
    public String getAnswerNumber(){
        return answerNumber;
    }
    public void setAnswerNumber(String answerNumber){
        this.answerNumber=answerNumber;
    }
}
class LandlinePhoneCharging extends ChargeMode{
    double monthlyRent=20;
    public LandlinePhoneCharging(){
        ChargeRules.add(new LandPhoneInCityRule());
        ChargeRules.add(new LandPhoneInProvinceRule());
        ChargeRules.add(new LandPhoneInLandRule());
    }
    @Override
    public double calCost(UserRecords userRecords){//三种收费方式加起来的钱
        double sum_cost=0;
        sum_cost += ChargeRules.get(0).calCost(userRecords.callingInCityRecords);
        sum_cost += ChargeRules.get(1).calCost(userRecords.callingInProvinceRecords);
        sum_cost += ChargeRules.get(2).calCost(userRecords.callingInLandRecords);
        return sum_cost;
    }
    @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++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        return Math.ceil(sum)*0.1;
    }
}
class LandPhoneInLandRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        return Math.ceil(sum)*0.6;
    }
}
class LandPhoneInProvinceRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        //System.out.println(Math.ceil(sum)*0.3);
        return sum*0.3;
    }
}
class MessageRecord extends CommunicationRecord{
    String message;

    public String getMessage(){
        return null;
    }
    public void setMessage(String message){

    };
}
class MobilePhoneCharging extends ChargeMode{
    double monthlyRent=15;
    public MobilePhoneCharging(){
        ChargeRules.add(new MobilePhoneInCityRule());
        ChargeRules.add(new MobilePhoneInProvinceRule());
        ChargeRules.add(new MobilePhoneInLandRule());
        ChargeRules.add(new MobilePhoneInProvinceRoamingDials());
        ChargeRules.add(new MobilePhoneInLandRoamingAnswering());
        ChargeRules.add(new MobilePhoneInLandRoamingDials());
    }
    @Override
    public double calCost(UserRecords userRecords) {
        double sum_cost=0;
        sum_cost += ChargeRules.get(0).calCost(userRecords.callingInCityRecords);
        sum_cost += ChargeRules.get(1).calCost(userRecords.callingInProvinceRecords);
        sum_cost += ChargeRules.get(2).calCost(userRecords.callingInLandRecords);
        sum_cost += ChargeRules.get(3).calCost(userRecords.callingInProvinceRoamingDialRecords);
        sum_cost += ChargeRules.get(4).calCost(userRecords.callingInLandRoamingAnswerRecords);
        sum_cost += ChargeRules.get(5).calCost(userRecords.callingInLandRoamingDialRecords);
        return sum_cost;
    }

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

    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        return Math.ceil(sum)*0.1;
    }
}
class MobilePhoneInLandRoamingAnswering extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        return Math.ceil(sum)*0.3;
    }
}
class MobilePhoneInLandRoamingDials extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        return Math.ceil(sum)*0.6;
    }
}
class MobilePhoneInLandRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        return Math.ceil(sum)*0.3;
    }
}
class MobilePhoneInProvinceRoamingDials extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        return Math.ceil(sum)*0.3;
    }
}
class MobilePhoneInProvinceRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        return Math.ceil(sum)*0.2;
    }
}
class User {
    UserRecords userRecords=new UserRecords();
    private final double balance=100;
    private ChargeMode chargeMode;
    private String number;
    public double calBalance(){
        return this.balance-this.calCost()-chargeMode.getMonthlyRent();
    }
    public double calCost(){
        return chargeMode.calCost(userRecords);
    }
    public UserRecords getUserRecords(){
        return this.userRecords;
    }
    public void setUserRecord(UserRecords userRecords){
        this.userRecords=userRecords;
    }
    public ChargeMode getChargeMode(){
        return chargeMode;
    }
    public double getBalance(){
        return this.balance;
    }
    public void setChargeMode(ChargeMode chargeMode){
        this.chargeMode=chargeMode;
    }
    public String getNumber(){
        return this.number;
    }
    public void setNumber(String number){
        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> answerInCityRecords=new ArrayList<CallRecord>();
    ArrayList<CallRecord> answerInProvinceRecords=new ArrayList<CallRecord>();
    ArrayList<CallRecord> answerInLandRecords=new ArrayList<CallRecord>();
    ArrayList<MessageRecord> sendMessageRecords=new ArrayList<MessageRecord>();
    ArrayList<MessageRecord> receiveMessageRecords=new ArrayList<MessageRecord>();
    ArrayList<CallRecord> callingInProvinceRoamingDialRecords=new ArrayList<CallRecord>();//省内漫游拨打记录
    ArrayList<CallRecord> callingInLandRoamingAnswerRecords=new ArrayList<CallRecord>();//省外漫游接听记录
    ArrayList<CallRecord> callingInLandRoamingDialRecords=new ArrayList<CallRecord>();//省外漫游拨打记录
    public void addCallingInLandRoamingDialRecords(CallRecord callRecord){
        callingInLandRoamingDialRecords.add(callRecord);
    }
    public void addCallingInLandRoamingAnswerRecords(CallRecord callRecord){
        callingInLandRoamingAnswerRecords.add(callRecord);
    }
    public void addCallingInProvinceRoamingDialRecords(CallRecord callRecord){
        callingInProvinceRoamingDialRecords.add(callRecord);
    }
    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 addSentMessageRecords(MessageRecord sendMessageRecords){}
    public void addReceiveMessageRecords(MessageRecord receiveMessageRecords){}

    public ArrayList<MessageRecord> getSendMessageRecords(){return sendMessageRecords;}
    public ArrayList<MessageRecord> getReceiveMessageRecords(){return receiveMessageRecords;}
    public ArrayList<CallRecord> getCallingInCityRecords(){return callingInCityRecords;}
    public ArrayList<CallRecord> getCallingInProvinceRecords(){return callingInProvinceRecords;}
    public ArrayList<CallRecord> getCallingInLandRecords(){return callingInLandRecords;}
    public ArrayList<CallRecord> getAnswerInCityRecords(){return answerInCityRecords;}
    public ArrayList<CallRecord> getAnswerInProvinceRecords(){return answerInProvinceRecords;}
    public ArrayList<CallRecord> getAnswerInLandRecords(){return answerInLandRecords;}
}

类图：

代码质量：

595行
报表 447
分支报表百分比 17.0
方法调用语句 267
带注释的百分比行 1.8
类和接口 20
每个类的方法 3.05
每个方法的平均语句数 5.18
最复杂方法的行号 17
最复杂方法的名称 main.main（）
最大复杂度 80
最深块线号 246
最大区块深度 9+
平均区块深度 3.01
平均复杂度 2.44

3，第八次作业（针对电信计费）

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

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

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

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

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

图1

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

 

图2

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

 

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

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

 

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

设计：

这题比较简单，只有短信计费，十个字记一次钱，发送短信0.1元/条，超过3条0.2元/条，超过5条0.3元/条，如果一次发送短信的字符数量超过10个，按每10个字符一条短信进行计算。加一个短信计费类型，在里面算出字符的个数再进行算钱，思路大概就是这样。然后在主函数里面把之前的删掉，改为一个短信计费的正则表达式即可。记录为短信记录。

相比于前两题还是很简单的

源码

import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Objects;
import java.util.Scanner;

public class Main {
    public static void Print(double data) {          //保留1位小数
        DecimalFormat df = new DecimalFormat("0.0#");
        df.setRoundingMode(RoundingMode.HALF_UP);
        System.out.print(df.format(data));
    }
    public static void main(String[] args) {
        String message ="m-1[0-9]{10}\\s"+"1[0-9]{10}\\s"+"[\\w\\s\\.,]+";
        String gre1 = "u-1[0-9]{10}\\s3";
        ArrayList<User> user = new ArrayList<>();
        Scanner in = new Scanner(System.in);
        while (true) {
            String str = in.nextLine();
            if (str.equals("end")) break;
            if (str.matches(gre1)) {
                String[] array = str.split("-", 2);
                String[] array1 = array[1].split(" ", 2);
                String phone_number = array1[0];
                boolean has_found = false;
                for (User value : user) {
                    if (phone_number.equals(value.getNumber())) {
                        has_found = true;
                        break;
                    }
                }
                if (has_found) continue;
                User u = new User();
                u.setNumber(phone_number);
                if (array1[1].equals("0")) {
                    u.setChargeMode(new LandlinePhoneCharging());
                } else if (array1[1].equals("1")) {
                    u.setChargeMode(new MobilePhoneCharging());
                }else if (array1[1].equals("3")) {
                    u.setChargeMode(new SendMessageCharging());
                }
                user.add(u);

            }else if (str.matches(message)){
                String[] array = str.split("-", 2);
                String[] array1 = array[1].split(" ",3);
                String phone_number = array1[0];
                String phone_number1 = array1[1];
                String Message = array1[2];
                MessageRecord messageRecord = new MessageRecord();
                messageRecord.setMessage(Message);
                for (int i = 0; i < user.size(); i++)
                {
                    if (phone_number.equals(user.get(i).getNumber()))
                    {
                        user.get(i).userRecords.addSentMessageRecords(messageRecord);
                    }
                }
            }
        }
        user.sort((user1,user2)->user1.getNumber().compareTo(user2.getNumber()));
        for (int i = 0; i < user.size(); i++) {
            System.out.print(user.get(i).getNumber() + " ");
            Print(user.get(i).calCost());
            System.out.print(" ");
            Print(user.get(i).calBalance());
            System.out.println();
        }

    }
}
abstract class CallChargeRule extends ChargeRule{
}class CallRecord extends CommunicationRecord{
    Date startTime;
    Date endTime;
    String callingAddressAreaCode;
    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 {
    ArrayList<ChargeRule> ChargeRules=new ArrayList<>();
    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 {
    public abstract double calCost(ArrayList<CallRecord> callRecords);
    public abstract double calCost1(ArrayList<MessageRecord> messageRecords);
}
abstract class CommunicationRecord {
    protected String callingNumber;
    protected String answerNumber;

    public String getCallingNumber(){
        return callingNumber;
    }
    public void setCallingNumber(String callingNumber){
        this.callingNumber=callingNumber;
    }
    public String getAnswerNumber(){
        return answerNumber;
    }
    public void setAnswerNumber(String answerNumber){
        this.answerNumber=answerNumber;
    }
}
class LandlinePhoneCharging extends ChargeMode{
    double monthlyRent=20;
    public LandlinePhoneCharging(){
        ChargeRules.add(new LandPhoneInCityRule());
        ChargeRules.add(new LandPhoneInProvinceRule());
        ChargeRules.add(new LandPhoneInLandRule());
    }
    @Override
    public double calCost(UserRecords userRecords){//三种收费方式加起来的钱
        double sum_cost=0;
        sum_cost += ChargeRules.get(0).calCost(userRecords.callingInCityRecords);
        sum_cost += ChargeRules.get(1).calCost(userRecords.callingInProvinceRecords);
        sum_cost += ChargeRules.get(2).calCost(userRecords.callingInLandRecords);
        return sum_cost;
    }
    @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++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        return Math.ceil(sum)*0.1;
    }

    @Override
    public double calCost1(ArrayList<MessageRecord> messageRecords) {
        return 0;
    }
}class LandPhoneInLandRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        return Math.ceil(sum)*0.6;
    } @Override
    public double calCost1(ArrayList<MessageRecord> messageRecords) {
        return 0;
    }
}
class LandPhoneInProvinceRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        //System.out.println(Math.ceil(sum)*0.3);
        return sum*0.3;
    } @Override
    public double calCost1(ArrayList<MessageRecord> messageRecords) {
        return 0;
    }
} abstract class MessageChargeRule extends ChargeRule{
} class MessageRecord extends CommunicationRecord{
    String message;
    public String getMessage(){
        return message;
    }
    public void setMessage(String message){
        this.message=message;
    };
}
 class MobilePhoneCharging extends ChargeMode{
    double monthlyRent=15;
    public MobilePhoneCharging(){
        ChargeRules.add(new MobilePhoneInCityRule());
        ChargeRules.add(new MobilePhoneInProvinceRule());
        ChargeRules.add(new MobilePhoneInLandRule());
        ChargeRules.add(new MobilePhoneInProvinceRoamingDials());
        ChargeRules.add(new MobilePhoneInLandRoamingAnswering());
        ChargeRules.add(new MobilePhoneInLandRoamingDials());
    }
    @Override
    public double calCost(UserRecords userRecords) {
        double sum_cost=0;
        sum_cost += ChargeRules.get(0).calCost(userRecords.callingInCityRecords);
        sum_cost += ChargeRules.get(1).calCost(userRecords.callingInProvinceRecords);
        sum_cost += ChargeRules.get(2).calCost(userRecords.callingInLandRecords);
        sum_cost += ChargeRules.get(3).calCost(userRecords.callingInProvinceRoamingDialRecords);
        sum_cost += ChargeRules.get(4).calCost(userRecords.callingInLandRoamingAnswerRecords);
        sum_cost += ChargeRules.get(5).calCost(userRecords.callingInLandRoamingDialRecords);
        return sum_cost;
    }

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

    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }

        return Math.ceil(sum)*0.1;
    } @Override
    public double calCost1(ArrayList<MessageRecord> messageRecords) {
        return 0;
    }
}
class MobilePhoneInLandRoamingAnswering extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        return Math.ceil(sum)*0.3;
    } @Override
    public double calCost1(ArrayList<MessageRecord> messageRecords) {
        return 0;
    }
}
class MobilePhoneInLandRoamingDials extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        return Math.ceil(sum)*0.6;
    } @Override
    public double calCost1(ArrayList<MessageRecord> messageRecords) {
        return 0;
    }
}
 class MobilePhoneInLandRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        return Math.ceil(sum)*0.3;
    } @Override
    public double calCost1(ArrayList<MessageRecord> messageRecords) {
        return 0;
    }
}
 class MobilePhoneInProvinceRoamingDials extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        return Math.ceil(sum)*0.3;
    } @Override
    public double calCost1(ArrayList<MessageRecord> messageRecords) {
        return 0;
    }
}
class MobilePhoneInProvinceRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        double sum=0;
        for (int i=0;i<callRecords.size();i++) {
            sum+=((callRecords.get(i).endTime.getTime() - callRecords.get(i).startTime.getTime()) / 1000.0) / 60;
            sum=Math.ceil(sum);
        }
        return Math.ceil(sum)*0.2;
    } @Override
    public double calCost1(ArrayList<MessageRecord> messageRecords) {
        return 0;
    }
}
class SendMessageCharging extends ChargeMode{
    public SendMessageCharging() {
        ChargeRules.add(new SendMessageRule());
    }
    @Override
    public double calCost(UserRecords userRecords) {
        double sum_cost=0;
        sum_cost += ChargeRules.get(0).calCost1(userRecords.sendMessageRecords);
        return sum_cost;
    }
    @Override
    public double getMonthlyRent() {
        return 0;
    }
}
class SendMessageRule extends MessageChargeRule{

    @Override
    public double calCost(ArrayList<CallRecord> callRecords) {
        return 0;
    }

    @Override
    public double calCost1(ArrayList<MessageRecord> messageRecords) {
        int messageNumber=0;
        for(int i=0;i<messageRecords.size();i++)
            messageNumber+=Math.ceil(messageRecords.get(i).getMessage().length()/10.0);
        if(messageNumber<=3)
        {
            return messageNumber*0.1;
        } else if (messageNumber<=5) {
            return 0.3+(messageNumber-3)*0.2;
        }else {
            return 0.3+2*0.2+(messageNumber-5)*0.3;
        }
    }
}
class User {
    UserRecords userRecords=new UserRecords();
    private final double balance=100;
    private ChargeMode chargeMode;
    private String number;
    public double calBalance(){
        return this.balance-this.calCost()-chargeMode.getMonthlyRent();
    }
    public double calCost(){
        return chargeMode.calCost(userRecords);
    }
    public UserRecords getUserRecords(){
        return this.userRecords;
    }
    public void setUserRecord(UserRecords userRecords){
        this.userRecords=userRecords;
    }
    public ChargeMode getChargeMode(){
        return chargeMode;
    }
    public double getBalance(){
        return this.balance;
    }
    public void setChargeMode(ChargeMode chargeMode){
        this.chargeMode=chargeMode;
    }
    public String getNumber(){
        return this.number;
    }
    public void setNumber(String number){
        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> answerInCityRecords=new ArrayList<CallRecord>();
    ArrayList<CallRecord> answerInProvinceRecords=new ArrayList<CallRecord>();
    ArrayList<CallRecord> answerInLandRecords=new ArrayList<CallRecord>();
    ArrayList<MessageRecord> sendMessageRecords=new ArrayList<MessageRecord>();
    ArrayList<MessageRecord> receiveMessageRecords=new ArrayList<MessageRecord>();
    ArrayList<CallRecord> callingInProvinceRoamingDialRecords=new ArrayList<CallRecord>();//省内漫游拨打记录
    ArrayList<CallRecord> callingInLandRoamingAnswerRecords=new ArrayList<CallRecord>();//省外漫游接听记录
    ArrayList<CallRecord> callingInLandRoamingDialRecords=new ArrayList<CallRecord>();//省外漫游拨打记录
    public void addCallingInLandRoamingDialRecords(CallRecord callRecord){
        callingInLandRoamingDialRecords.add(callRecord);
    }
    public void addCallingInLandRoamingAnswerRecords(CallRecord callRecord){
        callingInLandRoamingAnswerRecords.add(callRecord);
    }
    public void addCallingInProvinceRoamingDialRecords(CallRecord callRecord){
        callingInProvinceRoamingDialRecords.add(callRecord);
    }
    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 addSentMessageRecords(MessageRecord MessageRecords){
        sendMessageRecords.add(MessageRecords);
    }
    public void addReceiveMessageRecords(MessageRecord receiveMessageRecords){}

    public ArrayList<MessageRecord> getSendMessageRecords(){return sendMessageRecords;}
    public ArrayList<MessageRecord> getReceiveMessageRecords(){return receiveMessageRecords;}
    public ArrayList<CallRecord> getCallingInCityRecords(){return callingInCityRecords;}
    public ArrayList<CallRecord> getCallingInProvinceRecords(){return callingInProvinceRecords;}
    public ArrayList<CallRecord> getCallingInLandRecords(){return callingInLandRecords;}
    public ArrayList<CallRecord> getAnswerInCityRecords(){return answerInCityRecords;}
    public ArrayList<CallRecord> getAnswerInProvinceRecords(){return answerInProvinceRecords;}
    public ArrayList<CallRecord> getAnswerInLandRecords(){return answerInLandRecords;}
}

类图：

代码质量：

449行
报表 342
分支报表百分比 7.6
方法调用语句 109
带注释的百分比行 1.8
类和接口 23
每个类的方法 3.26
每个方法的平均语句数 2.40
最复杂方法的行号 17
最复杂方法的名称 main.main（）
最大复杂度 14
最深块线号 32
最大块深度 6
平均区块深度 1.70
平均复杂度 1.35

三，采坑心得

这三次作业里面好像也没有特别阴间的地方，只需要按照类图来写就可以

在我第二次电信计费的时候有一个点一直过不去，

就是这里，这里是省内漫游的一个点，主要是我对省内漫游理解错了，省内漫游就是省内打拨号者打给任意的地方即为省内漫游，而我一来的是省内对省内的理解为漫游，所以这个点一直过不去。后面发现错误改正过来了。

然后就是第三次作业，写完代码之后有几个点一直过不去，起初以为是在正则表达式没有判断全面

但是后来发现是自己算错了，好离谱，计算超过5条的，没有减去之前5条以内的，后面改正过来了。

四，改进建议

我觉得最需要改进的地方是这里

采用大量正则表达式区分每一种情况，然后就是区分完每一种情况之后呢，又发现每一种情况判断在省内省外有相同之处，所以说还是采用一步到位的正则表达式比较好

这些步骤真的有好多重复的地方，可以写到一个方法里面

五，总结

经过了一个一个学期的学习，Java的学习到这里也就结束了，最后三次大作业让我编写类的思维更加清晰，更懂得如何把类直接连在一起

在学习Java的过程中我得出这样的结论：
1. 学习中，要养成良好的习惯（写括号时要成对，字母大小写要区分，单词拼写要准确）。
2． 在学习的过程中，最好不是仅仅停留在java表层，不是抄书上的例子运行出结果就可以。要注意，即便对一个简单的例子也要有耐心去琢磨、调试、改动。
3． 在学习的过程中一定要动手做、试着写代码，而不是抱着老师的讲义看看就行。很多东西和体会必须自己动手才能真正属于自己。
4. 课程收获。学习Java这一学期以来，最大的感受是痛苦并快乐着(以后可能更痛苦。。)，痛苦是写不出来啊！狂抓也没用的那种！快乐是代码这种东西写出来运行一下，结果正确，那种成就感真的没法表达，还有一个意想不到收获就是CSDN，自己敲出来的代码有那么多的阅读量，真的很开心（虽然是照着老师的讲义敲的）
5. 在 Java 的学习过程中，可能会遇到形形色色的问题不容易解决，应多去专业论坛了解相关的知识，书本上的知识有限。要会从网上搜索有用的信息 加以整理，促进学习的深入和知识水平的提高。
看了好多网上课程，说学到一定程度要尝试着自己做东西，但觉得自己仅仅经过一学期的学习，还远远不够，希望自己在以后学习中继续努力，能够真真正正拥有一门编程语言，对自己今后的发展起到作用。在学习java语言的同时，也让我学会了如何来发现问题，如何解决问题，怎样有效的学习等等，相信会对我一生都有帮助。