Java的三大特性--封装、继承、多态

最新推荐文章于 2023-02-28 11:04:23 发布
最新推荐文章于 2023-02-28 11:04:23 发布
阅读量385 收藏 1
点赞数 2
分类专栏： JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_GIA/article/details/85016060
版权

Java的三大特性

一、封装

public : 公共的。 public修饰的成员变量或者方法任何人都可以直接访问。
private ： 私有的。private修饰的成员变量或者方法只能在本类中进行直接访问。

1.封装的步骤

①使用private修饰需要被封装的属性。
②提供一个公共的方法设置或者获取该私有的成员属性。

命名规范：
set属性名();
get属性名();

注意：封装不一定要提供get和set方法，具体是要根据需求而定的。

2.规范

在现实开发中一般实体类的所有成员属性（成员变量）都要封装起来。
**实体类：**实体类就是用于描述一类 事物的就称作为实体类。

class Member{
	public	String name; //名字
	private	String sex; //性别
	public	int salary; //薪水

	//定义一个公共的方法设置sex属性
	public void setSex(String s){
		if (s.equals("男")||s.equals("女")){ //注意： 如果比较两个字符串的内容是否一致，不要使用==比较， 使用equals方法。
			sex = s;
		}else{
			//默认是男
			sex = "男";
		}
	}
	//定义一个公共的方法获取sex属性
	public String getSex(){
		return sex;
	}
	//聊天
	public void talk(){
		System.out.println(name+"聊得非常开心");
	}
}

class Demo{

	public static void main(String[] args) 
	{
		Member m = new Member();
		m.name="小红";
		m.setSex("女");
		m.salary  = 5000;
		System.out.println("姓名："+ m.name+" 性别："+ m.getSex()+" 薪水："+ m.salary);
	}
}

实例：描述一个计算器类，计算器具备操作数1，操作数2 、操作符三个公共的属性
，还具备计算的功能行为。 不能直接对操作数1，操作数2，运算符这些属性进行直接 的赋值，要封装起来。

//计算器类
class Calculator{

	private int num1; //操作数1

	private int num2;  //操作数2
 
	private	char option ; //运算符
	

	//提供公共的方法设置属性值....					
	public void initCalculator(int n1 , int n2 , char o){
		num1 = n1;
		num2 = n2;
		if(o=='+'||o=='-'||o=='*'||o=='/'){
			option = o;
		}else{
			option = '+';	
		}
	
	}


	//计算的功能
	public void calculate(){
		switch(option){
			case '+':
				System.out.println("做加法运算,结果是："+(num1+num2));
				break;
			case '-':
				System.out.println("做减法运算,结果是："+(num1-num2));
				break;
			case '*':
				System.out.println("做乘法运算,结果是："+(num1*num2));
				break;
			case '/':
				System.out.println("做除法运算,结果是："+(num1/num2));
				break;
		}
	}
}
3.封装的好处
  • 提高数据的安全性。
  • 操作简单。
  • 隐藏了实现。

二、继承

在现实生活中事物与事物之间存在的两种关系：

  • 动物和猫 整体与部分的关系 has a
  • 程序员和人 继承的关系 is a

继承：使用关键字extends。

语法格式：

class 类名1 extends 类名2{
	
}

继承要注意的事项：

  1. 千万不要为了减少重复代码而去继承，只有真正存在着继承关系的时候才去继承。
  2. 父类私有的成员不能被继承。
  3. 父类的构造函数不能被继承。
  4. 创建子类对象时默认会先调用父类无参的构造函数。
//人类 
class Person{
	
	String name;

	private	int age;

	public  Person(String name){
		this.name = name;
	}

	public Person(){
		System.out.println("Person类的构造方法被调用了....");
	}

	public void eat(){
		System.out.println(name+"在吃饭...");
	}
}

//学生类
class Student extends Person {  // Student 就称作为Person类的子类， Person类就称作为Student的父类(超类、基类)

	int num; //学号

	public Student(){
		System.out.println("Student类的构造方法被调用了....");
	}

	public void study(){
		System.out.println(name+"good good study , day day up");
	}	
}

