Java流程控制

1.复合语句

        Java语言的复合语句又称作块语句，复合语句以开括号【{】开始，闭括号【}】结束。t

 

2.条件语句 

2.1 if条件语句

2.1.1 简单的if条件语句

        语法：if(布尔表达式){语句序列}

int a = 100;
if (a == 100) {
    System.out.println("a的值是：" + a);
        }

public class Getif {
    public static void main(String[] args) {
        int x = 45;
        int y = 12;
        if (x > y) {
            System.out.println("变量x大于变量y");
        }
        if (x < y) {
            System.out.println("变量x小于变量y");
        }
    }
}

输出：
变量x大于变量y

2.1.2 if...else语句

        语法：

if(表达式){
    若干语句;
        }
else{
    若干语句;
        }

public class Getifelse {
    public static void main(String[] args) {
        int math = 95;
        int english = 56;
        if (math > 60) {
            System.out.println("数学及格了！");
        } else {
            System.out.println("书序没及格！");
        }

        if (english > 60) {
            System.out.println("英语及格了！");
        } else {
            System.out.println("英语没及格！");
        }
    }
}


输出：
数学及格了！
英语没及格！

2.1.3 if...else if多分支语句

        表示为：如果满足某种条件，则执行某种处理，否则如果满足另一种条件则执行另一种处理

        语法：

if(条件表达式1){
    语句序列1;
        }
else if(条件表达式2){
    语句序列2;
        }
...
else if(条件表达式n){
    语句序列n;
        }

public class getTerm {
    public static void main(String[] args) {
        int x = 20;
        if (x > 30) {
            System.out.println("x的值大于30");
        } else if (x > 10) {
            System.out.println("x的值大于10，但小于30");
        } else if (x > 0) {
            System.out.println("x的值大于0，但小于10");
        } else {
            System.out.println("x的值小于0");
        }
    }
}


输出：
x的值大于10，但小于30

 

2.2 switch多分支语句

        语法：

switch(表达式){
    case 常量值1:
        语句块1
        [break;]
    ......
    case 常量值n:
        语句块n
        [break;]
    default:
        语句块n+1;
        [break;]
        
        }

        switch语句首先计算表达式的值，如果表达式的值和某个case后面的常量值相同，则执行该case后的若干语句，直到遇到break语句为止；如果匹配的case语句中没有break语句，则继续执行后面case中的若干语句，直到遇到break；若没有一个常量值与表达式的值相同，则执行default后面的语句；default为可选项，若不存在，且switch表达式中的值不与任何case常量值相同，则switch不做任何处理。

public class GetSwitch {
    public static void main(String[] args) {
        int week = 2;
        switch (week) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            default:
                System.out.printf("Sorry,I don't Know!");
                break;
        }
    }
}

输出：
Tuesday

3.循环语句

3.1 while循环语句

        条件判断语句，利用一个条件来控制是否要继续反复执行这个语句。

        表达式：while后的执行语句不要带分号【”;“】

while(条件表达式){
    执行语句;
        }

public class GetSum {
    public static void main(String[] args) {
        int a = 1;
        int sum = 0;
        while (a <= 10) {
            sum = sum + a;
            a++;
        }
        System.out.printf("1~10累加和为：" + sum);
    }
}


输出：
1~10累加和为：55

 

3.2 do....while循环语句

        do...while语句与while语句区别：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.3 for循环语句

3.3.1 for语句

        语法：

for (表达式1;表达式2;表达式3){
            语句序列
        }

表达式1：初始化表达式，负责完成变量的初始化；
表达式2：循环条件表达式，值为boolean型的表达式，指定循环条件；
表达式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

 

3.3.2 foreach语句

        foreach语句通常用来遍历数组。

for (元素变量 x : 遍历对象 obj){
            引用了x的Java语句;
        }

 foreach语句遍历数组：

public class Repetition {
    public static void main(String[] args) {
        int arr[] = {7, 10, 1};
        System.out.printf("一维数组中的元素分别为：");
        for (int a : arr) {
            System.out.println(a);
        }
    }
}

输出：
一维数组中的元素分别为：
7
10
1

 

4.循环控制

4.1 break语句

        break是中断循环。

//while循环中断
while(...)        
{
   ...
   break;
   ...
}

//do...while循环中断
do{
  ...
  break;
  ...  
}while(...);


//for循环中断
for{
  ...
  break;
  ...
}

public class BreakTest {
    public static void main(String[] args){
        for (int i=0; i<=100; i++){
            if (i==6){
                break;
            }
            System.out.println(i);
        }
        System.out.println("----end----");
    }
}

输出：
        0
        1
        2
        3
        4
        5
        ----end----

         如果在循环嵌套时，想让break跳出外层循环，Java提供了【标签】的功能，语法：

标签名:循环体{
    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 (j == 4) {
                    break Loop;
                }
                System.out.println("i=" + i + "\tj=" + j);

            }
        }
    }
}

输出：
        i=0	j=0
        i=0	j=1
        i=0	j=2
        i=0	j=3

 

4.2 continue语句

        continue是跳出当前循环，执行下一次循环。

public class ContinueTest {
    public static void main(String[] args) {
        //输出1~10之间的奇数
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                continue;
            }
            System.out.println(i);
        }
    }
}

输出：
        1
        3
        5
        7
        9

        与break语句一样，continue也支持标签功能，语法：

标签名:循环体{
    continue 标签名;
        }