首页 JavaSE

# 类和对象

# 类和对象的理解

  • 类
    • 类是对现实生活中一类具有共同属性和行为的事物的抽象
    • 类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
    • 简单理解：类就是对现实事物的一种描述
    • 类的组成
      • 属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）
      • 行为：指事物能执行的操作，例如：手机事物（打电话，发短信）
  • 类和对象的关系
    • 类：类是对现实生活中一类具有共同属性和行为的事物的抽象
    • 对象：是能够看得到摸的着的真实存在的实体
    • 简单理解：类是对事物的一种描述，对象则为具体存在的事物

# 类的定义

类的组成是由属性和行为两部分组成

  • 属性：在类中通过成员变量来体现（类中方法外的变量）
  • 行为：在类中通过成员方法来体现（和前面的方法相比去掉 static 关键字即可）

类的定义步骤：

①定义类

②编写类的成员变量

③编写类的成员方法

public class 类名 {
	// 成员变量
	变量1的数据类型 变量1；
	变量2的数据类型 变量2;
	…
	// 成员方法
	方法1;
	方法2;	
}

示例代码：

/*
    手机类：
        类名：
        手机 (Phone)
        成员变量：
        品牌 (brand)
        价格 (price)
        成员方法：
        打电话 (call)
        发短信 (sendMessage)
 */
public class Phone {
    // 成员变量
    String brand;
    int price;
    // 成员方法
    public void call() {
        System.out.println("打电话");
    }
    public void sendMessage() {
        System.out.println("发短信");
    }
}
# 对象的使用
  • 创建对象的格式：
    • 类名 对象名 = new 类名 ();
  • 调用成员的格式：
    • 对象名。成员变量
    • 对象名。成员方法 ();
  • 示例代码
/*
    创建对象
        格式：类名 对象名 = new 类名 ();
        范例：Phone p = new Phone ();
    使用对象
        1：使用成员变量
            格式：对象名。变量名
            范例：p.brand
        2：使用成员方法
            格式：对象名。方法名 ()
            范例：p.call ()
 */
public class PhoneDemo {
    public static void main(String[] args) {
        // 创建对象
        Phone p = new Phone();
        // 使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);
        p.brand = "小米";
        p.price = 2999;
        System.out.println(p.brand);
        System.out.println(p.price);
        // 使用成员方法
        p.call();
        p.sendMessage();
    }
}
# 学生对象 - 练习
  • 需求：首先定义一个学生类，然后定义一个学生测试类，在学生测试类中通过对象完成成员变量和成员方法的使用
  • 分析：
    • 成员变量：姓名，年龄…
    • 成员方法：学习，做作业…
  • 示例代码：
class Student {
    String name;
    int age;
    public void study() {
        System.out.println("好好学习，天天向上");
    }
    public void doHomework() {
        System.out.println("键盘敲烂，月薪过万");
    }
}
public class StudentDemo {
    public static void main(String[] args) {
        // 创建对象
        Student s = new Student();
        // 使用对象
        System.out.println(s.name + "," + s.age);
        s.name = "林青霞";
        s.age = 30;
        System.out.println(s.name + "," + s.age);
        s.study();
        s.doHomework();
    }
}
# 成员变量和局部变量
# 区别
  • 类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
  • 内存中位置不同：成员变量（堆内存）局部变量（栈内存）
  • 生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失）
  • 初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）
# 封装
# private 关键字
private 是一个修饰符，可以用来修饰成员（成员变量，成员方法）
  • 被 private 修饰的成员，只能在本类进行访问，针对 private 修饰的成员变量，如果需要被其他类使用，提供相应的操作
    • 提供 “get 变量名 ()” 方法，用于获取成员变量的值，方法用 public 修饰
    • 提供 “set 变量名 (参数)” 方法，用于设置成员变量的值，方法用 public 修饰
  • 示例代码：
    class Student {
        // 成员变量
        String name;
        private int age;
        // 提供 get/set 方法
        public void setAge(int a) {
            if(a<0 || a>120) {
                System.out.println("你给的年龄有误");
            } else {
                age = a;
            }
        }
        public int getAge() {
            return age;
        }
        // 成员方法
        public void show() {
            System.out.println(name + "," + age);
        }
    }
    # this 关键字
    • this 修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
      • 方法的形参如果与成员变量同名，不带 this 修饰的变量指的是形参，而不是成员变量
      • 方法的形参没有与成员变量同名，不带 this 修饰的变量指的是成员变量
