Java教程

[java基础] 网络编程: 域名.InetAddress类.TCP/IP

本文主要是介绍[java基础] 网络编程: 域名.InetAddress类.TCP/IP,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

网络的相关概念

网络通信

image-20220206162654131.png

网络

image-20220206162750398.png

ip地址

  1. 概念:用于唯一标识网络中的每台计算和41主机
  2. 查看ip地址:ipconfig
  3. ip地址的表示形式:点分十进制 xx.xx.xx.xx
  4. 每一个十进制数的范围:0~255
  5. ip地址的组成=网络地址+主机地址,比如:192.168.16.69
  6. IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议,其地址数量号称可以为全世界的每 一粒沙子编上一个地址。
  7. 由于IPv4最大的问题在于网络地址资源有限,严重制约了互联网的应用和发展。IPv6的使用,不仅能解决网络地址资源数量的问题,而且也解决了多种接入设备连入互联网的障碍

ipv4地址分类

image-20220206162920663.png

image-20220206162926064.png

域名

  1. www.baidu.cam
  2. 好处:为了方便记忆,解决记ip的困难
  3. 概念:将!p地址映射成域名,这里怎么映射上,HTTP协议
  • 端口号
  1. 概念:用于标识计算机上某个特定的网络程序
  2. 表示形式:以整数形式,端口范围0-65535 [2个字节表示端口0~2^16-1]
  3. 0~1024已经被占用,比如ssh 22,ftp 21,smtp 25,http 80
    4.常见的网络程序端口号:
  • tomcat:8080
  • mysql:3306
  • oracle:1521
  • sqlserver:1433

网络通信协议

TCP/IP(Transmission Control Protocol/Internet Protocol)的简写,中文译名为:传输控制协议/因特网互联协议,又叫网络通讯协议,这个协议是Internet最基本的协议,Internet国际互联网络的基础,简单地说,就是由网络层的IP协议和传输层的TCP协议组成的.
image-20220206163035673.png

image-20220206163217826.png

TCP和UDP

TCP协议:传输控制协议

  1. 使用TCP协议前,须先建立TCP连接,形成传输数据通道
  2. 传输前,采用"三次握手"方式,是可靠的
  3. TCP协议进行通信的两个应用进程:客户端、服务端
  4. 在连接中可进行大数据量的传输
  5. 传输完毕,需释放已建立的连接,效率低
    UDP协议:用户数据协议
  6. 将数据、源、目的封装成数据包,不需要建立连接
  7. 每个数据报的大小限制在64k内,不适合传输大量数据
  8. 因无需连接,故是不可靠的
  9. 发送数据结束时无需释放资源(因为不是面向连接的),速度快

InetAddress类

相关方法

  1. 获取本机InetAddress对象 getLocalHost
  2. 根据指定主机名/域名获取ip地址对象 getByName
  3. 获取InetAddress对象的主机名 getHostName
  4. 获取InetAddress对象的地址 getHostAddress

案例:

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-16:43
 * @Version 演示InetAddress类的使用
 */
//主机名等价域名对应一个ip(地址)
public class API_ {
    public static void main(String[] args) throws UnknownHostException {
        //1. 获取本机的InetAddress 对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println("localHost = " + localHost);//主机名/ip

        //2. 根据指定  主机名 获取 InetAddress对象
        InetAddress host1 = InetAddress.getByName("WIN-I0Q1644D4PA");
        System.out.println("host1 = " + host1);//主机名/ip

        //3. 根据 域名 获取InetAddress对象
        //亦可根据ip获取InetAddress对象
        InetAddress host2 = InetAddress.getByName("www.baidu.com");
        System.out.println("host2 = " + host2);


        //4. 通过 InetAddress 对象,获取对应的地址
        String address = host2.getHostAddress();
        System.out.println("address = " + address);

        //5. 通过 InetAddress 对象,获取对应的主机名/或者的域名
        String name = host2.getHostName();
        System.out.println("name = " + name);


    }
}

Socket

  1. 套接字(Socket)开发网络应用程序被广泛采用,以至于成为事实上的标准。
  2. 通信的两端都要有Socket,是两台机器间通信的端点
  3. 网络通信其实就是Socket间的通信。
  4. Socket允许程序把网络连接当成一个流,数据在两个Socket间通过IO传输。
  5. 一般主动发起通信的应用程序属客户端,等待通信请求的为服务端

