Java基础语法（四）

运算符
1、运算符概述

算数运算符	+ , - , * , / ,% , ++ , --
关系运算符	>,<,>=,<=,==,!=
逻辑运算符	!,&&,||
位运算符	>>,<<,>>>,&,|,^,~
赋值运算符	=,及其扩展运算符如：+=，-=，*=，/=
条件运算符	？：
对象运算符	.
下标运算符	[]
实例运算符	instanceof
内存分配运算符	new
强制类型转换运算符	(类型)
方法调用运算符	()

2、算数运算符

算术运算符	操作	范例	结果
+	正号	+3	3
-	负号	b=-4;-b	-4
+	加	5+5	10
-	减	3-2	1
*	乘	4*3	12
/	除	5/5	1
%	取模	10%9	1
++	自增（前）	a=2；b=++a	a=3，b=3
++	自增（后）	a=2；b=a++	a=3，b=2
--	自减（前）	a=2；b=--a	a=1，b=1
--	自减（后）	a=2；b=a--	a=1，b=2
+	字符串相加	“Hello”+“World”	“HelloWorld“

正负号（+，-）
int i = -1；
int j = 2；
/和%
/表示除法，如果两个数是整数，则值是商；如果有一个数是浮点数，则是简单意义上的数学除法。例如：
3/2=1
3.0/2=1.5
% 表示除法中的余数。例如：
5/2=2
5%2=1
++和–
++和–用法一样，只是一个是加法，一个是减法。
第一种情况
单独使用i++和++i。在该情况下将++放在操作数（例如i）的前面或者后面效果是一样的

public class Test01 {
	public static void main(String[] args) {
		int i = 5;
		i++;
		System.out.println(i);
	}
}
public class Test02 {
	public static void main(String[] args) {
		int i = 5;
		++i;
		System.out.println(i);
	}	
}

//在Test01()i=6
//在Test02()i=6

第二种情况
i++和++i参与运算。在该情况下：
(1)、将++放在操作数（例如i）的前面，那么i会先自增然后再参与运算
(2)、将++放在操作数（例如i）的后面，那么i会先参与运算然后再自增
++i表示先执行++运算改变变量值，再计算表达式；
i++表示先执行表达式计算，最后计算++改变变量值。

public static void main(String[] args) {
		int a = 4;
		int b = 3;
		int c = (a++) + b;
		System.out.println(c);
		
		int x = 4;
		int y = 3;
		int z = (++x) +y;
		System.out.println(z);
	}

除法运算和取模运算
根据计算的封闭性，除法运算中如果两个操作数都是int数据类型，那么计算结果也一定是int类型的数据。这时就会产生精度的丢失。
实例：

public static void main(String[] args) {
		/** 
		 *整数的除法运算结果也是整数，会丢弃余数
		 */
		int num1 =19;
		int num2 = 9;
		int num3 = num1/num2;
		System.out.println(num3);
//		取模运算（取余数）
		int num4 = num1 % num2;
		System.out.println(num4);
	}

Java中的运算规则
(1)、计算的封闭性（即：同一种数据类型参与运算，计算结果也是相同的数据类型）

int a = 5;
		int b = 2;
		int c = a/b;
		//结果为2
		System.out.println(c);
		double d = a/b;
		//原本结果为int类型的2.
		//但是，将结果赋值给了double类型的变量。所以，int转换为double；故，结果为2.0
	 	System.out.println(d);//结果为2.0

(2)、当byte，char，short类型的变量参与算数运算时，JVM会首先将byte，char，short处理成32位长再进一步操作；也就是说JVM会将byte，char，short变量转换为int类型再继续运算。

public class Test01 {
	public static void main(String[] args) {
		byte b1 = 3;
		byte b2 = 4;
//		Type mismatch: cannot convert from int to byte
//		byte b3 = b1 + b2;
		byte b3 = (byte)(b1 + b2);
		System.out.println("b3 = " + b3);
		int i = b1 + b2;
		System.out.println("i="+i);
	}
	
}


