java学习笔记（5） 控制语句、键盘输入

控制语句：

java控制可以分为7种：

*控制选择结构语句：

　　*if  if else

　　*switch

*控制循环结构语句：

　　*for

　　*while

　　*do while

*改变控制语句顺序：

　　*break

　　*continue

 if控制语句：

/*
    关于java语言当中的if语句，属于选择结构，if语句又被称为分支语句/条件控制语句；
        1、if语句的运发结构：包含4中编写方式
            第一种：
                if(布尔表达式){java语句;...};
            第二种：
                if(布尔表达式){
                    java语句;...
                }else{
                    java语句;...
                }
            第三种：
                if(布尔表达式){
                    java语句;...
                }else if(布尔表达式){
                    java语句;...
                }...
            第四种：
                if(布尔表达式){
                    java语句;...
                }else if(布尔表达式){
                    java语句;...
                }else{
                    java语句;...
                }
        重点：只要有一个if分支执行，整个if语句结束；
        注意：所有控制语句都是可以互相嵌套的。
        注意：嵌套使用的时候，代码格式要保证完美。
        注意：if语句中，只有一条java语句的话，大括号可以省略；
            if(true/false){java语句;}
            if(true/false) java语句;//但是不推荐使用，这种代码风格不好。不容易看清。
*/

public class ifTest01{
    public static void main(String[] args){
        // 需求，所在位置的5公里范围内有肯德基的话，去KFC吃午饭。
        // 公里数
        double distance = 6.0;//单位KM
        // 判断语句
        if(distance<=5){
            System.out.println("走着去KFC吃午饭");
        }else if(distance<=7.0&&distance>5){
            System.out.println("跑着去KFC吃午饭");
        }else{
            System.out.println("在附近吃别的");
        }

    }
}

接收用户键盘输入：

/*
    System.out.println() 负责向控制台输出，【从内存到控制台，输出的过程，这是从内存中出来了】
    接收用户键盘输入，从"键盘"到"内存"。【输入的过程，到内存汇总去】

*/

public class ifTest01{
    public static void main(String[] args){
        // 创建键盘扫描器对象
        java.util.Scanner s = new java.util.Scanner(System.in);
        // 第二部：调用Scanner对象的next()方法开始接收用户键盘输入
        // 程序执行到这里，会停下来，等待用户输入
        // 当用户输入的时候，并且最终敲回车键的时候，键入的信息会自动赋值给userInputContent
        // 程序执行到这里，用户输入的信息已经到内存中了

        // 接收文本【以字符串的形式接收】
        // String userInputContent = s.next();
        // 将内存中的数据输出到控制台
        // System.out.println("您输入了："+userInputContent);

        // 接收数字【以整数型的形式接收】
        int num = s.nextInt();
        System.out.println("您输入的数字是："+num);

    }
}

/*
    if控制语句练习：
        需求：假设系统给定一个人的年龄（这个年龄需要从键盘输入），
        根据年龄来判断这个人处于生命的哪个阶段。年龄必须在[0-150]
        [0-5]幼儿
        [6-10]少儿
        [11-18]青少年
        [19-35]青年
        [36-55]中年
        [56-150]老年
*/

public class ifTest01{
    public static void main(String[] args){
        // 1、接收键盘输入：年龄【输入的时候必须输入数字】

        // 创建键盘扫描器对象
        java.util.Scanner s = new java.util.Scanner(System.in);
        // 提示信息
        System.out.println("请输入您的年龄");
        int age = s.nextInt();//停下来等待用户输入，回车后赋值给age，然后往下执行
        System.out.println("age="+age);

        // 2、根据需求进行业务逻辑判断
        String str = "老年";
        if( age < 0 || age > 150 ){
            str = "您提供的年龄不合法，年龄需要在[0-150]";
        }else if(age <= 5){
            str = "幼儿";
        }else if(age <= 10){
            str = "少儿";
        }else if(age <= 18){
            str = "青少年";
        }else if(age <= 35){
            str = "青年";
        }else if(age <= 55){
            str = "中年";
        }else if(age <= 105){
            str = "老年";
        }
        System.out.println("您处于生命周期的"+str+"阶段");

    }
}

/*
    if控制语句练习：需求
        判断当前的天气：
            当外边下雨的时候：
                带雨伞：
                    男生：带一把大黑伞
                    女生：带一把小黑伞
            当外边晴天的时候：
                判断天气的温度：
                    当温度在30度以上：
                        男生：戴墨镜
                        女生：搽防晒霜

    提示：
        1、一定要用到嵌套
        2、天气状况、性别、温度都需要从键盘输入
            天气状况：1表示下雨、0表示晴天
            性别：1表示男、0表示女
            温度直接用数字表示即可
*/

