Java实训日志05

已于 2023-06-18 15:32:43 修改
阅读量43 收藏
点赞数
文章标签： java 开发语言
于 2023-06-14 11:48:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_78677599/article/details/131204670
版权

文章目录

八、项目开发实现步骤

（七）创建数据访问接口实现类

  • 在net.zhong.student.dao包里创建impl子包（impl:implementation实现）
    在这里插入图片描述

1、创建学校数据访问接口实现类

  • 在net.zhong.student.dao.impl包里创建CollegeDaoImpl类
    在这里插入图片描述
  • 实现CollegeDao接口（按Alt+回车）
    在这里插入图片描述
  • 选择要实现的抽象方法
    在这里插入图片描述
  • 单击【OK】按钮
    在这里插入图片描述
（1）按标识符查询学校记录方法
package net.zhong.student.dao.impl;

import net.zhong.student.bean.College;
import net.zhong.student.dao.CollegeDao;
import net.zhong.student.dbutil.ConnectionManager;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;



/**
 * 功能：学校数据访问接口实现类
 * 作者：钟城翔
 * 日期：2023年06月14日
 */
public class CollegeDaoImpl implements CollegeDao {
    @Override // 按标识符查询学校记录
    public College findById(int id) {
        // 定义学校对象
        College college = null;

        // 获取数据库连接
        Connection conn =   ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "SELECT * FROM t_college WHERE id = ?";
        try {
            // 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            pstmt.setInt(1, id);
            // 执行查询操作，返回结果集
            ResultSet rs = pstmt.executeQuery();
            // 判断结果集是否为空
            if (rs.next()) {
                // 创建学校对象
                college = new College();
                // 利用当前记录字段值设置学校对象属性值
                college.setId(rs.getInt("id"));
                college.setName(rs.getString("name"));
                college.setPresident(rs.getString("president"));
                college.setStartTime(rs.getTimestamp("start_time"));
                college.setEmail(rs.getString("email"));
                college.setAddress(rs.getString("address"));
                college.setProfile(rs.getString("profile"));
            }
            // 关闭结果集
            rs.close();
            //关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            System.err.println(e.getMessage());
        } finally {
            ConnectionManager.closeConnection(conn); // 关闭数据库连接
        }

        // 返回学校对象
        return college;
    }

    @Override
    public int update(College college) {
        return 0;
    }
}
（2）编写更新学校记录方法
@Override // 更新学校记录                                                                                                                    
public int update(College college) {                                                                                                   
    // 定义更新记录数                                                                                                                         
    int count = 0;                                                                                                                     
    // 获取数据库连接                                                                                                                         
    Connection conn =   ConnectionManager.getConnection();                                                                             
    // 定义SQL语句对象                                                                                                                       
    String strSQL = "UPDATE t_college SET name = ?, president = ?, start_time = ?, email = ?, address = ?, profile = ? WHERE id = ?";  
    try {                                                                                                                              
        // 创建预备语句对象                                                                                                                    
        PreparedStatement pstmt = conn.prepareStatement(strSQL);                                                                       
        // 设置占位符的值                                                                                                                     
        pstmt.setString(1, college.getName());                                                                                         
        pstmt.setString(2, college.getPresident());                                                                                    
        pstmt.setTimestamp(3, new Timestamp(college.getStartTime().getTime()));                                                        
        pstmt.setString(4, college.getEmail());                                                                                        
        pstmt.setString(5, college.getAddress());                                                                                      
        pstmt.setString(6, college.getProfile());                                                                                      
        pstmt.setInt(7, college.getId());                                                                                              
        // 执行更新操作，返回更新记录数                                                                                                              
        count = pstmt.executeUpdate();                                                                                                 
        // 关闭预备语句对象                                                                                                                    
        pstmt.close();                                                                                                                 
    } catch (SQLException e) {                                                                                                         
        System.err.println(e.getMessage());                                                                                            
    } finally {                                                                                                                        
        ConnectionManager.closeConnection(conn); // 关闭数据连接                                                                             
    }                                                                                                                                  
                                                                                                                                       
                                                                                                                                       
    // 返回更新记录数                                                                                                                         
    return count;                                                                                                                      
}

