基本数据类型间的转换 (转)

 基本数据类型间的转换

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

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

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

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

     原则： (1)  所占字节数相对少的可以自动向字节数相对多的转换。

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

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

               (4)  boolean型不能与其他任何数值类型之间转换。(下面强制转换也不可)

 

3、基本数据类型的强制转换

     如果非要将范围大的类型转换成小的类型，就必须执行强制类型转换，大范围类型多出的bit将会被截去。

Java代码

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

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

4、布尔型转换的小技巧

     原则上，布尔型与其他任何基本数据类型没有任何关系，这一点和C/C++不一样(0是true,非0是false)。但是可以通过条件表达式b?1:0来巧妙赋值为int。

Java代码

1. boolean b=true;   
2. int i=b?1:0;   
3. System.out.print(i);   
4. //打印结果： 1  

boolean b=true;
int i=b?1:0;
System.out.print(i);
//打印结果： 1

    其实实质上就是if语句，算不上转换。

 

 

 

* 类类型间的转换

这里有一句很经典的雷人之言：

        男人绝对是人，人可能不是男人，只有原来是男人的人才有希望变回男人。

 

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的实际类型为Employee
Manager 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的实际类型为Manager
Manager 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进行检查