Day4~5 流程控制语句，顺序，选择，循环。

最新推荐文章于 2024-05-16 20:02:23 发布
最新推荐文章于 2024-05-16 20:02:23 发布
阅读量427 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： Java SE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_21953671/article/details/78992245
本文详细介绍了程序设计中的流程控制语句，包括条件分支结构（if、switch）、循环结构（while、do-while、for）及相关的特殊流程控制语句（break、continue）。通过丰富的示例代码展示了不同控制语句的应用场景。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

导言：
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：顺序结构、分支结构和循环结构，如下图所示：
这里写图片描述

顺序结构：

从上到下，从左到右

分支结构：

单分支：

    if(布尔表达式){
        代码块...
    }

双分支：

    if(布尔表达式){
        代码块1...
    }else{
        代码块2...
    }
    如果布尔表达式的值为true，执行代码块1，如果为false，执行代码块2

多分支：

    if(布尔表达式1){
        代码块1...
    }else if(布尔表达式2){
        代码块2...
    }else if(布尔表达式3){
        代码块3...
    }else{
    }
    多选一
    如果表达1的结果为true，只执行代码块1，执行完之后，分支语句结束
    如果表达1为false，则考虑表达式2，如果2成立，则执行2，后续的不考虑

switch 语句：

switch(表达式或者值){
    case 1：break;
    case 2: break;
    case 3: break;

    default: break;

}

1.switch语句会根据表达式的值从相匹配的执行，一直执行到break标签处开始ak语句处或者是switch语句的末尾。与任一case值不匹配，则进入default语句(如果有的话)

2.只能处理等值条件判断的情况，且表达式必须为byte，short，int或char类型 ，String和枚举类型，不能是double,float，boolean
1.5开始，可以为Enum,枚举
1.7开始，可以为String
3.常量值必须是与表达式类型兼容的特定的一个常量

4.不允许有重复的case值

5.default子句为可选

if多分支和switch case语句的选择：
多分支跟switch多分支表示范围比较合适
switch表示具体的值比较合适

例题：

1.掷骰子
1~3 小
4~6 大
1、随机生成一个数值(1~6)
Random
2、提示猜大小 1.大 2.小
3、判断结果是否中出

import java.util.Random;
import java.util.Scanner;
public class Test5{
    public static void main(String[]args){
        //1.创建一个随机数生成器
        Random rd = new Random();
        //2.使用生成器生成一个1~6之间的随机数
        int num = rd.nextInt(6)+1;//rd.nextInt(6):生成数的范围0~5
        //3.猜测
        System.out.println("请猜测:1.大 2.小");
        Scanner sc = new Scanner(System.in);
        int choice = sc.nextInt();
        //5.打印结果
        /* if(num > 3){
            System.out.println("开出结果为大");
        }
        if(num < 4){
            System.out.println("开出结果为小");
        } */
        if(num > 3){
            if(choice == 1){
                System.out.println("恭喜中出");
            }else{
                System.out.println("很遗憾~");
            }
            System.out.println("开出结果为大:"+num);
        }else{
            if(choice == 2){
                System.out.println("恭喜中出");
            }else{
                System.out.println("很遗憾~");
            }
            System.out.println("开出结果为小:"+num);
        } 
    }
}

2.三个骰子，大、中、小
大：13-18
中：7-12
小：1-6
总点数的变量 count,count1,count2,count3
随机生成count1,count2,count3(1-6)
使用多分进行判断,打印结果

 import java.lang.Math;
public class Test6{
    public static void main(String[]args){
        int count = 0;
        int count1,count2,count3;
        //使用数学类中的方法，生成随机值
        count1 =(int)(Math.random() * 6) + 1;//Math.random()值  0~0.99999...，
        count2 =(int)(Math.random() * 6 + 1);
        count3 =(int)(Math.random() * 6 + 1);
        count = count1 + count2 + count3;
        if(count >= 13 && count <= 18){
            System.out.println("结果为大:三个骰子点数分别为:"+count1+","+count2+","+count3);
        }else if(count >= 7 && count <= 12){
            System.out.println("结果为中:三个骰子点数分别为:"+count1+","+count2+","+count3);
        }else{
            System.out.println("结果为小:三个骰子点数分别为:"+count1+","+count2+","+count3);
        }
    }
}

