05.基础语法（基本数据类型的相互转换）

基本数据类型的相互转换

数据类型	位数	占用储存空间	默认值	取值范围
byte(字节)	8	1字节	0	-2^7(-128) ~ 2^7-1(127)
short(短整数)	16	2字节	0	-2^15(-32768) ~ 2^15-1(32767)
int(整数)	32	4字节	0	-2^31(-2,147,483,648) ~ 2^31-1(2,147,483,647)
long(长整数)	64	8字节	0L	-2^63L ~ 2^63-1L
float(单精度)	32	4字节	0.0f	-2^31 ~ 2^31-1
double(双精度)	64	8字节	0.0	-2^63 ~ 2^63-1
char(字符)	16	2字节	空	0 ~ 2^16-1
boolean(布尔值)	8	1字节	false	true、false

位（bit）：是计算机内部 数据储存 的最小单位，11001100是一个八位二进制数。
字节（byte）：是计算机中 数据处理 的基本单位，习惯上用大写B来表示,1B（byte,字节）= 8bit（位）。

字节（Byte）是计算机信息技术用于计量存储容量的一种计量单位，作为一个单位来处理的一个二进制数字串，是构成信息的一个小单位。最常用的字节是八位的字节，即它包含八位的二进制数。

java中整数类型默认的int类型；小数类型默认的double;
在基本数据类型中除boolean外均可参与算数运算;
小容量向大容量转换叫做自动类型转换：

double > float > long > int > short > byte
                              char  >

byte,short,char做混合运算的时候，各自都先转换成int在做运算;
大容量向小容量转换是强制类型转换，需要加强制转换符，编译虽然通过，运行期可能损失精度。谨慎使用;
如果整数没有超出byte,short,char的取值范围，可以直接将这个整数赋值给byte,short,char;
多种数据类型做混合运算，先转换成容量最大的那种再做运算。

public class DataTypeTes {
        
        public static void main(String[] args) {
               
                //出现错误，1000超出了byte的范围
                //byte a = 1000;
               
                //正确，因为20没有超出byte范围
                //所以赋值
                byte a = 20;
               
                //变量不能重名
                //short a =  1000;
               
                //正确，因为数值1000没有超出short类型的范围
                //所以赋值正确
                short b =  1000;
               
                //正确，因为默认就是int，并且没有超出int范围
                int c = 1000;
               
                //正确，可以自动转换
                long d = c;
               
                //错误，出现精度丢失问题，大类型-->>小类型会出现问题
                //int e = d;
               
                //将long强制转换成int类型
                //因为值1000，没有超出int范围，所以转换是正确的
                int e = (int)d;
               
                //因为java中的运算会会转成最大类型
                //而10和3默认为int,所以运算后的最大类型也是int
                //所以是正确的
                int f = 10/3;        
               
                //声明10为long类型
                long g = 10;
               
                //出现错误，多个数值在运算过程中，会转换成容量最大的类型
                //以下示例最大的类型为double，而h为int，所以就会出现大类型（long）到小类型（int）
                //的转换，将会出现精度丢失问题
                //int h = g/3;
               
                //可以强制转换,因为运算结果没有超出int范围
                //int h = (int)g/3;
               
                //可以采用long类型来接收运算结果
                //long h = g/3;
               
                //出现精度损失问题，以下问题主要是优先级的问题
                //将g转换成int，然后又将int类型的g转换成byte,最后byte类型的g和3运算，那么
                //它的运算结果类型就是int，所以int赋值给byte就出现了精度损失问题
                //byte h = (byte)(int)g/3;
               
                //正确
                //byte h = (byte)(int)(g/3);                        
               
                //不能转换,还有因为优先级的问题
                //byte h = (byte)g/3;        
               
                //可以转换，因为运算结果没有超出byte范围
                //byte h = (byte)(g/3);
               
                //可以转换，因为运算结果没有超出short范围
                short h = (short)(g/3);
               
                short i = 10;
               
                byte j = 5;
               
                //错误，short和byte运算，首先会转换成int再运算
                //所以运算结果为int，int赋值给short就会出现精度丢失问题
                //short k = i + j;
               
                //可以将运算结果强制转换成short
                //short k = (short)(i + j);
               
                //因为运算结果为int，所以可以采用int类型接收
                int k  = i + j;
               
                char l = 'a';
                System.out.println(l);
               
                //输出结果为97，也就是a的ascii值
                System.out.println((byte)l);
               
                int m = l + 100;
                //输出结构为197,取得a的ascii码值，让后与100进行相加运算
                System.out.println(m);
               
        }
}