10-16周综合性总结（21201205-江向斌）

1.前言：

　　本阶段pta中主要关于java语言的基本程序设计，知识点涉及从最基础的命名变量到对象和类，其中包括了选择结构，循环结构，数学函数，字符和字符串以及方法的定义与调用，还有数组的使用等内容。更重要的是详细考察了java的封装，继承，多态的三大特性，同时深入学习了java的抽象函数，抽象类，还学习了java的集合框架（包括Arraylist类，各种集合类以及接口的使用还有迭代器Iterator的使用等等复杂内容），并且我们也学习了文件流，如何将数据写入文件，从文件中读出等等，还有图形界面javafx，GUI等等内容以及部分有关异常知识，总的来说着6周非常充实，学习内容量大且深入！题量适中，均能在规定时间内做完，但不一定能做全对。难度各不相同，第一题十分困难属于电话计费的题目，考察了多类的使用以及集合框架等等如容还有正则表达式的运用，思路也难，一时半会难以解决并且很难得到高分，属于非常锻炼我们java能力的题目，一开始敲击代码就会发现细节很难把握到位，尤其是有关于输入测试的部分尤为突出，明显很难考虑到每一个方面以至于无法拿到满分，总会有测试点过不了。第二题和第三题反而为一些简单的题目，都是多类的运用或者是迭代器Iterator的使用或者是集合框架的考察譬如implement move()接口的使用等等。

　　超星中的实验主要是针对了多个类的运用，强调有关于数据的封装还有java语言的其他两大特性，继承以及多态。通过农夫过河游戏的巧妙设计，我们能更好的理解这些。题量不算大，并且给我们的时间也很多，难度适中，涉及的知识点虽然都是刚学的或还没学的但是题目难度不难也不深入。并且超星系统因为其独特的功能，预防了我们复制粘贴的行为的发生，并且超星系统上直接写代码，也比在eclipse上写代码更加锻炼我们的语法能力和代码的规范意识。尤其是实验五，实验五真正的让我们完成了一个游戏的制作，使用了javafx工具实现了图形界面化，让农夫过河变得让用户可直接操作性，性能更好。实验四也让我们更好的理解了抽象类的使用以及继承等内容，将简单的农夫过河游戏代码框架化，可读性增强，更加专业化对我们未来真正着手写项目代码的影响深远，作用很大。

　　 总的来说，Java又是我们本学期第一次接触的语言，对Java语言的运用还有些许生疏，对语法的理解和java整体的结构把握不够清晰以及有关与行间距的习惯等还有很大进步空间，需要加强训练以求熟练。

2.设计分析：

　　　　　　PTA大作业6

　　　　　　7-1 电信计费系列1-座机计费

import java.util.ArrayList;
import java.util.Date;
import java.util.Scanner;
import java.text.ParseException;
import java.text.SimpleDateFormat;

abstract class CallChargeRule extends ChargeRule{//计费规则父类
    public double calCost(ArrayList<CallRecord> callRecords){
        return 1;
    }
}

class CallRecord extends CommunicationRecord {//具体的某一通话记录类
    private Date StartTime;
    private Date endTime;
    private String callingAddressAreaCode;
    private String answerAddressAreaCode;

    public Date getStartTime() {
        return StartTime;
    }

    public void setStartTime(Date startTime) {
        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 ChargeMode {//计费规则的合计
    private ArrayList<ChargeRule> chargeRules = new ArrayList<ChargeRule>();

    public ArrayList<ChargeRule> getChargeRules() {
        return chargeRules;
    }

    public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
        this.chargeRules = chargeRules;
    }

    public double calCost(UserRecords userRecords){
        return 1;
    }

    public double getMonthlyRen(){
        return 1;
    }
}

abstract class ChargeRule {
    public double calCost(ArrayList<CallRecord> callRecords){
        return 1;
    }
}

abstract class CommunicationRecord {
    private String callingNumber;
    private String answerNumber;

