2020年7月23日 Java 流程控制语句

/*
值：数据
变量：用来保存/存储值
表达式：
    用来计算的
语句：
    可以独立执行的，并且是要完成一件事情的。
    不是所有的表达式直接加;就可以构成语句的。

流程控制语句结构：
1、顺序结构（每一步都要走，而且从上往下顺着走）
2、分支结构（选择其中一个分支运行）
3、循环结构（重复执行某些语句）
*/
class Test01_Statement{
    public static void main(String[] args){
        int a = 10;
        //a;//没有意义，什么也没干
        //a>0?true:false;//这个表达式算完后，没有做具体的事情，例如：打印还是赋值等这些事情
        System.out.println("a = " + a);
        
        if(a%2==0){
            System.out.println(a+"是偶数");
        }else{
            System.out.println(a+"是奇数");
        }
        
        for(int i=1; i<=5; i++){
            System.out.println("柴老师真漂亮！");
        }
    }
}

/*
一、顺序结构
整个程序总体来说都是顺序执行的，从main()主方法开始，顺序往下走

比较有代表性：输入和输出

1、输出语句
System.out.println(xx); //输出xx之后换行
System.out.print(xx);//输出xx之后不换行

2、输入语句
步骤：
（1）准备一个数据的扫描仪（对象），指定数据的来源
java.util.Scanner input = new java.util.Scanner(System.in);


回忆：
    数据类型 变量名 = 值;
*/
class Test02_Order{
    public static void main(String[] args){
        /*
        （1）java.util.Scanner：是一个扫描仪的类型，是引用数据类型，首字母是大写
        其中java.util是包
        （2）input是一个变量名，它代表这个扫描仪
        （3）new java.util.Scanner(System.in)是给input赋值的，它是一个新的对象
        （4）(System.in)是指定了数据的来源，System.in默认代表键盘输入
        （5）整个语句中，唯一可以自己修改的就是input这个变量名
            如果你把input修改为其他了，那么下面的代码，凡是input的地方就修改为你自己命名的变量名
        */
        java.util.Scanner input = new java.util.Scanner(System.in);
        
        System.out.print("请输入年龄：");//这个语句在输入之前执行
        /*
        nextInt()是input这个对象的方法，所以Int的I是大写，因为方法名和变量名一样，从第二个单词开始首字母大写
        因为它是方法，所以()不能省略
        */
        int age = input.nextInt();//从扫描仪中获取一个int的值，赋值给age这个变量
        System.out.println("age = " + age);//输出age变量的值
        
        System.out.print("请输入姓名：");
        String name = input.next();//因为String输入太常用了，所以方法名简化了，没有用nextString
        
        System.out.print("请输入体重：");
        double weight = input.nextDouble();
        
        System.out.print("请输入是否漂亮：");
        boolean beautiful = input.nextBoolean();
        
        System.out.print("请输入性别：");
        char gender = input.next().charAt(0);//因为输入单个char太少用了，Scanner中没有提供输入单个char的方法，那么我们只能变通，先按字符串接收，然后取第一个字符
    
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        System.out.println("体重：" + weight);
        System.out.println("性别：" + gender);
        System.out.println("是否漂亮：" + beautiful);
    }
}

/*
二、分支结构
1、条件判断：if..else
2、选择结构：switch...case

（一）条件判断
1、单分支条件判断
语法格式：
if(条件表达式){
    当该条件表达式成立时，需要执行的语句
}

说明：
（1）if()中表达式必须是boolean类型的结果
①本身就是boolean类型的值
②比较表达式
③逻辑表达式
（2）当{}中的语句只有一句时，可以省略{}
但是我们不建议省略{}

提醒：
学习流程控制语句结构：
（1）语法格式
（2）执行特点
*/
class Test03_If{
    public static void main(String[] args){
        //1、从键盘输入一个年份
        //(1)准备Scanner扫描仪对象
        java.util.Scanner input = new java.util.Scanner(System.in);
        //(2)提示输入年份
        System.out.print("请输入年份：");
        //(3)输入并接收一个整数作为年份
        int year = input.nextInt();
        
        //2、需求：判断这个年份是否是闰年，然后显示它的2月份的总天数
        /*闰年的条件：（1）被4整除但不能被100整除或（2）被400整除
        */
        int days = 28;//平年
        
        //如果是闰年，days 修改为29
        /*
        if(year%4==0 && year%100!=0 || year%400==0){
            days = 29;
        }
        */
        if(year%4==0 && year%100!=0 || year%400==0)
            days = 29;
        
        System.out.println(year+"的2月份的总天数有：" + days);
    }
}

