The Last Blog

标签：return String double ArrayList Blog void Last public

• 前言

本次Blog是对6-8次的PTA进行总结，电信计费系列，包含三个部分：系列1-座机计费，系列2-手机+座机计费，系列3-短信计费。难度相对于前几次pta多边形的作业小了一些，这三次大作业主要应用了类的继承、多态、接口、抽象这几方面知识。题目会给出相应的类图，重点是自己实现相应的方法，以及搞清楚子类如何继承父类的属性以及子类必须给出完整的父类的抽象方法，在父类中抽象方法只是一个声明的作用。

 

---

 

• 第六次PTA

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元。
  每条通讯信息单独计费后累加，不是将所有时间累计后统一计费。
  格式：号码+英文空格符+总的话费+英文空格符+余额
  每个用户一行，用户之间按号码字符从小到大排序。

  错误处理：
  输入数据中出现的不符合格式要求的行一律忽略。

  建议类图：
  参见图1、2、3，可根据理解自行调整：

  

                                      图1
  图1中User是用户类，包括属性：
  userRecords （用户记录）、balance（余额）、chargeMode（计费方式）、number（号码）。
  
  ChargeMode是计费方式的抽象类：
  chargeRules是计费方式所包含的各种计费规则的集合，ChargeRule类的定义见图3。
  getMonthlyRent（）方法用于返回月租（monthlyRent）。
  
  UserRecords是用户记录类，保存用户各种通话、短信的记录，    
  各种计费规则将使用其中的部分或者全部记录。
  其属性从上到下依次是：
  市内拨打电话、省内（不含市内）拨打电话、省外拨打电话、
  市内接听电话、省内（不含市内）接听电话、省外接听电话的记录
  以及发送短信、接收短信的记录。
  

  

                                       图2
  图2中CommunicationRecord是抽象的通讯记录类：
  包含callingNumber拨打号码、answerNumber接听号码两个属性。
  CallRecord（通话记录）、MessageRecord（短信记录）是它的子类。
  
  CallRecord（通话记录类）包含属性：
  通话的起始、结束时间以及
  拨号地点的区号（callingAddressAreaCode）、接听地点的区号（answerAddressAreaCode）。
  区号用于记录在哪个地点拨打和接听的电话。座机无法移动，就是本机区号，如果是手机号，则会有差异。
  
  
  
  
  

  

  设计与分析 ：

  根据类图给出的方法与继承关系写出框架，补全方法里的内容，有一个User类, 其中UserRecords作为记账本。balance记录现有的话费。number记录电话号码。
  然后再UserRecords 里面记录 CallRecord, CallRecord作为父类引出各种通信方式的类。ChargeMode记录收费方式。ChargeMode里面又有chargeRule作为不同的收费规则。所以有上面的类图做参考，写起来还是比较轻松的。关键是各种边界条件的判断。对于本次题目来说，涉及的计算量非常小。因此本次题目的设计策略主要是围绕如何判断输入信息的格式，以及判断后是如何将信息存储进记录类，这是我们在进行此次题目的设计中要着重、优先考虑的。

  我所用的判断条件：

   

  str.matches("^u-[0-9]{11,12} 0$") || str.matches("^t-\\d{10,12}\\s\\d{10,12}\\s([1-9][0-9]*\\.[1-9][0-9]?\\.[1-9][0-9]? ([0|1]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9] ?){2}$") ) 

   

  主要代码：

  

  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 CallRecord extends CommunicationRecord {
      private Date startTime;
      private Date endTime;
      private String callingAddressAreaCode;
      private String answerAddressAreaCode;
      String callnumber;
      String answernumber;
  
      Date getStartTime() {
          return startTime;
      }
  
      void setStartTime(Date startTime2) {
          this.startTime = (Date) startTime2;
      }
  
      Date getEndTime() {
          return endTime;
      }
  
      void setEndTime(Date endTime2) {
          this.endTime = (Date) endTime2;
      }
  
      String getCallingAddressAreaCode() {
          return callingAddressAreaCode;
      }
  
      void setCallingAddressAreaCode(String callingAddressAreaCode) {
          this.callingAddressAreaCode = callingAddressAreaCode;
      }
  
      String getAnswerAddressAreaCode() {
          return answerAddressAreaCode;
      }
  
      void setAnswerAddressAreaCode(String answerAddressAreaCode) {
          this.answerAddressAreaCode = answerAddressAreaCode;
      }
      public void setCallingNumber(String string) {
          this.callnumber=string;
  
      }
      public void setAnswerNumber(String string) {
          this.answernumber=string;
      }
  
  }
  
  //继承CommunicationRecord父类
  
  class MessageRecord extends CommunicationRecord {
      private String message;
  
      String getMessage() {
          return message;
      }
  
      void setMessage(String message) {
          this.message = message;
      }
  
  }
  
  
  
  abstract class ChargeRule {
  
  
  }
  
  abstract class CallChargeRule extends ChargeRule {
      public abstract double calCost(ArrayList<CallRecord> callRecords);
  
  }
  
  
  
  
  class LandPhoneInlandRule extends CallChargeRule {
  //将CallChargeRule的抽象方法具体化
      @Override
      public double calCost(ArrayList<CallRecord> callRecords) {
          double sumCost = 0.0;
          for (CallRecord callRecord : callRecords) {
              double s = callRecord.getEndTime().getTime() - callRecord.getStartTime().getTime();
              s = s / 1000.0 / 60;//分钟
              if (s % 1 == 0) {
                  sumCost += s * 0.6;
              } else {
                  double a = s % 1;
                  s = s - a + 1;
                  sumCost += s * 0.6;
              }
  
          }
          return sumCost;
      }
  
  }
  
  class LandPhonelnCityRule extends CallChargeRule {
  
      @Override
      public double calCost(ArrayList<CallRecord> callRecords) {
          double sum = 0;
          for (CallRecord callRecord : callRecords) {
              double s = callRecord.getEndTime().getTime() - callRecord.getStartTime().getTime();
  
              s = s / 1000.0 / 60;//分钟
              if (s % 1 == 0) {
                  sum += s * 0.1;
              } else {
                  double a = s % 1;
                  s = s - a + 1;
                  sum += s * 0.1;
              }
          }
          return sum;
      }
  
  }
  
  class LandPhonelnProvinceRule extends CallChargeRule {
  
      @Override
      public double calCost(ArrayList<CallRecord> callRecords) {
          double sumCost = 0;
          for (CallRecord callRecord : callRecords) {
              double s = callRecord.getEndTime().getTime() - callRecord.getStartTime().getTime();
              s = s / 1000.0 / 60;//分钟
              if (s % 1 == 0) {
                  sumCost += s * 0.3;
              } else {
                  double a = s % 1;
                  s = s - a + 1;
                  sumCost += s * 0.3;
              }
          }
          return sumCost;
  
      }
  }
  
  class User {
      UserRecords userRecords = new UserRecords();
      double balance = 100;
      ChargeMode chargeMode;
      String number;
  
      User(ChargeMode chargeMode, String number) {
          this.chargeMode = chargeMode;
          this.number = number;
      }
  
      double calBalance() {
          return balance - (calCost() + chargeMode.getMonthlyRent());
      }
  
      double calCost() {
          return chargeMode.calCost(userRecords);
      }
  
      UserRecords getUserRecords() {
          return userRecords;
      }
  
      void setUserRecords(UserRecords userRecords) {
          this.userRecords = userRecords;
      }
  
      double getBalance() {
          return balance;
      }
  
      ChargeMode getChargeMode() {
          return chargeMode;
      }
  
      void setChargeMode(ChargeMode chargeMode) {
          this.chargeMode = chargeMode;
      }
  
      String getNumber() {
          return number;
      }
  
      void setNumber(String number) {
          this.number = number;
      }
  }
  abstract class ChargeMode {
      private ArrayList<ChargeRule> chargeRules = new ArrayList<>();
  
      public ArrayList<ChargeRule> getChargeRule() {
          return chargeRules;
      }
  
      public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
          this.chargeRules = chargeRules;
      }
  
      public abstract double calCost(UserRecords userRecords);
  
      abstract double getMonthlyRent();
  
  }
  class LandlinePhoneCharging extends ChargeMode {
      double monthlyRent = 20;
  
      public double calCost(UserRecords userRecords) {
          double sumCost = 0.0;
          LandPhoneInlandRule p1 = new LandPhoneInlandRule();
          LandPhonelnCityRule p2 = new LandPhonelnCityRule();
          LandPhonelnProvinceRule p3 = new LandPhonelnProvinceRule();
          double sum1 = sumCost + p1.calCost(userRecords.getCallingInLandRecords());
          double sum2 = sumCost + p2.calCost(userRecords.getCallingInCityRecords());
          double sum3 = sumCost + p3.calCost(userRecords.getCallingInProvinceRecords());
          return sum1 + sum2 + sum3;
  
  
      }
  
      public double getMonthlyRent() {
          return monthlyRent;
      }
  
  }
  class UserRecords {
      ArrayList<CallRecord> callinglnCityRecords = new ArrayList<>();
      ArrayList<CallRecord> callinglnProvinceRecords = new ArrayList<>();
      ArrayList<CallRecord> callinglnLandRecords = new ArrayList<>();
      ArrayList<CallRecord> answerlnCityRecords = new ArrayList<>();
      ArrayList<CallRecord> answerlnProvinceRecords = new ArrayList<>();
      ArrayList<CallRecord> answerlnLandRecords = new ArrayList<>();
      ArrayList<MessageRecord> sendMessageRecords = new ArrayList<>();
      ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<>();
  
      public void addCallingInCityRecords(CallRecord callRecord) {
          callinglnCityRecords.add(callRecord);
      }
  
      public void addCallingInProvinceRecords(CallRecord callRecord) {
          callinglnProvinceRecords.add(callRecord);
      }
  
      public void addCallingInLandRecords(CallRecord callRecord) {
          callinglnLandRecords.add(callRecord);
      }
  
      public void addAnswerInCityRecords(CallRecord answerRecord) {
          answerlnCityRecords.add(answerRecord);
      }
  
      public void addAnswerInProvinceRecords(CallRecord answerRecord) {
          answerlnProvinceRecords.add(answerRecord);
      }
  
      public void addAnswerInLandRecords(CallRecord answerRecord) {
          answerlnLandRecords.add(answerRecord);
      }
  
      public void addSendMessageRecords(MessageRecord sendMessageRecord) {
          sendMessageRecords.add(sendMessageRecord);
      }
  
      public void addReceiveMessageRecords(MessageRecord receiveMessageRecord) {
          receiveMessageRecords.add(receiveMessageRecord);
      }
  
      public ArrayList<MessageRecord> getSendMessageRecords() {
          return this.sendMessageRecords;
      }
  
      public ArrayList<MessageRecord> getReceiveMessageRecords() {
          return this.receiveMessageRecords;
      }
  
      public ArrayList<CallRecord> getCallingInCityRecords() {
          return this.callinglnCityRecords;
      }
  
      public ArrayList<CallRecord> getCallingInProvinceRecords() {
          return this.callinglnProvinceRecords;
      }
  
      public ArrayList<CallRecord> getCallingInLandRecords() {
          return this.callinglnLandRecords;
      }
  
      public ArrayList<CallRecord> getAnswerInCityRecords() {
          return this.answerlnCityRecords;
      }
  
      public ArrayList<CallRecord> getAnswerInProvinceRecords() {
          return this.callinglnProvinceRecords;
      }
  
      public ArrayList<CallRecord> getAnswerInLandRecords() {
          return this.callinglnLandRecords;
      }
  
  
  }

  View Code

  类图实现：

  

  复杂度检测：

   

  踩坑心得以及改进建议：

  一个好的抽象应该尽可能的使得程序归一化。所谓归一化就是按我的理解就是尽可能得定义出一个统一的接口在屏蔽底层得细节得同时, 使得不同对象都可以完成一个统一的逻辑, 也就是多态。面向对象把每一个变化抽象成一个接口, 就可以成功得做到归一化, 也就是一个好的抽象。这也提醒我使用面向对象得思想得时候一定要做出一个好的抽象，不好得抽象只会使得程序越来越乱。归根到底，也就是上课讲得那几个原则：单一职责、开闭原则等。

