第三章 流程控制2

第三章 流程控制

3.5 循环结构（for循环）

3.5.1 调用格式

for(初始化语句①; 循环条件语句②; 迭代语句④){
	循环体语句③//如果循环体中没有跳出循环体的语句，那么就是死循环
}

• 注：

  • for( ; ; )中的两个分号”;“，不能多也不能少；

  • 循环条件必须是boolean类型；

  • 如果循环条件语句②省略的话，就默认为循环条件成立。

3.5.2 案例演示

1. 案例演示1

/*
打印1-100的偶数
*/
class Test02{
	public static void main(String[] args){
		//int sum = 0;
		System.out.println("1-100的偶数为：");
		for(int i = 1;i <= 100;i++){
			if(i % 2 ==0){
				System.out.println(i);
			}
		}
	}
}

2. 案例演示2

/*
输入两个正整数m和n，求其最大公约数和最小公倍数
*/
import java.util.Scanner;
class Test07{
	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		
		System.out.print("请输入第一个数：");
		int m = scan.nextInt();
		
		System.out.print("请输入第二个数：");
		int n = scan.nextInt();
		
		int max = (m>=n)?m:n;
		int min = (m<=n)?m:n;
		
		System.out.println();
		//最大公约数：
		for(int i = min;i >= 1;i--){
			if(m % i == 0 && n % i == 0){
				System.out.println(i + "是" +m + "和" + n + "的最大公约数");
				break;
			}
		}
		//最小公倍数：
		for(int i = max;i <=max*min ;i++){
			if(i % m == 0 && i % n == 0){
				System.out.println(i + "是" +m + "和" + n + "的最小公倍数");
				break;
			}
		}
	}
}

3.6 循环结构（while循环）

3.6.1 调用格式

初始化语句①;
while (循环条件语句②) {
    循环体语句③；//如果此时循环体中没有跳出循环的语句，也是死循环
    迭代语句④；
}

• 说明

1. 不在循环条件部分限制的结构：for(;;)或while(true)；
2. 结束循环的方式：
   ① 循环条件部分返回false；
   ② 在循环体中，执行break；

3.6.2 案例演示

1. 案例演示1

/*
 *	练习：趣味折纸
 * 	
 *	题目：
 *		世界最高山峰是珠穆朗玛峰，它的高度是8844.43米，假如我有一张足够大的纸，它的厚度是0.1毫米。
 *		请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
 */
