1.算术运算符

1.1运算符和表达式

运算符：对常量或者变量进行操作的符号
表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式.
不同的运算符谅解的表达式体现的是不同类型的表达式
举例说明：
int a=10;
int b=20;
int c=a+b;
+是运算符，并且是算术运算符
a+b 是表达式，由于+是算术运算符，所以这个表达式叫做算术表达式.

1.2算术运算符

符号 作用 说明
+ 加 参考小学一年级+
- 减 参考小学一年级+
* 乘 参考小学二年级，与×相同
/ 除 参考小学二年级，与÷相同
% 取余 获得两个数据做除法的余数

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

  1. /**
  2.  * 算术运算符
  3.  */
  4. public class constant {
  5.     public static void main(String[] args) {
  6.         int a = 6;
  7.         int b = 4;
  8.         // 加
  9.         System.out.println(a + b);
  10.         // 减
  11.         System.out.println(a - b);
  12.         // 乘
  13.         System.out.println(a * b);
  14.         // 除
  15.         System.out.println(a / b);
  16.         // 取余
  17.         System.out.println(a % b);
  18.         // 除法得到的是商，取余得到的是余数
  19.         // 整数相除只能得到整数，要想得到小数，必须有浮点数的
  20.         System.out.println(6.0 / 4);
  21.     }
  22. }

1.3 字符的+操作

拿字符在计算机底层对应的数值来进行计算
A——65 A-Z是连续的
‘a’——97 a-z 是连续的
‘0’——— 48 0-9 是连续的。
算术表达式中包含多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升，提升规则
byte类型，short类型，和char 类型将会被自动提升到int 类型
整个表达式的类型自动提升到表达式中最高等级操作数同样的类型
等级顺序：byte，short，char—-int—-long—-float—-double 

  1. /**
  2.  * 字符的+操作
  3.  */
  4. public class constant {
  5.     public static void main(String[] args) {
  6.         // 定义两个变量
  7.         int a = 10;
  8.         char b = 'A'; // 字符'a'的值为97 //字符''A'的值为65
  9.         System.out.println(a + b);
  10.         // char ch=a+b
  11.         // char类型会被自动提升为int类型
  12.         int j = a + b;
  13.         System.out.println(j);
  14.         // int k=10+13.14;
  15.         double k = 10 + 13.14;
  16.         System.out.print(k);
  17.     }
  18. }

1.4 字符串的”+”操作

当”+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算
例子 ： “item”+666
当“+”操作中，如果出现字符串，就是连接运算符，否则就是算术运算，当连续进行“+”操作时，从左到右逐个执行.
例子：1+99+“年”

2.赋值运算符

2.1赋值运算符

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

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

  1. /**
  2.  * 赋值运算符
  3.  */
  4. public class constant {
  5.     public static void main(String[] args) {
  6.         // 将10赋值给int类型的变量a
  7.         int a = 10;
  8.         System.out.println(a + 10);
  9.         // += 把左边和右边的数据做加法操作，结果赋值给左边
  10.         // a += 20;等同于 a=a+20;
  11.         System.out.println(a);
  12.         // 扩展的赋值运算符隐含了强制类型转换
  14.     }
  15. }

3.自增自减运算符

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

注意事项：
++和—即可以放在变量的后面，也可以放在变量的前面。
单独使用的时候。++和—无论是放在变量的前面还是后边，结果是一样的
参与操作的时候，如果放在变量的后面，先拿变量的值参与操作，后拿变量做++或者—.
参与操作的时候，如果放在变量的前边，先拿变量做++或者—，后拿变量参与操作。
最常见的用法：单独使用。

4.关系运算符

4.1关系运算符

符号 说明
== a==b，判断a和b的值是否相等，成立为true，不成立为false
！= a!=b,判断a和b的值是否不相等，成立为ture，不成立为false
> a>b判断a是否大于b，成立为ture，不成立为false
>= a>=b判断a是否大于等于b，成立为true，不成立为false
< a<b，判断a是否小于b，成立为true，不成立为false
<= a<=b,判断a是否小于等于b，成立为true，不成立为false 
  1. public class constant {
  2.     public static void main(String[] args) {
  3.         // 定义变量
  4.         int a = 10;
  5.         int b = 20;
  6.         System.out.println(a == b);
  7.         System.out.println(a != b);
  8.         System.out.println(a >= b);
  9.         System.out.println(a > b);
  10.         System.out.println(a <= b);
  11.         System.out.println(a < b);
  13.     }
  14. }

