day10-java中接口与接口之间的多继承关系

day02/src/com/inmind/Demo11.java

@@ -0,0 +1,30 @@
+package com.inmind;
+/*
+
+三元运算符格式：
+	数据类型 变量名 = 表达式1？表达式2：表达式3;
+
+三元运算符的执行解析：
+	先执行表达式1，结果必须是布尔值（true，false）
+	如果表达式1的结果是true，那么就将表达式2作为运算结果返回
+	如果表达式1的结果是false，那么就将表达式3作为运算结果返回
+
+	注意：数据类型与表达式2：表达式3必须一致
+ */
+public class Demo11 {
+    public static void main(String[] args) {
+        //使用三元运算符，进行判断哪个值大
+        //定义2个整数变量
+        int a = 10;
+        int b = 20;
+
+        //判断a或者b谁大？？
+        int max = a<b?b:a;
+        String str = "这是字符串"+b;
+        System.out.println(max);//20
+        //判断下哪个变量名的值大？(表示出：“变量b的值大”)
+
+        String result = a>b?"变量a的值大:"+a:"变量b的值大:"+b;
+        System.out.println(result);
+    }
+}

day02/src/com/inmind/Demo12_Method.java

@@ -0,0 +1,52 @@
+package com.inmind;
+/*
+方法:就是将对应的java语句封装成单独的一个功能
+作用：当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。
+注意：
+	1.不调用不执行
+	2.方法必须定义在类中方法外，方法中不能再定义方法
+------------------------------------------------------------------
+java中方法的定义格式
+方法修饰符 返回值类型	方法名()
+{
+
+}
+
+1.方法修饰符：public static （固定，照抄）
+2.返回值类型：方法的返回值的数据类型，void表示没有返回值类型（固定，照抄void）
+3.方法名：标识符中的一种，符合软性规范：符合小驼峰命名方式 addMethod
+4.():方法参数，参数可以写0或多个（固定，什么都不写：没有参数）
+5.{java代码}：方法体，就是java语句的集合，也就是方法被调用后，要执行的java代码！！！
+
+调用格式：方法名(方法参数);
+*/
+public class Demo12_Method {
+    public static void main(String[] args) {
+        //调用加法功能的方法
+        addMethod();
+        //调用减法的方法
+        jfMethod();
+    }
+
+    //需求：定义一个无参无返回值的，封装了三元运算符，判断i,j哪个变量小的结果，并打印sout，最后在主方法中调用
+    public static void jfMethod() {
+        int a = 20;
+        int b = 30;
+
+        int result = a > b? b:a;
+        System.out.println(result);
+    }
+
+    //类中方法外
+    //需求：将加法的功能封装成一个方法，随时调用
+    public static void addMethod() {
+        //加法运行
+        int a = 10;
+        int b = 20;
+        int c = a+b;
+        System.out.println(c);
+    }
+
+
+
+}

day03/day03.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="17" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

day03/src/com/inmind/Demo01_if.java

@@ -0,0 +1,150 @@
+package com.inmind;
+/*
+if格式一：
+
+if(判断条件){
+	语句；
+}
+
+执行顺序：先执行判断条件，判断条件必须是布尔型的结果，
+			如果为true，就执行大括号内部的语句，false就直接跳过大括号中的内容
+
+----------------------------------------------------------------
+
+if格式二：
+if(判断条件){
+	语句1；
+}else{
+	语句2；
+}
+
+执行顺序:先执行判断条件，判断条件必须是布尔型的结果，
+		如果为true，就执行大括号语句1，这时else就不执行，
+		如果为false就直接跳过if后面大括号中的语句1直接执行else后面的语句2
+
+注意：格式二，语句1或语句2肯定会执行一个，但是也永远都只会执行一个
+
+在某种简单的逻辑之下，三元运算符可以跟if-else互换，但是在开发中if-else的使用场景更广
+----------------------------------------------------------------------
+
+
+if格式三：
+if(判断条件1){
+	语句1；
+}else if(判断条件2){
+	语句2；
+}else if(判断条件3){
+	语句3；
+}....
+else{
+	语句n;
+}
+
+执行顺序:先执行判断条件1，判断条件必须是布尔型的结果，
+		如果为true，就执行大括号语句1，这时结束了整个if语句，
+		如果为false就直接跳过if后面大括号中的语句1继续向下判断判断条件2
+			如果为true，就执行大括号语句2，这时结束了整个if语句
+			如果为false就直接跳过if后面大括号中的语句2继续向下判断....
+				最终如果所有的判断条件都为false，那么就直接执行else后面的语句n
+
+注意：格式三，肯定会执行一个语句，但是也永远都只会执行一个语句；
+
+*/
+public class Demo01_if {
+    //if的格式三的练习
+    public static void main(String[] args) {
+        int score =77;
+        if(score<0 || score>100){
+            System.out.println("你的成绩是错误的");
+        }else if(score>=90 && score<=100){
+            System.out.println("你的成绩属于优秀");
+        }else if(score>=80 && score<90){
+            System.out.println("你的成绩属于好");
+        }else if(score>=70 && score<80){
+            System.out.println("你的成绩属于良");
+        }else if(score>=60 && score<70){
+            System.out.println("你的成绩属于及格");
+        }else {
+            System.out.println("你的成绩属于不及格");
+        }
+    }
+
+    //if的格式三
+    public static void ifMethod3(String[] args) {
+        // x和y的关系满足如下：
+        // x>=3 y = 2x + 1;
+        //-1<=x<3 y = 2x;
+        // x<-1 y = 2x – 1;
+        // 根据给定的x的值，计算出y的值并输出。
+        int x = -2;
+        int y;
+        if (x >= 3) {
+            y = 2*x + 1;
+        } else if (x>=-1 && x<3) {
+            y = 2*x;
+        } else {
+            y = 2*x-1;
+        }
+
+        System.out.println(y);
+
+    }
+
+    //if格式二的练习
+    public static void ifDemo2() {
+        //判断给定的整数是奇数还是偶数（if-else）
+        int i = 20;
+        //分析：奇数：%2余数为1；反之为偶数
+        if (i % 2 == 1) {
+            System.out.println("变量i的值" + i + "为奇数");
+            //ctrl+D:复制一行
+        } else {
+            System.out.println("变量i的值" + i + "为偶数");
+            //ctrl+shift+上下，代码上下移动
+        }
+        System.out.println("程序结束");
+    }
+
+
+    //if的格式二
+    public static void ifMethod2() {
+        //判断2个值谁大
+        int a = 30;
+        int b = 20;
+        if (a > b) {
+            System.out.println("a的值大：" + a);
+        } else {
+            System.out.println("b的值大："+b);
+        }
+        System.out.println("程序结束");
+
+        //使用三元运算符来实现
+        String str = a>b?"a大":"b大";
+        System.out.println(str);
+    }
+
+
+    //if的格式一
+    public static void ifMethod1(String[] args) {
+        //判断下变量对应的值
+        int i = 12;
+        if (i!=10){
+            System.out.println("i不为10");
+        }
+
+        System.out.println("程序结束");
+        //判断2个值谁大，请用if判断流程来判断
+        int a = 10;
+        int b = 20;
+
+        //ctrl+shift+enter
+        if (a > b) {
+            System.out.println("a的值大："+a);
+        }
+
+        if (b > a) {
+            System.out.println("b的值大："+b);
+        }
+
+    }
+}

day03/src/com/inmind/Demo02_switch.java

@@ -0,0 +1,91 @@
+package com.inmind;
+/*
+选择流程 switch
+
+switch(表达式) {
+case 常量值1:
+语句体1;
+break;
+case 常量值2:
+语句体2;
+break;
+...
+default:
+语句体n;
+break;
+}
+
+执行顺序：先执行表达式，得到结果值，接下来将结果值与case之后的值依次比较，
+		如果结果与常量值1是一致就执行一次语句体1
+		遇到break，表示直接结束switch语句,如果所有的case都不符合，
+		就直接执行default后面的语句体n(类似于if的格式三种的else)
+
+注意：switch语句中，表达式的数据类型，可以是byte，short，int，char，enum（枚举），JDK7后可以接收字符串。
+*/
+public class Demo02_switch {
+    //case穿透的演示
+    public static void main(String[] args) {
+        //根据月份，判断季节（3~5 春天 6~8 夏天 9~11 秋天 12~2冬天）
+        int month = 12;
+        switch (month) {
+            case 3:
+                System.out.println(3);
+            case 4:
+                System.out.println(4);
+            case 5:
+                System.out.println(5);
+                System.out.println("春天");
+                break;
+            case 6:
+            case 7:
+            case 8:
+                System.out.println("夏天");
+                break;
+            case 9:
+            case 10:
+            case 11:
+                System.out.println("秋天");
+                break;
+            case 12:
+            case 1:
+            case 2:
+                System.out.println("冬天");
+                break;
+        }
+        System.out.println("程序结束");
+    }
+
+    //switch语法学习
+    public static void switchMethod() {
+        //定义变量，判断是星期几,1~7对应星期一~星期日
+        int day = 3;
+        switch (day+1) {
+            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("你给的变量值不合法，必须是1~7的值");
+                break;
+        }
+
+        System.out.println("程序结束");
+    }
+}

day03/src/com/inmind/Demo03_for.java

@@ -0,0 +1,77 @@
+package com.inmind;
+/*
+for，while，do-while 循环
+循环三要素：循环变量初始化、循环条件、修改循环变量
+
+for循环的格式：
+for(循环变量初始化①;循环条件②;修改循环变量④){
+	循环体语句③;
+}
+
+
+执行顺序：①②③④>②③④>②③④…②不满足为止。
+*/
+public class Demo03_for {
+    public static void main(String[] args) {
+        //for循环练习：使用循环，计算1-100之间的偶数和
+        /*
+        1.定义个变量用来保存总和的结果
+        2.for循环1~100，判断出所有偶数
+        3.将每个偶数相加得到结果打印
+         */
+        int sum = 0;
+        for (int i = 1; i <= 100; i++) {
+            if (i % 2 == 0) {
+                //当前i一定是偶数
+//                sum = sum+i;
+                sum+= i;
+            }
+        }
+        System.out.println("1-100之间的偶数和:"+sum);
+    }
+
+
+    //for循环练习1
+    public static void forDemo1() {
+        /*
+		打印1~10的值
+		打印10~1的值
+		打印所有的字母a-z、A-Z
+		*/
+        //打印1~10的值
+        for(int a = 1;a<=10;a++){
+            System.out.println(a);
+        }
+        System.out.println("---------------");
+        //打印10~1的值
+        for(int b = 10;b>=1;b--){
+            System.out.println(b);
+        }
+        System.out.println("---------------");
+        //打印所有的字母a-z、A-Z(注意字符在java运算时，根据ASCII码表对应的十进制的值计算)
+        //a-z 97  A-Z 65  0-9 48
+        for(int i = 97;i<=122;i++){
+            System.out.println((char) i);//4字节的int转为2字节的char
+        }
+
+        System.out.println("---------------");
+        for (int j = 'A'; j <= 'Z'; j++) {//自动类型转换
+            System.out.println((char) j);//4字节的int转为2字节的char（强制类型转换）
+//            System.out.println(j);//4字节的int转为2字节的char
+        }
+    }
+
+
+    //for循环的语法学习
+    public static void forMethod() {
+        //去跑圈，要求你跑1000圈
+        /*System.out.println("第1圈");
+        System.out.println("第2圈");
+        System.out.println("第3圈");*/
+
+        for(int i = 1;i<=3;i++){
+            System.out.println("第"+i+"圈");
+        }
+        System.out.println("程序结束");
+    }
+}

day03/src/com/inmind/Demo04_while.java

@@ -0,0 +1,57 @@
+package com.inmind;
+/*
+while循环的格式和使用
+
+循环变量初始化①
+while(循环条件②){
+	循环体语句③
+	修改循环变量④
+}
+
+执行顺序：①②③④>②③④>②③④…②不满足为止
+*/
+public class Demo04_while {
+    public static void main(String[] args) {
+        //使用while的语法，计算出1~100的偶数累和
+        //定义一个变量记录总和
+        int sum = 0;
+        //循环变量的定义
+        int i = 1;
+        while (i <= 100) {
+            //判断是否是偶数
+            if (i % 2 == 0) {
+                sum += i;
+            }
+            //修改循环变量
+            i++;
+        }
+        System.out.println("结果为："+sum);
+        System.out.println("程序结束");
+    }
+
+
+    //while循环的语法学习
+    public static void whileMethod(String[] args) {
+        //打印1~10
+        int i = 1;
+        while(i<=10){
+            System.out.println(i);
+            i++;
+        }
+        System.out.println("------------------");
+        //打印10~1
+        int j = 10;
+        while (j>=1) {
+            System.out.println(j);
+            j--;
+        }
+        System.out.println("------------------");
+
+        //打印A~Z
+        int k = 'A';
+        while (k <= 'Z') {
+            System.out.println((char)k);
+            k++;
+        }
+    }
+}

