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

复制代码

求解...

• 结果是1，先占楼
  这个题其实考的是&和&&的运算机制 还有+=的运算机制
  &是两边都要进行运算
  而&&则是左边如果为假，右边不运算，左边为真，再运算右边
  public static void methodA(int i) {
  

                boolean b;

                b = i > 10 & methodB(1);//这里传进来0,0<10,为假。但是要运算右边，所以调用了methodB，传进去了1

                b = i > 10 && methodB(2);//这里还是0<10,为假，所以右边不执行，这样methidB就没有调用，
也就是说method只调用了一次，传进去了一个1
所以结果为1

    b = i > 10 & methodB(1);    & 在前面是false的时候还会继续后面表达式的运算，也就是会执行methodB(1)，这个方法把 j 变成了1
而 b = i > 10 && methodB(2);  &&有短路效果，当判断到前面为false的时候，就不会继续判断后面表达式的值，直接返回false，所以methodB(2)  根本就没有运行到。

所以答案是  1

这段小代码有点唬人
public class Test {
        public static void main(String[] args) {
                   java是按顺序执行的
                // System.out.println(j); 把这个打开 你会更明白
                methodA(0);  //执行后，j的值为1；
                System.out.println(j);
}
        private static int j = 0;
        public static boolean methodB(int k) {
                j += k;   
                return true;
        }
      
        public static void methodA(int i) {
                boolean b;
                b = i > 10 & methodB(1);    //  j的值为1，  0>10为假，后面继续执行。methodB(1)方法中 j 的值为1；
                b = i > 10 && methodB(2);  //  0>10为假，短路后面不执行           所以methodB(2); 不执行
               //如果&&运算符的前面的结果为false, 无论后面的值是什么, 其结果都是false.
        }      
}
            

直接上代码！

1. package test;
   
2. 
   
3. 
   
4. public class Test3 {
   
5.         public static void main(String[] args) {
   
6.                 methodA(0);                        //按顺序走
   
7.                 System.out.println(j);//所以输出 结果为 1
   
8.         }
   
9. 
   
10.         private static int j = 0;
    
11. 
    
12.         public static boolean methodB(int k) {
    
13.                 j += k;                //j=0，k=1，j+=k,所以j=1，返回true。
    
14.                 return true;
    
15.         }
    
16. 
    
17.         public static void methodA(int i) {
    
18.                 boolean b;
    
19.                 b = i > 10 & methodB(1);//&逻辑运算符，与，无论左边真假与否，右边都要判断，i>10为假，执行methodB(1)
    
20.                                                         //通过methodB的运算，返回真，但左边已经回假，所以b现在为false，不过这无关紧要。因为是静态方法
    
21.                 b = i > 10 && methodB(2);//&& 逻辑运算符，与，如果左边卫假，右边不再判断。
    
22.         }
    
23. }
    
24. 
    
25. 
    
26. 
    
27. 
    
28. 
    
29. 
    
30. 
    

复制代码