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

1. 本章学习总结

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



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

① 以上周PTA实验“形状”为例，Circle类和Rectangle类中都有getPerimeter和getArea这样相似的方法。可利用多态性，引入Shape父类、Shapes数组存放Circle与Rectangle对象、对Shape类的具体方法进行编程。

② 随意强制类型转换是不安全的，可以通过 instanceof 可以判断父类引用所引用的对象实例的实际类型。

③ 给类或方法注释的格式如下：

/**
 * 在此输入注释内容
 * @author 比如作者
 */

2. 书面作业

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

A1：① 以Person类为例：



在Eclipse中查看：



② 以Person类中的Person方法为例：



在Eclipse中查看：

• Q2：面向对象设计(大作业1，非常重要)
• 2.1 将在网上商城购物或者在班级博客进行学习这一过程，描述成一个故事。（不得少于50字，参考QQ群中PPT的范例）

答：某天，小郭想要找一些关于古筝的教材。她打开了亚马逊的网页，输入古筝进行搜索。



她将一本评价很好的考级教材加入了购物车，还加了3卷古筝专用的胶布。



但后来听说朋友那有更便宜的二手教材卖，于是她非常非常理智的把购物车里的教材删去了。



最后结算！

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

答：

• Q3：ManagerTest.zip代码分析
  
  分析ManagerTest.zip中的代码，回答几个问题：
• 3.1 在本例中哪里体现了使用继承实现代码复用？回答时要具体到哪个方法、哪个属性。

答：以下代码体现了使用继承实现代码复用 ↓↓↓

        class Employee                                   //Employee是父类
    {
       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 String getName()
       {
          return name;
       }

       public double getSalary()
       {
          return salary;
       }

       public Date getHireDay()
       {
          return hireDay;
       }

       public void raiseSalary(double byPercent)
       {
          double raise = salary * byPercent / 100;
          salary += raise;
       }

       private String name;
       private double salary;
       private Date hireDay;
    }

    class Manager extends Employee                   //出现extends关键字，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);             //出现super关键字，调用Employee的初始化方法；
          bonus = 0;
       }

       public double getSalary()
       {
          double baseSalary = super.getSalary();     //出现super关键字，调用Employee的getSalary()方法；
          return baseSalary + bonus;
       }

       public void setBonus(double b)
       {
          bonus = b;
       }

       private double bonus;
    }

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

答：关键在于super关键字。

加上super.则调用Employee（父类）的方法，如图：



去掉super.则调用Manager（子类）的方法，如图：

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

答：staff[0]调用的是Manager类的getSalary方法，staff[1]和staff[2]调用的是Employee类的getSalary方法。

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

答：① 最大的好处是可以大大提高编程效率，也可避免出现代码冗余的情况。

② 复制粘贴相同的代码也可达到相同的效果，但会出现代码冗余的情况。并且在差错修改的过程中会产生不必要的麻烦，大大降低编程效率，也易出现遗漏的情况。

参考：http://blog.csdn.net/jfkidear/article/details/8001811

• Q4：Object类

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

答：① 编写代码如下 ↓↓↓

    public class Main {

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

    class Fruit{
    	private String name;
    }

> 运行结果：![](http://images2015.cnblogs.com/blog/1109980/201703/1109980-20170318152421823-1568857167.png)，是系统自动调用了Fruit.toString方法。

② 该方法的代码来自父类Object类，因为当一个类没有extends任何类时，系统将默认该类继承自Object类。

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

答：① 编写代码如下 ↓↓↓

    public class Main {

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

    class Fruit{
    	private String name;

    	@Override
    	public String toString() {
    		return "Fruit [name=" + name + "]";
    	}

    }

> 运行结果：![](http://images2015.cnblogs.com/blog/1109980/201703/1109980-20170318152228510-1976924656.png)其父类中的toString方法的代码仍然存在，我只是在子类中覆盖了toString方法。
② 如果同时想要复用其父类的toString方法，编写代码如下 ↓↓↓

    public class Main {

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

    	@Override
    	public String toString() {
    		System.out.println(super.toString());     //加上一句，这里利用super关键字
    		return "Fruit [name=" + name + "]";
    	}

    }

> 运行结果：![](http://images2015.cnblogs.com/blog/1109980/201703/1109980-20170318152026088-908476983.png)

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

答：① equals主要用于比较两个对象是否相等，它与“”不同，“”比较的是两个对象的引用是否相同。

参考JDK：



其他参考：http://blog.sina.com.cn/s/blog_9f48885501013kzo.html

② 先new两个对象并赋值：

    public static void main(String[] args) {
        Fruit[] fruit = new Fruit[2];
        fruit[0] = new Fruit("orange");          //小写橘子
        fruit[1] = new Fruit("Orange");          //大写橘子
        System.out.println(fruit[0].equals(fruit[1]));
    }

> 利用Elipse自动生成功能（这功能太厉害了，瑟瑟发抖……）

        class Fruit{
    	private String name;

    	public Fruit() {
    	}
    	public Fruit(String name) {
    		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;
    	}

    }

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

• 5.1 画出类的继承关系
  
  

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

答：推测：main函数里构造了一个Person类的数组对象peoples[4]：peoples[0]为Employee类，peoples[1]为Student类，peoples[2]为Programmer类，peoples[3]为Manager类。然后按照变量age，将数组进行升序排序，然后输出。

真正运行结果（和我想的一样）：

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

答：① 调用父类方法，也可以访问父类被子类隐藏的同名的成员。

② 不行不行。



因为创建子类时父类构造函数无论如何都会被调用；如果子类构造函数无显式的调用父类的构造函数，则自动调用父类默认无参构造函数；如果父类无相应无参构造函数，则会出错。

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

答：① 这里体现了多态 ↓↓↓

    for (Person person : peoples) {
        System.out.println(person);
    }
    //在此循环中，系统根据person实际的类型实现相应的toString方法。

> ② 好处：其一，多态可以增强程序的可扩展性及可维护性，使代码更加简洁。其二，不但能减少编码的工作量，也能大大提高程序的可维护性及可扩展性。
③ 有关系。多态与继承、方法重写密切相关，我们在方法中接收父类类型作为参数，在方法实现中调用父类类型的各种方法。当把子类作为参数传递给这个方法时，Java虚拟机会根据实际创建的对象类型，调用子类中相应的方法（存在方法重写时）。
参考：http://blog.csdn.net/xinxin19881112/article/details/2944760

3. 使用码云管理Java代码

4. PTA实验

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

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

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

• 4-1：这题比较简单，用super关键字调用父类的toString方法就好。
• 4-2：注意看题目哦，要求是逆序输出，先放到数组里再toString出来。
• 4-3：就是重写equals方法，不要忽略null的情况。
• 5-4：这题跟上周的5-3差不多，利用本周学习的继承、多态思想。定义Shape类，让Rectangle与Circle继承Shape类。
• 5-5：利用ArrayList中的contains方法，判断所要加入的对象在ArrayList中是否已存在。
• 这周的PTA作业看起来会比较多，但其实函数题做起来会比较快。每周写博客作业都觉得时间很紧。嗯！以后还是要多提高效率！