【Java基础】流程控制

男娘i 2022-04-24 09:32 166阅读 0赞

上次的运算符都消化好了吗？每一天都要用到一些哦~

以前有提到过一嘴，程序执行都是从上到下执行的，emm，学到这里，感觉这句话是对的也是错的了……

如果都是一行一行执行下去的话，上节课的例子：

今天不上班
    我呆在家里

假设今天上班，按照程序，那么执行完第一行，“今天不上班”，是假的呀，再执行第二行……？执行第二行 “我呆在家里”…… 于是应该上班的日子我呆在了家里…… 我就会被辞了 o(╥﹏╥)o

是不是啊？一行行来执行，就达不到我们想要的目的了~

还有啊，如果打印一个乘法口诀表，难道我们手打 45 行输出代码？于是我们今天学的东西就会解决这个问题了~

还是和上节一样的，搞两个变量先：

int a = 100, b = 0;

# 顺序结构 #

顺序结构就是上面说到的那种，从上到下一行行执行。

int c = a - b;
    System.out.println(c);

![1596190-20190415160459538-2147162119.png][]

吃完就睡了，真的。

# 选择结构 #

选择结构，就是满足了一个条件，我就会选择干一件事情。所以满足条件和不满足条件我们用 true 和 false 来代替，所以每个选择里面的条件语句需要用到运算符中的关系运算符以及逻辑运算符了，他们的结果必须是一个布尔值（布尔表达式）（switch 语句除外，另行讲述）~

这个结构大体上又可以分成三种：if 语句、if…else 语句、switch 语句。

## 1. if 语句 ##

int c = a - b;
    if (a > b) {
        System.out.println(c);
    }
    System.out.println("结束~");

![1596190-20190415191545116-409776309.png][]输出结果：![1596190-20190415161642577-816163897.png][]

如果不满足呢？

int c = a - b;
    if (a < b) {    // 不满足
        System.out.println(c);
    }
    System.out.println("结束~");

输出结果：![1596190-20190415161822898-22974894.png][]

跳过了哦~~

## 2. if…else 语句 ##

if (a > b) {    // 满足
        System.out.println("对的");
    }else {
        System.out.println("错了");
    }
    System.out.println("结束~");

![1596190-20190415162303953-5230132.png][]

输出结果：![1596190-20190415162425708-1677003407.png][]

错误情况请自己试验一下哦~

此外，if…else 还可以有多个分支的哦：

if (a < b) {
        System.out.println("a小于b");
    }else if( a == b){    
        System.out.println("相等");
    }else {
        System.out.println("a大于b");
    }

输出结果：![1596190-20190415162942420-598544594.png][]

此外，如果 if 语句后面仅有一句代码，那么可以省略大括号（但是一般来说不建议，少括号容易出错哦）

## 3. switch 语句 ##

switch 语句和上面的那几个不一样~ 它就像打电话一样，我拨的号码是哪个，哪个号码就会接到电话：（所以 switch 只支持整型以及 char 类型的变量！而且整型只包括 byte、short、int！）

int d = 10000;
    switch (d) {//只支持整型以及char类型的变量！而且整型只包括byte、short、int！
    case 10010:
        System.out.println("中国联通");
        break;
    case 10086:
        System.out.println("中国移动");
        break;
    case 10000: //拨打的这个号码
        System.out.println("中国电信");
        break;
    default:
        System.out.println("打错了");
        break;
    }

![1596190-20190415164232903-1325507478.png][]输出结果：![1596190-20190415164219805-1617633135.png][]

因为 d 是 10000，输出了中国电信~。

# 循环结构 #

循环就是重复做意见事情，同一句代码要写 10 句的话，用循环绝对是最好的选择~ 做循环需要三个条件：第一、循环的变量，第二、循环体（循环的内容），第三、循环的终止条件（啥时候退出循环）。Java 中有三种循环：while、do…while、for 循环。

## 1. while 循环 ##

先说语法：

while(布尔表达式) {
      程序语句    
    }

再举个栗子：

while (b<5) {    //循环终止条件
        System.out.println("第"+ （b+1） +"次循环");    //循环体
        b++;    //循环变量
    }

第一次判断：b=0<5 的时候，是第 1 次循环，b++，继续循环

第二次判断：b=1<5 的时候，是第 2 次循环，b++，继续循环

...

第五次判断：b=4<5 的时候，是第 5 次循环，b++，继续循环

第六次判断：b=5<5 的时候，不满足条件

so，while 先判断再运行循环体。这里一共进行了六次判断，五次运行循环体。

输出结果：![1596190-20190415173653418-1399921061.png][]

另外，如果布尔表达式一直为真，那么就会一直循环，造成 “死循环”，出不去的情况。

while (true) {    // 一直true，一直循环
        System.out.println("第"+ b +"次循环");
        b++;
    }

就会一直输出，除非手动停下程序或者内存不足……

## 2. do…while 循环 ##

先上语法：

do {
        程序语句;
    } while (布尔表达式);

再来代码：

do {
        System.out.println("do while 第"+ b +"次循环");
        b++;
    } while (b<5);

b=0 的时候，是第 1 次循环，b++，第一次判断：b=1<5，继续循环

b=1 的时候，是第 2 次循环，b++，第二次判断：b=2<5，继续循环

...

b=4 的时候，是第 5 次循环，b++，第五次判断：b=3<5，停止循环

so，dowhile 先运行循环体再做结果的判断，这里一共是五次判断，五次运行循环体。

输出结果：![1596190-20190415174142961-669877667.png][]

