【Java】带你从零到一系列3（程序逻辑控制详解）

前言：
本篇文章我们继续继续Java的学习，主要是对程序逻辑控制的学习，上一篇文章我们学到了运算符和关键字等内容，但是对于我们需要进行更多的工作是远远不够的，所以今天我们来学习程序逻辑控制。

每文一图：

让我们进行开始学习！

---

一.顺序结构

首先我们来肯定是从易到难，所以我们先学习顺序结构。顺序结构比较简单，像我们之前写过的代码就是顺序结构的，按照代码书写的顺序一行一行执行。

比如:

public static void main(String[] args) {
        System.out.println("111");
        System.out.println("222");
        System.out.println("333");
        //运行结果
        //111 222 333
    }

如果调整代码的书写顺序, 则执行顺序也发生变化:

public static void main(String[] args) {
        System.out.println("111");
        System.out.println("333");
        System.out.println("222");
        //运行结果
        //111 333 222
    }

这就是顺序结构，就是这么简单。

---

二.分支结构

然后就来到我们的分支语句，我们在生活中有许多的判断，那么代码世界里面呢，在之前我们学习过一个三目操作符用来进行简单的判断，但是这对于我们的代码世界来说是远远不够的，所以我们有了分支结构。

1.if 语句

我们先来理解什么叫 if 语句，if的意思就是如果，所以他在代码世界作为一个判断的关键字进行工作。

① 基本语法形式1

if(布尔表达式){
    //条件满足时执行代码
}

这是最简单的if语句语法形式，是一句判断语句，我们来看看例子就一清二楚了：

public static void main(String[] args) {
        int a = 5;
        if(a == 5)//这里是==，因为==才是代码中的=，一个=的意思是赋值
        {
            System.out.println("a="+a);
        }
        //结果打印 a = 5
    }

这就是if语句的第一种语法，在if括号中输入的是布尔表达式，也就是括号内的表达式的值只能是true或者false。

② 基本语法形式2

if(布尔表达式){
    //条件满足时执行代码
}else{
    //条件不满足时执行代码
}

这是第二种基本语法形式，在这里多了一个else，可以帮助我们进行一种选择性的判断，比如张三是男的吗，是输出xxx，不是输出xxx。还是让代码直接演示：

public static void main(String[] args) {
        int a = 8;
        if(a == 6){
            System.out.println("a = 6");
        }
        else{
            System.out.println("a != 6");
        }

这里实际上的意思就是，a等于6吗，如果（if）a等于6的话，输出a = 6，否则（else）输出a ！= 6。这就是if … else 语句，它可以判断一种情况不同结果做出两个不同的操作。

③ 基本语法形式3

上面的if else 是判断两个分支的，那对于多分支的情况，我们还有第三种语法。

if(布尔表达式){
    //条件满足时执行代码
}else if(布尔表达式){
    //条件满足时执行代码
}else{
    //条件都不满足时执行代码
}

对于两种结果的判断，我们用到了if else，那么对于多种结果的判断，我们就可以用到上面的这一块判断内容，表示可以进行判断多分支。先上代码：

 public static void main(String[] args) {
       int day = 5;
        if(day == 1){
            System.out.println("今天周一！");
        }
        else if(day == 2){
            System.out.println("今天周二！");
        }
        else if(day == 3){
            System.out.println("今天周三！");
        }
        else if(day == 4){
            System.out.println("今天周四！");
        }
        else if(day == 5){
            System.out.println("今天周五！");
        }
        else {
            System.out.println("今天周末，出去wet！");
        }
        
    }

在上面的代码中，我们首先判断（if）day是不是1，然后我们设定的day是5，所以判断错误，然后就会跳到那么（else if）day是不是2，如果不是，就跳到那么（else if）day是不是3，如果都不是就会一直跳，直到否则（else）然后输出今天周末，出去wet！

这就是第三种基本语法。

④ 例子

为了让大家理解if语句，我们再来几个示范代码：

1.判断一个数是奇数还是偶数

public static void main(String[] args) {
        int num = 10;
        if (num % 2 == 0) {
            System.out.println("num 是偶数");
        } else {
            System.out.println("num 是奇数");
        }
    }

2.判定某一年份是否是闰年

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int year = scanner.nextInt();

        if( (year % 100 != 0 && year % 4 == 0) || year % 400 == 0) {
            System.out.println(year+"是闰年！");
        }else {
            System.out.println(year+"不是闰年！");
        }
        scanner.close();
    }

