1. package first;
   
2. 
   
3. import java.net.*;
   
4. import java.io.*;
   
5. /*如何定义线程呢？只要了明白了每个客户端要在服务端执行的代码即可
   
6. * 将改代码存入run方法中。
   
7. * */
   
8. class ClientTcp {
   
9. 
   
10.         public static void main(String[] args) throws Exception {
    
11.                 Socket s = new Socket("192.168.1.254", 80001);
    
12.                 FileInputStream fis = new FileInputStream("C:\\1.txt");
    
13.                 OutputStream out = s.getOutputStream();
    
14.                 byte[] buf = new byte[1024 * 64];
    
15.                 int len = 0;
    
16.                 while ((len = fis.read(buf)) != -1) {
    
17.                         out.write(buf, 0, len);
    
18.                 }
    
19.                 // 告诉服务端数据已经写完
    
20.                 s.shutdownOutput();
    
21. 
    
22.                 InputStream in = s.getInputStream();
    
23.                 byte[] bufin = new byte[1024 * 64];
    
24.                 int num = in.read(bufin);
    
25.                 System.out.println(new String(bufin, 0, num));
    
26.                 fis.close();
    
27.                 s.close();
    
28.         }
    
29. }
    
30. /*服务端：
    
31. 这个服务端有一个局限性，当a客户端连接上之后，被服务端获取到，服务端执行具体流程，
    
32. 这是b客户端连接，只有等待。
    
33. 因为服务端还没有处理完A客户端的请求，还要循环回来执行下次accept方法。所以
    
34. 暂时获取不到b客户端对象，
    
35. 那么为了可以让多个客户端同时并发访问服务端。
    
36. 那么服务端最好就是让每一个客户端封装到一个单独 的线程中去，这样可以同时处理多个客户端请求。
    
37. */
    
38. class ServerTcp {
    
39.         public static void main(String[] args) throws Exception {
    
40.                 ServerSocket ss = new ServerSocket(80001);
    
41.                 // 这里写while(true),服务端不会一直转，accept她是阻塞式方法。
    
42.                 while (true) {
    
43.                         // 拿到客户端对象
    
44.                         Socket s = ss.accept();
    
45.                         // 读取s中的数据
    
46.                         InputStream in = s.getInputStream();
    
47.                         FileOutputStream fos = new FileOutputStream("server.bmp");
    
48.                         byte[] buf = new byte[1024 * 64];
    
49.                         int len = 0;
    
50.                         while ((len = in.read(buf)) != -1) {
    
51.                                 fos.write(buf, 0, len);
    
52.                         }
    
53.                         // 搞一个输出流，反馈给客户信息，显示上传成功
    
54.                         OutputStream out = s.getOutputStream();
    
55.                         out.write("上传成功".getBytes());
    
56.                         fos.close();
    
57.                         s.close();
    
58.                         // ss.close();
    
59.                 }
    
60. 
    
61.         }
    
62. }

复制代码

怎么在一个.java里执行两个main方法，顺便看下程序？

这么长，这么好的代码，当然可以放在同一个.java中运行啦，你可以命名为DemoTcp.java它保存在大硬盘中，编译只写DemoTcp.java,但执行时，要单独写类的名称，如果你用的是DOS命令行的话要开两个。
亲，你的端口写错了吧？哪有这么大的端口。优化代码可以用多线程。

快乐的黑马 发表于 2014-1-5 21:15
这么长，这么好的代码，当然可以放在同一个.java中运行啦，你可以命名为DemoTcp.java它保存在大硬盘中，编 ...

好尖的眼，建议版主给你加一分，恩，端口太大，已经报错了，不过似乎还有其他方面的问题
不过用eclipse，开两个窗口，是有错的，，，？？

可以一起执行的
你可以这样来做  你这不是写了两个类么   随便把哪个定义成public的  然后把整个文件定义成和你public类同名文件
然后你执行就能看见会让你选你要执行哪个类的main方法

1. import java.net.*;
   
2. import java.io.*;
   
3. /*如何定义线程呢？只要了明白了每个客户端要在服务端执行的代码即可
   
4. * 将改代码存入run方法中。
   
5. * */
   
6. public class ClientTcp {
   
7. 
   
8.         public static void main(String[] args) throws Exception {
   
9.                 Socket s = new Socket("192.168.1.105", 8001);
   
10.                 FileInputStream fis = new FileInputStream("C:\\1.txt");
    
11.                 OutputStream out = s.getOutputStream();
    
12.                 byte[] buf = new byte[1024 * 64];
    
13.                 int len = 0;
    
14.                 while ((len = fis.read(buf)) != -1) {
    
15.                         out.write(buf, 0, len);
    
16.                 }
    
17.                 // 告诉服务端数据已经写完
    
18.                 s.shutdownOutput();
    
19. 
    
20.                 InputStream in = s.getInputStream();
    
21.                 byte[] bufin = new byte[1024 * 64];
    
22.                 int num = in.read(bufin);
    
23.                 System.out.println(new String(bufin, 0, num));
    
24.                 fis.close();
    
25.                 s.close();
    
26.         }
    
27. }
    
28. /*服务端：
    
29. 这个服务端有一个局限性，当a客户端连接上之后，被服务端获取到，服务端执行具体流程，
    
30. 这是b客户端连接，只有等待。
    
31. 因为服务端还没有处理完A客户端的请求，还要循环回来执行下次accept方法。所以
    
32. 暂时获取不到b客户端对象，
    
33. 那么为了可以让多个客户端同时并发访问服务端。
    
34. 那么服务端最好就是让每一个客户端封装到一个单独 的线程中去，这样可以同时处理多个客户端请求。
    
35. */
    
36. class ServerTcp {
    
37.         public static void main(String[] args) throws Exception {
    
38.                 ServerSocket ss = new ServerSocket(8001);
    
39.                 // 这里写while(true),服务端不会一直转，accept她是阻塞式方法。
    
40.                 while (true) {
    
41.                         // 拿到客户端对象
    
42.                         Socket s = ss.accept();
    
43.                         // 读取s中的数据
    
44.                         InputStream in = s.getInputStream();
    
45.                         FileOutputStream fos = new FileOutputStream("server.bmp");
    
46.                         byte[] buf = new byte[1024 * 64];
    
47.                         int len = 0;
    
48.                         while ((len = in.read(buf)) != -1) {
    
49.                                 fos.write(buf, 0, len);
    
50.                         }
    
51.                         // 搞一个输出流，反馈给客户信息，显示上传成功
    
52.                         OutputStream out = s.getOutputStream();
    
53.                         out.write("上传成功".getBytes());
    
54.                         fos.close();
    
55.                         s.close();
    
56.                         // ss.close();
    
57.                 }
    
58. 
    
59.         }
    
60. }
    

复制代码

我已经执行成功了哦，试试吧  有问题再问我哈   求技术分

哈哈，我还没十个技术分，够呛来找你们啊