JavaSE04、什么是类和对象，如何使用？

最新推荐文章于 2024-05-02 11:11:16 发布
最新推荐文章于 2024-05-02 11:11:16 发布
阅读量3.1k 收藏 5
点赞数 14
分类专栏： JavaSE 文章标签： java 开发语言 后端 类和对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56884023/article/details/121128375
版权

一、定义一个类

类名命名：大驼峰
包括：字段、成员方法

class Person {
    //字段 -> 属性 -> 成员变量
    // --> 类的内部，方法的外部

    // 成员变量：1. 普通成员变量，2. 静态成员变量
    public String name = "gaobo";
    public int age = 18;

	// 一个对象存储到哪里，和被final修饰无关
    public final int size1 = 10; // 对象中
    public static final int size2 = 20; // 方法区
	
    // 成员方法
    // 1. 成员变量：普通成员方法，静态成员方法
    public void eat() {
        System.out.println(name+" 正在吃饭");
    }

    public void sleep() {
        System.out.println(name+" 正在睡觉");
    }
}

二、成员变量

1、怎样访问成员变量

普通成员变量的访问需要通过对象的引用
由 类 产生 对象 的过程：实例化，用new
由类Person实例化了一个对象

class Person {

    public String name = "gaobo";
    public int age = 18;

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

    public void sleep() {
        System.out.println(name+" 正在睡觉");
    }
}

public class TestDemo {
	public static void main(String[] args) {
        // 由类定义的变量：引用变量
        Person person1 = null;

        Person person2 = new Person();
    }
}

2、局部变量，成员变量

  • 局部变量没有赋初值，打印报错
  • 成员变量如果没有赋值，打印的name是null，而age是0

成员变量没有赋初值的默认值：

 *                         整数   byte short int long（默认值：0）
 *                         浮点数 float double（默认值：0.0）
 *          基本数据类型     字符   char（默认值：'\u0000'）
 *                         布尔   boolean（默认值：false）
 * 数据类型
 *          引用类型        String  数组 类 接口 枚举……（默认值：null）
 *

以下打印null：

class Person {

    public String name;
    public int age;

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

    public void sleep() {
        System.out.println(name+" 正在睡觉");
    }
}

public class TestDemo {
    public static void main(String[] args) {

        Person person = new Person();
        System.out.println(person.name);
    }
}

3、每个对象都有 name age

class Person {

    public String name;
    public int age;

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

    public void sleep() {
        System.out.println(name+" 正在睡觉");
    }
}

public class TestDemo {
    public static void main(String[] args) {

        Person person = new Person();
        person.name = "bit";
        person.age = 10;
        System.out.println(person.name); // bit
        System.out.println(person.age); // 10
        System.out.println("=======================");

        Person person2 = new Person();
        System.out.println(person2.name); // null
        System.out.println(person2.age); // 0
    }
}

在这里插入图片描述

三、成员方法

1、成员方法的访问

class Person {

    public String name;
    public int age;

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

    public void sleep() {
        System.out.println(name+" 正在睡觉");
    }
}

public class TestDemo {
    public static void main(String[] args) {

        Person person = new Person();
        person.eat(); // gaobo 正在吃饭
        person.sleep(); // gaobo 正在睡觉
    }
}

四、静态成员

字段-属性-成员变量：
1.普通成员变量
2.静态成员变量 --> 类名.静态的成员属性/方法

class Person {

    //  普通的成员变量 -都是属于对象的
    public String name; // 实例变量 存放在对象内
    public int age;

    // 静态成员变量 -类变量 -> 方法区
    public static int count;

    public void eat() {
        System.out.println(name+"正在吃饭！");
    }
    public void sleep() {
        System.out.println(name+"正在睡觉！");
    }
}

1、方法区

class Person {
    public String name; 
    public int age;

    // 静态成员变量 -类变量 -> 方法区
    public static int count;
}    

public class TestDemo {
    public static void main3(String[] args) {
        Person person1 = new Person();
        person1.count++;
        System.out.println(Person.count); // 1

        System.out.println("===================");

        Person person2 = new Person();
        person2.count++;
        System.out.println(Person.count); // 2
    }

    public static void main2(String[] args) {
        Person person1 = new Person();
        person1.age++;
        System.out.println(person1.age); // 1

        System.out.println("===================");

        Person person2 = new Person();
        person2.age++;
        System.out.println(person2.age); // 1
    }

