中科因仑“3+1”工程特种兵精英论坛

标题: 【Java学习】6、Java运算符 [打印本页]
作者: dong    时间: 2018-4-28 16:07
标题: 【Java学习】6、Java运算符
6、Java运算符一、算术运算符
算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。

表格中的实例假设整数变量A的值为10，变量B的值为20：
操作符
解释
例子
+
加法 - 相加运算符两侧的值
A+B=30
-
减法 - 左操作数减去右操作数
B-A=10
*
减法 - 左操作数减去右操作数
A*B=200
/
除法 - 左操作数除以右操作数
B/A=2
%
取模 - 左操作数除以右操作数的余数
B%A=0
++
自增: 操作数的值增加1
B++和++B都等于21
--
自减: 操作数的值减少1
B- -和- -B都等于19

实例
    /**
    *算术运算符
    */
    private static void arithmetic() {
       int a = 10;
       int b = 20;
       int c = 25;
       int d = 40;
       System.out.println("a + b = "+ (a + b));// 加法
       System.out.println("a - b = "+ (a - b));// 减法
       System.out.println("a * b = "+ (a * b));// 乘法
       System.out.println("b / a = "+ (b / a));// 除法
       System.out.println("c % a = "+ (c % a));// 求余
       System.out.println("a + + = "+ (a++));// 自加
       System.out.println("a - - = "+ (a--));// 自减
       //查看d++和d--的区别
       System.out.println("+ + d = "+ (++d));
       System.out.println("d + + = "+ (d++));
    }
结果输出
       略

自增自减运算符
       自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。新建方法selfAddMinus()
实例
    /**
    * 自增自减运算符 特殊的算术运算符
    */
    privatestatic voidselfAddMinus() {
       inta = 5;// 定义一个变量
       intb = ++a;// 进行自增运算
       intc = 10;
       intd = --c;// 进行自减运算
       System.out.println("进行自增运算后的值= "+ b);
       System.out.println("进行自减运算后的值= "+ d);
    }
运行结果
       略

解释
       intb = ++a; 拆分运算过程为:a=a+1=6; b=a=6, 最后结果为b=6,a=6
int d = --c; 拆分运算过程为: c=c-1=9; d=c=9, 最后结果为d=9,c=9

前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算。
实例：
/**
    * 自增自减运算符 特殊的算术运算符
    */
    privatestatic voidselfAddMinus() {
       inte = 5;// 定义一个变量；
       intf = 5;
       intx = 2 * ++e;
       inty = 2 * f++;
       System.out.println("自增运算符前缀运算后a=" + e + ",x="+ x);
       System.out.println("自增运算符后缀运算后b=" + f + ",y="+ y);
    }
运行结果
       略
二、关系运算符
下表为Java支持的关系运算符，表格中的实例整数变量A的值为10，变量B的值为20。
运算符
描述
例子
==
检查如果两个操作数的值是否相等，如果相等则条件为真。
（A == B）为假(非真)。
!=
检查如果两个操作数的值是否相等，如果值不相等则条件为真。
(A != B) 为真。
>
检查左操作数的值是否大于右操作数的值，如果是那么条件为真。
（A> B）非真。
<
检查左操作数的值是否小于右操作数的值，如果是那么条件为真。
（A <B）为真。
>=
检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。
（A> = B）为假。
<=
检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。
（A <= B）为真。

实例
    /**
    * 关系运算符
    */
    private static void relationship(){
       int a = 10;
       int b = 15;
       System.out.println("a == b = " + (a == b));
       System.out.println("a != b = " + (a != b));
       System.out.println("a > b = " + (a > b));
       System.out.println("a < b = " + (a < b));
       System.out.println("a >= b = " + (a >= b));
       System.out.println("a <= b = " + (a <= b));
    }
运行结果
       略
三、位运算符
Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。
位运算符作用在所有的位上，并且按位运算。假设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

操作符
描述
例子
＆
如果相对应位都是1，则结果为1，否则为0
（A＆B），得到12，即0000 1100
|
如果相对应位都是0，则结果为0，否则为1
（A | B）得到61，即 0011 1101
^
如果相对应位值相同，则结果为0，否则为1
（A ^ B）得到49，即 0011 0001
?
按位补运算符翻转操作数的每一位，即0变成1，1变成0。
（?A）得到-61，即1100 0011
<<
按位左移运算符。左操作数按位左移右操作数指定的位数。
A << 2得到240，即 1111 0000
>>
按位右移运算符。左操作数按位右移右操作数指定的位数。
A >> 2得到15即 1111
>>>
按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。
A>>>2得到15即0000 1111