⑤ 注意事项

注意事项1：
悬垂 else 问题

对于 if / else 语句中可以不加大括号，但是也可以写语句(只能写一条语句)。 此时 else 是和最接近的 if 匹配。但是实际开发中我们不建议这么写，最好加上大括号！注意代码质量！

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int year = scanner.nextInt();

        if( (year % 100 != 0 && year % 4 == 0) || year % 400 == 0)
            System.out.println(year+"是闰年！");

        else
            System.out.println(year+"不是闰年！");
           //不加也可以执行
        scanner.close();
    }

注意事项2 ：

代码风格问题，这个的话不用讲什么，我们直接看代码吧：

// 风格1
int x = 10;
if (x == 10) {
    // 满足条件
} else {
    // 不满足条件
}
// 风格2
int x = 10;
if (x == 10)
{
    // 满足条件
}
else
{
    // 不满足条件
}

对于代码来说，这两种风格是都可以的，但是Java中更通用第二种（有时候这种小细节也会加面试的印象分！）。

虽然两种方式都是合法的, 但是 Java 中更推荐使用风格1, { 放在 if / else 同一行。

注意事项3：

分号问题，这个也可以直接来看代码：

int x = 20;
if (x == 10); {
    System.out.println("hehe");
}
// 运行结果 hehe

这里为什么x不是10也打印了？其实是我在if语句的括号后面偷偷加了一个;,这个;威力可大了，代表语句的结束，所以此处多写了一个分号, 导致分号成为了if 语句的语句体, 而 { } 中的代码已经成为了和一个 if 无关的代码块，所以最后打印的就是hehe。

---

2. switch 语句

在刚刚是不是有同学想说，那个今天周几的代码（就是下面这个代码）太长了，重复写了很多东西，有没有更简便的，当然会满足你，这里就是我们switch语句的场子了。

//刚刚的if else语句
 public static void main(String[] args) {
       int day = 5;
        if(day == 1){
            System.out.println("今天周一！");
        }
        else if(day == 2){
            System.out.println("今天周二！");
        }
        else if(day == 3){
            System.out.println("今天周三！");
        }
        else if(day == 4){
            System.out.println("今天周四！");
        }
        else if(day == 5){
            System.out.println("今天周五！");
        }
        else {
            System.out.println("今天周末，出去wet！");
        }   
    }

就上面那个，啰里啰唆，现在我们来学习switch语句来写一遍，大伙看看效果怎么样：

public static void main(String[] args) {
        int n = 5;
        switch(n){
            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;
            default:
                System.out.println("今天周末，出去wet！");
        }
    }

好吧好像也没怎么短下来，但是在代码的世界中，机器觉得他更简易的判断了，可能机器看起来会舒服很多，我们看起来条理也舒服很多。什么？你看不懂？噢我们现在开始讲他的语法结构：

基本语法：

switch(整数|枚举|字符|字符串){
 case 内容1 : {
 内容满足时执行语句;
 [break;]
 }
 case 内容2 : {
 内容满足时执行语句;
 [break;]
 }
 ...
 default:{
 内容都不满足时执行语句;
 [break;]
 } 
}

实际上对于switch语句中，就是一个可以很清晰的看出判断。在switch语句中，switch括号内就是给判断的条件，比如上面的放5就是输出5这里。然后每一个case就是一个选择，对应是什么内容就选择哪一个case执行，而break就是退出，因为你选择完了嘛，所以就可以退出了。

这里还有一个细节：

根据 switch 中值的不同，会执行对应的 case 语句，遇到 break 就会结束该 case 语句。如果 switch中的值没有匹配的 case， 就会执行 default 中的语句，我们建议一个 switch 语句最好都要带上 default。

然后就是switch的注意事项：

1.break 不要遗漏, 否则会失去 “多分支选择” 的效果。比如下面的代码，没有break就相当于没有选择完之后离开，进行执行下去一样：

  public static void main(String[] args) {
        int day = 1;
        switch(day) {
            case 1:
                System.out.println("一号");
            case 2:
                System.out.println("二号");
                break;
                //输出一号 二号
        }
    }

2.switch 中的值只能是 整数|枚举|字符|字符串，对于switch括号中的值，只能是上面几种类型，这是语法规定的。比如：

public static void main(String[] args) {
        double num = 1.0;
        switch(num) {//报错 double类型不兼容
            case 1.0:
                System.out.println("hehe");
                break;
            case 2.0:
                System.out.println("haha");
                break;
        }
    }

3.switch 不能表达复杂的条件，比如，我要判断是否是大于50小于100的数字，用if可以很容易找到，但是switch就不行，它判断的都是简单的一些条件。

public static void main(String[] args) {
        // 例如: 如果 num 的值在 10 到 20 之间, 就打印 hehe
        // 这样的代码使用 if 很容易表达, 但是使用 switch 就无法表示. 
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        if (num > 10 && num < 20) {
            System.out.println("today is friday");
        }
    }

4.switch 虽然支持嵌套, 但是很丑

直接看一个代码吧：

public static void main(String[] args) {
        int x = 1;
        int y = 1;
        switch(x) {
            case 1:
                switch(y) {
                    case 1:
                        System.out.println("hehe");
                        break;
                }
                break;
            case 2:
                System.out.println("haha");
                break;
        }
    }

这样子又switch又case有switch的，看起来会很难受，尽量不要写一些看起来难受的代码，不然下一个难受的就是你了。毕竟这是一个看脸的时代。

这就是分支结构，判断条件。

---

三.循环结构

对于条件我们可以判断，这就可以增加很多我们需要的结构了，解决了选择的问题，那么重复一个动作的呢，如果我要输出1-100该不会要一句一句的答吧？于是我们有了循环结构。

接下来让我们见识一下：

---

1.while 循环

基本语法格式:

while(循环条件){ 
循环语句; 
} 

对于一种重复的工作，我们可以用循环来做，那么循环怎么停止，总不能无限循环，所以我们有循环条件，循环条件为 true，则执行循环语句；否则结束循环。

我们来看例子吧：

//打印1-100的值
public static void main(String[] args) {
        int num = 1;
        while (num <= 100) {
            System.out.println(num);
            num++;
        }
    }

这里就是打印1-100的代码，如果没有循环，我们可能要打100条System，但是现在，我们设定一个数为1，然后条件就是这个数小于100，小于就打印一次，然后这个数++（也就是+1），这样循环起来，第二次就打印2，然后再++，再进入…

当然也有复杂一点的例子，像阶乘这种，while也可以做。

//计算1！+2！+3！+4！+5！的值
public static void main(String[] args) {
        int num = 1;
        int sum = 0;
            // 外层循环负责求阶乘的和
        while (num <= 5) {
            int factorResult = 1;
            int tmp = 1;
            // 里层循环负责完成求阶乘的细节.
            while (tmp <= num) {
                factorResult *= tmp;
                tmp++;
            }
            sum += factorResult;
            num++;
        }
        System.out.println("sum = " + sum);
    }

这里我们发现, 当一个代码中带有多重循环的时候， 代码的复杂程度就大大提高了. 而比较复杂的代码就更容易出错，后面我们会采用更简单的办法来解决这个问题。

对于while语句，我们用以下注意事项：

1. 和 if 类似，while 下面的语句可以不写 { } ，但是不写的时候只能支持一条语句，建议还是加上 { }。
2. 和 if 类似, while 后面的 { 建议和 while 写在同一行。
3. 和 if 类似, while 后面不要多写 分号, 否则可能导致循环不能正确执行。

---

2.break与continue

对于循环语句，我们很多时候需要跳出循环，不能一直循环，所以我们有两个跳出循环的语句。

① break语句

首先是break语句，break 的功能是让循环提前结束。

break语句就是讲整个循环直接结束，比如下面这个代码：

//找到 100 - 200 中第一个 3 的倍数
public static void main(String[] args) {
        int num = 100;
        while (num <= 200) {
            if (num % 3 == 0) {
                System.out.println("找到了 3 的倍数, 为:" + num);
                break;
            }
            num++;
        }
    }

// 执行结果
//找到了 3 的倍数, 为:102 

这个代码就是，当我们第一次找到三的时候，就直接停止了，所以就是直接跳出整个循环，不再去循环了。

执行到 break 就会让循环结束。

②continue语句

continue 的功能是跳过这次循环, 立即进入下次循环。

//找到 100 - 200 中所有 3的倍数
public static void main(String[] args) {
        int num = 100;
        while (num <= 200) {
            if (num % 3 != 0) {
                num++; // 这里的 ++ 不要忘记! 否则会死循环. 
                continue;
            }
            System.out.println("找到了 3 的倍数, 为:" + num);
            num++;
        }
    }

这里的代码就执行到 continue 语句的时候, 就会立刻进入下次循环(判定循环条件), 从而不会执行到下方的打印语句。

continue就是跳过本次循环，也就是本次循环后面的语句不执行。

---

3.for语句

对于for循环，其实也是和while循环基本上一样的作用，但是我愿称之为while循环的plus版本，使用起来更有感觉一点，可能初学者一开始看不懂，但是熟悉之后会觉得for循环能做的事情很多很多。而且相比于 while 循环，for 循环将这三个部分合并在一起，写代码时不容易遗漏。

基本语法：

for(表达式1;表达式2;表达式3){ 
循环体; 
}

各个表达式的作用：
表达式1: 用于初始化循环变量。
表达式2: 循环条件。
表达式3: 更新循环变量。

我们先看一份代码再展开细说：

//将1到100加起来
public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        System.out.println("sum = " + sum);
        // 执行结果 5050
    }

在这里，我们就是将1-100的整数加起来，那么for循环是怎么运行的呢，我们来看一下这个图：

其实对于for循环来说，首先是执行表达式1，给循环变量一个初值，然后到表达式2，判断循环条件，如果条件满足就到3处循环体循环一次，然后再到4这里改变一下循环变量，让循环有朝一日能结束。

所以这里将1-100的整数加起来，就是先给i赋初值是1，然后看i小不小于100，小于就加到sum里面，然后改变循环变量就是i++，下一次进入循环就是i==2的时候了。

再来一个例子：

//计算 1! + 2! + 3! + 4! + 5!
public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            int tmp = 1;
            for (int j = 1; j <= i; j++) {
                tmp *= j;
            }
            sum += tmp;
        }
        System.out.println("sum = " + sum);
    }

