Java 基本数据类型详解：类型、范围及转换规则

Java 基本数据类型详解：类型、范围及转换规则 | 极客日志

public class ByteExample {
    public static void main(String[] args) {
        byte age = 25; // 合法，25 在 byte 范围内
        byte minValue = Byte.MIN_VALUE; // -128
        byte maxValue = Byte.MAX_VALUE; // 127

        System.out.println("年龄：" + age);
        System.out.println("byte 最小值：" + minValue);
        System.out.println("byte 最大值：" + maxValue);

        // byte invalidByte = 128; // 编译错误：超出范围
        // byte anotherInvalidByte = -129; // 编译错误：超出范围

        // 类型转换示例
        int intNum = 130;
        byte convertedByte = (byte) intNum; // 强制类型转换
        System.out.println("将 int " + intNum + " 转换为 byte 后的值：" + convertedByte); // 输出 -126 (因为 130 - 256 = -126)
    }
}

public class ShortExample {
    public static void main(String[] args) {
        short temperature = -5; // 合法
        short minValue = Short.MIN_VALUE; // -32768
        short maxValue = Short.MAX_VALUE; // 32767

        System.out.println("温度：" + temperature);
        System.out.println("short 最小值：" + minValue);
        System.out.println("short 最大值：" + maxValue);
        
        // short invalidShort = 32768; // 编译错误：超出范围
    }
}

public class IntExample {
    public static void main(String[] args) {
        int studentCount = 150; // 合法
        int minValue = Integer.MIN_VALUE; // -2147483648
        int maxValue = Integer.MAX_VALUE; // 2147483647

        System.out.println("学生数：" + studentCount);
        System.out.println("int 最小值：" + minValue);
        System.out.println("int 最大值：" + maxValue);

        // 整数溢出 (Integer Overflow) 示例
        int overflow = maxValue + 1;
        System.out.println("int 最大值 + 1 = " + overflow); // 输出 -2147483648，发生了溢出，这是一个 bug 的常见来源
    }
}

public class LongExample {
    public static void main(String[] args) {
        // 注意：long 类型的字面量需要在末尾加 'L' 或 'l'
        long fileSize = 1024L * 1024L * 1024L; // 1GB
        long minValue = Long.MIN_VALUE;
        long maxValue = Long.MAX_VALUE;

        System.out.println("文件大小：" + fileSize + " bytes");
        System.out.println("long 最小值：" + minValue);
        System.out.println("long 最大值：" + maxValue);

        // 如果不加 'L'，10 * 1000 * 1000 * 1000 会先按 int 计算，导致溢出
        long correctWay = 10L * 1000 * 1000 * 1000; // 正确，结果为 10,000,000,000
        long wrongWay = 10 * 1000 * 1000 * 1000;    // 错误，计算过程中 int 溢出，结果不正确
        System.out.println("正确计算：" + correctWay);
        System.out.println("错误计算：" + wrongWay);
    }
}

public class FloatExample {
    public static void main(String[] args) {
        // 注意：float 类型的字面量需要在末尾加 'f' 或 'F'
        float pi = 3.14159f;
        float gravity = 9.8f;

        System.out.println("π 的近似值：" + pi);
        System.out.println("重力加速度：" + gravity + " m/s²");

        // 精度问题示例
        float a = 0.1f;
        float b = 0.2f;
        float sum = a + b;
        System.out.println("0.1f + 0.2f = " + sum); // 可能输出 0.30000001 或 0.29999998，而不是精确的 0.3
    }
}

public class DoubleExample {
    public static void main(String[] args) {
        // double 是默认的浮点类型，无需后缀
        double precisePi = 3.141592653589793;
        double e = 2.718281828459045;

        System.out.println("π 的更精确值：" + precisePi);
        System.out.println("自然常数 e: " + e);

        // 精度问题依然存在，只是比 float 好
        double x = 0.1;
        double y = 0.2;
        double z = x + y;
        System.out.println("0.1 + 0.2 = " + z); // 可能输出 0.30000000000000004

        // 比较浮点数时要小心，不要使用 ==
        if (z == 0.3) {
            System.out.println("z 等于 0.3");
        } else {
            System.out.println("z 不等于 0.3"); // 这行会被执行
        }
        
        // 正确的比较方式是检查它们的差值是否小于一个很小的 epsilon
        final double EPSILON = 1e-10;
        if (Math.abs(z - 0.3) < EPSILON) {
            System.out.println("z 约等于 0.3 (使用 epsilon 比较)"); // 这行会被执行
        }
    }
}

