赵雅智_java运算符与表达式

• 运算符

运算符：用于标记对数据执行某种运算的特定符号 。

操作数：参加运算的数据称为运算对象（操作数）。

分类

按运算符的功能 ：算术运算符、关系运算符、逻辑运算符、位运算符等。

按参与运算的操作数的个数：单目运算符、双目运算符、三目运算符。

• 算数运算符：

1. 单目运算符：+（1.计算 2.连接两个字符串）、—、*、/、%（1.整数取模 2.小数取-->模判断奇偶）
2. 双目运算符：+、-、++、--（++（--）运算符的操作数必须是变量）
3. char类型的数据可以进行算术运算，
4. boolean类型的数据不能进行算术运算。

自增自减运算符的使用

public class Testlncrement
{
	public static void main(String[] args)
	{
		int i = 9;
		int j;
		j = ++i;            //等价于 i=i+1;j=i;
		System.out.println("i=" + i + "\tj=" + j);
		j = i++;            //等价于 j=i;i=i+1;
		System.out.println("i=" + i + "\tj=" + j);
	}
}

输出结果：i=10,j=10;i=11,j=10

• 关系运算符

<、<=、>、>=、==、!=

判断两个操作数的等价性和大小关系，得到的结果为布尔类型。常用于逻辑判断（if或循环）。

关系运算符的使用

public class TestComparison
{
	public static void main(String[],args)
	int a = 4;
	int b = 6;
	if(a == b)
		System.out.println("a 等于 b");
	if(a != b)
		System.out.println("a 不等于 b");
	if(a > b)
		System.out.println("a 大于 b");
	if(a < b)
		System.out.println("a 小于 b");
	if(a >= b)
		System.out.println("a 大于等于 b");
	if(a <= b)
		System.out.println("a 小于等于 b");
}

输出结果：a不等于b，a小于b，a小于等于b。

• 逻辑运算符

&、|、!、^（抑或，不同真相同假）、[&&、||提高效率]

a	b	! a	a & b	a | b	a ^ b	a && b	a || b
true	true	false	true	true	false	true	true
true	false	false	false	true	true	false	true
false	true	true	false	true	true	false	true
false	false	true	false	false	false	false	false

逻辑运算符的使用。

