Java核心基础之分支语句和循环语句

Java核心基础之分支语句和循环语句

Java 是第一大编程语言和开发平台。它有助于企业降低成本、缩短开发周期、推动创新以及改善应用服务。如今全球有数百万开发人员运行着超过 51 亿个 Java 虚拟机， Java 仍是企业和开发人员的首选开发平台。

   

课程内容的介绍

1. Eclipse 的安装操作

2. Scanner 工具类

3. 分支语句

4. 循环语句

  

一、Eclipse安装操作

1.下载安装

官方网站： https://www.eclipse.org/downloads/

   

1.1 官方下载指引

官方推荐的下载链接下载的是一个在线安装启动器，会在线下载对应的 Eclipse 版本，但是官网服务器在国外下载速度会很慢！

下载对应的版本

下载前选择国内的镜像地址下载：

但是要注意： Eclipse 官方提供的最新版本的 Eclipse 要求的 JDK 的最低版本到了 11. 我们课程中给大家介绍的还是JDK8. 所以暂时不推荐大家下载最新的 Eclipse 。

  

1.2 Eclipse的使用

提供给大家的 Eclipse 是一个绿色版本的，直接解压缩即可。

启动 Eclipse --> 设置 workspace 的路径

创建项目

点击左侧菜单栏空白处，鼠标右击，选择 project 即可

创建一个 Java 项目即可

设置项目的信息

点击 Finish 完成即可

   

2.常用的配置

   

2.1 配置JDK

  

2.2 配置字体大小

   

创建 Java 文件，执行 main 方法，比文本编辑器效率要高很多。

   

2.3 字符编码方式

防止后面出现编码相关的问题，我们在开始的时候就设置好编码方式。

   

改了编码方式后之前通过 GBK 所写的中文描述就乱码了，这个是正常的 。

  

要求每一个小伙伴刚开始的时候大家统一设置。

  

二、Scanner类

之前我们书写的程序，数据都是固定不变得，也就是我们都是使用的常量，在实际的开发过程中，数据肯定是动态的而不是固定的，所以我们需要把固定的数据变更为键盘录入。通过Scanner 模拟实际情况。

  

1.package

为了便于管理我们的 Java 文件，我们可以通过创建 package 的方式来处理， package 其实就是文件夹。

  

2.class

  

3.main

在 Eclipse 中，主方法可以在创建类的时候在菜单中勾选，也可以在创建好的 Java 文件手动敲，也可以通过 main 关键字然后 按 alt +/ 的快捷键来生成。

  

4.导包

在 Java 项目中，默认会引入 java.lang.* 下面的所有的类型，我们在使用 lang 包下的所有类型都不用导包，但是当我们要使用其他包下的类型的时候我们就需要通过 import 关键字来实现包的引入，同意可以通过 alt + / 方式快捷导入 也可以通过 ctrl + 1 （感叹号 1 ）。

package com.bobo.scanner;

import java.util.Scanner;
/**
* Scanner案例 键盘输入案例
* 在Java中会自动导入 java.lang.*
* @author dpb
*
*/

public class ScannerDemo {
    public static void main(String[] args) {
        String s1 = "HelloWorld";
        // 1. 创建Scanner对象
        // 在 java.lang.* 下没有找到Scanner类 就报错
        // 2.导入Scanner的包
        Scanner input = new Scanner(System.in);
        // 3. 使用变量接收数据
        // next() 接收一个字符串
        // String ss = input.next();
        // 快速生成输出语句 syso + alt + /
        // System.out.println("ss=" + ss );
        // nextInt() 获取一个整数
        int i = input.nextInt();
        System.out.println("i = " + i);
    }
}

   

如果接受的类型和实际键盘录入的类型不一致会出现如下的错误。

  

三、Java中的语句结构

Java 中我们执行 main 方法中的代码的时候是有执行的先后顺序的，之前所写的代码都从上往下一行行执行了，没有遗落，除非报错，这种执行顺序我们叫 顺序结构， 最简单的结构。

   

1. 顺序结构

程序从上到下一行一行的执行代码，没有判断和中转，写在前面的代码先执行，写在后面的代码后执行。

  

2.分支结构

分支结构又称为选择结构，根据判断的结果判断某些条件，根据判断的结果来控制程序的流程，在这个结构中代码有可能执行一次，也有可能一次也不执行，在Java 中分支结构的具体实现有 if 语句 和switch语句。

if 语句

switch 语句

      

3.循环结构

在满足循环条件的情况下，反复执行特定的代码，特定的代码有可能一次也不执行，也有可能执行了很多遍。

for 循环

while 循环

do while 循环

  

四、分支语句

1.if语句

为什么要用分支结构？

如果小明考试成绩大于 90 分，周末去海底世界游玩，这样的场景我们应该怎么来实现？

1.1 单if语句

语法结构

if ( 关系表达式 ) {
        // 语句体
}

  

针对语法结构的说明：

1. 表达式的类型必须是 boolean 类型，不能是其他类型。

2. 如果 if 语句下面只有一行代码，那么大括号可以省略，但是不推荐省略。

  

执行的流程：

1. 首先判断 if 语句的表达式的结果是 true 还是 false。

2. 如果是 true 那么执行语句体。

