java入门学习（五：运算符）

运算符

Java运算符

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

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

+：求和
-：相减
* ：乘积
/：商
%：求余数【取模】
++ ：自加1
--：自减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); // 8

int y = 7 ;
// ++ 运算符可以出现在变量前面【单目运算符】
++y ;
System.out.println(y); // 8

总结：++运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后，只要++运算结束，该变量中的值一定会自加1

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

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

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

int m = 20;
int n = ++ m;
System.out.println(m); // 21
System.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); // false
System.out.println(a>=b); // true
System.out.println(a<b); // false
System.out.println(a<=b); // true
System.out.println(a==b); // true
System.out.println(a!=b); // false

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

& ：逻辑与【并且】（两边的算子都是true，结果才是true）
| ：逻辑或【或者】（两边的算子只要有一个是true，结果就是true）
! ：逻辑非（取反，!false就是true，!true就是false，这是一个单目运算符）
^ ：逻辑异或（两边的算子只要不一样，结果就是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“
		}
}