    public String getCallingNumber() {
        return callingNumber;
    }

    public void setCallingNumber(String callingNumber) {
        this.callingNumber = callingNumber;
    }

    public String getAnswerNumber() {
        return answerNumber;
    }

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

class LandlinePhoneCharging extends ChargeMode {
    private double monthlyRent = 20;

    @Override
    public double calCost(UserRecords userRecords){//计算消费
        double cost1,cost2,cost3;
        cost1 = getChargeRules().get(0).calCost(userRecords.getAnswerInCityRecords());
        cost2 = getChargeRules().get(1).calCost(userRecords.getAnswerInProvinceRecords());
        cost3 = getChargeRules().get(2).calCost(userRecords.getAnswerInLandRecords());
        return cost1 + cost2 + cost3 + monthlyRent;
    }

    @Override
    public double getMonthlyRen(){
        return monthlyRent;
    }
}

class LandPhoneInCityRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords){
        long  miao = 0;
        long fen = 0;
        long sum= 0;
        for(int i=0;i<callRecords.size();i++){
            callRecords.get(i);
            miao=(callRecords.get(i).getEndTime().getTime()-callRecords.get(i).getStartTime().getTime())/1000;
            fen = miao / 60;
            if(miao % 60!=0){
                fen = fen + 1;
            }
            sum=sum+fen;
        }
        return sum*0.1;
    }
}

class LandPhoneInlandRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords){
        long  miao = 0;
        long fen = 0;
        long sum= 0;
        for(int i=0;i<callRecords.size();i++){
            callRecords.get(i);
            miao=(callRecords.get(i).getEndTime().getTime()-callRecords.get(i).getStartTime().getTime())/1000;
            fen = miao / 60;
            if(miao % 60!=0){
                fen = fen + 1;
            }
            sum=sum+fen;
        }
        return sum*0.6;
    }
}

