⭐️JavaSE系列⭐️Java程序设计基础——数据类型变量与运算符

⭐️前面的话⭐️

大家好！这是一个新的系列专栏，本专栏会介绍JavaSE及其应用，Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。本篇文章带大家认识Java最基本的数据类型与运算符，能够熟练地应用数据类型和运算符解决各类问题。

博客主页：未见花闻的博客主页
欢迎关注点赞收藏⭐️留言
本文由未见花闻原创，CSDN首发！
首发时间：2021年10月13日
✉️坚持和努力一定能换来诗与远方！
参考书籍：《Java核心技术卷1》，《Java核心技术卷2》，《Java编程思想》
参考在线编程网站：牛客网力扣
作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！
博主的码云gitee，平常博主写的程序代码都在里面。

---

---

---

1.Java程序输出（打印）

在Java语言当中给出了三种输出方式，一是打印换行，二是打印不换行，三是格式化输出（与C语言一样）。

1.1换行与不换行输出

光说不做假把戏，直接上代码！我们从输出结果上来分析是换行输出还是不换行输出。

public class print {
     
    public static void main(String[] args) {
     
        System.out.println("我能够换行输出数据！");//换行输出
        System.out.print("我只在一行上输出数据！");//不换行输出
        System.out.print("看到没！我真的不会换行！");
    }
}

运行结果：

我能够换行输出数据！
我只在一行上输出数据！看到没！我真的不会换行！
进程已结束，退出代码为 0

由运行结果可知，在Java当中换行输出方法为println，不换行输出为print。

System.out.println("数据");//换行
System.out.print("数据");//不换行

1.2格式化输出

Java当中格式化输出使用的方法和C语言一样！相信大家printf已经用的比较熟悉了！

public class print {
     
    public static void main(String[] args) {
     
        int a = 12;
        double b = 3.14;
        System.out.printf("a = %d, b = %.2lf", a, b);
    }
}

运行结果：

a = 12, b = 3.14
进程已结束，退出代码为 0

Java中格式化输出相关标志与转换符：

转换符	类型	举例
d	十进制整数	2569
x	十六进制整数	2a
o	八进制整数	233
f	定点浮点数（%.精确小数点后几位f）	3.14
e	指数浮点数	3.14e+00
g	通用浮点数（%.有效数字g）	3.14
a	十六进制浮点数	0x1.1eb851eb851ecp-3（十进制浮点数为3.14）
s	字符串	weijianhuawen
c	字符	A
b	布尔	true/false
h	散列码	42628b2
%	百分号	%
n	与平台相关分隔符号	——

表1 Java中用于printf转换符

标志	目的
+	打印正数和负数的符号
空格	在正数之前添加空格
0	数字前面补 0
-	左对齐
(	将数括在括号内
,	添加分组分隔符
#（对x或O格式）	添加前缀 0x 或 0
$	给定被格式化的参数索引。例如， %2$d，%2$x 将以十进制和十六进制格式打印第 2个参数
<	格式化前面说明的数值。 例如，%d%

表2 Java中用于printf标志符

2.注释与关键字

2.1注释

Java中注释方式包括三种：

1. 行注释 ：// 注释内容（用的最多）
2. 块注释：/* 注释内容*/（不推荐）
3. 文档注释：/** 注释内容 */（常见于方法和类之上描述方法和类的作用)，可用来自动生成文档

//我是行注释！

/*
	我是块注释！
*/

/**
	我是文档注释！
*/

注释规范：

1. 内容准确: 注释内容要和代码一致, 匹配, 并在代码修改时及时更新.
2. 篇幅合理: 注释既不应该太精简, 也不应该长篇大论.
3. 使用中文: 一般中国公司都要求使用中文写注释, 外企另当别论.
4. 积极向上: 注释中不要包含负能量(例如 领导 SB 等).

2.2关键字

