第3章 流程控制

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。程序设计中规定的三种流程结构，即：

• 顺序结构

  • 程序从上到下逐行地执行，中间没有任何判断和跳转。

• 分支结构

  • 根据条件，选择性地执行某段代码。

  • 有if…else和switch-case两种分支语句。

• 循环结构

  • 根据循环条件，重复性的执行某段代码。

  • 有for、while、do-while三种循环语句。

  • 补充：JDK5.0 提供了foreach循环，方便的遍历集合、数组元素。

1、顺序结构

        顺序结构就是程序从上到下逐行地执行。表达式语句都是顺序执行的。并且上一行对某个变量的修改对下一行会产生影响。

//代码依次往下执行，即顺序结构
public class StatementTest{
	public static void main(String[] args){
		int x = 1;
		int y = 2;
		System.out.println("x = " + x);		
        System.out.println("y = " + y);	
        //对x、y的值进行修改
        x++;
        y = 2 * x + y;
        x = x * 10;	
        System.out.println("x = " + x);
        System.out.println("y = " + y);
    }
}

Java中定义变量时采用合法的前项引用，举例如下

public static void main(String[] args) {

    //正确形式
	int num1 = 12;
	int num2 = num1 + 2;
    //错误形式
    int num3 = num4 + 2;
	int num4 = 12;
}

2、分支结构

2.1 if-else条件判断结构

（1）基本语法

 （i）结构1：单分支条件判断：if

         格式如下

if(条件表达式)｛
      语句块;
｝

 注：条件表达式必须是布尔表达式（关系表达式或逻辑表达式）或 布尔变量。

 执行流程如下：

• 首先判断条件表达式看其结果是true还是false

• 如果是true就执行语句块

• 如果是false就不执行语句块

  （ii）结构2：双分支条件判断：if...else

 if(条件表达式) {
      语句块1;
}else {
      语句块2;
}

 执行流程：

• 首先判断条件表达式看其结果是true还是false

• 如果是true就执行语句块1

• 如果是false就执行语句块2

 （iii）结构3：多分支条件判断：if...else if...else

         格式：

if (条件表达式1) {
      语句块1;
} else if (条件表达式2) {
      语句块2;
}
...
}else if (条件表达式n) {
     语句块n;
} else {
      语句块n+1;
}

注：一旦条件表达式为true，则进入执行相应的语句块。执行完对应的语句块之后，就跳出当前结构。

执行流程

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

• 如果是true就执行语句块1，然后结束当前多分支

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

• 如果是true就执行语句块2，然后结束当前多分支

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

• …
• n. 如果没有任何关系表达式为true，就执行语句块n+1，然后结束当前多分支。

 

  （2）例题分析

例题1：  成年人心率的正常范围是每分钟60-100次。体检时，如果心率不在此范围内，则提示需要做进一步的检查。

public class IfElseTest1{

    public static void main(String [] args){
            int herartNumber = 70;
            if(heartNumber > 60 && heartNumber <100){
                System.out.println("您的体检结果正常！");
            }else{
                System.out.println("您还需做进一步检查！");
            }
        
    }
}

例题2： 定义一个整数，判定是偶数还是奇数

public class IfElseTest2{

    public static void main(String []args){
        int number = 12;
        if(number % 2 == 0){
            System.out.println("该数字为偶数");
        }else {
            System.out.println("该数字为奇数");
        } 
    }
}

例题3： 岳小鹏参加Java考试，他和父亲岳不群达成承诺：如果：成绩为100分时，奖励一辆跑车；成绩为(80，99]时，奖励一辆山地自行车；当成绩为[60,80]时，奖励环球影城一日游；其它时，胖揍一顿。说明：默认成绩是在[0,100]范围内。

public class IfElseTest3{
    public static void main(String [] args){
        double grade = 85;
        if(grade == 100){
            System.out.println("奖励一辆跑车");
        }else if(grade > 80){
            System.out.println("奖励一辆山地自行车");
            
        }else if(grade >= 60){
            System.out.println("奖励环球影城一日游");
        }else {
            System.out.println("胖揍一顿");
        }
    
    }

}

注意：

（i）当条件表达式之间是“互斥”关系时（即彼此没有交集），条件判断语句及执行语句间顺序无所谓。

（ii）当条件表达式之间是“包含”关系时，“小上大下 / 子上父下”，否则范围小的条件表达式将不可能被执行。

(3) If - else 的嵌套使用

在 if 的语句块中，或者是在else语句块中，又包含了另外一个条件判断（可以是单分支、双分支、多分支），就构成了嵌套结构。

执行的特点： （i）如果是嵌套在if语句块中的，只有当外部的if条件满足，才会去判断内部的条件 （ii）如果是嵌套在else语句块中的，只有当外部的if条件不满足，进入else后，才会去判断内部的条件

例题4：由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else)，并且从小到大输出。

