JavaSE基础笔记——(程序流程控制:分支、循环结构)

1、分支语句:

if语句:

它是JAVA语言选择控制或分支控制语句之一,用来对给定条件进行判定,并根据判定的结果(真或假)决定执行给出的两种操作之一。

分类:

单分支if语句

格式:if(条件表达式){ 语句块}

双分支if语句

格式:if(条件表达式){语句块1

}else{语句块2}

多分支if语句

格式:if(条件表达式1){语句块1

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

}else if (条件表达式3){语句块3

}。。。。

else{语句块n}

if代码演示:

/**
        目标: 学会使用if分支结构解决问题,理解其流程。
 */
public class IfDemo1 {
    //If分支:根据判定的结果(真或假)决定执行某个分支的代码
    public static void main(String[] args) {
        // 需求: 心跳(60-100)之间是正常的,否则系统提示进一步检查
        // 格式1: if(条件表达式){   代码...}
        int hearBeat = 30 ;
        if (hearBeat < 60 || hearBeat >100){
        System.out.println("您的心跳数据是:" + hearBeat + ",您可能需要进一步检查!");
        }
        System.out.println("检查结束");

        // 格式2: if(条件表达式){  代码.....} else { 代码... }
        // 需求:发红包。
        double money = 5555 ;
        // 发送一个1314。
        if (money >= 1314){
            System.out.println("您当前发送红包成功---");
        }else {
            System.out.println("您自己都没钱了,就别发了---");
        }

        // 格式3: if(条件表达式){  代码....} else if(条件表达式){  代码....} ...else{ 代码...}
        // 绩效系统: 0-60 C ;60-80 B ;80-90 A ;90-100 A+ 。
        int score = 99 ;
        if (score >= 0 && score < 60 ){
            System.out.println("您本月的绩效是:C");
        }else if (score >= 60 && score <80 ){
            System.out.println("您本月的绩效是:B");
        }else if (score >= 80 && score <90 ){
            System.out.println("您本月的绩效是:A");
        }else if (score >= 90 && score <100 ){
            System.out.println("您本月的绩效是:A+");
        }else{
            System.out.println("您录入的分数有毛病! ");
        }
    }

switch语句:

匹配条件去执行分支,适合做值匹配的分支选择,结构清晰,格式很好。

格式:

switch(表达式){

        case 值1:

                执行代码。。。;

                break;

        case 值2:

                执行代码。。。;

                break;

............

        case 值n-1:

                执行代码。。。;

                break;

        default;

                执行代码n;

}

执行流程:

  1. 先执行表达式的值,拿着这个值去与case后的值进行匹配。
  2. 匹配哪个case的值为true就执行哪个case,遇到break就跳出switch分支。
  3. 如果case后的值都不匹配则执行default代码。

switch案例:

案例1:

        public static void main(String[] args) {
        // 目标: 学会switch分支结构,理解流程。
        //switch分支:匹配条件去执行分支,适合做值匹配的分支选择,结构清晰,格式良好。
        // 周一: 埋头苦干,解决bug           周五:今晚吃鸡
        // 周二: 请大牛程序员帮忙            周六: 与王婆介绍的小芳相亲
        // 周三: 今晚啤酒、龙虾、小烧烤       周日: 郁郁寡欢、准备上班。
        // 周四: 主动帮助新来的女程序员解决bug
        String weekday = "周四" ;
        switch (weekday){
            case "周一":
                System.out.println("埋头苦干,解决bug");
                break;
            case "周二":
                System.out.println("请大牛程序员帮忙");
                break;
            case "周三":
                System.out.println("今晚啤酒、龙虾、小烧烤");
                break;
            case "周四":
                System.out.println("主动帮助新来的女程序员解决bug");
                break;
            case "周五":
                System.out.println("今晚吃鸡");
                break;
            case "周六":
                System.out.println("与王婆介绍的小芳相亲");
                break;
            case "周日":
                System.out.println("郁郁寡欢、准备上班");
                break;
            default:
                System.out.println("数据有误!");
        }

    }
}

