1. Java基本数据类型：byte(1字节), short(2字节), char(2字节), int(4字节), long(8字节), float(4字节), double(8字节), boolean
Java基本数据类型的包装类型：Byte,Short,Character,Integer,Long,Float,Double,Boolean
2. 基本数据类型所能表示数的范围(精度)与默认值
byte(8位): 最小值 -128（-2^7），最大值 127（2^7）, 默认值为：0
short(16位): 最小值 -32768（-2^15），最大值 32767（2^15 - 1），默认值为：0
char(16位Unicode字符)：最小值是 \u0000（即为0），最大值是 \uffff（即为65,535），默认值为：'u0000'
int(32位): 最小值 -2,147,483,648（-2^31）,最大值 2,147,483,647（2^31 - 1） ,默认值为：0
long(64位)：最小值是 -9,223,372,036,854,775,808（-2^63），最大值是 9,223,372,036,854,775,807（2^63 -1），默认值为：0L
float(32位)：最小值：1.4E-45，最大值：3.4028235E38，默认值为：0.0f
double(64位)：最小值：4.9E-324，最大值：1.7976931348623157E308，默认值为：0.0d
整数默认是int类型,浮点数默认是double类型
3. 装箱与拆箱
装箱就是自动将基本数据类型转换为包装类型；拆箱就是自动将包装类型转换为基本数据类型。
Byte b = 1; //自动装箱 byte b1 = b; //自动拆箱(下同) Short s = 2; short s1 = s; Character c = 'F'; char c1 = c; Integer i = 100; int i1 = i; Long l = 100L; // l和L均可 long l1 = l; Float f = 3.14F; // f和F均可 float f1 = f; Double d = 3.14; double d1 = d; Boolean bool = true; boolean bool1 = bool;
4. 数据类型转换必须满足如下规则：
(1) 不能对boolean类型进行类型转换。
(2) 不能把对象类型转换成不相关类的对象。
(3) 在把范围大的类型转换为范围小的类型时必须使用强制类型转换。
(4) 转换过程中可能导致溢出或损失精度，例如：
int i =128;
byte b = (byte)i;
因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。
5. 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：
(int)33.5678 == 33;
(int)-30.89f == -30
5. 数据类型之间的转换
从低级到高级。
低 -------------------------------------------------> 高
byte,short,char—> int —> long—> float —> double
byte,short,char之间不转换,它们参与运算自动转成int
对于简单类型数据间的转换,有两种方式:自动类型转换和强制类型转换,通常发生在表达式中或方法的参数传递时。
自动类型转换：低精度向高精度转换（低级类型向高级类型转换）
(1)按照数据类型所能表示值的范围的大小(精度)，从小到大排序依次为：(byte, short, char)-->int-->long-->float-->double;
//低精度向高精度转换
byte b = 100;
short s = 200;
char c = 'B';
int i = b;
System.out.println("i = " + i);
int i1 = s;
System.out.println("i1 = " + i1);
int i2 = c;
System.out.println("i2 = " + i2);
long l = i;
System.out.println("l = " + l);
float f = l;
System.out.println("f = " + f);
double d = f;
System.out.println("d = " + d);(2)在进行表达式运算时：精度小的数据类型，会向精度高的数据类型进行自动转换（也可以说成低级类型向高级类型转换）；
(3)在进行方法调用时：实际参数的精度较小，而被调用的方法的形式参数的精度较大时(若有匹配的方法，则会直接调用匹配的方法)，系统也会将精度小的数据类型自动转换为精度较大的数据类型，然后进行方法调用。
private static double add(double d1, double d2) {
double sum = d1 + d2;
return sum;
}
private static double add1(double d1, float f1) {
double sum1 = d1 + f1;
return sum1;
}
public static void main(String[] args) {
byte b = 120;
int i = 180;
System.out.println("sum = " + add(b, i)); //300.0
System.out.println("sum1 = " + add1(b, i)); //300.0
}(4)同一个类中，对于多个重载方法，会转换成最“接近”的精度数据进行调用。
//定义多个重载方法(方法名相同，方法的参数类型，个数，返回值不同的方法)
private static double add(double d1, double d2) {
System.out.println("add被调用了");
double sum = d1 + d2;
return sum;
}
private static double add(double d1, float f1) {
System.out.println("add1被调用了");
double sum1 = d1 + f1;
return sum1;
}
private static float add(float f1, float f2) {
System.out.println("add2被调用了");
float sum2 = f1 + f2;
return sum2;
}
private static float add(int i1, float f2) {
System.out.println("add3被调用了");
float sum3 = i1 + f2;
return sum3;
}
public static void main(String[] args) {
byte b = 100;
short s = 300;
int i = 500;
float f = 3.14f;
double d = 314.15926d;
System.out.println("sum = " + add(b, s));
System.out.println("sum1 = " + add(b, i));
System.out.println("sum2 = " + add(s, i));
System.out.println("sum3 = " + add(i, f));
System.out.println("sum4 = " + add(b, d));
System.out.println("sum5 = " + add(f, d));
System.out.println("sum6 = " + add(d, f));
System.out.println("sum7 = " + add(b, b));
System.out.println("sum8 = " + add(i, i));
System.out.println("sum9 = " + add(f, f));
System.out.println("sum10 = " + add(d, d));
}(5)如果低级类型为char型，它向高级类型（整型）转换时，会转换为对于的ASCII码值。
char c = 'a';
int i = c;
System.out.println("i = " + i); // i = 97
(6)对于byte,short,char这三种类型，它们是平级的，因此它们不能相互自动转换。
强制类型转换：高精度向低精度转换（高级类型向低级类型转换），存在精度损失问题
将高精度的数据类型转换为低精度的数据类型时，可以使用强制类型转换，这种转换可能导致溢出或精度损失。
强制类型转换的数据类型必须是兼容的,强制转换不会报错,但是会损失精度。
格式：(type)value type是要强制类型转换后的数据类型
double d = 314.15926762562627d;
//double强转为float,丢失部分小数
float f = (float)d;
System.out.println("f = " + f);
//double强转为long，只保留整数部分
long l = (long)d;
System.out.println("l = " + l);
//double强转为int，只保留整数部分
int i = (int)d;
System.out.println("i = " + i);
//double强转为short，只保留整数部分
short s = (short)d;
System.out.println("s = " + s);
//double强转为byte，存在溢出(314对应的二进制为：0001 0011 1010，因为byte占8位，取其后8位为58)
byte b = (byte)d;
System.out.println("b = " + b);6. 表达式运算的数据类型自动提升规则：
(1)所有的byte,short,char型的值将被提升为int型；
(2)如果有一个操作数是long型，计算结果是long型；
(3)如果有一个操作数是float型，计算结果是float型；
(4)如果有一个操作数是double型，计算结果是double型；
//获取变量的类型
public static String getType(Object o){
return o.getClass().toString();
}
public static void main(String[] args) {
byte b = 12;
short s = 350;
char c = 90;
int i = 100;
long l = 2000;
float f = 3.14f;
double d = 3.14159265758;
System.out.println("1 --- " + getType(b));
System.out.println("2 --- " + getType(s));
System.out.println("3 --- " + getType(c));
System.out.println("4 --- " + getType(i));
System.out.println("5 --- " + getType(l));
System.out.println("6 --- " + getType(f));
System.out.println("7 --- " + getType(d));
System.out.println("\n");
System.out.println("1 --- " + getType(b + s));
System.out.println("2 --- " + getType(b + i));
System.out.println("3 --- " + getType(s + i));
System.out.println("4 --- " + getType(c + i));
System.out.println("5 --- " + getType(c + s));
System.out.println("6 --- " + getType(c + b));
System.out.println("\n");
System.out.println("1 --- " + getType(i+ l));
System.out.println("2 --- " + getType(l + f));
System.out.println("3 --- " + getType(f + d));
System.out.println("4 --- " + getType(l + d));
System.out.println("5 --- " + getType(f + f));
System.out.println("6 --- " + getType(d + d));
}未完，待续！请诸君多多支持，喜欢的话，点个赞吧！
共同学习，写下你的评论
评论加载中...
作者其他优质文章