class IfElseTest4 {
	public static void main(String[] args) {
		
			//声明num1,num2,num3三个变量并赋值
			int num1 = 23,num2 = 32,num3 = 12;

			if(num1 >= num2){
				
				if(num3 >= num1)
					System.out.println(num2 + "-" + num1 + "-" + num3);
				else if(num3 <= num2)
					System.out.println(num3 + "-" + num2 + "-" + num1);
				else
					System.out.println(num2 + "-" + num3 + "-" + num1);
			}else{ //num1 < num2
				
				if(num3 >= num2){
					System.out.println(num1 + "-" + num2 + "-" + num3);
				}else if(num3 <= num1){
					System.out.println(num3 + "-" + num1 + "-" + num2);
				}else{
					System.out.println(num1 + "-" + num3 + "-" + num2);
				}
			}
	}
}

注意：

• 语句块只有一条执行语句时，一对{}可以省略，但建议保留

• 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略

 （4）课后练习

练习1：

//1)对下列代码，若有输出，指出输出结果。
int x = 4;
int y = 1;
if (x > 2) {
       if (y > 2) 
            System.out.println(x + y);
       		System.out.println("atguigu");
} else
       System.out.println("x is " + x);

答案：有输出，atguigu

练习2：

boolean b = true;
//如果写成if(b=false)能编译通过吗？如果能，结果是？
if(b == false) 	 //建议：if(!b)
	System.out.println("a");
else if(b)
	System.out.println("b");
else if(!b)
	System.out.println("c");
else
	System.out.println("d");

答案：输出 b; 改编：能通过编译，输出c

练习3：定义两个整数，分别为small 和 big，如果第一个整数small大于第二个整数big，就交换。输出显示small和big变量的值。

public class IfElseExer3 {
    public static void main(String[] args) {
        int small = 133;
        int big = 12;

        if (small > big) {
            int temp = small;
            small = big;
            big = temp;
        }
        System.out.println("small=" + small + ",big=" + big);
    }
}

练习4：张三参加期末Java考试，通过考试成绩，判断其Java等级，成绩范围[0,100]

• 90-100 优秀

• 80-89 好

• 70-79 良

• 60-69 及格

• 60以下 不及格

import java.util.Scanner;
public class IfElseTest {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入你的Java考试成绩");
        int grade = scan.nextInt();
        if(grade >90){
            System.out.println("您的成绩为优秀！");
        }else if(grade >80){
            System.out.println("您的成绩为好！");
        }else if(grade>70){
            System.out.println("您的成绩为良");
        } else if (grade > 60) {
            System.out.println("您的成绩为及格!");
        }else {
            System.out.println("您的成绩不及格！");
        }
        scan.close();

    }
}

补充知识：Java语言如何实现键盘输入功能

• 如何从键盘获取不同类型（基本数据类型、String类型）的变量：使用Scanner类。

• 键盘输入代码的四个步骤：

  1. 导包：import java.util.Scanner;

  2. 创建Scanner类型的对象：Scanner scan = new Scanner(System.in);

  3. 调用Scanner类的相关方法（next() / nextXxx()），来获取指定类型的变量

  4. 释放资源：scan.close();

• 注意：需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常 导致程序终止。

例题 ：各种类型的数据输入

案例：小明注册某交友网站，要求录入个人相关信息。如下：

请输入你的网名、你的年龄、你的体重、你是否单身、你的性别等情况。

//① 导包
import java.util.Scanner;

public class ScannerTest1 {

    public static void main(String[] args) {
        //② 创建Scanner的对象
        //Scanner是一个引用数据类型，它的全名称是java.util.Scanner
        //scanner就是一个引用数据类型的变量了，赋给它的值是一个对象（对象的概念我们后面学习，暂时先这么叫）
        //new Scanner(System.in)是一个new表达式，该表达式的结果是一个对象
        //引用数据类型  变量 = 对象;
        //这个等式的意思可以理解为用一个引用数据类型的变量代表一个对象，所以这个变量的名称又称为对象名
        //我们也把scanner变量叫做scanner对象
        Scanner scanner = new Scanner(System.in);//System.in默认代表键盘输入
        
        //③根据提示，调用Scanner的方法，获取不同类型的变量
        System.out.println("欢迎光临你好我好交友网站！");
        System.out.print("请输入你的网名：");
        String name = scanner.next();

        System.out.print("请输入你的年龄：");
        int age = scanner.nextInt();

        System.out.print("请输入你的体重：");
        double weight = scanner.nextDouble();

        System.out.print("你是否单身（true/false)：");
        boolean isSingle = scanner.nextBoolean();

        //scanner.next()是用来输入字符串的
        System.out.print("请输入你的性别：");
        char gender = scanner.next().charAt(0);//先按照字符串接收，然后再取字符串的第一个字符（下标为0）
        
        System.out.println("你的基本情况如下：");
        System.out.println("网名：" + name + "\n年龄：" + age + "\n体重：" + weight + 
                           "\n单身：" + isSingle + "\n性别：" + gender);
        
        //④ 关闭资源
        scanner.close();
    }
}

2.2 switch-case选择结构

 （1）基本语法

基本格式：

switch(表达式){
    case 常量值1:
        语句块1;
        //break;
    case 常量值2:
        语句块2;
        //break;
    // ...
   [default:
        语句块n+1;
        break;
   ]
}

 执行过程：

