feat: 更新c260730授课代码——Demo01完整List.of示例、Demo02双链表源码注释、MyLinked单链表实现、Student类追加选课字段、Test01测试、CourseManager课程管理练习、MyArrayList选做作业框架

授课代码/c260730/src/course/Demo01.java

@@ -1,11 +1,50 @@
 package course;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
+ * @author WanJl
+ * @version 1.0
  * @title Demo01
- * @description 
- * @author WanJl 
- * @version 1.0 
- * @create 2026/7/30 
+ * @description List.of方法
+ * @create 2026/7/30
  */
 public class Demo01 {
+    /*
+        List接口的特殊方法
+        List.of()
+        ....... 系列方法
+
+     */
+    public static void main(String[] args) {
+        //
+        List<String> list1=new ArrayList<>();
+        //JAVA9之后，为List提供了一系列的of方法，用来快速创建一个List列表集合对象，而且是不可改变的集合。
+        List<String> list = List.of("张三","李四","wangwu");
+        //list.add("张三");
+        //list.set(1,"晚五");
+        for (int i = 0; i < list.size(); i++) {
+            System.out.println(list.get(i));
+        }
+
+        Student s1=new Student("张三",20,"S001");
+        Student s2=new Student("张三2",20,"S002");
+        Student s3=new Student("张三3",20,"S003");
+        Student s4=new Student("张三4",20,"S004");
+        List<Student> studentList = List.of(s1, s2, s3, s4);
+
+        for (int i = 0; i < studentList.size(); i++) {
+            System.out.println(studentList.get(i));
+
+        }
+        s2.setName("李四");
+        for (int i = 0; i < studentList.size(); i++) {
+            System.out.println(studentList.get(i));
+
+        }
+        studentList=List.of();
+
+    }
+
 }

授课代码/c260730/src/course/Demo02.java

@@ -1,11 +1,62 @@
 package course;
 
+import java.util.LinkedList;
+
 /**
+ * @author WanJl
+ * @version 1.0
  * @title Demo02
- * @description 
- * @author WanJl 
- * @version 1.0 
- * @create 2026/7/30 
+ * @description LinkedList集合
+ * @create 2026/7/30
  */
 public class Demo02 {
+    /*
+        LinkedList 直译就是链表
+        LinkedList 可以实现、链表、队列、和栈。
+        LinkedList 同时实现了 List集合接口（中文翻译：列表）和Deque集合接口（中文翻译：双端队列 Double Queue）
+        LinkedList底层是采用【双链表数据结构】来实现的集合。
+
+        LinkedList 的属性：
+            transient int size = 0; //集合元素个数
+            transient LinkedList.Node<E> first; 指向头节点
+            transient LinkedList.Node<E> last;  指向尾节点
+        构造方法：
+            public LinkedList()  无参构造方法，创建一个空的集合
+            public LinkedList(Collection<? extends E> c)    创建集合，传入一个Collection的对象作为参数
+
+        静态内部类-节点类
+            private static class Node<E> {
+                E item;     //节点元素
+                Node<E> next;   //下一个节点的地址，指向下一个节点
+                Node<E> prev;   //上一个节点的地址，指向上一个节点
+
+                Node(Node<E> prev, E element, Node<E> next) {   //有参构造方法
+                    this.item = element;
+                    this.next = next;
+                    this.prev = prev;
+                }
+            }
+
+        public E getFirst() ：返回头节点，如果头节点是null就抛出NoSuchElementException异常
+        public E getLast()  ：返回尾节点，如果尾节点是null就抛出NoSuchElementException异常
+        public E removeFirst()：移除头节点，如果头节点是null就抛出NoSuchElementException异常
+        重点：
+        private E unlinkFirst(Node<E> f) 移除链接的头节点：
+            构成头节点的条件：   Node节点的 prev=null、item有值、next=下一个节点的地址。
+            构成尾节点的条件：   Node节点的 prev=上一个节点的地址、item有值、next=null。
+            构成普通节点的条件： Node节点的 prev=上一个节点的地址、item有值、next=下一个节点的地址。
+            把传入的头结点参数f，的item赋值给一个元素变量。
+            f.next f的下一个节点的地址，赋值给next
+            清空头节点f的item和next。交给JVM进行垃圾回收。
+            下一步就是把原本的第二个节点，设置为头结点。
+            如果第二节点（新的头结点）为空，那么说明当前集合中只有一个节点，而且被删了，
+            所以尾节点last也设置为null。然后方法执行结束，返回被删除的对象元素。
+            如果第二节点（新的头结点）不是空的，那么就把第二个节点设置为新的头节点
+            原本的第二个节点的prev设置为null，让他符合构成头结点的条件。
+            size-1、修改次数modCount+1，最后返回删除的对象元素。
+        private E unlinkLast(Node<E> l) 只是unlinkFirst的一种镜像操作，只不过操作的是尾节点。
+
+
+
+     */
 }

