201871010135 张玉晶《面向对象程序设计（java）》第6-7周学习总结

201871010135 张玉晶《面向对象程序设计（java）》第6-7周学习总结

第一部分：总结第五章理论知识

一 .继承：

1.  继承：用已有的类来构建新类的一种机制。子类继承了父类的域和方法，同时也添加新的域和方法以适应新情况。

2.  类继承的格式：

class    新类名（子类）    extends      已有类名（父类,超类）

a)  子类的构造器不能直接访问超类的私有域，必须调用超类构造器，而且必须是第一条语句。   super();

b) 子类不能直接访问超类的私有域，必须和其它方法一样，使用公共接口。  super.方法名()；

c) 父类对象可以引用子类对象。

d) 多态性质。（在程序中同一个符号在不同情况下具有不同解释的想象）

e) 子类可增加父类的域的方法或覆盖，但不可以删除父类的任何方法及域。   方法覆盖只在不同的类中完成。

3.  继承层次：从一个超类扩展而来的类集合称为继承层次。

a）java 只支持单继承。（只有一个父类，可由多个子类）

b)  继承层次结构中，每个子类对象也可视作是超类对象，因此，可以将子类对象赋给超类变量。

4.  抽象类     abstract方法，只能声明，不能实现。

a)  包含一个或多个抽象方法的类本身必须被声明为抽象类；

b)  抽象方法充当着占位的角色，它们的具体实现在子类中；

c)  抽象类不能被实例化，既不能创建对象，只能产生子类。

5.  动态绑定   ：  又称为运行时绑定，即程序在运行时会自动选择调用哪个方法。

6.  阻止继承： final类的方法    不允许继承的类称为 final 类。

7.  强制类型转换  ： 把一个超类对象赋给一个子类变量，就必须进行强制类型转换。

8. 访问修饰符： public   private   protected  默认。

二 .  Object  :  所有类的超类

1.  equals   :  用于测试某个对象是否同另一个对象相等。

定义子类的equals 方法时，可调用超类的 equals 方法。   super.equals (otherObject）

2.   hashCode方法  ：   用于导出某个对象的散列码 —-表示对象的存储地址。两个相等对象的散列码相等。

3.   toString 方法 ： 用于返回一个代表该对象域值的字符串。 定义子类的toString方法时，可先调用超类的toString方法.    super.toString()

三.   泛型数组列表

1.  Java中 利用ArrayList类，可允许程序在运行时确定数组的大小。

2.  ArrayList 是一个采用类型参数的泛型类，为指定数组列表保存元素的对象类型，需要用一对<>将数组元素的对象名括起来加在后面； ArrayList<Employee> staff = new ArrayList<Employee>();

3.  数组列表的操作

a)  ArrayList 定义          ArrayList  <T> staff = new ArrayList<T>();            ArrayList<T>()构造一个空的数组列表

b) 添加新元素     API ： boolean  add(T  obj)   把元素obj 追加到数组列表的结尾

c) 统计个数     API : int size()  返回数组列表中当前元素的个数

d) 调整大小    API ：void trimToSize()   把数组列表的存储空间调整到当前大小

e)  访问    API ： void set(int index, T obj)    将obj放入数组列表index位置，将覆盖这个位置的原有内容。

API ： T  get (int   index) 获得指定位置index 的元素值

f)  增加与删除     API :  boolean  add(int index , T  obj)      向后移动元素，在第n个位置插入 obj

API :  T  remove (int index) ;      将第n个位置存放的对象删除，并将后面的元素向前移动

四.  对象包装器与自动打包

1.  所有基本数据类型都有着与之对应的预定义类，它们被称为对象包装器。

2.   Integer    Long  Float  Double  Short   Byte   Character    Void   Boolean  (前六个包装器类都是从公共包装器累Number继承而来

3.  对象包装器类是不可变的。对象包装器类还是final , 因此不能定义它们的子类。

4.  可以自动将基本数据类型转换为包装器类对象， 将这种变换称为自动打包。

5.  当对一个包装器类的对象进行赋值或算法运算时，将会自动拆包。

6.  打包和拆包是编译器认可的。

五.  枚举类

1.   声明枚举类      public   enum  Grade   {A , B , C ,  D , E }

a)  枚举类是一个类，它的隐含超类是  java. lang. Enum.

b) 枚举类并不是整数或其他类型，是被声明的枚举类的自身实例。

c) 枚举类不能有 public 修饰的构造函数，构造函数都是隐含private,编译器自动处理。

d) 枚举值隐含都是由 public , static, final 修饰的，无需自己添加这些修饰。

e) 比较两个枚举类型的值时，永远不要调用 equals 方法，直接使用“==”进行相等比较。

