Java数据类型、数据类型转换、运算符及优先级详解

文章讲解了Java的数据类型、数据类型转换、算术运算符、自增自减运算符、关系运算符、逻辑运算符、三元运算符。

一、数据类型

数据类型 变量名称 = 初始值;

基本数据类型

四类八种

1byte = 8bit 一个字节等于八个比特位

2^8=128

	数据类型	内存占用（字节）	数据范围
整型	byte	1	-128 ~ 127
整型	short	2	-32768 ~ 32767
整型	int (默认)	4	-2147483648 ~ 2147483647 (约21亿)
整型	long	8	-9223372036854775808 ~ 9223372036854775807
浮点型	float	4	1.401298E-45 ~ 3.4028235E+38
浮点型	double (默认)	8	4.9000000E-324 ~ 1.797693E+38（更高精度）
字符型	char	2	0 ~ 65535
布尔型	boolean	1	true / false

整型

Java中默认的整数的字面量，默认类型是int（+-21亿）

如果

long number4 = 700000000;
//会报错
//Java中默认的整数的字面量，默认类型是int（+-21亿）

---

[细节]创建module后记得要在project structure中导入module

导入后还记得，标记src为源代码。

上方文件栏中的图标才会变为正常的C图标。

---

可以看到这里报错了。

long number4 = 700000000;
long number4 = 700000000L;.//不报错

尽量用大写L好区分1。

---

浮点型同理

默认为double类型

float后方加L/l需要加。

• double数据的D/d相加就加（默认就是double）

练习代码：

​
public class Demo1 {public static void main(String[] args) {//1.整数byte number = 60;System.out.println(number);short number2 = 6000;int number3 = 100000000;
​//默认写一个整数的字面量，默认类型是int(+-21亿)，这里明显超过了int 的范围//        long number4 = 7000000000000000;//报错//某个数当做long类型，数据后加L或/llong number4 = 7000000000000000L;long number5 = 7000000000000000l;
​
​//2.浮点型//某个小数当做float类型，数据后加F或/ffloat score1 = 99.5F;
//        float score2 = 99.5;//报错//double后的数据相加就加double score2 = 99.5D;
​System.out.println("123s");
​}
}

引用数据类型

• 后期讲

回顾

Java的数据类型分为什么？

基本数据类型和引用数据类型，基本数据类型有四类八种，引用数据类型...。

随便写的整型或者浮点型，默认是什么类型？

整型：int 如果是long长整型，那么需要加L或/l

浮点型：double 如果为float浮点型，那么需要加F/f。

double的D/d相加就加。

二、数据类型转换

1.自动类型转换

类型范围小的变量，可以直接赋值给类型范围大的变量。

[重点]自动类型转换在计算机中的原理：

自动类型转换的时候，会赋值到数据范围大的数据的末尾，其他位用符号位补齐，符号位是0，代表正数。

转换方向：

byte——>short——>int——>long——>float——>double

char——>int

代码举例：

