Java实验5《面向对象——多态》

灰太狼 2021-11-23 00:10 397阅读 0赞

一、实验目的

  1. 理解多态性和动态绑定
  2. 存储、提取和操作ArrayList中的对象

二、实验内容

  1. 【Person、Student、Employee类】（注：此题在书上原题基础上有修改）设计一个名为Person的类和它的两个名为Student和Employee子类。
      每个人都有姓名和电话号码。学生有年级状态（大一、大二、大三或大四）。将这些状态定义为常量。一个雇员有工资和受聘日期。定义一个名为MyDate的类，包含数据域：year（年）、month（月）和day（日）。将各个类的数据域进行封装，并设置合理的读写访问器。
    覆盖每个类中的toString方法，返回类名及相应的类中可以获取的所有信息构成的字符串，如Person类的toString方法返回“Person类：姓名为*** 电话为***”；Student类的toString方法返回“Student类： 姓名为*** 电话为*** 年级为***”。
      在Student和Employee两个类中分别加入displayObject()方法，可以打印出对学生和雇员的提示消息，提示学生“to ***（学生姓名）：请按时交实验报告”，提示雇员“to ***（雇员姓名）：请按时上班”。
      目标输出任务：

    • 画出这些类的UML图。
    • 实现这些类。
    • 编写一个测试类，
      1）创建方法public static void m1(Person p)，显示p的姓名；
      2）创建方法public static void m2(Person p)，打印p的toString方法返回的字符串；
      3）创建方法public static void m3(Person p)，如果p是Student类或者Employee类的实例，分别调用它们的displayObject()；
      4）在主函数中创建Person、Student、Employee的对象实例，将它们均声明为Person类对象。将它们分别传入m1、m2和m3，体会多态。

 1.1 UML图
Alt

 1.2 程序代码：
（1）TestProgram1类的源程序：

  1. //TestProgram1类的源程序
  2. //此测试类用于测试Person类、Student类、Employee类
  3. public class TestProgram1{ 
  4.      public static void main(String[] args){ 
  5.      //在主函数中创建Person、Student、Employee的对象实例，
  6.   //将它们均声明为Person类对象。将它们分别传入m1、m2和m3
  7.            Person p1 = new Person("Annay", "15269358569");
  8.            Person p2 = new Student("大一", "Boens", "14985685962");
  9.            Person p3 = new Employee("10万/月", new MyDate("2018", "1", "20") , "Concy", "18659856589");
  11.            //将对象p1分别传入方法m1、m2、m3中
  12.            m1(p1);
  13.            m2(p1);
  14.            m3(p1);
  15.            //将对象p2分别传入方法m1、m2、m3中
  16.            m1(p2);
  17.            m2(p2);
  18.            m3(p2);
  20.            //将对象p3分别传入方法m1、m2、m3中
  21.            m1(p3);
  22.            m2(p3);
  23.            m3(p3);
  25.      }//mian方法结束
  27.      //显示p的姓名
  28.      public static void m1(Person p){ 
  29.            System.out.println( p.getName() );
  30.      }//m1结束
  32.      //打印p的toString方法返回的字符串
  33.      public static void m2(Person p){ 
  34.           System.out.println( p.toString() );
  35.      }//m2结束
  37.       //如果p是Student类或者Employee类的实例，分别调用它们//的displayObject()
  38.      public static void m3(Person p){ 
  39.            if(p instanceof Student)
  40.                  ((Student)p).displayObject();
  41.            else if(p instanceof Employee)
  42.                  ((Employee)p).displayObject();
  43.      }//m3结束
  44. }//TestClass结束

（2）Person类的源程序：

  1. //Person类的源程序
  2. public class Person { 
  3.     private String name;
  4.     private String numbers;
  6.     public Person(){ 
  8.     }
  10.     public Person(String name, String numbers){ 
  11.          this.name = name;
  12.          this.numbers = numbers;
  13.     }
  15.     public String getName(){ 
  16.          return name;
  17.     }
  19.     public String getNumbers(){ 
  20.            return numbers;
  21.     }
  23.     public void setName(String name){ 
  24.           this.name = name;
  25.     }
  27.     public void setNumbers(String numbers){ 
  28.             this.numbers = numbers;
  29.     }
  31.     public String toString(){ 
  32.           return "Person类：姓名为" + name + " 电话为" + numbers;
  33.     }
  34. }

