201871010101 陈来弟《面向对象程序设计（java）》第67周学习总结 201871010101

                                                                                                                     201871010101- 陈来弟《面向对象程序设计（java）》第6-7周学习总结

项目	内容
这个作业属于哪个课程	https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	https://www.cnblogs.com/nwnu-daizh/p/11605051.html
作业学习目标	1.深入理解程序设计中算法与程序的关系;                                  2.深入理解java程序设计中类与对象的关系;                                  3.理解OO程序设计的第2个特征：继承、多态;                                  4.学会采用继承定义类设计程序（重点、难点）;                                  5.能够分析与设计至少包含3个自定义类的程序;                                  6.掌握利用父类定义子类的语法规则及对象使用要求。

第一部分：理论部分

       在第五章中，分为了八小节，类、超类和子类，Object：所有类的超类，泛型数组列表，对象包装器与自动装箱，参数数量可变的方法，枚举类，反射，继承的设计技巧。在这些小节中，类、超类与子类这一节是最重要的，同时也是最难学的。

       继承：基于已存在的类构造一个新类，复用这些类的方法和域，还可以添加一些新的方法和域，以满足新的需求。

       反射：在程序运行期间发现更多的类及其属性的能力。主要是开发软件工具的人员，而不是编写应用程序的人员使用。（注：Java继承都为公有继承，而没有C++中的私有继承和保护继承。）

一、类、超类和子类

( 1 )继承后如果子类需要调用父类的方法，使用super关键字。如：super.getSalary();

      注：this和super比较：

       1> this是当前类对象的引用，可以在类的内部来访问自身的属性和方法。 super不是对象引用，只是一个指示编译器调用超类方法的特殊关键字。

       2>this的用途：一是引用隐式参数，二是调用该类的其它构造器。 super的用途：一是调用超类的方法，二是调用超类的构造器。

       3>调用构造器的语句只能作为另一个构造器的第一条语句出现。 构造参数既可以传递给本类（this）的其它构造器，也可以传递给超类（super）的构造器。

( 2 )多态：一个对象变量可以指示多种实际类型的现象称为多态。

         动态绑定：在运行时能够自动地选择调用哪个方法的现象称为动态绑定。注：

             a>is-a规则：判断子类的每个对象也是超类的对象。

             b>置换规则：程序中出现超类对象的任何地方都可以用子类对象置换。

             c>可以将子类对象引用赋给父类的对象变量，但是不能将父类对象的引用赋值给子类的对象变量。

( 3 )动态绑定流程：

1>编译器查看对象的声明类型和方法名。（本类中的同名方法和父类中访问属性为public的同名方法）

2>编译器查看调用方法提供的参数类型。

        如果在所有同名方法中存在一个与提供的参数类型完全匹配，就选中这个方法，这个过程称为重载解析。如果编译器没有找到与参数类型匹配的方法，或者发现经过类型转换后有多个方法与之匹配，就会报告一个错误。注：

       a>方法的名字和参数列表称为方法的签名。如果在子类中定义一个与超类签名相同的方法，那么子类中的方法将覆盖超类中方法签名相同的方法。不过返回类型不是签名的一部分，因此，在覆盖方法时，一定要保证返回类型的兼容性。允许子类将覆盖方法的返回类型定义为原返回类型的子类型。覆盖方法时，子类方法不能低于超类方法的可见性。

       b>每次调用方法都要进行搜索，时间开销相当大。因此，虚拟机预先为每个类创建了一个方法表，其中列出了所有方法的签名和实际调用的方法。这样在真正调用方法时，虚拟机仅查找这个表就行。如果需要查找父类的方法，需要查找父类的方法表。

       c>动态绑定的特性：无需对现存的代码进行修改，就可以对程序进行扩展。 ( 4 )静态绑定：如果是private方法、static方法、final方法或者构造器，那么编译器将可以准确地知道应该调用哪个方法，这种调用方式成为静态绑定。

( 5 )阻止继承：final类和方法

          1>不允许扩展的类被称为final类。

          2>域可以被声明为final，对于final域来说，构造对象之后不允许改变它们的值。

          3>如果将一个类声明为final，只有其中的方法自动地成为final，不包括域。

          4>在早期Java中，可以使用final关键字来避免动态绑定带来的系统开销。

