Java流程控制

时间：2021-03-12 13:34:15 收藏：0 阅读：0

Java流程控制

1.用户交互Scanner

Scanner对象

之前我们学习的基本语法中，并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner，它是 Java5 的新特性，我们可以通过Scanner 类来获取用户输入
基本语法：

Scanner s = new Scanner(System.in);

通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串，在读取前我们一般需要使用 hasNext() 与 hasNextLine() 判断是否还有输入的数据

Scanner对象的分类

next():
- 一定要读取到有效字符后才可以结束输入
- 对输入有效字符之前遇到的空白，next()方法会自动将其去掉
- 输入有效字符后，其后面输入的空白会被作为分隔符或者结束符
- 故：next()不能得到带有空格的字符串

package Java流程控制;

import java.util.Scanner;

public class 用户交互Scanner1 {

    public static void main(String[] args) {

        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接收：");

        //判断用户有没有输入字符串
        if (scanner.hasNext()==true){
            //使用next方式接收：
            String str = scanner.next();//这句话一旦执行，程序会等待用户输入完毕
            System.out.println("输出的内容为："+str);
        }

        //凡是属于IO流(输入输出流)的类如果不关闭会一直占用资源，要养成好习惯，用完就关掉
        scanner.close();
    }

}

nextLine()
- 以Ener为结束符，也就是说 nextLine() 方法返回的是敲回车键之前的所有字符
- 可以获得空白

package Java流程控制;

import java.util.Scanner;

public class 用户交互Scanner2 {

    public static void main(String[] args) {

        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用nextLine方式接收：");

        //判断用户是否还有输入
        if (scanner.hasNextLine()==true){
            //使用nextLine方式接收：
            String str = scanner.nextLine();//这句话一旦执行，程序会等待用户输入完毕
            System.out.println("输出的内容为："+str);
        }

        //凡是属于IO流(输入输出流)的类如果不关闭会一直占用资源，要养成好习惯，用完就关掉
        scanner.close();
    }

}

总结和梳理

package Java流程控制;

import java.util.Scanner;

public class 用户交互Scanner3 {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);//1.开始接收键盘数据

        System.out.println("请输入数据：");

        String str = scanner.nextLine();//2.在此停止，直到用户输入完毕按下回车，将输入的数据变成一个变量保存到str这个字符串里

        System.out.println("输出的内容为："+str);//3.根据用户的输入进行输出

        scanner.close();//4.关闭这个IO流

    }

}

由于 next() 有空格就会断，所以平时 nextLine() 用得比较多，next() 的运用场景少一些

Scanner进阶使用案例1

package Java流程控制;

import java.util.Scanner;

public class Scanner进阶使用 {

    public static void main(String[] args) {

        Scanner Scanner = new Scanner(System.in);

        //从键盘接收数据
        int i = 0;
        float f = 0.0F;

        System.out.println("请输入整数：");

        //如果。。。那么
        if (Scanner.hasNextInt()==true){
            i = Scanner.nextInt();
            System.out.println("整数数据：" + i);
        }else{
            System.out.println("输入的不是整数数据！");
        }


        System.out.println("请输入小数：");

        //如果。。。那么
        if (Scanner.hasNextFloat()==true){
            f = Scanner.nextFloat();
            System.out.println("小数数据：" + f);
        }else{
            System.out.println("输入的不是小数数据！");
        }

        Scanner.close();//关闭IO流的代码可以先写，然后再中间写代码，就不会忘记关闭
    }

}

Scanner进阶使用案例2

package Java流程控制;

import java.util.Scanner;

public class Scanner进阶使用_例 {

    public static void main(String[] args) {
        //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果：
        Scanner scanner = new Scanner(System.in);

        //和
        double sum = 0;
        //计算输入了多少个数字
        int m = 0;

        System.out.println("傻逼你好，请输入数据，以非数字结束");
        //通过循环判断是否还有输入，并在里面对每一次进行求和及统计
        while (scanner.hasNextDouble()){
            double X = scanner.nextDouble();
            m = m + 1;//这路也可以使用m++ (自增)
            sum = sum + X;
            System.out.println("傻逼，你输入了第"+ m +"个数据，然后当前总和="+ sum);
        }

        System.out.println(m + "个数的和为" + sum);
        System.out.println(m + "个数的平均值是" + (sum / m));

        scanner.close();
    }
}