3.输入一个数字，给出对应季节的提示
春 3,4,5
夏 6,7,8
秋 9,10,11
冬 12,1,2
例如：输入数字3，打印 春意盎然，春暖花开
输入：12 打印 冬雪皑皑

1.扫描器
2.输入，记录输入的值
3.根据输入的值进行多分支判断
4.打印对应结果

import java.util.Scanner;
public class Test7{
    public static void main(String[]args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入任意一个月份");
        int month = sc.nextInt();
        if(month >= 3 && month <= 5){
            System.out.println("春暖花开");
        }else if(month >= 6 && month <= 8){
            System.out.println("夏日炎炎");
        }else if(month >= 9 && month <= 11){
            System.out.println("秋高气爽");
        }else if(month == 1 || month == 2 || month == 12){
            System.out.println("冬雪皑皑");
        }else{
            System.out.println("输入月份有误");
        }
        char ch = 'A';
        switch(ch){
            case 'A':
            case 'B':
        }

    }
}

用Switch case 语句重写：

import java.util.Scanner;
public class Test8{
    public static void main(String[]args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入任意一个月份");
        int month = sc.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;
            default:
                System.out.println("月份有误");
                break;
        }

    }
}

4.键盘输入月份，年份 显示对应的天数 switch 去做

判断年份 是闰年还是平年
①能被4整除不能被100整除
②能被400整除

import java.util.Scanner;
class YearTest1{
    public static void main(String [] args){
        //创建Scanner对象
        Scanner input = new Scanner(System.in);
        //准备数据
        System.out.println("请输入一个年份");
        int year = input.nextInt();
        System.out.println("请输入一个月份");
        int month = input.nextInt();

        //定义变量记录每个月的天数
        int days = 0;
        switch(month){
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
        case 12:
            //System.out.println(month +"月  有31天");
            days = 31;
            break;
        case 4:
        case 6:
        case 9:
        case 11:
            //System.out.println(month+"月，有  30  天");
            days = 30;
            break;
        case 2:
            if(year % 4 == 0 && year % 100 !=0 || year % 400 == 0){
                //System.out.println(month+"月，有  29  天");
                days = 29;
            }else{
                //System.out.println(month+"月，有  28  天");
                days = 28;
            }
            break;
        }
        System.out.println(year+"年，"+month+" 月，有 "+days+"天");
    }

}

循环结构：

循环结构都由如下四个结构组成：
初始化条件、 只执行一次
循环条件、 循环最后执行的条件
循环体、
迭代条件

while循环
do-while循环
for循环
While循环
初始化条件；
while(条件判断){
循环体；
迭代条件；
}

在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。
语句中应有使循环趋向于结束的语句，否则会出现无限循环–––”死”循环。

while(true){
循环体；
迭代条件；
}  死循环
例题：

1.输出10次HelloWorld

class LoopTest1{

    public static void main(String [] args){
    int i = 1;
        //循环条件i <= 10
        while(i <= 5){
            //循环体
            System.out.println("Hello World\t"+i);
            //迭代条件
            //i++;
            ++i;
        }
        System.out.println("Over");
    }
    }

2.求1~100内偶数的和
①输出1~100内的100个数
②拿到100内的偶数
偶数：能被2整除的数
③ 求和
定义变量记录总和

class LoopTest2{

    public static void main(String [] args){
        //初始化条件
        int i = 1;
        //定义变量记录总和
        int sum = 0;
        //循环条件
        while( i <= 100){
            //循环体  能被2整除的数
            if(i % 2 == 0){
                System.out.println(i);
                //sum = sum + i;
                sum += i;
            }
            //迭代条件
            i++;
        }
        System.out.println("总和是  "+sum);
        System.out.println("Over");

    }

}

3.求100内能被5整除的数 每行输出5个 的 整体的和 及其个数
①列出1~100内的数
②列出1~100内能被5整除的数
③定义变量记录满足条件的元素的数量
int count = 0;
④定义变量记录总和
int sum = 0;

class LoopTest3{

    public static void main(String [] args){
        int i = 1;
        //定义变量记录数量
        int count = 0;
        //定义变量记录总和
        int sum = 0;
        while(i<=100){
            // 循环条件  判断是否能被5整除
            if( i % 5 == 0){
                //每次给本身+1
                //count = count + 1;
                count++;
                System.out.print(i+"\t");
                //每行输出5个元素
                if(count % 5 == 0){
                    System.out.println();
                }
                //记录总和
                //sum = sum + i;
                sum += i;
            }
            //迭代条件
            i++;
        }
        System.out.println("1~100内偶数的和是\t"+sum+"，一共有  "+count+" 个");
    }
}

