Java基础（四）（根据尚硅谷宋红康老师Java基础第四部分）（重点）

最新推荐文章于 2022-04-28 11:36:41 发布
最新推荐文章于 2022-04-28 11:36:41 发布
阅读量1k 收藏 1
点赞数
分类专栏： java基础 简单的Java题目 面向对象 文章标签： Java面向对象 宋红康
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45345128/article/details/103392747
版权

Java面向对象编程(中)

主要讲解宋老师里面课后题(无答案的)，以便后期复习使用。（可以私信我要文档资料

简答题

Object类的使用说明:

  1. 为什么要重写toString()方法？
    在Object类里面定义toString()方法的时候返回的对象的哈希code码,这个hashcode码不能简单明了的表示出对象的属性。所以要重写toString()方法。比如我前面数组那一篇文章用的Arrays.toString()方法就是调用重写的toString方法。

  2. 为什么要重写equals()方法？
    判断两个对象在逻辑上是否相等，如根据类的成员变量来判断两个类的实例是否相等，而继承Object中的equals方法只能判断两个引用变量是否是同一个对象（相当于比较的是存在堆里的地址值）。这样我们往往需要重写equals()方法来判断里面的数据是否相等。

  3. 写出“==”和equals的区别（重点）
    == ：运算符
    1.可以使用在基本数据类型变量和引用数据类型变量中
    2.如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
    如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
    补充： == 符号使用时，必须保证符号左右两边的变量类型一致。

    equals()方法的使用：

    1. 是一个方法，而非运算符

    2. 只能适用于引用数据类型

    3. Object类中equals()的定义：
      public boolean equals(Object obj) {
      return (this == obj);
      }
      说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体

    4. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是
      两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。

    5. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们
      就需要对Object类中的equals()进行重写.
      重写的原则：比较两个对象的实体内容是否相同.

编程题

  1. 按要求实现下列问题：实现一个名为Person的类和它的子类Employee，Employee有两个子类Faculty和Staff。具体要求如下：
    1） Person类中的属性有：姓名name（String类型），地址address（String类型），
    电话号码telphone（String类型）和电子邮件地址email（String类型）；
    2） Employee类中的属性有：办公室office（String类型），工资wage（double
    类型），受雇日期hiredate（String类型）；
    3） Faculty类中的属性有：学位degree（String类型），级别level（String类型）；
    4） Staff类中的属性有：职务称号duty（String类型）。
    5） 现有对象Person p1 =new Faculty()和Person p2 =new Staff ()，请分别为p1的属性赋值“本科”和Staff类的duty赋值“职员”
public class Person {
        private String name;
        private String address;
        private String telphone;
        private String email;

    public Person() {
    }

    public Person(String name, String address, String telphone, String email) {
        this.name = name;
        this.address = address;
        this.telphone = telphone;
        this.email = email;
    }

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getTelphone() {
        return telphone;
    }

