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

目录

• 1. 本周学习总结
• 2. 书面作业
  • 1.注释的应用
  • 2.面向对象设计(大作业1，非常重要)
    • • 2.1 将在网上商城购物或者在班级博客进行学习这一过程，描述成一个故事。（不得少于50字，参考QQ群中PPT的范例）
      • 2.2 通过这个故事我们能发现谁在用这个系统，系统中包含的类及其属性方法，类与类之间的关系。尝试找到这些类与属性，并使用思维导图描述类、属性、方法及类与类之间的关系。
  • 3.ManagerTest.zip代码分析
    • • 3.1 在本例中哪里体现了使用继承实现代码复用？回答时要具体到哪个方法、哪个属性。
      • 3.2 Employee类及其子类Manager都有getSalary方法，那怎么区分这两个方法呢？
      • 3.3 文件第26行e.getSalary()，到底是调用Manager类的getSalary方法还是Employee类的getSalary方法。
      • 3.4 Manager类的构造函数使用super调用父类的构造函数实现了代码复用，你觉得这样的有什么好处？为什么不把父类构造函数中的相关代码复制粘贴到Manager的构造函数中，这样看起来不是更直观吗？
  • 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方法是如何实现其功能的？
  • 5.代码阅读：PersonTest.java(abstract、多态)
    • • 5.1 画出类的继承关系
      • 5.2 读懂main函数，将自己推测的出代码运行结果与真正运行结果进行比较。尝试分析原因
      • 5.3 子类中里面使用了super构造函数，作用是什么？如果将子类中的super构造函数去掉，行不行？
      • 5.4 PersonTest.java中的代码哪里体现了多态？你觉得多态有什么好处？多态和继承有什么关系吗？
• 3. 码云代码提交记录
• 4. PTA实验
  • • • 4-1:
      • 4-2：
      • 4-3:这题要判断的条件特别多。
    • 编程(5-4, 5-5, 5-6)
      • 5-4:
      • 5-5：
      • 5-6：

1. 本周学习总结

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

2. 书面作业

1.注释的应用

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

在这里说一下/** */这种注释，通过Myeclipse我们可以看到，我们在类前面或者方法前面加注释，然后以后要调用它的时候，把鼠标放在上面，可以看到注释的内容，那么它和普通的多行注释/**/有什么区别吗？仅仅是第一行多了个*吗。就这设计到javadoc的语法，看下官方解释。javadoc是Sun公司提供的一个技术，它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。。也就是说我们用/** */这种注释写的内容是可以抽取出来的。我们常用的API文档其实就是源代码的注释中抽取出来的。


再经过一点加工这些文件这可以变成我们经常看见的.chm格式的API文档。

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

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

今天顶级黑客大会pwn2own刚刚落幕，360和腾讯分别获得第一和第二，长亭科技紧追其后，怀着对大牛们的向往，我决定开始研究二进制安全。
打开淘宝，搜索逆向工程，发现很多书

找到这本《逆向工程核心原理》，加入购物车

发现购物车里面出了书之外还有很多东西，都说买不起的

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

3.ManagerTest.zip代码分析

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

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

属性:

• name;
• salary;
• hireDay;
  方法:
• getName
• getHireDay
• raiseSalary

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

子类的getSalary覆盖了父类的，正常子类的实例调用的都是子类的，要想调用父类的，只能用super

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

不知道，这就是多态，只有在运行时才知道调用了哪个，比如Boss就调用Manager类的getSalary方法，其他两个就调用了Employee类的getSalary方法。

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

代码复用vs直接复制。确实，在编写阶段，复用和复制所花费的时间差不了多少，毕竟有ctrl+C和ctrl+v。但是，代码除了编写阶段还有调试阶段和维护阶段。一旦哪个地方出了错误，我们只能一一排错的时候，
我们内心还是希望错误的点少一点的。而复用的话复用的就只要调试一个点就好了，至于复制粘贴，鬼知道你有没有复制错地方了。

4.Object类

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

public class Fruit {
	String name;
	public static void main(String[] args) {
		System.out.println(new Fruit());
	}
}
work.Fruit@dcf3e99(不同机子结果不同)

Fruit虽然没有extends任何类，但是默认是继承自Object这个类的。System.out.println(new Fruit());这句话调用了Fruit的默认构造函数以及继承自Object的toString()方法。其代码为 return getClass().getName() + "@" + Integer.toHexString(hashCode());。也就是类名+@+hashcode的16进制.

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

public class Fruit {
	String name;
	private void testSuper() {
		// TODO Auto-generated method stub
		System.out.println(super.toString());

	}
	public static void main(String[] args) {
		System.out.println(new Fruit());
		new Fruit().testSuper();
	}
	@Override
	public String toString() {
		return "Fruit [name=" + name + "]";
	}
	
}
Fruit [name=null]
work.Fruit@15db9742

父类的toString并没有没有了，只是被覆盖了，通过super可以重新调用

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

   public class Fruit {
    	String name;
    	
    	public Fruit(String name) {
    		super();
    		this.name = name;
    	}
    
    	public static void main(String[] args) {
    		Fruit t1,t2;
    		t1=new Fruit("dai");
    		t2=new Fruit("dai");
    		System.out.println(t1.equals(t2));
    	}
    }
false

---

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

	@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))
			return false;
		return true;
	}


	public static void main(String[] args) {
		Fruit t1,t2;
		t1=new Fruit("dai");
		t2=new Fruit("Dai");
		System.out.println(t1.equals(t2));
	}
}
	true

