Java源码解读(一) 8种基本类型对应的封装类型

提及源码其实第一个要看的应该是咱们的父类Object，这里就不对它进行描述了你们各自对其进行阅读便可（其中留意wait()方法可能会存在虚假唤醒的状况）。

1、八种基本类型

接下来介绍咱们的八种基本类型（这个你们都知道吧）：char、byte、short、int、long、float、double、boolean。这里也不太描述其过多的东西，只说些要特别注意的事项（若是我这存在遗落的，欢迎你们补充）：

一、byte、short、char 不能进行含有变量的运算符运算（正常的运算符），都要求进行强转，由于都有范围限制。

 可是能够进行+= 和自增增减的操做。

二、自动转型等级：byte,short,char(同级)-> int -> long -> float -> double (由低精度到高精度)，同级不能自动转型，须要强制转换

 

2、八种封装类型

先说共同点：

• equals方法：

　　只有同一类型的才能做比较，而后再比较其值。源码以short为例，其它几个都同样。

    public boolean equals(Object obj) {
        if (obj instanceof Short) {
            return value == ((Short)obj).shortValue();
        }
        return false;
    }

　　因此不一样类型的无论值是否相等都是false;

    @Test
    public void testEquals(){
        Short num1 = 1;
        Integer num2 = 1;
        Long num3 = 1L;
        System.out.println(num1.equals(num2));//false
        System.out.println(num2.equals(num3));//false
    }

•  直接赋值时，都会调用valueOf方法。因此要注意其的源代码。

不一样点：

一、Character

• 注意valueOf中代码，它缓存了ASCII码0~127的字符。其余均会建立实例。

 

二、Byte

• 范围是-128~127，因此超过这个范围会要求强制转换。若是使用Byte(String s)建立实例的话，超过范围会抛出异常：NumberFormatException
• 注意valueOf中的代码，它缓存了-128~127，因此直接赋值是不建立新实例的。

    @Test
    public void testByte(){
        //byte的范围是-128~127，针对byte若是赋值不在范围eclipse会要求强制转型成byte.
        //封装类型Byte  new Byte("128")当使用字符串建立实例时，其中值超过范围会报错NumberFormatException。
        byte b1 = 12;
        Byte b2 = 12;//(byte)129;//超过范围要求强转
        Byte b3 = 12;//(byte)129;
        //Byte b4 = new Byte("128");//抛出异常
        Byte b4 = new Byte("12");//抛出异常
        System.out.println(b1 == b2);//true
        System.out.println(b2 == b3);//true
        System.out.println(b2 == b4);//false
    }

 

三、Short

• 跟byte的第一点同样，只是范围（-32768 ~ 32767）不同
• 注意valueOf方法，它缓存了-128~127的值，超过这个范围（-128~127）就会建立新的实例。
• 基于第二种状况，不便于进行循环遍历复制操做，不然超过范围就会多个实例，影响内存。

    @Test
    public void testShort(){
        //一、short范围：-32768 ~ 32767
        Short s = new Short("32767");//超过范围会报错 NumberFormatException
        s = new Short((short)327671);//超过这个范围自动转换
        
        //二、装箱与拆箱 自动转型
        short s1 = 12;
        Short s2 = new Short(s1);//手动装箱
        System.out.println("s1 == s2:" + (s1 == s2));//自动拆箱  true
        
        //三、valueOf方法缓存了-128~127的范围，超过这个范围就要另外建立这个实例。
        Short s3 = 12;
        Short s4 = 12;
        Short s5 = 128;
        Short s6 = 128;
        System.out.println("s3 == s4:" + (s3 == s4)); //true
        System.out.println("s5 == s6:" + (s5 == s6)); //false
        
        //四、因为上面这个特性，因此这种包装类型不能在循环遍历中赋值。否则其值超过这个范围的话，就会建立新的对象，若是不少的话，就会建立不少对象。浪费空间。
    }

 

四、Integer

• 承受的值要注意范围（-2147483648 ~ 2147483647 ），不要求强转。
• 注意valueOf方法,跟Short的方法同样，缓存了-128~127的值，超过这个范围（-128~127）就会建立新的实例。

