Java 支持两种选择语句：if语句和switch语句。这些语句允许你只有在程序运行时才能知道其状态的情况下，控制程序的执行过程。如果你没有C/C++ 的编程背景，你将会为这两个语句的强大功能和灵活性而感到吃惊。 
1.1 if语句
if语句是Java 中的条件分支语句。它能将程序的执行路径分为两条。if语句的完整格式
if (condition) statement1;
else statement2; 
其中，if和else的对象都是单个语句（statement ），也可以是程序块。条件condition 可以是任何返回布尔值的表达式。else子句是可选的。
if语句的执行过程如下:如果条件为真，就执行if的对象（statement1 ）；否则，执行else 的对象（statement2 ）。任何时候两条语句都不可能同时执行。考虑下面的例子：
int a，b; // ...if(a < b) a = 0;else b = 0; 
本例中，如果a小于b，那么a被赋值为0；否则，b被赋值为0。任何情况下都不可能使a 和b都被赋值为0。
通常，用于控制if语句的表达式都包含关系运算符。当然，这在技术上并不是必要的。仅用一
个布尔值来控制if语句也是可以的，如下面的程序段：
boolean dataAvailable; 
// ...
if (dataAvailable)
ProcessData();
else 
waitForMoreData(); 
记住，直接跟在if 或else语句后的语句只能有一句。如果你想包含更多的语句，你需要建一个程序块，如下面的例子：
int bytesAvailable;
// ...
if (bytesAvailable > 0) {
ProcessData();bytesAvailable -= n;} elsewaitForMoreData(); 
这里，如果变量bytesAvailable 大于0，则if块内的所有语句都会执行。
一些程序员觉得在使用if语句时在其后跟一个大括号是很方便的，甚至在只有一条语句的时
侯也使用大括号。这使得在日后添加别的语句变得容易，并且你也不必担心忘记括号。事实上，当需要定义块时而未对其进行定义是一个导致错误的普遍原因。例如，考虑下面的程序段：
int bytesAvailable;
// ...
if (bytesAvailable > 0) {
ProcessData();bytesAvailable -= n;
} else
waitForMoreData();
bytesAvailable = n; 
由于编排的原因，看起来似乎bytesAvailable = n 语句应该在else子句中执行。然而，当你调用时，空白对Java 无关紧要，编译器无法知道你的意图。这段程序会通过编译，但运用时会出错。上述例子应修改
int bytesAvailable;
// ...
if (bytesAvailable > 0) {
ProcessData();
bytesAvailable -= n;
} else {
waitForMoreData();
bytesAvailable = n; 
} 
嵌套if 语句
嵌套（nested）if语句是指该if语句为另一个if或者else 语句的对象。在编程时经常要用到嵌套if语句。当你使用嵌套if语句时，需记住的要点就是：一个else语句总是对应着和它在同一个块中的最近的if语句，而且该if语句没有与其他else语句相关联。下面是一个例子：
if(i == 10) {if(j < 20) a = b;if(k > 100) c = d; // this if iselse a = c; // associated with this else 
}
else a = d; // this else refers to if(i == 10) 
如注释所示，最后一个else语句没有与if（j <20 ）相对应，因为它们不在同一个块（尽管if（
j <20 ）语句是没有与else配对最近的if语句）。最后一个else语句对应着if（i==10 ）。内部的else语句对应着if（k>100 ），因为它是同一个块中最近的if语句。
if-else-if 阶梯
基于嵌套if语句的通用编程结构被称为 if-else-if 阶梯。它的语法
if(condition) statement; else if(condition) statement; else if(condition) 
statement; 
.  .  . 
else 
statement; 
条件表达式从上到下被求值。一旦到为真的条件，就执行与它关联的语句，该阶梯的其他部分就被忽略了。如果所有的条件都不为真，则执行最后的else语句。最后的else语句经常被作为默认的条件，即如果所有其他条件测试失败，就执行最后的else语句。如果没有最后的else语句，而且所有其他的条件都失败，那程序就不做任何动作。
下面的程序通过使用if-else-if 阶梯来确定某个月是什么季节。
// Demonstrate if-else-if statements.
class IfElse {
public static void main(String args) {
int month = 4; // April
String season; 
if(month == 12 || month == 1 || month == 2) |||
season = "Winter";
else if(month == 3 || month == 4 || month == 5)
season = "Spring";
else if(month == 6 || month == 7 || month == 8)
season = "Summer"; 
else if(month == 9 || month == 10 || month == 11)
season = "Autumn";
else 
season = "Bogus Month"; 
System.out.println("April is in the " + season + ".");
}
}
该程序产生如下输出： 
April is in the Spring. 
在往下继续讲之前，你可能想要先试验这个程序。你将看到，不管你给month 什么值，该阶梯中有而且只有一个语句执行。

