java学习之二（方法，面向对象基础）

已于 2024-07-06 09:01:33 修改
阅读量775 收藏 11
点赞数 23
文章标签： java 学习 开发语言
于 2024-05-24 21:31:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xifurui/article/details/137886182
版权

方法

  • 简单的方法

  • 方法的好处

    • 提高代码的复用性

  • 方法的概述：

    • 方法是实现特定功能的代码块
    •  一段具有独立功能的代码块，需要先定义才能调用
    • 如果没有调用，方法不会自动运行

  • 方法定义格式：

    •  public static void 方法名(){  方法体  }

  •     方法调用格式:

    • 方法名();

    方法与方法之间的关系:
        平级关系，所以不能嵌套定义

package ithema.day01;
public class Demo01 {
    public static void main(String[] args) {
        //调用方法
        eat();

        //调用方法
        study();

    }
    //定义方法
    public static void study(){
        System.out.println("学生在敲代码");
    }
    //定义方法
    public static void eat(){
        System.out.println("学生在吃饭");
    }
}

练习1

package ithema.day01;
/*
* 案例：方法练习（输出最大值）
*       定义方法，方法中定义两个变量，判断较大值并比较
*       调用方法查看结果
*
* */

public class Demo02 {
    public static void main(String[] args) {
        getMax();
    }
    public static void getMax(){
        int a=10;
        int b=20;
        if(a>b){
            System.out.println("max:"+a);
        }else if(b>a){
            System.out.println("max:"+b);
        }else{
            System.out.println("相等");
        }
    }
}

  • 含参数的方法

package ithema.day01;
/*
* 案例：方法练习（输出最大值）
*       定义方法，方法中定义两个变量，判断较大值并比较
*       调用方法查看结果
*
* */

public class Demo02 {
    public static void main(String[] args) {
        getMax(10,20);
        getMax(100,20);
    }
    public static void getMax(int a, int b){
//        int a=10;
//        int b=20;
        if(a>b){
            System.out.println("max:"+a);
        }else if(b>a){
            System.out.println("max:"+b);
        }else{
            System.out.println("相等");
        }
    }
}

  • 形参和实参

形参：方法定义中的参数，作用是接收实参

实参：方法调用中的参数，本质是参与操作的数据

练习A

package ithema.day01;

import java.util.Scanner;

/*
* 需求：
*       定义方法，接受三个整数，获取中间值并打印
*       通过键盘录入三个整数，作为参数传递，调用方法查看结果
*
* */
public class A {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
        getMid(a, b, c);
    }
    //1.定义方法
    public static void getMid(int a, int b, int c){
        //2.获取接受的是哪个整数中间值，并打印
        //三元运算符
        //先判断布尔表达式的结果,如果结果为true三元表达式的结果就是表达式1的值,否则就是表达式2的值。
        //因为肯定会有一个结果。所以我们在使用的时候需要把这个结果使用(用变量保存，打印等)起来。不然就没有意义。
        int max = (a>b?a:b) >c ? (a>b?a:b):c;
        int min =(a<b?a:b) < c ? (a<b?a:b):c;
        int mid =(a+b+c)-(max + min );
        System.out.println("中间值"+mid);
    }
}

  • 带返回值的方法的定义和调用

方法定义

  • 格式

        public static 数据类型 方法名（参数）{return 数据；}

  • 范例1

        public static boolean isEvenNumber(int number){return ture;}

  • 范例2

        publliic static int getMax(int a,int b){return 100;}

  • 注意

方法定义时return后面的返回值与方法定义上的数据类型必须要匹配，否则程序将报错

package ithema.day01;

public class Demo03 {
    public static void main(String[] args) {
        boolean flag =isEvenNumber(10);
        System.out.println(flag);
    }
    public static boolean isEvenNumber(int number) {
        if (number % 2 == 0) {
            return true;
        }else{
            return false;
        }
    }

}

优化练习1

public class Demo02 {
    public static void main(String[] args) {
        int max = getMax(10,20);
        System.out.println(max);
    }
    public static int getMax(int a, int b){ //void代表返回值为空

//        int a=10;
//        int b=20;
        if(a>b){
            return a;
        }else{
            return b;
        }
    }
}

  • 注意事项

