Java中的运算符

Java提供了多种类型的运算符，可以根据需要使用。它们根据它们提供的功能进行分类。其中一些类型是：

1. 算术运算符
2. 一元运算符
3. 赋值运算符
4. 关系运算符
5. 逻辑运算符
6. 三元运算符
7. 位运算符
8. 移位运算符
9. 运算符实例

让我们详细看看它们。

1.算术运算符：它们用于对原始数据类型执行简单的算术运算。

• * :乘法
• / ：除法
• % :模数
• + :加法
• - ：减法

2. 一元运算符：一元运算符只需要一个操作数。它们用于增加、减少或否定一个值。

• – ：一元减号，用于取反。
• + ：一元加号表示正值（但是，没有这个数字是正的）。当其操作数的类型是 byte、char 或 short 时，它会自动转换为 int。这称为一元数字提升。
• ++：自增运算符，用于将值加1。自增运算符有两种。
  • Post-Increment：值首先用于计算结果，然后递增。
  • Pre-Increment：先增加值，然后计算结果。
• — ：递减运算符，用于将值减1。递减运算符有两种。
  • 后递减：值首先用于计算结果，然后递减。
  • Pre-Decrement：先递减值，然后计算结果。
• ！ ：逻辑非运算符，用于反转布尔值。

3. 赋值运算符：'='赋值运算符用于给任意变量赋值。它具有从右到左的关联性，即在运算符右侧给出的值分配给左侧的变量，因此必须在使用它之前声明右侧的值或者应该是一个常量。

赋值运算符的一般格式是：

variable = value;

在许多情况下，赋值运算符可以与其他运算符组合以构建更短的语句版本，称为复合语句。例如，我们可以写 a += 5，而不是 a = a+5。

• += ，用于将左操作数与右操作数相加，然后将其分配给左侧的变量。
• -= ，用于从左操作数中减去右操作数，然后将其分配给左侧的变量。
• *= ，用于将左操作数与右操作数相乘，然后将其分配给左侧的变量。
• /= ，用于将左操作数除以右操作数，然后将其分配给左侧的变量。
• %= ，用于通过右操作数分配左操作数的模，然后将其分配给左侧的变量。

4. 关系运算符：这些运算符用于检查相等、大于、小于等关系。它们在比较后返回布尔结果，并广泛用于循环语句以及条件 if-else 语句。一般格式是，

variable relation_operator value

• 一些关系运算符是-
  • ==, 等于：如果左侧等于右侧，则返回 true。
  • !=，不等于：如果左侧不等于右侧，则返回 true。
  • <, 小于：如果左侧小于右侧，则返回 true。
  • <=, 小于或等于如果左侧小于或等于右侧，则返回 true。
  • >，大于：如果左侧大于右侧，则返回 true。
  • >=, 大于或等于：如果左侧大于或等于右侧，则返回 true。

5. 逻辑运算符：这些运算符用于执行“逻辑与”和“逻辑或”运算，即类似于数字电子中的与门和或门的函数。要记住的一件事是，如果第一个条件为假，则不会评估第二个条件，即它具有短路效应。广泛用于测试做出决定的几个条件。 Java也有“逻辑非”，当条件为假时返回真，反之亦然

条件运算符有：

• &&，逻辑与：当两个条件都为真时返回真。
• ||，逻辑或：如果至少一个条件为真，则返回真。
• ！ , 逻辑非：当条件为假时返回真，反之亦然

6. 三元运算符：三元运算符是 if-else 语句的简写版本。它有三个操作数，因此得名三元。

一般格式为：

condition ? if true : if false

上面的语句意味着如果条件评估为真，则执行'？'之后的语句。 else 执行 ':.' 之后的语句

Java

// Java program to illustrate
// max of three numbers using
// ternary operator.
public class operators {
    public static void main(String[] args)
    {
        int a = 20, b = 10, c = 30, result;
 
        // result holds max of three
        // numbers
        result
            = ((a > b) ? (a > c) ? a : c : (b > c) ? b : c);
        System.out.println("Max of three numbers = "
                           + result);
    }
}

输出

Max of three numbers = 30

7. 位运算符：这些运算符用于对数字的各个位进行操作。它们可以与任何整数类型一起使用。它们在执行二叉索引树的更新和查询操作时使用。

• &，按位与运算符：返回输入值的逐位与。
• |，按位或运算符：返回输入值的逐位或。
• ^，按位异或运算符：返回输入值的逐位异或。
• ~，按位补码运算符：这是一个一元运算运算符，它返回输入值的补码表示，即所有位反转。

8. 移位运算符：这些运算符用于向左或向右移动数字的位，从而分别将数字乘以或除以 2。当我们必须将一个数字乘以或除以 2 时，可以使用它们。一般格式——

number shift_op number_of_places_to_shift;

• <<，左移运算符：将数字的位向左移动，结果在左边的空白处填充 0。与将数字乘以 2 的某个幂的效果类似。
• >>，有符号右移运算符：将数字的位向右移动并在左侧的空白处填充 0。最左边的位取决于初始数字的符号。与将数字除以 2 的幂的类似效果。
• >>>，无符号右移运算符：将数字的位向右移动并在左侧的空白处填充 0。最左边的位设置为 0。

