201871010114-李巖鬆《面向對象程序設計（java）》第十二週學習總結

時間 2019-11-17

原文原文鏈接

項目html	內容java
這個做業屬於哪一個課程程序員	https://www.cnblogs.com/nwnu-daizh/web
這個做業的要求在哪裏編程	https://www.cnblogs.com/nwnu-daizh/p/11435127.htmlwindows
做業學習目標數組	(1) 掌握Vetor、Stack、Hashtable三個類的用途及經常使用API；架構 (2) 掌握ArrayList、LinkList兩個類的用途及經常使用API；框架 (3) 瞭解java集合框架體系組成；dom (4) 掌握Java GUI中框架建立及屬性設置中經常使用類的API； (5) 瞭解Java GUI中2D圖形繪製經常使用類的API；

第一部分：總結第九章、第十章理論知識

1、 Collection集合

1.1 集合概述

在前面基礎班咱們已經學習過並使用過集合ArrayList<E> ,那麼集合究竟是什麼呢?

* **集合**：集合是java中提供的一種容器，能夠用來存儲多個數據。

集合和數組既然都是容器，它們有啥區別呢？

* 數組的長度是固定的。集合的長度是可變的。
* 數組中存儲的是同一類型的元素，能夠存儲基本數據類型值。集合存儲的都是對象。並且對象的類型能夠不一致。在開發中通常當對象多的時候，使用集合進行存儲。

1.2  集合框架

JAVASE提供了知足各類需求的API，在使用這些API前，先了解其繼承與接口操做架構，才能瞭解什麼時候採用哪一個類，以及類之間如何彼此合做，從而達到靈活應用。

集合按照其存儲結構能夠分爲兩大類，分別是單列集合`java.util.Collection`和雙列集合`java.util.Map`，今天咱們主要學習`Collection`集合，在day04時講解`Map`集合。

* **Collection**：單列集合類的根接口，用於存儲一系列符合某種規則的元素，它有兩個重要的子接口，分別是`java.util.List`和`java.util.Set`。其中，`List`的特色是元素有序、元素可重複。`Set`的特色是元素無序，並且不可重複。`List`接口的主要實現類有`java.util.ArrayList`和`java.util.LinkedList`，`Set`接口的主要實現類有`java.util.HashSet`和`java.util.TreeSet`。

從上面的描述能夠看出JDK中提供了豐富的集合類庫，爲了便於初學者進行系統地學習，接下來經過一張圖來描述整個集合類的繼承體系。

其中，橙色框裏填寫的都是接口類型，而藍色框裏填寫的都是具體的實現類。這幾天將針對圖中所列舉的集合類進行逐一地講解。

集合自己是一個工具，它存放在java.util包中。在`Collection`接口定義着單列集合框架中最最共性的內容。

1.3 Collection 經常使用功能

Collection是全部單列集合的父接口，所以在Collection中定義了單列集合(List和Set)通用的一些方法，這些方法可用於操做全部的單列集合。方法以下：

* `public boolean add(E e)`：  把給定的對象添加到當前集合中。
* `public void clear()` :清空集合中全部的元素。
* `public boolean remove(E e)`: 把給定的對象在當前集合中刪除。
* `public boolean contains(E e)`: 判斷當前集合中是否包含給定的對象。
* `public boolean isEmpty()`: 判斷當前集合是否爲空。
* `public int size()`: 返回集合中元素的個數。
* `public Object[] toArray()`: 把集合中的元素，存儲到數組中。

方法演示：

~~~java
import java.util.ArrayList;
import java.util.Collection;

public class Demo1Collection {
    public static void main(String[] args) {
        // 建立集合對象
        // 使用多態形式
        Collection<String> coll = new ArrayList<String>();
        // 使用方法
        // 添加功能  boolean  add(String s)
        coll.add("小李廣");
        coll.add("掃地僧");
        coll.add("石破天");
        System.out.println(coll);

        // boolean contains(E e) 判斷o是否在集合中存在
        System.out.println("判斷  掃地僧是否在集合中"+coll.contains("掃地僧"));

        //boolean remove(E e) 刪除在集合中的o元素
        System.out.println("刪除石破天："+coll.remove("石破天"));
        System.out.println("操做以後集合中元素:"+coll);

        // size() 集合中有幾個元素
        System.out.println("集合中有"+coll.size()+"個元素");

        // Object[] toArray()轉換成一個Object數組
        Object[] objects = coll.toArray();
        // 遍歷數組
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }

        // void  clear() 清空集合
        coll.clear();
        System.out.println("集合中內容爲："+coll);
        // boolean  isEmpty()  判斷是否爲空
        System.out.println(coll.isEmpty());
    }
}
~~~

> tips: 有關Collection中的方法可不止上面這些，其餘方法能夠自行查看API學習。

2、Iterator迭代器

2.1 Iterator接口

在程序開發中，常常須要遍歷集合中的全部元素。針對這種需求，JDK專門提供了一個接口`java.util.Iterator`。`Iterator`接口也是Java集合中的一員，但它與`Collection`、`Map`接口有所不一樣，`Collection`接口與`Map`接口主要用於存儲元素，而`Iterator`主要用於迭代訪問（即遍歷）`Collection`中的元素，所以`Iterator`對象也被稱爲迭代器。

想要遍歷Collection集合，那麼就要獲取該集合迭代器完成迭代操做，下面介紹一下獲取迭代器的方法：

* `public Iterator iterator()`: 獲取集合對應的迭代器，用來遍歷集合中的元素的。

下面介紹一下迭代的概念：

* **迭代**：即Collection集合元素的通用獲取方式。在取元素以前先要判斷集合中有沒有元素，若是有，就把這個元素取出來，繼續在判斷，若是還有就再取出出來。一直把集合中的全部元素所有取出。這種取出方式專業術語稱爲迭代。

Iterator接口的經常使用方法以下：

* `public E next()`:返回迭代的下一個元素。
* `public boolean hasNext()`:若是仍有元素能夠迭代，則返回 true。

接下來咱們經過案例學習如何使用Iterator迭代集合中元素：

~~~java
public class IteratorDemo {
      public static void main(String[] args) {
        // 使用多態方式建立對象
        Collection<String> coll = new ArrayList<String>();

        // 添加元素到集合
        coll.add("串串星人");
        coll.add("吐槽星人");
        coll.add("汪星人");
        //遍歷
        //使用迭代器遍歷   每一個集合對象都有本身的迭代器
        Iterator<String> it = coll.iterator();
        //  泛型指的是迭代出元素的數據類型
        while(it.hasNext()){ //判斷是否有迭代元素
            String s = it.next();//獲取迭代出的元素
            System.out.println(s);
        }
      }
}
~~~

> tips:：在進行集合元素取出時，若是集合中已經沒有元素了，還繼續使用迭代器的next方法，將會發生java.util.NoSuchElementException沒有集合元素的錯誤。

2.2 迭代器的實現原理

咱們在以前案例已經完成了Iterator遍歷集合的整個過程。當遍歷集合時，首先經過調用t集合的iterator()方法得到迭代器對象，而後使用hashNext()方法判斷集合中是否存在下一個元素，若是存在，則調用next()方法將元素取出，不然說明已到達了集合末尾，中止遍歷元素。

Iterator迭代器對象在遍歷集合時，內部採用指針的方式來跟蹤集合中的元素，爲了讓初學者能更好地理解迭代器的工做原理，接下來經過一個圖例來演示Iterator對象迭代元素的過程：

在調用Iterator的next方法以前，迭代器的索引位於第一個元素以前，不指向任何元素，當第一次調用迭代器的next方法後，迭代器的索引會向後移動一位，指向第一個元素並將該元素返回，當再次調用next方法時，迭代器的索引會指向第二個元素並將該元素返回，依此類推，直到hasNext方法返回false，表示到達了集合的末尾，終止對元素的遍歷。

2.3 加強for

加強for循環(也稱for each循環)是**JDK1.5**之後出來的一個高級for循環，專門用來遍歷數組和集合的。它的內部原理實際上是個Iterator迭代器，因此在遍歷的過程當中，不能對集合中的元素進行增刪操做。

格式：

~~~java
for(元素的數據類型  變量 : Collection集合or數組){
      //寫操做代碼
}
~~~

它用於遍歷Collection和數組。一般只進行遍歷元素，不要在遍歷的過程當中對集合元素進行增刪操做。

練習1：遍歷數組

~~~java
public class NBForDemo1 {
    public static void main(String[] args) {
        int[] arr = {3,5,6,87};
           //使用加強for遍歷數組
        for(int a : arr){//a表明數組中的每一個元素
            System.out.println(a);
        }
    }
}
~~~

