switch和循环（Java基础语句3）

内容介绍

  • 分支结构语句：switch

  • 循环结构： for while do…while

  • Random类(jdk提供的)

今日重点：for循环和while循环！ ★★★★★

1. switch结构

  • switch格式为?
  • 执行流程为?

① switch语句的格式

1. switch语句的格式
  		switch(被检测的数据){ // 被检测数据一般是一个变量(有值)
            case 数值1:
            	语句体1；
            	break;
            case 数值2：
            	语句体2；
            	break;
            case 数值3：
            	语句体3；
            	break;
            ......
            default:
            	语句体n；
            	break;
  		}

对比if语句来学习switch语句

  
//if语句：								  switch语句：		
int number = 10;						int number =10;
if(number==1){							switch(number){
	语句体1；							  	 case 1:		
}else if(number==2){							语句体1；
    语句体2；									 break;
}else if(number==10){						case 2:
    语句体3；									  语句体2；	
}else{											 break;
    语句体n;								  case 10: 
}												 语句体3；
												 break;
                                            default:
                                                 语句体n;
                                                  break;

② switch语句的执行流程

* 格式：
		switch(被检测的数据){ // 被检测数据一般是一个变量(有值)
            case 数值1:
            	语句体1；
            	break;
            case 数值2：
            	语句体2；
            	break;
            case 数值3：
            	语句体3；
            	break;
            ......
            default:
            	语句体n；
            	break;
  		} 
* 执行流程：

	* 执行被检测数据(它可能是一个表达式) 【当然它还可以是一个变量】
	* 然后执行第一个case语句，拿着case的数值与被检测的数据进行匹配：
		匹配上了，就执行该case里面的语句体，遇到break就结束switch语句。
		未匹配上，就拿着第二个case的数值与被检测数据进行匹配：
			匹配上了，就执行该case里面的语句体，遇到break就结束switch语句。	
			未匹配上，就拿着第三个case的数值与被检测数据进行匹配：
 				依次类推。。。
	* 若所有的case数值都与被检测数据不匹配，那么就执行default里面的语句体，遇到break结束switch语句。

switch语句改写减肥计划案例

/**
	需求：键盘录入一个星期数，给出对应的减肥计划
		1	星期一
		2	星期二
		3	星期三
		4	星期四
		5	星期五
		6	星期六
		7	星期日
		
*/
import java.util.Scanner;
public class Demo01{
	public static void main(String[] args){
		
		// 1. 创建键盘录入核心对象
		Scanner sc = new Scanner(System.in);
		// 2. 给出友好提示
		System.out.println("请输入一个星期数：[1-7]");
		// 3. 获得用户输入的星期数数字
		int week = sc.nextInt();
		
		// 判断
		/*
			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 ==6){
				System.out.println("拳击");
			}else if(week ==7){
				System.out.println("好好吃一顿");
			}else{
				System.out.println("您录入的星期数有误！");
			}
		*/
		
		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;
		}
		
	}
}

③ switch语句的注意事项

1.case后面的值不允许重复

int week = sc.nextInt();
switch(week){
    case 1:
        System.out.println("爬山");
        break;
    case 1: // 重复的case值，编译会报错！
        System.out.println("游泳");
        break;
    case 3:
        System.out.println("跑步");
        break;
    default:
        System.out.println("您录入的星期数有误！");	
        break;
}

2.switch里面的被检测数据的数据类型只能是： byte short char int 枚举 String

double week = 3;		
switch(week){  // week变量的数据类型是double,不符合switch语句的要求，编译报错！
    case 1:
        System.out.println("爬山");
        break;
    case 2:
        System.out.println("游泳");
        break;

    default:
        System.out.println("您录入的星期数有误！");	
        break;
}

3.default的问题