public class Test02 {
	public static void main(String[] args) {
		char ch = 'a';
		int i = 9;
		int result = ch + i;
		//输出结果：106
		System.out.println(result);
		int b = ch;
		//输出结果：97
		System.out.println(b);
	}
}

(3)、两个不同类型的操作数参与运算时，系统会将两者先统一为较大范围者的数据类型再进行计算
例如：

public class Test03 {
	public static void main(String[] args) {
		int i = 5;
		byte b = 7;
		//Type mismatch: cannot convert from int to byte
		//byte result = i + b;
		int result = i + b;
		System.out.println(result);
	}
}

3、赋值运算符

常见赋值运算符	格式	范例	结果
=	变量=表达式	a=3	将3赋值给变量a
+=	变量+=表达式	a+=3,即a=a+3	变量a加3,并赋值给a
-=	变量-=表达式	a-=3即a=a-3	变量a减3,并赋值给a
*=	变量*=表达式	a*=3即a=a*3	变量a乘3,并赋值给a
/=	变量/=表达式	a/=3即a=a/3	变量a除3,并赋值给a
%=	变量%=表达式	a%=3,即a=a%3	对a取模,并赋值给a

为变量赋值
基本的赋值运算符就是赋值，例如：int i = 1；
拓展赋值运算符如+=，-=，*=，/=，%=等。例如：
int a = 1;
a+=1;这句话相当于a=a+1;
注意：在使用拓展赋值运算符时会自动完成强制类转换

public static void main(String[] args) {
		short s = 9;
		int i = 7;
		//Type mismatch: cannot convert from int to short
		//s = s + i;
		//right code
		s+=1;
		System.out.println(s);
	}

变量赋值示例

public static void main(String[] args) {
		int x = 1;//声明int变量x，赋值1给变量x
		int y = 0;//声明int变量y，赋值0给变量y
		double area;//声明double变量area
		double radius = 1.0;//声明double变量radius，并赋值1.0给变量radius
		x = 5 * (3/2)+3*2;//将=右半部分表达式的计算结果赋值给变量x
		x = y + 1;//将变量y和1的求和的值赋值给变量x
		area = radius * radius * 3.14159;//将计算面积的值赋值给变量area
	}

练习：对两个变量的值进行互换

public static void main(String[] args) {
		int x = 3,y=6;
		int z;
		z = x;
		x = y;
		y = z;
		System.out.println("x=" + x);
		System.out.println("y=" + y);
	}

4、关系运算符

关系运算符	缩写	操作	范例	结果
<	LT	小于	4<3	false
<=	LE	小于等于	4<=3	false
>	GT	大于	4>3	true
>=	GE	大于等于	4>=3	true
==	EQ	等于	4==3	false
！=	NE	不等于	4！=3	true

关系运算符对数字型、、布尔型和引用类型有效。这种表达式的计算值是布尔值。
数字型：>,<,>=,<=,= =,!=
例如：3>2的值是true；3<=4的值为true；4= =5的值是false。
布尔型：= =，!=
例如：true= =false的值是false；（2>3）= =（3<4）的值是false。
引用类型：= =，!=
例如：引用类型的= =比较为true时，表示当前比较的两个变量指向同一个对象。
Integer a = new integer（1）；
Integer b = new integer（2）；
Integer c = a；
这时，a==c的值是true；a= =b的值是false。
5、逻辑运算符

逻辑运算符	操作	范例	结果
&	AND()逻辑与	false&true	false
|	OR()逻辑或	false|true	true
^	XOR()逻辑异或	true^true	true
!	NOT()逻辑非	!true	false
&&	AND()逻辑与，具有短路效果	false&&true	false
||	OR()逻辑或，具有短路效果	false||true	true

（1）&与

true & true = true

false & true = false

true & false = false

false & false = false