7-2 多态测试

定义容器Container接口。模拟实现一个容器类层次结构，并进行接口的实现、抽象方法重写和多态机制测试。各容器类实现求表面积、体积的方法。

1. 定义接口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[]);
   其中两个静态方法分别计算返回容器数组中所有对象的面积之和、周长之和；
2. 定义Cube类、Cylinder类均实现自Container接口。
   Cube类(属性：边长double类型)、Cylinder类(属性：底圆半径、高，double类型)。

踩坑心得以及改进建议：

本次较为容易用给出的接口，在继承的子类中完善抽象的方法，没有什么坑很顺利完成。

 

---

  

• 第七次PTA

7-1 电信计费系列2-手机+座机计费  

实现南昌市电信分公司的计费程序，假设该公司针对手机和座机用户分别采取了两种计费方案，分别如下：
1、针对市内座机用户采用的计费方式（与电信计费系列1内容相同）：
月租20元，接电话免费，市内拨打电话0.1元/分钟，省内长途0.3元/分钟，国内长途拨打0.6元/分钟。不足一分钟按一分钟计。
假设本市的区号：0791，江西省内各地市区号包括：0790~0799以及0701。
2、针对手机用户采用实时计费方式：
月租15元，市内省内接电话均免费，市内拨打市内电话0.1元/分钟，市内拨打省内电话0.2元/分钟，市内拨打省外电话0.3元/分钟，省内漫游打电话0.3元/分钟，省外漫游接听0.3元/分钟，省外漫游拨打0.6元/分钟；
注：被叫电话属于市内、省内还是国内由被叫电话的接听地点区号决定，比如以下案例中，南昌市手机用户13307912264在区号为020的广州接听了电话，主叫号码应被计算为拨打了一个省外长途，同时，手机用户13307912264也要被计算省外接听漫游费：
u-13307912264 1
t-079186330022 13307912264 020 2022.1.3 10:00:25 2022.1.3 10:05:11