/*
二、分支结构
1、条件判断：if..else
2、选择结构：switch...case

（一）条件判断
1、单分支条件判断
2、双分支条件判断
if(条件表达式){
    当条件表达式成立时，要执行的语句块;
}else{
    当条件表达式不成立时，要执行的语句块;
}

说明：
（1）条件表达式必须是boolean值
（2）当{}中的语句只有一句时，可以省略{}
不建议省略{}
*/
class Test04_IfElse{
    public static void main(String[] args){
        /*
        从键盘输入一个整数，判断是偶数还是奇数
        */
        //1、键盘输入
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("请输入一个整数：");
        int num = input.nextInt();
        
        //2、判断
        /*
        if(num%2==0){
            System.out.println(num + "是偶数");
        }else{
            System.out.println(num + "是奇数");
        }
        */
        
        if(num%2==0)
            System.out.println(num + "是偶数");
        else
            System.out.println(num + "是奇数");
        
    }
}

/*
1、从键盘输入一个分数，如果60分（含）以上，就打印合格，如果60分以下，就打印不合格
提示：从键盘输入
*/
class Test05_Exer1{
    public static void main(String[] args){
        //1、从键盘输入一个分数
        java.util.Scanner input = new java.util.Scanner(System.in);
        
        System.out.print("请输入成绩：");
        int score = input.nextInt();
        
        //2、判断
        if(score >= 60){
            System.out.println("合格");
        }else{
            System.out.println("不合格");
        }
    }
}

