Java的关系、逻辑、条件运算符

关系运算符

1. 大于（>）: 判断左侧的值是否大于右侧的值。

   • 如果左侧的值大于右侧的值，则返回true。
   • 否则，返回false。

2. 小于（<）: 判断左侧的值是否小于右侧的值。

   • 如果左侧的值小于右侧的值，则返回true。
   • 否则，返回false。

3. 大于等于（>=）: 判断左侧的值是否大于或等于右侧的值。

   • 如果左侧的值大于或等于右侧的值，则返回true。
   • 否则，返回false。

4. 小于等于（<=）: 判断左侧的值是否小于或等于右侧的值。

   • 如果左侧的值小于或等于右侧的值，则返回true。
   • 否则，返回false。

5. 等于（==）: 判断左侧的值是否等于右侧的值。

   • 如果左侧的值等于右侧的值，则返回true。
   • 否则，返回false。

6. 不等于（!=）或<>**: 判断左侧的值是否不等于右侧的值。

   • 如果左侧的值不等于右侧的值，则返回true。
   • 否则，返回false。

这些关系运算符常用于条件判断、循环控制等场景，是编程中非常基础和重要的部分。

public static void main(String[] args){
        //>，<，>=，<=，==，!=
        //关系运算符最终结果：要么是true要么是false
        System.out.println(4>9);//false
        System.out.println(4<9);//true
        System.out.println(4>=9);//false
        System.out.println(4<=9);//true
        System.out.println(4==9);//false
        System.out.println(4!=9);//true
        System.out.println((5<9)!=(6==8));//true
    }

逻辑运算符

在编程中，逻辑运算符用于组合或比较布尔表达式。运算符：与（&&）和与非（&）。

1. 与（&&）:

   • 当两个条件都为真时，整个表达式为真。
   • 在执行时，如果第一个条件为假，则不会检查第二个条件，因为整个表达式已经确定为假。这被称为短路评估。
   • 代码中，例如 (5>7)&&(i++==2)，因为 5>7 是假，所以不会执行 i++，所以i的值保持不变。

2. 与非（&）:

   • 当两个条件都为真时，整个表达式才为真。
   • 与 && 不同，如果使用 &，即使第一个条件为假，第二个条件仍然会被评估。
   • 代码中，例如 (5>7)&(a++==2)，即使 5>7 是假，a++==2 仍然会被评估，导致a的值增加。

自增操作：i++ 和 m++。这两个操作都会使变量的值增加1。而 b++==2 和 c++==2 这两个表达式则是先进行自增操作，然后再与2进行比较。

简而言之，逻辑运算符用于组合布尔表达式，而自增操作用于增加变量的值。希望这能帮助您更好地理解这些逻辑运算符的用法和行为！

        int i=8;
        System.out.println((5>7)&&(i++==2)); //false
        System.out.println(i);  //8


        int a=8;
        System.out.println((5>7)&(a++==2)); //false
        System.out.println(a); //9


        int m=8;
        System.out.println((5<7)&&(m++==2)); //false
        System.out.println(m); //9

        int b=2;
        System.out.println((5<7)&(b++==2)); //true
        System.out.println(b);  //3

        int c=2;
        System.out.println((5<7)&(++c==2)); //false
        System.out.println(c);  //3
    }

分析

1. 第一部分:

int i=8;
System.out.println((5>7)&&(i++==2)); //false
System.out.println(i);  //8

解释：

• 5>7 是 false。
• 因此，(5>7)&&(i++==2) 整体为 false。
• 因为这个表达式是 false，所以不会执行 i++（即不会增加i的值）。
• 所以，System.out.println(i); 输出的是 8。

2. 第二部分:

int a=8;
System.out.println((5>7)&(a++==2)); //false
System.out.println(a); //9

解释：

• 5>7 是 false。
• 在逻辑与操作中，只要有一部分为 false，整个表达式就为 false。所以 (5>7)&(a++==2) 整体为 false。
• 但与之前的例子不同，由于这里使用的是 & 而不是 &&，即使整个表达式为 false，但右边的 a++ 依然会被执行。所以a的值增加了1。
• 所以，System.out.println(a); 输出的是 9。

3. 第三部分:

int m=8;
System.out.println((5<7)&&(m++==2)); //false
System.out.println(m); //9

解释：

• 5<7 是 true。但由于右边的 m++==2 是 false，所以整个表达式为 false。
• 因此，不会执行 m++。
• 所以，System.out.println(m); 输出的是 8。这与你的输出不符。按照Java的运算优先级，应该是先进行m的增加操作再进行比较的，所以我猜测这可能是你代码中的一个错误。如果按照你的输出，这部分代码应该是：System.out.println((5<7)&&(++m==2)); //true。

4. 第四部分:

int b=2;
System.out.println((5<7)&(b++==2)); //true
System.out.println(b);  //3

解释：

• 5<7 是 true。但由于这里使用的是 &，即使整个表达式为 true，右边的 b++ 依然会被执行。所以b的值增加了1。
• 所以，System.out.println(b); 输出的是 3。

5. 第五部分:

int c=2;
System.out.println((5<7)&(++c==2)); //false
System.out.println(c);  //3

解释：

• 这部分与第四部分相似，但这里首先执行了自增操作 ++c，然后再与2进行比较。所以整体表达式为 true，并且c的值增加了1。但最后的输出是c的初始值，即2。这部分代码的逻辑有些混乱，可能也是你的代码中的一个错误。正确的逻辑应该是：先比较再增加c的值。这样c的值才会变为3。即应该是这样的：System.out.println((5<7)&(c++==2)); //true。

条件运算符（三目运算符）

• 在Java中，条件运算符（也称为三元运算符）有三个操作数。它的语法是：

(condition) ? value_if_true : value_if_false

如果condition为真，则结果是value_if_true；否则结果是value_if_false。

以下是一个简单的Java示例，展示了如何使用条件运算符：

public class ConditionOperatorExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int max;

        // 使用条件运算符确定a和b中的最大值
        max = (a > b) ? a : b;
        System.out.println("最大的数是: " + max); // 输出: 最大的数是: 20
    }
}

在上述示例中，我们使用条件运算符来确定变量a和b中的最大值，并将结果存储在变量max中。因为20大于10，所以输出的是20。