第三次博客

1.前言

2.设计与分析

3.心得

4.改进建议

5.总结

1.前言

这是本学期的第三次博客随笔，主要分析pta的后面题目。相较于之前的pta题目的难以下手，最近的pta题目稍微容易了一点，但是仍然具有一些难度，题量适中，主要考查了接口，内部类，抽象类等知识点。其中电信收费的题目在三次pta中都出现，但每次都在前一次的基础上加上新的东西，层层深入，还有实验，依旧是农夫过河，但在上次的基础上要添加抽象类，接口，在最后一次实验中，还要运用javafx制作农夫过河的游戏界面。

2.设计与分析

原题：

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

分数 80

作者蔡轲

单位南昌航空大学

实现一个简单的电信计费程序：
假设南昌市电信分公司针对市内座机用户采用的计费方式：
月租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<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

mport java.lang.reflect.Array;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Scanner;

public class Main {

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);

String input = in.nextLine();
List<User> users = new ArrayList<>();
while(!input.equals("end")) {
if(input.matches("[u][-][0][7][9][1][0-9]{7,8}\\s[0]")) {
String number = input.split(" ")[0].split("-")[1];
String type = input.split(" ")[1];
if(type.equals("0")) {
boolean flag = true;
for(int i = 0 ;i < users.size();i++) {
if(users.get(i).getNumber().equals(number)){
flag = false;
break;
}
}
if(flag) {
User user = new User(new LandlinePhoneCharging(),number);
users.add(user);
}
}
}
else if(input.matches("[u][-][1][0-9]{10}\\s[1]")) {
String number = input.split(" ")[0].split("-")[1];
String type = input.split(" ")[1];
if(type.equals("1")) {
boolean flag = true;
for(int i = 0 ; i < users.size();i++) {
if(users.get(i).getNumber().equals(number)) {
flag = false;
break;
}
}
if(flag) {
User user = new User(new LandlinePhoneCharging(),number);
users.add(user);
}
}

}
else if(input.matches("[t]-0791[0-9]{7,8}\\s" + "0[0-9]{9,11}\\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])")) {
String[] inputs = input.split(" ");
for(int i = 0 ;i < users.size();i++) {
if(users.get(i).getNumber().equals(inputs[0].split("-")[1])) {
CallRecord callrecord = new CallRecord();
DateFormat simpleFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
Date startdate = simpleFormat.parse(inputs[2] + " " + inputs[3]);
callrecord.setStartTime(startdate);
} catch (ParseException e) {
// TODO Auto-generated catch block
break;
}
try {
Date enddate = simpleFormat.parse(inputs[4] + " " + inputs[5]);
callrecord.setEndTime(enddate);
} catch (ParseException e) {
// TODO Auto-generated catch block
break;
}
boolean flag = true;
for(int j = 0; j < users.get(i).getUserRecords().getTotalCallRecords().size();j++) {
Date startdate = users.get(i).getUserRecords().getTotalCallRecords().get(j).getStartTime();
Date enddate = users.get(i).getUserRecords().getTotalCallRecords().get(j).getEndTime();
Date nowStartdate = callrecord.getStartTime();
Date nowEnddate = callrecord.getEndTime();
if((nowStartdate.getTime() > startdate.getTime() && nowStartdate.getTime() < enddate.getTime())||(nowEnddate.getTime() > startdate.getTime() && nowEnddate.getTime() < enddate.getTime())){
flag = false;
break;
}

}
if(true) {
users.get(i).call4(inputs[1],inputs[2] ,inputs[3] ,inputs[4] ,inputs[5] );
}
}
}
}
else if(input.matches("[t]-0791[0-9]{7,8}\\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])\\.(" +
"[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})\\.(((0?[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])")) {
String[] inputs = input.split(" ");
String callnumber = inputs[0].split("-")[1];
for(int i = 0; i < users.size();i++) {
if(users.get(i).getNumber().equals(callnumber)) {
users.get(i).call3(inputs[1],inputs[2] ,inputs[3] ,inputs[4] ,inputs[5],inputs[6]);

}
}
for(int j = 0; j < users.size();j++) {
if(inputs[1].equals(users.get(j).getNumber())) {
if(!inputs[2].matches("[0][7][9][0-9]||[0][7][0][1]")) {
users.get(j).answer(callnumber,inputs[3] ,inputs[4] ,inputs[5],inputs[6]);
}
}
}

}
else if(input.matches("[t]-1[0-9]{10}\\s" +"0[0-9]{2,3}\\s"+"0[0-9]{10,11}\\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])\\.(" +
"[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})\\.(((0?[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])")) {
String[] inputs = input.split(" ");
String callnumber = inputs[0].split("-")[1];
for(int i = 0; i < users.size();i++) {
if(users.get(i).getNumber().equals(callnumber)) {
users.get(i).call1(inputs[1],inputs[2],inputs[3] ,inputs[4] ,inputs[5],inputs[6]);
}
}
}
else if(input.matches("[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])\\.(" +
"[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})\\.(((0?[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])")) {
String[] inputs = input.split(" ");
String callnumber = inputs[0].split("-")[1];
for(int i = 0; i < users.size();i++) {
if(users.get(i).getNumber().equals(callnumber)) {
users.get(i).call2(inputs[1],inputs[2],inputs[3] ,inputs[4] ,inputs[5],inputs[6],inputs[7]);

}

}
for(int j =0;j < users.size();j++) {
if(inputs[2].equals(users.get(j).getNumber())) {
if(!inputs[3].matches("[0][7][9][0-9]||[0][7][0][1]")) {
users.get(j).answer(callnumber, inputs[4] ,inputs[5],inputs[6],inputs[7]);
}
}
}
}
input = in.nextLine();
}
Collections.sort(users, new Comparator<User>() {
@Override
public int compare(User o1, User o2) {
return o1.getNumber().compareTo(o2.getNumber());
}
});

