201871010134周英杰《面向对象程序设计（java）》第六到七周学习总结

201871010134-周英杰《面向对象程序设计（java）》第六到七周学习总结

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

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

第五章

1.类、超类和子类

5.2 Object：所有类的超类

5.3 泛型数组列表

5.4 对象包装器和自动打包

5.5 参数数量可变的方法

5.6 枚举类

5.7 继承设计的技巧

5.1 类、超类和子类

5.2 Object：所有类的超类

5.3 泛型数组列表

5.4 对象包装器和自动打包

5.5 参数数量可变的方法

5.6 枚举类

5.7 继承设计的技巧

1.继承（继承（inheritance））

 继承：用已有类来构建新类的一种机制。当定义了一个新类继承了一个类时，这个新类就继承了这个类的方法和域，同时在新类中添加新的方法和域以适应新的情况。

 继承是Java程序设计中的一项核心技术, 也是面向对象特征之一。

2.继承的特点

 a.具有层次结构 b.子类继承了父类的域和方法

3.继承的优点

 a.代码可重用性 b.父类的域和方法可用于子类设计应用程序变得更加简单 c.可以轻松定义子类

4.类、超类和子类

 a.类继承的格式:class 新类名 extends 已有类名 b.已有类称为：超类（superclass）、基类（base class）或父类（parent class）、基类（base class）.

–来自系统类库–用户自定义类

 c.新类称作：子类（subclass）、派生类（derivedclass）或孩子类（child class）、派生类（derived

class）或孩子类（child class）

 d.一般来说，子类比超类拥有的功能更加丰富。

注意：1.子类不能直接访问超类的私有域，必须和其他方法一样、子类不能直接访问超类的私有域，必须和其他方法一样——使用公有接口。使用公有接口。

2.通过扩展超类定义子类时，仅需要指出子类与超类的不同之处。在子类中可以增加域、增加方法或覆盖（override）超类的方法，但绝对不能删除超类的任何域和方法。

3.super是一个指示编译器调用超类方法的特有关键字，它不是一个对象的引用，不能将super赋给另一个对象变量。

super关键字一般有两个用途：一是调用超类的方法（格式：super.方法名（）），二是调用超类的构造公式（：super())。

4.若子类构造器没有显式地调用超类的构造器，则将自动地调用超类默认构造器。如果超类只定义了带参数的构造器，若子类构造器没有显式地调用超类的构造器，则Java编译器将报告错误。

 5. 继承层次

  从一个超类扩展而来的类集合称为继承层次(inheritance hierarchy)。在继承层次中，从某个类到其祖先的路径被称为该类的继承链(inheritance chain)，并且Java不支持多继承。

 6.多态性(polymorphism)

 a.多态性的概念（Polymorphism）

–多态性泛指在程序中同一个符号在不同的情况下具有不同解释的现象。

–超类中定义的域或方法，被子类继承之后，可以具有不同的数据类型或表现出不同的行为。

–这使得同一个域或方法在超类及其各个子类中具有不同的语义。

–超类中的方法在子类中可方法重写。

 注意子类数组和超类数组的关系。p155的警告！！！

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

5.1.3 动态绑定

 动态绑定的概念

–又称为运行时绑定。意思是说，程序在运行时会自动选择调用哪个方法。

–调用对象方法的执行过程

首先，编译器检查对象的声明类型和方法名，搜索相应类(Son) 及其父类(Father)的“方法表”，找出所有访问属性

为public 的method方法。方法。

接下来，编译器检查方法调用中提供的参数类型，找出一个完全匹配的方法，这个过程称为重载解析.

如果方法是private、static、final修饰的，或者是构造器，那么编译器能准确地判断应该调用哪个方法，这称为

静态绑定。

程序运行时，如果子类程序运行时，如果子类Son 中定义了 method() 的方法，则直接调用子类中的相应方法；则到其父类中寻找method()方法。