class LandPhoneInProvinceRule extends CallChargeRule{
    @Override
    public double calCost(ArrayList<CallRecord> callRecords){
        long  miao = 0;
        long fen = 0;
        long sum= 0;
        for(int i=0;i<callRecords.size();i++){
            callRecords.get(i);
            miao=(callRecords.get(i).getEndTime().getTime()-callRecords.get(i).getStartTime().getTime())/1000;
            fen = miao / 60;
            if(miao % 60!=0){
                fen = fen + 1;
            }
            sum=sum+fen;
        }
        return sum*0.3;
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList<User> Users = new ArrayList<>();
        int numC = 0;
        String callNumber;
        String answerNumber;
        String startTime;
        String endTime;
        String line;
        CallRecord callRecord;
        LandPhoneInCityRule a0 =new LandPhoneInCityRule();
        LandPhoneInProvinceRule a1 = new LandPhoneInProvinceRule();
        LandPhoneInlandRule a2 =new LandPhoneInlandRule();
        ArrayList<ChargeRule> c = new ArrayList<>();
        c.add(a0);
        c.add(a1);
        c.add(a2);
        Scanner a = new Scanner(System.in);
        String kh = ("[u]-0791[0-9]{7,8}\\s[0]");
        String jl = "[t]-0791[0-9]{7,8}\\s0[0-9]{9,11}\\s((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.(((0?[13578]|1[02])\\.(0?[1-9]|[12][0-9]|3[01]))|(([469]|11)\\.([1-9]|[12][0-9]|30))|(2\\.([1-9]|[1][0-9]|2[0-8]))))|((([0-9]{2})([48]|[2468][048]|[13579][26])|(([48]|[2468][048]|[3579][26])00))\\.2\\.29))\\s([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])\\s((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.((([13578]|1[02])\\.([1-9]|[12][0-9]|3[01]))|(([469]|11)\\.([1-9]|[12][0-9]|30))|(2\\.([1-9]|[1][0-9]|2[0-8]))))|((([0-9]{2})([48]|[2468][048]|[13579][26])|(([48]|[2468][048]|[3579][26])00))\\.2\\.29))\\s([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])";
        line = a.nextLine();
        while (!line.equals("end")){
            if (line.matches(kh)) {
                String[] kh1 = line.split("-");
                kh1 = kh1[1].split(" ");
                    for(User x:Users){
                        if(x.getNumber().equals(kh1[0])){
                            numC = 1;
                            break;
                        }
                    }
                    if(numC == 0){
                        User user = new User();
                        user.setNumber((kh1[0]));
                        Users.add(user);
                    }
            }else if(line.matches(jl)){
                String[] jl1 = line.split("-");
                jl1 = jl1[1].split(" ");
                callNumber = jl1[0];
                answerNumber = jl1[1];
                callRecord = new CallRecord();
                callRecord.setCallingNumber(callNumber);
                callRecord.setCallingAddressAreaCode(callNumber.substring(0,4));
                callRecord.setAnswerNumber(answerNumber);
                callRecord.setAnswerAddressAreaCode(answerNumber.substring(0,4));
                try{
                    SimpleDateFormat aq2 = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
                    startTime = jl1[2]+" "+jl1[3];
                    endTime = jl1[4]+" "+jl1[5];
                    Date stareTimeDate = aq2.parse(startTime);
                    Date endTimeDate = aq2.parse(endTime);
                    callRecord.setStartTime(stareTimeDate);
                    callRecord.setEndTime(endTimeDate);
                    callRecord.setCallingNumber(callNumber);
                    callRecord.setCallingAddressAreaCode(callNumber.substring(0,4));
                    callRecord.setAnswerNumber(answerNumber);
                    callRecord.setAnswerAddressAreaCode(answerNumber.substring(0,4));
                    for(User user: Users){//存通话记录
                        if(user.getNumber().equals(callNumber)&&endTimeDate.getTime()>stareTimeDate.getTime()){
                            if(user.getNumber().substring(0,4).equals(callRecord.getAnswerAddressAreaCode())){
                                user.getUserRecords().addAnswerInCityRecords(callRecord);
                            }else if(callRecord.getAnswerNumber().startsWith("079")|| callRecord.getAnswerNumber().startsWith("0701")){
                                user.getUserRecords().addAnswerInProvinceRecords(callRecord);
                            }else{
                                user.getUserRecords().addAnswerInLandRecords(callRecord);
                            }
                        }
                    }
                } catch (ParseException e) {
                    throw new RuntimeException(e);
                }
            }
                line = a.nextLine();
        }
        for(User user:Users){
            user.getChargeMode().setChargeRules(c);
        }
        for(int i=0;i<Users.size()-1;i++){
            for(int j=i+1;j<Users.size();j++){
                if(Double.parseDouble(Users.get(i).getNumber())>Double.parseDouble(Users.get(j).getNumber())){
                    User con;
                    con = Users.get(i);
                    Users.set(i,Users.get(j));
                    Users.set(j,con);
                }
            }
        }
        for(User user: Users){
            user.setBalance(user.getBalance()-user.getChargeMode().calCost(user.getUserRecords()));
            System.out.printf("%s ",user.getNumber());
            System.out.printf("%.1f ",80-user.getBalance());
            System.out.printf("%.1f\n",user.getBalance());
        }
    }
}

class MessageRecord extends CommunicationRecord{
    private String message;

    public String getMessage() {
        return message;
    }

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

class User {
    private UserRecords userRecords = new UserRecords();
    private double balance = 100;
    private ChargeMode chargeMode = new LandlinePhoneCharging();
    private String number ;

    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;
    }

    public double calBalance(){

        return 1;
    }

    public double calCost(){

        return 1;
    }
}

class UserRecords {
    private ArrayList<CallRecord> callingInCityRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> callingInLandRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> answerInCityRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();
    private ArrayList<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();
    private ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<MessageRecord>();

    public ArrayList<MessageRecord> getSendMessageRecords() {
        return sendMessageRecords;
    }

