03-引用变量，选择与循环语句，猜数字小游戏案例

最新推荐文章于 2023-05-28 14:10:33 发布

Vanessa_wanglu

最新推荐文章于 2023-05-28 14:10:33 发布

阅读量389

点赞数

分类专栏： java基础大数据开发文章标签： java

本文链接：https://blog.csdn.net/weixin_38847462/article/details/79237866

版权

大数据开发同时被 2 个专栏收录

26 篇文章 0 订阅

订阅专栏

java基础

6 篇文章 0 订阅

订阅专栏

Java基础语法
1、引用类型变量的创建及使用
2、流程控制语句之选择语句
3、流程控制语句之循环语句
4、循环高级

01创建引用类型变量公式

* A: 创建引用类型变量公式
    * a: 我们要学的Scanner类是属于引用数据类型，我们先了解下引用数据类型。
    * b: 引用数据类型的定义格式
        * 与定义基本数据类型变量不同，引用数据类型的变量定义及赋值有一个相对固定的步骤或格式。
        * 数据类型  变量名  =  new 数据类型();
    * c: 引用数据类型的使用
        * 每种引用数据类型都有其功能，我们可以调用该类型实例的功能。
        * 变量名.方法名();

02Scanner类的使用

* A: Scanner类的使用
    * a: 导包import java.util.Scanner;
    * b：创建键盘录入对象 Scanner sc = new Scanner(System.in);
    * c: 读取键盘录入的一个整数
        * int enterNumber = sc.nextInt();
    * d: 读取键盘录入的字符串
        * String enterString = sc.next();
* B: 案例代码

       import java.util.Scanner;
        public class Demo05Scanner{
            public static void main(String[] args)
            {
                Scanner sc = new Scanner(System.in);
                int enterNumber = sc.nextInt();
                System.out.println("用户输入的整数为"+enterNumber);
                String enterString = sc.next();
                System.out.println("用户输入的字符串为"+enterString);
            }
        }

03Random随机数类的使用_1

* A: Random随机数类的使用_1
    * a: 功能
        * 生成随机数需要使用到引用类型随机数Random类
    * b: 使用方式
        * import导包：所属包java.util. Random
        * 创建实例格式：Random  random = new Random ();
        * 调用方法
            * nextInt(int maxValue)    产生[0,maxValue)范围的随机数,包含0不包含maxValue
            * nextDouble()  产生[0,1)范围的随机数
            如：
                Random  random = new Random ();
                int  myNumber = random.nextInt(100);//结果为0-99的一个数
* B: 案例代码

      import java.util.Random;
        public class RandomDemo{
            public static void main(String[] args){
               Random ran = new Random();
               // Random类中的,产生随机数的功能
               int i = ran.nextInt(100);
               System.out.println(i);

               //问题? 产生随机数,范围 1-100之间
               // nextInt(100) 0-99 + 1
            }
        }

04Random随机数类的使用_2

* A: Random随机数类的使用_2
    * a: 调用方法
        * nextDouble()  产生[0,1)范围的随机数
        如：
            Random  random = new Random ();
            int  myNumber = random.nextDouble();//结果为0.0-1.0之间的数(包括0.0不包括1.0)

05if语句格式第一种

* A: if语句格式第一种
    * a: 书写格式
        if(比较表达式) {
            语句体;
        }
    * b：执行流程：
        * 先计算比较表达式的值，看其返回值是true还是false。
        * 如果是true，就执行语句体；
        * 如果是false，就不执行语句体；
* B: 案例代码

      public class IfDemo{
            public static void main(String[] args){
                  int i = 5 ;
                  //对变量i进行if判断
                  if(i > 5){
                      System.out.println("if中的条件是true");
                      i++;
                  }

                  System.out.println(i);
            }
        }

06if语句格式第二种

* A: if语句格式第二种
    * a: 书写格式
        if(比较表达式) {
            语句体1;
        }else {
            语句体2;
        }
    * b：执行流程：
        * 首先计算比较表达式的值，看其返回值是true还是false。
        * 如果是true，就执行语句体1；
        * 如果是false，就执行语句体2；
* B: 案例代码

       public class IfElseDemo{
            public static void main(String[] args){
                 int i = 16 ;
                 //判断变量,是奇偶数, 除以2,看余数是0还是1
                 if( i % 2 == 0 ){
                     System.out.println(i+" 是偶数");
                 }else{
                     System.out.println(i+" 是奇数");
                 }
            }
        }

07if语句格式第三种

* A: if语句格式第三种
    * a: 书写格式
            if(比较表达式1) {
                语句体1;
            }else if(比较表达式2) {
                语句体2;
            }else if(比较表达式3) {
                语句体3;
            }
            ...
            else {
                语句体n+1;
            }
    * b：执行流程：
        * 首先计算比较表达式1看其返回值是true还是false，
        * 如果是true，就执行语句体1，if语句结束。
        * 如果是false，接着计算比较表达式2看其返回值是true还是false，

        * 如果是true，就执行语句体2，if语句结束。
        * 如果是false，接着计算比较表达式3看其返回值是true还是false，

        * 如果都是false，就执行语句体n+1。
