Java----键盘录入、顺序、选择以及循环结构

这一部分主要是有关，Scanner进行键盘录入数据，以及顺序、选择、循环结构的使用。

键盘录入数据
把数据改为键盘录入，可以提高程序的灵活性。
如何进行键盘录入：
1、导包（位置放到class定义的上面）
import java.util.Scanner;
2、创建对象
Scanner sc = new Scanner(System.in);
3、接收数据
int x = sc.nextInt();
/*
        键盘录入两个数据，并对两个数据求和，输出结果
        键盘录入两个数据，获取两个结果中的最大值

    分析：
        1.导包
        2.创建Scanner对象
        3.使用对象的方法，输出两个值
        4.输出两个值相加的结果
 */

//创建Scanner对象
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入第一个数据");
        int x = sc.nextInt();

        System.out.println("请输入第二个数据");
        int y = sc.nextInt();

        System.out.println("两值相加的结果为："+(x+y));

        System.out.println("********************************************");

        //键盘录入两个数据，获取两个数据中的最大值
        System.out.println("请输入第二题的第一个数据");
        int a = sc.nextInt();

        System.out.println("请输入第二题的第二个数据");
        int b = sc.nextInt();

        //使用三目运算符求最大值
        int result = (a>b)?a:b;
        System.out.println("最大值为："+result);

流程控制语句中的 顺序结构
是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
总的来说：写在前面的先执行，写在后面的后执行。

流程控制语句中的 选择结构
选择结构也被称为 分支结构。
选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。

Java中提供两种选择结构语句：
if语句
switch语句

if语句的三种格式：
（1）if(关系表达式){
语句体
}

执行流程：
首先判断关系表达式里的结果值，无论关系表达式里面简单还是复杂，最后结果一定要是Boolean类型
如果是true就进入if大括号内，执行语句体
如果是false就不进入if大括号，继续执行后面的代码

public class IfDemo1 {
    public static void main(String[] args) {
        int a = 100;
        if(a<90){
            System.out.println("a是小于90的");
        }
        System.out.println("程序执行完毕");
    }
}
//程序执行完毕
1
2
3
4
5
6
7
8
9
10
if语句编写的注意事项
1、if判断里面的关系表达式一定要严格遵循结果是Boolean类型的规则
2、if语句控制的语句体如果是一条语句，大括号可以省略；
如果是多条语句，就不能省略，建议永远不省略
3、一般来说：有左大括号就没有分号，有分号就没有左大括号

public class IfDemo2 {
    public static void main(String[] args) {
        double x = 3.14;
        if(x>3);//这就默认有了一个空的语句体
        //这是一个普通的代码块
        {
            System.out.println("x是大于3的");
        }
        System.out.println("程序执行完毕");
    }
}
//x是大于3的
//程序执行完毕
1
2
3
4
5
6
7
8
9
10
11
12
13
（2）if(关系表达式){
语句体1;
}else{
语句体2;
}

执行流程：
1、先判断关系表达式里面的结果值，无论关系表达式里面是简单还是复杂，最后结果一定是Boolean类型
2、如果关系表达式的结果是true，那么就执行语句体1，不会执行else后面的语句体
3、如果关系表达式的结果是false，那么就执行else里面的语句体2