練習2:遍歷集合

~~~java
public class NBFor {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<String>();
        coll.add("小河神");
        coll.add("老河神");
        coll.add("神婆");
        //使用加強for遍歷
        for(String s :coll){//接收變量s表明表明被遍歷到的集合元素
            System.out.println(s);
        }
    }
}
~~~

> tips: 新for循環必須有被遍歷的目標。目標只能是Collection或者是數組。新式for僅僅做爲遍歷操做出現。

3、 List集合

3.1 List接口介紹

`java.util.List`接口繼承自`Collection`接口，是單列集合的一個重要分支，習慣性地會將實現了`List`接口的對象稱爲List集合。在List集合中容許出現重複的元素，全部的元素是以一種線性方式進行存儲的，在程序中能夠經過索引來訪問集合中的指定元素。另外，List集合還有一個特色就是元素有序，即元素的存入順序和取出順序一致。

看完API，咱們總結一下：

List接口特色：

1. 它是一個元素存取有序的集合。例如，存元素的順序是十一、2二、33。那麼集合中，元素的存儲就是按照十一、2二、33的順序完成的）。
2. 它是一個帶有索引的集合，經過索引就能夠精確的操做集合中的元素（與數組的索引是一個道理）。
3. 集合中能夠有重複的元素，經過元素的equals方法，來比較是否爲重複的元素。

> tips:咱們在基礎班的時候已經學習過List接口的子類java.util.ArrayList類，該類中的方法都是來自List中定義。

3.2 List接口中經常使用方法

List做爲Collection集合的子接口，不但繼承了Collection接口中的所有方法，並且還增長了一些根據元素索引來操做集合的特有方法，以下：

- `public void add(int index, E element)`: 將指定的元素，添加到該集合中的指定位置上。
- `public E get(int index)`:返回集合中指定位置的元素。
- `public E remove(int index)`: 移除列表中指定位置的元素, 返回的是被移除的元素。
- `public E set(int index, E element)`:用指定元素替換集合中指定位置的元素,返回值的更新前的元素。

List集合特有的方法都是跟索引相關，咱們在基礎班都學習過，那麼咱們再來複習一遍吧：

```java
public class ListDemo {
    public static void main(String[] args) {
        // 建立List集合對象
        List<String> list = new ArrayList<String>();

        // 往尾部添加指定元素
        list.add("圖圖");
        list.add("小美");
        list.add("不高興");

        System.out.println(list);
        // add(int index,String s) 往指定位置添加
        list.add(1,"沒頭腦");

        System.out.println(list);
        // String remove(int index) 刪除指定位置元素  返回被刪除元素
        // 刪除索引位置爲2的元素
        System.out.println("刪除索引位置爲2的元素");
        System.out.println(list.remove(2));

        System.out.println(list);

        // String set(int index,String s)
        // 在指定位置進行元素替代（改）
        // 修改指定位置元素
        list.set(0, "三毛");
        System.out.println(list);

        // String get(int index)  獲取指定位置元素

        // 跟size() 方法一塊兒用  來遍歷的
        for(int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        //還可使用加強for
        for (String string : list) {
            System.out.println(string);
        }
    }
}
```

4、List的子類

4.1 ArrayList集合

`java.util.ArrayList`集合數據存儲的結構是數組結構。元素增刪慢，查找快，因爲平常開發中使用最多的功能爲查詢數據、遍歷數據，因此`ArrayList`是最經常使用的集合。

許多程序員開發時很是隨意地使用ArrayList完成任何需求，並不嚴謹，這種用法是不提倡的。

4.2 LinkedList集合

`java.util.LinkedList`集合數據存儲的結構是鏈表結構。方便元素添加、刪除的集合。

> LinkedList是一個雙向鏈表，那麼雙向鏈表是什麼樣子的呢，咱們用個圖瞭解下

實際開發中對一個集合元素的添加與刪除常常涉及到首尾操做，而LinkedList提供了大量首尾操做的方法。這些方法咱們做爲了解便可：

