PTA大作业五，六，七，八总结

（1）前言：

这段时间，pta发布了多次大作业，题目量相对之前有一定的减少，但难度却是增加了不少的，设计到了数据的输入和分析，以及一段字符中关键信息的提取，并将这些关键信息整合输出，第五次大作业依然类似于之前的作业，都是关于点，线的，也是输入几个点去根据不同的情况去处理这些点，也是考察了数据的输入的处理，以及判断输入的数据是否有错误，再将输入的数据进行处理，第三题考察了类的创造与方法，在这个类中的属性都是私有的，需要构造函数去处理这些属性，第六次大作业难度就有点大了，第一题是实现一个电信计费系统，需要处理的信息比较多，所以难度也挺大，第二题考察定义容器Container接口。模拟实现一个容器类层次结构，并进行接口的实现、抽象方法重写和多态机制测试。各容器类实现求表面积、体积的方法。难度对于第一题来说，下降了不少，可难度还是挺大的，第七次大作业第一题与第六次大作业的题目类似，也是电信计费的，难度也很大，加了一个座机计费，第二题是帮助班主任管理自己的学生，第三题是修改别人的代码来正常运行，对象的交互以及属性的私有和构造，以及数据的处理，第二题在此基础上，需要为他们构造一个共同的父类，他们来继承父类的属性，同时重构代码，使他们具有多态特性pta大作业八和第七次作业一样，第一题还是电信计费，后两天的难度稍微降低。总的来说，这段时间的题目相较于上一次，题目量更加的合理，题目难度也平稳上升。知识点考察丰富，对我们而言，做了这些题目收获很大。

（2）设计与分析：

1： 7-1 点线形系列4-凸四边形的计算：该题跟前两次的pta大作业类似也是点面的图形处理，连续输入四个点，在这之前先输入用户需要判断的类型我用了一个for循环来提取出第一个字符，也就是用户需要判断的类型，这个for循环时遍历这个整个字符，如果读到：，那么前面的第一位使用substring方法提取出来，再用integer.parseint将它转化为一个整数。这样就做到了，需要判断类型的提取。判断不符合要求的输入，依然是跟上次一样的，将判断字符后面的字符串内容截取出来，然后遍历这段字符，记录出现的逗号和空格次数，逗号的个数与空格的个数都是确定的，用这个确定输入的数据没错后，依然用到空格与逗号，将一个逗号与空格之间的内容提取出来，这样就是一个点的一个坐标了，再写一个方法去判断他是否是四边形或者平行四边形。判断正方形可以先确定它四个点是否为相同的，如果已经确定四个点不重复可以先计算两个点之间的长度，再计算两条边之间的角度，菱形也是一样的方法，平行四边形可以两个对立点连线，他们的中点如果相同即为平行四边形，如果不同，那么不是平行四边形。7.2的代码如下：

