知识点1：关键字和保留字

关键字(keyword)的定义和特点
定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EPFW0Kpt-1593436595211)(assets/1592816716644.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FkOJRLMc-1593436595212)(assets/1592816725113.png)]

Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字 比如：goto 、const

知识点2：标识符

• 概念

1. java中定义的变量名、方法名、类名、接口名、常量名、包名等都是标识符
2. 技巧：凡是可以自己命名的地方，都是标识符

• 命名规则

3. 定义合法标识符规则：
> 由26个英文字母大小写，0-9 ，_或 $ 组成  
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。小结：凡是不满足上述规则的命名，都会报编译的错误！

• 命名规范

4. 标识符命名规范：
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz   （大驼峰）
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz  （小驼峰）
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ小结：如果不满足上述的规范，编译、运行仍可正常执行。要求大家在开发时，要遵循上述的规范！

• 注意点

5. 给标识符命名时，要见名知意。

• 对应的代码测试

class IdentifierTest {public static void main(String[] args) {System.out.println("Hello World!");}
}class _8hello1
{
}class public1{
}class Goto{
}class Ren{
}
class staticvoid{
}class Hello123{}
/*
class hello123{}
*/

知识点3：变量

• 说明

1. java中的变量定义的规则：数据类型 变量名 = 变量值2. 注意点：
① 变量必须在初始化之后，才能使用
② 每个变量都有其声明所在的作用域。在其作用域内都可以使用。出了作用域之后，就不能使用了。
③ 在同一个作用域内不允许定义两个同名的变量

• 代码演示

class VariableTest {public static void main(String[] args) {//编译错误：变量必须在声明之后才可以使用//System.out.println(weight);//1.1变量的声明double weight;//编译错误：变量必须在初始化之后，才能使用//System.out.println(weight);//1.2 变量的赋值weight = 80.6;//变量的声明和赋值操作同时完成int myAge = 12;System.out.println(weight);System.out.println(myAge);//编译错误//System.out.println(score);//编译错误：在同一个作用域内不允许定义两个同名的变量//int myAge = 30;System.out.println(myAge);}public static void show(){int score = 98;System.out.println(score);int myAge = 30;}
}

知识点4：8种基本数据类型

1. 变量的分类

• 变量按照数据类型来分：

• 变量按照在类中声明的位置来分：（了解）

2. 8种基本数据类型的使用

整型

//1.整型：byte(1个字节 = 8bit, 范围：-128 ~ +127) 、 short(2字节) 、 int(4字节)  、 long(8字节) 
//① 变量的赋值不能超出数据类型的表数范围
byte b1 = 12;//b1 = 128;//编译不通过//② 给long类型变量赋值时，需要以"l" 或"L"结尾
long l1 = 123L;
long l2 = 432l;
System.out.println(l1);//123
System.out.println(l2);//432//③ 开发中，通常定义整型为int

浮点型

//2.浮点型:float(4字节,单精度)、double(8字节，双精度) 
//① float定义的变量值必须以"f"或"F"结尾
//② 开发中，默认我们可以使用double类型来定义浮点类型的变量
double d1 = 123.43;
double d2 = 5436345234.235234;float f1 = 123.43F;
System.out.println(f1);

字符型

//3.字符型:char
//一个字符占2个字节
//① 通常使用一对单引号表示一个字符。内部只能有一个字符char c1 = 'a';
char c2 = '1';
char c3 = 'セ';
char c4 = '中';
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);//编译错误：内部只能声明一个字符
//char c5 = 'ab';
//char c6 = '123';
//char c7 = '';//②其他表示方式：1.表示转义字符 2.使用Unicode值表示 
char c8 = '\n';//换行符
char c9 = '\t';//制表符System.out.println("hello" + c8 +"world");
System.out.println("hello" + c9 +"world");char c10 = '\u0026';
char c11 = '&';
System.out.println(c10);

• 常用的字符集：ASCII 、GB2312、GBK、Unicode、UTF-8

布尔型

//4. 布尔型：boolean
// 只有两个取值：true 、 false
// 通常使用在条件判断、循环结构中
boolean isMarried = true;if(isMarried){System.out.println("好好珍惜自己的媳妇");}else{System.out.println("可以多谈谈女朋友");
}
/*
int myAge = 18;
if(myAge > 18){}
*/

知识点5: 基本数据类型间的运算规则

1. 自动类型提升

基本数据类型变量间运算的规则1. 此时的运算规则涉及到的是7种基本数据类型，不包含boolean
2. 容量小的和容量大的数据类型的变量间做运算时，满足：自动类型提升> 容量小的和容量大的数据类型的变量间做运算时，结果的数据类型为容量大的数据类型。> 特别的：如果byte、short、char三者之间做运算的话，结果为int类型。总结：byte 、short、char -> int -> long -> float -> double 说明：容量大小指的是表数的范围。

