201871010121-王方-《面向對象程序設計（java）》第十二週學習總結

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

第一部分 基礎知識總結

1、Java集合框架

Java提供的一組類：Vector、Stack、Hashtable、BitsSet與Enumeration接口。其中Enumeration接口提供了一種用於訪問任意容器中各個元素的抽象機制。

1.將集合的接口與實現分離

（a）隊列接口指出能夠在隊列尾部添加元素，在隊列的頭部添加元素，而且能夠查找隊列中元素的個數。有「先進先出」的規則。

隊列接口的簡單形式，例如:

public interface Queue<E>//a simplified form of the interface in the standard library
{ void add(E element); E remove(); int size(); }

（b）隊列的兩種實現方式：

（1）使用循環數組：例ArrayQueue類（2）使用鏈表:例 LinkedList類； 每個實現均可以經過一li個實現了Queue接口的類表示。

（c）只有在構建集合對象時，使用具體的類纔有意義。可使用接口類型存放集合的引用。

Queue<Customer> expressLane  = new CircularArrayQueue<>(100); expressLane.add(new Customer("Harry"));

利用這種方式，當想法改變時，是須要改變調用構造器的地方便可。循環數組是一個遊街集合，即容量有限。

2.Collection接口

java中集合的基本接口爲Collection接口。這個接口有兩個基本方法，例以下：

 

public interface Collection<E>
 {
   boolean  add(E element);
   Iterator<E> iterator();
   ...
}

 

add方法用於向集合中添加元素，若是添加的元素確實改變了集合就返回true，若是集合沒有發生改變就返回false.  iterator方法用於返回一個實現了Iterator接口的對象。可使用這個迭代對象一次訪問集合中的元素。

3.迭代器

iterator接口包含四個方法：

public interface Iterator<E>
{
    E next();
    boolean hasNext();
    void remove();
    default  void forEachRemaning(Consumer<? super  E>action);
}

反覆調用next方法，能夠逐個訪問集合中的每一個元素。當到達集合末尾時，next將會輸出NoSuchElementException.所以，在調用next以前調用hasNext方法。若是迭代對象還有多個供訪問的元素，這個方法就返回true。

若是想要查看集合中的全部元素，就請求一個迭代器，並在hasNext返回ture時反覆地調用next方法。Collection接口擴展Iterable接口。所以，標準類庫中的任何集合均可以使用「for each」循環。

元素被訪問的順序取決於於集合類型。應該將java迭代器認爲是 位於兩個元素之間的。當調用next時，迭代器就超過下一個元素，並返回剛剛越過的哪一個元素的引用。

Interator接口的remove方法將會刪除上次調用next時返回的元素。next和remove方法的調用具備相互依賴性。若是調用remove以前沒有調用next時不合法的。例如：

it.remove();
it.next();
it.remove();//OK

4.泛型實用方法

Collection與Iterator都是泛型接口，能夠編寫操做任何集合類型的實用方法。另外，Collectio接口聲明瞭不少方法。例如：

Iterator<E> iterator()//返回一個用於訪問集合中每一個元素的迭代器

int size()//返回當前存儲在集合中的元素個數

boolean add(Object element)//將一個元素添加在集合中。若是這個調用改變了集合，返回true。

boolean remove(Object obj)從這個集合中刪除等於obj的對象。若是有匹配的對象被刪除，返回true.

List是一個有序集合。元素會增長到容器中的特定位置。有兩種方法：(1)使用迭代器訪問(2)使用一個整數索引來訪問（隨機訪問），由於這樣能夠按任意順序訪問元素。可是，使用迭代器訪問時，必須順序地訪問元素。List接口定義的多個隨機訪問方法：void add(int index,E element)    void remove(int index)  E get(int index)  E  set(int index, E element)

ListIterator接口時Iterator的一個子接口。它定義了一個方法用於在迭代器位置前面增長一個元素：void  add(E element).

2、具體的集合

1.鏈表

在java語言中，，全部列表實際上都是雙向連接的——每個還存放着指向前驅節點的引用。鏈表是一個有序集合。

2.數組列表

List接口用於描述有序集合，且有兩種中訪問元素的協議，（a）用迭代器（b）用get和set方法隨機地訪問每一個元素。第二章方法不適用於鏈表卻適用於數組，集合類提供了熟悉的ArrayList類，這個類也實現了List接口。

ArrayList封裝了一個每一個列表稱爲桶動態再分配的對象數組。

3.散列表

散列表由米娜子就可看出時沒有肯定位置的。可是散列表會爲每個元素對象計算一個整數，稱爲散列碼。散列碼是由對象的實例域產生的一個整數。或者說，具備不一樣數據域的對象產生不一樣的散列碼。

在java中，散列表用數組列表實現。在散列表中由有：    HashSet()//用來構造新散列表........

4.樹集

樹集是一個有序集合。能夠以任意順序將元素插入到集合中。自對集合進行遍歷時，每一個值將自動地按排序後的順序呈現。建立一個樹集的方法爲：TreeSet()

5.隊列與雙端隊列

有兩個端頭的隊列稱爲雙端隊列。可在頭部和尾部同時添加或者刪除元素。不支持在隊列中間插入。

6.優先級隊列

可按任意順序插入的元素，但按照排序的順序進行檢索。優先級隊列用了堆（能夠自我調整的二叉樹）。一個優先級對象能夠保存實現了Comparable接口的類對象，也能夠保存在構造器中提供的Comparator對象。

3、映射

當咱們知道某些關鍵信息且想茶軸與之對應的元素時的這種接口可稱之爲映射。映射用來存放鍵/值對。

1.映射的基本操做

java類庫爲映射提供了兩個實現：HashMap和TreeMap。這兩個類都實現了Map接口。每當往映射中添加對象時，必須同時提供一個鍵，這裏，鍵是一個字符串，對應的值是Employee對象。

並且，鍵必須是惟一的，不能對同一個鍵存放兩個值。

2.更新映射項

（1）能夠用getOrDefault方法（2）調用putIfAbsent方法，只有當鍵原先存在時纔會放入一個值。merge方法能夠簡化這個操做。

3.映射視圖

集合框架能夠獲得映射的視圖。這是實現了Collection接口或某個子接口的對象。

4.弱散列映射

5.連接散列集與映射

