java基础学习9-------史上最详细

最新推荐文章于 2023-01-27 14:53:33 发布
最新推荐文章于 2023-01-27 14:53:33 发布
阅读量408 收藏
点赞数
分类专栏： java基础 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kayleigh520/article/details/121725121
版权

今天我们来看构造方法

构造方法

什么是构造方法？下面来看

概念
构造方法的目的是为对象中的数据进行初始化。
格式
1.方法名字和类名相同
2.没有返回值类型，连void都没有
3.没有具体的返回值

class Student {
    private String name;
    private int age;

    Student(){
        System.out.println("这是无参的构造方法");
    }

    //getXxx()和setXxx()方法
    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

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

    public int getAge(){
        return age;
    }


    public void show() {
        System.out.println("姓名：" + name + ",年龄：" + age);
    }


}

public class StructureDemo1 {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        s.show();
    }
}

思考：

我们在学习构造方法之前，也是new对象出来，现在知道了，内部一直都是调用一个无参的构造方法，但是呢，我们在类中并没有区写出来构造方法，所以问题是我们一直用的构造的方法来自哪里呢？

注意哦：

1.如果我们没有给出构造方法，jvm就会自动的提供一个无参的构造方法给我们。
2.如果我们给出了构造方法，jvm就不会再提供默认的无参的构造方法了。
  如果我们没有给出无参的构造方法，却给出了其他的构造方法，jvm就不再提供默认的构造方法
   只要我们给出了构造方法，无论是有参的还是无参，jvm就用永远不会再提供午无参的构造方法。
3.构造在同一个类的也是可以发生重载的。（方法名一样，参数列表不一样，与返回值无关。）
作用
可以在创建对象的时候给对象的成员变量进行赋值。

现在我们学习了两种给成员对象赋值的方法了：

  1. 使用类提供的公共的setXxx()方法给成员变量进行赋值。
  2. 使用代参数的构造方法给私有的成员变量进行赋值。

注意：形参的变量名和成员名一样的时候，需要this关键字一起使用。
接下来代码练习：


class Structure {
    private String name;
    private int age;

    Structure() {
        System.out.println("这是我们自己写的无参构造方法");
    }

    Structure(String name) {
        System.out.println("这是我们自己写的带name参数的带参构造方法");
        this.name = name;
    }

    Structure(int age){
        System.out.println("这是我们自己写的带age参数的带参构造方法");
        this.age = age;
    }

    Structure(String name,int age){
        System.out.println("这是我们自己写的带所有成员变量的参数的带参构造方法");
        this.name = name;
        this.age = age;
    }


    public void show() {
        System.out.println("姓名：" + name + ",年龄：" + age);
    }

}

public class StructureDemo2 {
    public static void main(String[] args) {
        Structure s1 = new Structure();
        //能看到地址值说明咱们的对象已经被new了出来
        System.out.println(s1);
        System.out.println("=======================");


        //创建第二个对象
        Structure s2 = new Structure("李玉伟");
        s2.show(); //李玉伟,0
        System.out.println("=======================");

        //创建第三个对象
        Structure s3 = new Structure(17);
        s3.show();//null,17
        System.out.println("=======================");

        //创建第四个对象
        Structure s4 = new Structure("kayleigh",18);
        s4.show();

    }
}

构造方法就先看看到这，下面我们来看新的内容：我们用一个例子来引出这个内容

定义一个人的类
   经过测试发现，我们举例子的时候，都是中国人，国籍都一样，都是中国，一样的国籍，每次创建的时候，都会在堆内存开辟一个这样的变量空间，总觉得有点浪费。有没有什么办法，让所有一样国籍的人共用一个国籍的值，针对多个对象拥有共同的成员变量，值是一样的时候
   Java提供了一个关键字给我们处理这样的情况，这个关键字叫做：static
   可以修饰成员变量和成员方法，修饰成员变量的时候，可以让多个对象共用一个成员变量的值。

class Person{
    //姓名
    private String name;
    //年龄
    private int age;
    //国籍
//    private String nationality;
    private static String nationality;


    public Person() {
    }

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

    public Person(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;
    }

    public String getNationality() {
        return nationality;
    }

    public void setNationality(String nationality) {
        this.nationality = nationality;
    }

    public void show(){
        System.out.println("姓名："+name+",年龄："+age+",国籍："+nationality);
    }
}

