java something

本程序可以控制3個線程按順序執行， 代碼如下：

public class Test3 {

 public static void main(String[] args) throws IOException {
  final Test obj = new Test();
  
  new Thread()
  {
   public void run()
   {
    obj.m1();
   }
  }.start();
  new Thread()
  {
   public void run()
   {
    obj.m2();
   }
  }.start();
  new Thread()
  {
   public void run()
   {
    obj.m3();
   }
  }.start();
  
 }

}

class Test
{
 static int count;
 volatile int target = 1;
 synchronized void m1()
 { 
   for (int i = 0; i < 10; i++)
   {
    while (target == 2 || target == 3)
    {
     try {
      wait();
     } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
    }
    System.out.println("m1() =" + i);
    target = 2;
    notifyAll();
   }
 }
 
 synchronized void m2()
 {
  for (int i = 0; i < 10; i++)
  {
   while (target == 1 || target == 3)
   {
    try {
     wait();
    } catch (InterruptedException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }
   }
   System.out.println("m2() =" + i);
   target = 3;
   notifyAll();
  }
 }
 
 synchronized void m3()
 {
  for (int i = 0; i < 10; i++)
  {
   while (target == 1 || target == 2)
   {
    try {
     wait();
    } catch (InterruptedException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }
   }
   System.out.println("m3() =" + i);
   target = 1;
   notifyAll();
  }
 }
}

  1,線程的生命周期

        線程從創建、運行到結束總是處于下面五個狀態之一：新建狀態、就緒狀態、運行狀態、阻塞狀態及死亡狀態。

    1.新建狀態(New)： 
        當用new操作符創建一個線程時， 例如new Thread(r)，線程還沒有開始運行，此時線程處在新建狀態。 當一個線程處于新生狀態時，程序還沒有開始運行線程中的代碼

     2.就緒狀態(Runnable)

        一個新創建的線程并不自動開始運行，要執行線程，必須調用線程的start()方法。當線程對象調用start()方法即啟動了線程，start()方法創建線程運行的系統資源，并調度線程運行run()方法。當start()方法返回后，線程就處于就緒狀態。

        處于就緒狀態的線程并不一定立即運行run()方法，線程還必須同其他線程競爭CPU時間，只有獲得CPU時間才可以運行線程。因為在單CPU的計算機系統中，不可能同時運行多個線程，一個時刻僅有一個線程處于運行狀態。因此此時可能有多個線程處于就緒狀態。對多個處于就緒狀態的線程是由Java運行時系統的線程調度程序(thread scheduler)來調度的。

    3.運行狀態(Running)

        當線程獲得CPU時間后，它才進入運行狀態，真正開始執行run()方法.

    4. 阻塞狀態(Blocked)

        線程運行過程中，可能由于各種原因進入阻塞狀態:
        1>線程通過調用sleep方法進入睡眠狀態；
        2>線程調用一個在I/O上被阻塞的操作，即該操作在輸入輸出操作完成之前不會返回到它的調用者；
        3>線程試圖得到一個鎖，而該鎖正被其他線程持有；
        4>線程在等待某個觸發條件；
        ......           

        所謂阻塞狀態是正在運行的線程沒有運行結束，暫時讓出CPU，這時其他處于就緒狀態的線程就可以獲得CPU時間，進入運行狀態。

    5. 死亡狀態(Dead)

        有兩個原因會導致線程死亡：
        1) run方法正常退出而自然死亡，
        2) 一個未捕獲的異常終止了run方法而使線程猝死。
        為了確定線程在當前是否存活著（就是要么是可運行的，要么是被阻塞了），需要使用isAlive方法。如果是可運行或被阻塞，這個方法返回true； 如果線程仍舊是new狀態且不是可運行的， 或者線程死亡了，則返回false.

2,  線程的優先級和調度

Java的每個線程都有一個優先級，當有多個線程處于就緒狀態時，線程調度程序根據線程的優先級調度線程運行。

可以用下面方法設置和返回線程的優先級。

    · public final void setPriority(int newPriority) 設置線程的優先級。

    · public final int getPriority() 返回線程的優先級。

newPriority為線程的優先級，其取值為1到10之間的整數，也可以使用Thread類定義的常量來設置線程的優先級，這些常量分別為：Thread.MIN_PRIORITY、Thread.NORM_PRIORITY、Thread.MAX_PRIORITY，它們分別對應于線程優先級的1、5和10，數值越大優先級越高。當創建Java線程時，如果沒有指定它的優先級，則它從創建該線程那里繼承優先級。

一般來說，只有在當前線程停止或由于某種原因被阻塞，較低優先級的線程才有機會運行。

前面說過多個線程可并發運行，然而實際上并不總是這樣。由于很多計算機都是單CPU的，所以一個時刻只能有一個線程運行，多個線程的并發運行只是幻覺。在單CPU機器上多個線程的執行是按照某種順序執行的，這稱為線程的調度(scheduling)。

大多數計算機僅有一個CPU，所以線程必須與其他線程共享CPU。多個線程在單個CPU是按照某種順序執行的。實際的調度策略隨系統的不同而不同，通常線程調度可以采用兩種策略調度處于就緒狀態的線程。

(1) 搶占式調度策略

     Java運行時系統的線程調度算法是搶占式的 (preemptive)。Java運行時系統支持一種簡單的固定優先級的調度算法。如果一個優先級比其他任何處于可運行狀態的線程都高的線程進入就緒狀態，那么運行時系統就會選擇該線程運行。新的優先級較高的線程搶占(preempt)了其他線程。但是Java運行時系統并不搶占同優先級的線程。換句話說，Java運行時系統不是分時的(time-slice)。然而，基于Java Thread類的實現系統可能是支持分時的，因此編寫代碼時不要依賴分時。當系統中的處于就緒狀態的線程都具有相同優先級時，線程調度程序采用一種簡單的、非搶占式的輪轉的調度順序。

(2) 時間片輪轉調度策略

    有些系統的線程調度采用時間片輪轉(round-robin)調度策略。這種調度策略是從所有處于就緒狀態的線程中選擇優先級最高的線程分配一定的CPU時間運行。該時間過后再選擇其他線程運行。只有當線程運行結束、放棄(yield)CPU或由于某種原因進入阻塞狀態，低優先級的線程才有機會執行。如果有兩個優先級相同的線程都在等待CPU，則調度程序以輪轉的方式選擇運行的線程。

 3.  線程狀態的改變

一個線程在其生命周期中可以從一種狀態改變到另一種狀態，線程狀態的變遷如圖所示：

    
    
1>  控制線程的啟動和結束

當一個新建的線程調用它的start()方法后即進入就緒狀態，處于就緒狀態的線程被線程調度程序選中就可以獲得CPU時間，進入運行狀態，該線程就開始運行run()方法。

控制線程的結束稍微復雜一點。如果線程的run()方法是一個確定次數的循環，則循環結束后，線程運行就結束了，線程對象即進入死亡狀態。如果run()方法是一個不確定循環，早期的方法是調用線程對象的stop()方法，然而由于該方法可能導致線程死鎖，因此從1.1版開始，不推薦使用該方法結束線程。一般是通過設置一個標志變量，在程序中改變標志變量的值實現結束線程。請看下面的例子：

程序 ThreadStop.java

import java.util.*;

class Timer implements Runnable{

