Day03 --java语言基础 Scanner 选择语句结构

 a.
    逻辑运算符
        &(逻辑与) |(逻辑或) ^（逻辑异或） !（逻辑非）
        
    & 
        并且，and。有false，则false。
    | 
        或，or。有true，则true。【遇true，就true。】
    ^ 
        相同为false，异同为true。【男男为false,女女为false。男女为true。】
    ！ 
        非false就是true, 非true就是false。【!true,结果false。!false，结果true。】
    
    逻辑运算符特定：
        结果都是Boolean类型。


    && 和 ||
        &&与&的区别？
            1）结果都一样。
            2）具有短路的效果，当左边为false，右边【不执行】，如果左边为true，右边一定会执行。因为已经决定了整个条件的结果，都为false。


        ||与|的区别？
            1）结果也一样。
            2）具有短路的效果，当左边为true，右边【不执行】，如果左边为false,右边一定会执行。因为已经决定了整个条件的结果，都为true。
    p.s.
        使用&&和|| 比使用 &和|效果更高些。    


&与&&的例子：
具有短路的效果，当左边为false，右边【不执行】，如果左边为true，右边一定会执行。因为已经决定了整个条件的结果，都为false。
    //&与&&的例子：
        int a = 4;
        int b = 5;
    
        System.out.println(++a==4 & ++b==5); //false & false == false
                        //   5==4 &   6==5
        System.out.println("a = "+ a); //5  当逻辑运算符是单个&时，左边为false，右边也参与运算，a的结果是5；
        System.out.println("b = "+ b); //6    当逻辑运算符是单个&时，左边为false，右边也参与运算，b的结果是6；


        //当左边为false，右边【不执行】
        int x = 8;
        int y = 9;
        System.out.println(++x == 8 && ++y == 9); //false && 不参与运算 == false 
                        //   9 == 8 &&  9  ==9  //当逻辑运算符是&&时，左边为false,右边不参与运算，即x=9,y=9;
    
        System.out.println("x = "+ x); //9
        System.out.println("y = "+ y); //9


        //如果左边为true，右边一定会执行。
        int z = 4;
        int t = 7;
        System.out.println(z++ ==4 && ++t ==7); // true && false = false
                    //       4 ==4 &&  8 ==7    
        System.out.println("z = "+z);    //5
        System.out.println("t = "+t);   //8



|与||的例子：
具有短路的效果，当左边为true，右边【不执行】，如果左边为false,右边一定会执行。因为已经决定了整个条件的结果，都为true。
    |与||的例子：
        int a = 3;
        int b = 6;
        System.out.println(++a == 3 | ++b == 6); // false
        //                   4 == 3 | 7 == 6
        System.out.println("a = "+a);  //4
        System.out.println("b = "+b);  //7


        //当左边为true，右边【不执行】，
        int x = 2;
        int y = 4;
        System.out.println(x++ == 2 || ++y == 4); // true || 不参与运算 = true
        //                   2 == 2 || 4 == 4
        System.out.println("x = "+x);  //3
        System.out.println("y = "+y);  //4

//记住
        int z =6;
        System.out.println(z++ == 6); //6==6 true
        System.out.println("x = "+z); //7


        //如果左边为false,右边一定会执行。

        int v = 2;
        int q = 3;
        System.out.println(++v ==2 || q++ ==3); //false || true = false
                        //  3 ==2  ||  3 ==3
        System.out.println("v = "+v); //3
        System.out.println("q = "+q); //4


b.    
        位运算符
         &(位与), |(位或), ^(位异或), ~(取反), >>（向右移）, >>>（有符号右移）, <<（左移）
        !(非)
        
        & : 有0则0
        | : 有1则1
        ^ : 相同为0(false)，异同为1(true)
        ~ : 按位取反

例子：
//& 有0则0
        System.out.println(6 & 3);  //2

/*
    6 & 3  因为&位与运算符直接操作的是二进制,所以将6和3的二进制求出来。    
        00000110   6
    &    00000011   3
---------------------
             010   2
*/



//| 有1则1
    System.out.println(6 | 3);

/*
    6 | 3  因为|位与运算符直接操作的是二进制,所以将6和3的二进制求出来。    
        00000110   6
    |    00000011   3
---------------------
             111   7
*/


//^ 相同为0，异同为1
    System.out.println(7 ^ 2);

/*
       00000111   7
     ^ 00000010   2
-----------------
       00000101   5

*/



//~ 按位取反 又叫单目运算符。
    System.out.println(~5); //-6

