`
chenliang1234576
  • 浏览: 194920 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

java基本类型(内置类型)取值范围

    博客分类:
  • Java
阅读更多

例1:

  1. public class PrimitiveTypeTest {   
  2.     public static void main(String[] args) {   
  3.         // byte   
  4.         System.out.println("基本类型:byte 二进制位数:" + Byte.SIZE);   
  5.         System.out.println("包装类:java.lang.Byte");   
  6.         System.out.println("最小值:Byte.MIN_VALUE=" + Byte.MIN_VALUE);   
  7.         System.out.println("最大值:Byte.MAX_VALUE=" + Byte.MAX_VALUE);   


运行结果:

  1. 基本类型:byte 二进制位数:8
  2. 包装类:java.lang.Byte
  3. 最小值:Byte.MIN_VALUE=-128
  4. 最大值:Byte.MAX_VALUE=127
  5. 补充基本类型:short 二进制位数:16
  6. 包装类:java.lang.Short
  7. 最小值:Short.MIN_VALUE=-32768
  8. 最大值:Short.MAX_VALUE=32767
  9. 基本类型:int 二进制位数:32
  10. 包装类:java.lang.Integer
  11. 最小值:Integer.MIN_VALUE=-2147483648
  12. 最大值:Integer.MAX_VALUE=2147483647
  13. 基本类型:long 二进制位数:64
  14. 包装类:java.lang.Long
  15. 最小值:Long.MIN_VALUE=-9223372036854775808
  16. 最大值:Long.MAX_VALUE=9223372036854775807
  17. 基本类型:float 二进制位数:32
  18. 包装类:java.lang.Float
  19. 最小值:Float.MIN_VALUE=1.4E-45
  20. 最大值:Float.MAX_VALUE=3.4028235E38
  21. 基本类型:double 二进制位数:64
  22. 包装类:java.lang.Double
  23. 最小值:Double.MIN_VALUE=4.9E-324
  24. 最大值:Double.MAX_VALUE=1.7976931348623157E308
  25. 基本类型:char 二进制位数:16
  26. 包装类:java.lang.Character
  27. 最小值:Character.MIN_VALUE=0
  28. 最大值:Character.MAX_VALUE=65535

例2:

  1. public class PrimitiveTypeTest {   
  2.     public static void main(String[] args) {   
  3.         // 给byte类型变量赋值时,数字后无需后缀标识   
  4.         byte byte_a = 1;   
  5.         // 编译器会做范围检查,如果赋予的值超出了范围就会报错   
  6.         // byte byte_b = 1000;   
  7.         // 把一个long型值赋值给byte型变量,编译时会报错,即使这个值没有超出byte类型的取值范围   
  8.         // byte byte_c = 1L;   
  9.   
  10.         // 给short类型变量赋值时,数字后无需后缀标识   
  11.         short short_a = 1;   
  12.         // 编译器会做范围检查,如果赋予的值超出了范围就会报错   
  13.         // short short_b = 70000;   
  14.         // 把一个long型值赋值给short型变量,编译时会报错,即使这个值没有超出short类型的取值范围   
  15.         // byte short_c = 1L;   
  16.   
  17.         // 给short类型变量赋值时,数字后无需后缀标识   
  18.         int int_a = 1;   
  19.         // 编译器会做范围检查,如果赋予的值超出了范围就会报错   
  20.         // int int_b = 2200000000;   
  21.         // 把一个long型值赋值给int型变量,编译时会报错,即使这个值没有超出int类型的取值范围   
  22.         // int int_c = 1L;   
  23.   
  24.         // 可以把一个int型值直接赋值给long型变量,数字后无需后缀标识   
  25.         long long_a = 1;   
  26.         // 如果给long型变量赋予的值超出了int型值的范围,数字后必须加L(不区分大小写)标识   
  27.         long long_b = 2200000000L;   
  28.         // 编译器会做范围检查,如果赋予的值超出了范围就会报错   
  29.         // long long_c = 9300000000000000000L;   
  30.   
  31.         // 可以把一个int型值直接赋值给float型变量   
  32.         float float_a = 1;   
  33.         // 可以把一个long型值直接赋值给float型变量   
  34.         float float_b = 1L;   
  35.         // 没有F(不区分大小写)后缀标识的浮点数默认为double型的,不能将它直接赋值给float型变量   
  36.         // float float_c = 1.0;   
  37.         // float型数值需要有一个F(不区分大小写)后缀标识   
  38.         float float_d = 1.0F;   
  39.         // 把一个double型值赋值给float型变量,编译时会报错,即使这个值没有超出float类型的取值范围   
  40.         // float float_e = 1.0D;   
  41.         // 编译器会做范围检查,如果赋予的值超出了范围就会报错   
  42.         // float float_f = 3.5000000E38F;   
  43.   
  44.         // 可以把一个int型值直接赋值给double型变量   
  45.         double double_a = 1;   
  46.         // 可以把一个long型值直接赋值给double型变量   
  47.         double double_b = 1L;   
  48.         // 可以把一个float型值直接赋值给double型变量   
  49.         double double_c = 1F;   
  50.         // 不带后缀标识的浮点数默认为double类型的,可以直接赋值   
  51.         double double_d = 1.0;   
  52.         // 也可以给数字增加一个D(不区分大小写)后缀标识,明确标出它是double类型的   
  53.         double double_e = 1.0D;   
  54.         // 编译器会做范围检查,如果赋予的值超出了范围就会报错   
  55.         // double double_f = 1.8000000000000000E308D;   
  56.   
  57.         // 把一个double型值赋值给一个byte类型变量,编译时会报错,即使这个值没有超出byte类型的取值范围   
  58.         // byte byte_d = 1.0D;   
  59.         // 把一个double型值赋值给一个short类型变量,编译时会报错,即使这个值没有超出short类型的取值范围   
  60.         // short short_d = 1.0D;   
  61.         // 把一个double型值赋值给一个int类型变量,编译时会报错,即使这个值没有超出int类型的取值范围   
  62.         // int int_d = 1.0D;   
  63.         // 把一个double型值赋值给一个long类型变量,编译时会报错,即使这个值没有超出long类型的取值范围   
  64.         // long long_d = 1.0D;   
  65.   
  66.         // 可以用字符初始化一个char型变量   
  67.         char char_a = 'a';   
  68.         // 也可以用一个int型数值初始化char型变量   
  69.         char char_b = 1;   
  70.         // 把一个long型值赋值给一个char类型变量,编译时会报错,即使这个值没有超出char类型的取值范围   
  71.         // char char_c = 1L;   
  72.         // 把一个float型值赋值给一个char类型变量,编译时会报错,即使这个值没有超出char类型的取值范围   
  73.         // char char_d = 1.0F;   
  74.         // 把一个double型值赋值给一个char类型变量,编译时会报错,即使这个值没有超出char类型的取值范围   
  75.         // char char_e = 1.0D;   
  76.         // 编译器会做范围检查,如果赋予的值超出了范围就会报错   
  77.         // char char_f = 70000;   
  78.     }   
  79. }  
例3:

  1. public class PrimitiveTypeTest {   
  2.     public static void main(String[] args) {   
  3.         short s1 = 1;   
  4.         // 这一行代码会报编译错误   
  5.         // s1 = s1 + 1;   
  6.         // 这一行代码没有报错   
  7.         s1 = 1 + 1;   
  8.         // 这一行代码也没有报错   
  9.         s1 += 1;   
  10.     }   
  11. }  

例4:

  1. public class EqualsTest {   
  2.     public static void main(String[] args) {   
  3.         // int类型用int类型初始化   
  4.         int int_int = 0;   
  5.         // int类型用Integer类型初始化   
  6.         int int_Integer = new Integer(0);   
  7.         // Integer类型用Integer类型初始化   
  8.         Integer Integer_Integer = new Integer(0);   
  9.         // Integer类型用int类型初始化   
  10.         Integer Integer_int = 0;   
  11.   
  12.         System.out.println("int_int == int_Integer结果是:"  
  13.                 + (int_int == int_Integer));   
  14.         System.out.println("Integer_Integer == Integer_int结果是:"  
  15.                 + (Integer_Integer == Integer_int));   
  16.     }   
  17. }  

运行结果:

  1. int_int == int_Integer结果是:true
  2. Integer_Integer == Integer_int结果是:false
分享到:
评论
1 楼 noodiewm 2013-02-25  
嗯,很好用的基础文章,多谢分享。

相关推荐

Global site tag (gtag.js) - Google Analytics