第2章Java程序设计基础
2.1 标识符和关键字
2.1.1 标识符
Java程序中的变量、方法、类、对象等元素都应有自己的名称，各元素的名称通称为标识符。Java语言中，标识符是以字母、下划线（_）、美元符($)开始的一个字符序列，后面可以跟字母、下划线、美元符($)、数字。标识符不能和关键字同名，Java中的标识符没有长度限制。
例如：
userName，User_Name，_sys_val，$change为合法的标识符；而2student，Hello#，class为非法的标识符。
注意：Java标识符是区分大小写的，userName和UserName将会被视为两个不同的标识符。
Java标识符命名的一般约定：
（1）类名和接口名使用Pascal命名法，即所有单词连写，每个单词的第一个字母大写，其他字母小写。如：HelloWorld，GetData等。
（2）方法名，变量名，一般对象名，控件对象名以及方法的参数名均使用Camel命名法，即所有单词连写，第一个单词全部小写，其他每个单词的第一个字母大写，其他字母小写。如：userName，studentScore等。
（3）常量名，名字应该全是大写字母，使用下划线分隔单词，如MAX_HEIGHT。
2.1.2 关键字
关键字，又称为保留字，是某种语言事先定义的一组具有特定含义的词汇。下面是Java语言中的关键字：
abstract assert boolean break byte case
catch char class const continue default
do double else enum extends false
final finally float for goto if
implements import instanceof int interface long
native new null package private protected
public return short static strictfp super
switch synchronized this throw throws transient
true try void volatile while
注意：C++语言中的某些关键字，在Java语言中不是关键字，如sizeof。有些关键字是Java语言保留的没有意义的关键字，如const，goto等。
2.1.3 注释
注释在程序中主要起到说明、注解程序的作用。编译程序的时候，注释部分都会被忽略掉。为程序加上注释可以大大增加程序的可读性，这样便于以后对程序进行修改、维护。Java语言支持3种类型的注释。
⒈单行注释
“//”标记用于单行注释，自“//”标记开始到该行结束的所有内容均为注释。
如：//单行注释内容
⒉多行注释
多行注释是在要注释的起始行的开始处加入“/*”标记作为开始，并在最后一行的结尾处加入“*/”标记作为结束。
如：/* 多行注释内容
…………
……*/
⒊文档注释
文档注释是以“/**”标记开始，以“*/”标记结束的多行。文档注释是Java特有的，并可通过javadoc 工具转换成HTML文件。一个注释对应一个类、接口或成员。该注释应位于声明之前，如下面的代码所示。
/**
* Student类的主要功能是…
*/
public class Student { …}
同样，对方法使用文档注释也应位于方法的声明之前。
2.2 常量和变量
2.2.1 常量
在程序运行过程中，其值不能被改变的量称为常量。常量分为常数常量和符号常量。
⒈常数常量
常数常量也叫字面值，共有五种类型：整型、浮点型、字符型、布尔型和字符串常量。如238、-985为整型常量，1.234、3.2E3为浮点型常量，'a'、'B'为字符型常量，"This is a String"为字符串常量。
注意：字符串常量是用双引号定界的，字符串不属于基本数据类型。关于数据类型，我们将在2.3小节介绍。
⒉符号常量
为了方便，在程序中经常把不允许修改的量用一个标识符表示，该标识符称为符号常量。由final关键字来定义。例如，下面定义了几个符号常量：
final int NUM=35;
final double PI=3.1415926;
final int XL;
符号常量可以在声明的同时赋值，也可以稍后赋值。不管哪种情况，一旦赋值就不允许修改。
2.2.2 变量
为了在Java中存储一个数据，必须将它容纳在一个变量之中。之所以称为“变量”，是因为在变量中可根据需要存入不同的数据。变量具有名称、类型、作用域等特性，在使用一个变量前必须先定义。
其定义格式如下：
typeSpecifier varName[=value[,varName[=value]…];
如：int count;
int a,b,c;
char c='a';
变量的作用域指明可访问该变量的一段代码，声明一个变量的同时也就指明了变量的作用域。按作用域来分，变量可以有下面几种：局部变量、成员变量、方法参数和异常处理参数。在一个确定的域中，变量名应该是唯一的。局部变量在方法或方法的一个块代码中声明，它的作用域为它所在的代码块（整个方法或方法中的某块代码）。成员变量在类中声明，而不是在类的某个方法中声明，它的作用域是整个类。方法参数传递给方法，它的作用域就是这个方法。异常处理参数传递给异常处理代码，它的作用域就是异常处理部分。
2.3 基本数据类型
Java编程语言定义了八种基本的数据类型(见表2-1)，共分为四大类：整数类型(byte、short、int、long)、浮点类型(float、double) 布尔类型(boolean)、字符类型(char)。
表2-1 Java语言的基本数据类型
2.3.1 整数类型
⒈整型常量
Java的整型常量有三种形式：十进制、八进制和十六进制。
十进制整数以10为基数，用0~9的10个数字和正、负号组成，如-123，518。
八进制整数以8为基数，用0~7的8个数字和正、负号组成。八进制整数必须以0开始，如0156表示十进制数110，-012表示十进制数-10。
十六进制整数以16为位基数，用0~9的10个数字、字母A~F(小写也可，代表10~15这些整数)和正、负号组成。十六进制整数必须以0X或0x作为开头。如0x123表示十进制的291，-0xabc表示十进制数的2748。
每一个整型常量默认为int类型，占有32位(即4个字节)的存储空间。如果希望把一个整数强制存为一个长整型数，可以在数字后面加字母l或L。如158L，它在JVM中占64位的存储空间。
⒉整型变量
Java的整型变量有byte、short、int、long共4种类型。这里需要提醒的一点就是：Java语言中没有无符号整数类型。下面是几个整型变量的定义：
byte bb;
short y = 3456;
int i=987654321;
long k=1234;
2.3.2 浮点类型
⒈浮点型常量
Java的浮点型常量有标准和科学计数法两种表示形式。
⑴标准形式，由数字和小数点组成，且必须有小数点，如0.123、4.56、789.0、.43等。
⑵科学计数法形式，数字中带e或E，其中e或E的前后都必须有数字，且e或E后面的数字(表示以10为底的乘幂部分)必须为整数。如123e-2或4.56E3等。
浮点型常量的默认类型为double型，单精度float型的存储空间为32位(4个字节)。若带有后缀，则按后缀决定类型。浮点型常量用F或f作后缀时，表示单精度浮点型；用D或d作后缀时，表示双精度浮点型，如12f、3.4d、0.56e-7f、89e10d等。
⒉浮点型变量
浮点型变量有float型和double型两种。它们存放的位长分别是32位和64位。下面是几个浮点型变量的定义：
float f;
float r = 3.45f;
double d;
double s = 3.1415926535897932384;
注意：由于浮点型常量的默认类型是double型，所以如果需要float型的常量，必须显示指明，即在一个浮点型常量的后面加一个字母f或F。由于Java加强了类型检查，所以初始化一个实数时必须分清它是float型还是double型。
2.3.3 布尔类型
布尔类型（boolean）是最简单的一种数据类型，布尔型数据只有两个值：true和false，表示“真”和“假”两种状态。布尔型变量用boolean定义，例如：
boolean flag=true;
boolean mouseDown=false;
Java中的布尔类型不能转换成数字。
2.3.4 字符类型
字符类型（char）是存储字符的数据类型，它在机器中占16位，范围为0~65535。Java中的char型与C/C++中的char型不同。在C/C++中，char型采用的是ASCII字符集，宽度为8位，范围为0~255，而Java 中char型采用的是Unicode字符集，范围较ASCII字符集更大，可以表示更多的字符。
⒈字符型常量
字符型常量是由一对单引号括起来的单个字符。
在Java中还有一些不能直接加上单引号的特殊字符，需通过转义字符来表示。转义字符以反斜杠“\”开头，将其后的字符转换为另外的含义，表2-2列出了Java中的转义字符。
表2-2 常见的转义字符序列
⒉字符型变量
字符型变量的类型说明符是char，在机器中占16位，表示的数据范围是0~65535。下面是几个字符型
变量的定义：
char c1 = 'c';
char c2='\u0062';
char ch1=89; //89是字符' Y '的ASCII码
2.3.5 各类型数据间的相互转换
Java中的基本数据类型的转换分为两种：自动类型转换和强制类型转换。
⒈自动类型转换
定点和浮点类型都可看作是数值型数据，当不同的数值型数据运算时，有一个内在的规则：先统一为同一类型，再进行运算。结果就为运算前统一的类型。这里的“统一”就是自动类型转换。自动类型转换是由系统自动进行。
自动类型转换总是从低级到高级进行，数据类型高低是由在内存中所占的位数决定的，占内存位数多的为高类型，占内存位数少的为低类型。因此，byte、char、short的级别最低，double的级别最高，具体顺序如下：
byte，short，char →int →long →float →double
byte、short、char型数据只要参与运算，就首先将类型转为int后进行运算，所以即使short型数据之间的运算，运算结果也是int型。如果int型数据与float型数据运算，int型数据会自动转换成float型，运算结果也为float型。
有多种类型的数据混合运算时，系统首先自动将所有数据类型转换为容量最大的那一种数据类型，然后再进行计算。
[例2-1] 如有以下变量定义，请回答算式：x + y、x + y + z、a + b、a - x - y、x + c的结果分别是何种类型。
int x;
byte y;
long z;
float a;
double b;
char c;
分析：x + y的结果应为int型，x + y + z的结果为long型，a + b的结果为double型，a - x - y的结果为float型，x + c的结果为int型。
⒉强制类型转换
不同类型数据之间的运算和赋值时，低级别类型的数据可以自动转换成高级别类型的数据。欲让高级数据转换成低级数据，需用到强制类型转换，其形式是：
（类型）数据
其中，数据为需要类型转换的常量、变量或表达式。括号中的类型为数据要转换成的类型。注意，当高类型数据强制转换为低类型时，数据精度要受到损失。比如，浮点型数据强制转换成整型时，要截去小数部分。
如：int x = 3.5; //编译出错，高级别的数据不能给低级别的变量赋值
int x = (int)3.5; //将3.5强制转换成int型数据后给同级别的变量x赋值
[例2-2]阅读以下程序，分析它们的运行情况。
1 public class TypeConvExample1 {
2 public static void main(String[] args) {
3 int x = 2;
4 char y = 'a';
5 int z = (int) 3.8;
6 float f = z;
7 System.out.println(y);
8 System.out.println(x + y);
9 System.out.println(z + " " + f);
10 }
11 }
输出结果：
a
99
3 3.0
程序说明：程序中有x + y的运算，char型首先转换成int型，即字符对应的ASCII码值。而字符'a'对应的ASCII码为97，故程序结果为99。
思考：如何修改程序使x + y输出结果为字符c？
2.4 运算符
在Java中，对各种类型的数据进行加工的过程称为运算，而表示各种不同运算的符号则称为运算符。运算符的类型按操作数的数据分可以分为一元运算符、二元运算符和三元运算符，它们分别对应于一个、两个和三个操作数；按照运算符的功能来分，运算符可以分为算术运算符、赋值运算符、条件运算符、位运算符、关系运算符、逻辑运算符等。
2.4.1 算术运算符
算术运算由算术运算符完成，可以实现最基本的数值运算。算术运算符可分为一元运算符和二元运算符两类。一元运算符只对一个操作数进行运算，见表2-3。二元运算符需要两个操作数参与，有加、减、乘、除、求余（取模）五种，见表2-4。
⒈一元算术运算符
具体如表2-3所示，设x的值为10。
表2-3 一元算术运算符
++和—既可以是前置运算符也可以是后置运算符，这就是说，它们既可以放在操作数(必须是变量)前面(如++x)，也可以放在后面(如x++)。单独使用的时候，前置后置作用相同。但若在表达式中使用，前置后置的意义是不同的。前置时，变量的值先增1或减1，然后用变量的新值参加表达式的计算;后置时，变量的值先参加表达式的计算，然后变量再增1或减1。例如：
i = 5;
j = i++;
执行后，j为5，i为6。而
i = 5;
j = ++i;
执行后，j为6，i为6。
⒉二元算术运算符
具体如表2-4所示，设a=10，b=3。
表2-4 二元算术运算符
这些都是常用的运算，对二元算术运算符，有两点要注意：
⑴两个整数运算的结果是整数，5/2结果是2而不是2.5。
⑵取模运算是求两个数相除的余数，如17%3的结果是2。可以对实数求余数。实数a%b的结果为a-(int)(a/b)*b，余数的符号与被除数a相同。如123.4%10的结果为3.4。
[例2-3] 算术运算符应用举例。
1 public class ArithmaticOp {
2 public static void main(String args[]) {
3 int i = 4, j = 2;
4 int z;
5 z = i + j;
6 System.out.println(z);
7 z = i - j;
8 System.out.println(z);
9 z = i * j;
10 System.out.println(z);
11 z = i / j;
12 System.out.println(z);
13 z = i % j;
14 System.out.println(z);
15 i++;
16 System.out.println(i);
17 j--;
18 System.out.println(j);
19 }
20 }
输出结果：
6
2
8
2
5
1
2.4.2 赋值运算符
⒈简单赋值运算符(=)
赋值运算符“=”用来将一个数据赋给一个变量。在赋值运算符两侧的类型不一致的情况下，若左侧变量的数据类型的级别高，则右侧的数据被转换为与左侧相同的高级数据类型，然后赋给左侧变量。否则，需要使用强制类型转换运算符。而如果表达式类型与变量类型是不可互转的，这样的赋值运算在编译时将出错。
byte b = 4;
int i = b; //自动类型转换
int i = 4;
byte b = (byte)i; //强制类型转换
⒉复合赋值运算符
Java语言允许使用复合赋值运算符，即在赋值符前加上其他运算符。复合赋值运算符是表达式的一种缩写。例如：a+=5等价于a=a+5。复合赋值运算符有11种，如表2-5所示，设a=10，b=3。
表2-5 复合赋值运算符
复合赋值运算符的右边是一个整体，例如：a*=b+c;等价于a = a*(b+c);
2.4.3 条件运算符
条件运算符是一个由“？”和“：”组成的三元运算符，其格式如下：
e1 ？e2 ：e3
式中的e1为条件，应是布尔型数据，e2和e3可以是任意类型、但必须类型一致的数据。若条件e1为真，则条件运算结果为e2的值；若条件e1为假，则条件运算结果为e3的值。例如：下面语句可以求x 和y中的较大数，并赋值给变量max：
max = x > y ? x : y;
2.4.4 位运算符
位运算符分为逻辑位运算符和移位运算符。这些运算符用来对二进制位进行操作。
在Java语言中，整数是用补码表示的。在补码表示中，最高位为符号位，正数的符号位为0，负数的符号位为1。若一个数为正数，补码与原码相同；若一个数为负数，补码为原码的反码加1。
例如：
+42的补码为：00000000 00000000 00000000 00101010
-42的补码为：11111111 11111111 11111111 11010110
⒈逻辑位运算符
Java中共有4种逻辑位运算符。如表2-6所示，设a=10，b=3。
表2-6 逻辑位运算符
表2-7 逻辑位运算符的运算规则
⒉移位运算符
移位运算符面向的运算对象也是二进制位，用来处理整型或字符型数据。Java语言提供了3个移位运算符：左移运算符（<<）、右移运算符（>>）、无符号右移运算符（>>>）。
⑴左移运算符（<<）能将运算符左边的运算对象向左移动运算符右侧指定的位数（在低位补0）。
例如：16<<2
16的二进制序列为：00000000 00000000 00000000 00010000
执行16<<2后，结果为：00000000 00000000 00000000 01000000即64。
⑵右移运算符（>>）则将运算符左边的运算对象向右移动运算符右侧指定的位数。右移运算符使用了“符号扩展”：若值为正，则在高位插入0；若值为负，则在高位插入1。
例如：-16 >> 2
-16的二进制序列为：11111111 11111111 11111111 11110000
执行-16 >> 2后，结果为：11111111 11111111 11111111 11111100即-4。
⑶无符号右移运算符（>>>）也是将运算符左边的运算对象向右移动运算符右侧指定的位数，但它使用“零扩展”：即无论正负，都在高位插入0。
例如：-16 >>> 2
-16的二进制序列为：11111111 11111111 11111111 11110000
执行-16 >>> 2后，结果为：00111111 11111111 11111111 11111100即1073741820。
[例2-4] 移位运算符示例。
1 public class MoveBitOp {
2 public static void main(String[] args) {
3 int a = -36;
4 int b = 2;
5 long r1, r2, r3;
6 r1 = a >> b;
7 r2 = a << b;
8 r3 = a >>> b;
9 // 输出结果
10 System.out.println("a = " + a + " b = " + b);
11 System.out.println("a>>b = " + r1);
12 System.out.println("a<
13 System.out.println("a>>>b = " + r3);
14 }
15 }
输出结果：
a = -36
b = 2
a>>b = -9
a<
a>>>b = 1073741815
2.4.5 关系运算符
关系运算符用来比较两个值，返回布尔类型的值true或 false。关系运算符都是二元运算符，如表2-8所示，设a=10，b=3。
表2-8 关系运算符
Java中，任何数据类型的数据（包括基本类型和组合类型）都可以通过==或!=来比较是否相等。
关系运算符通常用于if语句、循环语句的条件中。
[例2-5] 关系运算符示例。
1 public class RelationOp {
2 public static void main(String[] args) {
3 int i = 88, j = 9;
4 System.out.println("i=" + i);
5 System.out.println("j=" + j);
6 System.out.println("i>j is " + (i > j));
7 System.out.println("i>=j is " + (i >= j));
8 System.out.println("i==j is " + (i == j));
9 System.out.println("i!=j is " + (i != j));
10 }
11 }
输出结果：
i=88
j=9
i>j is true
i>=j is true
i==j is false
i!=j is true
2.4.6 逻辑运算符
逻辑运算符的运算对象必须是逻辑型数据，并且运算结果也是逻辑型数据。逻辑运算符包括以下几种：逻辑非（！）、简洁逻辑与（&&）、简洁逻辑或（||）、非简洁逻辑与（&）、非简洁逻辑或（|）、逻辑异或（^）。假设a、b是两个逻辑型数据，逻辑运算符的运算规则如表2-9所示。
表2-9 逻辑运算符的运算规则
简洁逻辑运算符（&&、||）与非简洁逻辑运算符（&、|）的区别是：在简洁逻辑运算符组成的表达式中，从左至右计算操作数的值，当有一个操作数的值可以确定整个表达式的值时，其后面的操作数不再计算；在非简洁逻辑运算符组成的表达式中，所有操作数的值都必须计算。
2.4.7 其他运算符
⒈“？：”运算符
？：运算符是一个条件运算符，相当于一个简化的if-else语句。其一般形式为：
（<逻辑表达式>）？<结果表达式1>：<结果表达式2>
运算规则：首先计算逻辑表达式的值，若为true则返回结果表达式1的值，否则返回结果表达式2的值。例如：
int x=15;
int y=(x>18) ? 1 : 0 ; //y=0
⒉“[ ]”运算符
可以使用方括号来声明数组、创建数组以及访问数组中的元素。以下是数组声明的一个例子：
int [ ] arrayOfInt = new int[30];
或
int arrayOfInt [ ]= new int[30];
这个语句声明了一个数组来容纳30个整型数据。
⒊点运算符“.”
点运算符“.”用来访问对象实例或者访问类的成员变量或成员方法。
⒋“（）”运算符
当声明或调用一个方法时，可以在“（）”之间列出方法的参数，也可以利用“（）”来指定一个空的参数列表。
⒌“（type）”运算符
这个运算符可以将某个类型的值或对象转换为type类型。
⒍“new”运算符
可以使用new运算符来创建一个新对象或者一个新数组。例如，用https://www.doczj.com/doc/3c5303718.html,ng包中的Integer类创建一个整型数对象的方法如下：
Integer anInteger= new Integer(10);
⒎“instanceof”运算符
“instanceof”运算符用来测试第一个运算对象是否是第二个运算对象的实例，例如：
A instanceif B
这里的A必须是对象名，而B必须是类名。如果一个对象直接或者间接地来自于某个类，那么这个对象就被认为是这个类的一个实例。
2.4.8 运算符的优先级和结合性
在一个表达式中往往存在多个运算符，此时表达式是按照各个运算符的优先级从左到右运算的。也就是说，在一个表达式中，优先级高的运算符首先执行，然后是优先级较低的运算符，对于同优先级的运算符要按照它们的结合性来决定。运算符的结合性决定它们是从左到右计算（左结合性）还是从右到左计算（右结合性）。左结合性很好理解，因为大部分的运算符都是从左到右来计算的。需要注意的是右结合性的运算符，主要有3类：赋值运算符（如“=”、“+=”等）、一元运算符（如“++”、“！”等）和三元运算符（即条件运算符）。运算符具体的优先级顺序如表2-10所示。
表2-10 运算符的优先级和结合性
2.5 表达式
表达式是由操作数和运算符按一定的语法形式组成的符号序列。Java语言中，表达式分为：算术表达式、关系表达式、逻辑表达式和条件表达式5种。
算术表达式：是指表达式的值为算术值的表达式。它包含算术运算符和位操作运算符组成的表达式。
关系表达式：由关系运算符组成的表达式称为关系表达式。表达式的类型是布尔型的，其值为true或
者false。
逻辑表达式：由逻辑运算符组成的表达式称为逻辑表达式。逻辑表达式的值是布尔型的，或者为true 或者false。
赋值表达式：由赋值运算符组成的表达式称为赋值表达式。
条件表达式：由条件运算符组成的表达式称为条件表达式。
如：下面都是表达式的例子。
a + b
a= =b
m> 5 && n % 10 != 0
b=3
对表达式中的操作数进行运算得到的结果称为表达式的值。表达式的值的数据类型即为表达式的类型，一般多个类型的数据运算，最后结果的数据类型以最大的数据类型为准。
如：int a=10; float b=3.2f; double c=4.3;
则(a+b)*c的结果为double型。
表达式的运算应按照运算符的优先级从高到低的顺序进行，优先级相同的运算符按照事先约定的结合方向进行。关于运算符的优先级和结合性参见表2-10。
2.6 程序控制语句
程序控制语句有3类：选择语句，包括if语句和switch语句；循环语句，包括while语句、do-while 语句和for语句；跳转语句，包括break语句、continue语句和return语句。
2.6.1 if语句
if 语句根据条件表达式的真假来控制程序的执行，if 语句的语法格式如下：
if(condition)｛
statement1
}
[else {
statement2
}]
其中condition表示条件表达式，else子句是可选的。如果没有else子句，则构成单分支结构，程序执行的流程是：首先计算条件表达式的结果，如果其结果为true，则执行语句块statement1中的语句，否则转去执行if结构后面的语句；如果有else子句，则程序执行的流程是：首先计算条件表达式的结果，如果其结果为true，则执行语句块statement1中的语句，否则执行语句块statement2中的语句。任何时候，statement1和statement2都不可能同时执行。
当语句块只有一条语句时，可以省略｛｝，但建议写上｛｝。
[例2-6] if语句的一般用法。
1 public class IfExample1 {
2 public static void main(String[] args) {
3 int i = 1;
4 if (i == 1) {
5 System.out.println("i==1");
6 } else {
7 System.out.println("i!=1");
8 }
9 }
10 }
输出结果：
i==1
很多时候，会遇到多分支的情况，if语句也可以用来处理多重分支，具体格式如下：
if(condition1){
statement1;
}else if(condition2){
statement2;
}else if(condition3){
statement3;}
……
else{
statement;}
该语句功能如下：先计算condition1给出的表达式的值，如果该值为true，则执行statement1，然后退出该条件语句。如果condition1表达式值为false，则依次计算condition2表达式的值。如果该值为true，则执行statement2，然后退出该条件语句，否则再计算condition3表达式的值……依次类推。当某个条件表达式的值为true时，执行其后的语句，然后退出该条件语句。如果所有的条件表达式的值都不为true，则执行else关键字后面的语句。
[例2-7] 编写一个程序：根据分数来指定等级。大于等于90分，等级为A；80～89分，等级为B；70～79分，等级为C；60～69分，等级为D；60分以下，等级为E。
1 public class IfExample
2 {
2 public static void main(String[] args) {
3 int score = 88;
4 char grade;
5 if (score >= 90) {
6 grade = 'A';
7 } else if (score >= 80) {
8 grade = 'B';
9 } else if (score >= 70) {
10 grade = 'C';
11 } else if (score >= 60) {
12 grade = 'D';
13 } else {
14 grade = 'E';
15 }
16 System.out.println("grade = " + grade);
17 }
18 }
输出结果：
grade = B
if 语句可以嵌套，即一条if语句的语句块中可以含有一条或多条if语句，当嵌套时必须注意的是：一个else子句总是对应着和它在同一块中的最近的if语句，而且该if语句没有与其他else子句相关联。这里不再举例。
2.6.2switch语句
Java中的switch语句是一个多分支选择语句，它的一般格式如下：
switch(expression) {
case value1:
statement1;
[break;]
case value2:
statement2;
[break;]
……
case valueN:
statementN
[break;]
[default:
default_statement;]
}
其中expression表示表达式，它的值的类型必须为byte、short、int、char。Case子句用来设定每一种情况，后面的值必须与expression的值类型相容。switch语句将表达式expression的值与每个case后面的常量（或常量表达式）的值相比较，如果等于某个值，则执行该case语句后面的代码，直到遇到break语句为止。
break语句的功能是退出switch结构。如果在执行完某个case后面的语句块后就离开switch结构，则
必须在该case结构的后面加上break语句。
如果所有case语句都不满足，且有default语句，则执行default语句后的default_statement语句块，如果没有default语句，则跳到switch语句末端，执行switch程序块后面的语句。
[例2-8] 使用switch结构改写上例。
1 public class SwitchExample1 {
2 public static void main(String[] args) {
3 int score = 88;
4 char grade;
5 score = score / 10;
6 switch (score) {
7 case 10:
8 case 9:
9 grade = 'A';
10 break;
11 case 8:
12 grade = 'B';
13 break;
14 case 7:
15 grade = 'C';
16 break;
17 case 6:
18 grade = 'D';
19 break;
20 default:
21 grade = 'E';
22 }
23 System.out.println("grade = " + grade);
24 }
25 }
输出结果：
grade = B
2.6.3 while与do…while语句
⒈while语句
while语句是Java中最基本的循环语句，这种循环是在某个条件为true时，重复执行一个语句或语句块。它的一般格式如下：
while(condition) {
statement;
}
该语句的功能：当条件表达式condition为true时，反复执行语句块statement，直至condition为false。[例2-9] 利用while语句计算1+2+3+……+100的值。
1 public class WhileExample1 {
2 public static void main(String[] args) {
3 int i = 1;
4 int sum = 0;
5 while (i <= 100) {
6 sum += i;
7 i++;
8 }
9 System.out.println("1+2+3+......+100=" + sum);
10 }
11 }
输出结果：
1+2+3+......+100=5050
⒉do…while语句
do-while语句的格式如下：
do{
statement;
}while(condition);
该语句的功能：首先执行一次循环体(statement)，然后计算条件表达式(condition)的值。如果该表达式值为true，再执行一次循环体(statement)；否则退出该循环语句。
do-while语句与while语句的区别：do-while语句中，不管条件表达式的初始值是true还是false，循环体至少执行一次。而while语句中，若条件表达式的初始值为false，循环体一次也不会执行。
[例2-10] 用do-while语句计算1+2+3+……+100的值。
1 public class DoWhileExample1 {
2 public static void main(String[] args) {
3 int i = 1;
4 int sum = 0;
5 do {
6 sum += i;
7 i++;
8 } while (i <= 100);
9 System.out.println("1+2+3+......+100=" + sum);
10 }
11 }
输出结果：
1+2+3+......+100=5050
2.6.4 for语句
⒈普通for循环
for语句提供了一个更简便、更灵活的方法来进行循环。for语句的语法如下：
for(initialization; termination_condition; iteration) {
statement;
}
其中initialization表示初始化部分，用来设置循环控制变量的初始值，termination_condition为条件表达式，iteration为迭代部分，3部分之间需要用分号隔开。实际上，这3部分都是可选的。若前3个表达式都省略，则为无限循环。statement为循环体。
for语句的功能如下：
首先计算表达式initialization的值，再计算表达式termination_condition的值，如果termination_condition 的值为true，执行循环体语句statement，否则退出该循环语句。在执行循环体后，再计算表达式iteration，然后去计算表达式termination_condition，判断是否执行循环体……依次类推，直到表达式termination_condition的值为false时退出该循环语句。
[例2-11] 用for语句计算1+2+3+……+100的值。
1 public class ForExample1 {
2 public static void main(String[] args) {
3 int sum = 0;
4 for (int i = 1; i <= 100; i++) {
5 sum += i;
6 }
7 System.out.println("1+2+3+......+100=" + sum);
8 }
9 }
输出结果：
1+2+3+......+100=5050
⒉增强的for循环
JDK1.5中增加了增强的for循环。借助这种形式的for循环，可以用更简单的方式来遍历数组和Collection等类型的对象。这里，我们以数组为例来讲解（关于数组的相关知识，详见2.7小节。）语法格式：
for (Type value : array) {
expression value;
}