Day03（赋值、运算）

一、赋值运算

1、short s=1,s=s+1;

short s=1,s+=1;

上面两个代码有没有问题，如果有，哪里有问题？

答：第一个有问题，因为变量参与运算，首先会提升数据类型，然后做运算。所以s=s+1;s会提升到int型然后再做加法运算，最终的结果是int类型，所以拿short类型接收会报错，所以要想成功赋值就得强制类型转换。

第二个代码没有问题，是因为内部自动包含了强制类型转换，s+=1=======> s=(s的数据类型)(s+1)

public class OptFuZhiDemo2{

    public static vodi main(String[] args){

    // short s = 1;

    // s=(short)(s + 1);

    short s = 1;

    s+=1;

        System.out.println(s);

     }

}

二、关系运算符

关系运算符：==,!=,>,<,>=,<=

注意事项：

1、关系运算符的表达式结果是一个boolean类型，要么是true，要么是false

2、==不能少写，一个等号是赋值运算符，==才是关系运算符

3、赋值的时候要注意类型问题，关系运算符表达式的结果是boolean类型，所以接收的时候只能是boolaen类型的变量接收。

  public class OptGuanXiDemo1{

       public static void main(String[] args){

             int a = 3;

             int b = 9;

             boolean flag=(a==b);

             // int flag2=(a==b);

                   System.out.println(flag);

              //     !=

                   System.out.println(a!=b);

             //     >

                   System.out.println(a>b);

             //  <

                  System.out.println(a<b);

             //   >=

                  System.out.println(a>=b);

            //  <=

                  System.out.println(a<=b);

                   Sysem.out.println(a==b);

                  System.out.println(a=b);

    }

}

三、逻辑运算符：&,|,^,!&&,||

      逻辑运算符两边放的是boolean类型的值，计算的结果也是一个boolean类型的值

      &：参与运算的时候，两边有false，则false两边都做运算，有false则false

      |：参与运算的时候，两边有true，则true两边都做运算，有true则true

      ^:参与运算的时候，相同为false，不同为true，两边都做运算，相同false不同true

      ！:将true变成false，false变成true

       public class OptLogicDemo1{

            public static void main(String[] args){

//                 int a = 3;

//                 int b = 4;

//                 System.out.println(a&b);

                   int a = 3;

                   int b = 4;

1、&（按位与）

//      System.out.println((a++==3)&(b++==4));//左边true，右边也是true，结果是true，两边都做运算

//      System.out.println("a:"+a+",b:"+b);

//      System.out.println((a++==4)&(b++==4));//左边是false，右边是true，结果是false，两边都做运算

//      System.out.println("a:"+a+",b:"+b);

//      System.out.println((a++==3)&(b++==5));//左边是true，右边是false，结果是false，两边都做运算

//      System.out.println("a:"+a+",b:"+b);

//      System.out.println((a++==4)&(b++==5));//左边是false，右边是false，结果也是false，两边都做运算

//       System.out.println("a:"+a+"b:"+b);

2、  |（按位或）

//   System.out.println((a++==3)|(b++==4));//左边是true，右边也是true，结果是true，两边都做运算

//   System.out.println("a:"+a+",b:"+b);

//   System.out.println((a++==4)|(b++==4));左边是false，右边是true，结果是true，两边都做运算

//   System.out.println("a:"+a+",b:"+b);

//   System.out.println((a++==3)|(b++==5));//左边是true，右边是false，结果是true，两边都做运算

//   System.out.println("a"+a+",b:"+b);

//   System.out.println((a++==4)|(b++==5));//左边是false，右边也是false，结果是false，两边都做运算

//   System.out.println("a:"+a+",b:"+b);

3、  ^（按位异或）

//   System.out.println((a++==3)^(b++==4));//左边是true，右边也是true，结果是false，两边都做运算

//   System.out.println("a:"+a+",b:"+b);

//   System.out.println((a++==4)^(b++==4));//左边是false，右边是true，结果是true，两边都做运算

//   System.out.println("a:"+a+",b:"+b);

//   System.out.println((a++==3)^(b++==5));//左边是true，右边是false，结果是true，两边都做运算

//   System.out.println("a:"+a+",b:"+b);

//   System.out.println((a++==4)^(b++==5));//左边是false，右边是false，结果是false，两边都做运算

//   System.out.println("a:" +a+",b:"+b);

4  !（非）

//   System.out.println(!((a++==4)^(b++==5)));

    }

}

5、&&（短路与）：结果和单个结果一样，有false则false，但是执行的东西不一样，当&&左边的表达式结果为false的时候，结果为false，右边不执行

6、||（短路或）：结果和单个结果一样，有true则true，但是执行的东西不一样，当||左边是true的时候，右边不执行，结果是true

7、逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6,应该写成x>3&x<6

     a = 3;

     b = 4;

// &&（短路与）

//   System.out.println((a++==3)&&(b++==4));//左边true，右边也是true，结果是true，两边都做运算

//   System.out.println("a:"+a+",b:"+b);

//   System.out.println((a++==4)&&(b++==4));//左边是false，右边是true，结果是false，两边都做运算

//   System.out.println("a:"+a+",b:"+b);

//   System.out.println((a++==3)&&(b++==5)));//左边是true，右边是false，结果是false，两边都做运算

//   System.out.println("a:"+a+",b:"+b);

//   Sysetem.out.printf((a++==4)&&(b++==5));//左边是false，右边也是false，结果是false，两边都做运算

//   System.out.println("a:"+a+",b+"+b);

=======================================================================

   a=3;

   b=4;

//  ||（短路或）

//   System.out.println((a++==3)||(b++==4));//左边true，右边true，结果是true，两边都做运算

//   System.out.println("a:"+a+",b:"+b);//a:4,b:4

