java的基本数据类型

基本数据类型：byte、short、int、long、float、double、char、boolean 。
引用数据类型: 数组、类、接口。

1. int:整型，4个字节，-21多亿到21个多亿

int a=250;//250为整数直接量，默认为int型
int b=10000000000;//编译错误，100亿默认为int型, 但超出了范围
System.out.println(5/2); //2  小数位被舍弃了
System.out.println(2/5); //0  小数位被舍弃了
int c=2147483647;//int上的最大值
	c=c+1; //在c本身基础上增1
	System.out.println(c);//溢出  为-2147483648

2. long：长整型，8个字节，很大很大很大

long a=250L;//250L为长整型直接量
long b=10000000000;//编译错误，100亿默认为int,但超出了int的范围
long c=10000000000L;//正确
long d=1000000000*2*10L;
System.out.println(d);//200亿 int*int=int 20亿没有超出，int*long=long
long e=1000000000*3*10L;
System.out.println(e);//溢出  int*int=int 30亿仍属于int，但超出范围了，溢出	
long f=1000000000L*3*10;//建议：若有可能溢出，将L写在第一个数之后
System.out.println(f);//300亿 long*int=long 30亿*10=300亿，仍属于long
long g=System.currentTimeMillis();//获取自1970.1.1零时到此时此刻的毫秒数
System.out.println(g);

3. double:浮点型，8个字节，很大很大很大

double a=3.14159;//3.14159为浮点型直接量，默认为double型
float b=3.14159f;//3.14159f为float型直接量
double c1=3.0;
double d1=2.9;
System.out.println(c1-d1);//0.10000000000000009,舍入误差
double c2=6.0;
double d2=4.9;
System.out.println(c2-d2);//1.0999999999999996,舍入误差

4. boolean:布尔型，1个字节，只能取值为true和false

boolean b1=true;//true为布尔型的直接量
boolean b2=false;//false 为布尔型的直接量
boolean b3=250;//编译错误，数据类型不匹配

5. char：字符型，2个字节

char c1='男';
char c2='m';
char c3='5';
char c4=' ';
char c5=女;//编译错误，必须放在一对单引号中
char c6='';//编译错误，必须有字符
char c7='男性';//编译错误，只能有一个字符
char c8=97;//正确，数值必须在0到65535之间
System.out.println(c8);//a 因为c8的类型为char,所以会以对应的字符形式输出
System.out.println(2+2);//4   2是int，两个int的2相加为4
System.out.println('2'+'2');//100  字符'2'的码50加上'2'的码50
char c9='\'';
System.out.println(c9); // '

基本类型间的转换

• 从小到大 byte、short、int、long、float、double
• char转int， float不参与转换

int a=5;
long b=a;//自动类型转换（a到b是int到long，小到大）
int c=b;//编译错误，b到c是long到int,大到小要进行强制转换
int c=(int)b;//强制类型转换，（大到小） b本来是long,强制转换为int
long d=5;//5是int型 d是long型，这里系统帮忙进行了自动类型转换
double e=5;//自动类型转换，5是int型，e是double型，由小到大，自动类型转换
System.out.println(e);//5.0

//强制转换容易溢出
long f=10000000000l;
int g=(int)f;	
System.out.println(g);//long到int，由大到小，强制转换为int，但是100亿转换为int超出了int的范围，int是-21多亿到21多亿，发生溢出

//强制转换有可能精度丢失
double h=25.987;
int i=(int) h;
System.out.println(i);//强制转换，double到int，精度丢失

//整数直接量（int）可以直接赋值给byte，short，char,但不能超范围(byte是-128到127)
byte b1=5;//5是int，b1是byte，大到小，本来应该强制转换，但是整数直接量可以直接赋值给byte
byte b2=6;

//byte，short，char型变量参与运算时，先一律转换为int 再运算
byte b3=b1+b2; //编译错误，b1+b2本来是byte，参与运算的时候转成了int,所以b1+b2的值也是int,int到byte是大到小，需要强制转换(b1+b2是运算，不是整数直接量，所以不能直接赋值为int，只能强转)
byte b3=(byte)(b1+b2);
System.out.println(b3);//11
System.out.println('2'+'2');//100  '2'是char，参与运算时，先转换为int ，是50 。