class Demo7 
{
	public static void main(String[] args) 
	{
		Student s = new Student();
		
		/*
		s.name = "小红";
		System.out.println("名字："+ s.name);
		s.eat();
		*/
	}
}

创建子类对象时默认会先调用父类无参的构造函数的原因：
调用父类的构造方法是可以初始化从父类继承下去的属性的。

class Parent{
	
	int x = 10;
	String name;

	public Parent(String name){
		this.name = name;
		System.out.println("父类带参的构造方法");
	}

	public Parent(){
		System.out.println("父类无参的构造方法");
	}
}


class Child extends Parent{

	int x = 20;

	public Child(String name){
		super(name); //指定调用父类一个参数的构造函数。
	}

	public void print(){
		System.out.println("x1 = "+ x);
	}

}


class Demo
{
	public static void main(String[] args) 
	{
		Child c = new Child("大头儿子"); 
		System.out.println("name= "+c.name);

	}
}
super关键字

super关键字代表了父类空间的引用。

1.super关键字的作用：

  • 子父类存在着同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员。
  • 创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。

2.super关键字调用父类构造方法要注意的事项：

  • 如果在子类的构造方法上没有指定调用父类的构造方法，那么java编译器会在子类的构造方法上面加上super()语句。
  • super关键字调用父类的构造函数时，该语句必须要是子类构造函数中的第一个语句。
  • super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一个语句。

3.super关键字与this关键字的区别：

①代表的事物不一致。

  • super关键字代表的是父类空间的引用。
  • this关键字代表的是所属函数的调用者对象。

②使用前提不一致。

  • super关键字必须要有继承关系才能使用。
  • this关键字不需要存在继承关系也可使用。

③调用构造函数的区别：

  • super关键字是调用父类的构造函数。
  • this关键字是调用本类的构造函数。

demo：

class Parent{
		
	int x = 10;
	String name;

	public Parent(){
		System.out.println("父类无参的构造方法..");
	}

	public Parent(String name){
		this.name = name;
		System.out.println("父类带参的构造方法..");
	}

	public void eat(){
		System.out.println("爸爸做饭");
	}
}


class Child extends Parent{
	
	int x = 20; 
	int num;
	
	public Child(String name,int num){
		super(name); //指定调用了父类带参的构造方法...
		this(); // 调用本类无参构造方法..
		//super(); //指定调用了父类无参构造方法。。。
		System.out.println("子类带参的构造方法");
	}

	public Child(){
		System.out.println("子类无参的构造方法");
	}

	public void print(){
		System.out.println("x = " +super.x);
	}

	public void eat(){
		System.out.println("儿子吃饭");
	}
}

class Demo9 {

	public static void main(String[] args) 
	{
		Child c = new Child("小红");
	}
}
方法的重写

方法重写的前提：必须要存在继承的关系。

方法的重写：子父类出了同名的函数，这个我们就称作为方法的重写。

适用场景：父类的功能无法满足子类的需求时。

注意事项：
1.方法重写时，方法名与形参列表必须一致。
2.方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符。
3.方法重写时，子类的返回值类型必须要小于或者 等于父类的返回值类型。
4.方法重写时，子类抛出的异常类型要小于或者等于父类抛出的异常类型。

class Animal{  //大的数据类型 
}

class Fish extends Animal{  //Fish 小的数据类型。
}

class Parent{

	String name;

	public Parent(String name){
		this.name = name;
	}

	public Animal eat() throws RuntimeException {
		System.out.println(name+"做饭");
		return new Animal();
	}
}


class Child extends Parent{

	String num;
	
	public Child(String name){
		super(name);//指定调用父类带参的构造方法
	}

	//重写父类的eat方法
	public Animal eat() throws Exception{
		System.out.println("喝汤");
		System.out.println("吃肉");
		System.out.println("吃青菜");
		return new Animal();
	}
}

class Demo{

	public static void main(String[] args) 
	{
		Child c = new Child("大头儿子");
		c.eat();
	}
}
方法的重载