/*
	default语句不论放在switch语句的哪个位置，它都不会先执行！ 它永远先执行第一个case语句！
	只有当所有的case值都与被检测数据不匹配才会执行default语句！
*/
switch(week){
    // default语句不会先执行，当case值都不匹配才会执行！    
    default:
        System.out.println("您录入的星期数有误！");	
        break;
    case 1:
        System.out.println("爬山");
        break;
    case 2:
        System.out.println("游泳");
        break;
}
/*
	default语句若放在switch语句的末尾，那么break语句可以省略不写！【default语句里面的break建议写上！】
	default语法若不是放在switch语句的末尾，没有写break语句，依旧会发生穿透现象！
*/

4.case的穿透

/*
	当我们在书写switch语句的时候，忘记书写break语句，那么此时就会发生case穿透现象！	
*/
switch(week){
    case 1:
        System.out.println("爬山");
        // 此处没有写break语句，会发生case穿透！【下面可能是case语句，也可能是default语句，都会穿透！】
        // 穿透case语句，那么它是不做case值的匹配，直接进入下一个穿透的case语句体。
        // 结束：要么遇到break,要么就执行到switch语句的末尾
    default:
        System.out.println("您录入的星期数有误！");	
        break;	
    case 2:
        System.out.println("游泳");
        break;
}

5.case取值

/*
	★ case的值必须是一个常量
*/
int a = 1;		
switch(week){
    // 编译报错， 需要常量表达式   
    case a:
        System.out.println("爬山");
        break;
    default:
        System.out.println("您录入的星期数有误！");	
        break;
}

/*
	★ case常量值的类型要有被检测数据的类型一致！
*/
String week = "1";
switch(week){
    case 1:  // 此时，case的值1是一个int类型的，与被检测数据week(字符串)的类型不一致，编译报错！
        System.out.println("爬山");
        break;
    default:
        System.out.println("您录入的星期数有误！");	
        break;
}

2. 春夏秋冬 ★

  • 需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。
  • 代码:【春季：3 4 5 夏季：6 7 8 秋季：9 10 11 冬季：12 1 2】
/*
	需求：键入录入一个整数(月份)，打印对应的季节
		春季：3,4,5
		夏季：6,7,8
		秋季：9,10,11
		冬季：12,1,2

*/

import java.util.Scanner;

public class Demo02{
	public static void main(String[] args){
		// 1. 创建键盘录入核心对象
		Scanner sc = new Scanner(System.in);
		// 2. 给出友好提示
		System.out.println("请输入一个月份：[1-12]");
		// 3. 获得用户键盘录入的月份数据使用变量存储
		int month = sc.nextInt();
	
		// 判断
		/*
			switch(month){
				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;
				case 1:
					System.out.println("冬季");
					break;
				case 2:
					System.out.println("冬季");
					break;
				default:
					System.out.println("您输入的月份有误！");
					break;	
			}
		*/
		
		// 使用switch语句的穿透性，改写上面的代码！
		switch(month){
			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;
			case 12:
			case 1:
			case 2:
				System.out.println("冬季");
				break;
			default:
				System.out.println("您输入的月份有误！");
				break;	
		}
	}
}
  • 10分钟时间练习
  • 问题: 选择结构语句, if, switch两种, 该如何选择呢?
不管if还是switch语句都是用于判断，属于分支结构！！！！
那么我们可以从判断的条件入手！！！！！

★ 判断的条件(关系表达式/被检测数据)如果是一个固定数值范围，那么建议使用switch语句 【星期1-7 月份1-12】
★ 判断的条件(关系表达式/被检测数据)如果是一个数值区间范围，那么建议使用if语句 【数介于3到6之间】

3. for结构

  • for循环的格式为?
  • 其执行流程是?
