JAVA面试题解惑系列（八）——聊聊基本类型（内置类型）

Question

------------------------------------------------------------------------------------
  我想出一本名为《JAVA面试题解惑系列》的书籍，详情请见：  
  http://rmyd.group.javaeye.com/group/topic/6193          
  目前网络连载中：http://zangweiren.javaeye.com/          
  请大家多关注，多提宝贵意见！                            
------------------------------------------------------------------------------------作者：臧圩人（zangweiren） 
网址：http://zangweiren.javaeye.com >>>转载请注明出处！<<< 基本类型，或者叫做内置类型，是JAVA中不同于类的特殊类型。它们是我们编程中使用最频繁的类型，因此面试题中也总少不了它们的身影，在这篇文章中我们将从面试中常考的几个方面来回顾一下与基本类型相关的知识。 基本类型共有八种，它们分别都有相对应的包装类。关于它们的详细信息请看下表：  基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类java.lang.Void，不过我们无法直接对它们进行操作。对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。请看下面的例子： 
Java代码 
public class PrimitiveTypeTest {   
    public static void main(String[] args) {   
        // byte   
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);   
        System.out.println("包装类：java.lang.Byte");   
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);   
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);   
        System.out.println();   
  
        // short   
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);   
        System.out.println("包装类：java.lang.Short");   
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);   
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);   
        System.out.println();   
  
        // int   
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);   
        System.out.println("包装类：java.lang.Integer");   
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);   
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);   
        System.out.println();   
  
        // long   
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);   
        System.out.println("包装类：java.lang.Long");   
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);   
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);   
        System.out.println();   
  
        // float   
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);   
        System.out.println("包装类：java.lang.Float");   
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);   
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);   
        System.out.println();   
  
        // double   
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);   
        System.out.println("包装类：java.lang.Double");   
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);   
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);   
        System.out.println();   
  
        // char   
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);   
        System.out.println("包装类：java.lang.Character");   
        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台   
        System.out.println("最小值：Character.MIN_VALUE="  
                + (int) Character.MIN_VALUE);   
        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台   
        System.out.println("最大值：Character.MAX_VALUE="  
                + (int) Character.MAX_VALUE);   
    }   
}  运行结果： 1、基本类型：byte 二进制位数：8 
2、包装类：java.lang.Byte 
3、最小值：Byte.MIN_VALUE=-128 
4、最大值：Byte.MAX_VALUE=127 
5、
6、基本类型：short 二进制位数：16 
7、包装类：java.lang.Short 
8、最小值：Short.MIN_VALUE=-32768 
9、最大值：Short.MAX_VALUE=32767 
10、
11、基本类型：int 二进制位数：32 
12、包装类：java.lang.Integer 
13、最小值：Integer.MIN_VALUE=-2147483648 
14、最大值：Integer.MAX_VALUE=2147483647 
15、
16、基本类型：long 二进制位数：64 
17、包装类：java.lang.Long 
18、最小值：Long.MIN_VALUE=-9223372036854775808 
19、最大值：Long.MAX_VALUE=9223372036854775807 
20、
21、基本类型：float 二进制位数：32 
22、包装类：java.lang.Float 
23、最小值：Float.MIN_VALUE=1.4E-45 
24、最大值：Float.MAX_VALUE=3.4028235E38 
25、
26、基本类型：double 二进制位数：64 
27、包装类：java.lang.Double 
28、最小值：Double.MIN_VALUE=4.9E-324 
29、最大值：Double.MAX_VALUE=1.7976931348623157E308 
30、
31、基本类型：char 二进制位数：16 
32、包装类：java.lang.Character 
33、最小值：Character.MIN_VALUE=0 
34、最大值：Character.MAX_VALUE=65535 Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的“E+数字”表示E之前的数字要乘以10的多少倍。比如3.14E3就是3.14×1000=3140，3.14E-3就是3.14/1000=0.00314。 大家将运行结果与上表信息仔细比较就会发现float、double两种类型的最小值与Float.MIN_VALUE、Double.MIN_VALUE的值并不相同，这是为什么呢？实际上Float.MIN_VALUE和Double.MIN_VALUE分别指的是float和double类型所能表示的最小正数。也就是说存在这样一种情况，0到±Float.MIN_VALUE之间的值float类型无法表示，0到±Double.MIN_VALUE之间的值double类型无法表示。这并没有什么好奇怪的，因为这些范围内的数值超出了它们的精度范围。 基本类型存储在栈中，因此它们的存取速度要快于存储在堆中的对应包装类的实例对象。从Java5.0（1.5）开始，JAVA虚拟机（Java Virtual Machine）可以完成基本类型和它们对应包装类之间的自动转换。因此我们在赋值、参数传递以及数学运算的时候像使用基本类型一样使用它们的包装类，但这并不意味着你可以通过基本类型调用它们的包装类才具有的方法。另外，所有基本类型（包括void）的包装类都使用了final修饰，因此我们无法继承它们扩展新的类，也无法重写它们的任何方法。 