* `public void addFirst(E e)`:將指定元素插入此列表的開頭。
* `public void addLast(E e)`:將指定元素添加到此列表的結尾。
* `public E getFirst()`:返回此列表的第一個元素。
* `public E getLast()`:返回此列表的最後一個元素。
* `public E removeFirst()`:移除並返回此列表的第一個元素。
* `public E removeLast()`:移除並返回此列表的最後一個元素。
* `public E pop()`:今後列表所表示的堆棧處彈出一個元素。
* `public void push(E e)`:將元素推入此列表所表示的堆棧。
* `public boolean isEmpty()`：若是列表不包含元素，則返回true。

LinkedList是List的子類，List中的方法LinkedList都是可使用，這裏就不作詳細介紹，咱們只須要了解LinkedList的特有方法便可。在開發時，LinkedList集合也能夠做爲堆棧，隊列的結構使用。（瞭解便可）

方法演示：

~~~java
public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> link = new LinkedList<String>();
        //添加元素
        link.addFirst("abc1");
        link.addFirst("abc2");
        link.addFirst("abc3");
        System.out.println(link);
        // 獲取元素
        System.out.println(link.getFirst());
        System.out.println(link.getLast());
        // 刪除元素
        System.out.println(link.removeFirst());
        System.out.println(link.removeLast());

        while (!link.isEmpty()) { //判斷集合是否爲空
            System.out.println(link.pop()); //彈出集合中的棧頂元素
        }

        System.out.println(link);
    }
}
~~~

5、Set接口

`java.util.Set`接口和`java.util.List`接口同樣，一樣繼承自`Collection`接口，它與`Collection`接口中的方法基本一致，並無對`Collection`接口進行功能上的擴充，只是比`Collection`接口更加嚴格了。與`List`接口不一樣的是，`Set`接口中元素無序，而且都會以某種規則保證存入的元素不出現重複。

`Set`集合有多個子類，這裏咱們介紹其中的`java.util.HashSet`、`java.util.LinkedHashSet`這兩個集合。

> tips:Set集合取出元素的方式能夠採用：迭代器、加強for。

5.1 HashSet集合介紹

`java.util.HashSet`是`Set`接口的一個實現類，它所存儲的元素是不可重複的，而且元素都是無序的(即存取順序不一致)。`java.util.HashSet`底層的實現實際上是一個`java.util.HashMap`支持，因爲咱們暫時還未學習，先作了解。

`HashSet`是根據對象的哈希值來肯定元素在集合中的存儲位置，所以具備良好的存取和查找性能。保證元素惟一性的方式依賴於：`hashCode`與`equals`方法。

咱們先來使用一下Set集合存儲，看下現象，再進行原理的講解:

~~~java
public class HashSetDemo {
    public static void main(String[] args) {
        //建立 Set集合
        HashSet<String>  set = new HashSet<String>();

        //添加元素
        set.add(new String("cba"));
        set.add("abc");
        set.add("bac");
        set.add("cba");
        //遍歷
        for (String name : set) {
            System.out.println(name);
        }
    }
}
~~~

輸出結果以下，說明集合中不能存儲重複元素：

~~~
cba
abc
bac
~~~

> tips:根據結果咱們發現字符串"cba"只存儲了一個，也就是說重複的元素set集合不存儲。

2.2  HashSet集合存儲數據的結構（哈希表）

什麼是哈希表呢？

在**JDK1.8**以前，哈希表底層採用數組+鏈表實現，即便用鏈表處理衝突，同一hash值的鏈表都存儲在一個鏈表裏。可是當位於一個桶中的元素較多，即hash值相等的元素較多時，經過key值依次查找的效率較低。而JDK1.8中，哈希表存儲採用數組+鏈表+紅黑樹實現，當鏈表長度超過閾值（8）時，將鏈表轉換爲紅黑樹，這樣大大減小了查找時間。

簡單的來講，哈希表是由數組+鏈表+紅黑樹（JDK1.8增長了紅黑樹部分）實現的，以下圖所示。

看到這張圖就有人要問了，這個是怎麼存儲的呢？

爲了方便你們的理解咱們結合一個存儲流程圖來講明一下：

總而言之，**JDK1.8**引入紅黑樹大程度優化了HashMap的性能，那麼對於咱們來說保證HashSet集合元素的惟一，其實就是根據對象的hashCode和equals方法來決定的。若是咱們往集合中存放自定義的對象，那麼保證其惟一，就必須複寫hashCode和equals方法創建屬於當前對象的比較方式。

5.3  HashSet存儲自定義類型元素