4.键盘录入正数 或者 负数的整数
当录入0时终止程序 输出刚才一共录入了多少个正数 和负数
1 2 3
-1 -3
0
正数的个数有 3
负数的个数有 2

import java.util.Scanner;
class LoopTest4{
    public static void main(String [] args){
        //创建Scanner对象
        Scanner input = new Scanner(System.in);

        //定义变量统计正数的个数
        int zhengShu = 0;
        //定义变量统计负数的个数
        int fuShu = 0;
        //定义初始化条件
        int num = 90;

        while(num !=0 ){//  ==
            System.out.println("请您输入一个数");
            num = input.nextInt();

            if(num >  0){
                zhengShu++;
            }

            if(num < 0){
                fuShu++;
            }

        }
        System.out.println("正数的个数是\t"+zhengShu+"\n负数的个数是\t"+fuShu);




    }
}
do while循环
初始化条件
do{
循环题；
迭代条件
}while(循环条件);
例题：

1.输出100内偶数的和
1.输出1~100内的数

class DoWhileTest{
    public static void main(String [] args){
        //初始化条件
        int i = 1;
        //定义变量接收数据的和
        int sum = 0;

        do{
            //循环体
            if(i%2==0){
                System.out.println(i);
                sum+=i;
            }
            //迭代条件
            i++;
            //循环条件
        }while(i<=100);
            System.out.println("偶数的和是\t"+sum);
        System.out.println("Over");

    }

}
区别

while:判断初始化条件是否满足循环条件 不满足不执行循环体
dowhile:即使初始化条件不满足循环条件也会执行一次循环体

For循环

for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构
语法形式 

 for (初始表达式;循环条件;迭代条件) {
循环体；
}

增强for循环（foreach循环）:

for(type x : collection){
}

注意事项：
1.for循环在执行条件测试后，先执行程序部分，再执行步进。
2.在for语句的初始化部分声明的变量，其作用域为整个for循环体
3.“初始化”和“循环条件表达式”部分可以使用逗号来执行多个操作
4.如果三个部分都为空语句（分号不能省），相当于一个无限循环
5.初始化条件可以放到循环的外面作用域（作用范围）变大
6.缺少循环条件会变为死循环
7.缺少迭代条件会变为死循环
8.缺失所有的条件变为死循环
9.dos窗口终止死循环 ctrl + c

例题

1.1~100内能被3整除的数 每行输出 6个 求个数 求总和

class ForTest1{
    public static void main(String [] args){

        for(int i = 1;i<=0;i++){
            System.out.println("HelloWorld");
        }
        System.out.println("Over");
        System.out.println("-------------------------------------");
        //记录数量
        int count = 0;
        //定义变量求和
        int sum = 0;
        for(int i = 1;i<=100;i++){
            //判断是否能被3整除
            if(i % 3 ==0){
                System.out.print(i+"\t");
                count++;
                /*if(count % 6 ==0){
                    System.out.println();
                }*/
                //求和
                sum += i;
            }
            if( i % (3*6) == 0 ){
                System.out.println();
            }

        }
        System.out.println("\n总和是\t"+sum+",个数是  "+count);

    }


}

2.输出200以内的整数，被3整除后面输出 foo,
被5整除输出 biz,被7整除输出baz，同时被3,5整除输出foo biz ，同时被3,7整除输出foo baz，同时被3,5,7整除输出foo biz baz。

class ForTest4{
    public static void main(String [] args){



            System.out.println(i);
        for(int i = 1;i<=200;i++){
            //刷新str的值
            String str = "";
            if(i % 3 == 0){
                str = "\tfoo";
            }

            if(i % 5 == 0){
                str += "\tbiz";
            }
            if(i % 7 == 0){
                str += "\tbaz";
            }
            System.out.println(i+ str);

        }

    }
}
for循环与while,dowhile循环区别:

当循环次数不固定时 优先使用while循环

当循环次数固定时 使用for循环

无论如何都想执行一次循环体 do{}while();当初始化条件不满足循环条件也会执行一次循环体

特殊的流程控制语句

