实验六 继承定义与使用
实验时间 2018-9-28
1、实验目的与要求
(1) 继承的定义：用已有类来构建新类的一种机制。当定义了一个新类继承了一个类时，这个新类就继承了这个类的方法和域，同时在新类中添加新的方法和域以适应新的情况。
继承是java程序设计中的一项核心技术，也是面向对象特征之一。
继承具有层次结构，及子类继承父类的域和方法。
（2）Super关键字有两个用途，一是调用超类的方法（super.方法名（）），二是调用超类的构造
（super.()）; 继承层次：从一个超类扩展而来的类集合；继承链：在继承层次中，从某个类个类到其祖先的路径； Java不支持多继承。
B:多态性：泛指在程序中同一个符号在不同的情况下具有不同解释的现象；
阻止继承：final类和方法：不允许继承的类成为Final类，在类的定义中用修饰符加以说明；
类中的方法可定义子类，这时不能覆盖方法； String类是final类的一个例子。
抽象类：包含一个或多个抽象方法的类本身必须被声明为抽象类； 抽象方法充当着占位的角色，他们的具体实现在子类中 ； 抽象不能被实例化，即不能创建对象，只能产生子类。
D:访问修饰符：private：只有该类可以访问，public：该类或非该类均可访问，protected:该类及其子类可以访问，同一个包中的类也可以访问。(注：不写访问修饰符时默认为friendly)
（3）
多态性泛指在程序中同一个符号在不同的情况 下具有不同解释的现象。
–超类中定义的域或方法，被子类继承之后，可 以具有不同的数据类型或表现出不同的行为。
–这使得同一个域或方法在超类及其各个子类中 具有不同的语义。
–超类中的方法在子类中可方法重写。
(4) 掌握抽象类的定义及用途；
为了提高程序的清晰度，包含一个或多个抽象方法 的类本身必须被声明为抽象类。除了抽象方法之外 ，抽象类还可以包含具体数据和具体方法。
抽象方法充当着占位的角色，它们的具体实现在子 类中。扩展抽象类可以有两种选择：一种是在子类 中实现部分抽象方法，这样就必须将子类也标记为 抽象类；另一种是实现全部抽象方法，这样子类就 可以不是抽象类。
此外，类即使不含抽象方法，也 可以将类声明为抽象类。 ?抽象类不能被实例化，即不能创建对象，只能产生 子类。可以创建抽象类的对象变量，只是这个变量 必须指向它的非抽象子类的对象。
(5) 掌握类中4个成员访问权限修饰符的用途；
使用访问修饰符的原因：实现受限信息隐藏。 l
信息隐藏目的：
–对类中任何实现细节的更改不会影响使用该类的代码
–防止用户意外删除数据
–易于使用类
注：不写访问修饰符时默认为friendly
掌握枚举类定义方法及用途。
a.声明枚举类 publicenumGrade{A,B,C,D,E}; l
它包括一个关键字enum，一个新枚举类型的名字 Grade以及为Grade定义的一组值，这里的值既 非整型，亦非字符型。
b.枚举类说明:
–枚举类是一个类，它的隐含超类是java.lang.Enum。
–枚举值并不是整数或其它类型，是被声明的枚举类的 自身实例，例如A是Grade的一个实例。
–枚举类不能有public修饰的构造函数，构造函数都是 隐含private，编译器自动处理。
–枚举值隐含都是由public、static、final修饰的，无 须自己添加这些修饰符。
–在比较两个枚举类型的值时，永远不需要调用equals 方法，直接使用"=="进行相等比较
（6） 继承设计的技巧
①将公共操作和域放在超类。
②不要使用受保护的域。
③使用继承实现“is-a”关系。
④除非所有继承的方法都有意义，否则就不要使用继承。
除非所有继承的方法都有意义，否则就不要使用继承。
⑤在覆盖方法时，不要改变预期的行为。
⑥使用多态，而非类型信息。
⑦不要过多地使用反射。
总结
l 封装、继承和多态是面向对象的主要特征
l 继承可提高代码的重用性，使用extends关键字来实现。除了构造方法之外，父类的所有方法和属性都被子类的对象继承.
l 多态性是不同的实例对象以不同的方式对相同的信息作出不同的表现
l 访问修饰符用于确定访问类成员的方式
l Java 常用修饰符有 static、final、abstract
2、实验内容和步骤
实验1： 导入第5章示例程序，测试并进行代码注释。
测试程序1：
? 在elipse IDE中编辑、调试、运行程序5-1 （教材152页-153页） ；
? 掌握子类的定义及用法；
? 结合程序运行结果，理解并总结OO风格程序构造特点，理解Employee和Manager类的关系子类的用途，并在代码中添加注释。
实验结果：
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
Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);//生成Manger类对象，对象名为boss
boss.setBonus(5000);
Employee[] 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：
? 编辑、编译、调试运行教材PersonTest程序（教材163页-165页)；
? 掌握超类的定义及其使用要求；
? 掌握利用超类扩展子类的要求；
? 在程序中相关代码处添加新知识的注释。
实验结果：
测试程序3：
? 编辑、编译、调试运行教材程序5-8、5-9、5-10，结合程序运行结果理解程序（教材174页-177页）；
? 掌握Object类的定义及用法；
? 在程序中相关代码处添加新知识的注释。
实验代码：
EqualsTest.java:
package equals;
/** *这个程序演示了等值方法 * @version 1.12 2018-10-7 * @author 常惠琢 */ //实现了Employee类和Manager类的equals、hashCode和toString方法 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.java:
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) { // 快速测试以查看对象是否相同 if (this == otherObject) return true;
// 如果explicit的参数为null，必须返回false if (otherObject == null) return false;
// 如果类不匹配，那么他们不能相等 if (getClass() != otherObject.getClass()) return false;
// 现在我们知道otherObject是一个非null的Employee类 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 + "]"; } }
Manager.java:
package equals;
public class Manager extends 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; // Suff.Enter检查这个和其他属于同一个类。 return bonus == other.bonus; }
public int hashCode() { return java.util.Objects.hash(super.hashCode(), bonus); }
public String toString() { return super.toString() + "[bonus=" + bonus + "]"; } }
测试程序4：
? 在elipse IDE中调试运行程序5-11（教材182页），结合程序运行结果理解程序；
? 掌握ArrayList类的定义及用法；
? 在程序中相关代码处添加新知识的注释。
实验代码：
ArrayListTest.java:
package arrayList;
import java.util.*;
/** * 这个程序演示了ARAYLIST类 * @version 1.50 2018-10-7 * @author 常惠琢 */ public class ArrayListTest { public static void main(String[] args) { // 用三个雇员对象填充工作人员数组列表 ArrayList<Employee> staff = new ArrayList<>();
staff.add(new Employee("Carl Cracker", 75000, 1987, 12, 15)); staff.add(new Employee("Harry Hacker", 50000, 1989, 10, 1)); staff.add(new Employee("Tony Tester", 40000, 1990, 3, 15));
//把每个人的薪水提高5% for (Employee e : staff) e.raiseSalary(5);
// 打印所有员工对象的信息 for (Employee e : staff) System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay=" + e.getHireDay()); } }
Employee.java:
package arrayList;
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; } }
测试程序5：
? 编辑、编译、调试运行程序5-12（教材189页），结合运行结果理解程序；
? 掌握枚举类的定义及用法；
? 在程序中相关代码处添加新知识的注释。
实验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方法放在哪个类中更合适？
输入样例:
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
实验3： 编程练习2
编制一个程序，将身份证号.txt 中的信息读入到内存中，输入一个身份证号或姓名，查询显示查询对象的姓名、身份证号、年龄、性别和出生地。
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());
}
}
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Scanner;
public class Test{
private static ArrayList<Person> Personlist;
public static void main(String[] args) {
Personlist = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
File file = new File("E:\\WPS Office\\身份证号.txt");
try {
FileInputStream fis = new FileInputStream(file);
BufferedReader in = new BufferedReader(new InputStreamReader(fis));
String temp = null;
while ((temp = in.readLine()) != null) {
Scanner linescanner = new Scanner(temp);
linescanner.useDelimiter(" ");
String name = linescanner.next();
String ID = linescanner.next();
String sex = linescanner.next();
String age = linescanner.next();
String birthplace =linescanner.nextLine();
Person Person = new Person();
Person.setname(name);
Person.setID(ID);
Person.setsex(sex);
Person.setage(age);
Person.setbirthplace(birthplace);
Personlist.add(Person);
}
} catch (FileNotFoundException e) {
System.out.println("查找不到信息");
e.printStackTrace();
} catch (IOException e) {
System.out.println("信息读取有误");
e.printStackTrace();
}
boolean isTrue = true;
while (isTrue) {
System.out.println("1.按姓名查找");
System.out.println("2.按身份证号查找");
System.out.println("3.退出");
int nextInt = scanner.nextInt();
switch (nextInt) {
case 1:
System.out.println("请输入姓名：");
String Personname = scanner.next();
int nameint = findPersonByname(Personname);
if (nameint != -1) {
System.out.println("查找信息为：姓名:"
+ Personlist.get(nameint).getname() + " 身份证号:"
+ Personlist.get(nameint).getID() +" 年龄:"
+Personlist.get(nameint).getage() +" 性别:"
+Personlist.get(nameint).getsex()+" 出生地:"
+Personlist.get(nameint).getbirthplace()
);
} else {
System.out.println("此人不存在！");
}
break;
case 2:
System.out.println("请输入身份证号");
String PersonID = scanner.next();
int IDint = findPersonByID(PersonID);
if (IDint != -1) {
System.out.println("查找信息为：姓名:"
+ Personlist.get(IDint).getname() + " 身份证号:"
+ Personlist.get(IDint).getID() +" 年龄:"
+Personlist.get(IDint).getage() +" 性别:"
+Personlist.get(IDint).getsex()+" 出生地:"
+Personlist.get(IDint).getbirthplace()
);
} else {
System.out.println("此人不存在！");
}
break;
case 3:
isTrue = false;
System.out.println("退出程序!");
break;
default:
System.out.println("输入有误");
}
}
}
private static int findPersonByID(String personID) {
// TODO Auto-generated method stub
return 0;
}
private static int findPersonByname(String personname) {
return 0;
}
public static int findStudentByname(String name) {
int flag = -1;
int a[];
for (int i = 0; i < Personlist.size(); i++) {
if (Personlist.get(i).getname().equals(name)) {
flag= i;
}
}
return flag;
}
public static int findStudentByID(String ID) {
int flag = -1;
for (int i = 0; i < Personlist.size(); i++) {
if (Personlist.get(i).getID().equals(ID)) {
flag = i;
}
}
return flag;
}
}
实验总结：在第六周的学习中，对课本内容学习还不够，需要好好学习和应用。
原文地址：https://www.cnblogs.com/LZM7343/p/9750515.html