連接散列映射將用訪問順序，而不是插入順序，對映射條目進行迭代。

6.枚舉集與映射

EnumSet是一個枚舉類型元素集的高效實現。枚舉類型只有有限個實例，因此EnumSet內部用序列實現。EnumMap是一個鍵類型爲美劇類型的映射。它能夠直接且有效的用一個數值組實現。

7.標識散列映射

4、視圖與包裝器

 1.什麼時視圖？

          在Java的集合中，咱們能夠經過視圖(View)得到其餘的實現了Collection接口和Map接口的對象。例如，咱們在使用Map類的keySet方法能夠得到一個Set集合對象。初看起來，這個方法建立一個新的set集合，

而且將Map中全部的鍵都填進去，而後返回這個集合。可是，狀況而且如此，keySet方法返回一個實現Set接口的類對象，這個類的方法對原來的Map對象進行操做。這個集合就稱爲 視圖(View)

2.輕量級集合包裝器

  (1). Arrays.asList方法

  在Arrays類中有一個靜態方法--asList方法，這個方法做用是：將普通的Java數組包裝成一個List集合。例如：

String []strings = new String[10];
strings[0] = "pby";
strings[1] = "pby1";
strings[2] = "pby2";
List<String> stringList = Arrays.asList(strings);

   返回的對象不是一個ArrayList對象。它就是一個視圖對象，這個對象帶有底層數組的get和set方法。

  那這個視圖對象與普通的List或者ArrayList對象有什麼區別嗎？
  在這裏，視圖對象不能操做全部改變數組大小的方法(好比說，add方法和remove方法)，在調用這些方法的時候，程序會拋出一個UnsupportedOperationException異常；可是普通的List對象可以正常的調用改變數組大小的方法。

(2). Collections.nCopies方法

  與Arrays.asList方法相似的另外一個方法那就是在Collection中的nCopies方法。例如：

List<String> stringList = Collections.nCopies(100, "pby");

上面的代碼將建立一個包含100個"pby"字符串的List集合對象。這樣的操做優點在於存儲代價很小，由於這個對象不能修改大小。這就是視圖技術的一種巧妙應用。

3.子範圍

 

 在Java中，咱們還能夠給 不少的集合創建 子範圍視圖。例如，假設有一個集合對象list，咱們想要從中取出第10個~第19個元素。可使用subList方法來得到一個List集合對象的子範圍視圖。例如：

 List<String> list = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            list.add("" + i);
        }
        System.out.println(list);
        //獲取第10個~第19個
        List<String> list2 = list.subList(9, 20);
        
        System.out.println(list2);
        System.out.println(list);
        //清空自子範圍視圖以後，原來的List集合對象相應位置的數據也會被自動清空的
        list2.clear();
        System.out.println(list2);
        System.out.println(list);

4，不可修改的視圖

 Collections還有幾個方法，用於產生集合的不可修改視圖。這些視圖對現有的集合增長了一個運行時的檢查。若是發現對集合進行修改的話(這裏不只僅是改變數組的大小，而且包括set之類的方法)，就會拋出一個異常，同時這個集合將保持未修改的狀態。
  可使用以下8種方法來得到不可修改的視圖：

  1. Collections.unmodifiableCollection

  2. Collections.unmodifiableList

  3. Collections.unmodifiableSet

  3. Collections.unmodifiableSortedSet

  5. Collections.unmodifiableNavigableSet

  6. Collections.unmodifiableMap

  7. Collections.unmodifiableSortedMap

  8. Collections.unmodifiableNavigableMap

  每一個方法都定義於一個接口。例如，Collections.unmodifiableList方法定義於List接口，與ArrayList、LinkedList或者任何實現了List接口的其餘類一塊兒協同工做。
  例如，假設想要查看某個集合的內容，可是又能避免這個集合會被修改的狀況，就能夠進行下列的操做：

 LinkedList<String> list = new LinkedList<>();
        list.add("pby");
        list.add("pby2");
        List<String> list2 = Collections.unmodifiableList(list);
        //是不能被修改的
        //list2.set(0, "dasdas");

 Collections.unmodifiableList方法將返回一個List集合的對象(視圖對象)，咱們能夠從這個視圖對象中取得內容，可是不能修改，由於在個視圖對象中，全部修改類型的方法已經被從新定義爲一個拋出UnsupportOperationException的異常，而不是將方法的調用傳遞給底層集合對象(這裏底層集合對象指的就是當前List集合對象的實際類型對象，這種調用方式是因爲Java的多態性致使的)。
  可是咱們這裏須要注意的是，不可更改的視圖對象並非指集合自己不可修改，咱們仍然能夠經過集合原來的引用來(猶如上面例子中的list)對集合進行修改。同時，若是原來的引用修改了集合，那麼視圖對象的內容也是跟着變化的。

5.同步視圖

若是多個線程訪問集合，就確保集合不會被意外的破壞。例如，若是一個線程視圖將元素添加到Hash表中，同一個另外一個線程正在對Hash表進行再散列，這種操做的結果是災難性的。
  可是咱們使用視圖機制來確保常規集合的線程安全，而不是實現線程安全的集合類。例如，Collections類的靜態方法synchronizedMap方法能夠將任何一個映射錶轉換成爲具備同步訪問方法的Map：

Map<String, String> map = Collections.synchrizedMap(new HashMap<String, String>());

就能夠自由的使用多線程來訪問map對象了。像get和put這類方法都是同步操做的，即在另外一個線程中調用另外一個方法以前，剛纔的方法調用必須完全執行完畢。

6.受查視圖

受查視

List<String> list = new ArrayList<>();
        List list2 = list;
        //程序運行到這裏是不會報錯的，可是若是後面訪問這裏元素，
        //而且試圖強制轉換爲String類型的變量纔會拋出一個ClassCastException的異常
        list2.add(10);
        //這裏會拋出ClassCastException異常
        //String string = (String) list2.get(0);