* B: 案例代码

       public class IfElseIfDemo{
            public static void main(String[] args){
                //成绩判断要求 ,成绩>80  成绩>70  成绩>60  不及格
                //定义变量,保存成绩
                int grade = 75;
                //使用if else if 语句对成绩判断
                if( grade > 80 ){
                    System.out.println(grade+" 成绩是优");
                }else if ( grade > 70){
                    System.out.println(grade+" 成绩是良");
                }else if ( grade > 60){
                    System.out.println(grade+" 成绩是中");
                }else{
                    System.out.println(grade+" 成绩是差");
                }

            }
        }

08if语句和三元运算符的互换

* A: 三元运算符
    * a: 概念
        * 用来完成简单的选择逻辑，即根据条件判断，从两个选择中选择一种执行
    * b: 使用格式
        * (条件表达式)？表达式1：表达式2；
    * c: 运算规则
        * 1: 判断条件表达式，结果为一个布尔值
        * 2: true，运算结果为表达式1
        * 3: false，运算结果为表达式2
* B: 案例代码

      public class IfElseDemo_1{
            public static void main(String[] args){
                int j = 6;
                int i = 15;
                //使用if语句,判断出最大值
                if(i>j){
                int j = 6;
                    System.out.println(i+" 是最大值");
                }else{
                    System.out.println(j+" 是最大值");
                }

                //使用三元运算实现
                int k = i>j ? i : j;
                System.out.println(k+" 是最大值");
            }
        }

* C: 使用if语句还是三元表达式
    * 判断条件多,使用if
     * 三元,必须有结果的, if 可以没有结果的

09while循环

* A: while循环结构
    * a: 使用格式
        初始化表达式；
        while(条件){
            循环体
        }
    * b: 执行顺序
          当条件是true,就执行循环体,执行完循环体后
          程序再次执行while中的条件,如果条件还是true,继续执行循环体
          直到条件是false的时候,循环就结束
* B: 案例代码

    public class WhileDemo{
            public static void main(String[] args){
                //输出 1-4之间的整数
                //定义变量,整数类型, 循环的条件
                int i = 1;
                while( i < 5 ){
                    System.out.println(i);
                    i++;
                }
            }
        }

10for循环_1

* A: for循环_1
    * a: 使用格式
         for(初始化变量 ; 条件 ; 增量){
             循环体;
         }
    * b: 各模块解释
        初始化变量: 定义变量,作用是用来控制循环的次数
        条件: 当条件是true,执行循环体,条件是false,结束循环
        增量: 变量自增情况
* B: 案例代码

     public class ForDemo{
            public static void main(String[] args){
                //for循环,输出0-10
                for(int i = 0 ; i < 11 ; i++){
                    System.out.println(i);
                }
            }
        }

11for循环_2

* A: for循环的执行流程
    for（① ; ② ; ③）{
        ④
    }
    第一步，执行①
    第二步，执行②，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步
    第三步，执行④
    第四步，执行③，然后重复执行第二步
    第五步，退出循环

12for循环_3

* A: 案例
    * a: 利用for循环,计算1+4的结果
* B: 案例代码

    public class ForDemo_1{
            public static void main(String[] args){
                // 定义变量,记录求和后的数据
                int sum = 0;
                // 利用循环,将变量从1变化到4
                for(int i = 1 ; i <= 4 ; i++){
                    //对变量进行求和
                    sum = sum + i;
                }
                System.out.println(sum);
            }
        }

13do_while循环

* A: do_while循环
    * a: 使用格式
        do{
           循环体;
        }while(条件);
    * b: 执行顺序
        先执行一次循环体，然后再判断条件，如果条件为true，继续执行循环体，
        如果条件为false，循环结束。
    * c: 特点
        * 无条件先执行一次
* B: 案例代码

    public class DoWhileDemo{
            public static void main(String[] args){
                int i = 0;
                do{
                    System.out.println(i);
                    i++;
                }while( i <  5);
            }
        }

14死循环

* A: 死循环概述
    * 无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环
* B: 死循环格式
    * while(true){}
    * for(;;){}

15嵌套for循环_1

* A: 嵌套循环的概述
    * 嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套，如最常见的在for循环中嵌套for循环。
* B: 嵌套循环的格式
    for(初始化表达式; 循环条件; 操作表达式) {
        ………
        for(初始化表达式; 循环条件; 操作表达式) {
            执行语句
            ………
        }
        ………
    }
* C: 各模块解释
    * 总的循环次数 =  内循环次数 * 外循环的次数
    * 内循环,是外循环的循环体

    * 外循环,控制的是行数
    * 内循环,控制的是每行的个数

16嵌套for循环_2

* A: 案例
    * a: 打印正三角形
