JavaSE-网络编程总结

最新推荐文章于 2024-07-18 19:18:20 发布
最新推荐文章于 2024-07-18 19:18:20 发布
阅读量96 收藏
点赞数
分类专栏： JavaSE 文章标签： 网络 socket java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48450385/article/details/109441930
版权

文章目录


1. InetAddress类

  1. InetAddress类表示Internet协议地址，其常用方法有：

    // 获取：主机名/主机IP；主机名称可以是机器名称，也可以是IP地址
static InetAddress getByName(String host)
// 获取：主机名
String getHostName()
// 获取：主机IP
String getHostAddress()

  2. 127.0.0.1是回送地址，即localhost，指本地机，一般用来测试使用。

  3. InetAddress使用示例：

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

public class InetAddressTest {
    public static void main(String[] args) throws UnknownHostException {
        InetAddress localhost = InetAddress.getByName("127.0.0.1");
        String hostName = localhost.getHostName();
        String hostAddress = localhost.getHostAddress();
        System.out.println(localhost);
        System.out.println(hostName);
        System.out.println(hostAddress);
        /**
         * 运行结果：
         * www.liu2m.com/127.0.0.1
         * www.liu2m.com
         * 127.0.0.1
         */
    }
}

2. UDP通信

  1. Java为UDP客户端和服务端提供了DatagramSocket类

  2. UDP发送数据的步骤：

    1. 创建客户端的DatagramSocket对象：new DatagramSocket()
    2. 将待发送数据打包：new DatagramPacket(byte[] buf, int length, InetAddress address, int port)
    3. 调用DatagramSocket对象的方法发送数据：send(DatagramPacket p)
    4. 关闭客户端的DatagramSocket对象：close()

  3. UDP接收数据的步骤：

    1. 创建服务端的DatagramSocket对象：new DatagramSocket(int port)
    2. 创建一个数据包来存储接收到数据：new DatagramPacket(byte[] buf, int length)
    3. 调用DatagramSocket对象的方法接收数据：receive(DatagramPacket p)
    4. 调用DatagramPacket对象的方法解析收到的数据包：getData()、getLength()
    5. 关闭服务端的DatagramSocket对象：close()

  4. UDP发送端程序示例：

    import java.io.*;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
 * UDP发送端：
 */
public class UDPClient {
    public static void main(String[] args) throws IOException {
        // 1. 创建客户端的DatagramSocket对象
        String host = "127.0.0.1";
        int port = 22361;
        DatagramSocket ds = new DatagramSocket();

        // 2. 装饰标准输入流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line;
        System.out.println("You can exit the program by typing exit");

        while ((line = br.readLine()) != null) {
            // 3. 将待发送数据打包
            DatagramPacket dp = new DatagramPacket(line.getBytes(), line.length(), InetAddress.getByName(host), port);

            // 4. 调用DatagramSocket对象的方法发送数据
            ds.send(dp);

            if ("exit".equals(line)) {
                break;
            }
        }
        ds.disconnect();
        // 5. 释放资源
        br.close();
        ds.close();
    }
}

  5. UDP接收端程序示例：

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

/**
 * UDP接收端：
 */
public class UDPServer {
    public static void main(String[] args) throws IOException {
        // 1. 创建服务端的DatagramSocket对象
        int port = 22361;
        DatagramSocket ds = new DatagramSocket(port);

        byte[] bytes = new byte[1024];
        while (true) {
            // 2. 创建一个数据包来存储接收到数据
            DatagramPacket dp = new DatagramPacket(bytes, bytes.length);

            // 3. 调用DatagramSocket对象的方法接收数据
            ds.receive(dp);

            // 4. 调用DatagramPacket对象的方法解析收到的数据包
            String data = new String(dp.getData(), 0, dp.getLength());
            System.out.println(data);

            if ("exit".equals(data)) {
                break;
            }
        }
        // 5. 释放资源
        ds.close();
    }
}

3. TCP通信

  1. Java为TCP客户端提供了Socket类；为TCP服务端提供了ServerSocket类

  2. TCP发送数据的步骤：

    1. 创建客户端的Socket对象并将其连接到服务端：new Socket(String host, int port)
    2. 获取Socket对象的输出流来写数据：getOutputStream()
    3. 关闭发送端的Socket对象：close()

  3. TCP接收数据的步骤：

    1. 创建服务端的ServerSocket对象：new ServerSocket(int port)
    2. 调用ServerSocket对象的方法监听客户端连接并返回Socket：accept()
    3. 获取Socket对象的输入流来读数据：getInputStream()
    4. 关闭accept()返回的Socket对象：close()
    5. 关闭发送端的ServerSocket对象：close()

  4. 多线程上传文件示例：TCP发送端

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

