实验目的与要求
（1）进一步理解4个成员访问权限修饰符的用途；
（2）掌握Object类的常用API用法；
（3）掌握ArrayList类用法与常用API；
（4）掌握枚举类使用方法；
（5）结合本章知识，理解继承与多态性两个面向对象程序设计特征，并体会其优点；
（6）熟练掌握Java语言中基于类、继承技术构造程序的语法知识（ch1-ch5）；
（7）利用已掌握Java语言程序设计知识，学习设计开发含有1个主类、2个以上用户自定义类的应用程序。
一：理论部分。
1.继承。
1）继承建立了类与类的关系，同时也是多态特征的前提。
java只支持单继承，不支持多继承（避免两个父类出现同名方法的调用选择困难）
“is-a”关系是继承的一个明显特征。
2）多态：在程序中同一符号在不同情况下有不同解释。
在Java中，子类数组的引用可以转换成超类数组的引用，而不需要采用强制类型转换。
3）final类和方法：final类不允许被继承（不能做父类）
String类是一个final类的例子（故该类不能被扩展）
父类可以直接引用子类，而子类不能直接父类（必须进行强制转换类型），。咋进行强制转换类型前，先检查是否能够成功转换，使用instanceof操作符实现。
super主要有两种用法：
1.super.成员变量/super.成员方法;
2.super(parameter1,parameter2....)
第一种用法主要用来在子类中调用父类的同名成员变量或者方法；第二种主要用在子类的构造器中显示地调用父类的构造器，要注意的是，如果是用在子类构造器中，则必须是子类构造器的第一个语句。
4）抽象类：一个类一定被定义成抽象类，他就是一个专职父类。不能实例化，即不能创建对象，只能产生子类。
5）受保护访问：如果希望超类的某些方法或域被子类访问，就需在给超类定义时，将这些方法或域声明为protected。
Java中用于控制可见性的4个访问修饰符：
1.仅对本类可见：private
2.对所有类可见：public
3.对本包和所有子类可见：protected
4.对本包可见：默认，不需要修饰符。
2.object类：所有类的超类。
1）equals方法：检测一个对象是否等于另外一个对象。如果两个对象具有相同的引用，那么他们一定相等。
2）equals方法具有以下特性：
自反性、对称性、传递性、一致性
3.hashCode方法（散列码）：由对象导出的一个整型值。
散列码可以是任意整数。两个相等的对象要求返回相等的散列码。
4.枚举类：比较两个枚举类型值是，不用equals，直接用“==”。所有枚举类都是Enum类的子类。其中toString方法能够返回枚举常量名。
每个枚举类都有一个静态values方法，它将返回一个包含全部枚举值的数组。
实验部分。
实验1
补充以下程序中主类内main方法体，以验证四种权限修饰符的用法。
public class Test1 {
public static final String e2 = null;
public static final String e3 = null;
public static final String e4 = null;
private String t1 = "这是TEST1的私有属性";
public String t2 = "这是TEST1的公有属性";
protected String t3 = "这是TEST1受保护的属性";
String t4 = "这是TEST1的默认属性";
private void test1() {
System.out.println("我是TEST1用private修饰符修饰的方法");
}
public void test2() {
System.out.println("我是TEST1用public修饰符修饰的方法");
}
protected void test3() {
System.out.println("我是TEST1用protected修饰符修饰的方法");
}
void test4() {
System.out.println("我是TEST1无修饰符修饰的方法");
}
}
public class Test2 extends Test1{
private String e1 = "这是TEST1的私有属性";
public String e2 = "这是TEST1的公有属性";
protected String e3 = "这是TEST1受保护的属性";
String e4 = "这是TEST1的默认属性";
public void demo1() {
System.out.println("我是TEST2用public修饰符修饰的方法");
}
private void demo2() {
System.out.println("我是TEST2用private修饰符修饰的方法");
}
protected void demo3() {
System.out.println("我是TEST2用protected修饰符修饰的方法");
}
void demo4() {
System.out.println("我是TEST2无修饰符修饰的方法");
}
}
public class Main {
public static void main(String[] args) {
Test2 test2 = new Test2();
/*在下面分别调用 demo1 demo2 demo3 demo4 test1 test2 test3 test4方法
和t1 t2 t3 t3 e1 e2 e3 e4属性，好好理解继承和权限修饰符的用法与区别*/
Test1 test3 = new Test2();
((Test2) test3).demo1();
((Test2) test3).demo3();
((Test2) test3).demo4();
test3.test2();
test3.test3();
test3.test4();
System.out.println(test3.t2);
System.out.println(test3.t3);
System.out.println(test3.t4);
}
}
第五章测试程序反思，继承知识总结。
测试程序1：
Ÿ 编辑、编译、调试运行教材程序5-8、5-9、5-10（教材174页-177页）；
Ÿ 结合程序运行结果，理解程序代码，掌握Object类的定义及用法；
程序如下：
EqualsTest类：
/**
* 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);//在子类中Bouns赋初值为空，主类中用更改器更改为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类：
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语句判断两个引用是否是同一个，如果是同一个，那么这两个对象肯定相等。
if (this == otherObject) return true;
//如果显式参数为空必须返回false
if (otherObject == null) return false;
//用getclass（）方法得到对象的类。如果几个类不匹配，则它们不相等
if (getClass() != otherObject.getClass()) return false;
//其他对象是非空Employee类
//在以上判断完成，再将得到的参数对象强制转换为该对象，考虑到父类引用子类的对象的出现，然后再判断对象的属性是否相同
Employee other = (Employee) otherObject;
//测试字段是否具有相同的值
return Objects.equals(name, other.name) && salary == other.salary && Objects.equals(hireDay, other.hireDay);
}
public int hashCode()//重写hashcode方法，使相等的两个对象获取的HashCode也相等
{
return Objects.hash(name, salary, hireDay);
}
public String toString()//把其他类型的数据转为字符串类型的数据（toString方法可以自动生成）
{
return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay
+ "]";
}
}
Manager类：
public class Manager extends Employee//子类：Manager类继承Employee类
{
private double bonus;//创建私有属性bouns
public Manager(String name, double salary, int year, int month, int day)
{
super(name, salary, year, month, day);//子类直接调用超类中已创建的属性
bonus = 0;//给bouns赋初值为空
}
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()//重写hashcode方法，使相等的两个对象获取的HashCode也相等
{
return java.util.Objects.hash(super.hashCode(), bonus);
}
public String toString()//把其他类型的数据转为字符串类型的数据（toString方法可以自动生成）
{
return super.toString() + "[bonus=" + bonus + "]";
}
}
实验结果：
测试程序2：
Ÿ 编辑、编译、调试运行教材程序5-11（教材182页）；
Ÿ 结合程序运行结果，理解程序代码，掌握ArrayList类的定义及用法；
程序如下：
ArrayListTest类：
import java.util.*;
/**
* This program demonstrates the ArrayList class.
* @version 1.11 2012-01-26
* @author Cay Horstmann
*/
public class ArrayListTest//主类
{
public static void main(String[] args)
{
//用三个Employee类填充staff数组列表
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);
//打印出所有Employee类的信息
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
+ e.getHireDay());
}
}
测试程序3：
编辑、编译、调试运行程序5-12（教材189页）；
结合运行结果，理解程序代码，掌握枚举类的定义及用法；
import java.util.*;
/**
* This program demonstrates enumerated types.
* @version 1.0 2004-05-24
* @author Cay Horstmann
*/
public class EnumTest//主类
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
System.out.print("Enter a size: (SMALL, MEDIUM, LARGE, EXTRA_LARGE) ");
String input = in.next().toUpperCase();//字符串转换为大写
Size size = Enum.valueOf(Size.class, input);
System.out.println("size=" + size);
System.out.println("abbreviation=" + size.getAbbreviation());
if (size == Size.EXTRA_LARGE)
System.out.println("Good job--you paid attention to the _.");
}
}
enum Size//枚举类型（都是enum的子类）
{
SMALL("S"), MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL");//传入参数
private Size(String abbreviation) { this.abbreviation = abbreviation; }
public String getAbbreviation() { return abbreviation; }
private String abbreviation;
}
实验3：采用个人账号登录https://pintia.cn/，完成《2018秋季西北师范大学面向对象程序设计（Java）（ch1-ch5）测试题2》，测试时间60分钟；
实验4: 课后完成实验3未完成的测试内容。
实验总结：进一步验证了继承有关的知识，在调试代码的过程中理解了Object中equals方法、hashCode方法、toString方法的用法，面向对象程序设计是由继承、多态、封装组成；通过实验一的验证中再一次理解了子类继承父以及受保护访问权限的具体使用过程；在几次实验当中找到自己许多不足点，自主编程能力太差对Java这门功课努力不够，程序错误太多，以后继续努力加油吧。