北京郵電大學(xué)研究生java技術(shù)-孟祥武老師-期末復(fù)習(xí)題整理

1、1.判斷閏年import java.util.Scanner;public class DemoTest         /*         * param args 此處代碼無實(shí)際意義，可刪除         */        public static

2、 void main(Stringargs)                Scanner scan = new Scanner(System.in);/創(chuàng)建輸入流掃描器;                System.out.println("請輸入一個(gè)年份："

3、;);/向控制臺輸出一個(gè)提示信息                long year;                try             &

4、#160;          year = scan.nextLong();                        if(year%4 = 0 && year%100!=0 | year%400 = 0)/是閏年  

5、                              System.out.print(year+"是閏年!");             &#

6、160;          else                                System.out.print(year+"不是閏年!")

7、;                                        catch(Exception e)       

8、;                 System.out.println("你輸入的不是有效的年份");                        2.Socket編

9、程       對于Java Socket編程而言，有兩個(gè)概念，一個(gè)是ServerSocket，一個(gè)是Socket。服務(wù)端和客戶端之間通過Socket建立連接，之后它們就可以進(jìn)行通信了。首先ServerSocket將在服務(wù)端監(jiān)聽某個(gè)端口，當(dāng)發(fā)現(xiàn)客戶端有Socket來試圖連接它時(shí)，它會accept該Socket的連接請求，同時(shí)在服務(wù)端建立一個(gè)對應(yīng)的Socket與之進(jìn)行通信。這樣就有兩個(gè)Socket了，客戶端和服務(wù)端各一個(gè)。       對于Socket之間的通信其實(shí)很簡單，服務(wù)

10、端往Socket的輸出流里面寫東西，客戶端就可以通過Socket的輸入流讀取對應(yīng)的內(nèi)容。Socket與Socket之間是雙向連通的，所以客戶端也可以往對應(yīng)的Socket輸出流里面寫東西，然后服務(wù)端對應(yīng)的Socket的輸入流就可以讀出對應(yīng)的內(nèi)容。下面來看一些服務(wù)端與客戶端通信的例子：  1、客戶端寫服務(wù)端讀       服務(wù)端代碼 Java代碼  public class Server        

11、; public static void main(String args) throws IOException         /為了簡單起見，所有的異常信息都往外拋        int port = 8899;        /定義一個(gè)Ser

12、verSocket監(jiān)聽在端口8899上        ServerSocket server = new ServerSocket(port);        /server嘗試接收其他Socket的連接請求，server的accept方法是阻塞式的        Socket socket =&#