动态绑定中每次调用方法都要进行搜索，时间开销相当大。因此虚拟机预先为每个类创建了一个方法表，其中列出了所有方法的签名和实际调用的方法。

方法的名称和参数列表称为方法的签名。

.4 阻止继承：final类和方法

 不允许继承的类称为 final类，在类的定义中用final修饰符加以说明。

在类的定义中用final修饰符加以说明。

类中的方法可定义为final的。这时子类就不能覆盖该方法。

 如果一个类声明为final，属于它的方法会被自动设为final，但不包括域（如果域定义为final，在对象构造以

后，final域就不能再修改了）。

 String类是final类的一个例子。不能扩展该类。

5.1.5 强制类型转换

 如果要把一个超类对象赋给一个子类对象变量，就必须进

行强制类型转换。其格式为：子类对象＝（子类）（超类对象，就必须进行强制类型转换。其格式为：子类对象＝（子类）（超类对象）

 类型转换必须在继承层次内进行；而且在超类到子类转换

之前,应先使用 instanceof 操作符进行继承链检查。

abstract方法，只能声明，不能实现！

5.1.6 抽象类

 观察类的继承层次结构，位于上层的类更具通用性，甚至可能更加抽象。从某种角度看，祖先类更加通用，人们只

将它作为派生其他类的基类，而不作为特定的实例类。

•为了提高程序的清晰度，包含一个或多个抽象方法的类本身必须被声明为抽象类。除了抽象方法之外，抽象类还可以包含具体数据和具体方法。

•抽象方法充当着占位的角色，它们的具体实现在子类中。扩展抽象类可以有两种选择：一种是在子类中实现部分抽象方法，这样就必须将子类也标记为抽象类；另一种是实现全部抽象方法，这样子类就可以不是抽象类。此外，类即使不含抽象方法，也可以将类声明为抽象类。

•抽象类不能被实例化，即不能创建对象，只能产生类。可以创建抽象类的对象变量，只是这个变量必须指向它的非抽象子类的对象。

访问修饰符

private protected public 默认

 使用访问修饰符的原因：实现受限信息隐藏。

 信息隐藏目的：

–对类中任何实现细节的更改不会影响使用该类的代码

–防止用户意外删除数据

–易于使用

5.2 Object：所有类的超类

 Object类是Java中所有类的祖先——每一个类都由它扩展而来。在不给出超类的情况下，Java会自动把Object

作为要定义类的超类。

 可以使用类型为Object的变量指向任意类型的对象。但要对它们进行专门的操作都要进行类型转换。

5.4 对象包装器与自动打包

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

5.6 枚举类

a.声明枚举类

public enum Grade { A, B, C, D, E };

它包括一个关键字enum，一个新枚举类型的名字Grade以及为Grade定义的一组值，这里的值既非整型，亦非字符型。

5.6.1 声明枚举类

 枚举类说明

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

–枚举值并不是整数或其它类型，是被声明的枚举类的自身实例，例如A是Grade的一个实例。

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

5.7 继承设计的技巧

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

②不要使用受保护的域。

③使用继承实现“is-a”关系。

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

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

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

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

⑦不要过多地使用反射。

总结

 封装、继承和多态是面向对象的主要特征

 继承可提高代码的重用性，使用extends关键字来实现。除了构造方法之外，父类的所有方法和属性都被子类的对象继承.

 多态性是不同的实例对象以不同的方式对相同的信息作出不同的表现

 访问修饰符用于确定访问类成员的方式

 Java 常用修饰符有 static、final、abstract

第二部分：实验部分

 1、实验目的与要求

(1) 理解继承的定义；

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

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

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

(5) 掌握类中4个成员访问权限修饰符的用途；

(6) 掌握抽象类的定义方法及用途；

(7)掌握Object类的用途及常用API；

(8) 掌握ArrayList类的定义方法及用法；

(9) 掌握枚举类定义方法及用途。

2、实验内容和步骤

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