    public ArrayList<MessageRecord> getReceiveMessageRecords() {
        return receiveMessageRecords;
    }

    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 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(CallRecord callRecord) {

    }

    public void addReceiveMessageRecords(CallRecord callRecord) {

    }

    public void addSendMessageRecords(MessageRecord messageRecord) {
        sendMessageRecords.add(messageRecord);
    }

    public void addReceiveMessageRecords(MessageRecord messageRecord) {
        receiveMessageRecords.add(messageRecord);
    }
}

 

有图有真相！！！！！！！！！！！

本题难点主要体现在对正则表达式的陌生，以及多类的结合运用，包括了迭代器，集合框架等等，题目难度高但是十分锻炼java水平

    代码分析：1.输入判断：

• 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”结束。

 

  　　　　　　2.数据处理：

• 过于复杂三言两语难以概括，你写了你也懂！

　　　　　　3.输出处理：

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

• 7-2 多态测试

   

• import java.util.Scanner;
  import java.util.ArrayList;
  
  abstract class Container{
          public static final double pi=3.1415926;
      
          public abstract double area();
          public abstract double volume();
      
          static double sumofArea(Container c[]){
              double sum1 = 0;
              for(int i = 0;i<c.length;i++)
                  sum1 = sum1 + c[i].area();
              return sum1;
          }
          static double sumofVolume(Container c[]){
              double sum2 = 0;
              for(int i =0;i<c.length;i++)
                  sum2 = sum2 + c[i].volume();
              return sum2;
          }
  }
  
  class Cube extends Container{
      private double lengths;
      
      public void setlength(double lengths){
          
      this.lengths = lengths;
      }
      @Override
      public double area() {
              
              return lengths*lengths*6;
          }
      
          @Override
      public double volume() {
              return lengths*lengths*lengths;
          }
      
  }
  
  class Cylinder extends Container{
      private double r;
      private double high;
      
      public void setlength(double r,double high){
          
          this.r = r;
          this.high = high;
      }
      @Override
      public double area() {
              
              return pi*r*r*2+2*pi*r*high;
          }
      
          @Override
      public double volume() {
              return pi*r*r*high;
          }
      
  }
  
  public class Main {
      public static void main(String[] args) {
          int time;
          Scanner in=new Scanner(System.in);
          time = in.nextInt();
          Container c[] = new Container[time];
          int i = 0;
          while(time>0){
          String a;
          a = in.next();
          if(a.equals("cube")){
              Cube cube = new Cube();
              c[i] = cube;
              double lengths = in.nextDouble();
              cube.setlength(lengths);
              }
          if(a.equals("cylinder")){
              Cylinder cylinder = new Cylinder();
              c[i] = cylinder;
              double r = in.nextDouble();
              double high = in.nextDouble();
              cylinder.setlength(r,high);
              }
              i++;
              time--;
          }
          double sumofarea = c[0].sumofArea(c);
          double sumofvolume = c[0].sumofVolume(c);
          System.out.println(String.format("%.2f",sumofarea));
          System.out.println(String.format("%.2f",sumofvolume));
      }
  }

  本题难点主要体现在对

  定义容器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类型)。

  
  
      代码分析：1.输入判断：
  
  • 1、第一行n表示对象个数，对象类型用cube、cylinder区分，cube表示立方体对象，后面输入边长，输入cylinder表示圆柱体对象，后面是底圆半径、高。
  
   
  
    　　　　　　2.数据处理：
  

  • 将所输入数据转到相应类里，进行计算。

  　　　　　　3.输出处理：

• 分别输出所有容器对象的表面积之和、体积之和，结果保留小数点后2位。

PTA大作业七

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

