逻辑控制

前言：

本文 将学习到 选择语句 和 循环语句，最后 还有输入输出 语句。
 

if 语句

 
如果 满足 if 中的条件 那么 执行 if 语句中的内容， 如果不 满足 if 满足 else if 语句 中的条件 ，那么我们 执行 else if 中 的内容 ， 最后 if 和 else if 都不满足，就会执行 else 语句 中 的 内容。
 
语法：

if(布尔表达式) {

}else if(布尔表达式){

}else {
		
}
1
2
3
4
5
6
7

 
注意 ： 这里我们 if 语句 中的 条件， 要是 布尔表达式，而不像 c 中的 非零 表示 真 ，0表示假、
 
而是 布尔表达式结果为true，执行if中的语句，否则不执行。
 
演示：

下面 就 来 做 几道 练习 题 ，熟悉 一下我们的 if 语句
 

题目一 ： 判断一个数字是奇数还是偶数

    //    判断一个数字是奇数还是偶数
    public static void main(String[] args) {
        int n = 10;
        if(n % 2 == 0){
            System.out.println(n + " 是偶数 ");
        }else{
            System.out.println(n + " 不是偶数 ");
        }
    }
1
2
3
4
5
6
7
8
9

 
题目二 ： 判断一个数字是正数，负数，还是零
 