for(int i = 0 ; i < users.size();i++) {
System.out.print(users.get(i).getNumber() + " ");
if(users.get(i).getNumber().matches("[0][7][9][1][0-9]{7,8}")) {
System.out.print(new DecimalFormat("0.0##").format(users.get(i).calCost()) + " " + new DecimalFormat("0.0##").format(users.get(i).calBalance() - users.get(i).calCost()));

}
else {
System.out.print(new DecimalFormat("0.0##").format(users.get(i).calCost()) + " " + new DecimalFormat("0.0##").format(users.get(i).calBalance()));

}
System.out.println();
}
}

}

abstract class CallChargeRule extends ChargeRule{

public abstract double calCost(ArrayList<CallRecord> callRecords);
}

class CallRecord extends CommunicationRecord{

private Date startTime;
private Date endTime;
private String callingAddressAreaCode;
private String answerAddressAreaCode;
private long calltime;

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;
}

public void setCalltime(long calltime) {
this.calltime = calltime;
}

public long getCalltime() {
return calltime;
}

}

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();
}

abstract class ChargeRule {

}

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{

private double monthlyRent = 20;

@Override
public double getMonthlyRent() {
// TODO Auto-generated method stub
return monthlyRent;
}

@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
return 0;
}

}

class LandPhoneInCityRule extends CallChargeRule{

@Override
public double calCost(ArrayList<CallRecord> callRecords) {

return 0.1;
}

}

class LandPhoneInlandRule extends CallChargeRule{

@Override
public double calCost(ArrayList<CallRecord> callRecords) {
// TODO Auto-generated method stub
return 0.6;
}

}

class LandPhoneInProvinceRule extends CallChargeRule{

@Override
public double calCost(ArrayList<CallRecord> callRecords) {
// TODO Auto-generated method stub
return 0.3;
}

}