第1步：根据switch中表达式的值，依次匹配各个case。如果表达式的值等于某个case中的常量值，则执行对应case中的执行语句。

第2步：执行完此case的执行语句以后， ​ 情况1：如果遇到break,则执行break并跳出当前的switch-case结构 ​ 情况2：如果没有遇到break，则会继续执行当前case之后的其它case中的执行语句。--->case穿透 ​ ... ​ 直到遇到break关键字或执行完所有的case及default的执行语句，跳出当前的switch-case结构。

注意：

• switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0)；

• case子句中的值必须是常量，不能是变量名或不确定的表达式值或范围；

• 同一个switch语句，所有case子句中的常量值互不相同；

• break语句用来在执行完一个case分支后使程序跳出switch语句块；

  如果没有break，程序会顺序执行到switch结尾；

• default子句是可选的。同时，位置也是灵活的。当没有匹配的case时，执行default语句。

  （2）例题分析

例题1： 数字转换

import java.util.Scanner;
public class SwitchCaseTest1 {
    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个数字0~9");
        int num = scanner.nextInt();
        switch (num){
            case 0:
                System.out.println("零");
                break;
            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;
            default:
                System.out.println("其他");

        }
        scanner.close();
    }
}

例题2：季节转换

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请选择你喜欢的季节：spring、summer、autumn、winter");
        String season = scanner.next();
        switch (season){
            case "spring":
                System.out.println("春天");
                break;
            case "summer":
                System.out.println("夏天");
                break;
            case "autumn":
                System.out.println("秋天");
                break;
            case "winter":
                System.out.println("冬天");
                break;
            default:
                System.out.println("输入有误！");

        }
        scanner.close();
    }

例题3：经典错误

int key = 10;
switch(key){
	case key > 0 :
        System.out.println("正数");
        break;
    case key < 0:
        System.out.println("负数");
        break;
    default:
        System.out.println("零");
        break;
}

//原因：case值不可以为表达式

例题4：使用switch-case实现：对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

class SwitchCaseTest3 {
	public static void main(String[] args) {
		
		int score = 67;
		/*
		写法1：极不推荐
		switch(score){
			case 0:
				System.out.println("不及格");
				break;
			case 1:
				System.out.println("不及格");
				break;
			//...

			case 60:
				System.out.println("及格");
				break;
			//...略...
		
		}
		*/

		//写法2：
		switch(score / 10){
			case 0:
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
				System.out.println("不及格");
				break;
			case 6:
			case 7:
			case 8:
			case 9:
			case 10:
				System.out.println("及格");
				break;
			default:
				System.out.println("输入的成绩有误");
				break;
		}

		//写法3：
		switch(score / 60){
			case 0:
				System.out.println("不及格");
				break;
			case 1:
				System.out.println("及格");
				break;
			default:
				System.out.println("输入的成绩有误");
				break;
		}
	}
}

注意：在switch语句中，如果case的后面不写break，将出现穿透现象，也就是一旦匹配成功，不会在判断下一个case的值，直接向后运行，直到遇到break或者整个switch语句结束，执行终止。

例题5：从键盘上输入2023年的“month”和“day”，要求通过程序输出输入的日期为2023年的第几天。

import java.util.Scanner;

class SwitchCaseTest4 {
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入2023年的month:");
		int month = scan.nextInt();

		System.out.println("请输入2023年的day:");
		int day = scan.nextInt();

		//这里就不针对month和day进行合法性的判断了，以后可以使用正则表达式进行校验。

		int sumDays = 0;//记录总天数
		
		//写法1 ：不推荐（存在冗余的数据）
		/*
		switch(month){
			case 1:
				sumDays = day;
				break;
			case 2:
				sumDays = 31 + day;
				break;
			case 3:
				sumDays = 31 + 28 + day;
				break;
			//....
		
			case 12:
				//sumDays = 31 + 28 + ... + 30 + day;
				break;
		}
		*/

		//写法2：推荐
		switch(month){
			case 12:
				sumDays += 30;//这个30是代表11月份的满月天数
			case 11:
				sumDays += 31;//这个31是代表10月份的满月天数
			case 10:
				sumDays += 30;//这个30是代表9月份的满月天数
			case 9:
				sumDays += 31;//这个31是代表8月份的满月天数
			case 8:
				sumDays += 31;//这个31是代表7月份的满月天数
			case 7:
				sumDays += 30;//这个30是代表6月份的满月天数
			case 6:
				sumDays += 31;//这个31是代表5月份的满月天数
			case 5:
				sumDays += 30;//这个30是代表4月份的满月天数
			case 4:
				sumDays += 31;//这个31是代表3月份的满月天数
			case 3:
				sumDays += 28;//这个28是代表2月份的满月天数
			case 2:
				sumDays += 31;//这个31是代表1月份的满月天数
			case 1:
				sumDays += day;//这个day是代表当月的第几天
		}
		
		System.out.println(month + "月" + day + "日是2023年的第" + sumDays + "天");
        //关闭资源
		scan.close();
	}
}

变式：从键盘分别输入年、月、日，判断这一天是当年的第几天
 