这我们 假设 0 既不是 正数 也不是 负数 （将 if else if 和 else 都 使用上）

 //    判断一个数字是正数，负数，还是零
    public static void main(String[] args) {
        // 假设 0 既不是正数 也 不是 负数 
        	//int n = -20
            //int n = 20;
        	int n = 0;
            if(n > 0){
                System.out.println(n + " 是正数");
            }else if(n < 0){
                System.out.println(n + " 不是正数");
            }else {
                System.out.println("n 为 0 ");
            }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意： 这我们 还没 讲到 输入输出 语句 这里 先 让 n 赋值 完成我们的测试， 下面会 讲解。
 

题目三 ：判断一个年份是否为闰年
 
这里我们 只需要知道 闰年 的 判断 规则即可，如： 能被 4整除 且不能被 100 整除 或者 能被400整除 ，满足 这 两个条件的 其一就为 闰年。
 
知道了 条件 不就 非常简单了 吗 直接 来 完成我们的 代码。

    // 判断一个年份是否为闰年
    public static void main(String[] args) {
        int n = 200;
        if(n % 4 == 0 && n % 100 != 0){
            System.out.println(n + "为闰年");
        }else if(n % 400 == 0){
            System.out.println(n + "为闰年");
        }else {
            System.out.println(n + "不是闰年");
        }
    }

这 我们 还可 直接 使用|| 将 两个条件 写在 一个 if 语句 当中 
    
        if(n % 4 == 0 && n % 100 != 0 || n % 400 == 0){
            System.out.println(n + "为闰年");
        }else {
            System.out.println(n + "不是闰年");
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

 
完成了 上面的 三个 题目 ，我们是不是 很好的 了解 了 if 语句 。
 

另外 ： if 能够 单独使用 ，而 else 和 else if 是 不能 单独使用的。
 

 

这里我们 的 编译器 就 直接画 红线报错了，
 

 
注意： 有些 刚学完 c 的 同学 学 Java 会出先 下面的问题 我们来看看 是如何 出错的

public static void main(String[] args) {
    int n = 10;
    if(n != 10);    
    {
        System.out.println("haha");
    }
}
1
2
3
4
5
6
7

 

这里我们 if 语句 后面 多 加了 一个 分号 ; 这里我们 的 haha 会不会 被打印出来 呢？

 

通过 编译 可以发现 ，·haha 还是 打印 出来 了 ， 这里就与我们的 分号 ; 有关 ， 这里 if 语句 加了 分号， 会 默认执行 完 这条 语句，然后 就会 直接 进入 大括号 {} 将 haha 打印出来 , 所以这里 还是 需要注意的。 （此处多写了一个 分号, 导致分号成为了 if 语句的语句体, 而 { } 中的代码已经成为了和一个 if 无关的代码块）
 

这里我们 还要注意 一下 悬垂 else 问题
 

   public static void main(String[] args) {
        int x = 10;
        int y = 10;
        if (x != 10)
            if (y == 10)
                System.out.println("aaa");
        else
            System.out.println("bbb");

    }
1
2
3
4
5
6
7
8
9
10

这里 大家 可以 思考 一下 ，这里我们 的输出结果 是 啥？
 
通过 编译器 编译 ，可以发现 啥都没有输入 ，这里是为啥 呢 ？
 

其实 这里我们 的else 语句 会 与 最近的 if 对齐，而不是 与 if(x != 10) 匹配，这里 推荐 加上大括号 能更方便我们的 观察 代码。 （如果没加 大括号，if 语句 后只能 跟 一条语句）。
 
改正 ：

    public static void main(String[] args) {
        int x = 10;
        int y = 10;
      if(x != 0){
          if(y == 10){
              System.out.println("aaa");
          }else {
              System.out.println("bbb");
          }
      }

    }
1
2
3
4
5
6
7
8
9
10
11
12

 
这样 是不是 一眼 就看出来了。

 

if 语句 就到这里 ，也不难， 只需要 看一看即可。
 

switch 语句

语法：

 public static void main(String[] args) {
        int x = 2;
        switch (x) {
            case 1:
                System.out.println(1);
                break;
            case 2:
                System.out.println(2);
                break;
            case 3:
                System.out.println(3);
                break;
            default:
                System.out.println(4);
                break;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

 
执行流程：

1. 先计算表达式的值
    
2. 和case依次比较 （如 x = 2 ， 就会执行 case 2 ：处 的语句），一旦有响应的匹配就执行该项下的语句，直到遇到break时结束
    
3. 当表达式的值没有与所列项匹配时，执行default

 
这里我们 就来 根据 day 的值输出星期 来 熟悉 一下 switch 语句

    public static void main(String[] args) {
        int day = 1;
        switch (day) {
            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;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

 
注意： switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。 （long 就不能 成为 switch 中 的 条件，） ， 这里 还可以使用 枚举 类型。
 

另外 ： switch 不能表达复杂的条件
 

// 例如: 如果 num 的值在 10 到 20 之间, 就打印 hehe
// 这样的代码使用 if 很容易表达, 但是使用 switch 就无法表示.
if (num > 10 && num < 20) {
	System.out.println("hehe");
}

   public static void main(String[] args) {
        int num = 15;
        switch (num > 10 && num < 20){
            case 15:
                System.out.println("hhh");
                break;
        }
        
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

 

 

总结：switch 也 不 难 就 是通过 你 给 的 条件 在 case 中 寻找 如果 找到了 就会执行 当前 case 中的 语句，如果 没有 break， 就会 执行 下面的 case 内容，直到 switch 运行 完 或 遇到 break, 另外 switch 条件 不能 是 long 类型，还有 不能是 表达 复杂的条件。

 

switch 了解 完 ，让我们进入 循环 结构 。

 

循环结构

 

while 循环

语法 ：

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

 
循环条件为 true, 则执行循环语句; 否则结束循环.

这里 while 循环 也不难，这里直接 来 几道题 ，就能够 很好 学会。
 

题目一： 打印 1 - 10 的数字

  //    打印 1 - 10 的数字
    public static void main(String[] args) {
        int i  = 1;
        while(i <=10){
            System.out.printf(i + " ");
            i++;
        }
    }
1
2
3
4
5
6
7
8

 

题目 二 ： 计算 1 - 100 的和

//    计算 1 - 100 的和
    public static void main(String[] args) {
        int i = 1;
        while(i <= 100){
            System.out.printf(i + " ");
            i++;
        }
    }
1
2
3
4
5
6
7
8

 

题目 三 ： 计算 5 的阶乘

    //    计算 5 的阶乘
    public static void main(String[] args) {
        int i = 1;
        int n = 1;
        while(n <= 5){
            i *=n;
            n++;
        }
        System.out.println(i);
    }

1
2
3
4
5
6
7
8
9
10
11

 
题目四： 计算 1! + 2! + 3! + 4! + 5!
 
这里 我们 通过 while 计算 处 了 5 的 阶乘，那么 这里 计算 1 的 阶乘 加到5 的阶乘 不就是 多 一层 while 循环吗 ，这里我们继续

    //    计算 5 的阶乘
    public static void main(String[] args) {
        int i = 0;
        int n = 1;
        while (n <= 5) {
            int ret = 1;
            int tmp = 1;
            while (tmp <= n) {
                //计算 阶乘
                ret *= tmp;
                tmp++;
            }
            //将 每次的阶乘 加起来
            i += ret;
            n++;
        }
        System.out.println(i);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

 
注意事项
 

1. 和 if 类似, while 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }

2. 和 if 类似, while 后面的 { 建议和 while 写在同一行.

3. 和 if 类似, while 后面不要多写 分号, 否则可能导致循环不能正确执行.

int num = 1;
while (num <= 10); {
  System.out.println(num);
  num++;
}
// 执行结果
[无任何输出, 程序死循环]
1
2
3
4
5
6
7

此时 ; 为 while 的语句体(这是一个空语句), 实际的 { } 部分和循环无关. 此时循环条件 num <= 10 恒成立, 导致代码
死循环了.
 

学习完 while 那么我们 来学习一 下 for 循环 其实 也差不多。
 

for 循环

 
语法：

for(表达式①;布尔表达式②;表达式③){
	表达式④;
}
1
2
3

1.表达式1: 用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次
 

2.表达式2: 循环条件，满则循环继续，否则循环结束
 

3.表达式3: 循环变量更新方式

 

执行过程：
 
这里我们 的 表达式 1 只会 执行 一次，
 
①②③④—>②③④—>②③④—>②③④—>②③④—>②③④—>…—>②为false，循环结束。

 

下 面 我们 将 while 循环 做过 的 题目 改为 for 循环。

 

题目 一 ： 打印 1 - 10 的数字

    public static void main(String[] args) {
        for(int i = 1;i<=10;i++){
            System.out.printf(i + " ");
        }
    }
1
2
3
4
5

 

题目 二 ： 计算 1 - 100 的和

//    计算 1 - 100 的和
    public static void main(String[] args) {
        for (int i = 1; i <= 100; i++) {
            System.out.printf(i + " ");
        }
    }
1
2
3
4
5
6

 

题目 三 ： 计算 5 的阶乘

  //    计算 5 的阶乘
    public static void main(String[] args) {
        int sum = 1;
        for (int i = 1; i <= 5; i++) {
            sum *= i;
        }
        System.out.println(sum);
    }
1
2
3
4
5
6
7
8

 
题目 四 ： 计算 1! + 2! + 3! + 4! + 5!

    //    计算 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);
    }
1
2
3
4
5
6
7
8
9
10
11
12

 

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

1. 和 if 类似, for 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }

2. 和 if 类似, for 后面的 { 建议和 while 写在同一行.

3. 和 if 类似, for 后面不要多写 分号, 否则可能导致循环不能正确执行.

4. 和while循环一样，结束单趟循环用continue，结束整个循环用break

 

其实 for 循环 和 while 循环 是 非常 类似的 这里我们 ，可以 将 for循环 改为 while 循环 类似 的形式 ，
 

  public static void main(String[] args) {
        int i = 1;
        for (; i <= 10; ) {
            System.out.printf(i + " ");
            i++;
        }
      
        int j = 1;
        while (j <= 10) {
            System.out.printf(j + " ");
            j++;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

这 样 看 我们的 for 循环 是不是 与 while 循环 一样。
 

注意 ： 这里 如果 for 循环 的 表达式 2 没 有 写 将 会 陷入 死循环。

  public static void main(String[] args) {
        for (int i = 0; ; i++) {
            System.out.printf(i + " ");
        }
    }
1
2
3
4
5

 

 

这里 我们 来 看 一道题目 。
 
题目 ： 在 1 - 10 内 找到 最 小 大于 5 的 数。
 
这里我们 很快 能 想到，这不就 6吗 ， 那么 我们这里 通过 循环 和 if 语句 来完成 这道练习。

    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i > 5) {
                System.out.println(i);
            }
        }
    }

1
2
3
4
5
6
7
8

 
我们 这样 些 有没有 问题呢 ？
 
明显 是 有 的 这里 会 打印出 6 7 8 9 10，很明显 不满足 题目的要求 。
 
这里我们 就需要 在 i = 6 的 时候 停止 循环 ，这里我们 就 来 学习 一下我们的 break 。
 

break

 
break 的功能是让循环提前结束.

了解了 break 的 功能 那么我们 就来 改善 上面的 代码
 

   public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i > 5) {
                System.out.println(i);
                break;
            }
        }
1
2
3
4
5
6
7

 
 

是不是 这里我们就 成功的 将 6 打印出来 ，并没 将 其他 大于5 的 数字 给 打印 出来 。

那么 下面 还有 一道题 ，一起完成 一下把。

 

题目 ： 找到 100 - 200 中第一个 3 的倍数

    //    找到 100 - 200 中第一个 3 的倍数
    public static void main(String[] args) {
        for (int i = 100; i <= 200; i++) {
            if (i % 3 == 0) {
                System.out.println(i);
                break;
            }
        }
    }
1
2
3
4
5
6
7
8
9

 
除了 break 让 循环 提前 结束 还 有 continue 跳过 此次 循环， 执行 下次 循环， 下面 来 了解一下。
 

continue

 
continue 的功能是跳过这次循环, 立即进入下次循环.
 
这里我们 还是 通过 题目 来 了解一下
 
题目： 找到 100 - 200 中所有 3 的倍数
 
1.这里我们 可以 直接 来求 不使用 continue

   //    找到 100 - 200 中所有 3 的倍数
    public static void main(String[] args) {
        for(int i = 100;i<=200;i++){
            if(i % 3 == 0){
                System.out.printf(i + " ");
            }
        }
    }
1
2
3
4
5
6
7
8

 
2.那么这里 必须 要 将 continue 带上 要怎么 做呢？

    public static void main(String[] args) {
        for (int i = 100; i <= 200; i++) {
            if (i % 3 != 0) {
                continue;
            }
            System.out.print(i + " ");
        }
    }
1
2
3
4
5
6
7
8

 

这里我们 只需要 将条件 改 i % 3 != 0, 然后 在 if 语句 中 加 continue ，然后 将 打印 放在 下面 即可， 这里 continue 是不是 跳过 本次 循环 ，进入 下一次 循环，这样 就不会 执行 下面的 语句 ，那么我们 将 不是 3 的倍数 的 跳过 ，那么 打印 的不就是 3 的倍数。
 

除 了 while 循环 和 for 循环 其实 还有 一种 do while()循环 但是 ： 一般 do while 很少用到, 更推荐使用 for 和 while.
 

do while()循环

 
语法：

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

 

先执行循环语句, 再判定循环条件，循环条件成立则继续执行，否则循环结束。

（这里 do while()； 循环 不管 条件 是否 满足 都会 执行 一次 ）.
 
这里 我们 就 来 完成 一道 题目 即可
 
题目 ： 打印 1 - 10

   //    打印 1 - 10
    public static void main(String[] args) {
        int num = 1;
        do {
            System.out.printf(num + " ");
            num++;
        } while (num <= 10);
    }
1
2
3
4
5
6
7
8

 
【注意事项】

1. do while 循环最后的分号不要忘记

2. 一般 do while 很少用到, 更推荐使用 for 和 while.
    

其实 这里我们的 逻辑 控制 是 非常简单 的 稍微 学习 一下 就能 理解， 这 里 也没 啥 好说 的，下面我们 来 学习 一下 java中 的输入 输出。

 

输入输出

 

1.输入到 控制台

 
这里就 是 我们的 打印
 
在 java 中 有 3 种 打印 的 方式
 

System.out.println(msg);       // 输出一个字符串, 带换行

System.out.print(msg);        // 输出一个字符串, 不带换行

System.out.printf(format, msg); // 格式化输出
1
2
3
4
5

 
println 输出的内容自带 \n, print 不带 \n
 
printf 的格式化输出方式和 C 语言的 printf 是基本一致的.
 
java 中 最常用 的 其实 就算 println 这种 ，但我们 也可 像 c 中 使用 printf 来表示，这里我们 就需要格式 化字符串。

 

格式化字符串

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

2.从键盘输入

 
这里我们 可以通过 java 中 Scanner 类 来完成 我们 的 从键盘 输入（java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。）
 

import java.util.Scanner;

public class Test {


    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(); // 注意, 要记得调用关闭方法
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

 

 
这里 就 完成 了我们的 输入，

 

注意：

这里 输入 字符串 我们 需要 nextLine() 输入 数字 需要 nextInt() 输入 浮点型 就需要 nextFloat ()， 输入 双精度 浮点型 需要 nextDouble()。

 

另外 ： 如果 我们 先 输入 数字 在输入 字符串 这里 就会出现 问题。

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        String str = sc.nextLine();
        System.out.println(x);
        System.out.println(str);
    }
1
2
3
4
5
6
7

 

注意 ： 在同时 输入 字符串 和 数字 时 字符串 应 先 输入字符串 ，在输入 其他
 
这里我们 输入 了20 就会 直接 退出程序 ，这里 字符串 就会 输入 不了 ， 所以 这里推荐 先 输入 字符串 ，在 输入 数字。
 

 
另外 这里 我们 还需要 注意 一下 next() 与 nextLine() 区别
 
next():

• 1、一定要读取到有效字符后才可以结束输入。

• 2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。

• 3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。

• next() 不能得到带有空格的字符串。

nextLine()：

• 1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
• 2、可以获得空白。

 

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    String str = sc.next();
    System.out.println(str);
}

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String str = sc.nextLine();
        System.out.println(str);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

 

java中 同样 可以 输入 多个数字

通过 hasNextInt（） 来完成

 public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int sum = 0;
        int num = 0;
        while (sc.hasNextInt()) {
            int tmp = sc.nextInt();
            sum += tmp;
            num++;
        }
        System.out.println("sum = " + sum);
        System.out.println("avg = " + sum / num);
        sc.close();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

注意事项: 当循环输入多个数据的时候, 使用 ctrl + z 来结束输入 (Windows 上使用 ctrl + z, Linux / Mac 上使用 ctrl + d).
 

最后 我们 来 完成 一个 猜数字 游戏 结束 本文 学习。
 
猜数字游戏：

    public static void main(String[] args) {
        Random random = new Random();
        Scanner sc = new Scanner(System.in);
        int ret = 0;
        while (true) {
            int n = random.nextInt(100) + 1;
            while (true) {
                System.out.println("输入猜测的 数字");
                ret = sc.nextInt();
                if (ret < n) {
                    System.out.println("猜小了");
                } else if (ret > n) {
                    System.out.println("猜大了");
                } else {
                    System.out.println("恭喜你 猜对了");
                    break;
                }
            }
            System.out.println("是否继续 游戏 ， YES （1）  / NO （0） ");
            ret = sc.nextInt();
            if (ret == 0) {
                break;
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25