diff --git "a/01\350\213\217\346\270\205\345\215\216/20221124\345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250.md" "b/01\350\213\217\346\270\205\345\215\216/20221124\345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250.md"
deleted file mode 100644
index 2f7922059497434b60c17490880fd6ee01625065..0000000000000000000000000000000000000000
--- "a/01\350\213\217\346\270\205\345\215\216/20221124\345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250.md"
+++ /dev/null
@@ -1,72 +0,0 @@
-# 学习怎么安装jdk和使用
-
-#### 2022.11.4
-
-### jdk的下载与安装
-
-1.下载（可下载**jdk8,11 17**）
-
- 1.通过官方网站获取JDK（https://www.oracle.com/）
-
- 2.直接下载地址： https://www.oracle.com/java/technologies/javase-downloads.html
-
- 3.搜索国内镜像在好人分享的网盘里下载（方便）
-
-**注意：下载对应操作系统的jdk**
-
-2.安装
-
- 1.傻瓜式安装，下一步即可。
-
- 2.建议：安装路径中不要包含中文和空格。所有的开发工具最好安装目录统一。E:\develop\java\bin
-
-**注意：不要中文，不要空格。**
-
-### jdk安装后如何使用
-
-1.配置环境变量
-
- 此电脑—右键属性—高级系统设置—高级—环境变量—找到path双击打开—新建E:\develop\java—确定*2—退出
-
-2.如何使用**javac（编译）和java（运行）**命令
-
- 1.配置JAVA_HOME变量
-
- 1.此电脑—右键属性—高级系统设置—高级—环境变量—新建—变量名：JAVA_HOME 变量值：E:\develop\java
-
- 2.双击path—新建**%JAVA_HOME%bin**（因为是变量所以加上%）
-
-3.开发流程：编写—编译—运行。 文件名后缀为**.java**
-
-### 第一个程序
-
-##### HelloWorld程序编写
-
-1.新建一个文本文档，重命名为HelloWorld.java
-
-2.使用记事本方式打开
-
-3.书写以下内容
-
-```java
-public class HelloWorld{
- public static void main(String [] args){
- system.out.println("HelloWorld");
- }
-}
-```
-
-4.如何运行
-
-在当前文件夹内的地址栏 输入cmd回车，输入
-
-javac HelloWorld.java(编译，生成一个class文件) 回车后输入
-
-java HelloWorld (运行，输出内容) **注意：运行代码不需要加后缀名**
-
-输出的内容为 HelloWorld
-
-
-
-
-
diff --git "a/02 \346\236\227\344\275\263\346\263\275/20221124 \345\255\246\344\271\240JDK\345\256\211\350\243\205\345\222\214git\344\275\277\347\224\250 \347\254\254\344\270\200\344\270\252JAVA\347\250\213\345\272\217.md" "b/02 \346\236\227\344\275\263\346\263\275/20221124 \345\255\246\344\271\240JDK\345\256\211\350\243\205\345\222\214git\344\275\277\347\224\250 \347\254\254\344\270\200\344\270\252JAVA\347\250\213\345\272\217.md"
deleted file mode 100644
index 0bbaace504ba531ae2e40d35c9abed512e1297cd..0000000000000000000000000000000000000000
--- "a/02 \346\236\227\344\275\263\346\263\275/20221124 \345\255\246\344\271\240JDK\345\256\211\350\243\205\345\222\214git\344\275\277\347\224\250 \347\254\254\344\270\200\344\270\252JAVA\347\250\213\345\272\217.md"
+++ /dev/null
@@ -1,107 +0,0 @@
-## JDK安装配置
-
-##### ①JDK的下载：
-
-```
-JDK国内镜像：编程宝库
-```
-
-##### ②JAVA编译运行
-
-```
-javac 文件名.java（编译出class文件）
-
-java class文件（运行）
-```
-
-##### ③JAVA环境变量配置步骤（实现全系统运行）
-
-```
-计算机（右键）→属性→高级→环境变量→Path→添加新一项“%JAVA_HOME%\bin”
-```
-
-## Dos基础命令
-
-```
-（1）dir：显示当前文件/盘的文件
-```
-
-```
-（2）md：创建新的文件夹
-```
-
-```
-（3）cd：进入文件夹 cd..：退回上个文件夹 cd/：退回盘
-```
-
-```
-（4）del *.扩展名：删除当前文件夹下拓展名全部文件
-
- del 文件夹名：清空文件夹内的文件
-```
-
-```
-(5) rd:删除文件夹目录
-```
-
-## 写第一个JAVA程序
-
-（1）创建一个以“HelloWorld.java”命名的文件
-
-（2）
-
-```java
-Public class HelloWorld{
- public static void main(String[] args){
- System.out.println("Hello World");
- }
-}
-```
-
-## git操作
-
-1. ##### 安装git
-
- ```
- 下载地址:https://registry.npmmirror.com/-/binary/git-for-windows/v2.38.1.windows.1/Git-2.38.1-64-bit.exe
- 一键安装
- ```
-
-2. ##### 注册gitee.com帐号
-
- ```
- 注册地址:www.gitee.com
-
- 注册后,加入班级的组织.fork对应的仓库
-
- 复制仓库克隆地址
- ```
-
-
-
-3. ##### git命令使用
-
- ```
- 1. git clone 仓库的地址 “克隆仓库到本地命令,在本地电脑” ⭐首次配置需要
- 2. git config --global user.email "你的邮箱地址" “git中设置邮箱” ⭐首次配置需要
- 3. git config --global user.name "你的用户名" “git中设置gitee用户名” ⭐首次配置需要
- 4. git add . “添加文件到暂缓区” 🔺每次都需要
- 5. git commit -m "说明文字" “文件上传说明”🔺每次都需要
- 6. git push “文件推送到Gitee网络仓库”🔺每次都需要
-
- 回到gitee
-
- 1. +pull request “提交作业”
- ```
-
- ## 作业命名
-
- ```
- 1. 在U盘创建“JAVA仓库”
- 2. 克隆仓库到本地“JAVA仓库”
- 3. 在“JAVA仓库”文件夹创建 “座号 姓名”文件夹
- 4. 在“座号 姓名”文件夹创建以 “日期 当日学习作业名称.md”
- 5. 编写完成后提交作业
- ```
-
-
\ No newline at end of file
diff --git "a/03\345\276\220\351\233\250\346\231\264/20221124 \345\246\202\344\275\225\345\256\211\350\243\205JDK\345\222\214\344\275\277\347\224\250Git.md" "b/03\345\276\220\351\233\250\346\231\264/20221124 \345\246\202\344\275\225\345\256\211\350\243\205JDK\345\222\214\344\275\277\347\224\250Git.md"
deleted file mode 100644
index f588d6cc5d6f30d5103959c27fc9aa8f5db2cc55..0000000000000000000000000000000000000000
--- "a/03\345\276\220\351\233\250\346\231\264/20221124 \345\246\202\344\275\225\345\256\211\350\243\205JDK\345\222\214\344\275\277\347\224\250Git.md"
+++ /dev/null
@@ -1,71 +0,0 @@
-### Java的安装
-
-1. #### JDK的下载：http://www.codebaoku.com/jdk/jdk-index.html
-
- JDK 是 Java 语言的软件开发工具包。JDK 是整个 Java 开发的核心，它包括 Java 运行环境、Java 基础类库和 Java 工具。
-
- 目前，JDK有三个长期支持版本(LTS)，分别是：JDK8、JDK11和JDK17。
-
- - 注意：针对不同操作系统，下载对应的JDK(Windows、Linux、MacOS、Solaris，一般都采用windows x64版本)
-
-2. #### JDK的安装：
-
- - 傻瓜式安装，点击下一步即可
-
- - 所有的开发工具最好安装目录统一——D:\develop
-
- 建议：安装路径中不要包含中文和空格 JDK——D:\develop\Java
-
- - 公共JRE（点击——X此功能将不可用）
-
- - 点击下一步，即可安装完毕
-
-3. #### Java的配置：
-
- - **环境变量的配置**
-
- 此电脑属性——高级系统设置——环境变量——新建(系统变量)——变量名（%JAVA_HOME%）——变量值（D:develop\Java）
-
- 环境变量——编辑(Path)——新建——环境变量（%JAVA_HOME%\bin）
-
- - **HelloWorld程序编写**
-
- 1. 在Java目录下新建一个文本文档文件，修改文件名为HelloWorld.java
-
- 2. 选中HelloWorld.java文件，用Windows系统自带的记事本打开
-
- 3. 书写如下程序内容：
-
- `````java
- public class HelloWorld{
- public static void main (String[] args){
- System.out.println("Hello World!");
- }
- }
-
-
-
- 4. 保存文件：Ctrl+s;
-
- - 注意：文件名的后缀要与文件类型一致，也要与代码中的一致。
-
- - **HelloWorld程序的编译和运行**
-
- 1. *编译程序*
-
- 格式：javac 文件名.java
-
- 范例：javac HelloWorld.java
-
- 2. *运行程序*
-
- 格式：java 类名
-
- 范例：java HelloWorld
-
-
-
-
-
-
-
diff --git "a/08 \350\224\241\346\263\275\351\222\246/20221124 \345\255\246\344\271\240java\347\232\204\347\254\254\344\270\200\350\257\276.md" "b/08 \350\224\241\346\263\275\351\222\246/20221124 \345\255\246\344\271\240java\347\232\204\347\254\254\344\270\200\350\257\276.md"
deleted file mode 100644
index dce7f97d8decdb64e4d76870bef85a8215b50cce..0000000000000000000000000000000000000000
--- "a/08 \350\224\241\346\263\275\351\222\246/20221124 \345\255\246\344\271\240java\347\232\204\347\254\254\344\270\200\350\257\276.md"
+++ /dev/null
@@ -1,16 +0,0 @@
-jdk的安装
-
- 1.下载
- 2.安装
- 3.配置环境变量
- 4.测试运行helloWord
-
-作业
-
-```java
-public class Helloword ld{
- public static void main(String[] args){
- system.out.println("helloword")
- }
-}
-```
\ No newline at end of file
diff --git "a/10 \346\234\261\345\277\227\351\271\217/2022 11.24 \347\254\254\344\270\200\350\212\202\350\257\276java.md" "b/10 \346\234\261\345\277\227\351\271\217/2022 11.24 \347\254\254\344\270\200\350\212\202\350\257\276java.md"
deleted file mode 100644
index 3a46bdef83477286eaf4e566d1351a70789eb9b8..0000000000000000000000000000000000000000
--- "a/10 \346\234\261\345\277\227\351\271\217/2022 11.24 \347\254\254\344\270\200\350\212\202\350\257\276java.md"
+++ /dev/null
@@ -1,44 +0,0 @@
-## java语言概述
-
-1.Java是sun公司开发的一门编程语言,目前被Oracle公司收购，编程语言就是用来编写软件的。
-
-### Java的应用
-
-开发QQ、迅雷程序(桌面应用软件)
-
-淘宝、京东(互联网应用软件)
-
-安卓应用程序
-
-### Java语言
-
-JavaSE（标准版）部分,JavaSE并不能开发大型项目
-
-JavaEE（企业版）部分,学习完JavaEE部分就可以开发各种大型项目了
-
-## java下载
-
-JDK官网 http://www.oracle.com/cn/index.html
-
-
-
-
-
-
-
-练习
-
-```java
- public-class Helloworld{
- public static void main(string[] args){
- Systen.out.println("666")
- }
- }
-```
-
-
-
-
-
-
-
diff --git "a/13 \345\274\240\345\276\267\345\272\267/20221125 \345\255\246\344\271\240\345\256\211\350\243\205jdk\344\275\277\347\224\250git.md" "b/13 \345\274\240\345\276\267\345\272\267/20221125 \345\255\246\344\271\240\345\256\211\350\243\205jdk\344\275\277\347\224\250git.md"
deleted file mode 100644
index f2df0b9241f2c1ba4044165895850c14f78e3fb8..0000000000000000000000000000000000000000
--- "a/13 \345\274\240\345\276\267\345\272\267/20221125 \345\255\246\344\271\240\345\256\211\350\243\205jdk\344\275\277\347\224\250git.md"
+++ /dev/null
@@ -1,53 +0,0 @@
-## JAVA的安装
-
-1.下载jdk：https://www.oracle.com/downloads/
-
-2.安装jdk：不要空格；不要中文
-
-3.配置环境变量
-
-1. 在系统变量建立%JAVA_HOME%并添加路径
-2. 在path添加%JAVA_HOME%/bin
-
-4.开发一个Java 程序：javac编译程序，java运行程序，展现结果程序
-
-5.编写代码时：文件名和代码中类名一致
-
-## Gitee的使用
-
-1. 在班级仓库下点击forked链接本身仓库
-
-2. 在自己仓库打开Git bash here
-
-3. 输入git clone 仓库地址
-
-4. 后输入git add .
-
-5. git commit -m "名称"
-
- 1.git config --global user.email "1669327472@qq.com"
-
- 2.git config --global user.name "张德康"
-
- 3.输入账号与密码
-
- 4.git commit -m "名称"
-
-7. git push
-
-
-
-
-
-
-
-## 作业
-
-```java
-public class Helloworld{
- public static void main(String[] args){
- Ststem.out.println("Hi MXDX");
- }
-}
-```
-
diff --git "a/14\345\217\267\345\256\213\345\256\217\346\211\254/20221124\345\205\263\344\272\216Java\347\256\200\344\273\213\343\200\201JDK\347\232\204\344\270\213\350\275\275\345\256\211\350\243\205\344\270\216\345\237\272\346\234\254\347\250\213\345\272\217\347\274\226\345\206\231.md" "b/14\345\217\267\345\256\213\345\256\217\346\211\254/20221124\345\205\263\344\272\216Java\347\256\200\344\273\213\343\200\201JDK\347\232\204\344\270\213\350\275\275\345\256\211\350\243\205\344\270\216\345\237\272\346\234\254\347\250\213\345\272\217\347\274\226\345\206\231.md"
deleted file mode 100644
index 3c69759f09fa58e64fa13fc6e9372951a2642c81..0000000000000000000000000000000000000000
--- "a/14\345\217\267\345\256\213\345\256\217\346\211\254/20221124\345\205\263\344\272\216Java\347\256\200\344\273\213\343\200\201JDK\347\232\204\344\270\213\350\275\275\345\256\211\350\243\205\344\270\216\345\237\272\346\234\254\347\250\213\345\272\217\347\274\226\345\206\231.md"
+++ /dev/null
@@ -1,53 +0,0 @@
-### java简介
-
-##### 一、Java的版本分类
-
-1. Java SE：标准版，是其他两个版本的基础
-2. Java ME：小型版，用于嵌入式电子设备或者小型移动设备
-3. Java EE：企业版，用于企业应用开发，包括web方向开发
-
-##### 二、JDK的下载和安装
-
-JDK的版本：长期版本为JDK8、JDK11、JDK17
-
-###### JDK的下载
-
-1. 通过官网下载：通过官方网站（https://www.oracle.com/）
-
-2. 直接下载地址：https://www.oracle.com/java/technologies/javase-downloads.html
-
- (安装路径不要包含中文和空格，统一开发工具的安装目录【D:\develop】)
-
-###### JDK的安装目录
-
-1. bin：该路径下存放了JDK的各种工具命令，javac命令（编译）和java命令（运行）就在该工具下
-2. conf：该路径下存放了JDK的相关配置文件
-3. include：该路径下存放了一些平台特定的头文件
-4. jmods：该路径下存放了JDK的各种模块
-5. legal：该路径下存放了JDK各模块的授权文档
-6. lib：该路径下存放了JDK工具的一些补充JAR包
-
-##### 三、java程序编写
-
-1. 开发流程：编写程序 —> 编译程序（javac） —> 运行（java）
-
-2. 编辑环境变量：此电脑 —> 属性 —> 高级系统设置 —> 环境变量 —> path —> 编辑
-
-3. 编写程序：
- ```java
- public class HelloWorld {
- public static void main(String[] args) {
- System.out.println("HelloWorld");
- }
- }
- ```
-
- 注：文件后缀名是.java，文件类型是java文件；文件名和代码中类名一致
-4. 编译程序
- - 格式：javac 文件名.java
- - 范例：javac HelloWorld.java
-5. 运行程序
- - 格式：java 类名
- - 范例：java HelloWorld
-
-
diff --git "a/15\346\262\210\347\206\231\347\245\245/20221124JDk\347\232\204\345\256\211\350\243\205\344\270\216\344\275\277\347\224\250.md" "b/15\346\262\210\347\206\231\347\245\245/20221124JDk\347\232\204\345\256\211\350\243\205\344\270\216\344\275\277\347\224\250.md"
deleted file mode 100644
index 921401cab153c74415be124211eab59803016ca8..0000000000000000000000000000000000000000
--- "a/15\346\262\210\347\206\231\347\245\245/20221124JDk\347\232\204\345\256\211\350\243\205\344\270\216\344\275\277\347\224\250.md"
+++ /dev/null
@@ -1,74 +0,0 @@
-### JDK的下载和安装
-
-- ##### JDK的下载
-
- 1. 通过官方网站获取JDK ： https://www.oracle.com/
- 2. 直接下载：[JDK下载 - 编程宝库 (codebaoku.com)](http://www.codebaoku.com/jdk/jdk-index.html)
-
- 注意：针对不同操作系统，下载对应的JDK
-
-
-
-- ##### JDK的安装
-
-1. 安装路径不要包含 **中文**和**空格**
-
-3. 两个重要工具
-
-3. 需要配置环境变量
-
- 编译工具：javac
-
- 运行工具：java
-
-
-- ##### 第一个程序
-
- 1. HelloWorld程序编写
-
- ```java
- public class HelloWorld{
- public static void main(String[] args){
- System.out.println("HelloWorld");
- }
- }
- ```
-
-
- 注意： 文件名和类名一致，文件后缀名是 .java
-
-
-
- 2.编译和运行程序
-
- 打开DOS窗口
-
- 编译程序 javac 文件名.java
-
- 运行程序 java 文件名
-
-
-
-
-
-
-
-## Git的使用
-1.git clone 下载地址
-
-2.git add .
-
-3.git commit -m "名称"
-
-4.git config --global user.email "邮箱"
-
-5.git config --global user.name "用户名"
-
-6.输入账号密码
-
-7.git commit -m "名称"
-
-8.git push
-
-
-
diff --git "a/16 \346\236\227\346\210\220\351\270\277/20221124 jdk\347\232\204\345\256\211\350\243\205\344\273\245\345\217\212gitee\344\273\223\345\272\223\347\232\204\344\275\277\347\224\250.md" "b/16 \346\236\227\346\210\220\351\270\277/20221124 jdk\347\232\204\345\256\211\350\243\205\344\273\245\345\217\212gitee\344\273\223\345\272\223\347\232\204\344\275\277\347\224\250.md"
deleted file mode 100644
index b03daf5e75c6eb26f669298f99f3bcfe7e3ccbf3..0000000000000000000000000000000000000000
--- "a/16 \346\236\227\346\210\220\351\270\277/20221124 jdk\347\232\204\345\256\211\350\243\205\344\273\245\345\217\212gitee\344\273\223\345\272\223\347\232\204\344\275\277\347\224\250.md"
+++ /dev/null
@@ -1,35 +0,0 @@
-## java程序 jdk的安装以及配置环境变量
-
-有二种方法下载java程序的jdk
-
-1. 去官网那边下载jdk（https://www.oracle.com/）
-2. 另一种就是jdk的国内镜像 （https://www.oracle.com/java/technologies/javase-downloads.html）
-
-二种都是可以的 我们下载的是jkd 8 的版本
-
-
-
-## 配置环境变量
-
-1. 第一步 此电脑右键属性--然后高级系统设置--高级下面的环境变量
-2. 第二步 环境变量里面在下面空白处新建 变量名：（JAVA_HOME）变量值：（你jkd下载的位置）
-3. 第三步 在系统变量里面找到（path）点进去新建一个（%JAVA_HOME%\bin）
-4. 第四步 验证 打开运行窗口 在里面输入java和javac 有反应说明可以了
-
-
-
-## 第一个JAVA程序
-
-1. 在一个新建文件夹里面建一个文本框（HelloWorld.java）里面打出下面内容
-
- ```JAVA
- public class HelloWorld{
- public static void main(String[] args){
- System.out.println("Hi Lin Cheng Hong")
- }
- }
- ```
-
-2. 之后在运行窗口用命令（JAVAC HelloWorld.java）就会变成(HelloWorld.class)
-
-3. 之后运行窗口用命令（JAVA HelloWorld）就会在运行窗口输出结果了
\ No newline at end of file
diff --git "a/17\351\203\221\347\216\256\351\224\213/20221124 \345\255\246\344\271\240java\347\232\204\347\254\254\344\270\200\350\257\276.md" "b/17\351\203\221\347\216\256\351\224\213/20221124 \345\255\246\344\271\240java\347\232\204\347\254\254\344\270\200\350\257\276.md"
deleted file mode 100644
index dce7f97d8decdb64e4d76870bef85a8215b50cce..0000000000000000000000000000000000000000
--- "a/17\351\203\221\347\216\256\351\224\213/20221124 \345\255\246\344\271\240java\347\232\204\347\254\254\344\270\200\350\257\276.md"
+++ /dev/null
@@ -1,16 +0,0 @@
-jdk的安装
-
- 1.下载
- 2.安装
- 3.配置环境变量
- 4.测试运行helloWord
-
-作业
-
-```java
-public class Helloword ld{
- public static void main(String[] args){
- system.out.println("helloword")
- }
-}
-```
\ No newline at end of file
diff --git "a/18 \350\260\242\345\256\270/JDK\347\232\204\344\270\213\350\275\275\345\222\214\345\256\211\350\243\205.md" "b/18 \350\260\242\345\256\270/JDK\347\232\204\344\270\213\350\275\275\345\222\214\345\256\211\350\243\205.md"
deleted file mode 100644
index 1d8445bb37b636db37a959fee7b135ba91df926d..0000000000000000000000000000000000000000
--- "a/18 \350\260\242\345\256\270/JDK\347\232\204\344\270\213\350\275\275\345\222\214\345\256\211\350\243\205.md"
+++ /dev/null
@@ -1,43 +0,0 @@
-# **JDK**的下载和安装
-
-1.通过官方网站获取JDK（https://www.oracle.com/）
-
-2.直接下载地址： https://www.oracle.com/java/technologies/javase-downloads.html
-
-3.安装路径中不要包含中文和空格
-
-4.所有的开发工具最好安装目录统一 例：D:\develop
-
-# JDK的环境变量
-
-1.新建JAVA_HOME变量
-
-例子：变量名：JAVA_HOME
-
- 变量值：D:\develop\Java\jdk-1.8
-
-2.编辑path变量
-
-例子：编辑Path变量，在最上面新建一个值：%JAVA_HOME%\bin
-
-# 打开运行窗口
-
-1.win+r
-
-2.cmd
-
-3.回车
-
-
-# 作业
-
-```java
-public class HelloWorld{
- public static void main(String[] args){
- system.out.println("HelloWorld")
- }
-}
-```
-
-
-
diff --git "a/19 \345\224\220\345\233\275\344\272\256/20221124 \345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250git.md" "b/19 \345\224\220\345\233\275\344\272\256/20221124 \345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250git.md"
deleted file mode 100644
index ffe2959e235395b8864f36be80277ab9c2aeb442..0000000000000000000000000000000000000000
--- "a/19 \345\224\220\345\233\275\344\272\256/20221124 \345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250git.md"
+++ /dev/null
@@ -1,50 +0,0 @@
-# 第一次笔记
-
-## java的安装
-
-1.下载JDK：http://www.oraloe.com
-
-2.安装jdk:注意：不要空格不要中文
-
-3.需要配置环境变量
-
-4.操作步骤
-
-右击此电脑
-关于下面
- 相关设置 高级系统设置
- 环境变量
- 系统变量 新建 变量名：JAVA_HOME 变量值：路径安装的路径整个文件夹
- 找到Path 双击
-新建 %JAVA_HOME%\bin
-确定
- 打开D盘在导航栏输入Cmd
-
-## gitee的使用
-
-1.在gitee中吧班级仓库链接复制到自己的Java仓库
-
-2.在Java仓库中使用git得到文件夹
-
-3.吧笔记和作业保存到typora中
-
-4.选中Java仓库中的-git使用git clone 复制的网址
-
-5.编辑好文件名字和邮箱地址 git clone --giobal user.enail "12345679@XX.com"
-
-git config --global user.name "姓名" git commit -m "我的第一次作业" git push
-
-6.登录 找到自己的仓库 找到+Pull Request 输入名称创建pull
-
-
-
-## 作业
-
-```java
-public-class HelloWorld{
- public static void main(String[] args){
- System.out.println("Hi MXDX!");
- }
- }
-```
-
diff --git "a/20 \345\206\257\351\224\220/1img/\345\233\276\347\211\2071.jpg" "b/20 \345\206\257\351\224\220/1img/\345\233\276\347\211\2071.jpg"
new file mode 100644
index 0000000000000000000000000000000000000000..508c3fe609cc07af248790220059212bc10aa4da
Binary files /dev/null and "b/20 \345\206\257\351\224\220/1img/\345\233\276\347\211\2071.jpg" differ
diff --git "a/20 \345\206\257\351\224\220/2022 11 28.md" "b/20 \345\206\257\351\224\220/2022 11 28.md"
new file mode 100644
index 0000000000000000000000000000000000000000..23a723f3bc03e18575378c73addc7c5a9237d9fb
--- /dev/null
+++ "b/20 \345\206\257\351\224\220/2022 11 28.md"
@@ -0,0 +1,323 @@
+# 基础语法
+
+### 1.字面量
+
+**字面量概述**
+
+ 直接写出来的人可以理解的数据，在java中叫做字面量
+
+ 举例：“*HelloWorld*”，*666*，*13.14*
+
+**字面量分类**
+
+| 字面量类型 | 说明 | 举例 |
+| ------------ | -------------------- | ------------------------- |
+| 字符串字面量 | 用双引号括起来的内容 | “HelloWorld”,“java程序员” |
+| 整数字面量 | 不带小数的数字 | 666，-88 |
+| 小数字面量 | 带小数的数字 | 13.14，-5.21 |
+| 字符字面量 | 用单引号括起来的内容 | ‘A’，‘0’，‘我’ |
+| 布尔字面量 | 布尔值，表示真假 | 只有两个值：true，false |
+
+ **总结**
+
+1.*什么是字面量*
+
+ 直接写出来的人可以理解的数据
+
+2.字面量分类
+
+ 字符串，整数，小数，字符，布尔
+
+### 2.数据类型
+
+**数据类型的概述**
+
+java语言的强类型语言，对于每一种数据都给出了明确的类型
+
+| 数据 | 数据类型 |
+| ------------ | ---------------------- |
+| “HelloWorld” | 字符串类型 |
+| 666 | 整数类型 |
+| 13.14 | 浮点数类型（小数类型） |
+| ‘A’ | 字符类型 |
+| true | 布尔类型 |
+
+不同的数据类型分配了不同的内存空间
+
+不同的内存空间，所储存的数据大小是不一样的
+
+**计算机储存单元**
+
+计算机中储存数据的最小单位是：（byte），用B表示
+
+
+
+常见的储存单位：
+
+1TB=1024GB
+
+1GB=1025MB
+
+1MB=1024KB
+
+1KB=1024B
+
+
+
+**数据类型分类**
+
+
+
+
+
+
+
+**数据类型内存占用和取值范围**
+
+| 数据类型 | 关键字 | 占用内存 | 取值范围 |
+| ------------ | ------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
+| 整数 | byte | 1 | -128~127 |
+| short | 2 | -32768~32767 | -32768~32767 |
+| ***int*** | 4 | -2的31次方到2的31次方-1 | -2的31次方到2的31次方-1 |
+| long | 8 | -2的63次方到2的63次方-1 | -2的63次方到2的63次方-1 |
+| 浮点数 | float | 4 | 负数：-3.402823E+38到-1.401298E-45 正数：1.401298E-45到3.402823E+38 |
+| ***double*** | 8 | 负数：-1.797693E+308到-4.9000000E-324 正数：4.9000000E-324到1.797693E+308 | 负数：-1.797693E+308到-4.9000000E-324 正数：4.9000000E-324到1.797693E+308 |
+| 字符 | char | 2 | 0~65535 |
+| 布尔 | boolean | 1 | true，false |
+
+说明：E+38表示：乘以10的38次方。同理E-45表示：乘以10的负45次方
+
+**总结**
+
+1.数据类型分类
+
+基本类型
+
+引用类型
+
+2.基本类型分类
+
+
+
+3.默认值
+
+整数：int
+
+浮点数：double
+
+4.字符串
+
+String
+
+
+
+
+
+### 3.变量
+
+**什么是变量**
+
+变量就是内存中的储存空间
+
+空间中储存的数据是可以发生改变
+
+**变量的定义格式**
+
+格式：数据类型 变量名=变量值；
+
+范例：int pric=998
+
+**变量的使用**
+
+根据变量名进行使用，可以输出，也可以修改值
+
+```java
+public class VariableDemo01 {
+ public static void main(String[] args) {
+ int price = 998;
+ System.out.println(price);
+ price = 888;
+ System.out.println(price);
+ }
+}
+```
+
+**总结**
+
+1.什么是变量
+
+就是内存中的存储空间
+
+空间中存储的数据是可以发生改变
+
+2.变量的定义
+
+数据类型 变量名 = 变量值;
+
+3.变量的使用
+
+输出使用
+
+修改值
+
+
+
+
+
+① String name = “风清扬”;
+
+② int age = 36;
+
+③ char gender = ‘男’; 也可以采用String类型表示
+
+④ double temperature = 36.2;
+
+⑤ boolean flag = true; 也可以采用char或者String表示
+
+
+
+**变量的注意事项**
+
+变量名不能重复定义
+
+变量未赋值，不能使用
+
+定义long类型变量，数据后面加L
+
+定义float类型变量，数据后面加F
+
+### 4.关键字
+
+**关键字概述**
+
+关键字：就是被Java语言赋予了特定含义的单词
+
+关键字特点：
+
+关键字的字母全部小写
+
+常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观
+
+ ```java
+ public calss HelloWorld{
+ /*
+ 这是main方法
+ main方法是程序的入口方法，代码的执行是从main方法开始的
+ */
+ public static void mian(String[] args){
+ //这是输出语句，能够将""里面的内容输出到控制台，并且""里面的内容是可以修改的
+ System.out.println("HelloWorld");
+ System.out.println("Java");
+ }
+ }
+ ```
+
+| **abstract** | **assert** | **boolean** | **break** | **byte** |
+| ------------------------------------------------------- | ---------------- | ----------------------------------------- | -------------- | ---------- |
+| **case** | **catch** | **char** | **class** | **const** |
+| **continue** | **default** | **do** | **double** | **else** |
+| **enum** | **extends** | **final** | **finally** | **float** |
+| **for** | **goto** | **[if](https://baike.baidu.com/item/if)** | **implements** | **import** |
+| **instanceof** | **int** | **interface** | **long** | **native** |
+| **new** | **package** | **private** | **protected** | **public** |
+| **return** | **strictfp** | **short** | **static** | **super** |
+| **switch** | **synchronized** | **this** | **throw** | **throws** |
+| **[transient](https://baike.baidu.com/item/transient)** | **try** | **void** | **volatile** | **while** |
+
+### 5.标识符
+
+标识符概述
+
+标识符：就是给类，方法，变量等**起名字**的**符号**
+
+**标识符规则**
+
+组成规则
+
+由数字、字母、下划线（_）和美元符（$）组成
+
+
+
+**注意事项**
+
+不能以数字开头
+
+不能是关键字
+
+区分大小写
+
+**命名约定**
+
+小驼峰命名法：**方法**，**变量**
+
+约定1：标识符一个单词的时候，首字母小写
+
+范例1：name
+
+约定2：标识符是多个单词的时候，第一个单词首字母小写，其他单词首字母大写
+
+范例2：***firstName***
+
+
+
+大驼峰命名法：**类**
+
+约定1：标识符一个单词的时候，首字母大写
+
+范例1：Hello
+
+约定2：标识符是多个单词的时候，每个单词首字母大写
+
+范例2：HelloWorld
+
+
+
+```java
+/*
+疫情防控信息采集表
+*/
+public class VariableTest02 {
+ public static void main(String[] args){
+ //定义变量
+ String name="风清扬";
+ int age = 18;
+ char gender='男';
+ double temperature =36.2;
+ boolean flag = true;
+
+
+ //输出数据
+ System.out.println("姓名："+name);
+ System.out.println("年龄："+age);
+ System.out.println("性别："+gender);
+ System.out.println("体温："+temperature);
+ System.out.println("是否接种过疫苗："+flag);
+ }
+}
+```
+
+**总结**
+
+1.什么是标识符
+
+就是给类，方法，变量等起名字的符号
+
+2.标识符组成规则
+
+由数字，字母，下划线和美元符组成
+
+3.标识符注意事项
+
+不能以数字开头
+
+不能是关键字
+
+区分大小写
+
+4.常见命名规范
+
+见名知意
+
+类：大驼峰命名法
+
+方法，变量：小驼峰命名法
\ No newline at end of file
diff --git "a/5\345\217\267\346\236\227\344\274\237\345\275\254/20221124\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.md" "b/20 \345\206\257\351\224\220/20221124\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.md"
similarity index 100%
rename from "5\345\217\267\346\236\227\344\274\237\345\275\254/20221124\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.md"
rename to "20 \345\206\257\351\224\220/20221124\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.md"
diff --git "a/20 \345\206\257\351\224\220/20221208 \351\232\217\346\234\272\346\225\260\345\222\214\346\225\260\347\273\204.md" "b/20 \345\206\257\351\224\220/20221208 \351\232\217\346\234\272\346\225\260\345\222\214\346\225\260\347\273\204.md"
new file mode 100644
index 0000000000000000000000000000000000000000..69693182069c22aa749fb786191db69e453a008a
--- /dev/null
+++ "b/20 \345\206\257\351\224\220/20221208 \351\232\217\346\234\272\346\225\260\345\222\214\346\225\260\347\273\204.md"
@@ -0,0 +1,185 @@
+# Random产生随机数
+
+##### **概述： Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能 API后续课程详细讲解，现在可以简单理解为Java已经写好的代码 使用步骤：**
+
+##### ** 1. 导入包 import java.util.Random;
+
+##### 2. 创建对象 Random r = new Random(); 3
+
+##### . 产生随机数 int num = r.nextInt(10); 解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随 机数则是0-19
+
+##### 示例代码：**
+
+```java
+import java.util.Random;
+public class Demo1Random {
+ /* Random : 产生随机数
+ 1. 导包 : import java.util.Random; 导包的动作必须出现在类定义的上面
+ 2. 创建对象 : Random r = new Random(); 上面这个格式里面，r 是变量名，可以变，其他的都不允许变
+ 3. 获取随机数 : int number = r.nextInt(10); //获取数据的范围：[0,10) 包 括0,不包括10 上面这个格式里面，number是变量名，可以变，数字10可以变。其他的都不 允许变
+ 需求: 产生随机数1-10之间的 */ public static void main(String[] args){ //
+ 2. 创建对象 Random r = new Random(); for(int i = 1; i <= 10; i++){ //
+ 3. 获取随机数 int num = r.nextInt(10) + 1; // 1-10 System.out.println(num); } } }
+```
+
+# 数组
+
+数组介绍
+
+数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。
+
+数组的定义格式
+
+第一种格式：
+
+```java
+int[] arr;
+double[] arr;
+char[] arr;
+```
+
+ 第二种格式：
+
+```java
+int arr[];
+double arr[];
+char arr[];
+```
+
+数组的动态初始化
+
+什么是动态初始化：数组动态初始化就是只给定数组的长度，由系统给出默认初始化值。
+
+动态初始化格式;
+
+```java
+数据类型[] 数组名 = new 数据类型[数组长度];
+
+int[] arr = new int[3];
+```
+
+ 动态初始化格式详解
+
+- 等号左边：
+
+ - int:数组的数据类型
+
+ - []:代表这是一个数组
+
+ - arr:代表数组的名称
+
+- 等号右边：
+
+ - new:为数组开辟内存空间
+ - int:数组的数据类型
+ - []:代表这是一个数组
+ - 5:代表数组的长度
+
+**代码 :**
+
+```java
+package com.itheima.array;
+
+public class Demo2Array {
+ /*
+ 数组的动态初始化:
+ 在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值.
+
+ 动态初始化格式:
+ 数据类型[] 数组名 = new 数据类型[数组的长度];
+
+ 注意:
+ 打印数组变量的时候, 会打印出数组的内存地址
+
+ [I@10f87f48 :
+
+ @ : 分隔符
+ [ : 当前的空间是一个数组类型
+ I : 当前数组容器中所存储的数据类型
+ 10f87f48 : 十六进制内存地址
+
+ 0 1 2 3 4 5 6 7 8 9 a b c d e f
+ */
+ public static void main(String[] args) {
+ // 数据类型[] 数组名 = new 数据类型[数组的长度];
+ // 通过new关键字创建了一个int类型的数组容器, 该容器可以存储5个int类型的整数, 该容器被arr数组变量所记录
+ int[] arr = new int[5];
+ // [I@10f87f48
+ System.out.println(arr);
+
+ byte[] bArr = new byte[3];
+ // [B@b4c966a
+ System.out.println(bArr);
+
+ }
+
+}
+```
+
+# 作业
+
+需求： 程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？ 当猜错的时候根据不同情况给出相应的提示 A. 如果猜的数字比真实数字大，提示你猜的数据大了 B. 如果猜的数字比真实数字小，提示你猜的数据小了 C. 如果猜的数字与真实数字相等，提示恭喜你猜中了
+
+```java
+package 循环;
+
+import java.util.Random;
+import java.util.Scanner;
+
+public class d6 {
+ public static void main(String[] args) {
+ Random ran =new Random();
+ int num = ran.nextInt(100);
+ Scanner ee=new Scanner(System.in);
+ int count=0;
+ f:while (true){
+ System.out.println("请猜一个数:");
+ int ff= ee.nextInt();
+ if (ff>num){
+ System.out.println("太大了");
+ }else if (ffda){
+ da=arr[i];
+ }
+ }
+ System.out.println("最大为："+da);
+ }
+}
+```
diff --git "a/20 \345\206\257\351\224\220/2022121 \346\211\253\347\240\201\344\270\216\350\277\220\347\256\227\347\254\246\345\222\214\345\255\227\344\270\262\347\254\246.md" "b/20 \345\206\257\351\224\220/2022121 \346\211\253\347\240\201\344\270\216\350\277\220\347\256\227\347\254\246\345\222\214\345\255\227\344\270\262\347\254\246.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0ad3b5579981d70409e4f4de198100d99a392c64
--- /dev/null
+++ "b/20 \345\206\257\351\224\220/2022121 \346\211\253\347\240\201\344\270\216\350\277\220\347\256\227\347\254\246\345\222\214\345\255\227\344\270\262\347\254\246.md"
@@ -0,0 +1,51 @@
+四位数分解
+
+```java
+
+import java.util.Scanner;
+
+public class zy1 {
+ public static void main(String[] args) {
+ // 1：使用Scanner键盘录入一个四位数
+ Scanner sc = new Scanner(System.in);
+ System.out.println("请输入一个四位数");
+ int num = sc.nextInt();
+ // 2：个位的计算：数值 % 10
+ int ge = num % 10;
+ // 3：十位的计算：数值 / 10 % 10
+ int shi = num / 10 % 10;
+ // 4：百位的计算：数值 / 100 % 10
+ int bai = num / 100 % 10;
+ // 5:千位的计算：数值 / 1000
+ int qian = num / 1000;
+ // 5：将个位, 十位, 百位拼接上正确的字符串, 打印即可
+ System.out.println("整数"+num+"个位为:" + ge);
+ System.out.println("整数"+num+"十位为:" + shi);
+ System.out.println("整数"+num+"百位为:" + bai);
+ System.out.println("整数"+num+"千位为:" + qian);
+ }
+}
+```
+
+
+
+
+
+摄氏度与华氏度的转换
+
+```java
+import java.util.scanner;
+public class zy2 {
+public static void main(String[] args){
+ Scanner rl = new Scanner(System.in);system.out.print1n("华氏输入：");
+double hs =rl.nextDouble();
+double ss = (hs-32) *5 /9;
+System.out.println("得摄氏°为："+ss);
+ System.out.print1n("摄氏输入：");
+double sheshi = rl.nextDouble();
+double shesh = sheshi*5 /9 +32; I
+System.out.println("得华氏为："+shesh);
+ }
+}
+```
+
diff --git "a/20 \345\206\257\351\224\220/20221212 \346\225\260\347\273\204\347\232\204\345\260\217\347\273\223.md" "b/20 \345\206\257\351\224\220/20221212 \346\225\260\347\273\204\347\232\204\345\260\217\347\273\223.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d0927e7b41107fcef4de7e6e8c63c082b1b890c3
--- /dev/null
+++ "b/20 \345\206\257\351\224\220/20221212 \346\225\260\347\273\204\347\232\204\345\260\217\347\273\223.md"
@@ -0,0 +1,137 @@
+## 数组的小结
+
+1. 数组：一种用来存放多个或一个同一数据类型数据的容器，其实就是一种特殊的变量
+
+2. 数组里存放的每一个数据，称为数组的元素。
+
+3. 为了定位每个元素，程序会给每个元素一个编号，这个编号从0开始，称为索引，注意，索引最大值，只能是长度-1 ===> length-1
+
+4. 如何得到数组的长度（也就是元素的个数）：
+
+ ```java
+ // 数组名.length
+ int[] ages = {1,2,3};
+ ages.length;
+ // 数组长度什么什么用？
+ //可以用来遍历数组
+ ```
+
+5. 数组的赋值，也叫初始化
+
+ 1. 静态初始化
+
+ 1. 语法： 数据类型[] 数组名 = {元素1，元素2，元素3，……};
+
+ 2. 当定义一个数组，同时又明确知道每个元素的值的时候，边定义数组边赋值。
+
+ 3. 示例：
+
+ ```java
+ // 定义一个整数类型的数组，存放前三名各个的年龄
+ int[] ages = {18,19,20};
+ ```
+
+6. 动态初始化
+
+ 1. 语法：数据类型[] 数组名 = new 数据类型[数组的长度]
+
+ 2. 当要定义一个数组，但是只知道长度，却不知道每个元素具体的值的时候。用动态初始化法
+
+ 3. 动态初始化，其实是有默认值的 int[] 0 ; double[] 0.0 String[] null 【null 表示啥也没有！】
+
+ 4. 示例:
+
+ ```java
+ // 定义一个长度为3的整数类型的数组，得到 0 0 0 这么一个数组
+ int[] a = new int[3];
+ ```
+
+7. 怎么使用数组的元素（也就是取值）
+
+ 1. 语法： 数组名[索引]
+
+ 2. 示例：
+
+ ```java
+ num[1]// 表示取num这个数组中索引为1的那个元素的值，因为索引从0开始，所以这里1表示第2个元素
+ ```
+
+8. 数组的遍历：
+
+ 1. 将数组每个元素都用到一次
+
+ 2. 其实就是从索引0到数组长度-1循环一次，取出每个索引对应的值
+
+ 3. 示例，求数组中每个数的总和
+
+ ```java
+ // 普通的标签遍历方法
+ int[] num = {1,2,3};
+ sum = 0;
+ for(int i=0;i=0 && num<=100){
+ arr[i]=num;
+ }
+ }
+ int max = arr[0];
+ for (int i =1; i< arr.length;i++ ){
+ if (max< arr[i]){
+ max = arr[i];
+ }
+ }
+ int min = arr[0];
+ for (int i = 1; i < arr.length; i++) {
+ if (min > arr[i]) {
+ min = arr[i];
+ }
+ }
+ int sum =0;
+ for(int i=0;i< arr.length;i++){
+ sum+=arr[i];
+ }
+ int avg =(sum-max-min)/8;
+ System.out.println("最终平均分是"+avg);
+ }
+}
+
+
+```
diff --git "a/20 \345\206\257\351\224\220/20221215 AIP\344\270\216String\346\246\202\350\277\260.md" "b/20 \345\206\257\351\224\220/20221215 AIP\344\270\216String\346\246\202\350\277\260.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0d1e2a39a9284d5e165d30987077d48127108884
--- /dev/null
+++ "b/20 \345\206\257\351\224\220/20221215 AIP\344\270\216String\346\246\202\350\277\260.md"
@@ -0,0 +1,248 @@
+# 1.API
+
+### 1.1 API概述-帮助文档的使用
+
+#### 什么是API
+
+API (Application Programming Interface) ：应用程序编程接口 java中的API 指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这 些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何 使用。
+
+ 如何使用API帮助文档 :
+
+1. 打开帮助文档
+2. 找到索引选项卡中的输入框
+3. 在输入框中输入Random
+4. 看类在哪个包下
+5. 看类的描述
+6. 看构造方法
+7. 看成员方法
+
+# 1.2 键盘录入字符串
+
+### Scanner类 :
+
+next() : 遇到了空格, 就不再录入数据了 , 结束标记: 空格, tab键
+
+ nextLine() : 可以将数据完整的接收过来 , 结束标记: 回车换行符
+
+ 代码实现 :
+
+```java
+package com.itheima.api;
+import java.util.Scanner;
+public class Demo1Scanner {
+/*
+next() : 遇到了空格, 就不再录入数据了
+结束标记: 空格, tab键
+nextLine() : 可以将数据完整的接收过来
+结束标记: 回车换行符
+*/
+public static void main(String[] args) {
+// 1. 创建Scanner对象
+Scanner sc = new Scanner(System.in);
+System.out.println("请输入:");
+// 2. 调用nextLine方法接收字符串
+//ctrl + alt + v : 快速生成方法的返回值
+ String s = sc.nextLine();
+System.out.println(s);
+}
+}
+package com.itheima.api;
+import java.util.Scanner;
+public class Demo2Scanner {
+/*
+nextInt和nextLine方法配合使用的时候, nextLine方法就没有键盘录入的机会了
+建议: 今后键盘录入数据的时候, 如果是字符串和整数一起接受, 建议使用next方法接受字
+符串.
+*/
+public static void main(String[] args) {
+Scanner sc = new Scanner(System.in);
+System.out.println("请输入整数:");
+int num = sc.nextInt(); // 10 + 回车换行
+System.out.println("请输入字符串:");
+String s = sc.nextLine();
+System.out.println(num);
+System.out.println(s);
+}
+}
+```
+
+# String类
+
+### 2.1 String概述
+
+##### 1 String 类在 java.lang 包下，所以使用的时候不需要导包
+
+##### 2 String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例也就是 说，Java 程序中所有的双引号字 符串，都是 String 类的对象
+
+##### 3 字符串不可变，它们的值在创建后不能被更改 2.2 String类的构造方法 常用的构造方法
+
+### 2.2 String类的构造方法
+
+ 常用的构造方法
+
+
+
+示例代码：
+
+```java
+package com.itheima.string;
+public class Demo2StringConstructor {
+/*
+String类常见构造方法:
+public String() : 创建一个空白字符串对象，不含有任何内容
+public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
+public String(String original) : 根据传入的字符串内容，来创建字符串对象
+String s = “abc”; 直接赋值的方式创建字符串对象，内容就是abc
+注意:
+String这个类比较特殊, 打印其对象名的时候, 不会出现内存地址
+而是该对象所记录的真实内容.
+面向对象-继承, Object类
+*/
+public static void main(String[] args) {
+// public String() : 创建一个空白字符串对象，不含有任何内容
+String s1 = new String();
+System.out.println(s1);
+// public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
+char[] chs = {'a','b','c'};
+String s2 = new String(chs);
+System.out.println(s2);
+// public String(String original) : 根据传入的字符串内容，来创建字符串对象
+String s3 = new String("123");
+System.out.println(s3);
+}
+}
+```
+
+### 2.4 创建字符串对象的区别对比
+
+##### 通过构造方法创建
+
+ 通过 new 创建的字符串对象，每一次 new 都会申请一个新的内存空间，虽然内容相同，但是地 址值不同 所以直接== 是不成立的
+
+##### 直接赋值方式创建
+
+以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM虚 拟机 都只会建立一个 String 对象，并在字符串池中维护
+
+2.5 字符串的比较
+
+ 2.5.1 字符串的比较
+
+- == 比较基本数据类型：比较的是具体的值
+
+- == 比较引用数据类型：比较的是对象(内存)地址值
+
+- ##### String类 : public boolean equals(String s) 比较两个字符串内容是否相同、区分大小写
+
+ 代码 :
+
+ ```java
+ package com.itheima.stringmethod;
+ public class Demo1Equals {
+ public static void main(String[] args) {
+ String s1 = "abc";
+ String s2 = "ABC";
+ String s3 = "abc";
+ // equals : 比较字符串内容, 区分大小写
+ System.out.println(s1.equals(s2));
+ System.out.println(s1.equals(s3));
+ // equalsIgnoreCase : 比较字符串内容, 忽略大小写
+ System.out.println(s1.equalsIgnoreCase(s2));
+ }
+ }
+ ```
+
+ ## 2.6 用户登录案例【应用】
+
+ ##### 案例需求 :
+
+ 已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示
+
+ ##### 实现步骤 :
+
+ 1. 已知用户名和密码，定义两个字符串表示即可
+ 2. 键盘录入要登录的用户名和密码，用 Scanner 实现
+ 3. 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
+ 4. 字符串的内容比较，用equals() 方法实现
+ 5. 用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束 循 环
+ 6. 代码实现 :
+
+```java
+package com.itheima.test;
+import java.util.Scanner;
+public class Test1 {
+/*
+需求：已知用户名和密码，请用程序实现模拟用户登录。
+总共给三次机会，登录之后，给出相应的提示
+思路：
+1已知用户名和密码，定义两个字符串表示即可
+2. 键盘录入要登录的用户名和密码，用 Scanner 实现
+3. 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
+字符串的内容比较，用equals() 方法实现
+4. 用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用
+break结束循环
+*/
+public static void main(String[] args) {
+// 1. 已知用户名和密码，定义两个字符串表示即可
+String username = "admin";
+String password = "123456";
+// 2. 键盘录入要登录的用户名和密码，用 Scanner 实现
+Scanner sc = new Scanner(System.in);
+// 4. 用循环实现多次机会，这里的次数明确，采用for循环实现
+for(int i = 1; i <= 3; i++){
+System.out.println("请输入用户名:");
+String scUsername = sc.nextLine();
+System.out.println("请输入密码:");
+String scPassword = sc.nextLine();
+// 3. 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
+if(username.equals(scUsername) && password.equals(scPassword)){
+System.out.println("登录成功");
+break;
+}else{
+if(i == 3){
+System.out.println("您的登录次数已达到今日上限, 请明天再来");
+}else{
+System.out.println("登录失败,您还剩余" + (3-i) +"次机会");
+}
+}
+}
+}
+}
+```
+
+# 作业
+
+##### 计算燃气那个
+
+```java
+package 循环;
+
+public class H3 {
+ public static void main(String[] args) {
+// 已知 购买100立方 总共付了445.4
+// 第二梯度 4.05元/立方 第三梯度 5.06元/立方
+ for (int num=1;num<=100;num++){
+ if (num*4.05+(100-num)*5.06==445.4){
+ System.out.println("第一梯度有:"+num+"立方"+"\n"+"第二梯度有:"+(100-num)+"立方");
+ }
+ }
+ }
+}
+```
+
+##### 倒序输出乘法口诀,9到1
+
+```java
+package 循环;
+
+public class H5 {
+ public static void main(String[] args) {
+ for (int a=9;a>=1;a--){
+ for (int aa=9;aa>=a;aa--){
+ System.out.print(a+"*"+aa+"="+a*aa+"\t");
+ }
+ System.out.println("");
+ }
+ }
+}
+```
+
diff --git "a/20 \345\206\257\351\224\220/20221216 \346\226\271\346\263\225.md" "b/20 \345\206\257\351\224\220/20221216 \346\226\271\346\263\225.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ab2248adef99b270e3ea82daa3a8f52d28eebe60
--- /dev/null
+++ "b/20 \345\206\257\351\224\220/20221216 \346\226\271\346\263\225.md"
@@ -0,0 +1,255 @@
+# 方法概述
+
+### 1.1 方法的概念
+
+##### 方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
+
+###### 注意： 方法必须先创建才可以使用，该过程成为方法定义 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用
+
+## 方法的定义和调用
+
+#### 2.1 无参数方法定义和调用
+
+定义格式：
+
+```java
+public static void 方法名 ( ) {
+// 方法体;
+}
+```
+
+##### 注意： 方法必须先定义，后调用，否则程序将报错
+
+### 2.2 方法的调用过程
+
+ 总结：每个方法在被调用执行的时候，都会进入栈内存，并且拥有自己独立的内存空间，方法内部 代码调用完毕之后，会从栈内存中弹栈消失。
+
+### 2.3 方法练习-奇偶数判断
+
+需求：判断一个数是奇数还是偶数
+
+ 代码：
+
+```java
+public class Demo1Method {
+3. 带参数方法的定义和调用
+3.1 带参数方法定义和调用
+定义格式：
+参数：由数据类型和变量名组成 - 数据类型 变量名
+参数范例：int a
+范例：
+注意：
+/*
+带参数方法的定义格式:
+public static void 方法名 ( 参数 ) { … … }
+public static void 方法名 ( 数据类型 变量名 ) { … … }
+带参数方法的调用格式:
+方法名 ( 参数 ) ;
+方法名 ( 变量名/常量值 ) ;
+tips: 参数可以是一个, 也可以是多个.
+需求: 判断一个数是奇数还是偶数
+*/
+public static void main(String[] args) {
+isEvenNumber(10);
+}
+public static void isEvenNumber(int num){
+if(num % 2 == 0){
+System.out.println("偶数");
+}else{
+System.out.println("奇数");
+}
+}
+}
+```
+
+3. # 带参数方法的定义和调用
+
+ ### 3.1 带参数方法定义和调用
+
+ #### 定义格式：
+
+ 参数：由数据类型和变量名组成 - 数据类型 变量名
+
+ 参数范例：int a
+
+```java
+public static void 方法名 (参数1) {
+方法体;
+}
+public static void 方法名 (参数1, 参数2, 参数3...) {
+方法体;
+}
+例：
+ ublic static void isEvenNumber(int number){
+...
+}
+public static void getMax(int num1, int num2){
+...
+}
+注意：方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
+方法定义时，多个参数之间使用逗号( ，)分隔
+
+```
+
+##### 方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错
+
+### 3.2 形参和实参
+
+1. 形参：方法定义中的参数 等同于变量定义格式，例如：int number
+
+2. 2. 实参：方法调用中的参数 等同于使用变量或常量，例如： 10 number
+
+ ### 3.3 带参数方法的练习-打印n-m之间所有的奇数
+
+ 需求：设计一个方法（print） 用于打印 n 到 m 之间所有的奇数
+
+ 思路：
+
+ 1：定义方法，名称为print
+
+ 2：为方法添加两个int类型的形参，准备接受调用者传递过来的实参
+
+ 3：方法中设计for循环，循环从n开始，到m结束
+
+ 4：循环中加入if判断，是奇数，则打印
+
+ 5：main方法中调用print方法，传入两个实际参数
+
+ 代码：
+
+```java
+package com.itheima.method2;
+public class Demo2Method {
+public static void main(String[] args) {
+// 5：main方法中调用print方法，传入两个实际参数
+print(20,10);
+}
+//1：定义方法，名称为print
+// 2：为方法添加两个int类型的形参，准备接受调用者传递过来的实参
+public static void print(int n, int m){
+System.out.println(n + "到" + m + "之间的奇数为:");
+// 3：方法中设计for循环，循环从n开始，到m结束
+for(int i = 20; i <= 10; i++){
+// 4：循环中加入if判断，是奇数，则打印
+ if(i % 2 == 1){
+System.out.println(i);
+}
+}
+}
+}
+```
+
+## 带返回值方法的定义和调用
+
+### 4.1 带返回值方法定义和调用（掌握）
+
+### 4.2 带返回值方法的练习-求两个数的最大值(应用)
+
+##### 需求：设计一个方法可以获取两个数的较大值，数据来自于参数 思路： 1. 定义一个方法，声明两个形参接收计算的数值，求出结果并返回 2. 使用 if 语句 得出 a 和 b 之间的最大值，根据情况return具体结果 3. 在main()方法中调用定义好的方法并使用 【 变量保存 】
+
+## 方法的注意事项
+
+#### 5.1 方法的通用格式（掌握）
+
+# 方法重载
+
+### 6.1 方法重载
+
+##### 方法重载概念 方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载 多个方法在同一个类中 多个方法具有相同的方法名 多个方法的参数不相同，类型不同或者数量不同
+
+### 6.2 方法重载练习
+
+##### 需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型 （byte,short,int,long） 思路： ①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数 ②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数 ③定义所有的重载方法，两个byte类型与两个short类型参数 ④完成方法的调用，测试运行结果
+
+# 方法的参数传递
+
+### 7.1 方法参数传递基本类型（理解）
+
+##### 结论： 基本数据类型的参数，形式参数的改变，不影响实际参数 结论依据： 每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失
+
+### 7.2 方法参数传递引用类型
+
+##### 测试代码： 结论： 对于引用类型的参数，形式参数的改变，影响实际参数的值 结论依据： 引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以 即使方法弹栈，堆内存中的数据也已经是改变后的结果
+
+### 7.3 数组遍历
+
+##### 需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。起到换行的作用 定义一个数组，用静态初始化完成数组元素初始化 定义一个方法，用数组遍历通用格式对数组进行遍历 用新的输出语句修改遍历操作 调用遍历方法
+
+### 7.4 数组最大值
+
+##### 需求：设计一个方法用于获取数组中元素的最大值 思路： ①定义一个数组，用静态初始化完成数组元素初始化 ②定义一个方法，用来获取数组中的最大值，最值的认知和讲解我们在数组中已经讲解过了 ③调用获取最大值方法，用变量接收返回结果 ④把结果输出在控制台
+
+### 7.5 方法同时获取数组最大值和最小值
+
+##### 需求：设计一个方法，该方法能够同时获取数组的最大值，和最小值 注意: return语句, 只能带回一个结果.
+
+# 作业
+
+```Java
+package 循环;
+
+import java.util.Random;
+import java.util.Scanner;
+
+public class H6 {
+ public static void main(String[] args) {
+// 定义一函数，用于求2个数中的较大数，并将其返回，这2个数字在主函数中由用户输入
+ Scanner num =new Scanner(System.in);
+ System.out.println("请输入两个数进行比较:");
+ int a = num.nextInt();
+ int b = num.nextInt();
+ getmax(a,b);
+ System.out.println("两个数中最大的是:"+getmax(a,b));
+ }
+ public static int getmax (int a, int b){
+ return a>b?a:b;
+ }
+}
+```
+
+# 不会，求教
+
+```java
+package 循环;
+import java.util.Scanner;
+public class H7 {
+ public static void main(String[] args) {
+ //在主函数中从键盘接收X, Y , Z3个数，编写函数计算这3个数的立方和并返回计算结果：S=X3+Y3+Z3
+ Scanner num =new Scanner(System.in);
+ System.out.println("请输入x，y，z");
+ char nnum = num.next().charAt(0);
+ switch (nnum){
+ case 'x':
+ int x=10;
+ x();
+ System.out.print(xx(x));
+ break;
+ case 'y':
+ int y=20;
+ y();
+ System.out.print(yy(y));
+ break;
+ case 'z':
+ int z=30;
+ z();
+ System.out.print(zz(z)+"\n");
+ System.out.println("");
+ break;
+ default:
+ System.out.println("按键错误");
+ }
+ int a=xyz(1000,8000,27000);
+ System.out.println("\n" +"最终值为："+a);
+ }
+ public static void x(){System.out.println("x的值为10其立方和为:");}
+ public static void y(){System.out.println("x的值为20其立方和为:");}
+ public static void z(){System.out.println("x的值为30其立方和为:");}
+ public static int xx(int x){return x*x*x;}
+ public static int yy(int y){return y*y*y;}
+ public static int zz(int z){return z*z*z;}
+ public static int xyz(int x,int y,int z){
+ return x+y+z;
+ }
+}
+```
+
diff --git "a/20 \345\206\257\351\224\220/2022122 Java\345\237\272\347\241\200\350\257\255\346\263\225.md" "b/20 \345\206\257\351\224\220/2022122 Java\345\237\272\347\241\200\350\257\255\346\263\225.md"
new file mode 100644
index 0000000000000000000000000000000000000000..928600e9966e1b95731a04a8df7040740c2fbb4a
--- /dev/null
+++ "b/20 \345\206\257\351\224\220/2022122 Java\345\237\272\347\241\200\350\257\255\346\263\225.md"
@@ -0,0 +1,747 @@
+# day02 - Java基础语法
+
+## 1 类型转换
+
+在Java中，一些数据类型之间是可以相互转换的。分为两种情况：自动类型转换和强制类型转换。
+
+### 1.1 隐式转换(自动转换)
+
+ 把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，直接书写即可。例如：
+
+```java
+double num = 10; // 将int类型的10直接赋值给double类型
+System.out.println(num); // 输出10.0
+```
+
+ 类型从小到大关系图：
+
+ 
+
+说明：
+
+1. 整数默认是int类型，byte、short和char类型数据参与运算均会自动转换为int类型。
+
+```java
+byte b1 = 10;
+byte b2 = 20;
+byte b3 = b1 + b2;
+// 第三行代码会报错，b1和b2会自动转换为int类型，计算结果为int，int赋值给byte需要强制类型转换。
+// 修改为:
+int num = b1 + b2;
+// 或者：
+byte b3 = (byte) (b1 + b2);
+```
+
+2. boolean类型不能与其他基本数据类型相互转换。
+
+### 1.2 强制转换(理解)
+
+ 把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。
+
+ 强制类型转换格式：目标数据类型 变量名 = (目标数据类型)值或者变量;
+
+ 例如：
+
+```java
+double num1 = 5.5;
+int num2 = (int) num1; // 将double类型的num1强制转换为int类型
+System.out.println(num2); // 输出5（小数位直接舍弃）
+```
+
+### 1.3 类型转换案例(理解)
+
+案例代码：
+
+```java
+byte a = 3;
+byte b = 4;
+byte c = a + b; //错误。因为两个byte变量相加，会先提升为int类型
+byte d = 3 + 4; //正确。常量优化机制
+```
+
+**常量优化机制**：
+
+ 在编译时，整数常量的计算会直接算出结果，并且会自动判断该结果是否在byte取值范围内，
+
+- 在：编译通过
+
+- 不在：编译失败
+
+## 2. 运算符
+
+### 2.1 算术运算符
+
+#### 2.1.1 运算符和表达式（了解）
+
+运算符：对常量或者变量进行操作的符号
+
+表达式：用运算符把常量或者变量连接起来符合Java语法的式子就可以称为表达式。
+
+ 不同运算符连接的表达式体现的是不同类型的表达式。
+
+举例说明：
+
+```java
+int a = 10;
+int b = 20;
+int c = a + b;
+```
+
+ +：是运算符，并且是算术运算符。
+
+ a + b：是表达式，由于+是算术运算符，所以这个表达式叫算术表达式。 a和b称为操作数
+
+#### 2.1.2 算术运算符(应用)
+
+| 符号 | 作用 | 说明 |
+| :--: | :--: | ---------------------------- |
+| + | 加 | 参看小学一年级 |
+| - | 减 | 参看小学一年级 |
+| * | 乘 | 参看小学二年级，与“×”相同 |
+| / | 除 | 参看小学二年级，与“÷”相同 |
+| % | 取余 | 获取的是两个数据做除法的余数 |
+
+**注意：**
+
+1. /和%的区别：两者都做除法，
+ - / 取结果的商，
+
+ - % 取结果的余数。
+
+2. 整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。
+
+~~~java
+int a = 10;
+int b = 3;
+System.out.println(a / b); // 输出结果
+System.out.println(a % b); // 输出结果
+~~~
+
+> **练习:分别得到123这个数的个位,十位和百位上的数字**
+
+
+
+#### 2.1.3 字符的“+”操作（理解）
+
+char类型参与算术运算，使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值：
+
+'a' -- 97 a-z是连续的，所以'b'对应的数值是98，'c'是99，依次递加
+
+'A' -- 65 A-Z是连续的，所以'B'对应的数值是66，'C'是67，依次递加
+
+'0' -- 48 0-9是连续的，所以'1'对应的数值是49，'2'是50，依次递加
+
+~~~java
+// 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少
+char ch1 = 'a';
+System.out.println(ch1 + 1); // 输出98，97 + 1 = 98
+
+char ch2 = 'A';
+System.out.println(ch2 + 1); // 输出66，65 + 1 = 66
+
+char ch3 = '0';
+System.out.println(ch3 + 1); // 输出49，48 + 1 = 49
+~~~
+
+算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。
+
+**提升规则：**
+
+```java
+1. byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。
+2. 整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型
+3. 等级顺序：byte,short,char --> int --> long --> float --> double
+```
+例如：
+
+~~~java
+byte b1 = 10;
+byte b2 = 20;
+// byte b3 = b1 + b2; // 该行报错，因为byte类型参与算术运算会自动提示为int，int赋值给byte可能损失精度
+int i3 = b1 + b2; // 应该使用int接收
+byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型
+-------------------------------
+int num1 = 10;
+double num2 = 20.0;
+double num3 = num1 + num2; // 使用double接收，因为num1会自动提升为double类型
+~~~
+
+#### 2.1.4 字符串的“+”操作（理解）
+
+当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。【+号的左右两边任意一边出现字符串，那这个就个拼接符】
+
+当+号是拼接符的时候。得到的结果，也是字符串
+
+~~~java
+System.out.println("qiuqiu"+ 666); // 输出：qiuqiu666
+~~~
+
+在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。
+
+~~~java
+System.out.println(1 + 99 + "年白酒"); // 输出：100年白酒
+System.out.println(1 + 2 + "兔子" + 3 + 4); // 输出：3兔子34 // 只要前面有字符串，后面都被污染成字符串
+// 可以使用小括号改变运算的优先级
+System.out.println(1 + 2 + "兔子" + (3 + 4)); // 输出：3兔子7
+~~~
+
+#### 2.1.5 数值拆分（应用）
+
+需求：
+
+ 键盘录入一个三位数，将其拆分为个位，十位，百位，打印在控制台
+
+示例代码：
+
+```java
+import java.util.Scanner;
+public class Test {
+ public static void main(String[] args) {
+ // 1：使用Scanner键盘录入一个三位数
+ Scanner sc = new Scanner(System.in);
+ System.out.println("请输入一个三位数");
+ int num = sc.nextInt();
+ // 2：个位的计算：数值 % 10
+ int ge = num % 10;
+ // 3：十位的计算：数值 / 10 % 10
+ int shi = num / 10 % 10;
+ // 4：百位的计算：数值 / 100
+ int bai = num / 100;
+ // 5：将个位, 十位, 百位拼接上正确的字符串, 打印即可
+ System.out.println("整数"+num+"个位为:" + ge);
+ System.out.println("整数"+num+"十位为:" + shi);
+ System.out.println("整数"+num+"百位为:" + bai);
+
+ }
+}
+```
+
+### 2.2 自增自减运算符（理解）
+
+| 符号 | 作用 | 说明 |
+| ---- | ---- | ----------- |
+| ++ | 自增 | 变量的值加1 |
+| -- | 自减 | 变量的值减1 |
+
+注意事项：
+
+ ++和-- 既可以放在变量的后边，也可以放在变量的前边。
+
+ 单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的。
+
+ 参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者--。
+
+ 参与操作的时候，如果放在变量的前边，先拿变量做++或者--，后拿变量参与操作。
+
+ 最常见的用法：单独使用。
+
+```java
+int i = 10;
+i++; // 单独使用
+System.out.println("i:" + i); // i:11
+
+int j = 10;
+++j; // 单独使用
+System.out.println("j:" + j); // j:11
+
+int x = 10;
+int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
+System.out.println("x:" + x + ", y:" + y); // x:11，y:10
+
+int m = 10;
+int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
+System.out.println("m:" + m + ", n:" + n); // m:11，n:11
+```
+
+练习：
+
+```java
+int x = 10;
+int y = x++ + x++ + x++;
+System.out.println(y); // y的值是多少？
+/*
+解析，三个表达式都是++在后，所以每次使用的都是自增前的值，但程序自左至右执行，所以第一次自增时，使用的是10进行计算，但第二次自增时，x的值已经自增到11了，所以第二次使用的是11，然后再次自增。。。
+所以整个式子应该是：int y = 10 + 11 + 12;
+输出结果为33。
+*/
+注意：通过此练习深刻理解自增和自减的规律，但实际开发中强烈建议不要写这样的代码！小心挨打！
+```
+
+### 2.3 赋值运算符（应用）
+
+赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。
+
+| 符号 | 作用 | 说明 |
+| ---- | ---------- | --------------------- |
+| = | 赋值 | a=10，将10赋值给变量a |
+| += | 加后赋值 | a+=b，将a+b的值给a |
+| -= | 减后赋值 | a-=b，将a-b的值给a |
+| *= | 乘后赋值 | a*=b，将a×b的值给a |
+| /= | 除后赋值 | a/=b，将a÷b的商给a |
+| %= | 取余后赋值 | a%=b，将a÷b的余数给a |
+
+注意：
+
+扩展的赋值运算符隐含了强制类型转换。
+
+~~~java
+short s = 10;
+s = s + 10; // 此行代码报出，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度
+
+s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);
+~~~
+
+### 2.4 关系运算符（应用）
+
+关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于。
+
+| 符号 | 说明 |
+| ---- | ------------------------------------------------------- |
+| == | a==b，判断a和b的值是否相等，成立为true，不成立为false |
+| != | a!=b，判断a和b的值是否不相等，成立为true，不成立为false |
+| > | a>b，判断a是否大于b，成立为true，不成立为false |
+| >= | a>=b，判断a是否大于等于b，成立为true，不成立为false |
+| < | a b); // false
+System.out.println(a >= b); // false
+System.out.println(a < b); // true
+System.out.println(a <= b); // true
+
+// 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
+boolean flag = a > b;
+System.out.println(flag); // 输出false
+~~~
+
+### 2.5 逻辑运算符（应用）
+
+逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。
+
+| 符号 | 作用 | 说明 |
+| ---- | -------- | -------------------------------------------- |
+| & | 逻辑与 | a&b，a和b都是true，结果为true，否则为false |
+| \| | 逻辑或 | a\|b，a和b都是false，结果为false，否则为true |
+| ^ | 逻辑异或 | a^b，a和b结果不同为true，相同为false |
+| ! | 逻辑非 | !a，结果和a的结果正好相反 |
+
+~~~java
+//定义变量
+int i = 10;
+int j = 20;
+int k = 30;
+
+//& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
+System.out.println((i > j) & (i > k)); //false & false,输出false
+System.out.println((i < j) & (i > k)); //true & false,输出false
+System.out.println((i > j) & (i < k)); //false & true,输出false
+System.out.println((i < j) & (i < k)); //true & true,输出true
+System.out.println("--------");
+
+//| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
+System.out.println((i > j) | (i > k)); //false | false,输出false
+System.out.println((i < j) | (i > k)); //true | false,输出true
+System.out.println((i > j) | (i < k)); //false | true,输出true
+System.out.println((i < j) | (i < k)); //true | true,输出true
+System.out.println("--------");
+
+//^ “异或”，相同为false，不同为true
+System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
+System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
+System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
+System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
+System.out.println("--------");
+
+//! “非”，取反
+System.out.println((i > j)); //false
+System.out.println(!(i > j)); //!false，,输出true
+~~~
+
+### 2.6 短路逻辑运算符（理解）
+
+| 符号 | 作用 | 说明 |
+| ---- | ------ | ---------------------------- |
+| && | 短路与 | 作用和&相同，但是有短路效果 |
+| \|\| | 短路或 | 作用和\|相同，但是有短路效果 |
+
+在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。
+
+- 逻辑与&，无论左边真假，右边都要执行。
+
+- 短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
+
+- 逻辑或|，无论左边真假，右边都要执行。
+
+- 短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。
+
+~~~java
+int x = 3;
+int y = 4;
+System.out.println((x++ > 4) & (y++ > 5)); // 两个表达都会运算
+System.out.println(x); // 4
+System.out.println(y); // 5
+
+System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false，右边不参与运算
+System.out.println(x); // 4
+System.out.println(y); // 4
+~~~
+
+### 2.7 三元运算符（理解）
+
+三元运算符语法格式：
+
+~~~java
+关系表达式 ? 表达式1 : 表达式2;
+~~~
+
+解释：问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1，为false时调用表达式2。其逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。
+
+举例：
+
+~~~java
+int a = 10;
+int b = 20;
+int c = a > b ? a : b; // 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值
+~~~
+
+### 2.8 三元运算符案例(应用)
+
+需求：
+
+ 一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高。
+
+~~~java
+public class OperatorTest02 {
+ public static void main(String[] args) {
+ //1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
+ int height1 = 150;
+ int height2 = 210;
+ int height3 = 165;
+ //2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
+ int tempHeight = height1 > height2 ? height1 : height2;
+ //3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
+ int maxHeight = tempHeight > height3 ? tempHeight : height3;
+ //4：输出结果
+ System.out.println("maxHeight:" + maxHeight);
+ }
+}
+~~~
+
+## 3. 流程控制语句
+
+在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。
+
+### 3.1 流程控制语句分类(了解)
+
+ 顺序结构
+
+ 分支结构(if, switch)
+
+ 循环结构(for, while, do…while)
+
+### 3.2 顺序结构(了解)
+
+顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
+
+顺序结构执行流程图：
+
+
+
+### 3.3 分支结构之if语句
+
+#### 3.3.1 if语句格式1（理解）
+
+~~~java
+格式：
+if (关系表达式) {
+ 语句体;
+}
+~~~
+
+执行流程：
+
+①首先计算关系表达式的值
+
+②如果关系表达式的值为true就执行语句体
+
+③如果关系表达式的值为false就不执行语句体
+
+④继续执行后面的语句内容
+
+
+
+示例：
+
+~~~java
+public class IfDemo {
+ public static void main(String[] args) {
+ System.out.println("开始");
+
+ // 如果年龄大于18岁, 就可以上网吧
+ int age = 17;
+
+ if(age >= 18){
+ // int a = 10;
+ System.out.println("可以上网吧");
+ }
+
+ System.out.println("结束");
+ }
+}
+~~~
+
+#### 3.3.2 if语句格式2（理解）
+
+~~~java
+格式：
+if (关系表达式) {
+ 语句体1;
+} else {
+ 语句体2;
+}
+~~~
+
+执行流程：
+
+①首先计算关系表达式的值
+
+②如果关系表达式的值为true就执行语句体1
+
+③如果关系表达式的值为false就执行语句体2
+
+④继续执行后面的语句内容
+
+
+
+示例：奇偶数
+
+ 任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。
+
+~~~java
+public class Demo2If {
+ public static void main(String[] args) {
+ // 程序判断一个数, 是奇数还是偶数
+ int num = 9;
+
+ if(num % 2 == 0){
+ System.out.println("偶数");
+ }else{
+ System.out.println("奇数");
+ }
+ }
+}
+~~~
+
+#### 3.3.3 if语句格式3（理解）
+
+~~~java
+格式：
+if (关系表达式1) {
+ 语句体1;
+} else if (关系表达式2) {
+ 语句体2;
+}
+…
+else {
+ 语句体n+1;
+}
+~~~
+
+执行流程：
+
+①首先计算关系表达式1的值
+
+②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
+
+③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
+
+④…
+
+⑤如果没有任何关系表达式为true，就执行语句体n+1。
+
+
+
+示例：
+
+ 定义一个在0~100之间的变量a, 90~100优秀，80~89良好，70~79中等，60~69及格，0~59请努力加油！
+
+~~~java
+public class Demo3If {
+ public static void main(String[] args){
+ int score = 65;
+ if(score >= 90 && score <= 100){
+ System.out.println("优秀");
+ }else if (score >= 80 && score <= 89){
+ System.out.println("良好");
+ }else if (score >= 70 && score <= 79){
+ System.out.println("中等");
+ }else if (score >= 60 && score <= 69){
+ System.out.println("及格");
+ }else if (score >= 0 && score <= 59){
+ System.out.println("请努力加油");
+ }else{
+ System.out.println("成绩有误!");
+ }
+ }
+}
+~~~
+
+#### 3.3.4 if语句格式3案例（应用）
+
+需求：小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
+
+分析：
+
+ ①小明的考试成绩未知，可以使用键盘录入的方式获取值
+
+ ②由于奖励种类较多，属于多种判断，采用if...else...if格式实现
+
+ ③为每种判断设置对应的条件
+
+ ④为每种判断设置对应的奖励
+
+~~~java
+import java.util.Scanner;
+public class IfTest02 {
+ public static void main(String[] args){
+ // 1. 使用Scanner录入考试成绩
+ Scanner sc = new Scanner(System.in);
+ System.out.println("请输入您的成绩:");
+ int score = sc.nextInt();
+ // 2. 判断成绩是否在合法范围内 0~100
+ 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("您的成绩输入有误!");
+ }
+ }
+}
+~~~
+
+优惠方案（使用赋值运算符和算术运算符计算各自的钱，使用比较运算符对比大小）
+
+```java
+public class D5 {
+ public static void main(String[] args) {
+ int yxrs = 24;
+ int yzhs =8;
+ int mf =3;
+ double zk = (yxrs+yzhs+mf)*0.8;
+ double yh = 16+ yzhs+mf;
+ double zs = zk < yh ? zk: yh ;
+ System.out.println("最少要花：" + zs);
+ }
+}
+```
+
+绿茶与红茶
+
+```java
+public class D4 {
+ public static void main(String[] args) {
+ int hc = 21;
+ int nc = 24;
+ double hcx = 21*2 +3;
+ double ncx = 24*2;
+ System.out.println(hcx == ncx);
+ }
+}
+
+```
+
+身高【使用变量的定义和算术运算符完成本题】
+
+```java
+public class D3 {
+ public static void main(String[] args) {
+ int fq = 177;
+ int mq = 165;
+ double son = (fq+mq)*1.08/2;
+ double nv = (fq*0.923 + mq)/2;
+ System.out.println(son);
+ System.out.println(nv);
+ }
+}
+
+```
+
+
+
+3的倍数
+
+ ```java
+ import java.util.Scanner;
+
+ public class D2 {
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+ System.out.println("请输入");
+ int num1 = sc.nextInt();
+ int num2 = sc.nextInt();
+ System.out.println((num1+num2)%3 == 0 || num1 ==3 ||num2 ==3);
+ }
+ }
+ ```
+
+最大数（三元运算符）
+
+```java
+import java.util.Scanner;
+
+public class D1 {
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+ System.out.println("请输入");
+ int num1 = sc.nextInt();
+ int num2 = sc.nextInt();
+ int num3 = sc.nextInt();
+ int max1 = num1 > num2 ? num1:num2;
+ int max2 = max1 > num3 ? max1:num3;
+ System.out.println("最大值："+max2);
+ }
+}
+
+```
+
+运算练习
+
+```java
+public class D6 {
+ public static void main(String[] args) {
+ int x = 5;
+ int y = 6;
+ double z = ++x + y++; //12
+
+ z = ++x + x++;//14
+
+ x = ++x + x++；//19
+
+ z = x > y ? ++x : y++;//19
+
+ }
+}
+
+```
+
diff --git "a/20 \345\206\257\351\224\220/20221220 \345\217\202\346\225\260.md" "b/20 \345\206\257\351\224\220/20221220 \345\217\202\346\225\260.md"
new file mode 100644
index 0000000000000000000000000000000000000000..1513f8b5da1eb381edd427af59106d16c8f69643
--- /dev/null
+++ "b/20 \345\206\257\351\224\220/20221220 \345\217\202\346\225\260.md"
@@ -0,0 +1,151 @@
+
+
+```java
+import java.util.Scanner;
+
+public class a2 {
+ public static void main(String[] args) {
+ Scanner sc=new Scanner(System.in);
+ System.out.println("请输入圆的半径：");
+ double r= sc.nextInt();
+ System.out.println("半径为"+r+"的圆，周长为"+getZhou(r));
+ System.out.println("半径为"+r+"的圆，面积为"+getMian(r));
+ }
+ public static double getZhou(double r){
+ return (3.14*r*2);
+ }
+ public static double getMian(double r){
+ return (3.14*r*r);
+ }
+}
+```
+
+```java
+package 循环;
+
+import java.lang.reflect.Array;
+import java.util.Random;
+import java.util.Scanner;
+
+public class H13 {
+// 在主函数中产生20个0-10之间的随机数，将这20个随机数存入数组，并通过函数计算某个数在这些随机数中出现的次数（这“某个数”是在主函数中由用户输入的）
+ public static void main(String[] args) {
+ Scanner shu =new Scanner(System.in);
+ System.out.println("请输入一个数:");
+ int ss = shu.nextInt();
+ int[] nums = new int[20];
+ for (int i = 0; i < nums.length; i++) {
+ nums[i] = (int) (Math.random() * 10);
+ System.out.print(nums[i]+"\t");}
+// Math是数学类，random（）是Math类中的一个方法，random本身只产生（0~1）之间的小数，
+// random（）*10 意思是产生0~10之间的小数 ，int(random（）*10)的意思是强制取整，把小数部分去掉只去整数部分，所以 就变成了 产生0~9之间的整数。
+ System.out.println("");
+ int count =num(nums,ss);
+ System.out.println("该数在下面的随机数中共出现过"+count+"次");
+ }
+ static int num (int []nums,int ss){
+ int count =0;
+ for (int i =0;i< nums.length;i++)
+ if (nums [i] ==ss)
+ count++;
+ return count;
+ }
+}
+```
+
+```java
+package 循环;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class H14 {
+// 在主函数中接收10个数存入数组，在自定义函数中，将该数组中的最大值与第一个元素交换，最小值与最后一个元素交换，然后在主函数中输出交换后的数组
+public static void main(String[] args) {
+ int ten =10;
+ int []arr=new int[ten];
+ Scanner num =new Scanner(System.in);
+ for (int i=0;i< arr.length;i++){
+ System.out.println("请输入第"+(i+1)+"个数:");
+ int shuru= num.nextInt();
+ arr[i]=shuru ;
+ }
+ System.out.println(Arrays.toString(arr));
+ int max =arr[0];
+ int min =arr[0];
+ maxx (max,arr);
+ System.out.println("最大值:"+maxx( max,arr));
+ minn(min,arr);
+ System.out.println("最小值:"+minn(min,arr));
+ int t=0;
+
+
+}
+ static int maxx (int max,int [] arr){
+ for (int i=0;i array = new ArrayList();
+ //循环完成再次回到主页面
+ while (true) {
+ Scanner sc = new Scanner(System.in);
+ //输出语句完成学生信息管理系统主页面的编写
+ System.out.println("-------欢迎来到学生管理系统-------");
+ System.out.println("请给出你要进行的操作：");
+ System.out.println("1.添加学生信息");
+ System.out.println("2.删除学生信息");
+ System.out.println("3.修改学生信息");
+ System.out.println("4.查看所有学生信息");
+ System.out.println("5.退出系统");
+ System.out.println("请输入你的选择序号：");
+ //键盘录入使用者要进行的操作
+ String line = sc.nextLine();
+ //用switch语句完成操作的选择
+ switch (line) {
+ case "1":
+ //添加学生信息
+ addStudent(array);
+ break;
+ case "2":
+ //S删除学生信息
+ deleteStudent(array);
+ break;
+ case "3":
+ //修改学生信息
+ updateStudent(array);
+ break;
+ case "4":
+ // 查看所有学生信息
+ findStudent(array);
+ break;
+ case "5":
+ // 感谢你的使用,退出系统
+ System.out.println("感谢你的使用!");
+ System.exit(0);//JVM退出，退出java虚拟机
+
+ }
+ }
+
+
+ }
+
+ //定义一个方法，用于系统添加学生信息
+ public static void addStudent(ArrayList array) {
+ Scanner sc = new Scanner(System.in);
+ System.out.println("请输入学生学号");
+ String sid = sc.nextLine();//获取学生学号
+ Student s = new Student();//创建学生类对象
+ s.setSid(sid);
+ int a = -1;
+ for (int i = 0; i < array.size(); i++) {//运用一个循环语句匹配输入的学号与集合中的学号
+ Student h = array.get(i);
+ if (h.getSid().equals(sid)) {
+ a = i;
+ break;
+ }
+ }
+ if (a != -1) {//学生信息已经存在，不能再次输入
+ System.out.println("该学生信息已经存在，请重新输入！");
+ } else {
+ System.out.println("请输入学生姓名");
+ String name = sc.nextLine();
+ System.out.println("请输入学生年龄");
+ String age = sc.nextLine();
+ System.out.println("请输入学生居住地");
+ String address = sc.nextLine();
+ s.setName(name);
+ s.setAge(age);
+ s.setAddress(address);
+ //将学生对象添加到集合中去
+ array.add(s);
+ //信息添加成功提示
+ System.out.println("添加学生信息成功");
+ }
+ }
+
+ //定义一个方法，用于系统查找学生信息
+ public static void findStudent(ArrayList array) {
+ //判断集合中是否有数据，如果没有显示提示信息
+ if (array.size() == 0) {
+ System.out.println("系统暂无学生信息，请先输入信息！");
+ return;//程序不再向下执行
+ }
+ //显示表头信息
+ System.out.println("学 号\t姓 名\t年 龄\t\t居住地");
+ for (int i = 0; i < array.size(); i++) {
+ Student s = array.get(i);
+ //输出学生信息
+ System.out.println(s.getSid() + "\t\t" + s.getName() + "\t\t" + s.getAge() + "岁\t\t" + s.getAddress());
+ }
+ }
+
+ //定义一个方法，用于系统删除学生信息
+ public static void deleteStudent(ArrayList array) {
+ Scanner sc = new Scanner(System.in);
+ //判断集合中是否有数据，如果没有显示提示信息
+ if (array.size() == 0) {
+ System.out.println("系统暂无学生信息，请先输入信息！");
+ return;//程序不再向下执行
+ }
+ System.out.println("请输入你要删除的学号：");
+ //输入要删除的学生学号，同时给出提示信息
+ String sid = sc.nextLine();
+ int a = -1;
+ for (int i = 0; i < array.size(); i++) {//同添加学生信息一样，运用一个循环语句匹配输入的学号与集合中的学号
+ Student s = array.get(i);
+ if (s.getSid().equals(sid)) {
+ a = i;
+ break;
+ }
+ }
+ if (a == -1) {//不存在学生信息，无法删除
+ System.out.println("该学生信息不存在，请重新输入！");
+ } else {
+ array.remove(a);
+ //学生信息删除成功提示
+ System.out.println("删除学生信息成功！");
+ }
+ }
+
+ //定义一个方法，用于系统修改学生信息
+ public static void updateStudent(ArrayList array) {
+ //定义一个方法，用于系统修改学生信息
+
+ Scanner sc = new Scanner(System.in);
+ //判断集合中是否有数据，如果没有显示提示信息
+ if (array.size() == 0) {
+ System.out.println("系统暂无学生信息，请先输入信息！");
+ return;//程序不再向下执行
+ }
+ System.out.println("请输入你要修改学生的学号：");
+ //输入要修改的学生学号，同时给出提示信息
+ String sid = sc.nextLine();
+ int a = -1;
+ for (int i = 0; i < array.size(); i++) {//同添加学生信息一样，运用一个循环语句匹配输入的学号与集合中的学号
+ Student s = array.get(i);
+ if (s.getSid().equals(sid)) {
+ a = i;
+ break;
+ }
+ }
+ if (a == -1) {//不存在学生信息，无法删除
+ System.out.println("该学生信息不存在，请重新输入！");
+ } else {
+ System.out.println("请输入学生新姓名：");
+ String name = sc.nextLine();
+ System.out.println("请输入学生新年龄：");
+ String age = sc.nextLine();
+ System.out.println("请输入学生新居住地：");
+ String address = sc.nextLine();
+ Student s = new Student();
+ s.setSid(sid);
+ s.setName(name);
+ s.setAge(age);
+ s.setAddress(address);
+ //修改集合中对应学生信息
+ for (int x = 0; x < array.size(); x++) {
+ Student t = array.get(x);
+ if (t.getSid().equals(sid)) {
+ array.set(x, s);
+ break;
+ }
+ }
+ //学生信息修改成功提示
+ System.out.println("修改学生信息成功！");
+ }
+ }
+}
+
+```
+
+
diff --git "a/20 \345\206\257\351\224\220/2022126 \345\276\252\347\216\257\350\257\255\345\217\245.md" "b/20 \345\206\257\351\224\220/2022126 \345\276\252\347\216\257\350\257\255\345\217\245.md"
new file mode 100644
index 0000000000000000000000000000000000000000..1dd1b972d8cd7b47f9c0c3689f85cbdbaebc7134
--- /dev/null
+++ "b/20 \345\206\257\351\224\220/2022126 \345\276\252\347\216\257\350\257\255\345\217\245.md"
@@ -0,0 +1,920 @@
+# 1.switch语句
+
+#### 1.1分支语句switch语句
+
+**格式**
+
+```java
+switch (表达式){
+case 1:
+ 语句体1;
+ break;
+case 2:
+ 语句体2;
+ break;
+...
+ default:
+语句体n+1;
+ break;
+}
+```
+
+执行流程：
+
+* 首先计算出表达式的值
+* 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到 break就会结 束。
+* 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束 掉。
+
+#### 1.2switch案例-减肥计划...
+
+* 需求：键盘录入星期数，显示今天的减肥活动
+
+ ```java
+ 周一：跑步
+ 周二：游泳
+ 周三：慢走
+ 周四：动感单车
+ 周五：拳击
+ 周六：爬山
+ 周日：好好吃一顿
+ ```
+
+* 示例代码：
+
+ ```java
+ public static void main(String[] args){
+ // 1. 键盘录入星期数据，使用变量接收
+ Scanner sc = new Scanner(System.in);
+ System.out.println("请输入");
+ int week = sc.nextInt();
+ // 2. 多情况判断，采用switch语句实现
+ switch(week){
+ // 3. 在不同的case中，输出对应的减肥计划
+ 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;
+ }
+ }
+ }
+ ```
+
+#### 1.3 switch语句case穿透
+
+* 概述 : 如果switch语句中,case省略了break语句, 就会开始case穿透
+
+* 需求 : 键盘录入星期数，输出工作日、休息日 (1-5)工作日，(6-7)休息日
+
+* 示例代码：
+
+ ```java
+ * /*
+ case穿透是如何产生的?
+ 如果switch语句中,case省略了break语句, 就会开始case穿透.
+ 现象：
+ 当开始case穿透，后续的case就不会具有匹配效果，内部的语句都会执行
+ 直到看见break，或者将整体switch语句执行完毕，才会结束。
+ */
+ public static void main(String[] args){
+ Scanner sc = new Scanner(System.in);
+ System.out.println("请输入星期数:");
+ int week = sc.nextInt();
+ 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;
+ }
+ }
+ }
+
+ ```
+
+## 2.for循环
+
+#### 2.1循环语句-for循环
+
+- 循环
+
+ 循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。
+
+- for循环格式 ```java for(初始化语句；条件判断语句；条件控制语句){ 循环体语句; }
+
+- 格式解释
+* [x] 初始化语句：用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
+
+* [x] 条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
+
+* [x] 循环体语句：用于表示循环反复执行的内容，简单说就是循环反复执行的事情
+
+* [x] 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
+
+* 执行流程
+
+ ①执行初始化语句
+
+ ②执行条件判断语句，看其结果是true还是false
+
+ 如果是false，循环结束
+
+ 如果是true，继续执行
+
+ ③执行循环体语句
+
+ ④执行条件控制语句
+
+ ⑤回到②继续
+
+#### 2.2for循环案例-输出数据1-5和5-1
+
+* 需求：在控制台输出1-5和5-1的数据
+
+* 示例代码
+
+ ```java
+ public class ForTest01 {
+ public static void main(String[] args) {
+ //需求：输出数据1-5
+ for(int i=1; i<=5; i++) {
+ System.out.println(i);
+ }
+ System.out.println("--------");
+ //需求：输出数据5-1
+ for(int i=5; i>=1; i--) {
+ System.out.println(i);
+ }
+ }
+ }
+ ```
+
+#### 2.3for循环案例-求1-5数据和
+
+* 需要：求1-5之间的数据和，并把求和结果在控制台输出
+
+* 示例代码：
+
+```java
+ public class ForTest02 {
+ public static void main(String[] args) {
+ //求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
+ int sum = 0;
+ //从1开始到5结束的数据，使用循环结构完成
+ for(int i=1; i<=5; i++) {
+ //将反复进行的事情写入循环结构内部
+ // 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 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);
+ }
+ }
+```
+
+* 本题要点：
+
+ 今后遇到的需求中，如果带有求和二字，请立即联想到求和变量
+
+ 求和变量的定义位置，必须在循环外部，如果在循环内部则计算出的数据将是错误的
+
+ 2.4for循环案例-求1-100
+
+#### 2.4for循环案例-求1-100偶数和
+
+- 需求：求1-100之间的偶数和，并把求和结果在控制台输出
+
+- 示例代码：
+
+```java
+public class ForTest03 {
+public static void main(String[] args) {
+//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
+int sum = 0;
+ //对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同
+for(int i=1; i<=100; i++) {
+//对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数
+if(i%2 == 0) {
+sum += i;
+}
+}
+//当循环执行完毕时，将最终数据打印出来
+System.out.println("1-100之间的偶数和是：" + sum);
+}
+}
+```
+
+#### 2.5 for循环案例-水仙花数
+
+- 需求：在控制台输出所有的“水仙花数”
+
+- 解释：什么是水仙花？
+
+ - [ ] 水仙花数，指的是一个三位数，个位，十位，百位的数字立方和等于原数
+
+ 例如 153 3 * 3 * 3 + 5 * 5 * 5 + 1 * 1 * 1 = 153
+
+- 思路
+
+ 1. 获取所有的三位数，准备进行筛选，最小的三位数为100，最大的三位数为999，使用for循环获取
+ 2. 获取每一个三位数的个位，十位，百位，做if语句判断是否是水仙花数
+
+- 示例代码
+
+ ```java
+ public class ForTest04 {
+ public static void main(String[] args) {
+ //输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结
+ 束
+ for(int i=100; i<1000; i++) {
+ //在计算之前获取三位数中每个位上的值
+ int ge = i%10;
+ int shi = i/10%10;
+ int bai = i/10/10%10;
+ //判定条件是将三位数中的每个数值取出来，计算立方和后与原始数字比较是否相等
+ if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
+ //输出满足条件的数字就是水仙花数
+ System.out.println(i);
+ }
+ }
+ }
+ }
+ ```
+
+ #### 2.6循环案例-每行打印2个水仙花数（统计）
+
+- 需求：在控制台输出所有的“水仙花数”，要求每行打印2个
+
+- 示例代码：
+
+ ```java
+ public class Demo6For {
+ /*
+ 需求：在控制台输出所有的“水仙花数”，要求每行打印2个
+ System.out.print (打印内容); 打印后不换行
+ System.out.println(打印内容); 打印后换行
+ 分析:
+ 1. 定义变量count，用于保存“打印过”的数量，初始值为0
+ 2. 在判定和打印水仙花数的过程中，拼接空格, 但不换行，并在打印后让count变量
+ +1，记录打印过的数量
+ 3. 在每一次count变量+1后，判断是否到达了2的倍数，是的话，换行。
+ */
+ public static void main(String[] args){
+ // 1. 定义变量count，用于保存“打印过”的数量，初始值为0
+ int count = 0;
+ for(int i = 100; i <= 999; i++){
+ int ge = i % 10;
+ int shi = i / 10 % 10;
+ int bai = i / 10 / 10 % 10;
+ if( (ge*ge*ge + shi*shi*shi + bai*bai*bai) == i){
+ // 2. 在判定和打印水仙花数的过程中，拼接空格, 但不换行，并在打印后让
+ count变量+1，记录打印过的数量
+ System.out.print(i + " ");
+ count++;
+ // 3. 在每一次count变量+1后，判断是否到达了2的倍数，是的话，换行
+ if(count % 2 == 0){
+ System.out.println();
+ }
+ }
+ }
+ }
+ }
+
+ ```
+
+- 本题要点：
+
+- [ ] 今后如果需求带有统计xxx，请先想到计数器变量
+
+- [ ] 计数器变量定义的位置，必须在循环外部
+
+## 3.while循环
+
+#### 3.1循环语句-while循环
+
+- while循环完整格式：
+
+ ```java
+ 初始化语句;
+ while (条件判断语句) {
+ 循环体语句;
+ 条件控制语句;
+ }
+ ```
+
+- while循环执行流程：
+1. 执行初始化语句
+
+2. 执行条件判断语句，看其结果是true还是
+
+ 如果是false，循环结束
+
+ 如果是true，继续执行
+
+3. 执行循环体语句
+
+4. 执行条件控制语句
+
+5. 回到2.继续
+- 示例代码
+
+ ```java
+ public class WhileDemo {
+ public static void main(String[] args) {
+ //需求：在控制台输出5次"HelloWorld"
+ //for循环实现
+ for(int i=1; i<=5; i++) {
+ System.out.println("HelloWorld");
+ }
+ System.out.println("--------");
+ //while循环实现
+ int j = 1;
+ while(j<=5) {
+ System.out.println("HelloWorld");
+ j++;
+ }
+ }
+ }
+ ```
+
+3.2while循环案例-珠穆朗玛峰
+
+- 需求：世界最高山峰是珠穆朗玛峰（8844.43米=8844430毫米），假如我有一张足够大的纸，他的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度？
+
+- 示例代码：
+
+ ```java
+ public class WhileTest {
+ public static void main(String[] args) {
+ //定义一个计数器，初始值为0
+ int count = 0;
+ //定义纸张厚度
+ double paper = 0.1;
+ //定义珠穆朗玛峰的高度
+ int zf = 8844430;
+ //因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while
+ 循环
+ //折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
+ while(paper <= zf) {
+ //循环的执行过程中每次纸张折叠，纸张的厚度要加倍
+ paper *= 2;
+ //在循环中执行累加，对应折叠了多少次
+ count++;
+ }
+ //打印计数器的值
+ System.out.println("需要折叠：" + count + "次");
+ }
+ }
+ ```
+
+## 4.循环细节
+
+#### 4.1循环语句-dowhile循环
+
+- 完整格式
+
+ ```java
+ 初始化语句；
+ do{
+ 循环体语句；
+ 条件控制语句；
+ }wwhile（条件判断语句）；
+ ```
+
+- 执行流程
+
+ 1.执行初始化语句
+
+ 2.执行循环体语句
+
+ 3.执行条件控制语句
+
+ 4.执行条件判断语句，看其结果是true还是
+
+ 如果是false，循环结束
+
+ 如果是true，循环继续
+
+ 5.回到2.继续
+
+- 示例代码
+
+ ```java
+ public class DoWhileDemo {
+ public static void main(String[] args) {
+ //需求：在控制台输出5次"HelloWorld"
+ //for循环实现
+ for(int i=1; i<=5; i++) {
+ System.out.println("HelloWorld");
+ }
+ System.out.println("--------");
+ //do...while循环实现
+ int j = 1;
+ do {
+ System.out.println("HelloWorld");
+ j++;
+ }while(j<=5);
+ }
+ }
+ ```
+
+#### 4.2三种循环的区别
+
+- 三种循环的区别
+
+ for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
+
+ do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
+
+- for循环和while的区别
+
+ 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
+
+ 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
+
+- 死循环（无限循环）的三种格式
+
+ 1.for(;;){}
+
+ 2.while(true){}
+
+ 3.do {} while(true);
+
+#### 4.3死循环
+
+- 死循环格式
+
+ ```java
+ for死循环格式 :
+ for(;;){
+ }
+ while死循环格式 :
+ while(true){
+ }
+ do..while死循环格式 :
+ do{
+ }while(true);
+
+ ```
+
+- 死循环案例
+
+```java
+/*
+问题: 死循环有应用场景吗?
+例如: 键盘录入一个1-100之间的整数
+顾虑: 键盘录入是用户操作的, 用户就可能会出现一些误操作的现象
+*/
+public static void main(String[] args) {
+/*
+for(;;){
+System.out.println("我停不下来了~");
+}
+*/
+/*
+while(true){
+System.out.println("我停不下来了~");
+}
+*/
+do{
+System.out.println("我停不下来了~");
+}while(true);
+System.out.println("看看我能被执行吗?~"); // 无法访问的语句
+}
+}
+
+```
+
+#### 4.4跳转控制语句
+
+- 跳转控制语句（break）
+
+ 跳出循环，结束循环
+
+- 跳转控制语句（continue）
+
+- 跳过本次循环，继续下次循环
+
+- 注意：continue只能在循环中进行使用！
+
+ ```java
+ public class Demo1Continue {
+ /*
+ continue : 跳过某次循环体内容的执行
+ 注意：使用是基于条件控制, 在循环内部使用.
+ 需求: 模拟电梯上行的过程 1-24层, 4层不停.
+ */
+ public static void main(String[] args){
+ for(int i = 1; i <= 24; i++){
+ if(i == 4){
+ continue;
+ }
+ System.out.println(i + "层到了~");
+ }
+ }
+ }
+ ```
+
+```java
+public class Demo2Break {
+/*
+break : 终止循环体内容的执行
+注意：使用是基于条件控制的
+break语句只能在循环和switch中进行使用.
+需求: 模拟20岁工作到80岁, 60岁退休.
+*/
+public static void main(String[] args){
+for(int i = 20; i <= 80; i++){
+if(i == 60){
+break; // 结束整个循环
+}
+System.out.println(i + "岁正在上班");
+}
+}
+}
+```
+
+```java
+import java.util.Scanner;
+public class Test {
+/*
+需求：程序运行后，用户可多次查询星期对应的减肥计划，直到输入0，程序结束
+步骤:
+1. 不明确用户操作几次, 使用死循环包裹业务逻辑
+2. 匹配到0的时候，使用break结束循环死循环
+*/
+public static void main (String[] args){
+lo:while(true){
+System.out.println("请输入您要查看的星期数:");
+System.out.println("(如无需继续查看,请输入0退出程序)");
+// 1. 键盘录入星期数据，使用变量接收
+Scanner sc = new Scanner(System.in);
+int week = sc.nextInt();
+// 2. 多情况判断，采用switch语句实现
+switch(week){
+// 3. 在不同的case中，输出对应的减肥计划
+case 0:
+System.out.println("感谢您的使用");
+break lo;
+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;
+}
+}
+}
+}
+```
+
+## 5.Random
+
+#### 5.1Random产生随机数（掌握）
+
+- 概述：
+
+ Random类似Scanner，也是java提供好的API，内部提供了产生随机数的功能
+
+ API（java已经写好的代码）
+
+- 使用步骤：
+ 1.导入包
+
+ impor java.util.Random;
+
+ 2.创建对象
+
+ Random r = new Random();
+
+ 3.产生随机数
+
+ int num = r.nextInt(10)
+
+- 示例代码：
+
+```java
+import java.util.Random;
+public class Demo1Random {
+/*
+Random : 产生随机数
+1. 导包 : import java.util.Random;
+导包的动作必须出现在类定义的上面
+2. 创建对象 : Random r = new Random();
+上面这个格式里面，r 是变量名，可以变，其他的都不允许变
+3. 获取随机数 : int number = r.nextInt(10); //获取数据的范围：[0,10) 包
+括0,不包括10
+上面这个格式里面，number是变量名，可以变，数字10可以变。其他的都不
+允许变
+需求: 产生随机数1-10之间的
+*/
+public static void main(String[] args){
+// 2. 创建对象
+Random r = new Random();
+for(int i = 1; i <= 10; i++){
+// 3. 获取随机数
+int num = r.nextInt(10) + 1; // 1-10
+System.out.println(num);
+}
+}
+}
+```
+
+5.2Random练习-猜数字（应用）
+
+- 需求：
+
+程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
+
+当猜错的时候根据不同情况给出相应的提示
+
+A.如果猜的数字比真实数字大，提示你猜的数据大了
+
+B.如果猜的数字比真实数字小，提示你猜的
+
+C.如果猜的数字比真实数字相等，提示恭喜你猜中了
+
+- 示例代码
+
+```java
+import java.util.Scanner;
+import java.util.Random;
+public class Test {
+/*
+需求：程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
+当猜错的时候根据不同情况给出相应的提示
+如果猜的数字比真实数字大，提示你猜的数据大了
+如果猜的数字比真实数字小，提示你猜的数据小了
+如果猜的数字与真实数字相等，提示恭喜你猜中了
+1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
+2. 使用Random产生一个1-100之间的数, 作为要猜的数
+3. 键盘录入用户猜的的数据
+4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
+5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死
+循环包裹
+6. 猜对之后, break结束.
+*/
+public static void main(String[] args){
+// 1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
+Random r = new Random();
+Scanner sc = new Scanner(System.in);
+// 2. 使用Random产生一个1-100之间的数, 作为要猜的数
+int randomNum = r.nextInt(100) + 1;
+// 5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用
+while(true)死循环包裹
+while(true){
+// 3. 键盘录入用户猜的的数据
+System.out.println("请输入您猜的数据:");
+int num = sc.nextInt();
+// 4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
+if(num > randomNum){
+System.out.println("猜大了");
+}else if(num < randomNum){
+System.out.println("猜小了");
+}else{
+// 6. 猜对之后, break结束.
+System.out.println("恭喜,猜中了");
+break;
+}
+
+}
+
+S
+y
+s
+t
+e
+m
+.
+o
+u
+t
+.
+p
+r
+i
+n
+t
+l
+n
+(
+
+"
+感
+谢
+您
+的
+使
+用
+"
+);
+}
+}
+```
+
+汽车收费
+
+```java
+import java.util.Scanner;
+
+public class 分支结构Switch {
+ public static void main(String[] args) {
+ int num;
+ String cx ;
+ double ff ;
+ Scanner sc = new Scanner(System.in);
+ System.out.println("请输入车型：");
+ cx = sc .next();
+ System.out.println("请输入行车千米数：");
+ double lc = sc.nextDouble();
+ num = 0;
+ if(cx.equals("夏利")){
+ num=1;
+ } else
+ if (cx.equals("富康")) {
+ num= 2;
+ } else
+ if (cx.equals("桑塔纳")) {
+ num=3;
+ }else
+ {
+ System.out.println("输入错误");return;
+ }
+ switch (num){
+ case 1:if (lc<=3) ff=3;
+ else ff = 3+2.1*(lc-3);
+ System.out.println("乘车费用为："+ff);
+ break;
+ case 2:if (lc<=3) ff=4;
+ else ff = 3+2.4*(lc-3);
+ System.out.println("乘车费用为："+ff);
+ break;
+ case 3:if (lc<=3) ff=5;
+ else ff = 3+2.7*(lc-3);
+ System.out.println("乘车费用为："+ff);
+ break;
+ default:
+ System.out.println("请重新输入!");
+ }
+
+ }
+}
+
+```
+
+判断字符
+
+```java
+import java.util.Scanner;
+
+public class 判断字符Switch {
+ public static void main(String[] args) {
+ //小写声母
+ String[] ch1 = {"b", "p", "m", "f", "d", "t", "n", "l", "g", "k", "h", "j", "q", "x", "zh", "ch", "sh", "r", "z", "c", "s", "y", "w"};
+//大写声母
+ String[] ch11 = {"B", "P", "M", "F", "D", "T", "N", "L", "G", "K", "H", "J", "Q", "X", "ZH", "CH", "SH", "R", "Z", "C", "S", "Y", "W"};
+//小写韵母
+ String[] ch2 = {"a", " o", "e", " i", "u", "v"};
+//大写韵母
+ String[] ch22 = {"A", " O", "E", "I", "U", "V"};
+ Scanner sn = new Scanner(System.in);
+ while (true) {
+ System.out.println("请输入：");
+ String str = sn.next();
+ boolean isWord = false;
+ for (int i = 0; i < ch1.length; i++) {
+ if (str.equals(ch1[i])) {
+ System.out.println("小写声母：" + str);
+ isWord = true;
+ break;
+ }
+ }
+ for (int i = 0; i < ch11.length; i++) {
+ if (str.equals(ch11[i])) {
+ System.out.println("大写声母：" + str);
+ isWord = true;
+ break;
+ }
+ }
+ for (int i = 0; i < ch2.length; i++) {
+ if (str.equals(ch2[i])) {
+ System.out.println("小写韵母：" + str);
+ isWord = true;
+ break;
+ }
+ }
+ for (int i = 0; i < ch22.length; i++) {
+ if (str.equals(ch22[i])) {
+ System.out.println("大写韵母：" + str);
+ isWord = true;
+ break;
+ }
+ }
+ if (!isWord) {
+ System.out.println("不是字母" + str);
+ }
+ }
+ }
+}
+```
+
+判断今天是今年第几天
+
+```java
+import java.util.Scanner;
+
+public class 闰年Switch {
+ public static void main(String[] args) {
+ int years,month,day,sum = 0;
+ Scanner sc = new Scanner(System.in);
+ System.out.println("\n请输入年.月.日:\n");
+ years = sc.nextInt();
+ month = sc.nextInt();
+ day= sc.nextInt();
+ switch (month){
+ case 1:sum=0;break;
+ case 2:sum=31;break;
+ case 3:sum=59;break;
+ case 4:sum=90;break;
+ case 5:sum=120;break;
+ case 6:sum=151;break;
+ case 7:sum=181;break;
+ case 8:sum=212;break;
+ case 9:sum=243;break;
+ case 10:sum=273;break;
+ case 11:sum=304;break;
+ case 12:sum=334;break;
+ default:
+ System.out.println("date");break;
+ }
+ sum = sum+day;
+ if( years%4==0 && years%100!=0||years%400==0)
+ {if (month>=3)
+ sum++;
+ else
+ sum= sum+day;
+
+ }
+
+ System.out.println("今天是今年的第"+sum);
+
+
+
+ }
+}
+
+```
diff --git "a/20 \345\206\257\351\224\220/2img/\345\233\276\347\211\2071.png" "b/20 \345\206\257\351\224\220/2img/\345\233\276\347\211\2071.png"
new file mode 100644
index 0000000000000000000000000000000000000000..4757f5dc031f98e21ca4d69e9074750a77efc8db
Binary files /dev/null and "b/20 \345\206\257\351\224\220/2img/\345\233\276\347\211\2071.png" differ
diff --git "a/20 \345\206\257\351\224\220/2img/\345\233\276\347\211\2072.png" "b/20 \345\206\257\351\224\220/2img/\345\233\276\347\211\2072.png"
new file mode 100644
index 0000000000000000000000000000000000000000..54a5b64dade4a61fee0e2ff91effa4b5be4def2c
Binary files /dev/null and "b/20 \345\206\257\351\224\220/2img/\345\233\276\347\211\2072.png" differ
diff --git "a/20 \345\206\257\351\224\220/2img/\345\233\276\347\211\2073.png" "b/20 \345\206\257\351\224\220/2img/\345\233\276\347\211\2073.png"
new file mode 100644
index 0000000000000000000000000000000000000000..b17ad14d51deb7103046585e0ab0206177976631
Binary files /dev/null and "b/20 \345\206\257\351\224\220/2img/\345\233\276\347\211\2073.png" differ
diff --git "a/20 \345\206\257\351\224\220/2img/\345\233\276\347\211\2074.png" "b/20 \345\206\257\351\224\220/2img/\345\233\276\347\211\2074.png"
new file mode 100644
index 0000000000000000000000000000000000000000..17494d812df010f09713db004bf7983c95c69c02
Binary files /dev/null and "b/20 \345\206\257\351\224\220/2img/\345\233\276\347\211\2074.png" differ
diff --git "a/20 \345\206\257\351\224\220/2img/\345\233\276\347\211\2075.png" "b/20 \345\206\257\351\224\220/2img/\345\233\276\347\211\2075.png"
new file mode 100644
index 0000000000000000000000000000000000000000..b7835a46e9950ccf8d0429ede987c4cff03b3b02
Binary files /dev/null and "b/20 \345\206\257\351\224\220/2img/\345\233\276\347\211\2075.png" differ
diff --git "a/21 \345\210\230\345\260\221\346\265\267/20221124 java\347\254\224\350\256\260.txt" "b/21 \345\210\230\345\260\221\346\265\267/20221124 java\347\254\224\350\256\260.txt"
deleted file mode 100644
index 544879265cdc5958d18dbc198e19afdac958fe2a..0000000000000000000000000000000000000000
--- "a/21 \345\210\230\345\260\221\346\265\267/20221124 java\347\254\224\350\256\260.txt"
+++ /dev/null
@@ -1 +0,0 @@
-https://gitee.com/liu-shaohai/java-base.git
\ No newline at end of file
diff --git "a/21 \345\210\230\345\260\221\346\265\267/20221124.md" "b/21 \345\210\230\345\260\221\346\265\267/20221124.md"
deleted file mode 100644
index fb9f57238ee23f143fe40ce446c96b07f6e37623..0000000000000000000000000000000000000000
--- "a/21 \345\210\230\345\260\221\346\265\267/20221124.md"
+++ /dev/null
@@ -1,38 +0,0 @@
-# Java认识
-Java是一门非常优秀的计算机语言
-Java之父：詹姆斯 高斯林 (James Gosling)
-## 练习
-将Java下载在自己指定的文件夹里然后改环境变量加一个变量名Java_Have变量值Java的文件路径
-并且在path里加%Java_Have%\bin，在自己指定的文件夹创建一个文档输入：
-
-```
- public class HelloWorld {
- public static void main(String[] args) {
- System.out.println("HelloWorld");
- }
-}
-```
-
-
-将文件名后缀改成java确定好后win+r打开运行输入cmd在里面输入java，然后Javac 加文件名和后缀将其编译
-在Java加文件名运行程序
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git "a/21 \345\210\230\345\260\221\346\265\267/\345\256\236\351\252\214.text" "b/21 \345\210\230\345\260\221\346\265\267/\345\256\236\351\252\214.text"
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git "a/22\345\217\267 \345\274\240\351\276\231\350\205\276/20221124 \345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250git.md" "b/22\345\217\267 \345\274\240\351\276\231\350\205\276/20221124 \345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250git.md"
deleted file mode 100644
index 13040295642577f12dc0ebc067210f17958296cc..0000000000000000000000000000000000000000
--- "a/22\345\217\267 \345\274\240\351\276\231\350\205\276/20221124 \345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250git.md"
+++ /dev/null
@@ -1,38 +0,0 @@
-# 第一次作业
-
-1.下载JDK：http://www.oracle.com
-
-2.安装jdk：
-
- 注意：不要空格，不要中文
-
-3.需要配置环境变量
-
-### git的使用
-
-1.git clone 克隆
-
-2.git add . 增加
-
-3.git commit -m “内容”
-
-4.git config --global user.email or name“内容”
-
-5.git push （回车）发送到自己仓库
-
-
-
-
-
-
-
-## 作业
-
-~~~java
-public-class HelloWorld{
- public static void main(String[] args{
- System.out.println("Hi CXK");
- }
-}
-~~~
-
diff --git "a/27\351\222\237\346\242\223\351\221\253/20221124 \345\255\246\344\271\240java\347\232\204\347\254\254\344\270\200\350\257\276.md" "b/27\351\222\237\346\242\223\351\221\253/20221124 \345\255\246\344\271\240java\347\232\204\347\254\254\344\270\200\350\257\276.md"
deleted file mode 100644
index dce7f97d8decdb64e4d76870bef85a8215b50cce..0000000000000000000000000000000000000000
--- "a/27\351\222\237\346\242\223\351\221\253/20221124 \345\255\246\344\271\240java\347\232\204\347\254\254\344\270\200\350\257\276.md"
+++ /dev/null
@@ -1,16 +0,0 @@
-jdk的安装
-
- 1.下载
- 2.安装
- 3.配置环境变量
- 4.测试运行helloWord
-
-作业
-
-```java
-public class Helloword ld{
- public static void main(String[] args){
- system.out.println("helloword")
- }
-}
-```
\ No newline at end of file
diff --git "a/29 \347\216\213\351\233\257\351\235\231/2022.11.24\345\246\202\344\275\225\344\270\213\350\275\275jdk\345\222\214\344\275\277\347\224\250git.md" "b/29 \347\216\213\351\233\257\351\235\231/2022.11.24\345\246\202\344\275\225\344\270\213\350\275\275jdk\345\222\214\344\275\277\347\224\250git.md"
deleted file mode 100644
index f6a40fd72ab261628102659e55da2cc02389398b..0000000000000000000000000000000000000000
--- "a/29 \347\216\213\351\233\257\351\235\231/2022.11.24\345\246\202\344\275\225\344\270\213\350\275\275jdk\345\222\214\344\275\277\347\224\250git.md"
+++ /dev/null
@@ -1,50 +0,0 @@
-- ***JDK的下载***
-
- 1.可以从官网上直接下载：https://www.oracle.com（但是下载慢）
-
- 2.通过国内镜像下载
-
- 3.直接下载：https://www.oracle.com/java/technologies/javase-downloads.html
-
-`**注意：针对不同的操作系统，下载对应的JDK**` `我们主要用的是JDV8 JDV11 JDV17(不是最新的是最好)`
-
-- ***JDK的安装***
-
-1.在D盘或者自己的U盘新建一个目录打开jdk安装包点击下一步选择开发工具或者源代码再把公共jdk关闭
-
-2.在之后点击更改（更改路径 例如：D：、文件名点击确定）
-
-`注意：不要写中文不要空格，路径要统一`
-
-> {为了更好地让Java运行在任何盘中我们可以设置：
->
-> 右击点击此电脑选择属性；
->
-> 找到高级设置再点击环境变量；
->
-> 在系统变量中找到新建（新建中变量名写JAVA_HOME变量值写路径）
->
-> 然后找到path打开在新建写%JAVA_HOM%、bin}
-
-- ***如何打开命令行窗口***
-
-1.右击点击开始图标选择运行
-
-2.直接在此电脑的搜索框中打出cmd
-
-- ***JAVA程序开发流程***
-
- 编写程序，编译程序，运行程序
-
- HelloWorld的程序编写
-
- ```public class HelloWorld{
-public class HelloWorld{
- public static void main(String[] args){
- System.out.println(HelloWorld);
- }
-
-
-}
- ```
-
diff --git "a/30\345\217\267\350\256\270\346\201\251\346\260\221/Java\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.txt" "b/30\345\217\267\350\256\270\346\201\251\346\260\221/Java\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.txt"
deleted file mode 100644
index d61097c1b1ad604ad531c4ee7982072355523ab4..0000000000000000000000000000000000000000
--- "a/30\345\217\267\350\256\270\346\201\251\346\260\221/Java\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.txt"
+++ /dev/null
@@ -1,22 +0,0 @@
-java第一次课笔记
-一.jdk的安装和下
-1.下载此版本: 2014年JDK(8)
-地址:通过官方网站获取JDK（https://www.oracle.com/）
-直接下载地址： https://www.oracle.com/java/technologies/javase-downloads.htm(jdk镜像)
-2.JDK的安装
-安装路径中不要包含中文和空格
-所有的开发工具最好安装目录统一(D:\develop)
-二.JDK的bin目录下两个重要的工具
-编译工具：javac
-运行工具：java
-三.java得建立
-首先在d盘建立一个java文件,然后右击此电脑的属性,找到高级设置,然后点击高级系统设置里的环境变量,然后新建一个系统变量,变量名随意,变量值选择自己需要的地方,接着编辑环境变量path,环境变量格式:%JAVA_HOME%\bin,记得下面设置一个bin目录,然后点击确定就设置完毕.
-测试:打开dos命令,输入javac.
-四.hellowword的建立
-首先在d盘中建立一个helloworld的文件夹,然后在文件夹中建立一个helloworld.java文本,打开方式记事本中写入代码保存,打开dos命令输入javac编译，编译好后运行
-代码：public class HelloXiaoxue {
-public static void main(String[] args) {
-System.out.println("HelloXiaoxue");
-}
-}
- 许恩民
diff --git "a/31 \346\235\216\346\254\243/20221124 \345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk.md" "b/31 \346\235\216\346\254\243/20221124 \345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk.md"
deleted file mode 100644
index 902009f15d27fbe6c4bbd43323061cb4e6dd4113..0000000000000000000000000000000000000000
--- "a/31 \346\235\216\346\254\243/20221124 \345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk.md"
+++ /dev/null
@@ -1,65 +0,0 @@
-#### 安装jdk
-
-##### 一. 安装途径
-
-1.通过官方网站获取JDK（https://www.oracle.com/）
-
-2.直接下载地址： https://www.oracle.com/java/technologies/javase-downloads.html
-
-**PS:**
-
-1. 不要包含中文和空格
-2. 有jdk才能开发java程序
-3. 不同的系统对应不同的jdk
-
-#### JAVA
-
-**一.bin里面的两个重要工具**
-
-1.编译工具：javac
-
-2.运行工具：java
-
-##### **二.编写程序HelloWorld**
-
-1. 在D盘新建一个文本文档文件，文件名为HelloWorld.java
-2. 用记事本打开HelloWorld.java
-3. 内容为下：记得保存
-
-```java
-public class HelloWorld{
- public static void main(String[] args){
- System.out.printlin("HelloWoorld");
- }
-}
-```
-
- 4.在高级系统设置里进入环境变量
-
- 5.新建系统变量，输入名字和安装路径
-
- 6.点击path新建java的可执行文件执行
-
- 7.打开dos，用cmd(win+r/直接输入cmd等等）
-
- 8.输入：
-
-- 编译程序
-- 格式：java 文件名.java
-- 运行程序
-- 格式：java 类名
-
- 9.出现HelloWorld极为成功
-
-###
-
-
-
-
-
-
-
-
-
-
-
diff --git "a/32\351\202\223\347\220\252/20221124 \345\255\246\344\271\240java\347\232\204\347\254\254\344\270\200\350\257\276.md" "b/32\351\202\223\347\220\252/20221124 \345\255\246\344\271\240java\347\232\204\347\254\254\344\270\200\350\257\276.md"
deleted file mode 100644
index dce7f97d8decdb64e4d76870bef85a8215b50cce..0000000000000000000000000000000000000000
--- "a/32\351\202\223\347\220\252/20221124 \345\255\246\344\271\240java\347\232\204\347\254\254\344\270\200\350\257\276.md"
+++ /dev/null
@@ -1,16 +0,0 @@
-jdk的安装
-
- 1.下载
- 2.安装
- 3.配置环境变量
- 4.测试运行helloWord
-
-作业
-
-```java
-public class Helloword ld{
- public static void main(String[] args){
- system.out.println("helloword")
- }
-}
-```
\ No newline at end of file
diff --git "a/34\345\217\267\347\250\213\351\230\263/20221124\347\254\224\350\256\260.md" "b/34\345\217\267\347\250\213\351\230\263/20221124\347\254\224\350\256\260.md"
deleted file mode 100644
index 3bf86b62b8cf92949c07ba94d18f94c6f9228af5..0000000000000000000000000000000000000000
--- "a/34\345\217\267\347\250\213\351\230\263/20221124\347\254\224\350\256\260.md"
+++ /dev/null
@@ -1,26 +0,0 @@
-## JAVA
-
-java的简介
-
-Java SE Java ME Java EE
-
-java的下载
-
-通过官方网站获取JDK（http://ww.oracle.com/）
-
-java的安装
-
-注意：不要中文、不要空格
-
-
-
-## 作业
-
-```java
-public class Helloworld{
- public static void main(String[]){
- System.out.println("hi minda")
- }
-}
-```
-
diff --git "a/35 \345\274\240\344\277\212\350\261\252/20221125\347\254\254\344\270\200\346\254\241\344\272\244\344\275\234\344\270\232.md" "b/35 \345\274\240\344\277\212\350\261\252/20221125\347\254\254\344\270\200\346\254\241\344\272\244\344\275\234\344\270\232.md"
deleted file mode 100644
index 92c537d748bc850528f2baa5409236a14fd1388f..0000000000000000000000000000000000000000
--- "a/35 \345\274\240\344\277\212\350\261\252/20221125\347\254\254\344\270\200\346\254\241\344\272\244\344\275\234\344\270\232.md"
+++ /dev/null
@@ -1,18 +0,0 @@
-# 笔记
-
-1.git clone
-
-2.点击进去建文件夹35 张俊豪
-
-3.新建一个文档后缀改为.md
-
-# 作业
-
-```java
-public class HelloWorld {
- public static void main(String[] args) {
- System.out.println("HelloWorld");
- }
-}
-```
-
diff --git "a/37 \347\216\213\346\231\264/20221124 \345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250git.md" "b/37 \347\216\213\346\231\264/20221124 \345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250git.md"
deleted file mode 100644
index 1377e060f90d02e4eedf9b31655ce353c78db9ff..0000000000000000000000000000000000000000
--- "a/37 \347\216\213\346\231\264/20221124 \345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250git.md"
+++ /dev/null
@@ -1,57 +0,0 @@
-### JDK的下载和安装
-
-- ##### JDK的下载
-
- 1. 通过官方网站获取JDK ： https://www.oracle.com/
- 2. 直接下载地址：https://www.oracle.com/java/technologies/javase-downloads.html（镜像）
-
- 注意：针对不同操作系统，下载对应的JDK
-
-
-
-- ##### JDK的安装
-
-1. 安装路径不要包含 **中文**和**空格**
-2. 所有开发工具都安装统一目录：（D：\develop）
-3. JDK的目录bin中有两个重要工具
-
- 编译工具：javac
-
- 运行工具：java
-
- 4.需要配置环境变量
-
-- ##### 第一个程序
-
- 1. HelloWorld程序编写
-
- ```java
- public class HelloWorld{
- public static void main(String[] args){
- System.out.println("HelloWorld");
- }
- }
- ```
-
-
-
-注意： 文件后缀名是 .java
-
- 文件名和代码中类名一致
-
- 2.编译和运行程序
-
- 在地址栏输入cmd，打开DOS窗口
-
- 编译程序 javac HelloWorld.java
-
- 运行程序 java HelloWorld
-
-
-
-
-
-#####
-
-
-
diff --git "a/38 \351\273\204\346\255\243\347\204\225/java\345\237\272\347\241\200\347\237\245\350\257\206\347\254\224\350\256\260.md" "b/38 \351\273\204\346\255\243\347\204\225/java\345\237\272\347\241\200\347\237\245\350\257\206\347\254\224\350\256\260.md"
deleted file mode 100644
index 77034afa187c9249dc51b7e7624cd3fdb85defe9..0000000000000000000000000000000000000000
--- "a/38 \351\273\204\346\255\243\347\204\225/java\345\237\272\347\241\200\347\237\245\350\257\206\347\254\224\350\256\260.md"
+++ /dev/null
@@ -1,67 +0,0 @@
-# 注意编写都是需要用英文，包括符号
-
-## JAVA
-
-1.三大技术平台：Java SE、Java MM、Java EE
-
-## JDK的下载与安装
-
-1.JDK是JAVA的开发工具包
-
-2.推荐下载8 11 17版本
-
-3.JDK的下载途径：
-
- (1)通过官方网站获取JDK（https://www.oracle.com/）
-
- (2)直接下载地址： https://www.oracle.com/java/technologies/javase-downloads.html
-
- (3)百度搜索jdk国内镜像
-
-## 环境变量
-
-1.右键点击此电脑----属性---高级系统设置----高级----环境变量----系统变量----新建变量为JAVA_HOME，值为D:\jdk所在文件----点击Path----新建%JAVA_HOME%\bin----三次点击确定，这一操作下来就能让你的JAVA，在任何地方都可以运行
-
-## JAVA程序开发流程
-
-1.需要三步走:
-
- 第一步:编写程序（用记事本等）
-
- 第一步里的内容为：
-
-```java
-public class Hi MXDX{
- public static void main(String[] args){ System.out.println("Hi MXDX");
- }
-}
-```
-
-
-
- 第二步:编译程序(在DOS中写Javac 文件名+java)
-
- 打开DOS的方式: 在地址栏输入cmd,就会弹出DOS窗口
-
- 按住键盘win键＋R.输入cmd就会弹出DOS窗口
-
- 
-
- 文件名为Hi MXDX.java
-
- 例如:javac HiMXDX.java
-
- 第三步:运行程序(在DOS中写 java 文件名 **注意:这里不用加后缀**)
-
- java Hi MXDX
-
- 然后完成运行
-
-大概流程为下图：
-
-
-
-
-
-
-
diff --git "a/39 \345\247\234\344\274\237\345\261\261/\346\226\260\345\273\272\346\226\207\346\234\254\346\226\207\346\241\243.md" "b/39 \345\247\234\344\274\237\345\261\261/\346\226\260\345\273\272\346\226\207\346\234\254\346\226\207\346\241\243.md"
deleted file mode 100644
index 4e91a7ce3170256f7703ceac669347714e6dd49d..0000000000000000000000000000000000000000
--- "a/39 \345\247\234\344\274\237\345\261\261/\346\226\260\345\273\272\346\226\207\346\234\254\346\226\207\346\241\243.md"
+++ /dev/null
@@ -1 +0,0 @@
-第一次作业
\ No newline at end of file
diff --git "a/40 \346\226\207\346\231\272\345\213\207/20221124 \345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250git.md" "b/40 \346\226\207\346\231\272\345\213\207/20221124 \345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250git.md"
deleted file mode 100644
index 77df964354be8a80a5cccb10ae1b85d6cd381942..0000000000000000000000000000000000000000
--- "a/40 \346\226\207\346\231\272\345\213\207/20221124 \345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250git.md"
+++ /dev/null
@@ -1,23 +0,0 @@
-## java的安装
-1.下载JDK: http://www.oraloe.com
-
-2.安装jdk :
-
- 注意:不要空格,不要中文
-
-3.需要配置环境变量:aaaa
-
-
-
-
-
-## 作业
-
-```java
-public class HelloWorld{
- public static void main(String[] args){
- System.out.println("Hi MXDX!");
- }
-}
-```
-
diff --git "a/40 \346\226\207\346\231\272\345\213\207/20221124\345\255\246\344\271\240\346\200\216\346\240\267\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250git.md" "b/40 \346\226\207\346\231\272\345\213\207/20221124\345\255\246\344\271\240\346\200\216\346\240\267\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250git.md"
deleted file mode 100644
index bdd2942674a162da28bfdd64051fffb7ad99920a..0000000000000000000000000000000000000000
--- "a/40 \346\226\207\346\231\272\345\213\207/20221124\345\255\246\344\271\240\346\200\216\346\240\267\345\256\211\350\243\205jdk\345\222\214\344\275\277\347\224\250git.md"
+++ /dev/null
@@ -1,24 +0,0 @@
-## java的安装
-
-1.下载JDK: http://www.oraloe.com
-
-2.安装jdk :
-
- 注意:不要空格,不要中文
-
-3.需要配置环境变量:aaaa
-
-
-
-
-
-## 作业
-
-```java
-public class HelloWorld{
- public static void main(String[] args){
- System.out.println("HelloWorld");
- }
-}
-```
-
diff --git "a/40 \347\224\230\345\260\217\345\274\272/day1.md" "b/40 \347\224\230\345\260\217\345\274\272/day1.md"
deleted file mode 100644
index 3862abbe78d96b5487aeb643b33d8dd6dabd1736..0000000000000000000000000000000000000000
--- "a/40 \347\224\230\345\260\217\345\274\272/day1.md"
+++ /dev/null
@@ -1,28 +0,0 @@
-### 安装JDK
-
- 1.JDK网址：http://www.oraloe.com
-
- 2.安装JDK：直接无脑下一步
-
- 注意：不要多打或少打空格，不要写入中文
-
- 3.要配置环境变量
-
-------
-
-### 作业
-
-```java
-public class HelloWorld {
- public static void main(String []args) {
- System.out.println("Hello World");
- }
-}
-```
-
-
-
-
-
-
-
diff --git "a/6 \351\203\255\345\256\207\351\221\253/2022.11.24\345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\345\246\202\344\275\225\344\275\277\347\224\250git.md" "b/6 \351\203\255\345\256\207\351\221\253/2022.11.24\345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\345\246\202\344\275\225\344\275\277\347\224\250git.md"
deleted file mode 100644
index d2cc90c897a4ef7dcdbd6a411a8dfe3af9ca7ebf..0000000000000000000000000000000000000000
--- "a/6 \351\203\255\345\256\207\351\221\253/2022.11.24\345\255\246\344\271\240\346\200\216\344\271\210\345\256\211\350\243\205jdk\345\222\214\345\246\202\344\275\225\344\275\277\347\224\250git.md"
+++ /dev/null
@@ -1,34 +0,0 @@
-## java的安装
-
-1.下载jdk：http://www.oraloe.com
-
-2.安装jdk
-
-注意：不要空格 不要中文
-
-3.注意配置环境变量
-
-
-
-
-
-## java的使用
-
-1.打开DOS窗口：选择文件所在目录的地址栏，输入cmd
-
-2.编译程序：javac HelloWorld.java
-
-3.运行程序：java HelloWorld
-
-### 作业
-
-pubilc class HelloWorld{
-
-pubilc static void main(String[] args){
-
-System.out println("HelloWorld");
-
-}
-
-}
-
diff --git "a/9\346\241\202\346\263\275\347\205\234/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.md" "b/9\346\241\202\346\263\275\347\205\234/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.md"
deleted file mode 100644
index 3e26a41ca8ca34435463a74203a4bcb98ae8b2d2..0000000000000000000000000000000000000000
--- "a/9\346\241\202\346\263\275\347\205\234/\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.md"
+++ /dev/null
@@ -1,39 +0,0 @@
-# 认识Java语言
-
-
-### 安装JDK和DOS命令使用
-
-1.注意文件路径改到D盘，文件名为英文
-
-2.设置环境变量
-
-3.DOS命令
-
- 常用DOS命令
-
-命令 功能 说明
-
-dir 显示指定路径下磁盘目录 dir[盘符:] [路径] [文件名] [参数]
-
-cd 进入指定目录 cd只能进入当前盘符下目录：cd..返回上级目录
-
-md 创建目录 可通过\创建多级目录:md一级目录\二级目录
-
-rd 删除子目录 只能删除当前目录路径下的空目录
-
-copy 拷贝文件 copy[源目录或文件] [目的目录或文件]
-
-del 删除文件 只能删除指定目录下的文件
-
-cls 清空屏幕 清空命令窗口的内容
-
-exit 退出命令窗口 关闭命令窗口
-
-```java
-public class Helloword{
- public static void mian(String []args){
- System.out.println("Hello\word");
- }
-}
-```
-
diff --git "a/\345\255\224\345\207\257\350\276\2112244310344/2022-11-25\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.md" "b/\345\255\224\345\207\257\350\276\2112244310344/2022-11-25\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.md"
deleted file mode 100644
index 6cc50faf403aa3185e0368452d96a32ea3a35b77..0000000000000000000000000000000000000000
--- "a/\345\255\224\345\207\257\350\276\2112244310344/2022-11-25\347\254\254\344\270\200\346\254\241\344\275\234\344\270\232.md"
+++ /dev/null
@@ -1,26 +0,0 @@
-# java的安装
-
-### 1.下载jdk:http://www.oraloe.com
-
-### 2.安装jdk:
-
-```注意
-注意：不要空格、不要中文
-```
-
-### 3.需要配置环境变量
-
-
-
-# 作业
-
-``` java
-public class helloworld{
- public static void main(staring[] args){
- System.out.println("hiMD!");
- }
-}
-```
-
-
-