PTA第6、7、8次作业的总结

前言
这三次pta作业主要考查了电信计费系列的问题，从一开始的座机计费，再到座机计费与手机计费结合，最后到短信计费。其中座机计费与手机计费是难度最大的一次题目，因为它综合考虑的因素最多，需要花一定的时间才能解决，而且这题与座机计费的那题联系紧密，环环相扣。至于其它的题目，像C~K的班级，按照题目修改程序，商品内部类购物券，动物发声模拟器这几道题目都不是难度非常大的题目，只要我们认真审题，同时掌握上课老师讲的内容，基本上可以解决。详情见下面的设计与分析。
设计与分析

7-1 电信计费系列1-座机计费

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

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

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

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

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

                                图1

图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 callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。

LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是
座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。
（提示：可以从UserRecords类中获取各种类型的callRecords）。
后续扩展说明：
后续题目集将增加手机用户，手机用户的计费方式中除了与座机计费类似的主叫通话费之外，还包含市外接听电话的漫游费以及发短信的费用。在本题的设计时可统一考虑。
通话记录中，手机需要额外记录拨打/接听的地点的区号，比如：
座机打手机：t-主叫号码接听号码接听地点区号起始时间结束时间
t-079186330022 13305862264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
手机互打：t-主叫号码拨号地点接听号码接听地点区号起始时间结束时间
t-18907910010 0791 13305862264 0371 2022.1.3 10:00:25 2022.1.3 10:05:11
短信的格式：m-主叫号码，接收号码，短信内容
m-18907910010 13305862264 welcome to jiangxi
m-13305862264 18907910010 thank you

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

u-079186300001 0
t-079186300001 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:25
end
输出样例:
在这里给出相应的输出。例如：

079186300001 3.0 77.0
其余参考样例详见附件，未尽事宜以附件样例为准：
https://images.ptausercontent.com/d3c5de10-9e3f-4a4c-877f-64e76c98f1b6.pdf

代码长度限制
40 KB
时间限制
400 ms
内存限制
64 MB

本题的难度较大，一开始会完全不知道该如何动手，关键代码如下：

点击查看代码

public static boolean judgeRegister(String str){
        boolean flag2 = str.matches("u-0791[0-9]{7,8} 0");
        if(flag2){
            return true;
        }
        else
            return false;
    }
    public static boolean judgeProcess(String str){
        boolean flag2 = str.matches("t-0791[0-9]{7,8} [0-9]{11,12} [0-9]{4}.[0-9]{1,2}.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2} [0-9]{4}.[0-9]{1,2}.[0-9]{1,2} [0-9]{1,2}:[0-9]{1,2}:[0-9]{1,2}");

        if(flag2){
            return true;
        }
        else
            return false;
    }

7-1 电信计费系列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 callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。
SendMessageRule是发送短信的计费规则类，用于计算发送短信的费用。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。
（提示：可以从UserRecords类中获取各种类型的callRecords）。
注意：以上图中所定义的类不是限定要求，根据实际需要自行补充或修改。

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

u-13811111111 1
t-13811111111 0791 13811111110 020 2022.1.3 08:00:00 2022.1.3 08:09:20
end
输出样例:
在这里给出相应的输出。例如：

13811111111 3.0 82.0
更多内容详见附件：

https://images.ptausercontent.com/825588d3-6c7b-420b-abab-13e36b4c828c.pdf

代码长度限制
40 KB
时间限制
400 ms
内存限制
64 MB

本次作业是上一题作业的难度升级版，需要我们更加仔细认真地去做。部分代码如下：