* B: 案例代码

      public class ForForDemo{
            public static void main(String[] args){
                for(int i = 0 ; i < 9 ; i++){
                    for(int j = 0; j < i+1 ;j++){
                        System.out.print("* ");
                    }
                    System.out.println();
                }
            }
        }

17break语句

* A: break语句
    * a: 作用
        * 跳出所在的循环体
    * b: 书写位置
        * 必须出现在循环或选择结构内
    * c: 举例

      for(int i=0; i<10; i++) {
                if(i>5) {
                break;
            }
                System.out.println(“我爱Java”+i);
            }
            //会从0-5输出6次“我爱Java”

* B: break详细解释
    * a: 作用
        * 在loop/switch选择或者循环过程中，我们总是满足布尔表达条件才能执行对应的代码，然而在这些逻辑过程中，
            可以使用一些关键字直接跳出正在执行的代码，去执行后边或者指定位置的代码，
            这些关键字一旦出现就可以跳转语句执行顺序。
    * b: 使用方式
        * 无法单独使用，必须将break关键字置于switch或循环语句中
    * c: 运行规律
        * 不需要判断任何条件，只要遇到break变直接跳出执行后续代码。会完全跳出选择或者循环结构
        * 只能跳出最近的代码块，不能跨越多级代码块

* C：循环标号
    * a: 为什么使用循环标号
        * 当在双层循环或者循环内有switch选择语句时，我们发现，使用break或者continue所作用的对象均是内层语句，无法直接跳出外层循环，这时就需要使用标号语句跳转了.
    * b: 使用方式
        * 在外层循环外的某行前边，使用后边跟有冒号”:”的标识符，即定义完毕。
          使用时当在内层循环使用break或continue时后边紧跟之前定义的标号即可
    * c: 运行规律
        * 当外层循环外定义了标号
        * 内层使用break，终止内外双层循环。
        * 内层使用continue，终止内层循环，继续外层循环。

18continue语句

* A: continue语句
    * a: 作用
        * 提前结束本次循环，继续进行下次循环
    * b: 使用方式
        * 无法单独使用，必须将continue关键字置于循环语句中
    * c：运行规律
        * 不需要判断任何条件，只要遇到continue变直接跳出本轮循环进行下次循环
    * d：案例代码

    public class ContinueDemo{
                public static void main(String[] args){
                    for(int i = 0 ; i < 10 ; i++){
                        if(i%2==0){
                            continue;
                        }
                        System.out.println(i);
                    }
                }
            }
            //会把0-9之间所有的奇数打印到控制台上

19猜数字小游戏

* A: 猜数字小游戏        
    * a: 分析
        * 用户给的数可能大于、小于、或等于被猜的数，这样就会出现三种情况，用前面讲的三元运算符可以实现，
            但是得用三元运算符的嵌套，比较麻烦！可以用更简单的方式if条件判断，可以有三个以上的条件
    * b: 需求分析
        * 后台预先生成一个随机数1-100，用户键盘录入猜数字
        * 如果猜对了，打印“恭喜您，答对了”
        * 如果猜错了
        * 猜大了：打印“sorry，您猜大了!”
        * 猜小了：打印“sorry，您猜小了!”
                直到数字猜到为止
                最多只能猜5次，否则提示“sorry，您没有机会了!”
* B: 案例代码
    /*
        猜数字小游戏

        完成猜数字小游戏：
        1、产生随机数
        后台预先生成一个随机数1-100，用户键盘录入猜数字
        2、通过if语句对用户猜的数与随机数进行比较
        如果猜对了，打印“恭喜您，答对了”
        如果猜错了
        猜大了：打印“sorry，您猜大了!”
        猜小了：打印“sorry，您猜小了!”
        3、通过for循环完成用户猜数的循环
        直到数字猜到为止
        最多只能猜5次，否则提示“sorry，您没有机会了!”

     */
        import java.util.Random;
        import java.util.Scanner;
        //通过*的方式可以一次导入该包下所有的类，但是不建议使用。建议使用哪个导哪个。
        //import java.util.*;
        public class GuessNumber{
            public static void main(String[] args) {
                //1、产生随机数
                //后台预先生成一个随机数1-100，用户键盘录入猜数字
                //创建随机数对象
                Random random = new Random();
                //产生一个1-100的随机数
                int randomNumber = random.nextInt(100)+1;
                //System.out.println("我产生的随机数是："+randomNumber+"你猜猜是多少？");  作弊专用
                //产生控制台录入的Scanner对象
                Scanner sc = new Scanner(System.in);
                //3、通过for循环完成用户猜数的循环
                //通过for循环完成猜数字逻辑
                for(int i=1; i<=5; i++){
                    //提示用户输入要猜的数，用变量接收
                    System.out.println();
                    System.out.println("请您输入一个1-100的数：");
                    int guessNumber = sc.nextInt();

                    //2、通过if语句对用户猜的数与随机数进行比较
                    //如果猜对了
                    if(guessNumber==randomNumber) {
                        //打印猜对后的提示
                        System.out.println("恭喜您，猜对了！");
                        //跳出循环，不用再猜了
                        break;
                    }else {//如果猜错了
                        //如果猜大了
                        if(guessNumber>randomNumber) {
                            System.out.println("sorry，您猜大了!");
                        }else {//如果猜小了
                            System.out.println("sorry，您猜小了!");
                        }
                    }
                    //如果猜到了最后的第5次仍然没有猜对就跳出循环
                    if(i==5) {
                        System.out.println("对不起，点太背，下次再来吧！");
                        break;
                    }
                    //每次猜错后，都提示还有多少次机会
                    System.out.println("请注意，您还有"+(5-i)+"次机会，请慎重作答！");
                }
            }
        }