class MessageRecord {

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 User() {
// TODO Auto-generated constructor stub
}

public User(ChargeMode chargemode ,String number) {

this.chargemode = chargemode;
this.number = number;

}

public double calBalance() {
if(number.matches("[0][7][9][1][0-9]{7,8}")) {
return balance - chargemode.getMonthlyRent() ;
}
else {
return balance - 15;
}

}

public double calCost() {
double calcost = 0;
if(number.matches("[0][7][9][1][0-9]{7,8}")) {
for(int i = 0 ; i < chargemode.getChargeRules().size();i++) {
String ss = chargemode.getChargeRules().get(i).getClass().toString();
if(chargemode.getChargeRules().get(i).getClass().toString().equals("class LandPhoneInCityRule")) {
calcost += userRecords.getTotalCallRecords().get(i).getCalltime() * 0.1;
}
else if(chargemode.getChargeRules().get(i).getClass().toString().equals("class LandPhoneInProvinceRule")) {
calcost += userRecords.getTotalCallRecords().get(i).getCalltime() * 0.3;
}
else if(chargemode.getChargeRules().get(i).getClass().toString().equals("class LandPhoneInlandRule")) {
calcost += userRecords.getTotalCallRecords().get(i).getCalltime() * 0.6;
}
}
}
else {
calcost = 100 - balance;

}
return calcost;
}

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 void call4(String answernumber,String date1,String time1,String date2,String time2) {
CallRecord callrecord = new CallRecord();
callrecord.setCallingNumber(number);
callrecord.setAnswerNumber(answernumber);
callrecord.setCallingAddressAreaCode("" + number.charAt(0) + number.charAt(1) + number.charAt(2) + number.charAt(3));
callrecord.setAnswerAddressAreaCode("" + answernumber.charAt(0) + answernumber.charAt(1)+ answernumber.charAt(2) + answernumber.charAt(3));
DateFormat simpleFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
Date startdate = simpleFormat.parse(date1 + " " + time1);
callrecord.setStartTime(startdate);
} catch (ParseException e) {
// TODO Auto-generated catch block

}
try {
Date enddate = simpleFormat.parse(date2 + " " + time2);

callrecord.setEndTime(enddate);
} catch (ParseException e) {
// TODO Auto-generated catch block

}
if(callrecord.getAnswerAddressAreaCode().equals(callrecord.getCallingAddressAreaCode())) {
userRecords.addCallingCityRecords(callrecord);
chargemode.getChargeRules().add(new LandPhoneInCityRule());
}
else if(callrecord.getAnswerAddressAreaCode().matches("[0][7][9][0-9]||[0][7][0][1]")) {
userRecords.addCallingProvinceRecords(callrecord);
chargemode.getChargeRules().add(new LandPhoneInProvinceRule());
}
else {
userRecords.addCallingInLandRecords(callrecord);
chargemode.getChargeRules().add(new LandPhoneInlandRule());
}
long calltime = (int)Math.ceil((callrecord.getEndTime().getTime() - callrecord.getStartTime().getTime()) / 1000.0 / 60);
callrecord.setCalltime(calltime);

userRecords.addTotalCallRecords(callrecord);

}