像这里，就是两个for循环表示两个不同的位置，第一个for循环在循环需要阶乘到的数，第二个for循环就是计算这个数的阶乘。

注意事项 (和while循环类似)

1. 和 if 类似, for 下面的语句可以不写 { } ，但是不写的时候只能支持一条语句. 建议还是加上 { }。
2. 和 if 类似, for 后面的 { 建议和 while 写在同一行。
3. 和 if 类似, for 后面不要多写 分号，否则可能导致循环不能正确执行。

4.do…while语句

上面我们学习了while语句，那么这个do…while语句又有啥子不同呢，我们知道，do是做的意思吧，那么这里的意思其实就是，先do再while，也就是先do一次，然后再去进入循环。

基本语法：

do{ 
循环语句; 
}while(循环条件); 

也就是先执行循环语句, 再判定循环条件。

例子：

public static void main(String[] args) {
        int a = 5;
    
        do{
            a++;
        }while (a<=10);
        System.out.println(a);
        
    }

注意事项：

1. do while 循环最后的分号不要忘记。
2. 一般 do while 很少用到, 更推荐使用 for 和 while。

---

四.输入输出

我们在之前一直写代码都用到的输入输出，这里终于说到了，其实就是两个简单的语法，我们一起来看看：

1.输出到控制台

对于输出，有下面三种形式：

 public static void main(String[] args) {
        int a = 5;

        System.out.println("hello "+a); // 输出一个字符串, 带换行
        System.out.print("hello "+a); // 输出一个字符串, 不带换行
        System.out.printf("hello %d",a); // 格式化输出
    }

对于输出，前面的System.out是肯定需要的，然后就是输出的不同了，首先第一个是println，就是输出并自动换行，然后第二个就是print，对比第一个是不是少了ln，所以就是输出不换行，第三个printf的语法是与C语言语言的，输出如果想换行就在" "内写/n。

而输出变量，前两种只需要写+变量名就可以啦，然后第三个可以选择输出类型，然后要在" "内写上，再在后面用逗号隔开，然后加上变量名。

println 输出的内容自带 \n, print 不带 \n。
printf 的格式化输出方式和 C 语言的 printf 是基本一致的。

我们来写一些代码：

public static void main(String[] args) {
        System.out.println("hello world");
        int x = 10;
        System.out.printf("x = %d\n", x)
    }

而对于我们上面说的printf需要带上的变量类型，或者说是格式化字符串，我们有以下的一些类型：

转换符	类型	举例	例子
d	十进制整数	("%d", 100)	100
x	十六进制整数	("%x", 100)	64
o	八进制整数	("%o", 100)	144
f	定点浮点数	("%f", 100f)	100.000000
e	指数浮点数	("%e", 100f)	1.000000e+02
g	通用浮点数	("%g", 100f)	100.000
a	十六进制浮点数	("%a", 100)	0x1.9p6
s	字符串	("%s", 100)	100
c	字符	("%c", ‘1’)	1
b	布尔值	("%b", 100)	true
h	散列码	("%h", 100)	64
%	百分号	("%.2f%%", 2/7f)	0.29%

ps：这个表格没必要记住, 用到的时候根据需要查一下就行了。

---

2.从键盘输入

对于输入，我们有特别的包：使用 Scanner 读取字符串/整数/浮点数。

我们先来一个例子：

import java.util.Scanner; 
public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的姓名：");
        String name = sc.nextLine();
        System.out.println("请输入你的年龄：");
        int age = sc.nextInt();
        System.out.println("请输入你的工资：");
        float salary = sc.nextFloat();
        System.out.println("你的信息如下：");
        System.out.println("姓名: "+name+"\n"+"年龄："+age+"\n"+"工资："+salary);
        sc.close(); // 注意, 要记得调用关闭方法
    }

