表达式&运算符&位运算

表达式

概念：

• 由常量、变量、运算符、（）组成一句代码。
• 代码最终有一个结果。

// 定义： 由常量、变量、运算符、（）组成。由一个结果
        // 规律1： 当表达式中所有的变量类型小于等于int( int short byte char )的时候，运算后的结果都会自动提升为int类型。
        byte a = 10;
        short b = 20;
        int c = 30;
        int result = a + b + c;
        int result1 = 3 / 2; // 1

        // 当表达式中有变量类型大于等于int(float double)的时候，运算后的结果以表达式中精度最高的为主。
        // int + float = float    int + double = double   float + float = float
        float result2 = 3 / 2.0f;

运算符

算术运算符

符号	说明
+	加法
-	减法
*	乘法
/	除法。 整数相除得整数，小数相除得小数（double）
%	模,取余数部分（除二取余）

当然，运算符中也会有优先级：
乘除取余 > 加减
我们也可用（）去改变优先级。
+不止可以用于算术运算：

• 数字运算
• 字符串拼接： 一定要有字符得参与

自增&自减

格式：
变量++ -> 后自加 i++
++变量 -> 前自加 ++i
变量-- -> 后自减 i–
–变量 -> 前自减 --i
自增和自减都只变化1

单独使用

int i = 10;
        /*
        * 1.单独使用，自成一句；
        * */
        i++; // i自增了1   你可以理解为：i = i + 1
        System.out.println(i); // 11
        i--;
        System.out.println(i); // 10
        ++i;
        System.out.println(i); // 11
        --i;
        System.out.println(i); // 10

单独使用得情况下，前后位置没啥区别。反正经过了那句代码之后，变量变化1

复合使用（略微难）

输出的情况：
后自加：先输出，后自加

 int i = 10;

        /*2. 复合使用： 输出语句中， 赋值语句（参与计算）*/
        // 先使用，再变化
        System.out.println(i++); // 输出10
        System.out.println(i); // 11
        
        // 先变化，再输出
        System.out.println(++i); // 12
        System.out.println(i); // 12

赋值的情况：

        int i = 10;

        // 先赋值， 后变化
        int j = i++;
        System.out.println(j); // 10
        System.out.println(i); // 11 

先赋值，然后再变化。相当于把变化之前的值给到j

int i = 10;

        // 先变化，后赋值
        int j = ++i;
        System.out.println(j); // 11
        System.out.println(i); // 11

先变化，再赋值。相当于把变化后的值给到j

int i = 10;

        // 先用i，然后变化
        int j =i++ + 1;
        System.out.println(j); // 11
        System.out.println(i); // 11



int i = 10;

        // 先用i，然后变化
        int j =++i + 1;
        System.out.println(j); // 12
        System.out.println(i); // 11


 int i = 10;

        // 先用i，然后变化
        int j =++i + ++i; // 23
        // int j = i++ + i++; // 21
        // int j = i++ + ++i;
        // int j = ++i + --i;
        // int j = ++i + --i;
        System.out.println(j); // 23
        System.out.println(i); //

i++与i = i + 1的区别

• i++ java帮你自动强转
• i = i + 1 有时需要你自动强转

byte i = 1;
i = (byte)(i + 1);

i++和++i的区别

y = i++；
// 则有
y = i;
i = i + 1;

y = i--;
// 则有
i = i + 1;
y = i;

两者的区别是：前者是先赋值，然后再自增；后者是先自增，后赋值。
当然还有一些区别，后面提。

赋值运算符

基本的赋值运算符：
=
复合运算符：

• +=
• -=
• *=
• /=
• %=

// 1. 基本赋值运算符
        int a = 10;
        // 2. 复合赋值运算符： +=
        a%=5;
        System.out.println(a);

那么设计到了一个问题，a = a +5我们可以写成a+=5，会有什么问题呢？

• a+=5java会自动帮你强转（精度丢失、数据溢出）
• a = a + 5需要你手动强转

byte a = 10;
a = (byte)(a + 1);

比较运算符（关系运算符）

作用：

• 条件判断的时候需要

种类：

符号	说明
==	如果符号前后相等为true;否则为false
>	如果符号前的数据大于符号后的数据为true,否则为false
<	如果符号前的数据小于符号后的数据为true,否则为false
>=	如果符号前的数据大于或者等于符号后的数据为true,否则为false
<=	如果符号前的数据小于或者等于符号后的数据为true,否则为false
!=	如果符号前后不相等为true;否则为false

int a = 65;
int b = 12;
char c = 'A';

boolean res1 = a > b;
System.out.println(res1);
System.out.println(a <= b);
// 现在，尽量同类型比。
// 原理： c字符转成ascii码,然后进行比较
System.out.println(a == c);
System.out.println(a == b);
System.out.println(a != b);

三目运算符（元运算符）

语法：关系表达式 ? true对应的结果 : false对应的结果
例子：

10 > 9 ? 'A' : 'B'；
10 < 5 ? 10 : 'A' ；

逻辑运算符

基本使用

符号	说明
&&(与,并且)	有假则假,符号前后有一个结果为false,整体就是false
||(或者)	有真则真,符号前后有一个结果为true,整体就是true
!(非,取反)	不是true,就是false;不是false,就是true
^(异或)	符号前后结果一样为false;
不一样为true
true^true -> false
true^false -> true
false^true -> true
false^false -> false

优先级： ! > &&(&) > ||(|)
&&与&、||与|的区别

符号	说明
&	1.单与,如果前后都是布尔型,有假则假,但是如果符号前为false,符号后的判断会继续执行 2.如果该符号前后都是数字,看做是位运算符
&&	1.双与,有假则假,但是有短路效果,如果符号前为false,符号后的判断就不会执行了
|	1.单或,如果前后都是布尔型,有真则真,但是如果符号前为true,符号后的判断会继续执行 2.如果该符号前后都是数字,看做是位运算符
||	1.双或,有真则真,但是有短路效果,如果符号前为true,符号后的判断就不会执行了

位运算

开发基本不用

• 符号的介绍:
  • &(与) -> 有假则假
  • |(或) -> 有真则真
  • ~(非) -> 取反
  • ^(异或) -> 符号前后结果一样为false,不一样为true

    •  true ^ true -> false
      

    •  false ^ false -> false
      

    •  true ^ false -> true
      

    •  false ^ true -> true
      

• 1代表true 0代表false
• 计算机在存储数据的时候都是存储的数据的补码,计算也是用的数据的补码，但是我们最终看到的结果是原码换算出来的

原码 反码 补码

• 正数二进制最高位为0; 负数二进制最高位为1

• 如果是正数 原码 反码 补码 一致

    比如:5的原码  反码  补码一致:
  0000 0000 0000 0000 0000 0000 0000 0101 -> 因为是正数,二进制最高位为0
     如果是负数,原码 反码 补码不一样了
     反码是原码的基础上最高位不变,剩下的0和1互换
     补码是在反码的基础上+1
  

  比如:-9
  原码: 1000 0000 0000 0000 0000 0000 0000 1001
  反码: 1111 1111 1111 1111 1111 1111 1111 0110
  补码: 1111 1111 1111 1111 1111 1111 1111 0111
  左右移动：
  <<（左移），>>（右移）
  皆属于位运算符.其运算比乘除快
  <<表示左移，不分正负数，低位补0
  规则则是带符号位移，高位移出，低位补0。

表示右移，如果该数为正，则高位补0，若为负数，则高位补1；

表示无符号右移，也叫逻辑右移，即若该数为正，则高位补0，而若该数为负数，则右移后高位同样补0