public class IfDemo3 {
    public static void main(String[] args) {
        long a = 13965873016L;
        if(!(a==13965873016L)){
            System.out.println("");
        }else{
            System.out.println("");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
这里讲解一种三元运算符和if语句的第二种格式相转换的问题。
三元运算符，它根据比较判断后，给出的也是两个结果，所以，这种情况和if语句的第二种格式很相似，他们在某些情况下应该是可以相互转换的。
1、当选择结构存在最后输出的语句是控制台输出，就无法改进成三元运算符
2、当if第二种结构的最后输出语句是一个结果值的时候，可以使用三元运算符进行改进

import java.util.Scanner;
public class IfDemo6 {
    public static void main(String[] args) {
        //创建Scanner对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数");
        int x = sc.nextInt();
        System.out.println("请输入第二个数");
        int y = sc.nextInt();
        if(x>y){//不考虑相等的情况
            System.out.println("最大值x："+x);
        }else {
            System.out.println("最大值y："+y);
        }
        System.out.println("*********************************");
        System.out.println("三元运算符进行改进");
        int max = (x>y)?x:y;
        System.out.println("最大值："+max);
    }
}
//请输入第一个数
//34
//请输入第二个数
//45
//最大值y：45
//*********************************
//三元运算符进行改进
//最大值：45
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
（3）if语句的第三种格式：
if(关系表达式1){
语句体1;
}else if(关系表达式){
语句体2;
}
…
else{
语句体n+1;
}

import java.util.Scanner;
public class IfDemo5 {
    public static void main(String[] args) {
        //创建Scanner对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数");
        int x = sc.nextInt();
        System.out.println("请输入第二个数");
        int y = sc.nextInt();
        if(x>y){
            System.out.println("最大值x:"+x);
        }else if (x==y){
            System.out.println("两个数相等");
        }else{
            System.out.println("最大值y:"+y);
        }
    }
}
//请输入第一个数
//1
//请输入第二个数
//2
//最大值y:2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
这里补充一个小知识点：第三种情况下的else可以省去，但就不属于if中的格式了

        练习题：使用if嵌套输出三个数中的最大值
1
import java.util.Scanner;
public class IfDemo7 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数");
        int x1 = sc.nextInt();
        System.out.println("请输入第二个数");
        int x2 = sc.nextInt();
        System.out.println("请输入第三个数");
        int x3 = sc.nextInt();
        if(x1 > x2){
            if(x1 > x3){
                System.out.println("最大值是x1:"+x1);
            }
        }else if(x2 > x3){    //潜台词就是x1<x3，x1>x2
            System.out.println("最大值是x2:"+x2);
        }else {        //潜台词就是x2<x3，x1<x3，x1>x2
            System.out.println("最大值是x3:"+x3);
        }
    }
}
//请输入第一个数
//1
//请输入第二个数
//2
//请输入第三个数
//3
//最大值是x3:3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
流程控制语句中的 switch选择结构

switch语句格式：
switch(表达式){
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
…
default:
语句体n+1;
break;
}

switch表达式的一些注意点：
表达式的取值：byte、short、int（没有long）、char（不能有浮点数）
JDK5(1.5)之后可以是枚举
JDK7(1.7)之后可以是String
case后面跟的是要和表达式进行比较的值
语句体部分可以是一条或者多条语句
break表示中断，结束的意思，可以结束switch语句
default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似

执行流程：
1、首先计算表达式的值
2、拿着计算好的值与case对应值按照从上到下的顺序进行比较，如有相同，开始执行该case对应的语句体
3、当语句体执行完之后，会执行紧接着的break语句，执行break语句就代表着switch选择结构结束（跳出switch选择）
4、当从上到下依次寻找case对应的值的时候，没有找到相匹配的值，就会执行default中的语句体，最后跳出循环

switch语句的注意事项:
case 后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
default可以省略吗?
可以省略。一般不建议。除非判断的值是固定的。(单选题)
break可以省略吗?
可以省略，一般不建议。否则结果可能不是你想要的
当所有break语句都省略的时候，表达式的值与case的值进行匹配，从匹配到的那个case语句体开始执行，一直执行到结尾，直到最后一个语句
default的位置一定要在最后吗?
可以出现在switch语句任意位置。
1、当计算完表达式的值后，先与每一个case按照顺序去匹配，如果所有的case都补匹配，那么最后再执行default,这个和你default放再哪里的
位置并没有关系。
2、即使你放在了第一个，某些case没有写break语句，那么也会先去匹配case，记住一句话，只有当所有case都不匹配的时候，才会去执行
default;
switch语句的结束条件
遇到break
执行到程序的末尾

public class SwitchDemo5 {
    public static void main(String[] args) {
        int x = 2;
        int y = 3;
        switch(x){
            default:
                y++; // 4
            case 3:
                y++; // 5
            case 4:
                y++; // 6
        }
        System.out.println("y="+y); // 6
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
流程控制语句 for循环
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
/*
循环结构：
循环语句可以在满足循环条件的情况下，反复执行某一段代码，
这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，
需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

分类：
1、for循环
2、while循环

循环的组成：
初始化语句：
一条或者多条语句，这些语句完成一些初始化操作。
判断条件语句：
这是一个boolean 表达式，这个表达式能决定是否执行循环体。
循环体语句：
这个部分是循环体语句，也就是我们要多次做的事情。
控制条件语句：
这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束。

for循环：
语句格式：
for(初始化语句;判断语句;控制条件语句){
语句体;
}

 执行流程：
    1、先初始化语句
    2、执行判断语句，判断语句一般返回的结果是boolean类型
        如果判断语句返回的是true,则执行语句体；
        如果判断语句返回的是false,则跳出当前for循环
    3、如果判断语句是true,且执行完了语句体，接着去执行控制条件语句
    4、再者去执行判断语句，如果是true，继续执行第二步。
1
2
3
4
5
6
7
使用for循环的注意事项：
1、判断条件语句的结果是一个boolean类型
2、循环体语句如果是一条语句，大括号可以省略；
如果是多条语句，大括号不能省略。建议永远不要省略，如果省略，循环只对第一条语句有效。
3、一般来说：有左大括号就没有分号，有分号就没有左大括号
4、初始化语句可以不在for循环的语句结构中出现，但是必须在其执行之前定义。
5、判断语句一定不能不能省略，否则就是死循环
6、控制条件语句可以不在for循环的语句结构中出现，但是，必须在语句体中进行变化。
*/

public class ForDemo2 {
    public static void main(String[] args) {
        int i = 1;
        for(;i<=10;) {
            System.out.println("HelloWorld!");
            i++;
        }
        //想要终止for的死循环，就将判断条件的结果写为false即可。
        for(;i<0;){
            System.out.println("这是死循环");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
我是酷酷的涛，一位大数据科班专业的大四学生。