6、Java SE基础-static关键字与继承

最新推荐文章于 2023-07-12 09:21:06 发布
最新推荐文章于 2023-07-12 09:21:06 发布
阅读量217 收藏 1
点赞数
分类专栏： Java 学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42749734/article/details/108762662
版权

1、static

1.1、基本概念：

  • 使用static关键字修饰成员变量表示静态的含义，此时成员变量由对象层级提升为类层级，也就是整个类只有一份并被所有对象共享，该成员变量随着类的加载准备就绪，与是否创建对象无关。

  • static关键字修饰的成员可以使用引用.的方式访问，但推荐类名.的方式。

/*
    编程实现People类的封装
 */
public class People {
	
	// 1.私有化成员变量，使用private关键字修饰
	private String name;
	private int age;
	private String country; // 隶属于对象层级，也就是每个对象都拥有独立的一份
	


}

public class PeopleTest {
	
	public static void main(String[] args) {
		
		// 1.使用有参方式构造两个People类型的对象并打印特征
		People p1 = new People("zhangfei", 30/*, "China"*/);
		p1.show(); // zhangfei 30 China
		
		People p2 = new People("guanyu", 35/*, "China"*/);
		p2.show(); // guanyu 35 China
}

在这里插入图片描述

每个对象都有自己country，这个相同的东西，可以用同一个内存，减少内存的浪费，需要用static修饰，整个类只有一个，被大家共享。（修改People类）



// 1.私有化成员变量，使用private关键字修饰
	private String name;
	private int age;
	//private String country; // 隶属于对象层级，也就是每个对象都拥有独立的一份
	//public static String country; // 隶属于类层级，也就是整个类只有一份并且被所有对象共享
	private static String country;
}

在这里插入图片描述
完整代码：

public class People {
	
	// 1.私有化成员变量，使用private关键字修饰
	private String name;
	private int age;
	//private String country; // 隶属于对象层级，也就是每个对象都拥有独立的一份
	//public static String country; // 隶属于类层级，也就是整个类只有一份并且被所有对象共享
	private static String country;
	
	// 3.在构造方法中调用set方法进行合理值的判断
	public People() {}
	public People(String name, int age/*, String country*/) {
		setName(name);
		setAge(age);
		//setCountry(country);
	}
	
	// 2.提供公有的get和set方法，并在方法体中进行合理值的判断
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age > 0 && age < 150) {
			this.age = age;
		} else {
			System.out.println("年龄不合理哦！！！");
		}
	}
	public static String getCountry() {
		return country;
	}
	public static void setCountry(String country) {
		//this.country = country;
		People.country = country;
	}
	
	public void show() {
		System.out.println("我是" + getName() + "，今年" + getAge() + "岁了，来自" + getCountry());
	}
}

/*
    编程实现People类的测试
 */
public class PeopleTest {
	
	public static void main(String[] args) {
		
		// 3.验证static关键字修饰的静态成员(类成员)是否与创建对象无关  类名.的方式 => 无关
		//System.out.println("获取到的国籍信息是：" + People.country); // null
		System.out.println("获取到的国籍信息是：" + People.getCountry()); // null
		
		// 1.使用有参方式构造两个People类型的对象并打印特征
		People p1 = new People("zhangfei", 30/*, "China"*/);
		p1.show(); // zhangfei 30 China
		
		People p2 = new People("guanyu", 35/*, "China"*/);
		p2.show(); // guanyu 35 China

		System.out.println("--------------------------------------------");
		// 2.验证static关键字修饰的静态成员(类成员) 是否被所有对象共享  => 共享
		//p1.country = "蜀国";
		p1.setCountry("蜀国");
		//System.out.println("第一个对象的国籍是：" + p1.country); // 蜀国
		//System.out.println("第二个对象的国籍是：" + p2.country); // 蜀国
		System.out.println("第一个对象的国籍是：" + p1.getCountry()); // 蜀国
		System.out.println("第二个对象的国籍是：" + p2.getCountry()); // 蜀国
		
		People p3 = new People();
		//System.out.println("第三个对象的国籍是：" + p3.country); // 蜀国
		System.out.println("第三个对象的国籍是：" + p3.getCountry()); // 蜀国
	}
}

