【JavaSE 第四天】

Jade_Heng_Star

已于 2022-10-02 16:15:03 修改

阅读量489

点赞数

分类专栏： JavaSE 基础文章标签： java intellij-idea 开发语言

于 2022-01-30 13:31:49 首次发布

本文链接：https://blog.csdn.net/Jade_Heng_Star/article/details/122736515

版权

JavaSE 基础专栏收录该内容

25 篇文章 1 订阅

订阅专栏

【JavaSE 第四天】

一、分支结构

练习

import java.util.Scanner;
// 输入年月日判断这一天是当年的第几天
public class Demo {
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.println("year=");
        int year=scanner.nextInt();
        System.out.println("month=");
        int month=scanner.nextInt();
        System.out.println("day=");
        int day=scanner.nextInt();
        int finalDay=0;
        boolean runYear=false;
        if((year%4==0&&year%100!=0)||year%400==0){
            runYear=true;
        }
        if(month>=1&&month<=12){
            switch (month){
                case 1:
                    if(day>=1&&day<=31){
                         finalDay=day;
                    }else{
                         System.out.println("数据不合法");
                    }
                    break;
                case 2:
                    if(runYear==false) {
                        if (day >= 1 && day <= 28) {
                            finalDay = day+31;
                        } else {
                            System.out.println("数据不合法");
                        }
                    }else{
                        if(day>=1&&day<=29){
                            finalDay=day+31;
                        }else{
                            System.out.println("数据不合法");
                        }
                    }
                    break;
                case 3:
                    if(day>=1&&day<=31){
                        finalDay=day+31+((runYear)?29:28);
                    }else{
                        System.out.println("数据不合法");
                    }
                    break;
                case 4:
                    if(day>=1&&day<=30){
                        finalDay=day+31+((runYear)?29:28)+31;
                    }else{
                        System.out.println("数据不合法");
                    }
                    break;
                case 5:
                    if(day>=1&&day<=31){
                        finalDay=day+31+((runYear)?29:28)+31+30;
                    }else{
                        System.out.println("数据不合法");
                    }
                    break;
                case 6:
                    if(day>=1&&day<=30){
                        finalDay=day+31+((runYear)?29:28)+31+30+31;
                    }else{
                        System.out.println("数据不合法");
                    }
                    break;
                case 7:
                    if(day>=1&&day<=31){
                        finalDay=day+31+((runYear)?29:28)+31+30+31+30;
                    }else{
                        System.out.println("数据不合法");
                    }
                    break;
                case 8:
                    if(day>=1&&day<=31){
                        finalDay=day+31+((runYear)?29:28)+31+30+31+30+31;
                    }else{
                        System.out.println("数据不合法");
                    }
                    break;
                case 9:
                    if(day>=1&&day<=30){
                        finalDay=day+31+((runYear)?29:28)+31+30+31+30+31+31;
                    }else{
                        System.out.println("数据不合法");
                    }
                    break;
                case 10:
                    if(day>=1&&day<=31){
                        finalDay=day+31+((runYear)?29:28)+31+30+31+30+31+31+30;
                    }else{
                        System.out.println("数据不合法");
                    }
                    break;
                case 11:
                    if(day>=1&&day<=30){
                        finalDay=day+31+((runYear)?29:28)+31+30+31+30+31+31+30+31;
                    }else{
                        System.out.println("数据不合法");
                    }
                    break;
                case 12:
                    if(day>=1&&day<=31){
                        finalDay=day+31+((runYear)?29:28)+31+30+31+30+31+31+30+31+30;
                    }else{
                        System.out.println("数据不合法");
                    }
                    break;
                default:
                    System.out.println("时间不合法");
            }
            System.out.println(year+"-"+month+"-"+day+"是第"+finalDay+"天");

        }
    }
}

二、循环结构

1. 结构分类

for 循环 for(循环入口;判断条件;循环变量迭代){ 循环体 }
（1）循环结构中的判断条件部分必须是布尔类型。
（2）初始化部分可以声明多个变量，但必须是同一个类型，同逗号分隔。
（3）可以有多个变量迭代更新。

public class Demo {
    public static void main(String[] args){
        int sum=0;
        for(int i=1;i<=100;i++){
            if(i%2==0){
                sum+=i;
            }
        }
        System.out.println(sum);
    }
}

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

判断水仙花数：