六.  继承设计的技巧

a)   将公共操作和域放在超类。

b)  不要使用受保护的域。

c)  使用继承实现”is-a”关系。

d)  除非所有继承的方法都有意义， 否则就不要使用继承。

e)  在覆盖方法时， 不要改变预期的行为。

f) 使用多态，而非类型信息。

第二部分：实验部分

1、实验目的与要求

(1) 理解继承的定义；

(2) 掌握子类的定义要求

(3) 掌握多态性的概念及用法；

(4) 掌握抽象类的定义及用途。

2、实验内容和步骤

实验1： 导入第5章示例程序，测试并进行代码注释。

测试程序1：

Ÿ 在elipse IDE中编辑、调试、运行程序5-1 —5-3（教材152页-153页） ；

Ÿ 掌握子类的定义及用法；

Ÿ 结合程序运行结果，理解并总结OO风格程序构造特点，理解Employee和Manager类的关系子类的用途，并在代码中添加注释；

Ÿ 删除程序中Manager类、ManagerTest类，背录删除类的程序代码，在代码录入中理解父类与子类的关系和使用特点。

5-1  ManagerTest.java

程序代码如下：

 /**
  * This program demonstrates inheritance.
  * @version 1.21 2004-02-21
  * @author Cay Horstmann
  */
 public class ManagerTest
 {
    public static void main(String[] args)
    {
       // construct a Manager object
       Manager boss = new Manager("Carl Cracker", , , , );  //创建了一个Manager类
       boss.setBonus();       Employee[] staff = new Employee[];  //定义了一个三个雇员的数组staff       // fill the staff array with Manager and Employee objects
        //用Manager和Employee对象对数组进行初始化
       staff[] = boss;
       staff[] = new Employee("Harry Hacker", , , , );
       staff[] = new Employee("Tommy Tester", , , , );       // print out information about all Employee objects
       for (Employee e : staff)  //利用了for each 循环语句,打印出关于Employee类的所有信息
          System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
    }
 }

运行结果如下：

5-2   Employee.java

程序代码如下：

 import java.time.*; public class Employee
 {
    private String name;
    private double salary;
    private LocalDate hireDay;    public Employee(String name, double salary, int year, int month, int day)
    {
       this.name = name;
       this.salary = salary;
       hireDay = LocalDate.of(year, month, day);
    }    public String getName()
    {
       return name;
    }    public double getSalary()
    {
       return salary;
    }    public LocalDate getHireDay()
    {
       return hireDay;
    }    public void raiseSalary(double byPercent)
    {
       double raise = salary * byPercent / ;
       salary += raise;
    }
 }

运行结果如下：

5-3  Manager.java

程序代码如下：

 public class Manager extends Employee  //利用extends关键字，用Employee类派生出Manager
 {
    private double bonus;    /**
     * @param name the employee's name
     * @param salary the salary
     * @param year the hire year
     * @param month the hire month
     * @param day the hire day
     */
    public Manager(String name, double salary, int year, int month, int day)
    {
       super(name, salary, year, month, day);    //利用super关键字，调用超类的构造器
       bonus = ;
    }    public double getSalary()
    {
       double baseSalary = super.getSalary();  //利用super关键字，调用超类的方法
       return baseSalary + bonus;
    }    public void setBonus(double b)
    {
       bonus = b;
    }
 }

运行结果如下：

测试程序2：

Ÿ 编辑、编译、调试运行教材PersonTest程序（教材163页-165页)；

Ÿ 掌握超类的定义及其使用要求；

Ÿ 掌握利用超类扩展子类的要求；

Ÿ 在程序中相关代码处添加新知识的注释；

Ÿ 删除程序中Person类、PersonTest类，背录删除类的程序代码，在代码录入中理解抽象类与子类的关系和使用特点。

5-4   PersonTest.java

程序代码如下：

 /**
  * This program demonstrates abstract classes.
  * @version 1.01 2004-02-21
  * @author Cay Horstmann
  */
 public class PersonTest
 {
    public static void main(String[] args)
    {
       Person[] people = new Person[];       //用Student和Employee类填充people这个数组
       people[] = new Employee("Harry Hacker", , , , );
       people[] = new Student("Maria Morris", "computer science");       //打印出所有Person类的姓名和描述
       for (Person p : people)
          System.out.println(p.getName() + ", " + p.getDescription());
    }
 }

运行结果如下：

5-5   Person.java

程序代码如下：

 public abstract class Person    //定义抽象类型Person
 {
    public abstract String getDescription();  //定义抽象描述
    private String name;    public Person(String name)
    {
       this.name = name;
    }    public String getName()
    {
       return name;
    }
 }

运行结果如下：

5-6   Employee.java

