Java流程控制语句

1. switch语句

1.1 switch语句格式

格式说明:

• 表达式:取值为byte、short、int、char，JDK5以后可以是枚举，JDK7以后可以是String。
• case:后面跟的是要和表达式进行比较的值。
• break:表示中断，结束的意思，用来结束switch语句。
• default:表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

执行流程:

• ① 首先计算表达式的值。
• ② 依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
• ③如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束掉。
  

/**
 * switch语句
 * 格式:
 *    switch (表达式){
 *      case值1:
 *      语句体1;
 *      break;
 *      case值2:
 *      语句体2;
 *      break;
 *      ...
 *      default:
 *      语句体n+1;
 *      [break; ]
 * 格式说明:
 * 表达式:取值为byte、short、int、char，JDKs以后可以是枚举，JDK7以后可以是String
 *       case: 后面跟的是要和表达式进行比较的值。
 *       break:表示中断，结束的意思，用来结束switch语句。
 *       default:表示所有情况都不匹配的时候，就执行该处的内容，和if语句的e1se相似。
 * 执行流程:
 *      首先计算表达式的值。
 *      依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
 *      如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束掉
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        System.out.println ("开始");
        //需求:键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
        Scanner sc = new Scanner (System.in) ;
        System.out.println("请输入一个星期数(1-7): ");
        int week = sc.nextInt() ;
        switch (week){
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期日");
                break;
            default:
                System.out.println("你输入的星期数有误");
                break;
        }
        System.out.println ("结束");
    }
}

1.2 案例：春夏秋冬

需求:一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，
请用程序实现判断该月份属于哪个季节，并输出。

• 春:3、4、5
• 夏: 6、7、8
• 秋:9、10、11
• 冬:1、2、12
  
  

注意事项:
在switch语句中，如果case控制的语句体后面不写break，将出现穿透现象，在不判断下一个case值的情况下，
向下运行，直到遇到break，或者整体switch语句结束

/**
 * 春夏秋冬
 * 需求:
 *      一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，
 * 		请用程序实现判断该月份属于哪个季节，并输出。
 * 春:3、4、5
 * 夏:6、7、8
 * 秋:9、10、11
 * 冬:1、2、12
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        //键盘录入月份数据，使用变量接收
        Scanner sc = new Scanner (System.in) ;
        System.out.println ( "请输入一个月份:");
        int month = sc.nextInt () ;
        //多情况判断，这里采用switch语句实现
        //在每种情况中，完成输出对应的季节
        /*switch (month){
            case 1:
                System.out.println("冬季");
                break;
            case 2:
                System.out.println("冬季");
                break;
            case 3:
                System.out.println("春季");
                break;
            case 4:
                System.out.println("春季");
                break;
            case 5:
                System.out.println("春季");
                break;
            case 6:
                System.out.println("夏季");
                break;
            case 7:
                System.out.println("夏季");
                break;
            case 8:
                System.out.println("夏季");
                break;
            case 9:
                System.out.println("秋季");
                break;
            case 10:
                System.out.println("秋季");
                break;
            case 11:
                System.out.println("秋季");
                break;
            case 12:
                System.out.println("冬季");
                break;
            default:
                System.out.println("您输入的月份有误");
        }*/

        // case穿透
        switch (month){
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("您输入的有误");
                break;
        }
    }
}

2. for循环语句

2.1 循环结构

特征

• 重复做某件事情
• 具有明确的开始和停止标志

循环结构的组成：

• 初始化语句:用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
• 条件判断语句:用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
• 循环体语句:用于表示循环反复执行的内容，简单说就是循环反复执行的事情
• 条件控制语句:用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去

循环结构对应的语法:

• 初始化语句:这里可以是一条或者多条语句，这些语句可以完成一些初始化操作
• 条件判断语句:这里使用一个结果值为boolean类型的表达式，这个表达式能决定是否执行循环体。例如: a<3
• 循环体语句:这里可以是任意语句，这些语句将反复执行
• 条件控制语句:这里通常是使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的效果。常见i++,i–这样的操作

2.2 for循环语句格式

