关键字
概述
被Java语言赋予了特殊含义的单词。
特点
关键字中所有字母都为小写。
这里将Java语言中的关键字列出如下：
| 用于定义数据类型的关键字 | ||||
|---|---|---|---|---|
| class | interface | byte | short | int |
| long | float | double | char | boolean |
| void | ||||
| 用于定义数据类型值的关键字 | ||||
| true | false | null | ||
| 用于定义流程控制的关键字 | ||||
| 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 | ||||
| 其他修饰符关键字 | ||||
| native | strictfp | transient | volatile | assert |
标识符
概述
在程序中自定义的一些名称，就是给类、接口、方法、变量等起名字时使用的字符序列。
组成规则
由26个英文字母大小写，数字： 0-9，符号： _、$ 组成。
注意事项
定义合法标识符时须注意：
- 数字不可以开头。
- 不可以使用关键字。
- Java语法中严格区分大小写。
标识符常见命名规则
在起名字的时候，为了提高阅读性，要尽量有意义，即能见名知意。下面就是标识符常见的命名规范：
- 包名：多单词组成时所有字母都小写。例，xxxyyyzzz。
- 类名、接口名：多单词组成时，所有单词的首字母大写。例，XxxYyyZzz。
- 变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。例，xxxYyyZzz。
- 常量名：所有字母都大写。多单词时每个单词用下划线连接。例，XXX_YYY_ZZZ。
注释
概述
用于注解说明解释程序的文字。
Java中的注释格式
- 单行注释，格式：
//注释文字 - 多行注释，格式：
/* 注释文字 */ - 文档注释，格式：
/** 注释文字 */
初学者编写程序应该养成习惯：先写注释再写代码。将自己的思想通过注释先整理出来，在用代码去体现，因为代码仅仅是思想的一种体现形式而已。例如：
/**
这个类是用于演示hello world.
作者：李阿昀
版本：V1.0
*/
class Demo {
/*
main函数可以保证该类的独立运行
它是程序的入口
它会被JVM所调用
*/
public static void main(String[] args) {
//这是输出语句用于将括号内的数据打印到控制台。
System.out.println("hello java");
System.out.println("hello world");
}
}- 对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行。
- 对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档。
- 注释是一个程序员必须要具有的良好编程习惯。
常量
概述
表示不能改变的数值。
Java中常量的分类
- 整数常量。所有整数。
- 小数常量。所有小数。
- 布尔型常量。较为特殊，只有两个数值：true、false。
- 字符常量。将一个数字、字母或者符号用单引号( ’ ’ )标识。
- 字符串常量。将一个或者多个字符用双引号标识。
- null常量。只有一个数值就是：null。
Java针对整数常量提供了四种表现形式
- 十进制：0-9，满10进1。
- 八进制：0-7，满8进1，用0开头表示。
- 十六进制：0-9、A-F，满16进1，用0x或0X开头表示。
- 二进制：0、1，满2进1。
负数在计算机内存中的二进制表现形式
负数在计算机内存中的二进制表现形式为对应的正数二进制取反加1，所以(在计算机内存中的二进制形式表现的)负数转换成十进制数就应该这样计算：对应的负数二进制减1取反，转成十进制数，最后前面加一个-。
变量
概述
内存中的一个存储区域，该区域有自己的名称（变量名）和类型（数据类型），该区域的数据可以在同一类型范围内不断变化。我们可以理解为变量就如同数学中的未知数。
格式
数据类型 变量名 = 初始化值;。
注：格式是固定的，记住格式，以不变应万变。
为什么要定义变量？
用来不断的存放同一类型的常量，并可以重复使用。(即当数据不确定时，需要对数据进行存储时，就定义一个变量来完成存储动作。)
数据类型和类型转换
数据类型
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。如图：
这里，着重讲解基本数据类型，Java语言中的基本数据类型有：
| 数据类型 | 说明 | 所占内存 | 举例 | 备注 |
|---|---|---|---|---|
| byte | 字节型 | 1 byte | 3, 127 | |
| short | 短整型 | 2 bytes | 3, 32767 | |
| int | 整型 | 4 bytes | 3, 21474836 | |
| long | 长整型 | 8 bytes | 3L, 92233720368L | long最后要有一个L字母(大小写无所谓) |
| float | 单精度浮点型 | 4 bytes | 1.2F, 223.56F | float最后要有一个F字母(大小写无所谓) |
| double | 双精度浮点型 | 8 bytes | 1.2, 1.2D, 223.56, 223.56D | double最后最好要有一个D字母(大小写无所谓) |
| char | 字符型 | 2 bytes | ‘a’, ‘A’ | 字符型数据只能是一个字符，由单引号包围 |
| boolean | 布尔型 | 1 bit | true, false |
注意：整数默认为int，小数默认为double。
在Java中我们可以通过Integer.SIZE这样的方法直接查看基本类型所占内存空间的大小。通过以下程序就能够查看了：
class JavaType {
public static void main(String[] args) {
System.out.println("Byte: " + Byte.SIZE);
System.out.println("Short: " + Short.SIZE);
System.out.println("Integer: " + Integer.SIZE);
System.out.println("Long: " + Long.SIZE);
System.out.println("Float: " + Float.SIZE);
System.out.println("Double: " + Double.SIZE);
System.out.println("Character: " + Character.SIZE);
}
}输出结果为：(单位是bit)
Byte: 8(一个字节)
Short: 16(二个字节)
Integer: 32(四个字节)
Long: 64(八个字节)
Float: 32(四个字节)
Double: 64(八个字节)
Character: 16(二个字节)
boolean类型有点奇怪，官方文档是这么说的：This data type represents one bit of information, but its “size” isn’t something that’s precisely defined.，翻译为中文：这种数据类型保存一位的信息，但是它的大小却不是精确定义的。
Java基本数据类型举例如下：
int x = 4;
byte b = 2; //2是一个int常量，但是会自动判断2是不是在byte类型的范围内（-128~127），=运算符在给b赋值时，自动完成了强转操作
byte b1 = 128; //编译未通过，超出byte类型的范围
short s = 30000;
long l = 4l;
float f = 2.3f;
double d = 34.56;
char ch = '4';
char ch1 = 'a';
char ch2 = '+';
char ch3 = ' ';
char ch4 = '昀'; //一个中文在内存中占2个字节，而char就是2个字节空间大小
boolean bo = true;
boolean bo1 = false;类型转换
自动类型转换
自动类型转换也叫隐式类型转换。表达式中的数据类型自动提升：
- 所有的byte型、 short型和char型的值将被提升到int型。
- 如果一个操作数是long型/float型/double型，计算结果就是long型/float型/double型。
例，
byte b = 3;
int x = 4;
x = x + b;//b会自动提升为int类型进行运算。强制类型转换
强制类型转换也叫显式类型转换。例，
byte b = 3; // 3是一个int常量，但是会自动判断3是不是在byte类型的范围内（-128~127），=运算符在给b赋值时，自动完成了强转操作
b = b + 4;//报错
b = (byte)(b+4);//强制类型转换，强制将b+4的结果转换为byte类型，再赋值给b。运算符
算术运算符
这里就不介绍具体的运算符了，只讲其注意的三个点：
- 如果对负数取模，可以把模数负号忽略不记，如：
5%-2=1。但被模数是负数就另当别论，如：-5%2=-1，面试的时候可能会考到。 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。如：
int x = 4270; x = x / 1000 * 1000; System.out.println(x); // 4000字符串数据和任何数据使用+都是相连接，最终都会变成字符串。如：
System.out.println("5+5="+5+5); //"5+5=55" System.out.println("5+5="+(5+5)); // "5+5=10"
赋值运算符
例，
int a, b, c;
a = b = c = 5;这里有一个N年前的面试题，虽然以后再也不会出现在如今的面试题中了，但是可以通过这样的一个例子来加深对赋值运算符的理解。思考如下代码中s = s + 2;与s += 2;的区别？
short s = 3;
s = s + 2;
s += 2;答案：
short s = 3;
s = s + 2; // 编译失败，因为s会被提升为int类型，运算后的结果还是int类型，无法赋值给short类型
s += 2; // 编译通过，因为+=运算符在给s赋值时，自动完成了强转操作比较运算符
这里就不介绍具体的运算符了，只讲其注意的二个点：
- 比较运算符的结果都是boolean型，也就是要么是true，要么是false。
- 比较运算符==不能误写成=。
逻辑运算符
逻辑运算符用于连接boolean类型的表达式。
&——AND(与)
| boolean类型的表达式 | 逻辑运算符 | boolean类型的表达式 | 结果 |
|---|---|---|---|
| true | & | true | true |
| true | & | false | false |
| false | & | true | false |
| false | & | false | false |
特点：只要两边的布尔表达式结果有一个为false，那么结果就为false。只有两边都为true，结果为true。
|——OR(或)
| boolean类型的表达式 | 逻辑运算符 | boolean类型的表达式 | 结果 |
|---|---|---|---|
| true | | | true | true |
| true | | | false | true |
| false | | | true | true |
| false | | | false | false |
特点：两边只要有一个为true，结果为true，两边都为false，结果为false。
^——XOR(异或)
就是和|有点不一样，当true ^ true = false时。
| boolean类型的表达式 | 逻辑运算符 | boolean类型的表达式 | 结果 |
|---|---|---|---|
| true | ^ | true | false |
| true | ^ | false | true |
| false | ^ | true | true |
| false | ^ | false | false |
!——Not(非)
!true = false
!fasle = true注意：&和&&的区别以及|和||的区别
&：无论左边是true是false，右边都运算。
&&：当左边为false时，右边不运算。
|：两边都参与运算。
||：当左边为true时，右边不运算。
位运算符
位运算是直接对二进制进行运算。
| 位运算符 | 运算 | 范例 |
|---|---|---|
| << | 左移 | 3 << 2 = 12 → 3 * 2 * 2 = 12 |
| >> | 右移 | 3 >> 1 = 1 → 3 / 2 = 1 |
| >>> | 无符号右移 | 3 >>> 1 = 1 → 3 / 2 = 1 |
| & | 与运算 | 6 & 3 = 2 |
| | | 或运算 | 6 |
| ^ | 异或运算 | 6 ^ 3 = 5 |
| ~ | 反码 | ~6 = -7 |
注意：
<<：其实就是乘以2的移动的位数次幂。>>：其实就是除以2的移动的位数次幂。
位运算符的细节
| 位运算符 | 细节 |
|---|---|
| << | 空位补0，被移除的高位丢弃，空缺位补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 |
观察下面的一个例子，你能得出什么结论呢？
7 ^ 4
111
^ 100 (加密)
------
011
^ 100 (解密)，密钥：100
------
111 = 7; ----> 7 ^ 4 ^ 4 = 7;显然，结论：一个数异或同一个数两次，结果还是那个数。这里也有一个N年前的面试题，虽然以后再也不会出现在如今的面试题中了，但是可以通过这样的一个例子来加深对位运算符的理解。请对两个整数变量的值进行互换(不需要第三方变量)。
答案：
第一种方式：(使用第三方变量，实际开发时使用)
int n = 3, m = 8; System.out.println("n = " + n + ", m = " + m); int temp; temp = n; n = m; m = temp; System.out.println("n = " + n + ", m = " + m);第二种方式：(不需要第三方变量，这种方式最好不要用，因为容易超出int范围)
int n = 3, m = 8; System.out.println("n = " + n + ", m = " + m); n = n + m; // 如果n和m的值非常大，容易超出int范围 m = n - m; n = n - m; System.out.println("n = " + n + ", m = " + m);第三种方式：(不需要第三方变量，炫技型，用到了一个数异或同一个数两次，结果还是那个数的结论)
int n = 3, m = 8; System.out.println("n = " + n + ", m = " + m); n = n ^ m; m = n ^ m; // (n ^ m) ^ m = n; n = n ^ m; // n ^ (n ^ m) = m; System.out.println("n = " + n + ", m = " + m);
三元运算符
格式：
(条件表达式) ? 表达式1 : 表达式2
- 如果条件为true，运算后的结果是表达式1。
- 如果条件为false，运算后的结果是表达式2。
例，取出三个数中的最大值(三元运算符的嵌套)。
int a = 2;
int b = 10;
int c = 3;
int max = a > b ? (a > c ? a : c) : (b > c ? b : c); // 取出三个数中的最大值(三元运算符的嵌套)
System.out.println("max = " + max);