本来的equal就是判断两个对象的hashcode是不是一样，由于不同对象的hashcode唯一（靠hashcode函数来保证，因此本来的equal可以看成判断两个对象是不是一样。

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

   public static void main(String[] args) {
    		Fruit[] t=new Fruit[4];
    		t[0]=new Fruit("dai");
    		t[1]=new Fruit("Dai");
    		t[2]=new Fruit("zhi");
    		t[3]=new Fruit("zhi");
    		ArrayList<Fruit> fruitList=new ArrayList<>();
    		for (int i = 0; i < t.length; i++) {
    			if(!fruitList.contains(t[i])){
    				fruitList.add(t[i]);
    			}
    		}
    		System.out.println(fruitList);
    	}
	
		[Fruit [name=dai], Fruit [name=zhi]]

---

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

---

public int indexOf(Object o) {
        if (o == null) {//判断元素里面有没有null  ，null==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]))//遍历每个元素，看是不是有没有一样的，这里判断有没有一样调用的是equal方法。
                    return i;
        }
        return -1;
    }

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

5.1 画出类的继承关系

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

    	Person[] peoples = new Person[4];		
		peoples[0] = new Employee("zhang", "136", "1360", "1360@mail.com", 21, "female", 1000.0);
		peoples[1] = new Student("wang", "110", "15959", "15959@163.com", 18, "male", "1");
		peoples[2] = new Programmer("Gates", "usa", "911", "911@com", 59, "male", 100000.0, 50000.0);
		peoples[3] = new Manager("Clark", "GE", "111", "111@mail.com", 10, "mail", 90000.1, 12000.3);//实例化4个人，分别是Employee,Student,Programmer,Manager
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++)
				if (peoples[j].getAge() > peoples[j + 1].getAge()) {
					Person temp = peoples[j];
					peoples[j] = peoples[j + 1];
					peoples[j + 1] = temp;
				}
		}//按年龄冒泡排序（升序)
		for (Person person : peoples) {
			System.out.println(person);
		}//以各自特有的toString输出这4个人

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

调用了父类的构造函数。其实去掉也可以，自己手动写。但是往往super可以省很多代码量。

public Student(String name, String adress, String phonenumber, String email, int age, String gender,String status) {
	super(name, adress, phonenumber, email, age, gender);
	this.status = status;
}

在这里直接调用super就不用写基函数里面的构造函数，比如this.name=name这些。但是我们不写是可以的，只是为了方便。

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

代码中能体现多态地方
peoples[0] = new Employee("zhang", "136", "1360", "1360@mail.com", 21, "female", 1000.0);
peoples[1] = new Student("wang", "110", "15959", "15959@163.com", 18, "male", "1");
peoples[2] = new Programmer("Gates", "usa", "911", "911@com", 59, "male", 100000.0, 50000.0);
peoples[3] = new Manager("Clark", "GE", "111", "111@mail.com", 10, "mail", 90000.1, 12000.3);

多态可以减少量，加强代码的伸缩性，特别是在分工的时候。抽象了一点。我具体说下。
多态可以细分为编译时多态和运行时多态。所谓编译时多态就是我们所说的函数重载，同一个函数名，传进不同的参数可以执行不同的结果。
而运行时多态，是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定。在运行时才确定下来。比如上people，假如每个继承people的类都重写了
people的speak，但是我们定于了一个人，要执行people.speak（）。在编程阶段你并不知道谁会来调用，会有什么效果，，只有运行的时候实例化people的一个子类的时候，才知道具体会发生什么事。
这样设计的好处就在于我设计者设计这个函数的时候不用设置的太死了。给后面使用这个类的人提供了很多可扩展空间。
运行时多态紧紧依赖于于继承，或者这样说，没有继承就没有运行时多态。
运行时多态存在的三个必要条件：

1. 要有继承（包括接口的实现）
2. 要有重写；
3. 父类引用指向子类对象。

参考文件:PersonTest.java

3. 码云代码提交记录

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

4. PTA实验

4-1:

重写toString,没什么好讲的

4-2：

这题代码也比较简单，但是要注意的是格式，把main函数那些也给提交上去，一直显示错误，最后猜发现。

4-3:这题要判断的条件特别多。

先附上源代码。

public boolean equals(Object obj) {
		DecimalFormat df = new DecimalFormat("#.##");
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Employee other = (Employee) obj;
		if (!super.equals(other)) 
			return false;
		if (company == null) {
			if (other.company != null)
				return false;
		} else if (!company.equals(other.company))
			return false;
		if (df.format(salary)!=df.format(other.salary))
			return true;
		return true;
	}

大部分是让myEclipse帮我写的，但是单纯那些还过不了。
主要是没考虑父类的salary。还有salary这种也比较特别，由于题目中提醒是要用到DecimalFormat df = new DecimalFormat("#.##");。
在这里饶了一会儿，去查了一下这是double的格式化输出。用法是df.format(salary)

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

5-4:

这题相对于5-3只要是多了要写个抽象类shape，然后矩形和圆都来继承它。最后在算面积的时候利用多态的特性可以省很多事。
这一题的注意点在于题目要求的是用Math.PI，一直提交不了。后来想父类为什么定义个常量PI，，就直接用父类的PI。

5-5：

很多函数都是在MyEclipse的帮助下的，也没什么难点。

5-6：

主要功能在函数那部分已经写完了，也就拼凑一下