例如，上面的例子，先建立了一個List<String>類型的對象，再將它的泛型類型擦除，變成了List類型，因爲泛型類型被擦除，原來的泛型類型就會被Object代替，因此咱們在list2中添加一個整數(Integer)類型是不會有問題的，同時程序運行到add方法那裏也不會報錯的。也就是說，程序的編譯時和運行時的錯誤，咱們都成功的越過去了。可是在將添加進去的那個元素強制轉成爲String類型，就會拋出ClassCastException的異常。
  若是咱們使用受查視圖的話，例如：

        List<String> list3 = Collections.checkedList(list, String.class);
        List list4 = list3;
        //程序運行到這裏就會拋出一個ClassCastException的異常
        list4.add(10);

雖然在編譯時，程序是沒有報錯的，可是程序一旦運行到add方法那裏直接會拋出一個ClassCastException的異常。也就是說，經過受查視圖，能夠逃避編譯時的檢查，可是躲不過運行時的檢查。

5、算法

1.排序與混排：

現在排序算法已經成爲大多數編程語言標準庫中的一個組成部分

1.1java.util.Collections 1.2：

    static <T extends Comparable<? super T> void sort(List<T> elements)

    使用穩定的排序算法，對列表中的元素進行排序。這個算法的時間複雜度是O(n logn)，其中n爲列表長度

    static void shuffle(List<?> elements)

    static void shuffle(List<?> elements , Random r)

    隨機地打亂表中的元素。這個算法的時間複雜度是O(n a(n))，n是列表的長度，a(n)是訪問元素的平均時間

1.2java.util.List<E> 1.2：

    default void sort(Comparator<? super T> comparator) 8

    使用給定比較器對列表排序

1.3java.util.Comparator<T> 1.2：

    static <T extends Comparable<? super T>> Comparator<T> reverseOrder() 8

    生成一個比較器，將逆置Comparable接口提供的順序

    default Comparator<T> reversed() 8

    生成一個比較器，將逆置這個比較器提供的順序

2.二分查找：

只有採用隨機訪問，二分查找纔有意義

2.1java.util.Collections 1.2：

    static <T extends Comparable<? super T>> int binarySearch(List<T> elements , T key)

    static <T> int binarySearch(List<T> elements , T key , Comparator<? super T> c)

    從有序列表中搜索一個鍵，若是元素拓展了AbstractSequentialList類，則採用線性查找，不然將採用二分查找。

    這個方法的時間複雜度爲O(a(n) log n)，n爲列表的長度，a(n)是訪問一個元素的平均時間。

    這個方法將返回這個鍵在列表中的索引，若是在列表中不存在這個鍵將返回負值i。

    這種狀況下，應該將這個鍵插入到列表索引-i-1的位置上，以保持列表的有序性。

3.簡單算法：

3.1java.util.Collections 1.2：

    static <T extends Comparable<? super T>> T min(Collection<T> elements)

    static <T extends Comparable<? super T>> T max(Collection<T> elements)

    static <T> min(Collection<T> elements , Comparator<? super T> c)

    static <T> max(Collection<T> elements , Comparator<? super T> c)

    返回集合中最小的或最大的元素（爲清楚起見，參數的邊界被簡化了）

    static <T> void copy(List<? super T> to , List<T> from)

    將原列表中的全部元素複製到目標列表的相應位置上。目標列表的長度至少與原列表同樣

    static <T> void fill(List<? super T> l , T value)

    將列表中的全部位置設置爲相同值

    static <T> boolean addAll(Collection<? super T> c , T... values) 5.0

    將全部的值添加到集合中，若是集合改變了則返回true

    static <T> boolean replaceAll(List <T> l , T oldValue , T newValue) 1.4

    用newValue取代全部值爲oldValue的元素

    static int indexOfSubList(List <?> l , List<?> s) 1.4

    static int lastIndexOfSubList(List<?> l , List<?> s) 1.4

    返回l中第一個或者最後一個等於s子列表的索引。若是l中不存在等於s的子列表，則返回-1.

    static void swaq(List<?> l, int i, int j) 1.4

    交換給定偏移量的兩個元素

    static void reverse(List<?> l)

    逆置列表中元素的順序

    static void rotate(List<?> l, int d) 1.4

    旋轉列表中的元素，將索引i的條目移動到位置(i+d)%l.size()

    static int frequency(Collection<?> c1 , Collection<?> c2) 5.0

    返回c中與對象o相同的元素個數

    boolean disjoint(Collection<?> c1 , Collection<?> c2) 5.0

    若是兩個集合沒有共同元素，則返回true

3.2java.util.Collection<T> 1.2：

    default boolean removeIf(Predicate<? super E> filter) 8

    刪除全部匹配的元素

3.3java.util.List<E> 1.2

   default void replaceAll(UnaryOperator<E> op) 8

   對這個列表的全部元素應用這個操做

4.批處理：

不少操做會「成批」複製或者刪除元素，例如removeAll(...)等等，其實最好是對視圖進行操做，這樣既可以很好的完成任務，也可以界定範圍。

5.集合與數組的轉換：

若是須要把一個數組轉換爲集合，ArrayList.asList包裝器能夠達到這個目的

String[] values = ...;

HashSet<String> staff = new HashSet<>(ArrayList.asList(values));

從集合獲得數組會更加困難一些。固然，可使用toArray方法：

Object[] values = staff.toArray();

不過，這樣的結果是一個Object數組還不可以強制轉換，因此稍微改變String[] values = staff.toArray(new String[0]);                                   

 6、遺留的集合

1.Hashtable類：

Hashtable類與HashMap類的做用同樣，實際上，它們擁有相同的接口。Hashtable的方法是同步的。若是須要併發訪問，則須要使用ConcurrentHashMap

2.枚舉：

遺留集合使用Enumeration接口對元素進行遍歷

2.1    java.util.Enumeration<E> 1.0：

    boolean hasMoreElements()

    若是還有更多的元素能夠查看，則返回true

    E nextElement()

    返回被檢測的下一個元素。若是hasMoreElements()返回false，則不要調用這個方法

2.2   java.util.Hashtable<K,V> 1.0：

    Enumeration<K> keys()

    返回一個遍歷散列表中鍵的枚舉對象

    Enumeration<V> elements()

    返回一個遍歷散列表中元素的枚舉對象

2.3   java.util.Vector<E> 1.0：

    Enumeration<E> elements()

    返回遍歷向量中元素的枚舉對象

3.屬性映射：

屬性映射是一個類型很是特殊的映射結構：鍵與值都是字符串，表能夠保存到一個文件中，也能夠從文件中加載，使用一個默認的輔助表。