b0d93f8704ad46ef9cd16f8ea21241f1.png

  • 方法通用格式

方法重载

160a4c3766bf450b8c746abb205dc47b.png

面向对象基础

  • 面向对象概述

        类是对象的抽象，对象是类的实体

  • 类和对象

    • 类：是对一类具有共同属性和行为事物的描述

    1. 属性->成员变量
    2. 行为->成员方法

    • 对象 ：根据类创建出的多个实体 

    • 对象的内存图

    1. 栈内存：方法调用进栈执行
    2. 堆内存：new出来的东西都进堆，进堆就会开辟空间产生地址值

    • 成员变量和局部变量的区别

    1. 类中位置不同 ：成员变量在类中方法外，局部变量在方法中（包括形参）
    2. 内存中的位置不同：局部变量进入栈内存，成员变量进入堆内存
    3. 生命周期不同：局部便跟随方法的调用存在，随着方法弹栈（出栈）而消失；成员变量根据对象的创建而存在，随着对象消失而消失
    4. 初始化值不同 ：成员变量有默认初始值（null，0，0.0）,局部变量没有

    • 类的定义

    • dab4728ebe90437cb2fc09917d3bb5a8.png
    • package ithema.day02;
/*
    创建对象
        格式：类名 对象名 = new 类名
        范例：Phone P =new Phone();
    使用对象
        1：使用成员变量
            格式：对象名.变量名
            范例：p.brand
        2.使用成员方法
            格式：对象名.方法名(参数)
            范例：p.call()
 */

public class PhoneDemo {
    public static void main(String[] args) {
        Phone p = new Phone();

        p.brand ="小米";
        p.price=1999;
        p.color ="白";
       /* System.out.println(p.brand);
        System.out.println(p.price);
        System.out.println(p.color);*/

        p.show();
        p.call();
        p.sendMessage();


    }
}

  • 封装

    • private关键字

        

package ithema.day02;

public class StudentTest {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student();

        //赋值
        s1.setName("张三");
        s1.setAge(18);

        //取值
        System.out.println(s1.getName());
        System.out.println(s1.getAge());

        s1.show();

    }
}

  • this关键字

    • 代表本类对象，可以调用本类成员
    • 作用：解决局部变量与成员变量重名的问题
package ithema.day02;
/*
    汽车类

    private 是一个权限修饰符，可以修饰成员，代表私有的意思
    被private修饰的成员，只能在本类中进行访问(外界不能直接使用)
    针对被private修饰的成员变量，提供get 和set方法(获取/赋值)
 */

import java.sql.SQLOutput;

public class Car {
    //成员变量:私有
    private String brand;
    private double price;
    private String color;

    //成员方法：get和set方法
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        //局部变量brand 和 成员变量 brand ,重名了！
        //由于Java遵循就近原则，这里是局部变量brand 自己给自己赋值！
        //成员变量 =局部变量；
        //this ：代表本类对象，可以调用本类对象
        this.brand = brand;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {

        this.price = price;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {

        this.color = color;
    }

    //成员方法
    public void drive() {
        System.out.println("Car driving");
    }
}

package ithema.day02;

public class CarTest {
    public static void main(String[] args) {
        //创建对象
        Car c1 = new Car();

        //打印对象名，展示地址值
        System.out.println(c1); //ithema.day02.Car@b4c966a
        /*
            ithema.day02.Car :全类名 =包名 + 类名；
            @ :分隔符
            b4c966a：十六进制的内存值
             0~9 a~f
         */
        //取值
        System.out.println(c1.getBrand());
        System.out.println(c1.getPrice());
        System.out.println(c1.getColor());

        //赋值
        c1.setColor("red");
        c1.setPrice(100);
        c1.setBrand("Toyota");

        //取值
        System.out.println(c1.getColor()+" "+c1.getPrice()+" "+c1.getBrand());

        //调用方法
        c1.drive();
    }
}

  • 封装概念

           是面向对象三大特征之一(封装，继承，多态)