//   System.out.println((a++==4)||(b++==4);//左边是false，右边是true，结果是false，两边都做运算

//   System.out.println("a:"+a+",b+"+b);//a:4,b:5

//    System.out.println((a++==3)||(b++==5));//左边是true，右边是false，结果是false，两边都做运算

//    System.out.println("a:"+a+",b:"+b);//a:4,b:4

//   System.out.println((a++=4)||(b++==5);//左边是false，右边是false，结果为false，两边都做运算

//   System.out.println("a:"+a+",b:"+b));//a:4,b5

//   java 不支持连续比较

//   System.out.println(20>a>10);

     System.out.println((a<20 & a>10));

    }

}

四、三目运算符：又称之为三元运算符

       格式：(关系表达式)?表达式1:表达式2；

      如果关系表达式的结果为true，运算后的结果是表达式1；

      如果关系表达式的结果是false，运算后的结果是表达式1；

注意事项：

     1、三目运算符表达式的结果数据类型由三目运算符表达式1和表达式2中最大的数据类型决定的

     2、关系表达式一定只能是boolean类型

public class OptSanMuDemo1{

     public static void main(String[] args){

      //求出a,b中的最大值

      int a = 10;

      int b = 30;

      //三目运算符解决

      int c = (a>b)?a:b;

      //  面试题：

      int a = 20;

      double b = 30.0;

      (a>b)?a:b int a1 = 20;

      double b1 = 30.0;

      double c1 = (a1>b1)?a:b;

      System.out.println(c1);

    }

}

 五、位运算符:<<,>>,>>>,&,|,^,~

        public class OptWeiDemo1{

              public static void main(String[] args){

                 byte a = 3;

                 byte b = 4;

                 System.out.println(a&b);

                 System.out.println(a|b);

                 System.out.println(a^b);

                 System.out.println(~a);//-4

                 }

           }

      由于数据在计算机中参与运算都是补码，而想要知道补码，就得知道反码，原码，就得求出二进制

      3的二进制：00000011

      4的二进制：00000100

       又由于3和4都是正数

      3的补码：00000011

      4的补码：00000100

        & 运算：有0则0

            00000011

          &

            00000100

------------------------------------

            00000000

      结果是：0

==========================================================

      | 运算：有1则1

        00000011

     |

        00000100

------------------------------

         00000111

      结果为：7

        ^  运算：相同则0，不同则1

            00000011

         ^   

            00000100 

-------------------------------------

            00000111

       结果为：7

===============================================================

    ~运算：1变成0，0变成1

       00000011

   ~ 

  -------------------------------------------

       补码：           11111100

        已知补码求原码：

       反码：11111011

       原码：10000100

       结果为：-4

       位运算符：

<<：左移，二进制左移，右边用0补齐，多出来的丢弃。

>>:右移，最左边最高位是0用0补齐，最高位是1就用1补齐，多出来的丢弃。

>>>：无符号右移，无论左边最高是0还是1，都用0补齐，多出来的丢弃。

public class OptWeiDemo2{

    public static void main(String[] args){

         System.out.println(3<<2);//12=3*4=3*2^2

         System.out.println(24>>2);//6=24/(2*2)

         System.out.println(-24>>2);//-6

         System.out.println(-24>>>2);//1073741818

         System.out.println(3<<3);//3*2^3

// 请用最有效率的方式写出计算机2乘以8的结果

//        System.out.println(2*8);

          System.out.println(2<<3);

     }

}

<<:左移，二进制左移，右边用0补齐

3的进制：00000000 00000000 00000000 00000011

由于3是正数，所以原码，反码，补码都一样

3的补码：00000000 00000000 00000000 00000011

左移：

          00000000 00000000 00000000 00000011

     (00)000000 00000000 00000000 0000001100     (补码)

   由于最高位是0，既是补码也是原码，所以结果：12

==================================================================

   >>:右移，最左边最高位是0用0补齐，最高位是1就用1补齐，多出来的丢弃。

   24的二进制：00000000 00000000 00000000 00011000

   由于24是正数，所以原码，反码，补码都一样

   24的补码：00000000 00000000 00000000 00011000

   右移：

           00000000 00000000 00000000 00011000

           0000000000 00000000 00000000 000110(00)     (补码)

    由于最高位是0，既是补码也是原码，所以结果是：6

=====================================================================

>>：右移，最左边最高位是0就用0补齐，最高位是1就用1补齐，多出来的丢弃。

-24的二进制：10000000 00000000 00000000 00011000

已知原码求补码：

    原码：10000000 00000000 00000000 00011000

    反码：11111111 11111111 11111111 11100111

    补码：11111111 11111111 11111111 11101000

右移：

       11111111 11111111 11111111 11101000

       1111111111 11111111 11111111 111010(00)             (补码)

已知补码求原码：

     补码：11111111 11111111 11111111 11111010

     反码：11111111 11111111 11111111 11111001

     原码：00000000 00000000 00000000 00000110

   最终结果是：-6

======================================================================

>>>：无符号右移，无论左边最高是0还是1，都用0补齐，多出来的丢弃。

     -24的二进制：10000000 00000000 00000000 00011000

已知原码求补码：

      原码：10000000 00000000 00000000 00011000

      反码：11111111 11111111 11111111 11100111

      补码：11111111 11111111 11111111 11101000

无符号右移2位：

     11111111 11111111 11111111 11101000

     0011111111 11111111 11111111 111010(00)              (补码)

由于最高位是0，所以它的原码，反码，补码都一样

最终结果为：00111111 11111111 11111111 11111010 =1073741818

快捷键：1、生成main方法的快捷键 psvm

              2、换行输出快捷键 sout

              3、多行复制 ctrl + alt + 下键