输入：
输入信息包括两种类型
1、逐行输入南昌市用户开户的信息，每行一个用户，含手机和座机用户
格式：u-号码 计费类型 （计费类型包括：0-座机 1-手机实时计费 2-手机A套餐）
例如：u-079186300001 0
座机号码由区号和电话号码拼接而成，电话号码包含7-8位数字，区号最高位是0。
手机号码由11位数字构成，最高位是1。
本题在电信计费系列1基础上增加类型1-手机实时计费。
手机设置0或者座机设置成1，此种错误可不做判断。
2、逐行输入本月某些用户的通讯信息，通讯信息格式：
座机呼叫座机：t-主叫号码 接听号码 起始时间 结束时间
t-079186330022 058686330022 2022.1.3 10:00:25 2022.1.3 10:05:11
以上四项内容之间以一个英文空格分隔，
时间必须符合"yyyy.MM.dd HH:mm:ss"格式。提示：使用SimpleDateFormat类。
输入格式增加手机接打电话以及收发短信的格式，手机接打电话的信息除了号码之外需要额外记录拨打/接听的地点的区号，比如：
座机打手机：
t-主叫号码 接听号码 接听地点区号 起始时间 结束时间
t-079186330022 13305862264 020 2022.1.3 10:00:25 2022.1.3 10:05:11
手机互打：
t-主叫号码 拨号地点 接听号码 接听地点区号 起始时间 结束时间
t-18907910010 0791 13305862264 0371 2022.1.3 10:00:25 2022.1.3 10:05:11

