标签：出版   size   语句块   关键字   循环语句   中断   oop   fail   另一个   

流程控制

参考资料：《Java从入门到精通》/明日科技编著. 4版. 北京：清华大学出版社，2016

一、复合语句

Java的复合语句由“{”开始，“}”结束，又称为块语句。

• 复合语句都是由上至下被执行；
• 复合语句中可以嵌套复合语句。

public class Compound {
    public static void main(String[] args) {
        int x = 20;
        {
            int y = 35;
            System.out.println(y);
            {
                boolean c = true;
                System.out.println(c);
            }
        }
        String string = "hello";
        System.out.println(string);
        //System.out.println(y);   //错误代码，在作用域之外使用变量y
    }
}

复合语句为局部变量创造了一个作用域，在作用域中定义的变量只能在作用域中被使用。如果在某个变量的作用域之外使用该变量，则会发生错误。

二、条件语句

1、if条件语句

if条件语句是一个重要的编程语句，用于告诉程序在某个条件成立的情况下执行某段语句，而在另一个情况下执行另外的语句。if条件语句分为三种，如下所示：

（1）简单的if条件语句

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

• 布尔表达式：必要参数，表达式必须返回一个boolean值。
• 语句序列：非必要参数，可以是一条或者多条，甚至0条都可以。当布尔表达式的值为true时，执行这些语句。

public class Getif {
    public static void main(String[] args) {
        int a = 10;
        if(a == 10){
            System.out.println(a);
        }
    }
}

注意：当语句序列只有一条时，可以省略“{}”。

int a = 10;
if(a == 10)
    System.out.println(a);

(2)if...else语句

if(布尔表达式){
    语句序列1    
}
else{
    语句序列2
}

• if后面的布尔表达式的值为true，则执行语句序列1；
• if后面的布尔表达式的值为false，则执行语句序列2。

public class Getif {
    public static void main(String[] args) {
        int a = 80;
        if(a > 60){
            System.out.println("Pass");
        }
        else {
            System.out.println("Fail");
        }
    }
}

(3)if...else if多分支语句

if(布尔表达式1){
    语句序列1
}
else if(布尔表达式2){
    语句序列2
}
...
else if(布尔表达式n){
    语句序列n
}
else{
    语句序列n+1
}

• 可以对多种情况进行处理，甚至任意种情况。
• 只执行其中表达式为true的语句，其他语句不执行。
• 所有表达式都为false，则输出else后面的语句。

public class GetSource {
    public static void main(String[] args) {
        int a = 55;
        if(a > 90){
            System.out.println("优秀");
        }
        else if(a > 80){
            System.out.println("良好");
        }
        else if(a > 70){
            System.out.println("中等");
        }
        else if(a > 60){
            System.out.println("及格");
        }
        else {
            System.out.println("不及格");  //输出不及格
        }
    }
}

2、switch多分支语句

在java语言中，可以使用switch语句将所有情况组织起来，以一个简单明了的方式来实现“多选一”的选择。

swicth(表达式){
    case 常量1 ：
         语句块1
         break；
    case 常量2 :
         语句块2
         break；
    ...
    case 常量n :
         语句块n
         break;
    defaults：
         语句块n+1
         break;
} 

• 其中，表达式必须是整型、字符型或字符串类型。对应的，常量也必须是整型、字符型或字符串类型。
• 如果表达式的值和某个case后面的常量值相同，则执行该case语句后面的若干语句，直到遇到break语句为止。
• 如果表达式没有匹配到常量，则执行defaults后面的语句。
• 可以没有defaults，没有匹配到的话，switch则不作处理。

public class Demo1 {
    public static void main(String[] args) {
        String a = "hello";
        switch (a){
            case "hello1" :
                System.out.println("hi");
                break;
            case "nihao" :
                System.out.println("nihao");
                break;
            case "hello" :
                System.out.println("yes,you are right");
                break;
            default:
                System.out.println("sorry");
                break;
        }

    }
}

注意：

1. 在同一个switch语句，case的常量值必须互不相同。
2. case语句后面的常量表达式的值可以为整数，但绝不可为实数。例如，下面的代码不合法的：

case 2.1    //代码错误

三、循环语句

循环语句就是在满足一定的条件下，反复执行某一个操作。在Java中提供了三种常用的循环语句，分别是while循环语句、do...while循环语句和for循环语句。

1、while循环语句

while语句也称条件判断语句，它的循环方式为利用一个条件来控制是否要继续执行这个语句。

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

• 当表达式的返回值为true时，执行{}中的语句；
• 执行完{}中的语句后，重新判断表达式的返回值；
• 当表达式的返回值为false时，退出循环。

public class Demo2 {
    public static void main(String[] args) {
        int x = 1;
        int sum = 0;
        while (x <= 10){
            sum = sum + x;
            x++;
        }
        System.out.println(sum);
    }
}

2、do...while循环

while循环先判表达式是否成立，然后执行循环体，而do...while循环先执行一次循环后，再判断表达式是否成立。也就是说do...while循环的循环体语句至少被执行一次。

do{
    执行语句
}
while(表达式);    //这里有个分号，千万别忘了

do...while循环和while循环还有一个明显的差别，就是do...while循环在结尾多了一个分号。

public class Gess {
    public static void main(String[] args) {
        int a = 10;
        do {
            System.out.println("hello world");
            a--;
        } while(a > 6);   //输出4次hello world
    }
}

3、for循环语句

for循环用来重复执行循环体，直到某个条件得到满足后中止循环。

（1）for循环语句

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

• 表达式1：初始化表达式，负责完成变量的初始化。
• 表达式2：条件表达式，返回值为boolean型的表达式，指定循环条件。
• 表达式3：循环的操作表达式，负责修整变量，改变循环条件。

