Java基础知识笔记(三)

一、Java语句的执行结构

1.顺序结构
按照顺序从上往下依次执行，中间没有任何的判断和跳转

2.分支语句
if语句【if语句：单分支，if-else:双分支，if-else-if-else…:多重分支，if嵌套语句】、switch-case语句

3.循环结构
while语句、do-while语句、for循环

二、分支语句

1.什么是分支？
判断所给定的条件是否满足，根据判断的结果对应执行不同的语句

2.if语句

    使用布尔表达式或者布尔值作为条件来进行分支的控制

a.简单if语句【单分支】

    语法：
    if(条件表达式) {
        //执行语句
    }
    说明：1>这里的条件表达式一般使用的关系运算符
          2>如果条件表达式成立，则执行大括号中的语句，反之，不执行，程序在从上往下依次执行的过程中，直接跳过if语句，继续执行后面的语句

/*
        语法：
        if(条件表达式) {
            //执行语句
        }
        说明：1>这里的条件表达式一般使用的关系运算符
              2>如果条件表达式成立，则执行大括号中的语句，反之，不执行，程序在从上往下依次执行的过程中，直接跳过if语句，继续执行后面的语句
        */
        System.out.println("0000");

        int x = 3;

        //需求：判断x是否大于4，如果大于4，打印YES
        if(x < 4) {
            //执行语句
            //当条件表达式成立的时候，大括号中的语句会全部被执行
            System.out.println("YES");
            System.out.println("YES11");
            System.out.println("YES22");

        }

        System.out.println("1111");

b.if-else语句【双分支】

    语法：
    if(条件表达式) {
        //执行语句1
    } else {
        //执行语句2
    }
    说明：
    如果条件表达式成立，则执行语句1，如果不成立，则执行语句2【实现了二选一的操作】

/*
        语法：
        if(条件表达式) {
            //执行语句1
        } else {
            //执行语句2
        }
        说明：
        如果条件表达式成立，则执行语句1，如果不成立，则执行语句2【实现了二选一的操作】
        */

        //需求：如果你是男的，就去男厕所，如果是女的，就去女厕所；
        //规定：0代表男生，1代表女生
        int gender = 1;

        //实现了二选一
        String result1;
        if(gender == 0) {
            //System.out.println("就去男厕所");
            result1 = "就去男厕所";
        } else {
            //System.out.println("就去女厕所");
            result1 = "就去女厕所";
        }
        System.out.println(result1);

        //使用三目运算符实现上面的需求
        String result = (gender == 0) ? "就去男厕所" : "就去女厕所";
        System.out.println(result);

        /*
        在某些情境下，三目运算符可以简化if-else代码
        但是，必须要保证对应的情景有运算的结果
        */

c.if-else-if-else….【多重分支】

    语法：
    if(条件表达式1) {
        //执行语句1
    } else if(条件表达式2) {
        //执行语句2
    }else if(条件表达式3) {
        //执行语句3
    }
    ....
    else {
        //执行语句
    }
    说明：根据不同的表达式成立与否去执行对应的语句，但是，注意：只执行其中的一个分支【只要有一个条件成立，则执行对应的语句，然后整个if-else-if语句结束】

/*
        语法：
        if(条件表达式1) {
            //执行语句1
        } else if(条件表达式2) {
            //执行语句2
        }else if(条件表达式3) {
            //执行语句3
        }
        ....
        else {
            //执行语句
        }
        说明：根据不同的表达式成立与否去执行对应的语句，但是，
        注意：只执行其中的一个分支
        【只要有一个条件成立，则执行对应的语句，然后整个if-else-if语句结束】
        当if后面的条件都不成立的时候，去执行else后面的语句
        */

        //需求：根据成绩输出对应的等级
        /*
        90以上   优秀
        80~90  良好    80<= score < 90------>&&
        70~80  还行
        70以下    努力吧，少年
        */
        int score = 69;

        if(score >= 90) {
            System.out.println("优秀");
        } else if(score >= 80 && score < 90) {
            System.out.println("良好");
        }else if(score >= 70 && score < 80) {
            System.out.println("还行");
        } else {
            System.out.println("努力吧，少年");
        }

        System.out.println("OVER");

d.嵌套if语句

    在if语句中，再次添加if语句
    语法：
    if(条件表达式1) {

        //执行语句1

        if(条件表达式2) {
            //执行语句2
        }
    }
    说明：只有条件表达式1成立的情况下，当条件表达式2也成立时，才会执行语句2
    注意：从语法的角度来说，嵌套的层数没有限制，但是，为了提高程序的可读性，尽量嵌套的层数不要超过三层