总结&符号特点
&：只要两边的boolean表达式结果，有一个false，那么结果就是false
只有两边都为true，结果为true。
（2）|或

true | true = true

false | true = true

true | false = true

false | false = false

总结|：两边只要有一个为真，结果就为真，当两边同为假时结果才为假。
（3）^异或

true ^ true = false

false ^ true = true

true ^ false = true

false ^ false = false

^：两边相同结果是false
两边不同结果是true；
（4）!非

!true =false

!false = true

（5）&&
&运算只有两边全为真的时候，结果才为真。其实，当左边为假的时候就没有必要再进行判断了，于是&&就产生了，这就是短路效果。
int a=4;
a>3&&a<6;
A>3&a<6;
在这种情况下是没有区别的
如果：
a=2
a>3&a<6 2大于3为假，接着运算2小于6为真，总的结果为假
a>3&&a<6;此时的a不大于3的结果为false右边不运算了。即短路。所以&&比&效率稍微高了一点。

public static void main(String[] args) {
		int x = 0;
		int y = 1;
		if(x == 0 && y == 1) {
			System.out.println(x+y);
		}
	}

“&”和“&&”的区别：单与时（&），左边无论真假，右边都进行运算；双与时（&&），如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别：双或时（||），左边为真右边不参与运算。
“^”异或和“|”的不同之处：当左右两边都为true时，结果为false。逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6,应该写成X>3&&x<6.
6、三元运算符
也称三目运算符
语法格式：条件表达式 ？ 表达式1 ： 表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
示例：
(1)获取两个数中的大数。
int x = 3,y = 4,z;
z = (x>y)?x:y;//变量存储的就是两个数的大数。

int x = 1;
int y = 2;
int z;
z = x > y ? x :y;
System.out.println(z);

(2)判断一个数是奇数还是偶数。

int x = 5;
System.out.println(x%2==0?"偶数":"奇数");

7、移位操作符
移位计算：>>,<<,>>>
（1）位运算符

运算符	运算	范例
<<	左移	3<<2=12-->3*2*2=12
>>	右移	3>>1=1-->3/2=1
>>>	无符号右移	3>>>1=1-->3/2=1
&	与运算	6 & 3 = 2
|	或运算	6 | 3 = 7
^	异或运算	6 ^ 3 = 5
~	反码	~6=-7

（2）位运算符的细节
左移 << 空位补0，被移除的高位丢弃，空缺位补0。
右移 >> 被移除的二进制最高位是0，右移后空缺位补0；最高位是1，空缺位补1。
无符号右移 >>>> 被移位二进制最高位无论是0或者是1，空缺都用0补。
与运算 & 二进制位进行&运算，只有1&1时结果是1，否则是0；
或运算 | 二进制位进行|运算，只有0|0时结果是0，否则是1；
异或运算 ^ 任何相同二进制位进行 ^ 运算，结果是0；1^ 1=0,0^ 0=0。不相同二进制^运算结果是1。1 ^ 0=1,0 ^ 1=1。
8、下标运算符[]
用于访问数组的值，通过下标索引进行访问。例如：
int[] array = new int[5];
array[1] = 2;
System.out.println(array[1]);
9、实例运算符instance of
用于判断对象实例是否由某个类创建，计算结果为布尔值。例如：
String hello = new String(“hello”);
If(hello instanceof String){ //这个表达式的值为true
……
}
10、强制类型转换运算符
用于数据类型的强制转换
(1)、数值间的转型
数值的表示范围是有区别的，从小的范围向大的范围转换是不需要强制转型，会自动转换，但是由大的范围向小的范围转换是需要强制转型，并且通常会损失精度。
int a = 10000;
Byte b = (byte)a; 现在b=1,这就是损失了精度。
(2)、对象间的转型
子类赋值给父类是不需要转型的，但是父类向子类赋值则是需要转型的。
Object类是所有Java的父类，即是根父类。
Object object = new String(“hello”);不需要转型
String string = （String）object; 需要强制转型