public class CharExample {
    public static void main(String[] args) {
        char grade = 'A';
        char dollarSign = '$';
        char heart = '\u2665'; // 使用 Unicode 转义序列表示字符
        char newLine = '\n';   // 转义字符：换行
        char tab = '\t';       // 转义字符：制表符

        System.out.println("成绩等级：" + grade);
        System.out.println("美元符号：" + dollarSign);
        System.out.println("爱心符号：" + heart);
        
        System.out.println("Hello" + newLine + "World!");
        System.out.println("Name:\tAlice");
        
        // char 可以参与算术运算，使用的是其 Unicode 编码值
        char ch = 'a';
        int asciiValue = (int) ch; // 将 char 转换为 int，得到其 ASCII 码值
        System.out.println("'a' 的 ASCII 码值是：" + asciiValue); // 输出 97
        
        char nextChar = (char) (ch + 1); // 'a' + 1 = 'b'
        System.out.println("'a' 后面的字符是：" + nextChar); // 输出 b
    }
}

public class BooleanExample {
    public static void main(String[] args) {
        boolean isRaining = false;
        boolean hasPassed = true;

        System.out.println("正在下雨吗？" + isRaining);
        System.out.println("考试通过了吗？" + hasPassed);

        int x = 10;
        int y = 20;
        boolean isGreater = x > y; // 比较运算，结果为 false
        
        System.out.println(x + " 大于 " + y + " 吗？" + isGreater);
        
        // boolean 数组内存优化示例
        boolean[] flags = new boolean[1000];
        // 每个元素理论上只占 1 位，1000 个元素约占 125 字节
        System.out.println("boolean 数组长度：" + flags.length);
    }
}

数据类型	默认值
`byte`	`0`
`short`	`0`
`int`	`0`
`long`	`0L`
`float`	`0.0f`
`double`	`0.0d`
`char`	`'\u0000'`
`boolean`	`false`

public class DefaultValueExample {
    // 成员变量，会被赋予默认值
    static int memberInt;
    static boolean memberBoolean;
    static char memberChar;

    public static void main(String[] args) {
        System.out.println("成员变量 int 的默认值：" + memberInt);       // 输出 0
        System.out.println("成员变量 boolean 的默认值：" + memberBoolean); // 输出 false
        System.out.println("成员变量 char 的默认值 (为空字符): '" + memberChar + "'"); // 输出一个不可见的空字符
        
        // 局部变量，必须显式初始化
        // int localInt;  
        // System.out.println(localInt); // 编译错误：变量 'localInt' 可能尚未初始化
    }
}

public class AutoConversionExample {
    public static void main(String[] args) {
        int myInt = 100;
        long myLong = myInt; // int -> long，自动转换
        double myDouble = myLong; // long -> double，自动转换
        
        System.out.println("int: " + myInt);
        System.out.println("long: " + myLong);
        System.out.println("double: " + myDouble);
        
        char myChar = 'A'; // 'A' 的 ASCII 码是 65
        int charToInt = myChar; // char -> int，自动转换
        System.out.println("char 'A' 转换为 int: " + charToInt); // 输出 65
    }
}

public class ExplicitConversionExample {
    public static void main(String[] args) {
        double myDouble = 9.78;
        int myInt = (int) myDouble; // 强制转换，小数部分被舍弃
        
        System.out.println("double: " + myDouble);
        System.out.println("int: " + myInt); // 输出 9，而不是 10
        
        long myLong = 1234567890123L;
        int longToInt = (int) myLong; // 强制转换，可能发生溢出
        
        System.out.println("long: " + myLong);
        System.out.println("int (可能溢出): " + longToInt); // 结果是一个不确定的负数或正数
        
        // boolean 不能与任何其他类型进行转换
        // boolean b = true;
        // int i = (int) b; // 编译错误
    }
}