注：判断一年是否是闰年的标准：
   1）可以被4整除，但不可被100整除
      或
   2）可以被400整除
   
例如：1900，2200等能被4整除，但同时能被100整除，但不能被400整除，不是闰年

Scanner scanner = new Scanner(System.in);
        System.out.print("请输入年份year");
        int year = scanner.nextInt();
        boolean flag;
        if(((year % 4 == 0) &&(year %100)!=0)||year % 400 == 0){
            flag = true;
        }else{
            flag = false;
        }
        System.out.print("请输入月份month");
        int month = scanner.nextInt();
        System.out.print("请输入日期day");
        int day = scanner.nextInt();
        int sumday =0;
        switch (month){
            case 12:
                sumday += 30;

            case 11:
                sumday += 31;
            case 10:
                sumday += 30;
            case 9:
                sumday += 31;
            case 8:
                sumday +=31;
            case 7:
                sumday += 30;
            case 6:
                sumday += 31;
            case 5:
                sumday += 30;
            case 4:
                sumday += 31;
            case 3:
                if(flag){
                    sumday += 29;
                }else{
                    sumday += 28;
                }

            case 2:
                sumday += 31;
            case 1:
                sumday += day;

        }
        System.out.println(year+"年"+month+"月"+day+"日"+"是"+year+"年的第"+sumday+"天");
        scanner.close();

例题6：需求：指定一个月份，输出该月份对应的季节。一年有四季:
         3,4,5    春季
         6,7,8    夏季
         9,10,11    秋季
         12,1,2    冬季

public class SwitchCaseTest5 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入月份：");
        int month = input.nextInt();

       
		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的穿透性改进代码

Scanner scanner = new Scanner(System.in);
        System.out.print("请输入月份month");
        int month = scanner.nextInt();
        switch (month){
            case 12:
            case 1:
            case 2:
                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;
        }
        scanner.close();

注意错误实现方式：

switch(month){
    case 3|4|5://3|4|5 用了位运算符，11 | 100 | 101结果是 111是7
        System.out.println("春季");
        break;
    case 6|7|8://6|7|8用了位运算符，110 | 111 | 1000结果是1111是15
        System.out.println("夏季");
        break;
    case 9|10|11://9|10|11用了位运算符，1001 | 1010 | 1011结果是1011是11
        System.out.println("秋季");
        break;
    case 12|1|2://12|1|2 用了位运算符，1100 | 1 | 10 结果是1111，是15
        System.out.println("冬季");
        break;
    default:
        System.out.println("输入有误");
}

(3)if-else语句与switch-case语句比较

（i）结论：凡是使用switch-case的结构都可以转换为if-else结构。反之，不成立。

（ii）经验：如果既可以使用switch-case，又可以使用if-else，建议使用switch-case。因为效率稍高。

（iii）对比：

• if-else语句优势

  • if语句的条件是一个布尔类型值，if条件表达式为true则进入分支，可以用于范围的判断，也可以用于等值的判断，使用范围更广。

  • switch语句的条件是一个常量值（byte,short,int,char,枚举,String），只能判断某个变量或表达式的结果是否等于某个常量值，使用场景较狭窄。

• switch语句优势

  • 当条件是判断某个变量或表达式是否等于某个固定的常量值时，使用if和switch都可以，习惯上使用switch更多。因为效率稍高。当条件是区间范围的判断时，只能使用if语句。

  • 使用switch可以利用穿透性，同时执行多个分支，而if...else没有穿透性。

（4）练习题

练习1：从键盘输入星期的整数值，输出星期的英文单词

Scanner scan = new Scanner(System.in);
        int num = scan.nextInt();

        //方法一：if-else
        /*if(num == 1){
            System.out.println("Monday");
        } else if (num == 2) {
            System.out.println("Tuesday");
        } else if (num == 3) {
            System.out.println("Wednesday");
        } else if (num == 4) {
            System.out.println("Thursday");
        } else if (num == 5) {
            System.out.println("Friday");
        } else if (num == 6) {
            System.out.println("Saturday");
        } else if (num == 7) {
            System.out.println("Sunday");
        }else{
            System.out.println("输入有误！");
        }*/
        //方法2：switch -casse结构
        switch (num){
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            case 6:
                System.out.println("Saturday");
                break;
            case 7:
                System.out.println("Sunday");
                break;
            default:
                System.out.println("您的输入有误！");

        }


        scan.close();

练习2：

编写程序：从键盘上读入一个学生成绩，存放在变量score中，根据score的值输出其对应的成绩等级：

score>=90           等级:  A
70<=score<90        等级:  B    
60<=score<70        等级:  C
score<60            等级:  D

方式一：使用if-else
方式二：使用switch-case:  score / 10:   0 - 10

Scanner scan  = new Scanner(System.in);
        System.out.print("请输入您的考试成绩");
        int grade = scan.nextInt();