案例2(switch的穿透性):

 public static void main(String[] args) {
        //switch的穿透性:如果代码执行到没有写break的case块,执行完后将直接进入下一个case快执行代码
        // (而且不会进行任何匹配),直到遇到break才跳出分支。{case中没有写break会出现switch穿透现象}
        //switch穿透性解决的问题:存在多个case分支的功能代码是一样时,可以使用穿透性把流程集中到同一处处理,可简化代码。
        // 需求:用户输入月份可以展示该月份的天数。
        // 1、3、5、7、8、10、12月份是31天。
        // 2月份是闰年为29天、非闰年为28天。
        // 4、6、9、11月份 是30天。
        int month = 7 ;
        switch (month){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                System.out.println(month + "是31天!");
                break;
            case 2:
                System.out.println(month + "闰年为29天、非闰年为28天!");
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                System.out.println(month + "是30天!");
                break;
                default:
                    System.out.println("数据有误!");
        }
    }

switch的注意事项:

        目标:清楚switch的注意点,并在开发的时候注意。

  1. 表达式类型只能说byte、short、int、char,JDK5开始支持枚举,JDK7开始支持String、不支持double、float、long。

  2. case给出的值不允许重复,且只能是字面量,不能是变量。

  3. 不要忘记写break,否则会出现穿透现象。

if、switch分支各自适合做什么业务场景?
1、if其实在功能上远远强大于switch。
2、if适合做区间匹配。
3、switch适合做:值匹配的分支选择、代码优雅。

2、循环语句:

for循环:

格式: for(表达式1; 表达式2; 表达式3){ 循环体语句; }

循环变量:用来判断循环是否执行的变量

执行顺序:

1、执行表达式1:初始化语句,给循环变量赋初始值,它只执行一次

2、执行表达式2:循环条件,判断是否执行循环语句

3、如果条件为真,则执行语句块。为假,则结束循环。

4、表达式3:改变循环的变量的值。迭代语句。

5、在执行步骤二:如果条件为真,则执行步骤三。

如果条件为假,则结束循环。

for循环的一些案例:

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

 public static void main(String[] args) {
        // 求和 需求: 求1-5 之间的数据和,并把求和结果在控制台输出
        //1、定义for循环使其能够依次访问到:1、2、3、4、5。
        //2、在循环外定义一个整数变量sum来累加这些数据。
        //3、循环结束后,输出求和变量既是结果。
        int sum = 0 ;
        for (int i = 1 ; i <= 5 ; i++){ //i = 1、2、3、4、5.
            /**
               等价于:sum = sum + i
               i == 1 、 sum = 0 + 1 ;
               i == 2 、 sum = 1 + 2 ;
               i == 3 、 sum = 3 + 3 ;
               i == 4 、 sum = 6 + 4 ;
               i == 5 、 sum = 10 + 5 .
              */
            sum += i;
        }
        System.out.println("1-5之间的数据和是:" + sum);
}

 需求:求1-10之间的奇数和,并把求和结果在控制台输出。

 public static void main(String[] args) {
        // 需求:求1-10之间的奇数和,并把求和结果在控制台输出。
        //方式1:1、定义for循环使其能够依次访问到:1、2、3.....、10.
        //2、在for循环中通过if筛选出奇数
        //3、在循环外定义一个整数变量sum用来累加这些数据
        int sum = 0 ; //3、
        for (int i = 1 ; i <= 10; i++) {  //1、
            if (i % 2 == 1){ // i = 1、3、5、7、9.//2、
                sum += i;
            }
        }
        //输出求和变量。
        System.out.println("1-10之间的奇数和是:" + sum);

        System.out.println("----------------------------");
        //方式2:1、定义for循环使其能够依次访问到:1、3、5、7、9.
        //2、在循环外定义一个整数变量sum用来累加这些数据。
        int sum1 = 0 ;
        for (int i = 1; i <= 10 ; i += 2) { // i = 1、3、5、7、9.
            sum1 += i;
        }
        //3、输出求和变量。
        System.out.println("1-10之间的奇数和为:" + sum1);
    }

