JAVA选择语句

1.顺序结构

**顺序结构：**是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行

执行流程图：

在IDEA中演示：

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

2.选择结构

选择语句有两种结构：

1. if语句
2. switch语句

2.1 if语句

• 根据判定的结果（真或假）决定执行某个分支

if语句格式（1）

格式：

if(结果为boolean类型的表达式){
	语句体;
}

示例：

public class IfDemo01{
	public static void main(String[] args)
        boolean eat=true;
    	
    	if(eat){
            System.out.println("吃了");
        }
}

执行流程：

例题：

public class IfDemo01{
    public static void main(String[] args) {
        //定义一个整形变量
        int sorce = 65;
		
        //关系运算和逻辑运算结果都是boolean类型
        //对整型变量进行判断
        //sorce>60是对的话为boolean类型true，输出结果为及格了
        //否则为boolean类型false，输出为空
        if (sorce > 60) {
            System.out.println("及格了");
        }
    }
}

if语句格式（2）

格式：

if(结果为boolean类型的表达式){
	语句体1;
}else{
	语句2;
}

示例：

public class IfDemo01{
	public static void main(String[] args)
        boolean eat=false;
    	
    	if(eat){
            System.out.println("吃了");
        }else{
            System.out.println("还没吃");
        }
}

执行流程：

例题：

public class IfDemo01{
    public static void main(String[] args) {
        //定义一个整形变量
        int sorce = 55;
		
        //关系运算和逻辑运算结果都是boolean类型
        //对整型变量进行判断
        //sorce>60是对的话为true，输出结果为及格了
        //否则输出fales,输出结果为不及格
        if (sorce > 60) {
            System.out.println("及格了");
        }else{
            System.out.println("不及格");//结果
        }
    }
}

if语句格式（3）

格式：

if(结果为boolean类型的表达式1){
	语句体1;
}else if(结果为boolean类型的表达式2){
    语句体2;
}
...
else{
    语句体n+1;
}

执行流程：

例题：

需求描述: 自己随意给定一个分数，然后输出它是及格还是其他情况。(通过范围进行判断：0-60是不及格、60-80是及格、80-90是良好、90-100是优秀，其他则输出不符合)。

public class IfDemo01{
    public static void main(String[] args) {
        //定义一个整形变量
        int sorce = 55;
        //关系运算和逻辑运算结果都是boolean类型
        //对整型变量进行判断
        if (sorce >=0 && sorce < 60) {
            System.out.println("不及格");
        }else if(sorce>=60 && sorce<80){
            System.out.println("及格");
        }else if(sorce>=80 && sorce<90){
            System.out.println("良好");
        }else if(sorce>=90 && sorce<=100){
            System.out.println("优秀");
        }else{
            System.out.println("不符合");
        }
    }
}

2.2 switch语句

格式：

格式说名：

• 表达式：可以是byte类型，short类型，int类型，char类型
  JDK5之后可以是枚举类型，JDK7之后可以是String类型
• case：后面跟的是要和表达式进行比较的值
• break：表示中断，结束的意思。用来结束switch语句
• default：所有值都不匹配的时候，执行该处内容。和if语句的else相似

执行流程：

例题：

