标签：return String void private public ArrayList Blog3

前言：

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

• 继承是面向对象语法的三大特征之一。继承可以降低代码编写的冗余度，提高编程的效率。通过继承，子类获得了父类的成员变量和方法。一个子类如何继承父类的字段和方法，如何修改从父类继承过来的子类的方法呢。今天我们开始学习有关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中的集合类能够使程序方便的存储和操纵数目不固定的一组数据。

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

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

 

标签：return,String,void,private,public,ArrayList,Blog3
来源： https://www.cnblogs.com/0071286w/p/16389353.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。