java基础语法——条件判断与循环语句

我会带着你远行 2024-03-27 09:23 80阅读 0赞

**目录**

一、流程控制语句

流程控制语句分类

二、顺序结构

顺序结构概述

顺序结构图

三、选择结构

选择结构概述

选择结构(if语句1)

选择执行图1

选择结构(if语句2)

选择执行图2

选择结构(if语句3)

选择执行图3

选择结构(switch语句)

switch语句执行流程图

四、 循环结构

for循环语句图

五、 循环结构(while循环语句)

while循环语句执行流程图

六、 循环结构(do…while循环语句)

do…while循环语句执行流程图

### 流程控制语句 ###

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。

#### **流程控制语句分类** ####

——顺序结构

——选择结构

——循环结构

### 顺序结构 ###

#### **顺序结构概述** ####

——是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

——总的来说：写在前面的先执行，写在后面的后执行

#### 顺序结构图 ####

![c56b5363f612438dac4abdff2775ceaf.png][]

package com.demo01;
    
    /*
     * 顺序结构：从上往下依次进行
     */
    public class OrderDemo {
    	public static void main(String[] args) {
    		System.out.println("开始");
    		System.out.println("语句A");
    		System.out.println("语句B");
    		System.out.println("语句C");
    		System.out.println("结束");
    	}
    }

###  ###

### 选择结构 ###

#### **选择结构概述** ####

–也被称为分支结构。

–选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。

–Java语言提供了两种选择结构语句

*  if语句
 *  switch语句

#### **选择结构(if语句1)** ####

*  if语句有三种格式
 *  if语句第一种格式：

