201521123059 《Java程序设计》第四周学习总结

1. 本周学习总结

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

参考资料:

百度脑图

XMind

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

 1.多态性就是相同的形态，不同的行为（不同的定义）。多态就是就是以单一的接口操作多种类型的对象。
 2.强制类型转换时不能随意的强制，因为随意强制类型转换是不安全的，会出现ClassCastException系统报错。强制转换只能在继承层次内进行类型转换，而且将父类强制转换成子类之前，应该用instanceof进行检查。
 3.Object-equals方法，在Object类中用equals检测两个对象状态的相等性，如果两个对象的状态相等，就认为这两个对象相等。

2. 书面作业

1.注释的应用

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

package java03;

import java.util.Arrays;
import java.util.Scanner;
/**
 * 照着String的文档，这大概是用来描述公司里面的一个雇员。
 * <p>下面只是简单地试一些标签
 * <p>“@see”这个标签可以允许我们引用其他类的文档，生成HTML文件会生成超链接
 * <p>“@return”用来描述返回值的含义
 * <p>“@param”用来描述参数列表中的标识符
 */
class PersonOverride {
	private String name;
    private boolean gender;
    private  int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public boolean isGender() {
		return gender;
	}
	public void setGender(boolean gender) {
		this.gender = gender;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	/**
	 * 这是一个最常见的有参的构造器，就是把传进来的参数来初始化对象，
	 * 不过这边没有初始化id这个变量，所以会默认是0
	 * @param name
	 *        名字
	 *
	 * @param age
	 *        年龄
	 *
	 * @param gender
	 *        性别
	 */
    public PersonOverride(String name,int age,boolean gender){
        this.name=name;
        this.age =age;
        this.gender=gender;
    }
    /**
     * 这是一个无参构造器，会输出一个语句，然后将未初始化的默认成员变量值返回main函数
     */
    public PersonOverride(){
    	this("default",1,true);
    }
	@Override
	public String toString() {
		return (name+"-"+age+"-"+gender);
	}
	public boolean equals(Object other){
		if (this==other) {
			return true;

		}
		if (other == null){
			return false;
		}
		if (getClass() != other.getClass())
			return false;
		PersonOverride obj=(PersonOverride) other;
		if (age != obj.age)
			return false;
		if(gender!=obj.gender)
		    return false;
		if (name == null) {
			if (obj.name != null)
				return false;
		} else if (!name.equals(obj.name))
			return false;
		return true;
	}
}

类的注释



有参函数的注释



无参函数的注释

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

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

一天我上京东商城购物，在京东页面我搜索了我想要买的Java web书，然后跳出来了挺多关于Java的书我随机点击了一个，进去看到了关于书的价格、名称和书的出版社，经过一番比对之后我觉得这本书挺好的就决定了加入购物车购买，但我还想买其他的书，然后我又添加一本J关于java的书进入了购物车。再去购物车结账时我发现可以添加Java书的数量，之后在结算了这两本书价格为200后我觉得太贵了就把他们移除出我的购物车了

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

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

参考资料:

UML类图

面向对象案例-借款者姓名地址.zip

3.ManagerTest.zip代码分析

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

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();
   }
   .
   .
 public Manager(String n, double s, int year, int month, int day)
   {
      super(n, s, year, month, day);
      bonus = 0;
   }

 答：这段代码体现了使用继承实现了代码复用。这里使用了super关键字调用的父类方法，通过调用父类的构造器来完成子类的name、salary、year、month、day对象的初始化。

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

 答：编译器搜索getsalary签名的类，就能区分出哪个方法。

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

 答：根据下图得到getSalary是调用Employee方法

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

 答：我觉得这样的好处是可以避免敲很多的重复代码，代码看上去也没有那么繁琐，也能够体现相关类的层次关系。直接复制代码是比较直观，但是我们要学以致用学会用高级更简便的super方法。

4.Object类

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

代码如下：
class Fruit {
    private String name;
}

public class Test {
    public static void main(String[] args) {
        System.out.println(new Fruit());
    }
}

 答：直接输出就会调用Fruit的toString方法；没有在函数里编写有Tostring但是会这样输出我就不知道怎么调用来的，我估计是与继承某个东西有关吧。

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

 代码如下：