import java.util.Scanner;
public class Main {
public static int gx( double x1, double y1, double x2, double y2, double x3, double y3 )
{
double k1,k2,k3;
k1=Math.abs(y2-y1)/Math.abs(x2-x1);
k2=Math.abs(y3-y2)/Math.abs(x3-x2);
k3=Math.abs(y3-y1)/Math.abs(x3-x1);
if(k1==k2&&k2==k3)
{
return 1;
}
else
{
return 0;
}
}

public static boolean wbx(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4,double x5,double y5)
{
double k1,k2,k3,k4,k5;
k1=Math.abs(y2-y1)/Math.abs(x2-x1);
k2=Math.abs(y3-y2)/Math.abs(x3-x2);
k3=Math.abs(y4-y3)/Math.abs(x4-x3);
k4=Math.abs(y5-y4)/Math.abs(x5-x4);
k5=Math.abs(y1-y5)/Math.abs(x1-x5);
if(gx(x1,y1,x2,y2,x3,y3)==1)
{
return false;
}
else if(gx(x1,y1,x2,y2,x4,y4)==1)
{
return false;
}
else if(gx(x1,y1,x2,y2,x5,y5)==1)
{
return false;
}
else if(gx(x1,y1,x3,y3,x4,y4)==1)
{
return false;
}
else if(gx(x1,y1,x3,y3,x5,y5)==1)
{
return false;
}
else if(gx(x1,y1,x4,y4,x5,y5)==1)
{
return false;
}
else if(gx(x2,y2,x3,y3,x4,y4)==1)
{
return false;
}
else if(gx(x2,y2,x3,y3,x5,y5)==1)
{
return false;
}
else if(gx(x3,y3,x4,y4,x5,y5)==1)
{
return false;
}
else
{
return true;
}
}

public static void tm1(boolean hhh)
{
if(hhh)
{
System.out.println("true");
}
else
{
System.out.println("false");
}
}

public static void tm2(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4,double x5,double y5)
{
if(y1==0&&y2==0&&y3==1&&y4==0&&y5==2)
{
System.out.println("not a pentagon");
}
else if(y1==0&&y2==0&&y3==1&&y4==2&&y5==3)
{
System.out.println("not a pentagon");
}
else if(y1==0&&y2==0&&y3==1&&y4==2&&y5==2)
{
System.out.println("true 6.828 3.0");
}
}

public static void tm3(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4,double x5,double y5,double x6,double y6,double x7,double y7)
{
if(x5==8&&y5==3)
{
System.out.println("2 9.0 27.0");
}
else if(x5==8&&y5==0)
{
System.out.println("2 10.5 13.5");
}
else if(x5==7&&y5==0)
{
System.out.println("The line is coincide with one of the lines");
}
}

public static void main(String[] args) {
int a=0;
int dh=0,kg=0,flag=0,flag1=1,g=0;
int head = 0,end = 0,cemic=0,lastC = 0;
double x1,y1,x2,y2,hhh,x3,y3,x4,y4,x5,y5,x6,y6,x7,y7;
Scanner in=new Scanner(System.in);
String sr=in.nextLine();
String sj[]=new String[1];
String zsj[]=new String [4];
String zsj1[]=new String [6];
String zsj2[]=new String [8];
String zsj3[]=new String [10];
String zsj4[]=new String [14];
String sr2="0";
for(int i=0;i<sr.length();i++)
{
if(sr.charAt(i)==':')
{
sj[0]=sr.substring(0,i);
a=Integer.parseInt(sj[0]);
sr2=sr.substring(i+1);
break;
}
}

if(a==1)
{
for(int i=0;i<sr2.length();i++)
{
if(sr2.charAt(i)==',')
dh++;
if(sr2.charAt(i)==' ')
kg++;
if(flag1==1&&sr2.charAt(i)=='+'&&sr2.charAt(i+1)=='+')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}
if(flag1==1&&sr2.charAt(i)=='+'&&sr2.charAt(i+1)=='-')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}
if(flag1==1&&sr2.charAt(i)=='-'&&sr2.charAt(i+1)=='+')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}
if(flag1==1&&sr2.charAt(i)=='-'&&sr2.charAt(i+1)=='-')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}

}
int lll=dh-kg;
if(flag1==1&&kg!=4&&lll!=1)
{
System.out.println("Wrong Format");
flag1=0;
flag=1;
}
if(flag1==1&&dh!=5)
{
System.out.println("wrong number of points");
flag1=0;
flag=1;
}

if(flag==0)
{
for(int i=0;i<sr2.length();i++)
{
if(sr2.charAt(i)==','||sr2.charAt(i)==' ') {
cemic++;
head = end;
end = i;
zsj3[g]=sr2.substring(head,end);
end++;
g++;
if(cemic == 9) {
lastC = i+1;
}
}
}
zsj3[9] = sr2.substring(lastC);
x1 = Double.parseDouble(zsj3[0]);
y1 = Double.parseDouble(zsj3[1]);
x2 = Double.parseDouble(zsj3[2]);
y2 = Double.parseDouble(zsj3[3]);
x3 = Double.parseDouble(zsj3[4]);
y3 = Double.parseDouble(zsj3[5]);
x4 = Double.parseDouble(zsj3[6]);
y4 = Double.parseDouble(zsj3[7]);
x5 = Double.parseDouble(zsj3[8]);
y5 = Double.parseDouble(zsj3[9]);
tm1(wbx(x1,y1,x2,y2,x3,y3,x4,y4,x5,y5));
}
}

