1. 本章学习总结
你对于本章知识的学习总结
1.1 尝试使用思维导图总结有关继承的知识点。
参考资料:
1.2 使用常规方法总结其他上课内容。
(1)了解了类型转换（cast），只能在继承层次内进行类型转换，将父类强制转换成子类之前，应使用instanceof进行检查。
(2)懂得如何运用控制可见性的4个访问修饰符:
private -- 仅对本类可见
public -- 对所有类可见
protected -- 对本包和所有子类可见
默认 -- 没有标明任何修饰符，一般不用，对本包可见
(3)区分覆盖(Override)与重载(Overload)的区别。
2. 书面作业
Q1.注释的应用
使用类的注释与方法的注释为前面编写的类与方法进行注释，并在Eclipse中查看。(截图)
对图形面积、周长求和的实验代码做了简单的注释
类的注释
方法的注释
Q2.面向对象设计(大作业1，非常重要)
2.1 将在网上商城购物或者在班级博客进行学习这一过程，描述成一个故事。（不得少于50字，参考QQ群中PPT的范例）
1.进入网上购物商城网站
2.进入登录页面，登入账号
3.查找所要购买的商品，并在相应界面进行选择
4.进入对应商品查看商品属性，加入购物车
5.查看购物车进行确认
6.结算购买商品
2.2 通过这个故事我们能发现谁在用这个系统，系统中包含的类及其属性方法，类与类之间的关系。尝试找到这些类与属性，并使用思维导图描述类、属性、方法及类与类之间的关系。
参考资料:**
UML类图
面向对象案例-借款者姓名地址.zip
Q3.ManagerTest.zip代码分析
分析ManagerTest.zip中的代码，回答几个问题：
3.1 在本例中哪里体现了使用继承实现代码复用？回答时要具体到哪个方法、哪个属性。
class Manager extends Employee //Manager类继承父类Employee类，获得父类的属性和方法
{
/**
* @param n the employee's name
* @param s the salary
* @param year the hire year
* @param month the hire month
* @param day the hire day
*/
public Manager(String n, double s, int year, int month, int day)
{
super(n, s, year, month, day);//调用父类的有参构造函数来完成对子类的初始化
bonus = 0;
}
public double getSalary()
{
double baseSalary = super.getSalary();//调用父类的getSalary()方法
return baseSalary + bonus;
}
public void setBonus(double b)
{
bonus = b;
}
private double bonus;
}
如上代码注释上所述，Manager类继承父类Employee类，获得父类的属性和方法，父类属性中的name，salary，hireday则无需重新定义，还利用关键字super调用了Employee类的构造函数对子类的对象进行初始化，以及调用了getSalary()方法。
3.2 Employee类及其子类Manager都有getSalary方法，那怎么区分这两个方法呢？
如果父类和子类都有相同的方法名，可以使用super关键字调用父类的方法,使用super可以访问父类被子类隐藏的同名的成员。super.getSalary()使用的是父类中的方法，而getSalary()则是子类的方法。
3.3 文件第26行e.getSalary()，到底是调用Manager类的getSalary方法还是Employee类的getSalary方法。
运行代码得到的结果如上图所示，源代码中
Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);staff[0]=boss的属性是Manager类的，所以调用的是Manager类中getSalary()方法，在Manager的getSalary()中继承了它的父类Employee的getSalary()方法；staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);staff]1]和staff[2]的属性是Employee类的，所以调用的是Employee类中的getSalary方法。
3.4 Manager类的构造函数使用super调用父类的构造函数实现了代码复用，你觉得这样的有什么好处？为什么不把父类构造函数中的相关代码复制粘贴到Manager的构造函数中，这样看起来不是更直观吗？
虽然在每个类中复制相关的代码看起来很直观，但是代码量非常大，同时给代码的维护上也会带来极大的不便，例如代码中的name，salary，hireday要进行修改，就要在每一个类中进行修改，这样岂不是费时费力。如果使用了继承的思想来实现代码，用super调用父类的构造函数，在修改时只需在父类上进行相应的修改，这样大大方便了代码的维护，并且减少了代码的冗余度，提高了代码的复用性，使代码看起来更加简洁，何乐而不为呢。
Q4.Object类
4.1 编写一个Fruit类及属性String name，如没有extends自任何类。使用System.out.println(new Fruit());是调用Fruit的什么方法呢？该方法的代码是从哪来的？尝试分析这些代码实现了什么功能？
class Fruit{
private String name;
}
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new Fruit());
}
}
运行结果如下：
object的toString()方法一般就是打印某个对象的“地址”，即对象的所属类以及该对象的哈希值
参考文章
在Java中，所有的对象都是继承自Object，自然继承了toString方法，在当使用System,out.println()里面为一个对象的引用时，自动调用toString方法讲对象打印出来。如果重写了tostring方法则调用重写的toString 方法。
查看println的源代码即可知道toString方法的来源
4.2 如果为Fruit类添加了toString()方法，那么使用System.out.println(new Fruit());调用了新增的toString方法。那么其父类中的toString方法的代码就没有了吗？如果同时想要复用其父类的toString方法，要怎么操作？（使用代码演示）
·调用新增的toString方法
class Fruit{
private String name;
@Override
public String toString() {
return "Fruit [name=" + name + "]";
} //新增的toString方法
}
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new Fruit());
}
}
运行结果：
·父类Object中的toString方法当然还在，只需用关键字super调用即可。
class Fruit{
private String name;
@Override
public String toString() {
return "Fruit [name=" + name + "]"+"
"+super.toString();
} //新增的toString方法
}
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new Fruit());
}
}
运行结果如下：
4.3 Fruit类还继承了Object类的eqauls方法。尝试分析其功能？自己编写一个equals方法覆盖父类的相应方法，功能为当两个Fruit对象name相同时（忽略大小写），那么返回true。（使用代码证明你自己覆盖的eqauls方法是正确的）
equals()是对两个对象的地址值进行的比较（即比较引用是否相同）,相同返回true，不同返回false。
Object类的eqauls方法,查看源代码如下图
自己编写equals方法覆盖父类，可以利用自动生成，只需对忽略大小写上进行修改即可，代码如下：
package Q4;
class Fruit{
private String name;
public Fruit(String name){
this.name=name;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Fruit other = (Fruit) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equalsIgnoreCase(other.name)) //java.lang.String.equalsIgnoreCase()方法比较字符串到另一个字符串，忽略大小写因素。
return false;
return true;
}
}
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
//System.out.println(new Fruit());
Fruit a=new Fruit("Apple");
Fruit b=new Fruit("apple");
System.out.println(a.equals(b));
}
}
运行结果如下：
4.4 在4.3的基础上使用ArrayList
import java.util.ArrayList;
class Fruit{
private String name;
public Fruit(String name){
this.name=name;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Fruit other = (Fruit) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equalsIgnoreCase(other.name)) //java.lang.String.equalsIgnoreCase()方法比较字符串到另一个字符串，忽略大小写因素。
return false;
return true;
}
@Override
public String toString() {
return "Fruit [name=" + name + "]";
}
}
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
//System.out.println(new Fruit());
Fruit a=new Fruit("apple");
Fruit b=new Fruit("Apple");
Fruit c=new Fruit("banana");
ArrayList<Fruit> fruitList=new ArrayList<Fruit>();
fruitList.add(b);
if(!fruitList.contains(a)){
fruitList.add(a);
}
if(!fruitList.contains(c)){
fruitList.add(c);
}
System.out.println(fruitList);
}
}
运行结果如下：
ArrayList的contatins方法，从头到尾检索字符串，含有字符串的子串就返回true，否则返回false，可以查看源代码，如下图
Q5.代码阅读：PersonTest.java(abstract、多态)
5.1 画出类的继承关系
5.2 读懂main函数，将自己推测的出代码运行结果与真正运行结果进行比较。尝试分析原因
运行结果如下：
Person类是一个抽象类，没有实例对象，Student类，Employee类，Manager类和Programmer类的toString()方法是利用super关键字调用父类Person类的toString()方法，得出运行结果，Manager类和Programmer类是继承Employee类的，Employee类是继承Person类的。
5.3 子类中里面使用了super构造函数，作用是什么？如果将子类中的super构造函数去掉，行不行？
作用：调用父类的构造函数。
不能去掉,去掉后编译器会调用父类无参构造函数，而PersonTest.java中没有无参构造函数，会出现编译出错的问题。
5.4 PersonTest.java中的代码哪里体现了多态？你觉得多态有什么好处？多态和继承有什么关系吗？
参考文件:PersonTest.java
多态性：相同的形态，不同的行为（不同的定义）
相同的方法名，不同的实现
父类类型变量可以引用子类对象
多态的好处：
多态的好处：
1)可替换性（substitutability）:多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。
2)可扩充性（extensibility）:多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。
3)接口性（interface-ability）:多 态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和 Sphere为了实现多态，完善或者覆盖这两个接口方法。
4)灵活性（flexibility）:它在应用中体现了灵活多样的操作，提高了使用效率。
5)简化性（simplicity）:多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。
参考文章
多态和继承的关系：
继承:子类继承父类中所以的属性和方法，但是对于private的属相和方法，由于这个是父类的隐私，所以子类虽然是继承了，但是没有可以访问这些属性和方法的引用，所以相当于没有继承到。
多态：就是父类引用可以持有子类对象。这时候只能调用父类中的方法，而子类中特有方法是无法访问的，因为这个时候（编译时）你把他看作父类对象的原因，但是到了运行的时候，编译器就会发现这个父类引用中原来是一个子类的对像，所以如果父类和子类中有相同的方法时，调用的会是子类中的方法，而不是父类的。
3. PTA实验总结及码云上代码提交记录
3.1本周Commit历史截图
在码云的项目中，依次选择“统计-Commits历史-设置时间段”,然后搜索并截图，如下图所示
3.2 实验总结
实验碰到的问题、思考、收获与解决方案
实验第四题其实是对第三题的稍加改造，利用继承和多态的方法减少代码的冗余度，还用了抽象类，运用了abstract关键字。
实验第五题主要是利用工具栏中的Source自动生成函数，遇到的问题是equals()函数的编写。
实验第六题更加熟练地使用super复用Person类的相关有参构造函数，利用Collections.sort()来进行排序。主要遇到的问题还是equals（）函数没有考虑周全,以及ArrayList的运用。