    boolean flag=true;
    public void run(){
      while(flag){
        System.out.print("\r\t"+new Date()+"");
        try{
              Thread.sleep(1000);
        }catch(InterruptedException e){} 
      }
      System.out.println("\n"+Thread.currentThread().getName()+" Stop");
    }

    public void stopRun(){
           flag = false;
    }
}

public class ThreadStop{
    public static void main(String args[]){
       Timer timer = new Timer();
       Thread thread = new Thread(timer);       
       thread.setName("Timer");
       thread.start();

       for(int i=0;i<100;i++){
         System.out.print("\r"+i);
        try{
              Thread.sleep(100);
        }catch(InterruptedException e){} 
       }     
       timer.stopRun();
    }
}

該程序在Timer類中定義了一個布爾變量flag，同時定義了一個stopRun()方法，在其中將該變量設置為false。在主程序中通過調用該方法，從而改變該變量的值，使得run()方法的while循環條件不滿足，從而實現結束線程的運行。

說明  在Thread類中除了stop()方法被標注為不推薦(deprecated) 使用外，suspend()方法和resume()方法也被標明不推薦使用，這兩個方法原來用作線程的掛起和恢復.

2>  線程阻塞條件

處于運行狀態的線程除了可以進入死亡狀態外，還可能進入就緒狀態和阻塞狀態。下面分別討論這兩種情況：

(1) 運行狀態到就緒狀態

處于運行狀態的線程如果調用了yield()方法，那么它將放棄CPU時間，使當前正在運行的線程進入就緒狀態。這時有幾種可能的情況：如果沒有其他的線程處于就緒狀態等待運行，該線程會立即繼續運行；如果有等待的線程，此時線程回到就緒狀態狀態與其他線程競爭CPU時間，當有比該線程優先級高的線程時，高優先級的線程進入運行狀態，當沒有比該線程優先級高的線程時，但有同優先級的線程，則由線程調度程序來決定哪個線程進入運行狀態，因此線程調用yield()方法只能將CPU時間讓給具有同優先級的或高優先級的線程而不能讓給低優先級的線程。

一般來說，在調用線程的yield()方法可以使耗時的線程暫停執行一段時間，使其他線程有執行的機會。

(2) 運行狀態到阻塞狀態

有多種原因可使當前運行的線程進入阻塞狀態，進入阻塞狀態的線程當相應的事件結束或條件滿足時進入就緒狀態。使線程進入阻塞狀態可能有多種原因：

① 線程調用了sleep()方法，線程進入睡眠狀態，此時該線程停止執行一段時間。當時間到時該線程回到就緒狀態，與其他線程競爭CPU時間。

Thread類中定義了一個interrupt()方法。一個處于睡眠中的線程若調用了interrupt()方法，該線程立即結束睡眠進入就緒狀態。

② 如果一個線程的運行需要進行I/O操作，比如從鍵盤接收數據，這時程序可能需要等待用戶的輸入，這時如果該線程一直占用CPU，其他線程就得不到運行。這種情況稱為I/O阻塞。這時該線程就會離開運行狀態而進入阻塞狀態。Java語言的所有I/O方法都具有這種行為。

③ 有時要求當前線程的執行在另一個線程執行結束后再繼續執行，這時可以調用join()方法實現，join()方法有下面三種格式：

·         public void join() throws InterruptedException 使當前線程暫停執行，等待調用該方法的線程結束后再執行當前線程。

·         public void join(long millis) throws InterruptedException 最多等待millis毫秒后，當前線程繼續執行。

·         public void join(long millis, int nanos) throws InterruptedException 可以指定多少毫秒、多少納秒后繼續執行當前線程。

上述方法使當前線程暫停執行，進入阻塞狀態，當調用線程結束或指定的時間過后，當前線程線程進入就緒狀態，例如執行下面代碼：

t.join();

將使當前線程進入阻塞狀態，當線程t執行結束后，當前線程才能繼續執行。

④ 線程調用了wait()方法，等待某個條件變量，此時該線程進入阻塞狀態。直到被通知(調用了notify()或notifyAll()方法)結束等待后，線程回到就緒狀態。

⑤ 另外如果線程不能獲得對象鎖，也進入就緒狀態。

后兩種情況在下一節討論。

錯誤可能是由XML有中文格式的字符引起的。

樹遍歷這個概念先提一下：遍歷即逐個訪問，對于樹而言主要有三種：前序，后序，中序遍歷樹的每個節點。遍歷一般是用遞歸算法來實現的，三種遍歷法區別于先訪問樹的那個部分。樹遍歷也是比較難的一個技術，不好掌握，我在大學時用匯編實現過這三種算法，到現在還記憶猶新（完全自己找到的規律），一下來和朋友們分享一下。
對于一個有兩個子節點的樹（或多個子節點），請你沿著樹的外圍畫一個輪廓線：

———>         >——————
        /             \
      /                 \
     /_____>____\     

       這是大致繞樹行走的輪廓線，大家都知道（或許你還不知道）函數的調用時控制流的傳遞就是這個樣子的。（控制流是線程執行方法時的形象表述）比如一下函數： main(){

     f1();
     f2();
}//該函數的控制流向是：先傳給main，再由main（）傳給f1,之后退回到mian（），在傳給f2()在由f2退回給main之后結束程序。異步方法調用時才會從這個封閉的輪廓中分出一個分支來。現在來談你如何設計一個樹遍歷方法：
我們來看一個函數的幾個關鍵部位，
       func（）{
        entry入口處
          
            中間部位           

        return出口處   
      }也許你很迷惑這與樹遍歷算法有和關系，告訴你吧這三個特殊部位就是你在設計遞歸時，遞歸函數應該出現的位置，他們出現在不同的位置就是不同的“序”,偽碼如：
先序遍歷
traversTree(Node root){
   if(root !=null){
     if(root.isLeaf()){//當是葉子時，
         visit（root）;//前序遍歷是先遍歷頁節點
     }   
         Node[] children=root.getChildren();//獲取所有子樹
         for(Node n:children){
           traversTree(n);//遞歸遍歷所有子樹，注意子樹可能為空。
          }
   }

}

中序遍歷（亦稱廣度優先遍歷，總是先遍歷樹的根）

traversTree(Node root){
   if(root !=null){
     //樹非空
     visit(root); //這是中序遍歷 visit出現與遞歸函數之前。
    
     Node[] children=root.getChildren();//獲取所有子樹
         for(Node n:children){
           traversTree(n);//遞歸遍歷所有子樹，注意子樹可能為空。
          }
   }

}

后序遍歷（亦稱深度優先搜索）：
traversTree(Node root){
   if(root !=null){
        
     Node[] children=root.getChildren();//獲取所有子樹
         for(Node n:children){
           traversTree(n);//遞歸遍歷所有子樹，注意子樹可能為空。
          }
    
     
     visit(root); //這是后序遍歷 visit出現在遞歸函數之后。
   }

}