总结：【循环的特点：重复执行某个动作，有明确的开始和结束】
1. for循环的格式	
	格式：
		for(初始化表达式;条件判断语句;控制语句){
			// 循环体;
		}
	解释说明：
		①初始化表达式：确定循环的开始
		②条件判断语句：确定循环的结束
		③循环体：不断重复执行的功能！
		④控制语句：又称之为步进！
		整个循环执行的次数由 ①②④三部分来确定！！！
	举例：输出5次 我爱黄焖鸡！
		for(int i = 1; i <= 5; i++){
			System.out.println("我爱黄焖鸡！");
		}
		
		当i=1的时候，i的确小于等于5，所以会进入for循环，也就说会执行第一次：System.out.println("我爱黄焖鸡！"); 【1】
		然后执行控制语句 i++  此时i的值就变成了2
		接着执行条件判断语句，此时i的值为2，它的确小于等于5，所以再次进入for循环，System.out.println("我爱黄焖鸡！");【2】
		然后执行控制语句 i++  此时i的值就变成了3
		接着执行条件判断语句，此时i的值为3，它的确小于等于5，所以再次进入for循环，System.out.println("我爱黄焖鸡！");【3】
        然后执行控制语句 i++  此时i的值就变成了4
        接着执行条件判断语句，此时i的值为4，它的确小于等于5，所以再次进入for循环，System.out.println("我爱黄焖鸡！");【4】
        然后执行控制语句 i++  此时i的值就变成了5
        接着执行条件判断语句，此时i的值为5，它的确小于等于5，所以再次进入for循环，System.out.println("我爱黄焖鸡！");【5】
        然后执行控制语句 i++  此时i的值就变成了6
        接着执行条件判断语句，此时i的值为6，它不再小于等于5，条件判断语句结果为false,结束整个for循环！        

2. 执行流程	
	① 先执行初始化表达式
	② 执行条件判断语句，如果为true，执行循环体③
	③ 循环体(要重复执行的代码)，执行完毕后执行控制语句④
	④ 控制语句(步进)，让初始表达式的变量每次的变化多少，然后再次执行条件判断语句②
	② 拿着改变后的初始化表达式的变量的值去判断(执行条件判断语句)，如果为true,执行循环体③
	.....
	直到 条件判断语句的结果为false,它就不再执行循环体，此时整个for循环结束！！！
	
3. 注意事项	
	不要在for循环后面的小括号与大括号之间写分号！！！！！
        for(int i=1;i<=5;i++);{ // 此处多了一个分号，for循环没有循环体！后面的{}是一个独立的代码块！
            System.out.println("我爱黄焖鸡！");
        }
	上面的代码与我们预期的结果是不一样的！它压根儿就没有进行循环！！！！

4. 循环(遍历)输出数据 ★

  • for循环练习之获取数据1-5和5-1
  • 示例代码:
/**
	需求：循环亦称之为遍历
		for循环输出 1-10  1 2 3 4 5 6 7 8 9 10	正序！
		for循环输出 10-1  10 9 8 7 6 5 4 3 2 1	倒序！
		
	之前我们学习for循环知道，它有明确的开始和结束！	
		正序：
			开始：从1
			结束：到10
			步进：每次+1
			
		倒序：
			开始：从10
			结束：到1
			步进：每次-1
*/
public class Demo05{
	public static void main(String[] args){
	
		// 正序遍历1-10
		for(int i=1;i<=10;i++){
			System.out.println(i);
		}
        
		System.out.println("=================");
		
		// 倒序遍历10-1
		for(int i=10;i>=1;i--){
			System.out.println(i);
		}	
        
	}
}
  • 7分钟时间练习

5. 求和

  • 需求: for循环练习之求1-5的数据和

  • 示例代码: 1 2 3 4 5

  • 分析：

    ​ 在循环的外部定义一个变量，记录每次获得数据的和！ int sum = 0;

    ​ 1 sum+=1; // +=的含义：将符号左侧变量的值与右侧的数值相加再赋值给左侧的变量 sum = 1

    ​ 2 sum+=2 ; // sum = 3

    ​ 3 sum+=3; // sum = 6

    ​ 4 sum+=4; // sum = 10

    ​ 5 sum+=5; // sum = 15