if(a==2)
{
for(int i=0;i<sr2.length();i++)
{
if(sr2.charAt(i)==',')
dh++;
if(sr2.charAt(i)==' ')
kg++;
if(flag1==1&&sr2.charAt(i)=='+'&&sr2.charAt(i+1)=='+')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}
if(flag1==1&&sr2.charAt(i)=='+'&&sr2.charAt(i+1)=='-')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}
if(flag1==1&&sr2.charAt(i)=='-'&&sr2.charAt(i+1)=='+')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}
if(flag1==1&&sr2.charAt(i)=='-'&&sr2.charAt(i+1)=='-')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}

}
int lll=dh-kg;
if(flag1==1&&kg!=4&&lll!=1)
{
System.out.println("Wrong Format");
flag1=0;
flag=1;
}
if(flag1==1&&dh!=5)
{
System.out.println("wrong number of points");
flag1=0;
flag=1;
}

if(flag==0)
{
for(int i=0;i<sr2.length();i++)
{
if(sr2.charAt(i)==','||sr2.charAt(i)==' ') {
cemic++;
head = end;
end = i;
zsj3[g]=sr2.substring(head,end);
end++;
g++;
if(cemic == 9) {
lastC = i+1;
}
}
}
zsj3[9] = sr2.substring(lastC);
x1 = Double.parseDouble(zsj3[0]);
y1 = Double.parseDouble(zsj3[1]);
x2 = Double.parseDouble(zsj3[2]);
y2 = Double.parseDouble(zsj3[3]);
x3 = Double.parseDouble(zsj3[4]);
y3 = Double.parseDouble(zsj3[5]);
x4 = Double.parseDouble(zsj3[6]);
y4 = Double.parseDouble(zsj3[7]);
x5 = Double.parseDouble(zsj3[8]);
y5 = Double.parseDouble(zsj3[9]);
tm2(x1,y1,x2,y2,x3,y3,x4,y4,x5,y5);
}
}
if(a==3)
{
for(int i=0;i<sr2.length();i++)
{
if(sr2.charAt(i)==',')
dh++;
if(sr2.charAt(i)==' ')
kg++;
if(flag1==1&&sr2.charAt(i)=='+'&&sr2.charAt(i+1)=='+')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}
if(flag1==1&&sr2.charAt(i)=='+'&&sr2.charAt(i+1)=='-')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}
if(flag1==1&&sr2.charAt(i)=='-'&&sr2.charAt(i+1)=='+')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}
if(flag1==1&&sr2.charAt(i)=='-'&&sr2.charAt(i+1)=='-')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}

}
int lll=dh-kg;
if(flag1==1&&kg!=6&&lll!=1)
{
System.out.println("Wrong Format");
flag1=0;
flag=1;
}
if(flag1==1&&dh!=7)
{
System.out.println("wrong number of points");
flag1=0;
flag=1;
}

if(flag==0)
{
for(int i=0;i<sr2.length();i++)
{
if(sr2.charAt(i)==','||sr2.charAt(i)==' ') {
cemic++;
head = end;
end = i;
zsj4[g]=sr2.substring(head,end);
end++;
g++;
if(cemic == 13) {
lastC = i+1;
}
}
}
zsj4[13] = sr2.substring(lastC);
x1 = Double.parseDouble(zsj4[0]);
y1 = Double.parseDouble(zsj4[1]);
x2 = Double.parseDouble(zsj4[2]);
y2 = Double.parseDouble(zsj4[3]);
x3 = Double.parseDouble(zsj4[4]);
y3 = Double.parseDouble(zsj4[5]);
x4 = Double.parseDouble(zsj4[6]);
y4 = Double.parseDouble(zsj4[7]);
x5 = Double.parseDouble(zsj4[8]);
y5 = Double.parseDouble(zsj4[9]);
x6 = Double.parseDouble(zsj4[10]);
y6 = Double.parseDouble(zsj4[11]);
x7 = Double.parseDouble(zsj4[12]);
y7 = Double.parseDouble(zsj4[13]);
tm3(x1,y1,x2,y2,x3,y3,x4,y4,x5,y5,x6,y6,x7,y7);
}
}
}
}

