第一章：概述

  • 不论哪种编程语言，都会提供三种基本的流程控制结构：顺序结构、分支结构和循环结构。其中，顺序结构就是程序从上到下逐行的执行，中间没有任何判断和跳转；分支结构用于实现根据条件来选择性的执行某段代码；循环结构用于实现根据循环条件重复执行某段代码。

第二章：顺序结构

2.1 概述

  • 任何编程语言中最常见的程序结构就是 顺序结构 。顺序结构就是程序从上向下逐行的执行，中间没有任何判断和跳转。如果 main 方法的多行代码之间没有任何任何分支结构和循环结构，则程序总是从上向下依次执行，排在前面的代码先执行，排在后面的代码后执行。
  1. public static void main(String[] args){
  2.     //顺序执行，根据编写的顺序，从上到下运行
  3.     System.out.println(1);
  4.     System.out.println(2);
  5.     System.out.println(3);
  6. }

2.2 键盘输入

  • 步骤：
    • ① 准备 Scanner 类型的变量。
    • ② 提示输入 xxx 。
    • ③ 接收输入内容。
  • 示例： 
  1. import java.util.Scanner;
  3. /**
  4.  * 键盘输入
  5.  *
  6.  * @author 许大仙
  7.  * @version 1.0
  8.  * @since 2021-08-07 06:49
  9.  */
  10. public class ScannerDemo {
  11.     public static void main(String[] args) {
  12.         Scanner input = new Scanner(System.in);
  13.         System.out.print("请输入姓名：");
  14.         String name = input.next();
  15.         System.out.println("name = " + name);
  17.         System.out.println("------------------------");
  19.         System.out.print("请输入年龄：");
  20.         int age = input.nextInt();
  21.         System.out.println("age = " + age);
  23.         System.out.println("------------------------");
  25.         System.out.print("请输入体重：");
  26.         double weight = input.nextDouble();
  27.         System.out.println("weight = " + weight);
  29.         System.out.println("------------------------");
  31.         System.out.print("请输入性别（男或女）：");
  32.         String gender = input.next();
  33.         System.out.println("gender = " + gender);
  35.         System.out.println("------------------------");
  37.         System.out.print("是否已婚（true或false）：");
  38.         boolean isMarry = input.nextBoolean();
  39.         System.out.println("isMarry = " + isMarry);
  41.     }
  42. }

next() 和 nextLine() 的区别：

  • next() ：遇到空格等空白符，就认为输入结束。
  • nextLine() ：遇到回车换行，则认为输入结束。

第三章：分支结构

3.1 概述

  • 分支结构：根据条件，选择性地执行某段代码。

3.2 If语句

  • 语法：
  1. if(条件表达式){
  2.     // 执行语句
  3. }
  • 流程图：

if.jpg

  • 示例：
  1. import java.util.Scanner;
  3. /**
  4.  * @author 许大仙
  5.  * @version 1.0
  6.  * @since 2021-08-07 07:14
  7.  */
  8. public class IfDemo {
  9.     public static void main(String[] args) {
  10.         Scanner input = new Scanner(System.in);
  11.         System.out.print("请输入i：");
  12.         int i = input.nextInt();
  13.         System.out.print("请输入j：");
  14.         int j = input.nextInt();
  16.         if (i > j) {
  17.             System.out.println(i + "比" + j + "大");
  18.         }
  20.         System.out.println("结束");
  21.     }
  22. }

3.3 if…else语句

  • 语法：
  1. if(条件表达式){
  2.     // 执行语句1
  3. }else{
  4.     // 执行语句2
  5. }
  • 流程图：

ifelse.jpg

  • 示例：
  1. import java.util.Scanner;
  3. /**
  4.  * @author 许大仙
  5.  * @version 1.0
  6.  * @since 2021-08-07 07:23
  7.  */
  8. public class IfElseDemo2 {
  9.     public static void main(String[] args) {
  10.         Scanner input = new Scanner(System.in);
  11.         System.out.print("请输入i：");
  12.         int i = input.nextInt();
  13.         System.out.print("请输入j：");
  14.         int j = input.nextInt();
  16.         if (i > j) {
  17.             System.out.println(i + "比" + j + "大");
  18.         } else {
  19.             System.out.println(i + "小于或等于" + j);
  20.         }
  22.         System.out.println("结束");
  24.     }
  25. }