image-20220206163850798.png

TCP 网络通信编程

  1. 基于客户端一服务端的网络通信
  2. 底层使用的是TCP/IP协议
  3. 应用场景举例:客户端发送数据,服务端接受并显示控制台
  4. 基于Socket的TCP编程

image-20220206164008668.png

补充

  1. 当客户端连接到服务器后,实际上客户端也是通过一个端口和服务端进行通讯的,这个端口是TCP/IP来分配的,是不确定的,是随机的
  2. 程序验证+netstat

案例一

  1. 编写一个服务器端,和一个客户端
  2. 服务器端在9999端口监听
  3. 客户端连接到服务器端,发送"hello,server",然后退出
  4. 服务器端接收到客户端发送的信息,输出,并退出
/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:25
 * @Version
 * 服务端
 */
public class Server {
    public static void main(String[] args) throws IOException {
        //在(默认)本机的指定端口建立服务端插座
        //注意:serverSocket监听9999的前提是没有其他服务在监听9999
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,在9999端口监听,并等待连接..");

        //等待连接插入-->若没有连接,程序阻塞-->若连接成功,返回Socket对象,程序继续
        //注意:该方法可返回多个Socket对象->多个客户端连接服务器的并发
        Socket socket = serverSocket.accept();

        //net包下Socket类型
        System.out.println("服务端 socket="+socket.getClass());

        //通过网络连接构造输入流:读取
        InputStream inputStream = socket.getInputStream();

        byte[] buf = new byte[1024];
        int length;
        while ((length = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, length));
        }

        //关闭流,连接,端口插座(插孔有限)以节约资源
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:25
 * @Version
 * 客户端,发送 "hello, server" 给服务端
 */
public class Client {
    public static void main(String[] args) throws IOException {
        //客户端连接到服务端(本机的9999端口)的插座-->若连接成功,返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        //与服务端的连接类型一致
        System.out.println("客户端socket="+socket.getClass());

        //通过网络连接构造输出流:写入
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,sever".getBytes());

        //关闭流,连接
        outputStream.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

案例二

1.编写一个服务端,和一个客户端
2.服务器端在9999端口监听
3.客户端连接到服务端,发送”hello, serer",并接收服务器端回发的 “heilo,client”,再退出
4.服务器端接收到客户端发送的信息,输出,并发送”hello, client",再退出

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:57
 * @Version
 * 服务端:接收客户端发送的消息-->并发送"hello,client"
 */
public class Server {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //在(默认)本机的指定端口建立服务端插座
        //注意:serverSocket监听9999的前提是没有其他服务在监听9999
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,在9999端口监听,并等待连接..");

        //等待连接插入-->若没有连接,程序阻塞-->若连接成功,返回Socket对象,程序继续
        //注意:该方法可返回多个Socket对象->多个客户端连接服务器的并发
        Socket socket = serverSocket.accept();

        //net包下Socket类型
        System.out.println("服务端 socket="+socket.getClass()+"已连接");

        //通过网络连接构造输入流:读取
        InputStream inputStream = socket.getInputStream();

        byte[] buf = new byte[1024];
        int length;
        while ((length = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, length));
        }

        //读取后的 写入到数据通道
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,client".getBytes());

        //设置(输出)结束标记
        socket.shutdownOutput();//若写入后没有再传输可以不设置标记

        //关闭流,连接,端口插座(插孔有限)以节约资源
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();

    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:56
 * @Version
 * 客户端:连接服务端-->发送"hello,server"-->接收服务端回发的"hello,client"-->退出
 */
public class Client {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //客户端连接到服务端(本机的9999端口)的插座-->若连接成功,返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        //与服务端的连接类型一致
        System.out.println("客户端socket="+socket.getClass()+"已连接");

        //通过网络连接构造输出流:写入
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,sever".getBytes());

        //设置(输出)结束标记(先写后读不可省略,否则两端都阻塞在数据的传输上)
//        socket.shutdownOutput();

        //写入后的 读取数据
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int length;
        while ((length = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, length));
        }

        //关闭流,连接
        inputStream.close();
        outputStream.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

案例三

  1. 编写一个服务端,和一个客户端
  2. 服务端在9999端口监听
  3. 客户端连接到服务端,发送"hello,server",并接收服务端回发的"hello,client",在退出
  4. 服务端接收到客户端发送的信息,输出,并发送"hello,client",再退出
/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:57
 * @Version 字符流方式
 * 服务端:接收客户端发送的消息-->并发送"hello,client"
 */
public class Server {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //在(默认)本机的指定端口建立服务端插座
        //注意:serverSocket监听9999的前提是没有其他服务在监听9999
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,在9999端口监听,并等待连接..");

        //等待连接插入-->若没有连接,程序阻塞-->若连接成功,返回Socket对象,程序继续
        //注意:该方法可返回多个Socket对象->多个客户端连接服务器的并发
        Socket socket = serverSocket.accept();

        //net包下Socket类型
        System.out.println("服务端 socket="+socket.getClass()+"已连接");

        //通过网络连接构造输入流:读取
        InputStream inputStream = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));