首先我们在创建输入变量之前，先有一个Scanner sc = new Scanner(System.in);，那么这个是什么意思呢，其实它是一个包，里面已经写好了一个能读取你键盘的代码，这个包是java.util.Scanner ，是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。

意思是：通过new Scanner创建一个Scanner，控制台会一直等待输入，直到敲回车键结束，把所输入的内容传给Scanner，作为扫描对象。

所以上面我们首先就是导入包，然后是new一个Scanner，之后想创建什么变量就按照 变量类型+变量名 = new的名字.对应变量类型，比如：

 public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        //创建一个int类型的变量a进行键盘读取
        String ch = scanner.nextLine();
        //创建一个字符串类型变量ch读取键盘输入
    }

但是因为读取问题，有时候我们想连续输入的时候会读取错误，所以我们就还有一种选择，比如循环读取int类型的数字的时候：

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double sum = 0.0;
        int num = 0;
        while (sc.hasNextDouble()) {
            //hasNext就是读完我还有要读的
            double tmp = sc.nextDouble();
            sum += tmp;
            num++;
        }
        System.out.println("sum = " + sum);
        System.out.println("avg = " + sum / num);
        sc.close();
    }
    //同时当我们循环读取想结束，可以安ctrl+z结束

---

五.猜数字小游戏