day03/src/com/inmind/Demo05_dowhile.java

@@ -0,0 +1,41 @@
+package com.inmind;
+/*
+Do_While格式和使用
+
+循环变量初始化①
+do{
+	循环体语句③
+	修改循环变量④
+}while(循环条件②);
+
+do-while上来不管怎样肯定会执行一次循环体语句
+
+执行顺序：①③④>②③④>②③④…②不满足为止。
+*/
+public class Demo05_dowhile {
+    public static void main(String[] args) {
+        //打印1~10
+        int i = 1;
+        do{
+            System.out.println(i);
+            i++;
+        }while(i<=10);
+        System.out.println("程序结束");
+
+        //10~1
+        int j = 10;
+        do{
+            System.out.println(j);
+            j--;
+        }while(j>=1);
+        System.out.println("程序结束");
+        //a~z
+        int k = 'a';
+        do{
+            System.out.println((char)k);
+            k++;
+        }while(k<='z');
+        System.out.println("程序结束");
+
+    }
+}

day03/src/com/inmind/Demo06.java

@@ -0,0 +1,44 @@
+package com.inmind;
+/*
+三种循环的区别
+使用场景：for（数组遍历，字符串遍历，集合遍历）、while(io流)、do-while(当循环体必须执行一次的时候)
+
+区别：
+1.当循环条件都不满足时，只有do-while一定会执行一次循环体语句
+2.for循环的循环变量是定义在for语句内部的，所以超出for循环以外的话，就不能使用，就像没定义过一样
+3.while和do-while的循环变量可以一直使用
+*/
+public class Demo06 {
+    public static void main(String[] args)
+    {
+        //for
+        //打印1~10的值
+        for(int i = 1;i <= 10;i++){
+            System.out.println(i);
+        }
+
+        int i = 100;//证明for循环中的i与当前的i不在同一范围内
+        System.out.println(i);
+
+        System.out.println("-----------------------");
+        //while
+        //打印1~10的值
+        int j = 1;
+        while(j<=10){
+            System.out.println(j);
+            j++;
+        }//这里的大括号就表示结束了
+
+        System.out.println(j);
+        System.out.println("-----------------------");
+        //do-while
+        //打印1~10的值
+        int k = 1;
+        do{
+            System.out.println(k);
+            k++;
+        }while(k<=10);//错误: 需要';'，{}表示结束，而()不行，必须要加;表示结束
+
+        System.out.println(k);
+    }
+}

day03/src/com/inmind/Demo07_break.java

@@ -0,0 +1,25 @@
+package com.inmind;
+/*
+循环的控制_break
+break有2个作用：
+	1.结束switch语句
+	2.结束循环
+*/
+public class Demo07_break {
+    public static void main(String[] args) {
+        /*int i = 10;
+        if (i == 10) {
+            break; 错误：switch或循环之外无法使用break
+        }*/
+        //需求：跑10圈，但是在跑到第5圈的时候，身体不适，就停止跑步
+        for (int i = 1; i < 11; i++) {
+            if (i == 5) {
+                //跑到第5圈的时候,提前结束整个循环
+                break;
+            }
+            System.out.println(i);
+        }
+
+        System.out.println("程序结束");
+    }
+}

day03/src/com/inmind/Demo_Die.java

@@ -0,0 +1,24 @@
+package com.inmind;
+/*
+死循环：循环条件永远满足时，不断执行循环体。
+
+注意：死循环的后面不允许添加任何代码，因为永远都不会执行，编译器就直接报错
+*/
+public class Demo_Die {
+    public static void main(String[] args) {
+        //while死循环
+        int i = 0;
+        while(true){
+            i++;
+            if (i == 1000) {
+                break;
+            }
+        }
+        //-----------------------------------
+        System.out.println("程序结束");
+        //for死循环
+        for(;;){
+        }
+
+    }
+}

day03/src/com/inmind/Demo_continue.java

@@ -0,0 +1,19 @@
+package com.inmind;
+/*
+循环的控制_continue
+
+continue的作用：跳过 本次循环操作，继续下一次循环
+*/
+public class Demo_continue {
+    public static void main(String[] args) {
+        //打印1~10(在打印时，遇到4就不要打印，其他都要打印)1~10都要打印除了4
+        for (int i = 1; i <= 10; i++) {
+            if (i == 4) {
+                continue;
+            }
+            System.out.println(i);
+        }
+
+        System.out.println("程序结束");
+    }
+}

day03/src/com/inmind/Demo_xunhuans.java

@@ -0,0 +1,37 @@
+package com.inmind;
+
+/*
+循环的嵌套:循环里面还有循环
+
+外层循环执行一次，内层循环执行一轮
+*/
+public class Demo_xunhuans {
+    public static void main(String[] args) {
+        //for循环的嵌套（实现时钟的效果）//每小时和每分钟都打印比如0点1分 0点2分~23点59分
+        //0~23时  0~59分
+        for (int i = 0; i < 24; i++) {//0~23时
+            //这个循环体中每小时（循环60次）
+            for (int j = 0; j < 60; j++) {//0~59分
+                System.out.println(i+"时"+j+"分");
+            }
+        }
+
+        System.out.println("程序结束");
+    }
+
+    //循环的嵌套入门
+    public static void demo(String[] args) {
+        //打印一个5行每行5个*的矩形
+        for (int i = 0; i < 20; i++) {
+            /*System.out.print("*");
+            System.out.print("*");
+            System.out.print("*");
+            System.out.print("*");
+            System.out.print("*");*/
+            for (int j = 0; j < 20; j++) {
+                System.out.print("*");
+            }
+            System.out.println();
+        }
+    }
+}

day04/day04.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="17" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

day04/src/com/inmind/Demo01_method.java

@@ -0,0 +1,80 @@
+package com.inmind;
+/*
+方法_定义格式的详细说明
+
+    修饰符 返回值类型   方法名(){
+        方法体;(return只跟方法有关)
+    }
+
+    a.修饰符：public static (固定的)
+
+    b.返回值类型：
+        1.没有返回值：void
+        2.有返回值：基本数据类4类8种（java中的任意类型都能写）
+
+    c.方法名：自定义即可，在方法被调用时进行使用
+
+    d.():方法参数（参数列表）
+        1.如果没有参数，就直接()即可
+        2.如果有参数，直接在()中定义
+            2个int型参数：(int a,int b)
+
+     e.{}:方法体，就是java语句的集合
+        1.在方法中是可以使用关键字return,return就是结束当前的方法，遇到return，方法就结束了
+          return 可以将之后的值返回到方法调用处。
+        2.如果方法有返回值，就必须在方法体中输入return 返回值类型的数据;
+        3.如果方法没有返回值，就可以不写，但是也可以写成return;
+
+
+    方法定义的2个明确：
+            1.明确返回值类型
+            2.明确参数列表
+
+     案例：定义方法实现2个整数值的相加之和并返回
+
+
+
+ */
+public class Demo01_method {
+    public static void main(String[] args) {
+        //调用加法功能，实现整数相加得结果
+        int sum = addMethod(10, 20);
+        System.out.println(sum);
+    }
+    //方法练习1_比较两个整数是否相同
+    public static boolean isEqual(int a,int b){
+        /*if (a == b) {
+            return  true;
+        }else {
+            return false;
+        }*/
+//        return  a==b?true:false;
+        return  a==b;
+    }
+    //方法练习2_运算1到n的累和
+    public static  int getSum(int n){
+        if (n < 1) {
+            System.out.println("您传递的参数不合法");
+            return -1;
+        }
+        int sum = 0;
+        for (int i = 1; i <= n; i++) {
+            sum += i;
+        }
+        return sum;
+    }
+    //方法练习3_打印n遍HelloWorld
+    public static void printHW(int n){
+        for (int i = 0; i < n; i++) {
+            System.out.println("helloworld");
+        }
+    }
+
+
+
+    //2个整数值的相加之和并返回
+    public static int addMethod(int a,int b) {
+        int result = a+b;
+        return result;
+    }
+}

day04/src/com/inmind/Demo02_method_notification.java

@@ -0,0 +1,39 @@
+package com.inmind;
+/*
+学习方法的注意事项
+1.方法要定义在类中方法外
+2.当方法的返回值类型为void的时候，需要写return？不需要。
+  可以写return？可以,但是return之后不能跟任何数据，只能写return;
+3.return:结束方法，跟是否返回方法的调用处无关，只要方法结束了一定返回方法调用处
+4.在一个方法中可以写多个return吗？
+    可以，但是只能有一个return被调用
+ */
+public class Demo02_method_notification {
+    public static void main(String[] args) {
+        if (5 > 3) {
+            System.out.println("1");
+            return;
+        }
+
+        if (2 > 3) {
+            System.out.println("2");
+            return;
+        }
+
+        if (4 > 3) {
+            System.out.println("3");
+            return;
+        }
+
+        printHW(5);
+        System.out.println("程序结束");
+    }
+
+    //方法练习3_打印n遍HelloWorld
+    public static void printHW(int n){
+        for (int i = 0; i < n; i++) {
+            System.out.println("helloworld");
+        }
+    }
+
+}

day04/src/com/inmind/Demo03.java

@@ -0,0 +1,62 @@
+package com.inmind;
+/*
+方法的三种调用
+1.直接调用:有返回值的方法、没有返回值的方法
+    在代码中直接：方法名(参数列表);
+
+2.赋值调用:有返回值的方法
+        数据类型 变量名 = 方法名(参数列表);
+
+3.打印输出调用:有返回值的方法 (将一个方法的返回值作为另一个方法的参数)
+        System.out.println(方法名(参数列表));
+
+ 总结：直接调用可以调用任意方法，赋值调用和打印输出调用只能调用有返回值的方法
+ */
+public class Demo03 {
+    public static void main(String[] args) {
+        //直接调用
+        getSum(100);
+        printHW(5);
+
+        //赋值调用
+        int sum = getSum(100);
+        System.out.println("main方法中："+sum);
+
+        //void s =  printHW(5); 没有返回值的方法，不能使用赋值调用的方式
+        System.out.println("-------------------------");
+        //打印输出调用
+        System.out.println(isEqual(1,2));
+        /*int sum1 = getSum(10);
+        System.out.println(sum1);*/
+        System.out.println(getSum(10));
+
+    }
+    //方法练习1_比较两个整数是否相同
+    public static boolean isEqual(int a,int b){
+        /*if (a == b) {
+            return  true;
+        }else {
+            return false;
+        }*/
+//        return  a==b?true:false;
+        return  a==b;
+    }
+    //方法练习2_运算1到n的累和
+    public static  int getSum(int n){
+        if (n < 1) {
+            System.out.println("您传递的参数不合法");
+            return -1;
+        }
+        int sum = 0;
+        for (int i = 1; i <= n; i++) {
+            sum += i;
+        }
+        return sum;
+    }
+    //方法练习3_打印n遍HelloWorld
+    public static void printHW(int n){
+        for (int i = 0; i < n; i++) {
+            System.out.println("helloworld");
+        }
+    }
+}

day04/src/com/inmind/Demo04_overload.java

@@ -0,0 +1,81 @@
+package com.inmind;
+/*
+方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返
+        回值类型无关。
+
+ 方法重载：2同一不同
+ 1.在同一个类中
+ 2.方法名相同
+ 3.参数列表不同，（与修饰符和返回值类型无关）(参数列表不同：参数列表中的个数，数据类型，参数的顺序)
+
+ 重载的作用：只要记忆同一个方法名，就可以实现对应多种的功能
+ ---------------------------------------------------------------
+
+ class Demo
+{
+    void show(int a,float b,char c)
+    {
+
+    }
+}
+下列哪些函数和给定函数重载了。
+a.int show(int x,float y,char z)
+
+b.void show(float b,int a,char c)
+
+c.void show(int c,float a,char b)
+
+d.void show(int a,int b,int c)
+
+e.double show()
+
+ */
+public class Demo04_overload {
+    void show(int a,float b,char c)
+    {
+
+    }
+
+    void show(int a,int b,int c){
+
+    }
+
+    double show(){
+        return 1.1;
+    }
+
+    void show(float b,int a,char c){
+
+    }
+
+
+
+    public static void main(String[] args) {
+        //定义2个整数相加之和的方法，并返回和值
+        //定义3个整数相加之和的方法，并返回和值
+        //定义4个整数相加之和的方法，并返回和值
+        int sum = getSum(1, 2, 3);
+        System.out.println(sum);
+        System.out.println(1);
+        System.out.println(1.1);
+        System.out.println(true);
+        System.out.println("edd");
+        System.out.println('d');
+    }
+
+    //定义2个整数相加之和的方法，并返回和值
+    public static int getSum(int a, int b) {
+        int sum = a+b;
+        return sum;
+    }
+    //定义3个整数相加之和的方法，并返回和值
+    public static int getSum(int a, int b,int c) {
+        int sum = a+b+c;
+        return sum;
+    }
+    //定义4个整数相加之和的方法，并返回和值
+    public static int getSum(int a, int b,int c,int d) {
+        int sum = a+b+c+d;
+        return sum;
+    }
+}