3. 如果是 false 不执行语句体。

  

  

案例：

package com.bobo.ifdemo;

import java.util.Scanner;

public class IfDemo01 {
    /**
    * if语句
    * 需求：如果小明考试成绩大于90分，周末去海底世界游玩，
    * 这样的场景我们应该怎么来实现？
    * @param args
    */
    public static void main(String[] args) {
        // 获取一个Scanner对象
        Scanner in = new Scanner(System.in);
        System.out.println("请输入小明的考试成绩: " );
        int score = in.nextInt();
        if (score > 90) {
            System.out.println("周末去海底世界游玩....");
        }
        System.out.println("-------------------");
    }
}

   

面试题：

int i = 99;
if ( i > 100); {
    System.out.println("HelloWorld");
}

   

这段程序有没有问题？如果有问题什么原因？如果没有问题那么输出的结果是什么？

public static void main(String[] args) {
    int i = 99;
    if ( i > 100)
        ; // 这是一行代码
        // 这是一个代码块
        {
        System.out.println("HelloWorld");
    }
}

不会报错，输出的结果是 HelloWorld

   

课堂练习

张三 Java 成绩大于 98 分，而且音乐成绩大于 80 分，老师给他奖励，或者 Java 成绩大于等于 100 分，音乐成绩大于70 分，老师也可以给奖励。

package com.bobo.ifdemo;

import java.util.Scanner;

public class ifdemo03 {
    /**
    * 张三Java成绩大于98分，而且音乐成绩大于80分，老师给他奖励，
    * 或者 Java成绩大于等于100分，音乐成绩大于70分，老师也可以给奖励
    * @param args
    */
    public static void main(String[] args) {
        // 获取 Scanner对象
        Scanner in = new Scanner(System.in);
        System.out.println("请输入张三的Java成绩：");
        int javaScore = in.nextInt();
        System.out.println("请输入张三的音乐成绩：");
        int music = in.nextInt();
        // 表达式可以很简单也可以很复杂，但是最终要求的结果的类型必须是boolean
        // 复杂的表达式 最好通过() 括起来增强可读性
        if( ( javaScore > 98 && music > 80 )|| (javaScore >= 100 && music > 70)) {
            System.out.println("奖励一个苹果");
        }
        System.out.println("*************");
    }
}

   

1.2 if-else语句

如果小明考试成绩大于 90 分，周末去海底世界游玩，否则在家打扫卫生。这样的场景我们应该怎么来实现？

if-else 语句的语法格式：

if(条件表达式){
    // 代码块1
}else{
    // 代码块2
}

   

执行顺序：

1. 判断条件表达式的结果， true 或者 false

2. 如果结果是 true 就执行代码块 1

3. 否则执行代码块 2

案例：

package com.bobo.ifdemo;

import java.util.Scanner;

public class IfDemo04 {
    /**
    * 如果小明考试成绩大于90分，周末去海底世界游玩，否则在家打扫卫生。
    * @param args
    */
    public static void main(String[] args) {
        // 获取一个Scanner对象 shift+Tab
        Scanner in = new Scanner(System.in);
        System.out.println("请输入小明的考试成绩: " );
        int score = in.nextInt();
        /*if (score > 90) {
            System.out.println("周末去海底世界游玩..");
        }
        if (score <= 90) {
            System.out.println("周末在家打扫卫生...");
        }*/
        if (score > 90) {
            System.out.println("周末去海底世界游玩..");
        }else{
            System.out.println("周末在家打扫卫生...");
        }
        // 三目运算符适合比较简单的场景
        String prize = score > 90 ? "周末去海底世界游玩.." : "周末在家打扫卫生...";
        System.out.println("*********" + prize);
    }
}

    

课堂练习：

1. 如果体彩中了 500 万，我买车、资助希望工程、去欧洲旅游，如果没中，我买下一期体彩，继续烧高香。

2. 输入四位数字的会员号的百位数字等于产生的随机数字即为幸运会员，提示恭喜您中奖了，否则没中奖。

提示：生成随机数的方法 int random = (int)(Math.random()*10);

package com.bobo.ifdemo;

import java.util.Scanner;

public class IfDemo05 {
    /**
    * 输入四位数字的会员号的百位数字等于产生的随机数字即为幸运会员，
    * 提示恭喜您中奖了，否则没中奖
    * Math.random(); 获取一个0~1.0 不包含1.0的小树
    * 5678
    * 8 5678%10
    * 7 5678/10%10 5678%100/10
    * 6 5678/100%10 5678%1000/100
    * @param args
    */
    public static void main(String[] args) {
        // 生成一个个位数的随机值
        // System.out.println(Math.random());
        int random = (int)(Math.random()*10);
        System.out.println("random:" + random);
        Scanner in = new Scanner(System.in);
        System.out.println("请输入一个四位数的整数:");
        int code = in.nextInt();
        if(code >= 1000 && code <= 9999){
            // 1000 < code < 9999 5678
            int i = code/100%10; //5678/100%10
            if(i==random){
                System.out.println(random + " 恭喜您成为幸运的会员");
            }
        }else{
            System.out.println("请输入合法的数字...");
        }
        /*System.out.println(5678%10);
        System.out.println(5678/10%10);
        System.out.println(5678%100/10);*/
    }
}

  