授课代码/c260730/src/course/MyLinked.java

@@ -1,11 +1,68 @@
 package course;
 
 /**
+ * @author WanJl
+ * @version 1.0
  * @title MyLinked
- * @description 
- * @author WanJl 
- * @version 1.0 
- * @create 2026/7/30 
+ * @description
+ * @create 2026/7/30
  */
-public class MyLinked {
+public class MyLinked<N> {
+    private Integer size;
+
+    private Node<N> firstNode;
+    private Node<N> lastNode;
+
+    public MyLinked() {
+        firstNode=new Node<>(null,null);
+        lastNode=firstNode;
+    }
+
+    public int size(){
+        return this.size;
+    }
+    public static class Node<N>{
+        N value;    //节点的元素
+        Node<N> next;  //下一个节点的地址
+        //Node<N> prev;  //上一个节点的地址
+
+        public Node(N value, Node<N> next) {
+            this.value = value;
+            this.next = next;
+        }
+    }
+
+    //1、添加节点
+    public void addNode(N value){
+        //新建一个新节点，value就是存入的元素，next=null，就是下一个节点还是null。
+        Node<N> n=new Node<>(value,null);
+        if (firstNode.next==null){//集合中没有元素的情况
+            this.firstNode.next=n;
+            //把新加入的节点地址复制给lastNode
+            this.lastNode=n;
+        }
+        //集合中已经有了元素的情况
+        lastNode.next=n;    //原来的最后一个节点的后面加一个新的节点。
+        lastNode=n;//原本的最后一个节点不是最后一个了，应该是新的节点n才是最后一个
+
+    }
+
+
+    //2、移除节点
+
+    //3、获取节点
+
+    //4、遍历节点
+    public void print(){
+        //获取到第一个节点firstNode的下一个节点，也就是真正的有效节点
+        Node<N> node = firstNode.next;
+        while (true){
+            System.out.println(node.value);
+            node=node.next;
+            if (node.next==null){
+                System.out.println(node.value);
+                break;
+            }
+        }
+    }
 }

授课代码/c260730/src/course/Student.java

@@ -1,4 +1,4 @@
-package exericse.exericse01;
+package course;
 
 import java.util.ArrayList;
 import java.util.Objects;

授课代码/c260730/src/course/Test01.java

@@ -1,11 +1,26 @@
 package course;
 
 /**
+ * @author WanJl
+ * @version 1.0
  * @title Test01
- * @description 
- * @author WanJl 
- * @version 1.0 
- * @create 2026/7/30 
+ * @description
+ * @create 2026/7/30
  */
 public class Test01 {
+    public static void main(String[] args) {
+        MyLinked<String> linked = new MyLinked<>();
+
+        linked.addNode("张三");
+        linked.addNode("李四");
+        linked.addNode("王五");
+        linked.addNode("王五2");
+        linked.addNode("王五3");
+        linked.addNode("王五4");
+        linked.addNode("王五5");
+        linked.addNode("王五6");
+        linked.addNode(null);
+        linked.print();
+
+    }
 }

授课代码/c260730/src/exericse/exericse01/CourseManager.java

@@ -1,11 +1,38 @@
 package exericse.exericse01;
 
+import java.util.ArrayList;
+
 /**
+ * @author WanJl
+ * @version 1.0
  * @title CourseManager
- * @description 
- * @author WanJl 
- * @version 1.0 
- * @create 2026/7/30 
+ * @description
+ * @create 2026/7/30
  */
 public class CourseManager {
-}
+    public static void main(String[] args) {
+        // 1. 创建一个学生对象：张三, 20, S001
+        Student s=new Student("张三",20,"S001");
+        // 2. 为该学生添加 3 门课程："Java基础", "数据结构", "数据库原理"
+        //    提示：student.getCourses().add("课程名");
+        ArrayList<String> courseList = s.getCourses();
+        courseList.add("Java基础");
+        courseList.add("数据结构");
+        courseList.add("数据库原理");
+        // 3. 输出该学生的已选课程列表
+        //    输出格式："张三的已选课程：[Java基础, 数据结构, 数据库原理]"
+        System.out.println(s.getName()+"的已选课程"+courseList);
+        // 4. 判断是否已选"数据结构"（使用 contains() 方法）
+        //    输出："是否已选数据结构？true"
+        System.out.println("是否已选数据结构？"+courseList.contains("数据结构"));
+        // 5. 退选"数据结构"课程（使用 remove() 方法按对象删除）
+        //    输出："已退选课程：数据结构"
+        System.out.println("已退选课程："+(courseList.remove("数据结构")?"数据结构":"没找到课程"));
+        // 6. 再次输出该学生的已选课程列表
+        //    输出格式："退选后的课程：[Java基础, 数据库原理]"
+        System.out.println("退选后的课程："+courseList);
+        // 7. 查询"Java基础"课程的索引位置（使用 indexOf() 方法）
+        //    输出："'Java基础'的索引位置：0"
+        System.out.println("'Java基础'的索引位置："+courseList.indexOf("Java基础"));
+    }
+}

