Java 入门指南（九）：运算符

本文是《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=(ca)`
`/=`	除和赋值	`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)`
`	=`	按位或赋值

实例：

示例代码：

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

实例：

示例代码（普通运算符）：

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。
`^`	如果相对应位值相同，则结果为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 类型，则会直接报错。

当 object 是 Class 或 Class 的子类或 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

注意事项：

object 是引用数据类型，不能是基本数据类型。
如果 object 为 null，则返回 false。

运算符优先级

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

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

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

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

Jianrry