Answer 1

此回复为自动发出,仅用于显示而已，并无任何其他特殊作用
楼主【zangweiren】截止到2008-07-25 11:03:11的历史汇总数据(不包括此帖)：
发帖的总数量:16                       发帖的总分数:420                      每贴平均分数:26                       
回帖的总数量:17                       得分贴总数量:0                        回帖的得分率:0%                       
结贴的总数量:16                       结贴的总分数:420                      
无满意结贴数:0                        无满意结贴分:0                        
未结的帖子数:0                        未结的总分数:0                        
结贴的百分比:100.00%               结分的百分比:100.00%                  
无满意结贴率:0.00  %               无满意结分率:0.00  %                  
敬礼!

Answer 2

各种数值类型之间的赋值与转换遵循什么规律呢？我们来看下面这个例子： 
Java代码 
public class PrimitiveTypeTest {   
    public static void main(String[] args) {   
        // 给byte类型变量赋值时，数字后无需后缀标识   
        byte byte_a = 1;   
        // 编译器会做范围检查，如果赋予的值超出了范围就会报错   
        // byte byte_b = 1000;   
        // 把一个long型值赋值给byte型变量，编译时会报错，即使这个值没有超出byte类型的取值范围   
        // byte byte_c = 1L;   
  
        // 给short类型变量赋值时，数字后无需后缀标识   
        short short_a = 1;   
        // 编译器会做范围检查，如果赋予的值超出了范围就会报错   
        // short short_b = 70000;   
        // 把一个long型值赋值给short型变量，编译时会报错，即使这个值没有超出short类型的取值范围   
        // byte short_c = 1L;   
  
        // 给short类型变量赋值时，数字后无需后缀标识   
        int int_a = 1;   
        // 编译器会做范围检查，如果赋予的值超出了范围就会报错   
        // int int_b = 2200000000;   
        // 把一个long型值赋值给int型变量，编译时会报错，即使这个值没有超出int类型的取值范围   
        // int int_c = 1L;   
  
        // 可以把一个int型值直接赋值给long型变量，数字后无需后缀标识   
        long long_a = 1;   
        // 如果给long型变量赋予的值超出了int型值的范围，数字后必须加L（不区分大小写）标识   
        long long_b = 2200000000L;   
        // 编译器会做范围检查，如果赋予的值超出了范围就会报错   
        // long long_c = 9300000000000000000L;   
  
        // 可以把一个int型值直接赋值给float型变量   
        float float_a = 1;   
        // 可以把一个long型值直接赋值给float型变量   
        float float_b = 1L;   
        // 没有F（不区分大小写）后缀标识的浮点数默认为double型的，不能将它直接赋值给float型变量   
        // float float_c = 1.0;   
        // float型数值需要有一个F（不区分大小写）后缀标识   
        float float_d = 1.0F;   
        // 把一个double型值赋值给float型变量，编译时会报错，即使这个值没有超出float类型的取值范围   
        // float float_e = 1.0D;   
        // 编译器会做范围检查，如果赋予的值超出了范围就会报错   
        // float float_f = 3.5000000E38F;   
  
        // 可以把一个int型值直接赋值给double型变量   
        double double_a = 1;   
        // 可以把一个long型值直接赋值给double型变量   
        double double_b = 1L;   
        // 可以把一个float型值直接赋值给double型变量   
        double double_c = 1F;   
        // 不带后缀标识的浮点数默认为double类型的，可以直接赋值   
        double double_d = 1.0;   
        // 也可以给数字增加一个D（不区分大小写）后缀标识，明确标出它是double类型的   
        double double_e = 1.0D;   
        // 编译器会做范围检查，如果赋予的值超出了范围就会报错   
        // double double_f = 1.8000000000000000E308D;   
  
        // 把一个double型值赋值给一个byte类型变量，编译时会报错，即使这个值没有超出byte类型的取值范围   
        // byte byte_d = 1.0D;   
        // 把一个double型值赋值给一个short类型变量，编译时会报错，即使这个值没有超出short类型的取值范围   
        // short short_d = 1.0D;   
        // 把一个double型值赋值给一个int类型变量，编译时会报错，即使这个值没有超出int类型的取值范围   
        // int int_d = 1.0D;   
        // 把一个double型值赋值给一个long类型变量，编译时会报错，即使这个值没有超出long类型的取值范围   
        // long long_d = 1.0D;   
  
        // 可以用字符初始化一个char型变量   
        char char_a = 'a';   
        // 也可以用一个int型数值初始化char型变量   
        char char_b = 1;   
        // 把一个long型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围   
        // char char_c = 1L;   
        // 把一个float型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围   
        // char char_d = 1.0F;   
        // 把一个double型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围   
        // char char_e = 1.0D;   
        // 编译器会做范围检查，如果赋予的值超出了范围就会报错   
        // char char_f = 70000;   
    }   
}  从上面的例子中我们可以得出如下几条结论： 1、未带有字符后缀标识的整数默认为int类型；未带有字符后缀标识的浮点数默认为double类型。 
2、如果一个整数的值超出了int类型能够表示的范围，则必须增加后缀“L”（不区分大小写，建议用大写，因为小写的L与阿拉伯数字1很容易混淆），表示为long型。 
3、带有“F”（不区分大小写）后缀的整数和浮点数都是float类型的；带有“D”（不区分大小写）后缀的整数和浮点数都是double类型的。 
4、编译器会在编译期对byte、short、int、long、float、double、char型变量的值进行检查，如果超出了它们的取值范围就会报错。 
5、int型值可以赋给所有数值类型的变量；long型值可以赋给long、float、double类型的变量；float型值可以赋给float、double类型的变量；double型值只能赋给double类型变量。 下图显示了几种基本类型之间的默认逻辑转换关系： 
 