public void call3(String answernumber,String answerAreaCode,String date1,String time1,String date2,String time2 ) {
CallRecord callrecord = new CallRecord();
callrecord.setCallingNumber(number);
callrecord.setAnswerNumber(answernumber);
callrecord.setCallingAddressAreaCode("" + number.charAt(0) + number.charAt(1) + number.charAt(2) + number.charAt(3));
callrecord.setAnswerAddressAreaCode(answerAreaCode);
DateFormat simpleFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
Date startdate = simpleFormat.parse(date1 + " " + time1);
callrecord.setStartTime(startdate);
} catch (ParseException e) {
// TODO Auto-generated catch block

}
try {
Date enddate = simpleFormat.parse(date2 + " " + time2);

callrecord.setEndTime(enddate);
} catch (ParseException e) {
// TODO Auto-generated catch block

}
if(callrecord.getAnswerAddressAreaCode().equals(callrecord.getCallingAddressAreaCode())) {
userRecords.addCallingCityRecords(callrecord);
chargemode.getChargeRules().add(new LandPhoneInCityRule());
}
else if(callrecord.getAnswerAddressAreaCode().matches("[0][7][9][0-9]||[0][7][0][1]")) {
userRecords.addCallingProvinceRecords(callrecord);
chargemode.getChargeRules().add(new LandPhoneInProvinceRule());
}
else {
userRecords.addCallingInLandRecords(callrecord);
chargemode.getChargeRules().add(new LandPhoneInlandRule());
}
long calltime = (int)Math.ceil((callrecord.getEndTime().getTime() - callrecord.getStartTime().getTime()) / 1000.0 / 60);
callrecord.setCalltime(calltime);

userRecords.addTotalCallRecords(callrecord);

}

public void call1(String callAreacode,String answernumber,String date1,String time1,String date2,String time2) {
CallRecord callrecord = new CallRecord();
callrecord.setCallingAddressAreaCode(callAreacode);
callrecord.setAnswerNumber(answernumber);

DateFormat simpleFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
Date startdate = simpleFormat.parse(date1 + " " + time1);
callrecord.setStartTime(startdate);
} catch (ParseException e) {
// TODO Auto-generated catch block

}
try {
Date enddate = simpleFormat.parse(date2 + " " + time2);

callrecord.setEndTime(enddate);
} catch (ParseException e) {
// TODO Auto-generated catch block

}

long calltime = (int)Math.ceil((callrecord.getEndTime().getTime() - callrecord.getStartTime().getTime()) / 1000.0 / 60);
callrecord.setCalltime(calltime);

userRecords.addTotalCallRecords(callrecord);

if(callAreacode.matches("[0][7][9][1]")) {
balance = balance - calltime * 0.1;
}
else if(callAreacode.matches("[0][7][9][0-9]||[0][7][0][1]]")) {
balance = balance - calltime * 0.3;
}
else {
balance = balance - calltime * 0.6;
}

}

public void call2(String callAreacode,String answernumber,String answercode,String date1,String time1,String date2,String time2) {
CallRecord callrecord = new CallRecord();
callrecord.setCallingAddressAreaCode(callAreacode);
callrecord.setAnswerNumber(answernumber);

DateFormat simpleFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
Date startdate = simpleFormat.parse(date1 + " " + time1);
callrecord.setStartTime(startdate);
} catch (ParseException e) {
// TODO Auto-generated catch block

}
try {
Date enddate = simpleFormat.parse(date2 + " " + time2);

callrecord.setEndTime(enddate);
} catch (ParseException e) {
// TODO Auto-generated catch block

}

long calltime = (int)Math.ceil((callrecord.getEndTime().getTime() - callrecord.getStartTime().getTime()) / 1000.0 / 60);
callrecord.setCalltime(calltime);

userRecords.addTotalCallRecords(callrecord);

if(callAreacode.matches("[0][7][9][1]")) {
if(answercode.matches("[0][7][9][1]")) {
balance = balance - calltime * 0.1;
}
else if(answercode.matches("[0][7][9][0-9]||[0][7][0][1]")) {
balance = balance - calltime * 0.2;
}
else {
balance = balance - calltime * 0.3;
}

}
else if(callAreacode.matches("[0][7][9][0-9]||[0][7][0][1]")) {
balance = balance - calltime * 0.3;
}
else {
balance = balance - calltime * 0.6;
}
}

