本文是《Java 入门指南》的第九篇文章,介绍了 Java 的运算符。

算术运算符

描述:

Java 中的算术运算符,相当于数学中的算术运算符,有着同样的作用。

以下列举了全部的算术运算符(假设 a=10 b=20):

运算符 描述 例子
+ 加法 (a+b)=30
- 减法 (a-b)=-10
* 乘法 (a*b)=200
/ 除法(两数相除,向下取整) (a/b)=0
% 取余(模运算) (a%b)=10
++ 自增 (++a)=11
-- 自减 (--b)=19

实例:

示例代码(普通运算符):

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("(a%b)="+(a%b));

        System.out.println("(++a)="+(++a));

        System.out.println("(--b)="+(--b));


    }

}

运行结果(普通运算符):

(a+b)=30
(a-b)=-10
(a*b)=200
(a/b)=0
(a%b)=10
(++a)=11
(--b)=19

示例代码(自增自减运算符):

public class Test {

    public static void main(String[] args) {

        //定义一个变量 a, 类型为 int, 值为10。
        int a=10;

        //将 a 的值赋值给 b,此时 b 的值为10。然后 a 的值增加1,a 的值为11.
        int b=a++;

        //a 的值增加1,此时 a 的值为12。然后将 a 的值赋值给 c,c 的值为12。
        int c=++a;

        System.out.println("a="+a);

        System.out.println("b="+b);

        System.out.println("c="+c);

        //以此类推,定义一个变量 d, 类型为 int, 值为10。
        int d=10;

        //将 d 的值赋值给 e,此时 e 的值为10。然后 d 的值减少1,d 的值为9.
        int e=d--;

        //d 的值减少1,此时 d 的值为8。然后将 d 的值赋值给 f,f 的值为8。
        int f=--d;

        System.out.println("d="+d);

        System.out.println("e="+e);

        System.out.println("f="+f);
        
    }

}

运算结果(自增自减运算符):

a=12
b=10
c=12
d=8
e=10
f=8

赋值运算符

描述:

以下列举了全部的赋值运算符:

运算符 描述 例子
= 赋值 c=(a+b)
+= 加和赋值 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)

实例:

示例代码:

public class Test {

    public static void main(String[] args) {

        int a=10;

        int b=20;

        int c=0;

        System.out.println("c=a+b 等于 "+(c=a+b));
        c=0;

        System.out.println("c+=a 等于 "+(c+=a));
        c=0;

        System.out.println("c-=a 等于 "+(c-=a));
        c=0;

        System.out.println("c*=a 等于 "+(c*=a));
        c=0;

        System.out.println("c/=a 等于 "+(c/=a));
        c=0;

        System.out.println("c%=a 等于 "+(c%=a));
        c=0;

        System.out.println("c<<=2 等于 "+(c<<=2));
        c=0;

        System.out.println("c>>=2 等于 "+(c>>=2));
        c=0;

        System.out.println("c&=2 等于 "+(c&=2));
        c=0;

        System.out.println("c^=2 等于 "+(c^=2));
        c=0;

        System.out.println("c|=2 等于 "+(c|=2));
        c=0;


    }

}

运行结果:

c-=a 等于 -10
c*=a 等于 0
c/=a 等于 0
c%=a 等于 0
c<<=2 等于 0
c>>=2 等于 0
c&=2 等于 0
c^=2 等于 2
c|=2 等于 2

关系运算符

描述:

以下列举了全部的关系运算符(假设 a=10 b=20):

运算符 描述 例子
> 大于 (a>b)=false
>= 大于等于 (a>=b)=false
< 小于 (a<b)=true
<= 小于等于 (a<=b)=true
== 等于 (a==b)=false
!= 不等于 (a!=b)=true

实例:

示例代码:

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("(a==b)="+(a==b));

        System.out.println("(a!=b)="+(a!=b));

    }

}

运行结果:

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

逻辑运算符

描述:

以下列举了全部的逻辑运算符(假设 a=true b=false):

运算符 描述 例子
&& (a && b)=false
|| (a || b)=true
! !(a || b)=false

实例:

示例代码(普通运算符):

public class Test {

    public static void main(String[] args) {

        boolean a=true;

        boolean b=false;

        System.out.println("(a && b)="+(a && b));

        System.out.println("(a || b)="+(a || b));

        System.out.println("!(a || b)="+!(a || b));

    }

}

运行结果(普通运算符):

(a && b)=false
(a || b)=true
!(a || b)=false

示例代码(短路运算符):

public class Test {

    public static void main(String[] args) {

        //定义一个变量 a, 类型为 int, 值为10。
        int a=10;

        //(a<9)=false,则 b=false。此时 (a++>10) 不会执行,所以 a=10。
        boolean b=(a<9) && (a++>10);

        System.out.println("a="+a);

        System.out.println("b="+b);

    }

}

