运算符

靠近表顶部的运算符，其优先级最高。具有较高优先级的运算符在相对较低的优先级的运算符之前被评估。在同一行上的运算符具有相同的优先级。当在相同的表达式中出现相同优先级的运算符时，必须首先对该规则进行评估。除了赋值运算符外，所有二进制运算符进行评估从左到右，赋值操作符是从右到左。

运算符优先级表：

运算符 优先级
后缀（postfix） expr++ expr--
一元运算（unary） ++expr --expr +expr -expr ~ !
乘法（multiplicative） * / %
加法（additive） + -
移位运算（shift） << >> >>>
关系（relational） < > <= >= instanceof
相等（equality） == !=
与运算（bitwise AND） &
异或运算（bitwise exclusive OR） ^
或运算（bitwise inclusive OR） ` `
逻辑与运算（logical AND） &&
逻辑或运算（logical OR） ` `
三元运算（ternary） ? :
赋值运算（assignment） `= += -= *= /= %= &= ^= = <<= >>= >>>=`

赋值运算符

赋值运算符是最常用和最简单的运算符就是=，如下：

int cadence = 0;
int speed = 0;
int gear = 1;

该运算符也用于对象的引用关联。

算术运算符

算术运算符包括：

运算符 | 描述 |:----:| ----| |+ | 加 (也用于 String 的连接)| |- | 减| |* | 乘| |/ | 除| |% | 取余|

ArithmeticDemo 的例子

class ArithmeticDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int result = 1 + 2;
        // result is now 3
        System.out.println("1 + 2 = " + result);
        int original_result = result;

        result = result - 1;
        // result is now 2
        System.out.println(original_result + " - 1 = " + result);
        original_result = result;

        result = result * 2;
        // result is now 4
        System.out.println(original_result + " * 2 = " + result);
        original_result = result;

        result = result / 2;
        // result is now 2
        System.out.println(original_result + " / 2 = " + result);
        original_result = result;

        result = result + 8;
        // result is now 10
        System.out.println(original_result + " + 8 = " + result);
        original_result = result;

        result = result % 7;
        // result is now 3
        System.out.println(original_result + " % 7 = " + result);
    }

}

输出为：

1 + 2 = 3
3 - 1 = 2
2 * 2 = 4
4 / 2 = 2
2 + 8 = 10
10 % 7 = 3

+ 用于字符串连接的例子 ConcatDemo ：

class ConcatDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String firstString = "This is";
        String secondString = " a concatenated string.";
        String thirdString = firstString+secondString;
        System.out.println(thirdString);
    }
}

一元操作

一元运算符只需要一个操作数。

运算符 | 描述 |:----:| ----| |+ | 加运算;指正值| |- | 减运算符;表达成负值| |++ | 递增运算符;递增值1| |-- | 递减运算符;递减值1| |！| 逻辑补运算;反转一个布尔值|

下面是 UnaryDemo 的示例：

class UnaryDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int result = +1;
        // result is now 1
        System.out.println(result);

        result--;
        // result is now 0
        System.out.println(result);

        result++;
        // result is now 1
        System.out.println(result);

        result = -result;
        // result is now -1
        System.out.println(result);

        boolean success = false;
        // false
        System.out.println(success);
        // true
        System.out.println(!success);
    }

}

递增/递减运算符可以之前（前缀）或（后缀）操作数后应用。该代码result++; 和 ++result; 两个的 result 都被加一。唯一的区别是，该前缀版本++result;增递增了，而后缀版本result++;的计算结果为原始值。下面是 PrePostDemo 的示例，说明了两者的区别：

class PrePostDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int i = 3;
        i++;
        // prints 4
        System.out.println(i);
        ++i;               
        // prints 5
        System.out.println(i);
        // prints 6
        System.out.println(++i);
        // prints 6
        System.out.println(i++);
        // prints 7
        System.out.println(i);
    }
}

等价和关系运算符

等价和关系运算符包括

运算符 | 描述 |:----:| ----| |== | 相等（equal to）| |!= | 不相等（not equal to）| |> | 大于（greater than）| |>= | 大于等于（greater than or equal to）| |< | 小于（less than）| |<= | 小于等于（less than or equal to）|

