在Java中通过Observable类和Observer接口实现了观察者模式。一个Observer对象监视着一个Observable对象的变化，当Observable对象发生变化时，Observer得到通知，就可以进行相应的工作。

如果画面A是显示数据库里面的数据，而画面B修改了数据库里面的数据，那么这时候画面A就要重新Load。这时候就可以用到观察者模式

二、观察者模式实现方法

java.util.Observable中有两个方法对Observer特别重要

①setChanged()方法

setChanged()方法 ——

用来设置一个内部标志位注明数据发生了变化

notifyObservers()方法 / notifyObservers(Object data)方法 ——

通知所有的Observer数据发生了变化，这时所有的Observer会自动调用复写好的update(Observable observable, Object data)方法来做一些处理（比如说画面数据的更新）。

我们可以看到通知Observer有两个方法，一个无参，一个有参。那么这个参数有什么作用呢？

其中一个作用：现在我不想通知所有的Observer，而只想其中一个指定的Observer做一些处理，那么就可以传一个参数作为ID，然后在所有的Observer中判断，每个Observer判断只有接收到底参数ID是属于自己的才做一些处理。

当然参数还有其他作用，我只是举了个例子。

下面举个例子加以说明：

然后在setData()方法里面，也就是数据改变的地方，来调用Observable类的setChanged()方法和notifyObservers()方法，表示数据已改变并通知所有的Observer调用它们的update()方法做一些处理。

注意：只有在setChange()被调用后，notifyObservers()才会去调用update()，否则什么都不干。

然后还要复写update()方法，做数据改变后的一些处理。

下面可以写一个简单的测试类来测试一下

属性 ——

方法 ——

注意：在Observer对象销毁前一定要用deleteObserver将其从列表中删除，也就是在onDestroy()方法中调用deleteObserver()方法。

不然因为还存在对象引用的关系，Observer对象不会被垃圾收集，造成内存泄漏，并且已死的Observer仍会被通知到，有可能造成意料外的错误，而且随着列表越来越大，notifyObservers操作也会越来越慢。

下面2个工程是Observable与Observer的经典运用,是android实现的单指拖动放大图片的操作

两个例子：

http://download.csdn.net/detail/tianjf0514/4237628

http://download.csdn.net/download/tianjf0514/4237634

Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

(1) newCachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。示例代码如下：

因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。
定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()

(3)  newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：

表示延迟3秒执行。

定期执行示例代码如下：

表示延迟1秒后每3秒执行一次。

(4) newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：

结果依次输出，相当于顺序执行各个任务。

你可以使用JDK自带的监控工具来监控我们创建的线程数量，运行一个不终止的线程，创建指定量的线程，来观察：
工具目录：C:\Program Files\Java\jdk1.6.0_06\bin\jconsole.exe
运行程序做稍微修改：

效果如下：

选择我们运行的程序：

监控运行状态

1、如何编写多线程Socket程序

了解Socket看这里：Socket是什么
多线程Socket与单线程类似，只是使用了多线程的方式来管理连接，主线程负责接收连接，在接到连接后变创建新的线程，每个线程负责与自己的客户端进行通信。

了解单线程Socket看这里：如何编写单多线程Socket程序

与单线程Socket例子相比来说，服务端可以与多个客户端进行通信了，不过多线程频繁的创建与销毁便会带来很大的资源开销，而系统的网络资源等都是有限的。因此一般会引入线程池，可以在某种程度上重用线程，减少线程的创建和销毁的次数以减少开销。

我们的代码也分为客户端和服务端两部分。服务端的代码中包含了使用和不使用线程池的两种方式。

服务端代码：

 1 import java.io.BufferedReader;
 2 import java.io.IOException;
 3 import java.io.InputStreamReader;
 4 import java.io.PrintWriter;
 5 import java.net.ServerSocket;
 6 import java.net.Socket;
 7 import java.util.concurrent.ExecutorService;
 8 import java.util.concurrent.Executors;
 9 
