JAVA java学习（25）——————java运算符详解_java双目运算

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。

Java 语言中的运算符除了具有优先级之外，还有一个结合性的特点。当一个表达式中出现多种运算符时，执行的先后顺序不仅要遵守运算符优先级别的规定，还要受运算符结合性的约束，以便确定是自左向右进行运算还是自右向左进行运算。这些运算符按照操作数的数量可以分为单目运算符、双目运算符和三目运算符。

1.运算符的分类

1.算术运算符：+、 - 、 * 、 / 、 % 、++、--
2.赋值运算符：= 、 += 、 -= 、 *= 、 /= 、 %=、<< =、>> =、＆=、^ =、| =
3.关系运算符：>、<、>= 、<= 、 == 、 !=
4.逻辑运算符：! 、&、 | 、 ^ 、&&、 ||
5.位运算符：&、 | 、 ^ 、 ~ 、>>、<<、>>>(了解)
6.字符串连接运算符：+
7.三目运算符 ?:

2.算术运算符

Java 中的算术运算符主要用来组织数值类型数据的算术运算，按照参加运算的操作数的不同可以分为一元运算符和二元运算符。

2.1一元运算符

算术一元运算一共有 3 个，分别是 -、++ 和 --。具体说明参见表 1。

表 1 中，-a 是对 a 取反运算，a++ 或 a-- 是在表达式运算完后，再给 a 加一或减一。而 ++a 或 --a 是先给 a 加一或减一，然后再进行表达式运算。
例1：

    int a = 12;
    System.out.println(-a);
    int b = a++;
    System.out.println(b);
    b = ++a;
    System.out.println(b);
1
2
3
4
5
6

上述代码第 2 行是 -a，是把 a 变量取反，结果输出是 -12。第 4 行代码是先把 a 赋值给 b 变量再加一，即先赋值后 ++，因此输出结果是 12。第 6 行代码是把 a 加一，然后把 a 赋值给 b 变量，即先 ++ 后赋值，因此输出结果是 14。

关于 ++ 和 --，可直接参考JAVA java学习（26）——————java自增和自减运算符（++和–）一节。

2.2二元运算符

Java 语言中算术运算符的功能是进行算术运算，除了经常使用的加（+）、减（-）、乘（*）和除（\）外，还有取余运算（％）。加（+）、减（-）、乘（*）、除（\）和我们平常接触的数学运算具有相同的含义。
具体说明参见表 2。

算术运算符都是双目运算符，即连接两个操作数的运算符。优先级上，*、/、％ 具有相同运算级别，并高于 +、-（+、- 具有相同级别）。

例1：

int a = 4, b = 2, c = 3;
int d = a * (b + c) % c;
1
2

这种运算规则与数学运算中的规则是相同的。首先计算赋值符号（=）右边配对的括号内的值，其次按从左向右的结合方向计算乘法，最后做求余运算，表达式的结果为 2， 然后把 2 赋值给 d。

例2：
①int x=2,y=1; 表达式 y/x 的结果是 0。
②float x=2.0f; int y=1; 表达式 y/x 的结果是 0.5。

在 ① 中整型变量 x 和 y 相除，其结果仍为整型数据 0；在 ② 中由于两个不同类型的数据进行运算，此时首先要进行类型转换，会把 int 型的 y 转换成与 x 一样的 float 型，然后相除，最终结果为 float 类型的数字 0.5。

例3：下面的简单示例程序演示了算术运算符。

public class Test {

  public static void main(String args[]) {
     int a = 10;
     int b = 20;
     int c = 25;
     int d = 25;
     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) );
     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) );
  }
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

例4：编写一个程序，输出不同类型的两个数，执行相加、相减、相乘、相除和求余后输入结果。
实现代码如下：

