一.关键字
定义：
被java语言赋予特殊含义，用做专门用途的字符串（或单词）
特点：全部关键字都是小写字母。
例如：
HelloWorld案例中，出现的关键字有class、public、static、void等，这些单词已经被Java定义好了。
二.标识符
定义：
java中变量/方法/类等要素命名使用的字符串序列，称为标识符。
技巧：凡是自己可以起名字的地方都叫标识符。
比如：类名、常量、包名、变量名、方法名等
命名规则：
1、由24个英文字母组成，可以由0-9数字，也可由_或者&这两个特殊符号（其他的符号不行）
2.单，数字不能作为开头
3.java严格区分大小写，长度没有限制
4.标识符号中不包含空格
命名规范（建议遵守）：
1.包名：多单词时后，所有小写。例如：java.lang、com.atguigu.bean
2.类名、接口名：多单词的时候，所有单词首字母大写，例如：HelloWorld，String，System等
3.变量名、方法名：多单词的时候，第一单词首字母小写，后面的单词首字母大写，例如：bookName,main,binarySearch,getName
4.常量名，所有单词都大写。 例如：MAX_VALUE,PI,DEFAULT_CAPACITY
三、变量
1.变量的概念：
内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化
变量的构成包含三个要素：
数据类型、变量名、存储的值Java中变量声明的格式：
数据类型 变量名 = 变量值变量的作用：用于在内存中保存数据。
使用变量注意：
Java中每个变量必须先声明，后使用。
使用变量名来访问这块区域的数据。
变量的作用域：其定义所在的一对{ }内。
变量只有在其
作用域内才有效。出了作用域，变量不可以再被调用。同一个作用域内，不能定义重名的变量。
2.变量的类型
Java中分了两大类型：
基础数据类型（8种）：
整数类型：int、long、byte.short
浮点数类型:float/double
字符类型:char
布尔类型:buoolean
引用数据类型：
类class、数组 array、接口 inteface
枚举enum、注解annotation、记录record
说明和补充：
Java各整数类型有固定的表数范围和字段长度，不受具体操作系统的影响，以保证Java程序的可移植性。
3.基础数据类型：
注意事项：
1.定义long类型的变量，赋值时需要以"l"或"L"作为后缀。
2.一般在定义整型变量的过程时，都是定义为int类型，方便快捷，除非是特殊情况，才使用long类型
补充：计算机存储单位
字节（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.浮点型数据类型：float/double
float：单精度，尾数可以精确到7位有效数字，很多情况下，精度很难满足需求。定义的时候，要加上“f”或者“F”。
double:双精度，时lloat精度的两倍，通常采用double。
说明：
1.通常在定义浮点型数据类型的过程中，通常使用double.
2.浮点类型float、double的数据不适合在不容许舍入误差的金融计算领域。如果需要精确数字计算或保留指定位数的精度，需要使用BigDecimal类。
5.char字符类型：
常用的表示类型：
1.表示形式1：使用单引号来表示，例如：char c1 = 'a';char c2 = '1';char c3 = '3';
2.表示形式2：使用Unicode值来表示字符型常量，‘\uXXXX’，其中‘\u’就是特殊的表示方式，XXXX代表一个十六进制整数。 例如：‘\u0023 ’表示 '#'。
3.表示形式3：Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。通常有如下内容：
4.表示形式4：使用具体的字符对应的数值。
6.布尔类型：boolean
loolean类型用来判断逻辑条件，一般用在流程控制语句中
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类型占用的空间大小。但是，真正在内存中分配的话，使用的是4个字节。
7.基础数据类型变量间运算规则
转换的方式：自动型提升和强制类型转换。
自动类型提升：
规则：将取值范围小（或者容量小）的类型自动提升为取值范围大（或者容量大）的类型。
char.byte.short<int<long <float <double
在平时输出的时候，如何出现L2=123；的情况，没有报错，是因为将123的int类型自动提升了，但如何超出int的范围，就会报错，比如L4=1234548345313543131；就会报错，只要加上l就没问题，这是运算规律的体现。体现在小的数值往大的数值方面提升，但是反过来是不行的。
强制类型转换：
只有当高向低进行转化的时候使用，但通常会造成精度损失、溢出等问题。
数据类型1 变量名 = (数据类型1)被强转数据值;//()中的数据类型必须<=变量值的数据类型
例如下面的情况：
int i = (int)3.14;//损失精度
int i2 =128; byte b1 =(byte)i2; 使用System.out.println(b1);时候，结果时-128；，这也是精度问题。
double d = 1.2;
int num = (int)d;//损失精度
int i = 200;
byte b = (byte)i;//溢出
8.基础数据类型和String的运算
字符串类型 String
String不是基础数据类型，属于引用数据类型
使用一对“”来表示一个字符串，内部可以包含0个、1个或者多个字符。
声明方式和基本数据类型类似，类如：String str = “和尚出家了’";
运算规则：
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);//正确的，后面才能讲到，借助包装类的方法才能转
9.计算机底层如何存储数据
计算机世界中只有二进制，所以计算机中存储和运算的所有数据都要转为二进制。包括数字、字符、图片、声音、视频等。
进制的分类
十进制（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);
}
}
二进制的由来
二进制，是计算技术中广泛采用的一种数制，由德国数理哲学大师莱布尼茨于1679年发明。
二进制数据是用0和1两个数码来表示的数。它的基数为2，进位规则是“逢二进一”。
二进制广泛应用于我们生活的方方面面。比如，广泛使用的摩尔斯电码（Morse Code），它由两种基本信号组成：短促的点信号“·”，读“滴”；保持一定时间的长信号“—”，读“嗒”。然后，组成了26个字母，从而拼写出相应的单词。
二进制如何表示整数？
计算机数据的存储使用二进制
补码形式存储，并且最高位是符号位。正数：
最高位是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
歌进制间的转换
10.运算符（Operator）（掌握）
运算符是一种特殊的符号，用于表示数据的运算、赋值、和比较等。
运算符的分类：
按照功能划分：算数运算符、赋值运算符、比较（或关系）运算符、逻辑运算符、位运算符、条件运算符、Lambda运算符。
按照操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）
算符运算符
基础语法
1.加减乘除模
2.“+”号的两种用法：
第一种：对于
+两边都是数值的话，+就是加法的意思第二种：对于
+两边至少有一边是字符串的话，+就是拼接的意思
3.
自加自减运算
理解：++运算，表示自增1。同理，--运算，表示自减1，用法与++ 一致。
1、单独使用
变量在单独运算的时候，变量
前++和变量后++，是没有区别的。变量
前++：例如++a。变量
后++：例如a++。
2、复合使用
和
其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。
变量
前++：变量先自增1，然后再运算。变量
后++：变量先运算，然后再自增1。
问：下面的输出结果是什么？
int i = 1;
int j = i++ + ++i * i++;
System.out.println("j = " + j);
System.out.println("i = " +i);
答案是i=4，j=10；
解析：只要有了++符号，i就会加一，不过是先后问题，一共3个++，i就是4。
至于j的运算可以这样表示：
j=1+（1+1（+1））*（2+1），就是第一个i通过1和后面第二i（他现在是3，以为前面已经+1了，在*乘法运算前，又+1，所以用3的数字参加运算）
同理：
double s2=5;
s2+=(s2+=5)*(s2+=5);
s2的数值就是155，这样看5+10*15，s2先用5参与第一个，第二个就是10参与运算（有括号，先赋值），第三个就是15（10+5来的15）.
s2+=s2+=5*s2+=5;
赋值运算符
基础语法
符号：=
当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
支持
连续赋值扩展赋值运算符： +=、 -=、*=、 /=、%=
例子：
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);
}
}
比较（关系）运算符
说明：
比较运算符的结果都是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类型的变量或常量，而且运算得结果也是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);
//&和&&的区别
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。（正数、负数都适用）
【注意】当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位
（2）右移：>>
运算规则：在一定范围内，数据每向右移动一位，相当于原数据/2。（正数、负数都适用）
【注意】如果不能整除，向下取整。
（3）无符号右移：>>>
运算规则：往右移动后，左边空出来的位直接补0。（正数、负数都适用）
（4）按位与：&
运算规则：对应位都是1才为1，否则为0。
1 & 1 结果为1
1 & 0 结果为0
0 & 1 结果为0
0 & 0 结果为0
（5）按位或：|
运算规则：对应位只要有1即为1，否则为0。
1 | 1 结果为1
1 | 0 结果为1
0 | 1 结果为1
0 & 0 结果为0
（6）按位异或：^
运算规则：对应位一个为1一个为0，才为1，否则为0。
1 ^ 1 结果为0
1 ^ 0 结果为1
0 ^ 1 结果为1
0 ^ 0 结果为0
（7）按位取反：~
运算规则：对应位为1，则结果为0；对应位为0，则结果为1。
~0就是1
~1就是0
举例
举例2：体会 m = k ^ n = (m ^ n) ^ n
案例1：高效的方式计算2 * 8的值（经典面试题）
答案：2 << 3 、 8 << 1
如何交换两个int型变量的值？
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
说明：条件表达式是boolean类型的结果，根据boolean的值选择表达式1或表达式2
也就是，结果需要什么，条件就要设置什么类型的（或者兼容的类型，如double可以兼容int）
如果运算后的结果赋给新的变量，要求表达式1和表达式2为同种或兼容的类型
举例：三个数中选出最大的数值
public class ConditionExer2 { public static void main(String[] args) { int n1 = 23; int n2 = 13; int n3 = 33; int max; //写法1： max = (n1 > n2)? n1:n2; max = (max > n3)? max : n3; System.out.println("三个数中最大值为：" + max); //写法2：不推荐，可读性差 int finalMax1 = (((n1 > n2)? n1:n2) > n3)? ((n1 > n2)? n1:n2) : n3; System.out.println("三个数中最大值为：" + finalMax1); } }举例2：
今天是周5，10天以后是周几？
要求：控制台输出"今天是周5，10天以后是周x"。
public class ConditionExer3 { public static void main(String[] args) { int week = 4; week += 10; week %= 7; System.out.println("今天是周4,10天以后是周" + (week == 0 ? "日" : week)); // 如果出现被整除的情况，就会出现0的问题，但我们知道如果是0那就是星期日，也就是星期天 } }与if-else的转换关系
凡是可以使用条件运算符的地方，都可以改写为if-else结构。反之，不成立。
开发中，如果既可以使用条件运算符，又可以使用if-else，推荐使用条件运算符。因为执行效率稍高。
同样是选出三个数中最大的数值的问题，写法如下：
public class Test7{ public static void main(String[] args) { int n1=23; int n2=123; int n3=12312; int max; if(n1>=n2){ max=n1; } else{ max=n2; } if(max>=n3){ System.out.println( "最大数是："+max); } else { max=n3; System.out.println( "最大数是："+max); } } }运算符优先级
运算符有不同的优先级，所谓优先级就是在表达式运算中的运算符顺序。
上一行中的运算符总是优先于下一行的。
| 优先级 | 运算符说明 | 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;
