复制代码

1. 
   
2. <P>public class Test </P>
   
3. <P>{ private static int j = 0;</P>
   
4. <P> private static boolean methodB(int k) { </P>
   
5. <P>j += k; </P>
   
6. <P>return true; </P>
   
7. <P>}</P>
   
8. <P> public static void methodA(int i){</P>
   
9. <P> boolean b; </P>
   
10. <P>b = i < 10 | methodB(4);</P>
    
11. <P> b = i < 10 || methodB(8); </P>
    
12. <P>} </P>
    
13. <P>public static void main (String args[]){</P>
    
14. <P> methodA(0);</P>
    
15. <P> System.out.println(j); </P>
    
16. <P>}</P>
    
17. <P>}</P>

复制代码

为啥 是4的 而不是8的。。。

1. public class Test { private static int j = 0; private static boolean methodB(int k) { j += k; return true; } public static void methodA(int i){ boolean b; b = i < 10 | methodB(4); b = i < 10 || methodB(8); } public static void main (String args[]){ methodA(0); System.out.println(j); }}

复制代码

是 | 和 ||的区别的问题

1. public class Test {
   
2.         private static int j = 0;
   
3.         private static boolean methodB(int k)
   
4.         {
   
5.                 j += k;
   
6.                 return true;
   
7.                 }
   
8.         public static void methodA(int i){
   
9.                 boolean b;
   
10.                 //单个|的话两边都参与运算
    
11.                 b = i < 10 | methodB(4);
    
12.                 //两个||，如果左侧为真则右侧不参与运算，因为结果肯定是真
    
13.                 //如果把下面的也改成 | 的话，结果就是12了。因为上面的两侧运算，j变成4，下面的运算后加8变成12
    
14.                 b = i < 10 || methodB(8);
    
15.                 }
    
16.         public static void main (String args[]){
    
17.                 methodA(0);
    
18.                 System.out.println(j);
    
19.                 }
    
20.         }public class Demo2 {
    
21.         private static int j = 0;
    
22.         private static boolean methodB(int k)
    
23.         {
    
24.                 j += k;
    
25.                 return true;
    
26.                 }
    
27.         public static void methodA(int i){
    
28.                 boolean b;
    
29.                 //单个|的话两边都参与运算
    
30.                 b = i < 10 | methodB(4);
    
31.                 //两个||，如果左侧为真则右侧不参与运算，因为结果肯定是真
    
32.                 //如果把下面的也改成 | 的话，结果就是12了。因为上面的两侧运算，j变成4，下面的运算后加8变成12
    
33.                 b = i < 10 || methodB(8);
    
34.                 }
    
35.         public static void main (String args[]){
    
36.                 methodA(0);
    
37.                 System.out.println(j);
    
38.                 }
    
39.         }

复制代码

逻辑运算符执行的是短路求值
所谓短路，就是当参与运算的一个操作数已经足以推断出这个表达式的值的时候，另外一个操作数（有可能是表达式）就不会执行

位操作没有这一特性，所以不管那边的值是如何，任何参与运算的表达式都会被执行求值，因此也就产生了你代码之中的结果了。

嗯嗯嗯 谢谢啦  给搞混了这俩。。

楼主您好~帖子长时间未作出回答，我已经将您的帖子改成已解决。如果有问题的话可以私密我哦~