( 6 )强制类型转换：将一个类型强制转换为另一个类型的过程。

         1>进行类型转换的唯一原因：在暂时忽视对象的实际类型之后，使用对象的全部功能。

         2>子类的引用赋给超类变量，编译器是允许的；但一个超类的引用赋给一个子类变量，必须进行类型转换，这样才能通过运行时检查。（良好的程序设计习惯：在进行类型转换之前，先查看一下是否能够成功地转换。）

( 7 )抽象类

       1>抽象类包含抽象方法、具体方法和具体数据。

       2>建议尽量将通用的域和方法（不管是否是抽象的）放在超类（不管是否是抽象类）中。

       3>抽象方法充当占位的角色，它们的具体实现在子类中。扩展抽象类可以有两种选择。一种是在子类中定义部分抽象方法或抽象方法也不定义，这样就必须将子类也标记为抽象类；另一种是定义全部的抽象方法，这样一来，子类就不是抽象的。

       4>抽象类不能被实例化，但是可以定义抽象类的对象变量，但是它只能引用非抽象子类的对象。

( 8 )Java可见性的4种访问修饰符：

       1>仅对本类可见------private

       2>对所有类可见------public

       3>对本包和所有子类可见-------protected

       4>对本包可见--------默认（很遗憾），不需要修饰符

二、Object

       Object类是所有类的超类，Java中每个类都是由它扩展而来，如果没有明确指出超类，默认超类为Object类。（注：在Java中，只有基本类型不是对象，例如，数值、字符和布尔类型的值不是对象。所有的数组类型，不管是对象数组还是基本类型的数组都扩展于Object类。）

( 1 )equals方法

       Object类中的equals方法用于检测一个对象是否等于另一个对象。

      1>在Object类中，这个方法将判断两个对象的引用是否相同。（Object中的equals方法采用的是==来比较内存是否相等）。注：在创建类时，可以重新定义equals方法，用于比较对象是否相等。（是数据内容而不仅仅是内存）

( 2 )hashCode方法

      1>散列码（hash code）是由对象导出的一个整型值。

      2>散列码是没有规律的。

      3>如果x和y是两个不同的对象，x.hashCode()与y.hashCode()基本上不会相同。

      4>由于hashCode方法定义在Object类中，因此每个对象都有一个默认的散列码，其值为对象的存储地址。

注：

      a>内容相同的字符串具有相同的散列码，因为字符串的散列码是由内容导出的。

      b>内容相同的字符串缓存（StringBuffer）却有不同的散列码，这是因为在StringBuffer类中没有定义hashCode方法，它的散列码是由Object类的默认hashCode方法导出的对象存储地址。

      c>如果重新定义equals方法，就必须重新定义hashCode方法，以便用户可以将对象插入到散列表中。

      d>hashCode方法应该返回一个整型数值（也可以是负数），并合理地组合实例域的散列码，以便能够让各个不同的对象产生的散列码更加均匀。

      5>在Java7做了两个改进。

a>首先，最好使用null安全的方法Objects.hashCode。如果参数为null，这个方法会返回0，否则返回对参数调用hashCode的结果。

b>还有更好的做法，需要组合多个散列值时，可以调用Objects.hash并提供多个参数。这个方法会对各个参数调用Objects.hashCode，并组合这些散列值。

      6>Equals与hashCode的定义必须一致：如果x.equals返回true，那么x.hashCode ()就必须与y.hashCode()具有相同的值。

( 3 )toString方法

        在Object中的方法，用于返回表示对象值的字符串。

1>定义toString方法的主要原因：只要对象与一个字符串通过字符串“+”连接起来，Java编译就会自动地调用toString方法，以便获得这个对象的字符串描述。

2>Object类定义了toString方法，用来打印输出对象所属的类名和散列码。

