【解惑】Java类型间的转型

转载自：http://hxraid.iteye.com/blog/466997

 

★ 基本数据类型间的转换

1、Java要做到平台无关性，所有的基本数据类型所占的字节数量均是固定的。

           boolean ——1/8字节(1 bit)     byte —— 1字节             char —— 2字节         short —— 2字节

            int —— 4字节                          long —— 8字节             float —— 4字节         double —— 8字节

2、基本数据类型间的转换 

    (1)  所占字节数相对少的基本类型可以自动向字节数相对多的转换。

Java代码  

1. byte c=(byte)-1; //强制转化为byte型     
2. int i=c; //自动转化为整型  
3. System.out.println(i);//打印结果：-1  

byte c=(byte)-1; //强制转化为byte型int i=c; //自动转化为整型System.out.println(i);//打印结果：-1

 

      比如上面的byte型可以自动转化为int型，但这种转化是带符号扩展的。因为byte是有符号类型。这里有一个例外，就是char，它是一个无符号类型，因此自动扩展成int、long等类型时是不带符号扩展的。

Java代码  

1. char c=(char)-1;   
2. int i=c; //自动转化为整型  
3. System.out.println(i); //打印结果：65535  

char c=(char)-1; int i=c; //自动转化为整型System.out.println(i); //打印结果：65535

 

      上面的代码首先将整型0xFFFFFFFF(32bits)强制类型截短为0xFFFF(16bits)。而这个数的类型是char，那么它表示的数是65535，扩展成int类型的时候是无符号扩展，高位补0，因此变量i=0x0000FFFF(65536)。

 

    (2)  所占字节数多的向字节数少的转换要强制执行。

      大范围类型多出的bit将会被截去。

Java代码  

1. int i=10000;  
2. byte j=(byte)i;  //4字节强制转化为1字节  
3. System.out.println(j);//打印结果: 16   

int i=10000;byte j=(byte)i;  //4字节强制转化为1字节System.out.println(j);//打印结果: 16 

 

    (3)   字节一样多的，long向double类型转化也需要强制类型转化，反向不需要。

    (4)  boolean型不能与其他任何数值类型之间转换。

 

 

★  类类型间的转换

这里有一句很经典的话：男人绝对是人，人可能不是男人，只有原来是男人的人才有希望变回男人。

 

1、类类型的自动转换，只能在继承层次中自下而上的自动转换(向上转型)，即子类自动转换为父类。

Java代码  

1. //自动向上转型  
2. class Employee{  
3. }  
4. class Manager extends Employee{ //继承关系  
5. }  
6.   
7. Manager m=new Manager();  
8. Employee e=m;  //Manager类型自动转换为Employee类型  

//自动向上转型class Employee{}class Manager extends Employee{ //继承关系}Manager m=new Manager();Employee e=m;  //Manager类型自动转换为Employee类型

 

 2、强制类型转换

      在继承层次中将一个父类的变量转变成子类类型，必须强制类型转换。但这种转换并不是一定成功的：

Java代码  

1. //运行失败  
2. class Employee{  
3. }  
4. class Manager extends Employee{  
5. }  
6.   
7. Employee e=new Employee(); //e的实际类型为Employee  
8. Manager m=(Manager)e; //强制转换为Manager  

//运行失败class Employee{}class Manager extends Employee{}Employee e=new Employee(); //e的实际类型为EmployeeManager m=(Manager)e; //强制转换为Manager

 

      注意：上面的代码编译时可以通过，但运行的时候会产生一个ClassCastException的非检查异常。如果不捕获这个异常，程序将终止。再看一段代码：

Java代码  

1. //运行成功  
2. class Employee{  
3. }  
4. class Manager extends Employee{  
5. }  
6.   
7. Employee e=new Manager(); //多态，e的实际类型为Manager  
8. Manager m=(Manager)e; //强制类型转换  

//运行成功class Employee{}class Manager extends Employee{}Employee e=new Manager(); //多态，e的实际类型为ManagerManager m=(Manager)e; //强制类型转换

 

       这段代码可以正常运行。   

       如果父类引用的是一个子类的类型(多态情况下)。这是可以通过强制类型转换把父类变量赋值类子类变量。否则强制类型转换将以ClassCastException异常结束。            

3、instanceof检查能否成功的向下转型

     在类类型强制转换的程序设计中，要养成一个良好的习惯：在转换之前 ，使用instanceof运算符查看是否能成功转换。

      instanceof运算符用来判断一个对象是不是某个类或其子类的实例。

Java代码  

1. class Employee{  
2. }  
3. class Manager extends Employee{  
4. }  
5. //e1的引用是Employee类型，e1对象是Employee类的实例，  
6. Employee e1=new Employee();  
7. System.out.println("e1:"+e1 instanceof Manager);  
8. //e2的引用是Employee类型，e2对象是Manager类的实例，  
9. Employee e2=new Manager();  
10. System.out.println("e2:"+e2 instanceof Manager);  
11.   
12. //运行结果：  e1 : false  
13.                    e2 : true  

class Employee{}class Manager extends Employee{}//e1的引用是Employee类型，e1对象是Employee类的实例，Employee e1=new Employee();System.out.println("e1:"+e1 instanceof Manager);//e2的引用是Employee类型，e2对象是Manager类的实例，Employee e2=new Manager();System.out.println("e2:"+e2 instanceof Manager);//运行结果：  e1 : false                   e2 : true

 

        因此如果instanceof为false的时候，编译器将不会进行这个转化

Java代码  

1. if(e1 instanceof Manager){  
2.         Manager m=(Manager)e1;  
3. }  

if(e1 instanceof Manager){        Manager m=(Manager)e1;}

 

总结：(1) 类类型只能在继承层次内进行类型转换

                (2) 在向下转型之前，应该使用instanceof进行检查