for(int i=100;i<=999;i++){
            int hundredValue=i/100;
            int tenValue=(i%100)/10;
            int singleValue=i%10;
            int hundredTotal=hundredValue*hundredValue*hundredValue;
            int tenTotal=tenValue*tenValue*tenValue;
            int singleTotal=singleValue*singleValue*singleValue;
            int sum=hundredTotal+tenTotal+singleTotal;
            if(sum==i){
                System.out.println("水仙花数有："+i);
            }
        }

while 循环 while(){ 循环体 }
指数爆炸：

        double paperHeight=1.0;
        double tatolHeight=88444300;
        int i=0;
        double sum=paperHeight;
        while(sum<=tatolHeight){
            //每折一次就翻倍
            sum*=2;
            i++;
        }
        System.out.println("一共需要："+i+"次能达到");
        System.out.println("最终厚度："+sum);

do…while…循环
先进入循环体一次，后判断条件，再次执行（运用稀少）。

2.循环的嵌套

九九乘法表：
正三角写法：

public class Demo {
    public static void main(String[] args){
        // 九九乘法表
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                if(i==j){
                    System.out.println(j+"×"+i+"="+i*j+"\t");
                }else{
                 System.out.print(j+"×"+i+"="+i*j+"\t");
                }
            }
        }
    }
}

另一种右正三角：

// 九九乘法表
        for(int i=1;i<=9;i++){
            for(int t=1;t<=9-i;t++){
                System.out.print("\t");
            }
            for(int j=1;j<=i;j++){
                System.out.print(i+"×"+j+"="+i*j+"\t");
            }
            System.out.println();
        }

另一种左倒三角：

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

另一种右倒三角：

// 九九乘法表
        for(int i=9;i>=1;i--){
            for(int j=9;j>=1;j--){
                if(j>i){
                    System.out.print("\t");
                }else{
                    System.out.print(i+"×"+j+"="+i*j+"\t");
                }
            }
            System.out.println();
        }

实际开发尽量不进行嵌套，影响工作效率。

三、 break 和 continue 的用法

1. 循环控制语句：

（1） break 结束本层循环

只能用于 switch 语句和循环语句块中
即使放在嵌套循环里面也只会终止本层循环；
其后不能再写任何语句，因为不执行。（无法访问的语句！）
当一个 switch 语句中出现在循环中，switch 语句中使用 break 只能能对 switch 语句有效，对循环无效。

（2） continue 终止本次循环

continue 只能用于循环语句中
两者功能类似，其后同样不再添加任何语句，
continue 语句用于跳过其所在循环语句块的一次执行，继续下一次循环
continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
continue 也可以标号结束（用法与break相同）

（3） return 结束一个方法

return 并非专门用来结束循环的，它的功能是结束一个方法。当一个方法执行到一个 return 语句时，这个方法将被结束。

（与 break 和 continue 不同的是，return 直接结束整个方法，不管这个 return 处于多少层循环之内）
返回一个值（类比于：买一瓶饮料（操作）拿给你（把值返回给你））每一个函数都会有一个 return （操作遇到 return 会结束，值遇到 return 会返回值）
就如基础的 main 函数中有一个 return，整个 main 函数就会结束掉，return 之后的代码也不会被执行
本质上不是控制循环的语句，是用来结束一个方法（函数）的，但也可以用来控制循环结束（同时整个函数也就结束，之后的代码也不会再执行）。

（4）break 的标号结束功能：

public class Demo {
    public static void main(String[] args){
        //break的标号结束方法：
        System.out.println("外层循环开始了！");
        a:for(int k=1;k<=10;k++){
            System.out.println("内层循环开始了！");
            b:for(int i=1;i<=10;i++){
                if(i==5){
                    break;
                }
                if(k==6){
                    break a;
                }
                System.out.println("k="+k+" i="+i);
            }
            System.out.println("内层循环执行结束了！");
        }
    }
}

查找一百以内的素数（质数）。（只能被一和它本身整除）案例：

public class Demo {
    public static void main(String[] args){
        //查找一百以内的素数（质数），只能被一和它本身整除
        for(int i=2;i<100;i++){
            //外层循环遍历数字
            boolean flag=true;
            //设置一个变量进行素数的判断
            for(int j=2;j<=i/2;j++){
                //内层循环进行判断，验证是否能被（2~i/2）整除
                if(i%j==0){
                    flag=false;
                    break;
                    //一遇到整除就要中断这个数的遍历，结束内层循环
                }
            }
            if(flag){
                System.out.println("一百以内素数有:"+i);
            }
        }
    }
}