day06_程序流程控制

程序流程控制

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组 合成能完成一定功能的小逻辑模块。

其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：

• 顺序结构
• 分支结构
• 循环结构

顺序结构

• 程序从上到下逐行地执行，中间没有任何判断和跳转。

分支结构

• 根据条件，选择性地执行某段代码。
• 有if…else和switch-case两种分支语句。

循环结构

• 根据循环条件，重复性的执行某段代码。
• 有while、do…while、for三种循环语句。
• 注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素

顺序结构

• 程序从上到下逐行地执行，中间没有任何判断和跳转。

顺序结构代码执行执行流程图

                                                           

举例

public class Demo01Sequence {
    public static void main(String[] args) {
        //顺序执行，根据编写的顺序，从上到下运行
        System.out.println(1);// 1
        System.out.println(2);// 2
        System.out.println(3);// 3
    }
}

 分支结构之if语句

• if语句第一种形式： if

格式：

执行流程

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

单if语句执行顺序流程图

                                                    

举例：

public class Demo02If {
    public static void main(String[] args) {
        int heartBeats = 80;
        //heartBeats <0|| heartBeats>120 是条件表达式
        if (heartBeats < 0 || heartBeats > 120) {
            //条件表达式为true执行的代码
            System.out.println("心跳异常，需要进一步检查");
        }
    }
}

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

格式：

执行流程

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

if...else执行顺序流程图

                      

举例：

// 标准的if-else语句, 判断给定的数据是奇数还是偶数
public class Demo03IfElse {
    public static void main(String[] args) {
        // 定义变量
        int number = 666;
        // 关系表达式number % 2，如果除以2能够余数为0，说明是偶数，关系表达式为true
        if (number % 2 == 0) {
            //关系表达式为true执行的代码
            System.out.println("偶数");//偶数
        } else {
            //关系表达式为false执行的代码
            System.out.println("奇数");
        }
        System.out.println("其他代码");//其他代码
    }
}

• f语句第三种形式： 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 Demo04IfElsePractise {
    public static void main(String[] args) {
        //哪个关系表达式成立就执行哪个后面大括号里的代码
        int score = 100;
        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("不及格");
            //如果上面的关系表达式都为false，则执行else中代码
        } else {
            // 单独处理边界之外的不合理情况
            System.out.println("数据错误");
        }
    }
}

分支结构：if-else使用说明总结

• 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
• 语句块只有一条执行语句时，一对{}可以省略，但建议保留
• if-else语句结构，根据需要可以嵌套使用
• 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
• 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓
• 当多个条件是“包含”关系时，“小上大下 / 子上父下”

需求

当我们编写的程序要解决问题的时候，难免要用户从键盘输入数据。那怎么才能从键盘转换获取数据了？一个可以解析基本类型和字符串的简单文本扫描器。Scanner类的功能：可以实现键盘输入数据，到程序当中。Scanner使用步骤如下

1：导包:使用import关键字导包，在类的所有代码之前导包，引入要使用的类型，java.lang包下的所有类无需导入。

格式：

2：创建对象:使用该类的构造方法，创建一个该类的对象。

格式：

3：调用方法:调用该类的成员方法，完成指定功能。

格式：

注意：

需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchException导致程序终止。

举例：

import java.util.Scanner;

public class ScannerTest {
    public static void main(String[] args) {
        //2.Scanner的实例化,参数System.in代表从键盘进行输入
        Scanner scan = new Scanner(System.in);

        //3.调用Scanner类的相关方法
        System.out.println("请输入你的姓名：");
        String name = scan.next();
        System.out.println(name);
        //从键盘获取一个int数据
        System.out.println("请输入你的芳龄：");
        int age = scan.nextInt();

        //从键盘获取一个double数据
        System.out.println("请输入你的体重：");
        double weight = scan.nextDouble();

        //从键盘获取一个boolean数据
        System.out.println("你是否相中我了呢？(true/false)");
        boolean isLove = scan.nextBoolean();

        //对于char型的获取，Scanner没有提供相关的方法。只能获取一个字符串
        System.out.println("请输入你的性别：(男/女)");
        String gender = scan.next();
        //获取索引为0位置上的字符
        char genderChar = gender.charAt(0);


    }
}

