Java学习——黑马程序员

Java学习——黑马程序员

Java学习——黑马程序员（更）

编辑时间：2023/10/27
来源：b站黑马程序员

Java入门

1.Java应用六大领域：
桌面应用开发，企业级应用开发，移动应用开发，科学计算，大数据开发，游戏开发。
2.Java的主要特性
面向对象、安全性、多线程、简单易用、开源、跨平台。
3.Java三大版本
JavaSE Java语言版本（标准版），用于桌面应用开发，需要其他两个版本的基础
JavaME Java语言的（小型版），用于嵌入式电子设备或小型移动设备。
JavaEE Java语言的（企业版），用于web方向的网站开发。

4.java的主要特性
面向对象、跨平台、开源、安全性、多线程、简单用

编程：Java程序写的Java代码，c程序员写的c代码，Python程序员写的py代码
编译：把py的代码做转化让机器认识的过程
运行：让机器执行编译后的指令




5.JRE和JDK
JVM(java Virtual Machine):java虚拟机。真正运行Java顺序的地方

1.JDK是什么？有哪些内容组成
JDK是Java开发工具包
JVM虚拟机：Java程序运行的地方
核心类库：Java已经写好的东西，可以直接使用
开发工具：javac（编译工具）、Java（运行工具）、jdb（调试工具）、jhat（内存分析工具）… …
2.JRE是什么？有哪些内容组成
JRE是java运行环境
JVM、核心类库、运行工具
3.JDK、JRE、JVM三者包含关系
JDK包含JRE
JRE包含JVM

6.IDEA
1.IDEA结构分类

• project项目 工程
• moudle模块
• package包
• class类

Java入门——常用的CMD命令

1.打开CMD
CMD:在windows中利用命令行的方式操作计算机
快捷键：win+R ——>输入CMD——>回车

2.常见CMD命令
盘符名称+冒号 说明：盘符切换

E:

dir 说明：查看的钱路径下的内容

dir

cd目录 说明：进入到单级文件夹
cd 目录1目录2…

cd… 说明：回退到上一级目录

cd..

cd 说明：回退到盘符目录

cd 

cls 说明：清屏

cls

exit 说明：退出命令行提示窗口

exit

3.利用CMD打开qq练习
配置环境变量：我们想要在任意目录下都可以打开指定的软件，可以把软件的路径配置到环境变量中。
将qq的路径记录到系统环境变量的path路径下，让后在cmd直接输入qq.exe回车。

Java入门——运行第一个HelloWorld案件

1.Java安装目录介绍


编译：Javac是JDK提供编译的工具，我们可以通过这个工具把当前路径下的HelloWorld.java文件编译成class文件
运行：Java也是JDK 提供的一个工具作用是用来运行代码的。运行是当前路径下的HelloWorld.class文件，在运行的时候是不加后缀名的。

javac HelloWorld.java
java HelloWorld

Java基础概念

Java基础概念——注释和关键字

注释：注释就是对代码进行解释说明的文字；可分为单行注释多行注释和文档注释；注释使用的细节为注释的内容不参与编译和运行，仅仅是对代码的解释说明，注意注释不要嵌套。

//单行注释
/*多行注释*/
/**文档注释*/

注意：如果我们要对代码进行解释，那么就可以使用注释。 当注释的内容比较少，一行就写完了，可以用单行注释。 如果注释的内容比较多，需要写在多行，那么可以使用多行注释。注意点 注释的内容不会参与编译和运行的，仅仅是对代码的解释说明而已。 所以，不管在注释当中写什么内容，都不会影响代码运行的结果。

关键字：被Java赋予了特定语义的英文单词
关键字的字母都全部小写，常用的代码编辑器对关键字有特殊标记。

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void

Java基础概念——字面量

注意：null不能直接打印，除非是将它用字符串串起来才能打印"null"

拓展点：
1.区分技巧

• 不带小数点的数字都是整数类型的字面量。 只要带了小数点，那么就是小数类型的字面量。
• 只要用双引号引起来的，不管里面的内容是什么，不管里面有没有内容，都是字符串类型的字面量。
• 字符类型的字面量必须用单引号引起来，不管内容是什么，但是个数有且只能有一个。 字符类型的字面量只有两个值，true、false。
• 空类型的字面量只有一个值，null。

2.t 制表符 ：缩进、对齐、大空格

Java基础概念——变量

1.基本用法
变量的定义格式数据类型 变量名 =数据值
数据类型：限定了变量能存储数据的类型
变量名：存储空间的名字
数据值：真正存在变量中的数据
等号：赋值作用，把右边的数值赋给左边的变量
2.变量的使用方式
输出打印、参与计算、修改记录值
3.变量的注意事项
只能存放一个值、变量名不允许重复定义、一条语句可以定义多个变量、变量是使用之前一定要进行赋值

Java基本概念——计算机中的存储

1.计算机存储规则：计算机用的是二进制形式进行存储数据。

2.进制转换




三原色小结：

1. 计算机中事务颜色采用光学三原色
2. 分别为红绿蓝。也称为RGB
3. 可以写成十进制（255,255,255）
4. 也可以写成十六进制（FFF,FFF,FFF）

Java基础概念——数据类型

分类

1. 基本数据类型
2. 引用数据类型

基本数据类型分类

小结：
1.Java语言的数据类型分为：基本数据类型，引用数据类型
2.基本数据类型有8种
3.byte的取值分为-128~127
4.大小关系：double>float>long>int>short>byte
5.long类型变量：需要加入L标识（大小写都可以）
float类型变量：需要加入F标识（大小写都可以）