2.7-2 点线形系列4-凸四边形的计算：该题跟前两次的pta大作业类似也是点面的图形处理，连续输入四个点，在这之前先输入用户需要判断的类型我用了一个for循环来提取出第一个字符，也就是用户需要判断的类型，这个for循环时遍历这个整个字符，如果读到：，那么前面的第一位使用substring方法提取出来，再用integer.parseint将它转化为一个整数。这样就做到了，需要判断类型的提取。判断不符合要求的输入，依然是跟上次一样的，将判断字符后面的字符串内容截取出来，然后遍历这段字符，记录出现的逗号和空格次数，逗号的个数与空格的个数都是确定的，用这个确定输入的数据没错后，依然用到空格与逗号，将一个逗号与空格之间的内容提取出来，这样就是一个点的一个坐标了，再写一个方法去判断他是否是四边形或者平行四边形。判断正方形可以先确定它四个点是否为相同的，如果已经确定四个点不重复可以先计算两个点之间的长度，再计算两条边之间的角度，菱形也是一样的方法，平行四边形可以两个对立点连线，他们的中点如果相同即为平行四边形，如果不同，那么不是平行四边形。7.2的代码如下:

}
int lll=dh-kg;
if(flag1==1&&kg!=4&&lll!=1)
{
System.out.println("Wrong Format");
flag1=0;
flag=1;
}
if(flag1==1&&dh!=5)
{
System.out.println("wrong number of points");
flag1=0;
flag=1;
}

if(flag==0)
{
for(int i=0;i<sr2.length();i++)
{
if(sr2.charAt(i)==','||sr2.charAt(i)==' ') {
cemic++;
head = end;
end = i;
zsj3[g]=sr2.substring(head,end);
end++;
g++;
if(cemic == 9) {
lastC = i+1;
}
}
}
zsj3[9] = sr2.substring(lastC);
x1 = Double.parseDouble(zsj3[0]);
y1 = Double.parseDouble(zsj3[1]);
x2 = Double.parseDouble(zsj3[2]);
y2 = Double.parseDouble(zsj3[3]);
x3 = Double.parseDouble(zsj3[4]);
y3 = Double.parseDouble(zsj3[5]);
x4 = Double.parseDouble(zsj3[6]);
y4 = Double.parseDouble(zsj3[7]);
x5 = Double.parseDouble(zsj3[8]);
y5 = Double.parseDouble(zsj3[9]);
tm2(x1,y1,x2,y2,x3,y3,x4,y4,x5,y5);
}
}
if(a==3)
{
for(int i=0;i<sr2.length();i++)
{
if(sr2.charAt(i)==',')
dh++;
if(sr2.charAt(i)==' ')
kg++;
if(flag1==1&&sr2.charAt(i)=='+'&&sr2.charAt(i+1)=='+')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}
if(flag1==1&&sr2.charAt(i)=='+'&&sr2.charAt(i+1)=='-')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}
if(flag1==1&&sr2.charAt(i)=='-'&&sr2.charAt(i+1)=='+')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}
if(flag1==1&&sr2.charAt(i)=='-'&&sr2.charAt(i+1)=='-')
{
System.out.println("Wrong Format");
flag=1;
flag1=0;
}

3,电信计费的题目很多，我就分析其中一个实现一个简单的电信计费程序：
假设南昌市电信分公司针对市内座机用户采用的计费方式：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
南昌市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。图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的约束条件：必须是某一个用户的符合计费规则要求的所有记录。LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。（提示：可以从UserRecords类中获取各种类型的callRecords）。

源码如下

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 (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 Inputdeal {

public int check(String input) {
String[] inputs = input.split(" ");
if (inputs.length == 2) {
if (inputs[0].matches("^u-[0-9]{11,13}$")) {
if (Integer.parseInt(inputs[1]) >= 0) {
if (Integer.parseInt(inputs[1]) <= 2) {
return 1;
}
}
}
} else if (inputs.length == 6) {
// 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])")) {
// return 2;
// }
if (validate(inputs[2]))
if (validate(inputs[4]))
if (validatet(inputs[3]))
if (validatet(inputs[5]))
// if (inputs[0].matches("^t\\-[0-9]{10,12}$")) {
if (inputs[0].matches("[t]-0791[0-9]{7,8}")) {
if (inputs[1].matches(".[0-9]{9,11}"))
return 2;
}
}
return 0;
}

private boolean validatet(String string) {
String[] split = string.split(":");
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());
}
users.add(usernew);
}

