201521123003《Java程序设计》第4周学习总结

1. 本章学习总结

你对于本章知识的学习总结

1.1 尝试使用思维导图总结有关继承的知识点。

参考资料:

百度脑图

XMind

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 + "]"+"\n"+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 fruitList存储多个fruit，要求如果fruitList中已有的fruit就不再添加，没有的就添加进去。请编写相关测试代码。并分析ArrayList的contatins方法是如何实现其功能的？

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的运用。