测试程序1：

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

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

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

　　

 1 package inheritance;
 2 
 3 /**
 4  * This program demonstrates inheritance.
 5  * @version 1.21 2004-02-21
 6  * @author Cay Horstmann
 7  */
 8 public class ManagerTest
 9 {
10    public static void main(String[] args)
11    {
12       // 构建管理者对象
13       Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
14       boss.setBonus(5000);
15 
16       Employee[] staff = new Employee[3];
17 
18       // 用管理者和雇员对象填充数组
19 
20       staff[0] = boss;
21       staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
22       staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);
23 
24       // 打印所有员工对象的信息
25       for (Employee e : staff)
26          System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
27    }
28 }

 1 package inheritance;
 2 
 3 import java.time.*;
 4 
 5 public class Employee
 6 {
 7    private String name;
 8    private double salary;
 9    private LocalDate hireDay;//构建三个public对象//
10 
11    public Employee(String name, double salary, int year, int month, int day)
12    {
13       this.name = name;
14       this.salary = salary;
15       hireDay = LocalDate.of(year, month, day);
16    }
17 
18    public String getName()
19    {
20       return name;
21    }
22 
23    public double getSalary()
24    {
25       return salary;
26    }
27 
28    public LocalDate getHireDay()
29    {
30       return hireDay;
31    }
32 
33    public void raiseSalary(double byPercent)
34    {
35       double raise = salary * byPercent / 100;
36       salary += raise;
37    }
38 }

 1 package inheritance;
 2 //关键字extends表示继承，表明正在构造一个新类派生于一个已经存在的类//
 3 public class Manager extends Employee
 4 {
 5    private double bonus;
 6 
 7    /**
 8     * @param name the employee's name
 9     * @param salary the salary
10     * @param year the hire year
11     * @param month the hire month
12     * @param day the hire day
13     */
14    public Manager(String name, double salary, int year, int month, int day)
15    {//调用超类中含有的参数的构造器。//
16       super(name, salary, year, month, day);
17       bonus = 0;
18    }
19 
20    public double getSalary()
21    {//子类要想访问超类中的方法用关键字super//
22       double baseSalary = super.getSalary();
23       return baseSalary + bonus;
24    }
25 
26    public void setBonus(double b)
27    {
28       bonus = b;
29    }
30 }

理解并总结OO风格程序构造特点，理解Employee和Manager类的关系子类的用途

对于面向对象风格程序构造特点，大体有四个，即：抽象、封装、继承、多态。

继承：简单理解就是代码复用，把重复使用的代码精简掉的一种手段。封装：就是把一部分或全部属性和部分功能（函数）对外界屏蔽。多态：没有继承就没有多态，继承是多态的前提。虽然继承自同一父类，但是相应的操作却各不相同，这叫多态。

Employee和Manager使用extends关键字完成继承关系。用父类进行声明,子类进行构造。

测试程序2：

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

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

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

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

 1 package abstractClasses;
 2 
 3 /**
 4  * This program demonstrates abstract classes.
 5  * @version 1.01 2004-02-21
 6  * @author Cay Horstmann
 7  */
 8 public class PersonTest//主类//
 9 {
10    public static void main(String[] args)
11    {
12       Person[] people = new Person[2];

//用Employee类和Student类填充people数组//

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

18 // print out names and descriptions of all Person objects

 //打印出所有person类的名字和其他描述//

 19 for (Person p : people) 

20 System.out.println(p.getName() + ", " + p.getDescription());
 21  } 

22 }

 1 package abstractClasses;
 2 
 3 public class Student extends Person//子类：student类继承person类//
 4 {
 5    private String major;//创建一个私有属性major//
 6 
 7    /**
 8     * @param nama the student's name
 9     * @param major the student's major
10     */
11    public Student(String name, String major)
12    {
13       // 将n传递给超类构造函数//
14       super(name);//子类直接调用超类中的name属性//
15       this.major = major;
16    }
17 
18    public String getDescription()//访问器//
19    {
20       return "a student majoring in " + major;
21    }
22 }