3.4 if…else if…else语句

  • 语法：
  1. if(条件表达式1){
  2.     // 执行语句1
  3. }else if(条件表达式2){
  4.     // 执行语句2
  5. }else{
  6.     // 执行语句3
  7. }
  • 流程图：

ifelseif.jpg

  • 示例：
  1. import java.util.Scanner;
  3. /**
  4.  * @author 许大仙
  5.  * @version 1.0
  6.  * @since 2021-08-07 07:29
  7.  */
  8. public class IfElseIfDemo {
  9.     public static void main(String[] args) {
  10.         Scanner input = new Scanner(System.in);
  11.         System.out.print("请输入i：");
  12.         int i = input.nextInt();
  13.         System.out.print("请输入j：");
  14.         int j = input.nextInt();
  16.         if (i > j) {
  17.             System.out.println(i + "比" + j + "大");
  18.         } else if (i < j) {
  19.             System.out.println(i + "比" + j + "小");
  20.         } else {
  21.             System.out.println(i + "和" + j + "相等");
  22.         }
  24.         System.out.println("结束");
  25.     }
  26. }

3.5 switch…case语句

  • 语法：
  1. switch(表达式){
  2.     case 值1:
  3.         // 执行语句
  4.         break;
  5.     case 值2:
  6.         // 执行语句
  7.         break; 
  8.     default:
  9.         // 执行语句
  10.         break;
  11. }

注意：

  • 表达式的可选值类型：byte 、short 、int 、char 、枚举（JDK1.5）、String（JDK1.7）。
  • case 子句：
    • case 子句中指定的值必须是常量，不能是变量或不确定的表达式的值。
    • 同一个 switch 语句中所有 case 子句中的常量值必须互不相同。
  • default 子句：
    • default 子句是可选的。
    • default 子句的位置是灵活的。
  • 流程图：

switch.jpg

  • 示例：
  1. import java.util.Scanner;
  3. /**
  4.  * @author 许大仙
  5.  * @version 1.0
  6.  * @since 2021-08-07 07:47
  7.  */
  8. public class SwitchDemo {
  9.     public static void main(String[] args) {
  10.         Scanner input = new Scanner(System.in);
  11.         System.out.print("请输入你喜欢的季节（spring、summer、autumn、winter）：");
  12.         String season = input.nextLine();
  13.         switch (season) {
  14.             case "spring":
  15.                 System.out.println("我喜欢春天");
  16.                 break;
  17.             case "summer":
  18.                 System.out.println("我喜欢夏天");
  19.                 break;
  20.             case "autumn":
  21.                 System.out.println("我喜欢秋天");
  22.                 break;
  23.             case "winter":
  24.                 System.out.println("我喜欢冬天");
  25.                 break;
  26.             default:
  27.                 System.out.println("我一个季节都不喜欢");
  28.                 break;
  29.         }
  30.     }
  31. }

3.6 练习

3.6.1 练习1

  • 岳小鹏参加 Java 考试，他和父亲岳不群达成承诺： | 成绩 | 奖励 | | —- | —- | | 100 | BMW | | (80,99] | iphone xs max | | [60,80] | ipad | | 其它 | 无 |

  • 请从键盘输入岳小鹏的期末成绩，并加以判断。

  • 示例： 

  1. import java.util.Scanner;
  3. /**
  4.  * @author 许大仙
  5.  * @version 1.0
  6.  * @since 2021-08-07 14:25
  7.  */
  8. public class BranchStructureExercise1 {
  9.     public static void main(String[] args) {
  10.         // ① 用户输入成绩
  11.         Scanner input = new Scanner(System.in);
  12.         System.out.print("请输入岳小鹏的期末成绩：");
  13.         double score = input.nextDouble();
  15.         // ② 按照100、(80,99]、[60,80]的顺序检查输入的成绩数据，在各个分支内打印对应的奖励
  16.         if (score == 100) {
  17.             System.out.println("BMW");
  18.         } else if (score > 80 && score <= 99) {
  19.             System.out.println("iphone xs max");
  20.         } else if (score >= 60 && score <= 80) {
  21.             System.out.println("ipad");
  22.         } else {
  23.             System.out.println("其他");
  24.         }
  26.     }
  27. }