break:结束循环
只能用在循环和switch中
continue:结束本次（当前）循环继续下一次循环
只能用在循环中
return;结束方法

注意：
错误: 无法访问的语句
在特殊的流程控制语句下不可以存在其他的代码

例子：
class BreakTest{
    public static void main(String [] args){
        for(int i = 0;i<10;i++){
            if(i == 5){
                //continue;
                return;
                System.out.println("如果此句可以输出 给大家一百万");
            }
            System.out.println(i);
        }
        System.out.println("Game Over!!");
    }
}

多重循环

三种循环方式
while
do-while
for

多重循环（循环嵌套）
一个循环体内又包含另一个完整的循环结构
任何两种循环都可以相互嵌套
可以任意层次循环，但是一般不超过3层

多重循环执行过程
外层循环变量变化一次，内层循环变量要变化一遍

for(循环条件1){
     //循环操作1
     for(循环条件2){
          //循环操作2
     }
}
while(循环条件1){
      //循环操作1
      for(循环条件2){
            //循环操作2
     }
}
例题：

1.打印9*9乘法表,使用for嵌套


public class DoubleLoopTest{
    public static void main(String[] args){
        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();

        }
    }
}

2.打印
外层循环控制行数内层循环控制列数
行数和星星的关系
h s
* = 1 1
** = 2 2
*** = 3 3
**** = 4 4
***** =5 5

class DoubleLoopTest2{
    public static void main(String [] args){
        //外层控制行数
        for(int i = 1;i<=5;i++){

            for(int j = 1;j <= i;j++){

                System.out.print("*");
            }
            System.out.println();
        }
    }
}

3.打印
h k s
—-******* 1 4 7
—******* 2 3 7
–******* 3 2 7
-******* 4 1 7
******* 5 0 7
k = 5 - h;
行数，空格，和星星的关系如上

class DoubleLoopTest3{
    public static void main(String [] args){
        //确定外层循环
        for(int h = 1;h<=5;h++){
            //输出空格
            for(int k = 1;k <= 5-h;k++){
                System.out.print(" ");
            }
            //输出星星
            for(int s = 1;s<=7;s++){
                System.out.print("*");
            }
            //换行
            System.out.println();

        }

    }

}

4.打印

—-*
—* *
–* * *
-* * * *
* * * * *
-* * * *
– * * *
— * *
—- *

分析星星，空格，和行数的关系

—-* 1 1 4 k = 5 - h;
—* * 2 2 3 s = h;
–* * * 3 3 2
-* * * * 4 4 1
* * * * * 5 5 0

-* * * * 1 4 1
– * * * 2
— * *
—- *

class DoubleLoopTest4{
    public static void main(String [] args){
        //确定外层循环5次
        for(int h = 1;h<=5;h++){
            //输出空格
            for(int k = 1; k <= 5 - h;k++){
                System.out.print(" ");
            }
            //输出星星
            for(int s = 1;s <= h; s++){
                System.out.print("* ");
            }
            //换行
            System.out.println();
        }
        //菱形的下半部分
        for(int h = 1; h<=4;h++){
            //输出空格
            for(int k = 1;k<=h;k++){
                System.out.print(" ");
            }
            //输出星星
            for(int s = 1;s <= 5 - h;s++){
                System.out.print("* ");
            }
            //换行
            System.out.println();

        }

    }

}

5.将使用循环分别实现将101 进值正整数变成 二进制数
写法1：
将10进制的正整数转为二进制
分析：
1.不停的对被除数取模取商此处为重复操作 考虑使用 循环
2.不同的10进制数转为二进制数 循环的次数不固定 所以考虑使用while循环
3.第一次对10除以2 拿到商为5 余数是 0
第二次对5除以2 拿到商为2 余数是1
第三次对2除以2 拿到商为1 余数是0
第四次对1除以2 拿到商为0 余数是1

总结：上一次结果的商作为下一次运算的被除数

class HomeTest1{
    public static void main(String [] args){
        //定义一个数
        int num = 10;
        //定义字符串接收余数
        String str = "";
        while(num!=0){
            //求商
            int shang = num / 2;//2 
            //求余数
            int yuShu = num % 2;//1
            System.out.println(yuShu);//0 1
            str = yuShu+ str;//10
            System.out.println("--->"+str);
            //将商变为被除数
            num =  shang;//5

        }


    }
}