–if(关系表达式) \{

语句体

*  执行流程

——首先判断关系表达式看其结果是true还是false

——如果是true就执行语句体

——如果是false就不执行语句体

package com.demo02;
    
    /*
     * if语句有三种格式
     * 
     * if语句格式：
     * 		if(关系表达式) {
     * 			语句体;
     * 		}
     * 
     * ִ执行流程
     * 		A:首先判断关系表达式是true还是false
     * 		B:如果是true,就执行语句体
     * 		C:如果是false,就不执行语句体
     */
    public class IfDemo {
    	public static void main(String[] args) {
    		System.out.println("开始");
    		// 定义两个变量
    		int a = 10;
    		int b = 20;
    
    		if (a == b) {
    			System.out.println("a等于b");
    		}
    
    		int c = 10;
    		if (a == c) {
    			System.out.println("a等于c");
    		}
    
    		System.out.println("结束");
    	}
    }

![460739434c4c4e0badefad8be19fefec.png][]

#### 选择执行图1 ####

![8c03ce67b1ea4af698df65de78a7a616.png][]

#### 选择结构(if语句2) ####

*  if语句第二种格式：

–if(关系表达式)\{

语句体1;

\}else\{

语句体2;

*  执行流程

–首先判断关系表达式看其结果是true还是false

–如果是true就执行语句体1

–如果是false就执行语句体2

#### 选择执行图2 ####

![75e3920659044611a9673a449ffc7c57.png][]

package com.demo02;
    
    import java.util.Scanner;
    
    /*
     * if语句格式2
     * 		if(关系表达式) {
     * 			语句体1;
     * 		}else {
     * 			语句体2;
     * 		}
     * 
     * ִ执行流程
     * 		A:判断表达式是true还是false
     * 		B:如果是true,就执行语句体1
     * 		C:如果是false,就执行语句体2
     */
    public class IfDemo2 {
    	public static void main(String[] args) {
    		System.out.println("开始");
    		// 判断给定的数据是奇数还是偶数
    		Scanner sc = new Scanner(System.in);
    		
    		//接受数据
    		System.out.println("请录入一个整数：");
    		int a = sc.nextInt();
    
    
    		if (a % 2 == 0) {
    			System.out.println("a是偶数");
    		} else {
    			System.out.println("a是奇数");
    		}
    
    		System.out.println("结束");
    	}
    }

![0a78d86320eb41a9bec7fd969a7b5279.png][]

#### 选择结构(if语句3) ####

*  if语句第三种格式：

–if(关系表达式1) \{

语句体1;

\}else if (关系表达式2)\{

语句体2;

…

else \{

语句体n+1;

*  执行流程

–首先判断关系表达式1看其结果是true还是false

–如果是true就执行语句体1

–如果是false就继续判断关系表达式2看其结果是true还是false

–如果是true就执行语句体2

–如果是false就继续判断关系表达式…看其结果是true还是false

–…

–如果没有任何关系表达式为true，就执行语句体n+1。

#### 选择执行图3 ####

![703d143222ac4ad1b08e8d3c7c5fe26f.png][]

* 
     * if语句的3种格式
     * 		第一种适合做一种判断
     * 		第二种适合做两种判断
     * 		第三种适合做多种判断
     */
    public class IfDemo3 {
    	public static void main(String[] args) {
    		while (true) {
    		// x和y的关系满足如下：
    		// x>=3     y = 2x + 1;
    		// -1<=x<3  y = 2x;
    		// x<-1     y = 2x-1;
    		//
    		// 根据给定的x的值,计算y并输出
    
    		// 
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请录入一个数：");
    		int x = sc.nextInt();
    		int y = 0;
    		//根据x的值给y赋值ֵ
    		if (x >= 3) {
    			y = 2 * x + 1;
    		} else if (x >= -1 && x < 3) {
    			y = 2 * x;
    		} else if(x >= -10 && x < -1){
    			y = 2 * x - 1;
    		}
    		
    		System.out.println("y的值是"+y);
    		}
    	}
    }

![bf9baa69cda34d629dd64a877a4dcedc.png][]

**练习：键盘录入学生考试成绩，请根据成绩判断该学生属于那个级别**

package com.demo02;
    
    import java.util.Scanner;
    
    /*
     * 键盘录入学生考试成绩，请根据成绩判断属于哪个级别
     * 90-100	优秀
     * 80-90	好
     * 70-80	良
     * 60-70	及格
     * 60以下    不及格
     * 
     * 分析：
     * 		A:键盘录入学生考试成绩
     * 			三步骤
     * 		B:ͨ通过简单分析，我们决定采用if语句格式来实现
     * 
     * 程序一定要考虑周全
     * 		安全数据
     * 		边界数据
     * 		错误数据
     */
    public class IfTest2 {
    	public static void main(String[] args) {
    		while(true) {
    		// 创建对象
    		Scanner sc = new Scanner(System.in);
    
    		//接收数据 
    		System.out.println("输入考生成绩:");
    		int score = sc.nextInt();
    
    
    
    		if (score < 0 || score > 100) {
    			System.out.println("你的成绩是错误的");
    		} else if (score >= 90 && score <= 100) {
    			System.out.println("你的成绩属于优秀");
    		} else if (score >= 80 && score < 90) {
    			System.out.println("你的成绩属于好");
    		} else if (score >= 70 && score < 80) {
    			System.out.println("你的成绩属于良");
    		} else if (score >= 60 && score < 70) {
    			System.out.println("你的成绩属于及格");
    		} else {
    			System.out.println("你的成绩不及格");
    		}
    		}
    	}
    }

![8e58c266a1014f048ef8d47994524fb8.png][]

#### 选择结构(switch语句) ####

switch语句格式：

–switch(表达式) \{

**case 值1**：

语句体1;

break;

case 值2：

语句体2;

break;

…

default：

语句体n+1;

break;

•格式解释

–switch表示这是switch语句

•表达式的取值：byte,short,int,char

•JDK5以后可以是枚举

•JDK7以后可以是String

–case后面跟的是要和表达式进行比较的值

–语句体部分可以是一条或多条语句

–break表示中断，结束的意思，可以结束switch语句

–default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

•执行流程

–首先计算出表达式的值

–其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。

–最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

#### switch语句执行流程图 ####

![e14dd4b4f4ea47c9a347f60da6854097.png][]

package com.demo03;
    
    import java.util.Scanner;
    
    /*
     * switch语句格式
     * switch(表达式) {
     * 		case ֵ1:
     * 			语句体1;
     * 			break;
     * 		case ֵ2:
     * 			语句体22;
     * 			break;
     * 		...
     * 		default:
     * 			语句体n+1;
     * 			break;
     * }
     * 格式解释
     * 		表达式:byte,short,int,char
     * 			JDK5以后可以是枚举
     * 			JDK7以后可以是字符串
     * 		case:就是要和表达式比较的值ֵ
     * 		break:表示中断结束
     * 		default:表示所有语句体的情况都不匹配的时候就执行语句体n+1.和if语句的else相似
     * ִ�����̣�
     * 		A:计算出表达式的值ֵ
     * 		B:拿出计算出来的值和case后边的值依次比较，一旦有对应的值，就执该处的语句，在执行过程中，遇到break就结束
     * 		C:如果和所有的case都不匹配，就执行default控制语句，然后结束
     * ����
     * 		根据键盘录入的值1,2,3---7，输出对应的星期一，星期二，星期三---，星期日
     */
    public class SwitchDemo {
    	public static void main(String[] args) {
    		// 创建对象
    		while(true) {
    		Scanner sc = new Scanner(System.in);
    
    		// 接收数据
    		System.out.println("请输入数字（1-7）：");
    		int weekday = sc.nextInt();
    
    		// switch语句实现
    		switch (weekday) {
    		case 1:
    			System.out.println("星期一");
    			break;
    		case 2:
    			System.out.println("星期二");
    			break;
    		case 3:
    			System.out.println("星期三");
    			break;
    		case 4:
    			System.out.println("星期四");
    			break;
    		case 5:
    			System.out.println("星期五");
    			break;
    		case 6:
    			System.out.println("星期六");
    			break;
    		case 7:
    			System.out.println("星期日");
    			break;
    		default:
    			System.out.println("输入错误");
    			break;
    		}
    		}
    
    	}
    }

![8989df8e5ded4569896730da6decb41e.png][]

### 循环结构 ###

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

**循环语句的组成**

–初始化语句：

•一条或者多条语句，这些语句完成一些初始化操作。

–判断条件语句：

•这是一个boolean 表达式，这个表达式能决定是否执行循环体。

–循环体语句：

•这个部分是循环体语句，也就是我们要多次做的事情。

–控制条件语句：

•这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束。

**for循环语句格式：**

–for(初始化语句;判断条件语句;控制条件语句)\{

循环体语句；

**–执行流程**

•A:执行初始化语句

•B:执行判断条件语句，看其结果是true还是false

–如果是false，循环结束。

–如果是true，继续执行。

•C:执行循环体语句

•D:执行控制条件语句

•E:回到B继续

#### for循环语句图 ####

![913713d8938c42e99c440e9ade2c968d.png][]

**循环结构(for循环练习)**

1.  在控制台输出10次Hello Word
2.  获取数据1-5和5-1
3.  求出1-5之间数据之和
4.  求出1-100之间偶数和
5.  在控制台输出所有的”水仙花数”
6.  统计”水仙花数”共有多少个

**练习1：在控制台输出10次Hello Word**

package com.demo04;
    
    /*
     * for循环语句格式
     * 		for(初始化语句；判断条件语句；控制条件语句) {
     * 			循环体语句;
     * 		}
     * 
     * 	
     * 			A:ִ执行初始化语句
     * 			B:ִ执行判断条件语句，看结果是true还是false
     * 				如果是true，就继续执行
     * 				如果是false,就结束循环
     * 			C:ִ执行循环体语句
     * 			D:ִ执行控制条件语句
     * 			E:回到B继续
     * 
     * 需求：
     * 		在控制台输出10次hello word
     */
    public class ForDemo {
    	public static void main(String[] args) {
    
    
    		for (int x = 1; x <= 10; x++) {
    			System.out.println("HelloWorld:"+x);
    		}
    
    	}
    }

![e596250073184a8aa69f56d2fcb578cc.png][]

**练习2：获取数据1-5和5-1**

package com.demo04;
    
    /*
     * for循环语句格式
     * 		for(初始化语句；判断条件语句；控制条件语句) {
     * 			循环体语句;
     * 		}
     * 
     * 		ִ执行过程
     * 			A:ִ执行初始化语句
     * 			B:ִ执行判断条件语句，看结果是true还是false
     * 				如果是true，就继续执行
     * 				如果是false,就结束循环
     * 			C:ִ执行循环体语句
     * 			D:ִ执行控制条件语句
     * 			E:回到B继续
     * 
     * 需求：
     * 		获取数据1-5和5-1
     */
    public class ForDemo {
    	public static void main(String[] args) {
    
    		System.out.println("*************");
    		for (int x = 1; x <= 5; x++) {
    			System.out.println(x);
    		}
    		System.out.println("*************");
    		for(int i=5;i>=1;i--) {
    			System.out.println(i);
    		}
    
    	}
    }

![87243c196665474ea5d05f7879bcf29f.png][]

**练习3：求出1-5之间数据之和**

package com.demo04;
    
    /*
     * for循环语句格式
     * 		for(初始化语句；判断条件语句；控制条件语句) {
     * 			循环体语句;
     * 		}
     * 
     * 		ִ执行过程
     * 			A:ִ执行初始化语句
     * 			B:ִ执行判断条件语句，看结果是true还是false
     * 				如果是true，就继续执行
     * 				如果是false,就结束循环
     * 			C:ִ执行循环体语句
     * 			D:ִ执行控制条件语句
     * 			E:回到B继续
     * 
     * 需求：
     * 		求出1-5之间数据之和
     */
    public class ForDemo {
    	public static void main(String[] args) {
    		int sum = 0;
    		System.out.println("*************");
    		for (int x = 1; x <= 5; x++) {
    			sum = sum + x; 
    		}
    		System.out.println("1-5之和为："+ sum);
    
    		}
    
    	}

![1c835cfe087d460ca1422d88887f3f76.png][]

**练习4：求出1-100之间偶数和**

package com.demo04;
    
    /*
     * for循环语句格式
     * 		for(初始化语句；判断条件语句；控制条件语句) {
     * 			循环体语句;
     * 		}
     * 
     * 		ִ执行过程
     * 			A:ִ执行初始化语句
     * 			B:ִ执行判断条件语句，看结果是true还是false
     * 				如果是true，就继续执行
     * 				如果是false,就结束循环
     * 			C:ִ执行循环体语句
     * 			D:ִ执行控制条件语句
     * 			E:回到B继续
     * 
     * 需求：
     * 		 求出1-100之间偶数和
     */
    public class ForDemo {
    	public static void main(String[] args) {
    		int sum = 0;
    		System.out.println("*************");
    		for (int x = 1; x <= 100; x++) {
    			if (x%2==0) {
    			sum = sum + x; }
    		}
    		System.out.println("1-100 偶数之和为："+ sum);
    
    		}
    
    	}

![606bb5af3a36460bb967de99cc41071d.png][]

**练习5：在控制台输出所有的”水仙花数”**

package com.demo04;
    /*
     * 需求：在控制台输出所有的水仙花数
     * 
     * 分析：
     * 		什么是水仙花数?
     * 			所谓的水仙花数是指一个三位数，是指各位数字的立方和等于该数本身
     *			举例子：153就是一个水仙花数
     *			153 = 1*1*1 + 5*5*5 + 3*3*3
     *
     *		A:三位数实际告诉我们水仙花数字的范围：
     *			100-999
     *		B:如何获取一个数据的每一位上的数字呢？
     *			举例：我有一个数据153，如何获取个位、十位、百位？
     *			个位153%10 = 3;
     *			十位153/10%10 = 5;
     *			百位153/10/10%10 = 1;
    
     *		C:让每个位上的立方和相加，并和该数字比较，如果相等，就是水仙花数，在控制台输出
     */
    public class ForTest4 {
    	public static void main(String[] args) {
    		//ͨ通过循环获取到每一个三位数
    		for(int x=100; x<=999; x++) {
    			//获取十位、个位、百位
    			int ge = x%10;
    			int shi = x/10%10;
    			int bai = x/10/10%10;
    			
    			//让每个位上的立方和相加，并和该数字比较，如果相等，就是水仙花数，在控制台输出
    			if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
    				System.out.println(x);
    			}
    		}
    	}
    }

![cec9c9ad4a9748b2944b8c25749ea14d.png][]

**练习6：统计”水仙花数”共有多少个**

package com.demo04;
    /*
     * 需求：在控制台输出所有的水仙花数
     * 
     * 分析：
     * 		什么是水仙花数?
     * 			所谓的水仙花数是指一个三位数，是指各位数字的立方和等于该数本身
     *			举例子：153就是一个水仙花数
     *			153 = 1*1*1 + 5*5*5 + 3*3*3
     *
     *		A:三位数实际告诉我们水仙花数字的范围：
     *			100-999
     *		B:如何获取一个数据的每一位上的数字呢？
     *			举例：我有一个数据153，如何获取个位、十位、百位？
     *			个位153%10 = 3;
     *			十位153/10%10 = 5;
     *			百位153/10/10%10 = 1;
    
     *		C:让每个位上的立方和相加，并和该数字比较，如果相等，就是水仙花数，在控制台输出
     */
    public class ForTest4 {
    	public static void main(String[] args) {
    		//ͨ通过循环获取到每一个三位数
    		int count = 0;
    		for(int x=100; x<=999; x++) {
    			//获取十位、个位、百位
    			int ge = x%10;
    			int shi = x/10%10;
    			int bai = x/10/10%10;
    			
    			//让每个位上的立方和相加，并和该数字比较，如果相等，就是水仙花数，在控制台输出
    			if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
    				count++;
    				
    			}
    			
    		}
    		System.out.println(count);
    	}
    }

![651d607d82244158bd03695515e97ac6.png][]

### 循环结构(while循环语句) ###

while循环语句格式：

**–基本格式**

while(判断条件语句) \{

循环体语句;

**–改版格式**

初始化语句;

while(判断条件语句) \{

循环体语句;

控制条件语句; \}

#### while循环语句执行流程图 ####

![daa1d45c118d424e9fc28956164ee939.png][]

package com.demo05;
    /*
     * while循环语句的基本格式
     * 		while(判断条件语句) {
     * 			循环体语句;
     * 		}
     * 扩展格式
     * 		初始化语句;
     * 		while(判断条件语句) {
     * 			循环体语句;
     * 			控制条件语句
     * 		}
     * 
     * 回顾for循环语句格式
     * 		for(初始化语句；判断条件语句；控制条件语句) {
     * 			循环体语句;
     * 		}
     */
    public class WhileDemo {
    	public static void main(String[] args) {
    		//输出10次hello World
    		/*
    		 * for(int x=1; x<=10; x++) { System.out.println("HellloWorld"); }
    		 */
    		
    		
    		//while循环实现
    		int x=1;
    		while(x<=10) {
    			System.out.println("HellloWorld");
    			x++;
    		}
    		System.out.println(x);
    	}
    }

### ![0eff2e242d6b405aad5b9832cfb729d6.png][] ###

### 循环结构(do…while循环语句) ###

**do…while循环语句格式：**

**–基本格式**

do \{

循环体语句;

\}while((判断条件语句);

**–改版格式**

初始化语句;

do \{

循环体语句;

控制条件语句;\}

while((判断条件语句);

#### do…while循环语句执行流程图 ####

![d8ff0557d13a40348c31708fca3a9c5d.png][]

package com.demo06;
    /*
     * do...while循环基本格式
     * 		do {
     * 			循环体语句;
     * 		}while(判断条件语句);
     * 扩展格式
     * 		初始化语句;
     * 		do {
     * 			循环体语句;
     * 			控制条件语句;
     * 		}while(判断条件语句);
     * ִ执行流程
     * 		A:ִ执行初始化语句
     * 		B:ִ执行循环体语句
     * 		C:ִ执行控制条件语句;
     * 		D:ִ执行判断条件语句
     * 			如果是true，回到B继续
     * 			如果是false,就结束
     * 
     * 
     */
    public class DoWhileDemo {
    	public static void main(String[] args) {
    
    		int x=1;
    		System.out.println("************************");
    		do {
    
    			System.out.println("HelloWorld");
    			x++;
    		}while(x<=10);
    	}
    }

![64bbffa8da3d48a79b4a0c7004d8d7d2.png][] **循环结构(三种循环的区别)**

虽然可以完成同样的功能，但是还是有小区别：

–**do…while****循环至少会执行一次循环体**。

–for循环和while循环只有在条件成立的时候才会去执行循环体

**for循环语句和while循环语句的小区别：**

–使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是**for****循环结束，该变量就从内存中消失，能够提高内存的使用效率**。（for 变量定义在括号里边，while 变量定义在括号外边）

**跳转控制语句**

*  我想让循环在某一步的时候结束或者跳过某些数据不要，现在就做不了这件事情。为了弥补这个缺陷，Java就提供了break，continue来实现控制语句的中断和跳转。
 *  break 中断
 *  continue 继续
 *  **break的使用场景：**

–在选择结构switch语句中

–在循环语句中

–离开使用场景的存在是没有意义的

*  **break的作用：**

–跳出单层循环

package com.demo07;
    
    public class BreakDemo {
    	public static void main(String[] args) {
    		//break;
    		
    		for(int x=1; x<=10; x++) {
    			if(x == 3) {
    				break;
    			}
    			System.out.println("HelloWorld");
    		}
    	}
    }

*  **continue的使用场景：**

–在循环语句中

–离开使用场景的存在是没有意义的

*  **continue的作用：**

–单层循环对比break，然后总结两个的区别

•break 退出当前循环

•continue 退出本次循环

package com.demo07;
    
    public class ContinueDemo {
    	public static void main(String[] args) {
    		//continue;
    		
    		for(int x=1; x<=10; x++) {
    			if(x == 3) {
    				//break;
    				continue;
    			}
    			System.out.println("HelloWorld");
    		}
    	}
    }

### ![e898c69950404c78a1ee3f2b07270233.png][] ###

退出当前循环，往后走

### 随机数 ###

*  作用：———– 用于产生一个随机数
 *  使用步骤(和Scanner类似)

–导包

•import java.util.Random;

–创建对象

•Random r = new Random()

–获取随机数

•int number = r.nextInt(10);

•产生的数据在0到10之间，包括0，不包括10。

•如何获取一个1-100之间的随机数呢?

import java.util.Random;
    
    /**
     * 
     * @author 无限嚣张(菜菜) 
     * 使用步骤(和Scanner类似)     
     * 				–导包
     * 
     *                 •import java.util.Random;
     * 
     *             –创建对象
     * 
     *                 •Random r = new Random()
     * 
     *             –获取随机数
     * 
     *                 •int number = r.nextInt(10);
     */
    public class SuiJiShu {
    
    	public static void main(String[] args) {
    		for(int x=1;x<=10;x++) {
    		// TODO Auto-generated method stub
    		// 创建对象
    		Random Sc = new Random();
    		//接收数据
    		int i = Sc.nextInt(10);
    		System.out.println(i);}
    		
    		//如何获取1-100
    		//int i = Sc.nextInt(100)+1;
    
    	}
    
    }

![a804d5ed359e46728168267adbdd7991.png][]

**随机数练习：猜数字小游戏 (拒绝赌博，热爱家庭)**

import java.util.Random;
    import java.util.Scanner;
    
    /**
     * 
     * @author 无限嚣张(菜菜) 
     * 使用步骤(和Scanner类似)     
     * 				–导包
     * 
     *                 •import java.util.Random;
     * 
     *             –创建对象
     * 
     *                 •Random r = new Random()
     * 
     *             –获取随机数
     * 
     *                 •int number = r.nextInt(10);
     *        猜数字小游戏案例
     *        	系统产生一个1-100之间的随机数
     *        分析：
     *        A：系统产生一个1-100之间的随机数
     *        	random r = new Random();
     *          int number = r.nextInt(100)+1;
     *        B:键盘录入我们要猜的数据
     *        C：比较这两个数据，用if语句实现
     *        	大了：提示大了
     *        	笑了：提示小了
     *        	猜中：提示恭喜你猜中了
     *        D：多次猜数据，而我们不知道猜多少次怎么办呢？
     *        	while(true) 循环体语句
     */
    public class SuiJiShu {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		// 创建对象
    		while(true) {
    		Random Sc = new Random();
    		//接收数据
    		int i = Sc.nextInt(10);
    		System.out.println("随机数为：");
    		System.out.println(i);
    		
    		//创建键盘录入数据
    		Scanner sc = new Scanner(System.in);
    		
    		//接受数据
    		System.out.println("请输入您要猜的数字：");
    		int j = sc.nextInt();
    		
    		if(i>j) {
    			System.out.println("猜小了");
    		}
    		else if(i<j) {
    			System.out.println("猜大了");
    		}
    		else {
    			System.out.println("恭喜您猜中了");
    			break;
    		}
    		}
    		
    		
    		//如何获取1-100
    		//int i = Sc.nextInt(100)+1;
    
    	}
    
    }

![7c478523a51b4f9b862f00255bea288a.png][]

[c56b5363f612438dac4abdff2775ceaf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/b8580302fda54e27b0a53c0b01d503e9.png
[460739434c4c4e0badefad8be19fefec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/ef17e6057b474f6685e463ce2c0e9fdb.png
[8c03ce67b1ea4af698df65de78a7a616.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/5c24d2bbdbfb40698e8fdfb14fe00df0.png
[75e3920659044611a9673a449ffc7c57.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/95289b4f8b40497ead6869f8257bae42.png
[0a78d86320eb41a9bec7fd969a7b5279.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/6388f0f92a5a444cacc6a90f562b12eb.png
[703d143222ac4ad1b08e8d3c7c5fe26f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/94943e1130f94aa29b710e8907855c84.png
[bf9baa69cda34d629dd64a877a4dcedc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/d71cf622980a441887ef0da5c0a51aa0.png
[8e58c266a1014f048ef8d47994524fb8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/02605745e7854fb5ba399960af27bdc8.png
[e14dd4b4f4ea47c9a347f60da6854097.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/137aebd885bf4629a269e82aa6f1d24d.png
[8989df8e5ded4569896730da6decb41e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/70057738094c4fbb9d14253a0a6fde8a.png
[913713d8938c42e99c440e9ade2c968d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/76186fc3ce7c47d2a2952eef7f6f38cb.png
[e596250073184a8aa69f56d2fcb578cc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/1cb644c6f3eb4306ac9b89c945669281.png
[87243c196665474ea5d05f7879bcf29f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/56ad95a2ac794f1196fc30de44588d4e.png
[1c835cfe087d460ca1422d88887f3f76.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/8b0e068a98af4ec48b29b0d077e18d8c.png
[606bb5af3a36460bb967de99cc41071d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/e871c75796b1429ab02ca8ec028a300f.png
[cec9c9ad4a9748b2944b8c25749ea14d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/019b567b69d14f6daabf7c93ff1689cd.png
[651d607d82244158bd03695515e97ac6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/d2bd89019a45489eb6f8bd7fd4978b0e.png
[daa1d45c118d424e9fc28956164ee939.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/d01ede78720c4aa7be5557354aafa6da.png
[0eff2e242d6b405aad5b9832cfb729d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/af32aeac84404abfb73c35ec20737f61.png
[d8ff0557d13a40348c31708fca3a9c5d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/acef8763d1e945ba9293ba681343c755.png
[64bbffa8da3d48a79b4a0c7004d8d7d2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/c10318dee41a44d58e79939b2e9fba6d.png
[e898c69950404c78a1ee3f2b07270233.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/ae281c1d2f8f48c5bb88fd017a7332b1.png
[a804d5ed359e46728168267adbdd7991.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/a6d6aa9cd78243298b8267e57f47c17d.png
[7c478523a51b4f9b862f00255bea288a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/f5c7f62f03df4352a111f38b9690c73a.png