1_、测试学校数据访问接口实现类

  • 在test目录里创建net.zhong.student.dao.impl包，在包里创建TestCollegeDaoImpl类
    在这里插入图片描述
（1）编写测试按标识符查询学校记录方法
package net.zhong.student.dao.impl;

import net.zhong.student.bean.College;
import net.zhong.student.dao.CollegeDao;
import org.junit.Test;

/**
 * 功能：测试学校数据访问接口实现类
 * 作者：钟城翔
 * 日期：2023年06月14日
 */
public class TestCollegeDaoImpl {
    @Test // 测试按标识符查询学校记录
    public void testFindById() {
        // 定义标识符变量
        int id = 1;
        // 创建学校数据访问接口对象
        CollegeDao collegeDao = new CollegeDaoImpl();
        // 调用按标识符查询学校记录方法
        College college = collegeDao.findById(id);
        // 判断查询是否成功
        if (college != null) {
            System.out.println("标识符：" + college.getId());
            System.out.println("学校名称：" + college.getName());
            System.out.println("校长：" + college.getPresident());
            System.out.println("建校时间：" + college.getStartTime());
            System.out.println("电子邮箱：" + college.getEmail());
            System.out.println("通讯地址：" + college.getAddress());
            System.out.println("学校概况：" + college.getProfile());
        }else {
            System.out.println("标识符为[" + id + "]的学校记录不存在~");
        }
    }
}
  • 运行testFindById()方法，查看结果
    在这里插入图片描述
  • 修改标识符变量值，再运行测试方法，查看结果
（2）编写测试更新学校记录方法
@Test // 测试更新学校记录                                              
public void testUpdate() {                                     
    // 创建学校数据访问接口对象                                            
    CollegeDao collegeDao = new CollegeDaoImpl();              
    // 获取标识符为1的学校记录                                            
    College college = collegeDao.findById(1);                  
    // 输出更新前的学校信息                                              
    System.out.println("更新前：" + college);                      
    // 设置学校对象属性                                                
    college.setName("泸职院");                                    
    college.setPresident("飞飞");                                
    college.setProfile("泸职院是省双高建设单位......");                   
    // 调用更新学校记录方法                                              
    int count = collegeDao.update(college);                    
    // 判断更新是否成功                                                
    if (count > 0) {                                           
        System.out.println("恭喜，学校记录更新成功~");                    
        System.out.println("更新后：" + collegeDao.findById(1));   
    }else {                                                    
        System.out.println("遗憾，学校记录更新失败~");                    
    }                                                          
}
  • 运行testUpdate()方法，查看结果
    在这里插入图片描述

2、创建状态数据访问接口实现类

  • 在net.zhong.student.dao.impl包里创建StatusDaoImpl类
    在这里插入图片描述
package net.zhong.student.dao.impl;

import net.zhong.student.bean.Status;
import net.zhong.student.dao.StatusDao;
import net.zhong.student.dbutil.ConnectionManager;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * 功能：状态数据访问接口实现类
 * 作者：钟城翔
 * 日期：2023年06月14日
 */
public class StatusDaoImpl implements StatusDao {

