JAVA-基本数据类型转换

作者：马育民 • • 阅读：10058

概述

Java程序中要求参与的计算的数据，必须要保证 数据类型的一致性，如果数据类型 不一致 要进行 类型转换。

类型转换分为：

  • 自动转换（隐式转换）
  • 强制转换

归纳

  • 整型之间：

    • 范围小 赋值给 范围大，隐式转换（不需要额外处理）
    • 范围大 赋值给 范围小，强制转换

  • 浮点型之间

    • 范围小 赋值给 范围大，隐式转换（不需要额外处理）
    • 范围大 赋值给 范围小，强制转换

  • 整型 赋值 浮点型：隐式转换，不考虑范围

  • 浮点型 赋值 整型：需要 强制转换（理解：如果不强制转换，无法处理小数部分）

自动转换

将 值范围小 的类型，自动 提升为 值范围大 的类型 。

赋值时

public class Main {

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

将int型变量，赋给long型，自动转换

可以理解为：将 碗 中的水，倒入 盆 中

运算时

一个 int 型变量和一个 long 型变量进行加法运算， 结果是什么类型?

public class Test {

    public static void main(String[] args) {
        int i=123;
        long l=1000;

        //int类型和long类型运算，结果是long类型
        long x = i+l;
//        int x=i+l;//报错。long型的值，不能赋给 int型变量，理解：将一盆水，倒入碗中，倒不下
        System.out.println(x);
    }
}

运算结果是 long 型

总结：取值范围小的类型，与 取值范围大的类型，做运算时，结果是 取值范围大 的类型

可以理解为：一碗水，加上一盆水，结果用盆来装更合理

int型与double型运算时

同样道理，当一个 int 类型变量和一个 double 变量运算时， int 类型将会自动提升为 double 类型进行运算。

public static void main(String[] args) { 
  int i = 1;
  double d = 2.5;
    //int类型和double类型运算，结果是double类型
    //int类型会提升为double类型
  double e = d+i;
  System.out.println(e);
}

+=运算

阅读下面的程序，是否有错误

 public static void main(String[] args){
    short s = 1;
    long a=1000;
    s += a;// s = (short)s+a,其结果应该是long，自带强制转换的效果
    //        s = (short) (s+a);//  (强制转换的类型)值、变量、运算
    System.out.println(s);
}

错误分析：
代码 s += a 可以理解为 s = s + a, 根据上面的理论，计算结果被提升为 long型。
再向short类型变量赋值时，应该发生错误
因为不能将取值范围 大的类型赋值到取值范围小的类型。

正确解释：
符号 += 比较特殊，带有 强制转换 的特点， 也就是说 s += a 可以理解为 s = (short) (s+a)
因此程序可以正确执行

总结：

范围小 的类型，向 范围大 的类型 转换，是 java 自动转换 的

将 碗 中的水，倒入到 盆 中，是一件很自然的事，不需要额外操作

byte、short、char 运算时直接提升为 int 

byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double

+= 、-= 、*= 、/= 、%= 自动强制转换

强制转换

赋值时

问题一：

public class Main {

    public static void main(String[] args) {
        long l=123;
        int i=l;//报错
        System.out.println(i);
        System.out.println(l);
    }
}

long 型占8个字节，int 类型占4个字节，long 取值范围大于 int，将 long型 赋给 int 型，会报错

可以理解为：将 盆 中的水，倒入 碗 中，水可能会溢出，所以 不能 直接操作

问题二：

将 小数（浮点数） 赋值到 int 类型变量也会报错

int i=1.5;// 错误

整型变量无法存放小数

运算时

public static void main(String[] args) {
        int i=100;
        long l=200;
        int x=i+l;//i+l，其结果自动转换成long型
        System.out.println(x);
    }

强制转换

取值范围大 的类型，向 取值范围小 的类型 转换，需要 强制类型转换，需要 手动执行

转换格式

数据类型 变量名 = (数据类型)被转数据值;

问题一的解决方法：

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

问题二的解决方法：
将 1.5 赋值到 int 类型，代码修改为:

 // double类型数据强制转成int类型，直接去掉小数点。 
 int i = (int)1.5;
 System.out.println(i);

运算时的解决方法：

public static void main(String[] args) {
        int i=100;
        long l=200;
        int x=(int)(i+l);
        System.out.println(x);
    }

注意

  • 浮点转成整数，直接取消小数点，可能造成数据损失精度。
  • int 强制转成 short 砍掉2个字节，可能造成数据丢失。
// 定义s为short范围内最大值
short s = 32767;
/*
2是int型，s+2，结果为int型，赋给short型变量s时，会报错
需要强制转换
注意：32769超出short类型的最大值（32767），强转short型，超出最大值，会从最小值开始算
*/
s = (short)(s + 2);
System.out.println(s);

练习

阅读下面程序，分析是否能正确执行

public static void main(String[] args){
    byte b1=1;
    byte b2=2;
    byte b3=1 + 2;
    byte b4=b1 + b2;
    System.out.println(b3);
    System.out.println(b4);
}

分析:

  • 代码byte b3 = 1 + 2 ， 1 和 2 是常量，为固定不变的数据，在编译的时候(编译器javac)，已经确定了 1+2 的结果并没有超过byte类型的取值范围，可以赋值给变量 b3 ，因此 b3=1 + 2 是正确的。

  • 代码b4 = b2 + b3 ， b2 和 b3 是变量，变量的值是可能变化的，在编译的时候，编译器javac不确定b2+b3的结果 大小，因此会将结果以int类型进行处理，int类型不能赋值给byte类型，因此编译失败。

提示：
整型一般使用int型，int型的大小，足够表示日常生活中的整数，而且在各类转换中，不易出错
小数一般使用double型

吉ICP备15003043号