方法的重载：在一个类中 存在两个或者两个 以上的同名函数,称作为方法重载。

方法重载的要求：

  1. 函数名要一致。
  2. 形参列表不一致（形参的个数或形参 的类型不一致）
  3. 与返回值类型无关。
instanceof关键字

instanceof关键字的使用前提：判断的对象与指定的类别必须要存在继承或者实现的关系。

instanceof关键字的使用格式：

	对象  instanceof 类别

instanceof关键字的作用：判断一个对象是否属于指定的类别。
一般我们做强制类型转换之前都会使用该关键字先判断一把，然后再进行转换的。

class Animal{

	String name;
	String color;

	public Animal(String name, String color){
		this.name = name;
		this.color = color;
	}
}


//狗是属于动物中一种
class Dog extends Animal {

	public Dog(String name,String color){
		super(name,color); //指定调用父类两个 参数的构造函数。
	}

	public void bite(){
		System.out.println(name+"咬人!!");
	}
}

//猫也是属于动物中一种
class Cat extends  Animal{
	
	public Cat(String name,String color){
		super(name,color);
	}
	
	public void eat(){
		System.out.println(name+"吃鱼..");
	}

}

class Demo{

	public static void main(String[] args) 
	{
		Dog d = new Dog("哈士奇","白色");
		System.out.println("狗是狗类吗？"+ (d instanceof Dog));
		System.out.println("狗是动物类吗？"+ (d instanceof Animal));	
		//System.out.println("狗是猫类吗？"+ (d instanceof Cat));		// false true
		
		Animal a = new Animal("小红","黄色"); //小红是人
		System.out.println("动物都是狗吗？"+ (a instanceof Dog));
	}
}
final关键字

用法：

  1. final关键字修饰一个基本类型的变量时，该变量不能重新赋值，第一次的值为最终的。
  2. fianl关键字修饰一个引用类型变量时，该变量不能重新指向新的对象。
  3. final关键字修饰一个函数的时候，该函数不能被重写。
  4. final关键字修饰一个类的时候，该类不能被继承。
//圆形
class Circle{

	double r; //半径
	public static final double pi = 3.14; //固定不变的

	public Circle(double r){
		this.r = r;
	}

	//计算面积
	public final void getArea(){
		System.out.println("圆形的面积是："+r*r*pi);
	}
}

class Demo extends Circle
{
	
	public Demo(double r){
		super(r);
	}

	public static void main(String[] args) 
	{
		/*
		final Circle c = new Circle(4.0);
		test(c);
		*/	
		Demo c = new Demo(4.0);
		c.getArea();
	}
	
	public static void test(Circle c){
		c = new Circle(5.0);  //c变量又重新指向了新的对象。
		c.getArea();
	}

}

三、多态

1.概念

**多态：**一个对象具备多种形态。
①父类的引用类型变量指向了子类的对象
②接口的引用类型变量指向了接口实现类的对象

**多态的前提：**必须存在继承或者实现关系。

动物 a  = new 狗();
2.多态要注意的细节：
  1. 多态情况下，子父类存在同名的成员变量时，访问的是父类的成员变量。
  2. 多态情况下，子父类存在同名的非静态的成员函数时，访问的是子类的成员函数。
  3. 多态情况下，子父类存在同名的静态的成员函数时，访问的是父类的成员函数。
  4. 多态情况下，不能访问子类特有的成员。

总结：多态情况下，子父类存在同名的成员时，访问的都是父类的成员，除了在同名非静态函数时才是访问子类的。

注意：java编译器在编译的时候，会检查引用类型变量所属的类是否具备指定的成员，如果不具备马上编译报错。（编译看左边）

//动物类
abstract class Animal{

	String name;
	String  color = "动物色";

	public Animal(String name){
		this.name = name;
	}

	public abstract void run();

	public static void eat(){
		System.out.println("动物在吃..");
	}

}

//老鼠
class  Mouse extends Animal{

	String color = "黑色";

	public Mouse(String name){
		super(name);
	}
	
	public  void run(){
		System.out.println(name+"在大街上窜");
	}