注意：以上两类信息，先输入所有开户信息，再输入所有通讯信息，最后一行以“end”结束。

输出：
根据输入的详细通讯信息，计算所有已开户的用户的当月费用（精确到小数点后2位，单位元）。假设每个用户初始余额是100元。
每条通讯、短信信息均单独计费后累加，不是将所有信息累计后统一计费。
格式：号码+英文空格符+总的话费+英文空格符+余额
每个用户一行，用户之间按号码字符从小到大排序。
错误处理：
输入数据中出现的不符合格式要求的行一律忽略。

设计与分析：

本题类图和第六次大作业差不多，但是不同的是是实现座机与手机的两个计费，难度有提升，实际就是一个拓展增加，代码并不需要大刀阔斧的改。

主要代码：

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 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 MobilePhoneCharging extends ChargeMode {

    private double monthlyRent = 15;//月租15

    public MobilePhoneCharging() {
        super();
        chargeRules.add(new MobilePhoneInCityRule());
        chargeRules.add(new MobilePhoneInProvinceRule());
        chargeRules.add(new MobilePhoneInlandRule());
    }

    @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 Input {

    public int check(String input) {
        if (input.matches("u-0791[0-9]{7,8}\\s0") || input.matches("[u]-1[0-9]{10}\\s[1]")) {
            return 1;
        } else if (input.matches("(([t]-0791[0-9]{7,8}\\s" + "0[0-9]{9,11}\\s)|"
                + "([t]-0791[0-9]{7,8}\\s" + "1[0-9]{10}\\s" + "0[0-9]{2,3}\\s)|"
                + "([t]-1[0-9]{10}\\s" + "0[0-9]{2,3}\\s" + "0[0-9]{9,11}\\s)|"
                + "([t]-1[0-9]{10}\\s" + "0[0-9]{2,3}\\s" + "1[0-9]{10}\\s" + "0[0-9]{2,3}\\s))"
                + "((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.(((0?[13578]|1[02])\\.(0?"
                + "[1-9]|[12][0-9]|3[01]))|(([469]|11)\\.([1-9]|[12][0-9]|30))|(2\\.([1-9]|[1][0-9]|2[0-8]))))|((("
                + "[0-9]{2})([48]|[2468][048]|[13579][26])|(([48]|[2468][048]|[3579][26])00))\\.2\\.29))"
                + "\\s([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])\\s"
                + "((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.((([13578]|1[02])\\.("
                + "[1-9]|[12][0-9]|3[01]))|(([469]|11)\\.([1-9]|[12][0-9]|30))|(2\\.([1-9]|[1][0-9]|2[0-8]))))|((("
                + "[0-9]{2})([48]|[2468][048]|[13579][26])|(([48]|[2468][048]|[3579][26])00))\\.2\\.29))"
                + "\\s([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])")) {
            return 2;
        }
        return 0;
    }

    @SuppressWarnings("unused")
    private boolean validatet(String str) {
        return str.matches("^([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$");
    }

    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());
        } else if (mode == 1) {
            usernew.setChargeMode(new MobilePhoneCharging());
        }
        users.add(usernew);
    }

    public void writeRecord(ArrayList<User> users, String input) {
        String[] inputs = input.split(" ");

        User callu = null, answeru = null;
        CallRecord callrecord = new CallRecord(inputs);

        if (input.charAt(0) == 't') {
            String out = inputs[0];
            String in = "";
            if (inputs.length == 6) {
                in = inputs[1];
            } else if (inputs.length == 7) {
                in = inputs[1];
            } else if (inputs.length == 8) {
                in = inputs[2];
            }

            for (User i : users) {
                if (i.getNumber().equals(out)) {
                    callu = i;
                }
                if (i.getNumber().equals(in)) {
                    answeru = i;
                }
                if (callu != null && answeru != null) {
                    break;
                }
            }

            if (callu != null) {
                if (callrecord.getCallType().matches("^1[1-3]$")) {
                    callu.getUserRecords().addCallingInCityRecords(callrecord);
                } else if (callrecord.getCallType().matches("^2[1-3]$")) {
                    callu.getUserRecords().addCallingInProvinceRecords(callrecord);
                } else {
                    callu.getUserRecords().addCallingInLandRecords(callrecord);
                }
            }

            if (answeru != null) {
                if (callrecord.getCallType().matches("^[1-3]1$")) {
                    answeru.getUserRecords().addAnswerInCityRecords(callrecord);
                } else if (callrecord.getCallType().matches("^[1-3]2$")) {
                    answeru.getUserRecords().aaddAnswerInProvinceRecords(callrecord);
                } else {
                    answeru.getUserRecords().addAnswerInLandRecords(callrecord);
                }
            }
        }

    }

}

