第四章：Java的运算符

温馨提示：本章节的逻辑运算符的短路现象值得重点关注！！！

四目运算符

注意事项
	1.  整数 除以 整数 = 整数（有可能丢失精度）
	2. % 表示取模（取余）
	3. 	当两数类型不相同时，结果以大类型为基准进行计算

代码演示：加减乘除运算

public class Hello {
    public static void main(String[] args) {
        int a1 = 7;
        int a2 = 2;
        System.out.println(a1+a2);
        System.out.println(a1-a2);
        System.out.println(a1/a2);  // 整型 除以 整型 值为 整型
        System.out.println(a1%a2);  // % 表示取模（取余）

        double b1 = 3.5;
        double sum = a1 + b1;       // 当两数类型不相同时，以大类型为取值的标准
        System.out.println(sum);	// 运行结果：10.5

    }
}

加号的作用

1. 字符串与任何数据类型连接（拼接），结果都是字符串类型
2. 在数值运算中，作为加法
3. 对于char型，先将char型提升为int型

代码演示：字符串的拼接

public class Hello {
	public static void main(String[] args){
		int age = 10;
		String name = "wzz";		// 字符串赋值
		
		System.out.println(name);						// 运行结果：wzz
		System.out.println(name+"的年龄是"+age+"岁");	// 运行结果：wzz的年龄是10岁 （实现拼接作用）
		
		System.out.println(age+age);	// 运行结果：20	（实现运算作用）
		
		char a = 'A';
		System.out.println(a+1);	// 运行结果：66
		// ACSII码的char升为十进制数65+1=66
	}
}

代码演示：加号的拼接与运算

public class Hello {
    public static void main(String[] args) {
        String str = "wzz";
        System.out.println(str+1+2+3);	// 运行结果：wzz123
        //             String + int + int + int        ====    wzz + 1 + 2 + 3
        //                  String + int + int         ====      wzz1 + 2 + 3
        //                      String + int           ====        wzz12 + 3
        //                          String             ====          wzz123
        
        System.out.println(1+2+3+str);		// 运行结果：6wzz
        //             int + int + int + String      ====     1 + 2 + 3 + wzz
        //                 int + int + String        ====       3 + 3 + wzz
        //                     int + String          ====         6 + wzz
        //                        String             ====          6wzz
    }
}

自增、自减

自加、自减不可以对常量进行操作！！！

代码演示：先自增（减）后赋值、先赋值后自加（减）

public class Hello {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(++num1);		// 运行结果：11
        // 先自增后赋值：变量先+1，再参与运算 
        System.out.println(num1);		// 运行结果：11
        
        int num2 = 20;
        System.out.println(--num2);		// 运行结果：19
        // 先自减后赋值：变量先-1，再参与运算 
        System.out.println(num2);		// 运行结果：19

        int num3 = 30;
        System.out.println(num3--);		// 运行结果：30
        // 先赋值后自减：变量参与运算，再-1
        System.out.println(num3);		// 运行结果：29
 

		int num4 = 40;
        System.out.println(num4++);		// 运行结果：40
        // 先赋值后自加：变量参与运算，再+1
        System.out.println(num4);		// 运行结果：39

		// 混合运算
	    System.out.println("=============================");
        int a = 3;
        int b = 5;
        int c = a++ + --b;      // 3 + 4。a++ == 3，原因：第一次使用调用最初值
        System.out.println(a);  // 运行结果：4   
        System.out.println(b);  // 运行结果：4
        System.out.println(c);  // 运行结果：7
    }
}

赋值运算符

+=：左右两值相加赋值给左边的变量			例：int a += 10; 同理：a = a+10;
-=：左值 减 右值赋值给左边的变量			例：int a -= 10; 同理：a = a-10;		
*=：左右两值相乘赋值给左边的变量			例：int a *= 10; 同理：a = a*10;
/=：左值 除以 右值赋值给左边的变量			例：int a /= 10; 同理：a = a/10;

代码演示：字符的赋值运算

public class Hello {
    public static void main(String[] args) {
        char ch = 92;
        ch += 5;	
        // 同理：ch = ch + 5
        // ch = char + int
        // ch = int + int
        // ch = int	 （十进制97对应ASCII码为a）
        System.out.println("ch="+ch);	// 运行结果：ch=a

        System.out.println("=============================");
        byte by = 10;
        by += 5;	
        // 同理：by = by +5
        // by = by + int
        // by = int + int
        // by = int
        System.out.println("by="+by);	// 运行结果：by=15
    }
}

