逻辑运算符

ㄣ负二代

1. //: ShortCircuit.java
   
2. // Demonstrates short-circuiting behavior
   
3. // with logical operators.
   
4. 
   
5. public class ShortCircuit {
   
6.   static boolean test1(int val) {
   
7.     System.out.println("test1(" + val + ")");
   
8.     System.out.println("result: " + (val < 1));
   
9.     return val < 1;
   
10.   }
    
11.   static boolean test2(int val) {
    
12.     System.out.println("test2(" + val + ")");
    
13.     System.out.println("result: " + (val < 2));
    
14.     return val < 2;
    
15.   }
    
16.   static boolean test3(int val) {
    
17.     System.out.println("test3(" + val + ")");
    
18.     System.out.println("result: " + (val < 3));
    
19.     return val < 3;
    
20.   }
    
21.   public static void main(String[] args) {
    
22.     if(test1(0) && test2(2) && test3(2))
    
23.       System.out.println("expression is true");
    
24.     else
    
25.       System.out.println("expression is false");
    
26.   }
    
27. } ///:~

复制代码

每次测试都会比较自变量，并返回真或假。它不会显示与准备调用什么有关的资料。测试在下面这个表达式中进行：
if(test1(0)) && test2(2) && test3(2))
很自然地，你也许认为所有这三个测试都会得以执行。但希望输出结果不至于使你大吃一惊：

if(test1(0) && test2(2) && test3(2))

第一个测试生成一个true结果，所以表达式求值会继续下去。然而，第二个测试产生了一个false结果。由于这意味着整个表达式肯定为false，所以为什么还要继续剩余的表达式呢？这样做只会徒劳无益。事实上，“短路”一词的由来正种因于此。如果一个逻辑表达式的所有部分都不必执行下去，那么潜在的性能提升将是相当可观的。         
-

逻辑运算符AND（&&）、OR（||）以及NOT（!）能生成一个布尔值（true或false）——以自变量的逻辑关系为基础。下面这个例子向大家展示了如何使用关系和逻辑运算符。

1. //: Bool.java
   
2. // Relational and logical operators
   
3. import java.util.*;
   
4. 
   
5. public class Bool {
   
6.   public static void main(String[] args) {
   
7.     Random rand = new Random();
   
8.     int i = rand.nextInt() % 100;
   
9.     int j = rand.nextInt() % 100;
   
10.     prt("i = " + i);
    
11.     prt("j = " + j);
    
12.     prt("i > j is " + (i > j));
    
13.     prt("i < j is " + (i < j));
    
14.     prt("i >= j is " + (i >= j));
    
15.     prt("i <= j is " + (i <= j));
    
16.     prt("i == j is " + (i == j));
    
17.     prt("i != j is " + (i != j));
    
18. 
    
19.     // Treating an int as a boolean is
    
20.     // not legal Java
    
21. //! prt("i && j is " + (i && j));
    
22. //! prt("i || j is " + (i || j));
    
23. //! prt("!i is " + !i);
    
24. 
    
25.     prt("(i < 10) && (j < 10) is "
    
26.        + ((i < 10) && (j < 10)) );
    
27.     prt("(i < 10) || (j < 10) is "
    
28.        + ((i < 10) || (j < 10)) );
    
29.   }
    
30.   static void prt(String s) {
    
31.     System.out.println(s);
    
32.   }
    
33. } ///:~

复制代码

只可将AND，OR或NOT应用于布尔值。与在C及C++中不同，不可将一个非布尔值当作布尔值在逻辑表达式中使用。若这样做，就会发现尝试失败，并用一个“//!”标出。然而，后续的表达式利用关系比较生成布尔值，然后对结果进行逻辑运算。
输出列表看起来象下面这个样子：

1. i = 85
   
2. j = 4
   
3. i > j is true
   
4. i < j is false
   
5. i >= j is true
   
6. i <= j is false
   
7. i == j is false
   
8. i != j is true
   
9. (i < 10) && (j < 10) is false
   
10. (i < 10) || (j < 10) is true

复制代码

注意若在预计为String值的地方使用，布尔值会自动转换成适当的文本形式。
在上述程序中，可将对int的定义替换成除boolean以外的其他任何主数据类型。但要注意，对浮点数字的比较是非常严格的。即使一个数字仅在小数部分与另一个数字存在极微小的差异，仍然认为它们是“不相等”的。即使一个数字只比零大一点点（例如2不停地开平方根），它仍然属于“非零”值。

1. 短路
操作逻辑运算符时，我们会遇到一种名为“短路”的情况。这意味着只有明确得出整个表达式真或假的结论，才会对表达式进行逻辑求值。因此，一个逻辑表达式的所有部分都有可能不进行求值：