对之前发布的pta题目及的总结
前言
pta作业难还内容大，我都不知道具体内容要具体怎么实现，感觉简单的题好的分，但是难的题不是让我们得分的，感觉简单的题反而考到了知识点，但是难得题根本就偏离了我们所学的知识，感觉就是为了增加难度而出题，简单的题考到的知识点有正则表达式继承与多态，接口和抽象类，还有集合框架，数据的封装，还有老师能不能把每道题的测试点哪没过发出来呀，我感觉都对了，但是就是不知道哪里出现了问题，这样真的会急死人，知识点总结接口的注意事项：如果多个接口含有相同的抽象方法，则直接重写一回即可如果没有覆盖重写全部的，必须是抽象类接口中有相同的默认方法必须要重写，抽象类中也要重写一个类如果直接父类的方法与接口的默认方法冲突，优先使用父类的方法。多态的注意事项有继承关系子类重写父类方法子类引用指向父类对象，子类特有方法不能直接表达出来，需要子类和父类都有。抽象类的注意事项和知识点abstract(抽象类)：它是一个类，离不开extends(继承)，但extends是单继承，不能继承多个类，有局限性在抽象类中可以写普通方法，抽象方法必须写在抽象类中，不能实例化抽象类，只能靠它的子类去实现它，抽象类是受约束的。
设计与分析
实现南昌市电信分公司的计费程序，假设该公司针对手机和座机用户分别采取了两种计费方案，分别如下：
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）。
注意：以上图中所定义的类不是限定要求，根据实际需要自行补充或修改。
输入样例:
在这里给出一组输入。例如：
u-13811111111 1
t-13811111111 0791 13811111110 020 2022.1.3 08:00:00 2022.1.3 08:09:20
end
我的代码
// package integration;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.text.ParseException;
public class Main {
public static void main(String[] args) {
Outputtool outputtool = new Outputtool();
Inputdeal inputdeal = new Inputdeal();
ArrayList<User> users = new ArrayList<>();
Scanner in = new Scanner(System.in);
String input = in.nextLine();
while (!input.equals("end")) {
if (1 == inputdeal.check(input)) {
inputdeal.writeUser(users, input);
} else if (2 == inputdeal.check(input)) {
inputdeal.writeRecord(users, input);
}
input = in.nextLine();
}
users.sort(new Comparator<User>() {
@Override
public int compare(User u1, User u2) {
if (u1.getNumber().charAt(0) == '0' && u2.getNumber().charAt(0) != '0') {
return -1;
} else if (u1.getNumber().charAt(0) != '0' && u2.getNumber().charAt(0) == '0') {
return 1;
}
if (Double.parseDouble(u1.getNumber()) > Double.parseDouble(u2.getNumber())) {
return 1;
} else {
return -1;
}
}
});
for (User u : users) {
System.out.print(u.getNumber() + " ");
outputtool.output(u.calCost());
System.out.print(" ");
outputtool.output(u.calBalance());
System.out.println();
}
}
}
abstract class ChargeMode {
protected ArrayList<ChargeRule> chargeRules = new ArrayList<>();
public abstract double calCost(UserRecords userRecords);
public abstract double getMonthlyRent();
public ArrayList<ChargeRule> getChargeRules() {
return chargeRules;
}
public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
this.chargeRules = chargeRules;
}
}
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) {
callingInCityRecords.add(callRecord);
}
public void addCallingInProvinceRecords(CallRecord callRecord) {
callingInProvinceRecords.add(callRecord);
}
public void addCallingInLandRecords(CallRecord callRecord) {
callingInLandRecords.add(callRecord);
}
public void addAnswerInCityRecords(CallRecord callRecord) {
answerInCityRecords.add(callRecord);
}
public void aaddAnswerInProvinceRecords(CallRecord callRecord) {
answerInProvinceRecords.add(callRecord);
}
public void addAnswerInLandRecords(CallRecord callRecord) {
answerInLandRecords.add(callRecord);
}
public void addSendMessageRecords(MessageRecord callRecord) {
sendMessageRecords.add(callRecord);
}
public void addReceiveMessageRecords(MessageRecord callRecord) {
receiveMessageRecords.add(callRecord);
}
public ArrayList<CallRecord> getCallingInCityRecords() {
return callingInCityRecords;
}
public void setCallingInCityRecords(ArrayList<CallRecord> callingInCityRecords) {
this.callingInCityRecords = callingInCityRecords;
}
public ArrayList<CallRecord> getCallingInProvinceRecords() {
return callingInProvinceRecords;
}
public void setCallingInProvinceRecords(ArrayList<CallRecord> callingInProvinceRecords) {
this.callingInProvinceRecords = callingInProvinceRecords;
}
public ArrayList<CallRecord> getCallingInLandRecords() {
return callingInLandRecords;
}
public void setCallingInLandRecords(ArrayList<CallRecord> callingInLandRecords) {
this.callingInLandRecords = callingInLandRecords;
}
public ArrayList<CallRecord> getAnswerInCityRecords() {
return answerInCityRecords;
}
public void setAnswerInCityRecords(ArrayList<CallRecord> answerInCityRecords) {
this.answerInCityRecords = answerInCityRecords;
}
public ArrayList<CallRecord> getAnswerInProvinceRecords() {
return answerInProvinceRecords;
}
public void setAnswerInProvinceRecords(ArrayList<CallRecord> answerInProvinceRecords) {
this.answerInProvinceRecords = answerInProvinceRecords;
}
public ArrayList<CallRecord> getAnswerInLandRecords() {
return answerInLandRecords;
}
public void setAnswerInLandRecords(ArrayList<CallRecord> answerInLandRecords) {
this.answerInLandRecords = answerInLandRecords;
}
public ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
public void setSendMessageRecords(ArrayList<MessageRecord> sendMessageRecords) {
this.sendMessageRecords = sendMessageRecords;
}
public ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
public void setReceiveMessageRecords(ArrayList<MessageRecord> receiveMessageRecords) {
this.receiveMessageRecords = receiveMessageRecords;
}
}
class LandlinePhoneCharging extends ChargeMode {
private double monthlyRent = 20;
public LandlinePhoneCharging() {
super();
chargeRules.add(new LandPhoneInCityRule());
chargeRules.add(new LandPhoneInProvinceRule());
chargeRules.add(new LandPhoneInlandRule());
}
@Override
public double calCost(UserRecords userRecords) {
double sumCost = 0;
for (ChargeRule rule : chargeRules) {
sumCost += rule.calCost(userRecords);
}
return sumCost;
}
@Override
public double getMonthlyRent() {
return monthlyRent;
}
}
class MobilePhoneCharging extends ChargeMode {
private double monthlyRent = 15;
public MobilePhoneCharging() {
super();
chargeRules.add(new MobilePhoneInCityRule());
chargeRules.add(new MobilePhoneInProvinceRule());
chargeRules.add(new MobilePhoneInlandRule());
}
@Override
public double calCost(UserRecords userRecords) {
double sumCost = 0;
for (ChargeRule rule : chargeRules) {
sumCost += rule.calCost(userRecords);
}
return sumCost;
}
@Override
public double getMonthlyRent() {
return monthlyRent;
}
}
class Inputdeal {
public int check(String input) {
if (input.matches("[u]-0791[0-9]{7,8}\\s[0]") || input.matches("[u]-1[0-9]{10}\\s[1]")) {
return 1;
// } else if (input.charAt(0) == 'm') {
// return 2;
} else if (input.matches("(([t]-0791[0-9]{7,8}\\s" + "0[0-9]{9,11}\\s)|"
+ "([t]-0791[0-9]{7,8}\\s" + "1[0-9]{10}\\s" + "0[0-9]{2,3}\\s)|"
+ "([t]-1[0-9]{10}\\s" + "0[0-9]{2,3}\\s" + "0[0-9]{9,11}\\s)|"
+ "([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]{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])\\s"
+ "((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.((([13578]|1[02])\\.("
+ "[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])")) {
return 2;
}
return 0;
}
@SuppressWarnings("unused")
private boolean validatet(String string) {
if (!string.matches("^([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$")) {
return false;
}
return true;
}
public static boolean validate(String dateString) {
// 使用正则表达式 测试 字符 符合 dddd.dd.dd 的格式(d表示数字)
Pattern p = Pattern.compile("\\d{4}+[\\.]\\d{1,2}+[\\.]\\d{1,2}+");
Matcher m = p.matcher(dateString);
if (!m.matches()) {
return false;
}
// 得到年月日
String[] array = dateString.split("\\.");
int year = Integer.valueOf(array[0]);
int month = Integer.valueOf(array[1]);
int day = Integer.valueOf(array[2]);
if (month < 1 || month > 12) {
return false;
}
int[] monthLengths = new int[] { 0, 31, -1, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
if (isLeapYear(year)) {
monthLengths[2] = 29;
} else {
monthLengths[2] = 28;
}
int monthLength = monthLengths[month];
if (day < 1 || day > monthLength) {
return false;
}
return true;
}
/** 是否是闰年 */
private static boolean isLeapYear(int year) {
return ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0);
}
public boolean judge(String input) {
return false;
}
public void writeUser(ArrayList<User> users, String input) {
User usernew = new User();
String[] inputs = input.split(" ");
String num = inputs[0].substring(2);
for (User i : users) {
if (i.getNumber().equals(num)) {
return;
}
}
usernew.setNumber(num);
int mode = Integer.parseInt(inputs[1]);
if (mode == 0) {
usernew.setChargeMode(new LandlinePhoneCharging());
} else if (mode == 1) {
usernew.setChargeMode(new MobilePhoneCharging());
}
users.add(usernew);
}
public void writeRecord(ArrayList<User> users, String input) {
String[] inputs = input.split(" ");
User callu = null, answeru = null;
CallRecord callrecord = new CallRecord(inputs);
if (input.charAt(0) == 't') {
String out = inputs[0];
String in = "";
if (inputs.length == 6) {
in = inputs[1];
} else if (inputs.length == 7) {
in = inputs[1];
} else if (inputs.length == 8) {
in = inputs[2];
}
for (User i : users) {
if (i.getNumber().equals(out)) {
callu = i;
}
if (i.getNumber().equals(in)) {
answeru = i;
}
if (callu != null && answeru != null) {
break;
}
}
if (callu != null) {
if (callrecord.getCallType().matches("^1[1-3]$")) {
callu.getUserRecords().addCallingInCityRecords(callrecord);
} else if (callrecord.getCallType().matches("^2[1-3]$")) {
callu.getUserRecords().addCallingInProvinceRecords(callrecord);
} else {
callu.getUserRecords().addCallingInLandRecords(callrecord);
}
}
if (answeru != null) {
if (callrecord.getCallType().matches("^[1-3]1$")) {
answeru.getUserRecords().addAnswerInCityRecords(callrecord);
} else if (callrecord.getCallType().matches("^[1-3]2$")) {
answeru.getUserRecords().aaddAnswerInProvinceRecords(callrecord);
} else {
answeru.getUserRecords().addAnswerInLandRecords(callrecord);
}
}
} else if (input.charAt(0) == 'm') {
}
}
}
abstract class CommunicationRecord {
protected String callingNumber;
protected String answerNumbe;
public String getCallingNumber() {
return callingNumber;
}
public void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
public String getAnswerNumbe() {
return answerNumbe;
}
public void setAnswerNumbe(String answerNumbe) {
this.answerNumbe = answerNumbe;
}
}
abstract class ChargeRule {
abstract public double calCost(UserRecords userRecords);
}
class CallRecord extends CommunicationRecord {
private Date startTime;
private Date endTime;
private String callingAddressAreaCode;
private String answerAddressAreaCode;
public String getCallType() {
String type = "";
if (callingAddressAreaCode.equals("0791")) {
type = type.concat("1");
} else if (callingAddressAreaCode.matches("^079[023456789]$") || callingAddressAreaCode.equals("0701")) {
type = type.concat("2");
} else {
type = type.concat("3");
}
if (answerAddressAreaCode.equals("0791")) {
type = type.concat("1");
} else if (answerAddressAreaCode.matches("^079[023456789]$") || answerAddressAreaCode.equals("0701")) {
type = type.concat("2");
} else {
type = type.concat("3");
}
return type;
}
public CallRecord(String[] inputs) {
super();
char type = inputs[0].charAt(0);
inputs[0] = inputs[0].substring(2);
String sd = null, st = null, ed = null, et = null;
if (type == 't') {
if (inputs.length == 6) {
sd = inputs[2];
st = inputs[3];
ed = inputs[4];
et = inputs[5];
callingAddressAreaCode = inputs[0].substring(0, 4);
answerAddressAreaCode = inputs[1].substring(0, 4);
} else if (inputs.length == 7) {
sd = inputs[3];
st = inputs[4];
ed = inputs[5];
et = inputs[6];
if (inputs[0].charAt(0) != '0') {
if (inputs[2].length() == 10) {
answerAddressAreaCode = inputs[2].substring(0, 3);
} else {
answerAddressAreaCode = inputs[2].substring(0, 4);
}
callingAddressAreaCode = inputs[1];
} else {
if (inputs[0].length() == 10) {
callingAddressAreaCode = inputs[0].substring(0, 3);
} else {
callingAddressAreaCode = inputs[0].substring(0, 4);
}
answerAddressAreaCode = inputs[2];
}
} else if (inputs.length == 8) {
sd = inputs[4];
st = inputs[5];
ed = inputs[6];
et = inputs[7];
callingAddressAreaCode = inputs[1];
answerAddressAreaCode = inputs[3];
}
} else if (type == 'm') {
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss", Locale.getDefault());
try {
startTime = simpleDateFormat.parse(sd + " " + st);
endTime = simpleDateFormat.parse(ed + " " + et);
} catch (ParseException e) {
}
}
public CallRecord(Date startTime, Date endTime, String callingAddressAreaCode, String answerAddressAreaCode) {
super();
this.startTime = startTime;
this.endTime = endTime;
this.callingAddressAreaCode = callingAddressAreaCode;
this.answerAddressAreaCode = 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 CallChargeRule extends ChargeRule {
}
class LandPhoneInCityRule extends CallChargeRule {
@Override
public double calCost(UserRecords userRecords) {
double sumCost = 0;
for (CallRecord call : userRecords.getCallingInCityRecords()) {
double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (distanceS < 0) {
continue;
}
double distanceM = (int) distanceS / 60;
if (distanceS % 60 != 0) {
distanceM += 1;
}
if (call.getCallType().equals("11")) {
sumCost += distanceM * 0.1;
} else if (call.getCallType().equals("12")) {
sumCost += distanceM * 0.3;
} else if (call.getCallType().equals("13")) {
sumCost += distanceM * 0.6;
}
}
return sumCost;
}
}
class LandPhoneInlandRule extends CallChargeRule {
@Override
public double calCost(UserRecords userRecords) {
double sumCost = 0;
for (CallRecord call : userRecords.getCallingInLandRecords()) {
double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (distanceS < 0) {
continue;
}
double distanceM = (int) distanceS / 60;
if (distanceS % 60 != 0) {
distanceM += 1;
}
sumCost += distanceM * 0.6;
}
return sumCost;
}
}
class LandPhoneInProvinceRule extends CallChargeRule {
@Override
public double calCost(UserRecords userRecords) {
double sumCost = 0;
for (CallRecord call : userRecords.getCallingInProvinceRecords()) {
double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (distanceS < 0) {
continue;
}
double distanceM = (int) distanceS / 60;
if (distanceS % 60 != 0) {
distanceM += 1;
}
sumCost += distanceM * 0.3;
}
return sumCost;
}
}
class MobilePhoneInCityRule extends CallChargeRule {
@Override
public double calCost(UserRecords userRecords) {
double sumCost = 0;
for (CallRecord call : userRecords.getCallingInCityRecords()) {
double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (distanceS < 0) {
continue;
}
double distanceM = (int) distanceS / 60;
if (distanceS % 60 != 0) {
distanceM += 1;
}
if (call.getCallType().equals("11")) {
sumCost += distanceM * 0.1;
} else if (call.getCallType().equals("12")) {
sumCost += distanceM * 0.2;
} else if (call.getCallType().equals("13")) {
sumCost += distanceM * 0.3;
}
}
return sumCost;
}
}
class MobilePhoneInlandRule extends CallChargeRule {
@Override
public double calCost(UserRecords userRecords) {
double sumCost = 0;
for (CallRecord call : userRecords.getCallingInLandRecords()) {
double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (distanceS < 0) {
continue;
}
double distanceM = (int) distanceS / 60;
if (distanceS % 60 != 0) {
distanceM += 1;
}
sumCost += distanceM * 0.6;
}
for (CallRecord call : userRecords.getAnswerInLandRecords()) {
double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (distanceS < 0) {
continue;
}
double distanceM = (int) distanceS / 60;
if (distanceS % 60 != 0) {
distanceM += 1;
}
sumCost += distanceM * 0.3;
}
return sumCost;
}
}
class MobilePhoneInProvinceRule extends CallChargeRule {
@Override
public double calCost(UserRecords userRecords) {
double sumCost = 0;
for (CallRecord call : userRecords.getCallingInProvinceRecords()) {
double distanceS = (-call.getStartTime().getTime() + call.getEndTime().getTime()) / 1000;
if (distanceS < 0) {
continue;
}
double distanceM = (int) distanceS / 60;
if (distanceS % 60 != 0) {
distanceM += 1;
}
if (call.getCallType().equals("21")) {
sumCost += distanceM * 0.3;
} else if (call.getCallType().equals("22")) {
sumCost += distanceM * 0.3;
} else if (call.getCallType().equals("23")) {
sumCost += distanceM * 0.3;
}
}
return sumCost;
}
}
class MessageRecord extends CommunicationRecord {
private String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
class User {
private UserRecords userRecords = new UserRecords();
private double balance = 100;
private ChargeMode chargeMode;
private String number;
public double calCost() {
return chargeMode.calCost(userRecords);
}
public double calBalance() {
return balance - chargeMode.getMonthlyRent() - chargeMode.calCost(userRecords);
}
public UserRecords getUserRecords() {
return userRecords;
}
public void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
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;
}
}
class Outputtool {
@SuppressWarnings("deprecation")
public void output(double out) {
// java.text.DecimalFormat df=new java.text.DecimalFormat("#.##");
// String a=df.format(out);
// System.out.print(a);
BigDecimal numb = new BigDecimal(out);
out = numb.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
System.out.print(out);
}
}
本体考的知识点：主要考的的是arraylist的知识点而arraylist主要的知识点是使用工具类 Arrays.asList()把数组转换成集合时，不能使用其修改集合相关的方法，它的 add/remove/clear 方法会抛出 UnsupportedOperationException 异常。
实验三 继承与多态（一）
一、实验目的
1、 掌握Java语言中继承的基本概念及使用方法；
2、 掌握Java语言中super关键字的使用方法；
3、 理解继承与组合的区别；
4、 理解程序设计中代码复用的重要性。
二、实验要求
1、 根据实验步骤中提出的要求，使用eclipse等开发工具编写相应的Java程序；
2、 编译、运行自己所编写的Java程序；
3、 根据编译与运行过程中所获得的错误信息修改程序直至获得正确的结果；
4、 记录实验中遇到的各类问题并以及解决办法。
三、实验步骤
1、 农夫过河问题:将之前的代码进行如下改进：
（1） 为之前的类添加合适的父类。
（2） 为父类添加适合的属性和方法。并以此为基础修改原有的类，使之与添加的类构成继承关系。
（3） 使用多态改进整个代码，提高代码的复用性。
2、 请画出完整类图，包含每个类的类名、属性、方法以及类与类的关联，并用文字说明关联类的关联关系。
3、 说明你设计的继承关系的理由，为什么不用组合
4、 说明你在哪部分代码中使用了多态，带来了什么好处。
四、实验结果
五、实验小结
首先父类最好设成抽象类，这样用覆盖就可以检验父类中各个方法是否全用到，这样可以保证子类中的代码的正确性，父类中需要的代码有getisAlive（），isAlive（），getcrossRiver（），crossRiver（），这几种方法
子类中，需要把返回值调用之前的父类中的返回值，这样才可以带出来，
其次，羊和狼的类中
这两个方法需要把你的代码改写成和之前一样的。
不同之处就是你需要把子类中与之前重复的代码删除。
学到了什么
首先你学到了抽象类的方法，其次这样你也可以实现代码的改写的跟方便，用了继承，那么你的代码会变得更加简洁，其次父类的覆盖重写，需要加上注释，这样你就可以实现跟多代码错误的地方能跟加轻易的改写。
六、附录
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Game game=new Game();
game.play();
}
}
class GameGui{
public static void menu(){
System.out.println("==========Please choose operation=============");
System.out.println("==========1:Cross the river alone===============");
System.out.println("==========2:Cross the river with wolf=============");
System.out.println("==========3:Cross the river with sheep===========");
System.out.println("==========4:Cross the river with cabbage=========");
System.out.println("==========0:Quit============================");
System.out.println("===========================================");
System.out.println("Input the number(0~4):");
}
public static void showStatus(Farmer farmer,Wolf wolf,Sheep sheep,Cabbage cabbage){
farmer.showStatus();
wolf.showStatus();
sheep.showStatus();
cabbage.showStatus();
}
}
class Game{
Wolf wolf;
Sheep sheep;
Cabbage cabbage;
Farmer farmer;
Boat boat;
Game(){
wolf=new Wolf("祖安怒兽沃里克");
sheep=new Sheep("山隐之焰奥恩");
cabbage=new Cabbage();
farmer=new Farmer();
boat=new Boat();
}
protected void play(){
Scanner input=new Scanner(System.in);
int choice=0;
boolean gameOver=false,win=false;
while(!gameOver){
GameGui.menu();
choice=input.nextInt();
switch(choice){
case 0:
System.out.println("退出游戏");
System.exit(0);
break;
case 1:
farmer.crossRiver();
boat.crossRiver=!(boat.crossRiver);
break;
case 2:
if(farmer.getcrossRiver()==wolf.getcrossRiver()){
farmer.crossRiver();
wolf.crossRiver();
boat.crossRiver=!(boat.crossRiver);
}else{
wolf.crossRiver();
}
break;
case 3:
if(farmer.getcrossRiver()==sheep.getcrossRiver()){
farmer.crossRiver();
sheep.crossRiver();
boat.crossRiver=!(boat.crossRiver);
}else{
sheep.crossRiver();
}
break;
case 4:
if(cabbage.getcrossRiver()==farmer.getcrossRiver()){
farmer.crossRiver();
cabbage.crossRiver();
boat.crossRiver=!(boat.crossRiver);
}else{
cabbage.crossRiver();
}
break;
}
wolf.eatSheep(sheep,farmer);
sheep.eatCabbage(cabbage,farmer);
GameGui.showStatus(farmer,wolf,sheep,cabbage);
gameOver=isGameOver();
}
win=this.hasWin();
if(win){
System.out.println("game over:you win!");
}else{
System.out.println("game over:you lose!");
}
}
public boolean isGameOver(){
if(sheep.getisAlive()==false||cabbage.getisAlive()==false){
return true;
}
if(wolf.getcrossRiver()&&sheep.getcrossRiver()&&cabbage.getcrossRiver()){
return true;
}
return false;
}
public boolean hasWin(){
if(sheep.getisAlive()==false||cabbage.getisAlive()==false){
return false;
}
if(wolf.getcrossRiver()&&sheep.getcrossRiver()&&cabbage.getcrossRiver()){
return true;
}else{
return false;
}
}
}
abstract class Father{
private boolean isAlive;
private boolean crossRiver;
public Father(){
isAlive = true;
crossRiver = false;
}
public boolean getisAlive(){
return isAlive;
}
public void isAlive(){
isAlive =!isAlive;
}
public boolean getcrossRiver(){
return crossRiver;
}
public void crossRiver(){
crossRiver=!crossRiver;
}
}
class Farmer extends Father{
public void showStatus(){
System.out.println("Farmer has Cross :"+getcrossRiver());
}
@Override
public void crossRiver(){
super.crossRiver();
}
@Override
public boolean getcrossRiver(){
return super.getcrossRiver();
}
}
class Wolf extends Father{
String name;
public Wolf(String name){
this.name=name;
System.out.println("嗷呜~~~我"+name+"又回来了");
}
public void showStatus(){
System.out.println("Wolf is alive :true "+"Wolf has Cross :"+super.getcrossRiver());
}
public void eatSheep(Sheep sheep,Farmer farmer){
if(sheep.getcrossRiver()==this.getcrossRiver()&&sheep.getcrossRiver()!=farmer.getcrossRiver()){
sheep.isAlive();
}
}
@Override
public void crossRiver(){
super.getcrossRiver();
}
public boolean getcrossRiver(){
return super.getcrossRiver();
}
}
class Sheep extends Father{
String name;
public Sheep(String name){
this.name=name;
System.out.println("咩咩，我是可爱的小羊"+name);
}
public void showStatus(){
System.out.println("Sheep is alive :"+this.getisAlive()+" "+"Sheep has Cross :"+this.getcrossRiver());
}
public void eatCabbage(Cabbage cabbage,Farmer farmer){
if(cabbage.getcrossRiver()==this.getcrossRiver()&&cabbage.getcrossRiver()!=farmer.getcrossRiver()){
cabbage.isAlive();
}
}
public void crossRiver(){
super.crossRiver();
}
public boolean getcrossRiver(){
return super.getcrossRiver();
}
public void isAlive(){
super.isAlive();
}
public boolean getisAlive(){
return super.getisAlive();
}
}
class Cabbage extends Father{
public void showStatus(){
System.out.println("Cabbage is alive :"+this.getisAlive()+" "+"Cabbage has Cross :"+this.getcrossRiver());
}
public void crossRiver(){
super.crossRiver();
}
public boolean getcrossRiver(){
return super.getcrossRiver();
}
public void isAlive(){
super.isAlive();
}
public boolean getisAlive(){
return super.getisAlive();
}
}
class Boat{
boolean crossRiver=false;
}
踩坑心得
其实还好但是知识点有很多盲区比如知识点总结接口的注意事项：如果多个接口含有相同的抽象方法，则直接重写一回即可如果没有覆盖重写全部的，必须是抽象类接口中有相同的默认方法必须要重写，抽象类中也要重写一个类如果直接父类的方法与接口的默认方法冲突，优先使用父类的方法。多态的注意事项有继承关系子类重写父类方法子类引用指向父类对象，子类特有方法不能直接表达出来，需要子类和父类都有。抽象类的注意事项和知识点abstract(抽象类)：它是一个类，离不开extends(继承)，但extends是单继承，不能继承多个类，有局限性在抽象类中可以写普通方法，抽象方法必须写在抽象类中，不能实例化抽象类，只能靠它的子类去实现它，抽象类是受约束的。使用工具类 Arrays.asList()把数组转换成集合时，不能使用其修改集合相关的方，它的 add/remove/clear 方法会抛出 UnsupportedOperationException 异常。说明：asList 的返回对象是一个 Arrays 内部类，并没有实现集合的修改方法。Arrays.asList 体现的是适使用工具类 Arrays.asList()把数组转换成集合时，不能使用其修改集合相关的方法，它的 add/remove/clear 方法会抛出 UnsupportedOperationException 异常。
该进建议
题目尽量考到知识点吧，反正我觉得出太难的对我没什么提升，可能是我太菜了吧，没有花心思去学习吧，最后一部分作业：花费时间较长。
总结
学习的总结来说我还是太贪玩了，感觉疫情以来就放松了自己，导致这门科目挂科，，我觉得我也应该话跟多时间去学习但是就好像过一项嘴瘾一样，说一下，但是实际还是不会有太多的时间去学习，不会去找个安静的地方学习还是需要我走跟多的路，摔跟多的跤
我才会长记性，也不会在这无所事事，在这怨天尤人，在学习Java是应该是我人生中最颓废的时光了吧，刚开始的学习内容还比较仔细，而后期遇到那些难以理解的知识，就只是通过询问有模糊的理解就开始后面的内容，并没有完全掌握，问问题的时候也因为不好意思问，就只是问一遍，即使还不理解也没有继续问，在进行练习时，有不理解的地方或是不会敲的代码也是问一遍，还不懂就直接记套路。
浙公网安备 33010602011771号