public class Demo04{
	public static void main(String[] args){
		// 1. 定义一个变量来存储1-5之间数据累加和，初始化值为0
		int sum = 0;
		// 2. 使用循环遍历出1-5之间的数字
		for(int i=1;i<=5;i++){
			// 3. 累加求和
			//sum = sum + i; // 使用上一次的和与当前的数字相加然后赋值给记录累加求和的变量sum！
			sum += i;
			/*
				当i = 1: sum += i ====>>> sum = sum + i = 0 + 1 = 1
				当i = 2：sum += i ====>>> sum = sum + i = 1 + 2 = 3
				当i = 3：sum += i ====>>> sum = sum + i = 3 + 3 = 6
				当i = 4：sum += i ====>>> sum = sum + i = 6 + 4 = 10
				当i = 5：sum += i ====>>> sum = sum + i = 10 + 5 = 15
			*/
		}
		
		// 4. 打印输出求和的数值
		System.out.println("1-5之间数据的累加和是：" + sum);
	}	
}
  • 5分钟时间练习

6. 求偶数和

  • 需求：求1-100之间的偶数和，并把求和结果在控制台输出
  • 示例代码:
public class Demo05{
	public static void main(String[] args){
		// 1. 定义一个变量来存储1-100之间数据累加和，初始化值为0
		int sum = 0;
		// 2. 使用循环遍历出1-100之间的数字
		/*for(int i=1;i<=100;i++){
			
			// 判断是否为偶数
			if(i%2 == 0){
				// 说明此时的数字i它就是一个偶数，累加求和
				// 3. 累加求和
				//sum = sum + i; // 使用上一次的和与当前的数字相加然后赋值给记录累加求和的变量！
				sum += i;
				
			}
		}*/
		
		// 第二种方式！
		for(int i =2;i<=100;i+= 2){
			sum += i;
		}
			
		// 4. 打印输出求和的数值
		System.out.println("1-5之间数据的累加和是：" + sum);
	}
	
}
  • 5分钟时间练习

7. 水仙花数

  • 什么是水仙花数?【获得三位数中(100-999)的所有水仙花数：】
水仙花数是一个三位数, 其每一位的立方和相加的结果还等于该数本身
	例如 153 --> 3 * 3 * 3 + 5 * 5 * 5 + 1 * 1 * 1 = 153

分析:

	1. 使用for循环, 获取到所有的三位数 (100-999)
	2. 在循环过程中, 将三位数拆分成个位,十位,百位
	3. 加入if语句判断条件
  • 示例代码:
/*
	获得所有的水仙花数！
		水仙花数是一个三位数(100-999), 其每一位的立方和相加的结果还等于该数本身
		例如 153 --> 3 * 3 * 3 + 5 * 5 * 5 + 1 * 1 * 1 = 153
		
	分析：
		1.使用for循环获得100-999之间所有的整数(三位数)
		2.在循环里面获得当前遍历出来的这个三位数的，个位、十位、百位的数字 
			以153为例：
				个位：对10取模 153%10  ====>>> 3
				十位：除以10，然后对10取模  153/10%10 =====>>> 15%10 ====>>> 5
				百位：除以100
		3.对三位数进行筛选(判断) 个位的³ + 十位的³ + 百位的³ = 这个三位数本身，符合这个添加就输出这个三位数！
		
*/

public class Demo06{
	public static void main(String[] args){
		// 1. 使用for循环获得100-999之间所有的整数(三位数)
		for(int i=100;i<1000;i++){
			// 2.分别获得当前这个三位数的个位、十位、百位的数字
			int ge = i%10;
			int shi = i/10%10;
			int bai = i/100;
			// 3. 判断
			if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i){
				// 4.程序能执行到这里，说明这个数字i就是符合条件的数字，打印输出
				System.out.println(i); // 153 370 371 407
			}
		}
	}	
}
  • 10分钟时间练习

