Java基础分支循环模块

分支语句

1.流程控制

1.1流程控制语句概述

顺序 选择 循环

1.2 流程控制语句的分类

顺序结构

分支结构(if,switch)

循环结构(for,while,do…while)

1.3顺序结构

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

/*
    顺序结构
*/

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("结束");
	}
}

1.4 if语句

1.4.1if语句格式——一种判断

/*
    if语句格式1
	
	格式：
	
	    if (关系表达式) {
			语句体;
		}
		
	执行流程：
	    1.首先计算关系表达式的值
		2.如果关系表达式的值为true就执行语句体
		3.如果关系表达式的值为false就不执行语句体
		4.继续执行后面的语句内容
*/

public class IfDemo {
	public static void main(String[] args) {
		System.out.println("开始");
		
		//定义两个变量
		int a = 10;
		int b = 20;
		
		//需求：判断a和b的值是否相等，如果相等，就在控制台输出:a 等于 b
		if (a == b) {
			System.out.println("a等于b");
		}
		
		///需求：判断a和c的值是否相等，如果相等，就在控制台输出:a 等于 c
		int c = 10;
		if (a == c ) {
			System.out.println("a等于c");
		}
		System.out.println("结束");
	}
}

1.4.2 if语句格式——两种判断

/*
    if语句格式2
	
	格式：
	    if (关系表达式) {
			语句体1;
		} else {
			语句体2;
		}
		
	执行流程：
	    1.首先计算关系表达式的值
		2.如果关系表达式的值为true就执行语句体1
		3.如果关系表达式的值为false就执行语句体2
		4.继续执行后面的语句内容
*/

public class IfDemo02 {
	public static void main(String[] args) {
		System.out.println("开始");
		
		//定义两个变量
		int a = 10;
		int b = 20;
		//修改b的值
		b = 5;
		
		//需求：判断a是否大于b,如果是,在控制台输出：a的值大于b,如果不是，在控制台输出：a的值不大于b
		
		if (a > b) {
			System.out.println("a的值大于b");
		} else {
			System.out.println("a的值不大于b");
		}
		System.out.println("结束");
	}
}

1.4.3 案例：奇偶数

/*
    奇偶数
	
	需求：
	    任意给出一个整数，请用程序实现判断该
		整数是奇数还是偶数，并在控制台上输出
		该整数是奇数还是偶数
*/

import java.util.Scanner;

public class IfTest01 {
	public static void main(String[] args) {
		
		//创建对象
		Scanner sc = new Scanner(System.in);
		//接收数据
		System.out.println("请输入一个整数：");
		int number = sc.nextInt();
		
		if (number % 2 == 0) {
			System.out.println(number + "是偶数");
		} else {
			System.out.println(number + "是奇数");
		}
	}
}

1.4.4 if语句格式三——多种判断

/*
    if语句格式3
	
	格式：
	    if  (关系表达式1) {
			语句体1;
		} else if (关系表达式2) {
			语句体2;
		}
		...
		else {
			语句体n+1;
		}
		
	执行流程：
	
	    1.首先计算关系表达式1的值
		2.如果值为true就执行语句体1;如果值为false就计算关系表达式2的值
		3.如果值为true就执行语句体2;如果值为false就计算关系表达式3的值
		4. ...
		5.如果没有任何关系表达式为true,就执行语句体n + 1
*/

//需求：键盘录入一个星期数(1,2,3,4,5,6,7),输出对应的星期一，星期二，星期三...星期日

import java.util.Scanner;

public class IfDemo03 {
	public static void main(String[] args) {
			System.out.println("开始");
		
		//创建对象
		Scanner sc = new Scanner(System.in);
		
		//接收数据
		System.out.println("请输入一个星期数(1-7)：");
		int week = sc.nextInt();
		System.out.println("今天是星期" + week);
		if (week == 1) {
			System.out.println("今天是星期一");
		} else if (week == 2) {
			System.out.println("今天是星期二");
		} else if (week == 3) {
			System.out.println("今天是星期三");
		} else if (week == 4) {
			System.out.println("今天是星期四");
		} else if (week == 5) {
			System.out.println("今天是星期五");
		} else if (week == 5) {
			System.out.println("今天是星期六");
		} else {
			System.out.println("今天是星期天");
		}
		
		System.out.println("结束");
			
    }
}

1.4.5 案例：考试奖励

需求：小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送给他不同的礼物，假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。