图中的实线表示无精度损失的转换，而虚线则表示这样的转换可能会损失一定的精度。如果我们想把一个能表示更大范围或者更高精度的类型，转换为一个范围更小或者精度更低的类型时，就需要使用强制类型转换（Cast）了。不过我们要尽量避免这种用法，因为它常常引发错误。请看下面的例子，如果不运行代码，你能预测它的结果吗？ 
Java代码 
public class PrimitiveTypeTest {   
    public static void main(String[] args) {   
        int a = 123456;   
        short b = (short) a;   
        // b的值会是什么呢？   
        System.out.println(b);   
    }   
}  运行结果： 1、-7616 [size=6]运算符对基本类型的影响[/size] 当使用+、-、*、/、%运算符对基本类型进行运算时，遵循如下规则： 1、只要两个操作数中有一个是double类型的，另一个将会被转换成double类型，并且结果也是double类型； 
2、否则，只要两个操作数中有一个是float类型的，另一个将会被转换成float类型，并且结果也是float类型； 
3、否则，只要两个操作数中有一个是long类型的，另一个将会被转换成long类型，并且结果也是long类型； 
4、否则，两个操作数（包括byte、short、int、char）都将会被转换成int类型，并且结果也是int类型。 当使用+=、-=、*=、/=、%=、运算符对基本类型进行运算时，遵循如下规则： 1、运算符右边的数值将首先被强制转换成与运算符左边数值相同的类型，然后再执行运算，且运算结果与运算符右边数值类型相同。 了解了这些，我们就能解答下面这个常考的面试题了。请看： 
乍一看，觉得它们都应该没有错误，可以正常运行。我们来写个例子试试： 
Java代码 
public class PrimitiveTypeTest {   
    public static void main(String[] args) {   
        short s1 = 1;   
        // 这一行代码会报编译错误   
        // s1 = s1 + 1;   
        // 这一行代码没有报错   
        s1 = 1 + 1;   
        // 这一行代码也没有报错   
        s1 += 1;   
    }   
}  从例子中我们可以看出结果了。利用上面列举的规律，也很容易解释。在s1=s1+1;中，s1+1运算的结果是int型，把它赋值给一个short型变量s1，所以会报错；而在s1+=1;中，由于是s1是short类型的，所以1首先被强制转换为short型，然后再参与运算，并且结果也是short类型的，因此不会报错。那么，s1=1+1;为什么不报错呢？这是因为1+1是个编译时可以确定的常量，“+”运算在编译时就被执行了，而不是在程序执行的时候，这个语句的效果等同于s1=2，所以不会报错。前面讲过了，对基本类型执行强制类型转换可能得出错误的结果，因此在使用+=、-=、*=、/=、%=等运算符时，要多加注意。 [size=6]Math.round()方法[/size] java.lang.Math类里有两个round()方法，它们的定义如下： 
Java代码 
public static int round(float a) {   
    //other code   
}   
  
