本文详细介绍了Java语言中的关键字、保留字的定义和特点，以及标识符的命名规则和命名规范。同时，讲解了变量的定义、使用、数据类型，包括基本数据类型如整型、浮点型、字符型和布尔型的特性，以及变量间的转换规则。此外，还探讨了字符串类型、进制转换和各种运算符的用法，包括算术运算符、赋值运算符、比较运算符、逻辑运算符和位运算符。文章最后通过示例代码展示了各种运算符的实际运用。
1. 关键字与保留字
1.1 关键字(keyword)
- 定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）。
- 特点：关键字所有字母都是小写。
- 官方地址：https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
| 用于定义数据类型的关键字 | ||||
|---|---|---|---|---|
| class | interface | enum | byte | short |
| int | long | float | double | char |
| boolean | void | |||
| 用于定义流程控制的关键字 | ||||
| if | else | switch | case | default |
| while | do | for | break | continue |
| return | ||||
| 用于定义访问权限修饰符的关键字 | ||||
| private | protected | public | ||
| 用于定义类，函数，变量修饰符的关键字 | ||||
| abstract | final | static | synchronized | |
| 用于定义类与类之间关系的关键字 | ||||
| extends | implements | |||
| 用于定义建立实例及引用实例，判断实例的关键字 | ||||
| new | this | super | instanceof | |
| 用于异常处理的关键字 | ||||
| try | catch | finally | throw | throws |
| 用于包的关键字 | ||||
| package | import | |||
| 其他修饰符关键字 | ||||
| native | strictfp | transient | volatile | assert |
| * 用于定义数据类型值的字面值 | ||||
| true | false | null | ||
1.2 保留字(reserved word)
Java保留字：被Java语言保留，现有Java版本尚未使用，但以后版本可能会作为关键字使用的字符串（单词）。
注：自己命名标识符时要避免使用这些保留字，例如，goto、const等。
2. 标识符(Identifier)
2.1 定义
- 在Java中，对各种变量、方法和类等要素命名时使用的字符序列称为标识符。
- 技巧：凡是自己可以命名的地方都叫标识符。例如：变量名、方法名、类名、接口名、包名...
2.2 命名规则
- 由26个英文字母大小写，0-9，_或$组成。
- 数字不可以开头。（原因：可能会与数值型变量赋值产生矛盾，例，类名：0.1F，变量赋值：float x = 0.1F;）
- 不可以使用关键字和保留字，但能包含关键字和保留字
- Java严格区分大小写，长度无限制。
- 标识符不能包含空格。
注：如果不遵守以上命名规则，则编译不通过，需要严格遵守。
2.2 命名规范
- 包名：多单词组成时，所有字母都是小写，例：xxxyyyzzz
- 类名、接口名：多单词组成时，所有单词首字母大写，例：XxxYyyZzz（大驼峰命名法，UpperCamelCase）
- 变量名、方法名：多单词组成时，第一个单词首字母小写，其余单词首字母大写，例：xxxYyyZzz（小驼峰命名法，lowerCamelCase）
- 常量名：所有字母都大写，多单词时每个单词用下划线连接：XXX_YYY_ZZZ
注：
- 如果遵守以上规范，编译可以通过，但建议遵守
- 在起名字时，为提高阅读性，要尽量有意义，“见名知意”。
- Java采用Unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。
3. 变量
3.1 变量的定义
- 变量的概念
> 内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化。
> 变量用于在内存中保存数据，是程序中最基本的存储单元，包含变量类型、变量名和变量值
- 变量的使用
> Java定义变量的格式：数据类型 变量名 = 变量值;
> 变量必须先声明，后使用。
> 变量只在作用域内有效。
> 同一作用域内，不能声明两个同名的变量。（逆向思维，反证法）
public class VariableTest {
public static void main(String[] args) {
// 变量的定义
int variable = 1;
// 变量的使用
System.out.println(variable);
// 编译错误：使用myNumber之前并未定义myNumber
// System.out.println(myNumber);
// 变量的声明
int myNumber;
// 编译错误：使用myNumber之前并未赋值过myNumber，不会默认初始化，需要显式初始化
// System.out.println(myNumber);
// 变量的赋值
myNumber = 1001;
System.out.println(myNumber);
}
}3.2 基础数据类型
1. 按照数据类型区分
- 基本数据类型
> 整型：byte、short、int、long
> 浮点型：float、double
> 字符型：char
> 布尔型：boolean
- 引用数据类型
> 类（class）
> 接口（interface）
> 数组（array）
2. 按照声明位置区分
- 成员变量：定义在类体内且在方法、构造器和代码块之外的变量。
- 局部变量：定义在方法、构造器和代码块中的变量
3. 整型类型
- Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证Java程序的可移植性。
- Java的整型常量默认为int型，声明long型常量，须后加'l'或者'L'。
- Java程序中整型变量通常声明为int型，除非不足以表示较大的数，才使用long。
| 类 型 | 占用存储空间 | 表数范围 |
| byte | 1字节=8bit位 | -128 ~ 127 |
| short | 2字节 | -215 ~215-1 |
| int | 4字节 | -231 ~ 231-1 (约21亿) |
| long | 8字节 | -263 ~ 263-1 |
4. 浮点型类型
- 与整型类型相似，Java浮点型类型也有固定的表数范围和字段长度，不受具体操作系统的影响
- float：单精度，尾数可以精确到7为有效数字。很多情况下，精度很难满足需求
- double：双精度，精度是float的两倍
- float的表数范围比long还大
- Java的浮点型常量默认是double型，声明float型常量，须后加'f'或'F'
- Java程序中定义浮点型变量通常声明为double
| 类 型 | 占用存储空间 | 表数范围 |
| 单精度float | 4字节 | -3.403E38 ~ 3.403E38 |
| 双精度double | 8字节 | -1.798E308 ~ 1.798E308 |
5. 字符型类型
- Java中所有的字符都使用Unicode编码，char类最初用于表示Unicode字符集中的一个字符，占用2个字节的存储空间，但随着Unicode标准的不断发展，其字符集不断扩展，已经超出了16位的char类型可以表示的范围（65535），如今，char类型用于表示使用一个代码单元表示的Unicode字符。Unicode 基本字符用一个 char 型表示，Unicode 增补字符用一对 char 型表示。
码点(code point)是指与一个编码表中的某个字符对应的代码值。UTF-16 编码采用不同长度的编码表示所有 Unicode 码点，每个 16 位二进制表示一个代码单元(code unit)。基本字符的范围为[U+0000,U+FFFF]，辅助字符，即上面提到的增补字符，其两个代码单元的范围分别为 [U+D800,U+DBFF] 和 [U+DC00,U+DFFF]。这样很容易就能知道一个代码单元是一个基本字符的编码还是一个辅助字符的第一或第二部分。
-
字符型变量值需要用英文单引号‘’括起来，英文单引号中必须有值，且只能写一个Unicode字符
-
字符型类型是可以进行运算的，因为它有对应的Unicode码。
-
字符型变量值的三种表现形式：
> 单个Unicode字符，例如：'A'、'中'。
> 转义字符，例如：'\n'、'\t'。
> 使用Unicode编码值表示，例如：'\u0000'、'\uFFFF'。
6. 布尔型类型
- boolean类型用来判断逻辑条件，一般用于程序流程控制，如：条件判断、循环结构。
- boolean类型数据只允许取值true或false，无null。不可以使用0或非 0 的整数替代false和true，这点和C语言不同，因此无法进行数值运算。
Java虚拟机中没有任何供boolean值专用的字节码指令， Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替： true用1表示， false用0表示。 ———《java虚拟机规范 8版》
3.3 基本数据类型变量之间的转换
前提：这里讨论的只是7种基本数据类型间的运算，不包含boolean类型。
- 自动类型提升
- 定义：当容量小的数据类型变量与容量大的数据类型变量做运算时，容量小的数据类型自动转换为容量大的数据类型，然后再做运算，结果为容量大的数据类型。数据类型容量大小排序：byte、short、char --》int --》long --》float --》double
- 此处的容量大小指的是数据类型的表数范围大小，比如：float的容量要大于long的容量
- 特别的是，byte、short、char之间做运算时，结果为int，即：byte、short、char之间不会相互转换，它们三者在计算时首先转换为int类型。
- boolean类型不能与其它数据类型运算。
public class VariableTest1 {
public static void main(String[] args) {
byte b1 = 1;
int int1 = 12;
// 编译不通过，提示：不兼容的类型: 从int转换到byte可能会有损失
// int型表数范围和字段长度较大，运算后应向int型靠拢
// byte b2 = b1 + int1;
int int2 = b1 + int1;
System.out.println(int2);
float f = b1 + int1;
System.out.println(f);
double d = b1 + int1;
System.out.println(d);
char c1 = 'a';
int int3 = c1 + int1;
System.out.println(int3);
short s1 = 10;
// short s2 = c1 + s1; // 编译不通过，提示：不兼容的类型: 从int转换到short可能会有损失
// char c2 = c1 + s1; // 编译不通过，提示：不兼容的类型: 从int转换到char可能会有损失
// char c3 = c1 + b1; // 编译不通过，提示：不兼容的类型: 从int转换到char可能会有损失
// short s3 = s1 + b1; // 编译不通过，提示：不兼容的类型: 从int转换到short可能会有损失
// byte b3 = b1 + b1; // 编译不通过，提示：不兼容的类型: 从int转换到byte可能会有损失
}
}- 强制类型转换
- 自动类型提升运算的逆运算，将容量大的数据类型转换为容量小的数据类型。
- 需要使用强转符：()，例：int int4 = (int) 12.3;
- 注意点：强制类型转换可能导致精度损失。
public class VariableTest2 {
public static void main(String[] args) {
// 精度损失举例1
double d = 12.3;
int i1 = (int) d;
// 没有精度损失
long l1 = 123;
short s1 = (short) l1;
// 精度损失举例2
int i2 = 128;
byte b1 = (byte) i2;
System.out.println(b1); // -128
}
}基本数据类型变量运算的特殊情况：
public class VariableTest3 {
public static void main(String[] args) {
/*
Java语言中，整型常量默认为int型，浮点型常量默认为double型。
*/
// 编码情况1，自动类型提升
long l1 = 123;
// long l2 = 1232131231232131; // 编译失败，数值过大，超出int型的表数范围
long l3 = 1232131231232131L;
//float f1 = 12.3; // 编译失败，提示：不兼容的类型: 从double转换到float可能会有损失
float f2 = 12.3F;
}
}3.4 String类型变量的使用
- String类型属于引用数据类型，翻译为：字符串
- String类型变量值需要用英文双引号""括起来，声明举例：String str = "字符串";
- String类型变量可以和8种基本数据类型变量做运算，且运算只能是连接运算：+。
- 当把任何基本数据类型的值和字符串（String）进行连接运算（+）时，基本数据类型的值将自动转化为字符串类型，运算的结果仍然是字符串类型。
String str1 = 4; //判断对错： no String str2 = 3.5f + “”; //判断str2对错： yes System.out.println(str2); //输出： ”3.5” System.out .println(3+4+“Hello!”); //输出： 7Hello! System.out.println(“Hello!”+3+4); //输出： Hello!34 System.out.println(‘a’+1+“Hello!”); //输出： 98Hello! System.out.println(“Hello”+‘a’+1); //输出： Helloa1
3.5 进制与进制之间的转换
- 计算机中不同进制的使用说明
- 所有数字在计算机底层都以二进制的形式存在
- 对于整数，有四种表示方式：
> 二进制(binary)： 0,1 ，满2进1.以0b或0B开头。
> 十进制(decimal)： 0-9 ，满10进1。
> 八进制(octal)： 0-7 ，满8进1. 以数字0开头表示。
> 十六进制(hex)： 0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
public class BinaryTest {
public static void main(String[] args) {
int num1 = 0B110;
int num2 = 12;
int num3 = 0123;
int num4 = 0X00AF;
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
System.out.println(num4);
}
}| 十进制 | 十六进制 | 八进制 | 二进制 |
| 0 | 0 | 0 | 0 |
| 1 | 1 | 1 | 1 |
| 2 | 2 | 2 | 10 |
| 3 | 3 | 3 | 11 |
| 4 | 4 | 4 | 100 |
| 5 | 5 | 5 | 101 |
| 6 | 6 | 6 | 110 |
| 7 | 7 | 7 | 111 |
| 8 | 8 | 10 | 1000 |
| 十进制 | 十六进制 | 八进制 | 二进制 |
| 9 | 9 | 11 | 1001 |
| 10 | A | 12 | 1010 |
| 11 | B | 13 | 1011 |
| 12 | C | 14 | 1100 |
| 13 | D | 15 | 1101 |
| 14 | E | 16 | 1110 |
| 15 | F | 17 | 1111 |
| 16 | 10 | 20 | 10000 |
| 17 | 11 | 21 | 10001 |
- 二进制
- Java整数常量默认是int型，当用二进制定义整数时，它的第32位是符号位；当整数是long型时，二进制默认是64位，第64位是符号位。
- 二进制的整数有如下三种表现形式：
> 原码：将一个数值转换成二进制数，最高位表示符号位，正数符号位为0，负数符号位为1
> 反码：正数的反码是其原码，负数的反码是其原码符号位保持不变，其余位按位取反。
> 补码：正数的补码是其原码，负数的补码是其反码加1。
- 计算机以二进制补码的形式保存所有整数。
- 计算机二进制补码的形式存储整数的目的：计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了。
二进制转十进制（乘以2的幂数）以及负数补码的推算
byte类型表数范围最小值-128的推算：
十进制转二进制的推算：除2取余的逆
- 进制的基本转换
二进制与八进制互转 - 每三位二进制对应一位八进制
二进制与十六进制互转 - 每四位二进制对应一位十六进制
4. 运算符
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
- 算术运算符
- 赋值运算符
- 比较运算符（关系运算符）
- 逻辑运算符
- 位运算符
- 三元运算符
4.1 算术运算符
| 运算符 | 运算 | 范例 | 结果 |
| + | 正号 | +3 | 3 |
| - | 负号 | b=4; -b | -4 |
| + | 加 | 5+5 | 10 |
| - | 减 | 6-4 | 2 |
| * | 乘 | 3*4 | 12 |
| / | 除 | 5/5 | 1 |
| % | 取模(取余) | 7%5 | 2 |
| ++ | 自增（前）：先运算后取值 自增（后）：先取值后运算 | a=2;b=++a; a=2;b=a++; | a=3;b=3 a=3;b=2 |
| -- | 自减（前）：先运算后取值 自减（后）：先取值后运算 | a=2;b=- -a a=2;b=a- - | a=1;b=1 a=1;b=2 |
| + | 字符串连接 | “He”+”llo” | “Hello” |
算术运算符练习：
public class ArithmeticOperatorTest {
public static void main(String[] args) {
// 除号：/
int num1 = 12;
int num2 = 5;
int result1 = num1 / num2;
System.out.println(result1); // 2
int result2 = num1 / num2 * num2;
System.out.println(result2); // 10
double result3 = num1 / num2;
System.out.println(result3); // 2.0
double result4 = num1 / num2 + 0.0; // 2.0
double result5 = num1 / (num2 + 0.0); // 2.4
double result6 = (double) num1 / num2; //2.4
double result7 = (double) (num1 / num2); // 2.0
// %：取模运算(取余运算)
// 结果的符号与被模数的符号相同
// 开发中经常使用%来判断是否被除尽的情况
int m1 = 12;
int n1 = 5;
System.out.println("m1 % n1 = " + m1 % n1); // 2
int m2 = -12;
int n2 = 5;
System.out.println("m2 % n2 = " + m2 % n2); // -2
int m3 = 12;
int n3 = -5;
System.out.println("m3 % n3 = " + m3 % n3); // 2
int m4 = -12;
int n4 = -5;
System.out.println("m4 % n4 = " + m4 % n4); // -2
// (前)++：先自增1，后运算
// (后)++：先运算，后自增1
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1 + "，b1 = " + b1); // a1 = 11，b1 = 11
int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2 + "，b2 = " + b2); // a2 = 11，b2 = 10
// 注意点：
short s1 = 10;
// s1 = s1 + 1; // 编译失败
// s1 = (short) (s1 + 1); // 正确的
s1++; // 自增1不会改变本身变量的数据类型
// 问题：
byte bb1 = 127;
bb1++;
System.out.println(bb1); //-128
// (前)--：先自减1，后运算
// (后)--：先运算，后自减1
int a3 = 10;
int b3 = --a3;
System.out.println("a3 = " + a3 + "，b3 = " + b3); // a3 = 9，b3 = 9
int a4 = 10;
int b4 = a4--;
System.out.println("a4 = " + a4 + "，b4 = " + b4); // a4 = 9，b4 = 10
}
}4.2 赋值运算符
- 符号：=
- 当“=”两侧的数据类型不一致时，可以使用自动类型提升或强制类型转换原则处理。
- 支持连续赋值。
- 扩展赋值运算符：+=，-=，*=，/=，%=
/*
运算符之二：赋值运算符
= += -= *= /= %=
*/
public class SetValueTest {
public static void main(String[] args) {
// 赋值运算符：=
int i1 = 10;
int j1 = 10;
int i2,j2;
// 连续赋值
i2 = j2 = 10;
int i3 = 10, j3 = 10;
//********************************
int num1 = 10;
num1 += 2; // num1 = num1 + 2;
System.out.println(num1); // 12
int num2 = 10;
num2 %= 5; // num2 = num2 % 5;
System.out.println(num2); // 0
short s1 = 10;
//s1 = s1 + 2; // 编译失败
s1 += 2; // 结论：不会改变变量本身的数据类型
System.out.println(s1);
// 开发中，如果希望变量实现+2操作，有几种方法？（前提： int num = 10;）
// 方式一：num = num + 2；
// 方式二：num += 2; (推荐)
}
}4.3 比较运算符
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| == | 相等于 | 4==3 | false |
| != | 不等于 | 4!=3 | true |
| < | 小于 | 4<3 | false |
| > | 大于 | 4>3 | true |
| <= | 小于等于 | 4<=3 | false |
| >= | 大于等于 | 4>=3 | true |
| instanceof | 检查是否是类的对象 | “Hello” instanceof String | true |
- 比较运算符的结果都是boolean类型
- 比较运算符也称为关系运算符
- 比较运算符“==”不能误写成“=”
比较运算符练习：
/*
运算符之三：比较运算符
== != > < >= <=instanceof
结论：
1.比较运算符的结果是boolean类型
2.区分 == 和 =
*/
public class CompareTest {
public static void main(String[] args) {
int i = 10;
int j = 20;
System.out.println(i == j); // false
System.out.println(i = j); // 20
}
}4.4 逻辑运算符
&—逻辑与 | —逻辑或 ！ —逻辑非
&& —短路与 || —短路或 ^ —逻辑异或
| a | b | a&b | a&&b | a|b | a||b | !a | a^b |
| true | true | true | true | true | true | false | false |
| true | false | false | false | true | true | false | true |
| false | true | false | false | true | true | true | true |
| false | false | false | false | false | false | true | false |
- 逻辑运算符用于连接boolean类型表达式，在Java中不可以写成 3 < x < 6，应该写成x > 3 & x < 6 或 x > 3 && x < 6。
- “&”和“&&”的区别：
- 单&时，左边无论真假，右边都会进行运算。
- 双&&时，如果左边为真，右边参与运算，如果左边为假，右边不参与运算。
- “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
- 异或(^)与或(|)的不同之处是：当左右都为true时，结果为false，异或追求的是“异”，也就是说，左右两边相同，结果为false，左右两边不同，结果为true。
/* 运算符之四：逻辑运算符 & && | || ! ^ 说明： 1. 逻辑运算符操作的都是boolean类型的变量 */ public class LogicOperatorTest { public static void main(String[] args) { // 区分 & 与 && // 相同点1：& 与 &&的运算结果相同 // 相同点2：当符号左边是true时，二者都会执行符号右边的运算 // 不同点：当符号左边是false时，&继续执行符号右边的运算，&&不再执行右边的运算 // 开发中推荐使用&& boolean b1 = false; //b1 = true; int num1 = 10; if(b1 & num1++ > 0) { System.out.println("测试逻辑与结果为真"); } else { System.out.println("测试逻辑与结果为假"); } System.out.println("num1 = " + num1); boolean b2 = false; // b2 = true; int num2 = 10; if(b2 && num2++ > 0){ System.out.println("测试短路与结果为真"); } else { System.out.println("测试短路与结果为假"); } System.out.println("num2 = " + num2); // 区分：| 与 || //相同点1：| 与 || 的运算结果相同 //相同点2：当符号左边是false时，二者都会执行符号右边的运算 //不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算 //开发中，推荐使用|| boolean b3 = false; b3 = true; int num3 = 10; if(b3 | (num3++ > 0)){ System.out.println("我现在在北京"); }else{ System.out.println("我现在在南京"); } System.out.println("num3 = " + num3); boolean b4 = false; b4 = true; int num4 = 10; if(b4 || (num4++ > 0)){ System.out.println("我现在在北京"); }else{ System.out.println("我现在在南京"); } System.out.println("num4 = " + num4); } }
4.5 位运算符
位运算是直接对整数的二进制进行的运算。注意：无<<<
| 运算符 | 运算 | 范例 |
| << | 左移 | 3 << 2 = 12 --> 3*2*2=12 |
| >> | 右移 | 3 >> 1 = 1 --> 3/2=1 |
| >>> | 无符号右移 | 3 >>> 1 = 1 --> 3/2=1 |
| & | 与运算 | 6 & 3 = 2 |
| | | 或运算 | 6 | 3 = 7 |
| ^ | 异或运算 | 6 ^ 3 = 5 |
| ~ | 取反运算 | ~6 = -7 |
位运算符的细节：
| << | 被移除的高位丢弃，空缺位补0。 |
| >> | 被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1。 |
| >>> | 被移位二进制最高位无论是0或者是1，空缺位都用0补。 |
| & | 二进制位进行&运算，只有1&1时结果是1，否则是0; |
| | | 二进制位进行 | 运算，只有0 | 0时结果是0，否则是1; |
| ^ | 相同二进制位进行 ^ 运算，结果是0； 1^1=0 , 0^0=0 不相同二进制位 ^ 运算结果是1。 1^0=1 , 0^1=1 |
| ~ | 正数取反，各二进制码按补码各位取反 负数取反，各二进制码按补码各位取反 |
位运算图示：
位运算练习：
/*
运算符之五：位运算符 （了解）
结论：
1. 位运算符操作的都是整型的数据
2. << ：在一定范围内，每向左移1位，相当于 * 2
>> :在一定范围内，每向右移1位，相当于 / 2
面试题：最高效方式的计算2 * 8 ？ 2 << 3 或 8 << 1
*/
class BitTest {
public static void main(String[] args) {
int i = 21;
i = -21;
System.out.println("i << 2 :" + (i << 2));
System.out.println("i << 3 :" + (i << 3));
System.out.println("i << 27 :" + (i << 27));
int m = 12;
int n = 5;
System.out.println("m & n :" + (m & n));
System.out.println("m | n :" + (m | n));
System.out.println("m ^ n :" + (m ^ n));
//练习：交换两个变量的值
int num1 = 10;
int num2 = 20;
System.out.println("num1 = " + num1 + ",num2 = " + num2);
//方式一：定义临时变量的方式
//推荐的方式
int temp = num1;
num1 = num2;
num2 = temp;
//方式二：好处：不用定义临时变量
//弊端：① 相加操作可能超出存储范围 ② 有局限性：只能适用于数值类型
//num1 = num1 + num2;
//num2 = num1 - num2;
//num1 = num1 - num2;
//方式三：使用位运算符
//有局限性：只能适用于数值类型
//num1 = num1 ^ num2;
//num2 = num1 ^ num2;
//num1 = num1 ^ num2;
System.out.println("num1 = " + num1 + ",num2 = " + num2);
}
}
4.6 三元运算符
- 语法结构：
- 条件表达式的运算结果是boolean类型的
- 三元运算符要求必须返回一个结果，因此，表达式1和表达式2必须有返回值，而且两者的返回值类型必须是可以统一为同种类型的。
- 三元运算符与if-else的联系与区别：
> 三元运算符可改写成if-else语句
> 三元运算符要求必须返回一个结果
> if-else结构的代码块可有多个语句
/*
运算符之六：三元运算符
1、结构：(条件表达式) ? 表达式1 : 表达式2
2、说明
① 条件表达式的结果为boolean类型
② 根据条件表达式的真或假，决定执行表达式1，还是表达式2
如果条件表达式的结果为true，则执行表达式1
如果条件表达式的结果为false，则执行表达式2
③ 表达式1和表达式2必须是一致的
④ 三元运算符可以嵌套使用
3、凡是可以使用三元运算符的地方，都可以改写成if-else结构，反之，不成立。
4、如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符，原因：简洁、执行效率高。
*/
public class SanYuanTest {
public static void main(String[] args) {
// 获取两个整数的较大值
int m = 12;
int n = 5;
int max = m > n ? m : n;
// 根据运算符的优先级，三元运算符的优先级高于“+=”赋值运算符，实际执行代码为：int z = (m > n ? m+=1 : n)+=2;
// 因此编译失败
// int z = m > n ? m+=1 : n+=2;
// 比较三个数的最大值
int n1 = 12;
int n2 = 30;
int n3 = -43;
int max1 = n1 > n2 ? n1 : n2;
int max2 = max1 > n3 ? max1 : n3;
System.out.println();
System.out.println("三个数中的最大值为：" + max2);
//不建议
//int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
// System.out.println("三个数中的最大值为：" + max3);
//该写成if-else:
if(m > n){
System.out.println(m);
}else{
System.out.println(n);
}
}
}- 运算符的优先级
扫一扫
1393
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