           是面向对象语言对客观世界的模拟，客观世界成员变量都是隐藏在对象内部，外部是无法直接操作的          

  • 封装原则

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过对该类提供的方法来实现对隐藏信息的操作和访问

成员变量private，提供对应的getXxx()/setXxx()方法

  • 封装好处

通过方法来控制成员变量操作，提高了代码的安全性

把代码用方法进行封装，提高了代码的复用性

  • 构造方法

本质上，作用就是创建对象，借助构造方法的加载时机，完成赋值

new 类名(参数) ；// new 一次自动调用一次 

  • 空参构造

package ithema.day02;

public class Teacher {
    private String name;
    private int age;
    /*
            构造方法格式：
                public 方法法名(){

                }
            构造方法作用：创建对象    

            注意事项：
                1.方法名必须和类名一致
                2.每new一次对象，自动执行一次
     */
    public Teacher() {
        System.out.println("空参构造执行了...");
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) { //void 返回值为空
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }


}

package ithema.day02;

public class TeacherTest {
    public static void main(String[] args) {
        //创建对象
        Teacher t = new Teacher();
    }

}

  • 带参构造

package ithema.day02;

public class Teacher {
    private String name;
    private int age;
    /*
            构造方法格式：
                public 方法法名(){

                }
            构造方法作用：创建对象

            注意事项：
                1.方法名必须和类名一致
                2.每new一次对象，自动执行一次
                3.带参构造的本质，就是在创建对象的同时，完成赋值
                4.两种构造都提供，java允许方法重载

     */
    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Teacher() {
        System.out.println("空参构造执行了...");
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) { //void 返回值为空
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }


}

        

package ithema.day02;

public class TeacherTest {
    public static void main(String[] args) {
        //带参构造创建对象，并赋值
        Teacher t1 = new Teacher("张三",18);
        System.out.println(t1.getAge());
        System.out.println(t1.getName());

        //空参构造创建对象，配合set方法完成赋值

        Teacher t2 =new Teacher();
        t2.setName("李四");
        t2.setAge(18);
        System.out.println(t2.getAge());
        System.out.println(t2.getName());
    }

}

  • 构造方法的注意事项

  1. 方法名必须和类名一致
  2. 每new一次对象，自动执行一次（加载时机）
  3. 带参构造的本质，就是在创建对象的同时，完成赋值（赋所有的值）
  4.  如果我们不提供构造，系统提供一个默认的空参构造；如果我们提供带参构造，系统就不会给出空参了
  5. 结论：两种构造都写出来，java允许方法重载！

  • JavaBean 标准类

练习1

package ithema.day02.标准类;
/*
     电影测试类
        */

public class MovieTest {
    public static void main(String[] args) {
        //构造空参+set
        Movie m1 = new Movie();
        //赋值
        m1.setName("战狼");
        m1.setType("战争");
        m1.setDirector("吴京");
        //取值
        System.out.println(m1.getName()+" ,"+m1.getType()+" ,"+m1.getDirector());

        //带参构造直接赋值
        Movie m2 = new Movie("阿凡达","詹姆斯卡梅隆","科幻");
        System.out.println(m2.getName()+" ,"+m2.getType()+" ,"+m2.getDirector());


    }
}

package ithema.day02.标准类;
/*
    标准的JavaBean
        1.成员变量：必须私有，不能赋值
        2.构造方法：提供两种
        3.成员方法：针对私有的get和set方法,根据题目提供其他成员的变量

    电影类
        1.成员变量
        2.结构方法
        3.成员方法

 */

public class Movie {
    //1.成员变量：必须私有
    private String name; //名称
    private String director; //导演
    private String type; //类型

    //2.构造方法：提供两种 ->Alt +Insert -> Constructor -> 1.选择空参 2.选择带参

    public Movie() {}

    public Movie(String name, String director, String type) {
        this.name = name;
        this.director = director;
        this.type = type;
    }
    //3.成员方法：针对私有的get和set方法,根据题目提供其他成员的变量  Alt+Intsert -> Getter & Setter -> 全选


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDirector() {
        return director;
    }

