关于java的类型转换

关于java的类型转换

java属于强类型语言，所以运算的时候，类型转换是经常用到的，比较关键😀。

类型转换分为两种类型，一种是强制转换，一种是自动转换。

• 强制转换

1、强制转换是指由高到低的转换，由高到低说的是各个类型占用的字节大小，下面展示顺序🤣

2、byte（字节类型），short（短整型），char（字符类型）—>int（整型）—>long（长整型）—>float（单精度浮点型）

—>double（双精度浮点型）

3、这个是一个由低到高的顺序，因为小数的优先级是大于整数的，所以小数最高。

4、强制转换使用方法，(需要转换的类型)+需要转换的变量名。括号为英文括号。

5、下面举例说明一下int类型转换为byte类型，以及注意的点。

public class Demo{
    public static void main(String[] args){
        
        int i=126;//声明一个整型变量i
        
        byte b=(byte)i;//int比byte级别高，所以强制转换
        
        System.out.println(i);//输出的结果126
        System.out.println(b);//输出的结果126
        
    }
}

6、但是强制转换需要注意内存溢出！！下面举例说明一下。

public class Demo{
    public static void main(String[] args){
        
        int i=128;
        
        byte b=(byte)i;
        
        System.out.println(i);//输出的结果128
        System.out.println(b);//输出的结果-128
    }
}

在这里输出的结果就是-128，由于在上篇文章java类型中提到过，每个类型都是有自己的范围的，byte的范围是-128到127，

128>127,所以造成了内存溢出。所以这里就不可以用byte去转换了，可以换一个类型进行转换，比如short。

public class Demo{
    public static void main(String[] args){
        
        int i=128;
        
        short s=(short)i;
        
        System.out.println(i);//输出的结果128
        System.out.println(s);//输出的结果128
    }
}

• 自动转换

1、自动转换，就是由低到高的转换，相反与强制转换。

2、自动转换使用方法，不需要添加任何东西，可以直接对变量进行转换，下边举例说明一下。

public class Demo{
    public static void main(String[] args){
        
        int i=128;
        
        double d=i;
        
        System.out.println(i);//输出的结果128
        System.out.println(d);//输出的结果128.0
    }
}

3、再例如字符类型的转换

public class Demo{
    public static void main(String[] args){
        
        char c='A'
        
        int i=c+1;
        
        System.out.println(c);//输出的结果A
        System.out.println(i);//输出的结果66,因为A在UniCode中是65
        
        //再将目前的int类型转换回char类型
        System.out.println((char)i);//输出的结果B，因为B在UniCode中是66
    }
}

• 类型转换拓展

1、首先要说一下JDK的特性，现在JDK提供了一个新特性，可以在变量值里面加入_（英文下划线），用于分割很长的数字等，下划线在系统编译的时候不会被输出。

2、常见的问题，下面举例说明一下，假设一个人一年赚10亿，赚了20年。

public class Demo{
    public static void main(String[] args){
        
        int money=10_0000_0000;//10亿
        
        int years=20;
        
        int total=money*years;//总和
        
        System.out.println(money);//输出的结果1000000000
        System.out.println(years);//输出的结果20
        System.out.println(total);//输出的结果-1474836480
    }
}

这里发现，内存溢出了，因为int范围的最大值是1474836480（14亿多），总和已经20亿，所以溢出了。

一些小伙伴会进行类型转换，long>int，所以将总和转换成long，但是发现并没有解决问题。

public class Demo{
    public static void main(String[] args){
        
        int money=10_0000_0000;//10亿
        
        int years=20;
        
        long total=money*years;
        
        System.out.println(money);//输出的结果1000000000
        System.out.println(years);//输出的结果20
        System.out.println(total);//输出的结果-1474836480
    }
}

这是由于，money和years已经都是int类型了，所以求和的时候，转换之前就已经默认为int类型了，所以即使转换了，也没有解决。

这时候，可以换一种方式解决，因为10亿和20年，都没有超出范围，只是求和的时候超出范围了。

所以，可以提前先转换其中一个变量！

//第一种写法，比较简洁
public class Demo{
    public static void main(String[] args){
        
        int money=10_0000_0000;//10亿
        
        int years=20;
        
        long total=((long)money)*years;//将较大的先转为long类型
        
        System.out.println(money);//输出的结果1000000000
        System.out.println(years);//输出的结果20
        System.out.println(total);//输出的结果2000000000
    }
}

//第二种写法，比较清晰
public class Demo{
    public static void main(String[] args){
        
        int money=10_0000_0000;//10亿
        
        long money2=money;
        
        int years=20;
        
        long total=money2*years;
        
        System.out.println(total);//输出的结果2000000000
    }
}

• 总结

1、类型转换不能对布尔类型进行转换。

2、不能转换不相干的类型（像桌子不能转换成一只🐷）。

3、高转低强制，低转高自动。

4、注意内存溢出，精确度问题。