1.2、static的使用：

  • 在非静态成员方法中既能访问非静态的成员又能访问静态的成员。

（成员：成员变量 + 成员方法， 静态成员被所有对象共享）

  • 在静态成员方法中只能访问静态成员不能访问非静态成员。

（成员：成员变量 + 成员方法， 因为此时可能还没有创建对象）

  • 在以后的开发中只有隶属于类层级并被所有对象共享的内容才可以使用
    （关键字修饰。不能滥用static关键字）
public class StaticTest {
	
	private int cnt = 1; // 隶属于对象层级，也就是每个对象都拥有独立的一份
	private static int snt = 2; // 隶属于类层级，也就是所有对象都共享同一份
	
	// 自定义非静态的成员方法  需要使用引用.的方式访问
	public void show() {
		System.out.println("cnt = " + this.cnt); // 1
		System.out.println("snt = " + this.snt); // 2  静态成员被所有对象共享，this关键字可以省略
	}
	
	// 自定义静态的成员方法 推荐使用类名.的方式访问
	public static void test() {
		// StaticTest st = new StaticTest();
		//System.out.println("cnt = " + cnt); // 1   静态成员方法中没有this关键字，因为是可以通过类名.方式调用的
		System.out.println("snt = " + snt); // 2 
	}

	public static void main(String[] args) {
			
			StaticTest st = new StaticTest();
			st.show();
			
			System.out.println("--------------------------------");
			StaticTest.test();

	}
}

1.3、构造块和静态代码块

  • 构造块：在类体中直接使用 { } 括起来的代码块。

  • 每创建一个对象都会执行一次构造块。

  • 静态代码块：使用static关键字修饰的构造块。

  • 静态代码块随着类加载时执行一次。 （静态代码块会随着类的加载而准备就绪，会先于构造块执行）

  • 静态代码块先于构造块执行，构造块先于构造体之前执行

public class BlockTest {
	
	// 当需要在执行构造方法体之前做一些准备工作时，则将准备工作的相关代码写在构造块中即可，比如：对成员变量进行的统一初始化操作
	{
		System.out.println("构造块！"); // (2)
	}
	
	// 静态代码块会随着类的加载而准备就绪，会先于构造块执行
	// 当需要在执行代码块之前随着类的加载做一些准备工作时，则编写代码到静态代码块中，比如：加载数据库的驱动包等
	static {
		System.out.println("#####################静态代码块！");   // (1)
	}
	
	// 自定义构造方法
	public BlockTest() {
		System.out.println("====构造方法体！"); // (3)
	}
	
	public static void main(String[] args) {
		
		BlockTest bt = new BlockTest();
		
		
		BlockTest bt2 = new BlockTest();
	}
}

1.4、main方法详解

在这里插入图片描述

public class MainTest {
	
	public static void main(String[] args) {
		
		System.out.println("参数数组中元素的个数是：" + args.length);
		System.out.println("传递给main方法的实际参数为：");
		for(int i = 0; i < args.length; i++) {
			System.out.println("下标为" + i + "的形参变量数值为：" + args[i]);
		}
	}
}

重点案例：单例设计模式

1、单例设计模式的概念：

  • 在某些特殊场合中，一个类对外提供且只提供一个对象时，这样的类叫做单例类，而设计单例的流程和思想叫做单例设计模式。

2、单例设计模式的实现流程：

· 私有化构造方法，使用private关键字修饰。

· 声明本类类型的引用指向本类类型的对象，并使用private static关键字共同修饰。

· 提供公有的get方法负责将对象返回出去，并使用private static关键字共同修饰

3、单例设计模式的实现方式：

· 单例设计模式的实现方式有两种：饿汉式 和 懒汉式，在以后的开发中推荐饿汉式。

  • 编程实现Singleton类的封装。

  • 编程实现SingletonTest类对Singleton类进行测试，要求main方法中能得到且只能得到该类的一个对象。