//        方式一：使用if-else
        /*if(grade >= 90){
            System.out.println("您的等级为A");
        } else if (grade >= 70) {
            System.out.println("您的等级为B");
        } else if (grade >= 60) {
            System.out.println("您的等级为C");
        }else{
            System.out.println("您的等级为D");
        }*/
        switch (grade/10){
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("您的等级为D");
                break;
            case 6:
                System.out.println("您的等级为C");
                break;
            case 7:
            case 8:
                System.out.println("您的等级为B");
                break;
            case 9:
            case 10:
                System.out.println("您的成绩为A");
                break;
            default:
                System.out.println("您的输入有误！");
        }
        scan.close();

练习 3：编写一个程序，为一个给定的年份找出其对应的中国生肖。中国的生肖基于12年一个周期，每年用一个动物代表：rat、ox、tiger、rabbit、dragon、snake、horse、sheep、monkey、rooster、dog、pig。

提示：2022年：虎   2022 % 12 == 6

Scanner scan  = new Scanner(System.in);
        System.out.print("请输入年份");
        int year = scan.nextInt();
        switch (year%12){
            case 0:
                System.out.println(year+"年对应的为rat");
                break;
            case 1:
                System.out.println(year+"年对应的为ox");
                break;
            case 2:
                System.out.println(year+"年对应的为tiger");
                break;
            case 3:
                System.out.println(year+"年对应的为rabbit");
                break;
            case 4:System.out.println(year+"年对应的为dragon");
                break;
            case 5:
                System.out.println(year+"年对应的为snake");
                break;
            case 6:
                System.out.println(year+"年对应的为horse");
                break;
            case 7:
                System.out.println(year+"年对应的为sheep");
                break;
            case 8:
                System.out.println(year+"年对应的为monkey");
                break;
            case 9:
                System.out.println(year+"年对应的为rooster");
                break;
            case 10:
                System.out.println(year+"年对应的为dog");
                break;
            default:
                System.out.println(year+"年对应的为pig");
                break;

        }
        scan.close();

补充知识：如何获取一个随机整数

• Math类的random()的调用，会返回一个[0,1)范围的一个double型值
• Math.random() * 100 ---> [0,100) (int)(Math.random() * 100) ---> [0,99] (int)(Math.random() * 100) + 5 ----> [5,104]
• 如何获取[a,b]范围内的随机整数呢？(int)(Math.random() * (b - a + 1)) + a
• 举例

  class MathRandomTest {
  	public static void main(String[] args) {
  		double value = Math.random();
  		System.out.println(value);
  
  		//[1,6]
  		int number = (int)(Math.random() * 6) + 1; //
  		System.out.println(number);
  	}
  }

  练习4：随机产生3个1-6的整数，如果三个数相等，那么称为“豹子”，如果三个数之和大于9，称为“大”，如果三个数之和小于等于9，称为“小”，用户从键盘输入押的是“豹子”、“大”、“小”，并判断是否猜对了提示：随机数  Math.random()产生 [0,1)范围内的小数 如何获取[a,b]范围内的随机整数呢？(int)(Math.random() * (b - a + 1)) + a

       代码思路：由于用户输入的是字符串（“豹子”、“大”、“小”）故无法使用等号来直接判断，在后面会有equals方法，本题采用的方法是当用户输入字符串以后，根据用户所输入的字符串去判断答案是否正确，例如用户输入豹子，那么我们需要判断三个数字是否相等，若不相等，则一定押宝错误，其他同理。

 int num1 =(int) (Math.random()*(6-1+1))+1;
        int num2 =(int) (Math.random()*(6-1+1))+1;
        int num3 =(int) (Math.random()*(6-1+1))+1;
        String result;
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的选择：豹子、大或者小");
        String guess = scanner.next();
        int sum = num1 +num2 + num3;
        if(num1 ==num2 && num2 ==num3){
             result = "豹子";
        }else if(sum > 9){
            result = "大";
        }else {
            result = "小";
        }

        System.out.println("num1 = "+num1+",num2 = "+num2+",num3 = "+num3);
        switch (guess){
            case "豹子":
                if(num1 ==num2 && num2 ==num3){
                    System.out.println("恭喜你，猜对了！");
                }else{
                    System.out.println("很遗憾猜错了，正确结果是"+result);
                }
                break;
            case "大":
                if(sum > 9){
                    System.out.println("恭喜你，猜对了！");
                }else{
                    System.out.println("很遗憾猜错了，正确结果是"+result);
                }
                break;
            case "小":
                if(sum < 9){
                    System.out.println("恭喜你，猜对了！");
                }else{
                    System.out.println("很遗憾猜错了，正确结果是"+result);
                }
                break;
        }

3、循环结构

• 理解：循环语句具有在某些条件满足的情况下，反复执行特定代码的功能。

• 循环结构分类：

  • for 循环

  • while 循环

  • do-while 循环

• 循环结构四要素：

  • 初始化部分

  • 循环条件部分

  • 循环体部分

  • 迭代部分

3.1 for 循环

（1）基本语法

        格式：

        for (①初始化部分; ②循环条件部分; ④迭代部分)｛
             ③循环体部分;
｝

执行过程：①-②-③-④-②-③-④-②-③-④-.....-②

说明：

• for(;;)中的两个；不能多也不能少

• ①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔

                例如：for(int i=0,j=1;;)

• ②循环条件部分为boolean类型表达式，当值为false时，退出循环

