博客第三次作业
博客第三次作业
目录:
（1） 学习心得及前言
（2）设计与分析
（3）改进建议
（4）总结
（1） 学习心得及前言：随着本学期的结束，java的学习也接近了尾声
1、我感觉字学习java应该是循环渐进，有始有终，按部就班，脚踏实地。java是有着阶梯性的一们语言，如果要学习它。我觉得最好还是按照java的学习体系，先学习什么，在学习什么，只有这样，我们在学习中才会遇到更少的麻烦。]ava 是一门更倾向于网络的语言。不要上来就学习jsp;这样不好，因为这没有基础。在以后的学习中很可能遇到很多的麻烦，这就不好了。
2、信心，恒心，毅力是最重要的。这是我们必须具备的心理素质。要是2门这门语言开始的时候很有兴趣，遇到苦难就退缩，这样最终会放弃学习java，没有经历风雨怎么见彩虹。编程就是有的时候就是那么这么人。会遇到很多的困惑。但是一旦你弄懂了，或者是你把问题解决了，你会感到很兴奋，编程的快乐就在此了。
3、多看看一些资料，多多的向高手请教，这样才好。要学会总结和领会，当然，学习java一个人有一个人的想法，也有自己的独特学习方法。总之适合自己的就是最好的。
7-1 电信计费系列1-座机计费
实现一个简单的电信计费程序：
假设南昌市电信分公司针对市内座机用户采用的计费方式：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
南昌市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。
输入格式:
输入信息包括两种类型
1、逐行输入南昌市用户开户的信息，每行一个用户，
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐）
例如：u-079186300001 0
座机号码除区号外由是7-8位数字组成。
本题只考虑计费类型0-座机计费，电信系列2、3题会逐步增加计费类型。
2、逐行输入本月某些用户的通讯信息，通讯信息格式：
座机呼叫座机：t-主叫号码 接听号码 起始时间 结束时间
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四项内容之间以一个英文空格分隔，
时间必须符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat类。
以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。
注意：
本题非法输入只做格式非法的判断，不做内容是否合理的判断（时间除外，否则无法计算），比如：
1、输入的所有通讯信息均认为是同一个月的通讯信息，不做日期是否在同一个月还是多个月的判定，直接将通讯费用累加，因此月租只计算一次。
2、记录中如果同一电话号码的多条通话记录时间出现重合，这种情况也不做判断，直接 计算每条记录的费用并累加。
3、用户区号不为南昌市的区号也作为正常用户处理。
输出格式:
根据输入的详细通讯信息，计算所有已开户的用户的当月费用（精确到小数点后2位，
单位元）。假设每个用户初始余额是100元。
每条通讯信息单独计费后累加，不是将所有时间累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。
建议类图：
实验代码：
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);
}
}
作业心得： 类图比较麻烦，有许多类要创建，仔细看，慢慢看，先把他们串联起来再动手。
需要注意的点，
1.判断输入格式是否正确，比如，区号可能是三位，
2.价钱计算：计算的时候记得把时间转成整型，避免除以60后后面有小数，影响结果，最后余数计算，不到一分钟按一分钟计。
第二次
实现南昌市电信分公司的计费程序，假设该公司针对手机和座机用户分别采取了两种计费方案，分别如下：
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-手机实时计费。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
public class Main {
public static void main(String[] args) throws ParseException {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
Scanner input = new Scanner(System.in);
java.text.DecimalFormat df = new java.text.DecimalFormat("0.0#");
HashSet<String> init = new HashSet<String>();// 存储用户号码，代表User
ArrayList<String> operate = new ArrayList<String>();// 对User进行的操作
ArrayList<User> users = new ArrayList<User>();
String initCellphonenum = "[u][-]1[3-9]\\d{9}[ ][1]";
String initLandPhonenum = "[u][-]0791[0-9]{7,8}[ ][0]";
while (true) {// 将信息录入
String t = input.nextLine();
if (t.equals("end")) {
break;
} else {
if (t.length() < 13) {
continue;
}
if (t.charAt(0) == 'u') {// 首字母为u则为注册
init.add(t);
} else if (t.charAt(0) == 't') {// 首字母为t则为操作
operate.add(t);
}
}
}
for (String it : init) {
if (it.matches(initCellphonenum) || it.matches(initLandPhonenum)) {
String nums[] = it.split("[- ]");
if (nums[2].equals("1")) {
users.add(new User(new CellphoneCharging(), nums[1]));
} else if (nums[2].equals("0")) {
users.add(new User(new LandlinePhoneCharging(), nums[1]));
} else if (nums[2].equals("3")) {
}
}
} // TODO 用户的初始化已完成
// TODO 判断打电话操作时间，先利用字符串切割，然后判断切割后的字符串个数，通过个数以及手机号码来判断区号，
for (String it : operate) {
if (land_call_landjudge(it)) {
String arrs[] = it.split("[- ]");
String callNumber = arrs[1];
String answerNumber = arrs[2];
String startTime = arrs[3] + " " + arrs[4];
String endTime = arrs[5] + " " + arrs[6];
String Call_Code = callNumber.substring(0, 4);
String Answer_Code = answerNumber.substring(0, 4);
if (callNumber.equals(answerNumber)) {
continue;
}
if (Datejudge(startTime) && Datejudge(endTime)) {
Date startDate = simpleDateFormat.parse(startTime);
Date endDate = simpleDateFormat.parse(endTime);
for (User user : users) {
if (user.getNumber().equals(callNumber)) {
if (Answer_Code.equals("0791")) {
// TODO 判断是否为市内电话
user.getUserRecords().addCallingInCityRecords(
new CallRecord(startDate, endDate, Call_Code, Answer_Code));
break;
} else if (Answer_Code.substring(0, 3).equals("079") || Answer_Code.equals("0701")) {
// TODO 判断是否为市外电话
user.getUserRecords().addCallingInProvinceRecords(
new CallRecord(startDate, endDate, Call_Code, Answer_Code));
break;
} else {
// TODO 判断是否为国内电话
user.getUserRecords().addCallingInLandRecords(
new CallRecord(startDate, endDate, Call_Code, Answer_Code));
break;
}
}
}
}
} else if (land_call_cellJudge(it)) {
String arrs[] = it.split("[- ]");
String callNumber = arrs[1];
String answerNumber = arrs[2];
String startTime = arrs[4] + " " + arrs[5];
String endTime = arrs[6] + " " + arrs[7];
String Call_Code = callNumber.substring(0, 4);// 可能为省外电话，此时则不一定为前四位
String Answer_Code = arrs[3];
if (Datejudge(startTime) && Datejudge(endTime)) {
Date startDate = simpleDateFormat.parse(startTime);
Date endDate = simpleDateFormat.parse(endTime);
for (User user : users) {
if (user.getNumber().equals(callNumber)) {
if (Call_Code.equals(Answer_Code)) {
user.getUserRecords().addCallingInCityRecords(
new CallRecord(startDate, endDate, Call_Code, Answer_Code));
} else if (Call_Code.substring(0, 3).equals(Answer_Code.substring(0, 3))) {
user.getUserRecords().addCallingInProvinceRecords(
new CallRecord(startDate, endDate, Call_Code, Answer_Code));
} else {
user.getUserRecords().addCallingInLandRecords(
new CallRecord(startDate, endDate, Call_Code, Answer_Code));
}
}
}
if (!Answer_Code.equals("0701") && !Answer_Code.substring(0, 3).equals("079")) {// 不是江西省内区号
for (User user : users) {
if (user.getNumber().equals(answerNumber)) {
user.getUserRecords().addAnswerInLandRecords(
new CallRecord(startDate, endDate, Call_Code, Answer_Code));
break;
}
}
}
}
} else if (cell_call_landJudge(it)) {
String arrs[] = it.split("[- ]");
String callNumber = arrs[1];
String answerNumber = arrs[3];
String startTime = arrs[4] + " " + arrs[5];
String endTime = arrs[6] + " " + arrs[7];
String Call_Code = arrs[2];
String Answer_Code = answerNumber.substring(0, 4);
if (Datejudge(startTime) && Datejudge(endTime)) {
Date startDate = simpleDateFormat.parse(startTime);
Date endDate = simpleDateFormat.parse(endTime);
for (User user : users) {
if (user.getNumber().equals(callNumber)) {
if (Call_Code.equals("0791")) {
user.getUserRecords().addCallingInCityRecords(
new CallRecord(startDate, endDate, Call_Code, Answer_Code));
} else if (Call_Code.substring(0, 3).equals("079") || Call_Code.equals("0701")) {
user.getUserRecords().addCallingInProvinceRecords(
new CallRecord(startDate, endDate, Call_Code, Answer_Code));
} else {
user.getUserRecords().addCallingInLandRecords(
new CallRecord(startDate, endDate, Call_Code, Answer_Code));
}
}
}
for (User user : users) {// TODO 座机可能出问题
if (user.getNumber().equals(answerNumber)) {
user.getUserRecords().addAnswerInLandRecords(
new CallRecord(startDate, endDate, Call_Code, Answer_Code));
break;
}
}
}
} else if (cell_call_cellJudge(it)) {
String arrs[] = it.split("[- ]");
String callNumber = arrs[1];
String answerNumber = arrs[3];
String startTime = arrs[5] + " " + arrs[6];
String endTime = arrs[7] + " " + arrs[8];
String Call_Code = arrs[2];
String Answer_Code = arrs[4];
if (Datejudge(startTime) && Datejudge(endTime)) {
Date startDate = simpleDateFormat.parse(startTime);
Date endDate = simpleDateFormat.parse(endTime);
for (User user : users) {
if (user.getNumber().equals(callNumber)) {
if (Call_Code.equals("0791")) {
user.getUserRecords().addCallingInCityRecords(
new CallRecord(startDate, endDate, Call_Code, Answer_Code));
} else if (Call_Code.substring(0, 3).equals("079") || Call_Code.equals("0701")) {// 省内漫游通话
user.getUserRecords().addCallingInProvinceRecords(
new CallRecord(startDate, endDate, Call_Code, Answer_Code));
} else {
user.getUserRecords().addCallingInLandRecords(
new CallRecord(startDate, endDate, Call_Code, Answer_Code));
}
}
}
if (!Answer_Code.equals("0701") && !Answer_Code.substring(0, 3).equals("079")) {
for (User user2 : users) {
if (user2.getNumber().equals(answerNumber)) {
user2.getUserRecords().addAnswerInLandRecords(
new CallRecord(startDate, endDate, Call_Code, Answer_Code));
break;
}
}
}
}
} else {
continue;
}
}
for (User user : users) {
user.calCost();
user.calBalance();
}
for (int i = 0; i < users.size(); i++) {
int min = i;
for (int j = i; j < users.size(); j++) {
if (users.get(min).getNumber().compareTo(users.get(j).getNumber()) > 0) {
min = j;
}
}
Collections.swap(users, i, min);
}
for (User user : users) {
System.out.println(user.getNumber() + " " + df.format(user.calCost()) + " " +
df.format(user.getBalance()));
}
}
public static boolean Datejudge(String datestring) {
boolean flag = true;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
simpleDateFormat.setLenient(false);
try {
simpleDateFormat.parse(datestring);
} catch (Exception e) {
// TODO: handle exception
flag = false;
}
return flag;
}
public static boolean land_call_landjudge(String arr) {
String landcityincity = "t-0791\\d{7,8} 0\\d{9,11} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2}";
if (arr.matches(landcityincity)) {
return true;
} else {
return false;
}
}
public static boolean land_call_cellJudge(String arr) {
String land_call_cell = "t-0\\d{9,11} 1\\d{10} 0\\d{2,3} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2}";
if (arr.matches(land_call_cell)) {
return true;
} else {
return false;
}
}
public static boolean cell_call_landJudge(String arr) {
String cell_call_land = "t-1\\d{10} 0\\d{2,3} 0\\d{9,11} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2}";
if (arr.matches(cell_call_land)) {
return true;
} else {
return false;
}
}
public static boolean cell_call_cellJudge(String arr) {
String cell_call_cell = "t-1\\d{10} 0\\d{2,3} 1\\d{10} 0\\d{2,3} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2} \\d{4}.\\d{1,2}.\\d{1,2} \\d{2}:\\d{2}:\\d{2}";
if (arr.matches(cell_call_cell)) {
return true;
} else {
return false;
}
}
}
abstract class CallChargeRule extends ChargeRule{
public abstract double calCost(ArrayList<CallRecord> callRecords);
}
class CallRecord extends CommunicationRecord {//通话记录 继承自抽象类
private Date startTime;//开始时间
private Date endTime;//结束时间
private String callingAddressAreaCode;//地区，存区号
private String answerAddressAreaCode;//地区，存区号
public CallRecord() {
}
public CallRecord(Date startTime, Date endTime, String callingAddressAreaCode, String answerAddressAreaCode) {
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;
}
}
class CellphoneCharging extends ChargeMode {
final double monthlyRent = 15;
public CellphoneCharging() {
getChargeRules().add(new CellphoneInCityRule());
getChargeRules().add(new CellphoneInProvinceRule());
getChargeRules().add(new CellphoneInlandRule());
getChargeRules().add(new CellphoneInlandAnsRule());
}
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double all = 0;
all += ((CellphoneInCityRule) getChargeRules().get(0)).calCost(userRecords.getCallingInCityRecords());
all += ((CellphoneInProvinceRule) getChargeRules().get(1)).calCost(userRecords.getCallingInProvinceRecords());
all += ((CellphoneInlandRule) getChargeRules().get(2)).calCost(userRecords.getCallingInLandRecords());
all += ((CellphoneInlandAnsRule) getChargeRules().get(3)).calCost(userRecords.getAnswerInLandRecords());
return all;
}
@Override
public double getMonthlyRent() {
// TODO Auto-generated method stub
return monthlyRent;
}
}
class CellphoneInCityRule extends CallChargeRule {
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
// TODO Auto-generated method stub
double ans = 0;
for (CallRecord callRecord : callRecords) {
long a = callRecord.getStartTime().getTime();
long b = callRecord.getEndTime().getTime();
int c = (int) ((b - a) / 1000);
if (callRecord.getAnswerAddressAreaCode().equals("0791")) {
if (c % 60 != 0) {
ans += (c / 60 + 1) * 0.1;
} else {
ans += (c / 60) * 0.1;
}
} else if (callRecord.getAnswerAddressAreaCode().substring(0, 3).equals("079")||callRecord.getAnswerAddressAreaCode().equals("0701")) {
if (c % 60 != 0) {
ans += (c / 60 + 1) * 0.2;
} else {
ans += (c / 60) * 0.2;
}
} else {
if (c % 60 != 0) {
ans += (c / 60 + 1) * 0.3;
} else {
ans += (c / 60) * 0.3;
}
}
}
return ans;
}
}
class CellphoneInlandAnsRule extends CallChargeRule {
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double cost = 0;
for (CallRecord callRecord : callRecords) {
long a = callRecord.getStartTime().getTime();
long b = callRecord.getEndTime().getTime();
int c = (int) ((b - a) / 1000);
if (c % 60 != 0) {
cost += (c / 60 + 1) * 0.3;
} else {
cost += (c / 60) * 0.3;
}
}
return cost;
}
}
class CellphoneInlandRule extends CallChargeRule {
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
// TODO Auto-generated method stub
double ans = 0;
for (CallRecord callRecord : callRecords) {
long a = callRecord.getStartTime().getTime();
long b = callRecord.getEndTime().getTime();
int c = (int) ((b - a) / 1000);
if (c % 60 != 0) {
ans += (c / 60 + 1) * 0.6;
} else {
ans += (c / 60) * 0.6;
}
}
return ans;
}
}
class CellphoneInProvinceRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
// TODO Auto-generated method stub
double ans = 0;
for (CallRecord callRecord : callRecords) {
long a = callRecord.getStartTime().getTime();
long b = callRecord.getEndTime().getTime();
int c = (int) ((b - a) / 1000);
if (c % 60 != 0) {
ans += (c / 60 + 1) * 0.3;
} else {
ans += (c / 60) * 0.3;
}
}
return ans;
}
}
abstract class ChargeMode {
private ArrayList<ChargeRule> chargeRules = new ArrayList<ChargeRule>();
public ArrayList<ChargeRule> getChargeRules() {
return chargeRules;
}
public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
this.chargeRules = chargeRules;
}
public abstract double calCost(UserRecords userRecords);
public abstract double getMonthlyRent();
}
abstract class ChargeRule {
}
class CommunicationRecord {
private String callingNumber;//来电号码
private String answerNumber;//接电话号码
public String getCallingNumber() {
return callingNumber;
}
public void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
public String getAnswerNumber() {
return answerNumber;
}
public void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}
}
abstract class Judge {
public abstract boolean judge_landlinephone();
}
class LandlinePhoneCharging extends ChargeMode {
final double monthlyRent = 20;
public LandlinePhoneCharging() {
this.getChargeRules().add(new LandPhoneInCityRule());
this.getChargeRules().add(new LandPhoneInProvinceRule());
this.getChargeRules().add(new LandPhoneInlandRule());
}
@Override
public double calCost(UserRecords userRecords) {
// TODO Auto-generated method stub
double all = 0;
all += ((LandPhoneInCityRule) getChargeRules().get(0)).calCost(userRecords.getCallingInCityRecords());
all += ((LandPhoneInProvinceRule) getChargeRules().get(1)).calCost(userRecords.getCallingInProvinceRecords());
all += ((LandPhoneInlandRule) getChargeRules().get(2)).calCost(userRecords.getCallingInLandRecords());
return all;
}
@Override
public double getMonthlyRent() {
// TODO Auto-generated method stub
return monthlyRent;
}
}
class LandPhoneInCityRule extends CallChargeRule {
public LandPhoneInCityRule() {
}
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
// TODO Auto-generated method stub
double ans = 0;
for (CallRecord callRecord : callRecords) {
long a = callRecord.getStartTime().getTime();
long b = callRecord.getEndTime().getTime();
int c = (int) ((b - a) / 1000);
if (c % 60 != 0) {
ans += (c / 60 + 1) * 0.1;
} else {
ans += (c / 60) * 0.1;
}
}
return ans;
}
}
class LandPhoneInlandRule extends CallChargeRule {
public LandPhoneInlandRule() {
}
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
// TODO Auto-generated method stub
double ans = 0;
for (CallRecord callRecord : callRecords) {
long a = callRecord.getStartTime().getTime();
long b = callRecord.getEndTime().getTime();
int c = (int) ((b - a) / 1000);
if (c % 60 != 0) {
ans += (c / 60 + 1) * 0.6;
} else {
ans += (c / 60) * 0.6;
}
}
return ans;
}
}
class LandPhoneInProvinceRule extends CallChargeRule {
public LandPhoneInProvinceRule() {
}
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
// TODO Auto-generated method stub
double ans = 0;
for (CallRecord callRecord : callRecords) {
long a = callRecord.getStartTime().getTime();
long b = callRecord.getEndTime().getTime();
int c = (int) ((b - a) / 1000);
if (c % 60 != 0) {
ans += (c / 60 + 1) * 0.3;
} else {
ans += (c / 60) * 0.3;
}
}
return ans;
}
}
class MessageRecord extends CommunicationRecord {
private String message;
public MessageRecord() {
}
public MessageRecord(String message) {
this.message = message;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
class User {
private UserRecords userRecords = new UserRecords();
private double balance = 100;
private ChargeMode chargeMode;
private String number;
public User() {
}
public User(ChargeMode chargeMode, String number) {
this.chargeMode = chargeMode;
this.number = number;
}
public double calBalance() {
this.balance = this.balance - this.calCost() - this.getChargeMode().getMonthlyRent();
return this.balance;
}
public double calCost() {
return chargeMode.calCost(userRecords);
}
public UserRecords getUserRecords() {
return userRecords;
}
public void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
public double getBalance() {
return balance;
}
public ChargeMode getChargeMode() {
return chargeMode;
}
public void setChargeMode(ChargeMode chargeMode) {
this.chargeMode = chargeMode;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
}
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> answerInCitRecords = new ArrayList<CallRecord>();//市内接通电话
private ArrayList<CallRecord> answerInProvincRecords = 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 UserRecords() {
}
public ArrayList<CallRecord> getCallingInCityRecords() {
return callingInCityRecords;
}
public ArrayList<CallRecord> getCallingInProvinceRecords() {
return callingInProvinceRecords;
}
public ArrayList<CallRecord> getCallingInLandRecords() {
return callingInLandRecords;
}
public ArrayList<CallRecord> getAnswerInCitRecords() {
return answerInCitRecords;
}
public ArrayList<CallRecord> getAnswerInProvincRecords() {
return answerInProvincRecords;
}
public ArrayList<CallRecord> getAnswerInLandRecords() {
return answerInLandRecords;
}
public ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
public ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
public void addCallingInCityRecords(CallRecord callingInCityRecords) {
this.callingInCityRecords.add(callingInCityRecords);
}
public void addCallingInProvinceRecords(CallRecord callingInProvinceRecords) {
this.callingInProvinceRecords.add(callingInProvinceRecords);
}
public void addCallingInLandRecords(CallRecord callingInLandRecords) {
this.callingInLandRecords.add(callingInLandRecords);
}
public void addAnswerInCitRecords(CallRecord answerInCitRecords) {
this.answerInCitRecords.add(answerInCitRecords);
}
public void addAnswerInProvincRecords(CallRecord answerInProvincRecords) {
this.answerInProvincRecords.add(answerInProvincRecords);
}
public void addAnswerInLandRecords(CallRecord answerInLandRecords) {
this.answerInLandRecords.add(answerInLandRecords);
}
public void addSendMessageRecords(MessageRecord sendMessageRecords) {
this.sendMessageRecords.add(sendMessageRecords);
}
public void addReceiveMessageRecords(MessageRecord receiveMessageRecords) {
this.receiveMessageRecords.add(receiveMessageRecords);
}
}
第三次
实现一个简单的电信计费程序，针对手机的短信采用如下计费方式：
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）。
注意：以上图中所定义的类不是限定要求，根据实际需要自行补充或修改。
import java.text.ParseException;
import java.util.*;
public class Main {
public static void main(String[] args) throws ParseException {
try (Scanner input = new Scanner(System.in)) {
java.text.DecimalFormat df = new java.text.DecimalFormat("0.0#");
HashSet<String> init = new HashSet<String>();// 存储用户号码，代表User
ArrayList<String> operate = new ArrayList<String>();// 对User进行的操作
ArrayList<User> users = new ArrayList<User>();
while (true) {// 将信息录入
String t = input.nextLine();
if (t.equals("end")) {
break;
} else {
if (t.length() < 13) {
continue;
}
if (t.charAt(0) == 'u') {// 首字母为u则为注册
init.add(t);
} else if (t.charAt(0) == 'm') {// 首字母为t则为操作
operate.add(t);
}
}
}
for (String it : init) {
if (NumberJudge(it)) {
String nums[] = it.split("[- ]");
users.add(new User(new MessageCharging(), nums[1]));
}
}
for (String it : operate) {
if (MessageJudge(it)) {
String nums[] = it.split("[- ]");
String sendMessageNum = nums[1];
String message = it.substring(26);
for (User user : users) {
if (user.getNumber().equals(sendMessageNum)) {
user.getUserRecords().getSendMessageRecords().add(new MessageRecord(message));
}
}
}
}
for (User user : users) {
user.calCost();
user.calBalance();
}
for (int i = 0; i < users.size(); i++) {
int min = i;
for (int j = i; j < users.size(); j++) {
if (users.get(min).getNumber().compareTo(users.get(j).getNumber()) > 0) {
min = j;
}
}
Collections.swap(users, i, min);
}
for (User user : users) {
System.out.println(user.getNumber() + " " + df.format(user.calCost()) + " " +
df.format(user.getBalance()));
}
}
}
public static boolean NumberJudge(String arr) {
String numberjudge = "[u][-]1[3-9]\\d{9}[ ][3]";
if (arr.matches(numberjudge)) {
return true;
} else {
return false;
}
}
public static boolean MessageJudge(String arr) {
String messagejudge = "m-1[3-9]\\d{9} 1[3-9]\\d{9} [a-z|A-Z|0-9| |,|.]++";
if (arr.matches(messagejudge)) {
return true;
} else {
return false;
}
}
}
abstract class ChargeMode {
private ArrayList<ChargeRule> chargeRules = new ArrayList<ChargeRule>();
public ArrayList<ChargeRule> getChargeRules() {
return chargeRules;
}
public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
this.chargeRules = chargeRules;
}
public abstract double calCost(UserRecords userRecords);
public abstract double getMonthlyRent();
}
abstract class ChargeRule {
}
abstract class CommunicationRecord {
private String callingNumber;//来电号码
private String answerNumber;//接电话号码
public String getCallingNumber() {
return callingNumber;
}
public void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
public String getAnswerNumber() {
return answerNumber;
}
public void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}
}
class MessageCharging extends ChargeMode {
public MessageCharging() {
getChargeRules().add(new SendMessageRule());
}
@Override
public double calCost(UserRecords userRecords) {
double cost = 0;
cost += ((SendMessageRule) getChargeRules().get(0)).calCost(userRecords.getSendMessageRecords());
return cost;
}
@Override
public double getMonthlyRent() {
return 0;
}
}
abstract class MessageChargingRule extends ChargeRule{
abstract double calCost(ArrayList<MessageRecord> messageRecords);
}
class MessageRecord extends CommunicationRecord {
private String message;
public MessageRecord() {
}
public MessageRecord(String message) {
this.message = message;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
class SendMessageRule extends MessageChargingRule {
@Override
public double calCost(ArrayList<MessageRecord> messageRecords) {
double cost = 0;
int cnt = 0;
for (MessageRecord messageRecord : messageRecords) {
if (messageRecord.getMessage().length() % 10 != 0) {
cnt += messageRecord.getMessage().length() / 10 + 1;
} else {
cnt += messageRecord.getMessage().length() / 10;
}
}
if (cnt > 5) {
cost = 0.1 * 3 + 0.2 * 2 + (cnt - 5) * 0.3;
} else if (cnt > 3) {
cost = 0.1 * 3 + 0.2 * (cnt - 3);
} else {
cost = 0.1 * cnt;
}
return cost;
}
}
class User {
private UserRecords userRecords = new UserRecords();
private double balance = 100;
private ChargeMode chargeMode;
private String number;
public User() {
}
public User(ChargeMode chargeMode, String number) {
this.chargeMode = chargeMode;
this.number = number;
}
public double calBalance() {
this.balance = this.balance - this.calCost() - this.getChargeMode().getMonthlyRent();
return this.balance;
}
public double calCost() {
return chargeMode.calCost(userRecords);
}
public UserRecords getUserRecords() {
return userRecords;
}
public void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
public double getBalance() {
return balance;
}
public ChargeMode getChargeMode() {
return chargeMode;
}
public void setChargeMode(ChargeMode chargeMode) {
this.chargeMode = chargeMode;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
}
class UserRecords {
private ArrayList<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();//发送短信电话
private ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<MessageRecord>();//接受短信电话
public UserRecords() {
}
public ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
public ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
public void addSendMessageRecords(MessageRecord sendMessageRecords) {
this.sendMessageRecords.add(sendMessageRecords);
}
public void addReceiveMessageRecords(MessageRecord receiveMessageRecords) {
this.receiveMessageRecords.add(receiveMessageRecords);
}
}
（4）学习心得：
从大三开始算，我学习java已经有小半年年的时间了，不过虽然时间长，但是对于现在的我还是一个初学者，懂不了多少的java初学者。期间曾迷茫过，曾困惑过，走了不少的弯路，老师布置的试验作业每次都是不会做，每次都是要问同学，这个代码什么意思啊?为什么用这条代码，用别的不行吗?甚至后来根本没耐心问，索性就复制同学的作业交上去。但是都是各种0分，害的同学也这样，不过他能找老师反驳，而我却没实力。。。渐渐的，我认识到这样下去是不行的，我必须改正自己的学习态度和方式。接下提到的就是我这一年来的java学习心得。 刚一开始学习java时，我就已经学习过C语言，不过C语言学的不是很好，所以开始看到java的时候我很反感，看着源代码，都不知道失什么意思。看书的时候一看到源代码就头疼，因为根本看不懂。那段时间根本就是一无所获，在图书馆借了一本书，关java的语法特性，与别的语言相比的优点，什么跨平台，源代码公开，什么write 、 once 、 run 、 anywhere，能说得头头是道，可是一到具体的问题，想写一些具体的东西，问题就都来了，根本不知道该怎么下手。所以每次李旺老师布置的试验作业都没的按时完成。渐渐的时间过去了，一点进展都没有，我都几乎要放弃了。
而后又同学经常来宿舍跟我讲解，我很感谢他。慢慢的我也理解了一些知识。从他那里，我认识到，JAVA是一门计算机语言，是人类发明的语言，应该比人类语言更容易学习，只要你有一种必胜学习JAVA心态就可以成功。学习JAVA的方法：JAVA学习中，首先要做到课前、课后复习及预习，要时时保持一个清醒的头脑;多和同学沟通;互相学习;取长补短;在学习中做到帮助他人或他人帮助自己。学习java，的确要学习的东西很多，就像同学提到的。Java不像.net一家独大，Java的繁盛在于开源社区的庞大，这也带来了分支太多的问题，怎样选择一条好的学习路线，对于初学者来说，的确是一件很迷茫的事。其实不管java东西再多，总有规律可循。对于学习java基础的经验就是多做、多思考，基础知识的学习不能不求甚解，要追本溯源，弄清问题的本质。这样才能举一反三，由点及面。java的所有编程思路都是“面向对象”的编程。所以大家在往更高境界发展以前一定要打好基础，基础是王道。我们的基础要扎实扎实再扎实。所谓打好基 础并不是说要熟悉所有的java代码。要了解java的结构。class,methode,object,各种套用import,extend 让自己在结构上对java有个立体而且整体的了 解。
学Java千万不要浮躁。说到浮躁，这也是一个很值得我深思的问题。我觉得我自己也有这样的倾向，不仅是我，估计大多数的人都有这个毛病。总是喜欢讨论什么语言最好，什么语言功能强大。这种讨论倒没有错，不过真正学习的时候，浮躁会使你失去很多。在学习过程中，我很努力地使自己保持心理的平静，从基础学起，甚至是一些看上去完全没有必要的基础。
要多查API，它是Java编程的基本方法，也是编程过程中所不断利用的资源。Java的学习过程不仅仅是基本语法的学习，更多的是去学习和掌握它所提供的API类库。对于所接触到的类，方法，都去仔细去阅读文档的说明，再用自己编写的实例去此时一下。而且不要只看而不练，学好java靠的还是实践，在一周两节的实验课要认真编程，不懂问同学或问李老师。只有理论和实践相结合才能真正掌握只是和技能。而且还要懂得运用百度和谷歌，遇到问题可以先搜索一下，实在不懂再找同学。理论学习。通过对理论的学习，尽量了解新知识的概念;学习之后只是粗略的了解概念，不能和实际很好的结合。根据理论学习的知识，考虑在什么场合下可以应用这个新知识，哪些地方已经应用了这个概念，建立对新知识的感性认识。 java是一种面向对象的操作语言，必须要明白这点，才能从总体上把握java。学习编程，首先要从分析别人的代码开始，明白他们的思路，认真分析，在学习的过程中一定要动手做、写代码，九比如说老师布置的试验作业，一定要自己做，不能抄同学的，首先不是为了应付老师，而是要让自己真正懂得java，这样慢慢的，以后的试验自己就又实力去做。学习java不是抱一本书看看就行。很多东西和体会必须自己动手才能真正属于自己，实践失最重要的。而且还可以从实验中，体会到编程的乐趣，感受到自己做好一个程序，然后运行出结果，失很有成就感的!
在这小半年的学习过程中，通过同学的帮助和老师的教导，我对java有了初步的认识和了解。学习java首先主要是学习了Java的程序结构，包括了循环、数组、类和方法以及字符串处理等内容。在学习期间，上课认真听老师的讲解，特别是课后练习和上机的题目，以及老师提供给我们的有关学习编程语言的方法和技巧，对于我巩固所学的理论知识有很大的帮助。现在我也只是刚刚开始学习Java语言，所以想真正掌握Java技术，以后还会有很长的一段过程需要我们更加努力地去学习。毕竟，知识需要靠积累才能真正掌握。
浙公网安备 33010602011771号