public class Singleton {
	
	// 2.声明本类类型的引用指向本类类型的对象，使用private static关键字共同修饰
	//private static Singleton sin = new Singleton();  // 饿汉式
	private static Singleton sin = null;               // 懒汉式
	
	// 1.私有化构造方法，使用private关键字修饰
	private Singleton() {}
	
	// 3.提供公有的get方法负责将对象返回出去，使用public static关键字共同修饰
	public static Singleton getInstance() {
		//return sin;
		if(null == sin) {
			sin = new Singleton();
		}
		return sin;
	}
}

public class SingletonTest {
	
	public static void main(String[] args) {
		
		// 1.声明Singleton类型的引用指向该类型的对象
		//Singleton s1 = new Singleton();
		//Singleton s2 = new Singleton();
		//System.out.println(s1 == s2); // 比较变量s1的数值是否与变量s2的数值相等  false
		//Singleton.sin = null;  可以使得引用变量无效
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println(s1 == s2); // true
	}
}
  • sin用static修饰后就隶属于类层级，也就是整个类只有一份并且被所有对象共享；
  • 加private后私有化，防止通过类名.引用（Singleton.sin = null;）
  • 私有化后不能调用，通过公有的get方法返回值（唯一出口）
  • 整个sin加载在方法里

在这里插入图片描述

2、继承

继承的概念：
当多个类之间有相同的特征和行为时，可以将相同的内容提取出来组成 一个公共类，让多个类吸收公共类中已有特征和行为而在多个类型只需
要编写自己独有特征和行为的机制，叫做继承。

在java语言中使用extends(扩展)关键字来表示继承关系。

如：public class Worker extends Person{} -表示Worker类继承自Person类

–其中Person类叫做超类、父类、基类。

–其中Worker类叫做派生类、子类、孩子类。

· 使用继承提高了代码的复用性，可维护性及扩展性，是多态的前提条件。

public class Worker extends Person {
	
}

2.1、继承的特点

  • 子类不能继承父类的构造方法和私有方法，但私有成员变量可以被继承只是不能直接访问。

  • 无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法，来初始化从父类中继承的成员变量，相当于在构造方法的第一行增加代码super()的效果。

  • · 使用继承必须满足逻辑关系：子类is a 父类，也就是不能滥用继承。

  • 语言中只支持单继承不支持多继承，也就是说一个子类只能有一个父类，但一个父类可以有多个子类。

Person

public class Person {
	
	// 1.私有化成员变量，使用private关键字修饰
	private String name;
	private int age;
	//private boolean gender; // 性别
	
	// 3.在构造方法中调用set方法进行合理值的判断
	public Person() {
		System.out.println("Person()");
	}
	public Person(String name, int age) {
		System.out.println("Person(String, int)");
		setName(name);
		setAge(age);
	}
	
	// 2.提供公有的get和set方法并在方法体中进行合理值的判断
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age > 0 && age < 150) {
			this.age = age;
		} else {
			System.out.println("年龄不合理哦！！！");
		}
	}
	
	// 自定义成员方法实现特征的打印
	public void show() {
		System.out.println("我是" + getName() + "，今年" + getAge() + "岁了！");
	}
	// 自定义成员方法描述吃饭的行为
	public void eat(String food) {
		System.out.println(food + "真好吃！");
	}
	// 自定义成员方法描述娱乐的行为
	public void play(String game) {
		System.out.println(game + "真好玩！");
	}
}

Work类继承Person

public class Worker extends Person {
	
	private int salary;
	
	public Worker() {
		super(); // 表示调用父类的无参构造方法，若没有加则编译器自动添加
		System.out.println("Worker()");
	}
	public Worker(String name, int age, int salary) {
		super(name, age); // 表示调用父类的有参构造方法
		System.out.println("Worker(String, int, int)");
		//setName(name);
		//setAge(age);
		setSalary(salary);
	}
	
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		if(salary >= 2200) {
			this.salary = salary;
		} else {
			System.out.println("薪水不合理哦！！！");
		}
	}
	
	// 自定义成员方法描述工作的行为
	public void work() {
		System.out.println("今天的砖头有点烫手...");
	}
	// 自定义show方法覆盖从父类中继承的版本
	@Override  // 标注/注解，用于说明下面的方法是对父类方法的重写，若没有构成重写则编译报错
	public void show() {
		super.show(); // 表示调用父类的show方法
		System.out.println("我的薪水是：" + getSalary());
	}
}

