论坛里比较有趣的题目收集

public class Test1 ...{
    public static void main(String[] args) ...{
        int m = 5, n = 5;
        if((m != 5) && (n++ == 5))...{}
        System.out.println("a." + n);
        
        m = n = 5;
        if((m != 5) & (n++ == 6))...{}
        System.out.println("b." + n);
        
        m = n = 5;
        if((m == 5) || (n++ == 5))...{}
        System.out.println("c." + n);
        
        m = n = 5;
        if((m == 5) | (n++ == 6))...{}
        System.out.println("d." + n);
    }
}

 1，&、 ¦逻辑运算与&&、 ¦ ¦这几个逻辑运算还是有点区别的：
前者是非短路运算，后者是短路运算；

编译器对于&&和 ¦ ¦已经优化过的，凡&&前面的是false，那&&后面的表达式就不用了。
¦ ¦前面的是true， ¦ ¦后面的也就不做了，这就是所谓的“短路”。

而布尔逻辑运算符就没有这个特点，无论运算符前面的是true或false，运算符后面的
表达式都得继续进行运算。

＝＝＝＝＝★＝＝我＝＝是＝＝题＝＝目＝＝间＝＝的＝＝小＝＝分＝＝隔＝＝符＝＝★＝＝＝＝＝

public class Test2 ...{
    public static void main(String[] args) ...{
        int k = 100;
        Integer int1 = k;
        Integer int2 = k;
        System.out.println("a." + (int1 == int2));
        k = 200;
        Integer int3 = k;
        Integer int4 = k;
        System.out.println("b." + (int3 == int4));

        char c = 'A';
        Character char1 = c;
        Character char2 = c;
        System.out.println("c." + (char1 == char2));
        c = '国';
        Character char3 = c;
        Character char4 = c;
        System.out.println("d." + (char3 == char4));
    }
}

2..看了下jdk的源码终于明白了
Integer.valueOf()这个方法对于大小为byte的数字做了优化.
valueOf()方法原源码:
public   static   Integer   valueOf(int   i)   {
final   int   offset   =   128;
if   (i   > =   -128   &&   i   <=   127)   {   //   must   cache  
        return   IntegerCache.cache[i   +   offset];
}
                return   new   Integer(i);
}

*******这里是内置的数据**********
private static class IntegerCache {
private IntegerCache(){}

static final Integer cache[] = new Integer[-(-128) + 127 + 1];

static {
for(int i = 0; i < cache.length; i++)
cache[i] = new Integer(i - 128);
}
}

看到了吧！！！！！
Java 为了性能，系统中已经默认创建出了 －128～127 的 Integer 数据，你在创建这个范围的数据时，系统就直接给你一个 “引用”
所以 在 Integer 在 －128～127 之间时，相同的数值得到的都是同一个对象。 所以才会“相同”

而 大于了 127 就是当时新创建的对象了， 当然“引用”是不相等的了，因为指向了不同的对象了嘛！！！！！

如果是byte大小的它是从缓存中取一个,就从IntegerCache初始化的256个Integer缓存中取.
这样就只有一个对像,用==当然就是true了.第二个k=200超过了这个范围,就是new   Integer(i)了

100在-127到128之间,它是从IntegerCache初始化的256个Integer缓存中取的.这样
int1和int2是指向同一个对象

当k=200时不在这个范围,它就是执行的new   Integer()当然就是两个对象,就不等了

public class Test3 ...{
    public static void main(String[] args) ...{
        // 提示   表示换行（LF），而 0x000A 表示什么呢？
         char c = 0x000A;
        System.out.println("Hello" + c + "World!");
    }
}

3.

char   c   =   0x000A;//10   回车
char   c   =   0x000D;//13   换行

4.

来个简单点的填空题哈，在空格处填上适当的数，让下面的程序能输出“Hello   World!”。

 

public class Test4 ...{
    public static void main(String[] args) ...{
        int num = _____________;
        if(num < 0 && num == Math.abs(num)) ...{
            System.out.println("Hello World!");
        }
    }
}

Integer.MIN_VALUE是正确答案。原因在于绝对值的计算方式：
Integer.MIN_VALUE二进制位中最高位（符号位）为“1”，其余的位均为“0”，Math.abs的运算是
先看看参数的值是否是小于零的，若是小于零的，在前面加个负号（-），加负号的运算也就相当于，把
整个二进制位取反再加1，Integer.MIN_VALUE，取反后最高位为“0”了，其余都为“1”了，再加“1”
之后，嘿嘿...

public class Test5 ...{
    public static void main(String[] args) ...{        
        invoke(null);
    }
    private static void invoke(Object obj) ...{
        System.out.println("Object");
    }
    private static void invoke(int[] nums) ...{
        System.out.println("Arrays");
    }
}

5.

Java的重载解析过程是以两阶段运行的。第一阶段选取所有可获得并且可应用的方法或构造器。第二阶段在第一阶段选取的方法或构造器中选取最精确的一个。如果一个方法或构造器可以接受传递给另一个方法或构造器的任何参数，那么我们就说第一个方法比第二个方法缺乏精确性[JLS   15.12.2.5]。  

参数为Object的构造器可以接收所有int[]   nums的参数,所以它不够精确.所以调用的是int[]   nums为参数的构造器

6.

public class Test6 ...{
    public static void main(String[] args) ...{
        Number num = 12345 + 5432l;
        System.out.println(num.intValue());
    }
}

5432l   ==>>是L不是1所以编译错误