abstract class CommunicationRecord {
    String callingNumber;
    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 MessageRecord extends CommunicationRecord {

    private String message;

    public String getMessage() {
        return message;
    }

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

class CallRecord extends CommunicationRecord {
    private Date startTime;
    private Date endTime;
    private String callingAddressAreaCode;
    private String answerAddressAreaCode;

    public String getCallType() {
        String type = "";
        if (callingAddressAreaCode.equals("0791")) {
            type = type.concat("1");
        } else if (callingAddressAreaCode.matches("^079[023456789]$") || callingAddressAreaCode.equals("0701")) {
            type = type.concat("2");
        } else {
            type = type.concat("3");
        }

        if (answerAddressAreaCode.equals("0791")) {
            type = type.concat("1");
        } else if (answerAddressAreaCode.matches("^079[023456789]$") || answerAddressAreaCode.equals("0701")) {
            type = type.concat("2");
        } else {
            type = type.concat("3");
        }

        return type;
    }

    public CallRecord(String[] inputs) {
        super();

        char type = inputs[0].charAt(0);
        inputs[0] = inputs[0].substring(2);

        String sd = null, st = null, ed = null, et = null;

        if (type == 't') {
            if (inputs.length == 6) {
                sd = inputs[2];
                st = inputs[3];
                ed = inputs[4];
                et = inputs[5];
                callingAddressAreaCode = inputs[0].substring(0, 4);
                answerAddressAreaCode = inputs[1].substring(0, 4);
            } else if (inputs.length == 7) {
                sd = inputs[3];
                st = inputs[4];
                ed = inputs[5];
                et = inputs[6];
                if (inputs[0].charAt(0) != '0') {
                    if (inputs[2].length() == 10) {
                        answerAddressAreaCode = inputs[2].substring(0, 3);
                    } else {
                        answerAddressAreaCode = inputs[2].substring(0, 4);
                    }
                    callingAddressAreaCode = inputs[1];
                } else {
                    if (inputs[0].length() == 10) {
                        callingAddressAreaCode = inputs[0].substring(0, 3);
                    } else {
                        callingAddressAreaCode = inputs[0].substring(0, 4);
                    }
                    answerAddressAreaCode = inputs[2];
                }
            } else if (inputs.length == 8) {
                sd = inputs[4];
                st = inputs[5];
                ed = inputs[6];
                et = inputs[7];
                callingAddressAreaCode = inputs[1];
                answerAddressAreaCode = inputs[3];
            }
        }
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss", Locale.getDefault());
        try {
            startTime = simpleDateFormat.parse(sd + " " + st);
            endTime = simpleDateFormat.parse(ed + " " + et);
        } catch (ParseException ignored) {
        }

    }

    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 ChargeRule {

    abstract public double calCost(UserRecords userRecords);

}

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;
            }
            if (call.getCallType().equals("11")) {
                sumCost += distanceM * 0.1;
            } else if (call.getCallType().equals("12")) {
                sumCost += distanceM * 0.3;
            } else if (call.getCallType().equals("13")) {
                sumCost += distanceM * 0.6;
            }
        }
        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 MobilePhoneInCityRule 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;
            }
            if (call.getCallType().equals("11")) {
                sumCost += distanceM * 0.1;
            } else if (call.getCallType().equals("12")) {
                sumCost += distanceM * 0.2;
            } else if (call.getCallType().equals("13")) {
                sumCost += distanceM * 0.3;
            }

        }
        return sumCost;
    }

}