程序代码如下：

 import java.time.*; public class Employee extends Person   //子类Employee继承父类Person
 {
    private double salary;
    private LocalDate hireDay;    public Employee(String name, double salary, int year, int month, int day)
    {
       super(name);//调用父类构造器
       this.salary = salary;
       hireDay = LocalDate.of(year, month, day);  //hireDay使用LocalDate的方法
    }    public double getSalary()
    {
       return salary;
    }    public LocalDate getHireDay()
    {
       return hireDay;
    }    public String getDescription()
    {
       return String.format("an employee with a salary of $%.2f", salary);
    }    public void raiseSalary(double byPercent)
    {
       double raise = salary * byPercent / ;
       salary += raise;
    }
 }

运行结果如下：

5-7  Student.java

程序代码如下：

 public class Student extends Person   //子类Student继承父类Person
 {
    private String major;    /**
     * @param name the student's name
     * @param major the student's major
     */
    public Student(String name, String major)
    {
       // pass name to superclass constructor
       super(name);    //将name传递给父类的构造函数
       this.major = major;
    }    public String getDescription()
    {
       return "a student majoring in " + major;
    }
 }

运行结果如下：

测试程序3：

Ÿ 编辑、编译、调试运行教材程序5-8、5-9、5-10，结合程序运行结果理解程序（教材174页-177页）；

Ÿ 掌握Object类的定义及用法；

Ÿ 在程序中相关代码处添加新知识的注释。

5-8  Equals Test.java

程序代码如下：

 /**
  * This program demonstrates the equals method.
  * @version 1.12 2012-01-26
  * @author Cay Horstmann
  */
 public class EqualsTest
 {
    public static void main(String[] args)
    {
       Employee alice1 = new Employee("Alice Adams", , , , );
       Employee alice2 = alice1;
       Employee alice3 = new Employee("Alice Adams", , , , );
       Employee bob = new Employee("Bob Brandson", , , , );       System.out.println("alice1 == alice2: " + (alice1 == alice2));       System.out.println("alice1 == alice3: " + (alice1 == alice3));       System.out.println("alice1.equals(alice3): " + alice1.equals(alice3));       System.out.println("alice1.equals(bob): " + alice1.equals(bob));       System.out.println("bob.toString(): " + bob);       Manager carl = new Manager("Carl Cracker", , , , );
       Manager boss = new Manager("Carl Cracker", , , , );
       boss.setBonus();
       System.out.println("boss.toString(): " + boss);
       System.out.println("carl.equals(boss): " + carl.equals(boss));
       System.out.println("alice1.hashCode(): " + alice1.hashCode());
       System.out.println("alice3.hashCode(): " + alice3.hashCode());
       System.out.println("bob.hashCode(): " + bob.hashCode());
       System.out.println("carl.hashCode(): " + carl.hashCode());
    }
 }

运行结果如下：

5-9  Employee.java

程序代码如下：

 import java.time.*;
 import java.util.Objects; public class Employee
 {
    private String name;
    private double salary;
    private LocalDate hireDay;    public Employee(String name, double salary, int year, int month, int day)
    {
       this.name = name;
       this.salary = salary;
       hireDay = LocalDate.of(year, month, day);
    }    public String getName()
    {
       return name;
    }    public double getSalary()
    {
       return salary;
    }    public LocalDate getHireDay()
    {
       return hireDay;
    }    public void raiseSalary(double byPercent)
    {
       double raise = salary * byPercent / ;
       salary += raise;
    }    public boolean equals(Object otherObject)
    {
      //快速测试，看看这些对象是否相同
       if (this == otherObject) return true;       // 如果显示参数为空，则必须返回false
       if (otherObject == null) return false;       //如果类不匹配，它们就不能相等
       if (getClass() != otherObject.getClass()) return false;       // 现在我们知道 otherObject是一个非空雇员
       Employee other = (Employee) otherObject;       // 测试字段是否具有相同的值
       return Objects.equals(name, other.name)
          && salary == other.salary && Objects.equals(hireDay, other.hireDay);
    }    public int hashCode()  //
    {
       return Objects.hash(name, salary, hireDay);
    }    public String toString()
    {
       return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay="
          + hireDay + "]";
    }
 }

运行结果如下：

5-10  Manager.java

程序代码如下：

 public class Manager extends Employee //子类Employee继承父类Manager
 {
    private double bonus;    public Manager(String name, double salary, int year, int month, int day)
    {
       super(name, salary, year, month, day);  // //利用super关键字，调用超类的构造器
       bonus = ;
    }    public double getSalary()
    {
       double baseSalary = super.getSalary();
       return baseSalary + bonus;
    }    public void setBonus(double bonus)
    {
       this.bonus = bonus;
    }    public boolean equals(Object otherObject)
    {
       if (!super.equals(otherObject)) return false;
       Manager other = (Manager) otherObject;
       // super.equals 检查这个和其他属于同一类
       return bonus == other.bonus;
    }    public int hashCode()
    {
       return java.util.Objects.hash(super.hashCode(), bonus);
    }    public String toString()
    {
       return super.toString() + "[bonus=" + bonus + "]";
    }
 }

