Java入门 第八节面向对象（一）

已于 2022-11-03 22:45:07 修改
阅读量251 收藏
点赞数 1
分类专栏： Java入门基础阶段 文章标签： java 开发语言 后端
于 2022-02-18 18:15:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013280750/article/details/122849691
版权

文章目录

1. 啥是封装 ？

  1. 上一节了解了java中重要的概念，类和对象，也就算入门了思想编程阶段了，接下来也属于的编程思想上的延伸，我们java的核心思想是面向对象操作，既然是面向对象，就要了解面向对象的三大特征也是核心思想，封装，继承，多态。。
  2. 那么什么是封装 ？封装是指将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来对隐藏的信息进行操作和访问。
    • 可以理解为是将 属性和方法封装起来，而将属性和方法封装起来的载体就是 类。
  3. 列举生活中的一些例子：
    • 开车， 我们只要学会开就可以，不需要了解发动机是如何驱动的。
    • 电插座， 只需要知道如何使用即可，不需要直到里面电路集成原理。

1.1 封装好处

  1. 封装的好处： 保证了类的数据结构的完整性，使用该类，的用户不能轻易的操作数据结果，只允许操作公开的数据，就避免了对内部数据的影响，提高了程序的可维护性。
    • 只能通过规定的方法去访问数据。
    • 隐藏了实例细节，增加了数据安全性。
  2. 总结： 相当于把 功能封装进对象， 强调，对象具备了这样的功能！ 将变化隔离，提高重用性、提高安全性！

1.2 权限修饰符

  1. 用来控制类和类的 成员变量 以及 成员方法 的方法范围。
    • default :是没有修饰属性的时候，有默认为修饰。 只有同包类可以调用，子类不行。
修饰符本类同包其他类和子类不同包的类或子类
private可见看不可看不见
protected可见可见看不见
default（默认）可见可以（子类看不见）看不见
public可见可见可见

1.2.1 测试权限，在相同包下

  1. 在相同的包下，在这里插入代码片
package com.oop.var;

/**
 * 人类的属性
 *      实际开发中属性都是私有的private的。
 */
public class VarTest {

    private String name;  // 姓名

    protected int age; // 年龄

    char sex; // 性别  '男'，‘女’

    public String address; //地址


    /**
     * 测试方法 ： 吃  喝   玩   乐
     */

    private void eat(){
        System.out.println("方法： private eat输出");
    }

    void drink(){
        System.out.println("方法： 默认 drink输出");
    }

    public void  play(){
        System.out.println("方法： public play输出");
    }

    protected void happy(){
        System.out.println("方法：protected 输出 ");
    }

}
  • 相同包的测试类。
package com.oop.var;

public class VarTest01 {
    public static void main(String[] args) {
        //测试 同包 不同类
        VarTest vt3 = new VarTest();

        //方法 测试
        vt3.play(); //玩方法public
        vt3.drink(); // 默认
        vt3.happy(); // protected 修饰

        //属性 测试
        System.out.println(vt3.age);
        System.out.println(vt3.sex);  // 默认输出为 空字符
        System.out.println(vt3.address);

    }
}
  • 输出结果：
方法： public play输出
方法： 默认 drink输出
方法：protected 输出 
0
 
null

1.2.2 测试权限，在不相同包下

  1. 在不相同的包下测试权限范围。 上面接VarTest 类。
package com.oop.var2;

import com.oop.var.VarTest;

/**
 * 不同包 测试权限修饰
 *      public private protected 默认default
 */
public class VarTest2 {
    public static void main(String[] args) {
        // 使用类的对象 就需要实例化 new
        VarTest vt2 = new VarTest();
        //不同包里面只有public可以看见
        System.out.println(vt2.address);

        /*方法测试*/
        vt2.play();   // 直接输出方法，因为没有返回值

    }
}
  • 输出结果：
null
方法： public play输出

1.3 Get()方法和Set()方法使用

  1. 信息时代用户信息很重要，私有变量无法访问，关键字 private 去私有化变量，如果无法访问属性怎么办? 只能通过公共访问方法；
  1. 下面封装用户的信息。
/**
 * 用户类
 */
public class User {
    // 用户属性
    private String userName;  //private 私有用户 
    private int  age; // private 私有年龄

