二、运算符

1.运算符

1.1算术运算符

java开发中使用的算术运算符：

+ - * /(求得商后向下取整保留整数) %   （）
1. 先乘除，后加减
2. 从左至右运行
3. 除数不能为0
4. 先运算小括号里面的内容
5.赋值运算符=可以与+-*/%搭配使用+= -= *= /= %=


注意：
1. Java中所有的运算符优先级有18-19个等级，优先级最高的是小括号，开发中如果出现了需要整理优先级的问题，简单粗暴加括号。
**2. 小括号里面的内容对于小括号外部而言是一个整体，是一个【常量】

1.2赋值运算符

=
赋值号的功能是将赋值号右侧的数据，赋值给左侧的【变量】
赋值运算符可以搭配+-*/%使用，实现相应操作后在赋值给变量本身

public class TestOperatorSign {
    public static void main(String[] args){
        int num1 = 10;
        int num2 = 20;
        num1 = num1 + num2;
        num1 = num1 * num2;
        num1 = num1 - num2;
        num1 = num1 / num2;
        num1 = num2 % num1;
        System.out.println(num1);
        System.out.println(num2);

    }
}

public class TestOperationSign2 {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        num1 += num2;
        num1 *= num2;
        System.out.println(num1);
        System.out.println(num2);
    }
}

1.3关系运算符

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

public class TestOperationSign3 {
    public static void main(String[] args) {
        boolean ret = true;
        ret = 5 > 10;
        System.out.println(ret);
        ret = 5 < 10;
        System.out.println(ret);
        ret = 5 >= 5;
        System.out.println(ret);
        ret = 5 <= 2;
        System.out.println(ret);
        ret = 5 != 5;
        System.out.println(ret);
        ret = 5 == 4;
        System.out.println(ret);
    }
}

1.4自增自减运算符

【明确】
	自增自减运算符【有且只能操作变量】，不可以操作常量
【建议】
	开发中尽量减少或者标准化使用自增自减运算符。	
语法
	++ 自增运算符 操作的变量自增1 等价于 += 1
	-- 自减运算符 操作的变量自减1 等价于 -= 1
【难点】
	前后关系
	自增自减运算符在
		变量之前：首先执行自增自减操作，再来完成当前行代码的运行
		变量之后：首先执行当前行代码，再来执行自增自减操作

public class TestOperationSign4 {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println("num1++ : " + num1++); //10
        System.out.println("num1 : " + num1); //11
        System.out.println("++num1 : " + ++num1); //12
        System.out.println("num1 : " + num1);//12
    }
}

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

1.5逻辑运算符

与 &
	短路与 &&
	【重点】同真为真，有假【即】假
或 |
	短路或 ||
	【重点】有真【即】真，同假为假
非 ！
	取反

逻辑异或 ^
	
逻辑运算符运算的结果都是boolean类型数据。通常用于条件判断，数据过滤...
& 与 && 的区别：& 和 | 左右两边的式子一定会执行（比较笨），&& 和 || 只要左边的式子能得出结果，右边的式子就不会执行（比较聪明）

public class TestOperatorSign5 {
    public static void main(String[] args) {
        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
    }
}

短路原则

public class TestOperatorSign6 {
    public static void main(String[] args) {
        int num = 5;
        boolean ret = false;
        ret = num > 10 && ++num > 1; // 从false之后的其他所有条件都不会执行,++num没有执行
        System.out.println("ret : " + ret);
        System.out.println("num : " + num);
    }
}

public class TestOperatorSign7 {
    public static void main(String[] args) {
        int num = 10;
        boolean ret = false;
        ret = num > 5 || ++num > 20;  //只要发现一个条件为真，整个表达式结果已经确定为真。从true条件开始其他条件不需要执行
        System.out.println("ret : " + ret); // true
        System.out.println("num : " + num); // 10
    }
}

2练习

/*
条件:
	写出判断是否是英文字母的条件
*/
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;
/*
加上小括号是一个整体，增强阅读性！！！
*/