public class IfDemo01{
    public static void main(String[] args) {
        //定义一个整形变量
        int week=1;
//        week=2;
//        week=3;
//        week=4;
//        week=5;
//        week=6;
//        week=7;

        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语句中，如果case控制的语句体后面不写break，将出现穿透现象，在不判断下一个case值的情况下，向下运行，直到遇到break，或者整个switch语句结束

3.循环语句 3.1 for循环结构 （1）格式：

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

示例：

for (int i=1;i<5;i++){
	System.out.println("HelloWorld");
}

（2）格式说明：

• 初始化语句：这里可以是一条或多条语句，这些语句用来完成初始化操作（int i=1）
• 条件判断语句：这里使用一个结果为boolean类型的表达式，这个表达式能决定是否执行循环体语句（i<5）
• 循环体语句：t这里可以是任意语句，这些语句可能被多次执行( System.out.println(i);）
• 条件控制语句：这里通常是使用一条语句来改变变量的值，从而达到控制语句是否继续执行的效果（i++）

（3）执行流程

（4）例题： 1.在控制台输出1-5的数据

public class ForDemo {
    public static void main(String[] args) {
        //自增运算符：++
        //它跟在变量的后面表示变量的值+1
        for (int i=1;i<=5;i++){
            System.out.println(i);
        }
    }
}

2.求和

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

public class ForDemo1 {
    public static void main(String[] args) {
        //定义一个求和变量，用于保存求和的结果
        int sum = 0;
        //我们通过for循环实现获取数据1-5
        for (int i=1; i<=5; i++) {
//            i,1,2,3,4,5
//            sum = sum + i;
            sum += i;
            
        }
        //输出结果
        System.out.println("1-5的求和结果是：" + sum);
    }
}

3.求偶书和

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

分析：

① 对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同

② 对1-100的偶数求和，需要对求和操作添加限制条件

③ 限制条件是偶数才参与运算，因此条件应该是判断是否是偶数

④ 当循环执行完毕时，将最终数据打印出来

public class ForDemo2 {
    public static void main(String[] args) {
        //1:定义一个变量用来保存求和的最终结果，初始值为0
        int sum = 0;

        //2:对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同
        for (int i=1; i<=100; i++) {
            //3:对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数
            if(i % 2 == 0) {
                sum += i;
            }
        }

        //4:当循环执行完毕时，将最终数据打印出来
        System.out.println("1-100之间的偶数和是：" + sum);
    }
}

4.水仙花数+统计个数

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

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

什么样的数据是“水仙花数”？它满足如下两个条件：

① 水仙花数是一个三位数

比如：111 222 333 370 371 520 999

② 水仙花数的个位、十位、百位的数字立方和等于原数

实现步骤：

1. 定义一个count变量来保存水仙花数个数

2. 获取三位数，通过循环实现

3. 获取每一个三位数的个位，十位，百位

4. 判断该三位数是否是水仙花数

5. 输出水仙花数,并使count值+1

6. 输出水仙花数总个数

public class ForDemo3 {
    public static void main(String[] args) {
        //定义一个count变量来保存水仙花数个数
        int count=0;
        //通过循环获取三位数
        for (int i=100;i<1000;i++){
            //获取个、十、百、位上的值
            int ge=i%10;
            int shi=i/10%10;
            int bai=i/100%10;
            //对个位、十位、百位的数字立方求和
            int c= ge*ge*ge+shi*shi*shi+bai*bai*bai;
            //用if语句进行判断，看三位数是否是水仙花数
            if (c==i){
                //统计水仙花个数，每符合一个count值+1
                count += 1;
                //输出符合的水仙花数
                System.out.println(i);
            }

        }
        //输出水仙花数总个数
        System.out.println("水仙花数的个数是"+count+"个");
    }
}

5.回文数

需求：输出所有五位数的回文数

什么样的数据是“回文数”？一个数，无论是从左往右读,还是从右往左读，读起来都相同的数,叫做“回文数”

规律：

• 个位 = 万位

• 十位 = 千位

• 和百位无关

实现步骤：

① 获取五位数，通过循环实现

② 获取每一个五位数的个位，十位，千位，万位

③ 判断该五位数是否是回文数

④ 输出回文数

public class ForDemo4 {
    public static void main(String[] args) {
        //通过for循环获取五位数
        for (int i=10000;i<100000;i++){
            //获取五位数的个位，十位，千位，万位
            int ge = i%10;
            int shi = i/10%10;
            int qian=i/1000%10;
            int wan = i/10000%10;

            //判断该五位数是否是回文数
            if ((ge==wan) && (shi==qian)){
                //输出回文数
                System.out.println(i);
            }
        }
    }
}

6.逢七过

需求：从任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时都要说：过。

分析：

① 数据的范围1-100之间，用循环很容易实现

② 要满足的条件是：数字包含7(个位是7，或者十位是7)，或者是7的倍数

假如有一个数据：x

判断个位为7：x%10 == 7

判断十位为7：x/10%10 == 7

判断是7的倍数：x%7 == 0

分析完毕后，我们来说一下实现步骤：

实现步骤：

① 获取1-100之间的数据，通过循环实现

② 判断数字包含7或者是7的倍数

判断数据：要么个位是7，要么十位是7，要么能够被7整除

③ 在控制台输出满足条件的数据

public class ForDemo5 {
    public static void main(String[] args) {
        //用for循环获取1-100之间的数
        for (int i=1;i<100;i++){
            
//            //获取个位，十位
//            int ge=i%10;
//            int shi=i/10%10;
//            //判断是否位回文数
//            
//            if ((ge==7) || (shi==7) || (i%7==0)){
//                //输出满足条件的值
//                System.out.println(i);
//            }
            
            //判断是否位回文数
            if ((i%10==7) || (i/10%10==7) || (i%7==0)){
                //输出满足条件的值
                System.out.println(i);
            }
        }
    }
}

（5）循环嵌套例题： 1.根据下列图片，利用for循环设计出来

public class ForQian {
    public static void main(String[] args) {
        for (int i=1;i<=3;i++){
            System.out.println("---这是第"+i+"轮开始---");
            for (int j=1;j<=5;j++){
                System.out.println("t这是第"+j+"圈");//  t 是缩进对其
            }
            System.out.println("---这是第"+i+"轮结束---");
        }
    }
}

2.打印4行10列的矩形

public class ForQian02 {
    public static void main(String[] args) {
        //控制循环行数
        for (int i=1;i<=4;i++){
            //控制循环列数
            for (int j=1;j<=10;j++){
                System.out.print("#");//print是不带换行效果的
            }
            System.out.println();  //println是带换行效果的
        }
    }
}

3.打印直角三角形，如下图所示

public class ForQIan03 {
    public static void main(String[] args) {
        for (int i=1;i<10;i++){
            for (int j=1;j<=i;j++){
                System.out.print("#");
            }
            System.out.println(); //换行操作
        }
    }
}

4.打印九九乘法表

public class ForQIan03 {
    public static void main(String[] args) {
        for (int i=1;i<10;i++){
            for (int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+j*i+"t");
            }
            System.out.println(); //换行操作
        }
    }
}

5.打印正三角形

public class ForQian04 {
    public static void main(String[] args) {
        for (int i = 1; i <=7 ; i++) {
            //该循环控制行数
            for (int j = 1; j <= 7-i; j++) {
                //该循环控制输出空格
                System.out.print(" ");
            }
            for (int k = 1; k <= i*2-1; k++) {
                //该循环控制输出*号
                System.out.print("*"); 
            }System.out.println(); //换行
        }
    }
}

3.2 while循环结构 （1）格式

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

示例：

int i = 1;
while(i<=5){
    System.out.print("Hello");
    i++;
}

（2）执行流程

（3）例题

public class WhileDemo {
    public static void main(String[] args) {
        //定义求和变量，初始值为0
        int sum = 0;
        //获取1-100之间的数值
        int i = 1;
        while(i<=100){
            //判断数值是否为奇数
            if (i%2!=0){
                sum += i;
            }
            i++;
        }
        System.out.println(sum);
    }
}

3.3 do-while循环结构 （1）格式

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

示例：

int i = 1;
do{
    System.out.print("Hello");
    i++;
}while(i<=5);

（2）执行流程

（3）例题

public class DoWhileDemo {
    public static void main(String[] args) {
        //定义求和变量，初始值为0
        int sum = 0;
        int i = 1;
        do{
            //判断数值是否为奇数
            if (i%2!=0){
                sum += i;
            }
            i++;
        }while(i<=100);//获取1-100之间的数值
        System.out.println(sum);
    }
}

三种循环的区别

public class Demo {
    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);
    }
}

public class Demo2 {
    public static void main(String[] args) {
        //for循环
        for (int i = 1; i < 3; i++) {
            System.out.println("我爱Java");
        }
        //不可在循环体外输出i
//        System.out.println(i);
        System.out.println("--------");

        //while循环
        int j = 1;
        while (j < 3) {
            System.out.println("我爱Java");
            j++;
        }
        //可以在循环体外输出a
        System.out.println(j);
        System.out.println("--------");


        //do-while循环
        int k = 1;
        do {
            System.out.println("我爱Java");
            k++;
        }while (k < 3);
        //可以在循环体外输出a
        System.out.println(k);
        System.out.println("--------");

    }
}

总结：

三种循环的区别：

for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）

do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）（所以至少有一次输出）

for和while的区别：

条件控制语句所控制的自增变量，在for循环结束后，就不可以继续使用了

条件控制语句所控制的自增变量，在while循环结束后，还可以继续使用

死循环格式：

• for(;;）{}
• while(true) {}
• do{}while(true);

continue和break的区别

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

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

continue结果：

break结果：