Java-网络编程

最新推荐文章于 2024-08-07 21:33:33 发布
最新推荐文章于 2024-08-07 21:33:33 发布
阅读量141 收藏
点赞数
分类专栏： java笔记 文章标签： java 网络 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m12245/article/details/127921832
版权

一、概述

在这里插入图片描述

  1. 计算机网络：
    计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。
  2. 网络编程的目的：
    传播交流信、数据交换、通信（无线电台）
  3. 想要达到这个效果需要什么：
    1. 如何准确的定位网络上的一台主机 ip地址：端口，定位到这个计算机上的某个资源
    2. 找到这个主机，（如何传输数据呢？）

javaweb开发：网页编程 B/S架构
网络编程： TCP/IP C/S架构

二、网络通信的要素

  1. 网络编程中有两个主要的问题：
    1. 如何准确的定位到网络上的一台或者多台主机
    2. 找到主机之后如何进行通信
  2. 网络编程中的要素：
    1. IP和端口号
    2. 网络通信协议
  3. 面向对象：万物皆对象

TCP/IP参考模型：
在这里插入图片描述
通过域名获得目标ip地址：
在这里插入图片描述

三、IP

  1. ip地址：
    1. 唯一定位一台网络上计算机
    2. 127.0.0.1：本机localhost
    3. ip地址的分类：
      1. IP地址分类：IPv4、IPv6
        1. IPV4 127.0.0.1 4个字节组成，0-255。（共42亿个，30亿都在北美，亚洲4亿，2011年就用完了）
        2. IPV6 2001:0bbb：3451：0000：… 8个无符号整数组成（0-9，a-e），128位。
      2. 公网-私网

测试ip-代码实现：

package kuangshen;

import java.net.InetAddress;
import java.net.UnknownHostException;

//测试ip
public class TestInetAddress {
    public static void main(String[] args) {
//        new InetAddress();//由于这个方法没有构造器，所以不可以直接实例化，应调用它的静态方法返回它本身
        try {
            //查询本机地址
            InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");//捕获异常
            System.out.println(inetAddress1);
            InetAddress inetAddress3 = InetAddress.getByName("localhost");
            System.out.println(inetAddress3);
            InetAddress inetAddress4 = InetAddress.getLocalHost();
            System.out.println(inetAddress4);
            ///127.0.0.1
            //localhost/127.0.0.1

            //查询网站ip地址
            InetAddress inetAddress2 = InetAddress.getByName("wwww.baidu.com");//捕获异常
            System.out.println(inetAddress2);
            //wwww.baidu.com/220.181.38.148

        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

使用套接字获取ip地址-代码实现：

package kuangshen;

import java.net.InetSocketAddress;
//使用套接字获取ip地址
public class TsetInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress socketAddress=new InetSocketAddress("127.0.0.1",8080);
        InetSocketAddress socketAddress2=new InetSocketAddress("localhost",8080);
        System.out.println(socketAddress);
        System.out.println(socketAddress2);
        System.out.println(socketAddress.getAddress());
        System.out.println(socketAddress.getHostName());//地址
        System.out.println(socketAddress.getPort());//端口
        ///127.0.0.1:8080
        //localhost/127.0.0.1:8080
        ///127.0.0.1
        //127.0.0.1
        //8080
    }
}

四、端口(PID)

  1. 端口表示计算机上的一个程序的进程；

    1. 不同的进程有不同的端口号。用来区分软件。
    2. 被规定范围：0-65535
    3. TCP，UDP：共65535*2个端口。单个协议下，端口号不能冲突(但是可以TCP:80,UDP:80)。
    4. 端口分类：
      1. 公有端口：0-1023（百度为例：HTTP：80，HTTPS：443）
      2. 程序注册端口：1024-49151，分配用户或者程序（Tomcat：8080，Mysql：3306，Oracle：1521）
      3. 动态、私有：49152-65535（举netstat为例）
        1. netstat -ano #查看所有的端口
        2. netstat -ano|findstr “5900” # | ：管道符，起过滤作用。#查看指定端口：5900
        3. tasklist|findstr “8696” #查看指定端口的进程

