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

@@ -6,66 +6,132 @@ import com.hua.dao.DAO;
 import com.hua.dao.StudentGradeDAO;
 import com.hua.entity.StudentGrade;
 
+/**
+ * `StudentGradeDAOIpml`类是数据访问对象（DAO）的具体实现类，用于操作与学生成绩相关的数据，
+ * 它继承自泛型的`DAO`类，并实现了`StudentGradeDAO`接口，通过编写具体的SQL语句来实现对学生成绩信息在数据库中的增删改查以及按特定条件查询等操作。
+ */
 public class StudentGradeDAOIpml extends DAO<StudentGrade> implements StudentGradeDAO {
 
+	/**
+	 * 获取所有学生成绩信息的方法。
+	 * 该方法通过构造一条查询所有记录的SQL语句（针对名为`studentGrade`的数据库表），即 `SELECT * FROM studentGrade;`，
+	 * 然后调用父类`DAO`中的`getForList`方法来执行这个查询操作，将从数据库中获取到的所有记录转换为`List<StudentGrade>`类型的列表并返回，
+	 * 列表中的每个元素都是`StudentGrade`类型的对象，对应数据库表中的一条记录，代表一位学生某一门课程的成绩相关信息。
+	 *
+	 * @return 返回包含所有学生成绩信息的列表，若数据库表中不存在相关记录，则返回一个空列表。
+	 */
 	@Override
 	public List<StudentGrade> getAll() {
 		String sql = "SELECT * FROM studentGrade;";
 		return getForList(sql);
 	}
 
+	/**
+	 * 根据学生ID获取该学生所有课程成绩信息的方法。
+	 * 首先构建了一条带有条件查询的SQL语句，使用`studentId`（参数类型为`Long`）作为查询条件，从`studentGrade`表中筛选出对应学生的所有课程成绩记录，
+	 * 接着调用父类`DAO`中的`getForList`方法来执行这个带有条件的查询操作，该方法会将查询结果以`List<StudentGrade>`的形式返回，
+	 * 返回的列表中包含了该学生对应的所有课程成绩对象，若该学生在数据库中不存在成绩记录则返回空列表。
+	 *
+	 * @param studentId 要查询课程成绩信息的学生的唯一标识符（类型为`Long`），用于在数据库表中定位相应的学生课程成绩记录。
+	 * @return 返回对应学生的所有课程成绩信息列表，列表元素为`StudentGrade`类型的对象，若该学生无课程成绩记录则返回空列表。
+	 */
 	@Override
-	public List<StudentGrade> getAllCourseGrade(Long studentId){
-		String sql = "SELECT * FROM studentGrade where studentId = ?;";
+	public List<StudentGrade> getAllCourseGrade(Long studentId) {
+		String sql = "SELECT * FROM studentGrade where studentId =?";
 		return getForList(sql, studentId);
 	}
 
+	/**
+	 * 向数据库中插入一条新的学生成绩信息记录的方法。
+	 * 先构造了一条插入数据的SQL语句，明确了要插入数据的列以及对应的值的占位符（`?`），
+	 * 然后调用父类`DAO`中的`update`方法（此处的`update`方法实际上执行的是插入操作，名称上可能有些容易混淆，但功能符合此处插入数据的需求），
+	 * 将学生成绩对象（`studentGrade`）中的各个属性值按照SQL语句中占位符的顺序依次传递进去，
+	 * 从而将新的学生成绩数据插入到数据库的`studentGrade`表中。
+	 *
+	 * @param studentGrade 包含要插入的学生成绩信息的`StudentGrade`对象，其各个属性值将被插入到数据库表对应的列中。
+	 */
 	@Override
 	public void insert(StudentGrade studentGrade) {
 		String sql = "insert into studentGrade " +
 				"values(?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
-		update(sql ,studentGrade.getYearTerm(), studentGrade.getStudentId(), studentGrade.getStudentName(), 
+		update(sql,studentGrade.getYearTerm(), studentGrade.getStudentId(), studentGrade.getStudentName(),
 				studentGrade.getCourseId(),studentGrade.getCourseName(),studentGrade.getScore(),studentGrade.getGradePoint(),
 				studentGrade.getCredit(),studentGrade.getCourseClass(),studentGrade.getStudyWay(),studentGrade.getExamWay(),
 				studentGrade.getGradeWay(),studentGrade.getEffectivity(),studentGrade.getRemarks());
 	}
 
+	/**
+	 * 根据传入的学生成绩对象更新数据库中对应记录的方法。
+	 * 构建了一条更新数据的SQL语句，指定了要更新的列以及更新的条件（通过`studentId`来定位要更新的记录），
+	 * 然后调用父类`DAO`中的`update`方法，将学生成绩对象（`studentGrade`）中除`studentId`（用于定位记录）之外的各个属性值按照SQL语句中占位符的顺序依次传递进去，
+	 * 实现对数据库中对应学生成绩记录的更新操作，确保数据库中的数据与传入的学生成绩对象中的最新信息保持一致。
+	 *
+	 * @param studentGrade 包含更新后学生成绩信息的`StudentGrade`对象，其属性值将用于更新数据库中对应记录的相应列。
+	 */
 	@Override
 	public void update(StudentGrade studentGrade) {
-		String sql = "update studentGrade set yearTerm = ?, studentName = ?,courseId = ?, courseName = ?, " +
-				"score = ? ,gradePoint = ? ,credit = ? ,courseClass = ? ,studyWay = ?, examWay = ?, " +
-				"gradeWay = ?, effectivity = ?, remarks = ? where studentId = ?";
-		update(sql ,studentGrade.getYearTerm(), studentGrade.getStudentName(), 
+		String sql = "update studentGrade set yearTerm =?, studentName =?,courseId =?, courseName =?, " +
+				"score =?, gradePoint =?, credit =?, courseClass =?, studyWay =?, examWay =?, " +
+				"gradeWay =?, effectivity =?, remarks =? where studentId =?";
+		update(sql,studentGrade.getYearTerm(), studentGrade.getStudentName(),
 				studentGrade.getCourseId(),studentGrade.getCourseName(),studentGrade.getScore(),studentGrade.getGradePoint(),
 				studentGrade.getCredit(),studentGrade.getCourseClass(),studentGrade.getStudyWay(),studentGrade.getExamWay(),
 				studentGrade.getGradeWay(),studentGrade.getEffectivity(),studentGrade.getRemarks(), studentGrade.getStudentId());
 
 	}
 
+	/**
+	 * 根据学生ID删除数据库中对应的学生成绩记录的方法。
+	 * 构建了一条删除数据的SQL语句，以`studentId`（类型为`Long`）作为删除条件，从`studentGrade`表中删除对应学生的所有成绩记录，
+	 * 然后调用父类`DAO`中的`update`方法（底层可能通过执行SQL的`executeUpdate`等相关操作来实现删除功能）来执行删除操作，
+	 * 使得数据库中对应学生的成绩数据被移除。
+	 *
+	 * @param studentId 要删除学生成绩记录的学生的唯一标识符（类型为`Long`），用于在数据库表中定位要删除的记录。
+	 */
 	@Override
 	public void delete(Long studentId) {
-		String sql = "delete from studentGrade where studentId = ?";
+		String sql = "delete from studentGrade where studentId =?";
 		update(sql, studentId);
 	}
 
+	/**
+	 * 根据学生ID获取满足特定条件（这里通过统计该学生ID对应的成绩记录数量来体现特定条件，具体取决于业务逻辑）的学生成绩记录数量的方法。
+	 * 构建了一条用于统计记录数量的SQL语句（`select count(studentId) from studentGrade where studentId =?`），通过`studentId`来筛选符合条件的记录并统计其数量，
+	 * 然后调用父类`DAO`中的`getForValue`方法来执行这个查询操作，并返回统计得到的记录数量值（类型为`Integer`）。
+	 *
+	 * @param studentId 用于定位和筛选学生成绩记录的学生的唯一标识符（类型为`Long`），用于在数据库表中确定要统计数量的记录范围。
+	 * @return 返回满足给定条件（对应`studentId`的学生成绩记录）的记录数量，类型为`Integer`。
+	 */
 	@Override
 	public Integer getCountWithStudentId(Long studentId) {
-		String sql = "select count(studentId) from studentGrade where studentId = ?";
+		String sql = "select count(studentId) from studentGrade where studentId =?";
 		return getForValue(sql,studentId);
 	}
 
+	/**
+	 * 根据学生ID和学年学期获取相应学生成绩信息的方法。
+	 * 此方法会根据传入的学年学期（`yearTerm`）是否为 `null` 来动态构建不同的 SQL 查询语句。
+	 * 如果 `yearTerm` 不为 `null`，则构建一条模糊查询的 SQL 语句，通过 `like` 关键字结合 `%` 通配符，在 `studentGrade` 表中查找学年学期包含指定 `yearTerm` 值且对应指定学生ID的成绩记录；
+	 * 如果 `yearTerm` 为 `null`，则构建一条简单的根据学生ID查询的 SQL 语句，从 `studentGrade` 表中获取对应学生的所有成绩记录。
+	 * 最后都会调用父类 `DAO` 中的 `getForList` 方法来执行相应的查询操作，并将查询结果以 `List<StudentGrade>` 类型的列表返回，
+	 * 列表中的每个元素都是 `StudentGrade` 类型的对象，对应数据库表中的一条记录，代表该学生的某一门课程的成绩相关信息。
+	 *
+	 * @param studentId 要查询成绩信息的学生的唯一标识符（类型为`Long`），用于在数据库表中定位相应的学生成绩记录。
+	 * @param yearTerm 表示学年学期的字符串，用于筛选对应学年学期下该学生的成绩记录，如果为 `null` 则查询该学生的所有成绩记录。
+	 * @return 返回满足给定学生ID和学年学期条件的学生成绩信息列表，列表中的元素为`StudentGrade`类型的对象，若不存在匹配记录则返回空列表。
+	 */
 	@Override
 	public List<StudentGrade> getAllWithYearTerm(Long studentId,
-			String yearTerm) {
+												 String yearTerm) {
 		String sql;
-		
-		if(yearTerm != null){
-			sql = "SELECT * FROM studentGrade where yearTerm like '%" + yearTerm +"%' and studentId = ?;";
+
+		if (yearTerm!= null) {
+			sql = "SELECT * FROM studentGrade where yearTerm like '%" + yearTerm + "%' and studentId =?";
 			return getForList(sql,studentId);
-		}else{
-			sql = "SELECT * FROM studentGrade where studentId = ?;";
+		} else {
+			sql = "SELECT * FROM studentGrade where studentId =?";
 			return getForList(sql,studentId);
 		}
 	}
 
-}
+}

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

@@ -6,57 +6,129 @@ import com.hua.dao.DAO;
 import com.hua.dao.StudentOptCourseDAO;
 import com.hua.entity.StudentOptCourse;
 
+/**
+ * `StudentOptCourseDAOImpl`类是数据访问对象（DAO）的具体实现类，用于操作与学生选修课程相关的数据，
+ * 它继承自泛型的`DAO`类，并实现了`StudentOptCourseDAO`接口，通过编写具体的SQL语句来实现对学生选修课程信息在数据库中的增删改查以及按特定条件查询等操作。
+ */
 public class StudentOptCourseDAOImpl extends DAO<StudentOptCourse> implements StudentOptCourseDAO {
 
+	/**
+	 * 获取所有学生选修课程信息的方法。
+	 * 该方法通过构造一条查询所有记录的SQL语句（针对名为`StudentOptCourse`的数据库表），即 `SELECT * FROM StudentOptCourse;`，
+	 * 然后调用父类`DAO`中的`getForList`方法来执行这个查询操作，将从数据库中获取到的所有记录转换为`List<StudentOptCourse>`类型的列表并返回，
+	 * 列表中的每个元素都是`StudentOptCourse`类型的对象，对应数据库表中的一条记录，代表学生选修课程相关的一条信息记录。
+	 *
+	 * @return 返回包含所有学生选修课程信息的列表，若数据库表中不存在相关记录，则返回一个空列表。
+	 */
 	@Override
 	public List<StudentOptCourse> getAll() {
 		String sql = "SELECT * FROM StudentOptCourse;";
 		return getForList(sql);
 	}
 
+	/**
+	 * 根据学生ID获取特定学生选修课程信息的方法。
+	 * 首先构建了一条带有条件查询的SQL语句，使用`studentId`作为查询条件，从`StudentOptCourse`表中筛选出对应学生的选修课程记录，
+	 * 接着调用父类`DAO`中的`get`方法来执行这个带有条件的查询操作，该方法会返回查询到的符合条件的`StudentOptCourse`对象，
+	 * 如果在数据库中没有找到对应学生的选修课程记录，则返回`null`。
+	 *
+	 * @param studentId 要查询选修课程信息的学生的唯一标识符，用于在数据库表中定位相应的选修课程记录。
+	 * @return 返回对应学生的选修课程对象，如果不存在该学生的选修课程记录，则返回`null`。
+	 */
 	@Override
 	public StudentOptCourse get(String studentId) {
-		String sql = "select *from StudentOptCourse where studentId = ?";
+		String sql = "select *from StudentOptCourse where studentId =?";
 		return get(sql, studentId);
 	}
 
+	/**
+	 * 向数据库中插入一条新的学生选修课程信息记录的方法。
+	 * 先构造了一条插入数据的SQL语句，明确了要插入数据的列以及对应的值的占位符（`?`），
+	 * 然后调用父类`DAO`中的`update`方法（此处的`update`方法实际上执行的是插入操作，名称上可能有些容易混淆，但功能符合此处插入数据的需求），
+	 * 将学生选修课程对象（`studentOptCourse`）中的`studentId`和`CourseId`这两个属性值按照SQL语句中占位符的顺序依次传递进去，
+	 * 从而将新的学生选修课程数据插入到数据库的`StudentOptCourse`表中。
+	 *
+	 * @param studentOptCourse 包含要插入的学生选修课程信息的`StudentOptCourse`对象，其`studentId`和`CourseId`属性值将被插入到数据库表对应的列中。
+	 */
 	@Override
 	public void insert(StudentOptCourse studentOptCourse) {
 		String sql = "insert into StudentOptCourse values(?,?)";
-		update(sql , studentOptCourse.getStudentId(),studentOptCourse.getCourseId());
+		update(sql, studentOptCourse.getStudentId(),studentOptCourse.getCourseId());
 
 	}
 
+	/**
+	 * 根据传入的学生选修课程对象更新数据库中对应记录的方法。
+	 * 构建了一条更新数据的SQL语句，指定了要更新的列（这里是`CourseId`）以及更新的条件（通过`studentId`来定位要更新的记录），
+	 * 然后调用父类`DAO`中的`update`方法，将学生选修课程对象（`studentOptCourse`）中的`CourseId`和`studentId`属性值按照SQL语句中占位符的顺序依次传递进去，
+	 * 实现对数据库中对应学生选修课程记录的更新操作，确保数据库中的数据与传入的学生选修课程对象中的最新信息保持一致。
+	 *
+	 * @param studentOptCourse 包含更新后学生选修课程信息的`StudentOptCourse`对象，其属性值将用于更新数据库中对应记录的相应列。
+	 */
 	@Override
 	public void update(StudentOptCourse studentOptCourse) {
-		String sql = "update StudentOptCourse set CourseId = ? where studentId = ?";
+		String sql = "update StudentOptCourse set CourseId =? where studentId =?";
 		update(sql, studentOptCourse.getCourseId(), studentOptCourse.getStudentId() );
 
 	}
 
+	/**
+	 * 根据学生ID删除数据库中对应的学生选修课程记录的方法。
+	 * 构建了一条删除数据的SQL语句，以`studentId`作为删除条件，从`StudentOptCourse`表中删除对应学生的选修课程记录，
+	 * 然后调用父类`DAO`中的`update`方法（底层可能通过执行SQL的`executeUpdate`等相关操作来实现删除功能）来执行删除操作，
+	 * 使得数据库中对应学生的选修课程数据被移除。
+	 *
+	 * @param studentId 要删除学生选修课程记录的学生的唯一标识符，用于在数据库表中定位要删除的记录。
+	 */
 	@Override
 	public void delete(String studentId) {
-		String sql = "delete from StudentOptCourse where studentId = ?";
+		String sql = "delete from StudentOptCourse where studentId =?";
 		update(sql, studentId);
 	}
 
+	/**
+	 * （目前是未实现的方法，可能需要根据具体业务需求完善）
+	 * 按照名称获取学生选修课程记录数量的方法，此处暂时返回0，后续或许需要根据实际的业务逻辑编写具体的SQL查询语句，
+	 * 用于统计满足特定名称相关条件下的学生选修课程记录数量，并返回相应的计数值。
+	 *
+	 * @param studentId 此处参数名称可能不太准确（也许和实际业务中用于统计的关键条件相关，需要进一步确认），可能需要根据业务场景修改完善逻辑。
+	 * @return 目前固定返回0，后续完善代码后应返回满足特定条件下的学生选修课程记录数量。
+	 */
 	@Override
 	public long getCountWithName(String studentId) {
 		// TODO Auto-generated method stub
 		return 0;
 	}
 
+	/**
+	 * 根据传入的`StudentOptCourse`对象（通过其包含的学生ID和课程ID属性）获取特定学生选修课程信息的方法。
+	 * 构建了一条带有多个条件查询的SQL语句，通过指定`studentId`和`courseId`作为查询条件，从`StudentOptCourse`表中筛选出符合条件的选修课程记录，
+	 * 然后调用父类`DAO`中的`get`方法来执行这个带有条件的查询操作，该方法会返回查询到的符合条件的`StudentOptCourse`对象，
+	 * 如果在数据库中没有找到同时满足学生ID和课程ID条件的选修课程记录，则返回`null`。
+	 *
+	 * @param studentOptCourse 包含要查询选修课程信息的`StudentOptCourse`对象，通过其`studentId`和`CourseId`属性来定位数据库中的相应记录。
+	 * @return 返回对应学生和课程的选修课程对象，如果不存在满足条件的选修课程记录，则返回`null`。
+	 */
 	@Override
 	public StudentOptCourse get(StudentOptCourse studentOptCourse) {
-		String sql = "select *from StudentOptCourse where studentId = ? and courseId = ?";
+		String sql = "select *from StudentOptCourse where studentId =? and courseId =?";
 		return get(sql, studentOptCourse.getStudentId(), studentOptCourse.getCourseId());
 	}
 
+	/**
+	 * 根据学生ID获取该学生所有的学生选修课程信息的方法。
+	 * 构造了一条带有条件查询的SQL语句，通过指定`studentId`作为查询条件，从`StudentOptCourse`表中筛选出对应学生的所有选修课程记录，
+	 * 然后调用父类`DAO`中的`getForList`方法来执行查询，并将查询结果以`List<StudentOptCourse>`的形式返回，
+	 * 返回的列表中包含了满足给定学生ID条件的所有选修课程对象，若不存在匹配记录则返回空列表。
+	 *
+	 * @param studentId 要查询选修课程信息的学生的唯一标识符，用于在数据库表中筛选相应的选修课程记录。
+	 * @return 返回满足给定学生ID条件的选修课程信息列表，列表中的元素为`StudentOptCourse`类型的对象，若无匹配记录则返回空列表。
+	 */
 	@Override
 	public List<StudentOptCourse> getAll(String studentId) {
-		String sql = "SELECT * FROM StudentOptCourse where studentId = ?;";
+		String sql = "SELECT * FROM StudentOptCourse where studentId =?";
 		return getForList(sql, studentId);
 	}
 
 
-}
+}

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

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

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

@@ -7,58 +7,122 @@ import com.hua.dao.UserDAO;
 import com.hua.entity.CriterUser;
 import com.hua.entity.User;
 
+/**
+ * `UserDAOImpl`类是数据访问对象（DAO）的具体实现类，用于操作与用户相关的数据（对应数据库中的`users`表），
+ * 它继承自泛型的`DAO`类，并实现了`UserDAO`接口，通过编写具体的SQL语句来实现对用户信息在数据库中的增删改查以及按特定条件查询等操作。
+ */
 public class UserDAOImpl extends DAO<User> implements UserDAO {
-	
+
+	/**
+	 * 获取所有用户信息的方法。
+	 * 此方法构造了一条查询`users`表中所有记录的SQL语句，即 `SELECT * FROM users;`，
+	 * 然后调用父类`DAO`中的`getForList`方法来执行这个查询操作，将从数据库中获取到的所有记录转换为`List<User>`类型的列表并返回，
+	 * 列表中的每个元素都是`User`类型的对象，对应数据库表中的一条记录，代表一位用户的详细信息。
+	 *
+	 * @return 返回包含所有用户信息的列表，若数据库中不存在相关用户记录，则返回一个空列表。
+	 */
 	@Override
 	public List<User> getAll() {
-		
+
 		String sql = "SELECT * FROM users;";
 		return getForList(sql);
 	}
 
+	/**
+	 * 根据用户名获取特定用户信息的方法。
+	 * 首先构建一条带有条件查询的SQL语句，使用`username`作为查询条件，从`users`表中筛选出对应用户名的用户记录，
+	 * 接着调用父类`DAO`中的`get`方法来执行这个带有条件的查询操作，该方法会返回查询到的符合条件的`User`对象，
+	 * 如果在数据库中没有找到对应用户名的用户记录，则返回`null`。
+	 *
+	 * @param username 要查询用户信息的用户名，用于在数据库表中定位相应的用户记录。
+	 * @return 返回对应用户名的用户信息对象，如果不存在该用户名对应的用户记录，则返回`null`。
+	 */
 	@Override
 	public User get(String username) {
-		String sql = "select *from users where username = ?";
+		String sql = "select *from users where username =?";
 		return get(sql, username);
 	}
 
+	/**
+	 * 向数据库中插入一条新用户信息记录的方法。
+	 * 先构造一条插入数据的SQL语句，明确了要插入数据的列以及对应的值的占位符（`?`），
+	 * 然后调用父类`DAO`中的`update`方法（此处的`update`方法实际上执行的是插入操作，名称上可能有些容易混淆，但功能符合此处插入数据的需求），
+	 * 将用户对象（`user`）中的各个属性值按照SQL语句中占位符的顺序依次传递进去，
+	 * 从而将新用户的数据插入到数据库的`users`表中。
+	 *
+	 * @param user 包含要插入的用户信息的`User`对象，其各个属性值将被插入到数据库表对应的列中。
+	 */
 	@Override
 	public void insert(User user) {
 		String sql = "insert into users values(?,?,?,?,?,?,?)";
-		update(sql , user.getUsername(), user.getPassword(), user.getName(), 
-				user.getIdentity(), user.getFindMMproof(),user.getLogin_last_time(), 
+		update(sql, user.getUsername(), user.getPassword(), user.getName(),
+				user.getIdentity(), user.getFindMMproof(),user.getLogin_last_time(),
 				user.getPassword_last_changed());
 
 	}
 
+	/**
+	 * 根据传入的用户对象更新数据库中对应用户记录的方法。
+	 * 构建一条更新数据的SQL语句，指定了要更新的列以及更新的条件（通过`username`来定位要更新的记录），
+	 * 然后调用父类`DAO`中的`update`方法，将用户对象（`user`）中除`username`（用于定位记录）之外的各个属性值按照SQL语句中占位符的顺序依次传递进去，
+	 * 实现对数据库中对应用户记录的更新操作，确保数据库中的用户信息与传入的用户对象中的最新信息保持一致。
+	 *
+	 * @param user 包含更新后用户信息的`User`对象，其属性值将用于更新数据库中对应记录的相应列。
+	 */
 	@Override
 	public void update(User user) {
-		String sql = "update users set password = ?,name = ?, identity = ?, " +
-				"findMMproof = ?, login_last_time = ?, password_last_changed = ? where username = ?";
-		update(sql, user.getPassword(),user.getName(), user.getIdentity(), user.getFindMMproof(), 
+		String sql = "update users set password =?,name =?, identity =?, " +
+				"findMMproof =?, login_last_time =?, password_last_changed =? where username =?";
+		update(sql, user.getPassword(),user.getName(), user.getIdentity(), user.getFindMMproof(),
 				user.getLogin_last_time(), user.getPassword_last_changed(), user.getUsername());
 
 	}
 
+	/**
+	 * 根据用户名删除数据库中对应用户记录的方法。
+	 * 构建一条删除数据的SQL语句，以`username`作为删除条件，从`users`表中删除对应用户名的用户记录，
+	 * 然后调用父类`DAO`中的`update`方法（底层可能通过执行SQL的`executeUpdate`等相关操作来实现删除功能）来执行删除操作，
+	 * 使得数据库中对应用户名的用户数据被移除。
+	 *
+	 * @param username 要删除用户记录的用户名，用于在数据库表中定位要删除的记录。
+	 */
 	@Override
 	public void delete(String username) {
-		String sql = "delete from users where username = ?";
+		String sql = "delete from users where username =?";
 		update(sql, username);
 	}
 
+	/**
+	 * 根据用户名获取满足特定条件（此处通过统计符合该用户名条件的记录数量来体现特定条件，具体取决于业务逻辑）的用户记录数量的方法。
+	 * 构建一条用于统计记录数量的SQL语句（`select count(*) from users where username =?`），通过`username`来筛选符合条件的记录并统计其数量，
+	 * 然后调用父类`DAO`中的`getForValue`方法来执行这个查询操作，并返回统计得到的记录数量值（类型为`long`）。
+	 *
+	 * @param username 用于定位和筛选用户记录的用户名，用于在数据库表中确定要统计数量的记录范围。
+	 * @return 返回满足给定条件（对应`username`的用户记录）的记录数量，类型为`long`。
+	 */
 	@Override
 	public long getCountWithName(String username) {
-		String sql = "select count(*) from users where username = ?";
+		String sql = "select count(*) from users where username =?";
 		return getForValue(sql,username);
 	}
 
+	/**
+	 * 根据给定的`CriterUser`对象中的条件信息来获取符合条件的用户信息列表的方法。
+	 * 首先构建一条带有多个模糊查询条件的SQL语句，通过`like`关键字结合传入的`CriterUser`对象中的用户名（`username`）、姓名（`name`）以及身份（`identity`）等信息作为模糊查询条件，
+	 * 从`users`表中筛选出符合这些模糊条件的用户记录，
+	 * 然后调用父类`DAO`中的`getForList`方法来执行这个查询操作，并将查询结果以`List<User>`的形式返回，
+	 * 返回的列表中包含了满足给定条件的所有用户对象，若不存在匹配记录则返回空列表。
+	 *
+	 * @param user 包含了用于查询用户信息的各种条件信息的`CriterUser`对象，其各个属性值将作为模糊查询条件来筛选相应的用户信息记录。
+	 * @return 返回满足给定条件的用户信息列表，列表中的元素为`User`类型的对象，若不存在匹配记录则返回空列表。
+	 */
 	@Override
 	public List<User> getForListWithCriterCustomer(CriterUser user) {
 		String sql = "select * from users " +
-				"where username like ? and name like ? and identity like ?";
-		
+				"where username like? and name like? and identity like?";
+
 		return getForList(sql, user.getUsername(), user.getName(), user.getIdentity());
 	}
 
 
-}
+}