    public static void main1(String[] args) {
        Person person = new Person();
        person.count = 1999;
        System.out.println(person.count); // 1999
    }
}

在这里插入图片描述

2、访问静态成员变量

class Person {
    public String name; 
    public int age;

    // 静态成员变量 -类变量 -> 方法区
    public static int count;
}    

public class TestDemo {
    public static void main(String[] args) {
        /*Person person1 = new Person();
        person1.count++;*/

        // 通过类名访问静态成员变量
        // 类名.静态的成员属性/方法
        // 不需要new两个对象 节省了2个对象的空间
        Person.count++;
        System.out.println(Person.count); // 1

        System.out.println("===================");

        /*Person person2 = new Person();
        person2.count++;*/
        Person.count++;
        System.out.println(Person.count); // 2
        // 方法区
    }
}

2、访问静态方法：直接用类名

class Person {
    public void eat() {
        System.out.println(name+" 正在吃饭");
    }
	
	// 类方法/静态方法
    public static void staticFunc() {
        System.out.println("static::func()");
    }
}    

public class TestDemo {
    public static void main(String[] args) {
        // 访问静态方法：直接用类名
        Person.staticFunc();

        // 需要引用指向对象
        Person p = new Person();
        p.eat();
    }
}

3、注意事宜

① 普通的方法内部，不能定义静态的变量
  1. static 定义的变量，是类变量，属于类
  2. eat方法的调用，需要对应的引用来调用，但是如果可以定义static的变量，类名Person就可以调用
class Person1 {
    public String name;
    public int age;

    public static int count;

    public void eat() {
        // static int size = 0; // err
        System.out.println(name+"正在吃饭！");
    }
}

public class TestPerson {

    public static void main(String[] args) {
    
    }
}
② 静态的成员变量，是不可以在方法中定义的
class Person1 {
    public String name;
    public int age;

    public static int count;

    // 类方法/静态方法
    public static void staticFunc1() {
        
        // static int size = 0; // err
        count = 1; // 可以赋值静态成员变量
    }
}

public class TestPerson {

    public static void main(String[] args) {
    
    }
}
③ 普通方法内部，可以调用静态的方法
class Person {
    public String name;
    public int age;

    public static int count;

    public void sleep() {

        // 普通方法依赖于对象，静态方法不依赖对象
        staticFunc();
        System.out.println(name+"正在睡觉！");
    }
	
	// 类方法/静态方法
	public static void staticFunc() {
        System.out.println("static::func()");
    }
}

public class TestPerson {

    public static void main(String[] args) {
    	Person person = new Person();
        p.sleep();
    }
}
④ 静态方法内部，不能调用普通方法
class Person1 {
    public String name;
    public int age;

    public static int count;

    public void sleep() {
        System.out.println(name+"正在睡觉！");
    }
	
	// 类方法/静态方法
	public static void staticFunc() {
        // 通过类名就可以调用静态方法，而普通方法需要对象
        // sleep(); // err
        System.out.println("static::func()");
    }
}

public class TestPerson {

    public static void main(String[] args) {
    
    }
}
例1：
public class TestPerson {

    public static void func1() {

    }
    public void func2() {

    }
    
public class TestDemo {
    public static void main(String[] args) {
    	func1(); // ok

        // func2(); // err 普通成员方法需要对象
        TestDemo testDemo = new TestDemo();
        testDemo.func2(); // ok
    }
}
main函数为什么是静态的

main是不是静态的都可以，取决于JVM如何实现的

例2：
class Test{
    public int a;
    public static int count;
}

public class Main{

    public static void main(String[] args) {
        Test t1 = new Test();
        t1.a++; // 1
        Test.count++; // 1
        System.out.println(t1.a); // 1
        System.out.println(Test.count); // 1

        System.out.println("============");

        Test t2 = new Test();
        t2.a++; // 1
        Test.count++; // 2
        System.out.println(t2.a); // 1
        System.out.println(Test.count); // 2
    }

}

五、引用

1、null

public class TestDemo {    

    public static void main(String[] args) {
    	Person person = null; // 此引用不指向任何对象
    }
}

2、该引用指向？

public class TestDemo {    

