Java中的数据类型--基本数据类型_java里的已知数值计算需要带数值类型吗-CSDN博客

本文链接：https://blog.csdn.net/weixin_40243894/article/details/106454985

Java中对于数据类型，可以分别两大数据类型：基本数据类型和引用数据类型。

基本数据类型组成

Java中内置了8种基本数据类型，其中包括6种数字类型(4个整数型，2个浮点型)、1种字符型、1种布尔型。再说数据类型之前，先说一下计算中最小的信息存储单位：bit，二进制数的一位包含的信息或2个选项中特别指定1个的需要信息量称为一比特，是表示信息的最小单位，只有两种状态：0和1。

byte型：

byte 数据类型是8位（bit）、有符号的，以二进制补码表示的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
例子：byte a = 100，byte b = -50。

short：

short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
默认值是 0；
例子：short s = 1000，short r = -20000。

int：

int 数据类型是32位、有符号的以二进制补码表示的整数；
最小值是 -2,147,483,648（-2^31）；
最大值是 2,147,483,647（2^31 - 1）；
java中整数类型的默认值。
默认值是 0 ；
例子：int a = 100000, int b = -200000。

long：

long 数据类型是 64 位、有符号的以二进制补码表示的整数；
最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
这种类型主要使用在需要比较大整数的系统上；
默认值是 0L；
例子： long a = 100000L，Long b = -200000L。 "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float：

float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
float 在储存大型浮点数组的时候可节省内存空间；
默认值是 0.0f；
浮点数不能用来表示精确的值，如货币；
例子：float f1 = 234.5f。

double：

double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
java中浮点数的默认类型为double类型；
double类型同样不能表示精确的值，如货币；
默认值是 0.0d；
例子：double d1 = 123.4。

boolean：

boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
这种类型只作为一种标志来记录 true/false 情况；
默认值是 false；
例子：boolean flag= true。

char：

char类型是一个单一的 16 位 Unicode 字符；
最小值是 \u0000（即为0）；
最大值是 \uffff（即为65,535）；
char 数据类型可以储存任何字符；
例子：char c= 'A';。

Java中的数据类型自动转换机制

上边我们说到了Java中的基本数据类型，说到底，这些基本数据类型还是为了进行数值的存储和徐计算。接下来我们在说一下各个数据类型之间进行计算会发生什么。我们按照数据类型所占存储空间大小由小到大排序为：

byte < short < int(char) < long < float < double。

这里不包括boolean类型，虽然boolean占一个bit，但是一般只用来表示真假值，不存在进行与其它几个数据类型之间进行计算。这里我为什么把char也放进来呢，与boolean不同，char类型是可以运算的因为char在ASCII等字符编码表中，有对应的数值。所以，我们在用char进行计算时直接当做ASCII表对应的整数来对待。

1.隐式转换

从小到大，可以隐式转换，数据类型将自动提升。就是将占空间小的赋值给大的，不会报错，数据类型会自动转成声明的数据类型。如下代码，编译器没有报错。

    @Test
    public void test(){
        byte a = 10;
        short b = a;
        int c = b;
        long d = c;
        float e = d;
        double f = e;
    }

简单来说我们可以这么理解，我把一杯1升容量杯子里的水倒入一个2升的杯子里，顺便倒，因为1升杯子装满了也比2升小，大概这个意思，所以将小数据类型赋值给大数据类型可以实现隐氏的自动转换。那么上边例子里，对于byte a = 10我有点疑问，java整数数据类型的默认值是int啊，那么数值10应该是int型的，我们说小到大实现隐式转换，这不是大到小吗，为什么没有编译报错呢。我们再来看下下边代码。

    @Test
    public void test(){
        byte a = 10;
        byte b = 127;
        byte c = 128; // 编译报错
    }

这里涉及到一个叫字面值（literal）的问题，字面值就是表面上的值，例如整型字面值在源代码中就是诸如 5、0、 -200这样的。如果整型子面子后面加上L或者l，则这个字面值就是long类型，比如：1000L代表一个long类型的值。如果不加L或者l，则为int类型。基本类型当中的byte short int long都可以通过不加L的整型字面值（我们就称作int字面值吧）来创建，例如 byte b = 100； short s = 5；对于long类型，如果大小超出int所能表示的范围（32 bits），则必须使用L结尾来表示。整型字面值可以有不同的表示方式：16进制【0X or 0x】、10进制【nothing】、八进制【0】2进制【0B or 0b】等，二进制字面值是JDK 7以后才有的功能。在赋值操作中，int字面值可以赋给byte short int long，Java语言会自动处理好这个过程。如果方法调用时不一样，调用test（0）的时候，它能匹配的方法是test（int），当然不能匹配test（byte）方法，至于为什么Java没有像支持赋值操作那样支持方法调用，不得而知。注意区别包装器与原始类型的自动转换（anto-boxing，auto-unboxing）。byte d = 'A'；也是合法的，字符字面值可以自动转换成16位的整数。

    @Test
    public void test(){
        byte a = 10;
        byte b = 127;
        byte c = 128; // 编译报错
        byte d = 10L; // 编译报错
    }