以上三個算法，可能有點不正確，我沒測試過，時間太久了有點忘了，總之為大家做個參考吧！
因為樹結構典型的是應用了組合設計模式，所以只要涉及到樹肯定涉及遍歷，和遞歸。所以這里羅嗦一下。   所有的樹都是節點                   
**
***
swing中Jtree處理樹結構是通過樹模型接口，它實現了TreeNode接口（在api文檔中竟看不到此信息！），DefaultMutableTreeNode類實現了TreeNode接口，并提供了前,中,后序的樹遍歷能力。
JTree圖形化的顯示了樹結構的每一個節點，所有的UI控件都有兩個目的，顯示和輸入（輸入包括數據的輸入如JTextField和命令輸入如菜單，按鈕等），JTree既可以用于樹結構的顯示，也可以用于命令的輸入，或使得我們編輯樹節點。
樹節點可以被選中，它由TreeSelectionModel來控制，選擇涉及到維護作為TreeNode實例的樹節點間的路徑軌跡。樹控件典型的可以激發兩類事件：TreeModelEvent和TreeExpansionEvent，當然其他Awt和Swing事件也可由樹控件激發（看其繼承層次結構即可知）比如MouseListener可用來截取鼠標事件。JTree擴展了Scrollable接口，可被放在一個滾動面板中。

JTree的構造：可使用默認的構造方法，提供一個TreeNode作為其根節點，提供一個TreeModel包含所有其它的節點，或提供一個一維數組，向量，或對象的哈希表，對于這些集合中的單個元素，如果它又是一個集合，那么他們會被解釋顯示為子樹，該功能由JTree的內部類DynamicUtilTreeNode完成。
***
****
TreeModel接口：
該接口的實現者為JTree提供顯示的數據，如果你熟悉MVC模式，你應該明白所有的swing或awt控件中模型的作用就是為相應的控件提供數據。當模型的數據結構有所變化時它會通知視圖（這里就是JTree）來更新顯示。當然模型也可以添加其他的監聽器如Jtree的addTreeModelListener，你可以實現該監聽器，來使你自己的類接收模型變化給你的通知。如果你不熟悉MVC模式，請參考POSA卷一或其他資料，順便提一下在我們學校GUI時都知道有MVC模式的應用，往往不知道那個Controller是什么類，其實就是視圖的監聽器，比如ActionListener，注意別被眾多的監聽器弄昏了，一類是模型需要添加的，一類是視圖（比如JComponent的子類）需要添加的。控制的流向或數據的流向是相反的，視圖需要添加的監聽器（我們常常實現他們）才是控制器。

因為模型和視圖都能夠觸發事件，比如視圖（JTree等控件）是觸發用戶輸入導致的事件，而模型觸發的事件是因為模型中維護的數據有所變動才觸發的（比如，樹模型中樹節點的增刪，改，或樹路徑的變動）。而他們都使用了觀察者模式，算了不多說了，到時全弄成模式了，會搞昏大家的。繼續....