    @Override // 按标识符查询状态记录
    public Status findById(int id) {
        // 定义状态对象
        Status status = null;

        // 获取数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 定义SQL字符串
        String strSQL = "SELECT * FROM t_status WHERE id = ?";
        try{
            // 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            pstmt.setInt(1,id);
            // 执行查询操作，返回结果集
            ResultSet rs = pstmt.executeQuery();
            // 判断结果集是否为空
            if (rs.next()){
                //创建状态对象
                status = new Status();
                // 利用当前记录字段值设置状态对象属性
                status.setId(rs.getInt("id"));
                status.setCollege(rs.getString("college"));
                status.setVersion(rs.getString("version"));
                status.setAuthor(rs.getString("author"));
                status.setTelephone(rs.getString("telephone"));
                status.setAddress(rs.getString("address"));
                status.setEmail(rs.getString("email"));
            }
            // 关闭预备语句对象
            pstmt.close();
            // 关闭结果集对象
            rs.close();
        } catch (SQLException e) {
            System.err.println(e.getMessage());
        }finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }
        // 返回状态对象
        return status;
    }

    @Override
    public int update(Status status) {
        // 定义更新记录
        int count = 0;

        // 获得数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 定义SQl字符串
        String strSQL = "update t_status set college = ?,version = ?,author = ?," + "telephone = ?,address = ?,email = ? where id = ?";
        try{
            // 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 设置占位符的值
            pstmt.setString(1,status.getCollege());
            pstmt.setString(2,status.getVersion());
            pstmt.setString(3,status.getAuthor());
            pstmt.setString(4,status.getTelephone());
            pstmt.setString(5,status.getAddress());
            pstmt.setString(6,status.getEmail());
            pstmt.setInt(7,status.getId());
            // 执行更新操作，更新记录
            count = pstmt.executeUpdate();
            // 关闭预备语句对象
            pstmt.close();

        } catch (SQLException e) {
            System.err.println(e.getMessage());
        }finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }
        // 返回更新连接
        return count;
    }
}

2_、测试状态数据访问接口实现类

  • 在net.hw.student.test包里创建测试类TestStatusDaoImpl
    在这里插入图片描述
（1）编写测试方法testFindById()
package net.zhong.student.dao.impl;

import net.zhong.student.bean.Status;
import net.zhong.student.dao.StatusDao;
import org.junit.Test;

/**
 * 功能：测试状态数据访问接口实现类
 * 作者：钟城翔
 * 日期：2023年06月14日
 */
public class TestStatusDaoImpl {
    @Test // 测试按标识符查询状态记录
    public void testFindById() {
        // 定义标识符变量
        int id = 1;
        // 创建状态数据访问接口对象
        StatusDao statusDao = new StatusDaoImpl();
        // 调用按标识符查询状态记录方法
        Status status = statusDao.findById(id);
        // 判断查询是否成功
        if (status != null) {
            System.out.println(status);
        }else {
            System.out.println("标识符为[" + id + "]的状态记录不存在~");
        }
    }

    @Test // 测试更新状态记录
    public void testUpdate() {
        // 创建状态数据访问接口对象
        StatusDao statusDao = new StatusDaoImpl();
        // 获取标识符为1的状态记录
        Status status = statusDao.findById(1);
        // 输出更新的状态记录
        System.out.println("更新前：" + status);
        // 设置状态对象属性
        status.setCollege("泸州职业技术学院");
        status.setVersion("2.0");
        status.setVersion("钟");
        status.setTelephone("18982463589");
        status.setEmail("2950823446@qq.com");
        status.setAddress("泸州江阳区长桥路2号");
        // 调用更新状态记录方法
        int count = statusDao.update(status);
        // 判断更新是否成功
        if (count > 0) {
            System.out.println("状态记录更新成功！");
            System.out.println(statusDao.findById(1));
        }else {
            System.out.println("状态记录更新失败！");
        }
    }
}

3、创建学生数据访问接口实现类

  • 学生数据访问接口实现类StudentDaoImpl
    在这里插入图片描述
package net.zhong.student.dao.impl;

import net.zhong.student.bean.Student;
import net.zhong.student.dao.StudentDao;
import net.zhong.student.dbutil.ConnectionManager;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

/**
 * 功能：学生数据访问接口实现类
 * 作者：钟城翔
 * 日期：2023年06月15日
 */