public class VariableDemo3{public static void main(String[] args){//1.定义byte类型的变量//数据类型 变量名 = 数据值;byte a = 10;System.out.println(a);//2.定义short类型的变量short b = 20;System.out.println(b);//3.定义int类型的变量int c = 30;System.out.println(c);//4.定义long类型的变量long d = 123456789123456789L;System.out.println(d);//5.定义float类型的变量float e = 10.1F;System.out.println(e);//6.定义double类型的变量double f = 20.3;System.out.println(f);//7.定义char类型的变量char g = 'a';System.out.println(g);//8.定义boolean类型的变量boolean h = true;System.out.println(h);}
}

Java基础——标识符

硬性要求：
必须由数字、字母、下划线_、美元符号$组成。
数字不能开头
不能是关键字
区分大小写的。
软件建议：
1 小驼峰命名法
适用于变量名和方法名
如果是一个单词，那么全部小写，比如：name
如果是多个单词，那么从第二个单词开始，首字母大写，比如：firstName、maxAge
2 大驼峰命名法
适用于类名
如果是一个单词，那么首字母大写。比如：Demo、Test。
如果是多个单词，那么每一个单词首字母都需要大写。比如：HelloWorld

Java基础——键盘录入

使用步骤：
第一步：
​ 导包：其实就是表示先找到Scanner这个类在哪。
第二步：
​ 创建对象：其实就表示申明一下，我准备开始用Scanner这个类了。
第三步：
​ 接收数据：也是真正干活的代码。

代码示例：

//导包，其实就是先找到Scanner这个类在哪
import java.util.Scanner;
public class ScannerDemo1{public static void main(String[] args){//2.创建对象，其实就是申明一下，我准备开始用Scanner这个类了。Scanner sc = new Scanner(System.in);//3.接收数据//当程序运行之后，我们在键盘输入的数据就会被变量i给接收了System.out.println("请输入一个数字");int i = sc.nextInt();System.out.println(i);}
}

运算符

运算符：
​ 就是对常量或者变量进行操作的符号。

​ 比如： + - * /

表达式：
​ 用运算符把常量或者变量连接起来的，符合Java语法的式子就是表达式。

​ 比如：a + b 这个整体就是表达式。

​ 而其中+是算术运算符的一种，所以这个表达式也称之为算术表达式。

运算符——算术运算符详解和综合练习

分类：+ - * / %
运算特点：
1.+ - */ :跟小学数学中一模一样没有任何区别.
2.整数相除结果只能得到整除，如果结果想要是小数，必须要有小数参数。
3.小数直接参与运算，得到的结果有可能是不精确的。
案例：

System.out.println( 10 / 3);//3
System.out.println(10.0 / 3);//3.3333333333333335

4.%：取模、取余。
他做的也是除法运算，只不过获取的是余数而已。
案例：

System.out.println(10 % 2);//0
System.out.println(10 % 3);//1

应用场景：

//可以利用取模来判断一个数是奇数还是偶数
System.out.println(15 % 2);//1  奇数

练习：数值拆分
需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台

公式：

​ 获取任意一个数上每一位数。

个位：数字 % 10

十位：数字 / 10 % 10

百位：数字 / 100 % 10

千位：数字 / 1000 % 10

。。。以此类推。。。
代码示例：

//1.键盘录入一个三位数
//导包 --- 创建对象 --- 接收数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数");
int number = sc.nextInt();//123//2.获取这个三位数的个位、十位、百位并打印出来
//公式：
//针对于任意的一个数而言
//个位： 数字 % 10
int ones = number % 10;
//十位： 数字 / 10 % 10
int tens = number / 10 % 10;
//百位： 数字 / 100 % 10
int hundreds = number / 100  % 10;//输出结果
System.out.println(ones);
System.out.println(tens);
System.out.println(hundreds);

运算符——隐式转换和强制转换

1.隐式转换概念：
也叫自动类型提升。就是把一个取值范围小的数据或者变量，赋值给另一个取值范围大的变量。程序自动帮我们完成的。

简单记忆：
​ 就是小的给大的，可以直接给。
两种提升规则：
1.取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算。
2.byte、short、char三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算。
3.取值范围从小到大的关系：
​ byte <short< int <long <float <double

隐式转换的练习
请看下面案例是否有误，如果有问题，请说出原因，如果没有问题，请说出运算过程和运算结果

2.强制转换概念：
​ 如果要把一个取值范围大的数据或者变量赋值给另一个取值范围小的变量。是不允许直接操作。如果一定要这么干，就需要加入强制转换。

书写格式：目标数据类型 变量名 = （目标数据类型）被强转的数据；

简单理解：

​ 要转成什么类型的，那么就在小括号中写什么类型就可以了。

案例：

public class OperatorDemo2 {public static void main(String[] args) {double a = 12.3;int b = (int) a;System.out.println(b);//12}
}

注意点：

​ 强制转换有可能会导致数据发生错误。（数据的精度丢失）

运算符——字符串和字符的加操作

1.字符串的+操作
核心技巧：

• 当+操作中出现字符串时，此时就是字符串的连接符，会将前后的数据进行拼接，并产生一个新的字符串。
• 当连续进行+操作时，从左到右逐个执行的。

2.字符的+操作
规则：
​ 当+操作中出现了字符，会拿着字符到计算机内置的ASCII码表中去查对应的数字，然后再进行计算。

案例：

char c = 'a';
int result = c + 0;
System.out.println(result);//97

运算符——算术运算符的总结

1.分类：

+ - * / % 这些操作跟小学数学几乎是一模一样的。
2.注意点：

1./ 和 % 的区别：他们两个都是做除法运算，/取结果的商。% 取结果的余数。
2.整数操作只能得到整数，如果想要得到小数，必须有浮点数参与运算。
3.算术运算符的高级用法：是以+为例进行的讲解，其余减法，乘法，除法的运算规则也是一样的。
3.特例：字符串只有+操作，没有其他操作。

运算符——自增自减运算符

分类：
++ 自增运算符
-- 自减运算符
++：就是把变量里面的值+1
--：就是把变量里面的值-1
使用方式：
放在变量的前面，我们叫做先++。 比如：++a
放在变量的后面，我们叫做后++。 比如：a++
注意点：
​ 不管是先++，还是后++。单独写在一行的时候，运算结果是一模一样的。
案例：

//++
int a = 10;
a++;//就是让变量a里面的值 + 1
System.out.println(a);//11
++a;//就是让变量a里面的值 + 1
System.out.println(a);//12

运算符——赋值运算符和关系运算符

1.赋值运算符：最为常用的： =

运算过程：就是把等号右边的结果赋值给左边的变量

案例：

public class OperatorDemo6 {public static void main(String[] args) {//1.最为简单的赋值运算符用法int a = 10;//就是把10赋值给变量aSystem.out.println(a);//2.如果等号右边需要进行计算。int b = 20;int c = a + b;//先计算等号右边的，把计算的结果赋值给左边的变量System.out.println(c);//3.特殊的用法a = a + 10;//先计算等号右边的，把计算的结果赋值给左边的变量System.out.println(a);//20}
}

2.扩展赋值运算符
分类：+=、-=、*=、/=、%=

运算规则：
​ 就是把左边跟右边进行运算，把最终的结果赋值给左边，对右边没有任何影响。

案例：

public class OperatorDemo7 {public static void main(String[] args) {//扩展赋值运算符int a = 10;int b = 20;a += b;//把左边和右边相加，再把最终的结果赋值给左边，对右边没有任何影响// 相当于 a = a + b;System.out.println(a);//30System.out.println(b);//20}
}

注意点：
​ 扩展的赋值运算符中隐层还包含了一个强制转换。

以+=为例。

a += b ;实际上相当于 a = (byte)(a + b);

public class OperatorDemo8 {public static void main(String[] args) {byte a = 10;byte b = 20;//a += b;a = (byte)(a + b);System.out.println(a);//30}
}

3.关系运算符
又叫比较运算符，其实就是拿着左边跟右边进行了判断而已。

分类：
符号 解释
==就是判断左边跟右边是否相等，如果成立就是true，如果不成立就是false
!= 就是判断左边跟右边是否不相等，如果成立就是true，如果不成立就是false
> 就是判断左边是否大于右边，如果成立就是true，如果不成立就是false
>=就是判断左边是否大于等于右边，如果成立就是true，如果不成立就是false
<就是判断左边是否小于右边，如果成立就是true，如果不成立就是false
<=就是判断左边是否小于等于右边，如果成立就是true，如果不成立就是false
注意点：
关系运算符最终的结果一定是布尔类型的。要么是true，要么是false
在写==的时候，千万不要写成=

运算符——四种逻辑运算符

& 和 | 的使用：
&：逻辑与（而且）

​ 两边都为真，结果才是真，只要有一个为假，那么结果就是假。

|：逻辑或（或者）

​ 两边都为假，结果才是假，只要有一个为真，那么结果就是真。

代码示例：

// &  //两边都是真，结果才是真。
System.out.println(true & true);//true
System.out.println(false & false);//false
System.out.println(true & false);//false
System.out.println(false & true);//falseSystem.out.println("===================================");// | 或  //两边都是假，结果才是假，如果有一个为真，那么结果就是真。
System.out.println(true | true);//true
System.out.println(false | false);//false
System.out.println(true | false);//true
System.out.println(false | true);//true

^（异或）的使用：
​ 在以后用的不多，了解一下即可。

计算规则：如果两边相同，结果为false，如果两边不同，结果为true

代码示例：

//^   //左右不相同，结果才是true，左右相同结果就是false
System.out.println(true ^ true);//false
System.out.println(false ^ false);//false
System.out.println(true ^ false);//true
System.out.println(false ^ true);//true

!（取反）的使用：
​ 是取反，也叫做非。

计算规则：false取反就是true，true取反就是false

温馨提示：取反最多只用一个。

代码示例：

System.out.println(!false);//true
System.out.println(!true);//falseSystem.out.println(!!false);//注意点：取反最多只用一个。

运算符——短路逻辑运算符

分类： && ||

&&：
​ 运算结果跟&是一模一样的，只不过具有短路效果。

||：
​ 运算结果跟|是一模一样的。只不过具有短路效果。

逻辑核心：
​ 当左边不能确定整个表达式的结果，右边才会执行。

​ 当左边能确定整个表达式的结果，那么右边就不会执行了。从而提高了代码的运行效率。
注意事项

• &|，无论左边true false，右边都要执行。
• &&||,如果左边能确定整个表达式的结果，右边不执行
• &&：左边为false，右边不管是真是假，整个表达式的结果一定是false
• ||：左边为true，右边不管是真是假，整个表达式的结果一定是true
• 在这两种情况下，右边不执行提高了效率
• 最常用的逻辑运算符：&&，||，！

运算符——三元运算符和运算符等级

三元运算符：又叫做三元表达式或者问号冒号表达式。

格式：关系表达式 ？ 表达式1 ：表达式2 ；

计算规则：
计算关系表达式的值。
如果关系表达式的值为真，那么执行表达式1。
如果关系表达式的值为假，那么执行表达式2。
注意点：
​ 三元运算符的最终结果一定要被使用，要么赋值给一个变量，要么直接打印出来。

案例：

//1.定义三个变量记录和尚的身高
int height1 = 150;
int height2 = 210;
int height3 = 165;//2.利用三元运算符求出两个数中的较大值。
int temp = height1 > height2 ? height1 : height2;//3.求出最终的结果
int max = temp > height3 ? temp : height3;System.out.println(max);

其他的运算符

运算符的优先级

运算符——原码反码补码

1.原码
原码：十进制数据的二进制表现形式，最左边是符号位，0为正，1为负
反码：正数的补码反码是其本身，负数的反码是符号位保持不变，其余位取反
补码：正数的补码是其本身，负数的补码是其反码的基础上+1

原码的弊端
原码：十进制数的二进制形式，最左边是符号位，0为正，1为负
利用原码对正数进行计算不会有问题的
但是如果是负数计算，结果就出错，实际运算的结果，跟我们预期的结果是相反的
2.反码
反码出现的目的
反码：为了解决原码不能计算负数的问题而出现的
计算规则：正数的反码不变，负数的反码在原码的基础上，符号位不变，数值取反，0变1,1变0
反码的弊端：负数运算的时候，如果结果不跨0，是没有任何问题的，但是如果结果跨0，跟实际结果会有1的偏差
3.补码
补码出现的目的
为了解决负数计算时跨0的问题而出现的
补码的计算规则
正数的补码不变，负数的补码在反码的基础上+1。另外补码还能记录一个特殊值-128，该数据在1字节下，没有原码和反码
补码注意点
计算机中的存储和计算都是以补码的形式进行的

判断和循环

判断和循环——流程控制语句

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。

1.1 流程控制语句分类
​ 顺序结构

​ 判断和选择结构(if, switch)

​ 循环结构(for, while, do…while)

1.2 顺序结构
顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

判断和循环——if的格式

2.1 if语句格式1
格式：

if (关系表达式) {语句体;	
}

执行流程：

①首先计算关系表达式的值

②如果关系表达式的值为true就执行语句体

③如果关系表达式的值为false就不执行语句体

④继续执行后面的语句内容

示例：

public class IfDemo {public static void main(String[] args) {System.out.println("开始");	//定义两个变量int a = 10;int b = 20;	//需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于bif(a == b) {System.out.println("a等于b");}		//需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于cint c = 10;if(a == c) {System.out.println("a等于c");}		System.out.println("结束");}
}

练习1：老丈人选女婿
需求：

​ 键盘录入女婿的酒量，如果大于2斤，老丈人给出回应，否则没有任何回应

代码示例：

//分析：
//1.键盘录入女婿的酒量
Scanner sc = new Scanner(System.in);
System.out.println("请输入女婿的酒量");
int wine = sc.nextInt();//5
//2.对酒量进行一个判断即可
if(wine > 2) {System.out.println("不错哟，小伙子！");
}

练习2：考试奖励
需求：

​ 键盘录入一个整数，表示小明的考试名次，如果名次为1，小红可以当小明的女朋有了。

代码示例：

//分析：
//1.键盘录入一个整数，表示小明的考试名次
Scanner sc = new Scanner(System.in);
System.out.println("请输入小明的名次");
int rank = sc.nextInt();
//2.对小明的考试成绩进行判断即可
if(rank == 1){System.out.println("小红成为了小明的女朋友");
}

第一种格式的细节：
如果我们要对一个布尔类型的变量进行判断，不要写==，直接把变量写在小括号中即可。

如果大括号中的语句体只有一条，那么大括号可以省略不写

如果大括号省略了，那么if只能控制距离他最近的那一条语句。

**建议：**自己不要去写，如果别人这么写了，你要能看懂即可。

2.2 if语句格式2
格式：

if (关系表达式) {语句体1;	
} else {语句体2;	
}

执行流程：

①首先计算关系表达式的值

②如果关系表达式的值为true就执行语句体1

③如果关系表达式的值为false就执行语句体2

④继续执行后面的语句内容

示例：

public class IfDemo02 {public static void main(String[] args) {System.out.println("开始");		//定义两个变量int a = 10;int b = 20;//需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，否则，在控制台输出：a的值不大于bif(a > b) {System.out.println("a的值大于b");} else {System.out.println("a的值不大于b");}		System.out.println("结束");}
}

练习1：吃饭
需求：

​ 键盘录入一个整数，表示身上的钱。

​ 如果大于等于100块，就是网红餐厅。

​ 否则，就吃经济实惠的沙县小吃。

代码示例：

//分析：
//1.键盘录入一个整数。表示身上的钱。
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数表示身上的钱");
int money = sc.nextInt();
//2.对钱进行判断
if(money >= 100){System.out.println("吃网红餐厅");
}else{System.out.println("福建大酒店");
}

练习2：影院选座
需求：

​ 在实际开发中，电影院选座也会使用到if判断。

​ 假设某影院售卖了100张票，票的序号为1~100。

​ 其中奇数票号坐左侧，偶数票号坐右侧。

​ 键盘录入一个整数表示电影票的票号。

​ 根据不同情况，给出不同的提示：

​ 如果票号为奇数，那么打印坐左边。

​ 如果票号为偶数，那么打印坐右边。

代码示例：

//分析：
//1.键盘录入票号
Scanner sc = new Scanner(System.in);
System.out.println("请输入票号");
int ticket = sc.nextInt();
if(ticket >= 1 && ticket <= 100){//合法//2.对票号进行判断if (ticket % 2 == 0) {//偶数System.out.println("坐右边");} else {//奇数System.out.println("坐左边");}
}else{//票号不合法System.out.println("票号不合法");
}

2.3 if语句格式3
格式：

if (关系表达式1) {语句体1;	
} else if (关系表达式2) {语句体2;	
} 
…
else {语句体n+1;
}

执行流程：

①首先计算关系表达式1的值

②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值

③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值

④…

⑤如果没有任何关系表达式为true，就执行语句体n+1。

1545616667104

练习1：考试奖励
需求：

​ 小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，

假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。

分析：

​ ①小明的考试成绩未知，可以使用键盘录入的方式获取值

​ ②由于奖励种类较多，属于多种判断，采用if…else…if格式实现

​ ③为每种判断设置对应的条件

​ ④为每种判断设置对应的奖励

代码示例：

//95~100 自行车一辆
//90~94   游乐场玩一天
//80 ~ 89 变形金刚一个
//80 以下  胖揍一顿//1.键盘录入一个值表示小明的分数
Scanner sc = new Scanner(System.in);
System.out.println("请输入小明的成绩");
int score = sc.nextInt();
//2.对分数的有效性进行判断
if(score >= 0 && score <= 100){//有效的分数//3.对小明的分数进行判断，不同情况执行不同的代码if(score >= 95 && score <= 100){System.out.println("送自行车一辆");}else if(score >= 90 && score <= 94){System.out.println("游乐场玩一天");}else if(score >= 80 && score <= 89){System.out.println("变形金刚一个");}else{System.out.println("胖揍一顿");}
}else{//无效的分数System.out.println("分数不合法");
}

判断和循环——Switch语句

第三章 switch语句
3.1 格式

switch (表达式) {case 1:语句体1;break;case 2:语句体2;break;...default:语句体n+1;break;
}

3.2 执行流程：
首先计算出表达式的值
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
练习：运动计划
需求：键盘录入星期数，显示今天的减肥活动。

周一：跑步

周二：游泳

周三：慢走

周四：动感单车

周五：拳击

周六：爬山

周日：好好吃一顿

代码示例：

package a01switch选择语句;import java.util.Scanner;public class SwitchDemo2 {public static void main(String[] args) {//1.键盘录入一个整数表示星期Scanner sc = new Scanner(System.in);System.out.println("请输入一个整数表示星期");int week = sc.nextInt();//2.书写一个switch语句去跟week进行匹配switch (week){case 1:System.out.println("跑步");break;case 2:System.out.println("游泳");break;case 3:System.out.println("慢走");break;case 4:System.out.println("动感单车");break;case 5:System.out.println("拳击");break;case 6:System.out.println("爬山");break;case 7:System.out.println("好好吃一顿");break;default:System.out.println("输入错误，没有这个星期");break;}}
}

3.3 switch的扩展知识：
default的位置和省略情况

default可以放在任意位置，也可以省略

case穿透

不写break会引发case穿透现象

switch在JDK12的新特性

int number = 10;
switch (number) {case 1 -> System.out.println("一");case 2 -> System.out.println("二");case 3 -> System.out.println("三");default -> System.out.println("其他");
}

switch和if第三种格式各自的使用场景
当我们需要对一个范围进行判断的时候，用if的第三种格式

当我们把有限个数据列举出来，选择其中一个执行的时候，用switch语句

比如：

​ 小明的考试成绩，如果用switch，那么需要写100个case，太麻烦了，所以用if简单。

​ 如果是星期，月份，客服电话中0~9的功能选择就可以用switch

练习：休息日和工作日
需求：键盘录入星期数，输出工作日、休息日。

(1-5) 工作日，(6-7)休息日。

代码示例：

//分析：
//1.键盘录入星期数
Scanner sc = new Scanner(System.in);
System.out.println("请输入星期");
int week = sc.nextInt();//3
//2.利用switch进行匹配
----------------------------------------------------
利用case穿透简化代码
switch (week){case 1:case 2:case 3:case 4:case 5:System.out.println("工作日");break;case 6:case 7:System.out.println("休息日");break;default:System.out.println("没有这个星期");break;
}----------------------------------------------------

利用JDK12简化代码书写

switch (week) {case 1, 2, 3, 4, 5 -> System.out.println("工作日");case 6, 7 -> System.out.println("休息日");default -> System.out.println("没有这个星期");
}

判断和循环——for循环语句

4.1 for循环结构（掌握）
​ 循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形 成死循环。

4.1.1 for循环格式：

for (初始化语句;条件判断语句;条件控制语句) {循环体语句;
}

格式解释：

初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情
条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
执行流程：

①执行初始化语句

②执行条件判断语句，看其结果是true还是false

​ 如果是false，循环结束

​ 如果是true，继续执行

③执行循环体语句

④执行条件控制语句

⑤回到②继续

for循环书写技巧：

确定循环的开始条件
确定循环的结束条件
确定循环要重复执行的代码
代码示例：

//1.确定循环的开始条件
//2.确定循环的结束条件
//3.确定要重复执行的代码//需求：打印5次HelloWorld
//开始条件：1
//结束条件：5
//重复代码：打印语句for (int i = 1; i <= 5; i++) {System.out.println("HelloWorld");
}
for循环练习-输出数据
需求：在控制台输出1-5和5-1的数据
示例代码：
public class ForTest01 {public static void main(String[] args) {//需求：输出数据1-5for(int i=1; i<=5; i++) {System.out.println(i);}System.out.println("--------");//需求：输出数据5-1for(int i=5; i>=1; i--) {System.out.println(i);}}
}

for循环练习-求和
需求：求1-5之间的数据和，并把求和结果在控制台输出
示例代码：

public class ForTest02 {public static void main(String[] args) {//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0int sum = 0;//从1开始到5结束的数据，使用循环结构完成for(int i=1; i<=5; i++) {//将反复进行的事情写入循环结构内部// 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中sum = sum + i;/*sum += i;	sum = sum + i;第一次：sum = sum + i = 0 + 1 = 1;第二次：sum = sum + i = 1 + 2 = 3;第三次：sum = sum + i = 3 + 3 = 6;第四次：sum = sum + i = 6 + 4 = 10;第五次：sum = sum + i = 10 + 5 = 15;*/}//当循环执行完毕时，将最终数据打印出来System.out.println("1-5之间的数据和是：" + sum);}
}

本题要点：
今后遇到的需求中，如果带有求和二字，请立即联想到求和变量
求和变量的定义位置，必须在循环外部，如果在循环内部则计算出的数据将是错误的
for循环练习-求偶数和
需求：求1-100之间的偶数和，并把求和结果在控制台输出 }
示例代码：

public class ForTest03 {public static void main(String[] args) {//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0int sum = 0;//对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同for(int i=1; i<=100; i++) {//对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数if(i%2 == 0) {//sum += i；sum = sum + i;}}//当循环执行完毕时，将最终数据打印出来System.out.println("1-100之间的偶数和是：" + sum);}
}

for循环练习-统计次数
需求：

​ 键盘录入两个数字，表示一个范围。

​ 统计这个范围中。

​ 既能被3整除，又能被5整除数字有多少个？

代码示例：

判断和循环——while循环语句

4.2 while循环
4.2.1 格式：

初始化语句;
while(条件判断语句){循环体;条件控制语句;
}

练习1：打印5次HelloWorld

int i = 1;
while(i <= 5){System.out.println("HelloWorld");i++;
}System.out.println(i);

练习2：珠穆朗玛峰

//1.定义一个变量表示珠穆朗玛峰的高度
int height = 8844430;
//2.定义一个变量表示纸张的厚度
double paper = 0.1;//定义一个计数器（变量），用来统计折叠的次数
int count = 0;//3.循环折叠纸张
//只有纸张的厚度 < 穆朗玛峰的高度 循环才继续，否则循环就停止
//坑：只有判断为真，循环才会继续
while(paper < height){//折叠纸张paper = paper * 2;count++;
}//4.打印一下纸张的厚度
System.out.println(count);//27

4.3 do…while循环
本知识点了解即可

格式：

初始化语句;
do{循环体;条件控制语句;
}while(条件判断语句);

特点：

​ 先执行，再判断。

4.4 三种格式的区别：
​ for和while循环，是先判断，再执行。

​ do…while是先执行，再判断。

​ 当知道循环次数或者循环范围的时候，用for循环。

​ 当不知道循环次数，也不知道循环范围，但是知道循环的结束条件时，用while循环。

数组

数组——什么是数组

1. 数组是一种容器，可以存储同种数据类型的多个值。
2. 数组容器在存储数据的时候要考虑隐式转换考虑。

例如：
int类型可以转为byte short int 但是不能转double和boolean
double 类型的数组容器可以转为byte short int long float double
建议：容器的类型，和存储的数据类型保持一致

数组——数组定义

格式一：数据类型[]数组名
范例：int [] array

格式二:数据类型[] 数组名
范例：int array[]

数组——数组静态初始化

初始化：就是在内存中，为数组容器开辟空间，并将数据寻如容器中的过程
完整格式：数据类型[] 数组名 =new数据类型[]{元素1，元素2，元素3，... ...}；
范例：int[] array=new int[]{11,22,33};
范例：double[] array=new double[]{11.1,11.2};

数组——动态初始化

动态初始化：初始化时只是指定数组的长度，由系统分配初始值
格式：数据类型[]数组名=new 数据类型[数组长度]
范例：int[]arr=new int[3];

数组——数组动态初始化和静态初始化的区别

动态初始化：手动指定数组长度，由系统给出默认初始化值。
静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组长度。
注意：只明确元素的个数，不明确具体数值，推荐使用动态初始化；需求中已经明确了具体数据，直接静态初始化即可。

数组——数组的地址值

int[]arr={1,2,3,4,5};
system.out.println(arr);

拓展
解释地址值格式含义[D@776ec8df
[:表示当前一个数组
D：表示当前数组里面的元素都是double类型的
@：表示一个间隔符号（固定模式）
776ec8df：才是数组真正的地址值，（十六进制）

数组——索引

索引：下标、角标
索引从0开始，连续加1增长不间断

数组——数字遍历

数组遍历：将数组中所有的严内容取出来，取出来之后可以（打印、求和、判断…）
注意：遍历是指取出所有数据的过程，不要局限的理解为遍历就是 打印

数组——java内存分配

栈 方法运行时使用的内存，比如main方法执行，进入方法栈中执行
堆 存储对象或者数组，可以用new来创建，都存储在堆内存
方法区 存储可以运行的class文件
本地方法栈 JVM在使用操作系统功能的时候使用，和我们开发无关
寄存器 给CPU使用，和我们开发无关
注意：从JDK8开始，取消方法区，新增原件，把原来的方法区多种功能进行拆分，有的放到堆中，有的功能在元空间中。
当连个数组指向同一个小空间时，其中一个数组堆小空间中的值发生了改变，那么其他数组再次访问的时候都是修改之后的结果了。

数组——二维数组

什么是二维数组？
数组里面存数组
二维数组的应用场景
当我们需要把数据分组管理

二维数组的静态初始化
格式：数据类型[][] 数据名=new数据类型[][]{{元素1，元素2}，{元素1，元素2}};
范例：int[][]arr={{11,22},{33,44}}或intarr[][]={{11,22},{33,44}}
二维数组的获取元素
arr[i][j]表示：
arr二维数组
i二维数组的索引，获取出来的是里面的一维数组
j表示一维数组中的索引，获取出来的就是真正的元素
例如：
int arr[][]={{11,22},{33,44},{11,22,33,44}}
arr[0]表示二维数组中的第一个一维数组
arr[0][0]表示二维数组中的第一个一维数组的第一个元素

二维数组的动态初始化
格式数据类型[][] 数组名=new 数据类型[m][n]
m表示这个二维数组，可以存放多少个一维数组
n表示每一个一维数组，可以存放多少个元素
范例：int[][]arrnew int[2][3]
该数组可以存放2个一维数组 ，每一个一维数组中可以存放3个int类型元素
二维数组的内存图

static

快捷键：
滚轮或者alt+鼠标不动 修改多行
ctrl+alt+l 格式化代码
1.staitc定义
含义：staic表示静态，是Java中的一个修饰符，可以修饰成员方法，成员变量
（1）静态变量：被static修饰的成员变量
特点：被该类所有的对象共享
不属于对象、属于类
随着类的加载而加载，优先于对象存在
调用方式：
类名调用（推荐）
对象名调用
（2）静态方法:被static修饰的成员方法，叫做静态方法
多用在测试类和工具类中
Javabean类中很少用
调用方式：
类名调用（推荐）
对象名调用

2.static内存图
静态变量优先于对象加载，非静态受变量控制。


备注：可以被共享的属性可以定义为静态属性

3.static应用：编写工具类
工具类：帮助我们做一些事情的，但不是描述任何事物的类
区别：
javabean类：用来描述一类事物的类，比如Dog， Cat等
测试类：用来检查其他类是否书写正确，带有main方法的类，是程序的入口
注意：
1.类名间名知意
2.私有化构造方法
3.方法定义为静态
4.staitic注意事项
因为静态方法没有this关键字所以不能调用非静态的。
a、静态方法只能访问静态变量和静态方法
b、非静态方法可以访问静态变量或者静态方法，也可以访问非静态变量和非静态成员方法
c、静态方法中没有关键字static
继承结构中的语法特点
（1）继承中成员变量的特点
1.继承中成员变量的访问特点：就近原则
在局部位置找–>本类成员位置–>父类位置逐级往上
2.如果出现重名的成员变量怎么办？

Syetem.out.println(name);从局部 位置开始往上找
Syetem.out.println(this.name);从本类成员变量位置开始往上找
Syetem.out.println(super.name);从父类位置开始往上找

（2）方法重写
1.父类的方法不能满足子类的需求时，子类将方法重写
2.书写的格式：在继承体系中，子类出现了和父类一模一样的方法声明，我们将这个子类这个方法为重写的方法（改写方法体）
3.@override重写注解
a、@override是放在重写后的方法上，校验子类重写时语法是否正确。
b、加上注解后如果有红色波浪线，表示语法错误
c、建议重写方法都加上@override注解，代码安全，优雅。
4.方法重写的注意事项和要求
a、重写方法的名称，形参列表必须与父类中的一致
b、子类重写父类方法时，访问权限子类必须大于等于父类（暂时了解：空着不写<protected<public）
c、子类重写父类方法时，返回值类型子类必须小于等于父类
d、建议：重写的方法尽量和父类一致
e、只有被添加到虚方法表中的方法才能被重写
（3）继承中：构造方法的访问特点
a、特点：
父类中的构造方法不会被子类继承
子类中所有的构造方法默认先访问父类中的无参构造，再执行自已。
b、为什么？
子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
子类在初始化的时候，有可能会使用父类中的数据，如果父类没有完成初始化，子类将无法使用父类中的数据。
c、怎么调用父类的构造方法的？
子类构造方法的第一行语句默认都是：super(),不写也存在，且必须时第一行
5.总结：
继承中构造方法的访问特点：
子类不能继承父类的构造方法，但是可以通过super调用
子类构造方法的第一行，有一个默认的super();
默认先访问父类中的无参构造方法，再执行自已
如果想要方法文父类有无参构造，必须手动书写
（4）this、super使用总结
this：理解为变量、表示的当前方法调用者的地址值
super：代表父类的存储空间

关键字	访问成员变量	访问成员方法	访问构造方法
this	this.成员变量 访问成员本类成员变量	this.成员方法{…} 访问本类成员方法	this.{…} 访问本类构造方法
super	super.成员变量 访问父类成员变量	this.成员方法{…} 访问本类成员方法	super.{…} 范围内父类构造方法

抽象类

Java三大特性：封装，继承，多态
1.抽象方法
含义：将共性的行为（方法）抽取父类之后。由于每一个子类执行的内容不是一样的，所以在父类中不能确定具体的方法体，该方法就可以被定义为抽象方法。
抽象类：如果一个类中存在抽象方法，那么该类就必须声明为抽象类。

2.抽象类和抽象方法的定义格式
抽象类定义格式

public abstarct 返回值类型 方法名(参数列表);

抽象方法的定义格式

public abstarct class 类名{}

3.抽象类和抽思想那个方法的注意事项
1）抽象类相当于给了框架去给具体类使用
2）抽象类创建构造方法的作用是给当创建子类对象时候给子类赋值，即直接调用抽象类里的实例方法get/set()
3)抽象类和抽象方法的注意事项
a、抽象类不能被实例化
b、抽象中不一定有抽象方法、有抽象方法的类一定是抽象类
c、可以有构造方法
d、抽象类的子类
要么重写抽象类中的所有的抽象方法
要么是抽象类
4.脑图规划抽象类例子

5.抽象类和抽象方法的意义

6.重新认识main方法

public clasHelloWorld{
public static void mian(String[] args){
System.out.println("Hello")
}

public: 被JVM调用，访问权限足够大
static：被JVM调用，不用创建对象，直接类名访问，因为static是静态的，所以测试类其他方法也需要静态
void:被JVM调用，不需要给JVM返回值
main:一个通用的名称，虽然不是关键字，但可以被JVM识别
String[]args:以前用于接收键盘录入的数据，现在没用

继承

1.继承的含义
1）什么时候用继承？
当类与类之间，存在相同的内容，并且满足子类是父类的一种，就可以考虑使用继承来优化代码
2） Java的继承特点：
a、面向对象的三大特性：封装、继承、多态（封装：对象那个代表什么就封装对应的数据，并且提供数据的对应行为。）
b、Java支持单继承不支持多继承，但支持多层继承即a继承b，b继承c；每一个类都直接或者间接的继承Object
c、子类的继承范围

构造方法	非私有 不能	私有 不能
成员变量	非私有 能	私有 能
–	–	–
成员方法	非私有 能	私有 不能

备注：虚方法表：非private、非static、非final

2.继承的格式

public class Student extends Person{}

Student 为子类（派生类），Person父类（基类或者超类）

3.继承的意义
继承是类与类之间产生子父的关系，子类直接使用，减少代码冗余，提高代码的复用性，子类在父类的基础上增加功能

多态

什么是多态
同类型对象表现的不同形态
多态的表现形式

父类类型 对象名称=子类对象;

多态的前提
有继承/实现关系
有父类引用指向子类对象Fu f=new Zi()
有方法重写
案例：
老师学生注册信息
思路：
1.Person父类：定义属性 创建get/set方法 ,show(){}
2.Teacher类：继承父类，重写show（）
3.Student类：继承父类，重写show（）
4.测试类：public static void register(Person p){
p.show()}创建对象 Person s=new Student（），s.setXX(),s.register()

多态的好处
使用父类型作为单数，可以接收所有的子类对象，体现多态的扩展性和便利
多态调用成员的特点
）成员变量调用：编译看左边，运行看左边
）成员方法调用：编译看左边，运行看右边
多态的优势弊端
1.多态的优势：
在多态的形态下，右边的对象可以实现解耦合，便于拓展和维护，

Person p=new Student();
p.work()//业务逻辑发生改变时，后续代码无需修改
```定义方法的时候，使用父类型作为参数，可以接受所有的子类对象，体现多态的拓展性和便利方法中，使用父类型作为参数，可以接受所有的子类对象
2.多态的弊端：
能使用子类特有的功能
3.应用数据类型的类型转换，有几种方式？自动类型转换，强制类转换```java
Person p=new Student();
Student s=(Student)p;

4.强制类型转换能解决什么问题？
a、可以转换成真正的子类类型，从而调用子类独有的功能
b、转换类型与真实对象类型不一致会报错
c、转换的时候用instanceof关键字进行判断

接口

1.接口
1）接口代表规则，是行为的抽象，想要让哪个类拥有一个行为就让这个类实现对应的接口
2）当一个方法的参数是接口的时候，可以传递接所有实现的类的对象，这种方式成为接口多态

2.接口应用
不在乎搬家的对象，可以完成搬家这个行为就可以
接口定义

public interface 运输{
}

实体类

public void 搬家(运输的接口 c){
}

3.与抽象类的异同
1）抽象类对类的抽象
2）接口对行为的抽象

4.接口的定义和使用
1）接口的关键案子interface定义

public interface 接口名{}

2）接口不能实例化
3）接口和类之间是实现关系，通过implement关键字表示

public class 类名 implements 接口名 {}

4）接口的子类（实现类）
要么重写接口中的所有方法
要么是抽象类
5）注意事项
注意1：接口和类的实现关系，可以单实现，也可以多实现

public class 类名 implements 接口名1,接口名2{}

注意2：实现类还可以继承一个类的同时实现多个接口。

public class 类名 extends 父类 implements 接口名1，接口名2{}

5.接口中成员特点
1）成员变量
只能是常量
默认修饰符public static final
2）构造方法
没有
3）成员方法
只能是抽象方法
默认修饰符public abstract
6.接口和类之间的关系
1）类和类的关系
继承关系，只能单继承，不能多继承，但是可以多层继承
2）类是接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
3）接口和接口的关系
继承关系，可以单继承也可以多继承
7.例子分析

8.JDK接口的演变
JDK7以前：接口只能定义抽象方法
**JDK8的新特性：**接口中可以有方法体的方法
JDK9的新特性：接口中可以定义私有的方法
JDK8以后接口中新增加的方法
1)允许在接口中定义默认的方法，需要使用关键字default修饰
作用：解决接口升级的问题
2)接口中默认方法的定义格式：
格式：public default 返回值类型 方法名（参数列表）{}
范例：public default void show(){}
3)接口中默认方法的注意事项
默认方法不是抽象方法，所以不强制被重写，但如果被重写，重写要去掉default关键字
public可以省略，default不能省略
如果实现多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法重写

JDK9的新增的方法
接口中私有的方法的定义格式
格式1 private 返回值类型 方法名(参数列表){}
范例1： private void show(){}
格式2： private satic 返回值类型 方法名（参数列表）{}
范例2：private static void method(){}

interface Inter{
public default void start(){
System.out.println("statrt rountime working..")
log();
}
public default void end(){
System.out.println("end rountine working..");
log();
}
}

public default void log(){
System.out.println("logging")
}
```java
此方法只为Inter接口提供服务，不需要外类访问```java
private void log(){
System.out.println("logging");

9.适配器设计模型
（1）设计模式：是一套反复使用，被多数人知晓的，经过分类编目的，代码设计经验的总结，使用设计模式是为了可重复的代码，让代码更容易被他人理解，保证代码的可靠性，程序的复用性
(2）适配器设计模式：解决皆苦中和实现类之间的矛盾问题
3）.总结
1）当一个接口的抽象方法过多，但是我只要使用其中的一部分的使用就可以用适配器模型
2）书写步骤：
编写中间类XXXAdapter 实现对应接口
对接口的抽象方法进行空实现
让真正了解实现类继承中间类，并且重写需要的方法
为了避免其他类创建适配器类的对象，中间适配类用abstract进行修饰。
如图