Java——类型转换

一、类型转换

1、介绍

类型转换分为自动类型转换和强制类型转换。

2、自动类型转换

自动类型转换是指在表达式中，当两种不同的数据类型组合在一起时，较小的数据类型会自动转换为较大的数据类型，这个过程是自动的，无需编程者手动干预。在Java中，这种转换遵守以下规则，按照容量从小到大排列，自动类型转换会遵循以下顺序：

byte -> short -> int -> long -> float -> double

和

char -> int -> long -> float -> double

比如：

int i = 100;
long l = i;  // 自动类型转换从int到long
float f = l; // 自动类型转换从long到float

在上面的例子中，int 类型的 i 被自动转换为 long 类型的 l，然后 long 类型的 l 又被自动转换为 float 类型的 f。

由容量大的类型到容量小的类型会导致精度损失而致使报错，由容量小的类型到容量大的类型一般会自动类型转换。

3、强制类型转换

强制类型转换的语法为：

type identify = (targetType)value;

就是在圆括号中加上你想要转换成的目标类型，放到变量或数值前面。

例如：

double num1 = 2.1;
int num2 = (int)num1;

这里的 num1 是 double 类型，强制转换为 int 类型会导致它的小数部分丢失。

二、补充

1、自动类型转换补充

①多种数据混合运算：

当有多种数据类型混合运算时，系统会先将数据都转换为这些数据类型中最大的数据类型，然后运算。

就像下面这个例子：

int num1 = 10;
float num2 = num1 + 10.0;

它会报以下错误：

这就是因为，num1 + 10.0 运算时，由于浮点数常量默认是 double 类型，所以这里系统会将数据都转换为这里的最大数据类型 double 类型，也就是将 num1 提升为 double 类型，所以这里的结果是 double 类型，所以不能赋值给 float 类型，会出现这个报错。

可以使用以下方法解决：

int num1 = 10;
float num2 = num1 + 10.0f;

或

int num1 = 10;
double num2 = num1 + 10.0;

②byte，short 和 char 类型不会相互自动转换：

byte、short 和 char 类型不会相互自动转换，可能与 char 类型是无符号数有关。

就像下面的代码，是错误的：

byte num1 = 10;
char num2 = num1;

③为什么可以直接将整型常量值赋给 byte，short 或 char：

我们知道整型常量的值默认是 int 类型，那为什么以下语句是正确的呢：

byte a = 10;
char b = 20;
short c = 30;

若整型常量的值是 int 类型的话，那么这里的10，20 和 30 不都是 int 类型吗，那它们怎么可以赋值给精度较小的 byte，short 或 char 类型呢？

这里是因为：Java允许直接将这些整型常量赋值给 byte、short 或 char 类型的变量，而不需要进行强制类型转换。这是Java语言设计中的一个特殊规则，旨在简化代码并减少不必要的类型转换。

具体来说，以下是Java中允许的直接赋值情况：

• 如果整型常量的值在 byte 类型的范围内（即 -128 到 127），可以直接赋值给 byte 类型的变量。
• 如果整型常量的值在 short 类型的范围内（即 -32,768 到 32,767），可以直接赋值给 short 类型的变量。
• 如果整型常量的值在 char 类型的范围内（即 0 到 65,535），可以直接赋值给 char 类型的变量。

首先会检查这些整型常量是否是在这些范围内，如果在这些范围内，则可以正常赋值。如果超出这些范围，则会报错：

byte num = 300;

以上是对于常量来说的，如果是一个变量，那么就无法判断是否在这个范围内，即使变量的数值在这时就是在这个范围内的：

int num1 = 1;
byte num2 = num1;

这里就会直接报错，因为这里的 num1 是一个 int 型的变量，而不是常量：

④byte，short 和 char 类型在运算时会首先转化为 int 类型：

当byte、short或char类型的变量参与运算时，它们会被提升至int类型。这意味着即使两个byte类型的变量相加，它们首先会被转换为int，然后再进行加法运算。如果想将结果赋值回一个byte类型的变量，就需要显式地进行类型转换，也就是进行强制类型转换。

我们可以通过下面的代码来证明：

public class Test {
	public static void main(String[] args) {
		byte num1 = 10;
		char num2 = 20;
		short num3 = num1 + num2;
	}
}

这里后面的num1 + num2再运算时会先提升到int然后运算，这时得到的结果是int型，然而int型的变量不能直接赋值给short型，所以这里会报错：

⑤boolean 不会参与任何转换

