首页 > 其他分享 >BLOG-3

BLOG-3

时间：2023-06-28 13:35:26浏览次数：30  
标签：letters String BLOG 课程 成绩 id HashMap

一、前言

　　（1）第6-8次PTA题目集主要以课程成绩统计程序题目为主，难度逐步提升，此外，在 第7次题目集中还考察了HashMap及多态。

　　（2）相关知识点：这三次题目集基本覆盖了大部分java基础语法及其用法，以及java中的类及其中的方法，如HashMap类。

　　此外，还涉及了java三大特性之一的多态。（具体涉及的知识点我会在分析题目的时候总结）在有了前五次PTA作业积累的经验，这三次PTA相对而言比较顺手，学习HashMap花了较多的时间。

 二、设计与分析

　　相比于菜单，这道题目简单了一点，在有了菜单一题的经验后，我对题目的分析，理解，以及设计都有了进步。

　　课程成绩统计程序题目要求再次不在赘述，以下给出第六次题目集的类图与相关分析：

　　

　　在该题中，最为关键的就是字符串匹配（分类）类InputMatching与字符串解析类ParseInput：

对InputMatching类解析：

  1. 类变量：

    • stuNumMatching：用于匹配8位数字的正则表达式。
    • stuNameMatching：用于匹配1到10个非空格字符（不包括TAB）的正则表达式。
    • scoreMatching：用于匹配0到100之间的成绩的正则表达式。
    • courseNameMatching：用于匹配1到10个非空格字符（不包括TAB）的正则表达式。
    • courseTypeMatching：用于匹配"选修"或"必修"的正则表达式。
    • checkCourseTypeMatching：用于匹配"考试"或"考察"的正则表达式。
    • courseInput：通过组合courseNameMatching、courseTypeMatching和checkCourseTypeMatching得到的用于定义课程信息模式的字符串。
    • scoreInput1：通过组合stuNumMatching、stuNameMatching、courseNameMatching和scoreMatching得到的用于定义成绩信息模式的字符串。
    • scoreInput2：通过在scoreInput1的基础上再添加一个scoreMatching得到的用于定义成绩信息模式的字符串。

  2. 构造函数：

    • InputMatching()：默认的构造函数。

  3. 实例方法：

    • matchingInput(String s)：用于匹配输入字符串s的类型，返回对应的整数值。如果匹配为课程信息，则返回1；如果匹配为成绩信息，则返回2；如果不匹配任何类型，则返回0。

  4. 私有方法：

    • matchingCourse(String s)：用于判断输入字符串s是否匹配课程信息模式。
    • matchingScore(String s)：用于判断输入字符串s是否匹配成绩信息模式。

　　　该类封装了一些正则表达式来进行输入匹配，可以根据输入的字符串判断其是否符合特定的格式要求。使用该类可以方便地筛选和处理相关数据。

对ParseInput解析：

 　　1. listStudent、listCourse、listClass和listChooseCourse分别保存学生、课程、班级和选课的列表信息。   　　 2.courseMessage方法用于处理课程信息。它从输入字符串中提取课程名、类型和考试类型，并创建一个Course对象。然后通过调用checkCourse方法检查课程是否符合要求，并检查课程列表中是否已经存在该课程，如果满足条件则将课程添加到课程列表中。   　　 3.gradeMessage方法用于处理成绩信息。它从输入字符串中提取学生学号、班级ID、姓名和课程名，并创建一个Student对象。接着通过调用searchClass方法判断班级是否已存在，若不存在则创建一个Class对象并添加到班级列表中。然后再调用searchStudent方法判断学生是否已存在，若不存在则将学生添加到学生列表中。接下来检查课程是否存在，如果不存在则输出课程不存在的信息；如果课程存在，根据考试类型和输入字符串的长度，创建相应的成绩对象(AssessGrade或ExamGrade)并将成绩对象与课程、学生关联形成ChooseCourse对象，最后将ChooseCourse对象添加到选课列表中。    　　SourceMonitor的生成报表以供参考： 　　

　　由图可知，本题代码各项都较为良好，为接下来的进阶版课程成绩统计程序打下了较好的基础。

　　第七次题目集：

　　第七次题目集考察了HashMap的检索与排序，以下给出HashMap的检索代码：

import javax.security.auth.login.CredentialException;
import java.util.*;