到这里就衍生了一个疑问，while 好还是少做一次判断的 dowhile 好呢？

其实具体还是得看业务需求~（但是还是推荐优先使用 while）

主要是【如果我的变量一开始就不满足终止条件，使用 dowhile 的话仍然会执行一次，才会去判断条件成立与否。】

## 3. for 循环 ##

for 循环与 while 类似，先进行判断，再执行。语法：

for (表达式1; 表达式2; 表达式3) {
        执行语句
    }
    表达式1：循环变量赋初值
    表达式2：循环终止条件（布尔表达式）
    表达式3：循环变量的增、减

再来段代码：

for (int i = 0; i < 5; i++) {
        System.out.println("for 第"+ (i+1) +"次循环");
    }

b=0 的时候，第一次判断：b=1<5，b++，是第 1 次循环，然后继续循环

b=1 的时候，第二次判断：b=2<5，b++，是第 2 次循环，然后继续循环

...

b=4 的时候，第五次判断：b=3<5，b++，是第 5 次循环，停止循环。

输出结果![1596190-20190415190722437-644820750.png][]

for 循环也是先进行判断，然后再执行循环体。若 表达式 1、表达式 2、表达式 3 都不写，则会陷入死循环。

## 4. 循环嵌套 ##

循环和选择语句一样，也是可以嵌套使用的~ 比如

for (int i = 1; i <= 9; i++) {
        for (int j = 1; j <= i; j++) {
            System.out.print(j+"*"+i+"="+(j*i)+"\t");//  \t转移字符——制表符
        }//打印完一行之后换行
        System.out.println();//println自带换行
    }

i 的第一次循环，i = 1，i<=9,

j 的第一次循环，j=1, j<=**i(1)**, 输出 1\*1=1，

跳出 j 循环，输出换行。

i 的第二次循环，i = 2，i<=9,

j 的第一次循环，j=1, j<=**i(2)**, 输出 1\*2=1，

j 的第二次循环，j=2, j<=**i(2)**, 输出 2\*2=3，

跳出 j 循环，输出换行。

……

那么输出的就是一个乘法口诀表了：

![1596190-20190415183056817-606568752.png][]

# break & continue 语句 #

break：退出当前循环或终止 switch 语句序列。

continue：中断当前循环但不退出当前循环，而是继续进行。

### break 语句 ###

用上面的乘法口诀改吧改吧：

for (int i = 1; i < 3; i++) {
        for (int j = 1; j <= 3; j++) {
            if (j == 2) {
                System.out.println("j==2,结束了");
                break;
            }
            System.out.println("j="+j);
        }
        
    }
    System.out.println("外层才结束");

输出结果：![1596190-20190415183712944-1673727017.png][]

发现里面结束了两次，每次都没有输出 j=3，这样就说明，break 能结束当前的循环，而不能结束外面的循环（就是说它只管他自己在的地方）

### continue ###

再用上面的 break 改吧改吧：

for (int i = 1; i < 3; i++) {
        for (int j = 1; j <= 3; j++) {
            if (j == 2) {
                System.out.println("结束了");
                continue;
            }
            System.out.println("j="+j);
        }
        
    }
    System.out.println("外层才结束");

输出结果：![1596190-20190415184026868-92920248.png][]

ei？换成 continue 之后，j=3 也输出了…… 这样就说明，continue 是只结束了 j=2 的这次循环，并没有跳出 j 的循环。就等于是运行到 j=2 的时候跳过了，接着下一次循环。

\--------------------------------------------------

以我的语文水平，就够解释到这个程度了…… 见谅。

以上，阿里嘎多，20190415 from ahanwhite。

[1596190-20190415160459538-2147162119.png]: /images/20220216/2c361a0a8a664fb29f1ad4ee1f0b4916.png
[1596190-20190415191545116-409776309.png]: https://img2018.cnblogs.com/blog/1596190/201904/1596190-20190415191545116-409776309.png
[1596190-20190415161642577-816163897.png]: /images/20220216/1077114864b344d6915f44a683ba038f.png
[1596190-20190415161822898-22974894.png]: /images/20220216/d84dff470fad4a90b8b67ef994f3e0aa.png
[1596190-20190415162303953-5230132.png]: /images/20220216/5d55aaee600546659f39f4ea6ac5b7dc.png
[1596190-20190415162425708-1677003407.png]: /images/20220216/4acc67e5a43248329b80421a2424f23e.png
[1596190-20190415162942420-598544594.png]: /images/20220216/5b35aee475c3412a9e75e3ff43fcb8e4.png
[1596190-20190415164232903-1325507478.png]: https://img2018.cnblogs.com/blog/1596190/201904/1596190-20190415164232903-1325507478.png
[1596190-20190415164219805-1617633135.png]: /images/20220216/e7800a045ed741a1aabb41d52247e562.png
[1596190-20190415173653418-1399921061.png]: /images/20220216/ddea00b1541f40b880a1f8df09135c8b.png
[1596190-20190415174142961-669877667.png]: /images/20220216/bc3c0e2e354b4c4694927eb8bdee5934.png
[1596190-20190415190722437-644820750.png]: /images/20220216/7e6244accccc4c7cb25158cc3db59c03.png
[1596190-20190415183056817-606568752.png]: /images/20220216/e3f949f211564914b7a6a7f1998a3c63.png
[1596190-20190415183712944-1673727017.png]: /images/20220216/ecc78cfe73394732aa80a5d391d7e29c.png
[1596190-20190415184026868-92920248.png]: /images/20220216/16d3727672324bce930a855648116175.png