public class Student {
    private String name;
    private int age;
    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);
    }
}
# this 内存原理
  • this 代表当前调用方法的引用，哪个对象调用的方法，this 就代表哪一个对象
# 封装思想
  1. 封装概述
    是面向对象三大特征之一（封装，继承，多态）
    是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
  2. 封装原则
    将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
    成员变量 private，提供对应的 getXxx ()/setXxx () 方法
  3. 封装好处
    通过方法来控制成员变量的操作，提高了代码的安全性
    把代码用方法进行封装，提高了代码的复用性
# 构造方法
# 构造方法概述
构造方法是一种特殊的方法
  • 作用：创建对象 Student stu = new Student();
  • 功能：主要是完成对象数据的初始化
  • 示例代码：
class Student {
    private String name;
    private int age;
    public Student() {
        System.out.println("无参构造方法");
    }
    public void show() {
        System.out.println(name + "," + age);
    }
}
public class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.show();
    }
}
# 构造方法的注意事项
  • 构造方法的创建
    如果没有定义构造方法，系统将给出一个默认的无参数构造方法
  • 构造方法的重载
如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法
  • 推荐的使用方式
无论是否使用，都手工书写无参数构造方法
  • 重要功能！
可以使用带参构造，为成员变量进行初始化
# 标准类制作
  • 需求：定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过 setXxx 赋值，有参创建的对象直接赋值，并通过 show 方法展示数据。
  • 示例代码：
class Student {
    // 成员变量
    private String name;
    private int age;
    // 构造方法
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 成员方法
    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);
    }
}
/*
    创建对象并为其成员变量赋值的两种方式
        1: 无参构造方法创建对象后使用 setXxx () 赋值
        2: 使用带参构造方法直接创建带有属性值的对象
*/
public class StudentDemo {
    public static void main(String[] args) {
        // 无参构造方法创建对象后使用 setXxx () 赋值
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();
        // 使用带参构造方法直接创建带有属性值的对象
        Student s2 = new Student("林青霞",30);
        s2.show();
    }
}
# API
# API 概述
  • 什么是 API
    ​	API (Application Programming Interface) ：应用程序编程接口
  • java 中的 API
    ​	指的就是 JDK 中提供的各种功能的 Java 类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些 API 如何使用。
# String 类
# String 类概述
​	String 类代表字符串，Java 程序中的所有字符串文字（例如 “abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！
# String 类的特点
  • 字符串不可变，它们的值在创建后不能被更改
  • 虽然 String 的值是不可变的，但是它们可以被共享
  • 字符串效果上相当于字符数组 (char [] )，但是底层原理是字节数组 ( byte [] )
# String 类的构造方法
  • 常用的构造方法
    方法名说明
    public String()创建一个空白字符串对象，不含有任何内容
    public String(char[] chs)根据字符数组的内容，来创建字符串对象
    public String(byte[] bys)根据字节数组的内容，来创建字符串对象
    String s = “abc”;直接赋值的方式创建字符串对象，内容就是 abc
  • 示例代码
    public class StringDemo01 {
        public static void main(String[] args) {
            //public String ()：创建一个空白字符串对象，不含有任何内容
            String s1 = new String();
            System.out.println("s1:" + s1);
            //public String (char [] chs)：根据字符数组的内容，来创建字符串对象
            char[] chs = {'a', 'b', 'c'};
            String s2 = new String(chs);
            System.out.println("s2:" + s2);
            //public String (byte [] bys)：根据字节数组的内容，来创建字符串对象
            byte[] bys = {97, 98, 99};
            String s3 = new String(bys);
            System.out.println("s3:" + s3);
            //String s = “abc”;	直接赋值的方式创建字符串对象，内容就是 abc
            String s4 = "abc";
            System.out.println("s4:" + s4);
        }
    }
