# 第 02 章_变量与运算符
讲师：尚硅谷 - 宋红康（江湖人称：康师傅）
官网：http://www.atguigu.com
# 本章专题与脉络
# 1. 关键字（keyword）
- 定义：被 Java 语言赋予了特殊含义，用做专门用途的字符串（或单词）
- HelloWorld 案例中，出现的 **关键字** 有
class、public、static、void等，这些单词已经被 Java 定义好了。
- HelloWorld 案例中，出现的 **关键字** 有
- 特点：全部关键字都是
小写字母。 - 关键字比较多，不需要死记硬背，学到哪里记到哪里即可。
- 官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
说明：
- 关键字一共
50个，其中const、goto是 **保留字(reserved word)**。true，false，null不在其中，它们看起来像关键字，其实是字面量，表示特殊的布尔值和空值。
# 2. 标识符 (identifier)
Java 中变量、方法、类等要素命名时使用的字符序列，称为标识符。
技巧：凡是自己可以起名字的地方都叫标识符。
标识符的命名规则（必须遵守的 硬性规定 ）：
> 由26个英文字母大小写，0-9 ，_或 $ 组成
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。
练习：miles、Test、a++、 --a、4#R、$4、 #44、apps、class、public、int、x、y、radius
标识符的命名规范（建议遵守的 软性要求 ，否则工作时容易被鄙视）:
> 包名：多单词组成时所有字母都小写：xxxyyyzzz。
例如：java.lang、com.atguigu.bean
> 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
例如：HelloWorld，String，System等
> 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
例如：age,name,bookName,main,binarySearch,getName
> 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
例如：MAX_VALUE,PI,DEFAULT_CAPACITY
注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
更多细节详见《代码整洁之道_关于标识符.txt》《阿里巴巴 Java 开发手册 - 1.7.1 - 黄山版》
# 3. 变量
# 3.1 为什么需要变量
一花一世界，如果把一个程序看做一个世界或一个社会的话，那么变量就是程序世界的花花草草、万事万物。即，变量是程序中不可或缺的组成单位，最基本的存储单元。
# 3.2 初识变量
变量的概念：
内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化
变量的构成包含三个要素：
数据类型、变量名、存储的值Java 中变量声明的格式：
数据类型 变量名 = 变量值![image-20220311000744867]()
变量的作用：用于在内存中保存数据。
使用变量注意：
- Java 中每个变量必须先声明，后使用。
- 使用变量名来访问这块区域的数据。
- 变量的作用域：其定义所在的一对 { } 内。
- 变量只有在其
作用域内才有效。出了作用域，变量不可以再被调用。 - 同一个作用域内，不能定义重名的变量。
# 3.3 Java 中变量的数据类型
Java 中变量的数据类型分为两大类：
基本数据类型（四类八种）：包括
整数类型、浮点数类型、字符类型、布尔类型。存储的是数据值
引用数据类型：包括
数组、类、接口、枚举、注解、记录。存储的是地址值
![Java的数据类型]()
# 3.4 变量的使用
# 3.4.1 步骤 1：变量的声明
格式：数据类型 变量名;
// 例如： | |
// 存储一个整数类型的年龄 | |
int age; | |
// 存储一个小数类型的体重 | |
double weight; | |
// 存储一个单字符类型的性别 | |
char gender; | |
// 存储一个布尔类型的婚姻状态 | |
boolean marry; | |
// 存储一个字符串类型的姓名 | |
String name; | |
// 声明多个同类型的变量 | |
int a,b,c; // 表示 a,b,c 三个变量都是 int 类型。 |
注意：变量的数据类型可以是基本数据类型，也可以是引用数据类型。
# 3.4.2 步骤 2：变量的赋值
给变量赋值，就是把 “值” 存到该变量代表的内存空间中。同时，给变量赋的值类型必须与变量声明的类型一致或兼容。
变量赋值的语法格式：
变量名 = 值; |
举例 1：可以使用合适类型的 常量值 给已经声明的变量赋值
age = 18; | |
weight = 109; | |
gender = '女'; |
举例 2：可以使用其他 变量 或者 表达式 给变量赋值
int m = 1; | |
int n = m; | |
int x = 1; | |
int y = 2; | |
int z = 2 * x + y; |
3：变量可以反复赋值
// 先声明，后初始化 | |
char gender; | |
gender = '女'; | |
// 给变量重新赋值，修改 gender 变量的值 | |
gender = '男'; | |
System.out.println("gender = " + gender);//gender = 男 |
举例 4：也可以将变量的声明和赋值一并执行
boolean isBeauty = true; | |
String name = "迪丽热巴"; |
内存结构如图：
# 4. 基本数据类型介绍
# 4.1 整数类型：byte、short、int、long
- Java 各整数类型有固定的表数范围和字段长度，不受具体操作系统的影响，以保证 Java 程序的可移植性。
- 定义 long 类型的变量，赋值时需要以 "
l"或"L" 作为后缀。 - Java 程序中变量通常声明为 int 型，除非不足以表示较大的数，才使用 long。
- Java 的整型
常量默认为 int 型。
# 4.1.1 补充：计算机存储单位
** 字节（Byte）：** 是计算机用于
计量存储容量的基本单位，一个字节等于 8 bit。** 位（bit）：** 是数据存储的
最小单位。二进制数系统中，每个 0 或 1 就是一个位，叫做 bit（比特），其中 8 bit 就称为一个字节 (Byte)。转换关系：
- 8 bit = 1 Byte
- 1024 Byte = 1 KB
- 1024 KB = 1 MB
- 1024 MB = 1 GB
- 1024 GB = 1 TB
# 4.2 浮点类型：float、double
- 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。
- 浮点型常量有两种表示形式：
- 十进制数形式。如：5.12 512.0f .512 (必须有小数点）
- 科学计数法形式。如：5.12e2 512E2 100E-2
- float：
单精度，尾数可以精确到7 位有效数字。很多情况下，精度很难满足需求。 - double：
双精度，精度是float 的两倍。通常采用此类型。 - 定义 float 类型的变量，赋值时需要以 "
f"或"F" 作为后缀。 - Java 的浮点型
常量默认为double型。
# 4.2.1 关于浮点型精度的说明
并不是所有的小数都能可以精确的用二进制浮点数表示。二进制浮点数不能精确的表示 0.1、0.01、0.001 这样 10 的负次幂。
浮点类型 float、double 的数据不适合在
不容许舍入误差的金融计算领域。如果需要精确数字计算或保留指定位数的精度，需要使用BigDecimal类。测试用例：
// 测试 1：（解释见章末企业真题：为什么 0.1 + 0.2 不等于 0.3） | |
System.out.println(0.1 + 0.2);//0.30000000000000004 | |
// 测试 2： | |
float ff1 = 123123123f; | |
float ff2 = ff1 + 1; | |
System.out.println(ff1); | |
System.out.println(ff2); | |
System.out.println(ff1 == ff2); |
# 4.2.2 应用举例
案例 1：定义圆周率并赋值为 3.14，现有 3 个圆的半径分别为 1.2、2.5、6，求它们的面积。
/** | |
* @author 尚硅谷 - 宋红康 | |
* @create 12:36 | |
*/ | |
public class Exercise1 { | |
public static void main(String[] args) { | |
double PI = 3.14; // 圆周率 | |
double radius1 = 1.2; | |
double radius2 = 2.5; | |
int radius3 = 6; | |
System.out.println("第1个圆的面积：" + PI * radius1 * radius1); | |
System.out.println("第2个圆的面积：" + PI * radius2 * radius2); | |
System.out.println("第3个圆的面积：" + PI * radius3 * radius3); | |
} | |
} |
案例 2：小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。
它需要一个程序将华氏温度（80 度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。
℃ = (℉ - 32) / 1.8
/** | |
* @author 尚硅谷 - 宋红康 | |
* @create 12:51 | |
*/ | |
public class Exercise2 { | |
public static void main(String[] args) { | |
double hua = 80; | |
double she = (hua-32)/1.8; | |
System.out.println("华氏度" + hua+"℉转为摄氏度是" +she+"℃"); | |
} | |
} |
# 4.3 字符类型：char
char 型数据用来表示通常意义上 “
字符”（占2 字节）Java 中的所有字符都使用 Unicode 编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
字符型变量的三种表现形式：
** 形式 1：** 使用单引号 (' ')括起来的
单个字符。例如：char c1 = 'a'; char c2 = ' 中 '; char c3 = '9';
** 形式 2：** 直接使用
Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX 代表一个十六进制整数。查表
CodeCharts.pdf例如：\u0023 表示 '#'。
** 形式 3：**Java 中还允许使用
转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = '\n'; // '\n' 表示换行符
形式 4：ASCII 码表
例如：char ling = 48; char A = 65; char a = 97;
转义字符 说明 Unicode 表示方式 \n换行符 \u000a \t制表符 \u0009 \"双引号 \u0022 \'单引号 \u0027 \\反斜线 \u005c \b退格符 \u0008 \r回车符 \u000d char 类型是可以进行运算的。因为它都对应有 Unicode 码，可以看做是一个数值。
# 4.4 布尔类型：boolean
boolean 类型用来判断逻辑条件，一般用于流程控制语句中：
- if 条件控制语句；
- while 循环控制语句；
- for 循环控制语句；
- do-while 循环控制语句；
boolean 类型数据只有两个值：true、false，无其它。
- 不可以使用 0 或非 0 的整数替代 false 和 true，这点和 C 语言不同。
- 拓展：Java 虚拟机中没有任何供 boolean 值专用的字节码指令，Java 语言表达所操作的boolean 值，在编译之后都使用 java 虚拟机中的 int 数据类型来代替：true 用 1 表示，false 用 0 表示。——《java 虚拟机规范 8 版》
举例：
boolean isFlag = true; | |
if(isFlag){ | |
//true 分支 | |
}else{ | |
//false 分支 | |
} |
经验之谈：
Less is More！建议不要这样写：if (isFlag = = true)，只有新手才如此。关键也很容易写错成 if (isFlag = true)，这样就变成赋值 isFlag 为 true 而不是判断！
老鸟的写法是 if (isFlag) 或者 if ( !isFlag)。
# 5. 基本数据类型变量间运算规则
在 Java 程序中，不同的基本数据类型（只有 7 种，不包含 boolean 类型）变量的值经常需要进行相互转换。
转换的方式有两种： 自动类型提升 和 强制类型转换 。
# 5.1 自动类型提升（隐式转换）
规则：将取值范围小的类型自动提升为取值范围大的类型 。
基本数据类型的转换规则如图所示：
（1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时
int i = 'A';//char 自动升级为 int，其实就是把字符的编码值赋值给 i 变量了 | |
double d = 10;//int 自动升级为 double | |
long num = 1234567; // 右边的整数常量值如果在 int 范围呢，编译和运行都可以通过，这里涉及到数据类型转换 | |
//byte bigB = 130;// 错误，右边的整数常量值超过 byte 范围 | |
long bigNum = 12345678912L;// 右边的整数常量值如果超过 int 范围，必须加 L，显式表示 long 类型。否则编译不通过 |
（2）当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算。
int i = 1; | |
byte b = 1; | |
double d = 1.0; | |
double sum = i + b + d;// 混合运算，升级为 double |
（3）当 byte,short,char 数据类型的变量进行算术运算时，按照 int 类型处理。
byte b1 = 1; | |
byte b2 = 2; | |
byte b3 = b1 + b2;// 编译报错，b1 + b2 自动升级为 int | |
char c1 = '0'; | |
char c2 = 'A'; | |
int i = c1 + c2;// 至少需要使用 int 类型来接收 | |
System.out.println(c1 + c2);//113 |
练习：
设 x 为float型变量，y为double型变量，a为int型变量，b为long型变量，c为char型变量，则表达式
x + y * a / x + b / y + c的值类型为：
A. int B. long C. double D. char
# 5.2 强制类型转换
将 3.14 赋值到 int 类型变量会发生什么？产生编译失败，肯定无法赋值。
int i = 3.14; // 编译报错 |
想要赋值成功，只有通过 强制类型转换 ，将 double 类型强制转换成 int 类型才能赋值。
规则：将取值范围大的类型强制转换成取值范围小的类型。
自动类型提升是 Java 自动执行的，而强制类型转换是自动类型提升的逆运算，需要我们自己手动执行。
转换格式：
数据类型1 变量名 = (数据类型1)被强转数据值; //() 中的数据类型必须 & lt;= 变量值的数据类型 |
（1）当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会 损失精度 或 溢出 。
int i = (int)3.14;// 损失精度 | |
double d = 1.2; | |
int num = (int)d;// 损失精度 | |
int i = 200; | |
byte b = (byte)i;// 溢出 |
（2）当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是 没有风险 的，通常省略。
int i = 1; | |
int j = 2; | |
double bigger = (double)(i/j); |
（3）声明 long 类型变量时，可以出现省略后缀的情况。float 则不同。
long l1 = 123L; | |
long l2 = 123;// 如何理解呢？ 此时可以看做是 int 类型的 123 自动类型提升为 long 类型 | |
//long l3 = 123123123123; // 报错，因为 123123123123 超出了 int 的范围。 | |
long l4 = 123123123123L; | |
//float f1 = 12.3; // 报错，因为 12.3 看做是 double，不能自动转换为 float 类型 | |
float f2 = 12.3F; | |
float f3 = (float)12.3; |
练习：判断是否能通过编译
1）short s = 5; | |
s = s-2; // 判断：no | |
2） byte b = 3; | |
b = b + 4; // 判断：no | |
b = (byte)(b+4); // 判断：yes | |
3）char c = ‘a’; | |
int i = 5; | |
float d = .314F; | |
double result = c+i+d; // 判断：yes | |
4） byte b = 5; | |
short s = 3; | |
short t = s + b; // 判断：no |
问答：为什么标识符的声明规则里要求不能数字开头？
// 如果允许数字开头，则如下的声明编译就可以通过： | |
int 123L = 12; | |
// 进而，如下的声明中 l 的值到底是 123？还是变量 123L 对应的取值 12 呢？ 出现歧义了。 | |
long l = 123L; |
# 5.3 基本数据类型与 String 的运算
# 5.3.1 字符串类型：String 类
- String 不是基本数据类型，属于引用数据类型
- 使用一对
""来表示一个字符串，内部可以包含 0 个、1 个或多个字符。 - 声明方式与基本数据类型类似。例如：String str = “尚硅谷”;
# 5.3.2 运算规则
1、任意八种基本数据类型的数据与 String 类型只能进行连接 “+” 运算，且结果一定也是 String 类型
System.out.println("" + 1 + 2);//12 | |
int num = 10; | |
boolean b1 = true; | |
String s1 = "abc"; | |
String s2 = s1 + num + b1; | |
System.out.println(s2);//abc10true | |
//String s3 = num + b1 + s1;// 编译不通过，因为 int 类型不能与 boolean 运算 | |
String s4 = num + (b1 + s1);// 编译通过 |
2、String 类型不能通过强制类型 () 转换，转为其他的类型
只能借助包装类的方法才能转
String str = "123"; | |
int num = (int)str;// 错误的 | |
int num = Integer.parseInt(str);// 正确的，后面才能讲到，借助包装类的方法才能转 |
# 5.3.3 案例与练习
案例：公安局身份登记
要求填写自己的姓名、年龄、性别、体重、婚姻状况（已婚用 true 表示，单身用 false 表示）、联系方式等等。
/** | |
* @author 尚硅谷 - 宋红康 | |
* @create 12:34 | |
*/ | |
public class Info { | |
public static void main(String[] args) { | |
String name = "康师傅"; | |
int age = 37; | |
char gender = '男'; | |
double weight = 145.6; | |
boolean isMarried = true; | |
String phoneNumber = "13112341234"; | |
System.out.println("姓名：" + name); | |
System.out.println("年龄：" + age); | |
System.out.println("性别：" + gender); | |
System.out.println("体重：" + weight); | |
System.out.println("婚否：" + isMarried); | |
System.out.println("电话：" + phoneNumber); | |
// 或者 | |
System.out.println("name = " + name + ",age = " + age + "，gender = " + | |
gender + ",weight = " + weight + ",isMarried = " + isMarried + | |
",phoneNumber = " + phoneNumber); | |
} | |
} |
练习：
练习 1：
String str1 = 4; // 判断对错： | |
String str2 = 3.5f + ""; // 判断 str2 对错： | |
System.out.println(str2); // 输出： | |
System.out .println(3+4+"Hello!"); // 输出： | |
System.out.println("Hello!"+3+4); // 输出： | |
System.out.println('a'+1+"Hello!"); // 输出： | |
System.out.println("Hello"+'a'+1); // 输出： |
练习 2：
System.out.println("* *"); // 输出： | |
System.out.println("*\t*"); // 输出： | |
System.out.println("*" + "\t" + "*"); // 输出： | |
System.out.println('*' + "\t" + "*"); // 输出： | |
System.out.println('*' + '\t' + "*"); // 输出： | |
System.out.println('*' + "\t" + '*'); // 输出： | |
System.out.println("*" + '\t' + '*'); // 输出： | |
System.out.println('*' + '\t' + '*'); // 输出： |
# 6. 计算机底层如何存储数据
计算机世界中只有二进制，所以计算机中存储和运算的 所有数据 都要转为 二进制 。包括数字、字符、图片、声音、视频等。
世界上有 10 种人 ，认识和不认识二进制的。
# 6.1 进制的分类
十进制（decimal）
- 数字组成：0-9
- 进位规则：满十进一
二进制（binary）
- 数字组成：0-1
- 进位规则：满二进一，以
0b或0B开头
八进制（octal）：很少使用
- 数字组成：0-7
- 进位规则：满八进一，以数字
0开头表示
十六进制
- 数字组成：0-9，a-f
- 进位规则：满十六进一，以
0x或0X开头表示。此处的 a-f 不区分大小写
代码演示：
class BinaryTest { | |
public static void main(String[] args) { | |
int num1 = 123; // 十进制 | |
int num2 = 0b101; // 二进制 | |
int num3 = 0127; // 八进制 | |
int num4 = 0x12aF; // 十六进制 | |
System.out.println(num1); | |
System.out.println(num2); | |
System.out.println(num3); | |
System.out.println(num4); | |
} | |
} |
# 6.2 进制的换算举例
| 十进制 | 二进制 | 八进制 | 十六进制 |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 1 | 1 | 1 | 1 |
| 2 | 10 | 2 | 2 |
| 3 | 11 | 3 | 3 |
| 4 | 100 | 4 | 4 |
| 5 | 101 | 5 | 5 |
| 6 | 110 | 6 | 6 |
| 7 | 111 | 7 | 7 |
| 8 | 1000 | 10 | 8 |
| 9 | 1001 | 11 | 9 |
| 10 | 1010 | 12 | a 或 A |
| 11 | 1011 | 13 | b 或 B |
| 12 | 1100 | 14 | c 或 C |
| 13 | 1101 | 15 | d 或 D |
| 14 | 1110 | 16 | e 或 E |
| 15 | 1111 | 17 | f 或 F |
| 16 | 10000 | 20 | 10 |
# 6.3 二进制的由来
二进制，是计算技术中广泛采用的一种数制，由德国数理哲学大师 莱布尼茨 于 1679 年发明。
二进制数据是用 0 和 1 两个数码来表示的数。它的基数为 2，进位规则是 “ 逢二进一 ”。
二进制广泛应用于我们生活的方方面面。比如，广泛使用的摩尔斯电码（Morse Code），它由两种基本信号组成：短促的点信号 “ · ”，读 “ 滴 ”；保持一定时间的长信号 “ — ”，读 “ 嗒 ”。然后，组成了 26 个字母，从而拼写出相应的单词。
记忆技巧：
我们偶尔会看到的：SOS，即为：
# 原码、反码、补码
原码：一个数的二进制形式，其中最高位为符号位，0 表示正数，1 表示负数。利用原码对正数计算是没问题的。
弊端：对负数计算，结果就出错，实际运算的结果，跟我们预期的结果是相反的。
反码：为了解决原码不能计算负数的问题而出现的。
- 正数的反码就是它本身
- 负数的反码就是在它的原码的基础上，符号位不变，其余各个位取反
弊端：负数运算的时候，如果结果不跨 0，是没有任何问题的，但是如果结果跨 0，跟实际结果会有 1 的偏差。
这是因为在反码中，0 有 + 0（0000 0000）和 - 0（1111 1111）两种表示形式，这就导致当运算跨零时，会产生 1 的误差。
补码：为了解决反码中 0 有两种表示的问题。
- 正数的补码就是它本身
- 负数的补码就是在反码的基础上，最后 + 1
补码还能多记录一个特殊的值 - 128（1000 0000），该数据在 1 个字节下，没有原码和反码。
很完美，因此计算机中数据的存储和运算都是以补码的形式进行的。
隐式转换（自动类型提升）：取值范围小 -> 取值范围大，因此在高位补 0即可。
强制类型转换：取值范围大 -> 取值范围小，截断即可。
但是截断后，因为最高位的符号位变了
其他的运算符：
# 6.4 二进制转十进制
二进制如何表示整数？
计算机数据的存储使用二进制
补码形式存储，并且最高位是符号位。- 正数：
最高位是0 - 负数：
最高位是1
- 正数：
规 定
- 正数的补码与反码、原码一样，称为
三码合一 - 负数的补码与反码、原码不一样：
- 负数的
原码：把十进制转为二进制，然后最高位设置为 1 - 负数的
反码：在原码的基础上，最高位不变，其余位取反（0 变 1,1 变 0） - 负数的
补码：反码 + 1
- 负数的
- 正数的补码与反码、原码一样，称为
二进制转十进制：权相加法
针对于 byte 数据举例来说：
例如：byte 类型（1 个字节，8 位）
25 ==> 原码 0001 1001 ==> 反码 0001 1001 --> 补码 0001 1001
-25 ==> 原码 1001 1001 ==> 反码 1110 0110 ==> 补码 1110 0111
整数： | |
正数：25 00000000 00000000 000000000 00011001（原码） | |
正数：25 00000000 00000000 000000000 00011001（反码） | |
正数：25 00000000 00000000 000000000 00011001（补码） | |
负数：-25 10000000 00000000 000000000 00011001（原码） | |
负数：-25 11111111 11111111 111111111 11100110（反码） | |
负数：-25 11111111 11111111 111111111 11100111（补码） |
一个字节可以存储的整数范围是多少？：-128~127
//1 个字节：8 位 | |
0000 0001 ~ 0111 111 ==> 1~127 | |
1000 0001 ~ 1111 1111 ==> -127 ~ -1 | |
0000 0000 ==>0 | |
1000 0000 ==> -128（特殊规定）=-127-1 |
# 6.5 十进制转二进制
十进制转二进制： 除2取余的逆
# 6.6 二进制与八进制、十六进制间的转换
二进制转八进制
二进制转十六进制
八进制、十六进制转二进制
# 6.7 各进制间的转换（以二进制为桥梁）
练习：
1.将以下十进制数转换为十六进制和二进制
123 256 87 62
2.将以下十六进制数转换为十进制和二进制
0x123 0x25F 0x38 0x62
# 7. 运算符（Operator）（掌握）
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
运算符的分类：
- 按照
功能分为：算术运算符、赋值运算符、比较 (或关系) 运算符、逻辑运算符、位运算符、条件运算符、Lambda 运算符
| 分类 | 运算符 |
|---|---|
| 算术运算符（7 个） | +、-、*、/、%、++、-- |
| 赋值运算符（12 个） | =、+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、|=、^= 等 |
| 比较 (或关系) 运算符（6 个） | >、>=、<、<=、==、!= |
| 逻辑运算符（6 个） | &、|、^、!、&&、|| |
| 位运算符（7 个） | &、|、^、~、<<、>>、>>> |
| 条件运算符（1 个） | (条件表达式)? 结果 1: 结果 2 |
| Lambda 运算符（1 个） | ->（第 18 章时讲解） |
- 按照
操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）
| 分类 | 运算符 |
|---|---|
| 一元运算符（单目运算符） | 正号（+）、负号（-）、++、--、!、~ |
| 二元运算符（双目运算符） | 除了一元和三元运算符剩下的都是二元运算符 |
| 三元运算符 （三目运算符） | (条件表达式)? 结果 1: 结果 2 |
# 7.1 算术运算符
# 7.1.1 基本语法
举例 1：加减乘除模
public class ArithmeticTest1 { | |
public static void main(String[] args) { | |
int a = 3; | |
int b = 4; | |
System.out.println(a + b);// 7 | |
System.out.println(a - b);// -1 | |
System.out.println(a * b);// 12 | |
System.out.println(a / b);// 计算机结果是 0，为什么不是 0.75 呢？ | |
System.out.println(a % b);// 3 | |
// 结果与被模数符号相同 | |
System.out.println(5%2);//1 | |
System.out.println(5%-2);//1 | |
System.out.println(-5%2);//-1 | |
System.out.println(-5%-2);//-1 | |
// 商 * 除数 + 余数 = 被除数 | |
//5%-2 ==> 商是 - 2，余数时 1 (-2)*(-2)+1 = 5 | |
//-5%2 ==> 商是 - 2，余数是 - 1 (-2)*2+(-1) = -4-1=-5 | |
} | |
} |
举例 2：“+” 号的两种用法
- 第一种：对于
+两边都是数值的话，+就是加法的意思 - 第二种：对于
+两边至少有一边是字符串的话，+就是拼接的意思
public class ArithmeticTest2 { | |
public static void main(String[] args) { | |
// 字符串类型的变量基本使用 | |
// 数据类型 变量名称 = 数据值； | |
String str1 = "Hello"; | |
System.out.println(str1); // Hello | |
System.out.println("Hello" + "World"); // HelloWorld | |
String str2 = "Java"; | |
// String + int --> String | |
System.out.println(str2 + 520); // Java520 | |
// String + int + int | |
// String + int | |
// String | |
System.out.println(str2 + 5 + 20); // Java520 | |
} | |
} |
举例 3：自加自减运算
理解： ++ 运算，表示 自增1 。同理， -- 运算，表示 自减1 ，用法与 ++ 一致。
注意：++ 或 -- 不会改变变量的数据类型！
1、单独使用
- 变量在单独运算的时候，变量
前++和变量后++，是没有区别的。 - 变量
前++：例如++a。 - 变量
后++：例如a++。
public class ArithmeticTest3 { | |
public static void main(String[] args) { | |
// 定义一个 int 类型的变量 a | |
int a = 3; | |
//++a; | |
a++; | |
// 无论是变量前 ++ 还是变量后 ++，结果都是 4 | |
System.out.println(a); | |
} | |
} |
2、复合使用
- 和
其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。
- 变量
前++：变量先自增 1，然后再运算。 - 变量
后++：变量先运算，然后再自增 1。
public class ArithmeticTest4 { | |
public static void main(String[] args) { | |
// 其他变量放在一起使用 | |
int x = 3; | |
//int y = ++x; //y 的值是 4，x 的值是 4， | |
int y = x++; //y 的值是 3，x 的值是 4 | |
System.out.println(x); | |
System.out.println(y); | |
System.out.println("=========="); | |
// 和输出语句一起 | |
int z = 5; | |
//System.out.println (++z);// 输出结果是 6，z 的值也是 6 | |
System.out.println(z++);// 输出结果是 5，z 的值是 6 | |
System.out.println(z); | |
} | |
} |
# 7.1.2 案例与练习
案例 1：
随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：
例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1
/** | |
* @author 尚硅谷 - 宋红康 | |
* @create 12:20 | |
*/ | |
class ArithmeticExer1 { | |
public static void main(String[] args) { | |
int num = 187; | |
int bai = num / 100; | |
int shi = num % 100 / 10;//int shi = num / 10 % 10; | |
int ge = num % 10; | |
System.out.println("百位为：" + bai); | |
System.out.println("十位为：" + shi); | |
System.out.println("个位为：" + ge); | |
} | |
} |
拓展：获取一个四位数的个位，十位，百位，千位
/** | |
* @author 尚硅谷 - 宋红康 | |
* @create 12:39 | |
*/ | |
public class ArithmeticExer01 { | |
public static void main (String [] args) { | |
//1. 定义一个变量，赋值为一个四位数整数，例如 1234 | |
int num = 1234; | |
//2. 通过运算操作求出个位，十位，百位，千位 | |
int ge = num % 10; | |
int shi = num /10 % 10; | |
int bai = num /100 % 10; | |
int qian = num / 1000 % 10; | |
System.out.println("个位上的数字是：" + ge); | |
System.out.println("十位上的数字是：" + shi); | |
System.out.println("百位上的数字是：" + bai); | |
System.out.println("千位上的数字是：" + qian); | |
} | |
} |
** 案例 2：** 为抵抗洪水，战士连续作战 89 小时，编程计算共多少天零多少小时？
/** | |
* @author 尚硅谷 - 宋红康 | |
* @create 17:47 | |
*/ | |
public class ArithmeticExer2 { | |
public static void main(String[] args){ | |
int hours = 89; | |
int day = hours / 24; | |
int hour = hours % 24; | |
System.out.println("为抵抗洪水，战士连续作战89小时："); | |
System.out.println(hours + "是" + day + "天" + hour +"小时"); | |
} | |
} |
练习 1：算术运算符：自加、自减
public class ArithmeticExer3{ | |
public static void main(String[] args){ | |
int i1 = 10; | |
int i2 = 20; | |
int i = i1++; | |
System.out.print("i="+i); // | |
System.out.println("i1="+i1);// | |
i = ++i1; | |
System.out.print("i="+i);// | |
System.out.println("i1="+i1);// | |
i = i2--; | |
System.out.print("i="+i);// | |
System.out.println("i2="+i2);// | |
i = --i2; | |
System.out.print("i="+i);// | |
System.out.println("i2="+i2);// | |
} | |
} |
练习 2：
System.out.println("5+5=" + 5 + 5); // 打印结果是？ 5+5=55 ? |
练习 3：
byte bb1 = 127; | |
bb1++; | |
System.out.println("bb1 = " + bb1);//-128 |
练习 4：
int i = 1; | |
int j = i++ + ++i * i++; | |
System.out.println("j = " + j); // j=10,i=4 |
练习 5：（企业真题）写出下列程序的输出结果
int i = 2; | |
int j = i++; // j = 2 , i = 3 | |
System.out.println(j); | |
int m = 2; | |
m = m++; //(1) 先取 m 的值 “2” 放操作数栈 (2) m 再自增，m=3 (3) 再把操作数栈中的 "2" 赋值给 m,m=2 | |
System.out.println(m); // m = 2 |
看 class 文件
# 7.2 赋值运算符
# 7.2.1 基本语法
符号：=
- 当 “=” 两侧数据类型不一致时，可以使用自动类型转换或手动使用强制类型转换原则进行处理。
- 支持
连续赋值。
扩展赋值运算符： +=、 -=、*=、 /=、%=
不会改变变量本身的数据类型，因为 JVM 会自动进行隐式 /强制类型转换
赋值运算符 符号解释 +=将符号 左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量-=将符号 左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量*=将符号 左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量/=将符号 左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量%=将符号 左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量
public class SetValueTest1 { | |
public static void main(String[] args) { | |
int i1 = 10; | |
long l1 = i1; // 自动类型转换 | |
byte bb1 = (byte)i1; // 强制类型转换 | |
int i2 = i1; | |
// 连续赋值的测试 | |
// 以前的写法 | |
int a1 = 10; | |
int b1 = 10; | |
// 连续赋值的写法 | |
int a2,b2; | |
a2 = b2 = 10; | |
int a3 = 10,b3 = 20; | |
// 举例说明 += -= *= /= %= | |
int m1 = 10; | |
m1 += 5; // 类似于 m1 = m1 + 5 的操作，但不等同于。 | |
System.out.println(m1);//15 | |
// 练习 1：开发中，如何实现一个变量 + 2 的操作呢？ | |
// += 的操作不会改变变量本身的数据类型。其他拓展的运算符也如此。 | |
// 写法 1：推荐 | |
short s1 = 10; | |
s1 += 2; // 编译通过，因为在得到 int 类型的结果后，JVM 自动完成一步强制类型转换，将 int 类型强转成 short | |
System.out.println(s1);//12 | |
// 写法 2： | |
short s2 = 10; | |
//s2 = s2 + 2;// 编译报错，因为将 int 类型的结果赋值给 short 类型的变量 s 时，可能损失精度 | |
s2 = (short)(s2 + 2); | |
System.out.println(s2); | |
// 练习 2：开发中，如何实现一个变量 + 1 的操作呢？ | |
// 写法 1：推荐 | |
int num1 = 10; | |
num1++; | |
System.out.println(num1); | |
// 写法 2： | |
int num2 = 10; | |
num2 += 1; | |
System.out.println(num2); | |
// 写法 3： | |
int num3 = 10; | |
num3 = num3 + 1; | |
System.out.println(num3); | |
} | |
} |
# 7.2.2 练习
练习 1：
short s = 3; | |
s = s+2; //① 编译报错 | |
s += 2; //② 正常执行 | |
//①和②有什么区别？ | |
①中右侧运算完是int，不能直接赋给左侧的short，需要手动进行强制类型转换，在右侧添加(short)； | |
②中的+=运算符会自动进行强制类型转换； |
练习 2：
int i = 1; | |
i *= 0.1; | |
System.out.println(i);//0 | |
i++; | |
System.out.println(i);//1 |
练习 3：
int m = 2; | |
int n = 3; | |
n *= m++; //n = n * m++; | |
System.out.println("m=" + m);//3 | |
System.out.println("n=" + n);//6 |
练习 4：
int n = 10; | |
n += (n++) + (++n); //n = n + (n++) + (++n) | |
System.out.println(n);//32 |
练习 5：你有几种办法实现变量值减 1？变量值减 2 呢？
/** | |
* @author 尚硅谷 - 宋红康 | |
* @create 16:55 | |
*/ | |
public class MinusTest { | |
public static void main(String[] args) { | |
// 练习①：变量值减 1 | |
short s = 10; | |
// 方式 1： | |
//s = (short)(s - 1); | |
// 方式 2：推荐 | |
s--; // 或者 --s | |
// 方式 3： | |
s -= 1; | |
// 练习②：变量值减 2 | |
short s1 = 10; | |
// 方式 1： | |
//s1 = (short)(s1 - 2); | |
// 方式 2：推荐 | |
s1 -= 2; | |
} | |
} |
# 7.3 比较 (关系) 运算符
比较运算符的结果都是 boolean 型，也就是要么是 true，要么是 false。
> < >= <= ：只适用于基本数据类型（除 boolean 类型之外）
== != ：适用于基本数据类型、引用数据类型
比较运算符 “
==” 不能误写成 “=”
举例：
= 赋值后，表达式取左侧变量的值
class CompareTest { | |
public static void main(String[] args) { | |
int i1 = 10; | |
int i2 = 20; | |
System.out.println(i1 == i2);//false | |
System.out.println(i1 != i2);//true | |
System.out.println(i1 >= i2);//false | |
int m = 10; | |
int n = 20; | |
System.out.println(m == n);//false | |
System.out.println(m = n);//20！！！！！！！！！ | |
boolean b1 = false; | |
boolean b2 = true; | |
System.out.println(b1 == b2);//false | |
System.out.println(b1 = b2);//true | |
} | |
} |
思考：
boolean b1 = false; | |
// 区分好 == 和 = 的区别。 | |
if(b1 == true) //if(b1 = true) | |
System.out.println("结果为真"); | |
else | |
System.out.println("结果为假"); |
# 7.4 逻辑运算符
# 7.4.1 基本语法
逻辑运算符，操作的都是 boolean 类型的变量或常量，而且运算得结果也是 boolean 类型的值。
运算符说明：
- & 和 &&：表示 "且" 关系，当符号左右两边布尔值都是 true 时，结果才能为 true。否则，为 false。
- | 和 || ：表示 "或" 关系，当符号两边布尔值有一边为 true 时，结果为 true。当两边都为 false 时，结果为 false
- ! ：表示 "非" 关系，当变量布尔值为 true 时，结果为 false。当变量布尔值为 false 时，结果为 true。
- ^ ：当符号左右两边布尔值不同时，结果为 true。当两边布尔值相同时，结果为 false。
- 理解：
异或，追求的是“异”！
- 理解：
逻辑运算符用于连接布尔型表达式，在 Java 中不可以写成 3 <x < 6，应该写成 x> 3 & x < 6 。
区分 “&” 和 “&&”：
相同点：如果符号左边是 true，则二者都执行符号右边的操作
不同点：& ： 如果符号左边是 false, 则继续执行符号右边的操作
&& ：如果符号左边是 false, 则不再继续执行符号右边的操作
- 建议：开发中，推荐使用 &&
区分 “|” 和 “||”：
相同点：如果符号左边是 false，则二者都执行符号右边的操作
不同点：| ： 如果符号左边是 true，则继续执行符号右边的操作
|| ：如果符号左边是 true，则不再继续执行符号右边的操作
建议：开发中，推荐使用 ||
代码举例：
public class LoginTest { | |
public static void main(String[] args) { | |
int a = 3; | |
int b = 4; | |
int c = 5; | |
// & 与，且；有 false 则 false | |
System.out.println((a > b) & (a > c)); | |
System.out.println((a > b) & (a < c)); | |
System.out.println((a < b) & (a > c)); | |
System.out.println((a < b) & (a < c)); | |
System.out.println("==============="); | |
// | 或；有 true 则 true | |
System.out.println((a > b) | (a > c)); | |
System.out.println((a > b) | (a < c)); | |
System.out.println((a < b) | (a > c)); | |
System.out.println((a < b) | (a < c)); | |
System.out.println("==============="); | |
// ^ 异或；相同为 false，不同为 true | |
System.out.println((a > b) ^ (a > c)); | |
System.out.println((a > b) ^ (a < c)); | |
System.out.println((a < b) ^ (a > c)); | |
System.out.println((a < b) ^ (a < c)); | |
System.out.println("==============="); | |
// ! 非；非 false 则 true，非 true 则 false | |
System.out.println(!false); | |
System.out.println(!true); | |
//& 和 & amp;& 的区别 | |
System.out.println((a > b) & (a++ > c)); | |
System.out.println("a = " + a); | |
System.out.println((a > b) && (a++ > c)); | |
System.out.println("a = " + a); | |
System.out.println((a == b) && (a++ > c)); | |
System.out.println("a = " + a); | |
//| 和 || 的区别 | |
System.out.println((a > b) | (a++ > c)); | |
System.out.println("a = " + a); | |
System.out.println((a > b) || (a++ > c)); | |
System.out.println("a = " + a); | |
System.out.println((a == b) || (a++ > c)); | |
System.out.println("a = " + a); | |
} | |
} |
# 7.4.2 案例与练习
案例：
1. 定义类 CompareLogicExer
2. 定义 main方法
3. 定义一个int类型变量a,变量b,都赋值为20
4. 定义boolean类型变量bo1 , 判断++a 是否被3整除,并且a++ 是否被7整除,将结果赋值给bo1
5. 输出a的值,bo1的值
6. 定义boolean类型变量bo2 , 判断b++ 是否被3整除,并且++b 是否被7整除,将结果赋值给bo2
7. 输出b的值,bo2的值
/** | |
* @author 尚硅谷 - 宋红康 | |
* @create 12:42 | |
*/ | |
public class CompareLogicExer { | |
public static void main(String[] args){ | |
int a = 20; | |
int b = 20; | |
boolean bo1 = ((++a % 3) == 0) && ((a++ % 7) == 0); | |
System.out.println("bo1的值：" + bo1); | |
System.out.println("a的值：" + a); | |
System.out.println("----------------------------"); | |
boolean bo2 = ((b++ % 3) == 0) && ((++b % 7) == 0); | |
System.out.println("bo2的值：" + bo2); | |
System.out.println("b的值：" + b); | |
} | |
} |
** 练习 1：** 区分 & 和 &&
int x = 1; | |
int y = 1; | |
if(x++ == 2 & ++y == 2){ // x = 2 , y = 2 | |
x = 7; | |
} | |
System.out.println("x=" + x + ",y=" + y); |
int x = 1,y = 1; | |
if(x++ == 2 && ++y == 2){ // x = 2 , y = 1 | |
x =7; | |
} | |
System.out.println("x="+x+",y="+y); |
** 练习 2：** 区分 | 和 ||
int x = 1,y = 1; | |
if(x++==1 | ++y==1){ | |
x =7; | |
} | |
System.out.println("x="+x+",y="+y); |
int x = 1,y = 1; | |
if(x++==1 || ++y==1){ | |
x =7; | |
} | |
System.out.println("x="+x+",y="+y); |
** 练习 3：** 程序输出
class Test { | |
public static void main (String [] args) { | |
boolean x = true; | |
boolean y = false; | |
short z = 42; | |
if ((z++ == 42) && (y = true)) { // z = 43 | |
z++; // z = 44 | |
} | |
if ((x = false) || (++z == 45)) { | |
z++; | |
} | |
System.out.println("z=" + z); | |
} | |
} |
// 结果为： | |
//z= 46 |
# 7.5 位运算符（难点、非重点）
# 7.5.1 基本语法
- 位运算符的运算过程都是基于二进制的补码运算
（1）左移：<<
运算规则：在一定范围内，数据每向左移动一位，相当于原数据 * 2。（正数、负数都适用）
【注意】
- 当左移的位数 n 超过该数据类型的总位数时，相当于左移（n - 总位数）位
- 空缺位补 0
3<<4 类似于 3*2的4次幂 => 3*16 => 48 |
-3<<4 类似于 -3*2的4次幂 => -3*16 => -48 |
（2）右移：>>
运算规则：在一定范围内，数据每向右移动一位，相当于原数据 / 2。（正数、负数都适用）
【注意】
- 如果不能整除，
向下取整。- 空缺位根据符号位进行补位
69>>4 类似于 69/2的4次 = 69/16 =4 |
-69>>4 类似于 -69/2的4次 = -69/16 = -5
（3）无符号右移：>>>
运算规则：往右移动后，左边空出来的位直接补 0。（正数、负数都适用）
69>>>4 类似于 69/2的4次 = 69/16 =4
-69>>>4 结果：268435451
（4）按位与：&
运算规则：对应位都是 1 才为 1，否则为 0。
1 & 1 结果为 1
1 & 0 结果为 0
0 & 1 结果为 0
0 & 0 结果为 0
9 & 7 = 1 |
-9 & 7 = 7 |
（5）按位或：|
运算规则：对应位只要有 1 即为 1，否则为 0。
1 | 1 结果为 1
1 | 0 结果为 1
0 | 1 结果为 1
0 & 0 结果为 0
9 | 7 // 结果： 15 |
-9 | 7 // 结果： -9 |
（6）按位异或：^
运算规则：对应位一个为 1 一个为 0，才为 1，否则为 0。
1 ^ 1 结果为 0
1 ^ 0 结果为 1
0 ^ 1 结果为 1
0 ^ 0 结果为 0
9 ^ 7 // 结果为 14 |
-9 ^ 7 // 结果为 - 16 |
（7）按位取反：~
运算规则：对应位为 1，则结果为 0；对应位为 0，则结果为 1。
~0 就是 1
~1 就是 0
~9 // 结果：-10 |
~-9 // 结果：8 |
# 7.5.2 举例
举例 1：
举例 2：体会 m = k ^ n = (m ^ n) ^ n
# 7.5.3 案例
** 案例 1：** 高效的方式计算 2 * 8 的值（经典面试题）
答案：2 << 3 、 8 << 1
** 案例 2：** 如何交换两个 int 型变量的值？String 呢？
/** | |
* @author 尚硅谷 - 宋红康 | |
* @create 16:58 | |
*/ | |
public class BitExer { | |
public static void main(String[] args) { | |
int m = 10; | |
int n = 5; | |
System.out.println("m = " + m + ", n = " + n); | |
//（推荐）实现方式 1：优点：容易理解，适用于不同数据类型 缺点：需要额外定义变量 | |
//int temp = m; | |
//m = n; | |
//n = temp; | |
// 实现方式 2：优点：没有额外定义变量 缺点：可能超出 int 的范围；只能适用于数值类型 | |
//m = m + n; //15 = 10 + 5 | |
//n = m - n;//10 = 15 - 5 | |
//m = m - n;//5 = 15 - 10 | |
// 实现方式 3：优点：没有额外定义变量 缺点：不易理解；只能适用于数值类型 | |
m = m ^ n; | |
n = m ^ n; //(m ^ n) ^ n | |
m = m ^ n; | |
System.out.println("m = " + m + ", n = " + n); | |
} | |
} |
# 7.6 条件运算符
# 7.6.1 基本语法
- 条件运算符格式：
(条件表达式)? 表达式1:表达式2 |
说明：条件表达式是 boolean 类型的结果，根据 boolean 的值选择表达式 1 或表达式 2
![image-20220312002841945]()
如果运算后的结果赋给新的变量，要求表达式 1 和表达式 2 为同种或兼容的类型
必须对运算结果进行赋值 / 打印！
public static void main(String[] args) { | |
int i = (1==2 ? 100 : 200); | |
System.out.println(i);//200 | |
boolean marry = false; | |
System.out.println(marry ? "已婚" : "未婚" ); | |
double d1 = (m1 > m2)? 1 : 2.0; | |
System.out.println(d1); // 1.0！！！！！ | |
int num = 12; | |
System.out.println(num > 0? true : "num非正数"); | |
} |
# 7.6.2 案例
** 案例 1：** 获取两个数中的较大值
/** | |
* @author 尚硅谷 - 宋红康 | |
* @create 12:40 | |
*/ | |
public class ConditionExer1 { | |
public static void main(String[] args) { | |
// 获取两个数的较大值 | |
int m1 = 10; | |
int m2 = 20; | |
int max1 = (m1 > m2)? m1 : m2; | |
System.out.println("m1和m2中的较大值为" + max1); | |
} | |
} |
** 案例 2：** 获取三个数中的最大值
/** | |
* @author 尚硅谷 - 宋红康 | |
* @create 12:43 | |
*/ | |
public class ConditionExer2 { | |
public static void main(String[] args) { | |
int n1 = 23; | |
int n2 = 13; | |
int n3 = 33; | |
// 写法 1： | |
int tempMax = (n1 > n2)? n1:n2; | |
int finalMax = (tempMax > n3)? tempMax : n3; | |
System.out.println("三个数中最大值为：" + finalMax); | |
// 写法 2：不推荐，可读性差 | |
int finalMax1 = (((n1 > n2)? n1:n2) > n3)? ((n1 > n2)? n1:n2) : n3; | |
System.out.println("三个数中最大值为：" + finalMax1); | |
} | |
} |
** 案例 3：** 今天是周 2，10 天以后是周几？
要求：控制台输出 "今天是周 2，10 天以后是周 x"。
/** | |
* @author 尚硅谷 - 宋红康 | |
* @create 12:46 | |
*/ | |
public class ConditionExer3 { | |
public static void main(String[] args) { | |
int week = 2; | |
week += 10; | |
week %= 7; | |
System.out.println("今天是周2,10天以后是周" + (week == 0 ? "日" : week)); | |
} | |
} |
# 7.6.3 与 if-else 的转换关系
凡是可以使用条件运算符的地方，都可以改写为 if-else 结构。反之，不成立。
开发中，如果既可以使用条件运算符，又可以使用 if-else，推荐使用条件运算符。因为执行效率稍高。
//if-else 实现获取两个数的较大值 | |
int i1 = 10; | |
int i2 = 20; | |
int max;// 声明变量 max，用于记录 i1 和 i2 的较大值 | |
if(i1 > i2){ | |
max = i1; | |
}else{ | |
max = i2; | |
} | |
System.out.println(max); |
# 7.7 运算符优先级
运算符有不同的优先级，所谓优先级就是在表达式运算中的运算符顺序。
上一行中的运算符总是优先于下一行的。
| 优先级 | 运算符说明 | Java 运算符 |
|---|---|---|
| 1 | 括号 | () 、 [] 、 {} |
| 2 | 正负号 | + 、 - |
| 3 | 单元运算符 | ++ 、 -- 、 ~ 、 ！ |
| 4 | 乘法、除法、求余 | * 、 / 、 % |
| 5 | 加法、减法 | + 、 - |
| 6 | 移位运算符 | << 、 >> 、 >>> |
| 7 | 关系运算符 | < 、 <= 、 >= 、 > 、 instanceof |
| 8 | 等价运算符 | == 、 != |
| 9 | 按位与 | & |
| 10 | 按位异或 | ^ |
| 11 | 按位或 | | |
| 12 | 条件与 | && |
| 13 | 条件或 | || |
| 14 | 三元运算符 | ? : |
| 15 | 赋值运算符 | = 、 += 、 -= 、 *= 、 /= 、 %= |
| 16 | 位赋值运算符 | &= 、 |= 、 <<= 、 >>= 、 >>>= |
开发建议：
- 不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读性太差，尽量
使用()来控制表达式的执行顺序。- 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它
分成几步来完成。例如：
(num1 + num2) * 2 > num3 && num2 > num3 ? num3 : num1 + num2;
# 8. 【拓展】关于字符集
# 8.1 字符集
- 编码与解码
计算机中储存的信息都是用 二进制数 表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为 编码 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为 解码 。
字符编码（Character Encoding） : 就是一套自然语言的字符与二进制数之间的对应规则。
字符集：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。
# 8.2 ASCII 码
- ASCII 码（American Standard Code for Information Interchange，美国信息交换标准代码）：上个世纪 60 年代，美国制定了一套字符编码，对
英语字符与二进制位之间的关系，做了统一规定。这被称为 ASCII 码。 - ASCII 码用于显示现代英语，主要包括控制字符（回车键、退格、换行键等）和可显示字符（英文大小写字符、阿拉伯数字和西文符号）。
- 基本的 ASCII 字符集，使用 7 位（bits）表示一个字符（最前面的 1 位统一规定为 0），共
128个字符。比如：空格 “SPACE” 是 32（二进制 00100000），大写的字母 A 是 65（二进制 01000001）。 - 缺点：不能表示所有字符。
# 8.3 ISO-8859-1 字符集
- 拉丁码表，别名 Latin-1，用于显示欧洲使用的语言，包括荷兰语、德语、意大利语、葡萄牙语等
- ISO-8859-1 使用单字节编码，兼容 ASCII 编码。
# 8.4 GBxxx 字符集
- GB 就是国标的意思，是为了
显示中文而设计的一套字符集。 - GB2312：简体中文码表。一个小于 127 的字符的意义与原来相同，即向下兼容 ASCII 码。但两个大于 127 的字符连在一起时，就表示一个汉字，这样大约可以组合了包含
7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名们都编进去了，这就是常说的 "全角" 字符，而原来在 127 号以下的那些符号就叫 "半角" 字符了。 - GBK：最常用的中文码表。是在 GB2312 标准基础上的扩展规范，使用了
双字节编码方案，共收录了21003个汉字，完全兼容 GB2312 标准，同时支持繁体汉字以及日韩汉字等。 - GB18030：最新的中文码表。收录汉字
70244个，采用多字节编码，每个字可以由 1 个、2 个或 4 个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等。
# 8.5 Unicode 码
**Unicode** 编码为表达
任意语言的任意字符而设计，也称为统一码、标准万国码。Unicode 将世界上所有的文字用2个字节统一进行编码，为每个字符设定唯一的二进制编码，以满足跨语言、跨平台进行文本处理的要求。Unicode 的缺点：这里有三个问题：
- 第一，英文字母只用一个字节表示就够了，如果用更多的字节存储是
极大的浪费。 - 第二，如何才能
区别Unicode和ASCII？计算机怎么知道两个字节表示一个符号，而不是分别表示两个符号呢？ - 第三，如果和 GBK 等双字节编码方式一样，用最高位是 1 或 0 表示两个字节和一个字节，就少了很多值无法用于表示字符，
不够表示所有字符。
- 第一，英文字母只用一个字节表示就够了，如果用更多的字节存储是
Unicode 在很长一段时间内无法推广，直到互联网的出现，为解决 Unicode 如何在网络上传输的问题，于是面向传输的众多 UTF（UCS Transfer Format）标准出现。具体来说，有三种编码方案，UTF-8、UTF-16 和 UTF-32。
# 8.6 UTF-8
- Unicode 是字符集，UTF-8、UTF-16、UTF-32 是三种
将数字转换到程序数据的编码方案。顾名思义，UTF-8 就是每次 8 个位传输数据，而 UTF-16 就是每次 16 个位。其中，UTF-8 是在互联网上使用最广的一种 Unicode 的实现方式。 - 互联网工程工作小组（IETF）要求所有互联网协议都必须支持 UTF-8 编码。所以，我们开发 Web 应用，也要使用 UTF-8 编码。UTF-8 是一种
变长的编码方式。它可以使用 1-4 个字节表示一个符号它使用一至四个字节为每个字符编码，编码规则：- 128 个 US-ASCII 字符，只需一个字节编码。
- 拉丁文等字符，需要二个字节编码。
- 大部分常用字（含中文），使用三个字节编码。
- 其他极少使用的 Unicode 辅助字符，使用四字节编码。
- 举例
Unicode 符号范围 | UTF-8 编码方式
(十六进制) | （二进制）
————————————————————|—–—–—–—–—–—–—–—–—–—–—–—–—–—–
0000 0000-0000 007F | 0xxxxxxx（兼容原来的ASCII）
0000 0080-0000 07FF | 110xxxxx 10xxxxxx
0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
# 8.7 小结
注意：在中文操作系统上，ANSI（美国国家标准学会、AMERICAN NATIONAL STANDARDS INSTITUTE: ANSI）编码即为 GBK；在英文操作系统上，ANSI 编码即为 ISO-8859-1。
