JavaSE代码

01-JavaSE阶段代码/J20250714/API文档.txt

@@ -0,0 +1,6 @@
+API(Application Programing Interface) 应用程序编程接口
+JDK1.8-API，就是一个API文档就是一个使用说明书
+
+Java的API
+就是Java提供的各种功能的Java类，类的底层被封装起来了。
+不用关心是怎么实现的。会用就可以了。

01-JavaSE阶段代码/J20250714/String类常用方法.txt

@@ -0,0 +1,7 @@
+作业1：挨个使用String的以下方法：
+String类常用方法，
+1、charAt(int index) 返回 char指定索引处的值。
+2、toCharArray()  返回一个字符数组
+3、subString(int beginIndex, int endIndex)
+从beginIndex开始到endIndex结束，返回一个字符串，该字符串是此字符串的子字符串。
+4、split(String regex)将这个字符串拆分为指定的字符串。

01-JavaSE阶段代码/J20250714/demo01/Demo03.java

@@ -0,0 +1,17 @@
+package J20250714.demo01;
+
+import J20250714.demo02.Demo01;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo03
+ * @description
+ * @create 2025/7/14
+ */
+public class Demo03 {
+    public static void main(String[] args) {
+        Demo01 demo01=new Demo01();
+
+    }
+}

01-JavaSE阶段代码/J20250714/demo01/Person.java

@@ -0,0 +1,55 @@
+package J20250714.demo01;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Person
+ * @description 创建一个Person类
+ * @create 2025/7/14
+ */
+public class Person {
+    //属性
+    String name;
+
+    //我们的最终目的是让别人能复制，但是不能随便赋值
+    //1、在age前面加private修饰符-->外部不能赋值，内部可以赋值
+    //2、实现外部可以赋值
+    //3、加以赋值的限制
+
+    private int age;    //把这个age属性的权限变为私有的，也就是说只有在本类中，才能被使用
+    //为年龄赋值的方法
+    public void setAge(int age){
+        //如果age前面不加this，那么由于就近原则，指向都是局部变量(参数)age
+        //加了this.就说明这个age是对象的成员属性age。
+        //this的含义就是当前对象。
+        //这种方式赋值的好处，就是可以在方法中进行限制，比如加一个if判断
+        if(age>0&&age<125){
+            this.age=age;
+        }else {
+            System.out.println("年龄赋值有误");
+        }
+    }
+
+    //获取年龄的方法
+    public int getAge(){
+        return this.age;
+    }
+
+
+
+
+    //行为
+    public void eat(String sw){
+        System.out.println("我今天早上吃"+sw);
+    }
+    public void sleep(){
+        System.out.println("我喜欢睡觉");
+    }
+    public String work(String nr){
+        String s="我今天做"+nr+"工作，收获很多，各种摸鱼";
+        return s;
+    }
+    public String play(){
+        return "玩啥都开心";
+    }
+}

01-JavaSE阶段代码/J20250714/demo01/Phone.java

@@ -0,0 +1,25 @@
+package J20250714.demo01;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Phone
+ * @description
+ * @create 2025/7/14
+ */
+public class Phone {
+    String brand;//品牌
+    double price;
+    public void call(String name){
+        System.out.println("给"+name+"打电话");
+    }
+    public void sendMessage(){
+        System.out.println("发送消息");
+    }
+    public void method(){
+        ///////
+        /////
+        ////
+
+    }
+}

01-JavaSE阶段代码/J20250714/demo01/TestPerson.java

@@ -0,0 +1,19 @@
+package J20250714.demo01;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title TestPerson
+ * @description
+ * @create 2025/7/14
+ */
+public class TestPerson {
+    public static void main(String[] args) {
+        Person p=new Person();
+        p.name="张三";
+        //p.age=256;  //赋值是符合Java要求的。但是跟我们的业务是不符的
+        p.setAge(56);
+        int a=p.getAge();
+        System.out.println(a);
+    }
+}

01-JavaSE阶段代码/J20250714/demo01/TestPhone.java

@@ -0,0 +1,23 @@
+package J20250714.demo01;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title TestPhone
+ * @description
+ * @create 2025/7/14
+ */
+public class TestPhone {
+    public static void main(String[] args) {
+        Phone p=new Phone();
+        p.brand="大米";
+        p.price=128.6;
+
+        p.sendMessage();
+        p.call("张三");
+    }
+}
+
+
+
+

01-JavaSE阶段代码/J20250714/demo02/Demo01.java

@@ -0,0 +1,17 @@
+package J20250714.demo02;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description
+ * @create 2025/7/14
+ */
+public class Demo01 {
+    private String name;
+    int age;
+
+    public void setAge(int age){
+        this.age=age;
+    }
+}

01-JavaSE阶段代码/J20250714/demo02/Demo02.java

@@ -0,0 +1,19 @@
+package J20250714.demo02;
+
+import J20250714.demo01.Person;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description
+ * @create 2025/7/14
+ */
+public class Demo02 {
+    public static void main(String[] args) {
+        Demo01 demo01=new Demo01();
+        demo01.age=25;
+        Person p=new Person();
+
+    }
+}

01-JavaSE阶段代码/J20250714/demo03/Person.java