day05/day05.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="17" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

day05/src/com/inmind/Demo01_array.java

@@ -0,0 +1,59 @@
+package com.inmind;
+/*
+该类要学习的内容：
+    数组:将多个数据保存到一起，
+    2个特点：存储数据的长度是固定不能变；数据类型必须一致。
+
+数组的定义格式有3种：
+
+ 1.数组的定义格式一：（数组的动态初始化）
+    数组中要保存的数据类型[] 数组名 = new 数组中要保存的数据类型[数组的长度];
+    数据类型[] 数组名 = new 数据类型[数组的长度];
+
+    数组中要保存的数据类型：当前就是4类8种基本数据类型，但是这个可以使用java中的任意类型
+    []：数组的意思
+    数组名：可以理解为变量名，是标识符中的一种，数组名用来操作数组中的数据
+    new:java中的关键字的一种，给虚拟机看的，会开辟新的空间
+    数组中要保存的数据类型：要跟前面的数据类型保持一致
+    [数组的长度]:决定数组的长度
+
+  2.数组的定义格式二：（数组的静态初始化）
+    数据类型[] 数组名 = new 数据类型[]{值1,值2,值3};
+
+    这种格式，没有直接给数组的长度，它是根据你直接传入的值，确定自己的长
+
+  3.数组的定义格式三：（数组的静态初始化简写形式）
+    数据类型[] 数组名 = {值1，值2};
+    这种格式，没有直接给数组的长度，它是根据你直接传入的值，确定自己的长度
+
+ */
+public class Demo01_array {
+    public static void main(String[] args) {
+        //1.数组的定义格式一：（数组的动态初始化）
+        //创建一个int型的数组，长度为3
+        int[] array = new int[3];
+
+        //2.数组的定义格式二：（数组的静态初始化）
+        //创建一个double型的数组，具体的值为1.0,2.0,3.0
+        double[] array1 = new double[]{1.0,2.0,3.0};
+
+        //3.数组的定义格式三：（数组的静态初始化简写形式）
+        //创建一个String类型的数组，具体的值分别，java,c,python,html,css
+        String[] array2 = {"java","c","python","html","css"};
+
+        //注意：数组的定义格式三，只能在定义数组的时候直接赋值，当数组创建完毕后就不能直接赋值了
+
+        //获取数组的长度
+        System.out.println(array.length);
+        System.out.println(array1.length);
+        System.out.println(array2.length);
+
+        //获取array2中的具体的值
+        String str = array2[0];
+        System.out.println(str);
+
+        //修改array2中的java的值为JS
+        array2[0] = "JS";
+        System.out.println(array2[0]);
+    }
+}

day05/src/com/inmind/Demo02_array_memory.java

@@ -0,0 +1,33 @@
+package com.inmind;
+/*
+数组的操作
+    二进制：0~1
+    八进制：0~7
+    十进制：0~9
+    十六进制：0~15，  0~9 10（a）、11（b）、12(c)、13(d)、14(e)、15(f)
+ */
+public class Demo02_array_memory {
+    public static void main(String[] args) {
+        //定义一个数据不确定的长度为3的存放整型的数组
+        int[] arr = new int[3];
+        System.out.println(arr);//[I@50cbc42f
+         /*
+        [I@50cbc42f
+        [I:表示当前是一个数组数据类型，数组存放的数据类型是int
+        50cbc42f：表示数组在内存中开辟的空间地址
+
+        索引：操作数组指定空间的值，从0开始
+         */
+
+        System.out.println(arr[0]);//0
+        System.out.println(arr[1]);//0
+        System.out.println(arr[2]);//0
+        double[] dArr = new double[3];
+        System.out.println(dArr[0]);//0.0
+        System.out.println(dArr[1]);//0.0
+        System.out.println(dArr[2]);//0.0
+        System.out.println("-------------------");
+        //注意：数组的最大索引= 数组.length -1;
+        //System.out.println(dArr[3]);//(数组越界异常)java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
+    }
+}

day05/src/com/inmind/Demo03_array_foreach.java

@@ -0,0 +1,25 @@
+package com.inmind;
+/*
+11.数组的操作_数组的遍历
+遍历：将数组中每个数据，都一一展示出来
+ */
+public class Demo03_array_foreach {
+    public static void main(String[] args) {
+        //定义一个具体值为1,2,3的整数数组
+        int[] arr = {1,2,3,5,6,7,78,8,9};//50个值
+        //简单操作：直接根据索引获取值即可
+        /*System.out.println(arr[0]);
+        System.out.println(arr[1]);
+        System.out.println(arr[2]);*/
+        //实际操作：使用for循环实现遍历（0~arr.length-1）
+        //正向遍历
+        for (int i = 0; i < arr.length; i++) {
+            System.out.println(arr[i]);
+        }
+        System.out.println("-----------------------------------");
+        //反向遍历 最大索引~0
+        for (int i = arr.length-1; i >=0; i--) {
+            System.out.println(arr[i]);
+        }
+    }
+}

day05/src/com/inmind/Demo04_array_test.java

@@ -0,0 +1,23 @@
+package com.inmind;
+/*
+1.定义一个整型数组，传入一些固定的值
+2.使用数组的遍历，获取到数组中最大的值
+ */
+public class Demo04_array_test {
+    public static void main(String[] args) {
+        //定义一个整型数组
+        int[] arr = {10,20,30,50,100,-100,300};
+        //获取数组中的最大值
+        //定义一个变量，将数组的第一位数据保存到变量假定是最大
+        int max = arr[0];
+        //数组的遍历
+        for (int i = 1; i < arr.length; i++) {
+            //取出数组中每个元素
+            int temp = arr[i];
+            if (temp > max) {
+                max = temp;
+            }
+        }
+        System.out.println(max);
+    }
+}

day05/src/com/inmind/Demo05.java

@@ -0,0 +1,21 @@
+package com.inmind;
+/*
+数组作为方法参数_传递地址
+ */
+public class Demo05 {
+    public static void main(String[] args) {
+        //定义int型数组
+        int[] arr = {1,2,3};
+        foreachArray(arr);
+        //定义int型数组
+        int[] arr1 = {4,5,6};
+        foreachArray(arr1);
+    }
+
+    //我要定义一个方法，动态接收int数组，对该数组进行遍历打印
+    public static void foreachArray(int[] array){
+        for (int i = 0; i < array.length; i++) {
+            System.out.println(array[i]);
+        }
+    }
+}

day05/src/com/inmind/Demo06.java

@@ -0,0 +1,79 @@
+package com.inmind;
+
+public class Demo06 {
+    public static void main(String[] args) {
+        //定义出一个整数数组
+        int[] arr = {1,2,4,6,7,8,9,10,11,13,14};
+        //alt+enter
+//        int[] newArr = getOuShuArray(arr);
+//        int[] newArr = getOuShuArray1(arr);
+        int[] newArr = getOuShuArray2(arr);
+        foreachArray(newArr);
+    }
+
+    //定义一个方法，传入一个整数数组，将数组中的偶数，封装起来，并将只含有偶数的新数组返回回来
+
+    //方式三：先计算出偶数的个数，再自己维护索引
+    private static int[] getOuShuArray2(int[] arr) {
+        //先用遍历计算中原数组中偶数的个数
+        int num = 0;
+        for (int i = 0; i < arr.length; i++) {
+            if (arr[i] % 2 == 0) {
+                num++;
+            }
+        }
+
+        //创建一个新的长度跟arr数组的长度一致的int数组
+        int index = 0;
+        int[] newArr = new int[num];
+        for (int i = 0; i < arr.length; i++) {
+            int temp = arr[i];
+            if (temp % 2 == 0) {
+                newArr[index] = temp;
+                index++;
+            }
+        }
+
+        return newArr;
+    }
+
+
+    //方式二：自己控制索引
+    private static int[] getOuShuArray1(int[] arr) {
+        //创建一个新的长度跟arr数组的长度一致的int数组
+        int index = 0;
+        int[] newArr = new int[arr.length];
+        for (int i = 0; i < arr.length; i++) {
+            int temp = arr[i];
+            if (temp % 2 == 0) {
+                newArr[index] = temp;
+                index++;
+            }
+        }
+
+        return newArr;
+    }
+
+
+    //方式一：不是很好
+    private static int[] getOuShuArray(int[] arr) {
+        //创建一个新的长度跟arr数组的长度一致的int数组
+        int[] newArr = new int[arr.length];
+        for (int i = 0; i < arr.length; i++) {
+            //参数中的每个元素
+            int temp = arr[i];
+            if (temp % 2 == 0) {
+                newArr[i] = temp;
+            }
+        }
+        return newArr;
+    }
+
+
+    //我要定义一个方法，动态接收int数组，对该数组进行遍历打印
+    public static void foreachArray(int[] array){
+        for (int i = 0; i < array.length; i++) {
+            System.out.println(array[i]);
+        }
+    }
+}

day05/src/com/inmind/Demo07.java

@@ -0,0 +1,27 @@
+package com.inmind;
+/*
+基本数据类型作为方法参数的操作
+断点：break point
+断点使用：在要调用的方法的第一行，点上断点
+F8:向下执行一行代码
+F7:进入方法中
+shift+F8:跳出方法
+
+注意：基本数据类型作为方法参数，是直接传递具体的值，它是不会影响原本方法中的变量的值的！！！！
+ */
+public class Demo07 {
+    public static void main(String[] args) {
+        int a = 10;
+        int b = 20;
+        //修改值
+        changeValue(a,b);
+        System.out.println(a);
+        System.out.println(b);
+    }
+
+    //方法
+    public static void changeValue(int a, int b) {
+        a = a+a;
+        b = b+b;
+    }
+}

day05/src/com/inmind/Demo08.java

@@ -0,0 +1,18 @@
+package com.inmind;
+/*
+引用类型作为方法参数:传递的是地址！！！！
+ */
+public class Demo08 {
+    public static void main(String[] args) {
+        //定义一个数组
+        int[] arr = {10,20};
+        changValue(arr);
+        System.out.println(arr[0]);//
+        System.out.println(arr[1]);//
+    }
+
+    private static void changValue(int[] arr) {
+        arr[0] = arr[0] + arr[0];
+        arr[1] = arr[1] + arr[1];
+    }
+}

day06/src/com/inmind/object01/Demo01.java

@@ -0,0 +1,46 @@
+package com.inmind.object01;
+/*
+面向对象给学生类特征属性赋值并调用学生类方法
+
+类与对象的关系：类是抽象（设计图），对象是具体（根据设计图创建出来真正存在的实体）
+
+如何创建出对象？？？
+创建对象的格式：
+    类名 对象名 = new 类名();
+    Student s = new Student();
+
+ 总结：
+    要对另一个类的属性变量和行为方法进行调用操作，必须创建该类的对象，并通过该对象来操作：
+    a.对象.属性变量
+    b.对象.行为方法(参数列表)
+ */
+public class Demo01 {
+    public static void main(String[] args) {
+        //创建一个学生对象
+        /*
+        Student:表示创建的对象的类型
+        student:表示对象名，用来操作对象的，student中保存了真正学生对象的地址
+        new:在堆内存中创建内容
+        Student()：表示要创建的对象，跟之前的类名保持一致
+         */
+        Student student = new Student();
+
+
+        //对象的属性赋值
+        student.id = 1;
+        student.name = "张三";
+        student.gender = "男";
+        student.score = 99.9;
+
+        //属性值的获取
+        System.out.println(student.id);//0
+        System.out.println(student.name);//
+        System.out.println(student.gender);//
+        System.out.println(student.score);//0.0
+
+        //操作对象的行为
+        student.eat("汉堡");
+        student.sleep();
+        student.study("java");
+    }
+}

day06/src/com/inmind/object01/Student.java

@@ -0,0 +1,37 @@
+package com.inmind.object01;
+/*
+总结：
+    1.在java中描述一类事物，是要有特征(成员变量)和行为(功能方法，不要用static来修饰)来组成
+    2.在类中并不是都必须要主方法的，如果一个类要运行，并得到一些结果，那么就必须要主方法
+      在java中一个类只是用来描述一类事物的时候，那么就不要主方法。
+ */
+//学生类
+public class Student {
+    //属性（变量）
+    //姓名
+    String name;
+    //年龄
+    int age;
+    //学号
+    int id;
+    //性别
+    String gender;
+    //成绩
+    double score;
+
+    //行为（方法）
+    //吃饭
+    public void eat(String food) {
+        System.out.println("该学生在吃"+food);
+    }
+    //睡觉
+    public void sleep(){
+        System.out.println("该学生在睡觉");
+    }
+
+    //学习
+    public void study(String book) {
+        System.out.println("该学生在学"+book);
+    }
+
+}

day06/src/com/inmind/object_private03/Student.java