（3）Student类的源程序：

  1. //Student类的源程序
  2. public class Student extends Person{ 
  3.      private String status;
  5.      public Student(){ 
  7.      }
  9.      public Student(String status, String name, String numbers){ 
  10.           super(name, numbers);
  11.           this.status = status;
  12.      }
  14.      public String getStatus(){ 
  15.           return status;
  16.      }
  18.      public void setStatus(String status){ 
  19.           this.status = status;
  20.      }
  22.      public void displayObject(){ 
  23.          System.out.println("to " + super.getName() + "：请按时交实验报告");
  24.      }
  26.     public String toString(){ 
  27.         return "Student类：姓名为" + super.getName() + " 电话为" 
  28.                 + super.getNumbers() + " 年级为" + status;
  29.     }
  30. }

（4）Employee类的源程序：

  1. //Employee类的源程序
  2. public class Employee extends Person { 
  3.     private String salary;
  4.     private MyDate dateOfEmployment=new MyDate();
  6.     public Employee(){ 
  8.     }
  10.     public Employee(String salary,MyDate dateOfEmployment,String name,String numbers){ 
  11.         super(name,numbers);
  12.         this.salary = salary;
  13.         this.dateOfEmployment = dateOfEmployment;
  14.     }
  16.     public String getSalary(){ 
  17.         return salary;
  18.     }
  20.     public void setSalary(String salary){ 
  21.         this.salary = salary;
  22.     }
  24.     public MyDate getDateOfEmployment(){ 
  25.         return dateOfEmployment;
  26.     }
  28.     public void setDateOfEmployment(MyDate dateOfEmployment){ 
  29.         this.dateOfEmployment = dateOfEmployment;
  30.      }
  32.     public void displayObject(){ 
  33.         System.out.println("to "+ super.getName() + ": 请按时上班");
  34.     }
  36.     public String toString(){ 
  37.          return "Employee类：姓名为" + super.getName() 
  38. + " 电话为" + super.getNumbers() + " 工资为" + salary;
  39.    }
  40. }

（5）MyDate类的源程序：

  1. //MyDate类的源程序：
  2. public class MyDate{ 
  3.     private String year;
  4.     private String month;
  5.     private String day;
  7.         public MyDate(){ 
  9.         }
  11.         public MyDate(String year, String month, String day){ 
  12.              this.year = year;
  13.              this.month = month;
  14.              this.day = day;
  15.         } 
  17.         public String getYear(){ 
  18.              return year;
  19.         }
  21.         public String getMonth(){ 
  22.              return month;
  23.         }
  25.         public String getDay(){ 
  26.                return day;
  27.          }
  29.         public void setYear(){ 
  30.               this.year = year;
  31.         }
  33.         public void setMonth(String month){ 
  34.             this.month = month;
  35.         }
  37.         public void setDay(String day){ 
  38.            this.day = day;       
  39.         }
  40. }

  1.3 运行结果与分析：
Alt
    运行正确，符合题目要求。创建三个类的实例，三个测试方法，每个实例都用三个方法测试。

  1.4 心得体会：
    此题主要是三个类之间的继承与多态关系应用，先画UML图再一次性写出三个类，当然还有额外的MyDate类，最后再写测试类，测试类中的方法调用需谨慎书写。这道题的难点在于不同类之间的方法与对象的调用，类的声明类型与实际类型的应用。

  1. （P380, 11.5）【课程类Course】改写程序清单10-6中的Course类。 使用ArrayList代替数组来存储学生。不应该改变Course类的原始合约 （即不要改变构造方法和方法的方法头定义，包括返回类型、方法名及参数列表，但私有的成员可以改变）。

    //程序清单10-6
    public class Course {
    private String courseName;
    private String[] students = new String[100];
    private int numberOfStudents;

    public Course(String courseName) { 

    1. this.courseName = courseName;

    }

    public void addStudent(String student) { 

    1. students[numberOfStudents] = student;
    2. numberOfStudents++;

    }

    public String[] getStudents() { 

    1. return students;

    }

    public int getNumberOfStudents() { 

    1. return numberOfStudents;

    }

    public String getCourseName() { 

    1. return courseName;

    }

    public void dropStudent(String student) { 

    1. // Left as an exercise in Exercise 9.9

    }
    }

    //程序清单10-5
    //【注意：请参考以下程序来测试Course类，同时注意在此段程序基础上，增加必要的代码，以完整地测试Course类中定义的所有方法】
    public class TestCourse {
    public static void main(String[] args) { 

    1. Course course1 = new Course("Data Structures");
    2. Course course2 = new Course("Database Systems");
    4. course1.addStudent("Peter Jones");
    5. course1.addStudent("Brian Smith");
    6. course1.addStudent("Anne Kennedy");
    8. course2.addStudent("Peter Jones");
    9. course2.addStudent("Steve Smith");
    11. System.out.println("Number of students in course1: "
    12.   + course1.getNumberOfStudents());
    13. String[] students = course1.getStudents();
    14. for (int i = 0; i < course1.getNumberOfStudents(); i++)
    15.   System.out.print(students[i] + ", ");
    17. System.out.println();
    18. System.out.print("Number of students in course2: "
    19.   + course2.getNumberOfStudents());

    }
    }

 2.1 程序代码：