今日内容介绍

* 引用数据数据类型（Scanner、Random）
* 流程控制语句（if、for、while、dowhile、break、continue）


1. 引用数据类型

    1. Scanner类

我们要学的Scanner类是属于引用数据类型，我们先了解下引用数据类型。

* 引用数据类型的使用

与定义基本数据类型变量不同，引用数据类型的变量定义及赋值有一个相对固定的步骤或格式。
数据类型变量名 = new 数据类型();
每种引用数据类型都有其功能，我们可以调用该类型实例的功能。
变量名.方法名();

* Scanner类

Scanner类是引用数据类型的一种，我们可以使用该类来完成用户键盘录入，获取到录入的数据。
Scanner使用步骤：
导包：import java.util.Scanner;
创建对象实例：Scanner sc = new Scanner(System.in);
调用方法：
int i = sc.nextInt(); 用来接收控制台录入的数字
String s = sc.next(); 用来接收控制台录入的字符串
了解完Scanner类，我们编写代码来使用下它：ScannerDemo01.java

import java.util.Scanner;
public class ScannerDemo01 {
    public static void main(String[] args) {
        //创建Scanner引用类型的变量
        Scanner sc = new Scanner(System.in);
        //获取数字
        System.out.println("请输入一个数字");
        int n = sc.nextInt();
        System.out.println("n的值为" + n);
        //获取字符串
        System.out.println("请输入一个字符串");
        String str = sc.next();
        System.out.println("str的值为" + str);
    }
}

   运行结果如下图所示。


1. 运行结果


1. 随机数类Random

我们来学习下，用来产生随机数的类Random，它也属于引用数据类型。
这个Random类，它可以产生多种数据类型的随机数，在这里我们主要介绍生成整数与小数的方式。

* 方法简介

public int nextInt(int maxValue) 产生[0,maxValue)范围的随机整数，包含0，不包含maxValue；
public double nextDouble() 产生[0,1)范围的随机小数，包含0.0，不包含1.0。
引用数据类型的使用方式，在学习键盘录入Scanner时，我们已经学习过，在这里，再次回顾一下：

* Random使用方式:

    * import导包：所属包java.util.Random 
    * 创建实例格式：Random 变量名 = new Random();

接下来，通过一段代码，一起学习下Random类的使用，

RandomDemo.java
import java.util.Random;
public class RandomDemo {
    public static void main(String[] args) {
        // 创建Random类的实例
        Random r = new Random();
        // 得到0-100范围内的随机整数，将产生的随机整数赋值给i变量
        int i = r.nextInt(100);
        //得到0.0-1.0范围内的随机小数，将产生的随机小数赋值给d变量
        double d = r.nextDouble();
        System.out.println(i);
        System.out.println(d);
    }
}

   运行结果如下图所示：


1. 运行结果


1. 流程控制语句

    1. 选择结构if

接下来要学习的if条件语句分为三种语法格式，每一种格式都有它自身的特点，下面我们分别进行介绍。

1. if语句

if语句是指如果满足某种条件，就进行某种处理。例如，小明妈妈跟小明说“如果你考试得了100分，星期天就带你去游乐场玩”。这句话可以通过下面的一段伪代码来描述。
如果小明考试得了100分
妈妈星期天带小明去游乐场
在上面的伪代码中，“如果”相当于Java中的关键字if，“小明考试得了100分”是判断条件，需要用()括起来，“妈妈星期天带小明去游乐场”是执行语句，需要放在{}中。修改后的伪代码如下：
if (小明考试得了100分) {
妈妈星期天带小明去游乐场
}
上面的例子就描述了if语句的用法，在Java中，if语句的具体语法格式如下：
if (条件语句){
执行语句;
……
}
上述格式中，判断条件是一个布尔值，当判断条件为true时，{}中的执行语句才会执行。if语句的执行流程如下图所示。

1. if语句流程图

接下来通过一段代码，学习一下if语句的具体用法，IfDemo01.java

public class IfDemo01 {
    public static void main(String[] args) {
        int x = 5;
        if (x < 10) {
            x++;
        }
        System.out.println("x=" + x);
    }
}