小练习

import java.util.Scanner;

/*
岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆BMW；
成绩为(80，99]时，奖励一台iphone xs max；
当成绩为[60,80]时，奖励一个 iPad；
其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断

 */
public class ScannerIf {
    public static void main(String[] args) {
        //创建Scanner对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入岳小鹏期末成绩：(0-100)");
        //获取从键盘输入的数据
        int score = scanner.nextInt();
        if (score == 100) {
            System.out.println("奖励飞机");
        } else if (score > 80 && score <= 99) {
            System.out.println("奖励汽车");
        } else if (score >= 60 && score <= 80) {
            System.out.println("奖励手机");
        } else {
            System.out.println("什么奖励也没有");
        }
    }
}

总结

针对于条件表达式：

• 如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。
• 如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
• 如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。

/*
编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
对它们进行排序(使用 if-else if-else),并且从小到大输出。
*/
import java.util.Scanner;
class IfTest2 {
	public static void main(String[] args) {
		
		Scanner scanner = new Scanner(System.in);

		System.out.println("请输入第一个整数：");
		int num1 = scanner.nextInt();
		System.out.println("请输入第二个整数：");
		int num2 = scanner.nextInt();
		System.out.println("请输入第三个整数：");
		int num3 = scanner.nextInt();

		if(num1 >= num2){
			if(num3 >= num1)
				System.out.println(num2 + "," + num1 + "," + num3);
			else if(num3 <= num2)
				System.out.println(num3 + "," + num2 + "," + num1);
			else
				System.out.println(num2 + "," + num3 + "," + num1);
			
		
		}else{
			if(num3 >= num2)
				System.out.println(num1 + "," + num2 + "," + num3);
			else if(num3 <= num1)
				System.out.println(num3 + "," + num1 + "," + num2);
			else
				System.out.println(num1 + "," + num3 + "," + num2);
			
		}

	}
}

总结

• if-else结构是可以相互嵌套的。
• 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。

分支语句之switch-case结构

格式：

         

执行流程

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

执行顺序流程图

       

注意事项

• switch(表达式)中表达式的值必须是下述几种类型之一：byte，short， char，int，枚举 (jdk 5.0)，String (jdk 7.0)；
• case子句中的值必须是常量，不能是变量名或不确定的表达式值；
• 同一个switch语句，所有case子句中的常量值互不相同；
• switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略。“匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止。” 
• default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时， 执行default

举例

/*
2.说明：
① 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
  当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构
  末尾结束为止。
② break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
③ switch结构中的表达式，只能是如下的6种数据类型之一：
   byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
④ case 之后只能声明常量。不能声明范围。
⑤ break关键字是可选的。
⑥ default:相当于if-else结构中的else.
  default结构是可选的，而且位置是灵活的。
*/
 
class SwitchCaseTest {
    public static void main(String[] args) {
 
        int number = 5;
        switch (number) {
 
            case 0:
                System.out.println("zero");
                break;
            case 1:
                System.out.println("one");
                break;
            case 2:
                System.out.println("two");
                break;
            case 3:
                System.out.println("three");
                break;
            default:
                System.out.println("other");//other
                //break;
        }
 
 
        String season = "summer";
        switch (season) {
            case "spring":
                System.out.println("春暖花开");
                break;
            case "summer":
                System.out.println("夏日炎炎");//夏日炎炎
                break;
            case "autumn":
                System.out.println("秋高气爽");
                break;
            case "winter":
                System.out.println("冬雪皑皑");
                break;
            default:
                System.out.println("季节输入有误");
                break;
        }
 
 
        //**************如下的两种情况都编译不通过*********************
        //情况一
		/*
		boolean isHandsome = true;
		switch(isHandsome){
		case true:
			System.out.println("我好帅啊~~~");
			break;
		case false:
			System.out.println("我好丑啊~~~");
			break;
		default:
			System.out.println("输入有误~~~");
		}
		*/
        //情况二
		/*
		int age = 10;
		switch(age){
		case age > 18:
			System.out.println("成年了");
			break;
		default:
			System.out.println("未成年");
		}
		*/
    }
}