class Fruit {
    private String name;

	@Override
	public String toString() {
		return super.toString();
	}
}

public class Test {
    public static void main(String[] args) {
        System.out.println(new Fruit());
    }
}

输出结果为：

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

代码如下：
class Fruit {
    private String name;

	@Override
	public String toString() {
		return super.toString();
	}

	@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.equals(other.name))
			return false;
		return true;
	}
}

public class Test {
    public static void main(String[] args) {
        System.out.println(new Fruit());
    }
}

 答：在上两问的基础上可以在eclipse里面直接生成eqauls和hashCode()方法，其原理大概是将一个Fruit（）对象在hashCode（）生成一个整数，在equals调用比较，如果相同则返回true,

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

代码如下:
class Fruit {
    private String name;

	public Fruit(String name) {
		this.name=name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Fruit [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.equals(other.name))
			return false;
		return true;
	}
}
public class Test{
    public static void main(String[] arge){
    	// System.out.println(new Fruit(""));
         Scanner sc=new Scanner(System.in);
         ArrayList<Fruit> fruitList=new ArrayList<Fruit>();
         for(int i=0;i<2;i++){
                 Fruit n=new Fruit(sc.next());
                 if(!fruitList.contains(n))
                     fruitList.add(n);
         }
         System.out.println(fruitList);

     }
 }

ArrayList的contatins方法实现分析：根据HashCode（）的值比较，如果相同则不用添加，否则添加，而HashCode（）值是根据地址计算而来。

输出结果：

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

5.1 画出类的继承关系

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

输出结果为：
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]]]

原因不详

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

作用是调用父类的构造函数。
不行。因为如果将super构造函数去掉，那么编译器会自动加入对父类无参构造器的调用，然而这个例子中没有一个类是有无参构造器的，所以会编译出错。

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

多态的好处：可以增强程序的可扩展性及可维护性，使代码更加简洁。不但能减少编码的工作量，也能大大提高程序的可维护性及可扩展性。
多态和继承的关系：多态是使用单一接口操作多种类型的对象。多态与继承、方法重写密切相关，继承服务于多态，多态也不能单独使用，即多态与继承相互作用。

参考文件:PersonTest.java

3. 码云代码提交记录

在码云的项目中，依次选择“统计-Commits历史-设置时间段”, 然后搜索并截图

4. PTA实验

题目集：jmu-Java-03-面向对象1-基础-封装继承 中的

函数(4-1, 4-2, 4-3,4-4较难选做)

编程(5-4, 5-5, 5-6)

一定要有实验总结

实验总结：
4-1通过super来调用父类方法可以在子类中少写一些相同属性和方法，不过要注意super调用的格式。
4-2老师给了一个函数接口刚开始还不知道什么意思，知道写完了代码提交了很多遍以后才知道函数接口是题目已经给你写好的一部分，不需要全部提交完，所以说理解好题目意思也挺重要的，不然自讨苦吃了。
4-3在编写equals方法时少写了一个if（gender.equals(other。gender)）的比较，所以输出结果是错的，一直找原因也找而比较久， 这时候就体现了eclipse的强大和便利了，可以自动生成一些步骤避免繁琐而漏写了。可以boolean equals(Object anObject) 比较此字符串与指定的对象，而不用以前一个个字符比较的方法。
4-4和5-6没有写。
5-4这题运用到了定义抽象类，在定义时加上关键字abstract，然后构造无参函数public double getPerimeter()和public double getArea())，最后编写double sumAllArea方法输出形状数组中的面积和和  double sumAllPerimeter方法输出形状数组中的周长和。
5-5通过这题交给我们一个求输出所有构造函数的方法，即System.out.println(Arrays.toString(PersonOverride.class.getConstructors()))，只是还有点不明白其实现原理。通过输入的个数建立对象用Object来收集，之前不明白怎么把类放入数组中，通过这些题目以及了解Java.lang.Object的用法才慢慢理解了。

5-5错误答案图