• ④可以有多个变量更新，用逗号分隔

                例如：for（int i = 0，j =0;i<10,j<10;i++,j++)

（2）例题分析

例题1 ：输出5行HelloWorld

public class ForTest1 {
    public static void main(String[] args) {
        //需求1：控制台输出5行Hello World!
		//写法1：
		//System.out.println("Hello World!");
		//System.out.println("Hello World!");
		//System.out.println("Hello World!");
		//System.out.println("Hello World!");
		//System.out.println("Hello World!");

		//写法2：
		for(int i = 1;i <= 5;i++){
			System.out.println("Hello World!");
		}
    }
}

  例题2：遍历1-100以内的偶数，并获取偶数的个数，获取所有的偶数的和

int num = 0;
       int sum = 0;
       for(int i = 1;i<100;i++){
           if(i%2==0){
               num++;
               sum+=i;
           }
       }
        System.out.println("偶数的个数为："+num+",偶数总和为："+sum);

 例题3：输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。例如： 153 = 1*1*1 + 3*3*3 + 5*5*5

int a,b,c;
       for(int i = 100;i<1000;i++){
           //获取三位数的百位
          a = i / 100;
          //获取三位数的十位
          b = (i % 100) / 10;
          //获取三位数的个位
          c= (i % 100) % 10;
          if(a*a*a+b*b*b+c*c*c==i){
              System.out.println(i);
          }
       }

例题4：（重点）输入两个正整数m和n，求其最大公约数和最小公倍数。比如：12和20的最大公约数是4，最小公倍数是60。

public class ForTest5 {
    public static void main(String[] args) {
        //需求1：最大公约数
        int m = 12, n = 20;
        //取出两个数中的较小值
        int min = (m < n) ? m : n;

        for (int i = min; i >= 1; i--) {//for(int i = 1;i <= min;i++){

            if (m % i == 0 && n % i == 0) {
                System.out.println("最大公约数是：" + i); //公约数

                break; //跳出当前循环结构
            }
        }


        //需求2：最小公倍数
        //取出两个数中的较大值
        int max = (m > n) ? m : n;

        for (int i = max; i <= m * n; i++) {

            if (i % m == 0 && i % n == 0) {

                System.out.println("最小公倍数是：" + i);//公倍数

                break;
            }
        }

    }
}

注意：

（i）我们可以在循环中使用break。一旦执行break，就跳出当前循环结构。

（ii）小结：如何结束一个循环结构？

        结束情况1：循环结构中的循环条件部分返回false

       结束情况2：循环结构中执行了break。

（iii）如果一个循环结构不能结束，那就是一个死循环！我们开发中要避免出现死循环。

（3）练习题

练习1：编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”。

for(int i = 1;i <= 150;i++){
            if(i % 3 == 0){
                System.out.println(i+"foo");
            } else if (i % 5 == 0) {
                System.out.println(i+"biz");
            } else if (i % 7 == 0) {
                System.out.println(i+"baz");
            }else {
                System.out.println(i);
            }
        }

3.2 while循环

（1）基本语法

格式

①初始化部分
while(②循环条件部分)｛
    ③循环体部分;
    ④迭代部分;
}

执行过程：①-②-③-④-②-③-④-②-③-④-...-②

 

注意：

• while(循环条件)中循环条件必须是boolean类型。

• 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。

• for循环和while循环可以相互转换。二者没有性能上的差别。实际开发中，根据具体结构的情况，选择哪个格式更合适、美观。

• for循环与while循环的区别：初始化条件部分的作用域不同。

（2）例题分析

例题1：随机生成一个100以内的数，猜这个随机数是多少？

从键盘输入数，如果大了，提示大了；如果小了，提示小了；如果对了，就不再猜了，并统计一共猜了多少次。提示：生成一个[a,b] 范围的随机数的方式：(int)(Math.random() * (b - a + 1) + a)

public class GuessNumber {
    public static void main(String[] args) {
        //获取一个随机数
        int random = (int) (Math.random() * 100) + 1;

        //记录猜的次数
        int count = 1;

        //实例化Scanner
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个整数(1-100):");
        int guess = scan.nextInt();

        while (guess != random) {

            if (guess > random) {
                System.out.println("猜大了");
            } else if (guess < random) {
                System.out.println("猜小了");
            }

            System.out.println("请输入一个整数(1-100):");
            guess = scan.nextInt();
			//累加猜的次数
            count++;

        }

        System.out.println("猜中了！");
        System.out.println("一共猜了" + count + "次");
    }
}

3.3 do-while循环

（1）基本语法

格式：

①初始化部分;
do{
    ③循环体部分
    ④迭代部分
}while(②循环条件部分);

执行过程：①-③-④-②-③-④-②-③-④-...-②

 

注意：

• 结尾while(循环条件)中循环条件必须是boolean类型

• do{}while();最后有一个分号

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

• 循环的三个结构for、while、do-while三者是可以相互转换的。

（2）例题

例题1：遍历1-100的偶数，并计算所有偶数的和、偶数的个数（累加的思想）