10 public class SocketThreadPoolDemoServer {
11 
12     private int port = 8000;
13 
14     private ServerSocket serverSocket;
15 
16     private ExecutorService executorService; // 连接池
17 
18     private final int POOL_SIZE = 1; // 连接池大小 , 若为 1 时最多支持 2 线程
19 
20     public SocketThreadPoolDemoServer() throws Exception {
21         serverSocket = new ServerSocket(port);
22         executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);// 初始化线程池
23         System.out.println("waitting connet");
24 
25     }
26 
27     /**
28      *
29      * 接受连接
30      *
31      * @author sunjie at 2016年6月14日
32      *
33      */
34     public void service() {
35         Socket socket = null;
36         while (true) {
37             try {
38                 socket = serverSocket.accept();
39                 executorService.execute(new Handler(socket)); // 使用连接池
40                 // new Thread(new Handler(socket)).start();// 不使用连接池
41             } catch (IOException e) {
42                 e.printStackTrace();
43             }
44         }
45     }
46 
47     /**
48      *
49      * 线程类，负责维持与一个客户端的通信
50      *
51      * @author sunjie at 2016年6月14日
52      *
53      */
54     class Handler implements Runnable {
55 
56         private Socket socket = null;
57 
58         public Handler(Socket socket) {
59             this.socket = socket;
60         }
61 
62         @Override
63         public void run() {
64             System.out.println("new connection accepted:" + socket.getInetAddress() + ":" + socket.getPort());
65             try {
66                 BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
67                 PrintWriter writer = new PrintWriter(socket.getOutputStream());
68                 String msg = null;
69                 while ((msg = reader.readLine()) != null) {
70                     System.out.println("from " + socket.getInetAddress() + ":" + socket.getPort() + ", receive msg:"
71                             + msg);
72                     writer.println(msg);
73                     writer.flush();
74                     if ("close".equals(msg)) {
75                         break;
76                     }
77                 }
78             } catch (IOException e) {
79                 e.printStackTrace();
80             } finally {
81                 try {
82                     if (socket != null) {
83                         socket.close();
84                     }
85                 } catch (IOException e) {
86                     e.printStackTrace();
87                 }
88             }
89         }
90     }
91 
92     public static void main(String[] args) throws Exception {
93         new SocketThreadPoolDemoServer().service();
94     }
95 }
96 
97 

运行服务端代码后，程序会一直进行监听，直到接收到客户端请求为止。结果如下：

waitting connet…

客户端代码（与单线程完全相同）：

 1 public class SocketDemoClient {
 2 
 3     private String host = "127.0.0.1";// 要发送给服务端的ip
 4 
 5     private int port = 8000;// 要发送给服务端的端口
 6 
 7     private Socket socket;
 8 
 9     public SocketDemoClient() throws Exception {
10         socket = new Socket(host, port);// 构造Socket客户端，并与连接服务端
11     }
12 
13     public void talk() throws IOException {
14         try {
15             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
16             PrintWriter writer = new PrintWriter(socket.getOutputStream());
17             // 读取本地控制台的消息
18             BufferedReader localReader = new BufferedReader(new InputStreamReader(System.in));
19             String msg = null;
20             while ((msg = localReader.readLine()) != null) {
21                 writer.println(msg);
22                 writer.flush();
23                 System.out.println("send msg:" + reader.readLine());
24                 if ("close".equals(msg)) {
25                     break;
26                 }
27             }
28         } catch (Exception e) {
29             e.printStackTrace();
30         } finally {
31             if (socket != null) {
32                 socket.close();
33             }
34         }
35     }
36 
37     public static void main(String[] args) throws Exception {
38         new SocketDemoClient().talk();
39     }
40 }

由于我们要测试多个客户端连接同一个服务端，所以我们需要多次运行客户端代码。这里我们运行两次之后（称为客户端1、客户端2），查看服务端的Console，会出现以下结果，说明已经连接成功：

waitting connet…
new connection accepted:/127.0.0.1:59593
new connection accepted:/127.0.0.1:59596

我们在去客户端1的Console中输入我们要发送的消息”维护世界和平”，回车确定后，客户端1的Console出现以下结果，消息已经发出：

send msg:维护世界和平

再去客户端2的Console中输入”好好学习天天向上”，回车确定后，客户端2的Console出现以下结果，消息已经发出：

send msg:好好学习天天向上

在服务端的Console中，我们会看到如下结果，说明两个客户端的消息已经被接受：

waitting connet…
new connection accepted:/127.0.0.1:59593
new connection accepted:/127.0.0.1:59596
from /127.0.0.1:59593, receive msg:维护世界和平
from /127.0.0.1:59596, receive msg:好好学习天天向上

                      export LD_LIBRARY_PATH=/usr/classpath/lib/classpath:$LD_LIBRARY_PATH

                      export  BOOTCLASSPATH=/usr/jamvm/share/jamvm/classes.zip:/usr/classpath/share/classpath/glibj.zip

Servlet采用多线程来处理多个请求同时访问，Servelet容器维护了一个线程池来服务请求。
线程池实际上是等待执行代码的一组线程叫做工作者线程(Worker Thread)，Servlet容器使用一个调度线程来管理工作者线程(Dispatcher Thread)。

当容器收到一个访问Servlet的请求，调度者线程从线程池中选出一个工作者线程，将请求传递给该线程，然后由该线程来执行Servlet的service方法。
当这个线程正在执行的时候，容器收到另外一个请求，调度者线程将从池中选出另外一个工作者线程来服务新的请求，容器并不关系这个请求是否访问的是同一个Servlet还是另外一个Servlet。
当容器同时收到对同一Servlet的多个请求，那这个Servlet的service方法将在多线程中并发的执行。

