Java04

选择结构switch

/*
    switch语句格式：
        switch(表达式) {
            case 值1:
                语句体1;
                break;
            case 值2:
                语句体2;
                break;
            ...
            default:
                语句体n+1;
                break;
        }
        
    格式的解释：
        switch:表示这是switch选择结构
        表达式:这个地方的取值是有限定的
            byte,short,int,char
            JDK5以后可以是枚举
            JDK7以后可以是字符串
        case:后面跟的是要和表达式进行比较的值
        语句体:要执行的代码
        break:表示中断，结束的意思，可以控制switch语句的结束。
        default:当所有的值都和表达式不匹配的时候，就执行default控制的语句。其实它就相当于if语句的else。
    
    面试题：
        byte可以作为switch的表达式吗?
        long可以作为switch的表达式吗?
        String可以作为switch的表达式吗?
        
    案例：
        键盘录入一个数据，根据这个数据，我们输出对应的星期?
            键盘录入1,对应输出星期一
            键盘录入2,对应输出星期二
            ...
            键盘录入7,对应输出星期日
            
    分析：
        1:键盘录入，用Scanner实现
        2:判断我们既可以使用if语句，也可以使用我们要讲解的switch语句
        
    注意：
        A:遇到左大括号缩进一个tab的位置。
        B:关联不是很大的语句间空行
*/
import java.util.Scanner;

class SwitchDemo {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        
        //控制键盘录入数据
        System.out.println("请输入一个数据(1-7):");
        int week = sc.nextInt(); //3
        
        //switch判断语句
        switch(week) {
            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;
            default:
                System.out.println("你输入的数据有误");
                break;
        }
    }
}

 

/*
    switch语句的注意事项：
        A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
        B:default可以省略吗?
            可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
            特殊情况：
                case就可以把值固定。
                A,B,C,D
        C:break可以省略吗?
            可以省略，但是结果可能不是我们想要的。
            会出现一个现象：case穿透。
            最终我们建议不要省略
        D:default一定要在最后吗?
            不是，可以在任意位置。但是建议在最后。
        E:switch语句的结束条件
            a:遇到break就结束了
            b:执行到末尾就结束了
*/
import java.util.Scanner;

class SwitchDemo2 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        
        //控制键盘录入数据
        System.out.println("请输入一个数据(1-7):");
        int week = sc.nextInt(); //3
        
        //定义常量
        //int number = 3;
        //然后把case后面的值改为number，就会报错
        
        //switch判断语句
        switch(week) {
            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;
            default:
                System.out.println("你输入的数据有误");
                //break;
        }
    }
}

 

/*
    switch语句的注意事项：
        A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
        B:default可以省略吗?
            可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
            特殊情况：
                case就可以把值固定。
                A,B,C,D
        C:break可以省略吗?
            可以省略，但是结果可能不是我们想要的。
            会出现一个现象：case穿透。
            最终我们建议不要省略
        D:default一定要在最后吗?
            不是，可以在任意位置。但是建议在最后。
        E:switch语句的结束条件
            a:遇到break就结束了
            b:执行到末尾就结束了
*/
import java.util.Scanner;

class SwitchDemo2 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        
        //控制键盘录入数据
        System.out.println("请输入一个数据(1-7):");
        int week = sc.nextInt(); //3
        
        //定义常量
        //int number = 3;
        //然后把case后面的值改为number，就会报错
        
        //switch判断语句
        switch(week) {
            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;
            default:
                System.out.println("你输入的数据有误");
                //break;
        }
    }
}

 

/*
    看程序写结果
*/
class SwitchTest {
    public static void main(String[] args) {
        int x = 2;
        int y = 3;
        switch(x){
            default:
                y++;
                break;
            case 3:
                y++;
            case 4:
                y++;
        }
        System.out.println("y="+y);  // 4
        System.out.println("---------------");
        
        int a = 2;
        int b = 3;
        // 先走case 3 再case 4 再default b=4,没有break case穿透
        // 到case 3 b=5 再到case 4 b=6
        switch(a){
            default:
                b++; // 4  
            case 3:
                b++; // 5  case穿透
            case 4:
                b++; // 6
        }
        System.out.println("b="+b);  // 6
    }
}

 