package abstractClasses;

public abstract class Person//抽象类person//
{
   public abstract String getDescription();
   private String name;//创建一个私有属性//

   public Person(String name)//构造器//
   {
      this.name = name;
   }

   public String getName()//访问器//
   {
      return name;
   }
}

 1 package abstractClasses;
 2 
 3 import java.time.*;
 4 
 5 public class Employee extends Person//子类：employee类继承person类//
 6 {
 7    private double salary;
 8    private LocalDate hireDay;//构建两个私有属性//
 9 
10    public Employee(String name, double salary, int year, int month, int day)
11    {
12       super(name);//子类不再重新定义，直接调用超类中的name//
13       this.salary = salary;
14       hireDay = LocalDate.of(year, month, day);
15    }
16 
17    public double getSalary()
18    {
19       return salary;
20    }
21 
22    public LocalDate getHireDay()
23    {
24       return hireDay;
25    }
26 
27    public String getDescription()
28    {
29       return String.format("an employee with a salary of $%.2f", salary);
30    }
31 
32    public void raiseSalary(double byPercent)
33    {
34       double raise = salary * byPercent / 100;
35       salary += raise;
36    }//定义两个局部变量//
37 }

测试程序3：

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

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

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

 1 package equals;
 2 
 3 /**
 4  * This program demonstrates the equals method.
 5  * @version 1.12 2012-01-26
 6  * @author Cay Horstmann
 7  */
 8 public class EqualsTest
 9 {
10    public static void main(String[] args)
11    {
12       Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15);
13       Employee alice2 = alice1;
14       Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15);
15       Employee bob = new Employee("Bob Brandson", 50000, 1989, 10, 1);
16 
17       System.out.println("alice1 == alice2: " + (alice1 == alice2));
18 
19       System.out.println("alice1 == alice3: " + (alice1 == alice3));
20 
21       System.out.println("alice1.equals(alice3): " + alice1.equals(alice3));
22 
23       System.out.println("alice1.equals(bob): " + alice1.equals(bob));
24 
25       System.out.println("bob.toString(): " + bob);
26 
27       Manager carl = new Manager("Carl Cracker", 80000, 1987, 12, 15);
28       Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
29       boss.setBonus(5000);//子类中赋初值为空，主类中用更改器更改为5000//
30       System.out.println("boss.toString(): " + boss);
31       System.out.println("carl.equals(boss): " + carl.equals(boss));
32       System.out.println("alice1.hashCode(): " + alice1.hashCode());
33       System.out.println("alice3.hashCode(): " + alice3.hashCode());
34       System.out.println("bob.hashCode(): " + bob.hashCode());
35       System.out.println("carl.hashCode(): " + carl.hashCode());
36    }
37 }

 1 package equals;
 2 
 3 public class Manager extends Employee//Manger类继承employee类//
 4 {
 5    private double bonus;//创建私有属性bonnus//
 6 
 7    public Manager(String name, double salary, int year, int month, int day)
 8    {
 9       super(name, salary, year, month, day);//子类直接调用超类中已经创建的属性//
10       bonus = 0;
11    }
12 
13    public double getSalary()
14    {
15       double baseSalary = super.getSalary();
16       return baseSalary + bonus;
17    }
18 
19    public void setBonus(double bonus)
20    {
21       this.bonus = bonus;
22    }
23 
24    public boolean equals(Object otherObject)//测试是否是同一个超类//
25    {
26       if (!super.equals(otherObject)) return false;
27       Manager other = (Manager) otherObject;
28       // super.equals checked that this and other belong to the same class
29       return bonus == other.bonus;
30    }
31 
32    public int hashCode()//重写hashcode方法，让相等的两个对象获取的hascode也相等//
33    {
34       return java.util.Objects.hash(super.hashCode(), bonus);
35    }
36 
37    public String toString()//把其他类型的数据转换为字符串类型的数据//
38    {
39       return super.toString() + "[bonus=" + bonus + "]";
40    }
41 }

 1 package equals;
 2 
 3 import java.time.*;
 4 import java.util.Objects;
 5 
 6 public class Employee
 7 {
 8    private String name;
 9    private double salary;
10    private LocalDate hireDay;//创建三个私有属性//
11 
12    public Employee(String name, double salary, int year, int month, int day)
13    {
14       this.name = name;
15       this.salary = salary;
16       hireDay = LocalDate.of(year, month, day);
17    }
18 
19    public String getName()
20    {
21       return name;
22    }
23 
24    public double getSalary()
25    {
26       return salary;
27    }
28 
29    public LocalDate getHireDay()
30    {
31       return hireDay;
32    }
33 
34    public void raiseSalary(double byPercent)
35    {
36       double raise = salary * byPercent / 100;
37       salary += raise;//定义两个局部变量//
38    }
39 
40    public boolean equals(Object otherObject)
41    {
42       // 测试是否是同一个超类//
43       if (this == otherObject) return true;
44 
45       // 显示参数为空，返回faulse//
46       if (otherObject == null) return false;
47 
48       // 类不匹配，则不相等//
49       if (getClass() != otherObject.getClass()) return false;
50 
51       // 其他对象是非空employee类//
52       Employee other = (Employee) otherObject;
53 
54       // 测试是否具有相同的值//
55       return Objects.equals(name, other.name) && salary == other.salary && Objects.equals(hireDay, other.hireDay);
56    }
57 
58    public int hashCode()
59    {
60       return Objects.hash(name, salary, hireDay); 
61    }
62 
63    public String toString()
64    {
65       return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay
66             + "]";
67    }
68 }