2.顺序结构

Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行
顺序结构是最简单的算法结构
语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本结构

package Java流程控制;

public class 顺序结构 {

    public static void main(String[] args) {

        System.out.println("hello 1");
        System.out.println("hello 2");
        System.out.println("hello 3");
        System.out.println("hello 4");
        System.out.println("hello 5");

        //按照自上而下的顺序输出了 hello 12345

    }
}

3.选择结构

if 单选择结构
- 我们很多时候需要去判断一个东西是否可行，然后我们才去执行，这样一个过程在程序中用if语句来表示
- 语法

  if(布尔表达式)｛
      //如果布尔表达式为true将执行的语句
  ｝

举例：

package Java流程控制;

import java.util.Scanner;

public class 选择结构_if单选择结构 {

    public static void main(String[] args) {

        Scanner Scanner = new Scanner(System.in);

        System.out.println("请输入内容：");

        String s = Scanner.nextLine();

        //equals的作用：判断字符串是否一致，类似==但是这里不能用==判断
        if (s.equals("hello"))

            System.out.println(s);
            System.out.println("End");

        Scanner.close();

        /*输入hello 会输出hello和end ；输入其他字符 会直接输出end
        这就是选择结构的特点，如果成立(true/false)就执行下一语句，否则就跳过*/

    }
}

if 双选择结构
- 假如现在有个需求，公司要收购一个软件，成功的话，给人支付100万元，如果失败，就自己找人开发。这样子的需求，用刚才的if单选择就无法完成了，需要一个双选择结构，所以就有了if-else结构
- 语法：

    if(布尔表达式)｛
        //如果布尔表达式的值为true
    ｝else｛
        //如果布尔表达式的值为false

解析：布尔表达式之后：如果true--执行语句1 ； 如果false--执行语句2

package Java流程控制;

import java.util.Scanner;

public class 选择结构_if双选择结构 {

    public static void main(String[] args) {

        //分数大于等于60分就是合格，小于60分就是不及格

        Scanner Scanner = new Scanner(System.in);

        System.out.println("请输入成绩：");

        int score = Scanner.nextInt();

        if (score>=60){
            System.out.println("恭喜合格 : ) ");
        }else {
            System.out.println("不及格 :( ");
        }

        Scanner.close();

        //布尔表达式之后：如果true--执行语句1 ； 如果false--执行语句2
    }

}

if 多选择结构
- 当遇到更加复杂的情况，如有ABCD多种情况（存在区间多级判断），比如成绩 90-100为A，80-90为B...等等，在生活中我们很多时候的选择往往也不知两个，所以我们需要一个多选择结构来处理这些问题
- 语法

    if(布尔表达式1)｛
        //如果布尔表达式1的值为true执行代码
    ｝else if（布尔表达式2）｛
        //如果布尔表达式2的值为true执行代码
    ｝else if（布尔表达式3）｛
        //如果布尔表达式3的值为true执行代码
    ｝else if（布尔表达式4）｛
        //如果布尔表达式4的值为true执行代码
    ｝

举例：

package Java流程控制;

import java.util.Scanner;

public class 选择结构_if多选择结构 {

    public static void main(String[] args) {

        //分数90-100为A；80-89为B；70-79为C；60-69为D；60以下为不合格

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入成绩：");

        int score = scanner.nextInt();

        if (score>=90 && score<=100){
            System.out.println("A");
        }else if (score>=80 && score<90){
            System.out.println("B");
        }else if (score>=70 && score<80){
            System.out.println("C");
        }else if (score>=60 && score<70) {
            System.out.println("D");
        }else if (score<60 && score>=0){
            System.out.println("不及格 :( ");
        } else {
            System.out.println("成绩不合法");
        }

        scanner.close();

/*if 语句至多有 1 个 else 语句，else 语句应在所有 else if 语句之后
if 语句可以有若干个 else if 语句，它们必须在 else 语句之前
一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行*/

    }

}

嵌套的if结构
- 使用嵌套的 if...else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。你可以像 if 语句一样嵌套 else if... else
- 语法：

  if(布尔表达式 1){
      //如果布尔表达式 1的值为true执行代码
      if(布尔表达式 2)}
        //如果布尔表达式 2的值为true执行代码
      }
  }

? 所有的流程控制语句都可以相互嵌套而互不影响

