004 Java基础 - 流程控制1. 顺序结构代码是从上到下，从左到右顺序执行。 2.分支结构 3.循环结构 4.

1. 顺序结构

代码是从上到下，从左到右顺序执行。

package task01.day04;

public class C01Seque {
    public static void main(String[] args) {
        System.out.println("我是第一条");
        System.out.println("我是第二条");System.out.println("我是第三条");System.out.println("我是第四条");
        System.out.println("我是第五条");
    }
}

2. 分支结构

当需要进行条件判断并做出选择时，使用分支结构。

2.1 if 分支

判断条件表达式是否成立
- 若成立，则执行语句块；
- 若不成立，则跳过语句块；

package task01.day04;

import java.util.Scanner;

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

        // 提示用户输入两个整数，使用if分支结构找到最大值并打印出来。
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个整数: ");
        int x = scanner.nextInt();
        System.out.println("请输入第二个整数: ");
        int y = scanner.nextInt();

        // 方式一
        if (x > y) {
            System.out.println("最大值是: " + x);
        }

        if (y > x) {
            System.out.println("最大值是: " + y);
        }

        if (x == y) {
            System.out.println("两个数相等");
        }
        
        // 方式二
        int max = x;
        if (y > max) {
            System.out.println("最大值是: " + max);
        }

    }
}

2.2 if else分支结构

判断条件表达式是否成立
- 若成立，则执行语句块1；
- 若不成立，则执行语句块2；

package task01.day04;

import java.util.Scanner;

public class C03IfElse {
    public static void main(String[] args) {
        //提示用户输入一个整数，使用if else分支结构判断该整数是负数还是非负
        //数并打印。
        //• 使用if else分支结构判断该整数是正数、负数还是零。

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数: ");
        int num = scanner.nextInt();

        if (num >= 0) {

            if (num  > 0) {
                System.out.println("正负");
            } else {
                System.out.println("零");
            }
        } else {
            System.out.println("负数");
        }
    }
}

2.3 if else if else分支结构

判断条件表达式1是否成立
- 若成立，则执行语句块1；
- 若不成立，则判断条件表达式2是否成立
  - 若成立，则执行语句块2；
  - 若不成立，则执行语句块n；
注意
- else if 可以有一个，也可以有多个
- else 可以有，也可以省略

package task01.day04;

import java.util.Scanner;

public class C04Score {
    public static void main(String[] args) {
        // // 提示用户输入考试的成绩，使用if-else if-else分支结构判断所在等级并打印。
        //        // [90 ~ 100] 等级
        //        // [80 ~ 89] 等级B
        //        // [70 ~ 79] 等级C
        //        // [60 ~ 69] 等级D
        //        // [0 ~ 59] 等级E

        Scanner input = new Scanner(System.in);
        System.out.print("请输入成绩: ");
        int score = input.nextInt();

        if (score > 100 || score < 0) {
            System.out.println("无效成绩");
        } else if (score >= 90) {
            System.out.println("成绩： A");
        } else if (score >= 80) {
            System.out.println("成绩：B");
        } else if (score >= 70) {
            System.out.println("成绩: C");
        } else if (score >= 60) {
            System.out.println("成绩: D");
        } else {
            System.out.println("成绩：E， 你完了！");
        }
    }
}

练习
- 计算个数，起征点为5000.

package task01.day04;

import java.util.Scanner;

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

        // 根据用户输入的薪水计算个人所得税并打印出来，其中个税起征点为 5000
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入薪水: ");
        double salary = scanner.nextDouble();

        if (salary <= 5000) {
            System.out.println("无需缴税, 工资: " + salary);
        } else if (salary <= 8000) {
            double incomeTax = (salary - 5000) * 0.03;
            salary -= incomeTax;
            System.out.print("需缴税额: " + incomeTax + ", 工资: " + salary);
        } else if (salary <= 17000) {
            double incomeTax = (salary - 5000) * 0.10 - 210;
            salary -= incomeTax;
            System.out.print("需缴税额: " + incomeTax + ", 工资: " + salary);
        } else if (salary <= 30000) {
            double incomeTax = (salary - 5000) * 0.20 - 1410;
            salary -= incomeTax;
            System.out.print("需缴税额: " + incomeTax + ", 工资: " + salary);
        } else if (salary <= 40000) {
            double incomeTax = (salary - 5000) * 0.25 - 2660;
            salary -= incomeTax;
            System.out.print("需缴税额: " + incomeTax + ", 工资: " + salary);
        } else if (salary <= 60000) {
            double incomeTax = (salary - 5000) * 0.30 - 4410;
            salary -= incomeTax;
            System.out.print("需缴税额: " + incomeTax + ", 工资: " + salary);
        } else if (salary <= 80000) {
            double incomeTax = (salary - 5000) * 0.35 - 7160;
            salary -= incomeTax;
            System.out.print("需缴税额: " + incomeTax + ", 工资: " + salary);
        } else {
            double incomeTax = (salary - 5000) * 0.45 - 15160;
            salary -= incomeTax;
            System.out.print("需缴税额: " + incomeTax + ", 工资: " + salary);
        }

    }
}