运行结果如下图所示。

1. 运行结果

在上述代码中，定义了一个变量x，其初始值为5。在if语句的判断条件中判断x的值是否小于10，很明显条件成立，{}中的语句会被执行，变量x的值将进行自增。从运行结果可以看出，x的值已由原来的5变成了6。

1. if…else语句

if…else语句是指如果满足某种条件，就进行某种处理，否则就进行另一种处理。例如，要判断一个正整数的奇偶，如果该数字能被2整除则是一个偶数，否则该数字就是一个奇数。if…else语句具体语法格式如下：
if (判断条件){
执行语句1
……
}else{
执行语句2
……
}
上述格式中，判断条件是一个布尔值。当判断条件为true时，if后面{}中的执行语句1会执行。当判断条件为false时，else后面{}中的执行语句2会执行。if…else语句的执行流程如下图所示。

1. if…else语句流程图

接下来通过一段代码，来实现判断奇偶数的程序，IfDemo02.java

public class IfDemo02 {
    public static void main(String[] args) {
        int num = 19;
        if (num % 2 == 0) {
            // 判断条件成立，num被2整除
            System.out.println("num是一个偶数");
        } else {
            System.out.println("num是一个奇数");
        }
    }
}

运行结果如下图所示。

1. 运行结果

上述代码中，变量num的值为19，模以2的结果为1，不等于0，判断条件不成立。因此会执行else后面{}中的语句，打印“num是一个奇数”。

1. if…else if…else语句

if…else if…else语句用于对多个条件进行判断，进行多种不同的处理。例如，对一个学生的考试成绩进行等级的划分，如果分数大于80分等级为优，否则，如果分数大于70分等级为良，否则，如果分数大于60分等级为中，否则，等级为差。if…else if…else语句具体语法格式如下：
if (判断条件1) {
执行语句1
} else if (判断条件2) {
执行语句2
}
…
else if (判断条件n) {
执行语句n
} else {
执行语句n+1
}
上述格式中，判断条件是一个布尔值。当判断条件1为true时，if后面{}中的执行语句1会执行。当判断条件1为false时，会继续执行判断条件2，如果为true则执行语句2，以此类推，如果所有的判断条件都为false，则意味着所有条件均未满足，else后面{}中的执行语句n+1会执行。if…else if…else语句的执行流程如下图所示。

1. if…else if…else语句的流程图

接下来通过一段代码，来实现对学生考试成绩进行等级划分的程序，IfDemo03.java

public class IfDemo03 {
    public static void main(String[] args) {
        int grade = 75; // 定义学生成绩
        if (grade > 80) {
            // 满足条件 grade > 80
            System.out.println("该成绩的等级为优");
        } else if (grade > 70) {
            // 不满足条件 grade > 80 ，但满足条件 grade > 70
            System.out.println("该成绩的等级为良");
        } else if (grade > 60) {
            // 不满足条件 grade > 70 ，但满足条件 grade > 60
            System.out.println("该成绩的等级为中");
        } else {
            // 不满足条件 grade > 60
            System.out.println("该成绩的等级为差");
        }
    }
}

运行结果如下图所示。

1. 运行结果

上述代码中，定义了学生成绩grade为75。它不满足第一个判断条件grade>80，会执行第二个判断条件grade>70，条件成立，因此会打印“该成绩的等级为良”。

1. 选择结构if语句与三元运算转换

三元运算符，它和if-else语句类似，语法如下：
判断条件 ? 表达式1 : 表达式2
三元运算符会得到一个结果，通常用于对某个变量进行赋值，当判断条件成立时，运算结果为表达式1的值，否则结果为表达式2的值。
例如求两个数x、y中的较大者，如果用if…else语句来实现，具体代码如下：
int x = 0;
int y = 1;
int max;
if (x > y) {
max = x;
} else {
max = y;
}
上面的代码运行之后，变量max的值为1。其中3-8行的代码可以使用下面的三元运算来替换。
int max = x > y ? x : y;

1. 循环语句while

while循环语句和选择结构if语句有些相似，都是根据条件判断来决定是否执行大括号内的执行语句。区别在于，while语句会反复地进行条件判断，只要条件成立，{}内的执行语句就会执行，直到条件不成立，while循环结束。while循环语句的语法结构如下：
while(循环条件){
执行语句
………
}
在上面的语法结构中，{}中的执行语句被称作循环体，循环体是否执行取决于循环条件。当循环条件为true时，循环体就会执行。循环体执行完毕时会继续判断循环条件，如条件仍为true则会继续执行，直到循环条件为false时，整个循环过程才会结束。
while循环的执行流程如下图所示。

1. while循环的流程图

接下来通过一段代码，来实现打印1~4之间的自然数，WhileDemo.java

public class WhileDemo {
    public static void main(String[] args) {
        int x = 1; // 定义变量x，初始值为1
        while (x <= 4) { // 循环条件
            System.out.println("x = " + x); // 条件成立，打印x的值
            x++; // x进行自增
        }
    }
}