    public void setTelphone(String telphone) {
        this.telphone = telphone;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

public class Employee extends Person{
    private String office;
    private double wage;
    private String hiredate;

    public Employee(){

    }

    public Employee(String name, String address, String telphone, String email, String office, double wage, String hiredate) {
        super(name, address, telphone, email);
        this.office = office;
        this.wage = wage;
        this.hiredate = hiredate;
    }

    public String getOffice() {
        return office;
    }

    public void setOffice(String office) {
        this.office = office;
    }

    public double getWage() {
        return wage;
    }

    public void setWage(double wage) {
        this.wage = wage;
    }

    public String getHiredate() {
        return hiredate;
    }
    public void setHiredate(String hiredate) {
        this.hiredate = hiredate;
    }
}

public class Staff extends Employee{
    private String duty;

    public Staff() {

    }

    public Staff(String name, String address, String telphone, String email, String office, double wage, String hiredate, String duty) {
        super(name, address, telphone, email, office, wage, hiredate);
        this.duty = duty;
    }

    public String getDuty() {
        return duty;
    }

    public void setDuty(String duty) {
        this.duty = duty;
    }

    public static void main(String[] args) {
        Person p1  = new Staff();
        if(p1 instanceof Staff){
            Staff staff = (Staff)p1;   //因为父类里面没有duty这个属性,所以只能向下转型才能进行赋值操作.
            staff.setDuty("职员");
        }

    }
}

public class Faculty extends Employee{
    private String degree;
    private String level;

    public String getDegree() {
        return degree;
    }

    public void setDegree(String degree) {
        this.degree = degree;
    }

    public String getLevel() {
        return level;
    }

    public void setLevel(String level) {
        this.level = level;
    }

    public Faculty() {

    }

    public Faculty(String name, String address, String telphone, String email, String office, double wage, String hiredate, String degree, String level) {
        super(name, address, telphone, email, office, wage, hiredate);
        this.degree = degree;
        this.level = level;
    }


    public static void main(String[] args) {
        Person p2 = new Faculty();
        if(p2 instanceof Faculty){
            Faculty faculty = (Faculty)p2; //因为父类里面没有degree这个属性,所以只能向下转型才能进行赋值操作.
            faculty.setDegree("本科");

        }
    }
}
  1. 创建一个汽车类（Car）
    （1）为其定义两个属性：颜色和型号。每个属性都使用private进行封装，为每个属性设置set、get方法。
    （2）为该类创建两个构造方法。第一个为无参的构造方法。第二个为带参构造方法
    （3）重写toString方法，通过toString输出汽车信息。
    （4）重写equals方法，如果汽车的颜色和型号相同就认为是同一辆车。
    （5）实例化两个对象，输出两个对象的信息，比较两个对象是否是同一个对象。
public class Car {
    public static void main(String[] args) {
        Car c1 = new Car();
        c1.setColor("red");
        c1.setModel("宝马");
        Car c2 = new Car();
        c2.setColor("red");
        c2.setModel("宝马");
        System.out.println(c1.equals(c2));

    }

    private String color;
    private String model;
    @Override
    public String toString() {
        return "Car{" +
                "color='" + color + '\'' +
                ", model='" + model + '\'' +
                '}';
    }

    public Car() {
    }

    public Car(String color, String model) {
        this.color = color;
        this.model = model;
    }

    public String getColor() {
        return color;
    }

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

    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Car car = (Car) o;
        return Objects.equals(color, car.color) &&
                Objects.equals(model, car.model);
    }

    @Override
    public int hashCode() {                    //可以不用重新这个方法,集合时用到
        return Objects.hash(color, model);
    }
}
  1. 编写一个Java应用程序，设计一个汽车类Vehicle，包含的属性有车轮个数wheels和车重weight。小车类Car是Vehicle的子类，其中包含的属性有载人数loader。卡车类Truck是Car类的子类，其中包含的属性有载重量payload。
    （1）每个类都有构造方法进行属性初识化
    （2）每个类都输出相关数据的toString方法
    （3）使用Test类中的main方法定义各类初始化数据后台打印相关数据
public class Truck extends Car{
    private int payload;

    public Truck(){

    }
    public Truck(int payload) {
        this.payload = payload;
    }

    public int getPayload() {
        return payload;
    }

    public void setPayload(int payload) {
        this.payload = payload;
    }

    @Override
    public String toString() {
        return "Truck{" +
                "payload=" + payload +
        ",loader=" + getLoader() +",wheels=" + getWheels() +
                ", weight=" + getWeight() +
                '}';
    }
}




class Car extends Vehicle{
    private int loader;

    public Car(){

    }

    public Car(int loader) {
        this.loader = loader;
    }

    public int getLoader() {
        return loader;
    }

    public void setLoader(int loader) {
        this.loader = loader;
    }

    @Override
    public String toString() {
        return "Car{" +
                "loader=" + loader +",wheels=" + getWheels() +
                ", weight=" + getWeight() +
                '}';
    }
}





class Vehicle{
    private int wheels;
    private int weight;

    public Vehicle() {
    }

    public Vehicle(int wheels, int weight) {
        this.wheels = wheels;
        this.weight = weight;
    }

    public int getWheels() {
        return wheels;
    }

    public void setWheels(int wheels) {
        this.wheels = wheels;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Vehicle{" +
                "wheels=" + wheels +
                ", weight=" + weight +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
        Truck truck = new Truck();
        truck.setWheels(4);
        truck.setWeight(4000);
        truck.setPayload(8);
        truck.setLoader(40000);
        System.out.println(truck.toString());
    }
}
  1. 定义员工类Employee，包含姓名、工号和工资，包含计算奖金方法bonus，普通员工和经理都是员工，
    计算奖金的方法为工资*奖金系数，普通员工的奖金系数为1.5（常量），经理为2（常量），分别实现bonus方法，创建对象测试。
public class Employee {
    public static void main(String[] args) {
        Employee employee = new Employee("张三","1001",2000);
        employee.bonus(2);//经理
        employee.bonus(1.5);//职员

    }

