//我这么写是因为都是在127.0.0.1这一台机器上所以出现了冲突所以无法运行的还是为什么？
//还是根本就不能这么写？我是想实现一下dos的聊天，用一台电脑能实现么？如果ok应该是什么样的？
import java.net.*;
import java.io.*;
class er
{
public static void main(String[] args)throws Exception
{
  jieshou();
  fasong();
}
public static void jieshou()throws Exception
{
  DatagramSocket ds=new DatagramSocket(10001);
  while(true)
  {
   byte[] buf=new byte[1024];
   DatagramPacket dp=new DatagramPacket(buf,buf.length);
   
   ds.receive(dp);
   String ip=dp.getAddress().getHostAddress();
   String data=new String(dp.getData(),0,dp.getLength());
   int port=dp.getPort();
   System.out.println(ip+"::::"+data+":::::"+port);
   
  }
}
public static void fasong()throws Exception
{
  
  DatagramSocket ds=new DatagramSocket();
  
  BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
  String line=null;
  while((line=bufr.readLine())!=null)
  {
   if("886".equals(line))
    break;
   byte[] buf=line.getBytes();
   DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1"),10002);
   ds.send(dp);
  }
}
}
class yi
{
public static void main(String[] args)throws Exception
{
  jieshou();
  fasong();
}
public static void jieshou()throws Exception
{
  
  DatagramSocket ds=new DatagramSocket(10002);
  while(true)
  {
   byte[] buf=new byte[1024];
   DatagramPacket dp=new DatagramPacket(buf,buf.length);
   ds.receive(dp);
   String ip=dp.getAddress().getHostAddress();
   String data=new String(dp.getData(),0,dp.getLength());
   int port=dp.getPort();
   System.out.println(ip+"::::"+data+":::::"+port);
   
  }
}
public static void fasong()throws Exception
{
  
  DatagramSocket ds=new DatagramSocket();
  
  BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
  String line=null;
  while((line=bufr.readLine())!=null)
  {
   if("886".equals(line))
    break;
   byte[] buf=line.getBytes();
   DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1"),10001);
   ds.send(dp);
  }
}
}

{:soso_e113:}{:soso_e113:}{:soso_e113:}{:soso_e113:}{:soso_e113:}

我把我写的练习发上来吧，可以实现同一台电脑聊天，但是需要通过cmd命令执行class，不能通过eclipse
第一个客户端：

1. 
   
2. /*
   
3. * 练习：
   
4. * 通过多线程、键盘录入、Socket建立一个Chat程序，初步沟通没问题后，进行图形化修改
   
5. * 思路：
   
6. * 1.通一个进程中同时需要发送和接收信息，所以需要用到多线程
   
7. * 2.一个线程负责发送信息，一个线程负责接收信息
   
8. */
   
9. import java.io.BufferedReader;
   
10. import java.io.IOException;
    
11. import java.io.InputStreamReader;
    
12. import java.net.DatagramPacket;
    
13. import java.net.DatagramSocket;
    
14. import java.net.InetAddress;
    
15. import java.net.SocketException;
    
16. public class UdpOne {
    
17. 
    
18.         public static void main(String[] args) {
    
19.                 // TODO Auto-generated method stub
    
20.                 try
    
21.                 {
    
22.                         //DatagramSocket send = new DatagramSocket();
    
23.                         DatagramSocket receive = new DatagramSocket(10002);
    
24.                         new Thread(new Send(receive)).start();
    
25.                         new Thread(new Receive(receive)).start();
    
26.                 }
    
27.                 catch (SocketException se)
    
28.                 {
    
29.                         throw new RuntimeException("建立数据包套接字失败");
    
30.                 }
    
31.                
    
32.         }
    
33. 
    
34. }
    
35. 
    
36. //TODO Send
    
37. class Send implements Runnable
    
38. {
    
39.         private DatagramSocket ds;
    
40.         Send(DatagramSocket ds)
    
41.         {
    
42.                 this.ds = ds;
    
43.         }
    
44.         public void run()
    
45.         {
    
46.                 try
    
47.                 {
    
48.                         BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
    
49.                         String line = null;
    
50.                         while ((line=bfr.readLine())!=null)
    
51.                         {
    
52.                                 if(line.equals("over"))
    
53.                                         break;
    
54.                                 byte[] buf = line.getBytes();
    
55.                                 DatagramPacket dp = new DatagramPacket(buf,buf.length,
    
56.                                                 InetAddress.getByName("192.168.2.105"),10001);
    
57.                                 ds.send(dp);
    
58.                                 //System.out.println(line.toUpperCase());
    
59.                         }
    
60.                         bfr.close();
    
61.                         ds.close();
    
62.                 }
    
63.                 catch (IOException e)
    
64.                 {
    
65.                         throw new RuntimeException("发送失败");
    
66.                 }
    
67.         }
    
68. }
    
69. 
    
70. //TODO RECEIVE
    
71. class Receive implements Runnable
    
72. {
    
73.         private DatagramSocket ds;
    
74.         Receive(DatagramSocket ds)
    
75.         {
    
76.                 this.ds = ds;
    
77.         }
    
78.         public void run()
    
79.         {
    
80.                 try
    
81.                 {
    
82.                         while(true)
    
83.                         {
    
84.                                 //System.out.println("jieshou");
    
85.                                 byte[] buf = new byte[1024*64];
    
86.                                 DatagramPacket dp = new DatagramPacket(buf,buf.length);
    
87.                                 ds.receive(dp);
    
88.                                 String ip = dp.getAddress().getHostAddress();
    
89.                                 int port = dp.getPort();
    
90.                                 String data = new String(dp.getData(),0,dp.getLength());
    
91.                                 System.out.println(ip+"-"+port+"土豆："+data);
    
92.                         }
    
93.                 }
    
94.                 catch(IOException e)
    
95.                 {
    
96.                         throw new RuntimeException("接收失败");
    
97.                 }
    
98.                
    
99.         }
    
100. }
     