public class Main {
    public static void main(String [] args){
        HashMap<Student, String> students = new HashMap<Student, String>();
        Scanner in =new Scanner(System.in);
        while (true){
            String record=in.nextLine();
            if(record.equals("end"))
                break;
            String letters[]= record.split(" ");
            String id=letters[0];
            String name=letters[1];
            String grate=letters[2];
            Student student=new Student(id,name,grate);
            students.put(student,student.getString());
        }
        String id=in.nextLine();
        Student student=searchStudent( students,id);
        if(student==null)
            System.out.println("The student "+id+" does not exist");
        else{
            System.out.println(id+" "+student.getString());
        }
        for(Student key:students.keySet()){

        }
    }
    public static Student searchStudent(HashMap<Student, String> students,String id){
        for(Student key:students.keySet()){
            if(key.id.equals(id))
                return key;
        }
        return null;
    }
}
class Student implements Comparable<Student>{
    String id;
    String name;
    String grade;

    public Student(String id,String name,String grade) {
        this.id=id;
        this.name=name;
        this.grade=grade;
    }
    public String getString(){
        String s=name+" "+grade;
        return s;
    }
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getGrade() {
        return grade;
    }

    public void setGrade(String grade) {
        this.grade = grade;
    }
    @Override
    public int compareTo(Student s) {
        int num = new Integer(this.getId()).compareTo(new Integer(s.id));
        if (num == 0) {
            num = this.getName().compareTo(s.getName());
        }
        return num;
    }

　　

　　这段代码创建了一个名为students的HashMap对象。该HashMap的键类型是Student，值类型是String。HashMap是Java中的一种散列映射数据结构，它允许存储和检索键值对。在这个代码示例中，Student对象被用作键，对应的字符串String作为值。Student是自定义的类，可能包含学生的相关信息，例如学生ID、姓名、年龄等。通过将Student对象与对应的字符串进行关联，可以使用学生对象快速查找和获取相应的字符串值。

　　在完成检索之后，我进一步学习了HashMap的排序，排序方法很多，以下给出我使用的相关排序的代码：

　

 Set set=students.keySet();
        String[] arr= set.toArray();
        Arrays.sort(arr);
        for(int i=arr.length-1;i>=0;i--){
            Object key=arr[i];
            System.out.println(key+" "+students.get(key));
        }

 

　　这段代码对HashMap对象 students 中的键值对进行排序，并按照逆序输出。首先，set变量通过students.keySet()方法获得了students中所有的键，并存储在一个Set集合中。接下来，用set.toArray()方法将Set集合转换为数组arr。这样做是为了方便后续的排序操作。然后，使用Arrays.sort(arr)对数组arr进行排序，这里使用的是默认的自然排序方式，即根据元素的比较结果进行排序。最后，通过使用for循环从后往前遍历数组arr，取得每个键并分别打印出键和对应的值。需要注意的是，由于arr数组的类型是String[]，所以在循环体内将键赋值给Object key时，它会被自动向上转型为Object类型。然后使用students.get(key)方法获取到了键对应的值，并通过System.out.println()语句将键和值输出。综上所述，该代码片段的作用是对students中的键进行排序，然后逆序输出键及其对应的值。

　　第七次题目集中还考察了java中的多态，题目相对简单，我们最重要搞清楚多态的概念：

　　多态是面向对象编程中的一个重要概念，它是指同一类型的对象，在不同的情境下可以表现出不同的行为。

　　在Java中，多态主要通过继承和方法重写实现。当子类继承自父类并且重写了父类的方法时，可以使用父类的引用指向子类的对象，并调用相同的方法名，但具体执行的是子类重写后的方法。

　　多态的优势在于可以提高代码的灵活性和可扩展性。它可以使相同类型的对象具有不同的行为，根据具体情况选择正确的方法执行，避免了大量的条件语句。同时，多态也支持面向接口编程，降低了代码间的耦合度，并方便了代码的维护和开发过程中的模块化设计。

　　在第七次题目集中，最具有难度的就是第三题，在第六次题目集课程成绩统计程序的基础上增加了实验课，并由以下要求：

　　1、实验的总成绩等于课程每次实验成绩的平均分。

　　2、实验课的成绩必须为实验。

　　3、实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩。

　　4、实验次数至少4次，不超过9次。

　　5、实验课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+实验次数+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩。

　　6、实验课成绩格式：课程名称+英文空格+总成绩平均分。

　　其实本质上还是一样，只需要在处理课程信息和课程成绩信息的代码上做一些修改即可，以下给出判断实验课课程成绩信息的代码：

private static boolean matchingExScore(String s){
        /**实验课程成绩信息包括：学号、姓名、课程名称、实验次数、每次成绩
         实验次数至少4次，不超过9次
         实验课程信息格式：0学号+英文空格+1姓名+英文空格+2课程名称+英文空格+3实验次数+英文空格+第一次实验成绩+...+英文空格+最后一次实验成绩*/
        //20201103 张三 java 4 70 80 90
        String letters[]=s.split(" ");

        if(letters[0].matches(stuNumMatching)&&letters[1].matches(stuNameMatching)&&letters[2].matches(courseNameMatching)&&letters[3].matches(experimentNum)){
            for(int i=4;i<letters.length;i++){
                if(!letters[i].matches(scoreMatching))
                    return false;
            }
            return true;
        }
        return false;
    }

 

　　该方法通过使用正则表达式进行匹配来验证输入字符串中的各个字段是否符合规定的格式。具体而言，该方法根据以下条件进行判断：