    public void setDirector(String director) {
        this.director = director;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

  • 快捷键

alt + ins(insert) 快速生成

ctrl +a  全选

48479d08bb5e46cea9dc84182c3b3031.png

常用的API

  • API概述（应用程序编程接口）

    • 获取已有对象并使用

    • ab97ff8a208846b987c6011a7d743f46.png

    • 帮助文档的使用流程

      • dc9ad67049fa446faba1b85b58da042f.png

  • 包和导包

2327b2fddf6b46a3995d3ee541d323cd.png

  • String

78301095458e4eff9d362b42bc863067.png

  • Scanner键盘对象      键盘录入

  • Random随机数对象   

  • GUI

    • Graphical User Interface (图形用户接口)
    • 用图形的方式，来显示计算机操作界面

    • 使用的包

      • java.awt包 ：抽象窗口工具包，需要调用本地系统方法实现功能，属于重量级控件
      • Java.swing包：在awt系统上建立了一套图形界面系统，提供了更多的组件，而且完全由Java实现。增强了移植性，属于轻量级控件       

  • 常用的GUI组件

  • 020ee0c7e44242f3a89798a84ce4738e.png

    • JFrame

      • 是一个顶层窗口
      • 构造方法：JFrame():构造一个最初不可见的新窗体
      • 成员方法：
        • void setVisible(boolean b) :显示或隐藏此窗口具体取决于参数b的值
        • void setSize (int width,int height):调整此组件的大小，使其宽度为width,高度为hight,单位为像素

  • 字符串

    • String概述 ：java.lang.String 类代表字符串，java程序中所有字符串文字（例如"abc"）都为此类对象

    • String的注意点：字符串的内容是不会发生改变，它的对象创建后不能被更改。
    • 字符串拼接产生一个新的字符串               

    •  创建String 对象的两种方式

      • 直接赋值

      • new 
      •        4c56756bcb124d8a9c39765dfa27b797.png

    • Java常用方法（比较）  

      • ==

        • 进本数据类型 比较的是数据类型
        • 引用数据类型比较的是数据类型 

      • 字符串比较

      • boolean equals方法(要比较的字符串)
        • 完全没一样才是true，否则为false
      • boolean equalslgnoreCase(要比较的字符串)
        • 忽略大小写比较

    • 练习

      • 金额转换

        • 查表法

    • StringBuilder 

      • 可以看作一个容器，创建之后里面的内容是可以改变的
      • 作用：提高字符串效率

      • 构造方法

      • 常用方法

继承

概述

继承特点

继承成员变量访问特点

external

super

继承中成员方法访问特点

方法重写概述和应用场景

方法重写注意事项

权限修饰符

继承中构造方法的访问特点

构造方法的访问特点 - 父类没有空参构造方法

代码优化和内存图解

案例学生管理系统

扩充知识点

1.//退出当前正在运行的JVM虚拟机 System.exit(0);

环境搭建

添加实现功能

优化

查询功能的实现

删除学生功能

修改功能

系统优化

案例老师管理系统

需求说明

环境搭建

添加功能实现

抽象类

抽象类的注意事项

定义格式

模板设计模式

final关键字

代码块

接口

接口介绍

接口的定义和特点

接口总结

接口中成员的特点

jdk8中的成员变量的特点—默认方法

总结

jdk8中的成员变量的特点—静态方法

jdk9中的成员特点--私有方法

定义格式

接口使用思路

类和接口的关系

多态

多态概述

多态中成员访问特点

多态的好处和弊端

多态中的转型

多态中转型存在的风险

内部类

内部类的访问特点

局部内部类

匿名内部类

颜值癫疯
关注
  • 23
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
JAVA面向对象基础学习资料
07-09
JAVA面向对象的基础学习资料，包括了以下学习内容和代码注释： 01_成员变量和局部变量的区别 02_形式参数是类名的问题 03_匿名对象 04_封装和private关键字 05_this关键字 06_构造方法 07_成员方法 08_创建对象做了...
Java基础 面向对象入门基础知识 个人学习总结
12-21
以上就是Java面向对象编程的基础知识，包括类和对象的定义、创建和使用对象、构造方法以及静态变量和静态方法的概念。理解和掌握这些基础知识是成为Java开发者的必备条件。在实践中，不断地练习和应用这些概念，才能...
Java小白记录学习路线(java基础)—–面向对象
12-21
面向对象是Java编程的核心概念，它是对现实世界中事物的一种模拟和抽象。在Java中，面向对象编程（OOP）主要包括三个关键特性：封装、继承和多态。 1. 封装（封装/private）： 封装是面向对象编程的基础，它隐藏了...
Java面向对象编程学习笔记.pdf
12-01
Java面向对象编程学习笔记.pdf提供了Java面向对象编程的基础知识，包括类和对象、继承、多态性、封装、抽象、接口和异常处理等内容。学习这些知识点可以帮助开发者更好地理解和应用Java面向对象编程。
Java内存模型
weixin_44267758的博客
07-19 564
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
最新发布
山重水复疑无路，柳暗花明又一村。
07-20 482
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1009
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 171
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1040
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java实验2
qq_64727229的博客
07-16 534
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
每 日练 习
m0_67187271的博客
07-19 794
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 458
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
Srping Cloud - @Async注解+Feign手动设置token
qq_36782325的博客
07-16 272
在Spring cloud项目开发中，经常需要通过feign远程调用其他的服务的方法。有时因为跨服务调用的时间较长，就会存在需要异步跨服务调用的场景，此时就会出现请求头（主要是token）丢失的问题。
《简历宝典》15 - 简历中“项目经历”，实战讲解，Java篇
xingyu_qie的专栏
07-18 227
校招和初级Java开发的项目经历重点是突出自己在实战中的学习。比如对数据库的操作，比如前后端联调工作中遇到问题的解决，比如一些Java基础知识点的逐渐深入掌握，这些都是这个阶段的Java开发需要去不断增强的。和初级前端开发类似，例如你作为一名初级Java开发，负责的是校园图书管理系统的图书信息上传，图书信息管理这个模块的服务端开发，项目经历可以这样编写，如图。
python--实验14 并发编程（多线程）
wumingzei的博客
07-18 939
定义通过声明Thread的派生类，创建一个子类，并重写对象的run方法，然后创建其对象实例，可创建线程。通过对象的start方法，可启动线程，并自动执行对象的run方法。注意子类的构造器一定要先调用基类的构造器直接将线程需要做的事写到run方法中示例。
码农生涯问题杂记
qq_38189542的博客
07-18 163
Q：工作中需要测试一个JNA程序，想着Windows方便，所以就在Windows进行动态库的编译，然后在编译过程中，对应的代码在Linux系统GCC编译是成功的，但是在Windows下死活报错，而且报的错莫名其妙。A：后面经过测试，Vistual Studio在UTF8编码下，对中文支持很糟糕，导致编译的时候，语法解释出错，从而就出现一大堆乱七八糟让人摸不着头脑的错误。后面删除代码中的中文注释，编译成功。
达梦数据库 CASE_SENSITIVE参数的理解
qq_44669390的博客
07-19 809
CASE_SENSITIVE
java的基本参数类型和引用参数类型在传递的时候是否会影响实际参数呢?
Lele0456789的博客
07-19 114
/基本数据类型在传递真实的参数时,传递的是真实的数据,形参的改变,不影响实际参数的值。System.out.println("调用change方法前"+number);System.out.println("调用change方法后"+number);//传递引用数据类型的时候,传递的是地址值,形参的改变,影响实际参数的值。
Java反序列化漏洞CC2利用链注入内存马
道阻且长，行则将至。
07-20 518
本文从 0 到 1 介绍了 TemplatesImpl 链的基础原理，同时介绍其在 Fastjson 反序列化漏洞利用过程中的应用，最后介绍了 Java 反序列化漏洞 CC2 链中对 TemplatesImpl 链的集成，以及如何通过 CC2 链注入恶意类与 Java 内存马。
Java构造方法重载与面向对象基础
学习面向对象编程，理解类和对象的概念至关重要。类是对现实世界中一类事物的抽象，对象是类的实例，具有类定义的属性和方法。通过定义类，我们可以创建多个具有相同属性和行为的对象，而无需重复编写代码。 本教程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值