class MobilePhoneInlandRule 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;
        }
        for (CallRecord call : userRecords.getAnswerInLandRecords()) {
            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 MobilePhoneInProvinceRule 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;
            }
            if (call.getCallType().equals("21")) {
                sumCost += distanceM * 0.3;
            } else if (call.getCallType().equals("22")) {
                sumCost += distanceM * 0.3;
            } else if (call.getCallType().equals("23")) {
                sumCost += distanceM * 0.3;
            }
        }
        return sumCost;
    }

}

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 Output {

    
    public void output(double out) {
        BigDecimal numb = new BigDecimal(out);
        out = numb.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        System.out.print(out);
    }
}

View Code

类图实现：

复杂度检测：

 

踩坑心得以及改进建议：

这次的正则写的并不简洁，我是一个一个情况一一写了出来，导致代码较为复杂，还多加了一个输出类ouput，代码的复用性就降低了，有时候没有新建类导致有的信息没传，导致我会一直报错，面向对象的好处，思路更清晰，修改起来更简单，代码耦合度小，代码复杂度低的优点。当我掌握这种方法后可以使代码复用度更高，可以使后面需要加什么代码直接可以加上去，不用再去多写其他新的代码。

 

7-2 sdut-Collection-sort--C~K的班级（II）

经过不懈的努力，C~K终于当上了班主任。

现在他要统计班里学生的名单，但是C~K在教务系统中导出班级名单时出了问题，发现会有同学的信息重复，现在他想把重复的同学信息删掉，只保留一个，
但是工作量太大了，所以找到了会编程的你，你能帮他解决这个问题吗？

输入格式:

第一行输入一个N，代表C~K导出的名单共有N行（N<100000）.

接下来的N行，每一行包括一个同学的信息，学号 姓名 年龄 性别。

输出格式:

第一行输出一个n，代表删除重复名字后C~K的班级共有几人。

接下来的n行，输出每一个同学的信息，输出按照学号从小到大的顺序。

设计与分析：

这里需要用到HashMap<K,V>，HashMap是一个散列表，它存储的内容是键值对(key-value)映射。HashMap实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null。HashMap不会记录插入的顺序，即它是无序的。

import java.util.*;
public class Main {
    public static void main(String[] args) {
        ArrayList<Student> users =new ArrayList<>();
        int Num;
        int pd=0,i,j,age;
        Scanner input=new Scanner(System.in);
        Num=input.nextInt();
        String sno,name,sex;
        int nums=0;
        for( i=0;i<Num;i++){
            sno=input.next();
            name=input.next();
            age=input.nextInt();
            sex=input.next();
            if(i==0){
                users.add(new Student(sno,name,age,sex));
                nums++;
            }else {
                for( j=0;j<nums;j++){
                    if(sno.equals(users.get(j).num))
                        pd++;
                }
                if(pd==0){
                    users.add(new Student(sno,name,age,sex));
                    nums++;
                }
                pd=0;
            }
        }
        Student student=new Student("0001","nh",01,"F");
        int min=0;
        for(i=0;i<nums;i++){
            for(j=i;j<nums;j++){
                if(Integer.parseInt(users.get(i).num)>=Integer.parseInt(users.get(j).num)){
                    if(i!=j) {
                        student = users.get(i);
                        users.set(i, users.get(j));
                        users.set(j, student);
                    }
                }
            }

        }
        System.out.println(nums);
        for(int p=0;p<nums;p++){
            System.out.println(users.get(p).num+" "+users.get(p).name+" "+users.get(p).age+" "+users.get(p).sex);
        }
    }
}