class Test06{
    public static void main(String[] args){
    java.util.Scanner input = new java.util.Scanner(System.in);
    System.out.print("请输入一个数字，检验是否及格？");
    int num = input.nextInt();
    if(num < 60){
    System.out.println("不及格");
    }
    else if(num < 80){
    System.out.println("及格");
    }
    else if(num < 90){
    System.out.println("良好");
    }
    else if(num < 100){
    System.out.println("优秀");
    }
}

/*
二、分支结构
1、条件判断：if..else
2、选择结构：switch...case

（一）条件判断
1、单分支条件判断
2、双分支条件判断
3、多分支条件判断
语法格式：
if(条件表达式1){
    当条件表达式1成立时，要执行的语句块1;
}else if(条件表达式2){
    当条件表达式1不成立，
    当条件表达式2成立时，要执行的语句块2;
}else if(条件表达式3){
    当条件表达式1不成立，
    当条件表达式2不成立，
    当条件表达式3成立时，要执行的语句块3;
}。。。
【
else{
    当以上所有的条件都不成立时，要执行的语句块n+1；
}
】

说明：
（1）所有条件表达式必须是boolean值
（2）当{}中的语句只有一句时，可以省略{}
不建议省略{}


执行特点：
（1）不管有几个分支，最终只会执行其中的一个
（2）这么多条件表达式是顺序往下判断的，
如果上面有条件成立了，下面的就不看了；
如果上面的条件不成立，才会去看下面条件。
当多个条件的范围是“互斥”（没有重叠部分），顺序可以随意；
当多个条件的范围是“包含”（有重叠部分），顺序不能随意，小的在上，大的在下

*/
class Test06_IfElseIf{
    public static void main(String[] args){
        /*从键盘输入成绩：假设成绩输入[0,100]的合法成绩，这里先不讨论不合法的情况
        成绩分为：
            100分，输出满分
            90-99，输出优秀
            70-89，输出良好
            60-69，输出及格
            60以下，输出不及格
        */
        //1、从键盘输入成绩：
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("请输入成绩：");
        int score = input.nextInt();
        
        //2、判断
        
        if(score == 100){
            System.out.println("满分");
        }else if(score>=90 && score<=99){
            System.out.println("优秀");
        }else if(score>=70 && score<=89){
            System.out.println("良好");
        }else if(score>=60 && score<=69){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        
        /*
        if(score == 100){
            System.out.println("满分");
        }else if(score>=90){
            System.out.println("优秀");
        }else if(score>=70){
            System.out.println("良好");
        }else if(score>=60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        */
    }
}

/*
2、岳小鹏参加Java考试，他和父亲岳不群达成承诺：如果：
成绩为100分时，奖励一辆BMW；
成绩为(80，99]时，奖励一台iphone7plus；
当成绩为[60,80]时，奖励一个 iPad；
其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断
*/
class Test07_Exer2{
    public static void main(String[] args){
        //1、从键盘输入岳小鹏的期末成绩
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("请输入岳小鹏的成绩：");
        int score = input.nextInt();
        
        //2、判断
        if(score == 100){
            System.out.println("奖励一辆BMW");
        }else if(score>80){
            System.out.println("奖励一台iphone7plus");
        }else if(score>=60){
            System.out.println("奖励一个 iPad");
        }else{
            System.out.println("什么也没有");
        }
    }
}

class Test008{
    public static void main(String[] args){
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.println("请输入一个阿拉伯数字0-9");
        int num = input.nextInt();
        
        switch(num){
            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;
            case 8:
            System.out.println("七");
            break;
            case 9:
            System.out.println("七");
            break;
            default:
            System.out.println("错误");
            break;
        }
        
    }
}
//switch 注意是小写字母开头

/*
3、编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
对它们进行排序(使用 if-else if-else),并且从小到大输出。
*/
class Test08_Exer3{
    public static void main(String[] args){
        //1、键盘输入三个整数
        java.util.Scanner input = new java.util.Scanner(System.in);
        
        System.out.print("请输入num1：");
        int num1 = input.nextInt();
        
        System.out.print("请输入num2：");
        int num2 = input.nextInt();
        
        System.out.print("请输入num3：");
        int num3 = input.nextInt();
        
        //2、判断
        /*
        三个数排序，6种情况
        num1 <= num2 <= num3
        num1 <= num3 <= num2
        
        num2 <= num1 <= num3
        num2 <= num3 <= num1
        
        num3 <= num2 <= num1
        num3 <= num1 <= num2
        */
        if(num1<=num2 && num2<=num3){
            System.out.println(num1 + "<=" +  num2 + "<=" +  num3);
        }else if(num1<=num3 && num3<=num2){
            System.out.println(num1 + "<=" +  num3 + "<=" +  num2);
        }else if(num2<=num1 && num1<=num3){
            System.out.println(num2 + "<=" +  num1 + "<=" +  num3);
        }else if(num2<=num3 && num3<=num1){
            System.out.println(num2 + "<=" +  num3 + "<=" +  num1);
        }else if(num3<=num2 && num2<=num1){
            System.out.println(num3 + "<=" +  num2 + "<=" +  num1);
        }else{
            System.out.println(num3 + "<=" +  num1 + "<=" +  num2);
        }
        
    }
}

class Test009{
    public static void main(String[] args){
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.println("请输入一个阿拉伯数字0-9");
        int num = input.nextInt();
        
        switch(num){
            case 1:
            case 2:
            case 3:
            System.out.println("春");
            break;
            case 4:
            
            
            case 5:
            
            case 6:
            System.out.println("夏");
            break;
            case 7:
            
            case 8:
            
            case 9:
            System.out.println("秋");
            break;
            case 10:
            
            case 11:
            
            case 12:
            System.out.println("冬");
            default:
            System.out.println("错误");
            break;
        }
        
    }
}
//switch 注意是小写字母开头

/*
4、大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，
当然要提出一定的条件：高：180cm以上；富：财富1千万以上；帅：是。
如果这三个条件同时满足，则：“我一定要嫁给他!!!”
如果三个条件中有为真的情况，则：“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则：“不嫁！”
提示：从键盘输入
Scanner input=new Scanner(System.in);
input.nextInt();//接收从键盘输入的一个整数
input.next();输入一个字符串
input.nextDouble();//输入一个小数
input.nextBoolean();//输入一个布尔值
*/
class Test09_Exer4{
    public static void main(String[] args){
        //1、输入男方的条件
        java.util.Scanner input = new java.util.Scanner(System.in);
        
        System.out.print("请输入身高（单位：cm）：");
        int height = input.nextInt();
        
        System.out.print("请输入财富（单位：千万）：");
        double money  = input.nextDouble();
        
        System.out.print("请输入是否帅（true/false）：");
        boolean handsom = input.nextBoolean();
        
        //2、判断
        /*
        高：180cm以上；富：财富1千万以上；帅：是。
        如果这三个条件同时满足，则：“我一定要嫁给他!!!”
        如果三个条件中有为真的情况，则：“嫁吧，比上不足，比下有余。”
        如果三个条件都不满足，则：“不嫁！”
        */
        //if(height>=180 && money>=1 && handsom==true){
        if(height>=180 && money>=1 && handsom){    
            System.out.println("我一定要嫁给他!!!");
        }else if(height>=180 || money>=1 || handsom){
            System.out.println("嫁吧，比上不足，比下有余。");
        }else{
            System.out.println("不嫁！");
        }
    }
}

/*
4、大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，
当然要提出一定的条件：高：180cm以上；富：财富1千万以上；帅：是。
如果这三个条件同时满足，则：“我一定要嫁给他!!!”
如果三个条件中有为真的情况，则：“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则：“不嫁！”
提示：从键盘输入
Scanner input=new Scanner(System.in);
input.nextInt();//接收从键盘输入的一个整数
input.next();输入一个字符串
input.nextDouble();//输入一个小数
input.nextBoolean();//输入一个布尔值
*/
class Test09_Exer4_2{
    public static void main(String[] args){
        //1、输入男方的条件
        java.util.Scanner input = new java.util.Scanner(System.in);
        
        System.out.print("请输入身高（单位：cm）：");
        int height = input.nextInt();
        
        System.out.print("请输入财富（单位：千万）：");
        double money  = input.nextDouble();
        
        System.out.print("请输入是否帅（是/否）：");
        char handsom = input.next().charAt(0);
        
        //2、判断
        /*
        高：180cm以上；富：财富1千万以上；帅：是。
        如果这三个条件同时满足，则：“我一定要嫁给他!!!”
        如果三个条件中有为真的情况，则：“嫁吧，比上不足，比下有余。”
        如果三个条件都不满足，则：“不嫁！”
        */
        if(height>=180 && money>=1 && handsom==‘是‘){    
            System.out.println("我一定要嫁给他!!!");
        }else if(height>=180 || money>=1 || handsom==‘是‘){
            System.out.println("嫁吧，比上不足，比下有余。");
        }else{
            System.out.println("不嫁！");
        }
    }
}

/*
4、大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，
当然要提出一定的条件：高：180cm以上；富：财富1千万以上；帅：是。
如果这三个条件同时满足，则：“我一定要嫁给他!!!”
如果三个条件中有为真的情况，则：“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则：“不嫁！”
提示：从键盘输入
Scanner input=new Scanner(System.in);
input.nextInt();//接收从键盘输入的一个整数
input.next();输入一个字符串
input.nextDouble();//输入一个小数
input.nextBoolean();//输入一个布尔值
*/
class Test09_Exer4_3{
    public static void main(String[] args){
        //1、输入男方的条件
        java.util.Scanner input = new java.util.Scanner(System.in);
        
        System.out.print("请输入身高（单位：cm）：");
        int height = input.nextInt();
        
        System.out.print("请输入财富（单位：千万）：");
        double money  = input.nextDouble();
        
        System.out.print("请输入是否帅（帅/不帅）：");
        String handsom = input.next();
        
        //2、判断
        /*
        高：180cm以上；富：财富1千万以上；帅：是。
        如果这三个条件同时满足，则：“我一定要嫁给他!!!”
        如果三个条件中有为真的情况，则：“嫁吧，比上不足，比下有余。”
        如果三个条件都不满足，则：“不嫁！”
        handsom=="帅" 是不对的
        "帅".equals(handsom) 是可以的，String对象的比较
        */
        if(height>=180 && money>=1 && "帅".equals(handsom)){    
            System.out.println("我一定要嫁给他!!!");
        }else if(height>=180 || money>=1 || "帅".equals(handsom)){
            System.out.println("嫁吧，比上不足，比下有余。");
        }else{
            System.out.println("不嫁！");
        }
    }
}

/*
二、分支结构
1、条件判断：if..else
2、选择结构：switch...case

（一）条件判断
1、单分支条件判断
2、双分支条件判断
3、多分支条件判断
4、嵌套条件判断
语法格式：
在if(){
    出现了条件判断
}
或在else{
    出现了条件判断
}

当嵌套时，里面的条件判断要被执行的前提，外面的if或else要先满足。

*/
class Test10_NestIfElse{
    public static void main(String[] args){
        
        /*从键盘输入成绩：合法[0,100]之间
        成绩分为：
            100分，输出满分
            90-99，输出优秀
            70-89，输出良好
            60-69，输出及格
            60以下，输出不及格
        */
        //1、输入成绩
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("请输入成绩：");
        int score = input.nextInt();
        
        //2、判断
        if(score>=0 && score<=100){
            //再去判断是哪个等级的
            if(score == 100){
                System.out.println("满分");
            }else if(score>=90 && score<=99){
                System.out.println("优秀");
            }else if(score>=70 && score<=89){
                System.out.println("良好");
            }else if(score>=60 && score<=69){
                System.out.println("及格");
            }else{
                System.out.println("不及格");
            }
        }else{
            System.out.println("成绩输入有误，成绩范围：[0,100]");
        }
    }
}

class Test11_Random{
    public static void main(String[] args){
        //使用Math.random() 产生随机数
        System.out.println(Math.random());
        /*
        Math.random()：产生的随机数是[0,1)的小数
        */
        
        //如果我想要产生[1,10]之间的整数
        double rand = Math.random();//[0,1)的小数
        
        rand = rand * 10; //[0,10)的小数
        
        rand = rand + 1; //[1,11)的小数
        
        int num = (int)rand;//[1,10]的整数
        
        System.out.println(num);
        
        int m = (int)(Math.random()*10 + 1);
    }
}

/*
6、假设你想开发一个玩彩票的游戏，
程序随机地产生一个两位数的彩票，提示用户输入一个两位数，
然后按照下面的规则判定用户是否能赢。
1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000美元。
3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。
4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。
提示：使用Math.random() 产生随机数
Math.random() 产生[0,1)范围的随机值
两位数的范围：[10,99]
Math.random() * 90：[0,90) 
Math.random() * 90 + 10：[10,100) 即得到  [10,99]
使用(int)(Math.random() * 90  + 10)产生一个两位数的随机数。
*/
class Test12_Exer6{
    public static void main(String[] args){
        //1、随机地产生一个两位数的彩票
        int rand = (int)(Math.random() * 90  + 10);//[10,99]
        
        //2、提示用户输入一个两位数
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("请输入两位数的彩票号码：");
        int num = input.nextInt();
        
        //3、处理数字
        int randShi = rand/10;
        int randGe = rand%10;
        int numShi = num/10;
        int numGe = num%10;
        
        //4、判断
        /*
        1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
        2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000美元。
        3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。
        4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
        5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。
        */
        if(num == rand){
            System.out.println("奖金10 000美元");
        }else if(randShi == numGe && randGe == numShi){
            System.out.println("奖金3 000美元");
        }else if(randShi == numShi || randGe == numGe){
            System.out.println("奖金1 000美元");
        }else if(randShi == numGe || randGe == numShi){
            System.out.println("奖金500美元");
        }else{
            System.out.println("彩票作废");
        }
        
        System.out.println("本次号码：" + rand);
    }
}

/*
二、分支结构
1、条件判断：if..else
2、选择结构：switch...case

（一）条件判断
1、单分支条件判断
2、双分支条件判断
3、多分支条件判断
4、嵌套条件判断

（二）选择结构
语法结构：
switch(表达式){
    case 常量值1:
        语句块1;
        【break;】
    case 常量值2:
        语句块2;
        【break;】
    ...
    【default:
        语句块n+1;
        【break;】
    】
}
要求：
（1）case后面必须是常量值
（2）case后面的常量值不能重复
（3）switch()中的表达式的类型有要求：
    允许4种基本数据类型：byte,short,int,char
    允许2种引用数据类型：枚举（JDK1.5之后）、String（JDK1.7之后）

执行特点：
（1）入口
①当switch()中的表达式的值与某一个case后面的常量值“相等”，就会从这个case进入
②当switch()中的表达式的值与所有的case后面的常量值都“不相等”，就会寻找default进入
（2）出口
①自然出口：switch的结束}
②中断出口：break    （或后面要讲的return等）
（3）一旦找到“入口”就会顺序往下执行，直到遇到“出口”
（4）default的位置不一定在最后，习惯上我们写在最后

switch：开关
*/
class Test13_switch{
    public static void main(String[] args){
        /*
        请输入星期的数字，输出对应的英语单词
        */
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("请输入星期（1-7）：");
        int week = input.nextInt();
        
        //int a = 1;
        switch(week){
            default:
                System.out.println("输入有误");
                break;
            //case a:// a不是常量
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            case 6:
                System.out.println("Saturday");
                break;
            case 7:
                System.out.println("Sunday");
                break;
        }
    }
}

//8、使用 switch 把阿拉伯数字转为“零、壹、贰、叁、肆、伍、陆、柒、捌、玖”；其它的都输出 “other”。
class Test14_Exer8{
    public static void main(String[] args){
        //1、输入0-9的数字
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("请输入0-9的数字：");
        int num = input.nextInt();
        
        //2、转为中文大写数字
        switch(num){
            case 0:
                System.out.println("零");
                break;
            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;
            case 8:
                System.out.println("捌");
                break;
            case 9:
                System.out.println("玖");
                break;
            default:
                System.out.println("other");
        }
    }
}

/*
9、根据用于指定月份，打印该月份所属的季节。
3,4,5 春季 6,7,8 夏季  9,10,11 秋季 12, 1, 2 冬季
*/
class Test15_Exer9{
    public static void main(String[] args){
        //1、输入月份
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("请输入月份：");
        int month = input.nextInt();
        
        switch(month){
            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;
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
            default:
                System.out.println("输入有误！");
        }
    }
}

/*
11、从键盘分别输入年、月、日，判断这一天是当年的第几天 
   注：判断一年是否是闰年的标准：
       1）可以被4整除，但不可被100整除
       2）可以被400整除
*/
class Test16_Exer11{
    public static void main(String[] args){
        //1、从键盘分别输入年、月、日
        java.util.Scanner input = new java.util.Scanner(System.in);
        
        System.out.print("年：");
        int year = input.nextInt();
        
        System.out.print("月：");
        int month = input.nextInt();
        
        System.out.print("日：");
        int day = input.nextInt();
        
        //判断这一天是当年的第几天==>从1月1日开始，累加到xx月xx日这一天
        //(1)[1,month-1]个月满月天数
        //(2)第month个月的day天
        //(3)单独考虑2月份是否是29天（依据是看year是否是闰年）
        
        //2、声明一个变量days，用来存储总天数
        //int days = 0;
        //累加第month个月的day天
        //days += day;
        
        //修改上面的代码，直接把days初始化为day
        int days = day;
        
        //3、累加[1,month-1]个月满月天数
        /*
        switch(month){
            //case 1://不需要累加满月天数
            case 2:
                //累加1月的满月天数
                days += 31;
                break;
            case 3:
                //累加1月和2月的满月天数
                days += 31 + 28;
                break;
            case 4:
                //累加1月、2月、3月的满月天数
                days += 31 + 28 + 31;
                break;
            ....
        }
        */
        switch(month){
            case 12:
                //累加的1-11月
                days += 30;//这个30是代表11月份的满月天数
                //这里没有break，继续往下走
            case 11:
                //累加的1-10月
                days += 31;//这个31是代表10月的满月天数
                //这里没有break，继续往下走
            case 10:
                days += 30;//9月
            case 9:
                days += 31;//8月
            case 8:
                days += 31;//7月
            case 7:
                days += 30;//6月
            case 6:
                days += 31;//5月
            case 5:
                days += 30;//4月
            case 4:
                days += 31;//3月
            case 3:
                days += 28;//2月
                //4、在这里考虑是否可能是29天
                if(year%4==0 && year%100!=0 || year%400==0){
                    days++;//多加1天
                }
            case 2:
                days += 31;//1月
        }
        
        //5、输出结果
        System.out.println(year + "年" + month + "月" + day + "日是这一年的第" + days + "天");
    }
}       

/*
7、赌数游戏：随机产生3个1-6的整数，
如果三个数相等，那么称为“豹子”，
如果三个数之和大于9，称为“大”，
如果三个数之和小于等于9，称为“小”，
用户从键盘输入押的是“豹子”、“大”、“小”，并判断是否猜对了
*/
class Test17_Exer7{
    public static void main(String[] args){
        //1、随机产生3个1-6的整数
        int a = (int)(Math.random()*6 + 1);
        int b = (int)(Math.random()*6 + 1);
        int c = (int)(Math.random()*6 + 1);
        System.out.println("a="+a);
        System.out.println("b="+b);
        System.out.println("c="+c);
        
        //2、判断随机产生的数的结果是什么
        String result;
        if(a == b && b == c){
            result = "豹子";
        }else if(a + b + c > 9){
            result = "大";
        }else{
            result = "小";
        }
        
        //3、用户从键盘输入押的是“豹子”、“大”、“小”
        java.util.Scanner input = new java.util.Scanner(System.in);
        System.out.print("请押宝（豹子、大、小）：");
        String ya = input.next();
        
        //4、判断用户的输入是否猜对了
        //比较ya与result是否相同
        //if(result==ya){
        if(result.equals(ya)){
            System.out.println("猜对了");
        }else{
            System.out.println("猜错了");
        }
    }
}