public static long round(double a) {   
    //other code   
}  它们的返回值都是整数，且都采用四舍五入法。运算规则如下： 1、如果参数为正数，且小数点后第一位>=5，运算结果为参数的整数部分+1。 
2、如果参数为负数，且小数点后第一位>5，运算结果为参数的整数部分-1。 
3、如果参数为正数，且小数点后第一位<5；或者参数为负数，且小数点后第一位<=5，运算结果为参数的整数部分。 我们可以通过下面的例子来验证： 
Java代码 
public class MathTest {   
    public static void main(String[] args) {   
        System.out.println("小数点后第一位=5");   
        System.out.println("正数：Math.round(11.5)=" + Math.round(11.5));   
        System.out.println("负数：Math.round(-11.5)=" + Math.round(-11.5));   
        System.out.println();   
  
        System.out.println("小数点后第一位<5");   
        System.out.println("正数：Math.round(11.46)=" + Math.round(11.46));   
        System.out.println("负数：Math.round(-11.46)=" + Math.round(-11.46));   
        System.out.println();   
  
        System.out.println("小数点后第一位>5");   
        System.out.println("正数：Math.round(11.68)=" + Math.round(11.68));   
        System.out.println("负数：Math.round(-11.68)=" + Math.round(-11.68));   
    }   
}  运行结果： 1、小数点后第一位=5 
2、正数：Math.round(11.5)=12 
3、负数：Math.round(-11.5)=-11 
4、
5、小数点后第一位<5 
6、正数：Math.round(11.46)=11 
7、负数：Math.round(-11.46)=-11 
8、
9、小数点后第一位>5 
10、正数：Math.round(11.68)=12 
11、负数：Math.round(-11.68)=-12 根据上面例子的运行结果，我们还可以按照如下方式总结，或许更加容易记忆： 1、参数的小数点后第一位<5，运算结果为参数整数部分。 
2、参数的小数点后第一位>5，运算结果为参数整数部分绝对值+1，符号（即正负）不变。 
3、参数的小数点后第一位=5，正数运算结果为整数部分+1，负数运算结果为整数部分。 

Answer 3

[size=6]switch语句 [/size]哪些类型可以用于switch语句的判断呢？我们做个测试就知道了： 
Java代码 
public class MathTest {   
    // 枚举类型，Java5.0以上版本可用   
    static enum enum_e {   
        A, B   
    }   
  