class Student {

    String name;

    String num;

    int age;

    String sex;

    public Student(String num, String name, int old, String sex) {

        this.num = num;

        this.name = name;

        this.age = old;

        this.sex = sex;

    }

}

View Code

踩坑心得以及改进建议：

弄清楚题目重点知识点之后很快完成，难度并不大。

7-3 阅读程序，按照题目需求修改程序

功能需求：
      使用集合存储3个员工的信息（有序);
      通过迭代器依次找出所有的员工。 

提示：学生复制以下代码到编程区，并按需求进行调试修改。

踩坑心得以及改进建议：
本题难度较小，完善矢代器便利集合即可。

---

• 第八次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。

 

本题只考虑短信计费，不考虑通信费用以及月租费。

设计与分析：

根据前几次作业的类图，写出短信计费，第三次的电信计费相较于前面两次的题目容易了不少，只需要实现短信计费的功能，相较于前面两次的还是比较简单的的题目了。

正则表达式：

String input1 = "[u][-]1[3-9]\\d{9}[ ][3]";
            String input2 = "m-1[3-9]\\d{9} 1[3-9]\\d{9} [a-z|0-9| |,|.]++";

主要代码：

public static void main(String[] args) {
        SimpleDateFormat DF = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
        Scanner in = new Scanner(System.in);
        TreeMap<String, User> users = new TreeMap<>();
        String str = in.nextLine();

       
        while (!str.equals("end")) {

            String input1 = "[u][-]1[3-9]\\d{9}[ ][3]";
            String input2 = "m-1[3-9]\\d{9} 1[3-9]\\d{9} [a-z|0-9| |,|.]++";

            if (str.matches(input1)) {
                String[] s1 = str.split("-| ");
                users.put(s1[1], new User(new UserRecords(), 100, 0));
            }
            if (str.matches(input2)) {
                for (Map.Entry<String, User> entry : users.entrySet()) {
                    String[] s2 = str.split("-| ", 4);
                    if (s2[1].equals(entry.getKey())) {
                        String s3 = s2[3];
                        MessageRecord messageRecord = new MessageRecord(s3.length());
                        entry.getValue().userRecords.sendMessageRecords.add(messageRecord);
                    }
                }
            }

            str = in.nextLine();
        }
        for (Map.Entry<String, User> entry : users.entrySet()) {
            System.out.print(entry.getKey() + " ");
            System.out.printf("%.1f %.1f\n", 100 - new SendMessageRule().calCost(entry.getValue().userRecords.sendMessageRecords), new SendMessageRule().calCost(entry.getValue().userRecords.sendMessageRecords));

        }
    }

}

class SendMessageRule extends MessageChargeRule {
    public double calCost(ArrayList<MessageRecord> callRecords) {
        double sum = 0;
        int num = 0;
        for (int i = 0; i < callRecords.size(); i++) {
            if (callRecords.get(i).getLength() % 10 == 0) {
                num += callRecords.get(i).getLength() / 10;
            } else {
                num += callRecords.get(i).getLength() / 10 + 1;

            }
        }
        if (num <= 3) {
            return 100 - num * 0.1;
        } else if (num <= 5) {
            return 100 - 3 * 0.1 - (num - 3) * 0.2;
        } else {
            return 100 - 3 * 0.1 - 2 * 0.2 - 0.3 * (num - 5);
        }
    }
}

View Code

类图实现：

复杂度检测：

踩坑心得以及改进建议：

相较于前几次大作业的经验，这次短信计费也没有遇上很大困难。

7-2 编写一个类Shop（商店）、内部类InnerCoupons（内部购物券）

编写一个类Shop（商店），该类中有一个成员内部类InnerCoupons（内部购物券），可以用于购买该商店的牛奶（假设每箱牛奶售价为50元）。要求如下：
（1）Shop类中有私有属性milkCount（牛奶的箱数，int类型）、公有的成员方法setMilkCount( )和getMilkCount( )分别用于设置和获取牛奶的箱数。
（2）成员内部类InnerCoupons，有公有属性value（面值，int类型），一个带参数的构造方法可以设定购物券的面值value，一个公有的成员方法buy( )要求输出使用了面值为多少的购物券进行支付，同时使商店牛奶的箱数减少value/50。
（3）Shop类中还有成员变量coupons50（面值为50元的内部购物券，类型为InnerCoupons）、coupons100（面值为100元的内部购物券，类型为InnerCoupons）。
（4）在Shop类的构造方法中，调用内部类InnerCoupons的带参数的构造方法分别创建上面的购物券coupons50、coupons100。