点击查看代码

    public static int Area(String s1,String[] s) {
        int a = 0;
        int b= Integer.parseInt(s1.substring(1, 4));//获取区号后三位
        int c= Integer.parseInt(s[1].substring(1, 4));//获取区号后三位
        if((b>=790&&b<=799||b==701)&&(c>=790&&c<=799||c==701)) {
            if(b==791&&c==791) {
                a=1;//市内
            }
            else
                a=2;//省内
        }
        else
            a=3;//省外
        return a;
    }


    //根据号码找到对应的用户
    public static int getUser(String str) {
        int n = 0;
        for(int i = 0;i<m;i++) {
            if(str.equals(user[i].number)) {
                n=i;
            }
        }
        return n;
    }

    //计算通话时长
    public static int getCallDuration(String s1,String s2) {
        String a[] = s1.split(":");
        String b[] = s2.split(":");
        int sum = 0;
        int hour = 0;
        int minute = 0;
        int miao = 0;
        hour = Integer.parseInt(a[0])-Integer.parseInt(b[0]);

        minute =  Integer.parseInt(b[1]) - Integer.parseInt(a[1]);
        if(Integer.parseInt(b[2]) - Integer.parseInt(a[2])>0) {
            miao = 1;
        }
        else
            miao = 0;
        sum = 60*hour+minute+miao;
        return sum;
    }

有个需要注意的问题是：写在静态类里面的方法也应该是静态的。 * 7-2 sdut-Collection-sort--C~K的班级（II）分数 10 作者周雪芹单位山东理工大学经过不懈的努力，C~K终于当上了班主任。

现在他要统计班里学生的名单，但是C~K在教务系统中导出班级名单时出了问题，发现会有同学的信息重复，现在他想把重复的同学信息删掉，只保留一个，
但是工作量太大了，所以找到了会编程的你，你能帮他解决这个问题吗？

输入格式:
第一行输入一个N，代表C~K导出的名单共有N行（N<100000）.

接下来的N行，每一行包括一个同学的信息，学号姓名年龄性别。

输出格式:
第一行输出一个n，代表删除重复名字后C~K的班级共有几人。

接下来的n行，输出每一个同学的信息，输出按照学号从小到大的顺序。

输入样例:
6
0001 MeiK 20 M
0001 MeiK 20 M
0002 sdk2 21 M
0002 sdk2 21 M
0002 sdk2 21 M
0000 blf2 22 F
输出样例:
3
0000 blf2 22 F
0001 MeiK 20 M
0002 sdk2 21 M
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
`import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.Objects;

public class Main {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
List list = new ArrayList();
int n = in.nextInt();
for (int i = 0;i < n;i++){
Student student = new Student(in.next(),in.next(),in.nextInt(),in.next().charAt(0));
if (!list.contains(student))
list.add(student);
}
Collections.sort(list);
System.out.println(list.size());
for (int j = 0;j < list.size();j++)
System.out.println(list.get(j));
in.close();
}
}

class Student implements Comparable{
String sno;//学号
String name;//姓名
int age;//年龄
char sex;//性别

public Student() {
}

public Student(String sno, String name, int age, char sex) {
    super();
    this.sno = sno;
    this.name = name;
    this.age = age;
    this.sex = sex;
}

public String getSno() {
    return sno;
}

public void setSno(String sno) {
    this.sno = sno;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

public char getSex() {
    return sex;
}

public void setSex(char sex) {
    this.sex = sex;
}

@Override
public boolean equals(Object o) {
    if (this == o)
        return true;
    if (o == null || getClass() != o.getClass())
        return false;
    Student student = (Student) o;
    if (age != student.age)
        return false;
    if (sno == null){
        if (student.sno != null)
            return false;
    }else if (!sno.equals(student.sno))
        return false;
    if (name == null){
        if (student.name != null)
            return false;
    }else if (!name.equals(student.name))
        return false;
    if (sex != student.sex)
        return false;
    return true;
    //return age == student.age && sex == student.sex && Objects.equals(sno, student.sno) && Objects.equals(name, student.name);
}

@Override
public int compareTo(Student s){
    return this.sno.compareTo(s.sno);
}

@Override
public int hashCode() {
    return Objects.hash(sno, name, age, sex);
}

@Override
public String toString() {
    return sno + " " + name + " " + age + " " +sex;
}

}`
本需要我们注意的地方是class Student implements Comparable的应用

