2023最新版JavaSE教程——第2天：变量与运算符

一、关键字(keyword)

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（或单词）。 在 HelloWorld 案例中，出现的关键字有 class,public,static,void 等，这些单词已经被 Java 定义好了。

1. 特点：全部关键字都是小写字母。
2. 关键字比较多，不需要死记硬背，学到哪里记到哪里即可。
   
3. 官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

说明：关键字一共 50个，其中 const 和 goto 是 保留字(reserved word)。true,false,null 不在其中，它们看起来像关键字，其实是字面量，表示特殊的布尔值和空值。

二、标识符(identifier)

Java 中变量、方法、类等要素命名时使用的字符序列，称为标识符。技巧：凡是自己可以起名字的地方都叫标识符。标识符的命名规则(必须遵守的 硬性规定)：

1.由26个英文字母大小写，0-9 ，_或 $ 组成  
2.数字不可以开头。
3.不可以使用关键字和保留字，但能包含关键字和保留字。
4.Java中严格区分大小写，长度无限制。
5.标识符不能包含空格。

练习：miles、Test、a++、 --a、4#R、$4、 #44、apps、class、public、int、x、y、radius
1
2
3
4
5
6
7

标识符的命名规范(建议遵守的 软性要求，否则工作时容易被鄙视)：

包名：多单词组成时所有字母都小写：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

注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

三、变量

3.1 为什么需要变量

一花一世界，如果把一个程序看做一个世界或一个社会的话，那么变量就是程序世界的花花草草、万事万物。即，变量是程序中不可或缺的组成单位，最基本的存储单元。

3.2 初识变量

变量的概念：内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化

变量的构成包含三个要素：数据类型、变量名、存储的值

Java 中变量声明的格式：数据类型 变量名 = 变量值

变量的作用：用于在内存中保存数据。使用变量注意：

1. Java中每个变量必须先声明，后使用。
2. 使用变量名来访问这块区域的数据。
3. 变量的作用域：其定义所在的一对 {} 内。
4. 变量只有在其 作用域 内才有效。出了作用域，变量不可以再被调用。
5. 同一个作用域内，不能定义重名的变量。

3.3 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类型。
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意：变量的数据类型可以是基本数据类型，也可以是引用数据类型。

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 = "迪丽热巴";
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

内存结构如下图所示：

四、基本数据类型介绍

4.1 整数类型：byte、short、int、long

Java 各整数类型有固定的表数范围和字段长度，不受具体操作系统的影响，以保证 Java 程序的可移植性。

定义 long 类型的变量，赋值时需要以 l 或 L 作为后缀。Java 程序中变量通常声明为 int 型，除非不足以表示较大的数，才使用 long。Java 的整型 常量默认为 int 型。

4.1.1 补充：计算机存储单位

字节(Byte)： 是计算机用于 计量存储容量 的 基本 单位，一个字节等于 8bit。位(bit)： 是数据存储的 最小 单位。二进制数系统中，每个0或1就是一个位，叫做 bit(比特)， 其中 8bit 就称为一个字节(Byte)。转换关系：

8 bit = 1 Byte
1024 Byte = 1 KB
1024 KB = 1 MB
1024 MB = 1 GB
1024 GB = 1 TB
1
2
3
4
5

4.2 浮点类型：float、double

与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。

浮点型常量有两种表示形式：

十进制数形式。如：5.12 512.0f .512(必须有小数点)
科学计数法形式。如：5.12e2 512E2 100E-2
1
2

float：单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。double：双精度，精度是 float 的两倍。通常采用此类型。定义 float 类型的变量，赋值时需要以 f 或 F 作为后缀。Java 的浮点型 常量默认为double型。

4.2.1 关于浮点型精度的说明

并不是所有的小数都能可以精确的用二进制浮点数表示。二进制浮点数不能精确的表示 0.1、0.01、0.001 这样10的负次幂。浮点类型 float、double 的数据不适合在 不容许舍入误差 的金融计算领域。如果需要 精确 数字计算或保留指定位数的精度，需要使用 BigDecimal类。测试用例：

//测试1：
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);
1
2
3
4
5
6
7
8

4.2.2 应用举例

案例1：定义圆周率并赋值为3.14，现有3个圆的半径分别为1.2、2.5、6，求它们的面积。

