Java 运算符

运算符是执行变量和值的操作的符号。例如，+ 是用于加法的运算符，而 * 也是用于乘法的运算符。

Java 中的运算符可分为 5 种类型

1. 算术运算符
2. 赋值运算符
3. 关系运算符
4. 逻辑运算符
5. 一元运算符
6. 位运算符

1. Java 算术运算符

算术运算符用于对变量和数据执行算术运算。例如，

a + b;

在此，+ 运算符用于将两个变量 a 和 b相加。同样，Java 中还有各种其他算术运算符。

示例 1：算术运算符

class Main {
  public static void main(String[] args) {
    
    // declare variables
    int a = 12, b = 5;

    // addition operator
    System.out.println("a + b = " + (a + b));

    // subtraction operator
    System.out.println("a - b = " + (a - b));

    // multiplication operator
    System.out.println("a * b = " + (a * b));

    // division operator
    System.out.println("a / b = " + (a / b));

    // modulo operator
    System.out.println("a % b = " + (a % b));
  }
}

输出

a + b = 17
a - b = 7 
a * b = 60
a / b = 2 
a % b = 2 

在上面的示例中，我们使用了 +、- 和 * 运算符来计算加法、减法和乘法运算。

/ 除法运算符

请注意程序中的 a / b 操作。/ 运算符是除法运算符。

如果我们使用两个整数进行除法运算，则结果商也将是整数。而且，如果其中一个操作数是浮点数，那么结果也将是浮点数。

In Java,

(9 / 2) is 4
(9.0 / 2) is 4.5
(9 / 2.0) is 4.5
(9.0 / 2.0) is 4.5

% 模运算符

模运算符 % 计算余数。当 a = 7 除以 b = 4 时，余数为 **3**。

注意：% 运算符主要用于整数。

2. Java 赋值运算符

赋值运算符在 Java 中用于为变量赋值。例如，

int age;
age = 5;

在此，= 是赋值运算符。它将右侧的值赋给左侧的变量。也就是说，**5** 被赋给了变量 age。

让我们来看一些 Java 中可用的更多赋值运算符。

示例 2：赋值运算符

class Main {
  public static void main(String[] args) {
    
    // create variables
    int a = 4;
    int var;

    // assign value using =
    var = a;
    System.out.println("var using =: " + var);

    // assign value using =+
    var += a;
    System.out.println("var using +=: " + var);

    // assign value using =*
    var *= a;
    System.out.println("var using *=: " + var);
  }
}

输出

var using =: 4
var using +=: 8 
var using *=: 32

3. Java 关系运算符

关系运算符用于检查两个操作数之间的关系。例如，

// check if a is less than b
a < b;

在此，< 运算符是关系运算符。它检查 a 是否小于 b。

它返回 true 或 false。

示例 3：关系运算符

class Main {
  public static void main(String[] args) {
    
    // create variables
    int a = 7, b = 11;

    // value of a and b
    System.out.println("a is " + a + " and b is " + b);

    // == operator
    System.out.println(a == b);  // false

    // != operator
    System.out.println(a != b);  // true

    // > operator
    System.out.println(a > b);  // false

    // < operator
    System.out.println(a < b);  // true

    // >= operator
    System.out.println(a >= b);  // false

    // <= operator
    System.out.println(a <= b);  // true
  }
}

注意：关系运算符用于决策制定和循环。

4. Java 逻辑运算符

逻辑运算符用于检查表达式是 true 还是 false。它们用于决策制定。

示例 4：逻辑运算符

class Main {
  public static void main(String[] args) {

    // && operator
    System.out.println((5 > 3) && (8 > 5));  // true
    System.out.println((5 > 3) && (8 < 5));  // false

    // || operator
    System.out.println((5 < 3) || (8 > 5));  // true
    System.out.println((5 > 3) || (8 < 5));  // true
    System.out.println((5 < 3) || (8 < 5));  // false

    // ! operator
    System.out.println(!(5 == 3));  // true
    System.out.println(!(5 > 3));  // false
  }
}