  1. letters[0]（学号）、letters[1]（姓名）、letters[2]（课程名称）和letters[3]（实验次数）分别使用对应的正则表达式进行匹配验证。
  2. 如果以上四个字段都成功匹配，则进一步遍历letters数组中从索引位置4开始的元素。
  3. 对于从索引位置4开始的每个元素，使用正则表达式进行匹配验证，检查是否符合实验成绩的格式要求。
  4. 如果所有的字段都符合相应的格式要求，那么返回true，否则返回false。

　　课程信息的判断：

　　 static String courseTypeMatching = "(选修|必修|实验)";
    static String checkCourseTypeMatching = "(考试|考察|实验)";

　　用正则表达式解决。

　　

　　第八次题目集

　　第一题很简单了，实现Comparable接口就解决了。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Main {
    public static void main(String [] args){
        
        Scanner in=new Scanner(System.in);
        ArrayList<Student> students=new ArrayList<>();
        while(true){
            String input=in.nextLine();
            if(input.equals("end"))
              break;
                String letters[] = input.split(" ");
                String id = letters[0];
                String name = letters[1];
                int mathScore = Integer.parseInt(letters[2]);
                int physicalScore = Integer.parseInt(letters[3]);
                Student student = new Student(id, name, mathScore, physicalScore);
                students.add(student);
        }
        Collections.sort(students);
        for(Student stu:students){
            System.out.println(stu.id+" "+stu.name+" "+stu.sum);
        }

    }
}
class Student implements Comparable<Student>{
    String id;
    String name;
    int mathScore;
    int physicalScore;
    int sum;
    public Student(String id,String name,int mathScore,int physicalScore) {
        this.id=id;
        this.name=name;
        this.mathScore=mathScore;
        this.physicalScore=physicalScore;
        this.sum=mathScore+physicalScore;
    }

    @Override
    public int compareTo(Student o) {
        return o.sum-this.sum;
    }
}

　　第二题做法类似，有意思的是第四题，自定义接口ArrayIntegerStack，根据题目要求分析如下：

  1. 定义IntegerStack接口，声明存放整数元素的栈的常见方法。
  2. 实现ArrayIntegerStack类作为IntegerStack接口的实现类，内部使用数组来表示栈，并可以指定内部数组的大小。
  3. 在main方法中，按照指定的步骤进行操作：
    • 输入一个整数n，创建一个能够容纳n个元素的ArrayIntegerStack对象。
    • 依次输入m个整数值，并将它们压入栈中，每次入栈都打印入栈的返回结果。
    • 输出栈顶元素，判断栈是否为空，输出栈的大小。
    • 使用Arrays.toString()方法输出内部数组中的元素。
    • 输入一个整数x，然后连续出栈x次，并在每次出栈时打印出栈的元素。
    • 输出栈顶元素，判断栈是否为空，输出栈的大小。
    • 使用Arrays.toString()方法输出内部数组中的元素。

　　注意事项：在实现上述功能时，需要考虑边界条件和异常情况，比如当栈已满或者栈为空时的处理。

　　以下给出该题的代码：

　　