练习题1

/*
例题：对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。
说明：如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。
*/
class SwitchCaseTest1 {
	public static void main(String[] args) {
		
		/*
		int score = 78;
		switch(score){
		case 0:
		case 1:
		case 2:
			...
		case 100:
		
		}
		*/
 
		/*
		int score = 78;
		if(score >= 60){
		
		}else{
		
		}
		*/
		
		int score = 78;
		switch(score / 10){
		case 0:
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
			System.out.println("不及格");
			break;
		case 6:
		case 7:
		case 8:
		case 9:
		case 10:
			System.out.println("及格");
			break;
 
		}
		
		//更优的解决方案：
		switch(score / 60){
		case 0:
			System.out.println("不及格");
			break;
		case 1:
			System.out.println("及格");
			break;
		}
	
	}
}

练习题2

/*
从键盘分别输入年、月、日，判断这一天是当年的第几天
   注：判断一年是否是闰年的标准：
       1）可以被4整除，但不可被100整除
	或
       2）可以被400整除
*/
 
import java.util.Scanner;
 
class SwitchCaseExer {
    public static void main(String[] args) {
 
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入year：");
        int year = scan.nextInt();
        System.out.println("请输入month：");
        int month = scan.nextInt();
        System.out.println("请输入day：");
        int day = scan.nextInt();
 
 
        //定义一个变量来保存总天数
        int sumDays = 0;
 
        switch (month) {
            case 12:
                sumDays += 30;
            case 11:
                sumDays += 31;
            case 10:
                sumDays += 30;
            case 9:
                sumDays += 31;
            case 8:
                sumDays += 31;
            case 7:
                sumDays += 30;
            case 6:
                sumDays += 31;
            case 5:
                sumDays += 30;
            case 4:
                sumDays += 31;
            case 3:
                //sumDays += 28;
                //判断year是否是闰年
                if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
                    sumDays += 29;
                } else {
                    sumDays += 28;
                }
 
            case 2:
                sumDays += 31;
            case 1:
                sumDays += day;
        }
 
        System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天");
    }
}

switch和if语句的对比

if和switch语句很像，具体什么场景下，应用哪个语句呢？

• 如果判断的具体数值不多，而且符合byte、short 、char、int、String、枚举等几种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。
• 其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。 也就是说，使用switch-case的，都可以改写为if-else。反之不成立。

程序流程控制：循环结构

循环概述：循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。循环语句的四个组成部分

• 初始化部分(init_statement)
• 循环条件部分(test_exp)
• 循环体部分(body_statemen）
• 迭代部分(alter_statement)

循环语句之for循环

格式：

 

执行流程

• 执行顺序：①②③④>②③④>②③④…②不满足为止。
• ①负责完成循环变量初始化。在循环开始最初执行，而且只做唯一一次。①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
• ②负责判断是否满足循环条件，如果成立，则循环继续；如果不成立，则循环退出。
• ③具体执行的语句，重复要做的事情内容，若干行语句。
• ④循环后，循环条件所涉及变量的变化情况 。每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。④可以有多个变量更新，用逗号分隔 。

执行流程图

                         

举例：

/*
For循环结构的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件  --->是boolean类型
③ 循环体
④ 迭代条件
*/
class ForTest {
    public static void main(String[] args) {
 
        for (int i = 1; i <= 5; i++) {//i:1,2,3,4,5
            System.out.println("Hello World!");
        }
        //i:在for循环内有效。出了for循环就失效了。System.out.println(i); 错误
        //
 
        //练习：
        int num = 1;
        for (System.out.print('a'); num <= 3; System.out.print('c'), num++) {
            System.out.print('b');
        }
        //输出结果：abcbcbc
 
        System.out.println();
 
        //例题：遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
        int sum = 0;//记录所有偶数的和
        int count = 0;//记录偶数的个数
        for (int i = 1; i <= 100; i++) {
 
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
                count++;
            }
            //System.out.println("总和为：" + sum);
        }
 
        System.out.println("总和为：" + sum);//总和为：2550
        System.out.println("个数为：" + count);//个数为：50
 
    }
}

 小练习