public class ifTest01{
    public static void main(String[] args){
        java.util.Scanner s= new java.util.Scanner(System.in);

        System.out.println("欢迎使用本系统,您通过本系统可以完成一些简单的判断");
        System.out.println("说明1：1表示男、0表示女");
        System.out.println("说明2：1表示下雨、0表示晴天");
        System.out.println("说明3：用数字表示温度");

        // 接收性别
        System.out.println("请输入性别：");
        int sex = s.nextInt();
        // 接收天气状况
        System.out.print("请输入当前天气：");
        int weather = s.nextInt();
        // 判断天气状况
        if(weather == 1){
            // 下雨天
            System.out.println("下雨天");
            if(sex == 1){
                System.out.println("带一把大黑伞");
            }else if(sex == 0){
                System.out.println("带一把小花伞");
            }else{
                System.out.println("请输入正确的性别");
            }
        }else if(weather == 0){
            //晴天
            System.out.println("晴天");
            // 接收温度
            System.out.println("请输入温度：");
            int tem = s.nextInt();
            if(tem > 30){
                if(sex == 1){
                    System.out.println("带墨镜");
                }else if(sex == 0){
                    System.out.println("查防嗮爽");
                }else{
                    System.out.println("请输入正确的性别");
                }
            }else{
                System.out.println("今天天气良好，可以自由出行");
            }
        }else{
            System.out.println("您输入的天气有误，需要输入1或者0");
        };

    }
}

 switch语句

/*
关于switch语句：
    1、switch语句也属于选择结构，也属于分支语句
    2、switch语句的语法结构
        一个完整的switch语句应该这样编写：
            switch(int或String类型的字面值或变量){
                case int或String类型的字面值或变量:
                    java语句;
                    ...
                    break;
                case int或String类型的字面值或变量:
                    java语句;
                    ...
                    break;
                default :
                    java语句;
                    ...
            };
    3、switch语句执行原理：
        switch后面小括号当中的"数据"和case后面的"数据"，进行一一匹配，匹配成功的分支执行。
        按照从上到下的顺序依次匹配。
    4、匹配成功的分支执行，分支当中最后有break语句，整个switch语句终止。
    5、匹配成功的分支执行，分支当中最后没有break语句的话，直接进入下一个分支执行（不进行匹配）。
        这种现象被称为case穿透现象。【提供break;语句可以避免穿透】
    6、所有分支如果都没有匹配成功，如果有default语句的话，会执行default分支当中的语句。
    7、switch后面和case后面只能是int或String类型的数据，不能探测其它类型！
        *当然，byte、short、char也可以直接写到switch和case后面，因为他们可以进行自动类型转换。
            byte、short、char可以自动转换为int类型。
        *JDK6版本的话，switch和case后面只能探测int类型。
        *JDK7以后版本包括JDK7版本，引入新特性，switch和case后面可以探测int或String类型的数据。
    8、case可以合并：
        int i = 10;
        switch(i){
            case 1: case 2: case 3: case 10:
                java语句;
                ...
                break;
            default:
                java语句;
        }

*/
public class Switch01{
    public static void main(String[] agrs){
        /*类型错误
        long a = 100L;
        int b = a;
        */
        // 和上面的报错原因相同
        // long x = 100L;
        // switch(x){}

        // 解决编译错误
        long x = 100L;
        switch((int)x){};

        byte b = 10;
        switch(b){};

        short s = 20;
        switch(s){};

        char c = 'A';
        switch(c){};

        char cc = 97;
        switch(cc){};

        // switch(true){}; 编译错误  不兼容的类型 无法转换为int

        String username = "张三";
        switch(username){};

        /*
            较完整的switch语句
        */
        // 接收用户的输入：
        // 输入1：星期一
        // 输入2：星期二
        // ...
        // 输入7：星期日

        java.util.Scanner o = new java.util.Scanner(System.in);
        System.out.print("请输入数字1-7：");
        int num = o.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;
            default:
                System.out.println("您输入的啥都不是");
        }

        System.out.println("======================");
        //case穿透
        switch(num){
            case 1:
                System.out.println("星期一");
                // break;  输入1、2都会穿透到3的分支
            case 2:
                System.out.println("星期二");
                // break;   输入1、2都会穿透到3的分支
            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("您输入的啥都不是");
        };

