Self Java, day03_ flow control statements

Process Control

Outline

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

• According to the order written, running from top to bottom

Code demonstrates the sequence structure

// sequence structure 
public  class Demo01Sequence {
     public  static  void main (String [] args) {
        System.out.println(1);//1
        System.out.println(2);//2
        System.out.println(3);//3
        System.out.println(4);//4
    }
}

Execution Flow sequence structure

Judgment statement

If the judge sentences

• The first format if statement: if

format:

Implementation process

• First, determine the relationship between the expression to see the result is true or false
• If the statement is true on the implementation of the body
• If false statement is not executed body

Basic code demonstrates the use of a single if statement

// 单if语句
public class Demo02If {
    public static void main(String[] args) {
        int age = 19;
        // （age> 18） 判断关系表达式看其结果是true还是false
        if (age >= 18) {
            //如果是true就执行语句体
            System.out.println("进入网吧，开始high！");//进入网吧，开始high！
        }
        //if语句之后执行的代码
        System.out.println("回家吃饭");//回家吃饭
    }
}

单if语句的执行流程图

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

格式：

执行流程

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

代码演示if..else的基本使用

// 判断给定的数据是奇数还是偶数
public class DemoIfElse {
    public static void main(String[] args) {
        // 定义变量
        int a = 31;
        //a % 2 == 0 是关系表达式看其结果是true还是false
        if (a % 2 == 0) {
            //结果为true执行此括号里的代码 （语句体1）
            System.out.println("a是偶数");
        } else {
            //结果为false执行此括号里的代码（语句体2）
            System.out.println("a是奇数");//a 是奇数
        }
        //if..else 语句之后执行的代码
        System.out.println("结束"); //结束
    }
}

标准的if...else 语句执行流程图

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

格式：

执行流程

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

 代码演示if...else if ...else的基本使用

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

if...else if ...else语句执行流程图

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

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

代码演示

// 题目：使用三元运算符和标准的if-else语句分别实现：取两个数字当中的最大值
public class Demo06Max {
    public static void main(String[] args) {
        int a = 105;
        int b = 20;

        // 首先使用三元运算符
        // int max = a > b ? a : b;

        // 使用今天的if语句
        int max;
        if (a > b) {
            max = a;
        } else {
            max = b;
        }

        System.out.println("最大值：" + max);//最大值：105
    }
}

选择语句 

选择语句switch 

switch语句格式： 

执行流程

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

代码演示switch语句的基本使用

public class Demo07Switch {
    public static void main(String[] args) {
        //定义变量，判断是星期几
        int weekday = 4;
        //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语句执行流程图

switch语句使用的注意事项：

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

代码演示switch注意事项

public class Demo08SwitchNotice {
    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循环语句格式： 

执行流程

• 执行顺序：①②③④>②③④>②③④…②不满足为止。
• ①负责完成循环变量初始化。在循环开始最初执行，而且只做唯一一次。
• ②负责判断是否满足循环条件，不满足则跳出循环
• ③具体执行的语句，重复要做的事情内容，若干行语句。
• ④循环后，循环条件所涉及变量的变化情况 。每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。

代码演示for循环的基本使用

//使用for循环，计算1-100之间的偶数和
public class ForPractise {
    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);//sum:2550
    }
}

for循环的执行流程图

循环语句while 

while循环语句格式：

执行流程

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

代码演示while循环的基本使用

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

while循环的执行流程图

循环语句do...while 

do...while循环格式 ：

执行流程

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

代码演示do...while 循环的基本使用

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

do...while循环的执行流程图

三种循环的区别

• 如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但是do-while循环会执行至少一次。
• for循环的变量在小括号当中定义，只有循环内部才可以使用。while循环和do-while循环初始化语句本来就在外面，所以出来循环之后还可以继续使用。

代码演示

public class Demo13LoopDifference {
    public static void main(String[] args) {
        for (int i = 1; i < 0; i++) {
            System.out.println("Hello");
        }
        // System.out.println(i); // 这一行是错误写法！因为变量i定义在for循环小括号内，只有for循环自己才能用。
        
        int i = 1;
        do {
            System.out.println("World");
            i++;
        } while (i < 0);
        // 现在已经超出了do-while循环的范围，我们仍然可以使用变量i
        System.out.println(i); // 2
    }
}

关于循环的选择，有一个小建议：

• 凡是次数确定的场景多用for循环；否则多用while循环。

跳出语句 

关键字break

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

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

代码演示break基本使用

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

关键字continue

使用场景：用在循环中，一旦执行，立刻跳过当前次循环剩余内容，马上开始下一次循环。

代码演示continue的基本使用

public class Demo15Continue {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i == 4) { // 如果当前是第4层
                continue; // 那么跳过当前次循环，马上开始下一次（第5层）
            }
            System.out.println(i + "层到了。");
        }
    }
}

死循环 

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

代码演示什么是死循环

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

死循环的标准格式：
while (true) {
    循环体
}
*/
public class Demo16DeadLoop {
    public static void main(String[] args) {
        while (true) {
            System.out.println("I Love Java!");
        }
        
        // System.out.println("Hello");错误， 永远执行不到的代码不能写
    }
}

嵌套循环

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

嵌套循环格式： 

嵌套循环执行流程：

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

代码演示循环嵌套的基本使用

public class Test {
    //练习：使用嵌套循环，打印5*8的矩形
    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();
        }
    }
}