在Java中强制类型转换分为基本数据类型和引用数据类型两种，这里我们讨论的后者，也就是引用数据类型的强制类型转换。
在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异常。
所以在继承中，子类可以自动转型为父类，但是父类强制转换为子类时只有当引用类型真正的身份为子类时才会强制转换成功，否则失败。
扩展资料：
public class TestCastClassException
{
public static void main(String[] args)
{
Father father = new Son();
//这两句话是不对的，因为一个father类型的引用（指针）是看不见、看不到son中新定义的数据成员或者成员函数的
//虽然这个对象的本质是Son类型的，它也确实有这样的数据成员和成员函数，但是指针的作用范围不够，它看不到。
//代码后面附上模型分析
//father.son = 2;
//father.show_son();
father.show_father();
father.show();
Father father1 = (Father)father;//一个对象在内存中被new出来后，只能选择访问它的方式，不能修改它的布局（包含的成员的个数等）
father1.show();
} //main
}
class Father
{
public int father = 2;
Father(){}
void show()
{
System.out.println("This is father");
}
void show_father()
{
System.out.println("father!!");
}
}
class Son extends Father
{
public int son = 1;
Son(){}
void show()
{
System.out.println("This is son");
}
void show_son()
{
System.out.println("son!!");
}
}
Java的强制类型转换，可以分成编译和运行两个阶段来分析。
1、编译期间：
被转型变量的编译时类型与目标类型相同；
被转型变量的编译时类型是目标类型的父类；
被转型变量的编译时类型是目标类型的子类，这种情况是自动向上转换。
2、运行期间：
被转型变量所引用的对象的实际类型必须是目标类型的实例，或者是目标类型的子类，实现类的实力，否则运行时将引发ClassCastException异常。
扩展资料：
强制转换是还需要注意一次额问题：
无继承关系的引用类型间的转换是非法的，编译时会出错;
并不是任意的父类类型数据都可以被造型为子类类型，在造型前可以使用 instanceof 操 作符测试一个对象的类型，以避免运行是出错。
参考资料：
强制类型转换分两种形式：
1. 显式强制类型转换 ：
C中显式强制类型转换很简单，格式如下： TYPE b = (TYPE) a， 其中，TYPE为类型描述符，如int，float等。
经强制类型转换运算符运算后，返回一个具有TYPE类型的数值，这种强制类型转换操作并不改变操作数本身，运算后操作数本身未改变。
2.隐式强制类型转换：
隐式类型转换发生在赋值表达式和有返回值的函数调用表达式中。
在赋值表达式中，如果赋值符左右两侧的操作数类型不同，则将赋值符右边操作数强制转换为赋值符左侧的类型数值后，赋值给赋值符左侧的变量。
在函数调用时，如果return后面表达式的类型与函数返回值类型不同，则在返回值时将return后面表达式的数值强制转换为函数返回值类型后，再将值返回。
扩展资料：
强制类型转换规则、格式、注意事项及异常处理：
1.转换规则：
从存储范围大的类型到存储范围小的类型。
具体规则为：
double→float→long→int→short(char)→byte
2.语法格式为：
(转换到的类型)需要转换的值
示例代码：
double d = 3.10;
int n = (int)d;
3.注意问题：
强制类型转换通常都会存储精度的损失，所以使用时需要谨慎。
4.异常处理：
方式一：捕获处理
捕获处理的格式：
try{可能发生异常的代码；}catch(捕获的异常类型 变量名){处理异常的代码.... }
捕获处理要注意的细节：
（1） 如果try块中代码出了异常经过了处理之后，那么try-catch块外面的代码可以正常执行。
（2）如果try块中出了异常的代码，那么在try块中出现异常代码后面的代码是不会执行了。
（3） 一个try块后面是可以跟有多个catch块的，也就是一个try块可以捕获多种异常的类型。
（4） 一个try块可以捕获多种异常的类型,但是捕获的异常类型必须从小到大进行捕获，否则编译报错。
方式二：抛出处理
抛出处理要注意的细节：
（1）如果一个方法的内部抛出了一个异常 对象，那么必须要在方法上声明抛出。
（2）如果调用了一个声明抛出异常 的方法，那么调用者必须要处理异常。
（3）如果一个方法内部抛出了一个异常对象，那么throw语句后面的代码都不会再执行了（一个方法遇到了throw关键字，该方法也会马上停止执行的）。
（4） 在一种情况下，只能抛出一种类型异常对象。
参考资料：百度百科-强制类型转换
1 ) 整数 int 转换成字串 String , 有三种方法 :
String s = String.valueOf(i);
String s = Integer.toString(i);
String s = "" + i;
2 ) String 转 int
int i = Integer.parseInt([String]);
i = Integer.parseInt([String],[int radix]);
int i = Integer.valueOf(my_str).intValue();
3 ) 布尔类型 转 String
1. 第一种方法
boolean bool = true;
String s = new Boolean(bool).toString();//将bool利用对象封装器转化为对象
2. 第二种方法
boolean bool = true;
String s = String.valueOf( bool );
4 ) String 转 Date
1 . 导入 java.util.Date date=null;
2 . date=java.sql.Date.valueOf(String s);
5 ) 数字类型间的转换
转型有两种: 向上转型和向下转型(强制转型)
两种分别如下:
第一种是向上转型
对于基础数据类型 , 可以自动转型 ,比如:
int a = 10;
long b = a;
这里就是把int型转成了long型 , 因为 long范围比int大 , 这样的转型不会有任何影响 , 所以可以自动转型
第二种是向下转型 , 也就是强制
这种需要强转 , 比如
long a = 10 ;
int b = (int) a;
通过 (int)可以强制转型 , 但是这样会丢失精度 , 比如a如果超过了b的范围 , 那么强转成int型, 只会等于int的最大值
又如 : int a = ( int ) 8.8 ;
如果对编程感兴趣可以来我这个看看，希望对您有所帮助！~
一．Java 的自动转换
如果下列2个条件都能满足，那么将一种类型的数据赋给另外一种类型变量时，将执行自动类型转换（automatic type conversion）：
1．这2种类型是兼容的。
2．目的类型数的范围比来源类型的大。
当以上2个条件都满足时，拓宽转换（widening conversion ）发生。例如，int 型的范围比所有byte 型的合法范围大，因此不要求显式强制类型转换语句。
对于拓宽转换，数字类型，包括整数（integer ）和浮点（floating-point ）类型都是彼此兼容的，但是，数字类型和字符类型（char）或布尔类型（bollean ）是不兼容的。字符类型（char ）和布尔类型（bollean ）也是互相不兼容的。
二． 不兼容类型的强制转换
尽管自动类型转换是很有帮助的，但并不能满足所有的编程需要。例如，如果你需要将int 型的值赋给一个byte 型的变量，你将怎么办？这种转换不会自动进行，因为byte 型的变化范围比int 型的要小。这种转换有时称为“缩小转换”（），因为你肯定要将源数据类型的值变小才能适合目标数据类型。
为了完成两种不兼容类型之间的转换，你就必须进行强制类型转换。所谓强制类型转换只不过是一种显式的类型变换。它的通用格式如下：
(target-type)value
其中，目标类型（target-type ）指定了要将指定值转换成的类型。例如，下面的程序段将int 型强制转换成byte 型。如果整数的值超出了byte 型的取值范围，它的值将会因为对byte 型值域取模（整数除以byte 得到的余数）而减少。
int a;
byte b;
// ...
b = (byte) a;
当把浮点值赋给整数类型时一种不同的类型转换发生了：截断（truncation ）。你知道整数没有小数部分。这样，当把浮点值赋给整数类型时，它的小数部分会被舍去。例如，如果将值1.23赋给一个整数，其结果值只是1，0.23 被丢弃了。当然，如果浮点值太大而不能适合目标整数类型，那么它的值将会因为对目标类型值域取模而减少。
下面的程序说明了强制类型转换：
// Demonstrate casts.
class Conversion {
public static void main(String args[]) {
byte b;
int i = 257;
double d = 323.142;
System.out.println("\nConversion of int to byte.");
b = (byte) i;
System.out.println("i and b " + i + " " + b);
System.out.println("\nConversion of double to int.");
i = (int) d;
System.out.println("d and i " + d + " " + i);
System.out.println("\nConversion of double to byte.");
b = (byte) d;
System.out.println("d and b " + d + " " + b);
}
}
该程序的输出如下：
Conversion of int to byte.
i and b 257 1
Conversion of double to int.
d and i 323.142 323
Conversion of double to byte.
d and b 323.142 67
让我们看看每一个类型转换。当值257被强制转换为byte 变量时，其结果是257除以256 （256是byte 类型的变化范围）的余数1。当把变量d转换为int 型，它的小数部分被舍弃了。当把变量d转换为byte 型，它的小数部分被舍弃了，而且它的值减少为256 的模，即67。
参考资料： http://www.study888.com