# 创建字符串对象两种方式的区别
  • 通过构造方法创建
    ​	通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同
  • 直接赋值方式创建
    ​	以 “” 方式给出的字符串，只要字符序列相同 (顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护
# 字符串的比较
# == 号的作用
  • 比较基本数据类型：比较的是具体的值
  • 比较引用数据类型：比较的是对象地址值
# equals 方法的作用
  • 方法介绍
    public boolean equals(String s)     比较两个字符串内容是否相同、区分大小写
  • 示例代码
    public class StringDemo02 {
        public static void main(String[] args) {
            // 构造方法的方式得到对象
            char[] chs = {'a', 'b', 'c'};
            String s1 = new String(chs);
            String s2 = new String(chs);
            // 直接赋值的方式得到对象
            String s3 = "abc";
            String s4 = "abc";
            // 比较字符串对象地址是否相同
            System.out.println(s1 == s2);
            System.out.println(s1 == s3);
            System.out.println(s3 == s4);
            System.out.println("--------");
            // 比较字符串内容是否相同
            System.out.println(s1.equals(s2));
            System.out.println(s1.equals(s3));
            System.out.println(s3.equals(s4));
        }
    }
# 用户登录案例
​	已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示
/*
    思路：
        1: 已知用户名和密码，定义两个字符串表示即可
        2: 键盘录入要登录的用户名和密码，用 Scanner 实现
        3: 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，用 equals () 方法实现
        4: 用循环实现多次机会，这里的次数明确，采用 for 循环实现，并在登录成功的时候，使用 break 结束循环
 */
public class StringTest01 {
    public static void main(String[] args) {
        // 已知用户名和密码，定义两个字符串表示即可
        String username = "itheima";
        String password = "czbk";
        // 用循环实现多次机会，这里的次数明确，采用 for 循环实现，并在登录成功的时候，使用 break 结束循环
        for(int i=0; i<3; i++) {
            // 键盘录入要登录的用户名和密码，用 Scanner 实现
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入用户名：");
            String name = sc.nextLine();
            System.out.println("请输入密码：");
            String pwd = sc.nextLine();
            // 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，用 equals () 方法实现
            if (name.equals(username) && pwd.equals(password)) {
                System.out.println("登录成功");
                break;
            } else {
                if(2-i == 0) {
                    System.out.println("你的账户被锁定，请与管理员联系");
                } else {
                    //2,1,0
                    //i,0,1,2
                    System.out.println("登录失败，你还有" + (2 - i) + "次机会");
                }
            }
        }
    }
}
# 遍历字符串案例
​	键盘录入一个字符串，使用程序实现在控制台遍历该字符串
/*
    思路：
        1: 键盘录入一个字符串，用 Scanner 实现
        2: 遍历字符串，首先要能够获取到字符串中的每一个字符
            public char charAt (int index)：返回指定索引处的 char 值，字符串的索引也是从 0 开始的
        3: 遍历字符串，其次要能够获取到字符串的长度
            public int length ()：返回此字符串的长度
            数组的长度：数组名.length
            字符串的长度：字符串对象.length ()
        4: 遍历字符串的通用格式
 */
public class StringTest02 {
    public static void main(String[] args) {
        // 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        for(int i=0; i<line.length(); i++) {
            System.out.println(line.charAt(i));
        }
    }
}
# 统计字符次数案例
​	键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数 (不考虑其他字符)
/*
  思路：
        1: 键盘录入一个字符串，用 Scanner 实现
        2: 要统计三种类型的字符个数，需定义三个统计变量，初始值都为 0
        3: 遍历字符串，得到每一个字符
        4: 判断该字符属于哪种类型，然后对应类型的统计变量 + 1
            假如 ch 是一个字符，我要判断它属于大写字母，小写字母，还是数字，直接判断该字符是否在对应的范围即可
            大写字母：ch>='A' && ch<='Z'
            小写字母： ch>='a' && ch<='z'
            数字： ch>='0' && ch<='9'
        5: 输出三种类型的字符个数
 */