1.2 switch 语句
switch语句是Java 的多路分支语句。它提供了一种基于一个表达式的值来使程序执行不同部分的简单方法。因此，它提供了一个比一系列if-else-if 语句更好的选择。switch 语句的通用形式
switch (expression) { 
case value1: 
// statement sequence
break; 
case value2: 
// statement sequence
break; 
. 
. 
. 
case valueN: 
// statement sequence
break; 
default: 
// default statement sequence
} 
表达式expression 必须为byte，short，int 或char类型。每个case语句后的值value 必须是与表达式类型兼容的特定的一个常量（它必须为一个常量，而不是变量）。重复的case值是不允许的。
switch语句的执行过程表达式的值与每个case语句中的常量作比较。如果发现了一个与之相匹配的，则执行该case语句后的代码。如果没有一个case常量与表达式的值相匹配，则执行default 语句。当然，default 语句是可选的。如果没有相匹配的case 语句，也没有default 语句，则什么也不执行。
在case语句序列中的break 语句将引起程序流从整个switch 语句退出。当遇到一个break 语句时，程序将从整个switch 语句后的第一行代码开始继续执行。这有一种“跳出” switch 语句的效果。
下面是一个使用switch语句的简单例子：
// A simple example of the switch.
class SampleSwitch {
public static void main(String args) {
for(int i=0; i<6; i++)
switch(i) {
case 0: 
System.out.println("i is zero.");
break; 
case 1: 
System.out.println("i is one.");
break; 
case 2: 
System.out.println("i is two.");
break; 
case 3: 
System.out.println("i is three.");
break; 
default: 
System.out.println("i is greater than 3.");
}
}
}
该程序的输出
i is zero. 
i is one. 
i is two. 
i is three. 
i is greater than 3.
i is greater than 3. 
从中可以看出，每一次循环，与i值相配的case常量后的相关语句就被执行。其他语句则被忽略。当i大于3时，没有可以匹配的case语句，因此执行default 语句。break语句是可选的。如果你省略了break 语句，程序将继续执行下一个case语句。有时需要在多个case语句之间没有break 语句。例如下面的程序：
// In a switch, break statements are optional.
class MissingBreak {
public static void main(String args) {
for(int i=0; i<12; i++)
switch(i) {
case 0: 
case 1: 
case 2: 
case 3: 
case 4: 
System.out.println("i is less than 5");
break; 
case 5: 
case 6: 
case 7: 
case 8: 
case 9: 
System.out.println("i is less than 10");
break; 
default: 
System.out.println("i is 10 or more");
}
}
}
该程序产生的输出 
i is less than 5 
i is less than 5 
i is less than 5 
i is less than 5  |||
i is less than 5 
i is less than 10 
i is less than 10 
i is less than 10 
i is less than 10 
i is less than 10 
i is 10 or more 
i is 10 or more 
正如该程序所演示的那样，如果没有break语句，程序将继续执行下面的每一个case语
句，直到遇到break 语句（或switch语句的末尾）。当然该例子是为了示例而人为构造的，省略break语句在真实的程序中有许多实际的应
用。为了说明它更现实的用法，让我们考虑下例对以前显示季节例子的重写。这个重写的
版本使用switch语句来使程序的执行更高效。
// An improved version of the season program.
class Switch {
public static void main(String args) {
int month = 4;
String season;
switch (month) {
case 12: 
case 1: 
case 2: 
season = "Winter";
break; 
case 3: 
case 4: 
case 5: 
season = "Spring"; switch语句c语言例子
break;
case 6: 
case 7: 
case 8: 
season = "Summer"; 
break; 
case 9: 
case 10: 
case 11: 
season = "Autumn";
break; 
default: 
season = "Bogus Month";}System.out.println("April is in the " + season + ".");
}
}
嵌套switch 语句 
可以将一个switch语句作为一个外部switch语句的语句序列的一部分，这称为嵌套switch语句。因为一个switch语句定义了自己的块，外部switch语句和内部switch语句的case 常量不会产生冲突。例如，下面的程序段是完全正确的：
switch(count) {
case 1: 
switch(target) { // nested switch
case 0: 
System.out.println("target is zero");
break; 
case 1: // no conflicts with outer switch
System.out.println("target is one");
break; }
break; 
case 2: // ... 
本例中，内部switch语句中的 case 1 ：语句与外部switch语句中的case 1：语句不冲突。变量count仅与外层的case语句相比较。如果变量count 为1，则变量target 与内层的case语句相比较。
概括起来说，switch语句有3个重要的特性需注意：
·  switch语句不同于if语句的是switch语句仅能测试相等的情况，而if语句可计算任何类型的布尔表达式。也就是switch语句只能寻case常量间某个值与表达式的值相匹配。 
·  在同一个switch语句中没有两个相同的case常量。当然，外部switch语句中的case常量可
以和内部switch语句中的case常量相同。 
·  switch语句通常比一系列嵌套if语句更有效。 
最后一点尤其有趣，因为它使我们知道Java 编译器如何工作。当编译一个switch语句时，Java 编译器将检查每个case常量并且创造一个“跳转表”，这个表将用来在表达式值的基础上选择执行路径。因此，如果你需要在一组值中做出选择，switch语句将比与之等效的if-else 语句快得多。编译器可以这样做是因为它知道case常量都是同类型的，所要做的只是将它与switch表达式相比较看是否相等。对于一系列的if表达式，编译器就无此功能。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。