package Java流程控制;

import java.util.Scanner;

public class 选择结构_嵌套的if结构 {

    public static void main(String[] args) {

        //以超市购物 会员/非会员和消费金额不同 享受不同折扣举例：

        Scanner input = new Scanner(System.in);

        System.out.println("请输入是否为会员：是（Y）否（N）");

        String name = input.next();

        System.out.println("请输入消费金额：");

        double money = input.nextDouble();


        if (name.equals("Y")){    //判断是否为会员  如果是会员：
            if (money >= 200){
                money = money * 0.7;    //会员且消费大于等于200，打7折
                System.out.println("会员且消费满200，七折优惠，你需要支付" + money + "元人民币，欢迎下次光临！");
            }else if (money < 200 && money >= 0 ){
                money = money * 0.8;    //会员消费小于200，打8折
                System.out.println("会员且消费未满200，八折优惠，你需要支付" + money + "元人民币，欢迎下次光临！");
            }

            else{
                System.out.println("输入的消费金额不合法");    //输入其他数据，如负数，输出“不合法”
            }

        }else if (name.equals("N")){    //如果不是会员
            if (money >=100) {
                money = money * 0.9;    //非会员消费大于等于100，打9折
                System.out.println("非会员且消费满100，九折优惠，你需要支付" + money + "元人民币，欢迎下次光临！");
            }else if (money <100 && money >= 0){
                money = money * 1;    //非会员消费小于100，原价支付
                System.out.println("非会员且未满100，需要原价支付" + money + "元人民币，欢迎下次光临！");

            }else{
                System.out.println("输入的消费金额不合法");    //输入其他数据，如负数，输出“不合法”
            }


        }else {
            System.out.println("注意 由于之前未正确输入否为会员，无法得出应付金额！");    
            //输入除YN的其他数据，输出“无法得出金额”
        }
        input.close();    //关闭流
    }
    
}

switch 多选择结构
- 多选择结构还有一个实现方式就是 switch case 语句
- switch case 语句判断一个变量与一系列值中某个值是否相等，每个值成为一个分支
- 语法：
```
switch(expression){
    case value :
        //语句
        break;//可选
    case value ：
        //语句
        break;//可选
    //你可以有任意数量的 case 语句
    default ： //可选
        //语句
}
```
- switch 语句中的变量类型可以是：
  - byte、short、int 或者 char (示例为 switch多选择结构 1)
  - 从 Java SE 7 开始，switch 支持字符串 String 类型了(示例为 switch多选择结构 2)
  - 同时 case 标签必须为字符串常量或字面量

package Java流程控制;

public class switch多选择结构1 {

    public static void main(String[] args) {

        //case 穿透 ?-1 会解释 //switch 会匹配一个具体的值

        char grade = ‘A‘;

        switch (grade){
            case ‘A‘ :
                System.out.println("优秀");
                break;//输出将会这里停止 (break 为可选) 不会被 case 穿透 ?-1
            case ‘B‘ :
                System.out.println("良好");
                break;//停止输出下面的内容
            case ‘C‘ :
                /* -1 由于下面没有 break，如果输入C 将会把下面全部输出 直到遇到 break
                这就叫 case 穿透现象 (这里输入 C 会在输出 再接再厉 后停止)*/
                System.out.println("及格");
            case ‘D‘ :
                System.out.println("再接再厉");
                break;//停止 case 穿透
            case ‘E‘ :
                System.out.println("挂科");
                break;//停止 case 穿透
            default:
                System.out.println("未知等级");

            /*由于 case穿透现象 的存在，
            所以一般每写一个 case，都应该在后面加上 break */

        }

    }

}

package Java流程控制;

public class switch多选择结构2 {

    public static void main(String[] args) {

        /*从 Java SE 7 开始，switch 支持字符串 String 类型了
        也就是从 JDK7开始 支持字符串的比较了，表达式的结果可以是字符串 */

        /*拓展：这是因为 字符的本质还是数字，编译是java--class(字节码文件)
        在 反编译class(可以用IDEA进行) 之后 发现其实字符串也是根据哈希值比较的 */

        String name = "X";

        switch (name){
            case "低密度脂蛋白":
                System.out.println("低密度脂蛋白");
                break;
            case "木日雨林":
                System.out.println("木日雨林");
                break;
            default:
                System.out.println("???!!!");

        /*怎么用 IDEA 进行反编译？在资源管理器中，将输出的 class文件 拷贝到java类文件夹里
        然后再打开IDEA，打开那个class(字节码文件 图标为01)文件就可以 */

        }

    }

}