写法2：
用StringBuffer写：

public class  Scale{
    public static void main(String[] args){
        StringBuffer buffer=new StringBuffer();
        int a=101;
        int b=0;
        while(a>0){
            b=a%2;
            buffer.append(b);
            a/=2;

        }
        buffer.reverse();
    System.out.println(buffer);


    }
}
多重循环中使用特殊语句和lable标签的使用

break, continue,return
嵌套循环下特殊的流程控制语句执行过程

break:结束最近的循环

直接使用break结束外层循环：
方式1：在外层循环内定义boolean类型变量 通过变量传递的方式结束

方式2：定义循环lable(标签 符合命名规范和命名规则即可)
break结束的是 label 所在层的循环

标签：

label:外部循环{
内部循环{
//…
break;
//…
continue;
//…
continue label1;
//…
break label1;
}
}
“标签”是指后面跟一个冒号的标识符，例如：label:
对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：
我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，
它们就会中断到存在标签的地方。
在Java里唯一需要用到标签的地方就是拥有嵌套循环，而且想中断或继续多个嵌套级别的时候。

例题：

打印101-150之间所有的质数

public class PrimeNumber {    
    public static void main(String args[]) {
        int count = 0;
        outer: for (int i = 101; i < 150; i ++) {
            for (int j = 2; j < i / 2; j++) {
                if (i % j == 0)
                continue outer;
            }
                                System.out.print(i+ "  ");
        }
    }
}
例题：

class BreakDoubleLoop{
public static void main(String [] args){
/*
for(int i = 1;i<=5;i++){
boolean flag = false;
for(int j = 1;j <=15;j++){

            if(j==10){
                flag = true;
                break;
            }

            System.out.print(j+"\t");

        }
        if(flag){
            break;
        }
        System.out.println();
    }
*/  用lable 
    l:for(int i = 1;i<=5;i++){

            for(int j = 1;j <=15;j++){

                if(j==10){

                    break l;
                }

                System.out.print(j+"\t");

            }

            System.out.println();
        }
    System.out.println("Game Over!!!");
}

}

continue:结束当前循环继续下一次循环

输出5行1234678910

class ContinueDoubleLoop{
    public static void main(String [] args){

        for(int i = 1;i <= 5 ;i++){

            lable:for(int j = 1; j<= 10 ;j++){
                    if( j == 5){
                        //continue lable;
                        return;
                    }
                    System.out.print(j+"\t");
                }
                System.out.println();
            }

        System.out.println("Game Over");
    }
}

例题：
1.输出2~100内的质数
质数：1和本身的两个约数

class ZhiShuTest{
    public static void main(String [] args){

        for(int i = 2;i<=100;i++){
            boolean flag = true;
            for(int j = 2;j < i;j++){
                //不是质数
                if(i % j == 0){
                    flag = false;
                }
            }
            //判断当是质数时输出
            //if(flag==true){
            if(flag){
                System.out.println(i);
            }

        }
    }

}

二分法求2-100以内的质数：

class ZhiShuTest1{
    public static void main(String [] args){

        l:for(int i = 2;i<=100;i++){
            for(int j = 2;j <= i/2;j++){
                //不是质数
                if(i % j == 0){
                    continue l;
                }
            }
            System.out.println(i);
        }
    }

}

博弈小游戏 ：
这里写图片描述
这里写图片描述


博弈游戏：三个骰子，约定三个骰子的点数
最大点数：18
最小点数：3
要求：
1、大于9小于等于18是大，否则是小。
2、初始钱是5000；
3、每次只能下注50的倍数但最大不超过1000
4、最后一次下注必须要大于等于50
5、当下注金额小于余额时提示充值，如果不充值直接退出程序。


n:较大的数
m:较小的数
  Math.random()*(n-m+1)+m;
  (int)(Math.random()*(89-22+1)+m);
1.搭建框架
    主程序包含在循环内
2.创建选择菜单
    1.进入游戏
        1.用户押大小
        2.用户下注
            1.下注的金额是否大于本金
                1.不足
                    充值  重新下注 退出
                2.满足
                    能被50整除  小于1000
        3.电脑生成随机数
        4.判断电脑点数的大小
        5.用户大小与电脑大小进行对比产生结果
    2.退出游戏

*/