/*
编写程序从1循环到150，并在每行打印一个值，
另外在每个3的倍数行上打印出“foo”,
在每个5的倍数行上打印“biz”,
在每个7的倍数行上打印输出“baz”。
*/
 
class ForTest1 {
    public static void main(String[] args) {
 
        for (int i = 1; i <= 150; i++) {
 
            System.out.print(i + "  ");
 
            if (i % 3 == 0) {
                System.out.print("foo ");
            }
 
            if (i % 5 == 0) {
                System.out.print("biz ");
            }
 
            if (i % 7 == 0) {
                System.out.print("baz ");
            }
 
            //换行
            System.out.println();
 
        }
 
    }
}

小练习

 
/*
题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。
说明：break关键字的使用：一旦在循环中执行到break，就跳出循环
*/
 
import java.util.Scanner;
 
public class ForTest01 {
    public static void main(String[] args) {
 
        Scanner scan = new Scanner(System.in);
 
        System.out.println("请输入第一个正整数：");
        int m = scan.nextInt();
 
        System.out.println("请输入第二个正整数：");
        int n = scan.nextInt();
 
        //获取最大公约数
        //1.获取两个数中的较小值
        int min = (m <= n) ? m : n;
        //2.遍历,最大公约数一定小于或者等于最小数
        for (int i = min; i >= 1; i--) {
            if (m % i == 0 && n % i == 0) {
                System.out.println("最大公约数为：" + i);
                break;//一旦在循环中执行到break，就跳出循环
            }
        }
 
        //获取最小公倍数
        //1.获取两个数中的较大值
        int max = (m >= n) ? m : n;
        //2.遍历，最大公倍数一定是2个数的成积
        for (int i = max; i <= m * n; i++) {
            if (i % m == 0 && i % n == 0) {
 
                System.out.println("最小公倍数：" + i);
                break;
 
            }
        }
 
    }
 
}
 
 

循环语句之while循环 

格式： 

执行流程

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

说明：

• 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
• for循环和while循环可以相互转换

执行顺序流程图

                                                                                  

举例 

/*
说明：
1.写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
2.我们写程序，要避免出现死循环。
3.for循环和while循环是可以相互转换的！ 
区别：for循环和while循环的初始化条件部分的作用范围不同。
算法：有限性。
*/
class WhileTest {
    public static void main(String[] args) {
 
        //遍历100以内的所有偶数
        int i = 1;//① 初始化条件
        while (i <= 100) {//② 循环条件  --->是boolean类型
            //③ 循环体
            if (i % 2 == 0) {
                System.out.println(i);
            }
            //④ 迭代条件
            i++;
        }
        //出了while循环以后，仍可以调用。
        System.out.println(i);//101
 
    }
}

循环语句之do...while 

格式：

执行流程

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

执行顺序流程图

                                         

举例

/*
说明：
1.do-while循环至少会执行一次循环体！
2.开发中，使用for和while更多一些。较少使用do-while
*/
class DoWhileTest {
    public static void main(String[] args) {
 
        //遍历100以内的偶数,并计算所有偶数的和及偶数的个数
        int num = 1;//① 初始化条件
        int sum = 0;//记录总和
        int count = 0;//记录个数
        do {
 
            if (num % 2 == 0) {//③ 循环体
                System.out.println(num);
                sum += num;
                count++;
            }
 
            num++;//④ 迭代条件
 
        } while (num <= 100);//② 循环条件  --->是boolean类型
 
 
        System.out.println("总和为：" + sum);//总和为：2550
        System.out.println("个数为：" + count);//个数为：50
    }
}