        System.out.println(br.readLine());

        //读取后的 写入到数据通道
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
        bw.write("hello,client 字符流");


        //设置(输出)结束标记
//      bw.newLine();//若写入后没有再传输可以不设置标记


        //关闭流,连接,端口插座(插孔有限)以节约资源
        bw.close();//写入
        br.close();
        socket.close();
        serverSocket.close();

    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:56
 * @Version 字符流方式
 * 客户端:连接服务端-->发送"hello,server"-->接收服务端回发的"hello,client"-->退出
 */
public class Client {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //客户端连接到服务端(本机的9999端口)的插座-->若连接成功,返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        //与服务端的连接类型一致
        System.out.println("客户端socket="+socket.getClass()+"已连接");

        //通过网络连接构造输出流:写入
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
        bw.write("hello,server 字符流");


        //设置(输出)结束标记(先写后读不可省略,否则两端都阻塞在数据的传输上)
        bw.newLine();//对应的另一端必须使用readLine!!!
        bw.flush();//刷新以写入

        //写入后的 读取数据
        InputStream inputStream = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));

        System.out.println(br.readLine());

        //关闭流,连接
        br.close();
        bw.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

案例四(上传文件)

  1. 编写一个服务端,和一个客户端
  2. 服务器端在8 888端口监听
  3. 客户端连接到服务端,发送一张图片e://q i e. p n g
  4. 服务器端接收到客户端发送的图片,保存到src下,发送”收到图片”
  5. 客户端接收到服务端发送的”收到图片”,再退出
  6. 该程序要求使用StreamUtils.java,我们直接使用

image-20220206165633293.png

public class StreamUtils {
	/**
	 * 功能:将输入流转换成byte[]
	 * @param is
	 * @return
	 * @throws Exception
	 */
	public static byte[] streamToByteArray(InputStream is) throws Exception{
		ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
		byte[] b = new byte[1024];
		int len;
		while((len=is.read(b))!=-1){
			bos.write(b, 0, len);	
		}
		byte[] array = bos.toByteArray();
		bos.close();
		return array;
	}
	/**
	 * 功能:将InputStream转换成String
	 * @param is
	 * @return
	 * @throws Exception
	 */
	
	public static String streamToString(InputStream is) throws Exception{
		BufferedReader reader = new BufferedReader(new InputStreamReader(is));
		StringBuilder builder= new StringBuilder();
		String line;
		while((line=reader.readLine())!=null){ //当读取到 null时,就表示结束
			builder.append(line+"\r\n");
		}
		return builder.toString();
		
	}

}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-19:58
 * @Version 服务端
 * 接收客户端发送的文件-->保存到系统文件目录下-->发送"收到图片"后退出
 */
public class Server {
    public static void main(String[] args) throws Exception {
        //创建字节输出流-->上传到本地
        String filePath = "chapter21\\src\\Copy.wmv";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));

        //服务端监听本机端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端,监听8888端口,等待连接...");

        //等待连接
        Socket socket = serverSocket.accept();

        //连接后创建数据通道的输入流/输出流
        InputStream inputStream = socket.getInputStream();
        OutputStream outputStream = socket.getOutputStream();

