Java流程控制
[编程语言教程]

Java流程控制

1.用户交互Scanner

Scanner对象

  • 之前我们学习的基本语法中,并没有实现程序和人的交互,但是Java给我们提供了这样一个工具类,我们可以获取用户的输入。java.util.Scanner,它是 Java5 的新特性,我们可以通过Scanner 类来获取用户输入
  • 基本语法:
Scanner s = new Scanner(System.in);
  • 通过 Scanner 类的 next() 与 nextLine() 方法获取输入的字符串,在读取前我们一般需要使用 hasNext() 与 hasNextLine() 判断是否还有输入的数据

Scanner对象的分类

  1. 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();
    }

}
  1. 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"为转义字符 (空格)

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

                System.out.print("
");    //输出 "
" (换行)
                //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 + "	");
            }
            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 .

Java流程控制

原文地址:https://www.cnblogs.com/muriyulin/p/14520822.html

hmoban主题是根据ripro二开的主题,极致后台体验,无插件,集成会员系统
自学咖网 » Java流程控制