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

时间  2019-11-12
标签 Java程序设计 4周 学习 总结 栏目 Java 繁體版
原文   原文链接

1. 本章学习总结

你对于本章知识的学习总结
1.1 尝试使用思惟导图总结有关继承的知识点。
参考资料:html

百度脑图
XMindjava

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

(1)了解了类型转换（cast），只能在继承层次内进行类型转换，将父类强制转换成子类以前，应使用instanceof进行检查。
(2)懂得如何运用控制可见性的4个访问修饰符:
private -- 仅对本类可见
public -- 对全部类可见
protected -- 对本包和全部子类可见
默认 -- 没有标明任何修饰符，通常不用，对本包可见
(3)区分覆盖(Override)与重载(Overload)的区别。ide

2. 书面做业

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

对图形面积、周长求和的实验代码作了简单的注释
类的注释
工具

方法的注释
学习

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

2.进入登陆页面，登入帐号
flex

3.查找所要购买的商品，并在相应界面进行选择
网站

4.进入对应商品查看商品属性，加入购物车

5.查看购物车进行确认

6.结算购买商品

2.2 经过这个故事咱们能发现谁在用这个系统，系统中包含的类及其属性方法，类与类之间的关系。尝试找到这些类与属性，并使用思惟导图描述类、属性、方法及类与类之间的关系。
参考资料:**
UML类图
面向对象案例-借款者姓名地址.zip

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

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

class Manager extends Employee //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);//调用父类的有参构造函数来完成对子类的初始化
      bonus = 0;
   }

   public double getSalary()
   {
      double baseSalary = super.getSalary();//调用父类的getSalary()方法
      return baseSalary + bonus;
   }

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

   private double bonus;
}

如上代码注释上所述，Manager类继承父类Employee类，得到父类的属性和方法，父类属性中的name，salary，hireday则无需从新定义，还利用关键字super调用了Employee类的构造函数对子类的对象进行初始化，以及调用了getSalary()方法。

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

若是父类和子类都有相同的方法名，可使用super关键字调用父类的方法,使用super能够访问父类被子类隐藏的同名的成员。super.getSalary()使用的是父类中的方法，而getSalary()则是子类的方法。

3.3 文件第26行e.getSalary()，究竟是调用Manager类的getSalary方法仍是Employee类的getSalary方法。

运行代码获得的结果如上图所示，源代码中Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);staff[0]=boss的属性是Manager类的，因此调用的是Manager类中getSalary()方法，在Manager的getSalary()中继承了它的父类Employee的getSalary()方法；staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);staff]1]和staff[2]的属性是Employee类的，因此调用的是Employee类中的getSalary方法。

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

虽然在每一个类中复制相关的代码看起来很直观，可是代码量很是大，同时给代码的维护上也会带来极大的不便，例如代码中的name，salary，hireday要进行修改，就要在每个类中进行修改，这样岂不是费时费力。若是使用了继承的思想来实现代码，用super调用父类的构造函数，在修改时只需在父类上进行相应的修改，这样大大方便了代码的维护，而且减小了代码的冗余度，提升了代码的复用性，使代码看起来更加简洁，何乐而不为呢。

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

class Fruit{
    private String name;
}
public class Main {

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

运行结果以下：

object的toString()方法通常就是打印某个对象的“地址”，即对象的所属类以及该对象的哈希值
参考文章

在Java中，全部的对象都是继承自Object，天然继承了toString方法，在当使用System,out.println()里面为一个对象的引用时，自动调用toString方法讲对象打印出来。若是重写了tostring方法则调用重写的toString 方法。
查看println的源代码便可知道toString方法的来源

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

class Fruit{
    private String name;

    @Override
    public String toString() {
        return "Fruit [name=" + name + "]";
    }  //新增的toString方法
    
}
public class Main {

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

运行结果：

·父类Object中的toString方法固然还在，只需用关键字super调用便可。

class Fruit{
    private String name;