WorkTest测试

在这里插入图片描述

public class WorkerTest {
	
	public static void main(String[] args) {
		
		// 1.使用无参方式构造Worker类型的对象并打印特征
		Worker w1 = new Worker();
		// 当子类重写show方法后，则下面调用的是重写以后的版本
		w1.show(); // null  0
		
		System.out.println("----------------------------------");
		// 2.使用有参方式构造Worker类型的对象并打印特征
		Worker w2 = new Worker("zhangfei", 30, 3000);
		w2.show(); // zhangfei ...
		// 调用成员方法测试
		w2.eat("豆芽");
		w2.play("王者荣耀");
		w2.work();
	}
}

2.2、方法的重写

从父类中继承下来的方法不满足子类的需求时，就需要在子类中重新写一个和父类一样的方法来覆盖从父类中继承下来的版本，该方式就叫做方法的重写（Override）。

方法重写的原则

  • 要求方法名相同、参数列表相同以及返回值类型相同，从Java5开始允许返回子类类型。
//要求返回类型一致（Person）

//父类
public Person show(){}

//子类
public Person show(){}

//java5后面就可以不一样，可以返回子类类型

//父类
public Person show(){}

//子类
public Work show(){}

  • 要求方法的访问权限不能变小，可以相同或者变大。子类对父类的扩展，大等于（public>private）

  • 要求方法不能抛出更大的异常异常机制。

方法重写的步骤：

1、@Override注释

2、调用父类的方法，用super.show()

public class Person {
	

	public void show() {
			System.out.println("我是" + getName() + "，今年" + getAge() + "岁了！");

	}
}

public class Worker extends Person {

	// 自定义show方法覆盖从父类中继承的版本
	@Override  // 标注/注解，用于说明下面的方法是对父类方法的重写，若没有构成重写则编译报错
	public void show() {
		super.show(); // 表示调用父类的show方法
		System.out.println("我的薪水是：" + getSalary());
	}

}

2.3、构造块和静态代码块的考点

  • 先执行父类的静态代码块，再执行子类的静态代码块。

  • 执行父类的构造块，执行父类的构造方法体。

  • 执行子类的构造块，执行子类的构造方法体。

package com.lagou.task08;

import java.sql.SQLOutput;

public class SuperTest {

    {
        System.out.println("SuperTest类中的构造块！"); // (2)      c
    }

    static {
        System.out.println("SuperTest类中的静态代码块！"); // (1)    a
    }

    public SuperTest() {
        System.out.println("SuperTest类中的构造方法体！"); // (3)    d
    }

    public static void main(String[] args) {

        // 使用无参方式构造对象
        SuperTest st = new SuperTest();
    }
}


package com.lagou.task08;

// 导入java目录中lang目录中System类中的静态成员out  很少使用
import static java.lang.System.out;

public class SubSuperTest extends SuperTest {

    {
        System.out.println("==========SubSuperTest类中的构造块！"); // (2)      e
    }

    static {
        System.out.println("==========SubSuperTest类中的静态代码块！"); // (1)   b
    }

    public SubSuperTest() {
        //System.out.println("==========SubSuperTest类中的构造方法体！"); // (3)  f
        out.println("==========SubSuperTest类中的构造方法体！");
    }

    public static void main(String[] args) {

        // 使用无参方式构造子类的对象
        SubSuperTest sst = new SubSuperTest();
    }
}

在这里插入图片描述

2.4、常用的访问控制符

  • public修饰的成员可以在任意位置使用。

  • private修饰的成员只能在本类内部使用。

  • 通常情况下，成员方法都使用public关键字修饰，成员变量都使用private关键字修饰。