實現屬性映射的Java平臺類稱爲Properties，一般用於程序的配置選項

3.1java.util.Properties 1.0：

    Properties()

    建立一個空的屬性映射

    Properties(Properties defaults)

    建立一個帶有默認值的空的屬性映射

    String getProperty(String key)

    得到屬性的對應關係；返回與鍵對應的字符串。若是映射不存在，返回默認表中與這個鍵對應的字符串

    String getProperty(String key,String defaultValue)

    得到在鍵沒有找到時具備的默認值屬性；它將返回與鍵對應的字符串，若是在映射中不存在，就返回默認的字符串

    void load(InputStream in)

    從InputStream加載屬性映射

    void store(OutputStream out,String commentString)

    把屬性映射存儲到OutputStream

4.棧：

從1.0版本開始，就已經包含了Stack類，其中含有push方法和pop方法，可是，Stack類拓展爲Vector類，就理論角度看，Vector類並不使人滿意，它可讓棧使用不屬於棧操做的insert和remove方法

4.1java.util.Stack<E> 1.0：

    E push(E item)

    將item壓入棧並返回item

    E pop()

    彈出並返回棧頂的item。若是棧爲空，請不要使用

    E peek()

    返回棧頂元素，可是不彈出。若是棧爲空，請不要使用

5.位集：

Java平臺的BitSet類用於存放一個位序列（稱爲位向量或位數組更爲合適），若是須要高效的存儲位序列（例如，標誌）就可使用位集。因爲位集將位包裝在字節裏，因此，效率極高。

5.1  java.util.BitSet 1.0：

    BitSet(int initialCapacity)

    建立一個位集

    int length()

    返回位集的「邏輯長度」，即1加上位集的最高設置位的索引

    boolean get(int bit)

    得到一個位

    void set(int bit)

    設置一個位

    void clear(int bit)

    清楚一個位

    void and(BitSet set)

    這個位集與另外一個位集進行邏輯AND

    void or(BitSet set)

    這個位集與另外一個位集進行邏輯OR

    void xor(BitSet set)

    這個位集與另外一個位集進行邏輯XOR

    void andNot(BitSet set)

    清除這個位集中對應另外一個位集中設置的全部位

第十章  圖形程序設計

1.Swing概述

 swing並無徹底取代AWT，而是基於AWT架構之上。swing僅僅提供了功能更增強大的用戶界面組件。，尤爲是在用swing編寫程序是，仍是須要使用基本的AWT處理時間。從如今開始，swing是指被繪製的用戶界面類，而awt是指像事件處理這樣抽象窗口工具箱的底層機制。
雖然在用戶屏幕上顯示基於swing的用戶界面組件比現實awt基於對等體的界面元素要慢一些，但在計算機快速運行下這沒什麼。如下緣由讓人們選擇swing：
       1.swing擁有一個豐富、便捷的用戶界面元素集合。二、swing對平臺的依賴很小，意味着他有不多的關於平臺的bug。3.給予用戶一致的感受。

       對於第三點存在一些潛在問題，若在全部平臺上用戶界面元素看起來都同樣，他們可能與平臺的本地控件不同，而這些平臺的用戶對此可能並不熟悉。swing採起一種巧妙的方式解決。指定觀感（look and feel）。
注意：
1.      swing類位於javax.swing包中。包名錶示這是Java的一個擴展包。不過在1.2版本後，每一個Javase實現中都必須包含他。
2.    全部的swing組件都必須由事件分派線程（Event dispatch thread）進行配置，線程將按鍵控制和鼠標點擊轉移 到用戶接口組件中。可是許多swing程序並無這麼作，而是直接在主程序中完成初始化。因爲swing 組件很複雜，jdk程序員不能保證這種方式的安全性 ，爲了以防萬一，儘管代碼看起來神祕，可是最好的 選擇。

2.建立框架

建立框架
在Java中，頂層窗口（就是沒有包含在任何其餘窗口中的窗口）被稱爲框架（frame）。
在AWT庫中有一個稱爲Frame的類，用於描述頂層窗口。這個類的Swing版本名爲JFrame，它擴展於Frame類。
JFrame是極少數幾個不繪製在畫布上的Swing組件之一。所以，它的修飾部件（按鈕、標題欄、圖標等）由用戶的窗口系統繪製，而不是由Swing繪製。
注意：絕大多數Swing組件類都以「J」開頭，例如，JButton，JFrame等。在Java中有Button和Frame這樣的類，但它們屬於AWT組件。若是偶爾忘記了「J」程序仍然能夠編譯和運行，可是將Swing和AWT組件混合在一塊兒使用將會致使視覺和行爲的不一致。
如今咱們來作一個示例，依然是選擇使用工具Eclipse。
首先爲了便於管理和維護，咱們創建一個包，包名起爲SwingDemo。而後創建它的子包No1。
在首先編寫框架代碼JframeDemo.java子包內咱們先創建兩個文件，一個是用於創建框架的文件JframeDemo.java，用來存放框架代碼，另外一個用於演示的文件Demo.java用來編寫main方法作演示。

首先編寫框架代碼JframeDemo.java：

public class JframeDemo extends JFrame{
            private static final int DEFAULT_WIDTH=300;
            private static final int DEFAULT_HEIGHT=300;
            public JframeDemo(){
                        setSize(DEFAULT_WIDTH,DEFAULT_HEIGHT);
            }
}

Demo演示文件編寫以下：

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

3.框架定位

JFrame類自己只包含若干個改變外觀的方法。然而，繼承了各個超類中許多處理框架大小和位置的方法。如：
dispose方法用於關閉窗口，並回收建立窗口所使用的所有系統資源。
setIconImage方法用於將窗口極小化時的圖標設置爲Image對象。
setTitle方法用於改變標題欄中的文本。
setResizable方法利用一個boolean值肯定框架的大小是否容許用戶改變。
setLocation（x，y）方法將窗口放置在座標爲x，y的位置。
setBounds（x，y，width，height）方法將窗口指定位置，同時設定窗口大小。
可是對於不一樣分辨率的屏幕，框架的大小不一樣，因此應先檢查用戶屏幕的分辨率，並根據其分辨率編寫代碼重置框架的大小。這就須要用到Toolkit類，它包含了不少與本地窗口系統進行交付的方法。先調用靜態方法getDefaultToolkit獲得一個Toolkit對象。而後調用getScreenSize方法，該方法以Dimension對象的形式返回屏幕的大小。Dimension對象用公有實例變量width和height保存屏幕的寬度和高度