/*
    模拟单项选择题。
    
    分析：
        A:出一个选择题，然后供你选择。
        B:键盘录入选择的数据。
        C:根据选择来给出你选择的结论。
*/
import java.util.Scanner;

class SwitchTest2 {
    public static void main(String[] args) {
        //出一个选择题，然后供你选择。
        //由于我们现在没有办法键盘录入得到一个'A','B'
        //这样的东西，我就用65，66这样的值替代
        //将来我们获取到这样的值以后，强制转换为字符类型
        System.out.println("下面的几个人你最爱谁?");
        System.out.println("65 林青霞");
        System.out.println("66 张曼玉");
        System.out.println("67 刘德华");
        System.out.println("68 王力宏");
        
        //键盘录入选择的数据。
        Scanner sc = new Scanner(System.in);
        
        System.out.println("请输入你的选择：");
        int choiceNumber = sc.nextInt();
        
        //强制转换为字符类型
        char choice = (char) choiceNumber;
        
        switch(choice) {
            case 'A':
                System.out.println("恭喜你,选择正确");
                break;
            case 'B':
                System.out.println("不好意思，你选择有误");
                break;
            case 'C':
                System.out.println("不好意思，你选择有误");
                break;
            case 'D':
                System.out.println("不好意思，你选择有误");
                break;
            default:
                System.out.println("没有该选项");
                break;
        }
    }
}

 

/*
    根据你键盘录入的字符串，判断是否有满足要求的，如果有就输出。
    否则，提示有误。
    
    String s = sc.nextLine();
*/
import java.util.Scanner;

class SwitchTest3 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        
        //录入数据
        System.out.println("请输入你要判断的字符串：");
        String s = sc.nextLine();
        
        switch(s) {
            case "hello":
                System.out.println("你输入的是hello");
                break;
            case "world":
                System.out.println("你输入的是world");
                break;
            case "java":
                System.out.println("你输入的是java");
                break;
            default:
                System.out.println("没有找到你输入的数据");
                //break;
        }
    }
}

 

/*
    根据你键盘录入的字符串，判断是否有满足要求的，如果有就输出。
    否则，提示有误。
    
    String s = sc.nextLine();
*/
import java.util.Scanner;

class SwitchTest3 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        
        //录入数据
        System.out.println("请输入你要判断的字符串：");
        String s = sc.nextLine();
        
        switch(s) {
            case "hello":
                System.out.println("你输入的是hello");
                break;
            case "world":
                System.out.println("你输入的是world");
                break;
            case "java":
                System.out.println("你输入的是java");
                break;
            default:
                System.out.println("没有找到你输入的数据");
                //break;
        }
    }
}

 

/*
    用switch语句实现键盘录入月份，输出对应的季节
    
    分析：
        A:键盘录入一个月份，用Scanner实现
        B:用switch语句实现即可
        
    if语句和switch语句的区别?
        if语句：
            A:针对结果是boolean类型的判断
            B:针对一个范围的判断
            C:针对几个常量值的判断
        
        switch语句：
            针对几个常量值的判断
*/
import java.util.Scanner;

class SwitchTest4 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        
        //录入数据
        System.out.println("请输入月份(1-12)：");
        int month = sc.nextInt();
        
        /*
        switch(month) {
            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;
            case 10:
                System.out.println("秋季");
                break;
            case 11:
                System.out.println("秋季");
                break;
            case 12:
                System.out.println("冬季");
                break;
            default:
                System.out.println("你输入的月份有误");
        }
        */
        
        //这样写太麻烦了，我们使用一个我们不想使用的东西：case穿透
        switch(month) {
            case 1:
            case 2:
            case 12:
                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("你输入的月份有误");
        }
    }
}

循环for

/*
    需求：请在控制台输出10次"HelloWorld"
*/
class Demo {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
    }
}

 

