Java中的八种基本数据类型详解

@Test

     public void d() {

         int a= 100 ; //这个100就是直接量

         a=a+ 100 ; //但是这个a+100不是直接量

         double b= 3.14 ;

     }

@Test

     public void e(){

         long a= 200 ; //200是直接量，默认为int类型这里是自动转换为弄类型

         /*long b=100000000000;*/

         //100000000000是个整数直接量，默认应该为int类型，但是超出了int类型的取值范围

         long c=1000000000000L;

         //在整数直接量后面将了一个L，表示该直接量不再默认为int类型，为long类型，所以没错

         /*float d=34.3;*/

         //浮点型直接量默认为double,double类型大，所以不能直接转换为float

         float e= 34 .3f;

         //在浮点数直接量后面加上一个f，表示该直接量不再默认为double，为float类型

     }

@Test

     public void f() {

         byte a= 100 ;

         short b= 200 ;

         char c= 100 ; //注意char类型是一种特殊的int类型，可以不用写成单引号括起来的

         /*byte d=128;直接量128超出了byte类型的取值范围*/

         /*char e=-1;直接量-1不在char类型的取值范围内*/

     }

@Test

     public void g() {

         int a= 3 ;

         double b= 4 ;

         System.out.println(a+b); //输出7.0

         float c= 3 .2f;

         /*c=c+3.14; 编译错误,运算之后变为double类型*/   

     }

@Test

public void h() {

     byte a= 3 ;

     byte b= 4 ;

     /*byte c=a+b;

      * 编译错误,此处由于byte类型参与运算时，先直接转换为int类型，

      * 所以最后的结果也是int类型，但是得出的结果不能叫做int类型的直接量，所以编译错误

      * */

     int d=a+b;

}

@Test

     public void j() {

         int a= 128 ;

         byte b=( byte )a;

         System.out.println(b); //输出-128，出现了数据溢出

         double c= 1.23 ;

         int d=( int )c;

         System.out.println(d); //输出1，精度丢失

     }

@Test

     public void k() {

         int a= 10000000 ;

         int b= 10000000 ;

         int c=a*b;

         System.out.println(c); //输出276447232，得到的结果超出了int类型的范围，数据溢出

     }

@Test

     public void a() {

     /*1.参数为基本数据类型      

      * 作用：将基本数据类型转换为对应包装类 * */

         Integer i=Integer.valueOf( 10 );

         System.out.println(i); //输出10

     /*2.参数为String字符串时，

      * 作用：返回指定字符串值的包装类对象

      *  */

         Integer a=Integer.valueOf( "100" );

         System.out.println(a); //输出100

         Integer b=Integer.valueOf( "100a" )为

         System.out.println(b); //运行错误，字符串的值不少一个int类型的

     }

@Test

     public void b() {

         /*作用：将给定字符串装换为对应的基本数据类型

          * 前提是该字符串必须正确描述该基本数据类型表示的值*/

         int a=Integer.parseInt( "100" );

         System.out.println(a); //输出100

         int b=Integer.parseInt( "100a" );

         System.out.println(b); //运行错误，字符串的值不为int类型

     }

@Test

     public void c() {

         /*作用：将包装类对象转换为对应的基本数据类型*/

         Integer a=Integer.valueOf( 100 ); //将基本数据类型转换为包装类对象

         int b=a.intValue(); //将包装类对象转换为对应的基本数据类型

         System.out.println(b); //输出100

         Double c=Double.valueOf( 2.33 );

         double d=c.doubleValue();

         System.out.println(d);

     }

@Test

     public void d() {

         /*自动装箱：valueOf*/

         Integer i= 123 ; //原理是 Integer i=Integer.valueOf(123);

         /*自动拆箱*/

         int i1=i+ 1 ; //原理是    int i1=i.intValue()+1;

         Integer a= 123 ;

         Integer b= 123 ;

         Integer c=a+b;

         /*原理为Integer c=Integer.valueOf(a.intValue()+b.intValue());*/

     }

public static Integer valueOf( int i) {

        if (i >= IntegerCache.low && i <= IntegerCache.high)

            return IntegerCache.cache[i + (-IntegerCache.low)];

        return new Integer(i);

    }

public static void main(String[] args) {

         int a= 10 ;

         double b= 3.4 ;

         System.out.println(a>b?a:b);

         System.out.println(a);

     }

/*输出：10.0   10

解析：这里是一个很容易让人不注意的类型转化，这里a与b参与了运算，

所以类型向类型大的方向转化，10就变成了10.0，但是a本身是没有变化的*/

public static void main(String[] args) {

         short a= 1 ;  //第一行

          a=a+ 1 ;     //第二行

          a+= 1 ;      //第三行

}

/*第几行的代码会出错？

答案：第二行会出错，由于a+1变为了int类型,而int类型不能直接赋值给short类型

但是+=这种情况是特殊的，所以不会出错；

*/

public static void main(String[] args) {

         Integer a1= 127 ;

         Integer a2= 127 ;

         int a3= 127 ;

         Integer b1= 128 ;

         Integer b2= 128 ;

         int b3= 128 ;

         System.out.println(a1==a2);

         System.out.println(a1==a3);

         System.out.println(b1==b2);

         System.out.println(b1==b3);

}

/*输出：true true false true

解析：自动装箱时采用valueOf方法，由于127在静态数组的范围内，所以不是new的，

而128的两个引用是指向new出现对象的，所以第一个是true，第三个是false。

而包装类和基本数据类型比较时，只要数值是相等的，就相等

*/

public static void main(String[] args) {

         System.out.println( 0.1 * 3 == 0.3 );

         System.out.println( 0.1 * 4 );

}

/*输出：false 0.4

解析：有些浮点数不能准确的表示出来，与整数相乘之后出精度丢失，常见为小数位含3的

*/