习题1
写下这篇文章的主要目的是帮助初学者更好地学习Java语言，所有题目都是照着书一个字一个字敲出来的，代码都是经过思考写上去的，每道题会有详细的解析，并非随便写个答案糊弄一下的，写作不易且看且珍惜。如果有错误或者有更优解请留言，我会注明ID并修改。
一. P15 习题1
1.问答题
1.Java语言的主要贡献者是谁？
-James Gosling
2.开发Java应用程序需要经过哪些主要步骤？
-编写源文件、编译源文件生成字节码和加载运行字节码。
3.Java源文件是由什么组成的？一个源文件中必须要有public类吗？
-Java源文件是由若干个书写形式互相独立的类组成。不一定，可以没有public类。（具体的分析见本章结尾总结。）
4.如果JDK的安装目录是D:\jdk,应当怎样设置path和classpath的值？
-path配置时将目录改为D:\jdk下的bin文件夹。
-classpath配置时没有固定目录，方便查阅即可。
5.Java源文件的扩展名是什么？Java字节码的扩展名是什么？
-Java原文件的扩展名是.java，Java字节码的扩展名是.class
6.如果Java应用程序主类的名字是Bird，编译之后，应当怎样运行该程序？
-在Windows的cmd命令窗口下，编译之后，使用java Bird命令运行该程序。
7.有哪两种编程风格，在格式上各有怎样的特点？
-Allmans风格：也称“独行风格”，左右大括号各独占一行，如下列代码（不需要看懂代码只需要体会编程风格）：
class Allmans
{
public static void main(String[] args)
{
int result = 0;
for(int x = 1 ; x < 101; x++)
{
result = result + x;
}
}
}
※：当代码量较小时适合使用“独行”风格，代码布局清晰，可读性强。
-Kernighan风格：也称“行尾”风格，如下列代码所示（不需要看懂代码只需要体会编程风格）：
public class Test01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//CSDN \u6d3e duke \u661f
//需求：用for循环找出1~10000中所有的素数，要求每8个换一行输出
//素数：只能被1和自身整除的数。
int sum = 0;
for(int i=2;i<=10000;i++) {
boolean isSuShu = true;
for(int j=2;j<i;j++) {
if(i % j == 0) {
isSuShu = false;
break;
}
}
if(isSuShu) {
System.out.print(i + " ");
sum++;
if(sum % 8 == 0) {System.out.println();
}
}
}
}
}
二.选择题
1.下列哪个是JDK提供的编译器？ （B）
A. java.exe
B. javac.exe
C. javap.exe
D. javaw.exe
※：A是Java解释器。B是Java编译器。C是Java反编译器。D大多用来运行GUI程序。
2.下列哪个是Java应用程序主类中正确的main方法？ （D）
A. public void main(String args[ ])
B. static void main(String args[ ])
C. public static void Main(String args[ ])
D. public static void main(String args[ ])
3.阅读下列Java源文件，并回答问题。
public class Person {
void speakHello(){
System.out.println("您好，很高兴认识您");
System.out.println("nice to meet you");
}
}
class Xiti {
public static void main(String[] args){
Person zhang = new Person();
zhang.sperkHello;
}
}
（1）上述源文件的名字是什么？
-Person.java
（2）编译上述源文件将生成几个字节码文件？这些字节码文件的名字都是什么？
-两个字节码文件。Person.java和Xiti.java。
```
这里后缀应该是.class，写的时候没仔细看。（感谢咕噜咕噜崩的纠错）···
（3）在命令执行java Person 得到怎样的错误提示？执行java xiti得到怎样的错误提示？ 执行java Xiti.class 得到怎样的错误提示？执行java Xiti得到怎样的输出结果？
-错误: 错误: 在类 Person 中找不到 main 方法, 请将 main 方法定义为:public static void main(String[] args)否则 JavaFX 应用程序类必须扩展javafx.application.Application
-错误: 找不到或无法加载主类 xiti 原因: java.lang.ClassNotFoundException: xiti
-您好，很高兴认识您 nice to meet you
小结：
public class和class的区别：
*一个java源文件当中可以定义多个class
*一个java源文件当中public class不是必须的
*一个class会定义生成一个xxx.class字节码文件
*一个java源文件当中定义公开的类的话，只能有一个，并且该类名称必须和java源文件名称一致。
*每一个class当中都可以编写main方法，都可以设定程序的入口
*※：在cmd命令窗口执行java xxx，那么要求xxx.class当中必须有main方法，否则报错。
习题2
一.P30 习题2
1.问答题
（1）什么叫标识符？标识符的规则是什么？false是否可以作为标识符？
第一问：
用来标识类名、变量名、方法名、类型名、数组名、文件名的有效字符序，称为标识符。
第二问：
-只能由"数字、 字母、下划线_、 美元符号S”组成，不能含有其他符号
-不能以数字开头
-严格区分大小写
-关键字不能做标识符
-理论上无长度限制，但是最好不要太长
-Java语言源代码采用的是Unicode编码方式，所以"标识符”可以中文。
第三问：false属于数据类型的关键字不能作为标识符。
（2）什么叫关键字？true和false是否是关键字？请说出6个关键字。
第一问：关键字就是Java语言中已经被赋予特定意义的一些单词
第二问：if、for、while、public、return、class（其实有很多关键字，可以自行百度）
（3）Java的基本数据类型都是什么？
八种基本数据类型：byte,int,short,long,float,double,boolean,char
（4）float型常量和double型常量在表示上有什么区别？
在Java语言当中，带小数点的字面值默认时被当作double型数据，如果在数据后面加f/F表示float型，加d/D表示double型。
（5）怎样获取一维数组的长度，怎样获取二维数组中一维数组的个数？
第一问：一维数组名.length。
第二问：二维数组名.length。
2.选择题
（1）下列哪项字符可以作为标识符？ (C)
A.true B.default C._int D.good-class
解析：A和B都是关键字不能作为标识符，D中含有除下划线_美元符号$外的其他字符，所以不能做为标识符。
（2）下列哪三项是正确的float变量的声明？ （ADF）
A.float foo = -1;
B.float foo = 1.0;
C.float foo = 42e1;
D.float foo = 2.02f;
E.float foo = 3.03d;
F. float foo = 0x0123;
解析：B中没有加f/F,上面说过在Java语言当中带小数点的字面值默认是double型，大容量类型转小容量类型需要加强制类型转换符。C是42*10即420是一个整型字面值，不是浮点型。E中后面的d是double型后缀，应该用f/F。
（3）下列哪一项叙述是正确的？ （B）
A.char 型字符在Unicode表中的位置范围是0~32767
B.char 型字符在Unicode表中的位置范围是0~65535
C.char 型字符在Unicode表中的位置范围是0~65536
D.char 型字符在Unicode表中的位置范围是-32768~32767
（4）以下哪两项是正确的char型变量的声明？ (BE)
A.char ch = “R”;
B.char ch = ‘\’;
C.char ch = ‘ABCD’;
D.char ch = “ABCD”
E.char ch = ‘\ucafe’;
F.char ch = ‘\u10100’;
解析：首先明确char类型是占2个字节的。B中反斜杠对反斜杠转义，得到一个反斜杠\，可以。E中是一串Unicode码，转换后只占两个字节，也可以。
（5）下列程序中哪些【代码】是错误的？（解析写在代码中）
public class E {
public static void main(String[] args) {
int x = 8;
byte b = 127; //【代码1】
b = x; //【代码2】b是byte类型的变量，而x是int类型的变量
x = 12L; //【代码3】L表示该字面值是long类型的字面值，而x是int类型的变量
long y = 8.0; //【代码4】8.0是double类型的字面值，而y是long类型的变量
float z = 6.89; //【代码5】6.89是double类型的字面值，而z是float类型的变量
}
}
（6）对于“int a[] = new int [3]”,下列哪个叙述是错误的？ （B）
A. a.length 的值是3。
B. a[1]的值是1。
C. a[0]的值是0。
D. a[a.length-1]的值等于a[2]的值。
3.阅读或调试程序
此题属于操作题，请自己上机操作体会。
4.编程题
（1）编写一个应用程序，给出汉子“你”、“我”、“他”在Unicode表中的位置
public class A {
public static void main(String args[]) {
System.out.println((int)'你');
System.out.println((int)'我');
System.out.println((int)'他');
}
}
小知识：可以使用JDK中自带的native2ascii.exe命令，可以将中文转换成Unicode编码形式。使用方法：在cmd命令行输入native2ascii，回车，然后输入文字之后回车即可得到Unicode编码。
（2）编写一个Java应用程序，输出全部的希腊字母
public class B {
public static void main (String args[ ]) {
char first = 'α';
char end = 'ω';
for(char i=first ; c<=end ; c++){
System.out.println(i);
}
}
}
习题3
1.问答题
（1）关系运算符的运算结果是怎样的数据类型？
会返回一个布尔类型（boolean）的值。（true、fasle）
※：关系运算符（也叫做比较运算符）包括：>、<、==、>=、<=、!=
（2）if语句中的条件表达式的值是否可以是int类型？
不行。条件表达式只能是一个布尔表达式，而布尔表达式的返回值是boolean类型。
（3）while语句中的条件表达式的值是什么类型？
布尔类型。
（4）switch语句中必须有default选项吗？
可以没有default选项。
（5）在while语句的循环体中，执行break语句的效果是什么？
当程序执行到break语句时，直接退出while循环，不执行while循环中的任何代码。
（6）可以用for语句代替while语句的作用吗？
可以。但是编写出来的代码不同，执行出来效果一样。
知识点概括：
一.if语句的语法结构，有四种编写方式：
第一种：
if(布尔表达式){
java语句;
} //只有当表达式的值为true时，才执行java语句。
第二种：
if(布尔表达式){
java语句1;
}else{
java语句2;
} //当表达式的值为true时，执行java语句1。
//当表达式的值为false时，执行java语句2。
第三种：if(布尔表达式1){
java语句1;
}else if (布尔表达式2){
java语句2;
}else if (布尔表达式3){
java语句3;
}else if (布尔表达式4){
java语句4;
}…… //布尔1为true执行java语句1，布尔2为true执行java语句2。以此类推。
第四种：if(布尔表达式1){
java语句1;
}else if (布尔表达式2){
java语句2;
}else if (布尔表达式3){
java语句3;
}else if (布尔表达式4){
java语句4;
}else{
java语句5;
}…… //布尔1为true执行java语句1，布尔2为true执行java语句2。以此类推。当所有布尔表达式都为false时，执行else后面的java语句5。
※：对于java中的if语句来说，只要有一个分支执行，整个if语句全部结束。以上的第二种和第四种编写方式都带有else，这两种方式可以确保100%会有分支执行。
二.switch语句代码格式：
switch(int或String类型的字面值或变量){
case int或String类型的字面值或变量1:
java语句;
······
break;
case int或String类型的字面值或变量2:
java语句;
······
break;
case int或String类型的字面值或变量3:
java语句;
······
break;
}
switch语句的执行原理：
switch后面小括号中的“数据”和case后面的“数据”进行一 一匹配（按照自上而下的顺序一一匹配，所以效率不高），匹配成功的分支执行。若代码后面有default（默认的意思，可以不写），并且所有的case都没有匹配成功，则执行default后面的java语句。
※：当执行到break;语句时，整个switch语句结束。
注意：如果匹配成功后，该分支中没有break;语句的话，他会直接进入下一个分支（不进行匹配），这种现象被称为case穿透现象。【提供break;可以避免穿透现象】
注意：在JDK7之后的版本是可以匹配String类型的字面值或变量，如果用的是JDK6和之前的版本则只能匹配int类型的字面值或变量。
三.for循环的语法结构：
- for(初始化表达式;布尔表达式;更新表达式){
循环体(又java语句构成)
} - 执行原理：
*小括号内的表达式都不是必须的，但是两个分号“;”是必须的！
*初始化表达式最先执行，并且在整个for循环当中只执行一次
*布尔表达式必须是true/false，不能是其他值。 - ※：在for循环中定义的变量，作用域为for循环，在main方法中无法访问。
四.while，do while
1.while(布尔表达式){
循环体;
}
2.while循环的执行原理:
*先判断布尔表达式的结果
*true → 执行循环体
*判断布尔表达式的结果
*true → 执行循环体
*判断布尔表达式的结果
*true → 执行循环体
·············
*false → 循环结束
*false → 循环结束
*false → 循环结束
3.while循环的循环次数：0~N次。
4.※：在编译的时候不对变量进行分配内存，只有在运行的时候才分配。
2.选择题
（1）下列哪个叙述是正确的？ （A）
A. 5.0/2+10的结果是double类型的数据。
B. (int)5.8+1.0 的结果是int类型的数据。
C. ‘苹’+'果’的结果是char类型的数据。
D. (short)10+'a’的结果是short类型的数据
解析：
A：5.0/2+10,这个式子结果是12.0,是double类型的数据。
B：虽然对5.8使用了强制类型转换符，但是后面的1.0没有使用，在加法 运算符执行之后，结果为6.8还是double类型的数据。
C：结果"苹果"，是一个字符串类型的数据。注意：char类型占两个字节，中文正好占两个字节，苹果两个字占4个字节，超出了char类型的范围。
D：结果为107，是一个int类型的数据。
（2）用下列哪个代码替换程序标注的【代码】会导致编译错误？ （C）
A. m-- > 0
B. m++ > 0
C. m = 0
D. m > 100 && true
public class E {
public static void main(String[] args) {
int m=10,n=0;
while(【代码】) {
n++;
}
}
}
解析：while小括号内是一个布尔表达式，需要的是一个布尔类型的值，ABD都满足，而C是赋值运算符，而不是“==”运算符。
（3）假设有“int x = 1;”，以下哪个代码导致“可能损失精度，找到int需要char”这样的编译错误? （C）
A. short t = 12 + ‘a’;
B. char c = ‘a’ + 1;
C. char m = ‘a’ + x;
D. byte n = ‘a’ + 1;
3.阅读程序
不做过多解释，具体需要上机体会。
4.编程题（重点，需要体会编程思想）
（1）编写应用程序求1!+2!+······+10！。
public class Test01 {
public static void main(String[] args) {
int result=0,updata=1;
int isno = 1;
while(isno <= 10) {
//循环10次
result = result + updata;//结果
isno++;//每次循环自增1
updata = updata * isno;//做阶乘
}
System.out.println("1!+2!+····+10!" + "=" + result);//输出结果
}
}
（2）编写一个应用程序求100以内的全部素数。
public class Test02 {
public static void main(String[] args) {
for(int i=2;i<=100;i++) {
boolean isSuShu = true;//默认将i看做一个素数【标记在开发中比较常用】
for(int j=2;j<i;j++) {
if(i % j ==0) {
//非素数
isSuShu = false;
//已经知道i是非素数，跳出循环，效率更高。
break;
}
}
if(isSuShu) {
System.out.println(i);
}
}
}
（3）分别用do while和for循环计算1+1/2!+1/3!+1/4!+······的前20项和。
do while：
public class Test03 {
public static void main(String args[]) {
double sum=0,a=1,i=1;
do { sum=sum+a;
i++;
a=(1.0/i)*a;
}
while(i<=20);
System.out.println("1+1/2!+1/3!+1/4!+······的前20项和="+sum);
}
}
for：
public class Test03 {
public static void main(String args[]) {
double sum=0,j=1,i=1;
for(;i <= 20; i++) {
j = j * (1.0 / i);
sum = sum + j;
}
System.out.println("1+1/2!+1/3!+1/4!+······的前20项和="+sum);
}
}
（4）一个数如果恰好等于它的因子之和，这个数就称为完数。编写应用程序求1000之内的所有完数。
通过for循环嵌套来实现：
public class Test03 {
public static void main(String args[]) {
int result=0,i,j;
for(i=1;i<=1000;i++) { //外层循环1000次
for(j=1,result=0;j<i;j++) {
if(i%j==0)
result = result + j;
}
if(result==i) //判断是否为完数
System.out.println("完数:"+i);
}
}
}
（5）编写应用程序，使用for循环语句计算8+88+888+····前10项之和。
方法一：使用while循环机制
public class Test05 {
public static void main(String[] args) {
//思路：可以倒过来看，第十项有十个8,
double i = 0.8888888888d;
long temp = 0; //temp是一个中间变量
long result = 0;
while(i <= 8888888888.0) {
i *= 10.0;
temp = (long)i; //强制类型转换会舍弃小数点后面的数，通过这种方式来实现。
result = result + temp;
}
System.out.println(result);
}
}
方法二：通过for循环来实现
public class Test05{
public static void main(String args[]){
long a,b=0, c=0;
for(a=1;a<=10;a++){ //循环10次
b=b*10+8; //每一个数是前一个数的10倍加8
c+=b; //计算10项之和
}
System.out.print("8+88+888...前10项之和 = " + c);
}
}
※：这两中方法的实现思路都可以相互转换，只不过写出来的形式不同。
其他思路：
//把888当做字符串来看待，可以利用for循环，每循环一次就加个字符’8’
※：只是说明思路，不写具体的代码，因为基础篇中没有String转int的方法。
解析：第一次循环，i是一个字符串"8",然后转换成int类型的8，利用中间变量result来累加，第二次循环在拼接一个8，即"8"+“8"得到"88”,然后转花为int类型。以此类推。
（6）编写应用程序，输出满足1+2+3+·····+n<8888的最大正整数n。
方法一：通过for循环实现
public class Test06{
public static void main(String[] args) {
int result = 0;
for(int n=1;;) {
result = result + n;
n++;
if(result > 8888) {
System.out.println("满足条件的最大整数n为" + (n-1));
break;
}else continue;
}
}
}
方法二：通过while循环来实现
public class Test06 {
public static void main(String args[]) {
int n=1;
int result=0;
while(true) {
result = result + n;
n++;
if(result >= 8888)
break;
}
System.out.println("满足条件的最大整数n为:"+(n-1));
}
}
P105 习题4
一. P105 习题4
1.问答题
（1）面向对象语言有哪三个特性？
封装性、继承性、多态性。
（2）类名应当遵守怎样的编程风格？
遵守标识符的命名规则（忘记了可以去习题2那里看看），首字母大写，后面每个单词首字母大写，最好见名知意。
（3）变量和方法的名字应当遵守怎样的编程风格？
遵守标识符的命名规则，首字母小写，以后每个单词首字母大写，最好见名知意。
（4）类体中声明成员变量是为了体现对象的属性还是行为？
是为了体现对象的属性。（这个稍微理解一下就记住了，跟下面一题结合一下，记住一个另一个就不会忘记了。）
（5）类体内容中定义的非构造方法是为了体现对象的属性还是行为？
是为了体现对象的行为。
（6）什么时候使用构造方法？构造方法有类型吗？
在创建对象的时候会使用构造方法。有类型，但是在语法中不写（类型是它本身）。
（7）类中的实例变量在什么时候回被分配内存空间？
在该类构造方法执行的时候，会给该类中的实例变量分配内存空间。
（8）什么叫方法的重载？构造方法可以重载吗？
在同一个类中方法名相同但是形参不同（包括数量、顺序、类型）的方法构成重载。构造方法也可以重载。
（9）类中的实例方法可以操作类变量（static 变量）吗？类方法（static 方法）可以操作实例变量吗？
（10）类中的实例方法可以用类名直接调用吗？
不行。需要创建对象，通过对象的方式来调用。
（11）简述类变量和实例变量的区别。
1、实例变量有默认值而类变量没有。
2、实例变量有对象的参与而类变量没有。
（12）this 关键字代表什么？this可以出现在类方法中吗？
代表当前的引用所指向的对象（也可以理解为代表调用当前方法的对象）。不行。
2.选择题
（1）下列哪个叙述是正确的？ （B）
A. Java应用程序由若干个类所构成，这些类必须在一个源文件中。
B. Java应用程序由若干个类所构成，这些类可以在一个源文件中，也可以分布在若干个源文件中，其中必须有一个源文件含有主类。
C. Java源文件必须含有主类。
D. Java源文件如果含有主类，主类必须是public类。
（2）下列哪个叙述是正确的？ （D）
A. 成员变量的名字不可以和局部变量的名字相同。
B. 方法的参数名字可以和方法中声明的局部变量的名字相同。
C. 成员变量没有默认值、
D. 局部变量没有默认值。
解析：成员变量的名字和局部变量的名字可以相同。成员变量是有默认值的。
| 数据类型 | 默认值 |
|---|---|
| byte，short，int，long | 0 |
| float，double | 0.0 |
| boolean | false |
| char | \u0000 |
| 引用数据类型 | null |
（3）对于下列Hello类，哪个叙述是正确的？ （D）
A. Hello 类有两个构造方法
B. Hello 类的 int Hello()方法是错误的方法。
C. Hello 类没有构造方法。
D. Hello 无法通过编译，因为其中的hello方法的方法头是错误的（没有类型）。
解析：A选项：只有一个构造方法。就是第一个Hello(int m)这个方法。 B选项：是正确的，只不过修饰符列表是缺省的。 C选项：看A
public class Hello {
Hello(int m){
}
int Hello() {
return 20;
}
hello(){
}
}
（4）对于下列Dog类，哪个叙述是错误的？ （D）
A. Dog(int m)与Dog(double m)是互为重载的构造方法
B. int Dog(int m)与void Dog(double m)是互为重载的非构造方法
C. Dog类只有两个构造方法，而且没有无参数的构造方法
D. Dog类有三个构造方法
解析：D选项：代码中前两个是构造方法。剩下的都是成员方法
public class Dog {
Dog(int m){
}
Dog(double m){
}
int Dog(int m) {
return 23;
}
void Dog(double m) {
}
}
（5）下列哪些类的声明是错误的？ （CD）
A. class A
B. public class A
C. protected class A
D. private class A
解析：
（6）下列A类中【代码1】~【代码5】哪些是错误的？
解析：代码【1、4】是错误的。 【代码1】是想对Tom类的属性x的值修改为22，但是这个x是被private修饰过的，只能在本类（Tom）中访问。 【代码4】被private修饰，只能在本类中访问。
class Tom {
private int x = 120;
protected int y = 20;
int z = 11;
private void f() {
x = 200;
System.out.println(x);
}
void g(){
x = 200;
System.out.println(x);
}
}
public class A{
public static void main(String[] args) {
Tom tom = new Tom();
tom.x = 22; //【代码1】
tom.y = 33; //【代码2】
tom.z = 55; //【代码3】
tom.f(); //【代码4】
tom.g(); //【代码5】
}
}
（7）下列E类的类体中哪些【代码】是错误的？
解析：【代码4】是错误的。参数传递的是数值。而局部变量m声明了但没有赋值，无法进行“+”法运算，因为这个m没有具体的值。
public class E {
int x; //【代码1】
long y; //【代码2】
public void f(int n) {
int m; //【代码3】
int t = n + m; //【代码4】
}
}
3.阅读程序
※：别懒啊，一定要上机自己敲。
4.编程题（仅供参考，可以自己对照着写）
CPU类：
package code111;
public class CPU {
int speed;
public int getSpeed() {
return speed;
}
public void setSpeed(int m) {
speed = m;
}
}
硬盘类：
package code111;
public class HardDisk {
int amount;
public int getAmount() {
return amount;
}
public void setAmount(int m) {
amount = m;
}
}
PC类：
package code111;
public class PC {
HardDisk HD;
CPU cpu;
public void setCPU(CPU c) {
cpu = c;
}
public void setHardDisk(HardDisk h) {
HD = h;
}
public void show() {
System.out.println("cpu的速度是：" + cpu.getSpeed());
System.out.println("硬盘的容量是：" + HD.getAmount());
}
}
主类Test：
package code111;
public class Test {
public static void main(String[] args) {
CPU cpu = new CPU();
cpu.setSpeed(2200);
HardDisk disk = new HardDisk();
disk.setAmount(200);
PC pc = new PC();
pc.setCPU(cpu);
pc.setHardDisk(disk);
pc.show();
}
}
我们来回顾一下面向对象的核心内容（封装继承和多态）：
1、封装之后才会形成真正的“对象”，才会有独立体的概念。私有的属性不能在外部直接访问，这就是封装（只能通过入口（一般是set、get方法）来访问）。
2、有了继承之后才有了“方法重写”和“多态机制”（继承最重要的作用）。还有一个作用是“代码复用”。在Java中只支持单继承。
哪些不能被继承呢？ 私有的、构造方法。这些不能被继承
3、父类型引用指向子类型对象这种机制导致程序存在编译阶段绑定和运行阶段绑定两种不同的状态，这种机制称为一种多态语法机制。
4、多态中会遇到的异常（java.lang.ClassCastException异常），这种异常出现在向下转型的时候。使用instanceof运算符配合一些逻辑代码可以避免此类异常。
第五章以及后面的内容我会抽时间更新的，肯定不会断更的。由于比较忙，会找空闲时间来更新的，抱歉啦。你们的三连是我最大的动力୧(๑•̀◡•́๑)૭
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
