黑马程序员学习笔记之六（java网络编程）

最新推荐文章于 2024-05-09 14:29:24 发布

FX_SKY

最新推荐文章于 2024-05-09 14:29:24 发布

阅读量701

点赞数

分类专栏：黑马程序员笔记文章标签：网络编程 java 服务器 socket exception

本文链接：https://blog.csdn.net/BBF15/article/details/7332362

版权

黑马程序员笔记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

---------------------- android培训、java培训、期待与您交流！ ----------------------

网络编程概述

网络编程就是两个或多个设备之间的数据交换，其实更具体的说，网络编程就是两个或多个程序之间的数据交换，和普通的单机程序相比，网络程序最大的不同就是需要交换数据的程序运行在不同的计算机上，这样就造成了数据交换的复杂。虽然通过IP地址和端口可以找到网络上运行的一个程序，但是如果需要进行网络编程，则还需要了解网络通讯的过程。

网络通讯基于“请求-响应”模型。在网络通讯中，第一次主动发起通讯的程序被称作客户端(Client)程序，简称客户端，而在第一次通讯中等待连接的程序被称作服务器端(Server)程序，简称服务器。一旦通讯建立，则客户端和服务器端完全一样，没有本质的区别。

由此，网络编程中的两种程序就分别是客户端和服务器端，例如QQ程序，每个QQ用户安装的都是QQ客户端程序，而QQ服务器端程序则运行在腾讯公司的机房中，为大量的QQ用户提供服务。这种网络编程的结构被称作客户端/服务器结构，也叫做Client/Server结构，简称C/S结构。

使用C/S结构的程序，在开发时需要分别开发客户端和服务器端，这种结构的优势在于由于客户端是专门开发的，所以根据需要实现各种效果，专业点说就是表现力丰富，而服务器端也需要专门进行开发。但是这种结构也存在着很多不足，例如通用性差，几乎不能通用等，也就是说一种程序的客户端只能和对应的服务器端通讯，而不能和其它服务器端通讯，在实际维护时，也需要维护专门的客户端和服务器端，维护的压力比较大。

其实在运行很多程序时，没有必要使用专用的客户端，而需要使用通用的客户端，例如浏览器，使用浏览器作为客户端的结构被称作浏览器/服务器结构，也叫做Browser/Server结构，简称为B/S结构。

使用B/S结构的程序，在开发时只需要开发服务器端即可，这种结构的优势在于开发的压力比较小，不需要维护客户端。但是这种结构也存在着很多不足，例如浏览器的限制比较大，表现力不强，无法进行系统级操作等。

总之C/S结构和B/S结构是现在网络编程中常见的两种结构，B/S结构其实也就是一种特殊的C/S结构。

另外简单的介绍一下P2P(Point to Point)程序，常见的如BT、电驴等。P2P程序是一种特殊的程序，应该一个P2P程序中既包含客户端程序，也包含服务器端程序，例如BT，使用客户端程序部分连接其它的种子(服务器端)，而使用服务器端向其它的BT客户端传输数据。如果这个还不是很清楚，其实P2P程序和手机是一样的，当手机拨打电话时就是使用客户端的作用，而手机处于待机状态时，可以接收到其它用户拨打的电话则起的就是服务器端的功能，只是一般的手机不能同时使用拨打电话和接听电话的功能，而P2P程序实现了该功能。

网络通讯方式

在现有的网络中，网络通讯的方式主要有两种：

1、 TCP(传输控制协议)方式

2、 UDP(用户数据报协议)方式

为了方便理解这两种方式，还是先来看一个例子。大家使用手机时，向别人传递信息时有两种方式：拨打电话和发送短信。使用拨打电话的方式可以保证将信息传递给别人，因为别人接听电话时本身就确认接收到了该信息。而发送短信的方式价格低廉，使用方便，但是接收人有可能接收不到。

在网络通讯中，TCP方式就类似于拨打电话，使用该种方式进行网络通讯时，需要建立专门的虚拟连接，然后进行可靠的数据传输，如果数据发送失败，则客户端会自动重发该数据。而UDP方式就类似于发送短信，使用这种方式进行网络通讯时，不需要建立专门的虚拟连接，传输也不是很可靠，如果发送失败则客户端无法获得。