好啦，那么学完以上内容，我们就可以做一个猜数字小游戏了。

游戏规则:

系统自动生成一个随机整数(1-100)，然后由用户输入一个猜测的数字。如果输入的数字比该随机数小，提示 “猜小了”，如果输入的数字比该随机数大, 提示 “猜大了”，如果输入的数字和随机数相等, 则提示 “猜对了” 。

首先我们要生成随机数，这里我们用一个随机种子为系统时间就可以啦，也就是Random random = new Random();。然后就猜嘛，然后我们可以有while语句循环，猜不对不许出来，然后用if语句进行猜的数字和随机数比较。

话不多说，我们来看看代码：

public static void main(String[] args) {
            Random random = new Random(); // 默认随机种子是系统时间
            Scanner sc = new Scanner(System.in);
            int toGuess = random.nextInt(100);
            // System.out.println("toGuess: " + toGuess);
            // 作弊码 
            while (true) {
                System.out.println("请输入要输入的数字: (1-100)");
                int num = sc.nextInt();
                if (num < toGuess) {
                    System.out.println("猜大了");
                } else if (num > toGuess) {
                    System.out.println("猜小了");
                } else {
                    System.out.println("猜对了");
                    break;
                }
            }
            sc.close();
        }

---

这就是本篇程序逻辑控制详解的全部内容啦，如果觉得还不错或者感觉对你有帮助，不妨点赞关注一键三连，一起学习，共同努力！也可以期待这个系列接下来的博客噢。

链接：都在这里！ Java SE 带你从零到一系列

还有一件事：