7. Java基本数据类型之间的转换

自动类型转换

介绍

• 当java程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数据类型，这个就是自动类型转换。

• 数据类型按精度(容量)大小排序为
  

• 对上图说明

  1. 数据类型的自动转换，有两条线
  2. char -> int -> long -> float -> double
  3. byte -> short -> int -> long -> float -> double
  4. char 和 (byte 、short) 不能自动转换
  5. boolean 不参与类型转换

自动类型转换细节说明(!!!)

1. 有多种类型的数据混合运算时，系统首先自动将所有数据
   转换成容量最大的那种数据类型，然后再进行计算。
2. 当我们把精度(容量)大 的数据类型赋值给精度(容量)小 的数据类型时，就会报错，反之就会进行自动类型转换。
3. (byte, short) 和 char之间不会相互自动转换。
4. byte，short，char 他们三者可以计算，在计算时首先转换为int类型。
5. boolean 不参与转换
6. 自动提升原则： 表达式结果的类型自动提升为 操作数中最大的类型
7. 代码演示

public class TypeAutoConvert{
	public static void main(String[] args) {

		//基本案例
		int n1 = 'a'; // char -> int
		double d1 = 10; // int ->double
		System.out.println("d1=" + d1); // 10.0

		//细节1: 有多种类型的数据混合运算时，
		//系统首先自动将所有数据
		//转换成容量最大的那种数据类型，然后再进行计算

		int n2 = 100;
		//解读
		//1. n2 + 1.1  时候 1.1 是double 
		//2. 因此 n2 + 1.1 结果的类型就是double 
		//3. double -> float 不能发生自动转换，因此错误
		// float f1 = n2 + 1.1; //错误

		//细节2:当我们把精度(容量)大 的数据类型赋值给精度(容量)小 的数据类型时，
		// 就会报错，反之就会进行自动类型转换
		//int n3 = 1.1; //错误 double -> int

		//细节3: (byte, short) 和 char之间不会相互自动转换

		char c1 = 'a';
		//解读
		//1. 编译器，先看 c1 是 char ,类型就不可以
		byte b1 = c1; //char -> byte 

		//解读
		//1. 如果我们直接把‘a’ 赋给 byte 
		//2. 编译器会这样处理，先查看 'a' 对应的编码值 97
		//3. 判断 97 是否在 byte 的范围 (-128-127)
 		byte b2 = 'a'; 

		short s1 = 1;
		char c2 = s1; // 会报错,原因是因为java 不能让short->char

		//细节4:byte，short，char  他们三者可以计算(或者是任意两种或者任意1种)，
		//在计算时首先转换为int类型
		//解读
		//1.  b2 + s1 运算后的数据类型 int
		//2. b2 + b2 运算后的类型也是 int
		short s2 = b2 + s1; 
		short s3 = b2 + b2; // 

		//细节5: boolean 不参与转换
		boolean b3 = true;
		int n3 = b3;
		//
	}
}

---

强制类型转换

介绍

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符 ( )，但可能造成精度降低或溢出,格外要注意。

强制类型转换细节说明

1. 当进行数据的大小从 大——>小，就需要使用到强制转换
2. 强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
3. char类型可以保存 int的常量值，但不能保存int的变量值，需要强转
4. byte和short类型在进行运算时，当做int类型处理。
5. 代码演示

public class TypeForceConvert{
	public static void main(String[] args) {

		//解读
		//1. 在 1.99 前增加了一个(int), 表示
		//    把1.99 转成一个 int ,再赋给 n1
		//2. java 会这样处理，直接先小数点后的部分，全部去掉 ,即 1
		//3. n1 = 1
		//4. 程序员自己是清楚这个事情
		int n1  = (int)1.99; 
		System.out.println(n1);// 1

		//细节1: 当进行数据的大小从 大——>小，就需要使用到强制转换

		//细节2: 强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
		//解读
		//1. (int)10 * 3.5 + 6 * 1.5 这里的 (int) 只对 10 有效
		//2. 改成 (int)(10 * 3.5 + 6 * 1.5)
		int n2 = (int)(10 * 3.5 + 6 * 1.5);

		//细节3: char类型可以保存 int的常量值，但不能保存int的变量值，需要强转
		//如何理解:
		//1. 如果我们把1 常量赋给 c1 ,编译器先看 1 是否在 c1 的范围内,如果在范围内，则ok, 如果不在就报错
		//2. 如果我们把变量 n3 赋给 c1,  编译器直接看类型是否匹配.
		char c1 = 1; //对
		int n3 = 1;
		char c2 = n3; // 不对

		//细节4: byte和short类型在进行运算时，当做int类型处理
	}
}

---

基本数据类型和String类型的转换

介绍

在程序开发中，我们经常需要将基本数据类型转成String 类型。
或者将String类型转成基本数据类型。

基本类型转String类型

语法： 将基本类型的值+"" 即可
案例演示：

public class BasicToString {
	public static void main(String[] args) {
		int n1 = 10;
		double sal = 123.4;
		boolean b = true;
		//........

		String str1 = n1 + "";
		String str2 = sal + "";
		String str3 = b + "";
		System.out.println(str1);
		System.out.println(str2);
		System.out.println(str3);

		//抽问.
		//请求 n1 是什么类型? sal 是什么类型？
		//(1) n1 仍然是  int , sal 仍然是 double , b 仍然是 boolean
		//(2) String str1 = n1 + "" 如何理解：n1 + "" 这个结果是 String ,赋给 str1, n1 还是int


		//再举例
		double d1 = 1.99;
		int n2 = (int)d1; 
		//问 n2 是什么类型?  int
		//问 d1 是什么类型?  double
		System.out.println(d1);//1.99
		System.out.println(n2);//1
	}
}

String类型转基本数据类型

语法：通过基本类型的包装类调用parseXX方法即可
案例演示：

public class StringToBasic {
	public static void main(String[] args) {
			//
			//String str1 = "1234";
			//转成 int
			//语法：通过基本类型的包装类调用parseXX方法即可
			//体验 包装类使用, 体验，体验体验体验体验体验 体验 体验
		
			// 解读 "1234" => int
			int n1 = Integer.parseInt("1234"); // 1234
			// 解读 "567.89" => double
			double d1 = Double.parseDouble("567.89"); // 567.89
			byte b1 = Byte.parseByte("5");
			long l1 = Long.parseLong("567999999");
			float f1 = Float.parseFloat("7.89");
			boolean b2 = Boolean.parseBoolean("true");

			//把 String ->char , 含义就是取出第一字符
			char c1 = "hello".charAt(0);

			System.out.println(n1);
			System.out.println(d1);
			System.out.println(b1);
			System.out.println(l1);
			System.out.println(f1);
			System.out.println(b2);
			System.out.println(c1);

			//注意事项
			//如果格式不正确，就会抛出异常，程序就会终止， 这个问题在异常处理章节中，会处理
			/*
			 in thread "main" java.lang.NumberFormatException: For input string: "尚硅谷"
       at java.lang.NumberFormatException.forInputString(Unknown Source)
       at java.lang.Integer.parseInt(Unknown Source)
       at java.lang.Integer.parseInt(Unknown Source)
       at StringToBasic.main(StringToBasic.java:12)
			*/
			//int n2 = Integer.parseInt("尚硅谷");

	}
}

注意事项

1. 在将String 类型转成 基本数据类型时，要确保String类型能够转成有效的数据，比如 我们可以把 “123” , 转成一个整数，但是不能把 “hello” 转成一个整数
2. 如果格式不正确，就会抛出异常，程序就会终止， 这个问题在异常处理章节中，会处理