正文
马昕璐 201771010118《面向对象程序设计（java）》第六周学习总结
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
第一部分：理论知识学习部分
1. 继承
继承 ：用已有类来构建新类的一种机制。当定义了一个新类继承了一个类时，这个新类就继承了这个类的方法和域，同时在新类中添加新的方法和域以适应新的情况。
继承是Java程序设计中的一项核心技术, 也是面向对象特征
继承的特点 ：1.具有层次结构2.子类继承了父类的域和方法。
继承的优点 ：1.代码可用性2.父类的域和方法可用于子类3.设计应用程序变得更加简单4.可以轻松定义子类
2. 类、超类和子类
类继承的格式 ：
1.extends 已有类名
已有类称为：超类（superclass）、基类（base class）或父类（parent class）
2.class 新类名
新类称作：子类（subclass）、派生类（derived class）或孩子类（child class）
super 关键字一般有两个用途：
一是调用超类的方法（格式：super.方法名（））
二是调用超类的构造器(格式：super())
多态性的概念
多态性泛指在程序中同一个符号在不同的情况下具有不同解释的现象
超类中定义的域或方法，被子类继承之后，可以具有不同的数据类型或表现出不同的行为
超类中的方法在子类中可方法重写
不能把对超类的对象引用赋给子类对象变量
抽象类
定义一个抽象类：
abstract class Person
{
public abstract String getDescription( );
…...
}abstract方法，只能声明，不能实现
包含一个或多个抽象方法的类本身必须被声明为抽象类。除了抽象方法之外，抽象类还可以包含具体数据和具体方法
扩展抽象类可以有两种选择：一种是在子类中实现部分抽象方法，这样就必须将子类也标记为抽象类；另一种是实现全部抽象方法，这样子类就可以不是抽象类。此外，类即使不含抽象方法，也可以将类声明为抽象类。
抽象类不能被实例化，即不能创建对象，只能产生子类。可以创建抽象类的对象变量，只是这个变量必须指向它的非抽象子类的对象
Java 用于控制可见性的4个访问权限修饰符：1.private（只有该类可以访问） 2.protected（该类及其子类的成员可以访问，同一个包中的类也可访问） 3.public（该类或非该类均可） 4.默认（相同包中的类可以访问）
使用访问修饰符的原因：实现受限信息隐藏
信息隐藏目的：1. 对类中任何实现细节的更改不会影响使用该类的代码2. 防止用户意外删除数据.3. 易于使用类
3. Object ：所有类的超类
Object类是Java中所有类的祖先——每一个类都由它扩展而来。在不给出超类的情况下，Java会自动把Object作为要定义类的超类。
equals 方法，hashCode方法，toString方法
4. 泛型数组列表
利用ArrayList类，可允许程序在运行时确定数组的大小。
ArryList是一个采用类型参数的泛型类。
5. 枚举类
声明枚举类
public enum Grade { A, B, C, D, E };
枚举类是一个类，它的隐含超类是java.lang.Enum。枚举类不能有public修饰的构造函数，构造函数都是隐含private，编译器自动处理。
枚举值隐含都是由public、static、final修饰的，无须自己添加这些修饰符。
在比较两个枚举类型的值时，永远不需要调用 equals方法，直接使用"=="进行相等比较
第二部分：实验部分
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类的关系子类的用途，并在代码中添加注释。
package inheritance;
/**
* This program demonstrates inheritance.
* @version 1.21 2004-02-21
* @author Cay Horstmann
*/
public class ManagerTest//主方法
{
public static void main(String[] args)
{
// 构建一个Manager类对象boss
Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);//调用构造器
boss.setBonus(5000);//调用更改器，bonus改为5000
Employee[] staff = new Employee[3];//生成一个employee类对象数组
// 调用manager和employee类中对象将数据内容填入数组
staff[0] = boss;//父类对象变量可以引用子类变量
staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);//创建一个employee类对象
for (Employee e : staff)//输出所有employee类对象信息
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
}
}
package inheritance;
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;
}
}
package inheritance;
public class Manager extends Employee//Employee类里面定义一个manager子类
{
private double bonus;
/**
* @param name the employee's name
* @param salary the salary
* @param year the hire year
* @param month the hire month
* @param day the hire day
*/
public Manager(String name, double salary, int year, int month, int day)
/*定义一个构造器，其中包含name，salary，year，month，day五个参数*/
{
super(name, salary, year, month, day);//调用父类构造器
bonus = 0;
}
public double getSalary()
{
double baseSalary = super.getSalary();//调用父类的getsalary方法
return baseSalary + bonus;//总工资
}
public void setBonus(double b)
{
bonus = b;//更改器
}
}
程序运行结果如下：
测试程序2：
Ÿ 编辑、编译、调试运行教材PersonTest程序（教材163页-165页)；
Ÿ 掌握超类的定义及其使用要求；
Ÿ 掌握利用超类扩展子类的要求；
Ÿ 在程序中相关代码处添加新知识的注释。
package abstractClasses;
/**
* This program demonstrates abstract classes.
* @version 1.01 2004-02-21
* @author Cay Horstmann
*/
public class PersonTest//主方法
{
public static void main(String[] args)//抽象类的声明
{
Person[] people = new Person[2];//生成一个people类对象数组
//调用Student和employee类中对象将数据内容填入数组
people[0] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
people[1] = new Student("Maria Morris", "computer science");
// 打印所有人对象的名称和描述
for (Person p : people)
System.out.println(p.getName() + ", " + p.getDescription());
}
}
package abstractClasses;
public abstract class Person//父类
{
public abstract String getDescription();
private String name;
public Person(String name)//构造器
{
this.name = name;
}
public String getName()//访问器
{
return name;
}
}
package abstractClasses;
import java.time.*;
public class Employee extends Person//子类
{
private double salary;
private LocalDate hireDay;//定义两个私有变量
public Employee(String name, double salary, int year, int month, int day)//构造器
{
super(name);//调用父类构造器
this.salary = salary;//
hireDay = LocalDate.of(year, month, day);
}
public double getSalary()//实例域salary的访问器方法
{
return salary;
}
public LocalDate getHireDay()//实例域hireDay的访问器方法
{
return hireDay;
}
public String getDescription()//重写父类方法，返回一个格式化的字符串
{
return String.format("an employee with a salary of $%.2f", salary);
}
public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}
}
package abstractClasses;
public class Student extends Person//子类
{
private String major;
/**
* @param nama the student's name
* @param major the student's major
*/
public Student(String name, String major)
{
// 将n传递给父类构造器
super(name);
this.major = major;
}
public String getDescription()
{
return "a student majoring in " + major;
}
}
程序运行结果如下：
测试程序3：
Ÿ 编辑、编译、调试运行教材程序5-8、5-9、5-10，结合程序运行结果理解程序（教材174页-177页）；
Ÿ 掌握Object类的定义及用法；
Ÿ 在程序中相关代码处添加新知识的注释。
package equals;
/**
* 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);
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());
}
}
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)
//定义一个构造器，其中包含name，salary，year，month，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;
// 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()
{
return Objects.hash(name, salary, hireDay);
}
public String toString()
{
return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay
+ "]";
}
}
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;
// super.equals检查这个和其他属于同一个类
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类的定义及用法；
Ÿ 在程序中相关代码处添加新知识的注释。
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());
}
}
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页），结合运行结果理解程序；
Ÿ 掌握枚举类的定义及用法；
Ÿ 在程序中相关代码处添加新知识的注释。
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;
}
实验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
实验代码如下：
package shape;
import java.util.*;
public class ShapeTest {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.print("请输入图形个数");
String rec = "rec";
String cir = "cir";
int n = in.nextInt();
Shape[] num = new Shape[n];
for (int i = 0; i < n; i++)
{
System.out.println("请输入形状类型（rec or cir）");
String input = in.next();
if (input.equals(rec))
{
System.out.println("请输入长和宽：");
double length = in.nextDouble();
double width = in.nextDouble();
System.out.println("长方形：" + "长" + length + "宽" + width);
;
num[i] = new Rec(length, width);
}
if (input.equals(cir))
{
System.out.println("请输入半径：");
double radius = in.nextDouble();
System.out.println("圆：半径" + radius);
num[i] = new Cir(radius);
}
}
ShapeTest s = new ShapeTest();
System.out.println("总面积"+s.sumAllPerimer(num));
System.out.println("总周长"+s.sumAllArea(num));
for(Shape m:num)
{
System.out.println(m.getClass()+", "+m.getClass().getSuperclass());
}
}
public double sumAllArea(Shape num[])
{
double sum=0;
for(int i=0;i<num.length;i++)
sum+=num[i].getArea();
return sum;
}
public double sumAllPerimer(Shape num[])
{
double sum=0;
for(int i=0;i<num.length;i++)
sum+=num[i].getPerimer();
return sum;
}
}
package shape;
public abstract class Shape {
double PI =3.14;
public abstract double getPerimer();
public abstract double getArea();
}
package shape;
public class Rec extends Shape
{
private double width;
private double length;
public Rec(double w,double l)
{
this.width=w;
this.length=l;
}
public double getPerimer()
{
double Perimer=2*(length+width);
return Perimer;
}
public double getArea()
{
double Area=length*width;
return Area;
}
}
package shape;
public class Cir extends Shape {
private double radius;
public Cir(double r)
{
this.radius=r;
}
public double getPerimer()
{
double Perimer=2*PI*radius;
return Perimer;
}
public double getArea()
{
double Area=PI*radius*radius;
return Area;
}
}
实验结果如下：
实验3： 编程练习2
编制一个程序，将身份证号.txt 中的信息读入到内存中，输入一个身份证号或姓名，查询显示查询对象的姓名、身份证号、年龄、性别和出生地。
实验代码如下：
package 户口信息;
import java.io.*;
import java.util.*;
public class PersonTest {
private static ArrayList<Person> Personlist;
public static void main(String[] args) {
// TODO 自动生成的方法存根
Personlist = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
// 拿到户口信息文件
File file = new File("F:/身份证号.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 = findStudentByname(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;
}
}
package 户口信息;
public class Person {
private String name;
private String ID;
private String age;
private String sex;
private String birthplace;
public String getname() {
return name;
}
public void setname(String name) {
this.name = name;
}
public String getID() {
return ID;
}
public void setID(String ID) {
this.ID= ID;
}
public String getage() {
return age;
}
public void setage(String age) {
this.age= age;
}
public String getsex() {
return sex;
}
public void setsex(String sex) {
this.sex= sex;
}
public String getbirthplace() {
return birthplace;
}
public void setbirthplace(String birthplace) {
this.birthplace= birthplace;
}
}
实验结果如下：
学习总结：
通过前一周的学习，我对继承有了初步的了解，通过自主学习及编程练习后，编程能力也有所提高，对于语法等也有了更深一层次的了解与记忆。通过继承内容在编程中的应用，代码的逻辑结构更清晰，对我们的算法设计思维也有所帮助。同时，在自己自主学习过程中依然有碰到困难，通过自己看书查资料有所了解，同时也希望老师能在课堂上关于难懂的问题做适当解答。我会加强自主学习，努力解决在学习中遇到的问题。
