javaweb_project/src/com/hua/impl/CourseScheduleDAOImpl.java

@@ -6,56 +6,117 @@ import com.hua.dao.CourseScheduleDAO;
 import com.hua.dao.DAO;
 import com.hua.entity.CourseSchedule;
 
+/**
+ * `CourseScheduleDAOImpl`类是数据访问对象（DAO）的具体实现类，用于操作`CourseSchedule`实体对应的数据库表。
+ * 它继承自泛型的`DAO`类，并实现了`CourseScheduleDAO`接口，通过编写具体的SQL语句来实现对课程安排数据的增删改查等操作。
+ */
 public class CourseScheduleDAOImpl extends DAO<CourseSchedule> implements CourseScheduleDAO {
 
+	/**
+	 * 获取所有课程安排信息的方法。
+	 * 该方法通过执行一条查询所有记录的SQL语句，从名为`courseschedule`的数据库表中获取所有课程安排的数据，
+	 * 并将查询结果以`List<CourseSchedule>`的形式返回，调用了父类`DAO`中的`getForList`方法来执行查询并处理结果集转换为相应的对象列表。
+	 *
+	 * @return 返回包含所有课程安排信息的列表，列表中的每个元素都是`CourseSchedule`类型的对象，代表一条课程安排记录。
+	 */
 	@Override
 	public List<CourseSchedule> getAll() {
 		String sql = "SELECT * FROM courseschedule;";
 		return getForList(sql);
 	}
 
+	/**
+	 * 根据学生ID获取特定学生的课程安排信息的方法。
+	 * 构造了一条带有条件查询的SQL语句，通过指定`studentId`作为查询条件，从`courseschedule`表中获取对应学生的课程安排记录，
+	 * 然后调用父类`DAO`中的相应查询方法（此处为`get`方法）来执行查询，并返回查询到的`CourseSchedule`对象，如果没有找到匹配记录则返回`null`。
+	 *
+	 * @param studentId 要查询课程安排的学生的唯一标识符，用于在数据库表中定位对应的课程安排记录。
+	 * @return 返回对应学生的课程安排对象，如果不存在则返回`null`。
+	 */
 	@Override
 	public CourseSchedule get(String studentId) {
-		String sql = "select *from courseschedule where studentId = ?";
+		String sql = "select *from courseschedule where studentId =?";
 		return get(sql, studentId);
 	}
 
+	/**
+	 * 向数据库中插入一条新的课程安排记录的方法。
+	 * 首先构造了一条插入数据的SQL语句，该语句指定了要插入数据的列以及对应的值的占位符（`?`），
+	 * 然后调用父类`DAO`中的`update`方法，将课程安排对象（`courseSchedule`）中的各个属性值作为参数传递进去，
+	 * 按照SQL语句中占位符的顺序依次填充，从而将课程安排数据插入到数据库的`courseschedule`表中。
+	 *
+	 * @param courseSchedule 包含要插入的课程安排信息的`CourseSchedule`对象，其各个属性值将被插入到数据库表对应的列中。
+	 */
 	@Override
 	public void insert(CourseSchedule courseSchedule) {
 		String sql = "insert into courseschedule values(?,?,?,?,?,?,?)";
-		update(sql , courseSchedule.getStudentId(), courseSchedule.getWeek(), courseSchedule.getWeekday(), 
-				courseSchedule.getJoint(), courseSchedule.getCourse(),courseSchedule.getTeacher(), 
+		update(sql, courseSchedule.getStudentId(), courseSchedule.getWeek(), courseSchedule.getWeekday(),
+				courseSchedule.getJoint(), courseSchedule.getCourse(),courseSchedule.getTeacher(),
 				courseSchedule.getClassplace());
 
 	}
 
+	/**
+	 * 根据传入的课程安排对象更新数据库中对应记录的方法。
+	 * 构建了一条更新数据的SQL语句，指定了要更新的列以及更新的条件（通过`studentId`来定位要更新的记录），
+	 * 然后调用父类`DAO`中的`update`方法，将课程安排对象（`courseSchedule`）中除`studentId`（用于定位记录）之外的各个属性值按照SQL语句中占位符的顺序依次传递进去，
+	 * 从而实现对数据库中对应课程安排记录的更新操作，使数据库中的数据与传入的课程安排对象中的最新信息保持一致。
+	 *
+	 * @param courseSchedule 包含更新后课程安排信息的`CourseSchedule`对象，其属性值将用于更新数据库中对应记录的相应列。
+	 */
 	@Override
 	public void update(CourseSchedule courseSchedule) {
-		String sql = "update courseschedule set Week = ?,Weekday = ?, Joint = ?, " +
-				"Course = ?, Teacher = ?, Classplace = ? where studentId = ?";
-		update(sql, courseSchedule.getWeek(), courseSchedule.getWeekday(), 
-				courseSchedule.getJoint(), courseSchedule.getCourse(),courseSchedule.getTeacher(), 
+		String sql = "update courseschedule set Week =?,Weekday =?, Joint =?, " +
+				"Course =?, Teacher =?, Classplace =? where studentId =?";
+		update(sql, courseSchedule.getWeek(), courseSchedule.getWeekday(),
+				courseSchedule.getJoint(), courseSchedule.getCourse(),courseSchedule.getTeacher(),
 				courseSchedule.getClassplace(), courseSchedule.getStudentId());
 
 	}
 
+	/**
+	 * 根据学生ID删除数据库中对应的课程安排记录的方法。
+	 * 构造了一条删除数据的SQL语句，通过指定`studentId`作为删除条件，从`courseschedule`表中删除对应学生的课程安排记录，
+	 * 然后调用父类`DAO`中的`update`方法（此处的`update`方法在底层可能是执行SQL的`executeUpdate`等相关操作来实现删除功能）来执行删除操作，
+	 * 使得数据库中对应学生的课程安排数据被移除。
+	 *
+	 * @param studentId 要删除课程安排记录的学生的唯一标识符，用于在数据库表中定位要删除的记录。
+	 */
 	@Override
 	public void delete(String studentId) {
-		String sql = "delete from courseschedule where studentId = ?";
+		String sql = "delete from courseschedule where studentId =?";
 		update(sql, studentId);
 	}
 
+	/**
+	 * （目前是未实现的方法，可能需要根据具体业务需求完善）
+	 * 按照名称获取课程安排记录数量的方法，此处暂时返回0，可能后续需要根据实际的业务逻辑编写具体的SQL查询语句来统计满足特定名称条件下的课程安排记录数量，
+	 * 并返回相应的计数值。
+	 *
+	 * @param studentId 此处参数名称可能不太准确（也许和实际业务中用于统计的关键条件相关，需要进一步确认），可能需要根据业务场景修改完善逻辑。
+	 * @return 目前固定返回0，后续完善代码后应返回满足特定条件下的课程安排记录数量。
+	 */
 	@Override
 	public long getCountWithName(String studentId) {
 		// TODO Auto-generated method stub
 		return 0;
 	}
 
+	/**
+	 * 根据学生ID、学年学期以及周数获取相应课程安排信息的方法。
+	 * 构造了一条带有多个条件查询的SQL语句，通过指定`studentId`、`yearTerm`和`week`作为查询条件，从`courseschedule`表中筛选出符合条件的课程安排记录，
+	 * 然后调用父类`DAO`中的`getForList`方法来执行查询，并将查询结果以`List<CourseSchedule>`的形式返回，返回的列表中包含了满足条件的所有课程安排对象。
+	 *
+	 * @param studentId 要查询课程安排的学生的唯一标识符，用于在数据库表中筛选对应的课程安排记录。
+	 * @param yearTerm 表示学年学期的字符串，用于进一步缩小查询范围，筛选出对应学年学期下的课程安排记录。
+	 * @param week 表示周数的字符串，同样用于精准筛选出在该周数下该学生对应的课程安排记录。
+	 * @return 返回满足给定学生ID、学年学期以及周数条件的课程安排信息列表，列表中的每个元素都是`CourseSchedule`类型的对象。
+	 */
 	@Override
 	public List<CourseSchedule> getAllWithYearTerm(String studentId,
-			String yearTerm, String week) {
-		String sql = "SELECT * FROM courseschedule where studentId = ? and yearTerm = ? and week = ?;";
+												   String yearTerm, String week) {
+		String sql = "SELECT * FROM courseschedule where studentId =? and yearTerm =? and week =?;";
 		return getForList(sql, studentId, yearTerm, week);
 	}
 
-}
+}

javaweb_project/src/com/hua/impl/ExamArrangeDAOImpl.java

@@ -6,35 +6,73 @@ import com.hua.dao.DAO;
 import com.hua.dao.ExamArrangeDAO;
 import com.hua.entity.ExamArrange;
 
+/**
+ * `ExamArrangeDAOImpl`类是数据访问对象（DAO）的具体实现类，用于操作与考试安排相关的数据，
+ * 它继承自泛型的`DAO`类，并实现了`ExamArrangeDAO`接口，通过编写具体的SQL语句来实现对考试安排信息在数据库中的增删改查等操作。
+ */
 public class ExamArrangeDAOImpl extends DAO<ExamArrange> implements ExamArrangeDAO {
 
+	/**
+	 * 获取所有考试安排信息的方法。
+	 * 该方法通过构造一条查询所有记录的SQL语句（从名为`examarrange`的数据库表中获取所有数据），
+	 * 然后调用父类`DAO`中的`getForList`方法来执行查询操作，并将查询结果（以数据库表记录形式返回的数据）转换为`List<ExamArrange>`类型的列表返回，
+	 * 列表中的每个元素都对应数据库表中的一条记录，且被转换为`ExamArrange`类型的对象，代表一个具体的考试安排。
+	 *
+	 * @return 返回包含所有考试安排信息的列表，列表中的元素为`ExamArrange`类型的对象，若数据库表中无记录则返回空列表。
+	 */
 	@Override
 	public List<ExamArrange> getAll() {
 		String sql = "SELECT * FROM examarrange;";
 		return getForList(sql);
 	}
 
+	/**
+	 * 根据学生ID获取该学生相关的所有考试安排信息的方法。
+	 * 首先构造了一条带有条件查询的SQL语句，通过指定`studentId`作为查询条件，从`examarrange`表中筛选出对应学生的所有考试安排记录，
+	 * 之后调用父类`DAO`中的`getForList`方法来执行这个带有条件的查询，并将查询结果以`List<ExamArrange>`的形式返回，
+	 * 返回的列表中包含了该学生对应的所有考试安排对象，若不存在该学生的考试安排记录则返回空列表。
+	 *
+	 * @param studentId 要查询考试安排的学生的唯一标识符，用于在数据库表中定位相应的考试安排记录。
+	 * @return 返回对应学生的考试安排信息列表，列表元素为`ExamArrange`类型的对象，若该学生无考试安排记录则返回空列表。
+	 */
 	@Override
 	public List<ExamArrange> getAllWithStudentId(String studentId) {
-		String sql = "select *from examarrange where studentId = ?";
+		String sql = "select *from examarrange where studentId =?";
 		return getForList(sql, studentId);
 	}
 
+	/**
+	 * 向数据库中插入一条新的考试安排记录的方法。
+	 * 先构建了一条插入数据的SQL语句，该语句明确了要插入数据的列以及对应的值的占位符（`?`），
+	 * 接着调用父类`DAO`中的`update`方法（此处`update`方法实际上执行的是插入操作，名称可能有些容易混淆，但其功能符合此处需求），
+	 * 将考试安排对象（`examArrange`）中的各个属性值按照SQL语句中占位符的顺序依次传递进去，
+	 * 以此将新的考试安排数据插入到数据库的`examarrange`表中。
+	 *
+	 * @param examArrange 包含要插入的考试安排信息的`ExamArrange`对象，其各个属性值将被插入到数据库表对应的列中。
+	 */
 	@Override
 	public void insert(ExamArrange examArrange) {
 		String sql = "insert into examarrange values(?,?,?,?,?,?,?,?,?,?)";
-		update(sql , examArrange.getYearTerm(),examArrange.getStudentId(), examArrange.getStudentName(), 
+		update(sql, examArrange.getYearTerm(),examArrange.getStudentId(), examArrange.getStudentName(),
 				examArrange.getExamCourse(), examArrange.getExamWay(),examArrange.getExamTime(),
 				examArrange.getExamWeek(),examArrange.getExamCampus(), examArrange.getExamplace(),
 				examArrange.getExamSeatNum());
 
 	}
 
+	/**
+	 * 根据传入的考试安排对象更新数据库中对应记录的方法。
+	 * 构造了一条更新数据的SQL语句，指定了要更新的列以及更新的条件（通过`YearTerm`、`studentId`和`ExamCourse`的组合来定位要更新的记录），
+	 * 随后调用父类`DAO`中的`update`方法，将考试安排对象（`examArrange`）中相关属性值按照SQL语句中占位符的顺序依次传递进去，
+	 * 实现对数据库中对应考试安排记录的更新操作，确保数据库中的数据与传入的考试安排对象中的最新信息保持一致。
+	 *
+	 * @param examArrange 包含更新后考试安排信息的`ExamArrange`对象，其属性值将用于更新数据库中对应记录的相应列。
+	 */
 	@Override
 	public void update(ExamArrange examArrange) {
-		String sql = "update examarrange set StudentName = ?,ExamWay = ?, ExamTime = ?, " +
-				"ExamWeek = ?, ExamCampus = ?, Examplace = ?, ExamSeatNum = ? " +
-				"where YearTerm = ? and studentId = ? and ExamCourse = ?";
+		String sql = "update examarrange set StudentName =?,ExamWay =?, ExamTime =?, " +
+				"ExamWeek =?, ExamCampus =?, Examplace =?, ExamSeatNum =? " +
+				"where YearTerm =? and studentId =? and ExamCourse =?";
 		update(sql, examArrange.getStudentName(), examArrange.getExamWay(),examArrange.getExamTime(),
 				examArrange.getExamWeek(),examArrange.getExamCampus(), examArrange.getExamplace(),
 				examArrange.getExamSeatNum(),examArrange.getYearTerm(),examArrange.getStudentId(),
@@ -42,23 +80,49 @@ public class ExamArrangeDAOImpl extends DAO<ExamArrange> implements ExamArrangeD
 
 	}
 
+	/**
+	 * 根据学生ID删除数据库中对应的考试安排记录的方法。
+	 * 构建了一条删除数据的SQL语句，以`studentId`作为删除条件，从`examarrange`表中删除对应学生的所有考试安排记录，
+	 * 再调用父类`DAO`中的`update`方法（底层可能通过执行SQL的`executeUpdate`等相关操作来实现删除功能）来执行删除操作，
+	 * 使得数据库中对应学生的考试安排数据被移除。
+	 *
+	 * @param studentId 要删除考试安排记录的学生的唯一标识符，用于在数据库表中定位要删除的记录。
+	 */
 	@Override
 	public void delete(String studentId) {
-		String sql = "delete from examarrange where studentId = ?";
+		String sql = "delete from examarrange where studentId =?";
 		update(sql, studentId);
 	}
 
+	/**
+	 * （目前是未实现的方法，可能需要根据具体业务需求完善）
+	 * 按照名称获取考试安排记录数量的方法，此处暂时返回0，后续或许需要根据实际的业务逻辑编写具体的SQL查询语句，
+	 * 用于统计满足特定名称相关条件下的考试安排记录数量，并返回相应的计数值。
+	 *
+	 * @param studentId 此处参数名称可能不太准确（也许和实际业务中用于统计的关键条件相关，需要进一步确认），可能需要根据业务场景修改完善逻辑。
+	 * @return 目前固定返回0，后续完善代码后应返回满足特定条件下的考试安排记录数量。
+	 */
 	@Override
 	public long getCountWithName(String studentId) {
 		// TODO Auto-generated method stub
 		return 0;
 	}
 
+	/**
+	 * 根据学生ID和学年学期获取相应考试安排信息的方法。
+	 * 构造了一条带有多个条件查询的SQL语句，通过指定`studentId`和`yearTerm`作为查询条件，从`examarrange`表中筛选出符合条件的考试安排记录，
+	 * 然后调用父类`DAO`中的`getForList`方法来执行查询，并将查询结果以`List<ExamArrange>`的形式返回，
+	 * 返回的列表中包含了满足给定学生ID和学年学期条件的所有考试安排对象，若不存在匹配记录则返回空列表。
+	 *
+	 * @param studentId 要查询考试安排的学生的唯一标识符，用于在数据库表中筛选对应的考试安排记录。
+	 * @param yearTerm 表示学年学期的字符串，用于进一步缩小查询范围，筛选出对应学年学期下该学生的考试安排记录。
+	 * @return 返回满足给定学生ID和学年学期条件的考试安排信息列表，列表中的元素为`ExamArrange`类型的对象，若无匹配记录则返回空列表。
+	 */
 	@Override
 	public List<ExamArrange> getAllWithYearTerm(String studentId,
-			String yearTerm) {
-		String sql = "SELECT * FROM examarrange where studentId = ? and yearTerm = ?;";
+												String yearTerm) {
+		String sql = "SELECT * FROM examarrange where studentId =? and yearTerm =?";
 		return getForList(sql, studentId, yearTerm);
 	}
 
-}
+}

javaweb_project/src/com/hua/impl/ExemptionApplyDAOImpl.java

@@ -6,38 +6,84 @@ import com.hua.dao.DAO;
 import com.hua.dao.ExemptionApplyDAO;
 import com.hua.entity.ExemptionApply;
 
+/**
+ * `ExemptionApplyDAOImpl`类是数据访问对象（DAO）的具体实现类，用于操作与免修申请相关的数据，
+ * 它继承自泛型的`DAO`类，并实现了`ExemptionApplyDAO`接口，通过编写SQL语句来实现对免修申请信息在数据库中的查询、插入、更新和删除等操作。
+ */
 public class ExemptionApplyDAOImpl extends DAO<ExemptionApply> implements ExemptionApplyDAO {
 
+	/**
+	 * 获取所有免修申请信息的方法。
+	 * 该方法通过构造一条查询数据库表中所有记录的SQL语句（针对名为`exemptionapply`的表），
+	 * 然后调用父类`DAO`中的`getForList`方法来执行这个查询操作，将从数据库获取到的数据转换为`List<ExemptionApply>`类型的列表并返回，
+	 * 列表中的每个元素都是`ExemptionApply`类型的对象，对应数据库表中的一条记录，代表一个具体的免修申请信息。
+	 *
+	 * @return 返回包含所有免修申请信息的列表，若数据库中不存在相关记录，则返回一个空列表。
+	 */
 	@Override
 	public List<ExemptionApply> getAll() {
 		String sql = "SELECT * FROM exemptionapply;";
 		return getForList(sql);
 	}
 
+	/**
+	 * 根据学生ID获取特定学生的免修申请信息的方法。
+	 * 首先构建了一条带有条件查询的SQL语句，使用`studentId`作为查询条件，从`exemptionapply`表中筛选出对应学生的免修申请记录，
+	 * 接着调用父类`DAO`中的`get`方法来执行这个带有条件的查询操作，该方法会返回查询到的符合条件的`ExemptionApply`对象，
+	 * 如果在数据库中没有找到对应学生的免修申请记录，则返回`null`。
+	 *
+	 * @param studentId 要查询免修申请信息的学生的唯一标识符，用于在数据库表中定位相应的免修申请记录。
+	 * @return 返回对应学生的免修申请对象，如果不存在该学生的免修申请记录，则返回`null`。
+	 */
 	@Override
 	public ExemptionApply get(String studentId) {
-		String sql = "select *from exemptionapply where studentId = ?";
+		String sql = "select *from exemptionapply where studentId =?";
 		return get(sql, studentId);
 	}
 
+	/**
+	 * 向数据库中插入一条新的免修申请记录的方法。
+	 * 先构造了一条插入数据的SQL语句，明确了要插入数据的列以及对应的值的占位符（`?`），
+	 * 然后调用父类`DAO`中的`update`方法（此处的`update`方法实际上执行的是插入操作，名称上可能会有些误导，但功能上符合此处插入数据的需求），
+	 * 将免修申请对象（`exemptionApply`）中的各个属性值（`getYearTerm()`、`getStudentId()`、`getCourseName()`、`getApplyReason()`）按照SQL语句中占位符的顺序依次传递进去，
+	 * 从而将新的免修申请数据插入到数据库的`exemptionapply`表中。
+	 *
+	 * @param exemptionApply 包含要插入的免修申请信息的`ExemptionApply`对象，其各个属性值将被插入到数据库表对应的列中。
+	 */
 	@Override
 	public void insert(ExemptionApply exemptionApply) {
 		String sql = "insert into exemptionapply values(?,?,?,?)";
-		update(sql , exemptionApply.getYearTerm(),exemptionApply.getStudentId(), 
+		update(sql, exemptionApply.getYearTerm(),exemptionApply.getStudentId(),
 				exemptionApply.getCourseName(), exemptionApply.getApplyReason());
 
 	}
 
+	/**
+	 * 根据传入的免修申请对象更新数据库中对应记录的方法。
+	 * （目前该方法体为空，可能需要根据具体业务需求来完善相应的更新逻辑，比如根据特定条件定位要更新的记录，然后更新相应的字段等）
+	 * 理论上应该构建一条更新数据的SQL语句，指定要更新的列以及更新的条件（可能通过某个唯一标识来定位记录），
+	 * 再调用父类`DAO`中的`update`方法，将免修申请对象中的相关属性值按照SQL语句中占位符的顺序传递进去，实现对数据库中对应记录的更新操作。
+	 *
+	 * @param exemptionApply 包含更新后免修申请信息的`ExemptionApply`对象，其属性值应被用于更新数据库中对应记录的相应列。
+	 */
 	@Override
 	public void update(ExemptionApply exemptionApply) {
-		
+
 	}
 
+	/**
+	 * 根据学生ID删除数据库中对应的免修申请记录的方法。
+	 * 构建了一条删除数据的SQL语句，以`studentId`作为删除条件，从`exemptionapply`表中删除对应学生的免修申请记录，
+	 * 然后调用父类`DAO`中的`update`方法（底层可能通过执行SQL的`executeUpdate`等相关操作来实现删除功能）来执行删除操作，
+	 * 使得数据库中对应学生的免修申请数据被移除。
+	 *
+	 * @param studentId 要删除免修申请记录的学生的唯一标识符，用于在数据库表中定位要删除的记录。
+	 */
 	@Override
 	public void delete(String studentId) {
-		String sql = "delete from exemptionapply where studentId = ?";
+		String sql = "delete from exemptionapply where studentId =?";
 		update(sql, studentId);
 	}
 
 
-}
+}

javaweb_project/src/com/hua/impl/JwTeacherDAOImpl.java

@@ -6,54 +6,108 @@ import com.hua.dao.DAO;
 import com.hua.dao.JwTeacherDAO;
 import com.hua.entity.JwTeacher;
 
+/**
+ * `JwTeacherDAOImpl`类是数据访问对象（DAO）的具体实现类，用于操作与教师相关的数据（具体对应 `jwteacherinformation` 表中的数据），
+ * 它继承自泛型的 `DAO` 类，并实现了 `JwTeacherDAO` 接口，通过编写具体的 SQL 语句来实现对教师信息在数据库中的增删改查以及按特定条件统计数量等操作。
+ */
 public class JwTeacherDAOImpl extends DAO<JwTeacher> implements JwTeacherDAO {
-	
+
+	/**
+	 * 获取所有教师信息的方法。
+	 * 该方法通过构造一条查询 `jwteacherinformation` 表中所有记录的 SQL 语句（即 `SELECT * FROM jwteacherinformation;`），
+	 * 然后调用父类 `DAO` 中的 `getForList` 方法来执行这个查询操作，将从数据库获取到的所有记录数据转换为 `List<JwTeacher>` 类型的列表并返回，
+	 * 列表中的每个元素都是 `JwTeacher` 类型的对象，对应数据库表中的一条记录，代表一位教师的详细信息。
+	 *
+	 * @return 返回包含所有教师信息的列表，若数据库中不存在相关教师记录，则返回一个空列表。
+	 */
 	@Override
 	public List<JwTeacher> getAll() {
-		
+
 		String sql = "SELECT * FROM jwteacherinformation;";
 		return getForList(sql);
 	}
 
+	/**
+	 * 根据教师ID获取特定教师信息的方法。
+	 * 首先构建了一条带有条件查询的 SQL 语句，使用 `teacherId` 作为查询条件，从 `jwteacherinformation` 表中筛选出对应教师的记录，
+	 * 接着调用父类 `DAO` 中的 `get` 方法来执行这个带有条件的查询操作，该方法会返回查询到的符合条件的 `JwTeacher` 对象，
+	 * 如果在数据库中没有找到对应教师的记录，则返回 `null`。
+	 *
+	 * @param teacherId 要查询教师信息的教师的唯一标识符，用于在数据库表中定位相应的教师记录。
+	 * @return 返回对应教师的信息对象，如果不存在该教师的记录，则返回 `null`。
+	 */
 	@Override
 	public JwTeacher get(String teacherId) {
-		String sql = "select *from jwteacherinformation where teacherId = ?";
+		String sql = "select *from jwteacherinformation where teacherId =?";
 		return get(sql, teacherId);
 	}
 
+	/**
+	 * 向数据库中插入一条新教师信息记录的方法。
+	 * 先构造了一条插入数据的 SQL 语句，明确了要插入数据的列以及对应的值的占位符（`?`），该 SQL 语句用于向 `jwteacherinformation` 表中插入一条完整的教师记录，
+	 * 然后调用父类 `DAO` 中的 `update` 方法（此处的 `update` 方法实际上执行的是插入操作，名称上可能会有些误导，但功能上符合此处插入数据的需求），
+	 * 将教师对象（`teacher`）中的各个属性值（如 `getTeacherId()`、`getTeacherName()` 等）按照 SQL 语句中占位符的顺序依次传递进去，
+	 * 从而将新教师的信息数据插入到数据库的 `jwteacherinformation` 表中。
+	 *
+	 * @param teacher 包含要插入的教师信息的 `JwTeacher` 对象，其各个属性值将被插入到数据库表对应的列中。
+	 */
 	@Override
 	public void insert(JwTeacher teacher) {
 		String sql = "insert into jwteacherinformation values(?,?,?,?,?,?,?,?,?,?,?)";
-		update(sql , teacher.getTeacherId(), teacher.getTeacherName(), teacher.getGender(), 
-				teacher.getPoliticstatus(), teacher.getNation(),teacher.getNativeplace(), 
+		update(sql, teacher.getTeacherId(), teacher.getTeacherName(), teacher.getGender(),
+				teacher.getPoliticstatus(), teacher.getNation(),teacher.getNativeplace(),
 				teacher.getAcademy(),teacher.getQq(),teacher.getPhone(),
 				teacher.getEmail(),teacher.getAddress());
 
 	}
 
+	/**
+	 * 根据传入的教师对象更新数据库中对应教师记录的方法。
+	 * 构造了一条更新数据的 SQL 语句，指定了要更新的列以及更新的条件（通过 `teacherId` 来定位要更新的记录），
+	 * 然后调用父类 `DAO` 中的 `update` 方法，将教师对象（`teacher`）中除 `teacherId`（用于定位记录）之外的各个属性值按照 SQL 语句中占位符的顺序依次传递进去，
+	 * 实现对数据库中对应教师记录的更新操作，使数据库中的教师信息与传入的教师对象中的最新信息保持一致。
+	 *
+	 * @param teacher 包含更新后教师信息的 `JwTeacher` 对象，其属性值将用于更新数据库中对应记录的相应列。
+	 */
 	@Override
 	public void update(JwTeacher teacher) {
-		String sql = "update jwteacherinformation set TeacherName = ?,Gender = ?, Politicstatus = ?, " +
-				"Nation = ?, Nativeplace = ?, Academy = ?, qq = ?, Phone = ?, Email = ?," +
-				"Address = ? where teacherId = ?";
-		update(sql, teacher.getTeacherName(), teacher.getGender(), 
-				teacher.getPoliticstatus(), teacher.getNation(),teacher.getNativeplace(), 
+		String sql = "update jwteacherinformation set TeacherName =?,Gender =?, Politicstatus =?, " +
+				"Nation =?, Nativeplace =?, Academy =?, qq =?, Phone =?, Email =?," +
+				"Address =? where teacherId =?";
+		update(sql, teacher.getTeacherName(), teacher.getGender(),
+				teacher.getPoliticstatus(), teacher.getNation(),teacher.getNativeplace(),
 				teacher.getAcademy(),teacher.getQq(),teacher.getPhone(),
 				teacher.getEmail(),teacher.getAddress(),teacher.getTeacherId());
 
 	}
 
+	/**
+	 * 根据教师ID删除数据库中对应教师记录的方法。
+	 * 构建了一条删除数据的 SQL 语句，以 `teacherId` 作为删除条件，从 `jwteacherinformation` 表中删除对应教师的记录，
+	 * 然后调用父类 `DAO` 中的 `update` 方法（底层可能通过执行 SQL 的 `executeUpdate` 等相关操作来实现删除功能）来执行删除操作，
+	 * 使得数据库中对应教师的信息数据被移除。
+	 *
+	 * @param teacherId 要删除教师记录的教师的唯一标识符，用于在数据库表中定位要删除的记录。
+	 */
 	@Override
 	public void delete(String teacherId) {
-		String sql = "delete from jwteacherinformation where teacherId = ?";
+		String sql = "delete from jwteacherinformation where teacherId =?";
 		update(sql, teacherId);
 	}
 
+	/**
+	 * 根据教师ID获取满足特定条件（此处可能与教师姓名等相关，具体取决于业务逻辑，目前按代码逻辑是通过 `teacherId` 定位）的教师记录数量的方法。
+	 * 构建了一条用于统计记录数量的 SQL 语句（`select count(*) from jwteacherinformation where teacherId =?`），通过 `teacherId` 来筛选符合条件的记录并统计其数量，
+	 * 然后调用父类 `DAO` 中的 `getForValue` 方法来执行这个查询操作，并返回统计得到的记录数量值（类型为 `long`）。
+	 *
+	 * @param teacherId 用于定位和筛选教师记录的教师的唯一标识符，用于在数据库表中确定要统计数量的记录范围。
+	 * @return 返回满足给定条件（目前按代码逻辑是对应 `teacherId` 的教师记录）的记录数量，类型为 `long`。
+	 */
 	@Override
 	public long getCountWithName(String teacherId) {
-		String sql = "select count(*) from jwteacherinformation where teacherId = ?";
+		String sql = "select count(*) from jwteacherinformation where teacherId =?";
 		return getForValue(sql, teacherId);
 	}
 
-	
-}
+
+}