1.3 多重if-else语句

有这样一个场景：

老师在批改试卷，成绩在 90 分以上的为优秀，成绩在 80-90 分之间为良好，成绩在 60-80 分之间的为合格，60 分以下的为差，这个应该要怎么来实现？

多重 if-else 语句语法：

if (条件1) {
    // 代码1
}else if(条件2){
    // 代码2
}else if(条件3){
    // 代码3
}...{
}else{
    // 代码N
}

   

执行顺序：

1. 判断条件 1, 结果为 true 或者 false。

2. 如果为 true ，直接执行代码 1 ，然后结束。

3. 如果为 false ，那么看条件 2 是否为 true。

4. 如果为 true ，直接执行代码 2。

5. 否则判断条件 3 以此类推，如果所有的 else - if 语句都返回的是 false ，那么执行 else 中的代码。

  

注意：

1. else if 可以有 0 到多个。

2. else 语句最多只能有一个。

   

案例：

package com.bobo.ifdemo;

import java.util.Scanner;

public class IfDemo06 {
    /**
    * 老师在批改试卷，成绩在90分以上的为优秀，
    * 成绩在80-90分之间为良好，
    * 成绩在60-80分之间的为合格，
    * 60分以下的为差，
    * @param args
    */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入考试成绩：" );
        int score = in.nextInt();
        String info = "";
        if (score >= 90) {
            info = "成绩优秀";
        }else if(score >=80 ){
            info = "成绩良好，继续加油";
        }else if (score >= 60) {
            info = "成绩刚好及格，努力加油";
        }else {
            info = "成绩很差，明天叫家长过来....";
        }
        System.out.println(info);
    }
}

   

课堂练习：

键盘输入一个月份值，然后输出对应的季节。

package com.bobo.ifdemo;

import java.util.Scanner;

public class IfDemo07 {
    /**
    * 键盘输入一个月份值，然后输出对应的季节
    * @param args
    */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入一个月份");
        int month = in.nextInt();
        if(month >= 1 && month <= 12){
            if( month <= 3){
                // 表示是春季
                System.out.println(month + "月份对应的是春季");
            }else if(month <= 6){
                System.out.println(month + "月份对应的是夏季");
            }else if(month <= 9){
                System.out.println(month + "月份对应的是秋季");
            }else{
                System.out.println(month + "月份对应的是冬季");
            }
        }else{
            System.out.println("请输入一个合法的月份...");
        }
    }
}

   

1.4 嵌套if语句

语法结构：

if(条件1){
    if(条件2){
        // 代码1
    }else{
        // 代码2
    }
}else{
    // 代码3
}

   

执行流程：

1. 首先判断条件 1 是否为 true。

2. 为 true 再判断条件 2 是否为 true。

3. 条件如果为 true 执行代码 1 ，否则执行代码 2。

4. 条件 1 为 false ，则执行代码 3。

  

2.switch语句

2.1 switch语句介绍

switch 语句是根据表示的不同的值做出不同的执行的，针对特定的值来出来。

语法格式：

switch(表达式){
    case 值1:
        代码1;
        break;
    case 值2:
        代码2:
        break;
    ....N
    default:
    默认语句;
    break;
}

   

注意：

1. 表达式的值得类型必须是如下几种 (int shor byte char String) String 是 jkd7 之后支持的。

2. case 子句中的取值必须是常量，且所有 case 子句中的取值是不同的。

3. case 子句中农的取值数据类型必须是表达式返回值得类型。

4. default 子句是可选的，同时 default 块顺序可以变动，但要注意执行顺序，通常 default 块放在末尾，也可以省略。

5. break 语句的作用是在执行完一个 case 分支后是程序跳出 switch 语句块。

   

案例：

package com.bobo.switchdemo;

import java.util.Scanner;

public class SwitchDemo01 {
    /**
    * 模拟：拨打中国电信客户的案例
    * 按1：办理快带业务
    * 按2：办理手机业务
    * 按3：办理投诉业务
    * 按4：转人工服务
    * 没有上面的选项： 对不起您的输入有误
    * @param args
    */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入您服务编号：");
        int num = in.nextInt();
        switch (num) {
            case 1:
                System.out.println("办理快带业务");
                break;
            case 2:
                System.out.println("办理手机业务");
                break;
            case 3:
                System.out.println("办理投诉业务");
                break;
            case 4:
                System.out.println("转人工服务");
                break;
            default:
                System.out.println("对不起您的输入有误");
            break;
        }
    }
}

   

2.2 switch和if对比

if 语句

1. 表达式的结果是 boolean 类型。

2. 常用于区间的判断。

   

switch 语句

1. 表达式的类型不能是 boolean 类型，可以是 byte ， short ， int ， char 和 String 枚举类型。

2. 常用于等值判断。

   

选择语句的选取

1. 能 switch 语句实现的就一定能够有 if 语句实现，但是反之就不一定了。

2. 如果是区间范围的采用 if 语句，如果是等值判断的使用 switch 语句。

    

2.3 经典switch面试题

