Java基本数据类型转换（强制类型转换（手动）&隐式类型转换（自动））
基本数据类型转换
为什么需要数据类型转换？
答：因为java是强类型语言，要求执行“赋值运算”和“算术运算”的类型保持一致
基本数据类型转换的两种方式
- 隐式类型转换（自动）
- 强制类型转换（手动）
哪些基本数据类型可参与基本数据类型转换？
除了布尔类型外，其余的基本数据类型都可相互转换
隐式类型转换（自动）
核心：低字节向髙字节自动提升
byte（1字节）–>short(2字节)–>int(4字节)–>long(8字节)–>float(4字节)–>double(8字节)
char(2字节)–>int(4字节)
代码展示：
public class Demo{
public static void main(String[] args){
char a = 'a';
int num = a;
System.out.println(num);//97
}
}
代码展示：
public class DataTypeDemo{
public static void main(String[] args){
byte buf = 12;
// 将buf从byte类型隐式类型转换为了short类型
short copyBuf = buf;
System.out.println(copyBuf);// 18;
short age = 100;
// 将age从short类型隐式类型转换为了int类型
int copyAge = age;
System.out.println(copyAge);// 100
int year = 2019;
// 将year 从int类型隐式类型转换为了long类型
long copyYear = year;
System.out.println(copyYear);// 2019
long num = 14575642145L;
// 将num从long类型隐式类型转换为了float类型
float copyNum = num;
System.out.println(copyNum);// 1.45756426E10
float f = 3.14f;
// 将f从float类型隐式类型转换为了double类型
double d = f;
System.out.println(d);// 3.140000104904175
}
}
运行截图：
赋值运算：
规律：低字节向高字节自动提升
特例：把int类型的常量赋值给byte类型、short类型和char类型的变量或者final修饰的常量时，没有任何问题。
代码展示：
public class DataType{
public static void main(String[] args){
final int CONSTANT_NUM = 127;
byte copyNum = CONSTANT_NUM;
final int CONSTANT_NUM1 = 20000;
short copyNum1 = NUM1;
final int CONSTANT_NUM2 = 97;
char copyNum2 = NUM2;
System.out.println(copyNum); // 127
System.out.println(copyNum1);// 20000
System.out.println(copyNum2);// a
}
}
运行截图：
代码展示：
public class DataType{
public static void main(String[] args){
byte num = 127;
short num1 = 20000;
char num2 = 97;
final int num3 = 189;
System.out.println(num3);// 189
System.out.println(num);// 127
System.out.println(num1);// 20000
System.out.println(num2)// a
}
}
代码展示：
public class DataTypeDemo{
public static void main(String[] args){
int num = 10;
long num1 = num;
System.out.printlb(num1);//10
}
}
运行截图：
画图分析：
算术运算：
前提：两个不同类型的操作数，进行运算时，会触发隐式类型转换
规律：
若两个操作数其中有一个是double类型，另一个就会隐式类型转换为double类型否则，若两操作数中其中有一个是float类型，另一个就会隐式类型转换为float类型
否则，若两操作数中其中有一个long类型，另一个就会隐式类型转换为long类型
若两个操作数中即没有long类型，也没有float类型，也没有double类型，那最终的结果就为int类型
代码展示：
// 若两个操作数中有一个为double类型，另一个就会隐式类型转换为double类型
public claas DoubleTest1{
public static void main(String[] args){
double d = 3.14;
float f = 3.14f;
// 错误写法：
float f1 = d + f;
System.out.println(f1);
}
}
运行截图：
代码展示：
// 若两个操作数中有一个为double类型，另一个就会隐式类型转换为double类型
public claas DoubleTest1{
public static void main(String[] args){
double d = 3.14;
float f = 3.14f;
// 正确写法：
double f1 = d + f;
System.out.println(f1);// 6.280000104904175
}
}
运行截图：
代码展示：
// 若两个操作数中有一个为float类型，另一个就会隐式类型转换为float类型
public class FloatTest{
public static void main(Sting[] args){
float f = 3.4f;
int a = 12;
float sum = f + a;
System.out.println("Sum = " + sum);// Sum = 15.14
}
}
运行截图：
代码展示：
// 若两个操作数中有一个为long类型，另一个就会隐式类型转换为long类型
public class LongTest{
public static void main(String[] args){
long millons = 10000000000L;
float a = 12.1;
long b = millons + (int)a;
System.out.println("b = " + b);//b = 10000000012
}
}
运行截图：
代码展示：
// 若两个操作数中既没有long类型，也没有float类型，也没有double类型，那最终的结果为int类型
public class IntTest{
public static void main(String[] args){
byte num = 10;
short num1 = 20;
// 错误写法：
short sum = num + num1;
System.out.println("Sum = "+ sum);
}
}
编译出错截图：
代码展示：
// 若两个操作数中既没有long类型，也没有float类型，也没有double类型，那最终的结果就为int类型
public class IntTest{
public static void main(String[] args){
byte buf = 10;
short buf1 = 20;
int sum = buf + buf1;
System.out.println("Sum = " + sum);// sum = 30
}
}
运行截图：
常见面试题：
-
byte b1 = 11;byte b2 = 12;byte sum = b1 + b2;&
int num = 1;int num2 = 300;int sum = num + num2;哪一个正确呢？
答：
int sum = num + num2;正确，因为算术运算的规律：若两个操作数中既没有long类型，也没有float类型，也没有double类型，那最终结果是int类型，两个in类型的数值的和结果还是int类型。故，这题int sum = num +num2;代码展示：
public class Demo{ public static void main(String[] args){ byte b1 = 11; byte b2 = 12; // 会出现编译错误 byte sum = b1 + b2; System.out.println("sum = "+ sum); } }编译错误截图：
代码展示：
public class Demo{ public static void main(String[] args){ int num = 1; int num2 = 300; int sum = num + num2; System.out.println("Sum = " + sum);// sum = 301 } }运行截图：
-
请说出
100000L*100000*100000和100000 * 100000 * 100000的区别?答：
100000L*100000*100000结果为long类型，编译&执行都没问题，100000 * 100000 * 100000结果为int类型，编译没问题，执行得出来的结果有问题代码展示：
public class Demo{ public static void main(String[] args){ // 若两个操作数其中有一个为long类型，另一个会隐式类型转换为long类型 long multiply = 100000L*100000*100000; System.out.println("100000L*100000*100000的值为" + multiply); int multiply1 = 100000 * 100000 * 100000; System.out.println("100000 * 100000 * 100000的值为" + multiply1);// 预计：1000 0000 0000 0000 实际:-1530494976 } }运行截图：
-
int num = 90000;int num2 = 90000;int total = num * num2请问total的结果是多少？
答：预计结果：81 0000 0000
实际结果：-489934592
造成-489934592这个结果的原因：int类型的取值范围是-231~231-1,int类型无法存储81亿的数值，并只保留低位4字节的内容，故，造成了这个结果
代码展示：
public class Demo{ public static void main(String[] args){ int num = 90000; int num2 = 90000; int total = num * num2; System.out.println(total); } }运行截图：
强调：看待一个模块是否正确，需要从“编译”和“执行”两个角度考虑
编译，检查的是语法有没有问题（语法问题）
执行，程序在JVM（即java虚拟机）执行过程中是否有问题（逻辑问题）
强制类型转换（手动）
核心：高字节向低字节手动进行转换
double(8字节)–>float（4字节）–>long(8字节)–>int（4字节）–>short(2字节)–>byte(1字节)
int(4字节) -->char（2字节）
什么时候需要强制类型转换？
当隐式类型转换无法解决问题时，就需要使用强制类型转换
强制类型转换的作用？
语法：目标数据数据类型 变量名 = （目标数据类型）数据;
目标数据类型：想要转换的数据类型
代码展示：
public class ChangeTypeDemo{
public static void main(String[] args){
// int(4字节)-->char(2字节)
int b = 97;
char a = b;
System.out.println(a); // 'a'
}
}
代码展示：
public class ChangeType{
public static void main(String[] args){
// double -->float
double d = 3.14;
float f = (float)d;
System.out.println(f);// 3.14
// float -->long
float f1 = 12.1f;
long num = (long)f1;
System.out.println(num);//12
// long-->int
long num1 = 14564786854L;
int num2 = (int)num1;
System.out.println(num2);//1679884966
// int --> short
int num3 = 201412345;
short num4 = (short)num3;
System.out.println(num4);//20217
// short-->byte
short num5 = 128;
byte num6 = (byte)num5;
System.out.println(num6);//-128
}
}
运行截图：
代码展示：
public class ChangeType{
/*声明变量num1，在内存中开辟一块8个字节大小的存储空间，通过变量名num1找到对应内存中存储空间将10从十进制转为二进制，存储到该空间*/
long num1 = 10;
// 声明变量num2，在内存中开辟一块4个字节大小的存储空间，将num1从long类型强制类型转换为了int类型，将转换后的结果存储在num2变量中
int num2 = (int)num1;
System.out.println(num2);//10
}
运行截图：
画图分析：
以上代码执行完毕，num1的类型还是long类型，因为相当于只是将num1的值拷贝了一份到运算区进行运算，而没有改变原来num1的类型
强制类型转换的注意事项：
-
强制类型转换后不会对原有的数据类型产生任何影响，如上所示：num1的类型还是long类型
-
强制类型转换会易产生精度偏差，使用时一定注意
代码展示：
public class ChangeTypeDemo{ public static void main(String[] args){ int num = 128; byte num1 = (byte)num; System.out.println(num1);// -128 } }(byte)num分析：将num从int类型强制类型转换为了byte类型，意味着剪切掉了高位三字节，只保留了低位1字节
问题：如何实现小数取整？
实现方式：将小数强制类型转换为整数
代码实现
public class IntDemo{ public static void main(String[] args){ float e =12.5f; System.out.println((int)e);//12 double g = 13.9; System.out.println((int)g);//13 float a = 3.14f; float b = 6.14f; int num = (int)(a + b); System.out.println(num);//9 double c = 6.18; double d = 7.15; int sum = (int)c + (int)d; System.out.println(sum);//13 float h = 7.14f; double i = 8.14; System.out.println((int)(h+i));//15 } }运行截图：
-
使用强制类型转换时，一定要切记取值范围
需求：实现对两个小数之和的结果取整
代码实现:
public class ImplGetInt{ public static void main(String[] args){ System.out.println((int)(3.14f+6.14));// 9 } }
此文章于11月20日编辑完毕，小编也是个初学者，或许有些内容写的有错误的，我对自己的要求是：有错改之，无错加勉。还望大家能在评论区指点迷津，不胜感激，同时也希望大家口下留情！！
上一篇： java 计算对象的大小
下一篇： 一键部署nginx负载均衡