4.循环结构

while 循环
- 是最基本的循环，它的结构为
```
while(布尔表达式){
    //循环内容
}
```
- 只要布尔表达式为 true，循环就会一直循环下去
- 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环
- 少部分情况需要循环一直执行，比如服务器的请求响应监听等
- 循环条件一直为true就会造成无限循环（也就是死循环），我们正常的业务编程中，应当尽量避免死循环产生，它会影响程序性能或造成程序卡死/崩溃
- 案例：1、输出 1~100； 2、无限循环； 3、暴力计算 1+2+3+ ... +100 = ?

package Java流程控制;

public class 循环结构_while循环1从1到100 {

    public static void main(String[] args) {

        //输出1~100

        int i = 0;

        while (i < 100){    // i 一旦大于100 表达式就会失效 循环就会结束

            i++;// 每次执行前 都会检查  i 是否 < 100，当为 true 的情况下，将一直执行这个循环

            System.out.println(i);

        }

    }
}

package Java流程控制;

public class 循环结构_while循环2无限循环 {

    public static void main(String[] args) {

        // 无限循环 死循环

        while (true){    //这个循环将一直为 true 无限循环， 如等待客户端连接时、定时检查时...会用到

            System.out.println("123");    //运行代码将会一直输出 123  :(

        }

    }
}

package Java流程控制;

public class 循环结构_while循环3暴力计算 {

    public static void main(String[] args) {

        //用 while 计算 1+2+3+...+100= ?

        int i = 1;
        int sum = 0;

        while (i <= 100){    //当 i 小于等于100 时 执行下面的循环
            sum = sum + i;    //总和 = 当前总和 + 下一个自然数
            i++;    //每计算一次 自增

        }

        System.out.println(sum);

    }
}

do...while 循环
- 对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次
- do ... while 循环和 while 循环相似，不同的是，do ... while 循环至少会被执行一次
```
do {
    //代码语句
}while(布尔表达式);
```
- while 和 do ... while 的区别：
  - while 先判断后执行；do ... while 是先执行后判断
  - do ... while 总是保证循环体至少被执行一次，这是它们的主要差别
- 案例：1、使用 do...while 循环计算1+2+3+ ... +100 = ? ； 2、while 循环和 do...while 循环的对比

package Java流程控制;

public class 循环结构_dowhile循环1暴力计算 {

    public static void main(String[] args) {

        //用 do...while 计算 1+2+3+...+100= ?

        int i = 1;
        int sum = 0;

        do {
            sum = sum + i;
            i ++;
        }while ( i <= 100 );

        System.out.println(sum);

    }

}

package Java流程控制;

public class 循环结构_dowhile循环2和while对比 {

    public static void main(String[] args) {

        int a = 0;

        while (a < 0){
            System.out.println(a);
            a ++;
        }
        System.out.println("==============================");

        do {
            System.out.println(a);
        }while (a < 0);

        /*最后在分割线的下输出了一个 0 。这是由于 while 是先判断 后执行
        在判断 a < 0 不成立后就不执行下面的循环了；
        而 do...while 是先执行 后判断 在执行了一次 也就是输出0 之后
        再判断 a < 0 不成立 就不再次执行循环了 所以只输出一个 0  */

    }

}

for 循环
- 虽然所有循环结构都可以用 while 或者 do...while 表示，但 Java 提供了另一种语句--for 循环，使一些循环结构变得更加简单
- for 循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构
- for 循环执行次数是在执行前就确定的。语法格式如下：
```
for (初始值；布尔表达式（条件判断）；迭代){
    //代码语句
}
```
- 下面代码依次是：
  - 用 while 和 for 实现相同功能的对比
  - 练习1：计算0到100 奇数和偶数的和
  - 练习2：用while或for循环输出1~1000 能被5整除的数，并且每行输出3个
  - 练习3：打印九九乘法表

package Java流程控制;

public class 循环结构_for循环1效率很高 {