@@ -0,0 +1,112 @@
+package com.inmind.object_private03;
+/*
+Student():就是Student类的默认无参构造方法
+
+普通自定义方法
+方法修饰符 返回值类型 方法名(参数列表){
+    方法体；return
+}
+
+构造方法
+方法修饰符   构造方法名(参数列表){
+    方法体
+}
+
+构造方法：
+    1.没有返回值类型
+    2.构造方法名必须跟类名一致
+
+ 注意：当源文件，进行编译之后编译器扫描整个类的内容，如果它发现你没写构造方法，它会帮你自动添加一个
+       默认的无参构造方法。如果你写了构造方法，编译器就不会自动添加一个默认的无参构造方法
+
+构造方法是可以重载的。
+
+构造方法的作用：通过new调用该构造方法，创建对象，并且对该对象的属性进行赋值
+
+有参构造方法：创建对象并赋值指定的值
+无参构造方法：创建对象并赋值默认初始化值
+
+ */
+
+public class Student {
+    private String name;
+    private int age = 20;
+    private int id;
+
+    //默认无参构造方法
+    public Student(){
+
+    }
+
+    //满参构造方法
+    public Student(String name,int age,int id){
+        this.id = id;
+        this.name = name;
+        this.age = age;
+    }
+
+    //有参构造方法
+    public Student(String name){
+        this.name = name;
+    }
+
+    public Student(int id){
+        this.id = id;
+    }
+
+    public Student(String name,int id){
+        this.id = id;
+        this.name = name;
+    }
+
+
+    //学习
+    public void study(String book) {
+
+        System.out.println("学号："+id+",姓名："+name+",年龄为"+age+"岁的学生在学"+book);
+    }
+
+    //封装的get/set方法针对对应的属性的！！！
+    public String getName(){
+        return name;
+    }
+    //在开发中，定义变量尽量增强可读性，见其名知其意
+    public void setName(String name){
+        /*
+        当前代码想要的意思：成员变量 = 局部变量；
+        当前的意思却是：局部变量 = 局部变量；
+        注意：当成员变量与局部变量重名时！！！就近原则
+
+        如何解决当前的重名问题？？
+        使用this：this.成员变量名，这样就表示的是当前对象的成员变量
+        this:方法中的对象指的是，哪个对象调用该方法，那么这个this就表示该对象
+
+        this的作用：区分成员变量与局部变量
+         */
+        System.out.println(this);
+        this.name = name;
+    }
+
+    public int getAge(){
+        return age;
+    }
+
+    public void setAge(int age){
+        //增加数据的安全性的判断功能
+        if (age < 1||age>120) {
+            System.out.println("您输入的年龄非法的");
+            return;
+        }
+        this.age = age;
+    }
+
+    public int getId(){
+        return id;
+    }
+
+    //shift+f6:修改名称
+    public void setId(int id){
+        this.id = id;
+    }
+
+}

day06/src/com/inmind/object_private03/StudentTest.java

@@ -0,0 +1,37 @@
+package com.inmind.object_private03;
+/*
+
+为了学生类的代码的安全性，要使用封装
+封装的步骤：
+1.使用private修饰符
+2.提供对应属性的getXXX+setXXX方法
+
+private：权限修饰符，最小一个权限，被它修饰的内容只能够在本类中访问,
+        private只能修饰成员变量和成员方法,表示私有化。
+成员方法：处于成员位置的非静态方法。
+非静态：不被static修饰的方法
+ */
+public class StudentTest {
+    public static void main(String[] args) {
+
+        //创建一个学生对象
+        Student s = new Student();
+        System.out.println(s);
+        s.study("java");
+        //s.属性 = 值
+        //对象的属性的设置值
+        s.setId(1);
+        s.setAge(-20);
+        s.setName("李四");
+
+        s.study("java");
+        //对象的属性的获取值
+        System.out.println(s.getAge());
+        System.out.println(s.getId());
+        System.out.println(s.getName());
+
+        //使用满参构造方法创建出学生对象（2，王五，22）
+        Student s1 = new Student("王五", 22, 2);
+        s1.study("python");
+    }
+}

day06/src/com/inmind/object_private03/Teacher.java