2.显示转换

显示转换是相对与隐式转换的，显示转换则是从大到小，将大数据类型赋值给小数据类型时需要显示的进行强制类型转换，才可以编译通过。如下代码：

    @Test
    public void test(){
        long a = 127L;
        int b = (int)a;
        short c = (short) b;
        byte d = (byte) c;
    }

当我们将一个2升的杯子的水向一个1升的杯子倒时可能就会有部分水溢出来，因为超过了1升杯子的最大容量，同理，我们将大数据类型强制转换成小数据类型时可能会存在精度损失。所以我们必须要进行这个操作的话，就得进行强制转换，这样编译器才认可。另外，这里有个小疑问：上边d打印出来是什么呢？答案肯定是127。那么我将a赋值为128L呢，d打印出来是什么呢？答案是-128；128为int整数32位，前24为全部为0 后8位是1000 0000，（byte)128 转型为byte后首位是1，java认为是负数的补码标识，补码转原码，符号位不变，数值位取反加1，第9位为1，后8为位1000 0000，仍然是-128。

3.计算时类型的自动转换

当基本数据类型进行+、-、<<等计算操作时，会自动进行类型的提升，其规则为：

所有的byte型、short型、char型的值将被提升到int型；
如果一个操作数是long型，计算结果就是long型；
如果一个操作数是float型，计算结果就是float型；
如果一个操作数是double型，计算结果就是double型。

带着上边的规则，我们看下下边代码中注释着问号的代码会不会编译成功：

    @Test
    public void test(){
        byte a = 10;
        a = a + 1; // ?
        a += a; // ?
        a += 1; // ?
        a =+ a; // ?
        a =+ 1; // ?

        int x = 10;
        long y = 10;
        int z = x + 10; // ?
        z = y + 10; // ?
        z = x + y; // ?
    }

心里想好答案，或记在小本本上，我开始公布答案了o(*￣︶￣*)o：

    @Test
    public void test(){
        byte a = 10;
        a = a + 1; // 失败
        a += a; // 成功
        a += 1; // 成功
        a =+ a; // 失败
        a =+ 1; // 成功

        int x = 10;
        long y = 10;
        int z = x + 10; // 成功
        z = y + 10; // 失败
        z = x + y; // 失败
    }

这里在判断结果类型时，我通过java中的自动拆装箱写了一个判断方法来进行验证，可以验证运算结果的数据类型到底是什么。示例代码如下：

    @Test
    public void test(){
       byte a = 127;
       a += a;
       judge(a);// 输出 byte

       int x = 10;
       long y = 100L;
       judge(x + y);// 输出 long
    }

    /**
     * @desc 判断传入参数的数据类型
     * @author dataozi
     * @date 2020/5/31 17:24
     */
    private void judge(Object o){
        if(o instanceof Integer){
            System.out.println("int");
        }else if(o instanceof Double){
            System.out.println("double");
        } else if(o instanceof Long){
            System.out.println("long");
        } else if(o instanceof Short){
            System.out.println("short");
        } else if(o instanceof Byte){
            System.out.println("byte");
        } else if(o instanceof Float){
            System.out.println("float");
        } else {
            System.out.println("我裂开了");
        }
    }

a = a + 1；实际上是byte = int + int，这里需要进行强转a = (byte)(a + 1)，不强转的话编译报错。

a += a；转换一下是a = a + a，实际还是byte = int + int，这里为什么没有报错呢，是+=会自动进行强转，实际上最终变成了byte = (byte)(int + int)。

a += 1；和a += a同理。

a =+ a；这是我自己想的迷惑题，这不是个运算操作，实际就是 a = +a；这里编译器会报错。编译器不会进行计算，它虽然知道a是byte性，但是它不知道+a会不会超过byte的范围，这里+a会被自动升为int，实际变成了byte = +int，所以需要强转a = (byte)+a;

a =+ 1；这时实际是a= +1；因为是直接赋值没有计算操作，编译器知道+1在byte的范围之内，所以自动进行了类型转换。换成a =+ 129的话就编译报错。

int z = x +10；没什么好说的，int = int + int。

z = y + 10；y为long型，所以结果会升为long型，int = long + int，z是int型，需要强转z = (int)(y + 10)。

z = x + y；int = int + long，结果会升为long型，同样需要强转z = (int)(x + y)。