    public static void main(String[] args) {
    	Person person = new Person();
        Person person1 = person; // person1这个引用指向person这个引用所指向的对象
    }
}

3、一个引用能否同时指向多个对象？

public class TestDemo {    

    public static void main(String[] args) {
    	// 一个引用不能同时指向多个对象
        Person person = new Person();
        person = new Person();
        person = new Person();
        person = new Person();
        person = new Person(); // 最后一次
    }
}

4、引用一定在栈上吗？

不一定

public class TestDemo {    

	// 成员变量
    Person person = new Person();

    public static void main(String[] args) {
    	TestDemo testDemo = new TestDemo();
        Person person = new Person();
    }
}

在这里插入图片描述

🍳

六、toString

方法会在 println 的时候被自动调用
序列化：对象转成字符串

class Person {
    /*    public String toString() {
        return "姓名："+name+" 年龄"+age;
    }*/

    // 右击generate toString
    // 重写Object的toString方法
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class TestDemo {    
    public static void main(String[] args) {
    	Person person = new Person();
        System.out.println(person); // Person@1b6d3586
        // 打印此引用的值 toString
    }
}

自动生成：
右击generate toString
重写Object的toString方法
在这里插入图片描述

七、封装

1、什么是封装

在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者.
封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了.
这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度

被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用

封装：只能在当前类使用 -安全

2、getter和setter方法

如果name被private修饰，就只能在当前类中使用
需要获取或者修改这个 private 属性，就需要使用getter和setter方法

class Person {

    private String name;
    /*
    public String getName() {
        return name;
    }
    public void setN(String myN) {
        name = myName;
    }*/
    
    // 右击generate Getter Setter
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name; //this引用 代表**当前对象的引用**
    }
}

public class TestDemo {
	public static void main(String[] args) {

        Person person = new Person();
        // 赋值
        person.setN("bit");
        // 获取
        System.out.println(person.getN()); // bit
    }
}

在这里插入图片描述

3、注意问题

  1. getName 即为 getter 方法, 表示获取这个成员的值
  2. setName 即为 setter 方法, 表示设置这个成员的值
  3. 当set方法的形参名字和类中的成员属性的名字一样的时候，如果不使用this, 相当于自赋值. this 表示当前实例的引用

八、构造方法

构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作

方法名称与类名称相同，且构造方法比较特殊，没有返回值
构造方法是干什么的 -> 一个对象的产生/实例化new 需要：
1.为对象分配内存空间
2.调用合适的构造方法 --（构造方法不止一个）

class Person {
    // 构造方法
    public Person() {
        System.out.println("Person()::不带参数的构造方法");
    }
    public Person(String name) {
        this.name = name;
        System.out.println("Person(String)::带一个String 类型参数的构造方法");
    }
    // 重载
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Person(String)::带2个String 类型参数的构造方法");
    }
}

public class TestDemo {
	public static void main13(String[] args) {

        Person person = new Person(); // Person()::不带参数的构造方法

        System.out.println("=====================");
        /*
        1. 如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数
        一个类，至少会有一个改造方法
        2. 若类中定义了其他构造方法，则编译器默认生成的无参构造将不再生成
        3. 构造方法支持重载（方法名称相同，参数列表不同，返回值不做要求）. 规则和普通方法的重载一致
         */

        // 在实例化对象时，调用了构造方法
        // 同时会给name传值
        Person person1 = new Person("bit"); // Person(String)::带一个String 类型参数的构造方法

        System.out.println("======================");

        Person person2 = new Person("bit", 19); // Person(String)::带2个String 类型参数的构造方法
    }
}

九、this关键字

注意：this代表当前对象——err
调用完构造方法才会实例化生成对象，this只代表为对象分配内存空间，第二步还未完成，

  1. this.data --> 调用当前对象的属性
  2. this.func() --> 调用当前对象的方法 (静态方法里不能用this)
  3. this() --> 调用当前对象的其他构造方法
    只能存放在构造方法中
class Person {

    public String name;
    public int age;

    public Person() {
        // this调用构造函数
        // 必须放在第一行
        this("zhangsan"); // ->调用带有一个参数的构造方法
        System.out.println("Person()::不带参数的构造方法");
    }
    public Person(String name) {
        this.name = name; // 给name赋值
        System.out.println("Person(String)::带一个String 类型参数的构造方法");
    }
}