• 基于第二种状况，不便于进行循环遍历复制操做，不然超过范围就会多个实例，影响内存。

     @Test
      public void testInteger(){
          //一、Integer范围：-2147483648  ~ 2147483647 
          //后面与Short同样
          //二、装箱与拆箱 自动转型
          int s1 = 12;
          Integer s2 = new Integer(s1);//手动装箱
          System.out.println("s1 == s2:" + (s1 == s2));//自动拆箱 true
          
          //三、valueOf方法缓存了-128~127的范围，超过这个范围就要另外建立这个实例。
          Integer s3 = 12;
          Integer s4 = 12;
          Integer s5 = 128;
          Integer s6 = 128;
          System.out.println("s3 == s4:" + (s3 == s4));//true
          System.out.println("s5 == s6:" + (s5 == s6));//false
          //四、因为上面这个特性，因此这种包装类型不能在循环遍历中赋值。否则其值超过这个范围的话，就会建立新的对象，若是不少的话，就会建立不少对象。浪费空间。
      }

 

五、Long

• 承受的值要注意范围（-9223372036854775808 ~ 9223372036854775807 ），不要求强转。
• 注意valueOf方法,跟Short的方法同样，缓存了-128~127的值，超过这个范围（-128~127）就会建立新的实例。
• 基于第二种状况，不便于进行循环遍历复制操做，不然超过范围就会多个实例，影响内存。

      @Test
      public void testLong(){
          //范围就不考虑了。
          //一样、valueOf方法缓存了-128~127的范围，超过这个范围就要另外建立这个实例。
          Long s3 = 12L;
          Long s4 = 12L;
          Long s5 = 128L;
          Long s6 = 128L;
          System.out.println("s3 == s4:" + (s3 == s4));//true
          System.out.println("s5 == s6:" + (s5 == s6));//false
          //因为上面这个特性，因此这种包装类型不能在循环遍历中赋值。否则其值超过这个范围的话，就会建立新的对象，若是不少的话，就会建立不少对象。浪费空间。
      } 

六、Float

• 承受的值要注意范围（-1.4E-45~ 3.4028235E38），不要求强转。
• 注意valueOf方法，跟前面的Short、Integer、Long不同了，直接建立实例。　　
• 因此相等值的两个变量 ==运算是false.
• 不要作加减法运算。精度（9位）问题。

    @Test
    public void testFloat(){
        //没有特殊要注意的，其余跟上面同样
        int f = 1;
        Float f1 = 1F;
        Float f2 = new Float(f);
        System.out.println(f == f1);//true
        System.out.println(f1 == f2);//false
        //注意不要用这类型作加减运算，精度问题会影响。
        System.out.println(f1 - 0.1f*9);//0.099999964
    }

 

七、Double

• 承受的值要注意范围，不要求强转。
• 注意valueOf方法，与float同样，直接建立实例。

　　因此相等值的两个变量 ==运算是false.

• 不要作加减法运算。精度（17位）问题。

    @Test
    public void testDouble(){
        //注意不要用这类型作加减运算，精度问题会影响。
        System.out. println(1.0 - 0.1*9);//0.09999999999999998
        //valueof 
        Double i1 = 100.0;
        Double i2 = 100.0;
        Double i3 = 200.0;
        Double i4 = 200.0;
        System.out.println(i1==i2);//false
        System.out.println(i3==i4);//false
    }

八、Boolean

• valueof方法

 

　　缓存了两个方法，因此若是是一样的赋值，== 运算是为true的。

    @Test
    public void testEquals(){
        Short num1 = 1;
        Integer num2 = 1;
        Long num3 = 1L;
        System.out.println(num1.equals(num2));//false
        System.out.println(num2.equals(num3));//false
    }

 3、案例分析

　　猜猜下面各个输出的结果是什么：

@Test
    public void test1(){
        Integer a = 1;
        Integer b = 2;
        Integer c = 3;
        Integer d = 3;
        Integer e = 321;
        Integer f = 321;
        Long g = 3L;
        Long h = 2L;
         
        System.out.println(c==d);
        System.out.println(e==f);
        System.out.println(c==(a+b));
        System.out.println(c.equals(a+b));
        System.out.println(g==(a+b));
        System.out.println(g.equals(a+b));
        System.out.println(g.equals(a+h));
    }

　　其中会涉及到拆箱与装箱（自行弄懂）的问题。针对个别解析以下：

　　c==(a+b) ：a+b都会拆箱成int而后相加，因此c也会自动拆箱比较。

　　g==(a+b)：同理，a+b都会拆箱成int而后相加，g会拆箱成long类型。因此基本类型比较只要比较其值便可。

　　g.equals(a+b)：先拆箱a+b再装箱仍是Integer，这里不会自动转型。Long类型的equals判断不是同一类型直接返回false

　　g.equals(a+h)：同上,先拆箱a+h再装箱（这里会自动向上转型）为Long,因此同类型的比较值又相等，这里返回true.

　　最终结果以下：

true
false
true
true
true
false
true