Java™ 教程（运算符）

既然你已经学会了如何声明和初始化变量，那么你可能想知道如何使用它们，学习Java编程语言的运算符是一个很好的起点，运算符是对一个、两个或三个操作数执行特定运算的特殊符号，然后返回结果。

在我们探索Java编程语言的运算符时，提前知道哪些运算符具有最高优先级可能会对你有所帮助，下表中的运算符按优先顺序列出，运算符出现在离表顶部越近，其优先级越高，优先级较高的运算符在优先级相对较低的运算符之前进行求值。同一行上的运算符具有相同的优先权，当具有相同优先级的运算符出现在同一表达式中时，规则必须控制首先计算的值，除了赋值运算符之外的所有二元运算符都是从左到右计算的，赋值运算符从右到左进行求值。

在通用编程中，某些运算符往往比其他运算符更频繁地出现，例如，赋值运算符“=”比无符号右移运算符“>>>”更常见，考虑到这一点，以下讨论首先关注你最有可能经常使用的运算符，并最终关注那些不太常见的运算符。每个讨论都附带可以编译和运行的示例代码，研究它的输出将有助于加强你刚刚学到的东西。

你将遇到的最常见的运算符之一是简单赋值运算符“=”，你在Bicycle类中看到了此运算符，它将右侧的值赋给左侧的操作数：

</>复制代码 
 int cadence = 0;
 int speed = 0;
 int gear = 1;

此运算符也可用于对象以分配对象引用，如创建对象中所述。

Java编程语言提供执行加法，减法，乘法和除法的运算符，很有可能你会被基础数学方面的同行认出来，唯一可能看起来很新的符号是“％”，它将一个操作数除以另一个操作数，并将余数作为结果返回。

以下程序ArithmeticDemo测试算术运算符。

</>复制代码 
class ArithmeticDemo {
    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

你还可以将算术运算符与简单赋值运算符组合以创建复合赋值，例如，x+=1;和x=x+1;都将x的值递增1。

+运算符也可用于将两个字符串连接（连接）在一起，如下面的ConcatDemo程序所示：

</>复制代码 
class ConcatDemo {
    public static void main(String[] args){
        String firstString = "This is";
        String secondString = " a concatenated string.";
        String thirdString = firstString+secondString;
        System.out.println(thirdString);
    }
}

在该程序结束时，变量thirdString包含“This is a concatenated string.”，它被打印到标准输出。

一元运算符只需要一个操作数，它们执行各种操作，例如将值递增/递减1，否定表达式或反转布尔值。

以下程序UnaryDemo测试一元运算符：

</>复制代码 
class UnaryDemo {
    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;将两个结果都加1。唯一的区别是前缀版本（++result）评估为增量值，而后缀版本（result++）评估为原始值。如果你只是执行简单的增量/减量，那么选择哪个版本并不重要，但是，如果你在较大的表达式中使用此运算符，则你选择的运算符可能会产生显着差异。

以下程序PrePostDemo演示了前缀/后缀一元增量运算符：

</>复制代码 
class PrePostDemo {
    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);
    }
}

等于和关系运算符确定一个操作数是否大于，小于，等于或不等于另一个操作数，这些运算符中的大多数也可能看起来很熟悉，请记住，在测试两个原始值是否相等时，必须使用“==”而不是“=”。

以下程序ComparisonDemo测试比较运算符：

</>复制代码 
class ComparisonDemo {
    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

&&和||运算符对两个布尔表达式执行条件与和条件或运算，这些运算符表现出“最少运算”行为，这意味着仅在需要时才评估第二个操作数。

以下程序ConditionalDemo1测试这些运算符：

</>复制代码 
class ConditionalDemo1 {
    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");
    }
}

另一个条件运算符是?:，这可以被认为是if-then-else语句的简写（在本课程的控制流语句部分中讨论），此运算符也称为三元运算符，因为它使用三个操作数，在以下示例中，应将此运算符读作：“如果someCondition为true，则将value1的值赋给result，否则，将value2的值赋给result。”

以下程序ConditionalDemo2测试?:运算符：

</>复制代码 
class ConditionalDemo2 {
    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);
    }
}

因为someCondition为true，所以此程序在屏幕上打印“1”，如果它使代码更具可读性，请使用?:运算符而不是if-then-else语句，例如，当表达式紧凑且没有副作用（例如赋值）时。

instanceof运算符将对象与指定的类型进行比较，你可以使用它来测试对象是否是类的实例，子类的实例或实现特定接口的类的实例。

以下程序InstanceofDemo定义了一个父类（名为Parent），一个简单的接口（名为MyInterface）和一个继承自父类并实现接口的子类（名为Child）。

</>复制代码 
class InstanceofDemo {
    public static void main(String[] args) {
        Parent obj1 = new Parent();
        Parent obj2 = 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

使用instanceof运算符时，请记住null不是任何实例。

Java编程语言还提供对整数类型执行按位和位移操作的运算符，本节中讨论的运算符不太常用，因此，他们的报道很简短，目的是让你意识到这些运算符的存在。

一元按位补码运算符“〜”反转位模式，它可以应用于任何整数类型，使每个“0”为“1”，每个“1”为“0”，例如，一个字节包含8位，将此运算符应用于位模式为“00000000”的值会将其模式更改为“11111111”。

带符号的左移运算符“<<”将位模式向左移位，带符号的右移运算符“>>”将位模式向右移位，位模式由左侧操作数给出，以及由右侧操作数移位的位置数。无符号右移运算符“>>>”将零移动到最左侧位置，而“>>”之后的最左侧位置取决于符号扩展。

按位＆运算符执行按位与运算。
按位^运算符执行按位异或运算。
按位|运算符执行按位或运算。

以下程序BitDemo使用按位与运算符将数字“2”打印到标准输出。

</>复制代码 
class BitDemo {
    public static void main(String[] args) {
        int bitmask = 0x000F;
        int val = 0x2222;
        // prints "2"
        System.out.println(val & bitmask);
    }
}

以下快速参考总结了Java编程语言支持的运算符。