5）java运算符

java运算符

• 算术运算符
• 关系运算符
• 位运算符
• 逻辑运算符
• 赋值运算符
• 其他运算符

算术运算符

操作符	描述
+	加
_	减
*	乘
/	除
%	求余
++	自增
–	自减

自增自减法解释：

• 前缀自增自减法(++a,–a): 先进行自增或者自减运算，再进行表达式运算。
• 后缀自增自减法(a++,a–): 先进行表达式运算，再进行自增或者自减运算。

public class selfAddMinus{
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        int b = 5;
        int x = 2*++a;
        int y = 2*b++;
        System.out.println("自增运算符前缀运算后a="+a+",x="+x);
        System.out.println("自增运算符后缀运算后b="+b+",y="+y);
    }
}

结果：

自增运算符前缀运算后a=6，x=12
自增运算符后缀运算后b=6，y=10

关系运算符

操作符	描述
==	等于
!=	不等于
>	大于
<	小于
>=	大于等于
<=	小于等于

public class Test {
 
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     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("b >= a = " + (b >= a) );
     System.out.println("b <= a = " + (b <= a) );
  }
}

结果：

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

位运算符

十进制：A=60；B=13
二进制：A=0011 1100；B=0000 1101

操作符	描述	例子
＆	如果相对应位都是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

逻辑运算符
A:真
B:假

操作符	描述	例子
&&	逻辑与。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
| |	逻辑或。如果任何两个操作数任何一个为真，条件为真。	（A || B）为真。
！	逻辑非。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

赋值运算符

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	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

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

public class Test {
   public static void main(String[] args){
      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 );
   }
}

结果：

Value of b is : 30
Value of b is : 20

instanceof 运算符

• 该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
• instanceof运算符使用格式如下：
  ( Object reference variable ) instanceof (class/interface type)
  如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。

下面是一个例子：

String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

如果被比较的对象兼容于右侧类型,该运算符仍然返回true。

看下面的例子：

class Vehicle {}
public class Car extends Vehicle {
   public static void main(String[] args){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result);
   }
}

以上实例编译运行结果如下：

true

实例一、
在判断一个实例引用的类型时，使用的是实际类型，而不是声明的类型。在下面的代码中，
Vehicle v2 = new Car(); // v2 是 Car 类型
v2 是 Car 类型，而不是 Vehicle 类型。

class Vehicle {}

public class Car extends Vehicle {
    public static void main(String args[]){
        Car c1 = new Car();

        Vehicle v2 = new Car();    // v2 是 Car 类型
        Vehicle v3 = new Vehicle();

        //Car 是 Vehicle类型, Vehicle 不是 Car 类型
        boolean result1 =  c1 instanceof Vehicle;    // true
        boolean result2 =  v2 instanceof Car;        // true
        boolean result3 =  v2 instanceof Vehicle;    // true
        boolean result4 =  v3 instanceof Car;          // false

        System.out.println(result1);
        System.out.println(result2);
        System.out.println(result3);
        System.out.println(result4);
   }
}

实例二、
子类是父类的类型，但父类不是子类的类型。
子类的实例可以声明为父类型，但父类的实例不能声明为子类型。

class Vehicle {}

public class Car extends Vehicle {
    public static void main(String args[]){
        Vehicle v1 = new Vehicle(); //父类型
        Vehicle v2 = new Car(); //子类的实例可以声明为父类型
        Car c1 = new Car();    // 子类型
        Car c2 = new Vehicle(); //这句会报错，父类型的实例不能声明为子类型

        //Car（子类）是Vehicle（父类）类型, Vehicle（父类）不是Car（子类）类型
        boolean result1 =  c1 instanceof Vehicle;    // true
        boolean result2 =  c1 instanceof Car;        // true
        boolean result3 =  v1 instanceof Vehicle;    // true
        boolean result4 =  v1 instanceof Car;          // false
        boolean result5 =  v2 instanceof Vehicle;    // true
        boolean result6 =  v2 instanceof Car;          // true

        System.out.println(result1);
        System.out.println(result2);
        System.out.println(result3);
        System.out.println(result4);
        System.out.println(result5);
        System.out.println(result6);
   }
}

从执行结果来看，虽然 v2 被声明为了 Vehicle（父类），但它既是 instanceof Vehicle，又是 instanceof Car，所以 v2 其实是 Car（子类），否则 v2 instanceof Car 应该为 false。

运算符优先级

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。（"、"为分隔符）

类别	操作符	关联性
后缀	()、 []、 . (点操作符)	左到右
一元	+(正)、 -（负）、 ++、–、 ！、〜	从右到左
乘性	*、 /、％	左到右
加性	+ 、-	左到右
移位	>> 、>>>、 <<	左到右
关系	>> = 、<< =	左到右
相等	== 、 !=	左到右
按位与	＆	左到右
按位异或	^	左到右
按位或	|	左到右
逻辑与	&&	左到右
逻辑或	||	左到右
条件	？：	从右到左
赋值	=、+ =、 - =、 * =、 / =、％= 、>> =、 << =、＆=、 ^ =、 | =	从右到左
逗号	，	左到右