public class WhileTest01 {
    public static void main(String[] args) {
		//定义一个计数器，初始值为0
		int count = 0;
		
		//定义纸张厚度
		double paper = 0.1;
		
		//定义珠穆朗玛峰的高度
		int zf = 8844.43*1000;//米转换为毫米
		
		//因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
		//折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
		while(paper <= zf) {
			//循环的执行过程中每次纸张折叠，纸张的厚度要加倍
			paper *= 2;
			
			//在循环中执行累加，对应折叠了多少次
			count++;
		}
		
		//打印计数器的值
		System.out.println("需要折叠：" + count + "次");
    }

3.7 循环结构（do-while）

3.7.1 调用格式

初始化条件①;
	do{
		循环体语句③;
		迭代语句④;
	}while(循环条件（boolean类型）②)

• 说明：
  • do-while循环至少会执行一次循环体；
  • do…while结构的循环体语句是至少会执行一次，这个和for和while是不一样的。

3.7.2 案例演示

1. 案例演示1

public static void main(String[] args){
		//随机生成一个100以内的整数
		/*
		Math.random() ==> [0,1)的小数
		Math.random()* 100 ==> [0,100)的小数
		(int)(Math.random()* 100) ==> [0,100)的整数
		*/
		int num = (int)(Math.random()* 100);
		//System.out.println(num);
		
		//声明一个变量，用来存储猜的次数
		int count = 0;
		
		java.util.Scanner input = new java.util.Scanner(System.in);
		int guess;//提升作用域
		do{
			System.out.print("请输入100以内的整数：");
			guess = input.nextInt();
			
			//输入一次，就表示猜了一次
			count++;
			
			if(guess > num){
				System.out.println("大了");
			}else if(guess < num){
				System.out.println("小了");
			}
		}while(num != guess);
		
		System.out.println("一共猜了：" + count+"次");

3.7.3 循环语句的区别

• 从循环次数角度分析
  • do…while循环至少执行一次循环体语句
  • for和while循环先循环条件语句是否成立，然后决定是否执行循环体，至少执行零次循环体语句
• 从循环变量的生命周期角度分析
  • for循环的循环变量在for()中声明的，在循环语句结束后，不可以被访问；
  • while和do…while循环的循环变量因为在外面声明的，所以while和do…while结束后可以被继续使用的；
• 如何选择
  • 遍历有明显的循环次数（范围）的需求，选择for循环
  • 遍历没有明显的循环次数（范围）的需求，循环while循环
  • 如果循环体语句块至少执行一次，可以考虑使用do…while循环
  • 本质上：三种循环之间是可以互相转换的，都能实现循环的功能
• 三种循环结构都具有四要素：
  • （1）循环变量的初始化表达式；
  • （2）循环条件;
  • （3）循环变量的修改的迭代表达式；
  • （4）循环体语句块。

3.8 控制语句

3.8.1 break

• 使用场景：终止switch或者当前循环
  • 在选择结构switch语句中；
  • 在循环语句中；
  • 离开使用场景的存在是没有意义的。

3.8.2 continue

• 使用场景：结束本次循环，继续下一次的循环

3.9 嵌套循环

• 所谓嵌套循环，是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数。当然可以是三种循环任意互相嵌套。
• 嵌套循环格式：

for(初始化语句①; 循环条件语句②; 迭代语句⑦) {
    for(初始化语句③; 循环条件语句④; 迭代语句⑥) {
      	循环体语句⑤;
    }
}

3.9.1 扩展说明

1. 内层循环结构遍历一次，只相当于外层循环执行了一次；

2. 假设外层循环需要执行m次，内层循环需要执行n次，此时内层循环体一共执行了m*n次；

3. 外层循环控制行数，内层循环控制列数；

4. 案例演示1

/*
一个数如果恰好等于它的因子之和，这个数就称为"完数"。（因子：除去这个数本身的约数）

例如6=1＋2＋3.编程 找出1000以内的所有完数
*/
class CompletionNumber{
	public static void main(String[] args){
		for(int i = 1;i <= 1000;i++){
			int sum = 0;
			for(int j = 1;j < i;j++){
				if(i%j ==0){
					sum +=j;
				}
			}
			if(sum == i){
				System.out.println(i);
			}
			
		}
		
	}
}

2. 案例演示2

/*
嵌套循环：
     *
	* *
   * * *
  * * * *
 * * * * *
  * * * * 
   * * * 
    * *
	 *
说明：
	1.内层循环结构遍历一次，只相当于外层循环执行了一次；
	2.假设外层循环需要执行m次，内层循环需要执行n次，此时内层循环体一共执行了m*n次；
	3.外层循环控制行数，内层循环控制列数；
*/
class Rhombus{
	public static void main(String[] args){
		//-------------------方法1---------------------
		//上半段
		for(int i = 1;i<=5;i++){
			for(int j =5-i;j>0;j--){
				System.out.print(" ");
			}
			for(int k =1;k<=i;k++){
				System.out.print("* ");
			}
			System.out.println();
		}
		//下半段
		for(int i = 1;i<=4;i++){
			System.out.print(" ");
			for(int j =1;j<i;j++){
				System.out.print(" ");
			}
			for(int k =1;k<=5-i;k++){
				System.out.print("* ");
			}
			System.out.println();
		}
		
	

		//空心菱形
				System.out.println("-----空心菱形----\n");	
		//上半部分
		for(int i = 1;i <= 5;i++){
			for(int j = 1;j <= 5-i;j++){
				System.out.print("  ");
			}
			for(int j = 1;j <= 2*i-1;j++){
				if(j==1|| j == 2*i-1){
					System.out.print("* ");
				}else{
					System.out.print("  ");
				}
				
			}
			System.out.println();
		}
		//下半部分
		for(int i = 1;i <= 4;i++){
			for(int j = 1;j <= i;j++){
				System.out.print("  ");
			}
			for(int j = 1;j <= 9-2*i;j++){
				if(j==1|| j == 9-2*i){
					System.out.print("* ");
				}else{
					System.out.print("  ");
				}
			}
			System.out.println();
		}
		System.out.println("-----空心菱形----\n");	
	}

}