Merge branch 'develop1'

# Conflicts:
#	src/web/servlet/student/DeleteSelectStudentServlet.java
#	src/web/servlet/verifycode/CheckCodeServlet.java

src/service/AdminService.java

@@ -1,18 +1,43 @@
-package service;
+以下是添加注释后的代码：
 
+```java
+package service;
 
 import domain.Admin;
 
 /**
- * 管理员的业务接口
+ * 管理员的业务接口，定义了与管理员相关的业务操作方法，供具体的服务实现类去实现这些方法，以完成相应的业务逻辑。
  */
 public interface AdminService {
     /**
-     * 管理员登录
+     * 管理员登录方法。
+     * 接收一个表示管理员信息的Admin对象作为参数，用于验证管理员登录的合法性，
+     * 如果登录验证通过，则返回对应的Admin对象（通常包含登录成功后的相关信息等），若验证失败可能返回null或者抛出相应异常（具体取决于实现类的设计）。
+     *
+     * @param admin 包含管理员登录相关信息（如用户名、密码等）的Admin对象
+     * @return 登录成功的Admin对象，如果登录失败则返回情况依具体实现而定
      */
     Admin login(Admin admin);
 
+    /**
+     * 更新管理员密码的方法。
+     * 通过传入管理员的唯一标识（adminid）以及新密码（newpassword）来更新对应的管理员账户密码。
+     * 具体的更新操作细节（如数据库更新等）由实现该接口的类去完成。
+     *
+     * @param adminid    管理员的唯一标识，用于定位到具体要更新密码的管理员账户
+     * @param newpassword 要设置的新密码字符串
+     */
     void updatePassword(String adminid, String newpassword);
 
+    /**
+     * 根据管理员对象中的相关标识（比如ID等信息，具体取决于Admin类的定义）查找对应的管理员信息。
+     * 返回查找到的Admin对象，如果未找到可能返回null（具体取决于实现类的处理方式）。
+     *
+     * @param admin 包含用于查找管理员的相关标识信息的Admin对象
+     * @return 查找到的Admin对象，如果查找失败则返回情况依具体实现而定
+     */
     Admin findAdminById(Admin admin);
 }
+```
+
+注释对接口的整体作用以及每个方法的功能、参数含义、返回值情况等进行了详细的说明，有助于后续代码的阅读和维护，以及其他开发人员理解该接口的用途和使用方式。 

src/service/CDCService.java

@@ -1,20 +1,47 @@
 package service;
 
-
 import domain.Admin;
 import domain.CDC;
-
 import java.util.List;
 
 /**
- * 学院专业班级的业务接口
+ * 学院专业班级的业务接口，用于定义与学院、专业、班级相关业务操作的抽象方法，
+ * 具体的业务逻辑将由实现该接口的类来完成，通过该接口可以统一操作规范，方便进行不同实现的替换等操作。
  */
 public interface CDCService {
+    /**
+     * 查询所有学院信息的方法。
+     * 返回一个包含所有学院信息的CDC对象列表，列表中每个CDC对象代表一个学院，
+     * 如果没有查询到学院信息，则返回一个空列表。
+     *
+     * @return 包含所有学院信息的CDC对象列表
+     */
     List<CDC> findAllCollege();
 
+    /**
+     * 查询所有专业信息的方法。
+     * 返回一个包含所有专业信息的CDC对象列表，列表中每个CDC对象代表一个专业，
+     * 若未查询到专业信息则返回空列表，具体的专业信息获取逻辑由实现该接口的类负责。
+     *
+     * @return 包含所有专业信息的CDC对象列表
+     */
     List<CDC> findAllDepartment();
 
+    /**
+     * 查询所有班级信息的方法。
+     * 会返回一个装有所有班级信息的CDC对象列表，每个CDC对象对应一个班级，
+     * 当不存在班级信息时返回空列表，具体的班级信息查询实现由接口实现类来确定。
+     *
+     * @return 包含所有班级信息的CDC对象列表
+     */
     List<CDC> findAllClass();
 
+    /**
+     * 查询所有学院、专业、班级相关信息的方法。
+     * 返回一个综合了所有学院、专业、班级信息的CDC对象列表，
+     * 如果没有任何相关信息则返回空列表，具体如何整合以及查询这些信息取决于实现该接口的类。
+     *
+     * @return 包含所有学院、专业、班级信息的CDC对象列表
+     */
     List<CDC> findAll();
 }

src/service/ComplaintService.java

@@ -1,14 +1,28 @@
 package service;
 
 import domain.Complaint;
-
 import java.util.List;
 
 /**
- * 小吐槽的业务接口
+ * 小吐槽的业务接口，主要用于定义与用户吐槽相关业务操作的抽象方法，
+ * 具体的业务逻辑将由实现该接口的类去完成，方便在不同场景下按照统一规范来处理吐槽相关事务。
  */
 public interface ComplaintService {
+    /**
+     * 查询所有吐槽信息的方法。
+     * 该方法会返回一个包含所有吐槽信息的Complaint对象列表，
+     * 如果当前没有任何吐槽记录，那么将会返回一个空列表。
+     *
+     * @return 包含所有吐槽信息的Complaint对象列表
+     */
     List<Complaint> findAll();
 
+    /**
+     * 添加吐槽信息的方法。
+     * 接收一个Complaint对象作为参数，这个对象包含了用户提交的吐槽相关内容，
+     * 具体的添加操作（比如将吐槽信息保存到数据库等）由实现该接口的类来负责完成。
+     *
+     * @param complaint 包含吐槽相关内容的Complaint对象
+     */
     void addComplaint(Complaint complaint);
 }

src/service/CourseService.java

@@ -2,10 +2,36 @@ package service;
 
 import domain.Course;
 
+/**
+ * 课程相关业务的接口，定义了针对课程进行操作的一些抽象方法，
+ * 具体的业务逻辑实现将由实现该接口的类来完成，以此来规范课程相关业务操作的流程。
+ */
 public interface CourseService {
+    /**
+     * 添加选修课程的方法。
+     * 接收一个Course对象作为参数，该Course对象包含了选修课程的相关信息（如课程名称、授课教师、学分等），
+     * 由具体实现该接口的类来负责将该选修课程信息添加到相应的存储介质（比如数据库等）中，完成选修课程的添加操作。
+     *
+     * @param course 包含选修课程相关信息的Course对象
+     */
     void addOptionalCourse(Course course);
 
+    /**
+     * 根据课程编号查找已选课程的方法。
+     * 通过传入课程的唯一标识符（课程编号cid），在已选课程相关的数据存储（例如数据库中已选课程记录等）中查找对应的课程信息，
+     * 如果找到，则返回对应的Course对象（该对象包含课程详细信息），若未找到则可能返回null（具体取决于实现类的处理方式）。
+     *
+     * @param cid 课程的唯一编号，用于定位要查找的已选课程
+     * @return 查找到的已选课程对应的Course对象，如果未找到则返回情况依具体实现而定
+     */
     Course findSelectCourseByCourseId(String cid);
 
+    /**
+     * 根据课程编号删除课程相关服务记录的方法。
+     * 传入课程的唯一编号（cid），由实现该接口的类来负责从相应的存储（比如数据库中课程服务相关记录等）中删除该编号对应的课程相关记录，
+     * 具体的删除逻辑及涉及的相关操作（如关联数据的处理等）由实现该接口的类依据业务需求去完成。
+     *
+     * @param cid 课程的唯一编号，用于定位要删除的课程相关记录
+     */
     void deleteServiceById(String cid);
 }

src/service/NotifyService.java

@@ -1,23 +1,47 @@
 package service;
 
 import domain.Notify;
-
 import java.util.List;
 
 /**
- * 公告的业务接口
+ * 公告的业务接口，用于定义与公告相关业务操作的抽象方法，
+ * 为具体实现公告的发布、查询、删除等业务逻辑提供统一的规范，方便后续不同的实现类遵循此规范来操作公告相关事务。
  */
 public interface NotifyService {
     /**
-     * 公告发布
+     * 公告发布方法。
+     * 接收一个Notify对象作为参数，该对象包含了要发布公告的详细内容（如公告标题、正文、发布时间等信息），
+     * 由具体实现该接口的类负责将此公告信息添加到相应的存储介质（比如数据库等）中，完成公告的发布操作。
+     *
+     * @param notify 包含公告详细内容的Notify对象
      */
     void addNotify(Notify notify);
 
+    /**
+     * 查询公告的方法。
+     * 此方法用于获取符合特定条件的公告信息，具体的查询条件及逻辑由实现该接口的类去定义，
+     * 返回一个包含满足条件的公告信息的Notify对象列表，若没有符合条件的公告则返回空列表。
+     *
+     * @return 包含满足条件的公告信息的Notify对象列表
+     */
     List<Notify> find();
 
+    /**
+     * 查询所有公告信息的方法。
+     * 会返回一个包含所有已发布公告的Notify对象列表，不管是否有筛选条件等情况，
+     * 如果当前没有任何已发布的公告，则返回一个空列表。
+     *
+     * @return 包含所有已发布公告的Notify对象列表
+     */
     List<Notify> findAll();
 
+    /**
+     * 根据公告编号删除公告的方法。
+     * 传入公告的唯一编号（notifyid），由实现该接口的类负责从相应的存储（比如数据库中公告记录等）中删除该编号对应的公告信息，
+     * 具体的删除逻辑及涉及的相关操作（如关联数据的处理等）由实现该接口的类依据业务需求去完成。
+     *
+     * @param notifyid 公告的唯一编号，用于定位要删除的公告
+     */
     void deleteNotifyById(String notifyid);
-
-
+}
 }

src/service/PhotoService.java

@@ -2,10 +2,36 @@ package service;
 
 import domain.Photo;
 
+/**
+ * 照片相关业务的接口，定义了针对照片进行操作的一些抽象方法，
+ * 其具体业务逻辑将由实现该接口的类来完成，通过该接口可以规范照片相关业务操作流程，方便在不同应用场景下进行拓展和维护。
+ */
 public interface PhotoService {
+    /**
+     * 添加照片的方法。
+     * 接收一个Photo对象作为参数，该Photo对象包含了要添加照片的相关信息，比如照片本身的数据、照片名称、拍摄时间等（具体取决于Photo类的定义），
+     * 由具体实现该接口的类负责将此照片信息保存到相应的存储位置（例如数据库、文件系统等）中，完成照片的添加操作。
+     *
+     * @param photo 包含照片相关信息的Photo对象
+     */
     void addPhoto(Photo photo);
 
+    /**
+     * 根据照片编号查找照片的方法。
+     * 通过传入照片的唯一标识符（照片编号id），在存储照片信息的地方（如数据库的照片表等）查找对应的照片，
+     * 如果找到，则返回对应的Photo对象（该对象包含照片的详细信息），若没找到则可能返回null（具体取决于实现类的处理方式）。
+     *
+     * @param id 照片的唯一编号，用于定位要查找的照片
+     * @return 查找到的照片对应的Photo对象，如果未找到则返回情况依具体实现而定
+     */
     Photo findPhotoByPhotoId(String id);
 
+    /**
+     * 更新照片信息的方法。
+     * 接收一个Photo对象作为参数，该对象包含了更新后的照片相关信息，例如对照片进行了重新命名、修改了拍摄时间等（具体视业务需求而定），
+     * 由具体实现该接口的类根据传入的Photo对象来更新相应存储位置（如数据库中对应记录等）里照片的信息，完成照片信息的更新操作。
+     *
+     * @param photo 包含更新后照片相关信息的Photo对象
+     */
     void updatePhoto(Photo photo);
 }

src/service/SelectCourseService.java

@@ -1,13 +1,44 @@
 package service;
 
 import domain.SelectCourse;
-
 import java.util.List;
 
+/**
+ * 选课相关业务的接口，定义了针对学生选课情况以及课程成绩等相关操作的抽象方法，
+ * 具体的业务逻辑将由实现该接口的类来完成，为处理选课及成绩相关事务提供统一的规范和调用入口。
+ */
 public interface SelectCourseService {
+    /**
+     * 根据课程编号查找学生已选该课程情况的方法。
+     * 通过传入课程的唯一标识符（课程编号cid），从相关存储（例如数据库中选课记录等）里查询出选修了该课程的所有学生的选课信息，
+     * 并以SelectCourse对象列表的形式返回，列表中的每个SelectCourse对象代表一名学生关于该课程的选课相关信息（如选课时间、是否退选等情况），
+     * 如果没有学生选修该课程，则返回一个空列表。
+     *
+     * @param cid 课程的唯一编号，用于定位要查找学生选课情况的课程
+     * @return 包含选修该课程的学生选课信息的SelectCourse对象列表，若没有学生选修则返回空列表
+     */
     List<SelectCourse> findStudentSelectedCourseByCourseId(String cid);
 
+    /**
+     * 根据课程编号和学生编号查找学生该课程成绩的方法。
+     * 传入课程的唯一编号（cid）以及学生的唯一编号（sid），在存储成绩信息的相关数据结构（比如数据库成绩表等）中查找对应的学生在该课程上的成绩记录，
+     * 如果找到，则返回对应的SelectCourse对象（该对象包含成绩等相关选课信息），若未找到相应成绩记录则可能返回null（具体取决于实现类的处理方式）。
+     *
+     * @param cid 课程的唯一编号，用于定位要查找成绩的课程
+     * @param sid 学生的唯一编号，用于定位要查找成绩的学生
+     * @return 查找到的包含学生该课程成绩的SelectCourse对象，如果未找到则返回情况依具体实现而定
+     */
     SelectCourse findScoreByCourseIdAndStudentId(String cid, String sid);
 
+    /**
+     * 根据课程编号和学生编号更新学生该课程成绩的方法。
+     * 接收课程的唯一编号（cid）、学生的唯一编号（sid）以及要更新的成绩（sScore）作为参数，
+     * 由实现该接口的类负责根据传入的参数在相应存储（如数据库中成绩记录等）里更新指定学生在指定课程上的成绩信息，
+     * 具体的更新逻辑及涉及的关联数据处理（比如成绩更新后的相关统计等）由实现该接口的类依据业务需求去完成。
+     *
+     * @param cid 课程的唯一编号，用于定位要更新成绩的课程
+     * @param sid 学生的唯一编号，用于定位要更新成绩的学生
+     * @param sScore 要更新的学生该课程的成绩
+     */
     void upDateScoreByCidAndSid(String cid, String sid, String sScore);
 }

src/service/StudentService.java

@@ -8,44 +8,146 @@ import java.util.List;
 import java.util.Map;
 
 /**
- * 学生管理的业务接口
+ * 学生管理的业务接口，定义了一系列与学生相关业务操作的抽象方法，
+ * 这些方法涵盖了学生信息查询、登录、注册、信息更新、选课操作以及学生相关数据删除等多方面内容，
+ * 具体的业务逻辑将由实现该接口的类来完成，方便对学生管理相关业务进行统一规范和拓展。
  */
 public interface StudentService {
     /**
-     * 分页条件查询
-     * @param currentPage
-     * @param rows
-     * @param condition
-     * @return
+     * 分页条件查询方法。
+     * 根据传入的当前页码（currentPage）、每页显示行数（rows）以及查询条件（condition，以Map形式存储，键为查询条件字段名，值为对应字段值的数组），
+     * 从数据源（如数据库等）中按照分页和给定条件筛选出相应的学生信息，返回一个PageBean对象，该对象中包含了符合条件的学生信息列表以及分页相关的元数据（如总页数、总记录数等）。
+     *
+     * @param currentPage 当前页码，用于确定要获取哪一页的数据
+     * @param rows 每页显示的行数，用于控制每页展示的学生信息数量
+     * @param condition 包含查询条件的Map对象，用于筛选出符合特定条件的学生信息
+     * @return 包含符合条件学生信息及分页相关元数据的PageBean<Student>对象
      */
     PageBean<Student> findStudentByPage(String currentPage, String rows, Map<String, String[]> condition);
 
     /**
-     * 查询所有学生信息
+     * 查询所有学生信息的方法。
+     * 该方法会从数据源（例如数据库中的学生表）中获取所有已存储的学生信息，
+     * 并以List<Student>列表形式返回，列表中的每个Student对象代表一名学生的详细信息，
+     * 如果没有学生信息记录，则返回一个空列表。
+     *
+     * @return 包含所有学生详细信息的List<Student>对象，若没有学生信息则返回空列表
      */
     List<Student> findAll();
 
+    /**
+     * 学生登录方法。
+     * 接收一个Student对象作为参数，该对象包含了学生登录时提供的相关信息（如学号、密码等），
+     * 通过具体实现该接口的类来验证这些登录信息是否正确，若验证通过则返回对应的Student对象（通常包含更多学生相关信息），
+     * 若验证失败可能返回null或者抛出相应异常（具体取决于实现类的设计）。
+     *
+     * @param student 包含学生登录相关信息的Student对象
+     * @return 登录成功的Student对象，如果登录失败则返回情况依具体实现而定
+     */
     Student login(Student student);
 
+    /**
+     * 根据学生对象中的相关标识（比如学号等信息，具体取决于Student类的定义）查找对应的学生信息的方法。
+     * 返回查找到的Student对象，如果未找到可能返回null（具体取决于实现类的处理方式）。
+     *
+     * @param student 包含用于查找学生的相关标识信息的Student对象
+     * @return 查找到的Student对象，如果查找失败则返回情况依具体实现而定
+     */
     Student findStudentById(Student student);
 
+    /**
+     * 学生注册方法。
+     * 接收一个Student对象作为参数，该对象包含了新学生注册时需要填写的各项信息（如姓名、学号、密码、个人资料等），
+     * 由实现该接口的类负责将这些学生信息保存到相应的存储介质（比如数据库中的学生表）中，完成学生注册操作。
+     *
+     * @param student 包含新学生注册相关信息的Student对象
+     */
     void register(Student student);
 
+    /**
+     * 更新学生信息的方法。
+     * 接收一个Student对象作为参数，该对象包含了更新后的学生个人信息（如修改后的姓名、联系方式等），
+     * 具体实现该接口的类会根据传入的Student对象来更新相应存储位置（如数据库中对应学生记录）里的学生信息，完成信息更新操作。
+     *
+     * @param student 包含更新后学生相关信息的Student对象
+     */
     void updateInfo(Student student);
 
+    /**
+     * 更新学生密码的方法。
+     * 通过传入学生的唯一标识（studentid，如学号等）以及新密码（newpassword）来更新对应的学生账户密码。
+     * 具体的更新操作细节（如数据库更新等）由实现该接口的类去完成。
+     *
+     * @param studentid 学生的唯一标识，用于定位到具体要更新密码的学生账户
+     * @param newpassword 要设置的新密码字符串
+     */
     void updatePassword(String studentid, String newpassword);
 
+    /**
+     * 根据学生编号查找该学生所有已选课程信息的方法。
+     * 传入学生的唯一编号（studentid），从相关存储（例如数据库中选课记录等）里查询出该学生已选修的所有课程信息，
+     * 并以List<SelectCourse>列表形式返回，列表中的每个SelectCourse对象代表一门该学生已选课程的相关信息（如课程名称、成绩等情况），
+     * 如果该学生没有选修任何课程，则返回一个空列表。
+     *
+     * @param studentid 学生的唯一编号，用于定位要查找选课信息的学生
+     * @return 包含该学生所有已选课程信息的List<SelectCourse>对象，若该学生未选课则返回空列表
+     */
     List<SelectCourse> findAllSelectCourse(String studentid);
 
+    /**
+     * 查询所有可选课程信息的方法。
+     * 会从相关存储（比如数据库中的课程表）中获取所有可供学生选择的课程信息，
+     * 并以List<Course>列表形式返回，列表中的每个Course对象代表一门可选课程的详细信息（如课程名称、授课教师、学分等），
+     * 如果没有可选课程信息，则返回一个空列表。
+     *
+     * @return 包含所有可选课程详细信息的List<Course>对象，若没有可选课程则返回空列表
+     */
     List<Course> findAllOptionalCourse();
 
+    /**
+     * 学生添加选课的方法。
+     * 接收学生的唯一编号（studentid）以及课程的唯一编号（courseid）作为参数，
+     * 由实现该接口的类负责将该学生选择该课程的相关记录保存到相应存储介质（比如数据库中的选课表）中，完成选课操作。
+     *
+     * @param studentid 学生的唯一编号，用于定位要选课的学生
+     * @param courseid 课程的唯一编号，用于定位要选的课程
+     */
     void addSelectCourse(String studentid, String courseid);
 
+    /**
+     * 根据学生编号删除学生信息的方法。
+     * 传入学生的唯一编号（studentid），由实现该接口的类负责从相应的存储（比如数据库中的学生记录等）中删除该编号对应的学生信息，
+     * 具体的删除逻辑及涉及的相关操作（如关联数据的处理等）由实现该接口的类依据业务需求去完成。
+     *
+     * @param studentid 学生的唯一编号，用于定位要删除的学生信息
+     */
     void deleteStudentById(String studentid);
 
+    /**
+     * 根据学生编号数组批量删除学生选课信息的方法。
+     * 传入包含多个学生编号的数组（sids），由实现该接口的类负责从相应存储（如数据库中的选课记录等）中批量删除这些学生编号对应的选课信息，
+     * 具体的批量删除逻辑及涉及的相关操作（如数据一致性检查等）由实现该接口的类依据业务需求去完成。
+     *
+     * @param sids 包含要删除选课信息的学生编号的数组
+     */
     void deleteSelectStudent(String[] sids);
 
+    /**
+     * 添加学生所有信息的方法，通常用于更新学生的全部信息场景（可能涉及多个表或复杂的数据结构更新）。
+     * 接收一个Student对象作为参数，该对象包含了要更新的学生全部相关信息，
+     * 由实现该接口的类按照业务需求和数据存储规则来更新相应存储位置里的学生所有信息，完成信息更新操作。
+     *
+     * @param updateStudent 包含更新后学生全部相关信息的Student对象
+     */
     void addStudentAllInfo(Student updateStudent);
 
+    /**
+     * 查询所有学生选课信息的方法。
+     * 会从相关存储（比如数据库中选课记录等）中获取所有学生的选课信息，
+     * 并以List<SelectCourse>列表形式返回，列表中的每个SelectCourse对象代表一名学生关于某门课程的选课相关信息（如课程名称、成绩等情况），
+     * 如果没有任何选课信息，则返回一个空列表。
+     *
+     * @return 包含所有学生选课信息的List<SelectCourse>对象，若没有选课信息则返回空列表
+     */
     List<SelectCourse> findSelectCourseAllStudent();
 }

src/service/TeacherService.java

@@ -2,35 +2,107 @@ package service;
 
 import domain.Course;
 import domain.Teacher;
-
 import java.util.List;
 
 /**
- * 教师管理的业务接口
+ * 教师管理的业务接口，定义了一系列与教师相关业务操作的抽象方法，
+ * 涵盖教师登录验证、教师信息查询、课程相关操作（如查找授课课程、更新课程信息、删除课程等）以及教师个人信息更新、密码修改等多方面功能，
+ * 具体的业务逻辑将由实现该接口的类来完成，以此规范教师管理相关业务流程，方便在不同应用场景下进行拓展与维护。
  */
 public interface TeacherService {
     /**
-     * 教师登录
+     * 教师登录方法。
+     * 接收一个Teacher对象作为参数，该对象包含了教师登录时提供的相关信息（如工号、密码等），
+     * 通过具体实现该接口的类来验证这些登录信息是否正确，若验证通过则返回对应的Teacher对象（通常包含更多教师相关信息），
+     * 若验证失败可能返回null或者抛出相应异常（具体取决于实现类的设计）。
+     *
+     * @param teacher 包含教师登录相关信息的Teacher对象
+     * @return 登录成功的Teacher对象，如果登录失败则返回情况依具体实现而定
      */
     Teacher login(Teacher teacher);
 
+    /**
+     * 查询所有教师信息的方法。
+     * 该方法会从数据源（例如数据库中的教师表）中获取所有已存储的教师信息，
+     * 并以List<Teacher>列表形式返回，列表中的每个Teacher对象代表一名教师的详细信息，
+     * 如果没有教师信息记录，则返回一个空列表。
+     *
+     * @return 包含所有教师详细信息的List<Teacher>对象，若没有教师信息则返回空列表
+     */
     List<Teacher> findAll();
 
+    /**
+     * 根据教师编号查找该教师所授的所有可选课程信息的方法。
+     * 传入教师的唯一编号（T_id），从相关存储（例如数据库中课程与教师关联表等）里查询出该教师可以授课的所有可选课程信息，
+     * 并以List<Course>列表形式返回，列表中的每个Course对象代表一门该教师可授的可选课程的详细信息（如课程名称、学分、授课时间等情况），
+     * 如果该教师没有可授的可选课程，则返回一个空列表。
+     *
+     * @param T_id 教师的唯一编号，用于定位要查找可选课程信息的教师
+     * @return 包含该教师所授所有可选课程信息的List<Course>对象，若该教师无可选课程则返回空列表
+     */
     List<Course> findMySelfOptionalCourse(String T_id);
 
+    /**
+     * 根据课程编号查找对应的可选课程信息的方法。
+     * 通过传入课程的唯一标识符（课程编号cid），在存储课程信息的地方（如数据库的课程表等）查找对应的可选课程，
+     * 如果找到，则返回对应的Course对象（该对象包含课程的详细信息），若没找到则可能返回null（具体取决于实现类的处理方式）。
+     *
+     * @param cid 课程的唯一编号，用于定位要查找的可选课程
+     * @return 查找到的可选课程对应的Course对象，如果未找到则返回情况依具体实现而定
+     */
     Course findOptionalCourseByCourseId(String cid);
 
+    /**
+     * 更新课程信息的方法。
+     * 接收一个Course对象作为参数，该对象包含了更新后的课程相关信息（如修改后的课程名称、授课时间、学分等），
+     * 具体实现该接口的类会根据传入的Course对象来更新相应存储位置（如数据库中对应课程记录）里的课程信息，完成课程信息更新操作。
+     *
+     * @param updateCourse 包含更新后课程相关信息的Course对象
+     */
     void updateCourseInfo(Course updateCourse);
 
-    void deleteCourseById(String cid);
-
+    /**
+     * 根据课程编号删除课程信息的方法。
+     * 传入课程的唯一编号（cid），由实现该接口的类负责从相应的存储（比如数据库中的课程记录等）中删除该编号对应的课程信息，
+     * 具体的删除逻辑及涉及的相关操作（如关联数据的处理等）由实现该接口的类依据业务需求去完成。
+     *
+     * @param cid 课程的唯一编号，用于定位要删除的课程信息
+     */
     void updatePassword(String teacherid, String newpassword);
 
+    /**
+     * 根据教师对象中的相关标识（比如工号等信息，具体取决于Teacher类的定义）查找对应的教师信息的方法。
+     * 返回查找到的Teacher对象，如果未找到可能返回null（具体取决于实现类的处理方式）。
+     *
+     * @param teacher 包含用于查找教师的相关标识信息的Teacher对象
+     * @return 查找到的Teacher对象，如果查找失败则返回情况依具体实现而定
+     */
     Teacher findTeacherById(Teacher teacher);
 
+    /**
+     * 添加教师所有信息的方法，通常用于更新教师的全部信息场景（可能涉及多个表或复杂的数据结构更新）。
+     * 接收一个Teacher对象作为参数，该对象包含了要更新的教师全部相关信息，
+     * 由实现该接口的类按照业务需求和数据存储规则来更新相应存储位置里的教师所有信息，完成信息更新操作。
+     *
+     * @param updateTeacher 包含更新后教师全部相关信息的Teacher对象
+     */
     void addTeacherAllInfo(Teacher updateTeacher);
 
+    /**
+     * 根据教师编号删除教师信息的方法。
+     * 传入教师的唯一编号（teacherid），由实现该接口的类负责从相应的存储（比如数据库中的教师记录等）中删除该编号对应的教师信息，
+     * 具体的删除逻辑及涉及的相关操作（如关联数据的处理等）由实现该接口的类依据业务需求去完成。
+     *
+     * @param teacherid 教师的唯一编号，用于定位要删除的教师信息
+     */
     void deleteTeacherById(String teacherid);
 
+    /**
+     * 更新教师个人信息的方法。
+     * 接收一个Teacher对象作为参数，该对象包含了更新后的教师个人信息（如修改后的姓名、联系方式等），
+     * 具体实现该接口的类会根据传入的Teacher对象来更新相应存储位置（如数据库中对应教师记录）里的教师信息，完成信息更新操作。
+     *
+     * @param updateTeacher 包含更新后教师个人信息的Teacher对象
+     */
     void updateInfo(Teacher updateTeacher);
 }

src/utils/JDBCUtils.java

@@ -1,7 +1,6 @@
 package utils;
 
 import com.alibaba.druid.pool.DruidDataSourceFactory;
-
 import javax.sql.DataSource;
 import java.sql.Connection;
 import java.sql.ResultSet;
@@ -10,17 +9,22 @@ import java.sql.Statement;
 import java.util.Properties;
 
 /**
- * Druid连接池工具类,将来dao层调用
+ * Druid连接池工具类，主要用于管理数据库连接相关操作，方便将来dao层调用，
+ * 通过该工具类可以获取数据库连接、释放相关资源（如关闭结果集、语句对象、连接等）以及获取连接池对象等，有助于更规范、高效地进行数据库交互操作。
  */
 public class JDBCUtils {
-    private static DataSource dataSource;   //定义成员变量DataSource
+    // 定义成员变量DataSource，用于存储通过Druid连接池工厂创建的数据源对象，后续通过该数据源获取数据库连接
+    private static DataSource dataSource;  
+
     static {
         try {
-            //加载配置文件
+            // 加载配置文件，此处通过类加载器获取类路径下名为"druid.properties"的配置文件，并将其加载到Properties对象中，
+            // 配置文件中通常包含了连接数据库所需的各种参数，如数据库驱动、连接地址、用户名、密码等信息。
             Properties properties = new Properties();
             properties.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
 
-            //获取DataSource
+            // 获取DataSource，利用Druid提供的DruidDataSourceFactory工厂类，根据加载的配置文件属性创建数据源对象，
+            // 如果创建过程出现异常（如配置文件格式错误、缺少关键配置项等），则会打印异常堆栈信息。
             dataSource = DruidDataSourceFactory.createDataSource(properties);
         } catch (Exception e) {
             e.printStackTrace();
@@ -28,19 +32,36 @@ public class JDBCUtils {
     }
 
     /**
-     * 获取连接
+     * 获取连接方法，用于从之前创建的数据源对象中获取一个数据库连接，
+     * 若获取过程出现SQLException异常（比如数据库连接数已满等情况），则会将该异常抛出，由调用者进行相应处理。
+     *
+     * @return 返回一个可用的数据库连接对象Connection
+     * @throws SQLException 当获取连接出现问题时抛出该异常
      */
     public static Connection getConnection() throws SQLException {
         return dataSource.getConnection();
     }
 
     /**
-     * 释放资源
+     * 释放资源方法（重载形式之一），主要用于关闭Statement和Connection对象，释放相关的数据库资源，
+     * 该方法内部会调用另一个重载的close方法，传入null作为ResultSet参数，以实现关闭Statement和Connection的操作。
+     *
+     * @param statement 要关闭的SQL语句执行对象，用于执行SQL语句操作，使用完后需要关闭释放资源
+     * @param connection 要关闭的数据库连接对象，使用完后需要归还到连接池中，避免资源浪费
      */
     public static void close(Statement statement, Connection connection) {
         close(null, statement, connection);
     }
 
+    /**
+     * 释放资源方法（重载形式之二），用于关闭ResultSet、Statement和Connection对象，全面释放数据库操作相关的资源，
+     * 会按照先关闭ResultSet（如果不为空），再关闭Statement，最后关闭Connection并归还到连接池的顺序进行操作，
+     * 如果在关闭过程中出现SQLException异常（比如资源已经被关闭等情况），则会打印异常堆栈信息。
+     *
+     * @param resultSet 要关闭的查询结果集对象，若执行了查询操作并获取到结果集，使用完后需关闭释放资源，可为null表示无结果集需要关闭
+     * @param statement 要关闭的SQL语句执行对象，同上述close方法中参数含义
+     * @param connection 要关闭的数据库连接对象，同上述close方法中参数含义
+     */
     public static void close(ResultSet resultSet, Statement statement, Connection connection) {
         if (resultSet!= null) {
             try {
@@ -60,7 +81,7 @@ public class JDBCUtils {
 
         if (connection!= null) {
             try {
-                connection.close();//归还连接
+                connection.close();// 归还连接，将使用完的数据库连接归还给连接池，以便后续其他操作可以继续复用该连接
             } catch (SQLException e) {
                 e.printStackTrace();
             }
@@ -68,9 +89,15 @@ public class JDBCUtils {
     }
 
     /**
-     * 获取连接池方法
+     * 获取连接池方法，用于获取之前通过配置文件创建并存储的数据源对象，
+     * 返回该DataSource对象，外部可以通过该对象进一步获取连接或者进行其他与连接池相关的操作。
+     *
+     * @return 返回创建好的数据源对象DataSource
      */
     public static DataSource getDataSource() {
         return dataSource;
     }
 }
+//whdiwfb
+//
+///

src/web/servlet/admin/AddStudentInfoServlet.java

@@ -3,7 +3,6 @@ package web.servlet.admin;
 import domain.Student;
 import service.StudentService;
 import service.impl.StudentServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -12,8 +11,28 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.Date;
 
+/**
+ * AddStudentInfoServlet类，继承自HttpServlet，用于处理添加学生信息相关的请求，
+ * 通过接收前端传来的学生信息参数，判断学生是否已存在，若不存在则将新的学生信息添加到系统中，
+ * 并根据操作结果向前端返回相应提示信息，最终转发到相应页面。该Servlet被映射到"/addStudentInfoServlet"路径下，处理POST和GET请求。
+ */
 @WebServlet("/addStudentInfoServlet")
 public class AddStudentInfoServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，主要逻辑如下：
+     * 1. 设置请求编码为"utf-8"，确保能正确接收和处理包含中文等特殊字符的参数。
+     * 2. 创建StudentService的实现类对象，用于调用学生相关业务逻辑方法，比如查找学生信息、添加学生全部信息等操作。
+     * 3. 从请求参数中获取学生的编号（student-id），通过该编号构建一个Student对象，并调用服务层的方法查找该学生是否已存在于系统中。
+     * 4. 如果学生已存在，则在请求域中设置提示信息，告知前端“已存在该学生，请重新添加！”并附带当前时间，然后转发到“addStudentServlet”页面。
+     * 5. 如果学生不存在，则继续从请求参数中获取学生的其他详细信息（如姓名、性别、年龄、联系方式等），同时对部分可能为空的学院、专业、班级信息进行默认值设置（设置为“待分配”）。
+     * 6. 构建一个完整的Student对象，包含所有获取到的学生信息，然后调用服务层的方法将该学生的全部信息添加到系统中。
+     * 7. 在请求域中设置添加成功的提示信息，告知前端“添加成功！”并附带当前时间，最后转发到“addStudentServlet”页面。
+     *
+     * @param request  HttpServletRequest对象，用于获取前端传来的请求参数等信息
+     * @param response HttpServletResponse对象，用于向前端返回响应信息，如转发页面、设置响应状态码等
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应数据时出现输入输出相关异常，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         StudentService service = new StudentServiceImpl();
@@ -65,7 +84,18 @@ public class AddStudentInfoServlet extends HttpServlet {
         }
     }
 
+    /**
+     * 处理GET请求的方法，该方法直接调用doPost方法，使得该Servlet对于GET请求也按照与POST请求相同的逻辑进行处理，
+     * 这样可以简化代码结构，保证无论前端以POST还是GET方式发起请求，都能执行相同的业务逻辑来添加学生信息。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应数据时出现输入输出相关异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }
 }
+//mmm
+//mmm

src/web/servlet/admin/AddStudentServlet.java

@@ -6,7 +6,6 @@ import service.CDCService;
 import service.StudentService;
 import service.impl.CDCServiceImpl;
 import service.impl.StudentServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -16,8 +15,28 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
 
+/**
+ * AddStudentServlet类，继承自HttpServlet，用于处理添加学生相关的请求操作，
+ * 主要功能是从业务层获取学院、专业、班级相关信息，并将这些信息存入到HttpSession中，
+ * 然后将请求转发到添加学生信息的JSP页面（/WEB-INF/admin/addStudent.jsp），方便在页面上展示相关下拉选项等内容以供用户填写学生信息。
+ * 该Servlet被映射到"/addStudentServlet"路径下，并且对GET请求和POST请求进行了统一处理，GET请求会调用与POST请求相同的处理逻辑。
+ */
 @WebServlet("/addStudentServlet")
 public class AddStudentServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确处理包含中文等特殊字符的请求参数，避免出现乱码问题。
+     * 2. 获取当前请求对应的HttpSession对象，HttpSession可用于在多个请求之间存储和共享数据，在这里主要用于传递学院、专业、班级信息到后续的JSP页面。
+     * 3. 创建CDCService的实现类对象（CDCServiceImpl），通过该对象调用相应的业务方法来获取学院、专业、班级相关信息。
+     * 4. 分别调用service2的findAllCollege()、findAllDepartment()、findAllClass()方法，获取所有学院信息列表、所有专业信息列表以及所有班级信息列表，这些列表中的元素通常是CDC类型的对象，包含了相应的名称等属性信息。
+     * 5. 将获取到的学院信息列表、专业信息列表、班级信息列表分别存入到HttpSession中，使用自定义的属性名（"collegeLists"、"departmentLists"、"classLists"）进行存储，以便后续在JSP页面中可以通过这些属性名获取并展示相应信息。
+     * 6. 最后将请求转发到"/WEB-INF/admin/addStudent.jsp"页面，这个页面通常是用于展示添加学生信息的表单界面，通过之前存入HttpSession中的信息可以在页面上为用户提供相应的下拉选择框等交互元素，方便填写学生所属的学院、专业、班级等信息。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关的参数、属性等信息，比如请求中的参数值以及对应的HttpSession对象等
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，例如将请求转发到指定的JSP页面等操作，以向客户端返回相应的页面内容
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如配置错误、转发异常等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出页面内容失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         HttpSession session = request.getSession();
@@ -34,6 +53,15 @@ public class AddStudentServlet extends HttpServlet {
         request.getRequestDispatcher("/WEB-INF/admin/addStudent.jsp").forward(request, response);
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证将学院、专业、班级信息存入Session并转发到添加学生信息的JSP页面这一核心逻辑得以执行。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/admin/AdminPasswordIndexServlet.java

@@ -7,12 +7,39 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
+/**
+ * AdminPasswordIndexServlet类，继承自HttpServlet，用于处理与管理员更新密码相关的请求操作。
+ * 其主要功能是将请求转发到用于管理员更新密码的JSP页面（/WEB-INF/admin/adminUpdatePassword.jsp），
+ * 并且对GET请求和POST请求进行了统一处理，GET请求会调用与POST请求相同的逻辑，即都执行转发到指定JSP页面的操作，
+ * 该Servlet被映射到"/adminPasswordIndexServlet"路径下，以便接收对应的请求并做出相应处理。
+ */
 @WebServlet("/adminPasswordIndexServlet")
 public class AdminPasswordIndexServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 使用request对象的getRequestDispatcher方法获取一个请求转发器，指定要转发的目标页面为"/WEB-INF/admin/adminUpdatePassword.jsp"，
+     * 这个JSP页面通常包含了供管理员输入旧密码、新密码等相关表单元素，用于更新管理员密码的操作界面。
+     * 然后通过转发器的forward方法将当前请求和响应对象传递过去，实现请求的转发，使得客户端浏览器能够展示该JSP页面内容，以便管理员进行后续的密码更新操作。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关的信息，如请求的参数等，在此处主要用于获取请求转发器来进行页面转发操作
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，在转发操作中会将响应传递给目标JSP页面，使其能够正确向客户端返回页面内容
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，例如转发配置错误等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求信息失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.getRequestDispatcher("/WEB-INF/admin/adminUpdatePassword.jsp").forward(request, response);
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证将请求转发到管理员更新密码的JSP页面这一操作得以执行，
+     * 方便管理员可以通过不同的请求方式进入到密码更新的操作界面。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/admin/AdminPasswordUpdateServlet.java

@@ -6,7 +6,6 @@ import service.AdminService;
 import service.StudentService;
 import service.impl.AdminServiceImpl;
 import service.impl.StudentServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -16,8 +15,35 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.Date;
 
+/**
+ * AdminPasswordUpdateServlet类，继承自HttpServlet，用于处理管理员更新密码的具体业务逻辑，
+ * 主要功能包括验证新密码格式及确认密码是否一致，若验证通过则调用服务层方法更新密码，同时更新会话中的管理员信息，
+ * 最后根据操作结果向前端页面返回相应提示信息，并转发到管理员更新密码的JSP页面（/WEB-INF/admin/adminUpdatePassword.jsp）。
+ * 该Servlet被映射到"/adminPasswordUpdateServlet"路径下，且对GET请求和POST请求进行统一处理，GET请求会复用POST请求的处理逻辑。
+ */
 @WebServlet("/adminPasswordUpdateServlet")
 public class AdminPasswordUpdateServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确接收和处理包含中文等特殊字符的请求参数，避免出现乱码问题。
+     * 2. 获取当前请求对应的HttpSession对象，通过该对象可以获取之前存储在会话中的管理员信息，这里主要用于获取当前登录的管理员对象，以便后续关联更新其密码等操作。
+     * 3. 从会话中获取到管理员对象后，取出管理员的唯一标识（通常为管理员编号，如a_id），同时从请求参数中获取新密码（admin-newpassword）和确认密码（admin-ennewpassword）的值。
+     * 4. 定义一个正则表达式（regex）用于验证密码格式，要求密码必须是由3到12位的字母、数字或下划线组成（这里通过"^[\\w]{3,12}$"正则表达式来限定），
+     *    然后使用matches方法对新密码进行格式验证，如果新密码不符合该格式要求，就在请求域中设置提示信息告知前端“密码格式错误，重新提交！”并附带当前时间，
+     *    随后将请求转发到"/WEB-INF/admin/adminUpdatePassword.jsp"页面，让管理员重新输入密码。
+     * 5. 如果新密码格式验证通过，则进一步判断新密码和确认密码是否一致，如果不一致，就在请求域中设置提示信息“密码确认错误，请重新提交！”并附带当前时间，
+     *    同样将请求转发到更新密码的JSP页面，提醒管理员再次确认密码输入。
+     * 6. 当新密码格式正确且与确认密码一致时，创建AdminService的实现类对象（AdminServiceImpl），用于调用管理员相关的业务逻辑方法。
+     * 7. 通过服务层对象调用updatePassword方法，传入管理员编号和新密码，实现数据库中管理员密码的更新操作（具体的更新逻辑由服务层实现类内部完成）。
+     * 8. 接着再次调用服务层的findAdminById方法，根据更新后的管理员信息重新查找该管理员对象（可能是为了获取更新后完整的管理员信息，例如包含最新的修改时间等其他相关属性），
+     *    并将获取到的新管理员对象重新赋值给之前的管理员对象变量，然后将更新后的管理员对象重新存入HttpSession中，覆盖原来会话中的管理员信息，确保会话中的数据与数据库中的最新状态保持一致。
+     * 9. 最后在请求域中设置提示信息“修改成功！”并附带当前时间，再将请求转发到"/WEB-INF/admin/adminUpdatePassword.jsp"页面，告知管理员密码修改成功。
+     *
+     * @param request  HttpServletRequest对象，用于获取前端传来的请求参数、会话中的管理员对象等信息，同时用于进行请求转发等操作
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，如将请求转发到指定页面，以向客户端返回相应的页面内容及提示信息
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如转发异常、从会话获取对象异常等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出页面内容失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         HttpSession session = request.getSession();
@@ -49,6 +75,16 @@ public class AdminPasswordUpdateServlet extends HttpServlet {
 
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证管理员密码更新的整套业务逻辑得以执行，
+     * 包括密码格式验证、更新操作以及根据结果返回提示信息和页面转发等操作，方便管理员通过不同的请求方式来更新密码。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/admin/DoDeleteSelectCourseServlet.java

@@ -5,7 +5,6 @@ import service.CourseService;
 import service.StudentService;
 import service.impl.CourseServiceImpl;
 import service.impl.StudentServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -14,8 +13,29 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 
+/**
+ * DoDeleteSelectCourseServlet类，继承自HttpServlet，用于处理删除选课相关的业务逻辑，
+ * 主要功能是接收前端传来的课程编号参数，调用课程服务层的方法删除对应课程相关服务记录，然后将请求转发到学生可选课程展示的Servlet对应的路径，
+ * 以此实现删除选课操作后页面的相应更新，该Servlet对GET请求和POST请求进行统一处理，GET请求复用POST请求的逻辑，并且被映射到"/doDeleteSelectCourseServlet"路径下以接收对应请求。
+ */
 @WebServlet("/doDeleteSelectCourseServlet")
 public class DoDeleteSelectCourseServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确接收和处理包含中文等特殊字符的请求参数，避免因编码问题出现乱码情况。
+     * 2. 获取当前请求对应的HttpSession对象，虽然在当前代码中暂时未体现出对该会话对象的进一步使用，但它可用于在后续拓展功能时存储一些与请求相关的中间数据或者用户状态等信息。
+     * 3. 从请求参数中获取课程的唯一编号（cid），这个编号将用于定位要删除的具体课程相关服务记录，它通常由前端页面在发起删除操作时传递过来，指明要删除哪一门课程的相关记录。
+     * 4. 创建CourseService的实现类对象（CourseServiceImpl），通过该对象可以调用课程相关业务逻辑的具体实现方法，在这里主要是为了调用删除课程相关服务记录的方法。
+     * 5. 调用service的deleteServiceById方法，传入获取到的课程编号（cid），由具体的服务层实现类根据该编号去对应的存储介质（比如数据库中课程服务相关表等）里删除相应的课程记录，
+     *    完成课程相关服务记录的删除操作（具体的删除逻辑及涉及的关联数据处理等由服务层实现类内部完成）。
+     * 6. 使用request对象的getRequestDispatcher方法获取一个请求转发器，指定要转发的目标路径为"/studentOptionalCourseServlet"，
+     *    这个路径对应的Servlet通常用于展示学生可选课程相关信息，通过转发到该Servlet对应的页面，使得在删除课程相关服务记录后，页面能够及时更新并展示最新的可选课程情况。
+     *
+     * @param request  HttpServletRequest对象，用于获取前端传来的请求参数（如课程编号cid）以及用于进行请求转发操作等，是处理请求相关逻辑的关键对象
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，在转发操作中会将响应传递给目标Servlet对应的页面，使其能够正确向客户端返回页面内容，完成页面更新展示
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如转发配置错误、获取请求参数异常等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出页面内容失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         HttpSession session = request.getSession();
@@ -25,6 +45,16 @@ public class DoDeleteSelectCourseServlet extends HttpServlet {
         request.getRequestDispatcher("/studentOptionalCourseServlet").forward(request, response);
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证执行课程相关服务记录的删除操作以及页面转发更新这一核心逻辑，
+     * 方便前端可以根据不同的请求方式触发删除选课相关操作后看到最新的可选课程页面展示。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/admin/UpdateStudentInfoServlet.java

@@ -1,14 +1,11 @@
 package web.servlet.admin;
 
-
-
 import domain.CDC;
 import domain.Student;
 import service.CDCService;
 import service.StudentService;
 import service.impl.CDCServiceImpl;
 import service.impl.StudentServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -20,8 +17,37 @@ import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.List;
 
+/**
+ * UpdateStudentInfoServlet类，继承自HttpServlet，用于处理更新学生信息的相关业务逻辑，
+ * 其主要功能包括接收前端传来的学生各方面信息参数，对输入信息的格式进行简单校验，若格式正确则封装学生对象并调用服务层方法更新学生信息，
+ * 最后根据操作结果向前端返回相应提示信息，同时将请求转发到特定的页面（updateStudentServlet对应的页面，并携带学生编号sid作为参数），
+ * 该Servlet对GET请求和POST请求进行统一处理，GET请求复用POST请求的逻辑，且被映射到"/updateStudentInfoServlet"路径下以接收对应请求。
+ */
 @WebServlet("/updateStudentInfoServlet")
 public class UpdateStudentInfoServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确接收和处理包含中文等特殊字符的请求参数，避免出现乱码问题，使后续获取的参数值能准确使用。
+     * 2. 虽然此处注释掉了获取HttpSession对象的代码，但通常HttpSession可用于存储和共享与用户相关的数据，在某些场景下可用于传递更多信息或者保存用户登录等状态信息，这里暂时未用到该功能。
+     * 3. 从请求参数中获取学生的唯一编号（student-id），并打印出来方便调试查看（此处通过System.out.println输出，可在控制台查看获取到的学生编号具体值），这个编号将用于后续确定要更新信息的具体学生对象。
+     * 4. 依次从请求参数中获取学生的其他各项信息，包括姓名（student-name）、性别（student-sex）、年龄（student-age）、电话号码（student-phone）、邮箱（student-email）、家庭住址（student-address）以及所属学院（selectCollege）、专业（selectDepartment）、班级（selectClass）等信息，
+     *    并且对获取到的部分关键信息也进行了打印输出，同样有助于调试查看获取到的参数值是否符合预期，方便排查问题。
+     * 5. 创建一个新的Student对象（updateStudent），用于封装要更新的学生信息，后续将通过该对象把更新后的信息传递给服务层进行数据库更新操作。
+     * 6. 对获取到的输入信息进行格式校验，判断姓名长度是否大于4位、电话号码长度是否大于11位、邮箱长度是否大于24位、家庭住址长度是否大于24位、年龄长度是否大于2位，
+     *    同时还检查这些字段中是否包含特殊字符“<”（可能是出于防止一些非法输入或者潜在安全风险的考虑），如果有任何一项不符合要求，就在请求域中设置提示信息告知前端“格式错误，请重新提交！”并附带当前时间，
+     *    然后通过请求转发器将请求转发到“updateStudentServlet”页面，并将学生编号（sid）作为参数传递过去，让用户可以根据提示重新填写并提交正确的信息。
+     * 7. 如果输入信息格式校验通过，就将获取到的各项学生信息通过对应的set方法设置到之前创建的updateStudent对象中，完成学生对象的封装，使其包含了完整的要更新的信息内容。
+     * 8. 创建StudentService的实现类对象（StudentServiceImpl），通过该对象可以调用学生相关业务逻辑的具体实现方法，在这里主要是为了调用更新学生信息的方法。
+     * 9. 调用service的updateInfo方法，传入封装好的updateStudent对象，由具体的服务层实现类根据传入的学生对象信息去对应的存储介质（比如数据库中的学生表等）里更新相应学生的记录，
+     *    完成学生信息的更新操作（具体的更新逻辑及涉及的关联数据处理等由服务层实现类内部完成）。
+     * 10. 在请求域中设置提示信息告知前端“修改成功！”并附带当前时间，然后通过请求转发器将请求转发到“updateStudentServlet”页面，并带上学生编号（sid）作为参数，使得页面可以根据学生编号展示更新后的学生信息等相关内容，
+     *     让用户知晓信息更新成功。
+     *
+     * @param request  HttpServletRequest对象，用于获取前端传来的各种学生信息参数、进行请求转发操作以及设置请求域中的提示信息等，是整个请求处理过程中的核心对象
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，如配合请求转发操作将响应传递给目标页面，使其能够正确向客户端返回页面内容及提示信息
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如转发异常、获取请求参数异常等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出页面内容失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
         request.setCharacterEncoding("utf-8");
@@ -73,6 +99,16 @@ public class UpdateStudentInfoServlet extends HttpServlet {
         }
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证执行学生信息格式校验、更新以及根据结果返回提示信息和页面转发等核心逻辑，
+     * 方便前端可以根据不同的请求方式触发学生信息更新操作并看到相应的反馈结果。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/admin/UpdateStudentServlet.java

@@ -6,7 +6,6 @@ import service.CDCService;
 import service.StudentService;
 import service.impl.CDCServiceImpl;
 import service.impl.StudentServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -16,8 +15,36 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
 
+/**
+ * UpdateStudentServlet类，继承自HttpServlet，用于处理与更新学生信息相关的请求操作，
+ * 其主要功能是根据传入的学生编号查找对应的学生信息，并将该学生信息存入请求属性中，同时获取学院、专业、班级的相关列表信息存入HttpSession中，
+ * 最后将请求转发到用于更新学生信息的JSP页面（/WEB-INF/admin/updateStudent.jsp），方便在页面上展示学生当前信息以及相关下拉选项等内容以供后续更新操作，
+ * 该Servlet对GET请求和POST请求进行统一处理，GET请求复用POST请求的逻辑，且被映射到"/updateStudentServlet"路径下以接收对应请求。
+ */
 @WebServlet("/updateStudentServlet")
 public class UpdateStudentServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确接收和处理包含中文等特殊字符的请求参数，避免出现乱码问题，使后续获取的参数值能准确使用。
+     * 2. 获取当前请求对应的HttpSession对象，HttpSession可用于在多个请求之间存储和共享数据，在这里主要用于传递学生编号以及学院、专业、班级相关列表信息到后续的JSP页面。
+     * 3. 从请求参数中获取学生的唯一编号（sid），这个编号将用于查找特定的学生信息，它由前端页面在发起更新学生信息请求时传递过来，指明要操作的是哪一位学生的信息更新。
+     * 4. 创建一个新的Student对象，通过设置其学生编号（S_id）属性为获取到的studentid，以此构建一个用于查询的学生对象，后续将依据这个对象去查找对应的学生详细信息。
+     * 5. 创建StudentService的实现类对象（StudentServiceImpl），通过该对象可以调用学生相关业务逻辑的具体实现方法，在这里主要是为了调用根据学生编号查找学生信息的方法。
+     * 6. 调用service的findStudentById方法，传入构建好的student对象，由具体的服务层实现类根据该学生编号去对应的存储介质（比如数据库中的学生表等）里查找相应学生的记录，
+     *    获取到对应的Student对象（包含学生的详细信息，如姓名、性别、年龄等），并将该对象存入请求的属性中，属性名为"student"，以便后续在转发的JSP页面中可以获取并展示该学生的当前信息，方便进行信息更新操作。
+     * 7. 创建CDCService的实现类对象（CDCServiceImpl），用于调用获取学院、专业、班级相关信息的业务方法，为更新学生信息页面提供相应的下拉选项数据等。
+     * 8. 分别调用service2的findAllCollege()、findAllDepartment()、findAllClass()方法，获取所有学院信息列表、所有专业信息列表以及所有班级信息列表，这些列表中的元素通常是CDC类型的对象，包含了相应的名称等属性信息，
+     *    它们将用于在更新学生信息的JSP页面上展示可供选择的学院、专业、班级选项。
+     * 9. 将获取到的学院信息列表、专业信息列表、班级信息列表分别存入到HttpSession中，使用自定义的属性名（"collegeLists"、"departmentLists"、"classLists"）进行存储，以便后续在JSP页面中可以通过这些属性名获取并展示相应信息，
+     *    例如在页面上生成下拉列表展示所有学院、专业、班级供用户选择，方便更新学生所属的学院、专业、班级等信息。
+     * 10. 使用request对象的getRequestDispatcher方法获取一个请求转发器，指定要转发的目标页面为"/WEB-INF/admin/updateStudent.jsp"，
+     *     这个JSP页面通常是用于展示学生当前信息以及提供表单元素供用户更新学生信息的界面，通过之前存入请求属性和HttpSession中的信息可以在页面上准确展示学生当前情况以及相关的可选项内容，方便用户进行更新操作。
+     *
+     * @param request  HttpServletRequest对象，用于获取前端传来的请求参数（如学生编号sid）、设置请求属性（存入查找到的学生信息）以及进行请求转发操作等，是处理请求相关逻辑的关键对象
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，如配合请求转发操作将响应传递给目标JSP页面，使其能够正确向客户端返回页面内容，完成页面展示以供信息更新操作
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如转发异常、从数据库查询学生信息异常等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出页面内容失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         HttpSession session = request.getSession();
@@ -42,6 +69,16 @@ public class UpdateStudentServlet extends HttpServlet {
         request.getRequestDispatcher("/WEB-INF/admin/updateStudent.jsp").forward(request, response);
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证执行查找学生信息、获取学院等相关列表信息以及页面转发等核心逻辑，
+     * 方便前端可以根据不同的请求方式进入到更新学生信息的操作页面，并看到相应的学生当前信息和可选项内容。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/cdc/CDCListServlet.java

@@ -8,7 +8,6 @@ import service.CDCService;
 import service.StudentService;
 import service.impl.CDCServiceImpl;
 import service.impl.StudentServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -18,8 +17,34 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
 
+/**
+ * CDCListServlet类，继承自HttpServlet，用于处理获取学院、专业、班级（CDC）相关信息列表的请求，并根据当前登录用户的角色（学生、管理员、教师）不同，
+ * 将请求转发到相应的展示CDC信息列表的JSP页面，若无法确定有效角色则转发到错误页面。该Servlet对GET请求和POST请求进行统一处理，GET请求复用POST请求的逻辑，且被映射到"/cdcListServlet"路径下以接收对应请求。
+ */
 @WebServlet("/cdcListServlet")
 public class CDCListServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确接收和处理包含中文等特殊字符的请求参数，避免出现乱码问题，使后续获取和处理相关数据能准确进行。
+     * 2. 创建CDCService的实现类对象（CDCServiceImpl），通过该对象可以调用与学院、专业、班级（CDC）相关业务逻辑的具体实现方法，在这里主要是为了获取所有的CDC信息列表。
+     * 3. 调用service的findAll方法，由具体的服务层实现类去对应的存储介质（比如数据库中存储CDC相关信息的表等）里查询出所有的CDC信息，
+     *    并以List<CDC>列表形式返回，列表中的每个CDC对象包含了学院、专业或班级的具体信息（如名称、相关描述等），获取到的信息列表后续将用于在页面上展示。
+     * 4. 将获取到的CDC信息列表存入请求的属性中，属性名为"cdcs"，这样在转发到相应的JSP页面后，可以在页面中通过获取该属性来展示具体的CDC信息列表内容，方便用户查看。
+     * 5. 获取当前请求对应的HttpSession对象，HttpSession可用于在多个请求之间存储和共享数据，在这里主要是为了获取当前登录用户的相关信息，以判断用户角色，进而决定转发到哪个对应的页面进行展示。
+     * 6. 尝试从HttpSession中获取学生（Student）、管理员（Admin）、教师（Teacher）对象，通过判断这些对象是否为空来确定当前登录用户的角色。
+     * 7. 如果从会话中获取到学生对象不为空，且管理员对象和教师对象都为空，说明当前登录用户是学生角色，那么就使用请求转发器将请求转发到"/WEB-INF/student/sCDCList.jsp"页面，
+     *    这个页面通常是专门为学生设计的用于展示CDC信息列表的界面，页面内容和展示方式可能会根据学生的权限和需求进行定制。
+     * 8. 如果获取到管理员对象不为空，而学生对象和教师对象都为空，表明当前登录用户是管理员角色，此时将请求转发到"/WEB-INF/admin/aCDCList.jsp"页面，
+     *    该页面是面向管理员展示CDC信息列表的，可能会提供更多的操作选项或者展示不同的数据细节，符合管理员的使用场景。
+     * 9. 若获取到教师对象不为空，同时管理员对象和学生对象都为空，则意味着当前登录用户是教师角色，会把请求转发到"/WEB-INF/teacher/tCDCList.jsp"页面，
+     *    此页面专为教师展示CDC信息列表而设计，展示内容和功能可能与教师对CDC信息的使用需求相关联。
+     * 10. 如果上述三种角色判断情况都不满足，即无法确定一个有效的登录用户角色，就将请求转发到"error.jsp"页面，该页面一般用于提示出现了错误情况，比如用户未正常登录或者角色信息出现异常等，告知用户相应的错误提示信息。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关的参数（虽然此处未体现使用请求参数的情况，但可用于后续拓展）、设置请求属性（存入CDC信息列表）以及进行请求转发操作等，是处理请求相关逻辑的关键对象
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，如配合请求转发操作将响应传递给目标JSP页面，使其能够正确向客户端返回页面内容，根据用户角色展示相应的CDC信息列表页面或者错误提示页面
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如转发异常、获取会话对象异常等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出页面内容失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         //调用StudentService完成查询
@@ -44,6 +69,16 @@ public class CDCListServlet extends HttpServlet {
         }
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证执行获取CDC信息列表、判断用户角色以及转发到相应页面等核心逻辑，
+     * 方便前端可以根据不同的请求方式获取并查看适合当前登录用户角色的CDC信息列表页面，或者在出现异常情况时看到相应的错误提示页面。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         this.doPost(request, response);
     }

src/web/servlet/complaints/AddComplaintsServlet.java

@@ -4,7 +4,6 @@ import domain.Complaint;
 import service.ComplaintService;
 import service.NotifyService;
 import service.impl.ComplaintServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -14,8 +13,35 @@ import java.io.IOException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 
+/**
+ * AddComplaintsServlet类，继承自HttpServlet，用于处理添加投诉（小吐槽）相关的业务逻辑，
+ * 主要功能包括从请求中获取投诉内容参数，对内容进行简单的安全校验（过滤可能存在的脚本标签），
+ * 若内容合法则封装成投诉对象并添加到系统中，最后重定向到展示投诉列表的Servlet对应的路径（或原本注释掉的转发到另一个相关页面的操作），
+ * 该Servlet对GET请求和POST请求进行统一处理，GET请求复用POST请求的逻辑，且被映射到"/addComplaintsServlet"路径下以接收对应请求。
+ */
 @WebServlet("/addComplaintsServlet")
 public class AddComplaintsServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确接收和处理包含中文等特殊字符的请求参数，避免出现乱码问题，使后续获取的参数值能准确使用。
+     * 2. 创建一个新的Complaint对象，用于封装要添加的投诉相关信息，后续会将从请求中获取到的内容以及生成的时间等信息设置到该对象中，以便传递给服务层进行添加操作。
+     * 3. 从请求参数中获取名为"complaint"的参数值，这个值代表用户输入的投诉内容文本，将其赋值给text变量，此处获取到的是Object类型，所以进行了强制类型转换为String类型。
+     * 4. 进行简单的安全校验，检查获取到的投诉内容文本中是否包含"script"以及"/script"字符串，这是为了防止用户输入的内容中包含可能会造成安全隐患的脚本代码（比如JavaScript脚本等），
+     *    如果包含这两个字符串，则通过字符串替换的方式将它们去除，以此来净化输入的投诉内容，提高系统安全性。
+     * 5. 判断经过处理后的投诉内容文本是否不为空，如果不为空，说明有有效的投诉内容需要添加到系统中，此时将文本内容设置到之前创建的complaint对象的content属性中，用于存储投诉的具体内容。
+     * 6. 创建一个Date对象表示当前日期和时间，用于记录投诉的时间，然后通过SimpleDateFormat类按照指定的格式（"yyyy-MM-dd HH:mm:ss"）将日期时间格式化为字符串，
+     *    再将格式化后的时间字符串设置到complaint对象的cdate属性中，这样投诉对象就包含了完整的投诉内容和投诉时间信息。
+     * 7. 创建ComplaintService的实现类对象（ComplaintServiceImpl），通过该对象可以调用与投诉相关业务逻辑的具体实现方法，在这里主要是为了调用添加投诉的方法。
+     * 8. 调用service的addComplaint方法，传入封装好的complaint对象，由具体的服务层实现类根据传入的投诉对象信息去对应的存储介质（比如数据库中存储投诉信息的表等）里添加相应的投诉记录，
+     *    完成投诉信息的添加操作（具体的添加逻辑及涉及的关联数据处理等由服务层实现类内部完成）。
+     * 9. 原本代码中注释掉了通过请求转发器转发到"/complaintListServlet"页面的操作，而采用了response.sendRedirect("complaintServlet")，这是使用重定向的方式将客户端浏览器引导到"complaintServlet"对应的页面，
+     *    通常这个页面是用于展示投诉列表等相关信息的，通过重定向使得在添加完投诉信息后，用户可以看到最新的投诉列表情况，而重定向与转发的区别在于重定向会让浏览器重新发起一次请求，地址栏会显示新的请求地址。
+     *
+     * @param request  HttpServletRequest对象，用于获取前端传来的投诉内容参数、进行请求编码设置以及原本可以用于请求转发操作（注释掉的部分体现了这一点）等，是处理请求相关逻辑的关键对象
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，如重定向到展示投诉列表的页面（通过sendRedirect方法），使客户端浏览器跳转到相应页面查看最新情况，或者原本也可配合请求转发将响应传递给目标页面（注释掉的转发操作体现）
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如获取请求参数异常、重定向或转发配置错误等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出重定向指令失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
 
@@ -42,6 +68,16 @@ public class AddComplaintsServlet extends HttpServlet {
 //        request.getRequestDispatcher("/complaintListServlet").forward(request,response);
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证执行获取投诉内容、安全校验、添加投诉以及页面跳转等核心逻辑，
+     * 方便前端可以根据不同的请求方式来添加投诉信息并看到相应的反馈结果（跳转到展示投诉列表的页面）。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/complaints/ComplaintListServlet.java

@@ -3,7 +3,6 @@ package web.servlet.complaints;
 import domain.Complaint;
 import service.ComplaintService;
 import service.impl.ComplaintServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -12,8 +11,28 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.List;
 
+/**
+ * ComplaintListServlet类，继承自HttpServlet，用于处理获取投诉（小吐槽）信息列表的业务逻辑，
+ * 其主要功能是调用服务层方法获取所有投诉信息，将这些信息存入请求属性中，然后把请求转发到用于展示投诉信息列表的JSP页面（/WEB-INF/complaint/complaintsList.jsp），
+ * 该Servlet对GET请求和POST请求进行统一处理，GET请求复用POST请求的逻辑，且被映射到"/complaintListServlet"路径下以接收对应请求。
+ */
 @WebServlet("/complaintListServlet")
 public class ComplaintListServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，确保能够正确接收和处理包含中文等特殊字符的请求参数，避免出现乱码问题，使后续获取和处理投诉信息能准确进行。
+     * 2. 创建ComplaintService的实现类对象（ComplaintServiceImpl），通过该对象可以调用与投诉相关业务逻辑的具体实现方法，在这里主要是为了获取所有的投诉信息列表。
+     * 3. 调用service的findAll方法，由具体的服务层实现类去对应的存储介质（比如数据库中存储投诉信息的表等）里查询出所有的投诉信息，
+     *    并以List<Complaint>列表形式返回，列表中的每个Complaint对象包含了投诉的详细信息，如投诉内容、投诉时间等，获取到的信息列表后续将用于在页面上展示。
+     * 4. 将获取到的投诉信息列表存入请求的属性中，属性名为"complaints"，这样在转发到相应的JSP页面后，可以在页面中通过获取该属性来展示具体的投诉信息列表内容，方便用户查看所有投诉情况。
+     * 5. 使用request对象的getRequestDispatcher方法获取一个请求转发器，指定要转发的目标页面为"/WEB-INF/complaint/complaintsList.jsp"，
+     *    这个JSP页面通常是用于展示投诉信息列表的界面，页面上会遍历并展示存放在请求属性中的投诉信息列表里的每一条投诉内容、时间等详细信息，以供用户查看投诉相关情况。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关的参数（虽然此处未体现使用请求参数的情况，但可用于后续拓展）、设置请求属性（存入投诉信息列表）以及进行请求转发操作等，是处理请求相关逻辑的关键对象
+     * @param response HttpServletResponse对象，用于设置响应相关的信息，如配合请求转发操作将响应传递给目标JSP页面，使其能够正确向客户端返回页面内容，展示投诉信息列表页面让用户查看投诉情况
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，比如转发异常、从数据库查询投诉信息异常等情况，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，例如读取请求参数失败、向客户端输出页面内容失败等情况，则抛出该异常
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         ComplaintService service = new ComplaintServiceImpl();
@@ -21,6 +40,17 @@ public class ComplaintListServlet extends HttpServlet {
         request.setAttribute("complaints", complaints);
         request.getRequestDispatcher("/WEB-INF/complaint/complaintsList.jsp").forward(request, response);
     }
+
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也会按照与POST请求相同的逻辑进行处理，
+     * 这样做的好处是简化了代码结构，无论前端是通过GET方式还是POST方式发起请求，都能保证执行获取投诉信息列表以及转发到展示页面等核心逻辑，
+     * 方便前端可以根据不同的请求方式查看投诉信息列表页面，了解所有投诉相关情况。
+     *
+     * @param request  HttpServletRequest对象，同doPost方法中参数含义
+     * @param response HttpServletResponse对象，同doPost方法中参数含义
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/complaints/ComplaintServlet.java

@@ -3,7 +3,6 @@ package web.servlet.complaints;
 import domain.Complaint;
 import service.ComplaintService;
 import service.impl.ComplaintServiceImpl;
-
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
@@ -12,8 +11,28 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.List;
 
+/**
+ * ComplaintServlet类，继承自HttpServlet，用于处理展示投诉信息相关的业务逻辑，
+ * 主要功能为从服务层获取所有投诉信息，将其存入请求属性中，随后把请求转发至展示投诉信息列表的JSP页面（/WEB-INF/complaint/complaintsList.jsp），
+ * 以此向用户呈现投诉相关内容，并且对GET请求和POST请求采用统一的处理方式，GET请求复用POST请求的逻辑，该类被映射到"/complaintServlet"路径来接收对应请求。
+ */
 @WebServlet("/complaintServlet")
 public class ComplaintServlet extends HttpServlet {
+    /**
+     * 处理POST请求的方法，其具体逻辑如下：
+     * 1. 首先设置请求的编码格式为"utf-8"，这样做是为了能正确接收和处理包含中文等特殊字符的请求参数，避免因编码问题导致获取到的参数出现乱码，确保后续业务逻辑能基于准确的数据进行处理。
+     * 2. 创建ComplaintService的实现类对象（ComplaintServiceImpl），这个对象用于调用具体的投诉相关业务逻辑方法，在这里的核心作用是获取所有投诉信息的列表。
+     * 3. 通过调用service的findAll方法，由具体的服务层实现类去对应的存储介质（例如数据库中存储投诉记录的表等）里查询出全部的投诉信息，
+     *    并以List<Complaint>的形式返回，其中列表里的每个Complaint对象都涵盖了投诉的详细信息，像投诉内容、投诉时间等关键内容，这些信息后续将展示在相应页面上供用户查看。
+     * 4. 把获取到的投诉信息列表存入请求的属性中，属性命名为"complaints"，如此一来，当请求被转发到目标JSP页面后，页面代码就能够从请求属性中获取该列表，进而遍历并展示每条投诉的详细信息，方便用户了解所有投诉情况。
+     * 5. 使用request对象的getRequestDispatcher方法获取请求转发器，指定要转发的目标页面为"/WEB-INF/complaint/complaintsList.jsp"，
+     *    该JSP页面是专门用于展示投诉信息列表的界面，它会依据从请求属性中获取到的投诉信息列表进行渲染，将每条投诉的各项信息以合适的方式展示出来，使用户能够清晰查看所有投诉的具体内容。
+     *
+     * @param request  HttpServletRequest对象，在整个处理过程中扮演关键角色，用于设置请求编码格式、获取服务层返回的投诉信息列表并将其存入请求属性，同时利用它进行请求转发操作等
+     * @param response HttpServletResponse对象，主要用于配合请求转发操作，将响应相关信息传递给目标JSP页面，使页面能够正确向客户端返回展示了投诉信息列表的页面内容，让用户看到相关信息
+     * @throws ServletException 如果在Servlet处理过程中出现与Servlet规范相关的异常情况，例如转发页面时配置出错、获取服务层数据出现异常等，就会抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中产生输入输出相关的异常，比如读取请求参数失败、向客户端输出页面内容失败等情况时，该异常会被抛出
+     */
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.setCharacterEncoding("utf-8");
         ComplaintService service = new ComplaintServiceImpl();
@@ -22,6 +41,16 @@ public class ComplaintServlet extends HttpServlet {
         request.getRequestDispatcher("/WEB-INF/complaint/complaintsList.jsp").forward(request, response);
     }
 
+    /**
+     * 处理GET请求的方法，在此方法中直接调用了doPost方法，意味着对于GET请求也按照与POST请求相同的逻辑进行处理。
+     * 这样设计的好处在于简化了代码结构，无论前端是以GET方式还是POST方式发起请求，都能确保执行获取投诉信息列表、存入请求属性以及转发到展示页面这一系列核心逻辑，
+     * 方便用户通过不同的请求方式都能够顺利查看投诉信息列表页面，了解所有投诉的相关情况。
+     *
+     * @param request  HttpServletRequest对象，和处理POST请求时的作用及含义相同，用于获取、传递相关数据以及进行请求转发等操作
+     * @param response HttpServletResponse对象，同样和处理POST请求时作用一致，配合请求转发使目标页面能正确响应并展示内容给客户端
+     * @throws ServletException 如果在按照POST请求逻辑处理GET请求过程中出现与Servlet规范相关的异常，则抛出该异常
+     * @throws IOException      如果在读写请求或响应的数据过程中出现输入输出相关的异常，则抛出该异常
+     */
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/file/DeleteFileServlet.java

@@ -8,18 +8,27 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.File;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到指定的URL路径"/deleteFileServlet"，表明这是一个Servlet类，用于处理对应的网络请求
 @WebServlet("/deleteFileServlet")
 public class DeleteFileServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数
         request.setCharacterEncoding("utf-8");
+        // 从请求中获取名为"filename"的参数值，这个参数应该是要删除文件的文件名
         String fileName = request.getParameter("filename");
+        // 根据Servlet上下文获取"upload"目录的真实路径，并与文件名拼接起来，构造出要删除文件的完整路径，创建对应的File对象
         File file = new File(this.getServletContext().getRealPath("upload") + File.separator + fileName);
+        // 判断文件是否存在，如果存在则执行删除操作
         if (file.exists()) {
             file.delete();
         }
+        // 将请求转发到"/fileListServlet"对应的Servlet（应该是用于展示文件列表之类的功能），以更新文件列表等相关显示内容
         request.getRequestDispatcher("/fileListServlet").forward(request, response);
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/file/DownloadServlet.java

@@ -15,47 +15,78 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.net.URLEncoder;
 
+// 使用WebServlet注解将该类映射到"/downloadServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类
 @WebServlet("/downloadServlet")
 public class DownloadServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 从请求中获取名为"filename"的参数，该参数代表要下载的文件的文件名
         String filename = request.getParameter("filename");
+        // 判断文件名是否为"../"或者"/"，如果是则表示可能存在非法的访问路径，将请求转发到"error.jsp"页面进行错误提示
         if (filename.equalsIgnoreCase("../") || filename.equalsIgnoreCase("/")) {
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
+
+        // 设置响应头的Content-Type为"application/octet-stream"，表示这是一个二进制流数据，通常用于文件下载
         response.addHeader("content-Type", "application/octet-stream");
 
+        // 获取请求头中的User-Agent信息，用于判断客户端浏览器类型，不同浏览器对文件名编码处理可能有所不同
         String agent = request.getHeader("User-Agent");
 
+        // 判断User-Agent中是否包含"chrome"（转换为小写后判断），如果是Chrome浏览器
         if (agent.toLowerCase().indexOf("chrome") > 0) {
+            // 对文件名进行编码转换，先将UTF-8编码的字节数组转换为ISO8859-1编码的字符串，用于设置Content-Disposition响应头中的文件名部分，
+            // 这样Chrome浏览器能正确识别并显示下载文件名（处理文件名中的中文等特殊字符情况）
             response.addHeader("content-Disposition", "attachment;filename=" + new String(filename.getBytes("UTF-8"), "ISO8859-1"));
         } else {
+            // 如果不是Chrome浏览器，使用URLEncoder将文件名按照UTF-8编码进行URL编码，同样用于设置Content-Disposition响应头中的文件名部分，
+            // 以保证在其他浏览器中能正确显示下载文件名
             response.addHeader("content-Disposition", "attachment;filename=" + URLEncoder.encode(filename, "UTF-8"));
         }
+
+        // 通过Servlet上下文获取指定文件（位于"/upload/"目录下，文件名由前面获取的filename决定）的输入流，用于读取文件内容
         InputStream in = getServletContext().getResourceAsStream("/upload/" + filename);
+        // 获取ServletResponse的输出流，用于将文件内容写回到客户端，实现文件下载功能
         ServletOutputStream out = response.getOutputStream();
+
+        // 创建一个大小为1024字节的字节数组，用于缓存从文件读取的数据
         byte[] bs = new byte[1024];
         int len = -1;
+        // 通过循环从输入流读取数据到字节数组，每次读取的数据长度存放在len变量中，当读取到文件末尾时len为-1，循环结束
         while ((len = in.read(bs))!= -1) {
+            // 将读取到的字节数据（长度为len）从字节数组bs中写入到输出流out，实现将文件内容发送给客户端
             out.write(bs, 0, len);
         }
+
+        // 关闭输出流，释放相关资源
         out.close();
+        // 关闭输入流，释放相关资源
         in.close();
 
+        // 获取当前请求的HttpSession对象，用于获取会话中存储的用户相关信息
         HttpSession session = request.getSession();
+        // 从会话中尝试获取Student类型的用户对象，如果存在表示当前登录用户是学生角色
         Student student = (Student) session.getAttribute("student");
+        // 从会话中尝试获取Admin类型的用户对象，如果存在表示当前登录用户是管理员角色
         Admin admin = (Admin) session.getAttribute("admin");
+        // 从会话中尝试获取Teacher类型的用户对象，如果存在表示当前登录用户是教师角色
         Teacher teacher = (Teacher) session.getAttribute("teacher");
+
+        // 判断如果当前登录用户是学生角色，且不是管理员和教师角色，那么请求转发到学生角色对应的文件列表页面（"/WEB-INF/student/sFindFileList.jsp"）
         if (student!= null && admin == null && teacher == null) {
             request.getRequestDispatcher("/WEB-INF/student/sFindFileList.jsp").forward(request, response);
-        } else if (admin != null && student == null && teacher == null) {
+        } else if (admin!= null && student == null && teacher == null) {  // 如果是管理员角色，且不是学生和教师角色，转发到管理员对应的文件列表页面
             request.getRequestDispatcher("/WEB-INF/admin/aFindFileList.jsp").forward(request, response);
-        } else if (teacher != null && admin == null && student == null) {
+        } else if (teacher!= null && admin == null && student == null) {  // 如果是教师角色，且不是管理员和学生角色，转发到教师对应的文件列表页面
             request.getRequestDispatcher("/WEB-INF/teacher/tFindFileList.jsp").forward(request, response);
         } else {
+            // 如果不符合以上任何一种角色情况，可能存在异常情况，将请求转发到"error.jsp"页面进行错误提示
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/file/FileListServlet.java

@@ -18,69 +18,102 @@ import java.math.RoundingMode;
 import java.util.ArrayList;
 import java.util.List;
 
+// 使用WebServlet注解将该类映射到"/fileListServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类
 @WebServlet("/fileListServlet")
 public class FileListServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数
         request.setCharacterEncoding("utf-8");
+
+        // 根据Servlet上下文获取"upload"目录的真实路径，并创建对应的File对象，用于后续操作该目录下的文件
         File dir = new File(this.getServletContext().getRealPath("upload"));
+        // 判断该目录是否不存在，并且不是一个目录（可能不存在或者是个文件等不符合预期的情况）
         if (!dir.exists() &&!dir.isDirectory()) {
+            // 在控制台打印提示信息，说明"upload"目录不存在，需要创建
             System.out.println(this.getServletContext().getRealPath("upload") + "目录不存在，需要创建");
-            // 创建目录
+            // 创建"upload"目录
             dir.mkdir();
         }
+
+        // 获取"upload"目录下的所有文件和子目录，返回一个File数组，方便后续遍历操作这些文件
         File[] arrs = dir.listFiles();
+
+        // 创建一个FileClass类型的列表，用于存储文件相关信息，后续会将"upload"目录下每个文件的信息封装到FileClass对象中，并添加到这个列表里
         List<FileClass> fileLists = new ArrayList<FileClass>();
+
+        // 遍历"upload"目录下的所有文件（通过增强for循环遍历File数组）
         for (File f : arrs) {
+            // 获取文件的字节长度，即文件大小（单位为字节）
             long l = f.length();
+            // 调用getPrintSize方法将文件大小的字节数转换为合适的带单位的字符串表示形式（如KB、MB、GB等）
             String fileSize = getPrintSize(l);
+            // 创建一个FileClass对象，用于封装单个文件的相关信息
             FileClass file = new FileClass();
+            // 设置文件名，通过调用File对象的getName方法获取文件名
             file.setFileName(f.getName());
+            // 设置文件的绝对路径，通过调用File对象的getAbsolutePath方法获取
             file.setFilePath(f.getAbsolutePath());
+            // 设置文件大小，使用前面转换好的带单位的文件大小字符串
             file.setFileSize(fileSize);
+            // 将封装好文件信息的FileClass对象添加到fileLists列表中
             fileLists.add(file);
         }
+
+        // 将包含所有文件信息的fileLists列表存放到请求的属性中，属性名为"fileLists"，方便在后续转发的页面中获取并展示文件列表信息
         request.setAttribute("fileLists", fileLists);
 
+        // 获取当前请求的HttpSession对象，用于获取会话中存储的用户相关信息
         HttpSession session = request.getSession();
+        // 从会话中尝试获取Student类型的用户对象，如果存在表示当前登录用户是学生角色
         Student student = (Student) session.getAttribute("student");
-
+        // 从会话中尝试获取Admin类型的用户对象，如果存在表示当前登录用户是管理员角色
         Admin admin = (Admin) session.getAttribute("admin");
+        // 从会话中尝试获取Teacher类型的用户对象，如果存在表示当前登录用户是教师角色
         Teacher teacher = (Teacher) session.getAttribute("teacher");
+
+        // 判断如果当前登录用户是学生角色，且不是管理员和教师角色，那么请求转发到学生角色对应的文件列表页面（"/WEB-INF/student/sFindFileList.jsp"）
         if (student!= null && admin == null && teacher == null) {
             request.getRequestDispatcher("/WEB-INF/student/sFindFileList.jsp").forward(request, response);
-        } else if (admin != null && student == null && teacher == null) {
+        } else if (admin!= null && student == null && teacher == null) {  // 如果是管理员角色，且不是学生和教师角色，转发到管理员对应的文件列表页面
             request.getRequestDispatcher("/WEB-INF/admin/aFindFileList.jsp").forward(request, response);
-        } else if (teacher != null && admin == null && student == null) {
+        } else if (teacher!= null && admin == null && student == null) {  // 如果是教师角色，且不是管理员和学生角色，转发到教师对应的文件列表页面
             request.getRequestDispatcher("/WEB-INF/teacher/tFindFileList.jsp").forward(request, response);
         } else {
+            // 如果不符合以上任何一种角色情况，可能存在异常情况，将请求转发到"error.jsp"页面进行错误提示
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }
 
+    // 静态方法，用于将文件大小的字节数转换为合适的带单位的字符串表示形式，方便展示给用户直观了解文件大小
     public static String getPrintSize(long size) {
-        // 如果字节数少于1024，则直接以B为单位，否则先除于1024，后3位因太少无意义
+        // 将传入的文件大小字节数转换为double类型，方便后续进行数值计算和比较
         double value = (double) size;
+        // 如果字节数少于1024，说明文件较小，直接以B（字节）为单位返回，将数值转换为字符串并拼接上单位"B"
         if (value < 1024) {
             return String.valueOf(value) + "B";
         } else {
+            // 如果字节数大于等于1024，先将字节数除以1024，得到以KB为单位的数值（暂时还未处理小数位数等情况），
+            // 使用BigDecimal进行数值处理，设置小数位数为2位，舍入模式为向下取整（ROUND_DOWN），再获取处理后的double类型数值
             value = new BigDecimal(value / 1024).setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
         }
-        // 如果原字节数除于1024之后，少于1024，则可以直接以KB作为单位
-        // 因为还没有到达要使用另一个单位的时候
-        // 接下去以此类推
+        // 如果原字节数除于1024之后，少于1024，则可以直接以KB作为单位，将数值转换为字符串并拼接上单位"KB"
         if (value < 1024) {
             return String.valueOf(value) + "KB";
         } else {
+            // 如果数值大于等于1024KB，再将其除以1024，得到以MB为单位的数值（同样先进行数值处理，设置小数位数和舍入模式）
             value = new BigDecimal(value / 1024).setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
         }
         if (value < 1024) {
             return String.valueOf(value) + "MB";
         } else {
-            // 否则如果要以GB为单位的，先除于1024再作同样的处理
+            // 否则如果要以GB为单位的，先除于1024再作同样的处理，得到以GB为单位的数值，将其转换为字符串并拼接上单位"GB"后返回
             value = new BigDecimal(value / 1024).setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
             return String.valueOf(value) + "GB";
         }

src/web/servlet/file/FileServlet.java

@@ -7,12 +7,20 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到"/fileServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类
 @WebServlet("/fileServlet")
 public class FileServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 将当前请求转发到"/WEB-INF/admin/uploadFile.jsp"页面。
+        // 通常这样做可能是引导用户进入文件上传的相关页面，
+        // 比如后续在该JSP页面中会提供文件上传的表单等操作界面供用户进行文件上传操作。
         request.getRequestDispatcher("/WEB-INF/admin/uploadFile.jsp").forward(request, response);
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 也就是当接收到GET请求时，同样会将请求转发到"/WEB-INF/admin/uploadFile.jsp"页面。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/file/ShowPhotoServlet.java

@@ -20,79 +20,122 @@ import java.awt.image.BufferedImage;
 import java.io.*;
 import java.net.ServerSocket;
 
+// 使用WebServlet注解将该类映射到"/showPhotoServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类
 @WebServlet("/showPhotoServlet")
 public class ShowPhotoServlet extends HttpServlet {
-    private static final String GIF = "image/gif;charset=GB2312";// 设定输出的类型
-
+    // 定义表示GIF图片的MIME类型及字符编码，用于设置响应头中Content-Type字段，表明输出的内容类型为GIF图片格式
+    private static final String GIF = "image/gif;charset=GB2312";
+    // 定义表示JPEG图片的MIME类型及字符编码，用于设置响应头中Content-Type字段，表明输出的内容类型为JPEG图片格式
     private static final String JPG = "image/jpeg;charset=GB2312";
 
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        String spec = request.getParameter("spec");// 输出图片的类型的标志
+        // 从请求中获取名为"spec"的参数，该参数用于标识要输出图片的类型（可能是用于区分不同格式图片之类的标识）
+        String spec = request.getParameter("spec");
 
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数
         request.setCharacterEncoding("utf-8");
+
+        // 获取当前请求对应的HttpSession对象，用于获取会话中存储的用户相关信息
         HttpSession session = request.getSession();
+        // 从会话中尝试获取Student类型的用户对象，如果存在表示当前登录用户是学生角色
         Student student = (Student) session.getAttribute("student");
+        // 从会话中尝试获取Teacher类型的用户对象，如果存在表示当前登录用户是教师角色
         Teacher teacher = (Teacher) session.getAttribute("teacher");
+
+        // 定义一个Photo对象，用于存储要展示的照片相关信息，后续根据登录用户角色来获取对应的照片信息
         Photo p;
+        // 如果当前登录用户是学生角色
         if (student!= null) {
+            // 创建PhotoService的实现类实例，用于调用业务逻辑层方法来获取学生对应的照片信息
             PhotoService service = new PhotoServiceImpl();
+            // 通过业务逻辑层方法，根据学生的ID（student.getS_id()）查找对应的照片信息，并赋值给p对象
             p = service.findPhotoByPhotoId(student.getS_id());
         } else {
+            // 如果不是学生角色，即当前登录用户是教师角色，同样创建PhotoService的实现类实例
             PhotoService service = new PhotoServiceImpl();
+            // 通过业务逻辑层方法，根据教师的ID（teacher.getT_id()）查找对应的照片信息，并赋值给p对象
             p = service.findPhotoByPhotoId(teacher.getT_id());
         }
+
+        // 初始化要展示照片的文件路径字符串，后续根据实际情况确定具体路径
         String imagePath = "";
+        // 如果通过前面查找没有获取到对应的照片信息（p为null）
         if (p == null) {
+            // 则使用默认的照片路径，构造出默认照片（0.jpg）在服务器端的真实路径，通常用于当没有用户对应照片时展示默认图片
             imagePath = this.getServletContext().getRealPath("/photos/") + "0.jpg";
             System.out.println(imagePath);
         } else {
+            // 如果获取到了对应的照片信息，获取照片的名称（文件名）
             String photoName = p.getPhotoName();
+            // 根据照片名称构造出该照片在服务器端（"/photos/"目录下）的真实路径
             imagePath = this.getServletContext().getRealPath("/photos/") + photoName;
             System.out.println(imagePath);
         }
 
-
+        // 重置响应对象，清除之前可能设置的一些响应头和状态码等信息，确保后续设置是准确有效的
         response.reset();
 
-        OutputStream output = response.getOutputStream();// 得到输出流
-        if (imagePath.toLowerCase().endsWith(".jpg"))// 使用编码处理文件流的情况：
-        {
-            response.setContentType(JPG);// 设定输出的类型
-            // 得到图片的真实路径
+        // 获取ServletResponse的输出流，用于向客户端输出图片数据，实现图片展示功能
+        OutputStream output = response.getOutputStream();
 
-            // 得到图片的文件流
+        // 判断图片文件路径是否以".jpg"结尾，即判断是否为JPEG格式图片，若是则进行以下JPEG图片处理逻辑
+        if (imagePath.toLowerCase().endsWith(".jpg")) {
+            // 设置响应头的Content-Type为JPEG图片对应的MIME类型，告知客户端返回的是JPEG格式的图片数据
+            response.setContentType(JPG);
+
+            // 根据图片的真实路径创建FileInputStream对象，用于读取图片文件的原始数据
             InputStream imageIn = new FileInputStream(new File(imagePath));
-            // 得到输入的编码器，将文件流进行jpg格式编码
+            // 通过JPEGCodec创建JPEGImageDecoder对象，用于对读取到的JPEG格式文件流进行解码操作，将其转换为BufferedImage对象（便于后续处理）
             JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(imageIn);
-            // 得到编码后的图片对象
+            // 使用解码器对图片文件流进行解码，得到BufferedImage类型的图片对象，该对象包含了图片的像素等信息
             BufferedImage image = decoder.decodeAsBufferedImage();
-            // 得到输出的编码器
+            // 通过JPEGCodec创建JPEGImageEncoder对象，用于对处理后的图片进行编码，以便输出到客户端
             JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(output);
-            encoder.encode(image);// 对图片进行输出编码
-            imageIn.close();// 关闭文件流
+            // 使用编码器将BufferedImage类型的图片对象进行编码，并通过输出流输出到客户端，实现JPEG图片的展示
+            encoder.encode(image);
+            // 关闭用于读取图片文件的输入流，释放相关资源
+            imageIn.close();
         }
 
-        if (imagePath.toLowerCase().endsWith(".gif"))// 不使用编码处理文件流的情况：
-        {
+        // 判断图片文件路径是否以".gif"结尾，即判断是否为GIF格式图片，若是则进行以下GIF图片处理逻辑
+        if (imagePath.toLowerCase().endsWith(".gif")) {
+            // 设置响应头的Content-Type为GIF图片对应的MIME类型，告知客户端返回的是GIF格式的图片数据
             response.setContentType(GIF);
-            ServletContext context = getServletContext();// 得到背景对象
-            InputStream imageIn = context.getResourceAsStream(imagePath);// 文件流
-            BufferedInputStream bis = new BufferedInputStream(imageIn);// 输入缓冲流
-            BufferedOutputStream bos = new BufferedOutputStream(output);// 输出缓冲流
-            byte data[] = new byte[4096];// 缓冲字节数
+
+            // 获取Servlet上下文对象，可用于获取服务器端相关资源
+            ServletContext context = getServletContext();
+            // 通过Servlet上下文对象，根据图片文件路径获取对应的输入流，用于读取GIF图片文件的数据
+            InputStream imageIn = context.getResourceAsStream(imagePath);
+            // 使用BufferedInputStream对读取GIF图片文件的输入流进行缓冲包装，提高读取效率
+            BufferedInputStream bis = new BufferedInputStream(imageIn);
+            // 使用BufferedOutputStream对向客户端输出的输出流进行缓冲包装，提高输出效率
+            BufferedOutputStream bos = new BufferedOutputStream(output);
+
+            // 创建一个大小为4096字节的字节数组，用于缓存从文件读取和向客户端输出的数据
+            byte data[] = new byte[4096];
             int size = 0;
+            // 从缓冲输入流中读取数据到字节数组，每次读取的数据长度存放在size变量中，当读取到文件末尾时size为-1
             size = bis.read(data);
+            // 通过循环不断读取数据并输出到客户端，直到读取完整个文件（size为-1时结束循环）
             while (size!= -1) {
                 bos.write(data, 0, size);
                 size = bis.read(data);
             }
+
+            // 关闭缓冲输入流，释放相关资源
             bis.close();
-            bos.flush();// 清空输出缓冲流
+            // 刷新输出缓冲流，确保所有数据都被及时发送到客户端
+            bos.flush();
+            // 关闭输出缓冲流，释放相关资源
             bos.close();
         }
+
+        // 关闭用于向客户端输出的输出流，释放相关资源
         output.close();
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/file/UploadImageServlet.java

@@ -24,83 +24,137 @@ import java.io.InputStream;
 import java.util.Date;
 import java.util.List;
 
+// 使用WebServlet注解将该类映射到"/uploadImageServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类
 @WebServlet("/uploadImageServlet")
 public class UploadImageServlet extends HttpServlet {
-    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
+    // 重写doPost方法，用于处理HTTP POST请求
+    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 获取当前请求对应的HttpSession对象，用于获取会话中存储的用户相关信息
         HttpSession session = request.getSession();
+        // 从会话中尝试获取Student类型的用户对象，如果存在表示当前登录用户是学生角色
         Student student = (Student) session.getAttribute("student");
+        // 从会话中尝试获取Teacher类型的用户对象，如果存在表示当前登录用户是教师角色
         Teacher teacher = (Teacher) session.getAttribute("teacher");
+        // 从会话中尝试获取Admin类型的用户对象，如果存在表示当前登录用户是管理员角色
         Admin admin = (Admin) session.getAttribute("admin");
+
+        // 初始化一个字符串变量id，用于存储后续根据登录用户角色确定的唯一标识（如学生的学号、教师的教师编号等），先初始化为空字符串
         String id = "";
+        // 如果当前登录用户是学生角色，则将学生的学号赋值给id变量，作为后续处理图片相关操作的关联标识
         if (student!= null) {
             id = student.getS_id();
         }
 
+        // 在请求属性中设置"message"属性为空字符串，可能用于后续传递一些提示信息（目前此处暂未看到实际使用场景）
         request.setAttribute("message", "");
+        // 在请求属性中设置"path"属性为空字符串，可能用于后续传递图片的保存路径等相关信息（目前此处暂未看到实际使用场景）
         request.setAttribute("path", "");
+
+        // 初始化用于存储原始文件名的变量，初始化为null
         String filename = null;
+        // 初始化用于存储处理后的新文件名的变量，初始化为null
         String newFileName = null;
-        // 设置上传图片的保存路径
+
+        // 获取服务器上用于保存上传图片的目录路径，通过Servlet上下文获取"/photos"目录的真实路径
         String savePath = this.getServletContext().getRealPath("/photos");
+        // 根据保存路径创建对应的File对象，用于后续判断目录是否存在等操作
         File file = new File(savePath);
-        // 判断上传文件的保存目录是否存在
+
+        // 判断上传图片的保存目录是否存在，如果不存在并且不是一个目录（可能不存在或者是个文件等不符合预期的情况）
         if (!file.exists() &&!file.isDirectory()) {
+            // 在控制台打印提示信息，说明该目录不存在，需要创建
             System.out.println(savePath + "目录不存在，需要创建");
-            // 创建目录
+            // 创建该目录
             file.mkdir();
         }
+
+        // 1、创建一个DiskFileItemFactory对象，它是Apache Commons FileUpload组件中用于创建文件项的工厂类，
+        // 可以配置一些与文件上传相关的底层参数（如临时文件存储等，此处使用默认配置）
         DiskFileItemFactory factory = new DiskFileItemFactory();
-        // 2、创建一个文件上传解析器
+
+        // 2、创建一个ServletFileUpload对象，它是用于解析上传文件的核心类，通过传入前面创建的工厂对象来进行初始化，
+        // 后续可以使用它来解析HTTP请求中的文件上传相关内容
         ServletFileUpload upload = new ServletFileUpload(factory);
+        // 设置请求头的编码为"UTF-8"，确保能正确解析包含中文等多字节字符的文件名等信息
         upload.setHeaderEncoding("UTF-8");
-        // 3、判断提交上来的数据是否是上传表单的数据
+
+        // 3、判断提交上来的数据是否是符合文件上传表单的数据格式（通过请求的Content-Type等相关信息判断），
+        // 如果不是则说明不是文件上传请求，按照传统方式获取数据（此处直接返回，意味着不处理这种情况）
         if (!ServletFileUpload.isMultipartContent(request)) {
             // 按照传统方式获取数据
             return;
         }
+
         try {
+            // 使用ServletFileUpload对象解析HTTP请求，获取所有的文件项（FileItem）列表，每个FileItem对应一个表单中的文件上传字段或普通表单字段
             List<FileItem> list = upload.parseRequest(request);
-            System.out.println(list.toString());// 文件的路径 以及保存的路径
+            // 打印文件项列表信息（此处可能是用于调试，查看获取到的文件相关信息情况），实际应用中可根据需求决定是否保留
+            System.out.println(list.toString());
+
+            // 遍历文件项列表，对每个文件项进行处理
             for (FileItem item : list) {
-                filename = item.getName();// 获得一个项的文件名称
+                // 获取文件项对应的文件名，这里获取到的文件名包含完整路径（例如在客户端本地的完整路径）
+                filename = item.getName();
+
                 try {
+                    // 根据登录用户的标识（如学生学号等）和原始文件名的后缀（通过截取文件名中最后一个点后面的部分）构建新的文件名，
+                    // 目的可能是保证文件名的唯一性以及与用户关联等，例如将学号和原文件名后缀拼接起来
                     newFileName = id + filename.substring(filename.lastIndexOf("."));
+                    // 同时也对原始文件名做同样的处理，用于后续保存文件等操作（这里可能存在重复代码，可以考虑优化）
                     filename = id + filename.substring(filename.lastIndexOf("."));
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
-                if (filename == null || filename.trim().equals("")) {// 如果為空則跳過
+
+                // 如果文件名是空的（可能是获取文件名出现问题或者该项不是文件上传项等情况），则跳过当前循环，继续处理下一个文件项
+                if (filename == null || filename.trim().equals("")) {
                     continue;
                 }
-                // 報錯 需要過濾文件名稱 java.io.FileNotFoundException:
-                // G:\测试02\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\wtpwebapps\FaceUp\WEB-INF\images\C:\Users\Ray\Pictures\2.jpeg
-                // (文件名、目录名或卷标语法不正确。)
 
+                // 对文件名进行处理，截取文件名中最后一个反斜杠（\）后面的部分，去除路径信息，只保留文件名部分，
+                // 这样在保存文件到服务器指定目录时使用的文件名更符合要求（避免包含客户端本地的完整路径导致保存出错）
                 filename = filename.substring(filename.lastIndexOf("\\") + 1);
-//				System.out.print(filename);
-                if (filename.substring(filename.lastIndexOf(".") + 1).equals("JPG")
-                        || filename.substring(filename.lastIndexOf(".") + 1).equals("JPEG")
-                        || filename.substring(filename.lastIndexOf(".") + 1).equals("gif")
-                        || filename.substring(filename.lastIndexOf(".") + 1).equals("GIF")
-                        || filename.substring(filename.lastIndexOf(".") + 1).equals("jpg")
-                        || filename.substring(filename.lastIndexOf(".") + 1).equals("jpeg")) {
-                    InputStream in = item.getInputStream();// 獲得上傳的輸入流
-                    FileOutputStream out = new FileOutputStream(savePath + "\\" + filename);// 指定web-inf目錄下的images文件
+
+                // 判断文件名的后缀（通过截取文件名中最后一个点后面的部分并转换为大写后进行比较）是否是允许上传的图片格式（JPG、JPEG、GIF等），
+                // 如果是则进行文件上传相关操作
+                if (filename.substring(filename.lastIndexOf(".") + 1).equalsIgnoreCase("JPG")
+                        || filename.substring(filename.lastIndexOf(".") + 1).equalsIgnoreCase("JPEG")
+                        || filename.substring(filename.lastIndexOf(".") + 1).equalsIgnoreCase("GIF")
+                        || filename.substring(filename.lastIndexOf(".") + 1).equalsIgnoreCase("jpg")
+                        || filename.substring(filename.lastIndexOf(".") + 1).equalsIgnoreCase("jpeg")) {
+
+                    // 获取文件项对应的输入流，通过该输入流可以读取客户端上传的文件内容
+                    InputStream in = item.getInputStream();
+                    // 创建一个FileOutputStream对象，用于将读取到的文件内容写入到服务器指定的保存目录下，
+                    // 构造的文件路径是在之前确定的保存路径（savePath）基础上加上处理后的文件名（通过"\\"拼接路径和文件名）
+                    FileOutputStream out = new FileOutputStream(savePath + "\\" + filename);
+
+                    // 在请求属性中设置"path"属性，记录图片在服务器端保存后的相对路径（这里记录的路径格式可能需要根据实际前端使用情况进行调整），
+                    // 方便后续页面展示等操作可以获取到图片的位置信息
                     request.setAttribute("path", "photos" + "\\" + filename);
 
-                    int len = 0;
+                    // 创建一个大小为1024字节的字节数组，用于缓存从输入流读取的数据，提高读写效率
                     byte buffer[] = new byte[1024];
-                    while ((len = in.read(buffer)) > 0)// 每次讀取
-                    {
+                    int len = 0;
+                    // 通过循环不断从输入流读取数据到字节数组，每次读取的数据长度存放在len变量中，只要读取到的数据长度大于0就继续循环，
+                    // 并将读取到的数据通过输出流写入到服务器端的文件中，实现文件上传保存的功能
+                    while ((len = in.read(buffer)) > 0) {
                         out.write(buffer, 0, len);
                     }
+
+                    // 关闭用于读取文件的输入流，释放相关资源
                     in.close();
+                    // 关闭用于写入文件的输出流，释放相关资源
                     out.close();
+                    // 删除临时文件（如果有，根据Apache Commons FileUpload的机制，在一些情况下会生成临时文件，此处删除它）
                     item.delete();
-                } else {  //必须是图片才能上传否则失败
+                } else {
+                    // 如果文件名后缀不是允许上传的图片格式，则表示上传的文件不符合要求，
+                    // 在请求属性中设置"update_msg"属性，添加提示信息，说明上传失败以及失败原因（只能上传指定类型的图片文件），
+                    // 并带上当前的时间信息（通过String.format("%tT", new Date())格式化时间）
                     request.setAttribute("update_msg", "上传失败，只能上传类型为jpg或GIF的图像文件！" + String.format("%tT", new Date()));
-//        request.getRequestDispatcher("/WEB-INF/index.jsp").forward(request, response);
+                    // 将请求转发到"/WEB-INF/student/studentAddPhoto.jsp"页面，可能该页面用于显示上传结果等相关信息给用户
                     request.getRequestDispatcher("/WEB-INF/student/studentAddPhoto.jsp").forward(request, response);
                     return;
                 }
@@ -109,23 +163,33 @@ public class UploadImageServlet extends HttpServlet {
             e.printStackTrace();
         }
 
+        // 创建一个Photo对象，用于封装要保存或更新到数据库中的照片相关信息，先设置照片的唯一标识（如学生学号等）
         Photo photo = new Photo();
         photo.setPhotoId(id);
+        // 设置照片的名称，使用前面处理后得到的新文件名
         photo.setPhotoName(newFileName);
-        PhotoService service = new PhotoServiceImpl();
 
+        // 创建PhotoService的实现类实例，用于调用业务逻辑层方法来处理照片数据在数据库中的保存或更新操作
+        PhotoService service = new PhotoServiceImpl();
 
+        // 通过业务逻辑层方法，根据照片的唯一标识（id）查找数据库中是否已经存在对应的照片记录
         Photo photo1 = service.findPhotoByPhotoId(id);
+        // 如果查找结果为null，表示数据库中不存在该照片记录，则调用业务逻辑层的添加照片方法，将新的照片信息保存到数据库中
         if (photo1 == null) {
             service.addPhoto(photo);
         } else {
+            // 如果数据库中已经存在对应的照片记录，则调用业务逻辑层的更新照片方法，使用新的照片信息更新数据库中的记录
             service.updatePhoto(photo);
         }
+
+        // 在请求属性中设置"update_msg"属性，添加提示信息，说明上传成功，并带上当前的时间信息（通过String.format("%tT", new Date())格式化时间）
         request.setAttribute("update_msg", "上传成功！" + String.format("%tT", new Date()));
-//        request.getRequestDispatcher("/WEB-INF/index.jsp").forward(request, response);
+        // 将请求转发到"/WEB-INF/student/studentAddPhoto.jsp"页面，可能该页面用于显示上传结果等相关信息给用户
         request.getRequestDispatcher("/WEB-INF/student/studentAddPhoto.jsp").forward(request, response);
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会将请求转发到"/WEB-INF/student/studentAddPhoto.jsp"页面
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         request.getRequestDispatcher("/WEB-INF/student/studentAddPhoto.jsp").forward(request, response);
     }

src/web/servlet/file/UploadServlet.java

@@ -16,20 +16,37 @@ import org.apache.commons.fileupload.ProgressListener;
 import org.apache.commons.fileupload.disk.DiskFileItemFactory;
 import org.apache.commons.fileupload.servlet.ServletFileUpload;
 
+// 使用WebServlet注解将该类映射到"/uploadServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类
 @WebServlet("/uploadServlet")
 public class UploadServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数
         request.setCharacterEncoding("utf-8");
+        // 设置响应的字符编码为"utf-8"，确保响应内容中的中文等字符能正确显示
         response.setCharacterEncoding("utf-8");
+        // 设置响应的Content-Type为"text/html; charset=utf-8"，表明响应内容是HTML格式且字符编码为utf-8
         response.setContentType("text/html; charset=utf-8");
 
-
+        // 判断提交上来的数据是否是符合文件上传表单的数据格式（通过请求的Content-Type等相关信息判断），
+        // 如果是则返回true，表示是文件上传请求
         boolean isMultipart = ServletFileUpload.isMultipartContent(request);
         if (isMultipart) {
+            // 1、创建一个DiskFileItemFactory对象，它是Apache Commons FileUpload组件中用于创建文件项的工厂类，
+            // 可以配置一些与文件上传相关的底层参数（如临时文件存储等，此处使用默认配置）
             FileItemFactory factory = new DiskFileItemFactory();
+
+            // 2、创建一个ServletFileUpload对象，它是用于解析上传文件的核心类，通过传入前面创建的工厂对象来进行初始化，
+            // 后续可以使用它来解析HTTP请求中的文件上传相关内容
             ServletFileUpload upload = new ServletFileUpload(factory);
+            // 设置请求头的编码为"utf-8"，确保能正确解析包含中文等多字节字符的文件名等信息
             upload.setHeaderEncoding("utf-8");
 
+            // 以下代码被注释掉了，原本是用于设置文件上传进度监听器的功能。
+            // 当文件上传过程中，会根据读取的字节数、总字节数以及已处理的文件项数量等信息更新进度相关数据，
+            // 并将这些数据存放在一个自定义的ProcessInfo对象中，然后设置到请求的属性（hs，此处未定义应该是个错误，可能是想使用HttpSession，可根据实际情况修改）里，
+            // 方便前端页面获取并展示文件上传进度情况。
 //            upload.setProgressListener(new ProgressListener(){
 //                public void update(long pBytesRead, long pContentLength, int pItems) {
 //                    ProcessInfo pri = new ProcessInfo();
@@ -43,47 +60,71 @@ public class UploadServlet extends HttpServlet {
 //            });
 
             try {
+                // 使用ServletFileUpload对象解析HTTP请求，获取所有的文件项（FileItem）列表，每个FileItem对应一个表单中的文件上传字段或普通表单字段
                 List<FileItem> items = upload.parseRequest(request);
+                // 获取文件项列表的迭代器，用于遍历列表中的每个文件项
                 Iterator<FileItem> it = items.iterator();
                 while (it.hasNext()) {
+                    // 获取下一个文件项对象
                     FileItem item = it.next();
+                    // 获取文件项对应的表单字段名称
                     String itemname = item.getFieldName();
+                    // 初始化一个表示学号的变量，初始值设为 -1，用于后续根据表单字段判断并赋值
                     int sno = -1;
+                    // 初始化一个表示学生姓名的变量，初始值设为null，用于后续根据表单字段判断并赋值
                     String sname = null;
 
+                    // 判断该文件项是否是普通表单字段（非文件上传字段）
                     if (item.isFormField()) {
+                        // 如果表单字段名称为"sno"，则尝试将该字段的值解析为整数并赋值给sno变量，解析时指定字符编码为"utf-8"
                         if (itemname.equals("sno")) {
                             sno = Integer.parseInt(item.getString("utf-8"));
                         } else if (itemname.equals("sname")) {
+                            // 如果表单字段名称为"sname"，先获取该字段的值（字符编码为"utf-8"）并赋值给sname变量，
+                            // 然后又将文件名（这里可能存在逻辑错误，本意可能不是这样，应该是不需要再次赋值文件名，可根据实际需求确认）赋值给sname变量
                             sname = item.getString("utf-8");
                             sname = item.getName();
                         } else {
+                            // 如果是其他未处理的普通表单字段，则在控制台打印提示信息
                             System.out.println("其他字段");
                         }
                     } else {
+                        // 如果该文件项是文件上传字段，则获取文件名（包含完整路径，例如在客户端本地的完整路径）
                         String filename = item.getName();
+                        // 获取服务器上用于保存上传文件的目录路径，通过Servlet上下文获取"upload"目录的真实路径
+                        // （此处注释掉的代码是通过请求的会话获取Servlet上下文再获取路径，可根据实际情况选择合适的方式，当前使用的是直接通过Servlet获取上下文的方式）
                         // String path=request.getSession().getServletContext().getRealPath("upload");
                         String path = this.getServletContext().getRealPath("upload");
+
+                        // 判断文件名的后缀（通过截取文件名中最后一个点后面的部分并转换为小写后进行比较）是否是特定的网页文件格式（JSP、HTML、HTM等），
+                        // 如果是则表示不允许上传这类文件，将请求转发到"error.jsp"页面进行错误提示
                         if (filename.substring(filename.lastIndexOf(".") + 1).equals("jsp")
                                 || filename.substring(filename.lastIndexOf(".") + 1).equals("htm")
                                 || filename.substring(filename.lastIndexOf(".") + 1).equals("html")) {
                             request.getRequestDispatcher("error.jsp").forward(request, response);
                         } else {
+                            // 打印文件保存目录的路径（可能用于调试，查看路径是否正确）
                             System.out.println(path);
+                            // 根据保存路径创建对应的File对象，用于后续判断目录是否存在等操作
                             File file = new File(path);
+                            // 判断该目录是否不存在并且不是一个目录（可能不存在或者是个文件等不符合预期的情况），如果是则创建该目录
                             if (!file.exists() &&!file.isDirectory()) {
                                 file.mkdir();
                             }
+                            // 将上传的文件写入到服务器指定的目录下，构造的文件对象是在前面确定的保存目录（path）基础上加上文件名（filename）
                             item.write(new File(path, filename));
+                            // 在请求属性中设置"news"属性，添加提示信息，说明文件上传成功，并带上文件名
                             request.setAttribute("news", filename + "  上传成功!");
+                            // 将请求转发到"/WEB-INF/admin/uploadFile.jsp"页面，可能该页面用于显示上传结果等相关信息给用户
                             request.getRequestDispatcher("/WEB-INF/admin/uploadFile.jsp").forward(request, response);
+                            // 以下代码被注释掉了，原本是用于重定向到另一个Servlet（可能用于跳转到文件上传后的其他操作页面等），
+                            // 重定向和转发的区别在于重定向会重新发起一个请求，而转发是在服务器内部直接跳转，可根据实际需求选择使用哪种方式。
 //                        response.sendRedirect("fileUploadIndexServlet");
+                            // 在控制台打印文件上传成功的提示信息，带上文件名（可能用于调试，查看上传情况）
                             System.out.println(filename + "上传成功!!!");
-
-                        }
                             return;
                         }
-
+                    }
                 }
             } catch (FileUploadException e) {
                 e.printStackTrace();
@@ -93,6 +134,8 @@ public class UploadServlet extends HttpServlet {
         }
     }
 
+    // 定义一个内部类ProcessInfo，用于封装文件上传进度相关的信息，
+    // 包括总文件大小、已读取的文件大小、显示的进度字符串、已处理的文件项数量以及进度百分比等属性
     class ProcessInfo {
         public long totalSize = 1;
         public long readSize = 0;
@@ -101,6 +144,7 @@ public class UploadServlet extends HttpServlet {
         public int rate = 0;
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/index/AdminIndexServlet.java

@@ -7,11 +7,21 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到"/adminIndexServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 这里可能主要是针对管理员相关的页面索引请求进行处理的Servlet。
 @WebServlet("/adminIndexServlet")
 public class AdminIndexServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 将当前请求转发到"/WEB-INF/admin/aIndex.jsp"页面。
+        // 通常这个JSP页面可能是管理员功能模块对应的首页或者是一个主要的展示页面，
+        // 通过转发请求，服务器会去查找并渲染这个JSP页面，然后将生成的页面内容返回给客户端展示给用户。
         request.getRequestDispatcher("/WEB-INF/admin/aIndex.jsp").forward(request, response);
     }
+
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 也就是当接收到GET请求时，同样会将请求转发到"/WEB-INF/admin/aIndex.jsp"页面。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/index/StudentIndexServlet.java

@@ -7,11 +7,21 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到"/studentIndexServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 大概率是针对学生相关页面索引请求进行处理的Servlet。
 @WebServlet("/studentIndexServlet")
 public class StudentIndexServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 将当前请求转发到"/WEB-INF/student/sIndex.jsp"页面。
+        // 一般来说，这个JSP页面是学生功能模块对应的首页或者核心展示页面，
+        // 通过转发请求，服务器会查找并渲染该JSP页面，之后把生成的页面内容返回给客户端，展示给学生用户查看。
         request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request, response);
     }
+
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+        // 即当接收到GET请求时，同样会把请求转发到"/WEB-INF/student/sIndex.jsp"页面。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/index/TeacherIndexServlet.java

@@ -7,11 +7,21 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
+// 使用WebServlet注解将此类映射到"/teacherIndexServlet"这个URL路径，意味着该Servlet类是用来处理与之对应的网络请求的，
+// 通常是针对教师相关页面的访问请求进行相应处理的类。
 @WebServlet("/teacherIndexServlet")
 public class TeacherIndexServlet extends HttpServlet {
+
+    // 重写doPost方法，该方法用于处理HTTP POST请求。
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 将当前接收到的请求转发到"/WEB-INF/teacher/tIndex.jsp"页面。
+        // 一般来讲，这个JSP页面是教师功能模块对应的首页或者是主要展示页面，
+        // 服务器接收到转发请求后，会去查找并渲染这个JSP页面，随后将渲染好的页面内容返回给客户端，以便展示给教师用户查看。
         request.getRequestDispatcher("/WEB-INF/teacher/tIndex.jsp").forward(request, response);
     }
+
+    // 重写doGet方法，在此类中，该方法直接调用doPost方法来处理GET请求，这表明GET请求和POST请求在本Servlet中的处理逻辑是完全一致的，
+        // 也就是当接收到GET请求时，同样会把请求转发到"/WEB-INF/teacher/tIndex.jsp"页面。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/login/FindStudentServlet.java

@@ -14,34 +14,64 @@ import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
 
+// 使用WebServlet注解将该类映射到"/findStudentServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名推测，可能主要用于查找学生相关信息的功能。
 @WebServlet("/findStudentServlet")
 public class FindStudentServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置响应的Content-Type为"application/json;charset=utf-8"，表明响应内容将以JSON格式返回，并且字符编码为utf-8，
+        // 这样客户端（如前端页面中的JavaScript代码等）就能正确解析接收到的JSON数据。
         response.setContentType("application/json;charset=utf-8");
+
+        // 从请求中获取名为"studentid"的参数值，该参数应该是用于查找学生信息的学生ID，通常由前端页面传递过来。
         String studentId = request.getParameter("studentid");
+
+        // 创建两个Student对象，student对象用于设置要查找的学生ID条件，findStudent对象用于存储后续通过业务逻辑层查找得到的学生信息。
         Student student = new Student();
         Student findStudent = new Student();
+        // 将获取到的学生ID设置到student对象中，作为查找条件传递给业务逻辑层。
         student.setS_id(studentId);
+
+        // 创建StudentService的实现类实例，用于调用业务逻辑层方法来处理与学生相关的业务操作，
+        // 这里是通过学生ID查找对应的学生信息。
         StudentService service = new StudentServiceImpl();
+        // 调用业务逻辑层的findStudentById方法，传入设置好ID的student对象，将查找到的学生信息赋值给findStudent对象。
         findStudent = service.findStudentById(student);
+
+        // 创建一个HashMap对象，用于存储要返回给客户端的相关信息，以键值对的形式进行存储，方便后续转换为JSON格式数据。
         Map<String, Object> map = new HashMap<String, Object>();
 
         try {
+            // 判断获取到的学生ID（studentId）与查找到的学生对象（findStudent）中的ID是否相等，以此来判断该学生ID是否已存在对应的学生记录。
             if (studentId.equals(findStudent.getS_id())) {
+                // 如果相等，表示该学生ID已存在，在map中添加键值对，"studentExsit"键对应的值设为true，表示学生存在，
+                // 同时添加"msg"键，对应的值为提示信息"ID已存在"，这些信息将作为响应内容返回给客户端，方便客户端根据此信息进行相应处理（如提示用户等）。
                 map.put("studentExsit", true);
                 map.put("msg", "ID已存在");
             } else {
+                // 如果不相等，表示该学生ID不存在对应的学生记录，即用户名（这里以学生ID作为类似用户名的概念）可用，
+                // 在map中添加相应键值对，"studentExsit"键对应的值设为false，"msg"键对应的值设为"用户名可用"。
                 map.put("studentExsit", false);
                 map.put("msg", "用户名可用");
             }
-            //map转为json传给客户端
+
+            // 创建一个ObjectMapper对象，它是Jackson库中用于将Java对象转换为JSON格式数据的核心类，
+            // 这里将使用它把map对象转换为JSON格式，并写入到响应的输出流中，以便发送给客户端。
             ObjectMapper mapper = new ObjectMapper();
+            // 通过ObjectMapper的writeValue方法，将map对象转换为JSON格式的数据，并写入到HttpServletResponse的输出流中，
+            // 这样客户端就能接收到对应的JSON数据并进行解析和相应处理了。
             mapper.writeValue(response.getWriter(), map);
         } catch (Exception e) {
+            // 如果在上述处理过程中出现异常（如JSON转换出错等情况），则打印异常堆栈信息，方便排查问题，
+            // 在实际应用中，可能还需要更完善的异常处理逻辑，比如返回特定的错误信息给客户端等。
             e.printStackTrace();
         }
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的逻辑，进行学生信息查找并返回相应的JSON格式结果给客户端。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/login/LoginServlet.java

@@ -25,108 +25,168 @@ import java.lang.reflect.InvocationTargetException;
 import java.util.List;
 import java.util.Map;
 
+// 使用WebServlet注解将该类映射到"/loginServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名可以看出，主要负责处理用户登录相关的业务逻辑。
 @WebServlet("/loginServlet")
 public class LoginServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 初始化用于存储登录成功后的学生对象，初始值设为null，后续根据登录验证结果进行赋值
         Student loginStudent = null;
+        // 初始化用于存储登录成功后的教师对象，初始值设为null，后续根据登录验证结果进行赋值
         Teacher loginTeacher = null;
+        // 初始化用于存储登录成功后的管理员对象，初始值设为null，后续根据登录验证结果进行赋值
         Admin loginAdmin = null;
 
-        //设置编码
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数
         request.setCharacterEncoding("utf-8");
 
-        //获取数据
+        // 从请求中获取名为"verifycode"的参数值，该参数通常是用户在登录页面输入的验证码，用于后续验证码校验
         String verifycode = request.getParameter("verifycode");
+        // 从请求中获取名为"id"的参数值，该参数一般代表用户输入的登录账号（如学生学号、教师工号、管理员账号等），具体含义根据角色而定
         String loginid = request.getParameter("id");
+        // 从请求中获取名为"password"的参数值，该参数是用户输入的登录密码
         String loginpassword = request.getParameter("password");
 
-        //验证码校验
+        // 验证码校验相关逻辑
+        // 获取当前请求对应的HttpSession对象，用于获取会话中存储的验证码信息（之前生成并存储在会话中的验证码）
         HttpSession session = request.getSession();
+        // 从会话中获取名为"CHECKCODE_SERVER"的属性值，该值就是服务器端生成并存储的验证码，类型转换为String
         String checkcode_server = (String) session.getAttribute("CHECKCODE_SERVER");
-        session.removeAttribute("CHECKCODE_SERVER");//确保验证一次性
+        // 移除会话中的"CHECKCODE_SERVER"属性，确保验证码只能使用一次，防止重复利用
+        session.removeAttribute("CHECKCODE_SERVER");
+
+        // 判断服务器端存储的验证码是否为null（可能出现异常情况未生成验证码等），或者与用户输入的验证码不相等（不区分大小写进行比较），
+        // 如果满足此条件，则表示验证码不正确
         if (checkcode_server == null ||!checkcode_server.equalsIgnoreCase(verifycode)) {
-            //验证码不正确
+            // 在请求属性中设置"login_msg"属性，添加提示信息，说明验证码错误，用于后续在页面上展示给用户
             request.setAttribute("login_msg", "验证码错误");
-            //跳转页面
+            // 在请求属性中设置"loginid"属性，将用户输入的登录账号再次存入请求属性，方便在返回登录页面时可以回显给用户
             request.setAttribute("loginid", loginid);
+            // 在请求属性中设置"loginpassword"属性，将用户输入的登录密码再次存入请求属性，方便在返回登录页面时可以回显给用户
             request.setAttribute("loginpassword", loginpassword);
+            // 将请求转发到"/login.jsp"页面，通常这个页面就是登录页面，返回给用户并展示验证码错误的提示信息以及回显账号密码等内容
             request.getRequestDispatcher("/login.jsp").forward(request, response);
             return;
         }
-        //封装对象
+
+        // 封装对象相关逻辑
+        // 再次从请求中获取名为"id"的参数值，此处代码可能存在重复获取的情况（前面已经获取过loginid，可根据实际情况优化），该值用于构建用户对象的标识属性
         String id = request.getParameter("id");
+        // 再次从请求中获取名为"password"的参数值，此处代码可能存在重复获取的情况（前面已经获取过loginpassword，可根据实际情况优化），该值用于构建用户对象的密码属性
         String password = request.getParameter("password");
+        // 从请求中获取名为"roles"的参数值，该参数用于区分用户的角色（如"student"表示学生、"teacher"表示教师、"admin"表示管理员），以便后续进行不同角色的登录验证逻辑
         String roles = request.getParameter("roles");
 
-        //公告加载
+        // 公告加载相关逻辑
+        // 创建NotifyService的实现类实例，用于调用业务逻辑层方法来获取公告相关信息，这里应该是获取所有的公告列表
         NotifyService notifyService = new NotifyServiceImpl();
+        // 调用业务逻辑层的find方法，获取公告列表数据，返回的是Notify类型的列表
         List<Notify> notifys = notifyService.find();
+        // 将获取到的公告列表存放到HttpSession中，属性名为"notifys"，方便在后续页面中（不同角色登录后的页面）可以获取并展示公告信息
         session.setAttribute("notifys", notifys);
 
-        //判断roles封装对象、保存session、调用不同Service查询
+        // 根据不同角色进行登录验证、对象封装、会话保存以及页面跳转等逻辑处理
         if ("student".equals(roles)) {
-
+            // 创建一个Student对象，用于封装学生登录相关的信息，作为传递给业务逻辑层进行登录验证的数据对象
             Student student = new Student();
+            // 设置学生对象的学号属性，使用前面获取到的id值
             student.setS_id(id);
+            // 设置学生对象的密码属性，使用前面获取到的password值
             student.setS_password(password);
 
+            // 创建StudentService的实现类实例，用于调用业务逻辑层中与学生登录相关的方法
             StudentService service = new StudentServiceImpl();
+            // 调用业务逻辑层的login方法，传入封装好的学生对象，进行登录验证，将验证通过后返回的学生对象赋值给loginStudent变量（如果验证失败则为null）
             loginStudent = service.login(student);
 
+            // 判断登录验证是否成功，即loginStudent不为null，表示找到了对应的学生记录，登录成功
             if (loginStudent!= null) {
+                // 将登录成功的学生对象存放到HttpSession中，属性名为"student"，方便后续在其他页面判断用户是否登录以及获取学生相关信息
                 session.setAttribute("student", loginStudent);
+                // 在会话中设置"html_title"属性，值为"学生端"，可能用于在页面上显示不同的标题栏等内容，标识当前处于学生端页面
                 session.setAttribute("html_title", "学生端");
+                // 重定向到"studentIndexServlet"，通常这个Servlet会将请求转发到学生端对应的首页（如"/WEB-INF/student/sIndex.jsp"等页面），实现登录成功后跳转到学生端首页的功能
+                // （此处注释掉了直接转发的代码，选择使用重定向方式，重定向会重新发起一个请求，而转发是在服务器内部直接跳转，两者有不同的应用场景和效果）
 //                request.getRequestDispatcher("/WEB-INF/student/sIndex.jsp").forward(request, response);
                 response.sendRedirect("studentIndexServlet");
             } else {
-                //登录失败 提示信息
+                // 如果登录验证失败，即loginStudent为null，表示用户名或密码错误等情况
+                // 在请求属性中设置"login_msg"属性，添加提示信息，说明用户名或密码错误，用于后续在登录页面展示给用户
                 request.setAttribute("login_msg", "用户名或密码错误！");
+                // 在请求属性中设置"loginid"属性，将用户输入的登录账号再次存入请求属性，方便在返回登录页面时可以回显给用户
                 request.setAttribute("loginid", loginid);
+                // 在请求属性中设置"loginpassword"属性，将用户输入的登录密码再次存入请求属性，方便在返回登录页面时可以回显给用户
                 request.setAttribute("loginpassword", loginpassword);
+                // 将请求转发到"/login.jsp"页面，返回登录页面并展示错误提示信息以及回显账号密码等内容
                 request.getRequestDispatcher("/login.jsp").forward(request, response);
             }
         } else if ("teacher".equals(roles)) {
-
+            // 创建一个Teacher对象，用于封装教师登录相关的信息，作为传递给业务逻辑层进行登录验证的数据对象
             Teacher teacher = new Teacher();
+            // 设置教师对象的教师编号属性，使用前面获取到的id值
             teacher.setT_id(id);
+            // 设置教师对象的密码属性，使用前面获取到的password值
             teacher.setT_password(password);
 
+            // 创建TeacherService的实现类实例，用于调用业务逻辑层中与教师登录相关的方法
             TeacherService service = new TeacherServiceImpl();
+            // 调用业务逻辑层的login方法，传入封装好的教师对象，进行登录验证，将验证通过后返回的教师对象赋值给loginTeacher变量（如果验证失败则为null）
             loginTeacher = service.login(teacher);
 
+            // 判断登录验证是否成功，即loginTeacher不为null，表示找到了对应的教师记录，登录成功
             if (loginTeacher!= null) {
+                // 将登录成功的教师对象存放到HttpSession中，属性名为"teacher"，方便后续在其他页面判断用户是否登录以及获取教师相关信息
                 session.setAttribute("teacher", loginTeacher);
+                // 在会话中设置"html_title"属性，值为"教师端"，可能用于在页面上显示不同的标题栏等内容，标识当前处于教师端页面
                 session.setAttribute("html_title", "教师端");
+                // 重定向到"teacherIndexServlet"，通常这个Servlet会将请求转发到教师端对应的首页（如"/WEB-INF/teacher/tIndex.jsp"等页面），实现登录成功后跳转到教师端首页的功能
+                // （此处注释掉了直接转发的代码，选择使用重定向方式）
 //                request.getRequestDispatcher("/WEB-INF/teacher/tIndex.jsp").forward(request, response);
                 response.sendRedirect("teacherIndexServlet");
             } else {
-                //登录失败 提示信息
+                // 如果登录验证失败，即loginTeacher为null，表示用户名或密码错误等情况
+                // 在请求属性中设置"login_msg"属性，添加提示信息，说明用户名或密码错误，用于后续在登录页面展示给用户
                 request.setAttribute("login_msg", "用户名或密码错误！");
+                // 将请求转发到"/login.jsp"页面，返回登录页面并展示错误提示信息
                 request.getRequestDispatcher("/login.jsp").forward(request, response);
             }
-
         } else {
-
+            // 创建一个Admin对象，用于封装管理员登录相关的信息，作为传递给业务逻辑层进行登录验证的数据对象
             Admin admin = new Admin();
+            // 设置管理员对象的管理员编号属性，使用前面获取到的id值
             admin.setA_id(id);
+            // 设置管理员对象的密码属性，使用前面获取到的password值
             admin.setA_password(password);
 
+            // 创建AdminService的实现类实例，用于调用业务逻辑层中与管理员登录相关的方法
             AdminService service = new AdminServiceImpl();
+            // 调用业务逻辑层的login方法，传入封装好的管理员对象，进行登录验证，将验证通过后返回的管理员对象赋值给loginAdmin变量（如果验证失败则为null）
             loginAdmin = service.login(admin);
 
+            // 判断登录验证是否成功，即loginAdmin不为null，表示找到了对应的管理员记录，登录成功
             if (loginAdmin!= null) {
+                // 将登录成功的管理员对象存放到HttpSession中，属性名为"admin"，方便后续在其他页面判断用户是否登录以及获取管理员相关信息
                 session.setAttribute("admin", loginAdmin);
+                // 在会话中设置"html_title"属性，值为"管理员"，可能用于在页面上显示不同的标题栏等内容，标识当前处于管理员页面
                 session.setAttribute("html_title", "管理员");
+                // 重定向到"adminIndexServlet"，通常这个Servlet会将请求转发到管理员端对应的首页（如"/WEB-INF/admin/aIndex.jsp"等页面），实现登录成功后跳转到管理员端首页的功能
+                // （此处注释掉了直接转发的代码，选择使用重定向方式）
 //                request.getRequestDispatcher("/WEB-INF/admin/aIndex.jsp").forward(request, response);
                 response.sendRedirect("adminIndexServlet");
             } else {
-                //登录失败 提示信息
+                // 如果登录验证失败，即loginAdmin为null，表示用户名或密码错误等情况
+                // 在请求属性中设置"login_msg"属性，添加提示信息，说明用户名或密码错误，用于后续在登录页面展示给用户
                 request.setAttribute("login_msg", "用户名或密码错误！");
+                // 将请求转发到"/login.jsp"页面，返回登录页面并展示错误提示信息
                 request.getRequestDispatcher("/login.jsp").forward(request, response);
             }
         }
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的登录验证等相关逻辑
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/login/LogoutServlet.java

@@ -8,18 +8,43 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到"/logoutServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名可以推断出其主要功能是处理用户注销相关的业务逻辑。
 @WebServlet("/logoutServlet")
 public class LogoutServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"UTF-8"，确保能正确解析包含中文等多字节字符的请求参数（虽然此处可能没有特别涉及中文相关参数，但保持良好的编码设置习惯是必要的）。
         request.setCharacterEncoding("UTF-8");
+
+        // 获取当前请求对应的HttpSession对象，HttpSession用于在多个请求之间保存用户相关的会话信息，
+        // 在这里主要是为了操作会话中存储的用户登录相关的属性信息，以便实现注销功能。
         HttpSession session = request.getSession();
+
+        // 从会话中移除名为"student"的属性，该属性通常在用户（学生角色）登录成功后被设置，用于标识当前登录的学生用户信息，
+        // 移除它意味着清除该用户（学生角色）在会话中的相关登录状态信息。
         session.removeAttribute("student");
+
+        // 从会话中移除名为"teacher"的属性，同理，该属性是在教师角色用户登录成功后设置的，用于保存教师用户的相关信息，
+        // 移除操作清除教师角色用户在会话中的登录状态相关数据。
         session.removeAttribute("teacher");
+
+        // 从会话中移除名为"admin"的属性，这是针对管理员角色用户登录成功后在会话中保存的相关信息，
+        // 通过移除该属性，消除管理员角色用户的会话登录状态记录。
         session.removeAttribute("admin");
+
+        // 使当前会话失效，这一步操作会清除整个会话中的所有属性信息，并且后续该会话相关的请求将无法再获取到之前存储的任何数据，
+        // 相当于彻底结束了当前用户的会话，实现完整的注销效果。
         session.invalidate();
+
+        // 重定向到"index.jsp"页面，通常这个页面是网站的首页或者是一个未登录状态下展示的通用页面，
+        // 在用户注销后将其引导到这个页面，让用户回到初始状态或者未登录时可访问的页面。
         response.sendRedirect("index.jsp");
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的操作，完成用户注销并跳转到相应页面的功能。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/login/RegisterServlet.java

@@ -6,44 +6,86 @@ import service.impl.StudentServiceImpl;
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
-import javax.servlet.http.*;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到"/registerServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名可推测其主要功能是处理学生用户注册相关的业务逻辑。
 @WebServlet("/registerServlet")
 public class RegisterServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 获取当前请求对应的HttpSession对象，HttpSession用于在多个请求之间保存用户相关的会话信息，
+        // 在这里主要用于获取之前存储在会话中的验证码信息以及后续可能的其他与注册相关的会话操作。
         HttpSession session = request.getSession();
+
+        // 从请求中获取名为"studentid"的参数值，该参数通常代表学生注册时输入的学号，作为学生的唯一标识信息。
         String studentid = request.getParameter("studentid");
+        // 从请求中获取名为"password"的参数值，此参数为学生注册时输入的密码。
         String password = request.getParameter("password");
+        // 从请求中获取名为"repassword"的参数值，一般是用于让学生再次输入密码进行确认，确保两次输入的密码一致。
         String repassword = request.getParameter("repassword");
+        // 从请求中获取名为"verifycode"的参数值，该参数是学生在注册页面输入的验证码，用于后续的验证码校验环节。
         String vcode = request.getParameter("verifycode");
 
+        // 从会话中获取名为"CHECKCODE_SERVER"的属性值，该值就是服务器端生成并存储的验证码，类型转换为String类型，
+        // 用于和用户输入的验证码（vcode）进行对比验证。
         String checkcode_server = (String) session.getAttribute("CHECKCODE_SERVER");
-        session.removeAttribute("CHECKCODE_SERVER");//确保验证一次性
+        // 移除会话中的"CHECKCODE_SERVER"属性，确保验证码只能使用一次，防止用户重复利用验证码进行多次注册等异常操作，
+        // 保证验证码验证的一次性原则。
+        session.removeAttribute("CHECKCODE_SERVER");
+
+        // 判断用户输入的验证码（vcode）与服务器端存储的验证码（checkcode_server）是否不相等（不区分大小写进行比较），
+        // 如果不相等，则表示验证码错误。
         if (!vcode.equalsIgnoreCase(checkcode_server)) {
+            // 在请求属性中设置"msg"属性，添加提示信息"验证码错误"，用于后续在注册页面上展示给用户，提示验证码输入有误。
             request.setAttribute("msg", "验证码错误");
+            // 在请求属性中设置"studentid"属性，将用户输入的学号再次存入请求属性，方便在返回注册页面时可以回显给用户，
+            // 让用户无需重新输入学号，提升用户体验。
             request.setAttribute("studentid", studentid);
+            // 在请求属性中设置"password"属性，将用户输入的密码再次存入请求属性，同样方便在返回注册页面时回显密码内容给用户。
             request.setAttribute("password", password);
+            // 在请求属性中设置"repassword"属性，把用户再次输入用于确认的密码也存入请求属性，回显在注册页面上。
             request.setAttribute("repassword", repassword);
+            // 将请求转发到"register.jsp"页面，通常这个页面就是学生注册页面，返回给用户并展示验证码错误的提示信息以及回显之前输入的相关内容。
             request.getRequestDispatcher("register.jsp").forward(request, response);
             return;
         } else {
+            // 如果验证码验证通过，则创建一个Student对象，用于封装要注册的学生相关信息，准备传递给业务逻辑层进行注册操作。
             Student student = new Student();
+            // 设置学生对象的学号属性，使用前面获取到的studentid值。
             student.setS_id(studentid);
+            // 设置学生对象的密码属性，使用前面获取到的password值。
             student.setS_password(password);
+            // 打印学号信息（可能用于调试，查看获取到的学号是否正确等情况），在实际应用中可根据需求决定是否保留此打印语句。
             System.out.println(studentid);
+            // 打印密码信息（同样可能用于调试目的），查看密码获取情况，可按需决定是否保留。
             System.out.println(password);
+
+            // 创建StudentService的实现类实例，用于调用业务逻辑层中与学生注册相关的方法，将学生注册信息保存到数据库等相关操作。
             StudentService service = new StudentServiceImpl();
+            // 调用业务逻辑层的register方法，传入封装好的学生对象，执行学生注册操作。
             service.register(student);
+
+            // 在请求属性中设置"msg"属性，添加提示信息"注册成功"，用于后续在注册页面展示给用户，告知注册操作已成功完成。
             request.setAttribute("msg", "注册成功");
+            // 在请求属性中设置"studentid"属性为空字符串，清空之前存储的学号信息，可能用于在注册页面上显示相应的提示效果（比如清空输入框等）。
             request.setAttribute("studentid", "");
+            // 在请求属性中设置"password"属性为空字符串，同样清空之前存储的密码信息，用于页面显示相关的处理。
             request.setAttribute("password", "");
+            // 在请求属性中设置"repassword"属性为空字符串，清空再次输入确认密码的内容，配合页面显示需求进行处理。
             request.setAttribute("repassword", "");
+            // 将请求转发到"register.jsp"页面，返回注册页面并展示注册成功的提示信息以及清空相关输入框等操作，方便用户进行后续操作（比如登录等）。
             request.getRequestDispatcher("register.jsp").forward(request, response);
-
         }
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的注册相关逻辑操作。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/notify/AddNotifyServlet.java

@@ -17,22 +17,48 @@ import java.util.Date;
 import java.util.List;
 import java.util.Map;
 
+// 使用WebServlet注解将该类映射到"/addNotifyServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名推测其主要功能是处理添加通知相关的业务逻辑。
 @WebServlet("/addNotifyServlet")
 public class AddNotifyServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数，
+        // 这样在获取请求中的通知内容等信息时可以避免出现乱码等问题。
         request.setCharacterEncoding("utf-8");
 
-        //获取参数
+        // 获取参数相关逻辑
+        // 创建一个Notify对象，用于封装要添加的通知相关信息，后续会将其传递给业务逻辑层进行保存到数据库等操作。
         Notify notify = new Notify();
+        // 从请求中获取名为"notifyInfo"的参数值，该参数应该是通知的具体内容信息，将其设置到Notify对象的相应属性中。
         notify.setNotifyInfo((String) request.getParameter("notifyInfo"));
+
+        // 设置通知的发布时间，先获取当前的系统时间，通过创建一个Date对象来表示当前时刻。
         Date d = new Date();
+        // 创建一个SimpleDateFormat对象，用于对日期进行格式化，指定的格式为"yyyy-MM-dd HH:mm:ss"，
+        // 这样可以将日期按照指定的格式转换为字符串，方便存储和展示。
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        // 使用格式化对象将获取到的当前日期（Date类型）格式化为指定格式的字符串，并设置到Notify对象的发布时间属性（notifyDate）中，
+        // 表示该通知的发布时间为当前系统时间。
         notify.setNotifyDate(sdf.format(d));
+
+        // 创建NotifyService的实现类实例，用于调用业务逻辑层中与添加通知相关的方法，
+        // 这里的实现类会负责将封装好的通知对象保存到数据库等具体操作。
         NotifyService service = new NotifyServiceImpl();
+        // 调用业务逻辑层的addNotify方法，传入封装好的Notify对象，执行添加通知的操作，将通知信息保存到数据库中。
         service.addNotify(notify);
+
+        // 以下代码被注释掉了，原本是使用重定向的方式跳转到"/notifyListServlet"，重定向会重新发起一个请求，客户端会向新的URL发起请求。
         // response.sendRedirect("/notifyListServlet");
+
+        // 采用请求转发的方式将当前请求转发到"/notifyListServlet"，请求转发是在服务器内部进行跳转，相对重定向来说更高效，
+        // 转发到的"/notifyListServlet"通常可能是用于展示通知列表的Servlet，这样在添加通知成功后可以直接展示最新的通知列表情况。
         request.getRequestDispatcher("/notifyListServlet").forward(request, response);
     }
+
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的添加通知相关逻辑操作。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/notify/DeleteNotifyServlet.java

@@ -1,4 +1,4 @@
-package web.servlet.notify;
+、package web.servlet.notify;
 
 import domain.Student;
 import service.NotifyService;
@@ -12,17 +12,38 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到"/deleteNotifyServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名可以推断出其主要功能是处理删除通知相关的业务逻辑。
 @WebServlet("/deleteNotifyServlet")
 public class DeleteNotifyServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数，
+        // 虽然此处不一定涉及中文参数，但保持良好的编码设置习惯有助于避免潜在的乱码问题。
         request.setCharacterEncoding("utf-8");
+
+        // 获取当前请求对应的HttpSession对象，HttpSession用于在多个请求之间保存用户相关的会话信息，
+        // 不过在这段代码中暂时未看到对会话信息有进一步的操作，可根据实际业务需求后续考虑是否添加相关逻辑。
         HttpSession session = request.getSession();
+
+        // 从请求中获取名为"id"的参数值，该参数应该是用于标识要删除的通知的唯一ID，
+        // 通常在前端页面（如通知列表页面）点击删除操作时会将对应通知的ID传递过来。
         String notifyid = request.getParameter("id");
+
+        // 创建NotifyService的实现类实例，用于调用业务逻辑层中与删除通知相关的方法，
+        // 这个实现类会负责根据传入的通知ID，在数据库等存储介质中执行删除对应通知记录的操作。
         NotifyService service = new NotifyServiceImpl();
+        // 调用业务逻辑层的deleteNotifyById方法，传入获取到的通知ID（notifyid），执行删除通知的操作，将对应的通知记录从数据库中移除。
         service.deleteNotifyById(notifyid);
+
+        // 将当前请求转发到"/notifyListServlet"，通常这个Servlet是用于展示通知列表的，
+        // 这样在删除通知成功后，可以直接跳转到通知列表页面，展示最新的通知列表情况（已删除指定通知后的列表）。
         request.getRequestDispatcher("/notifyListServlet").forward(request, response);
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的删除通知相关逻辑操作。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/notify/NotifyListServlet.java

@@ -12,15 +12,35 @@ import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.List;
 
+// 使用WebServlet注解将该类映射到"/notifyListServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名可以推测出其主要功能是获取通知列表信息，并将其展示到对应的页面上，用于处理通知列表相关的业务逻辑。
 @WebServlet("/notifyListServlet")
 public class NotifyListServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数，
+        // 例如通知内容等可能包含中文信息，设置编码可以避免出现乱码情况，使后续操作能正常进行。
         request.setCharacterEncoding("utf-8");
+
+        // 创建NotifyService的实现类实例，用于调用业务逻辑层中与获取通知列表相关的方法，
+        // 该实现类具体会去数据库或者其他存储介质中查询并获取所有的通知信息。
         NotifyService service = new NotifyServiceImpl();
+        // 调用业务逻辑层的findAll方法，获取所有通知的列表信息，返回的是一个Notify类型的列表，
+        // 其中每个Notify对象代表一条通知记录，包含通知的各项属性（如通知内容、发布时间等）。
         List<Notify> notifys = service.findAll();
+
+        // 将获取到的通知列表信息存放到请求的属性中，属性名为"notifys"，这样在后续转发到的JSP页面中，
+        // 就可以通过相应的方式（如EL表达式、JSTL标签等）获取该属性值，进而展示通知列表的具体内容。
         request.setAttribute("notifys", notifys);
+
+        // 将当前请求转发到"/WEB-INF/notify/notifyList.jsp"页面，通常这个JSP页面就是用于展示通知列表的页面，
+        // 服务器会查找并渲染该JSP页面，然后把生成的页面内容返回给客户端进行展示，用户就能看到通知列表了。
         request.getRequestDispatcher("/WEB-INF/notify/notifyList.jsp").forward(request, response);
     }
+
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的获取通知列表并展示到对应页面的相关逻辑操作。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/notify/NotifyListToServlet.java

@@ -16,27 +16,56 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
 
+// 使用WebServlet注解将该类映射到"/notifyListToServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名推测其主要功能可能是根据不同用户角色来展示相应的通知列表，处理与通知列表展示定向相关的业务逻辑。
 @WebServlet("/notifyListToServlet")
 public class NotifyListToServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数，
+        // 例如通知的具体内容等可能存在中文信息，设置合适编码可避免出现乱码问题，保障后续操作顺利进行。
         request.setCharacterEncoding("utf-8");
+
+        // 创建NotifyService的实现类实例，用于调用业务逻辑层中与获取通知列表相关的方法，
+        // 该实现类内部通常会去数据库或者其他存储位置查询并获取所有的通知信息记录。
         NotifyService service = new NotifyServiceImpl();
+        // 调用业务逻辑层的findAll方法，获取全部通知的列表数据，返回的是一个Notify类型的列表，
+        // 其中每个Notify对象都包含了一条通知的各项详细信息，比如通知内容、发布时间等。
         List<Notify> notifys = service.findAll();
+        // 将获取到的通知列表信息存放在请求的属性中，属性名为"notifys"，这样在后续转发请求到相应页面时，
+        // 目标页面（如JSP页面）就可以通过相应的方式（例如EL表达式、JSTL标签等）获取到这个属性值，进而展示具体的通知列表内容。
         request.setAttribute("notifys", notifys);
 
+        // 获取当前请求对应的HttpSession对象，HttpSession用于在多个请求之间保存用户相关的会话信息，
+        // 这里主要是为了获取会话中存储的用户登录相关信息，以便判断当前登录用户的角色，进而决定通知列表展示的具体页面。
         HttpSession session = request.getSession();
+
+        // 尝试从会话中获取Student类型的用户对象，如果获取到了，表示当前登录用户是学生角色，否则返回null，
         Student student = (Student) session.getAttribute("student");
+        // 尝试从会话中获取Teacher类型的用户对象，如果获取到了，表示当前登录用户是教师角色，否则返回null，
         Teacher teacher = (Teacher) session.getAttribute("teacher");
+
+        // 根据获取到的学生和教师对象情况（即判断用户角色）来决定转发请求到不同的页面展示通知列表。
         if (student!= null && teacher == null) {
+            // 如果学生对象不为null且教师对象为null，说明当前登录用户是学生角色，
+            // 则将请求转发到"/WEB-INF/notify/notifyListToStudent.jsp"页面，通常这个页面是专门为学生定制的通知列表展示页面，
+            // 会根据学生的相关特点和需求展示通知内容等信息。
             request.getRequestDispatcher("/WEB-INF/notify/notifyListToStudent.jsp").forward(request, response);
         } else if (teacher!= null && student == null) {
+            // 如果教师对象不为null且学生对象为null，意味着当前登录用户是教师角色，
+            // 此时将请求转发到"/WEB-INF/notify/notifyListToTeacher.jsp"页面，该页面应该是针对教师设计的通知列表展示页面，
+            // 会以适合教师查看的方式呈现通知信息。
             request.getRequestDispatcher("/WEB-INF/notify/notifyListToTeacher.jsp").forward(request, response);
         } else {
+            // 如果既不是学生角色也不是教师角色（比如可能是管理员角色或者未登录等其他情况），
+            // 则将请求转发到"error.jsp"页面，这个页面一般用于展示错误提示信息，告知用户出现了不符合预期的情况（此处可能是角色不明确无法正确展示通知列表）。
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
-
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的根据用户角色来决定通知列表展示页面的相关逻辑操作。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/notify/NotifyServlet.java

@@ -7,12 +7,21 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 
+// 使用WebServlet注解将该类映射到"/notifyServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名及代码逻辑来看，大概率是用于引导用户进入通知相关操作页面的功能，比如添加通知等页面。
 @WebServlet("/notifyServlet")
 public class NotifyServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 将当前请求转发到"/WEB-INF/notify/addNotify.jsp"页面。
+        // 通常这个JSP页面是用于展示添加通知的表单界面，用户可以在该页面上填写通知的具体内容等相关信息，
+        // 然后通过后续的操作（比如提交表单）来触发添加通知的实际业务逻辑。
         request.getRequestDispatcher("/WEB-INF/notify/addNotify.jsp").forward(request, response);
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 也就是当接收到GET请求时，同样会将请求转发到"/WEB-INF/notify/addNotify.jsp"页面。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/page/FindStudentByPageServlet.java

@@ -16,45 +16,100 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.Map;
 
+// 使用WebServlet注解将该类映射到"/findStudentByPageServlet"这个URL路径，表明这是一个用于处理对应网络请求的Servlet类，
+// 从类名推测其主要功能是实现按照分页的方式查找学生信息，并根据不同用户角色将查询结果展示到相应页面的业务逻辑。
 @WebServlet("/findStudentByPageServlet")
 public class FindStudentByPageServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数，
+        // 例如学生相关信息中可能存在中文内容（姓名等），设置编码可避免出现乱码问题，使后续操作能正常进行。
         request.setCharacterEncoding("utf-8");
-        String currentPage = request.getParameter("currentPage");//当前页码
-        String rows = request.getParameter("rows");//每页显示条数
 
+        // 从请求中获取名为"currentPage"的参数值，该参数代表当前页码，用于确定要获取哪一页的数据，
+        // 通常由前端页面（如分页导航栏等）传递过来，告知后端当前用户请求查看的是第几页的学生信息。
+        String currentPage = request.getParameter("currentPage");
+
+        // 从请求中获取名为"rows"的参数值，该参数表示每页显示的记录条数，即每页展示多少条学生信息，
+        // 同样是由前端页面根据用户设置（如每页显示10条、20条等选择）传递给后端的参数。
+        String rows = request.getParameter("rows");
+
+        // 判断当前页码参数是否为null或者是空字符串，如果是，则说明前端没有传递或者传递的值不符合要求，
+        // 此时默认将当前页码设置为"1"，表示展示第一页的数据。
         if (currentPage == null || "".equals(currentPage)) {
             currentPage = "1";
         }
+
+        // 类似地，判断每页显示条数参数是否为null或者是空字符串，若满足此情况，
+        // 则默认将每页显示条数设置为"5"，即每页展示5条学生信息。
         if (rows == null || "".equals(rows)) {
             rows = "5";
         }
 
-        //获取条件查询参数
+        // 获取条件查询参数相关逻辑
+        // 通过调用request.getParameterMap()方法获取请求中所有的参数，以Map的形式返回，
+        // 其中键为参数名，值为对应参数名的所有值（以字符串数组形式存储，因为一个参数名可能对应多个值情况），
+        // 这些参数可用于构建更复杂的条件查询（比如根据学生姓名、学号范围等条件进行筛选查找学生信息）。
         Map<String, String[]> condition = request.getParameterMap();
 
+        // 创建StudentService的实现类实例，用于调用业务逻辑层中与按页查找学生信息相关的方法，
+        // 该实现类会根据传入的当前页码、每页显示条数以及查询条件等参数，从数据库等存储介质中获取相应的学生信息数据。
         StudentService service = new StudentServiceImpl();
+
+        // 调用业务逻辑层的findStudentByPage方法，传入当前页码、每页显示条数以及查询条件参数，
+        // 执行分页查找学生信息的操作，返回的是一个PageBean类型的对象，其中封装了查询到的学生信息列表、总记录数、总页数等分页相关的数据。
         PageBean<Student> pb = service.findStudentByPage(currentPage, rows, condition);
 
+        // 将获取到的包含学生信息分页数据的PageBean对象存放到请求的属性中，属性名为"pb"，
+        // 这样在后续转发到的相应页面（如JSP页面）中，就可以通过相应方式（如EL表达式、JSTL标签等）获取该属性值，进而展示分页的学生信息列表等内容。
         request.setAttribute("pb", pb);
-        request.setAttribute("condition",condition);//存入查询条件
+
+        // 将获取到的查询条件参数Map也存放到请求的属性中，属性名为"condition"，
+        // 方便在页面上可以根据之前设置的查询条件进行展示（比如回显用户之前输入的筛选条件等），或者用于后续再次发起查询等操作。
+        request.setAttribute("condition", condition);
+
+        // 再次设置请求的字符编码为"utf-8"，此处可能存在重复设置编码的情况，可根据实际情况确认是否需要保留（一般设置一次即可保证编码正确）。
         request.setCharacterEncoding("utf-8");
+
+        // 获取当前请求对应的HttpSession对象，HttpSession用于在多个请求之间保存用户相关的会话信息，
+        // 这里主要是为了获取会话中存储的用户登录相关信息，以便判断当前登录用户的角色，进而决定将查询结果展示到哪个对应的页面。
         HttpSession session = request.getSession();
+
+        // 尝试从会话中获取Student类型的用户对象，如果获取到了，表示当前登录用户是学生角色，否则返回null，
         Student student = (Student) session.getAttribute("student");
 
+        // 尝试从会话中获取Admin类型的用户对象，如果获取到了，表示当前登录用户是管理员角色，否则返回null，
         Admin admin = (Admin) session.getAttribute("admin");
+
+        // 尝试从会话中获取Teacher类型的用户对象，如果获取到了，表示当前登录用户是教师角色，否则返回null，
         Teacher teacher = (Teacher) session.getAttribute("teacher");
+
+        // 根据获取到的不同用户角色对象情况来决定转发请求到不同的页面展示学生信息分页列表。
         if (student!= null && admin == null && teacher == null) {
+            // 如果学生对象不为null且管理员对象和教师对象都为null，说明当前登录用户是学生角色，
+            // 则将请求转发到"/WEB-INF/student/sFindStudentList.jsp"页面，通常这个页面是专门为学生定制的查看学生信息分页列表的页面，
+            // 会根据学生的相关特点和需求展示学生信息内容等。
             request.getRequestDispatcher("/WEB-INF/student/sFindStudentList.jsp").forward(request, response);
         } else if (admin!= null && student == null && teacher == null) {
+            // 如果管理员对象不为null且学生对象和教师对象都为null，意味着当前登录用户是管理员角色，
+            // 此时将请求转发到"/WEB-INF/admin/aFindStudentList.jsp"页面，该页面应该是针对管理员设计的查看学生信息分页列表的页面，
+            // 会以适合管理员查看的方式呈现学生信息（比如可能包含更多操作按钮等管理功能）。
             request.getRequestDispatcher("/WEB-INF/admin/aFindStudentList.jsp").forward(request, response);
         } else if (teacher!= null && admin == null && student == null) {
+            // 如果教师对象不为null且管理员对象和学生对象都为null，表明当前登录用户是教师角色，
+            // 则将请求转发到"/WEB-INF/teacher/tFindStudentList.jsp"页面，这个页面是为教师定制的查看学生信息分页列表的页面，
+            // 可能会展示与教师教学相关的学生信息等内容。
             request.getRequestDispatcher("/WEB-INF/teacher/tFindStudentList.jsp").forward(request, response);
         } else {
+            // 如果不符合上述任何一种角色明确的情况（比如可能是未登录或者角色信息异常等其他情况），
+            // 则将请求转发到"error.jsp"页面，该页面一般用于展示错误提示信息，告知用户出现了不符合预期的情况（此处可能是无法正确展示学生信息分页列表）。
             request.getRequestDispatcher("error.jsp").forward(request, response);
         }
     }
 
+    // 重写doGet方法，在这个类中直接调用doPost方法来处理GET请求，意味着GET请求和POST请求在本Servlet中的处理逻辑是一样的，
+    // 即当接收到GET请求时，同样会执行上述doPost方法中的按照分页查找学生信息并根据用户角色展示到对应页面的相关逻辑操作。
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request, response);
     }

src/web/servlet/student/DeleteSelectStudentServlet.java

@@ -51,4 +51,12 @@ public class DeleteSelectStudentServlet extends HttpServlet {
         // 这里的实现是直接调用doPost方法，意味着不管是GET请求还是POST请求，都会执行同样的业务逻辑处理
         doPost(request,response);
     }
+<<<<<<< HEAD
 }
+//yuo
+//tu
+//rre
+//s
+=======
+}
+>>>>>>> develop1

src/web/servlet/teacher/AddOptionalCourseServlet.java

@@ -1,50 +1,84 @@
+// 包声明，表明该Servlet类所属的包名，用于组织和管理Java类
 package web.servlet.teacher;  
 
 import domain.Course;
 import domain.Teacher;
+// 导入课程相关的业务逻辑接口，用于后续调用相关业务方法
 import service.CourseService;  
+// 导入课程业务逻辑接口的具体实现类，用于创建具体的业务对象来处理课程相关操作
 import service.impl.CourseServiceImpl;  
 
 import javax.servlet.ServletException;
+// 用于标注该类是一个Servlet，并配置其访问的URL路径
 import javax.servlet.annotation.WebServlet;  
+// 继承自HttpServlet，是Java Web中处理HTTP请求的基础类
 import javax.servlet.http.HttpServlet;  
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+// 用于表示HTTP会话，可在其中存储和获取用户相关的会话信息
 import javax.servlet.http.HttpSession;  
 import java.io.IOException;
 import java.util.Date;
 
+// 使用@WebServlet注解配置该Servlet的访问路径为 "/addOptionalCourseServlet"，
+// 意味着当客户端通过此路径发起请求时，会由该Servlet进行处理
 @WebServlet("/addOptionalCourseServlet")  
 public class AddOptionalCourseServlet extends HttpServlet {
+
+    // 重写doPost方法，用于处理HTTP POST请求
+    // 参数request表示客户端发来的请求对象，包含请求的各种信息
+    // 参数response表示要返回给客户端的响应对象，用于设置响应内容等
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 设置请求的字符编码为"utf-8"，确保能正确解析包含中文等多字节字符的请求参数
         request.setCharacterEncoding("utf-8");  
 
+        // 获取当前请求对应的会话对象，如果不存在则创建一个新的会话
         HttpSession session = request.getSession();  
+        // 从会话中获取名为"teacher"的属性值，并转换为Teacher类型，
+        // 通常这里存储的是当前登录教师的相关信息
         Teacher teacher = (Teacher) session.getAttribute("teacher");  
 
+        // 从请求参数中获取课程ID，对应HTML表单中名为"cid"的输入项
         String cid = request.getParameter("cid");  
+        // 从请求参数中获取课程名称，对应HTML表单中名为"course-name"的输入项
         String cname = request.getParameter("course-name");  
+        // 从请求参数中获取课程详细信息，对应HTML表单中名为"course-info"的输入项
         String cinfo = request.getParameter("course-info");  
 
+        // 创建课程业务逻辑层的具体实现类对象，用于调用具体的课程相关业务方法
         CourseService service = new CourseServiceImpl();  
+        // 通过业务层方法，根据课程ID查找对应的课程对象，查看是否已存在该课程
         Course course =  service.findSelectCourseByCourseId(cid);  
         if (course!= null) {
+            // 如果课程已存在（即查找结果不为空），则向请求对象中设置一个属性"update_msg"，
+            // 提示课程ID冲突，并附带当前时间信息，然后将请求转发到指定的JSP页面进行展示
             request.setAttribute("update_msg","课程ID冲突，请重新添加！" + String.format("%tT",new Date()));
             request.getRequestDispatcher("/WEB-INF/teacher/addOptionalCourse.jsp").forward(request,response);
         } else {
+            // 如果课程不存在，则创建一个新的Course对象，用于封装要添加的课程信息
             Course newCourse = new Course();  
+            // 设置新课程的ID
             newCourse.setC_id(cid);  
+            // 设置新课程的名称
             newCourse.setC_name(cname);  
+            // 设置新课程的详细信息
             newCourse.setC_info(cinfo);  
+            // 设置新课程所属教师的ID，从之前从会话中获取的教师对象中获取教师ID
             newCourse.setT_id(teacher.getT_id());  
+            // 设置新课程所属教师的姓名，从之前从会话中获取的教师对象中获取教师姓名
             newCourse.setT_name(teacher.getT_name());  
 
+            // 通过业务层对象调用添加可选课程的方法，将新创建的课程信息保存到数据库等存储介质中
             service.addOptionalCourse(newCourse);  
+            // 向请求对象中设置一个属性"update_msg"，提示课程添加成功，并附带当前时间信息
             request.setAttribute("update_msg","课程添加成功！" + String.format("%tT",new Date()));
+            // 将请求转发到指定的JSP页面（通常用于展示添加课程后的相关提示信息等）
             request.getRequestDispatcher("/WEB-INF/teacher/addOptionalCourse.jsp").forward(request,response);
         }
     }
 
+    // 重写doGet方法，在该Servlet中直接调用doPost方法来处理GET请求，
+    // 意味着GET请求的处理逻辑和POST请求一样（实际应用中可根据需求单独定制处理逻辑）
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         doPost(request,response);
     }

src/web/servlet/teacher/AddSelectCourseServlet.java

@@ -1,4 +1,5 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，用于对类进行合理的组织和管理，方便在项目中区分不同功能模块的类。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -6,15 +7,35 @@ import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
+// 导入必要的Java EE相关的类库。
+// ServletException用于处理Servlet执行过程中出现的异常情况。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，方便容器识别并进行相关配置和管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法。
+// HttpServletRequest用于获取来自客户端的HTTP请求信息，例如请求参数、请求头信息等。
+// HttpServletResponse用于向客户端发送HTTP响应，例如设置响应状态码、响应头以及返回响应内容等。
+// IOException用于处理输入输出相关的异常，比如读写文件、网络传输等出现问题时抛出。
 
 @WebServlet("/addSelectCourseServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定该Servlet对应的访问路径为"/addSelectCourseServlet"。当客户端通过这个路径发起HTTP请求时，容器就会找到并调用这个Servlet来处理请求。
 public class AddSelectCourseServlet extends HttpServlet {
+    // 定义一个名为AddSelectCourseServlet的类，它继承自HttpServlet类，表明这个类是一个用于处理HTTP请求的Servlet，继承HttpServlet可以方便地重写相关方法来处理不同类型的HTTP请求（如GET、POST等）。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式访问此Servlet对应的路径时，容器会调用这个方法来处理请求。
+        // 参数request包含了客户端发送过来的请求信息，response用于向客户端返回响应信息。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，确保从客户端接收到的请求参数等数据能够正确地按照UTF-8编码进行解析，避免中文等特殊字符出现乱码问题。
+
         request.getRequestDispatcher("/WEB-INF/teacher/addOptionalCourse.jsp").forward(request, response);
+        // 获取一个请求转发器，指定转发的目标页面为"/WEB-INF/teacher/addOptionalCourse.jsp"。
+        // 然后使用forward方法将当前请求转发到指定的JSP页面，这样在处理完Servlet中的业务逻辑后，可以让服务器端渲染并返回对应的JSP页面内容给客户端，整个过程对客户端来说是一次请求响应的过程，地址栏中的URL不会发生变化。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet中的doGet方法，用于处理HTTP GET请求。当客户端通过GET方式访问此Servlet对应的路径时，容器会调用这个方法来处理请求。
+
         doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即都会将请求转发到"/WEB-INF/teacher/addOptionalCourse.jsp"这个JSP页面进行后续处理。
     }
 }

src/web/servlet/teacher/AddTeacherInfoServlet.java

@@ -1,8 +1,11 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，按照功能模块对类进行分类管理，方便在项目结构中组织代码。
 
 import domain.Teacher;
 import service.TeacherService;
 import service.impl.TeacherServiceImpl;
+// 导入与教师相关的领域模型类（Teacher），教师业务逻辑的服务接口（TeacherService）以及该接口的具体实现类（TeacherServiceImpl）。
+// Teacher类通常用于封装教师相关的属性和业务逻辑，TeacherService定义了教师业务操作的抽象方法，TeacherServiceImpl则是这些方法的具体实现类。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -11,25 +14,63 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.Date;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作和异常。
+// ServletException用于处理Servlet执行过程中出现的异常情况。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，如请求参数等。
+// HttpServletResponse用于向客户端发送HTTP响应，比如设置响应状态码、响应头以及返回响应内容等。
+// IOException用于处理输入输出相关的异常，例如读写文件或者网络传输等出现问题时抛出。
+// Date类用于获取当前的日期和时间信息，在这里可能用于记录操作的时间等用途。
 
 @WebServlet("/addTeacherInfoServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为"/addTeacherInfoServlet"。当客户端通过这个URL路径发起HTTP请求时，Web容器就会找到并调用这个Servlet来处理请求。
 public class AddTeacherInfoServlet extends HttpServlet {
+    // 定义一个名为AddTeacherInfoServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等）。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式访问此Servlet对应的URL路径时，容器会调用这个方法来处理请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则用于向客户端返回响应信息。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，确保从客户端接收到的请求参数等数据能够按照UTF-8编码格式正确解析，避免中文等特殊字符出现乱码问题，保证数据的准确性。
+
         TeacherService service = new TeacherServiceImpl();
+        // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量service。这样后续就可以调用TeacherService接口中定义的教师业务相关方法，而具体的实现则由TeacherServiceImpl类来完成。
+
         // 先进行判断是否已存在该教师
         String tid = request.getParameter("teacher-id");
+        // 从客户端发送的HTTP请求中获取名为"teacher-id"的参数值，该参数值通常代表教师的编号，用于后续判断是否已经存在具有该编号的教师记录。
+
         Teacher t = new Teacher();
+        // 创建一个Teacher类的实例t，用于封装教师相关的信息，此处先创建一个空的教师对象，后续会设置相应的属性值。
+
         t.setT_id(tid);
+        // 通过调用Teacher类的setT_id方法，将从请求中获取到的教师编号（tid）设置到教师对象t中，以便后续根据这个编号进行数据库查询等操作来判断教师是否已存在。
+
         Teacher newTeacher = service.findTeacherById(t);
+        // 调用service（实际是TeacherServiceImpl类的实例）的findTeacherById方法，传入刚才设置好编号的教师对象t，该方法应该是根据教师编号去数据库等存储介质中查询是否存在对应的教师记录，并返回查询到的教师对象（如果存在的话），将查询结果赋值给newTeacher变量。
+
         if (newTeacher!= null) {
+            // 判断查询到的教师对象newTeacher是否不为空，即是否已经存在具有该编号的教师记录。
             request.setAttribute("update_msg", "已存在该教师，请重新添加！" + String.format("%tT", new Date()));
+            // 如果教师已存在，使用request对象的setAttribute方法设置一个名为"update_msg"的属性，属性值是提示信息，告知用户该教师已存在，并拼接上当前的时间（通过String.format结合%tT格式化Date对象，得到具体的时间格式字符串），以便用户了解操作的时间情况。
             request.getRequestDispatcher("addTeacherServlet").forward(request, response);
+            // 获取一个请求转发器，将请求转发到名为"addTeacherServlet"的资源（可能是另一个Servlet或者JSP页面等），这样服务器端会接着处理转发后的请求，并向客户端返回相应的响应内容，整个过程对客户端来说是一次完整的请求响应过程，地址栏中的URL不会发生改变。
         } else {
+            // 如果教师不存在，则执行以下添加教师信息的逻辑。
+
             String name = request.getParameter("teacher-name");
+            // 从客户端请求中获取名为"teacher-name"的参数值，该值代表教师的姓名，用于后续设置到要添加的教师对象中。
+
             String sex = request.getParameter("teacher-sex");
+            // 从请求中获取名为"teacher-sex"的参数值，代表教师的性别，同样用于设置教师对象的属性。
+
             String education = request.getParameter("teacher-education");
+            // 获取"teacher-education"参数值，对应教师的文化程度信息，用于后续操作。
+
             String title = request.getParameter("teacher-title");
+            // 获取"teacher-title"参数值，代表教师的职称信息，准备设置到教师对象里。
 
 //            String college = request.getParameter("selectCollege");
 //            String department = request.getParameter("selectDepartment");
@@ -43,25 +84,46 @@ public class AddTeacherInfoServlet extends HttpServlet {
 //            if ("".equals(cclass)) {
 //                cclass = "待分配";
 //            }
+            // 上述代码段被注释掉了，但原本的意图可能是从请求中获取教师所属的学院、系别、班级信息，如果获取到的值为空字符串，就将其设置为"待分配"，表示该教师在这些方面暂未明确分配相应的归属。
 
             Teacher updateTeacher = new Teacher();
+            // 创建一个新的Teacher类实例updateTeacher，用于封装要添加的教师的完整信息，后续将各项参数值设置到这个对象中。
 
             updateTeacher.setT_id(tid);
+            // 将之前获取到的教师编号设置到updateTeacher对象中，确保添加的教师具有正确的编号信息。
+
             updateTeacher.setT_name(name);
+            // 设置教师的姓名到updateTeacher对象中。
+
             updateTeacher.setT_sex(sex);
+            // 设置教师的性别信息到对象中。
+
             updateTeacher.setT_education(education);
+            // 设置教师的文化程度信息到对象中。
+
             updateTeacher.setT_title(title);
+            // 设置教师的职称信息到对象中。
+
 //            updateTeacher.setT_college(college);
 //            updateTeacher.setT_department(department);
 //            updateTeacher.setT_class(cclass);
+            // 同样，上述被注释掉的代码原本是要设置教师所属的学院、系别、班级信息到updateTeacher对象中。
 
             service.addTeacherAllInfo(updateTeacher);
+            // 调用service（TeacherServiceImpl的实例）的addTeacherAllInfo方法，将封装好教师所有信息的updateTeacher对象传入，该方法应该会将教师信息保存到数据库等存储介质中，完成教师信息的添加操作。
+
             request.setAttribute("update_msg", "添加成功！" + String.format("%tT", new Date()));
+            // 设置名为"update_msg"的属性，属性值为添加成功的提示信息，并拼接当前时间，方便用户知晓操作完成的时间情况。
+
             request.getRequestDispatcher("addTeacherServlet").forward(request, response);
+            // 再次使用请求转发器将请求转发到"addTeacherServlet"资源，进行后续的页面展示或者其他相关业务处理，保持整个请求响应流程的连贯性，客户端看到的URL不变。
         }
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求。
+
         doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即都会按照doPost方法中的逻辑进行处理，比如判断教师是否存在、添加教师信息等操作。
     }
 }

src/web/servlet/teacher/AddTeacherServlet.java

@@ -1,8 +1,13 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，通过包名对类进行分类管理，有助于在项目中清晰地组织代码结构，方便区分不同功能模块对应的类。
 
 import domain.CDC;
 import service.CDCService;
 import service.impl.CDCServiceImpl;
+// 导入与CDC（可能是某种机构、部门等相关的领域模型类，具体含义取决于业务场景）相关的类和接口。
+// domain.CDC表示CDC类所在的包名和类名，该类通常用于封装CDC相关的属性和业务逻辑。
+// service.CDCService是定义CDC业务操作的服务接口，规定了可以对CDC进行的各种业务方法，比如查询、添加、删除等操作（这里从名字推测可能主要涉及查询相关操作）。
+// service.impl.CDCServiceImpl则是CDCService接口的具体实现类，实现了接口中定义的方法，具体完成与数据库或其他数据源交互来实现业务逻辑的功能。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -12,26 +17,60 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及可能出现的异常情况。
+// ServletException用于处理Servlet执行过程中出现的异常情况，比如配置错误、业务逻辑执行出错等。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性，方便Web容器识别和管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，我们可以通过重写它的方法来实现具体的业务逻辑处理。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，例如请求参数、请求头信息等，是处理请求数据的重要入口。
+// HttpServletResponse用于向客户端发送HTTP响应，比如设置响应状态码、响应头以及返回响应内容等，用于构建返回给客户端的信息。
+// HttpSession用于在服务器端管理用户会话信息，通过它可以在不同的请求之间共享数据，比如保存用户的登录状态、购物车信息等（这里可能用于保存一些与添加教师页面相关的数据）。
+// IOException用于处理输入输出相关的异常，像读写文件、网络传输等出现问题时会抛出该异常。
+// List是Java集合框架中的接口，表示一个有序的、可重复元素的集合，这里用于存放从数据库等数据源查询出来的CDC相关数据列表（例如学院、系别、班级列表等）。
 
 @WebServlet("/addTeacherServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为"/addTeacherServlet"。当客户端通过这个URL路径发起HTTP请求时，Web容器（如Tomcat等）就会找到并调用这个Servlet来处理请求。
 public class AddTeacherServlet extends HttpServlet {
+    // 定义一个名为AddTeacherServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等），以实现具体的业务逻辑。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式访问此Servlet对应的URL路径时，容器会调用这个方法来处理请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则用于向客户端返回响应信息。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，确保从客户端接收到的请求参数等数据能够按照UTF-8编码格式正确解析，避免中文等特殊字符出现乱码问题，保证后续获取和处理请求数据的准确性。
+
         HttpSession session = request.getSession();
+        // 获取当前请求对应的HttpSession对象，如果不存在则创建一个新的会话对象。HttpSession可以用于在多个请求之间保存和共享数据，方便实现一些需要跨请求保持状态的功能，比如登录后的用户信息保存等。在这里主要用于存放一些后续要在页面中展示的数据列表。
 
         CDCService service = new CDCServiceImpl();
+        // 创建一个CDCServiceImpl类的实例，通过多态的方式将其赋值给CDCService接口类型的变量service。这样后续就可以调用CDCService接口中定义的与CDC相关的业务方法，而具体的实现则由CDCServiceImpl类来完成，例如查询学院、系别、班级等列表信息的操作。
+
         List<CDC> collegeList = service.findAllCollege();
+        // 调用service（实际是CDCServiceImpl的实例）的findAllCollege方法，该方法应该是从数据库或者其他数据源中查询出所有学院的信息，并以CDC对象的列表形式返回，将查询到的学院信息列表赋值给collegeList变量。
+
         List<CDC> departmentList = service.findAllDepartment();
+        // 同样地，调用findAllDepartment方法，从数据源中获取所有系别的信息，以CDC对象列表形式返回，赋值给departmentList变量，用于后续在页面上展示系别相关的下拉选项等操作。
+
         List<CDC> classList = service.findAllClass();
+        // 调用findAllClass方法，查询并获取所有班级的信息，以CDC对象列表形式返回，赋值给classList变量，方便在页面中展示班级相关的下拉选择内容等。
 
         session.setAttribute("collegeLists", collegeList);
+        // 使用HttpSession对象的setAttribute方法，将查询到的学院信息列表（collegeList）保存到会话中，设置的属性名为"collegeLists"，这样在后续的请求处理或者页面渲染过程中（只要是同一个会话内），就可以获取到这个学院列表数据进行展示或其他操作。
+
         session.setAttribute("departmentLists", departmentList);
+        // 类似地，将系别信息列表（departmentList）保存到会话中，属性名为"departmentLists"，以便在相关页面中使用这些系别数据，例如构建下拉菜单选项等。
+
         session.setAttribute("classLists", classList);
+        // 把班级信息列表（classList）保存到会话中，属性名为"classLists"，便于后续页面展示班级相关的选择内容等操作。
 
         request.getRequestDispatcher("/WEB-INF/admin/addTeacher.jsp").forward(request, response);
+        // 获取一个请求转发器，将当前请求转发到"/WEB-INF/admin/addTeacher.jsp"这个页面（通常是一个JSP页面，用于展示添加教师的表单等相关内容）。这样服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面渲染后的内容，整个过程对客户端来说是一次完整的请求响应过程，地址栏中的URL不会发生改变。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求。
+
         doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即都会按照doPost方法中的逻辑进行处理，比如查询相关数据列表、保存到会话中以及转发请求到添加教师的JSP页面等操作。
     }
 }

src/web/servlet/teacher/DeleteOptionalCourseServlet.java

@@ -1,7 +1,11 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，通过包来对类进行分类管理，使项目代码结构更加清晰，便于区分不同功能模块对应的代码。
 
 import service.TeacherService;
 import service.impl.TeacherServiceImpl;
+// 导入教师相关业务逻辑的服务接口（TeacherService）以及该接口的具体实现类（TeacherServiceImpl）。
+// TeacherService接口定义了一系列针对教师业务操作的抽象方法，例如这里可能涉及到对课程相关操作的方法声明等。
+// TeacherServiceImpl类则是对TeacherService接口的具体实现，里面包含了与数据库或其他数据源交互，来实际完成业务逻辑的代码，比如具体的课程删除操作实现等。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -10,18 +14,44 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及可能出现的异常情况。
+// ServletException用于处理Servlet执行过程中出现的异常情况，比如业务逻辑执行出错、配置错误等。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性，方便Web容器识别并进行管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，我们可以通过重写它的方法来实现具体的业务逻辑处理。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，像请求参数、请求头信息等，是后续处理请求数据的重要依据。
+// HttpServletResponse用于向客户端发送HTTP响应，例如设置响应状态码、响应头以及返回响应内容等，用于构建返回给客户端的信息。
+// HttpSession用于在服务器端管理用户会话信息，通过它可以在不同的请求之间共享数据，不过在这段代码里暂时没有明显体现出对会话信息的复杂使用场景。
+// IOException用于处理输入输出相关的异常，例如读写文件、网络传输等出现问题时会抛出该异常。
 
 @WebServlet("/deleteOptionalCourseServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为"/deleteOptionalCourseServlet"。当客户端通过这个URL路径发起HTTP请求时，Web容器（如Tomcat等）就会找到并调用这个Servlet来处理请求。
 public class DeleteOptionalCourseServlet extends HttpServlet {
+    // 定义一个名为DeleteOptionalCourseServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等），以实现具体的业务逻辑，这里主要是实现删除可选课程的业务逻辑。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式访问此Servlet对应的URL路径时，容器会调用这个方法来处理请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则用于向客户端返回响应信息。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，确保从客户端接收到的请求参数等数据能够按照UTF-8编码格式正确解析，避免中文等特殊字符出现乱码问题，保证后续获取和处理请求数据的准确性，特别是这里要获取课程编号等信息，防止乱码很重要。
+
         String cid = request.getParameter("cid");
+        // 从客户端发送的HTTP请求中获取名为"cid"的参数值，该参数值通常代表要删除的课程的编号（具体含义取决于业务逻辑中的定义），将获取到的课程编号赋值给cid变量，以便后续根据这个编号进行课程删除操作。
+
         TeacherService service = new TeacherServiceImpl();
+        // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量service。这样后续就可以调用TeacherService接口中定义的业务方法，而具体的删除课程操作的实现则由TeacherServiceImpl类来完成。
+
         service.deleteCourseById(cid);
+        // 调用service（实际是TeacherServiceImpl的实例）的deleteCourseById方法，传入刚才获取到的课程编号cid，该方法应该是在数据库或其他存储课程信息的数据源中，根据课程编号来删除对应的课程记录，实现课程删除的业务逻辑操作。
+
         request.getRequestDispatcher("/teacherOptionalCourseServlet").forward(request, response);
+        // 获取一个请求转发器，将当前请求转发到"/teacherOptionalCourseServlet"这个资源（可能是另一个Servlet或者JSP页面等）。这样服务器端会接着处理转发后的请求，并向客户端返回相应的响应内容，整个过程对客户端来说是一次完整的请求响应过程，地址栏中的URL不会发生改变，通过转发可以继续后续的页面展示或者其他相关业务处理。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求。
+
         doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即都会按照doPost方法中的逻辑进行处理，比如获取课程编号、删除课程以及转发请求等操作。
     }
 }

src/web/servlet/teacher/DeleteTeacherServlet.java

@@ -1,7 +1,11 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，利用包来对类进行分类组织，使项目的代码结构更加清晰有条理，便于区分不同功能模块对应的类。
 
 import service.TeacherService;
 import service.impl.TeacherServiceImpl;
+// 导入教师业务相关的服务接口（TeacherService）以及该接口对应的具体实现类（TeacherServiceImpl）。
+// TeacherService接口通常会定义一系列针对教师相关业务操作的抽象方法，比如删除教师、查询教师信息等操作的方法声明。
+// TeacherServiceImpl类则是对TeacherService接口的具体实现，其内部包含了与数据库或者其他数据源进行交互的代码，以此来实际完成相应的业务逻辑，例如这里涉及的根据教师编号删除教师信息的具体实现就在这个类中。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -10,18 +14,44 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及可能出现的异常情况。
+// ServletException用于处理Servlet在执行过程中出现的各种异常，像业务逻辑出错、配置不正确等情况引发的异常都会通过它来处理。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并且可以配置这个Servlet对应的访问路径等相关属性，方便Web容器（例如Tomcat等服务器）识别并对其进行管理和调度。
+// HttpServlet是所有基于HTTP协议的Servlet的基础类，它提供了处理HTTP请求的基本结构和相关方法，开发人员可以通过重写它里面的方法来实现具体的业务逻辑，以应对不同类型的HTTP请求（如GET、POST等）。
+// HttpServletRequest主要用于获取客户端发送过来的HTTP请求中包含的各种信息，比如请求参数、请求头里的数据等，它是后续在Servlet中处理请求数据的重要入口。
+// HttpServletResponse用于向客户端发送HTTP响应，例如设置响应的状态码、响应头的相关信息以及返回具体的响应内容等，以此构建完整的返回给客户端的信息。
+// HttpSession用于在服务器端管理用户的会话信息，通过它能够实现在不同的请求之间共享数据，不过在当前这段代码里暂时没有复杂的针对会话信息的操作体现。
+// IOException用于处理输入输出相关的异常情况，像读写文件过程中、网络传输数据时等出现问题就会抛出该异常。
 
 @WebServlet("/deleteTeacherServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定这个Servlet对应的访问路径为"/deleteTeacherServlet"。当客户端通过这个特定的URL路径发起HTTP请求时，Web容器就会找到并调用这个Servlet来处理请求。
 public class DeleteTeacherServlet extends HttpServlet {
+    // 定义了一个名为DeleteTeacherServlet的类，它继承自HttpServlet类，这就表明这个类是一个专门用于处理HTTP请求的Servlet，借助继承HttpServlet类的特性，可以方便地重写其中的方法来实现具体的业务逻辑，此处重点在于实现删除教师的相关业务逻辑。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写了HttpServlet类中的doPost方法，该方法主要用于处理HTTP POST请求。当客户端通过POST方式访问此Servlet对应的"/deleteTeacherServlet"这个URL路径时，Web容器会自动调用这个方法来处理相应的请求。
+        // 方法中的参数request包含了客户端发送过来的全部请求信息，而response则是用于向客户端返回响应信息的对象。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，这一步操作很关键，它能确保从客户端接收到的请求参数等各类数据可以按照UTF-8编码格式被准确地解析出来，有效避免中文或者其他特殊字符出现乱码的问题，从而保障后续获取和处理请求数据时的准确性，在这里特别重要的是保证获取教师编号等关键信息不出错。
+
         String teacherid = request.getParameter("tid");
+        // 从客户端发送的HTTP请求中获取名为"tid"的参数值，按照业务逻辑推测，这个参数值通常代表着要删除的教师的编号，然后将获取到的教师编号赋值给teacherid变量，方便后续依据这个编号进行删除教师的具体操作。
+
         TeacherService service = new TeacherServiceImpl();
+        // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量service。如此一来，后续就能调用TeacherService接口里定义的各种业务方法了，而具体的删除教师操作的实际代码实现则是由TeacherServiceImpl类来完成的。
+
         service.deleteTeacherById(teacherid);
+        // 调用service（实际上就是TeacherServiceImpl的实例）的deleteTeacherById方法，将前面获取到的教师编号teacherid作为参数传入进去。这个方法应该是在数据库或者其他存储教师信息的数据源中，依据传入的教师编号来查找并删除对应的教师记录，以此实现删除教师的业务逻辑操作。
+
         request.getRequestDispatcher("/teacherListServlet").forward(request, response);
+        // 获取一个请求转发器，把当前的请求转发到"/teacherListServlet"这个资源（它可能是另一个Servlet或者是一个JSP页面等）。通过这样的转发操作，服务器端会接着去处理转发后的请求，并向客户端返回相应的响应内容，而且整个过程对于客户端来说就像是一次完整的请求响应过程，客户端浏览器地址栏中的URL并不会发生改变，转发后可以继续进行后续的页面展示或者其他相关业务处理，例如重新展示教师列表等。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，该方法主要用于处理HTTP GET请求。
+
         doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，这意味着对于GET请求的处理逻辑和POST请求的处理逻辑是完全一样的，也就是都会按照doPost方法里所定义的逻辑去进行相应的处理，比如获取教师编号、删除教师以及转发请求等操作都会同样执行。
     }
 }

src/web/servlet/teacher/FindStudentCourseScoreServlet.java

@@ -1,8 +1,13 @@
 package web.servlet.teacher;
+// 声明该类所属的包名，表明这个Servlet类位于"web.servlet.teacher"包下，通过包结构对类进行组织管理，有助于清晰地划分项目中的不同功能模块，方便代码的维护与扩展。
 
 import domain.SelectCourse;
 import service.SelectCourseService;
 import service.impl.SelectCourseServiceImpl;
+// 导入相关的类和接口，用于处理选课相关的业务逻辑。
+// "domain.SelectCourse"：通常是一个领域模型类，用于封装与选课相关的各种属性，比如学生所选课程的具体信息（课程编号、学生编号等）以及对应的成绩等内容，代表了业务领域中的选课这一概念实体在代码中的体现。
+// "service.SelectCourseService"：这是定义了选课业务操作的服务接口，规定了可以在选课业务方面进行的各种操作方法，例如查询学生选课信息、更新选课记录等，是对选课业务逻辑抽象出来的统一操作入口。
+// "service.impl.SelectCourseServiceImpl"：是"SelectCourseService"接口的具体实现类，里面包含了实际与数据库或其他数据源进行交互的代码，以此来真正完成接口中定义的那些选课业务操作，比如按照特定条件查询数据库获取选课信息等具体实现细节就在这个类中。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -11,26 +16,55 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.List;
+// 导入Java EE中Servlet相关的基础类和接口以及处理输入输出异常、使用集合框架所需的类。
+// "ServletException"：用于处理Servlet在执行过程中出现的各种异常情况，比如配置错误、业务逻辑执行出错、请求处理过程中遇到不符合预期的情况等，都可以通过抛出这个异常来进行相应的处理。
+// "WebServlet"：是一个注解类，用于将一个普通的Java类标注为Servlet，并可以通过它配置该Servlet对应的访问路径等相关属性，方便Web容器（像Tomcat等应用服务器）识别并对其进行管理和调度，决定何时以及如何调用这个Servlet来处理客户端的请求。
+// "HttpServlet"：是所有基于HTTP协议的Servlet的基类，它提供了处理HTTP请求的基础架构和一系列默认方法，开发人员通过重写它里面的特定方法（如doGet、doPost等）来实现具体的业务逻辑，以应对不同类型的HTTP请求。
+// "HttpServletRequest"：主要用于获取客户端发送过来的HTTP请求中包含的各种详细信息，例如请求参数（通过类似getParameter方法获取表单提交的数据等）、请求头信息（如浏览器相关的一些标识信息等）以及其他和请求相关的内容，是在Servlet中处理请求数据的关键入口。
+// "HttpServletResponse"：负责向客户端发送HTTP响应，包括设置响应的状态码（比如200表示成功、404表示未找到资源等）、响应头（设置如内容类型、缓存控制等相关的头部信息）以及返回具体的响应内容（如HTML页面、JSON数据等），用于构建完整的返回给客户端的信息。
+// "IOException"：用于处理输入输出相关的异常情况，例如在读取或写入文件、进行网络传输（像从数据库获取数据或者向客户端发送响应数据等涉及到数据传输的操作）等过程中如果出现问题，就会抛出这个异常，方便进行相应的错误处理。
+// "List"：是Java集合框架中的接口，表示一个有序的、可包含重复元素的集合，在这里用于存放查询出来的多个选课相关信息（以SelectCourse对象的形式），方便后续对这些数据进行遍历、处理以及传递给其他组件（如JSP页面用于展示等）。
 
 @WebServlet("/findStudentCourseScoreServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定这个Servlet对应的访问路径为"/findStudentCourseScoreServlet"。意味着当客户端通过浏览器等工具，向服务器发起的HTTP请求的URL路径为该指定路径时，Web容器（服务器端负责管理Servlet的环境，如Tomcat）就会找到并调用这个Servlet类来处理相应的请求。
 public class FindStudentCourseScoreServlet extends HttpServlet {
+    // 定义了一个名为"FindStudentCourseScoreServlet"的类，它继承自"HttpServlet"类，这表明该类是一个专门用于处理HTTP请求的Servlet，借助继承"HttpServlet"类的机制，可以方便地重写其中相应的方法（比如doGet、doPost等）来实现具体的、与业务相关的请求处理逻辑，在这个类中主要是实现查询学生课程成绩相关的业务逻辑。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写了"HttpServlet"类中的"doPost"方法，此方法专门用于处理HTTP POST请求。当客户端通过POST方式（例如表单提交等情况常用POST方式向服务器发送数据）访问此Servlet对应的"/findStudentCourseScoreServlet"这个URL路径时，Web容器会自动调用这个重写后的方法来处理相应的请求。
+        // 方法中的两个参数"request"和"response"分别代表客户端发送过来的请求信息以及用于向客户端返回响应信息的对象，它们在整个请求处理过程中起着关键作用，通过它们可以获取请求数据、设置响应内容等。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，这一步非常重要，因为客户端发送过来的数据可能包含各种字符（特别是如果有中文等非ASCII字符时），如果不设置正确的编码，在获取请求参数等数据时可能会出现乱码问题，无法正确解析数据内容。通过设置为"utf-8"编码格式，能确保后续从请求中获取到的参数等数据可以按照正确的编码规范进行解析，保障数据的准确性和完整性，在这里对于获取要查询成绩的课程编号等关键信息尤为重要。
+
         String cid = request.getParameter("cid");
+        // 从客户端发送的HTTP请求中获取名为"cid"的参数值，按照业务逻辑推测，这个参数值通常代表要查询成绩的课程的编号，它是后续进行查询学生该课程成绩相关操作的重要依据，将获取到的课程编号赋值给"cid"变量，方便后续在代码中使用这个变量来调用相应的业务方法进行查询操作。
+
         System.out.println(cid);
+        // 将获取到的课程编号（cid）输出打印到控制台，这一般是出于调试目的，方便开发人员在运行程序时查看实际接收到的课程编号是否符合预期，比如检查前端页面传递过来的参数是否正确，或者在排查程序出现问题（例如查询不到数据等情况）时，通过查看这个参数值来确认是否是传入参数的问题，有助于快速定位和解决问题。
 
         SelectCourseService service = new SelectCourseServiceImpl();
+        // 创建一个"SelectCourseServiceImpl"类的实例，通过多态的方式将其赋值给"SelectCourseService"接口类型的变量"service"。这样做的好处是，代码后续调用"SelectCourseService"接口中定义的方法时，实际上执行的是"SelectCourseServiceImpl"类中对这些方法的具体实现代码，使得代码的结构更加灵活，便于替换不同的实现方式或者进行单元测试等操作，在这里就是为了调用选课业务相关的方法来查询学生选课及成绩信息。
+
         List<SelectCourse> scs =  service.findStudentSelectedCourseByCourseId(cid);
+        // 调用"service"（实际上就是"SelectCourseServiceImpl"的实例）的"findStudentSelectedCourseByCourseId"方法，将前面获取到的课程编号"cid"作为参数传入进去。这个方法应该是在数据库或者其他存储选课信息的数据源中，依据传入的课程编号来查询出选修该课程的所有学生的选课信息（这些信息会被封装到"SelectCourse"对象中，可能包含学生的学号、所选课程的具体信息以及对应的成绩等内容），并以"SelectCourse"对象组成的列表形式返回，然后将查询到的学生选课信息列表赋值给"scs"变量，方便后续对这些查询结果进行进一步的处理和展示。
+
         for (int i = 0; i < scs.size(); i++) {
             System.out.println(scs.get(i));
         }
+        // 使用循环遍历查询到的学生选课信息列表（scs），通过调用"scs.get(i)"方法获取列表中的每一个"SelectCourse"对象，并将其输出打印到控制台。同样，这一步大概率也是出于调试目的，方便开发人员查看查询出来的每一条选课信息是否准确完整，例如查看学生的信息、课程信息以及成绩等是否符合预期，有助于在出现数据问题时排查是查询逻辑错误还是数据源本身数据有误等情况，进一步辅助定位和解决问题。
 
         request.setAttribute("scs", scs);
-        request.getRequestDispatcher("/WEB-INF/teacher/findSelectCourseListByCourseId.jsp").forward(request,response);
+        // 使用"request"对象的"setAttribute"方法，将查询到的学生选课信息列表（scs）保存到请求对象中，设置的属性名为"scs"，这样在后续将请求转发到JSP页面等操作时，在目标JSP页面中就可以通过这个属性名（"scs"）来获取到该选课信息列表，进而可以在页面中进行数据展示等相关操作，例如通过JSP的标签或者脚本语言将这些选课信息以表格等形式展示给用户查看。
 
+        request.getRequestDispatcher("/WEB-INF/teacher/findSelectCourseListByCourseId.jsp").forward(request, response);
+        // 获取一个请求转发器，将当前请求转发到"/WEB-INF/teacher/findSelectCourseListByCourseId.jsp"这个JSP页面（通常该JSP页面会用于展示查询到的学生选课及成绩信息等相关内容，可能会通过循环遍历获取到的选课信息列表，然后将学生的学号、课程名、成绩等信息以合适的HTML元素展示出来）。这样服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面经过渲染后的内容，整个过程对于客户端来说就像是一次完整的请求响应过程，客户端浏览器地址栏中的URL并不会发生改变，通过这种转发机制可以顺利地进行后续的页面展示操作，将查询到的学生课程成绩等信息呈现给用户查看。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写了"HttpServlet"类中的"doGet"方法，此方法主要用于处理HTTP GET请求，例如当客户端通过在浏览器地址栏直接输入URL或者点击链接等方式（通常这些情况会发起GET请求）访问此Servlet对应的路径时，Web容器会调用这个方法来处理相应的请求。
+
         doPost(request, response);
+        // 在"doGet"方法中直接调用了"doPost"方法，这意味着对于GET请求的处理逻辑和POST请求的处理逻辑是完全一样的，也就是不管客户端是通过POST方式还是GET方式访问这个Servlet对应的路径，都会按照"doPost"方法里所定义的逻辑去进行相应的处理，比如获取课程编号、查询选课信息、输出调试信息以及转发请求到JSP页面等操作都会同样执行，这样做可能是在业务逻辑上对于这两种请求方式获取和展示学生课程成绩信息的要求是一致的，所以进行了这样的复用处理。
     }
 }

src/web/servlet/teacher/TeacherInfomationServlet.java

@@ -1,6 +1,8 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，利用包结构来对类进行分类组织，使项目代码结构更清晰，便于区分不同功能模块对应的代码。
 
 import domain.Teacher;
+// 导入领域模型类Teacher，这个类通常用于封装教师相关的各种属性（比如教师编号、姓名、所属院系等信息）以及可能的业务逻辑方法（如果有定义的话），在这里虽然暂时看不出具体使用情况，但可能后续会涉及到和教师信息相关的操作。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -9,14 +11,32 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及应对可能出现的异常情况。
+// ServletException用于处理Servlet执行过程中出现的异常，像业务逻辑执行出错、配置错误等引发的异常都会通过它来处理。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并且可以配置这个Servlet对应的访问路径等属性，方便Web容器（如Tomcat等服务器）识别并进行管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，开发人员可以通过重写它里面的方法来实现具体的业务逻辑，以应对不同类型的HTTP请求（如GET、POST等）。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，例如请求参数、请求头信息等，是后续在Servlet中处理请求数据的重要依据。
+// HttpServletResponse用于向客户端发送HTTP响应，比如设置响应状态码、响应头以及返回响应内容等，以此构建完整的返回给客户端的信息。
+// HttpSession用于在服务器端管理用户会话信息，通过它能够实现在不同请求之间共享数据，不过在这段代码里暂时没有明显体现出对会话信息的使用场景。
+// IOException用于处理输入输出相关的异常，像读写文件、网络传输等出现问题时会抛出该异常。
 
 @WebServlet("/teacherInfomationServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为"/teacherInfomationServlet"。当客户端通过这个特定的URL路径发起HTTP请求时，Web容器（如Tomcat服务器）就会找到并调用这个Servlet来处理请求。
 public class TeacherInfomationServlet extends HttpServlet {
+    // 定义了一个名为TeacherInfomationServlet的类，它继承自HttpServlet类，这意味着这个类是一个用于处理HTTP请求的Servlet，借助继承HttpServlet类的特性，可以方便地重写其中的方法来实现具体的业务逻辑，在这里主要用于实现和教师信息相关的某种业务逻辑（从转发的JSP页面推测可能是展示教师信息之类的功能）。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，该方法主要用于处理HTTP POST请求。当客户端通过POST方式（比如表单提交等情况常用POST方式向服务器发送数据）访问此Servlet对应的"/teacherInfomationServlet"这个URL路径时，Web容器会自动调用这个方法来处理相应的请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则是用于向客户端返回响应信息的对象。
+
         request.getRequestDispatcher("/WEB-INF/teacher/tInformation.jsp").forward(request, response);
+        // 获取一个请求转发器，将当前请求转发到"/WEB-INF/teacher/tInformation.jsp"这个JSP页面。通常这个JSP页面会用于展示教师相关的信息（比如教师的个人基本信息、授课情况等，具体取决于页面的实现）。这样服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面经过渲染后的内容，整个过程对客户端来说就像是一次完整的请求响应过程，客户端浏览器地址栏中的URL并不会发生改变，通过转发请求可以进行后续的页面展示等业务操作，实现向用户展示教师信息的功能。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，该方法主要用于处理HTTP GET请求，例如当客户端通过在浏览器地址栏直接输入URL或者点击链接等方式（这些情况通常会发起GET请求）访问此Servlet对应的路径时，Web容器会调用这个方法来处理相应的请求。
+
         doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，这意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即不管客户端是通过POST方式还是GET方式访问这个Servlet对应的路径，都会按照doPost方法里所定义的逻辑去进行相应的处理，也就是都会将请求转发到"/WEB-INF/teacher/tInformation.jsp"这个JSP页面进行后续处理，可能是因为在业务逻辑上对于这两种请求方式展示教师信息的操作是相同的，所以进行了这样的复用处理。
     }
 }

src/web/servlet/teacher/TeacherListServlet.java

@@ -1,4 +1,5 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，通过包名对类进行分类管理，有助于在项目中清晰地组织代码结构，方便区分不同功能模块对应的类。
 
 import domain.Admin;
 import domain.Student;
@@ -7,6 +8,14 @@ import service.StudentService;
 import service.TeacherService;
 import service.impl.StudentServiceImpl;
 import service.impl.TeacherServiceImpl;
+// 导入不同领域模型类以及相关的服务接口和实现类。
+// domain.Admin：通常用于封装管理员相关的属性和业务逻辑，代表了系统中管理员这一角色对应的实体信息。
+// domain.Student：用于封装学生相关的属性和业务逻辑，包含学生的学号、姓名等各种信息，是对学生这一业务实体在代码中的体现。
+// domain.Teacher：类似地，用于封装教师相关的属性和业务逻辑，比如教师的工号、姓名、授课信息等内容，代表教师这一业务实体。
+// service.StudentService：定义了针对学生业务操作的服务接口，规定了可以进行的各种学生相关业务方法，例如查询学生信息、添加学生等操作的抽象方法声明。
+// service.TeacherService：是针对教师业务操作的服务接口，明确了如查询教师信息、更新教师资料等相关业务操作的接口方法。
+// service.impl.StudentServiceImpl：是StudentService接口的具体实现类，里面包含了与数据库或其他数据源交互来实际完成学生业务逻辑的代码，比如具体的查询所有学生信息、根据学号查询某个学生等操作的实现就在这个类里。
+// service.impl.TeacherServiceImpl：同样，是TeacherService接口的具体实现类，负责实现教师业务相关操作的具体代码逻辑，像这里要调用的查询所有教师信息的方法就在这个类中实现。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -16,33 +25,73 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及可能出现的异常情况，同时导入用于处理集合数据和会话相关操作的类。
+// ServletException用于处理Servlet执行过程中出现的异常情况，例如业务逻辑执行出错、配置错误等引发的异常都会通过它来处理。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性，方便Web容器（如Tomcat等服务器）识别并进行管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，开发人员可以通过重写它里面的方法来实现具体的业务逻辑，以应对不同类型的HTTP请求（如GET、POST等）。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，像请求参数、请求头信息等，是后续处理请求数据的重要依据。
+// HttpServletResponse用于向客户端发送HTTP响应，例如设置响应状态码、响应头以及返回响应内容等，用于构建返回给客户端的信息。
+// HttpSession用于在服务器端管理用户会话信息，通过它可以在不同的请求之间共享数据，比如保存用户的登录状态、用户相关的一些临时数据等，在这里用于判断当前登录用户的角色类型。
+// IOException用于处理输入输出相关的异常，像读写文件、网络传输等出现问题时会抛出该异常。
+// List是Java集合框架中的接口，表示一个有序的、可重复元素的集合，这里用于存放查询出来的教师信息列表（多个Teacher对象组成的列表）。
 
 @WebServlet("/teacherListServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为"/teacherListServlet"。当客户端通过这个URL路径发起HTTP请求时，Web容器（如Tomcat等）就会找到并调用这个Servlet来处理请求。
 public class TeacherListServlet extends HttpServlet {
+    // 定义一个名为TeacherListServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等），以实现具体的业务逻辑，这里主要是实现查询教师列表并根据不同用户角色进行页面转发的业务逻辑。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式访问此Servlet对应的URL路径时，容器会调用这个方法来处理请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则用于向客户端返回响应信息。
+
         // 调用TeacherService完成查询
         TeacherService teacherService = new TeacherServiceImpl();
+        // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量teacherService。这样后续就可以调用TeacherService接口中定义的业务方法，而具体的查询所有教师信息的操作实现则由TeacherServiceImpl类来完成。
+
         List<Teacher> teachers = teacherService.findAll();
+        // 调用teacherService（实际是TeacherServiceImpl的实例）的findAll方法，该方法应该是从数据库或其他存储教师信息的数据源中，查询出所有教师的信息，并以Teacher对象的列表形式返回，将查询到的教师信息列表赋值给teachers变量，以便后续使用这些数据进行页面展示等操作。
+
         // 将list存入request域
         request.setAttribute("teachers", teachers);
+        // 使用request对象的setAttribute方法，将查询到的教师信息列表（teachers）保存到请求对象中，设置的属性名为"teachers"，这样在后续转发请求到JSP页面等操作时，在目标页面中就可以通过这个属性名获取到该教师信息列表，用于展示教师信息的相关操作，比如在JSP页面中通过循环遍历列表展示每个教师的具体信息。
 
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，确保从客户端接收到的请求参数等数据能够按照UTF-8编码格式正确解析，避免中文等特殊字符出现乱码问题，保证后续获取和处理请求数据的准确性，虽然在这里暂时没有明显体现出获取参数的操作，但这是一个良好的编码习惯，防止后续可能的扩展或者其他地方出现乱码情况。
+
         HttpSession session = request.getSession();
+        // 获取当前请求对应的HttpSession对象，如果不存在则创建一个新的会话对象。HttpSession用于在服务器端管理用户的会话信息，在这里主要是为了获取会话中保存的当前登录用户的相关信息，以此来判断用户的角色类型，进而决定转发到哪个合适的页面进行教师列表展示。
+
         Student student = (Student) session.getAttribute("student");
+        // 从HttpSession对象中尝试获取名为"student"的属性值，并将其强制转换为Student类型，该属性值通常是在用户登录成功后（如果是学生角色登录）保存到会话中的学生对象，通过这样的获取操作可以判断当前登录用户是否是学生角色。
+
         Admin admin = (Admin) session.getAttribute("admin");
+        // 类似地，从会话中获取名为"admin"的属性值并转换为Admin类型，用于判断当前登录用户是否是管理员角色，若获取到的admin对象不为null，则表示当前是管理员登录状态。
+
         Teacher teacher = (Teacher) session.getAttribute("teacher");
+        // 同样，从会话中获取名为"teacher"的属性值并转换为Teacher类型，用于判断当前登录用户是否是教师角色，若获取到的teacher对象不为null，则说明当前是教师登录状态。
+
         if (student!= null && admin == null && teacher == null) {
+            // 判断如果从会话中获取到的学生对象不为null，同时管理员对象和教师对象都为null，即当前登录用户是学生角色，那么执行以下逻辑。
             request.getRequestDispatcher("/WEB-INF/student/sFindTeacherList.jsp").forward(request, response);
+            // 获取一个请求转发器，将当前请求转发到"/WEB-INF/student/sFindTeacherList.jsp"这个JSP页面，该页面应该是专门为学生角色设计的用于展示教师列表信息的页面，服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面经过渲染后的内容，整个过程对客户端来说是一次完整的请求响应过程，客户端浏览器地址栏中的URL不会发生改变。
         } else if (admin!= null && student == null && teacher == null) {
+            // 如果管理员对象不为null，而学生对象和教师对象都为null，即当前登录用户是管理员角色，则执行以下转发操作。
             request.getRequestDispatcher("/WEB-INF/admin/aFindTeacherList.jsp").forward(request, response);
+            // 将请求转发到"/WEB-INF/admin/aFindTeacherList.jsp"这个JSP页面，这大概率是为管理员设计的用于展示教师列表的页面，方便管理员进行相应的管理操作等查看教师信息。
         } else if (teacher!= null && admin == null && student == null) {
+            // 若教师对象不为null，管理员对象和学生对象都为null，也就是当前登录用户是教师角色，执行如下转发操作。
             request.getRequestDispatcher("/WEB-INF/teacher/tFindTeacherList.jsp").forward(request, response);
+            // 把请求转发到"/WEB-INF/teacher/tFindTeacherList.jsp"这个JSP页面，此页面应该是适合教师查看教师列表信息的页面，可能会展示一些与教师自身相关视角下的教师信息内容。
         } else {
             request.getRequestDispatcher("error.jsp").forward(request, response);
+            // 如果以上几种判断条件都不满足，说明可能出现了不符合预期的会话状态或者用户角色情况，此时将请求转发到"error.jsp"页面，该页面通常用于展示错误信息，提示用户出现了未知的系统状态等问题。
         }
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求。
+
         this.doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即都会按照doPost方法中的逻辑进行处理，比如查询教师列表、判断用户角色以及根据角色转发请求到相应的JSP页面等操作。
     }
 }

src/web/servlet/teacher/TeacherOptionalCourseServlet.java

@@ -1,4 +1,5 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于“web.servlet.teacher”包下，通过包结构对类进行分类管理，使项目代码的组织结构更加清晰，便于区分不同功能模块对应的代码所在位置。
 
 import domain.Course;
 import domain.Student;
@@ -7,6 +8,14 @@ import service.StudentService;
 import service.TeacherService;
 import service.impl.StudentServiceImpl;
 import service.impl.TeacherServiceImpl;
+// 导入不同的领域模型类以及相关的服务接口与实现类，用于处理业务逻辑中涉及到的数据和操作。
+// domain.Course：通常用于封装课程相关的各种属性（例如课程编号、课程名称、课程学分等信息）以及可能的业务逻辑方法（如果有针对课程对象自身的操作需求），代表了业务领域里课程这一实体在代码中的体现。
+// domain.Student：用于封装学生相关的各种属性（如学号、姓名、班级等）以及对应的业务逻辑，是对学生这个业务实体在代码层面的抽象表示，不过在当前这个Servlet中，从代码逻辑来看对学生相关操作体现并不明显，可能只是整体项目结构中涉及到的相关领域类导入。
+// domain.Teacher：类似地，用于封装教师相关的所有属性（像教师编号、姓名、所在院系等信息）和业务逻辑，在这个Servlet里会用于获取当前登录教师的信息以及后续和教师相关的业务操作关联。
+// service.StudentService：定义了针对学生业务操作的服务接口，规定了可以进行的各种学生相关业务操作的抽象方法，例如查询学生信息、添加学生、修改学生资料等方法声明，虽然此处不一定直接使用，但可能是项目中整体服务层接口的一部分被引入进来。
+// service.TeacherService：是专门针对教师业务操作所定义的服务接口，明确了像查询教师授课课程、更新教师信息等与教师业务相关的各种操作方法，为后续调用具体业务逻辑提供统一的接口规范。
+// service.impl.StudentServiceImpl：是StudentService接口的具体实现类，里面包含了与数据库或其他数据源进行实际交互的代码，以此来真正完成StudentService接口中定义的那些学生业务逻辑操作，比如具体的从数据库查询学生信息、往数据库插入新学生记录等实现细节都在这个类里，不过在此Servlet中暂时未直接调用其方法。
+// service.impl.TeacherServiceImpl：同样，它是TeacherService接口的具体实现类，负责实现教师业务相关操作的具体代码逻辑，例如这里要调用的根据教师编号查询该教师可选课程的方法就在这个类中进行具体实现。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -16,25 +25,58 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及应对可能出现的异常情况，同时导入用于处理集合数据类型和会话相关操作的类。
+// ServletException：用于处理Servlet在执行过程中出现的各种异常情况，比如业务逻辑执行出错、配置错误、请求处理不符合预期等情况引发的异常都会通过这个类来处理，方便进行统一的异常管理和错误提示。
+// WebServlet：是一个注解类，通过它可以将一个普通的Java类标注为Servlet，并配置该Servlet对应的访问路径等相关属性，方便Web容器（像Tomcat等应用服务器）能够识别并对其进行合适的管理与调度，决定何时以及如何调用这个Servlet来处理客户端的请求。
+// HttpServlet：是所有基于HTTP协议的Servlet的基类，它提供了处理HTTP请求的基础架构和一系列默认的方法，开发人员通过重写它里面特定的方法（如doGet、doPost等）来实现具体的业务逻辑，以应对不同类型的HTTP请求。
+// HttpServletRequest：主要用于获取客户端发送过来的HTTP请求中包含的各种详细信息，例如通过相关方法获取请求参数（像表单提交的数据等）、请求头信息（如浏览器相关的一些标识、请求的一些元数据等）以及其他和请求相关的内容，是在Servlet中处理请求数据的关键入口。
+// HttpServletResponse：负责向客户端发送HTTP响应，包括设置响应的状态码（比如常见的200表示成功、404表示未找到资源等）、响应头（例如设置响应内容的类型、缓存控制相关的信息等）以及返回具体的响应内容（像HTML页面、JSON数据等），以此构建完整的返回给客户端的信息。
+// HttpSession：用于在服务器端管理用户的会话信息，通过它可以实现在不同的请求之间共享数据，比如保存用户的登录状态、用户相关的一些临时数据等，在这个Servlet里主要用于获取当前登录教师的对象信息，以判断登录状态以及后续基于教师身份进行相关业务操作。
+// IOException：用于处理输入输出相关的异常情况，例如在读取或写入文件、进行网络传输（像从数据库获取数据或者向客户端发送响应数据等涉及到数据传输的操作过程中）如果出现问题，就会抛出这个异常，方便进行相应的错误处理和恢复机制实现。
+// List：是Java集合框架中的接口，表示一个有序的、可包含重复元素的集合，在这里用于存放查询出来的课程相关信息（以Course对象的形式），方便后续对这些数据进行遍历、展示或者其他相关的业务处理操作。
 
 @WebServlet("/teacherOptionalCourseServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定这个Servlet对应的访问路径为“/teacherOptionalCourseServlet”。这意味着当客户端通过浏览器等工具向服务器发起的HTTP请求的URL路径为该指定路径时，Web容器（服务器端负责管理Servlet的环境，如Tomcat）就会找到并调用这个Servlet类来处理相应的请求。
 public class TeacherOptionalCourseServlet extends HttpServlet {
+    // 定义了一个名为TeacherOptionalCourseServlet的类，它继承自HttpServlet类，这表明该类是一个专门用于处理HTTP请求的Servlet，借助继承HttpServlet类的机制，可以方便地重写其中相应的方法（比如doGet、doPost等）来实现具体的、与业务相关的请求处理逻辑，在这个类中主要是实现与教师可选课程相关的业务逻辑，例如查询并展示教师能够选择教授的课程信息等。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写了HttpServlet类中的doPost方法，此方法专门用于处理HTTP POST请求。当客户端通过POST方式（例如表单提交等情况常用POST方式向服务器发送数据）访问此Servlet对应的“/teacherOptionalCourseServlet”这个URL路径时，Web容器会自动调用这个重写后的方法来处理相应的请求。
+        // 方法中的两个参数“request”和“response”分别代表客户端发送过来的请求信息以及用于向客户端返回响应信息的对象，它们在整个请求处理过程中起着关键作用，通过它们可以获取请求数据、设置响应内容等。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为“utf-8”，这是非常重要的一步操作，因为客户端发送过来的数据可能包含各种字符（特别是如果存在中文等非ASCII字符时），若不设置正确的编码，在获取请求参数等数据时可能会出现乱码问题，导致无法正确解析数据内容。通过将编码格式设置为“utf-8”，能确保后续从请求中获取到的参数等数据可以按照正确的编码规范进行解析，保障数据的准确性和完整性，在这里对于后续可能涉及到的各种参数获取以及业务操作都有重要意义。
+
         HttpSession session = request.getSession();
+        // 获取当前请求对应的HttpSession对象，如果不存在则创建一个新的会话对象。HttpSession在服务器端用于管理用户的会话信息，在这里主要是为了从会话中获取当前登录教师的相关信息，以此来确定登录状态以及进行后续基于教师身份的业务操作，例如获取教师编号来查询其可选课程等。
+
         Teacher t = (Teacher) session.getAttribute("teacher");
+        // 从HttpSession对象中尝试获取名为“teacher”的属性值，并将其强制转换为Teacher类型。通常情况下，在用户（这里指教师）登录成功后，会将教师对象保存到会话中，对应的属性名为“teacher”，通过这样的获取操作可以得到当前登录教师的对象信息，后续就能基于这个对象进行相关业务逻辑操作，比如获取教师编号去查询该教师可教授的课程等。
+
         if (t!= null) {
+            // 判断获取到的教师对象t是否不为null，即判断当前是否有教师登录，如果有教师登录，才执行下面的业务逻辑操作，若为null则可能表示没有合法登录的教师，就不会进行后续的课程查询和页面展示等操作。
+
             // 调用StudentService完成查询
             TeacherService service = new TeacherServiceImpl();
+            // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量“service”。这样做的好处是，代码后续调用TeacherService接口中定义的方法时，实际上执行的是TeacherServiceImpl类中对这些方法的具体实现代码，使得代码结构更加灵活，便于替换不同的实现方式或者进行单元测试等操作，在这里就是为了调用教师业务相关的方法来查询教师可选课程信息。
+
             List<Course> optionalcourses = service.findMySelfOptionalCourse(t.getT_id());
+            // 调用“service”（实际上就是TeacherServiceImpl的实例）的“findMySelfOptionalCourse”方法，将前面获取到的教师对象t的教师编号（通过t.getT_id()方法获取）作为参数传入进去。这个方法应该是在数据库或者其他存储课程信息的数据源中，依据传入的教师编号来查询出该教师能够选择教授的所有课程信息，并以Course对象组成的列表形式返回，然后将查询到的可选课程信息列表赋值给“optionalcourses”变量，方便后续对这些查询结果进行进一步的处理和展示操作，比如在页面上展示课程列表供教师查看选择等。
+
             // 将list存入request域
             request.setAttribute("optionalcourses", optionalcourses);
+            // 使用“request”对象的“setAttribute”方法，将查询到的可选课程信息列表（optionalcourses）保存到请求对象中，设置的属性名为“optionalcourses”，这样在后续将请求转发到JSP页面等操作时，在目标JSP页面中就可以通过这个属性名（“optionalcourses”）来获取到该课程列表信息，进而可以在页面中进行数据展示等相关操作，例如通过循环遍历课程列表，将每个课程的名称、编号等信息以合适的HTML元素展示出来给教师查看。
+
             // 转发到list.jsp
             request.getRequestDispatcher("/WEB-INF/teacher/teacherOptionalCourse.jsp").forward(request, response);
+            // 获取一个请求转发器，将当前请求转发到“/WEB-INF/teacher/teacherOptionalCourse.jsp”这个JSP页面（通常该JSP页面会用于展示教师可选课程的相关信息，可能会通过循环遍历获取到的课程列表，然后将课程名、课程编号、课程学分等信息以合适的方式展示出来，方便教师进行查看和后续操作）。这样服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面经过渲染后的内容，整个过程对于客户端来说就像是一次完整的请求响应过程，客户端浏览器地址栏中的URL并不会发生改变，通过这种转发机制可以顺利地进行后续的页面展示操作，将教师可选课程信息呈现给教师查看。
         }
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写了HttpServlet类中的doGet方法，此方法主要用于处理HTTP GET请求，例如当客户端通过在浏览器地址栏直接输入URL或者点击链接等方式（通常这些情况会发起GET请求）访问此Servlet对应的路径时，Web容器会调用这个方法来处理相应的请求。
+
         this.doPost(request, response);
+        // 在“doGet”方法中直接调用了“doPost”方法，这意味着对于GET请求的处理逻辑和POST请求的处理逻辑是完全一样的，也就是不管客户端是通过POST方式还是GET方式访问这个Servlet对应的路径，都会按照“doPost”方法里所定义的逻辑去进行相应的处理，比如设置请求编码、获取教师登录信息、查询教师可选课程、将课程列表保存到请求对象以及转发请求到JSP页面等操作都会同样执行，这样做可能是在业务逻辑上对于这两种请求方式获取和展示教师可选课程信息的要求是一致的，所以进行了这样的复用处理。
     }
 }

src/web/servlet/teacher/TeacherOptionalCourseUpdateServlet.java

@@ -1,9 +1,15 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，通过包来对类进行分类管理，使项目的代码结构更加清晰，便于区分不同功能模块对应的类。
 
 import domain.Course;
 import domain.Teacher;
 import service.TeacherService;
 import service.impl.TeacherServiceImpl;
+// 导入与课程（Course）、教师（Teacher）相关的领域模型类，以及教师业务逻辑对应的服务接口（TeacherService）和该接口的具体实现类（TeacherServiceImpl）。
+// domain.Course类通常用于封装课程相关的各种属性，比如课程编号、课程名称、课程介绍等信息，代表了业务领域中课程这一实体在代码中的体现，方便对课程数据进行操作和传递。
+// domain.Teacher类用于封装教师相关的属性和业务逻辑，虽然在此处可能没有直接对教师对象进行过多复杂操作，但在整个业务场景中可能与教师操作课程等相关联。
+// service.TeacherService接口定义了针对教师业务操作中与课程相关（此处主要涉及课程更新相关操作）的抽象方法，为具体业务逻辑的调用提供了统一的规范。
+// service.impl.TeacherServiceImpl类则是TeacherService接口的具体实现，包含了与数据库或其他数据源交互，来实际完成更新课程信息等业务逻辑的代码。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -13,41 +19,79 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.Date;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及可能出现的异常情况，同时导入用于处理日期格式化相关的类。
+// ServletException用于处理Servlet执行过程中出现的异常情况，例如业务逻辑执行出错、配置错误等引发的异常都会通过它来处理。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性，方便Web容器（如Tomcat等服务器）识别并进行管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，开发人员可以通过重写它里面的方法来实现具体的业务逻辑，以应对不同类型的HTTP请求（如GET、POST等）。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，像请求参数、请求头信息等，是后续处理请求数据的重要依据。
+// HttpServletResponse用于向客户端发送HTTP响应，例如设置响应状态码、响应头以及返回响应内容等，用于构建返回给客户端的信息。
+// HttpSession用于在服务器端管理用户会话信息，通过它可以在不同的请求之间共享数据，不过在这段代码里暂时没有明显体现出复杂的会话信息使用场景，可能只是用于后续扩展等情况。
+// IOException用于处理输入输出相关的异常，像读写文件、网络传输等出现问题时会抛出该异常。
+// Date类用于获取当前的日期和时间信息，在这里主要是用于在给用户的提示信息中添加操作时间，方便用户知晓操作完成的时间情况。
 
 @WebServlet("/teacherOptionalCourseUpdateServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为"/teacherOptionalCourseUpdateServlet"。当客户端通过这个URL路径发起HTTP请求时，Web容器（如Tomcat等）就会找到并调用这个Servlet来处理请求。
 public class TeacherOptionalCourseUpdateServlet extends HttpServlet {
+    // 定义一个名为TeacherOptionalCourseUpdateServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等），以实现具体的业务逻辑，这里主要是实现更新教师可选课程信息的业务逻辑。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式访问此Servlet对应的URL路径时，容器会调用这个方法来处理请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则用于向客户端返回响应信息。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，确保从客户端接收到的请求参数等数据能够按照UTF-8编码格式正确解析，避免中文等特殊字符出现乱码问题，保证后续获取和处理请求数据的准确性，特别是这里要获取课程相关参数，防止乱码很重要。
 
         String cid = request.getParameter("cid");
+        // 从客户端发送的HTTP请求中获取名为"cid"的参数值，按照业务逻辑推测，这个参数值通常代表要更新的课程的编号，将获取到的课程编号赋值给cid变量，以便后续根据这个编号进行课程信息更新等操作。
 
         // 保存输入内容
         String name = request.getParameter("course-name");
+        // 从请求中获取名为"course-name"的参数值，该值对应要更新的课程的名称信息，将其赋值给name变量，用于后续封装到课程对象中，以更新课程在数据库等数据源中的名称信息。
+
         String info = request.getParameter("course-info");
+        // 同样，从请求中获取名为"course-info"的参数值，这个值代表要更新的课程的详细介绍等相关信息，赋值给info变量，准备后续封装进课程对象，用于更新课程的详细信息。
 
         Course updateCourse = new Course();
+        // 创建一个Course类的实例updateCourse，用于封装要更新的课程的相关信息，后续会将从请求中获取到的课程编号、名称、详细信息等设置到这个对象中，再通过业务层方法将更新后的课程对象保存到数据库等数据源中。
 
         // 判断输入位数是否大于数据库位数
         if (cid.contains("<") || name.contains("<") || info.contains("<")) {
+            // 检查获取到的课程编号（cid）、课程名称（name）、课程信息（info）中是否包含字符"<"，这里可能是基于安全或数据格式的考虑，防止输入的内容不符合数据库字段存储要求或者存在潜在的安全风险（比如SQL注入攻击等情况，虽然简单的这种判断不能完全杜绝，但能做一定程度防范），如果包含则认为格式错误。
             request.setAttribute("update_msg", "格式错误，请重新提交！" + String.format("%tT", new Date()));
+            // 使用request对象的setAttribute方法设置一个名为"update_msg"的属性，属性值是提示用户格式错误的信息，并拼接上当前的时间（通过String.format结合%tT格式化Date对象，得到具体的时间格式字符串），方便用户知晓出现格式错误的时间情况以及提示重新提交。
             request.getRequestDispatcher("updateTeacherOptionalCourseServlet?cid=" + cid).forward(request, response);
+            // 获取一个请求转发器，将当前请求转发到"updateTeacherOptionalCourseServlet"这个资源（可能是另一个Servlet或者JSP页面等），同时带上获取到的课程编号cid作为参数（通过URL拼接的方式传递参数），这样服务器端会接着处理转发后的请求，并向客户端返回相应的响应内容，整个过程对客户端来说是一次完整的请求响应过程，地址栏中的URL会根据转发情况发生相应改变，转发后可以继续后续的页面展示或者重新输入等操作。
         } else {
-            //封装学生对象
+            // 封装学生对象（此处应为封装课程对象，可能是注释的小失误）
             updateCourse.setC_id(cid);
+            // 通过调用Course类的setC_id方法，将前面获取到的课程编号设置到updateCourse对象中，确保更新的课程具有正确的编号信息，与数据库中要更新的记录对应起来。
+
             updateCourse.setC_name(name);
+            // 将获取到的课程名称设置到updateCourse对象中，用于更新课程在数据库中的名称信息。
+
             updateCourse.setC_info(info);
+            // 把获取到的课程详细信息设置到updateCourse对象中，完成课程对象的信息封装，准备进行更新操作。
 
-            //调用studentUpdata服务
+            // 调用studentUpdata服务（此处应为调用TeacherService服务，可能是注释书写错误）
             TeacherService service = new TeacherServiceImpl();
+            // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量service。这样后续就可以调用TeacherService接口中定义的业务方法，而具体的更新课程信息的操作实现则由TeacherServiceImpl类来完成。
+
             service.updateCourseInfo(updateCourse);
+            // 调用service（实际是TeacherServiceImpl的实例）的updateCourseInfo方法，将封装好的包含更新后信息的课程对象updateCourse传入，该方法应该是在数据库或其他存储课程信息的数据源中，根据课程对象中的信息（编号、名称、详细信息等）来更新对应的课程记录，实现课程信息的更新业务逻辑操作。
 
             // 成功则返回并给提示
             request.setAttribute("update_msg", "修改成功！" + String.format("%tT", new Date()));
+            // 设置名为"update_msg"的属性，属性值为修改成功的提示信息，并拼接当前时间，方便用户知晓操作完成且成功的时间情况。
+
             request.getRequestDispatcher("updateTeacherOptionalCourseServlet?cid=" + cid).forward(request, response);
+            // 同样获取请求转发器，将请求转发到"updateTeacherOptionalCourseServlet"资源并带上课程编号cid作为参数，进行后续的页面展示或者其他相关业务处理，告知用户修改成功并可以进行后续查看等操作。
         }
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求。
+
         doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即都会按照doPost方法中的逻辑进行处理，比如获取课程相关参数、判断格式、封装课程对象、更新课程信息以及转发请求等操作。
     }
 }

src/web/servlet/teacher/TeacherPasswordIndexServlet.java

@@ -1,4 +1,5 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于“web.servlet.teacher”包下，通过包名对类进行分类管理，有助于在项目中清晰地组织代码结构，方便区分不同功能模块对应的类。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -6,14 +7,31 @@ import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及可能出现的异常情况。
+// ServletException用于处理Servlet执行过程中出现的异常情况，例如业务逻辑执行出错、配置错误等引发的异常都会通过它来处理。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性，方便Web容器（如Tomcat等服务器）识别并进行管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，开发人员可以通过重写它里面的方法来实现具体的业务逻辑，以应对不同类型的HTTP请求（如GET、POST等）。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，像请求参数、请求头信息等，是后续处理请求数据的重要依据。
+// HttpServletResponse用于向客户端发送HTTP响应，例如设置响应状态码、响应头以及返回响应内容等，用于构建返回给客户端的信息。
+// IOException用于处理输入输出相关的异常，像读写文件、网络传输等出现问题时会抛出该异常。
 
 @WebServlet("/teacherPasswordIndexServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为“/teacherPasswordIndexServlet”。当客户端通过这个URL路径发起HTTP请求时，Web容器（如Tomcat等）就会找到并调用这个Servlet来处理请求。
 public class TeacherPasswordIndexServlet extends HttpServlet {
+    // 定义一个名为TeacherPasswordIndexServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等），以实现具体的业务逻辑，这里主要是实现与教师更新密码相关的页面跳转逻辑（从转发的JSP页面推测）。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式（比如表单提交等情况常用POST方式向服务器发送数据）访问此Servlet对应的“/teacherPasswordIndexServlet”这个URL路径时，Web容器会自动调用这个方法来处理相应的请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则是用于向客户端返回响应信息的对象。
+
         request.getRequestDispatcher("/WEB-INF/teacher/teacherUpdatePassword.jsp").forward(request, response);
+        // 获取一个请求转发器，将当前请求转发到“/WEB-INF/teacher/teacherUpdatePassword.jsp”这个JSP页面。通常这个JSP页面会用于展示教师更新密码的相关表单等内容，例如输入旧密码、新密码的输入框等，方便教师进行密码更新操作。这样服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面经过渲染后的内容，整个过程对客户端来说是一次完整的请求响应过程，客户端浏览器地址栏中的URL并不会发生改变，通过转发请求可以进行后续的页面展示等业务操作，引导教师进入密码更新页面。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，该方法主要用于处理HTTP GET请求，例如当客户端通过在浏览器地址栏直接输入URL或者点击链接等方式（这些情况通常会发起GET请求）访问此Servlet对应的路径时，Web容器会调用这个方法来处理相应的请求。
+
         doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，这意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即不管客户端是通过POST方式还是GET方式访问这个Servlet对应的路径，都会按照doPost方法里所定义的逻辑去进行相应的处理，也就是都会将请求转发到“/WEB-INF/teacher/teacherUpdatePassword.jsp”这个JSP页面进行后续处理，可能是因为在业务逻辑上对于这两种请求方式进入教师密码更新页面的操作是相同的，所以进行了这样的复用处理。
     }
 }

src/web/servlet/teacher/TeacherPasswordUpdateServlet.java

@@ -1,11 +1,19 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，通过包结构对类进行分类管理，使项目代码更有条理，便于区分不同功能模块对应的代码。
 
 import domain.Student;
 import domain.Teacher;
+// 导入领域模型类Student和Teacher，Student类通常用于封装学生相关的属性（如学号、姓名、班级等）和业务逻辑，Teacher类用于封装教师相关的属性（如教师编号、姓名、所在院系等）以及业务逻辑，虽然此处主要围绕教师密码更新操作，但可能是整体项目结构中涉及到相关领域类的统一导入。
+
 import service.StudentService;
 import service.TeacherService;
 import service.impl.StudentServiceImpl;
 import service.impl.TeacherServiceImpl;
+// 导入学生和教师相关业务逻辑的服务接口及对应的具体实现类。
+// StudentService定义了针对学生业务操作的抽象方法，例如查询学生信息、更新学生资料等相关操作的接口声明。
+// TeacherService是针对教师业务操作的服务接口，明确了如更新教师密码、查询教师信息等与教师业务相关的各种操作方法。
+// StudentServiceImpl是StudentService接口的具体实现类，包含了与数据库或其他数据源交互来实际完成学生业务逻辑的代码，不过在此处主要处理教师业务逻辑，该类暂时未直接使用。
+// TeacherServiceImpl则是TeacherService接口的具体实现类，负责实现教师业务相关操作的具体代码逻辑，像更新教师密码、根据教师编号查询教师等操作的具体实现就在这个类中。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -15,41 +23,91 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.Date;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及应对可能出现的异常情况，同时导入用于获取当前日期时间信息的Date类，用于在提示信息中添加时间戳等操作。
+// ServletException用于处理Servlet执行过程中出现的异常情况，像业务逻辑执行出错、配置错误等引发的异常都会通过它来处理。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性，方便Web容器（如Tomcat等服务器）识别并进行管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，开发人员通过重写它里面的方法来实现具体的业务逻辑，以应对不同类型的HTTP请求（如GET、POST等）。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，例如请求参数（像表单提交的数据等）、请求头信息等，是后续处理请求数据的重要依据。
+// HttpServletResponse用于向客户端发送HTTP响应，比如设置响应状态码、响应头以及返回响应内容等，以此构建完整的返回给客户端的信息。
+// HttpSession用于在服务器端管理用户会话信息，通过它可以在不同的请求之间共享数据，在这里主要用于获取当前登录教师的信息以及更新登录教师信息后重新保存到会话中，保持登录状态等操作。
+// IOException用于处理输入输出相关的异常，像读写文件、网络传输等出现问题时会抛出该异常。
+// Date类用于获取当前的日期和时间，方便在给用户反馈的提示信息中添加具体的操作时间，让用户知晓操作完成的时间情况。
 
 @WebServlet("/teacherPasswordUpdateServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为"/teacherPasswordUpdateServlet"。当客户端通过这个URL路径发起HTTP请求时，Web容器（如Tomcat等）就会找到并调用这个Servlet来处理请求。
 public class TeacherPasswordUpdateServlet extends HttpServlet {
-    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+    // 定义一个名为TeacherPasswordUpdateServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等），以实现具体的业务逻辑，这里主要是实现教师更新密码的相关业务逻辑。
+
+    protected void doPost(HttpServletRequest request, HttpServletRequest response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式（例如通过表单提交密码修改相关信息等情况常用POST方式向服务器发送数据）访问此Servlet对应的"/teacherPasswordUpdateServlet"这个URL路径时，Web容器会自动调用这个方法来处理相应的请求。
+        // 方法中的两个参数request和response分别用于获取客户端发送过来的所有请求信息以及向客户端返回响应信息。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，确保从客户端接收到的请求参数等数据能够按照UTF-8编码格式正确解析，避免中文等特殊字符出现乱码问题，保证后续获取和处理请求数据的准确性，特别是在获取新密码等文本信息时防止乱码很关键。
+
         HttpSession session = request.getSession();
+        // 获取当前请求对应的HttpSession对象，如果不存在则创建一个新的会话对象。HttpSession在服务器端用于管理用户的会话信息，在这里主要是为了获取当前登录教师的对象信息，以便后续基于该教师信息进行密码更新等相关操作。
+
         Teacher teacher = (Teacher) session.getAttribute("teacher");
+        // 从HttpSession对象中尝试获取名为"teacher"的属性值，并将其强制转换为Teacher类型。通常在教师登录成功后，会将教师对象保存到会话中，对应的属性名为"teacher"，通过这样的获取操作就能得到当前登录教师的对象实例，后续利用这个对象来获取教师编号等信息进行密码更新操作。
 
         String teacherid = teacher.getT_id();
+        // 通过调用Teacher类的getT_id方法，从获取到的教师对象teacher中获取教师编号信息，并赋值给teacherid变量，该教师编号将作为后续更新密码操作时识别具体教师记录的重要依据，用于准确更新对应教师的密码。
+
         String newpassword = request.getParameter("teacher-newpassword");
+        // 从客户端发送的HTTP请求中获取名为"teacher-newpassword"的参数值，这个参数值代表教师输入的新密码信息，将其赋值给newpassword变量，用于后续对新密码格式的验证以及实际的密码更新操作。
+
         String ennewpassword = request.getParameter("teacher-ennewpassword");
+        // 同样，从请求中获取名为"teacher-ennewpassword"的参数值，该值对应教师再次输入用于确认的新密码信息，赋值给ennewpassword变量，后续会将其和前面获取的新密码进行比对，以确保两次输入的密码一致。
+
         String regex = "^[\\w]{3,12}$";
+        // 定义一个正则表达式字符串regex，用于验证密码格式是否符合要求。这里的正则表达式表示密码必须由3到12位的字母、数字或下划线组成，用于限制用户输入的新密码格式在合理范围内，提高安全性。
+
         boolean flag = newpassword.matches(regex);
+        // 使用String类的matches方法，将获取到的新密码newpassword与定义好的正则表达式regex进行匹配，返回的结果（true或false）赋值给flag变量，用于判断新密码的格式是否正确。
+
         if (!flag) {
+            // 如果flag为false，即新密码格式不符合定义的正则表达式要求，说明密码格式错误。
             request.setAttribute("update_msg", "密码格式错误，重新提交！" + String.format("%tT", new Date()));
+            // 使用request对象的setAttribute方法设置一个名为"update_msg"的属性，属性值是提示用户密码格式错误并告知需要重新提交的信息，同时通过String.format结合%tT格式化Date对象，将当前的时间信息添加到提示信息中，方便用户知晓出现格式错误的时间情况以及提示重新操作。
             request.getRequestDispatcher("/WEB-INF/teacher/teacherUpdatePassword.jsp").forward(request, response);
+            // 获取一个请求转发器，将当前请求转发到"/WEB-INF/teacher/teacherUpdatePassword.jsp"这个JSP页面，通常该页面是用于展示教师更新密码的表单界面，这样服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面经过渲染后的内容，整个过程对客户端来说是一次完整的请求响应过程，客户端浏览器地址栏中的URL并不会发生改变，通过转发请求可以引导用户回到密码更新页面重新输入密码。
         } else if (!newpassword.equals(ennewpassword)) {
+            // 如果新密码格式正确，但是新密码和确认密码不一致（通过equals方法进行比对），则执行以下逻辑。
             request.setAttribute("update_msg", "密码确认错误，请重新提交！" + String.format("%tT", new Date()));
+            // 同样使用request对象的setAttribute方法设置"update_msg"属性，属性值为提示用户密码确认错误并需要重新提交的信息，同时添加当前时间信息，告知用户操作时间以及重新操作的提示。
             request.getRequestDispatcher("/WEB-INF/teacher/teacherUpdatePassword.jsp").forward(request, response);
+            // 将请求转发到"/WEB-INF/teacher/teacherUpdatePassword.jsp"页面，让用户回到密码更新页面重新进行密码输入和确认操作。
         } else {
+            // 如果新密码格式正确且两次输入的密码一致，执行以下密码更新及后续相关操作。
 
             TeacherService service = new TeacherServiceImpl();
+            // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量service，这样后续就可以调用TeacherService接口中定义的业务方法，而具体的更新教师密码的操作实现则由TeacherServiceImpl类来完成。
+
             service.updatePassword(teacherid, newpassword);
+            // 调用service（实际是TeacherServiceImpl的实例）的updatePassword方法，传入前面获取到的教师编号teacherid和新密码newpassword作为参数，该方法应该是在数据库或其他存储教师信息的数据源中，根据教师编号找到对应的教师记录，并将密码更新为新密码，实现教师密码的更新业务逻辑操作。
 
             Teacher newTeacher = service.findTeacherById(teacher);
+            // 调用service的findTeacherById方法，传入之前获取到的原教师对象teacher，该方法应该是根据教师对象中的相关标识信息（可能是教师编号等）去数据库等数据源中查询对应的教师记录，并返回更新后的教师对象（因为密码已经更新了，可能数据库中返回的教师对象包含最新的信息，比如更新时间等也会更新），将查询到的更新后的教师对象赋值给newTeacher变量。
+
             teacher = newTeacher;
+            // 将更新后的教师对象newTeacher赋值给原来的教师对象teacher，这样可以保证当前代码中使用的教师对象是最新的信息，比如后续如果还有基于教师对象进行的其他操作（虽然这里暂时未体现更多后续操作），就是基于更新后的教师信息了。
+
             session.setAttribute("teacher", teacher);
+            // 使用HttpSession对象的setAttribute方法，将更新后的教师对象teacher重新保存到会话中，覆盖原来会话中保存的教师对象，这样可以保证会话中保存的教师信息是最新的，例如保持登录状态等相关信息基于最新的教师数据，避免因为密码更新导致登录相关的一些验证等出现问题。
 
             request.setAttribute("update_msg", "修改成功！" + String.format("%tT", new Date()));
+            // 设置名为"update_msg"的属性，属性值为提示用户密码修改成功的信息，并通过格式化添加当前时间信息，让用户知晓操作完成且成功的时间情况。
+
             request.getRequestDispatcher("/WEB-INF/teacher/teacherUpdatePassword.jsp").forward(request, response);
+            // 再次获取请求转发器，将请求转发到"/WEB-INF/teacher/teacherUpdatePassword.jsp"这个JSP页面，可能是为了在页面上展示修改成功的提示信息，让用户知晓密码已经成功更新，或者可以继续进行其他相关操作（比如可能有刷新页面重新登录等后续引导操作，虽然这里代码未体现更多相关后续逻辑），整个过程对客户端来说是一次完整的请求响应过程，客户端浏览器地址栏中的URL不会发生改变。
         }
-
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求，例如当客户端通过在浏览器地址栏直接输入URL或者点击链接等方式（通常这些情况会发起GET请求）访问此Servlet对应的路径时，Web容器会调用这个方法来处理相应的请求。
+
         doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即不管客户端是通过POST方式还是GET方式访问这个Servlet对应的路径，都会按照doPost方法里所定义的逻辑去进行相应的处理，比如获取教师信息、验证密码格式、更新密码以及转发请求到JSP页面等操作都会同样执行，这样做可能是在业务逻辑上对于这两种请求方式更新教师密码的操作要求是一致的，所以进行了这样的复用处理。
     }
 }

src/web/servlet/teacher/UpdateOptionalCourseScoreServlet.java

@@ -1,15 +1,29 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，通过包结构对类进行分类管理，使项目代码更有条理，便于区分不同功能模块对应的代码。
 
 import domain.Course;
 import domain.SelectCourse;
 import domain.Student;
 import domain.Teacher;
+// 导入不同的领域模型类，这些类通常用于封装业务相关实体的属性和业务逻辑（如果有定义）。
+// domain.Course类用于封装课程相关的各种属性，比如课程编号、课程名称、学分等信息，代表了业务领域里课程这一实体在代码中的体现，方便后续对课程相关数据进行操作和传递。
+// domain.SelectCourse类大概率是用于封装学生选课相关的信息，例如学生所选课程的对应关系、选课时间以及可能的成绩等信息，体现了学生选课这一业务概念在代码层面的抽象。
+// domain.Student类用于封装学生相关的属性（像学号、姓名、班级等）以及对应的业务逻辑，是对学生这个业务实体在代码层面的表示，会在后续涉及学生信息查询等操作中用到。
+// domain.Teacher类用于封装教师相关的属性（如教师编号、姓名、所在院系等）以及业务逻辑，虽然在此处当前的主要操作围绕课程分数修改，教师相关体现不多，但可能是整体项目结构中相关领域类的统一引入。
+
 import service.CourseService;
 import service.SelectCourseService;
 import service.StudentService;
 import service.impl.CourseServiceImpl;
 import service.impl.SelectCourseServiceImpl;
 import service.impl.StudentServiceImpl;
+// 导入不同业务逻辑对应的服务接口以及它们的具体实现类，用于实现具体的业务操作功能。
+// service.CourseService接口定义了针对课程业务操作的抽象方法，例如查询课程信息、更新课程相关属性等操作的方法声明，为课程相关业务逻辑调用提供统一规范。
+// service.SelectCourseService接口明确了与学生选课业务相关的操作方法，比如根据课程和学生信息查询选课记录、更新选课成绩等相关业务逻辑的抽象方法定义。
+// service.StudentService接口规定了针对学生业务操作的各种方法，像查询学生信息、更新学生资料等相关操作的接口声明，便于后续调用相关学生业务功能。
+// service.impl.CourseServiceImpl是CourseService接口的具体实现类，里面包含了与数据库或其他数据源交互来实际完成课程业务逻辑的代码，例如实现从数据库查询、更新课程信息等具体功能的代码就在这个类里。
+// service.impl.SelectCourseServiceImpl是SelectCourseService接口的具体实现类，负责实现学生选课业务相关操作的具体代码逻辑，像根据特定条件更新选课成绩等操作就在此实现。
+// service.impl.StudentServiceImpl则是StudentService接口的具体实现类，包含了实现学生业务相关操作的具体代码，比如按照学号等条件查询学生信息的代码逻辑就在这个类中。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -19,36 +33,84 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.Date;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及应对可能出现的异常情况，同时导入用于获取当前日期时间信息的Date类，方便在提示信息中添加操作时间等。
+// ServletException用于处理Servlet执行过程中出现的异常情况，例如业务逻辑执行出错、配置错误等引发的异常都会通过它来处理。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性，方便Web容器（如Tomcat等服务器）识别并进行管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，开发人员通过重写它里面的方法来实现具体的业务逻辑，以应对不同类型的HTTP请求（如GET、POST等）。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，例如请求参数（像表单提交的数据等）、请求头信息等，是后续处理请求数据的重要依据。
+// HttpServletResponse用于向客户端发送HTTP响应，比如设置响应状态码、响应头以及返回响应内容等，以此构建完整的返回给客户端的信息。
+// HttpSession用于在服务器端管理用户会话信息，通过它可以在不同的请求之间共享数据，不过在这段代码里暂时没有明显体现出复杂的会话信息使用场景，可能只是整体项目框架下相关类的引入。
+// IOException用于处理输入输出相关的异常，像读写文件、网络传输等出现问题时会抛出该异常。
+// Date类用于获取当前的日期和时间，在这里主要是用于在给用户反馈的提示信息中添加具体的时间戳，让用户知晓分数修改操作完成的时间情况。
 
 @WebServlet("/updateOptionalCourseScoreServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为"/updateOptionalCourseScoreServlet"。当客户端通过这个URL路径发起HTTP请求时，Web容器（如Tomcat等）就会找到并调用这个Servlet来处理请求。
 public class UpdateOptionalCourseScoreServlet extends HttpServlet {
+    // 定义一个名为UpdateOptionalCourseScoreServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等），以实现具体的业务逻辑，这里主要是实现更新选修课程成绩的相关业务逻辑。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式（比如通过表单提交修改课程分数相关信息等情况常用POST方式向服务器发送数据）访问此Servlet对应的"/updateOptionalCourseScoreServlet"这个URL路径时，Web容器会自动调用这个方法来处理相应的请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则是用于向客户端返回响应信息的对象。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，确保从客户端接收到的请求参数等数据能够按照UTF-8编码格式正确解析，避免中文等特殊字符出现乱码问题，保证后续获取和处理请求数据的准确性，特别是在获取课程编号、学生学号、成绩等文本信息时防止乱码很关键。
 
         String cid = request.getParameter("cid");
+        // 从客户端发送的HTTP请求中获取名为"cid"的参数值，按照业务逻辑推测，这个参数值通常代表要修改成绩的选修课程的编号，将获取到的课程编号赋值给cid变量，以便后续根据这个编号进行相关的课程成绩更新以及查询操作。
+
         String sid = request.getParameter("sid");
+        // 同样，从请求中获取名为"sid"的参数值，该值对应要修改成绩的学生的学号信息，赋值给sid变量，后续会基于这个学号来查找对应的学生信息以及关联的选课记录等，用于准确更新该学生对应课程的成绩。
+
         String sScore = request.getParameter("student-score");
+        // 从请求中获取名为"student-score"的参数值，这个值就是要更新的学生在选修课程上的成绩信息，赋值给sScore变量，准备用于后续的成绩更新操作。
+
         StudentService service = new StudentServiceImpl();
+        // 创建一个StudentServiceImpl类的实例，通过多态的方式将其赋值给StudentService接口类型的变量service，这样后续就可以调用StudentService接口中定义的业务方法，而具体的查询学生信息等操作的实现则由StudentServiceImpl类来完成，在这里是为了后续查找对应学号的学生信息做准备。
+
         CourseService service1 = new CourseServiceImpl();
+        // 创建一个CourseServiceImpl类的实例，赋值给CourseService接口类型的变量service1，方便后续调用CourseService接口里定义的业务方法，像查询课程相关信息等操作就可以通过这个变量来调用具体实现类的方法，这里是为了获取对应课程信息做准备。
+
         SelectCourseService service2 = new SelectCourseServiceImpl();
+        // 创建一个SelectCourseServiceImpl类的实例，赋值给SelectCourseService接口类型的变量service2，以便后续调用SelectCourseService接口中定义的业务方法，例如根据课程编号和学生学号更新选课成绩、查询选课相关记录等操作都可以通过这个变量来调用具体实现类的方法，这里先是用于更新成绩操作。
 
         service2.upDateScoreByCidAndSid(cid, sid, sScore);
+        // 调用service2（实际是SelectCourseServiceImpl的实例）的upDateScoreByCidAndSid方法，传入前面获取到的课程编号cid、学生学号sid以及要更新的成绩sScore作为参数，该方法应该是在数据库或其他存储选课信息的数据源中，根据课程编号和学生学号找到对应的选课记录，并将成绩更新为传入的新成绩，实现选修课程成绩的更新业务逻辑操作。
 
         Student student = new Student();
+        // 创建一个Student类的实例student，用于封装学生相关信息，准备后续根据学号查询完整的学生信息，虽然这里只是简单创建一个新对象，后续会设置学号等关键信息去查询数据库中的对应学生记录。
+
         student.setS_id(sid);
+        // 通过调用Student类的setS_id方法，将前面获取到的学生学号sid设置到student对象中，使得这个对象可以携带准确的学号信息去进行后续的查询操作，确保查询的是对应学号的学生信息。
 
         Student s = service.findStudentById(student);
+        // 调用service（即StudentServiceImpl的实例）的findStudentById方法，传入封装了学号信息的student对象，该方法会依据学生学号去数据库等数据源中查询对应的学生信息，并返回完整的学生对象（包含学号、姓名、班级等各种信息），将查询到的学生对象赋值给s变量，方便后续在页面展示或者其他相关业务操作中使用该学生的详细信息。
+
         Course c = service1.findSelectCourseByCourseId(cid);
+        // 调用service1（即CourseServiceImpl的实例）的findSelectCourseByCourseId方法，传入课程编号cid，该方法会根据课程编号去查找对应的课程信息（如课程名称、学分等），并返回Course对象（包含课程相关的各种属性信息），将查询到的课程对象赋值给c变量，以便后续展示课程相关详情或者其他与课程有关的业务操作使用。
+
         SelectCourse sc = service2.findScoreByCourseIdAndStudentId(cid, sid);
+        // 调用service2的findScoreByCourseIdAndStudentId方法，传入课程编号cid和学生学号sid，该方法会依据这两个关键信息去查询对应的选课记录以及成绩等相关信息（因为选课记录关联了课程和学生，且成绩也是选课记录里的一部分内容），返回SelectCourse对象（包含选课相关的详细信息，比如选课时间、成绩等），将查询到的SelectCourse对象赋值给sc变量，用于后续的页面展示或者其他相关处理。
 
         request.setAttribute("s", s);
+        // 使用request对象的setAttribute方法，将查询到的学生对象s保存到请求对象中，设置的属性名为"s"，这样在后续转发请求到JSP页面等操作时，在目标JSP页面中就可以通过这个属性名获取到该学生对象，进而可以展示学生的详细信息，比如学号、姓名等内容。
+
         request.setAttribute("c", c);
+        // 同样，将查询到的课程对象c保存到请求对象中，属性名为"c"，方便在JSP页面等地方获取课程信息进行展示，例如展示课程名称、学分等相关内容。
+
         request.setAttribute("sc", sc);
+        // 把查询到的SelectCourse对象sc保存到请求对象中，属性名为"sc"，以便后续在页面中展示选课相关的详细信息，像选课时间、学生在该课程的成绩等情况。
+
         request.setAttribute("update_msg", "修改分数成功！" + String.format("%tT", new Date()));
+        // 设置名为"update_msg"的属性，属性值为提示用户修改分数成功的信息，并通过String.format结合%tT格式化Date对象，将当前的时间信息添加到提示信息中，让用户知晓操作完成且成功的时间情况，方便用户了解分数修改的及时性等。
+
         request.getRequestDispatcher("/WEB-INF/teacher/updateOptionalCourseScore.jsp").forward(request, response);
+        // 获取一个请求转发器，将当前请求转发到"/WEB-INF/teacher/updateOptionalCourseScore.jsp"这个JSP页面，通常该页面会用于展示修改课程分数后的相关信息，比如学生信息、课程信息、选课记录以及修改成功的提示信息等内容，这样服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面经过渲染后的内容，整个过程对客户端来说是一次完整的请求响应过程，客户端浏览器地址栏中的URL并不会发生改变，通过转发请求可以进行后续的页面展示操作，将修改分数后的情况呈现给用户查看。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求，例如当客户端通过在浏览器地址栏直接输入URL或者点击链接等方式（通常这些情况会发起GET请求）访问此Servlet对应的路径时，Web容器会调用这个方法来处理相应的请求。
+
         doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即不管客户端是通过POST方式还是GET方式访问这个Servlet对应的路径，都会按照doPost方法里所定义的逻辑去进行相应的处理，比如获取课程编号、学生学号、成绩信息，更新成绩，查询相关对象信息以及转发请求到JSP页面等操作都会同样执行，这样做可能是在业务逻辑上对于这两种请求方式更新选修课程分数的操作要求是一致的，所以进行了这样的复用处理。
     }
 }

src/web/servlet/teacher/UpdateScoreServlet.java

@@ -1,14 +1,27 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于web.servlet.teacher包下，利用包结构来对类进行分类管理，使项目的代码结构更加清晰，便于区分不同功能模块对应的代码。
 
 import domain.Course;
 import domain.SelectCourse;
 import domain.Student;
+// 导入相关的领域模型类，这些类用于封装业务领域中不同实体的属性及业务逻辑（若有定义）。
+// domain.Course类通常用于封装课程相关的属性，比如课程编号、课程名称、课程学分等信息，代表了业务领域里课程这一实体在代码中的体现，方便后续对课程相关数据进行操作与传递。
+// domain.SelectCourse类大概率是用来封装学生选课相关的信息，例如学生所选课程的对应关系、选课时间以及对应的成绩等内容，体现了学生选课这一业务概念在代码层面的抽象表示，便于处理与选课相关的业务操作。
+// domain.Student类用于封装学生相关的属性，像学号、姓名、所在班级等信息，是对学生这个业务实体在代码层面的表示，后续会基于学生学号等信息进行相关的查询操作。
+
 import service.CourseService;
 import service.SelectCourseService;
 import service.StudentService;
 import service.impl.CourseServiceImpl;
 import service.impl.SelectCourseServiceImpl;
 import service.impl.StudentServiceImpl;
+// 导入不同业务逻辑对应的服务接口以及它们的具体实现类，用于实现具体的业务操作功能。
+// service.CourseService接口定义了针对课程业务操作的抽象方法，例如查询课程详情、更新课程相关属性等操作对应的方法声明，为课程相关业务逻辑的调用提供统一规范。
+// service.SelectCourseService接口明确了与学生选课业务相关的操作方法，比如根据课程和学生信息查询选课记录、获取选课成绩等相关业务逻辑的抽象方法定义，便于后续进行选课相关的业务处理。
+// service.StudentService接口规定了针对学生业务操作的各种方法，像查询学生信息、更新学生资料等相关操作的接口声明，方便后续调用学生业务相关的功能。
+// service.impl.CourseServiceImpl是CourseService接口的具体实现类，其内部包含了与数据库或其他数据源交互来实际完成课程业务逻辑的代码，例如实现从数据库中查询课程信息、更新课程数据等具体功能的代码就在这个类里。
+// service.impl.SelectCourseServiceImpl是SelectCourseService接口的具体实现类，负责实现学生选课业务相关操作的具体代码逻辑，比如根据特定条件查询选课记录及成绩等操作的具体实现就在此。
+// service.impl.StudentServiceImpl则是StudentService接口的具体实现类，包含了实现学生业务相关操作的具体代码，比如依据学号查询学生信息等代码逻辑就在这个类中。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -16,32 +29,73 @@ import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及应对可能出现的异常情况。
+// ServletException用于处理Servlet执行过程中出现的异常情况，例如业务逻辑执行出错、配置错误等引发的异常都会通过它来处理。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性，方便Web容器（如Tomcat等服务器）识别并进行管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，开发人员通过重写它里面的方法来实现具体的业务逻辑，以应对不同类型的HTTP请求（如GET、POST等）。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，例如请求参数（像表单提交的数据等）、请求头信息等，是后续处理请求数据的重要依据。
+// HttpServletResponse用于向客户端发送HTTP响应，比如设置响应状态码、响应头以及返回响应内容等，以此构建完整的返回给客户端的信息。
+// IOException用于处理输入输出相关的异常，像读写文件、网络传输等出现问题时会抛出该异常。
 
 @WebServlet("/updateScoreServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为"/updateScoreServlet"。当客户端通过这个URL路径发起HTTP请求时，Web容器（如Tomcat等）就会找到并调用这个Servlet来处理请求。
 public class UpdateScoreServlet extends HttpServlet {
+    // 定义一个名为UpdateScoreServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等），以实现具体的业务逻辑，这里主要是实现与更新成绩相关的业务逻辑（从后续的操作和转发的页面推测）。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式（比如通过表单提交更新成绩相关信息等情况常用POST方式向服务器发送数据）访问此Servlet对应的"/updateScoreServlet"这个URL路径时，Web容器会自动调用这个方法来处理相应的请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则是用于向客户端返回响应信息的对象。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为"utf-8"，确保从客户端接收到的请求参数等数据能够按照UTF-8编码格式正确解析，避免中文等特殊字符出现乱码问题，保证后续获取和处理请求数据的准确性，特别是在获取课程编号、学生学号等关键信息时防止乱码很重要，因为这些信息后续要用于查询等操作。
+
         String cid = request.getParameter("cid");
+        // 从客户端发送的HTTP请求中获取名为"cid"的参数值，按照业务逻辑推测，这个参数值通常代表要更新成绩的课程的编号，将获取到的课程编号赋值给cid变量，以便后续根据这个编号进行相关的课程信息查询以及成绩更新等操作。
+
         String sid = request.getParameter("sid");
+        // 同样，从请求中获取名为"sid"的参数值，该值对应要更新成绩的学生的学号信息，赋值给sid变量，后续会基于这个学号来查找对应的学生信息以及关联的选课记录等，用于准确更新该学生对应课程的成绩。
 
         StudentService service = new StudentServiceImpl();
+        // 创建一个StudentServiceImpl类的实例，通过多态的方式将其赋值给StudentService接口类型的变量service，这样后续就可以调用StudentService接口中定义的业务方法，而具体的查询学生信息等操作的实现则由StudentServiceImpl类来完成，在这里是为了后续查找对应学号的学生信息做准备。
+
         Student student = new Student();
+        // 创建一个Student类的实例student，用于封装学生相关信息，准备后续根据学号查询完整的学生信息，虽然这里只是简单创建一个新对象，后续会设置学号等关键信息去查询数据库中的对应学生记录。
+
         student.setS_id(sid);
+        // 通过调用Student类的setS_id方法，将前面获取到的学生学号sid设置到student对象中，使得这个对象可以携带准确的学号信息去进行后续的查询操作，确保查询的是对应学号的学生信息。
+
         Student s = service.findStudentById(student);
+        // 调用service（即StudentServiceImpl的实例）的findStudentById方法，传入封装了学号信息的student对象，该方法会依据学生学号去数据库等数据源中查询对应的学生信息，并返回完整的学生对象（包含学号、姓名、班级等各种信息），将查询到的学生对象赋值给s变量，方便后续在页面展示或者其他相关业务操作中使用该学生的详细信息。
 
         CourseService service1 = new CourseServiceImpl();
+        // 创建一个CourseServiceImpl类的实例，赋值给CourseService接口类型的变量service1，方便后续调用CourseService接口里定义的业务方法，像查询课程相关信息等操作就可以通过这个变量来调用具体实现类的方法，这里是为了获取对应课程信息做准备。
+
         Course c = service1.findSelectCourseByCourseId(cid);
+        // 调用service1（即CourseServiceImpl的实例）的findSelectCourseByCourseId方法，传入课程编号cid，该方法会根据课程编号去查找对应的课程信息（如课程名称、学分等），并返回Course对象（包含课程相关的各种属性信息），将查询到的课程对象赋值给c变量，以便后续展示课程相关详情或者其他与课程有关的业务操作使用。
 
         SelectCourseService service2 = new SelectCourseServiceImpl();
+        // 创建一个SelectCourseServiceImpl类的实例，赋值给SelectCourseService接口类型的变量service2，以便后续调用SelectCourseService接口中定义的业务方法，例如根据课程编号和学生学号查询选课记录及成绩等操作都可以通过这个变量来调用具体实现类的方法，这里是为了获取选课相关信息做准备。
+
         SelectCourse sc = service2.findScoreByCourseIdAndStudentId(cid, sid);
+        // 调用service2的findScoreByCourseIdAndStudentId方法，传入课程编号cid和学生学号sid，该方法会依据这两个关键信息去查询对应的选课记录以及成绩等相关信息（因为选课记录关联了课程和学生，且成绩也是选课记录里的一部分内容），返回SelectCourse对象（包含选课相关的详细信息，比如选课时间、成绩等），将查询到的SelectCourse对象赋值给sc变量，用于后续的页面展示或者其他相关处理。
 
         request.setAttribute("s", s);
+        // 使用request对象的setAttribute方法，将查询到的学生对象s保存到请求对象中，设置的属性名为"s"，这样在后续转发请求到JSP页面等操作时，在目标JSP页面中就可以通过这个属性名获取到该学生对象，进而可以展示学生的详细信息，比如学号、姓名等内容。
+
         request.setAttribute("c", c);
+        // 同样，将查询到的课程对象c保存到请求对象中，属性名为"c"，方便在JSP页面等地方获取课程信息进行展示，例如展示课程名称、学分等相关内容。
+
         request.setAttribute("sc", sc);
+        // 把查询到的SelectCourse对象sc保存到请求对象中，属性名为"sc"，以便后续在页面中展示选课相关的详细信息，像选课时间、学生在该课程的成绩等情况。
+
         request.getRequestDispatcher("/WEB-INF/teacher/updateOptionalCourseScore.jsp").forward(request, response);
+        // 获取一个请求转发器，将当前请求转发到"/WEB-INF/teacher/updateOptionalCourseScore.jsp"这个JSP页面，通常该页面会用于展示更新成绩相关的信息，比如学生信息、课程信息、选课记录等内容，这样服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面经过渲染后的内容，整个过程对客户端来说是一次完整的请求响应过程，客户端浏览器地址栏中的URL并不会发生改变，通过转发请求可以进行后续的页面展示操作，将与更新成绩相关的情况呈现给用户查看。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求，例如当客户端通过在浏览器地址栏直接输入URL或者点击链接等方式（通常这些情况会发起GET请求）访问此Servlet对应的路径时，Web容器会调用这个方法来处理相应的请求。
+
         doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即不管客户端是通过POST方式还是GET方式访问这个Servlet对应的路径，都会按照doPost方法里所定义的逻辑去进行相应的处理，比如获取课程编号、学生学号，查询学生、课程、选课记录信息，设置请求属性以及转发请求到JSP页面等操作都会同样执行，这样做可能是在业务逻辑上对于这两种请求方式展示更新成绩相关信息的操作要求是一致的，所以进行了这样的复用处理。
     }
 }

src/web/servlet/teacher/UpdateTeacherInfoServlet.java

@@ -1,10 +1,18 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于“web.servlet.teacher”包下，通过包结构对类进行分类管理，有助于清晰地组织项目代码，方便区分不同功能模块对应的代码。
 
 import domain.Teacher;
+// 导入领域模型类Teacher，Teacher类通常用于封装教师相关的各种属性（如教师编号、姓名、性别、学历、职称等信息）以及对应的业务逻辑（如果有定义），在这里主要围绕教师信息的更新操作来使用这个类。
+
 import service.StudentService;
 import service.TeacherService;
 import service.impl.StudentServiceImpl;
 import service.impl.TeacherServiceImpl;
+// 导入学生和教师相关业务逻辑的服务接口以及对应的具体实现类。
+// StudentService定义了针对学生业务操作的抽象方法，不过在这段代码中主要处理教师信息更新相关业务，所以该接口相关操作在此处暂未直接使用，但可能是项目整体服务层结构中统一引入的部分。
+// TeacherService是针对教师业务操作的服务接口，明确了像更新教师信息、查询教师详情等与教师业务相关的各种操作方法，为后续调用教师业务逻辑提供统一的接口规范。
+// StudentServiceImpl是StudentService接口的具体实现类，包含了与数据库或其他数据源交互来实际完成学生业务逻辑的代码，不过在当前教师信息更新的业务场景下，暂时不会调用其方法，只是作为项目中服务层实现类的一部分被引入。
+// TeacherServiceImpl则是TeacherService接口的具体实现类，负责实现教师业务相关操作的具体代码逻辑，例如这里要调用的更新教师信息的方法就在这个类中进行具体实现。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -13,42 +21,89 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.Date;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及应对可能出现的异常情况，同时导入用于获取当前日期时间信息的Date类，方便在给用户的提示信息中添加操作时间等。
+// ServletException用于处理Servlet执行过程中出现的异常情况，例如业务逻辑执行出错、配置错误等引发的异常都会通过它来处理。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性，方便Web容器（如Tomcat等服务器）识别并进行管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，开发人员通过重写它里面的方法来实现具体的业务逻辑，以应对不同类型的HTTP请求（如GET、POST等）。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，像请求参数（如表单提交的数据等）、请求头信息等，是后续处理请求数据的重要依据。
+// HttpServletResponse用于向客户端发送HTTP响应，例如设置响应状态码、响应头以及返回响应内容等，以此构建完整的返回给客户端的信息。
+// IOException用于处理输入输出相关的异常，像读写文件、网络传输等出现问题时会抛出该异常。
+// Date类用于获取当前的日期和时间，在这里主要是用于在给用户反馈的提示信息中添加具体的时间戳，使得用户能知晓教师信息修改操作完成的时间情况。
 
 @WebServlet("/updateTeacherInfoServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为“/updateTeacherInfoServlet”。当客户端通过这个URL路径发起HTTP请求时，Web容器（如Tomcat等）就会找到并调用这个Servlet来处理请求。
 public class UpdateTeacherInfoServlet extends HttpServlet {
+    // 定义一个名为UpdateTeacherInfoServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等），以实现具体的业务逻辑，这里主要是实现更新教师信息的相关业务逻辑。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式（例如通过表单提交教师信息修改相关的数据等情况常用POST方式向服务器发送数据）访问此Servlet对应的“/updateTeacherInfoServlet”这个URL路径时，Web容器会自动调用这个方法来处理相应的请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则是用于向客户端返回响应信息的对象。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为“utf-8”，确保从客户端接收到的请求参数等数据能够按照UTF-8编码格式正确解析，避免中文等特殊字符出现乱码问题，保证后续获取和处理请求数据的准确性，因为要获取教师的各项信息（如姓名、学历、职称等文本信息），防止乱码很关键。
+
         String tid = request.getParameter("teacher-id");
+        // 从客户端发送的HTTP请求中获取名为“teacher-id”的参数值，按照业务逻辑推测，这个参数值通常代表要更新信息的教师的编号，将获取到的教师编号赋值给tid变量，以便后续根据这个编号准确地更新对应的教师信息，使其与数据库中相应教师记录对应起来。
 
         String name = request.getParameter("teacher-name");
+        // 从请求中获取名为“teacher-name”的参数值，该值对应要更新的教师的姓名信息，赋值给name变量，准备后续封装到教师对象中，用于更新教师在数据库等数据源中的姓名信息。
+
         String sex = request.getParameter("teacher-sex");
+        // 同样，从请求中获取名为“teacher-sex”的参数值，这个值代表教师的性别信息，赋值给sex变量，后续也会将其封装进教师对象，用于更新教师的性别相关信息（如果数据库中有相应字段存储性别信息的话）。
+
         String education = request.getParameter("teacher-education");
+        // 从请求中获取名为“teacher-education”的参数值，此值为要更新的教师的学历信息，赋值给education变量，将用于后续封装到教师对象里，以更新教师在数据库中的学历记录。
+
         String title = request.getParameter("teacher-title");
+        // 从请求中获取名为“teacher-title”的参数值，该值是要更新的教师的职称信息，赋值给title变量，后续会把它设置到教师对象中，用于更新教师的职称相关信息。
 
         Teacher updateTeacher = new Teacher();
+        // 创建一个Teacher类的实例updateTeacher，用于封装要更新的教师的相关信息，后续会将从请求中获取到的教师编号、姓名、性别、学历、职称等信息设置到这个对象中，再通过业务层方法将更新后的教师对象保存到数据库等数据源中，完成教师信息的更新操作。
+
         // 判断输入位数是否大于数据库位数
         if (name.length() > 4 || education.length() > 20 || title.length() > 24 || name.contains("<") || education.contains("<") || title.contains("<")) {
+            // 这里进行一系列的格式验证判断，检查教师姓名（name）的长度是否超过4个字符、学历（education）长度是否超过20个字符、职称（title）长度是否超过24个字符，并且检查姓名、学历、职称中是否包含字符“<”。这些限制可能是基于数据库字段长度设计以及安全考虑（比如防止潜在的SQL注入攻击等情况，虽然简单这样判断不能完全杜绝但能一定程度防范），如果不符合要求则认为格式错误。
             request.setAttribute("update_msg", "格式错误，请重新提交！" + String.format("%tT", new Date()));
+            // 使用request对象的setAttribute方法设置一个名为“update_msg”的属性，属性值是提示用户格式错误并告知需要重新提交的信息，同时通过String.format结合%tT格式化Date对象，将当前的时间信息添加到提示信息中，方便用户知晓出现格式错误的时间情况以及提示重新操作。
             request.getRequestDispatcher("updateTeacherServlet?tid=" + tid).forward(request, response);
+            // 获取一个请求转发器，将当前请求转发到“updateTeacherServlet”这个资源（可能是另一个Servlet或者JSP页面等），同时带上获取到的教师编号tid作为参数（通过URL拼接的方式传递参数），这样服务器端会接着处理转发后的请求，并向客户端返回相应的响应内容，整个过程对客户端来说是一次完整的请求响应过程，地址栏中的URL会根据转发情况发生相应改变，转发后可以继续后续的页面展示或者重新输入等操作。
         } else {
             // 封装教师对象
             updateTeacher.setT_id(tid);
+            // 通过调用Teacher类的setT_id方法，将前面获取到的教师编号设置到updateTeacher对象中，确保更新的教师信息对应正确的教师记录，与数据库中要更新的教师记录通过编号关联起来。
+
             updateTeacher.setT_name(name);
+            // 将获取到的教师姓名设置到updateTeacher对象中，用于更新教师在数据库中的姓名信息。
+
             updateTeacher.setT_sex(sex);
+            // 把获取到的教师性别信息设置到updateTeacher对象中，用于更新教师的性别相关信息（如果数据库中有对应字段存储性别信息的话）。
+
             updateTeacher.setT_education(education);
+            // 将获取到的教师学历信息设置到updateTeacher对象中，以更新教师在数据库中的学历记录。
+
             updateTeacher.setT_title(title);
+            // 把获取到的教师职称信息设置到updateTeacher对象中，用于更新教师的职称相关信息。
 
-            //调用TeacherUpdate服务
+            // 调用TeacherUpdate服务（此处应为调用TeacherService服务，可能是注释书写小失误）
             TeacherService service = new TeacherServiceImpl();
+            // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量service，这样后续就可以调用TeacherService接口中定义的业务方法，而具体的更新教师信息的操作实现则由TeacherServiceImpl类来完成。
+
             service.updateInfo(updateTeacher);
+            // 调用service（实际是TeacherServiceImpl的实例）的updateInfo方法，将封装好的包含更新后信息的教师对象updateTeacher传入，该方法应该是在数据库或其他存储教师信息的数据源中，根据教师对象中的信息（编号、姓名、性别、学历、职称等）来更新对应的教师记录，实现教师信息的更新业务逻辑操作。
 
             // 成功则返回并给提示
             request.setAttribute("update_msg", "修改成功！" + String.format("%tT", new Date()));
+            // 设置名为“update_msg”的属性，属性值为提示用户教师信息修改成功的信息，并通过格式化添加当前时间信息，让用户知晓操作完成且成功的时间情况。
+
             request.getRequestDispatcher("updateTeacherServlet?tid=" + tid).forward(request, response);
+            // 同样获取请求转发器，将请求转发到“updateTeacherServlet”资源并带上教师编号tid作为参数，进行后续的页面展示或者其他相关业务处理，告知用户修改成功并可以进行后续查看等操作。
         }
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求，例如当客户端通过在浏览器地址栏直接输入URL或者点击链接等方式（通常这些情况会发起GET请求）访问此Servlet对应的路径时，Web容器会调用这个方法来处理相应的请求。
+
         doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即不管客户端是通过POST方式还是GET方式访问这个Servlet对应的路径，都会按照doPost方法里所定义的逻辑去进行相应的处理，比如获取教师相关参数、验证格式、封装教师对象、更新教师信息以及转发请求等操作都会同样执行，这样做可能是在业务逻辑上对于这两种请求方式更新教师信息的操作要求是一致的，所以进行了这样的复用处理。
     }
 }

src/web/servlet/teacher/UpdateTeacherOptionalCourseServlet.java

@@ -1,8 +1,14 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于“web.servlet.teacher”包下，通过包结构对类进行分类组织，有助于使项目代码结构更清晰，便于区分不同功能模块对应的代码所在位置。
 
 import domain.Course;
+// 导入领域模型类Course，Course类通常用于封装课程相关的各种属性（比如课程编号、课程名称、课程详细介绍等信息）以及可能的业务逻辑方法（如果有针对课程对象自身的操作需求），在这里主要用于表示教师可选课程相关信息，方便后续操作课程数据。
+
 import service.TeacherService;
 import service.impl.TeacherServiceImpl;
+// 导入教师业务逻辑对应的服务接口（TeacherService）以及该接口的具体实现类（TeacherServiceImpl）。
+// TeacherService接口定义了针对教师业务操作中与课程相关（此处主要涉及查询可选课程等操作）的抽象方法，为具体业务逻辑的调用提供了统一的规范。
+// TeacherServiceImpl类则是TeacherService接口的具体实现，包含了与数据库或其他数据源交互，来实际完成查询可选课程等业务逻辑的代码。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -12,24 +18,60 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及可能出现的异常情况，同时导入用于处理集合数据类型（虽然此处暂时未体现集合操作）的类以及处理会话相关操作的类。
+// ServletException用于处理Servlet执行过程中出现的异常情况，例如业务逻辑执行出错、配置错误等引发的异常都会通过它来处理。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性，方便Web容器（如Tomcat等服务器）识别并进行管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，开发人员通过重写它里面的方法来实现具体的业务逻辑，以应对不同类型的HTTP请求（如GET、POST等）。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，像请求参数（例如表单提交的数据等）、请求头信息等，是后续处理请求数据的重要依据。
+// HttpServletResponse用于向客户端发送HTTP响应，例如设置响应状态码、响应头以及返回响应内容等，用于构建返回给客户端的信息。
+// HttpSession用于在服务器端管理用户会话信息，通过它可以在不同的请求之间共享数据，不过在这段代码里当前注释掉了相关使用代码，原本可能是用于获取登录教师等相关会话信息，现在暂未实际使用该功能（也许后续会完善）。
+// IOException用于处理输入输出相关的异常，像读写文件、网络传输等出现问题时会抛出该异常。
+// List是Java集合框架中的接口，表示一个有序的、可包含重复元素的集合，虽然在这里暂时没有直接体现出对集合的操作，但在一些更复杂的业务场景中，如果查询出多条课程相关记录可能就会用到List来存放并处理。
 
 @WebServlet("/updateTeacherOptionalCourseServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为“/updateTeacherOptionalCourseServlet”。当客户端通过这个URL路径发起HTTP请求时，Web容器（如Tomcat等服务器）就会找到并调用这个Servlet来处理请求。
 public class UpdateTeacherOptionalCourseServlet extends HttpServlet {
+    // 定义一个名为UpdateTeacherOptionalCourseServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等），以实现具体的业务逻辑，这里主要是实现与教师更新可选课程信息相关的业务逻辑（从转发的JSP页面推测）。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式（比如通过表单提交更新课程相关信息等情况常用POST方式向服务器发送数据）访问此Servlet对应的“/updateTeacherOptionalCourseServlet”这个URL路径时，Web容器会自动调用这个方法来处理相应的请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则是用于向客户端返回响应信息的对象。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为“utf-8”，确保从客户端接收到的请求参数等数据能够按照UTF-8编码格式正确解析，避免中文等特殊字符出现乱码问题，保证后续获取和处理请求数据的准确性，特别是在获取课程相关参数等文本信息时防止乱码很关键，因为后续要基于这些参数进行课程信息查询等操作。
+
 //        HttpSession session = request.getSession();
+        // 这行代码被注释掉了，原本的意图应该是获取当前请求对应的HttpSession对象，如果不存在则创建一个新的会话对象。HttpSession在服务器端用于管理用户的会话信息，通常可以用来获取当前登录教师的相关信息（比如教师编号等，用于后续根据教师身份查询对应的可选课程等操作），不过当前暂时没有启用这块功能，可能后续开发中会根据实际需求决定是否启用以及如何使用会话信息。
+
         String cid = (String) request.getParameter("cid");
+        // 从客户端发送的HTTP请求中获取名为“cid”的参数值，并将其强制转换为String类型（虽然一般情况下请求获取到的参数默认就是String类型，但这里明确转换更严谨），按照业务逻辑推测，这个参数值通常代表要更新信息的可选课程的编号，将获取到的课程编号赋值给cid变量，以便后续根据这个编号进行课程相关信息的查询以及后续可能的更新操作等。
+
         TeacherService service = new TeacherServiceImpl();
+        // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量service，这样后续就可以调用TeacherService接口中定义的业务方法，而具体的查询可选课程信息的操作实现则由TeacherServiceImpl类来完成，在这里就是为了通过课程编号查询对应的课程对象信息做准备。
+
         Course c = service.findOptionalCourseByCourseId(cid);
+        // 调用service（实际是TeacherServiceImpl的实例）的findOptionalCourseByCourseId方法，传入前面获取到的课程编号cid作为参数，该方法应该是在数据库或其他存储课程信息的数据源中，根据课程编号去查找对应的课程信息（如课程名称、课程详细介绍等），并返回一个Course对象（包含课程相关的各种属性信息），将查询到的课程对象赋值给c变量，方便后续展示课程相关详情或者进行其他与课程有关的业务操作使用。
+
         request.setAttribute("course", c);
+        // 使用request对象的setAttribute方法，将查询到的课程对象c保存到请求对象中，设置的属性名为“course”，这样在后续转发请求到JSP页面等操作时，在目标JSP页面中就可以通过这个属性名获取到该课程对象，进而可以展示课程的详细信息，比如课程名称、课程介绍等内容，方便教师查看并进行后续的课程信息更新操作（如果页面上有相应的表单等元素用于更新信息的话）。
+
         System.out.println(c.getC_id());
+        // 通过调用Course类的getC_id方法，获取课程对象c的课程编号属性，并将其输出到控制台，这可能是用于调试目的，方便开发人员查看当前获取到的课程编号是否正确，是否是预期的要操作的课程编号，在实际的生产环境中，可能会根据需要决定是否保留这样的输出语句（一般调试完成后可以考虑移除或者根据日志配置决定是否记录）。
+
         System.out.println(c.getC_name());
+        // 同样，调用Course类的getC_name方法获取课程对象c的课程名称属性，并输出到控制台，也是用于调试，便于确认获取到的课程名称信息是否准确，符合预期的查询结果，帮助开发人员排查可能出现的问题，比如课程名称显示异常等情况。
+
         System.out.println(c.getC_info());
+        // 调用Course类的getC_info方法获取课程对象c的课程详细介绍等信息，并输出到控制台，同样是出于调试目的，方便开发人员查看课程详细介绍内容是否正确获取到了，以此来验证查询课程信息的业务逻辑是否正确执行。
 
         request.getRequestDispatcher("/WEB-INF/teacher/updateTeacherOptionalCourseInfo.jsp").forward(request, response);
+        // 获取一个请求转发器，将当前请求转发到“/WEB-INF/teacher/updateTeacherOptionalCourseInfo.jsp”这个JSP页面，通常该页面会用于展示要更新的教师可选课程的相关信息（比如通过获取到的课程对象展示课程名称、课程介绍等内容），并且可能会提供相应的表单元素等，方便教师进行课程信息的修改操作，这样服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面经过渲染后的内容，整个过程对客户端来说是一次完整的请求响应过程，客户端浏览器地址栏中的URL并不会发生改变，通过转发请求可以进行后续的页面展示等业务操作，引导教师进入课程信息更新页面。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求，例如当客户端通过在浏览器地址栏直接输入URL或者点击链接等方式（通常这些情况会发起GET请求）访问此Servlet对应的路径时，Web容器会调用这个方法来处理相应的请求。
+
         doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即不管客户端是通过POST方式还是GET方式访问这个Servlet对应的路径，都会按照doPost方法里所定义的逻辑去进行相应的处理，比如获取课程编号、查询课程信息、设置请求属性以及转发请求到JSP页面等操作都会同样执行，这样做可能是在业务逻辑上对于这两种请求方式展示教师可选课程信息并引导进入更新页面的操作要求是一致的，所以进行了这样的复用处理。
     }
 }

src/web/servlet/teacher/UpdateTeacherServlet.java

@@ -1,15 +1,30 @@
 package web.servlet.teacher;
+// 定义该类所属的包名，表明这个Servlet类位于“web.servlet.teacher”包下，通过包结构对类进行分类管理，有助于在项目中清晰地组织代码，方便区分不同功能模块对应的代码。
 
 import com.sun.org.apache.regexp.internal.RE;
+// 导入了Apache的正则表达式相关的类（不过这里的导入路径看起来比较旧，后续可能更推荐使用java.util.regex包下的正则相关类），虽然从当前代码来看可能暂时未直接体现它的使用场景，但也许在更复杂的验证等逻辑中会涉及到正则表达式相关操作，比如对输入数据格式进行验证等情况。
+
 import domain.CDC;
 import domain.Student;
 import domain.Teacher;
+// 导入不同的领域模型类，这些类通常用于封装业务领域中不同实体的属性以及相关业务逻辑（如果有定义）。
+// domain.CDC类，从命名推测可能是用于表示学校相关组织结构信息，比如学院（College）、系（Department）、班级（Class）等相关信息的实体类，具体包含对应这些组织结构的相关属性以及可能的业务操作方法。
+// domain.Student类用于封装学生相关的属性，像学号、姓名、班级等信息，以及对应的业务逻辑，虽然在这个Servlet中主要围绕教师相关操作，但可能是整体项目结构中涉及到相关领域类的统一引入。
+// domain.Teacher类用于封装教师相关的属性（如教师编号、姓名、所在院系等）以及业务逻辑，在本类中会用于查询教师信息以及后续和教师相关的业务操作关联，比如更新教师信息等操作会基于这个类的对象来进行。
+
 import service.CDCService;
 import service.StudentService;
 import service.TeacherService;
 import service.impl.CDCServiceImpl;
 import service.impl.StudentServiceImpl;
 import service.impl.TeacherServiceImpl;
+// 导入不同业务逻辑对应的服务接口以及它们的具体实现类，用于实现具体的业务操作功能。
+// service.CDCService接口定义了针对CDC相关业务操作的抽象方法，例如查询所有学院、所有系、所有班级等操作对应的方法声明，为获取学校组织结构相关信息提供统一的接口规范。
+// service.StudentService接口规定了针对学生业务操作的各种方法，像查询学生信息、更新学生资料等相关操作的接口声明，不过在此处主要处理教师相关业务逻辑，该接口相关操作暂未直接体现使用，但可能是项目整体服务层的一部分引入进来。
+// service.TeacherService接口明确了与教师业务相关的各种操作方法，比如根据教师编号查询教师信息、更新教师相关属性等业务逻辑对应的方法定义，方便后续调用教师业务相关功能。
+// service.impl.CDCServiceImpl是CDCService接口的具体实现类，其内部包含了与数据库或其他数据源交互来实际完成CDC相关业务逻辑的代码，例如实现从数据库中查询所有学院、系、班级信息等具体功能的代码就在这个类里。
+// service.impl.StudentServiceImpl是StudentService接口的具体实现类，包含了实现学生业务相关操作的具体代码，虽然在此场景下暂时未直接使用其功能，但作为项目服务层实现类的一部分被引入。
+// service.impl.TeacherServiceImpl则是TeacherService接口的具体实现类，负责实现教师业务相关操作的具体代码逻辑，比如根据教师编号查找教师对象等操作的具体实现就在此，后续会用于查询教师信息等操作。
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -19,33 +34,78 @@ import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
+// 导入Java EE中Servlet相关的基础类和接口，用于处理Servlet相关的操作以及应对可能出现的异常情况，同时导入用于处理集合数据类型的List接口，用于存放查询出来的多条相关数据（比如多个学院、系、班级信息等）。
+// ServletException用于处理Servlet执行过程中出现的异常情况，例如业务逻辑执行出错、配置错误等引发的异常都会通过它来处理。
+// WebServlet注解用于将一个普通的Java类标注为Servlet，并配置其相关的访问路径等属性，方便Web容器（如Tomcat等服务器）识别并进行管理。
+// HttpServlet是所有基于HTTP协议的Servlet的基类，提供了处理HTTP请求的基础结构和方法，开发人员通过重写它里面的方法来实现具体的业务逻辑，以应对不同类型的HTTP请求（如GET、POST等）。
+// HttpServletRequest用于获取客户端发送过来的HTTP请求中的各种信息，例如请求参数（像表单提交的数据等）、请求头信息等，是后续处理请求数据的重要依据。
+// HttpServletResponse用于向客户端发送HTTP响应，比如设置响应状态码、响应头以及返回响应内容等，以此构建完整的返回给客户端的信息。
+// HttpSession用于在服务器端管理用户会话信息，通过它可以在不同的请求之间共享数据，在这里主要用于保存查询出来的学校组织结构相关信息（学院、系、班级列表等），方便在后续页面展示或者其他相关操作中使用这些共享数据。
+// IOException用于处理输入输出相关的异常，像读写文件、网络传输等出现问题时会抛出该异常。
+// List是Java集合框架中的接口，表示一个有序的、可包含重复元素的集合，用于存放从数据库或其他数据源查询出来的多条CDC相关对象（如多个学院信息、多个系信息、多个班级信息等），方便后续对这些数据进行遍历、展示等操作。
 
 @WebServlet("/updateTeacherServlet")
+// 使用@WebServlet注解将当前类标记为一个Servlet，并指定其对应的访问路径为“/updateTeacherServlet”。当客户端通过这个URL路径发起HTTP请求时，Web容器（如Tomcat等服务器）就会找到并调用这个Servlet来处理请求。
 public class UpdateTeacherServlet extends HttpServlet {
+    // 定义一个名为UpdateTeacherServlet的类，它继承自HttpServlet类，意味着这个类是一个用于处理HTTP请求的Servlet，通过继承HttpServlet可以方便地重写相应方法来处理不同类型的HTTP请求（如GET、POST等），以实现具体的业务逻辑，这里主要是实现与教师信息更新相关的前期准备工作的业务逻辑（从转发的JSP页面推测，可能是为更新教师信息页面准备数据等操作）。
+
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式（例如通过表单提交教师信息相关的数据等情况常用POST方式向服务器发送数据）访问此Servlet对应的“/updateTeacherServlet”这个URL路径时，Web容器会自动调用这个方法来处理相应的请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则是用于向客户端返回响应信息的对象。
+
         request.setCharacterEncoding("utf-8");
+        // 设置请求的字符编码为“utf-8”，确保从客户端接收到的请求参数等数据能够按照UTF-8编码格式正确解析，避免中文等特殊字符出现乱码问题，保证后续获取和处理请求数据的准确性，因为后续要获取教师编号等文本信息，防止乱码很关键，这些信息会用于查询教师信息等操作。
+
         HttpSession session = request.getSession();
+        // 获取当前请求对应的HttpSession对象，如果不存在则创建一个新的会话对象。HttpSession在服务器端用于管理用户的会话信息，在这里主要是为了保存后续查询出来的学校组织结构相关信息（如学院、系、班级列表等），以便在不同请求之间共享这些数据，方便后续页面展示等操作使用。
+
         String teacherid = request.getParameter("tid");
+        // 从客户端发送的HTTP请求中获取名为“tid”的参数值，按照业务逻辑推测，这个参数值通常代表要更新信息的教师的编号，将获取到的教师编号赋值给teacherid变量，以便后续根据这个编号准确地查询对应的教师信息，使其与数据库中相应教师记录对应起来。
 
         Teacher teacher = new Teacher();
+        // 创建一个Teacher类的实例teacher，用于封装教师相关信息，准备后续根据教师编号查询完整的教师信息，虽然这里只是简单创建一个新对象，后续会设置教师编号等关键信息去查询数据库中的对应教师记录。
+
         teacher.setT_id(teacherid);
+        // 通过调用Teacher类的setT_id方法，将前面获取到的教师编号设置到teacher对象中，使得这个对象可以携带准确的教师编号信息去进行后续的查询操作，确保查询的是对应编号的教师信息。
+
         TeacherService service = new TeacherServiceImpl();
+        // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量service，这样后续就可以调用TeacherService接口中定义的业务方法，而具体的查询教师信息等操作的实现则由TeacherServiceImpl类来完成，在这里就是为了根据教师编号查找对应的教师对象做准备。
+
         Teacher newTeacher = service.findTeacherById(teacher);
+        // 调用service（即TeacherServiceImpl的实例）的findTeacherById方法，传入封装了教师编号信息的teacher对象，该方法会依据教师编号去数据库等数据源中查询对应的教师信息，并返回完整的教师对象（包含教师编号、姓名、所在院系等各种信息），将查询到的教师对象赋值给newTeacher变量，方便后续在页面展示或者其他相关业务操作中使用该教师的详细信息。
+
         request.setAttribute("teacher", newTeacher);
+        // 使用request对象的setAttribute方法，将查询到的教师对象newTeacher保存到请求对象中，设置的属性名为“teacher”，这样在后续转发请求到JSP页面等操作时，在目标JSP页面中就可以通过这个属性名获取到该教师对象，进而可以展示教师的详细信息，比如姓名、所在院系等内容，为后续教师信息更新页面（推测）提供要更新的教师的初始信息展示。
 
         CDCService service2 = new CDCServiceImpl();
+        // 创建一个CDCServiceImpl类的实例，赋值给CDCService接口类型的变量service2，方便后续调用CDCService接口里定义的业务方法，像查询所有学院、所有系、所有班级等操作就可以通过这个变量来调用具体实现类的方法，这里是为了获取学校组织结构相关信息做准备。
+
         List<CDC> collegeList = service2.findAllCollege();
+        // 调用service2（即CDCServiceImpl的实例）的findAllCollege方法，该方法会从数据库或其他存储学校组织结构信息的数据源中，查询出所有学院的相关信息，并以CDC对象组成的列表形式返回，将查询到的学院信息列表赋值给collegeList变量，方便后续对这些学院信息进行展示或者其他相关处理（比如在更新教师信息页面上让用户选择教师所属学院等操作）。
+
         List<CDC> departmentList = service2.findAllDepartment();
+        // 调用service2的findAllDepartment方法，此方法会查询出所有系的相关信息，并返回CDC对象组成的列表，赋值给departmentList变量，同样用于后续的展示或者和系相关的业务操作（比如选择教师所属系等）。
+
         List<CDC> classList = service2.findAllClass();
+        // 调用service2的findAllClass方法，该方法从数据源中查询出所有班级的相关信息，以CDC对象列表形式返回，赋值给classList变量，后续可用于班级相关的展示或者操作（比如选择教师授课班级等情况，具体看业务需求）。
 
         session.setAttribute("collegeLists", collegeList);
+        // 使用HttpSession对象的setAttribute方法，将查询到的学院信息列表collegeList保存到会话对象中，设置的属性名为“collegeLists”，这样在不同的请求之间（比如后续页面刷新或者其他相关操作涉及到再次使用这些学院信息时）可以通过这个属性名从会话中获取到学院信息列表，方便在页面上展示所有学院供用户选择等操作。
+
         session.setAttribute("departmentLists", departmentList);
+        // 同样，将系信息列表departmentList保存到会话对象中，属性名为“departmentLists”，便于后续在页面展示系相关信息以及进行系相关的业务操作时从会话中获取对应的系信息列表。
+
         session.setAttribute("classLists", classList);
+        // 把班级信息列表classList保存到会话对象中，属性名为“classLists”，方便后续在页面展示班级信息以及进行班级相关操作时从会话中获取班级信息列表。
 
         request.getRequestDispatcher("/WEB-INF/admin/updateTeacher.jsp").forward(request, response);
+        // 获取一个请求转发器，将当前请求转发到“/WEB-INF/admin/updateTeacher.jsp”这个JSP页面，通常该页面会用于展示教师信息更新相关的表单以及学校组织结构相关的下拉列表等内容（比如通过从会话中获取学院、系、班级列表展示下拉框供用户选择教师所属的这些组织结构信息，同时展示之前查询到的教师对象信息用于用户查看和修改），这样服务器端会接着处理转发后的请求，并向客户端返回相应的JSP页面经过渲染后的内容，整个过程对客户端来说是一次完整的请求响应过程，客户端浏览器地址栏中的URL并不会发生改变，通过转发请求可以进行后续的页面展示等业务操作，引导进入教师信息更新页面。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求，例如当客户端通过在浏览器地址栏直接输入URL或者点击链接等方式（通常这些情况会发起GET请求）访问此Servlet对应的路径时，Web容器会调用这个方法来处理相应的请求。
+
         doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即不管客户端是通过POST方式还是GET方式访问这个Servlet对应的路径，都会按照doPost方法里所定义的逻辑去进行相应的处理，比如获取教师编号、查询教师信息、获取学校组织结构信息、设置请求和会话属性以及转发请求到JSP页面等操作都会同样执行，这样做可能是在业务逻辑上对于这两种请求方式进入教师信息更新页面的操作要求是一致的，所以进行了这样的复用处理。
     }
 }

src/web/servlet/verifycode/CheckCodeServlet.java

@@ -1,9 +1,7 @@
 package web.servlet.verifycode;
 
-
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.util.JSONPObject;
-
 import java.awt.Color;
 import java.awt.Font;
 import java.awt.Graphics;
@@ -21,71 +19,137 @@ import javax.servlet.http.HttpServletResponse;
 
 /**
  * 验证码
+ * 该类主要用于生成验证码图片，并将对应的验证码字符串存储在 HttpSession 中，同时把验证码图片响应给客户端浏览器，
+ * 在整个应用中通常用于用户登录、注册等需要验证身份的场景，防止机器自动操作等情况。
  */
 @WebServlet("/checkCodeServlet")
 public class CheckCodeServlet extends HttpServlet {
+
+    /**
+     * 处理 HTTP GET 请求的方法
+     * 在此方法中完成生成验证码图片、设置相关响应头、将验证码存入会话以及输出图片到浏览器等操作。
+     *
+     * @param request  HttpServletRequest 对象，用于获取请求相关信息，如会话等
+     * @param response HttpServletResponse 对象，用于设置响应相关的内容，如响应头、输出流等
+     * @throws ServletException 如果在 Servlet 处理过程中出现异常
+     * @throws IOException      如果在输入输出操作（如写入响应流）过程中出现异常
+     */
     public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
-		//服务器通知浏览器不要缓存
+<<<<<<< HEAD
+		//将内存中的图片输出到浏览器
+		//参数一：图片对象
+		//参数二：图片的格式，如PNG,JPG,GIF
+		//参数三：图片输出到哪里去
+		ImageIO.write(image,"PNG",response.getOutputStream());
+	}
+	/**
+	 * 产生4位随机字符串 
+	 */
+	private String getCheckCode() {
+		String base = "23456789ABCDEFGHJKMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz";
+		int size = base.length();
+		Random r = new Random();
+		StringBuffer sb = new StringBuffer();
+		for(int i=1;i<=4;i++){
+			//产生0到size-1的随机值
+			int index = r.nextInt(size);
+			//在base字符串中获取下标为index的字符
+			char c = base.charAt(index);
+			//将c放入到StringBuffer中去
+			sb.append(c);
+		}
+		return sb.toString();
+	}
+	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+		this.doGet(request,response);
+	}
+}
+//.......
+=======
+        // 服务器通知浏览器不要缓存验证码图片相关逻辑
+        // 设置响应头 "pragma" 为 "no-cache"，这是一种 HTTP 1.0 的缓存控制方式，告诉浏览器不要缓存页面
         response.setHeader("pragma", "no-cache");
+        // 设置响应头 "cache-control" 为 "no-cache"，这是 HTTP 1.1 中常用的缓存控制方式，明确指示浏览器不进行缓存
         response.setHeader("cache-control", "no-cache");
+        // 设置响应头 "expires" 为 "0"，指定缓存过期时间为过去的某个时间，也是一种强制浏览器不缓存的手段
         response.setHeader("expires", "0");
 
-		//在内存中创建一个长80，宽30的图片，默认黑色背景
-		//参数一：长
-		//参数二：宽
-		//参数三：颜色
+        // 在内存中创建一个指定尺寸的图片对象相关逻辑
+        // 定义图片的宽度，单位为像素，这里设置为 136 像素，可根据实际需求调整尺寸大小
         int width = 136;
+        // 定义图片的高度，单位为像素，此处设置为 38 像素，同样可按需改变尺寸
         int height = 38;
+        // 创建一个 BufferedImage 对象，用于在内存中表示图片，其参数依次为宽度、高度以及图像类型（这里使用 TYPE_INT_RGB 表示 24 位真彩色图像）
         BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
 
-		//获取画笔
+        // 获取用于在图片上绘制内容的画笔对象
         Graphics g = image.getGraphics();
-		//设置画笔颜色为灰色
+        // 设置画笔的颜色为灰色，用于填充图片背景，使背景呈现灰色
         g.setColor(Color.GRAY);
-		//填充图片
+        // 使用设置好颜色的画笔填充整个图片区域，坐标 (0, 0) 表示从图片左上角开始，填充的宽度和高度分别为前面定义的图片宽度和高度
         g.fillRect(0, 0, width, height);
+>>>>>>> develop1
 
-		//产生4个随机验证码，12Ey
+        // 产生 4 个随机验证码的逻辑
+        // 调用 getCheckCode 方法生成一个由随机字符组成的 4 位验证码字符串，例如 "12Ey" 这种形式
         String checkCode = getCheckCode();
-		//将验证码放入HttpSession中
+        // 将生成的验证码字符串存入 HttpSession 中，属性名为 "CHECKCODE_SERVER"，方便后续在其他地方（如登录验证等环节）取出进行比对验证
         request.getSession().setAttribute("CHECKCODE_SERVER", checkCode);
 
-		//设置画笔颜色为黄色
+        // 设置画笔颜色为黄色，以便后续用黄色画笔在图片上绘制验证码字符，使其更清晰可见（颜色可根据实际美观等需求调整）
         g.setColor(Color.YELLOW);
-		//设置字体的小大
+        // 设置绘制文字时使用的字体，这里选择 "黑体"，字体样式为加粗（Font.BOLD），字号大小为 30 像素，可根据验证码图片整体布局和显示效果调整字体相关参数
         g.setFont(new Font("黑体", Font.BOLD, 30));
-		//向图片上写入验证码
+        // 使用设置好的字体和颜色，将验证码字符串绘制到图片上指定的位置，坐标 (36, 28) 表示从图片上距离左边 36 像素、距离上边 28 像素的位置开始绘制，
+        // 具体坐标值可根据验证码在图片中的排版效果进行微调
         g.drawString(checkCode, 36, 28);
 
-		//将内存中的图片输出到浏览器
-		//参数一：图片对象
-		//参数二：图片的格式，如PNG,JPG,GIF
-		//参数三：图片输出到哪里去
+        // 将内存中生成好的图片输出到浏览器的逻辑
+        // 使用 ImageIO 类的 write 方法将图片对象输出到浏览器，参数依次为：要输出的图片对象、图片的格式（这里指定为 "PNG"，也可以是其他常见格式如 JPG、GIF 等）、
+        // 输出的目标流（这里使用 response.getOutputStream() 获取 HttpServletResponse 的输出流，将图片内容直接写入响应流，发送给浏览器）
         ImageIO.write(image, "PNG", response.getOutputStream());
     }
+
     /**
-	 * 产生4位随机字符串 
+     * 产生 4 位随机字符串的方法
+     * 从给定的字符集合中随机选取字符组成一个长度为 4 的字符串，作为验证码字符串返回。
+     *
+     * @return 生成的 4 位随机验证码字符串
      */
     private String getCheckCode() {
+        // 定义一个包含所有可用字符的字符串，用于从中随机选取字符生成验证码，这里排除了容易混淆的数字 0、1 和字母 l、o、O 等，减少用户识别验证码时的混淆情况
         String base = "23456789ABCDEFGHJKMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz";
+        // 获取可用字符集合的长度，用于后续生成随机索引来选取字符
         int size = base.length();
+        // 创建一个 Random 对象，用于生成随机数，它依据系统当前时间作为随机数生成器的种子，产生伪随机数序列
         Random r = new Random();
+        // 创建一个 StringBuffer 对象，用于高效地拼接字符，最终组成验证码字符串
         StringBuffer sb = new StringBuffer();
+        // 通过循环 4 次，每次生成一个随机字符并添加到 StringBuffer 中，最终组成 4 位的验证码字符串
         for (int i = 1; i <= 4; i++) {
-			//产生0到size-1的随机值
+            // 生成一个介于 0（包含）到 size - 1（包含）之间的随机整数索引，用于从 base 字符串中选取字符
             int index = r.nextInt(size);
-			//在base字符串中获取下标为index的字符
+            // 根据生成的随机索引，从 base 字符串中获取对应的字符
             char c = base.charAt(index);
-			//将c放入到StringBuffer中去
+            // 将获取到的字符添加到 StringBuffer 中，逐步构建验证码字符串
             sb.append(c);
         }
+        // 将 StringBuffer 转换为字符串并返回，得到最终的 4 位验证码字符串
         return sb.toString();
     }
+
+    /**
+     * 处理 HTTP POST 请求的方法
+     * 在此类中直接调用 doGet 方法来处理 POST 请求，意味着 GET 请求和 POST 请求在本 Servlet 中的处理逻辑是一样的，
+     * 即当接收到 POST 请求时，同样会执行生成验证码图片等相关操作，并响应给客户端。
+     *
+     * @param request  HttpServletRequest 对象，用于获取请求相关信息
+     * @param response HttpServletResponse 对象，用于设置响应相关内容
+     * @throws ServletException 如果在 Servlet 处理过程中出现异常
+     * @throws IOException      如果在输入输出操作过程中出现异常
+     */
     public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         this.doGet(request, response);
     }
 }
-
-
-

web/WEB-INF/admin/aCDCList.jsp

@@ -1,83 +1,90 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 以上两行是JSP页面的指令声明部分：
+第一行用于设置该JSP页面输出的内容类型为HTML格式（text/html），并指定字符编码为UTF-8，同时表明此页面使用Java语言来编写相应的逻辑代码；
+第二行引入了JSTL（JavaServer Pages Standard Tag Library）的核心标签库，通过定义前缀“c”，后续可以方便地使用该标签库所提供的各种标签进行诸如数据遍历、条件判断等操作 -->
 <html>
 <head>
-    <!-- 设置页面标题为“学院专业查询” -->
+    <!-- 设置页面标题为“学院专业查询”，此标题会显示在浏览器的标题栏位置，让用户直观知晓当前页面的主要功能 -->
     <title>学院专业查询</title>
-    <!-- 引入layui的样式文件，用于页面的样式布局等美化 -->
+    <!-- 引入layui的样式文件，layui.css中包含了众多预先定义好的样式规则，用于实现页面的布局、组件样式等方面的美化效果，能帮助快速搭建出具有一定风格的页面 -->
     <link rel="stylesheet" href="./css/layui.css">
-    <!-- 引入自定义的样式文件，可能包含针对本页面特定的样式设置 -->
+    <!-- 引入自定义的样式文件，style.css文件可以由开发者根据本页面的特定需求来编写样式规则，用于对layui框架默认样式进行补充或者覆盖，以实现更符合业务需求的页面外观展示 -->
     <link rel="stylesheet" href="./css/style.css">
-    <!-- 引入layui的JavaScript文件，layui是一个前端UI框架，提供了很多交互组件等功能 -->
+    <!-- 引入layui的JavaScript文件，layui.js包含了丰富的代码逻辑，实现了诸多交互组件（如表单、表格、菜单等）以及相应的交互功能，是页面实现动态效果的重要依赖 -->
     <script src="./layui.js"></script>
-    <!-- 引入jQuery库的.min压缩版本，jQuery是常用的JavaScript库，方便进行DOM操作、事件处理等 -->
+    <!-- 引入jQuery库的.min压缩版本，jQuery是一个广受欢迎的JavaScript库，它提供了简洁易用的方法来操作DOM元素（例如查找、修改、删除页面元素等）、处理页面事件（如点击、鼠标移动等事件）以及实现动画效果等，极大地方便了前端开发工作 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
-    <!-- 包含用于过滤登录状态的JSP页面，可能用于判断用户是否登录等相关逻辑处理 -->
+    <!-- 设置页面主体的类名为“layui-layout-body”，同时指定背景颜色为#F2F2F2（一种淡灰色），这通常是依据layui框架的布局样式规范来设定的，使得页面呈现出相应的视觉风格 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
-    <!-- 包含管理员头部页面，通常包含页面头部的一些通用元素，比如页面标题、导航栏等 -->
+    <!-- 通过JSP的include指令引入“filterLogin.jsp”页面，该页面一般用于执行用户登录验证相关的逻辑操作，只有当用户成功登录后，才允许访问当前页面展示的内容，起到安全控制的作用 -->
     <jsp:include page="/WEB-INF/admin/aHeader.jsp"></jsp:include>
-    <!-- 包含管理员导航栏页面，用于展示管理员操作相关的导航菜单等 -->
+    <!-- 引入“/WEB-INF/admin/aHeader.jsp”页面，通常这个页面用于构建管理员端页面的头部区域，比如展示系统名称、管理员相关的功能菜单、用户信息等通用元素 -->
     <jsp:include page="/WEB-INF/admin/adminNav.jsp"></jsp:include>
+    <!-- 引入“/WEB-INF/admin/adminNav.jsp”页面，其主要功能是生成管理员端的导航栏，通过该导航栏可以方便管理员在不同的功能模块、业务页面之间进行切换操作 -->
     <div class="layui-layout layui-layout-admin">
         <div class="layui-body">
-            <!-- 内容主体区域 -->
+            <!-- 这是layui框架中定义的用于承载页面主要内容的部分，也就是所谓的内容主体区域，各类核心业务数据展示以及相关操作功能都会放置在此处 -->
             <div style="padding: 15px;">
-                <!-- 使用layui的面包屑组件，展示当前页面的层级导航路径 -->
+                <!-- 使用layui的面包屑组件，通过面包屑可以清晰地向用户展示当前页面在整个系统层级结构中的位置，方便用户了解自己所在的页面路径以及页面之间的关联关系 -->
                 <span class="layui-breadcrumb">
-                    <!-- 面包屑的一级导航，链接指向根路径（此处可能根据实际情况有对应功能） -->
+                    <!-- 面包屑的一级导航，此处设置了一个超链接（href属性虽为空，但可能根据实际情况绑定相应的点击事件或指向根路径相关功能），显示文本为“管理员”，代表当前用户所处的角色层级 -->
                     <a href="">管理员</a>
-                    <!-- 面包屑的二级导航，链接指向学院专业管理相关页面（同样可能有对应功能） -->
+                    <!-- 面包屑的二级导航，同样设置了超链接（可能有对应指向学院专业管理相关页面的功能），显示文本为“学院专业管理”，进一步细化用户所在的业务模块层级 -->
                     <a href="">学院专业管理</a>
-                    <!-- 面包屑的三级导航，显示当前页面的具体名称 -->
+                    <!-- 面包屑的三级导航，这里没有设置超链接，直接通过<cite>标签显示当前页面的具体名称“学院专业查询”，明确当前所处的具体页面 -->
                     <a><cite>学院专业查询</cite></a>
                 </span>
-                <!-- 使用layui的表格组件，用于展示学院专业相关的数据 -->
+                <!-- 使用layui的表格组件来展示学院专业相关的数据，layui-table是layui框架中预定义好样式和交互功能的表格样式类，lay-filter属性通常用于为表格绑定一些特定的筛选、排序等交互功能（此处定义为“test”，后续可能需要相应的JavaScript代码来实现具体交互） -->
                 <table class="layui-table" lay-filter="test">
                     <thead>
                     <tr>
-                        <!-- 表格表头，定义第一列的标题为“ID” -->
+                        <!-- 定义表格表头的第一列标题为“ID”，用于展示每条学院专业相关记录的唯一标识符 -->
                         <th>ID</th>
-                        <!-- 表格表头，定义第二列的标题为“学院” -->
+                        <!-- 定义表格表头的第二列标题为“学院”，用于展示对应的学院名称信息 -->
                         <th>学院</th>
-                        <!-- 表格表头，定义第三列的标题为“专业” -->
+                        <!-- 定义表格表头的第三列标题为“专业”，用于展示所属的专业名称信息 -->
                         <th>专业</th>
-                        <!-- 表格表头，定义第四列的标题为“班级” -->
+                        <!-- 定义表格表头的第四列标题为“班级”，用于展示具体的班级名称信息 -->
                         <th>班级</th>
-                        <!-- 表格表头，定义第五列的标题为“操作”，通常用于放置对数据进行操作的按钮等 -->
+                        <!-- 定义表格表头的第五列标题为“操作”，这一列通常用于放置对表格中每一条数据记录进行操作的按钮等交互元素，比如删除、编辑等操作按钮 -->
                         <th>操作</th>
                     </tr>
                     </thead>
-                    <!-- 使用JSTL的forEach标签循环遍历名为“cdcs”的集合（应该是在后台传递过来的学院专业相关数据集合） -->
+                    <!-- 使用JSTL的forEach标签对名为“cdcs”的集合进行循环遍历，这个集合通常是由后端程序传递过来的、包含学院专业相关数据的集合，每一个元素代表一条具体的学院专业记录 -->
                     <c:forEach items="${cdcs}" var="cdc" varStatus="c">
                         <tr>
-                            <!-- 在表格行中显示当前循环的序号（从1开始计数） -->
+                            <!-- 在表格行的第一列单元格中显示当前循环的序号，通过varStatus对象的count属性来实现计数功能，序号从1开始，方便用户查看数据的顺序 -->
                             <td>${c.count}</td>
-                            <!-- 在表格行中显示当前循环对象（cdc）中的学院名称属性值 -->
+                            <!-- 在表格行的第二列单元格中显示当前循环对象（cdc）中的学院名称属性值，该属性值应该是从后端传递过来的数据对象中提取出来的，用于展示具体的学院名称信息 -->
                             <td>${cdc.college}</td>
-                            <!-- 在表格行中显示当前循环对象（cdc）中的专业名称属性值 -->
+                            <!-- 在表格行的第三列单元格中显示当前循环对象（cdc）中的专业名称属性值，同样是从后端数据对象中获取对应属性值来展示具体的专业名称 -->
                             <td>${cdc.department}</td>
-                            <!-- 在表格行中显示当前循环对象（cdc）中的班级名称属性值 -->
+                            <!-- 在表格行的第四列单元格中显示当前循环对象（cdc）中的班级名称属性值，用于展示具体的班级名称情况 -->
                             <td>${cdc.cclass}</td>
-                            <!-- 在表格行的操作列中添加一个删除按钮，按钮样式为layui的危险按钮样式，点击时调用JavaScript中的deleteCDC函数（目前函数未定义完整，可能需要补充具体删除逻辑） -->
+                            <!-- 在表格行的第五列（操作列）单元格中添加一个删除按钮，按钮应用了layui的危险按钮样式（layui-btn-danger），使其在视觉上更醒目地提示用户操作的危险性；
+                            点击该按钮时会调用JavaScript中的deleteCDC函数（目前函数未定义完整，后续需要补充具体的删除逻辑，比如向服务器发送删除请求等相关操作） -->
                             <td><a class="layui-btn layui-btn-danger" href="javascript:deleteCDC();">删除</a></td>
                         </tr>
                     </c:forEach>
                 </table>
-                <!-- 包含页面底部相关内容的JSP页面，可能包含版权信息、联系方式等通用的底部元素 -->
+                <!-- 引入“/footer.jsp”页面，通常这个页面用于展示页面底部的相关信息，例如版权声明、联系方式、网站相关的友情链接等通用的底部元素 -->
                 <jsp:include page="/footer.jsp"></jsp:include>
             </div>
         </div>
     </div>
 
 
-    <!-- 使用jQuery选择器选择特定的DOM元素（此处可能是导航栏中的某个元素）并添加类名“layui-this”，用于设置样式等相关操作（具体功能取决于对应的CSS样式定义） -->
+    <!-- 使用jQuery选择器（通过特定的选择表达式）选择导航栏中特定的DOM元素（此处是第4个li元素下的第一个dl元素下的第一个dd元素），并为其添加类名“layui-this”，
+    一般来说，添加这个类名是为了通过CSS样式来改变该元素的外观，使其呈现出与其他导航项不同的样式效果，用于标识当前选中的导航项或者处于特定状态的导航项（具体样式效果取决于对应的CSS定义） -->
     <script type="text/javascript">
         $("#nav li:nth-child(4) dl dd:nth-child(1)").addClass("layui-this");
         $("#nav li:nth-child(4)").addClass("layui-nav-itemed");
     </script>
-    <!-- 使用layui框架的element模块，进行相关初始化操作，element模块通常用于实现页面的交互元素（如折叠面板、导航栏等）的功能 -->
+    <!-- 使用layui框架提供的use方法来加载“element”模块，在加载完成后的回调函数里获取该模块的实例（将其赋值给变量“element”），然后调用实例的“init”方法进行初始化操作。
+    “element”模块在layui框架中主要负责处理页面元素相关的交互逻辑，例如菜单的展开与收起、选项卡的切换等功能的初始化工作，确保这些交互元素能正常展示和使用 -->
     <script>
         //JavaScript代码区域
         layui.use('element', function(){

web/WEB-INF/admin/adminNav.jsp

@@ -1,90 +1,92 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
-    <!-- 设置页面的字符编码为UTF-8，确保页面能正确显示各种字符 -->
+    <!-- 设置页面的字符编码为UTF-8，确保页面能正确显示各种字符，包括中文、特殊符号等不同语言的字符内容 -->
     <meta charset="utf-8">
-    <!-- 设置页面的视口（viewport）相关属性，让页面在不同设备上能自适应显示。
-         width=device-width表示页面宽度与设备屏幕宽度相同，
-         initial-scale=1表示初始缩放比例为1，
-         maximum-scale=1表示最大缩放比例为1，即限制用户不能对页面进行缩放操作 -->
+    <!-- 设置页面的视口（viewport）相关属性，让页面在不同设备（如手机、平板、电脑等）上能自适应显示，具体含义如下：
+         width=device-width表示页面宽度与设备屏幕宽度相同，使得页面能根据设备屏幕大小进行自适应调整宽度；
+         initial-scale=1表示初始缩放比例为1，即页面初始显示时按照原始设计大小呈现，不进行缩放；
+         maximum-scale=1表示最大缩放比例为1，意味着限制用户不能对页面进行缩放操作，保持页面布局的稳定性 -->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
 </head>
 <body class="layui-layout-body">
-    <!-- 创建一个layui布局的容器，用于构建页面的整体布局结构，layui是一个前端UI框架 -->
+    <!-- 创建一个layui布局的容器，layui是一个前端UI框架，通过使用其特定的布局类和样式，能够方便地构建出具有一定规范和交互功能的页面整体布局结构 -->
     <div class="layui-layout layui-layout-admin">
-        <!-- 创建页面左侧的侧边栏区域，设置背景颜色为黑色（layui-bg-black） -->
+        <!-- 创建页面左侧的侧边栏区域，应用layui的背景颜色样式类layui-bg-black，将侧边栏背景设置为黑色，用于视觉上区分不同的页面区域 -->
         <div class="layui-side layui-bg-black">
-            <!-- 创建一个可滚动的区域，用于放置侧边栏内容，当内容超出侧边栏高度时可以滚动查看 -->
+            <!-- 创建一个可滚动的区域，当侧边栏内的内容超出侧边栏本身的高度时，用户可以通过滚动条来查看全部内容，提升页面的可浏览性和用户体验 -->
             <div class="layui-side-scroll">
-                <!-- 左侧导航区域，使用layui的导航组件（layui-nav），以树形结构展示（layui-nav-tree），并设置了过滤器（lay-filter="test"）用于后续交互操作，同时设置了id为“nav”方便通过JavaScript等进行操作 -->
+                <!-- 左侧导航区域，使用layui的导航组件（layui-nav），以树形结构展示（layui-nav-tree），这种结构便于展示具有层级关系的菜单选项；
+                同时设置了过滤器（lay-filter="test"），用于后续与JavaScript等脚本语言配合实现一些交互操作，比如菜单点击事件的处理等；
+                并且设置了id为“nav”，方便通过JavaScript代码根据这个id来精准地获取和操作该导航元素 -->
                 <ul class="layui-nav layui-nav-tree"  lay-filter="test" id="nav">
-                    <!-- 一个导航菜单项，代表一级菜单，使用layui-nav-item类来应用相应的样式 -->
+                    <!-- 一个导航菜单项，代表一级菜单，应用layui-nav-item类来添加相应的样式，使其在视觉上呈现出符合layui框架风格的菜单样式 -->
                     <li class="layui-nav-item">
-                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“选课信息管理” -->
+                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空，即点击时不会跳转到其他页面），显示文本为“选课信息管理”，用于提示用户该菜单所代表的功能板块 -->
                         <a class="" href="javascript:;">选课信息管理</a>
-                        <!-- 一级菜单下的子菜单列表，使用dl标签配合layui的样式来展示子菜单 -->
+                        <!-- 一级菜单下的子菜单列表，使用dl标签配合layui的样式来展示子菜单，符合HTML语义化和layui框架对于菜单结构的规范 -->
                         <dl class="layui-nav-child">
-                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/studentSelectCourseListServlet）跳转到选课列表页面 -->
+                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/studentSelectCourseListServlet）跳转到选课列表页面，这里利用了服务器端的请求路径配置来实现页面导航功能 -->
                             <dd><a href="${pageContext.request.contextPath}/studentSelectCourseListServlet">选课列表</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/studentOptionalCourseServlet）跳转到可选课程页面 -->
+                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/studentOptionalCourseServlet）跳转到可选课程页面，同样借助服务器端配置的路径来实现页面跳转 -->
                             <dd><a href="${pageContext.request.contextPath}/studentOptionalCourseServlet">可选课程</a></dd>
                         </dl>
                     </li>
-                    <!-- 一个导航菜单项，代表一级菜单，使用layui-nav-item类来应用相应的样式 -->
+                    <!-- 一个导航菜单项，代表一级菜单，应用layui-nav-item类来添加相应的样式 -->
                     <li class="layui-nav-item">
-                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“学生管理” -->
+                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“学生管理”，用于标识该菜单对应的功能分类 -->
                         <a class="" href="javascript:;">学生管理</a>
                         <!-- 一级菜单下的子菜单列表，使用dl标签配合layui的样式来展示子菜单 -->
                         <dl class="layui-nav-child">
-                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/findStudentByPageServlet）跳转到查询学生页面 -->
+                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/findStudentByPageServlet）跳转到查询学生页面，通过服务器端配置的请求路径实现页面跳转 -->
                             <dd><a href="${pageContext.request.contextPath}/findStudentByPageServlet">查询学生</a></dd>
-                            <!-- 一个隐藏的子菜单选项（通过hidden属性隐藏），id为“hidden-update”，点击后暂时无实际跳转动作（href="#"表示链接到当前页面顶部），显示文本为“修改学生信息”，可能后续通过JavaScript等操作来显示并赋予实际功能 -->
+                            <!-- 一个隐藏的子菜单选项（通过hidden属性隐藏），设置了id为“hidden-update”，点击后暂时无实际跳转动作（href="#"表示链接到当前页面顶部），显示文本为“修改学生信息”，可能后续通过JavaScript等操作来显示并赋予实际功能，比如在满足某些条件下将其显示出来供用户点击操作 -->
                             <dd hidden id="hidden-update"><a href="#">修改学生信息</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/addStudentServlet）跳转到增加学生页面 -->
+                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/addStudentServlet）跳转到增加学生页面，依靠服务器端配置的请求路径来实现页面导航 -->
                             <dd><a href="${pageContext.request.contextPath}/addStudentServlet">增加学生</a></dd>
                         </dl>
                     </li>
-                    <!-- 一个导航菜单项，代表一级菜单，使用layui-nav-item类来应用相应的样式 -->
+                    <!-- 一个导航菜单项，代表一级菜单，应用layui-nav-item类来添加相应的样式 -->
                     <li class="layui-nav-item">
-                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“教师管理” -->
+                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“教师管理”，用于表明该菜单对应的管理功能范围 -->
                         <a class="" href="javascript:;">教师管理</a>
                         <!-- 一级菜单下的子菜单列表，使用dl标签配合layui的样式来展示子菜单 -->
                         <dl class="layui-nav-child">
-                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/teacherListServlet）跳转到查询教师页面 -->
+                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/teacherListServlet）跳转到查询教师页面，借助服务器端配置的请求路径实现页面跳转 -->
                             <dd><a href="${pageContext.request.contextPath}/teacherListServlet">查询教师</a></dd>
-                            <!-- 一个隐藏的子菜单选项（通过hidden属性隐藏），id为“hidden-update2”，点击后暂时无实际跳转动作（href="#"表示链接到当前页面顶部），显示文本为“修改教师信息”，可能后续通过JavaScript等操作来显示并赋予实际功能 -->
+                            <!-- 一个隐藏的子菜单选项（通过hidden属性隐藏），设置了id为“hidden-update2”，点击后暂时无实际跳转动作（href="#"表示链接到当前页面顶部），显示文本为“修改教师信息”，可能后续通过JavaScript等操作来显示并赋予实际功能 -->
                             <dd hidden id="hidden-update2"><a href="#">修改教师信息</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/addTeacherServlet）跳转到增加教师页面 -->
+                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/addTeacherServlet）跳转到增加教师页面，依靠服务器端配置的请求路径来实现页面导航 -->
                             <dd><a href="${pageContext.request.contextPath}/addTeacherServlet">增加教师</a></dd>
                         </dl>
                     </li>
-                    <!-- 一个导航菜单项，代表一级菜单，使用layui-nav-item类来应用相应的样式 -->
+                    <!-- 一个导航菜单项，代表一级菜单，应用layui-nav-item类来添加相应的样式 -->
                     <li class="layui-nav-item">
-                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“学院专业管理” -->
+                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“学院专业管理”，用于提示该菜单对应的功能板块 -->
                         <a class="" href="javascript:;">学院专业管理</a>
                         <!-- 一级菜单下的子菜单列表，使用dl标签配合layui的样式来展示子菜单 -->
                         <dl class="layui-nav-child">
-                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/cdcListServlet）跳转到学院专业查询页面 -->
+                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/cdcListServlet）跳转到学院专业查询页面，通过服务器端配置的请求路径实现页面跳转 -->
                             <dd><a href="${pageContext.request.contextPath}/cdcListServlet">学院专业查询</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后暂时无实际跳转动作（href="#"表示链接到当前页面顶部），显示文本为“学院专业增加”，可能后续通过JavaScript等操作来赋予实际功能 -->
+                            <!-- 子菜单中的另一个选项，点击后暂时无实际跳转动作（href="#"表示链接到当前页面顶部），显示文本为“学院专业增加”，可能后续通过JavaScript等操作来赋予实际功能，比如在合适的时机触发相应的业务逻辑实现增加学院专业的功能 -->
                             <dd><a href="#">学院专业增加</a></dd>
                         </dl>
                     </li>
-                    <!-- 一个导航菜单项，代表一级菜单，使用layui-nav-item类来应用相应的样式 -->
+                    <!-- 一个导航菜单项，代表一级菜单，应用layui-nav-item类来添加相应的样式 -->
                     <li class="layui-nav-item">
-                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“系统管理” -->
+                        <!-- 一级菜单的链接文本，点击暂时无实际跳转动作（href="javascript:;"表示执行一段JavaScript代码，此处为空），显示文本为“系统管理”，用于标识该菜单对应的功能分类 -->
                         <a class="" href="javascript:;">系统管理</a>
                         <!-- 一级菜单下的子菜单列表，使用dl标签配合layui的样式来展示子菜单 -->
                         <dl class="layui-nav-child">
-                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/notifyServlet）跳转到公告发布页面 -->
+                            <!-- 子菜单中的一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/notifyServlet）跳转到公告发布页面，借助服务器端配置的请求路径实现页面跳转 -->
                             <dd><a href="${pageContext.request.contextPath}/notifyServlet">公告发布</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/notifyListServlet）跳转到公告列表页面 -->
+                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/notifyListServlet）跳转到公告列表页面，依靠服务器端配置的请求路径来实现页面导航 -->
                             <dd><a href="${pageContext.request.contextPath}/notifyListServlet">公告列表</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/fileServlet）跳转到文件发布页面 -->
+                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/fileServlet）跳转到文件发布页面，通过服务器端配置的请求路径实现页面跳转 -->
                             <dd><a href="${pageContext.request.contextPath}/fileServlet">文件发布</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/fileListServlet）跳转到文件列表页面 -->
+                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/fileListServlet）跳转到文件列表页面，依靠服务器端配置的请求路径来实现页面导航 -->
                             <dd><a href="${pageContext.request.contextPath}/fileListServlet">文件列表</a></dd>
-                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/adminPasswordIndexServlet）跳转到修改密码页面 -->
+                            <!-- 子菜单中的另一个选项，点击后通过EL表达式指定的路径（${pageContext.request.contextPath}/adminPasswordIndexServlet）跳转到修改密码页面，借助服务器端配置的请求路径实现页面跳转 -->
                             <dd><a href="${pageContext.request.contextPath}/adminPasswordIndexServlet">修改密码</a></dd>
                         </dl>
                     </li>

web/WEB-INF/notify/addNotify.jsp

@@ -1,29 +1,43 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 以上两行是JSP页面的指令，第一行设置页面内容类型为HTML且编码为UTF-8，语言为Java；
+第二行引入JSTL核心标签库，方便在页面中进行逻辑处理等操作 -->
 <html>
 <head>
     <title>公告发布</title>
+    <!-- 设置页面标题为“公告发布” -->
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入layui的样式文件，用于页面布局和样式美化 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的style.css样式文件，可能包含针对该页面的特定样式 -->
     <script src="./layui.js"></script>
+    <!-- 引入layui的JavaScript脚本文件，提供各种交互功能等 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 引入jQuery库，方便进行DOM操作、事件处理等 -->
     <style type="text/css">
        .input-block {
             margin-left: 0px;
             min-height: 36px;
         }
+        /* 定义类名为.input-block的样式，设置左边距为0像素，最小高度为36像素 */
         #addnotifybutton {
             text-align: center;
         }
+        /* 定义id为addnotifybutton的元素样式，使其内部文本居中对齐 */
        .layui-btn {
             width: 30%;
         }
+        /* 定义类名为layui-btn的按钮样式，设置宽度为30% */
     </style>
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 设置页面主体的类名和背景颜色，可能与layui的布局样式相关 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 包含filterLogin.jsp页面，可能用于登录验证等相关功能 -->
     <jsp:include page="/WEB-INF/admin/aHeader.jsp"></jsp:include>
+    <!-- 包含aHeader.jsp页面，通常用于页面头部布局等内容 -->
     <jsp:include page="/WEB-INF/admin/adminNav.jsp"></jsp:include>
+    <!-- 包含adminNav.jsp页面，一般用于展示页面导航栏相关内容 -->
     <div class="layui-layout layui-layout-admin">
         <div class="layui-body">
             <!-- 内容主体区域 -->
@@ -33,16 +47,20 @@
                     <a>系统管理</a>
                     <a><cite>公告发布</cite></a>
                 </span>
+                <!-- 展示面包屑导航，显示当前页面在系统中的层级位置 -->
                 <p> &nbsp;</p>
                 <form action="${pageContext.request.contextPath}/addNotifyServlet" method="post">
+                    <!-- 创建一个表单，表单提交的目标地址是addNotifyServlet，提交方式为POST -->
                     <div class="input-block">
                         <textarea name="notifyInfo" placeholder="请输入内容" class="layui-textarea" required lay-verify="required"></textarea>
+                        <!-- 创建一个文本域，用于输入公告内容，设置了名称、占位提示文本、样式类以及必填验证等属性 -->
                         <p>
                     </div>
                     <%--    <input type="text" name="notifyInfo" />--%>
                     <div id="addnotifybutton">
                         <button type="submit" class="layui-btn">发布</button>
                     </div>
+                    <!-- 创建一个按钮，类型为提交按钮，样式类为layui-btn，点击时会提交表单 -->
                 </form>
 
                 <table class="layui-table" lay-filter="test">
@@ -54,7 +72,7 @@
                         <th>操作</th>
                     </tr>
                     </thead>
-
+                    <!-- 定义表格的表头，包含公告ID、日期、内容和操作列 -->
                     <c:forEach items="${notifys}" var="notify">
                     <tr>
                         <td>${notify.id}</td>
@@ -63,9 +81,12 @@
                         <td><button class="layui-btn layui-btn-normal">修改</button><button class="layui-btn layui-btn-danger">删除</button></td>
                     </tr>
                     </c:forEach>
+                    <!-- 使用JSTL的forEach标签循环遍历notifys集合，将每个元素（这里假设是公告对象）的数据展示在表格行中，
+                    每行包含公告的相关信息以及修改和删除按钮 -->
                 </table>
 
                 <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含footer.jsp页面，通常用于页面底部相关内容展示，比如版权信息等 -->
             </div>
         </div>
     </div>
@@ -73,7 +94,11 @@
 
     <script type="text/javascript">
         $("#nav li:nth-child(5) dl dd:nth-child(1)").addClass("layui-this");
+        // 使用jQuery选择器选中特定的导航栏元素（第5个li下的第一个dl下的第一个dd），并添加类名layui-this，
+        // 可能用于标记当前选中的导航项样式
         $("#nav li:nth-child(5)").addClass("layui-nav-itemed");
+        // 使用jQuery选择器选中特定的导航栏元素（第5个li），并添加类名layui-nav-itemed，
+        // 可能用于展开或标记特定导航栏的展开状态相关样式
     </script>
     <script>
         //JavaScript代码区域
@@ -81,8 +106,8 @@
             var element = layui.element;
             element.init();
         });
+        // 使用layui框架的element模块，调用init方法进行初始化，可能用于初始化页面的一些交互元素等功能
     </script>
 
 </body>
 </html>
-

web/WEB-INF/notify/notifyList.jsp

@@ -1,26 +1,39 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 上述两行是JSP页面的指令：
+第一行设置页面内容类型为HTML，编码格式为UTF-8，并且指定使用Java语言；
+第二行引入JSTL（JavaServer Pages Standard Tag Library）的核心标签库，方便在页面中进行一些逻辑处理、数据遍历等操作 -->
 <html>
 <head>
     <title>公告列表</title>
+    <!-- 设置页面的标题为“公告列表”，该标题会显示在浏览器的标题栏 -->
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入layui框架的样式文件，layui.css用于实现页面的布局、样式美化等功能 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的style.css样式文件，可能包含针对本页面特有的样式规则，用于进一步定制页面外观 -->
     <script src="./layui.js"></script>
+    <!-- 引入layui框架的JavaScript脚本文件，提供了众多交互功能、组件等相关的代码逻辑 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 引入jQuery库，它是一个广泛使用的JavaScript库，便于进行DOM操作、事件处理、动画效果等各种前端开发任务 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 设置页面主体的类名为layui-layout-body，并指定背景颜色为浅灰色（#F2F2F2），可能是基于layui框架的布局样式规范 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 通过JSP的include指令包含filterLogin.jsp页面，通常用于处理用户登录验证等相关逻辑，保证只有登录后的用户能访问本页面 -->
     <jsp:include page="/WEB-INF/admin/aHeader.jsp"></jsp:include>
+    <!-- 包含aHeader.jsp页面，一般用于构建页面的头部区域，比如展示网站名称、导航栏等内容 -->
     <jsp:include page="/WEB-INF/admin/adminNav.jsp"></jsp:include>
+    <!-- 包含adminNav.jsp页面，大概率是用于展示页面的导航菜单，方便用户在不同功能页面之间进行切换 -->
     <div class="layui-layout layui-layout-admin">
         <div class="layui-body">
-        <!-- 内容主体区域 -->
+            <!-- 内容主体区域，layui框架中用于承载页面主要内容的部分 -->
             <div style="padding: 15px;">
                 <span class="layui-breadcrumb">
                     <a>管理员</a>
                     <a>系统管理</a>
                     <a><cite>公告列表</cite></a>
                 </span>
+                <!-- 展示面包屑导航，清晰地呈现当前页面在整个系统层级结构中的位置，方便用户知晓所在路径 -->
                 <p> &nbsp;</p>
 
                 <table class="layui-table" lay-filter="test">
@@ -33,7 +46,9 @@
                         <th>操作</th>
                     </tr>
                     </thead>
-
+                    <!-- 定义表格的表头部分：
+                    第一个<th>中创建了一个带有layui样式的复选框，可能用于批量操作（如批量删除等）；
+                    后续的<th>分别定义了公告ID、公告日期、公告内容和操作列的表头名称 -->
                     <c:forEach items="${notifys}" var="notify" varStatus="n">
                     <tr>
                         <th><input type="checkbox" class="my-checkbox" name="" title="" lay-skin="primary"></th>
@@ -43,9 +58,17 @@
                         <td><a class="layui-btn layui-btn-danger" href="javascript:deleteNotify(${notify.id});">删除</a></td>
                     </tr>
                     </c:forEach>
+                    <!-- 使用JSTL的forEach标签循环遍历名为notifys的集合（通常是从后端传递过来的公告数据列表）：
+                    对于每个公告元素（用notify变量表示），创建表格的一行<tr>：
+                    第一个<td>同样创建一个复选框；
+                    第二个<td>使用varStatus属性的count属性展示序号（从1开始计数）；
+                    第三个<td>展示公告的日期；
+                    第四个<td>展示公告的内容；
+                    第五个<td>创建一个带有layui样式的删除按钮，点击按钮会调用JavaScript函数deleteNotify，并传递当前公告的ID作为参数 -->
                 </table>
 
                 <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含footer.jsp页面，通常用于展示页面底部的相关信息，比如版权声明、联系方式等内容 -->
             </div>
         </div>
     </div>
@@ -53,7 +76,11 @@
 
     <script type="text/javascript">
         $("#nav li:nth-child(5) dl dd:nth-child(2)").addClass("layui-this");
+        // 使用jQuery选择器选中特定的导航栏元素（第5个li下的第二个dl下的第二个dd），并添加类名layui-this，
+        // 可能用于标记当前选中的导航项样式，使其呈现出与其他导航项不同的视觉效果，表明当前所在页面为“公告列表”相关页面
         $("#nav li:nth-child(5)").addClass("layui-nav-itemed");
+        // 使用jQuery选择器选中特定的导航栏元素（第5个li），并添加类名layui-nav-itemed，
+        // 可能用于展开或标记特定导航栏的展开状态相关样式，以展示对应的二级导航等内容
     </script>
     <script>
         //JavaScript代码区域
@@ -61,6 +88,8 @@
             var element = layui.element;
             element.init();
         });
+        // 使用layui框架的element模块，调用init方法进行初始化，可能用于初始化页面的一些交互元素、组件等功能，
+        // 比如菜单的展开收起、选项卡切换等交互效果的初始化
     </script>
 
     <script>
@@ -69,7 +98,10 @@
                 location.href = "${pageContext.request.contextPath}/deleteNotifyServlet?id=" + n_id;
             }
         }
+        // 定义名为deleteNotify的JavaScript函数，接收一个参数n_id（公告的ID）：
+        // 首先通过confirm函数弹出一个确认框，询问用户是否确定删除该通知；
+        // 如果用户点击确认（点击“确定”按钮），则将页面重定向到后端的deleteNotifyServlet，并通过URL参数传递要删除的公告ID，
+        // 由后端的这个Servlet来处理实际的删除逻辑
     </script>
 </body>
 </html>
-

web/WEB-INF/notify/notifyListToStudent.jsp

@@ -1,25 +1,38 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 以上两行是JSP页面的相关指令：
+第一行用于设置该JSP页面输出的内容类型为text/html（即HTML格式），字符编码采用UTF-8，同时指定页面使用的编程语言为Java；
+第二行引入了JSTL（JavaServer Pages Standard Tag Library）核心标签库，通过指定的前缀“c”，后续就能在页面中方便地使用该库提供的各种标签进行逻辑处理、数据展示等操作 -->
 <html>
 <head>
     <title>公告列表</title>
+    <!-- 设置当前HTML页面的标题为“公告列表”，这个标题通常会显示在浏览器的标题栏位置 -->
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入layui框架的样式表文件，layui.css中定义了诸多用于页面布局、组件样式等方面的样式规则，能帮助快速搭建出具有一定风格的页面 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的style.css样式文件，这里面可以包含针对当前页面特殊需求所定制的一些样式，用于覆盖或补充layui框架样式的不足 -->
     <script src="./layui.js"></script>
+    <!-- 引入layui框架对应的JavaScript脚本文件，layui.js包含了实现各种交互功能、组件逻辑等的代码，是页面实现动态效果的重要依赖 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 引入jQuery库，jQuery是一个非常流行的JavaScript库，它提供了简洁易用的方法来操作DOM元素、处理事件、实现动画效果等，方便前端开发 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 设置页面主体的类名为“layui-layout-body”，同时指定背景颜色为#F2F2F2（一种淡灰色），这可能是基于layui框架的布局样式要求，使页面呈现出相应的外观效果 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 通过JSP的include指令包含名为“filterLogin.jsp”的页面，通常这个页面用于处理用户登录验证相关的逻辑，确保只有合法登录的用户才能访问当前页面的内容 -->
     <jsp:include page="/WEB-INF/student/sHeader.jsp"></jsp:include>
+    <!-- 包含“/WEB-INF/student/sHeader.jsp”页面，一般来说，这个页面用于构建学生端页面的头部区域，比如展示学校标识、学生相关的功能菜单等 -->
     <jsp:include page="/WEB-INF/student/studentNav.jsp"></jsp:include>
+    <!-- 包含“/WEB-INF/student/studentNav.jsp”页面，大概率是用于生成学生端的导航栏，方便学生在不同的功能模块或页面之间进行切换 -->
     <div class="layui-layout layui-layout-admin">
         <div class="layui-body">
-        <!-- 内容主体区域 -->
+            <!-- 这里是layui框架中用于承载页面主要内容的部分，也就是内容主体区域 -->
             <div style="padding: 15px;">
                 <span class="layui-breadcrumb">
                     <a>学生端</a>
                     <a><cite>公告列表</cite></a>
                 </span>
+                <!-- 展示面包屑导航，通过这种方式可以清晰地向学生展示当前页面在整个学生端系统层级结构中的位置，便于他们了解所处的页面路径 -->
                 <p> &nbsp;</p>
 
                 <table class="layui-table" lay-filter="test">
@@ -30,7 +43,7 @@
                         <th>公告内容</th>
                     </tr>
                     </thead>
-
+                    <!-- 定义表格的表头部分，分别创建了三个列标题，用于表示公告的ID、发布日期以及具体的内容，后续数据会按照这个表头结构进行展示 -->
                     <c:forEach items="${notifys}" var="notify" varStatus="n">
                     <tr>
                         <td>${n.count}</td>
@@ -38,9 +51,15 @@
                         <td>${notify.notifyInfo}</td>
                     </tr>
                     </c:forEach>
+                    <!-- 使用JSTL的forEach标签对名为“notifys”的集合进行循环遍历，这个集合通常是从后端传递过来的公告数据列表。
+                    对于列表中的每一个公告元素（用“notify”变量表示），创建表格中的一行（<tr>标签）来展示对应公告的数据：
+                    第一个<td>单元格展示序号（通过varStatus的count属性实现，从1开始计数）；
+                    第二个<td>单元格展示公告的发布日期；
+                    第三个<td>单元格展示公告的具体内容 -->
                 </table>
 
                 <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含“/footer.jsp”页面，通常这个页面用于展示页面底部的相关信息，比如版权声明、联系方式、页面底部的导航链接等内容 -->
             </div>
         </div>
     </div>
@@ -48,12 +67,13 @@
 
 
     <script>
-    //JavaScript代码区域
+        //JavaScript代码区域，以下代码用于初始化layui框架的相关功能模块
         layui.use('element', function(){
             var element = layui.element;
             element.init();
         });
+        // 通过layui.use方法调用“element”模块，并在回调函数中获取该模块的实例（赋值给“element”变量），然后调用其“init”方法进行初始化操作。
+        // “element”模块通常用于处理页面元素相关的交互逻辑，例如菜单的展开与收起、选项卡的切换等功能的初始化
     </script>
 </body>
 </html>
-

web/WEB-INF/notify/notifyListToTeacher.jsp

@@ -1,25 +1,38 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 以上两行是JSP页面的指令声明：
+第一行设置此JSP页面输出内容的类型为HTML格式（text/html），并且指定字符编码为UTF-8，同时表明该页面使用Java语言来编写相关逻辑代码；
+第二行引入了JSTL（JavaServer Pages Standard Tag Library）的核心标签库，定义了前缀“c”，后续就能利用这个标签库提供的标签在页面里进行诸如数据遍历、条件判断等操作 -->
 <html>
 <head>
     <title>公告列表</title>
+    <!-- 设置HTML页面的标题为“公告列表”，这个标题会显示在浏览器的标题栏上，让用户直观知晓当前页面的主要内容 -->
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入layui框架的样式表文件，layui.css里面包含了众多用于页面布局设计、各种组件样式定义等的样式规则，借助它可以快速搭建出风格统一的页面外观 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的style.css样式文件，通常是开发者根据页面的特定需求编写的，用于对layui框架的默认样式进行补充或者覆盖，实现更个性化的页面展示效果 -->
     <script src="./layui.js"></script>
+    <!-- 引入layui框架对应的JavaScript文件，layui.js包含了大量实现页面交互功能、各种组件业务逻辑等的代码，是让页面具备动态交互能力的关键所在 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 引入jQuery库，jQuery是一个广泛应用的JavaScript库，它提供了简洁且方便的方法来操作DOM元素、处理页面事件、实现动画效果等，能极大地简化前端开发工作 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 设置页面主体的类名为“layui-layout-body”，并指定背景颜色为#F2F2F2（一种淡灰色），这大概率是依据layui框架的布局样式规范来设定的，以此营造出特定的页面视觉风格 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 通过JSP的include指令引入“filterLogin.jsp”页面，一般情况下，这个页面用于执行用户登录验证相关的逻辑操作，只有当用户成功登录后，才能继续访问当前页面展示的内容 -->
     <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <!-- 引入“/WEB-INF/teacher/tHeader.jsp”页面，通常该页面用于构建教师端页面的头部区域，例如展示学校名称、教师相关的功能菜单、个人信息等内容 -->
     <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 引入“/WEB-INF/teacher/teacherNav.jsp”页面，其主要作用是生成教师端的导航栏，方便教师在不同的功能模块、业务页面之间进行切换操作 -->
     <div class="layui-layout layui-layout-admin">
         <div class="layui-body">
-        <!-- 内容主体区域 -->
+            <!-- 这是layui框架中定义的用于承载页面主要内容的部分，也就是所谓的内容主体区域，各种核心业务数据、功能展示都会放置在此处 -->
             <div style="padding: 15px;">
                 <span class="layui-breadcrumb">
                     <a>教师端</a>
                     <a><cite>公告列表</cite></a>
                 </span>
+                <!-- 展示面包屑导航，通过这种方式可以清晰地向教师展示当前页面在整个教师端系统的层级结构中所处的位置，方便教师了解自己当前所在的页面路径 -->
                 <p> &nbsp;</p>
 
                 <table class="layui-table" lay-filter="test">
@@ -30,7 +43,7 @@
                         <th>公告内容</th>
                     </tr>
                     </thead>
-
+                    <!-- 定义表格的表头部分，这里创建了三个列标题，分别用于展示公告的唯一标识符（公告ID）、公告发布的具体日期以及公告包含的详细内容，后续表格行的数据会按照这个表头结构来依次填充 -->
                     <c:forEach items="${notifys}" var="notify" varStatus="n">
                     <tr>
                         <td>${n.count}</td>
@@ -38,9 +51,15 @@
                         <td>${notify.notifyInfo}</td>
                     </tr>
                     </c:forEach>
+                    <!-- 使用JSTL的forEach标签对名为“notifys”的集合进行循环遍历，这个集合通常是由后端程序传递过来的公告数据列表。
+                    针对列表里的每一条公告数据（用变量“notify”表示），都会创建一个表格行（<tr>标签）来展示对应公告的相关信息：
+                    第一个<td>单元格展示的是序号，通过varStatus对象的count属性来实现计数功能，序号从1开始；
+                    第二个<td>单元格展示的是该公告的发布日期；
+                    第三个<td>单元格展示的是该公告包含的具体内容 -->
                 </table>
 
                 <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 引入“/footer.jsp”页面，一般来说，这个页面用于展示页面底部的相关信息，像版权声明、联系方式、网站相关的友情链接等内容 -->
             </div>
         </div>
     </div>
@@ -48,12 +67,13 @@
 
 
     <script>
-    //JavaScript代码区域
+        //JavaScript代码区域，以下代码的目的是初始化layui框架的相关功能模块，使其能正常工作并提供相应的交互功能
         layui.use('element', function(){
             var element = layui.element;
             element.init();
         });
+        // 通过layui框架提供的use方法来加载“element”模块，在加载完成后的回调函数里获取该模块的实例（将其赋值给变量“element”），然后调用实例的“init”方法进行初始化操作。
+        // “element”模块在layui框架中主要负责处理页面元素相关的交互逻辑，例如菜单的展开与收起、选项卡的切换等功能的初始化工作
     </script>
 </body>
 </html>
-

web/WEB-INF/teacher/addOptionalCourse.jsp

@@ -1,54 +1,84 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- 这是JSP页面的指令，用于设置页面的内容类型为"text/html"，字符编码为UTF-8，并且指定页面使用的编程语言是Java，确保页面能够正确地处理和显示文本内容，避免中文等特殊字符出现乱码问题，并告知服务器该页面是基于Java语言开发的JSP页面。 -->
+
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 引入JSTL（JavaServer Pages Standard Tag Library）核心标签库，通过设置前缀"c"，后续就可以在页面中使用以"c"开头的各种JSTL标签，方便进行如条件判断、循环遍历、数据输出等常见的操作，增强JSP页面的逻辑处理能力。 -->
+
 <html>
 <head>
     <title>添加课程</title>
+    <!-- 设置HTML页面的标题，在浏览器的标题栏中会显示该标题，方便用户识别页面的主要功能或主题，这里明确表示是“添加课程”相关的页面。 -->
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入Layui框架的样式文件，通过相对路径"./css/layui.css"找到对应的CSS文件，该文件定义了页面使用Layui框架相关组件的样式规则，使得页面中的各种元素（如按钮、表单等）能够按照Layui框架预设的风格进行显示。 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的样式文件"style.css"，可以在这个文件中覆盖或补充Layui框架样式的不足，定义页面特有的一些样式规则，比如页面整体的布局风格、颜色搭配等个性化的样式设置。 -->
     <script src="./layui.js"></script>
+    <!-- 引入Layui框架的JavaScript核心文件，通过该文件可以使用Layui框架提供的各种JavaScript功能，如弹出层、表单验证、页面元素操作等，为页面的交互功能提供支持。 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 从CDN（内容分发网络）引入jQuery库的精简版本，jQuery是一个广泛使用的JavaScript库，它简化了HTML文档遍历、事件处理、动画效果以及AJAX交互等操作，方便在页面中进行DOM操作和实现各种交互效果。 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 设置页面主体的样式类为"layui-layout-body"，并且指定背景颜色为#F2F2F2，通过样式类和内联样式相结合的方式来定义页面主体部分的外观风格，可能符合整个项目中统一的页面布局和色彩搭配要求。 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 通过JSP的include指令，将名为"filterLogin.jsp"的页面包含进来，通常这个页面可能用于处理用户登录验证相关的逻辑，比如判断用户是否已经登录，如果未登录则可能跳转到登录页面等操作，实现页面访问权限的控制。 -->
     <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <!-- 包含名为"WEB-INF/teacher/tHeader.jsp"的页面，一般这个页面用于定义教师端页面的头部区域，可能包含页面的标题、导航栏等头部相关的元素和布局。 -->
     <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 包含"WEB-INF/teacher/teacherNav.jsp"页面，该页面大概率是用于展示教师端的导航菜单，方便教师在不同功能模块（如课程管理、学生管理等，具体看业务需求）之间进行切换操作。 -->
     <div class="layui-layout layui-layout-admin">
+        <!-- 创建一个使用Layui框架的布局容器，类名"layui-layout"和"layui-layout-admin"表示采用了Layui框架提供的特定布局样式，可能适用于后台管理系统等场景，具有规范的页面分区结构。 -->
         <div class="layui-body">
+            <!-- 在Layui布局容器内定义页面的主体内容区域，这个区域会根据Layui框架的布局规则进行自适应显示，用于放置具体的业务相关内容，如添加课程的表单等。 -->
             <!-- 内容主体区域 -->
             <div style="padding: 15px;">
+                <!-- 创建一个具有内边距的div容器，用于对内部的内容进行布局排版，使得内容在页面中显示时有一定的空白间隔，更加美观和易读。 -->
                 <span class="layui-breadcrumb">
+                    <!-- 使用Layui框架的面包屑组件，用于显示页面的导航路径，方便用户了解当前页面在整个系统中的位置层级关系。 -->
                     <a href="">教师端</a>
+                    <!-- 面包屑中的第一个链接，通常指向教师端的首页或者入口页面，点击可以返回教师端的主要界面，这里暂时没有设置具体的链接地址（可能后续根据实际情况补充完整）。 -->
                     <a href="">课程信息</a>
+                    <!-- 面包屑中的第二个链接，指向课程信息相关的页面，点击可能进入课程信息的总览页面或者列表页面等，同样暂时没设置具体链接地址。 -->
                     <a><cite>添加课程</cite></a>
+                    <!-- 面包屑中的最后一个元素，显示当前页面的具体功能是“添加课程”，通常不可点击，只是用于展示当前所在功能位置的标识。 -->
                 </span>
                 <form class="layui-form" action="${pageContext.request.contextPath}/addOptionalCourseServlet" style="padding-top: 50px" method="post">
+                    <!-- 创建一个使用Layui框架样式的表单，设置表单的提交地址为通过EL表达式（Expression Language）获取的相对路径"/addOptionalCourseServlet"，意味着当表单提交时，数据会发送到对应的Servlet进行处理，同时设置表单的提交方法为"post"，一般用于提交较大量的数据或者需要保密的数据（比如涉及密码等情况），并且在顶部设置了50px的内边距，使表单在页面中显示有一定的垂直间距。 -->
                     <div class="layui-form-item">
+                        <!-- 在表单内创建一个Layui框架的表单项目容器，用于对表单中的单个输入项进行分组和布局，方便统一管理和设置样式。 -->
                         <label class="layui-form-label">课程号</label>
+                        <!-- 创建一个表单标签，用于显示输入项对应的提示文本，这里提示用户输入“课程号”。 -->
                         <div class="layui-input-block">
+                            <!-- 创建一个用于放置输入框的块级容器，按照Layui框架的布局规则，输入框会在这个块内进行合适的显示布局。 -->
                             <input type="text" name="cid" required lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 创建一个文本输入框，设置其名称为"cid"，通过"required"属性和"lay-verify=required"声明该输入项是必填项，并且关闭自动完成功能（防止浏览器自动填充可能不符合要求的数据），同时应用Layui框架的输入框样式类"layui-input"，使其外观符合Layui框架的风格，用户需要在此输入课程号信息。 -->
                         </div>
                     </div>
                     <div class="layui-form-item">
                         <label class="layui-form-label">课程名</label>
                         <div class="layui-input-block">
                             <input type="text" name="course-name" required lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 与上面课程号输入框类似，创建一个用于输入课程名的文本输入框，名称为"course-name"，同样是必填项，关闭自动完成功能并应用Layui框架样式，用户在此输入课程的名称信息。 -->
                         </div>
                     </div>
                     <div class="layui-form-item">
                         <label class="layui-form-label">课程信息</label>
                         <div class="layui-input-block">
                             <input type="text" name="course-info" required lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 创建用于输入课程详细信息的文本输入框，名称为"course-info"，也是必填项，遵循相同的规则，用户在此输入课程的详细介绍等相关信息。 -->
                         </div>
                     </div>
 
                     <div class="layui-form-item">
                         <div class="layui-input-block">
                             <button class="layui-btn" lay-submit lay-filter="formDemo">添加</button>
+                            <!-- 创建一个使用Layui框架样式的按钮，文本显示为“添加”，通过"lay-submit"属性声明该按钮用于提交表单，"lay-filter=formDemo"则可能是用于设置表单提交的验证规则或者事件监听等相关的过滤器名称（需要在后续的JavaScript代码中进一步定义具体逻辑），点击该按钮可以触发表单提交操作，将用户输入的课程相关信息发送到指定的Servlet进行处理。 -->
                             <span style="padding-left: 20px;">${update_msg}</span>
+                            <!-- 通过EL表达式显示名为"update_msg"的变量内容，这个变量可能是在服务器端（比如对应的Servlet）设置的提示信息，用于向用户反馈操作结果（比如添加课程成功或失败的提示等），并设置了左边20px的内边距，使其与按钮有一定的间距显示。 -->
                         </div>
                     </div>
                 </form>
                 <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含名为"footer.jsp"的页面，通常这个页面用于定义页面的底部区域，比如版权信息、联系方式、页面底部导航等相关内容，完善页面的整体布局结构。 -->
             </div>
         </div>
     </div>
@@ -56,19 +86,23 @@
 
     <script type="text/javascript">
         $("#nav li:nth-child(1) dl dd:nth-child(4)").addClass("layui-this");
+        // 使用jQuery选择器选择页面中id为"nav"的元素下的第一个li元素内的dl元素中的第四个dd元素，并为其添加"layui-this"样式类，可能是用于在导航菜单中标记当前选中的菜单项（具体取决于页面的导航结构和样式设置逻辑），使其显示出当前选中的效果，比如改变颜色、加粗等样式变化。
         $("#nav li:nth-child(1)").addClass("layui-nav-itemed");
+        // 同样使用jQuery选择器选择id为"nav"的元素下的第一个li元素，并为其添加"layui-nav-itemed"样式类，大概率是用于展开或折叠对应的导航菜单项目，显示出该导航项处于展开状态的视觉效果（根据Layui导航组件的样式规则）。
     </script>
     <script>
         //JavaScript代码区域
         layui.use('element', function(){
             var element = layui.element;
             element.init();
+            // 使用Layui框架的模块加载机制，加载"element"模块，获取该模块实例并赋值给变量"element"，然后调用模块的"init"方法进行初始化操作，这个"element"模块通常用于页面元素的操作、动态渲染以及交互效果实现等，初始化操作可能是准备相关的DOM操作环境、绑定事件等，确保模块能正常工作，实现页面中各种基于该模块的功能，比如页面布局的动态调整、元素显示隐藏控制等。
         });
     </script>
 
     <script>
         //Demo
         layui.use('form', function(){
+            // 使用Layui框架的模块加载机制，加载"form"模块，通常加载这个模块后可以使用Layui框架提供的表单相关的功能，比如表单验证、提交前的数据处理等操作，不过这里暂时没有在回调函数内添加具体的业务逻辑代码（可能后续根据实际的表单验证等需求补充完整）。
 
         });
     </script>

web/WEB-INF/teacher/findSelectCourseListByCourseId.jsp

@@ -1,54 +1,96 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- 设置JSP页面的相关属性，指定页面内容类型为"text/html"，字符编码采用UTF-8，这样能确保页面正确显示各种字符（包括中文等特殊字符），避免乱码问题，同时表明该页面使用Java语言来实现相关逻辑，它是整个JSP页面的基础配置指令。 -->
+
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 引入JSTL（JavaServer Pages Standard Tag Library）核心标签库，定义前缀为"c"，后续就可以使用以"c"开头的各种JSTL标签，方便在JSP页面中进行如循环遍历、条件判断、数据输出等常见操作，增强页面的动态处理能力，让页面能更灵活地展示数据和实现业务逻辑。 -->
+
 <html>
 <head>
     <title>我的授课</title>
+    <!-- 设置HTML页面的标题，在浏览器的标题栏中会显示该标题内容，方便用户清晰地知道当前页面的主题是关于“我的授课”相关内容，起到页面标识的作用。 -->
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入Layui框架的样式文件，通过相对路径"./css/layui.css"来定位该文件，这个文件定义了页面使用Layui框架相关组件（如表格、按钮等）的样式规则，使得页面元素能按照Layui预设的风格进行展示，呈现出统一、美观的视觉效果。 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的样式文件"style.css"，可以在这个文件里对页面的样式进行个性化定制，比如覆盖部分Layui框架默认样式，或者添加一些独特的页面布局、颜色搭配等样式设置，以满足特定的页面设计需求。 -->
     <script src="./layui.js"></script>
+    <!-- 引入Layui框架的JavaScript核心文件，有了这个文件，页面就能使用Layui框架提供的各种JavaScript功能，例如实现弹出层、表单验证、页面元素交互操作等功能，为页面的交互性和动态效果提供支持。 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 从CDN（内容分发网络）引入jQuery库的精简版本，jQuery是一个非常流行的JavaScript库，它简化了HTML文档遍历、事件处理、动画效果以及AJAX交互等操作，方便开发人员在页面中更便捷地操作DOM元素、实现各种交互功能，增强页面的动态交互体验。 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 为页面主体设置样式类为"layui-layout-body"，并通过内联样式指定背景颜色为#F2F2F2，这是结合Layui框架的样式规范来定义页面主体部分的外观风格，营造出特定的视觉背景，可能符合整个项目中统一的页面设计要求。 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 通过JSP的include指令，将名为"filterLogin.jsp"的页面包含进来，该页面通常用于处理用户登录验证相关的逻辑，比如判断用户是否已经登录，如果未登录可能会跳转到登录页面，以此来实现对页面访问权限的控制，保障系统的安全性和数据的合法性。 -->
     <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <!-- 包含名为"WEB-INF/teacher/tHeader.jsp"的页面，一般这个页面用于定义教师端页面的头部区域，里面可能包含页面的标题、导航栏、用户信息展示等头部相关元素，构建出页面头部的布局结构。 -->
     <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 包含"WEB-INF/teacher/teacherNav.jsp"页面，该页面大概率是用于展示教师端的导航菜单，方便教师在不同的功能模块（比如课程管理、成绩管理等，具体依业务而定）之间进行切换操作，实现页面功能的导航跳转。 -->
     <div class="layui-layout layui-layout-admin">
+        <!-- 创建一个采用Layui框架的布局容器，使用"layui-layout"和"layui-layout-admin"样式类，按照Layui框架提供的布局模式进行页面布局，这种布局通常适用于后台管理系统等场景，有着规范的页面分区结构，便于组织页面内容。 -->
         <div class="layui-body">
+            <!-- 在上述Layui布局容器内定义页面的主体内容区域，该区域会依据Layui框架的布局规则进行自适应显示，用于承载具体的业务相关内容，例如下面要展示的学生成绩相关信息的表格等内容。 -->
             <!-- 内容主体区域 -->
             <div style="padding: 15px;">
+                <!-- 创建一个带有内边距（上下左右均为15px）的div容器，通过设置内边距可以让内部的内容在页面中有一定的空白间隔，使其显示更加美观、易读，便于对内部元素进行布局排版。 -->
                 <span class="layui-breadcrumb">
+                    <!-- 使用Layui框架的面包屑组件，用于向用户展示页面的导航路径，清晰呈现当前页面在整个系统中的位置层级关系，方便用户了解所处的功能位置以及如何进行相关操作。 -->
                     <a href="">教师端</a>
+                    <!-- 面包屑中的第一个链接，通常指向教师端的首页或者入口页面，不过这里暂时没有设置具体的链接地址（可能后续根据实际情况完善），点击理论上可以返回教师端的主要界面。 -->
                     <a href="">课程信息</a>
+                    <!-- 面包屑中的第二个链接，指向课程信息相关的页面，可能是课程信息的总览页面或者列表页面等，同样暂时没设置具体链接地址，点击可进入相应的课程信息相关界面。 -->
                     <a><cite>学生成绩</cite></a>
+                    <!-- 面包屑中的最后一个元素，显示当前页面的具体功能是“学生成绩”，用于明确告知用户当前所在的功能位置，一般不可点击，仅作为标识展示。 -->
                 </span>
                 <table class="layui-table" lay-filter="test">
+                    <!-- 创建一个使用Layui框架样式的表格，应用"layui-table"样式类使其外观符合Layui框架的表格风格，同时通过"lay-filter"属性设置一个过滤器名称为"test"，这个过滤器可以在后续的JavaScript代码中用于绑定表格相关的事件（如行点击事件、排序事件等），方便对表格进行交互操作。 -->
                     <thead>
+                    <!-- 定义表格的表头部分，用于展示各列的标题信息。 -->
                     <tr>
+                        <!-- 创建表格中的一行，用于放置表头单元格（th元素）。 -->
                         <th>ID</th>
+                        <!-- 表头单元格，用于显示“ID”这一列的标题，具体含义可能是记录的唯一标识或者序号等，根据业务需求而定。 -->
                         <th>学号</th>
+                        <!-- 表头单元格，显示“学号”列标题，代表学生的学号信息，后续表格行会对应展示具体学生的学号内容。 -->
                         <th>学生姓名</th>
+                        <!-- 表头单元格，用于展示“学生姓名”这一标题，对应列会显示具体学生的姓名信息。 -->
                         <th>课程号</th>
+                        <!-- 表头单元格，标题为“课程号”，该列将展示相应课程的编号信息，用于区分不同的课程。 -->
                         <th>课程名</th>
+                        <!-- 表头单元格，显示“课程名”标题，对应的表格列会呈现具体课程的名称信息。 -->
                         <th>课程简介</th>
+                        <!-- 表头单元格，标题为“课程简介”，其所在列会展示相应课程的详细介绍信息，方便教师查看课程相关情况。 -->
                         <th>学生分数</th>
+                        <!-- 表头单元格，用于展示“学生分数”这一标题，对应列会显示学生在相应课程上的成绩情况。 -->
                         <td>操作</td>
+                        <!-- 表头单元格（这里使用td也可以，不过按规范表头一般用th更好些），标题为“操作”，该列用于放置针对每一行数据可进行的操作按钮等元素，比如修改分数、删除等操作。 -->
                     </tr>
                     </thead>
 
                     <c:forEach items="${scs}" var="sc" varStatus="t">
+                        <!-- 使用JSTL的forEach标签进行循环遍历操作，从名为"scs"的集合（这个集合通常是在服务器端（比如对应的Servlet）设置并传递到JSP页面的）中取出每一个元素，将当前元素赋值给变量"sc"，同时通过"varStatus"属性将循环状态信息（如当前循环次数等）赋值给变量"t"，以便在循环体中可以使用这些信息进行相关操作，比如序号的展示等。 -->
                         <tr>
+                            <!-- 在循环体内创建表格的每一行，用于展示具体的学生成绩相关数据。 -->
                             <td>${t.count}</td>
+                            <!-- 使用EL表达式（Expression Language）输出循环状态变量"t"的"count"属性，即当前循环的次数，一般可作为序号展示在表格中，方便查看每一行数据的顺序和数量情况。 -->
                             <td>${sc.s_id}</td>
+                            <!-- 通过EL表达式输出从集合元素（赋值给"sc"变量）中获取的学生学号信息，将具体的学号值显示在表格对应的单元格中，展示该学生的学号。 -->
                             <td>${sc.s_name}</td>
+                            <!-- 同样使用EL表达式输出集合元素中包含的学生姓名信息，在表格相应单元格展示具体学生的姓名内容。 -->
                             <td>${sc.c_id}</td>
+                            <!-- 利用EL表达式输出课程号信息，将对应的课程编号展示在表格单元格中，便于识别课程。 -->
                             <td>${sc.c_name}</td>
+                            <!-- 通过EL表达式输出课程名称信息，在表格单元格中显示具体的课程名，方便教师查看课程相关情况。 -->
                             <td>${sc.c_info}</td>
+                            <!-- 使用EL表达式输出课程简介信息，将课程的详细介绍展示在表格单元格中，让教师更全面地了解课程内容。 -->
                             <td>${sc.score}</td>
+                            <!-- 通过EL表达式输出学生的分数信息，在表格相应单元格呈现该学生在对应课程上的成绩情况，便于查看成绩。 -->
                             <td><a class="layui-btn layui-btn-normal" href="${pageContext.request.contextPath}/updateScoreServlet?cid=${sc.c_id}&sid=${sc.s_id}">修改分数</a><a class="layui-btn layui-btn-danger" href="javascript:deleteStudentSelectCourse();">删除</a></td>
+                            <!-- 在操作列的单元格中创建两个链接按钮，第一个按钮应用"layui-btn"和"layui-btn-normal"样式类，使其呈现Layui框架正常风格的按钮样式，按钮文本为“修改分数”，其链接地址通过EL表达式动态生成，指向"updateScoreServlet"这个Servlet，并传递当前行对应的课程号（${sc.c_id}）和学号（${sc.s_id}）作为参数，点击该按钮可跳转到相应页面进行分数修改操作；第二个按钮应用"layui-btn"和"layui-btn-danger"样式类，呈现危险操作（通常红色表示重要或危险操作）的按钮样式，按钮文本为“删除”，点击时会执行JavaScript函数"deleteStudentSelectCourse();"（不过这里函数体暂时未看到完整定义，可能在后续补充或者外部引入的脚本中有定义，用于实现删除相关的业务逻辑）。 -->
                         </tr>
                     </c:forEach>
                 </table>
                 <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含名为"footer.jsp"的页面，通常这个页面用于定义页面的底部区域，比如可能包含版权信息、联系方式、页面底部导航等相关内容，完善页面的整体布局结构，使页面更加完整。 -->
             </div>
         </div>
     </div>
@@ -56,14 +98,18 @@
 
     <script type="text/javascript">
         $("#nav li:nth-child(1) dl dd:nth-child(2)").addClass("layui-this");
+        // 使用jQuery选择器选择页面中id为"nav"的元素下的第一个li元素内的dl元素中的第二个dd元素，并为其添加"layui-this"样式类，很可能是用于在导航菜单中标记当前选中的菜单项（依据页面的导航结构和样式设置逻辑），使其呈现出被选中的视觉效果，例如改变颜色、加粗等样式变化，表明当前所在的功能页面对应的导航位置。
         $("#nav li:nth-child(1)").addClass("layui-nav-itemed");
+        // 同样使用jQuery选择器选择id为"nav"的元素下的第一个li元素，并为其添加"layui-nav-itemed"样式类，大概率是用于展开或折叠对应的导航菜单项目，使其显示出该导航项处于展开状态的视觉效果（根据Layui导航组件的样式规则），方便展示相关的子菜单或者突出当前所在的主菜单。
         $("#hidden-score").removeAttr("hidden");
+        // 使用jQuery选择器选择id为"hidden-score"的元素，并移除其"hidden"属性（如果有的话），意味着原本可能隐藏的元素（根据HTML中"hidden"属性的作用）会变为可见状态，具体这个元素是什么以及作用如何，要结合页面的其他部分代码来看，可能是与成绩相关的某个隐藏元素现在需要显示出来，比如隐藏的分数统计区域等（只是猜测，具体依业务而定）。
     </script>
     <script>
         //JavaScript代码区域
         layui.use('element', function(){
             var element = layui.element;
             element.init();
+            // 使用Layui框架的模块加载机制，加载"element"模块，获取该模块实例并赋值给变量"element"，然后调用模块的"init"方法进行初始化操作，"element"模块通常用于页面元素的操作、动态渲染以及交互效果实现等，初始化这个模块可以准备好相关的DOM操作环境、绑定必要的事件等，确保模块能正常工作，进而实现页面中各种基于该模块的功能，比如页面布局的动态调整、元素显示隐藏控制等。
         });
     </script>
     <script type="text/javascript">
@@ -72,6 +118,7 @@
                 location.href = "${pageContext.request.contextPath}/deleteOptionalCourseServlet?cid=" + c_id;
             }
         }
+        // 定义一个名为"deleteOptionalCourse"的JavaScript函数，接收一个参数"c_id"，该函数用于处理删除授课相关的操作逻辑。首先通过"confirm"函数弹出一个确认对话框，询问用户是否确定要删除授课，当用户点击“确定”按钮时（返回值为true时），会将页面的地址跳转到通过EL表达式动态生成的路径，指向"deleteOptionalCourseServlet"这个Servlet，并传递当前要删除授课对应的课程号（"c_id"参数的值）作为参数，以便在服务器端（对应的Servlet中）根据课程号执行相应的删除授课的业务逻辑，实现删除操作。
     </script>
 </body>
 </html>

web/WEB-INF/teacher/tCDCList.jsp

@@ -1,46 +1,80 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- 这是JSP页面的指令，用于设定页面的相关属性。这里指定页面的内容类型为"text/html"，意味着页面将以HTML格式呈现内容，同时将字符编码设置为UTF-8，确保可以正确处理和显示各种字符（包括中文等非英文字符），避免出现乱码情况，并且表明这个JSP页面是使用Java语言来实现其内部逻辑的。 -->
+
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 引入JSTL（JavaServer Pages Standard Tag Library）核心标签库，通过设置前缀为"c"，后续在页面中就能使用以"c"开头的各种JSTL标签了。JSTL标签库提供了诸如循环遍历、条件判断、数据输出等功能，能够方便地在JSP页面中进行动态数据展示和逻辑处理，增强页面的灵活性与交互性。 -->
+
 <html>
 <head>
     <title>学院专业查询</title>
+    <!-- 设置HTML页面的标题，在浏览器的标题栏中将会显示该标题内容，其作用是让用户清晰知晓当前页面的主题，这里表明是用于“学院专业查询”相关操作的页面。 -->
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入Layui框架的样式文件，通过相对路径"./css/layui.css"找到对应的CSS文件，该文件中定义了一系列符合Layui框架风格的样式规则，用于规范页面中使用Layui框架相关组件（比如表格、按钮等元素）的外观显示，使页面呈现出统一且美观的视觉效果。 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的样式文件"style.css"，开发人员可以在这个文件里对页面的样式进行个性化定制，例如覆盖Layui框架的部分默认样式，或者添加一些独特的页面布局、色彩搭配等样式设定，以此来满足特定的页面设计需求，使其与整个项目的风格更加契合。 -->
     <script src="./layui.js"></script>
+    <!-- 引入Layui框架的JavaScript核心文件，有了这个文件，页面就能调用Layui框架提供的各种JavaScript功能，像弹出层展示、表单验证、页面元素交互等功能都可以通过该框架的相关API来实现，从而为页面添加丰富的交互性和动态效果。 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 从CDN（内容分发网络）引入jQuery库的精简版本，jQuery是一个广受欢迎的JavaScript库，它大大简化了HTML文档遍历、事件处理、动画效果创建以及AJAX交互等操作，方便开发人员在页面中便捷地操作DOM元素，轻松实现各种交互功能，进一步增强页面的动态交互体验。 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 为页面主体设置样式类为"layui-layout-body"，并通过内联样式指定背景颜色为#F2F2F2，这样结合Layui框架的样式规范，定义了页面主体部分的整体外观风格，营造出特定的视觉背景效果，通常是为了与整个项目中统一的页面设计风格保持一致。 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 使用JSP的include指令将名为"filterLogin.jsp"的页面包含进来，这个页面一般用于处理用户登录验证相关的逻辑，例如判断当前用户是否已经登录，如果未登录则可能会引导用户跳转到登录页面，以此来实现对页面访问权限的有效控制，确保系统的安全性以及数据的合法性。 -->
     <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <!-- 包含名为"WEB-INF/teacher/tHeader.jsp"的页面，该页面通常用于定义教师端页面的头部区域，里面可能包含诸如页面标题、导航栏、用户信息展示等头部相关元素，以此构建出页面头部的整体布局结构。 -->
     <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 包含名为"WEB-INF/teacher/teacherNav.jsp"的页面，大概率是用于展示教师端的导航菜单，方便教师在不同的功能模块（比如课程管理、学生管理、学院专业相关管理等，具体取决于业务需求）之间进行快速切换操作，实现页面功能的便捷导航跳转。 -->
     <div class="layui-layout layui-layout-admin">
+        <!-- 创建一个采用Layui框架的布局容器，使用"layui-layout"和"layui-layout-admin"这两个样式类，按照Layui框架所提供的布局模式来对页面进行布局规划，这种布局方式常用于后台管理系统等场景，有着规范且清晰的页面分区结构，便于合理组织和展示页面内的各种内容。 -->
         <div class="layui-body">
+            <!-- 在上述Layui布局容器内定义页面的主体内容区域，这个区域会依据Layui框架既定的布局规则进行自适应显示，主要用于承载与具体业务相关的内容，例如下面即将展示的学院专业查询结果信息的表格等内容。 -->
             <!-- 内容主体区域 -->
             <div style="padding: 15px;">
+                <!-- 创建一个带有内边距（上下左右均为15px）的div容器，通过设置内边距，可以让容器内部的内容在页面中展示时有一定的空白间隔，使得页面布局更加美观、易读，也更便于对内部的各个元素进行合理的排版布局操作。 -->
                 <span class="layui-breadcrumb">
+                    <!-- 使用Layui框架的面包屑组件，其目的在于向用户清晰展示页面的导航路径，让用户能够直观了解当前页面在整个系统中的位置层级关系，方便用户知晓自己所处的功能位置以及如何进行相关的操作导航。 -->
                     <a href="">教师端</a>
+                    <!-- 面包屑中的第一个链接，通常指向教师端的首页或者主要入口页面，不过此处暂时没有设定具体的链接地址（可能后续会根据实际情况进一步完善），理论上点击该链接可以返回教师端的核心界面。 -->
                     <a href="">学院专业信息</a>
+                    <!-- 面包屑中的第二个链接，指向与学院专业信息相关的页面，可能是学院专业信息的总览页面或者列表页面等，同样暂时未设置具体的链接地址，点击该链接一般可进入对应的学院专业信息相关界面。 -->
                     <a><cite>学院专业查询</cite></a>
+                    <!-- 面包屑中的最后一个元素，明确显示当前页面的具体功能是“学院专业查询”，它主要起到标识当前所在功能位置的作用，通常情况下是不可点击的，仅作为文字提示展示给用户。 -->
                 </span>
                 <table class="layui-table" lay-filter="test">
+                    <!-- 创建一个使用Layui框架样式的表格，应用"layui-table"样式类使其外观符合Layui框架所定义的表格风格，同时通过"lay-filter"属性设置一个过滤器名称为"test"，这个过滤器后续可在JavaScript代码中用于绑定表格相关的各种事件（例如行点击事件、排序事件等），方便实现对表格的交互操作以及数据处理功能。 -->
                     <thead>
+                    <!-- 定义表格的表头部分，用于清晰展示各列所代表的标题信息，让用户明白每一列数据的含义。 -->
                     <tr>
+                        <!-- 创建表格中的一行，该行用于放置表头单元格（th元素），每个th元素对应表格中的一列标题。 -->
                         <th>ID</th>
+                        <!-- 表头单元格，标题为“ID”，此处的“ID”具体含义可能是每条学院专业记录的唯一标识编号或者是序号等，具体要根据业务需求来确定，其所在列后续会展示相应的标识信息。 -->
                         <th>学院</th>
+                        <!-- 表头单元格，显示“学院”这一标题，对应列将展示具体的学院名称信息，方便用户查看不同学院的相关数据。 -->
                         <th>专业</th>
+                        <!-- 表头单元格，标题为“专业”，所在列会呈现相应的专业名称等专业相关信息，便于了解各学院下包含的专业情况。 -->
                         <th>班级</th>
+                        <!-- 表头单元格，显示“班级”标题，其对应的表格列用于展示具体的班级名称等班级相关信息，有助于全面查看学院专业下涉及的班级情况。 -->
                     </tr>
                     </thead>
 
                     <c:forEach items="${cdcs}" var="cdc" varStatus="c">
+                        <!-- 使用JSTL的forEach标签来进行循环遍历操作，这里会从名为"cdcs"的集合（这个集合通常是在服务器端，比如对应的Servlet中进行数据查询获取后，设置并传递到当前JSP页面的）里依次取出每一个元素，将当前取出的元素赋值给变量"cdc"，同时借助"varStatus"属性把循环的状态信息（像当前循环的次数等）赋值给变量"c"，以便在循环体内部能够利用这些信息来进行相应的操作，例如展示序号等。 -->
                         <tr>
+                            <!-- 在循环体内部创建表格的每一行，用于展示具体的学院专业相关数据内容，每一次循环就生成一行数据展示在表格中。 -->
                             <td>${c.count}</td>
+                            <!-- 通过EL表达式（Expression Language）输出循环状态变量"c"的"count"属性，也就是当前循环的次数，一般可以将其作为序号展示在表格中，方便用户清晰查看每一行数据的顺序以及整体的数据数量情况。 -->
                             <td>${cdc.college}</td>
+                            <!-- 利用EL表达式输出从集合元素（赋值给"cdc"变量）中获取的学院名称信息，将具体的学院名称值显示在表格对应的单元格内，以便用户直观看到相应的学院信息。 -->
                             <td>${cdc.department}</td>
+                            <!-- 同样使用EL表达式输出集合元素中包含的专业名称信息，在表格相应的单元格中展示具体的专业名称内容，方便查看各学院下的专业设置情况。 -->
                             <td>${cdc.cclass}</td>
+                            <!-- 通过EL表达式输出集合元素里的班级名称等班级相关信息，将其展示在表格对应的单元格中，使得用户可以全面了解学院专业所涉及的班级情况。 -->
                         </tr>
                     </c:forEach>
                 </table>
                 <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含名为"footer.jsp"的页面，通常这个页面用于定义页面的底部区域，里面可能包含诸如版权信息、联系方式、页面底部导航等相关内容，通过包含该页面可以完善整个页面的布局结构，使其更加完整、规范。 -->
             </div>
         </div>
     </div>
@@ -48,13 +82,16 @@
 
     <script type="text/javascript">
         $("#nav li:nth-child(4) dl dd:nth-child(1)").addClass("layui-this");
+        // 使用jQuery选择器来定位页面中特定的元素，具体选择的是id为"nav"的元素下的第四个li元素内的dl元素中的第一个dd元素，然后为其添加"layui-this"样式类。这么做大概率是为了在导航菜单中标记当前选中的菜单项（依据页面本身的导航结构和样式设置逻辑来确定），使其呈现出被选中的视觉效果，例如改变颜色、加粗等样式变化，从而清晰地表明当前所在的功能页面对应的导航位置。
         $("#nav li:nth-child(4)").addClass("layui-nav-itemed");
+        // 同样利用jQuery选择器选择id为"nav"的元素下的第四个li元素，并为其添加"layui-nav-itemed"样式类，这通常是用于展开或折叠对应的导航菜单项目，使其显示出该导航项处于展开状态的视觉效果（按照Layui导航组件的样式规则来实现），方便展示相关的子菜单或者突出当前所在的主菜单部分。
     </script>
     <script>
         //JavaScript代码区域
         layui.use('element', function(){
             var element = layui.element;
             element.init();
+            // 使用Layui框架的模块加载机制，加载"element"模块，获取该模块实例并赋值给变量"element"，随后调用模块的"init"方法进行初始化操作。"element"模块在Layui框架中通常用于页面元素的操作、动态渲染以及交互效果实现等方面，通过初始化这个模块，可以准备好相关的DOM操作环境、绑定必要的事件等，以此确保该模块能够正常工作，进而实现页面中各种基于该模块的功能，例如页面布局的动态调整、元素显示隐藏控制等功能。
         });
     </script>
 

web/WEB-INF/teacher/tFindFileList.jsp

@@ -1,48 +1,90 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- JSP页面指令，用于设置页面的相关属性。
+    - “contentType”属性指定页面内容类型为“text/html”，意味着页面会以HTML格式来展示内容，这是常见的网页内容呈现格式。
+    - “charset=UTF-8”明确了字符编码为UTF-8，这样能保证页面可以正确处理和显示各种字符，像中文等特殊字符也不会出现乱码情况，确保页面内容的正常展示。
+    - “language=java”表明该JSP页面内部的逻辑实现是基于Java语言的，例如可以在页面中嵌入Java代码片段来与服务器端进行交互、处理业务数据等操作。 -->
+
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 引入JSTL（JavaServer Pages Standard Tag Library）核心标签库，通过设定“prefix”属性为“c”，后续在页面里就能使用以“c”开头的各种JSTL标签了。这些标签能够方便地实现诸如循环遍历集合数据、进行条件判断、将数据输出到页面等常见功能，大大增强了JSP页面在处理动态数据和展示内容方面的灵活性与便利性。 -->
+
 <html>
 <head>
     <title>文件列表</title>
+    <!-- 设置HTML页面的标题，这个标题会显示在浏览器的标题栏中，方便用户一眼就能知晓当前页面的主要功能或者主题，这里明确表示页面是用于展示“文件列表”相关内容的。 -->
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入Layui框架的样式文件，通过相对路径“./css/layui.css”去定位对应的CSS文件。该文件中定义了一系列符合Layui框架风格的样式规则，使得页面中运用Layui框架相关的组件（例如表格、按钮、导航栏等元素）都能按照预设的样式进行展示，从而让页面呈现出统一、美观且规范的视觉效果，保持整体风格的一致性。 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的样式文件“style.css”，开发人员可以在这个文件里根据项目的特定需求，对页面的样式进行个性化定制。例如，可以对Layui框架的部分默认样式进行覆盖，或者添加一些独特的页面布局、颜色搭配等样式设定，以便让页面更好地契合整个项目的设计风格和展示要求。 -->
     <script src="./layui.js"></script>
+    <!-- 引入Layui框架的JavaScript核心文件，有了这个文件的引入，页面就能调用Layui框架所提供的各种JavaScript功能了。比如，可以实现弹出层的展示、对表单进行验证、处理页面元素之间的交互操作（像点击按钮触发特定的事件、动态地显示或隐藏某些元素等）等功能，通过使用Layui框架的相关API，能够为页面添加丰富多样的交互性和动态效果，进而提升用户在使用页面过程中的体验感。 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 从CDN（内容分发网络）引入jQuery库的精简版本。jQuery是一款广受欢迎且功能十分强大的JavaScript库，它极大地简化了在HTML页面中进行DOM（Document Object Model，文档对象模型）操作的复杂度，像方便地遍历HTML文档中的元素、处理各种页面事件（例如鼠标的点击、键盘的输入等事件）、创建动画效果以及实现AJAX（Asynchronous JavaScript and XML，异步的JavaScript和XML）交互等操作，都能通过使用jQuery库轻松实现，这有助于开发人员更加便捷地在页面中构建各种交互功能，进一步增强页面整体的动态交互体验。 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 为页面主体设置样式类为“layui-layout-body”，同时通过内联样式设定背景颜色为“#F2F2F2”。这是按照Layui框架的样式规范来对页面主体部分的外观风格进行定义，使得页面呈现出特定的背景颜色，有助于营造出整体统一的视觉效果，并且方便后续依据Layui框架既定的布局和样式规则来组织和展示页面中的其他各种内容元素。 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 使用JSP的“include”指令将名为“filterLogin.jsp”的页面包含进来。通常情况下，这个“filterLogin.jsp”页面主要负责处理用户登录验证相关的逻辑，比如它会判断当前访问该页面的用户是否已经成功登录到系统中，如果发现用户没有登录，那么就会引导用户跳转到登录页面进行登录操作，以此来实现对页面访问权限的有效管控，确保只有合法登录的用户才能够访问当前页面以及后续与之相关的各种功能内容，从而保障整个系统的数据安全以及业务逻辑的正常运行。 -->
     <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <!-- 包含名为“WEB-INF/teacher/tHeader.jsp”的页面，一般来讲，这个页面主要是用于定义教师端页面的头部区域的。在这个头部区域当中，通常会包含诸如页面的大标题、用于页面导航的导航栏、展示教师用户基本信息（例如用户名、头像等内容）等与头部相关的各种元素，通过这样的包含操作，就可以把这些头部相关的元素整合到当前页面之中，进而构建出一个完整且规范的页面头部布局结构。 -->
     <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 包含名为“WEB-INF/teacher/teacherNav.jsp”的页面，大概率它的作用是用于展示教师端的导航菜单的。借助这个导航菜单，教师用户就可以方便快捷地在不同的功能模块（例如课程管理、学生管理、个人信息管理等不同的功能板块，具体的功能模块划分要取决于业务系统的整体设计需求）之间进行切换操作，实现页面功能的导航跳转，为用户提供便捷的操作入口，从而提升用户使用整个系统的便利性。 -->
     <div class="layui-layout layui-layout-admin">
+        <!-- 创建一个基于Layui框架的布局容器，通过应用“layui-layout”和“layui-layout-admin”这两个样式类，按照Layui框架所提供的特定布局模式对页面进行布局规划。这种布局方式在后台管理系统等应用场景中是比较常用的，它有着清晰、规范的页面分区结构，能够便于合理地放置和展示页面内的各种功能内容模块，例如可以很方便地划分出侧边栏、主体内容展示区、页面底部的页脚等不同的区域。 -->
         <div class="layui-body">
+            <!-- 在上述所创建的Layui布局容器内定义页面的主体内容区域，这个区域会依据Layui框架既定的布局规则来进行自适应显示，它主要的作用是用于承载和展示与具体业务相关的核心内容，比如下面即将呈现出来的关于教师“文件列表”相关信息的表格等内容元素，这里也就是用户在访问该页面时重点关注和进行操作的区域。 -->
             <!-- 内容主体区域 -->
             <div style="padding: 15px;">
+                <!-- 创建一个带有内边距的div容器，通过设置“padding: 15px;”这样的内边距样式，意味着在这个容器的四周（也就是上、下、左、右四个方向）都会留出15像素的空白空间。这样做的好处是可以让容器内部的内容在页面中展示的时候有一定的间隔，使得页面的布局更加美观、易读，也更便于对内部的各个元素进行排版布局操作，避免内容显得过于拥挤，从而提升用户查看和操作页面内容时的体验感。 -->
                 <span class="layui-breadcrumb">
+                    <!-- 使用Layui框架的面包屑组件，其最主要的作用就是向用户清晰地展示当前页面的导航路径，让用户能够直观地了解当前页面在整个系统中的位置层级关系。通过面包屑组件所展示出来的路径信息，用户可以清楚地知道自己是如何一步步进入到当前这个“文件列表”页面的，同时也方便用户在需要的时候，能够按照这个路径进行回退或者跳转到相关的上级页面等操作，有效地提升了页面的导航便利性以及用户对整个系统结构的理解程度。 -->
                     <a href="">教师端</a>
+                    <!-- 面包屑中的第一个链接，通常情况下它是指向教师端的首页或者是整个教师端功能的主要入口页面的，不过在这里暂时没有设置具体的链接地址（可能后续会根据实际情况进一步去完善它），从理论上来说，用户点击该链接是可以引导其返回教师端的核心界面的，也就是回到一个相对比较顶层的功能页面位置上。 -->
                     <a href="">个人信息管理</a>
+                    <!-- 面包屑中的第二个链接，它所指向的是与个人信息管理相关的页面，这个页面可能是个人信息管理的总览页面或者是对个人信息进行分类展示的列表页面等相关页面，同样在这里暂时也没有设定具体的链接地址，一般情况下用户点击该链接就可以进入到对应的个人信息管理相关的界面中，进而去查看更详细的个人信息相关内容。 -->
                     <a><cite>文件列表</cite></a>
+                    <!-- 面包屑中的最后一个元素，明确地显示出当前页面的具体功能是“文件列表”，它主要起到一个标识当前所在功能位置的作用，通常情况下这个元素是不可点击的，仅仅是作为文字提示信息展示给用户，告知用户当前所处的具体业务功能页面是什么。 -->
                 </span>
                 <table class="layui-table" lay-filter="test">
+                    <!-- 创建一个使用Layui框架样式的表格，通过应用“layui-table”样式类使得表格的外观符合Layui框架所定义的表格风格，整体看上去会更加美观、专业，并且能够与整个系统的界面风格保持一致性要求。同时，利用“lay-filter”属性设置了一个过滤器名称为“test”，这个过滤器在后续的JavaScript代码中可以用于绑定表格相关的各种事件（例如当用户点击某一行数据时触发的事件、对表格中的数据进行排序时触发的事件、对单元格内容进行编辑时触发的事件等等），方便实现对表格的交互操作以及数据处理等功能，进而增强表格在实际使用过程中的实用性和用户交互性。 -->
                     <thead>
+                    <!-- 定义表格的表头部分，这部分主要是用于清晰地展示出各列所代表的标题信息，让用户在查看表格中的具体数据时，一眼就能明白每一列数据的含义以及所代表的内容属性，起到对数据列进行说明的作用，便于用户能够快速地理解和查看表格中所展示的具体数据内容。 -->
                     <tr>
+                        <!-- 创建表格中的一行，该行的作用是用于放置表头单元格（也就是th元素），每个th元素会对应表格中的一列标题，按照从左到右的顺序依次排列，这样就形成了一个完整的表头行结构。 -->
                     <th>ID</th>
+                    <!-- 表头单元格，标题为“ID”，此处的“ID”具体含义可能是每条文件记录在系统中的唯一标识编号，或者是按照一定规则生成的序号等，具体的含义要根据业务系统的设计需求来确定，其所在的列后续会展示相应的标识信息，方便对不同的文件记录进行区分和索引查找。 -->
                     <th>文件名</th>
+                    <!-- 表头单元格，显示的标题是“文件名”，对应列将会展示具体的文件名称信息，通过文件名用户可以直观地了解到每个文件的基本名称，便于识别和区分不同的文件。 -->
                     <th>文件路径</th>
+                    <!-- 表头单元格，标题为“文件路径”，所在列会呈现出相应文件在服务器或者存储设备上的具体存储路径信息，这对于用户了解文件的存储位置以及在需要的时候进行文件相关的操作（比如通过文件路径去访问文件等）是很有帮助的。 -->
                     <th>文件大小</th>
+                    <!-- 表头单元格，显示“文件大小”这一标题，其对应的表格列用于展示具体的文件字节大小等相关信息，用户可以通过该列数据了解到每个文件所占用的存储空间情况。 -->
                     <th>操作</th>
+                    <!-- 表头单元格，标题为“操作”，该列主要是用于放置针对每一行文件记录数据可以进行的操作按钮等元素，比如常见的下载、删除、编辑等操作按钮，方便教师用户根据实际的需求对相应的文件信息进行各种操作管理，为用户提供了便捷的交互功能入口。 -->
                     </tr>
                     </thead>
 
                     <c:forEach items="${fileLists}" var="filelist" varStatus="f">
+                        <!-- 使用JSTL（JavaServer Pages Standard Tag Library）的“forEach”标签来进行循环遍历操作。
+                            - “items”属性指定了要遍历的集合对象，在这里就是名为“fileLists”的集合（这个集合通常是在服务器端，比如对应的Servlet中通过查询数据库或者其他数据存储方式获取到的文件相关数据，然后将这些数据封装成集合的形式，再设置并传递到当前的JSP页面中来的）。
+                            - “var”属性定义了一个变量名“filelist”，在每次循环的过程中，会从“fileLists”集合里依次取出每一个元素，并将当前取出的元素赋值给这个变量，方便在循环体内部使用该变量来获取元素中的具体数据内容，例如文件的各个属性信息等。
+                            - “varStatus”属性则是定义了一个循环状态变量“f”，这个变量可以获取到循环的一些状态信息，例如当前循环的次数、是否是第一次或者最后一次循环等，在这里主要是利用它的“count”属性（也就是当前循环的次数）来展示序号等相关信息，以此增强表格数据展示的可读性，让用户更清晰地查看每一行数据的顺序以及整体的数据数量情况。 -->
                         <tr>
+                            <!-- 在循环体内部创建表格的每一行，用于展示具体的文件相关数据内容，每一次循环就会生成一行数据展示在表格中，通过这样的循环操作，就可以将集合中的所有文件数据逐行地展示出来，从而形成一个完整的数据表格展示效果。 -->
                             <td>${f.count}</td>
+                            <!-- 通过EL表达式（Expression Language）输出循环状态变量“f”的“count”属性，也就是当前循环的次数，将其作为序号展示在表格的这一单元格中，方便用户能够清晰地查看每一行数据的顺序以及整体的数据数量情况，使得数据在表格中的展示更加有条理，便于用户快速地定位和查看特定行的数据内容。 -->
                             <td>${filelist.fileName}</td>
+                            <!-- 利用EL表达式输出从集合元素（赋值给“filelist”变量）中获取的文件名信息，将具体的文件名称值显示在表格对应的单元格内，以便用户直观地看到每一个文件的具体名称，方便对文件进行识别和区分。 -->
                             <td>${filelist.filePath}</td>
+                            <!-- 同样使用EL表达式输出集合元素中包含的文件路径信息，在表格相应的单元格中展示具体的文件路径内容，使得用户可以了解到每个文件在存储设备上的具体位置，这对于后续可能涉及到的文件访问或者管理操作是很有帮助的。 -->
                             <td>${filelist.fileSize}</td>
+                            <!-- 通过EL表达式输出集合元素里的文件大小等相关信息，将文件的字节大小等详细信息展示在表格对应的单元格中，让用户能够清楚地知道每个文件所占用的存储空间情况，便于进行文件相关的管理和判断。 -->
                             <td><a class="layui-btn layui-btn-normal" href="${pageContext.request.contextPath}/downloadServlet?filename=${filelist.fileName}">下载</a></td>
+                            <!-- 在操作列的单元格中创建一个链接按钮，该按钮应用“layui-btn”和“layui-btn-normal”样式类，使其呈现出Layui框架正常风格的按钮样式，按钮文本显示为“下载”，其链接地址通过EL表达式动态生成，指向“downloadServlet”这个Servlet，并传递当前行对应的文件名（${filelist.fileName}）作为参数，点击该按钮可跳转到相应的页面进行文件下载操作，方便教师用户根据需要下载对应的文件。 -->
                         </tr>
                     </c:forEach>
                 </table>
                 <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含名为“footer.jsp”的页面，通常这个页面主要是用于定义页面的底部区域的，在这个页面里可能会包含诸如版权信息、联系方式、页面底部导航等相关内容，通过这样的包含操作，可以完善整个页面的布局结构，使其更加完整、规范，给用户呈现出一个完整的页面视觉效果，同时也方便在底部展示一些通用的重要信息或者提供额外的操作入口等。 -->
             </div>
         </div>
     </div>
@@ -50,14 +92,6 @@
 
     <script type="text/javascript">
         $("#nav li:nth-child(5) dl dd:nth-child(3)").addClass("layui-this");
+        // 使用jQuery选择器来定位页面中特定的元素，具体选择的是id为“nav”的元素下的第五个li元素内的dl元素中的第三个dd元素，然后为其添加“layui-this”样式类。这么做大概率是为了在导航菜单中标记当前选中的菜单项（依据页面本身的导航结构和样式设置逻辑来确定），使其呈现出被选中的视觉效果，例如改变颜色、加粗等样式变化，从而清晰地表明当前所在的功能页面对应的导航位置，方便用户直观地知晓当前所处的功能模块在整个导航体系中的位置关系。
         $("#nav li:nth-child(5)").addClass("layui-nav-itemed");
-</script>
-<script>
-    //JavaScript代码区域
-    layui.use('element', function(){
-        var element = layui.element;
-        element.init();
-    });
-</script>
-</body>
-</html>
+        // 同样利用jQuery选择器选择id为“nav”的元素下的第五个li元素，并为其添加“layui-nav-itemed”样式类，这通常是用于展开或折叠对应的导航菜单项目，使其显示出该导航项处于展开状态的视觉效果（按照Layui导航

web/WEB-INF/teacher/tFindStudentList.jsp

@@ -1,127 +1,158 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- JSP页面指令，用于设置页面的相关属性。
+    - “contentType”属性指定页面内容类型为“text/html”，表明页面以HTML格式展示内容。
+    - “charset=UTF-8”设置字符编码为UTF-8，确保能正确处理和显示各类字符（如中文等），避免出现乱码问题，保证页面内容正常展示。
+    - “language=java”说明该JSP页面内部逻辑基于Java语言实现，比如与服务器交互、处理业务数据等操作会使用Java代码来完成。 -->
+
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 引入JSTL（JavaServer Pages Standard Tag Library）核心标签库，通过设置前缀“c”，后续可以使用以“c”开头的JSTL标签。这些标签能方便地实现循环遍历、条件判断、数据输出等功能，增强JSP页面处理动态数据和展示内容的灵活性，让页面可以根据不同情况呈现相应的信息。 -->
+
 <html>
 <head>
     <title>本院学生信息</title>
+    <!-- 设置HTML页面的标题，该标题会显示在浏览器标题栏中，让用户明确知晓页面的主要功能，这里表示是用于展示“本院学生信息”相关内容的页面。 -->
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入Layui框架的样式文件，通过相对路径“./css/layui.css”定位对应的CSS文件，该文件定义了Layui框架相关组件（如表格、按钮、表单等元素）的样式规则，使页面运用Layui框架的元素按预设样式展示，保持页面整体风格统一、美观。 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的样式文件“style.css”，开发人员可在其中对页面样式进行个性化定制，例如覆盖Layui框架部分默认样式，或添加特定的布局、颜色搭配等样式设置，使其符合项目的特定设计需求。 -->
     <script src="./layui.js"></script>
+    <!-- 引入Layui框架的JavaScript核心文件，借助这个文件，页面可调用Layui框架提供的各种JavaScript功能，像弹出层展示、表单验证、页面元素交互等，为页面添加丰富的交互性和动态效果，提升用户操作体验。 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 从CDN（内容分发网络）引入jQuery库的精简版本，jQuery是常用的JavaScript库，能简化HTML文档遍历、事件处理、动画效果创建以及AJAX交互等操作，方便开发人员操作DOM元素，实现各种交互功能，进一步增强页面动态交互性。 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 为页面主体设置样式类为“layui-layout-body”，并通过内联样式指定背景颜色为“#F2F2F2”，按照Layui框架的样式规范定义主体部分外观风格，营造特定视觉背景，符合项目统一的页面设计要求，便于后续布局页面内容。 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 通过JSP的“include”指令包含名为“filterLogin.jsp”的页面，该页面通常用于处理用户登录验证逻辑，判断用户是否已登录，未登录时引导用户跳转到登录页面，以此控制页面访问权限，保障系统安全和数据合法性。 -->
     <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <!-- 包含“WEB-INF/teacher/tHeader.jsp”页面，一般用于定义教师端页面的头部区域，包含如页面标题、导航栏、用户信息展示等元素，构建出页面头部的布局结构，使页面头部呈现规范的样式和功能。 -->
     <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 包含“WEB-INF/teacher/teacherNav.jsp”页面，大概率用于展示教师端的导航菜单，方便教师在不同功能模块（如课程管理、学生管理、个人信息管理等）间切换操作，实现页面功能的导航跳转，提高操作便利性。 -->
     <div class="layui-layout layui-layout-admin">
+        <!-- 创建采用Layui框架的布局容器，使用“layui-layout”和“layui-layout-admin”样式类，按Layui框架提供的布局模式规划页面布局，常用于后台管理系统，有着清晰规范的分区结构，便于组织不同功能内容。 -->
         <div class="layui-body">
+            <!-- 在Layui布局容器内定义页面主体内容区域，该区域依Layui框架布局规则自适应显示，用于承载具体业务相关内容，像下面展示本院学生信息的表单、表格及分页等内容。 -->
             <!-- 内容主体区域 -->
             <div style="padding: 15px;">
+                <!-- 创建带有内边距（上下左右均为15px）的div容器，通过设置内边距让内部内容在页面中有空白间隔，使布局更美观易读，便于对内部元素排版布局，避免内容显得拥挤。 -->
                 <span class="layui-breadcrumb">
+                    <!-- 使用Layui框架的面包屑组件，向用户展示页面的导航路径，清晰呈现当前页面在系统中的位置层级关系，方便用户了解所处功能位置及如何进行相关操作，提升导航便利性。 -->
                     <a href="">教师端</a>
+                    <!-- 面包屑中的第一个链接，通常指向教师端首页或入口页面，不过此处没设具体链接地址（可能后续完善），点击理论上可返回教师端主要界面。 -->
                     <a href="">学生通讯录</a>
+                    <!-- 面包屑中的第二个链接，指向学生通讯录相关页面，可能是学生信息总览或分类展示页面等，同样暂无具体链接地址，点击可进入对应界面。 -->
                     <a><cite>本院学生信息</cite></a>
+                    <!-- 面包屑中的最后一个元素，显示当前页面具体功能为“本院学生信息”，仅作标识展示，告知用户所在功能位置，一般不可点击。 -->
                 </span>
                 <form style="padding-top: 20px;" action="${pageContext.request.contextPath}/findStudentByPageServlet" method="post">
+                    <!-- 创建表单，设置顶部内边距为20px使表单有垂直间距，表单提交地址通过EL表达式动态指向“findStudentByPageServlet”这个Servlet，意味着表单提交时数据会发往此处处理，提交方法为“post”，常用于提交较大量或需保密的数据。 -->
                     <div class="layui-form-item">
+                        <!-- 在表单内创建Layui框架的表单项目容器，用于对单个输入项分组和布局，方便统一管理和设置样式，使每个输入项在页面中规范显示。 -->
                         <div class="layui-inline">
+                            <!-- 创建行内块级元素容器，用于让内部元素在行内排列，方便在一行内放置多个表单输入项及按钮等元素，实现紧凑的布局效果。 -->
                             <label class="layui-form-label" style="width: auto;">学号</label>
+                            <!-- 创建表单标签，用于显示输入项对应的提示文本，此处提示用户输入“学号”信息，设置宽度为自动适应内容宽度。 -->
                             <div class="layui-input-inline">
+                                <!-- 创建放置输入框的行内块级容器，按Layui框架布局规则，输入框会在此合理显示，确保页面布局整齐，与其他行内元素排列有序。 -->
                                 <input type="tel" name="s_id" value="${condition.s_id[0]}" autocomplete="off" class="layui-input">
+                                <!-- 创建电话号码类型的输入框，设置名称为“s_id”，通过EL表达式将“condition.s_id[0]”（可能是从服务器端传递过来的初始学号值）作为初始值显示，关闭自动完成功能，应用Layui框架输入框样式类“layui-input”，用户可在此输入或修改学号信息。 -->
                             </div>
                             <label class="layui-form-label" style="width: auto;">姓名</label>
                             <div class="layui-input-inline">
                                 <input type="text" name="s_name" value="${condition.s_name[0]}" autocomplete="off" class="layui-input">
+                                <!-- 类似学号输入框，创建用于输入姓名的文本输入框，名称为“s_name”，初始值通过EL表达式显示（可能来自服务器端传递的初始值），关闭自动完成功能，用户可输入或修改姓名内容。 -->
                             </div>
 
                             <div class="layui-input-inline">
-
+                                <!-- 再次创建行内块级容器，用于放置按钮等元素，保持布局的连贯性和合理性。 -->
                                 <button type="submit" class="layui-btn">查询</button>
+                                <!-- 创建使用Layui框架样式的按钮，文本显示为“查询”，类型为“submit”，意味着点击该按钮会触发表单提交操作，将用户输入的学号、姓名等信息发往指定的“findStudentByPageServlet”处理，以获取符合条件的学生信息。 -->
                             </div>
                         </div>
                     </div>
                 </form>
                 <table class="layui-table" lay-filter="test">
+                    <!-- 创建使用Layui框架样式的表格，设置过滤器名称为“test”，用于后续JavaScript代码绑定表格相关事件，应用“layui-table”样式类使其外观符合Layui框架的表格风格，便于统一页面风格及进行交互操作。 -->
                     <thead>
                     <tr>
+                        <!-- 创建表格中的表头行，用于放置各列的标题单元格（th元素），定义表格列的名称和顺序。 -->
                         <th>ID</th>
+                        <!-- 表头单元格，标题为“ID”，具体含义可能是每条学生记录在系统中的唯一标识序号等，用于区分不同学生记录，后续列会展示对应学生的详细信息。 -->
                         <th>学号</th>
+                        <!-- 表头单元格，显示“学号”标题，对应列展示学生的学号信息，方便识别和查找特定学生。 -->
                         <th>学院</th>
+                        <!-- 表头单元格，标题为“学院”，所在列呈现学生所属学院信息，帮助了解学生所在学院情况。 -->
                         <th>系别</th>
+                        <!-- 表头单元格，显示“系别”标题，其列展示学生所在系别的相关信息，进一步细化学生所属专业范畴。 -->
                         <th>班级</th>
+                        <!-- 表头单元格，标题为“班级”，对应列展示学生所在班级信息，便于在学院、系别基础上精准定位学生所在班级。 -->
                         <th>姓名</th>
+                        <!-- 表头单元格，显示“姓名”标题，所在列展示学生的具体姓名，方便直观认识学生。 -->
                         <th>性别</th>
+                        <!-- 表头单元格，标题为“性别”，其列展示学生的性别信息，属于基本个人信息范畴。 -->
                         <th>年龄</th>
+                        <!-- 表头单元格，标题为“年龄”，对应列展示学生的年龄情况，也是常见的个人信息内容。 -->
                         <th>城市</th>
+                        <!-- 表头单元格，标题为“城市”，所在列展示学生家庭所在城市等地址相关信息，丰富对学生的了解维度。 -->
                         <th>手机号</th>
+                        <!-- 表头单元格，显示“手机号”标题，其列展示学生的手机号码信息，便于联系沟通。 -->
                         <th>邮箱</th>
+                        <!-- 表头单元格，标题为“邮箱”，对应列展示学生的邮箱地址信息，同样可用于联系或发送相关信息等用途。 -->
                     </tr>
                     </thead>
 
                     <c:forEach items="${pb.list}" var="student" varStatus="s">
+                        <!-- 使用JSTL的“forEach”标签进行循环遍历操作，“items”属性指定要遍历的集合为“pb.list”（可能是从服务器端获取并封装好的当前页学生信息列表），“var”属性定义变量“student”用于接收每次循环取出的学生信息元素，“varStatus”定义变量“s”记录循环状态（如当前循环次数等）。 -->
                         <tr style="height: 70px;">
+                            <!-- 在循环体内创建表格的每一行，设置行高为70px，用于展示具体学生的各项信息，每循环一次生成一行数据展示在表格中。 -->
                             <td>${s.count}</td>
+                            <!-- 通过EL表达式输出循环状态变量“s”的“count”属性，即当前循环次数，作为序号展示在表格中，方便查看每行数据顺序及整体数据量情况。 -->
                             <td>${student.s_id}</td>
+                            <!-- 利用EL表达式输出从集合元素（赋值给“student”变量）中获取的学号信息，将具体学号值显示在表格对应单元格内，便于识别学生。 -->
                             <td>${student.s_college}</td>
+                            <!-- 同样使用EL表达式输出学生所属学院信息，展示在表格相应单元格，帮助了解学生所在学院。 -->
                             <td>${student.s_department}</td>
+                            <!-- 通过EL表达式输出学生所在系别信息，在表格对应单元格呈现，进一步明确学生专业相关情况。 -->
                             <td>${student.s_class}</td>
+                            <!-- 输出学生所在班级信息到表格单元格，方便精准定位学生所在班级情况。 -->
                             <td>${student.s_name}</td>
+                            <!-- 展示学生姓名信息到表格相应单元格，直观呈现学生个人信息。 -->
                             <td>${student.s_sex}</td>
+                            <!-- 输出学生性别信息到表格单元格，作为基本个人信息展示。 -->
                             <td>${student.s_age}</td>
+                            <!-- 展示学生年龄信息到表格对应单元格，属于常见个人信息展示内容。 -->
                             <td>${student.s_address}</td>
+                            <!-- 通过EL表达式输出学生家庭所在城市等地址相关信息，丰富对学生情况的了解维度。 -->
                             <td>${student.s_phone}</td>
+                            <!-- 输出学生手机号码信息到表格单元格，便于联系沟通等用途。 -->
                             <td>${student.s_email}</td>
+                            <!-- 展示学生邮箱地址信息到表格对应单元格，可用于联系或发送相关信息等操作。 -->
                         </tr>
                     </c:forEach>
                 </table>
                 <ul>
-
+                    <!-- 创建无序列表，用于放置分页相关的链接和页码显示元素，实现分页导航功能。 -->
                     <c:if test="${pb.currentPage == 1}">
+                        <!-- 使用JSTL的“if”条件判断标签，判断当前页码（“pb.currentPage”，可能是从服务器端传递过来表示当前显示的页码信息）是否等于1，如果是则执行下面的内容。 -->
                         <a href ="javascript:return false;">
+                            <!-- 创建链接元素，设置链接地址为“javascript:return false;”，意味着点击时不会进行实际的页面跳转，通常用于禁用当前链接，在这里就是禁用上一页链接（因为当前已经是第一页了）。 -->
                         </c:if>
                         <c:if test="${pb.currentPage!= 1}">
+                            <!-- 另一个“if”条件判断，当当前页码不等于1时，执行下面内容，即生成有效的上一页链接。 -->
                             <a href="${pageContext.request.contextPath}/findStudentByPageServlet?currentPage=${pb.currentPage-1}&rows=5&s_id=${condition.s_id[0]}&s_name=${condition.s_name[0]}">
+                                <!-- 创建链接元素，链接地址通过EL表达式动态生成，指向“findStudentByPageServlet”这个Servlet，并传递当前页码减1作为新页码（实现上一页功能），同时传递每页显示行数、学号、姓名等查询条件参数，点击可跳转到上一页对应的数据展示页面。 -->
                             </c:if>
-
                             <li class="page-li">上一页</li></a>
+                            <!-- 创建列表项元素，应用样式类“page-li”（可能是自定义的用于分页链接样式的类），文本显示为“上一页”，作为上一页的链接文本展示，点击时根据上述链接地址进行跳转（如果链接地址有效）。 -->
                     </a>
                     <c:forEach begin="1" end="${pb.totalPage}" var="i">
+                        <!-- 使用“forEach”标签进行循环遍历，从1开始到总页数（“pb.totalPage”，可能是从服务器端获取的总页码数量）结束，定义变量“i”表示当前页码，用于生成各页码的链接。 -->
                         <c:if test="${pb.currentPage == i}">
+                            <!-- 判断当前页码是否等于循环中的页码“i”，如果相等，说明是当前选中的页码，执行下面样式设置相关内容。 -->
                             <a href="${pageContext.request.contextPath}/findStudentByPageServlet?currentPage=${i}&rows=5&s_id=${condition.s_id[0]}&s_name=${condition.s_name[0]}"><li class="page-li" style="background-color: #009688;border-radius: 2px;color: white;">${i}</li></a>
+                            <!-- 创建链接元素，链接地址指向“findStudentByPageServlet”并传递当前页码等参数，在链接内创建列表项元素，应用“page-li”样式类并额外设置背景色、圆角、文字颜色等样式，使当前页码突出显示，文本显示为页码数字“i”，点击可跳转到对应页码的数据展示页面。 -->
                         </c:if>
                         <c:if test="${pb.currentPage!= i}">
+                            <!-- 当当前页码不等于循环中的页码“i”时，执行下面内容，生成普通页码链接样式。 -->
                             <a href="${pageContext.request.contextPath}/findStudentByPageServlet?currentPage=${i}&rows=5&s_id=${condition.s_id[0]}&s_name=${condition.s_name[0]}"><li class="page-li">${i}</li></a>
-                        </c:if>
-                    </c:forEach>
-
-                    <c:if test="${pb.currentPage == pb.totalPage}">
-                    <a href="javascript:return false;">
-                        </c:if>
-                        <c:if test="${pb.currentPage != pb.totalPage}">
-                        <a href="${pageContext.request.contextPath}/findStudentByPageServlet?currentPage=${pb.currentPage+1}&rows=5&s_id=${condition.s_id[0]}&s_name=${condition.s_name[0]}">
-                            </c:if>
-                            <li class="page-li">下一页</li></a>
-                </ul>
-
-                <fieldset class="layui-elem-field layui-field-title" style="margin-top: 0px;">
-                    <legend>共${pb.totalCount}条记录，共${pb.totalPage}页</legend>
-                </fieldset>
-                <jsp:include page="/footer.jsp"></jsp:include>
-            </div>
-        </div>
-    </div>
-
-
-<script type="text/javascript">
-    $("#nav li:nth-child(2) dl dd:nth-child(1)").addClass("layui-this");
-    $("#nav li:nth-child(2)").addClass("layui-nav-itemed");
-</script>
-<script>
-    //JavaScript代码区域
-    layui.use('element', function(){
-        var element = layui.element;
-        element.init();
-    });
-</script>
-
-</body>
-</html>
+                            <!-- 创建链接元素，链接地址类似上述

web/WEB-INF/teacher/tFindTeacherList.jsp

@@ -1,50 +1,94 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- JSP页面指令，用于设置页面的多项属性：
+    - “contentType”属性将页面内容类型设定为“text/html”，意味着这个页面会以HTML格式来呈现内容，这是网页内容展示的常见格式。
+    - “charset=UTF-8”明确了字符编码为UTF-8，通过这样的设置，页面能够正确处理和显示各种字符，像中文等非ASCII字符也不会出现乱码情况，从而保障页面内容的正常展现。
+    - “language=java”表明该JSP页面内部的业务逻辑是通过Java语言来实现的，例如可以在页面中嵌入Java代码片段进行诸如与服务器端的数据交互、对业务数据的处理等操作。 -->
+
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 引入JSTL（JavaServer Pages Standard Tag Library）核心标签库，通过指定“prefix”属性为“c”，后续在页面中就可以使用以“c”开头的各类JSTL标签了。这些标签提供了很多实用的功能，比如能够方便地实现对集合数据的循环遍历、进行条件判断、将服务器端传递的数据输出到页面等操作，大大增强了JSP页面在处理动态数据以及展示内容方面的灵活性与便利性。 -->
+
 <html>
 <head>
     <title>本院教师信息</title>
+    <!-- 设置HTML页面的标题，这个标题会在浏览器的标题栏中显示出来，其作用是让用户一眼就能知晓当前页面的主要功能或者主题是什么，在这里明确表示该页面是用于展示“本院教师信息”相关内容的。 -->
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入Layui框架的样式文件，通过相对路径“./css/layui.css”去查找对应的CSS文件，该文件中定义了一系列符合Layui框架风格的样式规则，使得页面中使用Layui框架相关的组件（例如表格、按钮、导航栏等元素）都能够按照预设的样式进行展示，进而让页面呈现出统一、美观且规范的视觉效果，保持整体风格的一致性。 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的样式文件“style.css”，开发人员可以在这个文件里依据项目的特定需求，对页面的样式进行个性化的定制。例如，可以对Layui框架的部分默认样式进行覆盖，或者添加一些独特的页面布局、颜色搭配等样式设定，以便使页面更好地契合整个项目的设计风格以及展示要求。 -->
     <script src="./layui.js"></script>
+    <!-- 引入Layui框架的JavaScript核心文件，有了这个文件的引入，页面就能调用Layui框架所提供的各种JavaScript功能了。比如，可以实现弹出层的展示、对表单进行验证、处理页面元素之间的交互操作（像点击按钮触发特定的事件、动态地显示或隐藏某些元素等）等功能，借助Layui框架的相关API，能够为页面添加丰富多样的交互性和动态效果，从而提升用户在使用页面过程中的体验感。 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 从CDN（内容分发网络）引入jQuery库的精简版本，jQuery是一款非常流行且功能强大的JavaScript库，它极大地简化了在HTML页面中进行DOM（Document Object Model，文档对象模型）操作的复杂度，像方便地遍历HTML文档中的元素、处理各种页面事件（例如鼠标的点击、键盘的输入等事件）、创建动画效果以及实现AJAX（Asynchronous JavaScript and XML，异步的JavaScript和XML）交互等操作，都可以通过使用jQuery库轻松地实现，这有助于开发人员更加便捷地在页面中构建各种交互功能，进一步增强页面整体的动态交互体验。 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 为页面主体设置样式类为“layui-layout-body”，同时通过内联样式设定背景颜色为“#F2F2F2”，这是按照Layui框架的样式规范来对页面主体部分的外观风格进行定义的，使得页面呈现出特定的背景颜色，有助于营造出整体统一的视觉效果，并且方便后续依据Layui框架既定的布局和样式规则来组织和展示页面中的其他各种内容元素。 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 使用JSP的“include”指令将名为“filterLogin.jsp”的页面包含进来，通常情况下，这个“filterLogin.jsp”页面主要负责处理用户登录验证相关的逻辑，例如它会判断当前访问该页面的用户是否已经成功登录到系统中，如果发现用户没有登录，那么就会引导用户跳转到登录页面进行登录操作，以此来实现对页面访问权限的有效管控，确保只有合法登录的用户才能够访问当前页面以及后续与之相关的各种功能内容，从而保障整个系统的数据安全以及业务逻辑的正常运行。 -->
     <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <!-- 包含名为“WEB-INF/teacher/tHeader.jsp”的页面，一般来讲，这个页面主要是用于定义教师端页面的头部区域的，在这个头部区域当中，通常会包含诸如页面的大标题、用于页面导航的导航栏、展示教师用户基本信息（例如用户名、头像等内容）等与头部相关的各种元素，通过这样的包含操作，就可以把这些头部相关的元素整合到当前页面之中，进而构建出一个完整且规范的页面头部布局结构。 -->
     <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 包含名为“WEB-INF/teacher/teacherNav.jsp”的页面，大概率它的作用是用于展示教师端的导航菜单的，借助这个导航菜单，教师用户就可以方便快捷地在不同的功能模块（例如课程管理、学生管理、个人信息管理等不同的功能板块，具体的功能模块划分要取决于业务系统的整体设计需求）之间进行切换操作，实现页面功能的导航跳转，为用户提供便捷的操作入口，从而提升用户使用整个系统的便利性。 -->
     <div class="layui-layout layui-layout-admin">
+        <!-- 创建一个基于Layui框架的布局容器，通过应用“layui-layout”和“layui-layout-admin”这两个样式类，按照Layui框架所提供的特定布局模式对页面进行布局规划，这种布局方式在后台管理系统等应用场景中是比较常用的，它有着清晰、规范的页面分区结构，能够便于合理地放置和展示页面内的各种功能内容模块，例如可以很方便地划分出侧边栏、主体内容展示区、页面底部的页脚等不同的区域。 -->
         <div class="layui-body">
+            <!-- 在上述所创建的Layui布局容器内定义页面的主体内容区域，这个区域会依据Layui框架既定的布局规则来进行自适应显示，它主要的作用是用于承载和展示与具体业务相关的核心内容，比如下面即将呈现出来的关于“本院教师信息”相关信息的表格等内容元素，这里也就是用户在访问该页面时重点关注和进行操作的区域。 -->
             <!-- 内容主体区域 -->
             <div style="padding: 15px;">
+                <!-- 创建一个带有内边距的div容器，通过设置“padding: 15px;”这样的内边距样式，意味着在这个容器的四周（也就是上、下、左、右四个方向）都会留出15像素的空白空间，这样做的好处是可以让容器内部的内容在页面中展示的时候有一定的间隔，使得页面的布局更加美观、易读，也更便于对内部的各个元素进行排版布局操作，避免内容显得过于拥挤，从而提升用户查看和操作页面内容时的体验感。 -->
                 <span class="layui-breadcrumb">
+                    <!-- 使用Layui框架的面包屑组件，其最主要的作用就是向用户清晰地展示当前页面的导航路径，让用户能够直观地了解当前页面在整个系统中的位置层级关系，通过面包屑组件所展示出来的路径信息，用户可以清楚地知道自己是如何一步步进入到当前这个“本院教师信息”页面的，同时也方便用户在需要的时候，能够按照这个路径进行回退或者跳转到相关的上级页面等操作，有效地提升了页面的导航便利性以及用户对整个系统结构的理解程度。 -->
                     <a href="">教师端</a>
+                    <!-- 面包屑中的第一个链接，通常情况下它是指向教师端的首页或者是整个教师端功能的主要入口页面的，不过在这里暂时没有设置具体的链接地址（可能后续会根据实际情况进一步去完善它），从理论上来说，用户点击该链接是可以引导其返回教师端的核心界面的，也就是回到一个相对比较顶层的功能页面位置上。 -->
                     <a href="">教师通讯录</a>
+                    <!-- 面包屑中的第二个链接，它所指向的是与教师通讯录相关的页面，这个页面可能是教师通讯录的总览页面或者是对教师信息进行分类展示的列表页面等相关页面，同样在这里暂时也没有设定具体的链接地址，一般情况下用户点击该链接就可以进入到对应的教师通讯录相关的界面中，进而去查看更详细的教师信息相关内容。 -->
                     <a><cite>本院教师信息</cite></a>
+                    <!-- 面包屑中的最后一个元素，明确地显示出当前页面的具体功能是“本院教师信息”，它主要起到一个标识当前所在功能位置的作用，通常情况下这个元素是不可点击的，仅仅是作为文字提示信息展示给用户，告知用户当前所处的具体业务功能页面是什么。 -->
                 </span>
                 <table class="layui-table" lay-filter="test">
+                    <!-- 创建一个使用Layui框架样式的表格，通过应用“layui-table”样式类使得表格的外观符合Layui框架所定义的表格风格，整体看上去会更加美观、专业，并且能够与整个系统的界面风格保持一致性要求。同时，利用“lay-filter”属性设置了一个过滤器名称为“test”，这个过滤器在后续的JavaScript代码中可以用于绑定表格相关的各种事件（例如当用户点击某一行数据时触发的事件、对表格中的数据进行排序时触发的事件、对单元格内容进行编辑时触发的事件等等），方便实现对表格的交互操作以及数据处理等功能，进而增强表格在实际使用过程中的实用性和用户交互性。 -->
                     <thead>
+                    <!-- 定义表格的表头部分，这部分主要是用于清晰地展示出各列所代表的标题信息，让用户在查看表格中的具体数据时，一眼就能明白每一列数据的含义以及所代表的内容属性，起到对数据列进行说明的作用，便于用户能够快速地理解和查看表格中所展示的具体数据内容。 -->
                     <tr>
+                        <!-- 创建表格中的一行，该行的作用是用于放置表头单元格（也就是th元素），每个th元素会对应表格中的一列标题，按照从左到右的顺序依次排列，这样就形成了一个完整的表头行结构。 -->
                         <th>ID</th>
+                        <!-- 表头单元格，标题为“ID”，此处的“ID”具体含义可能是每条教师记录在系统中的唯一标识编号，或者是按照一定规则生成的序号等，具体的含义要根据业务系统的设计需求来确定，其所在的列后续会展示相应的标识信息，方便对不同的教师记录进行区分和索引查找。 -->
                         <th>工号</th>
+                        <!-- 表头单元格，显示的标题是“工号”，对应列将会展示具体的教师工号信息，通过工号用户可以直观地了解到每个教师的基本编号，便于识别和区分不同的教师。 -->
                         <th>姓名</th>
+                        <!-- 表头单元格，标题为“姓名”，所在列会呈现出相应教师的具体姓名信息，这是最基本也是最直观的教师个人信息，方便用户对教师进行识别和称呼。 -->
                         <th>性别</th>
+                        <!-- 表头单元格，显示“性别”这一标题，其对应的表格列用于展示具体的教师性别信息，这属于教师的基本个人信息范畴，有助于更全面地了解教师情况。 -->
                         <th>文化程度</th>
+                        <!-- 表头单元格，标题为“文化程度”，所在列会展示教师的文化程度相关信息，比如学历水平等内容，对于了解教师的专业素养等方面有一定帮助。 -->
                         <th>职称</th>
+                        <!-- 表头单元格，标题为“职称”，对应的表格列用于展示教师的职称信息，职称通常反映了教师在专业领域内的级别和能力情况，是衡量教师专业水平的一个重要指标。 -->
                     </tr>
                     </thead>
 
                     <c:forEach items="${teachers}" var="teacher" varStatus="t">
+                        <!-- 使用JSTL（JavaServer Pages Standard Tag Library）的“forEach”标签来进行循环遍历操作。
+                            - “items”属性指定了要遍历的集合对象，在这里就是名为“teachers”的集合（这个集合通常是在服务器端，比如对应的Servlet中通过查询数据库或者其他数据存储方式获取到的教师相关数据，然后将这些数据封装成集合的形式，再设置并传递到当前的JSP页面中来的）。
+                            - “var”属性定义了一个变量名“teacher”，在每次循环的过程中，会从“teachers”集合里依次取出每一个元素，并将当前取出的元素赋值给这个变量，方便在循环体内部使用该变量来获取元素中的具体数据内容，例如教师的各个属性信息等。
+                            - “varStatus”属性则是定义了一个循环状态变量“t”，这个变量可以获取到循环的一些状态信息，例如当前循环的次数、是否是第一次或者最后一次循环等，在这里主要是利用它的“count”属性（也就是当前循环的次数）来展示序号等相关信息，以此增强表格数据展示的可读性，让用户更清晰地查看每一行数据的顺序以及整体的数据数量情况。 -->
                         <tr  style="height: 70px;">
+                            <!-- 在循环体内部创建表格的每一行，用于展示具体的教师相关数据内容，每一次循环就会生成一行数据展示在表格中，并且通过设置“style="height: 70px;"”为每行设置了一个固定的行高，使表格看上去更加规整，通过这样的循环操作，就可以将集合中的所有教师数据逐行地展示出来，从而形成一个完整的数据表格展示效果。 -->
                             <td>${t.count}</td>
+                            <!-- 通过EL表达式（Expression Language）输出循环状态变量“t”的“count”属性，也就是当前循环的次数，将其作为序号展示在表格的这一单元格中，方便用户能够清晰地查看每一行数据的顺序以及整体的数据数量情况，使得数据在表格中的展示更加有条理，便于用户快速地定位和查看特定行的数据内容。 -->
                             <td>${teacher.t_id}</td>
+                            <!-- 利用EL表达式输出从集合元素（赋值给“teacher”变量）中获取的工号信息，将具体的教师工号值显示在表格对应的单元格内，以便用户直观地看到每一个教师的具体工号，方便对教师进行识别和区分。 -->
                             <td>${teacher.t_name}</td>
+                            <!-- 同样使用EL表达式输出集合元素中包含的姓名信息，在表格相应的单元格中展示具体的教师姓名内容，使得用户可以清楚地知道每一行数据对应的是哪一位教师，便于进行查看和管理等操作。 -->
                             <td>${teacher.t_sex}</td>
+                            <!-- 通过EL表达式输出集合元素里的性别信息，将教师的性别信息展示在表格对应的单元格中，让用户能够了解到教师的这一基本个人信息情况。 -->
                             <td>${teacher.t_education}</td>
+                            <!-- 利用EL表达式输出教师的文化程度相关信息，将学历水平等文化程度内容展示在表格对应的单元格中，帮助用户进一步了解教师的专业素养等方面的情况。 -->
                             <td>${teacher.t_title}</td>
+                            <!-- 通过EL表达式输出教师的职称信息，将职称相关内容展示在表格对应的单元格中，便于用户知晓教师在专业领域内的级别和能力情况。 -->
                         </tr>
                     </c:forEach>
                 </table>
                 <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含名为“footer.jsp”的页面，通常这个页面主要是用于定义页面的底部区域的，在这个页面里可能会包含诸如版权信息、联系方式、页面底部导航等相关内容，通过这样的包含操作，可以完善整个页面的布局结构，使其更加完整、规范，给用户呈现出一个完整的页面视觉效果，同时也方便在底部展示一些通用的重要信息或者提供额外的操作入口等。 -->
             </div>
         </div>
     </div>
@@ -52,15 +96,6 @@
 
     <script type="text/javascript">
         $("#nav li:nth-child(3) dl dd:nth-child(1)").addClass("layui-this");
+        // 使用jQuery选择器来定位页面中特定的元素，具体选择的是id为“nav”的元素下的第三个li元素内的dl元素中的第一个dd元素，然后为其添加“layui-this”样式类。这么做大概率是为了在导航菜单中标记当前选中的菜单项（依据页面本身的导航结构和样式设置逻辑来确定），使其呈现出被选中的视觉效果，例如改变颜色、加粗等样式变化，从而清晰地表明当前所在的功能页面对应的导航位置，方便用户直观地知晓当前所处的功能模块在整个导航体系中的位置关系。
         $("#nav li:nth-child(3)").addClass("layui-nav-itemed");
-</script>
-<script>
-    //JavaScript代码区域
-    layui.use('element', function(){
-        var element = layui.element;
-        element.init();
-    });
-</script>
-
-</body>
-</html>
+        // 同样利用jQuery选择器选择id为“nav”的元素下的第三个li元素，并为其添加“layui-nav-itemed”样式类，这通常是用于展开或折叠对应的导航菜单项目，使其显示出该导航项处于展开状态的视觉效果（按照Layui导航组件

web/WEB-INF/teacher/tHeader.jsp

@@ -1,41 +1,69 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
+<!-- JSP页面指令，用于设置页面相关属性：
+    - “contentType”属性指定页面内容类型为“text/html”，表明页面以HTML格式展示内容，同时设置字符编码为“UTF-8”，确保能正确处理和显示各种字符（如中文等），避免乱码。
+    - “language=java”说明该页面内部逻辑使用Java语言来实现，比如与服务器交互、处理业务数据等操作可通过Java代码完成。
+    - “pageEncoding”属性再次明确页面的编码格式为“UTF-8”，它主要用于指定JSP页面本身的编码方式，与“contentType”中的编码设置相配合，保证整个页面字符处理的一致性。 -->
+
 <html>
 <head>
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入Layui框架的样式文件，通过相对路径“./css/layui.css”找到对应的CSS文件，该文件定义了Layui框架相关组件（如导航栏、表格、按钮等元素）的样式规则，使页面运用Layui框架的元素按预设样式展示，保持页面整体风格统一、美观。 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的样式文件“style.css”，开发人员可在其中对页面样式进行个性化定制，例如覆盖Layui框架部分默认样式，或添加特定的布局、颜色搭配等样式设置，使其符合项目的特定设计需求。 -->
     <link rel="icon" href="./images/favicon.ico" type="image/x-icon">
+    <!-- 设置页面的图标（favicon），浏览器在地址栏、书签栏等位置会显示该图标，通过指定相对路径“./images/favicon.ico”找到对应的图标文件，其类型为“image/x-icon”，用于标识该网页，增强页面的辨识度。 -->
     <link rel="shortcut icon" href="./images/favicon.ico" type="image/x-icon">
+    <!-- 同样是设置页面的快捷方式图标，和上面“link rel="icon"”作用类似，在不同浏览器或操作系统环境下，确保当页面被添加为快捷方式时能正确显示对应的图标，提升用户体验和页面的品牌辨识度。 -->
     <script src="layui.js"></script>
+    <!-- 引入Layui框架的JavaScript核心文件，借助这个文件，页面可调用Layui框架提供的各种JavaScript功能，像弹出层展示、表单验证、页面元素交互等，为页面添加丰富的交互性和动态效果，提升用户操作体验。 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 从CDN（内容分发网络）引入jQuery库的精简版本，jQuery是常用的JavaScript库，能简化HTML文档遍历、事件处理、动画效果创建以及AJAX交互等操作，方便开发人员操作DOM元素，实现各种交互功能，进一步增强页面动态交互性。 -->
 </head>
 <body class="layui-layout-body">
+    <!-- 为页面主体设置样式类为“layui-layout-body”，这通常是遵循Layui框架的样式规范，意味着页面主体部分将应用Layui框架相关的布局样式，方便后续按照框架既定的布局方式来组织页面内容，营造出符合框架风格的页面整体效果。 -->
     <div class="layui-layout layui-layout-admin">
+        <!-- 创建采用Layui框架的布局容器，使用“layui-layout”和“layui-layout-admin”样式类，按Layui框架提供的布局模式规划页面布局，常用于后台管理系统，有着清晰规范的分区结构，便于组织不同功能内容，比如划分出头部、侧边栏、主体内容区、页脚等区域。 -->
         <div class="layui-header">
+            <!-- 在Layui布局容器内定义页面的头部区域，该区域一般用于放置页面的标题、导航菜单等重要元素，是用户进入页面首先看到且频繁操作的部分，对于页面的整体导航和功能引导起着关键作用。 -->
             <div class="layui-logo" style="font-size: 52px">SIMS</div>
+            <!-- 创建一个带有特定样式（设置字体大小为52px）的div元素，用于展示页面的标识或名称，这里显示的是“SIMS”，通常作为网站或系统的品牌标识展示在头部显眼位置，方便用户识别和区分不同的系统。 -->
             <!-- 头部区域（可配合layui已有的水平导航） -->
             <ul class="layui-nav layui-layout-left">
+                <!-- 创建一个使用Layui框架样式的无序列表，作为水平导航菜单的容器，应用“layui-nav”样式类使其呈现出Layui框架定义的导航样式，“layui-layout-left”样式类用于控制导航在页面头部靠左布局，里面放置具体的导航菜单项，方便用户在页面不同功能模块间进行切换操作。 -->
                 <li class="layui-nav-item"><a class = "layui-icon layui-icon-home" id="fresh" href="index.jsp"> 主页</a></li>
+                <!-- 创建导航菜单中的一个菜单项，应用“layui-nav-item”样式类使其具备Layui框架中菜单项的基本样式效果，里面包含一个链接元素，链接应用“layui-icon layui-icon-home”样式类展示对应的图标（这里是主页图标），设置ID为“fresh”，链接地址指向“index.jsp”，点击可跳转到主页页面，文本显示为“ 主页”，方便用户返回系统首页。 -->
                 <li class="layui-nav-item "><a class = "layui-icon layui-icon-refresh-3" href="javascript:location.reload();"> 刷新</a></li>
+                <!-- 同样创建菜单项，图标样式为“layui-icon layui-icon-refresh-3”表示刷新图标，链接地址设置为“javascript:location.reload();”，意味着点击该链接会执行JavaScript代码来刷新当前页面，实现页面内容的重新加载，文本显示为“ 刷新”，方便用户手动刷新页面查看最新数据或状态。 -->
                 <li class="layui-nav-item">
                     <a class="layui-icon layui-icon-link" href="javascript:;"> 其它</a>
+                    <!-- 创建菜单项，图标样式为“layui-icon layui-icon-link”，链接地址暂时设置为“javascript:;”，表示点击暂时不会进行页面跳转（可能后续通过JavaScript代码添加点击事件来实现具体的交互逻辑），文本显示为“ 其它”，作为一个可展开的父级菜单，用于包含更多相关的子菜单选项。 -->
                     <dl class="layui-nav-child">
+                        <!-- 创建一个定义列表（dl）元素，应用“layui-nav-child”样式类，用于放置“其它”菜单项下的子菜单列表，使其呈现出子菜单的样式效果，与父级菜单在视觉上进行区分，且符合Layui框架的导航菜单结构规范。 -->
                         <dd><a href="#">小吐槽</a></dd>
+                        <!-- 创建一个定义列表项（dd）元素，里面包含一个链接元素，链接暂时指向一个空的地址（“#”），通常表示在当前页面内进行定位（这里可能后续会完善具体的跳转逻辑），文本显示为“小吐槽”，点击可进入对应的小吐槽相关功能页面（具体功能需后续开发完善）。 -->
                         <dd><a href="${pageContext.request.contextPath}/notifyListToServlet">学校公告</a></dd>
+                        <!-- 创建定义列表项及链接元素，链接通过EL表达式（Expression Language）动态生成，指向“notifyListToServlet”这个Servlet，点击可跳转到对应的Servlet处理逻辑，用于展示学校公告相关信息，文本显示为“学校公告”，方便用户查看学校发布的各类通知公告信息。 -->
                     </dl>
                 </li>
             </ul>
             <ul class="layui-nav layui-layout-right">
+                <!-- 创建另一个使用Layui框架样式的无序列表，应用“layui-nav”样式类呈现导航样式，“layui-layout-right”样式类用于控制导航在页面头部靠右布局，通常用于放置与用户相关的操作菜单，如用户登录信息、设置、退出等功能选项。 -->
                 <li class="layui-nav-item">
                     <a href="javascript:;">
                         <img src="${pageContext.request.contextPath}/showPhotoServlet" class="layui-nav-img">
                         ${teacher.t_id} ${teacher.t_name}
                     </a>
+                    <!-- 创建菜单项，链接地址暂时设置为“javascript:;”，表示点击暂时不会进行页面跳转（后续可能添加逻辑），里面包含一个图片元素，图片的来源地址通过EL表达式指向“showPhotoServlet”这个Servlet（大概率是用于获取并展示用户的头像图片），应用“layui-nav-img”样式类使其按照Layui框架中导航栏图片的样式显示，后面跟着通过EL表达式显示的教师工号（${teacher.t_id}）和教师姓名（${teacher.t_name}），整体用于展示当前登录教师的基本信息，方便用户知晓当前登录身份。 -->
                     <dl class="layui-nav-child">
+                        <!-- 创建子菜单列表容器，用于放置该菜单项展开后的子菜单选项，符合Layui框架导航结构规范。 -->
                         <dd><a href="#">个人信息</a></dd>
+                        <!-- 创建定义列表项及链接元素，链接暂时指向空地址（“#”），表示在当前页面内定位（后续可能完善具体跳转逻辑），文本显示为“个人信息”，点击可进入查看或编辑个人信息的相关页面（功能需后续开发）。 -->
                         <dd><a href="${pageContext.request.contextPath}/logoutServlet">退出</a></dd>
+                        <!-- 创建定义列表项及链接元素，链接通过EL表达式指向“logoutServlet”这个Servlet，点击可执行退出登录的操作，跳转到对应的Servlet处理逻辑，实现安全退出系统的功能，文本显示为“退出”，方便用户结束当前登录会话。 -->
                     </dl>
                 </li>
                 <li class="layui-nav-item"><a class="layui-icon layui-icon-about" href="JavaScript:alertabout()"> 关于</a></li>
+                <!-- 创建菜单项，图标样式为“layui-icon layui-icon-about”表示关于图标，链接地址设置为“JavaScript:alertabout()”，意味着点击该链接会调用名为“alertabout”的JavaScript函数（在后续代码中有定义），用于展示关于系统的相关信息，文本显示为“ 关于”，方便用户了解系统的基本情况、版本信息等内容。 -->
             </ul>
         </div>
     </div>
@@ -44,12 +72,15 @@
         layui.use('element', function(){
             var element = layui.element;
             element.init();
+            // 使用Layui框架的模块加载机制，加载“element”模块，获取该模块实例并赋值给变量“element”，然后调用模块的“init”方法进行初始化操作。“element”模块在Layui框架中通常用于页面元素的操作、动态渲染以及交互效果实现等，通过初始化该模块，可以准备好相关的DOM操作环境、绑定必要的事件等，确保模块能正常工作，进而实现页面中基于该模块的各种功能，例如展开收起导航菜单、切换菜单项的选中状态等操作，使得导航菜单具备相应的交互功能。
         });
     </script>
     <script type="text/javascript">
         function alertabout() {
             alert("学生信息管理系统\n陈双全1812123206");
+            // 定义一个名为“alertabout”的JavaScript函数，当被调用时，会弹出一个提示框，提示框内显示“学生信息管理系统”以及“陈双全1812123206”这两行文本信息，通常用于向用户展示系统的相关说明信息，比如系统名称、开发者信息等内容。
         }
     </script>
+
 </body>
 </html>

web/WEB-INF/teacher/tIndex.jsp

@@ -1,13 +1,21 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- JSP页面指令，用于设置页面的相关属性：
+    - “contentType”属性指定页面内容类型为“text/html”，表明页面以HTML格式展示内容，同时设置字符编码为“UTF-8”，这样能确保页面可以正确处理和显示各种字符（如中文等），避免出现乱码情况，保证页面内容正常展示。
+    - “language=java”说明该JSP页面内部的逻辑实现是基于Java语言的，例如可以在页面中嵌入Java代码片段来与服务器端进行交互、处理业务数据等操作。 -->
+
 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 引入JSTL（JavaServer Pages Standard Tag Library）核心标签库，通过设定“prefix”属性为“c”，后续在页面里就能使用以“c”开头的各种JSTL标签了。这些标签能够方便地实现诸如循环遍历集合数据、进行条件判断、将数据输出到页面等常见功能，大大增强了JSP页面在处理动态数据和展示内容方面的灵活性与便利性。 -->
+
 <html>
 <head>
     <title>${html_title}</title>
+    <!-- 设置HTML页面的标题，不过这里使用了EL表达式（Expression Language），意味着标题的值是动态从服务器端传递过来的，具体的标题内容会根据服务器设置的“html_title”变量值来显示，方便灵活地定制页面标题。 -->
     <script>
         //JavaScript代码区域
         layui.use('element', function(){
             var element = layui.element;
             element.init();
+            // 使用Layui框架的模块加载机制，加载“element”模块，获取该模块的实例并赋值给变量“element”，然后调用“init”方法进行初始化操作。“element”模块在Layui框架中通常用于页面元素的操作、动态渲染以及交互效果实现等，通过初始化该模块，可以准备好相关的DOM操作环境、绑定必要的事件等，确保模块能正常工作，进而实现页面中基于该模块的各种功能，例如展开收起导航菜单、切换菜单项的选中状态等操作，使得页面元素具备相应的交互功能。
         });
     </script>
     <style>
@@ -23,32 +31,59 @@
             color: #333;
             transition: all.3s;
             -webkit-transition: all.3s;
+            /* 以下是对类选择器组合“layui-card.layui-card-body.layui-icon”所匹配元素的样式设置：
+            - “display: inline-block;”：将元素设置为行内块级元素，使其既能像行内元素一样在一行内排列，又能像块级元素一样设置宽度、高度等属性，方便布局和样式控制。
+            - “width: 100%;”：设置元素宽度占满其所在容器的宽度，确保在相应布局中能充分利用空间。
+            - “height: 60px;”和“line-height: 60px;”：分别设置元素的高度以及行高为60像素，使元素内的文本在垂直方向上居中显示，达到美观的排版效果。
+            - “text-align: center;”：让元素内的文本内容在水平方向上居中显示，进一步优化排版布局。
+            - “border-radius: 2px;”：给元素设置2像素的圆角效果，使元素外观更加圆润，增加视觉美感。
+            - “font-size: 30px;”：设置元素内文本的字体大小为30像素，调整文本显示的大小，使其更醒目易读。
+            - “background-color: #F8F8F8;”：指定元素的背景颜色为浅灰色（#F8F8F8），为元素提供一个特定的背景色调，便于视觉区分和整体页面风格统一。
+            - “color: #333;”：设置元素内文本的颜色为深灰色（#333），确保文本颜色与背景色搭配协调，提高可读性。
+            - “transition: all.3s;”和“-webkit-transition: all.3s;”：定义元素在进行样式变化时的过渡效果，这里表示所有样式属性的变化都将在0.3秒内平滑过渡，用于实现一些动态交互时的视觉效果优化（如鼠标悬停等操作时元素样式改变的过渡效果），“-webkit-transition”是为了兼容webkit内核的浏览器（如Chrome、Safari等）。 */
         }
        .layui-card.layui-card-body {
             text-align: center;
+            /* 对类选择器组合“layui-card.layui-card-body”所匹配元素的样式设置，将元素内的文本内容在水平方向上设置为居中对齐，使得在该类元素内部包含的内容整体呈现居中布局效果，常用于对卡片主体内容进行排版布局，保证页面整体风格统一和美观。 */
         }
         #notify {
             text-align: left;
+            /* 通过ID选择器“#notify”对特定元素设置样式，将匹配元素内的文本内容在水平方向上设置为左对齐，这里可能是针对特定的通知内容区域进行的样式调整，使其文本按照常规的阅读习惯从左到右排列，方便用户查看相关信息。 */
         }
 
     </style>
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 为页面主体设置样式类为“layui-layout-body”，同时通过内联样式设定背景颜色为“#F2F2F2”，按照Layui框架的样式规范定义主体部分外观风格，营造出一种浅灰色（#F2F2F2）的视觉背景，符合项目统一的页面设计要求，便于后续布局页面内容，并且使页面整体视觉效果保持一致。 -->
     <%--<jsp:include page="/filterLogin.jsp"></jsp:include>--%>
+    <!-- 此处原本是通过JSP的“include”指令包含名为“filterLogin.jsp”的页面，一般这个页面用于处理用户登录验证逻辑，判断用户是否已登录，未登录时引导用户跳转到登录页面，不过这里被注释掉了，可能暂时不需要该登录验证功能或者后续会根据实际情况再启用它。 -->
     <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <!-- 通过JSP的“include”指令包含名为“WEB-INF/teacher/tHeader.jsp”的页面，通常该页面用于定义教师端页面的头部区域，包含如页面标题、导航栏、用户信息展示等元素，构建出页面头部的布局结构，使页面头部呈现规范的样式和功能。 -->
     <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 包含名为“WEB-INF/teacher/teacherNav.jsp”的页面，大概率用于展示教师端的导航菜单，方便教师在不同功能模块（如课程管理、学生管理、个人信息管理等）间切换操作，实现页面功能的导航跳转，提高操作便利性。 -->
     <div class="layui-layout layui-layout-admin">
+        <!-- 创建采用Layui框架的布局容器，使用“layui-layout”和“layui-layout-admin”样式类，按Layui框架提供的布局模式规划页面布局，常用于后台管理系统，有着清晰规范的分区结构，便于组织不同功能内容，比如划分出侧边栏、主体内容区、页脚等区域，使页面布局更加合理有序，符合后台管理系统的使用习惯和功能展示需求。 -->
         <div class="layui-body">
+            <!-- 在Layui布局容器内定义页面主体内容区域，该区域依Layui框架布局规则自适应显示，用于承载具体业务相关内容，像下面展示的功能列表、学校公告等信息，是用户在访问页面时重点关注和进行操作的核心区域。 -->
             <!-- 内容主体区域 -->
             <div style="padding: 15px;">
+                <!-- 创建带有内边距（上下左右均为15px）的div容器，通过设置内边距让内部内容在页面中有空白间隔，使布局更美观易读，便于对内部元素排版布局，避免内容显得拥挤，提升用户查看和操作页面内容时的体验感。 -->
                 <div class="layui-card">
+                    <!-- 创建一个使用Layui框架样式的卡片元素，通常用于对相关内容进行分组展示，使其在页面上有一个清晰的视觉边界，方便用户区分不同的功能模块或者信息板块，符合Layui框架的页面布局和展示风格。 -->
                     <div class="layui-card-header" id="index-function">功能</div>
+                    <!-- 创建卡片的头部区域元素，设置ID为“index-function”，文本内容显示为“功能”，用于给卡片添加一个标题，提示下面卡片主体内容所涉及的大致范畴，让用户一目了然知道该部分的主要作用。 -->
                     <div class="layui-card-body">
+                        <!-- 创建卡片的主体内容区域元素，用于放置具体的功能相关内容，在这里会展示一系列功能链接等元素，是卡片中实际展示核心信息的部分。 -->
                         <ul class="layui-row layui-col-space10 layui-this">
+                            <!-- 创建一个使用Layui框架样式的无序列表，应用“layui-row”样式类使其具备行布局的特点，“layui-col-space10”样式类用于设置列表项之间的水平间距为10像素，“layui-this”样式类可能是用于标记当前选中或特殊样式的状态（具体取决于Layui框架的样式定义），整体用于放置多个功能相关的列表项元素，方便以列表形式展示各项功能入口，并且实现一定的布局和样式效果。 -->
                             <li class="layui-col-xs3">
+                                <!-- 创建列表项元素，应用“layui-col-xs3”样式类，意味着该元素在小屏幕设备（如手机等）上会占据3列的宽度（基于Layui框架的栅格系统布局规则），方便实现响应式布局，根据不同设备屏幕大小合理分配空间，展示功能链接等内容。 -->
                                 <a lay-href="/mavenTemplate/student/query">
+                                    <!-- 创建一个链接元素，使用了Layui框架自定义的“lay-href”属性（可能是用于实现特定的链接跳转逻辑或者与Layui框架的交互功能相关），链接地址指向“/mavenTemplate/student/query”，点击可跳转到对应的学生信息查询功能页面，用于引导用户进入相关功能操作界面。 -->
                                     <i class="layui-icon layui-icon-survey"></i>
+                                    <!-- 创建一个图标元素，应用“layui-icon”样式类以及具体的图标样式“layui-icon-survey”，用于展示特定的图标（这里可能是表示查询相关的图标），增强功能链接的可视化效果，让用户更直观地识别功能。 -->
                                     <cite>学生信息查询</cite>
+                                    <!-- 创建一个引用（cite）元素，用于显示具体的功能名称文本“学生信息查询”，明确告知用户该链接对应的功能是什么，方便用户进行操作选择。 -->
                                 </a>
                             </li>
                             <li class="layui-col-xs3">
@@ -56,62 +91,63 @@
                                     <i class="layui-icon layui-icon-survey"></i>
                                     <cite>教师信息查询</cite>
                                 </a>
+                                <!-- 与上述“学生信息查询”功能项类似，创建教师信息查询的功能链接元素，包含对应的图标展示和功能名称文本显示，链接地址指向“/mavenTemplate/teacher/query”，点击可进入教师信息查询相关页面，方便教师查询教师相关信息。 -->
                             </li>
                             <li class="layui-col-xs3">
                                 <a lay-href="/mavenTemplate/class/query">
                                     <i class="layui-icon layui-icon-survey"></i>
                                     <cite>班级信息查询</cite>
                                 </a>
+                                <!-- 同样的结构，创建班级信息查询的功能链接元素，展示对应图标，显示功能名称“班级信息查询”，链接指向“/mavenTemplate/class/query”，用于引导用户进入班级信息查询功能页面，获取班级相关信息。 -->
                             </li>
                             <li class="layui-col-xs3">
                                 <a lay-href="/mavenTemplate/major/query">
                                     <i class="layui-icon layui-icon-survey"></i>
                                     <cite>专业&amp;学院信息查询</cite>
                                 </a>
+                                <!-- 创建专业和学院信息查询的功能链接元素，展示图标并显示功能名称“专业&amp;学院信息查询”（这里“&amp;”是HTML中表示“&”符号的实体编码，用于正确显示“专业&学院信息查询”这样的文本内容），链接地址指向“/mavenTemplate/major/query”，方便用户查询专业和学院相关信息。 -->
                             </li>
                             <li class="layui-col-xs3">
                                 <a lay-href="/mavenTemplate/user/info">
                                     <i class="layui-icon layui-icon-user"></i>
                                     <cite>个人资料</cite>
                                 </a>
+                                <!-- 创建个人资料查看或编辑相关的功能链接元素，图标样式为“layui-icon-user”表示用户相关图标，显示功能名称“个人资料”，链接指向“/mavenTemplate/user/info”，点击可进入个人资料管理相关页面，方便用户查看和修改自己的个人信息。 -->
                             </li>
                             <li class="layui-col-xs3">
                                 <a lay-href="/mavenTemplate/user/password">
                                     <i class="layui-icon layui-icon-set"></i>
                                     <cite>修改密码</cite>
                                 </a>
+                                <!-- 创建用于修改密码的功能链接元素，图标样式为“layui-icon-set”（可能表示设置相关图标），显示功能名称“修改密码”，链接指向“/mavenTemplate/user/password”，点击可进入密码修改功能页面，方便用户更新自己的登录密码，保障账号安全。 -->
                             </li>
                             <li class="layui-col-xs3">
                                 <a lay-href="/mavenTemplate/user/email">
                                     <i class="layui-icon layui-icon-set"></i>
                                     <cite>修改邮箱</cite>
                                 </a>
+                                <!-- 创建修改邮箱的功能链接元素，同样使用“layui-icon-set”图标样式，显示功能名称“修改邮箱”，链接指向“/mavenTemplate/user/email”，点击可进入邮箱修改功能页面，便于用户更新自己关联账号的邮箱地址等信息。 -->
                             </li>
                             <li class="layui-col-xs3">
                                 <a lay-href="/mavenTemplate/student/modify">
                                     <i class="layui-icon layui-icon-survey"></i>
                                     <cite>学生信息修改</cite>
                                 </a>
+                                <!-- 创建学生信息修改的功能链接元素，图标为“layui-icon-survey”，显示功能名称“学生信息修改”，链接指向“/mavenTemplate/student/modify”，点击可进入对学生信息进行修改的功能页面，方便教师等有权限用户对学生相关信息进行编辑更新操作。 -->
                             </li>
                         </ul>
                     </div>
                 </div>
                 <div class="layui-card">
+                    <!-- 再次创建一个Layui框架样式的卡片元素，用于展示另一个功能模块或者信息板块的内容，这里用于展示学校最新公告相关信息，通过卡片形式使其与其他内容区分开来，保持页面布局的清晰性和可读性。 -->
                     <div class="layui-card-header">学校最新公告</div>
+                    <!-- 创建卡片的头部区域元素，文本内容显示为“学校最新公告”，用于给该卡片添加标题，明确提示下面卡片主体内容是关于学校最新发布的公告信息，方便用户快速知晓该部分的主题。 -->
                     <c:forEach items="${notifys}" var="notify">
+                        <!-- 使用JSTL（JavaServer Pages Standard Tag Library）的“forEach”标签来进行循环遍历操作，“items”属性指定了要遍历的集合对象，在这里就是名为“notifys”的集合（这个集合通常是在服务器端，比如对应的Servlet中通过查询数据库或者其他数据存储方式获取到的学校公告相关数据，然后将这些数据封装成集合的形式，再设置并传递到当前的JSP页面中来的），“var”属性定义了一个变量名“notify”，在每次循环的过程中，会从“notifys”集合里依次取出每一个元素，并将当前取出的元素赋值给这个变量，方便在循环体内部使用该变量来获取元素中的具体数据内容，例如公告的详细信息、发布日期等。 -->
                         <div class="layui-card-body" id="notify">${notify.notifyInfo}<p>${notify.notifyDate}</div>
+                        <!-- 在循环体内部创建卡片的主体内容区域元素，应用ID为“notify”（与前面定义的样式选择器匹配，可能用于特定的样式应用），通过EL表达式输出从集合元素（赋值给“notify”变量）中获取的公告详细信息（“${notify.notifyInfo}”）以及公告发布日期（“${notify.notifyDate}”），不过这里的HTML结构不太规范，应该将“<p>”标签正确闭合，如“<div class="layui-card-body" id="notify">${notify.notifyInfo}</div><p>${notify.notifyDate}</p>”，这样才能正确展示公告信息和日期，且符合HTML语法规范，方便用户查看学校发布的每条公告的具体内容和发布时间。 -->
                     </c:forEach>
                 </div>
             </div>
         </div>
-    <jsp:include page="/footer.jsp"></jsp:include>
     </div>
-<script type="text/javascript">
-    $("#nav li:nth-child(1)").addClass("layui-nav-itemed");
-    $("#nav li:nth-child(2)").addClass("layui-nav-itemed");
-    $("#nav li:nth-child(3)").addClass("layui-nav-itemed");
-    $("#nav li:nth-child(4)").addClass("layui-nav-itemed");
-    $("#nav li:nth-child(5)").addClass("layui-nav-itemed");
-</script>
-</body>
-</html>

web/WEB-INF/teacher/tInformation.jsp

@@ -1,37 +1,65 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- JSP页面指令，用于设置页面的相关属性：
+    - “contentType”属性指定页面内容类型为“text/html”，意味着页面以HTML格式展示内容，同时设置字符编码为“UTF-8”，这样能确保页面可以正确处理和显示各种字符（如中文等），避免出现乱码情况，保证页面内容正常展示。
+    - “language=java”表明该JSP页面内部的逻辑实现是基于Java语言的，例如可以在页面中嵌入Java代码片段来与服务器端进行交互、处理业务数据等操作。 -->
+
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 引入JSTL（JavaServer Pages Standard Tag Library）核心标签库，通过设定“prefix”属性为“c”，后续在页面里就能使用以“c”开头的各种JSTL标签了。这些标签能够方便地实现诸如循环遍历集合数据、进行条件判断、将数据输出到页面等常见功能，大大增强了JSP页面在处理动态数据和展示内容方面的灵活性与便利性。 -->
+
 <html>
 <head>
     <title>个人信息</title>
+    <!-- 设置HTML页面的标题，这里明确表示页面是用于展示“个人信息”相关内容的，该标题会显示在浏览器的标题栏中，方便用户一眼就能知晓当前页面的主题。 -->
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入Layui框架的样式文件，通过相对路径“./css/layui.css”去定位对应的CSS文件，该文件中定义了一系列符合Layui框架风格的样式规则，使得页面中运用Layui框架相关的组件（例如表格、按钮、导航栏等元素）都能按照预设的样式进行展示，从而让页面呈现出统一、美观且规范的视觉效果，保持整体风格的一致性。 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的样式文件“style.css”，开发人员可以在这个文件里根据项目的特定需求，对页面的样式进行个性化定制。例如，可以对Layui框架的部分默认样式进行覆盖，或者添加一些独特的页面布局、颜色搭配等样式设定，以便让页面更好地契合整个项目的设计风格和展示要求。 -->
     <script src="./layui.js"></script>
+    <!-- 引入Layui框架的JavaScript核心文件，有了这个文件的引入，页面就能调用Layui框架所提供的各种JavaScript功能了。比如，可以实现弹出层的展示、对表单进行验证、处理页面元素之间的交互操作（像点击按钮触发特定的事件、动态地显示或隐藏某些元素等）等功能，通过使用Layui框架的相关API，能够为页面添加丰富多样的交互性和动态效果，进而提升用户在使用页面过程中的体验感。 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 从CDN（内容分发网络）引入jQuery库的精简版本，jQuery是一款广受欢迎且功能十分强大的JavaScript库，它极大地简化了在HTML页面中进行DOM（Document Object Model，文档对象模型）操作的复杂度，像方便地遍历HTML文档中的元素、处理各种页面事件（例如鼠标的点击、键盘的输入等事件）、创建动画效果以及实现AJAX（Asynchronous JavaScript and XML，异步的JavaScript和XML）交互等操作，都能通过使用jQuery库轻松实现，这有助于开发人员更加便捷地在页面中构建各种交互功能，进一步增强页面整体的动态交互体验。 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 为页面主体设置样式类为“layui-layout-body”，同时通过内联样式设定背景颜色为“#F2F2F2”，这是按照Layui框架的样式规范来对页面主体部分的外观风格进行定义，使得页面呈现出特定的背景颜色，有助于营造出整体统一的视觉效果，并且方便后续依据Layui框架既定的布局和样式规则来组织和展示页面中的其他各种内容元素。 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 使用JSP的“include”指令将名为“filterLogin.jsp”的页面包含进来，通常情况下，这个“filterLogin.jsp”页面主要负责处理用户登录验证相关的逻辑，比如它会判断当前访问该页面的用户是否已经成功登录到系统中，如果发现用户没有登录，那么就会引导用户跳转到登录页面进行登录操作，以此来实现对页面访问权限的有效管控，确保只有合法登录的用户才能够访问当前页面以及后续与之相关的各种功能内容，从而保障整个系统的数据安全以及业务逻辑的正常运行。 -->
     <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <!-- 包含名为“WEB-INF/teacher/tHeader.jsp”的页面，一般来讲，这个页面主要是用于定义教师端页面的头部区域的，在这个头部区域当中，通常会包含诸如页面的大标题、用于页面导航的导航栏、展示教师用户基本信息（例如用户名、头像等内容）等与头部相关的各种元素，通过这样的包含操作，就可以把这些头部相关的元素整合到当前页面之中，进而构建出一个完整且规范的页面头部布局结构。 -->
     <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 包含名为“WEB-INF/teacher/teacherNav.jsp”的页面，大概率它的作用是用于展示教师端的导航菜单的，借助这个导航菜单，教师用户就可以方便快捷地在不同的功能模块（例如课程管理、学生管理、个人信息管理等不同的功能板块，具体的功能模块划分要取决于业务系统的整体设计需求）之间进行切换操作，实现页面功能的导航跳转，为用户提供便捷的操作入口，从而提升用户使用整个系统的便利性。 -->
     <div class="layui-layout layui-layout-admin">
+        <!-- 创建一个基于Layui框架的布局容器，通过应用“layui-layout”和“layui-layout-admin”这两个样式类，按照Layui框架所提供的特定布局模式对页面进行布局规划，这种布局方式在后台管理系统等应用场景中是比较常用的，它有着清晰、规范的页面分区结构，能够便于合理地放置和展示页面内的各种功能内容模块，例如可以很方便地划分出侧边栏、主体内容展示区、页面底部的页脚等不同的区域。 -->
         <div class="layui-body">
+            <!-- 在上述所创建的Layui布局容器内定义页面的主体内容区域，这个区域会依据Layui框架既定的布局规则来进行自适应显示，它主要的作用是用于承载和展示与具体业务相关的核心内容，比如下面即将呈现出来的关于教师“个人信息”相关信息的表单等内容元素，这里也就是用户在访问该页面时重点关注和进行操作的区域。 -->
             <!-- 内容主体区域 -->
             <div style="padding: 15px;">
+                <!-- 创建一个带有内边距的div容器，通过设置“padding: 15px;”这样的内边距样式，意味着在这个容器的四周（也就是上、下、左、右四个方向）都会留出15像素的空白空间，这样做的好处是可以让容器内部的内容在页面中展示的时候有一定的间隔，使得页面的布局更加美观、易读，也更便于对内部的各个元素进行排版布局操作，避免内容显得过于拥挤，从而提升用户查看和操作页面内容时的体验感。 -->
                 <span class="layui-breadcrumb">
+                    <!-- 使用Layui框架的面包屑组件，其最主要的作用就是向用户清晰地展示当前页面的导航路径，让用户能够直观地了解当前页面在整个系统中的位置层级关系，通过面包屑组件所展示出来的路径信息，用户可以清楚地知道自己是如何一步步进入到当前这个“个人信息”页面的，同时也方便用户在需要的时候，能够按照这个路径进行回退或者跳转到相关的上级页面等操作，有效地提升了页面的导航便利性以及用户对整个系统结构的理解程度。 -->
                     <a href="">教师端</a>
+                    <!-- 面包屑中的第一个链接，通常情况下它是指向教师端的首页或者是整个教师端功能的主要入口页面的，不过在这里暂时没有设置具体的链接地址（可能后续会根据实际情况进一步去完善它），从理论上来说，用户点击该链接是可以引导其返回教师端的核心界面的，也就是回到一个相对比较顶层的功能页面位置上。 -->
                     <a href="">个人信息管理</a>
+                    <!-- 面包屑中的第二个链接，它所指向的是与个人信息管理相关的页面，这个页面可能是个人信息管理的总览页面或者是对个人信息进行分类展示的列表页面等相关页面，同样在这里暂时也没有设定具体的链接地址，一般情况下用户点击该链接就可以进入到对应的个人信息管理相关的界面中，进而去查看更详细的个人信息相关内容。 -->
                     <a><cite>个人信息</cite></a>
+                    <!-- 面包屑中的最后一个元素，明确地显示出当前页面的具体功能是“个人信息”，它主要起到一个标识当前所在功能位置的作用，通常情况下这个元素是不可点击的，仅仅是作为文字提示信息展示给用户，告知用户当前所处的具体业务功能页面是什么。 -->
                 </span>
                 <form class="layui-form" action="" style="padding-top: 50px" method="post">
+                    <!-- 创建一个使用Layui框架样式的表单，应用“layui-form”样式类使其呈现出符合Layui框架规范的表单样式，方便进行表单元素的布局以及后续的表单验证等操作。设置顶部内边距为50px，使表单与上面的面包屑等元素有一定的垂直间隔，更加美观易读。提交方法为“post”，常用于提交较大量或需保密的数据（不过这里“action”属性为空，可能后续会根据实际需求动态设置表单提交的目标地址）。 -->
                     <div class="layui-form-item">
+                        <!-- 在表单内创建Layui框架的表单项目容器，用于对单个输入项或一组相关输入项进行分组和布局，方便统一管理和设置样式，使每个输入项在页面中规范显示。 -->
                         <label class="layui-form-label">工号</label>
+                        <!-- 创建表单标签，用于显示输入项对应的提示文本，这里提示用户输入的是“工号”信息，引导用户明确该输入框的用途。 -->
                         <div class="layui-input-block">
+                            <!-- 创建用于放置输入框等表单控件的块级容器，按照Layui框架的布局规则，输入框等元素会在这个容器内合理显示，确保页面布局整齐，与其他表单项目区分开来。 -->
                             <input type="text" readonly="readonly" name="teacher-id" value="${teacher.t_id}" required lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 创建一个文本输入框，设置为只读（“readonly="readonly"”），意味着用户不能直接修改该输入框中的内容，其名称为“teacher-id”，通过EL表达式（Expression Language）将“teacher.t_id”（可能是从服务器端传递过来的教师工号值）作为初始值显示在输入框中，设置为必填项（“required lay-verify="required"”，Layui框架中用于表单验证，确保用户提交表单时该字段有值），关闭自动完成功能（“autocomplete="off"”），应用Layui框架输入框样式类“layui-input”，用于展示教师的工号信息。 -->
                         </div>
                     </div>
                     <div class="layui-form-item">
                         <label class="layui-form-label">学院</label>
                         <div class="layui-input-block">
                             <select name="selectCollege" readonly="readonly">
+                                <!-- 创建一个下拉选择框，名称为“selectCollege”，设置为只读，意味着用户不能在页面上直接修改其选项，不过这里暂时只有一个默认选中的空选项（“<option selected></option>”），可能后续会通过JavaScript等方式动态填充学院相关的选项数据（比如从服务器端获取学院列表后添加到下拉框中），用于让用户选择教师所属的学院信息。 -->
                                 <option selected></option>
                             </select>
                         </div>
@@ -41,6 +69,7 @@
                         <div class="layui-input-block">
                             <select name="selectDepartment" readonly="readonly">
                                 <option selected></option>
+                                <!-- 与学院的下拉选择框类似，创建用于选择教师所属系别的下拉选择框，名称为“selectDepartment”，设置为只读，同样暂时只有一个默认选中的空选项，后续可能动态添加系别相关选项数据，方便用户选择对应的系别信息。 -->
                             </select>
                         </div>
                     </div>
@@ -49,6 +78,7 @@
                         <div class="layui-input-block">
                             <select name="selectClass" readonly="readonly">
                                 <option selected></option>
+                                <!-- 创建用于选择教师所在班级的下拉选择框，名称为“selectClass”，设置为只读，当前也只有默认选中的空选项，预计后续会动态填充班级相关选项，以供用户进行相应的选择操作。 -->
                             </select>
                         </div>
                     </div>
@@ -56,71 +86,38 @@
                         <label class="layui-form-label">姓名</label>
                         <div class="layui-input-block">
                             <input type="text" name="student-name" id="student-name" value="${teacher.t_name}" placeholder="" autocomplete="off" class="layui-input">
+                            <!-- 创建一个文本输入框，名称为“student-name”，设置了ID为“student-name”，通过EL表达式将“teacher.t_name”（可能是从服务器端传递过来的教师姓名值）作为初始值显示在输入框中，没有设置占位符文本（“placeholder=""”），关闭自动完成功能，应用Layui框架输入框样式类“layui-input”，用于展示教师的姓名信息，并且用户可以在这里对姓名进行修改（与前面只读的工号输入框不同）。 -->
                         </div>
                     </div>
                     <div class="layui-form-item">
-
+                        <!-- 这里是一个空的表单项目容器，可能原本计划放置一些表单元素但暂时未添加，或者用于在页面布局上起到一定的间隔作用等，具体用途可能需要根据后续开发需求来确定。 -->
                     </div>
                     <div class="layui-form-item">
                         <div class="layui-inline">
+                            <!-- 创建行内块级元素容器，用于让内部元素在行内排列，方便在一行内放置多个表单输入项或相关元素，实现紧凑的布局效果，这里主要用于放置性别相关的输入项。 -->
                             <label class="layui-form-label">性别</label>
                             <div class="layui-input-block">
                                 <input type="radio" name="student-sex" id="idsex" value="男" title="男">
                                 <input type="radio" name="student-sex" id="idsex2" value="女" title="女">
+                                <!-- 创建两个单选按钮，它们的名称都为“student-sex”，意味着同一时刻只能选择其中一个选项，第一个单选按钮的ID为“idsex”，值为“男”，显示的文本标题为“男”，第二个单选按钮ID为“idsex2”，值为“女”，标题为“女”，用于让用户选择教师的性别信息，后续可以通过JavaScript等方式获取用户选择的性别值进行相应的处理。 -->
                             </div>
                         </div>
                         <div class="layui-inline">
                             <label class="layui-form-label">文化程度</label>
                             <div class="layui-input-block">
                                 <input type="text" name="student-age" id="student-age" value="${teacher.t_education}" placeholder="" autocomplete="off" class="layui-input">
+                                <!-- 创建一个文本输入框，名称为“student-age”，ID为“student-age”，通过EL表达式将“teacher.t_education”（可能是从服务器端传递过来的教师文化程度值）作为初始值显示在输入框中，无占位符文本，关闭自动完成功能，用于展示教师的文化程度信息，用户也可在此修改该信息。 -->
                             </div>
                         </div>
                         <div class="layui-inline">
                             <label class="layui-form-label">职称</label>
                             <div class="layui-input-block">
                                 <input type="text" name="student-phone" id="student-phone" value="${teacher.t_title}" placeholder="" autocomplete="off" class="layui-input">
+                                <!-- 创建一个文本输入框，名称为“student-phone”，ID为“student-phone”，通过EL表达式将“teacher.t_title”（可能是从服务器端传递过来的教师职称值）作为初始值显示在输入框中，无占位符文本，关闭自动完成功能，用于展示教师的职称信息，并且用户可进行相应的修改操作。 -->
                             </div>
                         </div>
                     </div>
                 </form>
                 <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含名为“footer.jsp”的页面，通常这个页面主要是用于定义页面的底部区域的，在这个页面里可能会包含诸如版权信息、联系方式、页面底部导航等相关内容，通过这样的包含操作，可以完善整个页面的布局结构，使其更加完整、规范，给用户呈现出一个完整的页面视觉效果，同时也方便在底部展示一些通用的重要信息或者提供额外的操作入口等。 -->
             </div>
-    </div>
-</div>
-
-
-<script type="text/javascript">
-    $("#nav li:nth-child(5) dl dd:nth-child(1)").addClass("layui-this");
-    $("#nav li:nth-child(5)").addClass("layui-nav-itemed");
-</script>
-<script>
-    //JavaScript代码区域
-    layui.use('element', function(){
-        var element = layui.element;
-        element.init();
-    });
-</script>
-
-<script>
-    //Demo
-    layui.use('form', function(){
-
-    });
-</script>
-<script>
-    var sex = "${teacher.t_sex}";
-    if (sex == '男') {
-        $("#idsex").attr("checked","checked");
-        $("#idsex2").removeAttr("checked");
-    } else if (sex == '女') {
-        $("#idsex2").attr("checked","checked");
-        $("#idsex").removeAttr("checked");
-    }else{
-        $("#idsex").removeAttr("checked");
-        $("#idsex2").removeAttr("checked");
-    }
-</script>
-
-</body>
-</html>
-

web/WEB-INF/teacher/teacherNav.jsp

@@ -1,49 +1,71 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- JSP页面指令，设置页面的内容类型为"text/html"，表示页面将以HTML格式展示内容，同时指定字符编码为UTF-8，这样能确保页面可以正确处理和显示各种字符（包括中文等特殊字符），避免出现乱码情况，并且表明该页面是基于Java语言来实现内部逻辑的。 -->
+
 <html>
 <head>
     <meta charset="utf-8">
+    <!-- 设置HTML页面的字符编码为utf-8，与外层JSP页面指令中指定的编码保持一致，再次明确页面文本内容的编码格式，确保浏览器能正确解析页面中的字符信息。 -->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
+    <!-- 这是一个用于移动端页面适配的viewport元标签设置。"width=device-width"表示页面宽度将根据设备的屏幕宽度进行自适应调整；"initial-scale=1"设定页面初始缩放比例为1，即正常大小显示；"maximum-scale=1"限制页面最大缩放比例为1，防止用户过度缩放页面，以此保证页面在移动设备上有较好的显示效果和交互体验。 -->
 
 </head>
 <body class="layui-layout-body">
+    <!-- 为页面主体设置样式类为"layui-layout-body"，这通常是遵循Layui框架的样式规范，表明页面主体部分将应用Layui框架相关的布局样式，方便后续按照框架既定的布局方式来组织页面内容。 -->
     <div class="layui-layout layui-layout-admin">
+        <!-- 创建一个使用Layui框架的布局容器，应用"layui-layout"和"layui-layout-admin"样式类，按照Layui框架提供的布局模式进行页面布局，这种布局常用于后台管理系统等场景，有着规范的分区结构，便于合理放置页面的不同功能模块。 -->
         <div class="layui-side layui-bg-black">
+            <!-- 创建页面的左侧侧边栏区域，应用"layui-side"样式类使其具备侧边栏的外观样式，"layui-bg-black"样式类则将其背景颜色设置为黑色，形成一个具有明显视觉区分的侧边栏效果，通常用于放置导航菜单等内容。 -->
             <div class="layui-side-scroll">
+                <!-- 创建一个可滚动的容器，应用于侧边栏内部，当侧边栏中的内容过多，超出了侧边栏的可视范围时，用户可以通过滚动条来查看全部内容，提升用户体验，确保侧边栏内容展示的完整性。 -->
                 <!-- 左侧导航区域（可配合layui已有的垂直导航） -->
                 <ul class="layui-nav layui-nav-tree"  lay-filter="test" id="nav">
+                    <!-- 创建一个使用Layui框架样式的无序列表，作为导航菜单的容器，应用"layui-nav"和"layui-nav-tree"样式类使其呈现出Layui框架定义的垂直导航树样式，通过"lay-filter"属性设置一个过滤器名称为"test"，方便后续使用JavaScript代码绑定相关的导航事件等操作，同时设置id为"nav"，便于通过JavaScript或CSS选择器对这个导航菜单进行定位和操作。 -->
                     <li class="layui-nav-item">
+                        <!-- 创建导航菜单中的一个菜单项，应用"layui-nav-item"样式类，使其具备Layui框架中菜单项的基本样式效果，比如合适的间距、鼠标悬停效果等。 -->
                         <a class="" href="javascript:;">课程信息</a>
+                        <!-- 创建一个链接元素，文本内容为“课程信息”，但此处的链接地址设置为"javascript:;"，表示点击该链接暂时不会进行页面跳转（可能后续通过JavaScript代码添加点击事件来实现具体的交互逻辑），只是作为一个可点击的文本展示，用于展开或收起下级菜单等操作，它是课程信息相关子菜单的父级菜单。 -->
                         <dl class="layui-nav-child">
+                            <!-- 创建一个定义列表（dl）元素，应用"layui-nav-child"样式类，用于放置“课程信息”菜单项下的子菜单列表，使其呈现出子菜单的样式效果，与父级菜单在视觉上进行区分，且符合Layui框架的导航菜单结构规范。 -->
                             <dd><a href="${pageContext.request.contextPath}/teacherOptionalCourseServlet">我的授课</a></dd>
+                            <!-- 创建一个定义列表项（dd）元素，里面包含一个链接元素，链接的地址通过EL表达式（Expression Language）动态生成，指向"teacherOptionalCourseServlet"这个Servlet，点击该链接可跳转到对应的Servlet处理逻辑，用于展示教师的授课相关信息，文本显示为“我的授课”，方便教师查看自己所教授的课程情况。 -->
                             <dd hidden id="hidden-score"><a href="#">学生成绩</a></dd>
+                            <!-- 创建一个定义列表项，里面的链接文本为“学生成绩”，但设置了"hidden"属性且id为"hidden-score"，意味着该菜单项初始状态是隐藏的（可能后续通过JavaScript代码根据某些条件来控制其显示与否，比如只有满足特定权限或者特定操作场景下才显示该菜单项），点击链接暂时指向一个空的地址（"#"），通常表示在当前页面内进行定位（这里可能后续会完善具体的跳转逻辑），用于查看学生成绩相关信息。 -->
                             <dd hidden id="hidden-update"><a href="#">修改课程</a></dd>
+                            <!-- 同样创建一个定义列表项，文本为“修改课程”，设置了"hidden"属性且有id为"hidden-update"，初始隐藏状态，链接暂时指向空地址，后续可用于实现课程修改相关的功能，点击跳转到相应的修改课程页面（具体地址等逻辑可能后续补充）。 -->
                             <dd><a href="${pageContext.request.contextPath}/addSelectCourseServlet">添加授课</a></dd>
+                            <!-- 创建定义列表项包含链接元素，链接通过EL表达式指向"addSelectCourseServlet"这个Servlet，点击可跳转到对应的逻辑处理页面，用于实现教师添加授课课程的功能，文本显示为“添加授课”，方便教师操作添加新的授课任务。 -->
                         </dl>
                     </li>
                     <li class="layui-nav-item">
                         <a class="" href="javascript:;">学生通讯录</a>
                         <dl class="layui-nav-child">
                             <dd><a href="${pageContext.request.contextPath}/findStudentByPageServlet">本院学生信息</a></dd>
+                            <!-- 创建定义列表项及链接元素，链接地址通过EL表达式指向"findStudentByPageServlet"这个Servlet，点击可跳转到对应的页面查看本院学生的相关信息，实现学生通讯录中查看本院学生详细信息的功能，文本显示为“本院学生信息”。 -->
                         </dl>
                     </li>
                     <li class="layui-nav-item">
                         <a class="" href="javascript:;">教师通讯录</a>
                         <dl class="layui-nav-child">
                             <dd><a href="${pageContext.request.contextPath}/teacherListServlet">本院教师信息</a></dd>
+                            <!-- 创建定义列表项及链接元素，链接指向"teacherListServlet"这个Servlet，点击可获取并展示本院教师的相关信息，实现教师通讯录中查看本院教师详细信息的功能，文本显示为“本院教师信息”。 -->
                         </dl>
                     </li>
                     <li class="layui-nav-item">
                         <a class="" href="javascript:;">学院专业信息</a>
                         <dl class="layui-nav-child">
                             <dd><a href="${pageContext.request.contextPath}/cdcListServlet">学院专业查询</a></dd>
+                            <!-- 创建定义列表项及链接元素，链接指向"cdcListServlet"这个Servlet，点击可跳转到对应的页面进行学院专业相关信息的查询操作，实现查看学院专业信息的功能，文本显示为“学院专业查询”。 -->
                         </dl>
                     </li>
                     <li class="layui-nav-item">
                         <a class="" href="javascript:;">个人信息管理</a>
                         <dl class="layui-nav-child">
                             <dd><a href="${pageContext.request.contextPath}/teacherInfomationServlet">个人信息</a></dd>
+                            <!-- 创建定义列表项及链接元素，链接指向"teacherInfomationServlet"这个Servlet，点击可跳转到对应的页面查看和管理教师个人的相关信息，如姓名、联系方式等基本信息，文本显示为“个人信息”。 -->
                             <dd><a href="${pageContext.request.contextPath}/teacherPasswordIndexServlet">修改密码</a></dd>
+                            <!-- 创建定义列表项及链接元素，链接指向"teacherPasswordIndexServlet"这个Servlet，点击可进入修改教师账号密码的页面，实现修改密码的功能，文本显示为“修改密码”。 -->
                             <dd><a href="${pageContext.request.contextPath}/fileListServlet">文件列表</a></dd>
+                            <!-- 创建定义列表项及链接元素，链接指向"fileListServlet"这个Servlet，点击可跳转到查看教师相关文件列表的页面，比如教学资料等文件信息，文本显示为“文件列表”，方便教师对文件进行管理查看。 -->
                         </dl>
                     </li>
                 </ul>
@@ -55,6 +77,7 @@
         layui.use('element', function(){
             var element = layui.element;
             element.init();
+            // 使用Layui框架的模块加载机制，加载"element"模块，获取该模块实例并赋值给变量"element"，然后调用模块的"init"方法进行初始化操作。"element"模块在Layui框架中通常用于页面元素的操作、动态渲染以及交互效果实现等，通过初始化该模块，可以准备好相关的DOM操作环境、绑定必要的事件等，确保模块能正常工作，进而实现页面中基于该模块的各种功能，例如展开收起导航菜单、切换菜单项的选中状态等操作，使得导航菜单具备相应的交互功能。
         });
     </script>
 </body>

web/WEB-INF/teacher/teacherOptionalCourse.jsp

@@ -1,48 +1,95 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- 这是JSP页面的指令语句，用于设置页面的相关属性。
+    - “contentType”属性指定页面内容的类型为“text/html”，意味着这个页面将以HTML格式来呈现内容。
+    - “charset=UTF-8”表示页面使用UTF-8字符编码，这样可以确保页面能够正确地处理和显示各种字符，包括中文等非ASCII字符，避免出现乱码问题。
+    - “language=java”表明该JSP页面使用Java语言来实现其内部的业务逻辑等功能。 -->
+
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 引入JSTL（JavaServer Pages Standard Tag Library）核心标签库。
+    - “prefix”属性指定了在页面中使用该标签库时的前缀为“c”，后续就可以通过“<c:xxx>”这样的形式来使用JSTL核心标签库中提供的各种标签了。
+    - “uri”属性给出了标签库的统一资源标识符，用于定位这个核心标签库所在的位置，方便服务器解析和处理对应的标签逻辑，利用这些标签可以方便地在页面中进行诸如循环遍历、条件判断、数据输出等操作，增强页面的动态展示能力。 -->
+
 <html>
 <head>
     <title>我的授课</title>
+    <!-- 设置HTML页面的标题，浏览器在显示该页面时，标题栏中就会显示这里设置的“我的授课”字样，方便用户直观地了解这个页面的主要功能或者主题内容。 -->
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入Layui框架的样式文件。通过相对路径“./css/layui.css”去查找对应的CSS文件，这个文件中定义了一系列符合Layui框架风格的样式规则，使得页面中使用Layui框架相关组件（例如表格、按钮、导航栏等元素）能够按照其预设的样式进行显示，呈现出统一且美观的视觉效果，让页面风格保持一致性。 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的样式文件“style.css”，开发人员可以在这个文件里根据项目的具体需求，对页面的样式进行个性化定制。比如，可以覆盖Layui框架的部分默认样式，或者添加一些独有的页面布局、颜色搭配等样式设定，从而使页面更符合整个项目特定的设计风格和展示要求。 -->
     <script src="./layui.js"></script>
+    <!-- 引入Layui框架的JavaScript核心文件，有了这个文件，页面就可以调用Layui框架提供的各种JavaScript功能了。例如，能够实现弹出层展示、表单验证、页面元素交互（如点击按钮触发特定事件、动态显示隐藏元素等）等功能，通过使用Layui框架的相关API，可以为页面添加丰富多样的交互性和动态效果，提升用户体验。 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 从CDN（内容分发网络）引入jQuery库的精简版本。jQuery是一个非常流行且功能强大的JavaScript库，它极大地简化了在HTML页面中进行DOM（Document Object Model，文档对象模型）操作的复杂度，比如方便地进行HTML文档遍历、处理各种事件（如鼠标点击、键盘输入等事件）、创建动画效果以及实现AJAX（Asynchronous JavaScript and XML，异步的JavaScript和XML）交互等操作，使得开发人员能够更轻松地实现页面中的各种交互功能，进一步增强页面整体的动态交互体验。 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 为页面主体设置样式类为“layui-layout-body”，同时通过内联样式设置背景颜色为“#F2F2F2”。这样的设置是遵循Layui框架的样式规范，来定义页面主体部分的外观风格，让页面呈现出特定的背景颜色，有助于营造整体统一的视觉效果，并且方便后续按照Layui框架既定的布局和样式规则来组织页面中的其他内容元素。 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 使用JSP的“include”指令将名为“filterLogin.jsp”的页面包含进来。通常，这个“filterLogin.jsp”页面会负责处理用户登录验证相关的逻辑，例如判断当前用户是否已经成功登录系统，如果用户没有登录，那么可能会引导用户跳转到登录页面进行登录操作，以此来实现对页面访问权限的有效管控，确保只有合法登录的用户才能访问该页面以及后续相关的功能内容，保障系统的数据安全和业务逻辑的正常运行。 -->
     <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <!-- 包含名为“WEB-INF/teacher/tHeader.jsp”的页面，一般情况下，这个页面主要用于定义教师端页面的头部区域。在这个头部区域中，可能会包含诸如页面的大标题、导航栏、教师用户的基本信息展示（如用户名、头像等）等头部相关的元素，通过这样的包含操作，就可以将这些头部元素整合到当前页面中，构建出完整且规范的页面头部布局结构。 -->
     <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 包含名为“WEB-INF/teacher/teacherNav.jsp”的页面，大概率它是用于展示教师端的导航菜单的。借助这个导航菜单，教师用户可以方便快捷地在不同的功能模块（比如课程管理、学生管理、个人信息管理等不同功能板块，具体取决于业务系统的设计需求）之间进行切换操作，实现页面功能的导航跳转，为用户提供便捷的操作入口，提升用户使用系统的便利性。 -->
     <div class="layui-layout layui-layout-admin">
+        <!-- 创建一个基于Layui框架的布局容器，应用“layui-layout”和“layui-layout-admin”这两个样式类，按照Layui框架所提供的特定布局模式对页面进行布局规划。这种布局方式在后台管理系统等场景中经常被使用，它有着清晰、规范的页面分区结构，便于合理地放置和展示页面内的各种功能内容模块，例如可以方便地划分出侧边栏、主体内容区、页脚等不同的区域。 -->
         <div class="layui-body">
+            <!-- 在上述的Layui布局容器内定义页面的主体内容区域，这个区域会依据Layui框架既定的布局规则进行自适应显示，它主要用于承载和展示与具体业务相关的核心内容，比如下面即将呈现的关于教师“我的授课”相关信息的表格等内容元素，是用户重点关注和操作的区域。 -->
             <!-- 内容主体区域 -->
             <div style="padding: 15px;">
+                <!-- 创建一个带有内边距的div容器，通过设置“padding: 15px;”的内边距样式，意味着在这个容器的四周（上、下、左、右）都会留出15像素的空白空间。这样做的好处是可以让容器内部的内容在页面中展示时有一定的间隔，使得页面布局更加美观、易读，也更便于对内部的各个元素进行排版布局，避免内容显得过于拥挤，提升用户查看和操作页面内容的体验。 -->
                 <span class="layui-breadcrumb">
+                    <!-- 使用Layui框架的面包屑组件，其主要作用是向用户清晰地展示当前页面的导航路径，让用户能够直观地了解当前页面在整个系统中的位置层级关系。通过面包屑，用户可以清楚地知道自己是如何一步步进入到当前这个“我的授课”页面的，同时也方便用户在需要的时候，可以按照这个路径进行回退或者跳转到相关的上级页面等操作，提升了页面的导航便利性和用户对系统结构的理解。 -->
                     <a href="">教师端</a>
+                    <!-- 面包屑中的第一个链接，通常指向教师端的首页或者是整个教师端功能的主要入口页面，不过这里暂时没有设置具体的链接地址（可能后续会根据实际情况进一步完善），理论上点击该链接可以引导用户返回教师端的核心界面，回到一个相对比较顶层的功能页面位置。 -->
                     <a href="">课程信息</a>
+                    <!-- 面包屑中的第二个链接，指向与课程信息相关的页面，这个页面可能是课程信息的总览页面或者是课程分类列表等相关页面，同样暂时没有设定具体的链接地址，点击该链接一般情况下可以进入到对应的课程信息相关的界面，进一步查看更详细的课程相关内容。 -->
                     <a><cite>我的授课</cite></a>
+                    <!-- 面包屑中的最后一个元素，明确显示当前页面的具体功能是“我的授课”，它主要起到一个标识当前所在功能位置的作用，通常情况下是不可点击的，仅仅作为文字提示展示给用户，告知用户当前所处的具体业务功能页面。 -->
                 </span>
                 <table class="layui-table" lay-filter="test">
+                    <!-- 创建一个使用Layui框架样式的表格，应用“layui-table”样式类使其外观符合Layui框架所定义的表格风格，整体看起来更加美观、专业且符合整个系统的界面风格一致性要求。同时通过“lay-filter”属性设置一个过滤器名称为“test”，这个过滤器后续可以在JavaScript代码中用于绑定表格相关的各种事件（例如行点击事件、排序事件、单元格编辑事件等），方便实现对表格的交互操作以及数据处理等功能，增强表格的实用性和用户交互性。 -->
                     <thead>
+                    <!-- 定义表格的表头部分，用于清晰地展示各列所代表的标题信息，让用户在查看表格数据时，一眼就能明白每一列数据的含义和所代表的内容属性，起到数据列说明的作用，便于用户快速理解和查看表格中的具体数据内容。 -->
                     <tr>
+                        <!-- 创建表格中的一行，该行用于放置表头单元格（th元素），每个th元素对应表格中的一列标题，按照顺序依次排列，形成完整的表头行结构。 -->
                         <th>ID</th>
+                        <!-- 表头单元格，标题为“ID”，此处的“ID”具体含义可能是每条授课记录在系统中的唯一标识编号，或者是按照一定规则生成的序号等，具体要根据业务系统的设计需求来确定，其所在列后续会展示相应的标识信息，方便对不同的授课记录进行区分和索引。 -->
                         <th>课程号</th>
+                        <!-- 表头单元格，显示“课程号”这一标题，对应列将展示具体的课程编号信息，通过课程号可以唯一确定一门课程，方便教师在众多课程中准确识别每一门自己授课的课程，也便于与系统中的其他课程相关功能（如查询、修改等操作）进行关联和交互。 -->
                         <th>课程名</th>
+                        <!-- 表头单元格，标题为“课程名”，所在列会呈现相应的课程名称等课程相关信息，便于教师直观地了解自己所教授课程的具体名称，更清晰地知晓每一行数据对应的是哪一门课程。 -->
                         <th>课程简介</th>
+                        <!-- 表头单元格，显示“课程简介”标题，其对应的表格列用于展示具体的课程详细介绍信息，例如课程的教学目标、主要内容、适用对象等相关简介内容，有助于教师进一步了解课程的大致情况，辅助教学相关的决策和操作。 -->
                         <th>操作</th>
+                        <!-- 表头单元格，标题为“操作”，该列用于放置针对每一行授课记录数据可进行的操作按钮等元素，比如修改、查看、删除等操作按钮，方便教师根据实际需求对相应的授课信息进行各种操作管理，提供便捷的交互功能入口。 -->
                     </tr>
                     </thead>
 
                     <c:forEach items="${optionalcourses}" var="optionalcourse" varStatus="t">
+                        <!-- 使用JSTL（JavaServer Pages Standard Tag Library）的“forEach”标签来进行循环遍历操作。
+                            - “items”属性指定了要遍历的集合对象，这里是名为“optionalcourses”的集合（这个集合通常是在服务器端，比如对应的Servlet中进行数据查询获取后，将查询到的教师授课相关数据封装成集合形式，然后设置并传递到当前JSP页面的）。
+                            - “var”属性定义了一个变量名“optionalcourse”，在每次循环过程中，会从“optionalcourses”集合里依次取出每一个元素，并将当前取出的元素赋值给这个变量，方便在循环体内部使用该变量来获取元素中的具体数据内容。
+                            - “varStatus”属性则是定义了一个循环状态变量“t”，这个变量可以获取到循环的一些状态信息，例如当前循环的次数、是否是第一次或最后一次循环等，在这里主要是利用它的“count”属性（表示当前循环次数）来展示序号等相关信息，增强表格数据展示的可读性。 -->
                         <tr>
+                            <!-- 在循环体内部创建表格的每一行，用于展示具体的教师授课相关数据内容，每一次循环就生成一行数据展示在表格中，这样通过循环就可以将集合中的所有授课数据逐行展示出来，形成完整的数据表格展示效果。 -->
                             <td>${t.count}</td>
+                            <!-- 通过EL表达式（Expression Language）输出循环状态变量“t”的“count”属性，也就是当前循环的次数，将其作为序号展示在表格的这一单元格中，方便用户清晰地查看每一行数据的顺序以及整体的数据数量情况，使得数据展示更加有条理，便于用户快速定位和查看特定行的数据内容。 -->
                             <td>${optionalcourse.c_id}</td>
+                            <!-- 利用EL表达式输出从集合元素（赋值给“optionalcourse”变量）中获取的课程号信息，将具体的课程编号值显示在表格对应的单元格内，以便教师直观地看到每一门授课课程的编号，方便与系统中其他地方涉及课程号的操作进行关联和对应。 -->
                             <td>${optionalcourse.c_name}</td>
+                            <!-- 同样使用EL表达式输出集合元素中包含的课程名称信息，在表格相应的单元格中展示具体的课程名称内容，使得教师能够清楚地知道每一行数据对应的是哪一门具体的课程，便于查看和管理授课课程信息。 -->
                             <td>${optionalcourse.c_info}</td>
+                            <!-- 通过EL表达式输出集合元素里的课程简介等相关信息，将课程的详细介绍展示在表格对应的单元格中，帮助教师更全面地了解每门授课课程的具体情况，比如课程的教学重点、难点等相关内容，辅助教师进行教学相关的操作和决策。 -->
                             <td><a class="layui-btn layui-btn-normal" href="${pageContext.request.contextPath}/updateTeacherOptionalCourseServlet?cid=${optionalcourse.c_id}">修改</a><a class="layui-btn" href="${pageContext.request.contextPath}/findStudentCourseScoreServlet?cid=${optionalcourse.c_id}">查看</a><a class="layui-btn layui-btn-danger" href="javascript:deleteOptionalCourse(${optionalcourse.c_id});">删除</a></td>
+                            <!-- 在操作列的单元格中创建三个链接按钮，用于提供不同的操作功能入口：
+                                - 第一个按钮应用“layui-btn”和“layui-btn-normal”样式类，使其呈现Layui框架正常风格的按钮样式，按钮文本为“修改”，其链接地址通过EL表达式动态生成，指向“updateTeacherOptionalCourseServlet”这个Servlet，并传递当前行对应的课程号（${optionalcourse.c_id}）作为参数，点击该按钮可跳转到相应的页面进行授课课程信息的修改操作，方便教师根据实际情况对课程相关内容进行调整更新。
+                                - 第二个按钮应用“layui-btn”样式类，按钮文本为“查看”，链接通过EL表达式指向“findStudentCourseScoreServlet”这个Servlet，并同样传递课程号作为参数，点击该按钮可跳转到对应的页面查看选修该课程的学生的成绩等相关信息，便于教师了解授课效果等情况。
+                                - 第三个按钮应用“layui-btn”和“layui-btn-danger”样式类，呈现危险操作（通常红色表示重要或危险操作）的按钮样式，按钮文本为“删除”，点击时会执行JavaScript函数“deleteOptionalCourse(${optionalcourse.c_id});”（这个函数在后续的JavaScript代码中有定义，用于实现删除授课相关的具体业务逻辑，比如向服务器端发送删除请求等操作），实现对相应授课记录的删除功能，不过执行删除操作一般会需要用户进一步确认，以防误操作。 -->
                         </tr>
                     </c:forEach>
                 </table>
                 <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含名为“footer.jsp”的页面，通常这个页面用于定义页面的底部区域，里面可能包含诸如版权信息、联系方式、页面底部导航等相关内容，通过包含该页面可以完善整个页面的布局结构，使其更加完整、规范，给用户呈现出一个完整的页面视觉效果，同时也方便在底部展示一些通用的重要信息或者提供额外的操作入口等。 -->
             </div>
         </div>
     </div>
@@ -50,21 +97,6 @@
 
     <script type="text/javascript">
         $("#nav li:nth-child(1) dl dd:nth-child(1)").addClass("layui-this");
+        // 使用jQuery选择器来定位页面中特定的元素，具体选择的是id为“nav”的元素下的第一个li元素内的dl元素中的第一个dd元素，然后为其添加“layui-this”样式类。这么做大概率是为了在导航菜单中标记当前选中的菜单项（依据页面本身的导航结构和样式设置逻辑来确定），使其呈现出被选中的视觉效果，例如改变颜色、加粗等样式变化，从而清晰地表明当前所在的功能页面对应的导航位置，方便用户直观地知晓当前所处的功能模块在整个导航体系中的位置关系。
         $("#nav li:nth-child(1)").addClass("layui-nav-itemed");
-</script>
-<script>
-    //JavaScript代码区域
-    layui.use('element', function(){
-        var element = layui.element;
-        element.init();
-    });
-</script>
-<script type="text/javascript">
-    function deleteOptionalCourse(c_id) {
-        if (confirm("你确定删除授课吗？")) {
-            location.href = "${pageContext.request.contextPath}/deleteOptionalCourseServlet?cid=" + c_id;
-        }
-    }
-</script>
-</body>
-</html>
+        // 同样利用jQuery选择器选择id为“nav”的元素下的第一个li元素，并为其添加“layui-nav-itemed”样式类，这通常是用于展开或折叠对应的导航菜单

web/WEB-INF/teacher/teacherUpdatePassword.jsp

@@ -1,43 +1,73 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- 这是JSP页面的指令，用于设置页面的相关属性。
+    - “contentType”属性指定页面内容类型为“text/html”，表明页面以HTML格式呈现内容。
+    - “charset=UTF-8”设定字符编码为UTF-8，确保页面能正确处理和显示各种字符（如中文等），避免乱码。
+    - “language=java”说明该页面使用Java语言来实现内部逻辑，比如与服务器端交互、处理业务数据等操作。 -->
+
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 引入JSTL（JavaServer Pages Standard Tag Library）核心标签库，通过设置前缀“c”，后续可使用以“c”开头的JSTL标签来实现如循环遍历、条件判断、数据输出等功能，增强页面的动态数据处理和展示能力，使页面更灵活地呈现内容。 -->
+
 <html>
 <head>
     <title>修改密码</title>
+    <!-- 设置HTML页面的标题，在浏览器的标题栏中会显示此标题，方便用户知晓页面的主要功能，这里明确表示是用于“修改密码”相关操作的页面。 -->
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入Layui框架的样式文件，通过相对路径“./css/layui.css”找到对应的CSS文件，该文件定义了Layui框架相关组件（如表单、按钮、表格等元素）的样式规则，使页面元素按Layui框架风格显示，保证页面整体风格统一、美观。 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的样式文件“style.css”，开发人员可在此文件中对页面样式进行个性化定制，比如覆盖Layui框架部分默认样式，或添加特定的布局、颜色搭配等样式设置，以契合项目的特定设计需求。 -->
     <script src="./layui.js"></script>
+    <!-- 引入Layui框架的JavaScript核心文件，借助这个文件，页面可使用Layui框架提供的各种JavaScript功能，像弹出层展示、表单验证、页面元素交互等，为页面添加丰富的交互性和动态效果，提升用户操作体验。 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 从CDN（内容分发网络）引入jQuery库的精简版本，jQuery是常用的JavaScript库，能简化HTML文档遍历、事件处理、动画效果创建以及AJAX交互等操作，方便开发人员在页面中操作DOM元素，实现各种交互功能，进一步增强页面动态交互性。 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 为页面主体设置样式类为“layui-layout-body”，并通过内联样式指定背景颜色为“#F2F2F2”，按照Layui框架的样式规范定义主体部分外观风格，营造特定视觉背景，通常符合项目统一的页面设计要求，便于后续布局内容。 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 通过JSP的“include”指令包含名为“filterLogin.jsp”的页面，该页面一般用于处理用户登录验证逻辑，判断用户是否已登录，未登录时会引导用户跳转到登录页面，以此控制页面访问权限，保障系统安全和数据合法性。 -->
     <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <!-- 包含“WEB-INF/teacher/tHeader.jsp”页面，通常此页面用于定义教师端页面的头部区域，包含如页面标题、导航栏、用户信息展示等元素，构建出页面头部的布局结构，使页面头部呈现出规范的样式和功能。 -->
     <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 包含“WEB-INF/teacher/teacherNav.jsp”页面，大概率用于展示教师端的导航菜单，方便教师在不同功能模块（如课程管理、学生管理、个人信息管理等）间切换操作，实现页面功能的导航跳转，提高操作便利性。 -->
     <div class="layui-layout layui-layout-admin">
+        <!-- 创建采用Layui框架的布局容器，使用“layui-layout”和“layui-layout-admin”样式类，按Layui框架提供的布局模式规划页面布局，常用于后台管理系统，有着清晰规范的分区结构，便于组织不同功能内容。 -->
         <div class="layui-body">
+            <!-- 在Layui布局容器内定义页面主体内容区域，该区域依Layui框架布局规则自适应显示，用于承载具体业务相关内容，像下面的修改密码表单等信息。 -->
             <!-- 内容主体区域 -->
             <div style="padding: 15px;">
+                <!-- 创建带有内边距（上下左右均为15px）的div容器，通过设置内边距让内部内容在页面中有空白间隔，使布局更美观易读，便于对内部元素排版布局，避免内容显得拥挤。 -->
                 <span class="layui-breadcrumb">
+                    <!-- 使用Layui框架的面包屑组件，向用户展示页面的导航路径，清晰呈现当前页面在系统中的位置层级关系，方便用户了解所处功能位置及如何进行相关操作，提升导航便利性。 -->
                     <a href="">教师端</a>
+                    <!-- 面包屑中的第一个链接，通常指向教师端首页或入口页面，不过此处没设具体链接地址（可能后续完善），点击理论上可返回教师端主要界面。 -->
                     <a href="">个人信息管理</a>
+                    <!-- 面包屑中的第二个链接，指向个人信息管理相关页面，可能是个人信息管理的总览或列表页面等，同样暂无具体链接地址，点击可进入对应界面。 -->
                     <a><cite>修改密码</cite></a>
+                    <!-- 面包屑中的最后一个元素，显示当前页面具体功能为“修改密码”，仅作标识展示，告知用户所在功能位置，一般不可点击。 -->
                 </span>
                 <form class="layui-form" action="${pageContext.request.contextPath}/teacherPasswordUpdateServlet" style="padding-top: 50px" method="post">
+                    <!-- 创建使用Layui框架样式的表单，设置表单提交地址通过EL表达式动态指向“teacherPasswordUpdateServlet”这个Servlet，意味着表单提交时数据会发往此处处理；设置顶部内边距为50px使表单有垂直间距；提交方法为“post”，常用于提交较大量或需保密的数据（如密码等）。 -->
                     <div class="layui-form-item">
+                        <!-- 在表单内创建Layui框架的表单项目容器，用于对单个输入项分组和布局，方便统一管理和设置样式，使每个输入项在页面中规范显示。 -->
                         <label class="layui-form-label">工号</label>
+                        <!-- 创建表单标签，用于显示输入项对应的提示文本，此处提示用户输入“工号”信息。 -->
                         <div class="layui-input-block">
+                            <!-- 创建放置输入框的块级容器，按Layui框架布局规则，输入框会在此合理显示，确保页面布局整齐。 -->
                             <input type="text" name="title" value="${teacher.t_id}" required readonly="readonly" lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 创建文本输入框，设置名称为“title”，通过EL表达式将“teacher.t_id”（可能是从服务器端传递过来的教师工号数据）作为初始值显示，设置为必填且只读，应用Layui框架输入框样式类“layui-input”，用户能看到但不能修改工号信息。 -->
                         </div>
                     </div>
                     <div class="layui-form-item">
                         <label class="layui-form-label">当前密码</label>
                         <div class="layui-input-block">
                             <input type="text" name="student-password" id="student-password" value="${teacher.t_password}" readonly="readonly" placeholder="" autocomplete="off" class="layui-input">
+                            <!-- 类似上述工号输入框，创建用于输入当前密码的文本输入框，名称为“student-password”，设置ID方便后续操作，初始值通过EL表达式显示教师当前密码（通常从服务器获取），设置为只读，用户无法在此修改当前密码内容。 -->
                         </div>
                     </div>
                     <div class="layui-form-item">
                         <label class="layui-form-label">新密码</label>
                         <div class="layui-input-block">
                             <input type="password" name="teacher-newpassword" id="teacher-newpassword" value="" required  lay-verify="required" placeholder="" autocomplete="off" class="layui-input">
+                            <!-- 创建用于输入新密码的密码类型输入框，名称为“teacher-newpassword”，设置ID便于操作，设置为必填项并应用Layui框架的验证规则（通过“lay-verify=required”），用户需在此输入新密码内容，输入时内容会以加密形式显示（因为是密码类型输入框）。 -->
                         </div>
                     </div>
 
@@ -46,17 +76,21 @@
                         <label class="layui-form-label">确认密码</label>
                         <div class="layui-input-block">
                             <input type="password" name="teacher-ennewpassword" id="teacher-ennewpassword" value=""  lay-verify="required" placeholder="" autocomplete="off" class="layui-input">
+                            <!-- 创建用于再次输入密码进行确认的密码类型输入框，名称为“teacher-ennewpassword”，设置ID方便操作，同样应用验证规则要求必填，用户需再次输入新密码进行确认，确保两次输入一致，避免密码输入错误。 -->
                         </div>
                     </div>
 
                     <div class="layui-form-item">
                         <div class="layui-input-block">
                             <button class="layui-btn" lay-submit lay-filter="formDemo">修改</button>
+                            <!-- 创建使用Layui框架样式的按钮，文本显示为“修改”，通过“lay-submit”属性声明该按钮用于提交表单，“lay-filter=formDemo”可用于设置表单提交的验证规则或事件监听等相关的过滤器名称（需在后续JavaScript代码中定义具体逻辑），点击按钮触发表单提交操作，将用户输入的密码相关信息发往指定Servlet处理。 -->
                             <span style="padding-left: 20px;">${update_msg}</span>
+                            <!-- 通过EL表达式显示名为“update_msg”的变量内容，该变量可能是在服务器端（如对应的Servlet）设置的提示信息，用于向用户反馈操作结果（如修改密码成功或失败的提示等），并设置左边20px内边距与按钮隔开显示。 -->
                         </div>
                     </div>
                 </form>
                 <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含名为“footer.jsp”的页面，通常用于定义页面底部区域，可包含版权信息、联系方式、页面底部导航等内容，完善页面整体布局结构，使其更完整规范，呈现出完整的页面视觉效果。 -->
             </div>
         </div>
     </div>
@@ -64,23 +98,26 @@
 
     <script type="text/javascript">
         $("#nav li:nth-child(5) dl dd:nth-child(2)").addClass("layui-this");
+        // 使用jQuery选择器选择页面中id为“nav”的元素下的第五个li元素内的dl元素中的第二个dd元素，并为其添加“layui-this”样式类，大概率用于在导航菜单中标记当前选中的菜单项（依据页面导航结构和样式设置逻辑），使其呈现选中的视觉效果（如变色、加粗等），表明当前所在功能页面对应的导航位置。
         $("#nav li:nth-child(5)").addClass("layui-nav-itemed");
+        // 同样用jQuery选择器选择id为“nav”的元素下的第五个li元素，并为其添加“layui-nav-itemed”样式类，通常用于展开或折叠对应的导航菜单项目，使其显示出展开状态的视觉效果（按Layui导航组件样式规则），方便展示相关子菜单或突出当前所在主菜单部分。
     </script>
     <script>
         //JavaScript代码区域
         layui.use('element', function(){
             var element = layui.element;
             element.init();
+            // 使用Layui框架的模块加载机制，加载“element”模块，获取实例赋值给“element”变量，然后调用“init”方法初始化，“element”模块用于页面元素操作、动态渲染及交互效果实现等，初始化准备DOM操作环境、绑定事件等，确保模块正常工作，实现相关功能。
         });
     </script>
 
     <script>
         //Demo
         layui.use('form', function(){
+            // 使用Layui框架的模块加载机制，加载“form”模块，后续可在回调函数内编写使用该模块相关功能的代码，比如进行表单验证、提交前数据处理等操作，不过这里暂时没添加具体业务逻辑代码（可能后续完善）。
 
         });
     </script>
 
 </body>
 </html>
-

web/WEB-INF/teacher/updateOptionalCourseScore.jsp

@@ -1,72 +1,107 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- JSP页面指令，用于设置页面的相关属性：
+    - “contentType”属性指定页面内容类型为“text/html”，意味着页面以HTML格式展示内容，同时设置字符编码为“UTF-8”，这样能确保页面可以正确处理和显示各种字符（如中文等），避免出现乱码情况，保证页面内容正常展示。
+    - “language=java”表明该JSP页面内部的逻辑实现是基于Java语言的，例如可以在页面中嵌入Java代码片段来与服务器端进行交互、处理业务数据等操作。 -->
+
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 引入JSTL（JavaServer Pages Standard Tag Library）核心标签库，通过设定“prefix”属性为“c”，后续在页面里就能使用以“c”开头的各种JSTL标签了。这些标签能够方便地实现诸如循环遍历集合数据、进行条件判断、将数据输出到页面等常见功能，大大增强了JSP页面在处理动态数据和展示内容方面的灵活性与便利性。 -->
+
 <html>
 <head>
     <title>修改分数</title>
+    <!-- 设置HTML页面的标题，这里明确表示页面是用于“修改分数”相关操作的，该标题会显示在浏览器的标题栏中，方便用户一眼就能知晓当前页面的主题。 -->
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入Layui框架的样式文件，通过相对路径“./css/layui.css”去定位对应的CSS文件，该文件中定义了一系列符合Layui框架风格的样式规则，使得页面中运用Layui框架相关的组件（例如表格、按钮、导航栏等元素）都能按照预设的样式进行展示，从而让页面呈现出统一、美观且规范的视觉效果，保持整体风格的一致性。 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的样式文件“style.css”，开发人员可以在这个文件里根据项目的特定需求，对页面的样式进行个性化定制。例如，可以对Layui框架的部分默认样式进行覆盖，或者添加一些独特的页面布局、颜色搭配等样式设定，以便让页面更好地契合整个项目的设计风格和展示要求。 -->
     <script src="./layui.js"></script>
+    <!-- 引入Layui框架的JavaScript核心文件，有了这个文件的引入，页面就能调用Layui框架所提供的各种JavaScript功能了。比如，可以实现弹出层的展示、对表单进行验证、处理页面元素之间的交互操作（像点击按钮触发特定的事件、动态地显示或隐藏某些元素等）等功能，通过使用Layui框架的相关API，能够为页面添加丰富多样的交互性和动态效果，进而提升用户在使用页面过程中的体验感。 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 从CDN（内容分发网络）引入jQuery库的精简版本，jQuery是一款广受欢迎且功能十分强大的JavaScript库，它极大地简化了在HTML页面中进行DOM（Document Object Model，文档对象模型）操作的复杂度，像方便地遍历HTML文档中的元素、处理各种页面事件（例如鼠标的点击、键盘的输入等事件）、创建动画效果以及实现AJAX（Asynchronous JavaScript and XML，异步的JavaScript和XML）交互等操作，都能通过使用jQuery库轻松实现，这有助于开发人员更加便捷地在页面中构建各种交互功能，进一步增强页面整体的动态交互体验。 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 为页面主体设置样式类为“layui-layout-body”，同时通过内联样式设定背景颜色为“#F2F2F2”，这是按照Layui框架的样式规范来对页面主体部分的外观风格进行定义，使得页面呈现出特定的背景颜色，有助于营造出整体统一的视觉效果，并且方便后续依据Layui框架既定的布局和样式规则来组织和展示页面中的其他各种内容元素。 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 使用JSP的“include”指令将名为“filterLogin.jsp”的页面包含进来，通常情况下，这个“filterLogin.jsp”页面主要负责处理用户登录验证相关的逻辑，比如它会判断当前访问该页面的用户是否已经成功登录到系统中，如果发现用户没有登录，那么就会引导用户跳转到登录页面进行登录操作，以此来实现对页面访问权限的有效管控，确保只有合法登录的用户才能够访问当前页面以及后续与之相关的各种功能内容，从而保障整个系统的数据安全以及业务逻辑的正常运行。 -->
     <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <!-- 包含名为“WEB-INF/teacher/tHeader.jsp”的页面，一般来讲，这个页面主要是用于定义教师端页面的头部区域的，在这个头部区域当中，通常会包含诸如页面的大标题、用于页面导航的导航栏、展示教师用户基本信息（例如用户名、头像等内容）等与头部相关的各种元素，通过这样的包含操作，就可以把这些头部相关的元素整合到当前页面之中，进而构建出一个完整且规范的页面头部布局结构。 -->
     <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 包含名为“WEB-INF/teacher/teacherNav.jsp”的页面，大概率它的作用是用于展示教师端的导航菜单的，借助这个导航菜单，教师用户就可以方便快捷地在不同的功能模块（例如课程管理、学生管理、个人信息管理等不同的功能板块，具体的功能模块划分要取决于业务系统的整体设计需求）之间进行切换操作，实现页面功能的导航跳转，为用户提供便捷的操作入口，从而提升用户使用整个系统的便利性。 -->
     <div class="layui-layout layui-layout-admin">
+        <!-- 创建一个基于Layui框架的布局容器，通过应用“layui-layout”和“layui-layout-admin”这两个样式类，按照Layui框架所提供的特定布局模式对页面进行布局规划，这种布局方式在后台管理系统等应用场景中是比较常用的，它有着清晰、规范的页面分区结构，能够便于合理地放置和展示页面内的各种功能内容模块，例如可以很方便地划分出侧边栏、主体内容展示区、页面底部的页脚等不同的区域。 -->
         <div class="layui-body">
+            <!-- 在上述所创建的Layui布局容器内定义页面的主体内容区域，这个区域会依据Layui框架既定的布局规则来进行自适应显示，它主要的作用是用于承载和展示与具体业务相关的核心内容，比如下面即将呈现出来的关于“修改学生分数”相关信息的表单等内容元素，这里也就是用户在访问该页面时重点关注和进行操作的区域。 -->
             <!-- 内容主体区域 -->
             <div style="padding: 15px;">
+                <!-- 创建一个带有内边距的div容器，通过设置“padding: 15px;”这样的内边距样式，意味着在这个容器的四周（也就是上、下、左、右四个方向）都会留出15像素的空白空间，这样做的好处是可以让容器内部的内容在页面中展示的时候有一定的间隔，使得页面的布局更加美观、易读，也更便于对内部的各个元素进行排版布局操作，避免内容显得过于拥挤，从而提升用户查看和操作页面内容时的体验感。 -->
                 <span class="layui-breadcrumb">
+                    <!-- 使用Layui框架的面包屑组件，其最主要的作用就是向用户清晰地展示当前页面的导航路径，让用户能够直观地了解当前页面在整个系统中的位置层级关系，通过面包屑组件所展示出来的路径信息，用户可以清楚地知道自己是如何一步步进入到当前这个“修改学生分数”页面的，同时也方便用户在需要的时候，能够按照这个路径进行回退或者跳转到相关的上级页面等操作，有效地提升了页面的导航便利性以及用户对整个系统结构的理解程度。 -->
                     <a href="">教师端</a>
+                    <!-- 面包屑中的第一个链接，通常情况下它是指向教师端的首页或者是整个教师端功能的主要入口页面的，不过在这里暂时没有设置具体的链接地址（可能后续会根据实际情况进一步去完善它），从理论上来说，用户点击该链接是可以引导其返回教师端的核心界面的，也就是回到一个相对比较顶层的功能页面位置上。 -->
                     <a href="">课程信息</a>
+                    <!-- 面包屑中的第二个链接，它所指向的是与课程信息相关的页面，这个页面可能是课程信息的总览页面或者是对课程进行分类展示的列表页面等相关页面，同样在这里暂时也没有设定具体的链接地址，一般情况下用户点击该链接就可以进入到对应的课程信息相关的界面中，进而去查看更详细的课程相关内容。 -->
                     <a><cite>修改学生分数</cite></a>
+                    <!-- 面包屑中的最后一个元素，明确地显示出当前页面的具体功能是“修改学生分数”，它主要起到一个标识当前所在功能位置的作用，通常情况下这个元素是不可点击的，仅仅是作为文字提示信息展示给用户，告知用户当前所处的具体业务功能页面是什么。 -->
                 </span>
                 <form class="layui-form" action="${pageContext.request.contextPath}/updateOptionalCourseScoreServlet?cid=${c.c_id}&sid=${s.s_id}" style="padding-top: 50px" method="post">
+                    <!-- 创建一个使用Layui框架样式的表单，应用“layui-form”样式类使其呈现出符合Layui框架规范的表单样式，方便进行表单元素的布局以及后续的表单验证等操作。设置顶部内边距为50px，使表单与上面的面包屑等元素有一定的垂直间隔，更加美观易读。提交方法为“post”，常用于提交较大量或需保密的数据。“action”属性通过EL表达式（Expression Language）动态设置表单提交的目标地址为“updateOptionalCourseScoreServlet”这个Servlet，并传递课程号（“cid=${c.c_id}”）和学号（“sid=${s.s_id}”）等参数，这些参数可能是当前要修改分数的学生和对应课程的相关标识，以便服务器端根据这些信息准确处理分数修改的业务逻辑。 -->
                     <div class="layui-form-item">
+                        <!-- 在表单内创建Layui框架的表单项目容器，用于对单个输入项或一组相关输入项进行分组和布局，方便统一管理和设置样式，使每个输入项在页面中规范显示。 -->
                         <label class="layui-form-label">学号</label>
+                        <!-- 创建表单标签，用于显示输入项对应的提示文本，这里提示用户输入的是“学号”信息，引导用户明确该输入框的用途。 -->
                         <div class="layui-input-block">
+                            <!-- 创建用于放置输入框等表单控件的块级容器，按照Layui框架的布局规则，输入框等元素会在这个容器内合理显示，确保页面布局整齐，与其他表单项目区分开来。 -->
                             <input type="text" name="student-id" value="${s.s_id}" readonly="readonly" required lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 创建一个文本输入框，名称为“student-id”，通过EL表达式（Expression Language）将“s.s_id”（可能是从服务器端传递过来的学生学号值）作为初始值显示在输入框中，设置为只读（“readonly="readonly"”），意味着用户不能直接修改该输入框中的内容，设置为必填项（“required lay-verify="required"”，Layui框架中用于表单验证，确保用户提交表单时该字段有值），关闭自动完成功能（“autocomplete="off"”），应用Layui框架输入框样式类“layui-input”，用于展示学生的学号信息。 -->
                         </div>
                     </div>
                     <div class="layui-form-item">
                         <label class="layui-form-label">姓名</label>
                         <div class="layui-input-block">
                             <input type="text" name="student-name" value="${s.s_name}" readonly="readonly" required lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 与学号输入框类似，创建一个文本输入框用于展示学生姓名信息，名称为“student-name”，初始值通过EL表达式从“s.s_name”获取，设置为只读、必填项，关闭自动完成功能，应用相应样式类，用户不能修改该姓名信息。 -->
                         </div>
                     </div>
                     <div class="layui-form-item">
                         <label class="layui-form-label">课程号</label>
                         <div class="layui-input-block">
                             <input type="text" name="course-id" value="${c.c_id}" readonly="readonly" required lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 创建文本输入框展示课程号信息，名称为“course-id”，初始值从“c.c_id”获取，设置为只读、必填项，关闭自动完成功能，按框架样式规范显示，用户不可修改课程号内容。 -->
                         </div>
                     </div>
                     <div class="layui-form-item">
                         <label class="layui-form-label">课程名</label>
                         <div class="layui-input-block">
                             <input type="text" name="course-name" value="${c.c_name}" readonly="readonly" required lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 同样地，创建用于展示课程名的文本输入框，名称“course-name”，初始值来自“c.c_name”，设置只读、必填且关闭自动完成功能，按样式类展示课程名，用户无法修改。 -->
                         </div>
                     </div>
                     <div class="layui-form-item">
                         <label class="layui-form-label">课程介绍</label>
                         <div class="layui-input-block">
                             <input type="text" name="course-info" value="${c.c_info}" readonly="readonly" required lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 创建文本输入框来展示课程介绍信息，名称“course-info”，初始值取自“c.c_info”，设置为只读、必填项，关闭自动完成功能，以符合框架样式展示课程介绍内容，用户不能直接编辑。 -->
                         </div>
                     </div>
                     <div class="layui-form-item">
                         <label class="layui-form-label">学生分数</label>
                         <div class="layui-input-block">
                             <input type="text" name="student-score" value="${sc.score}" required lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 创建文本输入框用于输入学生分数，名称“student-score”，初始值通过“sc.score”（可能是之前记录的分数值）获取，设置为必填项（这里可能是因为修改分数时需要用户明确输入新分数），关闭自动完成功能，应用样式类，用户可在此修改学生的分数信息。 -->
                         </div>
                     </div>
 
                     <div class="layui-form-item">
                         <div class="layui-input-block">
                             <button class="layui-btn" lay-submit lay-filter="formDemo">修改</button>
+                            <!-- 创建一个使用Layui框架样式的按钮，文本显示为“修改”，应用“layui-btn”样式类使其呈现出Layui框架中按钮的样式风格。设置“lay-submit”属性表示该按钮点击时会触发表单提交操作，“lay-filter”属性值为“formDemo”，用于后续结合Layui框架的表单验证等功能，为该按钮触发的提交行为绑定特定的验证逻辑或者事件处理逻辑（不过这里具体的验证或事件处理逻辑可能需要在JavaScript代码中进一步定义）。 -->
                             <span style="padding-left: 20px;">${update_msg}</span>
+                            <!-- 创建一个行内的<span>元素，设置左边距为20像素，用于显示一个动态的消息内容（通过EL表达式“${update_msg}”获取，可能是服务器端返回的提示信息，比如修改分数成功或失败的提示等），向用户反馈分数修改操作的相关情况。 -->
                         </div>
                     </div>
                 </form>
                 <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含名为“footer.jsp”的页面，通常这个页面主要是用于定义页面的底部区域的，在这个页面里可能会包含诸如版权信息、联系方式、页面底部导航等相关内容，通过这样的包含操作，可以完善整个页面的布局结构，使其更加完整、规范，给用户呈现出一个完整的页面视觉效果，同时也方便在底部展示一些通用的重要信息或者提供额外的操作入口等。 -->
             </div>
         </div>
     </div>
@@ -74,22 +109,6 @@
 
     <script type="text/javascript">
         $("#nav li:nth-child(1) dl dd:nth-child(4)").addClass("layui-this");
+        // 使用jQuery选择器定位到页面中id为“nav”的元素下的第一个li元素内的dl元素中的第四个dd元素，并为其添加“layui-this”样式类。大概率是用于在导航菜单中标记当前选中的菜单项（依据页面本身的导航结构和样式设置逻辑来确定），使其呈现出被选中的视觉效果，例如改变颜色、加粗等样式变化，从而清晰地表明当前所在的功能页面对应的导航位置，方便用户直观地知晓当前所处的功能模块在整个导航体系中的位置关系。
         $("#nav li:nth-child(1)").addClass("layui-nav-itemed");
-</script>
-<script>
-    //JavaScript代码区域
-    layui.use('element', function(){
-        var element = layui.element;
-        element.init();
-    });
-</script>
-
-<script>
-    //Demo
-    layui.use('form', function(){
-
-    });
-</script>
-
-</body>
-</html>
+        // 同样利用jQuery选择器选择id为“nav”的元素

web/WEB-INF/teacher/updateTeacherOptionalCourseInfo.jsp

@@ -1,54 +1,86 @@
 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
+<!-- JSP页面指令，用于设置页面的相关属性：
+    - “contentType”属性指定页面内容类型为“text/html”，意味着页面以HTML格式展示内容，同时设置字符编码为“UTF-8”，这样能确保页面可以正确处理和显示各种字符（如中文等），避免出现乱码情况，保证页面内容正常展示。
+    - “language=java”表明该JSP页面内部的逻辑实现是基于Java语言的，例如可以在页面中嵌入Java代码片段来与服务器端进行交互、处理业务数据等操作。 -->
+
 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
+<!-- 引入JSTL（JavaServer Pages Standard Tag Library）核心标签库，通过设定“prefix”属性为“c”，后续在页面里就能使用以“c”开头的各种JSTL标签了。这些标签能够方便地实现诸如循环遍历集合数据、进行条件判断、将数据输出到页面等常见功能，大大增强了JSP页面在处理动态数据和展示内容方面的灵活性与便利性。 -->
+
 <html>
 <head>
     <title>修改课程</title>
+    <!-- 设置HTML页面的标题，这里明确表示页面的主题是用于“修改课程”相关操作，该标题会显示在浏览器的标题栏中，方便用户一眼就能知晓当前页面的主要功能。 -->
     <link rel="stylesheet" href="./css/layui.css">
+    <!-- 引入Layui框架的样式文件，通过相对路径“./css/layui.css”去查找对应的CSS文件，该文件中定义了一系列符合Layui框架风格的样式规则，使得页面中使用Layui框架相关的组件（例如表格、按钮、导航栏等元素）都能按照预设的样式进行展示，从而让页面呈现出统一、美观且规范的视觉效果，保持整体风格的一致性。 -->
     <link rel="stylesheet" href="./css/style.css">
+    <!-- 引入自定义的样式文件“style.css”，开发人员可以在这个文件里依据项目的特定需求，对页面的样式进行个性化定制，比如对Layui框架的部分默认样式进行覆盖，或者添加一些独特的页面布局、颜色搭配等样式设定，使页面更好地契合整个项目的设计风格和展示要求。 -->
     <script src="./layui.js"></script>
+    <!-- 引入Layui框架的JavaScript核心文件，借助这个文件，页面能够调用Layui框架所提供的各种JavaScript功能，像弹出层的展示、对表单进行验证、处理页面元素之间的交互操作（比如点击按钮触发特定的事件、动态地显示或隐藏某些元素等）等功能，利用Layui框架的相关API，可为页面添加丰富多样的交互性和动态效果，进而提升用户在使用页面过程中的体验感。 -->
     <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.min.js"></script>
+    <!-- 从CDN（内容分发网络）引入jQuery库的精简版本，jQuery是一款功能强大且广受欢迎的JavaScript库，它极大地简化了在HTML页面中进行DOM（Document Object Model，文档对象模型）操作的复杂度，例如方便地遍历HTML文档中的元素、处理各种页面事件（像鼠标的点击、键盘的输入等事件）、创建动画效果以及实现AJAX（Asynchronous JavaScript and XML，异步的JavaScript和XML）交互等操作，都可以通过使用jQuery库轻松实现，这有助于开发人员更便捷地在页面中构建各种交互功能，进一步增强页面整体的动态交互体验。 -->
 </head>
 <body class="layui-layout-body" style="background-color: #F2F2F2">
+    <!-- 为页面主体设置样式类为“layui-layout-body”，同时通过内联样式设定背景颜色为“#F2F2F2”，这是按照Layui框架的样式规范来对页面主体部分的外观风格进行定义，使得页面呈现出特定的浅灰色（#F2F2F2）背景颜色，有助于营造出整体统一的视觉效果，并且方便后续依据Layui框架既定的布局和样式规则来组织和展示页面中的其他各种内容元素。 -->
     <jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 使用JSP的“include”指令将名为“filterLogin.jsp”的页面包含进来，通常情况下，这个“filterLogin.jsp”页面主要负责处理用户登录验证相关的逻辑，例如它会判断当前访问该页面的用户是否已经成功登录到系统中，如果发现用户没有登录，就会引导用户跳转到登录页面进行登录操作，以此来实现对页面访问权限的有效管控，确保只有合法登录的用户才能够访问当前页面以及后续与之相关的各种功能内容，从而保障整个系统的数据安全以及业务逻辑的正常运行。 -->
     <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <!-- 包含名为“WEB-INF/teacher/tHeader.jsp”的页面，一般来讲，这个页面主要是用于定义教师端页面的头部区域，在这个头部区域当中，通常会包含诸如页面的大标题、用于页面导航的导航栏、展示教师用户基本信息（例如用户名、头像等内容）等与头部相关的各种元素，通过这样的包含操作，就可以把这些头部相关的元素整合到当前页面之中，进而构建出一个完整且规范的页面头部布局结构。 -->
     <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 包含名为“WEB-INF/teacher/teacherNav.jsp”的页面，大概率它的作用是用于展示教师端的导航菜单，借助这个导航菜单，教师用户就可以方便快捷地在不同的功能模块（例如课程管理、学生管理、个人信息管理等不同的功能板块，具体的功能模块划分要取决于业务系统的整体设计需求）之间进行切换操作，实现页面功能的导航跳转，为用户提供便捷的操作入口，从而提升用户使用整个系统的便利性。 -->
     <div class="layui-layout layui-layout-admin">
+        <!-- 创建一个基于Layui框架的布局容器，通过应用“layui-layout”和“layui-layout-admin”这两个样式类，按照Layui框架所提供的特定布局模式对页面进行布局规划，这种布局方式在后台管理系统等应用场景中比较常用，它有着清晰、规范的页面分区结构，便于合理地放置和展示页面内的各种功能内容模块，例如可以很方便地划分出侧边栏、主体内容展示区、页面底部的页脚等不同的区域。 -->
         <div class="layui-body">
+            <!-- 在上述所创建的Layui布局容器内定义页面的主体内容区域，这个区域会依据Layui框架既定的布局规则来进行自适应显示，它主要的作用是用于承载和展示与具体业务相关的核心内容，比如下面即将呈现出来的关于“修改课程”相关信息的表单等内容元素，这里也就是用户在访问该页面时重点关注和进行操作的区域。 -->
             <!-- 内容主体区域 -->
             <div style="padding: 15px;">
+                <!-- 创建一个带有内边距的div容器，通过设置“padding: 15px;”这样的内边距样式，意味着在这个容器的四周（即上、下、左、右四个方向）都会留出15像素的空白空间，这样做的好处是可以让容器内部的内容在页面中展示的时候有一定的间隔，使得页面的布局更加美观、易读，也更便于对内部的各个元素进行排版布局操作，避免内容显得过于拥挤，从而提升用户查看和操作页面内容时的体验感。 -->
                 <span class="layui-breadcrumb">
+                    <!-- 使用Layui框架的面包屑组件，其主要作用是向用户清晰地展示当前页面的导航路径，让用户能够直观地了解当前页面在整个系统中的位置层级关系，通过面包屑组件所展示出来的路径信息，用户可以清楚地知道自己是如何一步步进入到当前这个“修改课程”页面的，同时也方便用户在需要的时候，能够按照这个路径进行回退或者跳转到相关的上级页面等操作，有效地提升了页面的导航便利性以及用户对整个系统结构的理解程度。 -->
                     <a href="">教师端</a>
+                    <!-- 面包屑中的第一个链接，通常情况下它是指向教师端的首页或者是整个教师端功能的主要入口页面的，不过在这里暂时没有设置具体的链接地址（可能后续会根据实际情况进一步去完善它），理论上用户点击该链接可以返回教师端的核心界面，也就是回到一个相对比较顶层的功能页面位置上。 -->
                     <a href="">课程信息</a>
+                    <!-- 面包屑中的第二个链接，它所指向的是与课程信息相关的页面，这个页面可能是课程信息的总览页面或者是对课程进行分类展示的列表页面等相关页面，同样暂时没有设定具体的链接地址，一般情况下用户点击该链接就可以进入到对应的课程信息相关的界面中，进而去查看更详细的课程相关内容。 -->
                     <a><cite>修改课程</cite></a>
+                    <!-- 面包屑中的最后一个元素，明确地显示出当前页面的具体功能是“修改课程”，它主要起到一个标识当前所在功能位置的作用，通常情况下这个元素是不可点击的，仅仅是作为文字提示信息展示给用户，告知用户当前所处的具体业务功能页面是什么。 -->
                 </span>
                 <form class="layui-form" action="${pageContext.request.contextPath}/teacherOptionalCourseUpdateServlet" style="padding-top: 50px" method="post">
+                    <!-- 创建一个使用Layui框架样式的表单，应用“layui-form”样式类使其呈现出符合Layui框架规范的表单样式，方便进行表单元素的布局以及后续的表单验证等操作。设置顶部内边距为50px，使表单与上面的面包屑等元素有一定的垂直间隔，让页面看起来更加美观易读。提交方法为“post”，常用于提交较大量或需要保密的数据，“action”属性通过EL表达式（Expression Language）动态设置表单提交的目标地址为“teacherOptionalCourseUpdateServlet”这个Servlet，意味着当用户提交表单时，数据会被发送到对应的Servlet进行处理，该Servlet大概率负责执行课程修改的相关业务逻辑。 -->
                     <div class="layui-form-item">
+                        <!-- 在表单内创建Layui框架的表单项目容器，用于对单个输入项或一组相关输入项进行分组和布局，方便统一管理和设置样式，使每个输入项在页面中规范显示，便于用户清晰地查看和操作各个表单元素。 -->
                         <label class="layui-form-label">课程号</label>
+                        <!-- 创建表单标签，用于显示输入项对应的提示文本，这里提示用户输入的是“课程号”信息，引导用户明确该输入框的用途。 -->
                         <div class="layui-input-block">
+                            <!-- 创建用于放置输入框等表单控件的块级容器，按照Layui框架的布局规则，输入框等元素会在这个容器内合理显示，确保页面布局整齐，与其他表单项目区分开来。 -->
                             <input type="text" name="cid" value="${course.c_id}" readonly="readonly" required lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 创建一个文本输入框，名称为“cid”，通过EL表达式（Expression Language）将“course.c_id”（可能是从服务器端传递过来的课程编号值）作为初始值显示在输入框中，设置为只读（“readonly="readonly"”），意味着用户不能直接修改该输入框中的内容，设置为必填项（“required lay-verify="required"”，在Layui框架中用于表单验证，确保用户提交表单时该字段有值），关闭自动完成功能（“autocomplete="off"”），应用Layui框架输入框样式类“layui-input”，用于展示课程的编号信息，该编号作为课程的唯一标识，通常不允许随意修改。 -->
                         </div>
                     </div>
                     <div class="layui-form-item">
                         <label class="layui-form-label">课程名</label>
                         <div class="layui-input-block">
                             <input type="text" name="course-name" value="${course.c_name}" required lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 创建一个文本输入框，名称为“course-name”，通过EL表达式将“course.c_name”（可能是从服务器端传递过来的课程名称值）作为初始值显示在输入框中，设置为必填项，用于表单验证，关闭自动完成功能，应用相应样式类，这里用户可以修改课程名称，输入新的名称后提交表单来更新课程相关信息。 -->
                         </div>
                     </div>
                     <div class="layui-form-item">
                         <label class="layui-form-label">课程信息</label>
                         <div class="layui-input-block">
                             <input type="text" name="course-info" value="${course.c_info}" required lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 创建一个文本输入框，名称为“course-info”，通过EL表达式将“course.c_info”（可能是从服务器端传递过来的课程详细介绍信息值）作为初始值显示在输入框中，设置为必填项，关闭自动完成功能，应用样式类，用户可在此修改课程的详细介绍内容，然后通过表单提交更新到服务器端。 -->
                         </div>
                     </div>
 
                     <div class="layui-form-item">
                         <div class="layui-input-block">
                             <button class="layui-btn" lay-submit lay-filter="formDemo">修改</button>
+                            <!-- 创建一个使用Layui框架样式的按钮，文本显示为“修改”，应用“layui-btn”样式类使其呈现出Layui框架中按钮的样式风格。设置“lay-submit”属性表示该按钮点击时会触发表单提交操作，“lay-filter”属性值为“formDemo”，用于后续结合Layui框架的表单验证等功能，为该按钮触发的提交行为绑定特定的验证逻辑或者事件处理逻辑（不过这里具体的验证或事件处理逻辑可能需要在JavaScript代码中进一步定义）。 -->
                             <span style="padding-left: 20px;">${update_msg}</span>
+                            <!-- 创建一个行内的<span>元素，设置左边距为20像素，用于显示一个动态的消息内容（通过EL表达式“${update_msg}”获取，可能是服务器端返回的提示信息，比如课程修改成功或失败的提示等），向用户反馈课程修改操作的相关情况。 -->
                         </div>
                     </div>
                 </form>
                 <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含名为“footer.jsp”的页面，通常这个页面主要是用于定义页面的底部区域，在这个页面里可能会包含诸如版权信息、联系方式、页面底部导航等相关内容，通过这样的包含操作，可以完善整个页面的布局结构，使其更加完整、规范，给用户呈现出一个完整的页面视觉效果，同时也方便在底部展示一些通用的重要信息或者提供额外的操作入口等。 -->
             </div>
         </div>
     </div>
@@ -56,24 +88,22 @@
 
     <script type="text/javascript">
         $("#nav li:nth-child(1) dl dd:nth-child(3)").addClass("layui-this");
+        // 使用jQuery选择器定位到页面中id为“nav”的元素下的第一个li元素内的dl元素中的第三个dd元素，并为其添加“layui-this”样式类。大概率是用于在导航菜单中标记当前选中的菜单项（依据页面本身的导航结构和样式设置逻辑来确定），使其呈现出被选中的视觉效果，例如改变颜色、加粗等样式变化，从而清晰地表明当前所在的功能页面对应的导航位置，方便用户直观地知晓当前所处的功能模块在整个导航体系中的位置关系。
         $("#nav li:nth-child(1)").addClass("layui-nav-itemed");
+        // 使用jQuery选择器选择id为“nav”的元素下的第一个li元素，并为其添加“layui-nav-itemed”样式类，这通常是用于展开或折叠对应的导航菜单项目，使其显示出该导航项处于展开状态的视觉效果（按照Layui导航组件的相关样式和交互逻辑来确定），方便用户查看该菜单项下包含的子菜单或者相关功能选项等内容。
         $("#hidden-update").removeAttr("hidden");
+        // 使用jQuery选择器选择id为“hidden-update”的元素，并移除其“hidden”属性（假设该元素初始是隐藏状态，通过这个操作可以使其在页面中显示出来），不过这里不清楚“hidden-update”具体代表的是什么元素以及它在页面功能中的具体作用，需要结合页面的完整业务逻辑和布局来进一步确定，但总体来说这个操作改变了该元素的显示隐藏状态。
     </script>
     <script>
         //JavaScript代码区域
         layui.use('element', function(){
             var element = layui.element;
             element.init();
+            // 使用Layui框架的模块加载机制，加载“element”模块，获取该模块的实例并赋值给变量“element”，然后调用“init”方法进行初始化操作。“element”模块在Layui框架中通常用于页面元素的操作、动态渲染以及交互效果实现等，通过初始化该模块，可以准备好相关的DOM操作环境、绑定必要的事件等，确保模块能正常工作，进而实现页面中基于该模块的各种功能，例如展开收起导航菜单、切换菜单项的选中状态等操作，使得页面元素具备相应的交互功能。
         });
     </script>
 
     <script>
         //Demo
         layui.use('form', function(){
-
-    });
-</script>
-
-</body>
-</html>
-
+            // 使用Layui框架的模块加载机制，加载“form”模块，不过这里函数体内部暂时没有具体的代码逻辑，一般加载“form”模块后，可以利用它来进行表单相关的操作，比如进一步定义表单验证规则、处理表单提交前后的各种事件