@@ -0,0 +1,46 @@
+package com.inmind.object_private03;
+
+//标准的java类！！！
+public class Teacher {
+    private String name;
+    private double salary;
+    private int age;
+    //alt+inset
+    //构造方法
+    public Teacher(String name, double salary, int age) {
+        this.name = name;
+        this.salary = salary;
+        this.age = age;
+    }
+
+
+    public Teacher() {
+    }
+
+
+    //get/set
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public double getSalary() {
+        return salary;
+    }
+
+    public void setSalary(double salary) {
+        this.salary = salary;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+}

day06/src/com/inmind/object_test02/Phone.java

@@ -0,0 +1,61 @@
+package com.inmind.object_test02;
+/*
+成员变量：处于成员位置的变量
+成员位置：类中方法外
+局部变量：在方法中定义的变量
+
+注意：在方法中，如果使用了成员变量与局部变量同名的变量，符合就近原则，直接使用的是局部变量
+
+成员变量与局部变量的区别：
+1.定义的位置不同
+    成员变量：类中方法外
+    局部变量：方法中
+2.作用范围不同
+    成员变量：整个类中都能用
+    局部变量：只能在定义该变量的方法中
+3.处于内存的位置不同
+    成员变量：在堆内存中
+    局部变量：在栈内存
+4.默认值不同：
+    成员变量：有默认值的
+    局部变量：没有默认值
+5.生命周期不同
+    成员变量：随着对象的出现而出现，随着对象的销毁而销毁
+    局部变量：随着方法的出现而出现，随着方法的销毁而销毁
+
+ */
+public class Phone {
+    //品牌
+    String brand;
+    //价格
+    double price;
+    //颜色
+    String color;
+    //尺寸
+    double size;
+
+
+    //show:展示自身（属性）
+    public void show() {
+        String brand1 = "某品牌";//局部变量，只能在定义该变量的方法中使用
+        System.out.println(brand);
+        System.out.println(price);
+        System.out.println(color);
+        System.out.println(size);
+    }
+
+    //打电话
+    public void call(String number) {
+        System.out.println("给"+number+"打电话");
+    }
+    //发短信
+    public void sendMsg(String number) {
+        System.out.println("给"+number+"发短信");
+    }
+    //玩app
+    public void playApp() {
+        System.out.println("玩抖音");
+        System.out.println("玩王者");
+        System.out.println("玩QQ");
+    }
+}

day06/src/com/inmind/object_test02/Test01.java

@@ -0,0 +1,32 @@
+package com.inmind.object_test02;
+//买2个手机，打印下属性
+public class Test01 {
+    public static void main(String[] args) {
+        //买一个土豪金的苹果手机
+        Phone p1 = new Phone();
+        p1.brand = "苹果";
+        p1.price = 12999.9;
+        p1.color = "土豪金";
+        p1.size = 6.4;
+        p1.show();
+//        showPhone(p1);
+        //买一个星空灰的华为折叠屏
+        Phone p2 = new Phone();
+        p2.brand = "华为";
+        p2.price = 22999.9;
+        p2.color = "星空灰";
+        p2.size = 12.4;
+//        showPhone(p2);
+        p2.show();
+    }
+
+    //使用类作为参数
+    //定义接收一个手机，将手机的属性打印的方法
+    /*public static void showPhone(Phone p){
+        System.out.println(p.brand);
+        System.out.println(p.price);
+        System.out.println(p.color);
+        System.out.println(p.size);
+    }*/
+
+}

day07/day07.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="17" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

day07/src/com/inmind/arraylist03/Demo08.java

@@ -0,0 +1,33 @@
+package com.inmind.arraylist03;
+/*
+对象数组：保存引用数据类型的数组
+ */
+public class Demo08 {
+    public static void main(String[] args) {
+        //定义一个保存3个学生的数组
+        //数据类型[] 数组名 = new 数据类型[长度]
+        Student[] arr = new Student[3];
+        //创建3个学生对象
+        Student s1 = new Student(1, 20, "张三");
+        Student s2 = new Student(2, 21, "李四");
+        Student s3 = new Student(3, 22, "王五");
+
+        //往数组中保存数据
+        arr[0] = s1;
+        arr[1] = s2;
+        arr[2] = s3;
+
+        System.out.println(arr);
+
+        //获取数组中每个学生的姓名
+        for (int i = 0; i < arr.length; i++) {
+            Student s = arr[i];
+            System.out.println(s.getName());
+        }
+
+        //数组定义完毕，还想要添加2个学生？？对象数组不行，除非创建新的数组
+        //数组定义完毕之后，直接删除数组中某一个值呢？对象数组不行，只能用新的值替换而不能直接删除
+        //为了解决以上的问题，有一个更好的容器，arraylist！！！
+        //arraylist的好处：1.长度可变 2.可以进行增删改查 3.arraylist可以存放任意引用数据类型
+    }
+}

day07/src/com/inmind/arraylist03/Demo09.java

@@ -0,0 +1,37 @@
+package com.inmind.arraylist03;
+
+import java.util.ArrayList;
+
+/*
+常用类_ArrayList_使用步骤
+1.导包java.util.ArrayList
+2.通过构造方法创建对象ArrayList()
+3.调用方法，add(E e)
+
+arraylist的好处：1.长度可变 2.可以进行增删改查 3.arraylist可以存放任意引用数据类型
+
+注意：ArrayList在使用的时候，大部分都是将一种类型的数据放在一个容器arraylist中
+
+泛型决定了集合中存放的数据类型！！！
+ */
+public class Demo09 {
+    public static void main(String[] args) {
+        //创建一个集合对象
+        /*ArrayList arrayList = new ArrayList();//如果泛型不写，默认是object，任意引用数据类型都能放进来
+        Student s = new Student();
+        arrayList.add(1);
+        arrayList.add(1.1);
+        arrayList.add('中');
+        arrayList.add(true);
+        arrayList.add("呵呵");
+        arrayList.add(s);*/
+        //正确的集合使用：
+        ArrayList<String> arrayList = new ArrayList<>();//创建了一个集合，该集合只能保存字符串
+        arrayList.add("张三");
+        arrayList.add("李四");
+        arrayList.add("王五");
+        //arrayList里面保存的是地址，但是这里输出了内容，由于对应源码的实现导致 （由于ArrayList重写了toString方法导致）
+        System.out.println(arrayList);
+
+    }
+}

day07/src/com/inmind/arraylist03/Demo10.java

@@ -0,0 +1,91 @@
+package com.inmind.arraylist03;
+
+import java.util.ArrayList;
+
+/*
+常用类_ArrayList_其他常用方法说明
+对于元素的操作,基本体现在——增、删、改、查。
+常用的方法有
+    添加：
+    void add(int index, E element) 在此列表中的指定位置插入指定的元素。
+    boolean add(E e) 将指定的元素追加到此列表的末尾。
+    删除：
+    E remove(int index) 删除该列表中指定位置的元素。
+    boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
+    修改：
+    E set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
+    查询：
+    E get(int index) 返回此列表中指定位置的元素。
+
+    集合的长度
+    int size() 返回此列表中的元素数。
+ */
+public class Demo10 {
+    public static void main(String[] args) {
+        //创建一个保存字符串的集合，添加数据
+        ArrayList<String> list = new ArrayList<>();
+        list.add("迪丽热巴");
+        list.add("王宝强");
+        list.add("赵丽颖");
+        list.add("杨幂");
+        System.out.println(list);
+        //E set(int index, E element) 用指定的元素替换此列表中指定位置的元素,返回原本的值
+        String updatedStr = list.set(1, "王宝宝");
+        System.out.println(list);
+        System.out.println(updatedStr);
+
+        //E get(int index) 返回此列表中指定位置的元素。获取每个元素
+        System.out.println(list.get(0));
+        System.out.println(list.get(1));
+        System.out.println(list.get(2));
+        System.out.println(list.get(3));
+
+        //int size() 返回此列表中的元素数
+        int size = list.size();
+        System.out.println(size);
+        //集合的数据全部获取 （for循环）
+        for (int i = 0; i < list.size(); i++) {
+            System.out.println(list.get(i));
+        }
+
+
+    }
+
+    private static void removeTest() {
+        //创建一个保存字符串的集合，添加数据
+        ArrayList<String> list = new ArrayList<>();
+        list.add("迪丽热巴");
+        list.add("王宝强");
+        list.add("赵丽颖");
+        list.add("杨幂");
+        list.add("王宝强");
+        System.out.println(list);
+        //boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
+        boolean removed = list.remove("王宝强");
+        System.out.println(list);
+        System.out.println(removed);
+
+
+        //E remove(int index) 删除该列表中指定位置的元素。
+        //想删除第二个王宝强
+        /*String removeStr = list.remove(4);
+        System.out.println(list);
+        System.out.println(removeStr);*/
+    }
+
+    //集合的添加操作
+    private static void addTest() {
+        //创建一个保存字符串的集合，添加数据
+        ArrayList<String> list = new ArrayList<>();
+        //boolean add(E e) 将指定的元素追加到此列表的末尾。（排队）
+        list.add("迪丽热巴");
+        list.add("赵丽颖");
+        list.add("杨幂");
+        System.out.println(list);
+        //void add(int index, E element) 在此列表中的指定位置插入指定的元素。(插队)
+        //让王宝强，插队到杨幂的前面
+//        list.add(2,"王宝强");
+        //list.add(4,"王宝强");//错误，插队的索引值最大就是集合的长度
+        System.out.println(list);
+    }
+}

day07/src/com/inmind/arraylist03/Demo11.java

@@ -0,0 +1,48 @@
+package com.inmind.arraylist03;
+
+import java.util.ArrayList;
+
+/*
+基本类型	基本类型包装类
+byte	Byte
+short	Short
+int	    Integer
+long	Long
+float	Float
+double	Double
+char	Character
+boolean	Boolean
+
+主要记录int和char的包装类
+
+自动装箱：int型的值------装箱成Integer类的对象
+自动拆箱：Integer类的对象----拆箱为int型的值
+ */
+public class Demo11 {
+    public static void main(String[] args) {
+        //定义一个保存int值的集合
+        ArrayList<Integer> integers = new ArrayList<>();
+        integers.add(1);//自动装箱：1---装箱为内容为1的Integer对象
+        integers.add(2);
+        integers.add(3);
+        System.out.println(integers);
+
+        //获取下integers中的第二个的内容(对象)
+        Integer i = integers.get(1);
+        int result = i+10;//自动拆箱：i是Integer类的对象----拆箱为int型的值2
+        System.out.println(result);//12
+
+
+        //保存double小数的集合
+        ArrayList<Double> doubles = new ArrayList<>();
+
+        doubles.add(1.0);//自动装箱：double1.0  ---装箱为内容为1.0的Double对象
+        doubles.add(2.0);
+        doubles.add(3.0);
+        System.out.println(doubles);
+        double d = 4;//自动类型提升：int--->double 4.0
+        Double d1 = d;//自动装箱
+        doubles.add(d1);
+        System.out.println(doubles);
+    }
+}

day07/src/com/inmind/arraylist03/Demo12.java

@@ -0,0 +1,27 @@
+package com.inmind.arraylist03;
+
+import java.util.ArrayList;
+
+/*
+常用类-ArrayList-练习2_添加对象
+ */
+public class Demo12 {
+    public static void main(String[] args) {
+        //创建一个保存学生对象的集合
+        ArrayList<Student> students = new ArrayList<>();
+        //往集合中保存3个学生对象
+        Student s1 = new Student(1, 20, "刘备");
+        Student s2 = new Student(2, 21, "关羽");
+        Student s3 = new Student(3, 22, "张飞");
+
+        students.add(s1);
+        students.add(s2);
+        students.add(s3);
+        
+        //对集合进行遍历打印学生的学号，年龄和姓名（直接获取属性打印，也可以封装为方法调用）
+        for (int i = 0; i < students.size(); i++) {
+            Student s = students.get(i);
+            s.show();
+        }
+    }
+}

day07/src/com/inmind/arraylist03/Demo13.java

@@ -0,0 +1,41 @@
+package com.inmind.arraylist03;
+
+import java.util.ArrayList;
+
+/*
+14.常用类-ArrayList-练习3_指定格式拼接字符串
+定义以指定格式打印集合的方法(ArrayList类型作为参数)，使用@分隔每个元素。并返回
+格式参照 [元素@元素@元素]。
+ */
+public class Demo13 {
+    public static void main(String[] args) {
+        //2.在主方法中调用该方法，获取内容，打印输出
+        ArrayList<String> list = new ArrayList<>();
+        list.add("张三");
+        list.add("李四");
+        list.add("关羽");
+        list.add("刘备");
+        list.add("王五");
+        String result = printList(list);
+        System.out.println(result);
+
+    }
+
+    //1.定义一个方法，作用将对应的集合的内容，获取出来，拼接成[元素@元素@元素]，返回
+    public static String printList(ArrayList<String> list){
+        String result = "[";
+
+        for (int i = 0; i < list.size(); i++) {
+            String temp = list.get(i);
+            //如果是最后一个拼接]否则是@
+            if (i == list.size() - 1) {
+                result += temp + "]";
+            } else {
+                result += temp + "@";
+            }
+        }
+
+        return result;
+    }
+
+}

day07/src/com/inmind/arraylist03/Demo14.java

@@ -0,0 +1,50 @@
+package com.inmind.arraylist03;
+
+import java.util.ArrayList;
+
+/*
+常用类-ArrayList-练习4_获取偶数集合
+实现方式2种：
+    1.创建新的集合只保存偶数
+    2.不创建新的集合，只把原集合中不为偶数的数据删除掉即可
+ */
+public class Demo14 {
+    public static void main(String[] args) {
+        //2.不创建新的集合，只把原集合中不为偶数的数据删除掉即可
+        ArrayList<Integer> integers = new ArrayList<>();
+        integers.add(2);
+        integers.add(3);
+        integers.add(3);
+        integers.add(8);
+        integers.add(6);
+
+        for (int i = 0; i < integers.size(); i++) {
+            Integer temp = integers.get(i);
+            if (temp % 2 ==1) {
+                //如果是奇数，从当前集合删除指定索引的值
+                integers.remove(i);
+                i--;//注意：但凡在集合遍历中删除，一定要加i--,避免跳过元素
+            }
+        }
+        System.out.println(integers);
+    }
+
+    //1.创建新的集合只保存偶数
+    private static void getOushu1() {
+        ArrayList<Integer> integers = new ArrayList<>();
+        integers.add(2);
+        integers.add(3);
+        integers.add(3);
+        integers.add(8);
+        integers.add(6);
+
+        ArrayList<Integer> newList = new ArrayList<>();
+        for (int i = 0; i < integers.size(); i++) {
+            Integer temp = integers.get(i);
+            if (temp % 2 == 0) {//自动拆箱
+                newList.add(temp);
+            }
+        }
+        System.out.println(newList);
+    }
+}

day07/src/com/inmind/arraylist03/Student.java

@@ -0,0 +1,55 @@
+package com.inmind.arraylist03;
+
+public class Student {
+    //属性（成员变量）
+    private int id;
+    private int age;
+    private String name;
+
+    //构造方法（无参和有参）
+
+    public Student() {
+    }
+
+    public Student(int id, int age, String name) {
+        this.id = id;
+        this.age = age;
+        this.name = name;
+    }
+
+    //行为（成员方法）
+
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void study(String book) {
+        System.out.println("在学习");
+    }
+
+    public void show(){
+        String showStr = "学号为"+this.getId()+",年龄为"+age+"，姓名为"+this.name;
+        System.out.println(showStr);
+    }
+}

day07/src/com/inmind/random02/Demo05.java

@@ -0,0 +1,23 @@
+package com.inmind.random02;
+
+import java.util.Random;
+
+/*
+获取随机数Random类的使用
+ */
+public class Demo05 {
+    public static void main(String[] args) {
+        //创建random对象，调用nextInt方法
+        Random random = new Random();
+
+        /*for (int i = 0; i < 100; i++) {
+            int a = random.nextInt();//在int的取值范围内获取一个随机值
+            System.out.println(a);
+        }*/
+
+        for (int i = 0; i < 100; i++) {
+            int result = random.nextInt(10);//获取0~9的随机数
+            System.out.println(result);
+        }
+    }
+}

day07/src/com/inmind/random02/Demo06.java

@@ -0,0 +1,18 @@
+package com.inmind.random02;
+
+import java.util.Random;
+
+/*
+获取10个55~66之间的值，（包含55和66）
+
+random.nextInt(10);//获取0~9的随机数
+ */
+public class Demo06 {
+    public static void main(String[] args) {
+        Random random = new Random();
+        for (int i = 0; i < 1000; i++) {
+            int result = random.nextInt(12)+55;//0~9: 55~66 -55 -->0~11--->12
+            System.out.println(result);
+        }
+    }
+}

day07/src/com/inmind/random02/Demo07.java

@@ -0,0 +1,53 @@
+package com.inmind.random02;
+
+import java.util.Random;
+import java.util.Scanner;
+
+/*
+常用类_Random_猜数字游戏(1~100)
+猜数字小游戏
+游戏开始时，会随机生成一个1-100之间的整数number 。
+玩家猜测一个数字guessNumber ，会与number 作比较，系统提示大了或者小了，直到玩家猜中，游戏结束。
+
+分析：
+1.使用random类获取一个随机值(1~100)
+2.使用scanner输入你所猜的值,假设输入的是33
+    （死循环，while(true)）
+    a.将输入的猜的值跟随机数做比较，如果猜的值大了，需要提示猜的值：33大了
+    b.将输入的猜的值跟随机数做比较，如果猜的值小了，需要提示猜的值：33小了
+    c.将输入的猜的值跟随机数做比较，如果猜的值一致，需要提示正确，并结束游戏
+ */
+public class Demo07 {
+    public static void main(String[] args) {
+
+        //1.使用random类获取一个随机值(1~100)
+        Random random = new Random();
+        //1~100 -1  0~99 
+        int number = random.nextInt(1, 101);
+        //2.使用scanner输入你所猜的值,假设输入的是33
+        Scanner sc = new Scanner(System.in);
+        //（死循环，while(true)）
+        while (true) {
+            //获取用户猜测的值
+            System.out.println("请输入您所猜的值：");
+            int guessNumber = sc.nextInt();
+
+
+            if (guessNumber > number) {
+                //a.将输入的猜的值跟随机数做比较，如果猜的值大了，需要提示猜的值：33大了
+                System.out.println("您猜的值"+guessNumber+",大了");
+            } else if (guessNumber < number) {
+                //b.将输入的猜的值跟随机数做比较，如果猜的值小了，需要提示猜的值：33小了
+                System.out.println("您猜的值"+guessNumber+",小了");
+            }else{
+                //c.将输入的猜的值跟随机数做比较，如果猜的值一致，需要提示正确，并结束游戏
+                System.out.println("恭喜您，猜对了");
+                //猜对了，结束死循环
+                break;
+            }
+        }
+
+        System.out.println("程序结束了！！！");
+        
+    }
+}

day07/src/com/inmind/scanner01/Demo01.java

@@ -0,0 +1,26 @@
+package com.inmind.scanner01;
+
+/*
+该类学习Scanner类的使用
+步骤：
+1.导包java.util.Scanner
+2.通过构造方法创建出Scanner类的对象
+3.通过Scanner类中已经定义好的方法，通过对象来调用，获取键盘输入的内容
+ */
+
+//1.导包java.util.Scanner
+import java.util.Scanner;
+
+public class Demo01 {
+    public static void main(String[] args) {
+        //2.通过构造方法创建出Scanner类的对象
+        /*
+        System.in:系统的输入方法，键盘输入
+        System.out:系统的输出方法，在控制台输出
+         */
+        Scanner sc = new Scanner(System.in);
+        //3.通过Scanner类中已经定义好的方法，通过对象来调用，获取键盘输入的内容
+        int i = sc.nextInt();
+        System.out.println(i);
+    }
+}

day07/src/com/inmind/scanner01/Demo02.java

@@ -0,0 +1,22 @@
+package com.inmind.scanner01;
+
+import java.util.Scanner;
+
+/*
+常用类-Scanner-练习1-录入两个整数求和
+ */
+public class Demo02 {
+    public static void main(String[] args) {
+        //创建Scanner对象
+        Scanner scanner = new Scanner(System.in);
+        //分别调用2次nextInt()方法，获取用户手动输入的整数
+        System.out.println("请输入第一个整数：");
+        int a = scanner.nextInt();
+        System.out.println("请输入第二个整数：");
+        int b = scanner.nextInt();
+        //进行2个整数相加得和，输出打印到控制
+        int result = a+b;
+        System.out.println("2个整数相加之和为："+result);
+//        System.out.println("2个整数相加之和为："+(a+b));
+    }
+}

day07/src/com/inmind/scanner01/Demo03.java

@@ -0,0 +1,34 @@
+package com.inmind.scanner01;
+
+import java.util.Scanner;
+
+/*
+常用类-Scanner-练习2_录入n个整数求最大值
+ */
+public class Demo03 {
+    public static void main(String[] args) {
+        //n可以手动赋值，也可以用户赋值
+        Scanner sc = new Scanner(System.in);
+        System.out.println("请输入要计算的整数个数：");
+        int n = sc.nextInt();
+
+        //获取n个整数值（for循环），保存到一个容器（数组）
+        int[] arr = new int[n];
+        //n次循环
+        for (int i = 1; i <= n; i++) {
+            System.out.println("请输入第"+i+"个整数");
+            arr[i-1] = sc.nextInt();
+        }
+        //对容器中的值，取最大值
+        int max = arr[0];
+        for (int i = 0; i < arr.length; i++) {
+            int temp = arr[i];
+            if (temp > max) {
+                max = temp;
+            }
+        }
+
+        //打印结果
+        System.out.println("您输入的"+n+"个整数的最大值为："+max);
+    }
+}

day07/src/com/inmind/scanner01/Demo04.java

@@ -0,0 +1,22 @@
+package com.inmind.scanner01;
+
+import java.util.Scanner;
+
+/*
+匿名对象：没有名字的对象
+匿名对象的使用场景：当一个对象只要被使用一次的时候，可以使用匿名对象来简单实现
+ */
+public class Demo04 {
+    public static void main(String[] args) {
+        //只取一个整数时
+        /*Scanner sc = new Scanner(System.in);
+        int result = sc.nextInt();
+        System.out.println(result);*/
+
+        /*int result = new Scanner(System.in).nextInt();
+        System.out.println(result);*/
+
+
+        System.out.println(new Scanner(System.in).nextInt());
+    }
+}

day08/day08.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="17" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

day08/src/com/inmind/arrays03/Demo12.java

@@ -0,0 +1,32 @@
+package com.inmind.arrays03;
+
+import java.util.Arrays;
+
+/*
+arrays类的2个工具类方法
+
+public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。
+
+public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。
+ */
+public class Demo12 {
+    public static void main(String[] args) {
+        //定义一个整数数组
+        int[] arr = {1, 2, 3, 4};
+        System.out.println(arr);//[I@4eec7777
+        for (int i = 0; i < arr.length; i++) {
+            System.out.println(arr[i]);
+        }
+        System.out.println("---------------------------");
+        //查看某个数组的内容
+        /*String str = Arrays.toString(arr);
+        System.out.println(str);*/
+        System.out.println(Arrays.toString(arr));
+
+        System.out.println("------------------------");
+        int[] arr1 = {1, 44, 22, 56, 2, 5};
+        System.out.println(Arrays.toString(arr1));
+        Arrays.sort(arr1);//对原数组进行排序
+        System.out.println(Arrays.toString(arr1));
+    }
+}

day08/src/com/inmind/arrays03/Demo13.java

@@ -0,0 +1,23 @@
+package com.inmind.arrays03;
+
+import java.util.Arrays;
+
+/*
+Arrays练习：字符串倒序排列
+将一个随机字符串中的所有字符升序排列，并倒序打印。
+ */
+public class Demo13 {
+    public static void main(String[] args) {
+        //1.定义字符串
+        String str = "akfjadkfja";
+        //2.字符串转字符数组
+        char[] chars = str.toCharArray();
+        //3.Arrays调用sort排序
+        Arrays.sort(chars);
+        //4.倒序遍历打印
+        System.out.println(Arrays.toString(chars));
+        for (int i = chars.length - 1; i >= 0; i--) {
+            System.out.println(chars[i]);
+        }
+    }
+}

day08/src/com/inmind/math04/Demo14.java

@@ -0,0 +1,25 @@
+package com.inmind.math04;
+/*
+Math工具类的使用
+public static double abs(double a) ：返回 double 值的绝对值。
+public static double ceil(double a) ：返回大于等于参数的最小的整数。
+public static double floor(double a) ：返回小于等于参数最大的整数。
+public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)
+ */
+public class Demo14 {
+    public static void main(String[] args) {
+        //public static double abs(double a) ：返回 double 值的绝对值。
+        System.out.println(Math.abs(-2));
+        System.out.println(Math.abs(-2.2));
+        //public static double ceil(double a) ：返回大于等于参数的最小的整数。(向上取整)
+        System.out.println(Math.ceil(6.1));//7.0
+        System.out.println(Math.ceil(-3.6));//-3.0
+        //public static double floor(double a) ：返回小于等于参数最大的整数。（向下取整）
+        System.out.println(Math.floor(4.9));//4.0;
+        System.out.println(Math.floor(-6.6));//-7.0
+        //public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)
+        System.out.println(Math.round(3.4));//3
+        System.out.println(Math.round(4.6));//5
+        System.out.println(Math.round(-8.8));//
+    }
+}

day08/src/com/inmind/math04/Demo15.java

@@ -0,0 +1,33 @@
+package com.inmind.math04;
+/*
+计算在 -10.8 到5.9 之间，绝对值大于6 或者小于2.1 的整数有多少个？
+分析：
+取值范围： -10.8 ~5.9
+条件>6||<2.1
+定义一个变量来计数
+
+Math工具类的使用
+public static double abs(double a) ：返回 double 值的绝对值。
+public static double ceil(double a) ：返回大于等于参数的最小的整数。
+public static double floor(double a) ：返回小于等于参数最大的整数。
+public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)
+ */
+public class Demo15 {
+    public static void main(String[] args) {
+        //取值范围： -10.8 ~5.9
+        double start = -10.8;
+        double end = 5.9;
+        //定义计数的变量
+        int count = 0;
+
+        for (double i = Math.ceil(start); i < end; i++) {
+            //判断条件：绝对值>6||<2.1
+            if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
+                System.out.println(i);
+                count++;
+            }
+        }
+        System.out.println("满足条件的个数："+count);
+
+    }
+}

