201871010105-曹玉中《面向对象程序设计（java）》第七周学习总结
| 项目 | 内容 |
| 这个作业属于哪个课程 | https://www.cnblogs.com/nwnu-daizh/ |
| 这个作业的要求在哪里 | https://www.cnblogs.com/nwnu-daizh/p/11605051.html |
| 作业学习目标 |
|
一：实验步骤
(1) 掌握四种访问权限修饰符的使用特点；
(2) 掌握Object类的用途及常用API；
(3) 掌握ArrayList类的定义方法及用法；
（4）掌握枚举类定义方法及用途；
（5）结合本章实验内容，理解继承与多态性两个面向对象程序设计特征，并体会其优点。
二、实验内容：
实验1： 在“System.out.println(...);”语句处按注释要求设计代码替换...，观察代码录入中IDE提示，以验证四种权限修饰符的用法。
代码如下：
class Parent {
private String p1 = "这是Parent的私有属性";
public String p2 = "这是Parent的公有属性";
protected String p3 = "这是Parent受保护的属性";
String p4 = "这是Parent的默认属性";
private void pMethod1() {
System.out.println("我是Parent用private修饰符修饰的方法");
}
public void pMethod2() {
System.out.println("我是Parent用public修饰符修饰的方法");
}
protected void pMethod3() {
System.out.println("我是Parent用protected修饰符修饰的方法");
}
void pMethod4() {
System.out.println("我是Parent无修饰符修饰的方法");
}
}
class Son extends Parent{
private String s1 = "这是Son的私有属性";
public String s2 = "这是Son的公有属性";
protected String s3 = "这是Son受保护的属性";
String s4 = "这是Son的默认属性";
public void sMethod1() {
System.out.println(p2);//分别尝试显示Parent类的p1、p2、p3、p4值
System.out.println("我是Son用public修饰符修饰的方法");
}
private void sMethod2() {
System.out.println("我是Son用private修饰符修饰的方法");
}
protected void sMethod3() {
System.out.println("我是Son用protected修饰符修饰的方法");
}
void sMethod4() {
System.out.println("我是Son无修饰符修饰的方法");
}
}
public class Demo {
public static void main(String[] args) {
Parent parent=new Parent();
Son son=new Son();
Parent pMethod3= new Son ();
((Son) pMethod3).sMethod1();
((Son) pMethod3).sMethod3();
((Son) pMethod3).sMethod4();
pMethod3.pMethod2();
pMethod3.pMethod3();
pMethod3.pMethod4();
System.out.println(pMethod3.p2);
System.out.println(pMethod3.p3);
System.out.println(pMethod3.p4);
}
}
运行结果如下：
实验2：导入第5章以下示例程序，测试并进行代码注释。
测试程序1：
1. 运行教材程序5-8、5-9、5-10，结合程序运行结果理解程序（教材174页-177页）；
5-8代码如下：
/**
* 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);//在子类中赋初值为空，主类中用更改器更改为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());
}
}
5-9代码如下：
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;
//如果显式参数为空必须返回false
if (otherObject == null) return false;
//如果几个类不匹配，则它们不相等
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()//把其他类型的数据转为字符串类型的数据
{
return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay
+ "]";
}
}
5-10代码如下：
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()//把其他类型的数据转为字符串类型的数据
{
return super.toString() + "[bonus=" + bonus + "]";
}
}
运行结果如下：
2. 删除程序中Employee类、Manager类中的equals()、hasCode()、toString()方法，背录删除方法，在代码录入中理解类中重写Object父类方法的技术要点。
Manager类代码如下：
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);
// TODO Auto-generated constructor stub
bonus = 0;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
@Override
public double getSalary() {
// TODO Auto-generated method stub
double baseSalary= super.getSalary();
return baseSalary+bonus;
}
@Override
public boolean equals(Object otherObject) {
// TODO Auto-generated method stub
if(!super.equals(otherObject)) return false;
Manager other=(Manager)otherObject;
return bonus==other.bonus;
}
@Override
public int hashCode() {
// TODO Auto-generated method stub
return super.hashCode()+17*new Double(bonus).hashCode();
}
@Override
public String toString() {
// TODO Auto-generated method stub
return super.toString()+"[bonus="+bonus+"]";
}
}
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;
}
@Override
public boolean equals(Object otherObject) {
// TODO Auto-generated method stub
if(this==otherObject) return true;
if(this==null) return false;
if(getClass() != otherObject.getClass()) return false;
Employee other=(Employee)otherObject;
return Objects.equals(name,other.name)&&salary == other.salary&&Objects.equals(hireDay,other.hireDay);
}
@Override
public int hashCode() {
// TODO Auto-generated method stub
return Objects.hash(name,salary,hireDay);
}
@Override
public String toString() {
// TODO Auto-generated method stub
return getClass().getName()+"[name="+name+",salary="+salary+",hireday="+hireDay+"]";
}
}
运行结果如下：
1）Object类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法在不明确给出超类的情况下，java会自动把object作为要定义类的超类。
2）可以使用类型为object的变量指向任意类型的对象。
3）object类有一个默认构造方法public object（），在构造子类时，都会先调用这个默认构造方法。
测试程序2：
1.在elipse IDE中调试运行程序5-11（教材182页），结合程序运行结果理解程序；
2. 掌握ArrayList类的定义及用法；
3.在程序中相关代码处添加新知识的注释；
代码如下：
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());
}
}
Employee类：
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;
}//定义两个局部变量
}
运行结果如下：
4. 设计适当的代码，测试ArrayList类的set()、get()、remove()、size()等方法的用法。
package arrayList;
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)
{
// fill the staff array list with three Employee objects
ArrayList<Employee> staff = new ArrayList<Employee>(); //声明和构造一个保存Employee对象的数组列表
staff.add(new Employee("Carl Cracker", 75000, 1987, 12, 15));//使用add方法将元素添加到数组列表中
staff.add(new Employee("Harry Hacker", 50000, 1989, 10, 1));
staff.add(new Employee("Tony Tester", 40000, 1990, 3, 15));
staff.remove(1); //从数组列表中删除元素
int n = staff.size();
System.out.println(n);
System.out.println(staff.get(0)!=staff.get(1));
// raise everyone's salary by 5%
for (Employee e : staff)
e.raiseSalary(5);
// print out information about all Employee objects
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
+ e.getHireDay());
}
}
运行结果如下：
ArrayList 即动态数组，它可以动态的增加和减少元素，灵活设置数组的大小。
ArrayList提供了三个构造器：
public ArrayList(); 默认的构造器
public ArrayList(ICollection);
public ArrayList(int); 用指定的大小来初始化内部的数组
测试程序3：
1. 编辑、编译、调试运行程序5-12（教材189页），结合运行结果理解程序；
2. 掌握枚举类的定义及用法；
3. 在程序中相关代码处添加新知识的注释；
代码如下：
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;
}
运行结果如下：
4.删除程序中Size枚举类，背录删除代码，在代码录入中掌握枚举类的定义要求。
代码如下：
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)
{
var 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); //静态方法valueOf
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; }
@Override
public String toString() {
// TODO Auto-generated method stub
return super.toString();
}
public String getAbbreviation() {
return abbreviation;
}
public void setAbbreviation(String abbreviation) {
this.abbreviation = abbreviation;
}
private String abbreviation;
}
运行结果如下：
创建枚举类型要使用 Enum 关键字，隐含了所创建的类型都是 java.lang.Enum 类的子类。
枚举类对象的属性不应允许被改动, 所以应该使用 private final 修饰。
枚举类的使用private final 修饰的属性应该在构造器中为其赋值。
若枚举类显式的定义了带参数的构造器,则在列出枚举值时也必须对应的传入参数。
测试程序4：录入以下代码，结合程序运行结果了解方法的可变参数用法
代码如下：
package cyz3;
public class TestVarArgus {
public static void dealArray(int... intArray){
for (int i : intArray)
System.out.print(i +" ");
System.out.println();
}
public static void main(String args[]){
dealArray();
dealArray(1);
dealArray(1, 2, 3);
}
}
运行结果如下：
可变参数用法适用于参数个数不确定，类型确定的情况，java把可变参数当做数组处理。
可变参数必须位于最后一项。当可变参数个数多余一个时，必将有一个不是最后一项，所以只支持有一个可变参数。
因为参数个数不定，所以当其后边还有相同类型参数时，java无法区分传入的参数属于前一个可变参数还是后边的参数，所以只能让可变参数位于最后一项。
实验:3：编程练习：参照输出样例补全程序，使程序输出结果与输出样例一致。
代码如下：
public class Demo { public static void main(String[] args) { Son son = new Son(); son.method(); } } class Parent { Parent() { System.out.println("Parent's Constructor without parameter"); } Parent(boolean b) { System.out.println("Parent's Constructor with a boolean parameter"); } public void method() { System.out.println("Parent's method()"); } } class Son extends Parent { Son(){ super(false); System.out.println("Son's Constructor without parameter"); System.out.println("Son's method()");
super.method(); } }
运行结果如下：
三：实验总结。
在前几周的学习基础上，这周又学习了第五章，相比之前，加深了对继承类、抽象类以及多态的学习。但对于后面学习的枚举类等新知识，在学习理论知识时，觉得已经基本掌握了。
但在实验过程中发现自己还是不会运用。在做测试题的时候，很多基础知识都不会，还是自己平时没有多看书，对基础知识掌握不到位。对于编程题，一方面是pta平台上只要出一点
格式错误程序就会显示错误，另外是自己的知识还不够，因此几乎不能完整的做出实验。在以后的学习中，我会多多pta平台上练习编程，来保证自己程序的严谨和准确性。