給HashSet中存放自定義類型元素時，須要重寫對象中的hashCode和equals方法，創建本身的比較方式，才能保證HashSet集合中的對象惟一

建立自定義Student類

~~~java
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;
        Student student = (Student) o;
        return age == student.age &&
               Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
~~~

~~~java
public class HashSetDemo2 {
    public static void main(String[] args) {
        //建立集合對象   該集合中存儲 Student類型對象
        HashSet<Student> stuSet = new HashSet<Student>();
        //存儲
        Student stu = new Student("于謙", 43);
        stuSet.add(stu);
        stuSet.add(new Student("郭德綱", 44));
        stuSet.add(new Student("于謙", 43));
        stuSet.add(new Student("郭麒麟", 23));
        stuSet.add(stu);

        for (Student stu2 : stuSet) {
            System.out.println(stu2);
        }
    }
}
執行結果：
Student [name=郭德綱, age=44]
Student [name=于謙, age=43]
Student [name=郭麒麟, age=23]
~~~

5.3 LinkedHashSet

咱們知道HashSet保證元素惟一，但是元素存放進去是沒有順序的，那麼咱們要保證有序，怎麼辦呢？

在HashSet下面有一個子類`java.util.LinkedHashSet`，它是鏈表和哈希表組合的一個數據存儲結構。

演示代碼以下:

~~~java
public class LinkedHashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new LinkedHashSet<String>();
        set.add("bbb");
        set.add("aaa");
        set.add("abc");
        set.add("bbc");
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}
結果：
  bbb
  aaa
  abc
  bbc
~~~

5.9  可變參數

在**JDK1.5**以後，若是咱們定義一個方法須要接受多個參數，而且多個參數類型一致，咱們能夠對其簡化成以下格式：

```
修飾符返回值類型方法名(參數類型... 形參名){  }
```

其實這個書寫徹底等價與

```
修飾符返回值類型方法名(參數類型[] 形參名){  }
```

只是後面這種定義，在調用時必須傳遞數組，而前者能夠直接傳遞數據便可。

**JDK1.5**之後。出現了簡化操做。**...** 用在參數上，稱之爲可變參數。

一樣是表明數組，可是在調用這個帶有可變參數的方法時，不用建立數組(這就是簡單之處)，直接將數組中的元素做爲實際參數進行傳遞，其實編譯成的class文件，將這些元素先封裝到一個數組中，在進行傳遞。這些動做都在編譯.class文件時，自動完成了。

代碼演示：

```java
public class ChangeArgs {
    public static void main(String[] args) {
        int[] arr = { 1, 4, 62, 431, 2 };
        int sum = getSum(arr);
        System.out.println(sum);
        //  6  7  2 12 2121
        // 求這幾個元素和 6  7  2 12 2121
        int sum2 = getSum(6, 7, 2, 12, 2121);
        System.out.println(sum2);
    }

    /*
     * 完成數組  全部元素的求和原始寫法

      public static int getSum(int[] arr){
        int sum = 0;
        for(int a : arr){
            sum += a;
        }

        return sum;
      }
    */
    //可變參數寫法
    public static int getSum(int... arr) {
        int sum = 0;
        for (int a : arr) {
            sum += a;
        }
        return sum;
    }
}
```

> tips: 上述add方法在同一個類中，只能存在一個。由於會發生調用的不肯定性
> 注意：若是在方法書寫時，這個方法擁有多參數，參數中包含可變參數，可變參數必定要寫在參數列表的末尾位置。

第十章圖形程序設計知識點總結：

一、swing概述:swing基於AWT架構之上,Swing是指被繪製的用戶界、面類,AWT是指像事件處理這樣的窗口工具箱的底層機制,Swing可讓用戶隨意的選擇喜歡的感官。

二、框架:沒有包含在其餘窗口中的窗口被稱爲框架(frame),在AWT中有一個Frame類,是用來描述框架的,這個類在Swing版本中是JFrame(絕大數的Swing組件都有J開頭),它是極少數幾個不繪製在畫布上的Swing組件之一,它的修飾部件(如按鈕,標題欄,圖標等)由用戶的窗口系統繪製,而不是由Swing繪製,Swing用來繪製框架裏的內容。

JFrame.setVisible(true)方法可讓框架可見,

JFrame.show()可讓框架可見而且置於其餘窗口的前面。