实例
    /**
    * 位运算符
    */
    private static void bitOperator() {
       int a = 60;/* 60 = 0011 1100 */
       int b = 13;/* 13 = 0000 1101 */
       int c = 0;
       c = a &b; /* 12 = 0000 1100 */
       System.out.println("a & b = " + c);

       c = a | b; /* 61 = 0011 1101 */
       System.out.println("a | b = " + c);

       c = a ^ b; /* 49 = 0011 0001 */
       System.out.println("a ^ b = " + c);

       c = ~a; /*-61 = 1100 0011 */
       System.out.println("~a = " + c);

       c = a<< 2; /* 240 = 1111 0000 */
       System.out.println("a << 2 = " + c);

       c = a>> 2; /* 15 = 1111 */
       System.out.println("a >> 2  = " + c);

       c = a>>> 2; /* 15 = 0000 1111 */
       System.out.println("a >>> 2 = " + c);
    }
运行结果
       略
四、逻辑运算符
下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假
操作符
描述
例子
&&
称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。
（A && B）为假。
| |
称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。
（A | | B）为真。
！
称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。
！（A && B）为真。

实例
    /**
    * 逻辑运算符
    */
    privatestatic voidlogicalOperators() {
       booleana = true;
       booleanb = false;
       System.out.println("a && b = " + (a && b));
       System.out.println("a || b = " + (a|| b));
       System.out.println("!(a && b) = " + !(a && b));
    }
运算结果
       略
短路逻辑运算符
当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。
实例
    /**
    * 逻辑运算符
    */
    privatestatic voidlogicalOperators() {
       intc = 5;// 定义一个变量；
       booleand = (c< 4) && (c++ < 10);
       System.out.println("使用短路逻辑运算符的结果为" + d);
       System.out.println("c的结果为" + c);
    }
运行结果
       略
       解析：该程序使用到了短路逻辑运算符(&&)，首先判断 a<4 的结果为 false，则 b 的结果必定是 false，所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5
五、赋值运算符
下面是Java语言支持的赋值运算符：
操作符
描述
例子
=
简单的赋值运算符，将右操作数的值赋给左侧操作数
C = A + B将把A + B得到的值赋给C
+ =
加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数
C + = A等价于C = C + A
- =
减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数
C - = A等价于C = C -
   A
* =
乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数
C * = A等价于C = C * A
/=
除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数
C / = A等价于C = C / A
（％）=
取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数
C％= A等价于C = C％A
<< =
左移位赋值运算符
C << = 2等价于C = C << 2
>> =
右移位赋值运算符
C >> = 2等价于C = C >> 2
＆=
按位与赋值运算符
C＆= 2等价于C = C＆2
^ =
按位异或赋值操作符
C ^ = 2等价于C = C ^ 2
| =
按位或赋值操作符
C | = 2等价于C = C | 2

实例
    /**
    * 赋值运算符
    */
    privatestatic voidassignmentOperator() {
       inta = 10;
       intb = 20;
       intc = 0;
       c = a + b;
       System.out.println("c = a + b = " + c);
       c += a;
       System.out.println("c += a  = " + c);
       c -= a;
       System.out.println("c -= a = " + c);
       c *= a;
       System.out.println("c *= a = " + c);
       a =10;
       c =15;
       c /= a;
       System.out.println("c /= a = " + c);
       a =10;
       c =15;
       c %= a;
       System.out.println("c %= a  = " + c);
       c<<= 2;
       System.out.println("c <<= 2 = " + c);
       c>>= 2;
       System.out.println("c >>= 2 = " + c);
       c>>= 2;
       System.out.println("c >>= a = " + c);
       c&= a;
       System.out.println("c &= 2  = " + c);
       c ^= a;
       System.out.println("c ^= a   = " + c);
       c |= a;
       System.out.println("c |= a   = " + c);
    }
运行结果
       略

六、其他运算符1、条件运算符-重点
条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
variable x = (expression) ? value if true : value iffalse

实例
/**
    * 条件运算符
    */
    private static voidconditionalOperators() {
       int a, b;
       a = 10;
       // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
       b = (a== 1) ? 20 : 30;
       System.out.println("Value of b is : " + b);

       // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
       b = (a== 10) ? 20 : 30;
       System.out.println("Value of b is : " + b);
    }
运行结果
       略
2、instanceof运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。instanceof运算符使用格式如下：
( Object reference variable ) instanceof  (class/interface type)

如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真，下面是一个例子：
String name ="James";
boolean result =name instanceof String; // 由于 name 是 String 类型，所以返回真
如果被比较的对象兼容于右侧类型,该运算符仍然返回true。
实例
    /**
    * instanceof运算符
    */
    privatestatic voidinstanceofOperators() {
       String str= "Hello";
       booleanresult = strinstanceof String;// 由于 name 是 String 类型，所以返回真
       System.out.println(result);
    }
运行结果
       略






欢迎光临 中科因仑“3+1”工程特种兵精英论坛 (http://bbs.enlern.com/) Powered by Discuz! X3.4