public class StudentDaoImpl implements StudentDao {
    /**
     * 插入学生记录
     *
     * @param student
     * @return 插入记录数
     */
    @Override
    public int insert(Student student) {
        // 定义插入记录数
        int count = 0;

        // 1. 获得数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String strSQL = "insert into t_student (id, name, sex, department, class, telephone)" + "values (?, ?, ?, ?, ?, ?)";
        try {
            // 3. 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 4. 设置占位符语句
            pstmt.setString(1, student.getId());
            pstmt.setString(2, student.getName());
            pstmt.setString(3, student.getSex());
            pstmt.setString(4, student.getDepartment());
            pstmt.setString(5, student.getClazz());
            pstmt.setString(6, student.getTelephone());
            // 5. 执行SQL，返回插入记录数
            count = pstmt.executeUpdate();
            // 6. 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

        // 返回插入记录数
        return count;
    }

    /**
     * 按学号删除学生记录
     *
     * @param id
     * @return 删除记录数
     */

    @Override
    public int deleteById(String id) {
        // 定义删除记录数
        int count = 0;

        // 1. 获取数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String strSQL = "delete from t_student where id = ?";
        try {
            // 3. 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 4. 设置占位符的值
            pstmt.setString(1, id);
            // 5. 执行SQL，返回删除记录数
            count = pstmt.executeUpdate();
            // 6. 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

        // 返回删除记录数
        return count;
    }

    /**
     * 按班级删除学生记录
     *
     * @param clazz
     * @return 删除记录数
     */

    @Override
    public int deleteByClass(String clazz) {
        // 定义删除记录数
        int count = 0;

        // 1. 获取数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String strSQL = "delete from t_student where class = ?";
        try {
            // 3. 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 4. 设置占位符的值
            pstmt.setString(1, clazz);
            // 5. 执行SQL，返回删除记录数
            count = pstmt.executeUpdate();
            // 6. 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }
        return count;
    }

    /**
     * 按系部删除学生记录
     *
     * @param department
     * @return 删除记录数
     */

    @Override
    public int deleteByDepartment(String department) {
        // 定义删除记录数
        int count = 0;

        // 1. 获取数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String strSQL = "delete from t_student where department = ?";
        try {
            // 3. 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 4. 设置占位符的值
            pstmt.setString(1, department);
            // 5. 执行SQL，返回删除记录数
            count = pstmt.executeUpdate();
            // 6. 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }
        return count;
    }

    /**
     * 更新学生记录
     *
     * @param student
     * @return 更新记录数
     */

    @Override
    public int update(Student student) {
        // 定义更新记录数
        int count = 0;

        // 1. 获取数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL语句
        String strSQL = "update t_student set name = ?, sex = ?, department = ?, class = ?, telephone = ? where id = ?";
        try {
            // 3. 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 4. 设置占位符的值
            pstmt.setString(1, student.getName());
            pstmt.setString(2, student.getSex());
            pstmt.setString(3, student.getDepartment());
            pstmt.setString(4, student.getClazz());
            pstmt.setString(5, student.getTelephone());
            pstmt.setString(6, student.getId());
            // 5. 执行SQL，返回更新记录数
            count = pstmt.executeUpdate();
            // 6. 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

        // 返回更新记录数
        return count;
    }

    /**
     * 按学号查询学生记录
     *
     * @param id
     * @return 更新记录数
     */

    @Override
    public Student findById(String id) {
        // 声明学生对象
        Student student = null;

        // 1. 获取数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL语句
        String strSQL = "select * from t_student where id = ?";
        try {
            // 3. 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 4. 设置占位符的值
            pstmt.setString(1, id);
            // 5. 执行SQL，返回结果集
            ResultSet rs = pstmt.executeQuery();
            // 6. 判断结果集是否有记录
            if (rs.next()) {
                // 创建学生实体
                student = new Student();
                // 利用当前记录各字段值设置学生实体属性
                student.setId(rs.getString("id"));
                student.setName(rs.getString("name"));
                student.setSex(rs.getString("sex"));
                student.setDepartment(rs.getString("department"));
                student.setClazz(rs.getString("class"));
                student.setTelephone(rs.getString("telephone"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

        // 返回学生对象
        return student;
    }

    /**
     * 按姓名查询学生记录
     *
     * @param name
     * @return 学生列表
     */

    @Override
    public List<Student> findByName(String name) {
        // 声明学生列表
        List<Student> students = new ArrayList<>();

        // 1. 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String strSQL = "select * from t_student where name like ?";
        try {
            // 3. 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 4. 设置占位符的值
            pstmt.setString(1, name + "%");
            // 5. 执行SQL，返回结果集
            ResultSet rs = pstmt.executeQuery();
            // 6. 遍历结果集
            while (rs.next()) {
                // 创建学生实体
                Student student = new Student();
                // 利用当前记录各字段值设置学生实体属性
                student.setId(rs.getString("id"));
                student.setName(rs.getString("name"));
                student.setSex(rs.getString("sex"));
                student.setDepartment(rs.getString("department"));
                student.setClazz(rs.getString("class"));
                student.setTelephone(rs.getString("telephone"));
                // 将实体添加到学生列表
                students.add(student);
            }
            // 7. 关闭结果集
            rs.close();
            // 8. 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }
        // 返回学生列表
        return students;
    }

    /**
     * 按班级查询学生记录
     *
     * @param clazz
     * @return 学生列表
     */

    @Override
    public List<Student> findByClass(String clazz) {
        // 声明学生列表
        List<Student> students = new ArrayList<>();

        // 1. 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String strSQL = "select * from t_student where class like ?";
        try {
            // 3. 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 4. 设置占位符的值
            pstmt.setString(1, clazz + "%");
            // 5. 执行SQL，返回结果集
            ResultSet rs = pstmt.executeQuery();
            // 6. 遍历结果集
            while (rs.next()) {
                // 创建学生实体
                Student student = new Student();
                // 利用当前记录各字段值设置学生实体属性
                student.setId(rs.getString("id"));
                student.setName(rs.getString("name"));
                student.setSex(rs.getString("sex"));
                student.setDepartment(rs.getString("department"));
                student.setClazz(rs.getString("class"));
                student.setTelephone(rs.getString("telephone"));
                // 将实体添加到学生列表
                students.add(student);
            }
            // 7. 关闭结果集
            rs.close();
            // 8. 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }
        // 返回学生列表
        return students;
    }

    /**
     * 按系部查询学生记录
     *
     * @param department
     * @return 学生列表
     */

    @Override
    public List<Student> findByDepartment(String department) {
            // 声明学生列表
            List<Student> students = new ArrayList<>();

            // 1. 获取数据库连接对象
            Connection conn = ConnectionManager.getConnection();
            // 2. 定义SQL字符串
            String strSQL = "select * from t_student where department like ?";
            try {
                // 3. 创建预备语句对象
                PreparedStatement pstmt = conn.prepareStatement(strSQL);
                // 4. 设置占位符的值
                pstmt.setString(1, department + "%");
                // 5. 执行SQL，返回结果集
                ResultSet rs = pstmt.executeQuery();
                // 6. 遍历结果集
                while (rs.next()) {
                    // 创建学生实体
                    Student student = new Student();
                    // 利用当前记录各字段值设置学生实体属性
                    student.setId(rs.getString("id"));
                    student.setName(rs.getString("name"));
                    student.setSex(rs.getString("sex"));
                    student.setDepartment(rs.getString("department"));
                    student.setClazz(rs.getString("class"));
                    student.setTelephone(rs.getString("telephone"));
                    // 将实体添加到学生列表
                    students.add(student);
                }
                // 7. 关闭结果集
                rs.close();
                // 8. 关闭预备语句对象
                pstmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }finally {
                // 关闭数据库连接
                ConnectionManager.closeConnection(conn);
            }
            // 返回学生列表
            return students;
    }

    /**
     * 查询全部学生记录
     *
     * @return 学生列表
     */

    @Override
    public List<Student> findAll() {
        // 声明学生列表
        List<Student> students = new ArrayList<>();

        // 1. 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String strSQL = "select * from t_student";
        try {
            // 3. 创建语句对象
            Statement stmt = conn.createStatement();
            // 4. 执行SQL，返回结果集
            ResultSet rs = stmt.executeQuery(strSQL);
            // 5. 遍历结果集
            while (rs.next()) {
                // 创建学生实体
                Student student = new Student();
                // 利用当前记录各字段设置学生实体属性
                student.setId(rs.getString("id"));
                student.setName(rs.getString("name"));
                student.setSex(rs.getString("sex"));
                student.setDepartment(rs.getString("department"));
                student.setClazz(rs.getString("class"));
                student.setTelephone(rs.getString("telephone"));
                // 将实体添加到学生列表
                students.add(student);
            }
            // 6. 关闭结果集
            rs.close();
            // 7. 关闭语句对象
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

        // 返回学生列表
        return students;
    }

    /**
     * 按性别统计学生人数
     *
     * @return 统计结果向量
     */

    @Override
    public Vector findRowsBySex() {
        // 定义行集向量
        Vector rows = new Vector();

        // 1. 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String strSQL = "select sex as '性别', count(*) as '人数' from t_student group by sex order by sex desc";
        try {
            // 3. 创建语句对象
            Statement stmt = conn.createStatement();
            // 4. 执行SQL，返回结果集
            ResultSet rs = stmt.executeQuery(strSQL);
            // 5. 遍历结果集
            while (rs.next()) {
                // 定义当前行向量
                Vector<String> currentRow = new Vector();
                // 利用当前记录字段值设置当前行向量的元素值
                currentRow.addElement(rs.getString("性别"));
                currentRow.addElement(rs.getInt("人数") + "");
                // 将当前行向量添加到行集向量
                rows.addElement(currentRow);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

        // 返回行集向量
        return rows;
    }

    /**
     * 按班级统计学生人数
     *
     * @return 统计结果向量
     */

    @Override
    public Vector findRowsByClass() {
        // 定义行集向量
        Vector rows = new Vector();

        // 1. 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String strSQL = "select class as '班级', count(*) as '人数' from t_student group by class order by class desc";
        try {
            // 3. 创建语句对象
            Statement stmt = conn.createStatement();
            // 4. 执行SQL，返回结果集
            ResultSet rs = stmt.executeQuery(strSQL);
            // 5. 遍历结果集
            while (rs.next()) {
                // 定义当前行向量
                Vector<String> currentRow = new Vector();
                // 利用当前记录字段值设置当前行向量的元素值
                currentRow.addElement(rs.getString("班级"));
                currentRow.addElement(rs.getInt("人数") + "");
                // 将当前行向量添加到行集向量
                rows.addElement(currentRow);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

        // 返回行集向量
        return rows;
    }

    /**
     * 按系部统计学生人数
     *
     * @return 统计结果向量
     */

    @Override
    public Vector findRowsByDepartment() {
        // 定义行集向量
        Vector rows = new Vector();

        // 1. 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String strSQL = "select department as '系部', count(*) as '人数' from t_student group by department order by department desc";
        try {
            // 3. 创建语句对象
            Statement stmt = conn.createStatement();
            // 4. 执行SQL，返回结果集
            ResultSet rs = stmt.executeQuery(strSQL);
            // 5. 遍历结果集
            while (rs.next()) {
                // 定义当前行向量
                Vector<String> currentRow = new Vector();
                // 利用当前记录字段值设置当前行向量的元素值
                currentRow.addElement(rs.getString("系部"));
                currentRow.addElement(rs.getInt("人数") + "");
                // 将当前行向量添加到行集向量
                rows.addElement(currentRow);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

        // 返回行集向量
        return rows;
    }
}

3_、测试学生数据访问接口实现类

  • 在net.zhong.student.test包里创建测试类TestStudentDaoImpl
    在这里插入图片描述
(1) 编写测试方法testInsert()

在这里插入图片描述

  • 运行该测试方法，查看结果
    在这里插入图片描述
(2）编写测试方法testDeleteById()

在这里插入图片描述

  • 运行该测试方法，查看结果
    在这里插入图片描述
（3）编写测试方法testDeleteByClass()

在这里插入图片描述

  • 运行该测试方法，查看结果
    在这里插入图片描述
（4）编写测试方法testFindByDepartment()

在这里插入图片描述

  • 运行该测试方法，查看结果
    在这里插入图片描述

  • 修改待查学生的学院
    在这里插入图片描述

  • 运行该测试方法，查看结果
    在这里插入图片描述

（5）编写测试方法testFindAll()

在这里插入图片描述

  • 运行该测试方法，查看结果
    在这里插入图片描述
（6）编写测试方法testFindRowsBySex()

在这里插入图片描述

  • 运行该测试方法，查看结果
    在这里插入图片描述
（7）编写测试方法testFindRowsByClass()

在这里插入图片描述

  • 运行该测试方法，查看结果
    在这里插入图片描述
（8）编写测试方法testFindRowsByDepartment()

在这里插入图片描述

  • 运行该测试方法，查看结果
    在这里插入图片描述

4、创建用户数据访问接口实现类

  • 创建用户数据访问接口实现类UserDaoImpl
    在这里插入图片描述

4_、测试用户数据访问接口实现类

  • 在test目录的net.zhong.student.dao.impl包里创建TestUserDaoImpl类
    在这里插入图片描述
城-
关注
Java实训日志1
qq_45978394的博客
07-01 3628
今天开始了第一次Java课程实训，实训项目是学生信息管理系统，了解了实训目的和简介后，开始了今天的小任务。 本次实训需要逐步完成的功能如下： 首先完成了实训项目的功能思维导图： 第一步是：创建一个名为student的数据库，用于后续实训任务的开展。 第二步：创建四张表 第四部：向表中插入部分数据。 总结：本次课内容是创建数据库与数据表，我按照老师的讲稿一步步完成，过程中没有遇见问题，希望下次课再接再厉。 ...
Java实训日志2
qq_45978394的博客
07-03 1507
上次课完成了数据库与数据表的创建。 一、开始前的准备 1.首先，创建好本次实训的项目，括号里以自己姓名命名。 2.在项目根目录创建三个文件夹，分别是help、images、lib。 3.把数据库驱动程序包放进lib目录， 作为库添加到项目里(右击数据库驱动程序----选择Add as Library);下载图片素材包，放进images目录下，更改背景图片，在图片上添加个人信息；在help里添加帮助文档。 注意：驱动程序下com.mysql文件下的jdbc里Driver类是非常重要的，数据库能否连接成
java实训日志05
naiber_的博客
06-14 51
创建数据访问接口实现类
java实习日志_Java毕业生校外实习日记
weixin_28869649的博客
02-12 8188
Java毕业生校外实习日记 信息工程系学生校外实习周记姓名 班级 学号周次 日期 实习内容与收获1 10-31这周老师主要是帮我们复习一下之前暑假学习的一些 Java 基础的内容，重要的内容有以下几点：一是：线程 Thread，主要是多用户同时工作；二是：集合 Collection，list,set,map,vector,proprity 这几个大类，主要需要掌握的内容是：arrarylist,l...
Java实训日志
2303_76911615的博客
06-12 122
安装软件及使用
Java实训日志5
qq_45978394的博客
07-10 801
小结        本次我接着上次课的内容，完成了创建用户数据访问接口实现类UserDaoImpl,完成了相应的测试代码。跟着老师一起完成了学校服务接口的创建，创建学校服务接口实现类，测试学校服务接口实现类，用服务接口调用数据访问接口。自己完成剩下的服务接口创建。 1.编写测试类 编写TestUserDaoImpl测试类： 跟着老师博客上的内容编写了以下方法： 编写了测试方法testFindById()； 编写了测试方法testLogin
java实训日志7
2302_76411479的博客
06-18 340
文章目录八、项目开发实现步骤（十）创建应用程序类1、创建app子包2、创建Application类（十一）创建窗口界面类1、创建主界面窗口2、创建用户登录窗口3、创建用户注册窗口RegisterFrame4、创建设置学校信息窗口SetCollegeInfoFrame5、创建修改用户密码窗口ChangePasswordFrame7、创建添加学生窗口AddStudentFrame8、创建添加学生窗口EditStudentFrame9、创建按学号删除学生窗口DeleteStudentByIdFrame10、创建按
Java实训日志4
qq_45978394的博客
07-10 897
小结 上次课我创建了四个接口，创建了学校数据访问接口实现类，创建了教师数据访问接口实现类，并编写了两个测试类完成他们的测试。本次课的实训内容是继续完成创建数据访问接口实现类。分别创建学生数据访问接口实现类和用户数据访问接口实现类，本次课我完成了学生数据接口实现类和他对应的测试代码。 编写测试方法： 以下是TestStudentDaoImpl类的部分方法（这部分是按照老师博客上的写的） package net.jxm.student.test; import net.jxm.student.bean.S
java毕业实习日志_java毕业实习日记.doc
weixin_35968185的博客
02-13 3546
java毕业实习日记java毕业实习日记篇一：JAVA毕业实习日志实习日志实习日志(一)经过一天一夜的行程，终于到了这座美丽的城市——青岛。拖着疲惫的身躯走出车站的那一瞬间，迎面扑来的海水的味道，将心底的那一丝疲惫伴着海风悄然的吹走。第一次如此近距离的接触海，第一次接受海风的洗礼，我的心彷佛飘荡在那泛着层层浪花的海里。到了实训基地，我看到了久别的几个同学也是永远的同学，感到分外的高兴，每一个人都充...
java毕业实习日志_《Java课程实习》日志（周一）
weixin_35503004的博客
02-16 1677
因为我周一的时候做的《第三个作业：网络编程》没有发日志，所以现在发在此日志里，相当于补发。《Java程序设计》第三次作业：网络编程作业的目标 目标1：Socket简单应用。 目标2：博文统计程序。先做目标1，首先，把教材P238中例11-5代码敲下来，还有一些步骤就不具体用文字写出来了：(1)import java.io.*;import java.net.*;public class Chat...
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 231
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 289
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 912
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
Backend - Java 基础
是萝卜干呀的博客
10-11 836
知识量决定了未来能走多远
JavaWeb Servlet--09深入：注册系统04--修改页面
weixin_62189092的博客
10-16 176
这里就会获取要修改的用户的id，返回用户，再把这个用户重定向跳转到update.jsp页面。在再UserServlet里书写修改的代码。分析：点击修改超链接，就跳转到一个修改界面，要显示原本的数据，且密码显示出来，在该页面将对用户的数据的进行修改，最后提交。findUserByID()----显示原本的内容，update()---修改数据库内容的方法。注意：修改信息是要展示密码的文本内容，所以在password处type="text";写法和register没有太大的区别，主要是对文本框获得值。
java在线招投标|评标|竞标|单一采购|邀标|评审专家|采购软件源码
最新发布
m0_72864708的博客
10-16 219
主要功能包含：招标公告管理、变更公告管理、终止公告管理、中标候选人公告管理、中标公告管理、采购公告管理、采购结果公告管理、单一来源采购结果公告管理。3、采购项目管理：可对项目采购过程全流程管理，包含功能有：评审人员的选取/抽取、基准价维护、供应商缴费审核、投标过程记录查询、供应商报价维护、项目评审查询、线下项目管理、采购计划制定与维护。主要功能包含：公告模板管理、评审人员管理、第三方机构管理、供应商管理、采购类别设置、评审模板管理、考核模板管理。主要板块包含：招标公告、非招标公告、系统通知、政策法规。
JavaSE——认识异常
wx2023_10_15的博客
10-12 961
本文主要是正在学习异常的总结，主要讲了异常的概念、体系结构、分类、处理以及捕获，还有自定义异常类
初始Python篇（2）——逻辑控制、序列
我要学编程的博客
10-14 1097
程序的组织结构：顺序、选择、循环 pass空语句 猜数字小游戏 序列、序列相关操作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值