JFrame.setDefaultCloseOperation(int i)能夠定義關閉這個框架時候的響應動做,讓程序退出的常量是JFrame.EXIT_ON_CLOSE。(以上方法都不是靜態方法!)在初始化完後,main方法退出,這個時候程序並無終止,終止的只是主線程,事件調度線程保持程序處於激活狀態,直到關閉框架或者調用System.exit。

三、改變框架:

3.一、Component類:setVisible(boolean bool)設置窗口是否顯示;

set||getSize(int w,int h||Dimension d)設置/獲取大小;

set||getLocation(int x,int y)設置獲取位置,setBounds(int x,int y,int w,int h)設置位置和大小。

3.二、windows類:toBack()將窗口移動到桌面窗口棧的後面 ;

toFront()將窗口移動到桌面的前面;

setLocationByPlatfrom(boolean bool)由平臺選擇一個合適的位置顯示窗口。

3.三、Frame類: isResizable(boolean bool)是否可讓用戶改變大小;

setTitle(String str)設置標題;

setIconImage(Image img)設置框架的圖標。

setUndecorate(boolean bool)框架顯示中的標題欄以及關閉按鈕這些是否顯示;

setExtendedState(int state)設置窗口的狀態,如Frame.ICONIFIED可讓窗口最小化。

3.四、Toolkit類:getDefaultToolkit()返回一個默認的工具箱;

Dimension getScreen()返回用戶屏幕的尺寸;

Image getImage(String filename)加載獲得一個指定的圖像對象。

四、繪製組件:繪製一個組件,須要定義一個擴展JComponent的類,並覆蓋其中的paintComponent(Graphics g)方法,在JAVA中,全部的繪製都必須使用Craphics對象。只要窗口須要從新繪圖時,事件處理器就會通告組件,從而執行全部組件的paintComponent方法。不用本身調用paintComponent方法,在應用程序須要從新繪圖的時候,這個方法會自動的被調用,若是須要強制從新繪製組件,那麼要調用的是repaint方法,他將引起採用相應配置的Graphics對象調用全部組件的paintComponent方法。

4.一、JFrame類:getContentPane()返回框架裏的內容窗口;

add(Component comp)將一個給定的組件添加到該框架的內容窗口中。

4.二、Component類:repaint()從新繪製組件。

4.三、JPanel類是一個能夠包含其餘組件的容器,但一樣也能夠在其上面進行繪製。

五、繪製2D圖形:主要是用java.awt.Graphics2D類去繪製圖形的。圖形的類主要在java.awt.geom裏。要掌握這些之間的關係。

paintComponent方法能夠自動得到一個Graphics對象,能夠把他強制轉型成Graphics2D對象。

第二部分：實驗部分

1、實驗目的與要求

(1) 掌握Vetor、Stack、Hashtable三個類的用途及經常使用API；

(2) 掌握ArrayList、LinkList兩個類的用途及經常使用API。

(3) 掌握Java GUI中框架建立及屬性設置中經常使用類的API；

(4) 應用結對編程（Pair programming），體驗程序開發中的兩人合做。

2、實驗內容和步驟

實驗1： 導入第9章示例程序，測試程序並進行代碼註釋。

測試程序1：

l 使用JDK命令運行編輯、運行如下三個示例程序，結合運行結果理解程序；

掌握Vetor、Stack、Hashtable三個類的用途及經常使用API

//示例程序1
import java.util.Vector;
class Cat {
     private int catNumber;
     Cat(int i) {
        catNumber = i;
    }
     void print() {
        System.out.println("Cat #" + catNumber);
     }
}
public class Cats{
public static void main(String[] args){
       Vector<Cat> cats= new Vector<Cat>();
       for(int i=0; i<7; i++)
           cats.addElement(new Cat(i)); 
       for(int i=0; i<cats.size(); i++)
           (cats.elementAt(i)).print();
   }
}

運行結果：

//示例程序2
package 集合;

import java.util.Stack;

public class Stacks {
    static String[] months = { "金", "銀", "銅", "鐵" };

    public static void main(String[] args) {
        Stack<String> stk = new Stack<String>();
        for (int i = 0; i < months.length; i++)
            stk.push(months[i]);
        System.out.println(stk);
        System.out.println("element2=" + stk.elementAt(2));

        while (!stk.empty()) {
            System.out.println(stk.pop());
        }
    }
}