    public static void main(String[] args) {

        //用 while 和 for 实现相同功能  的对比

        int a = 1;    //初始化值

        while (a <= 100){    //条件判断

            System.out.println(a);    //循环体 内容

            a += 2;    //迭代  (也就是每一次循环都会将 a 的值刷新)

        }

        System.out.println("while 循环已结束 ！");

        System.out.println("==============================");

        for (int i = 1;i <= 100;i ++){    //括号里分别是 (初始化值；条件判断；迭代)
            // ↑ 这里可以使用快捷键 100.for 回车

            System.out.println(i);

        }

        System.out.println("for 循环已结束 ！");

        /*关于 for 循环有以下几点需要注意：
        最先执行初始化步骤。可以声明一种类型，可初始化一个或者多个循环控制变量，也可以是空语句
        然后，检测布尔表达式的值，如果为 true，循环体被执行；如果为 false，循环终止，跳过循环体 开始执行后面的语句
        执行一次循环后，更新循环控制变量(迭代因子控制循环变量的增减)
        再次检测布尔表达式，循环执行上面的过程

        也就是说 可以没有初始值 没有判断 没有迭代  for (; ; ) { } 会不断循环循环体内容 这就是死循环  */

    }

}

package Java流程控制;

public class 循环结构_for循环2练习1 {

    public static void main(String[] args) {

        //练习1：计算 0 到 100 奇数和偶数的和

        int oddSum = 0;    //定义 oddSum 用来保存奇数的和
        int evenSum = 0;    //定义 evenSum 用来保存偶数的和

        for (int i = 0; i <=100; i++) {    //定义初始化值为：0  判断条件：小于等于100  迭代：每次+1
            if (i%2!=0){    //取模运算: 当i/2的余数 不等于 0 时 也就是为奇数时
                oddSum+= i;    //奇数的和=当前奇数的和 + 下一个得到的奇数
            }else {    //取反  (取模等于 0 ) 时  也就是为偶数时
                evenSum+= i;    //偶数的和=当前偶数的和 + 下一个得到的偶数
            }
            
        }
        System.out.println("0~100奇数的和=" + oddSum + "；偶数的和=" + evenSum + ".");
    }

}

package Java流程控制;

public class 循环结构_for循环3练习2 {

    public static void main(String[] args) {

        //练习2：用 while 或 for 循环 输出 1~1000 能被5整除的数，并且每行输出3个

        for (int i = 5; i <= 1000; i++) {

            if (i % 5 == 0){

                System.out.print(i+"\t");    // "/t"为转义字符 (空格)

            }
            if (i % (5*3) == 0){    //每当 i 能被 15 整除

                System.out.print("\n");    //输出 "\n" (换行)
                //System.out.println();    这段代码也能实现和 ↑ 同样的功能  相当于输出空白然后换行

            }
        }
         //println 输出完会换行； print 输出完不会换行
    }

}

package Java流程控制;

public class 循环结构_for循环4练习3_1打印第一列 {

    public static void main(String[] args) {

        // 打印九九乘法表_1

        /*
        1×1=1
        1×2=2  2×2=4
        1×3=3  2×3=6   3×3=9
        1×4=4  2×4=8   3×4=12  4×4=16
        1×5=5  2×5=10  3×5=15  4×5=20  5×5=25
        1×6=6  2×6=12  3×6=18  4×6=24  5×6=30  6×6=36
        1×7=7  2×7=14  3×7=21  4×7=28  5×7=35  6×7=42  7×7=49
        1×8=8  2×8=16  3×8=24  4×8=32  5×8=40  6×8=48  7×8=56  8×8=64
        1×9=9  2×8=16  3×9=27  4×9=36  5×9=45  6×9=54  7×9=63  8×9=72  9×9=81  */

        for (int i = 1; i <= 9; i++) {
            System.out.println(1 + "*" + i + "="+ 1*i );

        }

        }

    }

package Java流程控制;

public class 循环结构_for循环4练习3_2嵌套 {

    public static void main(String[] args) {

        // 打印九九乘法表_2

        for (int j = 1; j <= 9; j++) {
            for (int i = 1; i <= 9; i++) {
                System.out.println(j + "*" + i + "="+ j*i );
            }

        }

    }

}

package Java流程控制;

public class 循环结构_for循环4练习3_3去除重复 {