/*
    考试奖励
	
	需求：
	    小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，
		送给他不同的礼物，假如你可以控制小明的得分，请用程序实现
		小明到底该获得什么样的礼物，并在控制台输出。
	
    奖励：
        95~100    山地自行车一辆
        90~94     游乐场玩一次
        80~89     变形金刚玩具一个
        80以下    胖揍一顿		
*/
import java.util.Scanner;

public class IfTest02 {
	public static void main(String[] args) {
		//小明的考试成绩未知，可以使用键盘录入的方式获取值
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入一个分数：");
		int score = sc.nextInt();
		
		//由于奖励种类较多，属于多种判断，采用if...else...if格式实现
		//为每种判断设置对应的条件
		//为每种判断设置对应的奖励
		//&& 短路与   左边为真，执行右边，左边为假，右边不执行;充当"且"的关系
		/*
		if (score>=95 && score<=100 ) {
			System.out.println("山地自行车一辆");
		} else if (score>=90&&score<=94) {
			System.out.println("游乐场玩一次");
		} else if (score>=80&&score<=89) {
		    System.out.println("变形金刚玩具一个");	
		} else {
			System.out.println("胖揍一顿");
		}
		*/
		//数据测试：正确数据，边界数据，错误数据
	    //||短路或  左边为真，右边不执行，左边为假，右边执行;充当"或"的关系
		/*
		if (score >100 || score < 0) {
			System.out.println("你输入的分数有误");
		} else if (score>=95 && score<=100 ) {
			System.out.println("山地自行车一辆");
		} else if (score>=90&&score<=94) {
			System.out.println("游乐场玩一次");
		} else if (score>=80&&score<=89) {
		    System.out.println("变形金刚玩具一个");	
		} else {
			System.out.println("胖揍一顿");
		}
		*/
		if (score >100 | score < 0) {
			System.out.println("你输入的分数有误");
		} else if (score>=95 & score<=100 ) {
			System.out.println("山地自行车一辆");
		} else if (score>=90&score<=94) {
			System.out.println("游乐场玩一次");
		} else if (score>=80&score<=89) {
		    System.out.println("变形金刚玩具一个");	
		} else {
			System.out.println("胖揍一顿");
		}
		
	}
}

1.5 switch语句格式

1.5.1 switch语句格式

/*
    switch语句
	
	格式：
	    switch(表达式) {
			case 值1:
			语句体1;
			break;
			case 值2:
			语句体2;
			break;
			...
			default;
			语句体n+1;
			[break;]
		}
	
	格式说明：
	    表达式：取值为byte、short、int、char,JDK5以后可以是枚举，JDK7以后可以是String.
		case: 后面跟的是要和表达式进行比较的值。
		break: 表示中断，结束的意思，用来结束switch语句。
		default: 表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
		
	执行流程：
	    首先计算表达式的值。
		依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
		如果所有的case后面到底值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束掉。

*/

import java.util.Scanner;

public class SwitchDemo {
	public static void main(String[] args) {
		System.out.println("开始");
		
		//需求：键盘录入一个星期数(1,2,3...7),输出对应的星期一，星期二，...星期日
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入一个星期数(1-7):");
		//接收数据
		int week = sc.nextInt();
		
		switch(week) {
			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;
		}
		
	}
}

1.5.2 案例：春夏秋冬

需求：一年中有12个月，分别属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。

/*
    春夏秋冬
	
	需求：
	     一年有12个月，分属于春夏秋冬4个季节，键盘录入
		 一个月份，请用程序实现判断该月份属于哪个季节，并输出
	
	春： 3、4、5
	夏： 6、7、8
	秋： 9、10、11
	冬： 1、2、12
*/

import java.util.Scanner;

public class SwitchTest {
	public static void main(String[] args) {
		//键盘录入月份数据，使用变量接收
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入一个月份：");
		int month = sc.nextInt();
		
		//多情况判断，这里采用switch语句实现
		//在每种情况下，完成输出对应的季节
		
		/*
		switch(month) {
			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;
			case 8:
			    System.out.println("夏季");
				break;
            case 9:
			    System.out.println("秋季");
				break;
			case 10:
			    System.out.println("秋季");
				break;
            case 11:
			    System.out.println("秋季");
				break;
			case 12:
			    System.out.println("冬季");
				break;	
            default:
                System.out.println("输入的月份有误");
                //此时break;可不写				
			
		}
		*/
		//进行优化
		
		//case穿透
		switch (month) {
			case 1:
			case 2:
			case 12:
			    System.out.println("冬季");
				break;
			case 3:
			case 4:
			case 5:
			    System.out.println("春季");
				break;
			case 6:
			case 7:
			case 8:
			    System.out.println("夏季");
				break;
			case 9:
			case 10:
			case 11:
			    System.out.println("秋季");
				break;
			default:
			    System.out.println("输入的月份有误");
		}
	}
}