        /*byte[] buf = new byte[1024];
        int length;
        //从数据通道的输入流读取到图片数据
        while ((length = inputStream.read(buf)) != -1) {
            //通过字节输出流将数据写入到指定目录下的文件
            bos.write(buf,0,length);
        }*/

        //不使用缓冲数组的先读后写(简化了循环读写)
        byte[] bytes = StreamUtils.streamToByteArray(inputStream);
        bos.write(bytes);

        //从数据通道的输出流写入文本数据
        outputStream.write("收到图片".getBytes());

        //关闭资源
        outputStream.close();
        inputStream.close();
        bos.close();
        socket.close();
        serverSocket.close();
    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-19:58
 * @Version 客户端
 * 连接到服务端-->发送磁盘里的文件-->接收到"收到图片"后退出
 */
public class Client {
    public static void main(String[] args) throws Exception {
        //创建字节输入流-->从磁盘读取到内存
        String filePath = "f:\\io\\bufferedCopy.wmv";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));

        //连接到服务端
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);

        //创建数据通道的输出流/输入流
        OutputStream outputStream = socket.getOutputStream();
        InputStream inputStream = socket.getInputStream();


        /*byte[] buf = new byte[1024];
        int length;
        //通过字节输入流从磁盘读取到图片数据
        while ((length = bis.read(buf)) != -1) {
            //通过数据通道的输出流写入图片数据
            outputStream.write(buf,0,length);
        }*/

        //简化版先读后写
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        outputStream.write(bytes);

        //设置传输结束标记
        socket.shutdownOutput();

        /*byte[] bytes = new byte[1024];
        int len;
        //通过数据通道的输入流读取文本数据
        while ((len = inputStream.read(bytes))!=-1) {
            System.out.println(new String(bytes,0,len));
        }*/

        //简化版循环读取打印
        String string = StreamUtils.streamToString(inputStream);
        System.out.println(string);

        //关闭资源
        inputStream.close();
        outputStream.close();
        bis.close();
        socket.close();
    }
}

案例五(下载文件)

  1. 编写客户端程序和服务器端程序
  2. 客户端可以输入一个音乐文件名,比如高山流水,服务端收到音乐名后,可以给客户端返回这个音乐文件,如果服务器没有这个文件,返回一个默认的音乐即可.
  3. 客户端收到文件后,保存到本地e:\
  4. 提示:该程序可以使用StreamUtils.java
    本质:其实就是指定下载文件的应用
public class StreamUtils {
	/**
	 * 功能:将输入流转换成byte[]
	 * @param is
	 * @return
	 * @throws Exception
	 */
	public static byte[] streamToByteArray(InputStream is) throws Exception{
		ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
		byte[] b = new byte[1024];
		int len;
		while((len=is.read(b))!=-1){
			bos.write(b, 0, len);	
		}
		byte[] array = bos.toByteArray();
		bos.close();
		return array;
	}
	/**
	 * 功能:将InputStream转换成String
	 * @param is
	 * @return
	 * @throws Exception
	 */
	
	public static String streamToString(InputStream is) throws Exception{
		BufferedReader reader = new BufferedReader(new InputStreamReader(is));
		StringBuilder builder= new StringBuilder();
		String line;
		while((line=reader.readLine())!=null){ //当读取到 null时,就表示结束
			builder.append(line+"\r\n");
		}
		return builder.toString();
		
	}

}

public class Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,监听9999端口,等待连接...");
        Socket socket = serverSocket.accept();

        //接收文件名
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String musicName = br.readLine();
        System.out.println("客户端点歌:"+musicName);

        String srcPath = "";
        if (musicName.equals("高山流水")) {
            srcPath = "chapter21\\src\\高山流水.mp3";
        } else {
            srcPath="chapter21\\src\\无名.mp3";
        }

        //提取文件数据到数组
        FileInputStream fileInputStream = new FileInputStream(srcPath);
        byte[] data = StreamUtils.streamToByteArray(fileInputStream);

        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(data);

        bos.close();
        fileInputStream.close();
        br.close();
        socket.close();
        serverSocket.close();

    }
}

