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

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. System.out.println("int_int == int_Integer结果是："
12. + (int_int == int_Integer));
13. System.out.println("Integer_Integer == Integer_int结果是："
14. + (Integer_Integer == Integer_int));
15. }
16. }

运行结果：

1. int_int == int_Integer结果是：true
2. Integer_Integer == Integer_int结果是：false