• 代码演示

class VariableTest2 {public static void main(String[] args) {long l1 = 123L;float f1 = 123.4F;//编译失败//long l2 = l1 + f1;float f2 = l1 + f1;byte b1 = 123;int i1 = 432;//编译失败//short s = b1 + i1;int i2 = b1 + i1;float f3 = i1;System.out.println(f3);//432.0//##########################char c1 = 'a';//97int i3 = 1;int i4 = c1 + i3;System.out.println(i4);//############################byte bb1 = 12;short ss1 = 13;//编译失败//short ss2 = bb1 + ss1;char cc1 = 97;//编译失败//char cc2 = bb1 + cc1;//编译失败//short ss3 = ss1 + cc1;byte bb2 = 32;//编译失败byte bb3 = bb1 + bb2;}
}

2. 强制类型转换

自动类型提升规则的逆运算：强制类型转换1. 强制类型转换，可以将容量大的数据类型的变量转换为容量小的数据类型的变量
2. 强制类型转换，需要使用强制类型转换符

• 代码演示

class VariableTest3 {public static void main(String[] args) {long l1 = 123L;//编译失败//int i1 = l1;int i2 = (int)l1;System.out.println(i2);//损失精度的情况1：double weight = 140.23;int truncWeight = (int)weight;System.out.println(truncWeight);//140//损失精度的情况2：int num = 128;byte byteNum = (byte)num;System.out.println(byteNum);//-128}
}

3. 补充说明

//对于整型数据类型，常量的默认类型为：int
//对于浮点数据类型，常量的默认类型为：double

• 代码演示

class VariableTest4 {public static void main(String[] args) {long count = 2341234;System.out.println(count);//编译错误//long count1 = 2423535443654564;long count1 = 2423535443654564L;//编译错误//float f1 = 123.23;float f1 = (float)123.23;//byte b1 = 12;int i1 = b1 + 10;//编译错误//float f2 = b1 + 123.34;}
}

知识点6：String与基本数据类型间的运算规则

1. String的基本使用

• String类型的变量使用一对""进行定义。

String info = "Hello World!";
System.out.println(info);String s1 = "";//可以编译通过

2. String与8种基本数据类型间的运算规则

1. String 与 8种基本数据类型之间只能做连接运算： +
2. 运算的结果是String类型

• 代码演示

String info = "Hello World!";
System.out.println(info);String s1 = "";//可以编译通过int num = 2;
String s2 = info + num + true;
System.out.println(s2);//######################
//编译失败
//String s3 = num;String s4 = "123";
//编译失败
//int i1 = (int)s4;//超纲内容：包装类时讲
int i2 = Integer.parseInt(s4);
System.out.println(i2 + 1);

• 练习

/*
练习1：*/
char c1 = 'a';//97
int i = 1;
String str = "hello";
System.out.println(c1 + i + str);//98hello
System.out.println(c1 + str + i);//ahello1
System.out.println(c1 + (i + str));//a1hello/*
练习2：*/
//*	*
System.out.println('*' + '\t' + '*');//93
System.out.println('*' + '\t' + "*");//51*
System.out.println("*" + '\t' + '*');//*	*
System.out.println("*" + "\\t" + '*');//*	*
System.out.println("*\t*");//*	*System.out.println("芳芳老师很\"漂亮\"");//芳芳老师很"漂亮"

知识点7：进制间的运算（了解）

1. 了解常见的几种进制

/*二进制(binary)：0,1 ，满2进1.以0b或0B开头。   
十进制(decimal)：0-9 ，满10进1。
八进制(octal)：0-7 ，满8进1. 以数字0开头表示。
十六进制(hex)：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。如：0x21AF +1= 0X21B0*/
class BinaryTest {public static void main(String[] args) {int num1 = 0b10;int num2 = 010;int num3 = 10;int num4 = 0x10;System.out.println(num1);System.out.println(num2);System.out.println(num3);System.out.println(num4);}
}

2. 熟悉二进制的情况

• 计算机的底层都是使用二进制表示数据的

• 对于数值型的变量，底层使用数值的二进制数据的补码表示数据

• 二进制原码、反码、补码的关系：

  • 正数：原码、反码、补码，三码合一

  • 负数：

