[Java知识库]JAVA期末项目学生管理系统

college

package c01.s01.t09.bean;

import java.sql.Date;
import java.sql.ResultSet;
import java.sql.Time;

/**
 * 功能：
 * 作者：
 * 日期：2022年06月10日
 */
public class College {
    private int id;
    private String username;
    private String password;
    private String telephone;
    private Time register_time;
    private String president;
    private String name;
    private ResultSet startTime;
    private String email;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getTelephone() {
        return telephone;
    }

    public void setTelephone(String telephone) {
        this.telephone = telephone;
    }

    public Time getRegister_time() { return register_time;    }

    public void setRegister_time(Time register_time) { this.register_time = register_time; }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", telephone='" + telephone + '\'' +
                ", registerTime=" + register_time +
                '}';
    }


    public void setPresident(String president) {
        this.president = president;
    }

    public String getPresident() {
        return president;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setStartTime(Date start_time) {

    }

    public void setEmail(String email) {

    }

    public void setAddress(String address) {

    }

    public void setProfile(String profile) {

    }

    public String getName() {
        return null;
    }

    public ResultSet getStartTime() {
        return startTime;
    }

    public String getEmail() {
        return email;
    }

    public String getProfile() {
        return null;
    }
}

status

package c01.s01.t09.bean;

/**
 * 功能：
 * 作者：
 * 日期：2022年06月10日
 */
public class Status {
    private int id;
    private String college;
    private String version;
    private String author;
    private String telephone;
    private String address;
    private String email;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getCollege() {
        return college;
    }

    public void setCollege(String username) {
        this.college = college;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String password) {
        this.version = version;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) { this.author = author;}

    public String getTelephone() {
        return telephone;
    }

    public void setTelephone(String telephone) {
        this.telephone = telephone;
    }

    public String getAdress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) { this.email = email;    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + college + '\'' +
                ", password='" + version + '\'' +
                ", telephone='" + author + '\'' +
                ", telephone='" + telephone + '\'' +
                ", telephone='" + address + '\'' +
                ", registerTime=" + email +
                '}';
    }


    public String getAddress() {
        return null;
    }
}

student

package c01.s01.t09.bean;

/**
 * 功能：
 * 作者：
 * 日期：2022年06月10日
 */
public class Student {
    private int id;
    private String name;
    private String sex;
    private int age;
    private String department;
    private String t_class ;
    private String telephone;

    public Student() {

    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() { return sex ; }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    public String getT_class() { return t_class ; }

    public void setT_class(String t_class) {
        this.sex = t_class;
    }

    public String getTelephone() { return telephone ; }

    public void setTelephone(String telephone) {this.telephone = telephone;    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + name + '\'' +
                ", username='" + sex + '\'' +
                ", username='" + age + '\'' +
                ", username='" + department + '\'' +
                ", username='" + t_class + '\'' +
                ", username='" + telephone + '\'' +
                '}';
    }

}

user

package c01.s01.t09.bean;

import java.util.Date;

/**
 * 功能：用户实体类
 * 作者：
 * 日期：
 */
public class User {
    private int id;
    private String username;
    private String password;
    private String telephone;
    private Date registerTime;

    public User() {

    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getTelephone() {
        return telephone;
    }

    public void setTelephone(String telephone) {
        this.telephone = telephone;
    }

    public Date getRegisterTime() {
        return registerTime;
    }

    public void setRegisterTime(Date registerTime) {
        this.registerTime = registerTime;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", telephone='" + telephone + '\'' +
                ", registerTime=" + registerTime +
                '}';
    }


}

t09.dao.impl(CollegeDaoImpl, StatusDaoImpl, StudentDaoImpl, UserDaoImpl)

package c01.s01.t09.dao.impl;
import c01.s01.t09.bean.Status;
import c01.s01.t09.dao.StatusDao;
import c01.s01.t09.dbutils.ConnectionManager;

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


/**
 * 功能：状态数据访问接口实现类
 * 作者:
 * 日期：
 */
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);
            // 执行SQL查询，返回结果集
            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"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } 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) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }

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

}`
``

```java
package c01.s01.t09.dao.impl;
import c01.s01.t09.bean.Status;
import c01.s01.t09.dao.StatusDao;
import c01.s01.t09.dbutils.ConnectionManager;

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


/**
 * 功能：状态数据访问接口实现类
 * 作者:
 * 日期：
 */
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);
            // 执行SQL查询，返回结果集
            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"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } 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) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }

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

}

package c01.s01.t09.dao.impl;

import c01.s01.t09.bean.Student;
import c01.s01.t09.dao.StudentDao;
import c01.s01.t09.dbutils.ConnectionManager;

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

