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

1. 本周学习总结

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

1.2 使用常规方法总结其他上课内容。

1.1

1. instanceof 测试一个对象是否是某个类的实例，即使左边是右边类的子类的实例对象，也会返回true。
2. protected关键词：
   
   2.1 子类可以访问（即使不在同一个包）；
   
   2.2 同包的可以访问protected属性和方法。

2. 书面作业

1.注释的应用:使用类的注释与方法的注释为前面编写的类与方法进行注释，并在Eclipse中查看。(截图)

答：类的注释如下图所示：

首先我们对要进行注释的类前添加相应的注释语句

最后在main中查看的结果是这样的

2.面向对象设计(大作业1，非常重要)

2.1 将在网上商城购物或者在班级博客进行学习这一过程，描述成一个故事。（不得少于50字，参考QQ群中PPT的范例）

2.2 通过这个故事我们能发现谁在用这个系统，系统中包含的类及其属性方法，类与类之间的关系。尝试找到这些类与属性，并使用思维导图描述类、属性、方法及类与类之间的关系。

2.3 尝试使用Java代码实现故事中描述的这一过程（不必很完善），将来要在这个基础上逐渐完善、扩展成一个完整的面向对象的系统。(可选：加分)

答：2.1 比如买一个篮球吧：打开淘宝网，登上自己的账号，在搜索栏中输入篮球会出现相关的关键词比如篮球鞋，篮球服等等与篮球相关的商品。但是我们只要篮球，所以点击搜索；搜索之后看到出现一个分类框有品牌，球分类等等；那么就选定我们想要的品牌，以及分类。选下一款篮球添加到购物车，但是由于要作为奖品，一个篮球不够那么就再添加一个吧，统计总价格。

2.2 通过这个故事我们发现淘宝注册的客户在用这个系统，系统中包含的类有很多，首先要登陆需要有客户类，然后就是商品类，其中的商品分类又有很多种，就又细分成服饰类，鞋靴类，儿童类，家电类，珠宝类，运动类，游戏类，食品类，家具类，汽车类等等一些其他类商品。我们想要的篮球则属于运动类，篮球由于属性不同就分成不同的类别。当我们将一个篮球加入到购物车时，购物车又是属于系统中与商品类同等级别。其思维导图如下：

3.ManagerTest.zip代码分析

分析ManagerTest.zip中的代码，回答几个问题：

3.1 在本例中哪里体现了使用继承实现代码复用？回答时要具体到哪个方法、哪个属性。

3.2 Employee类及其子类Manager都有getSalary方法，那怎么区分这两个方法呢？

3.3 文件第26行e.getSalary()，到底是调用Manager类的getSalary方法还是Employee类的getSalary方法。

3.4 Manager类的构造函数使用super调用父类的构造函数实现了代码复用，你觉得这样的有什么好处？为什么不把父类构造函数中的相关代码复制粘贴到Manager的构造函数中，这样看起来不是更直观吗？

答：3.1 先了解一下继承的概念：子类获得父类的属性与方法。继承时子类不用再编写从父类获得属性与方法的代码，可以引用父类的代码，以此减少代码量。本例中复用了了以下代码，其中的方法有有参构造函数，属性有姓名，薪水，雇佣日期。

   public Employee(String n, double s, int year, int month, int day)
   {
      name = n;
      salary = s;
      GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day);
      hireDay = calendar.getTime();
   }
   private String name;
   private double salary;
   private Date hireDay;

3.2 如何区分这两个两个方法？我认为是与函数的重载一样，但是当看到这两个方法都是无参的，不能通过参数辨别的，所以这个想法就不适用。老师在上课时提过但是忘了差不多。那么如何区分呢？在调用getsalary时，可以在其前面加上不同的类名或者不同的对象名。

3.3 应该根据e的类型，由于在for语句中定义了e的类型为Employee，所以应该调用的时Employee的

for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());