这两种传输方式都是实际的网络编程中进行使用，重要的数据一般使用TCP方式进行数据传输，而大量的非核心数据则都通过UDP方式进行传递，在一些程序中甚至结合使用这两种方式进行数据的传递。

由于TCP需要建立专用的虚拟连接以及确认传输是否正确，所以使用TCP方式的速度稍微慢一些，而且传输时产生的数据量要比UDP稍微大一些。

Java网络编程技术

Java语言是在网络环境下诞生的，所以Java语言虽然不能说是对于网络编程的支持最好的语言，但是必须说是一种对于网络编程提供良好支持的语言，使用Java语言进行网络编程将是一件比较轻松的工作。

和网络编程有关的基本API位于java.net包中，该包中包含了基本的网络编程实现，该包是网络编程的基础。该包中既包含基础的网络编程类，也包含封装后的专门处理WEB相关的处理类。在本章中，将只介绍基础的网络编程类。

首先来介绍一个基础的网络类——InetAddress类。该类的功能是代表一个IP地址，并且将IP地址和域名相关的操作方法包含在该类的内部。

关于该类的使用，下面通过一个基础的代码示例演示该类的使用，代码如下：

import java.net.*;
public class InetAddressDemo {

         public static void main(String[] args) {

                   try{

                            //使用域名创建对象

                            InetAddress inet1 = InetAddress.getByName("www.sina.com");

                            System.out.println(inet1);

                            //使用IP创建对象

                            InetAddress inet2 = InetAddress.getByName("127.0.0.1");

                            System.out.println(inet2);

                            //获得本机地址对象

                            InetAddress inet3 = InetAddress.getLocalHost();

                            System.out.println(inet3);

                            //获得对象中存储的域名

                            String host = inet3.getHostName();

                            System.out.println("域名：" + host);

                            //获得对象中存储的IP

                            String ip = inet3.getHostAddress();

                            System.out.println("IP:" + ip);

                   }catch(Exception e){}

         }

}

运行结果：

说明：由于该代码中包含一个互联网的网址，所以运行该程序时需要联网，否则将产生异常。

在后续的使用中，经常包含需要使用InetAddress对象代表IP地址的构造方法，当然，该类的使用不是必须的，也可以使用字符串来代表IP地址进行实现。

一 TCP编程

网络通讯的方式有TCP和UDP两种，其中TCP方式的网络通讯是指在通讯的过程中保持连接，有点类似于打电话，只需要拨打一次号码(建立一次网络连接)，就可以多次通话(多次传输数据)。这样方式在实际的网络编程中，由于传输可靠，类似于打电话，如果甲给乙打电话，乙说没有听清楚让甲重复一遍，直到乙听清楚为止，实际的网络传输也是这样，如果发送的一方发送的数据接收方觉得有问题，则网络底层会自动要求发送方重发，直到接收方收到为止。

在Java语言中，对于TCP方式的网络编程提供了良好的支持，在实际实现时，以java.net.Socket类代表客户端连接，以java.net.ServerSocket类代表服务器端连接。在进行网络编程时，底层网络通讯的细节已经实现了比较高的封装，所以在程序员实际编程时，只需要指定IP地址和端口号码就可以建立连接了。正是由于这种高度的封装，一方面简化了Java语言网络编程的难度，另外也使得使用Java语言进行网络编程时无法深入到网络的底层，所以使用Java语言进行网络底层系统编程很困难，具体点说，Java语言无法实现底层的网络嗅探以及获得IP包结构等信息。但是由于Java语言的网络编程比较简单，所以还是获得了广泛的使用。

在客户端网络编程中，首先需要建立连接，在Java API中以java.net.Socket类的对象代表网络连接，所以建立客户端网络连接，也就是创建Socket类型的对象，该对象代表网络连接，示例如下：

Socket socket1 = new Socket(“192.168.1.103”,10000);

Socket socket2 = new Socket(“www.sohu.com”,80);

上面的代码中，socket1实现的是连接到IP地址是192.168.1.103的计算机的10000号端口，而socket2实现的是连接到域名是www.sohu.com的计算机的80号端口，至于底层网络如何实现建立连接，对于程序员来说是完全透明的。如果建立连接时，本机网络不通，或服务器端程序未开启，则会抛出异常。