public class Demo2 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i=2;i<=100;i+=2){
            sum = sum + i;
            System.out.println(sum);  //计算2~100之间所有偶数之和
        }
    }
}

（2）foreach语句

foreach语句是for语句的特殊简化版，不能完全取代for语句，但是任何foreach语句都能改写成佛如语句版本。foreach不是一个关键字。

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

• foreach语句中的元素变量x，不必对其进行初化。

public class Demo2 {
    public static void main(String[] args) {
        int arr[] = {2,4,6};
        for(int x : arr){         //遍历数组
            System.out.println(x);  
        }
    }
}

四、循环控制

循环控制包含两个方面的内容，一方面是控制循环变量的变化方式，另一方面是控制循环的跳转。控制循环的跳转需要用到break和continue两个关键词，break是中断循环，continue是执行下一次循环。

1、break语句

使用break语句可以跳出switch结构，在循环中，同样可以使用break语句跳出当前循环体，从而中断当前循环。

public class BreakTest {
    public static void main(String[] args) {
        for(int i=0;i<=100;i++){
            System.out.println(i);
            if(i == 10){
                System.out.println("循环终止");
                break;   //中断循环
            }
        }
    }
}

注意：如果遇到循环嵌套的情况，break只会跳出包含它的最内层循环，也就是说只跳出一层循环。

public class BreakNest {
    public static void main(String[] args) {
        for(int i=0;i<3;i++){
            for(int j=0;j<10;j++){
                System.out.println("i=" + i + "  j=" + j);
                if(j == 4){
                    break;  
                }
            }
        }
    }
}
//break语句中断了内层循环，但是并没有影响外层循环。
输出结果：
i=0  j=0
i=0  j=1
i=0  j=2
i=0  j=3
i=0  j=4
i=1  j=0
i=1  j=1
i=1  j=2
i=1  j=3
i=1  j=4
i=2  j=0
i=2  j=1
i=2  j=2
i=2  j=3
i=2  j=4

如果想让break跳出外层循环，Java提供了“标签”功能，如下：

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

public class BreakNest {
    public static void main(String[] args) {
        Loop:for(int i=0;i<3;i++){      //给外层循环添加标签
            for(int j=0;j<10;j++){
                System.out.println("i=" + i + "  j=" + j);
                if(j == 4){
                    break Loop;
                }
            }
        }
    }
}
//用带有标签的break跳出外层循环
输出结果：
i=0  j=0
i=0  j=1
i=0  j=2
i=0  j=3
i=0  j=4     //当j变量的值等于4时，i的值没有增加，直接结束外层循环。

2、continue语句

continue语句是针对break语句的补充，contiune语句不是立即中止循环体，而是结束本次循环，回到循环的条件判断语句，重新开始执行循环。

• 在for循环语句中，循环体中遇到continue语句后，先执行循环的增量部分，然后进行条件判断。
• 在while和do...while循环语句中，遇到continue语句则直接回到条件判断部分。

public class ContinueTest {
    public static void main(String[] args) {
        for(int i=1;i<=20;i++){
            if(i%2 == 0 ){      //判断i是否为偶数
                continue;     //先执行i++，然后跳到下一次循环
            }
            System.out.println(i);   //输出1~20之间的奇数
        }
    }
}

与break一样，continue也支持标签的功能，使得可以指定continue语句跳出指定的循环体。如下所示：

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

五、课后实践

1、编写Java程序，使用for循环打印菱形。

public class Out{
    public static void main(String[] args) {
        //设置菱形的大小
        int size = 5;
        //菱形的上半部分
        for(int i = 1;i <= size; i++) {
            for (int j = 1; j <= size - i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k <= i * 2 - 1; k++) {
                System.out.print("*");
            }
            System.out.println();   //起换行作用
        }
        //菱形的下半部分
        for(int i = 1; i <= size -1; i++){
            for(int j = 1; j <= i; j++){
                System.out.print(" ");
            }
            for(int k=1; k <= 2 * (size -i) -1; k++){
                System.out.print("*");
            }
            System.out.println();   //起换行作用
        }
    }
}

输出结果如下所示：
    *
   ***
  *****
 *******
*********
 *******
  *****
   ***
    *

注意：

• System.out.print()输出不换行；
• System.out.println()输出自动换行。

for(int x=1; x<=5; x++){
            System.out.print("*");
        }
输出结果：
*****

for(int x=1; x<=5; x++){
            System.out.println("*");    //自动换行
        }
输出结果：
*
*
*
*
*

2、打印一个空心菱形。

public class out{
    public static void main(String[] args) {
        //设置菱形的大小
        int size = 5;
        //菱形的上半部分
        for(int i = 1;i <= size; i++) {
            for (int j = 1; j <= size - i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k <= i * 2 - 1; k++) {
                //if语句判断“*”号是否位于开头或结束，若不是则输出空格
                if(k == 1 || k == i * 2 - 1){    
                    System.out.print("*");
                }
               else {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
        //菱形的下半部分
        for(int i = 1; i <= size -1; i++){
            for(int j = 1; j <= i; j++){
                System.out.print(" ");
            }
            for(int k=1; k <= 2 * (size -i) -1; k++){
                //if语句判断“*”号是否位于开头或结束，若不是则输出空格
                if(k == 1 || k == 2 * (size -i) -1){    
                    System.out.print("*");
                }
               else {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
}

输出结果如下：
    *
   * *
  *   *
 *     *
*       *
 *     *
  *   *
   * *
    *

Java基础03—流程控制

标签：出版   size   语句块   关键字   循环语句   中断   oop   fail   另一个   

原文地址：https://www.cnblogs.com/xuliang-daydayup/p/12900880.html