day08/src/com/inmind/static02/Demo10.java

@@ -0,0 +1,47 @@
+package com.inmind.static02;
+/*
+static关键字的使用：
+可以修饰成员变量和成员方法。
+1.使用static修饰成员变量的使用方式：只跟类有关，与对象无关了,并且该类的每个对象都共享了该变量的值
+静态成员变量的使用方式：
+    a.类名.静态变量名（推荐使用）
+    b.对象名.静态变量名（不推荐使用）
+
+2.使用static修饰成员方法的使用方式：只跟类有关，与对象无关了，并且该类的每个对象都可以直接调用静态方法
+    区分
+        a.自定义成员方法：（对象方法），它的定义是给每个对象来调用，必须通过创建对象来调用
+        b 静态方法：（类方法），它的定义是给对应的类直接调用，跟每个对象无关的操作
+  静态方法的使用方式：
+    a.类名.静态方法名(参数列表)（推荐使用）
+    b.对象名.静态方法名(参数列表)（不推荐使用）
+
+    静态方法的作用：静态方法调用的比较方便，不需要创建对象，常用于对应的工具类的抽取，在一个项目中有可能有特定的功能代码，到处都要用，抽取成静态方法，直接通过类名.静态方法名，直接调用功能即可。
+  ---------------------------------------------------
+
+静态方法调用的注意事项：
+1.静态方法可以直接访问类变量（静态变量）和静态方法。
+2.静态方法不能直接访问普通成员变量或成员方法。静态方法只能访问静态内容，反之，成员方法可以直接访问静态变量或静态方法。（先人(刘邦)不知道（张三）后人，后人（张三）是知道先人（刘邦）的）
+3.静态方法中，不能使用this关键字。
+
+static 修饰的内容：
+是随着类的加载而加载的，且只加载一次。(只跟类有关)
+存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。
+它优先于对象存在，所以，可以被所有对象共享。
+ */
+public class Demo10 {
+    public static void main(String[] args) {
+        //创建2个学生对象
+        Student s1 = new Student(1, 21, "刘备");
+        Student s2 = new Student(2, 22, "张飞");
+//        System.out.println(s1.classRoom);
+//        System.out.println(Student.classRoom);
+//        s1.classRoom = "1903室";
+
+        Student.showRoom();
+        Student.classRoom = "1903室";
+//        System.out.println(s2.classRoom);//"1903室"
+//        System.out.println(Student.classRoom);//"1903室"
+        Student.showRoom();
+
+    }
+}

day08/src/com/inmind/static02/Demo11.java

@@ -0,0 +1,40 @@
+package com.inmind.static02;
+/*
+静态代码块：
+定义在成员位置，使用static修饰的代码块{ }。
+位置：类中方法外。
+执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。
+
+格式：
+static{
+    java语句;
+}
+
+    静态代码块的作用：在程序运行之前，就进行一些操作，常用于对静态变量的初始化操作，后期工作中常用于对配置文件的值赋值操作
+ */
+public class Demo11 {
+    static  int num = 10;
+    String str;
+
+    static{
+        System.out.println("静态代码块执行了");
+        if (1 > 0) {
+            num = 200;
+        } else {
+            num = 300;
+        }
+        num = 100;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(num);
+        System.out.println("程序开始");
+        //创建1个学生
+        Student student = new Student();
+        System.out.println("程序结束");
+    }
+
+    public void test(){
+        System.out.println("呵呵哒");
+    }
+}

day08/src/com/inmind/static02/Student.java

@@ -0,0 +1,31 @@
+package com.inmind.static02;
+
+public class Student {
+    //属性（成员变量）
+     int id;
+     int age;
+     String name;
+     //静态变量
+    static String classRoom;
+    //行为（成员方法）
+    public  void show(){
+        String showStr = "学号为"+this.id+",年龄为"+age+"，姓名为"+this.name+"在"+classRoom+"教室上课";
+        System.out.println(showStr);
+        showRoom();
+    }
+    //静态方法
+    public static void showRoom(){
+        String showStr = "该同学在"+classRoom+"教室上课";
+        System.out.println(showStr);
+    }
+
+
+    public Student() {
+        System.out.println("学生类的无参构造方法调用了");
+    }
+    public Student(int id, int age, String name) {
+        this.id = id;
+        this.age = age;
+        this.name = name;
+    }
+}

day08/src/com/inmind/string01/Demo01.java

@@ -0,0 +1,29 @@
+package com.inmind.string01;
+/*
+常用类_String的概述和特点
+1.String类代表字符串。 Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。
+""双引号字符串就是String类的对象，所以就可以直接调用String类的方法
+2.字符串不变; 它们的值在创建后不能被更改。 因为String对象是不可变的，它们可以被共享。
+
+
+ */
+public class Demo01 {
+    public static void main(String[] args) {
+        //引用数据类型，保存的是地址
+        Student s1 = new Student();
+        Student s2 = new Student();
+        System.out.println(s1);//com.inmind.string01.Student@3b07d329
+        System.out.println(s1 == s2);//false,比较的是2个学生对象的地址
+
+        //定义一个String对象
+        String str = "abc";//str是一个对象名，是引用数据，str中保存的是地址
+        //str保存的是地址，由于println的重载方法，导致String类型的对象直接输出的是内容
+        System.out.println(str);
+
+        String str1 = "abc";//str1保存的是地址
+        System.out.println(str1);
+
+        System.out.println(str == str1);//比较的是地址，不是内容，true，因为string是常量，指向的是同一个地址
+
+    }
+}

day08/src/com/inmind/string01/Demo02.java

@@ -0,0 +1,38 @@
+package com.inmind.string01;
+/*
+String类的构造方法：创建String类的对象
+
+String(String original) 初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本
+public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
+public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。
+ */
+public class Demo02 {
+    public static void main(String[] args) {
+        //public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。
+//        byte[] bytes = {97,98,99,100};
+        byte[] bytes = {48,49,50,51};
+        //将字节数组的内容拼接成新的字符串(根据编码方式，将对应的十进制的值编码成字符串内容)
+        //使用场景：javase，io流知识点中的字节流中来使用
+        String str = new String(bytes);
+        System.out.println(str);//abcd:97根据ASCII码将十进制转为字符，再用字符拼接成字符串
+
+    }
+
+    private static void stringMethod2() {
+        //String(String original) 初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本
+        String str = "java";
+        String str1 = new String(str);
+        System.out.println(str);//java
+        System.out.println(str1);//java
+
+        System.out.println(str == str1);//false
+    }
+
+    private static void stringMethod1() {
+        //public String(char[] value) ：通过当前参数中的字符数组来构造新的String。(String就是一串字符)
+        char[] chars = {'a','b','c','d'};
+        //通过构造方法创建对象
+        String s = new String(chars);//s保存的是地址
+        System.out.println(s);//打印的是内容：abcd
+    }
+}

day08/src/com/inmind/string01/Demo03.java

@@ -0,0 +1,30 @@
+package com.inmind.string01;
+/*
+常用类_String的比较的方法_equals_equalsIgnoreCase
+
+String的比较：
+==：表示比较String对象的地址，其实没有任何意义，==一般用于基本数据类型的值是否相等比较
+equals：表示比较String对象地址所指向的内容
+
+比较的方法：
+public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
+public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小
+写。
+ */
+public class Demo03 {
+    public static void main(String[] args) {
+        String s1 = "abcd";
+        //通过构造方法创建s2
+        String s2 = new String(s1);
+        System.out.println(s1== s2);//false
+        //往往引用数据类型比较的是内容，不能使用==号来比较，它比较的是地址
+        boolean result = s1.equals(s2);
+        System.out.println(result);//true,比较的是地址指向的内容！！！！
+
+        System.out.println("----------------");
+        String s3 = "AbCd";
+        System.out.println(s1 == s3);//false
+        System.out.println(s1.equals(s3));//false
+        System.out.println(s1.equalsIgnoreCase(s3));//true
+    }
+}

day08/src/com/inmind/string01/Demo04.java

