03流程控制语句

1.顺序结构

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

2.分支结构(if, switch)

if语句

if语句格式1

格式：
if (关系表达式) {
    语句体;	
}

if语句格式2

格式：
if (关系表达式) {
    语句体1;	
} else {
    语句体2;	
}

if语句格式3

格式：
if (关系表达式1) {
    语句体1;	
} else if (关系表达式2) {
    语句体2;	
} 
…
else {
    语句体n+1;
}

if语句实例

大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出
一定的条件：高：180cm以上；富：财富1千万以上；帅：是。（注意:不用管单位）
     如果这三个条件同时满足，则：“我一定要嫁给他!!!”
     如果三个条件有为真的情况，则：“嫁吧，将就过日子。”
     如果三个条件都不满足，则：“不嫁！”

package day3;
import java.util.Scanner;
public class day3_6 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入男方的身高（厘米为单位），财富(万为单位)，是否长得帅(1为是，0为不是)");
        System.out.println("-------------------注意:不用管单位--------------------------");
        int height = sc.nextInt();
        int rich = sc.nextInt();
        int sunb = sc.nextInt();
        if(height>180&rich>1000&sunb==1)
        {
            System.out.println("我一定要嫁给他!!!");
        }
        else if (height>180|rich>1000|sunb==1)
        {
            System.out.println("嫁吧，将就过日子。");
        }
        else {
            System.out.println("不嫁！");
        }
    }
}

运行结果：

switch语句

分支语句switch语句

switch (表达式) {
	case 1:
		语句体1;
		break;
	case 2:
		语句体2;
		break;
	...
	default:
		语句体n+1;
		break;
}

执行流程：

• 首先计算出表达式的值
• 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。
• 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

switch语句case穿透

• 概述 : 如果switch语句中,case省略了break语句, 就会开始case穿透
• 需求 : 键盘录入星期数，输出工作日、休息日 (1-5)工作日，(6-7)休息日
• 示例代码：

/*
case穿透是如何产生的?
		
		如果switch语句中,case省略了break语句, 就会开始case穿透.
		
		现象：
			当开始case穿透，后续的case就不会具有匹配效果，内部的语句都会执行
			直到看见break，或者将整体switch语句执行完毕，才会结束。
*/
public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入星期数:");
		int week = sc.nextInt();
		
		switch(week){
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
				System.out.println("工作日");
				break;
			case 6:
			case 7:
				System.out.println("休息日");
				break;
			default:
				System.out.println("您的输入有误");
				break;
		}
	}	
}

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

循环语句-for循环

for (初始化语句;条件判断语句;条件控制语句) {
	循环体语句;
}

eg：

3000米长的绳子，每天减一半。问多少天这个绳子会小于5米？不考虑小数。

package day3;

public class day3For5_6 {
    public static void main(String[] args) {
        int day,l ;
        for (l=3000,day=0;l>=5;day++)
        {
          l/=2;
        }
        System.out.println(day);
    }
}

运行结果

循环语句-while循环

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

eg：
用while循环语句实现，打印出0-100,不包括7或者3的倍数

package day3;

public class day3While6_3 {
    public static void main(String[] args) {
        int i=0;
        System.out.println(i);
       while (i < 100){
            i++;
           if ((i%7==0)|(i%3==0))
           {
               continue;
           }
           System.out.println(i);

       }
    }
}

循环语句-dowhile循环

初始化语句;
do {
	循环体语句;
	条件控制语句;
}while(条件判断语句);  //先执行后判断

三种循环的区别

• 三种循环的区别
  1. for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
  2. do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
• for循环和while的区别
  • 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
  • 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
• 死循环（无限循环）的三种格式
  1. for( ; ; ){}
  2. while(true){}
  3. do {} while(true);

跳转控制语句

• 跳转控制语句（break）
  • 跳出循环，结束循环
• 跳转控制语句（continue）
  • 跳过本次循环，继续下次循环
• 注意： continue只能在循环中进行使用！

4.Random

Random产生随机数

概述：

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

• • 使用步骤：

  1. 导入包

     import java.util.Random;

  2. 创建对象

     Random r = new Random();

  3. 产生随机数

     int num = r.nextInt(10);

     解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随机数则是0-19

示例代码：

import java.util.Random;

public class Demo1Random {
	/*
		Random : 产生随机数
		
		1. 导包	: import java.util.Random;
				    导包的动作必须出现在类定义的上面

		2. 创建对象 : Random r = new Random();
					上面这个格式里面，r 是变量名，可以变，其他的都不允许变

		3. 获取随机数 : int number = r.nextInt(10);	
		//获取数据的范围：[0,10) 包括0,不包括10
		
		需求: 产生随机数1-10之间的
	*/
	public static void main(String[] args){
		// 2. 创建对象
		Random r = new Random();
		
		for(int i = 1; i <= 10; i++){
			// 3. 获取随机数
			int num = r.nextInt(10) + 1;		// 1-10
			System.out.println(num);
		}
		
		
		
	}
}