（1）Course类

  1. //Course类
  2. import java.util.ArrayList;
  4. public class Course { 
  5.   private String courseName;
  6.   private ArrayList<String> students = new ArrayList<>();
  8.   public Course(String courseName) { 
  9.     this.courseName = courseName;
  10.   }
  12.   //添加学生
  13.   public void addStudent(String student) { 
  14.     students.add(student);
  15.   }
  17.   //输出学生姓名
  18.   public String[] getStudents() { 
  19.     int size = students.size();
  20.     String[] st = new String[size];
  21.     for(int i=0; i<students.size(); i++)
  22.          st[i] = students.get(i);
  23.     return st;
  24.   }
  26.   //返回数组大小
  27.   public int getNumberOfStudents() { 
  28.     return students.size();
  29.   }  
  31.   //返回课程名称
  32.   public String getCourseName() { 
  33.     return courseName;
  34.   }  
  36.   //删除学生
  37.   public void dropStudent(String student) { 
  38.     students.remove(student);
  39.   }
  40. }

（2）TestCourse类

  1. //TestCourse类
  2. public class TestCourse { 
  3.   public static void main(String[] args) { 
  4.     Course course1 = new Course("Data Structures");
  5.     Course course2 = new Course("Database Systems");
  7.     //输入coures1,course2的学生名字
  8.     course1.addStudent("Peter Jones");
  9.     course1.addStudent("Brian Smith");
  10.     course1.addStudent("Anne Kennedy");
  12.     course2.addStudent("Peter Jones");
  13.     course2.addStudent("Steve Smith");
  15.     //输出course1的名称
  16.     System.out.println("course1: " + course1.getCourseName());
  18.     //输出course1的学生数量
  19.     System.out.println("Number of students in course1: "
  20.       + course1.getNumberOfStudents());
  22.     //输出course1的学生名字
  23.     String[] st1 = course1.getStudents();
  24.     for (int i = 0; i < course1.getNumberOfStudents(); i++)
  25.       System.out.print(st1[i] + ", ");
  27.     System.out.println();
  28.     System.out.println();
  30.     System.out.println("After coures1 removes \"Peter Jones\" ");
  31.     //删除courese1中的“Peter Jones”
  32.     course1.dropStudent("Peter Jones");
  34.     //输出删除后course1的学生数量
  35.     System.out.println("Number of students in course1: "
  36.       + course1.getNumberOfStudents());
  38.     //输出删除后course1的学生名字
  39.     String[] st3 = course1.getStudents();
  40.     for (int i = 0; i < course1.getNumberOfStudents(); i++)
  41.       System.out.print(st3[i] + ", ");
  43.     System.out.println();
  44.     System.out.println();
  46.     //输出course2的名称
  47.     System.out.println("course2: " + course2.getCourseName());
  49.     //输出course2的学生数量 
  50.     System.out.println("Number of students in course2: "
  51.       + course2.getNumberOfStudents());
  53.     //输出course2的学生名字
  54.     String[] st2 = course2.getStudents();
  55.     for (int i = 0; i < course2.getNumberOfStudents(); i++)
  56.       System.out.print(st2[i] + ", ");
  58.     System.out.println();
  59.     System.out.println();
  61.     System.out.println("After coures2 removes \"Steve Smith\" ");
  63.     //删除courese2中的“Steve Smith”
  64.     course2.dropStudent("Steve Smith");
  66.     //输出删除后course2的学生数量
  67.     System.out.println("Number of students in course2: "
  68.       + course2.getNumberOfStudents());
  70.     //输出删除后course2的学生名字
  71.     String[] st4 = course2.getStudents();
  72.     for (int i = 0; i < course2.getNumberOfStudents(); i++)
  73.       System.out.print(st4[i] + ", ");
  75.     System.out.println();
  76.   }
  77. }

  2.2 运行结果：