 1 import java.util.*;
 2 
 3 public class Main {
 4     public static void main(String [] args){
 5         Scanner in=new Scanner(System.in);
 6         String n=in.nextLine();
 7         ArrayIntegerStack arrayIntegerStack=new ArrayIntegerStack(Integer.parseInt(n));
 8         String m=in.nextLine();
 9 
10         String s=in.nextLine();
11         String letters[]=s.split(" ");
12         for(int i=0;i<Integer.parseInt(m);i++){
13             System.out.println(arrayIntegerStack.push(Integer.parseInt(letters[i])));
14         }
15         System.out.println(arrayIntegerStack.peek()+","+arrayIntegerStack.empty()+","+arrayIntegerStack.size());
16 
17         System.out.println(Arrays.toString(arrayIntegerStack.stackArray));
18 
19         String x= in.nextLine();
20         for(int i=0;i<Integer.parseInt(x);i++){
21             System.out.println(arrayIntegerStack.pop());
22         }
23 System.out.println(arrayIntegerStack.peek()+","+arrayIntegerStack.empty()+","+arrayIntegerStack.size());
24         System.out.println(Arrays.toString(arrayIntegerStack.stackArray));
25 
26         
27     }
28 }
29 interface IntegerStack{
30     public Integer push(Integer item);
31 //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。
32 
33     public Integer pop();   //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
34     public Integer peek();  //获得栈顶元素，如果为空，则返回null.
35     public boolean empty(); //如果为空返回true
36     public int size();      //返回栈中元素个数
37 }
38 class ArrayIntegerStack implements IntegerStack{
39     String[] stackArray;
40     int top;
41     // 创建指定大小的数组实现栈
42     public ArrayIntegerStack(int size) {
43         stackArray = new String[size];
44         top = -1;
45     }
46     @Override
47     public Integer push(Integer item) {
48         
49         if (top == stackArray.length - 1) {
50             return null;
51         }
52         if(item==null)
53             return null;
54         top++;
55         stackArray[top] = item.toString();
56         return item;
57     }
58 
59     @Override
60     public Integer pop() {
61         if(top==-1)
62             return null;
63         String element = stackArray[top];
64         top--;
65         return Integer.parseInt(element);
66     }
67 
68     @Override
69     public Integer peek() {
70         if(top==-1)
71         return null;
72         return Integer.parseInt(stackArray[top]);
73     }
74 
75     @Override
76     public boolean empty() {
77         if(top==-1)
78         return true;
79         return false;
80     }
81 
82     @Override
83     public int size() {
84         return top + 1;
85     }
86 }

　　上述代码定义了一个IntegerStack接口以及其实现类ArrayIntegerStack，用于表示存放整数元素的栈，并提供了常见的方法。 在main方法中，首先输入一个整数n作为栈的容量，然后创建了一个容量为n的ArrayIntegerStack对象。 接下来，输入了m个整数值，并依次将它们压入栈中，并打印每次入栈的返回结果。 随后，输出栈顶元素、判断栈是否为空以及栈中元素个数，并使用Arrays.toString()方法输出栈的内部数组中的元素。 接着，输入一个整数x，并连续出栈x次，每次出栈时打印出栈的元素。 最后，再次输出栈顶元素、判断栈是否为空以及栈中元素个数，并使用Arrays.toString()方法输出栈的内部数组中的元素。

　　在理清思绪之后，这道题目还是很容易被解决的。

　　在第八次题目集中，课程成绩统计程序-3在第二次的基础上修改了计算总成绩的方式，

　　要求：

   　1、修改类结构，将成绩类的继承关系改为组合关系，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，分项成绩类由成绩分值和权重两个属性构成。

　　2、实验的总成绩等于课程每次实验成绩乘以权重后累加而得。

　　3、课程权重值在录入课程信息时输入。（注意：所有分项成绩的权重之和应当等于1）

　　4、课程信息包括：课程名称、课程性质、考核方式、分项成绩数量、每个分项成绩的权重。

　　　考试课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+平时成绩的权重+英文空格+期末成绩的权重

　　　考察课信息格式：课程名称+英文空格+课程性质+英文空格+考核方式

           实验课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式+英文空格+分项成绩数量n+英文空格+分项成绩1的权重+英文空格+。。。+英文空格+分项成绩n的权重

　　相对于第二次，第三次的改变较为复杂，课程信息的代码也做出了一些修改：

