第二章 Java语言编程基础
2.1 了解Java的标识符与关键字
下面我们通过一个 简单的程序来学习java中的标识符与关键字。
//Example2_1.java
//输入两个数，然后求和
package Chapter2;//声明程序所在包
import java.util.Scanner;
public class Example2_1 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int x,y,z;
System.out.println("请输入两个整数：");
//Scanner类表示一个文本扫描器，它可以扫描从键盘上输入的字符
Scanner in=new Scanner(System.in);//根据Scanner类创建in对象
x=in.nextInt();
y=in.nextInt();
z=x+y;
System.out.println(x+"+"+y+"="+z);
}
}
上例中，类名Example2_1，变量名x、y和z，对象名in等均属于用户定义的标识符，而public、class、static、void、int等均属于Java 语言本身定义的关键字。
一、Java标识符的命名规则
Java的标识符命名规则如下：
（1）标识符由字母、数字、下划线、美元符号组成，没有长度限制。
（2）标识符的首字符必须是字母、下划线（_）或美元符号（$）。
（3）标识符中的字母是区分大小写的，比如Dog和dog是不同的标识符。
（4）常量通常以大写字母英文单词命名，变量通常以小写字母英文单词命名。如果一个变量名由多个单词构成，第一个单词为小写，第二个单词首字 母大写，如anInt。
（5）类的标识符通常以大写英文字母开始。
（6）Java关键字、保留字等不能作为用户自定义标识符使用。
二、Java关键字与保留字
关键字（keyword）是指编程语言预先定义的标识符，在程序中有其特殊的含义，用户不能将其作为自定义标识符。
abstract（抽象） assert（断言） boolean（布尔） break（中断） byte（字节）
catch（捕获） char（字符） class（类） continue（继续） default（默认）
do（做） double（双精度） else（否则） enum（枚举） extends（继承）
false（假） final（最终） finally（最终） float（单精度浮点） for（当…时候）
if（如果） implements（实现） import（引入） instanceof（是…的实例） int（整数）
interface（接口） long（长整数） native（本地） new（新建） null（空）
package（打包） private（私有） protected（受保护） public（公共） return（返回）
short（短整数） static（静态） strictfp（精确浮点） super（超级的） switch（转换）
保留字（reserved word）是指Java语言预留的但暂时没有使用的关键字。对于保留字，用户也不能将其作为标识符使用。
byValue（按值） case（情形） const（常量）
future（将来） generic（类属） goto（跳转到）
inner（内部） outer（外部） operator（运算符）
rest（余数） var（变量）
2.2 了解Java的数据类型
一、Java的数据类型
Java的数据类型分为简单数据类型和复合数据类型。
（1）byte、short、int、long均用于表示整数，只不过它们的取值范围不同。
（2）float和double均用于表示浮点型数值，其区别在于它们所能表示的数值范围 和精度不同。其中，double型比float型可以存储范围更大，精度更高的数值。
（3）字符型（char）用来表示Unicode字符集中的符号，如各种控制字符、字母、数字和汉字。Unicode字符集采用十六进制数表示每一个字符，如‘\u0061’表示小写字母a。
（4）布尔型（boolean）只有“真”（true）和“假”（false）两个值。
二、数据类型转换
在编写程序时，由于参与运算的变量或常量的数据类型不同，或者表达式结果与目标变量的数据类型不同，我们会经常碰到数据类型的转换问题。
//DataTypeConvert.java
package Chapter2;
public class DataTypeConvert {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
char c1='a', c2='b', c3; //声明三个字符变量
int x1=10, x2, x3; //声明三个整型变量
float y1=20.56F, y2; //声明两个浮点型变量
c3=(char)(c1+c2); //两个字符相加，表示其ASCII码值相加，结果为整型
//由于c3为字符型，故必须将整型强制转换为字符型
x2=x1+c1; //整型字符型（实际上是字符的ASCII码值），结果为整型
x3=(int)(x1+y1); //整型加浮点型，结果为浮点型。由于x3为整型，
//其级别低于浮点型，故必须进行强制转换。
y2=x1*y1; //整型与浮点型相乘，结果为浮点型
System.out.println("c3="+c3+" x2="+x2+" x3="+x3);
System.out.println("y2="+y2);
}
}
1.简单数据类型的优先级
在Java中，为了规范简单数据类型的转换，系统基于各种简单数据类型取值精度的不同，为各种简单数据类型规定了不同的优先级，具体如下：（byte、short、char） → int → long → float → double
2.数据类型的自动转换与强制转换
在参与运算的数据包含多种数据类型，或者赋值语句中左侧赋值变量和右侧表达式结果类型不同时，有如下几个原则：
① 如果赋值变量的数据类型优先级高于表达式结果数据类型的优先级，则表达式
结果的数据类型将被自动转换为赋值变量的数据类型。
② 如果赋值变量的数据类型优先级低于表达式结果数据类型的优先级，或者两者同级，则表达式结果的数据类型必须强制转换为赋值变量的数据类型。
三、各种数据类型数据的表示方式
1.整型数值
整型数值有三种表示形式：十进制整数、八进制整数和十六进制整数， 其特点如下：
十进制表示方法：由正、负号和数字0~9组成，但数字部 分不能以0开头 。例如：int x=10, y=-24;
八进制表示方法：由正、负号和数字0~7组成，数字部分以0开头 。例如：short x=010, y=-024;
十六进制表示方法：由正、负号，数字09，字母AF或af（表示数值1015）组成，数字部分以0X或0x开头 。
例如：int x=0xffff, y=-0X3D4;
提示：对于长整型变量来说，数值后必须添加后缀字母L或l。同
时，由于小写字母“l”很容易与阿拉伯数字“1”混淆，建议使用“L” 。
2.浮点型数值
浮点型数值有如下两种表示方式：
（1）小数表示法，它由整数部分和小数部分组成， 例如：4.0，5.32。
（2）科学表示法，它常用来表示很大或很小的数，表示方 法是在小数
表示法后加“E”或“e”及指数部分。但要注意， “E”或“e”前面必须
有
数字，指数部分可正可负，但必须都是整数。例如：4.2E-5，3E6。
3.字符值
字符值有普通字符表示法和转义字符表示法两种。例如：char c1 = ‘a’,
c2 = ‘\n’, c3=‘人’;
普通字符表示法是用单引号括起来的一个字符，而且区分大小写， 例如：‘A’和‘a’是两个不同的字符，而‘VC’是不合法的。
转义字符表示法的格式为“\字符”，主要用来表示一些无法显示的字符，
如回车符、换行符、制表符等。
常用的转义字符及其功能：
4.字符串值
字符串值是使用双引号括起来的零个或多个字符，且字符串中可以包含转义字符。例如：String c1 = “I am Java!”; String c2 = “\n换行”;
5.布尔型值
布型尔数据只有两个值：true和false，分别表示真和假。例如：
boolean cond1 = true, cond2 = false;
2.3 了解Java的变量和常量
一、声明变量的方法
变量是指在程序运行过程中可以发生变化的量，它用于在程序运行时临时存放数据。声明变量的语法格式如下：
datatype variablename1 [,variablename2[,variablename3] ];
datatype表示Java中任意的数据类型；variablename1表示任意合法的变量名。我们可以同时声明多个变量，各变量之间用逗号分隔。例如：char a; int i1,i2;
Java变量又分为成员变量（位于类中方法体以外的变量）和方法变量（位于方法体内的变量，又称局部变量）。对于成员变量而言，我们还可以为其增加访问控制修饰符（如public、private等）和“static” 字样，以限制访问变量的权限和变量的创建方式。 例如：
public int var2; public static int var3;
二、声明常量的方法
常量是指在程序运行过程中不能改变的量，它用来记忆一个固定的数值。也就是说，常量只能被赋值一次。
在Java中，常量用final来声明，而且常量名全部用大写字母，以便与变量名有所区别。
定义常量的的一般格式如下：
final datatype CONSTANTNAME=值或表达式;
datatype表示Java中的任意数据类型，CONSTANTNAME是用户自定义的合法的常量名， 例如：
final double PI = 3.14, RADIUS = 20;
final double CIRCUMFERENCE = 2 * PI * RADIUS;
2.4 了解Java的运算符与表达式
运算符是指具有运算功能的符号。参与运算的数据称为操作数， 运算符和操作数按照一定规则组成的式子称为表达式。
根据操作数个数不同，可以将运算符分为三种：单目运算符（又称一元运算符）、双目运算符（又称二元运算符）和三目运算符（又称三元运算符）。
根据运算符的性质或用途不同，Java中的基本运算符分为以下几类：
（1）算术运算符：+，-，，/，%，++，- -
（2）关系运算符：>，<，>=，<=，= =，!=
（3）逻辑运算符：！，&&，||
（4）位运算符：>>，<<，>>>，&，|，^，~
（5）赋值运算符：= ，+=，-=，=，/= ，%=等
（6）条件运算符：？和：成对使用
一、算术运算符及其表达式
算术表达式由算术运算符和操作数组成，用于完成基本的算术运算。算术表达式的操作数包括常量、变量等。根据操作数个数的不同，算术运算符可以分为双目运算符和单目运算符两种。
二、关系运算符及其表达式
关系表达式由关系运算符和操作数组成，用来比较两个操作数的大小，比较的结果是一个布尔值（True或False）。操作数可以是算数表达式、布尔表达式、整数、浮点数和字符等。
三、逻辑运算符及其表达式
逻辑表达式由逻辑运算符和操作数组成。操作数为布尔值或布尔表达式，运算结果是布尔值。
提示：“&&”和“||”运算符又分别称“短路与”和“短路或”。如果“短路 与”左边的表达式值为false，则整个逻辑表达式的值为false，编译器不再运算右边的表达式。同样，如果“短路或”左边的表达式值为true，则整个逻辑表达式的值为true，右边的表达式也不会再运算。
四、赋值运算符及其表达式
赋值表达式由赋值运算符和操作数组成。赋值运算符用于将其右侧表达式的值赋给左侧变量。在Java中，使用“=”作为赋值运算符，它不同于数学中的等号。
五、条件运算符及其表达式
条件运算符属于三目运算符，即包含3个操作对象，其语法格式如下：
expression1 ? expression2 : expression3;
表达式expression1的值必须为布尔型，表达式expression2与表达式expression3的值可以为任意类型，且类型可以不同。
条件表达式的值取决于expression1的判断结果。如果expression1
的值为true，则执行表达式expression2，否则执行表达式expression3。
编写程序时，对于一些简单的选择结构，使用三目运算符来实现会更简捷。例如：
int x = 20; int y = 10; int max = x >= y ?x : y;
六、位运算符及其表达式
Java提供了可以直接对二进制数进行操作的位运算符 。
七、运算符的优先级
运算符的优先级决定了表达式中运算符执行的先后顺序，而通过改变运算符的结合方向和使用括号可以改变执行的顺序。
2.5 熟悉Java的程序的流程控制
Java的程序流程控制分为顺序结构、选择结构、循环结构和跳转语句。
一、顺序结构
顺序结构就是按照程序代码先后顺序自上而下地执行，直到程序结束，中间没有任何判断和跳转。
二、选择结构
选择结构（又称分支结构）用于判断给定的条件，根据判断的结果来控制程序的流程。选择语句包括if语句和switch语句，它们用来解决实际应用中按不同情况进行不同处理的问题。
1.if语句
if 语句是通过判断给定表达式的值来决定程序流程的。if语句有多种形式，最常见的有如下三种：
第一种形式：
if (expression){ statement;
}
第二种形式：
if (expression){ statement；
}else{ statement;
}
第三种形式：
if (expression){ statement;
}else if(expression){ statement;
}
…… //可以有零个或多个else if语句
else { //最后的else语句也可以视情况省略statement;
}
表达式expression的结果只能是布尔型，即此表达式的结果只能是true或
false。
当表达式expression为true时执行if所对应的代码块，否则，如果有else则执行else对应的代码块。
第二种形式和第三种形式是相通的，如果第三种形式中else if代码块不出现，则变成第二种形式。
else语句必须和if或else if配对使用，else总是与离它最近的if或else if配对，可以通过大括号来改变配对关系。
实例2-1 计算税款
在我国，个人所得税是基于纳税人的情况和应征收入计算的。纳税人情况共分为三种：单身纳税人、已婚纳税人和家庭纳税人。另外，对于不同情况的纳税人，其税率是分档计算的，中国2008年的税率如下表所示。
例如：如果是单身纳税人，可征税收入为10000元，则前6000元的税率为10%，后4000元的税率为15%，则需要缴纳的税额为1200元。
【技术要点】
程序定义两个变量分别表示纳税人的情况和可征税收入，其中用0 表示单身纳税人，1表示已婚纳税人，2表示家庭纳税人。
对每一种纳税人的情况，有五种税率，每种税率对应特定的可征税 收入。例如：一个单身纳税人的收入是10 0000元，则6000元部分的税率为10%，6000-27950部分为15%，27950-67700部分为27%，67700-100000部分为30%。
步骤1：启动Eclipse，在Chapter2包中创建类ComputeTax，并编写如下代码。
// ComputeTax.java
package Chapter2;
import java.util.Scanner;
public class ComputeTax {
public static void main(String[] args) {
double income = 0.0; // 定义可征税收入
int status = 0; // 定义纳税人的情况
double tax = 0; // 定义税额
// 提示用户输入纳税人的类型
System.out.println("请输入纳税人的类型:0-单身，1-已婚，2-家庭");
Scanner inStatus = new Scanner(System.in);
// 方法hasNextInt()判断扫描器的输入内容是否可以解释为int型数据
if (inStatus.hasNextInt()) {
// 方法nextInt()将输入信息扫描为一个int型数据
status = inStatus.nextInt(); // 输入纳税人的类型
}
System.out.println("请输入可征税收入：");
Scanner in = new Scanner(System.in);
if (in.hasNextDouble()) {
income = in.nextDouble(); // 输入可征税收入
}
if (status == 0) { // 计算单身纳税人的缴纳税额
if (income <= 6000)
tax = income * 0.10;
else if (income <= 27950)
tax = 6000 * 0.10 + (income - 6000) * 0.15;
else if (income <= 67700)
tax = 6000 * 0.10 + (27950 - 6000) * 0.15 + (income - 27950)
* 0.27;
else if (income <= 141250)
tax = 6000 * 0.10 + (27950 - 6000) * 0.15 + (67700 - 27950)
* 0.27 + (income - 67700) * 0.30;
else
tax = 6000 * 0.10 + (27950 - 6000) * 0.15 + (67700 - 27950)
* 0.27 + (141250 - 67700) * 0.30 + (income - 141250)
* 0.35;
} else if (status == 1) { // 计算已婚纳税人的缴纳税额
if (income <= 12000)
tax = income * 0.10;
else if (income <= 46700)
tax = 12000 * 0.10 + (income - 12000) * 0.15;
else if (income <= 112850)
tax = 12000 * 0.10 + (46700 - 12000) * 0.15 + (income - 46700)
* 0.27;
else if (income <= 171950)
tax = 12000 * 0.10 + (46700 - 12000) * 0.15 + (112850 - 46700)
* 0.27 + (income - 112850) * 0.30;
else
tax = 12000 * 0.10 + (46700 - 12000) * 0.15 + (112850 - 46700)
* 0.27 + (171950 - 112850) * 0.30 + (income - 171950)
* 0.35;
} else if (status == 2) { // 计算家庭纳税人的缴纳税额
// ……
if (income <= 10000)
tax = income * 0.10;
else if (income <= 37450)
tax = 10000 * 0.10 + (income - 10000) * 0.15;
else if (income <= 96700)
tax = 10000 * 0.10 + (37450 - 10000) * 0.15 + (income - 37450)
* 0.27;
else if (income <= 156600)
tax = 10000 * 0.10 + (37450 - 10000) * 0.15 + (96700 - 37450)
* 0.27 + (income - 96700) * 0.30;
else
tax = 10000 * 0.10 + (37450 - 10000) * 0.15 + (96700 - 37450)
* 0.27 + (156600 - 96700) * 0.30 + (income - 156600)
* 0.35;
}
System.out.println("纳税人需要缴纳的税额为" + tax + "￥");
}
}
步骤2：保存文件并运行程序 ，程序的运行结果如下所示。
2.switch语句
switch语句（多分支语句）是通过数据匹配的方式实现程序的多分支控制 。
switch (expression){ case value1:{
statement1; break;
}
case value2:{
statement2; break;
}
.....//可以有多个case代码块case value N:{
statementN; break;
}
default:{
default statement;
}
}
表达式expression的返回值类型只能是char、byte、short或int型。
switch语句先取得表达式expression的返回值，然后根据返回值依次与每个case 语句所对应的value1，value2，…， valueN值匹配，如果匹配成功则执行对应的代码块。
case语句所对应的value值必须为常量， 而且各value值应当不同。
break语句用来在执行完相应的case分支语句后跳出switch语句，否则将顺序执
行后面的语句。
default是可选的，当表达式的值与任何的value值都不匹配时，则执行default代码块。如果没有default语句时，则程序不做任何操作，直接跳出switch代码块。
实例2-2 输出某年某个月的天数
【实例描述】
本程序运行时，将在屏幕上输出指定年份中指定月份的天数。读者可通过此实例进一步熟悉多分支语句switch的语法格式及其用法。
【技术要点】
一年有12个月，其中1、3、5、7、8、10、12月的天数为31 天；4、6、9、11月的天数为30天；闰年时，2月份的天数为29天， 其他年份为28天。
判断当前年份是否为闰年，如果为闰年，则该年份应能被4整除， 但不能被100整除，或者该年份能被400整除。
步骤1：启动Eclipse，在Chapter2包中创建类ShowDays，并编写如下代码。
// ShowDays.java
package Chapter2;
import java.util.Scanner;
public class ShowDays {
public static void main(String[] args) {
System.out.println("请输入年份：");
Scanner inYear = new Scanner(System.in);
int year = inYear.nextInt(); // 输入年
System.out.println("请输入月份：");
Scanner inMonth = new Scanner(System.in);
int month = inMonth.nextInt(); // 输入月份
int numDays = 0;
switch (month) { // 以月份作为分支条件
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
numDays = 31; // 1、3、5、7、8、10、12月天数为31
break; // 跳出switch语句
case 4:
case 6:
case 9:
case 11:
numDays = 30; // 4、6、9、11月天数为30
break;
case 2: // 对于2月，根据是否为闰年判断当月天数
if (((year % 4 == 0) && !(year % 100 == 0)) || (year % 400 == 0)) {
numDays = 29;
} else {
numDays = 28;
}
break;
}
System.out.println(year + "年" + month + "月份" + " 有" + numDays + " 天");
}
}
步骤2：保存并运行程序，查看程序的运行结果。
三、循环结构
利用循环结构可以重复执行某一段代码，直到不满足循环条件为止。循环结构主要有for、while和do-while三种循环语句 。
1.for语句
for语句通常适用于明确知道循环次数的情况，其语法格式如下：
for (initialization;condition;iteration){
statement;
}
循环的初始化（initialization）：只在循环开始前执行一次，通常在此进行迭代变量的定义 。
条件（condition）表达式：这是一个布尔类型表达式，如果其值为真，执行循环体内的语句（statement），如果为假则结束循环。
迭代（iteration）表达式：通常是迭代变量的自增或自减运算表达式，在循环体执行完毕时执行。
2.while语句
while语句通常用于重复执行次数不确定的循环，其语法格式如下：
while(expression){
statement;
}
expression是一个布尔表达式；while语句首先取得expression的返回值，当返回值为true时，执行循环体中的语句statement，否则，循环结束。
3.do-while语句
do-while语句与while语句的区别在于第一次循环时，while语句是先判断循环条件，再循环，如果条件为假，则循环体不会被执行。而do-while语句则是先执行循环体后判断。
do-while语句的语法格式如下：
do{
statement;
}while(expression);
实例2-3 游戏中生命力购买问题
【实例描述】
在一场名为Game的游戏中，作为玩家的你手头拥有若干个金币。为增加生命力，你需要购买仙女草和银河梭两件宝物。其中仙女草每件售价20个金币，可增加玩家30个单位的生命力；银河梭每件售价16 个金币，能够增加玩家20个单位的生命力。
编程求出一种最佳购买方案，使得用你的金币购买的宝物能够最大限度地增加你的生命力（不一定要用完所有金币），并输出最佳方案中每件宝物的购买数量。
【技术要点】
首先输入金币的数量，然后计算出这些金币所能购买的仙女草和银河梭的最大与最小数量；随后构造双层嵌套的循环结构，外层循环以仙女草的数目为循环变量，内层循环以银河梭的数目为循环变量； 循环体中找出能够得到最大生命力的购买方案，并记录下购买方案中各变量值，最后输出结果。
// Game.java
package Chapter2;
import java.util.Scanner;
public class Game {
static final int FGVALUE = 20; // 定义仙女草的售价
static final int GSVALUE = 16; // 定义银河梭的售价
static final int FGLIFE = 30; // 定义仙女草增加的生命力
static final int GSLIFE = 20; // 定义银河梭增加的生命力
public static void main(String[] args) {
int goldcoin = 100; // 定义金币的数量
int fg_num = 0, gs_num = 0; // 定义仙女草与银河梭的数量
int max_life = 0; // 定义最大生命力值
System.out.println("请输入金币的数量：");
Scanner in = new Scanner(System.in); // 根据Scanner类创建in对象
goldcoin = in.nextInt(); // 方法nextInt()返回键盘上输入的一个整数
for (int fg_loop = 0; fg_loop <= (goldcoin / FGVALUE); fg_loop++)
for (int gs_loop = 0; gs_loop <= (goldcoin / GSVALUE); gs_loop++)
if (((fg_loop * FGVALUE + gs_loop * GSVALUE) <= goldcoin)
&& ((FGLIFE * fg_loop + GSLIFE * gs_loop) > max_life)) {
fg_num = fg_loop; // 记录仙女草的数量
gs_num = gs_loop; // 记录银河梭的数量
// 记录增加的最大生命力
max_life = FGLIFE * fg_loop + GSLIFE * gs_loop;
}
System.out.println("购买的宝物最多能增加你" + max_life + "个生命力！");
System.out.println("购买仙女草的数量为" + fg_num);
System.out.println("购买银河梭的数量为" + gs_num);
}
}
四、跳转语句
通过跳转语句可以实现程序流程的跳转。 Java中的跳转语句包括break语句、continue语句和return语句。
1.break语句
break语句可以用在循环语句的内部，用来结束循环。
public static void main(String args[]){ int i = 0;
while(i < 10){ //i<10时执行while循环
i++; //i自身加1
if(i = = 5){ //如果i等于5，则退出循环break ;
}
System.out.println(i); //输出i值
}
System.out.println("循环结束");
}
2.continue语句
continue语句只能用在循环语句内部，用来跳过本次循环，继续执行下一次循环。
在while和do-while循环结构中使用continue语句，表示将跳转到循环条件处继续执行；而在for循环结构中使用continue语句，表示将跳转到迭代语句处继续执行。
public static void main(String args[]){ int i = 0;
while(i < 4){ i++;
if(i = = 2){ //当i等于2时，执行continue语句
continue; //跳过过本次循环，直接执行下一次循环
}
System.out.println(i); //当执行continue语句后，这行代码将执行不到
}
System.out.println("循环结束");
}
3.return语句
return语句用在方法中，作用是终止当前方法的执行，返回到调用该方法的语句处，并继续执行程序。
return语句的语法格式如下：
return [expression];
return语句后面可以带返回值，也可以不带。
表达式expression可以是常量、变量、对象等。return语句后面表达式的数据类型必须与方法声明的数据类型一致。
当程序执行return语句时，先计算表达式的值，然后将表达式的值返回到调用该方法的语句处。
位于return语句后面的代码不会被执行，所以return语句通常位于代码块的最后。
2.6 掌握Java程序的注释用法
Java有三种程序注释方式，分别为单行注释、多行注释和文档注释， 其特点如下：
单行注释以双斜杠“//”开始，终止于本行结束。单行注释多用于对一行代码的简短说明。
多行注释以“/”开始，以“/”结束，两者之间的所有字符都是多行注释的内容。多行注释通常用于对文件、方法、数据结构等的说
明，或者算法的描述。多行注释一般位于方法的前面，起引导作用， 也可以根据需要放在其他合适的位置。
文档注释以“/**”开始，以“*/”结束，在此之间的所有字符都是文档注释的内容。文档注释主要是为了支持JDK工具javadoc，通过javadoc，文档注释将会生成HTML格式的代码报告，因此文档注释应当书写在类、构造方法、成员方法以及常量或变量的定义之前。
本章小结
本章首先介绍了Java中标识符与关键字、数据类型、变量和常量等基础知识，之后介绍了Java的运算符及其表达式，最后通过多个实例重点讲述了程序流程控制方面的知识，并对Java的几种程序注释方法作了简要说明。
380
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
