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) {
    // 鼠标点击时的处理
}
});

Pixel length of String
import java.awt.FontMetrics;
import java.awt.geom.Rectangle2D;

1. awt
 Font font = new Font("Verdana", Font.PLAIN, 10); 
 FontMetrics metrics = new FontMetrics(font) { 
 }; 
 Rectangle2D bounds = metrics.getStringBounds("string", null); 
 int widthInPixels = (int) bounds.getWidth(); 

文章出处：飞诺网(www.firnow.com):http://dev.firnow.com/course/3_program/java/javajs/20091214/184739.html