/**
 * @author AmoXiang
 * @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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

案例2：小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。它需要一个程序将华氏温度(80度)转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。℃ = (℉ - 32) / 1.8

/**
 * @author AmoXiang
 * @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+"℃");
    }
}
1
2
3
4
5
6
7
8
9
10
11

4.3 字符类型：char

char 型数据用来表示通常意义上 字符(占2字节)。Java 中的所有字符都使用 Unicode 编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。字符型变量的三种表现形式：

形式1：使用单引号(' ')括起来的单个字符。
例如：char c1 = 'a';   char c2 = '中'; char c3 =  '9';

形式2：直接使用Unicode值来表示字符型常量：'\uXXXX'。其中，XXXX代表一个十六进制整数。
例如：\u0023 表示 '#'。

形式3：Java中还允许使用转义字符'\'来将其后的字符转变为特殊字符型常量。
例如：char c3 = '\n';  // '\n'表示换行符
| 转义字符 |  说明  | Unicode表示方式 |
| :------: | :----: | :-------------: |
|   \n   | 换行符 |     \u000a      |
|   \t   | 制表符 |     \u0009      |
|   \"   | 双引号 |     \u0022      |
|   \'   | 单引号 |     \u0027      |
|   \\   | 反斜线 |     \u005c      |
|   \b   | 退格符 |     \u0008      |
|   \r   | 回车符 |     \u000d      |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

char 类型是可以进行运算的。因为它都对应有 Unicode 码，可以看做是一个数值。

4.4 布尔类型：boolean

boolean 类型用来判断逻辑条件，一般用于流程控制语句中：

1. if 条件控制语句
2. while 循环控制语句
3. for 循环控制语句
4. 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分支
}
1
2
3
4
5
6

经验之谈：Less is More！建议不要这样写：if(isFlag == true)，只有新手才如此。关键也很容易写错成 if(isFlag = true)，这样就变成赋值 isFlag 为 true 而不是判断！老鸟的写法 是 if(isFlag) 或者 if(!isFlag)。

五、基本数据类型变量间运算规则

在 Java 程序中，不同的基本数据类型(只有7种，不包含 boolean 类型) 变量的值经常需要进行相互转换。转换的方式有两种：自动类型提升 和 强制类型转换。

5.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类型。否则编译不通过
1
2
3
4
5

② 当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算。

int i = 1;
byte b = 1;
double d = 1.0;
double sum = i + b + d;//混合运算，升级为double
1
2
3
4

③ 当 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 
1
2
3
4
5
6
7
8

练习：

设 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
1
2
3

5.2 强制类型转换

将 3.14 赋值到 int 类型变量会发生什么？产生编译失败，肯定无法赋值。

int i = 3.14; // 编译报错
1

想要赋值成功，只有通过 强制类型转换，将 double 类型强制转换成 int 类型才能赋值。

规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型。 自动类型提升是 Java 自动执行的，而强制类型转换是自动类型提升的逆运算，需要我们自己手动执行。转换格式：

数据类型1 变量名 = (数据类型1)被强转数据值; //()中的数据类型必须<=变量值的数据类型
1

① 当把存储范围大的值(常量值、变量的值、表达式计算的结果值)强制转换为存储范围小的变量时，可能会 损失精度 或 溢出。

int i = (int)3.14;//损失精度
double d = 1.2;
int num = (int)d;//损失精度
int i = 200;
byte b = (byte)i;//溢出
1
2
3
4
5

② 当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是 没有风险 的，通常省略。

int i = 1;
int j = 2;
double bigger = (double)(i/j);
1
2
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
2
3
4
5
6
7

练习：判断是否能通过编译

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
1
2
3
4
5
6
7
8
9
10
11
12

问答：为什么标识符的声明规则里要求不能数字开头？

//如果允许数字开头，则如下的声明编译就可以通过：
int 123L = 12;
//进而，如下的声明中l的值到底是123？还是变量123L对应的取值12呢？ 出现歧义了。
long l = 123L;
1
2
3
4

5.3 基本数据类型与String的运算

5.3.1 字符串类型：String

String 不是基本数据类型，属于引用数据类型。使用一对 "" 来表示一个字符串，内部可以包含0个、1个或多个字符。声明方式与基本数据类型类似。例如：String str = "唱奢香夫人，做气质男人";

5.3.2 运算规则

① 任意八种基本数据类型的数据与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);//编译通过
1
2
3
4
5
6
7
8
9
10

② String 类型不能通过强制类型()转换，转为其他的类型：

String str = "123";
int num = (int)str;//错误的

int num = Integer.parseInt(str);//正确的，后面才能讲到，借助包装类的方法才能转
1
2
3
4

5.3.3 案例与练习

案例：公安局身份登记。 要求填写自己的姓名、年龄、性别、体重、婚姻状况(已婚用 true 表示，单身用 false 表示)、联系方式等等。

/**
 * @author AmoXiang
 * @create 12:34
 */