/*
    循环语句：for循环,while循环,do...while循环。
    
    for循环格式：
        for(初始化语句;判断条件语句;控制条件语句) {
            循环体语句;
        }
        
        执行流程：
            A:执行初始化语句
            B:执行判断条件语句,看其返回值是true还是false
                如果是true，就继续执行
                如果是false，就结束循环
            C:执行循环体语句;
            D:执行控制条件语句
            E:回到B继续。
            
    注意事项：
        A:判断条件语句无论简单还是复杂结果是boolean类型。
        B:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
        C:一般来说：有左大括号就没有分号，有分号就没有左大括号
            
    需求：请在控制台输出10次"HelloWorld"
*/
class ForDemo {
    public static void main(String[] args) {
        //最原始的做法
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("----------");
        
        //这种做法不好,代码的重复度太高。
        //所以呢，我们用循环改进
        for(int x=1;x<=10;x++) {
            System.out.println("HelloWorld");
        }
    }
}

 

/*
    需求：请在控制台输出数据1-10
*/
class ForDemo2 {
    public static void main(String[] args) {
        //原始做法
        System.out.println(1);
        System.out.println(2);
        System.out.println(3);
        System.out.println(4);
        System.out.println(5);
        System.out.println(6);
        System.out.println(7);
        System.out.println(8);
        System.out.println(9);
        System.out.println(10);
        
        System.out.println("-------------");
        
        //如何改进呢?用循环改进
        for(int x=1; x<=10; x++) {
            System.out.println(x);
        }
        
        System.out.println("-------------");
        
        //从0开始
        for(int x=0; x<10; x++) {
            System.out.println(x+1);
        }
    }
}    

 

/*
    需求：求出1-10之间数据之和
    
    分析：
        0+1=1
            1+2=3
                3+3=6
                    6+4=10
                        10+5=15
                             ...
                             
        由此可见我们要定义两个变量：
            一个变量用于存储第一个加数，第一个加数其实保存的是以前的所有数据和。默认初始化值应该是0。
            一个变量用于存储第二个加数，第二个加数其实就是每次的数据变化的值。
            
    求和思想。        
*/
class ForDemo3 {
    public static void main(String[] args) {
        //原始做法
        System.out.println(1+2+3+4+5+6+7+8+9+10);
        
        //定义第一个加数
        int sum = 0;
        
        for(int x=1; x<=10; x++) {
            //这里的x其实是第二个加数
            sum = sum + x;
            /*
                0 + 1 = 1
                        1 + 2 = 3
                                3 + 3 = 6
                                ...
            */
            
            //sum += x;
        }
        
        System.out.println("sum:"+sum);
    }
}

 

/*
    需求：
        A:求1-100之和。
        B:求出1-100之间偶数和
        C:求出1-100之间奇数和(自己做)
*/
class ForDemo4 {
    public static void main(String[] args) {
        //求1-100之和。
        int sum1 = 0;
        
        for(int x=1; x<=100; x++) {
            sum1 +=x;
        }
        
        System.out.println("1-100之和是："+sum1);
        System.out.println("------------------");
        
        //求出1-100之间偶数和
        //方式1
        int sum2 = 0;
        
        for(int x=1; x<=100; x++) {
            if(x%2 == 0) {
                sum2 += x;
            }
        }
        
        System.out.println("1-100偶数之和是："+sum2);
        System.out.println("------------------");
        
        //方式2
        int sum3 = 0;
        
        for(int x=0; x<=100; x+=2) {
                sum3 += x;
        }
        
        System.out.println("1-100偶数之和是："+sum3);
        System.out.println("------------------");
    }
}

 

/*
    需求：求5的阶乘。
    
    什么是阶乘呢?
        n! = n*(n-1)! 规则
        n! = n*(n-1)*(n-2)*...*3*2*1
        
    求和思想。
    求阶乘思想。
*/
class ForDemo5 {
    public static void main(String[] args) {
        //定义最终结果变量
        int jc = 1;
        
        //这里的x其实可以直接从2开始
        //for(int x=1; x<=5; x++) 
        
        for(int x=2; x<=5; x++) {
            jc *=x;
        }
        
        System.out.println("1-5的阶乘是："+jc);
    }
}

 

