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

最新推荐文章于 2025-08-08 22:01:10 发布

转载最新推荐文章于 2025-08-08 22:01:10 发布 · 306 阅读

文章标签：

#java #面试 #float #byte #编译器 #string

java技术专栏收录该内容

29 篇文章

订阅专栏

本文深入探讨了Java中基本类型的特性和应用，包括九种基本类型及其包装类的详细信息，以及数值类型、字符类型和布尔类型的取值范围。通过代码示例展示了基本类型在赋值、参数传递和数学运算中的使用方式，并解释了不同类型之间的转换规则。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

基本类型，或者叫做内置类型，是JAVA中不同于类的特殊类型。它们是我们编程中使用最频繁的类型，因此面试题中也总少不了它们的身影，在这篇文章中我们将从面试中常考的几个方面来回顾一下与基本类型相关的知识。

基本类型共有九种，它们分别都有相对应的包装类。关于它们的详细信息请看下表：

[img]http://zangweiren.javaeye.com/upload/picture/pic/18450/8071c6c2-7cfb-3783-829a-a6abb3ae55e5.jpg [/img]

对于基本类型void以及它的包装类java.lang.Void，我们都无法直接进行操作。基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。请看下面的例子：

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);
    }
}
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);
}
}
运行结果：

基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127
基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767
基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647
基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807
基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38
基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308
基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：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修饰，因此我们无法继承它们扩展新的类，也无法重写它们的任何方法。

各种数值类型之间的赋值与转换遵循什么规律呢？我们来看下面这个例子：

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;
    }
}
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 doub