public static void main(String[] args) {
    float f1 = 9 % 4;// 保存取余后浮点类型的结果
    double da = 9 + 4.5; // 双精度加法
    double db = 9 - 3.0; // 双精度减法
    double dc = 9 * 2.5; // 双精度乘法
    double dd = 9 / 3.0; // 双精度除法
    double de = 9 % 4; // 双精度取余

    System.out.println("整数的算术运算"); // 整数的加、减、乘、除和取余
    System.out.printf("9+4=%d \n", 9 + 4);
    System.out.printf("9-4=%d \n", 9 - 4);
    System.out.printf("9*4=%d \n", 9 * 4);
    System.out.printf("9/4=%d \n", 9 / 4);
    System.out.printf("9%%4=%d \n", 9 % 4);

    System.out.println("\n浮点数的算术运算"); // 浮点数的加、减、乘、除和取余
    System.out.printf("9+4.5f=%f \n", 9 + 4.5f);
    System.out.printf("9-3.0f=%f \n", 9 - 3.0f);
    System.out.printf("9*2.5f=%f \n", 9 * 2.5f);
    System.out.printf("9/3.0f=%f \n", 9 / 3.0f);
    System.out.printf("9%%4=%f \n", f1);

    System.out.println("\n双精度数的算术运算"); // 双精度数的加、减、乘、除和取余
    System.out.printf("9+4.5=%4.16f \n", da);
    System.out.printf("9-3.0=%4.16f \n", db);
    System.out.printf("9*2.5=%4.16f \n", dc);
    System.out.printf("9/3.0=%4.16f \n", dd);
    System.out.printf("9%%4=%4.16f \n", de);

    System.out.println("\n字符的算术运算"); // 对字符的加法和减法
    System.out.printf("'A'+32=%d \n", 'A' + 32);
    System.out.printf("'A'+32=%c \n", 'A' + 32);
    System.out.printf("'a'-'B'=%d \n", 'a' - 'B');
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

保存文件并运行，输出的结果如下所示。

整数的算术运算
9+4=13
9-4=5
9*4=36
9/4=2
9%4=1

浮点数的算术运算
9+4.5f=13.500000
9-3.0f=6.000000
9*2.5f=22.500000
9/3.0f=3.000000
9%4=1.000000

双精度数的算术运算
9+4.5=13.5000000000000000
9-3.0=6.0000000000000000
9*2.5=22.5000000000000000
9/3.0=3.0000000000000000
9%4=1.0000000000000000

字符的算术运算
'A'+32=97
'A'+32=a
'a'-'B'=31
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

本示例中使用了 4 种类型来执行算术运算。其中，整数类型的结果最容易理解，浮点型和双精度型返回的结果都带有小数，字符型将会把字符转换为 ASCII 码再运算。

从输出结果中可以看到，整数之间的运算结果只保留整数部分，浮点型运算时保留 6 位小数部分，双精度运算时则保留 16 位小数部分。

注意：Java 语言算术运算符的优先级是先乘除后加减。例如在表达式“a-bc”中，b 的左侧为减号，右侧为乘号，而乘号优先级高于减号，因此该表达式可以转换为“a-(bc)”。

3.赋值运算符

下面是Java语言支持的赋值运算符：

常用的：

例1：

    int a = 1;
    int b = 2;
    a += b; // 相当于 a = a + b
    System.out.println(a);
    a += b + 3; // 相当于 a = a + b + 3
    System.out.println(a);
    a -= b; // 相当于 a = a - b
    System.out.println(a);
    a *= b; // 相当于 a=a*b
    System.out.println(a);
    a /= b; // 相当于 a=a/b
    System.out.println(a);
    a %= b; // 相当于 a=a%b
    System.out.println(a);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

上述例子分别对整型进行了+=、-=、*=、/= 和 %= 运算。

例2：下面的简单示例程序演示了赋值运算符。

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 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 >>= 2 = " + 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 );
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

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

c = a + b = 30
c += a  = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a  = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a  = 0
c ^= a   = 10
c |= a   = 10
1
2
3
4
5
6
7
8
9
10
11
12

例3：在大型程序中，灵活运用这些赋值运算符可以提高程序的易读性，并且使程序更加容易保护。下面是一些使用赋值运算符的示例。

    int x, y, z; // 定义3个整型的变量
    x = y = z = 5; // 为变量赋初值为5
    x += 10; // 等价于x=x+10，结果x=15
    y -= 3; // 等价于y=y-3，结果y=2
    z *= 5; // 等价于z=z*5，结果z=25
    x /= 4; // 等价于x=x/4，结果x=3
    z %= x; // 等价于z=z%x，结果z=1
1
2
3
4
5
6
7

例4：例如，一件商品的单价从 10.25 元降了 1.25 元，而自己购买的数量由原来的两个增加到 10 个，可以使用复合赋值运算符来计算购买商品的总价。

实现代码如下：

    public static void main(String[] args) {
        double price = 10.25; // 定义商品的单价，赋值为10.25
        double total = 0; // 定义总价初始为0
        int count = 2; // 定义购买数量，赋值为2
        price -= 1.25; // 减去降价得到当前单价
        count *= 5; // 现在需要购买10个，即原来数量的5倍
        total = price * count; // 总价=当前单价*数量
        System.out.printf("商品当前的单价为：%4.2f \n", price); // 输出当前单价
        System.out.printf("购买商品的数量为：%d \n", count); // 输出购买数量
        System.out.printf("总价为：%4.2f \n", total); // 输出总价
    }
1
2
3
4
5
6
7
8
9
10
11

保存代码并运行，输出的结果如下：
注意：虽然 Java 支持这种一次为多个变量赋值的写法，但这种写导致程序的可读性降低，因此不推荐这样写。

在该程序中，表示商品单价的 price 变量值为 10.25，而现在降了 1.25，在原来的基础上减去 1.25 即可获取现在的单价。而原来购买的数量为两个，现在需要购买 10 个，可以使用“count*=5”将数量乘以 5 倍之后的值赋值给 count 本身。

赋值运算符还可与其他运算符结合，扩展成功能更加强大的赋值运算符。如：<< =、>> =、＆=、^ =、| =，在位运算符讲解。

4.关系运算符

关系运算符（relational operators）也可以称为“比较运算符”，用于比较判断两个变量或常量的大小。关系运算符是二元运算符，运算结果是 boolean 型。当运算符对应的关系成立时，运算结果是 true，否则是 false。

关系表达式是由关系运算符连接起来的表达式。关系运算符中“关系”二字的含义是指一个数据与另一个数据之间的关系，这种关系只有成立与不成立两种可能情况，可以用逻辑值来表示，逻辑上的 true 与 false 用数字 1 与 0 来表示。关系成立时表达式的结果为 true（或 1），否则表达式的结果为 false（或 0）。

表格中的实例整数变量A的值为10，变量B的值为20：

注意点如下所示：

• 基本类型的变量、值不能和引用类型的变量、值使用 == 进行比较；boolean 类型的变量、值不能与其他任意类型的变量、值使用 == 进行比较；如果两个引用类型之间没有父子继承关系，那么它们的变量也不能使用 == 进行比较。
• == 和 != 可以应用于基本数据类型和引用类型。当用于引用类型比较时，比较的是两个引用是否指向同一个对象，但当时实际开发过程多数情况下，只是比较对象的内容是否相当，不需要比较是否为同一个对象。

关系运算符的优先级为：>、<、>=、<= 具有相同的优先级，并且高于具有相同优先级的 !=、==。关系运算符的优先级高于赋值运算符而低于算术运算符，结合方向是自左向右。

关系表达式通常用于 Java 程序的逻辑判断语句的条件表达式中。使用关系表达式要注意以下几点：

• 运算符 >=、==、！=、<= 是两个字符构成的一个运算符，用空格从中分开写就会产生语法错误。例如 x> =y; 是错误的，但是可以写成x >= y; 在运算符的两侧增加空格会提高可读性。同样将运算符写反，例如 =>、=<、=! 等形式会产生语法错误。
• 由于计算机内存放的实数与实际的实数存在着一定的误差，如果对浮点数进行 ==（相等）或 !=（不相等）的比较，容易产生错误结果，应该尽量避免。
• 不要将“==”写成“=”。

例1：

a > b    // 比较变量a的值是否大于变量b的值
x+y> = z    // 比较变量x与变量y的和是否大于或等于变量z的值
width * width+size != area    // 比较变量width的平方加上变量size的值是否与变量area的值不相等
name == "zhht"    // 比较变量name的值是否等于字符串nzht
pass != "123456"    // 比较变量pass的值是否不等于字符串“123456”

1
2
3
4
5
6

例2：

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) );
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false
1
2
3
4
5
6

