前言：

　　最近几周都在琢磨电信计费这系列的题目，其中涉及到了继承、接口、集合框架和抽象类等知识点，总体来说难度较高。

• 继承是面向对象语法的三大特征之一。继承可以降低代码编写的冗余度，提高编程的效率。通过继承，子类获得了父类的成员变量和方法。一个子类如何继承父类的字段和方法，如何修改从父类继承过来的子类的方法呢。今天我们开始学习有关Java继承的知识。是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。

• Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类，既接口中的方法必须全部是抽象方法。
• 普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。那么什么叫抽象方法呢？在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。而拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明。

• 抽象类的使用原则如下：
  （1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；
  （2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
  （3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
  （4）子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；

设计与分析：

（这是pta中的一道电信计费题目）　　

　　实现一个简单的电信计费程序，针对手机的短信采用如下计费方式：
　　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。

根据以上类图，可以写出如下代码：

import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

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

String dateS;
String dateE;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
ArrayList<User> users = new ArrayList<>();
String x = in.nextLine();
while (!MessagePh(x)) {
if(x.charAt(0)!='m'){
if (x.charAt(0) == 'u') {
String t = x.substring(2);
String[] ak = t.split(" +");
if((Ph(x))&&!repeat(users,ak[0])){
users.add(new User(ak[0]));
}
x = in.nextLine();
continue;
}
x = in.nextLine();
}
}
while (!x.equals("end")){
if (!x.equals("")) {
if(x.charAt(0)=='m'){
if(MessagePh(x)){
for (User user:users){
String[] ak=x.split(" +");
String s=ak[0].substring(2);
if(user.getNumber().equals(s)){
int num=ak[0].length()+ak[1].length()+2;
String message = x.substring(num);
int mes=0;
mes=message.length()/10;
if(message.length()%10>0){
mes+=1;
}
user.setMessageNum(user.getMessageNum()+mes);
}

}}
}
x = in.nextLine();
continue;
}
x=in.nextLine();
}

String []all=new String[users.size()];
for (int i=0;i<users.size();i++){
all[i]=users.get(i).getNumber()+" "+tran(users.get(i).calBalance())+" "+tran(users.get(i).getBalance());
}
Arrays.sort(all);
if(users.size()!=0){
for (int i=0;i<users.size();i++){
System.out.println(all[i]);
}
}
}
public static String format1(double x){
return String.format("%.1f",x);
}
public static boolean judgePr(String x,String y){
return x.substring(0, 3).equals(y.substring(0, 3));
}
public static boolean judgeCity(String x,String y){
return x.substring(0, 4).equals(y.substring(0, 4));
}
public static String tran(double x) {
String str_d = String.valueOf(x);
str_d = str_d.substring(str_d.indexOf(".") + 1);
int len = str_d.length();
len = 1;
String out = String.format("%." + len + "f", x);
return out;
}
public static boolean repeat(ArrayList<User> users,String x){
int i=0;
for (User user1:users){
if(user1.getNumber().equals(x)){
i++;
}
}
return i!=0;
}
public static boolean Ph(String x) {
String w;
w = "[u][-][1][0-9][0-9]{9}\\s[3]";
if(x.matches(w))
return true;
else
return false;
}
public static boolean MessagePh(String x){
String message="[a-zA-Z0-9.,\\s]*$";
String w= "^[m]-1[0-9]{10}\\s1[0-9]{10}\\s"+message;
if(x.matches(w))
return true;
else
return false;
}
}

abstract class CommunicationRecord{
String callingNumber;
String answerNumber;
public String getCallingNumber(){
return callingNumber;
}

public String getAnswerNumber() {
return answerNumber;
}

public void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}