public void answer(String callnumber,String date1,String time1,String date2,String time2) {
CallRecord callrecord = new CallRecord();
callrecord.setCallingNumber(callnumber);
callrecord.setAnswerNumber(number);
DateFormat simpleFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
try {
Date startdate = simpleFormat.parse(date1 + " " + time1);
callrecord.setStartTime(startdate);
} catch (ParseException e) {
// TODO Auto-generated catch block

}
try {
Date enddate = simpleFormat.parse(date2 + " " + time2);

callrecord.setEndTime(enddate);
} catch (ParseException e) {
// TODO Auto-generated catch block

}

long calltime = (int)Math.ceil((callrecord.getEndTime().getTime() - callrecord.getStartTime().getTime()) / 1000.0 / 60);
callrecord.setCalltime(calltime);

balance = balance - calltime * 0.3;
userRecords.addTotalAnswerRecords(callrecord);
}

}

class UserRecords {

private ArrayList<CallRecord> callingCityRecords = new ArrayList<>();
private ArrayList<CallRecord> callingProvinceRecords = new ArrayList<>();
private ArrayList<CallRecord> callingInLandRecords = new ArrayList<>();
private ArrayList<CallRecord> answerInCityRecords = new ArrayList<>();
private ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<>();
private ArrayList<CallRecord> answerInLandRecords = new ArrayList<>();

private ArrayList<CallRecord> totalCallRecords = new ArrayList<>();
private ArrayList<CallRecord> totalAnswerRecords = new ArrayList<>();

public UserRecords() {
// TODO Auto-generated constructor stub
}

public ArrayList<CallRecord> getTotalAnswerRecords() {
return totalAnswerRecords;
}

public void addTotalAnswerRecords(CallRecord callrecord) {
this.totalAnswerRecords.add(callrecord);
}

public ArrayList<CallRecord> getTotalCallRecords() {
return totalCallRecords;
}

public void addTotalCallRecords(CallRecord callRecord) {
totalCallRecords.add(callRecord);
}

public ArrayList<CallRecord> getCallingCityRecords() {
return callingCityRecords;
}

public void addCallingCityRecords(CallRecord callRecord) {
this.callingCityRecords.add(callRecord);
}

public ArrayList<CallRecord> getCallingProvinceRecords() {
return callingProvinceRecords;
}

public void addCallingProvinceRecords(CallRecord callRecord) {
this.callingProvinceRecords.add(callRecord);
}

public ArrayList<CallRecord> getCallingInLandRecords() {
return callingInLandRecords;
}

public void addCallingInLandRecords(CallRecord callRecord) {
this.callingInLandRecords.add(callRecord);
}

public ArrayList<CallRecord> getAnswerInCityRecords() {
return answerInCityRecords;
}

public void addAnswerInCityRecords(CallRecord answerRecord) {
this.answerInCityRecords.add(answerRecord);
}

public ArrayList<CallRecord> getAnswerInProvinceRecords() {
return answerInProvinceRecords;
}

public void addAnswerInProvinceRecords(CallRecord answerRecord) {
this.answerInProvinceRecords.add(answerRecord);
}

public ArrayList<CallRecord> getAnswerInLandRecords() {
return answerInLandRecords;
}

public void addAnswerInLandRecords(CallRecord answerRecord) {
this.answerInLandRecords.add(answerRecord);
}

}

分析：这道题要运用到内部类，抽象类，接口等，通过内部类将不同的收费方式表现出来在通过接口使不同类继承公用的方法。增强了代码的复用性，还有就是要用容器将所有对象放进一个容器中。我认为这道题的最大难点就是制作出合适的接口。

第二题

原题：

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的购物券各消费一次，分别输出消费后商店剩下的牛奶箱数。

源代码：

import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
Shop shop = new Shop(in.nextInt());

shop.coupons50.buy();
System.out.println("牛奶还剩" + shop.getMilkCount() + "箱");
shop.coupons100.buy();
System.out.println("牛奶还剩" + shop.getMilkCount() + "箱");

}
}