    public static void main(String[] args) {   
        // byte   
        byte byte_n = 0;   
        switch (byte_n) {   
        case 0:   
            System.out.println("byte可以用于switch语句");   
            break;   
        }   
  
        // Byte类   
        Byte byte_m = 0;   
        // 需要Java5.0（1.5）以上版本支持   
        switch (byte_m) {   
        case 0:   
            System.out.println("Byte类可以用于switch语句");   
            System.out.println();   
            break;   
        }   
  
        // char   
        char char_n = 0;   
        switch (char_n) {   
        case 0:   
            System.out.println("char可以用于switch语句");   
            break;   
        }   
  
        // Character类   
        Character char_m = 0;   
        // 需要Java5.0（1.5）以上版本支持   
        switch (char_m) {   
        case 0:   
            System.out.println("Character类可以用于switch语句");   
            System.out.println();   
            break;   
        }   
  
        // short   
        short short_n = 0;   
        switch (short_n) {   
        case 0:   
            System.out.println("short可以用于switch语句");   
            break;   
        }   
  
        // Short   
        Short short_m = 0;   
        // 需要Java5.0（1.5）以上版本支持   
        switch (short_m) {   
        case 0:   
            System.out.println("Short类可以用于switch语句");   
            System.out.println();   
            break;   
        }   
  
        // int   
        int int_n = 0;   
        switch (int_n) {   
        case 0:   
            System.out.println("int可以用于switch语句");   
            break;   
        }   
  
        // Integer类   
        Integer int_m = 0;   
        // 需要Java5.0（1.5）以上版本支持   
        switch (int_m) {   
        case 0:   
            System.out.println("Integer类可以用于switch语句");   
            System.out.println();   
            break;   
        }   
  
        // long   
        long long_n = 0;   
        // 编译错误，long型不能用于switch语句   
        // switch (long_n) {   
        // case 0:   
        // System.out.println("long可以用于switch语句");   
        // break;   
        // }   
  
        // Long类   
        Long long_m = 0L;   
        // 编译错误，Long类型不能用于switch语句   
        // switch (long_m) {   
        // case 0:   
        // System.out.println("Long类可以用于switch语句");   
        // System.out.println();   
        // break;   
        // }   
  
        // float   
        float float_n = 0.0F;   
        // 编译错误，float型不能用于switch语句   
        // switch (float_n) {   
        // case 0.0F:   
        // System.out.println("float可以用于switch语句");   
        // break;   
        // }   
  
        // Float类   
        Float float_m = 0.0F;   
        // 编译错误，Float类型不能用于switch语句   
        // switch (float_m) {   
        // case 0.0F:   
        // System.out.println("Float类可以用于switch语句");   
        // System.out.println();   
        // break;   
        // }   
  
        // double   
        double double_n = 0.0;   
        // 编译错误，double型不能用于switch语句   
        // switch (double_n) {   
        // case 0.0:   
        // System.out.println("double可以用于switch语句");   
        // break;   
        // }   
  
        // Double类   
        Double double_m = 0.0;   
        // 编译错误，Double类型不能用于switch语句   
        // switch (double_m) {   
        // case 0.0:   
        // System.out.println("Double类可以用于switch语句");   
        // System.out.println();   
        // break;   
        // }   
  
        // boolean   
        boolean bool_b = true;   
        // 编译错误，boolean型不能用于switch语句   
        // switch (bool_b) {   
        // case true:   
        // System.out.println("boolean可以用于switch语句");   
        // break;   
        // }   
  
        // Boolean类   
        Boolean bool_l = true;   
        // 编译错误，Boolean类型不能用于switch语句   
        // switch (bool_l) {   
        // case true:   
        // System.out.println("Boolean类可以用于switch语句");   
        // System.out.println();   
        // break;   
        // }   
  
        // String对象   
        String string_s = "Z";   
        // 编译错误，long型不能用于switch语句   
        // switch (string_s) {   
        // case "Z":   
        // System.out.println("String可以用于switch语句");   
        // System.out.println();   
        // break;   
        // }   
  
        // enum（枚举类型，Java5.0以上版本可用）   
        switch (MathTest.enum_e.A) {   
        case A:   
            System.out.println("enum可以用于switch语句-A");   
            break;   
        case B:   
            System.out.println("enum可以用于switch语句-B");   
            break;   
        }   
    }   
}  运行结果如下： 1、byte可以用于switch语句 
2、Byte类可以用于switch语句 
3、
4、char可以用于switch语句 
5、Character类可以用于switch语句 
6、
7、short可以用于switch语句 
8、Short类可以用于switch语句 
9、
10、int可以用于switch语句 
11、Integer类可以用于switch语句 
12、
13、enum可以用于switch语句-A 结果已经出来了，我们来总结一下： 1、byte、char、short、int四种基本类型以及它们的包装类（需要Java5.0/1.5以上版本支持）都可以用于switch语句。 
2、long、float、double、boolean四种基本类型以及它们的包装类（在Java所有版本中）都不能用于switch语句。 
3、enum类型，即枚举类型可以用于switch语句，但是要在Java5.0（1.5）版本以上才支持。 
4、所有类型的对象（包括String类，但在Java5.0/1.5以上版本中，该项要排除byte、char、short、int四种基本类型对应的包装类）都不能用于switch语句。 