public void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
}
class CallRecord extends CommunicationRecord{
private Date startTime=new Date();
private Date endTime=new Date();
private String callingAddressAreaCode;
private String 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;
}
public long timeToTime(){
return endTime.getTime()-startTime.getTime();
}
}
class MessageRecord extends CommunicationRecord{
private String message;

public String getMessage() {
return message;
}

public void setMessage(String message) {
this.message = message;
}
}
abstract class ChargeRule{

}
abstract class CallChargeRule{
abstract double calCost(ArrayList<CallRecord> callRecords);
}

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> callingCityToPrinceRecords = 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 addCallingCityToPrinceRecords (CallRecord callRecord){
callingCityToPrinceRecords.add(callRecord);
}
public void addCallingInProvinceRecords (CallRecord callRecord){
callingInProvinceRecords.add(callRecord);
}
public void addCallingInLandRecords (CallRecord callRecord){
callingInLandRecords.add(callRecord);
}
public void addAnswerInCityRecords (CallRecord answerRecord){
answerInCityRecords.add(answerRecord);
}
public void addAnswerInProvinceRecords (CallRecord answerRecord){
answerInProvinceRecords.add(answerRecord);
}
public void addAnswerInLandRecords (CallRecord answerRecord){
answerInLandRecords.add(answerRecord);
}
public void addSendMessageRecords (MessageRecord sendMessageRecord){
sendMessageRecords.add(sendMessageRecord);
}
public void addReceiveMessageRecords (MessageRecord receiveMessageRecord){
receiveMessageRecords.add(receiveMessageRecord);
}
public ArrayList<CallRecord> getAnswerInCityRecords() {
return answerInCityRecords;
}
public ArrayList<CallRecord> getAnswerInLandRecords() {
return answerInLandRecords;
}
public ArrayList<CallRecord> getAnswerInProvinceRecords() {
return answerInProvinceRecords;
}
public ArrayList<CallRecord> getCallingInCityRecords() {
return callingInCityRecords;
}
public ArrayList<CallRecord> getCallingInLandRecords() {
return callingInLandRecords;
}
public ArrayList<CallRecord> getCallingInProvinceRecords() {
return callingInProvinceRecords;
}
public ArrayList<MessageRecord> getReceiveMessageRecords() {
return receiveMessageRecords;
}
public ArrayList<MessageRecord> getSendMessageRecords() {
return sendMessageRecords;
}
public void setAnswerInCityRecords(ArrayList<CallRecord> answerInCityRecords) {
this.answerInCityRecords = answerInCityRecords;
}
public void setAnswerInLandRecords(ArrayList<CallRecord> answerInLandRecords) {
this.answerInLandRecords = answerInLandRecords;
}
public void setAnswerInProvinceRecords(ArrayList<CallRecord> answerInProvinceRecords) {
this.answerInProvinceRecords = answerInProvinceRecords;
}
public void setCallingInCityRecords(ArrayList<CallRecord> callingInCityRecords) {
this.callingInCityRecords = callingInCityRecords;
}
public void setCallingInLandRecords(ArrayList<CallRecord> callingInLandRecords) {
this.callingInLandRecords = callingInLandRecords;
}
public void setCallingInProvinceRecords(ArrayList<CallRecord> callingInProvinceRecords) {
this.callingInProvinceRecords = callingInProvinceRecords;
}
public void setReceiveMessageRecords(ArrayList<MessageRecord> receiveMessageRecords) {
this.receiveMessageRecords = receiveMessageRecords;
}
public void setSendMessageRecords(ArrayList<MessageRecord> sendMessageRecords) {
this.sendMessageRecords = sendMessageRecords;
}
public ArrayList<CallRecord> getCallingCityToPrinceRecords() {
return callingCityToPrinceRecords;
}
public void setCallingCityToPrinceRecords(ArrayList<CallRecord> callingCityToPrinceRecords) {
this.callingCityToPrinceRecords = callingCityToPrinceRecords;
}
}
abstract class ChargeMode{
private ArrayList<ChargeRule> chargeRules=new ArrayList<>();
public ArrayList<ChargeRule> getChargeRules() {
return chargeRules;
}
public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
this.chargeRules = chargeRules;
}
abstract public double calCost(UserRecords userRecords);
abstract public double getMonthlyRent();
}
class LandlinePhoneCharging extends ChargeMode{
private double monthlyRent=20;
@Override
public double calCost(UserRecords userRecords) {
return 0;
}
@Override
public double getMonthlyRent() {
return monthlyRent;
}
public void setMonthlyRent(double monthlyRent) {
this.monthlyRent = monthlyRent;
}
}
class User implements Comparable<User>{
private double messageFee=0;
private double messageNum=0;
private UserRecords userRecords=new UserRecords();
private double balance=100;
private ChargeMode chargeMode;
private String number;
public User(String number){
this.number=number;
}
public UserRecords getUserRecords() {
return userRecords;
}
public void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
public double getBalance() {
chargeMode=new LandlinePhoneCharging();
balance=balance-calBalance();
return balance;
}

public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public ChargeMode getChargeMode() {
return chargeMode;
}
public void setChargeMode(ChargeMode chargeMode) {
this.chargeMode = chargeMode;
}
public double calBalance(){
return getMessageFee();
}
public int compareTo(User o){
return Integer.getInteger(this.getNumber().substring(10,12))-Integer.getInteger(o.getNumber().substring(10,12));
}
@Override
public String toString() {
return number+" "+calBalance()+" "+getBalance();
}

public double getMessageNum() {
return messageNum;
}

public void setMessageNum(double messageNum) {
this.messageNum = messageNum;
}

public double getMessageFee() {
if(messageNum<=3){
messageFee=messageNum*0.1;
}
else if(messageNum>3&&messageNum<=5){
messageFee=0.3+(messageNum-3)*0.2;
}
else if(messageNum>5){
messageFee=0.7+(messageNum-5)*0.3;
}
return messageFee;
}

public void setMessageFee(double messageFee) {
this.messageFee = messageFee;
}
}