2.4 switch case分支结构

计算变量/表达式的数值
- 判断是否匹配字面值1
- 若匹配，则执行语句块1 => 执行break跳出当前结构
- 若不匹配，则判断是否匹配字面值2
- 若匹配，则执行语句块2 => 执行break跳出当前结构
- 若不匹配，则执行语句块n
switch()中支持的数据类型有：byte、short、char以及int类型，从jdk1.5 开始支持枚举类型，从jdk1.7开始支持String类型。

package task01.day04;

import java.util.Scanner;

public class C07Switch {
    public static void main(String[] args) {
        // // 提示用户输入考试的成绩，使用if-else if-else分支结构判断所在等级并打印。
        //        // [90 ~ 100] 等级
        //        // [80 ~ 89] 等级B
        //        // [70 ~ 79] 等级C
        //        // [60 ~ 69] 等级D
        //        // [0 ~ 59] 等级E

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩: ");
        int score = scanner.nextInt();

        if (score > 100 || score < 0) {
            System.out.println("无效成绩");
        } else {

            switch (score / 10) {
                case 10:
                case 9:
                    System.out.println("A");
                    break;

                case 8:
                    System.out.println("B");
                    break;

                case 7:
                    System.out.println("C");
                    break;

                case 6:
                    System.out.println("D");
                    break;

                default:
                    System.out.println("E");
                    break;
            }
        }

    }
}

3. 循环结构

在Java程序中若希望重复执行一段代码时，就需要使用循环结构

3.1 for 循环

执行初始化表达式 => 判断条件表达式是否成立
- 成立则执行循环体 => 修改初始值表达式 => 判断条件是否成立
- 若不成立，则循环结束

package task01.day04;

public class C08For {

    // 使用for循环打印三位数中所有水仙花数。
    //• 所谓“水仙花数”即一个整数满足其值等于各个数位的立方和。
    //• 如：153是一个水仙花数，因为153=1^3+5^3+3^3

    public static void main(String[] args) {

        for(int i = 100; i  < 1000; i++) {

            int i1 = i % 10;
            int i2 = i / 10 % 10;
            int i3 = i / 100;

            if (i == i1 * i1 * i1 + i2 * i2 * i2 + i3 * i3 * i3) {
                System.out.println(i + " 是水仙花数");
            }
        }
    }
}

3.2 continue 关键字

continue语句用在循环体中，用于结束本次循环而开始下一次循环

package task01.day04;

public class C09Continue {
    public static void main(String[] args) {
        //使用for循环打印1 ~ 20之间的所有整数，若遇到5的倍数则跳过不打印。

        for (int i = 0; i <= 20; i++) {
            if (i % 5 == 0) {
                continue;
            }
            System.out.println("i = " + i);
        }
    }
}

3.3 break关键字

break用于退出当前语句块，break用在循环体中用于退出循环。 • for(;;) - 这种没有循环条件的循环叫做无限循环，俗称死循环.

package task01.day04;

import java.util.Scanner;

public class C10Break {
    public static void main(String[] args) {
       // 不断地提示用户输入聊天内容并输出，直到用户输入”bye”结束聊天。

        Scanner scanner = new Scanner(System.in);
        for(;;) {
            System.out.println("输入内容: ");
            String message = scanner.nextLine();
            System.out.println("收到消息: " + message);

            if (message.equals("bye")) {
                break;
            }
        }

        System.out.println("聊天结束");
    }
}

3.4 猜数字游戏

• 随机生成数字n(1-100), 等待用户输入猜测数据, 根据用户的输入比较输出猜大了，猜小了，猜对了, 如果用户猜对了就结束游戏。

产生随机数的类 Random()

package task01.day04;

import java.util.Random;
import java.util.Scanner;

