Java-流程控制

复合语句（块语句）

以整个块区为单位的语句，由开括号{开始，闭括号}结束；
复合语句中的每个语句都是从上到下被执行；
复合语句为局部变量创建了一个作用域；

条件语句

（1）if条件语句
用于告诉程序在某个条件成立的情况下执行某段语句，而在另一种情况下执行另外的语句；
如果表达式返回的结果为true，则执行其后的语句；若为false，则不执行if条件之后的语句；

• 简单的if条件语句：若语句序列中仅有一条语句，则可以省略条件语句中的{}；
  if（布尔表达式）{
  语句序列
  }
• if…else语句：通常表现为“如果满足条件，就进行某种处理，否则就进行另一种处理”；
  if(表达式){
  若干语句
  }
  else{
  若干语句
  }
• if…else if语句语法：
  if(条件表达式1){
  语句序列1
  }
  else if(条件表达式2){
  语句序列2
  }
  …
  else if(表达式n){
  语句序列n
  }

（2）switch多分支语句
语法：
switch(表达式){
case 常量值1：
语句块1
[break]；
…
case 常量值n：
语句块n
[break]；
default:
语句块n+1;
[break]；
}

switch语句中表达式的值必须是整型、字符型或字符串类型；
swtich语句首先计算表达式的值，如果表达式的值和某个case后面的常量值相同，则执行该case语句后的若干个语句直到遇到break语句为止；若果没有一个常量的值与表达式的值相同，则执行defult后面的语句，default语句是可选的；

循环语句

（1）while循环语句
语法：
while(条件表达式){
执行语句
}
当条件表达式的返回值为真时，则还执行{}中的语句，当执行完{}中的语句后，重新判断条件表达式的返回值，直到表达式返回的结果为假时，退出循环；

举例：
public class GetSum {
public static void main(String args[]){
int x=1;
int sum=0;
while(x<=10){
sum=sum+x;
x++;
}
System.out.println(“sum=”+sum);
}
}
运行结果：sum=55
（2）do…while循环语句（{}中的程序至少要被执行一次）
语法：
do{
执行语句
}while(条件表达式)；

举例：比较while与do…while的区别
public class Cycle {
public static void main(String args[]) {
int a = 100;
while (a == 60) {
System.out.println(“OK1”);
a–;
}
int b = 100;
do {
System.out.println(“OK2”);
b–;
} while (b == 60);
}
运行结果：OK2
（3）for循环语句（java中最有用的循环之一）
for语句
语法：
for(表达式1；表达式2；表达式3){
语句序列
}

举例一：
public class Circulate {
public static void main(String[] args) {
int sum=0;
for(int i=2;i<=100;i+=2){
sum=sum+i;
}
System.out.println(“2到100之间所有偶数之和为：”+sum);
}
}
运行结果：2到100之间所有偶数之和为：2550
举例二：九九乘法表
public class BreakInsideNested {
public static void main(String[] args) {
for (int i=1;i<=9;i++){
for (int j=1;j<=i;j++){
System.out.print(j+""+i+"="+(ij)+" ");
}
System.out.println();
}
}
}
运行结果：
11=1
12=2 22=4
13=3 23=6 33=9
14=4 24=8 34=12 44=16
15=5 25=10 35=15 45=20 55=25
16=6 26=12 36=18 46=24 56=30 66=36
17=7 27=14 37=21 47=28 57=35 67=42 77=49
18=8 28=16 38=24 48=32 58=40 68=48 78=56 88=64
19=9 29=18 39=27 49=36 59=45 69=54 79=63 89=72 9*9=81
foreach语句
语法：
for(元素变量x:遍历对象 obj){
引用了x的java语句;
}
foreach语句中的元素变量x，不必对其进行初始化；
举例：
public class Repetition {
public static void main(String[] args) {
int arr[] = {7, 10, 1};
System.out.println(“一维数组中的元素分别为：”);
for (int x : arr) {
System.out.println(x);
}
}
}
运行结果：
一维数组中的元素分别为：
7
10
1

循环控制

循环控制包含两方面的内容，控制循环变量的变化方式、控制循环的跳转；
break语句：跳出switch结构
举例一：使用break跳出循环
public class BreakTest {
public static void main(String[] args) {
for (int i=1;i<=100;i++){
System.out.println(i);
if (i6){
break;
}
}
System.out.println("–end–");
}
运行结果：
1
2
3
4
5
6
–end–
举例二：在嵌套的循环中使用break跳出内层循环（break语句只会使程序流程跳出包含它的最内层的循环结构，只跳出一层循环）
public class BreakInsideNested {
public static void main(String[] args) {
for (int i=0;i<3;i++){
for (int j=0;j<6;j++){
if (j4){
break;
}
System.out.println(“i=”+i+" j="+j);
}
}
}
}
运行结果：
i=0 j=0
i=0 j=1
i=0 j=2
i=0 j=3
i=1 j=0
i=1 j=1
i=1 j=2
i=1 j=3
i=2 j=0
i=2 j=1
i=2 j=2
i=2 j=3
举例三：用带有标签的break跳出外层循环
标签语法：
标签名：循环体{
break 标签名；
}
public class BreakOutsideNested {
public static void main(String[] args) {
Loop:for (int i=0;i<3;i++){
for (int j=0;j<6;j++){
if (j4){
break Loop;
}
System.out.println(“i=”+i+" j="+j);
}
}
}
}
运行结果：
i=0 j=0
i=0 j=1
i=0 j=2
i=0 j=3
continue语句
continue不是立即跳出循环体，而是跳过本次循环结束前的语句，回到循环的条件测试部分，重新开始执行循环；
举例：输出1~20之间的奇数，使用continue跳出循环
public class ContinueTest {
public static void main(String[] args) {
for (int i=1;i<20;i++){
if (i%20){
continue;
}
System.out.println(i);
}
}
}