/*
        00000000 00000000 00000000 00000101  5的原码也是反码，补码
        11111111 11111111 11111111 11111010  对5取反
-1      00000000 00000000 00000000 00000001
---------------------------------------------
        11111111 11111111 11111111 11111000  反码
        10000000 00000000 00000000 00000111  原码（-6）
*/

        System.out.println(~8);  //-9
/*        00000000 00000000 00000000 00001000   8的原码也是反码，补码
        11111111 11111111 11111111 11110111   对8取反
-1      00000000 00000000 00000000 00000001   做减1操作
    -------------------------------------------------
        11111111 11111111 11111111 11110110   反码
        10000000 00000000 00000000 00001001   原码（-9）


*/
​        


c.    
    位异或运算符的特定
        一个数对另一个数位异或两次，还是该本身(单独的那个数)。


//B:面试题：
    //请自己实现两个整数变量的交换(不能定义第三方变量)
    //注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。
        
    // 三种方法
    
    // 1 使用第三方变量  开发中推荐
        int a = 10;
        int b = 12;
/*
        int temp = a;
         a = b;
         b = temp;
        System.out.println("a = "+a+", b = "+b); //a=12，b=10
*/        

/*
    // 2 不使用第三方变量  采用 总加减的方法
        a = a+b  // 22 = 10+12
        b = a-b  // 12 = 22-10 
        a = a-b; // 10  = 22-12 
    
        System.out.println("a = "+a+", b = "+b);
*/


    // 3 不使用第三方变量  采用 异或的方法
         a = a^b;   //10^12 
         b = a^b;   //10^12^12  b=10
         a = a^b;   //10^12^10  a=12
        System.out.println("a = "+a+", b = "+b);  //a=12 b=10


c.
    位运算符的基本用法2及面试题
        案例演示 >>,>>>,<<的用法:
            左移：向左移动，最高位丢弃，右边0补齐 (最终该数在原来的基础上是越来越大。) 
            右移：向右移动，看最高位（最左边），如果左边是0，就0补齐，如果左边是1，就1补齐。（最终该数在原来的基础上是越来越小。）
       无符号右移：无论最高位是0还是1，左边都是用0补齐。


例子：
//左移（正数的原反补都一样）：<< 最高位丢弃，右边用0补齐。(向左移动几位，就是乘以2的几次幂) 

        System.out.println(13<<3); //104
        //00000000 00000000 00000000 00001101    13的补码
    //000(00000 00000000 00000000 00001101000    104的补码
                                      //64+32+8=104  
        
        System.out.println(17<<4);  //272
     //00000000 00000000 00000000 000010001   17的补码
//0000(0000 00000000 00000000 0000100010000  272的补码
        //                       256+16  =272 

//右移：>> 看最高位，如果最高位是1（负数），左边有1补齐，最高位是0（正数），左边0补齐  (向左移动几位，就是乘以2的几次幂)
        System.out.println(12>>1); //6
        //00000000 00000000 00000000 000001100    12的补码
        //000000000 00000000 00000000 00000110(0  6的补码 
    
            System.out.println(11>>4);  //0
        //00000000 00000000 00000000 0001011            11的补码
        //000000000000 00000000 00000000 000)1011        0的补码        
    
        System.out.println(-12>>2);  //-3
        //10000000 00000000 00000000 0001100            -12的补码
        //1110000000 00000000 00000000 00011)00             -3的补码
    
        System.out.println(-8 >>1);  //-4
        //10000000 00000000 00000000 0001000      -8的补码    
        //110000000 00000000 00000000 000100)0    -4的补码


//无符号右移，无论最高位是0还是1，左边是用0补齐
    System.out.println(11>>>2);  //2
    //00000000 00000000 00000000 0001011        11的补码
    //0000000000 00000000 00000000 00010)11        2的补码
    
    System.out.println(12>>>3);
    //00000000 00000000 00000000 0001100        12的补码
    //00000000000 00000000 00000000 0001)100    1的补码

//最有效率的算出2 * 8的结果
    System.out.println(2<<3); //16  因为能口算出2*8的结果是16，所以根据判断是用左移，还是右移，还是无符号右移呢？
    //因为右移是将原数字的结果变的越来越小，而左移是将原数字的结果变的越来越多。所以根据8421码的规则，选择左移 因为16在8421码中8个比特位刚好有对应的数字，根据2在8421码中对应的位置（0010），所以向左移动3位就能得到16的结果（10(000）。
     //00000000 00000000 00000000 0000010
  //00000000 00000000 00000000 0000010000

    }
}


【8421码】
  0000000   0  |0    0  0  0    0000 
//       (256) |128  64 32 16   8421