连接一旦建立，则完成了客户端编程的第一步，紧接着的步骤就是按照“请求-响应”模型进行网络数据交换，在Java语言中，数据传输功能由Java IO实现，也就是说只需要从连接中获得输入流和输出流即可，然后将需要发送的数据写入连接对象的输出流中，在发送完成以后从输入流中读取数据即可。示例代码如下：

OutputStream os = socket1.getOutputStream(); //获得输出流

InputStream is = socket1.getInputStream(); //获得输入流

上面的代码中，分别从socket1这个连接对象获得了输出流和输入流对象，在整个网络编程中，后续的数据交换就变成了IO操作，也就是遵循“请求-响应”模型的规定，先向输出流中写入数据，这些数据会被系统发送出去，然后在从输入流中读取服务器端的反馈信息，这样就完成了一次数据交换过程，当然这个数据交换过程可以多次进行。

这里获得的只是最基本的输出流和输入流对象，还可以根据前面学习到的IO知识，使用流的嵌套将这些获得到的基本流对象转换成需要的装饰流对象，从而方便数据的操作。

最后当数据交换完成以后，关闭网络连接，释放网络连接占用的系统端口和内存等资源，完成网络操作，示例代码如下：

socket1.close();

这就是最基本的网络编程功能介绍。下面是一个简单的网络客户端程序示例，该程序的作用是向服务器端发送一个字符串“服务端，你好”，服务器端的反馈“哥们，你也好”并显示到控制台，数据交换只进行一次，当数据交换进行完成以后关闭网络连接，程序结束。实现的代码如下：

import java.io.*;
import java.net.*;
/*
演示tcp的传输的客户端和服务端的互访。

需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。

*/

/*
客户端：
1，建立socket服务。指定要连接主机和端口。
2，获取socket流中的输出流。将数据写到该流中。通过网络发送给服务端。
3，获取socket流中的输入流，将服务端反馈的数据获取到，并打印。
4，关闭客户端资源。

*/
class TcpClient2 
{
	public static void main(String[] args)throws Exception 
	{
		Socket s = new Socket("192.168.0.15",10004);
		
		OutputStream out = s.getOutputStream();

		out.write("服务端，你好".getBytes());

		
		InputStream in = s.getInputStream();

		byte[] buf = new byte[1024];

		int len = in.read(buf);

		System.out.println(new String(buf,0,len));

		s.close();
	}
}


class TcpServer2
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss = new ServerSocket(10004);

		Socket s = ss.accept();

		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"....connected");
		InputStream in = s.getInputStream();

		byte[] buf = new byte[1024];

		int len = in.read(buf);

		System.out.println(new String(buf,0,len));


		OutputStream out = s.getOutputStream();


		Thread.sleep(10000);
		out.write("哥们收到,你也好".getBytes());

		s.close();

		ss.close();
	}
}

运行结果：

在该示例代码中建立了一个连接到IP地址为192.168.0.15，端口号码为10004的TCP类型的网络连接，然后获得连接的输出流对象，将需要发送的字符串“服务端，你好”转换为byte数组写入到输出流中，由系统自动完成将输出流中的数据发送出去，如果需要强制发送，可以调用输出流对象中的flush方法实现。在数据发送出去以后，从连接对象的输入流中读取服务器端的反馈信息，读取时可以使用IO中的各种读取方法进行读取，这里使用最简单的方法进行读取，从输入流中读取到的内容就是服务器端的反馈，并将读取到的内容在客户端的控制台进行输出，最后依次关闭打开的流对象和网络连接对象。

在服务器端程序编程中，由于服务器端实现的是被动等待连接，所以服务器端编程的第一个步骤是监听端口，也就是监听是否有客户端连接到达。实现服务器端监听的代码为：

ServerSocket ss = new ServerSocket(10000);

该代码实现的功能是监听当前计算机的10000号端口，如果在执行该代码时，10000号端口已经被别的程序占用，那么将抛出异常。否则将实现监听。