JTree的setModel和getModel方法是用來更換/設置和獲取模型的方法。你可替換現有JTree的模型，或者你想這樣用，兩個模型，一個用，一個備。如果構造模型復雜耗時的話，先在后臺構造好一個在換掉原先的。就如同雙緩沖技術的思路那樣。
****
*****
雜項：
DefultTreeModel是對TreeModel接口的默認實現類，
TreeNode接口可告訴你改實現者是否為一個葉子，一個父節點等。MutalbeTreeNode接口擴展了TreeNode接口，我們可在該實現者中存放一個我們自己的類實例（setUserObject（）/getUserObject）;
defaultMutableTreeNode 實現了MutableTreeNode接口，children()方法返回以一維向量形式存放的直接子節點的枚舉，也可以使用getChildAt()返回特定索引位置的子節點（注意子節點完全可以是一顆子樹）該類提供了前中后序訪問樹的能力：preorderEnumeration()，,breadthFirstEnumeration()，depthFirstEnumeration(）postorderEnumeration()最后兩個方法同行為，只不過是不同的稱號而已。

TreePath：該類用一系列節點表示一個從樹根到一個節點的路徑，它是只讀的，提供與其他路徑比較的能力。
TreeCellRenderrer接口：渲染tree的一個單元的組件，我們自己實現該接口并用jtree的setCellRenderer（）方法替換原先的渲染器，可以是樹節點在選中，獲取焦點，不同的樹狀態（葉子或父節點，展開，或收縮）等不同的狀態下的外觀。
DefaultTreeCellRenderer類是TreeCellRenderrer接口的默認實現，它擴展了JLabel，并基于以上描述的樹狀態來渲染樹節點，其提供的屬性包括圖標，背景色，前景色等，其get和set方法是我們可以訪問的，通過這些方法你當然可以換掉樹節點的圖標了。

CellEditor接口：定義了控制何時編輯將開始，結束，提取一個新的結果，是否編輯請求改變當前組件的選擇，請參考API文檔看該接口的方法。該接口在JTree和JTable中都有用到。，該接口也可以添加監聽器，當編輯停止或取消時會激發ChangeEvents到其所有的注冊處理器哪里。
TreeCellEditor接口擴展了CellEditor接口，jtree的setCellEditor()使得我們可以用任何一個可充當編輯器的組件替換掉原來的那個。DefaultCellEditor實現了該接口，這個編輯器允許使用JTextField，JComboBox或是JCheckBox組件來編輯數據，其保護的內部類EditorDelegate會響應getCellEditorValue（）方法把當前值返回。DefaultCellEditor僅基于以上三個J控件作為編輯器，其clickCountToStart方法決定鼠標單擊幾次會觸發編輯。默認對于JTextField是兩次，JComboBox和JCheckBox是一次，changeEvents會在stopCellEditing（）和cancelCellEditing（）時激發。
DefaultTreeCellEditor擴展了DefaultCellEditor類并且是TreeCellEditor的默認實現類，他使用JTextField來編輯節點數據，在鍵入ENTER鍵后stopCellEditing（）會被調用。對于樹節點的編輯我們可添加自己的時間監聽器來處理他們。默認時編輯開始于節點被單擊三次或兩次（時間間隔在內部會用一個定時器來決定），也可以改變他們的數目setClickCountToStart()；
JTree的選擇是基于行和樹路徑的，我們可以選擇使用那個。

TreeSelectionModel接口用于樹選擇模型，支持三種選擇，SINGLE_TREE_SELECTION，
DISCONTIGUOUS_TREE_SELECTION，CONTIGUOUS_TREE_SELECTION，set/getSelectionMode()可以訪選擇模型。getSelectionPath『s』()會返回一個當前選中的樹路徑。DefaultTreeSelectionModel默認實現了該接口，該類提供TreeSelectionlistener通知，當樹路徑選擇發生變化時。

TreeModelListener實現者可以偵聽模型變化，TreeSelectionListener用來偵聽視圖JTree的selection（僅有一個方法valueChanged(TreeSlectcionEvent tsEvt)）;
TreeExpansionListener用來對樹展開收縮進行處理。
TreeW illExpandListener在樹“將要”展開和收縮時得到通知，你可截獲處理，ExpandVetoException異常如果拋出，那么樹不會展開和收縮。

TreeModelEvent，用來通知模型的監聽器，JTree的數據部分或全部發生了變化。該事件對象封裝了源組件的引用，封裝了一個TreePath或一個用來表示路徑的數組。
TreeselectionEvent，視圖會用其通知所有視圖監聽器TreeSelectionListeners，選擇發生了變化。
TreeExpansionEvent，用來封裝相應最近或可能展開或收縮的TreePath，使用getPath()方法訪問樹路徑。
ExpandVetoException異常可由TreeWillExpandListener拋出，來否決樹路徑的展開和收縮。

JTree提供的現成方便的UI屬性：
myJTree.putClientProperty("JTree.lineStyle", "Angled");//更改線型。
如同其他Swing組件，我們也可以改變默認的用于JTree的ＵＩ資源（全局性的）：
UIManager.put("Tree.hash",
new ColorUIResource(Color.lightGray));／／改變渲染節點間edges邊的顏色。
UIManager.put("Tree.openIcon", new IconUIResource(
new ImageIcon("myOpenIcon.gif")));//改變一個打開的樹節點的圖標。同理可用于其它情況：Tree.leafIcon, Tree.expandedIcon，和Tree.closedIcon， Tree.collapsedIcon。

其他控制TreeＵＩ顯示的方法：
myTree.setRowHeight()／／控制樹節點的行高，
JTree的UI委托也提供了更改樹外觀的方法（相比于ＵＩＭａｎａｇｅｒ的方法，這里是局部的）。
BasicTreeUI basicTreeUI = (BasicTreeUI) myJTree.getUI();
basicTreeUI.setRightChildIndent(10);
basicTreeUI.setLeftChildIndent(8);

以上簡要提及了ＪＴｒｅｅ的方方面面,許多的事件，將聽器模型，請仔細分析，一定要分清哪些是針對模型的那些是針對視圖的。

*****
******
簡單的示例，我這里僅用到了最簡單的樹構造方法，和一個監聽器，在
以后我的自學過程中，我會繼續試用其他的JTree知識，我的JTree學習
最終都是想實現那個ＧＵＩ上的授權控制系統，請參考其他篇章，
至于這里用到的LAndFSysMenu類，在我的其他篇章中有該類的實現。
package jTreeDemo;

import java.awt.Container;
import javax.swing.*;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import lookAndFeelSys.*;
import userInterfaces.UIUtil;
import java.awt.*;
import java.util.Hashtable;
import java.util.Vector;
import javax.swing.tree.*;

public class JTreeTest extends JFrame{

public static void main(String[] args){
new JTreeTest("測試");
}

public JTreeTest(String title){
   super(title);
   biuldFrame();
}

   private void biuldFrame(){
    JMenuBar jmb=new JMenuBar();
   
    JMenu jm=new LAndFSysMenu();
    //JMenu jm=new JMenu("hello");
   
    jmb.add(jm);
    this.setJMenuBar(jmb);
   
    buildFrmContent();   
   
    UIUtil.SetComponentDimension(this,0.5,0.6);
    UIUtil.SetComponentToCenterOfScreen(this);
    this.setVisible(true);
    this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
   }
  
   private void buildFrmContent(){
    Container root_c=this.getContentPane();
    JTabbedPane jtp=new JTabbedPane();
    Container c = new JPanel();
    jtp.addTab("靜態樹組件練習",c );
    jtp.addTab("事件監聽",this.treeDemo2());
     

   root_c.add(jtp);

c.setLayout(new GridLayout(2,4));
JScrollPane jsp_1=new JScrollPane();
JScrollPane jsp_2=new JScrollPane();
JScrollPane jsp_3=new JScrollPane();
JScrollPane jsp_4=new JScrollPane();


/*為JTree準備顯示的模型*/
Object[] m1=new String[]{"節點1","節點2","節點3"};
Object[] m2=new String[][]{
    {"1.1","1.2","1.3"},
    {"2.1","2.2","2.3"},
    {"3.1","3.2","3.3"}
};
Vector<Object> m3=new Vector<Object>();
m3.add("1");
m3.add("2");
m3.add(m1);
m3.add(m2);
Hashtable<String,Object> m4=new Hashtable<String,Object>();
m4.put("子一","葉子");
m4.put("子二", m1);
m4.put("子三",m3);


JTree jtr_1=new JTree(m1);
jsp_1.getViewport().add(jtr_1);
JTree jtr_2=new JTree(m2);
jsp_2.getViewport().add(jtr_2);
JTree jtr_3=new JTree(m3);
jsp_3.getViewport().add(jtr_3);
JTree jtr_4=new JTree(m4);
jsp_4.getViewport().add(jtr_4);


c.add(jsp_1);
c.add(jsp_2);
c.add(jsp_3);
c.add(jsp_4);

/*jsp_1.getViewport().add(jtr_1);
c.add(jsp_1);*/
   }

   /*<<     另一組JTree實例：*/
   private JPanel treeDemo2(){
    JPanel rsltPanel=new JPanel();
    rsltPanel.setLayout(new BorderLayout());
   
    JLabel jl_msg=new JLabel("此標簽用來顯示樹選擇情況");
    JScrollPane jsp_1=new JScrollPane();
    Object[] m=new String[]{"節點1","節點2","節點3"};
    JTree jtr=new JTree(m);
    jtr.getSelectionModel()
    .addTreeSelectionListener(new MySelectionLstnr(
      jl_msg));
   
    jsp_1.getViewport().add(jtr);
   
    rsltPanel.add(jsp_1,BorderLayout.CENTER);
    rsltPanel.add(jl_msg,BorderLayout.SOUTH);
    return rsltPanel;
   }
   class MySelectionLstnr implements TreeSelectionListener{
    //該內部類實現樹監聽器，在樹被選中后將選中的節點
    //信息打印到一個Label上
    private JLabel jl_msg=null;
   
    public MySelectionLstnr(JLabel msgLabel){
    this.jl_msg=msgLabel;
    }
@Override
public void valueChanged(TreeSelectionEvent e) {
   // 凡是樹選擇的處理都涉及到樹路徑的處理：
   TreePath path = e.getPath();
   Object[] nodes = path.getPath();
  
   //當前選中的節點是樹路徑上最后一個節點
     Object selectedNode=nodes[nodes.length-1 ];
     if(this.jl_msg!=null){
     this.jl_msg.setText("選中的節點上的文本是："+
         selectedNode.toString());
     }
}


   }
   /*另一組JTree實例：>>*/
}

******
參考Java Swing （Manning出版社）swing hack （orelly出版社）。

今天終于耐著性子弄懂了GridBagLayout是怎么使用的。
構造函數：
    GirdBagLayout()建立一個新的GridBagLayout管理器。
    GridBagConstraints()建立一個新的GridBagConstraints對象。
    GridBagConstraints(int gridx,int gridy,
                                   int gridwidth,int gridheight,
                                   double weightx,double weighty,
                                   int anchor,int fill, Insets insets,
                                   int ipadx,int ipady)建立一個新的GridBagConstraints對象，并指定其參數的值。
看著這一堆的參數就快煩死了，下面就了解一下參數的意思：

參數說明：
 gridx,gridy    ——    設置組件的位置，
                   gridx設置為GridBagConstraints.RELATIVE代表此組件位于之前所加入組件的右邊。
                   gridy設置為GridBagConstraints.RELATIVE代表此組件位于以前所加入組件的下面。
                  建議定義出gridx,gridy的位置以便以后維護程序。gridx=0,gridy=0時放在0行0列。

 gridwidth,gridheight    ——    用來設置組件所占的單位長度與高度，默認值皆為1。
                 你可以使用GridBagConstraints.REMAINDER常量，代表此組件為此行或此列的最后一個組件，而且會占據所有剩余的空間。

 weightx,weighty    ——    用來設置窗口變大時，各組件跟著變大的比例。
                當數字越大，表示組件能得到更多的空間，默認值皆為0。

 anchor    ——    當組件空間大于組件本身時，要將組件置于何處。
               有CENTER(默認值)、NORTH、NORTHEAST、EAST、SOUTHEAST、WEST、NORTHWEST選擇。

 insets    ——    設置組件之間彼此的間距。
              它有四個參數，分別是上，左，下，右，默認為(0,0,0,0)。

ipadx,ipady    ——    設置組件間距，默認值為0。

GridBagLayout里的各種設置都必須通過GridBagConstraints，因此當我們將GridBagConstraints的參數都設置
好了之后，必須new一個GridBagConstraints的對象出來，以便GridBagLayout使用。

代碼片斷：
       JButton b;
      GridBagConstraints c;
      int gridx,gridy,gridwidth,gridheight,anchor,fill,ipadx,ipady;
      double weightx,weighty;
      Insets inset;
     
      JFrame f=new JFrame();
     
      GridBagLayout gridbag=new GridBagLayout();
      Container contentPane=f.getContentPane();
      contentPane.setLayout(gridbag);
       
        b=new JButton("first");
        gridx=0;
        gridy=0;
        gridwidth=1;
        gridheight=1;
        weightx=10;
        weighty=1;
        anchor=GridBagConstraints.CENTER;
        fill=GridBagConstraints.HORIZONTAL;
        inset=new Insets(0,0,0,0);
        ipadx=0;
        ipady=0;
        c=new GridBagConstraints(gridx,gridy,gridwidth,gridheight,weightx,weighty,anchor,fill,inset,ipadx,ipady);
        gridbag.setConstraints(b,c);
        contentPane.add(b);

GridBagLayout這種管理器是十分靈活的，只不過他寫起來比較麻煩，不過用了之后才發現他對界面的部署幫助很大。
 

本文來自CSDN博客，轉載請標明出處：http://blog.csdn.net/dracularking/archive/2008/04/22/2314336.aspx

下面的是這個界面的一個原始草圖：

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

public class GridBagWindow extends JFrame {

private JButton searchBtn;

private JComboBox modeCombo;

private JLabel tagLbl;

private JLabel tagModeLbl;

private JLabel previewLbl;

private JTable resTable;

private JTextField tagTxt;

public GridBagWindow() {

Container contentPane = getContentPane();

GridBagLayout gridbag = new GridBagLayout();

contentPane.setLayout(gridbag);

GridBagConstraints c = new GridBagConstraints();

//setting a default constraint value

c.fill =GridBagConstraints.HORIZONTAL;

tagLbl = new JLabel("Tags");

c.gridx = 0; //x grid position

c.gridy = 0; //y grid position

gridbag.setConstraints(tagLbl, c); //associate the label with a constraint object

contentPane.add(tagLbl); //add it to content pane

tagModeLbl = new JLabel("Tag Mode");

c.gridx = 0;

c.gridy = 1;

gridbag.setConstraints(tagModeLbl, c);

contentPane.add(tagModeLbl);

tagTxt = new JTextField("plinth");

c.gridx = 1;

c.gridy = 0;

c.gridwidth = 2;

gridbag.setConstraints(tagTxt, c);

contentPane.add(tagTxt);

String[] options = {"all", "any"};

modeCombo = new JComboBox(options);

c.gridx = 1;

c.gridy = 1;

c.gridwidth = 1;

gridbag.setConstraints(modeCombo, c);

contentPane.add(modeCombo);

searchBtn = new JButton("Search");

c.gridx = 1;

c.gridy = 2;

gridbag.setConstraints(searchBtn, c);

contentPane.add(searchBtn);

resTable = new JTable(5,3);

c.gridx = 0;

c.gridy = 3;

c.gridwidth = 3;

gridbag.setConstraints(resTable, c);

contentPane.add(resTable);

previewLbl = new JLabel("Preview goes here");

c.gridx = 0;

c.gridy = 4;

gridbag.setConstraints(previewLbl, c);

contentPane.add(previewLbl);

addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e) {

System.exit(0);

}

});

}