public class Info {
    public static void main(String[] args) {
        String name = "AmoXiang";
        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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

练习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);     //输出：
1
2
3
4
5
6
7

练习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' + '*');		//输出：
1
2
3
4
5
6
7
8

六、计算机底层如何存储数据

计算机组成原理之数据的表示和运算（一）：https://blog.csdn.net/xw1680/article/details/132417469
代码演示：

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);

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

七、运算符(Operator)(掌握）

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。运算符的分类：按照 功能 分为：算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、Lambda运算符

按照 操作数个数 分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）

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
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

举例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
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

举例3：自加自减运算。 理解：++ 运算，表示 自增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);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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);
        
	} 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

7.1.2 案例与练习

案例1：

随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：

例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1
/**
 * @author AmoXiang
 * @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);

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

拓展：获取一个四位数的个位，十位，百位，千位

/**
 * @author AmoXiang
 * @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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

案例2： 为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？

/**
 * @author AmoXiang
 * @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
2
3
4
5
6
7
8
9
10
11
12
13

练习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);//
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

练习2：

System.out.println("5+5=" + 5 + 5); //打印结果是？ 5+5=55 ?
1

练习3：

byte bb1 = 127;
bb1++;
System.out.println("bb1 = " + bb1);//-128
1
2
3

练习4：

int i = 1;
int j = i++ + ++i * i++;
System.out.println("j = " + j);
1
2
3

练习5：（企业真题）写出下列程序的输出结果

int i = 2;
int j = i++;
System.out.println(j);

int m = 2;
m = m++; //(1)先取b的值2放操作数栈 (2)m再自增,m=3 (3)再把操作数栈中的2赋值给m,m=2
System.out.println(m);
1
2
3
4
5
6
7

7.2 赋值运算符

7.2.1 基本语法

符号：=。当 = 两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。支持 连续赋值。扩展赋值运算符： +=、 -=、*=、 /=、%=

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);

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

7.2.2 练习

练习1：

short s = 3; 
s = s+2;  //① 编译报错
s += 2;   //② 正常执行

//①和②有什么区别？ 
1
2
3
4
5

练习2：

int i = 1;
i *= 0.1;
System.out.println(i);//0
i++;
System.out.println(i);//1
1
2
3
4
5

练习3：

int m = 2;
int n = 3;
n *= m++; 	//n = n * m++;
System.out.println("m=" + m);//3
System.out.println("n=" + n);//6
1
2
3
4
5

练习4：

int n = 10;
n += (n++) + (++n);  //n = n + (n++) + (++n)
System.out.println(n);//32
1
2
3

练习5：你有几种办法实现变量值减1？变量值减2呢？

/**
 * @author AmoXiang
 * @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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

思考：

boolean b1 = false;
//区分好==和=的区别。
if(b1 == true)  //if(b1 = true)
	System.out.println("结果为真");
else
	System.out.println("结果为假");
1
2
3
4
5
6

7.4 逻辑运算符

7.4.1 基本语法

逻辑运算符，操作的都是 boolean 类型的变量或常量，而且运算得结果也是 boolean 类型的值。运算符说明：

1. & 和 &&：表示 且 关系，当符号左右两边布尔值都是 true 时，结果才能为 true。否则，为 false。
2. | 和 || ：表示 或 关系，当符号两边布尔值有一边为 true 时，结果为 true。当两边都为 false 时，结果为 false
3. ! ：表示 非 关系，当变量布尔值为 true 时，结果为 false。当变量布尔值为 false 时，结果为 true。
4. ^ ：当符号左右两边布尔值不同时，结果为 true。当两边布尔值相同时，结果为 false。理解：异或，追求的是"异"!

逻辑运算符用于连接布尔型表达式，在 Java 中不可以写成 3 < x < 6，应该写成 x > 3 & x < 6。区分“&”和“&&”：

1. 相同点：如果符号左边是 true，则二者都执行符号右边的操作
2. 不同点：& ： 如果符号左边是 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);
        
        //&和&&的区别
        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);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

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 AmoXiang
 * @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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

练习1： 区分 & 和 &&

int x = 1;
int y = 1;

if(x++ == 2 & ++y == 2){
	x = 7;
}
System.out.println("x=" + x + ",y=" + y);
/*------------------------------------------------------------*/
int x = 1,y = 1;
if(x++ == 2 && ++y == 2){
	x =7;
}
System.out.println("x="+x+",y="+y);
1
2
3
4
5
6
7
8
9
10
11
12
13