循环语句

1.for循环语句

1.1循环结构

循环结构的特征：

1.重复做某件事情

2.具有明确的开始和停止标志

1.2 for循环语句格式

/*
    for语句
	
	格式：
	
	    for(初始化语句;条件判断语句;条件控制语句) {
			循环体语句;
		}
	
	执行流程：
	1.执行初始化语句
	2.执行条件判断语句，看其结果是true还是false
	    如果是false,循环结束
		如果是true,继续执行
	3.执行循环体语句
	4.执行条件控制语句
	5.回到2执行
*/

public class ForDemo {
	public static void main(String[] args) {
		//需求：在控制台输入5次"HelloWorld"
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("----------");
		
		//用循环改进
		自增自减运算符单独使用时，i++和++i效果一样。习惯放后面 i++
		for(int i=1;i<=5;i++) {
			System.out.println("HelloWorld");
		}
	}
}

1.3 案例：输出数据

需求：在控制台输出1-5和5-1的数据

/*
    输出数据
	
	需求：
	    在控制台输出1-5和5-1
		
*/

public class ForTest01 {
	public static void main(String[] args) {
		//需求：输出数据1-5
		for(int i = 1; i<=5; i++) {
			System.out.println(i);
		}
		System.out.println("---------");
		//需求：输出数据5-1
		for(int i =5; i>=1; i--) {
			System.out.println(i);
		}
	}
}

1.4 案例：求和

需求：求1-5之间的数据和，并把求和结果在控制台输出

/*
    求和
	
	需求：
	    求1-5之间的数据和，并把求和结果在控制台输出
		
*/

public class ForTest02 {
	public static void main(String[] args) {
		//求和的最终结果是必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
		int sum = 0;
		//从1开始到5结束，使用循环结构完成
		for (int i = 1 ;i<=5;i++) {
			//讲反复进行的事情写入循环结构内部，此处反复进行的事情是将数据 i加到用于保存最终求和变量 sum中
			sum += i;
		}
		
		//将循环执行完毕时，将最终数据打印出来
		System.out.println("1-5之间的数据和为：" + sum);
		
		/*
		sum += 1;本质是sum = sum + 1;
		第一次是 sum = sum + i = 0 + 1 = 1
		第二次是 sum = sum + i = 1 + 2 = 3
		...
		*/
	}
}

1.5 案例：求偶数和

需求：求1-100之间的偶数和，并把求和结果在控制台输出

/*
    求偶数和
	
	需求：
	    求1-100之间的偶数和，并把求和结果在控制台输出
		
*/

public class ForTest03 {
	public static void main(String[] args) {
		//求和的最终结果是必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
		int sum = 0;
		//求奇数和
		int sum_ = 0;
		//对1-100的数据求和与1-5的数据求和大致相同
		for (int i = 1; i<=100;i++) {
			//对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数
			if (i % 2 == 0) {
				sum += i;	
			} else {
				sum_ += i;	
			}
		}
		//当循环执行完毕时，将最终数据打印出来
		System.out.println("1-100之间的偶数和为：" + sum);
		System.out.println("1-100之间的奇数和为：" + sum_);
	}
}

1.6 案例：水仙花

需求：在控制台输出所有的"水仙花数"

/*
    水仙花
	
	需求：
	    在控制台输出所有的"水仙花数"
		
*/

public class ForTest04 {
	public static void main(String[] args) {
		//输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
		/*
		for (int i =100;i<1000;i++) {
			
		}
		*/
		for (int i =100; i<=999;i++) {
			//在计算之前获得三位数中每个位上的值
			int ge = i % 10;
			int shi = i/10 % 10;
			int bai = i/10/10 % 10;
			
			//判定条件是将三位数中的每个数值取出来，计算立方和后与原始数字比较是否相等
			if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
				//输出满足条件的数字就是水仙花数
				System.out.println(i);
			}
		}	
	}
} 

1.7 案例：统计

需求：统计"水仙花数" 一共有多少个，并在控制台输出个数

/*
    统计
	
	需求：
	    统计"水仙花数"一共有多少个，并在控制台输出个数
*/

public class ForTest05 {
	public static void main(String[] args) {
		//定义变量名count,用于保存"水仙花数"的数量，初始值为0
		int count = 0;
		//输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
		for (int i =100;i<1000;i++) {
			//在计算之前获得三位数中每个位上的值
			int ge = i%10;
			int shi = i/10%10;
			int bai = i/10/10%10;
			
			//在判定水仙花数的过程中，满足条件不再输出，更改为修改count的值，使count+1
			if (ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
				count++;
			}
		}

		//打印输出最终结果
		System.out.println("水仙花共有：" + count + "个");
	}
}

