Java面向对象之泛型基本使用

最新推荐文章于 2023-07-02 01:02:46 发布
最新推荐文章于 2023-07-02 01:02:46 发布
阅读量548 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wcg920212/article/details/122096157
版权

文章目录

1、泛型

1.1、需求引出

在这里插入图片描述

package generic;

import java.util.ArrayList;

@SuppressWarnings({"all"})
public class Generic01 {
    public static void main(String[] args) {
        // 使用传统的方法来解决
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Dog("旺财", 10));
        arrayList.add(new Dog("发财", 1));
        arrayList.add(new Dog("小黄", 5));

        // 假如我们不小心, 添加了一只猫
        arrayList.add(new Cat("招财猫", 8));

        // 遍历
        for (Object o : arrayList) {
            // 向下转型 Object -> Dog
            Dog dog = (Dog) o;
            System.out.println(dog.getName() + " - " + dog.getAge());
            /**
             * 旺财 - 10
             * 发财 - 1
             * 小黄 - 5
             * Exception in thread "main" java.lang.ClassCastException: generic.Cat cannot be cast to generic.Dog
             * 	at generic.Generic01.main(Generic01.java:20)
             * 	由于里面混入了猫类, 在向下转型的时候报错了
             */
        }

    }
}

/**
 * 请编写程序, 在 ArrayList 中, 添加 3 个 Dog 对象
 * Dog 对象含有 name 和 age, 并输出 name 和 age (要求使用 getXxx())
 */
class Dog {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

class Cat {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
1.2、使用传统方法的问题分析
  1. 不能对加入到集合 ArrayList中的数据类型进行约束(不安全)
  2. 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响
1.3、用泛型来解决前面的问题

ArrayList arrayList = new ArrayList();

package generic;

import java.util.ArrayList;

@SuppressWarnings({"all"})
public class Generic01 {
    public static void main(String[] args) {
        // 1. 当我们 ArrayList<Dog> 表示存放到 ArrayList 集合中的元素是 Dog 类型
        // 2. 如果编译器发现添加的类型, 不满足要求, 就会报错
        // 3. 在遍历的时候, 可以直接取出 Dog 类型而不是 Object
        // 4. public class ArrayList<E> {} E 称为泛型, 那么 Dog->E
        ArrayList<Dog> arrayList = new ArrayList<Dog>();
        arrayList.add(new Dog("旺财", 10));
        arrayList.add(new Dog("发财", 1));
        arrayList.add(new Dog("小黄", 5));

        // 假如我们不小心, 添加了一只猫
        // arrayList.add(new Cat("招财猫", 8));  // 使用了泛型以后, 该行报错

        // 遍历
        for (Dog dog : arrayList) {  // 使用泛型以后, 这里不需要向下转型
            System.out.println(dog.getName() + " - " + dog.getAge());
            /**
             * 旺财 - 10
             * 发财 - 1
             * 小黄 - 5
             */
        }

    }
}

/**
 * 请编写程序, 在 ArrayList 中, 添加 3 个 Dog 对象
 * Dog 对象含有 name 和 age, 并输出 name 和 age (要求使用 getXxx())
 */
class Dog {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

class Cat {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
1.4、泛型的好处

在这里插入图片描述

1.5、泛型介绍

在这里插入图片描述
在这里插入图片描述

package generic;

public class Generic03 {
    public static void main(String[] args) {
        // 注意, 特别强调: E 具体的数据类型在定义 Person 对象的时候指定, 即在编译期间, 就确定 E 是什么类型
        Person<String> person = new Person<String>("hello");
        person.show();  // class java.lang.String
        /**
         * 可以这样理解上面的 Person 类
         * class Person {
         *     String s;  // E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定, 即在编译期间, 就确定 E 是什么类型
         *
         *     public Person(String s) {  // E 也可以是参数类型
         *         this.s = s;
         *     }
         *
         *     public String f() {  // 返回类型使用
         *         return s;
         *     }
         *
         *     public void show() {
         *         System.out.println(s.getClass());  // 显示 s 的运行类型
         *     }
         * }
         */

        Person<Integer> person2 = new Person<>(100);
        person2.show();  // class java.lang.Integer
        /**
         * class Person {
         *     Integer s;  // E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定, 即在编译期间, 就确定 E 是什么类型
         *
         *     public Person(Integer s) {  // E 也可以是参数类型
         *         this.s = s;
         *     }
         *
         *     public Integer f() {  // 返回类型使用
         *         return s;
         *     }
         *
         *     public void show() {
         *         System.out.println(s.getClass());  // 显示 s 的运行类型
         *     }
         * }
         */
    }
}

// 泛型的作用是: 可以在类声明时通过一个标识表示类中某个属性的类型
// 或者是某个方法的返回值的类型, 或者是参数类型
class Person<E> {
    E s;  // E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定, 即在编译期间, 就确定 E 是什么类型