public class Print {

    public static void main(String[] args) {
        Person person = new Person(); // ->调用不带参数的构造方法
        // Person(String)::带一个String 类型参数的构造方法
        // Person()::不带参数的构造方法
        System.out.println(person);
        // Person{name='zhangsan', age=0}
    }
}

十、代码块

1、四种代码块

本地代码块，实例代码块，静态代码块，同步代码块

class Person {
    
    {
        this.age = 50; // 实例代码块可以实例数据成员 静态代码块不能
        System.out.println("实例代码块");
    }
    
    static {
        System.out.println("静态代码块");
    }
}

public class TestDemo {
    public static void main(String[] args) {

        {
			// 本地代码块
        }
    }
}

2、代码块是如何被调用的

运行此代码

class Person {

    {
        System.out.println("实例代码块");
    }
    
    static {
        System.out.println("静态代码块");
    }
}

public class TestDemo {
	public static void main(String[] args) {
		Person person1 = new Person();
		/**打印：
         * 静态代码块
         * 实例代码块
         * Person()::不带参数的构造方法
         */
		
		System.out.println("====================");
        Person person2 = new Person();
        /**
         * 第二次实例化对象：
         * 静态代码块
         * 实例代码块
         * Person()::不带参数的构造方法
         * ====================
         * 实例代码块
         * Person()::不带参数的构造方法
         */
	}
}

静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
静态代码块不用实例化 就可以被执行 （类加载的时候）

3、静态变量test打印多少？

test打印10还是99

class Person {

    public static int test = 10;
    
    {
        System.out.println("实例代码块");
    }
    
    static {
        test = 99;
        System.out.println("静态代码块");
    }
}

public class TestDemo {
    public static void main(String[] args) {

        System.out.println(Person.test);
        // 99
        // 如果都是静态的，和定义的顺序有关
        // 字段在前 99
        // 静态代码块在前 10
        // 如果test没有初始化默认值0：
        // 字段在前 99
        // 静态代码块在前 99
    }
}

在这里插入图片描述

十一、匿名对象

没有引用的对象称为匿名对象.
匿名对象只能在创建对象时使用.
如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象

class Person {
	public String name;

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

    public void sleep() {
        System.out.println(name+" 正在睡觉");
    }
}

public class TestDemo {
    public static void main(String[] args) {

        // 一次性
        new Person().eat(); // new对象 调用eat
        new Person().sleep();
        System.out.println(new Person());
        System.out.println("==============");

        // 只用一次对象
        Person person1 = new Person();
        person1.eat();
        person1.sleep();
        System.out.println(person1);
    }
}

十二、用类编写代码：

1、编写一个类Calculator

编写一个类Calculator,有两个属性num1,num2,这两个数据的值，不能在定义的同时初始化，最后实现加减乘除四种运算.

class Calculator {
    private int num1;
    private int num2;

    public int getNum1() {
        return num1;
    }

    public void setNum1(int num1) {
        this.num1 = num1;
    }

    public int getNum2() {
        return num2;
    }

    public void setNum2(int num2) {
        this.num2 = num2;
    }

    public int add() {
        return num1 + num2;
    }
    public int sub() {
        return num1 - num2;
    }
    public int mul() {
        return num1 * num2;
    }
    public double dev() {
        return num1*1.0 / num2;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        calculator.setNum1(1);
        calculator.setNum2(2);
        System.out.println(calculator.add());
    }
}

2、实现交换两个变量的值。要求：需要交换实参的值

class MyValue {
    public int val;
}

public class TestDemo {

    public static void swap(MyValue myV1, MyValue myV2) {
        int tmp = myV1.val;
        myV1.val = myV2.val;
        myV2.val = tmp;
    }

