数据类型转换
由来
自动转换
- 概念:自动转换:将 取值范围小的类型 自动提升为 取值范围大的类型 。
- 转换规则:范围小的类型向范围大的类型提升, byte、short、char 运算时直接提升为 int 。byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double
- 特点:代码不需要进行特殊处理,自动完成。
自动类型转换,代码演示
/* 当数据类型不一样时,将会发生数据类型转换。 自动类型转换(隐式) 1. 特点:代码不需要进行特殊处理,自动完成。 2. 规则:数据范围从小到大。 强制类型转换(显式) */ public class Demo01DataType { public static void main(String[] args) { //直接写上的整数 默认就是int类型 System.out.println(1024);//1024 //直接写上的小数,默认就是double类型 System.out.println(3.14);//3.14 /* 将右侧的int常量,交给左侧的long变量进行存储 int --> long,int类型的数据自动提升为long类型 这一行代码发生了自动类型转换。 */ long num1 = 100; System.out.println(num1); // 100 /* float --> double,符合从小到大的规则 float类型的数据自动提升为double类型 这一行代码发生了自动类型转换。 */ double num2 = 2.5F; System.out.println(num2); // 2.5 //long --> float,范围是float更大一些,符合从小到大的规则 float num3 = 30L; System.out.println(num3); // 30.0 } }
强制转换
- 概念:强制类型转换:将 取值范围大的类型 强制转换成 取值范围小的类型 。
- 转换格式:数据类型 变量名 = (数据类型)被转数据值;
- 特点:自动转换是Java自动执行的,而强制转换需要我们自己手动执行。
public class Demo02DataType { public static void main(String[] args) { /* long类型的数据 交给int类型的数据进行保存,我们必须进行强制转换,否则无法编译 强制类型转换的格式:范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据; 同理:数据取值范围大的类型交个数据取值范围小类型保存,必须进行强制转换 */ int num = (int) 100L; System.out.println(num);//100 } }
注意事项:
- 强制类型转换一般不推荐使用,因为有可能发生精度损失、数据溢出。
- byte/short/char这三种类型都可以发生数学运算,例如加法“+”.
- byte/short/char这三种类型在运算的时候,都会被首先提升成为int类型,然后再计算。
- boolean类型不能发生数据类型转换
注意事项,代码演示
public class Demo { public static void main(String[] args) { //浮点转成整数,直接取消小数点,可能造成数据损失精度。 int number1 = (int) 3.99; System.out.println(number1);//3 // 数据过大,超过了数据范围小的最大取值范围,可能造成数据丢失。 int number2 = (int) 6000000000L; System.out.println(number2);//1705032704 } }
ASCII编码表
查看下面代码,并解释为什么结果是98?
public class Demo03DataTypeChar { public static void main(String[] args) { //字符类型变量 char c = 'a'; int i = 1; //字符类型和int类型计算 System.out.println(c + i);// 98 } }
解答:在char类型和int类型计算的过程中,char类型的字符先查询编码表,得到97,再和1求和,结果为98。char类型提升为了int类型。char类型内存2个字节,int类型内存4个字节。
运算符
什么是运算符?
运算符:进行特定操作的符号。例如:+
什么是表达式?
表达式:用运算符连起来的式子叫做表达式。例如:20 + 5。又例如:a + b
算数运算符
常见的算数运算符如下图所示
代码演示,常见的算数运算符的使用
/* 除法公式: 被除数 / 除数 = 商 ... 余数 对于一个整数的表达式来说,除法用的是整除,整数除以整数,结果仍然是整数。只看商,不看余数。 只有对于整数的除法来说,取模运算符才有余数的意义。 */ public class Demo04Operator { public static void main(String[] args) { // 两个常量之间可以进行数学运算 System.out.println(20 + 30);//50 // 两个变量之间也可以进行数学运算 int a = 20; int b = 30; System.out.println(a - b); // -10 // 变量和常量之间可以混合使用 System.out.println(a * 10); // 200 int x = 10; int y = 3; //只看商,不看余数。 int result1 = x / y; System.out.println(result1); // 3 //取模运算,两个数字相除取余数 int result2 = x % y; System.out.println(result2); // 1 // 一旦运算当中有不同类型的数据,那么结果将会是数据类型范围大的那种。 double result3 = x + 2.5; System.out.println(result3); // 12.5 } }
注意事项:
- 一旦运算当中有不同类型的数据,那么结果将会是数据类型范围大的那种。
四则运算当中的加号“+”有常见的三种用法:
- 对于数值来说,那就是加法。
- 对于字符char类型来说,在计算之前,char会被提升成为int,然后再计算。char类型字符,和int类型数字,之间的对照关系表:ASCII、Unicode
- 对于字符串String(首字母大写,并不是关键字)来说,加号代表字符串连接操作。任何数据类型和字符串进行连接的时候,结果都会变成字符串
代码演示
public class Demo05Plus { public static void main(String[] args) { //对于数值来说,那就是加法。 System.out.println(1 + 1); // 2 //在计算之前,char会被提升成为int char c = 'Y'; //char + int -->int + int -->int System.out.println(c + 3);//92 String s = "Java"; // 加号代表字符串连接操作。String + int --> String System.out.println(s + 20); // Java20 // 优先级问题 System.out.println(s + 20 + 30); // Java2030 //小括号里的优先执行 System.out.println(s + (20 + 30)); // Java50 } }
自增运算符:++ 自减运算符:--
基本含义:让一个变量涨一个数字1,或者让一个变量降一个数字1
使用格式:写在变量名称之前,或者写在变量名称之后。例如:++i,也可以i++
使用方式:
- 单独使用:不和其他任何操作混合,自己独立成为一个步骤。
- 混合使用:和其他操作混合,例如与赋值混合,或者与打印操作混合,等。
使用区别:
单独使用:前++和后++没有任何区别。也就是:++i;和i++;是完全一样的。
混合使用:有【重大区别】
如果是【前++】,那么变量【立刻马上+1】,然后拿着结果进行使用。 【先加后用】
如果是【后++】,那么首先使用变量本来的数值,【然后再让变量+1】。 【先用后加】
代码演示,自增/自减运算符的基本使用
public class Demo06Operator { public static void main(String[] args) { int i = 10; System.out.println(i); // 10 ++i; // 单独使用,前++ System.out.println(i); // 11 i++; // 单独使用,后++ System.out.println(i); // 12 // 与打印操作混合的时候 int j = 20; // 混合使用,先++,变量立刻马上变成21,然后打印结果21 System.out.println(++j); // 21 System.out.println(j); // 21 int z = 30; // 混合使用,后++,首先使用变量本来的30,然后再让变量+1得到31 System.out.println(z++); // 30 System.out.println(z); // 31 int x = 40; // 和赋值操作混合,前--,变量立刻马上-1变成39,然后将结果39交给result1变量 int result1 = --x; System.out.println(result1); // 39 System.out.println(x); // 39 int y = 50; // 混合使用,后--,首先把本来的数字50交给result2,然后我自己再-1变成49 int result2 = y--; System.out.println(result2); // 50 System.out.println(y); // 49 int a = 10; int b = 20; // 11 + 20 = 31 int result3 = ++a + b--; System.out.println(result3); // 31 System.out.println(a); // 11 System.out.println(b); // 19 // 30++; // 错误写法!常量不可以使用++或者-- } }
注意事项:
- 只有变量才能使用自增、自减运算符。常量不可发生改变,所以不能用。
赋值运算符
常见的赋值运算符如下图所示
代码演示赋值运算符的基本使用
/* 赋值运算符分为: 基本赋值运算符:就是一个等号“=”,代表将右侧的数据交给左侧的变量。 int a = 30; 复合赋值运算符: += a += 3 相当于 a = a + 3 -= b -= 4 相当于 b = b - 4 *= c *= 5 相当于 c = c * 5 /= d /= 6 相当于 d = d / 6 %= e %= 7 相当于 e = e % 7 */ public class Demo07Operator { public static void main(String[] args) { int a = 10; // 按照公式进行翻译:a = a + 5 a += 5; System.out.println(a); // 15 int x = 10; // x = x % 3; x %= 3; System.out.println(x); // 1 // 50 = 30; // 常量不能进行赋值,不能写在赋值运算符的左边。错误写法! byte num = 30; /*
隐藏了赢过强制类型转换
num = num + 5; num = byte + int num = int + int num = int num = (byte) int */ num += 5; System.out.println(num); // 35 } }
注意事项:
- 只有变量才能使用赋值运算符,常量不能进行赋值。
- 复合赋值运算符其中隐含了一个强制类型转换。
比较运算符
常见的比较运算符如下图所示
代码演示比较运算符的基本使用
/* 【两个等号连写才是相等,一个等号代表的是赋值】 */ public class Demo08Operator { public static void main(String[] args) { System.out.println(10 > 5); // true int num1 = 10; int num2 = 12; System.out.println(num1 < num2); // true System.out.println(num2 >= 100); // false System.out.println(num2 <= 100); // true System.out.println(num2 <= 12); // true System.out.println("==============="); System.out.println(10 == 10); // true System.out.println(20 != 25); // true System.out.println(20 != 20); // false int x = 2; // System.out.println(1 < x < 3); // 错误写法!编译报错!不能连着写。 } }
注意事项:
- 比较运算符的结果一定是一个boolean值,成立就是true,不成立就是false
- 如果进行多次判断,不能连着写。数学当中的写法,例如:1 < x < 3程序当中【不允许】这种写法。
逻辑运算符
常见的逻辑运算符如下图所示
代码演示,逻辑运算符的基本使用
/* 与(并且) && 全都是true,才是true;否则就是false 或(或者) || 至少一个是true,就是true;全都是false,才是false 非(取反) ! 本来是true,变成false;本来是false,变成true 与“&&”,或“||”,具有短路效果:如果根据左边已经可以判断得到最终结果,那么右边的代码将不再执行,从而节省一定的性能。 */ public class Demo09Logic { public static void main(String[] args) { System.out.println(true && false); // false // true && true --> true System.out.println(3 < 4 && 10 > 5); // true System.out.println("============"); System.out.println(true || false); // true System.out.println(true || true); // true System.out.println(false || false); // false System.out.println("============"); System.out.println(true); // true System.out.println(!true); // false System.out.println("============"); int a = 10; // false && ... System.out.println(3 > 4 && ++a < 100); // false System.out.println(a); // 10 System.out.println("============"); int b = 20; // true || ... System.out.println(3 < 4 || ++b < 100); // true System.out.println(b); // 20 } }
注意事项:
- 逻辑运算符只能用于boolean值。
- 与、或需要左右各自有一个boolean值,但是取反只要有唯一的一个boolean值即可。
- 与、或两种运算符,如果有多个条件,可以连续写。两个条件:条件A && 条件B 多个条件:条件A && 条件B && 条件C 例如:对于1 < x < 3的情况,应该拆成两个部分,然后使用与运算符连接起来:int x = 2;1 < x && x < 3
三元运算符
格式:
计算方式:
- 布尔类型表达式结果是true,三元运算符整体结果为结果1,赋值给变量。
- 布尔类型表达式结果是false,三元运算符整体结果为结果2,赋值给变量。
代码演示
/* 一元运算符:只需要一个数据就可以进行操作的运算符。例如:取反!、自增++、自减-- 二元运算符:需要两个数据才可以进行操作的运算符。例如:加法+、赋值= 三元运算符:需要三个数据才可以进行操作的运算符。 格式: 数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B; 流程: 首先判断条件是否成立: 如果成立为true,那么将表达式A的值赋值给左侧的变量; 如果不成立为false,那么将表达式B的值赋值给左侧的变量; 二者选其一。 */ public class Demo10Operator { public static void main(String[] args) { int a = 10; int b = 20; // 数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B; // 判断a > b是否成立,如果成立将a的值赋值给max;如果不成立将b的值赋值给max。二者选其一 int max = a > b ? a : b; // 最大值的变量 System.out.println("最大值:" + max); // 20 // int result = 3 > 4 ? 2.5 : 10; // 错误写法! System.out.println(a > b ? a : b); // 正确写法! // a > b ? a : b; // 错误写法! } }
注意事项:
- 必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
- 三元运算符的结果必须被使用。
编译器的2点优化
优化1
对于byte/short/char三种类型来说,如果右侧赋值的数值没有超过范围,那么javac编译器将会自动隐含地为我们补上一个(byte)(short)(char)。
- 如果没有超过左侧的范围,编译器补上强转。
- 如果右侧超过了左侧范围,那么直接编译器报错。
代码演示
public class Demo1Notice { public static void main(String[] args) { // 右侧确实是一个int数字,但是没有超过左侧的范围,就是正确的。 // int --> byte,不是自动类型转换 byte num1 = /*(byte)*/ 30; // 右侧没有超过左侧的范围 System.out.println(num1); // 30 // byte num2 = 128; // 右侧超过了左侧的范围 // int --> char,没有超过范围 // 编译器将会自动补上一个隐含的(char) char c= /*(char)*/ 65; System.out.println(c); // A } }
优化2
在给变量进行赋值的时候,如果右侧的表达式当中全都是常量,没有任何变量,那么编译器javac将会直接将若干个常量表达式计算得到结果。例如:short result = 5 + 8; // 等号右边全都是常量,没有任何变量参与运算编译之后,得到的.class字节码文件当中相当于【直接就是】:short result = 13;右侧的常量结果数值,没有超过左侧范围,所以正确。这称为“编译器的常量优化”但是注意:一旦表达式当中有变量参与,那么就不能进行这种优化了。
代码演示
public class Demo13Notice { public static void main(String[] args) { short num1 = 10; // 正确写法,右侧没有超过左侧的范围, short a = 5; short b = 8; // short + short --> int + int --> int // short result = a + b; // 错误写法!左侧需要是int类型 // 右侧不用变量,而是采用常量,而且只有两个常量,没有别人 short result = 5 + 8; System.out.println(result); // short result2 = 5 + a + 8; 错误 不能进行常量优化 } }
。