	public static void eat(){
		System.out.println("老鼠在偷吃..");
	}

	//老鼠特有方法---打洞
	public void dig(){
		System.out.println("老鼠在打洞..");
	}
}

class Fish extends Animal {

	public Fish(String name){
		super(name);
	}
	
	public  void run(){
		System.out.println(name+"慢慢的游");
	}
}

class Demo
{
	public static void main(String[] args) 
	{
		/*
		Mouse m = new Mouse("老鼠");
		System.out.println(m.color);
		
		//多态： 父类的引用类型变量指向子类的对象
		*/
		Animal a = new Mouse("老鼠");
		a.dig();
		//a.eat();
	}	
}
4.多态的应用：
  1. 多态用于形参类型的时候，可以接收更多类型的数据。
  2. 多态用于返回值类型的时候，可以返回更多类型的数据。

多态的好处： 提高了代码的拓展性。

定义一个函数可以接收任意类型的图形对象，并且打印图形面积与周长。

//图形类
abstract class MyShape{

	public abstract void getArea();
	public abstract void getLength();	
}



class Circle extends MyShape{

	public static final double PI = 3.14;
	double r;

	public Circle(double r){
		this.r =r ;	
	}

	public  void getArea(){
		System.out.println("圆形的面积："+ PI*r*r);
	}

	public  void getLength(){
		System.out.println("圆形的周长："+ 2*PI*r);
	}
}


class Rect  extends MyShape{

	int width;
	int height;

	public Rect(int width , int height){
		this.width = width;
		this.height = height;
	}

	public  void getArea(){
		System.out.println("矩形的面积："+ width*height);
	}

	public  void getLength(){
		System.out.println("矩形的周长："+ 2*(width+height));
	}
}



class Demo{

	public static void main(String[] args) 
	{
		/*
		//System.out.println("Hello World!");
		Circle c = new Circle(4.0);
		print(c);

		Rect r = new Rect(3,4);
		print(r);
		*/
		MyShape m = getShape(0); //调用了使用多态的方法，定义的变量类型要与返回值类型一致。
		m.getArea();
		m.getLength();
	}

	//需求1： 定义一个函数可以接收任意类型的图形对象，并且打印图形面积与周长。
	public static void print(MyShape s){ // MyShpe s = new Circle(4.0);
		s.getArea();
		s.getLength();
	}
	// 需求2： 定义一个函数可以返回任意类型的图形对象。
	public static MyShape  getShape(int i){
		if (i==0){
			return new Circle(4.0);
		}else{
			return new Rect(3,4);
		}
	}
}
5.数据类型转换

目前多态情况下不能访问子类特有的成员。
如果需要访问子类特有的成员，那么需要进行类型强制转换.

①基本数据类型的转换

  • 自动类型转换：小数据类型—>大数据类型
  • 强制类型转换：大数据类型—>小数据类型 小数据类型 变量名 = （小数据类型）大数据类型;

②引用数据类型的转换

  • 自动类型转换：小数据类型—>大数据类型
  • 强制类型转换：大数据类型—>小数据类型
//动物类
abstract class Animal{

	String name;

	public Animal(String name){
		this.name = name;
	}

	public abstract void run();
}

//老鼠
class  Mouse extends Animal{

	public Mouse(String name){
		super(name);
	}
	
	public  void run(){
		System.out.println(name+"在大街上窜!");
	}

	//老鼠特有方法---打洞
	public void dig(){
		System.out.println("老鼠在打洞..");
	}
}

//鱼
class Fish extends Animal{

	public Fish(String name){
		super(name);
	}

	public  void run(){
		System.out.println(name+"在水里慢慢的游!");
	}

	//吹泡泡
	public void bubble(){
		System.out.println(name+"吹泡泡...!");
	}

}

class Demo2 
{
	public static void main(String[] args) 
	{
		/*
		Animal a = new Mouse("老鼠");  //多态
		//调用子类特有的方法
		Mouse m  = (Mouse)a;  //强制类型转换
		m.dig();
		*/

		Mouse m = new Mouse("米老鼠");
		Fish f = new Fish("草鱼");

		print(f);

	}

