Java流程控制

一、顺序结构

• Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句的执行。

• 顺序结构是最简单的算法结构。

  

• 语句与语句之间，框与框之间是按上到下的顺序进行，它是有若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构

二、选择结构

1、if 语句(单选择结构)

一个 if 语句包含一个布尔表达式和一条或多条语句。

语法如下：

if(布尔表达式)
{
   //如果布尔表达式为true将执行的语句
}

如果布尔表达式的值为 true，则执行 if 语句中的代码块，否则执行 if 语句块后面的代码。实例如下：

public class Demo01 {
    public static void main(String[] args) {
        int i = 10;

        //判断i是否小于20；
        if(i < 20){
            System.out.println("这是if语句");
        }
    }
}

运行结果

这是if语句

2、if...else 语句(双选择结构)

if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行。

语法如下：

if(布尔表达式){
   //如果布尔表达式的值为true
}else{
   //如果布尔表达式的值为false
}

实例如下：

public class Demo02 {
    public static void main(String[] args) {
        //分数大于等于60为合格；小于60为不及格。
        int score = 60;

        //if...else语句判断
        if (score >= 60) {
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }
    }
}

运行结果：

及格

3、if...else if...else 语句(多选择结构)

if 语句后面可以跟 else if…else 语句，这种语句可以检测到多种可能的情况。

使用 if，else if，else 语句的时候，需要注意下面几点：

• if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后。
• if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
• 一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。

语法如下：

if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}

实例如下

public class Demo03 {
    public static void main(String[] args) {
        int score = 90  

        if (score == 100) {
            System.out.println("恭喜满分");
        }else if (score < 100 && score >= 90){
            System.out.println("A级");
        }else if (score < 90 && score >= 80){
            System.out.println("B级");
        }else if (score < 80 && score >= 70){
            System.out.println("C级");
        }else if (score < 70 && score >= 60){
            System.out.println("D级");
        }else if (score < 60 && score >= 0){
            System.out.println("E级");
        }else {
            System.out.println("成绩不合法");
        }
    }
}

运行结果：

A级

4、嵌套的 if 结构

使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。

语法如下：

if(布尔表达式 1){
   ////如果布尔表达式 1的值为true执行代码
   if(布尔表达式 2){
      ////如果布尔表达式 2的值为true执行代码
   }
}

实例如下：

public class Demo04 {
    public static void main(String[] args) {
        int i = 10;
        int j = 30;

        if(i < 20){
            if (j == 30){
                System.out.println("这是嵌套的if语句");
            }
        }
    }
}

运行结果：

这是嵌套的if语句

5、switch 语句(多选择结构)

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

语法如下：

switch(表达式){
    case 常量值 :
       //语句
       break; //可选
    case 常量值 :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

switch case 语句有如下规则：

• switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
• switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
• case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
• 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
• 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
• switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

实例如下：

public class Demo05 {
    public static void main(String[] args) {
        char s = ‘B‘;

        switch (s){
            case ‘A‘:
                System.out.println("优秀");
                break;
            case ‘B‘:
                System.out.println("良好");
                break;
            case ‘C‘:
                System.out.println("合格");
                break;
            case ‘D‘:
                System.out.println("不合格");
                break;
            default:
                System.out.println("无法确定");
        }
    }
}

运行结果：

良好

三、循环结构

顺序结构的程序语句只能被执行一次。如果您想要同样的操作执行多次,，就需要使用循环结构。

Java中有三种主要的循环结构：while 循环、do…while 循环、for 循环

在Java 5中引入了一种主要用于数组的增强型for循环。

1、while 循环语句

语法：

while( 布尔表达式 ) {
  //循环内容
}

实例：

public class Demo06 {
    public static void main(String[] args) {
        int i = 0;
        
        //输出1到10的数字
        while (i < 10){
            i++;
            System.out.println("数字为" + i);
        }
    }
}

运行结果：

数字为1
数字为2
数字为3
数字为4
数字为5
数字为6
数字为7
数字为8
数字为9
数字为10

2、do...while 循环语句

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

语法如下：

do {
       //代码语句
}while(布尔表达式);

while 与do...while 的区别

• while 先判断后执行。do...while 先执行后判断。
• do...while 总是保证循环体会被至少会执行一次。

实例如下：

public class Demo07 {
    public static void main(String[] args) {
        int i = 10;
        int j = 10;

        //while 循环
        while (i < 10){
            i++;
            System.out.println("i的值为" + i);
        }

        //do...while 循环
        do {
            j++;
            System.out.println("j的值为" + j);
        }while (j < 10);
    }
}

运行结果：

j的值为11

3、for 循环语句

虽然所有循环结构都可以用 while 或者 do...while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。

for循环执行的次数是在执行前就确定的。

语法如下：

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

关于 for 循环有以下几点说明：

• 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
• 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
• 执行一次循环后，更新循环控制变量。
• 再次检测布尔表达式。循环执行上面的过程。

实例如下：

public class Demo08 {
    public static void main(String[] args) {

        for (int i = 0; i < 10; i++){
            System.out.println("i的值为" + i);
        }
    }
}

运行结果：

i的值为0
i的值为1
i的值为2
i的值为3
i的值为4
i的值为5
i的值为6
i的值为7
i的值为8
i的值为9

练习：输出一个九九乘法表

public class Demo09 {
    public static void main(String[] args) {
        //输出一个九九乘法表
        for(int i = 1; i <= 9; i++){
            for (int j = 1; j <= i; j++){

                System.out.print( i + "*" + j + "=" + (i*j) + "\t");
            }
            System.out.println();
        }
    }
}

运行结果：

1*1=1	
2*1=2	2*2=4	
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12	4*4=16	
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81	

4、增强for循环语句

Java 5 引入了一种主要用于数组的增强型 for 循环。

语法如下

for(声明语句 : 表达式)
{
   //代码句子
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

实例如下：

public class Demo09 {
    public static void main(String[] args) {

        int[] numbers = {10, 20, 30, 40, 50};  //定义一个数组

        //遍历数组的元素
        for (int s : numbers){
            System.out.println(s);
        }
    }
}

运行结果：

10
20
30
40
50

5、break关键字

break语句在for、while、do···while循环语句中，用于强行退出当前循环，为什么说是当前循环呢，因为break只能跳出离它最近的那个循环的循环体，假设有两个循环嵌套使用，break用在内层循环下，则break只能跳出内层循环，

语法如下：

break;

实例如下：

public class Demo10 {
    public static void main(String[] args) {

        for (int i = 0; i < 2; i++) {               //外层循环
            for (int j = 4; j < 7; j++) {           //内层循环
                System.out.println("j的值为" + j);
                break;                       //通过break跳出内层循环，相当于不执行该循环语句，直接输出j=4
            }
            System.out.println("i的值为" + i);
        }
    }
}

运行结果：

j的值为4
i的值为0
j的值为4
i的值为1

6、continue关键字

continue语句只能用于for、while、do···while循环语句中，用于让程序直接跳过其后面的语句，进行下一次循环。

语法如下：

continue;

实例如下：

public class Demo11 {
    public static void main(String[] args) {
        int i = 0;

        while (i < 10){
            i++;
            if (i % 2 == 0) {
                continue;
            }
            System.out.print(i + " ");
        }
    }
}

运行结果：

1 3 5 7 9 

05：Java流程控制

原文：https://www.cnblogs.com/lb0903/p/15073327.html