/*
    天将降大任于斯人也,必先盗其QQ,封其微博,收其wifi,夺其手机。让其静心学习Java欧耶。

    需求：在控制台输出所有的”水仙花数”
    
    分析：
        我们都不知道什么叫"水仙花数"，你让我怎么做呢?
        
        所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
        举例：153就是一个水仙花数。
        153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153

        A:三位数其实是告诉了我们范围。
        B:通过for循环我们就可以实现获取每一个三位数
          但是麻烦是如何获取这个三位数的个,十,百位上的数据
          
          我们如何获取一个数据的个,十,百呢?
            假设有个一个数据:153
            ge:    153%10 = 3
            shi: 153/10%10 = 5
            bai：153/10/10%10 = 1
            qian：x/10/10/10%10
            wan:  x/10/10/10/10%10
            ...

        C:让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较
          如果相同，就把该数据在控制台输出。
*/
class ForDemo6 {
    public static void main(String[] args) {
        //三位数其实是告诉了我们范围。
        for(int x=100; x<1000; x++) {
            int ge = x%10;
            int shi = x/10%10;
            int bai = x/10/10%10;
            
            //让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较
            if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
                //如果相同，就把该数据在控制台输出。
                System.out.println(x);
            }
        }
    }
}

 

/*
    练习：
        请在控制台输出满足如下条件的五位数
        个位等于万位
        十位等于千位
        个位+十位+千位+万位=百位
        
    分析：
        A:五位数就告诉了我们范围。
        B:分解每一个五位数的个，十，百，千，万位上的数据
        C:按照要求进行判断即可
*/
class ForDemo7 {
    public static void main(String[] args) {
        //五位数就告诉了我们范围。
        for(int x=10000; x<100000; x++) {
            //分解每一个五位数的个，十，百，千，万位上的数据
            int ge = x%10;
            int shi = x/10%10;
            int bai  = x/10/10%10;
            int qian = x/10/10/10%10;
            int wan = x/10/10/10/10%10;
            
            //按照要求进行判断即可
            if((ge==wan) && (shi==qian) && (ge+shi+qian+wan==bai)) {
                System.out.println(x);
            }
        }
    }
}

 

/*
    需求：统计”水仙花数”共有多少个
    
    分析：
        A:首先必须知道什么是水仙花数
            所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
            举例：153就是一个水仙花数。
            153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
        B:定义统计变量，初始化值是0
        C:三位数告诉了我们范围，用for循环就可以搞定
        D:获取每一个三位数的个，十，百的数据
        E:按照要求进行判断
        F:如果满足要求就计数。
*/
class ForDemo8 {
    public static void main(String[] args) {
        //定义统计变量，初始化值是0
        int count = 0;
        
        //三位数告诉了我们范围，用for循环就可以搞定
        for(int x=100; x<1000; x++) {
            //获取每一个三位数的个，十，百的数据
            int ge = x%10;
            int shi = x/10%10;
            int bai = x/10/10%10;
            
            //按照要求进行判断
            if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
                //如果满足要求就计数。
                count++;
            }
        }
        
        System.out.println("水仙花数共有"+count+"个");
    }
}

 

/*
    需求：请统计1-1000之间同时满足如下条件的数据有多少个：
            对3整除余2
            对5整除余3
            对7整除余2

    分析：
        A:定义统计变量,初始化值是0
        B:1-1000之间是一个范围，用for很容易就可以实现。
        C:每个数据要同时满足如下要求
            x%3==2
            x%5==3
            x%7==2
        D:如果满足条件，统计数据++即可，最后输出统计变量
*/
class ForDemo9 {
    public static void main(String[] args) {
        //定义统计变量,初始化值是0
        int count = 0;
    
        //1-1000之间是一个范围，用for很容易就可以实现。
        for(int x=1; x<=1000; x++) {
            /*
                每个数据要同时满足如下要求
                x%3==2
                x%5==3
                x%7==2
            */
            if(x%3==2 && x%5==3 && x%7==2) {
                count++;
                System.out.println(x);
            }
        }
        
        //输出数据
        System.out.println("满足这样条件的数据共有："+count+"个");
    }
}