public class C11Guess {
    public static void main(String[] args) {
        //  猜数字游戏
        // 随机生成数字n(1-100), 等待用户输入猜测数据, 根据用户的输入比较输出
        //猜大了，猜小了，猜对了, 如果用户猜对了就结束游戏 。

        int guess = new Random().nextInt(100) + 1;
        int answer = 0;
        int count = 0;

        Scanner scanner = new Scanner(System.in);

        for(;;) {
            System.out.println("请输入您的答案(1 ~ 100): ");
            answer = scanner.nextInt();

            if (answer > 100 || answer <= 0) {
                System.out.println("输入有误");
                continue;
            }

            // 计数
            ++count;

            if(answer == guess) {
                System.out.println("猜对了！");
                break;
            } else if (answer < guess) {
                System.out.println("猜小了");
            } else {
                System.out.println("猜大了");
            }
        }

        if (count <= 3) {
            System.out.println("你真棒!，次数: " + count);
        } else if (count < 8) {
            System.out.print("不错，次数: " + count);
        } else {
            System.out.println("好好练习练习！");
        }
    }
}

3.5 双重for循环的格式

执行流程
- 执行表达式1 => 判断表达式2是否成立
  - => 若成立，则执行表达式4 => 判断表达式5是否成立
    - => 若成立，则执行循环体 => 执行表达式6 => 表达式5是否成立
    - => 若不成立，则内层循环结束 => 表达式3 => 表达式2是否成立
    - => 若不成立，则外层循环结束
特点
- 外层循环用于控制打印的行数，内层循环用于控制打印的列数，外层循环改一下，内层循环从头到尾跑一圈。
- 多重循环不宜嵌套太多层，否则效率很低。一般到三重循环即可，最常见的就是双重循环。

package task01.day04;

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

        // 三角形
        //      *
        //     ***
        //    *****
        //   *******
        //  *********

        /*
         分析：
            图形一共有5行9列
            三角形的左边是空白，可以把它填充成一个倒三角形
            所以整个打印就分成了空白三角形和*号三角形
            1. 空白三角形是随行数增加而减少
                显示的规则是 行数-1
            2. * 号三角形是随行数的增加而增加
                显示的规则是 2 * 行数 - 1
         */

        // 一共5行
        for (int i = 1; i <= 5; i++) {
            // 打印空白三角形
            for (int j = 1; j <= 5 - i; j++) {
                System.out.print(" ");
            }

            // 打印*号三角形
            for (int j = 1; j <= 2 * i - 1; j++) {
                System.out.print("*");
            }

            System.out.println(); // 换行
        }
    }
}

3.6 break关键字跳出多层循环

在嵌套的循环结构中，break用于退出所在循环体。
如果要退出外层循环体，需要使用标号的方式。
- break 标号;

package task01.day04;

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

        outter:
        for (int i = 0; i < 10; i++) {

            for (int j = 0; j <= i; j++) {

                System.out.print("i = " + i + ", j = " + j + "\t");

                if (j == 2) {
                    break;
                }

                if (i == 5) {
                    break outter;
                }
            }

            System.out.println("内层循环结束");

        }

        System.out.println("双重循环结束");
    }
}

3.7 while循环

语法
- while(条件表达式) {循环体;}

判断条件表达式是否成立
- 若成立，则执行循环体 => 判断条件表达式是否成立
- 若不成立，则循环结束
和for的对比
- while循环和for循环完全可以互换
- while循环更适合于明确循环条件但不明确循环次数的场合中
- for循环更适合于明确循环次数或范围的场合中
- while(true) 等价于 for(;;) 都表示无限循环

package task01.day04;

public class C14While {
    public static void main(String[] args) {
        // 使用双重循环打印2~100之间的所有素数。
        // 当一个数只能被1和它本身整除时，这个数就叫做素数或质数

        int num = 2;
        while (num <= 100) {
            //  只需要判断2到该数的平方根即可，因为随着除数的增大商必然减小，会造成重复的判断
            boolean isPrime = true;
            int i = 2;
            while (i <= Math.sqrt(num)) {

                if (num % i == 0) {
                    isPrime = false;
                    break;
                }

                i++;
            }

            if (isPrime) {
                System.out.println( num + " 是素数");
            }

            num++;
        }
    }
}

3.8 do while

语法
- do {循环体;} while(条件表达式);

执行流程
- 执行循环体 => 判断条件表达式是否成立
  - 若成立，则执行循环体 => 判断条件表达式是否成立
  - 若不成立，则循环结束
do-while循环主要用于至少执行一次循环体的场合中

package task01.day04;

import java.util.Scanner;

public class C15DoWhile {
    public static void main(String[] args) {
        // 输入一个数整数的逆序输出
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数: ");
        int num = scanner.nextInt();
        System.out.println(num + " 的逆序输出是：");
        do {
            System.out.print(num % 10);
            num /= 10;
        } while (num > 0);
    }
}