	//需求： 定义一个函数可以接收任意类型的动物对象，在函数内部要调用到动物特有的方法。
	public static void print(Animal a){ // Animal a   = new Mouse("米老鼠");
		if(a instanceof Fish){
			Fish f = (Fish)a;
			f.bubble();
		}else if(a instanceof Mouse){
			Mouse m = (Mouse)a;
			m.dig();
		}
	}

}

多态： 父类的引用类型变量指向了子类的对象或者是接口类型的引用类型变量指向了接口实现类的对象。

实现关系下的多态：

接口  变量  = new  接口实现类的对象。

Demo:

interface Dao{  //接口的方法全部都是非静态的方法。
	public void add();
	public void delete();
}

//接口的实现类
class UserDao implements Dao{
	
	public void add(){
		System.out.println("添加员工成功！！");
	}

	public void delete(){
		System.out.println("删除员工成功！！");
	}

}

class Demo
{
	public static void main(String[] args) 
	{
		//实现关系下的多态
		Dao d = new UserDao(); //接口的引用类型变量指向了接口实现类的对象。
		d.add();
	}
}
我可能是个假开发
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
利用java编写计算器的案例_Java对象简单实用（计算器案例）
weixin_42386819的博客
02-27 302
1 import java.util.Scanner;2 class Calculste3 {4 int a; //定义两个整数5 int b;6 String option; //定义接收操作符的字符串7 public void count(){89 //对操作符进行判断10 switch(option){11 ...
Java——一个简单的计算器程序
最新发布
weixin_66547608的博客
08-24 6589
它实现了一个简单的图形化计算器界面，并提供了一些基本的计算功能和历史记录功能。用户可以通过界面上的按钮进行输入和操作，并在文本域中显示结果和历史记录。
JAVA封装，继承，多态详解
qq_48984694的博客
07-26 3290
Java封装，继承，多态详解，带代码示例。
Java 实现计算器
万伏小太阳
02-28 4502
要求：（1）在程序中要体现面向对象编程语言的三大特征：封装、继承和多态。（2）该程序要易于扩展和复用。以后可以方便地增加新的运算；程序的业务逻辑与界面部分要实现分离，便于业务逻辑的复用。（3）使用UML类图描述程序的结构。指出你所设计的程序符合哪些设计原则。
java实验（3）Java中类的继承及其应用
m0_60472361的博客
01-09 1342
4、设计一个圆类Circle，具有属性：圆心坐标x和y及圆半径r，除具有设置及获取属性的方法外，还具有计算周长的方法perimeter()和计算面积的方法area()。再设计一个圆柱体类Cylinder，Cylinder继承自Circle，增加了属性：高度h，增加了设置和获取h的方法、计算表面积的方法area()和计算体积的方法volume()。(4)声明测试类，生成2个Student类、1个StudentXW类及1个StudentBZ类对象，并分别计算它们的评测成绩，以及互相进行总成绩的对比。
java 三大特性--封装、继承和多态理解
04-02
Java编程语言以其强大的功能和广泛的应用而闻名，其中三大特性——封装、继承和多态是其核心概念，对于理解和编写高效、可维护的代码至关重要。 **封装**是面向对象编程的基础，它涉及到将数据（属性）和操作这些...
Java面向对象三大特性，即封装、继承、多态
12-23
Java面向对象三大特性思维导图 一、封装 封装的必要性：在对象的外部为对象的属性赋值，可能存在非法数据的录入，存在不安全隐患。就目前的技术而言，并没有办法对属性的赋值加以控制。所以要实现属性的封装非常重要...
Educoder题目：Java面向对象 - 封装、继承和多态答案解析.md
11-08
Educoder题目：Java面向对象 - 封装、继承和多态答案解析
JAVA面向对象基础测试题-继承-封装-多态等测试题.docx
09-30
JAVA面向对象基础测试题-继承-封装-多态等测试题.docx
Java封装、继承、多态三大特征的理解
08-27
Java封装、继承、多态三大特征的理解 Java语言中的三大特征分别是封装、继承和多态，这三大特征是面向对象编程的核心概念，掌握这些特征是 Java 开发者必须具备的基本技能。 封装 封装是指隐藏对象的属性和实现...
JAVA基础练习题（JAVA入门到面向对象，有答案）
03-18
JAVA基础练习，填空题和选择题为主，适合新人学习
JAVA面向对象基础作业题目
qq_45045583的博客
08-23 4917
JAVA作业题目 使用java类设计一个计算器， 计算机具备操作数1,、操作数2、操作符三个属性， 还具备计算功能。 要求创建计算器对象的时候不能直接对计算器的属性赋值， 要把属性都封装起来。 请按照以下要求设计一个计算器类Calculator。 要求如下： 1） 计算器类有三个属性， 分别是操作数1(num1)、操作数2(num2)、操作符(option)。 2） 使用封装的思想将所有属性私有化，并对外界提供共有的访问getter和setter方法。 3） 计算器类中有一个计算的方法count()，用于执
JAVA小练习37——使用java类描述一个计算器，计算器具备 公共属性： 操作数1 、操作数2 、 运算符. 公共的功能：运算。要求： 计算器的属性需要封装起来，不能直接对计算器的属性赋值。
Eric_The_Red的博客
05-21 3311
class Caculator{ private int num1; private int num2; private char option; public void setNum1(int n1) { num1=n1; } public void setNum2(int n2) { num2=n2; } public void setOption(char o) { i...
java_final、抽象类、接口、多态
小鱼儿
09-03 409
/* final(最终、修饰符) final关键字的用法： 1. final关键字修饰一个基本类型的变量时，该变量不能重新赋值，第一次的值为最终的。 2. fianl关键字修饰一个引用类型变量时，该变量不能重新指向新的对象。 3. final关键字修饰一个函数的时候，该函数不能被重写。 4. final关键字修饰一个类的时候，该类不能被继承。常量 的修饰符
java基础知识17_封装
renhe0721的博客
06-16 177
面向对象三大特征： 封装 继承 多态 需求：使用java类描述百合网的会员。 问题：性别有问题？？ 根本原因：由于其他人可以直接操作sex属性，可以对sex属性进行了直接的赋值。 class Member{ String name;//姓名 String sex;//性别 int salary;//薪水 //聊天 public void tal...
Java--面向对象之封装
sophiaviayang的博客
07-13 308
/* 面向对象三大特征：     1.封装 2.继承 3.多态 需求：使用java类描述百合网会员 问题：性别有问题？？ 根本原因：由于其他人可以直接操作sex属性。可以对sex属性进行了直接的赋值。 封装：     权限修饰符：权限修饰符就是控制变量可见范围的 public：公共的。public 修饰的成员变量或者方法任何人都可以访问的
Java面向对象2(封装、继承、多态)
sunlightnn的博客
03-07 133
在学习面向对象的三大特性时也会产生一些困难，我在学习时虽然很清楚明白面向对象编程的三大特性是：封装，继承，多态。但对于书本之中的生硬的概念，确实不好理解，但多敲代码多练习一定会有新收获的，我现在可以把现阶段我理解的内容写出来，以后随时有了更深的理解也会更新。 封装 那就先说封装吧，封装就是将类的某些信息隐藏在类的内部，不允许外部程序直接进行访问，而是通过该类提供...
java面向对象计算器怎么写_Java对象简单实用案例之计算器实现代码
weixin_34730055的博客
02-24 1117
对 Java中的对象与属性，方法的使用，简单写了个案例import java.util.Scanner;class Calculste{int a; //定义两个整数int b;String option; //定义接收操作符的字符串public void count(){//对操作符进行判断switch(option){case "+":System.out.println("计算和："+a+"...
使用java面向对象创建动物类并输出动物信息
热门推荐
侯春强的博客
07-24 1万+
题目： 使用java面向对象创建动物并输出动物信息 gitup下载地址： https://github.com/benxiaohai8888/Javase/blob/master/Animal.java 代码： import java.util.Scanner; public class Animal{ private double weight;//体重 private i

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值