整数溢出：这是最常见的错误之一。在进行加法、乘法等运算时，要时刻警惕结果是否会超出变量类型的范围。
- 最佳实践：
  - 优先使用范围更大的类型（如用 long 代替 int）进行中间计算。
  - 在关键计算前，进行范围检查。
  - 对于需要任意精度的计算，使用 java.math.BigInteger。
浮点数精度：永远记住 float 和 double 是不精确的。
- 最佳实践：
  - 不要使用 == 来比较浮点数。
  - 使用一个小的 epsilon 值来比较浮点数的近似相等性。
  - 对于货币、税务等需要精确十进制表示的场景，使用 java.math.BigDecimal。
char 的 Unicode 处理：char 只能表示 BMP（Basic Multilingual Plane）中的字符。对于超出 BMP 的字符（如 emoji），需要用 String 来表示。
- 最佳实践：在处理可能包含复杂字符的文本时，优先使用 String 和 Character 类的方法（如 Character.isLetter(int codePoint)），而不是直接操作 char。
选择合适的类型：
- 最佳实践：
  - 对于整数，默认使用 int。如果范围不够，再考虑 long。
  - 对于小数，默认使用 double。只有在内存极度紧张且精度要求不高时，才考虑 float。
  - 对于单个字符，使用 char。
  - 对于 true/false，使用 boolean。
  - 为了代码的可读性和健壮性，不要为了一点点内存节省而过度使用 byte 和 short，除非你能证明这确实是性能瓶颈。
包装类的使用：每个基本数据类型都有一个对应的包装类（Wrapper Class），如 Integer 对应 int，Double 对应 double。包装类是对象，可以为 null。
- 最佳实践：
  - 在集合（如 List、Map）中，必须使用包装类，因为集合只能存储对象。
  - 当需要表示一个可能不存在的数值（例如，从数据库查询一个可为空的字段）时，使用包装类（Integer 可以是 null，而 int 不能）。
  - 注意自动装箱（Autoboxing）和自动拆箱（Unboxing）可能带来的性能开销和 NullPointerException 风险。例如：Integer i = null; int j = i; 会抛出 NullPointerException。

Java 基本数据类型详解：类型、范围及转换规则

Java 语言基本数据类型全面解析

1. 数据类型分类

2. 8 种基本数据类型详解

2.1 整数类型 (Integral Types)

2.1.1 `byte`

2.1.2 `short`

2.1.3 `int`

2.1.4 `long`

2.2 浮点类型 (Floating-Point Types)

2.2.1 `float`

2.2.2 `double`

2.3 字符类型 (Character Type)

2.3.1 `char`

2.4 布尔类型 (Boolean Type)

2.4.1 `boolean`

3. 基本数据类型的默认值

4. 类型转换 (Type Conversion/Casting)

4.1 自动类型转换 (Widening Conversion / Implicit Conversion)

4.2 强制类型转换 (Narrowing Conversion / Explicit Conversion)

5. 常见问题与最佳实践

6. 总结

更多推荐文章

相关免费在线工具

Java 基本数据类型详解：类型、范围及转换规则

Java 语言基本数据类型全面解析

1. 数据类型分类

2. 8 种基本数据类型详解

2.1 整数类型 (Integral Types)

2.1.1 byte

2.1.2 short

2.1.3 int

2.1.4 long

2.2 浮点类型 (Floating-Point Types)

2.2.1 float

2.2.2 double

2.3 字符类型 (Character Type)

2.3.1 char

2.4 布尔类型 (Boolean Type)

2.4.1 boolean

3. 基本数据类型的默认值

4. 类型转换 (Type Conversion/Casting)

4.1 自动类型转换 (Widening Conversion / Implicit Conversion)

4.2 强制类型转换 (Narrowing Conversion / Explicit Conversion)

5. 常见问题与最佳实践

6. 总结

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具

2.1.1 `byte`

2.1.2 `short`

2.1.3 `int`

2.1.4 `long`

2.2.1 `float`

2.2.2 `double`

2.3.1 `char`

2.4.1 `boolean`