diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/if\345\222\214switch\350\257\255\345\217\245\347\232\204\350\257\255\346\263\225.md" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/if\345\222\214switch\350\257\255\345\217\245\347\232\204\350\257\255\346\263\225.md"
new file mode 100644
index 0000000000000000000000000000000000000000..8d0e317682f881847cef3d1785cdae9544043617
--- /dev/null
+++ "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/if\345\222\214switch\350\257\255\345\217\245\347\232\204\350\257\255\346\263\225.md"	
@@ -0,0 +1,165 @@
+# 1 if语句
+
+1.1 单if语句
+
+格式：
+
+```java
+if （表达式）{
+    执行的命令；
+}
+```
+
+执行流程：
+
+1判断表达式是否满足
+
+2 如果true就执行命令否则执行false语句
+
+3如果满足表达式则不执行false语句
+
+4继续执行后面语句内容
+
+```java
+public class name{
+    public static void main(String[ ] args){
+    System.out.println("开始");
+        Scanner sc=new Scanner(System.in);
+        int age=sc nextInt();
+        if(age>=18){
+            System.out.println("通过")
+        }
+    }
+}
+```
+
+1.2 if 后跟else
+
+格式
+
+```java
+if （表达式）{
+    执行的命令；
+}
+else{
+    执行的命令；
+}
+```
+
+执行流程
+
+1首先计算关系表达式的值
+
+2如果关系表达式的值为true就执行语句体1
+
+3如果关系表达式的值为false就执行语句体2
+
+4继续执行后面的语句内容
+
+```java
+public class Demo2If {
+	public static void main(String[] args) {
+		// 程序判断一个数, 是奇数还是偶数
+		int num;
+		Scanner sc=new Scanner(System.in);
+        int=sc nextInt()
+		if(num % 2 == 0){
+			System.out.println("偶数");
+		}else{
+			System.out.println("奇数");
+		}
+	}
+}
+```
+
+1.3 else if语句
+
+格式
+
+```java
+if(式子1){
+   命令1；
+}
+else if(式子2){
+    命令2；
+}
+else if(式子3){
+    命令3；
+}
+…
+ else {
+     语句n+1
+ }
+```
+
+
+
+执行流程：
+
+1首先计算关系表达式1的值
+
+2如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
+
+3如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
+
+4…
+
+5如果没有任何关系表达式为true，就执行语句体n+1。
+
+![](.\t1.png)
+
+# 2 switch语句
+
+1语句
+
+格式
+
+```java
+  switch(表达式子){
+      case 1:
+          命令1；
+       break;
+      case 2:
+          命令2；
+       break;
+      case 2:
+          命令2；
+       break;
+      default:
+          命令3
+         break;
+  }
+```
+
+执行流程：
+1 首先计算出表达式的值
+2 其次，和case依次比较，一旦有对应的值,就会执行相应的语句，在执行的过程中，遇到break就会结束。
+3 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
+
+例子：减肥案例
+
+![](.\t2.png)
+
+2. switch语句case穿透
+
+   原因: 如果switch语句中,case省略了break语句, 就会开始case穿透。
+
+   现象：当开始case穿透，后续的case就不会具有匹配效果，内部的语句都会执行 直到看见break，或者将整体switch语句执行完毕，才会结束。
+
+   例子：
+
+   ![](.\t3.png)
+
+# 作业
+
+1  出租车
+
+![](.\work1.png)
+
+2   天数
+
+![](.\work2.png)
+
+3  字符判断
+
+![](.\work3.png)
\ No newline at end of file
diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/t1.png" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/t1.png"
new file mode 100644
index 0000000000000000000000000000000000000000..02637fe9ba959021353b086b201a13c6de61e8a4
Binary files /dev/null and "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/t1.png" differ
diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/t2.png" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/t2.png"
new file mode 100644
index 0000000000000000000000000000000000000000..a788ad9671639b98475fbe9848faa4922a608fe6
Binary files /dev/null and "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/t2.png" differ
diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/t3.png" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/t3.png"
new file mode 100644
index 0000000000000000000000000000000000000000..08c9da4e63b6f3b41f6a004d8349efeab79d2cb4
Binary files /dev/null and "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/t3.png" differ
diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/work1.png" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/work1.png"
new file mode 100644
index 0000000000000000000000000000000000000000..923a9f1271c2a18cab18b14552c2a04e51672f06
Binary files /dev/null and "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/work1.png" differ
diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/work2.png" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/work2.png"
new file mode 100644
index 0000000000000000000000000000000000000000..d52bc70ed6cffef1be1d3e406fd2e57adffdf51a
Binary files /dev/null and "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/work2.png" differ
diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/work3.png" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/work3.png"
new file mode 100644
index 0000000000000000000000000000000000000000..56f763986b24425a14c20b29960fb0568082d584
Binary files /dev/null and "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221202/work3.png" differ
diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/for,while\345\276\252\347\216\257\347\254\224\350\256\260.md" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/for,while\345\276\252\347\216\257\347\254\224\350\256\260.md"
new file mode 100644
index 0000000000000000000000000000000000000000..598338140af0d656d95830885899c9485feaf23b
--- /dev/null
+++ "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/for,while\345\276\252\347\216\257\347\254\224\350\256\260.md"	
@@ -0,0 +1,175 @@
+# 1.for循环
+
+1.1循环的定义
+
+循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。
+
+1.2 for循环格式:
+
+```
+for(初始化语句;条件判断语句;条件控制语句){
+        循环语句体；
+}
+```
+
+格式解释：
+     初始化语句：  用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
+     条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
+     循环体语句：  用于表示循环反复执行的内容，简单说就是循环反复执行的事情
+     条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
+
+流程:
+
+先执行初始化语句之后进行判断初始化语句是否满足条件如果满足进行循环语句，之后执行条件控制语句，之后继续执行条件判断不执行初始化语句，直到条件不满足则不执行循环。
+
+<hr>
+
+#### 案例
+
+1. 1-5输出
+
+   ![](.\tfor1.png)
+
+2. 5-1输出
+
+   ![](.\tfor2.png)
+
+
+
+
+
+3.1-5求和
+
+![](.\tfor3.png)
+
+4.1-100偶数求和
+
+![tfor4](.\tfor4.png)
+
+5水仙花数
+
+![](.\tfor5.png)
+
+# 2 while循环语句
+
+while循环完整格式：
+
+```java
+初始化语句;
+while (条件判断语句) {
+循环体语句;
+条件控制语句;
+}
+```
+
+while循环执行流程：
+
+ 1 执行初始化语句之后执行条件判断语句，看其结果是true还是false 如果是false，循环结束 如果是true，继续执行，之后执行循环体语句，之后执行条件限制语句，然后继续判断条件。
+
+例子：
+
+```java
+public class WhileDemo { public static void main(String[] args) {
+for(int i=1; i<=5; i++) {
+System.out.println("HelloWorld");
+}
+System.out.println("--------");
+int j = 1;
+while(j<=5) {
+System.out.println("HelloWorld");
+j++;
+           }
+    }
+ }
+```
+
+1.珠穆朗玛峰
+
+需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚
+度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
+示例代码：
+
+```java
+pupublic class WhileTest {
+    public static void main(String[] args) {
+                   int count = 0;
+                   double paper = 0.1;
+                   int height = 8844430;
+while(paper <= zf) {
+paper *= 2;
+count++;
+}
+System.out.println("需要折叠：" + count + "次");
+}
+}
+```
+
+# 3 do......while循环
+
+格式：
+
+```Java
+初始化语句;
+do {
+循环体语句;
+条件控制语句;
+}while(条件判断语句);
+```
+
+执行流程：
+$$
+
+$$
+1  执行初始化语句
+2  执行循环体语句
+3  执行条件控制语句
+4 执行条件判断语句，看其结果是true还是false
+
+如果是false，结束循环
+
+如果是true，循环继续
+
+之后执行2
+
+例子：
+
+```java
+public class DoWhileDemo { public static void main(String[] args) {
+int j = 1; do {
+System.out.println("HelloWorld");
+j++;
+}while(j<=5);
+}
+}
+```
+
+# 4死循环
+
+1格式
+
+```java
+for死循环格式 : for(;;){
+}
+while死循环格式 : while(true){
+}
+do..while死循环格式 :
+do{
+}while(true);
+```
+
+2案例
+
+```java
+public static void main(String[] args) {
+for(;;){ System.out.println("我停不下来了~");
+}
+while(true){ System.out.println("我停不下来了~");
+}
+do{
+System.out.println("我停不下来了~");
+}while(true);
+System.out.println("看看我能被执行吗?~");   
+}
+}
+```
+
diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/tfor1.png" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/tfor1.png"
new file mode 100644
index 0000000000000000000000000000000000000000..dd1112315170be2e6d33ee1c0c75f9ecd1c7d821
Binary files /dev/null and "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/tfor1.png" differ
diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/tfor2.png" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/tfor2.png"
new file mode 100644
index 0000000000000000000000000000000000000000..2c78a5a583170d7aaacb88e053241fd1ee8eaed9
Binary files /dev/null and "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/tfor2.png" differ
diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/tfor3.png" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/tfor3.png"
new file mode 100644
index 0000000000000000000000000000000000000000..d8f02497294ed0265a97daec681ae853d7462205
Binary files /dev/null and "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/tfor3.png" differ
diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/tfor4.png" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/tfor4.png"
new file mode 100644
index 0000000000000000000000000000000000000000..dc103f50bc90e9bc084c679830da04419c2c7807
Binary files /dev/null and "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/tfor4.png" differ
diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/tfor5.png" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/tfor5.png"
new file mode 100644
index 0000000000000000000000000000000000000000..36f4fe316e02f318c095a911d0c8d1673017f98b
Binary files /dev/null and "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221206\345\276\252\347\216\257/tfor5.png" differ
diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221208 \351\232\217\346\234\272\345\207\275\346\225\260\345\222\214\345\207\275\346\225\260\347\273\204.md" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221208 \351\232\217\346\234\272\345\207\275\346\225\260\345\222\214\345\207\275\346\225\260\347\273\204.md"
new file mode 100644
index 0000000000000000000000000000000000000000..dfc720eb46c766ab2818b7889b6fff83f6397167
--- /dev/null
+++ "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221208 \351\232\217\346\234\272\345\207\275\346\225\260\345\222\214\345\207\275\346\225\260\347\273\204.md"	
@@ -0,0 +1,215 @@
+# 1 Rando产生随机数
+
+概述：
+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
+
+示例
+
+1. ```Java
+  import java.util.Random;
+  public class Demo1Random {
+  
+     public static void main(String[] args){
+     Random r = new Random();
+     for(int i = 1; i <= 10; i++){
+     int num = r.nextInt(10) + 1;  
+     System.out.println(num);
+     }
+     }
+     }
+  ```
+
+  猜数字游戏（作业）
+
+  ```java
+  import java.util.Random;
+  import java.util.Scanner;
+  
+  public class a {
+          public static void main(String[] args){
+  
+              Random r = new Random(); Scanner sc = new Scanner(System.in);
+              int randomNum = r.nextInt(100) + 1;
+              int count=0;
+              one:while (true) {
+                  System.out.println("请输入您猜的数据:");
+                  int num = sc.nextInt();
+                  if (num > randomNum) {
+                      System.out.println("猜大了");
+                  } else if (num < randomNum) {
+                      System.out.println("猜小了");
+                  } else {
+                      System.out.println("恭喜,猜中了");
+                      break ;
+                  }
+                      count++;
+                      if (count == 3) {
+                          System.out.println("已经猜错三次了是否继续(输入y继续，输入其它退出)");
+                          char a = sc.next().charAt(0);
+                          switch (a) {
+                              case 'y':
+                              case 'Y':
+                                  count -= 3;
+                                  break;
+                              default:{  break one;
+                                          }
+                          }
+                      }
+                  }
+              }
+      }
+  
+  ```
+
+  # 2数组
+
+  1定义：数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。
+
+​       2格式
+
+​          2.1数据类型[] 数组名
+
+例示:
+
+```java
+int[] arr;        
+double[] arr;      
+char[] arr;
+```
+
+​        2.2数据类型 数组名 []
+
+例示：
+
+```Java
+int arr[];
+double arr[];
+char arr[];
+```
+
+​       3数组的动态初始化
+
+1定义：	数组动态初始化就是只给定数组的长度，由系统给出默认初始化值
+
+ 2格式
+
+```java
+数据类型[] 数组名 = new 数据类型[数组长度];
+```
+
+例如：
+
+```java
+int[] arr = new int[3];
+```
+
+#### 1.3.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什么是索引
+
+​	每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。
+
+​	这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。
+
+2格式访问数组元素格式:
+
+```java
+数组名[索引];
+```
+
+例示:
+
+```java
+package com.itheima.array;
+
+public class Demo3ArrayIndex {
+    public static void main(String[] args) {
+        int[] arr = new int[3];         
+        System.out.println(arr);        
+        System.out.println(arr[0]);     
+        System.out.println(arr[1]);
+        System.out.println(arr[2]);
+
+        System.out.println("--------------");
+
+        
+        arr[0] = 11;
+        arr[1] = 22;
+        arr[2] = 33;
+
+        System.out.println(arr[0]);
+        System.out.println(arr[1]);
+        System.out.println(arr[2]);
+    }
+}
+```
+
diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221209 \346\225\260\347\273\204\347\232\204\345\237\272\346\234\254\350\257\255\346\263\225\344\273\245\345\217\212\351\232\217\346\234\272\346\225\260\347\224\250\346\263\225/homework.png" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221209 \346\225\260\347\273\204\347\232\204\345\237\272\346\234\254\350\257\255\346\263\225\344\273\245\345\217\212\351\232\217\346\234\272\346\225\260\347\224\250\346\263\225/homework.png"
new file mode 100644
index 0000000000000000000000000000000000000000..129c61eef5267f882fff203e2a409c5dfe64f0d6
Binary files /dev/null and "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221209 \346\225\260\347\273\204\347\232\204\345\237\272\346\234\254\350\257\255\346\263\225\344\273\245\345\217\212\351\232\217\346\234\272\346\225\260\347\224\250\346\263\225/homework.png" differ
diff --git "a/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221209 \346\225\260\347\273\204\347\232\204\345\237\272\346\234\254\350\257\255\346\263\225\344\273\245\345\217\212\351\232\217\346\234\272\346\225\260\347\224\250\346\263\225/\346\225\260\347\273\204\347\232\204\345\237\272\346\234\254\350\257\255\346\263\225\345\217\212\347\254\224\350\256\260.md" "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221209 \346\225\260\347\273\204\347\232\204\345\237\272\346\234\254\350\257\255\346\263\225\344\273\245\345\217\212\351\232\217\346\234\272\346\225\260\347\224\250\346\263\225/\346\225\260\347\273\204\347\232\204\345\237\272\346\234\254\350\257\255\346\263\225\345\217\212\347\254\224\350\256\260.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9f722b5fb050dd8f672f5aa57e5a73b2ffa75ec9
--- /dev/null
+++ "b/23\345\217\267 \351\273\204\346\265\251\344\270\234/20221209 \346\225\260\347\273\204\347\232\204\345\237\272\346\234\254\350\257\255\346\263\225\344\273\245\345\217\212\351\232\217\346\234\272\346\225\260\347\224\250\346\263\225/\346\225\260\347\273\204\347\232\204\345\237\272\346\234\254\350\257\255\346\263\225\345\217\212\347\254\224\350\256\260.md"	
@@ -0,0 +1,276 @@
+# 1.数组
+
+### 1.1定义
+
+数组就是存放同一类型不同值的数据的容器；
+
+### 1.2命名格式
+
+1.数据类型[] 数组名；
+
+例示
+
+```java
+int[] arr;
+char[] arr;
+double[] arr;
+```
+
+2.数据类型 数组名[]；
+
+例示：
+
+```java
+int arr[];
+char arr[];
+double arr[];
+```
+
+### 1.3数组的动态命名
+
+1.3.1 定义
+
+​    只定义数组长度不定义内容，由系统给内容。
+
+1.3.2格式
+
+```java
+数据类型[] 数组名 = new 数据类型[长度]
+```
+
+```java
+int[] arr /*数组的命名格式*/= new/*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.4数组的静态初始化
+
+1定义：创建数组时，直接将元素确定。
+
+2格式
+
+```java
+数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
+```
+
+例示
+
+```Java
+package com.itheima.array2;
+public class Demo1Array {
+/*
+数组静态初始化 : 初始化时指定每个数组元素的初始值，由系统决定数组长度
+完整格式:
+数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
+简化格式:
+数据类型[] 数组名 = {数据1,数据2,数据3...};
+*/
+public static void main(String[] args) {
+// 数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
+int[] arr = new int[]{11,22,33};
+System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]);
+// 数据类型[] 数组名 = {数据1,数据2,数据3...};
+int[] arr2 = {44,55,66};
+System.out.println(arr2); System.out.println(arr2[0]);
+```
+
+### 1.5数组元素访问
+
+1.5.1引索
+
+定义：就是‘[]’中的数值。每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。
+
+可以通过数组的索引访问到数组中的元素。
+
+1.5.2访问数据格式
+
+```java
+数组名[引索];
+```
+
+1.5.3 例示：
+
+```java
+package com.itheima.array;
+public class Demo3ArrayIndex {
+/*
+数组动态初始化:
+初始化的时候, 手动指定数组长度, 系统会为数组容器分配初始值.
+数组的元素访问格式:
+数组名[索引]
+索引: 数组中数据的编号方式, 编号从0开始
+作用: 访问数组容器中的空间位置
+注意:
+数组在创建完毕后, 即使没有赋值, 也可以取出, 但取出的元素都是默认初始化
+值.
+*/
+public static void main(String[] args) {
+int[] arr = new int[3];         // 0 1 2
+System.out.println(arr);        // 数组的内存地址  [I@10f87f48
+// 数组名[索引]  访问数组容器中的空间位置
+System.out.println(arr[0]);     // 0  系统自动分配的默认初始化值 
+System.out.println(arr[1]);
+System.out.println(arr[2]); 
+System.out.println("--------------");
+// 数组名[索引]
+arr[0] = 11; arr[1] = 22; arr[2] = 33;
+System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]);
+}
+}
+```
+
+### 1.6 Java中的内存分配
+
+Java的内存分配主要有三个位置，
+方法区，就是字节文件。存储未运行的代码。
+栈内存，当方法运行的时候，则在栈内存中存储。
+堆内存，当方法新生成对象的时候，或者新产生出局的时候将在堆内存中存储。
+
+方法区：字节文件加载时进入的内存
+存储的就是编写成功后的编码。
+方法没有运行的时候，实在这里存储的
+
+栈内存：方法与你形式所进入的内存 变量也是在这里
+main方法，加载变量，没有存数据，
+方法如果进行运行，在没有进行新生成数据的时候，代码就是在栈中存储。
+
+堆内存：new出来的东西会在这块内存中开辟空间并产生地址
+当方法进行new新建的时候，则这个新建的数据则会在堆内存中存放。
+
+### 1.7数组操作的两个常见问题
+
+1.7.1索引越界异常
+
+出现原因：
+
+数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。
+程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界
+异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
+
+例如：
+
+```java
+public class ArrayDemo { public static void main(String[] args) {
+int[] arr = new int[3];
+System.out.println(arr[3]);
+}
+}
+```
+
+修改：
+
+```java
+public class ArrayDemo { public static void main(String[] args) {
+int[] arr = new int[4];
+System.out.println(arr[3]);
+}
+}
+```
+
+1.7.2.空指针异常
+
+出现原因：
+
+​    arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因 此运行的时候会抛出 NullPointerException 空指针异常。在开发中，空指针异常是不能出现的， 一旦出现了，就必须要修改我们编写的代码。
+
+例如：
+
+```java
+public class ArrayDemo { public static void main(String[] args) {
+int[] arr = new int[3];
+//把null赋值给数组
+arr = null;
+System.out.println(arr[0]);
+}
+}
+```
+
+修改：
+
+```java
+public class ArrayDemo { public static void main(String[] args) {
+int[] arr = new int[3];
+//把‘arr = null;’删除
+System.out.println(arr[0]);
+}
+}
+```
+
+# 作业
+
+1闽大举行选美比赛，男生参赛，10个女生当评委，定义一个数组，存放评分，用随机数模拟打分的过程，用程序算出选手的最后得分【去掉一个最高分，再去掉一个最低分，用剩下的分数求平均值】
+
+```java
+import java.util.Random;
+import java.util.Scanner;
+
+public class bwdf {
+    public static void main(String[] args) {
+        int[] fen = new int[10];
+        int max;
+        int min;
+        int sum = 0;
+        double middle;
+        Random ran = new Random();
+
+        for (int i = 0; i < fen.length; i++) {
+            fen[i] = ran.nextInt(10) + 1;
+            System.out.println("第" +(i+1) + "位评委打分为" + fen[i]);
+            sum+=fen[i];
+        }
+        max=fen[0];
+        for (int i = 0; i < fen.length; i++) {
+            if (max < fen[i]) {
+                max = fen[i];
+            }
+        }
+            min=fen[0];
+        for (int i = 0; i < fen.length; i++) {
+            if (min > fen[i]) {
+                min = fen[i];
+            }
+        }
+        middle=(sum-max-min)*1.0/8;
+        System.out.println("最高分为："+max);
+        System.out.println("最低分为："+min);
+        System.out.println("平均分为："+middle);
+    }
+}
+
+```
+
+![](.\homework.png)
\ No newline at end of file