服务器端编程的第二个步骤是获得连接。该步骤的作用是当有客户端连接到达时，建立一个和客户端连接对应的Socket连接对象，从而释放客户端连接对于服务器端端口的占用。实现功能就像公司的前台一样，当一个客户到达公司时，会告诉前台我找某某某，然后前台就通知某某某，然后就可以继续接待其它客户了。通过获得连接，使得客户端的连接在服务器端获得了保持，另外使得服务器端的端口释放出来，可以继续等待其它的客户端连接。实现获得连接的代码是：

Socket socket = ss.accept();

该代码实现的功能是获得当前连接到服务器端的客户端连接。需要说明的是accept和前面IO部分介绍的read方法一样，都是一个阻塞方法，也就是当无连接时，该方法将阻塞程序的执行，直到连接到达时才执行该行代码。

前面的服务器端程序，只是实现了概念上的服务器端，离实际的服务器端程序结构距离还很遥远，如果需要让服务器端能够实际使用，那么最需要解决的问题就是——如何支持多个客户端同时工作。

一个服务器端一般都需要同时为多个客户端提供通讯，如果需要同时支持多个客户端，则必须使用多线程技术。简单来说，也就是当服务器端接收到一个连接时，启动一个专门的线程处理和该客户端的通讯。

下面以图片上传为例来演示，代码如下：

客户端：

import java.io.*;
import java.net.*;

/*
 * Tcp上传图片文件
 * */
public class PicClient {

	/**
	 * @param args
	 */
	public static void main(String[] args)throws Exception {
		// TODO Auto-generated method stub
		
		/*
		 * 客户端只允许上传jpg格式的图片，并且不能超过5M。
		 * 
		 * */
		if(args.length!=1)
		{
			System.out.println("请选择一个jpg格式的图片");
			return ;
		}
		
		File file = new File(args[0]);
		System.out.println(args[0]);
		// 判断文件是否有效
		if(!(file.exists()&&file.isFile()))
		{
			System.out.println("该文件有问题，要么不存在，要么不是文件");
			return ;
		}
		// 判断文件大小是否合法
		if(file.length()>=1024*1024*5)
		{
			System.out.println("请上传容量小于5M的图片");
			return ;
		}
		// 判断文件格式
		if(!file.getName().endsWith("jpg"))
		{
			System.out.println("请上传jpg格式的图片");
			return ;
		}
		
		
		Socket s = new Socket(InetAddress.getByName("192.168.0.15"),10007);
		
		FileInputStream  fis = new FileInputStream(file);
		OutputStream out = s.getOutputStream();
		
		byte[] buf = new byte[1024];
		
		int len = 0;
		while((len=fis.read(buf))!=-1)
		{
			out.write(buf,0,len);
		}
		
		s.shutdownOutput(); //告知服务端数据已写完
		
		InputStream in = s.getInputStream();
		byte[] bfuIn = new byte[1024];
		int num = in.read(bfuIn);
		System.out.println(new String(bfuIn,0,num));
		
		fis.close();
		s.close();
	}

}

服务端：

import java.io.*;
import java.net.*;

/*
 * 客户端并发上传文件
 */
public class PicThread implements Runnable{

	private Socket s;
	
	public PicThread(Socket s)
	{
		this.s = s ;
	}
	
	public void run()
	{
		int count = 1;
		String ip = s.getInetAddress().getHostAddress();
		try {
			
			System.out.println(ip+"......connected");
			
			File file = new File(ip+"("+count+")"+".jpg");
			//if(file.exists())
			while(file.exists())  // 不能写成if，要用while进行循环判断
			{
				file = new File(ip+"("+(count++)+")"+".jpg");
			}
			
			FileOutputStream fos = new FileOutputStream(file);
			
			InputStream in = s.getInputStream();
			
			byte[] buf = new byte[1024];
			int len = 0;
			while((in.read(buf))!=-1)
			{
				fos.write(buf,0,len);
			}
			
			OutputStream out = s.getOutputStream();
			out.write("上传成功".getBytes());
			
			fos.close();
			s.close();
			
		} catch (Exception e) {
			// TODO: handle exception
			new RuntimeException("上传失败");
		}
	}
}

import java.net.*;

public class PicServer_Multiple {

