标签：架构   软件   开发   排序算法   结果   步骤   header   成员函数   known   

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

教材学习内容总结

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

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

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

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

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

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

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

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

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解决方案：

1: 什么是权限修饰符，他有什么作用，为什么需要他；

一个Java应用有很多类，但是有些类，并不希望被其他类使用。每个类中都有数据成员和方法成员，但是并不是每个数据和方法，都允许在其他类中调用。如何能做到访问控制呢？就需要使用访问权限修饰符。

2：java中权限修饰符包括4种：

图片：

3: 关于权限修饰符还要注意几个问题；

• 问题2：this和super引用有啥不同：
  
• 问题2解决方案：

• 问题3：Java语言的设计者为啥明确决定不支持多继承？
  
• 问题3解决方案：

James Gosling在1995年2月发表了一篇名为”Java概览”的Java白皮书，文章解释了Java不支持多重继承的原因。

为了强化简单这个特点，这就是我们去除多重继承的原因。下面来看个例子，多重继承的菱形继承问题。

tupian

有两个类B和C继承自A。假设B和C都继承了A的方法并且进行了覆盖，编写了自己的实现。假设D通过多重继承继承了B和C，那么D应该继承B和C的重载方法，那么它应该继承哪个的呢？是B的还是C的呢？

C++中经常会掉入这个陷阱，虽然它也提出了替代的方法来解决这个问题。我们在Java中就不会出现这个问题。就算两个接口拥有同样的方法，实现的类只会有一个方法，这个方法由实现的类编写。动态的加载类会让多重继承的实现变得困难。

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

• 问题1：在做pp9.1时，遇到到了下面这个问题
  图片115054
• 问题1解决方案：这是我对Coin类完全没改造成的，在Coin类中，我们应该将face的修饰符改为protected。
• 问题2：在做pp9.1时，我在测试类中选择创建一个大小为5的数组，但我定义时，只定义了三个，所以最后运行时，无法将sum值算出来。
  图片
• 问题2解决方案：前面一个问题改一下顺序就可以，后面一个问题我又设了一个变量b，把计算过程分开才可以。

上周考试错题总结

• 问题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
• 解析:这道题目是在问是在什么阶段确定多态变量所引用的类型，对于多数情况下的这种请求，这种绑定是发生在编译阶段，但是对于多态性引用，这种绑定要延迟到程序运行才能执行，并且要绑定的方法取决于当时引用变量所引用的对象，这种被延迟的请求事件被称为后绑定或动态绑定。

代码托管

结对及互评

点评模板：

• 博客中值得学习的或问题：

  • xxx
  • ...
• 基于评分标准，我给本博客打分：XX分。得分情况如下：xxx
• 代码中值得学习的或问题：
  • xxx
  • xxx
  • ...

• 基于评分标准，我给本博客打分：XX分。得分情况如下：xxx

• 参考示例

点评过的同学博客和代码

• 本周结对学习情况
  • 20172317
  • 结对照片
  • 结对学习内容
    • XXXX
    • XXXX
    • ...

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

概念很多，嘚仔细看，有很多细节，和前面的章节联系紧密。

学习进度条

参考：软件工程软件的估计为什么这么难，软件工程 估计方法

• 计划学习时间:22小时

• 实际学习时间:24小时

• 改进情况：稍有点

(有空多看看现代软件工程 课件
软件工程师能力自我评价表)

参考资料

• 《Java程序设计与数据结构教程（第二版）》

• 《Java程序设计与数据结构教程（第二版）》学习指导
• Java中this与super的用法总结

• 为什么Java不支持多重继承

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

标签：架构   软件   开发   排序算法   结果   步骤   header   成员函数   known   

原文地址：https://www.cnblogs.com/mrf1209/p/8981520.html