Toolkit kit = Toolkit.getDefaultToolkit();
Dimension screenSize = kit.getScreenSize();

int screenWidth = screenSize.width;

int screenHeight = screenSize.height;

 

4.在組件中顯示信息

1. 在JFrame中有四層面板。其中的根面板、層級面板和玻璃面板人們並不太關心；它們是用來組織菜單欄和內容窗格以及實現觀感的。Swing程序員最關心的是內容窗格（content pane）。在設計框架的時候，將全部的組件添加到內容窗格中。
2. 繪製一個組件，須要定義一個擴展JComponent的類，並覆蓋其中的paintComponent方法。paintComponent方法有一個Graphics類型的參數，這個參數保存着用於繪製圖像和文本的設置。在Java中，全部的繪製都必須使用Graphics對象，其中包含了繪製圖案、圖像和文本的方法。
3. 不管何種緣由，只要窗口須要從新繪圖，事件處理器就會通告組件，從而引起執行全部組件的paintComponent方法。
4. 必定不要本身調用paintComponent方法。在應用程序須要從新繪圖的時候，這個方法將被在佛那個地調用，不要人爲的干預這個自動的處理過程。
5. 若是須要強制刷新屏幕，就須要調用repaint方法，而不是paintComponent方法。它將引起採用相應配置的Graphics對象調用全部組件的paintComponent方法。
6. 在框架中添加一個或多個組件時，若是隻想使用它們的首選大小，能夠調用pack方法而不是setSize方法。
7. 有些程序員更喜歡擴展JPanel，而不是JComponent。JPanel是一個能夠包含其餘組件的容器（container），但一樣也能夠在其上面進行繪製。有一點不一樣之處是，面板不透明，這意味着須要在面板的邊界內繪製全部的像素。最容易實現的方法是，在每一個面板子類的paintComponent方法中調用super.paintComponent來用背景色繪製面板。
8. javax.swing.JFrame 1.2
   • Container getContentPane()
     返回這個JFrame的內容窗格對象。
   • Component add(Component c)
     將一個給定的組件添加到改框架的內容窗格中（在Java SE 5.0之前的版本中，這個方法將拋出一個異常）。
9. java.awt.Component 1.0
   • void repaint()
     「儘量快地」從新繪製組件。
   • Dimension getPreferredSize()
     要覆蓋這個方法，發揮這個組件的首選大小。
10. javax.swing.JComponent 1.2
    • void paintComponent(Grphics g)
      覆蓋這個方法來描述應該如何繪製本身的組件。
11. java.awt.Window 1.0
    • void pack()
      調整窗口大小，要考慮到其組件的首選大小。

5.處理2D圖形

1. Graohics類包含繪製直線、矩形和橢圓等方法。可是，這些繪製圖形的操做能力很是有限。例如，不能改變先的粗細，不能旋轉這個圖形。
2. Java SE 1.2引入了Java 2D庫，這個庫實現了一組功能強大的圖形操做。
3. 要想使用Java 2D庫繪製圖形，須要得到一個Graphics2D類對象。這個類是Graphics類的子類。自從Java SE 2版本依賴，paintComponent方法就會自動地獲取一個Graphics2D類對象，只須要進行一次類型轉換就能夠了。
4. Java 2D庫採用面向對象的方式將幾何圖形組織起來。包括描述直線、矩形的橢圓的類：LINE2D、Rectangle2D、Ellipse2D這些類都實現了Shape接口。
5. 要想繪製圖形，首先要建立一個實現了Shape接口的類的對象，而後調用Graphics2D類中的draw方法。
6. 使用Java 2D圖形或許會增長一些複雜度。在1.0的繪製方法中，採用的是整型像素座標，而Java 2D圖形採用的是浮點座標。在不少狀況下，用戶可使用更有意義的形式（例如，微米或英寸）指定圖形的座標，而後再將其轉換成像素，這樣作很方便。在Java 2D庫中，內部的不少浮點極端都採用單精度float。畢竟，幾何計算的最終目的是要設置屏幕或打印機的像素，因此單精度徹底能夠知足要求了。只要舍入偏差限制在一個像素的範圍內，視覺效果就不會受到任何影響。另外，在某些平臺上，float計算的速度比較快，而且只佔據double值的通常存儲量。
7. 因爲後綴和類型轉換都有點麻煩，因此2D庫的設計者決定爲每一個圖形類提供兩個版本：一個是爲那些節省空間的程序員提供的float類型的座標；另外一個是爲那些懶惰的程序員提供的double類型的座標。
8. Rectangle2D方法的參數和返回值均爲double類型。
9. 直接使用Double圖形類能夠避免處理float類型的值，而後若是須要建立上千個圖形對象，仍是應該考慮使用Float類，這樣能夠節省存儲空間。
10. Rectangle2D和Ellipse2D類都是由公共超類RectangularShape繼承來的。
11. RectangularShape類定義了20多個有關圖形操做的通用方法，其中比較經常使用的方法有getWidth、getHeight、getCenterX、getCenterY等。
12. 從Java 1.0遺留下來的兩個類也被放置在圖形類的繼承層次中。它們是Rectangle和Point類，分別擴展於Rectangle2D和Point2D類，並用整型座標存儲矩形和點。
13. Rectangle2D和Ellipse2D對象很容易構造，須要給出左上角的x和y座標，寬和高。

6.使用顏色