    负数的反码：是对原码按位取反，只是最高位（符号位）确定为1。
    负数的补码：其反码加1。

3. 二进制与十进制之间的转换

• 二进制转十进制

• 十进制转二进制：除2取余的逆

4. 与其他进制间的转换

• 二进制转换为八进制、十六进制

• 八进制、十六进制转换为二进制

知识点8：运算符

1. 逻辑运算符

• 说明

& &&  |  ||  ! ^说明：
1. 逻辑运算符操作的都是boolean类型的变量
2. 逻辑运算符的运算结果也是boolean类型

• 代码演示

class LogicTest {public static void main(String[] args) {//& 和 &&相同点：当符号左边是true时，都执行符号右边的操作//不同点：//& : 当符号左边是false时,继续执行符号右边的操作//&& : 当符号左边是false时,不再执行符号右边的操作//& 与 && 表达的都是且的关系。但是，在开发中我们使用&&的频率高一些。boolean b1 = true;b1 = false;int n1 = 10;if(b1 & (n1++) > 0){System.out.println("今天天气稍微闷热一些~");}else{System.out.println("明天预计天气稍微闷热一些~");}System.out.println("n1 = " + n1);//#################################boolean b2 = true;b2 = false;int n2 = 10;if(b2 && (n2++) > 0){System.out.println("今天天气稍微闷热一些~");}else{System.out.println("明天预计天气稍微闷热一些~");}System.out.println("n2 = " + n2);//###############################//| 和 || 相同点：当符号左边是false时，都执行符号右边的操作//不同点：//| : 当符号左边是true时,继续执行符号右边的操作//|| : 当符号左边是true时,不再执行符号右边的操作//| 与 || 表达的都是或的关系。但是，在开发中我们使用||的频率高一些。boolean b3 = false;b3 = true;int n3 = 10;if(b3 | (n3++) > 0){System.out.println("今天天气稍微闷热一些~");}else{System.out.println("明天预计天气稍微闷热一些~");}System.out.println("n3 = " + n3);//###################boolean b4 = false;b4 = true;int n4 = 10;if(b4 || (n4++) > 0){System.out.println("今天天气稍微闷热一些~");}else{System.out.println("明天预计天气稍微闷热一些~");}System.out.println("n4 = " + n4);}
}

2. 位运算符

• 说明

<<   >>   >>>  &  |  ^  ~总结：
<< ： 在一定范围内，每左移一位，数值*2>> : 在一定范围内，每右移一位，数值 / 2"过犹不及">>> : 不管是正数还是负数，右移之后，高位都补0总结：我们在开发中使用位运算的机会不多。
具体说到如果使用的话，主要是为了提升运算的效率。经典的面试题：
最高效的方式计算 2 * 8  2 << 3
8 << 1

• 举例

• 代码演示

class BitTest {public static void main(String[] args) {System.out.println("13 << 2 : " + (13 << 2));System.out.println("-13 << 2 : " + (-13 << 2));System.out.println("13 << 27 : " + (13 << 27));System.out.println("13 << 28 : " + (13 << 28));System.out.println("13 >> 2 : " + (13 >> 2));System.out.println("-13 >> 2 : " + (-13 >> 2));System.out.println("-13 >>> 2 : " + (-13 >>> 2));//练习：如何交换两个int型变量的值int m = 10;int n = 20;System.out.println("m = " + m + ", n = " + n);//交换两个变量的值(重点)//方式一：推荐！//int temp = m;//m = n;//n = temp;//方式二：使用有局限性：① 可能会超出int的范围  ② 数据类型的局限性//m = m + n;//10 + 20//n = m - n;//30 - 20//m = m - n;//30 - 10//方式三：使用有局限性：数据类型的局限性m = m ^ n;n = m ^ n;m = m ^ n;System.out.println("m = " + m + ", n = " + n);}
}

3. 三元运算符

• 说明

格式： (条件表达式)? 表达式1 : 表达式2说明1： ① 条件表达式的结果为boolean② 如果条件表达式的结果为true,则返回表达式1。反之，如果条件表达式的结果为false,则返回表达式2③ 表达式1和表达式2满足一致性。说明2：三元运算符可以嵌套使用说明3：凡是可以使用三元运算符的地方，都可以改写成if-else结构。反之，不成立。凡是既可以使用三元运算符，又可以使用if-else结构的地方，建议使用三元运算符。因为执行效率高一些。

• 代码演示

class SanYuanTest {public static void main(String[] args) {//获取两个数的较大值int m = 10;byte n = 15;int max = (m > n)? m : n;System.out.println("较大值为：" + max);//String s = 12;//编译不通过String maxString = (m > n)? "m大" : "n大";n = 10;String maxString1 = (m > n)? "m大" : ((m == n)? "m和n相等" : "n大");System.out.println(maxString);System.out.println(maxString1);//练习：获取三个数的最大值int a = 10;int b = 43;int c = 5;int max1 = (a > b)? a : b;int max2 = (max1 > c)? max1 : c;//不建议： int max2 = (((a > b)? a : b) > c)? ((a > b)? a : b) : c;System.out.println(max2);}
}

4. 运算符的优先级