 1 private static boolean matchingCourse(String s) {
 2         String letters[]=s.split(" ");
 3         if(letters[0].matches(courseNameMatching)&&letters[1].matches(courseTypeMatching)
 4                 &&letters[2].matches(checkCourseTypeMatching)&&letters[3].matches(coursePowerNum))
 5         {
 6             if(letters[1].equals("实验")&&letters[2].equals("实验")&&(!letters[3].matches(experimentNum)))
 7                 return false;
 8             for(int i=4;i<letters.length;i++){
 9                 if(!letters[i].matches(powerNum))
10                     return false;
11             }
12             return true;
13         }
14         return false;
15     }

　　根据要求，需要对类的结构进行修改，将成绩类的继承关系改为组合关系。具体地，成绩信息由课程成绩类和分项成绩类组成，课程成绩类组合分项成绩类，而分项成绩类由成绩分值和权重两个属性构成。

　　以下给出相关类图与SourceMonitor的生成报表：

　　通过组合关系，成绩信息类包含一个课程成绩对象，而课程成绩类则包含一个分项成绩对象。分项成绩类拥有成绩分值和权重两个属性用来表示某一具体分项的成绩情况。这样的设计使得成绩类的组合关系更加灵活和复用性更高，可以方便地添加、修改或删除各个组成部分，同时也符合面向对象的设计原则。

　　比较课程成绩统计程序-1与课程成绩统计程序-3的题目难度与SourceMonitor的生成报表内容，可知虽然题目要求增加了，题目难度有一定的提高，但是代码的规范性大大提高，足以见类的使用给我们程序员带来的便捷，不仅在与编写的过程，在浏览他人的代码时，规范的代码更容易理解与修改。

三、采坑心得

　　1、第八次题目集第四题中，因没注意满栈存入，第二个测试点没过，后来仔细审题，才发现自己的错误，以下给出我的代码：

 1 import java.util.*;
 2 
 3 public class Main {
 4     public static void main(String [] args){
 5         Scanner in=new Scanner(System.in);
 6         String n=in.nextLine();
 7         ArrayIntegerStack arrayIntegerStack=new ArrayIntegerStack(Integer.parseInt(n));
 8         String m=in.nextLine();
 9 
10         String s=in.nextLine();
11         String letters[]=s.split(" ");
12         for(int i=0;i<Integer.parseInt(m);i++){
13             System.out.println(arrayIntegerStack.push(Integer.parseInt(letters[i])));
14         }
15         System.out.println(arrayIntegerStack.peek()+","+arrayIntegerStack.empty()+","+arrayIntegerStack.size());
16 
17         System.out.println(Arrays.toString(arrayIntegerStack.stackArray));
18 
19         String x= in.nextLine();
20         for(int i=0;i<Integer.parseInt(x);i++){
21             System.out.println(arrayIntegerStack.pop());
22         }
23 System.out.println(arrayIntegerStack.peek()+","+arrayIntegerStack.empty()+","+arrayIntegerStack.size());
24         System.out.println(Arrays.toString(arrayIntegerStack.stackArray));
25 
26         
27     }
28 }
29 interface IntegerStack{
30     public Integer push(Integer item);
31 //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。
32 
33     public Integer pop();   //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
34     public Integer peek();  //获得栈顶元素，如果为空，则返回null.
35     public boolean empty(); //如果为空返回true
36     public int size();      //返回栈中元素个数
37 }
38 class ArrayIntegerStack implements IntegerStack{
39     String[] stackArray;
40     int top;
41     // 创建指定大小的数组实现栈
42     public ArrayIntegerStack(int size) {
43         stackArray = new String[size];
44         top = -1;
45     }
46     @Override
47     public Integer push(Integer item) {
48         
49         if (top == stackArray.length - 1) {
50             return null;
51         }
52         if(item==null)
53             return null;
54         top++;
55         stackArray[top] = item.toString();
56         return item;
57     }
58 
59     @Override
60     public Integer pop() {
61         if(top==-1)
62             return null;
63         String element = stackArray[top];
64         top--;
65         return Integer.parseInt(element);
66     }
67 
68     @Override
69     public Integer peek() {
70         if(top==-1)
71         return null;
72         return Integer.parseInt(stackArray[top]);
73     }
74 
75     @Override
76     public boolean empty() {
77         if(top==-1)
78         return true;
79         return false;
80     }
81 
82     @Override
83     public int size() {
84         return top + 1;
85     }
86 }

　　

　　在ArrayIntegerStack类的实现中，我们需要考虑空栈和满栈的状态。在题目要求的方法实现中已经对这两种状态进行了处理。

