Java流程控制

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。

顺序结构

程序从上到下逐行执行，中间不存在任何跳转或判断

例如：

public class serviceImpl implements service{
    char c=65536;
    boolean a;
    static void show(){

    }
    public boolean getParam(){
        return a;
    }
}

分支结构

根据条件，选择性的执行某段代码

if-else

if-else if-else

public class AgeTest{
  public static void main(String args[]){
    int age = 75;
    if (age< 0) {
      System.out.println("不可能！");
    } else {
      System.out.println(“人家芳龄 " + age +" ,马马乎乎啦！");
    }
  }
}

public class AgeTest{
  public static void main(String args[]){
    int age = 75;
    if (age< 0) {
      System.out.println("不可能！");
    } else if (age>250) {
      System.out.println("是个妖怪！");
    } else {
      System.out.println(“人家芳龄 " + age +" ,马马乎乎啦！");
    }
  }
}

switch-case

switch(表达式){
  case 常量1:
    语句1;
    // break;
  case 常量2:
    语句2;
    // break;
  … …
  case 常量N:
    语句N;
    // break;
  default:
    语句;
    // break;
} 

public class SwitchTest {
  public static void main(String args[]) {
    int i = 1;
    switch (i) {
      case 0:
        System.out.println("zero");
        break;
      case 1:
        System.out.println("one");
        break;
      default:
        System.out.println("default");
        break;
    }
  }
}

• switch(表达式)中表达式的值必须是下述几种类型之一：byte，short， char，int，枚举 (jdk 5.0)，String (jdk 7.0)；

• case子句中的值必须是常量，不能是变量名或不确定的表达式值；

• 同一个switch语句，所有case子句中的常量值互不相同；

• break语句用来在执行完一个case分支后使程序跳出switch语句块；如 果没有break，程序会顺序执行到switch结尾

• default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时， 执行default

循环结构

根据循环条件，重复执行某段代码

• 循环语句的四个组成部分

  • 初始化部分(init_statement)

  • 循环条件部分(test_exp)

  • 循环体部分(body_statement)

  • 迭代部分(alter_statement)

for循环

语法：

for (①初始化部分; ②循环条件部分; ④迭代部分)｛
    ③循环体部分;
｝

执行过程：

①-②-③-④-②-③-④-②-③-④-…-②

说明：

• ②循环条件部分为boolean类型表达式，当值为false时，退出循环

• ①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔

• ④可以有多个变量更新，用逗号分隔

public class ForLoop {
  public static void main(String args[]) {
    int result = 0;
    for (int i = 1; i <= 100; i++) {
      result += i;
    }
    System.out.println("result=" + result);
  }
}

while循环

①初始化部分
while(②循环条件部分)｛
   ③循环体部分;
   ④迭代部分;
}

执行过程： ①-②-③-④-②-③-④-②-③-④-…-②

注意：

• 不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。

• for循环和while循环可以相互转换

public class WhileLoop {
  public static void main(String args[]) {
    int result = 0;
    int i = 1;
    while (i <= 100) {
      result += i;
      i++;
    }
    System.out.println("result=" + result);
  }
}

do-while循环

①初始化部分;
do{
  ③循环体部分 ④迭代部分
}while(②循环条件部分);

执行过程： ①-③-④-②-③-④-②-③-④-…②

说明：

• do-while循环至少执行一次循环体。

public class DoWhileLoop {
  public static void main(String args[]) {
    int result = 0, i = 1;
    do {
      result += i;
      i++;
    } while (i <= 100);
    System.out.println("result=" + result);
  }
}

总结：

• 分支结构和循环结构都支持嵌套使用，在分支结构中使用分支结构，在循环结构中使用循环结构这样

• 也可以在分支结构中使用循环结构，在循环结构中使用分支结构
  

增强for循环

在Java5后，Java提供了一种更加简单的循环：foreach循环(也叫：增强for循环)，这种循环遍历数组和集合更加简洁。

• 无需获取数组和集合的长度

• 无需根据索引来访问数组元素和集合元素

• 无需循环条件

• 无需迭代语句

语法格式：

//type是数组/集合元素的类型
//variableName是形参--需要命名
//array：数组名 collection：集合名
for(type variableName:array|collection){
  //循环体
}

举个例子：

boolean[] b={true,true,true,true,false,true,true};
for (boolean bl : b) {
    System.out.println(bl);
}
List<String> strList=new ArrayList<>();
strList.add("李白");
strList.add("杜甫");
strList.add("白居易");
strList.add("李牧");
for (String s : strList) {
    System.out.println(s);
}

foreach在循环过程中，循环变量相当于一个临时变量，系统会把数组或集合中的元素依次赋值给这个临时变量，而这个临时变量并不是数组元素，只是保存了数组元素的值，如果希望改变数组元素的值，不能使用foreach循环

控制循环结构

Java语言没有提供goto语句来控制程序的跳转，goto语句虽然提高了程序流程的可读性，但是降低了程序流程控制的灵活性

Java使用continue和break来控制循环语句，return虽然是用来结束整个方法的，但是当满足某种功能的情况下，也可以看作是结束了这个循环。

使用break结束循环

当某种条件满足的情况下，为了强制终止循环，执行循环外的语句，不能等到循环条件为false的时候终止循环，使用break可以满足这样的需求，对于嵌套循环，只能终止当前所在循环，不能终止外层循环。

举个例子：

public static void main(String[] args) {
        boolean[] b={true,true,true,true,false,true,true};
        boolean flag=true;
        for (int i = 0; i < b.length; i++) {
            System.out.println("b的值："+b[i]);
            if (!b[i]) {
                flag=b[i];
                break;
            }
        }
        serviceImpl service=new serviceImpl();
        service.setLike(flag);
        System.out.println(service.getLike());
}

对于嵌套循环，默认是结束break所在循环，但是也可以通过标签的方式，来控制结束第几层循环，甚至是最外层循环。

举个例子：

for (int i = 0; i < 10; i++) {
    //想要在那个循环位置结束，就在哪个循环前加上`标签:`
    out:for (int j = 0; j < 5; j++) {//j永远都是0，因为第一次进去遍历k=2就会重新开始
        for (int k = 0; k < 4; k++) {
            if(k==2){
                //添加标签
                break out;
            }
        }
    }
}

注意事项：

• 使用break 标签的方式，标签:定义在break当前所在循环的外层任意循环，即为有效标签，如果定义在当前break所在循环，则为无效标签

• break是终止循环，不再执行此循环，除非外层循环再去循环调用这个循环，这个循环会重新开始

使用continue结束本次循环

continue用于结束本次循环，忽略continue后面的语句，进入下一次循环

continue也可以使用标签来控制结束哪层循环的当前次数

for (int i = 0; i < 5; i++) {
    System.out.println("i="+i);
    out:for (int j = 0; j < 2; j++) {
        System.out.println("j="+j);
        for (int k = 0; k < 2; k++) {
            //永远无法输出k=1
            if(k==1){
                continue out;
            }
            System.out.println("k="+k);
        }
    }
}

使用return结束方法

return关键字用于结束一个方法，并不用于结束循环，当一个方法执行到return 语句，这个方法将会结束，不管外面多少层循环，所以其并不能称为控制循环的关键字，但是有控制循环结束的效果。

for (int i = 0; i < 5; i++) {
    System.out.println("i="+i);
    for (int j = 0; j < 2; j++) {
        System.out.println("j="+j);
        for (int k = 0; k < 2; k++) {
            //当k=1时返回当前k值
            if(k==1){
                return k;
            }
            System.out.println("k="+k);
        }
    }
}