第一章：概述
第二章：算术运算符
2.4 数值拆分（应用）
2.5 自增自减运算
第三章：赋值运算符
- 3.1 概述
- 3.2 应用示例
第四章：关系运算符（比较运算符）
- 4.1 概述
- 4.2 应用示例
第五章：逻辑运算符
第六章：条件运算符（三元运算符）
- 6.1 概述
- 6.2 应用示例
第七章：位运算（了解）
- 7.1 概述
- 7.2 概述
第八章：运算符的优先级（了解）

第一章：概述

运算符：对常量或者变量进行操作的符号
表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。
```
              不同运算符连接的表达式体现的是不同类型的表达式。
```
运算符的分类：
- 按照功能分为：算术运算符、赋值运算符、比较运算符、逻辑运算符、条件运算符……

分类	运算符
算术运算符	`+`、`-`、`*`、`/`、`%`、`++`、`--`
赋值运算符	`=`、`+=`、`-=`、`*=`、`/=`、`%=`等
关系运算符	`>`、`>=`、`<`、`<=`、`==`、`!=`
逻辑运算符	`&`、`\|`、`^`、`!`、`&&`、`\|\|`
条件运算符	`(条件表达式)?结果1:结果2；`
位运算符（了解）	`&`、`\|`、`~`、`^`、`<<`、`>>`、`>>>`

按照操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符（三目运算符）
- 一元运算符：操作数只有一个
  - 例如：
    - 正号（+）：+a
    - 负号（-）：-a
    - 自增（++）：++i
    - 逻辑非：!true
- 二元运算符：操作数有两个
  - 例如：
    - 加法：a + b
    - 大于：a > b
    - 逻辑与：a && b
- 三元运算符：条件 ? 结果1 ：结果2。
  第二章：算术运算符
  2.1 概述
  | 算术运算符 | 符号解释 | | —- | —- | | + | 加法运算，字符串连接运算，正号 | | - | 减法运算，负号 | | * | 乘法运算 | | / | 除法运算，整数/整数结果还是整数 | | % | 求余运算，余数的符号只看被除数 | | ++ 、-- | 自增自减运算 |

2.2 应用示例

public class ArithmeticOperator {
    public static void main(String[] args) {
        // 正号：+
        int operator01 = +5;
        System.out.println("operator01 = " + operator01); // 5

        // 负号：-
        int operator02 = -5;
        System.out.println("operator02 = " + operator02); // -5

        // 负负得正
        int operator03 = -3;
        System.out.println("operator03 = " + -operator03); // 3

        // 加法: +
        int operatorAdd01 = 1;
        int operatorAdd02 = 2;

        int addResult = operatorAdd01 + operatorAdd02;
        System.out.println("addResult = " + addResult);// 3

        double operatorAdd03 = 10.2;
        double operatorAdd04 = 3.8;

        double addResultDouble = operatorAdd03 + operatorAdd04;
        System.out.println("addResultDouble = " + addResultDouble); // 14.0

        // 减法：-
        int operatorMinus01 = 1;
        int operatorMinus02 = 2;

        int minusResult = operatorMinus01 - operatorMinus02;
        System.out.println("minusResult = " + minusResult); // -1

        // 乘法：*
        int operatorMulti01 = 1;
        int operatorMulti02 = 2;

        int multiResult = operatorMulti01 * operatorMulti02;
        System.out.println("multiResult = " + multiResult); // 2

        // 除法：/ ，注意：除数不能为0
        int operatorDivision01 = 6;
        int operatorDivision02 = 3;

        int divisionResult = operatorDivision01 / operatorDivision02;
        System.out.println("divisionResult = " + divisionResult); // 2

        int operatorDivision03 = 6;
        int operatorDivision04 = 4;

        int divisionResult2 = operatorDivision03 / operatorDivision04;
        System.out.println("divisionResult2 = " + divisionResult2); // 1

        // 取模：%
        int mod = operatorDivision03 % operatorDivision04;
        System.out.println("mod = " + mod); // 2

    }
}