需求: 在控制台输出所有的水仙花数,水仙花数必须满足如下两个条件

1、水仙花数是一个三位数;2、水仙花数的个位、十位、百位的数字立方和等于原数。

 public static void main(String[] args) {
        //需求: 在控制台输出所有的水仙花数,水仙花数必须满足如下两个条件
        //1、水仙花数是一个三位数;2、水仙花数的个位、十位、百位的数字立方和等于原数。
        //分析:1、定义一个for循环从100到999.
        //2、每次访问到数据后,提取该数据的:个位、十位、百位数字。
        //3、使用if判断:个位、十位、百位的数字立方和是否等于原数,等于输出该数据。
        //在循环外定义一个变量用于记录水仙花的个数(想知道水仙花数的个数怎么办?)
        int count = 0;
        for (int i = 100 ; i <=999 ; i++) {
            // 个位
            int ge = i % 10 ;
            // 十位
            int shi = i / 10 % 10 ;
            // 百位
            int bai = i / 100 ;
            if (ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
                System.out.print(i + "\t");
                count ++ ; // 每输出水仙花个数时 count++。
            }
        }
        System.out.println(); // 换行!
        System.out.println("水仙花数量是:" + count);

}

While循环语句:

public static void main(String[] args) {
        // 目标: 学会使用while循环,并了解它的流程。
        //什么时候使用for循环,什么时候使用while循环?
        //功能上完全一样,for能解决的while也能解决。
        //使用规范是:知道循环几次:使用for;不知道循环几次建议使用:while。
        int i = 0 ;//初始化语句;
        while (i < 3){ // while(循环条件){
            System.out.println("Hello World"); // 循环体语句;
            i ++; // 迭代语句;
        }
    }

while 和 for 的区别:

  • while:在不知道循环次数的时候用while
  • for:知道循环次数时候,用for。
  • for循环和while循环的执行流程是一摸一样的。
  • for循环里,控制循环的变量只能在循环里可以使用。while循环种,控制循环的变量在循环后还可以继续使用。

While案例:

需求: 珠穆朗玛峰高度是8848860,纸张厚度是0.1,折叠纸张直到不低于珠穆朗玛峰的位置,求折叠次数。

public static void main(String[] args) {
        // 需求: 珠穆朗玛峰高度是8848860,纸张厚度是0.1,折叠纸张直到不低于珠穆朗玛峰的位置,求折叠次数。
        // 1、 定义变量记录山峰的高度和纸张的厚度。
        double peakHeight = 8848860 ; // 珠穆朗玛峰高度
        double paperThickness = 0.1 ; //纸张厚度
        //3、定义一个变量用于记录纸张折叠次数。
        int count = 0 ;
        //2、定义一个while循环控制纸张进行折叠。
        while (paperThickness < peakHeight){
            // 让纸张的厚度多一倍。
            paperThickness *= 2 ;
            count ++;
        }
        System.out.println("折叠次数为:" + count);
        System.out.println("纸张的最终厚度为:" + paperThickness);
    }

do-While语句

格式:
do{
   循环语句块;
    迭代语句;
}while(循环条件表达式);
for循环适用于明确知道循环的次数。
while循环适用于不知道循环的具体次数, 只知道达到某个条件的时候循环结束。
do-while循环适用于不知道循环的具体次数但至少要执行一次, 只知道达到某个条件的时候循环结束。

死循环:

// 目标:学会定义死循环。
        for (; ; ) {
            System.out.println("Hello World---");
        }

        // 经典写法
        while (true){
            System.out.println("我是快乐的死循环---");
        }

        do {
            System.out.println("我是快乐的死循环---");
        }while (true) ;

案例:系统密码是520,请用户不断的输入密码验证,验证不对输出密码错误,验证成功输出欢迎进入系统,并停止程序。