    端口对应-实现通信（左QQ->右QQ发信息）
    在这里插入图片描述

五、通信协议

  1. TCP/IP协议簇：实际上是一组协议
    1. 重要协议：TCP(用户传输协议)，UDP(用户数据报协议)，IP(网络互连协议)
  2. TCP和UDP对比
    1. TCP（打电话）：
      1. 需要连接、稳定
      2. 三次握手，四次挥手
        在这里插入图片描述
      3. 客户端、服务端
      4. 传输完成，释放连接，效率低
    2. UDP（发短信）：
      1. 不需要连接、不稳定
      2. 客户端、服务端：没有明确的界限
      3. 不管对方有没有准备好，都可以发送（导弹、DDOS：洪水攻击（饱和攻击））

六、TCP

知识补充：

  1. ServerSocket:点此进入
  2. write:点此进入

b – 数据
off – 在数据偏移的开始
len – 写入的字节数

客户端

  1. 连接服务器Socket
  2. 发送消息

客户端-代码实现：

package kuangshen;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

//客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {
        Socket socket =null;
        OutputStream os =null;
        try {
            //1.要知道服务器的地址，端口号
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            int port=9999;
            //2.创建一个socket连接
            socket = new Socket(serverIP,port);
            //3.发送消息IO流
            os = socket.getOutputStream();
            os.write("你好，我是客户".getBytes());

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关闭数据流
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

服务端

  1. 建立服务的端口ServerSocket
  2. 等待用户的连接accept
  3. 接收用户的消息

服务器-代码实现:

package kuangshen;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

//服务端
public class TcpServerDemo01 {
    public static void main(String[] args) {
        //提升作用域
        ServerSocket serverSocket =null;
        Socket accept =null;
        InputStream is =null;
        ByteArrayOutputStream baos=null;
        try {
            //1.我要有一个地址
            serverSocket = new ServerSocket(9999);
            //2.等待客户端连接过来
            accept = serverSocket.accept();//accept和客户端中的socket相同
            //3.读取客户端的信息
            is = accept.getInputStream();
            //管道流
            baos=new ByteArrayOutputStream();
            byte[] buffer=new byte[1024];
            int len;
            while ((len=is.read(buffer))!=-1){
                baos.write(buffer,0,len);//边读边写，不会因为读取的文件超出缓存区大小而乱码
            }
            System.out.println(baos.toString());

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源，从最后一个开始，依次关闭，关闭有顺序,正常情况下会报错，此时需要提升一下这四个方法的作用域
            //if(流!=null)不是指数据还在传输，意思是通过这个判断流有传输数据，finally时数据已经传输完毕，
            //此时数据流已经不在传输了，但功能还在，通过这个判断能够有效准确的关闭传输流。
            //捕获异常可以避免关闭流时出现的异常情况，直接抛出异常也可以消除报错，但是如果出现异常，不容易发现哪里出现异常
            if (baos!=null){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (accept!=null){
                try {
                    accept.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

案例：文件上传

服务端

代码实现：

package kuangshen;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception{
        //1.创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2.监听客户端的连接
        Socket accept = serverSocket.accept();//阻塞式监听，会一直等待客户端连接类似于Scanner方法
        //3.获取输入流
        InputStream is = accept.getInputStream();
        //4.文件输出
        FileOutputStream fis = new FileOutputStream(new File("recevice.png"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len=is.read(buffer))!=-1){
            fis.write(buffer,0,len);//从下标0开始，写入buffer数组，共写入len个字节
        }

        //通知客户端接收完毕
        OutputStream os = accept.getOutputStream();
        os.write("我接受完毕了".getBytes());//返回byte类型的数据

        //5.关闭数据流
        fis.close();
        is.close();
        accept.close();
        serverSocket.close();
    }
}

客户端

代码实现：

package kuangshen;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

public class TcpClientDemo02 {
    public static void main(String[] args) throws Exception {
        //1.创建一个Socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9000);//抛出异常即可
        //2.创建一个输出流
        OutputStream os = socket.getOutputStream();
        //3.读取文件，在这个项目下的文件可使用相对路径,但是绝对路径肯定可以找到
        FileInputStream fis = new FileInputStream(new File("C:\\...\\02.png"));
        //4.写出文件
        byte[] buffer=new byte[1024];
        int len;
        while ((len=fis.read(buffer))!=-1){
            os.write(buffer,0,len);
        }

        //通知服务器，已经结束了
        //避免的问题：服务器的read方法一直在等下一组数据，而客户端早就结束了传输，但是服务器不知道，而客户端传输完之后就关闭数据流了
        socket.shutdownOutput();//我已经传输完了

        //确定服务器接收完毕，才能断开连接
        InputStream inputStream = socket.getInputStream();
        //getByte方法，返回的是byte类型的数据
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer2=new byte[1024];
        int len2;
        while ((len2=inputStream.read(buffer2))!=-1){
            baos.write(buffer2,0,len2);
        }
        System.out.println(baos.toString());

        //5.关闭资源
        fis.close();
        os.close();
        socket.close();
    }
}

在这里插入图片描述在这里插入图片描述

Tomcat

客户端

  1. 自定义：C
  2. 浏览器：B

服务端

  1. 自定义：S
  2. Tomcat服务器：S，用于java后台开发

UDP

案例：发送消息

发送端

代码实现：

package kuangshen;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
//不需要连接接收端一样可以发送，UDP中没有服务器这个概念，两遍都是接收端，也都是发送端
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception{
        //1.创建一个Socket
        DatagramSocket socket = new DatagramSocket();
        //2.创建个包
        String msg="你好，服务器";
        //2.1发送给谁
        InetAddress localhost = InetAddress.getByName("localhost");
        int port=9090;
        //DatagramPacket(数据，数据长度的开始，数据长度的结尾，接受者的IP，端口)
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);
        //3.发送包
        socket.send(packet);
        //4.关闭流
        socket.close();
    }
}

接收端

代码实现：

package kuangshen;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
//如果要接收客户端发来的文件，还是要等待客户端的连接
public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception{
        //开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        //接收数据包
        byte[] buffer=new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);

        socket.receive(packet);//阻塞接收

        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(),0,packet.getLength()));

        //关闭连接
        socket.close();
        //127.0.0.1
        //你好，服务器
    }

案例：咨询

知识补充：

  1. 问题一：接收端，接收到bye之后不能停止接收：
    1. trim方法：用于删除字符串的头尾空白符。详细内容点此进入
    2. 引用文章一：点此进入
    3. 引用文章二：点此进入

在接收端收到消息进行equals字符串比较时，由于创建byte数组时，设置长度为1024，之后读取的字符串长度也是1024，与设置的bye字符串的长度不一致导致结果总是false。由此看出，用equals方法比较时，首先比较的是读取的字符串长度，如果其中由于包含空格、复制错误，将不能正确比较，所以此时需要使用trim方法。代码为：receiveData.trim().equals(“bye”)，此时当读取到bye时，将停止接收。

  1. 问题二：使用过BufferedReader之后，为什么不关闭：
    1. 引用文章：点此进入
  1. 直接调用最外层的close()：一个链条，关闭了最外面的->最外面的关闭里面的->里面的关闭更里面的。
  2. 看BufferedReader的close源码，它关闭的是它说装饰的Reader，而Reader的关闭方法这是直接使用close方法。
  3. 以上两点为可以直接关闭最外层的，如果都要关闭，则按照：最先创建的最后关，最后创建的最先关的顺序在finally中依次关闭。

发送端

代码实现：

package kuangshen;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class UdpSenderDemo01 {
    public static void main(String[] args) throws Exception{
        //创建一个Socket
        DatagramSocket socket = new DatagramSocket(8888);

        //准备数据：控制台读取System.in
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        while (true){
            //读取数据
            String data = reader.readLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost",6666));

            //发送数据
            socket.send(packet);
            if (data.equals("over")){
                break;
            }
        }
        socket.close();
    }
}

接收端

代码实现：

package kuangshen;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UdpReceiveDemo01 {
    public static void main(String[] args) throws Exception{
        DatagramSocket socket = new DatagramSocket(6666);

        while (true){
            //准备接收包裹
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            socket.receive(packet);//阻塞式接收包裹

            //断开连接  读取到 bye时
            byte[] data=packet.getData();
            String receiveData = new String(data, 0, data.length);

            System.out.println(receiveData);

            if (receiveData.trim().equals("bye")){
                break;
            }
        }
        socket.close();
    }
}

在线咨询：学生与教师之间相互通信

  • 两人都可以是发送方，也都可以是接收方。

TalkSend-代码实现：

package kuangshen;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class TalkSend implements Runnable {
    DatagramSocket socket =null;
    BufferedReader reader =null;

    private int fromIP;
    private String toIP;
    private int toPort;

    public TalkSend(int fromIP, String toIP, int toPort) {//负责从那里发、发到哪
        this.fromIP = fromIP;
        this.toIP = toIP;
        this.toPort = toPort;

        try {
            socket = new DatagramSocket(8888);
            //准备数据：控制台读取System.in
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {//负责发送消息

        while (true){
            //读取数据
            String data = null ;
            try {
                data = reader.readLine();
                byte[] datas = data.getBytes();
                DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress(this.toIP,this.toPort));

                //发送数据
                socket.send(packet);
                if (data.equals("over")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

TalkReceive-代码实现：

package kuangshen;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class TalkReceive implements Runnable{

    DatagramSocket socket = null;
    private int port;
    private String msgFrom;

    public TalkReceive(int port,String msgFrom) {
        this.port = port;
        this.msgFrom = msgFrom;
        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {

        while (true){
            try {
                //准备接收包裹
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);
                socket.receive(packet);
                //断开连接  读取到 bye时
                byte[] data=packet.getData();
                String receiveData = new String(data, 0, data.length);

                System.out.println(msgFrom+":"+receiveData);

                if (receiveData.trim().equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

学生端-代码实现：

package kuangshen;

public class TalkStudent {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new TalkSend(7777,"localhost",9999)).start();
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}

教师端-代码实现：

package kuangshen;

public class TalkTeacher {
    public static void main(String[] args) {
        //从端口5555发送给localhost的8888端口
        new Thread(new TalkSend(5555,"localhost",8888)).start();
        //接收端口9999，给“学生”说
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

图解：
在这里插入图片描述
补充：

  • 本代码最终运行，会提示端口被占用的错误：java.net.BindException: Address already in use: Cannot bind。解决方法：点此进入

URL

  • 统一资源定位符：用来定位资源的，定位互联网上的某一个资源
  • DNS域名解析：www.baidu.com-----》xxx.xxx.xxx.xxx…(IP地址)

基础方法-代码实现：

package kuangshen.wlbc;

import java.net.MalformedURLException;
import java.net.URL;

public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        //捕获异常（因为这个URL不存在），Tomcat端口号：8080
        URL url = new URL("http://localhost:8080/helloworld/inde.jsp?uesrname=kuangshen&password=123");
        System.out.println(url.getProtocol());//获得协议名
        System.out.println(url.getHost());//获得主机ip
        System.out.println(url.getPort());//获得端口号
        System.out.println(url.getPath());//获得文件
        System.out.println(url.getFile());//获得全路径
        System.out.println(url.getQuery());//获得url查询的名字、参数
        //http
        //localhost
        //8080
        ///helloworld/inde.jsp
        //uesrname=kuangshen&password=123
    }
}

根据URL下载网络资源-代码实现：

package kuangshen.wlbc;

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class UrlDown {
    public static void main(String[] args) throws Exception{
        //1.下载地址
        URL url = new URL("Http://nie.res.netease.com/r/pic/20210608/61039f93-a986-42bf-8da6-6b7f875c1cdf.jpg");
        //2.连接到这个资源 HTTP
        HttpURLConnection urlConnection=(HttpURLConnection) url.openConnection();

        InputStream inputStream=urlConnection.getInputStream();

        FileOutputStream fis = new FileOutputStream("yjwj.jpg");

        byte[] buffer=new byte[1024];
        int len;
        while ((len=inputStream.read(buffer))!=-1){
            fis.write(buffer,0,len);//写出这个数据
        }
        fis.close();
        inputStream.close();
        urlConnection.disconnect();//断开连接
    }
}

在这里插入图片描述步骤：F12—》网络

王婆不卖瓜z
关注
专栏目录
Java 网络编程
qq_55674489的博客
07-14 597
在前面刚学习完IO流之后，我们今天紧接着来学习Java之中的网络编程。 首先我们先了解一下什么是计算机网络
java网络编程
热门推荐
xiazdong
08-24 2万+
网络基本知识： 在java中网络程序有两种协议：TCP和UDP，TCP通过握手协议进行可靠的连接，UDP则是不可靠连接。 IP地址：用于标记一台计算机的身份证。 IP地址由网络地址（确定网络）和主机地址（网络中的主机）组成。 子网掩码：为了区分网络地址和主机地址。 IP地址分为A类地址、B类地址、C类地址（常用）、D类地址、E类地址。 127.0.0.1（localhost）是本机地址
Java - 网络编程
心如冰清，天塌不惊
08-07 901
即双方进行传输数据，得按照一定的组织形式也就是一定的规则，当对方接收的时候，才能正确读取数据信息，也才能按照相应的规则，响应你要的数据信息。在本机的9999端口监听，等待连接；中文译名为传输控制协议，网络通讯协议，这个协议是Internet最基本的协议，Internet国际互联网络的基础。到达对方的时候，就是包装好的数据(以太网帧)，之后再根据协议，逐渐拆包，得到用户数据。6.当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这个端口是TCP/IP 来分配的，是不确定的，是随机的。
java网络编程TCP，UDP简述
堂堂百星王者
10-20 736
网络编程 Java 网络编程 网络编程是指编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。 java.net 包中 J2SE 的 API 包含有类和接口，它们提供低层次的通信细节。你可以直接使用这些类和接口，来专注于解决问题，而不用关注通信细节。 java.net 包中提供了两种常见的网络协议的支持： TCP：TCP 是传输控制协议的缩写，它保障了两个应用程序之间的可靠通信。通常用于互联网协议，被称 TCP / IP。 UDP：UDP 是用户数据报协议的缩写，一个无连接的协议。提供了应用程
java进阶学习 --java网络编程一（转）
weixin_30409849的博客
09-29 191
Java - 网络编程完全总结（基础介绍） 本文主要是在网络编程方面的学习总结，先主要介绍计算机网络方面的相关内容，包括计算机网络基础，OSI参考模型，TCP/IP协议簇，常见的网络协议等等，在此基础上，主要介绍Java中的网络编程。 目录　　 一、概述 二、计算机网络 1.网络协议 2.网络体系结构 三、OSI参考模型 四、TCP/IP参考模型 五、常见网络协议...
16.java-网络编程.md
最新发布
08-18
16.java-网络编程
Java-Java网络编程教程
11-14
Java网络编程是Java开发中的重要组成部分，它允许Java应用程序通过网络进行通信，实现数据的传输。本教程将针对Java的网络编程进行详细讲解，旨在帮助Java学习者掌握这一核心技术。 一、TCP/IP基础 在Java网络编程...
java编程-socket-套接字-网络编程.docx
07-19
Socket编程是Java网络编程的核心技术之一，主要用于实现不同计算机之间的通信。通过Socket，应用程序可以在网络上发送和接收数据，实现分布式系统的构建。 #### 二、Socket编程基本概念 - **Socket**：在网络编程...
基于Java--Socket-网络编程.doc
10-10
基于Java--Socket-网络编程.doc
java-网络编程的介绍和应用
qdzjo的博客
12-08 1576
java-网络编程 1. 概述 计算机网络是通过传输介质、通信设施和网络通信协议，把分散在不同地点的计算机设备互连起来的，实现资源共享和数据传输的系统。网络编程就是编写程序使互联网的两个（或多个）设备（如计算机）之间进行数据传输。Java语言对网络编程提供了良好的支持。通过其提供的接口我们可以很方便地进行网络编程。 ​ 网络编程的目的 用来实现网络互连的不同计算机上运行的程序键可以进行数据交换 直接或间接地通过网络协议与其他计算机进行通讯 java.net包中J2SE的API包含有类和接口,它
java 网络编程
这啥玩意
03-23 399
Java 网络编程 网络通信协议 TCP/IP协议(Transmission Control Protocal/Internet Protoal 传输控制协议)：包括TCP协议、IP协议、UDP协议(User Datagram Protocol)、ICMP协议(Internet Control Message Protocol)和其他一些协议的协议组。 层次结构： TCP/IP协议分为4层结构，分...
第九章 网络编程
m0_56280646的博客
07-17 165
计算机网络把分布在不同地理区域的具有独立功能的计算机,通过通信设备与线路连接起来，由功能完善的软件实现资源共享和信息传递的系统。有人说，20世纪最伟大的发明不是计算机，而是计算机网络。还有人说，如果你买了计算机而没有联网，就等于买了电话机而没有接电话线一样。Java是Internet上的语言，它从语言级上提供了对网络应用程序的支持，程序员能够很容易开发常见的网络应用程序。Java提供的网络类库，可以实现网络连接，联网的底层细节被隐藏在Java的本机安装系统里，由JVM进行控制。。...
《JAVA 进阶： 网络编程》
yexiangCSDN的专栏
07-29 517
一、网络编程概述 Java是 Internet 上的语言，它从语言级上提供了对网络应用程序的支持，程序员能够很容易开发常见的网络应用程序。 Java提供的网络类库，可以实现无痛的网络连接，联网的底层细节被隐藏在 Java 的本机安装系统里，由 JVM 进行控制。并且 Java 实现了一个跨平台的网络库，程序员面对的是一个统一的网络编程环境。 计算机网络： 把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大、功能强的网络系统，从而使众多的计算机可以方便地互相传递信息、共享硬件、软.
Java—网络编程总结（整理版）
Swordfall的博客
05-05 263
1.概述 　　计算机网络是通过传输介质、通信设施和网络通信协议，把分散在不同地点的计算机设备互连起来的，实现资源共享和数据传输的系统。网络编程就是编写程序使互联网的两个（或多个）设备（如计算机）之间进行数据传输。Java语言对网络编程提供了良好的支持。通过其提供的接口我们可以很方便地进行网络编程。 2.网络分层 　　计算机网络20世纪60年代出现，经历了20世纪70年代、80年代和90年...
Java网络编程精解 - 孙卫琴作品
"Java网络编程，作者孙卫琴，涵盖了JDK 1.5的并发特性，详细讲解了Java在互联网编程中的应用。" 在Java网络编程中，开发者需要理解和掌握一系列关键概念和技术，以便创建能够跨网络通信的应用程序。本书《Java网络...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值