在UDP聊天的课程里,毕老师把DatagramSocket定义在了外面,并且用构造函数传入,而我直接在里面设置运行起来也是一样可以,请问为什么要设置在外面呢?谢谢

1. package NetTest;
   
2. 
   
3. import java.io.BufferedReader;
   
4. import java.io.IOException;
   
5. import java.io.InputStreamReader;
   
6. import java.net.DatagramPacket;
   
7. import java.net.DatagramSocket;
   
8. import java.net.InetAddress;
   
9. import java.net.SocketException;
   
10. 
    
11. //创建一个UDP发送和接收程序.
    
12. // step2 将两个控制台合并,在一个控制台上显示收发内容.用多线程实现.
    
13. public class UDPDemo {
    
14. 
    
15.         /**
    
16.          * @param args
    
17.          */
    
18.         public static void main(String[] args) {
    
19.                 // TODO Auto-generated method stub
    
20.                 new Thread(new UDPSend()).start();
    
21.                 new Thread(new UDPRece()).start();
    
22.         }
    
23. 
    
24. }
    
25. /* 毕老师的写法:
    
26. 
    
27. //发送端
    
28. class UDPSend implements Runnable{
    
29.         private DatagramSocket ds;
    
30.         
    
31.         public UDPSend(DatagramSocket ds){
    
32.                 this.ds = ds;
    
33.         }
    
34.         
    
35.         @Override
    
36.         public void run() {
    
37.                 // TODO Auto-generated method stub
    
38.                 try {
    
39.                         DatagramPacket dp;
    
40.                         while (true){
    
41.                                 BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
    
42.                                 String line = null;
    
43.                                 while ((line=bufr.readLine())!=null){
    
44.                                         if ("over".equals(line))
    
45.                                                 return;
    
46.                                         dp = new DatagramPacket(line.getBytes(), line.getBytes().length,InetAddress.getByName("192.168.1.101"),5555);
    
47.                                         ds.send(dp);
    
48.                                 }
    
49.                         }
    
50.                 } catch (IOException e) {
    
51.                         // TODO Auto-generated catch block
    
52.                         e.printStackTrace();
    
53.                 }
    
54.         }
    
55.         
    
56. }
    
57. 
    
58. class UDPRece implements Runnable {
    
59.         private DatagramSocket ds = null;
    
60.         
    
61.         public UDPRece(DatagramSocket ds){
    
62.                 this.ds = ds;
    
63.         }
    
64.         public void run() {
    
65.                 while (true) {// 一直准备接收数据
    
66.                         try {
    
67.                                 byte[] buf = new byte[1024];
    
68.                                 DatagramPacket dp = new DatagramPacket(buf, buf.length);// 接收数据后的存储位置
    
69.                                 ds.receive(dp);// 接收数据
    
70.                                 String ip = dp.getAddress().getHostAddress();// 获取数据中的ip
    
71.                                 String data = new String(buf, 0, dp.getLength());// 获取数据内容
    
72.                                 System.out.println("ip:(" + ip + "):" + data);
    
73.                                 // ds.close();
    
74.                         } catch (IOException e) {
    
75.                                 // TODO Auto-generated catch block
    
76.                                 e.printStackTrace();
    
77.                         }
    
78.                 }
    
79.         }
    
80. }
    
81. */
    
82. 
    
83. // 我的写法:
    
84. 
    
85. // 发送端,1,建立UDPsocket,2,封装数据,3,发送,4,关闭
    
86. class UDPSend implements Runnable {
    
87.         public void run() {
    
88.                 DatagramSocket ds = null;
    
89.                 try {
    
90.                         ds = new DatagramSocket();
    
91.                 } catch (SocketException e1) {
    
92.                         // TODO Auto-generated catch block
    
93.                         e1.printStackTrace();
    
94.                 }
    
95.                 while (true) {// 一直准备发送数据,通过控制台输入
    
96.                         try {
    
97.                                 // 录入数据
    
98.                                 BufferedReader bufr = new BufferedReader(new InputStreamReader(
    
99.                                                 System.in));
    
100.                                 String line = null;
     
101.                                 while ((line = bufr.readLine()) != null) {
     
102.                                         if ("over".equals(line))
     
103.                                                 return;
     
104.                                         byte[] buf = line.getBytes();
     
105.                                         DatagramPacket dp = new DatagramPacket(buf, buf.length,
     
106.                                                         InetAddress.getByName("192.168.1.101"), 5561);// 将数据写入包中,
     
107.                                         //ip192.168.1.255为广播,发送往该网段所有的主机
     
108. 
     
109.                                         ds.send(dp);
     
110.                                 }
     
111.                                 // ds.close();
     
112.                         } catch (IOException e) {
     
113.                                 // TODO Auto-generated catch block
     
114.                                 e.printStackTrace();
     
115.                         }
     
116.                 }
     
117.         }
     
118. }
     
119. 
     
120. class UDPRece implements Runnable {
     
121.         public void run() {
     
122.                 DatagramSocket ds = null;
     
123.                 try {
     
124.                         ds = new DatagramSocket(5561);// 需要在while(true)外面设置,否则发生端口绑定异常
     
125.                 } catch (SocketException e1) {
     
126.                         // TODO Auto-generated catch block
     
127.                         e1.printStackTrace();
     
128.                 }
     
129.                 while (true) {// 一直准备接收数据
     
130.                         try {
     
131.                                 byte[] buf = new byte[1024];
     
132.                                 DatagramPacket dp = new DatagramPacket(buf, buf.length);// 接收数据后的存储位置
     
133.                                 ds.receive(dp);// 接收数据
     
134.                                 String ip = dp.getAddress().getHostAddress();// 获取数据中的ip
     
135.                                 String data = new String(buf, 0, dp.getLength());// 获取数据内容
     
136.                                 int port = dp.getPort();
     
137.                                 System.out.println("ip:(" + ip + "),data:(" + data + "),port:("
     
138.                                                 + port + ").");
     
139.                                 // ds.close();
     
140.                         } catch (IOException e) {
     
141.                                 // TODO Auto-generated catch block
     
142.                                 e.printStackTrace();
     
143.                         }
     
144.                 }
     
145.         }
     
146. }

复制代码

写在外边是为了再有局部函数使用该变量时使用。而构造函数你好像复制错了，构造函数重载后，默认无参的构造函数就没有了。