@@ -0,0 +1,34 @@
+package J20250714.demo03;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Person
+ * @description
+ * @create 2025/7/14
+ */
+public class Person {
+    private String name;
+    private int gae;
+    //java会默认为所有类的都创建一个构造方法，构造方法的修饰符是根据类的修饰符决定的。
+    public Person(){
+        System.out.println("我创建了"+this+"对象");
+    }
+
+    public void setName(String name){
+        this.name=name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getGae() {
+        return gae;
+    }
+
+    public void setGae(int gae) {
+        this.gae = gae;
+    }
+
+}

01-JavaSE阶段代码/J20250714/demo03/Student.java

@@ -0,0 +1,51 @@
+package J20250714.demo03;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Student
+ * @description
+ * @create 2025/7/14
+ */
+public class Student {
+
+    private String id;
+    private String name;
+    private int age;
+
+    //构造方法
+    //  创建一个学生对象
+    public Student(){   //无参构造方法
+        System.out.println("我是一个学生对象");
+    }
+    //有参构造方法
+    public Student(String id,String name,int age){
+        this.id=id;
+        this.name=name;
+        this.age=age;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+}

01-JavaSE阶段代码/J20250714/demo03/Teacher.java

@@ -0,0 +1,52 @@
+package J20250714.demo03;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * 这个类是教师的类，里面包含了3个成员属性 id、name、age
+ *
+ * @title Teacher
+ * @description
+ * @create 2025/7/14
+ */
+public class Teacher {
+
+    private String id;
+    private String name;
+    private int age;
+    //Alt键+insert键
+    //鼠标右键点击，展示选项列表，选择generate选项，可以展开生成弹窗
+
+    public Teacher() {
+    }
+
+    public Teacher(String id, String name, int age) {
+        this.id = id;
+        this.name = name;
+        this.age = age;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+}

01-JavaSE阶段代码/J20250714/demo03/TestPerson.java

@@ -0,0 +1,25 @@
+package J20250714.demo03;
+
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title TestPerson
+ * @description
+ * @create 2025/7/14
+ */
+public class TestPerson {
+    public static void main(String[] args) {
+        //创建Person的对象
+        //Java中的引用数据类型变量，默认值都是null空。
+        Person p=null;//创建一个Person类型的变量p
+        p=new Person(); //为变量p赋值，赋值的是创建的Person对象
+        //创建对象其实是调用了Person类的构造方法来实现的。
+        System.out.println(p);
+        System.out.println(new Person());
+        System.out.println(new Person());
+        System.out.println(new Person());
+        System.out.println(new Person());
+    }
+
+}

01-JavaSE阶段代码/J20250714/demo03/TestString.java

@@ -0,0 +1,38 @@
+package J20250714.demo03;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title TestString
+ * @description
+ * @create 2025/7/14
+ */
+public class TestString {
+    public static void main(String[] args) {
+        String ss1=new String("张三");
+        String ss2=new String("张三");
+        //使用==进行比较字符串对象，比较的是对象的地址
+        System.out.println(ss1==ss2);   //都是创建了对象，地址不一样，肯定不是一个对象
+
+        String s1="张三"; //其实走的是字符串常量池
+        String s2="张三";//再定义一个变量的时候，
+        // 会先再常量池里找是否存在这个值，如果有，就直接引用
+        //System.out.println(s1==s2);
+
+        char[] arr={'h','e','l','l','o'};
+        String ss3=new String(arr);
+        System.out.println(ss3);
+
+        //一般来讲，我们创建了某个对象，或使用Java提供的某个类创建的对象。输出这个对象的时候
+        //输出的都是这个对象的地址值。
+        Teacher t=new Teacher();
+        System.out.println(t);
+        //但是String字符串比较特殊，输出的不是地址值，而是字符串内容。
+        //因为String类在继承了Java中所有类的祖宗类(Object)类之后，重新了某一个方法。
+
+        //使用equals(String s)方法，比较两个字符串的时候，比较的就是字符串内容。
+        System.out.println(ss1.equals(ss2));
+
+
+    }
+}

01-JavaSE阶段代码/J20250714/demo03/TestTeacher.java

@@ -0,0 +1,18 @@
+package J20250714.demo03;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title TestTeacher
+ * @description
+ * @create 2025/7/14
+ */
+public class TestTeacher {
+    public static void main(String[] args) {
+        //需求：先创建教师对象，暂时不进行年龄赋值。
+        Teacher t=new Teacher("t00001","张三",26);
+        System.out.println(t.getAge());
+        t.setAge(62);
+        System.out.println(t.getAge());
+    }
+}

01-JavaSE阶段代码/J20250714/demo04/Demo01.java

@@ -0,0 +1,53 @@
+package J20250714.demo04;
+
+import java.util.Scanner;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description
+ *
+ * 案例1：
+ *     需求：已知用户名和密码，编写程序实现模拟用户登录。总共给3次机会，登录后给出相应提示。
+ *     步骤：
+ *         1、已知用户名和密码，定义两个字符串。
+ *         2、键盘输入要登录的用户名和密码，使用Scanner实现
+ *         3、用键盘输入的用户名、密码和已知的用户名、密码进行比较，给出相应提示
+ *         4、字符串内容比较，使用equals进行比较。
+ *         5、使用循环实现多次机会，次数明确，for循环，登录成功，就用break跳出循环。
+ *
+ *
+ * @create 2025/7/14
+ */
+public class Demo01 {
+    public static void main(String[] args) {
+        //用户名、密码
+        String username="admin";
+        String password="admin123456";
+        //利用键盘输入要登录的用户名和密码，使用Scanner实现
+        Scanner sc=new Scanner(System.in);
+        //调用方法获取键盘输入的用户名和密码
+        //sc.nextInt();//获取键盘输入的整数
+        //sc.nextDouble();//获取键盘输入的小数
+        //sc.next();//获取键盘输入的一段字符串(包含整数、小数、符号....)，以空格为结束符
+        //sc.nextLine();//获取键盘输入的一行字符串  以回车为结束符。
+        for (int i = 1; i <= 3; i++) {
+            //每一次都要输入用户名和密码
+            String scUsername=sc.nextLine();
+            String scPassword=sc.nextLine();
+            if (username.equals(scUsername)&&password.equals(scPassword)){
+                System.out.println("登录成功");
+                break;
+            }else {
+                if (i==3){
+                    System.out.println("你今日登录次数已经达到上限，请明天再来");
+                    break;
+                }
+                System.out.println("登录失败，用户名或密码错误，今天还剩"+(3-i)+"次机会");
+            }
+        }
+
+
+    }
+}

01-JavaSE阶段代码/J20250714/demo04/Demo02.java

@@ -0,0 +1,16 @@
+package J20250714.demo04;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description
+ * @create 2025/7/14
+ */
+public class Demo02 {
+    public static void main(String[] args) {
+        String s="hello";
+        char c = s.charAt(0);
+        System.out.println(c);
+    }
+}

01-JavaSE阶段代码/J20250714/封装思想.txt

@@ -0,0 +1,25 @@
+1、什么是封装？
+面向对象的语言有三大特征：封装、继承、多态
+面向对象思想的编程语言，本身的目的就是对客观事物模拟。
+外界是无法直接操作内部细节。
+封装就是把自身的细节隐藏起来，暴露出可以被使用的接口。
+封装原则：就是把类的信息隐藏在内部。不允许外部成员直接访问。
+但是可以通过类提供的方法进行访问。
+封装的好处：
+可以通过方法来控制成员变量的操作，提高代码的安全性
+把代码使用方法封装。提高代码的复用性。
+
+
+封装的具体使用：
+类中成员(类中的属性和方法)的权限修饰符：
+分别是四种访问权限修饰符：
+private：本类中可以访问
+default：本类中可以访问，同一包中可以访问，不允许跨包访问，不用任何修饰符就是default
+protected：本类中可以访问，同一包中可以访问，不允许正常的跨包访问，
+但是允许跨包继承，非同包的子类是可以继承的。
+public: 任意位置都可以访问的
+
+如果是修饰类本身，那么访问权限修饰符就只有两种：
+public：任意位置都可以访问的
+default：不加任何修饰的，默认的，同一包中可以访问，不允许跨包访问
+

01-JavaSE阶段代码/J20250714/构造方法.txt

@@ -0,0 +1,66 @@
+构造方法：
+其实就是构造Java对象的时候使用的方法。
+也就是我们创建一个对象的时候需要调用的方法就是构造方法。
+
+格式：
+    1、构造方法的方法名和类名完全一致，单词大小写全相同。
+    2、构造方法不需要定义返回值类型，甚至连void都不需要
+    (因为构造方法的返回值类型早就确定了，就是这个构造方法所属的类的类型)
+    3、没有具体的返回值，不能使用return
+
+什么时候执行？
+    构造方法，当创建对象的时候就会被调用，就会执行，每当创建一次对象，就会执行一次构造方法。
+    不能手动调用构造方法
+
+注意：
+    如果我们没有编写构造方法，那么系统会提供一个默认的构造方法。
+    如果我们编写了构造方法，那么系统就不会提供了。
+
+
+        //构造方法
+        //  创建一个学生对象
+        public Student(){   //无参构造方法
+            System.out.println("我是一个学生对象");
+        }
+        //有参构造方法
+        public Student(String id,String name,int age){
+            this.id=id;
+            this.name=name;
+            this.age=age;
+        }
+
+
+建议：
+    我们无论是否使用构造方法，都自己编写一个无参的构造方法一个有参的构造方法。
+
+
+一个完整的实体类(映射某一类事物的类)一般都要包含以下内容：
+    1、类的成员属性
+    2、成员属性的set方法和get方法
+    3、无参的构造方法、有参的构造方法
+
+
+案例1：
+    需求：已知用户名和密码，编写程序实现模拟用户登录。登录后给出相应提示。
+    步骤：
+        1、已知用户名和密码，定义两个字符串。
+        2、键盘输入要登录的用户名和密码，使用Scanner实现
+        Scanner sc=new Scanner(System.in);
+        3、用键盘输入的用户名、密码和已知的用户名、密码进行比较，给出相应提示
+        sc.next();//获取键盘输入的字符串
+        4、字符串内容比较，使用equals进行比较。
+
+
+
+
+
+案例1：
+    需求：已知用户名和密码，编写程序实现模拟用户登录。总共给3次机会，登录后给出相应提示。
+    步骤：
+        1、已知用户名和密码，定义两个字符串。
+        2、键盘输入要登录的用户名和密码，使用Scanner实现
+        3、用键盘输入的用户名、密码和已知的用户名、密码进行比较，给出相应提示
+        4、字符串内容比较，使用equals进行比较。
+        5、使用循环实现多次机会，次数明确，for循环，登录成功，就用break跳出循环。
+
+

01-JavaSE阶段代码/J20250715/StringBuilder可变字符串.txt

@@ -0,0 +1,35 @@
+StringBuilder可变字符串
+StringBuilder是一种可变长度的字符串类，可以把它看成一个容器，可变就是StringBuilder对象的内容是可以变化的。
+StringBuilder和String的区别：
+1、StringBuilder内容可变
+2、String内容不可变
+
+StringBuilder的构造方法：
+    StringBuilder() 构造一个没有字符的StringBuilder对象，初始容量为16个字符。
+    StringBuilder(String str) 构造一个初始化为指定字符串内容的StringBuilder对象。
+
+StringBuilder的常用方法：
+    append(任意类型) 将参数的字符串表示附加到StringBuilder字符串序列中。
+    reverse() 字符串反转。
+
+StringBuilder和String之间进行转换：
+    StringBuilder-》String   ： toString()方法就可以实现转换
+    String-》StringBuilder   ：通过构造方法StringBuilder(String str) 就可以实现
+
+
+
+StringBuilder实验案例：
+需求：
+    定义一个方法，把int数组种的数据，按照指定的格式拼接成一个字符串返回，调用这个方法
+    并且在控制台输入结果，比如数组：int[] arr={1,2,3}; 输出的结果为："[1,2,3]"
+实现步骤：
+    1、定义一个int类型数组，用静态初始化方式进行数组元素的初始化
+    2、定义一个方法，用来把数组种的数据按照格式进行拼接，拼接为一个字符串返回
+        方法的返回值类型String, 参数列表是int[] arr；
+    3、在方法中实验StringBuilder按照要求进行拼接，并且把结果转化为String返回。
+    4、调用方法，用一个变量接收结果
+    5、输出结果
+    public String arrayToString(int[] arr){
+
+    }
+

01-JavaSE阶段代码/J20250715/String常用方法.txt

@@ -0,0 +1,11 @@
+equals()方法：比较两个字符串是否内容一致，严格区分大小写
+length()方法：返回字符串的长度
+equalsIgnoreCase() ：比较两个字符串是否一致，不区分大小写
+charAt():返回指定索引位置的字符
+toCharArray():返回一个字符数组
+substring(beginIndex,endIndex):从开始位置到结束位置进行截取字符串，返回截取后的字符串。
+比如字符串：abcdef  substring(2,5)  得到的结果为：cde
+substring(beginIndex):从索引值位置截取到结尾
+split(regex):根据传入的字符串(也可以是正则表达式)进行切割，返回分隔后的字符串数组
+replace(CharSequence target, CharSequence replacement)  将字符串中所有的target都换成replacement
+比如字符串：hello world replace("l", "z") 得到结果：hezzo worzd

01-JavaSE阶段代码/J20250715/_static/Demo01.java

@@ -0,0 +1,27 @@
+package J20250715._static;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description
+ * @create 2025/7/15
+ */
+public class Demo01 {
+    static int a=10;
+
+    public static void method(){
+        System.out.println("哈哈哈哈哈");
+    }
+    public static void main(String[] args) {
+        System.out.println(a);
+        method();
+        Person p1=new Person("张三",25);
+
+        Person p2=new Person("李四",88);
+        System.out.println(Person.name);
+        System.out.println(p1.getName());
+
+        System.out.println(p2.getName());
+    }
+}

01-JavaSE阶段代码/J20250715/_static/Person.java

@@ -0,0 +1,37 @@
+package J20250715._static;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Person
+ * @description
+ * @create 2025/7/15
+ */
+public class Person {
+    static String name;
+    int age;
+
+    public Person() {
+    }
+
+    public Person(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+}

01-JavaSE阶段代码/J20250715/_static/static修饰符静态的.txt

@@ -0,0 +1,14 @@
+static 是一种修饰符，可以修饰属性或方法
+也可以叫static关键字。含义就是静态的意思。
+
+被static修饰的特点：
+    1、如果static修饰某个属性变量，那么这个变量会被类的所有对象共享
+    2、如果static修饰某个属性变量，那么这个变量会随着类的加载而加载，优于对象先加载。
+    3、因为对象是需要等类加载完毕后，才创建。
+    4、如果static修饰某个属性变量，那么这个变量可以通过类名直接调用。不需要对象调用。
+
+注意：
+    static可以修饰变量，也可以修饰方法。不论修饰哪个，该成员都是属于类的。
+    static修饰的方法，称为静态方法，静态方法只能访问静态的成员变量或成员方法。
+    没有被static修饰的方法，称为非静态方法，非静态方法可以访问静态成员变量或成员方法，也可以访问非静态的。
+    静态方法中是没有this关键字。

01-JavaSE阶段代码/J20250715/extend/Animal.java

@@ -0,0 +1,14 @@
+package J20250715.extend;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Animal
+ * @description 动物类 是父类
+ * @create 2025/7/15
+ */
+public class Animal {
+    public void animalMethod(){
+        System.out.println("动物的方法");
+    }
+}

01-JavaSE阶段代码/J20250715/extend/Bird.java

@@ -0,0 +1,12 @@
+package J20250715.extend;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Bird
+ * @description 鸟类 子类
+ * @create 2025/7/15
+ */
+public class Bird extends Animal{
+
+}

01-JavaSE阶段代码/J20250715/extend/Dog.java

@@ -0,0 +1,14 @@
+package J20250715.extend;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Dog
+ * @description 狗类 子类
+ * @create 2025/7/15
+ */
+public class Dog extends Animal{
+    public void dogMethod(){
+        System.out.println("狗的方法");
+    }
+}

01-JavaSE阶段代码/J20250715/extend/Main.java

@@ -0,0 +1,17 @@
+package J20250715.extend;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Main
+ * @description
+ * @create 2025/7/15
+ */
+public class Main {
+    public static void main(String[] args) {
+        Teddy teddy=new Teddy();
+        teddy.teddyMethod();
+        teddy.dogMethod();
+        teddy.animalMethod();
+    }
+}

01-JavaSE阶段代码/J20250715/extend/Teddy.java

@@ -0,0 +1,14 @@
+package J20250715.extend;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Teddy
+ * @description
+ * @create 2025/7/15
+ */
+public class Teddy extends Dog{
+    public void teddyMethod(){
+        System.out.println("泰迪的方法");
+    }
+}

01-JavaSE阶段代码/J20250715/extend/继承.txt

@@ -0,0 +1,36 @@
+面向对象的三大特征：
+封装
+继承
+多态
+
+继承：
+可以让子类具有父类的特征(属性和方法)，还可以在子类中重新定义，
+甚至追加属性和方法
+
+
+继承的格式：
+    继承的关键字：extends
+    格式：
+        class 子类 extends 父类{
+        }
+    比如：
+        class Dog extends Animal{
+
+        }
+继承的好处：
+    1、提高代码的复用性
+    2、提高代码的可维护性
+继承的弊端：
+    继承让类和类之间产生了关系，增加了【耦合性】
+    以后我们会用很多的时间和手段和技术，想办法解耦
+    当父类发生了变化，子类也不得不跟着进行变化。削弱了子类的独立性。
+
+继承是一种 is...a的关系   是...一个    子类是一种父类
+    [马]是一个[动物]
+    [老师]是一个[动物]
+    [人]是一个[动物]
+    [老师]是一个[人]
+
+注意：
+    Java中只能够单继承，也就是一个子类只能有一个直接父类。
+    Java支持多重继承，也就是A继承B，B继承C，C继承D.....

01-JavaSE阶段代码/J20250715/homework/Demo01.java

@@ -0,0 +1,26 @@
+package J20250715.homework;
+
+import java.util.Scanner;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description 遍历字符串案例
+ * @create 2025/7/15
+ */
+public class Demo01 {
+    public static void main(String[] args) {
+        System.out.println("请输入一段字符串....");
+        //创建Scanner对象
+        Scanner sc=new Scanner(System.in);
+        //获取字符串的长度的方法：字符串变量.length();
+        String s = sc.nextLine();
+        int length=s.length();  //获取s字符串的长度，赋值给一个整型变量
+        for (int i = 0; i < length; i++) {
+            char c=s.charAt(i);
+            System.out.println(c);
+        }
+    }
+
+}

01-JavaSE阶段代码/J20250715/homework/Demo02.java

@@ -0,0 +1,23 @@
+package J20250715.homework;
+
+import java.util.Scanner;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description toCharArray()方法
+ * @create 2025/7/15
+ */
+public class Demo02 {
+    public static void main(String[] args) {
+        System.out.println("请输入一段字符串....");
+        //创建Scanner对象
+        Scanner sc=new Scanner(System.in);
+        String s = sc.nextLine();
+        char[] chars = s.toCharArray();
+        for (int i = 0; i < chars.length; i++) {
+            System.out.println(chars[i]);
+        }
+    }
+}

01-JavaSE阶段代码/J20250715/homework/Demo03.java

@@ -0,0 +1,33 @@
+package J20250715.homework;
+
+import java.util.Scanner;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo03
+ * @description subString(int beginIndex, int endIndex) 方法
+ * @create 2025/7/15
+ */
+public class Demo03 {
+    public static void main(String[] args) {
+        /*
+        String s="123456789";
+        //substring()方法只有一个参数的时候，是截取前n个字符，返回剩下的字符串
+        String s1 = s.substring(3);
+        System.out.println("截取到3的字符串为："+s1);
+        //substring()方法两个参数的时候，从索引值0开始，到前一个参数为止，前面的字符不要了
+        //到后一个参数位置，后面的不要了，只要中间的字符串。
+        String s2=s.substring(2,6);
+        System.out.println("截取从2开始到6结束的字符串为："+s2);
+
+         */
+        System.out.println("请输入一段字符串....");
+        //创建Scanner对象
+        Scanner sc=new Scanner(System.in);
+        String s = sc.nextLine();
+        String start = s.substring(0, 3);
+        String end = s.substring(7);
+        System.out.println(start+"****"+end);
+    }
+}

01-JavaSE阶段代码/J20250715/homework/Demo04.java

@@ -0,0 +1,40 @@
+package J20250715.homework;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo04
+ * @description split(String regex) 方法
+ * @create 2025/7/15
+ */
+public class Demo04 {
+    public static void main(String[] args) {
+        /*
+        String s="hello world";
+        String[] s1 = s.split("o");
+        for (int i = 0; i < s1.length; i++) {
+            System.out.println(s1[i]);
+        }
+
+         */
+
+        System.out.println("请输入一段字符串....");
+        //创建Scanner对象
+        Scanner sc=new Scanner(System.in);
+        String s = sc.nextLine();
+        String[] strings = s.split(",");
+        //创建Student对象
+        Student student=new Student();
+        student.setName(strings[0]);
+        String sAge = strings[1];
+        //Integer是int类型对应的引用数据类型
+        //Integer.parseInt(字符串); 作用就是把字符串类型的数字转换为int类型的数字
+        int age = Integer.parseInt(sAge);
+        student.setAge(age);
+
+        System.out.println(student.getName()+"..."+student.getAge());
+    }
+}

01-JavaSE阶段代码/J20250715/homework/Student.java

@@ -0,0 +1,37 @@
+package J20250715.homework;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Student
+ * @description
+ * @create 2025/7/15
+ */
+public class Student {
+    private String name;
+    private int age;
+
+    public Student(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    public Student() {
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+}

01-JavaSE阶段代码/J20250715/stringbuider/Demo01.java

@@ -0,0 +1,26 @@
+package J20250715.stringbuider;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description
+ * @create 2025/7/15
+ */
+public class Demo01 {
+    public static void main(String[] args) {
+        //这种方式创建的变量，值是存储在字符串常量池，所以用==比较是一致的。
+        String s="he";
+        String s1="he";
+        //这种方式创建的字符串对象，是存储在堆内存中，
+        //分别开辟不同的空间，地址不同，==比较不一致
+        String s2=new String("wo");
+        String s3=new String("wo");
+
+        //字符串本身是不可变的。
+        String s4="hello";  //在常量池开辟空间，存入字符串。
+        s4="world";//再开辟一个空间存入字符串
+
+        //可变的字符串，最常用的是就是StringBuilder类
+    }
+}

01-JavaSE阶段代码/J20250715/stringbuider/Demo02.java

@@ -0,0 +1,33 @@
+package J20250715.stringbuider;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description
+ * @create 2025/7/15
+ */
+public class Demo02 {
+    public static void main(String[] args) {
+        //创建StringBuilder可变字符串对象--无参数
+        StringBuilder sb=new StringBuilder();
+        System.out.println("sb："+sb);
+        System.out.println("sb.length() :"+sb.length());
+
+        //创建StringBuilder可变字符串对象--有参数
+        StringBuilder sb1=new StringBuilder("hello world");
+        System.out.println("sb1："+sb1);
+        System.out.println("sb1.length() :"+sb1.length());
+
+        //调用StringBuilder追加字符串的方法 append(任意类型);
+        sb.append("今天");
+        sb.append("是个");
+        sb.append("好天气");
+        System.out.println("sb："+sb);
+        System.out.println("sb.length() :"+sb.length());
+
+        //调用方法实现字符串反转
+        sb.reverse();
+        System.out.println("字符串反转："+sb);
+    }
+}

01-JavaSE阶段代码/J20250715/stringbuider/Demo03.java

@@ -0,0 +1,46 @@
+package J20250715.stringbuider;
+
+import java.util.Arrays;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo03
+ * @description
+ * @create 2025/7/15
+ */
+public class Demo03 {
+
+
+    /**
+     * 把int类型数组转换为字符串
+     *
+     * @param arr int类型数组
+     * @return 字符串
+     */
+    public String arrayToString(int[] arr) {
+        //创建StringBuilder对象，并且添加开头的[
+        StringBuilder sb = new StringBuilder("[");
+        for (int i = 0; i < arr.length; i++) {
+            if (i == arr.length - 1) {
+                sb.append(arr[i]);
+            } else {
+                //sb.append(arr[i]);
+                //sb.append(",");
+                sb.append(arr[i]).append(",");
+            }
+        }
+        //最后追加结尾的]
+        sb.append("]");
+        //转换为字符串返回给调用者
+        return sb.toString();
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        Demo03 d3 = new Demo03();
+        String s = d3.arrayToString(arr);
+        System.out.println(s);
+        Arrays.toString(arr);
+    }
+}

01-JavaSE阶段代码/J20250715/studentManager/Demo01.java

@@ -0,0 +1,36 @@
+package J20250715.studentManager;
+
+import java.util.ArrayList;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description 长度可变的数组：ArrayList
+ * @create 2025/7/15
+ */
+public class Demo01 {
+    public static void main(String[] args) {
+        //创建对象
+        //ArrayList实际上是Java中集合的一种
+        //ArrayList其实就是一个长度可变的数组，底层代码就是新数组替换旧数组
+        //<类型名> 泛型，就是规定这个可变长度的数组中能存哪种类型的元素
+
+        ArrayList<String> list=new ArrayList();
+        //add(变量值); 向集合中添加元素
+        list.add("asdasd");
+        list.add("666");
+
+        //获取集合长度
+        int size = list.size();
+        System.out.println(size);
+
+        //获取指定索引位置的元素，不删除
+        String s = list.get(1);//索引位置为1的元素
+        System.out.println(s);
+
+        //删除指定位置的元素，返回被删除的那个元素
+        String s1 = list.remove(2);
+        System.out.println("被删除的元素是："+s1);
+    }
+}

01-JavaSE阶段代码/J20250715/studentManager/Main.java

@@ -0,0 +1,48 @@
+package J20250715.studentManager;
+
+import java.util.ArrayList;
+import java.util.Scanner;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Main
+ * @description
+ * @create 2025/7/15
+ */
+public class Main {
+    public static void main(String[] args) {
+        //创建键盘输入对象
+        Scanner sc = new Scanner(System.in);
+        //创建集合容器，用来存储多个学生
+        ArrayList<Student> list = new ArrayList<>();
+        while (true) {
+
+            System.out.println("--------欢迎进入学生管理系统--------");
+            System.out.println("1 添加学生");
+            System.out.println("2 删除学生");
+            System.out.println("3 修改学生");
+            System.out.println("4 查看学生");
+            System.out.println("5 退出系统");
+            System.out.println("请输入您的选择：");
+            int i = sc.nextInt();
+            switch (i) {
+                case 1:
+                    StudentManagerSystem.addStudent(list);
+                    break;
+                case 2:
+                    break;
+                case 3:
+                    StudentManagerSystem.updateStudent(list);
+                    break;
+                case 4:
+                    StudentManagerSystem.queryStudentList(list);
+                    break;
+                case 5:
+                    System.out.println("正在退出系统...");
+                    return;
+            }
+
+        }
+    }
+}

01-JavaSE阶段代码/J20250715/studentManager/Student.java

@@ -0,0 +1,95 @@
+package J20250715.studentManager;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Student
+ * @description
+ * @create 2025/7/15
+ */
+public class Student {
+    /**
+     * 学号
+     */
+    private String sid;
+    /**
+     * 姓名
+     */
+    private String name;
+    /**
+     * 年龄
+     */
+    private int age;
+    /**
+     * 生日
+     */
+    private String birthday;
+
+    /**
+     * 无参构造方法
+     */
+    public Student() {
+    }
+
+    /**
+     * 有参构造方法
+     * @param sid
+     * @param name
+     * @param age
+     * @param birthday
+     */
+    public Student(String sid, String name, int age, String birthday) {
+        this.sid = sid;
+        this.name = name;
+        this.age = age;
+        this.birthday = birthday;
+    }
+
+    /**
+     * 获取学生id
+     * @return
+     */
+    public String getSid() {
+        return sid;
+    }
+
+    /**
+     * 设置学生id
+     * @param sid
+     */
+    public void setSid(String sid) {
+        this.sid = sid;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public String getBirthday() {
+        return birthday;
+    }
+
+    public void setBirthday(String birthday) {
+        this.birthday = birthday;
+    }
+
+    /**
+     * 重写toString()方法
+     * @return
+     */
+    public String toString(){
+        return sid+"\t"+name+"\t"+age+"\t"+birthday;
+    }
+}

01-JavaSE阶段代码/J20250715/studentManager/StudentManagerSystem.java

@@ -0,0 +1,99 @@
+package J20250715.studentManager;
+
+import java.util.ArrayList;
+import java.util.Scanner;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title StudentManager
+ * @description
+ * @create 2025/7/15
+ */
+public class StudentManagerSystem {
+
+    //添加学生到系统
+    /**
+     * 向list集合中添加学生对象
+     * @param list
+     */
+    public static void addStudent(ArrayList<Student> list){
+        System.out.println("添加学生信息...");
+        Scanner sc=new Scanner(System.in);
+        //判断学号是否重复，如果不重复才可以输入
+        System.out.println("请输入学号：");
+        String sid=sc.nextLine();
+        System.out.println("请输入姓名：");
+        String name=sc.nextLine();
+        System.out.println("请输入年龄：");
+        int age=sc.nextInt();
+        System.out.println("请输入生日：");
+        String birthday=sc.next();
+        //创建学生对象
+        Student student=new Student(sid,name,age,birthday);
+        //把学生对象存入ArrayList集合对象
+        list.add(student);
+        System.out.println("添加学生成功");
+    }
+    //根据学号修改学生信息
+    public static void updateStudent(ArrayList<Student> list){
+        //获取键盘输入
+        Scanner sc=new Scanner(System.in);
+        System.out.println("请输入要修改学生的学号：");
+        //先根据学号，找到这个学生对象元素在集合的位置索引值下标。
+        String sid = sc.next();
+        int index = getIndex(sid, list);//找到索引值
+        //判断 index如果是-1，说明没有这个学生
+        if (index==-1){
+            System.out.println("查无此人，请重新输入学号");
+        }else {
+            System.out.println("请输入新的学生姓名：");
+            String name = sc.next();
+            System.out.println("请输入新的学生年龄：");
+            int age = sc.nextInt();
+            System.out.println("请输入新的学生生日：");
+            String birthday = sc.next();
+            Student s=new Student(sid,name,age,birthday);
+            //调用list的修改元素的方法
+            //list.set(集合的索引值,学生对象);
+            list.set(index,s);  //找到集合中index位置，将该元素替换为s
+            System.out.println("修改学生成功");
+        }
+    }
+
+    //根据学号删除学生信息
+
+
+    //查询学生列表信息
+    public static void queryStudentList(ArrayList<Student> list){
+        //判空
+        if(list.size()==0){
+            System.out.println("没有学生信息，请先添加，后查询");
+            return;
+        }
+        System.out.println("学号\t\t姓名\t年龄\t生日");
+        //遍历集合
+        for (int i = 0; i < list.size(); i++) {
+            Student student = list.get(i);
+            System.out.println(student);
+        }
+    }
+
+    //根据id获取学生对象在集合中的索引值的方法
+    public static int getIndex(String sid,ArrayList<Student> list){
+        //索引值初始化为-1
+        int index=-1;
+        //遍历集合
+        for (int i = 0; i < list.size(); i++) {
+            Student student = list.get(i);
+            String studentSid = student.getSid();
+            if (sid.equals(studentSid)){    //id比较相等
+                //说明存在这个学生，把索引值赋值给index
+                index=i;
+            }
+        }
+        return index;
+    }
+
+
+}

01-JavaSE阶段代码/J20250715/testString/Demo02.java

@@ -0,0 +1,31 @@
+package J20250715.testString;
+
+import java.util.Scanner;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description 案例：敏感词替换
+ * @create 2025/7/15
+ */
+public class Demo02 {
+    /*
+    需求：
+        键盘输入一个字符串，其中字符串包含(TMD)，则使用***替换
+    实现步骤：
+        1、键盘录入一个字符串，用Scanner实现
+        2、替换敏感词
+        replace(CharSequence target, CharSequence replacement)方法
+        replace("","")
+        把当前字符串中的指定的内容替换为新的字符串
+        3、输出结果
+     */
+    public static void main(String[] args) {
+        System.out.println("请输入一段字符串...");
+        Scanner sc=new Scanner(System.in);
+        String s = sc.nextLine();
+        String result = s.replace("TMD", "***");
+        System.out.println(result);
+    }
+}

01-JavaSE阶段代码/J20250715/testString/TestString.java

@@ -0,0 +1,17 @@
+package J20250715.testString;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title TestString
+ * @description
+ *  replace(char oldChar, char newChar) 将字符串中所有的oldChar都换成newChar
+ * @create 2025/7/15
+ */
+public class TestString {
+    public static void main(String[] args) {
+        String s="hello world";
+        String s1 = s.replace('l', 'z');
+        System.out.println(s1);
+    }
+}

01-JavaSE阶段代码/J20250715/为什么输出对象打印的是地址.txt

@@ -0,0 +1,7 @@
+为什么我们自定义的类创建的对象，输出的这个对象的时候，在控制台打印的是对象的地址？
+1、Java中规定任意类的直接父类或间接父类都是Object类。
+2、Object类里面有一个toString()方法，这个方法就是返回当前对象所属类型和地址值。
+格式：
+    包名.类名@地址值
+    J20250715.studentManager.Student@140e19d
+3、当我们调用输出某个对象的时候，其实默认是调用这个类的toString()方法，如果它没有，就调用父类的。

01-JavaSE阶段代码/J20250716/demo01_extends/Animal.java

@@ -0,0 +1,21 @@
+package J20250716.demo01_extends;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Animal
+ * @description
+ * @create 2025/7/16
+ */
+public class Animal {
+    public Animal(int a) {
+        System.out.println("父类的无参的构造方法");
+    }
+
+    protected void move(){
+        System.out.println("动物移动......");
+    }
+    public static void met(){
+        System.out.println("父类的静态方法");
+    }
+}

01-JavaSE阶段代码/J20250716/demo01_extends/Bird.java

@@ -0,0 +1,20 @@
+package J20250716.demo01_extends;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Bird
+ * @description
+ * @create 2025/7/16
+ */
+public class Bird extends Animal{
+    public Bird(int a) {
+        super(a);
+    }
+
+    @Override   //这种用@符号开头的单词，我们一般称为【注解】，它不是注释，
+    // 而是属于给类、变量、方法等等打一个标签。
+    public void move() {
+        System.out.println("我是鸟...我不跑...我飞");
+    }
+}

01-JavaSE阶段代码/J20250716/demo01_extends/Cat.java

@@ -0,0 +1,11 @@
+package J20250716.demo01_extends;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Cat
+ * @description
+ * @create 2025/7/16
+ */
+public class Cat {
+}

01-JavaSE阶段代码/J20250716/demo01_extends/Demo01.java

@@ -0,0 +1,28 @@
+package J20250716.demo01_extends;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description
+ * @create 2025/7/16
+ */
+public class Demo01 {
+    public static void main(String[] args) {
+        new Zi().show();
+    }
+}
+class FuFu{
+    int v=1;
+}
+
+class Fu extends FuFu{
+    int v=10;
+}
+class Zi extends Fu{
+    int v=20;
+
+    public void show(){
+        System.out.println(super.v);
+    }
+}

01-JavaSE阶段代码/J20250716/demo01_extends/Dog.java

@@ -0,0 +1,24 @@
+package J20250716.demo01_extends;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Dog
+ * @description
+ * @create 2025/7/16
+ */
+public class Dog extends Animal{
+    public Dog(int a) {
+        super(a);
+        System.out.println("狗类无参的构造方法");
+    }
+    @Override   //重写注解，检查下面的方法是否是重写的父类方法
+    public void move(){
+        System.out.println("狗要跑...四个蹄儿......");
+    }
+    //父类和子类有相同的静态方法，只能说明巧合，恰巧父子类有同名方法。不能说明是子类重写父类的静态方法。
+    //因为无法通过Override注解验证
+    public static void met(){
+        System.out.println("父类的静态方法");
+    }
+}

01-JavaSE阶段代码/J20250716/demo01_extends/Main.java

@@ -0,0 +1,20 @@
+package J20250716.demo01_extends;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Main
+ * @description
+ * @create 2025/7/16
+ */
+public class Main {
+    public static void main(String[] args) {
+        //Animal animal=new Animal();
+        //Dog dog=new Dog();
+        //Teddy teddy=new Teddy(6);
+        //teddy.move();
+        Bird bird=new Bird(1);
+        bird.move();
+
+    }
+}

01-JavaSE阶段代码/J20250716/demo01_extends/Teddy.java

@@ -0,0 +1,19 @@
+package J20250716.demo01_extends;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Teddy
+ * @description
+ * @create 2025/7/16
+ */
+public class Teddy extends Dog{
+    public Teddy(int a) {
+        //默认都先调用了父类的构造方法
+        super(a);
+        System.out.println("泰迪类无参构造方法");
+    }
+    public void move(){
+        System.out.println("泰迪移动......");
+    }
+}

01-JavaSE阶段代码/J20250716/demo02_extends/DesignDepartment.java

@@ -0,0 +1,11 @@
+package J20250716.demo02_extends;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title DesignDepartment
+ * @description 设计部员工
+ * @create 2025/7/16
+ */
+public class DesignDepartment extends Employee{
+}

01-JavaSE阶段代码/J20250716/demo02_extends/Employee.java

@@ -0,0 +1,42 @@
+package J20250716.demo02_extends;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Employee
+ * @description 员工类 父类
+ * @create 2025/7/16
+ */
+public class Employee {
+    private String id;
+    private String name;
+    private String job;
+
+
+
+    public void work(){}
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getJob() {
+        return job;
+    }
+
+    public void setJob(String job) {
+        this.job = job;
+    }
+}

01-JavaSE阶段代码/J20250716/demo02_extends/JavaDevelopmentEngineer.java

@@ -0,0 +1,15 @@
+package J20250716.demo02_extends;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title JavaDevelopmentEngineer
+ * @description
+ * @create 2025/7/16
+ */
+public class JavaDevelopmentEngineer extends RDDepartment{
+    @Override
+    public void work() {
+        System.out.println("员工姓名："+getName()+"工作岗位是："+getJob()+"员工编号是："+getId()+"工作内容是：开发上传后台管理系统");
+    }
+}

01-JavaSE阶段代码/J20250716/demo02_extends/Main.java

@@ -0,0 +1,24 @@
+package J20250716.demo02_extends;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Main
+ * @description
+ * @create 2025/7/16
+ */
+public class Main {
+    public static void main(String[] args) {
+        JavaDevelopmentEngineer jde=new JavaDevelopmentEngineer();
+        jde.setId("1001");
+        jde.setName("张三");
+        jde.setJob("Java开发工程师");
+        jde.work();
+        UIDesigner ui1=new UIDesigner();
+        ui1.setName("王五");
+        ui1.work();
+        UIDesigner ui2=new UIDesigner();
+        ui2.setName("赵六");
+
+    }
+}

01-JavaSE阶段代码/J20250716/demo02_extends/RDDepartment.java

@@ -0,0 +1,11 @@
+package J20250716.demo02_extends;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title RDDepartment
+ * @description 研发部员工
+ * @create 2025/7/16
+ */
+public class RDDepartment extends Employee{
+}

01-JavaSE阶段代码/J20250716/demo02_extends/UIDesigner.java

@@ -0,0 +1,16 @@
+package J20250716.demo02_extends;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title UIDesigner
+ * @description
+ * @create 2025/7/16
+ */
+public class UIDesigner extends DesignDepartment{
+    @Override
+    public void work() {
+        System.out.println("员工姓名："+getName()+"工作岗位是："+getJob()+
+                "员工编号是："+getId()+"工作内容是：商城logo设计");
+    }
+}

01-JavaSE阶段代码/J20250716/demo02_extends/WebDevelopmentEngineer.java

@@ -0,0 +1,15 @@
+package J20250716.demo02_extends;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title WebDevelopmentEngineer
+ * @description
+ * @create 2025/7/16
+ */
+public class WebDevelopmentEngineer  extends RDDepartment{
+    @Override
+    public void work() {
+        System.out.println("员工姓名："+getName()+"工作岗位是："+getJob()+"员工编号是："+getId()+"工作内容是：开发商城首页");
+    }
+}

01-JavaSE阶段代码/J20250716/demo03_abstract/Animal.java

@@ -0,0 +1,15 @@
+package J20250716.demo03_abstract;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Animal
+ * @description
+ * @create 2025/7/16
+ */
+public abstract class Animal {
+    public abstract void eat();
+    public void drink(){
+        System.out.println("喝水.....");
+    }
+}

01-JavaSE阶段代码/J20250716/demo03_abstract/Bird.java

@@ -0,0 +1,14 @@
+package J20250716.demo03_abstract;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Bird
+ * @description
+ * @create 2025/7/16
+ */
+//抽象方法，只能存在与抽象类中
+public abstract class Bird {
+    //一个方法，去掉了方法体大括号，增加了abstract关键字，就成了抽象方法
+    public abstract void move();
+}

01-JavaSE阶段代码/J20250716/demo03_abstract/Cat.java

@@ -0,0 +1,15 @@
+package J20250716.demo03_abstract;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Cat
+ * @description
+ * @create 2025/7/16
+ */
+public class Cat extends Animal{
+    @Override
+    public void eat() {
+        System.out.println("猫吃鱼...");
+    }
+}

01-JavaSE阶段代码/J20250716/demo03_abstract/Dog.java

@@ -0,0 +1,15 @@
+package J20250716.demo03_abstract;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Dog
+ * @description
+ * @create 2025/7/16
+ */
+public class Dog extends Animal{
+    @Override
+    public void eat() {
+        System.out.println("狗吃肉....");
+    }
+}

01-JavaSE阶段代码/J20250716/demo03_abstract/EssayTemplate.java

@@ -0,0 +1,17 @@
+package J20250716.demo03_abstract;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title EssayTemplate
+ * @description
+ * @create 2025/7/16
+ */
+public abstract class EssayTemplate {
+    public void write(){
+        System.out.println("《我的爸爸》");
+        body();
+        System.out.println("啊~这就是我的爸爸！");
+    }
+    public abstract void body();
+}

01-JavaSE阶段代码/J20250716/demo03_abstract/Main.java

@@ -0,0 +1,22 @@
+package J20250716.demo03_abstract;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Main
+ * @description
+ * @create 2025/7/16
+ */
+public class Main {
+    public static void main(String[] args) {
+        Cat cat=new Cat();
+        cat.eat();
+        cat.drink();
+        Dog dog=new Dog();
+        dog.eat();
+        dog.drink();
+
+        Tom tom=new Tom();
+        tom.write();
+    }
+}

01-JavaSE阶段代码/J20250716/demo03_abstract/Ostrich.java

@@ -0,0 +1,15 @@
+package J20250716.demo03_abstract;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Ostrich
+ * @description 鸵鸟
+ * @create 2025/7/16
+ */
+public class Ostrich extends Bird{
+    @Override
+    public void move() {
+        System.out.println("鸵鸟也不会飞....跑.....");
+    }
+}

01-JavaSE阶段代码/J20250716/demo03_abstract/Penguin.java

@@ -0,0 +1,12 @@
+package J20250716.demo03_abstract;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Penguin
+ * @description 企鹅
+ * @create 2025/7/16
+ */
+public abstract class Penguin extends Bird{
+
+}

01-JavaSE阶段代码/J20250716/demo03_abstract/Tom.java

@@ -0,0 +1,15 @@
+package J20250716.demo03_abstract;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Tom
+ * @description
+ * @create 2025/7/16
+ */
+public class Tom extends EssayTemplate{
+    @Override
+    public void body() {
+        System.out.println("那一天，我的区长爸爸，陪下棋，一步卧槽马绝杀");
+    }
+}

01-JavaSE阶段代码/J20250716/demo03_abstract/Tony.java

@@ -0,0 +1,11 @@
+package J20250716.demo03_abstract;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Tony
+ * @description
+ * @create 2025/7/16
+ */
+public class Tony {
+}

01-JavaSE阶段代码/J20250716/demo03_abstract/抽象类和抽象方法.txt

@@ -0,0 +1,27 @@
+抽象类和抽象方法：
+当我们在做子类共性特征功能抽取的时候，有些方法在父类中是没有具体功能体现的。
+这时候就需要抽象类了。
+Java中，如果一个方法，没有方法体，就应该被定义为抽象方法。
+如果类中有了抽象方法，那么这个类就必须定义为抽象类
+抽象类和抽象方法必须使用abstract关键字进行修饰：
+抽象类：
+public abstract class 类名{
+    抽象方法：
+    public abstract void 回家();
+}
+特点：
+    1、抽象方法必须存在于抽象类中，但是抽象类不只有抽象方法，还有具体方法。
+    2、抽象类是不能实例化，也就是不能创建对象的。
+    3、抽象方法存在的唯一意义，就是被子类重写。
+    4、抽象类的子类，要么重写父类的抽象方法，要么子类也必须是抽象类。
+
+案例需求：
+    定义猫类(Cat)和狗类(Dog)
+    猫的成员方法：eat(){猫吃鱼}  drink(){喝水...}
+    狗的成员方法：eat(){狗吃肉}  drink(){喝水...}
+实现步骤：
+    1、猫类和狗类存在共性特征，应该向上抽取出一个动物类Animal
+    2、父类Animal中不能把eat方法具体描述清楚，所以定义成抽象方法。
+    3、抽象方法需要存活在抽象类中，那么就要将Animal定义为抽象类。
+    4、让Cat和Dog分别继承Animal，并且抽象eat()方法
+    5、编写测试类，创建Cat和Dog对象，分别调用eat()和drink()方法进行测试。

01-JavaSE阶段代码/J20250716/demo03_abstract/设计模式.txt

@@ -0,0 +1,19 @@
+设计模式
+设计模式是一套反复被使用，多数人知道，经过分类的，代码设计经验的总结。
+使用设计模式，可以让代码更容易被他人理解，保证代码的可靠性，程序的重用性。
+比较常说的：Java的23种设计模式 其实不止23种。
+先说一种：
+-[模板设计模式]
+把抽象类整体看成一种模板，模板种不能决定的东西都定义为抽象方法。
+让使用模板的类(继承抽象类的类)，去重写抽象方法，自己实现需求。
+模板设计模式的优势：
+    模板已经定义了通用的结构，使用的人只需要关心自己要实现的功能就可以了。
+
+abstract class 作文模板类{
+    public void write(){
+        System.out.println("《我的爸爸》");
+        body();
+        System.out.println("啊~这就是我的爸爸！");
+    }
+    public abstract void body();
+}

01-JavaSE阶段代码/J20250716/demo04_final/Demo01.java

@@ -0,0 +1,30 @@
+package J20250716.demo04_final;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description final 最终的 最后的
+ * @create 2025/7/16
+ */
+public class Demo01{
+    //一般final经常会和static一起使用
+    //这时候这个变量就是静态常量，一般静态常量都会使用全大写进行命名
+    //使用static修饰的变量是静态成员变量，可以使用类名直接调用
+    public static final String STRING="春天";
+}
+//父类
+class Fu{
+    //使用final修饰的方法，不能被重写
+    public final void method(){
+
+    }
+}
+//子类
+//被final修饰的类不能被继承
+final class Zi extends Fu{
+    //不能重写使用final修饰的方法。
+//    public final void method(){
+//
+//    }
+}

01-JavaSE阶段代码/J20250716/demo04_final/Demo02.java

@@ -0,0 +1,23 @@
+package J20250716.demo04_final;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description
+ * @create 2025/7/16
+ */
+public class Demo02 {
+    public static void main(String[] args) {
+        //对象是使用final修饰了
+        final Person p=new Person("张三",25);
+        //p=new Person("李四",30);    用一个新的对象，替换了原来的对象。报错
+        System.out.println(p.getName());
+        p.setName("李四");
+        //因为final修饰的是常量，不可改变。
+        //p=new Person("李四",30);其实是把对象的地址赋值给p。
+        //final修饰的常量不能改变地址只。但是该地址所对应的内存里的内容是可以改变的。
+
+    }
+
+}

01-JavaSE阶段代码/J20250716/demo04_final/Person.java

@@ -0,0 +1,37 @@
+package J20250716.demo04_final;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Person
+ * @description
+ * @create 2025/7/16
+ */
+public class Person {
+    private String name;
+    private int age;
+
+    public Person() {
+    }
+
+    public Person(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+}

01-JavaSE阶段代码/J20250716/demo04_final/Round.java

@@ -0,0 +1,22 @@
+package J20250716.demo04_final;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Round
+ * @description 圆形类
+ * @create 2025/7/16
+ */
+public class Round {
+    //圆形类
+    //一个公共的 静态的 常量  PI=3.1415926
+    public static final double PI=3.1415926;
+    //一个公共的 求周长的方法getPerimeter(double d) d是直径
+    public double getPerimeter(double d){
+        return PI*d;
+    }
+    //一个公共的 求面积的方法getArea(double r) r是半径
+    public double getArea(double r){
+        return PI*r*r;
+    }
+}

01-JavaSE阶段代码/J20250716/demo04_final/final.txt

@@ -0,0 +1,8 @@
+final也是一个关键字，可以修饰类、成员变量、成员方法
+final代码最终的的意思，修饰类、成员变量、成员方法。
+final修饰类、方法、变量的效果：
+    final修饰类后，这个类就不能被继承，也就是不能有子类。
+    final修饰方法，这个方法不能被重写。
+    final修饰变量，这个变量是一个常量，不能再次赋值。不能改值。
+    Java中对常量的定义是：
+    在定义常量的时候，必须要初始化赋值，并且不能修改。

01-JavaSE阶段代码/J20250716/demo05_codeblocks/Demo01.java

@@ -0,0 +1,19 @@
+package J20250716.demo05_codeblocks;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description 局部代码块
+ * @create 2025/7/16
+ */
+public class Demo01 {
+    public static void main(String[] args) {
+        {
+            int a=10;
+            System.out.println(a);
+        }
+        //在main方法运行结束之前，代码块里面的内容就已经运行完了，并且结束和释放了。
+        //System.out.println(a);
+    }
+}

01-JavaSE阶段代码/J20250716/demo05_codeblocks/Demo02.java

@@ -0,0 +1,39 @@
+package J20250716.demo05_codeblocks;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description
+ * @create 2025/7/16
+ */
+public class Demo02 {
+    {
+        //成员代码块 构造代码块
+        //构造代码块是在类中，方法外部定义的，和方法是同一级。
+        //每当执行构造方法的时候，都会先执行构造代码块里的代码。
+        System.out.println("今天天气不错");
+        System.out.println("是风和日丽的");
+        //提高代码的复用性，代码块里面的代码，会被所有的构造方法执行。
+    }
+    /*
+
+
+     */
+    public Demo02() {
+    }
+    public Demo02(int a) {
+    }
+    public Demo02(String b) {
+    }
+    public Demo02(double c) {
+    }
+    public Demo02(int a,String b) {
+    }
+    public Demo02(int a,String b,double c) {
+    }
+
+    public static void main(String[] args) {
+        Demo02 d=new Demo02(1);
+    }
+}

01-JavaSE阶段代码/J20250716/demo05_codeblocks/Demo03.java

@@ -0,0 +1,58 @@
+package J20250716.demo05_codeblocks;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo03
+ * @description
+ * @create 2025/7/16
+ */
+public class Demo03 extends Fu{
+    public Demo03() {
+        System.out.println("我是子类的构造方法....");
+        {
+            System.out.println("我是子类的局部代码块");
+        }
+    }
+    {
+        System.out.println("我是子类的代码块");
+    }
+    static {
+        System.out.println("我是子类的静态代码块");
+    }
+
+    public static void staticMethod(){
+        System.out.println("我是子类的静态方法");
+    }
+    public void method(){
+        System.out.println("我是子类的普通方法");
+    }
+
+    public static void main(String[] args) {
+        //Demo03.staticMethod();
+        Demo03 d=new Demo03();
+        d.method();
+    }
+
+}
+class Fu{
+    public Fu() {
+        System.out.println("我是父类的构造方法....");
+        {
+            System.out.println("我是父类的局部代码块");
+        }
+    }
+    {
+        System.out.println("我是父类的代码块");
+    }
+    static {
+        System.out.println("我是父类的静态代码块");
+    }
+
+    public static void staticMethod(){
+        System.out.println("我是父类的静态方法");
+    }
+    public void method(){
+        System.out.println("我是父类的普通方法");
+    }
+}

01-JavaSE阶段代码/J20250716/demo05_codeblocks/代码块.txt

@@ -0,0 +1,42 @@
+代码块
+Java中使用{}括起来的代码被称为代码块
+代码块分为三种：
+    1、局部代码块
+    2、成员代码块
+    3、静态代码块
+1、局部代码块
+    局部代码块在方法中定义。比如：
+    public void method(){
+        {
+            //这就是代码块
+        }
+    }
+    作用，就是限制变量的生命周期，提早释放，提高内存的使用效率
+2、成员代码块
+    成员代码块在类中方法的外部进行定义，每次执行构造方法的时候，
+    都会执行代码块里面的代码，并且是在构造方法之前执行。
+    提高代码的复用性，代码块里面的代码，会被所有的构造方法执行。
+        格式：
+    class 类名{
+        {
+            //构造代码块
+        }
+    }
+作用：
+    在对象加载的时候，做一些数据初始化的操作。
+3、静态代码块
+    静态代码块也是在类中方法外部定义，但是静态代码块需要使用static修饰
+    格式：
+    class 类名{
+        static{
+            //静态代码块
+        }
+    }
+    静态代码块要先于对象执行。
+    静态代码块随着类的加载而加载，并且只执行一次。
+作用：
+    在类加载的时候，做一些数据初始化的操作。
+
+练习题：
+定义 交通工具、汽车、火车、飞机这些类，注意他们之间的继承关系，
+并且为这些类提供超过3不同的构造方法，并且通过初始化代码块提取出构造方法中通用的代码。

01-JavaSE阶段代码/J20250716/继承02.txt

@@ -0,0 +1,77 @@
+继承中类的成员访问的特点：
+成员变量的特点：在子类的方法中访问一个变量，采用的叫就近原则。
+    最先在子类局部范围查找
+    然后在子类成员范围查找
+    最后在父类成员范围查找
+    直到都没有，就报错
+
+super关键字
+    this指向的是当前的对象，【我】
+    super指向的是当前对象的父类对象，【我爹】
+
+使用this和super调用方法和变量
+    成员变量：
+        this.成员变量   -访问本类对象的成员变量
+        super.成员变量  -访问父类对象的成员变量
+    成员方法：
+        this.成员方法   -访问本类对象的成员方法
+        super.成员方法   -访问父类对象的成员方法
+    构造方法：
+        this()  -访问当前对象的构造方法
+        super() -访问父类对象的构造方法
+
+所有的子类，在创建对象的时候，一定一定一定先调用父类的构造方法，然后再调用本类的构造方法创建对象。
+子类中所有的构造方法，都会默认的访问父类的无参构造方法。
+如果父类没有无参构造方法，那么子类必须在构造方法的[第一行]显式调用父类的有参构造方法并传递参数。
+
+由于this()和super()都必须在构造方法的第一行，所以二者不能共存
+
+
+父类的方法被子类的同名方法覆盖，这种情况叫方法的【重写】
+具体的表现：
+    子类中出现了和父类中一模一样的方法声明(方法名相同，参数列表也相同)
+
+重载和重写的区别：
+    重载是发生在同一个类中的，方法名相同，参数列表必须不相同。
+    重写是发生在父子类中的，方法名相同，参数列表也必须相同。
+
+    重写的目的：当子类需要父类的功能，但是功能的主体实现需要子类有自己特定的内容时，就需要重写父类的方法。
+
+方法重写的注意事项：
+    1、private修饰的方法不能被重写，父类的私有成员子类是无法继承的。
+    2、子类方法的访问权限不能比父类方法的方法访问权限更低 public>default>private
+    3、父类的方法如果想被子类重写，那么就只能属于public或protected修饰
+    4、静态方法不能被重写，即使子类有父类相同的方法，也不是重写父类方法，只是方法同名。
+
+
+
+案例：
+某IT公司有``研发部门``和``设计部门``两个部门的员工，每名员工都有自己的``员工编号``、``员工姓名``、``员工岗位``3个属性，
+并且每名员工都有自己的``工作内容``。
+比如：
+- 员工姓名：张三，工作岗位是：Java开发工程师，员工编号是：1001，工作内容是：开发商城后台管理系统。
+- 员工姓名：李四，工作岗位是：前端开发工程师，员工编号是：1011，工作内容是：开发商城首页。
+- 员工姓名：王五，工作岗位是：UI设计师，员工编号是2001，工作内容是：商城logo设计。
+- 员工姓名：赵六，工作岗位是：UI设计师，员工编号是2002，工作内容是：商城logo设计。
+
+| 员工类类名         | ``Employee``                |
+| ------------------ | --------------------------- |
+| 研发部类名         | ``RDDepartment``            |
+| 设计部类名         | ``DesignDepartment``        |
+| Java开发工程师类名 | ``JavaDevelopmentEngineer`` |
+| 前端开发工程师类名 | ``WebDevelopmentEngineer``  |
+| UI设计师类名       | ``UIDesigner``              |
+| 员工姓名           | ``name``                    |
+| 员工编号           | ``id``                      |
+| 员工岗位           | ``job``                     |
+| 工作方法名         | ``work()``                  |
+
+请根据上面的信息，合理的编写代码，利用继承相关的知识，实现需求。
+
+需求：
+
+- 员工类是父类
+- 创建员工类及其各种子类，并分别添加属性和方法。
+- 创建提示中的各类员工对象，并为属性赋值，然后调用工作的方法。
+- 类名、属性名、方法名必须严格按照表中来写。
+- 工作方法中要实现在控制台中输出哪一个部门的哪一个员工，id是什么，岗位是什么，以及在做什么工作内容。

01-JavaSE阶段代码/J20250717/demo01_/Main.java

@@ -0,0 +1,15 @@
+package J20250717.demo01_;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Main
+ * @description
+ * @create 2025/7/17
+ */
+public class Main {
+    public static void main(String[] args) {
+        SubClass sc=new SubClass();
+        sc.method();
+    }
+}

01-JavaSE阶段代码/J20250717/demo01_/SubClass.java

@@ -0,0 +1,27 @@
+package J20250717.demo01_;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title SubClass
+ * @description
+ * @create 2025/7/17
+ */
+public class SubClass extends SuperClass{
+    {
+        System.out.println("子类初始化代码块");
+    }
+    static{
+        System.out.println("子类静态初始化代码块");
+    }
+
+    public SubClass() {
+        System.out.println("子类无参构造方法");
+    }
+    public void method(){
+        {
+            System.out.println("子类普通方法中的局部代码块");
+        }
+        System.out.println("子类普通方法");
+    }
+}

01-JavaSE阶段代码/J20250717/demo01_/SuperClass.java

@@ -0,0 +1,22 @@
+package J20250717.demo01_;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title SuperClass
+ * @description
+ * @create 2025/7/17
+ */
+public abstract class SuperClass {
+    {
+        System.out.println("父类初始化代码块");
+    }
+    static{
+        System.out.println("父类静态初始化代码块");
+    }
+
+    public SuperClass() {
+        System.out.println("父类无参构造方法");
+    }
+    public abstract void method();
+}

01-JavaSE阶段代码/J20250717/demo02_interface/BirdMan.java

@@ -0,0 +1,22 @@
+package J20250717.demo02_interface;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title BirdMan
+ * @description 鸟人
+ * @create 2025/7/17
+ */
+//鸟人继承人类，实现移动的接口，重写飞行的方法
+public class BirdMan extends Person implements Fly ,Swim{
+
+    @Override
+    public void fly() {
+        System.out.println("鸟人....我会飞...");
+    }
+
+    @Override
+    public void swim() {
+        System.out.println("鸟人...还会游泳...");
+    }
+}

01-JavaSE阶段代码/J20250717/demo02_interface/Fly.java

@@ -0,0 +1,19 @@
+package J20250717.demo02_interface;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Move
+ * @description
+ * @create 2025/7/17
+ */
+public interface Fly {
+    //接口里的成员变量，默认都是使用public static final修饰的
+    //接口里的任何成员变量，都必须是公共的，静态的，常量
+    public static final String name="张三";
+
+    //接口种所有的方法都是使用public abstract修饰的
+    void fly();
+
+
+}

01-JavaSE阶段代码/J20250717/demo02_interface/Key.java

@@ -0,0 +1,20 @@
+package J20250717.demo02_interface;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Key
+ * @description
+ * @create 2025/7/17
+ */
+public class Key implements USB{
+    @Override
+    public void open() {
+        System.out.println("键盘开启");
+    }
+
+    @Override
+    public void close() {
+        System.out.println("键盘关闭");
+    }
+}

01-JavaSE阶段代码/J20250717/demo02_interface/Main.java

@@ -0,0 +1,24 @@
+package J20250717.demo02_interface;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Main
+ * @description
+ * @create 2025/7/17
+ */
+public class Main {
+    public static void main(String[] args) {
+//        BirdMan birdMan=new BirdMan();
+//        birdMan.fly();
+//        birdMan.swim();
+
+        Mouse mouse=new Mouse();//创建鼠标对象
+        Key key=new Key();//创建键盘对象
+        Notepad notepad=new Notepad();  //创建笔记本对象
+        notepad.run();  //调用开机方法
+        notepad.useUsb(mouse);  //使用USB设备 mouse
+        notepad.useUsb(key);    //使用USB设备 key
+        notepad.shutdown();     //调用关机方法
+    }
+}

01-JavaSE阶段代码/J20250717/demo02_interface/Mouse.java

@@ -0,0 +1,21 @@
+package J20250717.demo02_interface;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Mouse
+ * @description
+ * @create 2025/7/17
+ */
+public class Mouse implements USB{
+
+    @Override
+    public void open() {
+        System.out.println("鼠标开启");
+    }
+
+    @Override
+    public void close() {
+        System.out.println("鼠标关闭");
+    }
+}

01-JavaSE阶段代码/J20250717/demo02_interface/Notepad.java

@@ -0,0 +1,22 @@
+package J20250717.demo02_interface;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Notepad
+ * @description
+ * @create 2025/7/17
+ */
+public class Notepad {
+    public void run(){
+        System.out.println("笔记本开机");
+    }
+    public void useUsb(USB usb){
+        usb.open();
+        System.out.println("使用usb设备");
+        usb.close();
+    }
+    public void shutdown(){
+        System.out.println("笔记本关机");
+    }
+}

01-JavaSE阶段代码/J20250717/demo02_interface/Person.java

@@ -0,0 +1,16 @@
+package J20250717.demo02_interface;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Person
+ * @description
+ * @create 2025/7/17
+ */
+public class Person {
+    //胎生
+    //哺乳
+    private String name;
+    private Integer age;
+    private String sex;
+}

01-JavaSE阶段代码/J20250717/demo02_interface/Swim.java

@@ -0,0 +1,12 @@
+package J20250717.demo02_interface;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Swim
+ * @description
+ * @create 2025/7/17
+ */
+public interface Swim {
+    void swim();
+}

01-JavaSE阶段代码/J20250717/demo02_interface/USB.java

@@ -0,0 +1,14 @@
+package J20250717.demo02_interface;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title USB
+ * @description
+ * @create 2025/7/17
+ */
+public interface USB {
+    void open();
+
+    void close();
+}

01-JavaSE阶段代码/J20250717/demo02_interface/UserDao.java

@@ -0,0 +1,35 @@
+package J20250717.demo02_interface;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title UserDao
+ * @description
+ * @create 2025/7/17
+ */
+public interface UserDao {
+    /**
+     * 新增用户
+     */
+    void addUser();
+
+    /**
+     * 修改用户
+     */
+    void updateUser();
+
+    /**
+     * 删除用户
+     */
+    void deleteUser();
+
+    /**
+     * 查询用户列表
+     */
+    void queryList();
+
+    /**
+     * 查询单个用户
+     */
+    void getOneUser();
+}

01-JavaSE阶段代码/J20250717/demo02_interface/UserDaoImpl.java

@@ -0,0 +1,50 @@
+package J20250717.demo02_interface;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title UserDaoImpl
+ * @description
+ * @create 2025/7/17
+ */
+public class UserDaoImpl implements UserDao{
+    /**
+     * 新增用户
+     */
+    @Override
+    public void addUser() {
+        System.out.println("新增用户");
+    }
+
+    /**
+     * 修改用户
+     */
+    @Override
+    public void updateUser() {
+        System.out.println("修改用户");
+    }
+
+    /**
+     * 删除用户
+     */
+    @Override
+    public void deleteUser() {
+        System.out.println("删除用户");
+    }
+
+    /**
+     * 查询用户列表
+     */
+    @Override
+    public void queryList() {
+        System.out.println("查询用户列表");
+    }
+
+    /**
+     * 查询单个用户
+     */
+    @Override
+    public void getOneUser() {
+        System.out.println("查询单个用户");
+    }
+}

01-JavaSE阶段代码/J20250717/demo03_interface02/Demo01.java

@@ -0,0 +1,23 @@
+package J20250717.demo03_interface02;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title MyInter
+ * @description 如果一个类实现两个接口，且两个接口具有相同名方法，那么只需要实现一次。
+ * @create 2025/7/17
+ */
+public class Demo01 implements MyInter01,MyInter02{
+
+    @Override
+    public void method() {
+
+    }
+}
+interface MyInter01{
+    void method();
+}
+
+interface MyInter02{
+    void method();
+}

01-JavaSE阶段代码/J20250717/demo03_interface02/Demo02.java

@@ -0,0 +1,28 @@
+package J20250717.demo03_interface02;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description
+ * 如果实现类只实现了一个接口，那么该接口中的默认方法，实现类可以不重写。
+ * 如果实现类实现了两个接口，且接口中具有相同的默认方法，那么实现类必须重写默认方法
+ * @create 2025/7/17
+ */
+public class Demo02 implements MyInter03,MyInter04{
+
+    @Override
+    public void method() {
+        System.out.println("demo02重写后的默认方法");
+    }
+}
+interface MyInter03{
+    default void method(){
+        System.out.println("03的默认方法");
+    }
+}
+interface MyInter04{
+    default void method(){
+        System.out.println("04的默认方法");
+    }
+}

01-JavaSE阶段代码/J20250717/demo03_interface02/Demo03.java

@@ -0,0 +1,24 @@
+package J20250717.demo03_interface02;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo03
+ * @description
+ * @create 2025/7/17
+ */
+public class Demo03 implements MyInter05{
+
+    public static void main(String[] args) {
+        Demo03 d3=new Demo03();
+        //d3.method();  实现类对象，无法调用接口的静态方法
+        MyInter05.method(); //只要接口名才能调用自己的静态方法
+        //Demo03.method();  //实现类类名，无法调用接口的静态方法
+    }
+}
+interface MyInter05{
+    static void method(){
+        System.out.println("05的静态方法");
+    }
+
+}

01-JavaSE阶段代码/J20250717/demo03_interface02/UserService.java

@@ -0,0 +1,35 @@
+package J20250717.demo03_interface02;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title UserService
+ * @description
+ * @create 2025/7/17
+ */
+public interface UserService {
+    /**
+     * 新增用户
+     */
+    void addUser();
+
+    /**
+     * 修改用户
+     */
+    void updateUser();
+
+    /**
+     * 删除用户
+     */
+    void deleteUser();
+
+    /**
+     * 查询用户列表
+     */
+    void queryList();
+
+    /**
+     * 查询单个用户
+     */
+    void getOneUser();
+}