例3：编写一个程序，使用户可以从键盘输入两个数，并判断这两个数之间的大小。 实现代码如下：

    public static void main(String[] args) {
        int number1, number2; // 定义变量，保存输入的两个数
        System.out.print("请输入第一个整数(number1)：");
        Scanner input = new Scanner(System.in);
        number1 = input.nextInt(); // 输入第一个数
        System.out.print("请输入第二个整数(number2)：");
        input = new Scanner(System.in);
        number2 = input.nextInt(); // 输入第二个数
        System.out.printf("number1=%d,number2=%d\n", number1, number2); // 输出这两个数
        // 判断用户输入的两个数是否相等
        if (number1 == number2) {
            System.out.println("number1 和 number2 相等。");
        }
        // 判断用户输入的两个数据是否相等
        if (number1 != number2) {
            System.out.println("number1 和 number2 不相等。");
            // 判断用户输入的数1是否大于数2
            if (number1 > number2) {
                System.out.println("number1 大于 number2。");
            }
            // 判断用户输入的数1是否小于数2
            if (number1 < number2) {
                System.out.println("number1 小于 number2。");
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

保存程序并运行，运行结果如下所示：

在本程序中，使用 input.nextInt() 接收用户从键盘输入的两个数，然后通过关系运算符来比较这两个数之间的大小。这里用到了 if 语句，它是一个流程控制语句，将在后面的章节中详细讲解。

5.逻辑运算符

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。

逻辑运算符是对布尔型变量进行运算，其结果也是布尔型，具体如表 1 所示。

• && 与 & 区别：如果 a 为 false，则不计算 b（因为不论 b 为何值，结果都为 false）
• || 与 | 区别：如果 a 为 true，则不计算 b（因为不论 b 为何值，结果都为 true）

注意：短路与（&&）和短路或（||）能够采用最优化的计算方式，从而提高效率。在实际编程时，应该优先考虑使用短路与和短路或。

结果为 boolean 型的变量或表达式可以通过逻辑运算符结合成为逻辑表达式。逻辑运算符 &&、|| 和 ！按表 2 进行逻辑运算。

逻辑运算符的优先级为：！运算级别最高，&& 运算高于 || 运算。！运算符的优先级高于算术运算符，而 && 和 || 运算则低于关系运算符。结合方向是：逻辑非（单目运算符）具有右结合性，逻辑与和逻辑或（双目运算符）具有左结合性。

例1：下面的简单示例程序演示了逻辑运算符。

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));
  }
}