    private String name;
    private String id;
    private double salary;


    public Employee() {
    }

    public Employee(String name, String id, int salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
    public void bonus(double n){
        double bonus = salary * n;
        System.out.println(bonus);

    }

}
  1. 定义一个交通工具类，并定义抽象方法，说明交通工具可以移动。继承交通工具而产生汽车、飞机、轮船类，并实现其移动方法。
public abstract class Vehicle {

    public abstract void move();
}

class Car extends Vehicle{

    public void move(){
        System.out.println("汽车移动速度");
    }
}

class Airplane extends Vehicle{
    public void move(){
        System.out.println("飞机移动速度");
    }
}

class Ship extends Vehicle{
    public void move(){
        System.out.println("轮船移动速度");
    }
}
  1. （1）编写一个人类Person，其中包含姓名、性别和年龄的属性，包含构造方法以及显示姓名、性别和年龄的方法。（10分）
    （2）再编写一个学生类Student，它继承Person类，其中包含学号属性，包含构造方法以及显示学号的方法。（10分）
    （3）在Student类里面重写equals方法，只要是学号和姓名一致就认为是同一个学生。（20分）
    （4）最后编写一个测试类，此类里面包含main()方法，在main()方法中定义两个学生s1和s2并给他们赋值，
    最后显示他们的学号、姓名、性别以及年龄，以及判断两个学生是否是同一个学生。（10分）
public class Person {
    private String name;
    private String gender;
    private int age;


    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Student extends Person {

    public static void main(String[] args) {
        Student s1 = new Student("张三","女",11,"1001");
        Student s2 = new Student("张三","男",12,"1001");
        System.out.println(s1.equals(s2));
    }
    private String ID;

    public Student(String name, String gender, int age, String ID) {
        super(name, gender, age);
        this.ID = ID;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        if(ID != student.ID)
            return false;
        if(this.getName() != ((Student) o).getName())
            return false;
        return true;
    }


}
  1. 封装一个西游记人物类Person：包含私有属性：姓名（name）、身高（height）、武器（weapon）、种族（race），
    并提供访问器（get方法）和修改器（set方法）
    2） 在测试类中实例化三个对象：tangseng（唐僧）、sunwukong（孙悟空）、baigujing（白骨精），
    分别设置他们的种族为：人族、仙族、妖族
    3） 在打印对象时，按照例如：“姓名：孙悟空；种族：仙族”的格式在控制台输出信息。
    4） 提供一个技能方法void skill()，这个方法根据当前对象name属性判断技能， 如果是孙悟空，就打印“七十二变”，如果是唐僧，就打印“紧箍咒”，如果是白骨精，就打印“九阴白骨爪”，在测试类中调用这个方法。
    5） 重写equals方法进行判断，如果种族属性是人族或者仙族，则返回true，如果是妖族，
    则返回false，在测试类中对孙悟空和唐僧进行比较，打印结果，对唐僧和白骨金进行比较，并打印结果。
public class Test{
    public static void main(String[] args) {
        Person tangsheng = new Person();
        tangsheng.setName("唐僧");
        tangsheng.setRace("人族");
        Person sunwukong = new Person();
        sunwukong.setName("孙悟空");
        sunwukong.setRace("仙族");
        System.out.println(tangsheng.equals(sunwukong));
        Person baigujing = new Person();
        baigujing.setName("白骨精");
        baigujing.setRace("妖族");
        System.out.println(tangsheng.equals(baigujing));

    }

}




 class Person {
    private String name;
    private int height;
    private String weapon;
    private String race;

    public Person() {
    }

    public Person(String name, int height, String weapon, String race) {
        this.name = name;
        this.height = height;
        this.weapon = weapon;
        this.race = race;
    }

    public String getName() {
        return name;
    }

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

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public String getWeapon() {
        return weapon;
    }

    public void setWeapon(String weapon) {
        this.weapon = weapon;
    }

    public String getRace() {
        return race;
    }

    public void setRace(String race) {
        this.race = race;
    }

    public void skill(){
        if(name.equals("孙悟空") )
            System.out.println("七十二变");
        if(name.equals("唐僧"))
            System.out.println("紧箍咒");
        if(name.equals("白骨精"))
            System.out.println("九阴白骨爪");

    }