1. 若 a 和 b 均是整型变量并已正确赋值，正确的 switch 语句是 ( ) 。

        A) switch(a+b); { ...... }           B) switch( a+b*3.0 ) { ...... }

        C) switch a { ...... }                 D) switch ( a%b ) { ...... }

2. 设 int 型变量 a 、 b ， float 型变量 x 、 y ， char 型变量 ch 均已正确定义并赋值，正确的 switch 语句是( ) 。

        A) switch (x + y) { ...... }         B) switch ( ch + 1 ) { ...... }

        C) switch ch { ...... }               D) switch ( a + b ); { ...... }

3. 下列语句序列执行后， k 的值是 ( ) 。

        int x = 6, y = 10, k = 5;

        switch (x % y) {

                case 0:

                        k = x * y;

                case 6:

                        k = x / y;

                case 12:

                        k = x - y;

                default:

                        k = x * y - x;

        }

        A) 60         B) 5         C) 0         D) 54

4. 下列语句序列执行后， k 的值是 ( ) 。

        int i = 10, j = 18, k = 30;

        switch (j - i) {

                case 8:

                        k++;

                case 9:

                        k += 2;

                case 10:

                        k += 3;

                default:

                        k /= j;

         }

        A) 31         B) 32         C) 2         D) 33

5. 下列语句序列执行后， r 的值是 ( )

        char ch = '8';

        int r = 10;

        switch (ch + 1) {

                case '7':

                        r = r + 3;

                case '8':

                        r = r + 5;

                case '9':

                        r = r + 6;

                        break;

                default:

                        r = r + 8;

        }

        A) 13         B) 15         C) 16         D) 18

6. 下面语句运行结果为：（）

        switch (5) {

                default:

                        System.out.println(5);

                        break;

                case 0:

                        System.out.println(0);

                        break;

                case 1:

                        System.out.println(1);

                        break;

                case 2:

                        System.out.println(2);

                        break;

         }

        A) 0         B) 1         C) 2         D) 5

7. 下面语句运行结果为：（）

        switch (5) {

                default:

                        System.out.print(5);

                case 0:

                        System.out.print(0);

                case 1:

                        System.out.print(1);

                        break;

                case 2:

                        System.out.print(2);

                        break;

                }

        A) 1         B) 5         C) 0         D) 501

  

五、循环语句

循环语句就是重复执行某块代码，能够大大提高我们的效率。

/**
* 输出一个 好好学习，天天向上 这个信息到控制台上
* 输出两遍
* 10遍呢
* 100遍
* 10000遍？
* @param args
*/
public static void main(String[] args) {
    /*System.out.println("好好学习，天天向上");
    System.out.println("好好学习，天天向上");
    System.out.println("好好学习，天天向上");
    System.out.println("好好学习，天天向上");
    System.out.println("好好学习，天天向上");
    System.out.println("好好学习，天天向上");
    System.out.println("好好学习，天天向上");
    System.out.println("好好学习，天天向上");
    System.out.println("好好学习，天天向上");
    System.out.println("好好学习，天天向上");*/
    for(int i = 0 ; i < 10000 ; i ++){
        System.out.println("好好学习，天天向上 : " + i);
    }
}

生活中循环的例子

  

1.for循环

1.1 for循环的语法格式

for( 表达式1 ; 表达式2 ; 表达式3 )
{
    // 循环体语句
}

   

语法格式说明：

for( 初始化语句 ; 循环条件语句 ; 控制条件语句 )
{
    // 循环体语句
}

   

1.2 for循环的执行流程

  

1.3 课堂案例

1. 控制台输出数据 1-1。

2. 计算 1 到 100 的和，用 for 语句实现。

3. 求 1~100 之间不能被 3 整除的数的和。

  

案例代码

/**
* 控制台输出数据1-10
* @param args
*/
public static void main(String[] args) {
    // 添加注释的快捷键 多行注释 ctrl + shift + /
    /*for (int i = 0 ; i < 10 ; i ++) {
        System.out.println(i+1);
    }*/
    // 循环案例的实现 单行注释 Ctrl+/
    for (int i = 1 ; i <= 10 ; i ++) {
        System.out.println(i);
    }
}

/**
* 计算1到100的和，用for语句实现
* @param args
*/
public static void main(String[] args) {
    // 在for循环之外创建一个变量 来接收我们的数据 相当于一个 容器
    int total = 0 ; // 保存计算结果
    for ( int i = 1 ; i <= 100 ; i ++) {
        total += i; // 将变量的结果累加到到total中
    }
    System.out.println(total);
}

package com.bobo.fordemo;

public class ForDemo04 {
    /**
    * 求1~100之间不能被3整除的数的和
    * 1.先找到所有不能被3整除的数
    * 2.将找到的数累加即可
    * @param args
    */
    public static void main(String[] args) {
        int total = 0;
        for( int i = 1 ; i <= 100 ; i ++){
            if (i % 3 != 0) {
                // 表示不能被3整除
                // System.out.println(i);
                total += i;
            }
        }
        System.out.println("1~100之间不能被3整除的数的和：" + total);
    }
}

   

扩展案例：

1. 求 n 的阶乘 9 * 8 * 7 * ... * 1

package com.bobo.fordemo;

import java.util.Scanner;