    public Person(E s) {  // E 也可以是参数类型
        this.s = s;
    }

    public E f() {  // 返回类型使用
        return s;
    }

    public void show() {
        System.out.println(s.getClass());  // 显示 s 的运行类型
    }
}
1.6、泛型的语法
1.6.1、泛型的声明

在这里插入图片描述

1.6.2、泛型的实例化

在这里插入图片描述

1.6.3、泛型使用举例

在这里插入图片描述

package generic;

import java.util.*;

public class GenericExercise {
    public static void main(String[] args) {
        // 使用泛型方式给 HashSet 放入 3 个学生对象
        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("jack", 18));
        students.add(new Student("tom", 28));
        students.add(new Student("mary", 19));

        // 遍历
        for (Student student : students) {
            System.out.println(student);
            /**
             * Student{name='mary', age=19}
             * Student{name='tom', age=28}
             * Student{name='jack', age=18}
             */
        }

        // 使用泛型方式给 HashMap 放入 3 个学生对象
        // K -> String V -> Student
        HashMap<String, Student> hm = new HashMap<String, Student>();
        /*
        public class HashMap<K,V> {}
         */
        hm.put("milan", new Student("milan", 38));
        hm.put("smith", new Student("smith", 48));
        hm.put("jack", new Student("jack", 15));

        // 迭代器 EntrySet
        /*
        public Set<Map.Entry<K,V>> entrySet() {
            Set<Map.Entry<K,V>> es;
            return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
        }
         */
        Set<Map.Entry<String, Student>> entries = hm.entrySet();
        /*
        public final Iterator<Map.Entry<K,V>> iterator() {
            return new EntryIterator();
        }
         */
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        System.out.println("==============================");
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next = iterator.next();
            System.out.println(next.getKey() + "-" + next.getValue());
        }
        /**
         * ==============================
         * smith-Student{name='smith', age=48}
         * milan-Student{name='milan', age=38}
         * jack-Student{name='jack', age=15}
         */
    }
}

/**
 * 创建 3 个学生对象
 * 放入到 HashSet 中学生对象, 使用
 * 放入到 HashMap 中, 要求 Key 是 String name, Value 就是 学生对象
 * 使用两种方式遍历
 */
class Student {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
1.6.4、泛型使用的注意事项和细节

在这里插入图片描述

package generic;

import java.util.ArrayList;
import java.util.List;

@SuppressWarnings({"all"})
public class GenericDetail {
    public static void main(String[] args) {
        // 1.给泛型指向数据类型是要求是引用类型, 不能是基本数据类型
        List<Integer> list = new ArrayList<Integer>();  // OK
        // List<int> list2 = new ArrayList<int>();  // 错误

        // 2.说明: 因为 E 指定了 A 类型, 构造器传入了 new A()
        // 在给泛型指定具体类型后, 可以传入该类型或者其子类类型
        Pig<A> aPig = new Pig<A>(new A());
        aPig.f();  // class generic.A

        Pig<A> aPig2 = new Pig<A>(new B());
        aPig2.f();  // class generic.B

        // 3.泛型的使用形式
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();
        // 在实际开发中, 我们往往简写
        // 编译器会进行类型推断, 推荐使用下面写法
        ArrayList<Integer> list3 = new ArrayList<>();
        List<Integer> list4 = new ArrayList<>();
        ArrayList<Pig> pigs = new ArrayList<>();

        // 4.如果是这样写 泛型默认是 Object
        ArrayList arrayList = new ArrayList();  // 等价 ArrayList<Object> arrayList = new ArrayList<Object>()
        /**
         * public boolean add(Object e) {
         *     ensureCapacityInternal(size + 1); // Increments modCount!!
         *     elementData[size++] = e;
         *     return true;
         * }
         */

        Tiger tiger = new Tiger();
        /**
         * class Tiger {  // 类
         *     Object e;
         *
         *     public Tiger() {
         *     }
         *
         *     public Tiger(Object e) {
         *         this.e = e;
         *     }
         * }
         */
    }
}

class Tiger<E> {  // 类
    E e;

