Java强制类型转换的所有规则都在这里了_java类型强转换

本文链接：https://blog.youkuaiyun.com/2401_84253894/article/details/139937009

short 类型内存占有2个字节，在和 int类型运算时会提升为 int 类型，自动补充2个字节，计算后的结果还是 int 类型，但最终被强转为了short类型，占用2个字节空间。

2.2.2 浮点数与整数的底层存储

下面是8个基本数据类型的取值范围大小：

数据类型	关键字	内存占用	取值范围
字节型	byte	1个字节	-128~127
短整型	short	2个字节	-32768~32767
整型	int（默认）	4个字节	-2147483648~2147483647
长整型	long	8个字节	-2的63次方~2的63次方-1
单精度浮点数	float	4个字节	1.4013E-45~3.4028E+38
双精度浮点数	double（默认）	8个字节	4.9E-324~1.7977E+308
字符型	char	2个字节	0-65535
布尔类型	boolean	1个字节	true，false

我们可以发现，int和float都是占用4个字节大小，但是float的取值范围却比int要大的多。同样的情况在long与double这两种类型上也存在；

这是为什么呢？

double与long表示范围的差距是由于存储结构的不同导致的，换句话说我们保存1000这个数，我们long要存储+1000，其二进制为001111101000，而double存储的是+1E3。拆开来看，存储一个数double可以分成三部分：尾数位（1），基数位（10），指数位（3）。 也就是用科学计数法来存储，这简单的1000就能看出差距，long存储1000需要符号位（+）和数字位（1000），需要5位。而double存储，却只需要3位。同样一个数，double能够用更少的内存存储，所以多余的内存就能存储更多的数，因此double > long

通过如下代码可以查看到每个类型的最大值：

/\*\*
 \* @author lscl
 \* @version 1.0
 \* @intro:
 \*/
public class Demo01 {
    public static void main(String[] args) {
        // 2147483647
        System.out.println(Integer.MAX\_VALUE);
        
        // 3.4028235E38
        System.out.println(Float.MAX\_VALUE);
        
        // 9223372036854775807
        System.out.println(Long.MAX\_VALUE);
        
        // 1.7976931348623157E308
        System.out.println(Double.MAX\_VALUE);
    }
}

2.2.3 整数之间的强制转换

强制转换指的是：取值范围大的，转换为取值范围小的。强制转换的时候尤其要注意转换之后的类型是否能存储之前的数据。

示例1：数值==没有超出==转换之后类型的取值范围的情况

/\*\*
 \* @author lscl
 \* @version 1.0
 \* @intro:
 \*/
public class Demo05\_强制类型转换_整数转换_01 {
    public static void main(String[] args) {
        int a = 100;
        byte b = (byte) a;

        // byte也能存储100，因此转换的时候不会出现什么问题
        System.out.println(b);      // 100
    }
}

示例2：数值==超出了==转换之后类型的取值范围的情况

/\*\*
 \* @author lscl
 \* @version 1.0
 \* @intro:
 \*/
public class Demo06\_强制类型转换_整数转换_02 {
    public static void main(String[] args) {
        // 八个字节: 00000000 00000000 0000000 10000100 01000000 11000000 11000000 10000000 ---> 十进制: 568022057088
        long a = 568022057088L;

        // 四个字节: 01000000 11000000 11000000 10000000 ---> 十进制: 1086374016
        int b = (int) a;
        System.out.println(b);      // 1086374016

        // 两个字节: 11000000 10000000 ---> 十进制: -16256
        short c = (short) b;
        System.out.println(c);      // -16256

        // 一个字节: 10000000 ---> 十进制: -128
        byte d = (byte) c;
        System.out.println(d);      // -128
    }
}

2.2.4 浮点数的强制转换

1）浮点数转浮点数

示例1：数值==没有超出==转换之后类型的取值范围的情况

/\*\*
 \* @author lscl
 \* @version 1.0
 \* @intro:
 \*/
public class Demo07\_强制类型转换_浮点数转浮点数_01 {
    public static void main(String[] args) {
        double a = 180.8D;
        float b = (float) a;

        System.out.println(b);          // 180.8
    }
}

示例2：数值==超出了==转换之后类型的取值范围的情况

/\*\*
 \* @author lscl
 \* @version 1.0
 \* @intro:
 \*/
public class Demo07\_强制类型转换_浮点数转浮点数_02 {
    public static void main(String[] args) {
        double a = 3.8E38D;
        float b = (float) a;

        // float的最大取值范围为: 1.4013E-45~3.4028E+38,无法存储3.8E38，赋值失败
        System.out.println(b);          // Infinity
    }
}

超出最大容量：

2）浮点数转整数

浮点数强制转换为整数类型时也会出现一定的问题；

示例1：浮点数强制转换为整数，数值==没有超出==转换之后类型的取值范围的情况

/\*\*
 \* @author lscl
 \* @version 1.0
 \* @intro:
 \*/
public class Demo09\_强制类型转换_浮点数转整数_01 {
    public static void main(String[] args) {
        double a = 18.8D;

        // 取值范围: -2的63次方~2的63次方-1
        long b = (long) a;

        // 取值范围: -2147483648~2147483647
        int c = (int) a;

        // 取值范围: -32768~32767
        short d = (short) a;

        // 取值范围: -128~127
        byte e = (byte) a;

        System.out.println(a);          // 18.8
        System.out.println(b);          // 18
        System.out.println(c);          // 18
        System.out.println(d);          // 18
        System.out.println(e);          // 18
    }
}

Tips：浮点数转成整数后将会丢失精度，即小数点后面的通通丢失（注意，并不是四舍五入）

示例2：浮点数强制转换为整数（long和int类型），数值==超出了==转换之后类型的取值范围的情况

/\*\*
 \* @author lscl
 \* @version 1.0
 \* @intro:
 \*/
public class Demo10\_强制类型转换_浮点数转整数_02 {
    public static void main(String[] args) {
        double a = 5.2E63;

        // 取值范围: -2的63次方~2的63次方-1
        long b = (long) a;

        // 取值范围: -2147483648~2147483647
        int c = (int) a;

        System.out.println(a);          // 5.2E63
        System.out.println(b);          // 9223372036854775807(long的最大值)
        System.out.println(c);          // 2147483647(int的最大值)
    }
}