常用类的概述和使用
一、常用类的概述和使用
1.1 API的使用和常用包的概述
- 查找：模块 -> 包 -> 类
- 搜索
包的名称和功能
- Java.lang包 - 该包是Java语言的核心包，并且该包中的所有内容由JVM自动导入
如：System类、String类、… - java.util包 - 该包是Java语言的工具包，里面提供了大量工具类以及集合类等（包含集合框架，一些国际化支持类，服务加载器，属性，随机数生成，字符串解析和扫描类，base64编码和解码，位数组和几个其他实用程序类。 ）
如：Scanner类、Random类、List集合、… - java.io包 - 该包是Java语言中的输入输出包，里面提供了大量读写文件相关的类等（通过数据流，序列化和文件系统提供系统输入和输出）
如：FileInputStream类、FileOutputStream类、… - java.net包 - 该包是Java语言中的网络包，里面提供了大量网络编程相关的类等
如：ServerSocket类、Socket类、… - java.sql 包 - 该包是Java语言中的数据包，里面提供了大量操作数据库的类和接口等。
如：DriverManager类、Connection接口、… - … …
- Java程序员在编程时可以使用大量类库，因此Java编程时需要记的很多，对编程能力本身要求不是
特别的高
1.2 Object类的概述（重点）
基本概念
- java.lang.Object类是Java语言中类层次结构的根类，也就是说任何一个类都是该类的直接或者间
接子类 - 如果定义一个Java类时没有使用extends关键字声明其父类，则其父类为 java.lang.Object 类
- Object类定义了对象的基本行为, 被子类默认继承
常用的方法
Object
Object() - 构造方法
- 使用无参方式构造对象
equals（重点）
boolean equals(Object obj)
- equals方法的默认功能
用于判断调用对象是否与参数对象相等。
该方法默认比较两个对象的地址是否相等，与 == 运算符的结果一致
若希望比较两个对象的内容，则需要重写该方法
若该方法被重写后，则应该重写hashCode方法来保证结果的一致性
public class Student extends Object {
private int id; // 用于描述学号的成员变量
private String name; // 用于描述姓名的成员变量
public Student() {
}
public Student(int id, String name) {
setId(id);
setName(name);
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class StudentTest {
public static void main(String[] args) {
// 使用有参方式构造Student类型的两个对象并判断是否相等
Student s1 = new Student(1001, "zhangfei");
Student s2 = new Student(1002, "guanyu");
// Student s2 = s1; // 表示s2和s1表示了同一个对象
// 下面调用从Object类中继承下来的equals方法，该方法默认比较两个对象的地址
boolean b1 = s1.equals(s2);
System.out.println("b1 = " + b1); // false
System.out.println(s1 == s2); // false
}
}
- equals方法的重写实现
public class Student extends Object {
private int id; // 用于描述学号的成员变量
private String name; // 用于描述姓名的成员变量
public Student() {
}
public Student(int id, String name) {
setId(id);
setName(name);
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* 为了比较两个对象的学号信息，需要重写equals方法
*/
// Student this = s1;
// Object obj = s2;
@Override
public boolean equals(Object obj) {
// 父类对象obj要强转，才能调用子类对象s2中的独有方法getId()
//return this.getId() == obj.getId();
// 判断obj指向的对象是否为Student类型的对象，是则条件成立，否则不成立
if(obj instanceof Student) {
Student st = (Student)obj;
return st.getId() == this.getId();
}
// 否则类型不一致没有可比性，则内容一定不相同
return false;
}
}
public class StudentTest {
public static void main(String[] args) {
// 使用有参方式构造Student类型的两个对象并判断是否相等
Student s1 = new Student(1001, "zhangfei");
Student s2 = new Student(1001, "guanyu");
// Student s2 = s1; // 表示s2和s1表示了同一个对象
// 下面调用从Object类中继承下来并重写的equals方法，该方法比较两个对象的内容
boolean b1 = s1.equals(s2);
System.out.println("b1 = " + b1); // true 比较内容
System.out.println(s1 == s2); // false 比较地址
}
}
- equals方法的重写优化
public class Student extends Object {
private int id; // 用于描述学号的成员变量
private String name; // 用于描述姓名的成员变量
public Student() {
}
public Student(int id, String name) {
setId(id);
setName(name);
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* 为了比较两个对象的学号信息，需要重写equals方法
*/
// Student this = s1;
// Object obj = s2;
@Override
public boolean equals(Object obj) {
// 当调用对象和参数对象为同一个对象时，则内容一定相同
if(this == obj) return true;
// 当调用对象不为空而参数对象为空时，则内容一定不相同
if(null == obj) return false;
// 父类对象obj要强转，才能调用子类对象s2中的独有方法getId()
//return this.getId() == obj.getId();
// 判断obj指向的对象是否为Student类型的对象，是则条件成立，否则不成立
if(obj instanceof Student) {
Student st = (Student)obj;
return st.getId() == this.getId();
}
// 否则类型不一致没有可比性，则内容一定不相同
return false;
}
}
public class StudentTest {
public static void main(String[] args) {
// 使用有参方式构造Student类型的两个对象并判断是否相等
Student s1 = new Student(1001, "zhangfei");
Student s2 = new Student(1001, "guanyu");
// Student s2 = s1; // 表示s2和s1表示了同一个对象
// 下面调用从Object类中继承下来的equals方法，该方法默认比较两个对象的地址
//boolean b1 = s1.equals(s2);
Student s3 = null;
boolean b1 = s1.equals(s3);
boolean b2 = s1.equals(s1);
//System.out.println("b1 = " + b1); // false
System.out.println(s1 == s3); // false
System.out.println("b2 = " + b2); // true
}
}
hashCode（重点）
int hashCode()
- 功能：
用于获取调用对象的哈希码值(内存地址的编号) - Java官方约定的规则：
若两个对象调用equals方法相等，则各自调用该方法的结果必须相同
若两个调用对象equals方法不相等，则各自调用该方法的结果应该不相同
为了使得该方法与equals方法保持一致，需要重写该方法
- 方法重写
public class Student extends Object {
private int id; // 用于描述学号的成员变量
private String name; // 用于描述姓名的成员变量
public Student() {
}
public Student(int id, String name) {
setId(id);
setName(name);
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* 为了比较两个对象的学号信息，需要重写equals方法
*/
// Student this = s1;
// Object obj = s2;
@Override
public boolean equals(Object obj) {
// 当调用对象和参数对象为同一个对象时，则内容一定相同
if(this == obj) return true;
// 当调用对象不为空而参数对象为空时，则内容一定不相同
if(null == obj) return false;
// 父类对象obj要强转，才能调用子类对象s2中的独有方法getId()
//return this.getId() == obj.getId();
// 判断obj指向的对象是否为Student类型的对象，是则条件成立，否则不成立
if(obj instanceof Student) {
Student st = (Student)obj;
return st.getId() == this.getId();
}
// 否则类型不一致没有可比性，则内容一定不相同
return false;
}
/**
* 为了使得该方法的结果与equals方法的结果保持一致，从而满足Java官方的常规协定，需要重写该方法
*/
@Override
public int hashCode() {
//return getId(); // 不再代表内存地址的编号
final int type = 12;
return type*31 + getId(); // 随便怎么写，只要依赖于学号就可以了
}
}
public class StudentTest {
public static void main(String[] args) {
// 使用有参方式构造Student类型的两个对象并判断是否相等
Student s1 = new Student(1001, "zhangfei");
Student s2 = new Student(1002, "guanyu");
// Student s2 = s1; // 表示s2和s1表示了同一个对象
// 下面调用从Object类中继承下来的equals方法，该方法默认比较两个对象的地址
//boolean b1 = s1.equals(s2);
//Student s3 = null;
boolean b1 = s1.equals(s2);
//boolean b2 = s1.equals(s1);
System.out.println("b1 = " + b1);
//System.out.println(s1 == s3); // false
//System.out.println("b2 = " + b2); // true
System.out.println("--------------------------------");
// 下面调用从Object类中继承下来的hashCode方法，获取调用对象的哈希码值(内存地址的编号)
int ia = s1.hashCode();
int ib = s2.hashCode();
System.out.println("ia = " + ia);
System.out.println("ib = " + ib);
}
}
getClass
- Class<?> getClass()
用于返回调用对象执行时的Class实例，反射机制使用
toString（重点）
String toString()
- 功能：
用于获取调用对象的字符串形式
该方法默认返回的字符串为：包名.类名@哈希码值的十六进制
为了返回更有意义的数据，需要重写该方法
使用print或println打印引用或 字符串拼接 引用变量 都会自动调用该方法
public class Student extends Object {
private int id; // 用于描述学号的成员变量
private String name; // 用于描述姓名的成员变量
public Student() {
}
public Student(int id, String name) {
setId(id);
setName(name);
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* 为了比较两个对象的学号信息，需要重写equals方法
*/
// Student this = s1;
// Object obj = s2;
@Override
public boolean equals(Object obj) {
// 当调用对象和参数对象为同一个对象时，则内容一定相同
if(this == obj) return true;
// 当调用对象不为空而参数对象为空时，则内容一定不相同
if(null == obj) return false;
// 父类对象obj要强转，才能调用子类对象s2中的独有方法getId()
//return this.getId() == obj.getId();
// 判断obj指向的对象是否为Student类型的对象，是则条件成立，否则不成立
if(obj instanceof Student) {
Student st = (Student)obj;
return st.getId() == this.getId();
}
// 否则类型不一致没有可比性，则内容一定不相同
return false;
}
/**
* 为了使得该方法的结果与equals方法的结果保持一致，从而满足Java官方的常规协定，需要重写该方法
*/
@Override
public int hashCode() {
//return getId(); // 不再代表内存地址的编号
final int type = 12;
return type*31 + getId(); // 随便怎么写，只要依赖于学号就可以了
}
/**
* 为了返回更有意义的字符串数据，需要重写该方法
*/
@Override
public String toString() {
return "Student[id = " + getId() + ", name = " + getName() + "]";
}
}
public class StudentTest {
public static void main(String[] args) {
// 使用有参方式构造Student类型的两个对象并判断是否相等
Student s1 = new Student(1001, "zhangfei");
Student s2 = new Student(1002, "guanyu");
// Student s2 = s1; // 表示s2和s1表示了同一个对象
// 下面调用从Object类中继承下来的equals方法，该方法默认比较两个对象的地址
//boolean b1 = s1.equals(s2);
//Student s3 = null;
boolean b1 = s1.equals(s2);
//boolean b2 = s1.equals(s1);
System.out.println("b1 = " + b1);
//System.out.println(s1 == s3); // false
//System.out.println("b2 = " + b2); // true
System.out.println("--------------------------------");
// 下面调用从Object类中继承下来的hashCode方法，获取调用对象的哈希码值(内存地址的编号)
// 当Student类中重写hashCode方法后，则调用重写后的版本
int ia = s1.hashCode();
int ib = s2.hashCode();
System.out.println("ia = " + ia);
System.out.println("ib = " + ib);
System.out.println("------------------------------");
// 下面调用从Object类中继承下来的toString方法，获取调用对象的字符串形式：包名.类名@哈希码值的十六进制
String str1 = s1.toString();
// 重写toString方法前：com.lagou.task11.Student@55d
// 重写toString方法后：str1 = Student[id = 1001, name = zhangfei]
System.out.println("str1 = " + str1);
// 打印一个引用变量时会自动调用toString方法
System.out.println(s1); // Student[id = 1001, name = zhangfei]
// 使用字符串拼接时会自动调用toString方法
String str2 = "hello" + s1;
System.out.println("str2 = " + str2); // str2 = helloStudent[id = 1001, name = zhangfei]
}
}
案例扩展
- 上述例子是以学号作为基准判断两个对象是否相等。那么如何实现以姓名作为基准来判断两个对象是否相等？以及以学号和姓名同时作为基准来判断两个对象是否相等？
- 姓名作为基准
public class Student extends Object {
private int id; // 用于描述学号的成员变量
private String name; // 用于描述姓名的成员变量
public Student() {
}
public Student(int id, String name) {
setId(id);
setName(name);
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* 为了比较两个对象的学号信息，需要重写equals方法
*/
// Student this = s1;
// Object obj = s2;
@Override
public boolean equals(Object obj) {
// 当调用对象和参数对象为同一个对象时，则内容一定相同
if(this == obj) return true;
// 当调用对象不为空而参数对象为空时，则内容一定不相同
if(null == obj) return false;
// 父类对象obj要强转，才能调用子类对象s2中的独有方法getId()
//return this.getId() == obj.getId();
// 判断obj指向的对象是否为Student类型的对象，是则条件成立，否则不成立
if(obj instanceof Student) {
Student st = (Student)obj;
// 以学号作为基准判断两个对象是否相同 学号int是基本数据类型，栈区内存空间中存放数据本身
// 使用 == 可以判断数据是否相同
//return st.getId() == this.getId();
// 以姓名作为基准判断两个对象是否相同，姓名String类型，为引用数据类型，栈区内存空间中放的是地址
// 使用 == 判断地址是否相同
// 也就是判断两个对象中姓名字符串的地址是否相同，不够完美
//return this.getName() == st.getName();
// 这里this.getName()是String类型，因此调用的equals方法是String类重写后的equals方法(Java官方帮写好了)
return this.getName().equals(st.getName());
}
// 否则类型不一致没有可比性，则内容一定不相同
return false;
}
/**
* 为了使得该方法的结果与equals方法的结果保持一致，从而满足Java官方的常规协定，需要重写该方法
*/
@Override
public int hashCode() {
//return getId(); // 不再代表内存地址的编号
final int type = 12;
//return type*31 + getId(); // 随便怎么写，只要依赖于学号就可以了
// 因为String类重写了equals方法，因此它也会重写hashCode方法，来保证一致性，可以直接调用
return type*31 + getName().hashCode();
}
/**
* 为了返回更有意义的字符串数据，需要重写该方法
*/
@Override
public String toString() {
return "Student[id = " + getId() + ", name = " + getName() + "]";
}
}
public class StudentTest {
public static void main(String[] args) {
// 使用有参方式构造Student类型的两个对象并判断是否相等
Student s1 = new Student(1001, "zhangfei");
Student s2 = new Student(1002, "guanyu");
// Student s2 = s1; // 表示s2和s1表示了同一个对象
// 下面调用从Object类中继承下来的equals方法，该方法默认比较两个对象的地址
//boolean b1 = s1.equals(s2);
//Student s3 = null;
boolean b1 = s1.equals(s2);
//boolean b2 = s1.equals(s1);
System.out.println("b1 = " + b1);
//System.out.println(s1 == s3); // false
//System.out.println("b2 = " + b2); // true
System.out.println("--------------------------------");
// 下面调用从Object类中继承下来的hashCode方法，获取调用对象的哈希码值(内存地址的编号)
// 当Student类中重写hashCode方法后，则调用重写后的版本
int ia = s1.hashCode();
int ib = s2.hashCode();
System.out.println("ia = " + ia);
System.out.println("ib = " + ib);
System.out.println("------------------------------");
// 下面调用从Object类中继承下来的toString方法，获取调用对象的字符串形式：包名.类名@哈希码值的十六进制
String str1 = s1.toString();
// 重写toString方法前：com.lagou.task11.Student@55d
// 重写toString方法后：str1 = Student[id = 1001, name = zhangfei]
System.out.println("str1 = " + str1);
// 打印一个引用变量时会自动调用toString方法
System.out.println(s1); // Student[id = 1001, name = zhangfei]
// 使用字符串拼接时会自动调用toString方法
String str2 = "hello" + s1;
System.out.println("str2 = " + str2); // str2 = helloStudent[id = 1001, name = zhangfei]
}
}
- equals方法和hashCode方法的生成
在IDEA里可以直接生成
在平时开发中可以直接生成
但是遇到笔试题要知道怎么改写
1.3 包装类
概念
- 通常情况下，基本数据类型的变量不是对象，为了满足万物皆对象的理念，就要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，称为包装类
int num = 10;
public class MyInt {
private int num = 10;
}
- 实际上，代码不需要我们自己写，Java官方帮我们写好了
分类
- 因为有八种基本数据类型，所以官方提供了八种包装类
1.4 Integer类
基本概念
- java.lang.Integer类内部包装了一个int类型的变量作为成员变量，主要用于实现对int类型的包装并提供int类型到String类型之间的转换等方法
常用的常量和构造方法
- 常用常量
- 常用的方法（上）
public class IntegerTest {
public static void main(String[] args) {
// 1.打印Integer类中常用的常用数值
System.out.println("最大值是：" + Integer.MAX_VALUE); // -2^31
System.out.println("最大值是：" + Integer.MIN_VALUE); // 2^31-1
System.out.println("所表示的二进制位数是：" + Integer.SIZE); // 32
System.out.println("所占字节的个数是：" + Integer.BYTES); // 4
System.out.println("对应int类型的Class实例是：" + Integer.TYPE); // int
// 2.使用构造方法来构造Integer类型的对象并引用
//Integer it1 = new Integer(123);
//System.out.println("it1 = " + it1); // 自动调用toString方法 123
Integer it2 = new Integer("456");
//System.out.println("it2 = " + it2); // 自动调用toString方法 456
// 上述方法已过时，建议使用valueOf方法取代之
// int --> Integer
Integer it3 = Integer.valueOf(123);
System.out.println("it3 = " + it3); // 456
// String --> Integer
Integer it4 = Integer.valueOf("456");
System.out.println("it4 = " + it4); // 456，此处自动调用toString方法，得到的是String类型
// 获取调用对象中的整数数值，相当于从Integer类型转换到int类型
int ia = it4.intValue();
System.out.println("获取到的整数数据是：" + ia); // 456，得到的是int类型
}
}
装箱和拆箱机制（笔试题）
- 装箱：从基本数据类型(如int类型)到包装类(如Integer类型)的转换
- 拆箱：从包装类(如Integer类型)到i基本数据类型(如int类型)的转换
在Java5之前使用包装类对象进行运算时，需要较为繁琐的“拆箱”和“装箱”操作：即运算前将包装类对象拆分为基本数据类型，运算后再将结果封装成包装类对象
从Java5开始增加了自动拆箱和自动装箱的功能
- 自动装箱池（笔试）
在Integer类的内部提供了自动装箱技术，将 -128到127之间的整数(可以根据需要进行范围调整)已经装箱完毕，当程序中使用该范围内的整数时，无需装箱直接取用自动装箱池中的对象即可，从而提高效率
public class IntegerTest {
public static void main(String[] args) {
// 1.打印Integer类中常用的常用数值
System.out.println("最大值是：" + Integer.MAX_VALUE); // -2^31
System.out.println("最大值是：" + Integer.MIN_VALUE); // 2^31-1
System.out.println("所表示的二进制位数是：" + Integer.SIZE); // 32
System.out.println("所占字节的个数是：" + Integer.BYTES); // 4
System.out.println("对应int类型的Class实例是：" + Integer.TYPE); // int
System.out.println("-------------------------------------------");
// 2.使用构造方法来构造Integer类型的对象并引用
//Integer it1 = new Integer(123);
//System.out.println("it1 = " + it1); // 自动调用toString方法 123
Integer it2 = new Integer("456");
//System.out.println("it2 = " + it2); // 自动调用toString方法 456
// 上述方法已过时，建议使用valueOf方法取代之，相当于从int类型到Integer类型的转换，叫做装箱
// int --> Integer
Integer it3 = Integer.valueOf(123);
System.out.println("it3 = " + it3); // 456
// String --> Integer
Integer it4 = Integer.valueOf("456");
System.out.println("it4 = " + it4); // 456，此处自动调用toString方法，得到的是String类型
// 获取调用对象中的整数数值，相当于从Integer类型转换到int类型，叫做拆箱
int ia = it4.intValue();
System.out.println("获取到的整数数据是：" + ia); // 456，得到的是int类型
System.out.println("-------------------------------------------");
// 3.从Java5开始增加了自动装箱和自动拆箱的机制
Integer it5 = 100; // 直接通过赋值运算符实现自动装箱
int ib = it5; // 直接通过赋值运算符实现自动拆箱
System.out.println("-------------------------------------------");
// 4.装箱和拆箱的笔试考点
/*Integer it6 = 128;
Integer it7 = 128;
Integer it8 = new Integer(128);
Integer it9 = new Integer(128);
System.out.println(it6 == it7); // 比较地址，false
System.out.println(it6.equals(it7)); // 比较内容，true
System.out.println(it8 == it9); // 比较地址，false
System.out.println(it8.equals(it9)); // 比较内容，true*/
Integer it6 = 127;
Integer it7 = 127;
Integer it8 = new Integer(127);
Integer it9 = new Integer(127);
System.out.println(it6 == it7); // 比较地址，true，受自动装箱池技术的影响
System.out.println(it6.equals(it7)); // 比较内容，true
System.out.println(it8 == it9); // 比较地址，false
System.out.println(it8.equals(it9)); // 比较内容，true
}
}
Integer类的常用方法（下）
- 注意：都是static静态方法，类层级，直接 类名. 引用以下方法
// 实现静态方法的调用
int a = Integer.parseInt("200"); // 200
int b = Integer.parseInt("200a"); // 编译OK，运行发生NumberFormatException数字格式异常，因为有字母
int c = Integer.toBinaryString(200); // 1100 1000
int d = Integer.toString(200); // 200
int e = Integer.toOctalString(200); // 810
int f = Integer.toHexString(); // c8
- 至此，我们得到了 6 种异常
- ArithmeticException 算术异常
- ArrayIndexOutOfBoundsException 数组越界异常
- NullPointerException 空指针异常
- ClassCastException 类型转换异常
- IllegalArgumentException 非法参数异常
- NumberFormatException 数字格式异常
1.5 double类
概念
- java.lang.Double类型内部包装了一个double类型的变量作为成员变量，主要用于实现对double
类型的包装并提供double类型到String类之间的转换等方法。
常用的常量和方法
- 常用的常量
- 常用的方法
- 从Java5开始，也有自动装箱和自动拆箱
- 没有自动装箱池
- java.lang.Number类是个抽象类，是上述类的父类，用来描述所有类共有的成员
1.6 Boolean类的概念和使用
基本概念
- java.lang.Boolean类型内部包装了一个boolean类型的变量作为成员变量，主要用于实现对
boolean类型的包装并提供boolean类型到String类之间的转换等方法
常用的常量和方法
- 常用的常量
- 常用的方法
1.7 Character类的概述
基本概念
- ava.lang.Character类型内部包装了一个char类型的变量作为成员变量，主要用于实现对char类型
的包装并提供字符类别的判断和转换等方法
常用的常量和变量
- 常用的常量
- 常用的方法
1.8 包装类的使用总结
- 基本数据类型转换为对应包装类的方式（装箱） -》 对象层级
调用包装类的构造方法或静态方法(valueOf方法)即可 - 获取包装类对象中基本数据类型变量数值的方式（拆箱）-》 类层级
调用包装类中的xxxValue方法即可 - 字符串转换为基本数据类型的方式 -》类层级
调用包装类中的parseXxx方法即可
1.9 数学处理类
（1）Math类
基本概念
- java.lang.Math类主要用于提供执行数学运算的方法，如：对数，平方根。
常用方法
（2）BigDecimal类
基本概念
- 由于float类型和double类型在运算时可能会有误差，若希望实现精确运算则借助
java.math.BigDecimal类型加以描述
（注意区分：java.lang.Math 和 java.math.BigDecimal）
常用的方法
// 1.构造BigDecimal类型的两个对象
BigDecimal bd1 = new BigDecimal("2.6");
BigDecimal bd2 = new BigDecimal("3.1");
// 2.使用这两个对象实现加减乘除
System.out.prinln(bd1.add(bd2)); // 5.7
... 其他的减乘除同理
（3）BigInteger类
基本概念
- 若希望表示比long类型范围还大的整数数据，则需要借助java.math.BigInteger类型描述
常用的方法
- 跟 BigDecimal类 同理
总结
扫一扫
3317
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