Alt

  2.3 心得体会：
    此题主要是ArrayList类中的方法的调用与运用，再就是测试时运用所有已创建的方法以及调整输出格式。

  1. 附加题（可选做）（P381, 11.10）（利用继承实现MyStack）在程序清单11-10中，MyStack是用组合实现的。扩展ArrayList创建一个新的栈类。实现MyStack类。编写一个测试程序，提示用户输入5个字符串，然后以逆序显示这些字符串。

  3.1 程序代码：

  1. import java.util.Scanner;   
  2. public class MyStack extends java.util.ArrayList{ 
  3.       public MyStack(){ 
  5.       }
  7.       //实现获取栈的最后一个元素
  8.       public Object peek(){ 
  9.            return this.get(this.size()-1);
  10.       }
  12.       //创建栈的实例并把栈的最后一个元素传给实例对象，然后删除这个元素
  13.       public Object pop(){ 
  14.           Object o = this.get(this.size()-1);
  15.           this.remove(this.size() - 1);
  16.           return o;
  17.       }
  19.      //将这个实例对象放入一个新的栈中
  20.      public void push(Object o){ 
  21.         this.add(o);
  22.      }
  24.      //测试程序
  25.      @SuppressWarnings("unchecked")
  26.      public static void main(String[] args){ 
  27.         Scanner input = new Scanner(System.in);
  29.         System.out.println("请输入5个字符串: ");
  30.         MyStack mystack = new MyStack();
  31.         for(int i = 0; i < 5; i++) { 
  32.            String st = input.next();
  33.            mystack.push(st);
  34.         }
  36.         System.out.println("逆序输出为: ");
  37.         for(int i=0; i<5; i++)
  38.             System.out.print(mystack.pop() + " ");
  40.         System.out.println();
  41.         }//main方法结束
  43. }//MyStack类结束

  3.2 运行结果及分析：
Alt
  运行结果正确，输入5个字符串，利用MyStack逆序输出，但是编译时出现了一个小问题，不过不影响运行，具体说明见下。

  3.3 心得体会：
  本题利用继承关系，创建MyStack继承类，关键在于思路。想清楚继承类中需要书写的方法，其实就三个，取栈的最后一个元素、取栈的最后一个元素再删除、向栈里面添加元素。再就是这三个方法的书写，直接使用泛型，调用时采用类似this.get()的方式调用就好。
  本题遗留了一个小问题：
Alt
  程序编译显示以上错误，后经过检查是使用泛型时需要确定类型的问题，其中一种解决方法是添加注释：@SuppressWarnings(“unchecked”)
  但是，貌似由于版本问题，问题依旧存在。
  还有一个解决方法是泛型具体化，不过此方法在本题中不方便使用，所以问题暂未解决。

发表评论

表情：
评论列表 （有 0 条评论，397人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java面向对象多态

    1、 认识多态 （1）多态一词的通常含义是指能够呈现出多种不同的形式或形态。 （2）在程序设计的术语中，它意味着一个特定类型的变量可以引用不同类型的对象，并且自动地

    比眉伴天荒比眉伴天荒/ 0 赞/ 159 阅读

    相关 面向对象—多态

    面向对象—多态 定义 实现 原理 1、定义 > 多态可以简单的概括为“一个接口，多种方法”，在程序运行过程中才决定调用的函数，简单的说就是，允许

    我不是女神ヾ我不是女神ヾ/ 0 赞/ 286 阅读

    相关 面向对象多态

    多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在运行时，可以通过指向基类的指针，来调用实现派生类中的方法。 编译时的多态性： 编译时的多态性是通过重

    妖狐艹你老母妖狐艹你老母/ 0 赞/ 366 阅读

    相关 面向对象---多态

    多态： > 可以理解为事物存在的多种体现形态。 > 比如：人：男人，女人 多态的体现： > 父类的引用指向了自己的子类对象。 > > 父类的引用也可以接受自己的对象。

    蔚落蔚落/ 0 赞/ 511 阅读