public static void main(String args[]) {

GridBagWindow window = new GridBagWindow();

window.setTitle("GridBagWindow");

window.pack();

window.setVisible(true);

}

}

package client.test;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.httpclient.HostConfiguration;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.htmlparser.Node;
import org.htmlparser.NodeFilter;
import org.htmlparser.Parser;
import org.htmlparser.filters.AndFilter;
import org.htmlparser.filters.HasAttributeFilter;
import org.htmlparser.filters.TagNameFilter;
import org.htmlparser.nodes.TagNode;
import org.htmlparser.util.NodeList;
import org.htmlparser.util.ParserException;

public class TIPOTest {

 private static String mainPageUrl = "http://twpat.tipo.gov.tw/twcgi/ttsweb?@0:0:1:twpat2@@"
   + Math.random();
 public static String strEncoding = "utf-8"; //strEncoding = "iso-8859-1";
 final static String userAgent = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0; .NET CLR 1.0.3705)";

 public static void main(String[] args) throws Exception {
//  HttpClient client = new HttpClient();
//  client.getHostConfiguration().setProxy("10.41.16.98", 808);
//  client.getHostConfiguration().setHost(
//    "http://twpat3.tipo.gov.tw/tipotwoc", 80, "http");

//  String strLegalStatus = null;
  String mainPage = doGetMethod(mainPageUrl);

  String searchPageUrl = parserMainPage(mainPage);

  String searchPage = doGetMethod(searchPageUrl);

  String queryPageUrl = getQueryPageUrl(searchPage);

  String queryPage = doGetMethod(queryPageUrl);

  String searchResultUrl = parserPageForPostURL(queryPage);
  Map parameterMap = parseParameters(queryPage);

  System.out.println("searchResultUrl : " + searchResultUrl);

  String response = getResultPage(searchResultUrl, "087121847",
    parameterMap);

  // HttpMethod method = getPostMethod(); // 使用 POST 方式提交數據
  // // HttpMethod method = getGetMethod(); // 使用 GET 方式提交數據
  // client.executeMethod(method); // 打印服務器返回的狀態
  // System.out.println(method.getStatusLine()); // 打印結果頁面
  // String response = new
  // String(method.getResponseBodyAsString().getBytes(
  // "8859_1"));

  // 打印返回的信息
  System.out.println(response);
  // 釋放連接
  // method.releaseConnection();
 }

 private static String doGetMethod(String url) throws Exception {
  try {
   HttpClient httpClient = new HttpClient();
   HostConfiguration hc = httpClient.getHostConfiguration();

   hc.setProxy("10.41.16.98", 808);
   httpClient.getState().setAuthenticationPreemptive(true);

   GetMethod getMethod = new GetMethod(url);

   getMethod.setRequestCharSet(strEncoding);
   getMethod.setResponseCharSet(strEncoding);
   getMethod.setRequestHeader("User-Agent", userAgent);
   getMethod.setTimeout(1000 * 60 * 2);
   int StatusCode = httpClient.executeMethod(getMethod);
   if (StatusCode >= 400) {
    getMethod.getConnection().close();
    throw new Exception("Can't get information.");
   }
   String str = getMethod.getResponseBodyAsString();
   getMethod.releaseConnection();

   writeStrToTxt(str);// wuwen add for test

   return str;
  } catch (Exception e) {
   e.printStackTrace();
   throw e;
  }
 }

 static int i = 1;

 // wuwen add for test
 public static void writeStrToTxt(String str) {
  i++;
  BufferedWriter output;
  try {
   output = new BufferedWriter(new FileWriter(
     "C:\\Documents and Settings\\F3223114\\桌面\\" + i + ".txt"));

   output.write(str);
   output.close();

  } catch (IOException e) {
   e.printStackTrace();
  }
 }

 private static String parserMainPage(String body) {
  String parserSearchUrl = "";
  /*
   * String regEx = "href=(.+?)\\s*class=menu"; Pattern pattern =
   * Pattern.compile(regEx, Pattern.CASE_INSENSITIVE); Matcher matcher =
   * pattern.matcher(body); while (matcher.find()) { if
   * (matcher.group(1).contains(":80:::0")) { parserSearchUrl =
   * matcher.group(1); } }
   */
  int i = body.indexOf("http");
  if (i != -1) {
   parserSearchUrl = body.substring(i, body.indexOf(">", i));
  }
  return parserSearchUrl;
 }

 public String getMidString(String sInput, String sStartTag, String sEndTag) {
  int i, j = -1;
  if ((i = sInput.indexOf(sStartTag)) < 0) {
   return null;
  } else {
   if ((j = sInput.indexOf(sEndTag, i + sStartTag.length())) < 0) {
    return null;
   } else {
    if (i + sStartTag.length() == j) {
     return null;
    } else {
     return sInput.substring(i + sStartTag.length(), j);
    }
   }
  }
 }

 private static String doPostMethod(String url, NameValuePair[] nameValuePair)
   throws Exception {
  try {
   HttpClient httpClient = new HttpClient();
   HostConfiguration hc = httpClient.getHostConfiguration();
   hc.setProxy("10.41.16.98", 808);
   httpClient.getState().setAuthenticationPreemptive(true);

   PostMethod postMethod = new PostMethod(url);
   postMethod.setRequestCharSet(strEncoding);
   postMethod.setResponseCharSet(strEncoding);
   postMethod.setRequestHeader("User-Agent", userAgent);
   postMethod.setTimeout(1000 * 60 * 2);
   postMethod.setRequestBody(nameValuePair);
   int StatusCode = httpClient.executeMethod(postMethod);
   if (StatusCode >= 400) {
    postMethod.getConnection().close();
    throw new Exception("Can't get information.");
   }
   String str = postMethod.getResponseBodyAsString();

   postMethod.releaseConnection();
   return str;
  } catch (Exception e) {
   e.printStackTrace();
   throw e;
  }
 }

 // modify by zhuoluo 2008.12.09
 private static String getResultPage(String url, String strAppNo,
   Map parameterMap) throws Exception {
  try {
   NameValuePair _0_1_T = new NameValuePair("@_0_1_T", "T_UID");
   _0_1_T.setHeadNeedEncode(false);
   NameValuePair _0_1_T_1 = new NameValuePair("_0_1_T", "");
   _0_1_T_1.setHeadNeedEncode(false);
   NameValuePair _0_2_P = new NameValuePair("@_0_2_P", "P_PWD");
   _0_2_P.setHeadNeedEncode(false);
   NameValuePair _0_2_P_1 = new NameValuePair("_0_2_P", "");
   _0_2_P_1.setHeadNeedEncode(false);
   NameValuePair _20_0_T = new NameValuePair("@_20_0_T", "T_AN");
   _20_0_T.setHeadNeedEncode(false);
   NameValuePair appNo = new NameValuePair("_20_0_T", strAppNo);
   appNo.setHeadNeedEncode(false);
   NameValuePair _20_1_K = new NameValuePair("@_20_1_K", "K_NE");
   _20_1_K.setHeadNeedEncode(false);
   NameValuePair _20_1_K_1 = new NameValuePair("_20_1_K", "");
   _20_1_K_1.setHeadNeedEncode(false);
   NameValuePair JPAGE = new NameValuePair("JPAGE", "");
   JPAGE.setHeadNeedEncode(false);

   NameValuePair INFO = new NameValuePair("INFO", parameterMap.get(
     "INFO").toString());
   INFO.setHeadNeedEncode(false);

//   NameValuePair x = new NameValuePair("_IMG_%E6%AA%A2%E7%B4%A2.x",
//     "39");
//   x.setHeadNeedEncode(false);
//   NameValuePair y = new NameValuePair("_IMG_%E6%AA%A2%E7%B4%A2.y",
//     "10");
//   y.setHeadNeedEncode(false);
   NameValuePair x = new NameValuePair("_IMG_%E6%AA%A2%E7%B4%A2%25z.x",
   "39");
   x.setHeadNeedEncode(false);
   NameValuePair y = new NameValuePair("_IMG_%E6%AA%A2%E7%B4%A2%25z.y",
   "10");
   y.setHeadNeedEncode(false);

   NameValuePair[] nameValuePair = new NameValuePair[] { _0_1_T,
     _0_1_T_1, _0_2_P, _0_2_P_1, _20_0_T, appNo, _20_1_K,
     _20_1_K_1, x, y , INFO };
//   NameValuePair[] nameValuePair = new NameValuePair[] { _0_1_T,
//     _0_1_T_1, _0_2_P, _0_2_P_1, _20_0_T, appNo, _20_1_K,
//     _20_1_K_1, JPAGE, INFO };//x, y ,
   String str = doPostMethod(url, nameValuePair);

   writeStrToTxt(str);// wuwen add for test

   return str;
  } catch (Exception e) {
   e.printStackTrace();
   throw e;
  }
 }

 private static String getQueryPageUrl(String body) {
  Parser parser = Parser.createParser(body, "utf-8");
  NodeFilter filter_constellation_summart = new AndFilter(
    (new TagNameFilter("a")), (new HasAttributeFilter("class",
      "menu")));
  NodeList nodeList = null;
  String href = "";
  try {
   nodeList = parser
     .extractAllNodesThatMatch(filter_constellation_summart);
   Node node = null;
   node = nodeList.elementAt(3);
   href = ((TagNode) node).getAttribute("href");
  } catch (ParserException ex) {
  }

  return href;
 }

 private static String parserPageForPostURL(String body)
   throws ParserException {
  String searchResultUrl = "";
  NodeFilter tagFilter = new TagNameFilter("FORM");
  Parser parser = Parser.createParser(body, "UTF-8");
  NodeList list = parser.extractAllNodesThatMatch(tagFilter);
  for (int i = 0; i < list.size(); i++) {
   Node node = list.elementAt(i);
   if (node instanceof TagNode) {
    String methodValue = ((TagNode) node).getAttribute("METHOD");
    if (methodValue != null) {
     String actionPath = ((TagNode) node).getAttribute("ACTION");
     searchResultUrl = actionPath;
    }
   }
  }
  return searchResultUrl;
 }

 private static Map<String, String> parseParameters(String pageBody)
   throws ParserException {
  Map<String, String> parameterMap = new HashMap<String, String>();
  NodeFilter tagFilter = new TagNameFilter("input");
  Parser parser = Parser.createParser(pageBody, "UTF-8");
  NodeList list = parser.extractAllNodesThatMatch(tagFilter);
  for (int i = 0; i < list.size(); i++) {
   Node node = list.elementAt(i);
   if (node instanceof TagNode) {
    String nodeName = ((TagNode) node).getAttribute("name");
    String nodeValue = ((TagNode) node).getAttribute("value");

    if (nodeName != null) {
     if (nodeName.equals("INFO")) {
      if (nodeValue == null) {
       nodeValue = "";
      }
      parameterMap.put(nodeName, nodeValue);
     }
    }
   }
  }
  return parameterMap;
 }
}