关键字	含义
abstract	表明类或者成员方法具有抽象属性
assert	用来进行程序调试
boolean	基本数据类型之一，布尔类型
break	提前跳出一个块
byte	基本数据类型之一，字节类型
case	用在switch语句之中，表示其中的一个分支
catch	用在异常处理中，用来捕捉异常
char	基本数据类型之一，字符类型
class	类
const	保留关键字，没有具体含义
continue	回到一个块的开始处
default	默认，例如，用在switch语句中，表明一个默认的分支
do	用在do-while循环结构中
double	基本数据类型之一，双精度浮点数类型
else	用在条件语句中，表明当条件不成立时的分支
enum	枚举
extends	表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float	基本数据类型之一，单精度浮点数类型
for	一种循环结构的引导词
goto	保留关键字，没有具体含义
if	条件语句的引导词
implements	表明一个类实现了给定的接口
import	表明要访问指定的类或包
instanceof	用来测试一个对象是否是指定类型的实例对象
int	基本数据类型之一，整数类型
interface	接口
long	基本数据类型之一，长整数类型
native	用来声明一个方法是由与计算机相关的语言(如C/C++/FORTRAN语言)实现的
new	用来创建新实例对象
package	包
private	一种访问控制方式:私用模式
protected	一种访问控制方式:保护模式
public	一种访问控制方式:共用模式
return	从成员方法中返回数据
short	基本数据类型之一,短整数类型
static	表明具有静态属性
strictfp	用来声明FP_strict(单精度或双精度浮点数)表达式遵循IEEE 754算术规范
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
while	用在循环结构中

3.数据类型与变量

Java是一种强类型语言。这就意味着必须为每一个变量声明一种类型。在 Java中，一共有8 种基本类型（primitive type），其中有4种整型、2种浮点类型、1种用于表示Unicode编码的字符单元的字符类型char和1种用于表示真值的 boolean类型。
Java 有一个能够表示任意精度的算术包，通常称为"大数值"（big number）。虽然被称为大数值，但它并不是一种新的 Java 类型，而是一个Java对象。后续博客将会介绍！

在C和C++中，int和long等类型的大小与目标平台相关。在8086这样的16位处理器上整型数值占2字节;不过，在32位处理器（比如Pentium或 SPARC）上，整型数值则为 4 字节。类似地，在 32位处理器上long 值为 4 字节，在64位处理器上则为8字节。由于存在这些差别，这对编写跨平台程序带来了很大难度。在 Java中，所有的数值类型所占据的字节数量与平台无关。
注意，Java 没有任何无符号（unsigned）形式的 int、long、short或 byte 类型。

3.1整型

类型	储存需求	范围
int	4字节	-2147483648 ~ 2147483647（刚好超过20亿）
long	8字节	-9 223 372 036 854 775 808 ~ 9 223 372 036 854 775 807
short	2字节	-32768 ~ 32767
byte	1字节	-128 ~ 127

3.1.1整型

int 变量名 = 整型常量;
public class testData {
     
    public static void main(String[] args) {
     
        int a = 10;
        System.out.println(a);
        //访问最大值与最小值
        System.out.println(Integer.MAX_VALUE);//max
        System.out.println(Integer.MIN_VALUE);//min
    }
}

其中Integer为整型的包装类，其实每个基本数据类型都有一个对应的包装类，可以理解为对应类型的加强版。MAX_VALUE MIN_VALUE分别为最大值与最小值。
运行结果:

10
2147483647
-2147483648

Process finished with exit code 0

3.1.2短整型

short 变量名 = 短整型常量;
public class testData {
     
    public static void main(String[] args) {
     
        short b = 8;
        System.out.println(b);
        //访问最大值与最小值
        System.out.println(Short.MAX_VALUE);//max
        System.out.println(Short.MIN_VALUE);//min
    }
}

运行结果：

8
32767
-32768

Process finished with exit code 0

3.1.3长整型

long 变量名 = 长整型常量;
public class testData {
     
    public static void main(String[] args) {
     
        long c = 345L;//or 345l(不推荐，容易与1混)
        System.out.println(c);
        System.out.println(Long.MAX_VALUE);//max
        System.out.println(Long.MIN_VALUE);//min
    }
}

运行结果：

345
9223372036854775807
-9223372036854775808

Process finished with exit code 0

3.1.4字节类型

byte 变量名 = 字节型常量;
public class testData {
     
    public static void main(String[] args) {
     
        byte d = 32;
        System.out.println(d);
        System.out.println(Byte.MAX_VALUE);//MAX
        System.out.println(Byte.MIN_VALUE);//MIN
    }
}

运行结果：

32
127
-128

Process finished with exit code 0

3.2浮点型