        System.out.println("======================");
        //case合并
        switch(num){
            case 1: case 2: case 3: case 4: case 5:
                System.out.println("工作日");
                break;
            case 6: case 7:
                System.out.println("休息日");
                break;
            default:
                System.out.println("您输入的啥都不是");
        };

    }
}

/*
switch确实可以探测String类型，这是java7的新特性。
*/
public class Switch01{
    public static void main(String[] agrs){

        java.util.Scanner s = new java.util.Scanner(System.in);

        System.out.print("请输入汉字的星期几：");

        String str = s.next();
        switch(str){
            case "星期一":
                System.out.println(1);
                break;
            case "星期二":
                System.out.println(2);
                break;
            case "星期三":
                System.out.println(3);
                break;
            case "星期四":
                System.out.println(4);
                break;
            case "星期五":
                System.out.println(5);
                break;
            case "星期六":
                System.out.println(6);
                break;
            case "星期日":
                System.out.println(7);
                break;
            default:
                System.out.println("您输入有误");
        }
    }
}

/*

*/
public class Switch01{
    public static void main(String[] agrs){

        char c = 'A';
        switch(c){
            case 'A':
                System.out.println("高级");
                break;
            case 'B':
                System.out.println("中级");
                break;
            case 'C':
                System.out.println("低级");
                break;
            default:
                System.out.println("级别太低了");
        }
        switch(c){
            case 65://'A'对应的int类型是65
                System.out.println("高级");
                break;
            case 'B':
                System.out.println("中级");
                break;
            case 'C':
                System.out.println("低级");
                break;
            default:
                System.out.println("级别太低了");
        }
    }
}

/*
    需求：实现计算机中的加、减、乘、除、取余数
    实现思路：
        1、选择所有数据从键盘输入
        2、使用switch语句进行判断
        3、需要从控制台输入三次
            *第一个数字
            *运算符
            *第二个数字

*/
public class Switch01{
    public static void main(String[] agrs){

        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入第一个数字");
        int a = s.nextInt();
        System.out.print("请输入运算符");
        String str = s.next();
        System.out.print("请输入第二个数字");
        int b = s.nextInt();

        switch(str){
            case "+":
                System.out.println(a+" + "+b+" = "+(a + b));
                break;
            case "-":
                System.out.println(a+" - "+b+" = "+(a - b));
                break;
            case "*":
                System.out.println(a+" * "+b+" = "+(a * b));
                break;
            case "/":
                System.out.println(a+" / "+b+" = "+(a / b));
                break;
            case "%":
                System.out.println(a+" % "+b+" = "+(a % b));
                break;
            default:
                System.out.println("计算有误");
        }
    }
}

循环语句

for循环

/*
    1、循环结构
        在程序当中，总有一些需要反复的/重复执行的代码，假设没有循环结构，
        那么这段需要重复执行的代码自然是需要重复编写的。代码无法得到重复
        使用。所以多数变成语言都是支持训话结构的。将来把需要重复执行的代码
        片段放到"循环体"，再联合"计数器"，共同控制这段需要重复执行的代码。
    2、基本上所有的变成语言支持的循环包括三种：
        *for循环
        *while循环
        *do...while循环
    3、接下来主要介绍for循环：
        for循环的语法结构是什么呢？
            for(初始化表达式;布尔表达式;更新表达式){
                // 需要重复执行的代码片段【循环体：由java与语句构成】
            }
    4、for循环的执行过程/执行原理：
        4.1:初始化表达式、布尔表达式、更新表达式都不是必须的！【但是 两个分号 是必须的】
        4.2:初始化表达式最先执行，并且在整个for循环当中只执行一次。
        4.3:布尔表达式的执行结构必须是true/false,不能是其它值。
        4.4:for的执行过程：
            *先执行初始化表达式，并且该表达式只执行一次
            *判断布尔表达式的执行结构是true/false：
                - 布尔表达式true：
                    *执行循环体
                    *执行更新表达式
                    *判断布尔表达式的结构是true/false
                        - 布尔表达式true：
                            *执行循环体
                            *执行更新表达式
                            *判断布尔表达式的结构是true/false
                                ...
                        -布尔表达式false：
                            *循环结束
                - 布尔表达式false：
                    *循环结束
*/

