目录
一、变量和类型
1. 整形变量
基本语法格式：
int 变量名 = 初始值;
代码示例：
int num = 10; // 定义一个整型变量
System.out.println(num);
注意事项：
-
int 表示变量的类型是一个整型
-
变量名是变量的标识，后续都是通过这个名字来使用变量
-
Java 中 = 表示赋值(和数学不一样)，意思是给变量赋一个初始值
-
初始化操作是可选的，但是建议创建变量的时候都初始化
-
最后不要忘记分号，否则会编译失败
-
// 表示注释，注释作为代码的解释说明部分，不参与编译运行
-
在 Java 中， 一个 int 变量占 4 个字节，和操作系统没有直接关系
什么是字节?
字节是计算机中表示空间大小的基本单位
计算机使用二进制表示数据，我们认为 8 个二进制位(bit) 为一个字节(Byte)
我们平时的计算机为 8GB 内存，意思是 8G 个字节
其中 1KB = 1024 Byte，1MB = 1024 KB, 1GB = 1024 MB
所以 8GB 相当于 80 多亿个字节
2. 短整型变量
基本语法格式：
short 变量名 = 初始值;
代码示例：
short value = 0;
System.out.println(value);
注意事项：
-
short 占用 2 个字节, 表示的数据范围是 -32768 -> +32767
-
这个表示范围比较小, 一般不推荐使用
3. 长整形变量
基本语法格式：
long 变量名 = 初始值;
代码示例：
long num = 10L; // 定义一个长整型变量, 初始值写作 10l 也可以(小写的 L, 不是数字1).
System.out.println(num);
注意事项：
-
基本语法格式和创建 int 变量基本一致, 只是把类型修改成 long
-
初始化设定的值为 10L , 表示一个长整型的数字 10l 也可以
-
使用 10 初始化也可以, 10 的类型是 int, 10L 的类型是 long, 使用 10 L 或者 10 l 更好一些
4. 双精度浮点型变量
基本语法格式：
double 变量名 = 初始值;
代码示例：
double num = 1.0;
System.out.println(num);-
Java 中的 double 虽然也是 8 个字节, 但是浮点数的内存布局和整数差别很大, 不能单纯的用 2 ^ n 的形式表示数据范围
-
Java 的 double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差
代码示例：
double num = 1.1;
System.out.println(num * num)
// 执行结果
1.2100000000000002
5. 单精度浮点型变量
基本语法格式：
float 变量名 = 初始值;
代码示例：
float num = 1.0f; // 写作 1.0F 也可以
System.out.println(num);
注意事项：
-
float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 float
6. 字符型变量
基本语法格式：
char 变量名 = 初始值;
代码示例：
char ch = 'A';
注意事项：
-
Java 中使用 单引号 + 单个字母 的形式表示字符字面值
-
计算机中的字符本质上是一个整数，在 C 语言中使用 ASCII 表示字符，而 Java 中使用 Unicode 表示字符，因此一个字符占用两个字节，表示的字符种类更多，包括中文
7. 字节型变量
基本语法格式：
byte 变量名 = 初始值;
代码示例：
byte value = 0;
System.out.println(value);
注意事项：
-
字节类型表示的也是整数只占一个字节, 表示范围较小 ( -128 -> +127 )
-
字节类型和字符类型互不相干
8. 字符串类型变量
基本语法格式：
String 变量名 = "初始值";
代码示例：
String name = "zhangsan";
System.out.println(name);
注意事项：
-
Java 使用 双引号 + 若干字符 的方式表示字符串字面值
-
和上面的类型不同, String 不是基本类型, 而是引用类型(后面重点解释)
-
字符串中的一些特定的不太方便直接表示的字符需要进行转义
9. 布尔类型变量
基本语法格式：
boolean 变量名 = 初始值;
代码示例：
boolean value = true;
System.out.println(value);
注意事项：
-
boolean 类型的变量只有两种取值, true 表示真, false 表示假
-
Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法
-
boolean 类型有些 JVM 的实现是占 1 个字节, 有些是占 1 个比特位, 这个没有明确规定
二、运算符
1. 算数运算符
1.1 四则运算符：
+ – * /
四则运算符与数学上的四则运算基本一致，除数同样不能为0，并且：
int / int 结果还是 int，需要使用 double 来计算
int a = 1;
int b = 2;
System.out.println(a / b);
// 结果为 0
1.2 取模运算符：
%
% 其实就是取两个数相除之后的余数，不仅仅可以对 int 求模, 也能对 double 来求模
System.out.println(11.5%2.0);
System.out.println(11%2);
// 执行结果
1.5
1
1.3 增量赋值运算符：
+= -= *= /= %=
int a = 10;
a += 1; // 等价于 a = a + 1
System.out.println(a);
// 执行结果
11
1.4 自增/自减运算符：
++ —
int a = 10;
int b = ++a;
System.out.println(b);
int c = a++;
System.out.println(c);
// 执行结果
11
11
结论:
-
如果不取自增运算的表达式的返回值，则前置自增和后置自增没有区别
-
如果取表达式的返回值，则前置自增的返回值是自增之后的值，后置自增的返回值是自增之前的值
-
自减与自增的运算是一样的，只不过自增是+1，自减则-1
2. 关系运算符
关系运算符主要有六个：
== != < > <= >=
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);
// 执行结果
true
false
true
false
注意: 关系运算符的表达式返回值都是 boolean 类型
3. 逻辑运算符
逻辑运算符主要有三个：
&& || !
3.1 逻辑与：&&
规则：两个操作数都为 true, 结果为 true, 否则结果为 false
int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b && b < c);
// 执行结果
true
3.2 逻辑或：||
规则：两个操作数都为 false, 结果为 false, 否则结果为 true
int a = 10;
int b = 20;
int c = 30;
System.out.println(a < b || b < c);
// 执行结果
true
3.3 逻辑非：!
规则: 操作数为 true，结果为 false；操作数为 false，结果为 true
int a = 10;
int b = 20;
System.out.println(!(a < b));
// 执行结果
false
3.4 短路求值：
&& 和 || 遵守短路求值的规则
System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true
我们都知道, 计算 10 / 0 会导致程序抛出异常，但是上面的代码却能正常运行，说明 10 / 0 并没有真正被求值
结论:
-
对于 && , 如果左侧表达式值为 false, 则表达式的整体的值一定是 false, 无需计算右侧表达式
-
对于 ||, 如果左侧表达式值为 true, 则表达式的整体的值一定是 true, 无需计算右侧表达式
3.5 & 和 |
& 和 | 如果操作数为 boolean 时, 也表示逻辑运算. 但是和 && 以及 || 相比, 它们不支持短路求值
System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常
4. 位运算符
位运算符主要有四个：
& | ~ ^
位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算
4.1 按位与 &：
如果两个二进制位都是 1, 则结果为 1, 否则结果为 0
int a = 10;
int b = 20;
System.out.println(a & b); // 结果为 0
// 按位 &
10的二进制： 00000000 00000000 00000000 00001010
20的二进制： 00000000 00000000 00000000 00010100
---------------------------------------------------
按位&的结果: 00000000 00000000 00000000 00000000
4.2 按位或 |：
如果两个二进制位都是 0, 则结果为 0, 否则结果为 1
int a = 10;
int b = 20;
System.out.println(a | b); // 结果为 30
// 按位 |
10的二进制： 00000000 00000000 00000000 00001010
20的二进制： 00000000 00000000 00000000 00010100
---------------------------------------------------
按位|的结果: 00000000 00000000 00000000 00000000
注意：当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表示逻辑运算
4.3 按位取反 ~：
如果该位为 0 则转为 1, 如果该位为 1 则转为 0
int a = 0xf;
System.out.printf("%x\n", ~a); // 结果为 fffffff0
// 按位 ~
a的二进制： 00000000 00000000 00000000 00000001
---------------------------------------------------
按位~的结果：00000000 00000000 00000000 11111110
注意:
-
0x 前缀的数字为 十六进制 数字，十六进制可以看成是二进制的简化表示方式，一个十六进制数字对应 4 个二进制位（一个32位的二进制数可以用8位十六进制表示）
-
0xf 表示 10 进制的 15，也就是二进制的 1111
-
printf 能够格式化输出内容，%x 表示按照十六进制输出.
-
\n 表示换行符
4.4 按位异或 ^：
如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1
int a = 1;
int b = 2;
System.out.printf(a ^ b);// 结果为 3
// 按位 ^
a的二进制： 00000000 00000000 00000000 00000001
b的二进制： 00000000 00000000 00000000 00000010
----------------------------------------------------
按位^的结果：00000000 00000000 00000000 00000011
5. 移位运算符
移位运算符有三个：
<< >> >>>
都是按照二进制位来运算
5.1 左移 <<：
最左侧位不要了, 最右侧补 0
int a = 10;
System.out.println(a<<1); // 结果为 20
// 左移1位
a的二进制：00000000 00000000 00000000 00001010
-------------------------------------------------
a左移一位：00000000 00000000 00000000 00010100
5.2 右移 >>：
最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)
int a = 10;
System.out.println(a>>1); // 结果为 5
// 右移1位
a的二进制：00000000 00000000 00000000 00001010
-------------------------------------------------
a右移一位：00000000 00000000 00000000 00000101
5.3 无符号右移 >>>：
最右侧位不要了, 最左侧补 0
int a = -1;
System.out.println(a>>>1); // 结果为 2147483647
// 无符号右移 >>>
a 的二进制原码：10000000 00000000 00000000 00000001
a 的二进制反码：11111111 11111111 11111111 11111110
a 的二进制补码：11111111 11111111 11111111 11111111
----------------------------------------------------------
补码无符号右移：01111111 11111111 11111111 11111111
注意:
-
左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
-
右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
-
计算机计算移位效率比乘除要搞, 当某个代码正好乘除 2 的N次方时可以用移位运算代替
-
移动负数位或者移位位数过大都没有意义
6. 条件运算符
条件运算符只有一个:
表达式1 ? 表达式2 : 表达式3
当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值; 当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.
// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;
System.out.println(max);
// 执行结果
20
7. 运算符的优先级
先看一段代码
System.out.println(1 + 2 * 3);
结果为 7, 说明先计算了 2*3 , 再计算 加法
另外一个例子
System.out.println(10 < 20 && 20 < 30);此时明显是先计算的 10 < 20 和 20 < 30, 再计算 &&. 否则 20 && 20 这样的操作是语法上有误的(&& 的操作数只能是boolean)
结论：
运算符之间是有优先级的，具体的规则我们不必记忆，在可能存在歧义的代码中加上括号即可
三、注释
Java中的注释主要分为以下三种
单行注释：// 注释内容
多行注释：/* 注释内容*/
文档注释：/** 文档注释 */（常见于方法和类之上描述方法和类的作用)，可用来自动生成文档