java c 运算符_Java基本运算符

转自原文：http://www.yiibai.com/java/java_basic_operators.html

Java提供了一组运算符丰富的操纵变量。我们可以把所有的Java操作符为以下几组：

算术运算符

关系运算符

位运算符

逻辑运算符

赋值运算符

其它运算符

算术运算符：

算术运算符用于在数学表达式中，他们是在代数中使用的方法相同。下表列出了算术运算符：

假设整型变量A=10和变量B=20，则：

运算符描述实例

+

Addition - Adds values on either side of the operator

A + B = 30

-

Subtraction - Subtracts right hand operand from left hand operand

A - B = -10

*

Multiplication - Multiplies values on either side of the operator

A * B = 200

/

Division - Divides left hand operand by right hand operand

B / A = 2

%

Modulus - Divides left hand operand by right hand operand and returns remainder

B % A = 0

++

Increment - Increases the value of operand by 1

B++ =21

--

Decrement - Decreases the value of operand by 1

B-- =19

关系运算符：

有下列由Java语言支持的关系运算符

假设变量A=10和变量B=20，则：

运算符描述实例

==

Checks if the values of two operands are equal or not, if yes then condition becomes true.

(A == B) is not true.

!=

Checks if the values of two operands are equal or not, if values are not equal then condition becomes true.

(A != B) is true.

>

Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true.

(A > B) is not true.

<

Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true.

(A < B) is true.

>=

Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true.

(A >= B) is not true.

<=

Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true.

(A <= B) is true.

按位运算符：

Java定义了几个位运算符，它可以应用到整数类型，长型，整型，短整型，字符和字节。

位运算符作用于位，并执行逐位操作。假设当a =60和b= 13; 现在以二进制格式，他们将会如下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

下表列出了按位运算符：

假设整型变量A=60和变量B=13，则：

运算符描述实例

&

Binary AND Operator copies a bit to the result if it exists in both operands.

(A & B) will give 12 which is 0000 1100

|

Binary OR Operator copies a bit if it exists in either operand.

(A | B) will give 61 which is 0011 1101

^

Binary XOR Operator copies the bit if it is set in one operand but not both.

(A ^ B) will give 49 which is 0011 0001

~

Binary Ones Complement Operator is unary and has the effect of 'flipping' bits.

(~A ) will give -61 which is 1100 0011 in 2's complement form due to a signed binary number.

<<

Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand.

A << 2 will give 240 which is 1111 0000

>>

Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand.

A >> 2 will give 15 which is 1111

>>>

Shift right zero fill operator. The left operands value is moved right by the number of bits specified by the right operand and shifted values are filled up with zeros.

A >>>2 will give 15 which is 0000 1111

逻辑运算符：

下表列出了逻辑运算符：

假设布尔变量A=ture，变量B=false，那么：

运算符描述实例

&&

Called Logical AND operator. If both the operands are non-zero, then the condition becomes true.

(A && B) is false.

||

Called Logical OR Operator. If any of the two operands are non-zero, then the condition becomes true.

(A || B) is true.

!

Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false.

!(A && B) is true.

赋值运算符：

有下列由Java语言支持赋值操作符：

运算符描述实例

=

Simple assignment operator, Assigns values from right side operands to left side operand

C = A + B will assign value of A + B into C

+=

Add AND assignment operator, It adds right operand to the left operand and assign the result to left operand

C += A is equivalent to C = C + A

-=

Subtract AND assignment operator, It subtracts right operand from the left operand and assign the result to left operand

C -= A is equivalent to C = C - A

*=

Multiply AND assignment operator, It multiplies right operand with the left operand and assign the result to left operand

C *= A is equivalent to C = C * A

/=

Divide AND assignment operator, It divides left operand with the right operand and assign the result to left operand

C /= A is equivalent to C = C / A

%=

Modulus AND assignment operator, It takes modulus using two operands and assign the result to left operand

C %= A is equivalent to C = C % A

<<=

Left shift AND assignment operator

C <<= 2 is same as C = C << 2

>>=

Right shift AND assignment operator

C >>= 2 is same as C = C >> 2

&=

Bitwise AND assignment operator

C &= 2 is same as C = C & 2

^=

bitwise exclusive OR and assignment operator

C ^= 2 is same as C = C ^ 2

|=

bitwise inclusive OR and assignment operator

C |= 2 is same as C = C | 2

其它运算符

Java 语言支持一些其他的运算符。

条件运算符 ( ? : ):

条件运算符也被称为三元运算符。该运算符包括三个操作数，用于评估计算布尔表达式。此运算符的目标是确定哪些值应分配给该变量。可写为：

variable x =(expression)?value iftrue:value iffalse

下面是例子：

publicclassTest{publicstaticvoidmain(Stringargs[]){inta ,b;a =10;b =(a ==1)?20:30;System.out.println("Value of b is : "+b );b =(a ==10)?20:30;System.out.println("Value of b is : "+b );}}

这将产生以下结果：

Valueof b is:30Valueof b is:20

instanceof运算符：

这个操作符只用于对象引用变量。操作检查对象是否为特定类型(类类型或接口类型)。instanceof 运算符被写为：

(Objectreference variable )instanceof(class/interfacetype)

如果运算符的左侧提到的变量的对象传递了IS-A检查右侧的类/接口类型，那么结果将为 true。下面是例子：

publicclassTest{publicstaticvoidmain(Stringargs[]){Stringname ="James";// following will return true since name is type of Stringbooleanresult =name instanceofString;System.out.println(result );}}

这将产生以下结果：

true

这个操作符仍然会返回true，如果被比较的对象是分配在右侧的类型兼容。下面是一个例子：

classVehicle{}publicclassCarextendsVehicle{publicstaticvoidmain(Stringargs[]){Vehiclea =newCar();booleanresult =a instanceofCar;System.out.println(result );}}

这将产生以下结果：

true

优先级的Java操作符：

运算符优先级决定的条件在表达式中分组。这会影响一个表达式如何计算。某些运算符的优先级高于其它，例如，乘法运算符的优先级比加法运算高：

例如x= 7+3* 2;这里x被赋值13，而不是20，因为运算符*的优先级高于+，所以它首先被乘以3 * 2，然后加7。

这里，具有最高优先级的操作出现在表格上方，那些具有最低出现在底部。在表达式中，优先级较高的运算符将首先评估计算。

分类运算符关联

Postfix

() [] . (dot operator)

Left to right

Unary

++ - - ! ~

Right to left

Multiplicative

* / %

Left to right

Additive

+ -

Left to right

Shift

>> >>> <<

Left to right

Relational

> >= < <=

Left to right

Equality

== !=

Left to right

Bitwise AND

&

Left to right

Bitwise XOR

^

Left to right

Bitwise OR

|

Left to right

Logical AND

&&

Left to right

Logical OR

||

Left to right

Conditional

?:

Right to left

Assignment

= += -= *= /= %= >>= <<= &= ^= |=

Right to left

Comma

,

Left to right