3.6.2 练习2

  • 由键盘输入三个整数分别存入变量 num1 、num2 、num3 ，对它们进行排序，并且从小到大输出。

  • 示例： 

  1. import java.util.Scanner;
  3. /**
  4.  * @author 许大仙
  5.  * @version 1.0
  6.  * @since 2021-08-07 14:47
  7.  */
  8. public class BranchStructureExercise2 {
  9.     public static void main(String[] args) {
  10.         Scanner input = new Scanner(System.in);
  11.         System.out.print("请输入num1的值：");
  12.         int num1 = input.nextInt();
  13.         System.out.print("请输入num2的值：");
  14.         int num2 = input.nextInt();
  15.         System.out.print("请输入num3的值：");
  16.         int num3 = input.nextInt();
  18.         int temp = 0;
  20.         if (num1 >= num2) {
  21.             // 交换 num1 和 num2的值
  22.             temp = num1;
  23.             num1 = num2;
  24.             num2 = temp;
  25.         }
  27.         if (num2 >= num3) {
  28.             // 交换 num2 和 num3的值，这样num3的值最大
  29.             temp = num2;
  30.             num2 = num3;
  31.             num3 = temp;
  33.             // 如果 num2 和 num3进行了交换，就再比较一下num1和num2（新的）
  34.             if (num1 >= num2) {
  35.                 // 比较 num1 和 num2的值，这样就能决定num1和num2谁大
  36.                 temp = num2;
  37.                 num2 = num1;
  38.                 num1 = temp;
  39.             }
  40.         }
  42.         System.out.println(num1 + "<" + num2 + "<" + num3);
  43.     }
  45. }

3.6.3 练习3

  • 下面的代码，如果有输出，指出输出的结果。
  1. /**
  2.  * @author 许大仙
  3.  * @version 1.0
  4.  * @since 2021-08-07 15:40
  5.  */
  6. public class BranchStructureExercise3 {
  7.     public static void main(String[] args) {
  8.         int x = 4;
  9.         int y = 1;
  10.         if (x > 2) {
  11.             if (y > 2) 
  12.                 System.out.println(x + y);
  13.             System.out.println("许大仙");
  14.         } else 
  15.             System.out.println("x is " + x);
  16.     }
  17. }

注意：实际开发中，强烈建议不要这么写。

  • 输出结果：
  1. 许大仙

3.6.4 练习4

  • 编写程序，声明 2 个 int 型变量并赋值。判断两数之和，如果大于等于 50 ，打印 “ hello world! “ 。

  • 示例： 

  1. /**
  2.  * @author 许大仙
  3.  * @version 1.0
  4.  * @since 2021-08-07 19:51
  5.  */
  6. public class BranchStructureExercise4 {
  7.     public static void main(String[] args) {
  8.         int i = 20;
  9.         int j = 30;
  11.         if ((i + j) >= 50) {
  12.             System.out.println("Hello World!");
  13.         }
  14.     }
  15. }

3.6.5 练习5

  • 编写程序，声明 2 个 double 型变量并赋值。判断第一个数大于 10.0 ，且第 2 个数小于 20.0 ，打印两数之和。否则，打印两数的乘积。

  • 示例： 

/**
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-07 19:55
 */
public class BranchStructureExercise5 {
    public static void main(String[] args) {
        double a = 11.5;
        double b = 19.8;

        if (a >= 10.0 && b < 20.0) {
            System.out.println(a + b);
        } else {
            System.out.println(a * b);
        }

    }
}

3.6.6 练习6

  • 我家的狗 5 岁了，5 岁的狗相当于人类多大呢？其实，狗的前两年每一年相当于人类的 10.5 岁，之后每增加一年就增加四岁。那么 5 岁的狗相当于人类多少年龄呢？应该是：10.5 + 10.5 + 4 + 4 + 4 = 33 岁。

  • 编写一个程序，获取用户输入的狗的年龄，通过程序显示其相当于人类的年龄。如果用户输入负数，请显示一个提示信息。

  • 示例： 

import java.util.Scanner;

/**
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-07 20:03
 */