7-1 电信计费系列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

图2

图2中CommunicationRecord是抽象的通讯记录类：

包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。

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

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

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

u-18907910010 3
m-18907910010 13305862264 aaaaaaaaaaaaaaaaaaaaaaa
end
输出样例:
在这里给出相应的输出。例如：

18907910010 0.3 99.7

输入样例1:

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

u-18907910010 3
m-18907910010 13305862264 aaaaaaaaaaaa
m-18907910010 13305862264 aaaaaaa.
m-18907910010 13305862264 bb,bbbb
end
输出样例1:
在这里给出相应的输出。例如：

18907910010 0.5 99.5
代码长度限制
20 KB
时间限制
400 ms
内存限制
64 MB

本题的难度相对前两道电信计费系列的题目，难度有所降低。
`import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
public static ArrayList userArrayList = new ArrayList();
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (true){
String user_information = in.nextLine();//用户开户信息
if (!"end".equals(user_information)){
if (user_information.matches("[u]-1[0-9]{10}\s[3]")){
String[] s1 = user_information.split(" ");
User user = new User(s1[0].substring(2,s1[0].length()));
userArrayList.add(user);
}else if (user_information.matches("[m]-1[0-9]{10}\s"+"1[0-9]{10}\s"+"[a-zA-Z-z0-9-,\.\ ]+$")){
String[] s2 = user_information.split(" ",3);
userArrayList.get(getUser(s2[0].substring(2,s2[0].length()))).sendMessageRecord.add(s2[2]);
}
}
else break;
}
Collections.sort(userArrayList, new Comparator() {
@Override
public int compare(User o1, User o2) {
return o1.getPhone_number().compareTo(o2.getPhone_number());
}
});

    for (int j = 0;j < userArrayList.size();j++)
        System.out.println(userArrayList.get(j).getPhone_number()+" "+String.format("%.1f",userArrayList.get(j).calCost())+" "+String.format("%.1f",userArrayList.get(j).getSurplus_balance()));
}

public static int getUser(String str){
    //根据手机号码找到对应的用户
    int n = 0;
    for (int i = 0;i < userArrayList.size();i++){
        if (str.equals(userArrayList.get(i).getPhone_number()))
            n = i;
    }
    return n;
}

}

class User{
private final double balance = 100;//余额
private String phone_number;//手机号码
private double surplus_balance;//剩余余额
private double cost = 0;//花费的话费
ArrayList sendMessageRecord = new ArrayList();

public double getBalance() {
    return balance;
}

public String getPhone_number() {
    return this.phone_number;
}

public void setPhone_number(String phone_number) {
    this.phone_number = phone_number;
}

public double getSurplus_balance() {
    this.surplus_balance = this.balance - this.cost;//剩余余额等于初始余额减去花费的话费
    return this.surplus_balance;
}

public void setSurplus_balance(double surplus_balance) {
    this.surplus_balance = surplus_balance;
}

public double getCost() {
    return cost;
}

public void setCost(double cost) {
    this.cost = cost;
}

public ArrayList<String> getSendMessageRecord() {
    return sendMessageRecord;
}

public void setSendMessageRecord(ArrayList<String> sendMessageRecord) {
    this.sendMessageRecord = sendMessageRecord;
}

public User() {
}

public User(String phone_number) {
    super();
    this.phone_number = phone_number;
}

public int message_count(String str){
    //计算发送一次短信算的短信条数
    int count = 0;//短信条数
    if (str.length() % 10 == 0)
        count = str.length() / 10;
    else count = str.length() / 10 + 1;
    return count;
}

public double calCost(){
    //计算花费的话费
    int count = 0;//短信条数
    for (int i = 0;i < sendMessageRecord.size();i++){
        if (message_count(sendMessageRecord.get(i))+count <= 3){
            this.cost += 0.1*message_count(sendMessageRecord.get(i));
            count += message_count(sendMessageRecord.get(i));
        }else if (message_count(sendMessageRecord.get(i))+count > 3 && message_count(sendMessageRecord.get(i))+count <= 5){
            if (count == 0)
                this.cost += 0.1*3 + (message_count(sendMessageRecord.get(i))-3)*0.2;
            else if (count == 1)
                this.cost += 0.1*2 + (message_count(sendMessageRecord.get(i))-2)*0.2;
            else if (count == 2)
                this.cost += 0.1*1 + (message_count(sendMessageRecord.get(i))-1)*0.2;
            else if (count >= 3)
                this.cost += message_count(sendMessageRecord.get(i))*0.2;
            count += message_count(sendMessageRecord.get(i));
        }else if (message_count(sendMessageRecord.get(i))+count > 5){
            if (count <= 3)
                this.cost += (3-count)*0.1+2*0.2+(message_count(sendMessageRecord.get(i))-5+count)*0.3;
            else if (count == 4)
                this.cost += 0.2+(message_count(sendMessageRecord.get(i))-1)*0.3;
            else this.cost += message_count(sendMessageRecord.get(i))*0.3;
            count += message_count(sendMessageRecord.get(i));
        }
    }
    return this.cost;
}

}`
本题可以不按照题目给的类图来写代码，可以简化代码。