運行結果：

//示例程序3
import java.util.*;
class Counter {
    int i = 1;
    public String toString() {
        return Integer.toString(i);
    }
}

public class Statistics {
    public static void main(String[] args) {
        Hashtable ht = new Hashtable();
        for (int i = 0; i < 10000; i++) {
            Integer r = new Integer((int) (Math.random() * 20));
if(ht.containsKey(r))
              ((Counter)ht.get(r)).i++;
          else
              ht.put(r, new Counter());
}
        System.out.println(ht);
    }

運行結果：

測試程序2：

l 使用JDK命令編輯運行ArrayListDemo和LinkedListDemo兩個程序，結合程序運行結果理解程序；

import java.util.*;

public class ArrayListDemo {
    public static void main(String[] argv) {
        ArrayList al = new ArrayList();
        // Add lots of elements to the ArrayList...
        al.add(new Integer(11));
        al.add(new Integer(12));
        al.add(new Integer(13));
        al.add(new String("hello"));
        // First print them out using a for loop.
        System.out.println("Retrieving by index:");
        for (int i = 0; i < al.size(); i++) {
            System.out.println("Element " + i + " = " + al.get(i));
        }
     }
}

運行結果：

package 集合;

import java.util.LinkedList;
import java.util.ListIterator;

public class LinkedListDemo {
    public static void main(String[] argv) {
        LinkedList l = new LinkedList();
        l.add(new Object());
        l.add("Hello");
        l.add("zhangsan");
        ListIterator li=l.listIterator(0);// listIterator(int index) 構造器，能夠從指定下標處開始遍歷
        while(li.hasNext())
            System.out.println(li.next());
        if(l.indexOf("Hello")<0)//public int indexOf(int ch): 返回指定字符在字符串中第一次出現處的索引，若是此字符串中沒有這樣的字符，則返回 -1。
            System.out.println("Lookup does not work");
        else
            System.out.println("Lookup works");                
    }
}

運行結果：

l 在Elipse環境下編輯運行調試教材360頁程序9-1，結合程序運行結果理解程序；

l 掌握ArrayList、LinkList兩個類的用途及經常使用API。

package 集合;

import java.util.*;

/**
 * This program demonstrates operations on linked lists.
 * @version 1.12 2018-04-10
 * @author Cay Horstmann
 */
public class LinkedListTest
{
   public static void main(String[] args)
   {
      var a = new LinkedList<String>();
      a.add("Amy");
      a.add("Carl");
      a.add("Erica");

      var b = new LinkedList<String>();
      b.add("Bob");
      b.add("Doug");
      b.add("Frances");
      b.add("Gloria");

      // merge the words from b into a

      ListIterator<String> aIter = a.listIterator();
      Iterator<String> bIter = b.iterator();

      while (bIter.hasNext())
      {
         if (aIter.hasNext()) aIter.next();
         aIter.add(bIter.next());
      }

      System.out.println(a);

      // remove every second word from b

      bIter = b.iterator();
      while (bIter.hasNext())
      {
         bIter.next(); // skip one element
         if (bIter.hasNext())
         {
            bIter.next(); // skip next element
            bIter.remove(); // remove that element
         }
      }

      System.out.println(b);

      // bulk operation: remove all words in b from a

      a.removeAll(b);

      System.out.println(a);
   }
}

運行結果：

實驗2：導入第10章示例程序，測試程序並進行代碼註釋。

測試程序1：

l 運行下列程序，觀察程序運行結果。

package 集合;

import javax.swing.JFrame;

public class SimpleFrameTest {
        public static void main(String[] args)
        {
            JFrame frame=new JFrame();
            frame.setBounds(0,0,300,200);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setVisible(true);
        }
    }

運行結果：

l 在elipse IDE中調試運行教材407頁程序10-1，結合程序運行結果理解程序；與上面程序對比，思考異同；

l 掌握空框架建立方法；

l 瞭解主線程與事件分派線程概念；

l 掌握GUI頂層窗口建立技術。

package 圖像程序設計;

import java.awt.EventQueue;

import javax.swing.JFrame;

public class SimpleFrameTest {
   public static void main(String[] args) {
       EventQueue.invokeLater(()->
       {
          SimpleFrame frame=new SimpleFrame();
          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//是設置用戶在此窗體上發起 "close" 時默認執行的操做。必須指定如下選項之一：
          frame.setVisible(true);//setVisible方法：程序框是否是在界面可見的
          frame.setTitle("Hello world");//用於改變標題欄的文字
       });
       
   }
    
}

運行結果：

測試程序2：

l 在elipse IDE中調試運行教材412頁程序10-2，結合運行結果理解程序；

l 掌握肯定框架經常使用屬性的設置方法。

package 圖像程序設計;

import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Image;
import java.awt.Toolkit;

import javax.swing.ImageIcon;
import javax.swing.JFrame;


public class SizedFrameTest{