    @Override
    public String toString() {
        return "Fruit [name=" + name + "]"+"\n"+super.toString();
    }  //新增的toString方法
    
}
public class Main {

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

运行结果以下：

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

equals()是对两个对象的地址值进行的比较（即比较引用是否相同）,相同返回true，不一样返回false。
Object类的eqauls方法,查看源代码以下图

本身编写equals方法覆盖父类，能够利用自动生成，只需对忽略大小写上进行修改便可，代码以下：

package Q4;

class Fruit{
    private String name;
    public Fruit(String name){
        this.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.equalsIgnoreCase(other.name)) //java.lang.String.equalsIgnoreCase()方法比较字符串到另外一个字符串，忽略大小写因素。
            return false;
        return true;
    }
}
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //System.out.println(new Fruit());
        Fruit a=new Fruit("Apple");
        Fruit b=new Fruit("apple");
        System.out.println(a.equals(b));

    }
}

运行结果以下：

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

import java.util.ArrayList;
class Fruit{
    private String name;
    public Fruit(String name){
        this.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.equalsIgnoreCase(other.name)) //java.lang.String.equalsIgnoreCase()方法比较字符串到另外一个字符串，忽略大小写因素。
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "Fruit [name=" + name + "]";
    }
    
}
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //System.out.println(new Fruit());
        Fruit a=new Fruit("apple");
        Fruit b=new Fruit("Apple");
        Fruit c=new Fruit("banana");
        ArrayList<Fruit> fruitList=new ArrayList<Fruit>();
        fruitList.add(b);
        if(!fruitList.contains(a)){
            fruitList.add(a);
        }
        if(!fruitList.contains(c)){
            fruitList.add(c);
        }
        System.out.println(fruitList);
    }
}

运行结果以下：

ArrayList的contatins方法，从头至尾检索字符串，含有字符串的子串就返回true，不然返回false，能够查看源代码，以下图

Q5.代码阅读：PersonTest.java(abstract、多态)
5.1 画出类的继承关系

5.2 读懂main函数，将本身推测的出代码运行结果与真正运行结果进行比较。尝试分析缘由
运行结果以下：

Person类是一个抽象类，没有实例对象，Student类，Employee类，Manager类和Programmer类的toString()方法是利用super关键字调用父类Person类的toString()方法，得出运行结果，Manager类和Programmer类是继承Employee类的，Employee类是继承Person类的。

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

做用：调用父类的构造函数。
不能去掉,去掉后编译器会调用父类无参构造函数，而PersonTest.java中没有无参构造函数，会出现编译出错的问题。

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

多态性：相同的形态，不一样的行为（不一样的定义）
相同的方法名，不一样的实现
父类类型变量能够引用子类对象
多态的好处：
多态的好处：
1)可替换性（substitutability）:多态对已存在代码具备可替换性。例如，多态对圆Circle类工做，对其余任何圆形几何体，如圆环，也一样工做。
2)可扩充性（extensibility）:多态对代码具备可扩充性。增长新的子类不影响已存在类的多态性、继承性，以及其余特性的运行和操做。实际上新加子类更容易得到多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。
3)接口性（interface-ability）:多 态是超类经过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和 Sphere为了实现多态，完善或者覆盖这两个接口方法。
4)灵活性（flexibility）:它在应用中体现了灵活多样的操做，提升了使用效率。
5)简化性（simplicity）:多态简化对应用软件的代码编写和修改过程，尤为在处理大量对象的运算和操做时，这个特色尤其突出和重要。
参考文章
多态和继承的关系：
继承:子类继承父类中因此的属性和方法，可是对于private的属相和方法，因为这个是父类的隐私，因此子类虽然是继承了，可是没有能够访问这些属性和方法的引用，因此至关于没有继承到。
多态：就是父类引用能够持有子类对象。这时候只能调用父类中的方法，而子类中特有方法是没法访问的，由于这个时候（编译时）你把他看做父类对象的缘由，可是到了运行的时候，编译器就会发现这个父类引用中原来是一个子类的对像，因此若是父类和子类中有相同的方法时，调用的会是子类中的方法，而不是父类的。

3. PTA实验总结及码云上代码提交记录

3.1本周Commit历史截图

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

3.2 实验总结

实验碰到的问题、思考、收获与解决方案

实验第四题实际上是对第三题的稍加改造，利用继承和多态的方法减小代码的冗余度，还用了抽象类，运用了abstract关键字。 实验第五题主要是利用工具栏中的Source自动生成函数，遇到的问题是equals()函数的编写。 实验第六题更加熟练地使用super复用Person类的相关有参构造函数，利用Collections.sort()来进行排序。主要遇到的问题仍是equals（）函数没有考虑周全,以及ArrayList的运用。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程