相对于前面两道题，这一道题无疑简单了很多，类图清晰，也给了我们很多提示。但是不得不说一句。学习上的懈怠都会在做练习的时候体现的淋漓尽致，所以稳扎稳打是永远不会过时的处事方式，像前面两道题，说实话我还是有一定的畏难情绪的，所以基本都没怎么去写。写的话漏洞也很多......

采坑心得：

• 缺乏自主编程能力，不参照类图的话比较容易迷失方向，不知道如何下手，换句话说应该是写题写的太少了。
• 关于类的设计的题目，当时以为给出的是完整的类图，没有多看看就敲代码去了，然后越来越混乱。所以说拿到题目应该把大致的方向找好。
• 数据的存放也有问题，因为对应的区号并不是连串的，所以就可能要用到正则表达式去对区号进行匹配检测，否则繁重的工作量大大提升了代码的耦合性。

改进建议：

• 很多算法用起来十分的不熟练，显得很繁琐也很呆板，希望可以通过更多的学习提高自己的能力。

• 重新设计新的类，包括了新的数据存放数组和方法，节省代码空间。

  多做继承应用之类的题目，不能第一时间反应出来总归到底是做的题目不够写的代码太少了。

• 对于正则表达式的运用不够熟练，对于Java的集中设计原则不会合理的运用，对于一些集合类的掌握程度不高，每次作业花费的时间较长，需要查阅大量的资料才能解决问题，作业的成功率不高，得到的分数不高。解决方法：遇到不懂的知识点上网查阅资料，请教他人，多看书记住一些基本的知识点。

总结：

• 面向对象和面向过程的思想有着本质上的区别,作为面向对象的思维来说，当你拿到一个问题时，你分析这个问题不再是第一步先做什么，第二步再做什么，这是面向过程的思维，你应该分析这个问题里面有哪些类和对象，这是第一点，然后再分析这些类和对象应该具有哪些属性和方法。这是第二点。最后分析类和类之间具体有什么关系，这是第三点。这些都是面向过程思想所不具备的，在解决一些问题的时候，运用面向对象的思想来编写程序解决问题才是最好的解决方式。面向过程是一种基础的方法，它考虑的是实际的实现.一般的面向过程是从上往下步步求精，所以面向过程最重要的是模块化的思想方法。
• 通过本学期的PTA作业学会了正则表达式的使用。正则表达式是一种可以用于模式匹配和替换的强有力的工具，可以看成是多个字符的组成规则。
• 了解到Java中存放对象的三种类型的集合：Set（集）List（表）Map（映射）。Set是最简单的集合，集合中的对象排序是没有特定方式的，并且没有重复的对象，Set的接口的两个主要实现类是：HashSet和TreeSet。HashSet：按照哈希算法来存取集合中的对象，HashSet会调用对象的hashCode（）方法获得哈希码，从而算出对象在集合中的位置。TreeSet：采用树结构来存储数据，每一个元素都是一个节点，一层一层的依次排列。List以线性方式存储元素，允许集合中存放重复元素。List接口的主要实现来是ArrayList和LinkedList。Map：集合中的每一个元素包含一对键对象和值对象，集合中的键对象不能重复，值对象可以重复。HashMap按照哈希算法来存取键值对象。Java中的集合类能够使程序方便的存储和操纵数目不固定的一组数据。

• 面向对象编程不能注重于按步骤一步一步解决问题，而应该注重于将问题中的部分分成各个对象，各司其职，谁做了什么事，谁又做了什么事，他们共同作用的结果解决了一件事。可以说，面向对象编程更接近现实世界。

• 希望在自己在以后的学习中可以更用心一点吧......