注：

       a>数组继承了object类的toString方法，数组类型将按照旧的格式打印。修正方式：调用静态方法Arrays.toString，如果想要打印多维数组则需要调用Arrays.deepToString方法。

       b>toString方法是一个非常有用的调试工具。在标准类库中，许多类都定义了toString方法，以便用户能够获得一些有关对象状态的必要信息。

       c>强烈建议为自定义的每一个类增加toString方法。这样做不仅自己受益，而且所有使用这个类的程序员也会从这个日志记录支持中受益匪浅

为了能够便于动态修改大小，可以使用ArrayList的类。它使用起来有点像数组，但在添加或删除元素时，具有自动调节数组容量的功能，而且不需要为此编写任何代码。

( 1 )ArrayList是一个采用类型参数的泛型类。为了指定数组列表保存的元素对象类型，需要用一对尖括号将类名括起来加在后面。

注：

1>声明和构造数组列表：ArrayList<Employee> staff = new ArrayList<Employee>();

    在Java7中，可以省去右边的类型参数(即为“菱形”语法)：ArrayList<Employee> staff = new ArrayList<>();

    原理：可以结合new操作符使用菱形语法。编译器会检查新值是什么。如果赋值给一个变量，或传递到某个方法，或者从某个方法返回，编译器会检查这个变量、参数或方法的泛型类型，然后将这个类型放在<>中。

2>数组列表管理着对象引用的一个内部数组。最终，数组的全部空间有可能被用尽。如果调用add且内部数组已经满了，数组列表就自动地创建一个更大的数组，并将所有的对象从较小的数组中拷贝到较大的数组中。

3>如果已经清楚或能够估计出数组可能存在的元素数量，就可以在填充数组之前调用ensureCapacity方法。这个方法调用将分配一个包含特定数量对象的内部数组。另外还可以把初始容量传递给ArrayList构造器:ArrayList<Employee> staff = new ArrayList<>(100);

4>数组列表分配与数组分配空间区别：数组分配存储空间后，数组就有相应数目的空位置可以使用，而数组列表只是拥有保存相应个元素的潜力（实际上，重新分配空间的话，将会超过这个数目），但是在最初，甚至完成初始化构造之后，数组列表根本就不含有任何元素。

5>size方法将返回数组列表中包含的实际元素数目。

6>一旦能够确认数组列表的大小不在发生变化，就可以调用trimToSize方法。这个方法将存储区域的大小调整为当前元素数量所需要的存储空间数目。垃圾回收器将回收多余的存储空间。

( 2 )访问数组列表元素

1>使用get和set方法实现访问或改变数组元素的操作，add方法为数组添加元素，set方法只能替换数组中已经存在的元素内容。

2>toArray方法将数组元素拷贝到一个数组中：X[] a = new X[ list.size() ]; list.toArray(a);

3>除了在数组列表的尾部追加元素之外，还可以在数组列表的中间插入元素，n之后的所有元素后移一个位置。如果数组列表的大小超过了容量，数组列表就会重新分配存储空间。删除中间元素，后面的元素前移一个位置，并且数组大小减1。 所以对数组进行插入和删除操作的效率比较低。

( 3 )类型化与原始数组列表的兼容性

       鉴于兼容性的考虑，编译器在对类型转换进行检查之后，如果没有发现违反规则的现象，就将所有的类型化数组列表转换成原始ArrayList对象。在程序运行时，所有的数组列表都是一样的，即没有虚拟机中的类型参数。

四、对象包装器与自动装箱

有时需要将int这样的基本类型转换为对象，所有的基本类型都有一个与之对应的类（包装器）。Integer、Long、Float、Double、Short、Byte、Character、Void、Boolean（前6个类派生于公共的超类Number）。

1>对象包装器类是不可变的，即一旦构造了包装器，就不允许更改包装在其中的值。对象包装器类是final，因此不能定义它们的子类。

注：

a>数组列表尖括号中的类型参数不允许为基本类型。

b>由于每个值分别包装在对象中，所以ArrayList<Integer>的效率远远低于int[]数组。因此，应该用它构造小型集合，这时操作的方便性比执行效率更加重要。

2>自动装箱：

Java SE5.0的改进之处是更加便于添加或获得数组元素。

list.add(3)将自动地变换成list.add(Integer.valueOf(3)),这种变换称为自动装箱。

3>自动拆箱：