/*
        语法：
        if(条件表达式1) {

            //执行语句1

            if(条件表达式2) {
                //执行语句2
            }
        }
        说明：只有条件表达式1成立的情况下，当条件表达式2也成立时，才会执行语句2
        注意：从语法的角度来说，嵌套的层数没有限制，
        但是，为了提高程序的可读性，尽量嵌套的层数不要超过三层
        */

        //需求：如果明天没太阳，并且有风，我们就出去玩
        //==:比较字符串，常量的话没问题，但是如果变量的话，比较不严谨
        String sun = "没太阳";
        String wind = "有风";

        if(sun == "没太阳") {

            System.out.println("没太阳的条件成立了");

            if(wind == "有风") {
                System.out.println("我们就出去玩");
            }
        }

2.switch-case语句

语法：
switch(变量) {
    case 常量值1：{
        //执行语句1
        break;
    }
    case 常量值2：{
        //执行语句2
        break;
    }
    case 常量值3：{
        //执行语句3
        break;
    }
    ...

    default:{
        //执行语句
    }
}

说明：根据变量的值进行匹配，如果在case分支中匹配到了相应的常量值，则执行case后面对应的语句，然后整个switch-case结束，当所有的case都没有匹配上的情况下，会执default中的语句

/*
        语法：
    switch(变量) {
        case 常量值1：{
            //执行语句1
            break;
        }
        case 常量值2：{
            //执行语句2
            break;
        }
        case 常量值3：{
            //执行语句3
            break;
        }
        ...

        default:{
            //执行语句
        }
    }
    说明：根据变量的值进行匹配，
    如果在case分支中匹配到了相应的常量值，则执行case后面对应的语句，
    然后整个switch-case结束，
    当所有的case都没有匹配上的情况下，会执default中的语句
        */

        //需求：有人加你好友，如果是美女的话，则欣然接受，如果是男的，则残忍拒绝，如果不明确性别的话，不做处理
        //规定：B---男  G---女
        char sex = 'Z';

        switch(sex) {
            default: {
                System.out.println("不做处理");
                break;
            }
            //如果是男的
            case 'B': {
                System.out.println("残忍拒绝");
                break;
            }
            case 'G': {
                System.out.println("欣然接受");
                break;
            }

        }

        //1.break的作用：如果没有break，case语句会向下穿透，作用：直接跳出swicth分支语句
        //2.default的作用：当所有的case分支都不匹配的时候，则最后默认执行default中语句
        //3.case先执行，default后执行
        //4.当default书写在case分支后面的话，最后执行，执行完成之后，整个switch-case语句结束
          //当将default书写在case分支的前面或者穿插在case分支中间的时候，务必要添加break，阻止向下的穿透



        //测试long、浮点型
        boolean num = true;
        switch(num) {
            case true:{
                System.out.println("111");
                break;
            }
            case false:{
                System.out.println("222");
                break;
            }
            default: {
            }
        }

总结：
a.变量的类型：byte.short,int,char，String【JDK1.7之后新添加的】，枚举
b.case和default的书写顺序和执行的顺序没有关系，先匹配case，然后去匹配default


穿插：Scanner的使用
JDK1.5之后添加的
作用：表示获取从控制台直接输入的内容
使用步骤：
第一步：导包【文件夹】，获取指定的类【如果一个类在java.lang包下，就不需要导包，是默认包】，格式：import java.util.Scanner;
第二步：创建输入器 ,格式：Scanner input = new Scanner(System.in);
第三步：开始获取控制台输入的值

总结：
    switch语句和if语句的区别

相同点：都是分支语句【选择语句】

不同点：
    a.语句后的表达式类型不同，if语句的表达式的值是boolean，但是switch的byte，short,int,char，String【JDK1.7之后新添加的】，枚举
    b.适用场景：变量的值在某个区间之内的话，选用if语句，switch语句适用于变量是某个定值【if的使用频率更广】

三、循环结构

1.什么是循环？
在满足条件的情况下，反复执行某一段代码，这段被反复执行的代码就被称为循环体

在反复执行循环体的时候，需要在合适的时机将条件改为不满足，从而结束循环，否则，这个循环将一直进行下去，称为死循环

2.三种循环语句

a.while语句

    语法：
    while（条件表达式） {
        //循环体
    }
    说明：当条件表达式成立的时候，循环体会被多次执行，直到条件表达式不成立，则整个while语句结束
    死循环：条件表达式一直成立

    while语句和if语句之间的区别：if只执行一次，while在满足条件的情况下会多次执行