13、160;server.accept();        /跟客戶端建立好連接之后，我們就可以獲取socket的InputStream，并從中讀取客戶端發(fā)過來的信息了。        Reader reader = new InputStreamReader(socket.getInputStream();        

14、;char chars = new char64;        int len;        StringBuilder sb = new StringBuilder();        while (len=reader.read(chars) 

15、;!= -1)            sb.append(new String(chars, 0, len);                System.out.println("from client: " + sb

16、);        reader.close();        socket.close();        server.close();                    

17、;  服務(wù)端從Socket的InputStream中讀取數(shù)據(jù)的操作也是阻塞式的，如果從輸入流中沒有讀取到數(shù)據(jù)程序會一直在那里不動，直到客戶端往Socket的輸出流中寫入了數(shù)據(jù)，或關(guān)閉了Socket的輸出流。當(dāng)然，對于客戶端的Socket也是同樣如此。在操作完以后，整個(gè)程序結(jié)束前記得關(guān)閉對應(yīng)的資源，即關(guān)閉對應(yīng)的IO流和Socket。        客戶端代碼Java代碼  public class Client      

18、60;  public static void main(String args) throws Exception         /為了簡單起見，所有的異常都直接往外拋        String host = "127.0.0.1"  /要連接的服務(wù)端IP地址 &

19、#160;      int port = 8899;   /要連接的服務(wù)端對應(yīng)的監(jiān)聽端口        /與服務(wù)端建立連接        Socket client = new Socket(host, port);    &#

20、160;   /建立連接后就可以往服務(wù)端寫數(shù)據(jù)了        Writer writer = new OutputStreamWriter(client.getOutputStream();        writer.write("Hello Server.");      

21、  writer.flush();/寫完后要記得flush        writer.close();        client.close();                     對于客戶端往Soc

22、ket的輸出流里面寫數(shù)據(jù)傳遞給服務(wù)端要注意一點(diǎn)，如果寫操作之后程序不是對應(yīng)著輸出流的關(guān)閉，而是進(jìn)行其他阻塞式的操作（比如從輸入流里面讀數(shù)據(jù)），記住要flush一下，只有這樣服務(wù)端才能收到客戶端發(fā)送的數(shù)據(jù)，否則可能會引起兩邊無限的互相等待。在稍后講到客戶端和服務(wù)端同時(shí)讀和寫的時(shí)候會說到這個(gè)問題。      2、客戶端和服務(wù)端同時(shí)讀和寫       前面已經(jīng)說了Socket之間是雙向通信的，它既可以接收數(shù)據(jù)，同時(shí)也可以發(fā)送數(shù)據(jù)。     &

23、#160; 服務(wù)端代碼 Java代碼  public class Server         public static void main(String args) throws IOException         /為了簡單起見，所有的異常信息都往外拋     

24、;   int port = 8899;        /定義一個(gè)ServerSocket監(jiān)聽在端口8899上        ServerSocket server = new ServerSocket(port);        /server嘗試接收其他S

25、ocket的連接請求，server的accept方法是阻塞式的        Socket socket = server.accept();        /跟客戶端建立好連接之后，我們就可以獲取socket的InputStream，并從中讀取客戶端發(fā)過來的信息了。        Reader reader 

26、;= new InputStreamReader(socket.getInputStream();        char chars = new char64;        int len;        StringBuilder sb = new

27、60;StringBuilder();        while (len=reader.read(chars) != -1)            sb.append(new String(chars, 0, len);          

28、;      System.out.println("from client: " + sb);        /讀完后寫一句        Writer writer = new OutputStreamWriter(socket.getOutputStream(); 

29、;       writer.write("Hello Client.");        writer.flush();        writer.close();        reader.close();    

30、;    socket.close();        server.close();                      在上述代碼中首先我們從輸入流中讀取客戶端發(fā)送過來的數(shù)據(jù)，接下來我們再往輸出流里面寫入數(shù)據(jù)給客戶端，接下來關(guān)閉對應(yīng)的資源文件。而實(shí)際上上述代碼可能并不會按照我們預(yù)

31、先設(shè)想的方式運(yùn)行，因?yàn)閺妮斎肓髦凶x取數(shù)據(jù)是一個(gè)阻塞式操作，在上述的while循環(huán)中當(dāng)讀到數(shù)據(jù)的時(shí)候就會執(zhí)行循環(huán)體，否則就會阻塞，這樣后面的寫操作就永遠(yuǎn)都執(zhí)行不了了。除非客戶端對應(yīng)的Socket關(guān)閉了阻塞才會停止，while循環(huán)也會跳出。針對這種可能永遠(yuǎn)無法執(zhí)行下去的情況的解決方法是while循環(huán)需要在里面有條件的跳出來，縱觀上述代碼，在不斷變化的也只有取到的長度len和讀到的數(shù)據(jù)了，len已經(jīng)是不能用的了，唯一能用的就是讀到的數(shù)據(jù)了。針對這種情況，通常我們都會約定一個(gè)結(jié)束標(biāo)記，當(dāng)客戶端發(fā)送過來的數(shù)據(jù)包含某個(gè)結(jié)束標(biāo)記時(shí)就說明當(dāng)前的數(shù)據(jù)已經(jīng)發(fā)送完畢了，這個(gè)時(shí)候我們就可以進(jìn)行循環(huán)的跳出了。那么改進(jìn)后

32、的代碼會是這個(gè)樣子：Java代碼  public class Server         public static void main(String args) throws IOException         /為了簡單起見，所有的異常信息都往外拋      

33、  int port = 8899;        /定義一個(gè)ServerSocket監(jiān)聽在端口8899上        ServerSocket server = new ServerSocket(port);        /server嘗試接收其他Socket的連

34、接請求，server的accept方法是阻塞式的        Socket socket = server.accept();        /跟客戶端建立好連接之后，我們就可以獲取socket的InputStream，并從中讀取客戶端發(fā)過來的信息了。        Reader reader = 

35、;new InputStreamReader(socket.getInputStream();        char chars = new char64;        int len;        StringBuilder sb = new Stri

36、ngBuilder();        String temp;        int index;        while (len=reader.read(chars) != -1)          &

37、#160; temp = new String(chars, 0, len);           if (index = temp.indexOf("eof") != -1) /遇到eof時(shí)就結(jié)束接收            &#

38、160; sb.append(temp.substring(0, index);              break;                      sb.append(temp);  

39、              System.out.println("from client: " + sb);        /讀完后寫一句        Writer writer = new Ou

40、tputStreamWriter(socket.getOutputStream();        writer.write("Hello Client.");        writer.flush();        writer.close();      

41、60; reader.close();        socket.close();        server.close();                     在上述代碼中，當(dāng)服務(wù)端讀取到客戶端發(fā)送的結(jié)束標(biāo)記

42、，即“eof”時(shí)就會結(jié)束數(shù)據(jù)的接收，終止循環(huán)，這樣后續(xù)的代碼又可以繼續(xù)進(jìn)行了。        客戶端代碼Java代碼  public class Client         public static void main(String args) throws Exception     

43、0;   /為了簡單起見，所有的異常都直接往外拋       String host = "127.0.0.1"  /要連接的服務(wù)端IP地址       int port = 8899;   /要連接的服務(wù)端對應(yīng)的監(jiān)聽端口      

44、60;/與服務(wù)端建立連接       Socket client = new Socket(host, port);        /建立連接后就可以往服務(wù)端寫數(shù)據(jù)了       Writer writer = new OutputStreamWriter(client.getOutput

45、Stream();        writer.write("Hello Server.");        writer.flush();        /寫完以后進(jìn)行讀操作       Reader reader = new&

46、#160;InputStreamReader(client.getInputStream();        char chars = new char64;        int len;        StringBuffer sb = new StringBuff

47、er();        while (len=reader.read(chars) != -1)            sb.append(new String(chars, 0, len);            &

48、#160;   System.out.println("from server: " + sb);        writer.close();        reader.close();        client.close();   

49、;                  在上述代碼中我們先是給服務(wù)端發(fā)送了一段數(shù)據(jù)，之后讀取服務(wù)端返回來的數(shù)據(jù)，跟之前的服務(wù)端一樣在讀的過程中有可能導(dǎo)致程序一直掛在那里，永遠(yuǎn)跳不出while循環(huán)。這段代碼配合服務(wù)端的第一段代碼就正好讓我們分析服務(wù)端永遠(yuǎn)在那里接收數(shù)據(jù)，永遠(yuǎn)跳不出while循環(huán)，也就沒有之后的服務(wù)端返回?cái)?shù)據(jù)給客戶端，客戶端也就不可能接收到服務(wù)端返回的數(shù)據(jù)。解決方法如服務(wù)端第二段代碼所示，在客戶端發(fā)送數(shù)據(jù)完

50、畢后，往輸出流里面寫入結(jié)束標(biāo)記告訴服務(wù)端數(shù)據(jù)已經(jīng)發(fā)送完畢了，同樣服務(wù)端返回?cái)?shù)據(jù)完畢后也發(fā)一個(gè)標(biāo)記告訴客戶端。那么修改后的客戶端代碼就應(yīng)該是這個(gè)樣子：Java代碼  public class Client         public static void main(String args) throws Exception        

51、; /為了簡單起見，所有的異常都直接往外拋       String host = "127.0.0.1"  /要連接的服務(wù)端IP地址       int port = 8899;   /要連接的服務(wù)端對應(yīng)的監(jiān)聽端口       /與服務(wù)端建立連接&

52、#160;      Socket client = new Socket(host, port);        /建立連接后就可以往服務(wù)端寫數(shù)據(jù)了       Writer writer = new OutputStreamWriter(client.getOutputStream();

53、0;       writer.write("Hello Server.");        writer.write("eof");        writer.flush();        /寫完以后進(jìn)行讀操作  

54、     Reader reader = new InputStreamReader(client.getInputStream();        char chars = new char64;        int len;      

55、;  StringBuffer sb = new StringBuffer();        String temp;        int index;        while (len=reader.read(chars) != -1)

56、60;           temp = new String(chars, 0, len);           if (index = temp.indexOf("eof") != -1)     

57、0;         sb.append(temp.substring(0, index);              break;                   

58、   sb.append(new String(chars, 0, len);                System.out.println("from server: " + sb);        writer.close();&

59、#160;       reader.close();        client.close();                        我們?nèi)粘Ｊ褂玫谋容^多的都是這種客戶端發(fā)送數(shù)據(jù)給服務(wù)端，服務(wù)端接

60、收數(shù)據(jù)后再返回相應(yīng)的結(jié)果給客戶端這種形式。只是客戶端和服務(wù)端之間不再是這種一對一的關(guān)系，而是下面要講到的多個(gè)客戶端對應(yīng)同一個(gè)服務(wù)端的情況。      3、多個(gè)客戶端連接同一個(gè)服務(wù)端       像前面講的兩個(gè)例子都是服務(wù)端接收一個(gè)客戶端的請求之后就結(jié)束了，不能再接收其他客戶端的請求了，這往往是不能滿足我們的要求的。通常我們會這樣做：Java代碼  public class Server      

61、   public static void main(String args) throws IOException         /為了簡單起見，所有的異常信息都往外拋       int port = 8899;        /定義

62、一個(gè)ServerSocket監(jiān)聽在端口8899上       ServerSocket server = new ServerSocket(port);        while (true)            /server嘗試接收其他Socket的連接請求，server的

63、accept方法是阻塞式的         Socket socket = server.accept();           /跟客戶端建立好連接之后，我們就可以獲取socket的InputStream，并從中讀取客戶端發(fā)過來的信息了。         Reader 

64、;reader = new InputStreamReader(socket.getInputStream();           char chars = new char64;           int len;      

65、0;    StringBuilder sb = new StringBuilder();           String temp;           int index;        

66、60;  while (len=reader.read(chars) != -1)               temp = new String(chars, 0, len);              if

67、 (index = temp.indexOf("eof") != -1) /遇到eof時(shí)就結(jié)束接收                  sb.append(temp.substring(0, index);          

68、60;       break;                            sb.append(temp);           

69、;           System.out.println("from client: " + sb);           /讀完后寫一句         Writer writer = new&

70、#160;OutputStreamWriter(socket.getOutputStream();           writer.write("Hello Client.");           writer.flush();          

71、; writer.close();           reader.close();           socket.close();                   &#

72、160;         在上面代碼中我們用了一個(gè)死循環(huán)，在循環(huán)體里面ServerSocket調(diào)用其accept方法試圖接收來自客戶端的連接請求。當(dāng)沒有接收到請求的時(shí)候，程序會在這里阻塞直到接收到來自客戶端的連接請求，之后會跟當(dāng)前建立好連接的客戶端進(jìn)行通信，完了后會接著執(zhí)行循環(huán)體再次嘗試接收新的連接請求。這樣我們的ServerSocket就能接收來自所有客戶端的連接請求了，并且與它們進(jìn)行通信了。這就實(shí)現(xiàn)了一個(gè)簡單的一個(gè)服務(wù)端與多個(gè)客戶端進(jìn)行通信的模式。    

73、60;  上述例子中雖然實(shí)現(xiàn)了一個(gè)服務(wù)端跟多個(gè)客戶端進(jìn)行通信，但是還存在一個(gè)問題。在上述例子中，我們的服務(wù)端處理客戶端的連接請求是同步進(jìn)行的，每次接收到來自客戶端的連接請求后，都要先跟當(dāng)前的客戶端通信完之后才能再處理下一個(gè)連接請求。這在并發(fā)比較多的情況下會嚴(yán)重影響程序的性能，為此，我們可以把它改為如下這種異步處理與客戶端通信的方式：Java代碼  public class Server           public static&#

74、160;void main(String args) throws IOException         /為了簡單起見，所有的異常信息都往外拋       int port = 8899;        /定義一個(gè)ServerSocket監(jiān)聽在端口8899上  &#

75、160;    ServerSocket server = new ServerSocket(port);        while (true)            /server嘗試接收其他Socket的連接請求，server的accept方法是阻塞式的    &

76、#160;      Socket socket = server.accept();           /每接收到一個(gè)Socket就建立一個(gè)新的線程來處理它           new Thread(new Task(socket).start(); &#

77、160;                     /*     * 用來處理Socket請求的    */     static class Task implements Runnable 

78、;           private Socket socket;                public Task(Socket socket)           

79、60;this.socket = socket;                        public void run()              try &#

80、160;               handleSocket();            catch (Exception e)               

81、e.printStackTrace();                                   /*        * 跟客戶端Socket進(jìn)行通

82、信        * throws Exception        */        private void handleSocket() throws Exception          &

83、#160; Reader reader = new InputStreamReader(socket.getInputStream();           char chars = new char64;           int len;   

84、        StringBuilder sb = new StringBuilder();           String temp;           int index;     

85、;      while (len=reader.read(chars) != -1)               temp = new String(chars, 0, len);          

86、0;   if (index = temp.indexOf("eof") != -1) /遇到eof時(shí)就結(jié)束接收               sb.append(temp.substring(0, index);          

87、;        break;                            sb.append(temp);          &

88、#160;           System.out.println("from client: " + sb);           /讀完后寫一句         Writer writer = 

89、new OutputStreamWriter(socket.getOutputStream();           writer.write("Hello Client.");           writer.flush();         &

90、#160; writer.close();           reader.close();           socket.close();                  

91、0;                  在上面代碼中，每次ServerSocket接收到一個(gè)新的Socket連接請求后都會新起一個(gè)線程來跟當(dāng)前Socket進(jìn)行通信，這樣就達(dá)到了異步處理與客戶端Socket進(jìn)行通信的情況。       在從Socket的InputStream中接收數(shù)據(jù)時(shí)，像上面那樣一點(diǎn)點(diǎn)的讀就太復(fù)雜了，有時(shí)候我們就會換成使用BufferedR

92、eader來一次讀一行，如：Java代碼  public class Server         public static void main(String args) throws IOException         /為了簡單起見，所有的異常信息都往外拋     &#

93、160; int port = 8899;        /定義一個(gè)ServerSocket監(jiān)聽在端口8899上       ServerSocket server = new ServerSocket(port);        while (true)  

94、          /server嘗試接收其他Socket的連接請求，server的accept方法是阻塞式的           Socket socket = server.accept();           /每接收到一個(gè)Socket就建立

95、一個(gè)新的線程來處理它           new Thread(new Task(socket).start();                       /*     * 用

96、來處理Socket請求的    */     static class Task implements Runnable            private Socket socket;            

97、;    public Task(Socket socket)            this.socket = socket;                      

98、0; public void run()            try               handleSocket();            catch (E

99、xception e)               e.printStackTrace();                             

100、      /*        * 跟客戶端Socket進(jìn)行通信       * throws Exception        */        private void ha

101、ndleSocket() throws Exception            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream();           StringBuilder

102、 sb = new StringBuilder();           String temp;           int index;           while (temp=br.read

103、Line() != null)               System.out.println(temp);              if (index = temp.indexOf("eof") != -1)

104、60;/遇到eof時(shí)就結(jié)束接收               sb.append(temp.substring(0, index);                  break;       

105、;                     sb.append(temp);                      System.out.println("

106、from client: " + sb);           /讀完后寫一句         Writer writer = new OutputStreamWriter(socket.getOutputStream();       &

107、#160;   writer.write("Hello Client.");           writer.write("eofn");           writer.flush();         

108、  writer.close();           br.close();           socket.close();                   &

109、#160;    這個(gè)時(shí)候需要注意的是，BufferedReader的readLine方法是一次讀一行的，這個(gè)方法是阻塞的，直到它讀到了一行數(shù)據(jù)為止程序才會繼續(xù)往下執(zhí)行，那么readLine什么時(shí)候才會讀到一行呢？直到程序遇到了換行符或者是對應(yīng)流的結(jié)束符readLine方法才會認(rèn)為讀到了一行，才會結(jié)束其阻塞，讓程序繼續(xù)往下執(zhí)行。所以我們在使用BufferedReader的readLine讀取數(shù)據(jù)的時(shí)候一定要記得在對應(yīng)的輸出流里面一定要寫入換行符（流結(jié)束之后會自動標(biāo)記為結(jié)束，readLine可以識別），寫入換行符之后一定記得如果輸出流不是馬上關(guān)閉的情況下記

110、得flush一下，這樣數(shù)據(jù)才會真正的從緩沖區(qū)里面寫入。對應(yīng)上面的代碼我們的客戶端程序應(yīng)該這樣寫：Java代碼  public class Client        public static void main(String args) throws Exception         /為了簡單起見，所有的異常都直接往外拋 

111、      String host = "127.0.0.1"  /要連接的服務(wù)端IP地址       int port = 8899;   /要連接的服務(wù)端對應(yīng)的監(jiān)聽端口       /與服務(wù)端建立連接     

112、60; Socket client = new Socket(host, port);        /建立連接后就可以往服務(wù)端寫數(shù)據(jù)了       Writer writer = new OutputStreamWriter(client.getOutputStream();      

113、  writer.write("Hello Server.");        writer.write("eofn");        writer.flush();        /寫完以后進(jìn)行讀操作       B

114、ufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream();        StringBuffer sb = new StringBuffer();        String temp;   

115、60;    int index;        while (temp=br.readLine() != null)            if (index = temp.indexOf("eof") != -1)  

116、0;            sb.append(temp.substring(0, index);              break;                

117、      sb.append(temp);                System.out.println("from server: " + sb);        writer.close();   

118、     br.close();        client.close();              4、設(shè)置超時(shí)時(shí)間       假設(shè)有這樣一種需求，我們的客戶端需要通過Socket從服務(wù)端獲取到XX信息，然后給用戶展示在頁面上。我們知道Socket在讀數(shù)據(jù)的時(shí)候是阻塞式的

119、，如果沒有讀到數(shù)據(jù)程序會一直阻塞在那里。在同步請求的時(shí)候我們肯定是不能允許這樣的情況發(fā)生的，這就需要我們在請求達(dá)到一定的時(shí)間后控制阻塞的中斷，讓程序得以繼續(xù)運(yùn)行。Socket為我們提供了一個(gè)setSoTimeout()方法來設(shè)置接收數(shù)據(jù)的超時(shí)時(shí)間，單位是毫秒。當(dāng)設(shè)置的超時(shí)時(shí)間大于0，并且超過了這一時(shí)間Socket還沒有接收到返回的數(shù)據(jù)的話，Socket就會拋出一個(gè)SocketTimeoutException。       假設(shè)我們需要控制我們的客戶端在開始讀取數(shù)據(jù)10秒后還沒有讀到數(shù)據(jù)就中斷阻塞的話我們可以這樣做： Java

120、代碼  public class Client         public static void main(String args) throws Exception         /為了簡單起見，所有的異常都直接往外拋       String

121、0;host = "127.0.0.1"  /要連接的服務(wù)端IP地址       int port = 8899;   /要連接的服務(wù)端對應(yīng)的監(jiān)聽端口       /與服務(wù)端建立連接       Socket client = new

122、60;Socket(host, port);        /建立連接后就可以往服務(wù)端寫數(shù)據(jù)了       Writer writer = new OutputStreamWriter(client.getOutputStream();        writer.write("Hello Serv

123、er.");        writer.write("eofn");        writer.flush();        /寫完以后進(jìn)行讀操作       BufferedReader br = new Buf

124、feredReader(new InputStreamReader(client.getInputStream();        /設(shè)置超時(shí)間為10秒       client.setSoTimeout(10*1000);        StringBuffer sb = new StringBuffer();

125、60;       String temp;        int index;        try            while (temp=br.readLine() != null)

126、60;              if (index = temp.indexOf("eof") != -1)                   sb.append(temp.substring(0

127、, index);                  break;                            sb.a

128、ppend(temp);                    catch (SocketTimeoutException e)            System.out.println("數(shù)據(jù)讀取超時(shí)。");  &#

129、160;             System.out.println("from server: " + sb);        writer.close();        br.close();    &

130、#160;   client.close();               5、接收數(shù)據(jù)亂碼       對于這種服務(wù)端或客戶端接收中文亂碼的情況通常是因?yàn)閿?shù)據(jù)發(fā)送時(shí)使用的編碼跟接收時(shí)候使用的編碼不一致。比如有下面這樣一段服務(wù)端代碼：Java代碼  public class Server   

131、60;     public static void main(String args) throws IOException         /為了簡單起見，所有的異常信息都往外拋        int port = 8899;     

132、   /定義一個(gè)ServerSocket監(jiān)聽在端口8899上        ServerSocket server = new ServerSocket(port);        while (true)            /serv

133、er嘗試接收其他Socket的連接請求，server的accept方法是阻塞式的           Socket socket = server.accept();           /每接收到一個(gè)Socket就建立一個(gè)新的線程來處理它         &

134、#160; new Thread(new Task(socket).start();                       /*     * 用來處理Socket請求的     */   

135、60; static class Task implements Runnable            private Socket socket;                public Task(Socket socke

136、t)            this.socket = socket;                        public void run()            try