# Java 基础数据类型

# 数据类型常识

Java 编程语言属于强类型语言，变量在定义时必须声明数据类型。

public class DataTypeDemo {

    public static void main(String[] args) {
        int i = 1;
        System.out.println(i); // 1
    }
}

计算机的最小传输单位是位，也称为比特（bit），一个比特的值只能是0或1。

因为一个比特（bit）无法完整的表达人类的最小单位信息（一个字母或者一个汉字），所以程序一般以一个字节（Byte）来作为计算机的最小存储单位。

计算机早期的 ASCII 码表中的每一个字符占用的存储空间就是1个字节，也就是8个比特。

简单看下每种类型存储占用的空间：

byte：1字节（8位）
short：2字节（16位）
int：4字节（32位）
long：8字节（64位）
char：2字节（16位）
float：4字节（32位）
double：8字节（64位）
boolean：1位

对于整数类型（byte/short/int/long）赋值方式很简单。

对于超过 int 类型最大值范围的长整型 long 数值，需要在数值后加上小写 l 或大写 L。建议全使用大写，更加容易识别。

public class DataTypeDemo {

    public static void main(String[] args) {
        byte b = 1;
        short s = 1;
        int i = 1;
        long l = 1;
        long l1 = 123123123123123123L;
        System.out.println(b); // 1
        System.out.println(s); // 1
        System.out.println(i); // 1
        System.out.println(l); // 1
        System.out.println(l1); // 123123123123123123
    }
}

字符类型 char 用于表示一个字符，占用2字节的存储空间，因为 Java 使用统一的 Unicode 字符规范。

char 类型的赋值可以使用十进制整数、字符和十六进制。

public class DataType {
    public static void main(String[] args) {
        // 在 Unicode 中十进制65的字符是 A
        char n1 = 65;
        // 在 Unicode 中 A 的十进制为65
        char n2 = 'A';
        char n3 = '\u0041';

        int n4 = '中';
        int n5 = '\u0041';

        System.out.println(n1); // A
        System.out.println(n2); // A
        System.out.println(n3); // A
        System.out.println(n4); // 20013
        System.out.println(n5); // 65
    }
}

关于浮点类型 float 和 double，如果定义一个小数 3.14，默认类型为 double 双精度类型，如需定义定义单精度类型，一定要在赋值后面加上小写 f 或者大写 F。

public class DataTypeDemo {

    public static void main(String[] args) {
        float f = 3.14f;
        float f1 = 3.14; // 编译出错
    }
}

# 类型转换

类型转换分为两种：隐式转换（宽转换）和强制转换。

# 隐式转换

隐式转换有两个必要条件：

数据类型必须兼容
类型的转换根据取值范围必须是由小到大依次为：byte/short/int/long/float/double

boolean 和 char 不支持隐式转换。

    public static void main(String[] args) {
        byte b = 1;
        short s = b;
        int i = s;
        long l = i;
        float f = l;
        double d = f;

        System.out.println(b); // 1
        System.out.println(s); // 1
        System.out.println(i); // 1
        System.out.println(l); // 1
        System.out.println(f); // 1.0
        System.out.println(d); // 1.0
    }

# 强制转换

对于不兼容的数据类型，可以使用强制转换。强制转换通过在赋值过程中加 ([type]) 完成。

public class DataTypeDemo {

    public static void main(String[] args) {
        char c = 'A';
        int i = (int) c;

        System.out.println(i); // 65
    }
}

上例使用隐式转换会出现编译错误。

由大类型转小类型的时候，当值超过小类型的最大取值范围时，会出现溢出或精度丢失的情况。

取值范围不用刻意去记，基本类型对应的包装类型中会有 MIN_VALUE 和 MAX_VALUE 两个变量。下面就是 Integer 包装类的源码。

    /**
     * A constant holding the minimum value an {@code int} can
     * have, -2<sup>31</sup>.
     */
    @Native public static final int   MIN_VALUE = 0x80000000;

    /**
     * A constant holding the maximum value an {@code int} can
     * have, 2<sup>31</sup>-1.
     */
    @Native public static final int   MAX_VALUE = 0x7fffffff;

public class DataTypeDemo {

    public static void main(String[] args) {
        int i = 130;
        byte b = (byte) i;
        System.out.println(b); // -126
    }
}

上例中130已经超出 byte 类型的最大取值127，所以输出结果出现错误。

为什么结果是-126呢？

计算机在存储时使用补码运算，当 int 类型转换为 byte 类型时，只留下最后一个字节的数值。

将最后一个字节的内容使用补码、反码、补码运算后得到的数据，转换为十进制，就是控制台打印的数据。

← 字符串的不可变关键字 →