在测试类Main中，创建一个Shop类的对象myshop，从键盘输入一个整数（大于或等于3），将其设置为牛奶的箱数。假定有顾客分别使用了该商店面值为50的购物券、面值为100的购物券各消费一次，分别输出消费后商店剩下的牛奶箱数。

踩坑心得以及改进建议：
在课堂上老师让我们写了咖啡馆设计的作业，其实和这题很相似，内部类，以及完善有参和无参构造，创建父类还是子类对象，搞清楚调用方法的对象就很容易完成，是一道典型的面向对象题目，很好理解。
主要代码：

import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Shop myshop = new Shop(in.nextInt());
        myshop.coupons50.buy();
        myshop.coupons100.buy();
    }

}

class Shop {
    private int milkCount;// 牛奶箱数
    InnerCoupons coupons50 = new InnerCoupons(50);//创建
    InnerCoupons coupons100 = new InnerCoupons(100);

    public Shop(int milkCount) {
        this.milkCount=milkCount;
    }
    public void setMilkCount(int milkCount) {
        this.milkCount = milkCount;
    }

    public int getMilkCount() {
        return milkCount;
    }

    class InnerCoupons {
        int value;//面值

        //带参构造数方法
        public InnerCoupons(int value)
        {
            this.value=value;
        }

        public void buy() {
            System.out.println("使用了面值为" + this.value + "的购物券进行支付");
            milkCount = milkCount - (value / 50);
            System.out.println("牛奶还剩"+milkCount+"箱");
        }
    }
}

View Code

7-3 动物发声模拟器（多态）

设计一个动物发生模拟器，用于模拟不同动物的叫声。比如狮吼、虎啸、狗旺旺、猫喵喵……。
定义抽象类Animal，包含两个抽象方法：获取动物类别getAnimalClass()、动物叫shout()；
然后基于抽象类Animal定义狗类Dog、猫类Cat和山羊Goat，用getAnimalClass()方法返回不同的动物类别（比如猫，狗，山羊），用shout()方法分别输出不同的叫声（比如喵喵、汪汪、咩咩）。
最后编写AnimalShoutTest类测试，输出：
猫的叫声：喵喵
狗的叫声：汪汪
山羊的叫声：咩咩

其中，在AnimalShoutTestMain类中，用speak(Animal animal){}方法输出动物animal的叫声，在main()方法中调用speak()方法，分别输出猫、狗和山羊对象的叫声。

请在下面的【】处添加代码

踩坑心得以及改进建议：

本题也并不难，给出了类与方法只需加以完善，也是典型子类继承父类的属性方法问题，以及子类一定要写明抽象方法。

代码如下：

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Dog dog = new Dog();
        Goat goat = new Goat();
        speak(cat);
        speak(dog);
        speak(goat);
    }

    //定义静态方法speak()
    private static void speak(Animal animal) {
        System.out.println(animal.getAnimalClass() + "的叫声：" + animal.shout());
    }

}

//定义抽象类Animal
abstract class Animal {
    abstract public String getAnimalClass();

    abstract public String shout();
}

//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal {
    @Override
    public String getAnimalClass() {
        return "猫";
    }

    @Override
    public String shout() {
        return "喵喵";
    }
}

//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal {
    @Override
    public String getAnimalClass() {
        return "狗";
    }

    @Override
    public String shout() {
        return "汪汪";
    }
}

//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal {
    @Override
    public String getAnimalClass() {
        return "山羊";
    }

    @Override
    public String shout() {
        return "咩咩";
    }
}

View Code

 

---

  

总结：

Java的PTA作业也告一段落了。通过这次的题目更加掌握了类的四大块———继承、多态、抽象、接口，但是对于复杂的情况出现是还是不能够清晰的分析出题目中的需求。但是对大题目的架构不是很清晰明白，还需要去下功夫，好好学习对于本阶段，在内容上学习了是进一步对现实问题的分析和解决，如何提高代码的复用性是我要提升的！

标签：return,String,double,ArrayList,Blog,void,Last,public
From： https://www.cnblogs.com/dtyyyy-1016/p/16971384.html