测试程序4：

Ÿ   在elipse IDE中调试运行程序5-11（教材182页），结合程序运行结果理解程序；

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

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

 1 package arrayList;
 2 
 3 import java.util.*;
 4 
 5 /**
 6  * This program demonstrates the ArrayList class.
 7  * @version 1.11 2012-01-26
 8  * @author Cay Horstmann
 9  */
10 public class ArrayListTest
11 {
12    public static void main(String[] args)
13    {
14       // 用三个employee类填充数组//
15       ArrayList<Employee> staff = new ArrayList<>();
16 
17       staff.add(new Employee("Carl Cracker", 75000, 1987, 12, 15));
18       staff.add(new Employee("Harry Hacker", 50000, 1989, 10, 1));
19       staff.add(new Employee("Tony Tester", 40000, 1990, 3, 15));
20 
21       // 将每个人的薪水提高5%//
22       for (Employee e : staff)
23          e.raiseSalary(5);
24 
25       // 打印所有employee的信息//
26       for (Employee e : staff)
27          System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
28                + e.getHireDay());
29    }
30 }

 1 package arrayList;
 2 
 3 import java.time.*;
 4 
 5 public class Employee
 6 {
 7    private String name;
 8    private double salary;
 9    private LocalDate hireDay;
10 
11    public Employee(String name, double salary, int year, int month, int day)
12    {
13       this.name = name;
14       this.salary = salary;
15       hireDay = LocalDate.of(year, month, day);
16    }
17 
18    public String getName()
19    {
20       return name;
21    }
22 
23    public double getSalary()
24    {
25       return salary;
26    }
27 
28    public LocalDate getHireDay()
29    {
30       return hireDay;
31    }
32 
33    public void raiseSalary(double byPercent)
34    {
35       double raise = salary * byPercent / 100;
36       salary += raise;
37    }//定义两个局部变量//
38 }

测试程序5：

Ÿ   编辑、编译、调试运行程序5-12（教材189页），结合运行结果理解程序；

Ÿ   掌握枚举类的定义及用法；

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

 1 package enums;
 2 
 3 import java.util.*;
 4 
 5 /**
 6  * This program demonstrates enumerated types.
 7  * @version 1.0 2004-05-24
 8  * @author Cay Horstmann
 9  */