public class For01{
    public static void main(String[] args){
        // 需求：输出数字1-10
        for(int i = 1; i <= 10; i++){
            System.out.println(i);
        };

        // 死循环
        // for( ; ; ){
        //     System.out.println("我是死循环");
        // }

        // 需求：
        // 找出1-100所有奇数
        // 方案1：从1开始，每次递增2，这样每一个数字一定是奇数
        for(int i = 1; i<= 100; i+=2){
            System.out.println(i);
        }
        // 方案2：从1开始，每次都递增1，每次判断是否为奇数，如果是再输出。
        for(int i = 1; i<= 100; i++){
            if((i % 2) != 0){
                System.out.println(i);
            }
        }

        // 计算1-100所有奇数的和
        int sum = 0;
        for(int i = 1;i <= 100; i+=2){
            sum += i;
        }
        System.out.println("sum = " + sum);

        // for循环的嵌套使用
        // 内层循环中的变量名不能和外层循环中的变量名重复
        for(int i = 0; i < 10; i++){
            for(int j = 0; j < 3; j++){
                System.out.println(j);//0、1、2执行10遍
            }
        }

        // 写一个九九乘法表
        String str = "";
        for(int i = 1;i < 10; i++){
            str = "";
            for(int j = 1;j <= i;j++){
                str += (i + " * " + j + " = "+(i * j)+ "; ");
            }
            System.out.println(str);
        }
    }
}

public class For01{
    public static void main(String[] args){
        // 编写for循环，找出1-100中所有的素数
        // 素数又被称为质数，只能被1和本身整除
        int count = 0;//计数 被整除的次数
        int num = 0;//计数 打印的次数
        System.out.println(2);
        for(int i = 3;i < 100;i++){
            count = 0;
            for(int j = 1;j <= i;j++){
                if(i % j == 0){
                    count++;
                }
            }
            if(count == 2){
                System.out.println(i);
            }
        }

        // 升级版
        // 编写for循环找出1-10000中所有的素数
        // 要求每8个换一行输出
        for(int i = 3;i < 10000;i++){
            count = 0;
            for(int j = 1;j <= i;j++){
                if(i % j == 0){
                    count++;
                }
            }
            if(count == 2){
                num++;
                if(num % 8 == 0){
                    System.out.print("\n");
                }
                System.out.print(i +" ");
            }
        }
    }
}

public class Continue{
    public static void main(String[] args){
        // 打印出1-100的素数
        boolean issushu = true;
        // 1不是素数，所以直接从2开始
        for(int i = 2;i <= 100;i++){
            issushu=true;//初始化一下issushu的值
            for(int j = 2;j < i;j++){
                if(i % j == 0){
                    issushu = false;//除了1和本身外能够被其它数整除，代表不是素数
                    break;//加上break，大大提高执行效率
                }
            };
            if(issushu){
                System.out.println(i);
            }
        };
        // 升级版
        // 找出1-10000的素数
        // 每8个换一行
        int count = 0;
        for(int i = 2;i <= 10000;i++){
            issushu=true;
            for(int j = 2;j < i;j++){
                if(i % j == 0){
                    issushu = false;
                    break;
                };
            };
            if(issushu){
                System.out.print(i+" ");
                count++;
                if(count % 8 == 0){
                    System.out.println();//换行
                }

            }
        };
    }
}

 while循环

/*
1、while循环的语法结构：
    while(布尔表达式){
        循环体;
    }
2、while循环的执行原理：
    -先判断布尔表达式结果：
        *true：
            -执行循环体
            -判断布尔表达式
                *true：
                    -执行循环体
                    -判断布尔表达式
                        ...
                *false：
                    -循环结束
        *false：
            -循环结束
3、while循环的循环次数：
    0 ~ N次；
    注意：如果while循环的循环体有可能一次都不执行

*/

public class While01{
    public static void main(String[] args){
        // 写个死循环
        // while(true){
        //     System.out.println("死循环");
        // }
        // 编译器检测到死循环后面的语句永远都执行不到  编译器真牛逼
        // System.out.println("死循环后面的语句");

        int i = 10;
        int j = 3;
        while(i < j){
            System.out.println("永远都执行不到");
        }

        // while(i > j){//这样写虽然是死循环，但是编译器不会报错 [后面的语句执行不到],因为变量的内存空间时在运行期开辟的
        //     System.out.println("死循环");
        // }
        // 编译通过
        // System.out.println("在死循环后面的语句");

        // while(10 > 3){//这样写  后面的语句执行不到  会编译报错
        //     System.out.println("死循环");
        // }
        // System.out.println("写在死循环后面的语句执行不到，编译器会报错");

    }
}

/*
*/