1. 使用Graphics2D類的setPaint方法能夠爲圖形環境上的全部後續的繪製操做選擇顏色。
2. 只須要將調用dra替換爲調用fill就能夠用一種顏色填充一個封閉圖形的內部。
3. 要想繪製多種顏色，就須要按照選擇顏色、繪製圖形、再選擇另一種顏色、再繪製圖形的過程實施。
4. fill方法會在右側和下方少繪製一個像素。
5. Color類用於定義顏色。在java.awt.Color類中提供了13個預約義的常量，它們分別表示13種標準顏色。BLANK、BLUE、CYAN、DARK_GRAY、GRAY、LIGHT_GRAY、MAGENTA、ORANGE、PINK、RED、WHITE、WELLOW。
6. 能夠經過提供紅、綠和藍三色成分來建立一個Color對象，以達到定製顏色的目的。
7. 要想設置背景顏色，就須要使用Component類中的setBackground方法。Component類是JComponent類的祖先。
8. setForeground方法是用來設定在組件上進行繪製時使用的默認顏色。
9. Color類中的brighter()方法和darker()方法的功能，它們分別加亮或變暗當前的顏色。使用brighter方法也是加亮條目的好辦法。實際上，brighter()只微微地加亮一點。要達到耀眼的效果，須要調用三次這個方法：c.brighter().brighter().brighter()。
10. java在SystemColor類中與定義了不少顏色的名字。在這個類中的常量，封裝了用戶系統的各個元素的顏色。

7.使用文本特殊字體

1. 能夠經過字體名(font dace name)指定一個字體。字體名由」Helvetica」這樣的字體家族名(font family name)和一個可選的」Bold」後綴組成。
2. 要想知道某臺特定計算機上容許使用的字體，就須要調用GraphicsEnvironment類中的getAvailableFontFamilyNames方法。這個方法將返回一個字符型數組，其中包了全部可用的字體名。GraphicsEnvironment類描述了用戶系統的圖形環境，爲了獲得這個類的對象，須要調用靜態的getLocalGraphicsEnvironment方法。
3. 點數目是排版中廣泛使用的表示字體大小的單位，每英寸包含72個點。
4. 字體風格值：Font.PLAIN、Font.BOLD、Font.ITALIC、Font.BOLD+Font.ITALIC。
5. 要想獲得屏幕設備字體屬性的描述對象，須要調用Graphics2D類中的getFontRenderContext方法。它將返回一個FontRenderContext類對象。
6. 基線（baseline）是一條虛構的線。上坡度（ascent）是從基線到坡頂（ascenter）的距離。下坡度（descent）是從基線到坡頂（descenter）的距離。
7. 行間距（leading）是某一行的坡底與其下一行的坡頂之間的空隙。字體的高度是連續兩個基線之間的距離，它等於下坡度+行間距+上坡度。
8. getStringBounds方法返回的矩形寬度是字符串水平方向的寬度。矩形的高度是上坡度、下坡度、行間距的總和，若是須要知道下坡度或行間距，可使用Font類的getLineMetrics方法，這個方法將返回一個LineMetrics類對象。
9. 爲了可以得到中央的位置，可使用getWidth()獲得組件的寬度。使用bounds.getWidth()獲得字符串的寬度。前者減去後者就是兩側應該剩餘的空間，所以，每側剩餘的空間應該是這個差值的通常。高度也同樣。
10. java.awt.Font 1.0
    1. Font(String name,int style,int size)
       建立一個字體對象。
       參數： name 字體名。不是字體名（例如，「Helvetica Bold」），就是邏輯字體名（例如，「Serif」、「SansSerif」）。style 字體風格（Font.PLAIN、Font.BOLD、Font.ITALIC或Font.BOLD+Font.ITALIC）。size 字體大小（例如，12）。
    2. String getFontName()
       返回字體名，例如，「Helvetica Bold」。
    3. String getFamily()
       返回字體家族名，例如，「Helvetica」。
    4. String getName()
       若是採用邏輯字體名建立字體，將返回邏輯字體，例如，「SansSerif」；不然，返回字體名。
    5. Rectangle2D getStringBounds(String s,FontRenderContext context) 1.2
       返回包圍這個字符串的矩形。矩形的起點爲基線。矩形頂端的y座標等於上坡度的負值。矩形的高度等於上坡度、下坡地和行間距之和。寬度等於字符串的寬度。
    6. LineMetrics getLineMetrics(String s,FontRenderContext context) 1.2
       返回測定字符串寬度的一個線性metrics對象。
    7. Font deriveFont(int style) 1.2
    8. Font deriveFont(float size) 1.2
    9. Font deriveFont(int style,float size) 1.2
       返回一個新字體，除給定大小和字體風格外，其他與原字體同樣。
    10. java.awt.font.LineMetrics 1.2
        • float getAscent()
          返回字體的上坡度—從基線到大寫字母頂端的距離。
        • float getDescent()
          返回字體的下坡度—從基線到坡底的距離。
        • float getLeading()
          返回字體的行間距—從一行文本底端到下一行文本頂端之間的空隙。
        • float getHeight()
          返回字體的總高度—兩條文本基線之間的距離（下坡度+行間距+上坡度）。
    11. java.awt.Graphics 1.0
        • Font getFont()
        • void setFont(Font font)
          獲取或設置當前的字體。這種字體將被應用於後續的文本繪製操做中。
          參數：font 一種字體。
          • void drawString(String str,int x,int y)
            參數：str 將要繪製的字符串。x 字符串開始的x座標。y 字符串基線的y座標。
    12. java.awt.Graphics 1.2
        • FontRenderContext getFontRenderContext()
          返回這個圖形文本中，指定字體特徵的字體繪製環境。
        • void drawString(String str,float x,float y)
          採用當前的字體和顏色繪製一個字符串。
          參數：str 將要繪製的字符串。 x 字符串開始的x座標。y 字符串基線的y座標。
    13. javax.swing.JComponent 1.2
        • FontMetrics getFontMetrics(Font f) 5.0
          獲取給定字體的度量。FontMetrics類是LineMetrics類的早先版。
    14. java.awt.FontMetrics 1.0
        • FontRenderContext getFontRenderContext() 1.2
          返回字體的字體繪製環境。

8.顯示圖像

1.使用Graphics類的drawImage方法將圖像顯示出來。

2.java.awt.Graphics 1.0

（1）boolean drawImage(Image img,int x,int y,ImageObserver observer)繪製一副非比例圖像。注意：這個調用可能會在圖像尚未繪製完畢就返回。

參數：img 將要繪製的圖像。x 左上角的x座標。y 左上角的y座標。observer 繪製進程中以通告爲目的的對象（可能爲null）。

