20172327 2017-2018-2 《程序设计与数据结构》第八周学习总结-CSDN博客

学号 2017-2018-2 《程序设计与数据结构》第八周学习总结

教材学习内容总结

- 后绑定：

1.术语“多态性”可以理解为“有许多形式”，一个“多态性引用”是可以在不同时间指向不同类型对象的引用变量。利用多态性调用的方法能够由一个调用改变为另一个调用。

2.在多数情况下，绑定发生在编译阶段，但对于多态性引用，这种绑定要延迟到程序运行时才能执行。

3.后绑定的效率低于编译阶段绑定效率，因为后绑定需要在程序执行期间决定所要绑定的定义方法。

4.在Java中，可以用两种方式建立多态性引用：继承方式和接口方式。

- 由继承实现多态性：

1.一个引用变量可以指向有继承关系的任何类的任何对象。

2.一个object引用可以指向任何对象，因为所有类归根结底都是object类的后代类。

3.实际将调用的方法版本取决于对象的类型而不是引用变量的类型。

4.多态性的实质是，每个类很清楚自己如何完成一个指定的行为，并从某种意义来讲，每个类的行为是相同的。多态机制允许用具有一致性但又独特的方式处理类似的对象。

- 利用接口实现多态性：

1.类名可以用于声明对象引用变量，类似地，接口名也可以用做声明对象引用变量的类型。一个接口引用变量可以指向任何实现该接口的类的对象。

2.一个接口引用变量可以指向实现该接口的任何类的任何对象。

3.像基于继承的多态性引用一样（父类名可用做方法参数的类型），接口名也可以用做方法参数的类型，使得任何实现同意接口的类对象都可以作为参数传给方法。

- 排序：

1.排序是将一组元素调整为有序排列的过程。

2.选择排序法：选择法排序算法通过相继地将各值放在自己的最终位置（排序后的位置）来实现数值的有序排列。以多态性方式实现的排序算法可对任何一组可比较的对象排序。
图片QN

3.插入法排序：插入排序法是不断的将一个新元素插入到已经安排好序的数列子集中。在每一轮排序中，将一个未排序的新元素插入到已排序子集中的适当位置，直到整个数列有序排列为止。
图片5E

- 搜索：

1.搜索分为线性搜索和二分搜索

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

public class LSearch   
{   
 public static int[] Data = { 12, 76, 29, 22, 15, 62, 29, 58, 35, 67, 58,   
   33, 28, 89, 90, 28, 64, 48, 20, 77 }; // 输入数据数组   
  
 public static int Counter = 1;    // 查找次数计数变量   
  
 public static void main(String args[])   
 {   
  
  int KeyValue = 22;   
  // 调用线性查找   
  if (Linear_Search((int) KeyValue))   
  {   
   // 输出查找次数   
   System.out.println("");   
   System.out.println("Search Time = " + (int) Counter);   
  }   
  else  
  {   
   // 输出没有找到数据   
   System.out.println("");   
   System.out.println("No Found!!");   
  }   
 }   
  
 // ---------------------------------------------------   
 // 顺序查找   
 // ---------------------------------------------------   
 public static boolean Linear_Search(int Key)   
 {   
  int i; // 数据索引计数变量   
  
  for (i = 0; i < 20; i++)   
  {   
   // 输出数据   
   System.out.print("[" + (int) Data[i] + "]");   
   // 查找到数据时   
   if ((int) Key == (int) Data[i])   
    return true; // 传回true   
   Counter++; // 计数器递增   
  }   
  return false; // 传回false   
 }   
}

运行结果：
[12][76][29][22] Search Time = 4

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

public class BSearch   
{   
 public static int Max  = 20;   
 public static int[] Data = { 12, 16, 19, 22, 25, 32, 39, 48, 55, 57, 58,   
   63, 68, 69, 70, 78, 84, 88, 90, 97 }; // 数据数组   
 public static int Counter = 1;    // 计数器   
  
 public static void main(String args[])   
 {   
  int KeyValue = 22;   
  // 调用折半查找   
  if (BinarySearch((int) KeyValue))   
  {   
   // 输出查找次数   
   System.out.println("");   
   System.out.println("Search Time = " + (int) Counter);   
  }   
  else  
  {   
   // 输出没有找到数据   
   System.out.println("");   
   System.out.println("No Found!!");   
  }   
 }   
  
 // ---------------------------------------------------   
 // 折半查找法   
 // ---------------------------------------------------   
 public static boolean BinarySearch(int KeyValue)   
 {   
  int Left; // 左边界变量   
  int Right; // 右边界变量   
  int Middle; // 中位数变量   
  
  Left = 0;   
  Right = Max - 1;   
  
  while (Left <= Right)   
  {   
   Middle = (Left + Right) / 2;   
   if (KeyValue < Data[Middle]) // 欲查找值较小   
    Right = Middle - 1; // 查找前半段   
   // 欲查找值较大   
   else if (KeyValue > Data[Middle])   
    Left = Middle + 1; // 查找后半段   
   // 查找到数据   
   else if (KeyValue == Data[Middle])   
   {   
    System.out.println("Data[" + Middle + "] = " + Data[Middle]);   
    return true;   
   }   
   Counter++;   
  }   
  return false;   
 }   
}

运行结果：

   Data[3] = 22 
   Search Time = 5

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

问题1：引用变量和对象的含义
问题1解决方案：

Java对象及其引用
关于对象与引用之间的一些基本概念。
       初学Java时，在很长一段时间里，总觉得基本概念很模糊。后来才知道，在许多Java书中，把对象和对象的引用混为一谈。可是，如果我分不清对象与对象引用，
       那实在没法很好地理解下面的面向对象技术。把自己的一点认识写下来，或许能让初学Java的朋友们少走一点弯路。
       为便于说明，我们先定义一个简单的类：
       class Vehicle {
       int passengers;      
       int fuelcap;
       int mpg;
                   }