boolean 类型不会参与任何类型转换，这是因为 boolean 表示的是逻辑而不是数值，所以不能转换为其他类型。

在一些编程语言中（如 C 和 C++），数值 0 可以被视为假（false），非 0 值视为真（true）。这种设计可以导致歧义和混淆，特别是在逻辑与数值运算混合使用的时候。为了避免这种情况，Java 设计者决定不允许 boolean 类型与数值类型之间的隐式或显式转换。

2、强制类型转换补充

①将 int 类型数据赋值给 char 类型变量：

由于 int 类型常量只要在 char 类型范围内就可以正常赋值给 char 类型变量，所以我们可以直接将整型常量赋值给 char 类型变量。但是我们不能直接将 int 类型的变量直接赋值给 char 类型变量，这时就需要强制类型转换，但你需要知道这个 int 类型的变量的范围不应当超出 char 类型的范围：

public class Test {
	public static void main(String[] args) {
		int num1 = 65;
		char num2 = (char)num1;
		System.out.println(num2);
	}
}

这里是正确的，运行结果：

三、基本数据类型和 String 类型相互转换

1、基本数据类型向 String 类型转换

1）使用 + "" 方法

当一个字符串与任何其他类型的数据进行连接时，其他类型的数据会自动转换为String。然后连接成一个新的字符串。

        int num1 = 10;
		float num2 = 1.0f;
		double num3 = 3.0;
		long num4 = 1000L;
		short num5 = 20;
		boolean b = true;
		String str1 = num1 + "";
		String str2 = num2 + "";
		String str3 = num3 + "";
		String str4 = num4 + "";
		String str5 = num5 + "";
		String str6 = b + "";

2）使用 String.valueOf() 方法：

这是一个静态方法，可以接受各种类型的参数，并将其转换为 String 表示。

public class Test {
	public static void main(String[] args) {
		int num1 = 10;
		double num2 = 1.1;
		boolean b = true;
		String str1 = String.valueOf(num1);
		String str2 = String.valueOf(num2);
		String str3 = String.valueOf(b);
		System.out.println(str1 + " " + str2 + " " + str3);
	}
}

运行结果：

3）使用 toString() 方法：

 每个基本数据类型的包装类（如 Integer、Double、Boolean 等）都有一个 toString() 方法，可以将基本类型转换为 String。

        int i = 100;
		double d = 1.2;
		String str1 = Integer.toString(i);  // "100"
		String str2 = Double.toString(d);   // "1.2"

2、String 数据转换到基本数据类型

1）使用包装类的 parseXxx() 方法：

每个基本数据类型的包装类都提供了一个 parseXxx() 静态方法，可以将 String 转换为对应的基本类型（Xxx 是数据类型的首字母大写，如 parseInt, parseDouble, parseBoolean 等）。

        String str1 = "100";
		int i = Integer.parseInt(str1);  // 100
		String str2 = "false";
		boolean b = Boolean.parseBoolean(str2); // false;

2）使用包装类的 valueOf() 方法：

除了 parseXxx() 方法，包装类还提供了 valueOf() 方法将 String 转换为基本类型。与 parseXxx() 方法不同，valueOf() 方法返回的是封装了基本数据类型的对象而不是基本数据类型本身，但在实际使用上，由于自动拆箱的存在，使用起来并无太大差异。

        String str1 = "100";
		String str2 = "true";
		String str3 = "1.11";
		int num1 = Integer.valueOf(str1);
		boolean b = Boolean.valueOf(str2);
		double num2 = Double.valueOf(str3);

3.注意事项

对于字符串类型转换成基本数据类型，需要确定字符串可以被正确解析成对应的基本数据类型。就像字符串 "nihao" 是无法被解析成整数的，如果强行将 "nihao" 转换为型，则会抛出异常，然后程序终止。

public class Test {
	public static void main(String[] args) {
		String str = "nihao";
		int i = Integer.parseInt(str);
	}
}

以上代码在运行时会抛出以下异常：

四、小细节

1、两个字符相加：

public class Test {
	public static void main(String[] args) {
		char ch1 = '好';
		char ch2 = '坏';
		System.out.println(ch1 + ch2);//这里会打印字符'好'的码值加上'坏'的码值
	}
}

运行以上代码，我们会得到以下结果：

由于 char 类型的变量在算数运算时会提升为 int 类型，这里就是这个原因，两个字符类型的数据提升到 int 类型，然后进行算数相加，最终得到两个字符的码值的和，所以会得到以上结果。