达拉草201771010105《面向对象程序设计（java）》第七周学习总结
实验七继承附加实验
实验时间 2018-10-11
1、实验目的与要求
（1）进一步理解4个成员访问权限修饰符的用途；
（2）掌握Object类的常用API用法；
（3）掌握ArrayList类用法与常用API；
（4）掌握枚举类使用方法；
（5）结合本章知识，理解继承与多态性两个面向对象程序设计特征，并体会其优点；
（6）熟练掌握Java语言中基于类、继承技术构造程序的语法知识（ch1-ch5）；
（7）利用已掌握Java语言程序设计知识，学习设计开发含有1个主类、2个以上用户自定义类的应用程序。
如何使用ArrayList
最简单的例子：
ArrayList List = new ArrayList();
for( int i=0;i <10;i++ ) //给数组增加10个Int元素
List.Add(i);
//..程序做一些处理
List.RemoveAt(5);//将第6个元素移除
for( int i=0;i <3;i++ ) //再增加3个元素
List.Add(i+20);
Int32[] values = (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的数组
这是一个简单的例子，虽然没有包含ArrayList所有的方法，但是可以反映出ArrayList最常用的用法
ArrayList重要的方法和属性
1）构造器
ArrayList提供了三个构造器：
public ArrayList();
默认的构造器，将会以默认（16）的大小来初始化内部的数组
public ArrayList(ICollection);
用一个ICollection对象来构造，并将该集合的元素添加到ArrayList
public ArrayList(int);
用指定的大小来初始化内部的数组
object是类层次的根类，所有类的父（超）类
getClass()
public final native Class getClass();
返回该对象运行时的类的对象
例如 定义一个类Person ，创建一个Person对象， Person p= new Person（）；
此时调用p.getClass() 返回值即为Person类的对象即： Class c=p.getClass();
可通过方法获取该类的名称等信息：c.getName() ,结果为"Person"
此方法常用于反射
hashCode()
public native int hashCode();
返回当前对象的哈希值 本地方法
hashCode常规协定：
在java应用执行期间，对同一对象多次调用haseCode方法，必须返回相同的整数（前提：equals比较时信息没有被修改）
通过equals方法比较，两个对象相等，返回的值必须相同整数
通过equals方法比较，两个对象不同，不一定生成不同的整数，但是不同对象生成不同的整数可以提高哈希表的性能
equals(Object obj)
public boolean equals(Object obj) {
return (this == obj);
}
返回布尔值，表示其他对象是否与本对象相等
参数：Object类型
返回值：
特点：
自反性：对于任何非空引用值X，自己和自己比较即：X.equals(x)，结果都为true
对称性：对于任何非空引用值X和Y，当X.equals(Y)结果为true时，Y.equals(X)的结果一定为true
传递性：对于任何非空引用值X、Y和Z，当X.equals(Y)结果为true，Y.equals(Z)的结果为true时，X.equals(Z)的值一定为true
一致性：对于任何非空引用值X和Y，多次调用X.equals(Y)始终返回相同的值true或者false （前提equals对比的信息没有修改）
对于任何非空引用值X，X.equals(null) 的结果都为false
注意：
Object中对于任何非空引用值X和Y，当且仅当X和Y指向同一对象时，返回值为true
重写equals方法时建议要重写hashCode()方法以便维护haseCode的常规协定
2、实验内容和步骤
实验1 补充以下程序中主类内main方法体，以验证四种权限修饰符的用法。
| public class TEST1 { private String t1 = "这是TEST1的私有属性"; public String t2 = "这是TEST1的公有属性"; protected String t3 = "这是TEST1受保护的属性"; String t4 = "这是TEST1的默认属性"; private void tese1() { System.out.println("我是TEST1用private修饰符修饰的方法"); } public void tese2() { System.out.println("我是TEST1用public修饰符修饰的方法"); } protected void tese3() { System.out.println("我是TEST1用protected修饰符修饰的方法"); } void tese4() { System.out.println("我是TEST1无修饰符修饰的方法"); } } public class TEST2 extends TEST1{ private String e1 = "这是TEST2的私有属性"; public String e2 = "这是TEST2的公有属性"; protected String e3 = "这是TEST2受保护的属性"; String e4 = "这是TEST2的默认属性"; 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属性，结合程序运行结果理解继承和权限修饰符的用法与区别*/ } } |
实验代码补充如下：
1 public class TEST1 { 2 private String t1 = "这是TEST1的私有属性"; 3 public String t2 = "这是TEST1的公有属性"; 4 protected String t3 = "这是TEST1受保护的属性"; 5 String t4 = "这是TEST1的默认属性"; 6 private void tese1() { 7 System.out.println("我是TEST1用private修饰符修饰的方法"); 8 } 9 public void tese2() { 10 System.out.println("我是TEST1用public修饰符修饰的方法"); 11 } 12 protected void tese3() { 13 System.out.println("我是TEST1用protected修饰符修饰的方法"); 14 } 15 void tese4() { 16 System.out.println("我是TEST1无修饰符修饰的方法"); 17 } 18 }
1 public class TEST2 extends TEST1{ 2 private String e1 = "这是TEST2的私有属性"; 3 public String e2 = "这是TEST2的公有属性"; 4 protected String e3 = "这是TEST2受保护的属性"; 5 String e4 = "这是TEST2的默认属性"; 6 public void demo1() { 7 System.out.println("我是TEST2用public修饰符修饰的方法"); 8 } 9 private void demo2() { 10 System.out.println("我是TEST2用private修饰符修饰的方法"); 11 } 12 protected void demo3() { 13 System.out.println("我是TEST2用protected修饰符修饰的方法"); 14 } 15 void demo4() { 16 System.out.println("我是TEST2无修饰符修饰的方法"); 17 } 18 }
1 public class Main { 2 public static void main(String[] args) { 3 TEST2 test2 = new TEST2(); 4 /*以下设计代码分别调用 demo1 demo2 demo3 demo4 test1 test2 test3 test4方法和t1 t2 t3 t3 e1 e2 e3 e4属性，结合程序运行结果理解继承和权限修饰符的用法与区别*/ 5 test2.demo1(); 6 test2.demo3(); 7 test2.demo4(); 8 test2.tese2(); 9 test2.tese3(); 10 test2.tese4(); 11 System.out.println(test2.e2); 12 System.out.println(test2.e3); 13 System.out.println(test2.e4); 14 System.out.println(test2.t2); 15 System.out.println(test2.t3); 16 System.out.println(test2.t4); 17 } 18 }
实验结果如下：
实验2 第五章测试程序反思，继承知识总结。
测试程序1：
编辑、编译、调试运行教材程序5-8、5-9、5-10（教材174页-177页）；
结合程序运行结果，理解程序代码，掌握Object类的定义及用法；
代码如下：
EqualsTest类;
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); 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 }
Employee类:
1 package equals; 2 3 import java.time.*; 4 import java.util.Objects; 5 6 public class Employee 7 { 8 private String name;//private定义了一个只能在该类中访问的字符串变量 9 private double salary; 10 private LocalDate hireDay; 11 //创建私有属性 12 13 public Employee(String name, double salary, int year, int month, int day) 14 { 15 this.name = name; 16 this.salary = salary; 17 hireDay = LocalDate.of(year, month, day); 18 } 19 20 public String getName() 21 { 22 return name; 23 } 24 25 public double getSalary() 26 { 27 return salary; 28 } 29 30 public LocalDate getHireDay() 31 { 32 return hireDay; 33 } 34 //访问器 35 36 public void raiseSalary(double byPercent) 37 { 38 double raise = salary * byPercent / 100; 39 salary += raise; 40 } 41 42 public boolean equals(Object otherObject) 43 { 44 // 快速测试这些对象是否相同 45 if (this == otherObject) return true; 46 47 // 如果显示参数为空，必须返回flase 48 if (otherObject == null) return false; 49 50 // 如果几个类不匹配，则他们不相同 51 if (getClass() != otherObject.getClass()) return false; 52 53 // 其他对象为非空Employee类 54 Employee other = (Employee) otherObject; 55 56 // 测试是不是有相同值 57 return Objects.equals(name, other.name) && salary == other.salary && Objects.equals(hireDay, other.hireDay); 58 } 59 60 public int hashCode() 61 { 62 return Objects.hash(name, salary, hireDay); 63 } 64 65 public String toString()//把其他类型的数据转换为字符串类型的数据 66 { 67 return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay 68 + "]"; 69 } 70 }
Manager类：
1 package equals; 2 3 public class Manager extends Employee//扩展了一个子类Manager 4 { 5 private double bonus;//创建一个私有属性 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检查这个类和其他类是否属于同一个类 29 return bonus == other.bonus; 30 } 31 32 public int hashCode() 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.object是所有类的基类：Java中所有类（包括用户自己定义的类）都自动继承Object类，即Object类是所有类的父类。位于java.lang包中。
2.数组也是Object类的子类。
3.Object类的常用方法有：
toString();Object类的toString方法返回一个代表该对象域值的字符串。
equals();Object类中的equals方法用于测试某个对象是否同另一 个对象相等。它在Object类中的实现是判断两个对象是 否具有相同的引用。如果两个对象具有相同的引用，它 们一定是相等的。
hashCode();Object类中的hashCode方法导出某个对象的散列 码。散列码是任意整数，表示对象的存储地址。
测试程序2：
编辑、编译、调试运行教材程序5-11（教材182页）；
结合程序运行结果，理解程序代码，掌握ArrayList类的定义及用法；
代码如下：
ArrayListTest类：
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类填充staff数组列表 15 ArrayList<Employee> staff = new ArrayList<>();//构造了一个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 // raise everyone's salary by 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 }
Employee类：
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 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 35 public void raiseSalary(double byPercent) 36 { 37 double raise = salary * byPercent / 100; 38 salary += raise; 39 } 40 }
代码运行如下：
总结：
测试程序3：
编辑、编译、调试运行程序5-12（教材189页）；
结合运行结果，理解程序代码，掌握枚举类的定义及用法；
复制代码 package enums; 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//定义了枚举类 { 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未完成的测试内容。