二，Servlet容器默认采用单实例多线程的方式来处理请求，这样减少产生Servlet实例的开销，提升了对请求的响应时间。对于Tomcat可以在server.xml中通过<Connector>元素设置线程池中线程的数目。

就实现来说：
  调度者线程类所担负的责任如其名字，该类的责任是调度线程，只需要利用自己的属性完成自己的责任。所以该类是承担了责任的，并且该类的责任又集中到唯一的单体对象中。
而其他对象又依赖于该特定对象所承担的责任，我们就需要得到该特定对象。那该类就是一个单例模式的实现了。

三，如何开发线程安全的 Servlet                                                                                                                
 1，变量的线程安全：这里的变量指字段和共享数据(如表单参数值)。

  a，将 参数变量 本地化。多线程并不共享局部变量.所以我们要尽可能的在servlet中使用局部变量。
   例如：String user = "";
         user = request.getParameter("user");

  b，使用同步块Synchronized，防止可能异步调用的代码块。这意味着线程需要排队处理。
  在使用同板块的时候要尽可能的缩小同步代码的范围，不要直接在sevice方法和响应方法上使用同步，这样会严重影响性能。

 2,属性的线程安全：ServletContext，HttpSession，ServletRequest对象中属性
  ServletContext：（线程是不安全的）
   ServletContext是可以多线程同时读/写属性的，线程是不安全的。要对属性的读写进行同步处理或者进行深度Clone()。
   所以在Servlet上下文中尽可能少量保存会被修改（写）的数据，可以采取其他方式在多个Servlet中共享，比方我们可以使用单例模式来处理共享数据。
  HttpSession：（线程是不安全的）
   HttpSession对象在用户会话期间存在，只能在处理属于同一个Session的请求的线程中被访问，因此Session对象的属性访问理论上是线程安全的。
   当用户打开多个同属于一个进程的浏览器窗口，在这些窗口的访问属于同一个Session，会出现多次请求，需要多个工作线程来处理请求，可能造成同时多线程读写属性。
   这时我们需要对属性的读写进行同步处理：使用同步块Synchronized和使用读/写器来解决。

  ServletRequest：（线程是安全的）
   对于每一个请求，由一个工作线程来执行，都会创建有一个新的ServletRequest对象，所以ServletRequest对象只能在一个线程中被访问。ServletRequest是线程安全的。
   注意：ServletRequest对象在service方法的范围内是有效的，不要试图在service方法结束后仍然保存请求对象的引用。

 3，使用同步的集合类：
  使用Vector代替ArrayList，使用Hashtable代替HashMap。

 4，不要在Servlet中创建自己的线程来完成某个功能。
  Servlet本身就是多线程的，在Servlet中再创建线程，将导致执行情况复杂化，出现多线程安全问题。

 5，在多个servlet中对外部对象(比方文件)进行修改操作一定要加锁，做到互斥的访问。 

四，SingleThreadModel接口
 javax.servlet.SingleThreadModel接口是一个标识接口，如果一个Servlet实现了这个接口，那Servlet容器将保证在一个时刻仅有一个线程可以在给定的servlet实例的service方法中执行。将其他所有请求进行排队。
 服务器可以使用多个实例来处理请求，代替单个实例的请求排队带来的效益问题。服务器创建一个Servlet类的多个Servlet实例组成的实例池，对于每个请求分配Servlet实例进行响应处理，之后放回到实例池中等待下此请求。这样就造成并发访问的问题。
 此时,局部变量(字段)也是安全的，但对于全局变量和共享数据是不安全的，需要进行同步处理。而对于这样多实例的情况SingleThreadModel接口并不能解决并发访问问题。
 
 SingleThreadModel接口在servlet规范中已经被废弃了。

import javax.swing.JButton;
import javax.swing.JEditorPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextPane;
import javax.swing.UIManager;
import javax.swing.WindowConstants;
import javax.swing.text.AttributeSet;
import javax.swing.text.DefaultStyledDocument;
import javax.swing.text.Document;
import javax.swing.text.EditorKit;
import javax.swing.text.MutableAttributeSet;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyledDocument;
import javax.swing.text.StyledEditorKit;

public class NewJFrame extends javax.swing.JFrame implements ActionListener {
 private JPanel jp1;

 private JButton color;

 private JTextPane jep;

 private JScrollPane jsp;

 private JButton font;

 /**
  * Auto-generated main method to display this JFrame
  */
 public static void main(String[] args) {
  NewJFrame inst = new NewJFrame();
  inst.setVisible(true);
 }