    public static void main(String[] args) {

        // 打印九九乘法表_2

        /*总结
        1.先打印第一列，比较简单
        2.把固定的 1 再用一个循环包起来
        3.用 i <= j 判断，去除重复项
        4.调整样式  */

        for (int j = 1; j <= 9; j++) {
            for (int i = 1; i <= j; i++) {
                System.out.print(i + "*" + j + "="+ i*j + "\t");
            }
            System.out.println();
        }

    }

}

在 Java 5 中引入了一种主要用于数组的增强型 for 循环
- 这里只是先了解一下，之后数组会重点使用
- 这是Java 5 引入的一种主要用于数组或集合的增强型 for 循环
- Java 增强 for 循环语法格式：
```
for (声明语句 : 表达式)
{
    //代码句子
}
```
- 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等
- 表达式：表达式是要访问的数组名，或者是返回值为数组的方法

package Java流程控制;

public class 循环结构_增强型for循环 {

    public static void main(String[] args) {

        int [] numbers = {10,20,30,40,50};    //这就是定义了一个数组

        //遍历数组中的元素 ：

        //1.用普通 for 循环

        for (int i = 0; i < 5;i ++){    //定义 i 的初始值 为 0；判断条件 小于5；迭代 自增

            System.out.println(numbers[i]);    //numbers[i] 的意思就是取出数组里面的第 i 个元素
        }

        System.out.println("==============================");

        //2.用 增强型 for 循环

        for (int x:numbers){    //把 numbers 数组里每一项的值 直接赋值给了 int x  也就是简化流程

            System.out.println(x);

        }

    }

}

5.break & continue

break 在任何循环语句的主体部分，均可用 break 控制循环的流程。break 用于强制退出循环，不执行循环中的剩余语句。(break 语句也在 switch 语句中使用可以防止 case 穿透)

package Java流程控制;

public class break和continue1_break {

    public static void main(String[] args) {

        int i = 0;

        while (i < 100){
            i ++;
            System.out.println(i);

            if (i == 30){    //当 i = 30 的时候
                break;    //跳出这个循环 (强制退出循环)

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

        System.out.println(i);
        //这里仍会输出 30 ，这是因为 break 虽跳出了循环，但并没有终止程序
    }

}

continue 语句用在循环语句体中，continue 用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定

package Java流程控制;

public class break和continue2_continiu {

    public static void main(String[] args) {

        int i = 0;

        while (i < 100){
            i++;

            if (i%10 == 0){    //当 i 能被10整除时
                System.out.println();    //换行
                continue;    /*终止这次循环
                (也就是不往下走了 不输出 10 的倍数。而是进行下一次是否执行循环的判定) */
            }
            System.out.print(i);
        }


    }

}

关于 goto 关键字（拓展只需要了解不用完全掌握）
- goto 关键字很早就在程序设计语言中出现。尽管 goto 仍是 Java 的一个保留字，但并未在语言中得到正式使用；Java 没有 goto。然而，在 break 和 continiu 这两个关键字身上，我们仍能看吃 goto 的影子---带标签的 break 和 continiu
- "标签" 是指后面跟着冒号的标识符，例如 label :
- 对 Java 来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于 break 和 continiu 关键字通常只中断当前循环，但若随同标签使用，他们就会中断在存在标签的地方

package Java流程控制;

public class 关于goto关键字_拓展<i> {

    //打印 101 - 150 之间的所有质数

    //质数是在大于1的自然数中，只有1和它本身 两个因数 的自然数

    public static void main(String[] args) {
        int count = 0 ;

        outre:for (int i = 101;i < 150;i ++){
            for (int j = 2;j < i/2;j++){
                if (i % j == 0){    //当能被除了 1 和 小于自己1/2 的数字 整除 的时候
                    continue outre;    //则回到标签的位置 (也就是从内部的循环 跳到了 外部的循环)

        //由于使用起来十分麻烦 不建议使用标签
                }
            }
            System.out.print(i+" ");
        }

    }

}

6.练习

package Java流程控制;

public class 流程控制的练习 {

    public static void main(String[] args) {

        //打印三角形  5 行

        for (int i = 1; i <= 5; i++) {
            for (int j = 5; j >= i ; j --){
                System.out.print(" ");
            }
            for (int j =1; j<= i; j++){
                System.out.print("+");
            }
            for (int j =1; j< i; j++){
                System.out.print("+");
            }
            System.out.println();
        }

    }

}

end .