/**
 * 文件上传：TCP客户端
 * 1. 创建Socket对象并将其连接到服务端
 * 2. 使用FileInputStream读取待上传文件
 * 3. 获取Socket对象的输出流来给服务端写数据
 * 4. 禁用Socket对象的输出流；任何先前写入的数据将被发送，随后是TCP的正常连接终止序列
 * 由于read方法在检测到流的结尾或抛出异常之前会阻塞，因此客户端应给服务端一个结束标志
 * 5. 获取Socket对象的输入流来读服务端返回的数据
 * 6. 释放资源
 */
public class TCPClient {
    public static void main(String[] args) throws IOException {
        // 1. 创建客户端的Socket对象并将其连接到服务端
        String host = "127.0.0.1";
        int port = 22361;
        Socket socket = new Socket(host, port);
        // 2. 使用FileInputStream读取待上传文件
        String filePath = "D:\\upload.txt";
        FileInputStream fis = new FileInputStream(filePath);
        // 3. 获取Socket对象的输出流来写数据
        OutputStream socketOut = socket.getOutputStream();
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = fis.read(bytes)) != -1) {
            // 给服务端写数据
            socketOut.write(bytes, 0, len);
        }
        // 4. 禁用Socket对象的输出流；任何先前写入的数据将被发送，随后是TCP的正常连接终止序列
        socket.shutdownOutput();
        // 5. 获取Socket对象的输入流来读服务端返回的数据
        InputStream socketIn = socket.getInputStream();
        int receiveLen = socketIn.read(bytes);
        System.out.println(new String(bytes, 0, receiveLen));
        // 6. 释放资源
        fis.close();
        socket.close();
    }
}

  5. 多线程上传文件示例：TCP接收端

    import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 文件上传：TCP服务端
 * 1. 创建服务端的ServerSocket对象
 * 2. 调用ServerSocket对象的方法监听客户端连接并返回Socket
 * 线程完成：
 * 3. 获取Socket对象的输入流来读服务端上传的数据
 * 4. 使用FileOutputStream将读取到的文件写到磁盘
 * 5. 获取Socket对象的输出流来给服务端写回复
 * 6. 释放资源
 */
public class TCPServer {
    public static void main(String[] args) throws IOException {
        // 1. 创建服务端的ServerSocket对象
        int port = 22361;
        ServerSocket serverSocket = new ServerSocket(port);
        // 获取线程池
        ExecutorService es = Executors.newFixedThreadPool(20);
        while (true) {
            // 2. 调用ServerSocket对象的方法监听客户端连接并返回Socket
            Socket socket = serverSocket.accept();
            // 为每一个客户端提交一个线程
            es.submit(new UploadThread(socket));
        }
        // es.shutdown();
        // serverSocket.close();
    }
}

  6. 多线程上传文件示例：上传线程

    import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

/**
 * 文件上传：上传线程
 */
public class UploadThread implements Runnable {
    private Socket socket = null;

    public UploadThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            // 3. 获取Socket对象的输入流来读服务端上传的数据
            InputStream socketIn = socket.getInputStream();
            // 4. 使用FileOutputStream将读取到的文件写到磁盘
            String uploadPath = "D:\\upload\\upload_" + System.currentTimeMillis() + ".txt";
            FileOutputStream fos = new FileOutputStream(uploadPath);
            byte[] bytes = new byte[1024];
            int len = 0;
            while ((len = socketIn.read(bytes)) != -1) {
                // 给磁盘写数据
                fos.write(bytes, 0, len);
            }
            // 5. 获取Socket对象的输出流来给服务端写回复
            OutputStream socketOut = socket.getOutputStream();
            socketOut.write("Uploaded successfully".getBytes());
            // 6. 释放资源
            fos.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4. 模拟B/S服务器

  1. 服务端：