类型	存储需求	取值范围
float	4 字节	大约 ± 3.402 823 47E+38F (有效位数为 6 ~ 7 位）
double	8 宇节	大约 ± 1.797 693 134 862 315 70E+308 (有效位数为 15 位）

float 类型的数值有一个后缀 F 或 f (例如，3.14F。) 没有后缀 F 的浮点数值（如 3.14 ) 默认为 double 类型。当然，也可以在浮点数值后面添加后缀 D 或 d (例如，3.14D)。
所有的浮点数值计算都遵循 IEEE 754 规范。具体来说，下面是用于表示溢出和出错情况的三个特殊的浮点数值：

1. 正无穷大
2. 负无穷大
3. NaN (不是一个数字）

例如， 一 正整数除以 0 的结果为正无穷大。计算 0/0 或者负数的平方根结果为 NaN。

3.2.1双精度浮点型

double 变量名 = 双精度浮点数常量;
public class testData {
     
    public static void main(String[] args) {
     
        double e = 3.14;
        System.out.println(e);
        System.out.println(Double.MAX_VALUE);//MAX
        System.out.println(Double.MIN_VALUE);//MIN
    }
}

运行结果：

3.14
1.7976931348623157E308
4.9E-324

Process finished with exit code 0

3.2.2单精度浮点型

float 变量名 = 单精度浮点数常量;
public class testData {
     
    public static void main(String[] args) {
     
        float f = 3.14F;//or 3.14f F or f 不能省，否则会编译错误
        System.out.println(f);
        System.out.println(Float.MAX_VALUE);//MAX
        System.out.println(Float.MIN_VALUE);//MIN
    }
}

运行结果：

3.14
3.4028235E38
1.4E-45

Process finished with exit code 0

3.3字符型

char 变量名 = 字符;
public class testDemo {
     
    public static void main(String[] args) {
     
        char c = 'A';
        char d = '花';
        System.out.println(c);
        System.out.println(d);
    }
}

运行结果：

A
花

Process finished with exit code 0

注意事项:

1. Java 中使用 单引号 + 单个字母 的形式表示字符字面值.
2. 计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文.

3.4布尔型

boolean 变量名 = falae/true;

boolean (布尔）类型有两个值：false 和true, 用来判定逻辑条件，整型和浮点型值和布尔值之间不能进行相互转换。
在 C++ 中， 数值甚至指针可以代替 boolean 值。值 0 相当于布尔值 false, 非 0 值相当于布尔值 true, 在 Java 中则不是这样。

3.5字符串型

在Java中字符串型并不是八大基本数据之一，它是Java当中的引用类型，后续博客会介绍，这里只需要了解字符串的简单使用即可。Java 没有内置的字符串类型， 而是在标准 Java 类库中提供了一个预定义类，很自然地叫做 String。

String 变量名 = "string";
public class testDemo {
     
    public static void main(String[] args) {
     
        String st = "weijianhuawen";
        String str = "This is a string!";
        System.out.println(st);
        System.out.println(str);
    }
}

运行结果：

weijianhuawen
This is a string!

Process finished with exit code 0

另外Java支持使用+号来进行字符串的拼接。

public class testDemo {
     
    public static void main(String[] args) {
     
        String str1 = "welcome";
        String str2 = "to";
        String str3 = "my";
        String str4 = "blog!";
        String str5 = str1 + str2 +str3 +str4;
        System.out.println(str5);
        String str6 = "value = " + 10 + 20;//数据与字符串拼接，最终会成为一个字符串！
        System.out.println(str6);
        String str7 = 10 + 20 + " is a value!";//这个有一点特殊，因为10与20都是整型且在字符串前，所以会先执行加法运算再和字符串拼接，当然最终会还是成为一个字符串！
        System.out.println(str7);
    }
}

运行结果：

welcometomyblog!
value = 1020
30 is a value!

Process finished with exit code 0

转义字符	解释
\n	换行
\b	退格
\r	回车
\t	水平制表符
\’	单引号
\"	双引号
\\	反斜杠

3.6变量与常量

3.6.1变量的声明

这个很简单，在前面的定义一系列的数据类型变量，即局部变量的声明。

int a = 12;
double d = 3.12;
float f = 3.14f;

3.6.2局部变量的作用域

局部变量的作用域为其变量定义距离最近的一对花括号中。

public class testDemo {
     
    public static void main(String[] args) {
     
        int b = 24;
        {
     
            int a = 48;
            System.out.println(a);//编译通过
            System.out.println(b);//编译通过
        }
        System.out.println(a);//编译出错
        System.out.println(b);//编译通过
    }
}

3.6.3变量的命名规则

硬性指标:

1. 一个变量名只能包含数字, 字母, 下划线
2. 数字不能开头.
3. 变量名是大小写敏感的. 即 num 和 Num 是两个不同的变量.

注意: 虽然语法上也允许使用中文/美元符($)命名变量, 但是 强烈 不推荐这样做.

软性指标:

1. 变量命名要具有描述性, 见名知意.
2. 变量名不宜使用拼音(但是不绝对).
3. 变量名的词性推荐使用名词.
4. 变量命名推荐 小驼峰命名法, 当一个变量名由多个单词构成的时候, 除了第一个单词之外, 其他单词首字母都大写.

int maxValue = 100;
int minValue = 0;//小驼峰

3.6.4常量

常量一类就是我们常见的数值，字符，字符串等，比如3.14 "string" A…
除此之外，Java中可以使用final来定义常量。

final int a = 10; 
a = 20; // 编译出错. 提示 无法为最终变量a分配值

关键字 final 表示这个变量只能被赋值一次。一旦被赋值之后，就不能够再更改了。习惯上,常量名使用全大写。
const 是 Java 保留的关键字，但目前并没有使用。在 Java 中， 必须使用 final定义常量。

3.7类型转换与数值提升

3.7.1类型转换

Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验.

int a = 10; 
long b = 20; 
a = b; // 编译出错, 提示可能会损失精度. 
b = a; // 编译通过. 
int a = 10; 
double b = 1.0; 
a = b; // 编译出错, 提示可能会损失精度. 
b = a; // 编译通过.

long 表示的范围更大, 可以将 int 赋值给 long, 但是不能将 long 赋值给 int.
double 表示的范围更大, 可以将 int 赋值给 double, 但是不能将 double 赋值给 int.
结论: 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型, 反之则不行.

int a = 10; 
boolean b = true; 
b = a; // 编译出错, 提示不兼容的类型
a = b; // 编译出错, 提示不兼容的类型

结论: int 和 boolean 是毫不相干的两种类型, 不能相互赋值.不仅仅是 int 类型，所有的数值型的变量都不能与布尔类型相互赋值

byte a = 100; // 编译通过
byte b = 256; // 编译报错, 提示 从int转换到byte可能会有损失

注意: byte 表示的数据范围是 -128 -> +127, 256 已经超过范围, 而 100 还在范围之内.
结论: 使用字面值常量赋值的时候, Java 会自动进行一些检查校验, 判定赋值是否合理，比如 byte 与 short.

int a = 0; 
double b = 10.5; 
a = (int)b; //编译通过
int a = 10; 
boolean b = false; 
b = (boolean)a; // 编译出错, 提示不兼容的类型.

结论: 使用 (类型) 的方式可以将 double 类型强制转成 int.
但是注意：

1. 强制类型转换可能会导致精度丢失. 如刚才的例子中, 赋值之后, 10.5 就变成 10 了, 小数点后面的部分被忽略.
2. 强制类型转换不是一定能成功, 互不相干的类型之间无法强转.

类型转换小结

1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型.
2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失.
3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查.

3.7.2运算过程中的数值提升

int 和 long 混合运算

int a = 10; 
long b = 20; 
int c = a + b; // 编译出错, 提示将 long 转成 int 会丢失精度
long d = a + b; // 编译通过.

结论: 当 int 和 long 混合运算的时候, int 会提升成 long, 得到的结果仍然是 long 类型, 需要使用 long 类型的变量来接收结果. 如果非要用 int 来接收结果, 就需要使用强制类型转换.
byte 和 byte 的运算

byte a = 10; 
byte b = 20; 
byte c = a + b; 
System.out.println(c); 
// 编译报错
Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失

结论: byte 和 byte 都是相同类型, 但是出现编译报错. 原因是：虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a 和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这时再赋给 c, 就会出现编译错误.

由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short 这种低于4 个字节的类型, 会先提升成 int, 再参与计算.

正确写法：

byte a = 10; 
byte b = 20; 
byte c = (byte)(a + b); 
System.out.println(c);

类型提升小结:

1. 不同类型的数据混合运算, 范围小的会提升成范围大的.
2. 对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算.

3.7.3整型与字符串型的转换

int 转成 String

int num = 10; 
// 方法1 
String str1 = num + ""; 
// 方法2 
String str2 = String.valueOf(num);

String 转成 int

String str = "100"; 
int num = Integer.parseInt(str);

4.运算符

4.1赋值运算符

赋值运算符=。

int a = 12;
double d = 4.99;
a = a + 1;

4.2算术运算符

算术运算符：加+减 - 乘* 除/ 取模%

int a = 10;
a = a + 2;
a = a - 2;
a = a * a;
a = a / a;
a = a % 2;

注意：

1. int / int 结果还是 int, 需要使用 double 来计算。
2. 0 不能作为除数，编译器会报错。
3. % 表示取余, Java中，不仅仅可以对 int 求模, 也能对 double 来求模。

4.3关系运算符

关系运算符：判断相等== 判断不相等!= 判断大小< > <= >=。

public class testDemo {
     
    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);
        System.out.println(a <= b);
        System.out.println(a >= b);
    }
}

注意: 关系运算符的表达式返回值都是 boolean 类型.

运行结果：

false
true
true
false
true
false

Process finished with exit code 0

4.4逻辑运算符

逻辑运算符：或|| | 与 && & 非!
当|与&表示逻辑运算符时，其中||，&&与|，&的区别是前者有短路现象，后者没有短路现象，后者不推荐使用，基本上Java程序也不会使用| 与 &做逻辑判断。
注意: 逻辑运算符的操作数(操作数往往是关系运算符的结果)和返回值都是 boolean。

逻辑与 &&
规则: 两个操作数都为 true, 结果为 true, 否则结果为 false.
逻辑或 ||
规则: 两个操作数都为 false, 结果为 false, 否则结果为 true.
逻辑非 !
规则: 操作数为 true, 结果为 false; 操作数为 false, 结果为 true(这是个单目运算符, 只有一个操作数).

短路求值
&& 和 || 遵守短路求值的规则。

System.out.println(10 > 20 && 10 / 0 == 0); // 发生短路，不执行后者语句，程序不报错，打印 false 
System.out.println(10 < 20 || 10 / 0 == 0); // 发生短路，不执行后者语句，程序不报错，打印 true

我们都知道, 计算 10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行, 说明 10 / 0 并没有真正被求值.
结论:

1. 对于 && , 如果左侧表达式值为 false, 则表达式的整体的值一定是 false, 无需计算右侧表达式.
2. 对于 ||, 如果左侧表达式值为 true, 则表达式的整体的值一定是 true, 无需计算右侧表达式

& 和 | (不推荐使用)
& 和 | 如果操作数为 boolean 的时候, 也表示逻辑运算. 但是和 && 以及 || 相比, 它们不支持短路求值.

System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常

4.5位运算符

位运算符：按位与& 按位或| 按位取反~ 按位异或^
移位运算符：左移<< 右移>> 无符号右移>>>

按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.
按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.
注意: 当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表示逻辑运算.
按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0.
按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.（找不同）

左移 <<: 最左侧位丢弃, 最右侧补 0.
右移 >>: 最右侧位丢弃, 最左侧补符号位(正数补0, 负数补1).
无符号右移 >>>: 最右侧位不要了, 最左侧补 0.
注意：

1. 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
2. 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
3. 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
4. 移动负数位或者移位位数过大都没有意义.

4.6条件运算符

条件运算符只有一个:
表达式1 ? 表达式2 : 表达式3
当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值; 当 表达式1 的值为false 时, 整个表达式的值为 表达式3 的值.
也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法.

// 求两个整数的最大值
int a = 10; 
int b = 20; 
int max = a > b ? a : b;

4.7其他运算符

复合赋值运算符 += -= *= /= %= <<= >>=等。

int a = 10; 
a += 1; // 等价于 a = a + 1 
System.out.println(a);

自增/自减运算符 ++ --
++a表示先++，再使用。
a++表示先使用，在++。
--与++用法相同。

int a = 10; 
int b = ++a; 
System.out.println(b); 
int c = a++; 
System.out.println(c);

结论:

1. 如果不取自增运算的表达式的返回值, 则前置自增和后置自增没有区别.
2. 如果取表达式的返回值, 则前置自增的返回值是自增之后的值, 后置自增的返回值是自增之前的值.

4.8运算符优先级

优先级	运算符	结合性
1	() [] .	从左到右
2	! +(正) -(负) ~ ++ –	从右向左
3	* / %	从左向右
4	+(加) -(减)	从左向右
5	<< >> >>>（移位运算符）	从左向右
6	< <= > >=（比较大小关系运算符） instanceof	从左向右
7	== !=（判断相等关系运算符）	从左向右
8	&(按位与)	从左向右
9	^	从左向右
10	|（按位或）	从左向右
11	&&	从左向右
12	||	从左向右
13	表达式1?表达式2:表达式3（三目运算符）	从右向左
14	= += -= *= /= %= &= |= ^= ~= <<= >>= >>>=（等于与复合运算符）	从右向左

觉得文章写得不错的老铁们，点赞评论关注走一波！谢谢啦！