7-2 编写一个类Shop（商店）、内部类InnerCoupons（内部购物券）
分数 30
作者吴光生
单位新余学院
编写一个类Shop（商店），该类中有一个成员内部类InnerCoupons（内部购物券），可以用于购买该商店的牛奶（假设每箱牛奶售价为50元）。要求如下：
（1）Shop类中有私有属性milkCount（牛奶的箱数，int类型）、公有的成员方法setMilkCount( )和getMilkCount( )分别用于设置和获取牛奶的箱数。
（2）成员内部类InnerCoupons，有公有属性value（面值，int类型），一个带参数的构造方法可以设定购物券的面值value，一个公有的成员方法buy( )要求输出使用了面值为多少的购物券进行支付，同时使商店牛奶的箱数减少value/50。
（3）Shop类中还有成员变量coupons50（面值为50元的内部购物券，类型为InnerCoupons）、coupons100（面值为100元的内部购物券，类型为InnerCoupons）。
（4）在Shop类的构造方法中，调用内部类InnerCoupons的带参数的构造方法分别创建上面的购物券coupons50、coupons100。

在测试类Main中，创建一个Shop类的对象myshop，从键盘输入一个整数（大于或等于3），将其设置为牛奶的箱数。假定有顾客分别使用了该商店面值为50的购物券、面值为100的购物券各消费一次，分别输出消费后商店剩下的牛奶箱数。

输入格式:
输入一个大于或等于3的整数。

输出格式:
使用了面值为50的购物券进行支付
牛奶还剩XX箱
使用了面值为100的购物券进行支付
牛奶还剩XX箱

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

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

使用了面值为50的购物券进行支付
牛奶还剩4箱
使用了面值为100的购物券进行支付
牛奶还剩2箱
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