public class StringTest03 {
    public static void main(String[] args) {
        // 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        // 要统计三种类型的字符个数，需定义三个统计变量，初始值都为 0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        // 遍历字符串，得到每一个字符
        for(int i=0; i<line.length(); i++) {
            char ch = line.charAt(i);
            // 判断该字符属于哪种类型，然后对应类型的统计变量 + 1
            if(ch>='A' && ch<='Z') {
                bigCount++;
            } else if(ch>='a' && ch<='z') {
                smallCount++;
            } else if(ch>='0' && ch<='9') {
                numberCount++;
            }
        }
        // 输出三种类型的字符个数
        System.out.println("大写字母：" + bigCount + "个");
        System.out.println("小写字母：" + smallCount + "个");
        System.out.println("数字：" + numberCount + "个");
    }
}
# 字符串拼接案例
​	定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
​	并在控制台输出结果。例如，数组为 int [] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]
/*
    思路：
        1: 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        2: 定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。
          返回值类型 String，参数列表 int [] arr
        3: 在方法中遍历数组，按照要求进行拼接
        4: 调用方法，用一个变量接收结果
        5: 输出结果
 */
public class StringTest04 {
    public static void main(String[] args) {
        // 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1, 2, 3};
        // 调用方法，用一个变量接收结果
        String s = arrayToString(arr);
        // 输出结果
        System.out.println("s:" + s);
    }
    // 定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
    /*
        两个明确：
            返回值类型：String
            参数：int [] arr
     */
    public static String arrayToString(int[] arr) {
        // 在方法中遍历数组，按照要求进行拼接
        String s = "";
        s += "[";
        for(int i=0; i<arr.length; i++) {
            if(i==arr.length-1) {
                s += arr[i];
            } else {
                s += arr[i];
                s += ", ";
            }
        }
        s += "]";
        return s;
    }
}
# 字符串反转案例
​	定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
​	例如，键盘录入 abc，输出结果 cba
/*
    思路：
        1: 键盘录入一个字符串，用 Scanner 实现
        2: 定义一个方法，实现字符串反转。返回值类型 String，参数 String s
        3: 在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
        4: 调用方法，用一个变量接收结果
        5: 输出结果
 */
public class StringTest05 {
    public static void main(String[] args) {
        // 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        // 调用方法，用一个变量接收结果
        String s = reverse(line);
        // 输出结果
        System.out.println("s:" + s);
    }
    // 定义一个方法，实现字符串反转
    /*
        两个明确：
            返回值类型：String
            参数：String s
     */
    public static String reverse(String s) {
        // 在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
        String ss = "";
        for(int i=s.length()-1; i>=0; i--) {
            ss += s.charAt(i);
        }
        return ss;
    }
}
# String 常用方法
方法名说明
public boolean equals(Object anObject)比较字符串的内容，严格区分大小写 (用户名和密码)
public char charAt(int index)返回指定索引处的 char 值
public int length()返回此字符串的长度
# StringBuilder 类
# StringBuilder 类概述
​	StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的
# StringBuilder 类和 String 类的区别
  • String 类：内容是不可变的
  • StringBuilder 类：内容是可变的
# StringBuilder 类的构造方法
  • 常用的构造方法
    方法名说明
    public StringBuilder()创建一个空白可变字符串对象，不含有任何内容
    public StringBuilder(String str)根据字符串的内容，来创建可变字符串对象
  • 示例代码
public class StringBuilderDemo01 {
    public static void main(String[] args) {
        //public StringBuilder ()：创建一个空白可变字符串对象，不含有任何内容
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:" + sb);
        System.out.println("sb.length():" + sb.length());
        //public StringBuilder (String str)：根据字符串的内容，来创建可变字符串对象
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println("sb2:" + sb2);
        System.out.println("sb2.length():" + sb2.length());
    }
}
# StringBuilder 类添加和反转方法
  • 添加和反转方法
    方法名说明
    public StringBuilder append (任意类型)添加数据，并返回对象本身
    public StringBuilder reverse()返回相反的字符序列
  • 示例代码