RMI原理及實現
簡介
　　RMI是遠程方法調用的簡稱，象其名稱暗示的那樣，它能夠幫助我們查找并執行遠程對象的方法。通俗地說，遠程調用就象將一個class放在A機器上，然后在B機器中調用這

個class的方法。
　　我個人認為，盡管RMI不是唯一的企業級遠程對象訪問方案，但它卻是最容易實現的。與能夠使不同編程語言開發的CORBA不同的是，RMI是一種純Java解決方案。在RMI

中，程序的所有部分都由Java編寫。
　　在看本篇文章時，我假定讀者都已經具備了較扎實的Java基礎知識，在這方面有欠缺的讀者請自行閱讀有關資料。
　　概念
　　我在前面已經提到，RMI是一種遠程方法調用機制，其過程對于最終用戶是透明的：在進行現場演示時，如果我不說它使用了RNI，其他人不可能知道調用的方法存儲在其他

機器上。當然了，二臺機器上必須都安裝有Java虛擬機（JVM）。
　　其他機器需要調用的對象必須被導出到遠程注冊服務器，這樣才能被其他機器調用。因此，如果機器A要調用機器B上的方法，則機器B必須將該對象導出到其遠程注冊服務器

。注冊服務器是服務器上運行的一種服務，它幫助客戶端遠程地查找和訪問服務器上的對象。一個對象只有導出來后，然后才能實現RMI包中的遠程接口。例如，如果想使機器A