import java.util.*;
public class BoYiGame{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int choose=0;  //选择
        int  dian=0;   //庄家点
        int  daXiao=0; //庄家的大小
        int selfDaXiao=0; //自己猜的大小
        int money1=1000;  //初始的1000；
        int paymoney=0;   //押注的钱
        int money2=0;     //充值的钱
    l:  while(true){
        System.out.println("============欢迎来到博弈游戏=============");
        System.out.println("============1、进入游戏 2、退出游戏=== 请选择：");
        choose=sc.nextInt();
        if(choose==1){
            System.out.println("进入游戏成功！");
            dian=(int)(Math.random()*6+1)*3;
            if(dian>9){
                daXiao=1;
            }
            else{
                daXiao=2;
            }
            System.out.println("庄家点数已生成，请下注：1、大  2、小");
            selfDaXiao=sc.nextInt();
            System.out.println("买定离手，请压钱：");
            paymoney=sc.nextInt();
            while(true){
            if(paymoney>money1){
                System.out.println("操作不成功，余额不足，请及时充值，现在可以1、前往充值中心充值  2  修改下注金额  3  结束游戏");
                choose=sc.nextInt();
                if(choose==1){
                    System.out.println("欢迎来到支付宝充值中心，请输入想要充值的金额");
                    money2=sc.nextInt();
                    System.out.println("充值成功，您的余额为："+(money1+money2));
                    System.out.println("请您重新下注：");
                    paymoney=sc.nextInt();

                }
                else if(choose==2){
                    System.out.println("请您重新下注：");
                    paymoney=sc.nextInt();

                }
                else{
                    System.out.println("没钱回家！");
                    break l;
                }
            }
            else{
                if(paymoney%50==0&&paymoney<=1000&&paymoney>0){
                    break;
                }
                else{
                    System.out.println("押注必须小于1000且是50的倍数，请重新下注");
                    paymoney=sc.nextInt();
                }
            }}
            if(selfDaXiao==daXiao){
                money1+=paymoney;
                System.out.println("恭喜您猜对了");
                System.out.println("您的余额为："+money1);
            }
            else{
                money1-=paymoney;
                System.out.println("菜的抠脚！");
                System.out.println("您的余额为："+money1);

            }
        }
        else if(choose==2){
            System.out.println("退出游戏成功！");      
            break;
        }
        else{
            System.out.println("输入有误，请重新输入！");

        }
        }

    }
}

小结：

选择结构
if语句 单、双、多分支选择结构，等值、不等值判断均可
switch语句 只有多分支选择结构 只针对等值判断

循环结构
while循环 先判断再循环 适合循环次数不固定情况
do-while循环 先循环再判断 适合循环次数不固定情况
for循环 适合循环次数固定情况

循环跳转语句
break 跳出本层循环，跳出外层循环需要结合标签或符号位实现
continue 提前结束本次循环
return 结束当前方法

多重循环
任何两种循环都可以相互嵌套
外层循环变量变化一次，内层循环变量要变化一遍

求质数的4种写法：
一、if语句控制
public class PrimeNumber{
public static void main(String[] args){
for(int i=2;i<=100;i++){

        for(int j=2;j<i;j++){
            if(i%j==0){
                System.out.println(i+"不是质数");
                break;
        }
        else {
        System.out.println(i+"是质数");break;
        }
    }
}

}
}
二、布尔类型控制
class ZhiShuTest{
public static void main(String [] args){

    for(int i = 2;i<=100;i++){
        boolean flag = true;
        for(int j = 2;j < i;j++){
            //不是质数
            if(i % j == 0){
                flag = false;
            }
        }
        //判断当是质数时输出
        //if(flag==true){
        if(flag){
            System.out.println(i);
        }

    }
}

}
三、continue和标签的使用
class ZhiShuTest1{
public static void main(String [] args){

    l:for(int i = 2;i<=100;i++){
        for(int j = 2;j <= i/2;j++){
            //不是质数
            if(i % j == 0){
                continue l;
            }
        }
        System.out.println(i);
    }
}

}
四、判断条件的开方，效率较高
class ZhiShuTest1{
public static void main(String [] args){

    l:for(int i = 2;i<=100;i++){
        for(int j = 2;j <= Math.sqrt(i);j++){
            //不是质数
            if(i % j == 0){
                continue l;
            }
        }
        System.out.println(i);
    }
}

}

