1. 8种基本数据类型除boolean类型之外都可以相互转换.
                2. 小容量向大容量转换叫做自动类型转换：
                                byte<short<int<long<float<double
                                     char<
                3. byte,short,char做混合运算的时候，各自都先转换成int在做运算
               
                4.大容量向小容量转换是强制类型转换，需要加强制转换符，
                编译虽然通过，运行期可能损失精度。谨慎使用。
               
                5.如果整数没有超出byte,short,char的取值范围，可以直接将这个整数赋值给byte,short,char
               
                6.多种数据类型做混合运算，先转换成容量最大的那种再做运算。

1. public class DataTypeTes {
   
2.         
   
3.         public static void main(String[] args) {
   
4.                
   
5.                 //出现错误，1000超出了byte的范围
   
6.                 //byte a = 1000;
   
7.                
   
8.                 //正确，因为20没有超出byte范围
   
9.                 //所以赋值
   
10.                 byte a = 20;
    
11.                
    
12.                 //变量不能重名
    
13.                 //short a =  1000;
    
14.                
    
15.                 //正确，因为数值1000没有超出short类型的范围
    
16.                 //所以赋值正确
    
17.                 short b =  1000;
    
18.                
    
19.                 //正确，因为默认就是int，并且没有超出int范围
    
20.                 int c = 1000;
    
21.                
    
22.                 //正确，可以自动转换
    
23.                 long d = c;
    
24.                
    
25.                 //错误，出现精度丢失问题，大类型-->>小类型会出现问题
    
26.                 //int e = d;
    
27.                
    
28.                 //将long强制转换成int类型
    
29.                 //因为值1000，没有超出int范围，所以转换是正确的
    
30.                 int e = (int)d;
    
31.                
    
32.                 //因为java中的运算会会转成最大类型
    
33.                 //而10和3默认为int,所以运算后的最大类型也是int
    
34.                 //所以是正确的
    
35.                 int f = 10/3;        
    
36.                
    
37.                 //声明10为long类型
    
38.                 long g = 10;
    
39.                
    
40.                 //出现错误，多个数值在运算过程中，会转换成容量最大的类型
    
41.                 //以下示例最大的类型为double，而h为int，所以就会出现大类型（long）到小类型（int）
    
42.                 //的转换，将会出现精度丢失问题
    
43.                 //int h = g/3;
    
44.                
    
45.                 //可以强制转换,因为运算结果没有超出int范围
    
46.                 //int h = (int)g/3;
    
47.                
    
48.                 //可以采用long类型来接收运算结果
    
49.                 //long h = g/3;
    
50.                
    
51.                 //出现精度损失问题，以下问题主要是优先级的问题
    
52.                 //将g转换成int，然后又将int类型的g转换成byte,最后byte类型的g和3运算，那么
    
53.                 //它的运算结果类型就是int，所以int赋值给byte就出现了精度损失问题
    
54.                 //byte h = (byte)(int)g/3;
    
55.                
    
56.                 //正确
    
57.                 //byte h = (byte)(int)(g/3);                        
    
58.                
    
59.                 //不能转换,还有因为优先级的问题
    
60.                 //byte h = (byte)g/3;        
    
61.                
    
62.                 //可以转换，因为运算结果没有超出byte范围
    
63.                 //byte h = (byte)(g/3);
    
64.                
    
65.                 //可以转换，因为运算结果没有超出short范围
    
66.                 short h = (short)(g/3);
    
67.                
    
68.                 short i = 10;
    
69.                
    
70.                 byte j = 5;
    
71.                
    
72.                 //错误，short和byte运算，首先会转换成int再运算
    
73.                 //所以运算结果为int，int赋值给short就会出现精度丢失问题
    
74.                 //short k = i + j;
    
75.                
    
76.                 //可以将运算结果强制转换成short
    
77.                 //short k = (short)(i + j);
    
78.                
    
79.                 //因为运算结果为int，所以可以采用int类型接收
    
80.                 int k  = i + j;
    
81.                
    
82.                 char l = 'a';
    
83.                 System.out.println(l);
    
84.                
    
85.                 //输出结果为97，也就是a的ascii值
    
86.                 System.out.println((byte)l);
    
87.                
    
88.                 int m = l + 100;
    
89.                 //输出结构为197,取得a的ascii码值，让后与100进行相加运算
    
90.                 System.out.println(m);
    
91.                
    
92.         }
    
93. }
    

复制代码

收藏有用

看看  碎觉

有收获，谢谢分享