    import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 模拟B/S服务器：
 * 1. 创建服务端的ServerSocket对象
 * 2. 调用ServerSocket对象的方法监听客户端连接并返回Socket
 * 线程完成：
 * 3. 获取Socket对象的输入流
 * 装饰Socket对象的输入流
 * 读取请求的第一行
 * 在请求的第一行中分离出uri
 * 4. 获取Socket对象的输出流
 * 5. 使用FileInputStream来读取浏览器请求的文件
 * 向浏览器回复HTTP协议
 * 向浏览器回复数据
 * 6. 释放资源
 */
public class WebServer {
    public static void main(String[] args) throws IOException {
        // 1. 创建服务端的ServerSocket对象
        int port = 22361;
        ServerSocket serverSocket = new ServerSocket(port);

        // 获取线程池
        ExecutorService es = Executors.newFixedThreadPool(20);

        while (true) {
            // 2. 调用ServerSocket对象的方法监听客户端连接并返回Socket
            Socket socket = serverSocket.accept();
            // 为每一个客户端提交一个线程
            es.submit(new ResponseThread(socket));
        }
        // es.shutdown();
        // serverSocket.close();
    }
}

  2. 响应线程：

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

/**
 * 响应线程
 */
public class ResponseThread implements Runnable {
    private Socket socket;

    public ResponseThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            // 3. 获取Socket对象的输入流
            InputStream socketIn = socket.getInputStream();
            // 装饰Socket对象的输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(socketIn));
            // 读取请求的第一行
            String s = br.readLine();
            // 在请求的第一行中分离出uri
            String uri = s.split(" +")[1].substring(1);

            // 4. 获取Socket对象的输出流
            OutputStream socketOut = socket.getOutputStream();

            System.out.println(uri);
            // 5. 使用FileInputStream来读取浏览器请求的文件
            FileInputStream fis = new FileInputStream(uri);
            // 向浏览器回复HTTP协议
            socketOut.write("HTTP/1.1 200 OK\r\n".getBytes());
            socketOut.write("Content-Type:text/html\r\n".getBytes());
            socketOut.write("\r\n".getBytes());

            byte[] bytes = new byte[1024];
            int len = 0;
            while ((len = fis.read(bytes)) != -1) {
                // 向浏览器回复数据
                socketOut.write(bytes, 0, len);
            }

