2022年下学期面向对象程序设计学习总结（三）
一、前言
(1)部分学习总结：
①正则表达式：
- “^……$"：
^是正则表达式匹配字符串开始位置
$是正则表达式匹配字符串结束位置
- 用正则表达式简化代码，例如用
匹配具体时间，其中包括了年份的平年和闰年的判断，月份、日期合法性的判断、时间合法性的判断以及整体字符格式的判断。"((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.(((0?[13578]|1[02])\\.(0?" + "[1-9]|[12][0-9]|3[01]))|(([469]|11)\\.([1-9]|[12][0-9]|30))|(2\\.([1-9]|[1][0-9]|2[0-8]))))|(((" + "[0-9]{2})([48]|[2468][048]|[13579][26])|(([48]|[2468][048]|[3579][26])00))\\.2\\.29))" + "\\s([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])"
②排序问题：
- Collections.sort()的使用
在日常开发中，很多时候都需要对一些数据进行排序的操作。然而那些数据一般都是放在一个集合中如：Map ，Set ，List 等集合中。他们都提共了一个排序方法 sort()，要对数据排序直接使用这个方法就行，但是要保证集合中的对象是可比较的。为使一个对象可比较，该对象需要实现 Comparable<T> 接口，然后重写里面的compareTo()方法。假设我们有一个学生类，默认需要按学生的年龄字段 age 进行排序 代码如下：
示例如下
public class Student implements Comparable<Student> {
private int id;
private int age;
private String name;
public Student(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
@Override
public int compareTo(Student o) {
//降序
//return o.age - this.age;
//升序
return this.age - o.age;
}
……
……
……
}-
比较器Comparator的使用
Collections.sort(list,Comparator<T>）;
list.sort(Comparator<T>);
示例如下
//自定义排序1
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getId() - o2.getId();
}
});
-
比较器衍生
usersMobile.sort(Comparator.comparing(User::getNumber));
ArraylistName.sort(Comparator.comparing([比较对象类型]::[比较对象属性]));;
根据ArrayList 中储存对象的某一个属性进行从小到大的排序。
③对于数字的处理
Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作。
BigDecimal所创建的是对象，故我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。
示例如下
public static String round(double val) {
BigDecimal bigDecimal = new BigDecimal(val);
bigDecimal = bigDecimal.setScale(3, BigDecimal.ROUND_HALF_UP);
bigDecimal = bigDecimal.stripTrailingZeros();
String ret = bigDecimal.toPlainString();
if (!ret.contains(".")) {
ret += ".O";
}
return ret;
}④时间的处理：
Date startTime;
Date endTime;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
startTime = sdf.parse(records[2] + " " + records[3]);
endTime = sdf.parse(records[4] + " " + records[5]);SimpleDateFormat：相当于一种限定格式的数据转换
使用format()方法将日期转换为字符串
使用parse()方法将字符串转换为日期
注意：如果字符串与指定的格式不匹配，会报java.text.ParseException异常。
| 格式 | 释义 | 举例 |
|---|---|---|
| yyyy | 年 | 2019 |
| MM | 月 | 02 |
| dd | 日 | 18 |
| HH | 小时(24小时制) | 13，下午一点 |
| mm | 分钟 | 53 |
| ss | 秒 | 42 |
| SSS | 毫秒 | 629 |
(2)题量与难度：
| 题量 | 难度 | |
| 212019班-题目集09 | 2 | *** |
| 212019班-题目集10 | 3 | **** |
| 212019班-题目集11 | 3 | *** |
二、设计与分析
(1)电信计费问题——座机：
踩坑心得：
1.通话时间存在交集问题：（PS 这本是题设中要求忽略的一个问题）
public boolean checkIntersection(CallRecord record, ArrayList<CallRecord> records){
for (CallRecord rd:records){
if (ifHasIntersection(record.getStartTime(),record.getEndTime(),rd.getStartTime(),rd.getEndTime())) {
return true;
}
}
return false;
}
public boolean ifHasIntersection(Date beginDate1, Date endDate1, Date beginDate2, Date endDate2) {
long begin1 = beginDate1.getTime();
long end1 = endDate1.getTime();
long begin2 = beginDate2.getTime();
long end2 = endDate2.getTime();
return Math.max(begin1, begin2) < Math.min(end1, end2);
}2.对于时间的输入之后一定要对时间进行格式验证
其中包括年份、月份、日期、小时、分钟、秒钟、星期等。
小时、分钟、秒钟要注意数值上限。
3.对于str.substring(begin[,end]);在用之前要先看str的长度和切割位置的关系，判断数组是否会存在越界情况。
4.注意题设的逻辑。题目可能存在一些常识性的漏洞要判断是否这些漏洞有需要规避。
例如：
①区号不仅有4位的也有3位的———010北京。
②对于号码自己打给自己也是允许的。
③在电话还没有普及时候电话记录依然存在。
设计思路：
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元。
每条通讯信息单独计费后累加，不是将所有时间累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
2.输入格式：
①逐行输入南昌市用户开户的信息，每行一个用户，
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐）
例如：u-079186300001 0
座机号码除区号外由是7-8位数字组成。
本题只考虑计费类型0-座机计费，电信系列2、3题会逐步增加计费类型。
②逐行输入本月某些用户的通讯信息，通讯信息格式：
座机呼叫座机：t-主叫号码 接听号码 起始时间 结束时间
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四项内容之间以一个英文空格分隔。
处理输入：
①用in.nextLine()接收一整行数据
②判断整行格式
（PS 不要分割后对标号u、t判断后进行格式判断，因为其中可能涉及str.substring()造成数组越界等问题。）
3.分流处理：分出开户和花费记录两个流向。
4.开户时需要注意是否是南昌市内号码，还需要注意是否已经开户，若确定是南昌市内号码并且未开过户则对该号码进行开户
5.花费记录时，首先需要判断主叫号码是否是记录在册的开户号码，若是则继续操作。因为主叫号码为座机，所以不用判断主叫号码拨出位置，只对接听号码进行分类（市内，省内，国内）。
6.计费：调取所有花费记录，对时间进行处理
public static double calculateTimeDifferenceBySimpleDateFormat(Date date1, Date date2) {
long startTime = date1.getTime();
long endTime = date2.getTime();
return (long) (int)Math.ceil((endTime - startTime) / 1000.0 / 60);
}然后再乘以单价并进行累加。
7.输出：
根据输入的详细通讯信息，计算所有已开户的用户的当月费用（精确到小数点后2位，单位元）。假设每个用户初始余额是100元。
每条通讯、短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
类图：
图1中User是用户类，包括属性：
userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。
ChargeMode是计费方式的抽象类：
chargeRules是计费方式所包含的各种计费规则的集合，ChargeRule类的定义见图3。
getMonthlyRent（）方法用于返回月租（monthlyRent）。
UserRecords是用户记录类，保存用户各种通话、短信的记录，
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是：
市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。
图2中CommunicationRecord是抽象的通讯记录类：
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。CallRecord（通话记录类）包含属性：
通话的起始、结束时间以及
拨号地点的区号（callingAddressAreaCode）、接听地点的区号（answerAddressAreaCode）。
区号用于记录在哪个地点拨打和接听的电话。座机无法移动，就是本机区号，如果是手机号，则会有差异。
图3是计费规则的相关类，这些类的核心方法是：
calCost（ArrayList<CallRecord> callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。
SendMessageRule是发送短信的计费规则类，用于计算发送短信的费用。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。 复杂度：
(2)电信计费问题——手机：
踩坑心得：
1.内部类中相似数据的处理要注意函数名别写错。
设计思路：
1.分析题目：假设南昌市电信分公司针对市内座机以及用户采用的计费方式：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途
拨打0.6元/分钟。不足一分钟按一分钟计。
假设本市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。
针对手机用户采用实时计费方式：
月租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-手机实时计费。
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
短信的格式：
m-主叫号码，接收号码，短信内容 发送时间
（短信内容只能由数字、字母、空格、英文逗号、英文句号组成）
m-18907910010 13305862264 welcome to jiangxi.
m-13305862264 18907910010 thank you.
注意：以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
输出：
根据输入的详细通讯信息，计算所有已开户的用户的当月费用（精确到小数点后2位，
单位元）。假设每个用户初始余额是100元。
每条通讯、短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
本题只做格式的错误判断，无需做内容上不合理的判断，比如同一个电话两条通讯记
录的时间有重合、开户号码非南昌市的号码等，此类情况都当成正确的输入计算。但时间
的输入必须符合要求，比如不能输入2022.13.61 28:72:65。
2.花费记录分为：
①手机打给手机
②手机打给座机
③座机打给手机
④座机打给座机
要对拨打发起和接收地进行判别，
①市内打给市内
②市内打给省内
③市内打给省外
④省内打给市内
⑤省内打给省内
⑥省内打给省外
⑦省外打给市内
⑧省外打给省内
⑨省外打给省外
因为情况增加，所以在UserRecords里面要适当增加ArrayList用于储存相应通话记录。
3.在计算花销时，要注意省外漫游接听为0.3元/分钟。
类图：
复杂度：
(3)电信计费问题——短信：
设计思路：
1.分析题目：
实现一个简单的电信计费程序，针对手机的短信采用如下计费方式：
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。
本题只考虑短信计费，不考虑通信费用以及月租费。
类图：
计费规则的相关类，这些类的核心方法是： calCost（ArrayList callRecords）。 该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。 输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。 SendMessageRule是发送短信的计费规则类，用于计算发送短信的费用。 LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。
代码如下：
import java.math.BigDecimal;
import java.text.ParseException;
import java.util.ArrayList;
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);
String row = in.nextLine();
ArrayList<User> usersMobile = new ArrayList<>();
String mobilePhone = "1\\d{10}";
String inputUMobile = "^u-(13|18)\\d{9} 3$";
String inputM = "^m-" + mobilePhone + "\\s" + mobilePhone + "\\s" + "[\\s.\\d\\w,]+$";
while (!row.equals("end")) {
if (row.matches(inputUMobile)) {
String[] newUser = row.substring(2).split("\\s");
int indexU = findIndex(usersMobile, newUser[0]);
if (indexU == -1) {
User user = new User(100, newUser[0], new MobilePhoneCharging());
usersMobile.add(user);
}
} else if (row.matches(inputM)) {
String[] message = row.substring(2).split("\\s",2);
int index = findIndex(usersMobile,message[0]);
if (index != -1) {
usersMobile.get(index).getUserRecords().addSendMessageRecords(new MessageRecord(row.substring(26)));
}
}
row = in.nextLine();
}
usersMobile.sort(Comparator.comparing(User::getNumber));
for (User user : usersMobile) {
System.out.println(user.getNumber() + " " + round(user.calCost()) + " " + round(user.calBalance()));
}
}
public static int findIndex(ArrayList<User> users, String newUser){
int index = -1;
for (int i = 0; i < users.size(); i++) {
if (newUser.equals(users.get(i).getNumber())) {
index = i;
break;
}
}
return index;
}
public static double calculateTimeDifferenceBySimpleDateFormat(Date date1, Date date2) {
long startTime = date1.getTime();
long endTime = date2.getTime();
return (long) (int)Math.ceil((endTime - startTime) / 1000.0 / 60);
}
public static String round(double val) {
BigDecimal bigDecimal = new BigDecimal(val);
bigDecimal = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP);
bigDecimal = bigDecimal.stripTrailingZeros();
String ret = bigDecimal.toPlainString();
if (!ret.contains(".")) {
ret += ".O";
}
return ret;
}
}
class User {
private UserRecords userRecords = new UserRecords();
private double balance;
private ChargeMode chargeMode;
private String number;
User() {}
User(double balance, String number, ChargeMode chargeMode) {
this.balance = balance;
this.number = number;
this.chargeMode = chargeMode;
}
public UserRecords getUserRecords() {
return userRecords;
}
public void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = 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 double calBalance() {
balance = balance - calCost();
return balance;
}
public double calCost() {
return chargeMode.calCost(userRecords);
}
}
abstract class ChargeMode {
private 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();
}
class UserRecords {
private ArrayList<CallRecord> callingInCityRecords = new ArrayList<CallRecord>();//市内打市内
private ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<CallRecord>();//市内打省内
private ArrayList<CallRecord> callingInLandRecords = new ArrayList<CallRecord>();//市内打省外
private ArrayList<CallRecord> answerInCityRecords = new ArrayList<CallRecord>();//
private ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();//省外漫游接听
private ArrayList<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();
private ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<MessageRecord>();
public void addCallingInCityRecords (CallRecord callRecord) {
// if (!checkIntersection(callRecord,callingInCityRecords)) {
callingInCityRecords.add(callRecord);
// }
}
public void addCallingInProvinceRecords (CallRecord callRecord) {
// if (!checkIntersection(callRecord,callingInProvinceRecords)) {
callingInProvinceRecords.add(callRecord);
// }
}
public void addCallingInLandRecords (CallRecord callRecord) {
// if (!checkIntersection(callRecord,callingInLandRecords)) {
callingInLandRecords.add(callRecord);
// }
}
public void addAnswerInCityRecords (CallRecord answerRecords) {
answerInCityRecords.add(answerRecords);
}
public void addAnswerInProvinceRecords(CallRecord answerRecords) {
answerInProvinceRecords.add(answerRecords);
}
public void addAnswerInLandRecords (CallRecord answerRecords) {
answerInLandRecords.add(answerRecords);
}
public void addSendMessageRecords (MessageRecord answerRecords) {
sendMessageRecords.add(answerRecords);
}
public void addReceiveMessageRecords (MessageRecord answerRecords) {
receiveMessageRecords.add(answerRecords);
}
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;
}
public ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
public ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
}
abstract class MessageRule extends ChargeRule{
public abstract double calCost(ArrayList<MessageRecord> messageRecords);
}
class CallRecord extends CommunicationRecord{
private Date startTime;
private Date endTime;
private String callingAddressAreaCode;
private String answerAddressAreaCode;
CallRecord() {}
CallRecord(Date startTime, Date endTime,String calling,String answer) {
this.answerAddressAreaCode = answer.substring(0,4);
this.callingAddressAreaCode = calling.substring(0,4);
this.startTime = startTime;
this.endTime = endTime;
callingNumber = calling;
answerNumber = answer;
}
public Date getStartTime() {
return startTime;
}
public void setStartTime(Date startTime) {
this.startTime = startTime;
}
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;
}
public Date getEndTime() {
return endTime;
}
}
abstract class ChargeRule {
abstract double calCost(ArrayList<MessageRecord> callRecords);
}
abstract class CommunicationRecord {
protected String callingNumber;
protected String answerNumber;
public String getAnswerNumber() {
return answerNumber;
}
public String getCallingNumber() {
return callingNumber;
}
public void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}
public void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
}
class MobilePhoneCharging extends ChargeMode{
private double monthlyRent = 15;
MobilePhoneCharging() {
getChargeRules().add(new SendMessageRule());
}
@Override
public double calCost(UserRecords userRecords) {
double all = 0;
all += getChargeRules().get(0).calCost(userRecords.getSendMessageRecords());
return all;
}
@Override
public double getMonthlyRent() {
return monthlyRent;
}
}
class SendMessageRule extends MessageRule {
@Override
public double calCost(ArrayList<MessageRecord> messageRecords) {
double all = 0;
double n = 0;
for (MessageRecord messageRecord : messageRecords) {
n = n + Math.ceil(messageRecord.getMessage().length() / 10.0);
}
if (n <= 3) {
all = all + n * 0.1;
} else if ( n <= 5) {
all = all + 0.3 + (n - 3) * 0.2;
} else{
all = all + 0.3 + 0.4 + (n - 5) * 0.3;
}
return all;
}
}
class MessageRecord extends CommunicationRecord{
private String message;
MessageRecord(String message) {
this.message = message;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}其中
| case14 | 单用户单条短信，多种字符输入，短信内容长。 |
答案错误
|
0 | 256 ms | 21388 KB |
(4)其他：
踩坑心得：
1.区分对于in.nextInt()、in.next()、in.nextLine()的运用选择。
三、总结
我们这段时间所学习的知识量比较的大，且难度也比较大，因此在学习过程中会比较的费力。尤其是在后面的阶段，其他课程临近期末考试，压力也就更大了。不过俗话说有压力就有动力。只几周的学习让我对Java更加的熟悉，也学会了更多的知识，对我有很大的提升，这也是我们这个学期最后一次博客了，我希望我们大家都可以有一个好多成绩！！！！
浙公网安备 33010602011771号