 public NewJFrame() {
  super();
  initGUI();
 }

 private void initGUI() {
  try {
   BorderLayout thisLayout = new BorderLayout();
   getContentPane().setLayout(thisLayout);
   setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
   {
    jp1 = new JPanel();
    getContentPane().add(jp1, BorderLayout.NORTH);
    {
     font = new JButton();
     font.addActionListener(this);
     jp1.add(font);
     font.setText("font");
    }
    {
     color = new JButton();
     jp1.add(color);
     color.addActionListener(this);
     color.setText("color");
    }
   }
   {
    jsp = new JScrollPane();
    getContentPane().add(jsp, BorderLayout.CENTER);
    {
     jep = new JTextPane();
     jsp.setViewportView(jep);
     jep.setDocument(new DefaultStyledDocument());
    }
   }
   pack();
   setSize(400, 300);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 public static void setFontSize(JEditorPane editor, int size) {
  if (editor != null) {
   if ((size > 0) && (size < 512)) {
    MutableAttributeSet attr = new SimpleAttributeSet();
    StyleConstants.setFontSize(attr, size);
    setCharacterAttributes(editor, attr, false);
   } else {
    UIManager.getLookAndFeel().provideErrorFeedback(editor);
   }
  }
 }

 public static void setForeground(JEditorPane editor, Color fg) {
  if (editor != null) {
   if (fg != null) {
    MutableAttributeSet attr = new SimpleAttributeSet();
    StyleConstants.setForeground(attr, fg);
    setCharacterAttributes(editor, attr, false);
   } else {
    UIManager.getLookAndFeel().provideErrorFeedback(editor);
   }
  }
 }

 public static final void setCharacterAttributes(JEditorPane editor,
   AttributeSet attr, boolean replace) {
  int p0 = editor.getSelectionStart();
  int p1 = editor.getSelectionEnd();
  if (p0 != p1) {
   StyledDocument doc = getStyledDocument(editor);
   doc.setCharacterAttributes(p0, p1 - p0, attr, replace);
  }
  StyledEditorKit k = getStyledEditorKit(editor);
  MutableAttributeSet inputAttributes = k.getInputAttributes();
  if (replace) {
   inputAttributes.removeAttributes(inputAttributes);
  }
  inputAttributes.addAttributes(attr);
 }

 protected static final StyledDocument getStyledDocument(JEditorPane e) {
  Document d = e.getDocument();
  if (d instanceof StyledDocument) {
   return (StyledDocument) d;
  }
  throw new IllegalArgumentException("document must be StyledDocument");
 }

 protected static final StyledEditorKit getStyledEditorKit(JEditorPane e) {
  EditorKit k = e.getEditorKit();
  if (k instanceof StyledEditorKit) {
   return (StyledEditorKit) k;
  }
  throw new IllegalArgumentException("EditorKit must be StyledEditorKit");
 }

 public void actionPerformed(ActionEvent e) {
  Object obj = e.getSource();
  if (obj == font) {
   JEditorPane editor = jep;
   setFontSize(editor, 20);
  }
  if (obj == color) {
   JEditorPane editor = jep;
   setForeground(editor, Color.red);
  }
 }

}
其他操作如下：
1、对字体的操作
MutableAttributeSet attr = new SimpleAttributeSet();
    StyleConstants.setFontFamily(attr, family);
    setCharacterAttributes(editor, attr, false);
family为字体
2、对字体大小的操作
MutableAttributeSet attr = new SimpleAttributeSet();
    StyleConstants.setFontSize(attr, size);
    setCharacterAttributes(editor, attr, false);
size为字号
3、是否是粗体的操作
StyledEditorKit kit = getStyledEditorKit(editor);
   MutableAttributeSet attr = kit.getInputAttributes();
   boolean bold = (StyleConstants.isBold(attr)) ? false : true;
   SimpleAttributeSet sas = new SimpleAttributeSet();
   StyleConstants.setBold(sas, bold);
   setCharacterAttributes(editor, sas, false);
4、是否是斜体的操作
StyledEditorKit kit = getStyledEditorKit(editor);
   MutableAttributeSet attr = kit.getInputAttributes();
   boolean italic = (StyleConstants.isItalic(attr)) ? false : true;
   SimpleAttributeSet sas = new SimpleAttributeSet();
   StyleConstants.setItalic(sas, italic);
   setCharacterAttributes(editor, sas, false);
5、是否有下划线的操作
StyledEditorKit kit = getStyledEditorKit(editor);
   MutableAttributeSet attr = kit.getInputAttributes();
   boolean underline = (StyleConstants.isUnderline(attr)) ? false
     : true;
   SimpleAttributeSet sas = new SimpleAttributeSet();
   StyleConstants.setUnderline(sas, underline);
   setCharacterAttributes(editor, sas, false);
6、左中右对齐的处理
MutableAttributeSet attr = new SimpleAttributeSet();
   StyleConstants.setAlignment(attr, a);
   setParagraphAttributes(editor, attr, false);
public static final void setParagraphAttributes(JEditorPane editor,
   AttributeSet attr, boolean replace) {
  int p0 = editor.getSelectionStart();
  int p1 = editor.getSelectionEnd();
  StyledDocument doc = getStyledDocument(editor);
  doc.setParagraphAttributes(p0, p1 - p0, attr, replace);
 }
a:0：左，1：中，2：右

7、文本字体颜色的设置
MutableAttributeSet attr = new SimpleAttributeSet();
    StyleConstants.setForeground(attr, fg);
    setCharacterAttributes(editor, attr, false);
fg：为color
8、文本背景颜色的设置
MutableAttributeSet attr = new SimpleAttributeSet();
    StyleConstants.setBackground(attr, bg);
    setCharacterAttributes(editor, attr, false);

1 coo one=new coo();
2 for（int i=0;i<point.size();i++）{
3 one=point.get(i);
4 one.x=one.x*r1/r2;
5 point.remove(i);
6 point.add(i,one);
7 }

这段代码的错误很多，简单分析一下。
one 并没有分配内存，所以3行获得的只是一个地址，4行操作的也只是把地址为i的内容操作了；
5行逻辑也是错误的，因为地址i的数据就是计算后的，把正确的删掉了又把第i行（就是删除前的第i+1行），插了进去，弄来弄去，全乱套了。

下面是正确的代码正确的代码：

for (int i = 0; i < pointV.size(); i++) {
    point_hold = new coordinate();
    point_hold.x = ((coordinate) pointV.get(i)).x;
    point_hold.y = ((coordinate) pointV.get(i)).y;
    point_hold.x = point_hold.x * Reflectance_hold
      / Reflectance;
    pointH.add(point_hold);   
   }
  
   pointV.clear();
   pointV=(Vector)pointH.clone();
   pointH.clear();

其实这段代码用的是最笨的办法，不多说了，以后多注意。

 implements forReplayMBean{
 
 private String State="待调用";
 
 public void play(){
  System.out.println("play函数调用成功！");
  
 }

 public String getState() {
  
  return State;
 }

 public void setState(String s) {
  State=s;
  
 }

}
***********************************************************
***********************************************************
forReplayMBean.java
***************************************
public interface forReplayMBean {
 
 public String getState();
 public void setState(String s);
 public void play();

}
***********************************************************
***********************************************************
Client.java
***************************************
import javax.management.MBeanServerConnection;
import javax.management.ObjectName;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;

public class Client {

    public static void main(String[] args) {
        try {
         
            // 创建RMI连接客户端到RMI连接服务器
            JMXServiceURL url = new JMXServiceURL(
        "service:jmx:rmi:///jndi/rmi://localhost:9999/server");
            JMXConnector jmxc = JMXConnectorFactory.connect(url, null);

            // 获得一个MBean服务器连接
            MBeanServerConnection mbsc = jmxc.getMBeanServerConnection();

            //创建一个forPlay类
            ObjectName mbeanName = new ObjectName("chengang:name=forReplay");
            mbsc.createMBean("forReplay", mbeanName, null, null);

           
            System.out.println("\nMBean数量为" + mbsc.getMBeanCount());// 获得Mbean的数量
            mbsc.invoke(mbeanName,"play", null, null);//调用forPlay类中的play（）函数

            Thread.sleep(2000);//挂起2000毫秒，等待服务器反应.
         
            mbsc.unregisterMBean(mbeanName); //注销MBean的注册,不是必要的
            jmxc.close();// 关闭连接，不是必要的
           
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

***********************************************************
***********************************************************

此函数（符合上述格式）是程序的入口，系统会在一开始调用此函数以开始程序的运行。


public 公用的，表示该方法共有，可以被外部访问
static 静态的,运行自动加载，程序运行时会在最开始实例化static类型的东西，比如这里的main函数
void 表示该方法不返回任何数值
main 是函数名
String[] args表示args是一个String类型的数组，存放参数，实际上args是可以随意改变的

有一个例子可以帮助我们理解:
 
public class Message{
public static void main(String[] a){
if(a[0].equals("-h"))
System.out.println("hello world");
else if(a[0].equals("-g"))
System.out.println("goodbye ");
for(int i=0;i<a.length;i++)
System.out.println(""+a[i]);

}
}

运行时为java Message -h
或者 java Message -g
在后面再加字符串也可以

a实际上就是一个字符数组的名字，作用是用来存储java Message后面跟着传进来的参数。名字可以自定义，但是你改成数字当然不行了，需要符合java中变量的命名规则。如果代码里没有用到这个数组的话随便改都没有问题。但是如果程序里面使用了这个数组的话，改名就需要同时将调用的地方一起改掉。

因为java不知道你是不是会带参数执行。例如java Message 或者 java Message Hello。如果不允许args参数。那么可以在程序中通过
if (args.length!=0) System.out.println("此程序不允许带参数执行");
来避免出现无法处理的错误

一个main()函数只有是 main(String[] x)才是系统的main函数， 程序开始执行的函数。其实它也不过是一个函数而已，你不必想像为一个很特殊的东西，只是系统会去主动找这个函数来执行，你也可以在程序中主动调用main(String[])，当然大多数情况下这都没有必要。

如果不加参数"String[]"，就不是原来这个main函数了，只能叫做自己定义的一个函数。 至于String[] x 中的x 只是一个变量名，随便你定义。

JDBC驱动有两种方法。
　　a）  在命令行方式下指定驱动器或者用冒号分割驱动器列表：
　　具体命令如下：
      C:\>java –Djdbc.drivers = com.company1.Driver:com.company2.Driver youProject
　　b)第二种方法，在程序中调用Class.forName（）方法。推荐使用。。。。
              try
　　{
　　   String driverName = “com.imaginary.sql.msql.MsqlDriver”;
　　   Class.forName(driverName).newInstance();
　　}
              Catch(ClassNotFoundException e1)
                 {
            //catch could not find database driver exception.
　　  }
　　2.连接到数据库。　　
　　根据您后台待连接的数据库不同，而有小小的差别。
　　a)       连接到Oracle数据库。
　　Connection connection = null ;
　　try
　　{
　　  //load the jdbc driver ;
 　　 String driverName = “oracle.jdbc.driver.OracleDriver”;
 　　 Class.forName(driverName).newInstance();
　　 //create a connection to the database;
 　　 String serverName = “127.0.0.1”;
 　　 String serverPort = “1521”;
 　　 String serverID = “datebase1”
 　　 String userName = “hello”;
 　　 String userPsw = “world”;
 　　 String url = “jdbc:oracle.thin:@” + serverName + “:” + serverPort + “:” + serverID ;
 　　 Connection = DriverManager.getConnection(url , userName , userPsw);
　　}
　　catch(ClassNotFoundException e1)
　　{
　　  //catch could not find database driver exception.
　　}
　　catch(SQLException e2)
　　{
 　　 //catch could not connect to the database exception.
　　}
　　b)      连接到一个SQL Server数据库。
   　　Connection connection = null ;
　　try
　　{
　　  //load the jdbc driver ;
 　　 String driverName = “com.microsoft.jdbc.sqlserver.SQLServerDriver”;
　　  Class.forName(driverName).newInstance();
  　　 //create a connection to the database;
　　  String serverName = “127.0.0.1”;
　　  String serverPort = “1433”;
 　　 String serverID =  serverName + serverPort ;
　　  String userName = “hello”;
 　　 String userPsw = “world”;
 　　 String url = “jdbc:JSQLConnect ://” + serverID ;
 　　 Connection = DriverManager.getConnection(url , userName , userPsw);
　　}
　　catch(ClassNotFoundException e1)
　　{
　　  //catch could not find database driver exception.
　　}
　　catch(SQLException e2)
　　{
　　  //catch could not connect to the database exception.
　　}
　　c)      连接到一个MySQL数据库上。。。。
          Connection connection = null ;
　　try
　　{
　　  //load the jdbc driver ;
　　  String driverName = “org.gjt.mm.mysql.Driver”;
　　  Class.forName(driverName).newInstance();
  　　  //create a connection to the database;
　　  String serverName = “127.0.0.1”;
　　  String serverID =  “database”;
　　  String userName = “hello”;
　　  String userPsw = “world”;
　　  String url = “jdbc:mysql ://” + serverName + “/” + serverID ;
　　  Connection = DriverManager.getConnection(url , userName , userPsw);
　　}
　　catch(ClassNotFoundException e1)
　　{
　　  //catch could not find database driver exception.
　　}
　　catch(SQLException e2)
　　{
　　  //catch could not connect to the database exception.
　　}

　　综合上面的三种数据库连接方式 ， 其实大同小异。由于访问不同的数据库和所使用的数据库驱动程序不同，所以导致代码表面上有小小

不同，但透过表面看来，内部都是

　　1．  加载一个特定的数据库JDBC驱动。
　　2．  连接到一个数据库。
　　3．  之后，就可以对一个特定的数据库进行特定的操作了。

public class Server {