//遍历1-100的偶数，并计算所有偶数的和、偶数的个数（累加的思想）
		//初始化部分
		int num = 1;
		
		int sum = 0;//记录1-100所有的偶数的和
		int count = 0;//记录1-100之间偶数的个数

		do{
			//循环体部分
			if(num % 2 == 0){
				System.out.println(num);
				sum += num;
				count++;
			}
			
			num++;//迭代部分


		}while(num <= 100); //循环条件部分


		System.out.println("偶数的总和为：" + sum);
		System.out.println("偶数的个数为：" + count);

例题3：模拟ATM取款

声明变量balance并初始化为0，用以表示银行账户的余额，下面通过ATM机程序实现存款，取款等功能。

=========ATM========
   1、存款
   2、取款
   3、显示余额
   4、退出
请选择(1-4)：

import java.util.Scanner;
public class ATM {
	public static void main(String[] args) {

		//初始化条件
		double balance = 0.0;//表示银行账户的余额
		Scanner scan = new Scanner(System.in);
		boolean isFlag = true;//用于控制循环的结束

		do{
			System.out.println("=========ATM========");
			System.out.println("\t1、存款");
			System.out.println("\t2、取款");
			System.out.println("\t3、显示余额");
			System.out.println("\t4、退出");
			System.out.print("请选择(1-4)：");

			int selection = scan.nextInt();
			
			switch(selection){
				case 1:
					System.out.print("要存款的额度为：");
					double addMoney = scan.nextDouble();
					if(addMoney > 0){
						balance += addMoney;
					}
					break;
				case 2:
					System.out.print("要取款的额度为：");
					double minusMoney = scan.nextDouble();
					if(minusMoney > 0 && balance >= minusMoney){
						balance -= minusMoney;
					}else{
						System.out.println("您输入的数据非法或余额不足");
					}
					break;
				case 3:
					System.out.println("当前的余额为：" + balance);
					break;
				case 4:
					System.out.println("欢迎下次进入此系统。^_^");
					isFlag = false;
					break;
				default:
					System.out.println("请重新选择！");
					break;	
			}
		
		}while(isFlag);

		//资源关闭
		scan.close();
		
	}
}

 3.4对比三种循环

• 三种循环结构都具有四个要素：

  • 循环变量的初始化条件

  • 循环条件

  • 循环体语句块

  • 循环变量的修改的迭代表达式

• 从循环次数角度分析

  • do-while循环至少执行一次循环体语句。

  • for和while循环先判断循环条件语句是否成立，然后决定是否执行循环体。

• 如何选择

  • 遍历有明显的循环次数（范围）的需求，选择for循环

  • 遍历没有明显的循环次数（范围）的需求，选择while循环

  • 如果循环体语句块至少执行一次，可以考虑使用do-while循环

  • 本质上：三种循环之间完全可以互相转换，都能实现循环的功能

3.5无限循环

格式：最简单"无限"循环格式：while(true) , for(;;)

场景：

• 开发中，有时并不确定需要循环多少次，需要根据循环体内部某些条件，来控制循环的结束（使用break）。

• 如果此循环结构不能终止，则构成了死循环！开发中要避免出现死循环。

例题：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。

import java.util.Scanner;

class PositiveNegative {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
        
		int positiveNumber = 0;//统计正数的个数
		int negativeNumber = 0;//统计负数的个数
		for(;;){  //while(true){
			System.out.println("请输入一个整数：(输入为0时结束程序)");
			int num = scanner.nextInt();
			if(num > 0){
				 positiveNumber++;
            }else if(num < 0){
				 negativeNumber++;
        	}else{
                System.out.println("程序结束");
				break; 
            }
         }
		 System.out.println("正数的个数为："+ positiveNumber);
		 System.out.println("负数的个数为："+ negativeNumber);  
        
         scanner.close();
	} 
}

3.6嵌套循环

• 所谓嵌套循环，是指一个循环结构A的循环体是另一个循环结构B。比如，for循环里面还有一个for循环，就是嵌套循环。其中，for ,while ,do-while均可以作为外层循环或内层循环。

  • 外层循环：循环结构A

  • 内层循环：循环结构B

• 实质上，嵌套循环就是把内层循环当成外层循环的循环体。只有当内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的外层循环。

• 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

• 技巧：从二维图形的角度看，外层循环控制行数，内层循环控制列数。

• 注意：实际开发中，我们最多见到的嵌套循环是两层。一般不会出现超过三层的嵌套循环。如果将要出现，一定要停下来重新梳理业务逻辑，重新思考算法的实现，控制在三层以内。否则，可读性会很差。

例如两个for循环的嵌套使用格式

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

//执行过程：① - ② - ③ - ④ - ⑤ - ⑥ - ④ - ⑤ - ⑥ - ... - ④ - ⑦ - ② - ③ - ④ - ⑤ - ⑥ - ④..

执行特点：外层循环执行一次，内层循环执行一轮。

典型例题：

例题1：打印"菱形"形状的图案

        *
      * * *
    * * * * *
  * * * * * * *
* * * * * * * * *
  * * * * * * *
    * * * * *
      * * *
        *    

