diff --git "a/09 \346\241\202\346\263\275\347\205\234/2022-12-24 \347\261\273\344\270\216\345\257\271\350\261\241 .md" "b/09 \346\241\202\346\263\275\347\205\234/2022-12-24 \347\261\273\344\270\216\345\257\271\350\261\241 .md"
new file mode 100644
index 0000000000000000000000000000000000000000..c48da88cc002291008f9ee3e29f8e6b2965da65c
--- /dev/null
+++ "b/09 \346\241\202\346\263\275\347\205\234/2022-12-24 \347\261\273\344\270\216\345\257\271\350\261\241 .md"	
@@ -0,0 +1,73 @@
+# 类与对象
+
+类是Java中最重要的数据类型。类的目的是抽象出一类事物的共有属性和行为，即抽象出数据以及数据上所进行的操作
+
+类的类体由两部分组成：
+
+(1)变量的声明
+
+(2)方法的定义
+
+构造方法用于创建对象，其中方法名与类名相同，其他的方法供该类创建的对象调用
+
+构造方法包括：
+
+(1)方法名
+
+(2)类名
+
+(3)无类型
+
+抽象的目的是产生类，而类的目的是创建具有属性和行为的对象。使用new运算符和类的构造方法为声明的对象分配变量，即创建对象，对象不仅可以操作自己的变量改变现状，而且能调用类中的方法产生一定的行为
+
+Java以类为“基本单位”，即一个Java程序就是由若干个类构成，一个Java程序可以将它使用的各个类分别存放在不同的源文件中，也可以将它使用的类放在一个源文件中
+
+![img](clip_image001-1671888029728.png) 
+
+类的成员变量可以是某个类的对象
+
+类的两种基本的成员：变量和方法
+
+变量：用来刻画对象的属性
+
+方法：用来体现对象的行为
+
+成员变量：用来刻画类创建的对象的属性
+
+成员变量分为两部分{实例变量、（静态变量、类变量）}
+
+实例变量：和对象相关联的变量
+
+类变量：与类相关联的变量
+
+
+
+不同对象的实例变量分配到不同的内存空间，类变量分配到同一处内存空间
+
+方法是类体的重要成员之一，构造方法是具有特殊地位的方法，供类创建对象时使用，用来给出类所创建的初始化状态，类所创建的对象可以调用这些方法形成一定的算法，体现对象具有某种行为
+
+实例方法可操作实例成员变量和静态成员变量，静态方法只能操作静态成员变量
+
+![img](clip_image001.png) 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
\ No newline at end of file
diff --git "a/09 \346\241\202\346\263\275\347\205\234/2022-12-24 \347\273\247\346\211\277\344\270\216\346\216\245\345\217\243.md" "b/09 \346\241\202\346\263\275\347\205\234/2022-12-24 \347\273\247\346\211\277\344\270\216\346\216\245\345\217\243.md"
new file mode 100644
index 0000000000000000000000000000000000000000..04886001042f8c2550c4c947942c3ad0a5d1600d
--- /dev/null
+++ "b/09 \346\241\202\346\263\275\347\205\234/2022-12-24 \347\273\247\346\211\277\344\270\216\346\216\245\345\217\243.md"	
@@ -0,0 +1,199 @@
+# 继承与接口
+
+由继承而得到的类称为子类，被继承的类称为父类(超类)，Java不支持多重继承，即子类只有一个父类
+
+子类和父类在同一个包中，子类自然地继承了父类中不是private的成员变量作为子类的成员变量，并且也自然的继承了父类中不是private的方法作为子类的方法。继承的成员变量或方法的访问权限保持不变
+
+子类和父类不在同一个包中，父类中的private和方法访问权限的成员变量不会被子类继承
+
+子类声明的成员变量的名字和从父类继承来的成员变量的名字相同时，将隐藏掉所有继承的成员变量
+
+方法重写：子类中定义一个方法，这个方法的类型和父类的方法的类型一致或者是父类的方法的类型的子类型，并且这个方法的名字、参数个数、参数的类型和父类完全相同
+
+子类继承的方法所操作的成员变量一定是被子类继承或隐藏的成员变量，重写的方法无法操作被子类隐藏的成员变量和方法
+
+```java
+public class people {
+
+    protected String like;
+        public void speaklike () {
+            System.out.println("yayayaya");
+        }
+        public void averagelike () {
+            like = "编程";
+            System.out.println("averagelike:" + like);
+        }
+}
+  class chinesepeople extends people{
+    public void speaklike(){
+        System.out.println("谢谢");
+    }
+    public void averagelike(){
+        like = "游戏";
+        System.out.println("喜欢："+like);
+    }
+    public void chinalike(){
+        System.out.println("他很喜欢");
+    }
+
+      public static void main(String[] args) {
+          people people = new people();
+          chinesepeople chinesepeople = new chinesepeople();
+          people.speaklike();
+          people.averagelike();
+          chinesepeople.speaklike();
+          chinesepeople.averagelike();
+          chinesepeople.chinalike();
+      }
+}
+```
+
+
+
+子类一旦隐藏了继承的成员变量，子类创建的对象就不再拥有该变量，该变量将归关键字super所拥有，同样子类一旦重写了继承方法，就覆盖(隐藏)了继承的方法，子类创建的对象就不能调用被覆盖(隐藏)的方法，该方法的调用由关键字super负责
+
+在子类中想要使用隐藏的成员变量或覆盖的方法就要使用super关键字
+
+super.x、super.play()就是访问和调用被子类隐藏的成员变量x和方法play()
+
+```java
+public class bank{
+    int money;
+    int year;
+    double interest;
+    double getInterest = 0.3;
+    public double computerInterest(){
+        interest = year * getInterest * money;
+        return interest;
+    }
+    public void  setInterest(double rest){
+        getInterest = rest;
+    }
+    public static class  Constructionban extends  bank{
+        double year;
+
+        public double computerInterest(){
+            super.year = (int) year;
+            double r = year - (int) year;
+            int day = (int) (r * 1500);
+            double yearInterest = super.computerInterest();
+            double dayInterest = day * 0.01 * money;
+            System.out.println("%d元在农商银行%d年零%天的利息：%f元\n"+money
+                    +super.year+day+interest);
+            return interest;
+        }
+    }
+   public static class bankof extends bank {
+       double year;
+
+       public double computerInterest() {
+           super.year = (int) year;
+           double r = year - (int) year;
+           int day = (int) (r * 1500);
+           double yearInterest = super.computerInterest();
+           double dayInterest = day * 0.012 * money;
+           System.out.println("%d元在农业银行%d年零%天的利息：%f元\n" + money
+                   + super.year + day + interest);
+           return interest;
+       }
+   }
+}
+```
+
+```java
+public class Money {
+    public static void main(String[] args) {
+        int a = 9000;
+        bank.Constructionban bank = new bank.Constructionban();
+        bank.money = a;
+        bank.year = 8.2;
+        bank.setInterest(0.03);
+        double interest = bank.computerInterest();
+        bank.bankof bankof = new bank.bankof();
+        bankof.year = 8.2;
+        bankof.setInterest(0.03);
+        double interest2 = bankof.computerInterest();
+        System.out.println("两个银行利息相差%f元\n" + (interest - interest2));
+    }
+}
+```
+
+```注意
+当super调用被隐藏的方法时，该方法中出现的成员变量被子类隐藏的成员变量或继承的成员变量
+
+子类不继承父类的构造方法，子类在其构造方法中需要使用super来调用父类的构造方法，而且super必须是子类构造方法中的头一条语句
+
+在子类的构造方法中，没有明显地写出super关键字来调用父类的某个构造方法，默认有"super();",类中定义多个构造方法时，建议包括一个不带参数的构造方法，以便子类可以省略"super();"
+```
+
+
+
+B类是A类的子类或间接子类，当用子类B创建一个对象，并把这个对象的引用放到A类声明的对象中
+
+```java
+public abstract class rf{
+    public abstract  double getarea();
+}
+
+ class totarea{
+     private static Cir[] ret;
+     rf[] rfs;
+    double totarea = 0;
+    public void setTotarea(rf[]rfs1){
+        rfs = rfs1;
+    }
+    public double computertotarea(){
+
+        return totarea;
+    }
+ class ret extends  rf{
+
+     @Override
+     public double getarea() {
+         return 0;
+     }
+     double a ,b;
+     ret(double a,double b){
+         this.a = a;
+         this.b = b;
+     }
+ }
+  static class Cir extends rf{
+
+      public Cir(int r) {
+          super();
+      }
+
+      @Override
+      public double getarea() {
+          return getarea();
+      }
+      double r;
+      Cir(double r, int i){
+          this.r = r;
+      }
+  }
+
+     public static void main(String[] args) {
+         rf [] rfs = new  rf[40];
+         for(int i = 0; i < rfs.length ; i++){
+             if(i % 3 == 0){
+                 rfs[i] = new Cir(20+i,63);
+
+             } else if(i % 3 == 1){
+                 rfs[i] = new Cir(25+i);
+             }
+         }
+         totarea computer = new totarea();
+         computer.setTotarea(rfs);
+         System.out.println("各种图形的面积之和为：\n%f"+computer.computertotarea());
+     }
+}
+```
+
+
+
+接口体中只有常量的声明和抽象方法声明，接口体中所有的常量的访问权限一定都是Public、所有的抽象方法的访问权限一定都是Public
+
+类实现接口，以便绑定接口中的方法，一个类可以实现多个接口，类通过使用关键字implements声明自己实现一个或多个接口，一个非抽象类实现了某个接口，那么这个类必须重写该接口的所有方法
+
diff --git "a/09 \346\241\202\346\263\275\347\205\234/clip_image001-1671888029728.png" "b/09 \346\241\202\346\263\275\347\205\234/clip_image001-1671888029728.png"
new file mode 100644
index 0000000000000000000000000000000000000000..5065291a21dab272221cc1bfee08fdf9f9ea938e
Binary files /dev/null and "b/09 \346\241\202\346\263\275\347\205\234/clip_image001-1671888029728.png" differ
diff --git "a/09 \346\241\202\346\263\275\347\205\234/clip_image001.png" "b/09 \346\241\202\346\263\275\347\205\234/clip_image001.png"
new file mode 100644
index 0000000000000000000000000000000000000000..16ede36d5fdd48d91d475c92686f9934131e6175
Binary files /dev/null and "b/09 \346\241\202\346\263\275\347\205\234/clip_image001.png" differ
diff --git "a/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\344\275\234\344\270\232.md" "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\344\275\234\344\270\232.md"
new file mode 100644
index 0000000000000000000000000000000000000000..43cfc8f3753b540e04bdc13df1c26983fef8d960
--- /dev/null
+++ "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\344\275\234\344\270\232.md"	
@@ -0,0 +1,307 @@
+# 巩固题
+
+## 1、输出你最想说的一句话！
+
+* 编写步骤：
+
+1. 定义类 Homework1
+
+2. 定义 main方法
+
+3. 控制台输出5行字符串类型常量值
+
+   ```java
+   public class Homework1 {
+       public static void main(String[] args) {
+           int a; a = 3;
+           double b; b =6;
+           float c;  c = 7;
+           short d; d = 97;
+           long e ; e = 87;
+   
+           System.out.print("a的值为：" + a +
+                   "\nb的值为："+b +
+                   "\nc的值为："+c +
+                   "\nd的值为："+d +
+                   "\ne的值为："+e);
+       }
+   }
+   ```
+
+   
+
+## 2、按步骤编写代码，效果如图所示：
+
+![](Java基础语法图片/1.jpg)
+
+* 编写步骤：
+
+1. 定义类 Homework2
+
+2. 定义 main方法
+
+3. 控制台输出5行字符串类型常量值
+
+4. 控制台输出5行字符类型常量值
+
+   ```java
+   public class Homework2 {
+       public static void main(String[] args) {
+           String a = "善学如春起之苗";
+           a ="不见其增，日有所长";
+           System.out.println(a);
+           a ="徦学如磨刀之石";
+           System.out.println(a);
+           a ="不见其损，年有所亏";
+           System.out.println(a);
+           a ="加油吧！少年";
+           System.out.println(a);
+           char b = 'J';
+           System.out.println(b);
+           b = 'A';
+           System.out.println(b);
+           b = 'V';
+           System.out.println(b);
+           b = 'A';
+           System.out.println(b);
+           b = '!';
+           System.out.println(b);
+       }
+   }
+   ```
+
+   
+
+
+
+## 3、按步骤编写代码，效果如图所示：
+
+![](Java基础语法图片/3.jpg)
+
+- 编写步骤：
+
+  1. 定义类 Homework3
+  2. 定义 main方法
+  3. 控制台输出所有布尔类型常量值
+
+## 4、按步骤编写代码，效果如图所示：
+
+![](Java基础语法图片/4.jpg)
+
+- 编写步骤：
+
+  1. 定义类 Homework4
+  
+  2. 定义 main方法
+  
+  3. 定义2个 byte类型变量,分别赋byte类型范围内最大值和最小值,并输出在控制台.
+  
+  4. 定义2个 short类型变量,分别赋short类型范围内的值,并输出在控制台.
+  
+  5. 定义2个 int类型变量,分别赋int类型范围内的值,并输出在控制台.
+  
+  6. 定义2个 long类型变量,分别赋超过int类型范围的值,并输出在控制台.
+  
+     ```java
+     public class Homework4 {
+         public static void main(String[] args) {
+          byte a = -128;
+          byte b = 127;
+             System.out.println(a);
+             System.out.println(b);
+             short c = -32768;
+             short d = 32767;
+             System.out.println(c);
+             System.out.println(d);
+             int e = -2147483648;
+             int f =2147483647;
+             System.out.println(e);
+             System.out.println(f);
+             long g = Long.parseLong("-2147483649");
+             long q = Long.parseLong("2147483648");
+             System.out.println(g);
+     ```
+  
+     
+
+## 5、按步骤编写代码，效果如图所示：
+
+![](Java基础语法图片/5.jpg)
+
+
+
+* 编写步骤：
+  1. 定义类Homework5
+  
+  2. 定义 main方法
+  
+  3. 定义2个 float类型变量,分别赋值,并输出在控制台.
+  
+  4. 定义2个 double类型变量,分别赋值,并输出在控制台.
+  
+     ```java
+     public class Homework5 {
+         public static void main(String[] args) {
+           float a = -3.14F;
+             System.out.println(a);
+             a = 3.14F;
+             System.out.println(a);
+             double b = -3.4;
+             System.out.println(b);
+             b = 3.4;
+             System.out.println(b);
+         }
+     }
+     ```
+  
+     
+
+## 6、交换两个变量的值
+
+编写步骤：
+
+1. 定义类Homework6
+2. 定义 main方法
+3. 定义两个整数变量a，b并赋值
+4. 控制台输出变量a，b互换前的值
+5. 定义一个第三方变量temp
+6. 利用第三方变量temp使a，b的值互换
+7. 控制台输出变量a，b互换后的值
+
+![image-20211219152628406](Java基础语法图片/image-20211219152628406.png)
+
+```java
+public class Homework6 {
+    public static void main(String[] args) {
+        int a = 10;
+        int b =20;
+        int temp;
+          temp = a;
+          a = b ;
+          b = temp;
+        System.out.println(a);
+        System.out.println(b);
+    }
+}
+```
+
+
+
+## 7、按步骤编写代码，效果如图所示：
+
+![](Java基础语法图片/8.png)
+
+
+
+* 开发提示：四则运算的符号
+
+  ```java
+  加: +
+  减: -
+  乘: *
+  除: /
+  ```
+
+* 编写步骤：
+
+  1. 定义类 Homework7
+  
+  2. 定义 main方法
+  
+  3. 定义2个int类型变量x、y，x赋值为100，y赋值为200
+  
+  4. 定义新变量add，保存变量x，y的和并打印到控制台
+  
+  5. 定义新变量sub，保存变量x，y的差并打印到控制台
+  
+  6. 定义新变量mul，保存变量x，y的积并打印到控制台
+  
+  7. 定义新变量div，保存变量x，y的商并打印到控制台
+  
+     ```java
+     public class Homework7 {
+         public static void main(String[] args) {
+             int x = 100,y = 200;
+             int add = x+y;
+             System.out.println("x,y的和为："+add);
+             int sub = x-y;
+             System.out.println("x,y的差为："+sub);
+             int mul = x*y;
+             System.out.println("x,y的积为："+mul);
+             int div = x/y;
+             System.out.println("x,y的商为："+div);
+         }
+     }
+     ```
+  
+     
+
+## 8、按步骤编写代码，效果如图所示：
+
+![](Java基础语法图片/9.png)
+
+- 开发提示：四则运算的符号
+
+  ```java
+  加: +
+  减: -
+  乘: *
+  除: /
+  ```
+
+- 编写步骤：
+
+  1. 定义类 Homework8
+  
+  2. 定义 main方法
+  
+  3. 定义2个double类型变量x、y，x赋值为100.8，y赋值为20.6
+  
+  4. 定义新变量add，保存变量x，y的和并打印到控制台
+  
+  5. 定义新变量sub，保存变量x，y的差并打印到控制台
+  
+  6. 定义新变量mul，保存变量x，y的积并打印到控制台
+  
+  7. 定义新变量div，保存变量x，y的商并打印到控制台
+  
+     ```java
+     public class Homework8 {
+         public static void main(String[] args) {
+             double x =100.8,y=20.6;
+             double add = x+y;
+             System.out.println("x,y的和为："+ add);
+             double sub = x-y;
+             System.out.println("x,y的差为："+sub);
+             double mul = x*y;
+             System.out.println("x,y的积为："+mul);
+             double div = x/y;
+             System.out.println("x,y的商为："+div);
+         }
+     }
+     ```
+  
+     
+
+## 9、简答题
+
+（1）Java的基本数据类型有哪些？String是基本数据类型吗？
+
+```java
+Java的基本数据类型有：byte,short,int,long,float,double,char,boolean
+        String不是基本数据类型
+```
+
+（2）float f=3.4;是否正确，表达式15/2*2的值是多少
+
+```java
+float f=3.4; //错误，因为3.4默认是double类型
+        System.out.println(15/2*2); //14，因为15/2结果是7
+```
+
+（3）char型变量中是否可以存储一个汉字？
+
+```
+可以
+```
+
diff --git "a/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/1.jpg" "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/1.jpg"
new file mode 100644
index 0000000000000000000000000000000000000000..423133fa81e8b9afde6adc5463fd13cb37561d75
Binary files /dev/null and "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/1.jpg" differ
diff --git "a/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/3.jpg" "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/3.jpg"
new file mode 100644
index 0000000000000000000000000000000000000000..eb087a34bd41aeb943002840a1e2acab120020d7
Binary files /dev/null and "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/3.jpg" differ
diff --git "a/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/4.jpg" "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/4.jpg"
new file mode 100644
index 0000000000000000000000000000000000000000..cbd6ca85c4f7e038bad866015951fe41e336cfc2
Binary files /dev/null and "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/4.jpg" differ
diff --git "a/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/5.jpg" "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/5.jpg"
new file mode 100644
index 0000000000000000000000000000000000000000..ec57819bb9a5ea35428f5c01a7f419c6926be435
Binary files /dev/null and "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/5.jpg" differ
diff --git "a/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/8.png" "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/8.png"
new file mode 100644
index 0000000000000000000000000000000000000000..91e2739b2361cec8f1d8e82816d3b9597e2ba37d
Binary files /dev/null and "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/8.png" differ
diff --git "a/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/9.png" "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/9.png"
new file mode 100644
index 0000000000000000000000000000000000000000..418632bbc6be9bbd79d8b8265c557ce911fee5d4
Binary files /dev/null and "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/9.png" differ
diff --git "a/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/image-20211219152628406.png" "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/image-20211219152628406.png"
new file mode 100644
index 0000000000000000000000000000000000000000..72a6ca6e2ef8999d5e1d71161a4ef8ceb3b2c65b
Binary files /dev/null and "b/09 \346\241\202\346\263\275\347\205\234/java\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\345\233\276\347\211\207/image-20211219152628406.png" differ
diff --git "a/09 \346\241\202\346\263\275\347\205\234/\346\257\217\346\227\245\344\275\234\344\270\232-\350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md" "b/09 \346\241\202\346\263\275\347\205\234/\346\257\217\346\227\245\344\275\234\344\270\232-\350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ccde795ca70323a334c652779d7d2d2141ec144e
--- /dev/null
+++ "b/09 \346\241\202\346\263\275\347\205\234/\346\257\217\346\227\245\344\275\234\344\270\232-\350\277\220\347\256\227\347\254\246\344\275\234\344\270\232.md"	
@@ -0,0 +1,178 @@
+**1、判断一个字符数据是否是数字字符 **
+
+**分析：**
+
+​	1、需要判断一个字符是否是数字字符，首先需要提供一个字符数据
+
+​	2、字符是否为数字字符： 数字字符的范围 0 - 9 之间都属于数字字符，因此提供的字符只要大于或等于字符0，并且还要小于或等于字符9即可。
+
+​	3、判断完成之后，打印判断的结果。
+
+```java
+package org.example;
+
+import java.util.Random;
+
+public class hjgh {
+    public static void main(String[] args) {
+     Random random = new Random();
+     int a = random.nextInt(10);
+        System.out.println(a);
+        if(a>=0 && a<=9){
+            System.out.println("这是数字字符");
+        }
+    }
+}
+```
+
+
+
+**2、判断一个字符数据是否是字母字符** 
+
+**分析：**
+
+​	1、需要判断一个字符是否是字母字符，首先需要提供一个字符数据
+
+​	2、字符是否为字母字符： 数字字符的范围 a - z 或者 A - Z 之间都属于字母字符，因此提供的字符只要大于或等于a，并且还要小于或等于z 或者 大于或等于A，并且还要下于或等于Z
+
+​	3、判断完成之后，打印判断的结果。
+
+```java
+import java.util.Scanner;
+
+public class bnnm {
+    public static void main(String[] args) {
+        start();
+    }
+     static void start(){
+        Scanner scanner = new Scanner(System.in);
+         System.out.println("请输入一个字符");
+        int sj = scanner.next().charAt(0);
+        if((sj >='a' && sj <='z') ||(sj >='A' && sj<='Z')){
+            System.out.println("这是字母字符");
+        }
+        else{
+            System.out.println("这不是字母字符");
+        }
+     }
+}
+```
+
+
+
+**3、判断指定的年份是否为闰年，请使用键盘录入** 
+
+**分析：**
+
+​	1、闰年的判断公式为：能被4整除，但是不能被100整除 或者 能被400整除
+
+​	2、首先需要提供一个需要判断的年份，判断完成之后，打印判断的结果。
+
+```java
+package org.example;
+
+import java.util.Scanner;
+
+public class jkfh {
+    public static void main(String[] args) {
+        year();
+    }
+    public static void year(){
+        Scanner scanner = new Scanner(System.in);
+        System.out.println("请输入年份");
+        int a = scanner.nextInt();
+        if(a%4 == 0 ||(a%100 == 0 && a%400 == 0)){
+            System.out.println("这是闰年");
+        }
+        else
+        {
+            System.out.println("这是平年");
+        }
+    }
+}
+```
+
+
+
+**4、判断一个数字是否为水仙花数,请使用键盘录入**
+
+水仙花是指3位数字，表示的是每位上的数字的3次幂相加之后的和值和原数相等，则为水仙花数，
+
+**分析：**
+
+​	如：153  --->  1×1×*1 + 5*×5×*5 + 3×*3×3 = 153; 就是水仙花数
+
+​		1、首先需要提供一个需要判断的3位数字，因此需要一个数值
+
+​		2、判断的过程 
+
+​			a) 将3位数字的每一位上的数字拆分下来 
+
+​			b) 计算每位数字的3次幂之和
+
+​			C) 用和值 和 原来的数字进行比较 
+
+​		D) 打印判断的比较结果即可
+
+```java
+public class fdfvd {
+    public static void main(String[] args) {
+        worter();
+    }
+
+    public static void worter() {
+        for (int i = 100; i < 1000; i++) {
+            int a , b, c, d;
+            a = i / 100;
+            b = i / 10 % 10;
+            c = i % 10;
+            d = a*a*a+b*b*b+c*c*c;
+            if(d==i){
+                System.out.println(d+"是水仙花数");
+            }
+        }
+    }
+}
+```
+
+
+
+**5、判断一个5位数字是否为回文数，使用键盘录入** 
+
+五位数的回文数是指最高位和最低位相等，次高位和次低位相等。如：12321  23732  56665 
+
+**分析：**
+
+​	1、首先需要提供一个需要判断的5位数字，因此需要一个数值
+
+​	2、判断的过程 
+
+​		a) 将5位数字的万、千、十、个位数拆分出来
+
+​		b) 判断比较万位和个位 、 千位和十位是否相等
+
+​	3、判断完成之后，打印判断的结果。
+
+```java
+import java.util.Scanner;
+
+public class jhj {
+    public static void main(String[] args) {
+        hws();
+    }
+    public static void hws(){
+Scanner scanner = new Scanner(System.in);
+        System.out.println("请输入一个五位数");
+           int a[] = new int[]{scanner.nextInt()};
+          if(a[0]%10 == a[0]/10000){
+              System.out.println("这是回文数");
+          }
+          else{
+              System.out.println("这不是回文数");
+          }
+         }
+    }
+```
+
+
+
diff --git "a/09 \346\241\202\346\263\275\347\205\234/\347\214\234\346\225\260\345\255\227.md" "b/09 \346\241\202\346\263\275\347\205\234/\347\214\234\346\225\260\345\255\227.md"
new file mode 100644
index 0000000000000000000000000000000000000000..b3fabe653d8e4e276e755165654e0f5c89bc4f0a
--- /dev/null
+++ "b/09 \346\241\202\346\263\275\347\205\234/\347\214\234\346\225\260\345\255\227.md"	
@@ -0,0 +1,39 @@
+```java
+import javax.swing.*;
+import java.awt.*;
+import java.util.Scanner;
+
+import static java.lang.System.exit;
+
+public class jkjdk {
+    static Scanner scanner = new Scanner(System.in);
+
+    public static void main(String[] args) throws InterruptedException {
+        JFrame jFrame = new JFrame();
+        jFrame.add(start());
+    }
+
+    static Component start() throws InterruptedException {
+        while (true) {
+            Thread.currentThread().sleep(1000);
+            System.out.println("请输入一个数");
+              pd();
+            }
+        }
+
+    static void pd() {
+        int d = scanner.nextInt();
+        int c = 75;
+        if (d == c) {
+            System.out.println("你猜对了");
+            exit(0);
+        } else if (d > c) {
+            System.out.println("你猜大了");
+        } else {
+            System.out.println("你猜小了");
+        }
+
+    }
+}
+```
+
diff --git "a/09 \346\241\202\346\263\275\347\205\234/\350\257\276\345\220\216\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\346\211\251\345\261\225\344\275\234\344\270\232.md" "b/09 \346\241\202\346\263\275\347\205\234/\350\257\276\345\220\216\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\346\211\251\345\261\225\344\275\234\344\270\232.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c21551c31edaf1c118c5cc944f4765a0b898b77a
--- /dev/null
+++ "b/09 \346\241\202\346\263\275\347\205\234/\350\257\276\345\220\216\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\346\211\251\345\261\225\344\275\234\344\270\232.md"	
@@ -0,0 +1,320 @@
+# 巩固题
+
+## 1、强制类型转换练习
+
+（1）先声明两个byte类型的变量b1,b2,并分别赋值为10和20，求b1和b2变量的和，并将结果保存在byte类型的变量b3中，最后输出b3变量的值
+
+（2）先声明两个short类型的变量s1,s2,并分别赋值为1000和2000，求s1和s2变量的和，并将结果保存在short类型的变量s3中，最后输出s3变量的值
+
+（3）先声明1个char类型的变量c1赋值为'a'，再声明一个int类型的变量num赋值为5，求c1和num变量的和，并将结果将结果保存在char类型的变量letter中，最后输出letter变量的值。
+
+（4）先声明两个int类型的变量i1,i2，并分别赋值5和2，求i1和i2的商，并将结果保存在double类型的变量result中，最后输出result变量的值。如何得到结果2.5呢？
+
+![image-20211219161207200](Java基础语法扩展作业图片/image-20211219161207200.png)
+
+```java
+public class gh {
+    public static void main(String[] args) {
+        start();
+        sum();
+        num();
+        s();
+    }
+    static void start(){
+        byte b1 = 10,b2 = 20;
+        byte b3 = (byte)(b1+b2);
+        System.out.println("byte类型的b1和b2的和为："+b3);
+    }
+    static void sum(){
+        short s1 = 1000,s2 = 2000;
+        short s3 = (short) (s1+s2);
+        System.out.println("shore类型的s1和s2的和为："+s3);
+    }
+    static void num(){
+        char c1 = 'a';
+        int num = 5;
+        char letter = (char) (c1 + num);
+        System.out.println("char类型的c1和int类型的num的和："+letter);
+    }
+    static void s(){
+        int i1 = 5,i2 = 2;
+        double result = (double) i1 / i2;
+        System.out.println("int类型的i1和i2的商是："+result);
+    }
+}
+```
+
+
+
+## 2、按步骤编写代码，效果如图所示：
+
+![](Java基础语法扩展作业图片/4.jpg)
+
+1. 定义两个int类型变量a1和a2,分别赋值10,11,判断变量是否为偶数,拼接输出结果
+2. 定义两个int类型变量a3和a4,分别赋值12,13,判断变量是否为奇数,拼接输出结果
+
+```java
+public class fj {
+    public static void main(String[] args) {
+        start();
+        sum();
+    }
+    static void start(){
+        int a1 = 10,a2 =11;
+        if(a1%2 ==1 & a2%2==1){
+            System.out.println(a1+"是奇数？");
+            System.out.println(a1%2 ==1?true:false);
+            System.out.println(a2+"是奇数？");
+            System.out.println(a2%2 ==1?true:false);
+        }
+        else{
+            System.out.print(a1+"是偶数？");
+            System.out.println(a1%2 ==0?true:false);
+            System.out.print(a2+"是偶数");
+            System.out.println(a2%2 ==0?true:false);
+        }
+    }
+    static void sum() {
+        int a3 = 12, a4 = 13;
+        if (a3 % 2 == 0 & a4 % 2 == 0) {
+            System.out.print(a3 + "是偶数？");
+            System.out.println(a3%2 ==0?true:false);
+            System.out.print(a4 + "是偶数？");
+            System.out.println(a3%2 ==0?true:false);
+        }else{
+            System.out.print(a3+"是奇数？");
+            System.out.println(a3%2 ==1?true:false);
+            System.out.print(a4+"是奇数？");
+            System.out.println(a4%2 ==1?true:false);
+        }
+    }
+}
+```
+
+
+
+## 3、计算时间
+
+案例：为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？
+
+![1557879127503](Java基础语法扩展作业图片/6.png)
+
+1. 定义一个int类型变量hours，赋值为89
+2. 定义一个int类型变量day，用来保存89小时中天数的结果
+3. 定义一个int类型变量hour，用来保存89小时中不够一天的剩余小时数的结果
+4. 输出结果
+
+```java
+public class jkf {
+    public static void main(String[] args) {
+        start();
+    }
+    static void start(){
+       int hours = 89,day = hours/24,hour=hours%24;
+        System.out.println("为抵抗洪水，战士连续作战"+hours+"小时\n:"+hours+"是"+day+"天"+hour+"小时");
+    }
+}
+```
+
+
+
+
+
+## 4、案例：今天是周2，100天以后是周几？
+
+![1557879464870](Java基础语法扩展作业图片/7.png)
+
+1. 定义一个int类型变量week，赋值为2
+2. 修改week的值，在原值基础上加上100
+3. 修改week的值，在原值基础上模以7
+4. 输出结果，在输出结果的时候考虑特殊值，例如周日
+
+```java
+public class jhkh {
+    public static void main(String[] args) {
+        start();
+    }
+    static void start(){
+       int today = 2;
+        System.out.print("今天是周"+today);
+        int after =100;
+        System.out.print(","+after+"天以后是");
+        int fin  =(after-(7-today))%7;
+        System.out.println("周"+fin);
+    }
+}
+```
+
+
+
+
+
+## 5、案例：求三个整数x,y,z中的最大值
+
+![1557879847378](Java基础语法扩展作业图片/8.png)
+
+1. 定义三个int类型变量,x,y,z，随意赋值整数值
+2. 定义一个int类型变量max，先存储x与y中的最大值（使用三元运算符）
+3. 再次对max赋值，让它等于上面max与z中的最大值（使用三元运算符）
+4. 输出结果
+
+```java
+public class jhk {
+    public static void main(String[] args) {
+        start();
+    }
+    static void start(){
+        int x=3,y=4,z=1;
+        System.out.print(x+","+y+","+z+"中的");
+          if(x>y & x>z) {
+              System.out.print("最大值是: "+x);
+          }
+          if(y>x & y>z){
+              System.out.print("最大值是: "+y);
+          }
+          if(z>x & z>y){
+              System.out.print("最大值是: "+z);
+          }
+    }
+}
+```
+
+
+
+## 6、案例：判断今年是否是闰年
+
+闰年的判断标准是：
+
+​       1）可以被4整除，但不可被100整除
+
+​       2）可以被400整除
+
+![1557902649882](Java基础语法扩展作业图片/9.png)
+
+1. 定义一个int类型变量year，赋值为今年年份值
+2. 定一个一个boolean类型变量，用来保存这个年份是否是闰年的结果
+3. 输出结果
+
+```java
+
+public class jhklbjhk {
+    public static void main(String[] args) {
+        start();
+    }
+    static void start(){
+        int year = 2018;
+        if(year%4 == 0 ||(year%100!=0 && year%400 ==0)){
+            System.out.println(year+"是闰年");
+        }else{
+            System.out.println(year+"不是闰年");
+        }
+    }
+}
+
+```
+
+
+
+## 7、华氏度转摄氏度
+
+案例：小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。它需要一个程序将华氏温度（80度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。
+
+![1557903785834](Java基础语法扩展作业图片/1557903785834.png)
+
+![1557903814057](Java基础语法扩展作业图片/1557903814057.png)
+
+1. 定义一个double类型变量hua，存储华氏温度80
+2. 定义一个double类型变量she，存储摄氏温度，根据公式求值
+3. 输出结果
+
+```java
+public class jhkhgvh {
+    public static void main(String[] args) {
+        start();
+    }
+    static void start(){
+        double hua = 80;
+        double she = (80-32)/1.8;
+        System.out.println("华氏度"+hua+"°F转为摄氏度是"+she+"°C");
+    }
+}
+```
+
+
+
+
+
+# 拔高题
+
+## 第一题
+
+```java
+如下代码的计算结果是：
+int i = 1;
+i *= 0.2;  
+i++;
+System.out.println("i=" + i);
+答：i =1
+```
+
+## 第二题
+
+```java
+如下代码的运算结果是：
+int i = 2;
+i *= i++;
+
+int j = 2;
+j *= j+1; 
+
+int k = 2;
+k *= ++k;
+
+System.out.println("i=" + i);
+System.out.println("j=" + j);
+System.out.println("k=" + k);
+答：i=4
+   j=6
+   k=6
+```
+
+## 第三题
+
+```java
+如下代码的运算结果是：
+int a = 3;
+int b = 1;
+if(a == b){
+	System.out.println("Equal");
+}else{
+	System.out.println("Not Equal");
+}
+答：Not Equal
+```
+
+## 第四题
+
+```java
+如下代码的运算结果是：
+int a = 8, b = 3;
+System.out.println(a>>>b);
+System.out.println(a>>>b | 2);
+答：1
+   3
+ 
+```
+
+## 第五题
+
+如何用最有效的的方法计算2乘以8
+
+```java
+public class ghjh {
+    public static void main(String[] args) {
+        int a = 2;
+        int b =2*8;
+        System.out.println(b);
+        }
+    }
+```
+
diff --git "a/09 \346\241\202\346\263\275\347\205\234/\350\257\276\345\220\216\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\346\211\251\345\261\225\344\275\234\344\270\232\345\233\276\347\211\207/1557903785834.png" "b/09 \346\241\202\346\263\275\347\205\234/\350\257\276\345\220\216\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\346\211\251\345\261\225\344\275\234\344\270\232\345\233\276\347\211\207/1557903785834.png"
new file mode 100644
index 0000000000000000000000000000000000000000..b6bbaaa0e88e03bcec507a1f89560a260f903f75
Binary files /dev/null and "b/09 \346\241\202\346\263\275\347\205\234/\350\257\276\345\220\216\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\346\211\251\345\261\225\344\275\234\344\270\232\345\233\276\347\211\207/1557903785834.png" differ
diff --git "a/09 \346\241\202\346\263\275\347\205\234/\350\257\276\345\220\216\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\346\211\251\345\261\225\344\275\234\344\270\232\345\233\276\347\211\207/1557903814057.png" "b/09 \346\241\202\346\263\275\347\205\234/\350\257\276\345\220\216\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\346\211\251\345\261\225\344\275\234\344\270\232\345\233\276\347\211\207/1557903814057.png"
new file mode 100644
index 0000000000000000000000000000000000000000..a174d3c8f4b22f02bfef4174a7fb7e71bab58e88
Binary files /dev/null and "b/09 \346\241\202\346\263\275\347\205\234/\350\257\276\345\220\216\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\346\211\251\345\261\225\344\275\234\344\270\232\345\233\276\347\211\207/1557903814057.png" differ
diff --git "a/09 \346\241\202\346\263\275\347\205\234/\350\257\276\345\220\216\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\346\211\251\345\261\225\344\275\234\344\270\232\345\233\276\347\211\207/4.jpg" "b/09 \346\241\202\346\263\275\347\205\234/\350\257\276\345\220\216\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\346\211\251\345\261\225\344\275\234\344\270\232\345\233\276\347\211\207/4.jpg"
new file mode 100644
index 0000000000000000000000000000000000000000..93807a26b91abfd2dec2796ba08443c05fa444ae
Binary files /dev/null and "b/09 \346\241\202\346\263\275\347\205\234/\350\257\276\345\220\216\344\275\234\344\270\232/Java\345\237\272\347\241\200\350\257\255\346\263\225\346\211\251\345\261\225\344\275\234\344\270\232\345\233\276\347\211\207/4.jpg" differ
diff --git "a/09 \346\241\202\346\263\275\347\205\234/\351\242\230\347\233\2561.md" "b/09 \346\241\202\346\263\275\347\205\234/\351\242\230\347\233\2561.md"
new file mode 100644
index 0000000000000000000000000000000000000000..a837e3a5ea5c51bc64fc8e69a441e43e601f8a1d
--- /dev/null
+++ "b/09 \346\241\202\346\263\275\347\205\234/\351\242\230\347\233\2561.md"	
@@ -0,0 +1,197 @@
+switch判断语句
+
+## 题目1
+
+模拟计算器功能，对键盘录入的两个int类型的数据进行加、减、乘、除的运算，并打印运算结果。
+
+要求：
+
+​	键盘录入三个整数,其中前两个整数代表参加运算的数据，第三个整数为要进行的运算(1:表示加法运算,2:表示减法运算,3:表示乘法运算,4:表示除法运算)，演示效果如下:
+
+​		请输入第一个整数: 30
+
+​		请输入第二个整数: 40
+
+​		请输入您要进行的运算(1:表示加法,2:表示减法,3:表示乘法,4:表示除法): 1
+
+​		控制台输出:30+40=70
+
+### 训练提示
+
+1. 用户录入了数据之后，用什么知识点去判断加减乘除四种不同的操作？ 
+
+### 解题方案
+
+1. 使用switch判断语句完成。
+
+### 操作步骤
+
+1. 使用键盘录入三个变量。
+2. 使用switch判断语句对第三个变量进行判断，匹配要执行的操作。
+3. 在每一个case中分别对第一个变量和第二个变量进行不同的操作。
+
+```java
+import java.util.Scanner;
+
+public class fbv {
+    public static void main(String[] args) {
+        start();
+    }
+    static void start(){
+        Scanner scanner = new Scanner(System.in);
+        System.out.println("请输入第一个整数");
+        int a = scanner.nextInt();
+        System.out.println("请输入第二个整数");
+        int b = scanner.nextInt();
+        System.out.println("请输入您想要进行的运算");
+        int c = scanner.nextInt();
+        switch(c){
+            case 1:
+                System.out.println(a+"+"+b+"="+(a+b));
+            break;
+            case 2:
+                System.out.println(a+"-"+b+"="+(a-b));
+                break;
+            case 3:
+                System.out.println(a+"*"+b+"="+a*b);
+                break;
+            case 4:
+                System.out.println(a+"/"+b+"="+a/b);
+            break;
+        }
+    }
+}
+```
+
+
+
+if判断语句
+
+## 题目2（训练）
+
+李雷想买一个价值7988元的新手机，她的旧手机在二手市场能卖1500元，而手机专卖店推出以旧换新的优惠，把她的旧手机交给店家，新手机就能够打8折优惠。为了更省钱，李雷要不要以旧换新？请在控制台输出。
+
+### 训练提示
+
+1. 用什么知识点能够对不同购买方式的价格做判断？
+
+### 解题方案
+
+1. 使用if...else语句判断
+
+### 操作步骤
+
+1. 计算不使用以旧换新时的花费。
+2. 计算使用以旧换新时的花费。
+3. 使用if..else语句判断哪种方式更省钱，并输出结果
+
+```java
+public class dfcvg {
+    public static void main(String[] args) {
+        start();
+    }
+    static void start() {
+        int now = 7988;
+        int b = 1500;
+        int a = 0;
+        int  c =(int) (now * 0.8);
+        if (true) {
+            a = now - b;
+            System.out.println("方案一:如果不使用依旧换新需要花费" + a + "元");
+        }
+        if (true) {
+            System.out.println("方案二:如果以旧换新需要花费" + c + "元");
+        }
+        if (a >c) {
+            System.out.println("方案二省钱");
+        }
+        else{
+            System.out.println("方案一省钱");
+        }
+    }
+}
+```
+
+
+
+循环语句
+
+## 题目3(训练)
+
+已知2019年是猪年，请在控制台输出从1949年到2019年中所有是猪年的年份。
+
+### 训练提示
+
+1. 1949到2019有很多年？逐个判断这么多年份肯定要用循环。
+2. 用什么条件来判断是否是猪年？
+
+### 解题方案
+
+1. 使用for循环逐年判断，根据2019是猪年这个条件，使用if来判断其他是猪年的年份。
+
+### 操作步骤
+
+1. 定义for循环，1949到2019的年份是循环次数。
+2. 对每个年份逐个判断，如果年份和2019的差值是12的倍数，说明这年是猪年
+3. 打印符合条件的年份
+
+```java
+public class dfg {
+    public static void main(String[] args) {
+        start();
+    }
+    static void start(){
+        for(int i = 1949; i <=2019;i++){
+        if(i % 12 == 3){
+            System.out.println(i+"这年是猪年");
+        }
+    }
+    }
+}
+```
+
+
+
+
+
+## 题目4(训练)
+
+有一个输出语句System.out.print("@")。使用这个语句，在控制台打印出一个五行的三角形，效果如下：
+​	@
+​	@@
+​	@@@
+​	@@@@
+​	@@@@@
+
+### 训练提示
+
+1. 已知条件中只有一个@,如何产生多行的符号？
+2. 每行的打印个数不同，循环的次数如何控制？
+
+### 解题方案
+
+1. 使用for循环的嵌套完成。
+
+### 操作步骤
+
+1. 定义循环执行5次代表一共5行
+2. 定义内层循环执行i次代表每行打印的个数是i
+3. 在内层循环中输出符号
+4. 每行结束之后执行换行操作
+
+```java
+public class dgfdg {
+    public static void main(String[] args) {
+        start();
+    }
+    static void start() {
+        for (int i = 1; i <= 5; i++) {
+            for (int j = 1; j <= i; j++) {
+                System.out.print("@");
+            }
+            System.out.println();
+        }
+    }
+    }
+```
+