运行结果(短路运算符):

a=10
b=false

位运算符

描述:

位运算符,适用于 byte(字节型)、short(短整型)、int(整数型)、long(长整型)、char(字符型)等类型。

假设 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 << 2)=1111 0000

(a >> 2)=1111

(a >>> 2)=0000 1111
运算符 描述 例子
& 如果相对应位都是1,则结果为1,否则为0。 (a & b)=0000 1100 即 12
| 如果相对应位都是 0,则结果为 0,否则为1。 (a | b)=0011 1101 即 61
^ 如果相对应位值相同,则结果为0,否则为1。 (a ^ b)=0011 0001 即 49
按位取反运算符翻转操作数的每一位,即0变成1,1变成0。 (~a)=1100 0011 即 -61
<< 按位左移运算符。左操作数按位左移右操作数指定的位数。 (a << 2)=1111 0000 即 240
>> 按位右移运算符。左操作数按位右移右操作数指定的位数。 (a >> 2)=1111 即 15
>>> 按位右移补零操作符。左操作数的值按右操作数指定的位数右移,移动得到的空位以零填充。 (a >>> 2)=0000 1111 即 15

实例:

示例代码:

public class Test {

    public static void main(String[] args) {

        //a=0011 1100
        int a=60; 

         //b=0000 1101
        int b=13;

        //(a & b)=0000 1100
        System.out.println("(a & b)="+(a & b)); 

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

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

         //(~a)=1100 0011
        System.out.println("(~a)="+(~a));

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

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

         //(a >>> 2)=0000 1111
        System.out.println("(a >>> 2)="+(a >>> 2));


    }

}

运行结果:

(a & b)=12
(a | b)=61
(a ^ b)=49
(~a)=-61
(a << 2)=240
(a >> 2)=15
(a >>> 2)=15

示例代码:

public class Test {

    public static void main(String[] args) {

        // 二进制数   十进制数
        // 0000 0000 0
        // 0000 0001 1
        // 0000 0010 2
        // 0000 0011 3
        // 0000 0100 4
        // 0000 0101 5
        // 0000 0110 6
        // 0000 0111 7
        // 0000 1000 8

        //由此可见,向左移动 1 位,值乘以 2。反之,值除以 2。
        //以此类推,8=2*2*2 等价于 2 向左移动 2 位。
        //虽然这两种方式得出的结果相同,但是 2 向左移动 2 位的方式效率更高。

        System.out.println(2*2*2);

        System.out.println(2 << 2);

    }

}

运行结果:

8
8

条件运算符(三元运算符)

描述:

条件运算符,又被称为三元运算符。

variable x = (expression) ? value if true : value if false

实例:

示例代码:

public class Test {

    public static void main(String[] args) {

        int a=10;

        int b=20;
        
        int c=0;

        // 如果 (a>b)=true,则将 a 赋值给 c。否则,则将 b 赋值给 c。
        c=(a>b) ? a : b;

        System.out.println("c="+c);


    }

}

运行结果:

c=20

instanceof

描述:

instanceof 是一个二元运算符,判断一个对象是否是一个类的实例,返回一个 boolean 类型的数据。

object instanceof Class

左边的 object 是一个对象,右边的 Class 是一个类或接口。

如果左边的 object 无法转换为右边的 Class 类型,则会直接报错。

objectClassClass 的子类 或 Class 的接口实现类的对象时,返回 true,否则返回 false

实例:

示例代码:

package com.jianrry.oop;

public class Animal {

}
package com.jianrry.oop;

public class Cat extends Animal {

}
package com.jianrry.oop;

public class Application {

    public static void main(String[] args) {

        Cat cat=new Cat();

        System.out.println(cat instanceof Cat);

        System.out.println(cat instanceof Animal);

        System.out.println(cat instanceof Object);

        System.out.print("\n");

        Animal animal=new Animal();

        System.out.println(animal instanceof Cat);

        System.out.println(animal instanceof Animal);

        System.out.println(animal instanceof Object);

    }

}

运行结果:

true
true
true

false
true
true

注意事项:

  1. object 是引用数据类型,不能是基本数据类型。
  2. 如果 objectnull,则返回 false

运算符优先级

运算符优先级分为 14 级,其中 1 最高,14 最低。

在同一个表达式中,先执行优先级高的,然后再执行优先级低的。

以下列举了全部运算符的优先级和结合性:

优先级 运算符 结合性
1 ()、[]、{} 从左向右
2 !、+、-、~、++、-- 从右向左
3 *、/、% 从左向右
4 +、- 从左向右
5 «、»、>>> 从左向右
6 <、<=、>、>=、instanceof 从左向右
7 ==、!= 从左向右
8 & 从左向右
9 ^ 从左向右
10 | 从左向右
11 && 从左向右
12 || 从左向右
13 ? : 从右向左
14 =、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>= 从右向左