    //对外提供方法的方法 get方法
    public String getUserName(){
        return userName;
    }

    // 对外提供修改方法  set方法 
    public void setUserName(String name){
        userName=name; //相当于 this.name = name;
    }
  // 年龄对外提供
    public void setAge(int age){
        // 进行封装内部处理 ，来处理负数的问题
        if (0<=age||age>=100){
            userAge =age;
        }else{
            System.out.println("输入错误，请从新输入");
        }
    }

    public int getUserAge(){
        return userAge;
    }
}
  • 测试类：
  1. 只有对外提供方法，才能访问私有变量；
public class UserTest {
    public static void main(String[] args) {
        User u = new User(); //创建对象
        String userName = u.getUserName();
        System.out.println(userName);

        u.setUserName("周杰伦");
        System.out.println(u.getUserName());

       //如果设置 int 为负数？
        u.setAge(-20); // 年龄为负数？？ 怎么办？
        System.out.println(u.getUserAge()); // 输入0 是因为默认值
    }
}

输出结果：

null
周杰伦
输入错误，请从新输入
0  // 在调用了一次 getUserAge（） 默认值

1.4 封装并不单纯指 private

  1. 封装 并不是单纯指使用权限修饰符修饰属性和方法， 更广义的意思指将某些复杂的功能集成起来形成模块化，让使用者调用该模块即可。
    • 其作用增加了代码的复用性。
  2. 如案例：数组之前学过的根据元素查询该元素下的索引。
public class ArrayDemo {
    public static void main(String[] args) {

        //1.定义数组
        String[] arr = {"张三","李四","王五","赵六"};
        System.out.println("请输出查询元素： ");
        String arr2 = new Scanner(System.in).next();//匿名对象使用。

        //2.业务逻辑处理，如何通过元素获取下标。
        for (int i = 0; i <arr.length ; i++) {
           //2.1 判断
            if (arr2.equals(arr[i])){
                System.out.println(i);
                break;//如果查询出，跳出即可
            }
        }
    }
}
  • 这样的代码，没有将核心代码进行封装，造成了复用率低，使用者如果要查询索引，都得写一遍这个代码。并且核心代码也暴露了在外面。所以 广义上得封装，就是将核心代码封装起来对外提供访问方法即可。
public class ArrayDemo {
    public static void main(String[] args) {
        String[] arr = {"张三","李四","王五","赵六"};
        int resault = new Utils().seach_Index(arr, "王五"); //通过这一句话就可以调用。
        System.out.println(resault);
    }
}

//1.将方法进行封装。
class Utils{
    /**
     *
     * @param o 数组名
     * @param o1 传入查询元素
     * @return int 类型 -1没有查询到。
     */
    public  int seach_Index(Object[] o, Object o1 ){
        for (int i = 0; i <o.length ; i++) {
            if (o1.equals(o[i])){
                return i;
            }
        }
        return -1; //返回-1就是没有
    }
}

1.5 课堂练习：封装学生类信息

  1. 通过上述学习的封装思想，将学生类必要的属性封装起来，方便创建对象，调用对象使用。oop思想。
    • 使用get()和set()方法对外提供访问。
public class Students {
    //1. 私有化属性
    private String name;//姓名
    private int age;//年龄
    private String adress; //地址

    //2.对外提供访问方法get和set方法
    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 getAdress() {
        return adress;
    }

    public void setAdress(String adress) {
        this.adress = adress;
    }

    //3. 封装自己独特的方法例如 介绍自己
    public void introduce(){
        System.out.println("我的名字叫"+name+",年龄 "+age+",家在"+adress);
    }

}
  • 测试类，同包下。
public class Student_Test {
    public static void main(String[] args) {
        //1.创建对象1
        Students s = new Students();
        int age = s.getAge();
        System.out.println(age); //返回值是0，因为什么？

        //2.给属性赋值 通过set方法
        s.setName("张三");
        s.setAge(18);
        s.setAdress("北京");
        s.introduce();

        //2.创建对象2
        Students s2 = new Students();
        s2.setName("李四");
        s2.setAge(30);
        s2.setAdress("上海");
        s2.introduce();

        
    }
}