2.while循环语句

2.1while循环语句格式

/*
    while语句
	
	基本格式：
	    while(条件判断语句){
			循环体语句;
		}
	
	完整格式：
	    初始化语句;
		while(条件判断语句) {
			循环体语句;
			条件控制语句;
		}
	
	执行流程：
	    1.执行初始化语句
		2.执行条件判断语句，看其结果是true还是false
		    如果是false,循环结束
			如果是true,继续执行
		3.执行循环体语句
		4.执行条件控制语句
		5.回到2继续
*/

public class WhileDemo {
	public static void main(String[] args) {
		//需求：在控制台输出5次"HelloWorld"
		//用for循环
		
		for (int i = 1;i<=5;i++) {
			System.out.println("HelloWorld");
		}
		System.out.println("---------");
		//用while循环实现
		int j = 1;
		while (j <= 5) {
			System.out.println("HelloWorld");
			j++;
		}
	}
}

2.2 案例：珠穆朗玛峰

需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米),假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?

/*
    珠穆朗玛峰
	
	需求：
	
	    世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米),
		假如我有一张足够大的纸，它的厚度是0.1毫米。
		请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
*/

public class WhileTest {
	public static void main(String[] args) {
		//定义一个计数器，初始值为0
		int count = 0;
		//定义纸张厚度
		double paper = 0.1;
		//定义珠穆朗玛峰的高度
		int zf = 8844430;
		//因为要反复折叠，所有要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
		//折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
		while (paper <= zf) {
        //循环的执行过程中每次纸张折叠，纸张的厚度要加倍
		paper *=2;
		//在循环中执行累加，对应折叠了多少次
		count++;
		}
		
		//打印计数器的值
		System.out.println("需要折叠：" + count + "次");
	}
}

3.do…while循环语句

3.1 do…while循环语句格式

/*
    do...while语句
	
	基本格式：
	do {
		循环体语句;
	}while(条件判断语句);
	
	完整格式：
	    初始化语句;
		do {
			循环体语句;
			条件控制语句;
		} while(条件判断语句);
		
	执行流程：
	    1.执行初始化语句
		2.执行循环体语句
		3.执行条件控制语句
		4.执行条件判断语句，看其结果是true还是false
		    如果是false,循环结束
			如果是true,继续执行
		5.回到2执行
*/

public class DoWhileDemo {
	public static void main(String[] args) {
		//需求：在控制台输出5次"HelloWorld"
		
		//for循环实现
		for(int i =1; i<=5;i++) {
			System.out.println("HelloWorld");
		}
		System.out.println("----------");
		
		//while循环实现
		int j = 1;
		while(j<=5) {
			System.out.println("HelloWorld");
			j++;
		}
		System.out.println("===========");
		
		//do...while循环实现
		int z = 1;
		do {
			System.out.println("HelloWorld");
			z++;
		} while(z<=5);
	}
}

3.2三种循环的区别

/*
    三种循环的区别
*/

public class LoopTest {
	public static void main(String[] args) {
		/*
		//for循环
		for(int i =3; i<3;i++){
			System.out.println("学习Java");
		}
		System.out.println("----------");
		
		//while循环
		int j =3;
		while(j<3){
			System.out.println("学习Java");
			j++;
		}
		System.out.println("===========");
		//do...while循环
		int k =3;
		do {
			System.out.println("学习java");
			k++;
		}while(k<3);
		*/
		/*
		for(int i =3; i<3;i++){
			System.out.println("学习Java");
		}
		//System.out.println(i); 报错
		System.out.println("----------");
		
		//while循环
		int j =3;
		while(j<3){
			System.out.println("学习Java");
			j++;
		}
		System.out.println(j);
		System.out.println("===========");
		*/
		//死循环
		/*
	    for(;;) {
			System.out.println("for");
		}
		*/
		/*
		while(true) {
			System.out.println("while");
		}
		*/
		/*
		do {
			System.out.println("do...while");
		}while(true);
		*/
		
	} 
}

4.跳转控制语句

4.1跳转控制语句概述

continue	用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行
break	用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环

public class ControlDemo {
	public static void main(String[] args) {
		for(int i =1;i<=5;i++){
			//筛选偶数
			if(i % 2 == 0){
				//continue;
		        break;
			}
			System.out.println(i);
		}
		
	}
}

5.循环嵌套

5.1 循环语句的概述