package com.itheima.type;
​
public class Demo1 {public static void main(String[] args) {byte a = 12;int b = a;//自动类型转换System.out.println(a);//12System.out.println(b);//12
​char ch = 'a';//97 那么二进制存储在计算机中为 00000000 01100001//char为2字节16位int i  =ch;//自动类型转换 转换后 为：00000000 00000000 00000000 01100001//int为32位System.out.println(i);}
}
​

这里字符a，在计算机中是ASCII码表示，为97，97转换为二进制为01100001。

那么char为2字节，8位，存储在计算机中为00000000 01100001

那么赋值给int类型， 进行自动类型转换，00000000 00000000 00000000 01100001，前24位自动补0。

回顾

什么是自动类型转换？为什么要进行自动类型转换？

类型范围小的变量，可以直接赋值给类型范围大的变量。

存在不同类型的变量要赋值给其他类型的变量

2.[重点]表达式的自动类型转换

表达式中，小范围类型的变量，会自动转换成表达式中较大范围的类型，再参与运算。

注意：

表达式的最终结果类型由表达式中的最高类型决定。

[重]表达式中，byte、short、char是直接转换成int类型参与运算的。

举例：

[1.易错]经典题目：

byte i = 10;
short j = 30;
short res2 = i+j;//报错
//int res2 = i+j;//正确

[2易错]经典题目：

byte b1 = 10;
byte b2 = 7;
byte b3 = b1+b2;//报错
//int b3 = b1+b2;//正确

其实从题目2中，我们能看出byte、short、char在表达式中自动转化为int的初衷：因为byte的大小为一字节，2^4=16，如果不进行转换，那么就超过byte的大小了。short、char也是同理。

代码：

package com.itheima.type;
​
public class Demo2 {public static void main(String[] args) {//2.表达式的自动类型转换int a = 12;float b = 12.1F;
​char c = 'A';float res = a+b+c;System.out.println(res);//表达式中的自动类型转化
​//byte、short、char会自动转化为int类型byte a1 = 1;short a2 = 2;char a3 = 'A';int res_1 = a1+a2+a3;//byte、short、char会自动转化为int类型System.out.println(res_1);}
}
​

回顾：

1.什么是表达式的自动类型转换？

在表达式的运算中，小范围的类型会自动转化为大范围的类型进行运算。

2.表达式的最终结果是由谁决定的？

最终类型的结果，由表达式中的最高类型决定。

[重点]3.表达式中有哪些类型转化是需要注意的？

byte、short、char类型在运算的过程中，是直接转化成int类型参与运算的。

---

3.强制类型转换

大范围——>小范围类型的变量

因为类型范围大的数据或者变量，直接赋值给类型范围小的变量，会报错

强行将类型范围大的变量的数据，赋值给类型范围小的变量。

• 提示快捷键：Alt+Enter

[重点]强制类型转换在计算机中的执行原理

可以看到，我们int类型转换为byte类型，在2^8=128的二进制数范围内，不会造成数据（丢失）溢出。

但是当我们强制类型转换的时候，大范围的数据类型的数据，大于小范围数据类型的表示范围的时候，会造成精度损失（数据丢失/溢出）。

• 举例：

  

  我们可以看到，最终的结果是-36负数