    public static void main(String[] args) {
        MyValue myValue1 = new MyValue();
        myValue1.val = 10;

        MyValue myValue2 = new MyValue();
        myValue2.val = 20;

        swap(myValue1, myValue2);
        System.out.println(myValue1.val+" "+ myValue2.val); // 20 10
    }
}
三春去后诸芳尽
关注
  • 14
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
Java面向对象和工具类
06-26
java 面向对象的重难点知识以及常用的工具类的使用
西安云工厂xaygc.com_JavaSE_04类与对象_旺旺老师
09-22
学习java,讲的很不错
浅谈类与对象
weixin_52528821的博客
01-04 103
一、为什么要面对对象。 面向过程的思想 1、步骤简单清晰，分析出解决问题的步骤，第一步做什么，第二步做什么···，再用方法逐一实现 2、面向过程适合处理一些简单的问题 面向对象的思想 1、 ...
如何理解和使用对象与类？
绿薄荷的博客
01-19 171
类和对象有什么关系？ 如何创建一个对象？ 如何使用类中的变量和方法？ 构造方法如何使用？
【JavaSE】JavaSE之类和对象（上）
bit me的博客
09-21 1297
JavaSE之类和对象前半部分知识，庖丁解牛式带你深入学习~~
【JavaSE】JavaSE之类和对象（下）
bit me的博客
09-24 2448
JavaSE类和对象后半部分讲解，让类和对象手到擒来供你使用~~
JAVASE.面向对象(1)
12-22
面向对象基础内容1面向对象的概念1.1类的定义格式1.2如何通过类创建对象1.3封装1.3.1封装的步骤1.4构造器1.4.1构造器的作用1.5this关键字1.6匿名对象2继承2.1继承的概念2.2继承的含义2.3继承的好处2.4类的继承格式...
06_javaSE复习之面向对象准备阶段
04-24
什么是面向对象、如何定义类、如何定义对象、成员变量、局部变量、静态变量、匿名对象、Math.randon()/this/static 代码块(局部代码块、构造代码块、静态代码块、同步代码块) 、java内存结构
浅谈javaSE 面向对象(Object类toString)
09-02
下面小编就为大家带来一篇浅谈javaSE 面向对象(Object类toString)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 1251
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 1099
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
yajunjiao的专栏
04-30 471
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
Spring Cloud——LoadBalancer
????
05-01 1164
这里只是简单的讲解了一下LoadBalancer如何使用，因为实际上我们使用的不是很多，主要还是使用OpenFeign。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1065
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
Java解决最长公共前缀
无人罪的博客
04-28 371
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 883
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
Spring cloud原理详解
qq_33449977的博客
04-28 462
想象一下，你开了一家餐馆，一开始只卖汉堡，后来生意火了，你又增加了炸鸡、披萨、冰淇淋各种摊位，每个摊位就是一个微服务，它们各自独立工作，但又得相互配合。有时候，某个服务可能太忙了，电话老打不通，这时候Spring Cloud还有个叫Hystrix的断路器，它会说：“嘿，别打了，那边线路忙，我给你个备用方案或者告诉你稍后再试。至于餐馆运营情况，Spring Cloud Sleuth和Zipkin这些工具，就像监控摄像头，记录服务间的每一次交互，方便你查看哪里出了问题，优化服务流程。
软件工程毕业设计选题100例
最新发布
HUXINY的博客
05-02 805
学长搜集分享最新的软件工程业专业毕设选题，难度适中，适合作为毕业设计，大家参考。相对容易工作量达标题目新颖。
java SE的内容有什么_JavaSE包含哪些内容？JavaEE呢？
06-07
JavaSE是Java Standard Edition的缩写，包含了Java语言的基础类库和开发工具，主要包括以下内容： 1. Java语言基础：基本语法、数据类型、运算符、控制流语句等； 2. 面向对象编程：类、对象、继承、多态、接口等； 3. Java API类库：集合框架、I/O流、网络编程、多线程、反射、异常处理等； 4. Java开发工具：JDK、Eclipse、NetBeans、IntelliJ IDEA等。 JavaEE是Java Enterprise Edition的缩写，是在JavaSE的基础上扩展而来，用于开发企业级应用程序，主要包括以下内容： 1. Web应用程序开发：Servlet、JSP、JSF、Web Services等； 2. 分布式应用程序开发：EJB、JMS、JTA、JPA等； 3. 安全性和身份验证：JAAS、JACC、JASPIC等； 4. 大型数据处理和分析：Hadoop、Spark等； 5. 前端技术：HTML、CSS、JavaScript等。 JavaSE和JavaEE都是Java平台的不同版本，JavaSE是基础版，JavaEE是高级版。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

三春去后诸芳尽

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

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

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

打赏作者

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

抵扣说明：

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

余额充值