蔡雅楠

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) {
+        if (course!= null) {
-            request.setAttribute("update_msg","课程ID冲突，请重新添加！"+String.format("%tT",new Date()));
+            // 如果课程已存在（即查找结果不为空），则向请求对象中设置一个属性"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 {
+        } 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);  
-            request.setAttribute("update_msg","课程添加成功！"+String.format("%tT",new Date()));
+            // 向请求对象中设置一个属性"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");
-        request.getRequestDispatcher("/WEB-INF/teacher/addOptionalCourse.jsp").forward(request,response);
+        // 设置请求的字符编码为"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 {
-        doPost(request,response);
+        // 重写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");
-        TeacherService service= new TeacherServiceImpl();
+        // 设置请求的字符编码为"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);
-        if (newTeacher != null) {
+        // 调用service（实际是TeacherServiceImpl类的实例）的findTeacherById方法，传入刚才设置好编号的教师对象t，该方法应该是根据教师编号去数据库等存储介质中查询是否存在对应的教师记录，并返回查询到的教师对象（如果存在的话），将查询结果赋值给newTeacher变量。
-            request.setAttribute("update_msg","已存在该教师，请重新添加！"+String.format("%tT",new Date()));
+
+        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);
-        }else {
+            // 获取一个请求转发器，将请求转发到名为"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 {
-        doPost(request,response);
+        // 重写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("collegeLists",collegeList);
+        session.setAttribute("departmentLists", departmentList);
-        session.setAttribute("departmentLists",departmentList);
+        // 类似地，将系别信息列表（departmentList）保存到会话中，属性名为"departmentLists"，以便在相关页面中使用这些系别数据，例如构建下拉菜单选项等。
-        session.setAttribute("classLists",classList);
 
-        request.getRequestDispatcher("/WEB-INF/admin/addTeacher.jsp").forward(request,response);
+        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 {
-        doPost(request,response);
+        // 重写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);
-        request.getRequestDispatcher("/teacherOptionalCourseServlet").forward(request,response);
+        // 调用service（实际是TeacherServiceImpl的实例）的deleteCourseById方法，传入刚才获取到的课程编号cid，该方法应该是在数据库或其他存储课程信息的数据源中，根据课程编号来删除对应的课程记录，实现课程删除的业务逻辑操作。
+
+        request.getRequestDispatcher("/teacherOptionalCourseServlet").forward(request, response);
+        // 获取一个请求转发器，将当前请求转发到"/teacherOptionalCourseServlet"这个资源（可能是另一个Servlet或者JSP页面等）。这样服务器端会接着处理转发后的请求，并向客户端返回相应的响应内容，整个过程对客户端来说是一次完整的请求响应过程，地址栏中的URL不会发生改变，通过转发可以继续后续的页面展示或者其他相关业务处理。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写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);
-        request.getRequestDispatcher("/teacherListServlet").forward(request,response);
+        // 调用service（实际上就是TeacherServiceImpl的实例）的deleteTeacherById方法，将前面获取到的教师编号teacherid作为参数传入进去。这个方法应该是在数据库或者其他存储教师信息的数据源中，依据传入的教师编号来查找并删除对应的教师记录，以此实现删除教师的业务逻辑操作。
+
+        request.getRequestDispatcher("/teacherListServlet").forward(request, response);
+        // 获取一个请求转发器，把当前的请求转发到"/teacherListServlet"这个资源（它可能是另一个Servlet或者是一个JSP页面等）。通过这样的转发操作，服务器端会接着去处理转发后的请求，并向客户端返回相应的响应内容，而且整个过程对于客户端来说就像是一次完整的请求响应过程，客户端浏览器地址栏中的URL并不会发生改变，转发后可以继续进行后续的页面展示或者其他相关业务处理，例如重新展示教师列表等。
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写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.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 {
-        doPost(request,response);
+        // 重写了"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 {
-        request.getRequestDispatcher("/WEB-INF/teacher/tInformation.jsp").forward(request,response);
+        // 重写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 {
-        doPost(request,response);
+        // 重写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 {
-        //调用TeacherService完成查询
+        // 重写HttpServlet类中的doPost方法，用于处理HTTP POST请求。当客户端通过POST方式访问此Servlet对应的URL路径时，容器会调用这个方法来处理请求。
+        // 参数request包含了客户端发送过来的所有请求信息，response则用于向客户端返回响应信息。
+
+        // 调用TeacherService完成查询
         TeacherService teacherService = new TeacherServiceImpl();
+        // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量teacherService。这样后续就可以调用TeacherService接口中定义的业务方法，而具体的查询所有教师信息的操作实现则由TeacherServiceImpl类来完成。
+
         List<Teacher> teachers = teacherService.findAll();
-        //将list存入request域
+        // 调用teacherService（实际是TeacherServiceImpl的实例）的findAll方法，该方法应该是从数据库或其他存储教师信息的数据源中，查询出所有教师的信息，并以Teacher对象的列表形式返回，将查询到的教师信息列表赋值给teachers变量，以便后续使用这些数据进行页面展示等操作。
-        request.setAttribute("teachers",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();
-        Student student= (Student)session.getAttribute("student");
+        // 获取当前请求对应的HttpSession对象，如果不存在则创建一个新的会话对象。HttpSession用于在服务器端管理用户的会话信息，在这里主要是为了获取会话中保存的当前登录用户的相关信息，以此来判断用户的角色类型，进而决定转发到哪个合适的页面进行教师列表展示。
-        Admin admin= (Admin)session.getAttribute("admin");
+
-        Teacher teacher= (Teacher)session.getAttribute("teacher");
+        Student student = (Student) session.getAttribute("student");
-        if (student != null && admin == null && teacher == null) {
+        // 从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);
-        } else if (admin != null && student == null && teacher == null) {
+            // 获取一个请求转发器，将当前请求转发到"/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);
-        } else if (teacher != null && admin == null && student == null) {
+            // 将请求转发到"/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 {
-        this.doPost(request,response);
+        // 重写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");
-        if (t != null) {
+        // 从HttpSession对象中尝试获取名为“teacher”的属性值，并将其强制转换为Teacher类型。通常情况下，在用户（这里指教师）登录成功后，会将教师对象保存到会话中，对应的属性名为“teacher”，通过这样的获取操作可以得到当前登录教师的对象信息，后续就能基于这个对象进行相关业务逻辑操作，比如获取教师编号去查询该教师可教授的课程等。
-            //调用StudentService完成查询
+
+        if (t!= null) {
+            // 判断获取到的教师对象t是否不为null，即判断当前是否有教师登录，如果有教师登录，才执行下面的业务逻辑操作，若为null则可能表示没有合法登录的教师，就不会进行后续的课程查询和页面展示等操作。
+
+            // 调用StudentService完成查询
             TeacherService service = new TeacherServiceImpl();
+            // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量“service”。这样做的好处是，代码后续调用TeacherService接口中定义的方法时，实际上执行的是TeacherServiceImpl类中对这些方法的具体实现代码，使得代码结构更加灵活，便于替换不同的实现方式或者进行单元测试等操作，在这里就是为了调用教师业务相关的方法来查询教师可选课程信息。
+
             List<Course> optionalcourses = service.findMySelfOptionalCourse(t.getT_id());
-            //将list存入request域
+            // 调用“service”（实际上就是TeacherServiceImpl的实例）的“findMySelfOptionalCourse”方法，将前面获取到的教师对象t的教师编号（通过t.getT_id()方法获取）作为参数传入进去。这个方法应该是在数据库或者其他存储课程信息的数据源中，依据传入的教师编号来查询出该教师能够选择教授的所有课程信息，并以Course对象组成的列表形式返回，然后将查询到的可选课程信息列表赋值给“optionalcourses”变量，方便后续对这些查询结果进行进一步的处理和展示操作，比如在页面上展示课程列表供教师查看选择等。
-            request.setAttribute("optionalcourses",optionalcourses);
+
-            //转发到list.jsp
+            // 将list存入request域
-            request.getRequestDispatcher("/WEB-INF/teacher/teacherOptionalCourse.jsp").forward(request,response);
+            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 {
-        this.doPost(request,response);
+        // 重写了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");
+        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("<")) {
-            request.setAttribute("update_msg","格式错误，请重新提交！"+String.format("%tT",new Date()));
+            // 检查获取到的课程编号（cid）、课程名称（name）、课程信息（info）中是否包含字符"<"，这里可能是基于安全或数据格式的考虑，防止输入的内容不符合数据库字段存储要求或者存在潜在的安全风险（比如SQL注入攻击等情况，虽然简单的这种判断不能完全杜绝，但能做一定程度防范），如果包含则认为格式错误。
-            request.getRequestDispatcher("updateTeacherOptionalCourseServlet?cid="+cid).forward(request, response);
+            request.setAttribute("update_msg", "格式错误，请重新提交！" + String.format("%tT", new Date()));
-        }else {
+            // 使用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服务（此处应为调用TeacherService服务，可能是注释书写错误）
+            TeacherService service = new TeacherServiceImpl();
+            // 创建一个TeacherServiceImpl类的实例，通过多态的方式将其赋值给TeacherService接口类型的变量service。这样后续就可以调用TeacherService接口中定义的业务方法，而具体的更新课程信息的操作实现则由TeacherServiceImpl类来完成。
 
-            //调用studentUpdata服务
-            TeacherService service= new TeacherServiceImpl();
             service.updateCourseInfo(updateCourse);
+            // 调用service（实际是TeacherServiceImpl的实例）的updateCourseInfo方法，将封装好的包含更新后信息的课程对象updateCourse传入，该方法应该是在数据库或其他存储课程信息的数据源中，根据课程对象中的信息（编号、名称、详细信息等）来更新对应的课程记录，实现课程信息的更新业务逻辑操作。
 
-            //成功则返回并给提示
+            // 成功则返回并给提示
-            request.setAttribute("update_msg", "修改成功！"+String.format("%tT",new Date()));
+            request.setAttribute("update_msg", "修改成功！" + String.format("%tT", new Date()));
-            request.getRequestDispatcher("updateTeacherOptionalCourseServlet?cid="+cid).forward(request, response);
+            // 设置名为"update_msg"的属性，属性值为修改成功的提示信息，并拼接当前时间，方便用户知晓操作完成且成功的时间情况。
+
+            request.getRequestDispatcher("updateTeacherOptionalCourseServlet?cid=" + cid).forward(request, response);
+            // 同样获取请求转发器，将请求转发到"updateTeacherOptionalCourseServlet"资源并带上课程编号cid作为参数，进行后续的页面展示或者其他相关业务处理，告知用户修改成功并可以进行后续查看等操作。
         }
     }
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-        doPost(request,response);
+        // 重写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 {
-        request.getRequestDispatcher("/WEB-INF/teacher/teacherUpdatePassword.jsp").forward(request,response);
+        // 重写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 {
-        doPost(request,response);
+        // 重写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();
-        Teacher teacher = (Teacher)session.getAttribute("teacher");
+        // 获取当前请求对应的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) {
-            request.setAttribute("update_msg", "密码格式错误，重新提交！"+String.format("%tT",new Date()));
+            // 如果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();
+            TeacherService service = new TeacherServiceImpl();
-            service.updatePassword(teacherid,newpassword);
+            // 创建一个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;
-            session.setAttribute("teacher",teacher);
+            // 将更新后的教师对象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 {
-        doPost(request,response);
+        // 重写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.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);
-        SelectCourse sc = service2.findScoreByCourseIdAndStudentId(cid,sid);
+        // 调用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("s",s);
+        request.setAttribute("c", c);
-        request.setAttribute("c",c);
+        // 同样，将查询到的课程对象c保存到请求对象中，属性名为"c"，方便在JSP页面等地方获取课程信息进行展示，例如展示课程名称、学分等相关内容。
-        request.setAttribute("sc",sc);
+
-        request.setAttribute("update_msg","修改分数成功！"+String.format("%tT",new Date()));
+        request.setAttribute("sc", sc);
-        request.getRequestDispatcher("/WEB-INF/teacher/updateOptionalCourseScore.jsp").forward(request,response);
+        // 把查询到的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 {
-        doPost(request,response);
+        // 重写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();
-        SelectCourse sc = service2.findScoreByCourseIdAndStudentId(cid,sid);
+        // 创建一个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("s",s);
+        request.setAttribute("c", c);
-        request.setAttribute("c",c);
+        // 同样，将查询到的课程对象c保存到请求对象中，属性名为"c"，方便在JSP页面等地方获取课程信息进行展示，例如展示课程名称、学分等相关内容。
-        request.setAttribute("sc",sc);
+
-        request.getRequestDispatcher("/WEB-INF/teacher/updateOptionalCourseScore.jsp").forward(request,response);
+        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 {
-        doPost(request,response);
+        // 重写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("<")) {
+
-            request.setAttribute("update_msg","格式错误，请重新提交！"+String.format("%tT",new Date()));
+        // 判断输入位数是否大于数据库位数
-            request.getRequestDispatcher("updateTeacherServlet?tid="+tid).forward(request, response);
+        if (name.length() > 4 || education.length() > 20 || title.length() > 24 || name.contains("<") || education.contains("<") || title.contains("<")) {
-        }else {
+            // 这里进行一系列的格式验证判断，检查教师姓名（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 {
-        doPost(request,response);
+        // 重写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();
-        String cid = (String)request.getParameter("cid");
+        // 这行代码被注释掉了，原本的意图应该是获取当前请求对应的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);
-        request.setAttribute("course",c);
+        // 调用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);
+        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 {
-        doPost(request,response);
+        // 重写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);
-        request.setAttribute("teacher",newTeacher);
+        // 调用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("collegeLists",collegeList);
+        session.setAttribute("departmentLists", departmentList);
-        session.setAttribute("departmentLists",departmentList);
+        // 同样，将系信息列表departmentList保存到会话对象中，属性名为“departmentLists”，便于后续在页面展示系相关信息以及进行系相关的业务操作时从会话中获取对应的系信息列表。
-        session.setAttribute("classLists",classList);
 
-        request.getRequestDispatcher("/WEB-INF/admin/updateTeacher.jsp").forward(request,response);
+        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 {
-        doPost(request,response);
+        // 重写HttpServlet类中的doGet方法，用于处理HTTP GET请求，例如当客户端通过在浏览器地址栏直接输入URL或者点击链接等方式（通常这些情况会发起GET请求）访问此Servlet对应的路径时，Web容器会调用这个方法来处理相应的请求。
+
+        doPost(request, response);
+        // 在doGet方法中直接调用了doPost方法，意味着对于GET请求的处理逻辑和POST请求的处理逻辑是一样的，即不管客户端是通过POST方式还是GET方式访问这个Servlet对应的路径，都会按照doPost方法里所定义的逻辑去进行相应的处理，比如获取教师编号、查询教师信息、获取学校组织结构信息、设置请求和会话属性以及转发请求到JSP页面等操作都会同样执行，这样做可能是在业务逻辑上对于这两种请求方式进入教师信息更新页面的操作要求是一致的，所以进行了这样的复用处理。
     }
 }

web/WEB-INF/teacher/addOptionalCourse.jsp

@@ -1,77 +1,111 @@
 <%@ 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">
-<jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 设置页面主体的样式类为"layui-layout-body"，并且指定背景颜色为#F2F2F2，通过样式类和内联样式相结合的方式来定义页面主体部分的外观风格，可能符合整个项目中统一的页面布局和色彩搭配要求。 -->
-<jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <jsp:include page="/filterLogin.jsp"></jsp:include>
-<jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 通过JSP的include指令，将名为"filterLogin.jsp"的页面包含进来，通常这个页面可能用于处理用户登录验证相关的逻辑，比如判断用户是否已经登录，如果未登录则可能跳转到登录页面等操作，实现页面访问权限的控制。 -->
-<div class="layui-layout layui-layout-admin">
+    <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
-    <div class="layui-body">
+    <!-- 包含名为"WEB-INF/teacher/tHeader.jsp"的页面，一般这个页面用于定义教师端页面的头部区域，可能包含页面的标题、导航栏等头部相关的元素和布局。 -->
-        <!-- 内容主体区域 -->
+    <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
-        <div style="padding: 15px;">
+    <!-- 包含"WEB-INF/teacher/teacherNav.jsp"页面，该页面大概率是用于展示教师端的导航菜单，方便教师在不同功能模块（如课程管理、学生管理等，具体看业务需求）之间进行切换操作。 -->
-            <span class="layui-breadcrumb">
+    <div class="layui-layout layui-layout-admin">
-                <a href="">教师端</a>
+        <!-- 创建一个使用Layui框架的布局容器，类名"layui-layout"和"layui-layout-admin"表示采用了Layui框架提供的特定布局样式，可能适用于后台管理系统等场景，具有规范的页面分区结构。 -->
-                <a href="">课程信息</a>
+        <div class="layui-body">
-                <a><cite>添加课程</cite></a>
+            <!-- 在Layui布局容器内定义页面的主体内容区域，这个区域会根据Layui框架的布局规则进行自适应显示，用于放置具体的业务相关内容，如添加课程的表单等。 -->
-            </span>
+            <!-- 内容主体区域 -->
-            <form class="layui-form" action="${pageContext.request.contextPath}/addOptionalCourseServlet" style="padding-top: 50px" method="post">
+            <div style="padding: 15px;">
-                <div class="layui-form-item">
+                <!-- 创建一个具有内边距的div容器，用于对内部的内容进行布局排版，使得内容在页面中显示时有一定的空白间隔，更加美观和易读。 -->
-                    <label class="layui-form-label">课程号</label>
+                <span class="layui-breadcrumb">
-                    <div class="layui-input-block">
+                    <!-- 使用Layui框架的面包屑组件，用于显示页面的导航路径，方便用户了解当前页面在整个系统中的位置层级关系。 -->
-                        <input type="text" name="cid" required lay-verify="required" autocomplete="off" class="layui-input">
+                    <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>
+                    <div class="layui-form-item">
-                <div class="layui-form-item">
+                        <label class="layui-form-label">课程名</label>
-                    <label class="layui-form-label">课程名</label>
+                        <div class="layui-input-block">
-                    <div class="layui-input-block">
+                            <input type="text" name="course-name" required lay-verify="required" autocomplete="off" class="layui-input">
-                        <input type="text" name="course-name" required lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 与上面课程号输入框类似，创建一个用于输入课程名的文本输入框，名称为"course-name"，同样是必填项，关闭自动完成功能并应用Layui框架样式，用户在此输入课程的名称信息。 -->
+                        </div>
                     </div>
-                </div>
+                    <div class="layui-form-item">
-                <div class="layui-form-item">
+                        <label class="layui-form-label">课程信息</label>
-                    <label class="layui-form-label">课程信息</label>
+                        <div class="layui-input-block">
-                    <div class="layui-input-block">
+                            <input type="text" name="course-info" required lay-verify="required" autocomplete="off" class="layui-input">
-                        <input type="text" name="course-info" required lay-verify="required" autocomplete="off" class="layui-input">
+                            <!-- 创建用于输入课程详细信息的文本输入框，名称为"course-info"，也是必填项，遵循相同的规则，用户在此输入课程的详细介绍等相关信息。 -->
+                        </div>
                     </div>
-                </div>
 
-                <div class="layui-form-item">
+                    <div class="layui-form-item">
-                    <div class="layui-input-block">
+                        <div class="layui-input-block">
-                        <button class="layui-btn" lay-submit lay-filter="formDemo">添加</button>
+                            <button class="layui-btn" lay-submit lay-filter="formDemo">添加</button>
-                        <span style="padding-left: 20px;">${update_msg}</span>
+                            <!-- 创建一个使用Layui框架样式的按钮，文本显示为“添加”，通过"lay-submit"属性声明该按钮用于提交表单，"lay-filter=formDemo"则可能是用于设置表单提交的验证规则或者事件监听等相关的过滤器名称（需要在后续的JavaScript代码中进一步定义具体逻辑），点击该按钮可以触发表单提交操作，将用户输入的课程相关信息发送到指定的Servlet进行处理。 -->
+                            <span style="padding-left: 20px;">${update_msg}</span>
+                            <!-- 通过EL表达式显示名为"update_msg"的变量内容，这个变量可能是在服务器端（比如对应的Servlet）设置的提示信息，用于向用户反馈操作结果（比如添加课程成功或失败的提示等），并设置了左边20px的内边距，使其与按钮有一定的间距显示。 -->
+                        </div>
                     </div>
-                </div>
+                </form>
-            </form>
+                <jsp:include page="/footer.jsp"></jsp:include>
-            <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含名为"footer.jsp"的页面，通常这个页面用于定义页面的底部区域，比如版权信息、联系方式、页面底部导航等相关内容，完善页面的整体布局结构。 -->
+            </div>
         </div>
     </div>
-</div>
 
 
-<script type="text/javascript">
+    <script type="text/javascript">
-    $("#nav li:nth-child(1) dl dd:nth-child(4)").addClass("layui-this");
+        $("#nav li:nth-child(1) dl dd:nth-child(4)").addClass("layui-this");
-    $("#nav li:nth-child(1)").addClass("layui-nav-itemed");
+        // 使用jQuery选择器选择页面中id为"nav"的元素下的第一个li元素内的dl元素中的第四个dd元素，并为其添加"layui-this"样式类，可能是用于在导航菜单中标记当前选中的菜单项（具体取决于页面的导航结构和样式设置逻辑），使其显示出当前选中的效果，比如改变颜色、加粗等样式变化。
-</script>
+        $("#nav li:nth-child(1)").addClass("layui-nav-itemed");
-<script>
+        // 同样使用jQuery选择器选择id为"nav"的元素下的第一个li元素，并为其添加"layui-nav-itemed"样式类，大概率是用于展开或折叠对应的导航菜单项目，显示出该导航项处于展开状态的视觉效果（根据Layui导航组件的样式规则）。
-    //JavaScript代码区域
+    </script>
-    layui.use('element', function(){
+    <script>
-        var element = layui.element;
+        //JavaScript代码区域
-        element.init();
+        layui.use('element', function(){
-    });
+            var element = layui.element;
-</script>
+            element.init();
+            // 使用Layui框架的模块加载机制，加载"element"模块，获取该模块实例并赋值给变量"element"，然后调用模块的"init"方法进行初始化操作，这个"element"模块通常用于页面元素的操作、动态渲染以及交互效果实现等，初始化操作可能是准备相关的DOM操作环境、绑定事件等，确保模块能正常工作，实现页面中各种基于该模块的功能，比如页面布局的动态调整、元素显示隐藏控制等。
+        });
+    </script>
 
-<script>
+    <script>
-    //Demo
+        //Demo
-    layui.use('form', function(){
+        layui.use('form', function(){
+            // 使用Layui框架的模块加载机制，加载"form"模块，通常加载这个模块后可以使用Layui框架提供的表单相关的功能，比如表单验证、提交前的数据处理等操作，不过这里暂时没有在回调函数内添加具体的业务逻辑代码（可能后续根据实际的表单验证等需求补充完整）。
 
-    });
+        });
-</script>
+    </script>
 
 </body>
 </html>

web/WEB-INF/teacher/findSelectCourseListByCourseId.jsp

@@ -1,77 +1,124 @@
 <%@ 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">
-<jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 为页面主体设置样式类为"layui-layout-body"，并通过内联样式指定背景颜色为#F2F2F2，这是结合Layui框架的样式规范来定义页面主体部分的外观风格，营造出特定的视觉背景，可能符合整个项目中统一的页面设计要求。 -->
-<jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <jsp:include page="/filterLogin.jsp"></jsp:include>
-<jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 通过JSP的include指令，将名为"filterLogin.jsp"的页面包含进来，该页面通常用于处理用户登录验证相关的逻辑，比如判断用户是否已经登录，如果未登录可能会跳转到登录页面，以此来实现对页面访问权限的控制，保障系统的安全性和数据的合法性。 -->
-<div class="layui-layout layui-layout-admin">
+    <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
-    <div class="layui-body">
+    <!-- 包含名为"WEB-INF/teacher/tHeader.jsp"的页面，一般这个页面用于定义教师端页面的头部区域，里面可能包含页面的标题、导航栏、用户信息展示等头部相关元素，构建出页面头部的布局结构。 -->
-        <!-- 内容主体区域 -->
+    <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
-        <div style="padding: 15px;">
+    <!-- 包含"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">
+                <table class="layui-table" lay-filter="test">
-                <thead>
+                    <!-- 创建一个使用Layui框架样式的表格，应用"layui-table"样式类使其外观符合Layui框架的表格风格，同时通过"lay-filter"属性设置一个过滤器名称为"test"，这个过滤器可以在后续的JavaScript代码中用于绑定表格相关的事件（如行点击事件、排序事件等），方便对表格进行交互操作。 -->
-                <tr>
+                    <thead>
-                    <th>ID</th>
+                    <!-- 定义表格的表头部分，用于展示各列的标题信息。 -->
-                    <th>学号</th>
-                    <th>学生姓名</th>
-                    <th>课程号</th>
-                    <th>课程名</th>
-                    <th>课程简介</th>
-                    <th>学生分数</th>
-                    <td>操作</td>
-                </tr>
-                </thead>
-
-                <c:forEach items="${scs}" var="sc" varStatus="t">
                     <tr>
-                        <td>${t.count}</td>
+                        <!-- 创建表格中的一行，用于放置表头单元格（th元素）。 -->
-                        <td>${sc.s_id}</td>
+                        <th>ID</th>
-                        <td>${sc.s_name}</td>
+                        <!-- 表头单元格，用于显示“ID”这一列的标题，具体含义可能是记录的唯一标识或者序号等，根据业务需求而定。 -->
-                        <td>${sc.c_id}</td>
+                        <th>学号</th>
-                        <td>${sc.c_name}</td>
+                        <!-- 表头单元格，显示“学号”列标题，代表学生的学号信息，后续表格行会对应展示具体学生的学号内容。 -->
-                        <td>${sc.c_info}</td>
+                        <th>学生姓名</th>
-                        <td>${sc.score}</td>
+                        <!-- 表头单元格，用于展示“学生姓名”这一标题，对应列会显示具体学生的姓名信息。 -->
-                        <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>
+                        <th>课程号</th>
+                        <!-- 表头单元格，标题为“课程号”，该列将展示相应课程的编号信息，用于区分不同的课程。 -->
+                        <th>课程名</th>
+                        <!-- 表头单元格，显示“课程名”标题，对应的表格列会呈现具体课程的名称信息。 -->
+                        <th>课程简介</th>
+                        <!-- 表头单元格，标题为“课程简介”，其所在列会展示相应课程的详细介绍信息，方便教师查看课程相关情况。 -->
+                        <th>学生分数</th>
+                        <!-- 表头单元格，用于展示“学生分数”这一标题，对应列会显示学生在相应课程上的成绩情况。 -->
+                        <td>操作</td>
+                        <!-- 表头单元格（这里使用td也可以，不过按规范表头一般用th更好些），标题为“操作”，该列用于放置针对每一行数据可进行的操作按钮等元素，比如修改分数、删除等操作。 -->
                     </tr>
-                </c:forEach>
+                    </thead>
-            </table>
+
-            <jsp:include page="/footer.jsp"></jsp:include>
+                    <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>
-</div>
 
 
-<script type="text/javascript">
+    <script type="text/javascript">
-    $("#nav li:nth-child(1) dl dd:nth-child(2)").addClass("layui-this");
+        $("#nav li:nth-child(1) dl dd:nth-child(2)").addClass("layui-this");
-    $("#nav li:nth-child(1)").addClass("layui-nav-itemed");
+        // 使用jQuery选择器选择页面中id为"nav"的元素下的第一个li元素内的dl元素中的第二个dd元素，并为其添加"layui-this"样式类，很可能是用于在导航菜单中标记当前选中的菜单项（依据页面的导航结构和样式设置逻辑），使其呈现出被选中的视觉效果，例如改变颜色、加粗等样式变化，表明当前所在的功能页面对应的导航位置。
-    $("#hidden-score").removeAttr("hidden");
+        $("#nav li:nth-child(1)").addClass("layui-nav-itemed");
-</script>
+        // 同样使用jQuery选择器选择id为"nav"的元素下的第一个li元素，并为其添加"layui-nav-itemed"样式类，大概率是用于展开或折叠对应的导航菜单项目，使其显示出该导航项处于展开状态的视觉效果（根据Layui导航组件的样式规则），方便展示相关的子菜单或者突出当前所在的主菜单。
-<script>
+        $("#hidden-score").removeAttr("hidden");
-    //JavaScript代码区域
+        // 使用jQuery选择器选择id为"hidden-score"的元素，并移除其"hidden"属性（如果有的话），意味着原本可能隐藏的元素（根据HTML中"hidden"属性的作用）会变为可见状态，具体这个元素是什么以及作用如何，要结合页面的其他部分代码来看，可能是与成绩相关的某个隐藏元素现在需要显示出来，比如隐藏的分数统计区域等（只是猜测，具体依业务而定）。
-    layui.use('element', function(){
+    </script>
-        var element = layui.element;
+    <script>
-        element.init();
+        //JavaScript代码区域
-    });
+        layui.use('element', function(){
-</script>
+            var element = layui.element;
-<script type="text/javascript">
+            element.init();
-    function deleteOptionalCourse(c_id) {
+            // 使用Layui框架的模块加载机制，加载"element"模块，获取该模块实例并赋值给变量"element"，然后调用模块的"init"方法进行初始化操作，"element"模块通常用于页面元素的操作、动态渲染以及交互效果实现等，初始化这个模块可以准备好相关的DOM操作环境、绑定必要的事件等，确保模块能正常工作，进而实现页面中各种基于该模块的功能，比如页面布局的动态调整、元素显示隐藏控制等。
-        if (confirm("你确定删除授课吗？")) {
+        });
-            location.href = "${pageContext.request.contextPath}/deleteOptionalCourseServlet?cid=" + c_id;
+    </script>
+    <script type="text/javascript">
+        function deleteOptionalCourse(c_id) {
+            if (confirm("你确定删除授课吗？")) {
+                location.href = "${pageContext.request.contextPath}/deleteOptionalCourseServlet?cid=" + c_id;
+            }
         }
-    }
+        // 定义一个名为"deleteOptionalCourse"的JavaScript函数，接收一个参数"c_id"，该函数用于处理删除授课相关的操作逻辑。首先通过"confirm"函数弹出一个确认对话框，询问用户是否确定要删除授课，当用户点击“确定”按钮时（返回值为true时），会将页面的地址跳转到通过EL表达式动态生成的路径，指向"deleteOptionalCourseServlet"这个Servlet，并传递当前要删除授课对应的课程号（"c_id"参数的值）作为参数，以便在服务器端（对应的Servlet中）根据课程号执行相应的删除授课的业务逻辑，实现删除操作。
-</script>
+    </script>
 </body>
 </html>

web/WEB-INF/teacher/tCDCList.jsp

@@ -1,62 +1,99 @@
 <%@ 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">
-<jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 为页面主体设置样式类为"layui-layout-body"，并通过内联样式指定背景颜色为#F2F2F2，这样结合Layui框架的样式规范，定义了页面主体部分的整体外观风格，营造出特定的视觉背景效果，通常是为了与整个项目中统一的页面设计风格保持一致。 -->
-<jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <jsp:include page="/filterLogin.jsp"></jsp:include>
-<jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 使用JSP的include指令将名为"filterLogin.jsp"的页面包含进来，这个页面一般用于处理用户登录验证相关的逻辑，例如判断当前用户是否已经登录，如果未登录则可能会引导用户跳转到登录页面，以此来实现对页面访问权限的有效控制，确保系统的安全性以及数据的合法性。 -->
-<div class="layui-layout layui-layout-admin">
+    <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
-    <div class="layui-body">
+    <!-- 包含名为"WEB-INF/teacher/tHeader.jsp"的页面，该页面通常用于定义教师端页面的头部区域，里面可能包含诸如页面标题、导航栏、用户信息展示等头部相关元素，以此构建出页面头部的整体布局结构。 -->
-        <!-- 内容主体区域 -->
+    <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
-        <div style="padding: 15px;">
+    <!-- 包含名为"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">
+                <table class="layui-table" lay-filter="test">
-                <thead>
+                    <!-- 创建一个使用Layui框架样式的表格，应用"layui-table"样式类使其外观符合Layui框架所定义的表格风格，同时通过"lay-filter"属性设置一个过滤器名称为"test"，这个过滤器后续可在JavaScript代码中用于绑定表格相关的各种事件（例如行点击事件、排序事件等），方便实现对表格的交互操作以及数据处理功能。 -->
-                <tr>
+                    <thead>
-                    <th>ID</th>
+                    <!-- 定义表格的表头部分，用于清晰展示各列所代表的标题信息，让用户明白每一列数据的含义。 -->
-                    <th>学院</th>
-                    <th>专业</th>
-                    <th>班级</th>
-                </tr>
-                </thead>
-
-                <c:forEach items="${cdcs}" var="cdc" varStatus="c">
                     <tr>
-                        <td>${c.count}</td>
+                        <!-- 创建表格中的一行，该行用于放置表头单元格（th元素），每个th元素对应表格中的一列标题。 -->
-                        <td>${cdc.college}</td>
+                        <th>ID</th>
-                        <td>${cdc.department}</td>
+                        <!-- 表头单元格，标题为“ID”，此处的“ID”具体含义可能是每条学院专业记录的唯一标识编号或者是序号等，具体要根据业务需求来确定，其所在列后续会展示相应的标识信息。 -->
-                        <td>${cdc.cclass}</td>
+                        <th>学院</th>
+                        <!-- 表头单元格，显示“学院”这一标题，对应列将展示具体的学院名称信息，方便用户查看不同学院的相关数据。 -->
+                        <th>专业</th>
+                        <!-- 表头单元格，标题为“专业”，所在列会呈现相应的专业名称等专业相关信息，便于了解各学院下包含的专业情况。 -->
+                        <th>班级</th>
+                        <!-- 表头单元格，显示“班级”标题，其对应的表格列用于展示具体的班级名称等班级相关信息，有助于全面查看学院专业下涉及的班级情况。 -->
                     </tr>
-                </c:forEach>
+                    </thead>
-            </table>
+
-            <jsp:include page="/footer.jsp"></jsp:include>
+                    <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>
-</div>
 
 
-<script type="text/javascript">
+    <script type="text/javascript">
-    $("#nav li:nth-child(4) dl dd:nth-child(1)").addClass("layui-this");
+        $("#nav li:nth-child(4) dl dd:nth-child(1)").addClass("layui-this");
-    $("#nav li:nth-child(4)").addClass("layui-nav-itemed");
+        // 使用jQuery选择器来定位页面中特定的元素，具体选择的是id为"nav"的元素下的第四个li元素内的dl元素中的第一个dd元素，然后为其添加"layui-this"样式类。这么做大概率是为了在导航菜单中标记当前选中的菜单项（依据页面本身的导航结构和样式设置逻辑来确定），使其呈现出被选中的视觉效果，例如改变颜色、加粗等样式变化，从而清晰地表明当前所在的功能页面对应的导航位置。
-</script>
+        $("#nav li:nth-child(4)").addClass("layui-nav-itemed");
-<script>
+        // 同样利用jQuery选择器选择id为"nav"的元素下的第四个li元素，并为其添加"layui-nav-itemed"样式类，这通常是用于展开或折叠对应的导航菜单项目，使其显示出该导航项处于展开状态的视觉效果（按照Layui导航组件的样式规则来实现），方便展示相关的子菜单或者突出当前所在的主菜单部分。
-    //JavaScript代码区域
+    </script>
-    layui.use('element', function(){
+    <script>
-        var element = layui.element;
+        //JavaScript代码区域
-        element.init();
+        layui.use('element', function(){
-    });
+            var element = layui.element;
-</script>
+            element.init();
+            // 使用Layui框架的模块加载机制，加载"element"模块，获取该模块实例并赋值给变量"element"，随后调用模块的"init"方法进行初始化操作。"element"模块在Layui框架中通常用于页面元素的操作、动态渲染以及交互效果实现等方面，通过初始化这个模块，可以准备好相关的DOM操作环境、绑定必要的事件等，以此确保该模块能够正常工作，进而实现页面中各种基于该模块的功能，例如页面布局的动态调整、元素显示隐藏控制等功能。
+        });
+    </script>
 
 </body>
 </html>

web/WEB-INF/teacher/tFindFileList.jsp

@@ -1,63 +1,97 @@
 <%@ 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">
-<jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 为页面主体设置样式类为“layui-layout-body”，同时通过内联样式设定背景颜色为“#F2F2F2”。这是按照Layui框架的样式规范来对页面主体部分的外观风格进行定义，使得页面呈现出特定的背景颜色，有助于营造出整体统一的视觉效果，并且方便后续依据Layui框架既定的布局和样式规则来组织和展示页面中的其他各种内容元素。 -->
-<jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <jsp:include page="/filterLogin.jsp"></jsp:include>
-<jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 使用JSP的“include”指令将名为“filterLogin.jsp”的页面包含进来。通常情况下，这个“filterLogin.jsp”页面主要负责处理用户登录验证相关的逻辑，比如它会判断当前访问该页面的用户是否已经成功登录到系统中，如果发现用户没有登录，那么就会引导用户跳转到登录页面进行登录操作，以此来实现对页面访问权限的有效管控，确保只有合法登录的用户才能够访问当前页面以及后续与之相关的各种功能内容，从而保障整个系统的数据安全以及业务逻辑的正常运行。 -->
-<div class="layui-layout layui-layout-admin">
+    <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
-    <div class="layui-body">
+    <!-- 包含名为“WEB-INF/teacher/tHeader.jsp”的页面，一般来讲，这个页面主要是用于定义教师端页面的头部区域的。在这个头部区域当中，通常会包含诸如页面的大标题、用于页面导航的导航栏、展示教师用户基本信息（例如用户名、头像等内容）等与头部相关的各种元素，通过这样的包含操作，就可以把这些头部相关的元素整合到当前页面之中，进而构建出一个完整且规范的页面头部布局结构。 -->
-        <!-- 内容主体区域 -->
+    <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
-        <div style="padding: 15px;">
+    <!-- 包含名为“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">
+                <table class="layui-table" lay-filter="test">
-                <thead>
+                    <!-- 创建一个使用Layui框架样式的表格，通过应用“layui-table”样式类使得表格的外观符合Layui框架所定义的表格风格，整体看上去会更加美观、专业，并且能够与整个系统的界面风格保持一致性要求。同时，利用“lay-filter”属性设置了一个过滤器名称为“test”，这个过滤器在后续的JavaScript代码中可以用于绑定表格相关的各种事件（例如当用户点击某一行数据时触发的事件、对表格中的数据进行排序时触发的事件、对单元格内容进行编辑时触发的事件等等），方便实现对表格的交互操作以及数据处理等功能，进而增强表格在实际使用过程中的实用性和用户交互性。 -->
-                <tr>
+                    <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">
-                    <tr>
-                        <td>${f.count}</td>
-                        <td>${filelist.fileName}</td>
-                        <td>${filelist.filePath}</td>
-                        <td>${filelist.fileSize}</td>
-                        <td><a class="layui-btn layui-btn-normal" href="${pageContext.request.contextPath}/downloadServlet?filename=${filelist.fileName}">下载</a></td>
                     </tr>
-                </c:forEach>
+                    </thead>
-            </table>
+
-            <jsp:include page="/footer.jsp"></jsp:include>
+                    <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>
-</div>
 
 
-<script type="text/javascript">
+    <script type="text/javascript">
-    $("#nav li:nth-child(5) dl dd:nth-child(3)").addClass("layui-this");
+        $("#nav li:nth-child(5) dl dd:nth-child(3)").addClass("layui-this");
-    $("#nav li:nth-child(5)").addClass("layui-nav-itemed");
+        // 使用jQuery选择器来定位页面中特定的元素，具体选择的是id为“nav”的元素下的第五个li元素内的dl元素中的第三个dd元素，然后为其添加“layui-this”样式类。这么做大概率是为了在导航菜单中标记当前选中的菜单项（依据页面本身的导航结构和样式设置逻辑来确定），使其呈现出被选中的视觉效果，例如改变颜色、加粗等样式变化，从而清晰地表明当前所在的功能页面对应的导航位置，方便用户直观地知晓当前所处的功能模块在整个导航体系中的位置关系。
-</script>
+        $("#nav li:nth-child(5)").addClass("layui-nav-itemed");
-<script>
+        // 同样利用jQuery选择器选择id为“nav”的元素下的第五个li元素，并为其添加“layui-nav-itemed”样式类，这通常是用于展开或折叠对应的导航菜单项目，使其显示出该导航项处于展开状态的视觉效果（按照Layui导航
-    //JavaScript代码区域
-    layui.use('element', function(){
-        var element = layui.element;
-        element.init();
-    });
-</script>
-</body>
-</html>

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">
-<jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 为页面主体设置样式类为“layui-layout-body”，并通过内联样式指定背景颜色为“#F2F2F2”，按照Layui框架的样式规范定义主体部分外观风格，营造特定视觉背景，符合项目统一的页面设计要求，便于后续布局页面内容。 -->
-<jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <jsp:include page="/filterLogin.jsp"></jsp:include>
-<jsp:include page="/WEB-INF/teacher/teacherNav.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}">
-                    <a href ="javascript:return false;">
+                        <!-- 使用JSTL的“if”条件判断标签，判断当前页码（“pb.currentPage”，可能是从服务器端传递过来表示当前显示的页码信息）是否等于1，如果是则执行下面的内容。 -->
+                        <a href ="javascript:return false;">
+                            <!-- 创建链接元素，设置链接地址为“javascript:return false;”，意味着点击时不会进行实际的页面跳转，通常用于禁用当前链接，在这里就是禁用上一页链接（因为当前已经是第一页了）。 -->
                         </c:if>
-                        <c:if test="${pb.currentPage != 1}">
+                        <c:if test="${pb.currentPage!= 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]}">
+                            <!-- 另一个“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}">
+                        <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,66 +1,101 @@
 <%@ 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">
-<jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 为页面主体设置样式类为“layui-layout-body”，同时通过内联样式设定背景颜色为“#F2F2F2”，这是按照Layui框架的样式规范来对页面主体部分的外观风格进行定义的，使得页面呈现出特定的背景颜色，有助于营造出整体统一的视觉效果，并且方便后续依据Layui框架既定的布局和样式规则来组织和展示页面中的其他各种内容元素。 -->
-<jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <jsp:include page="/filterLogin.jsp"></jsp:include>
-<jsp:include page="/WEB-INF/teacher/teacherNav.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>
 
 
-<script type="text/javascript">
+    <script type="text/javascript">
-    $("#nav li:nth-child(3) dl dd:nth-child(1)").addClass("layui-this");
+        $("#nav li:nth-child(3) dl dd:nth-child(1)").addClass("layui-this");
-    $("#nav li:nth-child(3)").addClass("layui-nav-itemed");
+        // 使用jQuery选择器来定位页面中特定的元素，具体选择的是id为“nav”的元素下的第三个li元素内的dl元素中的第一个dd元素，然后为其添加“layui-this”样式类。这么做大概率是为了在导航菜单中标记当前选中的菜单项（依据页面本身的导航结构和样式设置逻辑来确定），使其呈现出被选中的视觉效果，例如改变颜色、加粗等样式变化，从而清晰地表明当前所在的功能页面对应的导航位置，方便用户直观地知晓当前所处的功能模块在整个导航体系中的位置关系。
-</script>
+        $("#nav li:nth-child(3)").addClass("layui-nav-itemed");
-<script>
+        // 同样利用jQuery选择器选择id为“nav”的元素下的第三个li元素，并为其添加“layui-nav-itemed”样式类，这通常是用于展开或折叠对应的导航菜单项目，使其显示出该导航项处于展开状态的视觉效果（按照Layui导航组件
-    //JavaScript代码区域
-    layui.use('element', function(){
-        var element = layui.element;
-        element.init();
-    });
-</script>
-
-</body>
-</html>

web/WEB-INF/teacher/tHeader.jsp

@@ -1,55 +1,86 @@
 <%@ 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">
-<div class="layui-layout layui-layout-admin">
+    <!-- 为页面主体设置样式类为“layui-layout-body”，这通常是遵循Layui框架的样式规范，意味着页面主体部分将应用Layui框架相关的布局样式，方便后续按照框架既定的布局方式来组织页面内容，营造出符合框架风格的页面整体效果。 -->
-    <div class="layui-header">
+    <div class="layui-layout layui-layout-admin">
-        <div class="layui-logo" style="font-size: 52px">SIMS</div>
+        <!-- 创建采用Layui框架的布局容器，使用“layui-layout”和“layui-layout-admin”样式类，按Layui框架提供的布局模式规划页面布局，常用于后台管理系统，有着清晰规范的分区结构，便于组织不同功能内容，比如划分出头部、侧边栏、主体内容区、页脚等区域。 -->
-        <!-- 头部区域（可配合layui已有的水平导航） -->
+        <div class="layui-header">
-        <ul class="layui-nav layui-layout-left">
+            <!-- 在Layui布局容器内定义页面的头部区域，该区域一般用于放置页面的标题、导航菜单等重要元素，是用户进入页面首先看到且频繁操作的部分，对于页面的整体导航和功能引导起着关键作用。 -->
-            <li class="layui-nav-item"><a class = "layui-icon layui-icon-home" id="fresh" href="index.jsp"> 主页</a></li>
+            <div class="layui-logo" style="font-size: 52px">SIMS</div>
-            <li class="layui-nav-item "><a class = "layui-icon layui-icon-refresh-3" href="javascript:location.reload();"> 刷新</a></li>
+            <!-- 创建一个带有特定样式（设置字体大小为52px）的div元素，用于展示页面的标识或名称，这里显示的是“SIMS”，通常作为网站或系统的品牌标识展示在头部显眼位置，方便用户识别和区分不同的系统。 -->
-            <li class="layui-nav-item">
+            <!-- 头部区域（可配合layui已有的水平导航） -->
-                <a class="layui-icon layui-icon-link" href="javascript:;"> 其它</a>
+            <ul class="layui-nav layui-layout-left">
-                <dl class="layui-nav-child">
+                <!-- 创建一个使用Layui框架样式的无序列表，作为水平导航菜单的容器，应用“layui-nav”样式类使其呈现出Layui框架定义的导航样式，“layui-layout-left”样式类用于控制导航在页面头部靠左布局，里面放置具体的导航菜单项，方便用户在页面不同功能模块间进行切换操作。 -->
-                    <dd><a href="#">小吐槽</a></dd>
+                <li class="layui-nav-item"><a class = "layui-icon layui-icon-home" id="fresh" href="index.jsp"> 主页</a></li>
-                    <dd><a href="${pageContext.request.contextPath}/notifyListToServlet">学校公告</a></dd>
+                <!-- 创建导航菜单中的一个菜单项，应用“layui-nav-item”样式类使其具备Layui框架中菜单项的基本样式效果，里面包含一个链接元素，链接应用“layui-icon layui-icon-home”样式类展示对应的图标（这里是主页图标），设置ID为“fresh”，链接地址指向“index.jsp”，点击可跳转到主页页面，文本显示为“ 主页”，方便用户返回系统首页。 -->
-                </dl>
+                <li class="layui-nav-item "><a class = "layui-icon layui-icon-refresh-3" href="javascript:location.reload();"> 刷新</a></li>
-            </li>
+                <!-- 同样创建菜单项，图标样式为“layui-icon layui-icon-refresh-3”表示刷新图标，链接地址设置为“javascript:location.reload();”，意味着点击该链接会执行JavaScript代码来刷新当前页面，实现页面内容的重新加载，文本显示为“ 刷新”，方便用户手动刷新页面查看最新数据或状态。 -->
-        </ul>
+                <li class="layui-nav-item">
-        <ul class="layui-nav layui-layout-right">
+                    <a class="layui-icon layui-icon-link" href="javascript:;"> 其它</a>
-            <li class="layui-nav-item">
+                    <!-- 创建菜单项，图标样式为“layui-icon layui-icon-link”，链接地址暂时设置为“javascript:;”，表示点击暂时不会进行页面跳转（可能后续通过JavaScript代码添加点击事件来实现具体的交互逻辑），文本显示为“ 其它”，作为一个可展开的父级菜单，用于包含更多相关的子菜单选项。 -->
-                <a href="javascript:;">
+                    <dl class="layui-nav-child">
-                    <img src="${pageContext.request.contextPath}/showPhotoServlet" class="layui-nav-img">
+                        <!-- 创建一个定义列表（dl）元素，应用“layui-nav-child”样式类，用于放置“其它”菜单项下的子菜单列表，使其呈现出子菜单的样式效果，与父级菜单在视觉上进行区分，且符合Layui框架的导航菜单结构规范。 -->
-                    ${teacher.t_id} ${teacher.t_name}
+                        <dd><a href="#">小吐槽</a></dd>
-                </a>
+                        <!-- 创建一个定义列表项（dd）元素，里面包含一个链接元素，链接暂时指向一个空的地址（“#”），通常表示在当前页面内进行定位（这里可能后续会完善具体的跳转逻辑），文本显示为“小吐槽”，点击可进入对应的小吐槽相关功能页面（具体功能需后续开发完善）。 -->
-                <dl class="layui-nav-child">
+                        <dd><a href="${pageContext.request.contextPath}/notifyListToServlet">学校公告</a></dd>
-                    <dd><a href="#">个人信息</a></dd>
+                        <!-- 创建定义列表项及链接元素，链接通过EL表达式（Expression Language）动态生成，指向“notifyListToServlet”这个Servlet，点击可跳转到对应的Servlet处理逻辑，用于展示学校公告相关信息，文本显示为“学校公告”，方便用户查看学校发布的各类通知公告信息。 -->
-                    <dd><a href="${pageContext.request.contextPath}/logoutServlet">退出</a></dd>
+                    </dl>
-                </dl>
+                </li>
-            </li>
+            </ul>
-            <li class="layui-nav-item"><a class="layui-icon layui-icon-about" href="JavaScript:alertabout()"> 关于</a></li>
+            <ul class="layui-nav layui-layout-right">
-        </ul>
+                <!-- 创建另一个使用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>
-</div>
+    <script>
-<script>
+        //注意：导航 依赖 element 模块，否则无法进行功能性操作
-    //注意：导航 依赖 element 模块，否则无法进行功能性操作
+        layui.use('element', function(){
-    layui.use('element', function(){
+            var element = layui.element;
-        var element = layui.element;
+            element.init();
-        element.init();
+            // 使用Layui框架的模块加载机制，加载“element”模块，获取该模块实例并赋值给变量“element”，然后调用模块的“init”方法进行初始化操作。“element”模块在Layui框架中通常用于页面元素的操作、动态渲染以及交互效果实现等，通过初始化该模块，可以准备好相关的DOM操作环境、绑定必要的事件等，确保模块能正常工作，进而实现页面中基于该模块的各种功能，例如展开收起导航菜单、切换菜单项的选中状态等操作，使得导航菜单具备相应的交互功能。
-    });
+        });
-</script>
+    </script>
-<script type="text/javascript">
+    <script type="text/javascript">
-    function alertabout() {
+        function alertabout() {
-        alert("学生信息管理系统\n陈双全1812123206");
+            alert("学生信息管理系统\n陈双全1812123206");
-    }
+            // 定义一个名为“alertabout”的JavaScript函数，当被调用时，会弹出一个提示框，提示框内显示“学生信息管理系统”以及“陈双全1812123206”这两行文本信息，通常用于向用户展示系统的相关说明信息，比如系统名称、开发者信息等内容。
-</script>
+        }
+    </script>
+
 </body>
 </html>

web/WEB-INF/teacher/tIndex.jsp

@@ -1,17 +1,25 @@
 <%@ 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>
-        .layui-card .layui-card-body .layui-icon {
+       .layui-card.layui-card-body.layui-icon {
             display: inline-block;
             width: 100%;
             height: 60px;
@@ -21,97 +29,125 @@
             font-size: 30px;
             background-color: #F8F8F8;
             color: #333;
-            transition: all .3s;
+            transition: all.3s;
-            -webkit-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 {
+       .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">
-<%--<jsp:include page="/filterLogin.jsp"></jsp:include>--%>
+    <!-- 为页面主体设置样式类为“layui-layout-body”，同时通过内联样式设定背景颜色为“#F2F2F2”，按照Layui框架的样式规范定义主体部分外观风格，营造出一种浅灰色（#F2F2F2）的视觉背景，符合项目统一的页面设计要求，便于后续布局页面内容，并且使页面整体视觉效果保持一致。 -->
-<jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <%--<jsp:include page="/filterLogin.jsp"></jsp:include>--%>
-<jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 此处原本是通过JSP的“include”指令包含名为“filterLogin.jsp”的页面，一般这个页面用于处理用户登录验证逻辑，判断用户是否已登录，未登录时引导用户跳转到登录页面，不过这里被注释掉了，可能暂时不需要该登录验证功能或者后续会根据实际情况再启用它。 -->
-<div class="layui-layout layui-layout-admin">
+    <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
-    <div class="layui-body">
+    <!-- 通过JSP的“include”指令包含名为“WEB-INF/teacher/tHeader.jsp”的页面，通常该页面用于定义教师端页面的头部区域，包含如页面标题、导航栏、用户信息展示等元素，构建出页面头部的布局结构，使页面头部呈现规范的样式和功能。 -->
-        <!-- 内容主体区域 -->
+    <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
-        <div style="padding: 15px;">
+    <!-- 包含名为“WEB-INF/teacher/teacherNav.jsp”的页面，大概率用于展示教师端的导航菜单，方便教师在不同功能模块（如课程管理、学生管理、个人信息管理等）间切换操作，实现页面功能的导航跳转，提高操作便利性。 -->
-            <div class="layui-card">
+    <div class="layui-layout layui-layout-admin">
-                <div class="layui-card-header" id="index-function">功能</div>
+        <!-- 创建采用Layui框架的布局容器，使用“layui-layout”和“layui-layout-admin”样式类，按Layui框架提供的布局模式规划页面布局，常用于后台管理系统，有着清晰规范的分区结构，便于组织不同功能内容，比如划分出侧边栏、主体内容区、页脚等区域，使页面布局更加合理有序，符合后台管理系统的使用习惯和功能展示需求。 -->
-                <div class="layui-card-body">
+        <div class="layui-body">
-                    <ul class="layui-row layui-col-space10 layui-this">
+            <!-- 在Layui布局容器内定义页面主体内容区域，该区域依Layui框架布局规则自适应显示，用于承载具体业务相关内容，像下面展示的功能列表、学校公告等信息，是用户在访问页面时重点关注和进行操作的核心区域。 -->
-                        <li class="layui-col-xs3">
+            <!-- 内容主体区域 -->
-                            <a lay-href="/mavenTemplate/student/query">
+            <div style="padding: 15px;">
-                                <i class="layui-icon layui-icon-survey"></i>
+                <!-- 创建带有内边距（上下左右均为15px）的div容器，通过设置内边距让内部内容在页面中有空白间隔，使布局更美观易读，便于对内部元素排版布局，避免内容显得拥挤，提升用户查看和操作页面内容时的体验感。 -->
-                                <cite>学生信息查询</cite>
+                <div class="layui-card">
-                            </a>
+                    <!-- 创建一个使用Layui框架样式的卡片元素，通常用于对相关内容进行分组展示，使其在页面上有一个清晰的视觉边界，方便用户区分不同的功能模块或者信息板块，符合Layui框架的页面布局和展示风格。 -->
-                        </li>
+                    <div class="layui-card-header" id="index-function">功能</div>
-                        <li class="layui-col-xs3">
+                    <!-- 创建卡片的头部区域元素，设置ID为“index-function”，文本内容显示为“功能”，用于给卡片添加一个标题，提示下面卡片主体内容所涉及的大致范畴，让用户一目了然知道该部分的主要作用。 -->
-                            <a lay-href="/mavenTemplate/teacher/query">
+                    <div class="layui-card-body">
-                                <i class="layui-icon layui-icon-survey"></i>
+                        <!-- 创建卡片的主体内容区域元素，用于放置具体的功能相关内容，在这里会展示一系列功能链接等元素，是卡片中实际展示核心信息的部分。 -->
-                                <cite>教师信息查询</cite>
+                        <ul class="layui-row layui-col-space10 layui-this">
-                            </a>
+                            <!-- 创建一个使用Layui框架样式的无序列表，应用“layui-row”样式类使其具备行布局的特点，“layui-col-space10”样式类用于设置列表项之间的水平间距为10像素，“layui-this”样式类可能是用于标记当前选中或特殊样式的状态（具体取决于Layui框架的样式定义），整体用于放置多个功能相关的列表项元素，方便以列表形式展示各项功能入口，并且实现一定的布局和样式效果。 -->
-                        </li>
+                            <li class="layui-col-xs3">
-                        <li class="layui-col-xs3">
+                                <!-- 创建列表项元素，应用“layui-col-xs3”样式类，意味着该元素在小屏幕设备（如手机等）上会占据3列的宽度（基于Layui框架的栅格系统布局规则），方便实现响应式布局，根据不同设备屏幕大小合理分配空间，展示功能链接等内容。 -->
-                            <a lay-href="/mavenTemplate/class/query">
+                                <a lay-href="/mavenTemplate/student/query">
-                                <i class="layui-icon layui-icon-survey"></i>
+                                    <!-- 创建一个链接元素，使用了Layui框架自定义的“lay-href”属性（可能是用于实现特定的链接跳转逻辑或者与Layui框架的交互功能相关），链接地址指向“/mavenTemplate/student/query”，点击可跳转到对应的学生信息查询功能页面，用于引导用户进入相关功能操作界面。 -->
-                                <cite>班级信息查询</cite>
+                                    <i class="layui-icon layui-icon-survey"></i>
-                            </a>
+                                    <!-- 创建一个图标元素，应用“layui-icon”样式类以及具体的图标样式“layui-icon-survey”，用于展示特定的图标（这里可能是表示查询相关的图标），增强功能链接的可视化效果，让用户更直观地识别功能。 -->
-                        </li>
+                                    <cite>学生信息查询</cite>
-                        <li class="layui-col-xs3">
+                                    <!-- 创建一个引用（cite）元素，用于显示具体的功能名称文本“学生信息查询”，明确告知用户该链接对应的功能是什么，方便用户进行操作选择。 -->
-                            <a lay-href="/mavenTemplate/major/query">
+                                </a>
-                                <i class="layui-icon layui-icon-survey"></i>
+                            </li>
-                                <cite>专业&amp;学院信息查询</cite>
+                            <li class="layui-col-xs3">
-                            </a>
+                                <a lay-href="/mavenTemplate/teacher/query">
-                        </li>
+                                    <i class="layui-icon layui-icon-survey"></i>
-                        <li class="layui-col-xs3">
+                                    <cite>教师信息查询</cite>
-                            <a lay-href="/mavenTemplate/user/info">
+                                </a>
-                                <i class="layui-icon layui-icon-user"></i>
+                                <!-- 与上述“学生信息查询”功能项类似，创建教师信息查询的功能链接元素，包含对应的图标展示和功能名称文本显示，链接地址指向“/mavenTemplate/teacher/query”，点击可进入教师信息查询相关页面，方便教师查询教师相关信息。 -->
-                                <cite>个人资料</cite>
+                            </li>
-                            </a>
+                            <li class="layui-col-xs3">
-                        </li>
+                                <a lay-href="/mavenTemplate/class/query">
-                        <li class="layui-col-xs3">
+                                    <i class="layui-icon layui-icon-survey"></i>
-                            <a lay-href="/mavenTemplate/user/password">
+                                    <cite>班级信息查询</cite>
-                                <i class="layui-icon layui-icon-set"></i>
+                                </a>
-                                <cite>修改密码</cite>
+                                <!-- 同样的结构，创建班级信息查询的功能链接元素，展示对应图标，显示功能名称“班级信息查询”，链接指向“/mavenTemplate/class/query”，用于引导用户进入班级信息查询功能页面，获取班级相关信息。 -->
-                            </a>
+                            </li>
-                        </li>
+                            <li class="layui-col-xs3">
-                        <li class="layui-col-xs3">
+                                <a lay-href="/mavenTemplate/major/query">
-                            <a lay-href="/mavenTemplate/user/email">
+                                    <i class="layui-icon layui-icon-survey"></i>
-                                <i class="layui-icon layui-icon-set"></i>
+                                    <cite>专业&amp;学院信息查询</cite>
-                                <cite>修改邮箱</cite>
+                                </a>
-                            </a>
+                                <!-- 创建专业和学院信息查询的功能链接元素，展示图标并显示功能名称“专业&amp;学院信息查询”（这里“&amp;”是HTML中表示“&”符号的实体编码，用于正确显示“专业&学院信息查询”这样的文本内容），链接地址指向“/mavenTemplate/major/query”，方便用户查询专业和学院相关信息。 -->
-                        </li>
+                            </li>
-                        <li class="layui-col-xs3">
+                            <li class="layui-col-xs3">
-                            <a lay-href="/mavenTemplate/student/modify">
+                                <a lay-href="/mavenTemplate/user/info">
-                                <i class="layui-icon layui-icon-survey"></i>
+                                    <i class="layui-icon layui-icon-user"></i>
-                                <cite>学生信息修改</cite>
+                                    <cite>个人资料</cite>
-                            </a>
+                                </a>
-                        </li>
+                                <!-- 创建个人资料查看或编辑相关的功能链接元素，图标样式为“layui-icon-user”表示用户相关图标，显示功能名称“个人资料”，链接指向“/mavenTemplate/user/info”，点击可进入个人资料管理相关页面，方便用户查看和修改自己的个人信息。 -->
-                    </ul>
+                            </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 class="layui-card">
-                <div class="layui-card-header">学校最新公告</div>
-                <c:forEach items="${notifys}" var="notify">
-                    <div class="layui-card-body" id="notify">${notify.notifyInfo}<p>${notify.notifyDate}</div>
-                </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,126 +1,123 @@
 <%@ 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">
-<jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 为页面主体设置样式类为“layui-layout-body”，同时通过内联样式设定背景颜色为“#F2F2F2”，这是按照Layui框架的样式规范来对页面主体部分的外观风格进行定义，使得页面呈现出特定的背景颜色，有助于营造出整体统一的视觉效果，并且方便后续依据Layui框架既定的布局和样式规则来组织和展示页面中的其他各种内容元素。 -->
-<jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <jsp:include page="/filterLogin.jsp"></jsp:include>
-<jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 使用JSP的“include”指令将名为“filterLogin.jsp”的页面包含进来，通常情况下，这个“filterLogin.jsp”页面主要负责处理用户登录验证相关的逻辑，比如它会判断当前访问该页面的用户是否已经成功登录到系统中，如果发现用户没有登录，那么就会引导用户跳转到登录页面进行登录操作，以此来实现对页面访问权限的有效管控，确保只有合法登录的用户才能够访问当前页面以及后续与之相关的各种功能内容，从而保障整个系统的数据安全以及业务逻辑的正常运行。 -->
-<div class="layui-layout layui-layout-admin">
+    <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
-    <div class="layui-body">
+    <!-- 包含名为“WEB-INF/teacher/tHeader.jsp”的页面，一般来讲，这个页面主要是用于定义教师端页面的头部区域的，在这个头部区域当中，通常会包含诸如页面的大标题、用于页面导航的导航栏、展示教师用户基本信息（例如用户名、头像等内容）等与头部相关的各种元素，通过这样的包含操作，就可以把这些头部相关的元素整合到当前页面之中，进而构建出一个完整且规范的页面头部布局结构。 -->
-        <!-- 内容主体区域 -->
+    <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
-        <div style="padding: 15px;">
+    <!-- 包含名为“WEB-INF/teacher/teacherNav.jsp”的页面，大概率它的作用是用于展示教师端的导航菜单的，借助这个导航菜单，教师用户就可以方便快捷地在不同的功能模块（例如课程管理、学生管理、个人信息管理等不同的功能板块，具体的功能模块划分要取决于业务系统的整体设计需求）之间进行切换操作，实现页面功能的导航跳转，为用户提供便捷的操作入口，从而提升用户使用整个系统的便利性。 -->
-            <span class="layui-breadcrumb">
+    <div class="layui-layout layui-layout-admin">
-                <a href="">教师端</a>
+        <!-- 创建一个基于Layui框架的布局容器，通过应用“layui-layout”和“layui-layout-admin”这两个样式类，按照Layui框架所提供的特定布局模式对页面进行布局规划，这种布局方式在后台管理系统等应用场景中是比较常用的，它有着清晰、规范的页面分区结构，能够便于合理地放置和展示页面内的各种功能内容模块，例如可以很方便地划分出侧边栏、主体内容展示区、页面底部的页脚等不同的区域。 -->
-                <a href="">个人信息管理</a>
+        <div class="layui-body">
-                <a><cite>个人信息</cite></a>
+            <!-- 在上述所创建的Layui布局容器内定义页面的主体内容区域，这个区域会依据Layui框架既定的布局规则来进行自适应显示，它主要的作用是用于承载和展示与具体业务相关的核心内容，比如下面即将呈现出来的关于教师“个人信息”相关信息的表单等内容元素，这里也就是用户在访问该页面时重点关注和进行操作的区域。 -->
-            </span>
+            <!-- 内容主体区域 -->
-            <form class="layui-form" action="" style="padding-top: 50px" method="post">
+            <div style="padding: 15px;">
-                <div class="layui-form-item">
+                <!-- 创建一个带有内边距的div容器，通过设置“padding: 15px;”这样的内边距样式，意味着在这个容器的四周（也就是上、下、左、右四个方向）都会留出15像素的空白空间，这样做的好处是可以让容器内部的内容在页面中展示的时候有一定的间隔，使得页面的布局更加美观、易读，也更便于对内部的各个元素进行排版布局操作，避免内容显得过于拥挤，从而提升用户查看和操作页面内容时的体验感。 -->
-                    <label class="layui-form-label">工号</label>
+                <span class="layui-breadcrumb">
-                    <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">
+                    <a href="">教师端</a>
-                    </div>
+                    <!-- 面包屑中的第一个链接，通常情况下它是指向教师端的首页或者是整个教师端功能的主要入口页面的，不过在这里暂时没有设置具体的链接地址（可能后续会根据实际情况进一步去完善它），从理论上来说，用户点击该链接是可以引导其返回教师端的核心界面的，也就是回到一个相对比较顶层的功能页面位置上。 -->
-                </div>
+                    <a href="">个人信息管理</a>
-                <div class="layui-form-item">
+                    <!-- 面包屑中的第二个链接，它所指向的是与个人信息管理相关的页面，这个页面可能是个人信息管理的总览页面或者是对个人信息进行分类展示的列表页面等相关页面，同样在这里暂时也没有设定具体的链接地址，一般情况下用户点击该链接就可以进入到对应的个人信息管理相关的界面中，进而去查看更详细的个人信息相关内容。 -->
-                    <label class="layui-form-label">学院</label>
+                    <a><cite>个人信息</cite></a>
-                    <div class="layui-input-block">
+                    <!-- 面包屑中的最后一个元素，明确地显示出当前页面的具体功能是“个人信息”，它主要起到一个标识当前所在功能位置的作用，通常情况下这个元素是不可点击的，仅仅是作为文字提示信息展示给用户，告知用户当前所处的具体业务功能页面是什么。 -->
-                        <select name="selectCollege" readonly="readonly">
+                </span>
-                            <option selected></option>
+                <form class="layui-form" action="" style="padding-top: 50px" method="post">
-                        </select>
+                    <!-- 创建一个使用Layui框架样式的表单，应用“layui-form”样式类使其呈现出符合Layui框架规范的表单样式，方便进行表单元素的布局以及后续的表单验证等操作。设置顶部内边距为50px，使表单与上面的面包屑等元素有一定的垂直间隔，更加美观易读。提交方法为“post”，常用于提交较大量或需保密的数据（不过这里“action”属性为空，可能后续会根据实际需求动态设置表单提交的目标地址）。 -->
-                    </div>
+                    <div class="layui-form-item">
-                </div>
+                        <!-- 在表单内创建Layui框架的表单项目容器，用于对单个输入项或一组相关输入项进行分组和布局，方便统一管理和设置样式，使每个输入项在页面中规范显示。 -->
-                <div class="layui-form-item">
+                        <label class="layui-form-label">工号</label>
-                    <label class="layui-form-label">系别</label>
+                        <!-- 创建表单标签，用于显示输入项对应的提示文本，这里提示用户输入的是“工号”信息，引导用户明确该输入框的用途。 -->
-                    <div class="layui-input-block">
+                        <div class="layui-input-block">
-                        <select name="selectDepartment" readonly="readonly">
+                            <!-- 创建用于放置输入框等表单控件的块级容器，按照Layui框架的布局规则，输入框等元素会在这个容器内合理显示，确保页面布局整齐，与其他表单项目区分开来。 -->
-                            <option selected></option>
+                            <input type="text" readonly="readonly" name="teacher-id" value="${teacher.t_id}" required lay-verify="required" autocomplete="off" class="layui-input">
-                        </select>
+                            <!-- 创建一个文本输入框，设置为只读（“readonly="readonly"”），意味着用户不能直接修改该输入框中的内容，其名称为“teacher-id”，通过EL表达式（Expression Language）将“teacher.t_id”（可能是从服务器端传递过来的教师工号值）作为初始值显示在输入框中，设置为必填项（“required lay-verify="required"”，Layui框架中用于表单验证，确保用户提交表单时该字段有值），关闭自动完成功能（“autocomplete="off"”），应用Layui框架输入框样式类“layui-input”，用于展示教师的工号信息。 -->
-                    </div>
+                        </div>
-                </div>
-                <div class="layui-form-item">
-                    <label class="layui-form-label">班级</label>
-                    <div class="layui-input-block">
-                        <select name="selectClass" readonly="readonly">
-                            <option selected></option>
-                        </select>
                     </div>
-                </div>
+                    <div class="layui-form-item">
-                <div class="layui-form-item">
+                        <label class="layui-form-label">学院</label>
-                    <label class="layui-form-label">姓名</label>
+                        <div class="layui-input-block">
-                    <div class="layui-input-block">
+                            <select name="selectCollege" readonly="readonly">
-                        <input type="text" name="student-name" id="student-name" value="${teacher.t_name}" placeholder="" autocomplete="off" class="layui-input">
+                                <!-- 创建一个下拉选择框，名称为“selectCollege”，设置为只读，意味着用户不能在页面上直接修改其选项，不过这里暂时只有一个默认选中的空选项（“<option selected></option>”），可能后续会通过JavaScript等方式动态填充学院相关的选项数据（比如从服务器端获取学院列表后添加到下拉框中），用于让用户选择教师所属的学院信息。 -->
+                                <option selected></option>
+                            </select>
+                        </div>
                     </div>
-                </div>
+                    <div class="layui-form-item">
-                <div class="layui-form-item">
+                        <label class="layui-form-label">系别</label>
-
-                </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="男">
+                            <select name="selectDepartment" readonly="readonly">
-                            <input type="radio" name="student-sex" id="idsex2" value="女" title="女">
+                                <option selected></option>
+                                <!-- 与学院的下拉选择框类似，创建用于选择教师所属系别的下拉选择框，名称为“selectDepartment”，设置为只读，同样暂时只有一个默认选中的空选项，后续可能动态添加系别相关选项数据，方便用户选择对应的系别信息。 -->
+                            </select>
                         </div>
                     </div>
-                    <div class="layui-inline">
+                    <div class="layui-form-item">
-                        <label class="layui-form-label">文化程度</label>
+                        <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">
+                            <select name="selectClass" readonly="readonly">
+                                <option selected></option>
+                                <!-- 创建用于选择教师所在班级的下拉选择框，名称为“selectClass”，设置为只读，当前也只有默认选中的空选项，预计后续会动态填充班级相关选项，以供用户进行相应的选择操作。 -->
+                            </select>
                         </div>
                     </div>
-                    <div class="layui-inline">
+                    <div class="layui-form-item">
-                        <label class="layui-form-label">职称</label>
+                        <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">
+                            <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>
+                    <div class="layui-form-item">
-            </form>
+                        <!-- 这里是一个空的表单项目容器，可能原本计划放置一些表单元素但暂时未添加，或者用于在页面布局上起到一定的间隔作用等，具体用途可能需要根据后续开发需求来确定。 -->
-            <jsp:include page="/footer.jsp"></jsp:include>
+                    </div>
-        </div>
+                    <div class="layui-form-item">
-    </div>
+                        <div class="layui-inline">
-</div>
+                            <!-- 创建行内块级元素容器，用于让内部元素在行内排列，方便在一行内放置多个表单输入项或相关元素，实现紧凑的布局效果，这里主要用于放置性别相关的输入项。 -->
-
+                            <label class="layui-form-label">性别</label>
-
+                            <div class="layui-input-block">
-<script type="text/javascript">
+                                <input type="radio" name="student-sex" id="idsex" value="男" title="男">
-    $("#nav li:nth-child(5) dl dd:nth-child(1)").addClass("layui-this");
+                                <input type="radio" name="student-sex" id="idsex2" value="女" title="女">
-    $("#nav li:nth-child(5)").addClass("layui-nav-itemed");
+                                <!-- 创建两个单选按钮，它们的名称都为“student-sex”，意味着同一时刻只能选择其中一个选项，第一个单选按钮的ID为“idsex”，值为“男”，显示的文本标题为“男”，第二个单选按钮ID为“idsex2”，值为“女”，标题为“女”，用于让用户选择教师的性别信息，后续可以通过JavaScript等方式获取用户选择的性别值进行相应的处理。 -->
-</script>
+                            </div>
-<script>
+                        </div>
-    //JavaScript代码区域
+                        <div class="layui-inline">
-    layui.use('element', function(){
+                            <label class="layui-form-label">文化程度</label>
-        var element = layui.element;
+                            <div class="layui-input-block">
-        element.init();
+                                <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”（可能是从服务器端传递过来的教师文化程度值）作为初始值显示在输入框中，无占位符文本，关闭自动完成功能，用于展示教师的文化程度信息，用户也可在此修改该信息。 -->
-</script>
+                            </div>
-
+                        </div>
-<script>
+                        <div class="layui-inline">
-    //Demo
+                            <label class="layui-form-label">职称</label>
-    layui.use('form', function(){
+                            <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”（可能是从服务器端传递过来的教师职称值）作为初始值显示在输入框中，无占位符文本，关闭自动完成功能，用于展示教师的职称信息，并且用户可进行相应的修改操作。 -->
-</script>
+                            </div>
-<script>
+                        </div>
-    var sex = "${teacher.t_sex}";
+                    </div>
-    if (sex == '男') {
+                </form>
-        $("#idsex").attr("checked","checked");
+                <jsp:include page="/footer.jsp"></jsp:include>
-        $("#idsex2").removeAttr("checked");
+                <!-- 包含名为“footer.jsp”的页面，通常这个页面主要是用于定义页面的底部区域的，在这个页面里可能会包含诸如版权信息、联系方式、页面底部导航等相关内容，通过这样的包含操作，可以完善整个页面的布局结构，使其更加完整、规范，给用户呈现出一个完整的页面视觉效果，同时也方便在底部展示一些通用的重要信息或者提供额外的操作入口等。 -->
-    } else if (sex == '女') {
+            </div>
-        $("#idsex2").attr("checked","checked");
-        $("#idsex").removeAttr("checked");
-    }else{
-        $("#idsex").removeAttr("checked");
-        $("#idsex2").removeAttr("checked");
-    }
-</script>
-
-</body>
-</html>
-

web/WEB-INF/teacher/teacherNav.jsp

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

web/WEB-INF/teacher/teacherOptionalCourse.jsp

@@ -1,70 +1,102 @@
 <%@ 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">
-<jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 为页面主体设置样式类为“layui-layout-body”，同时通过内联样式设置背景颜色为“#F2F2F2”。这样的设置是遵循Layui框架的样式规范，来定义页面主体部分的外观风格，让页面呈现出特定的背景颜色，有助于营造整体统一的视觉效果，并且方便后续按照Layui框架既定的布局和样式规则来组织页面中的其他内容元素。 -->
-<jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <jsp:include page="/filterLogin.jsp"></jsp:include>
-<jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 使用JSP的“include”指令将名为“filterLogin.jsp”的页面包含进来。通常，这个“filterLogin.jsp”页面会负责处理用户登录验证相关的逻辑，例如判断当前用户是否已经成功登录系统，如果用户没有登录，那么可能会引导用户跳转到登录页面进行登录操作，以此来实现对页面访问权限的有效管控，确保只有合法登录的用户才能访问该页面以及后续相关的功能内容，保障系统的数据安全和业务逻辑的正常运行。 -->
-<div class="layui-layout layui-layout-admin">
+    <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
-    <div class="layui-body">
+    <!-- 包含名为“WEB-INF/teacher/tHeader.jsp”的页面，一般情况下，这个页面主要用于定义教师端页面的头部区域。在这个头部区域中，可能会包含诸如页面的大标题、导航栏、教师用户的基本信息展示（如用户名、头像等）等头部相关的元素，通过这样的包含操作，就可以将这些头部元素整合到当前页面中，构建出完整且规范的页面头部布局结构。 -->
-        <!-- 内容主体区域 -->
+    <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
-        <div style="padding: 15px;">
+    <!-- 包含名为“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">
+                <table class="layui-table" lay-filter="test">
-                <thead>
+                    <!-- 创建一个使用Layui框架样式的表格，应用“layui-table”样式类使其外观符合Layui框架所定义的表格风格，整体看起来更加美观、专业且符合整个系统的界面风格一致性要求。同时通过“lay-filter”属性设置一个过滤器名称为“test”，这个过滤器后续可以在JavaScript代码中用于绑定表格相关的各种事件（例如行点击事件、排序事件、单元格编辑事件等），方便实现对表格的交互操作以及数据处理等功能，增强表格的实用性和用户交互性。 -->
-                <tr>
+                    <thead>
-                    <th>ID</th>
+                    <!-- 定义表格的表头部分，用于清晰地展示各列所代表的标题信息，让用户在查看表格数据时，一眼就能明白每一列数据的含义和所代表的内容属性，起到数据列说明的作用，便于用户快速理解和查看表格中的具体数据内容。 -->
-                    <th>课程号</th>
-                    <th>课程名</th>
-                    <th>课程简介</th>
-                    <th>操作</th>
-                </tr>
-                </thead>
-
-                <c:forEach items="${optionalcourses}" var="optionalcourse" varStatus="t">
                     <tr>
-                        <td>${t.count}</td>
+                        <!-- 创建表格中的一行，该行用于放置表头单元格（th元素），每个th元素对应表格中的一列标题，按照顺序依次排列，形成完整的表头行结构。 -->
-                        <td>${optionalcourse.c_id}</td>
+                        <th>ID</th>
-                        <td>${optionalcourse.c_name}</td>
+                        <!-- 表头单元格，标题为“ID”，此处的“ID”具体含义可能是每条授课记录在系统中的唯一标识编号，或者是按照一定规则生成的序号等，具体要根据业务系统的设计需求来确定，其所在列后续会展示相应的标识信息，方便对不同的授课记录进行区分和索引。 -->
-                        <td>${optionalcourse.c_info}</td>
+                        <th>课程号</th>
-                        <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>
+                        <!-- 表头单元格，显示“课程号”这一标题，对应列将展示具体的课程编号信息，通过课程号可以唯一确定一门课程，方便教师在众多课程中准确识别每一门自己授课的课程，也便于与系统中的其他课程相关功能（如查询、修改等操作）进行关联和交互。 -->
+                        <th>课程名</th>
+                        <!-- 表头单元格，标题为“课程名”，所在列会呈现相应的课程名称等课程相关信息，便于教师直观地了解自己所教授课程的具体名称，更清晰地知晓每一行数据对应的是哪一门课程。 -->
+                        <th>课程简介</th>
+                        <!-- 表头单元格，显示“课程简介”标题，其对应的表格列用于展示具体的课程详细介绍信息，例如课程的教学目标、主要内容、适用对象等相关简介内容，有助于教师进一步了解课程的大致情况，辅助教学相关的决策和操作。 -->
+                        <th>操作</th>
+                        <!-- 表头单元格，标题为“操作”，该列用于放置针对每一行授课记录数据可进行的操作按钮等元素，比如修改、查看、删除等操作按钮，方便教师根据实际需求对相应的授课信息进行各种操作管理，提供便捷的交互功能入口。 -->
                     </tr>
-                </c:forEach>
+                    </thead>
-            </table>
+
-            <jsp:include page="/footer.jsp"></jsp:include>
+                    <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>
-</div>
 
 
-<script type="text/javascript">
+    <script type="text/javascript">
-    $("#nav li:nth-child(1) dl dd:nth-child(1)").addClass("layui-this");
+        $("#nav li:nth-child(1) dl dd:nth-child(1)").addClass("layui-this");
-    $("#nav li:nth-child(1)").addClass("layui-nav-itemed");
+        // 使用jQuery选择器来定位页面中特定的元素，具体选择的是id为“nav”的元素下的第一个li元素内的dl元素中的第一个dd元素，然后为其添加“layui-this”样式类。这么做大概率是为了在导航菜单中标记当前选中的菜单项（依据页面本身的导航结构和样式设置逻辑来确定），使其呈现出被选中的视觉效果，例如改变颜色、加粗等样式变化，从而清晰地表明当前所在的功能页面对应的导航位置，方便用户直观地知晓当前所处的功能模块在整个导航体系中的位置关系。
-</script>
+        $("#nav li:nth-child(1)").addClass("layui-nav-itemed");
-<script>
+        // 同样利用jQuery选择器选择id为“nav”的元素下的第一个li元素，并为其添加“layui-nav-itemed”样式类，这通常是用于展开或折叠对应的导航菜单
-    //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>

web/WEB-INF/teacher/teacherUpdatePassword.jsp

@@ -1,86 +1,123 @@
 <%@ 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">
-<jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 为页面主体设置样式类为“layui-layout-body”，并通过内联样式指定背景颜色为“#F2F2F2”，按照Layui框架的样式规范定义主体部分外观风格，营造特定视觉背景，通常符合项目统一的页面设计要求，便于后续布局内容。 -->
-<jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <jsp:include page="/filterLogin.jsp"></jsp:include>
-<jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 通过JSP的“include”指令包含名为“filterLogin.jsp”的页面，该页面一般用于处理用户登录验证逻辑，判断用户是否已登录，未登录时会引导用户跳转到登录页面，以此控制页面访问权限，保障系统安全和数据合法性。 -->
-<div class="layui-layout layui-layout-admin">
+    <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
-    <div class="layui-body">
+    <!-- 包含“WEB-INF/teacher/tHeader.jsp”页面，通常此页面用于定义教师端页面的头部区域，包含如页面标题、导航栏、用户信息展示等元素，构建出页面头部的布局结构，使页面头部呈现出规范的样式和功能。 -->
-        <!-- 内容主体区域 -->
+    <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
-        <div style="padding: 15px;">
+    <!-- 包含“WEB-INF/teacher/teacherNav.jsp”页面，大概率用于展示教师端的导航菜单，方便教师在不同功能模块（如课程管理、学生管理、个人信息管理等）间切换操作，实现页面功能的导航跳转，提高操作便利性。 -->
-            <span class="layui-breadcrumb">
+    <div class="layui-layout layui-layout-admin">
-                <a href="">教师端</a>
+        <!-- 创建采用Layui框架的布局容器，使用“layui-layout”和“layui-layout-admin”样式类，按Layui框架提供的布局模式规划页面布局，常用于后台管理系统，有着清晰规范的分区结构，便于组织不同功能内容。 -->
-                <a href="">个人信息管理</a>
+        <div class="layui-body">
-                <a><cite>修改密码</cite></a>
+            <!-- 在Layui布局容器内定义页面主体内容区域，该区域依Layui框架布局规则自适应显示，用于承载具体业务相关内容，像下面的修改密码表单等信息。 -->
-            </span>
+            <!-- 内容主体区域 -->
-            <form class="layui-form" action="${pageContext.request.contextPath}/teacherPasswordUpdateServlet" style="padding-top: 50px" method="post">
+            <div style="padding: 15px;">
-                <div class="layui-form-item">
+                <!-- 创建带有内边距（上下左右均为15px）的div容器，通过设置内边距让内部内容在页面中有空白间隔，使布局更美观易读，便于对内部元素排版布局，避免内容显得拥挤。 -->
-                    <label class="layui-form-label">工号</label>
+                <span class="layui-breadcrumb">
-                    <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">
+                    <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>
+                    <div class="layui-form-item">
-                <div class="layui-form-item">
+                        <label class="layui-form-label">当前密码</label>
-                    <label class="layui-form-label">当前密码</label>
+                        <div class="layui-input-block">
-                    <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">
-                        <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>
+                    <div class="layui-form-item">
-                <div class="layui-form-item">
+                        <label class="layui-form-label">新密码</label>
-                    <label class="layui-form-label">新密码</label>
+                        <div class="layui-input-block">
-                    <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">
-                        <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>
-                </div>
 
 
-                <div class="layui-form-item layui-form-text">
+                    <div class="layui-form-item layui-form-text">
-                    <label class="layui-form-label">确认密码</label>
+                        <label class="layui-form-label">确认密码</label>
-                    <div class="layui-input-block">
+                        <div class="layui-input-block">
-                        <input type="password" name="teacher-ennewpassword" id="teacher-ennewpassword" value=""  lay-verify="required" placeholder="" autocomplete="off" class="layui-input">
+                            <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>
 
-                <div class="layui-form-item">
+                    <div class="layui-form-item">
-                    <div class="layui-input-block">
+                        <div class="layui-input-block">
-                        <button class="layui-btn" lay-submit lay-filter="formDemo">修改</button>
+                            <button class="layui-btn" lay-submit lay-filter="formDemo">修改</button>
-                        <span style="padding-left: 20px;">${update_msg}</span>
+                            <!-- 创建使用Layui框架样式的按钮，文本显示为“修改”，通过“lay-submit”属性声明该按钮用于提交表单，“lay-filter=formDemo”可用于设置表单提交的验证规则或事件监听等相关的过滤器名称（需在后续JavaScript代码中定义具体逻辑），点击按钮触发表单提交操作，将用户输入的密码相关信息发往指定Servlet处理。 -->
+                            <span style="padding-left: 20px;">${update_msg}</span>
+                            <!-- 通过EL表达式显示名为“update_msg”的变量内容，该变量可能是在服务器端（如对应的Servlet）设置的提示信息，用于向用户反馈操作结果（如修改密码成功或失败的提示等），并设置左边20px内边距与按钮隔开显示。 -->
+                        </div>
                     </div>
-                </div>
+                </form>
-            </form>
+                <jsp:include page="/footer.jsp"></jsp:include>
-            <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含名为“footer.jsp”的页面，通常用于定义页面底部区域，可包含版权信息、联系方式、页面底部导航等内容，完善页面整体布局结构，使其更完整规范，呈现出完整的页面视觉效果。 -->
+            </div>
         </div>
     </div>
-</div>
 
 
-<script type="text/javascript">
+    <script type="text/javascript">
-    $("#nav li:nth-child(5) dl dd:nth-child(2)").addClass("layui-this");
+        $("#nav li:nth-child(5) dl dd:nth-child(2)").addClass("layui-this");
-    $("#nav li:nth-child(5)").addClass("layui-nav-itemed");
+        // 使用jQuery选择器选择页面中id为“nav”的元素下的第五个li元素内的dl元素中的第二个dd元素，并为其添加“layui-this”样式类，大概率用于在导航菜单中标记当前选中的菜单项（依据页面导航结构和样式设置逻辑），使其呈现选中的视觉效果（如变色、加粗等），表明当前所在功能页面对应的导航位置。
-</script>
+        $("#nav li:nth-child(5)").addClass("layui-nav-itemed");
-<script>
+        // 同样用jQuery选择器选择id为“nav”的元素下的第五个li元素，并为其添加“layui-nav-itemed”样式类，通常用于展开或折叠对应的导航菜单项目，使其显示出展开状态的视觉效果（按Layui导航组件样式规则），方便展示相关子菜单或突出当前所在主菜单部分。
-    //JavaScript代码区域
+    </script>
-    layui.use('element', function(){
+    <script>
-        var element = layui.element;
+        //JavaScript代码区域
-        element.init();
+        layui.use('element', function(){
-    });
+            var element = layui.element;
-</script>
+            element.init();
+            // 使用Layui框架的模块加载机制，加载“element”模块，获取实例赋值给“element”变量，然后调用“init”方法初始化，“element”模块用于页面元素操作、动态渲染及交互效果实现等，初始化准备DOM操作环境、绑定事件等，确保模块正常工作，实现相关功能。
+        });
+    </script>
 
-<script>
+    <script>
-    //Demo
+        //Demo
-    layui.use('form', function(){
+        layui.use('form', function(){
+            // 使用Layui框架的模块加载机制，加载“form”模块，后续可在回调函数内编写使用该模块相关功能的代码，比如进行表单验证、提交前数据处理等操作，不过这里暂时没添加具体业务逻辑代码（可能后续完善）。
 
-    });
+        });
-</script>
+    </script>
 
 </body>
 </html>
-

web/WEB-INF/teacher/updateOptionalCourseScore.jsp

@@ -1,95 +1,114 @@
 <%@ 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">
-<jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 为页面主体设置样式类为“layui-layout-body”，同时通过内联样式设定背景颜色为“#F2F2F2”，这是按照Layui框架的样式规范来对页面主体部分的外观风格进行定义，使得页面呈现出特定的背景颜色，有助于营造出整体统一的视觉效果，并且方便后续依据Layui框架既定的布局和样式规则来组织和展示页面中的其他各种内容元素。 -->
-<jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <jsp:include page="/filterLogin.jsp"></jsp:include>
-<jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 使用JSP的“include”指令将名为“filterLogin.jsp”的页面包含进来，通常情况下，这个“filterLogin.jsp”页面主要负责处理用户登录验证相关的逻辑，比如它会判断当前访问该页面的用户是否已经成功登录到系统中，如果发现用户没有登录，那么就会引导用户跳转到登录页面进行登录操作，以此来实现对页面访问权限的有效管控，确保只有合法登录的用户才能够访问当前页面以及后续与之相关的各种功能内容，从而保障整个系统的数据安全以及业务逻辑的正常运行。 -->
-<div class="layui-layout layui-layout-admin">
+    <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
-    <div class="layui-body">
+    <!-- 包含名为“WEB-INF/teacher/tHeader.jsp”的页面，一般来讲，这个页面主要是用于定义教师端页面的头部区域的，在这个头部区域当中，通常会包含诸如页面的大标题、用于页面导航的导航栏、展示教师用户基本信息（例如用户名、头像等内容）等与头部相关的各种元素，通过这样的包含操作，就可以把这些头部相关的元素整合到当前页面之中，进而构建出一个完整且规范的页面头部布局结构。 -->
-        <!-- 内容主体区域 -->
+    <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
-        <div style="padding: 15px;">
+    <!-- 包含名为“WEB-INF/teacher/teacherNav.jsp”的页面，大概率它的作用是用于展示教师端的导航菜单的，借助这个导航菜单，教师用户就可以方便快捷地在不同的功能模块（例如课程管理、学生管理、个人信息管理等不同的功能板块，具体的功能模块划分要取决于业务系统的整体设计需求）之间进行切换操作，实现页面功能的导航跳转，为用户提供便捷的操作入口，从而提升用户使用整个系统的便利性。 -->
-            <span class="layui-breadcrumb">
+    <div class="layui-layout layui-layout-admin">
-                <a href="">教师端</a>
+        <!-- 创建一个基于Layui框架的布局容器，通过应用“layui-layout”和“layui-layout-admin”这两个样式类，按照Layui框架所提供的特定布局模式对页面进行布局规划，这种布局方式在后台管理系统等应用场景中是比较常用的，它有着清晰、规范的页面分区结构，能够便于合理地放置和展示页面内的各种功能内容模块，例如可以很方便地划分出侧边栏、主体内容展示区、页面底部的页脚等不同的区域。 -->
-                <a href="">课程信息</a>
+        <div class="layui-body">
-                <a><cite>修改学生分数</cite></a>
+            <!-- 在上述所创建的Layui布局容器内定义页面的主体内容区域，这个区域会依据Layui框架既定的布局规则来进行自适应显示，它主要的作用是用于承载和展示与具体业务相关的核心内容，比如下面即将呈现出来的关于“修改学生分数”相关信息的表单等内容元素，这里也就是用户在访问该页面时重点关注和进行操作的区域。 -->
-            </span>
+            <!-- 内容主体区域 -->
-            <form class="layui-form" action="${pageContext.request.contextPath}/updateOptionalCourseScoreServlet?cid=${c.c_id}&sid=${s.s_id}" style="padding-top: 50px" method="post">
+            <div style="padding: 15px;">
-                <div class="layui-form-item">
+                <!-- 创建一个带有内边距的div容器，通过设置“padding: 15px;”这样的内边距样式，意味着在这个容器的四周（也就是上、下、左、右四个方向）都会留出15像素的空白空间，这样做的好处是可以让容器内部的内容在页面中展示的时候有一定的间隔，使得页面的布局更加美观、易读，也更便于对内部的各个元素进行排版布局操作，避免内容显得过于拥挤，从而提升用户查看和操作页面内容时的体验感。 -->
-                    <label class="layui-form-label">学号</label>
+                <span class="layui-breadcrumb">
-                    <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">
+                    <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>
+                    <div class="layui-form-item">
-                <div class="layui-form-item">
+                        <label class="layui-form-label">姓名</label>
-                    <label class="layui-form-label">姓名</label>
+                        <div class="layui-input-block">
-                    <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">
-                        <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>
+                    <div class="layui-form-item">
-                <div class="layui-form-item">
+                        <label class="layui-form-label">课程号</label>
-                    <label class="layui-form-label">课程号</label>
+                        <div class="layui-input-block">
-                    <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">
-                        <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>
+                    <div class="layui-form-item">
-                <div class="layui-form-item">
+                        <label class="layui-form-label">课程名</label>
-                    <label class="layui-form-label">课程名</label>
+                        <div class="layui-input-block">
-                    <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">
-                        <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>
+                    <div class="layui-form-item">
-                <div class="layui-form-item">
+                        <label class="layui-form-label">课程介绍</label>
-                    <label class="layui-form-label">课程介绍</label>
+                        <div class="layui-input-block">
-                    <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">
-                        <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>
+                    <div class="layui-form-item">
-                <div class="layui-form-item">
+                        <label class="layui-form-label">学生分数</label>
-                    <label class="layui-form-label">学生分数</label>
+                        <div class="layui-input-block">
-                    <div class="layui-input-block">
+                            <input type="text" name="student-score" value="${sc.score}" required lay-verify="required" autocomplete="off" class="layui-input">
-                        <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>
 
-                <div class="layui-form-item">
+                    <div class="layui-form-item">
-                    <div class="layui-input-block">
+                        <div class="layui-input-block">
-                        <button class="layui-btn" lay-submit lay-filter="formDemo">修改</button>
+                            <button class="layui-btn" lay-submit lay-filter="formDemo">修改</button>
-                        <span style="padding-left: 20px;">${update_msg}</span>
+                            <!-- 创建一个使用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>
-                </div>
+                </form>
-            </form>
+                <jsp:include page="/footer.jsp"></jsp:include>
-            <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含名为“footer.jsp”的页面，通常这个页面主要是用于定义页面的底部区域的，在这个页面里可能会包含诸如版权信息、联系方式、页面底部导航等相关内容，通过这样的包含操作，可以完善整个页面的布局结构，使其更加完整、规范，给用户呈现出一个完整的页面视觉效果，同时也方便在底部展示一些通用的重要信息或者提供额外的操作入口等。 -->
+            </div>
         </div>
     </div>
-</div>
-
-
-<script type="text/javascript">
-    $("#nav li:nth-child(1) dl dd:nth-child(4)").addClass("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>
+    <script type="text/javascript">
-</html>
+        $("#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”的元素

web/WEB-INF/teacher/updateTeacherOptionalCourseInfo.jsp

@@ -1,79 +1,109 @@
 <%@ 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">
-<jsp:include page="/filterLogin.jsp"></jsp:include>
+    <!-- 为页面主体设置样式类为“layui-layout-body”，同时通过内联样式设定背景颜色为“#F2F2F2”，这是按照Layui框架的样式规范来对页面主体部分的外观风格进行定义，使得页面呈现出特定的浅灰色（#F2F2F2）背景颜色，有助于营造出整体统一的视觉效果，并且方便后续依据Layui框架既定的布局和样式规则来组织和展示页面中的其他各种内容元素。 -->
-<jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
+    <jsp:include page="/filterLogin.jsp"></jsp:include>
-<jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
+    <!-- 使用JSP的“include”指令将名为“filterLogin.jsp”的页面包含进来，通常情况下，这个“filterLogin.jsp”页面主要负责处理用户登录验证相关的逻辑，例如它会判断当前访问该页面的用户是否已经成功登录到系统中，如果发现用户没有登录，就会引导用户跳转到登录页面进行登录操作，以此来实现对页面访问权限的有效管控，确保只有合法登录的用户才能够访问当前页面以及后续与之相关的各种功能内容，从而保障整个系统的数据安全以及业务逻辑的正常运行。 -->
-<div class="layui-layout layui-layout-admin">
+    <jsp:include page="/WEB-INF/teacher/tHeader.jsp"></jsp:include>
-    <div class="layui-body">
+    <!-- 包含名为“WEB-INF/teacher/tHeader.jsp”的页面，一般来讲，这个页面主要是用于定义教师端页面的头部区域，在这个头部区域当中，通常会包含诸如页面的大标题、用于页面导航的导航栏、展示教师用户基本信息（例如用户名、头像等内容）等与头部相关的各种元素，通过这样的包含操作，就可以把这些头部相关的元素整合到当前页面之中，进而构建出一个完整且规范的页面头部布局结构。 -->
-        <!-- 内容主体区域 -->
+    <jsp:include page="/WEB-INF/teacher/teacherNav.jsp"></jsp:include>
-        <div style="padding: 15px;">
+    <!-- 包含名为“WEB-INF/teacher/teacherNav.jsp”的页面，大概率它的作用是用于展示教师端的导航菜单，借助这个导航菜单，教师用户就可以方便快捷地在不同的功能模块（例如课程管理、学生管理、个人信息管理等不同的功能板块，具体的功能模块划分要取决于业务系统的整体设计需求）之间进行切换操作，实现页面功能的导航跳转，为用户提供便捷的操作入口，从而提升用户使用整个系统的便利性。 -->
-            <span class="layui-breadcrumb">
+    <div class="layui-layout layui-layout-admin">
-                <a href="">教师端</a>
+        <!-- 创建一个基于Layui框架的布局容器，通过应用“layui-layout”和“layui-layout-admin”这两个样式类，按照Layui框架所提供的特定布局模式对页面进行布局规划，这种布局方式在后台管理系统等应用场景中比较常用，它有着清晰、规范的页面分区结构，便于合理地放置和展示页面内的各种功能内容模块，例如可以很方便地划分出侧边栏、主体内容展示区、页面底部的页脚等不同的区域。 -->
-                <a href="">课程信息</a>
+        <div class="layui-body">
-                <a><cite>修改课程</cite></a>
+            <!-- 在上述所创建的Layui布局容器内定义页面的主体内容区域，这个区域会依据Layui框架既定的布局规则来进行自适应显示，它主要的作用是用于承载和展示与具体业务相关的核心内容，比如下面即将呈现出来的关于“修改课程”相关信息的表单等内容元素，这里也就是用户在访问该页面时重点关注和进行操作的区域。 -->
-            </span>
+            <!-- 内容主体区域 -->
-            <form class="layui-form" action="${pageContext.request.contextPath}/teacherOptionalCourseUpdateServlet" style="padding-top: 50px" method="post">
+            <div style="padding: 15px;">
-                <div class="layui-form-item">
+                <!-- 创建一个带有内边距的div容器，通过设置“padding: 15px;”这样的内边距样式，意味着在这个容器的四周（即上、下、左、右四个方向）都会留出15像素的空白空间，这样做的好处是可以让容器内部的内容在页面中展示的时候有一定的间隔，使得页面的布局更加美观、易读，也更便于对内部的各个元素进行排版布局操作，避免内容显得过于拥挤，从而提升用户查看和操作页面内容时的体验感。 -->
-                    <label class="layui-form-label">课程号</label>
+                <span class="layui-breadcrumb">
-                    <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">
+                    <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>
+                    <div class="layui-form-item">
-                <div class="layui-form-item">
+                        <label class="layui-form-label">课程名</label>
-                    <label class="layui-form-label">课程名</label>
+                        <div class="layui-input-block">
-                    <div class="layui-input-block">
+                            <input type="text" name="course-name" value="${course.c_name}" required lay-verify="required" autocomplete="off" class="layui-input">
-                        <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>
+                    <div class="layui-form-item">
-                <div class="layui-form-item">
+                        <label class="layui-form-label">课程信息</label>
-                    <label class="layui-form-label">课程信息</label>
+                        <div class="layui-input-block">
-                    <div class="layui-input-block">
+                            <input type="text" name="course-info" value="${course.c_info}" required lay-verify="required" autocomplete="off" class="layui-input">
-                        <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>
 
-                <div class="layui-form-item">
+                    <div class="layui-form-item">
-                    <div class="layui-input-block">
+                        <div class="layui-input-block">
-                        <button class="layui-btn" lay-submit lay-filter="formDemo">修改</button>
+                            <button class="layui-btn" lay-submit lay-filter="formDemo">修改</button>
-                        <span style="padding-left: 20px;">${update_msg}</span>
+                            <!-- 创建一个使用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>
-                </div>
+                </form>
-            </form>
+                <jsp:include page="/footer.jsp"></jsp:include>
-            <jsp:include page="/footer.jsp"></jsp:include>
+                <!-- 包含名为“footer.jsp”的页面，通常这个页面主要是用于定义页面的底部区域，在这个页面里可能会包含诸如版权信息、联系方式、页面底部导航等相关内容，通过这样的包含操作，可以完善整个页面的布局结构，使其更加完整、规范，给用户呈现出一个完整的页面视觉效果，同时也方便在底部展示一些通用的重要信息或者提供额外的操作入口等。 -->
+            </div>
         </div>
     </div>
-</div>
-
-
-<script type="text/javascript">
-    $("#nav li:nth-child(1) dl dd:nth-child(3)").addClass("layui-this");
-    $("#nav li:nth-child(1)").addClass("layui-nav-itemed");
-    $("#hidden-update").removeAttr("hidden");
-</script>
-<script>
-    //JavaScript代码区域
-    layui.use('element', function(){
-        var element = layui.element;
-        element.init();
-    });
-</script>
-
-<script>
-    //Demo
-    layui.use('form', function(){
 
-    });
-</script>
 
-</body>
+    <script type="text/javascript">
-</html>
+        $("#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(){
+            // 使用Layui框架的模块加载机制，加载“form”模块，不过这里函数体内部暂时没有具体的代码逻辑，一般加载“form”模块后，可以利用它来进行表单相关的操作，比如进一步定义表单验证规则、处理表单提交前后的各种事件