（2）boolean drawImage(Image img,int x,int y,int width,int height,ImageObserver observer)
繪製一副比例圖像。系統按照比例將圖像放入給定寬和高的區域。注意：這個調用可能會在圖像尚未繪製完畢就返回。
參數：img 將要繪製的圖像。x 左上角的x座標。y 左上角的y座標。width 描述圖像的寬度。height 描述圖像的高度。observer 繪製進程中以通告爲目的的對象（可能爲null）。

（3）void copyArea(int x,int y,int width,int height,int dx,int dy)
拷貝屏幕的一塊區域。
參數：x 原始區域左上角的x座標。y 原始區域左上角的y座標。width 原始區域的寬度。 height 原始區域的高度。dx 原始區域到目的區域的水平距離。dy 原始區域到目的區域的數值距離。

 第二部分  實驗部分

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

測試程序1：

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

l 掌握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
import java.util.*;
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("element 2=" + 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);
    }
}

實驗運行源代碼爲：

 

package chart10;
//示例程序1
 
import java.util.Vector;            //矢量類包
class Cat {
     private int catNumber;         //Cat類的整型私有變量catNumber
     Cat(int i) {                   //Cat構造器        
        catNumber = i;
    }
     void print() {                 //print方法定義
        System.out.println("Cat #" + catNumber);
     }
}
public class Cats{
public static void main(String[] args){
       Vector<Cat> cats= new Vector<Cat>();     //建立一個Vector<Cat>類對象cats
       for(int i=0; i<7; i++)                    //for循環經過Vector<Cat>類對象cats來調用addElement()方法
           cats.addElement(new Cat(i)); 
       for(int i=0; i<cats.size(); i++)
           (cats.elementAt(i)).print();         //經過Vector<Cat>類對象cats來調用elementAt()方法以及Cat類的print()方法
   }
}

 

　　實驗運行結果截圖爲：

 

 

程序運行源代碼爲：

package Stacks;
 
 
//示例程序2
import java.util.*;
public class Stacks                                 //堆棧類
{
 static String[] months={"金","銀","銅","鐵"};              //定義一個字符類數組months[],其中元素爲金、銀、銅、鐵
 public static void main(String[] args){
    Stack<String> stk = new Stack<String> ();       //建立一個Stack<String>類對象stk
    for(int i=0; i<months.length; i++)   
        stk.push(months[i]);                         //經過對象名來調用push()方法
    System.out.println(stk);
    System.out.println("element 2=" + stk.elementAt(2));
    while(!stk.empty())                             //當stk不爲空時，將經過對象名調用pop()方法
        System.out.println(stk.pop());
}
}

　程序運行結果截圖爲：

　

 

 程序源代碼爲：

package Counter;
 
//示例程序3
import java.util.*;
class Counter {      //Counter類
    int i = 1;      //定義一個整型的Counter類變量i
    public String toString() {    //toString()方法
        return Integer.toString(i);     
    }
}
 
public class Statistics {
    public static void main(String[] args) {
        Hashtable ht = new Hashtable();     //建立一個Hashtable類對象ht。Hashtable保存了一批鍵值對
        for (int i = 0; i < 10000; i++) {    
            Integer r = new Integer((int) (Math.random() * 20));     
    //建立一個Integer類對象r，調用Math包的random()方法隨機生成10000個1-20之間的隨機數，強制類型轉換爲int型
if(ht.containsKey(r))           //若是r的鍵值不爲空
            ((Counter)ht.get(r)).i++;    //將Hashtable類對象ht強制轉換爲Counter類，調用get()方法而後再讓i（r的出現次數）加一
        else                           
            ht.put(r, new Counter());           //不然Hashtable類對象ht調用put()方法，再建立一個Counter類對象
}
        System.out.println(ht);                 //將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));
        }
     }
}
import java.util.*;
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);
        while (li.hasNext())
            System.out.println(li.next());
        if (l.indexOf("Hello") < 0)   
            System.err.println("Lookup does not work");
        else
            System.err.println("Lookup works");
   }
}

 程序運行源代碼爲：

package ArrayListDemo;
import java.util.*;
 
public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList al = new ArrayList();     //建立一個ArrayList類對象al
        // Add lots of elements to the ArrayList...
        al.add(new Integer(11));            //經過al調用add()方法添加元素
        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:");         //將Retrieving by index:（按索引搜索）輸出在控制檯上
        for (int i = 0; i < al.size(); i++) {               //i小於數組類對象al的大小時，輸出i的值
            System.out.println("Element " + i + " = " + al.get(i));
        }
     }
}

 

 

 

 

程序運行結果截圖爲：

 

 程序源代碼爲：

package LinkedListDemo;
 
import java.util.*;
public class LinkedListDemo {
    public static void main(String[] argv) {
        LinkedList l = new LinkedList();    //建立一個LinkedList類的對象l
        l.add(new Object());                //經過l調用add()方法增長元素
        l.add("Hello");
        l.add("zhangsan");
        ListIterator li = l.listIterator(0);     //建立一個ListIterator類的對象li
        while (li.hasNext())                    //這是java的迭代器的用法。使用hasNext()檢查序列中是否還有元素。
            System.out.println(li.next());      //使用next()得到序列中的下一個元素。
 
        if (l.indexOf("Hello") < 0)          //indexOf檢測若是不存在就會返回Lookup does not work
            System.err.println("Lookup does not work");      
        else
            System.err.println("Lookup works");
   }
}

程序運行結果截圖爲：

 

 實驗代碼以下：

package linkedList;
 
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)
   {
      LinkedList<String> a = new LinkedList<String>();//建立一個LinkedList<String>類對象
      a.add("Amy");         //經過a調用add()方法添加元素
      a.add("Carl");
      a.add("Erica");
 
      LinkedList<String> b = new LinkedList<String>();//建立一個LinkedList<String>類對象
      b.add("Bob");                 //經過b調用add()方法添加元素
      b.add("Doug");
      b.add("Frances");
      b.add("Gloria");
 
      // merge the words from b into a
 
      ListIterator<String> aIter = a.listIterator();  //listIterator接口是iterator的子接口
      Iterator<String> bIter = b.iterator();
 
      while (bIter.hasNext())                   //若是存在訪問的元素，返回ture
      {
         if (aIter.hasNext()) aIter.next();    //若是aIter中存在訪問的元素使用next()得到序列中的下一個元素。
         aIter.add(bIter.next());               //添加bIter.next()獲得的元素到aIter中
      }
 
      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()得到序列中的下一個元素。
         {
            bIter.next(); // skip next element    使用next()得到序列中的下一個元素。
            bIter.remove(); // remove that element   刪除bIter中的元素
         }
      }
 
      System.out.println(b);
 
      // bulk operation: remove all words in b from a
 
      a.removeAll(b);       //刪除b中全部的來自a的元素
 
      System.out.println(a);
   }
}

