20172302 《程序设计与数据结构》第八周学习总结

<hr/> 2018年学习总结博客总目录：[第一周](http://www.cnblogs.com/hzy0628/p/8539037.html) [第二周](http://www.cnblogs.com/hzy0628/p/8584976.html) [第三周](http://www.cnblogs.com/hzy0628/p/8642935.html) [第四周](http://www.cnblogs.com/hzy0628/p/8671888.html) [第五周](http://www.cnblogs.com/hzy0628/p/8746606.html) [第六周](http://www.cnblogs.com/hzy0628/p/8830819.html) [第七周](http://www.cnblogs.com/hzy0628/p/8870071.html) [第八周](http://www.cnblogs.com/hzy0628/p/8940111.html) <hr/>

教材学习内容总结

1.绑定（binding）与后绑定（动态绑定）：咱们在程序执行时可能会要求某段代码来完成一个方法的调用，这被称为一个方法调用与一个方法定义的绑定。大多数状况下，这种绑定是在编译阶段就会完成。可是对于多态性引用，这种绑定会延迟到程序运行时才会完成，而且要绑定的方法定义取决于当时引用变量所引用的对象，这就是后绑定，或称为动态绑定。

2.后绑定的效率要低于编译阶段的绑定效率，因其须要在程序执行期间去进行判断，从而绑定与引用变量所引用的对象相对应的方法。

3.由继承实现多态性：当用类名声明一个引用变量时，这个变量能够指向该类的任何一个对象，同时，它也能引用经过继承与它所声明的类型有关的任何类的对象。下面这是一个小例子，咱们能够看到Christmas是Holiday的一个子类，经过这样的声明，咱们的day变量就是能够调用Christmas中的方法，即实际将调用的方法取决于对象的类型而不是引用变量的类型。同时多态机制容许用具备一致性但又特殊的方式处理相似的对象。

4.利用接口实现多态性：首先一个接口名能够用来声明对象引用变量，一个接口引用变量能够指向任何实现该接口的类的对象。执行代码时实际调用的方法将取决于调用发生时接口引用所指向的对象的类型。<font color=#DC143C >使用接口引用变量时，只能调用定义在接口中的方法，即便接口引用变量所指向的对象还有一些其余可用方法，也不能调用。</font>举一个接口实现多态的小例子：（以下面中Philosopher和Dog都实现了Speaker接口）

public interface Speaker
{
    public void speak()
     public void announce(String str)
}

class test
{
   public static void main(String[] args){
   Speaker current;
   current = new Philosopher();
   currrent.speak();
    currrent = new Dog();
    current.speak();
}

若是Dog类没有announce方法，那么咱们引用变量指向Dog时将不能调用announce方法，若是须要，能够将其转换为Philosopher的类型((Philosopher)current).announce;

5.排序：这里分析两种：选择排序法和插入排序法。 选择排序的基本思想:第1趟，在待排序记录r[1]~r[n]中选出最小的记录，将它与r[1]交换;第2趟，在待排序记录r[2]~r[n]中选出最小的记录，将它与r[2]交换;以此类推，第i趟在待排序记录r[i]~r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增加直到所有排序完毕。

初始序列:{49 27 65 97 76 12 38} 第1趟:12与49交换:12{27 65 97 76 49 38} 第2趟:27不动 :12 27{65 97 76 49 38} 第3趟:65与38交换:12 27 38{97 76 49 65} 第4趟:97与49交换:12 27 38 49{76 97 65} 第5趟:76与65交换:12 27 38 49 65{97 76} 第6趟:97与76交换:12 27 38 49 65 76 97 完成

插入排序法：检查第i个数字，若是在它的左边的数字比它大，进行交换，这个动做一直继续下去，直到这个数字的左边数字比它还要小，就会中止，进行下一个数字的排序，直到造成有序数列。

1 5 7 3 1 6 把表分红两部分，前半部分已排序，后半部分未排序，我用|分开 初始为 5 | 1 7 3 1 6 一次插入排序，把第一个1插入前边已排序部分，得 1 5 | 7 3 1 6 后边依次是 1 5 7 | 3 1 6 1 3 5 7 | 1 6 1 1 3 5 7 | 6 1 1 3 5 6 7 |

6.排序算法比较：选择排序和插入排序实际上进行的比较次数相近，都是大约进行n^2次比较，可是选择排序法所执行的交换操做的次数要少，所以选择排序法要优于插入法。

7.搜索：分析两种：线性搜索和二分搜索。 线性搜索，即从搜索池的起点开始，将目标依次与每一个元素进行比较，最终找到目标元素，或搜索到数列的终点后发现数列中不存在目标元素。这里列一下代码的编写：

{
      int index = 0;
      boolean found = false;

      while (!found && index < list.length)
      {
         if (list[index].equals(target))
            found = true;
         else
            index++;
      }

      if (found)
         return list[index];
      else
         return null;
   }

二分搜索：前提是数列必须是已经排序好的，搜索过程从数组的中间元素开始，若是中间元素正好是要查找的元素，则搜索过程结束；若是某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，并且跟开始同样从中间元素开始比较。若是在某一步骤数组为空，则表明找不到。下面是其代码（以升序的数列为例）

int min=0, max=list.length, mid=0;
      boolean found = false;

      while (!found && min <= max)
      {
         mid = (min+max) / 2;
         if (list[mid].equals(target))
            found = true;
         else
            if (target.compareTo(list[mid]) < 0)
               max = mid-1;
            else
               min = mid+1;

教材学习中的问题和解决过程

• 问题1：关于上面所提到的“实际将调用的方法取决于对象的类型而不是引用变量的类型”，以及书上例题中的这个staffList[0] = new Executive("Sam", "123 Main Line", "555-0469", "123-45-6789", 2423.07);,((Executive)staffList[0]).awardBonus(500.00);,我就不明白这个引用变量和对象的含义了。

• 问题1解决方案：经过查资料，算是明白一些，这里尝试说一下：先拿最简单的来讲，Animal animal1 = new Animal();这条语句咱们将它拆分为两句Animal animal1;、animal1 = new Animal();第一条语句作的是建立了一个引用变量animal，在第二条语句执行时，这个引用变量指向了Animal这个对象。 而后再去理解咱们的多态这里的引用变量和对象的关系(Cat为Animal的一个子类)：Animal animal2 = new Cat();一样拆为两句，Animal animal2;、animal2 = new Cat();,这时理解起来就很简单，咱们建立了一个Animal的引用变量animal2，而后这个引用变量是指向Animal的子类Cat类的对象的，那么引用变量的类型是Animal，而引用的对象的类型是Cat。这也就解释了多态使用中的具体含义。参考连接：(http://www.javashuo.com/article/p-gnkbzymu-ho.html)

• 问题2：一个小问题：【例10.10】中的equals方法，我觉得是下面的CompareTo方法调用了这个方法，可又感受不对，不是一个类型的怎么使用的？

• 问题2解决方案：后来上去问了老师，老师说CompareTo方法中使用的是String类里面的equals方法，和上面的没有关系。我就开始找这个方法到底在哪使用了？我读完整个代码，包括下一节的都没有发现这个方法的做用，彻底没有使用这个方法，还有第10.5.1的最后一段说是调用了equals方法，彻底看不到，很迷糊，这哪里使用了？上面问题解决了，但这个方法在哪使用没有解决。

• 问题3：关于这个后绑定，是不是只有多态状况下才会进行后绑定，其它状况下的绑定是否都在编译阶段已经完成？

• 问题3解决方案：这个查了一些资料，见下图，这样的状况下即便不是多态也有可能进行后绑定，后绑定运用会去判断与它最符合的声明类型和方法名。

代码调试中的问题和解决过程

• 问题1：关于编程项目PP10.1的编写，一开始想的是只能在这里实现使用接口，不能再去使用使用继承，就是把StaffMember改写为Payable接口，其余的类都声明这个接口实现多态，可作起来就比较吃力。

• 问题1解决方案：作起来时的想法是将StaffMember类改写为一个接口，而后呢，将Employee类也改成一个接口，为StaffMember接口的一个接口，这样也不符合题目的要求，题目要求的是只去写这一个Payable接口，而后就是一直在改动，最后作的结果是只写了这一个接口，而后让Volunteer类和Employee类都声明该接口，并重写其方法，而后Executive和Hourly类都是继承Employee类，并将Staff类声明该接口，重写方法，Firm为驱动类，完成了经过接口实现多态这一题目。下面是Payable接口的代码：

public interface Payable
{
    public String toString();
    public  double pay();
}

• 问题2：编程项目PP10.5，这里编写时遇到了一些问题，本身作的时候老是在想着那个DVDCollection类到底该怎么去改写，一直是出现问题。而后致使Movies和Sorting类致使矛盾，两边要求改写的错误恰巧是相矛盾的。

• 问题2解决方案：最后是参考那个书上的例题，我就没有再使用DVDCollection类，而是直接一个DVD类和一个Movies类，直接是Movies声明那个Comparable接口，而后重写CompareTo方法，再对Movies类进行改写，实例化一个DVD对象的数组，往其中添加元素，再使用Sorting类进行排序，完成这个题目，Movies代码见下：

public class Movies
{
    public static void main(String[] args)
    {
        DVD[] movies=  new DVD[7];

        movies[0]=new DVD("The Godfather", "Francis Ford Coppola", 1972,24.95,true);
        movies[1]=new DVD("District 9", "Neill Blomkamp", 2009,19.95,false);
        movies[2]=new DVD("Iron Man","Jon Favreau", 2008,15.95,false);
        movies[3]=new DVD("All About Eve", "Joseph Mankiewicz", 1950,17.50,false);
        movies[4]=new DVD("The Matrix", "Andy & Lana Wachowski", 1999,19.95,true);
        movies[5]=new DVD("Iron Man 2","Jon Favreau", 2010,22.99,false);
        movies[6]=new DVD("Casablanca","Michael Curtiz", 1942,19.95,false);

        Sorting.selectionSort(movies);
        for(DVD movie:movies)
            System.out.println(movie);

        Sorting2.selectionSort(movies);
        for(DVD movie:movies)
            System.out.println(movie);
        }
}

最后的运行结果：

代码托管

上周考试错题总结

• 1.Inheritance through an extended (derived) class supports which of the following concepts? A . interfaces B . modulary C . information hiding <font color=#0000CD >D . code reuse</font> E . correctness

• 解析：当继承一个已有类时，新类没必要从新实现任何继承的方法或实例数据，从而为程序员节省了一项工做，提升了效率。所以，代码重用是一种重用其余人的代码的能力，它能够为咱们的须要扩展它。

Java继承是使用已存在的类的定义做为基础创建新类的技术，新类的定义能够增长新的数据或新的功能，也能够用父类的功能，但不能选择性地继承父类。这种技术使得复用之前的代码很是容易，可以大大缩短开发周期，下降开发费用。

• 2.Which of the following is an example of multiple inheritance? A . A computer can be a mainframe or a PC B . A PC can be a desktop or a laptop <font color=#0000CD >C . A laptop is both a PC and a portable device</font> D . A portable device is a lightweight device E . Macintosh and IBM PC are both types of PCs

• 解析：多继承意味着一个新的派生类继承了不止一个父类。在上面列出的那些电脑中，一台笔记本电脑从我的电脑和便携设备上继承了一些属性，所以这属于多继承。A、B和E的答案都是单继承的例子，其中一个类至少有两个子类（在A中，计算机有主机和PC机；在B中，PC机有桌面和笔记本电脑，在E，PC机有Macintosh机和IBM 我的计算机），D表示一个类的一个属性。当时误选D项，觉得成其余都是属于多继承。

• 3.A variable declared to be of one class can later reference an extended class of that class. This variable is known as A . protected B . derivable C . cloneable <font color=#0000CD >D . polymorphic</font> E . none of the above, a variable declared to be of one class can never reference any other type of class, even an extended class

• 解析：一个被声明为一个类的对象能够引用该类的子类，这种方法是被称做为多态，这是在第十章中的内容,一个父类的对象是能够指向任何一个子类的一个对象，这种就是由多态所引发的。

多态是同一个行为具备多个不一样表现形式或形态的能力。多态下容许将子类类型的指针赋值给父类类型的指针。

• 4.In order to determine the type that a polymorphic variable refers to, the decision is made A . by the programmer at the time the program is written B . by the compiler at compile time C . by the operating system when the program is loaded into memory <font color=#0000CD >D . by the Java run-time environment at run time</font> E . by the user at run time

• 解析:这道题目是在问是在什么阶段肯定多态变量所引用的类型，这也是属于第十章内容。对于多数状况下的这种请求，这种绑定是发生在编译阶段，可是对于多态性引用，这种绑定要延迟到程序运行才能执行，而且要绑定的方法取决于当时引用变量所引用的对象，这种被延迟的请求事件被称为后绑定或动态绑定。

• 5.Why shouldn't an abstract method be declared final? A . There's nothing wrong with doing so <font color=#0000CD >B . Abstract methods cannot be overridden and they must be if a concrete class ever is to be instantiated</font> C . So long as the Abstract method never actually is used in by any other method, there's no problem with doing this D . So long as the Abstract method is declared in a Class (not an Interface), there's nothing wrong with doing this E . None of the above

• 解析：为了让抽象方法成为具体的方法，它必须被重写。声明一个方法是final的，这使得它不能被重写，所以没法为一个抽象final方法提供定义。

• 6.Using the reserved word, super, one can A . access a parent class'constructor(s) B . access a parent class'methods and instance data C . access a child class'constructor(s) D . access a child class'methods and instance data <font color=#0000CD >E . both A and B</font>

• 解析：这道题目误选A，答案应该是E，使用super的方法是能够访问父类的构造函数、方法以及实例数据，见上周博客有详细介绍，这里是由于题目有错，误选了a。参考连接：(http://www.javashuo.com/article/p-qjwwegcr-y.html)

• 7.If class AParentClass has a protected instance data x, and AChildClass is a derived class of AParentClass, then AChildClass can access x but can not redefine x to be a different type. A . true <font color=#0000CD >B . false</font>

• 解析：子类是能够访问父类的任何实例数据或方法的，同时子类也能够从新定义父类中的任何实例数据或方法的，从新定义的父类实例数据称为影子变量，这个咱们不提倡，但重写父类的方法这个是常常会使用到的，也是符合规范的。

结对及互评

点评过的同窗博客和代码

• 本周结对学习状况

  • 20172308

  • 博客中值得学习的或问题： 问题的记录至关详细了，已经具体到每一步所出现的问题及解决过程，配图的截取也很充分恰当，重点出错部分用红框显目标示，而且学习时长很长，认真到位。

  • 结对学习内容：共同窗习第十章内容，并就四则运算展开交流，共同编写。

其余（感悟、思考等）

感悟

• 这周进行了多态的学习，课本上的这一章第一次读了一遍以后，印象很模糊，并且不少地方都不太明白，又去读了第二遍，才理解了书上的内容包括例题代码的编写，这一章的编程项目作起来难度不算太大，主要就是对前面的一些题目进行修改，完成的比较快，由于这周也在作结对编程的那个四则运算，时间有些不太够用，可能有些东西本身去想的时间不如以前的多，尽可能克服一下，下周继续。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	157/157	1/1	15/15
第二周	382/539	1/2	16/31
第三周	317/856	2/4	15/46
第四周	996/1852	1/5	24/70
第五周	578/2330	1/6	16/86	这周对上周第七章的学习有了更深的理解
第六周	475/2805	1/7	14/100	学习了数组方面的相关知识
第七周	629/3434	1/8	14/114	关于继承有必定认识
第八周	1567/5001	3/11	25/141

参考资料

• 《Java程序设计与数据结构教程》
• 《Java学习笔记(第8版)》学习指导
• 多态的概念和做用
• Java对象及其引用
• Java的静态绑定与动态绑定
• Java多态和动态绑定