  1. 对于空栈状态，在创建ArrayIntegerStack对象时，我们初始化栈顶指针top为-1，表示栈为空。在empty()方法中，检查top是否等于-1来判断栈是否为空。

  2. 对于满栈状态，在push()方法中，我们通过调用isFull()方法来检查栈是否已满。isFull()方法检查top是否等于数组长度减1，如果相等则表示栈已满。当栈满时，不会入栈新元素，并返回null。

　　2、在课程成绩统计程序-3中， 在尝试多次后仍有几个测试点未过：

四、主要困难以及改进建议

　　（1）主要困难：

　　一、是知识点的补充，这三次题目集让我学会了HashMap及IntegerStack接口。

　　二、对课程成绩统计程序的分析，对不同的要求要分析，最后总结是一个挺困难的事情。

　　（2）改进建议：

　　有SouranceMonitor的生成报表图可知，对代码的注释需要增加，这在写代码中也是非常重要的一环，有简单明了的注释，在自己写代码的过程中也能够让自己读懂，方便自己前后增添、修改代码。除代码的注释外，对变量的命名也要规范，要使用简单易懂，具有意义的名称，使代码易于理解与维护。

五、总结

　　（1）这三次作业包含的知识点很广泛，极大的补充了我的知识库，让我对java这门语言有了更深入的了解，也让我学会了更好的自主学习，自我学习。

　　（2）学习Java中的HashMap、IntegerStack接口以及多态的相关知识，让我们对面向对象编程中的关键概念和技术有了更深入的理解。下面是针对这些主题的综合总结：

　　一、HashMap： HashMap是Java中常用的数据结构之一，它实现了Map接口，并基于哈希表（Hash Table）来存储和访问数据。HashMap的特点包括：

  1. 键值对：HashMap存储数据的单位是键值对（Key-Value），其中键是唯一的，而值可以重复。
  2. 快速查找：通过哈希函数将键映射到哈希表的特定位置，从而实现快速的插入、查找和删除操作。
  3. 基于数组和链表/红黑树：HashMap内部实现了一个数组，每个数组元素是一个链表/红黑树的头节点。当链表长度过长时，会转化为红黑树以提高性能。
  4. 非同步：HashMap是非同步的，不具备线程安全性，需要在多线程环境下注意同步问题。

　　在使用HashMap时，需注意以下几点：

  1. 键的唯一性：HashMap要求键是唯一的，如果重复插入相同键的键值对，则后面的值会覆盖前面的值。
  2. 性能优化：通过设置初始容量、负载因子等参数，可以提高HashMap的性能。
  3. hashCode和equals方法：为了正确地使用HashMap，需要正确实现键对象的hashCode()和equals()方法。

　　二、IntegerStack接口： IntegerStack接口定义了一个整数栈的操作规范，包括入栈、出栈、获取栈顶元素、判断栈是否为空以及获取栈的大小等方法。它提供了一种抽象的方式来描述整数栈的行为。

　　通过使用IntegerStack接口，可以实现多态的编程特性。具体表现在：

  1. 实现类的灵活性：通过实现IntegerStack接口，可以创建不同的整数栈实现类，如ArrayIntegerStack、ListIntegerStack等，每个实现类有自己的内部结构和算法，但对外提供相同的操作方法。
  2. 接口引用变量多态性：可以声明一个接口类型的引用变量，并将其指向任何实现该接口的对象。这样做可以统一处理不同的具体实现类，并且根据需要在运行时动态选择实际引用的对象。

　　三、多态： 多态是面向对象编程中非常重要的概念之一，它体现了软件设计的灵活性和可扩展性。具体包括以下几个方面：