关系运算符

==：判断左右值是否相同，若相同，则输出true。否则false
=：将右值赋值给左边的变量

代码演示：关系运算

public class Hello {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        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);	// 运行结果：false
        System.out.println(a=b);	// 运行结果：2
    }
}

逻辑运算符

&&：与（并且），全部满足一个条件为true
||：或（或者），至少满足一个条件为true
 !：非（取反），true为假，false为真

代码演示：逻辑运算

public class Hello {
    public static void main(String[] args) {
        System.out.println(!false);         // 运行结果：true
        System.out.println(!true);          // 运行结果：false
        System.out.println("==========================");
        System.out.println(false && false); // 运行结果：false
        System.out.println(false && true);  // 运行结果：false
        System.out.println(true && false);  // 运行结果：false
        System.out.println(true && true);   // 运行结果：true
        System.out.println("==========================");
        System.out.println(false || false); // 运行结果：false
        System.out.println(false || true);  // 运行结果：true
        System.out.println(true || false);  // 运行结果：true
        System.out.println(true || true);   // 运行结果：true
    }
}

代码演示：逻辑运算中的短路现象

// 短路的作用：提高运行效率
public class Hello {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(10 > 11 && ++a > 10);	// 运行结果：false
        // 短路现象： false && ...
        // 原因：第一个表达式为false，后面的表示式不会被执行
        System.out.println(a);						// 运行结果：1

        int b = 2;
        System.out.println(15 > 11 || ++b > 10);	// 运行结果：true
        // 短路现象： false || ...
        //      第一个表达式为true，后面的表示式不会被执行
        System.out.println(b);						// 运行结果：2
    }	
}

位运算符

“~”取反运算符中存在原码、反码、补码的运算

&（与）：两个相应的二进制位都为1，则该位的结果值为1，否则为0
	例：	1010			十进制：10
		    0110			十进制：6
	   结果：0010			十进制：2

|（或）：两个相应的二进制位中只要有一个为1，该位的结果值为1
	例：	1010			十进制：10
		    0110			十进制：6
	   结果：1110			十进制：14

^（异或）：若参加运算的两个二进制位值相同则为0，否则为1
	例：   	1010			十进制：10
		    0110			十进制：6
	   结果：1100			十进制：12	

~（取反）:按位取反运算符翻转操作数的每一位，即1变0，即0变1
	例：	1010			十进制：10
	   结果：11101			十进制：-11
	解析：	（符号位0为正数，1为负数）
			正数的原码、反码、补码都相等，所以正数的补码是0000 1010
			补码取反：1111 0101
			反码：1111 0100		（反码 = 补码 - 1）
			原码：1000 1011		（原码到反码：符号位不变其余取反）

<<：按位左移运算符。左操作数按位左移左操作数指定的位数
	例：	0011 1100<<2			十进制：60
		结果：1111 0000				十进制：240

>>：按位右移运算符。左操作数按位右移右操作数指定的位数
	例：	0011 1100>>2			十进制：60
		结果：0000 1111				十进制：15

>>>：按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充
	例：	0111 0001>>>2			十进制：113
		结果：0001 1100				十进制：28		

代码演示：位运算

public class Hello {
    public static void main(String[] args) {
        int a1 = 10;
        int a2 = 6;
        System.out.println(a1 & a2);         // 运行结果：2
        System.out.println(a1 | a2);         // 运行结果：14
        System.out.println(a1 ^ a2);         // 运行结果：12
        System.out.println(~a1);         	 // 运行结果：-11

        int a3 = 60;
        System.out.println(a3<<2);		    // 编译结果 240
        System.out.println(a3>>2);		    // 编译结果 15

        int a4 = 113;
        System.out.println(a4>>>2);		    // 编译结果 28
    }
}

三目运算符

表达式1 ? 表达式2 : 表达式3;

当条件表达式1为true，返回结果：表达式2
当条件表达式1为false，返回结果：表达式3

代码演示：三目运算

public class Hello {
    public static void main(String []args) {
      	int a = 10;
		int b = 20;
		int max = a > b ? a : b;		
		int min = a < b ? a : b;
		// 冒号两边的类型相同或兼容
		System.out.println("max:"+max);		// 运行结果：max:20
		System.out.println("min:"+min);		// 运行结果：min:10
    }
}