@@ -0,0 +1,67 @@
+package com.inmind.string01;
+/*
+常用类_String的获取方法_length_concat_charAt_indexOf_subString
+
+public int length () ：返回此字符串的长度。
+public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
+public char charAt (int index) ：返回指定索引处的 char值。
+public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
+public int indexOf(String str, int fromIndex)
+
+public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符
+串结尾。
+public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
+ */
+public class Demo04 {
+    public static void main(String[] args) {
+        //public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
+        //public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
+        String str = "123javahelloworld321";
+        //截取第一个helloworld,到字符串末尾的一个子字符串
+        String substring = str.substring(7);
+        System.out.println(substring);
+
+        //只截取helloworld作为子字符串
+        System.out.println(str.substring(7, 17));//java中包头不包尾
+
+    }
+
+    private static void method04() {
+        //public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
+        //public int indexOf(String str, int fromIndex)
+        String str = "123java321java54321";
+        //查询第一个j的位置
+        int index = str.indexOf("j");
+        System.out.println(index);//3
+        //查询第一个321的索引
+        index = str.indexOf("321");
+//        index = str.indexOf("abc"); 如果没有找到子字符串，返回-1
+        System.out.println(index);//7
+
+        //查询第二个321的索引
+        index = str.indexOf("321", 8);
+        System.out.println(index);//16
+    }
+
+    private static void method03() {
+        //public char charAt (int index) ：返回指定索引处的 char值。
+        String str = "helloworld";
+        //获取w这个字符
+        char c = str.charAt(5);
+        System.out.println(c);
+    }
+
+    private static void method02() {
+        //public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
+        String s1 = "hello";
+        String newStr = s1.concat("world");
+        System.out.println(newStr);//helloworld
+    }
+
+    private static void method01() {
+        //public int length () ：返回此字符串的长度。
+        String s = "123456";
+        System.out.println(s.length());//6
+        System.out.println("abc".length());//3
+    }
+}

day08/src/com/inmind/string01/Demo05.java

@@ -0,0 +1,39 @@
+package com.inmind.string01;
+/*
+String判断方法和获取方法的练习
+
+定义一个方法，动态的计算出第n个子字符串所在的索引，如果没有第n个，要显示出它一共有几个子字符串，返回-1表示找不到，如果
+有第n个就不用显示，直接返回索引即可。
+123123123321abc
+ 第3个"123"的索引   6
+ 第4个"123"的索引   -1  当前只有3个123
+
+ */
+public class Demo05 {
+    public static void main(String[] args) {
+        String str = "12a12b12c123";
+        int index = getIndex(str, "12", 2);
+        System.out.println(index);
+
+    }
+
+    public static  int getIndex(String str ,String subStr,int n){
+        //记录索引，为找下一个子字符串做准备
+        int index = 0;
+        //记录找到的次数
+        int count = 0;
+        for (int i = 0; i < n; i++) {
+            index = str.indexOf(subStr, index);
+            if (index != -1) {
+                count++;
+                index++;
+            } else {
+                System.out.println("在"+str+"中，只有"+count+"个子字符串"+subStr);
+                return  -1;
+            }
+        }
+
+        index--;
+        return index;
+    }
+}

day08/src/com/inmind/string01/Demo06.java

@@ -0,0 +1,40 @@
+package com.inmind.string01;
+/*
+常用类_String的转换方法_replace_toCharArray_getBytes
+
+
+public char[] toCharArray () ：将此字符串转换为新的字符数组。
+public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
+public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使
+用replacement字符串替换。
+ */
+public class Demo06 {
+    public static void main(String[] args) {
+        //public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。
+        String str = "今天，天气很好，我很高兴";
+        //把字符串中的所有“天”替换为*
+        String newStr = str.replace("天", "**");
+        System.out.println(str);
+        System.out.println(newStr);
+
+    }
+
+    private static void method2() {
+        //public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
+        String str = "abc";//a:97
+        byte[] bytes = str.getBytes();
+        for (int i = 0; i < bytes.length; i++) {
+            System.out.println(bytes[i]);// 97 98 99
+        }
+    }
+
+    private static void method1() {
+        //public char[] toCharArray () ：将此字符串转换为新的字符数组。
+        String str = "hello";
+        char[] chars = str.toCharArray();
+        for (int i = 0; i < chars.length; i++) {
+            System.out.println(chars[i]);
+        }
+        System.out.println(chars);//chars保存的是地址，直接打印字符数组，由于println方法的源码，导致打印字符数组中打印的内容
+    }
+}

day08/src/com/inmind/string01/Demo07.java

@@ -0,0 +1,25 @@
+package com.inmind.string01;
+/*
+常用类_String的分割方法_split
+public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组
+ */
+public class Demo07 {
+    public static void main(String[] args) {
+        //定义一个字符串
+        String str = "1,22,张三";
+        //按,切割，获取对应的属性值;   注意：按什么分割，该字符串就不会出现
+        String[] values = str.split(",");
+        System.out.println(values);
+        for (int i = 0; i < values.length; i++) {
+            System.out.println(values[i]);
+        }
+
+        //扩展：将字符串转为学生对象！！
+        String str1 = "2,21,李四";
+        String[] strings = str1.split(",");
+        Student s = new Student(Integer.parseInt(strings[0]), Integer.parseInt(strings[1]), strings[2]);
+        System.out.println(s.getId());
+        System.out.println(s.getAge());
+        System.out.println(s.getName());
+    }
+}

day08/src/com/inmind/string01/Student.java

@@ -0,0 +1,55 @@
+package com.inmind.string01;
+
+public class Student {
+    //属性（成员变量）
+    private int id;
+    private int age;
+    private String name;
+
+    //构造方法（无参和有参）
+
+    public Student() {
+    }
+
+    public Student(int id, int age, String name) {
+        this.id = id;
+        this.age = age;
+        this.name = name;
+    }
+
+    //行为（成员方法）
+
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void study(String book) {
+        System.out.println("在学习");
+    }
+
+    public void show(){
+        String showStr = "学号为"+this.getId()+",年龄为"+age+"，姓名为"+this.name;
+        System.out.println(showStr);
+    }
+}

day08/src/com/inmind/string01/Test08.java

@@ -0,0 +1,29 @@
+package com.inmind.string01;
+/*
+常用类_String的练习_拼接字符串
+定义一个方法，把数组{1,2,3}按照指定个格式拼接成一个字符串。
+格式参照如下：[值1#值2#值3]。
+
+ */
+public class Test08 {
+    public static void main(String[] args) {
+        String str = "a,b,c";
+        String result = toString(str.split(","));
+        System.out.println(result);
+    }
+
+    public static String toString(String[] arr){
+        //[值1#值2#值3]
+        String result = "[";
+        for (int i = 0; i < arr.length; i++) {
+            String temp = arr[i];
+            if (i == arr.length - 1) {
+                result = result.concat(temp + "]");
+            } else {
+                result = result.concat(temp + "#");
+            }
+        }
+
+        return result;
+    }
+}

day08/src/com/inmind/string01/Test09.java

@@ -0,0 +1,47 @@
+package com.inmind.string01;
+
+import java.util.Scanner;
+
+/*
+8.常用类_String的练习_统计字符个数
+键盘录入一个字符串，统计字符串中大小写字母及数字字符个数
+
+分析：
+1.scanner的使用
+2.接收一个字符串
+3.统计字符串中大小写字母及数字字符个数（获取字符串的每个字符来判断）
+ */
+public class Test09 {
+    public static void main(String[] args) {
+        //创建一个Scanner对象
+        Scanner sc = new Scanner(System.in);
+        System.out.println("请输入一串字符串：");
+        String str = sc.nextLine();//获取用户输入的一行字符串
+        int bigNum = 0;//大写字母的个数
+        int smallNum = 0;//小写字母的个数
+        int num = 0;//数字字符母的个数
+
+        //字符串转为字符数组
+        char[] chars = str.toCharArray();
+
+        for (int i = 0; i < chars.length; i++) {
+            char c = chars[i];
+            if (c >= 'A' && c <= 'Z') {
+                bigNum++;
+            }
+
+            if (c >= 'a' && c <= 'z') {
+                smallNum++;
+            }
+            if (c >= '0' && c <= '9') {
+                num++;
+            }
+        }
+
+        System.out.println("大写的字母：" + bigNum);
+        System.out.println("小写的字母：" + smallNum);
+        System.out.println("数字：" + num);
+
+    }
+
+}

day09/day09.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="17" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

day09/src/com/inmind/abstract06/Animal.java

@@ -0,0 +1,14 @@
+package com.inmind.abstract06;
+
+//抽象类
+public abstract  class Animal {
+
+    public Animal(){
+        System.out.println("animal抽象类的无参构造方法执行了");
+    }
+
+    //动物，请问，你吃什么？？
+    public abstract void eat();//抽象方法
+    public abstract void eat1();//抽象方法
+    public abstract void eat2();//抽象方法
+}

day09/src/com/inmind/abstract06/Cat.java

@@ -0,0 +1,4 @@
+package com.inmind.abstract06;
+
+public abstract class Cat extends Animal{
+}

day09/src/com/inmind/abstract06/Demo08.java

@@ -0,0 +1,28 @@
+package com.inmind.abstract06;
+/*
+如何使用抽象类和抽象方法？
+1.抽象类不能被创建，只能由子类“实现”了抽象类之后才能创建子类对象
+2.在子类中必须“实现重写”抽象类中的抽象方法
+3.这时创建子类的对象，并调用方法
+-------------------------------------------------
+注意事项：（在线教程中查看！！！！）
+1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象
+2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的
+3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类
+4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。
+---------------------------------------
+抽象类的意义
+抽象类的意义是对某一些功能添加约束
+重写，我已经实现了自己该有的功能，子类，可以在此基础选择性扩展功能
+ */
+public class Demo08 {
+    public static void main(String[] args) {
+        //创建一个动物类对象，调用它的eat方法
+//        Animal animal = new Animal();//错误抽象类不能创建对象
+        Dog dog = new Dog();
+        dog.eat();
+
+        HelloKitty kitty = new HelloKitty();
+        kitty.eat();
+    }
+}

day09/src/com/inmind/abstract06/Dog.java

@@ -0,0 +1,19 @@
+package com.inmind.abstract06;
+//alt+enter
+public class Dog extends Animal{
+
+    @Override
+    public void eat() {
+        System.out.println("狗吃骨头");
+    }
+
+    @Override
+    public void eat1() {
+
+    }
+
+    @Override
+    public void eat2() {
+
+    }
+}

day09/src/com/inmind/abstract06/HelloKitty.java

@@ -0,0 +1,18 @@
+package com.inmind.abstract06;
+
+public class HelloKitty extends Cat{
+    @Override
+    public void eat() {
+        System.out.println("我是动漫猫，不吃");
+    }
+
+    @Override
+    public void eat1() {
+
+    }
+
+    @Override
+    public void eat2() {
+
+    }
+}

day09/src/com/inmind/abstract06/test/Circle.java

@@ -0,0 +1,20 @@
+package com.inmind.abstract06.test;
+
+
+public class Circle extends Shape {
+
+    //定义一个有参构造，必须要求传入半径，交给父类来管理
+    public Circle(int r){
+        super(0,0,r);
+    }
+
+    @Override
+    public double getArea() {
+        return Math.PI*getR()*getR();
+    }
+
+    @Override
+    public double getZC() {
+        return 2*Math.PI*getR();
+    }
+}

day09/src/com/inmind/abstract06/test/Demo09.java

@@ -0,0 +1,31 @@
+package com.inmind.abstract06.test;
+/*
+- 定义形状抽象类Shape，矩形Rectangle和圆形Circle继承Shape类。
+- 圆形只能通过指定半径的方式，创建Circle对象。
+- 矩形只能通过指定长，宽的方法，创建Rectangle对象。
+
+并且计算出各自的面积和周长
+
+分析：
+1.Shape类是一个父类，可以将各种图形的属性抽取到该类中（比如长方形 的长宽，圆的半径）
+2.矩形Rectangle和圆形Circle继承Shape类，可以通过构造方法将指定的属性值传递给父类进行保存
+3.可以将面积和周长的方法实现定义为抽象方法，由指定的子类具体实现
+
+ */
+public class Demo09 {
+    public static void main(String[] args) {
+        //创建一个长方形对象
+        Rectangle rectangle = new Rectangle(4,2);
+        System.out.println("长方形的面积："+rectangle.getArea());
+        System.out.println("长方形的周长："+rectangle.getZC());
+        //创建一个圆形对象
+        Circle circle = new Circle(2);
+        System.out.println("圆形的面积："+circle.getArea());
+        System.out.println("圆形的周长："+circle.getZC());
+
+        //如何快速定义出一个正方型的类，还不用自己实现周长和面积的方法
+        Square square = new Square(2);
+        System.out.println("正方形形的面积："+square.getArea());
+        System.out.println("正方形形的周长："+square.getZC());
+    }
+}

day09/src/com/inmind/abstract06/test/Rectangle.java

@@ -0,0 +1,19 @@
+package com.inmind.abstract06.test;
+
+public class Rectangle extends Shape{
+
+    //定义一个有参构造，必须要求传入长宽，交给父类来管理
+    public Rectangle(int chang,int kuan){
+        super(chang,kuan,0);
+    }
+
+    @Override
+    public double getArea() {
+        return getChang()*getKuan();
+    }
+
+    @Override
+    public double getZC() {
+        return (getChang()+getKuan())*2;
+    }
+}