     @Override
     public String toString() {
         return
                 "姓名:" + name  +
                 "; 种族:" + race;
     }

     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         Person person = (Person) o;
         if(race.equals(person.race) || (race.equals("仙族") && person.race.equals("人族")) || (race.equals("人族") && person.race.equals("仙族")))
         return true;
         else
             return false;
     }



 }
goodmentality
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
JAVA初学笔记&宋红康JAVA基础篇(其十)
CyiceK的博客
09-08 698
面向对象 封装和隐藏 体现 我们将类属性私有化(private),同时提供公共的(public)方法来获取(getXxx)和设置此属性的值 不对外暴露私有的方法 单例模式 Java权限规定 修饰符 类内部 同一个包 不同包的子类 同一个工程 private Yes \ \ \ default(缺省) Yes Yes \ \ protected Yes Yes Yes \ public Yes Yes Yes Yes 用来修饰类的内部结构：属性、方法、构造器、内部类 修
JAVA初学笔记&宋红康JAVA基础篇（其一）
CyiceK的博客
08-02 855
还没开始写
Java基础核心技术：Java语言概述（day01）-宋红康-专题视频课程
songhongk的专栏
04-27 361
本套Java视频完全针对初级学员，课堂实录，自发布以来，好评如潮！Java视频中注重与学生互动，讲授幽默诙谐、细致入微，覆盖Java基础所有核心知识点，同类Java视频中也是代码量大、案例多、实战性强的。同时，本Java视频教程注重技术原理剖析，深入JDK源码，辅以代码实战贯穿始终，用实践驱动理论，并辅以必要的代码练习。...
JAVA初学笔记&宋红康JAVA基础篇(其三)
CyiceK的博客
08-06 305
JAVA基础语法 字符 关键字 内构语法？，可以去JAVA菜鸟教程了解，例如：if 保留字 Java未使用，但是已经被命名占用了，编程时尽可能避免 有 goto 、const 命名 标识符 由26个英文字母大小写，0-9，_或$组成 数字不可以开头 不能使用关键字和保留字，但能包含它们 Java中和C++一样严格区分大小写，长度不做限制 标识符不能有空格，空格统一用 _ 代替 命名规范（驼峰命名法） 包名：多个单词组成时所有的字母都小写。例如：aaabbbccc 类名、接口名：多单词组成时
JAVA初学笔记&宋红康JAVA基础篇(其五)
CyiceK的博客
08-14 230
运算符 运算符大全 整理半天了还不如上边的= = 流程控制-if else –待补
Java基础尚硅谷宋红康学习笔记
05-29
Java的基础部分主要包括以下几个方面： 1. **语法基础**：Java的语法与C++类似，但更简洁。它包括变量声明、数据类型（如整型、浮点型、字符型、布尔型等）、运算符（算术、关系、逻辑、位等）、流程控制（如if语句...
尚硅谷_宋红康_第11章_Java集合.pdf
07-05
·拒绝晦涩难懂的呆板教学，宋老师语言生动幽默，举例形象生动深入浅出，迅速让你把握问题本质，四两拨千斤 2.课程内容推陈出新： ·基于JDK 11，将Java8、Java9、Java10、Java11新特性一网打尽 ·课程中，Eclipse...
尚硅谷_宋红康_第16章_Java8的其它新特性.pdf
07-08
·拒绝晦涩难懂的呆板教学，宋老师语言生动幽默，举例形象生动深入浅出，迅速让你把握问题本质，四两拨千斤 2.课程内容推陈出新： ·基于JDK 11，将Java8、Java9、Java10、Java11新特性一网打尽 ·课程中，Eclipse...
尚硅谷_宋红康_第11章节练习_Java集合.doc
07-05
·拒绝晦涩难懂的呆板教学，宋老师语言生动幽默，举例形象生动深入浅出，迅速让你把握问题本质，四两拨千斤 2.课程内容推陈出新： ·基于JDK 11，将Java8、Java9、Java10、Java11新特性一网打尽 ·课程中，Eclipse...
尚硅谷_宋红康_第5章_面向对象编程(中).pdf
07-01
·拒绝晦涩难懂的呆板教学，宋老师语言生动幽默，举例形象生动深入浅出，迅速让你把握问题本质，四两拨千斤 2.课程内容推陈出新： ·基于JDK 11，将Java8、Java9、Java10、Java11新特性一网打尽 ·课程中，Eclipse...
面向对象（中）
QQ932816537的博客
04-28 300
写出错误答案错误的原因 class Demo{ int show(int a,int b){return 0;} } 下面那些函数可以存在于Demo的子类中。 A.public int show(int a,int b){return 0;}//可以，覆盖。 B.private int show(int a,int b){return 0;}//不可以，权限不够。 C.private int show(int a,long b){return 0;}//可以，和父类不是...
面向对象（中） 章节练习题及面试题
qq_41048982的博客
11-01 4032
继承性 java类是否可以多继承，怎么实现多继承？ 答：java没有多继承，但可以通过接口的形式来达到多继承的目地。 继承练习 定义类A 和类B 如下： class A { int a = 1; double d = 2.0; void show() { System.out.println("Class A: a=" + a + "\td=" + d); } } class B extends A { float a = 3.0f; String d = "Java pro
封装一个西游记人物类Person
总有一天我们会在虚拟的世界里相遇的博客
10-18 1175
按要求实现下列问题： 1）封装一个西游记人物类Person：包含私有属性：姓名（name）、身高（height）、武器（weapon）、种族（race），并提供访问器（get方法）和修改器（set方法） 2）在测试类中实例化三个对象：tangseng（唐僧）、sunwukong（孙悟空）、baigujing（白骨精），分别设置他们的种族为：人族、仙族、妖族 3）在打印对象时(toString())，按照例如：“姓名：孙悟空；种族：仙族”的格式在控制台输出信息。 4）提供一个技能方法void skill().
java_Object根类中关于toString、equals方法的详解
D大调奏鸣曲_第七序章_de博客
09-08 1050
目录 toString： 代码案例： equals： 代码案例： toString： 概念：拼接对象的地址值；toString()方法用于返回表示对象值的字符串（返回的是String对象)。 快捷写法：Alt+Insert，直接会显示toString的方法，选取需要返回的对象就行。 代码案例： /* 定义一个person类，属性如下： （1）身份证号，性别，姓名，年龄，户籍，出生日期（Data类型，需要引用java.uitl.Data）功能： （2）自我介绍：介绍格式：（toSt
尚硅谷-Java教程（宋红康)-JAVA8特性
hxinx的博客
11-22 875
尚硅谷-Java零基础教程（宋红康)- 编程入门 思维方式： 1、大处着眼，小处着手 2、逆向思维、反证法 3、透过问题看本质 冯诺依曼体系结构： 内存（RAM）：由一个有序的字节序列组成，用于存储程序及程序所需要的数据，一个程序和它的数据在被CPU执行前必须移到计算机的内存中。 比特(bit)和字节(byte): bit：计算机中最小的存储单位（一个0或者一个1存储为一个比特） byte：计算机中最基本的存储单元（每个字节由8个比特构成） 计算机的存储能力是以字节和多字节来衡量的。 .........
2．按要求编写Java应用程序： （1）编写西游记人物类（XiYouJiRenWu） 其中属性有：身高（height），名字（name），武器（weapon） 方法有：显示名字（printName)，...
weixin_30477797的博客
09-18 1586
XiYouJiRenWu package com.hanqi.test; public class XiYouJiRenWu { String height,name,weapon; XiYouJiRenWu(String h,String n,String w) { height=h; name=n; weapon=w; } String printName() { return name; }...
实验7：Student类继承Person类，并增加查找，统计功能
weixin_30621711的博客
05-06 589
源代码如下： 1 package Students; 2 public class Person 3 { 4 public String name; 5 public String birthday; 6 public String province,city; ...
==和.equals()方法的异同点
席同学的博客
01-07 616
1、对于基本数据类型，“==”比较的是两者的值是否相等。 2、对于引用数据类型，（1）“==”比较的是引用的地址是否相同（即是否是同一辆汽车（注意，只有一辆汽车））； Object中的.equals()方法和"==’功能一样 （2）但是String类中的.equals()方法重写了，比较的是两个引用对象的内容是否想同（即是否是完全相同的汽车（注意，有两辆汽车，且一模一样，完全相同））。 equal...
尚硅谷宋红康 Java 基础编程1
最新发布
08-03
"尚硅谷宋红康 Java 基础编程1" 这门课程是由尚硅谷的讲师宋红康主讲的Java基础编程课程，旨在为学员打下坚实的Java编程基础，以便进一步学习JavaEE、大数据、Android等领域的技术。课程内容涵盖了Java语言的各个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值