import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String args[])
{
    Scanner in = new Scanner(System.in);
    int i, n,j;
    n = in.nextInt();
    String a = in.nextLine();
    ArrayList<String> list = new ArrayList<String>();   
    while(n > 0)
    {
        n--;
        a = in.nextLine();
        if(list.contains(a))
        {
            continue;
        }
        else
        {
            list.add(a);
        }
    }
    System.out.println(list.size());
        String []str1 = new String[list.size()];
        list.toArray(str1);
        for(i = 0;i<str1.length;i++){
            for(j = str1.length-1;j>i;j--){
                if(str1[j].compareTo(str1[j-1])<0){
                    a = str1[j];
                    str1[j] = str1[j-1];
                    str1[j-1] = a;
                }
            }
        }
    for(String k:str1)
        System.out.println(k);
    }
}

 

 

• 本题难点主要体现在对发现会有同学的信息重复，现在他想把重复的同学信息删掉，只保留一个，
  但是工作量太大了。    代码分析：1.输入判断：
  
  • 第一行输入一个N，代表C~K导出的名单共有N行（N<100000）.接下来的N行，每一行包括一个同学的信息，学号 姓名 年龄 性别。
   
  
    　　　　　　2.数据处理：
  
  • 将所输入数据转到相应集合里，进行删减排序。
  　　　　　　3.输出处理：
• 第一行输出一个n，代表删除重复名字后C~K的班级共有几人。接下来的n行，输出每一个同学的信息，输出按照学号从小到大的顺序。

 

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

 

import java.util.Iterator; // 引入 Iterator 类
import java.util.Scanner;
import java.util.Collection;
import java.util.ArrayList;
// 1、导入相关包

//定义员工类
class Employee {

    private String name;
    private int age;

    public Employee() {
        super();
    }

    public Employee(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

//主函数
public class Main {

    public static void main(String[] args) {
                // 1、创建有序集合对象
                Collection c = new ArrayList();

      // 创建3个员工元素对象
        for (int i = 0; i < 3; i++) {
            Scanner sc = new Scanner(System.in);
            String employeeName = sc.nextLine();
            int employeeAge = sc.nextInt();
            
            Employee employee = new Employee(employeeName, employeeAge);
            c.add(employee);
        }            
                
                
                
                // 2、创建迭代器遍历集合
                Iterator it = c.iterator();
                
                //3、遍历
                while (it.hasNext()) {
                    
                    //4、集合中对象未知，向下转型
                    Employee e =  (Employee)it.next();
                    
                    System.out.println(e.getName() + "---" + e.getAge());
                }
    }

}

 

 

 

本题难点主要体现使用集合存储3个员工的信息（有序); 通过迭代器依次找出所有的员工。

代码分析：主要是迭代器的使用

    

3.踩坑心得：

 

　　1.对输入的判断一定要谨慎，尤其是最后一次的三道题目，一开始我都是拿不到满分，后来发现多多少少都有受到输入的影响！尤其是第一道题，输入判断不只是对" " , "," , "+"此三个符号的判断还有很容易忽略的"."，所以发现了此问题后我就加上了一段新代码。

　　2.电话计费基本一路磕磕绊绊，正则表达式的不够熟练导致输入判断很难。

class CallRecord extends CommunicationRecord {//具体的某一通话记录类
    private Date StartTime;
    private Date endTime;
    private String callingAddressAreaCode;
    private String answerAddressAreaCode;

    public Date getStartTime() {
        return StartTime;
    }

    public void setStartTime(Date startTime) {
        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 ChargeMode {//计费规则的合计
    private ArrayList<ChargeRule> chargeRules = new ArrayList<ChargeRule>();

    public ArrayList<ChargeRule> getChargeRules() {
        return chargeRules;
    }

    public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
        this.chargeRules = chargeRules;
    }

    public double calCost(UserRecords userRecords){
        return 1;
    }

    public double getMonthlyRen(){
        return 1;
    }
}

abstract class ChargeRule {
    public double calCost(ArrayList<CallRecord> callRecords){
        return 1;
    }
}

3.集合的运用不够到位，很多地方如果使用迭代器去遍历整个集合或者是接口进行比较会简单很多！！！

class UserRecords {
    private ArrayList<CallRecord> callingInCityRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> callingInProvinceRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> callingInLandRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> answerInCityRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> answerInProvinceRecords = new ArrayList<CallRecord>();
    private ArrayList<CallRecord> answerInLandRecords = new ArrayList<CallRecord>();
    private ArrayList<MessageRecord> sendMessageRecords = new ArrayList<MessageRecord>();
    private ArrayList<MessageRecord> receiveMessageRecords = new ArrayList<MessageRecord>();