将一个Integer对象赋给一个int值时，将会自动地拆箱。

例如：Integer n = 3; n++;

编译器将自动地插入一条对象拆箱的指令，然后进行自增计算，最后在将结果装箱。

注：

a>装箱和拆箱是编译器认可的，而不是虚拟机。编译器在生成类的字节码时，插入必要的方法调用。虚拟机只是执行这些字节码。

b>使用数值对象包装器好处，可以将某些基本方法放置在包装器中，如：int x = Integer.parseInt(s);

第二部分：实验部分

1、实验目的与要求

(1) 理解继承的定义；

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

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

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

2、实验内容和步骤

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

测试程序1：

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

2. 掌握子类的定义及用法；

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

实验5-1代码如下：

Employee ：

package inheritance;

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 / 100;
      salary += raise;
   }
}

Manager：

package inheritance;

public class Manager extends Employee
{
   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);
      bonus = 0;
   }

   public double getSalary()
   {
      double baseSalary = super.getSalary();
      return baseSalary + bonus;
   }

   public void setBonus(double b)
   {
      bonus = b;
   }
}

Manager  Test：

package inheritance;

/**
 * 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
      var boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
      boss.setBonus(5000);

      var staff = new Employee[3];

      // fill the staff array with Manager and Employee objects

      staff[0] = boss;
      staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
      staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);

      // print out information about all Employee objects
      for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
   }
}

运行结果如下：

测试程序2：

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

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

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

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

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

 实验5-2代码如下：

Employee：

package abstractClasses;

import java.time.*;

public class Employee extends 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);
   }

   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 / 100;
      salary += raise;
   }
}

Person：

package abstractClasses;

public abstract class Person
{
   public abstract String getDescription();
   private String name;

   public Person(String name)
   {
      this.name = name;
   }

   public String getName()
   {
      return name;
   }
}

Person Test：

package abstractClasses;

/**
 * This program demonstrates abstract classes.
 * @version 1.01 2004-02-21
 * @author Cay Horstmann
 */
public class PersonTest
{
   public static void main(String[] args)
   {
      var people = new Person[2];

      // fill the people array with Student and Employee objects
      people[0] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
      people[1] = new Student("Maria Morris", "computer science");

      // print out names and descriptions of all Person objects
      for (Person p : people)
         System.out.println(p.getName() + ", " + p.getDescription());
   }
}

Student：

package abstractClasses;

public class Student extends 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);
      this.major = major;
   }

   public String getDescription()
   {
      return "a student majoring in " + major;
   }
}

运行结果：

删除后override的代码：

//package abstractClasses;

import java.time.*;

public class Employee extends Person
{
   public Employee(String name, int i, int j, int k, int l) {
        super(name);
        // TODO Auto-generated constructor stub
    }
@Override
public String getDescription() {
    // TODO Auto-generated method stub
    return null;
}
@Override
public String getName() {
    // TODO Auto-generated method stub
    return super.getName();
}
   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);
   }

   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 / 100;
      salary += raise;
   }*/
}

测试程序3：

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

2.掌握Object类的定义及用法；

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

5-8示例程序：

Manager：

package equals;

public class Manager extends Employee//子类Manager继承父类Employee
{
   private double bonus;

   public Manager(String name, double salary, int year, int month, int day)
   {
      super(name, salary, year, month, day);
      bonus = 0;
   }

   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 + "]";
   }
}

EqualsTest：

package equals;