public class While01{
    public static void main(String[] args){
        // while循环输出1-10
        int i = 1;
        while(i <= 10){
            System.out.println(i);
            i++;
        }
        System.out.println("------------------");
        // while循环输出10-1
        int j = 10;
        while(j > 0){
            System.out.println(j--);
            System.out.println("--->"+j);
        }

        int k = 10;
        while(k >= 0){
            System.out.println(--k);//输出 9到-1
        }

    }
}

 dowhile循环：

/*
    do..while循环
        1、do..while循环的语法结构：
            do{
                循环体;
            }while(布尔表达式);
        2、do..while循环的执行原理：
            先执行循环体，再执行判断布尔表达式，若果为假，循环结束，如果为真，再执行循环体。以此类推。
        3、do..while循环的执行次数：
            1-N次，也就是循环体执行一次
        4、使用do..while循环的注意事项：
            do..while循环最终有一个分号，别丢了。
*/
public class DoWhile{
    public static void main(String[] args){
        int i = 10;
        do{
            System.out.println(i);
        }while(i > 100);//条件为假  会执行一次
        System.out.println("----------------------------");
        while(i > 100){//条件为假  一次都不执行
            System.out.println(i);
        };
        System.out.println("-----------------------");
        int a = 1;
        do{
            System.out.println(a);
            a++;
        }while(a <= 10);
    }
}

控制循环的语句：

break;

/*
    关于java控制语句当中的break语句：
        1、break是java语言中的关键字，被翻译为"中断/折断".
        2、break + ";",可以成为单独的java语句：break;
        3、break语句使用在switch语句中，用来终止switch语句。
        4、break语句同样可以使用在for循环中，用来终止循环。
        5、break终止那个循环呢？
        6、break;使用在for、while、do..while循环中，用来跳出循环，终止循环的执行。
            因为当循环执行到某个条件的时候，后面的循环没必要再执行了，再执行也是耗费资源。
            所以可以终止循环，这样可以提高循环的执行效率。
        7、以下以for循环为例，讲解break;
        8、在默认情况下，break;终止的是离他最近的循环；当然也可以指定终止某个循环，
            需要给循环起名，采用这种语法：break 循环名称;

*/
public class DoWhile{
    public static void main(String[] args){
        for(int i = 0;i < 10;i++){//0，1，2，3，4这段代码打印到4就不再执行了
            if(i == 5){
                break;
            }
            System.out.println(i);
        };
        // 这里的程序和for循环无关,以下程序照样执行
        System.out.println("hello world");

        System.out.println("------------------");
        // break;终止的是当前循环，不影响外层循环
        for(int j = 0;j < 3;j++){
            for(int i = 0;i < 10;i++){
                if(i == 5){
                    break;
                }
                System.out.println(i);
            };
        };
        // 在来看看以下代码
        System.out.println("--------------------------");
        // 以下语法使用较少，但需要会用
        // 给for循环起名叫for1
        for1:for(int j = 0;j < 3;j++){
            // 给for循环起名叫for2
            for2:for(int i = 0;i < 10;i++){
                if(i == 5){
                    break for1;//在这里终止的是for1循环
                }
                System.out.println(i);
            };
        };

    }
}

 continue：

/*
    continue语句：
        1、continue表示：继续/go on/下一个
        2、continue也是一个continue关键字加一个分号构成一个单独的完整的java语句，
            出现在循环语句当中，用来控制循环的执行。
        3、break和continue的区别：
            *break表示循环不执行了。终止循环。
            *continue表示直接跳出当前"本次"循环，进入下一个循环继续执行。
        4、continue也有这样的语法：
            continue 循环名称;【了解即可，用的不多】
*/

public class Continue{
    public static void main(String[] args){
        // break
        for(int i = 0;i < 10;i++){//0、1、2、3、4
            if(i == 5){
                break;
            }
            System.out.println("i = "+i);
        };
        System.out.println("-------------------------");
        // continue
        for(int i = 0;i < 10;i++){//0、1、2、3、4、(跳过5)、6、7、8、9
            if(i == 5){
                continue;
            }
            System.out.println("i = "+i);
        };
        System.out.println("-------------------------");
        // continue 循环名称;
        for1:for(int i = 0;i < 5;i++){//总共执行4次，因为中间跳过一次
            for2:for(int j = 0;j < 5;j++){
                if(i == 3){
                    continue for1;//当i==3时，跳出for1外层的这一次循环，继续执行
                };
                System.out.println(i+"---"+j);
            }
        };
    }
}

。