Self Java, day03_ flow control statements

Others 2019-12-26 19:55:48 views: null

Process Control Overview

During a program execution, the order of execution of the statement of the program is the result of a direct impact. That is, the flow of the program have a direct impact on operating results. So, we have to understand the flow of execution for each statement. And, many times we want to achieve our functions to be performed by the execution order control statements.

Sequence Structure

  • Order execution, according to the order written, running from top to bottom
Code demonstrates 
package demo01;

public  class DemoSequence {
     public  static  void main (String [] args) {
         // sequentially executed, prepared according to the order, from top to bottom operation 
        System.out.println (. 1 );
        System.out.println(2);
        System.out.println(3);
    }
}

The results of the code execution

Judgment statement 

  • The first if statement formats: single if statement
format:
Implementation process
  1. First, determine the relationship between the expression to see the result is true or false
  2. If the statement is true on the implementation of the body
  3. If false statement is not executed body 

Execution Flow

Code demonstrates

package demo02;

/*
Define two variables, using a single if statement that compares for equality
 */
public class Demo01If {
    public static void main(String[] args) {
        // 定义两个变量
        int a = 10;
        int b = 20;
        //变量使用if判断
        if (a == b) {
            //语句体
            System.out.println("a等于b");
        }
        int c = 10;
        if (a == c) {
            //语句体
            System.out.println("a等于c");
        }
        System.out.println("结束");
    }
}

代码执行后结果

  • if语句第二种格式： if...else 

格式：

执行流程
  1. 首先判断关系表达式看其结果是true还是false
  2. 如果是true就执行语句体1
  3. 如果是false就执行语句体2 

执行流程图

代码演示

package demo02;

public class Demo02IfElse {
    public static void main(String[] args) {
        // 判断给定的数据是奇数还是偶数
        // 定义变量
        int a = 28;
        //关系表达式
        if (a % 2 == 0) {
            //语句体1
            System.out.println("a是偶数");
        } else {
            //语句体2
            System.out.println("a是奇数");
        }
        System.out.println("结束");
    }
}

代码执行后的结果

  • if语句第三种格式： if...else if ...else

格式：

执行流程
  • 首先判断关系表达式1看其结果是true还是false
  • 如果是true就执行语句体1
  • 如果是false就继续判断关系表达式2看其结果是true还是false
  • 如果是true就执行语句体2
  • 如果是false就继续判断关系表达式
  • …
  • 看其结果是true还是false
  • …
  • 如果没有任何关系表达式为true，就执行语句体n+1。

执行流程图

代码演示

package demo02;

/*
指定考试成绩，判断学生等级
 90-100 优秀
 80-89 好
 70-79 良
 60-69 及格
 60以下 不及格
 */
public class Demo03IfElseExt {
    public static void main(String[] args) {
        int score = 60;
        // 处理边界之外的不合理情况
        if (score < 0 || score > 100) {
            System.out.println("你的成绩是错误的");
        } else if (score >= 90 && score <= 100) {
            System.out.println("你的成绩属于优秀");
        } else if (score >= 80 && score < 90) {
            System.out.println("你的成绩属于好");
        } else if (score >= 70 && score < 80) {
            System.out.println("你的成绩属于良");
        } else if (score >= 60 && score < 70) {
            System.out.println("你的成绩属于及格");
        } else {
            System.out.println("你的成绩属于不及格");
        }
    }
}

代码执行后的结果

if语句和三元运算符的互换

在某些简单的应用中，if语句是可以和三元运算符互换使用的。

代码演示 
package demo02;

public class Demo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //定义变量，保存a和b的较大值
        int max;
        if (a > b) {
            max = a;
        } else {
            max = b;
        }
        System.out.println("最大值是：" + max);//最大值是：20
        //可以上述功能改写为三元运算符形式
        System.out.println("最大值是：" + (a > b ? a : b));//最大值是：20

    }
}

选择语句

  • 选择语句之switch语句
格式：
执行流程
  • 首先计算出表达式的值
  • 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
  • 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
执行流程图

 代码演示

package demo03;

public class Demo01Switch {
    public static void main(String[] args) {
        //定义变量，判断是星期几
        int weekday = 5;
        //switch语句实现选择
        switch (weekday) {
            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语句可以省略，但是强烈推荐不要省略
                break;
        }
    }
}

代码执行后的结果

switch语句使用的注意事项：

  • 多个case后面的数值不可以重复。
  • witch后面小括号当中只能是下列数据类型：基本数据类型中的：byte/short/char/int   引用数据类型中的：String字符串、enum枚举
  • switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略。
  • 在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。 

