运算符

运算符

1.运算符

1.1算数运算符

小学知识点:
	加+，减-，乘×，除÷，小括号()

开发中使用的算术运算符:
	加 + 减 - 乘 * 除 / 取余 % 小括号 () = 赋值号

注意事项:
	1. 先乘除，后加减
	2. 从左至右运行
	3. 除数不能为0
	4. 先运算小括号里面的内容
	【批注】
		1. Java中所有的运算符优先级有18-19个等级，优先级最高的是小括号，开发中
		如果出现了需要整理优先级的问题，简单粗暴加括号
		2. 小括号里面的内容对于小括号外部而言是一个整体，是一个【常量】 

= 赋值号
	赋值号的功能是将赋值号右侧的数据，赋值给左侧的【变量】
	char ch = 'A'; True
	10 = 20; false

使用总结:
	1. 变量有且只能是被赋值之后才可以修改内容，未赋值不能修改
	2. 取余操作注意细节
	3. 【批注】
		取余操作针对整数，小数没有取余操作

/* 算术运算符演示 */
class Demo1 {
	public static void main(String[] args) {
		// 定义两个int类型变量
		int num1 = 10;
		int num2 = 20;
		
		// num1 + num2结果赋值给num1
		num1 = num1 + num2; // num1 = 30 num2 = 20
		// 变量在代码运行的过程中是会发生改变。
		num1 = num1 * num2; // num1 = 600 num2 = 20
		num1 = num1 - num2; // num1 = 580 num2 = 20
		num1 = num1 / num2; // num1 = 29 num2 = 20
		
        // 小学手写方式
		// 20 ÷ 29 = 0 ...... 20
		// 5 ÷ 2 = 2 ...... 1
        // 9 ÷ 4 = 2 ...... 1
		num1 = num2 % num1; // num1 = 20 num2 = 20
		
		/*
		num2的值从开始到最后没有发生改变
			num2从开始没有被赋值过
		*/
		System.out.println(num1);
		System.out.println(num2);
	}
}

1.2偷懒专用算术运算符

非常实用！！！
	+=	-=	/=	*=	%=
	
	num1 = num1 + num2; ==> num1 += num2;
	

/* 偷懒专用算术运算符 */
class Demo2 {
	public static void main(String[] args) {
		// 定义两个变量
		int num1 = 10;
		int num2 = 20;
		
		// num1 = num1 + num2;
		num1 += num2;
		num1 *= num2; 
		
		System.out.println(num1);
		System.out.println(num2);
	}
}

1.3关系运算符

小学关系运算符:
	>	<	≥	≤	≠	＝
	
代码开发中关系运算符
	＞ 大于
	＜ 小于
	>= 大于等于
	<= 小于等于
	!= 不等于
	== 等于判断
	
注意事项:
	1.关系运算符结果是一个boolean数据类型，true or false
	2.关系运算符一般用于条件判断，数据过滤...

/* 关系运算符 */
class Demo3 {
	public static void main(String[] args) {
		// 定义一个boolean 类型变量
		boolean ret = true;
		
		// 5 > 10 结果赋值给ret 这个boolean类型变量
		ret = 5 > 10;
		System.out.println(ret); // false
		
		ret = 5 < 10;
		System.out.println(ret); // true
		
		ret = 5 >= 5;
		System.out.println(ret); // true
		
		ret = 5 <= 2;
		System.out.println(ret); // false
		
		ret = 5 != 5;
		System.out.println(ret); // false
		
		ret = 5 == 4;
		System.out.println(ret); // false
	}
}

1.4自增自减运算符【难点，考点】

【明确】
	自增自减运算符【有且只能操作变量】，不可以操作常量
【建议】
	开发中尽量减少或者标准化使用自增自减运算符。
	
	
语法
	++ 自增运算符 操作的变量自增1 等价于 +=1
	-- 自减运算符 操作的变量自减1 等价于 -=1
	
【难点】
	前后关系
	自增自减运算符在
		变量之前：首先执行自增自减操作，再来完成当前行代码的运行
		变量之后：首先执行当前行代码，再带执行自增自减操作
		
【建议】
	1.尽量使用 += 1 或者 -= 1 替换自增自减运算符。阅读星更好，并且在Swift语言中已经取消自增自减运算符，使用 += 1 和 -= 1 代替，额日了避免没有必要的歧义性
	2.如果非要使用自增自减运算符，推荐自增自减运算符，单独成行。
    	int num = 10l;
    	++nume; or num++;	没有任何的歧义性