public class PersonDemo {
    public static void main(String[] args) {
        //创建第一个对象
        Person p1 = new Person("kayleigh",26,"中国");
        p1.show();

        //创建第二个对象
        Person p2 = new Person("kaylemon",30);
        p2.show();

        //创建第三个对象
        Person p3 = new Person("kaylele",18);
        p3.show();
        System.out.println("==========================================");

       // p1.setNationality("俄罗斯");
       // p1.show();
       // p2.show();
       // p3.show();
//这里可以把注释去掉，可以看看输出的内容有什么不一样。


    }
}

注意一下，这里的重置默认的国籍，就会更改全部的成员变量的国籍值。
下面我们正式来看一下static关键字的作用和用途。

static关键字

特点
  1. 随着类的加载而加载。
    运行之前会将calss类文件加载到方法区，而被static修饰的成员是随着类的加载而加载，所以static修饰的成员在方法区里面存放。
  2. 优先于对象存在。
  3. 被类所有的对象共享。
    举例：所有的中国人的国籍信息都一样什么时候使用static关键字呢？如果说明某个成员变量是被所有对象共享的，那么它就应该被定义为静态的。
    举例：
    哈罗单车：（可以被static修饰）
    自己的水杯：（不可以被static修饰）
  4. 被静态修饰的成员可以直接通过类名调用。
    一般情况下，我们今后开发的时候，只要看到类中有静态的成员变量或者成员方法，今后在调用的时候，一律用 类名.静态成员 这样的方法调用。
    推荐使用类名的方法调用，这也是规范。
    通过调用的方式区分不同的成员。

所以被静态修饰的成员，一般情况下称之为：类成员，与类相关。

class Demo2{
    //定义一个非静态的成员变量
    int a = 10;

    //定义一个静态的成员变量
    static int b = 20;
}

public class StaticDemo1 {
    public static void main(String[] args) {
        Demo2 d1 = new Demo2();
        System.out.println(d1.a);
        System.out.println(d1.b);
        
        //这里可以看到可以直接被调用。
        System.out.println(Demo2.b);
    }
}

下面我们来看看静态成员访问的问题

1、static可以修饰成员变量和成员方法。
2、非静态成员方法：
               1)访问的是非静态的成员变量
                    可以
                2)访问的是静态的成员变量
                    可以
                3)访问的是非静态的成员方法
                    可以
                4)访问的是静态的成员方法
                    可以
           总结：非静态的成员方法可以访问静态的成员也可也访问非静态的成员

            静态的成员方法：
                1)访问的是非静态的成员变量
                    不可以
                2)访问的是静态的成员变量
                    可以
                3)访问的是非静态的成员方法
                    不可以
                4)访问的是静态的成员方法
                    可以
           总结：静态的成员方法只能访问静态的成员

class Demo3{
    //非静态的成员变量
    int a = 10;

    //静态的成员变量
    static int b = 20;


    //非静态的成员方法
    public void fun1(){
        System.out.println(a);
        System.out.println(b);
        fun2();
        fun3();
    }

    public static void fun2(){
        //Error:(47, 28) java: 无法从静态上下文中引用非静态 变量 a
//        System.out.println(a);
//        System.out.println(b);
//        System.out.println("这是静态的成员方法fun2");
        //Error:(51, 9) java: 无法从静态上下文中引用非静态 方法 fun3()
//        fun3();
        fun4();
    }

    public void fun3(){
        System.out.println("这个是非静态的成员方法fun3");
    }

    public static void fun4(){
        System.out.println("这是静态的成员方法fun4");
    }

}

public class StaticDemo2 {
    public static void main(String[] args) {
        Demo3 d = new Demo3();
//        d.fun1();
        Demo3.fun2();
        fun();
    }


    public static void fun(){
        System.out.println("helloworld");
    }
}

我们来做做练习：



/*
        标准类代码3.0版本，一个标准的手机类
        分析：
            手机：
                属性：品牌，颜色，价格
                行为：打电话，发短信，学习
            类：
                成员变量：brand,color,price（使用private修饰）
                构造方法：无参构造方法，带参构造方法
                成员方法：setXxx()和getXxx()方法
                show():输出所有的成员变量


 */
public class Phone {
    //定义成员变量
    private String brand;
    private String color;
    private int price;

    //定义构造方法
    Phone() {

    }

    Phone(String brand, String color, int price) {
        this.brand = brand;
        this.color = color;
        this.price = price;
    }

    //定义公共的setXxx()和getXxx()
    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

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