练习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);
1
2
3
4
5
6
7
8
9
10
11
12

练习3： 程序输出

class  Test  {
	public static void main (String []  args)  {
		boolean x = true;
        boolean y = false;
        short z = 42;
        
        if ((z++ == 42) && (y = true)) {
            z++;
        }
        if ((x = false) || (++z == 45)) {
            z++;
        }

        System.out.println("z=" + z);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

7.5 位运算符(难点)

7.5.1 基本语法

位运算符的运算过程都是基于二进制的补码运算

① 左移：<<。 运算规则：在一定范围内，数据每向左移动一位，相当于原数据*2。(正数、负数都适用)【注意】当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位

3<<4 类似于 32的4次幂 => 316 => 48

-3<<4 类似于 -32的4次幂 => -316 => -48

② 右移：>>。 运算规则：在一定范围内，数据每向右移动一位，相当于原数据/2。(正数、负数都适用)【注意】如果不能整除，向下取整。

69>>4 类似于 69/2的4次 = 69/16 =4

-69>>4 类似于 -69/2的4次 = -69/16 = -5

③ 无符号右移：>>>。 运算规则：往右移动后，左边空出来的位直接补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

⑤ 按位或：| 运算规则：对应位只要有1即为1，否则为0。1 | 1 结果为1 1 | 0 结果为1 0 | 1 结果为1 0 & 0 结果为0

9 | 7 //结果： 15

-9 | 7 //结果： -9

⑥ 按位异或：^。 运算规则：对应位一个为1一个为0，才为1，否则为0。1 ^ 1 结果为0 1 ^ 0 结果为1 0 ^ 1 结果为1 0 ^ 0 结果为0

9 ^ 7 //结果为14

-9 ^ 7 //结果为-16

⑦ 按位取反：~。 运算规则：对应位为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
1

案例2： 如何交换两个 int 型变量的值？String 呢？

/**
 * @author AmoXiang
 * @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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

7.6 条件运算符

7.6.1 基本语法

条件运算符格式：

(条件表达式)? 表达式1:表达式2
1

说明：条件表达式是 boolean 类型的结果，根据 boolean 的值选择表达式1或表达式2

如果运算后的结果赋给新的变量，要求表达式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);
    
    int num = 12;
    System.out.println(num > 0? true : "num非正数");
}
1
2
3
4
5
6
7
8
9
10
11
12
13

7.6.2 案例

案例1： 获取两个数中的较大值

/**
 * @author AmoXiang
 * @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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

案例2： 获取三个数中的最大值

/**
 * @author AmoXiang
 * @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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

案例3： 今天是周2，10天以后是周几？要求：控制台输出 今天是周2，10天以后是周x。

/**
 * @author AmoXiang
 * @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));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

7.7 运算符优先级

运算符有不同的优先级，所谓优先级就是在表达式运算中的运算符顺序。上一行中的运算符总是优先于下一行的。

开发建议：

1. 不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读性太差，尽量 使用()来控制 表达式的执行顺序。
2. 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它 分成几步 来完成。例如：(num1 + num2) * 2 > num3 && num2 > num3 ? num3 : num1 + num2;

八、【拓展】关于字符集

参考 C语言系统化精讲（一）：编程基础：https://blog.csdn.net/xw1680/article/details/134001443 一文中的 八、字符编码 小节

至此今天的学习就到此结束了，笔者在这里声明，笔者写文章只是为了学习交流，以及让更多学习Java语言的读者少走一些弯路，节省时间，并不用做其他用途，如有侵权，联系博主删除即可。感谢您阅读本篇博文，希望本文能成为您编程路上的领航者。祝您阅读愉快！

---

    好书不厌读百回，熟读课思子自知。而我想要成为全场最靓的仔，就必须坚持通过学习来获取更多知识，用知识改变命运，用博客见证成长，用行动证明我在努力。
    如果我的博客对你有帮助、如果你喜欢我的博客内容，请 点赞、评论、收藏 一键三连哦！听说点赞的人运气不会太差，每一天都会元气满满呦！如果实在要白嫖的话，那祝你开心每一天，欢迎常来我博客看看。
 编码不易，大家的支持就是我坚持下去的动力。点赞后不要忘了 关注 我哦！