运行结果如下图所示。

1. 运行结果

在上述代码中，x初始值为1，在满足循环条件x <= 4的情况下，循环体会重复执行，打印x的值并让x进行自增。因此打印结果中x的值分别为1、2、3、4。
大家要注意的是，代码x++用于在每次循环时改变变量x的值，从而达到最终改变循环条件的目的。如果没有这行代码，整个循环会进入无限循环的状态，永远不会结束。

1. 循环语句for

for循环语句是最常用的循环语句，一般用在循环次数已知的情况下。for循环语句的语法格式如下：
for（初始化表达式; 循环条件; 操作表达式）{
执行语句
………
}
在上面的语法结构中，for关键字后面()中包括了三部分内容：初始化表达式、循环条件和操作表达式，它们之间用“;”分隔，{}中的执行语句为循环体。
接下来分别用①表示初始化表达式、②表示循环条件、③表示操作表达式、④表示循环体，通过序号来具体分析for循环的执行流程。具体如下：
for（① ; ② ; ③）{
④
}
第一步，执行①
第二步，执行②，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步
第三步，执行④
第四步，执行③，然后重复执行第二步
第五步，退出循环
接下来通过一个案例对自然数1~4进行求和，如下所示。ForDemo01.java

public class ForDemo01 {
    public static void main(String[] args) {
        int sum = 0; // 定义变量sum，用于记住累加的和
        for (int i = 1; i <= 4; i++) { // i的值会在1~4之间变化
            sum += i; // 实现sum与i的累加
        }
        System.out.println("sum = " + sum); // 打印累加的和
    }
}

运行结果如下图所示。

1. 运行结果

上述代码中，变量i的初始值为1，在判断条件i<=4为true的情况下，会执行循环体sum+=i，执行完毕后，会执行操作表达式i++，i的值变为2，然后继续进行条件判断，开始下一次循环，直到i=5时，条件i<=4为false，结束循环，执行for循环后面的代码，打印“sum=10”。
为了让初学者能熟悉整个for循环的执行过程，现将上述代码运行期间每次循环中变量sum和i的值通过表2-11罗列出来。

1. sum和i循环中的值

循环次数
sum
i
第一次
1
1
第二次
3
2
第三次
6
3
第四次
10
4

1. 循环语句do…while

do…while循环语句和while循环语句功能类似，其语法结构如下：
do {
执行语句
………
} while(循环条件);
在上面的语法结构中，关键字do后面{}中的执行语句是循环体。do…while循环语句将循环条件放在了循环体的后面。这也就意味着，循环体会无条件执行一次，然后再根据循环条件来决定是否继续执行。
do…while循环的执行流程如下图所示。

1. do…while循环的执行流程

接下来使用do…while循环语句来实现打印1~4之间的自然数DoWhileDemo.java。

public class DoWhileDemo {
    public static void main(String[] args) {
        int x = 1; // 定义变量x，初始值为1
        do {
            System.out.println("x = " + x); // 打印x的值
            x++; // 将x的值自增
        } while (x <= 4); // 循环条件
    }
}

运行结果如下图所示。

1. 运行结果

我们发现WhileDemo.java与DoWhileDemo.java运行的结果一致，这说明什么呢？这说明do …while循环和while循环能实现同样的功能。然而在程序运行过程中，这两种语句还是有差别的。如果循环条件在循环语句开始时就不成立，那么while循环的循环体一次都不会执行，而do…while循环的循环体还是会执行一次。若将DoWhileDemo.java中的循环条件x<=4改为x < 1，DoWhileDemo.java运行结果会打印x=1，而WhileDemo.java运行结果什么也不会打印。

1. 无限循环

最简单无限循环格式：
while(true){}
或
for(;;){}
无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。

1. 循环嵌套

嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套，如最常见的在for循环中嵌套for循环，格式如下：
for(初始化表达式; 循环条件; 操作表达式) {
………
for(初始化表达式; 循环条件; 操作表达式) {
执行语句
………
}
………
}
接下来通过一个练习，来实现使用“*”打印直角三角形，如下所示。ForForDemo.java

1.

 public class ForForDemo {
    2.     public static void main(String[] args) {
    3.         int i, j; // 定义两个循环变量
    4.         for (i = 1; i <= 9; i++) { // 外层循环
    5.             for (j = 1; j <= i; j++) { // 内层循环
    6.                 System.out.print("*"); // 打印*
    7.             }
    8.             System.out.print("\n"); // 换行
    9.         }
    10.     }
    11. }

运行结果如下所示。

1. 运行结果