	/**
	 * @param args
	 */
	public static void main(String[] args)throws Exception {
		// TODO Auto-generated method stub

		ServerSocket ss = new ServerSocket(10007);
		
		while(true)
		{
			Socket s = ss.accept();
			
			new Thread(new PicThread(s)).start();
		}
	}

}

运行结果：

在该示例代码中，每次使用一个连接对象构造该线程，该连接对象就是该线程需要处理的连接，在线程构造完成以后，该线程就被启动起来了，然后在run方法内部对客户端连接进行处理。服务端在保存图片时，为避免文件重名而被覆盖，使用客户端的ip加上一个计数器来命名。

总结：

在TCP编程中要注意结束标记的问题，否则客户端与服务端会陷入莫名的等待

解决办法有两种

（1）时间戳

（2）客户端每次写完数据后将输出流关闭。相当于给流加上一个结束标记 -1。

二 UDP编程

在Java API中，实现UDP方式的编程，包含客户端网络编程和服务器端网络编程，主要由两个类实现，分别是：

l DatagramSocket

DatagramSocket类实现“网络连接”，包括客户端网络连接和服务器端网络连接。虽然UDP方式的网络通讯不需要建立专用的网络连接，但是毕竟还是需要发送和接收数据，DatagramSocket实现的就是发送数据时的发射器，以及接收数据时的监听器的角色。类比于TCP中的网络连接，该类既可以用于实现客户端连接，也可以用于实现服务器端连接。

l DatagramPacket

DatagramPacket类实现对于网络中传输的数据封装，也就是说，该类的对象代表网络中交换的数据。在UDP方式的网络编程中，无论是需要发送的数据还是需要接收的数据，都必须被处理成DatagramPacket类型的对象，该对象中包含发送到的地址、发送到的端口号以及发送的内容等。其实DatagramPacket类的作用类似于现实中的信件，在信件中包含信件发送到的地址以及接收人，还有发送的内容等，邮局只需要按照地址传递即可。在接收数据时，接收到的数据也必须被处理成DatagramPacket类型的对象，在该对象中包含发送方的地址、端口号等信息，也包含数据的内容。和TCP方式的网络传输相比，IO编程在UDP方式的网络编程中变得不是必须的内容，结构也要比TCP方式的网络编程简单一些。

下面通过一个示例来演示，代码如下：

import java.net.*;

/*
需求：通过udp传输方式，将一段文字数据发送出去。，
定义一个udp发送端。
思路：
1，建立updsocket服务。
2，提供数据，并将数据封装到数据包中。
3，通过socket服务的发送功能，将数据包发出去。
4，关闭资源。

*/


class  UdpSend
{
	public static void main(String[] args) throws Exception
	{
		//1，创建udp服务。通过DatagramSocket对象。
		DatagramSocket ds = new DatagramSocket(8888);

		//2，确定数据，并封装成数据包。DatagramPacket(byte[] buf, int length, InetAddress address, int port) 

		byte[] buf = "First UDP packet ".getBytes();
		DatagramPacket dp = 
			new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.0.15"),10000);

		//3，通过socket服务，将已有的数据包发送出去。通过send方法。
		ds.send(dp);

		//4，关闭资源。

		ds.close();

	}
}

/*
需求：
定义一个应用程序，用于接收udp协议传输的数据并处理的。


定义udp的接收端。
思路：
1，定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。
	方便于明确哪些数据过来该应用程序可以处理。

2，定义一个数据包，因为要存储接收到的字节数据。
因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
3，通过socket服务的receive方法将收到的数据存入已定义好的数据包中。
4，通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。
5，关闭资源。

*/


class  UdpRece
{
	public static void main(String[] args) throws Exception
	{
		//1,创建udp socket，建立端点。
		DatagramSocket ds = new DatagramSocket(10000);
		while(true)
		{
		//2,定义数据包。用于存储数据。
		byte[] buf = new byte[1024];
		DatagramPacket dp = new DatagramPacket(buf,buf.length);

		//3，通过服务的receive方法将收到数据存入数据包中。
		ds.receive(dp);//阻塞式方法。
		

		//4，通过数据包的方法获取其中的数据。
		String ip = dp.getAddress().getHostAddress();

		String data = new String(dp.getData(),0,dp.getLength());

		int port = dp.getPort();

		System.out.println(ip+"::"+data+"::"+port);

		}
		//5，关闭资源
		//ds.close();

	}
}

