本文共 4951 字，大约阅读时间需要 16 分钟。

运算符

Java运算符

• 算术运算符
• 关系运算符
• 逻辑运算符
• 赋值类运算符
• 字符串连接运算符
• 三元运算符

1. 运算符——算术运算符

+：求和

public class HelloWorld {
   				public static void main (String[] args) {
   					int i = 8 ;			int j = 3 ;						System.out.println(i + j); // 11			System.out.println(i - j); // 5			System.out.println(i * j); // 24			System.out.println(i / j); // 2			System.out.println(i % j); // 2					}}

• 关于++运算符【自加1】

int k = 7 ;// ++ 运算符可以出现在变量后面【单目运算符】k++ ;System.out.println(k); // 8int y = 7 ;// ++ 运算符可以出现在变量前面【单目运算符】++y ;System.out.println(y); // 8总结：++运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后，只要++运算结束，该变量中的值一定会自加1

• ++ 出现在变量后
  规则：先做赋值运算，再对变量中保存的值进行自加1

int a = 100;int b = a ++;System.out.println(a); // 101System.out.println(b); // 100

• ++ 出现在变量前
  规则：先进行自加1运算，然后再进行赋值操作

int m = 20;int n = ++ m;System.out.println(m); // 21System.out.println(n); // 21

• 变形

int x = 500;System.out.println(x ++); // 500(++出现在变量后,先赋值再自加1)System.out.println(x); //501

int y = 500;System.out.println(++y); // 501(++出现在变量前,先自加1再赋值)System.out.println(y); //501

2. 运算符——关系运算符
   >：大于
   >=：大于等于
   < ：小于
   <=：小于等于
   ==：等于等于
   != ：不等于
   注意
   =：赋值运算符
   ==：关系运算符

• 关系运算符的运算结果一定是布尔型：true/false

• 关系运算符的运算原理
  int a = 10 ;
  int b = 10 ;
  a > b 比较的时候，比较的是a中保存的10这个值和b中保存的10这个值之间的比较
  a == b 也是如此

int a = 10;int b = 10;			System.out.println(a>b); // falseSystem.out.println(a>=b); // trueSystem.out.println(a

3. 运算符——逻辑运算符

& ：逻辑与【并且】（两边的算子都是true，结果才是true）

&& ：短路与

• 逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型
• 短路与和逻辑与最终的运算结果是相同的，只是短路与存在短路现象；
• 短路或和逻辑或最终的运算结果是相同的，只是短路或存在短路现象；
• 什么情况下发生短路现象
• 什么时候选择使用短路与运算符？什么时候选择使用短路与运算符？

public class Test01{
   		public static void main (String[] args) {
   					//运算符优先级不确定，加小括号			System.out.println(6 > 5 & 6 > 1); // true			System.out.println((6 > 5) & (6 > 1)); // true			System.out.println(6 > 7 & 6 > 2); // false			System.out.println(6 > 7 | 6 > 2); // true						}}

public class Test02{
   		public static void main (String[] args) {
   					System.out.println(true & true); // true			System.out.println(true & false); // false			System.out.println(false & true); // false			System.out.println(false & false); // false						System.out.println(true | true); // true			System.out.println(true | false); // true			System.out.println(false | false); // false						System.out.println(!true); // false			System.out.println(!false); // true						System.out.println(true ^ false); // true			System.out.println(true ^ true); // false			System.out.println(false ^ false); // false						}}

• 逻辑与和短路与
  A：从某个角度来看，短路与更智能，由于后面的表达式可能不执行，所以执行效率较高，这种方式在实际开发中较多使用，短路与比逻辑与使用的多，短路与更常见。
  B：但是在某些特殊的业务逻辑中，要求运算符两边的算子必须全部执行，此时必须使用逻辑与，不能使用短路与，使用短路与可能导致后边的表达式不执行。

public class Test01{
   		public static void main (String[] args) {
   					int x = 10 ;			int y = 8 ;			//逻辑与			System.out.println(x < y & ++ x < y); // false			System.out.println(x); // 11						int x1 = 10 ;			int y1 = 8 ;			//短路与			// x < y 结果是false，整个表达式结果已经确定是false			//所有后面的表达式没有再执行，这种现象被称为短路现象			//短语与才会有短路现象，逻辑与是不会存在短路现象的			System.out.println(x1 < y1 && ++ x1 < y1); // false			System.out.println(x1); // 10						}}

• 什么情况下发生短路或
  第一个表达式执行结果是true，或发生短路或
• 什么情况下发生短路与
  第一个表达式执行结果是false，或发生短路与

4. 运算符——赋值运算符

赋值类运算符包括两种：

• 基本的赋值运算符
  =
• 扩展的赋值运算符
  +=
  -=
  *=
  /=
  %=

1. 赋值类的运算符优先级：先执行等号右边的表达式，将执行结果赋值给左边的变量
2. 注意

• byte a = 10;
  a += 5 ; 等同于：a = (byte) (a + 5)
• int b = 10;
  b += 5；等同于：b = (int) (b + 5)
• long c = 10L;
  int d = 20;
  y += x；等同于：y = (int) (y + x)

3. 结论：扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是byte类型，无论怎么进行追加或追减，最终该变量的数据类型还是byte类型。

public class Test02{
   		public static void main (String[] args) {
   				//基本的赋值运算符		int i = 100;		System.out.printlb(i); // i = 100				i = i + 3;		System.out.printlb(i); // i = 103				//扩展的赋值运算符【+= 运算符可以翻译为：“追加/累加”】		i += 5; //等同于： i = i + 5		System.out.printlb(i); // i = 108				i -= 5; //等同于：i = i - 5		System.out.println(i); // i = 103					i /= 5;	//等同于：i = i / 5		System.out.println(i); // i = 20					i *= 5; //等同于：i = i * 5		System.out.println(i); // i = 500					i %= 5; //等同于：i = i % 5		System.out.println(i); // i = 0	---------------------------------------------------------------------------------------		// 10没有超出byte取值范围，可以直接赋值		byte b = 10 ;		//编译报错，编译器只检查语法，不运行程序，编译器发现b+5的类型是int类型，b变量的数据类型是byte，大容量向小容量转换需要加强制类型转换符，所以一下程序编译报错		b = b + 5;		//纠正错误，强制类型转换		b =(byte) (b + 5);;		System.out.println(b); //15		b = 15; //可以，编译通过，15没有超出byte取值范围		}}

5. 运算符——字符串连接运算符

1. “+”运算符在Java语言当中的两个作用

• 加法运算，求和
• 字符串的连接运算

2. 当“+”运算符两边的数据都是数字的话，一定要进行加法运算
3. 当“+”运算符两边的数据只要有一个数据是字符串，一定会进行字符串连接运算，并且连接运算之后结果还是一个字符串类型
   数字 + 数字 -----> 数字【求和】
   数字 + “字符串” ------> “字符串”【字符串连接】
4. 在一个表达式当中可以出现多个“+”，在没有添加小括号的前提之下，遵循自左向右的顺序依次运行。

public class Test02{
   		public static void main (String[] args) {
   		System.out.printlb(10 + 20); // 30 “+”求和		System.out.printlb(10 + 20 + 30); // 60 “+”求和		System.out.printlb(10 + 20 + “30”); // 3030 自左向右的顺序下执行运算，第一个加号是求和，第二个加号是字符串运算符			System.out.printlb(10 + (20 + “30”)); // ”102030“		}}

转载地址：https://blog.csdn.net/qq_41144305/article/details/123820170 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！