public class ForDemo05 {
    /**
    * 求n的阶乘 9 * 8 * 7 * ... * 1
    * 5的阶乘
    * 5 * 4 * 3 * 2 * 1
    * 1 * 2 * 3 * 4 * 5
    * 其实和 1 到 N的整合的和 效果是一样
    * @param args
    */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("输入阶乘的值：" );
        int num = in.nextInt();
        int total = 1 ; // 记录阶乘结果的变量
        for( int i = 1 ; i <= num; i++){
            total *= i;
        }
        System.out.println(num + "的阶乘是：" + total);
    }
}

  

2. 实现如下的效果

请输入一个值：
根据这个值可以输出如下的加法表：
0 + 6 = 6
1 + 5 = 6
2 + 4 = 6
3 + 3 = 6
4 + 2 = 6
5 + 1 = 6
6 + 0 = 6

package com.bobo.fordemo;

import java.util.Scanner;

public class ForDemo06 {
    /**
    * 请输入一个值：
    根据这个值可以输出如下的加法表：
    0 + 6 = 6
    1 + 5 = 6
    2 + 4 = 6
    3 + 3 = 6
    4 + 2 = 6
    5 + 1 = 6
    6 + 0 = 6
    i + (6-i) = 6
    循环N次，每次循环打印一条输出语句
    * @param args
    */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入一个1-9之间的数字" );
        int num = in.nextInt();
        for (int i = 0 ; i <= num ; i++) {
            System.out.println(i + " + " + (num - i ) + " = " + num);
        }
        System.out.println("------------");
        // 第二种方式 通过多个变量来控制
        for (int i = 0, j = num ; i <= num ;i++,j--) {
            System.out.println(i + " + " + j + " = " + num);
        }
        System.out.println("------------");
        // 第二种方式 通过多个变量来控制
        for (int i = 0, j = num ; j >= 0 ;i++,j--) {
            System.out.println(i + " + " + j + " = " + num);
        }
    }
}

   

3. 在控制台输出所有 5 位数的回文数字

注意：回文数如 12321,13531 等等 ... 11111

package com.bobo.fordemo;

public class ForDemo07 {
    /**
    * 在控制台输出所有5位数的回文数字
    注意：回文数如 12321,13531 等等... 11111
    解决思路：
    1.遍历找出所有的5位数
    2.分离出遍历的数字的 万位 千位 十位 个位
    3.判断如果 万位和个位相等 同时 千位和十位相等 说明是我们要找的数字
    * @param args
    */
    public static void main(String[] args) {
        for(int i = 10000; i < 100000 ; i ++ ){
            int ge = i / 1 % 10;
            int shi = i / 10 % 10;
            int qian = i / 1000 % 10;
            int wan = i / 10000 % 10;
            if (ge == wan && shi == qian) {
                System.out.println(i);
            }
        }
    }
}

   

4. 在控制台输出 1000 以内的所有的水仙花数，并统计水仙花数的个数。

注意：水仙花数指的是其各位数的立方和等于该数本身的三位数

153 = 1^3 + 5^ + 3^ = 153

package com.bobo.fordemo;

public class ForDemo08 {
    /**
    * ctrl + d 快速删除一行
    *
    * 在控制台输出1000以内的所有的水仙花数，并统计水仙花数的个数。
    注意：水仙花数指的是其各位数的立方和等于该数本身的三位数
    153 = 1^3 + 5^3 + 3^3 = 1 + 125 + 27 =153
    解决思路：
    1.遍历出所有的数字
    2.对遍历的数字，拆分出 个位 十位 百位
    3.判断 个位的立方+ 十位的立方 + 百位的立方 是否等于遍历的数字本身
    4.是 输出这个结果 统计变量+1
    5.不是 不做任何处理
    * @param args
    */
    public static void main(String[] args) {
        int count = 0 ; // 统计水仙花数的个数
        for (int i = 0 ; i <= 1000; i ++) {
            int ge = i / 1 % 10;
            int shi = i / 10 % 10;
            int bai = i / 100 % 10;
            /*if(ge * ge * ge + shi * shi * shi + bai* bai * bai == i){
                System.out.println(i);
                count ++;
            }*/
            if (Math.pow(ge, 3) + Math.pow(shi, 3) + Math.pow(bai, 3) == i) {
                System.out.println(i);
                count ++;
            }
        }
        System.out.println("1000以内的水仙花数是：" + count);
    }
}

   

1.4 for循环的注意事项

1.4.1 大括号可以省略

如果循环体大括号省略 ，循环体默认执行 for 语句后面的第一条语句 (; 结尾 )。

public class ForDemo09 {
    public static void main(String[] args) {
        // 作用域：i 的作用域 是在for循环以内 表达式 1 2 3 4 中使用
        for(int i = 0 ; i < 4 ; i ++)
        //;
        System.out.println(i);// 这个是我们的循环体
        System.out.println("---------");
    }
}

   

1.4.2 表达式2的值是一个boolean类型

表达式 2 如果有多个条件我们需要用逻辑运算符连接。

int a = 10;
int b = 20;
for(int i = 0 ; i < 10 && (a > 0 || b < 30) ; i ++){
}

   

1.4.3 表达式2可以省略，但是";"不能省略

如果表达式 2 省略的话，那么程序会一直执行，直到资源耗尽，死循环。

