BLOG-3
一，前言
这是本学期的最后一次博客。第六，七，八次大作业的题量较之前的大作业并没有很大的变化。除第六次大作业是两道题以外，其他都是三道题。主要考查了接口，内部类，抽象类等知识点。其中电信收费的题目在三次pta中都出现，但每次都在前一次的基础上加上新的东西，层层深入。电信计费的设计问题，老师巧妙的通过三道题，层层递进
的考察了java面向对象的“继承”这一用法，继承首先需要一个“是”（is-a）关系，通过继承，可以极大的减少代码的复用，使代码看上去简洁，便于维护，继承是java面向对象
编程技术的一块基石，因为它允许创建分等级层次的类。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，
使得子类具有父类相同的行为。多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作。在电信计费的计费规则中
有集中体现。
二，设计与分析
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
输入样例:
在这里给出一组输入。例如：
u-079186300001 0
t-079186300001 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:25
end
输出样例:
在这里给出相应的输出。例如：
079186300001 3.0 77.0
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
//import snippet.CallRecord;
//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)
{
Inputdeal inputdeal = new Inputdeal();
ArrayList<User> users = new ArrayList<>();
Scanner in = new Scanner(System.in);
String input = in.nextLine();
while (!input.matches("end")) {
if (inputdeal.inputdeal(input)==1) {
inputdeal.writeUser(users, input);
} else if (inputdeal.inputdeal(input)==2) {
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());
System.out.print(" ");
System.out.printf("%.1f",u.calCost());
System.out.print(" ");
System.out.printf("%.1f",u.calBalance());
System.out.println();
}
}
}
abstract class ChargeMode//计费方式的抽象类
{
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)
{
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 sum = 0;
for (ChargeRule rule : chargeRules) {
sum = sum+rule.calCost(userRecords);
}
return sum;
}
@Override
public double getMonthlyRent() {
return monthlyRent;
}
}
class LandPhoneInCityRule extends ChargeRule//市内0.1元/分
{
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double cost=0;
int i=0;
for(CallRecord call : userRecords.getCallingInCityRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
// cost=cost+totaltime*0.1;
if(call.getCallType().matches("11"))
cost=cost+totaltime*0.1;
if(call.getCallType().matches("12"))
cost=cost+totaltime*0.3;
if(call.getCallType().matches("13"))
cost=cost+totaltime*0.6;
}
return cost;
}
}
class LandPhoneInlandRule extends ChargeRule//国内0.6元/分
{
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double cost=0;
int i=0;
for(CallRecord call : userRecords.getCallingInLandRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=cost+totaltime*0.6;
}
return cost;
}
}
class LandPhoneInProvinceRule extends ChargeRule//省内0.3元/分
{
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double cost=0;
int i=0;
for(CallRecord call : userRecords.getCallingInProvinceRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=cost+totaltime*0.3;
}
return cost;
}
}
class Inputdeal//输入处理，塞到main类里去
{
public int inputdeal (String s)//检查输入的字符串
{
if (s.matches("[u]-0791[0-9]{7,8}\\s[0]") || s.matches("[u]-1[0-9]{10}\\s[1]"))
return 1;
else if(s.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;
}
private boolean validatet(String s)//判断时间
{
if (!s.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)
{
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] = 28;
} else
{
monthLengths[2] = 29;
}
int mLength = monthLengths[month];
//判断日期是否合法
if (day < 1 || day > mLength)
{
return false;
}
return true;
}
//判断是否为闰年
private static boolean isLeapYear(int year) {
if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
return true;
else
return false;
}
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().matches(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(" ");
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().matches(out)) {
callu = i;
}
if (i.getNumber().matches(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//抽象的通讯记录类
{
String callingNumber; //拨打号码
String answerNumber; //接听号码
public void setcallingNumber(String callingNumber)
{
this.callingNumber=callingNumber;
}
public String getcallingNumber()
{
return callingNumber;
}
public void setanswerNumber(String answerNumber)
{
this.answerNumber=answerNumber;
}
public String getanswerNumber()
{
return answerNumber;
}
}
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.matches("0791"))
type="1";
else if(callingAddressAreaCode.matches("^079[023456789]$") || callingAddressAreaCode.equals("0701"))
type="2";
else
type="3";
if(answerAddressAreaCode.matches("0791"))
type="1";
else if(answerAddressAreaCode.matches("^079[023456789]$") || answerAddressAreaCode.equals("0701"))
type="2";
else
type="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;
}*/
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 ="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//计费规则
{
public double calCost(ArrayList<CallRecord> callRecord)
{
return 1;
}
}
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;
}
}
踩坑心得：
这是我第一次错误的正则表达式
String regex_u = "^u+(-)+[0-9]{11,12}\\s+[0-2]$";//开户格式的判断正则表达式
Pattern pattern_u = Pattern.compile(regex_u);
String regex_t = "^t+(-)+[0-9]{11,12}\\s+[0-9]{11,12}\\s+[0-9]{4}+(.)+((0?[1-9])|([10-12]))+(.)+[0-9]{1,2}\\s+[0-9]{4}+(.)+((0?[1-9])|([10-12]))+(.)+[0-9]{1,2}$";
Pattern pattern_t = Pattern.compile(regex_t);
这是第二次电信计费题我的满分正则表达式
String regexLandToMobile = "^t-([0][0-9]{9,11})\\s([1][0-9]{10})\\s([0-9]{3,5})\\s[0-9]{4}(.)((0?[1-9])|([10-12]))+(.)+[0-9]{1,2}\\s+[0-9]{4}+(.)+((0?[1-9])|([10-12]))+(.)+[0-9]{1,2}$";
String regexLandToLand = "^t-([0][0-9]{9,11})\\s([0][0-9]{9,11})\\s[0-9]{4}(.)((0?[1-9])|([10-12]))+(.)+[0-9]{1,2}\\s+[0-9]{4}+(.)+((0?[1-9])|([10-12]))+(.)+[0-9]{1,2}$";
String regexMobileToLand = "^t-([1][0-9]{10})\\s([0-9]{3,5})\\s([0][0-9]{9,11})\\s[0-9]{4}(.)((0?[1-9])|([10-12]))+(.)+[0-9]{1,2}\\s+[0-9]{4}+(.)+((0?[1-9])|([10-12]))+(.)+[0-9]{1,2}$";
String regexMobileToMobile = "[t]-1[0-9]{10}\\s[0-9]{3,4}\\s1[0-9]{10}\\s[0-9]{3,4}\\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])";//"^t-([1][0-9]{10})\\s([0-9]{3,5})\\s([1][0-9]{10})\\s([0-9]{3,5})\\s[0-9]{4}(.)((0?[1-9])|([10-12]))+(.)+[0-9]{1,2}\\s+[0-9]{4}+(.)+((0?[1-9])|([10-12]))+(.)+[0-9]{1,2}$";
这是第三次满分的正则表达式：
String regexUser = "^u-([1][0-9]{10})\\s[3]$";
String regexMessage = "^m-1[0-9]{10}\\s1[0-9]{10}\\s(\\w|\\s|,|[.])+$";
定义容器Container接口。模拟实现一个容器类层次结构，并进行接口的实现、抽象方法重写和多态机制测试。各容器类实现求表面积、体积的方法。
- 定义接口Container：
属性：
public static final double pi=3.1415926;
抽象方法:
public abstract double area();
public abstract double volume();
static double sumofArea(Container c[]);
static double sumofVolume(Container c[]);
其中两个静态方法分别计算返回容器数组中所有对象的面积之和、周长之和； - 定义Cube类、Cylinder类均实现自Container接口。
Cube类(属性：边长double类型)、Cylinder类(属性：底圆半径、高，double类型)。
输入格式:
第一行n表示对象个数，对象类型用cube、cylinder区分，cube表示立方体对象，后面输入边长，输入cylinder表示圆柱体对象，后面是底圆半径、高。
输出格式:
分别输出所有容器对象的表面积之和、体积之和，结果保留小数点后2位。
输入样例:
在这里给出一组输入。例如：
4
cube
15.7
cylinder
23.5 100
cube
46.8
cylinder
17.5 200
输出样例:
在这里给出相应的输出。例如：
56771.13 472290.12
设计与分析：
import java.util.Scanner;
public class Main {
public static void main(String[] args)
{
Scanner input=new Scanner(System.in);
int a=input.nextInt();
Object[] list=new Object[a];
for(int i=0;i<a;i++)
{
String s1=input.next();
if(s1.matches("cube"))
list[i]=new Cube(input.nextDouble());
else if(s1.matches("cylinder"))
list[i]=new Cylinder(input.nextDouble(),input.nextDouble());
}
double sumofArea=0.0;
double sumofVolume=0.0;
for(Object i:list)
{
sumofArea=sumofArea+i.area();
sumofVolume=sumofVolume+i.volume();
}
System.out.printf("%.2f\n%.2f",sumofArea,sumofVolume);
}
}
interface Container
{
public static final double pi=3.1415926;
public abstract double area();
public abstract double volume();
static double sumofArea(Container c[])
{
double sumofArea=0;
for(Container i: c)
sumofArea=sumofArea+i.area();
return sumofArea;
}
static double sumofVolume(Container c[])
{
//return 0;
double sumofVolume=0;
for(Container i: c)
sumofVolume=sumofVolume+i.volume();
return sumofVolume;
}
}
abstract class Object implements Container
{
}
class Cube extends Object
{
private double x;
double area;
double volume;
public Cube(double x)
{
this.x=x;
}
public void setx( double x)
{
this.x=x;
}
public double getx()
{
return x;
}
@Override
public double area() {
// TODO Auto-generated method stub
area=6*getx()*getx();
return area;
}
@Override
public double volume() {
// TODO Auto-generated method stub
volume=getx()*getx()*getx();
return volume;
}
}
class Cylinder extends Object
{
private double r;
private double h;
double area;
double volume;
public Cylinder(double r,double h)
{
super();
this.r=r;
this.h=h;
}
public void setx( double r)
{
this.r=r;
}
public double getr()
{
return r;
}
public void seth( double h)
{
this.h=h;
}
public double geth()
{
return h;
}
@Override
public double area() {
// TODO Auto-generated method stub
area=2*pi*getr()*geth()+2*pi*getr()*getr();
return area;
}
@Override
public double volume() {
// TODO Auto-generated method stub
volume=pi*getr()*getr()*geth();
return volume;
}
}
实现南昌市电信分公司的计费程序，假设该公司针对手机和座机用户分别采取了两种计费方案，分别如下：
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
输出样例:
在这里给出相应的输出。例如：
13811111111 3.0 82.0
设计与分析：
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)
{
Inputdeal inputdeal = new Inputdeal();
ArrayList<User> users = new ArrayList<>();
Scanner in = new Scanner(System.in);
String input = in.nextLine();
while (!input.matches("end")) {
if ( inputdeal.inputdeal(input)==1) {
inputdeal.writeUser(users, input);
}
else if (inputdeal.inputdeal(input)==2)
{
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());
System.out.print(" ");
System.out.printf("%.1f",u.calCost());
System.out.print(" ");
System.out.printf("%.1f",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 sum = 0;
for (ChargeRule rule : chargeRules) {
sum = sum+rule.calCost(userRecords);
}
return sum;
}
@Override
public double getMonthlyRent() {
return monthlyRent;
}
}
class MobilePhoneCharging extends ChargeMode//手机缴费
{
private double monthlyRent = 15;
public MobilePhoneCharging() {
super();
chargeRules.add(new MobilePhoneIncityRule());
//chargeRules.add(new MobilePhoneInLandRule());
chargeRules.add(new MobilePhoneInProvinceRule());
chargeRules.add(new MobilePhoneInLandRule());
}
@Override
public double calCost(UserRecords userRecords) {
double sum = 0;
for (ChargeRule rule : chargeRules) {
sum = sum+rule.calCost(userRecords);
}
return sum;
}
@Override
public double getMonthlyRent() {
return monthlyRent;
}
}
class Inputdeal//输入处理
{
public int inputdeal (String s)//检查输入的字符串
{
if (s.matches("[u]-0791[0-9]{7,8}\\s[0]") || s.matches("[u]-1[0-9]{10}\\s[1]"))
return 1;
else if(s.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;
}
private boolean validatet(String s)//判断时间
{
if (!s.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)
{
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] = 28;
} else
{
monthLengths[2] = 29;
}
int mLength = monthLengths[month];
//判断日期是否合法
if (day < 1 || day > mLength)
{
return false;
}
return true;
}
//判断是否为闰年
private static boolean isLeapYear(int year) {
if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
return true;
else
return false;
}
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().matches(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().matches(out))
{
callu = i;
}
if (i.getNumber().matches(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 ChargeRule//市内0.1元/分
{
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double cost=0;
int i=0;
for(CallRecord call : userRecords.getCallingInCityRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
if(call.getCallType().matches("11"))
cost=cost+totaltime*0.1;
if(call.getCallType().matches("12"))
cost=cost+totaltime*0.3;
if(call.getCallType().matches("13"))
cost=cost+totaltime*0.6;
}
return cost;
}
}
class LandPhoneInlandRule extends ChargeRule//国内0.6元/分
{
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double cost=0;
int i=0;
for(CallRecord call : userRecords.getCallingInLandRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=cost+totaltime*0.6;
}
return cost;
}
}
class LandPhoneInProvinceRule extends ChargeRule//省内0.3元/分
{
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double cost=0;
int i=0;
for(CallRecord call : userRecords.getCallingInProvinceRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=cost+totaltime*0.3;
}
return cost;
}
}
class MobilePhoneIncityRule extends ChargeRule//市内打/接
{
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double cost=0;
int i=0;
for(CallRecord call : userRecords.getCallingInCityRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
//cost=cost+totaltime*0.1;
if(call.getCallType().equals("11"))
cost=cost+totaltime*0.1;
else if(call.getCallType().equals("12"))
cost=cost+totaltime*0.2;
else if(call.getCallType().equals("13"))
cost=cost+totaltime*0.3;
}
/*for(CallRecord call : userRecords.getAnswerInCityRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=0.0;
}*/
return cost;
}
}
class MobilePhoneInProvinceRule extends ChargeRule//省内漫游（无论打哪里）
{
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double cost=0;
int i=0;
for(CallRecord call : userRecords.getCallingInProvinceRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=cost+totaltime*0.3;
/* if(call.getCallType().equals("21"))
cost=cost+totaltime*0.3;
else if(call.getCallType().equals("22"))
cost=cost+totaltime*0.3;
else if(call.getCallType().equals("23"))
cost=cost+totaltime*0.3; */
}
/*for(CallRecord call : userRecords.getAnswerInProvinceRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=0.0;
}*/
return cost;
}
}
class MobilePhoneInLandRule extends ChargeRule//省外
{
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double cost=0;
int i=0;
for(CallRecord call : userRecords.getCallingInLandRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=cost+totaltime*0.6;
/* if(call.getCallType().equals("31"))
cost=cost+totaltime*0.6;
else if(call.getCallType().equals("32"))
cost=cost+totaltime*0.6;
else if(call.getCallType().equals("33"))
cost=cost+totaltime*0.6; */
}
for(CallRecord call : userRecords.getAnswerInLandRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=cost+totaltime*0.3;
}
return cost;
}
}
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;
}
}
踩坑心得：
第一次提交的时候有很多测试点过不了，后来检查很久，通过一个个可能性排查发现是时间特判上发生了错误，导致在计算话费的时候总是出错。还有本次代码主要是在上一次的基础上再添一些东西，有了上一次的铺垫，这一次会显得好做一些。 改进建议：这一次代码同样很长，代码的复用就显得十分重要。一开始我并没有把这一点看得很重要，这就使得我的代码过于冗长，最后不得不重新构造类与类之间的关系，精简代码。还有就是通过写这类题目，我深感自己平时写题的经验不足，对于容器，接口乃至正则表达式这些知识点用得不是很熟练。所以我打算以后多多练习代码，所谓孰能生巧，期待下一次碰到这类题时能够得心应手。 7-2 sdut-Collection-sort--C~K的班级（II） 分数 10 作者 周雪芹 单位 山东理工大学经过不懈的努力，C~K终于当上了班主任。
现在他要统计班里学生的名单，但是C~K在教务系统中导出班级名单时出了问题，发现会有同学的信息重复，现在他想把重复的同学信息删掉，只保留一个，
但是工作量太大了，所以找到了会编程的你，你能帮他解决这个问题吗？
输入格式:
第一行输入一个N，代表C~K导出的名单共有N行（N<100000）.
接下来的N行，每一行包括一个同学的信息，学号 姓名 年龄 性别。
输出格式:
第一行输出一个n，代表删除重复名字后C~K的班级共有几人。
接下来的n行，输出每一个同学的信息，输出按照学号从小到大的顺序。
输入样例:
6
0001 MeiK 20 M
0001 MeiK 20 M
0002 sdk2 21 M
0002 sdk2 21 M
0002 sdk2 21 M
0000 blf2 22 F
输出样例:
3 0000 blf2 22 F 0001 MeiK 20 M 0002 sdk2 21 M
设计与分析：
import java.util.Scanner;
import java.util.HashSet;
import java.util.ArrayList;
import java.util.Collections;
public class Main
{
public static void main(String []args)
{
Scanner input=new Scanner(System.in);
HashSet<Student>students=new HashSet<>();
int n;
n=input.nextInt();
int i=0;
for(i=0;i<n;i++)
{
//Student s;
//s=new Student(input.next(),input.next(),input.next(),input.next());
students.add(new Student(input.next(),input.next(),input.next(),input.next()));
}
System.out.println(students.size());
ArrayList<Student> studentArrayList=new ArrayList<>(students);
Collections.sort(studentArrayList);
for(Student student:studentArrayList)
System.out.println(student);
}
}
class Student implements Comparable<Student>
{
private String xuehao;
private String name;
private String age;
private String sex;
public void setxuehao(String a)
{
xuehao=a;
}
public String getxuehao()
{
return xuehao;
}
public void setname(String a)
{
name=a;
}
public String getname()
{
return name;
}
public void setage(String a)
{
age=a;
}
public String getage()
{
return age;
}
public void setsex(String a)
{
sex=a;
}
public String getsex()
{
return sex;
}
public Student(String xuehao,String name,String age,String sex)
{
this.xuehao=xuehao;
this.name=name;
this.age=age;
this.sex=sex;
}
@Override
public int compareTo(Student o) {
// TODO Auto-generated method stub
int b=0;
b=Integer.compare(Integer.parseInt(getxuehao()),Integer.parseInt(o.getxuehao()) );
return b;
}
public boolean equals(Object o)
{
return getxuehao().equals(((Student)o).getxuehao());
}
public String toString()
{
return xuehao+" "+name+" "+age+" "+sex;
}
public int hashCode()
{
int s = 0;
s=Integer.parseInt(getxuehao());
return s;
}
}
功能需求：
使用集合存储3个员工的信息（有序);
通过迭代器依次找出所有的员工。
提示：学生复制以下代码到编程区，并按需求进行调试修改。
// 1、导入相关包
//定义员工类
class Employee {
private String name;
private int age;
public Employee() {
super();
}
public Employee(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//主函数
public class Main {
public static void main(String[] args) {
// 1、创建有序集合对象
Collection c ;
// 创建3个员工元素对象
for (int i = 0; i < 3; i++) {
Scanner sc = new Scanner(System.in);
String employeeName = sc.nextLine();
int employeeAge = sc.nextInt();
Employee employee = new Employee(employeeName, employeeAge);
c.add(employee);
}
// 2、创建迭代器遍历集合
Iterator it;
//3、遍历
while (it.hasnext) {
//4、集合中对象未知，向下转型
Employee e = it.next();
System.out.println(e.getName() + "---" + e.getAge());
}
}
}
输入样例:
在这里给出一组输入。例如：
zs
10
ls
20
ww
30
输出样例:
在这里给出相应的输出。例如：
zs---10
ls---20
ww---30
设计与分析：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Collection;
//1、导入相关包
//定义员工类
class Employee {
private String name;
private int age;
public Employee() {
super();
}
public Employee(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//主函数
class Main {
public static void main(String[] args) {
// 1、创建有序集合对象
Collection c=new ArrayList<Employee>();
// 创建3个员工元素对象
for (int i = 0; i < 3; i++)
{
Scanner sc = new Scanner(System.in);
String employeeName = sc.next();
int employeeAge = sc.nextInt();
Employee employee = new Employee(employeeName, employeeAge);
c.add(employee);
}
// 2、创建迭代器遍历集合
Iterator<Employee> it= c.iterator();
//3、遍历
while (it.hasNext()) {
//4、集合中对象未知，向下转型
Employee e = (Employee)it.next();
System.out.println(e.getName() + "---" + e.getAge());
}
}
}
实现一个简单的电信计费程序，针对手机的短信采用如下计费方式：
1、接收短信免费，发送短信0.1元/条，超过3条0.2元/条，超过5条0.3元/条。
2、如果一次发送短信的字符数量超过10个，按每10个字符一条短信进行计算。
输入：
输入信息包括两种类型
1、逐行输入南昌市手机用户开户的信息，每行一个用户。
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐 3-手机短信计费）
例如：u-13305862264 3
座机号码由区号和电话号码拼接而成，电话号码包含7-8位数字，区号最高位是0。
手机号码由11位数字构成，最高位是1。
本题只针对类型3-手机短信计费。
2、逐行输入本月某些用户的短信信息，短信的格式：
m-主叫号码，接收号码，短信内容 （短信内容只能由数字、字母、空格、英文逗号、英文句号组成）
m-18907910010 13305862264 welcome to jiangxi.
m-13305862264 18907910010 thank you.
注意：以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
输出：
根据输入的详细短信信息，计算所有已开户的用户的当月短信费用（精确到小数点后2位，单位元）。假设每个用户初始余额是100元。
每条短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
本题只做格式的错误判断，无需做内容上不合理的判断，比如同一个电话两条通讯记录的时间有重合、开户号码非南昌市的号码、自己给自己打电话等，此类情况都当成正确的输入计算。但时间的输入必须符合要求，比如不能输入2022.13.61 28:72:65。
本题只考虑短信计费，不考虑通信费用以及月租费。
建议类图：
参见图1、2、3：
图1
图1中User是用户类，包括属性：
userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。
ChargeMode是计费方式的抽象类：
chargeRules是计费方式所包含的各种计费规则的集合，ChargeRule类的定义见图3。
getMonthlyRent（）方法用于返回月租（monthlyRent）。
UserRecords是用户记录类，保存用户各种通话、短信的记录，
各种计费规则将使用其中的部分或者全部记录。
其属性从上到下依次是：
市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
以及发送短信、接收短信的记录。
图2
图2中CommunicationRecord是抽象的通讯记录类：
包含callingNumber拨打号码、answerNumber接听号码两个属性。
CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。
图3
图3是计费规则的相关类，这些类的核心方法是：
calCost（ArrayList callRecords）。
该方法针根据输入参数callRecords中的所有记录计算某用户的某一项费用；如市话费。
输入参数callRecords的约束条件：必须是某一个用户的符合计费规则要求的所有记录。
SendMessageRule是发送短信的计费规则类，用于计算发送短信的费用。
LandPhoneInCityRule、LandPhoneInProvinceRule、LandPhoneInLandRule三个类分别是座机拨打市内、省内、省外电话的计费规则类，用于实现这三种情况的费用计算。
（提示：可以从UserRecords类中获取各种类型的callRecords）。
注意：以上图中所定义的类不是限定要求，根据实际需要自行补充或修改。
输入样例:
在这里给出一组输入。例如：
u-18907910010 3
m-18907910010 13305862264 aaaaaaaaaaaaaaaaaaaaaaa
end
输出样例:
在这里给出相应的输出。例如：
18907910010 0.3 99.7
### 输入样例1:
在这里给出一组输入。例如：
u-18907910010 3
m-18907910010 13305862264 aaaaaaaaaaaa
m-18907910010 13305862264 aaaaaaa.
m-18907910010 13305862264 bb,bbbb
end
输出样例1:
在这里给出相应的输出。例如：
18907910010 0.5 99.5
设计与分析：
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)
{
Inputdeal inputdeal = new Inputdeal();
ArrayList<User> users = new ArrayList<>();
Scanner in = new Scanner(System.in);
String input = in.nextLine();
while (!input.matches("end")) {
if ( inputdeal.check(input)==1) {
inputdeal.writeUser(users, input);
}
else if (inputdeal.check(input)==2)
{
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());
System.out.print(" ");
System.out.printf("%.1f",u.calCost());
System.out.print(" ");
System.out.printf("%.1f",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 sum = 0;
for (ChargeRule rule : chargeRules) {
sum = sum+rule.calCost(userRecords);
}
return sum;
}
@Override
public double getMonthlyRent() {
return monthlyRent;
}
}
class MobilePhoneCharging extends ChargeMode//手机缴费
{
private double monthlyRent = 15;
public MobilePhoneCharging() {
super();
chargeRules.add(new MobilePhoneIncityRule());
//chargeRules.add(new MobilePhoneInLandRule());
chargeRules.add(new MobilePhoneInProvinceRule());
chargeRules.add(new MobilePhoneInLandRule());
}
@Override
public double calCost(UserRecords userRecords) {
double sum = 0;
for (ChargeRule rule : chargeRules) {
sum = sum+rule.calCost(userRecords);
}
return sum;
}
@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[13]")) {
return 1;
} else if (input.matches("[m]-1[0-9]{10}\\s" + "1[0-9]{10}\\s" + "[0-9a-zA-Z\\s\\.,]+")) {
return 2;
}
return 0;
}
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());
} else if (mode == 3) {
usernew.setChargeMode(new MobilePhoneMassageCharging());
}
users.add(usernew);
}
public void writeRecord(ArrayList<User> users, String input) {
String[] inputs = input.split(" ");
inputs[0] = inputs[0].substring(2);
User callu = null, answeru = null;
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];
} else {
in = inputs[1];
}
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 (input.charAt(0) == 'm') {
MessageRecord messageRecord = new MessageRecord(input);
if (callu != null) {
callu.getUserRecords().addSendMessageRecords(messageRecord);
;
}
if (answeru != null) {
callu.getUserRecords().addReceiveMessageRecords(messageRecord);
}
}
}
}
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 ChargeRule//市内
{
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double cost=0;
int i=0;
for(CallRecord call : userRecords.getCallingInCityRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
if(call.getCallType().matches("11"))
cost=cost+totaltime*0.1;
if(call.getCallType().matches("12"))
cost=cost+totaltime*0.3;
if(call.getCallType().matches("13"))
cost=cost+totaltime*0.6;
}
return cost;
}
}
class LandPhoneInlandRule extends ChargeRule//国内0.6元/分
{
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double cost=0;
int i=0;
for(CallRecord call : userRecords.getCallingInLandRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=cost+totaltime*0.6;
}
return cost;
}
}
class LandPhoneInProvinceRule extends ChargeRule//省内0.3元/分
{
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double cost=0;
int i=0;
for(CallRecord call : userRecords.getCallingInProvinceRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=cost+totaltime*0.3;
}
return cost;
}
}
class MobilePhoneIncityRule extends ChargeRule//市内打/接
{
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double cost=0;
int i=0;
for(CallRecord call : userRecords.getCallingInCityRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
//cost=cost+totaltime*0.1;
if(call.getCallType().equals("11"))
cost=cost+totaltime*0.1;
else if(call.getCallType().equals("12"))
cost=cost+totaltime*0.2;
else if(call.getCallType().equals("13"))
cost=cost+totaltime*0.3;
}
/*for(CallRecord call : userRecords.getAnswerInCityRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=0.0;
}*/
return cost;
}
}
class MobilePhoneInProvinceRule extends ChargeRule//省内漫游（无论打哪里）
{
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double cost=0;
int i=0;
for(CallRecord call : userRecords.getCallingInProvinceRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=cost+totaltime*0.3;
/* if(call.getCallType().equals("21"))
cost=cost+totaltime*0.3;
else if(call.getCallType().equals("22"))
cost=cost+totaltime*0.3;
else if(call.getCallType().equals("23"))
cost=cost+totaltime*0.3; */
}
/*for(CallRecord call : userRecords.getAnswerInProvinceRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=0.0;
}*/
return cost;
}
}
class MobilePhoneInLandRule extends ChargeRule//省外
{
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double cost=0;
int i=0;
for(CallRecord call : userRecords.getCallingInLandRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=cost+totaltime*0.6;
/* if(call.getCallType().equals("31"))
cost=cost+totaltime*0.6;
else if(call.getCallType().equals("32"))
cost=cost+totaltime*0.6;
else if(call.getCallType().equals("33"))
cost=cost+totaltime*0.6; */
}
for(CallRecord call : userRecords.getAnswerInLandRecords())
{
long totaltime=call.getEndTime().getTime()-call.getStartTime().getTime();
if(totaltime%60000>1) {
totaltime = totaltime/60000+1;
}
else totaltime = totaltime/60000;
cost=cost+totaltime*0.3;
}
return cost;
}
}
class MessageRecord {
private String message;
public MessageRecord(String input) {
super();
this.message = input.substring(26);
}
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;
}
}
/*abstract class MessageChargeRule extends ChargeMode
{
private double monthlyRent = 0;
public MessageChargeRule() {
super();
chargeRules.add(new SendMessageRule());
}
@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 MobilePhoneMassageCharging extends ChargeMode {
private double monthlyRent = 0;
public MobilePhoneMassageCharging() {
super();
chargeRules.add(new MobilePhoneMessageRule());
}
@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 MobilePhoneMessageRule extends CallChargeRule {
@Override
public double calCost(UserRecords userRecords) {
double sumCost = 0;
int number = 0;
for (MessageRecord m : userRecords.getSendMessageRecords()) {
int length = m.getMessage().length();
if (length <= 10)
{
number++;
} else
{
number += length / 10;
if (length % 10 != 0) {
number++;
}
}
}
if (number <= 3)
{
sumCost = number * 0.1;
}
else if (number <= 5)
{
sumCost = (number - 3)*0.2+0.3;
}
else
{
sumCost =(number - 5)*0.3+0.7;
}
return sumCost;
}
}
踩坑心得：
这道题要运用到内部类，抽象类，接口等，通过内部类将不同的收费方式表现出来在通过接口使不同类继承公用的方法。增强了代码的复用性，还有就是要用容器将所有对象放进一个容器中。我认为这道题的最大
难点就是制作出合适的接口。而在我第一次做这道题时，虽然有前面两次大作业做铺垫，但仍然在这个问题上困扰了很久。
改进建议：
对于接口这类问题，在平时还要多加练习，除了看相关得书籍，我认为最重要得就是多做相关得题目。对于编程得一些语法规则，也许看几遍书并不能很好的记住，所以就需要我们一遍又一遍得刷题，当题目达到了
一定量后，很多东西就自然而然得记住了。
7-2 编写一个类Shop（商店）、内部类InnerCoupons（内部购物券） 分数 30 作者 吴光生 单位 新余学院编写一个类Shop（商店），该类中有一个成员内部类InnerCoupons（内部购物券），可以用于购买该商店的牛奶（假设每箱牛奶售价为50元）。要求如下：
（1）Shop类中有私有属性milkCount（牛奶的箱数，int类型）、公有的成员方法setMilkCount( )和getMilkCount( )分别用于设置和获取牛奶的箱数。
（2）成员内部类InnerCoupons，有公有属性value（面值，int类型），一个带参数的构造方法可以设定购物券的面值value，一个公有的成员方法buy( )要求输出使用了面值为多少的购物券进行支付，同时使商店牛奶的箱数减少value/50。
（3）Shop类中还有成员变量coupons50（面值为50元的内部购物券，类型为InnerCoupons）、coupons100（面值为100元的内部购物券，类型为InnerCoupons）。
（4）在Shop类的构造方法中，调用内部类InnerCoupons的带参数的构造方法分别创建上面的购物券coupons50、coupons100。
在测试类Main中，创建一个Shop类的对象myshop，从键盘输入一个整数（大于或等于3），将其设置为牛奶的箱数。假定有顾客分别使用了该商店面值为50的购物券、面值为100的购物券各消费一次，分别输出消费后商店剩下的牛奶箱数。
输入格式:
输入一个大于或等于3的整数。
输出格式:
使用了面值为50的购物券进行支付
牛奶还剩XX箱
使用了面值为100的购物券进行支付
牛奶还剩XX箱
输入样例:
在这里给出一组输入。例如：
5
输出样例:
在这里给出相应的输出。例如：
使用了面值为50的购物券进行支付 牛奶还剩4箱 使用了面值为100的购物券进行支付 牛奶还剩2箱
设计与分析：
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
shop myshop = new shop();
Scanner in = new Scanner(System.in);
myshop.setMilkCount(in.nextInt());
System.out.println("使用了面值为50的购物券进行支付");
System.out.println("牛奶还剩"+myshop.coupons50.buy()+"箱");
System.out.println("使用了面值为100的购物券进行支付");
System.out.println("牛奶还剩"+myshop.coupons100.buy()+"箱");
}
}
class shop{
private int milkCount;
InnerCoupons coupons50 = new InnerCoupons(50);
InnerCoupons coupons100 = new InnerCoupons(100);
public void setMilkCount(int i)
{
milkCount = i;
}
public int getMilkCount(){
return milkCount;
}
class InnerCoupons{
public int value;
InnerCoupons(int value)
{
this.value = value;
}
public int buy()
{
milkCount = milkCount - value/50;
return milkCount;
}
}
}
设计一个动物发生模拟器，用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()、动物叫shout()；
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat，用getAnimalClass()方法返回不同的动物类别（比如猫，狗，山羊），用shout()方法分别输出不同的叫声（比如喵喵、汪汪、咩咩）。
最后编写AnimalShoutTest类测试，输出：
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩
其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声。
请在下面的【】处添加代码。
//动物发生模拟器. 请在下面的【】处添加代码。
public class AnimalShoutTest2 {
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
Goat goat = new Goat();
speak(cat);
speak(dog);
speak(goat);
}
//定义静态方法speak()
【】
}
//定义抽象类Animal
【】class Animal{
【】
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat 【】{
【】
【】
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog 【】{
【】
【】
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat 【】{
【】
【】
}
输入样例:
输出样例:
猫的叫声：喵喵 狗的叫声：汪汪 山羊的叫声：咩咩
设计与分析：
//动物发生模拟器. 请在下面的【】处添加代码。
public class Main {
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
Goat goat = new Goat();
speak(cat);
speak(dog);
speak(goat);
}
//定义静态方法speak()
public static void speak(Animal animal)
{
System.out.println( animal.getAnimalClass()+"的叫声："+animal.shout());
}
}
//定义抽象类Animal
abstract class Animal{
public abstract String getAnimalClass();
public abstract String shout();
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal{
public String getAnimalClass()
{
String s = null;
s="猫";
return s;
}
public String shout()
{
String s = null;
s="喵喵";
return s;
}
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal {
public String getAnimalClass()
{
String s= null;
s="狗";
return s;
}
public String shout()
{
String s = null;
s="汪汪";
return s;
}
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal {
public String getAnimalClass()
{
String s;
s="山羊";
return s;
}
public String shout()
{
String s ;
s="咩咩";
return s;
}
}
总结
在这个学期得java学习中，我们学习了封装，多态，抽象类，接口，容器，内部类，还有最后面的javafx，对于接口，容器我的掌握不是很好，今后我会在这些方面多下功夫，找相关得题目练习。还有就是代码长度得问题
通过本次题目集我学到了减少代码长度得方法，那就是将一直使用的方法，设计成一个传入特定的参数即可得到结果的，这样我们在遇到需要使用的情况时只需要，调用这个方法即可。还有就是在Java中一些上课没有讲到的类，但用起来很方便的类，需要自己去深入的了解一下，因为这样可以大大的提高了我们的解题效率。
还需要进一步提高自己的编程思维，在解题时提前设计好类之间的关系，类的功能，这样写起来代码很快，效率高。还有就是我在使用正则表达式得时候总是会碰到这样或那样得问题，我希望在今后加大对这方面的训练以
减少这些问题。