    public String getColor() {
        return color;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public int getPrice() {
        return price;
    }

    //定义一个可以输出所有成员变量的方法
    public void show() {
        System.out.println("品牌：" + brand + ",颜色：" + color + ",价格：" + price);
    }
}



/*
        手机测试类：
            开发中最常用的是第二种方式，单个使用永远要比混合使用要灵活

 */
public class  PhoneDemo {
    public static void main(String[] args) {
        //使用无参的构造方法创建对象，并使用setXxx()给成员变量进行赋值
        System.out.println("=======使用无参的构造方法创建对象，并使用setXxx()给成员变量进行赋值=======");
        Phone p1 = new Phone();
        System.out.println("未赋值前：");
        p1.show();
        p1.setBrand("华为");
        p1.setColor("黑色");
        p1.setPrice(4999);
        System.out.println("赋值后：");
        p1.show();
        System.out.println("================================================");
        System.out.println("=======使用带参数的构造方法创建对象，并使用getXxx()获取成员变量=======");
        Phone p2 = new Phone("锤子手机","白色",8888);
        String brand = p2.getBrand();
        String color = p2.getColor();
        int price = p2.getPrice();
        System.out.println("品牌["+brand+"]\t颜色["+color+"]\t价格["+price+"]");


    }
}


package com.bigdata.day12;
/*

    定义一个类Demo,其中定义一个求两个数据和的方法，定义一个测试了Test，进行测试。
 */

class Demo {
    //第一种方式：
//    public int sum() {
//        int a = 11;
//        int b = 22;
//        int c = a + b;
//        return c;
//    }


    //第二种方式：
    //通过第一种方式实现了我们题目的需求
    //但是不好，因为加法的数值写固定了，所以不好
    //改进：可以将来传两个值进来
    public int sum(int x, int y) {
        return x + y;
    }

    //第二种方式对然相比较于第一种方式来说，虽然我们可以进行手动传入参数，但是
    //实现的过程并没有用到面向对象的封装的知识
    //我们可以尝试将两个参数定义为成员变量

    //第三种方式：
//    private int a;
//    private int b;
//
//    public int sum(int a,int b){
//        this.a = a;
//        this.b = b;
//        return (this.a+this.b);
//    }

    //问题：哪一种方式实现该问题的最优解？
    //其实，我们在面对业务问题的时候，什么时候考虑使用面向对象的思想
    //或者换句话说，什么情况下，将我们问题中的参数定义成成员变量呢？
    //只有当我们题目中参数与该类形成属性和行为的关系的时候，才定义成成员变量
    //因为类是用来描述现实世界事物的，
    //所以也就说成员变量是用来描述类
    //所以，这道题，第二种方式是最优解。





}

public class Test1 {
    public static void main(String[] args) {
        //创建对象
        Demo d = new Demo();
        int sum = d.sum(65,70);
        System.out.println(sum);

    }

}


package com.bigdata.day12;

/*
        定义一个员工类,自己分析出几个成员，
        然后给出成员变量，构造方法，getXxx()/setXxx()方法，
        以及一个显示所有成员信息的方法。并测试。


        员工：
            属性：工号，姓名，年龄，薪水
            行为：敲代码，吃饭，喝水


 */

class Staff {
    private String id;
    private String name;
    private int age;
    private int salary;

    Staff() {

    }

    Staff(String id, String name, int age, int salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }


    public String getId() {
        return id;
    }

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

    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;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }


    //以及一个显示所有成员信息的方法
    public void show() {
        System.out.println("工号：" + id + ",姓名：" + name + ",年龄：" + age + ",薪水：" + salary);
    }

}


public class Test3 {
    public static void main(String[] args) {
        //使用带参数的构造方法创建对象
        Staff s = new Staff("SJ005","王友虎",18,1000000);

        s.show();

    }
}


package com.bigdata.day12;
/*
        定义一个类MyMath,提供基本的加减乘除功能，然后进行测试

        导包import语句在所有的class之前
 */


import java.util.Scanner;

class MyMath {
    //加法功能
    public int add(int a, int b) {
        return a + b;
    }

    //减法功能
    public int sub(int a, int b) {
        return a - b;
    }

    //乘法功能
    public int mul(int a, int b) {
        return a * b;
    }

    //除法功能
    public double div(int a, int b) {
        return (a * 1.0) / b;
    }
}