复制代码

第二个客户端：

1. 
   
2. import java.io.BufferedReader;
   
3. import java.io.IOException;
   
4. import java.io.InputStreamReader;
   
5. import java.net.DatagramPacket;
   
6. import java.net.DatagramSocket;
   
7. import java.net.InetAddress;
   
8. import java.net.SocketException;
   
9. public class UdpTwo {
   
10. 
    
11.         public static void main(String[] args) {
    
12.                 // TODO Auto-generated method stub
    
13.                 try
    
14.                 {
    
15.                         //DatagramSocket send = new DatagramSocket();
    
16.                         DatagramSocket receive = new DatagramSocket(10001);
    
17.                         new Thread(new OhterSend(receive)).start();
    
18.                         new Thread(new OhterReceive(receive)).start();
    
19.                 }
    
20.                 catch (SocketException se)
    
21.                 {
    
22.                         throw new RuntimeException("建立数据包套接字失败");
    
23.                 }
    
24.                
    
25.         }
    
26. 
    
27. }
    
28. 
    
29. //TODO Send
    
30. class OhterSend implements Runnable
    
31. {
    
32.         private DatagramSocket ds;
    
33.         OhterSend(DatagramSocket ds)
    
34.         {
    
35.                 this.ds = ds;
    
36.         }
    
37.         public void run()
    
38.         {
    
39.                 try
    
40.                 {
    
41.                         BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
    
42.                         String line = null;
    
43.                         while ((line=bfr.readLine())!=null)
    
44.                         {
    
45.                                 if(line.equals("over"))
    
46.                                         break;
    
47.                                 byte[] buf = line.getBytes();
    
48.                                 DatagramPacket dp = new DatagramPacket(buf,buf.length,
    
49.                                                 InetAddress.getByName("192.168.2.105"),10002);
    
50.                                 ds.send(dp);
    
51.                                 //System.out.println(line.toUpperCase());
    
52.                         }
    
53.                         bfr.close();
    
54.                         ds.close();
    
55.                 }
    
56.                 catch (IOException e)
    
57.                 {
    
58.                         throw new RuntimeException("发送失败");
    
59.                 }
    
60.         }
    
61. }
    
62. 
    
63. //TODO RECEIVE
    
64. class OhterReceive implements Runnable
    
65. {
    
66.         private DatagramSocket ds;
    
67.         OhterReceive(DatagramSocket ds)
    
68.         {
    
69.                 this.ds = ds;
    
70.         }
    
71.         public void run()
    
72.         {
    
73.                 try
    
74.                 {
    
75.                         while(true)
    
76.                         {
    
77.                                 //System.out.println("jieshou");
    
78.                                 byte[] buf = new byte[1024];
    
79.                                 DatagramPacket dp = new DatagramPacket(buf,buf.length);
    
80.                                 ds.receive(dp);
    
81.                                 String ip = dp.getAddress().getHostAddress();
    
82.                                 int port = dp.getPort();
    
83.                                 String data = new String(dp.getData(),0,dp.getLength());
    
84.                                 System.out.println(ip+"-"+port+"番茄："+data);
    
85.                         }
    
86.                 }
    
87.                 catch(IOException e)
    
88.                 {
    
89.                         throw new RuntimeException("接收失败");
    
90.                 }
    
91.                
    
92.         }
    
93. }

复制代码

可以实现的 毕老师内个我试过- -
你开两个命令行 分别执行两个class
  eclipse的也有两个命令行
楼主出什么问题了啊

TCP我的代码没有问题，但是UDP我上面的代码没有成功实现，能不能给看看问题出在哪？

freehiker 发表于 2013-11-26 11:12
我把我写的练习发上来吧，可以实现同一台电脑聊天，但是需要通过cmd命令执行class，不能通过eclipse
第一个 ...

我想是可以通过eclipse的，我之前也遇到过，不知道你和我的问题一样不一样，用eclipse没办法开启两个控制台，这种情况只要将两个程序放在不同的工作间就可以了，这样可以开两个eclipse

一直很安静 发表于 2013-11-26 14:17
我想是可以通过eclipse的，我之前也遇到过，不知道你和我的问题一样不一样，用eclipse没办法开启两个控制 ...

恩，只是那样太占资源了，所以我就用dos了，省力，方便，直观

freehiker 发表于 2013-11-26 14:18
恩，只是那样太占资源了，所以我就用dos了，省力，方便，直观

嗯，开一个eclipse就挺占内存的，只是我当时是基础测试的一个题，要求必须要使用eclipse

一直很安静 发表于 2013-11-26 14:20
嗯，开一个eclipse就挺占内存的，只是我当时是基础测试的一个题，要求必须要使用eclipse ...

你不需要在两个workspace下操作的，同一个包下都没问题的，在右下角有一个Display selected Console，可以切换

freehiker 发表于 2013-11-26 14:27
你不需要在两个workspace下操作的，同一个包下都没问题的，在右下角有一个Display selected Console，可 ...

哦哦 谢谢拉

一直很安静 发表于 2013-11-26 14:29
哦哦 谢谢拉

不客气:lol