d.
    三元运算符
        (关系([比较]表达式) ? 表达式1 ：表达式2;
例子：    
        int x = 3;
            int y = 5;
            int result = (x > y)? x : y;
            System.out.println(result); //5


        Boolean b = (5 == 5)? true : false;
        System.out.println(b); //true

* A:案例演示
  * 比较两个整数是否相同
* B:案例演示
  * 获取三个整数中的最大值


    //(关系([比较]表达式) ? 表达式1 ：表达式2;
        int x = 3;
        int y = 5;
        int result = (x > y)? x:y;
        System.out.println(result); //5


        Boolean n = (5 == 5)? true : false;
        System.out.println(n); //true


/*
* A:案例演示
  * 比较两个整数是否相同
* B:案例演示
  * 获取三个整数中的最大值
    */

  //比较两个整数是否相同

  Boolean result2 = (5==8)? true: false;
  System.out.println(result2);    //false

  Boolean ns = (0==1);
  System.out.println(ns); //false  
  ​    

// 获取三个整数中的最大值
    int a = 4;
    int b = 5;
    int c = 6;
    int max = (a>b)?a:b;
    int max2 = (max>c)?max:c;
    System.out.println("最大值： "+max2);


    int BigMax = (4 > 5) ? 4:5;
    int BMax = (BigMax > 7) ? BigMax : 7;
    System.out.println("最大值： "+BMax);

​    

e.
    键盘录入
        方便自己录入数据；
    如何实现？
        1） 导包：
                a. import java.util.Scanner;  //util:工具，Scanner：扫描器
                b. 在class的上面；
        2） 创建键盘录入对象；
                Scanner sc = new Scanner(System.in);
            
        3) 通过对象来获取数据；
                int t = sc.nextInt();    

例子：
1、键盘录入1个整数，并输出到控制台。
         //1、导包；
        import java.util.Scanner;
        //2、创建键盘录入对象；
        Scanner sc = new Scanner(System.in); 
        System.out.println("请输入一个数：");
        //3、录入一个数据，肯定是要将该数据放到一个数据类型中的，所以将键盘录入的数据存储到num中；
        int num = sc.nextInt(); 
        System.out.println("该数是："+num);



2、键盘录入2个整数，并输出到控制台。【该题的出现，是要告诉我们，在一个类中，如果创建了键盘录入对象，就无需创建第二次】
        //Scanner sc2 = new Scanner(System.in);
        //int num2 =  sc2.nextInt();
        System.out.println("请输入二个数：");
        //System.out.println("该数是："+num2);
        int num2 =  sc.nextInt();
        System.out.println("该数是："+num2);




3、 键盘录入练习：键盘录入两个数据，并对这两个数据求和，输出其结果
        System.out.println("请输入第一个数：");
        int a = sc.nextInt();
        System.out.println("请输入第二个数：");
        int b =sc.nextInt();
        System.out.println("这两个数据求和，输出其结果");
        int result = a+b;
        System.out.println(result);



4、键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值
        System.out.println("请输入第一个数：");
        int a2 = sc.nextInt();
        System.out.println("请输入第二个数：");
        int b2 =sc.nextInt();
        System.out.println("获取这两个数据中的最大值");
        int MaxNum = (a2>b2)?a2:b2;
        System.out.println(MaxNum);


5、键盘录入练习：键盘录入两个数据，比较这两个数据是否相等    
        System.out.println("请输入第一个数：");
        int a3 = sc.nextInt();
        System.out.println("请输入第二个数：");
        int b3 =sc.nextInt();
        System.out.println("比较这两个数据是否相等");
        Boolean n  = (a3 == b3)?true:false;
        Boolean n2 = (a3 == b3);
        System.out.println(n);
        System.out.println(n2);

6、键盘录入三个数据，获取这三个数据中的最大值
        System.out.println("请输入第1个数：");
        int a4 = sc.nextInt();
        System.out.println("请输入第2个数：");
        int b4 =sc.nextInt();
        System.out.println("请输入第3个数：");
        int c4 =sc.nextInt();
    
        int temp = (a4>b4)?a4:b4;
        int res = (temp>c4)?temp:c4;
        System.out.println("获取这三个数据中的最大值: "+res);