有了这个模板，就可以用它来创建对象：
       Vehicle veh1 = new Vehicle();
通常把这条语句的动作称之为创建一个对象，其实，它包含了四个动作。
1）右边的“new Vehicle”，是以Vehicle类为模板，在堆空间里创建一个Vehicle类对象（也简称为Vehicle对象）。
2）末尾的()意味着，在对象创建后，立即调用Vehicle类的构造函数，对刚生成的对象进行初始化。构造函数是肯定有的。如果你没写，Java会给你补上一个默认的构造函数。
3）左边的“Vehicle veh 1”创建了一个Vehicle类引用变量。所谓Vehicle类引用，就是以后可以用来指向Vehicle对象的对象引用。
4）“=”操作符使对象引用指向刚创建的那个Vehicle对象。
我们可以把这条语句拆成两部分：
Vehicle veh1;
veh1 = new Vehicle();
效果是一样的。这样写，就比较清楚了，有两个实体：一是对象引用变量，一是对象本身。
       在堆空间里创建的实体，与在数据段以及栈空间里创建的实体不同。尽管它们也是确确实实存在的实体，但是，我们看不见，也摸不着。不仅如此，
       我们仔细研究一下第二句，找找刚创建的对象叫什么名字？有人说，它叫“Vehicle”。不对，“Vehicle”是类（对象的创建模板）的名字。
       一个Vehicle类可以据此创建出无数个对象，这些对象不可能全叫“Vehicle”。
       对象连名都没有，没法直接访问它。我们只能通过对象引用来间接访问对象。
       为了形象地说明对象、引用及它们之间的关系，可以做一个或许不很妥当的比喻。对象好比是一只很大的气球，大到我们抓不住它。引用变量是一根绳， 可以用来系汽球。
       如果只执行了第一条语句，还没执行第二条，此时创建的引用变量veh1还没指向任何一个对象，它的值是null。引用变量可以指向某个对象，或者为null。
       它是一根绳，一根还没有系上任何一个汽球的绳。执行了第二句后，一只新汽球做出来了，并被系在veh1这根绳上。我们抓住这根绳，就等于抓住了那只汽球。
       再来一句：
       Vehicle veh2;
就又做了一根绳，还没系上汽球。如果再加一句：
       veh2 = veh1;
系上了。这里，发生了复制行为。但是，要说明的是，对象本身并没有被复制，被复制的只是对象引用。结果是，veh2也指向了veh1所指向的对象。两根绳系的是同一只汽球。
       如果用下句再创建一个对象：
veh2 = new Vehicle();
则引用变量veh2改指向第二个对象。
       从以上叙述再推演下去，我们可以获得以下结论：
（1）一个对象引用可以指向0个或1个对象（一根绳子可以不系汽球，也可以系一个汽球）；
（2）一个对象可以有N个引用指向它（可以有N条绳子系住一个汽球）。
       如果再来下面语句：
       veh1 = veh2;
按上面的推断，veh1也指向了第二个对象。这个没问题。问题是第一个对象呢？没有一条绳子系住它，它飞了。多数书里说，它被Java的垃圾回收机制回收了。
这不确切。正确地说，它已成为垃圾回收机制的处理对象。至于什么时候真正被回收，那要看垃圾回收机制的心情了。
       由此看来，下面的语句应该不合法吧？至少是没用的吧？
new Vehicle();
不对。它是合法的，而且可用的。譬如，如果我们仅仅为了打印而生成一个对象，就不需要用引用变量来系住它。最常见的就是打印字符串：
    System.out.println(“I am Java!”);
字符串对象“I am Java!”在打印后即被丢弃。有人把这种对象称之为临时对象。
       对象与引用的关系将持续到对象回收

Java在运行时才处理别名引用

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

本周作业过程中，没有多少大问题，都是一些小毛病，所以没有写这个

上周考试错题总结

问题1：Inheritance through an extended (derived) class supports which of the following concepts?
A . interfaces
B . modulary
C . information hiding
D . code reuse
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
C . A laptop is both a PC and a portable device
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
D . polymorphic
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
D . by the Java run-time environment at run time
E . by the user at run time
解析:这道题目是在问是在什么阶段确定多态变量所引用的类型，对于多数情况下的这种请求，这种绑定是发生在编译阶段，但是对于多态性引用，这种绑定要延迟到程序运行才能执行，并且要绑定的方法取决于当时引用变量所引用的对象，这种被延迟的请求事件被称为后绑定或动态绑定。

代码托管

参考示例

点评过的同学博客和代码

本周结对学习情况
- 20172317
- 20172320
- 结对学习内容
  - 教材第10章
  - 阅读10.1-10.6章节
  - 完成课后自测题，并参考答案学习
  - 完成课后练习题
  - 完成程序设计项目：至少完成PP10.1、PP10.4、PP10.5.

其他（感悟、思考等，可选）

这一周状态不好，可能放假打乱了节奏，而且多了一个四则运算需要看，所以没认真看书，所以做的不太好，下周我会调整的。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）
目标	5000行	30篇	400小时
第一周	95/95	1/1	18/18
第二周	515/620	1/2	22/40
第三周	290/910	1/3	20/60
第四周	1741/2651	1/4	30/84
第五周	579/3230	1/5	20/104
第六周	599/3829	2/8	18/122
第七周	732/4561	2/9	24/146
第八周	1354/5915	2/11	30/176