其中三和四种方法，i/2，和 Math.sqrt(i)效果相同。

面试题分析
weixin_46064172的博客
07-27 1959
一 vue优点？ 1、它是一个轻量级的框架 解释：Vue.js通过简洁的API提供高效的数据绑定和灵活的组件系统 2、简单易学 解释：国人开发,中文文档,不存在语言障碍,易于理解和学习 3、双向数据绑定 解释：结合了angular的特点，在操作数据时更为简单，减少dom操作，页面加载更快。 4、组件化 解释：在前端应用，我们是否也可以像编程一样把模块封装呢？这就引入了组件化开发的思想。 5、视图,数据,结构分离 解释：使数据的更改更为简单,不需要进行逻辑代码的修改,只
01.根据输入月份判断季节
SC的博客
09-10 9743
编程题目： 1.设计一个程序,键盘输入月份,控制条输出季节.3,4,5春季/6,7,8夏季/9,10,11秋季/12,1,2冬季。 示例代码： package program.calculation.exercise01; import java.util.Scanner; /** * 1.设计一个程序,键盘输入月份,控制条输出季节.3,4,5春季/6,7,8夏季/9,10,1...
输入月份就可以显示季节
04-18
输入月份就可以显示季节，该程序用VC2010编译器编写，
用switch语句实现输入月份，输出季节
围巢
03-12 1万+
switch注意事项 1.case 后面只能是常量，不能是变量，而且多个。 2.case后面的值不能出现相同的。 3.default可以省略，但不建议，除非判断的值是固定的。 4.default可以出现在switch语句的任意位置 5.switch语句的结束条件：遇到break或者执行到程序末尾。 6.break可以忽略，但结果可能不是想要的，可会出现case穿透 package javase; ...
需求：根据用户所输信息对应出相应的季节的if和switch两种结构
weixin_49341271的博客
10-26 188
import java.util.Scanner; /** * 需求：根据用户所输信息对应出相应的季节 * 分析： * 3~5春 * 6~8夏 * 9~11秋 * 12~2冬 * */ public class homework { //主方法 public static void main(String[] args) { //创建Scanner对象 Scanner sc = new ...
day03【 流程控制语句】.pdf
11-02
本文为读者提供了流程控制语句的概念和应用，包括Scanner类、Random类、顺序结构、判断语句、if语句、for循环、while循环、do...while循环、跳出语句break、continue等，旨在帮助读者更好地理解和应用流程控制语句。
流程控制语句：顺序结构、选择结构、循环结构
weixin_45887924的博客
02-08 624
顺序结构 代码从主函数开始逐行向下运行 是一种宏观的代码运行结构 选择结构 程序员在写代码时碰到了多中可能发生的情况时，会使用选择结构来完成程序。 选择结构主要有两种 if 语句和switch语句 if 和 switch 的区别： if 既可以对一个单一的值进行判断，也可以对一个区间的值进行判断；switch 只能判断单一的值 if语句 双分支 基本格式： if(条件表达式){ ...
【基础篇-Day4：JAVA流程控制语句(分支、循环)的介绍】
最新发布
Ma Sizhou
05-16 475
print9x9();i <= 9;j++){要是想要1-100之间的随机数怎么写？return i;} }Random;return i;
深入分析JAVA流程控制语句
08-19
Java流程控制语句是编程中不可或缺的部分，它们用于控制程序执行的顺序，使得代码可以根据不同的条件执行不同的路径或重复执行某些任务。以下是关于Java流程控制语句的详细说明： 1. **复合语句**：在Java中，复合...
用switch结构编程完成：输入月份数字，输出对应的季节，12-2月是冬季，3-5月是春季，6-8月是夏季，9-11月是秋季。
winds_tide的博客
08-14 1万+
#include<stdio.h> int main() { int a; printf("请输入一个月份："); scanf("%d", &a); switch (a) { case 3: case 4: case 5:printf("该月份是春季"); break; case 6: case 7: case 8:printf("该月份是夏季"); break; case 9: case 10: case 11:printf("该月份是秋季"); brea
1-3 用switch结构编写函数根据月份输出对应的季节
CN-WXY的专栏
03-13 5354
/* * 程序的版权和版本声明部分 * Copyright (c)2012, 烟台大学计算机学院学生 * All rightsreserved. * 文件名称： fun.cpp * 作 者：王心垚 * 完成日期：2013 年3月 13日 * 版本号： v1.0 * 对任务及求解方法的描述部分：用switch结构编写函数根据月份输出对应的季节。 * 输入描述：略 * 问题描述：略
Java笔试题（一）单选题
热门推荐
互联网叫兽
08-15 13万+
1、下列哪一种叙述是正确的 A． abstract修饰符可修饰字段、方法和类 B． 抽象方法的body部分必须用一对大括号{ }包住 C． 声明抽象方法，大括号可有可无 D． 声明抽象方法不可写出大括号 答案：D abstract（抽象）修饰符，可以修饰类和方法 abstract修饰符在修饰类时必须放在类名前。 public abstract void method(); 2、如下代码，...
else应输入一个语句是什么意思_Python基础知识储备，关于if-else使用性能的一点感悟...
weixin_39743511的博客
11-27 354
前面给大家介绍的if-if分支结构是只要条件满足就会执行；而if-else的语句结构是前面的条件成立执行什么操作，则下面的分支结构就不会被执行，若前面的条件不成立(否则)做什么。以下通过三个案例给大家演示if-else语句的使用方法：Python开发实例01：编程实现只有当用户输入用户名和密码正确时，才能成功登陆系统；反之则登陆失败，无法进入系统提示登录的用户输入用户名和密码；如果用户名和密码都输...
Java-用switch判断季节
weixin_30341735的博客
11-17 464
import java.util.*;class Demo3 { public static void main(String[] args) { //需求 ：输入一个月份 ，判断月份属于哪一个季节 ：春天:3,4,5 //夏天 ：6，7，8 ，秋天:9,10,11 冬天：12，1，2 System.out.println("请输入一个月份:"); //Scanner 输入函数...
java--输入月份输出相应的季节
dwldp的专栏
01-18 2167
import java.util.Scanner; class Demo4{ public static void main(String[] args){ Scanner sc = new Scanner(System.in); System.out.println("请输入一个月份"); int a = sc.nextInt(); if (a>=3 && a System.out
功能描述:给定月份，输出对应的季节switch
Qioooba的博客
03-28 2105
1.功能描述:给定月份，输出对应的季节 2.要求: (1)定义一个月份，例如：int month = 5; (2)输出该月份对应的季节 3,4,5春季 6,7,8夏季 9,10,11秋季 12,1,2冬季 (3)演示格式如下: 定义的月份:5 控制台输出:5月份是春季 public class JiJie { public static void main(String[] args){ i...
java程序控制语句 if、switch、while、do-while、for、for…each、break、continue、return语句
雨云21的博客
08-26 587
一、if语句 //condition可以是单个语句也可以是程序块 if(condition) //如果条件condition为真，则执行statement1 statement1; else //否则执行statement2 statement2; //任何时候两条语句都不能同时执行 嵌套if语句： 一个if语句包含另外一个if语句： if(i==10){ if(j<20) a=b; if(k>100) c=d; else a = c; //与if(k&
根据用指定的月份，打印该月所属的季节（if else）3,4,5 春季 6,7,8 为夏季 9,10,11 秋季 12,1,2为冬季
雪阳的博客
05-27 1万+
源码如下：         Scanner sr = new Scanner(System.in);         System.out.print("请输入月份（1-12）：");         int x = sr.nextInt();         if (x >= 3 && x             System.out.println(x+"月是春季！");   
循环语句 break与continue 九九乘法表
Heiko_O的博客
12-30 1319
1.for( ; ; )和 while (true) 都是死循环.不知道具体次数时,可以使用 whlie(true) 死循环,并用break控制结束 2.while 循环是条件循环; for 是次数循环 ;2个循环之间可以互相转换 3.break 用来结束整个循环;continue 用来跳过本次循环,继续执行下次满足条件的循环. 4.双重for循环: 外循环,控制行数,执行一次 内循环,控制列数,...
Java SE 易错题
新世界的大门
02-03 1万+
一、初始JAVA1、Java虚拟机就是一个虚拟的用于执行  字节码文件         的计算机。它是Java最核心的技术，是Java跨平台的基础。2、一个Java源程序是由若干个类组成。如果源文件中有多个类时，则只能有一个类是  Public        类，并且这个类必须与源文件名同名。 3、以下选项中关于Java跨平台原理的说法正确的是（AC  ）。（选择二项）    AJava源程序要先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值