public class BranchStructureExercise6 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入狗的年龄：");
        int age = input.nextInt();

        if (age <= 0) {
            System.out.println("年龄不能为负数或0");
        } else if (age <= 2) {
            System.out.println("狗的年龄相当于：" + age * 10.5);
        } else {
            // 前两年
            double towYearAge = 10.5 * 2;
            // 比2大的
            double moreYearAge = (age - 2) * 4;
            // 总的年龄
            double totalAge = towYearAge + moreYearAge;
            System.out.println("狗的年龄相当于：" + totalAge);
        }
    }
}

3.6.7 练习7

  • 假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票中奖号码，提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。
  • ① 如果用户输入的数匹配彩票的实际顺序，奖金 10 000 美元。
  • ② 如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000 美元。
  • ③ 如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金 1 000 美元。
  • ④ 如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金 500 美元。

  • ⑤ 如果用户输入的数字没有匹配任何一个数字，则彩票作废。

  • 示例： 

import java.util.Random;
import java.util.Scanner;

/**
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-07 20:11
 */
public class BranchStructureExercise7 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入两位数（01~99）：");
        int number = input.nextInt();

        Random random = new Random();
        int prizeNumber = random.nextInt(100);

        int gePrize = prizeNumber % 10;
        int shiPrize = prizeNumber / 10;

        if (number <= 0 || number > 100) {
            System.out.println("用户输入号码不合法");
        } else {
            System.out.println("用户输入号码：" + number);
            System.out.println("彩票中奖号码：" + prizeNumber);

            int ge = number % 10;
            int shi = number / 10;

            if (number == prizeNumber) {
                System.out.println("奖金10 000美元");
            } else if (gePrize == shi && shiPrize == ge) {
                System.out.println("奖金 3 000美元");
            } else if (gePrize == ge || shiPrize == shi) {
                System.out.println("奖金1 000美元");
            } else if (gePrize == shi || shiPrize == ge) {
                System.out.println("奖金500美元");
            } else {
                System.out.println("没有中奖");
            }
        }
    }
}

第四章：循环结构

4.1 概述

  • 循环结构：在某些条件满足的情况下，反复执行特定代码的功能。

4.2 for循环

  • 语法：
for(初始化条件①;循环条件语句②;迭代语句④){
    循环体语句③
}

for(;;){
    循环体语句块；//如果循环体中没有跳出循环体的语句，那么就是死循环
}

注意：

  • for(;;){} 中的两个 ; 是不能多也不能少的。
  • 循环条件必须是 boolean 类型。
  • 如果循环条件语句 ② 省略的话，就默认为循环条件成立。
  • 执行流程：
    • 第一步：执行初始化语句 ① ，完成循环变量的初始化；
    • 第二步：执行循环条件语句 ② ，看循环条件语句的值是 true ，还是 false ；
      • 如果是 true ，执行第三步；
      • 如果是 false ，循环语句中止，循环不再执行。
    • 第三步：执行循环体语句 ③ ；
    • 第四步：执行迭代语句 ④ ，针对循环变量重新赋值；
    • 第五步：根据循环变量的新值，重新从第二步开始再执行一遍；
  • 示例： 
/**
 * 打印10次"Hello"
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-08 08:08
 */
public class ForDemo1 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello");
        }
    }
}
  • 示例：
/**
 * 从1累加到5
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-08 08:09
 */
public class ForDemo2 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += i;
        }
        System.out.println("sum = " + sum);
    }
}
  • 示例：
/**
 * 1~100的偶数和
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-08 09:11
 */
public class ForDemo3 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                sum += i;
            }
        }
        System.out.println("sum = " + sum);
    }
}
  • 示例：
/**
 * 编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”。
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-08 15:04
 */
public class ForDemo4 {
    public static void main(String[] args) {

        for (int i = 1; i <= 150; i++) {
            System.out.print(i + "\t");
            if (i % 3 == 0) {
                System.out.print("foo" + "\t");
            }
            if (i % 5 == 0) {
                System.out.print("biz" + "\t");
            }
            if (i % 7 == 0) {
                System.out.print("baz" + "\t");
            }
            System.out.println();
        }
    }
}
  • 示例：