1
2
3
4
5
6
7
8
9
10
11

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

a && b = false
a || b = true
!(a && b) = true
1
2
3

例2：当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

public class LuoJi{
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        boolean b = (a<4)&&(a++<10);
        System.out.println("使用短路逻辑运算符的结果为"+b);
        System.out.println("a的结果为"+a);
    }
}

1
2
3
4
5
6
7
8
9
10

运行结果为：

使用短路逻辑运算符的结果为false
a的结果为5
1
2

6.位运算符

Java 定义的位运算（bitwise operators）直接对整数类型的位进行操作，这些整数类型包括 long，int，short，char 和 byte。

位运算符主要用来对操作数二进制的位进行运算。按位运算表示按每个二进制位（bit）进行计算，其操作数和运算结果都是整型值。

Java 语言中的位运算符分为位逻辑运算符和位移运算符两类

6.1位逻辑运算符

位逻辑运算符包含 4 个：&（与）、|（或）、~（非）和 ^（异或）。除了 ~（即位取反）为单目运算符外，其余都为双目运算符。

6.1.1位与运算符

位与运算符为 &，其运算规则是：参与运算的数字，低位对齐，高位不足的补零，如果对应的二进制位同时为 1，那么计算结果才为 1，否则为 0。因此，任何数与 0 进行按位与运算，其结果都为 0。

例1：表达式：100&0
例2：下面是两个非零的数字进行位与运算的过程。

    int x = 5,y = 12; // 创建整型变量保存两个数
    int z = x&y; // 对这两个数进行位与运算，结果保存到z
1
2

6.1.2位或运算符

位或运算符为 |，其运算规则是：参与运算的数字，低位对齐，高位不足的补零。如果对应的二进制位只要有一个为 1，那么结果就为 1；如果对应的二进制位都为 0，结果才为 0。

例1：表达式：11|7

6.1.3位异或运算符

位异或运算符为^，其运算规则是：参与运算的数字，低位对齐，高位不足的补零，如果对应的二进制位相同（同时为 0 或同时为 1）时，结果为 0；如果对应的二进制位不相同，结果则为 1。

例1：表达式：11^7
提示：在有的高级语言中，将运算符^作为求幂运算符，要注意区分。

6.1.4位取反运算符

位取反运算符为~，其运算规则是：只对一个操作数进行运算，将操作数二进制中的 1 改为 0，0 改为 1。

例：表达式：~10
我们可以使用如下的程序来检查这个运算结果。

int i = 10;
System.out.printf("%d \n",~i);
1
2

编译执行以上程序，会发现输出的结果是 -11，而不是 65525。这是因为取反之后的结果是十六进制数，而在上面的程序中使用 %d 将输出转换为了十进制数。

可以使用如下语句查看十六进制结果。

int i=10;
System.out.printf("%x \n",~i);
1
2

可以看到输出结果为 fff5，将它转换为二进制是 1111111111110101。这个二进制数的最高位为 1，表示这个数为负数。除最高位外，按位取反再加 1，即得到二进制原码 1000000000001011，用十进制数表示即为 -11。