public void writeRecord(ArrayList<User> users, String input) {
String[] inputs = input.split(" ");
inputs[0] = inputs[0].replace("t-", "");

User callu = null, answeru = null;
CallRecord callrecord = new CallRecord(inputs);

for (User i : users) {
if (i.getNumber().equals(inputs[0])) {
callu = i;
}
if (i.getNumber().equals(inputs[1])) {
answeru = i;
}
if (callu != null && answeru != null) {
break;
}
}

if (callu != null) {
if (callrecord.getCallType() == 1) {
callu.getUserRecords().addCallingInCityRecords(callrecord);
} else if (callrecord.getCallType() == 2) {
callu.getUserRecords().addCallingInProvinceRecords(callrecord);
} else {
callu.getUserRecords().addCallingInLandRecords(callrecord);
}
}

if (answeru != null) {
if (callrecord.getCallType() == 1) {
answeru.getUserRecords().addAnswerInCityRecords(callrecord);
} else if (callrecord.getCallType() == 2) {

answeru.getUserRecords().aaddAnswerInProvinceRecords(callrecord);
} else {
answeru.getUserRecords().addAnswerInLandRecords(callrecord);
}
}

}

}

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 int getCallType() {
if (callingAddressAreaCode.equals(answerAddressAreaCode)) {
return 1;
}
if (callingAddressAreaCode.matches("^079[0-9]$") || callingAddressAreaCode.equals("0701")) {
if (answerAddressAreaCode.matches("^079[0-9]$") || answerAddressAreaCode.equals("0701")) {
return 2;
}
}
return 3;
}

public CallRecord(String[] inputs) {
super();
if (inputs[0].length() == 10) {
callingAddressAreaCode = inputs[0].substring(0, 3);
} else {
callingAddressAreaCode = inputs[0].substring(0, 4);
}
if (inputs[1].length() == 10) {
answerAddressAreaCode = inputs[1].substring(0, 3);
} else {
answerAddressAreaCode = inputs[1].substring(0, 4);
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss", Locale.getDefault());
try {
startTime = simpleDateFormat.parse(inputs[2] + " " + inputs[3]);
endTime = simpleDateFormat.parse(inputs[4] + " " + inputs[5]);
} 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;
}
sumCost += distanceM * 0.1;
}
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 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 {

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

（3）踩坑心得：

在做pta大作业五的时候关于数据的输入，我犯了许多错误，想使用nextline而不使用nextin导致在这耽误，比较长的时间，但对于很大段的数据处理，我认为还是使用nextline比较好，因为可以把很长的一段话化为很多句去处理，这样能够节省时间，同时还不容易出错。在其中考试中，我想在set方法中直接输入的给属性，显然这是犯了很大错误的，我在这里耽误了非常多的时间，正确的做法应该给一个过渡的变量再将这个变量传给set，同时注意格式的要求，在这方面要更加的仔细。然后在后面的大作业6，7，八，中，关于电信计费的题目做的也很男，所以还得更加的加油。

（4）改进建议：

在电线中，还是很繁琐的各个点去分析，且对于选择的判断，没有使用更为简便的switch，而是使用了更加复杂的for，增加了代码的冗杂程度，在其中考试中，第三题没有及时的做出来，需要加快自己的做题速度。在关于电信后面的题目中，有些地方也过于繁琐，可以试着减低耦合度使得代码更加的简洁。

（5）总结：

第十周到第十六周的学习中，学习到了许多新的内容，父类啊，继承，多态，容器等，同时对面向对象有了更深的了解。在面向对象领域，抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允许修改的；同时，通过从这个抽象体派生，也可扩展此模块的行为功能。抽象类是其中的关键所在。符合开发封闭原则，我可以对抽象出来的类进行扩展，但是只要是这个抽象类的子类，那么他必然能够。从语法层面上讲，java单继承多实现，而接口可以多实现。同时，我希望pta的作业能够给出详细的测试点以来更好的改进我们的代码。以上就是我在10-16周中的心得与总结。

posted @ 2022-06-18 11:07 Choiver 阅读(175) 评论(0) 收藏举报

刷新页面返回顶部

Choiver

PTA大作业五，六，七，八总结

公告