【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);
            }
        }

2. 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);

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

循环的嵌套

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

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的用法

循环控制语句

一、break结束本层循环
即使放在嵌套循环里面也只会终止本层循环；
只能用于switch语句和循环语句块中
其后不能再写任何语句，因为不执行。（无法访问的语句！）
当一个switch语句中出现在循环中，switch语句中使用break只能能对switch语句有效，对循环无效。
二、continue终止本次循环
continue只能用于循环语句中
两者功能类似，其后同样不再添加任何语句，
continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
continue也可以标号结束（用法与break相同）
三、return并非专门用来结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。
（与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内）
返回一个值（类比于：买一瓶饮料（操作）拿给你（把值返回给你））每一个函数都会有一个return （操作 遇到return会结束，值 遇到return会返回值）
就如基础的main函数中有一个return，整个main函数就会结束掉，return之后的代码也不会被执行
本质上不是控制循环的语句，是用来结束一个方法（函数）的，
但也可以用来控制循环结束（同时整个函数也就结束，之后的代码也不会再执行）。

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);
            }
        }
    }
}