三种循环的区别

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

死循环

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

举例：

/*
题目：
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
说明：
1. 不在循环条件部分限制次数的结构：for(;;) 或 while(true)
2. 结束循环有几种方式？
     方式一：循环条件部分返回false
	 方式二：在循环体中，执行break
*/
 
import java.util.Scanner;
 
class ForWhileTest {
    public static void main(String[] args) {
 
        Scanner scan = new Scanner(System.in);
 
        int positiveNumber = 0;//记录正数的个数
        int negativeNumber = 0;//记录负数的个数
 
        for (; ; ) {//while(true){
 
            int number = scan.nextInt();
 
            //判断number的正负情况
            if (number > 0) {
                positiveNumber++;
            } else if (number < 0) {
                negativeNumber++;
            } else {
                //一旦执行break，跳出循环
                break;
            }
 
        }
 
        System.out.println("输入的正数个数为：" + positiveNumber);
        System.out.println("输入的负数个数为：" + negativeNumber);
 
 
    }
}

嵌套循环

所谓嵌套循环，是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数。比如跳绳：一共跳5组，每组跳10个。5组就是外循环，10个就是内循环。 

嵌套循环格式： 

执行流程：

• 执行顺序：①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥
• 外循环一次，内循环多次。 

代码举例

 
 
/*
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环
2.
外层循环：循环结构B
内层循环：循环结构A
3. 说明
① 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次
4. 技巧：
   外层循环控制行数，内层循环控制列数
   
   需求：
   打印下面图形
*
**
***
****
*****
****
***
**
*
*/
class ForForTest {
    public static void main(String[] args) {
 
 
        for (int i = 1; i <= 5; i++) {//控制行数
            for (int j = 1; j <= i; j++) {//控制列数
                System.out.print("*");
 
            }
            System.out.println();
        }
 
        for (int i = 1; i <= 4; i++) {
            for (int j = 1; j <= 5 - i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
 
 
    }
}
 
 

小练习

/*
100以内的所有质数的输出。
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。
最小的质数是：2
*/
class PrimeNumberTest {
	public static void main(String[] args) {
		
		boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
 
		for(int i = 2;i <= 100;i++){//遍历100以内的自然数
			
		
			for(int j = 2;j < i;j++){//j:被i去除
				
				if(i % j == 0){ //i被j除尽
					isFlag = false;
				}
				
			}
			//
			if(isFlag == true){
				System.out.println(i);
			}
			//重置isFlag
			isFlag = true;
		
		}
	}
}

程序流程控制的关键字

break 语句

• break语句用于终止某个语句块的执行
• break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是 哪一层语句块

continue 语句

• continue只能使用在循环结构中
• continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
• continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环 。

举例：

 
 
 
class BreakContinueTest {
    public static void main(String[] args) {
 
        for (int i = 1; i <= 10; i++) {
 
            if (i % 4 == 0) {
                break;//123
                //关键字后面不能声明执行语句
                //continue;//123567910
                //System.out.println("今晚迪丽热巴要约我！！！");
            }
            System.out.print(i);
        }
 
        System.out.println("\n");
        //******************************
 
        label:
        for (int i = 1; i <= 4; i++) {
 
            for (int j = 1; j <= 10; j++) {
 
                if (j % 4 == 0) {
                    //break;//默认跳出包裹此关键字最近的一层循环。
                    //continue;
 
                    //break label;//结束指定标识的一层循环结构
                    continue label;//结束指定标识的一层循环结构当次循环
                }
 
                System.out.print(j);
            }
 
            System.out.println();
        }
    }
}

特殊流程控制语句说明

• break只能用于switch语句和循环语句中。
• continue 只能用于循环语句中。
• 二者功能类似，但continue是终止本次循环，break是终止本层循环。
• break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
• 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
• 很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条 语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同 于goto的。