JavaSE第4篇：流程控制

明了LM

已于 2022-04-17 12:28:38 修改

阅读量675

点赞数

分类专栏： Java基础文章标签： java

于 2022-04-10 17:49:53 首次发布

本文链接：https://blog.csdn.net/qq_29445811/article/details/124079484

版权

Java基础专栏收录该内容

16 篇文章 0 订阅

订阅专栏

文章目录

一、流程控制是什么
二、顺序结构
三、分支结构
- 1、if else
- 2、switch case
四、循环结构
五、嵌套循环
六、关键字使用
总结

一、流程控制是什么

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块

二、顺序结构

顺序结构：程序从上到下逐行的执行、中间没有任何判断和跳转

三、分支结构

分支结构:根据条件选择性的执行某段代码

1、if else

if三种格式：

		//第一种
        if (条件表达式) {
            执行代码块
        }
		//第二种
        if (条件表达式) {
            执行代码块1
        } else {
            执行代码块2
        }
		//第三种
        if (条件表达式1) {
            执行代码块1
        } else if（条件表达式2）{
            执行代码块2
        ....
        }else{
            执行代码块
        }

2、switch case

语法：

        switch (表达式) {
            case 常量1:
                语句1;
                break;
                
            case 常量2:
                语句2;
                break;
                
            default:
                默认语句;
                break;
        }

说明：
根据swith表达式中的值，依次匹配各个case中的常量。一旦匹配成功则进入相应case中的的执行语句。当调用完执行语句以后，则任然继续向下执行其他case语句，直到遇见break关键字或者默认语句为止结束

switch中的表达式有6中数据类型：byte、 short 、 char 、int 、枚举(JDk1.5) 、String （JDK1.7）

case之后只能声明常量。不能声明范围。

default相当于if else中的else。 default结构是可选的

可以使用switch-case结构都可以使用if-else 。反之不成立
可以使用三元表达式和switch-case都可以使用if-esle

四、循环结构

循环结构:根据循环条件重复性的执行某段代码

所有循环语句的四个组成部分
1、初始化条件(只执行一次)
2、循环条件 (boolean类型)
3、循环体
4、迭代条件

1、while

不在循环条件部分限制次数的结构：

for(;;) 
while(true)

结束循环有几种方式
方式一：循环条件中返回false
方式二：循环体中执行break;
continue;

2、do while

	1、初始化部分
	do {
	3、循环体
	4、迭代条件
	}while (2、循环条件boolean类型);

执行过程：①----③—④---②—③---④—②--------③—④---②
特点：至少会执行一次循环体

    public static void main(String[] args) {
        //遍历100以内的偶数、并求和、统计偶数的个数
        int c = 1;//初始化条件
        int count = 0;
        int sum = 0;
        do {
            //循环体
            if (c % 2 == 0) {
                System.out.println(c);
                count++;
                sum += c;
            }
            //迭代条件
            c++;
        } while (c <= 100);//循环条件
        System.out.println("和：" + sum);
        System.out.println("个数：" + count);
    }

3、for

执行过程：①—②---③—④---②—③---④--------②—③---④

eg1:遍历100以内的偶数、并求和、统计偶数的个数

    public static void main(String[] args) {
        //遍历100以内的偶数、并求和、统计偶数的个数
        int sum = 0;
        int count = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println("偶数：" + i);
                sum += i;
                count++;
            }
        }
        System.out.println("和：" + sum);
        System.out.println("个数：" + count);
    }

循环遍历1-150，并在每行打印一个值。如果是3的倍数每行打印foo 5的倍数打印biz 7的倍数打印输出baz

        //循环遍历1-150，并在每行打印一个值。如果是3的倍数每行打印foo 5的倍数打印biz 7的倍数打印输出baz

        for (int i = 1; i <= 150; i++) {
            System.out.print(i + "\t");
            if (i % 3 == 0) {
                System.out.print("foo" + "\t");
            }
            if (i % 5 == 0) {
                System.out.print("biz" + "\t");
            }
            if (i % 7 == 0) {
                System.out.print("baz" + "\t");
            }

            System.out.println();
        }
    }