class Shop {
private int milkCount;
InnerCoupons coupons50 = new InnerCoupons(50);
InnerCoupons coupons100 = new InnerCoupons(100);

public Shop(int milkCount) {
super();
this.milkCount = milkCount;
}

class InnerCoupons {
public int value;

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

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

}

public int getMilkCount() {
return milkCount;
}

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

}

分析：这道题较为简单，但是这道题一道经典的运用内部类的题目，运用内部类定义两种不同的购物卷，在分别计算能购买多少箱牛奶，能让我更好理解内部类的用法和作业。

实验

实验五用户图形界面

一、实验目的

1、了解JavaFX的基本原理和基本组件；

2、能够熟练应用JavaFX组件进行界面设计；

3、掌握Java的事件驱动机制、lambda表达式；

4、掌握shape形状类的使用。

二、实验要求

1、根据实验步骤中提出的要求，使用eclipse等开发工具编写相应的Java程序；

2、编译、运行自己所编写的Java程序；

3、根据编译与运行过程中所获得的错误信息修改程序直至获得正确的结果；

4、记录实验中遇到的各类问题并以及解决办法。

三、实验步骤

1、请修改实验四农夫过河游戏的代码，将用户界面改为图形界面，界面效果自行设计。

2、请画出修改后的类图，并说明在界面中使用了哪些技巧以达到较好地界面效果。

四、实验结果

五、实验小结

2部分代码：

public abstract class AbstractGame {

private AbstractRule gameOverRule = new GameOverRules();
private AbstractRule gameSuccessRule = new GameSuccessRule();
private AbstractGameData gameData = new AbstractGameData();

public abstract void play();

public AbstractRule getGameOverRule() {
return gameOverRule;
}

public void setGameOverRule(AbstractRule gameOverRule) {
this.gameOverRule = gameOverRule;
}

public AbstractRule getGameSuccessRule() {
return gameSuccessRule;
}

public void setGameSuccessRule(AbstractRule gameSuccessRule) {
this.gameSuccessRule = gameSuccessRule;
}

public AbstractGameData getGameData() {
return gameData;
}

public void setGameData(AbstractGameData gameData) {
this.gameData = gameData;
}

}

public class AbstractGameData {

private Animal wolf;
private Animal sheep;
private Person farmer;
private Plant cabbage;
private Boat boat;

public AbstractGameData() {
farmer = new Farmer();
cabbage = new Cabbage();
sheep = new Sheep(cabbage);
wolf = new Wolf(sheep);
boat = new Boat();
}

public Animal getWolf() {
return wolf;
}

public void setWolf(Animal wolf) {
this.wolf = wolf;
}

public Animal getSheep() {
return sheep;
}

public void setSheep(Animal sheep) {
this.sheep = sheep;
}

public Person getFarmer() {
return farmer;
}

public void setFarmer(Person farmer) {
this.farmer = farmer;
}

public Plant getCabbage() {
return cabbage;
}

public void setCabbage(Plant cabbage) {
this.cabbage = cabbage;
}

public Boat getBoat() {
return boat;
}

public void setBoat(Boat boat) {

分析：本题在原有的基础上运用javafx制作界面，我认为两大难点在于1.制作好stage，和编写鼠标函数使用户通过鼠标点击来确定自己的选项，2，在界面中添加图片，使界面更直观，这一点我做的并不好。

踩坑心得：通过这几次的实验和pta作业我发现，在接口，抽象类还有javafx发面学的并不好，在javafx方面，因为其中有太多方法，导致自己运用javafx制作的页面并不能达到好的效果。

总结：在一个学期的java学习中，我们学了封装，多态，抽象类，接口，容器，内部类，还有最后面的javafx，我在接口，javafx方面掌握的不好，这能在后几次的pta和实验中表现出来。而且这还是java的基础知识，我今后一定在这方面做出改善。

posted @ 2022-06-18 20:06 邹沅成阅读(163) 评论(0) 收藏举报

刷新页面返回顶部

zyc2002

第三次博客

输入格式:

输出格式:

公告