/**
 * 功能：学生数据访问接口实现类
* 作者：
* 日期：
*/
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,age,department,class,telephone)"
                + "values(?,?,?,?,?,?,?)";
        try {
            // 3、创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 4、设置占位符的值
            pstmt.setInt(1,student.getId());
            pstmt.setString(2, student.getName());
            pstmt.setString(3,student.getSex());
            pstmt.setInt(4,student.getAge());
            pstmt.setString(5,student.getDepartment());
            pstmt.setString(6,student.getT_class());
            pstmt.setString(7,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 = ?, age = ?,"
                +"department = ?,class = ?,telephone = ? where id = ?";
        try {
            //3、创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            //4、设置占位符的值
            pstmt.setString(1,student.getName());
            pstmt.setString(2,student.getSex());
            pstmt.setInt(3,student.getAge());
            pstmt.setString(4,student.getDepartment());
            pstmt.setString(5,student.getT_class());
            pstmt.setString(6,student.getTelephone());
            pstmt.setInt(7,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.getInt("id"));
                student.setName(rs.getString("name"));
                student.setSex(rs.getString("sex"));
                student.setAge(rs.getInt("age"));
                student.setDepartment(rs.getString("department"));
                student.setT_class(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<Student>();

        //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.getInt("id"));
                student.setName(rs.getString("name"));
                student.setSex(rs.getString("sex"));
                student.setAge(rs.getInt("age"));
                student.setDepartment(rs.getString("department"));
                student.setT_class(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<Student>();

        // 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.getInt("id"));
                student.setName(rs.getString("name"));
                student.setSex(rs.getString("sex"));
                student.setAge(rs.getInt("age"));
                student.setDepartment(rs.getString("department"));
                student.setT_class(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<Student>();

        // 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.getInt("id"));
                student.setName(rs.getString("name"));
                student.setSex(rs.getString("sex"));
                student.setAge(rs.getInt("age"));
                student.setDepartment(rs.getString("department"));
                student.setT_class(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<Student>();

        // 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.getInt("id"));
                student.setName(rs.getString("name"));
                student.setSex(rs.getString("sex"));
                student.setAge(rs.getInt("age"));
                student.setDepartment(rs.getString("department"));
                student.setT_class(rs.getString("class"));
                student.setTelephone(rs.getString("telephone"));
                // 将实体添加到学生列表
                students.add(student);
            }
            // 6. 关闭结果集
            rs.close();
            // 7. 关闭语句对象
            stmt.close();
        } catch (SQLException e1) {
            e1.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;
    }
}

package c01.s01.t09.dao.impl;
import c01.s01.t09.bean.User;
import c01.s01.t09.dao.UserDao;
import c01.s01.t09.dbutils.ConnectionManager;

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

/**
 * 功能：用户数据访问接口实现类
 * 作者：
 * 日期：
 */
public class UserDaoImpl implements UserDao{
    /**
     * 插入用户记录
     *
     * @param user
     * @return 插入记录数
     */
    @Override
    public int insert(User user) {
        // 定义插入记录数
        int count = 0;

        // 1. 获得数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String strSQL = "insert into t_user (username, password, telephone, register_time)"
                + " values (?, ?, ?, ?)";
        try {
            // 3. 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 4. 设置占位符的值
            pstmt.setString(1, user.getUsername());
            pstmt.setString(2, user.getPassword());
            pstmt.setString(3,user.getTelephone());
            pstmt.setTimestamp(4, new Timestamp(user.getRegisterTime().getTime()));
            // 5. 执行SQL，返回插入记录数
            count = pstmt.executeUpdate();
            // 6. 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

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

    @Override
    public int delete(int id) {
        return 0;
    }

    /**
     * 按id删除用户记录
     *
     * @param id
     * @return 删除记录数
     */
    @Override
    public int deleteById(int id) {
        // 定义删除记录数
        int count = 0;

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

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

    /**
     * 更新用户记录
     *
     * @param user
     * @return 更新记录数
     */
    @Override
    public int update(User user) {
        // 定义更新记录数
        int count = 0;

        // 1. 获得数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String strSQL = "update t_user set username = ?, password = ?, telephone = ?,"
                + " register_time = ? where id = ?";
        try {
            // 3. 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 4. 设置占位符的值
            pstmt.setString(1, user.getUsername());
            pstmt.setString(2, user.getPassword());
            pstmt.setString(3, user.getTelephone());
            pstmt.setTimestamp(4, new Timestamp(user.getRegisterTime().getTime()));
            pstmt.setInt(5, user.getId());
            // 5. 执行SQL，返回更新记录数
            count = pstmt.executeUpdate();
            // 6. 关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

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

    /**
     * 按id查询用户
     *
     * @param id
     * @return 用户实体
     */
    @Override
    public User findById(int id) {
        // 声明用户对象
        User user = null;

        // 1. 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String strSQL = "select * from t_user where id = ?";
        try {
            // 3. 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 4. 设置占位符的值
            pstmt.setInt(1, id);
            // 5. 执行SQL，返回结果集
            ResultSet rs = pstmt.executeQuery();
            // 6. 判断结果集是否有记录
            if (rs.next()) {
                // 创建用户实体
                user = new User();
                // 利用当前记录各字段值设置用户实体属性
                user.setId(rs.getInt("id"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setTelephone(rs.getString("telephone"));
                user.setRegisterTime(rs.getTimestamp("register_time"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

        // 返回用户对象
        return user;
    }

    /**
     * 查询所有用户
     *
     * @return 用户列表
     */
    @Override
    public List<User> findAll() {
        // 声明用户列表
        List<User> users = new ArrayList<User>();

        // 1. 获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String strSQL = "select * from t_user";
        try {
            // 3. 创建语句对象
            Statement stmt = conn.createStatement();
            // 4. 执行SQL，返回结果集
            ResultSet rs = stmt.executeQuery(strSQL);
            // 5. 遍历结果集
            while (rs.next()) {
                // 创建用户实体
                User user = new User();
                // 利用当前记录各字段值设置用户实体属性
                user.setId(rs.getInt("id"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setTelephone(rs.getString("telephone"));
                user.setRegisterTime(rs.getTimestamp("register_time"));
                // 将实体添加到用户列表
                users.add(user);
            }
            // 6. 关闭结果集
            rs.close();
            // 7. 关闭语句对象
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

        // 返回用户列表
        return users;
    }

    /**
     * 用户登录
     *
     * @param username
     * @param password
     * @return 登录用户实体
     */
    @Override
    public User login(String username, String password) {
        // 声明用户对象
        User user = null;

        // 1. 获取数据库连接
        Connection conn = ConnectionManager.getConnection();
        // 2. 定义SQL字符串
        String strSQL = "select * from t_user where username = ? and password = ?";
        try {
            // 3. 创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            // 4. 设置占位符的值
            pstmt.setString(1, username);
            pstmt.setString(2, password);
            // 5. 执行SQL，返回结果集
            ResultSet rs = pstmt.executeQuery();
            // 6. 判断结果集是否有记录
            if (rs.next()) {
                // 实例化用户
                user = new User();
                // 利用当前记录各字段值设置用户实体属性
                user.setId(rs.getInt("id"));
                user.setUsername(rs.getString("username"));
                user.setPassword(rs.getString("password"));
                user.setTelephone(rs.getString("telephone"));
                user.setRegisterTime(rs.getTimestamp("register_time"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

        // 返回用户对象
        return user;
    }
}

c09.dao(CollegeDao, StatusDao, StudentDao, UserDao)

package c01.s01.t09.dao;

import c01.s01.t09.bean.College;

/**
 * 功能：学校数据访问接口
 * 作者：
 * 日期：
 */
public interface CollegeDao {
    College findById(int id);
    int update(College college);
}

package c01.s01.t09.dao;

        import c01.s01.t09.bean.Status;

/**
 * 功能：状态数据访问接口
 * 作者：
 * 日期：
 */
public interface StatusDao {
    Status findById(int id);
    int update(Status status);
}

package c01.s01.t09.dao;

import c01.s01.t09.bean.Student;

import java.util.List;
import java.util.Vector;

/**
 * 功能：学生数据访问接口
 * 作者：
 * 日期：
 */
public interface StudentDao {
    int insert(Student student);
    int deleteById(String id);
    int deleteByClass(String clazz);
    int deleteByDepartment(String department);
    int update(Student student);
    Student findById(String id);
    List<Student> findByName(String name);
    List<Student> findByClass(String clazz);
    List<Student> findByDepartment(String department);
    List<Student> findAll();
    Vector findRowsBySex();
    Vector findRowsByClass();
    Vector findRowsByDepartment();

}

package c01.s01.t09.dao;

import c01.s01.t09.bean.User;

import java.util.List;

/**
 * 功能：用户数据访问接口
 * 作者：
 * 日期：
 */
public interface UserDao {
    int insert(User user);
    int delete(int id);

    int deleteById(int id);

    int update(User user);
    User findById(int id);
    List<User> findAll();
    User login(String username, String password);
}

c09.dbutils

package c01.s01.t09.dbutils;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

/**
 * 功能：数据库连接管理类
 * 作者：
 * 日期：
 */
public class ConnectionManager {
    // 数据库连接属性
    private static final String DRIVER = "com.mysql.jdbc.Driver";
    private static final String URL = "jdbc:mysql://localhost:3306/student?useSSL=false";
    private static final String USER = "root";
    private static final String PASSWORD = "123456"; // 改成自己数据库的密码

    /**
     * 私有化构造方法，拒绝实例化
     */
    private ConnectionManager() {
    }

    /**
     * 获取数据库连接静态方法
     *
     * @return 数据库连接
     */
    public static Connection getConnection() {
        // 定义数据库连接
        Connection conn = null;

        try {
            // 安装数据库驱动
            Class.forName(DRIVER);
            // 获取数据库连接
            conn = DriverManager.getConnection(URL, USER, PASSWORD);
            // 提示用户数据库连接成功
            System.out.println("提示：数据库连接成功~");
        } catch (ClassNotFoundException e) {
            System.err.println("异常：数据库驱动程序未找到！");
        } catch (SQLException e) {
            System.err.println("异常：数据库连接失败！");
        }

        // 返回数据库连接
        return conn;
    }

    /**
     * 关闭数据库连接静态方法
     *
     * @param conn
     */
    public static void closeConnection(Connection conn) {
        // 判断连接是否为空
        if (conn != null) {
            try {
                // 判断连接是否关闭
                if (!conn.isClosed()) {
                    // 关闭数据库连接，释放资源
                    conn.close();
                    // 提示用户
                    System.out.println("提示：数据库连接关闭~");
                }
            } catch (SQLException e) {
                System.err.println(e.getMessage());
            }
        }
    }

    /**
     * 主方法测试数据库连接
     *
     * @param args
     */
    public static void main(String[] args) {
        // 获取数据库连接
        Connection conn = getConnection();
        // 关闭数据库连接
        closeConnection(conn);
    }
}

c09.gui.(AddFrame, ChangeFrame, DeleteFrame, LogonFrame, MainFrame, RegisterFrame, SeleteFrame, Start)

package c01.s01.t09.gui;

/**
 * 功能：
 * 作者：
 * 日期：
 */


import c03.SQLHelp;

import javax.swing.*;
import javax.swing.border.EmptyBorder;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.sql.SQLException;

public class AddFrame extends JFrame {

    private JPanel contentPane;
    private JTextField idField;
    private JTextField nameField;
    private JTextField genderField;
    private JTextField dobField;
    private JTextField batchField;

    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    AddFrame frame = new AddFrame();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public AddFrame() {
        // 和前面类似
        setResizable(false);
        setTitle("添加学生");
        // 这个地方，添加学生只是这个程序的一部分，所以当关闭这部分的时候，程序不直接退出，只是关闭该部分程序
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        setBounds(100, 100, 450, 470);
        setLocationRelativeTo(null);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPane);
        contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS));

        JPanel panel = new JPanel();
        contentPane.add(panel);
        panel.setLayout(null);

        JLabel TitleLabel = new JLabel("请输入新学生的信息：");
        TitleLabel.setFont(new Font("宋体", Font.BOLD, 20));
        TitleLabel.setBounds(71, 34, 220, 45);
        panel.add(TitleLabel);

        JLabel idLabel = new JLabel("学号：");
        idLabel.setFont(new Font("宋体", Font.PLAIN, 16));
        idLabel.setBounds(71, 105, 50, 30);
        panel.add(idLabel);

        idField = new JTextField();
        idField.setBounds(143, 99, 240, 45);
        panel.add(idField);
        idField.setColumns(10);

        JLabel nameLabel = new JLabel("姓名：");
        nameLabel.setFont(new Font("宋体", Font.PLAIN, 16));
        nameLabel.setBounds(71, 160, 50, 30);
        panel.add(nameLabel);

        nameField = new JTextField();
        nameField.setColumns(10);
        nameField.setBounds(143, 154, 240, 45);
        panel.add(nameField);

        JLabel genderLabel = new JLabel("性别：");
        genderLabel.setFont(new Font("宋体", Font.PLAIN, 16));
        genderLabel.setBounds(71, 215, 50, 30);
        panel.add(genderLabel);

        genderField = new JTextField();
        genderField.setColumns(10);
        genderField.setBounds(143, 209, 240, 45);
        panel.add(genderField);

        JLabel dobLabel = new JLabel("出生日期：");
        dobLabel.setFont(new Font("宋体", Font.PLAIN, 16));
        dobLabel.setBounds(41, 270, 80, 30);
        panel.add(dobLabel);

        dobField = new JTextField();
        dobField.setColumns(10);
        dobField.setBounds(143, 264, 240, 45);
        panel.add(dobField);

        JLabel batchLabel = new JLabel("班级：");
        batchLabel.setFont(new Font("宋体", Font.PLAIN, 16));
        batchLabel.setBounds(71, 325, 50, 30);
        panel.add(batchLabel);

        batchField = new JTextField();
        batchField.setColumns(10);
        batchField.setBounds(143, 319, 240, 45);
        panel.add(batchField);

        JButton addButton = new JButton("添加");
        // 添加鼠标监听事件
        addButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                // 先取出数据
                // getText() 返回字符串类型的
                // Integer.parseInt 数据类型转换
                int id = Integer.parseInt(idField.getText());

                String nameString = nameField.getText();

                String genderString = genderField.getText();

                String dobfieldString = dobField.getText();

                int batch = Integer.parseInt(batchField.getText());
                // 输出一下学生的信息，方便修改
                System.out.println(id + "\t" + nameString + "\t" + genderString + "\t" + dobfieldString + "\t" + batch);
                // SQLHelp 是自己写的一个工具类
                SQLHelp sqlHelp = new SQLHelp();
                try {
                    // 调用添加学生信息的方法
                    sqlHelp.addStudent(id, nameString, genderString, dobfieldString, batch);
                    // 弹出对话框，提示用户添加成功
                    JOptionPane.showMessageDialog(AddFrame.this, "添加成功！");
                } catch (SQLException e1) {
                    // 这里捕获一下异常，因为学生的学号是唯一的，所以当学号已经存在的时候，提示用户，该学生信息已存在
                    // 异常代码为 23000
                    if(e1.getSQLState().equals("23000")) {
                        JOptionPane.showMessageDialog(AddFrame.this, "添加失败!该学生已存在");
                    }
                    e1.printStackTrace();
                }

            }
        });
        addButton.setFont(new Font("宋体", Font.PLAIN, 18));
        addButton.setBounds(182, 389, 97, 33);
        panel.add(addButton);
    }
}

package c01.s01.t09.gui;

/**
 * 功能：
 * 作者：
 * 日期：2022年06月11日
 */


import c03.SQLHelp;
import c03.Student;

import javax.swing.*;
import javax.swing.border.EmptyBorder;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.sql.SQLException;

public class ChangeFrame extends JFrame {

    private JPanel contentPane;
    private JTextField idField;
    private JTextField nameField;
    private JTextField genderField;
    private JTextField dobField;
    private JTextField batchField;
    private JTextField searchField;


    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    ChangeFrame frame = new ChangeFrame();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public ChangeFrame() {
        setResizable(false);
        setTitle("修改信息");
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        setBounds(100, 100, 450, 470);
        setLocationRelativeTo(null);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPane);
        contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS));

        JPanel panel = new JPanel();
        contentPane.add(panel);
        panel.setLayout(null);

        JLabel lblNewLabel = new JLabel("请输入要修改的学生的学号：");
        lblNewLabel.setFont(new Font("宋体", Font.PLAIN, 16));
        lblNewLabel.setBounds(71, 0, 208, 29);
        panel.add(lblNewLabel);

        JLabel lblNewLabel_1 = new JLabel("学号：");
        lblNewLabel_1.setFont(new Font("宋体", Font.PLAIN, 16));
        lblNewLabel_1.setBounds(71, 105, 50, 30);
        panel.add(lblNewLabel_1);

        idField = new JTextField();
        idField.setEditable(false);
        idField.setBounds(143, 99, 240, 45);
        panel.add(idField);
        idField.setColumns(10);

        JLabel lblNewLabel_1_1 = new JLabel("姓名：");
        lblNewLabel_1_1.setFont(new Font("宋体", Font.PLAIN, 16));
        lblNewLabel_1_1.setBounds(71, 160, 50, 30);
        panel.add(lblNewLabel_1_1);

        nameField = new JTextField();
        nameField.setColumns(10);
        nameField.setBounds(143, 154, 240, 45);
        panel.add(nameField);

        JLabel lblNewLabel_1_1_1 = new JLabel("性别：");
        lblNewLabel_1_1_1.setFont(new Font("宋体", Font.PLAIN, 16));
        lblNewLabel_1_1_1.setBounds(71, 215, 50, 30);
        panel.add(lblNewLabel_1_1_1);

        genderField = new JTextField();
        genderField.setColumns(10);
        genderField.setBounds(143, 209, 240, 45);
        panel.add(genderField);

        JLabel lblNewLabel_1_1_1_1 = new JLabel("出生日期：");
        lblNewLabel_1_1_1_1.setFont(new Font("宋体", Font.PLAIN, 16));
        lblNewLabel_1_1_1_1.setBounds(41, 270, 80, 30);
        panel.add(lblNewLabel_1_1_1_1);

        dobField = new JTextField();
        dobField.setColumns(10);
        dobField.setBounds(143, 264, 240, 45);
        panel.add(dobField);

        JLabel lblNewLabel_1_1_1_2 = new JLabel("班级：");
        lblNewLabel_1_1_1_2.setFont(new Font("宋体", Font.PLAIN, 16));
        lblNewLabel_1_1_1_2.setBounds(71, 325, 50, 30);
        panel.add(lblNewLabel_1_1_1_2);

        batchField = new JTextField();
        batchField.setColumns(10);
        batchField.setBounds(143, 319, 240, 45);
        panel.add(batchField);

        JButton changeButton = new JButton("修改");
        changeButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) {

                int id = Integer.parseInt(searchField.getText());

                String nameString = nameField.getText();

                String gendeString = genderField.getText();

                String dobString = dobField.getText();

                String batch = batchField.getText();

                SQLHelp sqlHelp = new SQLHelp();

                try {
                    sqlHelp.changeStudent(id, nameString, gendeString, dobString, batch);

                    JOptionPane.showMessageDialog(ChangeFrame.this, "修改成功！");
                } catch (SQLException e) {
                    JOptionPane.showMessageDialog(ChangeFrame.this, "修改失败！");
                    e.printStackTrace();
                }

            }
        });
        changeButton.setFont(new Font("宋体", Font.PLAIN, 18));
        changeButton.setBounds(182, 389, 97, 33);
        panel.add(changeButton);

        searchField = new JTextField();
        searchField.setBounds(71, 39, 208, 45);
        panel.add(searchField);
        searchField.setColumns(10);

        JButton searchButton = new JButton("查找");
        searchButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e){

                int id = Integer.parseInt(searchField.getText());

                try {

                    SQLHelp sqlHelp = new SQLHelp();

                    Student student = sqlHelp.queryStudent(id);

                    if(student != null) {

                        // id 是直接读入的，所以就不需要从数据库中读出了
                        idField.setText(String.valueOf(id));
                        nameField.setText(student.getName());
                        genderField.setText(student.getGender());
                        dobField.setText(student.getDob());
                        batchField.setText(String.valueOf(student.getBatch()));

                    } else {
                        JOptionPane.showMessageDialog(ChangeFrame.this, "无此用户");
                    }

                } catch (SQLException e1) {
                    e1.printStackTrace();
                }

            }
        });
        searchButton.setFont(new Font("宋体", Font.PLAIN, 18));
        searchButton.setBounds(289, 42, 97, 39);
        panel.add(searchButton);
    }
}

package c01.s01.t09.gui;

/**

• 功能：
• 作者：
• 日期：2022年06月11日
  */

import c03.SQLHelp;
import c03.Student;

import javax.swing.;
import javax.swing.border.EmptyBorder;
import java.awt.;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.sql.SQLException;

class QueryFrame extends JFrame {

private JPanel contentPane;
private JTextField idField;
private JTextField nameField;
private JTextField genderField;
private JTextField dobField;
private JTextField batchField;
private JTextField searchField;


public static void main(String[] args) {
    EventQueue.invokeLater(new Runnable() {
        public void run() {
            try {
                QueryFrame frame = new QueryFrame();
                frame.setVisible(true);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
}


public QueryFrame() {
    setResizable(false);
    setTitle("查询信息");
    setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    setBounds(100, 100, 450, 470);
    setLocationRelativeTo(null);
    contentPane = new JPanel();
    contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
    setContentPane(contentPane);
    contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS));

    JPanel panel = new JPanel();
    contentPane.add(panel);
    panel.setLayout(null);

    JLabel lblNewLabel = new JLabel("请输入要查找的学生的学号：");
    lblNewLabel.setFont(new Font("宋体", Font.PLAIN, 16));
    lblNewLabel.setBounds(71, 0, 208, 29);
    panel.add(lblNewLabel);

    JLabel lblNewLabel_1 = new JLabel("学号：");
    lblNewLabel_1.setFont(new Font("宋体", Font.PLAIN, 16));
    lblNewLabel_1.setBounds(71, 105, 50, 30);
    panel.add(lblNewLabel_1);

    idField = new JTextField();
    idField.setEditable(false);
    idField.setBounds(143, 99, 240, 45);
    panel.add(idField);
    idField.setColumns(10);

    JLabel lblNewLabel_1_1 = new JLabel("姓名：");
    lblNewLabel_1_1.setFont(new Font("宋体", Font.PLAIN, 16));
    lblNewLabel_1_1.setBounds(71, 160, 50, 30);
    panel.add(lblNewLabel_1_1);

    nameField = new JTextField();
    nameField.setColumns(10);
    nameField.setBounds(143, 154, 240, 45);
    panel.add(nameField);

    JLabel lblNewLabel_1_1_1 = new JLabel("性别：");
    lblNewLabel_1_1_1.setFont(new Font("宋体", Font.PLAIN, 16));
    lblNewLabel_1_1_1.setBounds(71, 215, 50, 30);
    panel.add(lblNewLabel_1_1_1);

    genderField = new JTextField();
    genderField.setColumns(10);
    genderField.setBounds(143, 209, 240, 45);
    panel.add(genderField);

    JLabel lblNewLabel_1_1_1_1 = new JLabel("出生日期：");
    lblNewLabel_1_1_1_1.setFont(new Font("宋体", Font.PLAIN, 16));
    lblNewLabel_1_1_1_1.setBounds(41, 270, 80, 30);
    panel.add(lblNewLabel_1_1_1_1);

    dobField = new JTextField();
    dobField.setColumns(10);
    dobField.setBounds(143, 264, 240, 45);
    panel.add(dobField);

    JLabel lblNewLabel_1_1_1_2 = new JLabel("班级：");
    lblNewLabel_1_1_1_2.setFont(new Font("宋体", Font.PLAIN, 16));
    lblNewLabel_1_1_1_2.setBounds(71, 325, 50, 30);
    panel.add(lblNewLabel_1_1_1_2);

    batchField = new JTextField();
    batchField.setColumns(10);
    batchField.setBounds(143, 319, 240, 45);
    panel.add(batchField);

    searchField = new JTextField();
    searchField.setBounds(71, 39, 208, 45);
    panel.add(searchField);
    searchField.setColumns(10);

    JButton searchButton = new JButton("查找");
    searchButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {

            // 1.读出要查询的学生输入的id
            // 因为学生的学号是唯一的，所以我们根据学号查询后，只会有一条数据
            // 转化一下数据类型
            int id = Integer.parseInt(searchField.getText());

            // 2.执行JDBC语句
            try {
                SQLHelp sqlHelp = new SQLHelp();

                Student student = sqlHelp.queryStudent(id);

                // 3.将查询结果填到文本框中
                // 前提是学生存在
                if(student != null) {
                    idField.setText(String.valueOf(id));
                    nameField.setText(student.getName());
                    genderField.setText(student.getGender());//性别
                    dobField.setText(student.getDob());//出生日期
                    batchField.setText(String.valueOf(student.getBatch()));//班级
                } else {
                    // 此时学生不存在，提示用户，不存在该学生
                    JOptionPane.showMessageDialog(QueryFrame.this, "无此学生");
                }

            } catch (SQLException e) {
                e.printStackTrace();
            }

        }
    });
    searchButton.setFont(new Font("宋体", Font.PLAIN, 18));
    searchButton.setBounds(289, 42, 97, 39);
    panel.add(searchButton);
}

}

```java
package c01.s01.t09.gui;

import c01.s01.t09.bean.User;
import c01.s01.t09.service.UserService;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.util.List;

/**
 * 功能：用户登录窗口
 * 作者：
 * 日期：
 */
public class LoginFrame extends JFrame {
    private String username;
    private String password;

    private JLabel lblUsername;
    private JLabel lblPassword;
    private JTextField txtUsername;
    private JPasswordField txtPassword;

    private JButton btnOK;
    private JButton btnCancel;

    private JPanel panel, panel1, panel2, panel3;

    /**
     * 有参构造方法
     *
     * @param title
     */
    public LoginFrame(String title) {
        super(title);
        initGUI(); // 调用初始化图形用户界面方法
        eventsHandling();
    }

    /**
     * 事件处理
     */
    private void eventsHandling() {
        // 给【确定】按钮注册监听器
        btnOK.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 获取用户输入的用户名和密码
                username = txtUsername.getText().trim();
                password = new String(txtPassword.getPassword());
                // 创建用户服务对象
                UserService userService = new UserService() {
                    @Override
                    public User login(String username, String password) {
                        return null;
                    }

                    @Override
                    public int deleteUserById(int i) {
                        return 0;
                    }

                    @Override
                    public User findUserById(int i) {
                        return null;
                    }

                    @Override
                    public void updateUser(User user) {

                    }

                    @Override
                    public List<User> findAllUsers() {
                        return null;
                    }
                };
                // 调用服务对象的登录方法
                User user;
                user = userService.login(username, password);
                // 判断用户登录是否成功
                if (user != null) {
                    // 弹出消息框提示用户
                    JOptionPane.showMessageDialog(null, "恭喜，[" + username + "]登录成功~");
                    dispose(); // 关闭登录窗口
                } else {
                    // 弹出消息框提示用户
                    JOptionPane.showMessageDialog(null, "遗憾，用户名或密码错误~");
                    // 清空两个文本框
                    txtUsername.setText("");
                    txtPassword.setText("");
                    // 让姓名文本框获取焦点
                    txtUsername.requestFocus();
                }
            }
        });

        // 给【取消】按钮注册监听器
        btnCancel.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.exit(0); // 退出应用程序
            }
        });
    }


    /**
     * 初始化图形用户界面方法
     */
    private void initGUI() {
        // 实例化组件（面板与控件）
        panel = (JPanel) getContentPane();
        panel1 = new JPanel();
        panel2 = new JPanel();
        panel3 = new JPanel();

        lblUsername = new JLabel("用户名：");
        lblPassword = new JLabel("密    码：");
        txtUsername = new JTextField(15);
        txtPassword = new JPasswordField(15);
        btnOK = new JButton("确定[O]");
        btnCancel = new JButton("取消[C]");

        // 将控件添加到三个小面板
        panel1.add(lblUsername);
        panel1.add(txtUsername);
        panel2.add(lblPassword);
        panel2.add(txtPassword);
        panel3.add(btnOK);
        panel3.add(btnCancel);

        // 设置主面板为三行一列的网格布局
        panel.setLayout(new GridLayout(3, 1));
        // 将三个小面板依次添加到主面板
        panel.add(panel1);
        panel.add(panel2);
        panel.add(panel3);

        // 设置按钮热键字母
        btnOK.setMnemonic(KeyEvent.VK_O);
        btnCancel.setMnemonic(KeyEvent.VK_C);
        // 设置密码框回显字符
        txtPassword.setEchoChar('*');

        // 设置窗口大小
        setSize(250, 200);
        // 设置窗口屏幕居中
        setLocationRelativeTo(null);
        // 设置窗口不可调整大小
        setResizable(false);
        // 设置窗口刚好容纳组件
        pack();
        // 设置窗口可见
        setVisible(true);
        // 设置窗口默认关闭操作
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    }

    public static void main(String[] args) {
        new LoginFrame("用户登录");
    }
}

package c01.s01.t09.gui;

/**
 * 功能：
 * 作者：
 * 日期：2022年06月10日
 */

import c03.SelectFrame;

import javax.swing.*;
import javax.swing.border.EmptyBorder;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.sql.SQLException;

public class MainFrame extends JFrame {

    private JPanel contentPane;

//    // 有了main函数才可以单独运行   取消注释可以单独测试该文件
//    public static void main(String[] args) {
//        EventQueue.invokeLater(new Runnable() {
//            public void run() {
//                try {
//                    MainFrame frame = new MainFrame();
//                    frame.setVisible(true);
//                } catch (Exception e) {
//                    e.printStackTrace();
//                }
//            }
//        });
//    }

    public MainFrame() {
        // 设置大小不可改变
        setResizable(false);
        // 设置标题
        setTitle("学生管理系统");
        // 由于这是主页面，所有当主页面关闭的时候，程序就直接退出
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // setBounds(int x,int y,int width,int height);
        // x 和 y 是窗口打开时的位置
        // width 和 height 是窗口打宽度和高度
        setBounds(100, 100, 450, 500);
        // setLocationRelativeTo(c)
        // 设置窗口相对于 c 的位置，当 c 为空或者 null 时，默认为是相对于屏幕中央
        setLocationRelativeTo(null);
        // 实例化一个 pane
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPane);
        contentPane.setLayout(null);

        JLabel lblNewLabel = new JLabel("学生管理系统");
        lblNewLabel.setForeground(Color.RED);
        lblNewLabel.setFont(new Font("宋体", Font.BOLD, 25));
        lblNewLabel.setBounds(140, 10, 163, 44);
        contentPane.add(lblNewLabel);

        JButton addButton = new JButton("添加学生");
        // addActionListener 注册监听器
        addButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                // 设置新窗口可见
                new AddFrame().setVisible(true);
            }
        });

        addButton.setFont(new Font("宋体", Font.PLAIN, 18));
        addButton.setBounds(167, 64, 114, 37);
        contentPane.add(addButton);

        JButton changeButton = new JButton("修改信息");
        changeButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                // 同上
                new ChangeFrame().setVisible(true);
            }
        });
        changeButton.setFont(new Font("宋体", Font.PLAIN, 18));
        changeButton.setBounds(167, 121, 114, 37);
        contentPane.add(changeButton);

        JButton deleteButton = new JButton("删除学生");
        deleteButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                // 同上
                new DeleteFrame().setVisible(true);
            }
        });
        deleteButton.setFont(new Font("宋体", Font.PLAIN, 18));
        deleteButton.setBounds(167, 180, 114, 37);
        contentPane.add(deleteButton);

        JButton queryButton = new JButton("查询信息");
        queryButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                // 同上
                new QueryFrame().setVisible(true);
            }
        });
        queryButton.setFont(new Font("宋体", Font.PLAIN, 18));
        queryButton.setBounds(167, 240, 114, 37);
        contentPane.add(queryButton);

        JButton selectButton = new JButton("查询所有学生记录");
        selectButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    SelectFrame s = new SelectFrame();
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }
        });
        selectButton.setBounds(134,300,180,37);
        selectButton.setFont(new Font("宋体", Font.PLAIN, 18));
        contentPane.add(selectButton);
    }

    private class DeleteFrame {
        private boolean visible;

        public void setVisible(boolean visible) {
            this.visible = visible;
        }在这里插入代码片

        public boolean getVisible() {
            return visible;
        }
    }
}

package c01.s01.t09.gui;

/**
 * 功能：
 * 作者：
 * 日期：2022年06月11日
 */


import c03.SQLHelp;
import c03.User;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.sql.SQLException;

public class Register extends JFrame {
    JLabel username;
    JLabel password;
    JLabel passwordAgain;

    JTextField usernameFile;
    JPasswordField passwordFile;
    JPasswordField PasswordFileAgain;
//    FlowLayout flowLayout;

    JButton sign;

    JPanel p;
    JPanel p1;

//    private Connection connection = null;//初始化conn~
//    private PreparedStatement pStatement = null;//初始化stat~
//    private ResultSet rSet = null;//初始化结果

    final int WIDTH = 410;
    final int HEIGHT = 610;

//    flowLayout = new FlowLayout(FlowLayout.CENTER);

    public Register() {
        init();//调用init方法
        setResizable(false);//这是不可变窗口
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);//设置窗口关闭默认关闭方式
        validate();
        setVisible(true);//可显示
        Toolkit kit = Toolkit.getDefaultToolkit();//获取屏幕宽度
        Dimension screenSize = kit.getScreenSize();//初始化变量
        int width = screenSize.width;//这边都是设置大小的，当然后面我老师i给我讲的时候发现根本不需要
        int height = screenSize.height;
        int x = (width - WIDTH) / 2;
        int y = (height - HEIGHT) / 2;
        setBounds(x, y, WIDTH, HEIGHT);//设置主窗口位置和大小
        setTitle("账号注册");//设置主窗口的标题
    }

    void init() {
//        p.setBorder(BorderFactory.createTitledBorder("基本信息处理"));
//        p.setPreferredSize(new Dimension(WIDTH, HEIGHT));
//        p.setLayout(new FlowLayout(FlowLayout.CENTER));
//        p.setBounds(0,0,WIDTH,HEIGHT);
//        p.setLayout(null);
//        p.setOpaque(false);
        p = new JPanel();//初始化窗口p
        p.setLayout(null);//设置布局为空
        p.setVisible(true);//设置可见

        p1 = new JPanel();//这里因为不知道什么原因如果不重新声明一个Panle那么我的内容显示不出来
//        p1.setLayout(null);
        p1.setVisible(true);//设置可见
        p1.setLayout(null);//设置恐怖剧
        p1.setBounds(0, 0, 400, 600);//设置位置和大小

        username = new JLabel("账号：");//这里全是定义所需要的元素
        password = new JLabel("密码：");
        passwordAgain = new JLabel("确认密码：");

        usernameFile = new JTextField(20);//这里是设置长度
        passwordFile = new JPasswordField(20);//注意TextFile和PasswordFile在后续获取的时候不一样
        PasswordFileAgain = new JPasswordField(20);

        passwordFile.setEchoChar('*');//这个是输入密码的填充
        PasswordFileAgain.setEchoChar('*');

        sign = new JButton("注册");//设置注册按钮

        //这里开始设置元素位置和大小
        sign.setBounds(160, 300, 100, 50);

        username.setBounds(130, 150, 40, 20);
        password.setBounds(130, 200, 40, 20);
        passwordAgain.setBounds(130, 250, 120, 20);

        usernameFile.setBounds(200, 150, 100, 20);
        passwordFile.setBounds(200, 200, 100, 20);
        PasswordFileAgain.setBounds(200, 250, 100, 20);

        //将元素逐层添加
        p1.add(username);
        p1.add(password);
        p1.add(passwordAgain);
        p1.add(usernameFile);
        p1.add(passwordFile);
        p1.add(PasswordFileAgain);
        p1.add(sign);
        p.add(p1);
        this.add(p);

        //这里我们为注册按钮添加了监听事件
        sign.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String strusername = usernameFile.getText();//获取usernameFile的内容
                String strpassword = new String(passwordFile.getPassword());//在这里我们获取usernameFile和passwordFile方式就不一样了，看好
                String strpasswordAgain = new String(PasswordFileAgain.getPassword());
                SQLHelp sqlHelp = new SQLHelp();//这里我们调用SQLHelp文件  我在那里写了注册所需的模块

                try {
                    User users = sqlHelp.userpassweord(strusername);  //这里我们先接收看看能不能接收到数据

                    if (users == null) {//没数据说明没有账户可以注册
                        if (strpassword.equals(strpasswordAgain)) {
                            System.out.println("注册成功");//判断是否进入
                            String username = strusername;//当然这里也可以不用在初始化一次，因为上面可以直接使用
                            String password = strpassword;
                            sqlHelp.addManeger(username,password);//这里就是向SQLHelp文件里卖弄的addManager模块传入数据
                            JOptionPane.showMessageDialog(null, "注册成功", "点击确定后返回登录界面", JOptionPane.INFORMATION_MESSAGE);

                            //这里是两次密码不同
                        } else {
                            System.out.println("注册失败");
                            JOptionPane.showMessageDialog(null, "注册失败，请检查两次密码是否相同", "登录失败提示窗口", JOptionPane.INFORMATION_MESSAGE);
                        }
                        //这里是账号重复
                    }else{
                        System.out.println("已有账号无法注册");//控制台提示信息
                        JOptionPane.showMessageDialog(null,"注册失败了，已拥有该账号，请检查密码是否输入错误，目前不支持找回密码","账号已有窗口",JOptionPane.INFORMATION_MESSAGE);
//                        dispose();
                    }
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }
        });
    }


    //这里是单独测试Register文件的时候用的
    public static void main(String[] args) {
        new Register();
    }

}