中的Xyz對象能夠被遠程調用，它就必須實現遠程接口。
　　RMI需要使用占位程序和框架，占位程序在客戶端，框架在服務器端。在調用遠程方法時，我們無需直接面對存儲有該方法的機器。
　　在進行數據通訊前，還必須做一些準備工作。占位程序就象客戶端機器上的一個本機對象，它就象服務器上的對象的代理，向客戶端提供能夠被服務器調用的方法。然

后，Stub就會向服務器端的Skeleton發送方法調用，Skeleton就會在服務器端執行接收到的方法。
　　Stub和Skeleton之間通過遠程調用層進行相互通訊，遠程調用層遵循TCP/IP協議收發數據。下面我們來大致了解一種稱為為“綁定”的技術。
　　客戶端無論何時要調用服務器端的對象，你可曾想過他是如何告訴服務器他想創建什么樣的對象嗎？這正是“綁定”的的用武之地。在服務器端，我們將一個字符串變量與一個

對象聯系在一起（可以通過方法來實現），客戶端通過將那個字符串傳遞給服務器來告訴服務器它要創建的對象，這樣服務器就可以準確地知道客戶端需要使用哪一個對象了。所

有這些字符串和對象都存儲在的遠程注冊服務器中。
　　在編程中需要解決的問題
　　在研究代碼之前，我們來看看必須編寫哪些代碼：
　　遠程對象：這個接口只定義了一個方法。我們應當明白的是，這個接口并非總是不包括方法的代碼而只包括方法的定義。遠程對象包含要導出的每個方法的定義，它還實

現Java.rmi中的遠程接口。
　　遠程對象實現：這是一個實現遠程對象的類。如果實現了遠程對象，就能夠覆蓋該對象中的所有方法，因此，遠程對象的實現類將真正包含我們希望導出的方法的代碼。
　　遠程服務器：這是一個作為服務器使用的類，它是相對于要訪問遠程方法的客戶端而言的。它存儲著綁定的字符串和對象。
　　遠程客戶端：這是一個幫助我們訪問遠程方法提供幫助的類，它也是最終用戶。我們將使用查找和調用遠程方法的方法在該類中調用遠程方法。
　　編程
　　我們將首先編寫遠程對象，并將代碼保存為名字為AddServer.Java的文件：
　　import Java.rmi.*;
　　public interface AddServer extends Remote {
　　public int AddNumbers(int firstnumber,int secondnumber) throws RemoteException;
　　}
　　我們來看看上面的代碼。首先，為了使用其內容，我們導入rmi包。然后，我們創建一個擴展了Java.rmi中遠程接口的接口。所有的遠程對象必須擴展該遠程接口，我們將該

遠程接口稱為AddServer。在該遠程對象中，有一個名字為AddNumbers的方法，客戶端可以調用這一方法。我們必須記住的是，所有的遠程方法都需要啟

動RemoteException方法，有錯誤發生時就會調用該方法。
　　下面我們開始編寫遠程對象的實現。這是一個實現遠程對象并包含有所有方法代碼的類，將下面的代碼保存為名字為AddServerImpl.Java的文件：
　　import Java.rmi.*;
　　public class AddServerImpl extends UnicastRemoteObject implements AddServer {
　　public AddServerImpl() {
　　super();
　　}
　　public int AddNumbers(int firstnumber,int secondnumber) throws RemoteException {
　　return firstnumber + secondnumber;
　　}
　　}
　　首先，我們導入rmi包，然后創建一個擴展UnicastRemoteObject和實現創建的遠程對象的類；其次，我們可以為類創建一個缺省的構建器。我們還了解了AddNumbers方

法的代碼，它啟動RemoteException。這樣我們就覆蓋了創建的遠程對象中的方法。AddNumbers方法的代碼非常好理解，它接受2個整型參數，然后相加并返回它們的和。
　　至此，我們已經有了二個Java文件：遠程對象和遠程對象的實現。下面我們將使用Javac命令編譯這二個文件：
　　編譯遠程對象：
　　C:\jdk\bin\Javac workingdir\AddServer.Java
　　編譯遠程對象實現：
　　C:\jdk\bin\Javac workingdir\AddServerImpl.Java 這樣，就會達到二個Java文件和二個類文件，下面我們將創建stub和skeleton。為了創建stub和skeleton文件，

我們必須使用rmic編譯器編譯遠程對象實現文件。
　　用Rmic編譯遠程對象實現文件：
　　C:\jdk\bin\rmic workingdir\AddServerImpl.Java 然后，我們就會發現多了2個新建的類文件，它們分別是AddServerImpl_Stub.class

和AddServerImpl_Skel.class 。
　　The Coding (Contd.)
　　我們已經編譯了所有的源代碼，下面我們來創建客戶端和服務器端，將下面的代碼保存為名字為RmiServer.Java的文件：
　　import Java.rmi.*;
　　import Java.net.*;
　　public class RmiServer {
　　public static void main (String args[]) throws RemoteException, MalformedURLException {
　　AddServerImpl add = new AddServerImpl();
　　Naming.rebind("addnumbers",add);
　　}
　　}
　　首先，我們導入Java.rmi包和Java.net包。另外，我們還使用throws從句捕獲任何異常。我們從對象中得出遠程對象實現，使用rebind方法將字符串addnumbers與該對

象綁定。下面的例子顯示了綁定的含義：
　　從現在開始，無論何時客戶端要調用遠程對象，使用字符串addnumbers就可以實現。rebind方法有二個參數：第一個參數是字符串變量，第二個參數是遠程對象實現類的