运行结果如下：

实验2：编程练习

Ÿ 定义抽象类Shape：

属性：不可变常量double PI，值为3.14；

方法：public double getPerimeter()；public double getArea())。

Ÿ 让Rectangle与Circle继承自Shape类。

Ÿ 编写double sumAllArea方法输出形状数组中的面积和和double sumAllPerimeter方法输出形状数组中的周长和。

Ÿ main方法中

1）输入整型值n，然后建立n个不同的形状。如果输入rect，则再输入长和宽。如果输入cir，则再输入半径。
2） 然后输出所有的形状的周长之和，面积之和。并将所有的形状信息以样例的格式输出。
3） 最后输出每个形状的类型与父类型，使用类似shape.getClass()(获得类型)，shape.getClass().getSuperclass()(获得父类型);

输入样例：

输出样例：

程序代码：

Test.java:

 import java.util.Scanner;
 public class Test {
  public static void main(String[] args) {
   Scanner in = new Scanner(System.in);
   System.out.println("个数");
   int a = in.nextInt();
   System.out.println("种类");
   String rect="rect";
   String cir="cir";
   Shape[] num = new Shape[a];
   for(int i=;i<a;i++){
    String input=in.next();
    if(input.equals(rect)) {
    System.out.println("长和宽");
    int length = in.nextInt();
    int width = in.nextInt();
          num[i]=new Rectangle(width,length);
          System.out.println("Rectangle["+"length:"+length+"  width:"+width+"]");
          }
    if(input.equals(cir)) {
          System.out.println("半径");
       int radius = in.nextInt();
       num[i]=new Circle(radius);
       System.out.println("Circle["+"radius:"+radius+"]");
          }
          }
          Test c=new Test();
          System.out.println("求和");
          System.out.println(c.sumAllPerimeter(num));
          System.out.println(c.sumAllArea(num));          for(Shape s:num) {
              System.out.println(s.getClass()+","+s.getClass().getSuperclass());
              }
          }            public double sumAllArea(Shape score[])
            {
            double sum=;
            for(int i=;i<score.length;i++)
                sum+= score[i].getArea();
                return sum;
            }
            public double sumAllPerimeter(Shape score[])
            {
            double sum=;
            for(int i=;i<score.length;i++)
                sum+= score[i].getPerimeter();
                return sum;
            }
 }

shape.java：

 abstract class Shape { //定义抽象父类Shape
 abstract double getPerimeter(); //定义求解周长的方法
 abstract double getArea(); //定义求解面积的方法
 } class Rectangle extends Shape{
 private int length;
 private int width;
 public Rectangle(int length, int width) {
     this.length = length;
     this.width = width;
 }
 //继承父类
 double getPerimeter(){ //调用父类求周长的方法
 return *(length+width);
 }
 double getArea(){
 return length*width; //调用父类求面积的方法
 }
 } class Circle extends Shape{
 private int radius;
 public Circle(int radius) {
     this.radius = radius;
 }
 double getPerimeter(){
 return  * Math.PI * radius;
 }
 double getArea(){
 return Math.PI * radius * radius;
 }
 }

运行结果：

实验总结：  在这一章中，我学到了“继承”这一重要部分，在继承中，用到了extends关键字，子类继承了父类的域和方法，同时也添加新的域和方法以适应新情况。子类的构造器不能直接访问超类的私有域，必须调用超类构造器，super();  子类不能直接访问超类的私有域，必须要用到，super.方法名（）；但是父类对象可以直接引用子类对象， 子类可以增加父类的域的方法或覆盖，但不可以删除父类的任何方法和域。Java只支持单继承，也就是只能有一个父类，但可以有多个子类。   Object类是所有类的超类，equals方法和toString方法比较重要，其中equals方法用于比较两个 对象是否相等。  在数组列表中，用到了ArrayList这个关键字，它是ArrayList <T> staff = new ArrayList<T>来定义的。  还有对象包装器与自动打包以及枚举类。

在实验中我遇到了很多困难，包括程序有些错误改不过来，有时候不知道错在了哪里，以及题目不太理解等情况。 在实验中有重复用到了extends关键字以及super的应用，所以因此也巩固了这一方面的理解， 通过向同学寻求帮助以及找资料搜索，解决了这些问题， 当然我自己也会在后期努力。