在上述代码中定义了两层for循环，分别为外层循环和内层循环，外层循环用于控制打印的行数，内层循环用于打印“”，每一行的“”个数逐行增加，最后输出一个直角三角形。由于嵌套循环程序比较复杂，下面分步骤进行详细地讲解，具体如下：
第一步，在第3行代码定义了两个循环变量i和j，其中i为外层循环变量，j为内层循环变量。
第二步，在第4行代码将i初始化为1，条件i <= 9为true，首次进入外层循环的循环体。
第三步，在第5行代码将j初始化为1，由于此时i的值为1，条件j <= i为true，首次进入内层循环的循环体，打印一个“*”。
第四步，执行第5行代码中内层循环的操作表达式j++，将j的值自增为2。
第五步，执行第5行代码中的判断条件j<=i，判断结果为false，内层循环结束。执行后面的代码，打印换行符。
第六步，执行第4行代码中外层循环的操作表达式i++，将i的值自增为2。
第七步，执行第4行代码中的判断条件i<=9，判断结果为true，进入外层循环的循环体，继续执行内层循环。
第八步，由于i的值为2，内层循环会执行两次，即在第2行打印两个“*”。在内层循环结束时会打印换行符。
第九步，以此类推，在第3行会打印3个“*”，逐行递增，直到i的值为10时，外层循环的判断条件i <= 9结果为false，外层循环结束，整个程序也就结束了。

1. 跳转语句（break、continue）

跳转语句用于实现循环执行过程中程序流程的跳转，在Java中的跳转语句有break语句和continue语句。接下来分别进行详细地讲解。

1. break语句

在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。当它出现在循环语句中，作用是跳出循环语句，执行后面的代码。关于在switch语句中使用break前面的例程已经用过了，接下来通过下面一段代码，实现将当变量x的值为3时，使用break语句跳出循环，代码如下所示。BreakDemo.java

public class BreakDemo {
    public static void main(String[] args) {
        int x = 1; // 定义变量x，初始值为1
        while (x <= 4) { // 循环条件
            System.out.println("x = " + x); // 条件成立，打印x的值
            if (x == 3) {
                break;
            }
            x++; // x进行自增
        }
    }
}

运行结果如下图所示。

1. 运行结果

在上述带代码中，通过while循环打印x的值，当x的值为3时使用break语句跳出循环。因此打印结果中并没有出现“x=4”。

1. 标记

当break语句出现在嵌套循环中的内层循环时，它只能跳出内层循环，如果想使用break语句跳出外层循环则需要对外层循环添加标记。接下来将ForForDemo.java稍作修改，控制程序只打印4行“*”，如下所示。BreakDemo02.java

public class BreakDemo02 {
    public static void main(String[] args) {
        int i, j; // 定义两个循环变量
        itcast: for (i = 1; i <= 9; i++) { // 外层循环
            for (j = 1; j <= i; j++) { // 内层循环
                if (i > 4) { // 判断i的值是否大于4
                    break itcast; // 跳出外层循环
                }
                System.out.print("*"); // 打印*
            }
            System.out.print("\n"); // 换行
        }
    }
}

运行结果如下图所示。

1. 运行结果

BreakDemo02.java与ForForDemo.java实现原理类似，只是在外层for循环前面增加了标记“itcast”。当i>4时，使用break itcast;语句跳出外层循环。因此程序只打印了4行“*”。

1. continue语句

continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环。接下来通过一个练习对1~100之内的奇数求和，ContinueDemo.java

public class ContinueDemo {
    public static void main(String[] args) {
        int sum = 0; // 定义变量sum，用于记住和
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) { // i是一个偶数，不累加
                continue; // 结束本次循环
            }
            sum += i; // 实现sum和i的累加
        }
        System.out.println("sum = " + sum);
    }
}

运行结果如下图所示。

1. 运行结果

上述代码中，使用for循环让变量i的值在1~100之间循环，在循环过程中，当i的值为偶数时，将执行continue语句结束本次循环，进入下一次循环。当i的值为奇数时，sum和i进行累加，最终得到1~100之间所有奇数的和，打印“sum = 2500”。
在嵌套循环语句中，continue语句后面也可以通过使用标记的方式结束本次外层循环，用法与break语句相似，在此不再举例说明。

1. 猜数字案例

    1. 案例介绍

我们在日常生活中，经常与朋友们玩猜数字的游戏，非常的有趣。现在我们通过java把这个猜数字游戏编写出来。
猜数字案例是要完成什么样的功能呢？顾名思义，这个游戏就是你出个数字、我来猜。
游戏操作如下：

* 后台预先生成一个1-100之间的随机数，用户键盘录入猜数字
* 如果猜对了，打印“恭喜您，答对了”
* 如果猜错了

猜大了：打印“sorry，您猜大了!”
猜小了：打印“sorry，您猜小了!”

* 直到数字猜到为止

在案例开始之前，我们先要学习如下知识点：

* 随机数类Random
* 选择结构if
* 循环结构while


1. 案例需求分析、

猜数字案例的需求如下：

* 后台预先生成一个1-100之间的随机数，用户键盘录入猜数字
* 如果猜对了，打印“恭喜您，答对了”
* 如果猜错了