代码演示

package demo03;

public class Demo02SwitchNotice {
    public static void main(String[] args) {
        int i = 5;
        switch (i) {
            case 0:
                System.out.println("执行case0");
                break;
            case 5:
                System.out.println("执行case5");
            case 10:
                System.out.println("执行case10");
            default:
                System.out.println("执行default");
        }
    }
}
代码执行后结果
上述程序中，执行case5后，由于没有break语句，程序会一直向后走，不会在判断case，也不会理会break，直接运行完整体switch。由于case存在穿透性，因此初学者在编写switch语句时，必须要写上break。 

循环语句

循环概述：循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。
  • 循环语句 之for 循环
for循环语句格式：
执行流程
  • 执行顺序：①②③④>②③④>②③④…②不满足为止。
  • ①负责完成循环变量初始化。初始化语句：在循环开始最初执行，而且只做唯一一次。
  • ②负责判断是否满足循环条件，不满足则跳出循环。条件判断：如果成立，则循环继续；如果不成立，则循环退出。
  • ③具体执行的语句。循环体：重复要做的事情内容，若干行语句。
  • ④循环后，循环条件所涉及变量的变化情况 。每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。
执行流程图

代码演示

package demo4;

/*
循环练习：使用for循环，计算1-100之间的偶数和
 */
public class Demo01For {
    public static void main(String[] args) {
        //1.定义一个初始化变量,记录累加求和,初始值为0
        int sum = 0;
        //2.利用for循环获取1‐100之间的数字
        for (int i = 1; i <= 100; i++) {
            //3.判断获取的数组是奇数还是偶数 
            if (i % 2 == 0) {
                //4.如果是偶数就累加求和
                sum += i;
            }
        }
        //5.循环结束之后,打印累加结果
        System.out.println("sum:" + sum);
    }
}

代码执行后的结果

  • 循环语句之while循环 
格式：
执行流程
  • 执行顺序：①②③④>②③④>②③④…②不满足为止。
  • ①负责完成循环变量初始化。
  • ②负责判断是否满足循环条件，不满足则跳出循环。
  • ③具体执行的语句。
  • ④循环后，循环变量的变化情况。
 执行流程图

代码演示

package demo05;

/*
while循环有一个标准格式，还有一个扩展格式。

标准格式：
while (条件判断) {
    循环体
}

扩展格式：

初始化语句;
while (条件判断) {
    循环体;
    步进语句;
}
*/
//使用while循环，计算1-100之间的偶数和
public class Demo01While {
    public static void main(String[] args) {
        //1.定义一个初始化变量result,记录累加求和,初始值为0
        int result = 0;
        //1：定义初始化表达式i
        int i = 1;
        //2：负责判断i< 101 是否满足循环条件，不满足则跳出循环。
        while (i < 101) {
            //3.判断获取的数组是奇数还是偶数
            if (i % 2 == 0) {
                //4.如果是偶数就累加求和
                result += i;
            }
            //5 循环一次后，负责修改初始化变量
            i++;
        }
        //6.循环结束之后,打印累加结果
        System.out.println("1-100之间的偶数和：" + result);
    }
}

代码执行后的结果

  • 循环语句之do...while循环
格式：
 
执行流程
  • 执行顺序：①③④>②③④>②③④…②不满足为止。
  • ①负责完成循环变量初始化。
  • ②负责判断是否满足循环条件，不满足则跳出循环。
  • ③具体执行的语句
  • ④循环后，循环变量的变化情况
执行流程图

代码演示

package demo06;

/*
do-while循环的标准格式：

do {
    循环体
} while (条件判断);

扩展格式：

初始化语句
do {
    循环体
    步进语句
} while (条件判断);
*/
// 需求：do...while循环输出5次HelloWorld
public class Demo01DoWhile {
    public static void main(String[] args) {
        // 1. 初始化语句
        int i = 0;
        do {
            // 3. 循环体
            System.out.println("HelloWorld");
            // 4. 步进语句
            i++;
        } while (i < 5); // 2. 条件判断

    }
}

代码执行后的结果

 三种循环语句的区别

  • 如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但是do-while循环会执行至少一次。
  • 控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while/do...while循环结束还可以继续使用，如果你想继续使用，就用while/do....while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
    在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。

 代码演示

package demo06;