注意事项：
关系运算符的结果都是boolean类型，要么是true，要么是false，
千万不能将”==”误写成”=”

5.逻辑运算符

5.1逻辑运算符

在数学中，一个数据X 大于3小于6，我们可以这样来进行表示3在Java中，需要把上面的式子先进性拆解，再进行合并表达。
拆解为：x>3和x<6
合并后x>3&&x<6
&&其实就是一个逻辑运算符.
我们可以这样说，逻辑运算符，是用来连接关系表达式的运算符，当然，逻辑运算符也可以直接连接布尔类型的常量或者变量。

符号 作用 说明
& 逻辑与 a&b a和b都是true，结果为true，否则为false
| 逻辑或 a|b，a和b都是false，结果为false，否则为true
^ 逻辑异或 a^b,a和b的结果不同为ture，相同为false
! 逻辑非 ！a 结果和a的结果正好相反。

5.3 短路逻辑运算符

符号 作用 说明
&& 短路与 作用和&相同，具有短路的作用
|| 短路或 作用和|相同，具有短路的作用

注意事项：
逻辑&，无论左边真假，右边都执行。
短路&&，如果左边为真，右边执行，如果左边为假，右边不执行
逻辑| ，无论左边真假，右边执行
短路||，如果左边为假，右边执行，如果左边为真，右边不执行。

6.三元运算符

6.1三元运算符

格式： 关系表达式？表达式1：表达式2;
范例：a>b？a：b，
计算规则： 首先计算关系表达式的值，如果为true，表达式1的值就是运算结果，如果值为false，表达式2的值就是运算结果。

  1. /**
  2.  * 三元运算符
  3.  * 格式：
  4.  * 关系表达式？表达式1:表达式2
  5.  * 范例：a>b?a:b
  6.  * 执行流程
  7.  * 首先计算关系表达式的值
  8.  * 如果值为true，表达式1的值就是运算结果
  9.  * 如果值为false，表达式2的值就是运算结果
  10.  */
  11. public class constant {
  12.     public static void main(String[] args) {
  13.         // 定义变量
  14.         int a = 10;
  15.         int b = 20;
  16.         // 获取两个值中的大的值
  17.         int c = a > b ? a : b;
  18.         System.out.println(c);
  20.     }
  21. }

案例： 两只老虎（一只：180kg，一只：200kg）
需求： 动物园里有两只老虎，已知两只老虎的体重分别为180kg，200kg，请用程序实现判断两只老虎的体重是否相同
分析：1.定义两个变量用于保存老虎的体重，单位为kg，这里仅仅体现数值即可。
2.用三元运算符实现老虎的体重的判断，体重相同，返回true，体重不同返回false
3.输出结果

  1. /**
  2.  * 案例：两只老虎
  3.  * 需求： 动物园里有两只老虎，已知两只老虎的体重分别为180kg，200kg，请用程序实现判断两只老虎的体重是否相同
  4.  */
  5. public class constant {
  6.     public static void main(String[] args) {
  8.         // 1.定义两个变量用于保存老虎的体重，单位为kg，这里仅仅体现数值即可
  9.         int a = 180;
  10.         int b = 200;
  11.         // 2.用三元运算符实现老虎的体重的判断，体重相同，返回true，体重不同返回false
  12.         Boolean c = a == b ? true : false;
  13.         // 3输出结果
  14.         System.out.println(c);
  16.     }
  17. }

案例：3个和尚
需求： 一座寺庙里住着三个和尚，已知他们身高分别为150cm，210cm，165cm，请用程序实现获取这三个和尚的最高身高
分析：1.定义三个变量，用来保存和尚的身高 单位为cm,这里仅仅体现数值即可.

  1. 用三元运算符获取两个和尚的较高身高值，并用临时身高变量保存起来

  2. 用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。 ```javascript /**

    • 案例：三个和尚

    • 需求： 一座寺庙里住着三个和尚，已知他们身高分别为150cm，210cm，165cm，请用程序实现获取这三个和尚的最高身高 */ public class constant { public static void main(String[] args) {

      // 分析：1.定义三个变量，用来保存和尚的身高 单位为cm,这里仅仅体现数值即可. int height1 = 150; int height2 = 210; int height3 = 165; // 2.用三元运算符获取两个和尚的较高身高值，并用临时身高变量保存起来 int c = height1 > height2 ? height1 : height2; // 3.用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。 int b = c > height3 ? c : height3; // 4.输出结果 System.out.println(b);

      } }

```