    public Tiger() {
    }

    public Tiger(E e) {
        this.e = e;
    }
}

class A {
}

class B extends A {
}

class Pig<E> {
    E e;

    public Pig(E e) {
        this.e = e;
    }

    public void f() {
        System.out.println(e.getClass());  // 运行类型
    }
}
1.6.5、泛型小练习

在这里插入图片描述

package generic;

import java.util.ArrayList;
import java.util.Comparator;

@SuppressWarnings({"all"})
public class GenericExercise02 {
    public static void main(String[] args) {
        ArrayList<Employee> employees = new ArrayList<>();
        employees.add(new Employee("jack", 12000.95, new MyDate(1993, 10, 10)));
        employees.add(new Employee("tom", 25000.40, new MyDate(1981, 11, 11)));
        employees.add(new Employee("lucy", 5500.50, new MyDate(2004, 9, 12)));

        // 循环遍历
        for (Employee employee : employees) {
            System.out.println(employee);
            /**
             * Employee{name='jack', sal=12000.95, birthday=MyDate{year=1993, month=10, day=10}}
             * Employee{name='tom', sal=25000.4, birthday=MyDate{year=1981, month=11, day=11}}
             * Employee{name='lucy', sal=5500.5, birthday=MyDate{year=2004, month=9, day=12}}
             */
        }

        // 排序
        // 传入 Comparator 对象[使用泛型], 先按照 name 排序, 如果 name 相同, 则按生日日期的先后排序 【即: 定制排序】
        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee employee1, Employee employee2) {
                // 先对传入的参数进行验证
                if (!(employee1 instanceof Employee && employee2 instanceof Employee)) {
                    System.out.println("类型不正确..");
                    return 0;
                }
                int i = employee1.getName().compareTo(employee2.getName());
                if (i != 0) {
                    return i;
                }

                // 下面是对 birthday 的比较, 因此, 我们最好把这个比较, 放在 MyDate 类完成
                // 封装后, 将来可维护性和复用性, 就大大增强
                return employee1.getBirthday().compareTo(employee2.getBirthday());
            }
        });
        // 排序后
        System.out.println("=== 排序后 ===");
        for (int j = 0; j < employees.size(); j++) {
            System.out.println(employees.get(j));
            /**
             * === 排序后 ===
             * Employee{name='jack', sal=12000.95, birthday=MyDate{year=1993, month=10, day=10}}
             * Employee{name='lucy', sal=5500.5, birthday=MyDate{year=2004, month=9, day=12}}
             * Employee{name='tom', sal=25000.4, birthday=MyDate{year=1981, month=11, day=11}}
             */
        }
    }
}

/**
 * 定义 Employee 类
 * 1) 该类包含: private 成员变量 name, sal, birthday, 其中 birthday 为 MyDate 类的对象
 * 2) 为每一个属性定义 getter, setter 方法
 * 3) 重写 toString 方法输出 name, sal, birthday
 * 4) MyDate 类包含: private 成员变量 month, day, year, 并为每一个属性定义 getter, setter 方法
 * 5) 创建该类的 3 个对象, 并把这些对象放入 ArrayList 集合中(ArrayList 需使用泛型来定义), 对集合中的元素进行排序, 并遍历输出
 * 排序方式: 调用 ArrayList 的 sort 方法
 * 传入 Comparator 对象[使用泛型], 先按照 name 排序, 如果 name 相同, 则按生日日期的先后排序 【即: 定制排序】
 */

// Employee 类
class Employee {
    private String name;
    private double sal;
    private MyDate birthday;

    public Employee(String name, double sal, MyDate birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

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

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", birthday=" + birthday +
                '}';
    }
}