8. 统计水仙花数个数 ★

  • 需求: 统计水仙花数出现的个数
  • 示例代码:
/*
	获得所有的水仙花数的个数
		水仙花数是一个三位数(100-999), 其每一位的立方和相加的结果还等于该数本身
		例如 153 --> 3 * 3 * 3 + 5 * 5 * 5 + 1 * 1 * 1 = 153
		
	分析：		
		0.定义一个变量记录水仙花的个数，初始值为0
		1.使用for循环获得100-999之间所有的整数(三位数)
		2.在循环里面获得当前遍历出来的这个三位数的，个位、十位、百位的数字 
			以153为例：
				个位：对10取模 153%10  ====>>> 3
				十位：除以10，然后对10取模  153/10%10 =====>>> 15%10 ====>>> 5
				百位：除以100
		3.对三位数进行筛选(判断) 个位的3 + 十位的3 + 百位的3 = 这个三位数本身，符合这个条件，让记录水仙花个数的变量+1	
*/
public class Demo07{
	public static void main(String[] args){
		
		// 定义一个变量记录水仙花的个数，初始值为0
		int count = 0;
		
		// 1. 使用for循环获得100-999之间所有的整数(三位数)
		for(int i=100;i<1000;i++){
			// 2.分别获得当前这个三位数的个位、十位、百位的数字
			int ge = i%10;
			int shi = i/10%10;
			int bai = i/100;
			// 3. 判断
			if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i){
				// 4.程序能执行到这里，说明这个数字i就是符合条件的数字，让记录水仙花个数的变量+1
				count++;
			}
		}
		
		// 输出记录所有水仙花数据的变量即可
		System.out.println("水仙花的个数为：" + count);
	}
	
}
  • 5分钟时间改进代码

9. while结构

  • while循环的格式为?
  • 其执行流程是?
总结：
	1.while循环的格式：
		基本格式：
			while(条件判断语句){
				循环体；
			}
		
		完整格式：
			初始化语句;
			while(条件判断语句){
				循环体语句；
				步进(控制语句)；
			}

		for循环：
			for(初始化语句；条件判断语句；步进){
				循环体；
			}

	2.while循环的执行流程：【与for循环完全一样的！】
		先执行初始化语句；
		然后执行条件判断语句：
			结果为true:
				它就会执行循环体语句
				执行完循环体语句之后，就会执行步进(条件控制语句)
				然后再执行条件判断语句：
					如果条件为true,就再执行一次循环体，步进，接着执行条件判断语句，直到条件判断语句为false，它就结束while循环！

	3. 例如：打印5次 黄焖鸡
		
		int i = 0;
		while(i<5){
			System.out.println("黄焖鸡");
			i++;
		}

		for(int i=0;i<5;i++){
			System.out.println("黄焖鸡");
		}

10. 珠穆朗玛峰 ★

  • 需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
  • 示例代码:
/*
	需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。
	请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
		
	分析：
		1. 定义一个变量记录纸张的厚度！
		2. 定义一个变量统计最终折叠的次数(这个变量我们有一个专门的名词：计数器)
		3. 我们可以使用循环来完成，因为不知道具体需要折叠多少次(循环的次数)，我们使用while循环比较合适的！
		4. 循环中，每折叠一次，纸张的厚度需要加倍的！只要这个纸张的厚度没有超过珠穆朗玛峰，就一直循环下去！
		5. 在循环中，没进入一次，需要让计数器+1	
*/

public class Demo08{
	public static void main(String[] args){
		// 1.定义一个变量记录纸张的厚度！
		double paper = 0.1;
		// 2.定义一个变量统计最终折叠的次数(这个变量我们有一个专门的名词：计数器)
		int count = 0;
		
		// 3.我们可以使用循环来完成，因为不知道具体需要折叠多少次(循环的次数)，我们使用while循环比较合适的！
		while(paper <= 8844430){
			// 4. 纸张加倍
			paper *= 2;
			// 5. 让计数器+1
			count++;
		}
		
		// 6. 输出折叠的次数
		System.out.println("需要折叠：" + count + "次，就可以达到珠穆朗玛峰的高度！");

	}
	
}
  • 7分钟时间练习