注意：位运算符的操作数只能是整型或者字符型数据以及它们的变体，不用于 float、double 或者 long 等复杂的数据类型。

6.2位移运算符

位移运算符用来将操作数向某个方向（向左或者右）移动指定的二进制位数。表 2 列出了 Java 语言中的两个位移运算符，它们都属于双目运算符。

6.2.1左位移运算符

左移位运算符为 «，其运算规则是：按二进制形式把所有的数字向左移动对应的位数，高位移出（舍弃），低位的空位补零。

从图 6 中可以看到，原来数的所有二进制位都向左移动 1 位。原来位于左边的最高位 0 被移出舍弃，再向尾部追加 0 补位。最终到的结果是 22，相当于原来数的 2 倍。

6.2.2右位移运算符

右位移运算符为 »，其运算规则是：按二进制形式把所有的数字向右移动对应的位数，低位移出（舍弃），高位的空位补零。

从图 7 中可以看到，原来数的所有二进制位都向右移动 1 位。原来位于右边的最低位 1 被移出舍弃，再向最高位追加 0 补位。最终到的结果是 5，相当于原数整除 2 的结果。

位运算符作用在所有的位上，并且按位运算。假设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
1
2
3
4
5
6
7

下表列出了位运算符的基本运算，假设整数变量 A 的值为 60 和变量 B 的值为 13：

例：下面的简单示例程序演示了位运算符。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

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

a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2  = 15
a >>> 2 = 15
1
2
3
4
5
6
7

6.3 复合位赋值运算符

所有的二进制位运算符都有一种将赋值与位运算组合在一起的简写形式。复合位赋值运算符由赋值运算符与位逻辑运算符和位移运算符组合而成。表 3 列出了组合后的复合位赋值运算符。

例：下面的程序定义了几个 int 型变量，然后运用位赋值简写的形式将运算后的值赋给相应的变量：

int a = 1;
int b = 2;
int c = 3;

a &= 4;
a |= 4;
a ^= c;
a -= 6;
b >>= 1;
c <<= 1;
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

该程序的输出为：

a = 1
b = 1
c = 6
1
2
3

6.4表达式

表达式的值和类型

• 对表达式中操作数进行运算得到的结果称为表达式的值
• 表达式的值的数据类型即为表达式的类型

7.字符串连接运算符

+：字符串相加，只要有一个操作数是字符串，自动变为字符串相连。

8.三目运算符 （条件运算符）

Java 提供了一个特别的三元运算符（也叫三目运算符）经常用于取代某个类型的 if-then-else 语句。条件运算符的符号表示为“?:”，使用该运算符时需要有三个操作数，因此称其为三目运算符。使用条件运算符的一般语法结构为：

result = <expression> ? <statement1> : <statement3>;
1

其中，expression 是一个布尔表达式。当 expression 为真时，执行 statement1， 否则就执行 statement3。此三元运算符要求返回一个结果，因此要实现简单的二分支程序，即可使用该条件运算符。

例1：下面是一个使用条件运算符的示例

    int x,y,z;
    x = 6,y = 2;
    z = x>y ? x-y : x+y;
1
2
3

在这里要计算 z 的值，首先要判断 x>y 表达的值，如果为 true，z 的值为 x-y；否则 z 的值为 x+y。很明显 x>y 表达式结果为 true，所以 z 的值为 4。

技巧：可以将条件运算符理解为 if-else 语句的简化形式，在使用较为简单的表达式时，使用该运算符能够简化程序代码，使程序更加易读。

在使用条件运算符时，还应该注意优先级问题，例如下面的表达式：

x>y ? x-=y : x+=y;
1

在编译时会出现语法错误，因为条件运算符优先于赋值运算符，上面的语句实际等价于：

    (x>y ? x-=y : x)+=y;
1

而运算符“+=”是赋值运算符，该运算符要求左操作数应该是一个变量，因此出现错误。为了避免这类错误，可以使用括号“0”来加以区分。例如，下面是正确的表达式。

    (x>y) ? (x-=y): (x+=y);
1

例2：

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 );
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

Value of b is : 30
Value of b is : 20
1
2

9.instanceof 运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

instanceof运算符使用格式如下：

( Object reference variable ) instanceof  (class/interface type)
1

如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。
例：

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

如果被比较的对象兼容于右侧类型,该运算符仍然返回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);
   }
}

1
2
3
4
5
6
7
8
9
10
11

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

true
1

上一篇：JAVA java学习（24）——————java修饰符
下一篇：JAVA java学习（26）——————java自增和自减运算符（++和–）