public class TestBooleanOperator
{
	public static void main(String[] args)
	{
		boolean b1,b2;
	b2 = false;
	b1 = ! b2;
	System.out.println("逻辑值：b1=" + b1 + ",b2=" + b2);
	System.out.println("逻辑与：b1 & b2=" + (b1 & b2);
	System.out.println("逻辑或：b1 | b2=" + (b1 | b2);
	System.out.println("逻辑抑或：b1 ^ b2=" + (b1 ^ b2)");

	int x=3,y=9;
	b1 = x > y && x ++ == y --;
	System.out.println("短路与的结果：" + b1 + ",x = "+ x +",y=" + y);

	x=3;
	y=9;
	b2 = x > y & x ++ == y --;
	System.out.println("逻辑与的结果：" + b1 + ",x = "+ x +",y=" + y);
	}
}

输出结果：

逻辑值：b1=true,b2=false;

逻辑与：b1&b2=false;

逻辑或：b1|b2=true

逻辑抑或：b1^b2=true

短路与的结果：false,x=3,y=9

逻辑与的结果：false,x=4,y=8

• 位运算符

&、|、^、>>、<<、>>>、~

位运算符用来对整型（byte、short、int、long）或字符型（char）数据二进制位进行操作，结果为一个整数。

负数：将绝对值取反+1

15： 00000000 00000000 00000000 00001111

-15：11111111 11111111 11111111 11110001

～ （按位取反） ：将操作数a中的二进制位由1变0，由0变1。

& （按位相与） ：两个操作数的相应位都为1，则该位为1，否则为0。

>> （按位右移） ：将a右移b位，右端的低位被舍弃，左端高位补原来的符号位。

<< （按位左移） ：将a左移b位，右端的低位补0，左端的高位被舍弃。

>>>（无符号右移）：将a右移b位，右端的低位被舍弃，左端的高位补0。

注意：移位运算时真正的移位位数不一定是指定的b位。

当a为int型（或byte、short、char型）时，系统会先将b对32取模，得到的结果才是真正移位的位数

而当a为long型时，系统先将b对64取模，得到的结果作为真正的移位位数。

public class TestBitwiseOPerator
{
	public static void main(String[] args)
	{
		int a = 9 & 12;               	9：1001
		int b = 9 | 12;		        12：1100	
		int c = 9 ^ 12;			&：1000   8	
		int d = ~12;			|：1101   13
		System.out.print("9 & 12 =" + a);	^：0101   5
		System.out.print("9 & 12 =" + b);	~：1100  
		System.out.print("9 & 12 =" + c);	   0011
		System.out.print("9 & 12 =" + d);	   0010
	}					   1101   -13
}

输出结果：9 & 12 = 8，9 | 12 = 13，9 ^ 12 = 5，~ 12 = -13

public class TestMask
{
	public int getOneBit(int num,int n)//public static int getOneBit(int num,int n)
	{
		int i = 1 << (n - 1);
		int nb = num & i;
		return nb >> (n-1);
	}

	public static void main(String[] args)
	{
		int x = 9;
		TestMask obj = new TestMask();//
		System.out.print(obj.getOneBit(x,4));//System.out.println(TestMask.getOneBit(x,4));//System.out.println(getOneBit(x,4))
		System.out.print(obj.getOneBit(x,3));//System.out.println(TestMask.getOneBit(x,3));//System.out.println(getOneBit(x,3))
		System.out.print(obj.getOneBit(x,2));//System.out.println(TestMask.getOneBit(x,2));//System.out.println(getOneBit(x,2))
		System.out.println(obj.getOneBit(x,1));//System.out.println(TestMask.getOneBit(x,1));//System.out.println(getOneBit(x,1))
	}
}

输出结果：1001

分析：方法getOneBit()可以返回参数num的第n-1位。

• 赋值运算符

格式：变量(已声明)=表达式 double d = 7.8f; //合法 int a = 78L; //非法 int a = (int)78L; //合法 10 = i + j;//非法 i + j = 10; //非

当赋值运算符两侧的类型不一致时，如果左侧变量的数据类型的表示范围更大，则把右侧的数据自动转换为与左侧相同的数据类型，然后赋给左侧变量

否则，需要使用强制类型转换运算符。

复合的赋值运算符 +=、-=、*=、/=、%=、&=、|=、^=、 >>=、 <<= 、>>>=

• 条件运算符
  
  格式：表达式1 ？ 表达式2 ：表达式3（表达式1应是boolean类型的表达式；表达式2和表达式3的类型要一致。）

import javax.swing.JOptionPane;
public class TestConditionalOpreator
{
	public static void main(String[] args)
	{
		int score;
		score = Integer.parseInt(JOpionPane.showInputDialog("请输入百分制成绩："));
		String result = (score>=60)?"及格":"不及格";
		System.out.println(result);
	}
}

分析：
弹出输入对话框，接收用户输入： JOptionPane.showInputDialog(s)
将数字的字符串表示形式转换为整数：Integer.parseInt(s)
result = (score>=60) ? "及格" : "不及格"

• 表达式

表达式：若干操作数（operand）和运算符（operator）按照约定规则构成的一个序列。

运算符标明对操作数进行何种操作；

操作数可以是变量、常量或有返回值的方法调用等其他的表达式。

运算符优先级和结合方向 优先级 运算符 操作数 结合方向

1	[]、()
2	++、--、+(单目)、-(单目)、~、！、(强制类型转换)、new	单目	右-->左
3	*、/、%	双目	左-->右
4	+、=	双目	左-->右
5	<<、>>、>>>	双目	左-->右
6	<、<=、>、>=、instanceof	双目	左-->右
7	==、!=	双目	左-->右
8	&	双目	左-->右
9	^	双目	左-->右
10	|	双目	左-->右
11	&&	双目	左-->右
12	||	双目	左-->右
13	?:	三目	右-->左
14	=、+=、-=、*=、/=、^=、%=、&=、|=、<<=、>>=、>>>=	双目	右-->左

• 表达式中的数据类型转换

1. 自动类型转换
   为了保证精度，转换从表示数的范围较小的数据类型到表示数的范围较大的数据类型。
   （byte或short）和 int-->int
   （byte或short或int）和 long-->long
   （byte或short或int或long）和 float-->float
   （byte或short或int或long或float）和 double-->double
   char和int-->int
   箭头左边表示参与运算的数据类型，操作可以是算术运算、赋值运算等，箭头右边转换后进行运行的数据类型
   long longVar = 12345; double doubleVar = 1.2f;
   float f = 23456434563L;
   doubleVar = doubleVar * (12 + longVar);
   int a=doubleVar/100; //错，需使用强制类型转换
   注意：布尔类型不能与任何其它数据类型转换。
2. 强制类型转换
   （目标数据类型）变量或表达式 float)5 / 9 * (f - 32)
   注意：强制类型转换时，由于目标数据类型的取值范围小于待转换数据类型的取值范围，在转换过程中会出现截断，导致高位数据丢失或精度下降。

public class TypeConversion
{
	public static void main(String[],args)
	{
		int intVar = Oxff56;
		byte byteVar = (byte)intVar;
		System.out.println("intVar=" + Integer.toString(intVar,2) + ";" + intVar);
		System.out.println("byteVar=" + Integer.toString(byteVar,2) + ";" + intVar);
	}
}

结果：intVar=1111111101010110;65366;

byteVar=1010110;86;

将32位整数65366强制转换为byte型后，整数的高位被截掉，只剩下低8位，字节数据为86，导致数据丢失。

数值的类型转换。

public class TypeConversion
{
	public static void main(String[],args)
	{
		int i1 = 1234567891;
		float f = i1;			//合法，但任然可能存在精度损失
		System.out.println(f);
		double d1 = i1;			//合法，不存在精度损失
		System.out.println(d1);

		double d2 = 3.99;
		int i2 = (int)d2;
		System.out.println(i2);

		byte a = 37;			//合法
		byte b = 112;			//合法
		//byte c = 200;			//非法，超出范围
		//byte d = a + b;		//非法，可能存在精度损失
		int e = a + b;
		System.out.println(e);

		int k = 12;
		//byte b1 = k;			//非法，可能存在精度损失
	}
}

结果：1.23456794E9

1.234567891E9

3

149