运行结果：

在该服务器端实现中，首先监听10000号端口，和TCP方式的网络编程类似，服务器端的receive方法是阻塞方法，如果客户端不发送数据，则程序会在该方法处阻塞。当客户端发送数据到达服务器端时，则接收客户端发送过来的数据，然后将客户端发送的数据内容读取出来，并在服务器端程序中打印客户端的相关信息，从客户端发送过来的数据包中可以读取出客户端的IP以及客户端端口号，最后关闭服务器端连接，释放占用的系统资源，完成程序功能示例。

和前面TCP方式中的网络编程类似，这个示例也仅仅是网络编程的功能示例，也存在前面介绍的客户端无法进行多次数据交换，以及服务器端不支持多个客户端的问题，这两个问题也需要对于代码进行处理才可以很方便的进行解决。

下面是实现客户端多次发送以及服务器端支持多个数据包同时处理的程序结构，实现的原理和TCP方式类似，在客户端将数据的发送和接收放入循环中，而服务器端则将接收到的每个数据包启动一个专门的线程进行处理。实现的代码如下：

/*
编写一个聊天程序。
有收数据的部分，和发数据的部分。
这两部分需要同时执行。
那就需要用到多线程技术。
一个线程控制收，一个线程控制发。

因为收和发动作是不一致的，所以要定义两个run方法。
而且这两个方法要封装到不同的类中。

*/
import java.io.*;
import java.net.*;
class Send implements Runnable
{
	private DatagramSocket ds;
	public Send(DatagramSocket ds)
	{
		this.ds = ds;
	}


	public void run()
	{
		try
		{
			BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

			String line = null;

			while((line=bufr.readLine())!=null)
			{
				

				byte[] buf = line.getBytes();

				DatagramPacket dp = 
					new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10002);

				ds.send(dp);

				if("886".equals(line))
					break;
			}
		}
		catch (Exception e)
		{
			throw new RuntimeException("发送端失败");
		}
	}
}

class Rece implements Runnable
{

	private DatagramSocket ds;
	public Rece(DatagramSocket ds)
	{
		this.ds = ds;
	}
	public void run()
	{
		try
		{
			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());

				if("886".equals(data))
				{
					System.out.println(ip+"....离开聊天室");
					break;
				}


				System.out.println(ip+":"+data);
			}
		}
		catch (Exception e)
		{
			throw new RuntimeException("接收端失败");
		}
	}
}


class  ChatDemo
{
	public static void main(String[] args) throws Exception
	{
		DatagramSocket sendSocket = new DatagramSocket();
		DatagramSocket receSocket = new DatagramSocket(10002);

		new Thread(new Send(sendSocket)).start();
		new Thread(new Rece(receSocket)).start();

	}
}

在示例中，客户端Send将和服务器端进行数据交换的逻辑写在一个while循环的内部，这样就可以实现和服务器端的多次交换了。最后当数据交换完成以后关闭连接，结束程序。服务器端Rece的接收逻辑，使用一个循环来接收客户端发送过来的数据包，当接收到数据包以后将客户端的ip和数据打印在控制台上。

在主程序ChatDemo中创建了两个线程，一个客户端Send和服务器端Rece，这样客户端和服务器就可以进行交互了。

运行结果如下：

由于UDP数据传输过程中可能存在丢失，所以在运行该程序时可能会出现程序阻塞的情况。如果需要避免该问题，可以将客户端的网络发送部分也修改成线程实现。

关于网络编程方面的就写到这里，由于自己知识有限，不足的地方，还请大家多多指教!

---------------------- android培训、java培训、期待与您交流！ ----------------------

FX_SKY

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员学习笔记之六（java网络编程）

---------------------- android培训、java培训、期待与您交流！ ---------------------- 网络编程概述网络编程就是两个或多个设备之间的数据交换，其实更具体的说，网络编程就是两个或多个程序之间的数据交换，和普通的单机程序相比，网络程序最大的不同就是需要交换数据的程序运行在不同的计算机上，这样就造成了数据交换的复
复制链接

扫一扫