11. do…while结构 [了解]

  • 格式:
	初始化语句;
    do {
        循环体语句;
        条件控制语句;
    }while(条件判断语句);


其余的2种循环：
	for(初始化语句；条件判断语句；条件控制语句){
		循环体语句；
	}
	
	初始化语句；
	while(条件判断语句){
		循环体语句；
		条件控制语句(步进)
	}
  • 执行流程:
① 执行初始化语句
② 执行循环体语句
③ 执行条件控制语句
④ 执行条件判断语句，看其结果是true还是false
	如果是false，循环结束
	如果是true，继续执行循环体、条件控制语句，再执行条件判断语句……

	特点: do..while循环, [无论条件是否满足, 都至少执行一次循环体.]

	原因在于: 程序从上到下依次执行

12. 三种循环的区别 ★

  • 三种循环的基本格式
1. for循环
	for(初始化语句;条件判断语句;条件控制语句){
		循环体语句;
	}

	例如：
		for(int i=1;i<=5;i++){
			System.out.println("我爱黄焖鸡！");
		}

2. while循环
	初始化话语句;
	while(条件判断语句){
		循环体语句;
		条件控制语句;
	}
	例如：
		int i = 1;
		while(i<=5){
			System.out.println("我爱黄焖鸡！");
			i++;
		}
	while还有基本格式：
		while(条件判断语句){
            循环体语句;
        }
	
3. do...while循环
	初始化语句;
	do{
		循环体语句;
		条件控制语句;
	}while(条件判断语句);

	例如：
		int i = 1;
		do{
			System.out.println("我爱黄焖鸡！");
			i++;
		}while(i<=5);

	do...while还有基本格式：
		do{
			循环体语句;
		}while(条件判断语句);
  • 三种循环的区别
for循环、while循环与do...while循环的区别：
	do...while循环至少会执行一次循环体！
  • for循环和while的区别 [重点掌握]
for循环无法获得里面的变量的值！
while循环可以获得里面的变量值！

在没有明确需要循环多少次的时候，优先考虑while循环！
  • 死循环（无限循环）的三种格式
for循环:
	for(;;){
   		System.out.println("for");
    }
while循环：
	while(true){
    	System.out.println("while");
    }
do...while循环：
	do{
    	System.out.println("do...while");
    }while(true);

结论：开发中偶尔会使用以下while死循环！ 【死循环：了解即可！】
	可以使用ctrl+c在命令行中结束死循环！！！！！

以后开发，三种循环，for循环使用是最多的，在不明确循环次数的时候我们会是用while，do...while基本不怎么使用！死循环我们基本上使用的都是while死循环！

13. 跳转控制语句 ★

  • break有什么作用?
  • break的应用环境是?
总结:
	直接终止循环！【循环、switch语句】

在这里插入图片描述

我们可以通过break来控制死循环：

while(true){
	System.out.println("while");
	if(满足特定条件){
		break;
	}
}
  • continue有什么作用?
  • continue的应用环境是?
总结:
	结束本次循环，进入下一次循环【循环当中使用！】

在这里插入图片描述

14. 循环嵌套 ★

  • 什么是循环嵌套?
    * 在循环中，继续定义循环
结论: 
	在一个循环中的循环体又出现一个循环！

问题: 什么时候使用循环嵌套呢??
	二维数组, 集合
		为将来遍历二维数组, 做铺垫.
  • 示例代码:
public static void main(String[] args) {
    //外循环控制小时的范围，内循环控制分钟的范围
    for (int hour = 0; hour < 24; hour++) {
        for (int minute = 0; minute < 60; minute++) {
            System.out.println(hour + "时" + minute + "分");
        }
        System.out.println("--------");
    }
}
  • 扩展案例: 控制台输出4行5列的
