201521123023《java程序设计》第四周学习总结-优快云博客

本文总结了一周内的面向对象编程学习成果，包括抽象类、继承、多态等核心概念的理解与应用，通过实例展示了如何利用这些特性进行有效的代码设计。

1. 本周学习总结

思维导图

常规：

(1)抽象类：不能被直接实例化。只能作为其它类的父类，这一点与final类正好相反。用关键词abstract声明。
(2)继承：只能有一个父类，即单继承，子类继承父类的全部成员(属性和方法)，  并可能有自己特有的属性和方法。用extends声明。能够复用代码，去除冗余的代码，提高时效
(3)多态：以继承、重载等为基础，实现用相同的形态完成不同行为

2. 书面作业

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

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

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

小d打开淘宝，在搜索栏里输入“java学习笔记”，跳出来的目录中商品琳琅满目，点击筛选，就商品类目、折扣和服务、价格区间等进行筛选，然后点开其中一个，内有对此书的详细介绍，并有配图。小d觉得不错，就将这本书加入了购物车，而后又搜索了其他的商品，并添加了几项到购物车中，最后，小d点开购物车，进行结算。后台，商家接单，发货。

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

使用这个系统的有买家和卖家；
包含的类： 人 类、搜索类、商品类、购物车类，后台管理类等

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

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

    super(n, s, year, month, day);
    double baseSalary = super.getSalary();

第一行代码：使用了super关键字，调用了父类Employee中的构造函数
第二行代码：使用了super关键字，调用了父类中的getSalary()

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

JVM根据调用该方法的实际对象的类型来决定选择调用哪个方法，即动态绑定。

子类中：

public double getSalary(){
    double baseSalary = super.getSalary();
    return baseSalary + bonus;
}

getSalary()中调用父类同名函数，用super关键字以示区别。

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

调用的是父类Employee的方法，因为   “Employee[] staff = new Employee[3]” staff定义的Employee类。（动态绑定）

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

好处当然是减少了代码量，代码复用就是为了要节省时间和资源，直接粘贴不是很冗余吗？当然，直接粘贴是很直观，但是如一个父类有n个子类，每个子类都用到父类相关代码，那就有点烦了

Q4.Object类

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

public class Fruit {
    private String name;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(new Fruit());
    }
}

System.out.println(new Fruit())； 其调了toString()方法，该类中没有写此方法，也没有extends自任何类，但是在java中，Object类是所有类的父类，因此系统会默认执行Object中toString方法。

Object中toStrig代码如下

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

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

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

添加了toString方法后，父类中的方法并不改，要使用的话就用super关键字

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

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

父类中的equals方法是使用“==”，而“==”比较的是引用对象的地址，而不是对象值。

public 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;
    }
    public String toString() {
        return "Fruit [name=" + name + "]    "+super.toString();
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(new Fruit("daijianzhao"));
        System.out.println((new Fruit("daijianzhao")).equals((new Fruit("djz"))));
        System.out.println((new Fruit("djz")).equals((new Fruit("djz"))));
    }
}

未自己添加equals方法时输出的结果为：

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;
    }

添加后的结果为：

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

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    ArrayList<Fruit> fruitList = new ArrayList<Fruit>();
    for (String str = sc.nextLine(); !str.equals("end"); str = sc.nextLine())
    {
        Fruit f = new Fruit(str);
        if (!fruitList.contains(f)) {
            fruitList.add(f);
        }
        else System.out.println(str+" exist");
    }
    System.out.println(fruitList);
}

测试结果：

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

5.1 画出类的继承关系

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

推测：按年龄递增顺序排列persons数组（正解）
Person类是抽象类，不存在可实例化的对象，因此需要引用子类类型，由于子类都继承了父类的属性与方法，因此，people之间可以直接复用父类成员从而进行比较。

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

作用是调用父类的构造器，对类成员初始化；
如果去掉，则系统会默认调用父类无参构造函数，假如父类中没有此类函数，则会编译出错。本例就是无无参构造函数的

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

多态就是“相同的形态，不同的行为”，

System.out.println(person);

如此简单的一句，却能实现不同类对象的输出（Employee、Student、Programmer、Manager）
好处不言而喻，如果没有多态性，那么我们的代码会是这样的：

System.out.println(Employee);
System.out.println(Student);
System.out.println(Programmer);
System.out.println(Manager);

并且如果还有新的类型，新的对象，那么，我们的工作量就又加大不少，从时间效率上来看也不理想。
关系：继承是多态的基础

3.码云提交记录

PTA实验总结

(1)在子类中，可以自己编写方法，若与父类同名则在调用时，会调用子类的方法，从而覆盖掉父类的方法，例：equals、toString方法
(2)ArrayList，动态创建数组，数组元素数据类型可以是基本的也可以是抽象的
(3)abstract 声明的类为抽象类，无法实例化，因此必须被继承
(4)使用super关键字调用父类构造器时，应将其放在子类构造函数中的第一行
(5)......

转载于:https://www.cnblogs.com/daijz/p/6574811.html