/* 自增运算符前后关系演示 */
class Demo4 {
	public static void main(String[] args) {
		int num1 = 10;
		
		// 双引号内容是所见即所得
		/*
		自增运算符在操作数之后，首先操作数原始数据参与该行代码运行
		当前代码运行结束之后，再进行自增操作。
		先执行当前行代码，再执行自增操作
		*/
		System.out.println("num1++ : " + num1++); // num1++ : 10
		System.out.println("num1 : " + num1); // num1 : 11
		
		/*
		自增运算符在操作数之前，首先执行自增操作，num1 += 1;
		num1 ==> 12 然后在进行数据展示
		先执行自增，在参与当前行代码执行
		*/
		System.out.println("++num1 : " + ++num1); // ++num1 : 12
		System.out.println("num1 : " + num1); // num1 : 12
	}
}

/* 自减运算符演示 */
class Demo5 {
	public static void main(String[] args) {
		int num = 10;
		
		System.out.println("num-- : " + num--); // num-- : 10
		System.out.println("num : " + num); //  num : 9
		
		System.out.println("--num : " + --num); // num-- : 8
		System.out.println("num : " + num); //  num : 8	
	}
}

【自增自减运算符考点】

常见面试题1

int num = 5;
int ret = num++ * ++num;

ret = ?
num = ?
/*
请问num值经历了几次自增操作？
	两次，num确定最后结果为7

ret的结果从何而来？
	num++ 
		++在后，提供的数据5， num++在运行表达式中提供的数据为5
		这里运算操作是一个乘以操作，num++需要执行完毕 num ==> 6
	*
	++num:
		++在前，提供的数据6 + 1 ==> 7
    
    最终表达式的结果为
    	5 * 7 = 35 ==> ret;
    	
int ret = num++ * ++num;拆解
	num == 5;
	num += 1 ==> 6
	*
	++num ==> 7
*/

常见面试题2

int num = 5;
++(num++);

num = ?;
/*
Demo7.java:5: 错误: 意外的类型
                ++(num++);
                      ^
		  需要: 变量
		  找到:    值
		1 个错误
解释:
	因为(num++)是存在于小括号以内，按照计算优先级处理，首先计算小括号里面的内容，但是因为小括号是一个整体，对外的数据时num++的结果，这是一个常量！！！
	自增自减运算符，只能操作变量，不可以操作常量。
	语法报错！！！
	
同理
	++num++ 也是错误的
	++num结果是一个常量
	
	(num)这个是常量还是变量呢
	这个小括号是无用的！！！
	（num）++这是对的
	
	num = 5
	拿++num*++num = 42
	
	5 
	num++ + --num + ++num 
*/

1.5逻辑运算符

与
	银行的金库，两个人两把钥匙，需要同时在场，缺一不可。
	&&
	【重点】同真为真，有假【即】假
或
	自己家门，我和我女朋友出去逛街，只要有一个人带有钥匙就可以回家，满足一个条件即
	可。
	||
	【重点】有真【即】真，同假为假
非
	强牛 
	犟，杠精！！
	取反
	!
	
	逻辑运算符运算的结果都是boolean类型数据。
	通常用于条件判断，数据过滤...
	想要成为VIP，充值超过10W 【并且】 消费超过5次
				 提出的标准都要具备
	
	想要成为VIP，充值超过10W 【或者】 消费超过5次
				只达成其中一个便可

/* 逻辑运算符演示 */
class Demo8 {
	public static void main(String[] args) {
		// 定义一个boolean类型的变量
		boolean ret = false;
		
		ret = 5 > 3 && 10 > 8;
		System.out.println("ret : " + ret); // true
		
		ret = 5 < 3 && 10 > 8;
		System.out.println("ret : " + ret); // false
		
		ret = 5 < 3 || 10 > 8;
		System.out.println("ret : " + ret); // true
		
		ret = 5 < 3 || 10 < 8;
		System.out.println("ret : " + ret); // false
		
		ret = !(5 > 3);
		System.out.println("ret : " + ret); // false
	}
}

【逻辑运算符短路原则】

/* 逻辑与短路原则 */
class Demo9 {
	public static void main(String[] args) {
		int num = 5;
		boolean ret = false;
		
		/*
		只要有错后面的就不看了吗 为了效率是吗
				是的，有错即停
		逻辑与的情况下：
			同真为真，有假【即】假
			当出现一个条件为false之后，整个逻辑与表达式的结果为
			false，从false之后的其他所有条件都不会执行。
			
			计算机的节约性能问题！！！
		*/
		ret = num > 10 && ++num > 1;
		
		System.out.println("ret : " + ret);
		System.out.println("num : " + num);		
	}
}

