// server.java
      import java.io.*;
      import java.net.*;
      public class server extends thread
      {
      　　　　public final static int default_port=6543;
      　　　　protectd int port;
      　　　　protectd serversockt listen_socket;
      // 定义出错例程：如果出现异常错误，退出程序。
      public static void fail(exception e, string msg)
      {
      　　　　system.err.println(msg   ": "   e);
      　　　　system.exit(1);
      }
      // 定义并启动服务器的socket 
      例程，监听客户机的连接请求。
      public server(int port)
      {
      if(port == 0) port = default_port;
      this.port = port;
      try
      {
      listen_socket = new serversocket(port);
      }
      catch(ioexception e) fail(e, "exception creating server 
      socket");
      system.out.println("server: listening on port"   port);
      this.start();
      }
      /* 
      下面为服务器监听线程的主程序。该线程一直循环执行，监听并接受客户机发出的连接
      请求。对每一个连接，均产生一个连接对象与之对应，通过socket 
      通道进行通信。*/
      public void run()
      {
      try
      　　　　{
      while(true)
      {
      　　　　socket client_socket = listen_socket.accept();
      　　　　connection c = new connection(client_socket);
      　　　　　　　　　　　　}
      }
      catch(ioexception e) fail(e,"exception while listening for 
      connections")
      }
      // 启动服务器主程序
      public static void main(string args[])
      {
      　　　　int port = 0;
      　　　　if (args.length == 1)
      　　　　{
      　　　　try port = integer.parseint(args[0]);
      　　　　catch(numberformatexception e) port = 0;
      }
      new server(port);
      }　　　　　　　　　　　　　　　　　　　　　　 
      // end of the main
      }　　　　　　　　　　　　　　　　　　 // end of 
      server class
      //以下定义了connection 
      类，它是用来处理与客户机的所有通信的线程。
      class connection extends thread
      {
      protected socket client;
      　　　　protected datainputstream in;
      　　　　　　　　protected printstream out;
      // 初始化通信流并启动线程
      public connection(socket client_socket)
      {
      　　　　　　　　client = client_socket;
      　　　　try
      　　　　{
      　　　　　in = new datainputstream(client.getinputstream());
      　　　　　out = new printstream(client.getoutputstream());
      }
      catch(ioexception e)
      　　{
      　　　　try client.close();
      　　　　　　　　catch(ioexception e2);
      　　　 system.err.println("exception while getting socket 
      streram: "   e);
      　　　return;
      　　}
      　this.start;
      }　　　　　　　　　　　　　　　　　　 // end of 
      connection method
      // 
      服务例程：读出一行文本；反转文本；返回文本。
      public void run()
      {
      　　　　　　　　string line;
      　　　　stringbuffer revline;
      int len;
      　　　　try
      {
      　　　　　　　　for(;;)
      {
      　　　　　　　　　　　　// read a line
      　　　　　　　　　　　　　　　　line = in.readline();
      　　　　　　　　　　　　　　　　　　　　if(line 
      == null) break;
      　　　　　　　　// reverse the line
      　　　　　　　　　　　　　　　　len = line.length();
      　　　　　　　　　　　　　　　　revline = new 
      stringbuffer(len);
      　　　　　　　　for(int i = len-1; i >=0; i--)
      　　　　　　　　revline.insert(len-1-i;line.charat(i));
      　　　　　　　　　　 // write out the reverse line
      　　　　　　　　out.println(revline);
      　　　　　　　　　　　　}
      catch(ioexception e);
      finally try client.close();
      catch(ioexception e2);
      }
      // end of run method
      }
      // end of connection class
      3、编写客户机类java 程序
      // client.java
      import java.io.*;
      import java.net.*;
      public class client extends
      {
      　　　　public static final int default_port = 6543;
      // 定义出错例程
      　　　　public static final void usage()
      　　　　{
      　　　　system.out.println("usage: java client []");
      　　　　　　　　system.exit(0);
      }
      　　　　public static void main(string args[])
      {
      　　　　int port = default_port;
      socket s = null;
      // 解析端口参数
      if ((args.length != 1)&&(args.length != 2 )) usage();
      if (args.length == 1)
      　　　　port = default_port;
      else
      {
      　　　　try port = integer.parseint(args[1]);
      　　　　catch(numberformaatexception e) usage();
      }
      try{
      　　// 产生一个socket 
      ，通过指定的端口与主机通信。
      　　s = new socket(args[0], port);
      　　// 产生用于发出和接收的文本字符流
      　　datainputstream sin = new datainputstream(s.getinputstream());
      　　printstream sout = new datainputstream(s.getinputstream());
      　　// 从控制台读入字符流
      　　datainputstream in = new datainputstream(system.in);
      　　　// 返回连接的地址和端口
      　　ystem.out.println("connected to" s.getinetaddress() ":" 
      s.getport());
      　　　　string line;
      　　　　for(;;)
      　　　　{
      　　　　　　　　// 显示提示符
      　　　　　　　　system.out.print(" >");
      　　　　　　　　system.out.flush();
      　　　　　　　　// 读入控制台输入的一行字符
      　　　　　　　　line = in.readline();
      　　　　　　　　if (line == null) break;
      　　　　　　　　// 将接收的文本行送至服务器
      　　　　　　　　sout.println(line);
      　　　　　　　　// 从服务器接收一行字符
      　　　　　　　　line = sin.readline();
      　　　　　　　　// check if connection is closed(i.e. for 
      eof)
      　　　　　　　　if(line == null)
      　　　　　　　　{
      　　　　　　　　　system.out.println("connection 
      closed by server.");
      　　　　　　　　　break;
      　　　　　　　　}
      　　　　// 在控制台上显示接收的字符
      　　　　system.out.println(line);
      　　}
      　// end of for loop
      }
      / end of try
      catch(ioexception e ) system.err.println(e);
      // always be sure to close the socket
      finally
      {
      　　　　try if(s != null) s.close();
      　　　　catch(ioexception e2);
      }
      }　　　　　　　　　　　　　　　　　　　　　　 
      // end of main
      }　　　　　　　　　　　　　　 // end of client