标签：10 题目 double 08 callRecord second ArrayList new public
前言：
知识点包括：类与类之间的设计，正则表达式的使用，继承，抽象类之间的设计，以及什么时候使用抽象类，对于抽象类进行一些继承的，列表Arraylist的使用
多态的设计，TreeSet的使用，迭代器的使用，成员内部类的使用
题量：本次包括三次题集，其中一共包括了 8 道题目，题目量相对来说较少
题目难度：适中
题目集一：
实现一个简单的电信计费程序：
假设南昌市电信分公司针对市内座机用户采用的计费方式：
月租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元。
每条通讯信息单独计费后累加，不是将所有时间累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
设计与分析：本次题目中，给出了其中的类图设计，相对于来说还是比较好操作，所需要的就是读懂题目中的内容，将其中的内容进行一些实现，由于这次作业给出的类图设计的比较好，其中的很多的 内容都已经实现，但是读懂却比较麻烦，因此需要我么细心的去读懂其中的内容，在创建类上，我们可以不需要重复打开过的的窗口导致其中的窗口过多，使得其中的类显示出一种眼花缭 乱的感觉，难以给人琢磨清楚，因此，我们可以换一种打开方式，比如说，我们可以对于抽象类ChargrRule和其子类抽象类的CallChargeRule类、LandPhoneCityRule、 LandPhoneLandRule、LandPhoneProvinceRule、这几个类将其放在一个页面中便于我们操作和理解，其显示的效果，如下图所示，就比较清晰。
踩坑心得：本次实验中，确实有很多次踩坑。
一：对于时间上的计算思路是不正确的，其中没超过一分钟，就要计入为下一分钟，刚开始以为自己考虑好了，后来才发现自己考虑到不完善，其中的时间 设计方式不对，因 此，我们可以采用以下方式
if(second > second1)
second = second1 + 1;
else
second = second1;
cost = cost + second * 0.1;
其中的second 是精确计算下的结果，而second1 是在计算下，去尾的结果，这样可以实现电话费的时间计算模式，当然，这是对于花费是0.1每分钟，在市内打电话的收费，对于后来的迭 代，我们需要采用使用一些方法，在市内打不同的地方的收费价格是不一样的，需要重新写方法，而不是使用0.1这样的数字方式，这个我们可以在后文重新讲解；
二、对于电话的了解不多，导致其中的问题，比如说，一般的电话都是区号+号码的形式，所构成的号码一般是11位或者是12位的，但是对于一些特殊地区的，比如说北京的，区号就是010 的。所以就会导致之前的号码是11位或者是12位的错误，这是常识缺乏所导致的错误，一般上，一时半会儿是难以解决的，所以我们需要更改的其中的正则表达式
三、号码输出所导致的排序错误，刚开始的时候，自己的输出上没有注意到其中的错误，对于输出上还有一定的要求，我都是自然输出的。在发现错误后，我们可以采用hashmap的方式进行 排序，虽然可以实现本次代码，但是对于之后的迭代代码上，并不通用，在后续中，我会对其中的错误进行讲述，当且先暂且使用hashmap。使用了hashmao之后可以将其中的电话号码，按 照我们所需要的排序进行。
Map<String, User> mm = new HashMap<>();
string是我们输入的电话号码的内容，将其和user用户一同放入进去。
改进建议：其中的很多部分是不完善的，比如说，那个计算每分钟多少钱的内容，我们是不够完善的，需要设计方法，实现对不同情况下产生不同的计算金额
以下是源代码：
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.Date;
import java.util.ArrayList;
public class Main {
public static void main(String[] args) throws ParseException {
Infor infor = new Infor();
infor.input();
}
}
class Infor{
public void input() throws ParseException {
Scanner in = new Scanner(System.in);
String[] x = new String[1000];
ArrayList<User> users = new ArrayList<>();//创建一个存储用户的数组
Map<String, User> mm = new HashMap<>();
int i = 0 , count = 0;
String [] str = new String[1000];
for(i = 0 ; i < 1000; i++) {
x[i] = in.nextLine();
String []a = x[i].split(" ");
if(numberBegin(x[i])){//注册账户正确
String []num = a[0].split("-");
User user = new User(num[1]);
for(int aa = 0 ;aa <= i ;aa++) {
if (x[i].equals(x[aa])&&i!=0 &&i!= aa)
break;
if (aa == i) {
users.add(user);//创建了一个用户
mm.put(num[1], user);
str[count] = num[1];
count++;
}
}
}
if(numberCallRecordBegin(a[0]) ){//通话记录格式正确
int j = 0,pos = 0;
String [] b = x[i].split(" ");
String [] c = b[0].split("-");//把第一个拆分了
if( numberEnd(b[1]) && isDate(b[2]) && isTime(b[3]) && isDate(b[4]) &&isTime(b[5])){//全部格式正确
for(j = 0; j < 1000;j++){
if(c[1].equals(str[j])) {
pos++;
break;
}
}
CallRecord callRecord = new CallRecord();
int result = 0;//开始地址
String endPlace = "";
result = getIsWhere(b[1]);
switch(result){
case 1: endPlace = "市内";break;
case 2: endPlace = "省内";break;
case 3: endPlace = "国内";break;
}
String startDate = b[2] + " " + b[3];
String endDate = b[4] + " " + b[5];
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
Date date1 = simpleDateFormat.parse(startDate);
Date date2 = simpleDateFormat.parse(endDate);
callRecord.setStartTime(date1);
callRecord.setEndTime(date2);
callRecord.setCallingNumber(c[1]);
callRecord.setAnswerNumber(b[1]);
callRecord.setCallingAddressAreaCode("南昌");
callRecord.setAnswerAddressAreaCode(endPlace);
if(pos == 1)
switch (result){
case 1:users.get(j).getUserRecords().addCallingInCityRecords(callRecord);break;
case 2:users.get(j).getUserRecords().addCallingInProvinceRecords(callRecord);break;
case 3:users.get(j).getUserRecords().addCallingInLandRecords(callRecord);break;
}
}
}
if(x[i].equals("end"))
break;
}
for(User user : mm.values()){
System.out.println(user.getNumber() +" "+ user.calCost() +" "+ (80 - user.calCost()) );
}
}
public boolean numberBegin(String a){//注册的账号的内容
if(a.matches("^[u][-][0-9]{11}[0-9]{0,1}[ ][0]"))
return true;
else
return false;
}
public boolean numberCallRecordBegin(String a){//通话记录的格式是否正确
if(a.matches("^[t][-][0-9]{10,12}"))
return true;
else
return false;
}
public boolean numberEnd(String a){//判断是打电话的内容
if(a.matches("^[0-9]{10,12}"))
return true;
else
return false;
}
public boolean isDate(String str) {//判断日期的合法性
boolean result = true;
SimpleDateFormat format = new SimpleDateFormat("yyyy.MM.dd");
try {
format.setLenient(false);
format.parse(str);
}catch (Exception e){
result = false;
}
String [] a = str.split("[.]");
if(a[1].matches("^([1-9]|[1][0-2])") && a[2].matches("^([0][1-9]|[1-9]|[1-3][0-9])"))
result = true;
else
result = false;
return result;
}
public boolean isTime(String str){//判断时间是否合法
boolean result = true;
SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");
try {
format.setLenient(false);
format.parse(str);
}catch (Exception e){
result = false;
}
String []a = str.split("[:]");
if(a[0].matches("^([0][0-9]|[1][0-9]|[2][0-3])") && a[1].matches("^([0][0-9]|[1-5][0-9])")
&&a[2].matches("^([0][0-9]|[1-5][0-9])") )
result = true;
else
result = false;
return result;
}
public int getIsWhere(String str){
int result = 0;
if(str.matches("^[0][7][9][1][0-9]{7,8}"))//市内电话
result = 1;
else if(str.matches("(([0][7][9][0-9][0-9]{7,8}))"))//省内电话
result = 2;
else if(str.matches("[0][7][0][1][0-9]{7,8}"))//省内电话
result = 2;
else//国内电话
result = 3;
return result;
}
}
class User {
private UserRecords userRecords = new UserRecords();//用户记录
private double balance = 100;//余额
private ChargeMode chargeMode ;//计费方式
private String number = "";//号码
public User(String number) {
this.number = number;
this.chargeMode = new LandlinePhoneCharging();
}
public double calBalance(){//总计剩余余额
return (balance - calCost() - chargeMode.getMonthlyRent());
}
public double calCost(){//总计消费余额,这里面没有信息消费
double cost = chargeMode.calCost(userRecords);
return cost;
}
public UserRecords getUserRecords() {
return userRecords;
}
public void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public ChargeMode getChargeMode() {
return chargeMode;
}
public void setChargeMode(ChargeMode chargeMode) {
this.chargeMode = chargeMode;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
}
class UserRecords {
private ArrayList<CallRecord> callingInCityRecords = new ArrayList<>();
private ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<>();
private ArrayList<CallRecord> callingInLandRecords = new ArrayList<>();
private ArrayList<CallRecord> answerInCityRecords = new ArrayList<>();
private ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<>();
private ArrayList<CallRecord> answerInLandRecords = new ArrayList<>();
private ArrayList<MessageRecord> sendMessageRecords = new ArrayList<>();
private ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<>();
public UserRecords() {
}
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 addAnswerInProvinceRecords(CallRecord callRecord){
answerInLandRecords.add(callRecord);
}
public void answerInLandRecords (CallRecord callRecord){
answerInLandRecords.add(callRecord);
}
public void addSendMessageRecords(MessageRecord messageRecord){
sendMessageRecords.add(messageRecord);
}
public void addReceiveMessageRecords(MessageRecord messageRecord){
receiveMessageRecords.add(messageRecord);
}
public ArrayList<CallRecord> getCallingInCityRecords() {
return callingInCityRecords;
}
public ArrayList<CallRecord> getCallingInProvinceRecords() {
return callingInProvinceRecords;
}
public ArrayList<CallRecord> getCallingInLandRecords() {
return callingInLandRecords;
}
public ArrayList<CallRecord> getAnswerInCityRecords() {
return answerInCityRecords;
}
public ArrayList<CallRecord> getAnswerInProvinceRecords() {
return answerInProvinceRecords;
}
public ArrayList<CallRecord> getAnswerInLandRecords() {
return answerInLandRecords;
}
public ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
public ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
}
abstract class CommunicationRecord{
protected String callingNumber;
protected String answerNumber;
public CommunicationRecord(){
}
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 CallRecord extends CommunicationRecord{
private Date startTime;
private Date endTime;
private String callingAddressAreaCode;
private String answerAddressAreaCode;
public CallRecord(){
}
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 MessageRecord extends CommunicationRecord{
private String message;
public MessageRecord(){
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
//还有继承的方法没有实现
}
abstract class ChargeMode {
private ArrayList<ChargeRule> chargeRules = new ArrayList<>();
private LandPhoneInProvinceRule landPhoneInProvinceRule = new LandPhoneInProvinceRule();
private LandPhoneInLandRule landPhoneInLandRule = new LandPhoneInLandRule();
private LandPhoneInCityRule landPhoneInCityRule = new LandPhoneInCityRule();
public ChargeMode(){
chargeRules.add(landPhoneInCityRule);
chargeRules.add(landPhoneInProvinceRule);
chargeRules.add(landPhoneInLandRule);
}
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 LandlinePhoneCharging extends ChargeMode{
private double monthlyRent = 20;
public LandlinePhoneCharging(){
}
@Override
public double calCost(UserRecords userRecords) {
//数据中有起始时间和终止时间
//打电话的地址和接电话的地址
//需要转换成数字
//需要
double cost1 = getChargeRules().get(0).calCost(userRecords.getCallingInCityRecords());
double cost2 = getChargeRules().get(1).calCost(userRecords.getCallingInProvinceRecords());
double cost3 = getChargeRules().get(2).calCost(userRecords.getCallingInLandRecords());
return cost1 + cost2 + cost3;
}
@Override
public double getMonthlyRent() {
return monthlyRent;
}
}
abstract class ChargeRule {
public abstract double calCost(ArrayList<CallRecord> callRecord);
}
abstract class CallChargeRule extends ChargeRule{
public abstract double calCost(ArrayList<CallRecord> callRecord);
}
class LandPhoneInLandRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecord) {//这是一个数组
double second = 0,cost = 0,second1;
for (int i = 0;i < callRecord.size() ;i++){
second = -(callRecord.get(i).getStartTime().getTime()-callRecord.get(i).getEndTime().getTime())/1000/60.0;
DecimalFormat df = new DecimalFormat("0");
second1 = Double.parseDouble(df.format(second));
if(second > second1)
second = second1 + 1;
else
second = second1;
cost = cost + second * 0.6;
DecimalFormat df1 = new DecimalFormat("0.0");
cost = Double.parseDouble(df1.format(cost));
}
return cost;
}
}
class LandPhoneInProvinceRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecord) {
double second = 0,cost = 0,second1 = 0;
for (int i = 0;i < callRecord.size() ;i++){
second = -(callRecord.get(i).getStartTime().getTime()-callRecord.get(i).getEndTime().getTime())/1000/60.0;
DecimalFormat df = new DecimalFormat("0");
second1 = Double.parseDouble(df.format(second));
if(second > second1)
second = second1 + 1;
else
second = second1;
cost = cost + second * 0.3;
DecimalFormat df1 = new DecimalFormat("0.0");
cost = Double.parseDouble(df1.format(cost));
}
return cost;
}
}
class LandPhoneInCityRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecord) {
double second = 0,cost = 0,second1 = 0;
for (int i = 0;i < callRecord.size() ;i++){
second = -(callRecord.get(i).getStartTime().getTime()-callRecord.get(i).getEndTime().getTime())/1000/60.0;
DecimalFormat df = new DecimalFormat("0");
second1 = Double.parseDouble(df.format(second));
if(second > second1)
second = second1 + 1;
else
second = second1;
cost = cost + second * 0.1;
DecimalFormat df1 = new DecimalFormat("0.0");
cost = Double.parseDouble(df1.format(cost));
}
return cost;
}
}
phone1
定义容器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类型)。
设计与分析：本题相对于开说就比较简单 ，按照题目要求，定义一个接口，在接口里面的抽象类 ，运用foreach循环获取你输入的内容就可以了，在需要的类Cylinder和类Cube中实现算法，计算 面积与 周长即可 。对其中还需要创建Container的数组，将其中的数据存储进去即可
计算其中的体积的方法：
static double sumofVolume(Container c[]) {
double Svolume = 0;
for( Container container : c){
Svolume = Svolume + container.volume();
}
return Svolume;
类比，我们还可以将其中的代码进行更改，变成面积的计算，其中的内容是在Container中的接口里的方法
踩坑心得：这次并没有踩坑，短短的代码，就可以实现其中的内容，没有踩坑心得噢。
改进建议：等大家来提出建议，题目内容比较少
以下是源代码：
import java.text.DecimalFormat;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int num = in.nextInt();
int i = 0;
Container []container = new Container[num];
while(i < num){
String name = in.next();
if(name.equals("cube")){
double a = in.nextDouble();
Cube cube = new Cube(a);
container[i] = cube;
}
if(name.equals("cylinder")){
double r = in.nextDouble();
double h = in.nextDouble();
Cylinder cylinder = new Cylinder(r,h);
container[i] = cylinder;
}
i++;
}
DecimalFormat df = new DecimalFormat("0.00");
double sumArea = Double.parseDouble(df.format(Container.sumofArea(container)));
double sumVolume = Double.parseDouble(df.format(Container.sumofVolume(container)));
System.out.println(sumArea);
System.out.println(sumVolume);
}
}
interface Container{
public static final double pi = 3.1415926;
public abstract double area();
public abstract double volume();
static double sumofArea(Container c[]) {
double Sarea = 0;
for(Container container : c){
Sarea = Sarea + container.area();
}
return Sarea;
}
static double sumofVolume(Container c[]) {
double Svolume = 0;
for( Container container : c){
Svolume = Svolume + container.volume();
}
return Svolume;
}
}
class Cube implements Container{
private double a;
public Cube(double a) {
this.a = a;
}
@Override
public double area() {
return a*a*6;
}
@Override
public double volume() {
return a*a*a;
}
}
class Cylinder implements Container{
private double r;
private double h;
public Cylinder(double r,double h) {
this.r = r;
this.h = h;
}
@Override
public double area() {
return pi * r * r*2 + 2*pi*r*h;
}
@Override
public double volume() {
return pi * r * r * h;
}
}
Container接口
题目三：对于上次的代码进行了迭代处理，拓展出了手机用户的模式
实现南昌市电信分公司的计费程序，假设该公司针对手机和座机用户分别采取了两种计费方案，分别如下：
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
设计与分析：本次代码主要是对上次的代码进行增加一些方法，其中主要是对上次的代码进行拓展，主要实现一些方法，比如说上次提到的，对于收费的问题，对于处在不同的位置，我们需要不同的计 算金额的方式
public double getPrice(ArrayList<CallRecord> callRecord,int i ){
double price = 0;
if (callRecord.get(i).getCallingAddressAreaCode().equals("市内"))//打电话的在市内
if (callRecord.get(i).getAnswerAddressAreaCode().equals("市内"))
price = 0.1;
if (callRecord.get(i).getCallingAddressAreaCode().equals("市内"))//打电话的在市内
if (callRecord.get(i).getAnswerAddressAreaCode().equals("省内"))
price = 0.2;
if (callRecord.get(i).getCallingAddressAreaCode().equals("市内"))//打电话的在市内
if (callRecord.get(i).getAnswerAddressAreaCode().equals("国内"))
price = 0.3;
return price;
}
在算法的主要内容中，对于其中的不同的地方进行，进行不同的返还价格，这样既可以了。同时，我们还要对其中后来添加的方法进行加进去。
踩坑心得：没有按照顺序将其中的收费模式调用进去，导致调用的方法的不是我所需要的方法，最后产生了很多错误
没有对很多类初始化，类多了，导致老是没有按照要求进行初始化，导致了很多类的问题，数据没有传输进去
对于之前的设计不合理，导致计算的时候产生，进错了位置
hashmap无法满足其中的要求，因此需要采用treemap，来实现其中的内容
但是还是有两分没有拿到，至今没有解决
改进建议：对于一些正则表达式，还是需要一直更改，对于电话卡中的排序，算法上还有很多的重复赘余的内容，需要对其中的内容稍微修改一下，更改一下其中不必要的内容。
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.text.DecimalFormat;
import java.util.ArrayList;
class Main {
public static void main(String[] args) throws ParseException {
Infor infor = new Infor();
infor.input();
}
}
class Infor{
public void input() throws ParseException {
Scanner in = new Scanner(System.in);
String[] x = new String[1000];
ArrayList<User> users = new ArrayList<>();//创建一个存储用户的数组
TreeMap<String, User> mm = new TreeMap<>();
int i = 0 , count = 0;
String [] str = new String[1000];
for(i = 0 ; i < 1000; i++) {
x[i] = in.nextLine();
String []a = x[i].split(" ");
if(x[i].equals("end"))
break;
else if(numberBegin(x[i]) != 0){//注册账户正确
String []num = a[0].split("-");
User user = new User(num[1]);
for(int aa = 0 ;aa <= i ;aa++) {
if (x[i].equals(x[aa])&&i!=0 &&i!= aa)
break;
if (aa == i) {
users.add(user);//创建了一个用户
mm.put(num[1], user);
str[count] = num[1];
count++;
}
}
}
else if(getType(x[i]) ){//通话记录格式正确
int j = 0,k = 0,time1 = 0,time2 = 0;
String [] b = x[i].split(" ");
String [] c = b[0].split("-");//把第一个拆分了
int [] pos1 = new int[3];
int [] pos2 = new int[3];
//找到两个日期的位置，把日期的数据加入进去
for(int num1 =0,num2 = 0; k < b.length; k++){
if(isDate(b[k])){
pos1[num1] = k;
num1 ++;
}
if(isTime(b[k])){
pos2[num2] = k;
num2 ++;
}
if(num1 == 2 && num2 ==2)
break;
}
//全部格式正确
if(!x[i].equals("end")) {
//判断第号码是手机还是电话
int phone1, phone2;
int place1, place2;
phone1 = numberCallRecordBegin(b[0]);//第一个号码是电话还是手机
//place1 是第一个号码所在的位置
//place2 是第二个号码所在的位置
if (phone1 == 1) {//座机
place1 = 0;
phone2 = numberEnd(b[1]);
if (phone2 == 1)
place2 = 1;
else
place2 = 2;
} else {
place1 = 1;
phone2 = numberEnd(b[2]);
if (phone2 == 1)
place2 = 2;
else
place2 = 3;
}
int isplace = place2;
if(phone2 == 2)
isplace = place2 - 1;
for (j = 0; str[j] != null; j++) {//判断是打电话的吗？
if (c[1].equals(str[j])) {
time1++;
break;
}
}
for (k = 0; str[k] != null; k++) {
if (b[isplace].equals(str[k])) {
time2++;
break;
}
}
CallRecord callRecord = new CallRecord();
int result1 = 0;
String startPlace = "";
if (phone1 == 1)
result1 = getIsWhere(c[place1+1]);
else
result1 = getIsWhere(b[place1]);
int result2 = 0;//开始地址
String endPlace = "";
result2 = getIsWhere(b[place2]);
switch (result1) {
case 1:
startPlace = "市内";
break;
case 2:
startPlace = "省内";
break;
case 3:
startPlace = "国内";
break;
}
switch (result2) {
case 1:
endPlace = "市内";
break;
case 2:
endPlace = "省内";
break;
case 3:
endPlace = "国内";
break;
}
String startDate = b[pos1[0]] + " " + b[pos2[0]];
String endDate = b[pos1[1]] + " " + b[pos2[1]];
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
Date date1 = simpleDateFormat.parse(startDate);
Date date2 = simpleDateFormat.parse(endDate);
callRecord.setStartTime(date1);
callRecord.setEndTime(date2);
callRecord.setCallingNumber(c[1]);
callRecord.setAnswerNumber(b[1]);
callRecord.setCallingAddressAreaCode(startPlace);
callRecord.setAnswerAddressAreaCode(endPlace);
if(phone1 == 1)
result1 = result2;
if (time1 == 1)
switch (result1) {//加入数据
case 1:
users.get(j).getUserRecords().addCallingInCityRecords(callRecord);
break;
case 2:
users.get(j).getUserRecords().addCallingInProvinceRecords(callRecord);
break;
case 3:
users.get(j).getUserRecords().addCallingInLandRecords(callRecord);
break;
}
if (time2 == 1)
switch (result2) {//加入数据
case 1:
users.get(k).getUserRecords().addAnswerInCityRecords(callRecord);
break;
case 2:
users.get(k).getUserRecords().addAnswerInProvinceRecords(callRecord);
break;
case 3:
users.get(k).getUserRecords().addAnswerInLandRecords(callRecord);
break;
}
}
}
}
for(User user : mm.values()){
System.out.println(user.getNumber() +" "+ user.calCost() +" "+ user.calBalance() );
}
}
public int numberBegin(String a){//注册的账号的内容
if(a.matches("^[u][-][1][0-9]{10}[ ][1]"))
return 2;
else if(a.matches("^[u][-][0][0-9]{9,11}[ ][0]"))
return 1;
else
return 0;
}
public boolean getType(String str) {
String[] a = str.split(" ");
boolean result = false;
if (numberCallRecordBegin(a[0]) == 1) {//第一个是座机
if (numberEnd(a[1]) == 1) {//第二个是座机
if (isDate(a[2]) && isTime(a[3]) && isDate(a[4]) && isTime(a[5]))
result = true;
else
result = false;
}
if (numberEnd(a[1]) == 2) {//第二个是手机
if (isDate(a[3]) && isTime(a[4]) && isDate(a[5]) && isTime(a[6]) && a[2].matches("^[0][0-9]{2,3}"))
result = true;
else
result = false;
}
}
if (numberCallRecordBegin(a[0]) == 2&& a[1].matches("^[0][0-9]{2,3}")) {//第一个是手机
if (numberEnd(a[2]) == 1 ) {//第二个是座机
if (isDate(a[3]) && isTime(a[4]) && isDate(a[5]) && isTime(a[6]))
result = true;
else
result = false;
}
if (numberEnd(a[2]) == 2&& a[3].matches("^[0][0-9]{2,3}")) {//第二个是手机
if (isDate(a[4]) && isTime(a[5]) && isDate(a[6]) && isTime(a[7]) )
result = true;
else
result = false;
}
}
return result;
}
public int numberCallRecordBegin(String a){//通话记录的格式是否正确
int result = 0;
if(a.matches("^[t][-][1][0-9]{10}"))
result = 2;//电话
else if(a.matches("^[t][-][0][0-9]{9,11}") )
result = 1;//座机
else
result = 0;
return result;
}
public int numberEnd(String a){//判断是打电话的内容
int result = 0;
if(a.matches("^[1][0-9]{10}"))
result = 2;
else if(a.matches("^[0][0-9]{9,11}") )
result = 1;
else
result = 0;
return result;
}
public boolean isDate(String str) {//判断日期的合法性
boolean result = true;
SimpleDateFormat format = new SimpleDateFormat("yyyy.MM.dd");
try {
format.setLenient(false);
format.parse(str);
}catch (Exception e){
result = false;
}
return result;
}
public boolean isTime(String str){//判断时间是否合法
boolean result = true;
SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");
try {
format.setLenient(false);
format.parse(str);
}catch (Exception e){
result = false;
}
return result;
}
public int getIsWhere(String str) {
int result = 0;
if (str.matches("^[0][7][9][1][0-9]{7,8}") || str.matches("[0][7][9][1]"))//市内电话
result = 1;
else if (str.matches("[0][7][9][0-9][0-9]{7,8}") || str.matches("[0][7][9][0-9]"))//省内电话
result = 2;
else if (str.matches("[0][7][0][1][0-9]{7,8}") || str.matches("[0][7][0][1]"))//省内电话
result = 2;
else//国内电话
result = 3;
return result;
}
// public void getType(String str){
// str.matches("^[t][-][0-9]{11,12}[ ]")
// }
}
abstract class ChargeMode {
private ArrayList<ChargeRule> chargeRules = new ArrayList<>();
private LandPhoneInProvinceRule landPhoneInProvinceRule = new LandPhoneInProvinceRule();
private LandPhoneInLandRule landPhoneInLandRule = new LandPhoneInLandRule();
private LandPhoneInCityRule landPhoneInCityRule = new LandPhoneInCityRule();
private MobilePhoneCallInCityRule mobilePhoneCallInCityRule = new MobilePhoneCallInCityRule();
private MobilePhoneAnswerInCityRule mobilePhoneAnswerInCityRule = new MobilePhoneAnswerInCityRule();
private MobilePhoneCallInProvinceRule mobilePhoneCallInProvinceRule = new MobilePhoneCallInProvinceRule();
private MobilePhoneAnswerInProvinceRule mobilePhoneAnswerInProvinceRule = new MobilePhoneAnswerInProvinceRule();
private MobilePhoneCallInLandRule mobilePhoneCallInLandRule = new MobilePhoneCallInLandRule();
private MobilePhoneAnswerInLandRule mobilePhoneAnswerInLandRule = new MobilePhoneAnswerInLandRule();
public ChargeMode(){
chargeRules.add(landPhoneInCityRule);
chargeRules.add(landPhoneInProvinceRule);
chargeRules.add(landPhoneInLandRule);
chargeRules.add(mobilePhoneCallInCityRule);
chargeRules.add(mobilePhoneAnswerInCityRule);
chargeRules.add(mobilePhoneCallInProvinceRule);
chargeRules.add(mobilePhoneAnswerInProvinceRule);
chargeRules.add(mobilePhoneCallInLandRule);
chargeRules.add(mobilePhoneAnswerInLandRule);
}
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 LandlinePhoneCharging extends ChargeMode{
private double monthlyRent = 20;
public LandlinePhoneCharging(){
}
@Override
public double calCost(UserRecords userRecords) {
//数据中有起始时间和终止时间
//打电话的地址和接电话的地址
//需要转换成数字
//需要
double cost1 = getChargeRules().get(0).calCost(userRecords.getCallingInCityRecords());
double cost2 = getChargeRules().get(1).calCost(userRecords.getCallingInProvinceRecords());
double cost3 = getChargeRules().get(2).calCost(userRecords.getCallingInLandRecords());
return cost1 + cost2 + cost3 ;
}
@Override
public double getMonthlyRent() {
return monthlyRent;
}
}
class MobilePhoneCharging extends ChargeMode{
private double monthlyRent = 15;
@Override
public double calCost(UserRecords userRecords) {
double cost4 = getChargeRules().get(3).calCost(userRecords.getCallingInCityRecords());
double cost5 = getChargeRules().get(4).calCost(userRecords.getAnswerInCityRecords());
double cost6 = getChargeRules().get(5).calCost(userRecords.getCallingInProvinceRecords());
double cost7 = getChargeRules().get(6).calCost(userRecords.getAnswerInProvinceRecords());
double cost8 = getChargeRules().get(7).calCost(userRecords.getCallingInLandRecords());
double cost9 = getChargeRules().get(8).calCost(userRecords.getAnswerInLandRecords());
return cost4 + cost5 + cost6 + cost7 + cost8 + cost9;
}
@Override
public double getMonthlyRent() {
return monthlyRent;
}
}
abstract class ChargeRule {
public abstract double calCost(ArrayList<CallRecord> callRecord);
}
abstract class CallChargeRule extends ChargeRule{
public abstract double calCost(ArrayList<CallRecord> callRecord);
}
class LandPhoneInLandRule extends CallChargeRule{//表明使用的电话在国内
@Override
public double calCost(ArrayList<CallRecord> callRecord) {//这是一个数组
double second = 0,cost = 0,second1;
for (int i = 0;i < callRecord.size() ;i++){
second = -(callRecord.get(i).getStartTime().getTime()-callRecord.get(i).getEndTime().getTime())/1000/60.0;
DecimalFormat df = new DecimalFormat("0");
second1 = Double.parseDouble(df.format(second));
if(second > second1)
second = second1 + 1;
else
second = second1;
cost = cost + second * 0.6;
DecimalFormat df1 = new DecimalFormat("0.0");
cost = Double.parseDouble(df1.format(cost));
}
return cost;
}
}
class LandPhoneInProvinceRule extends CallChargeRule{//表明使用的电话在省内
@Override
public double calCost(ArrayList<CallRecord> callRecord) {//打电话
double second = 0,cost = 0,second1 = 0;
for (int i = 0;i < callRecord.size() ;i++){
second = -(callRecord.get(i).getStartTime().getTime()-callRecord.get(i).getEndTime().getTime())/1000/60.0;
DecimalFormat df = new DecimalFormat("0");
second1 = Double.parseDouble(df.format(second));
if(second > second1)
second = second1 + 1;
else
second = second1;
cost = cost + second * 0.3;
DecimalFormat df1 = new DecimalFormat("0.0");
cost = Double.parseDouble(df1.format(cost));
}
return cost;
}
}
class LandPhoneInCityRule extends CallChargeRule{//表明使用的电话在市内
@Override
public double calCost(ArrayList<CallRecord> callRecord) {//拨打的电话是在市内
double second = 0,cost = 0,second1 = 0;
for (int i = 0;i < callRecord.size() ;i++){
second = -(callRecord.get(i).getStartTime().getTime()-callRecord.get(i).getEndTime().getTime())/1000/60.0;
DecimalFormat df = new DecimalFormat("0");
second1 = Double.parseDouble(df.format(second));
if(second > second1)
second = second1 + 1;
else
second = second1;
cost = cost + second * 0.1;
DecimalFormat df1 = new DecimalFormat("0.0");
cost = Double.parseDouble(df1.format(cost));
}
return cost;
}
}
class MobilePhoneCallInCityRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecord) {
double second = 0, cost = 0, second1 = 0;
double price = 0;
for (int i = 0; i < callRecord.size(); i++) {
second = (callRecord.get(i).getEndTime().getTime() - callRecord.get(i).getStartTime().getTime()) /60000.0;
DecimalFormat df = new DecimalFormat("0");
second1 = Double.parseDouble(df.format(second));
if (second > second1)
second = second1 + 1;
else
second = second1;
price = getPrice(callRecord,i);//确定单价
cost = cost + second * price;
DecimalFormat df1 = new DecimalFormat("0.0");
cost = Double.parseDouble(df1.format(cost));
}
return cost;
}
public double getPrice(ArrayList<CallRecord> callRecord,int i ){
double price = 0;
if (callRecord.get(i).getCallingAddressAreaCode().equals("市内"))//打电话的在市内
if (callRecord.get(i).getAnswerAddressAreaCode().equals("市内"))
price = 0.1;
if (callRecord.get(i).getCallingAddressAreaCode().equals("市内"))//打电话的在市内
if (callRecord.get(i).getAnswerAddressAreaCode().equals("省内"))
price = 0.2;
if (callRecord.get(i).getCallingAddressAreaCode().equals("市内"))//打电话的在市内
if (callRecord.get(i).getAnswerAddressAreaCode().equals("国内"))
price = 0.3;
return price;
}
}
class MobilePhoneAnswerInCityRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecord) {
return 0;
}
}
class MobilePhoneCallInProvinceRule extends CallChargeRule{//这些都是打电话的
@Override
public double calCost(ArrayList<CallRecord> callRecord) {
double second = 0, cost = 0, second1 = 0;
double price = 0;
for (int i = 0; i < callRecord.size(); i++) {
second = -(callRecord.get(i).getStartTime().getTime() - callRecord.get(i).getEndTime().getTime()) / 1000 / 60.0;
DecimalFormat df = new DecimalFormat("0");
second1 = Double.parseDouble(df.format(second));
if (second > second1)
second = second1 + 1;
else
second = second1;
price = getPrice(callRecord,i);//确定单价
cost = cost + second * price;
DecimalFormat df1 = new DecimalFormat("0.0");
cost = Double.parseDouble(df1.format(cost));
}
return cost;
}
public double getPrice(ArrayList<CallRecord> callRecord,int i ){
double price = 0;
if (callRecord.get(i).getCallingAddressAreaCode().equals("省内"))//打电话的在市内
price = 0.3;
return price;
}
}
class MobilePhoneAnswerInProvinceRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecord) {
return 0;
}
}
class MobilePhoneCallInLandRule extends CallChargeRule{//这些都是打电话的
@Override
public double calCost(ArrayList<CallRecord> callRecord) {
double second = 0, cost = 0, second1 = 0;
double price = 0;
for (int i = 0; i < callRecord.size(); i++) {
second = -(callRecord.get(i).getStartTime().getTime() - callRecord.get(i).getEndTime().getTime()) / 1000 / 60.0;
DecimalFormat df = new DecimalFormat("0");
second1 = Double.parseDouble(df.format(second));
if (second > second1)
second = second1 + 1;
else
second = second1;
price = getPrice(callRecord,i);//确定单价
cost = cost + second * price;
DecimalFormat df1 = new DecimalFormat("0.0");
cost = Double.parseDouble(df1.format(cost));
}
return cost;
}
public double getPrice(ArrayList<CallRecord> callRecord,int i ){
double price = 0;
if (callRecord.get(i).getCallingAddressAreaCode().equals("国内"))//打电话的在市内
price = 0.6;
return price;
}
}
class MobilePhoneAnswerInLandRule extends CallChargeRule{
@Override
public double calCost(ArrayList<CallRecord> callRecord) {
double second = 0, cost = 0, second1 = 0;
double price = 0;
for (int i = 0; i < callRecord.size(); i++) {
second = -(callRecord.get(i).getStartTime().getTime() - callRecord.get(i).getEndTime().getTime()) / 1000 / 60.0;
DecimalFormat df = new DecimalFormat("0");
second1 = Double.parseDouble(df.format(second));
if (second > second1)
second = second1 + 1;
else
second = second1;
price = getPrice(callRecord,i);//确定单价
cost = cost + second * price;
DecimalFormat df1 = new DecimalFormat("0.0");
cost = Double.parseDouble(df1.format(cost));
}
return cost;
}
public double getPrice(ArrayList<CallRecord> callRecord,int i ){
double price = 0;
if (callRecord.get(i).getAnswerAddressAreaCode().equals("国内"))//打电话的在市内
price = 0.3;
return price;
}
}
class UserRecords {
private ArrayList<CallRecord> callingInCityRecords = new ArrayList<>();
private ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<>();
private ArrayList<CallRecord> callingInLandRecords = new ArrayList<>();
private ArrayList<CallRecord> answerInCityRecords = new ArrayList<>();
private ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<>();
private ArrayList<CallRecord> answerInLandRecords = new ArrayList<>();
private ArrayList<MessageRecord> sendMessageRecords = new ArrayList<>();
private ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<>();
public UserRecords() {
}
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 addAnswerInProvinceRecords(CallRecord callRecord){
answerInProvinceRecords.add(callRecord);
}
public void addAnswerInLandRecords (CallRecord callRecord){
answerInLandRecords.add(callRecord);
}
public void addSendMessageRecords(MessageRecord messageRecord){
sendMessageRecords.add(messageRecord);
}
public void addReceiveMessageRecords(MessageRecord messageRecord){
receiveMessageRecords.add(messageRecord);
}
public ArrayList<CallRecord> getCallingInCityRecords() {
return callingInCityRecords;
}
public ArrayList<CallRecord> getCallingInProvinceRecords() {
return callingInProvinceRecords;
}
public ArrayList<CallRecord> getCallingInLandRecords() {
return callingInLandRecords;
}
public ArrayList<CallRecord> getAnswerInCityRecords() {
return answerInCityRecords;
}
public ArrayList<CallRecord> getAnswerInProvinceRecords() {
return answerInProvinceRecords;
}
public ArrayList<CallRecord> getAnswerInLandRecords() {
return answerInLandRecords;
}
public ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
public ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
}
abstract class CommunicationRecord{
protected String callingNumber;
protected String answerNumber;
public CommunicationRecord(){
}
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 CallRecord extends CommunicationRecord{
private Date startTime;
private Date endTime;
private String callingAddressAreaCode;
private String answerAddressAreaCode;
public CallRecord(){
}
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 MessageRecord extends CommunicationRecord{
private String message;
public MessageRecord(){
}
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(String number) {
this.number = number;
if(number.matches("^[1][0-9]{10}"))
this.chargeMode = new MobilePhoneCharging();
else
this.chargeMode = new LandlinePhoneCharging();
}
public double calBalance(){//总计剩余余额
return (balance - calCost() - chargeMode.getMonthlyRent());
}
public double calCost(){//总计消费余额,这里面没有信息消费
double cost = chargeMode.calCost(userRecords);
return cost;
}
public UserRecords getUserRecords() {
return userRecords;
}
public void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public ChargeMode getChargeMode() {
return chargeMode;
}
public void setChargeMode(ChargeMode chargeMode) {
this.chargeMode = chargeMode;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
}
View Code
题目三：
实现一个简单的电信计费程序，针对手机的短信采用如下计费方式：
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”结束。
设计与分析：设计出一个需要的正则来判断信息内容是否正确，
在添加一个判断出信息开户的正则表达式，注意对于信息内容要求
收费模式上添加心得收费方法，信息长短上的收费需要注意
计算上添加新的月租和算法
踩坑心得：对于短信的计费方式上，理解存在一定的问题，导致计算上有问题
信息的内容没有了解清楚，题目中的要求是：短信内容只能由数字、字母、空格、英文逗号、英文句号组成
我的切割函数时，切割的是以空格的方式，导致一直出错，无法对信息内容进行统计，在最后没办法的情况下，使用了信息长度加一的方式
总结：对于这次作业来说，更多的是设计，但是很多的设计都不是自己设计的，所以很多实现的是比较快的，但是最多的是自己的细节处理不够好，导致存在了很多的错误，在最开始的时候，我们应该 做出很多的需求分析，从不同的方面，大的框架上，到类的设计，再到需要的方法设计，对于自己需要哪些方法，需要的方法内容大体上如何设计，应该在最开始的时候设计好。对于书写代码的 时候，应该注意到自己的细节，而不是盲目的去写，有时候一个很小的错误，比如说等于号之类的，都会导致很大的错误，这些都是需要注意的，还有对于hashset，map,等等学会使用。对于自 己最近是学习到了很多，对于类的设计已经好了很多，细节上的处理已经有了很大的改变，也会对于一些抽象类接口的作用和使用方法上，有了很多新的认识，还有内部类的使用，foreach等等， 于我们写代码的人，需要有持之以恒的精神，不要总是过一会儿就放弃，对于错误的测试点，需要自己慢慢去啃，从教训中汲取经验，才能在最后开出花朵。
标签：10,题目,double,08,callRecord,second,ArrayList,new,public 来源： https://www.cnblogs.com/en-em-em/p/16384024.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。