程序工作原理

• (5 > 3) && (8 > 5) 返回 true，因为 (5 > 3) 和 (8 > 5) 都为 true。
• (5 > 3) && (8 < 5) 返回 false，因为表达式 (8 < 5) 为 false。
• (5 < 3) || (8 > 5) 返回 true，因为表达式 (8 > 5) 为 true。
• (5 > 3) || (8 < 5) 返回 true，因为表达式 (5 > 3) 为 true。
• (5 < 3) || (8 < 5) 返回 false，因为 (5 < 3) 和 (8 < 5) 都为 false。
• !(5 == 3) 返回 true，因为 5 == 3 为 false。
• !(5 > 3) 返回 false，因为 5 > 3 为 true。

5. Java 一元运算符

一元运算符只与一个操作数一起使用。例如，++ 是一个一元运算符，它将变量的值增加 **1**。也就是说，++5 返回 **6**。

一元运算符的不同类型有

自增和自减运算符

Java 还提供自增和自减运算符：分别为 ++ 和 --。++ 将操作数的值增加 **1**，而 -- 将其减少 **1**。例如，

int num = 5;

// increase num by 1
++num;

在此，num 的值从其初始值 **5** 增加到 **6**。

示例 5：自增和自减运算符

class Main {
  public static void main(String[] args) {
    
    // declare variables
    int a = 12, b = 12;
    int result1, result2;

    // original value
    System.out.println("Value of a: " + a);

    // increment operator
    result1 = ++a;
    System.out.println("After increment: " + result1);

    System.out.println("Value of b: " + b);

    // decrement operator
    result2 = --b;
    System.out.println("After decrement: " + result2);
  }
}

输出

Value of a: 12
After increment: 13
Value of b: 12     
After decrement: 11

在上面的程序中，我们使用了前缀形式的 ++ 和 -- 运算符（++a, --b）。我们也可以将这些运算符用作后缀形式（a++, b++）。

当这些运算符用作前缀和后缀时，它们之间存在细微的差别。

要了解有关这些运算符的更多信息，请访问 自增和自减运算符。

6. Java 位运算符

Java 中的位运算符用于对单个位执行操作。例如，

Bitwise complement Operation of 35

35 = 00100011 (In Binary)

~ 00100011 
  ________
   11011100  = 220 (In decimal)

在此，~ 是一个位运算符。它反转每个位的值（**0** 变为 **1**，**1** 变为 **0**）。

Java 中存在的各种位运算符是

这些运算符在 Java 中通常不使用。要了解更多信息，请访问 Java 位运算符和位移运算符。

其他运算符

除了这些运算符之外，Java 中还有其他附加运算符。

Java instanceof 运算符

instanceof 运算符检查一个对象是否是特定类的实例。例如，

class Main {
  public static void main(String[] args) {

    String str = "Programiz";
    boolean result;

    // checks if str is an instance of
    // the String class
    result = str instanceof String;
    System.out.println("Is str an object of String? " + result);
  }
}

输出

Is str an object of String? true

在此，str 是 String 类的实例。因此，instanceof 运算符返回 true。要了解更多信息，请访问 Java instanceof。

Java 三元运算符

三元运算符（条件运算符）是 if-then-else 语句的简写。例如，

variable = Expression ? expression1 : expression2

它的工作原理如下。

• 如果 Expression 为 true，则将 expression1 赋给 variable。
• 如果 Expression 为 false，则将 expression2 赋给 variable。

让我们看一个三元运算符的例子。

class Java {
  public static void main(String[] args) {

    int februaryDays = 29;
    String result;

    // ternary operator
    result = (februaryDays == 28) ? "Not a leap year" : "Leap year";
    System.out.println(result);
  }
}

输出

Leap year

在上面的示例中，我们使用了三元运算符来检查年份是否为闰年。要了解更多信息，请访问 Java 三元运算符。

现在您已经了解了 Java 运算符，是时候了解运算符的求值顺序了。要了解更多信息，请访问 Java 运算符优先级。