public class StringBuilderDemo01 {
    public static void main(String[] args) {
        // 创建对象
        StringBuilder sb = new StringBuilder();
        //public StringBuilder append (任意类型)：添加数据，并返回对象本身
//        StringBuilder sb2 = sb.append("hello");
//
//        System.out.println("sb:" + sb);
//        System.out.println("sb2:" + sb2);
//        System.out.println(sb == sb2);
//        sb.append("hello");
//        sb.append("world");
//        sb.append("java");
//        sb.append(100);
        // 链式编程
        sb.append("hello").append("world").append("java").append(100);
        System.out.println("sb:" + sb);
        //public StringBuilder reverse ()：返回相反的字符序列
        sb.reverse();
        System.out.println("sb:" + sb);
    }
}
# StringBuilder 和 String 相互转换
  • StringBuilder 转换为 String
    ​ public String toString ()：通过 toString () 就可以实现把 StringBuilder 转换为 String
  • String 转换为 StringBuilder
    ​ public StringBuilder (String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
  • 示例代码
public class StringBuilderDemo02 {
    public static void main(String[] args) {
        /*
        //StringBuilder 转换为 String
        StringBuilder sb = new StringBuilder ();
        sb.append ("hello");
        //String s = sb; // 这个是错误的做法
        //public String toString ()：通过 toString () 就可以实现把 StringBuilder 转换为 String
        String s = sb.toString ();
        System.out.println (s);
        */
        //String 转换为 StringBuilder
        String s = "hello";
        //StringBuilder sb = s; // 这个是错误的做法
        //public StringBuilder (String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
        StringBuilder sb = new StringBuilder(s);
        System.out.println(sb);
    }
}
# 字符串拼接升级版案例
​	定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
​	并在控制台输出结果。例如，数组为 int [] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]
/*
    思路：
        1: 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        2: 定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。
          返回值类型 String，参数列表 int [] arr
        3: 在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
        4: 调用方法，用一个变量接收结果
        5: 输出结果
 */
public class StringBuilderTest01 {
    public static void main(String[] args) {
        // 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1, 2, 3};
        // 调用方法，用一个变量接收结果
        String s = arrayToString(arr);
        // 输出结果
        System.out.println("s:" + s);
    }
    // 定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
    /*
        两个明确：
            返回值类型：String
            参数：int [] arr
     */
    public static String arrayToString(int[] arr) {
        // 在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for(int i=0; i<arr.length; i++) {
            if(i == arr.length-1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return  s;
    }
}
# 字符串反转升级版案例
​	定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
​	例如，键盘录入 abc，输出结果 cba
/*
    思路：
        1: 键盘录入一个字符串，用 Scanner 实现
        2: 定义一个方法，实现字符串反转。返回值类型 String，参数 String s
        3: 在方法中用 StringBuilder 实现字符串的反转，并把结果转成 String 返回
        4: 调用方法，用一个变量接收结果
        5: 输出结果
 */
public class StringBuilderTest02 {
    public static void main(String[] args) {
        // 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        // 调用方法，用一个变量接收结果
        String s = myReverse(line);
        // 输出结果
        System.out.println("s:" + s);
    }
    // 定义一个方法，实现字符串反转。返回值类型 String，参数 String s
    /*
        两个明确：
            返回值类型：String
            参数：String s
     */
    public static String myReverse(String s) {
        // 在方法中用 StringBuilder 实现字符串的反转，并把结果转成 String 返回
        //String --- StringBuilder --- reverse() --- String
//        StringBuilder sb = new StringBuilder(s);
//        sb.reverse();
//        String ss = sb.toString();
//        return ss;
       return new StringBuilder(s).reverse().toString();
    }
}
# StringBuilder 常用方法
方法名说明
public StringBuilder append (任意类型)添加数据，并返回对象本身
public StringBuilder reverse()返回相反的字符序列
public int length()返回长度，实际存储值
public String toString()通过 toString () 就可以实现把 StringBuilder 转换为 String
 更新于