/**
 * for语句
 * 格式:
 *      for(初始化语句;条件判断语句;条件控制语句){
 *          循环体语句;
 *      }
 * 执行流程:
 *      1:执行初始化语句
 *      2:执行条件判断语句，看其结果是true还是false
 *          如果是false，循环结束
 *          如果是true，继续执行
 *      3:执行循环体语句
 *      4 :执行条件控制语句5:回到z继续
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        //需求:在控制台输出5次"Helloworld"
        System.out.println ("Helloworld");
        System.out.println ("Helloworld");
        System.out.println ("Helloworld");
        System.out.println ("He1loworld");
        System.out.println ("Helloworld");
        System.out.println ("--------") ;

        //用循环改进
        for (int i = 0; i < 5; i++) {
            System.out.println ("Helloworld");
        }
    }
}

2.3 案例： 输出数据

• 需求:在控制台输出1-5和5-1的数据
  
  

/**
 * 需求:在控制台输出1-5和5-1的数据
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        //控制台输出1-5
        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
        }
        System.out.println("==============");

        for (int j = 5; j >= 1; j--) {
            System.out.println(j);
        }
    }
}

2.4 案例：求和

• 需求:求1-5之间的数据和，并把求和结果在控制台输出
  

/**
 * 求和需求:
 * 求1-5之间的数据和，并把求和结果在控制台输出
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        int sum = 0;

        for (int i = 1; i <= 5; i++) {
            sum += i;
        }
        System.out.println(sum);
    }
}

2.5 案例：求偶数和

• 需求:求1-100之间的偶数和，并把求和结果在控制台输出

/**
 * 需求:求1-100之间的偶数和，并把求和结果在控制台输出
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        int sum = 0;

        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0){
                sum += i;
            }
        }
        System.out.println(sum);
    }
}

2.6：水仙花

• 需求:在控制台输出所有的“水仙花数”
  
  
  

/**
 * 需求:在控制台输出所有的“水仙花数”
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        for (int i = 100; i <= 999; i++) {
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 10 / 10 % 10;

            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
                System.out.println(i);
            }
        }
    }
}

2.7 案例：统计

• 需求:统计“水仙花数”一共有多少个，并在控制台输出个数
  

/**
 * 需求:统计“水仙花数”一共有多少个，并在控制台输出个数
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 100; i < 1000; i++) {
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 10 / 10 % 10;

            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
                count++;
            }
        }
        System.out.println(count);
    }
}

3. while循环语句

3.1 while循环语句格式

/**
 * 需求:在控制台输出5次"Helloworld"
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        int i = 1;
        while (i <= 5) {
            System.out.println("Helloworld");
            i++;
        }
    }
}

3.2案例：珠穆朗玛峰

• 需求:世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?

/**
 * 需求:世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，
 * 它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        int count = 0;
        double paper = 0.1;
        int zf = 8844430;
        while (paper <= zf) {
            paper *= 2;
            count++;
        }
        System.out.println(count);
    }
}

4. do…while循环语句

4.1 do…while循环语句格式

/**
 * 需求:在控制台输出5次"Helloworld"
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        int i = 1;
        do {
            System.out.println("Helloworld");
            i++;
        } while (i <= 5);
    }
}

4.2 三种循环的区别

三种循环的区别:

• for循环和while循环先判断条件是否成立，然后决定是否执行循环体(先判断后执行)
• do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断)
  for和while的区别:
• 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
• 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用

/**
 * 三种循环的区别
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        //for循环
        for (int i = 5; i < 5; i++) {
            System.out.println("我爱Java");
        }

        System.out.println("===========================");
        //while循环
        int j = 5;
        while (j < 5) {
            System.out.println("我爱Java");
            j++;
        }

        System.out.println("===========================");
        //do...while循环
        int k = 5;
        do {
            System.out.println("我爱Java");
            k++;
        } while (k < 5);
    }
}

5. 跳转控制语句

5.1 跳转控制语句概述

• continue用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行
• break用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环
  
  

/**
 * continue用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行
 * break用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i % 2 == 0) {
                //continue;
                break;
            }
            System.out.println(i);
        }
    }
}

6. 循环嵌套

6.1 循环嵌套概述

/**
 * 循环嵌套:
 *      循环语句中包含循环语句
 * 需求:
 *      在控制台输出一天的小时和分钟
 *      分钟和小时的范围:
 *          分钟: 0 <= minute < 60
 *          小时: 0 <= hour < 24
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        for (int i = 0; i < 24; i++) {
            for (int j = 0; j < 60; j++) {
                System.out.println(i + "时" + j + "分");
            }
        }
    }
}

7. Random [随机数]

7.1 Random的作用和使用步骤

import java.util.Random;
/**
 * Random
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        Random random = new Random();
        //获取十个随机数
        for (int i = 0; i < 10; i++) {
            int r = random.nextInt(20);
            //int r = random.nextInt();
            System.out.println(r);
        }

        System.out.println("==================");
        //获取一个1-100之间的随机数
        int x = random.nextInt(100) + 1;
        System.out.println(x);
    }
}

7.2 案例：猜数字

需求:程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少?
当猜错的时候根据不同情况给出相应的提示

• 如果猜的数字比真实数字大，提示你猜的数据大了
• 如果猜的数字比真实数字小，提示你猜的数据小了
• 如果猜的数字与真实数字相等，提示恭喜你猜中了

/**
 * 猜数字
 */
public class VariableDemo02 {
    public static void main(String[] args) {
        Random random = new Random();
        Scanner scanner = new Scanner(System.in);

        int i = random.nextInt(100) + 1;

        while (true) {
            System.out.println("请输入您要猜的数字：");
            int j = scanner.nextInt();
            if (j < i) {
                System.out.println("您猜的数字" + j + "小了");
            } else if (j > i) {
                System.out.println("您猜的数字" + j + "大了");
            } else {
                System.out.println("您猜中了！");
                break;
            }
        }
    }
}