10 public class EnumTest//主类//
11 {  
12    public static void main(String[] args)
13    {  
14       Scanner in = new Scanner(System.in);
15       System.out.print("Enter a size: (SMALL, MEDIUM, LARGE, EXTRA_LARGE) ");
16       String input = in.next().toUpperCase();//字符串转换为大写//
17       Size size = Enum.valueOf(Size.class, input);
18       System.out.println("size=" + size);
19       System.out.println("abbreviation=" + size.getAbbreviation());
20       if (size == Size.EXTRA_LARGE)
21          System.out.println("Good job--you paid attention to the _.");      
22    }
23 }
24 
25 enum Size//枚举类型（都是enum的子类）//
26 {
27    SMALL("S"), MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL");//传入参数//
28 
29    private Size(String abbreviation) { this.abbreviation = abbreviation; }
30    public String getAbbreviation() { return abbreviation; }
31 
32    private String abbreviation;
33 }

实验2：编程练习1

Ÿ   定义抽象类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()(获得父类型);

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

输入样例:

 1 3
 2 
 3 rect
 4 
 5 1 1
 6 
 7 rect
 8 
 9 2 2
10 
11 cir
12 
13 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

import java.util.Scanner;

public class Work
{

    public static void main(String[] args) 
    {
        Scanner in = new Scanner(System.in);
        String rect = "rect";
        String cir = "cir";
        System.out.print("请输入所需图形的形状个数:");
        int n = in.nextInt();
        shape[] count = new shape[n];
        for(int i=0;i<n;i++)
        {
            System.out.println("请输入图形形状：");
            String input = in.next();
            if(input.equals(rect))
            {
                double length = in.nextDouble();
                double width = in.nextDouble();
                System.out.println("长方形："+"长:"+length+"  宽:"+width);
                count[i] = new Rect(length,width);
            }
            if(input.equals(cir)) 
            {
                double radius = in.nextDouble();
                System.out.println("圆："+"半径:"+radius);
                count[i] = new Cir(radius);
            }
        }
        Work c = new Work();
        System.out.println(c.sumAllPerimeter(count));
        System.out.println(c.sumAllArea(count));
        for(shape s:count) 
        {

            System.out.println(s.getClass()+",  "+s.getClass().getSuperclass());
        }
    }

public double sumAllArea(shape count[])
    {
         double sum = 0;
         for(int i = 0;i<count.length;i++)
             sum+= count[i].getArea();
         return sum;
    }
    
    public double sumAllPerimeter(shape count[])
    {
         double sum = 0;
         for(int i = 0;i<count.length;i++)
             sum+= count[i].getPerimeter();
         return sum;
    }
    
}

1 public abstract class shape
2  {
3      double PI = 3.14;
4      public abstract double  getPerimeter();
5      public abstract double  getArea();
6  }

public class Rect extends shape
{
    private double width;
    private double length;
    public Rect(double w,double l)
    {
        this.width = w;
        this.length = l;
    }
    public double getPerimeter()
    {
        double Perimeter = 2*(length+width);
        return Perimeter;
    }
    public double getArea()
    {
        double Area = length*width;
        return Area;
    }
}

 1 public class Cir extends shape
 2 {
 3     private double radius;
 4  
 5     public Cir(double radius2) {
 6         // TODO Auto-generated constructor stub
 7     }
 8     public double getPerimeter()
 9     {
10         double Perimeter=2*PI*radius;
11         return Perimeter;
12     }
13     public double getArea()
14     {
15         double Area=PI*radius*radius;
16         return Area;
17     }
18 }

结果

总结：

在这周的学习中，我学会了面向对象的特征之一继承的相关知识。在后面的两个实验中，我了解了在父类下定义子类的方法程序以及其中的注意点，比如子类会继承父类的所有方法和域，我体会到继承的优点，它可以轻松定义子类，使得设计应用程序更加简单。前面的实验要求进行注解，通过这种方式，感觉读代码理解更深，不过掌握的英语知识太少，以后应该加强学习。