/**
 * 输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
 * <p>
 * 例如： 153 = 111 + 333 + 555
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-08 15:14
 */
public class ForDemo5 {
    public static void main(String[] args) {
        for (int i = 100; i <= 999; i++) {
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100;

            if (i == Math.pow(ge, 3) + Math.pow(shi, 3) + Math.pow(bai, 3)) {
                System.out.println("水仙花数 = " + i);
            }
        }
    }
}

4.3 while循环

  • 语法：
初始化语句①；
while (循环条件语句②) {
    循环体语句③；
    迭代语句④；
}
  • 执行流程：
    • 第一步：执行初始化语句 ① ，完成循环变量的初始化；
    • 第二步：执行循环条件语句 ② ，看循环条件语句的值是 true ，还是 false ；
      • 如果是 true ，执行第三步；
      • 如果是 false ，循环语句中止，循环不再执行；
    • 第三步：执行循环体语句 ③ ；
    • 第四步：执行迭代语句 ④ ，针对循环变量重新赋值；
    • 第五步：根据循环变量的新值，重新从第二步开始再执行一遍；

注意：while (循环条件)中循环条件必须是 boolean 类型。

  • 示例：
/**
 * 打印1~10
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-08 16:02
 */
public class WhileDemo {
    public static void main(String[] args) {
        int i = 1;
        while (i <= 10) {
            System.out.println(i);
            i++;
        }
    }
}
  • 示例：
/**
 * 世界最高山峰是珠穆朗玛峰，它的高度是8844.43米，假如我有一张足够大的纸，它的厚度是0.1毫米。
 * 请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-08 16:07
 */
public class WhileDemo2 {
    public static void main(String[] args) {
        // 统一计量单位
        double height = 88444300;
        double paper = 1.0;

        // 折叠次数
        int count = 0;

        // 折纸的高度，初始化时为纸张没有折叠的高度
        double paperHeight = paper;

        while (paperHeight <= height) {
            // 每折叠一次，厚度翻倍
            paperHeight *= 2;

            // 折叠次数自增
            count++;
        }
        System.out.println("最终纸的厚度 = " + paperHeight);
        System.out.println("最终折叠的次数 = " + count);

    }
}
  • 示例：
import java.util.Scanner;

/**
 * 从键盘读入个数不确定的整数，并判断读入的奇数和偶数的个数，输入为0时结束程序。
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-08 16:19
 */
public class WhileDemo3 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入整数：");
        int number = input.nextInt();

        int oddCount = 0;
        int evenCount = 0;

        while (number != 0) {

            if (number % 2 == 0) {
                evenCount++;
            } else {
                oddCount++;
            }

            System.out.print("请输入整数：");
            number = input.nextInt();
        }

        System.out.println("奇数的个数 = " + oddCount);
        System.out.println("偶数的个数 = " + evenCount);
    }
}

4.4 do…while循环

  • 语法：
初始化语句①
do {
    循环体语句②；
    迭代语句③；
} while (循环条件语句④)；
  • 执行流程：
    • 第一步：执行初始化语句 ① ，完成循环变量的初始化；
    • 第二步：执行循环体语句 ② ；
    • 第三步：执行迭代语句 ③ ，针对循环变量重新赋值；
    • 第四步：执行循环条件语句 ④ ，看循环条件语句的值是 true ，还是 false ；
      • 如果是 true ，根据循环变量的新值，重新从第二步开始再执行一遍；
      • 如果是 false ，循环语句中止，循环不再执行；
  • 示例： 
/**
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-08 20:32
 */
public class DoWhileTest {
    public static void main(String[] args) {
        int sum = 0;
        int i = 1;
        do {
            sum += i;
            i++;
        } while (i <= 100);

        System.out.println("sum = " + sum);
    }
}