ComparisonDemo 对比的例子：

class ComparisonDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int value1 = 1;
        int value2 = 2;
        if (value1 == value2)
            System.out.println("value1 == value2");
        if (value1 != value2)
            System.out.println("value1 != value2");
        if (value1 > value2)
            System.out.println("value1 > value2");
        if (value1 < value2)
            System.out.println("value1 < value2");
        if (value1 <= value2)
            System.out.println("value1 <= value2");
    }
}

输出为：

value1 != value2
value1 < value2
value1 <= value2

条件运算符

条件运算符包括：

运算符 | 描述 |:----:| ----| | && | 条件与（Conditional-AND）| | || | 条件或（Conditional-OR）| | ?: | 三元运算符（ternary operator）|

条件与、条件或的运算符例子 ConditionalDemo1： 

class ConditionalDemo1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int value1 = 1;
        int value2 = 2;
        if ((value1 == 1) && (value2 == 2))
            System.out.println("value1 is 1 AND value2 is 2");
        if ((value1 == 1) || (value2 == 1))
            System.out.println("value1 is 1 OR value2 is 1");
    }
}

输出：

value1 is 1 AND value2 is 2 value1 is 1 OR value2 is 1

下面是一个三元运算符的例子,类似与 if-then-else 语句，见 ConditionalDemo2 ：

class ConditionalDemo2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int value1 = 1;
        int value2 = 2;
        int result;
        boolean someCondition = true;
        result = someCondition ? value1 : value2;

        System.out.println(result);
    }
}

instanceof 运算符

instanceof 用于匹配判断对象的类型。可以用它来测试对象是否是类的一个实例，子类的实例，或者是实现了一个特定接口的类的实例。见例子 InstanceofDemo,父类是 Parent ，接口是 MyInterface ，子类是 Child 继承了父类并实现了接口。

class InstanceofDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {

        // Must qualify the allocation with an enclosing instance of type InstanceofDemo 
        Parent obj1 = new InstanceofDemo().new Parent();
        Parent obj2 = new InstanceofDemo().new Child();

        System.out.println("obj1 instanceof Parent: "
            + (obj1 instanceof Parent));
        System.out.println("obj1 instanceof Child: "
            + (obj1 instanceof Child));
        System.out.println("obj1 instanceof MyInterface: "
            + (obj1 instanceof MyInterface));
        System.out.println("obj2 instanceof Parent: "
            + (obj2 instanceof Parent));
        System.out.println("obj2 instanceof Child: "
            + (obj2 instanceof Child));
        System.out.println("obj2 instanceof MyInterface: "
            + (obj2 instanceof MyInterface));
    }

    class Parent {}
    class Child extends Parent implements MyInterface {}
    interface MyInterface {}
}

输出为：

obj1 instanceof Parent: true
obj1 instanceof Child: false
obj1 instanceof MyInterface: false
obj2 instanceof Parent: true
obj2 instanceof Child: true
obj2 instanceof MyInterface: true

注：null 不是任何类的实例

位运算和位移运算符

位运算和位移运算符适用于整型。

位运算符

运算符 | 描述 |:----:| ----| | & | 与| | | | 或| | ^ | 异或| | ~ | 非（把0变成1，把1变成0）|

BitDemo 例子：

class BitDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int bitmask = 0x000F;
        int val = 0x2222;
        // prints "2"
        System.out.println(val & bitmask);
    }
}

位移运算符

首先我们先阐述一下符号位的概念:

  • 符号位：是数的最后一位，不用来计算的；
  • 当符号位为0时，值为正数；当符号位为1时，值为负数；
  • 无符号位时为正数，有符号位时为正数或者负数；

运算符 | 描述 |:----:| ----| | << | 左移| | >> | 右移| | >>> | 右移（补零）|

左移（<<） 运算形式：值 << 位数

右移（>>） 运算形式：值 >> 位数

移动后，左移、右移都会保留符号位！

右移（补零），移动后，不保留符号位，永远为正数，因为其符号位总是被补零；

源码

本章例子的源码，可以在 com.waylau.essentialjava.operator 包下找到。

results matching ""

    No results matching ""