程序運行結果輸出以下：

 

 

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

測試程序1：

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

 

import javax.swing.*;
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);    
   }
}

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

 

package SimpleFrameTest;
 
import javax.swing.*;
public class SimpleFrameTest
{   
   public static void main(String[] args)
   {
     JFrame  frame = new JFrame();     //建立一個JFrame類對象frame，
     frame.setBounds(0, 0,300, 200);    //經過frame來調用setBounds()方法，後面的參數分別是像素最初始位置，以及框架的寬度和長度
     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);    //經過調用setDefaultCloseOperation()方法。可關閉
     frame.setVisible(true);      //調用setVisible()方法，
   }
}

 

程序運行輸出截圖爲：

 

 

 

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

 掌握空框架建立方法；

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

 

package sizedFrame;
 
import java.awt.*;
import javax.swing.*;
 
/**
 * @version 1.35 2018-04-10
 * @author Cay Horstmann
 */
public class SizedFrameTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() ->     //lambda表達式
         {
            SizedFrame frame = new SizedFrame();     //建立一個SizedFrame類對象frame
            frame.setTitle("SizedFrame");           //經過frame對象來調用setTitle()方法，來設置標題
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);   //調用setDefaultCloseOperation()方法來設置取消窗口界面
            frame.setVisible(true);   //調用setVisible()方法來決定窗口是否可見
         });
   }
}
 
class SizedFrame extends JFrame     //建立一個類SizedFrame類來繼承JFrame類
{
   public SizedFrame()       //構造器
   {
      // get screen dimensions
 
      Toolkit kit = Toolkit.getDefaultToolkit();  //建立一個Toolkit類對象kit，經過類名來調用getDefaultToolkit()方法
      Dimension screenSize = kit.getScreenSize();   //調用getScreenSize()方法來獲得框的大小，返回維度類型
      int screenHeight = screenSize.height;
      int screenWidth = screenSize.width;
 
      // set frame width, height and let platform pick screen location
 
      setSize(screenWidth / 2, screenHeight / 2);     //設置大小
      setLocationByPlatform(true);
 
      // set frame icon
 
      Image img = new ImageIcon("icon.gif").getImage();    //建立一個Image對象來設置灰度
      setIconImage(img);      
   }
}

實驗輸出截圖爲：

 

 

測試程序2：

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

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

實驗源代碼爲：

 

package simpleFrame;
 
import java.awt.*;
import javax.swing.*;
 
/**
 * @version 1.34 2018-04-10
 * @author Cay Horstmann
 */
public class SimpleFrameTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() ->      //lambda表達式
         {
            SimpleFrame frame = new SimpleFrame();   //建立一個SimpleFrame類對象
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  //調用setDefaultCloseOperation()方法來取消窗口
            frame.setVisible(true);    //調用setVisible()方法決定窗口是否可見
         });
   }
}
 
class SimpleFrame extends JFrame     //建立一個SimpleFrame類繼承JFrame類
{
   private static final int DEFAULT_WIDTH = 300;     //定義私有常量DEFAULT_WIDTH和DEFAULT_HEIGHT的值
   private static final int DEFAULT_HEIGHT = 200;
 
   public SimpleFrame()    //SimpleFrame構造器
   {
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);     //設置寬度和長度的大小
   }
}

 實驗輸出結果截圖爲：

 

 

 

 測試程序3：

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

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

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

 

package notHelloWorld;
 
import javax.swing.*;
import java.awt.*;
 
/**
 * @version 1.34 2018-04-10
 * @author Cay Horstmann
 */
public class NotHelloWorld
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() ->     //lambda表達式
         {
            NotHelloWorldFrame frame = new NotHelloWorldFrame();     //建立一個NotHelloWorldFrame類對象
            frame.setTitle("NotHelloWorld");     //經過frame來調用setTitle()方法，來設置標題
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//調用setDefaultCloseOperation()方法取消窗口
            frame.setVisible(true);   //調用setVisible()方法設置窗口是否可見
         });
   }
}
 
/**
 * A frame that contains a message panel.
 */
class NotHelloWorldFrame extends JFrame     //建立一個NotHelloWorldFrame類來繼承JFrame類
{
   public NotHelloWorldFrame()     //NotHelloWorldFrame構造器
   {
      add(new NotHelloWorldComponent());    //add()方法添加窗口
      pack();
   }
}
 
/**
 * A component that displays a message.
 */
class NotHelloWorldComponent extends JComponent //建立一個NotHelloWorldComponent類繼承JComponent類
{
   public static final int MESSAGE_X = 75;     //私有屬性，常量MESSAGE_X以及MESSAGE_Y 的定義
   public static final int MESSAGE_Y = 100;
 
   private static final int DEFAULT_WIDTH = 300;  //私有屬性，常量DEFAULT_WIDTH以及DEFAULT_HEIGHT 的定義
   private static final int DEFAULT_HEIGHT = 200;
 
   public void paintComponent(Graphics g)    //paintComponent()方法定義來實現繪圖
   {
      g.drawString("Not a Hello, World program", MESSAGE_X, MESSAGE_Y);
   }
 
   public Dimension getPreferredSize()     //getPreferredSize()獲得維度
   {  
      return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT); 
   }
}

 

實驗結果輸出截圖爲：

 

 

實驗總結：

     （1）這周咱們主要學習了兩個方面的知識，主要學習了有關集合和圖形程序設計的知識。對於我來講相對容易理解的是圖形程序設計部分，而集合相關知識對我來講相對更難一點。此次的實驗沒有太難，

由於此次都是驗證性的實驗，實驗過程中也沒有出現驗證錯誤等問題。固然，經過實驗我才更加深刻的瞭解了程序的邏輯性。

     (2)經過此次實驗基礎總結，更加系統的看了一遍書，理解了在老師講解過程當中沒有理解的細微的知識點。