Answer 4

think in java中提到了一切都是对象但是我感觉byte,char,int,short,long,float,double,void基本数据类型是不是按对象来处理的

Answer 5

这是java不纯洁的地方,为了效率做的折中,好在比较容易理解.

Answer 6

楼主讲的太详细，又让我重温了下Java基础知识

Answer 7

我看<<core java>>上面提到void也应该算是基本数据类型吧，应该是九种。byte,char,short,int,long,double,floatboolean,void

Answer 8

写得确实不错！不过建议楼主可以附带的讲一下:Integer i1=100;Integer i2=100;System.out.println(i1==i2);Integer i3=100;Integer i4=100;System.out.println(i3==i4);

Answer 9

回复jishu_vip： 这是个非常好的建议，我已经将相关内容添加到这篇文章中了。下面是新增部分的内容，也欢迎大家到我的博客查看最新版本：
http://zangweiren.javaeye.com/blog/219369

Answer 10

当使用“==”运算符在基本类型和其包装类对象之间比较时，遵循如下规则： 只要两个操作数中有一个是基本类型，就是比较它们的数值是否相等。 
否则，就是判断这两个对象的内存地址是否相等，即是否是同一个对象。 下面的测试例子则验证了以上的规则： 
Java代码 
public class EqualsTest {   
    public static void main(String[] args) {   
        // int类型用int类型初始化   
        int int_int = 0;   
        // int类型用Integer类型初始化   
        int int_Integer = new Integer(0);   
        // Integer类型用Integer类型初始化   
        Integer Integer_Integer = new Integer(0);   
        // Integer类型用int类型初始化   
        Integer Integer_int = 0;   
  
        System.out.println("int_int == int_Integer结果是："  
                + (int_int == int_Integer));   
        System.out.println("Integer_Integer == Integer_int结果是："  
                + (Integer_Integer == Integer_int));   
        System.out.println();   
        System.out.println("int_int == Integer_Integer结果是："  
                + (int_int == Integer_Integer));   
        System.out.println("Integer_Integer == int_int结果是："  
                + (Integer_Integer == int_int));   
        System.out.println();   
  
        // boolean类型用boolean类型初始化   
        boolean boolean_boolean = true;   
        // boolean类型用Boolean类型初始化   
        boolean boolean_Boolean = new Boolean(true);   
        // Boolean类型用Boolean类型初始化   
        Boolean Boolean_Boolean = new Boolean(true);   
        // Boolean类型用boolean类型初始化   
        Boolean Boolean_boolean = true;   
  
        System.out.println("boolean_boolean == boolean_Boolean结果是："  
                + (boolean_boolean == boolean_Boolean));   
        System.out.println("Boolean_Boolean == Boolean_boolean结果是："  
                + (Boolean_Boolean == Boolean_boolean));   
        System.out.println();   
        System.out.println("boolean_boolean == Boolean_Boolean结果是："  
                + (boolean_boolean == Boolean_Boolean));   
        System.out.println("Boolean_Boolean == boolean_boolean结果是："  
                + (Boolean_Boolean == boolean_boolean));   
    }   
}  运行结果： int_int == int_Integer结果是：true 
Integer_Integer == Integer_int结果是：false int_int == Integer_Integer结果是：true 
Integer_Integer == int_int结果是：true boolean_boolean == boolean_Boolean结果是：true 
Boolean_Boolean == Boolean_boolean结果是：false boolean_boolean == Boolean_Boolean结果是：true 
Boolean_Boolean == boolean_boolean结果是：true 为了便于查看，上例中变量命名没有采用规范的方式，而是采用了“变量类型”+“_”+“初始化值类型”的方式。

Answer 11

我的文章里也提到了void以及它的包装类java.lang.Void，不过因为我们无法直接操作它们，所以没有把它包含进来。
我会在新的版本里会做调整。

Answer 12

先Mark 以便以后继续关注。