/*
        语法：
        while（条件表达式） {
            //循环体
        }
        说明：当条件表达式成立的时候，循环体会被多次执行，直到条件表达式不成立，则整个while语句结束
        死循环：条件表达式一直成立
        */

        //需求：打印10次hello world
        //System.out.println("hello world");
        //System.out.println("hello world");
        //System.out.println("hello world");

        int num = 0;
        while(num < 10) {
            //循环体
            System.out.println("hello world");

            //在合适的时机将条件改为false
            num++;
            //++num;
        }

        System.out.println("OVER");

b.do-while语句

    语法：
    do {
        //循环体
    }
    while(条件表达式)；

/*
        语法：
        do {
            //循环体
        }
        while(条件表达式)；
        */
        int num = 0;
        while(num < 10) {
            System.out.println("hello world");
            num++;
        }

        int num1 = 0;
        do{
            System.out.println("hello world");
            num1++;
        }
        while(num1 < 10);


        //while和do-while二者之间的区别
        //while
        int x = 2;
        while(x < 1) {
            System.out.println("1111111");
            x++;
        }

        //do-while
        int y = 2;
        do
        {
            System.out.println("2222222");
            y++;
        }
        while (y < 1);

        /*
        总结：
        while:先判断条件，然后才执行循环体【使用频率更广】
        do-while:先去执行一次循环体，然后才去判断条件

        不管条件表达式成立与否，do-while都会至少执行一次
        */


        //死循环
        while(true) {
        }

c.for循环

    语法：
    for(表达式1；表达式2；表达式3) {
        //循环体
    }
    表达式1：初始化表达式【只执行一次】
    表达式2：循环条件表达式
    表达式3: 循环后的操作表达式
    执行顺序：表达式1---》表达式2---》表达式3---》表达式2----》表达式3.。。。。。
    类比while语句中三个表达式的执行顺序

/*
        语法：
        for(表达式1；表达式2；表达式3) {
            //循环体
        }
        表达式1：初始化表达式【只执行一次】
        表达式2：循环条件表达式
        表达式3: 循环后的操作表达式
        执行顺序：表达式1---》表达式2---》表达式3---》表达式2----》表达式3.。。。。。
        类比while语句中三个表达式的执行顺序

        */
        int x = 1;
        for(System.out.println("a");x < 3;System.out.println("b")) {
            System.out.println("c");
            x++;
        }
        //acbcb

//需求：打印10遍hello wolrd
        int num = 0;
        while(num < 10) {
            System.out.println("hello world");
            num++;
        }

        for(int num1 = 0;num1 < 10;num1++) {
            System.out.println("hello world");
        }

        //需求：打印0~9的数字
        for(int num1 = 0;num1 < 10;num1++) {
            System.out.println(num1);
        }
        //System.out.println(num1);


        int num2 = 0;
        while(num2 < 10) {
            System.out.println(num2);
            num2++;
        }
        System.out.println(num2);

//for循环的特殊写法
//1.标准写法
        for(int i = 0; i < 10;i++) {
            System.out.println(i);
        }

        //2.表达式1可以省略，但是要在外面进行声明
        int i = 0;
        for(;i < 10;i++) {
            System.out.println(i);
        }

        //3.表达式2可以省略,但是是死循环
        for(int j = 0;;j++) {
            System.out.println(j);
        }

        //4.表达式3也可以省略
        for(int k = 0; k < 10;) {
            System.out.println(k);
            k++;
        }

        //5.可以表达式1和表达式3同时省略
        int m = 0;
        for(;m < 10;) {
            System.out.println(m);
            m++;
        }

        //6.三个全部省略:死循环
        while(true) {
        }
        for(;;) {
        }

    总结：
    for循环和while循环的区别

    相同点：实现循环

    不同点:
        a.如果循环中的变量只是为了控制循环的次数的话，使用for循环，内存相对比较优化
        b.变量有自己的作用域【作用范围】，对于for而言，定义的变量只在for语句内有效，当for语句执行完毕之后，这个变量就会被销毁。while中变量的存活时间比for中变量的存活时间长

        d.扩展：嵌套for循环

    打印九九乘法表为例

//嵌套for循环：打印九九乘法表

/*
        分析
                                                    行       列
        1x1=1                                       1       1
        1x2=2   2x2=4                               2       2
        1x3=3   2x3=6   3x3=9                       3       3
        ......

        1x9=9   2x9=18  3x9=27  4x9=36 ... 9x9=81   9       9

        规律：列数跟着行数的变化而变化的，列数的最大值和行数相等
        */
        //嵌套for循环
        //外层for循环----控制行数
        for(int line = 1;line <= 9;line++) {

            //内层for循环----控制列数
            for(int column = 1;column <= line;column++) {
                System.out.print(column + "x" + line + "=" + column * line + " ");
            }

            System.out.println();
        }