f.
​     
    流程控制语句
        可以控制程序的执行流程；
    流程语句结构的分类：
        顺序结构：从上到下，从左到右
        选择结构：if，switch
        循环结构：while，for


    选择结构分类：    
        if、switch
    选择结构的执行流程：
        先计算比较表达式中的值，看其返回值，如果是true还是false。
        如果是true，就执行该大括号中的语句体；
        如果是false,就不执行该大括号中的语句体；
    注意事项：
        1） 无论比较表达式的结果是简单还是复杂，结果都是Boolean类型。
        2） 当if语句中的语句体，只有一条时，可以省略大括号，但if语句中是多条时，不能省略，建议都不要省略。
        3） 有左大括号的，就没有分号，没有左大括号的，必须要有分号，有分号就表示该if语句已经结束，{}的只是一个局部代码块；


    if语句的结构：
        1）满足比较表达式，就执行该语句体中的内容。
            if(比较表达式){
    
            }
    
        2） 满足比较表达式，就执行该语句体中的内容，不满足，就执行else中的。
            if(比较表达式){
    
            }else{
    
            }
    
        3) if中不满足，就去看elseif中是否满足，满足就执行，不满足就执行else中的内容。
            if(比较表达式){
                
            }else if(比较表达式){
            
            }else {
    
            } 


    if语句与三元表达式的区别？ 开发中建议用三元运算符
        能用三元表达式表现的形式，都能if语句来表示，反之不行，因为if语句输出的是语句，而三元输出的是一个结果。
    
    p.s.
    
    if和switch区别
        if  
            1)对具体的值进行判断。
            2）对区间值判断。
            3）对运行结果是Boolean类型的表达式进行判断。
        switch
            1)对具体的值的判断。
            2）值的个数通常是固定的。
    
        对于几个固定值的判断，建议使用switch，因为switch会将具体的答案加载到内存，效率更高。


​    
例子：
//if语句的格式2和三元的相互转换问题
    int a1 =3;
    int b1 =5;
    int i = (a1>b1)? a1:b1;
    System.out.println(i+"是最大值");


//案例演示
     需求：获取三个数据中的最大值
     if语句的嵌套使用。
    
    int a = 2;
    int b = 70;
    int c = 5;
    
    if(a>b){ //2>70
        if(a>c){ //2>5
            System.out.println("最大值是："+a);
        }else{  //5
            System.out.println("最大值是?："+c);
        }
    }else{ 
            if(b>c){ //70>5
                System.out.println("最大值是："+b);
            }else{  //70
                System.out.println("最大值是!："+c);
            }
        }



g.
    switch语句
        格式：
            switch(表达式){ //该表达式的范围是：基本数据类型：byte,short,char int,引用数据类型：String，枚举；
                case 值1:
                    语句体1;
                break;
                case 值2:
                    语句体2;
                break;
                case 值n+1:
                    语句体n+1;
                break;
                default:
                    default的语句体;
                break;
            }
    
        问题：
            byte能作为switch的表达式吗？能，byte,short,char，int都可以，long不行，因为long比int的取值范围要大，会损失精度。
            String能作为switch的表达式吗？    能，jdk1.7后是String, 1.5后是枚举。
        执行流程：
            1） 先计算表达式中的值，
            2） 与case的值进行匹配，如果有就执行，如果都没有，就执行default中的语句体。
        注意事项：
            1） case后面只能是常量吗？是，不能是变量，而且多个case不能出现重复的值；
            2） break能省略吗? 最后一个能省略，否则会出现case穿透，建议都不要省略。
            3） default能省略吗？可以，但建议不要省略，因为能在对case不满足条件的情况下，给出提示；
            4） default只能放在后面吗？不一定，可以放在case的前面，但是执行顺序还是case不满足条件时，才去执行default里的，然后再顺序执行下去。
            5） switch的结束语句？
                两种情况：
                    1）遇到break结束。
                    2）遇到右大括号结束。


看程序写结果：
1.   
      int x = 2;
          int y = 3;
          switch(x){
              default:
                  y++;   // case的结果都不满足，所以走default 3+1
                  break;
              case 3:
                  y++;  // 因为case==3,不满足条件，不走，但是没有break,出现case穿透，继续往下走。
              case 4: 
                  y++;  // 因为case==4,不满足条件，不走，但是没有break,出现case穿透，继续往下走。
          }
          System.out.println("y="+y);  // 4


2.
        int x = 2;
        int y = 3;
        switch(x){ 
            default:
                y++;  // 3）case都不满足条件，只能走这，3+1， 4）因为defualt没有break，所以继续走    
            case 3:          
                y++;  // 1）case==3，不满足条件，不走、       5）4+1 只+1，不计算
            case 4:
                y++;  // 2）case==4，不满足条件，不走、          6）5+1 只+1，不计算
        }              // 7) 遇到右大括号，结束流程。 最终是6
        System.out.println("y="+y);   //6



h.
    选择结构if语句和switch语句的区别?
        1） switch建议判断固定值的时候使用，即常量。
        2） if建议判断区间值、范围值的时候使用，即变量。
        3） 能用switch做的，都能用if来做，而if能做的，不一定都能用switch来做，因为if可以用Boolean值且数字范围值太大。

分别用switch和if来做案例：
     键盘录入月份，输出对应的季节