猜大了：打印“sorry，您猜大了!”
猜小了：打印“sorry，您猜小了!”

* 直到数字猜到为止

我们经过分析，得出如下的分析结果：

* 1.通过Random类中方法nextInt（），生成一个1-100之间的随机数
* 2.输入猜的数字
* 3.通过while循环，进行猜数字对错判断

    * 猜对，跳出循环，游戏结束
    * 猜错了，根据结果，给出提示，接着猜数字，游戏继续

        * 如果猜大了，打印sorry，您猜大了!继续下一次循环  
        * 如果猜小了，打印sorry，您猜小了!继续下一次循环


1. 实现代码步骤

分析完毕之后，在main()方法中，我们一起来完成代码的编写：GuessNumber.java

public class GuessNumber {
    public static void main(String[] args) {
        //1.通过Random类中方法nextInt（），生成一个1-100之间的随机数
        int randomNumber = new Random().nextInt(100);
        System.out.println("随机数已生成！");
        //2.输入猜的数字
        System.out.println("----请输入您猜的数字：----");
        Scanner sc = new Scanner(System.in);
        int enterNumber = sc.nextInt();
        //3.通过while循环，进行猜数字对错判断
        //猜对，跳出循环，游戏结束
        while(enterNumber != randomNumber){
            //猜错了，根据结果，给出提示，接着猜数字，游戏继续
            if(enterNumber>randomNumber) {
                //如果猜大了，打印sorry，您猜大了!继续下一次循环
                System.out.println("sorry，您猜大了!继续下一次循环");
            }else {
                //如果猜小了，打印sorry，您猜小了!继续下一次循环
                System.out.println("sorry，您猜小了!继续下一次循环");
            }
            //输入猜的数字
            System.out.println("----请输入您猜的数字：----");
            enterNumber = sc.nextInt();
        }
        System.out.println("恭喜您，答对了！");
    }
}

1. 总结

    1. 知识点总结


* 选择结构 if

    * 方式1:

          格式：
                 if(条件表达式) {
                        语句体;
                 }
          执行流程：
                 如果条件表达式值为true, 执行语句体
                 如果条件表达式值为false,不执行语句体


* 方式2：

          格式:
                 if(条件表达式) {
                        语句体1;
                 } else {
                        语句体2;
                 }
          执行流程：
                 如果条件表达式值为true, 执行语句体1
                 如果条件表达式值为fales,执行语句体2

* 方式3：

          格式：
                 if(条件表达式1) {
                        语句体1;
                 } else if (条件表达式2) {
                     语句体2;
                 } else if (条件表达式n...) {
                        语句体n...
                 }
                 ...
                 else {
                        语句体n+1;
                 }
          执行流程：
                 哪一个条件表达式成立，执行对应的语句体，
                 如果所有的条件表达式都不成立，执行最后else中的语句体


* 注意事项：

          1，条件表达式无论是简单还是复杂，结果都是boolean类型的值
          2, 如果语句体只有一条语句，大括号可以省略，
             如果是多条语句，大括号不能省略，建议什么时候都写上大括号

* 循环语句For

    * 格式：

          for (初始化表达式;条件表达式; 控制条件表达式) {
                 语句体;
          }

* 执行流程：

          1，初始化表达式；
          2，条件表达式
                  如果结果为true, 执行语句体
                  如果结果为flase, 循环结束
          3, 当语句体执行后， 执行控制条件表达式
          4，接下来，回到第二步, 直到条件表达式为false 循环结束

* 循环语句 while

    * 格式：

          初始化表达式;
          while (条件表达式) {
                 语句体;
                 控制条件表达式;
          }

* 执行流程；

          1，初始化表达式；
          2，条件表达式
                  如果结果为true, 执行语句体
                  如果结果为flase, 循环结束
          3, 当语句体执行后， 执行控制条件表达式
          4，接下来，回到第二步, 直到条件表达式为false 循环结束跳转语句（break、continue）

* 循环语句  do...while

    * 格式：

          初始化表达式;
          do {
                 语句体;
                 控制条件表达式;
          } while (条件表达式);

* 执行流程:

          1，初始化表达式；
          2, 执行语句体
          3, 执行控制条件表达式
          4, 执行条件表达式,
                 如果结果为true, 继续执行语句体
                 如果结果为false, 循环结束

* 跳转控制语句

   break; 跳出循环
   continue; 结束本次循环

* Scanner类

    * 获取键盘录入的数据，对获取数据的具体操作进行了封装，只需要调用方法，即可得到键盘录入的数据。
    * 常用的方法

public int nextInt()：获取键盘录入的数据，返回int类型值
public String next()：获取键盘录入的数据，返回String类型值

* Random类：随机数类，用来产生多种类型的随机数

    * 方法：

public int nextInt(int n) 返回一个，在 0（包括）和指定值（不包括）之间int随机数

Vanessa_wanglu

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录