    public static void main(String[] args) {
        try {
            // Instantiate the MBean server
            //
            System.out.println("\nCreate the MBean server");
            MBeanServer mbs = MBeanServerFactory.createMBeanServer();

            // Create an RMI connector server
            //
            System.out.println("\nCreate an RMI connector server");
            JMXServiceURL url = new JMXServiceURL(
        "service:jmx:rmi:///jndi/rmi://219.242.119.89:9999/server");
            JMXConnectorServer cs =
                JMXConnectorServerFactory.newJMXConnectorServer(url, null, mbs);

            // Start the RMI connector server
            //
            System.out.println("\nStart the RMI connector server");
            cs.start();
            System.out.println("\nRMI connector server successfully started");
            System.out.println("\nWaiting for incoming connections...");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

************************************************************************
第2个源文件SimpleStandardMBean.java
*******************************

import javax.management.AttributeChangeNotification;
import javax.management.NotificationBroadcasterSupport;

public class SimpleStandard
    extends NotificationBroadcasterSupport
    implements SimpleStandardMBean {

    /*
     * -----------------------------------------------------
     * CONSTRUCTORS
     * -----------------------------------------------------
     */

    /* "SimpleStandard" does not provide any specific constructors.
     * However, "SimpleStandard" is JMX compliant with regards to
     * contructors because the default contructor SimpleStandard()
     * provided by the Java compiler is public.
     */

    /*
     * -----------------------------------------------------
     * IMPLEMENTATION OF THE SimpleStandardMBean INTERFACE
     * -----------------------------------------------------
     */

    /**
     * Getter: get the "State" attribute of the "SimpleStandard" standard MBean.
     *
     * @return the current value of the "State" attribute.
     */
    public String getState() {
        return state;
    }

    /**
     * Setter: set the "State" attribute of the "SimpleStandard" standard MBean.
     *
     * @param <VAR>s</VAR> the new value of the "State" attribute.
     */
    public void setState(String s) {
        state = s;
        nbChanges++;
    }

    /**
     * Getter: get the "NbChanges" attribute of the "SimpleStandard" standard
     * MBean.
     *
     * @return the current value of the "NbChanges" attribute.
     */
    public int getNbChanges() {
        return nbChanges;
    }

    /**
     * Operation: reset to their initial values the "State" and "NbChanges"
     * attributes of the "SimpleStandard" standard MBean.
     */
    public void reset() {
 AttributeChangeNotification acn =
     new AttributeChangeNotification(this,
         0,
         0,
         "NbChanges reset",
         "NbChanges",
         "Integer",
         new Integer(nbChanges),
         new Integer(0));
 state = "initial state";
        nbChanges = 0;
 nbResets++;
 sendNotification(acn);
    }

    /*
     * -----------------------------------------------------
     * METHOD NOT EXPOSED FOR MANAGEMENT BY A JMX AGENT
     * -----------------------------------------------------
     */

    /**
     * Return the "NbResets" property.
     * This method is not a Getter in the JMX sense because it
     * is not exposed in the "SimpleStandardMBean" interface.
     *
     * @return the current value of the "NbResets" property.
     */
    public int getNbResets() {
 return nbResets;
    }

    /*
     * -----------------------------------------------------
     * ATTRIBUTES ACCESSIBLE FOR MANAGEMENT BY A JMX AGENT
     * -----------------------------------------------------
     */

    private String state = "initial state";
    private int nbChanges = 0;

    /*
     * -----------------------------------------------------
     * PROPERTY NOT ACCESSIBLE FOR MANAGEMENT BY A JMX AGENT
     * -----------------------------------------------------
     */

    private int nbResets = 0;
}

************************************************************************
第3个源文件 SimpleStandard.java
*******************************

/**
 * This is the management interface explicitly defined for the
 * "SimpleStandard" standard MBean.
 *
 * The "SimpleStandard" standard MBean implements this interface
 * in order to be manageable through a JMX agent.
 *
 * The "SimpleStandardMBean" interface shows how to expose for management:
 * - a read/write attribute (named "State") through its getter and setter
 *   methods,
 * - a read-only attribute (named "NbChanges") through its getter method,
 * - an operation (named "reset").
 */
public interface SimpleStandardMBean {

    /**
     * Getter: set the "State" attribute of the "SimpleStandard" standard
     * MBean.
     *
     * @return the current value of the "State" attribute.
     */
    public String getState();

    /**
     * Setter: set the "State" attribute of the "SimpleStandard" standard
     * MBean.
     *
     * @param <VAR>s</VAR> the new value of the "State" attribute.
     */
    public void setState(String s);

    /**
     * Getter: get the "NbChanges" attribute of the "SimpleStandard" standard
     * MBean.
     *
     * @return the current value of the "NbChanges" attribute.
     */
    public int getNbChanges();

    /**
     * Operation: reset to their initial values the "State" and "NbChanges"
     * attributes of the "SimpleStandard" standard MBean.
     */
    public void reset();
}

************************************************************************
第4个源文件ClientListener.java
*******************************

import javax.management.Notification;
import javax.management.NotificationListener;

public class ClientListener implements NotificationListener {
    public void handleNotification(Notification notification, Object handback) {
 System.out.println("\nReceived notification: " + notification);
    }
}
*************************************************************************
第5个源文件Client.java
********************************

import javax.management.Attribute;
import javax.management.MBeanServerConnection;
import javax.management.MBeanServerInvocationHandler;
import javax.management.ObjectName;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;

public class Client {

    public static void main(String[] args) {
        try {
            // Create an RMI connector client and
            // connect it to the RMI connector server
            //
            System.out.println("\nCreate an RMI connector client and " +
                               "connect it to the RMI connector server");
            JMXServiceURL url = new JMXServiceURL(
        "service:jmx:rmi:///jndi/rmi://219.242.119.89:9999/server");
            JMXConnector jmxc = JMXConnectorFactory.connect(url, null);

            // Get an MBeanServerConnection
            //
            System.out.println("\nGet an MBeanServerConnection");
            MBeanServerConnection mbsc = jmxc.getMBeanServerConnection();

            // Get domains from MBeanServer
            //
            System.out.println("\nDomains:");
            String domains[] = mbsc.getDomains();
            for (int i = 0; i < domains.length; i++) {
                System.out.println("\tDomain[" + i + "] = " + domains[i]);
            }

            // Create SimpleStandard MBean
            //
            ObjectName mbeanName = new ObjectName("MBeans:type=SimpleStandard");
            System.out.println("\nCreate SimpleStandard MBean...");
            mbsc.createMBean("SimpleStandard", mbeanName, null, null);

            // Get MBean count
            //
            System.out.println("\nMBean count = " + mbsc.getMBeanCount());

            // Get State attribute
            //
            System.out.println("\nState = " +
                               mbsc.getAttribute(mbeanName, "State"));

            // Set State attribute
            //
            mbsc.setAttribute(mbeanName,
                              new Attribute("State", "changed state"));

            // Get State attribute
     //
     // Another way of interacting with a given MBean is through a
     // dedicated proxy instead of going directly through the MBean
     // server connection
     //
     SimpleStandardMBean proxy = (SimpleStandardMBean)
  MBeanServerInvocationHandler.newProxyInstance(
          mbsc,
          mbeanName,
          SimpleStandardMBean.class,
          false);
            System.out.println("\nState = " + proxy.getState());

            // Add notification listener on SimpleStandard MBean
            //
            ClientListener listener = new ClientListener();
            System.out.println("\nAdd notification listener...");
            mbsc.addNotificationListener(mbeanName, listener, null, null);

            // Invoke "reset" in SimpleStandard MBean
            //
            // Calling "reset" makes the SimpleStandard MBean emit a
            // notification that will be received by the registered
            // ClientListener.
            //
            System.out.println("\nInvoke reset() in SimpleStandard MBean...");
            mbsc.invoke(mbeanName, "reset", null, null);

            // Sleep for 2 seconds in order to have time to receive the
            // notification before removing the notification listener.
            //
            System.out.println("\nWaiting for notification...");
            Thread.sleep(2000);

            // Remove notification listener on SimpleStandard MBean
            //
            System.out.println("\nRemove notification listener...");
            mbsc.removeNotificationListener(mbeanName, listener);

            // Unregister SimpleStandard MBean
            //
            System.out.println("\nUnregister SimpleStandard MBean...");
            mbsc.unregisterMBean(mbeanName);

            // Close MBeanServer connection
            //
            System.out.println("\nClose the connection to the server");
            jmxc.close();
            System.out.println("\nBye! Bye!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

RJMX_HOME      user_dir/jmxremote-1_0_1-bin

JMX_HOME        jmx_install_dir

RJMXLIB            {RJMX_HOME}/lib

JMXLIB                {JMX_HOME}/lib
classp                    ${RJMXLIB}/jmxremote.jar:${JMXLIB}/jmxri.jar
CLASSPATH        .:$classp
其中user_dir为jmxremote-1_0_1-bin这个文件夹所在的目录，如我的设置完为C:\Program Files\Java\otherlib\jmxremote-1_0_1-bin；
jmx_install_dir 为JMX包的文件jmx-1_2_1-bin文件夹所在的目录，我的为C:\Program Files\Java\otherlib\jmx-1_2_1-bin
2、运行一个命令。
这个命令我也不太懂，要在DOS下运行，命令行格式为rmiregistry 9999
我的运行时命令行整体为
C:\Documents and Settings\tingfeng>rmiregistry 9999
回车以后运行，它就会停下来，然后就可以启动server端了，再启动Client。