*****
*****
*****
*****
*****

在这里插入图片描述

  • 扩展案例: 控制台输出正三角形
*
**
***
****
*****

/*
	打印一个正三角形，也是需要使用循环嵌套！
		5行：外层的循环跟之前一样的！
			列:
				第一行：打印1列：
				第二行：打印2列：
				第三行：打印3列：
				第四行：打印4列：
				第五行：打印5列：
			结论：列受行的控制【列<=行】		
*/
for(int i=0;i<5;i++){  // 打印五行！
    for(int j=0;j<=i;j++){
        System.out.print("*");
    }
    System.out.println();
}
  • 扩展案例: 控制台输出99乘法表
/*
    打印99乘法表：
    1 * 1 = 1
    1 * 2 = 2	2 * 2 = 4
    1 * 3 = 3	2 * 3 = 6	3 * 3 = 9
    ……
*/
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();
}

15. Random

  • 概述：
Random类似Scanner，也是Java提供好的API，内部提供了产生[随机数]的功能

​ API后续课程详细讲解，现在可以简单理解为Java已经写好的代码

  • 使用步骤：
第一步：导包 
	import java.util.Random;      // 必须放在类的上面！

第二步：创建对象
	Random random = new Random(); // 除了random这个变量名可以修改之外，其它的都是固定的！

第三步：获得随机数
	int num = random.nextInt(10); // 获取0-9之间的数字 【num变量名可以修改，数值10可以修改，其余的固定】
	
	获得1-100 ： random.nextInt(100)+1;
  • 示例代码: 获得 1-100之间的10个随机数
// 1.导包
import java.util.Random;
public class Demo09{
    public static void main(String[] args){
        // 2.创建Random对象
        Random random = new Random();
        // 3.循环
        for(int i=0;i<10;i++){
        	// 4.生成随机数
            int number = random.nextInt(100)+1;
            // 5.打印
            System.out.println("生成的随机数为："+number);
        }
    }
}

16. Random练习-猜数字游戏 ★

  • 需求：
    程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
    当猜错的时候根据不同情况给出相应的提示
    A. 如果猜的数字比真实数字大，提示你猜的数据大了
    B. 如果猜的数字比真实数字小，提示你猜的数据小了
    C. 如果猜的数字与真实数字相等，提示恭喜你猜中了
思路分析：
	1.生成一随机数(1-100之间)，记录到一个变量 int number
	2.键盘录入数据，记录到一个变量 int guess
	3.用录入的数据与随机生成的数据进行比较
		if(guess<number){
			// 猜的数太小了！
		}else if(guess>number){
			// 猜的数太大 了
		}else if(guess==number){
			// 猜对了
		}
	4.不能确定一次性猜对，可以使用死循环来完成！
  • 示例代码:
/*
	需求：
		程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
		当猜错的时候根据不同情况给出相应的提示
		A. 如果猜的数字比真实数字大，提示你猜的数据大了
		B. 如果猜的数字比真实数字小，提示你猜的数据小了
		C. 如果猜的数字与真实数字相等，提示恭喜你猜中了
	
	分析：
		1.使用Random生成一个1-100之间的随机数
		2.使用键盘录入，录入用户猜测的数字
		3.使用录入的数字与生成的随机数进行比较
			如果猜的数字比真实数字大，提示你猜的数据大了
			如果猜的数字比真实数字小，提示你猜的数据小了
			如果猜的数字与真实数字相等，提示恭喜你猜中了
		4.使用死循环(让用户一直猜，当用户猜对了，才结束这个死循环<break>)	
*/

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