public class Test4 {
    public static void main(String[] args) {
        MyMath compute = new MyMath();
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入第一个数据num1：");
        int num1 = sc.nextInt();
        System.out.println("请输入第二个数据num2：");
        int num2 = sc.nextInt();

        System.out.println("num1+num2=" + compute.add(num1, num2));
        System.out.println("num1-num2=" + compute.sub(num1, num2));
        System.out.println("num1*num2=" + compute.mul(num1, num2));
        System.out.println("num1/num2=" + compute.div(num1, num2));

    }
}
创作者mateo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java开发工具（1）你真的会用IDEA么？（上）Structure、Favorites功能介绍
lz710117239的博客
02-07 1834
idea你真的会用么？本篇文章主要介绍了侧边栏Structure和标签功能，这是你不容错过的细节
历经5年锤练--史上最适合初学者入门的Java基础视频
09-20
历经5年锤练--史上最适合初学者入门的Java基础视频 JAVASE基础视频,并附带相应代码(5.02M) 视频+代码共(6.26GB) 36个压缩包
java高级用法之:JNA中的Structure
程序那些事
05-09 2299
文章目录简介native中的structStructure特殊类型的Structure结构体数组作为参数结构体数组作为返回值结构体中的结构体结构体中的数组结构体中的可变字段结构体中的只读字段总结 简介 前面我们讲到了JNA中JAVA代码和native代码的映射，虽然可以通过TypeMapper来将JAVA中的类型和native中的类型进行映射，但是native中的数据类型都是基础类型，如果native中的数据类型是复杂的struct类型该如何进行映射呢？ 不用怕，JNA提供了Structure类，来帮助我们
Java 入门之8：Java分支结构，循环结构总结
随手记记，加深印象。
05-14 2383
目录 Java的中流程控制的分类： 顺序结构（sequential structure）图示： 分支结构（branch structure）（选择结构 （choice structure）） if单分支语法结构：​ if单分支流程图示： if单分支结构总结： if双分支语法结构：​ if双分支流程图示： if双分支结构总结： if多分支语法结构：​ if多分支流程图示： if多分支结构总结： switch分支语法结构：​ switch分支流程图示：​ switch分支结构总结：
java structure_Java 数据结构实现（DataStructure）1
weixin_33582801的博客
02-21 647
线性表和链表单向链表利用了类的自引用，实现了类似指针的效果。双向链表的实现，必须注意双向链表的head和back两个指针的正确指向，以及插入和删除过程中指向操作增减的有序性。下面几图从java面向对象的角度说明了单向双向链表的逻辑结构，类的自引用使得逻辑指向成为可能。以下两图说明了添加删除头尾节点时执行的顺序：添加头结点时先加一个临时节点，建立此临时节点和原头节点后使此临时节点为新头结点即可。删除...
百度贴吧签到网站源码Java-Linux:Linux学习
06-06
百度贴吧签到网站源码Java Linux 1.简介 1.1.UNIX发展史 （1)1965年,美国麻省理工学院(MIT)、通用电气公司(GE)及AT&T的贝尔实验室联合开发 Multics工程计划,其目标是开发一种交互式的具有多道程序处理能力的分时操作...
高级java笔试题-awesome-learning:Github仓库学习资源！
06-03
史上最全的BAT大厂Android面试题汇集，以及常用的Android开发的一些技能点，冷门知识点汇总，开发中遇到的坑汇总等干货。 LeetCode 上面主要收集了各大 IT 公司的笔试面试题,该项目为 LeetCode Java 语言的题解集合 ...
java班级管理源码-Android-Interview:Android面试宝典
06-04
面试资料集合](Android/史上最全 Android 面试资料集合.md) 目录 [Activity Task和Process之间的关系](Activity/Activity Task和Process.md) [手把手教你如何解决as jar包冲突](开发遇到的问题/手把手教你如何解决as...
史上最详细的Java基础知识总结（入门一）
01-20
笔者的java还在学习中，为了巩固一下自己学习的知识，在这里与大家分享一下，所以有些地方难免会理解错误之类的，如果看到错误的地方，请指出来，或者有什么不理解的地方也可以提出来，大家一起进步。 这篇教程是一...
data structures and other objects using java
01-17
这是一本关于Java的数据结构书，第4版作者是Micherl Main
Java_Data_Structure：用Java实现数据结构
02-16
Java_Data_Structure 用Java实现数据结构
Object-Oriented Data Structures Using Java
12-14
英文原版，用Java讲解的数据结构，共800多页，讲解很细致，值得推荐。
leetcode2-DataStructureDemo:数据结构学习。1、啊哈算法
06-29
leetcode 2 DataStructureDemo 项目介绍 数据结构 + 算法练习。 1、啊哈 算法。 2、剑指Offer 3、LeetCode代码练习 github传送门 github传送门 gitee传送门 啊哈 算法 剑指Offer LeetCode 一、链表 1、Java实现单链表，支持增删改查。 2、单向链表反转 3、单向链表是否有环 4、合并两个有序链表 5、删除链表倒数第 n 个结点 6、求单向链表的中间结点 二、栈 1、Java实现顺序栈、链式栈 三、队列 1、顺序队列、链式队列 2、循环队列 四、排序算法 1、冒泡排序 2、插入排序 3、选择排序 4、归并排序 5、快速排序 6、桶排序、计数排序，基数排序 五、查找算法 1、二分查找 ①求一个数的平方根，精确到小数点后六位。二分查找实现，牛顿迭代法实现。 ②变体1：查找第一个值等于给定值的元素 ③变体2：查找最后一个值等于给定值的元素 ④变体3：查找第一个大于等于给定值的元素 ⑤变体4：查找最后一个小于等于给定值的元素
data structure_demo（数据结构）
01-08
一个数据结构的演示系统，一个数据结构的演示系统，一个数据结构的演示系统，一个数据结构的演示系统，一个数据结构的演示系统，一个数据结构的演示系统
数据结构(Java版)
Jrquen的博客
01-27 998
数据结构Java版(自学)
java初始化structure_Java类的初始化
weixin_42317730的博客
02-23 560
之前整理了《JVM之类加载机制》的文章，对于一个类的初始化阶段介绍太过简略，这里再开一篇文章，着重介绍类的初始化流程。类初始化是类加载过程的最后一个阶段，到初始化阶段，才真正开始执行类中的Java程序代码。虚拟机规范严格规定了有且只有四种情况必须立即对类进行初始化：遇到new、getstatic、putstatic、invokestatic这四条字节码指令时，如果类还没有进行过初始化，则需要先触发...
Java学习笔记一--从hello world开始
BeforeEasy的博客
10-17 686
1、 从hello world开始的Java—jdk编译，第一个Java程序 2、 IDE—eclipse建立工程和几个小技巧 3、 Java Structure – Java程序的结构 举例 4、 对象—创建对象和调用对象 从hello world开始的Java 首先要有Java的编译器，也就是Javajdk，并且得把相应的路径配置好（这个问题非常多的博客解释的比较清楚，这里不
java structure,讲解：Programming、Java、Java、StructureSPSS|R
weixin_35816287的博客
03-13 97
讲解：Programming、Java、Java、StructureSPSS|RProgramming Fundamentals, SP5 2019Assignment 2October 9, 2019IntroductionAssignment StructureOne thing that I have learnt in life is that farming simulators are...
Java02基础语法1--标识符
最新发布
09-01
在Java基础语法中，标识符是由程序员自己规定的代表一定含义的单词。标识符可以用于标识变量、方法、类等。主要注意的是，标识符不能修改，而且其中的main是一个特殊的标识符，无法自己规定。 在Java基础部分的相关知识讲解中，也包括了关于标识符的内容。 如果你想要判断一个字符串是否是合法的Java标识符，可以使用以下代码作为参考： ```java import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner reader = new Scanner(System.in); while (reader.hasNext()) { int flag = 1; String str = reader.nextLine(); char ch; ch = str.charAt(0); int len = str.length(); if (Character.isJavaIdentifierStart(ch)) { for (int i = 1; i < len; i++) { ch = str.charAt(i); if (!Character.isJavaIdentifierPart(ch)) { flag = 0; break; } } } else { flag = 0; } if (flag == 0) System.out.printf("false\n"); else System.out.printf("true\n"); } reader.close(); } } ``` 这段代码可以读取用户输入的字符串，并判断其是否是合法的Java标识符。如果是合法的标识符，则输出true，否则输出false。 希望以上内容能够帮助到你。如果还有其他问题，请随时提问。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [【零基础学Java】Day-02 基础语法--标识符](https://blog.csdn.net/qq_52681453/article/details/126020455)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *2* [Java基础[02-Java基础语法1].ppt](https://download.csdn.net/download/xiaoyoupei/13206691)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *3* [2021级-JAVA02 基础语法1--标识符、常量与变量、数据类型、运算符与表达式](https://blog.csdn.net/weixin_62455462/article/details/126696523)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

创作者mateo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值