/*
    循环嵌套：
	    循环语句中包含循环语句
		
	需求：
	    在控制台输出一天的小时和分钟
		
		分钟和小时的范围：
		    分钟: 0<= minute <60
		    小时：0<= hour < 24
*/

public class ForForDemo {
	public static void main(String[] args) {
		/*
		System.out.println("0时0分");
		System.out.println("0时1分");
		System.out.println("0时2分");
		System.out.println("0时3分");
		System.out.println("------");
		System.out.println("1时0分");
		System.out.println("1时1分");
		System.out.println("1时2分");
		System.out.println("1时3分");
		System.out.println("-------");
		System.out.println("2时0分");
		System.out.println("2时1分");
		System.out.println("2时2分");
		System.out.println("2时3分");
		*/
		
		//循环改进
		/*
		for(int minute=0;minute<4;minute++){
			System.out.println("0时" + minute + "分");
		}
		System.out.println("---------");
		for(int minute=0;minute<4;minute++){
			System.out.println("0时" + minute + "分");
		}
		System.out.println("==========");
		for(int minute=0;minute<4;minute++){
			System.out.println("0时" + minute + "分");
		}
		*/
		//外循环控制小时的范围，内循环控制分钟的范围
	    /*
		for(int hour=0;hour<3;hour++){
			for(int minute=0;minute<4;minute++){
			System.out.println(hour + "时" + minute + "分");
			}
			System.out.println("---------");
		}
		*/
		for(int hour=0;hour<24;hour++){
			for(int minute=0;minute<60;minute++){
			System.out.println(hour + "时" + minute + "分");
			}
			System.out.println("---------");
		}
		
	} 
}

6.Random

6.1 Random的作用和使用步骤

作用：随机产生的一个随机数

使用步骤：

/*
    Random
	
	作用：
	    1.导包
		    import java.util.Random;
		2.创建对象
		    Random r = new Random();
		3.获取随机数
		    int number = r.nextInt(10);
			获取数据的范围：[0,10) 包括0，不包括10
*/

import java.util.Random;


public class RandomDemo {
	public static void main(String[] args) {
		//创建对象
		Random r = new Random();
		
		//获取随机数
		for(int i=0;i<10;i++) {
			int number = r.nextInt(10);
		
		    System.out.println("number为"+ number);
		}
		//需求：获取一个1-100之间的随机数
		//分析：nextInt(100)只能取到0-99，加个1，就可以实现1-100
		int x = r.nextInt(100)+1;
		System.out.println(x);
		
	}
}

6.2 案例：猜数字

/*
    猜数字
	
	需求：
	
	    程序自动生成一个1-100之间的数字，使用程序实现猜中这个数字是多少？
		当猜错的时候根据不同情况给出相应的提示
		
		如果猜的数字比真实数字大，提示你猜的数据大了
		如果猜的数字比真实数字小，提示你猜的数据小了
		如果猜的数字与真实数字相等，提示恭喜你猜中了
*/

import java.util.Random;
import java.util.Scanner;

public class RandomTest{
	public static void main(String[] args) {
		//要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围到1到100
		//创建对象
		Random r = new Random();
		int number = r.nextInt(100) + 1;
		
		while(true) {
			//使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
			//创建对象
			Scanner sc = new Scanner(System.in);
			
			System.out.println("请输入你要猜的数字：");
			
			//接收数据
			int guessNumber = sc.nextInt();
			
			//比较输入的数字和系统实现产生的数据，需要使用分支语句，这里使用if...else...if...格式，根据不同的情况进行猜测结果显示
			if(guessNumber > number){
				System.out.println("你猜的数字" + guessNumber + "大了");
			}else if(guessNumber < number) {
				System.out.println("你猜的的数字"+guessNumber + "小了");
			}else {
				System.out.println("恭喜你猜中了");
				break;
			}
		}
		
	}
}

python实现：

""""
猜数字
1.计算机随机生成一个1-100以内的正整数
2.用户通过键盘输入数字，猜测计算机所生成的随机数。
3.注意：对用户输入的次数不做限制

"""
import random
guessNumber = random.randint(1,101)

while True:
    user_number = input("请输入一个数字：")
    #  isdigit() 方法检测字符串是否只由数字组成
    if user_number.isdigit():
        user_number = int(user_number)
        if user_number > guessNumber:
            print("你猜的数字" + str(user_number) + "大了")
        if user_number < guessNumber:
            print("你猜的数字" + str(user_number) + "小了")
        if user_number == guessNumber:
            print("恭喜你，猜中了！")
            break
    else:
        print("非法输入！请重新输入")
        continue