2. 构造函数

2.1 概述

  1. 构造方法和它所在类的名字相同，注意：不用定义返回值类型，即不用 void 修饰。
  2. 当一个对象被创建时候，就会 自动调用默认的空参构造方法。
    • 不管你是否自定义构造方法，所有的类都有默认的 空参构造方法，因为 Java 自动提 供了一个默认构造方法， 默认构造方法的访问修饰符和类的访问修饰符相同 (类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。
    • 一旦你定义了自己的构造方法（如含参数），默认的空参构造方法就会失效。
  3. 构造方法的作用：即给重要属性赋初始值。

2.2 语法结构

  1. 构造函数可以有参数，也可以没有参数。
  2. 默认的是空参数构造方法。
  3. 构造方法可以重载 （方法名相同，参数不同）。
	
	//修饰符 如果没有就是默认 default  
	修饰符 方法名(参数){ //方法名必须与类名一致。参数可由可无
		初始化;
	}

2.3 构造方法的使用

  1. 构造方法的作用是什么 ？ 什么时候调用构造方法？
    • 创建对象时，即new 会调用默认的空参构造方法，进行初始化赋值。
    	public class Student {
    private String name;
    private  int age;

    /**
     * java提供了一个默认的构造方法;
     */
    //1.空参数构造
    public Student() {
        //自己定义
        System.out.println("我是构造方法");
    }

    //2.一个参数构造
    public Student(String name) {
        //同时给可以赋值
        //age=10; 也可以给属性初始化值
        this.name = name;
    }

    //3.多参数构造
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //普通方法，输出属性
    public void introduce(){
        System.out.println("name="+name+" , age= "+age);
    }

	//main 方法程序入口
    public static void main(String[] args) {
        //1,调用的是无参数构造方法
        Student s1 = new Student();
        s1.introduce();

        //2.调用的是含参数构造方法
        Student s2 = new Student("张三", 30);
        s2.introduce();

        //3.调用的是单个参数构造方法
        new Student("李四").introduce();


    }
}

  • 输出结果：

    我是构造方法
name=null , age= 0
name=张三 , age= 30
name=李四 , age= 10

3. 代码块（静态代码块，构造代码块，局部代码块）

  1. 啥叫代码块？ 就是用 { }括起来的代码块；

    • 根据位置不同，分构造代码块 和 局部代码块。
    • 根据修饰符不同，如果被static关键字修饰的代码块，叫静态代码块，随着类的加载而加载。
    // Person{} 就是一个代码块 ，即{}就是代码块
class Person{
	public static void main(String[] args){

	}
}

3.1 构造代码块

  1. 构造代码块 。

    • 位置： 在 类的内部，方法外部，的代码块。
    • 作用： 通常用于抽取 构造方法中的共性代码。
    • 加载顺序：每次调用构造方法前都会调用构造代码块，优先于构造方法加载。

  2. 构造代码块案例。

public class Person {
    private String name; //名字
    private String country; //国家
    private String city; // 城市


    //4. 构造代码块，
    {
        country="中国";//初始化成员变量
        System.out.println("语言：汉语");
    }

    //5.set和get方法
    public void setCountry(String country) {
        this.country = country;
    }
    public String getCountry() {
        return country;
    }

    //1.空参构造方法
    public Person() {
        System.out.println("语言：汉语");
    }


    //2.带多个参数构造方法
    public Person(String name, String country, String city) {
        this.name = name;
        this.country = country;
        this.city = city;
        System.out.println("语言：汉语");
    }

    //3.带一个参数的构造方法
    public Person(String country) {
        this.country = country;
        System.out.println("语言：汉语");
    }

    public static void main(String[] args) {
        Person p = new Person();
        //new Person("中国");
        //没有调用set（）方法进行赋值。会输出什么？
        System.out.println(p.country);//输出中国，由构造代码块提前赋值。
        p.setCountry("China");
        System.out.println(p.getCountry());//输出China，有set方法更改了值。
    }

}

  • 输出结果：

    语言：汉语
语言：汉语
中国
China

3.2 局部代码块

  1. 局部代码块。
    • 位置： 在方法里面的代码块。
    • 作用： 通常用于控制变量的作用范围，出了括号就失效。
    • 加载顺序： 构造代码块是最优先的，然后局部代码块当方法调用时才会执行。
  2. 局部代码块。
    public class Person2 {
    private  int age;

    //1.普通方法
    public void init(){

        {
            int age=10;//优先于加载局部代码块的值age
            System.out.println("我是局部代码块 "+age);
        }
        System.out.println(age);// 成员变量的age
    }

    public static void main(String[] args) {
        Person2 p = new Person2();
        p.init();

    }
}

  • 输出结果：

    我是局部代码块 10
0

3.3 静态代码块

  1. 被关键字 static修饰的代码块，就是静态代码块。
    • 位置： 在类里，方法外。
    • 作用： 一般用于加载项目驱动（加载配置文件），或者项目初始化。
    • 加载顺序： 优先于类的加载而加载，只加载一次。
  2. 静态代码块。
public class Person3 {
    //private  String IP;//ip地址
     private static  String hostName;// 主机地址
    //1.空参构造方法
    public Person2() {
        System.out.println("我是构造方法");
    }

    //2.作用，在类的加载之前加载，提前加载配置文件。
    static {
        hostName ="192.168.1.1";//静态代码块只能给静态属性赋值;
        System.out.println("我是静态代码块");
    }


    public void conn(){
        String ip ="192.168.1.1";//数据接口
        if (ip.equals(hostName)){
            System.out.println("连接成功");
        }else {
            System.out.println("连接失败");
        }

    }

    public static void main(String[] args) {

        new Person3().conn();
        System.out.println("-----------");
        new Person3();//第二次就不会调用，只加载一次。

    }
}

  • 输出结果：

    我是静态代码块
我是构造方法
连接成功
-----------
我是构造方法

3.4 代码块的执行顺序

  1. 静态代码块 > 构造代码块> 构造方法>局部代码块
public class Person4 {

    public void init(){
        {
            System.out.println("局部代码块");
        }
    }

    {
        System.out.println("构造代码块");
    }

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

    public Person4(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        new Person4();

        //1.局部代码块只有在调用方法时才会执行
        // new Person4().init();
    }
}

  • 输出结果：

    静态代码块
构造代码块
构造方法

4. this关键字

4.1 概述

  1. java里面 this 是指 本身 的意思,当前类，本类对象的一个引用对象。
  2. 形参与成员变量重名时，可以用this关键字来区分？
    • 是不是很熟悉这句话？哪见过？ set() 和 get() 方法。
  3. 只能在构造函数中使用。
    • this(); 必须放在第一行。

4.2 使用场景

4.2.1 练习：区分变量名相同

  1. 区分同名参数，this 相当于本类调用。
    public class Test_this {

    private String name;

    //构造方法
    public Test_this(){
        System.out.println("空参构造方法");
    }

    //1.类似于 set赋值方法。
    public void setName1(String name1){
        name = name1; // 给成员变量赋值
    }

    public void setName(String name) {
        //形式参数名称和成员变量名称相同时，使用this区别，相当于 Test_this.name=name;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    //2. 普通方法
    public void info(){
        System.out.println(this.getName());//相当于 Test_this.getName();
    }

    public static void main(String[] args) {
        new Test_this();
        Test_this t = new Test_this();
        t.setName1("张三");
        //打印输出name值
        System.out.println(t.getName());
        t.info();


    }
}

  • 输出结果：

    空参构造方法
空参构造方法
张三
张三

4.2.2 练习：构造方法调用

  1. this(参数)，相当于调用类中的构造方法， 但是必须放在第一行。
  2. 并且在类中，只能出现一个this() ；
    • 不能同时在两个构造方法中使用this();
public class Test_this {

    private String name;

    //1.空参构造方法
    public Test_this(){
        this("张三"); //只能出现一个this（）引用构造函数。
        System.out.println("空参构造方法");
       // this(""); //必须放在首行。
    }

   //2.含参数构造方法
    public Test_this(String name) {
        //this();  //只能出现一个this();引用的构造函数
        this.name = name;
        System.out.println("含参数构造函数");

    }

    public String getName() {
        return name;
    }

    public static void main(String[] args) {
        String name = new Test_this().getName();//通过调用含参构造方法赋值
        System.out.println(name);
    }
}

  • 输出结果：

    含参数构造函数
空参构造方法
张三

4.3 比较两个人的名字是否相同

  1. 创建两个对象比较它们之间的年龄是否相等。
    • 使用this 关键字。
public class Test_this {
    private int age;

    public int getAge() {
        return age;
    }

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


    //2.当使用this之后的写法
    public Boolean compare2(Test_this t){
        return this.getAge() == t.getAge();//不同包下可以方法

        //return this.age == t.age;  //本类方法私有。
    }

    public static void main(String[] args) {
        Test_this t = new Test_this();
        t.setAge(18);

        Test_this t2 = new Test_this();
        t2.setAge(18);



        Boolean compare = t.compare2(t2);
        System.out.println(compare);
    }
}
吴琼老师
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java面向对象（七）
m0_53452634的博客
07-25 85
主要介绍static关键字的使用，单例模式的两种写法，类的成员之四：代码块的使用以及final关键字的使用
Java入门 第十一节 内部类
云深不知处
05-01 568
内部类 1.概述
Java新手小白入门篇 Java面向对象（一）
weixin_46030002的博客
08-09 886
Java面向对象（第一天）类，对象，方法的重载，练习题
java面向对象最全入门笔记(通俗易懂，适合初学者)
热门推荐
javaboy_yl
11-14 1万+
一、为什么使用面向对象 前言: 面向对象的三大特征 封装 (Encapsulation) 继承 (Inheritance) 多态 (Polymorphism) 编程思想： 面向过程：做某件事情都需要自己亲历亲为，按照步骤去完成 面向对象：做某件事情不需要自己亲历亲为，只需指定特定的对象去完成即可。 1.现实世界就是由对象组成的，如下图，万物皆对象(不是单指女朋友也不是单指男朋友哈~) 2.面...
完整版 Java编程基础入门教程 Java语言程序设计 第3章_面向对象程序设计基础（共16页）.ppt
12-18
Java编程基础入门教程的第三章主要讲解了面向对象程序设计的基础知识。面向对象编程（OOP）是一种基于对象和类的编程范式，它强调通过模拟现实世界中的实体及其交互来构建软件系统。以下是该章节的主要知识点： 1. ...
java入门第一课
05-27
Java入门第一课主要针对初学者，旨在提供一个良好的起点，帮助理解Java编程语言的基本概念和语法。这个课程可能源自GitHub上的一个开源项目，因此，它应该是动态更新的，随着学习者的需求和技术的发展而不断丰富。 ...
Java面向对象程序设计
03-17
1. **第1章：Java入门** - **Java简介**：Java是由Sun Microsystems开发的一种高级编程语言，现由Oracle公司维护，广泛应用于服务器端开发、移动应用、嵌入式系统等。 - **JVM**：Java虚拟机是Java程序运行的平台...
跟汤老师学Java（第8季）：面向对象
06-12
本课程从零开始，以通俗易懂的方式讲解Java入门，手把手教你掌握每一个知识点，真正做到零基础入门学习，最适合初学者的教程！课程内容包括：1.面向对象简介2.类的使用3.this关键字4.static关键字5.方法重载6.构造...
第章Java入门hx0ppt课件.ppt
11-12
2. **面向对象**：Java完全支持面向对象编程，包括类的继承、封装和多态性，不支持传统的面向过程编程。 3. **解释执行**：Java代码首先被编译为字节码，然后由Java虚拟机（JVM）解释执行。 4. **平台无关性**：...
golang 接口
m0_70982551的博客
07-24 963
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 517
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 658
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 595
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 367
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 429
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 863
java、数据类型、循环、选择等
新建springboot项目找不到java版本8?
最新发布
weixin_74009895的博客
07-28 102
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 188
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
Java入门经典：从控制结构到面向对象第六版
《从控制结构到面向对象：初识Java第六版》是一本针对Java编程语言入门的经典教材。本书由Tony Gaddis撰写，旨在帮助读者系统地掌握Java的基本概念和技术，从基础的控制结构（如循环、条件语句）开始，逐步深入到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

吴琼老师

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

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

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

打赏作者

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

抵扣说明：

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

余额充值