/* 逻辑或短路原则问题 */
class Demo10 {
	public static void main(String[] args) {
		int num = 10;
		boolean ret = false;
		
		/*
		逻辑或短路原则
			有【真】即真，同假为假
			只要发现一个条件为真，整个表达式结果已经确定为真。
			从true条件开始其他条件不需要执行
		*/
		ret = num > 5 || ++num > 20;
		
		System.out.println("ret : " + ret); // true
		System.out.println("num : " + num); // 10
	}
}

1.6运算符练习题

/*
条件：
	写出判断是否是英文大写字母的条件
	在使用字符常量时，请使用字符本身
*/
char ch; // 声明一个变量
ch >= 'A' && ch <= 'Z';
// 'A' <= ch <= 'Z'; // 计算机不承认这样的写法！！！ ERROR

/*
条件:
	写出判断是否是英文小写写字母的条件
	在使用字符常量时，请使用字符本身
*/
char ch; // 申明一个变量
ch >= 'a' && ch <= 'z';

/*
条件:
	写出判断是否是英文字母的条件
*/
char ch;

(ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z');
ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z';
/*
以上两种写法结果一致
	按照Java规范的运算符优先级问题，&& 高于 || 
	使用小括号是将条件作出一个整体！！！便于阅读和整理思路
*/

/*
闰年问题:
	1. 能被4整除，但是不能被100整除
	2. 能被400整除
*/
int year;
// 能被4整除
year % 4 == 0;

// 不能被100整除
year % 100 != 0;

// 能被400整除
year % 400 == 0;

// 以上三个条件如何组合？
(year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
/*
加上小括号是一个整体，增强阅读性！！！
*/

总结

1.1算术运算符

小括号里面的内容对于小括号外部而言是一个整体，是一个【常量】 

= 赋值号
	赋值号的功能是将赋值号右侧的数据，赋值给左侧的【变量】

取余操作针对整数，小数没有取余操作

1.2关系运算符

代码开发中关系运算符
	> 大于
    < 小于
    >= 大于等于
    <= 小于等于
    != 不等于
    == 等于判断
   
注意事项：
	1. 关系运算符结果是一个boolean数据类型，true or false
	2. 关系运算符一般用于条件判断，数据过滤...

1.3自增自减运算符

【明确】
	自增自减运算符【有且只能操作变量】，不可以操作常量
【建议】
	开发中尽量减少或者标准化使用自增自减运算符。
	
	
1. 尽量使用 += 1 或者 -= 1替换自增自减运算符。阅读性更好，并且在Swift语言中
	已经取消自增自减运算符，使用 += 1 和 -= 1代替，为了避免没有必要的歧义性
2. 如果非要使用自增自减运算符，推荐自增自减运算符，单独成行。

1.4逻辑运算符

与
	银行的金库，两个人两把钥匙，需要同时在场，缺一不可。
	&&
	【重点】同真为真，有假【即】假
或
	自己家门，我和我女朋友出去逛街，只要有一个人带有钥匙就可以回家，满足一个条件即
	可。
	||
	【重点】有真【即】真，同假为假
非
	强牛 
	犟，杠精！！
	取反
	!
	
逻辑与的情况下：
			同真为真，有假【即】假
			当出现一个条件为false之后，整个逻辑与表达式的结果为
			false，从false之后的其他所有条件都不会执行。
			
逻辑或短路原则
			有【真】即真，同假为假
			只要发现一个条件为真，整个表达式结果已经确定为真。
			从true条件开始其他条件不需要执行

化使用自增自减运算符。

1. 尽量使用 += 1 或者 -= 1替换自增自减运算符。阅读性更好，并且在Swift语言中
   已经取消自增自减运算符，使用 += 1 和 -= 1代替，为了避免没有必要的歧义性
2. 如果非要使用自增自减运算符，推荐自增自减运算符，单独成行。

#### 1.4逻辑运算符

与
银行的金库，两个人两把钥匙，需要同时在场，缺一不可。
&&
【重点】同真为真，有假【即】假
或
自己家门，我和我女朋友出去逛街，只要有一个人带有钥匙就可以回家，满足一个条件即
可。
||
【重点】有真【即】真，同假为假
非
强牛
犟，杠精！！
取反
!

逻辑与的情况下：
同真为真，有假【即】假
当出现一个条件为false之后，整个逻辑与表达式的结果为
false，从false之后的其他所有条件都不会执行。

逻辑或短路原则
有【真】即真，同假为假
只要发现一个条件为真，整个表达式结果已经确定为真。
从true条件开始其他条件不需要执行