4.5 循环语句的区别

  • 从循环次数角度分析：
    • do…while 循环至少执行一次循环体语句。
    • for 和 while 循环先循环条件语句是否成立，然后决定是否执行循环体，至少执行零次循环体语句。
  • 从循环变量的生命周期角度分析：
    • for 循环的循环变量在 for() 中声明的，在循环语句结束后，不可以被访问。
    • while 和 do…while 循环的循环变量因为在外面声明的，所以 while 和 do…while 结束后可以被继续使用的。
  • 如何选择：
    • 遍历有明显的循环次数（范围）的需求，选择 for 循环。
    • 遍历没有明显的循环次数（范围）的需求，循环 while 循环。
    • 如果循环体语句块至少执行一次，可以考虑使用 do…while 循环。
    • 本质上：三种循环之间是可以互相转换的，都能实现循环的功能。
  • 三种循环结构都具有四要素：
    • ① 循环变量的初始化表达式。
    • ② 循环条件。
    • ③ 循环变量的修改的迭代表达式。
    • ④ 循环体语句块。

4.6 嵌套循环（多重循环）

  • 将一个循环放在另一个循环体内，就形成了多重循环。其中，for 、while 、do…while 均可以作为外层循环或内层循环。
  • 实际上，嵌套循环就是将内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false ，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次循环。

  • 假设外层循环次数为 m 次，内层循环次数为 n 次，则内层循环体实际上需要执行m*n 次。

  • 示例： 

/**
 * 九九乘法表
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-08 20:43
 */
public class ForForDemo {
    public static void main(String[] args) {
        // 外层循环控制行数
        for (int i = 1; i <= 9; i++) {
            // 内层循环控制列数
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + i * j + "\t");
            }
            System.out.println();
        }
    }
}

4.7 控制语句

4.7.1 break

  • 使用场景：
    • ① 在选择结构 switch 语句中。
    • ② 在循环语句中。
  • 示例： 
/**
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-08 21:14
 */
public class BreakDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                // 将本层的循环结束
                break;
            }
            System.out.println(i);
        }
    }
}
  • 示例：
import java.util.Scanner;

/**
 * 从键盘输入不断输入整数，输入0表示结束，统计一共有几个正数、负数。
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-09 15:57
 */
public class BreakDemo2 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        // 正数的个数
        int positive = 0;
        // 负数的个数
        int negative = 0;

        while (true) {
            System.out.print("请输入数字：");
            int number = input.nextInt();

            if (number > 0) {
                positive++;
            } else if (number < 0) {
                negative++;
            } else {
                break;
            }
        }

        System.out.println("正数的个数 = " + positive);
        System.out.println("负数的个数 = " + negative);
    }
}
  • 示例：
/**
 * 求1-100之间的质数
 * ps: 质数是指能被1和其本身整除的数
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-08 21:07
 */
public class PrimeNumber {
    public static void main(String[] args) {

        // 外层循环，列出从2~100的所有的数字
        for (int i = 2; i <= 100; i++) {
            // 标记：先设置为true，后面再使用内层循环进行排序
            boolean flag = true;
            // 内层循环：验证i变量中保存的这个数是不是质数
            // 验证方式：用i 对 从2到i/2的所有数 取模，如果发现能够整除，那么说明i不是质数
            for (int j = 2; j <= i / 2; j++) {
                if (i % j == 0) {
                    // 如果不是素数，就将标记改为false
                    flag = false;
                    break;
                }
            }
            if (flag) {
                System.out.println("i = " + i);
            }
        }

    }
}

4.7.2 continue

  • 使用场景：结束本次循环，继续下一次的循环。

  • 示例： 

/**
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-09 16:07
 */
public class ContinueDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i % 3 == 0) {
                continue;
            }
            System.out.println("i = " + i);
        }
    }
}
  • 示例：
/**
 * 打印1-100之间的整数，跳过7的倍数和7结尾的数
 *
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-09 16:08
 */
public class ContinueDemo2 {
    public static void main(String[] args) {
        for (int i = 1; i <= 100; i++) {
            if (i % 7 == 0 || i % 10 == 7) {
                continue;
            }
            System.out.println("i = " + i);
        }
    }
}

4.7.3 return

  • reutrn ：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个 return 语句的时候，这个方法将被结束。

  • 和 break 和 continue 不同的是，return 直接结束整个方法，不管这个 return 处于多少层循环之内。

  • 示例： 

/**
 * @author 许大仙
 * @version 1.0
 * @since 2021-08-09 16:13
 */
public class ReturnDemo {
    public static void main(String[] args) {

        for (int i = 0; i < 100; i++) {
            if (i == 7) {
                return;
            }
            System.out.println(i);
        }

    }
}