授课代码/c260730/src/exericse/exericse01/Student.java

@@ -1,4 +1,7 @@
-package exericse.exericse03;
+package exericse.exericse01;
+
+import java.util.ArrayList;
+import java.util.Objects;
 
 /**
  * @author WanJl
@@ -8,15 +11,16 @@ package exericse.exericse03;
  * @create 2026/7/29
  */
 public class Student {
-    // 属性
     private String name;      // 姓名
     private Integer age;      // 年龄（使用包装类）
     private String studentId; // 学号
+    private ArrayList<String> courses;  // 已选课程列表
 
     /**
      * 无参构造方法
      */
     public Student() {
+        courses = new ArrayList<>();
     }
 
     /**
@@ -29,9 +33,11 @@ public class Student {
         this.name = name;
         this.age = age;
         this.studentId = studentId;
+        courses = new ArrayList<>();
     }
 
-    // ========== Getter 和 Setter 方法 ==========
+
+// ========== Getter 和 Setter 方法 ==========
 
     public String getName() {
         return name;
@@ -57,34 +63,33 @@ public class Student {
         this.studentId = studentId;
     }
 
-    /**
-     * 重写 toString 方法，方便打印对象信息
-     */
-    @Override
-    public String toString() {
-        return "Student{" +
-                "name='" + name + '\'' +
-                ", age=" + age +
-                ", studentId='" + studentId + '\'' +
-                '}';
+    public ArrayList<String> getCourses() {
+        return courses;
+    }
+
+    public void setCourses(ArrayList<String> courses) {
+        this.courses = courses;
     }
 
-    /**
-     * 重写 equals 方法，基于学号判断两个学生是否相等
-     */
     @Override
-    public boolean equals(Object obj) {
-        if (this == obj) return true;
-        if (obj == null || getClass() != obj.getClass()) return false;
-        Student student = (Student) obj;
-        return studentId != null && studentId.equals(student.studentId);
+    public boolean equals(Object o) {
+        if (o == null || getClass() != o.getClass()) return false;
+        Student student = (Student) o;
+        return Objects.equals(name, student.name) && Objects.equals(age, student.age) && Objects.equals(studentId, student.studentId) && Objects.equals(courses, student.courses);
     }
 
-    /**
-     * 重写 hashCode 方法，基于学号生成哈希值
-     */
     @Override
     public int hashCode() {
-        return studentId != null ? studentId.hashCode() : 0;
+        return Objects.hash(name, age, studentId, courses);
+    }
+
+    @Override
+    public String toString() {
+        return "Student{" +
+                "name='" + name + '\'' +
+                ", age=" + age +
+                ", studentId='" + studentId + '\'' +
+                ", courses=" + courses +
+                '}';
     }
 }

授课代码/c260730/src/homework0729/p4/MyArrayList.java

@@ -1,11 +1,35 @@
 package homework0729.p4;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+
 /**
+ * @author WanJl
+ * @version 1.0
  * @title MyArrayList
- * @description 
- * @author WanJl 
- * @version 1.0 
- * @create 2026/7/30 
+ * @description
+ * @create 2026/7/30
  */
-public class MyArrayList {
+public class MyArrayList<E> {
+    private Object[] elementData;
+    private Integer size;
+    public MyArrayList() {
+        elementData=new Object[0];
+    }
+    public MyArrayList(int initialCapacity) {
+        elementData=new Object[initialCapacity];
+    }
+
+    public boolean add(E e){
+        if (size+1>=elementData.length){
+            //扩容--复制
+        }
+        return false;
+    }
+
+
+
+
+
 }

授课代码/c260730/src/homework0729/p4/题目.md

@@ -0,0 +1,50 @@
+
+## 第 4 题：手写简化版 MyArrayList（选做 / 加分题）⭐⭐⭐⭐⭐
+
+**包名**：`p2_myarraylist`
+
+**知识点**：综合运用泛型、数组操作、扩容机制
+
+### 需求说明
+
+基于你对 ArrayList 源码的理解，手写一个简化版的 `MyArrayList<E>` 类，实现以下方法：
+
+| 方法 | 说明 |
+|------|------|
+| `MyArrayList()` | 无参构造，默认容量 10 |
+| `MyArrayList(int initialCapacity)` | 指定初始容量 |
+| `boolean add(E e)` | 添加元素（自动扩容） |
+| `E get(int index)` | 获取元素（检查越界） |
+| `E set(int index, E element)` | 修改元素 |
+| `E remove(int index)` | 删除元素（返回被删除的元素） |
+| `int size()` | 返回元素个数 |
+| `boolean isEmpty()` | 判断是否为空 |
+| `void clear()` | 清空所有元素 |
+| `String toString()` | 返回格式如 `[元素1, 元素2, ...]` |
+
+**要求**：
+1. 必须使用**泛型**（`MyArrayList<E>`）
+2. 底层使用 `Object[]` 存储数据
+3. 实现自动扩容机制（参考 JDK 的 1.5 倍扩容）
+4. 所有方法必须添加详细中文注释
+5. 编写测试类 `MyArrayListTest` 测试所有方法
+
+**测试数据示例**：
+
+```java
+MyArrayList<String> list = new MyArrayList<>();
+list.add("Java");
+list.add("Python");
+list.add("C++");
+System.out.println(list);           // [Java, Python, C++]
+System.out.println(list.size());    // 3
+System.out.println(list.get(1));    // Python
+list.set(1, "JavaScript");
+list.remove(0);
+System.out.println(list);           // [JavaScript, C++]
+System.out.println(list.isEmpty()); // false
+list.clear();
+System.out.println(list.isEmpty()); // true
+```
+
+---