public static void main(String[] args) {
    for ( int i = 0 ; ; i ++) {
        System.out.println("-->" + i);
    }
}

   

1.4.4 表达式1 省略，表达式3省略

表达式 1 和表达式 3 也省略。

package com.bobo.fordemo;

public class ForDemo11 {
    /**
    * 表达式1 初始化变量的
    * @param args
    */
    public static void main(String[] args) {
        int i = 0; // 表示i的作用域在方法中
        for (; i < 10 ;) {
            System.out.println(i);
            // 将表达式4的信息 写到循环体的尾部
            i ++;
        }
        /*for ( int i = 0 ; i < 10; i++) {
        }*/
    }
}

   

1.4.5 表达式123都可以省略

表达式 123 都可以省略，但是两个 ";" 是不能够省略的 , 出现死循环的情况。

public class ForDemo12 {
    /**
    * 表达式1 初始化变量的
    * @param args
    */
    public static void main(String[] args) {
        for(;;){
            System.out.println("----");
        }
    }
}

   

2.while循环

while 是 Java 使用频率也比较高的一种循环方式。 while 语句的语法结构要比 for 循环简单些。

  

2.1 语法格式

while (条件表达式) {
    // 循环语句
}

/**
* while循环
* @param args
*/
public static void main(String[] args) {
    int i = 0;
    while( i < 10){
        System.out.println("i = " + i);
        i ++ ;
    }
    System.out.println("循环结束...");
}

   

2.2 while语句的执行顺序

1. 首先判断条件表达式结果是为 true 还是 false。

2. 如果结果是 true ，执行循环体。

3. 如果结果是 false ，退出循环体。

   

这里面为了便于大家的理解，可以将 while 循环看出 for 循环的一种简化形式。

for( 表达式1 ; 表达式2 ; 表达式3 ){
    循环体
}
--->
表达式1
for( ; 表达式2 ; ){
    循环体;
    表达式3
}

   

对应的 while 循环。

表达式1
while (表达式2){
    循环体
    表达式3
}

   

2.3 课堂案例

1.用while语句去实现1到100的和。

package com.bobo.whiledemo;

public class WhileDemo02 {
    /**
    * 用while语句去实现1到100的和
    * @param args
    */
    public static void main(String[] args) {
        int total = 0; // 记录总和
        int i = 1; // 声明的变量
        while( i <= 100){
            total += i;
            // 改变循环条件
            i ++; // 不能漏掉，不然会 死循环
        }
        System.out.println("1到100的和是：" + total);
    }
}

  

2.用while语句实现1到100偶数的和。

package com.bobo.whiledemo;

public class WhileDemo03 {
    /**
    * 用while语句实现1到100偶数的和
    * @param args
    */
    public static void main(String[] args) {
        int total = 0;
        int i = 0;
        while( i <= 100){
            if( i % 2 == 0){
                // 表示循环的数字是偶数
                total += i;
            }
            i++;
        }
        System.out.println("1到100之间的偶数和是：" + total);
        // 重置我们的信息
        i = 0;
        total = 0;
        while( i <= 100){
            if (i %2 != 0){
                i++;
            }
            // 表示循环的数字是偶数
            total += i;
            i += 2; // 改变循环条件，每次自增2
        }
        System.out.println("1到100之间的偶数和是：" + total);
    }
}

   

3.将前面讲的for循环中的案例该为通过while循环来实现。

  

3.do while循环

3.1 语法格式

do while 循环的特点：先执行一次循环体，然后在判断条件是否成立。

do{
    循环语句;
}while ( 条件表达式 ) ;

public static void main(String[] args) {
    int i = 0 ;
    do{
        // 循环在循环条件判断之前执行一次
        System.out.println("----" + i);
    }while(i < 0);
    System.out.println("循环执行结束...");
}

  

3.2 执行顺序

1. 先执行循环语句一次。

2. 然后判断条件语句的返回结果是 true 还是 false。

3. 如果是 true 再执行一次循环体，然后判断条件语句。

4. 如果是 false ，那么直接退出循环。

  

  

3.3 课堂案例

1. 使用 do-while 语句去实现 1 到 100 的和。

2. 使用 do-while 循环实现 1-100 的偶数求和。

3. 使用 do-while 循环实现 for 循环中的所有的案例。

  

4. while循环和for循环的对比

1. for 循环和 while 循环都是先判断再执行， do-while 是先执行再判断，并且一定会执行一次循环体。

2. 在循环结束之后，还希望能够使用循环变量，使用 while 循环，否则使用 for 循环， for 循环的变量 i只能作用于循环体。

3. 死循环的方式。

   

while:

while (true) {}

   

do -while:

do{
}while(true);

   

for:

for (;;){
}

   

循环方式的选择：

1. 如果循环条件是一个区间范围 ( 循环次数确定的 ) ，推荐使用 for 循环。

2. 如果循环次数不明确的情况下，推荐使用 while 循环。

3. 在第二个基础上如果要先执行再判断就使用 do-while 循环，否则使用 while 循环。

  

场景引入：

请在控制台输出如下的图形
********
********

public static void main(String[] args) {
    // TODO Auto-generated method stub
    System.out.println("********");
    System.out.println("********");
    System.out.println("********");
}

  