// MyDate 类
class MyDate implements Comparable<MyDate> {
    private Integer year;
    private Integer month;
    private Integer day;

    public MyDate(Integer year, Integer month, Integer day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public Integer getYear() {
        return year;
    }

    public void setYear(Integer year) {
        this.year = year;
    }

    public Integer getMonth() {
        return month;
    }

    public void setMonth(Integer month) {
        this.month = month;
    }

    public Integer getDay() {
        return day;
    }

    public void setDay(Integer day) {
        this.day = day;
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }

    @Override
    public int compareTo(MyDate o) {  // 把对year-month-day比较放在这里
        int yearMinus = year - o.getYear();
        if (yearMinus != 0) {
            return yearMinus;
        }
        // 如果year相同, 就比较month
        int monthMinus = month - o.getMonth();
        if (monthMinus != 0) {
            return monthMinus;
        }

        // 如果year 和 month 相同直接返回day的比较结果
        return day - o.getDay();
    }
}
一切随心走_水瓶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面向对象之16：一文 彻底搞懂Java中的泛型、泛型的 使用细节 及 注意事项：
随手记记，加深印象。
06-15 993
what's Generic？ 泛型（广泛的类型）： 泛型就相当于是一个标签。形象一些就是：在生活中随处可见的类似于泛型的参考。比如：男卫生间门上贴的标签 --》 男 or boy ，女卫生间门上的标签 --》 女 or girl，能表示性别的标签 理解在Java中就叫做泛型。再 比如：垃圾分类的垃圾桶上面贴的标签，比如：厨余辣鸡、有害辣鸡、可回收辣鸡、其他辣鸡，……等等。 泛型的声明格式：<泛型标识符[,泛型标识符2,……]> 这个<>有的 因为像，也叫做钻石运算符。 Java中 泛型的
Educoder–Java面向对象-泛型程序设计【笔记+参考代码】
12-21
Java中的泛型是面向对象程序设计的一个重要特性，它允许我们在类、接口和方法中使用类型参数，从而创建可重用的组件，这些组件能够处理多种数据类型而无需显式进行类型转换。泛型的主要目标是提高代码的类型安全性和...
Java面向对象【泛型】
weixin_62584200的博客
08-20 204
泛型的简单使用及介绍
java面向对象之泛型
qq_42403069的博客
08-13 176
一.认识泛型 实现泛型的set和get 一般形式set和get 使用泛型过后，我们可以在主方法中轻易地通过改变<>中的内容，从而更简单的实现其相同类型的数据操作。 二.构造方法中使用泛型 三.指定多个泛型 每个泛型用逗号隔开就行了。 四.泛型之通配符（?） 没有通配符情况： 用了通配符？过后就可以用了 五.泛型接口的使用 六.泛型方法 七....
Java面向对象编程-泛型
qq_50743381的博客
05-06 632
泛型 1、泛型问题的引出 泛型从JDK1.5之后追加到Java语言里面的，其主要的是为了解决ClassCastException的问题，在进行对象的向下转型时永远都存在有安全隐患，而Java希望通过泛型慢慢解决掉此类问题 泛型问题的引出 现在假设说定义一个描述x与y坐标的处理类，并且在这个类之中允许开发者保存有三类数据 整型数据：x=10、y=20 浮点型数据：x=10.1、y=20.9 字符串型数据：x=东经120度、北纬30度 于是在设计Point类的时候就需要去考虑具体的x和y属性的类
java 对象 泛型,Java 持有对象以及泛型基础
weixin_29164497的博客
03-13 443
1、泛型 > 泛型一般结合集合类又叫容器类(Colletion)来使用ArrayList nameList=newArrayList();2、泛型的类型可以向上转型publicclass泛型 {//泛型publicstaticvoidmain(String[] args) {ArrayList list=newArrayList();list.add(newTeacher(...
Java泛型的使用限制实例分析
08-25
此外，还有很多其他的Java知识点，例如Java面向对象程序设计、Java数据结构与算法、Java操作DOM节点技巧、Java文件与目录操作技巧、Java缓存操作技巧等等，读者可以查看相关的教程和教程来深入了解。
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计是计算机科学中的一个重要领域，它基于面向对象编程（OOP）的概念，是一种强大的编程范式。在Java中，OOP的核心概念包括类、对象、封装、继承、多态等。这本书"Java面向对象程序设计"由耿祥义和...
Java面向对象知识点梳理(思维导图)
11-10
初学者可以通过导图了解和学习Java面向对象编程的基本概念和语法；有一定Java基础的开发者可以通过导图巩固和扩展他们的知识，进一步提升面向对象编程的能力。 使用场景以及目标： 这个导图可以作为学习和复习Java...
Java面向对象知识点的思维导图
11-10
初学者可以通过导图了解和学习Java面向对象编程的基本概念和语法；有一定Java基础的开发者可以通过导图巩固和扩展他们的知识，进一步提升面向对象编程的能力。 使用场景以及目标： 这个导图可以作为学习和复习Java...
java泛型中的对象
03-19 125
import java.util.HashMap; class Key { String s; Key(String s) { this.s = new String(s); } @Override public boolean equals(Object obj) { if (obj instanceof Key) { if (s.equa...
Java面向对象之泛型
henry的博客
10-07 576
认识泛型 1、泛型是在JDK1.5之后增加的新功能。泛型（Generic） 2、泛型可以解决数据类型的安全性问题，他主要的原理，是在类声明的时候通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。 3、格式： 访问权限 class 类名称{ 属性 方法 } 4、对象的创建 类名称  对象名称=new  类名称(); 示例： //class里面不明确指定什么类型
java 泛型列表_Java泛型：列表，列表<对象>，列表<？>
weixin_30629043的博客
02-16 335
慕哥6287543用我自己简单的话说：列单将声明一个普通集合，可以保存任何类型，并将始终返回对象。列表将创建一个列表，该列表可以容纳任何类型的对象，但只能分配另一个对象。列表例如，这是行不通的；List l = new ArrayList();当然，您可以添加任何东西，但只能拉动对象。List l = new ArrayList();l.add( new Employee() );l.add( n...
java泛型详解
ma_nong33的博客
05-25 1061
不是限制 addAll() 的参数是一个与您将要添加到的集合包含相同类型的集合，而有可能建立一个更合理的约束，即传递给 addAll() 的集合的元素 适合于添加到您的集合。如果您试图将 List 传递给一个接受 List 的方法，它将能够工作，但是编译器将会发出一个可能丧失类型安全的警告，即所谓的“unchecked conversion（不检查转换）”警告。这可以让您消除代码中的强制类型转换，同时获得一个附加的类型检查层，该检查层可以防止有人将错误类型的键或值保存在集合中。
JAVA面向对象之泛型
Lyajpunov的博客
01-11 1567
契子、引入泛型 我们在学习JAVA中经常会写这样一些类用来联系，比如超级数组，我们先写一个这样的类 SuperArray.java package com; import java.util.Arrays; public class SuperArray { // 定义我们操作的数组,初始化长度为10 private int[] num = new int[10]; // 定义游标 private int current = -1; // 空参构造 pub
【Java】Java中的泛型
最新发布
qq_61635026的博客
07-02 1827
在Java中，泛型是一种在编译时期类型检查的机制，它使得我们能够创建具有通用行为的类、接口和方法，以适应不同类型的数据。通过使用泛型，可以提高代码的复用性、类型安全性以及可读性。 泛型是在JDK 1.5 引入的新语法，通俗来讲，泛型就是适应多种类型。从代码上来看，就是对类型实现了参数化，即从传入的类型参数来确定数据的具体类型。
java+构造泛型对象_Java面向对象：泛型
weixin_42335570的博客
02-27 282
泛型类示例classPoint{privateTx;privateTy;publicTgetX(){returnx;}publicvoidsetX(Tx){this.x=x;}publicTgetY(){returny;}publicvoidsetY(Ty){this.y=y;}}publicclasstest3{publicstatic...
Java泛型
刘程云的博客
11-30 190
泛型：是JDK5中引入的一个新特性，泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型 泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法
Java面向对象：抽象类与泛型详解
本资源主要聚焦于Java编程中的面向对象概念以及相关技术，特别是抽象类和泛型的应用。首先，我们讨论了抽象类在Java中的作用，它是允许程序员定义具有通用特性的类，但并不提供具体实现。抽象类中可以包含抽象方法，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值