for (int i = 1; i <= 5; i++) {
            //-
            for (int j = 1; j <= 10 - 2 * i; j++) {
                System.out.print(" ");
            }
            //*
            for (int k = 1; k <= 2 * i - 1; k++) {
                System.out.print("* ");
            }
            System.out.println();
        }
        //下半部分
        for (int i = 1; i <= 4; i++) {
            //-
            for (int j = 1; j <= 2 * i; j++) {
                System.out.print(" ");
            }

            //*
            for (int k = 1; k <= 9 - 2 * i; k++) {
                System.out.print("* ");
            }
            System.out.println();
        }

例题2：九九乘法表

for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i + "*" + j + "=" + (i * j) + "\t");
            }
            System.out.println();
        }

4、break和continue关键字的使用

例题分析

例题1：

class BreakContinueTest1 {
	public static void main(String[] args) {
	
		for(int i = 1;i <= 10;i++){
			
			if(i % 4 == 0){
				//break;//123
				continue;//123567910
				//如下的语句不可能被执行，编译不通过
				//System.out.println("今晚迪丽热巴要约我吃饭");
			}

			System.out.print(i);
		}

		System.out.println("####");

		//嵌套循环中的使用
		for(int i = 1;i <= 4;i++){
		
			for(int j = 1;j <= 10;j++){
				if(j % 4 == 0){
					//break; //结束的是包裹break关键字的最近的一层循环！
					continue;//结束的是包裹break关键字的最近的一层循环的当次！
				}
				System.out.print(j);
			}
			System.out.println();
		}

	}
}

带标签的使用

break语句用于终止某个语句块的执行
{    ……	 
	break;
	 ……
}

break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块 
	label1: {   ……        
	label2:	     {   ……
	label3:			 {   ……
				           break label2;
				           ……
					 }
			     }
			} 

注：（i）continue语句出现在多层嵌套的循环语句体中时，也可以通过标签指明要跳过的是哪一层循环。

（ii）标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。

class BreakContinueTest2 {
	public static void main(String[] args) {
		l:for(int i = 1;i <= 4;i++){
		
			for(int j = 1;j <= 10;j++){
				if(j % 4 == 0){
					//break l;
					continue l;
				}
				System.out.print(j);
			}
			System.out.println();
		}
	}
}

例题分析找出100以内所有的素数（质数）？100000以内的呢？

方法1：

class PrimeNumberTest {
	public static void main(String[] args) {
		
		
		//boolean isFlag = true; //用于标识i是否被除尽过

		long start = System.currentTimeMillis(); //记录当前时间距离1970-1-1 00:00:00的毫秒数
			
		int count = 0;//记录质数的个数


		for(int i = 2;i <= 100000;i++){  //i

			boolean isFlag = true; //用于标识i是否被除尽过
		
			for(int j = 2;j <= i - 1;j++){
				
				if(i % j == 0){ //表明i有约数
					isFlag = false;
				}
			
			}

			//判断i是否是质数
			if(isFlag){ //如果isFlag变量没有给修改过值，就意味着i没有被j除尽过。则i是一个质数
				//System.out.println(i);
				count++;
			}

			//重置isFlag
			//isFlag = true;
		
		}

		long end = System.currentTimeMillis();
		System.out.println("质数的个数为：" + count);
		System.out.println("执行此程序花费的毫秒数为：" + (end - start)); //16628

	}
}

方法2优化

class PrimeNumberTest1 {
	public static void main(String[] args) {
		
		long start = System.currentTimeMillis(); //记录当前时间距离1970-1-1 00:00:00的毫秒数

		int count = 0;//记录质数的个数

		for(int i = 2;i <= 100000;i++){  //i

			boolean isFlag = true; //用于标识i是否被除尽过
		
			for(int j = 2;j <= Math.sqrt(i);j++){ //优化2：将循环条件中的i改为Math.sqrt(i)
				
				if(i % j == 0){ //表明i有约数
					isFlag = false;
					break;//优化1：主要针对非质数起作用
				}
			
			}

			//判断i是否是质数
			if(isFlag){ //如果isFlag变量没有给修改过值，就意味着i没有被j除尽过。则i是一个质数
				//System.out.println(i);
				count++;
			}
		
		}

		long end = System.currentTimeMillis();
		System.out.println("质数的个数为：" + count);
		System.out.println("执行此程序花费的毫秒数为：" + (end - start));//1062

	}
}

方法3：使用continue+标签

class PrimeNumberTest2 {
	public static void main(String[] args) {
		
		long start = System.currentTimeMillis(); //记录当前时间距离1970-1-1 00:00:00的毫秒数

		int count = 0;//记录质数的个数

		label:for(int i = 2;i <= 100000;i++){  //i
		
			for(int j = 2;j <= Math.sqrt(i);j++){ //优化2：将循环条件中的i改为Math.sqrt(i)
				
				if(i % j == 0){ //表明i有约数
					continue label;
				}
			
			}
			//一旦程序能执行到此位置，说明i就是一个质数
			System.out.println(i);
			count++;
		}
		

		long end = System.currentTimeMillis();
		System.out.println("质数的个数为：" + count);
		System.out.println("执行此程序花费的毫秒数为：" + (end - start));//1062

	}
}