3.4 我认为这样能够减少代码量，使得整段代码不会显的那么冗长。如果一段代码非常长的话，在不同的类中有相同的属性，同时没有继承自同一类。那么如果出现一点错误的话，找到这些错误点是一个难题，修改又是另一个难题。如果都继承自一个大类的话，修改的话只需修改一个地方，这样将大大减少了我们的工作量。以上的例子可以解释第二问吧。

4.Object类

4.1 编写一个Fruit类及属性String name，如没有extends自任何类。使用System.out.println(new Fruit());是调用Fruit的什么方法呢？该方法的代码是从哪来的？尝试分析这些代码实现了什么功能？

4.2 如果为Fruit类添加了toString()方法，那么使用System.out.println(new Fruit());调用了新增的toString方法。那么其父类中的toString方法的代码就没有了吗？如果同时想要复用其父类的toString方法，要怎么操作？（使用代码演示）

4.3 Fruit类还继承了Object类的eqauls方法。尝试分析其功能？自己编写一个equals方法覆盖父类的相应方法，功能为当两个Fruit对象name相同时（忽略大小写），那么返回true。（使用代码证明你自己覆盖的eqauls方法是正确的）

4.4 在4.3的基础上使用ArrayList fruitList存储多个fruit，要求如果fruitList中已有的fruit就不再添加，没有的就添加进去。请编写相关测试代码。并分析ArrayList的contatins方法是如何实现其功能的？

答：4.1 代码以及运行结果如下：

为什么会输出这样的结果呢？因为在输出某个对象时，会调用toString方法，因为这个类都没有继承，所以认为自动继承自Object类。其调用的是Object中的toString。其功能是返回一段字符串：类名+@+哈希值；详细代码如下图。

4.2 不会没有了，因为新增toString只是覆盖了继承自Object中的toString，并不会将父类中的toString的代码修改了。如果想复用父类的toString方法可以用super关键词调用父类的toString具体代码和运行结果如下图：

4.3 Object中的equals方法的代码如下,我们可以看出来这段代码只是简单判断两个变量是否相同，即判断是不是指向同一个对象，如果是的话返回true。

public boolean equals(Object obj) {
        return (this == obj);
    }

证明测试代码如下以及运行结果如下：

package Java02;
class Fruit{
	private String name;
	public Fruit(String name) {
		// TODO Auto-generated constructor stub
		this.name=name;
	}
	@Override
	public String toString() {
		return "Fruit [name=" + name + "]\n";
	}
	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;
		return name.equalsIgnoreCase(other.name);
	} 

}
public class Java {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Fruit f1=new Fruit("wu");
		Fruit f2=new Fruit("Wu");
		Fruit f3=new Fruit("zhang");
		System.out.println(f1.equals(f2));
		System.out.println(f1.equals(f3));
	}
}

4.4 测试代码如下：

package Java02;

import java.util.ArrayList;
import java.util.Scanner;

class Fruit{
	private String name;
	public Fruit(String name) {
		// TODO Auto-generated constructor stub
		this.name=name;
	}
	@Override
	public String toString() {
		return "Fruit [name=" + name + "]\n";
	}
	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;
		return name.equalsIgnoreCase(other.name);
	} 

}
public class Java {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		ArrayList<Fruit> fruitList=new ArrayList<Fruit>();
		Fruit f1=new Fruit("wu");
		Fruit f2=new Fruit("Wu");
		Fruit f3=new Fruit("zhang");
		System.out.println(f1.equals(f2));
		System.out.println(f1.equals(f3));
		int n=sc.nextInt();
		for (int i = 0; i < n; i++) {
			String str=sc.next();
			if (str.equals("exit")) break;
			Fruit name=new  Fruit(str);
			if (!fruitList.contains(name)) {
				 fruitList.add(name);
			}
		}
		for (Fruit fruit : fruitList) {
			System.out.println(fruit);
		}
		sc.close();
	}
}

ArrayList中contains以及相关的indexof的源代码如下；我们可以看出其是在将ArrayList中的元素进行一一对比，如果相同的话，就返回true；