            // 6. 释放资源
            br.close();
            fis.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

若有错误或补充，欢迎私信

「已注销」
关注
专栏目录
JavaSE-11-面向对象编程
feng25751006的博客
03-02 765
面向对象编程一. 包1. 导入包中的类2. 静态导入3. 将类放入到包中4. 常见的系统包二. 继承背景（1）语法规则**（2）protected 关键字（3）包的访问权限控制（4）更复杂的继承关系（5）final 关键字三. 多态1. 向上转型2. 动态绑定3. 方法重写4. 理解多态5. 向下转型6. super 关键字（1）使用了 super 来调用父类的构造器（2）使用 super 来调用父类的普通方法（3）super 和 this 的区别四. 抽象类五. 接口1. 语法规则 一. 包 包 (pac
JavaSE-网络编程、正则表达式
qq_59737375的博客
04-25 812
regex：[a|e|s] result：结果就是匹配字符a、e、s三个字符，这个跟(a|e|s)有区别的，区别就是(a|e|s)匹配的是a、e、s三个字符的随意一个，三个 中的任意一个，这里|是元字符。匹配一个单词边界，也就是指单词和空格间的位置（即正则表达式的“匹配”有两种概念，一种是匹配字符，一种是匹配位置，这里的\b就是匹配位置的）。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”。例如，“\\n”匹配\n。序列“\\”匹配“\”而“\(”则匹配“(”。
JavaSE进阶--网络编程
程序员Forlan的博客
06-14 1192
本篇内容主要分享网络编程的知识，属于基础内容，说实话，这块在大部分公司中，使用很少甚至可能用不上，游戏行业、视频行业可能使用多一些，可以根据情况学习，作一个知识补充~
JAVASE总结作业----网络编程
m0_57785152的博客
08-22 361
2）端口号：计算机中应用的标号（代表一个应用程序），0-1024系统使用或保留端口，端口号占2个字节，所以有效端口0-65535.1）IP地址：唯一标识网络上的每一台计算机，两台计算机之间通信的必备要素。(1) OSI 参考模式:开放系统互连参考模型（Open System。4）注意：在通信协议相同的情况下，端口号才是唯一的。一种无连接的传输层协议，提供面向事务的简单不可靠信。一种面向连接（连接导向）的、可靠的、基于字节流。3）通信协议：通信的规则TCP，UDP。TCP 和 和 UDP 协议的区别。
黑马程序员--javaSE--网络编程基础总结
快乐小编的专栏
12-31 1203
------- android培训、java培训、期待与您交流！ ---------- 在写这篇博客之前，我先写点自己的感慨：java网络编程以前是学过的，但在今天复习总结这方面的 知识点时，还真有点力不从心，好多东西只是记得大概，所以在真正写代码时就遇见了好多问题，不说别的， 就说在写通过网络编程实现多线程上传文件时，就是因为读取文件路径的方式错误，衍生了好多的错误， 比如说conn
【JavaSE基础】09-网络编程
用编程认知世界，Just coding....
05-01 2172
JavaSE 网络 Socket，TCP/IP 网络协议和模型、UDP 等
JAVASE-医疗管理系统项目总结
最新发布
ngczx的博客
07-18 1125
比如我要修改医生信息，点击修改之后如何回显医生信息呢，因为我们每一个页面都是独立的，不是在一个类里面的，所以我们采用ThreadLocal线程来存放id，然后根据id找到这个医生，并回显数据。因为Map里面的那个key是强引用的，使用后不能自动回收，会让内存移除，我们需要手动的将loca移除内存。2.采用socket网络编程，实现统一局域网内的同学，建立一个服务端，多个医生是客户端，服务端存储和转发消息。UIconstant也是枚举类，重写了toString方法，返回了页面的URL，给FX去加载。
【JavaSE】16-网络编程
Sihang_Xie的博客
05-16 1129
十六、 网络编程 16.1 网络编程概述 网络编程的目的： 直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯。 网络编程中有两个主要的问题： 如何准确地定位网络上一台或多台主机；定位主机上的特定的应用。 找到主机后如何可靠高效地进行数据传输。 16.2 网络通信要素概述 网络编程中的两个主要问题，分别对应以下两个要素： 要素一：IP和端口号 IP ：相当于每台主机的身份证号码，是网络当中唯一定位的一台主机。 端口号：区分一台主机上不同的应用程序，哪一个应用程序来进行通信。 要
JavaSE-15 异常和异常处理机制
擦镜子的默
07-20 369
文章目录一、异常二、异常处理机制三、自定义异常 一、异常 异常是指在程序运行中出现的不期而至的各种状况，如文件找不到，网络连接失败、非法参数等 异常发生在程序运行期间，它影响正常的程序执行流程 简单分类： 检查性异常：用户错误或问题引起的异常等，程序员无法预见。例如，要打开一个不存在的文件，就会发生一个异常 运行时异常：程序运行时发生的异常，程序编译时被忽略（在IDE编程时不提示错误），在运行时发生异常 错误：错误不是异常，是脱离了程序员控制的问题。例如，当栈溢出时，一个错误就发生了，在编译时也检查不
JavaSe总结-26- 网络编程
lzhat的博客
02-12 677
26.01 网络编程概述 26.02 网络模型概述和图解 26.03 网络编程三要素概述 26.04 网络编程三要素之IP概述1 26.05 InetAddress类的概述和使用 26.06 网络编程三要素之端口 26.07 网络编程三要素之协议 26.08 Socket通信原理 26.09 UDP协议发送数据 26.10 UDP协议接收数据 26.11 UDP协议发送和接
JAVASE-基础 - 网络编程
07-30
### 知识点一：网络编程概念 网络编程是指利用编程技术实现计算机间的数据传输与交互。这种技术在现代互联网应用中极为重要，涉及到不同计算机系统间的通信与数据交换。 ### 知识点二：软件架构类型 1. **CS...
面试题总结---javaSE--适用于初学者
07-15
本文将深入解析“面试题总结---javaSE--适用于初学者”这一主题，旨在为初学者提供宝贵的复习资料。 1. **Java基础** - **数据类型**：Java分为基本数据类型（如int、char、boolean等）和引用数据类型（类、接口、...
JavaSE-基础练习题
三省的博客
11-03 3391
前言 部分练习题摘录自：Sun-Java程序员认证考试题库 部分练习题加入了自己的解析 还未整理完，待更 若有错误或补充，欢迎私信 一、Java入门 下列哪项不是JDK所包含的内容？（选一项）C A. Java编程语言 B. 工具及工具的API C. Java EE扩展API D. Java平台虚拟机 下列关于JDK、JRE和JVM的描述。哪项正确？D A. JDK中包含了JRE，JVM中包含了JRE B. JRE中包含了JDK，JDK中包含了JVM C. JRE中包含了JDK，JVM中包含了
JUnit基本使用
三省的博客
11-03 1571
1. 测试分类 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值 白盒测试：需要写代码，关注程序具体的执行流程 2. JUnit基本概念 JUnit是Java的一个单元测试框架，属于白盒测试 JUnit简单理解：可以取代main方法 JUnit属于第三方工具，需要导入jar包(如：hamcrest-core-1.3.jar、junit-4.12.jar或IDE自动添加) 3. JUnit基本使用 JUnit使用步骤： 定义一个测试类(测试用例) 定义测试方法：可以独立运行；建议：返.
JavaSE-线程总结
三省的博客
11-02 642
1. 实现线程 继承Thread类： 定义一个类MyThread继承Thread类 在MyThread类中重写run()方法 创建MyThread类的对象 调用MyThread的start方法启动线程 实现Runnable接口：无返回值 定义一个类MyRunnable实现Runnable接口 在MyRunnable类中重写run()方法 创建MyRunnable类的对象 创建Thread类的对象，把MyRunnable对象作为构造方法的参数 调用Thread的start方法启动线程 实.
JavaSE-注解总结
三省的博客
11-03 595
1. 注解基本概念 注解本质上就是一个接口，该接口默认继承Annotation接口 注解和注释的区别： 注解：JDK1.5之后的新特性，是说明程序的，给计算机看的 注释：用文字描述程序的，给程序员看的 注解作用： 编写文档：通过代码里标识的注解生成文档 代码分析：通过代码里标识的注解对代码进行分析 编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查 常见注解： @author：标识创建者 @date：标识创建日期 @Override：检测被该注解标注的方法是否是继承自父.
JavaSE-常用API总结
三省的博客
11-02 573
1.1 String jdk1.8及以前String底层使用的是char数组，jdk1.9及以后使用的是byte数组。 字符串之间使用+号连接时，系统底层会自动创建一个StringBuilder或StringBuffer对象，然后再调用其append方法完成拼接，拼接后再调用其toString方法转换为String类型。 String内容不可变，字符串创建后不能被更改，但可以被共享； Java中的所有双引号字符串，都是String类的对象； 通过new创建的字符串对象，每一次new都会申请一个内存空间，虽
JavaSE-集合总结
三省的博客
11-02 535
1. Collection Collection是所有单列集合的父接口，在Collection中定义了单列集合(List和Set)通用的一些方法，而且Collection重写了toString。 Collection接口常用方法： // 把给定的对象添加到当前集合中 public boolean add(E e); // 清空集合中所有的元素 public void clear(); // 把给定的对象在当前集合中删除 // 若有相同元素，只删除遇到的第一个 public boolean re.
JavaSE-面向对象总结
三省的博客
11-02 423
1. 封装 封装的最基本单位是对象，封装的最基本目标是“高内聚、低耦合”。通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象，我们在类中编写的方法就是对实现细节的一种封装，我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口。 2. 继承 Java是单继承 继承好处：提高了代码的复用性、维护性 继承弊端：类的耦合性增强了 继承体现的关系：is a 设计时可以抽象
javase网络编程网络模型
08-16
JavaSE网络编程采用的是基于TCP/IP协议的网络模型。这个模型包括客户端和服务器端两部分。客户端通过套接字（Socket）与服务器建立连接，服务器则监听客户端的连接请求并进行响应。 在Java中，可以使用Socket类和ServerSocket类来实现网络编程。Socket类用于建立客户端与服务器之间的通信连接，而ServerSocket类则用于创建服务器端的套接字，监听并接受客户端的连接请求。 客户端通过创建Socket对象，指定服务器的IP地址和端口号，然后通过Socket对象的方法与服务器进行通信。服务器端通过创建ServerSocket对象，指定服务器要监听的端口号，并通过accept()方法接受客户端的连接请求。一旦建立了连接，客户端和服务器端就可以通过输入流和输出流来进行数据的传输。 网络模型是基于TCP/IP协议的，因此可以使用Java的InputStream和OutputStream来进行数据的读写。客户端可以通过InputStream从服务器端接收数据，通过OutputStream向服务器端发送数据。服务器端则可以通过InputStream接收客户端发送的数据，通过OutputStream向客户端发送数据。 总结来说，JavaSE网络编程采用的是基于TCP/IP协议的网络模型，通过Socket和ServerSocket来实现客户端和服务器端之间的通信。通过InputStream和OutputStream来进行数据的读写。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [JavaSE——网络编程](https://blog.csdn.net/yzl1293346757/article/details/126192384)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [JavaSE学习——网络编程](https://blog.csdn.net/Demon_and_Angle_/article/details/126387829)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值