继续浏览精彩内容
慕课网APP
程序员的梦工厂
打开
继续
感谢您的支持,我会继续努力的
赞赏金额会直接到老师账户
将二维码发送给自己后长按识别
微信支付
支付宝支付

Java数据类型的转换(一)

霜花似雪
关注TA
已关注
手记 163
粉丝 1.5万
获赞 8507

http://img2.mukewang.com/5eb6846b0001ca3714401080.jpg

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));
}

未完,待续!请诸君多多支持,喜欢的话,点个赞吧!

打开App,阅读手记
2人推荐
发表评论
随时随地看视频慕课网APP