在这里插入图片描述

2.5、final

基本概念
final本意为“最终的、不可改变的”，可以修饰类、成员方法以及成员变量。

使用方式

  • final关键字修饰类体现在该类不能被继承。
    -主要用于防止滥用继承，如：java.lang.String类等。

  • final关键字修饰成员方法体现在该方法不能被重写但可以被继承。

 -主要用于防止不经意间造成重写，如：java.textDateformat类中的format方法等。

  • final关键字修饰成员变量体现在该变量必须初始化且不能改变。

    -主要用于防止不经意间造成改变，如：java.lang.Thread类中MAX_PRIORITY等。

public /*final*/ class FinalClass {

    public final void show() {
        System.out.println("FinalClass类中的show方法！");
    }

}

public class SubFinalClass extends FinalClass {

    /*@Override
    public void show() {
        super.show();
    }*/

    public static void main(String[] args) {
        SubFinalClass sfc = new SubFinalClass();
        sfc.show();
    }
}


public class FinalMemberTest {
//    private final int cnt = 1; // 显式初始化
    private final int cnt;

    /*{
        cnt = 2;  // 构造块中进行初始化
    }*/

    public FinalMemberTest() {
        cnt = 3; // 构造方法体中进行初始化
    }

    public static void main(String[] args) {

        // 声明FinalMemberTest类型的引用指向该类的对象
        FinalMemberTest fmt = new FinalMemberTest();
        // 打印成员变量的数值
        System.out.println("fmt.cnt = " + fmt.cnt); // 0  1  2  3
    }
}
微毂
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java零基础-static关键字.md
08-10
建议通过阅读相关的Java教材或搜索资料，进一步扩展学习与static关键字相关的高级主题，如静态代码块、静态内部类和静态导入等内容。 如有疑问，可以参考Java官方文档或向技术论坛寻求帮助，进一步加深对static...
JavaOOP-04-static关键字笔记.pdf
07-27
java中的static关键字的作用及应用场景
java 创建对象的内存图解 （通俗易懂)
Cyan_RA9的博客
01-02 2977
Java 内存图解篇之创建对象的内存图解，非常详细，适合初学者！
浅谈Java对象的内存分配
codergp的博客
06-21 192
看完上面的两个TIP我们就可以说说对象在堆中的分配了，大多数情况，对象是在新生代的Eden区分配的，当Eden区放满时会触发minor gc ,剩余存活的对象则会被挪到survior区 survior区分为 s1 , s2 区 首先会挪到s1区 ，当再次发生minor gc时 会清空 Eden 和 s1 将存活的对象挪动到 ，s2区，如果 survior区装不下，那么会提前挪动到老年代中。：分析对象的动态作用域，当一个对象在方法中被定义后，它可能被外部方法所引用，那么这种对象就不适合栈上分配。
java对象的内存分配
lilshork的博客
07-19 541
java对象的内存分配
java对象内存分配
w_hname的博客
11-10 841
众所周知，java对象对象创建分配的地方在堆上，但是jdk8，java对象可以分配在栈上。在栈上为对象分配内存具有一定的条件性，即在栈上对象的生命周期可以随着方法移除栈而死亡才能将对象放入到栈上。
Java继承和多态
CodeBlues的博客
08-02 186
一、继承 1、什么是继承，继承的作用是什么？ 在父类中只定义一些通用的属性和方法，子类可以继承父类的特征和行为，使得子类具有父类的各种属性和方法（例如儿子继承父亲财产）。子类可以重写父类的方法，也可以自己重新定义特有的行为和属性。 继承的作用：提高了代码的复用性，避免重复代码的出现。 继承的基本语法： class 子类 extends 父类{ } //父类的构造方法不可以被继承 特点： ①在继承关系中，父类和子类需要满足 is a 的关系。 ②父类具有子类通用的特征和行为，而子类除了具.
Java面向对象（高级）- static关键字的使用
最新发布
11-16
Java面向对象（高级）-- static关键字的使用
Java并发--final关键字.docx
06-26
在Java中变量可以分为成员变量和局部变量 成员变量 通常每个类中成员变量可以分为 类变量（static修饰的变量） 以及 实例变量 针对这两种类型的变量赋初始值的时机是不同的。 类变量可以再声明变量的时候直接赋...
Java static关键字详细介绍与用法总结
08-30
主要介绍了Java中static关键字的作用和用法详细介绍,主要讲了静态方法、静态变量、静态类、static和final一块用等内容。需要的朋友可以参考下
JAVA基础 —— 面向对象内存图
hdakj22的博客
02-17 680
java面向对象内存图 包括：一个或多个变量，基本数据类型和引用数据类型、this关键字以及成员变量和局部变量
jvm专讲之对象创建和内存分配机制
落雪
07-12 622
本章对java的创建过程以及对象的内存分配机制进行详解
Java中对象几种类型的内存分配（JVM对象储存机制）
yinying293的博客
01-15 826
Java中对象的3种类型的内存分配
图文详解Java对象内存布局
04-03 934
作为一名Java程序员，我们在日常工作中使用这款面向对象的编程语言时，做的最频繁的操作大概就是去创建一个个的对象了。对象的创建方式虽然有很多，可以通过new、反射、clone、反序列化等不同方式来创建，但最终使用时对象都要被放到内存中，那么你知道在内存中的java对象是由哪些部分组成、又是怎么存储的吗？ 本文将基于代码进行实例测试，详细探讨对象在内存中的组成结构。全文目录结构如下： 文章目录1、对象内存结构概述2、JOL 工具简介3、对象头3.1 Mark Word 标记字3.1.1 锁升级3.1.2 其他
Java对象内存分配流程
小小张自由—>张有博
08-10 2828
Java对象内存分配流程
Java对象的分配和内存布局
Minor的Java技术博客
06-27 575
当JVM执行到执行时(new、克隆、反序列化等)，先去常量池中是否能定位到该类的，并检查该符号引用对应的类是否已经加载并解析完成，如果没有则进入类加载流程。因为如果类还没有加载，那么此时分配类对应的对象是没有任何意义的，对象的所有信息都要来自于Class。因为对象的实际内存大小在类加载阶段早已确定，所以分配内存空间这个流程就是在堆内存中开辟一个确定好大小的地址空间；但是分配内存这个阶段有2个问题需要解决：如何分配？并发安全问题如何保障？如果堆内存时绝对整齐的，所有的使用和未使用的内存是划分开来，将一个地址指
Java进阶知识体系_static关键字和继承
weixin_41300542的博客
05-05 142
Java进阶知识体系 （一）、类和对象 （二）、方法和封装 （三）、static关键字和继承 （四）、多态 （五）、特殊类 （三）、static关键字和继承 1，static关键字 基本概念 使用static关键字修饰成员变量表示静态的含义，此时成员变量由对象层级提升为类层级，也就是整个类只有一份并被所有对象共享，静态成员(成员变量和成员方法)随着类的加载而加载，与是否创建对象无关。 static关键字修饰的成员可以使用引用.的方式访问，但推荐类名.的方式。 使用方式 在非静态成员方法中既能访问非静态的成
public static final什么意思？
热门推荐
handsome1_的博客
05-20 1万+
public static final :全局常量 static是为了让其成为类的成员，而不是对象的成员，这样用起来就方便了 public是为了方便访问 final则是表明这是个常量，不能修改 private的对象，然后定义get、set是为了访问控制，是一种常规的封装 综上，public static final可以让访问变得很方便，而且不会被修改。一般可以放配置信息，还有一些状态码的定义。 public interface DemoInterface{
java对象内存分配的俩种方式
sinat_38852244的博客
06-29 655
java对象内存分配
Java8基础之static关键字
05-19
Java 中的 static 关键字可以用来修饰类、方法和变量，它的作用是使得这些元素成为类级别的而非实例级别的。 1. static 变量 在 Java 中，每个实例都会拥有一份自己的成员变量，而 static 变量则是属于整个类的，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值