/**
 * 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", 75000, 1987, 12, 15);
      Employee alice2 = alice1;
      Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15);
      Employee bob = new Employee("Bob Brandson", 50000, 1989, 10, 1);

      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", 80000, 1987, 12, 15);
      Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
      boss.setBonus(5000);
      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());
   }
}

Employee：

//package equals;

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 / 100;
      salary += raise;
   }

   public boolean equals(Object otherObject) //Objects类中的equals方法用于检测一个对象是否等于另外一个对象
   {
      // a quick test to see if the objects are identical
      if (this == otherObject) return true;

      // must return false if the explicit parameter is null
      if (otherObject == null) return false;     //如果显示参数为空，则返回false

      // if the classes don't match, they can't be equal
      if (getClass() != otherObject.getClass()) return false;  //如果不是相同类型的对象，则返回false，getClass方法将返回一个对象所属的类

      // now we know otherObject is a non-null Employee
      var other = (Employee) otherObject;  

      // test whether the fields have identical values
      return Objects.equals(name, other.name) 
         && salary == other.salary && Objects.equals(hireDay, other.hireDay);
   }

   public int hashCode()
   {
      return Objects.hash(name, salary, hireDay);
    /*Objects.hash()  这个类用于操作对象的静态实用方法这些工具包括用于计算对象的哈希代码的空安全或空容错方法，返回一个对象的字符串，并比较两个对象
      Object类中的hashCode方法导出某个对象的散列码。散列码世人以整数，表示对象的存储地址
                 两个相等对象的散列码相等*/
   }

   public String toString() //方法返回一个代表该对象域值的字符串
   //toString
   {
      return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay=" 
         + hireDay + "]";
   }
}

运行结果：

实验2：编程练习

1.定义抽象类Shape：

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

3.方法：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()(获得父类型);

思考sumAllArea和sumAllPerimeter方法放在哪个类中更合适？

输入样例:

3

rect

1 1

rect

2 2

cir

1

 

输出样式：

18.28

8.14

[Rectangle [width=1, length=1], Rectangle [width=2, length=2], Circle [radius=1]]

class Rectangle,class Shape

class Rectangle,class Shape

class Circle,class Shape

 练习代码如下：

 1 import java.util.Scanner;
 2 public class Test {
 3  public static void main(String[] args) {
 4   Scanner in = new Scanner(System.in);
 5   System.out.println("个数");
 6   int a = in.nextInt();
 7   System.out.println("种类");
 8   String rect="rect";
 9   String cir="cir";
10   Shape[] num = new Shape[a];
11   for(int i=0;i<a;i++){
12    String input=in.next();
13    if(input.equals(rect)) {
14    System.out.println("长和宽");
15    int length = in.nextInt();
16    int width = in.nextInt();
17          num[i]=new Rectangle(width,length);
18          System.out.println("Rectangle["+"length:"+length+"  "+width+"]");
19          }
20    if(input.equals(cir)) {
21          System.out.println("半径");
22       int radius = in.nextInt();
23       num[i]=new Circle(radius);
24       System.out.println("Circle["+"radius:"+radius+"]");
25          }
26          }
27          Test c=new Test();
28          System.out.println("求和");
29          System.out.println(c.sumAllPerimeter(num));
30          System.out.println(c.sumAllArea(num));
31 
32          for(Shape s:num) {
33              System.out.println(s.getClass()+","+s.getClass().getSuperclass());
34              }
35          }
36 
37            public double sumAllArea(Shape score[])
38            {
39            double sum=0;
40            for(int i=0;i<score.length;i++)
41                sum+= score[i].getArea();
42                return sum;
43            }
44            public double sumAllPerimeter(Shape score[])
45            {
46            double sum=0;
47            for(int i=0;i<score.length;i++)
48                sum+= score[i].getPerimeter();
49                return sum;
50            }
51 }

package shape;

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 2*(length+width);
}
double getArea(){
return length*width; /*调用父类求面积的方法*/
}
}

class Circle extends Shape{
private int radius;
public Circle(int radius) {
    this.radius = radius;
}
double getPerimeter(){
return 2 * Math.PI * radius;
}
double getArea(){
return Math.PI * radius * radius;
}
}

运行结果：

实验总结：

        第五章内容中，第一小节很是难学，在此次实验操作时，导入的代码总是出错，经过我多次改正，还是有错，在同学的帮助下，我终于运行出了结果，在此过程中，我学到了在eclipse出错时，如何改正。并且在这章的学习中，了解到继承是什么，通过老师的讲解，知道了其的特点：  继承：基于已存在的类构造一个新类，复用这些类的方法和域，还可以添加一些新的方法和域，以满足新的需求。还有反射， 反射：在程序运行期间发现更多的类及其属性的能力。主要是开发软件工具的人员，而不是编写应用程序的人员使用。

        我相信，经过此次的学习，我对Java的了解会更深。