输入两个正整数m和n、求其最大公约数和最小公倍数

    public static void main(String[] args) {
        //输入两个正整数m和n、求其最大公约数和最小公倍数  约数(余数为0的数比如12除以1是12) 倍数
        //比如12和20最大公约数是4，最小公倍数是60
        Scanner s = new Scanner(System.in);
        System.out.println("请输入第一个整数");
        int m = s.nextInt();
        System.out.println("请输入第二个整数");
        int n = s.nextInt();
        //获取最大公约数
        //1、获取两个数的较小值 因为最大公约数不能比自身还大12
        int min = m <= n ? m : n;//c=12
        //2遍历
        for (int i = min; i >= 1; i--) {
            if (m % i == 0 && n % i == 0) {
                System.out.println("最大公约数：" + i);
                break;
            }
        }
        //获取最小公倍数
        //2、获取两个数的最大值
        int max = m >= n ? m : n;//c=20
        for (int i = max; i <= m * n; i++) {
            if (i % m == 0 && i % n == 0) {
                System.out.println("最小公倍数：" + i);
                break;
            }
        }
    }

五、嵌套循环

嵌套循环：我们将一个循环结构声明在另一个循环结构的循环体中

外层循环：循环m
内层循环：循环n

外层循环控制行数、内存循环控制列数
外层循环m次、内层循环n次，则内层循环的次数m乘n次

        /**
         * ******
         * ******
         * ******
         * ******
         */
        for (int i = 1; i <= 4; i++) {
            for (int j = 1; j <= 6; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        /**
         * *
         * **
         * ***
         * ****   
         */
        for (int i = 1; i <= 4; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        /**
         *
         *  ****
         *  ***
         *  **
         *  *
         * 
         */
        for (int i = 1; i <= 4; i++) {
            for (int j = 1; j <=5-i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= 4 - i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k < i + 1; k++) {
                System.out.print("* ");
            }
            System.out.println();
        }

        /**
         *     * 
         *   * * 
         *  * * * 
         * * * * * 
         */
      
        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= 4 - i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k < i + 1; k++) {
                System.out.print("* ");
            }
            System.out.println();
        }

        for (int i = 1; i <= 5; i++) {

            for (int k = 1; k < i + 1; k++) {
                System.out.print(" ");
            }
            for (int j = 1; j <= 4 - i; j++) {
                System.out.print("* ");
            }

            System.out.println();
        }

九九乘法表

        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <=i; j++) {
                System.out.print(j + "X" + i + "=" + i * j);
                System.out.print('\t');
            }
            System.out.println();
        }

输出100以内的所有质数

			boolean flag = true;
        //优化二：对本身是质数的自然数是有效的
        for (int i = 2; i <= 100; i++) {
            for (int j = 2; j <=i; j++) {
                if (i % j == 0) {
                    flag = false;
                }
            }
            if (flag == true) {
                System.out.println(i);
            }
            flag = true;
        }

			boolean flag = true;
        //优化二：对本身是质数的自然数是有效的
        for (int i = 2; i <= 100; i++) {
            for (int j = 2; j <=i; j++) {
                if (i % j == 0) {
                    flag = false;
                     break;//优化一：只对本身非自然数是有效的
                }
            }
            if (flag == true) {
                System.out.println(i);
            }
            flag = true;
        }

       /**
         * 输出100以内的所有质数
         * 质数：素数，只能被1和他本身整除的自然数-->从2开始到这个数减1结束为止都不能被这个数整除
         */
        boolean flag = true;
        //优化二：对本身是质数的自然数是有效的
        for (int i = 2; i <= 100; i++) {
            for (int j = 2; j <=Math.sqrt(i); j++) {
                if (i % j == 0) {
                    flag = false;
                    break;//优化一：只对本身非自然数是有效的
                }
            }
            if (flag == true) {
                System.out.println(i);
            }
            flag = true;
        }

       /**
         * 输出100以内的所有质数
         * 质数：素数，只能被1和他本身整除的自然数-->从2开始到这个数减1结束为止都不能被这个数整除
         */
        label:for (int i = 2; i <= 100; i++) {
            //Math.sqrt(i)开方
            for (int j = 2; j <= Math.sqrt(i); j++) {//j被i去除
                if (i % j == 0) {//i被j除尽
                    continue label;//优化一：只对本身非自然数是有效的
                }
            }
            //能执行到次步骤的都是质数
            System.out.println(i);
        }

六、关键字使用

1、break

适用范围 switch…case 或者循环结构
不同点 结束当前循环

2、continue

适用范围 循环结构
不同点 结束当次循环进入下次循环
相同点：关键字后面不能添加其它语句不会执行、编译报错

        label:
        for (int i = 1; i <= 4; i++) {
            for (int j = 1; j <= 10; j++) {
                if (j % 4 == 0) {
                    //break;
                    // continue;
                    //break label;//结束指定标识的一层循环结构
                    continue label;//结束指定标识的一层循环结构当次循环
                }
                System.out.print(j);
            }
            System.out.println();
        }