注意：
1. /和%的区别：两个数据做除法，`/取结果的商，%取结果的余数。
2. 整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

2.3 `+` 号的三种用法

①对于 + 号两边都是数值的情况，+ 就是加法的意思。
② 对于 + 号有 Char类型参与运算
②对于 + 号两边至少一边是字符串的情况，+ 就是拼接的意思。

2.3.1 字符的“+”操作（理解）

char类型参与算术运算，使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值：
‘a’ — 97 a-z是连续的，所以’b’对应的数值是98，’c’是99，依次递加
‘A’ — 65 A-Z是连续的，所以’B’对应的数值是66，’C’是67，依次递加
‘0’ — 48 0-9是连续的，所以’1’对应的数值是49，’2’是50，依次递加

// 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少
// 此处的 + 号也是加法的意思
char ch1 = 'a';
System.out.println(ch1 + 1); // 输出98，97 + 1 = 98

char ch2 = 'A';
System.out.println(ch2 + 1); // 输出66，65 + 1 = 66

char ch3 = '0';
System.out.println(ch3 + 1); // 输出49，48 + 1 = 49

算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。提升规则： byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型等级顺序：byte,short,char —> int —> long —> float —> double

示例：

byte b1 = 10;
byte b2 = 20;
// byte b3 = b1 + b2; // 该行报错，因为byte类型参与算术运算会自动提示为int，int赋值给byte可能损失精度
int i3 = b1 + b2; // 应该使用int接收
byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型
-------------------------------
int num1 = 10;
double num2 = 20.0;
double num3 = num1 + num2; // 使用double接收，因为num1会自动提升为double类型

2.3.2 字符串的“+”操作（理解）

当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。

System.out.println("lhl"+ 666); // 输出：lhl666

在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。

System.out.println(1 + 99 + "年");            // 输出：100年
System.out.println(1 + 2 + "lhl" + 3 + 4);   // 输出：3lhl34
// 可以使用小括号改变运算的优先级 
System.out.println(1 + 2 + "lhl" + (3 + 4)); // 输出：3lhl7

2.4 数值拆分（应用）

需求：
键盘录入一个三位数，将其拆分为个位，十位，百位，分别打印在控制台

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        // 1：使用Scanner键盘录入一个三位数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个三位数");
        int num = sc.nextInt();
        // 2：个位的计算：数值 % 10
        int ge = num % 10;        
        // 3：十位的计算：数值 / 10 % 10
        int shi = num / 10 % 10;    
        // 4：百位的计算：数值 / 100
        int bai = num / 100;
        // 5：将个位, 十位, 百位拼接上正确的字符串, 打印即可
        System.out.println("整数"+num+"个位为:" + ge);
        System.out.println("整数"+num+"十位为:" + shi);
        System.out.println("整数"+num+"百位为:" + bai);

    }
}

2.5 自增自减运算

2.5.1 概述

符号	作用	说明
++	自增	变量的值加1
—	自减	变量的值减1

++ 运算，变量自身 +1 ；反之，-- 运算，变量自身 -1 。

2.5.2 单独使用

变量在单独运算的使用，变量 前++ 和变量 后++ ，变量的值是一样的。
变量 前++ ：例如 ++a 。

变量 后++ ：例如 a++ 。

public class IncreaseAndDecrease {
 public static void main(String[] args) {
     int a = 3;
     a++;
     System.out.println("a = " + a); // a = 4

     int b = 3;
     ++b;
     System.out.println("b = " + b); // b = 4
 }
}

2.5.3 复合使用

和 其他变量放在一起使用 或者和 输出语句在一起使用 ，前++ 和 后++ 就产生了不同。
变量 前++ ：变量先自身加 1 ，然后再取值。
变量 后++ ：变量先取值，然后再自身加 1 。
总结：注意变量参与运算前，运算时，运算后的值
- ++在前，先自增，后使用。
- ++在后，先使用，后自增。

int x = 10;
int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
System.out.println("x:" + x + ", y:" + y); // x:11，y:10

int m = 10;
int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
System.out.println("m:" + m + ", m:" + m); // m:11，m:11

练习：

int x = 10;
int y = x++ + x++ + x++;
System.out.println(y); // y的值是多少？
/*
解析，三个表达式都是++在后，所以每次使用的都是自增前的值，但程序自左至右执行，所以第一次自增时，使用的是10进行计算，但第二次自增时，x的值已经自增到11了，所以第二次使用的是11，然后再次自增。。。
所以整个式子应该是：int y = 10 + 11 + 12;
输出结果为33。
*/
注意：通过此练习深刻理解自增和自减的规律，但实际开发中强烈建议不要写这样的代码！小心挨打！

第三章：赋值运算符

3.1 概述

赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。

符号	作用	说明
=	赋值	a=10，将10赋值给变量a
+=	加后赋值	a+=b，将a+b的值给a
-=	减后赋值	a-=b，将a-b的值给a
*=	乘后赋值	a*=b，将a×b的值给a
/=	除后赋值	a/=b，将a÷b的商给a
%=	取余后赋值	a%=b，将a÷b的余数给a

注意：扩展的赋值运算符隐含了强制类型转换。

short s = 10;
s = s + 10; // 此行代码报出，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度

s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);

3.2 应用示例

public class AssignmentOperator {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        a = a + b;
        System.out.println("a = " + a); // 7
        System.out.println("b = " + b); // 4
    }
}

/**
 * 扩展赋值运算符
 */
public class AssignmentOperator2 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        b += a; // 相当于 b = b + a;
        System.out.println("a = " + a); // a = 3
        System.out.println("b = " + b); // b = 7

        short s = 3;
        // s = s + 4; 代码编译错误，因为将int类型的结果赋值给short类型的变量s，可能损失精度
        s += 4; // 代码没有报错，因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型转换成short
        System.out.println("s = " + s); // s = 7

        int j = 1;
        j += ++j * j++; // 相当于  j = j + (++j * j++);
        System.out.println(j); // 5
    }
}

第四章：关系运算符（比较运算符）

4.1 概述

关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于。

符号	说明
==	a==b，判断a和b的值是否相等，成立为true，不成立为false
!=	a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>	a>b，判断a是否大于b，成立为true，不成立为false
>=	a>=b，判断a是否大于等于b，成立为true，不成立为false
<	a<b，判断a是否小于b，成立为true，不成立为false
<=	a<=b，判断a是否小于等于b，成立为true，不成立为false

注意事项：

关系运算符的结果都是boolean类型，要么是true，要么是false。
千万不要把==误写成“=”，这个是判断是否相等的关系，”=”是赋值。
> 、< 、>= 、<= 不支持 boolean 和 String 类型。
== 和 != 支持 boolean 和 String 类型。

4.2 应用示例

int a = 10;
int b = 20;
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a > b); // false
System.out.println(a >= b); // false
System.out.println(a < b); // true
System.out.println(a <= b); // true

// 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
boolean flag = a > b;
System.out.println(flag); // 输出false

第五章：逻辑运算符

5.1 概述

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。

符号	作用	说明
&	逻辑与	a&b，a和b都是true，结果为true，否则为false
\|	逻辑或	a\|b，a和b都是false，结果为false，否则为true
^	逻辑异或	a^b，a和b结果不同为true，相同为false
!	逻辑非	!a，结果和a的结果正好相反
&&	短路与	作用和&相同，但是有短路效果
\|\|	短路或	作用和\|相同，但是有短路效果

5.2 应用示例

//定义变量
int i = 10;
int j = 20;
int k = 30;

//& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
System.out.println((i > j) & (i > k)); //false & false,输出false
System.out.println((i < j) & (i > k)); //true & false,输出false
System.out.println((i > j) & (i < k)); //false & true,输出false
System.out.println((i < j) & (i < k)); //true & true,输出true
System.out.println("--------");

//| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
System.out.println((i > j) | (i > k)); //false | false,输出false
System.out.println((i < j) | (i > k)); //true | false,输出true
System.out.println((i > j) | (i < k)); //false | true,输出true
System.out.println((i < j) | (i < k)); //true | true,输出true
System.out.println("--------");

//^ “异或”，相同为false，不同为true
System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
System.out.println("--------");

//! “非”，取反
System.out.println((i > j)); //false
System.out.println(!(i > j)); //!false，,输出true

5.3 短路逻辑运算符

短路原理：
在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。

逻辑与&，无论左边真假，右边都要执行。
短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
逻辑或|，无论左边真假，右边都要执行。
短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。

应用示例：

int x = 3;
int y = 4;
System.out.println((x++ > 4) & (y++ > 5)); // 两个表达都会运算
System.out.println(x); // 4
System.out.println(y); // 5

System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false，右边不参与运算
System.out.println(x); // 4
System.out.println(y); // 4

第六章：条件运算符（三元运算符）

6.1 概述

语法：
```
关系表达式 ? 表达式1 : 表达式2;
```
问号前面的位置是判断的条件，判断结果为boolean型，
条件表达式的结果是 true ，条件运算符整体结果为结果 1 ，赋值给变量。

条件表达式的结果是 false ，条件运算符整体结果为结果 2 ，赋值给变量。

/**
* 三元运算符
*/
public class ConditionOperator {
  public static void main(String[] args) {
      int i = (1 == 2) ? 100 : 200;
      System.out.println("i = " + i); // i = 200

      int j = (3 <= 4) ? 500 : 600;
      System.out.println("j = " + j); // j = 500
  }
}

6.2 应用示例

需求1：3个数比较大小

public class OperatorTest01 {
  public static void main(String[] args) {
          int a = 10;
          int b = 15;
          int c = 22;
          int n = a>b? a : b; //找出a和b最大值。
          int m = n>c? n : c;//用n和c比较。
          System.out.println(m);//最后m保持了最大值。
          //也可以写成一句代码。
          //int m = a>b? (a>c?a:c):(b>c?b:c);
  }
}

需求2：
一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高。

public class OperatorTest02 {
  public static void main(String[] args) {
      //1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
      int height1 = 150;
      int height2 = 210;
      int height3 = 165;    
      //2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
      int tempHeight = height1 > height2 ? height1 : height2;        
      //3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
      int maxHeight = tempHeight > height3 ? tempHeight : height3;    
      //4：输出结果
      System.out.println("maxHeight:" + maxHeight);
  }
}

第七章：位运算（了解）

7.1 概述

Java提供的位运算符有：左移( << )、右移( >> ) 、无符号右移( >>> ) 、位与( & ) 、位或( | )、位非( ~ )、位异或( ^ )，除了位非( ~ )是一元操作符外，其它的都是二元操作符。

7.2 概述

1、左移( << )
将5左移2位：

public class Test {
    public static void main(String[] args) {
    System.out.println(5<<2);//运行结果是20
    }
}

运行结果是20，但是程序是怎样执行的呢？
首先会将5转为2进制表示形式 (java中，整数默认就是int类型,也就是32位):
0000 0000 0000 0000 0000 0000 0000 0101 然后左移2位后，低位补0：
0000 0000 0000 0000 0000 0000 0001 0100 换算成10进制为20

2、右移( >> )
右移同理，只是方向不一样罢了

System.out.println(5>>2);//运行结果是1

还是先将5转为2进制表示形式：
0000 0000 0000 0000 0000 0000 0000 0101 然后右移2位，高位补0：
0000 0000 0000 0000 0000 0000 0000 0001

3、无符号右移( >>> )
我们知道在Java中int类型占32位，可以表示一个正数，也可以表示一个负数。正数换算成二进制后的最高位为0，负数的二进制最高为为1（正0负1）
例如 -5换算成二进制后为：
1111 1111 1111 1111 1111 1111 1111 1011

public class Test {
    public static void main(String[] args) {
    System.out.println(5>>3);//结果是0
    System.out.println(-5>>3);//结果是-1
    System.out.println(-5>>>3);//结果是536870911
    }
}

4、位与( & )
参加运算的两个数据，按二进制位进行“与”运算。
运算规则：0&0=0; 0&1=0; 1&0=0; 1&1=1;
即：两位同时为“1”，结果才为“1”，否则为0

public class Test {
    public static void main(String[] args) {
    System.out.println(5 & 3);//结果为1
    }
}

还是老套路，将2个操作数和结果都转换为二进制进行比较：
5转换为二进制：0000 0000 0000 0000 0000 0000 0000 0101
3转换为二进制：0000 0000 0000 0000 0000 0000 0000 0011

1转换为二进制：0000 0000 0000 0000 0000 0000 0000 0001

位与：第一个操作数的的第n位于第二个操作数的第n位如果都是1，那么结果的第n为也为1，否则为0

5、位或( | )

参加运算的两个对象，按二进制位进行“或”运算。
运算规则：0|0=0； 0|1=1； 1|0=1； 1|1=1；
即：参加运算的两个对象只要有一个为1，其值为1。

public class Test {
    public static void main(String[] args) {
    System.out.println(5 | 3);//结果为7
    }
}

5转换为二进制：0000 0000 0000 0000 0000 0000 0000 0101

3转换为二进制：0000 0000 0000 0000 0000 0000 0000 0011

7转换为二进制：0000 0000 0000 0000 0000 0000 0000 0111
位或操作：第一个操作数的的第n位于第二个操作数的第n位只要有一个是1，那么结果的第n为也为1，否则为0

6、位异或( ^ )
参加运算的两个数据，按二进制位进行“异或”运算。
运算规则：0^0=0； 0^1=1； 1^0=1； 1^1=0；
即：参加运算的两个对象，如果两个相应位为“异”（值不同），则该位结果为1，否则为0。

public class Test {
    public static void main(String[] args) {
    System.out.println(5 ^ 3);//结果为6
}
}

5转换为二进制：0000 0000 0000 0000 0000 0000 0000 0101

3转换为二进制：0000 0000 0000 0000 0000 0000 0000 0011

6转换为二进制：0000 0000 0000 0000 0000 0000 0000 0110
位异或：第一个操作数的的第n位于第二个操作数的第n位相反，那么结果的第n为也为1，否则为0

7、位非( ~ ) 位非是一元操作符

public class Test {
    public static void main(String[] args) {
    System.out.println(~5);//结果为-6
    }
}

5转换为二进制：0000 0000 0000 0000 0000 0000 0000 0101

-6转换为二进制：1111 1111 1111 1111 1111 1111 1111 1010

位非：操作数的第n位为1，那么结果的第n位为0，反之。

8、衍生位运算
&= 按位与赋值
|= 按位或赋值
^= 按位非赋值
>>= 右移赋值
>>>= 无符号右移赋值
<<= 赋值左移

和 += 一个概念而已。

public class Test {
    public static void main(String[] args) {
        int a = 5
        a &= 3;
        System.out.println(a);//结果是1
    }
}

第八章：运算符的优先级（了解）

数字越小，优先级越高

优先级	描述	运算符	结合性
1	分隔符	. [ ] ( )
2	自增自减	++ — ~ !	右到左
3	算术乘除	`*`、`/`、`%`	左到右
4	算术加减	+ -	左到右
5	移位运算	>> << >>>	左到右
6	大小关系	< <= > >=	左到右
7	相等关系	== !=	左到右
8	按位与运算	&	左到右
9	按位异或	^	左到右
10	按位或	\|	左到右
11	逻辑与	&&	左到右
12	逻辑或	\|\|	左到右
13	三目条件	？：	左到右
14	赋值运算	= 以及衍生赋值运算符	右到左

注意：

表达式不要太复杂。
先算的使用 () ，提升优先级。
大体的排序：算术->位—>比较—>逻辑—>三元—>赋值。

Java 讲义

Java 运算符

第一章：概述

第二章：算术运算符

2.1 概述

2.2 应用示例

2.3 `+` 号的三种用法

2.3.1 字符的“+”操作（理解）

2.3.2 字符串的“+”操作（理解）

2.4 数值拆分（应用）

2.5 自增自减运算

2.5.1 概述

2.5.2 单独使用

2.5.3 复合使用

第三章：赋值运算符

3.1 概述

3.2 应用示例

第四章：关系运算符（比较运算符）

4.1 概述

4.2 应用示例

第五章：逻辑运算符

5.1 概述

5.2 应用示例

5.3 短路逻辑运算符

第六章：条件运算符（三元运算符）

6.1 概述

6.2 应用示例

第七章：位运算（了解）

7.1 概述

7.2 概述

第八章：运算符的优先级（了解）

Java 运算符

第一章：概述

第二章：算术运算符

2.1 概述

2.2 应用示例

2.3 + 号的三种用法

2.3.1 字符的“+”操作（理解）

2.3.2 字符串的“+”操作（理解）

2.4 数值拆分（应用）

2.5 自增自减运算

2.5.1 概述

2.5.2 单独使用

2.5.3 复合使用

第三章：赋值运算符

3.1 概述

3.2 应用示例

第四章：关系运算符（比较运算符）

4.1 概述

4.2 应用示例

第五章：逻辑运算符

5.1 概述

5.2 应用示例

5.3 短路逻辑运算符

第六章：条件运算符（三元运算符）

6.1 概述

6.2 应用示例

第七章：位运算（了解）

7.1 概述

7.2 概述

第八章：运算符的优先级（了解）

2.3 `+` 号的三种用法