5.嵌套循环

5.1 嵌套循环的格式

最常用的方式：

for(表达式1 ; 表达式2 ; 表达式3){
    for(表达式1 ; 表达式2 ; 表达式3){
    }
}

   

其他的组合

for(表达式1 ; 表达式2 ; 表达式3){
    while(表达式){
    }
}

while(表达式){
    while(表达式){
    }
}

do{
    for(表达式1 ; 表达式2 ; 表达式3){
    }
}while(表达式);

  

...

  

5.2 嵌套循环的规则

1. 外层循环控制行数，内层循环控制列数。

2. 外层循环变量变化以此，内层循环变量要变化一轮。

  

5.3 课堂案例

1.打印如下的图案

********
********
********

package com.bobo.forfor;

public class QTDemo01 {
    /**
    * 请在控制台输出如下的图形
    * ********
    ********
    ********
    * @param args
    */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*System.out.println("********");
        System.out.println("********");
        System.out.println("********");*/
        for(int i = 0 ; i < 8; i ++){
            System.out.print("*");
        }
        System.out.println(); // 显示的换行
        for(int i = 0 ; i < 8; i ++){
            System.out.print("*");
        }
        System.out.println();// 显示的换行
        for(int i = 0 ; i < 8; i ++){
            System.out.print("*");
        }
        System.out.println();// 显示的换行
        System.out.println("------------------");
        /*
        * 1. 外层循环控制行数，内层循环控制列数
        * 2. 外层循环变量变化以此，内层循环变量要变化一轮
        */
        for (int i = 0 ; i < 3 ; i ++) { // 外层循环控制行数
            for( int j = 0 ; j < 8 ; j ++){ // 内层循环控制列数
                System.out.print("*");
            }
            System.out.println(); // 内层循环走完一遍 显示的换行
        }
    }
}

   

2.打印如下图案，直角三角形

*
**
***
****
*****
******

package com.bobo.forfor;