本题主要考查了Java内部类，一开始我也没有很懂这方面的内容，如何通过看教学视频才有了更深的体会，了解到了各种内部类，比如说局部内部类，匿名内部类等等，这是Java学习的一大重要知识。代码如下：
`import java.util.Scanner;

public class Main {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
Shop myshop = new Shop();
int milkCount = in.nextInt();//牛奶箱数
myshop.setMilkCount(milkCount);
if (milkCount < 3)
System.out.println("牛奶箱数应大于等于3，请重新输入");
else {
Shop.InnerCoupons coupons50 = myshop.new InnerCoupons(50);
Shop.InnerCoupons coupons100 = myshop.new InnerCoupons(100);
coupons50.buy();
coupons100.buy();
}
}
}

class Shop{
private int milkCount;//牛奶箱数
//InnerCoupons coupons50;
//InnerCoupons coupons100;
Shop.InnerCoupons coupons50 = new Shop.InnerCoupons(50);//面值为50元的内部购物券
Shop.InnerCoupons coupons100 = new Shop.InnerCoupons(100);//面值为100元的内部购物券

public Shop() {
}

public Shop(int milkCount, InnerCoupons coupons50, InnerCoupons coupons100) {
    super();
    this.milkCount = milkCount;
    this.coupons50 = coupons50;
    this.coupons100 = coupons100;
}

public int getMilkCount() {
    return milkCount;
}

public void setMilkCount(int milkCount) {
    this.milkCount = milkCount;
}


class InnerCoupons{
    public int value;//面值

    public InnerCoupons(int value) {
        this.value = value;
    }


    public void buy(){
        System.out.println("使用了面值为" + value + "的购物券进行支付");
        milkCount -= value/50;
        System.out.println("牛奶还剩" + milkCount + "箱");
    }
}

}
`

7-3 动物发声模拟器（多态）
分数 20
作者刘凤良
单位天津仁爱学院
设计一个动物发生模拟器，用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()、动物叫shout()；
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat，用getAnimalClass()方法返回不同的动物类别（比如猫，狗，山羊），用shout()方法分别输出不同的叫声（比如喵喵、汪汪、咩咩）。
最后编写AnimalShoutTest类测试，输出：
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩

其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声。

请在下面的【】处添加代码。

//动物发生模拟器. 请在下面的【】处添加代码。
public class AnimalShoutTest2 {
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
Goat goat = new Goat();
speak(cat);
speak(dog);
speak(goat);
}
//定义静态方法speak()
【】

}

//定义抽象类Animal
【】class Animal{
【】
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat 【】{
【】
【】
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog 【】{
【】
【】
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat 【】{
【】
【】
}
输入样例:

输出样例:
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

本题难度相对简单，主要考察了多态的使用，多态是一个很基本也很重要的知识点。代码如下：

点击查看代码

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Dog dog = new Dog();
        Goat goat = new Goat();
        speak(cat);
        speak(dog);
        speak(goat);
    }
    //定义静态方法speak()
    public static void speak(Animal animal){
        animal.getAnimalClass();
        animal.shout();
    }
}

//定义抽象类Animal
abstract class Animal{
    public abstract void getAnimalClass();
    public abstract void shout();
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal{
    public void getAnimalClass(){
        System.out.print("猫的叫声：");
    }
    public void shout(){
        System.out.println("喵喵");
    }
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal{
    public void getAnimalClass(){
        System.out.print("狗的叫声：");
    }
    public void shout(){
        System.out.println("汪汪");
    }
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal{
    public void getAnimalClass(){
        System.out.print("山羊的叫声：");
    }
    public void shout(){
        System.out.println("咩咩");
    }
}

踩坑心得
通过这几次的PTA作业，我发现正则表达式出现的频率非常之高，所以如果对正则表达式的掌握还不够熟悉和熟练的同学需要再去补一补这方面的知识。
然后就是关于排序问题，我们需要掌握Java的一些类，来帮助我们排序，比如说：sort（）方法和Comparable接口。
除此之外我们还需要熟练掌握我们所用ide的一些快捷方式，不管是eclipse还是idea，可以大大节省我们写代码的时间。
改进建议
对于电信计费系列问题，这是一个非常经典且有代表性的问题，如果我们当时没有做出来，在后面我们也应该再去搞懂。
总结
Java中几个非常重要的知识都在这几次作业中有所体现，像封装，继承，多态，内部类，接口，这些都是Java的重中之重，我们复习的时候也应该着重复习这些知识，此外，正则表达式的掌握也是必须的，我们也应该充分利用各种工具来提高我们完成作业的效率，像用来画类图的powerdesigner等。

posted @ 2022-06-09 13:33 L2B3J 阅读(329) 评论(0) 收藏举报

刷新页面返回顶部

PTA第6、7、8次作业的总结

输入样例1:

公告