對象。
　　下面我們來創建客戶端，將下面的代碼保存為名字為RmiClient.Java的文件：
　　import Java.rmi.*;
　　import Java.net.*;
　　public class RmiClient {
　　public static void main(String args[]) throws RemoteException, MalformedURLException {
　　String url="rmi://127.0.0.1/addnumbers";
　　AddServer add;
　　add = (AddServer)Naming.lookup(url);
　　int result = add.AddNumbers(10,5);
　　System.out.println(result);
　　}
　　}
　　首先，我們導入Java.rmi包和Java.net包，并使用throws從句捕獲所有必要的異常。然后通過利用Naming類中的靜態lookup方法從遠程對象中得到一個對象。（這也是我

們無需從Naming類中得到一個對象并調用它。而只使用類名字的原因。）
　　lookup方法接受遠程對象的完整的URL名字，該URL由完整的機器IP地址以及與對象綁定的字符串（也誻對象的綁定名）組成。在調用遠程對象時，我們使用了RMI協

議。lookup方法向我們返回一個對象，在能夠使用它前，我們必須將它的數據類型轉換為與遠程對象的數據類型一致。
　　Since we have both our server and client source ready, let's compile them both:
　　至此，我們已經有了服務器端和客戶端的源代碼，下面我們來編譯這二個源文件：
　　編譯遠程服務器：
　　C:\jdk\bin\Javac workingdir\RmiServer.Java
　　編譯遠程客戶端：
　　C:\jdk\bin\Javac workingdir\RmiClient.Java
　　在對我們的代碼進行測試前，還必須首先啟動RMI Registry。RMI Registry存儲有所有綁定的數據，沒有它，RMI就不能正常地運行！
　　啟動Rmi Registry服務器：
　　C:\jdk\bin\start rmiregistry
　　我們會注意到，這時會出現一個空白的DOS提示符窗口，這表明Rmi Registry服務器在運行，注意不要關閉該窗口。然后，我們首先在一個DOS提示符窗口中運行Rmi服務

器，然后在另一個DOS提示符窗口中運行Rmi客戶端。
　　啟動RMI服務器：
　　C:\jdk\bin\Java workingdir\RmiServer
　　啟動RMI客戶端：
　　C:\jdk\bin\Java workingdir\RmiClient
　　如果一切正常，我們應該能夠得到15這個輸出。我們向AddNumbers方法輸入10和5二個數字，該方法將這二者加起來，并將其和15返回給我們。如果得到了15這個輸出，

說明我們已經成功地執行了一個遠程方法。當然，在這里，我們并沒有執行真正意義上的遠程方法，因為我們的計算機既是服務器，又是客戶機。如果有計算機網絡，我們就可以

方便地進行執行遠程方法的試驗了。

一.創建表格控件的各種方式:
1) 調用無參構造函數.
JTable table = new JTable();
2) 以表頭和表數據創建表格.
Object[][] cellData = {{"row1-col1", "row1-col2"},{"row2-col1", "row2-col2"}};
String[] columnNames = {"col1", "col2"};
   
JTable table = new JTable(cellData, columnNames);
3) 以表頭和表數據創建表格,并且讓表單元格不可改.
String[] headers = { "表頭一", "表頭二", "表頭三" };
Object[][] cellData = null; 

DefaultTableModel model = new DefaultTableModel(cellData, headers) {

public boolean isCellEditable(int row, int column) {
    return false;
}
};

table = new JTable(model);

二.對表格列的控制

0)獲取JTable中特定單元格的位置

table.addMouseListener(new MouseListener() {

        public void mouseClicked(MouseEvent e) {

                   int row = jt.rowAtPoint(e.getPoint());
                   int col = jt.columnAtPoint(e.getPoint());

}

});

   
1) 設置列不可隨容器組件大小變化自動調整寬度.
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
2) 限制某列的寬度.
TableColumn firsetColumn = table.getColumnModel().getColumn(0);
firsetColumn.setPreferredWidth(30);
firsetColumn.setMaxWidth(30);
firsetColumn.setMinWidth(30);
3) 設置當前列數.
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();
int count=5;
tableModel.setColumnCount(count);
4) 取得表格列數
int cols = table.getColumnCount();
5) 添加列
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();
tableModel.addColumn("新列名");
6) 刪除列
table.removeColumn(table.getColumnModel().getColumn(columnIndex));// columnIndex是要刪除的列序號
三.對表格行的控制
1) 設置行高
table.setRowHeight(20);
2) 設置當前航數
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();
int n=5;
tableModel.setRowCount(n);
3) 取得表格行數
int rows = table.getRowCount();

4) 添加表格行
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();
tableModel.addRow(new Object[]{"sitinspring", "35", "Boss"});
5) 刪除表格行
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();
model.removeRow(rowIndex);// rowIndex是要刪除的行序號
四.存取表格單元格的數據
1) 取單元格數據
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();
String cellValue=(String) tableModel.getValueAt(row, column);// 取單元格數據,row是行號,column是列號
2) 填充數據到表格.
注:數據是Member類型的鏈表,Member類如下:
public class Member{
    // 名稱
    private String name;
   
    // 年齡
    private String age;
   
    // 職務
    private String title;
}
填充數據的代碼:
public void fillTable(List<Member> members){
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();
tableModel.setRowCount(0);// 清除原有行
// 填充數據
for(Member member:members){
    String[] arr=new String[3];
    arr[0]=member.getName();
    arr[1]=member.getAge();
    arr[2]=member.getTitle();
   
    // 添加數據到表格
    tableModel.addRow(arr);
}
// 更新表格
table.invalidate();
}
2) 取得表格中的數據
public List<Member> getShowMembers(){
List<Member> members=new ArrayList<Member>();
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();
int rowCount=tableModel.getRowCount();
for(int i=0;i<rowCount;i++){
    Member member=new Member();
   
    member.setName((String)tableModel.getValueAt(i, 0));// 取得第i行第一列的數據

    member.setAge((String)tableModel.getValueAt(i, 1));// 取得第i行第二列的數據
    member.setTitle((String)tableModel.getValueAt(i, 2));// 取得第i行第三列的數據
   
    members.add(member);
}
return members;
}
五.取得用戶所選的行
1) 取得用戶所選的單行
int selectRows=table.getSelectedRows().length;// 取得用戶所選行的行數
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();

if(selectRows==1){
int selectedRowIndex = table.getSelectedRow(); // 取得用戶所選單行
.// 進行相關處理
}
2) 取得用戶所選的多行
int selectRows=table.getSelectedRows().length;// 取得用戶所選行的行數
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();

if(selectRows>1)
int[] selRowIndexs=table.getSelectedRows();// 用戶所選行的序列
for(int i=0;i<selRowIndexs.length;i++){
    // 用tableModel.getValueAt(row, column)取單元格數據
    String cellValue=(String) tableModel.getValueAt(i, 1);
}
}
六.添加表格的事件處理

view.getTable().addMouseListener(new MouseListener() {
public void mousePressed(MouseEvent e) {
    // 鼠標按下時的處理
}

public void mouseReleased(MouseEvent e) {
    // 鼠標松開時的處理
}

public void mouseEntered(MouseEvent e) {
    // 鼠標進入表格時的處理
}

public void mouseExited(MouseEvent e) {
    // 鼠標退出表格時的處理
}

public void mouseClicked(MouseEvent e) {
    // 鼠標點擊時的處理
}
});