在程序中使用运算符

 

运算符

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

当我们探索 Java 编程语言的运算符时，您可能需要提前知道哪些运算符具有最高优先级。下表中的运算符按优先级顺序排列。运算符在表中越靠近顶部，其优先级越高。优先级较高的运算符在优先级较低的运算符之前进行评估。同一行上的运算符具有相同的优先级。当具有相同优先级的运算符出现在同一个表达式中时，必须有一条规则来控制哪个运算符首先进行评估。除赋值运算符外，所有二元运算符都是从左到右进行评估的；赋值运算符是从右到左进行评估的。

运算符	优先级
后缀	expr++ expr--
一元	++expr --expr +expr -expr ~ !
乘法	* / %
加法	+ -
移位	<< >> >>>
关系	< > <= >= instanceof
相等	== !=
按位 AND	&
按位异或	^
按位或	|
逻辑 AND	&&
逻辑 OR	||
三元	? :
赋值	= += -= *= /= %= &= ^= |= <<= >>= >>>=

在通用编程中，某些运算符往往比其他运算符出现得更频繁；例如，赋值运算符 = 比无符号右移运算符 >>> 常见得多。考虑到这一点，以下讨论首先侧重于您最有可能定期使用的运算符，最后侧重于那些不太常见的运算符。每个讨论都附带示例代码，您可以编译和运行。研究其输出将有助于强化您刚刚学到的知识。

 

简单赋值运算符

您将遇到的最常见的运算符之一是简单赋值运算符 =。您在 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、对表达式取反或反转布尔值。

运算符	描述
+	一元加运算符；表示正值（数字在没有此运算符的情况下为正，但是）
-	一元减运算符；对表达式取反
++	递增运算符；将值增加 1
--	递减运算符；将值减少 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; 最终都会使 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

 

条件运算符

&& 和 || 运算符对两个布尔表达式执行条件 AND 和条件 OR 操作。这些运算符表现出“短路”行为，这意味着只有在需要时才评估第二个操作数。

运算符	描述
&&	条件 AND
||	条件 OR

以下程序 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 为真，则将 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 为真，所以此程序将“1”打印到屏幕上。如果使用 ?: 运算符而不是 if-then-else 语句可以使您的代码更易读；例如，当表达式紧凑且没有副作用（如赋值）时。

 

类型比较运算符 Instanceof

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。

有符号左移运算符 << 将位模式向左移位，有符号右移运算符 >> 将位模式向右移位。位模式由左侧操作数给出，移位的位数由右侧操作数给出。无符号右移运算符 >>> 将零移入最左边的位置，而 >> 之后的最左边位置取决于符号扩展。

按位 & 运算符执行按位 AND 操作。

按位 ^ 运算符执行按位异或操作。

按位 | 运算符执行按位或操作。

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

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