    public ArrayList<MessageRecord> getSendMessageRecords() {
        return sendMessageRecords;
    }

    public ArrayList<MessageRecord> getReceiveMessageRecords() {
        return receiveMessageRecords;
    }

    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 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(CallRecord callRecord) {

    }

    public void addReceiveMessageRecords(CallRecord callRecord) {

    }

    public void addSendMessageRecords(MessageRecord messageRecord) {
        sendMessageRecords.add(messageRecord);
    }

    public void addReceiveMessageRecords(MessageRecord messageRecord) {
        receiveMessageRecords.add(messageRecord);
    }
}

 

 

 4.改进建议：4.改进建议：

1. 整体代码的可读性需加强有很多地方重复性太高。

  2.对大作业2的7-2题，代码缩进不行，可读性差。

                        }
                }
                for(int n=0;n<time;n++){
                    output(arr[n],n+1);
                }
            }
            }
        }
}

     　　3.大作业三的7-1题目，判断条件重复性太高，而且逻辑性不够清晰。

　　　 4.大作业三的7-2题目，整体运用的方法多，但是很多方法的内部也可以简化出别的方法。

　　　5.大作业三的7-3题目，整体困难导致几种情况想不出来，而且整体对数学函数的运用和思路都需要大大提升。

代码的继承和类的设计。

 

import java.util.Scanner;

public  class Main{
        public static void main(String []args) {
            Scanner in =new Scanner(System.in);
            String name;
            String key;
            int balance;
            
            name = in.next();
            key = in.next();
            BankBusiness account = new BankBusiness(name,key);
            
            key = in.next();
            balance = in.nextInt();
            account.deposit(key,balance);
            
            key = in.next();
            balance = in.nextInt();
            account.withdrawal(key,balance);
            
            key = in.next();
            balance = in.nextInt();
            account.withdrawal(key,balance);
            
            key = in.next();
            balance = in.nextInt();
            account.withdrawal(key,balance);
            
            account.end();
        }
}

 

5.总结：

　　本阶段三次题目集让我学到了基本的循环语句以及选择语言，尤其是更加熟练的运用字符串和字符串有关函数等等并让我更加熟练掌握了方法的运用和类的运用还有数学函数的运用等。对于类的运用和字符串以及数组等级基本类型的运用还需加强，尤其是一些基本语法。对整体的题目程序涉及方面还需加强，有很多地方可以简化运算和代码。对于java抽象及继承等方方面面还需加强尤其是有关于集合框架的部分，集合框架十分不熟练需要加强而且对于集合等等类的运用很差很多函数不知道如何使用以及很多地方如果使用了接口和迭代器的话会让代码简单很多但是仍需改进，尤其是电话计费的题目正则表达式的运用还需加强以及拓展，前期因为没有正则表达式的导致输入判断十分复杂而且不好用，容错率很低。代码的书写过程也需加强，很多题目的总体代码都存在重复性过高，可读性不强等问题。对方法的运用还需加强，熟练方法后可以增加代码可读性也能使代码更简单。

 

　作业的测试点可以增加多一些提示，譬如有些模糊不清的输入判断如果增加一些提示将会更好。整体题目的难度，就是第一次第二次比较简单，突然第三次特别难，我觉得可以第三次也有一些难题，但是也可以增加两道简单题有循序渐进的过程，电话计费也太难了，而且很容易0分希望可以改进一下一道题不需要一定是全是难得地方可以有一些简单的地方让我们得到一些基础的基本的分数。　　

 

 

dep_id