public class QTDemo02 {
    /**
    * 输出如下图案
    * *
    **
    ***
    ****
    *****
    ******
    1. 外层循环控制行数，内层循环控制列数
    2. 外层循环变量变化以此，内层循环变量要变化一轮
    * @param args
    */
    public static void main(String[] args) {
        for(int i = 0 ; i < 6 ; i ++){
            // i = 0 1*
            // i = 1 2*
            // i = 2 3*
            // ...
            for(int j = 0 ; j < i +1 ; j ++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

   

3.打印如下图案，直角三角形

*
***
*****
*******
*********

package com.bobo.forfor;

public class QTDemo03 {
    /**
    * 输出如下图案
    * *
    ***
    *****
    *******
    *********
    ***********
    1. 外层循环控制行数，内层循环控制列数
    2. 外层循环变量变化以此，内层循环变量要变化一轮
    * @param args
    */
    public static void main(String[] args) {
        for(int i = 0 ; i < 6 ; i ++){
            // i = 0 1*
            // i = 1 3*
            // i = 2 5*
            // ...
            for(int j = 0 ; j < 2 * i +1 ; j ++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

   

4.打印九九乘法表

package com.bobo.forfor;

public class QTDemo04 {
    /**
    * 打印九九乘法表
    * 1*1=1
    * 1*2=2 2*2=4
    * 1*3=3 2*3=6 3*3=9
    * ....
    * 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=72 ... 9*9=81
    *
    * i = 1 1个表达式
    * i = 2 2个表达式
    * ..
    * i = 9 9个表达式
    * @param args
    */
    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();
        }
    }
}

  

5.计算若干个学生5门课的平均分。

package com.bobo.forfor;

import java.util.Scanner;

public class QTDemo05 {
    /**
    * 计算若干个学生5门课的平均分。
    * 提示：
    * 外层循环一次处理一个学生
    * 内层循环一遍处理一个学生的五门成绩
    * @param args
    */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("输入学生的个数：");
        int num = in.nextInt();
        for(int i = 1 ; i <= num ; i ++){
            double sum = 0.0 ; // 记录当前学生的总成绩
            for(int j = 0 ; j < 5 ; j ++){ // 五门课程 内层循环5次
                // 获取该学生的每门课程的成绩
                double score = 0.0;
                System.out.println("请输入第" + i + "个学生的第" + (j+1) + "门的成绩");
                score = in.nextDouble();
                sum += score;
            } // 通过一次内层循环获取到该学生的总成绩
            System.out.println("第" + i + "个学生的平均成绩是：" + sum/5);
        }
    }
}

   

6.break、continue、return关键字

6.1 break关键字

6.1.1 break关键字介绍

在循环过程中我们要跳出循环的时候那么可以通过 break 关键字来实现，改变程序控制流。

用户do-while 、 while 、 for 循环中，可以跳出循环而执行循环以后的语句。

  

6.1.2 使用的场合

1. 循环语句中 ( 单层循环、嵌套循环 )。

2. switch 语句。

  

6.1.3 课堂案例

1. 打印 1 到 10 个数，遇到 4 的倍数程序自动退出。

package com.bobo.breakdemo;

public class BreakDemo01 {
    /**
    * 打印1到10个数，遇到4的倍数程序自动退出
    * @param args
    */
    public static void main(String[] args) {
        for( int i = 1 ;i <= 10 ; i++){
            if(i % 4 == 0){
                break; // 跳出循环 执行之后的代码
            }
            System.out.println(i);
        }
        System.out.println("程序结束...");
    }
}

   

2. 循环录入学生成绩，求和。如果输入的成绩为负数。则停止输入，给出错误的提示。

package com.bobo.breakdemo;

import java.util.Scanner;

public class BreakDemo02 {
    /**
    * 循环录入学生成绩，求和。如果输入的成绩为负数。则停止输入，给出错误的提示
    * @param args
    */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int sum = 0;
        int i = 1; // 记录循环的次数
        while(true){
            System.out.println("请输入第" + i + "个学生的成绩：");
            int score = in.nextInt();
            if(score < 0){
                // 表示是负数
                System.out.println("你输入的数据有误！！！");
                break; // 退出循环
            }
            sum += score;
            System.out.println("sum = " +sum);
            i++;
        }
    }
}

   

3. 嵌套循环中的 break ；只能跳出包裹的那层循环。

package com.bobo.breakdemo;

import java.util.Scanner;

public class BreakDemo02 {
    /**
    * 循环录入学生成绩，求和。如果输入的成绩为负数。则停止输入，给出错误的提示
    * @param args
    */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int sum = 0;
        int i = 1; // 记录循环的次数
        while(true){
            System.out.println("请输入第" + i + "个学生的成绩：");
            int score = in.nextInt();
            if(score < 0){
                // 表示是负数
                System.out.println("你输入的数据有误！！！");
                break; // 退出循环
            }
            sum += score;
            System.out.println("sum = " +sum);
            i++;
        }
    }
}

   

6.2 continue 关键字

作用： continue 关键字用于跳过某个循环语句的一次执行，下一次循环还会继续。

使用的场合：跳过循环体中剩余的语句而执行下一次循环。

package com.bobo.continuedemo;

import java.util.Scanner;

public class ContinueDemo01 {
    /**
    * 循环录入Java课程的学生成绩，统计分数大于等于80分的学生比例
    * 分析：
    * 1.通过循环获取分数大于等于80分的学生人数num
    * 2.判断成绩是否<80分，满足条件不执行num++,直接进入下一次循环
    * @param args
    */
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入班级总的人数：");
        int count = input.nextInt();
        int num = 0 ; // 记录成绩大于等于80分的人数
        for(int i = 0 ; i < count ; i ++){
            System.out.println("请输入第" + i + "个学生的成绩:");
            int score = input.nextInt();
            if(score < 80){
                continue;
            }
            num++;
        }
        System.out.println("80分以上的人数：" + num);
        System.out.println("80分以上的人数的比例：" + num/(double)count);
    }
}

   

6.3 break和continue的对比

使用场合

1. break 可以用于 switch 语句和循环结构中。

2. continue 只能用于循环结构中。

作用：

1. break 语句终止某个循环，程序跳转到循环块外的下一条语句。

2. continue 跳出本次循环，进入下一次循环。

    

6.4 课外练习

1. 循环录入会员信息。

package com.bobo.continuedemo;

import java.util.Scanner;

public class ContinueDemo02 {
    /**
    * 循环录入会员信息
    * @param args
    */
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("MyShopping管理系统....");
        for(int i = 0 ; i < 3 ; i ++){
            System.out.println(i + "请输入会员号<4位整数>");
            int vipNumber = input.nextInt();
            System.out.println("请输入会员生日(月/日 用俩位整数表示):");
            String birthday = input.next();
            System.out.println("请输入会员的积分：");
            int score = input.nextInt();
            if( !(vipNumber >=1000 && vipNumber < 10000)){
                System.out.println("客户号" + vipNumber + "无效");
                System.out.println("录入信息失败...");
                continue;
            }
            System.out.println("您录入的会员信息是:");
            System.out.println(vipNumber + "\t" + birthday + "\t" + score);
        }
    }
}

  

2. 模拟验证用户登录信息

录入成功：

package com.bobo.continuedemo;

import java.util.Scanner;

public class ContinueDemo03 {
    /**
    * 模拟用户登录操作
    * 情况：
    * 1.登录成功
    * 2.登录失败，提示可以使用的登录次数，
    * 3.登录失败的次数超过了规定的次数，就不让再登录
    * @param args
    */
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        for(int i = 0 ; i < 3 ; i ++){ // 循环控制登录的次数
            System.out.println("请输入登录的账号：" );
            String userName = input.next();
            System.out.println("请输入密码：");
            String password = input.next();
            // 判断账号密码是否正确 admin 123456
            if("admin".equals(userName) && "123456".equals(password)){
                // 表示登录成功
                System.out.println("欢迎光临MyShopping管理系统....");
                break; // 跳出循环
            }
            // 表示登录失败
            if(i == 2){
                System.out.println("对不起，您3次机会都输入错误~~");
                continue;
            }
            System.out.println("认证失败，您还有" + (2-i) + "次机会");
        }
    }
}

  

6.5 return关键字

return 关键字的作用是从当前方法中退出。返回到调用该方法的语句处，并且从该语句的下一条语句处开始执行。