day09/src/com/inmind/abstract06/test/Shape.java

@@ -0,0 +1,46 @@
+package com.inmind.abstract06.test;
+
+public abstract class Shape {
+    //定义共性的属性：涵盖大部分形状的属性
+    private int chang;//矩形的长
+    private int kuan;//矩形的宽
+    private int r;//圆的半径
+
+    //满参构造：创建对象，对属性进行赋值
+    public Shape(int chang, int kuan, int r) {
+        this.chang = chang;
+        this.kuan = kuan;
+        this.r = r;
+    }
+
+    //提供get/set方法，对私有的属性进行操作
+    public int getChang() {
+        return chang;
+    }
+
+    public void setChang(int chang) {
+        this.chang = chang;
+    }
+
+    public int getKuan() {
+        return kuan;
+    }
+
+    public void setKuan(int kuan) {
+        this.kuan = kuan;
+    }
+
+    public int getR() {
+        return r;
+    }
+
+    public void setR(int r) {
+        this.r = r;
+    }
+
+    //计算面积的方法
+    public abstract double getArea();
+    //计算周长的方法
+    public abstract double getZC();
+
+}

day09/src/com/inmind/abstract06/test/Square.java

@@ -0,0 +1,10 @@
+package com.inmind.abstract06.test;
+
+public class Square extends Rectangle{
+
+    //定义一个有参构造，必须要求传入边长，交给父类来管理
+    public Square(int bc){
+        super(bc,bc);
+    }
+
+}

day09/src/com/inmind/extend01/Assistant.java

@@ -0,0 +1,8 @@
+package com.inmind.extend01;
+
+public class Assistant extends Employee{
+    //特有行为
+    public void help(){
+        System.out.println("年龄为"+age+",姓名为"+name+"帮助学生解决学习和生活上的问题");
+    }
+}

day09/src/com/inmind/extend01/BanZhuRen.java

@@ -0,0 +1,9 @@
+package com.inmind.extend01;
+
+public class BanZhuRen extends Employee{
+
+    //特有行为
+    public void manage(){
+        System.out.println("管理班级");
+    }
+}

day09/src/com/inmind/extend01/Demo01.java

@@ -0,0 +1,29 @@
+package com.inmind.extend01;
+/*
+继承：对同一类事物的相同的属性和行为，进行“共性抽取”
+
+继承的格式和和基本使用
+public class Fu{
+}
+public class Zi extends Fu{
+}
+
+继承的特点：子类拥有父类的所有内容，除了被private修饰的和构造方法。
+继承的好处：实现多个类中相同内容的复用,子类可以实现各自的不同功能需求
+
+ */
+public class Demo01 {
+    public static void main(String[] args) {
+        //创建一个老师对象
+        Teacher teacher = new Teacher();
+        teacher.name = "张三";
+        teacher.age = 30;
+        teacher.teach();
+
+        //创建一个辅导员
+        Assistant assistant = new Assistant();
+        assistant.name = "李四";
+        assistant.age = 32;
+        assistant.help();
+    }
+}

day09/src/com/inmind/extend01/Employee.java

@@ -0,0 +1,7 @@
+package com.inmind.extend01;
+
+public class Employee {
+    //属性
+    String name;
+    int age;
+}

day09/src/com/inmind/extend01/Teacher.java

@@ -0,0 +1,8 @@
+package com.inmind.extend01;
+
+public class Teacher extends Employee {
+    //特有行为
+    public void teach(){
+        System.out.println("年龄为"+age+",姓名为"+name+"老师来教学");
+    }
+}

day09/src/com/inmind/extend01/test/Animal.java

@@ -0,0 +1,11 @@
+package com.inmind.extend01.test;
+
+public class Animal {
+    String name;
+    int age;
+    String color;
+
+    public void eat(){
+        System.out.println("到点了，该吃饭了");
+    }
+}

day09/src/com/inmind/extend01/test/Cat.java

@@ -0,0 +1,7 @@
+package com.inmind.extend01.test;
+
+public class Cat extends Animal{
+    public void catchMouse(){
+        System.out.println("猫能抓老鼠");
+    }
+}

day09/src/com/inmind/extend01/test/Demo02.java

@@ -0,0 +1,31 @@
+package com.inmind.extend01.test;
+/*
+请大家使用继承描述一下，动物类，狗类，猫类，相同的
+属性：name age color
+行为：eat
+
+特有的行为：
+狗看门
+猫抓老鼠
+
+创建猫和狗对象，设置属性，并调用各自的方法
+ */
+public class Demo02 {
+    public static void main(String[] args) {
+        //创建一只狗
+        Dog dog = new Dog();
+        dog.name = "小黄";
+        dog.age = 1;
+        dog.color = "黄色";
+        dog.eat();
+        dog.watchDoor();
+
+        //创建一只猫
+        Cat cat = new Cat();
+        cat.name = "小白";
+        cat.age = 2;
+        cat.color = "白色";
+        cat.eat();
+        cat.catchMouse();
+    }
+}

day09/src/com/inmind/extend01/test/Dog.java

@@ -0,0 +1,8 @@
+package com.inmind.extend01.test;
+
+public class Dog extends Animal{
+
+    public void watchDoor(){
+        System.out.println("狗在看门");
+    }
+}

day09/src/com/inmind/extends_contructor04/Demo06.java

@@ -0,0 +1,35 @@
+package com.inmind.extends_contructor04;
+/*
+继承中构造方法的访问特点
+1.创建子类对象时，一定会调用父类的构造方法
+2.super调用父类的构造方法时，必须在子类的构造方法的第一行
+3.super可以调用父类的有参构造方法。
+
+----------------------------------------------------
+super三个使用操作：
+1.super,可以在子类的成员方法中，访问父类的成员变量，格式super.父类成员变量
+2.super,可以在子类的成员方法中，访问父类的成员方法，格式：super.父类成员方法名(参数列表)
+3.super,可以在子类的构造方法中，访问父类的构造方法，格式：super(参数列表)
+----------------------------------------------------
+谁调用方法，方法中的this就是谁（对象）
+this表示本类，super表示父类
+
+this关键字使用方式
+1.this,可以区分当前类中局部变量和成员变量
+2.this,可以在本类的成员方法中，调用该类的其他的成员方法(其实在一个类中所有的成员变量和成员方法的调用之前都有this.)
+3.this,可以在本类的构造方法中，调用其他的重载构造方法
+
+关于第三点的注意事项：
+    a.this必须在第一行，不能调用自己构造方法（自己不能调用自己）
+    b.this和super在调用构造方法时，都必须在第一行，所以在一个构造方法中不能同时出现
+    c.this可以调用其他的重载构造方法，但是不能互相调用（死循环）
+
+ */
+public class Demo06 {
+    public static void main(String[] args) {
+        Fu fu = new Fu();
+        System.out.println("------");
+        Zi zi = new Zi();
+        System.out.println("程序结束");
+    }
+}

day09/src/com/inmind/extends_contructor04/Fu.java

@@ -0,0 +1,17 @@
+package com.inmind.extends_contructor04;
+
+public class Fu {
+    String name;
+    int age;
+    //默认无参构造
+    public Fu(){
+        System.out.println("父类无参构造方法被调用了");
+    }
+
+    public Fu(String name,int age){
+        System.out.println("父类有参构造方法被调用了");
+        this.name = name;
+        this.age = age;
+    }
+
+}

day09/src/com/inmind/extends_contructor04/Zi.java

@@ -0,0 +1,25 @@
+package com.inmind.extends_contructor04;
+
+public class Zi extends Fu{
+    //默认无参构造
+    public Zi(){
+        this("张三");
+//        super("张飞",20);
+        System.out.println("子类无参构造方法被调用了");
+    }
+
+    public Zi(String name){
+//        super("张飞",20);
+        System.out.println("子类无参构造方法被调用了");
+    }
+
+    public void test(){
+        this.test2();
+    }
+
+    public void test1(){
+    }
+
+    public void test2(){
+    }
+}

day09/src/com/inmind/extends_memberv02/Demo03.java

@@ -0,0 +1,24 @@
+package com.inmind.extends_memberv02;
+/*
+继承中成员变量的访问特点
+1.直接通过对象去访问，看对象创建语句=左边的内容，是谁就优先使用谁的成员变量，如果没有则向上找
+2.间接通过对象调用成员方法去访问，调用时，方法属于谁，就优先使用谁的成员变量，如果没有则向上找
+
+继承中成员方法的访问特点:
+    在继承中访问成员方法时，new的是谁，就优先使用谁的成员方法，如果没有则向上找
+
+ */
+public class Demo03 {
+    public static void main(String[] args) {
+        //创建一个子类对象
+        Zi zi = new Zi();
+        System.out.println(zi.numZi);//展示子类中的成员变量20
+        System.out.println(zi.numFu);//展示父类中的成员变量10
+        System.out.println(zi.num);//展示子类中的成员变量40
+
+        zi.methodZi();
+        zi.methodFu();
+        System.out.println("---------------");
+        zi.method();
+    }
+}

day09/src/com/inmind/extends_memberv02/Fu.java

@@ -0,0 +1,11 @@
+package com.inmind.extends_memberv02;
+
+public class Fu {
+    int numFu = 10;
+    int num = 30;
+
+    public void methodFu(){
+        System.out.println(numFu);
+        System.out.println(num);
+    }
+}

day09/src/com/inmind/extends_memberv02/Zi.java

@@ -0,0 +1,23 @@
+package com.inmind.extends_memberv02;
+/*
+区分子类方法中重名的三种变量
+ */
+
+public class Zi extends Fu{
+    int numZi = 20;
+    int num = 40;
+
+    public void methodZi(){
+        System.out.println(numZi);
+        System.out.println(numFu);
+        System.out.println(num);
+    }
+
+    public void method(){
+        int num = 50;//局部变量
+        //注意：在java中访问变量时遇到同名变量有个规律：就近原则
+        System.out.println(num);
+        System.out.println(this.num);//获取本类的成员变量
+        System.out.println(super.num);//获取父类的成员变量
+    }
+}

day09/src/com/inmind/extends_override03/Demo04.java

@@ -0,0 +1,20 @@
+package com.inmind.extends_override03;
+/*
+继承中的重写：
+重载(overload):在同一个类中，方法名相同，参数列表不同
+重写(override)：在父子类中，方法名相同，参数列表相同（重写，覆盖重写，覆写）
+
+成员方法的访问特点：在父子类中，通过对象去访问成员方法，new后面是谁，优先使用谁的成员方法，没有则向上找
+
+重写的注意事项：
+权限：public>protected>(default)不写就是默认>private
+1. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
+2.private的内容不能被继承，所以也就没有重写概念
+3.返回值类型、方法名和参数类型必须一致
+ */
+public class Demo04 {
+    public static void main(String[] args) {
+        Zi zi = new Zi();
+        zi.method();
+    }
+}

day09/src/com/inmind/extends_override03/Fu.java

@@ -0,0 +1,7 @@
+package com.inmind.extends_override03;
+
+public class Fu {
+    public void method(){
+        System.out.println("父类的method方法");
+    }
+}

day09/src/com/inmind/extends_override03/Zi.java

@@ -0,0 +1,9 @@
+package com.inmind.extends_override03;
+
+public class Zi extends Fu{
+
+    @Override //验证当前方法是否是一个重写方法
+    public void method(){
+        System.out.println("子类的method方法");
+    }
+}

day09/src/com/inmind/extends_override03/test/Demo05.java

@@ -0,0 +1,22 @@
+package com.inmind.extends_override03.test;
+
+import java.awt.print.PrinterJob;
+
+/*
+重写的应用案例
+ */
+public class Demo05 {
+    public static void main(String[] args) {
+        //创建一个旧手机
+        Phone phone = new Phone();
+        phone.call();
+        phone.send();
+        phone.showNumber();
+
+        //创建一个新手机
+        NewPhone newPhone = new NewPhone();
+        newPhone.call();
+        newPhone.send();
+        newPhone.showNumber();
+    }
+}

day09/src/com/inmind/extends_override03/test/NewPhone.java

@@ -0,0 +1,14 @@
+package com.inmind.extends_override03.test;
+
+public class NewPhone extends Phone{
+    //对原本的功能call()send()进行了沿用
+
+    //对原本的来电显示要扩展新的功能
+    @Override
+    public void showNumber(){
+        //要求：显示电话号码要沿用，扩展显示头像和归属地
+        super.showNumber();
+        System.out.println("显示头像");
+        System.out.println("显示归属地");
+    }
+}

day09/src/com/inmind/extends_override03/test/Phone.java

@@ -0,0 +1,15 @@
+package com.inmind.extends_override03.test;
+
+public class Phone {
+    public void call(){
+        System.out.println("打电话");
+    }
+
+    public void send(){
+        System.out.println("发短信");
+    }
+
+    public void showNumber(){
+        System.out.println("显示电话号码");
+    }
+}