    public static void main(String[] args)
    {
        EventQueue.invokeLater(()->
        {
          JFrame frame=new SizedFrame();
          frame.setTitle("SizedFrame");
          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          frame.setVisible(true);
        });
    }
}
class SizedFrame extends JFrame{
        public SizedFrame() {
              //get screen dimensions
            Toolkit  kit=Toolkit.getDefaultToolkit();//調用Toolkit類的靜態方法，getDefaultTookit獲得Tookit對象
            Dimension screenSize=kit.getScreenSize();//獲得屏幕的尺寸
            int screenHeight=screenSize.height;
            int screenWidth=screenSize.width;
            
            setSize(screenWidth/2,screenHeight/2);
            setLocationByPlatform(true);
            
            //set frame icon
            Image img=new ImageIcon("F:\\照片\\2019-05\\3e22741e711cf0b01c0e52dc4efc587b.jpg").getImage();
            setIconImage(img);    
        }
}

運行結果：

測試程序3：

l 在elipse IDE中調試運行教材418頁程序10-3，結合運行結果理解程序；

l 掌握在框架中添加組件；

l 掌握自定義組件的用法。

package 圖像程序設計;

import java.awt.EventQueue;

import javax.swing.JFrame;

public class NotHelloWorld {
    public static void main(String[] args)
    {
            EventQueue.invokeLater(()->
            {
             JFrame frame=new NotHelloWorldFrame();
             frame.setTitle("NotHelloWorld");
             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
             frame.setVisible(true);
            });
    }

}

package 圖像程序設計;

import java.awt.Dimension;
import java.awt.Graphics;

import javax.swing.JComponent;

public class NotHelloWorldComponent extends JComponent {
              public static final int MESSAGE_X=75;
              public static final int MESSAGE_Y=100;
              
              private static final int DFFAULT_WIDTH=300;
              private static final int DFFAULT_HEIGHT=300;
              
              public void paintComponent(Graphics g)
              {
                  g.drawString("Not a Hello,World program", MESSAGE_X, MESSAGE_Y);
              }
              public Dimension getPreferredSize() {
                  return new Dimension( DFFAULT_WIDTH,DFFAULT_HEIGHT);
              }
}

package 圖像程序設計;

import javax.swing.JFrame;

public class NotHelloWorldFrame extends JFrame {
        public NotHelloWorldFrame()
        {
            add(new NotHelloWorldComponent());
            pack();
        }
}

運行結果：

關於結對編程：

l 如下圖片是一個結對編程場景：兩位學習夥伴坐在一塊兒，面對着同一臺顯示器，使用着同一鍵盤，同一個鼠標，他們一塊兒思考問題，一塊兒分析問題，一塊兒編寫程序

l 關於結對編程的闡述可參見如下連接：

http://www.cnblogs.com/xinz/archive/2011/08/07/2130332.html

http://en.wikipedia.org/wiki/Pair_programming

l 對於結對編程中代碼設計規範的要求參考：

http://www.cnblogs.com/xinz/archive/2011/11/20/2255971.html

實驗總結：

個人感覺：本週主要學習了Vetor、Stack、Hashtable三個類的用途及經常使用API，ArrayList、LinkList兩個類的用途及經常使用API，同時對於集合的知識進行了更加深刻的學習，同時也學習了圖形用戶界面設計有關的知識，經過本章的學習我瞭解瞭如何用一些組件去畫字，圖形。瞭解了建立框架時的一些經常使用API，圖形用戶界面的一些基礎的設計操做，好比窗口顯示不一樣圖形，文字等等，以爲頗有意思；但實際用這些知識本身去設計圖形仍是會有必定的難度。經過練習題集練習學過的內容，對學過的知識進行了再鞏固，加深了理解。