20172302 《程序設計與數據結構》第八週學習總結

時間 2020-05-27

原文原文鏈接

<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/>html

教材學習內容總結

1.綁定（binding）與後綁定（動態綁定）：咱們在程序執行時可能會要求某段代碼來完成一個方法的調用，這被稱爲一個方法調用與一個方法定義的綁定。大多數狀況下，這種綁定是在編譯階段就會完成。可是對於多態性引用，這種綁定會延遲到程序運行時纔會完成，而且要綁定的方法定義取決於當時引用變量所引用的對象，這就是後綁定，或稱爲動態綁定。git

2.後綁定的效率要低於編譯階段的綁定效率，因其須要在程序執行期間去進行判斷，從而綁定與引用變量所引用的對象相對應的方法。程序員

3.由繼承實現多態性：當用類名聲明一個引用變量時，這個變量能夠指向該類的任何一個對象，同時，它也能引用經過繼承與它所聲明的類型有關的任何類的對象。下面這是一個小例子，咱們能夠看到Christmas是Holiday的一個子類，經過這樣的聲明，咱們的day變量就是能夠調用Christmas中的方法，即實際將調用的方法取決於對象的類型而不是引用變量的類型。同時多態機制容許用具備一致性但又特殊的方式處理相似的對象。算法

4.利用接口實現多態性：首先一個接口名能夠用來聲明對象引用變量，一個接口引用變量能夠指向任何實現該接口的類的對象。執行代碼時實際調用的方法將取決於調用發生時接口引用所指向的對象的類型。使用接口引用變量時，只能調用定義在接口中的方法，即便接口引用變量所指向的對象還有一些其餘可用方法，也不能調用。舉一個接口實現多態的小例子：（以下面中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 |this

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 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
解析:這道題目是在問是在什麼階段肯定多態變量所引用的類型，這也是屬於第十章內容。對於多數狀況下的這種請求，這種綁定是發生在編譯階段，可是對於多態性引用，這種綁定要延遲到程序運行才能執行，而且要綁定的方法取決於當時引用變量所引用的對象，這種被延遲的請求事件被稱爲後綁定或動態綁定。
5.Why shouldn't an abstract method be declared final? A . There's nothing wrong with doing so B . Abstract methods cannot be overridden and they must be if a concrete class ever is to be instantiated 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 E . both A and B
解析：這道題目誤選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 B . false
解析：子類是能夠訪問父類的任何實例數據或方法的，同時子類也能夠從新定義父類中的任何實例數據或方法的，從新定義的父類實例數據稱爲影子變量，這個咱們不提倡，但重寫父類的方法這個是常常會使用到的，也是符合規範的。

結對及互評

點評過的同窗博客和代碼

本週結對學習狀況
- 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