  1. 继承和重写：基于类与对象之间的继承关系，子类可以重写父类的方法，并提供自己特定的实现。通过多态，我们可以使用父类类型的引用变量来调用子类对象的重写方法。
  2. 接口与实现：接口提供了一种规范和契约，它定义了一组必须实现的方法。通过接口，可以实现不同类之间的共享规则，使得对象在代码层面表现出多态性。
  3. 引用变量多态性：通过使用父类或接口类型的引用变量，可以引用不同的具体子类对象，从而提高代码的灵活性和可扩展性。根据实际运行时所引用的对象类型

　　（3）改进：要多花一点时间在学习java上，java中的已经定义的类是非常多的，仅仅是写题目的时候用一次只能有一个粗略映像，需要花其他时间去巩固。此外，在写题目时，自己需要更有耐心一点，不要急于求成，也不要不带脑子写代码，使得写出的代码不仅得分不高，质量还低。

　　（4）对于老师布置的作业，我觉得老师布置的作业题量适中，精确把握在我们能够完成的时间内。

 

标签：letters,String,BLOG,课程,成绩,id,HashMap
From： https://www.cnblogs.com/zhangtaowei/p/17510792.html

相关文章

  • 选课成绩管理系统-BLOG-3-PTA6-8
    目录（1）前言（2）设计与分析（3）踩坑心得（4）改进建议（5）总结正文（1）前言题目知识点题量（5分为满）难度（5分为满）选课11.正则表达式的基本使用（选课1要求会读懂）。2.多次if-else完成业务判断。3.解析字符串处理一般业务（之后我会总结到正文第五点总结部分）。4.简单的继承多态，以及基本......
  • Blog - 3
    前言这次的题目集总共有三道题，难度逐级增加，不过只要逻辑清晰，还是很容易做出来的。以下是涉及到的知识点：Java基础语法，包括变量、数据类型、运算符、控制语句等。Java中的字符串处理，包括字符串的拼接、分割、替换等。Java中的数组和集合，包括数组的定义、初始化、遍历等，以......
  • 6-8次PTA题目集（成绩计算系列）BLOG-3
    1.前言对题目集的总结：1.知识点第6次：6-1课程成绩计价程序-1锻炼学生自主构建类（maybe，如果是完全参考题目给的那当我没说），实现继承，组合关系的能力。第7次：或许是上次作业有些学生不太理想，所有第七次出了几个小题去让学生了解一些知识点：7-1 容器-HashMap-检索（相当于利用HashMap......
  • 题目集7~11的总结性Blog
    一、前言（1）pta第七次作业题目列表如下：7-1 菜单计价程序-5总结：这个菜单计价1程序-5是前菜单计价程序-3的迭代，难度较之前的有所提升，题目难度对我来说感觉很大，写了很久也没有拿下。（2）pta第八次作业题目列表如下：7-1课程成绩统计程序-1总结：总算是熬过了菜单，迎来了新的课......
  • BLOG-3
    某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。考察的总成绩直接等于期末成绩必修课的考核方式必须为考试，选修课可以选择考试、......
  • oop题目集7~11的总结性Blog
    目录一、前言二、设计与分析：一、前言4~6的训练集难度较上一次提升很多，训练了很多java中独有的提供好的方法，如hashset，数组的sort等方法，实现了代码运行时间的优化，和内存的占用减少，学会了代码的封装，和使用类间关系，同时了解并使用了正则表达式,了解Scanner类中nextLine()等方法、Str......
  • 面向对象程序设计题目集总结blog3
    一、前言本次是第三次对面向对象程序设计题目集的总结分析博客。 关于知识点本次的题目集所体现的知识点重点考虑设计问题，许多题目不提供类图，或者只提供一个参考框架（只有类和类之间的关系），题目的代码量也较于前几次提升了不少。题目集七注重类的设计，通过三道设......
  • JavaBlog-3
    前言第三次也是最后博客文章主要是关于java课程第三阶段关于PTA题目集、超星作业以及在实验平台上布置的一些题型。相较于第一、二阶段的作业总结而言此次作业更加针对于总结在面向对象过程中的三大技术特性，即封装性、继承性和多态性，类图的设计更加普遍。在不断深入学习Java......
  • 第三次blog
    1.前言      这是第三次作业总结，总体难度适中，主要考验我们的学习能力和对编程的理解能力，有之前题目的迭代（菜单和成绩系统）和新方法的使用（如：题目集9中的考查语法(map,set)的使用），迭代的部分因为能力的问题（主要就是懒）没有完善之前的代码，所以难以迭代，都学到最后阶段了，还学的......
  • 题目集7~11的总结性blog
    一.前言这是这学期最后一次blog了，其中有7~11五次题目集题目集07：只有一道题，该题为菜单计价程序-5，是菜单计价程序-3的迭代，与菜单计价程序-4属于不同的迭代分支。 ......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99