public class Demo10{
	public static void main(String[] args){
		// 创建对象
		Random random = new Random();
		// 生成1-100之间的一个随机数
		int number = random.nextInt(100)+1;
		//System.out.println(number);
		
		while(true){	
			// 创建对象
			Scanner scanner = new Scanner(System.in);
			
			// 给出友好提示
			System.out.println("请输入您猜测的数字[1-100]：");
			
			// 接收用户猜测的数字
			int guess = scanner.nextInt();
			
			// 用用户猜测的数字与生成的随机数进行比对
			if(guess > number){
				System.out.println("您猜的数过大！");
			}else if(guess < number){
				System.out.println("您猜的数过小！");
			}else if(guess == number){
				System.out.println("恭喜您，猜对了！");
				// 猜对了，结束死循环
				break;
			}
		}
	}
	
}

今日内容总结

1.switch语句
	★ 格式
		switch(被检测数据){
			case 值1：
				语句体1；
				break;
			case 值2：
				语句体2；
				break;
            ……
            default:
            	语句体n;
            	break;
		}
	★ 执行流程
		
	★ 细节
		
2. for循环 ★★★★★
	★格式
    	for(初始化语句;条件判断;步进){
    		循环体；
    	}
    ★执行流程
    
3. while循环 ★★★★
	★格式：
		初始化语句;
		while(条件判断语句){
			循环体;
			步进;
		}
		
	★执行流程

4. do...while循环 ★
	★格式
		初始化语句;
		do{
			循环体语句；
			步进;
		}while(条件判断语句);
	★执行流程

5.三种循环的区别
	for while与do...while
    
    for与while
    	for循环里面的变量i,只能在循环内部使用，一旦循环结束，内存就会释放！【变量的作用范围】
    	在不确定循环次数的情况下，建议使用while循环
     	
    三种死循环的写法：
    	for(;;){}
    	while(true){}  ★★★★★
    	do{}while(true);

6.跳转控制语句
	break:结束整个循环或者switch语句 
	continue:结束本次循环，进入下一次循环！
	
7.循环嵌套：
	★ 执行流程
		for(int i=0;i<5;i++){
			for(int j= 0;j<5;j++){
				System.out.println("*");
			}
		}
 8.Random类的使用
 	★ 操作步骤

// 接收用户猜测的数字
int guess = scanner.nextInt();

		// 用用户猜测的数字与生成的随机数进行比对
		if(guess > number){
			System.out.println("您猜的数过大！");
		}else if(guess < number){
			System.out.println("您猜的数过小！");
		}else if(guess == number){
			System.out.println("恭喜您，猜对了！");
			// 猜对了，结束死循环
			break;
		}
	}
}

}


## 今日内容总结

```markdown
1.switch语句
	★ 格式
		switch(被检测数据){
			case 值1：
				语句体1；
				break;
			case 值2：
				语句体2；
				break;
            ……
            default:
            	语句体n;
            	break;
		}
	★ 执行流程
		
	★ 细节
		
2. for循环 ★★★★★
	★格式
    	for(初始化语句;条件判断;步进){
    		循环体；
    	}
    ★执行流程
    
3. while循环 ★★★★
	★格式：
		初始化语句;
		while(条件判断语句){
			循环体;
			步进;
		}
		
	★执行流程

4. do...while循环 ★
	★格式
		初始化语句;
		do{
			循环体语句；
			步进;
		}while(条件判断语句);
	★执行流程

5.三种循环的区别
	for while与do...while
    
    for与while
    	for循环里面的变量i,只能在循环内部使用，一旦循环结束，内存就会释放！【变量的作用范围】
    	在不确定循环次数的情况下，建议使用while循环
     	
    三种死循环的写法：
    	for(;;){}
    	while(true){}  ★★★★★
    	do{}while(true);

6.跳转控制语句
	break:结束整个循环或者switch语句 
	continue:结束本次循环，进入下一次循环！
	
7.循环嵌套：
	★ 执行流程
		for(int i=0;i<5;i++){
			for(int j= 0;j<5;j++){
				System.out.println("*");
			}
		}
 8.Random类的使用
 	★ 操作步骤
版权声明：本文为user_name_CSDN原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。