public class Client {
    public static void main(String[] args) throws Exception {
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入下载的音乐名");
        String music = sc.next();
        bw.write(music);
        bw.newLine();
        bw.flush();

        InputStream inputStream = socket.getInputStream();
        byte[] data = StreamUtils.streamToByteArray(inputStream);

        String destPath = "";
        if (music.equals("高山流水")) {
            destPath = "f:\\io\\高山流水.mp3";
        } else {
            destPath = "f:\\io\\zxk.mp3";
        }
        FileOutputStream fos = new FileOutputStream(destPath);
        fos.write(data);

        fos.close();
        inputStream.close();
        bw.close();
        socket.close();
        System.out.println("客户端退出");
    }
}

netstat指令

image-20220206165239029.png

补充:

netstat -anb指令:

查看监听端口的应用:

必须在管理员身份下运行控制台输入指令

UDP 网络通信编程

介绍

  1. 类DatagramSocket和DatagramPacket[数据报/数据包]实现了基于UDP协议网络程序。
  2. UDP数据报通过数据报套接字DatagramSacket发送和接收,系统不保证UDP数据报一定能够安全送到目的地,也不能确定什么时候可以抵达。
  3. DatagramPacket对象封装了UDP数据报,在数据报中包含了发送端的IP地址端口号以及接收端的IP地址和端口号。
  4. UDP协议中每个数据报都给出了完整的地址信息,因此无须建立发送方和接收方的连接

基本流程

  1. 核心的两个类/对象DatagrarnSocket与DatagramPacket
  2. 建立发送端,接收端(没有服务端和客户端概念)
  3. 发送数据前,建立数据报 DatagramPacket对象
  4. 调用DatagramSocket的发送、接收方法
  5. 关闭DatagramSocket

image-20220206165814418.png

案例

  1. 编写一个接收端A,和一个发送端B
  2. 接收端A在9999端口等待接收数据(receive)
  3. 发送端B向接收端A发送数据”hello,明天吃火锅~”
  4. 接收端A接收到发送端B发送的数据,回复"好的,明天见",再退出
  5. 发送端接收回复的数据,再退出
/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-06-0:53
 * @Version 接收端A
 */
public class UDPReceiverA {
    public static void main(String[] args) throws IOException {
        //创建DatagramSocket对象-->在指定端口接收
        DatagramSocket socket = new DatagramSocket(9999);

        //创建DatagramPacket对象-->准备接收数据报
        byte[] bytes = new byte[1024];//接收数组
        DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
        System.out.println("端口A,监听9999端口,等待接收...");
        //调用 接收方法, 将通过网络传输的 DatagramPacket 对象,填充到 packet对象
        socket.receive(packet);
        //拆包显示
        int length = packet.getLength();
        byte[] data = packet.getData();
        String s = new String(data, 0, length);
        System.out.println(s);

        //创建待发送数据报,并指明接收端的地址和端口
        byte[] buf = "好的明天见".getBytes();
        packet = new DatagramPacket(buf, buf.length,
                InetAddress.getByName("192.168.200.1"), 9998);
        socket.send(packet);

        socket.close();
        System.out.println("A端退出");
    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-06-0:53
 * @Version 发送端B
 */
public class UDPSenderB {
    public static void main(String[] args) throws IOException {
        //创建DatagramSocket对象-->在指定端口接收
        DatagramSocket socket = new DatagramSocket(9998);

        //待发送数据封装到数据报
        byte[] data = "hello,明天吃火锅~".getBytes();
        //待发报中指明接收地址和端口
        DatagramPacket packet = new DatagramPacket(data, data.length,
                InetAddress.getByName("192.168.200.1"), 9999);
        socket.send(packet);

        //创建数据报准备接收
        byte[] bytes = new byte[1024];
        packet = new DatagramPacket(bytes, bytes.length);
        System.out.println("端口B,监听9998端口,等待接收...");
        //调用接收方法填充数据报
        socket.receive(packet);
        //拆包显示
        int length = packet.getLength();//实际接收的数据字节长度
        byte[] buf = packet.getData();//接收到的数据
        String s = new String(buf, 0, length);
        System.out.println(s);


        socket.close();
        System.out.println("B端退出");
    }
}
这篇关于[java基础] 网络编程: 域名.InetAddress类.TCP/IP的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!