9. instanceof运算符：运算符的实例用于类型检查。它可用于测试对象是否是类、子类或接口的实例。一般格式——

object instance of class/subclass/interface

Java

// Java program to illustrate
// instance of operator
class operators {
    public static void main(String[] args)
    {
 
        Person obj1 = new Person();
        Person obj2 = new Boy();
 
        // As obj is of type person, it is not an
        // instance of Boy or interface
        System.out.println("obj1 instanceof Person: "
                           + (obj1 instanceof Person));
        System.out.println("obj1 instanceof Boy: "
                           + (obj1 instanceof Boy));
        System.out.println("obj1 instanceof MyInterface: "
                           + (obj1 instanceof MyInterface));
 
        // Since obj2 is of type boy,
        // whose parent class is person
        // and it implements the interface Myinterface
        // it is instance of all of these classes
        System.out.println("obj2 instanceof Person: "
                           + (obj2 instanceof Person));
        System.out.println("obj2 instanceof Boy: "
                           + (obj2 instanceof Boy));
        System.out.println("obj2 instanceof MyInterface: "
                           + (obj2 instanceof MyInterface));
    }
}
 
class Person {
}
 
class Boy extends Person implements MyInterface {
}
 
interface MyInterface {
}

输出

obj1 instanceof Person: true
obj1 instanceof Boy: false
obj1 instanceof MyInterface: false
obj2 instanceof Person: true
obj2 instanceof Boy: true
obj2 instanceof MyInterface: true

运算符的优先级和关联性

在处理涉及多于一种运算符的混合方程时，使用优先级和关联规则。在这种情况下，这些规则决定了首先考虑等式的哪一部分，因为同一个等式可能有许多不同的估值。下表以降序描述了运算符的优先级，顶部表示最高优先级，底部表示最低优先级。

关于运营商的有趣问题

1. 优先级和关联性：当涉及到具有多个运算符的方程时，经常会出现混淆。问题是先解决哪个部分。在这些情况下，有一条黄金法则可以遵循。如果运算符的优先级不同，请先解决较高的优先级。如果它们具有相同的优先级，则根据关联性求解，即从右到左或从左到右。以下程序的解释很好地写在程序本身的注释中。

Java

public class operators {
    public static void main(String[] args)
    {
        int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
 
        // precedence rules for arithmetic operators.
        // (* = / = %) > (+ = -)
        // prints a+(b/d)
        System.out.println("a+b/d = " + (a + b / d));
 
        // if same precedence then associative
        // rules are followed.
        // e/f -> b*d -> a+(b*d) -> a+(b*d)-(e/f)
        System.out.println("a+b*d-e/f = "
                           + (a + b * d - e / f));
    }
}

输出

a+b/d = 20
a+b*d-e/f = 219

2. 成为编译器：我们系统中的编译器在生成标记时使用 lex 工具来匹配最大匹配。如果被忽视，这会产生一些问题。例如，考虑语句a=b+++c ；太多的读者，这似乎会造成编译器错误。但是这个说法是绝对正确的，因为 lex 创建的标记是 a、=、b、++、+、c。因此，该语句具有类似的效果，首先将 b+c 分配给 a，然后将 b 递增。同理，a=b+++++c；会产生错误，因为生成的标记是 a、=、b、++、++、+、c。这实际上是一个错误，因为在第二个一元操作数之后没有操作数。

Java

public class operators {
    public static void main(String[] args)
    {
        int a = 20, b = 10, c = 0;
 
        // a=b+++c is compiled as
        // b++ +c
        // a=b+c then b=b+1
        a = b++ + c;
        System.out.println("Value of a(b+c), "
                           + " b(b+1), c = " + a + ", " + b
                           + ", " + c);
 
        // a=b+++++c is compiled as
        // b++ ++ +c
        // which gives error.
        // a=b+++++c;
        // System.out.println(b+++++c);
    }
}

输出

Value of a(b+c),  b(b+1), c = 10, 11, 0

3. 使用 + over ()：在system.out.println()中使用 +运算符时，请确保使用括号进行加法。如果我们在做加法之前写了一些东西，那么就会发生字符串加法，也就是说，加法的关联性是从左到右的，因此整数首先被添加到字符串中，产生一个字符串，使用 + 时字符串对象连接。因此，它可能会产生不需要的结果。

Java

public class operators {
    public static void main(String[] args)
    {
 
        int x = 5, y = 8;
 
        // concatenates x and y as
        // first x is added to "concatenation (x+y) = "
        // producing "concatenation (x+y) = 5"
        // and then 8 is further concatenated.
        System.out.println("Concatenation (x+y)= " + x + y);
 
        // addition of x and y
        System.out.println("Addition (x+y) = " + (x + y));
    }
}

输出

Concatenation (x+y)= 58
Addition (x+y) = 13