//需求:系统密码是520,请用户不断的输入密码验证,验证不对输出密码错误,验证成功输出欢迎进入系统,并停止程序。
        // 1、 定义正确的密码
        int okPassword = 520 ;
        // 2、 定义一个死循环让用户不断输入密码验证
        Scanner sc = new Scanner(System.in) ;
        while (true){
            System.out.println("请您输入正确的密码: ");
            int password = sc.nextInt();
            // 3、使用if判断密码是否正确
            if (password == okPassword){
                System.out.println("登录成功了--- ");
            break ; // 可以立即结束当前所在循环的执行的
            }else {
                System.out.println("密码错误! ");
            }
        }

循环中断:

break:

在循环结构种,用break语句跳出本层循环体,从而提前结束本层循环。

continue:

是结束本次循环(即跳过本次循环中余下尚未执行的语句),接着再一次进行循环条件的判断。

嵌套循环:

关键是执行顺序,外层循环执行1次,内层循环执行1圈。

外部循环每循环一次,内部循环全部执行完一次。

格式:
   外层循环{
       内层循环{
       
       }
}

例子:打星星。

System.out.println("----------在控制台使用* 打出四行五列的矩形------------------");
        for (int i = 0; i < 4 ; i++) {
            for (int j = 0; j < 5 ; j++) {
                System.out.print("*");
            }
            System.out.println(); // 换行
        }

3、随机数Random: 

 public static void main(String[] args) {
        // 目标: 学会使用java提供的随机数类Random。
        // 1、导包
        // 2、创建随机数对象
        Random r = new Random() ;
        // 3、调用nextInt功能(方法),可以返回一个整型的随机数给你
        //nextInt(n)功能只能生成: 0 - (n-1)之间的随机数,不包括n
        for (int i = 0 ; i < 20 ; i++) {
            int data = r.nextInt(10 ); // 0-9不包含10前(包前不包后)
            System.out.println(data);
            }

        System.out.println("----------Rondom生成区间随机数的技巧:减加法----------------------");
        // 1 - 10 的随机数===>- 1 ===> (0 - 9 ) + 1
        int data = r.nextInt(10) + 1 ; // 1 - 10
        System.out.println(data);

        // 3 - 17 的随机数===>- 3 ===> (0 - 14) + 3
        int data1 = r.nextInt(15) + 3 ; // 3 - 17
        System.out.println(data1);

        // 65 - 91 间的随机数===> -65 ===> (0-26) +65
        int data2 = r.nextInt(27) + 65 ; // 65 - 91
        System.out.println(data2);
        }

案例: 猜数字游戏:

需求:随机生成一个1-100之间的数据,提示用户猜测,猜大提示过大,猜小提示过小,直到猜中结束游戏。

public static void main(String[] args) {
        //猜数字游戏:需求:随机生成一个1-100之间的数据,提示用户猜测,猜大提示过大,
        // 猜小提示过小,直到猜中结束游戏。
        // 1、 随机生产一个1 - 100 之间的数据。
        Random r = new Random() ;
        int LuckNumber = r.nextInt(100) + 1;

        // 2、使用一个死循环让用户不断的去猜测,并给出提示。
        Scanner sc = new Scanner(System.in) ;
        while (true) {
            //让用户输入数据猜测
            System.out.println("请您输入猜测的数字(1-100): ");
            int guessNumber = sc.nextInt();

            // 3、判断这个猜测的数字与幸运数字的大小情况
            if (guessNumber > LuckNumber){
                System.out.println("您猜测的数字过大!");
            }else if (guessNumber < LuckNumber){
                System.out.println("您猜测的数字过小!");
            }else {
                System.out.println("恭喜您,猜中了!");
                break; //直接跳出并结束当前死循环!!
            }
        }
    }

分支、循环结构的一些练习题链接如下:

JavaSE基础——分支、循环语句练习题_小曹爱编程!的博客-CSDN博客JavaSE基础——分支、循环语句练习题https://blog.csdn.net/weixin_62993347/article/details/125737810?spm=1001.2014.3001.5501

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值