Java中，经常可以遇到类型转换的场景，从变量的定义到复制、数值变量的计算到方法的参数传递、基类与派生类间的造型等，随处可见类型转换的身影。Java中的类型转换在Java编码中具有重要的作用。
首先，来了解下数据类型的基本理解：数据是用来描述数据的种类，包括其值和基于其值基础上的可进行的操作集合。
Java中数据类型主要分为两大类：基本数据类型和引用数据类型。
基本数据类型共有8种，分别是：布尔型boolean, 字符型char和数值型byte/short/int/long/float/double。
由于字符型char所表示的单个字符与Ascii码中相应整形对应，因此，有时也将其划分到数值型中 。
引用类型具体可分为：数组、类和接口。
因此，本文中Java类型转换的总结也将分为基本数据类型和引用数据类型两个方面展开。
一、基本数据类型的类型转换【引自http://www.cnblogs.com/lwbqqyumidi/p/3700164.htm】
基本数据类型中，布尔类型boolean占有一个字节，由于其本身所代码的特殊含义，boolean类型与其他基本类型不能进行类型的转换（既不能进行自动类型的提升，也不能强制类型转换）， 否则，将编译出错。
1.基本数据类型中数值类型的自动类型提升
数值类型在内存中直接存储其本身的值，对于不同的数值类型，内存中会分配相应的大小去存储。如:byte类型的变量占用8位，int类型变量占用32位等。相应的，不同的数值类型会有与其存储空间相匹配的取值范围。具体如下所示：
图中依次表示了各数值类型的字节数和相应的取值范围。在Java中，整数类型（byte/short/int/long）中，对于未声明数据类型的整形，其默认类型为int型。在浮点类型（float/double）中，对于未声明数据类型的浮点型，默认为double型。
自动转换有以下规律：
小的类型自动转化为大的类型
整数类型可以自动转化为浮点类型，可能会产生舍入误差
按从低级到高级顺序:
char
↓
Byte→short→int→long---›float→double
接下来我们看看如下一个较为经典例子：
1 package com.corn.testcast;
2 public class TestCast {
3 public static void main(String[] args) {
4 byte a = 1000; // 编译出错 Type mismatch: cannot convert from int to byte
5 float b = 1.5; // 编译出错 Type mismatch: cannot convert from double to float
6 byte c = 3; // 编译正确
7 }
8}
是不是有点奇怪？按照上面的思路去理解，将一个int型的1000赋给一个byte型的变量a，编译出错，提示"cannot convert from int to byte"是对的，1.5默认是一个double型，将一个double类型的值赋给一个float类型，编译出错，这也是对的。但是最后一句：将一个int型的3赋给一个byte型的变量c，居然编译正确，这是为什么呢？
原因在于：jvm在编译过程中，对于默认为int类型的数值时，当赋给一个比int型数值范围小的数值类型变量（在此统一称为数值类型k，k可以是byte/char/short类型），会进行判断，如果此int型数值超过数值类型k，那么会直接编译出错。因为你将一个超过了范围的数值赋给类型为k的变量，k装不下嘛，你有没有进行强制类型转换，当然报错了。但是如果此int型数值尚在数值类型k范围内，jvm会自定进行一次隐式类型转换，将此int型数值转换成类型k。如图中的虚线箭头。
这一点有点特别，需要稍微注意下。
在其他情况下，当将一个数值范围小的类型赋给一个数值范围大的数值型变量，jvm在编译过程中俊将此数值的类型进行了自动提升。在数值类型的自动类型提升过程中，数值精度至少不应该降低（整型保持不变，float->double精度将变高）。
1 package com.corn.testcast;
2 public class TestCast {
3 public static void main(String[] args) {
4 long a = 10000000000; //编译出错: The literal 10000000000 of type int is out of range
5 long b = 10000000000L; //编译正确
6 int c = 1000;
7 long d = c;
8 float e = 1.5F;
9 double f = e;
10 }
11 }
如上：定义long类型的a变量时，将编译出错，原因在于10000000000默认是int类型，同时int类型的数值范围是-2^31 ~ 2^31-1，因此，10000000000已经超过此范围内的最大值，故而其自身已经编译出错，更谈不上赋值给long型变量a了。
此时，若想正确赋值，改变10000000000自身默认的类型即可，直接改成10000000000L即可将其自身类型定义为long型。此时再赋值编译正确。
将值为1000的int型变量c赋值给long型变量d，按照上文所述，此时直接发生了自动类型提升， 编译正确。同理，将e赋给f编译正确。
接下来，还有一个地方需要注意的是：char型其本身是unsigned型，同时具有两个字节，其数值范围是0 ~ 2^16-1，因为，这直接导致byte型不能自动类型提升到char，char和short直接也不会发生自动类型提升（因为负数的问题），同时，byte当然可以直接提升到short型。
2.基本数据类型中的数值类型强制转换
当我们需要将数值范围较大的数值类型赋给数值范围较小的数值类型变量时，由于此时可能会丢失精度（1讲到的从int到k型的隐式转换除外），因此，需要人为进行转换。我们称之为强制类型转换。首先我们看一下如下的例子：
1 package com.corn.testcast;
2 public class TestCast {
4 public static void main(String[] args) {
5 byte p = 3; // 编译正确:int到byte编译过程中发生隐式类型转换
6 int a = 3;
7 byte b = a; // 编译出错：cannot convert from int to byte
8 byte c = (byte) a; // 编译正确
9 float d = (float) 4.0;
10 }
11 }
byte p =3；编译正确在1中已经进行了解释。接下来将一个值为3的int型变量a赋值给byte型变量b，发生编译错误。这两种写法之间有什么区别呢？
区别在于前者3是直接量，编译期间可以直接进行判定，后者a为一变量，需要到运行期间才能确定，也就是说，编译期间为以防万一，当然不可能编译通过了。此时，需要进行强制类型转换。
强制类型转换所带来的结果是可能会丢失精度，如果此数值尚在范围较小的类型数值范围内，对于整型变量精度不变，但如果超出范围较小的类型数值范围内，很可能出现一些意外情况。
如下经典例子：
1 package com.corn.testcast;
2 public class TestCast {
3 public static void main(String[] args) {
4 int a = 233;
5 byte b = (byte) a;
6 System.out.println("b:" + b); // 输出：-23
7 }
8 }
为什么结果是-23？需要从最根本的二进制存储考虑。233的二进制表示为：24位0 + 11101001，byte型只有8位，于是从高位开始舍弃，截断后剩下：11101001，由于二进制最高位1表示负数，0表示正数，其相应的负数为-23。
3.进行数学运算时的数据类型自动提升与可能需要的强制类型转换
如下代码：
1 package com.corn.testcast;
2 public class TestCast {
3 public static void main(String[] args) {
4 byte a = 3 + 5; // 编译正常 编译成 3+5直接变为8
5 int b = 3, c = 5;
6 byte d = b + c; // 编译错误：cannot convert from int to byte
7 byte e = 10, f = 11;
8 byte g = e + f; // 编译错误 +直接将10和11类型提升为了int
9 byte h = (byte) (e + f); //编译正确
10 }
11 }
当进行数学运算时，数据类型会自动发生提升到运算符左右之较大者，以此类推。当将最后的运算结果赋值给指定的数值类型时，可能需要进行强制类型转换。
二、引用数据类型的类型转换
在Java中由于继承和向上转型，子类可以非常自然地转换成父类，但是父类转换成子类则需要强制转换。因为子类拥有比父类更多的属性、更强的功能，所以父类转换为子类需要强制。那么，是不是只要是父类转换为子类就会成功呢？
其实不然，他们之间的强制类型转换是有条件的。
当我们用一个类型的构造器构造出一个对象时，这个对象的类型就已经确定的，也就说它的本质是不会再发生变化了。在Java中我们可以通过继承、向上转型的关系使用父类类型来引用它，这个时候我们是使用功能较弱的类型引用功能较强的对象，这是可行的。但是将功能较弱的类型强制转功能较强的对象时，就不一定可以行了。
举个例子来说明。比如系统中存在Father、Son两个对象。首先我们先构造一个Son对象，然后用一个Father类型变量引用它：
Father father = new Son();在这里Son 对象实例被向上转型为father了，但是请注意这个Son对象实例在内存中的本质还是Son类型的，只不过它的能力临时被消弱了而已，如果我们想变强怎么办？将其对象类型还原！
Son son = (Son)father;这条语句是可行的，其实father引用仍然是Father类型的，只不过是将它的能力加强了，将其加强后转交给son引用了，Son对象实例在son的变量的引用下，恢复真身，可以使用全部功能了。
前面提到父类强制转换成子类并不是总是成功，那么在什么情况下它会失效呢？
当引用类型的真实身份是父类本身的类型时，强制类型转换就会产生错误。例如：
Father father = new Father();
Son son = (Son) father;
这个系统会抛出ClassCastException异常信息。
所以编译器在编译时只会检查类型之间是否存在继承关系，有则通过；而在运行时就会检查它的真实类型，是则通过，否则抛出ClassCastException异常。所以在继承中，子类可以自动转型为父类，但是父类强制转换为子类时只有当引用类型真正的身份为子类时才会强制转换成功，否则失败。
综上：简单总结：（引自https://blog.csdn.net/qq_20289209/article/details/52796655）
1.向上造型：即父类引用指向子类对象,可以自动转换。如：
Father father = new Son();
这里的引用father指向内存中对象实质还是Son类型，不过对象的功能被临时削弱为father。
2.向下转型：即强制类型转换。
被向上造型的对象进行强制类型转换是没有问题的：
Son son =(Son)father;
但是强转没有向上造型的对象会出现错误的：
Father father = new Father();
Son son = (Son)father;
以下将进行代码测试：