  int i = 1500;//     00000000 00000000 00000101 11011100
  byte j = (byte) i;//                        11011100
  System.out.println(j);

截断为byte后，保留最低8位11011100

符号位判断：11011100，最高位是1，那么是负数。

补码转十进制 取反+1 得到-36原码。

• 负数在计算机中存储是补码存储的。

• 补码—取反+1—>原码

注意：

强制类型转换可能造成数据（丢失）溢出；

浮点型转成整型，直接丢掉小数部分，保留整数部分返回。

回顾：

1.什么是强制类型转换？

默认情况下，大范围的数据类型转换为小范围的数据类型，转换会报错。

强制类型转化就是大范围的数据类型转换为小范围数据类型的过程。

• 数据类型 变量 = (要转换的数据类型)变量、数据;

2.强制类型转换有哪些需要注意的？

要注意变量或数据的范围，如果该变量或数据的范围在目标数据类型范围之内，如果不在则会造成数据（丢失）溢出。在的话就不会造成数据（丢失）溢出。

可以举个例子。

所以适用范围：一般我们很了解数据范围的时候，转化不会造成数据（丢失）溢出，我们去用强制类型转换。

三、算术运算符

注意Java中两个整数相除结果是整数。

符号	作用	说明
+	加	加法运算，与小学数学中的加法规则一致
-	减	减法运算，与小学数学中的减法规则一致
*	乘	乘法运算，与数学中的 × 符号作用相同
/	除	除法运算，与数学中的 ÷ 符号作用相同 注意：在Java中，两个整数相除结果仍是整数（直接舍去小数部分）
%	取余	取模运算，获取两个数据相除后的余数

[重点]常见的处理方式

public class Demo4 {public static void main(String[] args) {int a = 10;int b = 20;System.out.println(a+b);System.out.println(a-b);System.out.println(a*b);System.out.println(a/b);//0System.out.println(a%b);//10    取余
​//常见的处理方式int i = 5;int j = 2;System.out.println(1.0*i/j);//得到2.5，因为表达式自动类型转换，结果自动转换为大精度的类型。}
}

代码中，我们可以看到，如果要求传入的数据是int类型， 结果是double类型。那么我们常用，在输出的结果中*1.0，使用表达式自动类型转换，让结果转换为double类型。

1."+"符号可以做连接符

[重点]注意+与字符类型在一起是可以运算的

public class Demo2 {public static void main(String[] args) {int a2 = 5;System.out.println("abc"+5);System.out.println(123+a2);System.out.println(a2+123);
​System.out.println("qwe"+a2+'a');System.out.println('a'+a2+"qwe");//102qwe，注意字符能用ASCII码进行运算,然后再拼接System.out.println(a2+'a'+"qwe");//同上
​}
}
​

秘诀：能算就算，不能算就连接。

回顾

1.运算符有哪些？

2./的时候需要注意什么？为什么

整数相除，结果是整数。当两个操作数都是整数的时候，因为Java在/运算的时候，/运算会直接截断小数部分。

注意1/5的结果为0。（截断了小数部分）

常用的处理方式*1.0。

案例：位拆分

public class Case1 {public static void main(String[] args) {//需求，一个三位数，拆分个位、十位、百位。并输出。int a = 789;int ge = 789%10;int shi = 789/10%10;int bai = 789/100%10;System.out.println(ge);System.out.println(shi);System.out.println(bai);
​}
}

---

四、自增自减运算符

自增自减运算符只能用于变量，不能用于字面量。

单独使用或在表达式中

import org.w3c.dom.ls.LSOutput;
​
public class Demo3 {public static void main(String[] args) {//自增自减运算符
​//单独使用，放前放后是没有区别int a = 10;a++;System.out.println(a);int b = 20;++b;System.out.println(b);
​//表达式中使用，放前放后有区别了int a1 = 10;int res = a1++;
​System.out.println(a1);//11System.out.println(res);//10System.out.println("------");
​int res1 = ++a1;System.out.println(a1);//12System.out.println(res1);//12}
}

++a：先进行a+1再赋值给结果；

a++：先进行赋值给结果再进行a+1；

[重点]案例：自增自减综合案例

package com.itheima.operator;
​
public class Case2 {public static void main(String[] args) {
//        自增自减的综合案例int c = 10;int d = 5;int rs3 = c++ + ++c - --d - ++d + 1 + c--;System.out.println(rs3);System.out.println(c);//11System.out.println(d);//5
​//c 初始10 10 11 12 11//d 初始5 4 5//res3 10+12-4-5+1+12
//        最终结果是c是11，d是5，res3结果是26
//        理解是先拿去用再自增，还是，先去自增再拿去用。}
}
​

五、基本赋值运算符

=，从右边往左边看。

六、扩展赋值运算符

符号	用法	作用	底层代码形式
+=	a += b	加后赋值	a = (a的类型)(a + b);
-=	a -= b	减后赋值	a = (a的类型)(a - b);
*=	a *= b	乘后赋值	a = (a的类型)(a * b);
/=	a /= b	除后赋值	a = (a的类型)(a / b);
%=	a %= b	取余后赋值	a = (a的类型)(a % b);

[重点]注意：扩展的赋值运算符包含了强制类型转换。

[重点]经典案例-扩展赋值运算符

byte x =10;
byte y =30;
//x = x+y;//会报错，因为表达式中，byte会自动转化为int类型，最后又赋值给了byte类型的x，会导致数据范围大的数据类型，赋值给小的。导致报错。
//而
x += y;//等价于x=(byte)(x+y);不会报错！！！因为内含强制类型转换。最终x 的类型还是byte。

回顾：

1.赋值运算符有哪些？

基本赋值运算符和扩展赋值运算符。

基本赋值运算符：=

扩展赋值运算符：+=、-=、*=、/=、%=

2.扩展赋值运算符的作用是什么？有什么特点

例如：+=扩展赋值运算符，可以做累加。

特点：在底层代码实现形式是，a = (a的类型)(a+b)。带有强制类型转化。注意区分。

---

七、关系运算符

符号	例子	作用	结果
>	a > b	判断 a 是否 大于 b	成立返回 true，否则 false
>=	a >= b	判断 a 是否 大于或等于 b	成立返回 true，否则 false
<	a < b	判断 a 是否 小于 b	成立返回 true，否则 false
<=	a <= b	判断 a 是否 小于或等于 b	成立返回 true，否则 false
==	a == b	判断 a 是否 等于 b	成立返回 true，否则 false
!=	a != b	判断 a 是否 不等于 b	成立返回 true，否则 false

• 布尔类型返回值：所有比较运算符的返回值都是 布尔类型（boolean），即 true 或 false。这些返回值可以用于条件语句（如 if、while）中，以决定程序的执行流程。

[重点]== 和!=不仅适用于基本数据类型，还适用于对象引用的比较。

对象比较：对于对象类型的比较，== 和!=运算符比较的是 对象的引用。

• 而对于对象内容要使用对象的 equals() 方法。

---

八、[重点]逻辑运算符

• 把多个条件放在一起运算，最终返回布尔类型的值：true、flase

符号	叫法	例子	运算逻辑
&&	逻辑与	3 > 2 && 1 < 5	多个条件必须都是 true，结果才是 true；只要有一个是 false，结果就是 false
||	逻辑或	2 > 1 || 3 < 1	多个条件中只要有一个是 true，结果就是 true；所有条件都是 false，结果才是 false
!	逻辑非	!(2 > 1)	取反操作：如果原条件为 true，则结果为 false；如果原条件为 false，则结果为 true
^	逻辑异或	(2 > 1) ^ (3 > 1)	当两个条件的结果不同时，返回 true；当两个条件的结果相同时，返回 false

异或：两个结果相同，false；两个结果不同，true。

public class Demo6 {public static void main(String[] args) {
//        逻辑运算符的使用//需求：手机屏幕的大于6.98且内存要大于等于8double size = 6.8;int storage = 16;boolean res = size >6.95 & storage>=8;System.out.println(res);
​//需求：手机要么手机屏幕大于6.98，要么内存大于等于8double size1 = 6.8;int storage1 = 16;boolean res1 = size1 >6.95 | storage1>=8;System.out.println(res1);
​System.out.println("---");//!取反System.out.println(!false);System.out.println(!true);System.out.println(!(2>1));
​System.out.println("---");//异或System.out.println(true ^ true);//falseSystem.out.println(false ^ false);//trueSystem.out.println(false ^ true);//true
​}
}
​

[重点]短路与、短路或

符号	叫法	例子	运算逻辑
&&	短路与	2 > 1 && 3 > 2	判断结果与逻辑与（&）相同，但过程不同： - 如果左边表达式为 false，右边表达式不执行，直接返回 false。 - 如果左边表达式为 true，则执行右边表达式。 - 只有当两边表达式都为 true 时，结果才为 true。
||	短路或	2 > 1 || 3 < 5	判断结果与逻辑或（|）相同，但过程不同： - 如果左边表达式为 true，右边表达式不执行，直接返回 true。 - 如果左边表达式为 false，则执行右边表达式。 - 只要有一个表达式为 true，结果就为 true。

&&：左边为false，右边就不执行了。

||：左边为true，右边就不执行了。

逻辑运算符的优先级：

1. 逻辑非（!）

2. 逻辑与（&）

3. 逻辑或（|）

4. 短路与（&&）

5. 短路或（||）

九、三元运算符

条件表达式 ? 值1 : 值2;

条件表达式的类型是boolean

执行流程：首先计算关系表达式的值，如果为true则返回值1，如果为false则返回值2。

[重点]找两个、三个值中的较大值

package com.itheima.operator;
​
public class Demo7 {public static void main(String[] args) {//掌握三元运算符格式和执行流程double score = 87.5;String res = score >= 60 ? "成绩合格" : "成绩不合格";System.out.println(res);
​
//【常见需求】：找出两个整数中的较大值int a = 99;int b = 66;int c = a > b ? a : b;//找出两个值中的较大值System.out.println(c);
​
//【常见需求】找出三个整数中的较大值int x = 100;int y = 88;int z = 500;//建立一个tempint temp = x>y ? x : y;int max = temp > z ? z : temp;System.out.println(max);
​}
}

补充：运算符优先级

public class Demo8 {public static void main(String[] args) {//优先级System.out.println(10>3 || 10>3 && 10<3);//这里记一下逻辑运算符的优先级，||的优先级最低System.out.println((10>3 || 10<3) && 10<3);//记住，以后写代码使用小括号就可以了。}
}

只需要记优先级最高的是小括号，就可以了。