/*
三种循环的区别。

1. 如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但是do-while循环会执行至少一次。
2. for循环的变量在小括号当中定义，只有循环内部才可以使用。while循环和do-while循环初始化语句本来就在外面，所以出来循环之后还可以继续使用。
*/
public class LoopDifference {
    public static void main(String[] args) {
        for (int i = 1; i < 0; i++) {
            //i 不满足 不会执行语句体中代码
            System.out.println("Hello");
        }
        // System.out.println(i); // 这一行是错误写法！因为变量i定义在for循环小括号内，只有for循环自己才能用。
        System.out.println("===============");
        int i = 1;
        do {
            //语句体中的代码至少执行一次
            System.out.println("World");
            i++;
        } while (i < 0);
        // 现在已经超出了do-while循环的范围，我们仍然可以使用变量i
        System.out.println(i);
        System.out.println("=========================");
        int j = 0;
        while (j < 1) {
            System.out.println("加油");//加油
            j++;
        }
        // 现在已经超出了while循环的范围，我们仍然可以使用变量j
        System.out.println(j);
    }
}

代码执行后的结果

跳出语句

关键字 break

使用场景：终止switch或者循环，离开使用场景的存在是没有意义的

break关键字的用法有常见的两种：

  • 可以用在switch语句当中，一旦执行，整个switch语句立刻结束。
  • 还可以用在循环语句当中，一旦执行，整个循环语句立刻结束。打断循环。

代码演示

public class DemoBreak {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            // 如果希望从第4次开始，后续全都不要了，就要打断循环
            if (i == 4) {
                // 打断整个循环,循环结束
                break;
            }
            System.out.println("Hello" + i);
        }
        System.out.println("循环结束后的代码");
    }

}

代码执行后的结果

关键字 continue

  • 使用场景：在循环中使用，离开使用场景的存在是没有意义的
  • 常见用法：一旦执行，立刻跳过当前次循环剩余内容，马上开始下一次循环。

代码演示

package demo07;

//需求： 打印1 2 5 6
public class DemoContinue {
    public static void main(String[] args) {
        for (int i = 1; i <= 6; i++) {
            if (i == 3 || i == 4) {
                //执行了continue循环之后，本次循环后续代码不在执行，循环从头再来
                continue;
            }
            System.out.println(i);
        }
        System.out.println("循环结束后的代码");
    }
}

代码执行后的结果

死循环

死循环：也就是循环中的条件永远为true，死循环的是永不结束的循环。在后期的开发中，会出现使用死循环的场景，例如：我们需要读取用户输入的输入，但是用户输入多少数据我们并不清楚，也只能使用死循环，当用户不想输入数据了，就可以结束循环了，如何去结束一个死循环呢，就需要使用到跳出语句了。

代码演示

package demo07;

/*
永远停不下来的循环，叫做死循环。

死循环的标准格式：
while (true) {
    循环体
}
*/
public class DeadLoop {
    public static void main(String[] args) {
        while (true) {
            System.out.println("I Love Java!");
        }

        // System.out.println("Hello");错误，永远执行不到的代码不能写
    }
}

循环嵌套

所谓嵌套循环，是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数
嵌套循环格式：

嵌套循环执行流程：

  • 执行顺序：①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥外循环一次，内循环多次。比如跳绳：一共跳5组，每组跳10个。5组就是外循环，10个就是内循环

代码演示

package demo07;

//需求：使用嵌套循环，打印5*8的矩形
public class DemoLoop {
    public static void main(String[] args) {
        /*5*8的矩形，打印5行*号，每行8个
         外循环5次，内循环8次
          */
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 8; j++) {
                //不换行打印星号
                System.out.print("*");
            }//内循环打印8个星号后，需要一次换行
            System.out.println();
        }
    }
}

代码执行后的结果

 

 

 

 

Guess you like

Origin www.cnblogs.com/wurengen/p/12102326.html
Recommended
Ranking
SpringBoot-integrate redis
[Sword pointing to offer] Interview question 03: Repeated numbers in an array
Arrangement "Offer Penalty for prove safety" string
Browser prevent the automatic generation of fill and Echo have been saved account solutions
Work hard and never slacken——2022 Yinmai Information Year-End Summary
Install jdk7 on Linux system
App common dependency management tools
EduCoder-Web程序设计基础-html5— 给表单组件添加说明-第1关：label标签相关概念
Machine learning - clustering - density clustering algorithm notes
Ant's large model is exposed, AI+ finance enters the "big model" era
Daily
More
2024-04-30(36)
2024-04-29(5)
2024-04-28(12)
2024-04-27(29)
2024-04-26(22)
2024-04-25(32)
2024-04-24(30)
2024-04-23(30)
2024-04-22(5)
2024-04-21(0)

Code World

© 2018 codetd.com