public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

5.代码阅读：PersonTest.java(abstract、多态)

5.1 画出类的继承关系

5.2 读懂main函数，将自己推测的出代码运行结果与真正运行结果进行比较。尝试析原因

5.3 子类中里面使用了super构造函数，作用是什么？如果将子类中的super构造函数去掉，行不行？

5.4 PersonTest.java中的代码哪里体现了多态？你觉得多态有什么好处？多态和继承有什么关系吗？

答：5.1 ：

5.2 真正运行结果如下：

Manager [bonus=12000.3, toString()=Employee [salary=90000.1, toString()=Person [name=Clark, adress=GE, phonenumber=111, email=111@mail.com, age=10, gender=mail]]]
Student [status=1, toString()=Person [name=wang, adress=110, phonenumber=15959, email=15959@163.com, age=18, gender=male]]
Employee [salary=1000.0, toString()=Person [name=zhang, adress=136, phonenumber=1360, email=1360@mail.com, age=21, gender=female]]
Programmer [allowance=50000.0, toString()=Employee [salary=100000.0, toString()=Person [name=Gates, adress=usa, phonenumber=911, email=911@com, age=59, gender=male]]]

原因：Person是一个abstract（抽象类），所以不能够实例化这个类的对象，所以只看其他4个类，这四个类的toString方法都是系统自动生成的所以有一样的格式，输出自己成员变量的同时调用其父类的toStringfangfa。

5.3 子类中用super构造函数是为了调用父类的构造函数，到达复用代码的效果。能够使得代码更加简练。不能够把super构造函数去掉，因为如果去掉的化，编译器会自动调用父类的无参函数，如果去掉的话会提示如下错误，这段提示说的是Person类中的无参构造函数未定义，必须显式地调用另一个构造函数。

Exception in thread "main" java.lang.Error: Unresolved compilation problem:
	Implicit super constructor Person() is undefined. Must explicitly invoke another constructor

	at Java02.Student.<init>(PersonTest.java:112)
	at Java02.PersonTest.main(PersonTest.java:11)

5.4 多态的概念：相同的形态，不同的行为。相同的方法名，不同的实现。同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。代码体现在每个类的toString（）方法的不同实现。代码如下：

@Override//Employee类
	public String toString() {
		return "Employee [salary=" + salary + ", toString()=" + super.toString() + "]";
	}
@Override//Student类
	public String toString() {
		return "Student [status=" + status + ", toString()=" + super.toString() + "]";
	}

多态有两个好处：

1. 应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承
2. 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。 //多态的真正作用
   
   多态和继承的关系：
3. 继承：子类继承自父类所有的属性和方法，但是private的属性和方法子类不能访问；
4. 多态：多态的特征是表现出多种形态，具有多种实现方式。或者多态是具有表现多种形态的能力的特征。或者同一个实现接口，使用不同的实例而执行不同的操作。

3. 码云代码提交记录

4. PTA实验

• 4-1、用super关键词调用父类的构造函数；
• 4-2、在提交不是将全部代码拷贝进去导致一直出现编译错误，还有在用sc.next()和sc.nextLine()分不清情况。sc.next()遇到空格和回车，table键就输入完成。而sc.nextLine()能够接收输入端的空格和Table符；
• 4-3、这题的输出样例与我的代码输出结果有点差别。但是还是能够通过，不知道为什么。
• 4-4、实在不会，不懂的如何写clone（）方法；
• 5-4、没什么问题，可以用ArrayList来储存对象，但是在计算总面积和总周长的时候卡住了，只能改用数组存储对象。
• 5-5、5-6、用编译器自动生成的方法生成相应的构造函数以及方法，节省了不少时间。在5-6中比较两个double常量时的应用方法df.format(salary).equals(df.format(other.salary))而不能这么用df.format(salary)==df.format(other.salary)。这个用法没毛病，编译器不会出现编译错误的提示，其运行结果是两个数绝对值相差0.05之内的输出true。