精华内容
下载资源
问答
  • 本实验要求学生使用JDBC提供的接口和类编写一个Java应用程序,实现对学生数据信息的查询、删除、插入、更新等操作。 学生数据库(student)在MySQL数据库服务器中创建。 1. 在MySQL中创建学生数据库student,其中一...

    一 实验内容

    本实验要求学生使用JDBC提供的接口和类编写一个Java应用程序,实现对学生数据信息的查询、删除、插入、更新等操作。

    学生数据库(student)在MySQL数据库服务器中创建。

    1. 在MySQL中创建学生数据库student,其中一个学生信息表stuinfo结构如下:

                             图1  stuinfo表结构

    2. 设计一个Java程序,界面如图2所示,实现以下功能:

    (1)点击“全部检索”按钮,检索stuinfo表的所有记录,显示在上面的JTable组件中;

    (2)输入查询学号,点击“查询”按钮,查询该学生信息显示在左边面板中,查询不到时弹出信息提示。

    (3)左边面板中输入学生信息,点击“添加”按钮,将此学生信息插入stuinfo表中,弹出插入是否成功的提示框。

    (4)点击“删除”按钮,依据上边学号值删除该学生记录,弹出删除是否成功的提示框。

    (5)点击“更新”按钮,依据上边学号值更新该学生的其它信息,弹出更新是否成功的提示框。

    *首先完成界面设计,然后逐项功能实现,可以选作部分功能。

                                                图2  学生数据管理

    二 实验思路

        1,画界面,
        2,连接数据库
        3,对数据库操作

    三 画界面

    四 连接数据库

    package studentsql;
    
    import java.sql.*;
    
    public class Test_connect_SQL {
        
        public static void main(String[] args) {
            String driverName = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
            String dbURL = "jdbc:sqlserver://localhost:1433;DatabaseName=student";
            String userName = "lw";
            String userPwd = "123456";
            try {
                Class.forName(driverName);
                System.out.println("加载驱动成功!");
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("加载驱动失败!");
            }
            try {
                Connection dbConn = DriverManager.getConnection(dbURL, userName, userPwd);
                System.out.println("连接数据库成功!");
            } catch (Exception e) {
                e.printStackTrace();
                System.out.print("SQL Server连接失败!");
            }
            ///new StudentJFrame(new StudentJPanel(),"studentim");
        }
    }

    五 对数据库操作

    -------------------------------------

    六 程序代码

    链接:http://pan.baidu.com/s/1eR97AkM 密码:otun

    StudentJFrame

    package studentsql;
    /*
     * 思路:1,画界面,
     *        2,连接数据库
     *         3,对数据库操作
     * */
    import java.awt.*;
    import java.awt.event.*;
    import java.sql.*;
    import javax.swing.*;
    import javax.swing.event.*;
    import javax.swing.table.DefaultTableModel;                                             
    public class StudentJFrame extends JFrame implements ActionListener, ListSelectionListener {//响应按钮动作和列表框选择事件
        protected StudentJPanel student;     // Student对象信息面板
        protected JTable jtable;            //表格
        public JButton inquire, allsearch;    //查询,全部检索按钮
        public JTextField number;            //学号
        JPanel rightpanel;                    //左边的StudentJPanel面板
        private JScrollPane scrollPane;        //滚动窗格
        public Connection conn;             //数据库连接对象
        String userName = "lw";                //数据库名字
        String userPwd = "123456";            //数据库密码
        /**
         * 整体的框架,
         * @param StudentJFrame 
         * */
        public StudentJFrame(StudentJPanel person, String driver, String url) throws ClassNotFoundException, SQLException {
            super("Student对象信息管理");                        //标题
            this.setSize(800, 300);                         // 设置组件尺寸
            this.setLocationRelativeTo(null);                 // 将窗口置于屏幕中央
            this.setDefaultCloseOperation(EXIT_ON_CLOSE);
            this.student = person;                             // Person对象或其子类信息面板
            rightpanel = new JPanel(new BorderLayout());    // 面板边布局
            JSplitPane split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, this.student, rightpanel);
                                                            // 水平分割窗格,左右边各添加一个面板
            split.setDividerLocation(200);                     // 设置水平分隔条的位置
            this.getContentPane().add(split);                 // 框架内容窗格添加分割窗格
            Class.forName(driver);
            this.conn = DriverManager.getConnection(url, this.userName, this.userPwd); // 返回数据库连接对象
            jtable=new JTable();
            scrollPane = new JScrollPane(jtable);// 面板添加包含列表框的滚动窗格
            rightpanel.add(scrollPane,"Center");
            JPanel buttonpanel = new JPanel(); // 按钮面板,默认流布局
            rightpanel.add(buttonpanel, "South"); // 南边添加按钮面板
    
            buttonpanel.add(new Label("学号"));
            number=new JTextField("102012012", 10);
            buttonpanel.add(number);
            inquire=new JButton("查询");
            buttonpanel.add(inquire);
            this.inquire.addActionListener(this);
            this.allsearch = new JButton("全部检索");
            buttonpanel.add(this.allsearch);
            this.allsearch.addActionListener(this);
            this.setVisible(true);
        }
        /**
         * 获得表格模型
         * @param 
         * */
        public DefaultTableModel query(String table) throws SQLException {
            DefaultTableModel tablemodel = new DefaultTableModel();     // 表格模型
            String sql = "SELECT * FROM " + table + ";";
            Statement stmt = this.conn.createStatement();                // 1003,1007); //创建语句对象
            ResultSet rset = stmt.executeQuery(sql);                     // 执行数据查询SELECT语句
            // 获得表中列数及各列名,作为表格组件的标题
            ResultSetMetaData rsmd = rset.getMetaData();                 // 返回表属性对象
            int count = rsmd.getColumnCount();                             // 获得列数
            for (int j = 1; j <= count; j++)                             // 将各列名添加到表格模型作为标题,列序号≥1
                tablemodel.addColumn(rsmd.getColumnLabel(j));
            // 将结果集中各行数据添加到表格模型,一次遍历
            Object[] columns = new Object[count];                         // 创建列对象数组,数组长度为列数
            while (rset.next())                                         // 迭代遍历结果集,从前向后访问每行
            {
                for (int j = 1; j <= columns.length; j++)                 // 获得每行各列值
                    columns[j - 1] = rset.getString(j);
                tablemodel.addRow(columns);                             // 表格模型添加一行,参数指数各列值
    
            }
            rset.close();
            stmt.close();
            return tablemodel;                                             // 创建表格,指定表格模型
    
        }
    
        @Override
        public void valueChanged(ListSelectionEvent arg0) {
            // TODO Auto-generated method stub
    
        }
    /**
     * 查询,全部检索,按钮触发事件
     * @param
     * */
        @Override
        public void actionPerformed(ActionEvent e) {
            if (e.getSource() == allsearch) {
                System.out.println(99);
                try {
                    
                    jtable.setModel(query("studentim"));
    
                } catch (SQLException e1) {
                    e1.printStackTrace();
                }
            }
            if(e.getSource()==inquire)
            {
                try {
                    String num = "112";
                    String sql="SELECT* from studentim where stu_id='"+num+"'";
                    Statement stmt = this.conn.createStatement();// 1003,1007); //创建语句对象
                    ResultSet rset = stmt.executeQuery(sql); // 执行数据查询SELECT语句
    //                ResultSetMetaData rsmd=rset.getMetaData();
    //                int count=rsmd.getColumnCount();
    //                String result1 = null;
    //                String result2 = null;
    //                String result3 = null;
    //                
    //                while(rset.next())
    //                {    String result[] = new String[6];                        
    //                         result1 = rset.getString(1);
    //                         result2 = rset.getString(2);
    //                         result3 = rset.getString(3);
    //                        
    //                }
    //                //this.number.setText(re);
    //                new StudentJPanel().setString("1", "22", "33");
                    
                    rset.next();
                    student.texts[0].setText(rset.getString(1));
                } catch (SQLException e1) {
                
                    e1.printStackTrace();
                } catch (Exception e1) {
                    e1.printStackTrace();
                }
            }
    
        }
        
        public static void main(String arg[]) throws ClassNotFoundException, SQLException {
    
            String driver = "com.microsoft.sqlserver.jdbc.SQLServerDriver"; // 指定MySQL// JDBC驱动程序
            String url = "jdbc:sqlserver://localhost:1433;DatabaseName=student";
            new StudentJFrame(new StudentJPanel(), driver, url);
        }
    
    }

    StudentJPanel

    package studentsql;
    
    import java.awt.*;
    import java.awt.event.*;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    import javax.swing.*;
    import javax.swing.border.TitledBorder;
    /**
     * studentJPanel 面板  
     * @param 
     * */
    public class StudentJPanel extends JPanel implements ActionListener// ,ItemListener
                                                                        // //Person对象信息面板
    {
        JTextField texts[];                             // 文本行数组,表示学号,姓名、出生日期
        JRadioButton radiobs[];                         // 性别按钮
        JTextField combox_province, combox_city;         // 省份、城市组合框
        JButton add, delete, update;                    //添加 删除 更新按钮
        Connection conn;                                 // 数据库连接对象
        String userName = "lw";                             //用户名
        String userPwd = "123456";                        //密码
        String driver = "com.microsoft.sqlserver.jdbc.SQLServerDriver";             // 指定MySQL//
        String url = "jdbc:sqlserver://localhost:1433;DatabaseName=student";
        /**
         * 学生信息面板
         * */
        public StudentJPanel() throws ClassNotFoundException, SQLException            // 构造方法
        {
            Class.forName(this.driver);                                                //指定JDBC驱动程序
            this.conn = DriverManager.getConnection(url, this.userName, this.userPwd);//创建接口的连接对象
            this.setBorder(new TitledBorder("Student"));                             // 设置面板具有带标题的边框
            this.setLayout(new GridLayout(7, 1));                                     // 面板网格布局,行1列
            String str[][] = { { "学号","姓名", "1990年01月01日" }, { "男", "女" } };        //信息数组
            this.texts = new JTextField[str[0].length];
            for (int i = 0; i < this.texts.length; i++)                             // 面板添加两个文本行
                this.add(this.texts[i] = new JTextField(str[0][i]));
            JPanel panel_rb = new JPanel(new GridLayout(1, 2));                         // 性别面板,网格布局,1行2列,单选按钮
            this.add(panel_rb);
            ButtonGroup bgroup = new ButtonGroup();                                 // 按钮组
            this.radiobs = new JRadioButton[str[1].length];
            for (int i = 0; i < this.radiobs.length; i++) {
                panel_rb.add(this.radiobs[i] = new JRadioButton(str[1][i]));         // 创建单选按钮,默认不选中,添加到面板
                bgroup.add(this.radiobs[i]);                                         // 单选按钮添加到按钮组
            }
            this.radiobs[0].setSelected(true);                                         // 单选按钮选中
            this.add(this.combox_province = new JTextField("广东"));                    // 省份组合框
            this.add(this.combox_city = new JTextField("广州"));                        // 城市组合框
            this.combox_province.addActionListener(this);                             // 省份组合框注册单击事件监听器
            JPanel panel_bu = new JPanel(new GridLayout(1, 3));
            this.add(panel_bu);
            panel_bu.add(this.add = new JButton("添加"));                                //添加按钮
            this.add.addActionListener(this);                                        
            panel_bu.add(this.delete = new JButton("删除"));                            //删除按钮
            this.delete.addActionListener(this);
            panel_bu.add(this.update = new JButton("更新"));                            //更新按钮
            this.update.addActionListener(this);
        }
        /**
         * 添加  删除 更新按钮的触发事件
         * */    
        @Override
        public void actionPerformed(ActionEvent ex) {
            /**
             * 获得觉得输入的信息
             * */
            String numbers=texts[0].getText();
            String names=texts[1].getText();
            String brithday=texts[2].getText();
            String sex=radiobs[0].isSelected()?radiobs[0].getText():radiobs[1].getText();
            String prirvince=combox_province.getText();
            String city=combox_city.getText();
            if (ex.getSource() == this.add) {                //添加动作
                String sql = "INSERT INTO studentim(stu_id,stu_name,birthday,sex,province,city)" + "VALUES('"+numbers+"','"+names+"','"+brithday+"','"+sex+"','"+prirvince+"','"+city+"')";
                try {
                    Statement stmt = this.conn.createStatement();
                    int count = stmt.executeUpdate(sql);
                } catch (SQLException e) {
                    e.printStackTrace();
                }                         // 1003,1007); //创建语句对象
    
                System.out.println(2);
                JOptionPane.showMessageDialog(this, "添加成功");
            }
            if (ex.getSource() == this.delete) {             //删除动作    
                String sql = "DELETE FROM studentim WHERE(stu_id='"+numbers+"')";
                try {
                    Statement stmt = this.conn.createStatement();
                    int count = stmt.executeUpdate(sql);
                } catch (SQLException e) {
                    e.printStackTrace();
                } // 1003,1007); //创建语句对象
    
                System.out.println(4);
                JOptionPane.showMessageDialog(this, "删除成功");
            }
            if (ex.getSource() == this.update) {        //更新动作
                String sql = "update studentim set stu_name='"+names+"' where (stu_id='"+numbers+"')";
                try {
                    Statement stmt = this.conn.createStatement();
                    int count = stmt.executeUpdate(sql);
                } catch (SQLException e) {
                    e.printStackTrace();
                }                     // 1003,1007); //创建语句对象
    
                System.out.println(3);
                JOptionPane.showMessageDialog(this, "更新成功");
            }
    
        }
    
    }

     

     

    展开全文
  • Python题目:学生信息管理系统-高级版(图形界面+MySQL数据库) 使用图形界面显示,选用list、tuple、dictionary或map等数据结构,操作数据库存储X个学生的三门课的成绩(机器学习、Python程序设计、研究生英语)...

    Python题目:学生信息管理系统-高级版(图形界面+MySQL数据库)

           使用图形界面显示,选用list、tuple、dictionary或map等数据结构,操作数据库存储X个学生的三门课的成绩(机器学习、Python程序设计、研究生英语),并实现以下功能:

    1.添加学生信息
    2.修改学生信息
    3.删除学生
    4.添加学生的成绩
    5.修改学生成绩
    6.按姓名或者学号查找学生,显示学生信息及三门课的成绩,以及排名
    7.学生成绩统计(每门课的平均分、最高分、最低分)

    代码里的注释很清楚了,这里不做讲解了,有任何问题可以评论提问。 

    注意:

    • 数据表不存在则创建表,但自动创建的表是空白的,管理员用户名和密码需要自己数据库中添加一个(也可以运行文章最后的sql语句),为什么会出现这个问题,因为这是个课堂作业,当时没有设计好,现在懒得再改代码了╮(╯﹏╰)╭.......
    • 数据库在代码中(代码里有两处需要修改数据库 用户名、密码 的地方第66行第490行),配置为:
    # 打开数据库连接 连接测试
    db = pymysql.connect("localhost", "root", "root", "student")

           分别表示  主机名:localhost,用户名:root,密码:root,数据库名:student 


    下面是界面的截图

     

     管理员操作界面,拥有增删改查功能,甚至拥有排序功能φ(>ω<*) ,快点击标签栏试试

     

     代码:

    #!/usr/bin/python3
    
    import pymysql
    from tkinter import ttk
    import tkinter as tk
    import tkinter.font as tkFont
    from tkinter import * # 图形界面库
    import tkinter.messagebox as messagebox # 弹窗
    
    
    class StartPage:
    	def __init__(self, parent_window):
    		parent_window.destroy() # 销毁子界面
    
    		self.window = tk.Tk()  # 初始框的声明
    		self.window.title('学生信息管理系统')
    		self.window.geometry('300x470') # 这里的乘是小x
    
    		label = Label(self.window, text="学生信息管理系统", font=("Verdana", 20))
    		label.pack(pady=100)  # pady=100 界面的长度
    
    		Button(self.window, text="管理员登陆", font=tkFont.Font(size=16), command=lambda: AdminPage(self.window), width=30, height=2,
    			   fg='white', bg='gray', activebackground='black', activeforeground='white').pack()
    		Button(self.window, text="学生登陆", font=tkFont.Font(size=16), command=lambda: StudentPage(self.window), width=30,
    			   height=2,fg='white', bg='gray', activebackground='black', activeforeground='white').pack()
    		Button(self.window, text="关于", font=tkFont.Font(size=16), command=lambda: AboutPage(self.window), width=30, height=2,
    			   fg='white', bg='gray', activebackground='black', activeforeground='white').pack()
    		Button(self.window, text='退出系统', height=2, font=tkFont.Font(size=16), width=30, command=self.window.destroy,
    			   fg='white', bg='gray', activebackground='black', activeforeground='white').pack()
    
    		self.window.mainloop() # 主消息循环
    
    
    #管理员登陆页面
    class AdminPage:
    	def __init__(self, parent_window):
    		parent_window.destroy() # 销毁主界面
    
    		self.window = tk.Tk()  # 初始框的声明
    		self.window.title('管理员登陆页面')
    		self.window.geometry('300x450')  # 这里的乘是小x
    
    		label = tk.Label(self.window, text='管理员登陆', bg='green', font=('Verdana', 20), width=30, height=2)
    		label.pack()
    
    		Label(self.window, text='管理员账号:', font=tkFont.Font(size=14)).pack(pady=25)
    		self.admin_username = tk.Entry(self.window, width=30, font=tkFont.Font(size=14), bg='Ivory')
    		self.admin_username.pack()
    
    		Label(self.window, text='管理员密码:', font=tkFont.Font(size=14)).pack(pady=25)
    		self.admin_pass = tk.Entry(self.window, width=30, font=tkFont.Font(size=14), bg='Ivory', show='*')
    		self.admin_pass.pack()
    
    		Button(self.window, text="登陆", width=8, font=tkFont.Font(size=12), command=self.login).pack(pady=40)
    		Button(self.window, text="返回首页", width=8, font=tkFont.Font(size=12), command=self.back).pack()
    
    		self.window.protocol("WM_DELETE_WINDOW", self.back)  # 捕捉右上角关闭点击
    		self.window.mainloop()  # 进入消息循环
    
    	def login(self):
    		print(str(self.admin_username.get()))
    		print(str(self.admin_pass.get()))
    		admin_pass = None
    
    		# 数据库操作 查询管理员表
    		db = pymysql.connect("localhost", "root", "root", "student")  # 打开数据库连接
    		cursor = db.cursor()  # 使用cursor()方法获取操作游标
    		sql = "SELECT * FROM admin_login_k WHERE admin_id = '%s'" % (self.admin_username.get())  # SQL 查询语句
    		try:
    		# 执行SQL语句
    			cursor.execute(sql)
    			# 获取所有记录列表
    			results = cursor.fetchall()
    			for row in results:
    				admin_id = row[0]
    				admin_pass = row[1]
    				# 打印结果
    				print("admin_id=%s,admin_pass=%s" % (admin_id, admin_pass))
    		except:
    			print("Error: unable to fecth data")
    			messagebox.showinfo('警告!', '用户名或密码不正确!')
    		db.close()  # 关闭数据库连接
    
    		print("正在登陆管理员管理界面")
    		print("self",self.admin_pass)
    		print("local",admin_pass)
    
    		if self.admin_pass.get() == admin_pass:
    			AdminManage(self.window)  # 进入管理员操作界面
    		else:
    			messagebox.showinfo('警告!', '用户名或密码不正确!')
    
    	def back(self):
    		StartPage(self.window) # 显示主窗口 销毁本窗口
    
    
    #学生登陆页面
    class StudentPage:
    	def __init__(self, parent_window):
    		parent_window.destroy() # 销毁主界面
    
    		self.window = tk.Tk()  # 初始框的声明
    		self.window.title('学生登陆')
    		self.window.geometry('300x450')  # 这里的乘是小x
    
    		label = tk.Label(self.window, text='学生登陆', bg='green', font=('Verdana', 20), width=30, height=2)
    		label.pack()
    
    		Label(self.window, text='学生账号:', font=tkFont.Font(size=14)).pack(pady=25)
    		self.student_id = tk.Entry(self.window, width=30, font=tkFont.Font(size=14), bg='Ivory')
    		self.student_id.pack()
    
    		Label(self.window, text='学生密码:', font=tkFont.Font(size=14)).pack(pady=25)
    		self.student_pass = tk.Entry(self.window, width=30, font=tkFont.Font(size=14), bg='Ivory', show='*')
    		self.student_pass.pack()
    
    		Button(self.window, text="登陆", width=8, font=tkFont.Font(size=12), command=self.login).pack(pady=40)
    		Button(self.window, text="返回首页", width=8, font=tkFont.Font(size=12), command=self.back).pack()
    
    		self.window.protocol("WM_DELETE_WINDOW", self.back)  # 捕捉右上角关闭点击
    		self.window.mainloop()  # 进入消息循环
    
    	def login(self):
    		print(str(self.student_id.get()))
    		print(str(self.student_pass.get()))
    		stu_pass = None
    
    		# 数据库操作 查询管理员表
    		db = pymysql.connect("localhost", "root", "root", "student")  # 打开数据库连接
    		cursor = db.cursor()  # 使用cursor()方法获取操作游标
    		sql = "SELECT * FROM stu_login_k WHERE stu_id = '%s'" % (self.student_id.get())  # SQL 查询语句
    		try:
    			# 执行SQL语句
    			cursor.execute(sql)
    			# 获取所有记录列表
    			results = cursor.fetchall()
    			for row in results:
    				stu_id = row[0]
    				stu_pass = row[1]
    				# 打印结果
    				print("stu_id=%s,stu_pass=%s" % (stu_id, stu_pass))
    		except:
    			print("Error: unable to fecth data")
    			messagebox.showinfo('警告!', '用户名或密码不正确!')
    		db.close()  # 关闭数据库连接
    
    		print("正在登陆学生信息查看界面")
    		print("self", self.student_pass.get())
    		print("local", stu_pass)
    
    		if self.student_pass.get() == stu_pass:
    			StudentView(self.window, self.student_id.get()) # 进入学生信息查看界面
    		else:
    			messagebox.showinfo('警告!', '用户名或密码不正确!')
    
    	def back(self):
    		StartPage(self.window)  # 显示主窗口 销毁本窗口
    
    
    
    # 管理员操作界面
    class AdminManage:
    	def __init__(self, parent_window):
    		parent_window.destroy() # 销毁主界面
    
    		self.window = Tk()  # 初始框的声明
    		self.window.title('管理员操作界面')
    
    		self.frame_left_top = tk.Frame(width=300, height=200)
    		self.frame_right_top = tk.Frame(width=200, height=200)
    		self.frame_center = tk.Frame(width=500, height=400)
    		self.frame_bottom = tk.Frame(width=650, height=50)
    
    		# 定义下方中心列表区域
    		self.columns = ("学号", "姓名", "性别", "年龄")
    		self.tree = ttk.Treeview(self.frame_center, show="headings", height=18, columns=self.columns)
    		self.vbar = ttk.Scrollbar(self.frame_center, orient=VERTICAL, command=self.tree.yview)
    		# 定义树形结构与滚动条
    		self.tree.configure(yscrollcommand=self.vbar.set)
    
    		# 表格的标题
    		self.tree.column("学号", width=150, anchor='center')  # 表示列,不显示
    		self.tree.column("姓名", width=150, anchor='center')
    		self.tree.column("性别", width=100, anchor='center')
    		self.tree.column("年龄", width=100, anchor='center')
    
    		# 调用方法获取表格内容插入
    		self.tree.grid(row=0, column=0, sticky=NSEW)
    		self.vbar.grid(row=0, column=1, sticky=NS)
    
    		self.id = []
    		self.name = []
    		self.gender = []
    		self.age = []
    		# 打开数据库连接
    		db = pymysql.connect("localhost", "root", "root", "student")
    		cursor = db.cursor()  # 使用cursor()方法获取操作游标
    		sql = "SELECT * FROM student_k"  # SQL 查询语句
    		try:
    			# 执行SQL语句
    			cursor.execute(sql)
    			# 获取所有记录列表
    			results = cursor.fetchall()
    			for row in results:
    				self.id.append(row[0])
    				self.name.append(row[1])
    				self.gender.append(row[2])
    				self.age.append(row[3])
    				# print(self.id)
    				# print(self.name)
    				# print(self.gender)
    				# print(self.age)
    		except:
    			print("Error: unable to fetch data")
    			messagebox.showinfo('警告!', '数据库连接失败!')
    		db.close()# 关闭数据库连接
    
    
    		print("test***********************")
    		for i in range(min(len(self.id), len(self.name), len(self.gender), len(self.age))):  # 写入数据
    			self.tree.insert('', i, values=(self.id[i], self.name[i], self.gender[i], self.age[i]))
    
    		for col in self.columns:  # 绑定函数,使表头可排序
    			self.tree.heading(col, text=col,
    							  command=lambda _col=col: self.tree_sort_column(self.tree, _col, False))
    
    		# 定义顶部区域
    		# 定义左上方区域
    		self.top_title = Label(self.frame_left_top, text="学生信息:", font=('Verdana', 20))
    		self.top_title.grid(row=0, column=0, columnspan=2, sticky=NSEW, padx=50, pady=10)
    
    		self.left_top_frame = tk.Frame(self.frame_left_top)
    		self.var_id = StringVar()  # 声明学号
    		self.var_name = StringVar()  # 声明姓名
    		self.var_gender = StringVar()  # 声明性别
    		self.var_age = StringVar()  # 声明年龄
    		# 学号
    		self.right_top_id_label = Label(self.frame_left_top, text="学号:", font=('Verdana', 15))
    		self.right_top_id_entry = Entry(self.frame_left_top, textvariable=self.var_id, font=('Verdana', 15))
    		self.right_top_id_label.grid(row=1, column=0)  # 位置设置
    		self.right_top_id_entry.grid(row=1, column=1)
    		# 姓名
    		self.right_top_name_label = Label(self.frame_left_top, text="姓名:", font=('Verdana', 15))
    		self.right_top_name_entry = Entry(self.frame_left_top, textvariable=self.var_name, font=('Verdana', 15))
    		self.right_top_name_label.grid(row=2, column=0)  # 位置设置
    		self.right_top_name_entry.grid(row=2, column=1)
    		# 性别
    		self.right_top_gender_label = Label(self.frame_left_top, text="性别:", font=('Verdana', 15))
    		self.right_top_gender_entry = Entry(self.frame_left_top, textvariable=self.var_gender,
    											font=('Verdana', 15))
    		self.right_top_gender_label.grid(row=3, column=0)  # 位置设置
    		self.right_top_gender_entry.grid(row=3, column=1)
    		# 年龄
    		self.right_top_gender_label = Label(self.frame_left_top, text="年龄:", font=('Verdana', 15))
    		self.right_top_gender_entry = Entry(self.frame_left_top, textvariable=self.var_age,
    											font=('Verdana', 15))
    		self.right_top_gender_label.grid(row=4, column=0)  # 位置设置
    		self.right_top_gender_entry.grid(row=4, column=1)
    
    		# 定义右上方区域
    		self.right_top_title = Label(self.frame_right_top, text="操作:", font=('Verdana', 20))
    
    		self.tree.bind('<Button-1>', self.click)  # 左键获取位置
    		self.right_top_button1 = ttk.Button(self.frame_right_top, text='新建学生信息', width=20, command=self.new_row)
    		self.right_top_button2 = ttk.Button(self.frame_right_top, text='更新选中学生信息', width=20,
    											command=self.updata_row)
    		self.right_top_button3 = ttk.Button(self.frame_right_top, text='删除选中学生信息', width=20,
    											command=self.del_row)
    
    		# 位置设置
    		self.right_top_title.grid(row=1, column=0, pady=10)
    		self.right_top_button1.grid(row=2, column=0, padx=20, pady=10)
    		self.right_top_button2.grid(row=3, column=0, padx=20, pady=10)
    		self.right_top_button3.grid(row=4, column=0, padx=20, pady=10)
    
    		# 整体区域定位
    		self.frame_left_top.grid(row=0, column=0, padx=2, pady=5)
    		self.frame_right_top.grid(row=0, column=1, padx=30, pady=30)
    		self.frame_center.grid(row=1, column=0, columnspan=2, padx=4, pady=5)
    		self.frame_bottom.grid(row=2, column=0, columnspan=2)
    
    		self.frame_left_top.grid_propagate(0)
    		self.frame_right_top.grid_propagate(0)
    		self.frame_center.grid_propagate(0)
    		self.frame_bottom.grid_propagate(0)
    
    		self.frame_left_top.tkraise() # 开始显示主菜单
    		self.frame_right_top.tkraise() # 开始显示主菜单
    		self.frame_center.tkraise() # 开始显示主菜单
    		self.frame_bottom.tkraise() # 开始显示主菜单
    
    		self.window.protocol("WM_DELETE_WINDOW", self.back)  # 捕捉右上角关闭点击
    		self.window.mainloop()  # 进入消息循环
    
    	def back(self):
    		StartPage(self.window) # 显示主窗口 销毁本窗口
    
    	def click(self, event):
    		self.col = self.tree.identify_column(event.x)  # 列
    		self.row = self.tree.identify_row(event.y)  # 行
    
    		print(self.col)
    		print(self.row)
    		self.row_info = self.tree.item(self.row, "values")
    		self.var_id.set(self.row_info[0])
    		self.var_name.set(self.row_info[1])
    		self.var_gender.set(self.row_info[2])
    		self.var_age.set(self.row_info[3])
    		self.right_top_id_entry = Entry(self.frame_left_top, state='disabled', textvariable=self.var_id,
    										font=('Verdana', 15))
    
    		print('')
    
    	def tree_sort_column(self, tv, col, reverse):  # Treeview、列名、排列方式
    		l = [(tv.set(k, col), k) for k in tv.get_children('')]
    		l.sort(reverse=reverse)  # 排序方式
    		# rearrange items in sorted positions
    		for index, (val, k) in enumerate(l):  # 根据排序后索引移动
    			tv.move(k, '', index)
    		tv.heading(col, command=lambda: self.tree_sort_column(tv, col, not reverse))  # 重写标题,使之成为再点倒序的标题
    
    	def new_row(self):
    		print('123')
    		print(self.var_id.get())
    		print(self.id)
    		if str(self.var_id.get()) in self.id:
    			messagebox.showinfo('警告!', '该学生已存在!')
    		else:
    			if self.var_id.get() != '' and self.var_name.get() != '' and self.var_gender.get() != '' and self.var_age.get() != '':
    				# 打开数据库连接
    				db = pymysql.connect("localhost", "root", "root", "student")
    				cursor = db.cursor()  # 使用cursor()方法获取操作游标
    				sql = "INSERT INTO student_k(id, name, gender, age) \
    				       VALUES ('%s', '%s', '%s', '%s')" % \
    					  (self.var_id.get(), self.var_name.get(), self.var_gender.get(), self.var_age.get())  # SQL 插入语句
    				try:
    					cursor.execute(sql)  # 执行sql语句
    					db.commit()  # 提交到数据库执行
    				except:
    					db.rollback()  # 发生错误时回滚
    					messagebox.showinfo('警告!', '数据库连接失败!')
    				db.close()  # 关闭数据库连接
    
    				self.id.append(self.var_id.get())
    				self.name.append(self.var_name.get())
    				self.gender.append(self.var_gender.get())
    				self.age.append(self.var_age.get())
    				self.tree.insert('', len(self.id) - 1, values=(
    				self.id[len(self.id) - 1], self.name[len(self.id) - 1], self.gender[len(self.id) - 1],
    				self.age[len(self.id) - 1]))
    				self.tree.update()
    				messagebox.showinfo('提示!', '插入成功!')
    			else:
    				messagebox.showinfo('警告!', '请填写学生数据')
    
    	def updata_row(self):
    		res = messagebox.askyesnocancel('警告!', '是否更新所填数据?')
    		if res == True:
    			if self.var_id.get() == self.row_info[0]:  # 如果所填学号 与 所选学号一致
    				# 打开数据库连接
    				db = pymysql.connect("localhost", "root", "root", "student")
    				cursor = db.cursor()  # 使用cursor()方法获取操作游标
    				sql = "UPDATE student_k SET name = '%s', gender = '%s', age = '%s' \
    				 WHERE id = '%s'" % (self.var_name.get(), self.var_gender.get(), self.var_age.get(), self.var_id.get())  # SQL 插入语句
    				try:
    					cursor.execute(sql)  # 执行sql语句
    					db.commit()  # 提交到数据库执行
    					messagebox.showinfo('提示!', '更新成功!')
    				except:
    					db.rollback()  # 发生错误时回滚
    					messagebox.showinfo('警告!', '更新失败,数据库连接失败!')
    				db.close()  # 关闭数据库连接
    
    				id_index = self.id.index(self.row_info[0])
    				self.name[id_index] = self.var_name.get()
    				self.gender[id_index] = self.var_gender.get()
    				self.age[id_index] = self.var_age.get()
    
    				self.tree.item(self.tree.selection()[0], values=(
    					self.var_id.get(), self.var_name.get(), self.var_gender.get(),
    					self.var_age.get()))  # 修改对于行信息
    			else:
    				messagebox.showinfo('警告!', '不能修改学生学号!')
    
    	def del_row(self):
    		res = messagebox.askyesnocancel('警告!', '是否删除所选数据?')
    		if res == True:
    			print(self.row_info[0])  # 鼠标选中的学号
    			print(self.tree.selection()[0])  # 行号
    			print(self.tree.get_children())  # 所有行
    			# 打开数据库连接
    			db = pymysql.connect("localhost", "root", "root", "student")
    			cursor = db.cursor()  # 使用cursor()方法获取操作游标
    			sql = "DELETE FROM student_k WHERE id = '%s'" % (self.row_info[0]) # SQL 插入语句
    			try:
    				cursor.execute(sql)  # 执行sql语句
    				db.commit()  # 提交到数据库执行
    				messagebox.showinfo('提示!', '删除成功!')
    			except:
    				db.rollback()  # 发生错误时回滚
    				messagebox.showinfo('警告!', '删除失败,数据库连接失败!')
    			db.close()  # 关闭数据库连接
    
    			id_index = self.id.index(self.row_info[0])
    			print(id_index)
    			del self.id[id_index]
    			del self.name[id_index]
    			del self.gender[id_index]
    			del self.age[id_index]
    			print(self.id)
    			self.tree.delete(self.tree.selection()[0])  # 删除所选行
    			print(self.tree.get_children())
    
    
    # 学生查看信息界面
    class StudentView:
    	def __init__(self, parent_window, student_id):
    		parent_window.destroy() # 销毁主界面
    
    		self.window = tk.Tk()  # 初始框的声明
    		self.window.title('关于')
    		self.window.geometry('300x450')  # 这里的乘是小x
    
    		label = tk.Label(self.window, text='学生信息查看', bg='green', font=('Verdana', 20), width=30, height=2)
    		label.pack(pady=20)
    
    		self.id = '学号:' + ''
    		self.name = '姓名:' + ''
    		self.gender = '性别:' + ''
    		self.age = '年龄:' + ''
    		# 打开数据库连接
    		db = pymysql.connect("localhost", "root", "root", "student")
    		cursor = db.cursor()# 使用cursor()方法获取操作游标
    		sql = "SELECT * FROM student_k WHERE id = '%s'" % (student_id) # SQL 查询语句
    		try:
    			# 执行SQL语句
    			cursor.execute(sql)
    			# 获取所有记录列表
    			results = cursor.fetchall()
    			for row in results:
    				self.id = '学号:' + row[0]
    				self.name = '姓名:' + row[1]
    				self.gender = '性别:' + row[2]
    				self.age = '年龄:' + row[3]
    		except:
    			print("Error: unable to fetch data")
    		db.close()		# 关闭数据库连接
    
    		Label(self.window, text=self.id, font=('Verdana', 18)).pack(pady=5)
    		Label(self.window, text=self.name, font=('Verdana', 18)).pack(pady=5)
    		Label(self.window, text=self.gender, font=('Verdana', 18)).pack(pady=5)
    		Label(self.window, text=self.age, font=('Verdana', 18)).pack(pady=5)
    
    		Button(self.window, text="返回首页", width=8, font=tkFont.Font(size=16), command=self.back).pack(pady=25)
    
    		self.window.protocol("WM_DELETE_WINDOW", self.back)  # 捕捉右上角关闭点击
    		self.window.mainloop()  # 进入消息循环
    
    	def back(self):
    		StartPage(self.window)  # 显示主窗口 销毁本窗口
    
    
    # About页面
    class AboutPage:
    	def __init__(self, parent_window):
    		parent_window.destroy() # 销毁主界面
    
    		self.window = tk.Tk()  # 初始框的声明
    		self.window.title('关于')
    		self.window.geometry('300x450')  # 这里的乘是小x
    
    		label = tk.Label(self.window, text='学生信息管理系统', bg='green', font=('Verdana', 20), width=30, height=2)
    		label.pack()
    
    		Label(self.window, text='作者:清晨的光明', font=('Verdana', 18)).pack(pady=30)
    		Label(self.window, text='blog.csdn.net/kdongyi', font=('Verdana', 18)).pack(pady=5)
    
    		Button(self.window, text="返回首页", width=8, font=tkFont.Font(size=12), command=self.back).pack(pady=100)
    
    		self.window.protocol("WM_DELETE_WINDOW", self.back)  # 捕捉右上角关闭点击
    		self.window.mainloop()  # 进入消息循环
    
    	def back(self):
    		StartPage(self.window)  # 显示主窗口 销毁本窗口
    
    
    if __name__ == '__main__':
    	try:
    		# 打开数据库连接 连接测试
    		db = pymysql.connect("localhost", "root", "root", "student")
    		# 使用cursor()方法获取操作游标
    		cursor = db.cursor()
    		# 如果数据表不存在则创建表 若存在则跳过
    		# 设置主键唯一
    		sql = """CREATE TABLE IF NOT EXISTS student_k(
    				id char(20) NOT NULL,
    				name char(20) default NULL,
    				gender char(5) default NULL,  
    				age char(5) default NULL,
    				PRIMARY KEY (id)
    				
    				) ENGINE = InnoDB 
    				DEFAULT	CHARSET = utf8
    				"""
    		cursor.execute(sql)
    		# 如果数据表不存在则创建表 若存在则跳过
    		sql = """CREATE TABLE IF NOT EXISTS admin_login_k(
    						admin_id char(20) NOT NULL,
    						admin_pass char(20) default NULL,
    						PRIMARY KEY (admin_id)
    						) ENGINE = InnoDB 
    						DEFAULT	CHARSET = utf8
    						"""
    		cursor.execute(sql)
    		# 如果数据表不存在则创建表 若存在则跳过
    		sql = """CREATE TABLE IF NOT EXISTS stu_login_k(
    						stu_id char(20) NOT NULL,
    						stu_pass char(20) default NULL,
    						PRIMARY KEY (stu_id)
    						) ENGINE = InnoDB 
    						DEFAULT	CHARSET = utf8
    						"""
    		cursor.execute(sql)
    
    		# 关闭数据库连接
    		db.close()
    
    		# 实例化Application
    		window = tk.Tk()
    		StartPage(window)
    	except:
    		messagebox.showinfo('错误!', '连接数据库失败!')
    
    

     下面是我从我电脑数据库转储的SQL文件:

    /*
    Navicat MySQL Data Transfer
    
    Source Server         : mysql
    Source Server Version : 50532
    Source Host           : localhost:3306
    Source Database       : student
    
    Target Server Type    : MYSQL
    Target Server Version : 50532
    File Encoding         : 65001
    
    Date: 2019-11-28 15:09:36
    */
    
    SET FOREIGN_KEY_CHECKS=0;
    
    -- ----------------------------
    -- Table structure for `admin_login_k`
    -- ----------------------------
    DROP TABLE IF EXISTS `admin_login_k`;
    CREATE TABLE `admin_login_k` (
      `admin_id` char(20) NOT NULL,
      `admin_pass` char(20) DEFAULT NULL,
      PRIMARY KEY (`admin_id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    -- Records of admin_login_k
    -- ----------------------------
    INSERT INTO `admin_login_k` VALUES ('admin', 'admin');
    
    -- ----------------------------
    -- Table structure for `student_k`
    -- ----------------------------
    DROP TABLE IF EXISTS `student_k`;
    CREATE TABLE `student_k` (
      `id` char(20) NOT NULL,
      `name` char(20) DEFAULT NULL,
      `gender` char(5) DEFAULT NULL,
      `age` char(5) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    -- Records of student_k
    -- ----------------------------
    INSERT INTO `student_k` VALUES ('182085211003', 'a', '女', '22');
    INSERT INTO `student_k` VALUES ('182085211004', 'b', '女', '18');
    INSERT INTO `student_k` VALUES ('182085211005', 'abc', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211006', 'abc', '女', '24');
    INSERT INTO `student_k` VALUES ('182085211008', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211009', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211010', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211011', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('1820852110111', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211012', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211013', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211014', 'Tom2', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211015', 'Tom1', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211016', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211017', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211018', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211019', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211020', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211021', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('1820852110211', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211022', 'Tom1', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211023', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211024', 'Tom', '男', '23');
    INSERT INTO `student_k` VALUES ('182085211034', 'Tom', '男', '23');
    
    -- ----------------------------
    -- Table structure for `stu_login_k`
    -- ----------------------------
    DROP TABLE IF EXISTS `stu_login_k`;
    CREATE TABLE `stu_login_k` (
      `stu_id` char(20) NOT NULL,
      `stu_pass` char(20) DEFAULT NULL,
      PRIMARY KEY (`stu_id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    -- Records of stu_login_k
    -- ----------------------------
    INSERT INTO `stu_login_k` VALUES ('182085211000', '123456');
    
    -- ----------------------------
    -- Table structure for `t_course`
    -- ----------------------------
    DROP TABLE IF EXISTS `t_course`;
    CREATE TABLE `t_course` (
      `SNO` char(255) NOT NULL,
      `COURSE` char(255) DEFAULT NULL,
      `CREDIT` char(255) DEFAULT NULL,
      `GRADE` char(255) DEFAULT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    -- Records of t_course
    -- ----------------------------
    INSERT INTO `t_course` VALUES ('08300205', '程序设计', '4', '88');
    INSERT INTO `t_course` VALUES ('08300205', '数据库', '2.5', '90');
    INSERT INTO `t_course` VALUES ('08300205', '力学', '5', '92');
    INSERT INTO `t_course` VALUES ('08080929', '数据库', '2.5', '85');
    INSERT INTO `t_course` VALUES ('09350124', '数据库', '2.5', '92');
    INSERT INTO `t_course` VALUES ('09620233', '数据库', '2.5', '80');
    INSERT INTO `t_course` VALUES ('09300218', '数据库', '2.5', '78');
    INSERT INTO `t_course` VALUES ('09010122', '数据库', '2.5', '87');
    INSERT INTO `t_course` VALUES ('08080929', '程序设计', '4', '86');
    INSERT INTO `t_course` VALUES ('09010122', '程序设计', '4', '80');
    INSERT INTO `t_course` VALUES ('08300516', '程序设计', '4', '76');
    
    -- ----------------------------
    -- Table structure for `t_st`
    -- ----------------------------
    DROP TABLE IF EXISTS `t_st`;
    CREATE TABLE `t_st` (
      `SNO` char(11) NOT NULL,
      `SNAME` char(255) DEFAULT NULL,
      `SSEX` char(255) DEFAULT NULL,
      `AGE` char(255) DEFAULT NULL,
      `DEPT` char(255) DEFAULT NULL,
      PRIMARY KEY (`SNO`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    -- Records of t_st
    -- ----------------------------
    INSERT INTO `t_st` VALUES ('08080929', '刘超世', '男', '19', '计算机应用技术');
    INSERT INTO `t_st` VALUES ('08300205', '李媛媛', '女', '19', '软件工程');
    INSERT INTO `t_st` VALUES ('09300218', '王海超', '男', '19', '软件工程');
    INSERT INTO `t_st` VALUES ('09350124', '王彤', '女', '19', '通信原理');
    INSERT INTO `t_st` VALUES ('09620233', '陈晓丽', '女', '21', '通信工程');
    

    觉得有用,点个赞再走吧^_^

    展开全文
  • 创建一个学生管理应用,基本信息包含学生姓名,班级,学号。采用文件存储 和数据库存储两种方式存储这些信息 应用应该至少包含信息录入和信息显示两个页面 最终生成文件存储和数据库存储两个程序,完成同一个功能...

    分别使用sqlite3工具和Android代码的方式建立SQLite数据库。在完成建立数据库的工作后,编程实现基本的数据库操作功能,包括数据的添加、删除和更新,

    1. 创建一个学生管理的应用,基本信息包含学生姓名,班级,学号。采用文件存储
      和数据库存储两种方式存储这些信息
    2. 应用应该至少包含信息录入和信息显示两个页面
    3. 最终生成文件存储和数据库存储两个程序,完成同一个功能。
    4. 分析文件存储和数据库存储的异同,以及使用场合

    1:先使用sharepreference来完成对数据的存储
    接下来直接附上代码

    主操作ctivity

    package com.example.sharepreferencesave;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    
    import android.app.Activity;
    import android.content.Context;
    import android.media.MediaMuxer.OutputFormat;
    import android.os.Bundle;
    import android.view.Menu;
    import android.view.MenuItem;
    import android.view.TextureView;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.widget.Button;
    import android.widget.CheckBox;
    import android.widget.EditText;
    import android.widget.TextView;
    import android.widget.Toast;
    
    public class MainActivity extends Activity implements OnClickListener{
    
        private final String fileName = "fileDemo.xml";
        private EditText addSnoEditText,addSnameEditText,addClassEditText;
        private Button btnAdd,btnRead;
        private CheckBox chk;
        private TextView tvShow;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
             btnRead = (Button)findViewById(R.id.btnRead);
             btnAdd = (Button)findViewById(R.id.btnAdd);
             addSnoEditText = (EditText)findViewById(R.id.addSnoEditText);
             addSnameEditText = (EditText)findViewById(R.id.addSnameEditText);
             addClassEditText = (EditText)findViewById(R.id.addClassEditText);
             chk = (CheckBox)findViewById(R.id.appendBox);
             tvShow = (TextView)findViewById(R.id.tvShow);
    
             btnRead.setOnClickListener(this);
             btnAdd.setOnClickListener(this);
        }
    
        @Override
        public boolean onCreateOptionsMenu(Menu menu) {
            // Inflate the menu; this adds items to the action bar if it is present.
            getMenuInflater().inflate(R.menu.main, menu);
            return true;
        }
    
        @Override
        public boolean onOptionsItemSelected(MenuItem item) {
            // Handle action bar item clicks here. The action bar will
            // automatically handle clicks on the Home/Up button, so long
            // as you specify a parent activity in AndroidManifest.xml.
            int id = item.getItemId();
            if (id == R.id.action_settings) {
                return true;
            }
            return super.onOptionsItemSelected(item);
        }
    
        @Override
        public void onClick(View v) {
            // TODO Auto-generated method stub
            switch (v.getId()) {
            case R.id.btnAdd:
            {
                FileOutputStream fos =null;
    
                //针对文本框是否被选中选择不同的写入方式
                try{
    
                if(chk.isChecked())
                {
                    fos = openFileOutput(fileName, MODE_APPEND);
    
    
                    String sno = addSnoEditText.getText().toString();
                    String sname = addSnameEditText.getText().toString();
                    String classes = addClassEditText.getText().toString();
    
                    //将数据写到文本文件中
                    String msg  = sno+sname+classes;
                    fos.write(msg.getBytes());
                    tvShow.setText("文件追加 成功,写入长度:"+msg.length());
    
                     addSnoEditText.setText("");
                     addSnameEditText.setText("");
                     addClassEditText.setText("");
                     Toast.makeText(this, "文件追加", Toast.LENGTH_LONG).show();    
                }else {
                    fos = openFileOutput(fileName, MODE_PRIVATE);
                    //获取文本框中的输入数据
                    String sno = addSnoEditText.getText().toString();
                    String sname = addSnameEditText.getText().toString();
                    String classes = addClassEditText.getText().toString();
    
                    //将数据写到文本文件中
                    String msg  = sno+sname+classes;
                    fos.write(msg.getBytes());
                    tvShow.setText("文件写入成功,写入长度:"+msg.length());
    
                     addSnoEditText.setText("");
                     addSnameEditText.setText("");
                     addClassEditText.setText("");
                     Toast.makeText(this, "文件写入成功", Toast.LENGTH_LONG).show();  
                }
                }catch (Exception e) {
                    // TODO: handle exception
                    e.printStackTrace();
                    Toast.makeText(this, "写入出错", Toast.LENGTH_LONG);
                }finally {
                    if(fos!=null)
                    {
                        try{
                            fos.flush();
                            fos.close();
                            fos=null;
                        }catch(Exception e)
                        {
    
                        }
                    }   
                }
                break;
            }   
            case R.id.btnRead:
                {
                    tvShow.setText("");
                    FileInputStream fis = null;
                    try {
                    fis  = openFileInput(fileName);
    
                    if (fis.available()==0) {
    
                        Toast.makeText(this, "文本数据为空不能读入", Toast.LENGTH_LONG);
    
                        return ;
                    }
                    else {
    
                        byte [] bytes = new byte[fis.available()];
                        fis.read(bytes);
    
                        String msg = new String(bytes,"utf-8");
    
                        tvShow.setText(msg);
                        Toast.makeText(this, "文本数据读取成功", Toast.LENGTH_LONG);
    
                    }
    
    
                }catch (Exception e) {
                    // TODO: handle exception
    
    
                } finally {
                    // TODO: handle finally clause
                    if (fis != null){
                        try {
    
                            fis.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }           
                    }
                }   
                break;
    
                }
            default:
                break;
            }
    
        }
    }
    

    界面显示效果如下
    这里写图片描述

    其中xml文件如下

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        android:orientation="vertical"
        tools:context="com.example.sharepreferencesave.MainActivity" >
    
         <TableLayout
                android:layout_width="match_parent"
                android:layout_height="wrap_content" >
                <TableRow
                    android:id="@+id/tableRow1"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content" >
                    <TextView
                        android:id="@+id/viewSno"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="学号" />
    
                      <EditText
                        android:id="@+id/addSnoEditText"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:ems="10" />
    
                </TableRow>
                <TableRow
                    android:id="@+id/tableRow2"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content" >
                    <TextView
                        android:id="@+id/viewSname"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="姓名" />
                    <EditText
                        android:id="@+id/addSnameEditText"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:ems="10" />
                </TableRow>
    
                <TableRow
                    android:id="@+id/tableRow3"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content" >
    
                    <TextView
                        android:id="@+id/viewClass"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="班级" />
                    <EditText
                        android:id="@+id/addClassEditText"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:ems="10" />
                </TableRow>
                <LinearLayout 
                    android:layout_height="wrap_content"
                    android:layout_width="wrap_content" >
                  <TableLayout 
                      android:layout_width="fill_parent"
                      android:layout_height="wrap_content"
                      >
                      <TableRow
                          android:id="@+id/tableRow4"
                          android:layout_width="wrap_content"
                          android:layout_height="wrap_content" >
    
                          <Button
                              android:id="@+id/btnAdd"
                              android:layout_width="wrap_content"
                              android:layout_height="wrap_content"
                              android:text="写入" />
                          <TextView
                              android:id="@+id/appendView"
                              android:layout_width="wrap_content"
                              android:layout_height="wrap_content"
                              android:text="追加模式" />
    
                          <CheckBox
                              android:id="@+id/appendBox"
                              android:layout_width="wrap_content"
                              android:layout_height="wrap_content"
                              android:text="追加" />
    
    
                            <Button
                              android:id="@+id/btnRead"
                              android:layout_width="wrap_content"
                              android:layout_height="wrap_content"
                              android:text="读取" />
                      </TableRow>
    
                 </TableLayout>
    
                </LinearLayout>
    
         </TableLayout>
    
         <LinearLayout
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:orientation="vertical" >
    
             <TextView
                 android:id="@+id/tvShow"
                 android:layout_width="fill_parent"
                 android:layout_height="wrap_content"
                 android:text="" />
    
         </LinearLayout>
    
    </LinearLayout>
    

    上面要实现的操作是文件存储,对于一把情况下我们还要实现数据库的存储,所以同样存储上面的信息我们采用数据库存储信息

    接下来显示主要的数据库代码
    DBAdapter.java

    package com.example.usesqlite;
    
    import android.R.integer;
    import android.content.ContentValues;
    import android.content.Context;
    import android.database.Cursor;
    import android.database.sqlite.SQLiteDatabase;
    import android.database.sqlite.SQLiteException;
    import android.database.sqlite.SQLiteDatabase.CursorFactory;
    import android.database.sqlite.SQLiteOpenHelper;
    
    public class DBAdapter {
    
        private final Context context;
        private SQLiteDatabase db;
    
        private DBHelper dbHelper;
    
       private final static String DB_TABLE="studentinfo";
       private final static String DB_NAME="student.db";
       private final static int DB_VERSION=1;
    
       private final static String KEY_ID="id";
       private final static String KEY_SNO="sno";
       private final static String KEY_SNAME="sname";
       private final static String KEY_CLASSES="classes";
    
    
    
        public DBAdapter(Context _cContext) {
            // TODO Auto-generated constructor stub
    
            context = _cContext;
          }
    
        //关闭数据库的连接
        public void close()
        {
            if(db!=null)
            {
                db.close();
                db=null;
            }
        }
    
       public void open() throws SQLiteException
       {
           dbHelper = new DBHelper(context, DB_NAME, null, DB_VERSION);
    
    
            try{ 
                  db = dbHelper.getWritableDatabase();
                }catch(Exception e)
                {
                   db  = dbHelper.getReadableDatabase();
                }
       }
    
       //插入数据
       public long insert(Student s)
       {
    
            ContentValues cv = new ContentValues();
            cv.put(KEY_SNO,s.getSno() );
            cv.put(KEY_SNAME, s.getSname());
            cv.put(KEY_CLASSES, s.getClasses());
    
            return db.insert(DB_TABLE, null, cv);
       }
    
    
    
       //查询所有的数据
       public Student[] findAllStudent()
       {
    
             Cursor c = db.query(DB_TABLE, null, null, null, null,null, null);
    //       while (c.moveToNext()) {
    //          System.out.println(c.getString(c.getColumnIndex("sno")));
    //          
    //      }
             return  convertToStudent(c);
       }
    
    
    
      public long deleteAllStudent()
      {
    
          return db.delete(DB_TABLE, null, null);
    
      }
    
    
      //这种方发比较好能够防止sql注入
      public long deleteBySno(String sno)
      {
          return db.delete(DB_TABLE, "sno=?", new String[]{sno});
      }
    
      //这种方式其实不太好存在sql注入的问题,但是一般的情况下是可以使用的
     public long deleteBYId(int id)
     {
    
         return db.delete(DB_TABLE, "id="+id, null);
     }
    
    
     public Student[] findStudentsBySno(String sno)
     {
         Cursor c = db.query(DB_TABLE, null, "sno=?", new String[]{sno}, null, null, null);
         return  convertToStudent(c);
     }
    
     public long updateOneStudentById(int id,Student s)
     {
         ContentValues cv = new ContentValues();
         cv.put(KEY_SNO, s.getSno());
         cv.put(KEY_SNAME, s.getSname());
         cv.put(KEY_CLASSES, s.getClasses());
    
         return db.update(DB_TABLE, cv, "id="+id, null);
    
    
     }
     public Student[] findOneStudentByID(int ID)
     {
    
         Cursor c = db.query(DB_TABLE, null, "id="+ID, null, null, null, null);
    
    
         return convertToStudent(c);
    
     }
    
       //转换函数
       public Student[] convertToStudent(Cursor c)
       {
           int resultsCount = c.getCount();
    
           if(resultsCount==0||!c.moveToFirst())
           {
    
               return null;
           }
    
           Student []stu = new Student[resultsCount];   
           for (int i = 0; i < stu.length; i++) {
    //         System.out.println("HHHHH");
    //         stu[i].setId(c.getInt(c.getColumnIndex(KEY_ID)));
    //         stu[i].setSno(c.getString(c.getColumnIndex(KEY_SNO)));
    //         stu[i].setSname(c.getString(c.getColumnIndex(KEY_SNAME)));
    //         stu[i].setClasses(c.getString(c.getColumnIndex(KEY_CLASSES)));
    //         stu[i].setId(c.getInt(0));
    //         System.out.println(sno+"\n"+sname+"\n"+classes+"\n");
    //         stu[i].sno=c.getString(c.getColumnIndex(KEY_SNO));
    //         stu[i].sname = c.getString(c.getColumnIndex(KEY_SNAME));
    //         stu[i].classes = c.getString(c.getColumnIndex(KEY_CLASSES));
    //         stu[i].setSno(sno);
    //         stu[i].setSname(sname);
    //         stu[i].setClasses(classes);
               stu[i] = new Student();
               String sno  = c.getString(c.getColumnIndex("sno"));
               String sname = c.getString(c.getColumnIndex("sname"));
               String classes = c.getString(c.getColumnIndex("classes"));
               stu[i].id=c.getInt(0);
               stu[i].setSno(sno);
               stu[i].setSname(sname);
               stu[i].setClasses(classes);
               //切记不可少了这一句,这个是循环的条件
               c.moveToNext(); 
            }
    
           return stu;
    
       }
    
    
       //内部的静态类用于创建数据库和建立数据库链接
        private   static class DBHelper extends SQLiteOpenHelper{
    
            public DBHelper(Context context, String name, CursorFactory factory, int version) {
                super(context, name, factory, version);
                // TODO Auto-generated constructor stub
            }
            private static final String SQL="CREATE TABLE studentinfo ("
                    + "id INTEGER PRIMARY KEY AUTOINCREMENT,"
                    + "sno TEXT DEFAULT NONE,"
                    + "sname TEXT DEFAULT NONE,"
                    + "classes TEXT DEFAULT NONE"
                    + ")";
    
    
    
            @Override
            public void onCreate(SQLiteDatabase db) {
                // TODO Auto-generated method stub
    
                db.execSQL(SQL);
            }
    
            @Override
            public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
                // TODO Auto-generated method stub
                db.execSQL("DROP TABLE IF EXISTS"+DB_TABLE);
                onCreate(db);
    
            }
    
    
    
        }
    }
    
    

    实体student类

    package com.example.usesqlite;
    
    import java.io.Serializable;
    
    public class Student implements Serializable{
    
        public  int id=-1;
        public String sno;
        public  String sname;
        public String classes;
    
        public Integer getId() {
            return id;
        }
        public void setId(Integer id) {
            this.id = id;
        }
        public String getSno() {
            return sno;
        }
        public void setSno(String sno) {
            this.sno = sno;
        }
        public String getSname() {
            return sname;
        }
        public void setSname(String sname) {
            this.sname = sname;
        }
        public String getClasses() {
            return classes;
        }
        public void setClasses(String classes) {
            this.classes = classes;
        }
        @Override
        public String toString() {
            return "id:" + id +"  " + "学号:" + sno +"  "+ "姓名:" + sname +"  "+ "班级:" + classes ;
        }
    }
    

    Mainactivity

    package com.example.usesqlite;
    
    import android.R.integer;
    import android.app.Activity;
    import android.content.ContentValues;
    import android.database.Cursor;
    import android.database.sqlite.SQLiteDatabase;
    import android.os.Bundle;
    import android.view.Menu;
    import android.view.MenuItem;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.widget.Adapter;
    import android.widget.Button;
    import android.widget.EditText;
    import android.widget.TextView;
    import android.widget.Toast;
    
    public  class MainActivity extends Activity implements OnClickListener{
    
        private DBAdapter dbAdapter;
        private EditText addSnoEditText,addSnameEditText,addClassEditText,dleteBySnoEditText,deleteByIdEditText,findBySnoEditText,findOneStudentByIdEditText,updateByIdEditText;
        private Button btnAdd,btnFindAll,btnClearAllData,btnClearShowView,btnDeleteBySno,btnDeleteById,btnFindBySno,btnFindOneStudentById,btnUpdateById;
        private TextView labelShow;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
    //      DB db = new DB(this);
    //      SQLiteDatabase dbWrite  =  db.getWritableDatabase();
    //      //构造一条数据
    //      ContentValues cv = new ContentValues();
    //      cv.put("name", "小张");
    //      cv.put("sex", "男");
    //      dbWrite.insert("user", null, cv);
    //      cv = new ContentValues();
    //      cv.put("name", "小李");
    //      cv.put("sex", "女");
    //      dbWrite.insert("user", null, cv);
    //      dbWrite.close();
    //      SQLiteDatabase dbRead = db.getReadableDatabase();
            //将所有的数据都返回,所以columns这一咧指定为空,代表查询到所有的数据
            //selection代表查询的条件
            //selectionArgs代表查询条件的参数
    //       groupBy用于指定分组
    //       having用于指定条件
    //       orderBy用于指定排序
    //      dbRead.query("user", null, "name=?", new String[]{"小张"}, groupBy, having, orderBy)
            //返回值为游标类型的     
    //     Cursor cursor = dbRead.query("user", null, null, null, null, null, null);
    //     while (cursor.moveToNext()) {
    //       String name = cursor.getString(cursor.getColumnIndex("name"));
    //       String sex = cursor.getString(cursor.getColumnIndex("sex"));
    //       System.out.println(name +"\n" + sex+"\n");
    //       }
    
    
            btnAdd = (Button)findViewById(R.id.btnAdd);
            btnFindAll = (Button)findViewById(R.id.btnFindAll);
            addSnoEditText = (EditText)findViewById(R.id.addSno);
            addSnameEditText = (EditText)findViewById(R.id.addSname);
            addClassEditText = (EditText)findViewById(R.id.addClass);
            labelShow  = (TextView)findViewById(R.id.labelShow);
            btnClearShowView = (Button)findViewById(R.id.btnClearShowView);
            btnClearAllData = (Button)findViewById(R.id.btnClearAllData);
            btnDeleteById = (Button)findViewById(R.id.btnDeleteById);
            btnDeleteBySno = (Button)findViewById(R.id.btnDeleteBySno);
            dleteBySnoEditText = (EditText)findViewById(R.id.dleteBySnoEditText);
            deleteByIdEditText= (EditText)findViewById(R.id.deleteByIdEditText);
            findBySnoEditText = (EditText)findViewById(R.id.findBySnoEditText);
            updateByIdEditText = (EditText)findViewById(R.id.updateByIdEditText);
            btnUpdateById = (Button)findViewById(R.id.btnUpdateById);
            findOneStudentByIdEditText = (EditText)findViewById(R.id.findOneStudentByIdEditText);
            btnFindBySno = (Button)findViewById(R.id.btnFindBySno);
            btnFindOneStudentById = (Button)findViewById(R.id.btnFindOneStudentById);
    
    
            btnAdd.setOnClickListener(this);
            btnFindAll.setOnClickListener(this);
            btnClearShowView.setOnClickListener(this);
            btnClearAllData.setOnClickListener(this);
            btnDeleteById.setOnClickListener(this);
            btnDeleteBySno.setOnClickListener(this);
            btnFindBySno.setOnClickListener(this);
              btnFindOneStudentById .setOnClickListener(this);
              btnUpdateById.setOnClickListener(this);
    
    
            dbAdapter = new DBAdapter(this);
            dbAdapter.open();
    
    
    
        }
    
        @Override
        public boolean onCreateOptionsMenu(Menu menu) {
            // Inflate the menu; this adds items to the action bar if it is present.
            getMenuInflater().inflate(R.menu.main, menu);
            return true;
        }
    
        @Override
        public boolean onOptionsItemSelected(MenuItem item) {
            // Handle action bar item clicks here. The action bar will
            // automatically handle clicks on the Home/Up button, so long
            // as you specify a parent activity in AndroidManifest.xml.
            int id = item.getItemId();
            if (id == R.id.action_settings) {
                return true;
            }
            return super.onOptionsItemSelected(item);
        }
    
        @Override
        public void onClick(View v) {
            // TODO Auto-generated method stub
            switch (v.getId()) {
            //添加数据
            case R.id.btnAdd:
            {
                Student ss = new Student();
                String sno = addSnoEditText.getText().toString();
                String sname = addSnameEditText.getText().toString();
                String classes = addClassEditText.getText().toString();
                ss.setSno(sno);
                ss.setSname(sname);
                ss.setClasses(classes);
                dbAdapter.insert(ss);
                Toast.makeText(this, "添加成功",Toast.LENGTH_LONG).show();
    
                //清空上一次的文本框输入的数据
                addSnoEditText.setText("");
                addSnameEditText.setText("");
                addClassEditText.setText("");
    
    
                //跟新添加数据后的显示频
                Student[] s =dbAdapter.findAllStudent();
                //输出测试
                //          for (int i = 0; i < s.length; i++) {
                //              System.out.println(s[i].getSname()+"\n"+s[i].getClasses()+"\n"+s[i].getSno()+"\n");
                //          }
                if(s==null)
                {
                    labelShow.setText("数据库中不存在数据");
                    Toast.makeText(this, "数据库中不存在数据", Toast.LENGTH_LONG).show();
                    return ;
                }
                else  
                {
                    String msg="";
                    for (int i = 0; i < s.length; i++)
                    {
                        msg += s[i].toString()+"\n";
                    }
                    labelShow.setText(msg);
                }
                break;  
    
            }
            //查询到数据库中所有的数据
            case R.id.btnFindAll:
            {
                Student[] s =dbAdapter.findAllStudent();
                //输出测试
                //          for (int i = 0; i < s.length; i++) {
                //              System.out.println(s[i].getSname()+"\n"+s[i].getClasses()+"\n"+s[i].getSno()+"\n");
                //          }
                if(s==null)
                {
                    labelShow.setText("数据库中不存在数据");
                    Toast.makeText(this, "数据库中不存在数据", Toast.LENGTH_LONG).show();
                    return ;
                }
                else  
                {
                    String msg="";
                    for (int i = 0; i < s.length; i++)
                    {
                        msg += s[i].toString()+"\n";
                    }
                    labelShow.setText(msg);
                }
                break;
            }
            //删除数据库中的所有数据操作
            case R.id.btnClearAllData:
            {
                dbAdapter.deleteAllStudent();
                Toast.makeText(this, "数据库中不存在数据", Toast.LENGTH_LONG).show();
                labelShow.setText("数据全部删除");
                break;
            }
            //清除显示屏幕上的所有数据
            case R.id.btnClearShowView:
            {
                labelShow.setText("");
                Toast.makeText(this, "显示屏清除数据成功", Toast.LENGTH_LONG).show();
                break;
            }
            //按照id来及行删除
            case R.id.btnDeleteById:
            {
    
                String _id = deleteByIdEditText.getText().toString();
    
               if ("".equals(_id)) {
    
                    Toast.makeText(this, "ID不能为空", Toast.LENGTH_LONG).show();
                    return ;
    
                }
                int id = Integer.parseInt(_id);
                labelShow.setText("");
                dbAdapter.deleteBYId(id);
    
    
                Student[] s =dbAdapter.findAllStudent();
                if(s==null)
                {
                    labelShow.setText("数据库中不存在数据");
                    Toast.makeText(this, "数据库中不存在数据", Toast.LENGTH_LONG).show();
                    return ;
                }
                else  
                {
                    String msg="";
                    for (int i = 0; i < s.length; i++)
                    {
                        msg += s[i].toString()+"\n";
                    }
                    labelShow.setText(msg);
                }
                Toast.makeText(this, "删除成功", Toast.LENGTH_LONG).show();
                break;
            }
            //按照学号老进行删除
            case R.id.btnDeleteBySno:
            {
    
                  String sno = dleteBySnoEditText.getText().toString();
                  if ("".equals(sno)) {
    
                        Toast.makeText(this, "学号不能为空", Toast.LENGTH_LONG).show();
                        return ;
    
                    }
                  dbAdapter.deleteBySno(sno);
                 labelShow.setText("");
    
                   Student[] s =dbAdapter.findAllStudent();
                    if(s==null)
                    {
                        labelShow.setText("数据库中不存在数据");
                        Toast.makeText(this, "数据库中不存在数据", Toast.LENGTH_LONG).show();
                        return ;
                    }
                    else  
                    {
                        String msg="";
                        for (int i = 0; i < s.length; i++)
                        {
                            msg += s[i].toString()+"\n";
                        }
                        labelShow.setText(msg);
                    }
                Toast.makeText(this, "删除成功", Toast.LENGTH_LONG).show();
                break;
            }
    
            case R.id.btnFindBySno:
            {
                String sno = findBySnoEditText.getText().toString();
    
                if ("".equals(sno)) {
    
                    Toast.makeText(this, "学号不能为空", Toast.LENGTH_LONG).show();
                    return ;
    
                }
                findBySnoEditText.setText("");
    
                 Student []s =dbAdapter.findStudentsBySno(sno);
                 labelShow.setText("");
    
                 if(s==null)
                    {
                        labelShow.setText("数据库中不存在数据");
                        Toast.makeText(this, "数据库中不存在数据", Toast.LENGTH_LONG).show();
                        return ;
                    }
                    else  
                    {
                        String msg="";
                        for (int i = 0; i < s.length; i++)
                        {
                            msg += s[i].toString()+"\n";
                        }
                        labelShow.setText(msg);
                    }
    
                break;  
            }
    
            case R.id.btnFindOneStudentById:
            {
    
                String _id =findOneStudentByIdEditText.getText().toString();
                   if ("".equals(_id)) {
    
                        Toast.makeText(this, "ID不能为空", Toast.LENGTH_LONG).show();
                        return ;
    
                    }
                int id  = Integer.parseInt(_id);
                labelShow.setText("");
    
                Student[] s = dbAdapter.findOneStudentByID(id);
    
    
                 if(s==null)
                    {
                        labelShow.setText("数据库中不存在数据");
                        Toast.makeText(this, "数据库中不存在数据", Toast.LENGTH_LONG).show();
                        return ;
                    }
                    else  
                    {
                        String msg="";
                        for (int i = 0; i < s.length; i++)
                        {
                            msg += s[i].toString()+"\n";
                        }
                        labelShow.setText(msg);
                    }
    
                break;
    
            }
    
            case R.id.btnUpdateById:
            {
    
                String _id = updateByIdEditText.getText().toString();
                   if ("".equals(_id)) {
    
                        Toast.makeText(this, "ID不能为空", Toast.LENGTH_LONG).show();
                        return ;    
                  }
                int id = Integer.parseInt(_id);
                String sno = addSnoEditText.getText().toString();
                String sname = addSnameEditText.getText().toString();
                String classes = addClassEditText.getText().toString();
    
                Student ss = new Student();
                ss.setId(id);
                ss.setSno(sno);
                ss.setSname(sname);
                ss.setClasses(classes);
                dbAdapter.updateOneStudentById(id, ss);
    
                //查询跟新的数据 显示出来
    
                Student[] s =dbAdapter.findAllStudent();
                //输出测试
                //          for (int i = 0; i < s.length; i++) {
                //              System.out.println(s[i].getSname()+"\n"+s[i].getClasses()+"\n"+s[i].getSno()+"\n");
                //          }
                if(s==null)
                {
                    labelShow.setText("数据库中不存在数据");
                    Toast.makeText(this, "数据库中不存在数据", Toast.LENGTH_LONG).show();
                    return ;
                }
                else  
                {
                    String msg="";
                    for (int i = 0; i < s.length; i++)
                    {
                        msg += s[i].toString()+"\n";
                    }
                    labelShow.setText(msg);
                }
                break;  
            }
    
            default:
    
                break;
            }
        }
    }
    

    xml文件

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context="com.example.usesqlite.MainActivity"
        android:orientation="vertical" >
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical" >
    
            <TableLayout
                android:layout_width="match_parent"
                android:layout_height="wrap_content" >
    
                <TableRow
                    android:id="@+id/tableRow1"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content" >
    
                    <TextView
                        android:id="@+id/viewSno"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="学号" />
    
                    <EditText
                        android:id="@+id/addSno"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:ems="10" >
    
                        <requestFocus />
                    </EditText>
    
                </TableRow>
    
                <TableRow
                    android:id="@+id/tableRow2"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content" >
    
                    <TextView
                        android:id="@+id/viewSname"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="姓名" />
    
                    <EditText
                        android:id="@+id/addSname"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:ems="10" />
    
                </TableRow>
    
                <TableRow
                    android:id="@+id/tableRow3"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content" >
    
                    <TextView
                        android:id="@+id/viewClass"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="班级" />
    
                    <EditText
                        android:id="@+id/addClass"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:ems="10" />
    
                </TableRow>
    
                <LinearLayout android:layout_height="wrap_content" >
    
                <TableRow
                    android:id="@+id/tableRow4"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content" >
    
                    <Button
                        android:id="@+id/btnAdd"
                        android:layout_width="120px"
                        android:layout_height="wrap_content"
                        android:text="添加" />
    
                    <Button
                        android:id="@+id/btnUpdateById"
                        android:layout_width="180px"
                        android:layout_height="wrap_content"
                        android:text="更新根据ID" />
                    <EditText
                        android:id="@+id/updateByIdEditText"
                        android:layout_width="120px"
                        android:layout_height="wrap_content"
                        android:ems="10" />
    
    
                </TableRow>
               </LinearLayout>
            </TableLayout>
    
    
    
    
    
    
    
        </LinearLayout>
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical" >
    
            <TableLayout
                android:layout_width="match_parent"
                android:layout_height="wrap_content" >
    
                <TableRow
                    android:id="@+id/tableRow5"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content" >
    
                    <Button
                        android:id="@+id/btnFindAll"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="查询所有" />
    
                    <Button
                        android:id="@+id/btnFindBySno"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="学号查询" />
    
                    <EditText
                        android:id="@+id/findBySnoEditText"
                        android:layout_width="135px"
                        android:layout_height="wrap_content"
                        android:ems="10" />
    
                </TableRow>
    
                  <TableRow
                    android:id="@+id/tableRow6"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content" >
    
                    <Button
                        android:id="@+id/btnClearShowView"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="清除显示" />
    
                    <Button
                        android:id="@+id/btnDeleteBySno"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="学号删除" />
    
                    <EditText
                        android:id="@+id/dleteBySnoEditText"
                        android:layout_width="135px"
                        android:layout_height="wrap_content"
                        android:ems="10" />
    
                </TableRow>
    
    
    
    
                    <TableRow
                    android:id="@+id/tableRow7"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content" >
    
                    <Button
                        android:id="@+id/btnClearAllData"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="删除所有" />
    
                    <Button
                        android:id="@+id/btnDeleteById"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="ID删除" />
    
                    <EditText
                        android:id="@+id/deleteByIdEditText"
                        android:layout_width="135px"
                        android:layout_height="wrap_content"
                        android:ems="10" />
    
                </TableRow>
    
    
    
            </TableLayout>
    
        </LinearLayout>
    
         <RelativeLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
             >
    
             <Button
                 android:id="@+id/btnFindOneStudentById"
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
                 android:layout_alignParentLeft="true"
                 android:layout_alignParentTop="true"
                 android:text="ID查询" />
    
             <EditText
                 android:id="@+id/findOneStudentByIdEditText"
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
                 android:layout_alignBaseline="@+id/findOneStudentById"
                 android:layout_alignBottom="@+id/findOneStudentById"
                 android:layout_alignParentRight="true"
                 android:ems="10" />
    
        </RelativeLayout>
    
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical" >
    
            <TextView
                android:id="@+id/labelShow"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="" />
    
        </LinearLayout>
    
    </LinearLayout>
    

    最终的实现效果
    这里写图片描述

    代码链接
    http://pan.baidu.com/s/1miAsLoW
    http://pan.baidu.com/s/1bNUdYY

    展开全文
  • 数据库课设之学生信息管理系统

    万次阅读 多人点赞 2019-07-13 17:31:10
    数据库课设之学生信息管理系统 一、系统需求分析 学校每年都有新生入学、老生毕业,还有其他各种人事变动。如何有效地管理这些学生 的信息,帮助学校和老师掌握学生的情况,这就是学生信息管理系统需要完成的功能。 ...

    数据库课设之学生信息管理系统

    一、系统需求分析

    学校每年都有新生入学、老生毕业,还有其他各种人事变动。如何有效地管理这些学生
    的信息,帮助学校和老师掌握学生的情况,这就是学生信息管理系统需要完成的功能。

    1.1 系统功能分析
    本系统主要的功能是收集学生的个人信息,以便向教师提供每个学生在校的情况。系统
    的主要功能有:
    a、学生个人信息输入,包括:姓名、性别、院系、生日、籍贯、生源所在地等。
    b、学生流动情况的输入,包括:转系、休学、复学、退学、毕业。
    c、奖惩情况的输入。
    d、学生个人情况查询和修改,包括流动情况和奖罚情况。

    1.2 系统功能模块设计(划分)
    根据系统功能要求可以将系统分解成几个模
    块来分别设计应用程序界面,如图 1 所示。
    在这里插入图片描述
    1.3 与其它系统的关系
    学生信息管理系统是校园信息管理系统的一个组成部分。它为其它系统,如班级信息管理系统、
    教学管理系统、成绩单系统、宿舍分配系统等,提供学生的基本情况。同时需要其他系统提
    供的班级设置和院系设置等情况。这些系统可以使用同一个数据库,直接相互调用所需的数
    据。

    1.4 数据流程图
    学生信息管理系统的数据流程如图 2 所示。
    在这里插入图片描述

    二、数据库设计

    2.1 数据库需求分析
    根据上一节的数据流程图,可以列出以下记录学生信息所需的数据项和数据结构:
    a、学生:学号、姓名、性别、生日、籍贯、所在院系、所在班级。
    b、处罚记录:记录号、级别、处罚对象、记录时间、详细描述、是否生效。
    c、奖励记录:记录号、级别、奖励对象、记录时间、详细描述。
    d、学籍变更记录:记录号、变更情况、记录对象、记录时间、详细描述。
    所需的外部数据支持:
    e、班级:班级编号、班级名称、所属院系。
    f、院系:代码、名称。

    2.2 数据库概念结构设计
    图 3 是本系统所需数据的 E-R 模型图。
    在这里插入图片描述

    三、各功能模块的设计与实现

    3.1 功能说明
    1、学生个人信息输入
    2、学籍变更情况的输入
    3、奖励情况的输入
    4、处罚情况的输入
    5、学生个人情况查询和修改

    3.2 用户界面设计
    完成数据库创建和功能说明以后,我们可以进行下一步工作,即设计用户界面。由于本
    系统管理内容比较简单,且为校园管理信息系统的一部分,因此使用一个窗体不同的标签页
    来完成系统要求的 5 项功能。
    我们把学生信息管理系统的窗体分成____个主要部分,如图____所示。
    1、应用程序主窗体的创建
    2、学生个人信息输入界面
    3、学籍变更情况输入界面
    4、奖励情况输入界面
    5、处罚情况输入界面
    6、学生个人情况查询和修改界面

    3.3 各功能模块的实现
    1、学生个人信息输入
    2、学籍变更情况输入
    3、奖励情况输入
    4、处罚情况输入
    5、学生个人情况查询和修改
    在这里插入图片描述

    四、系统实现

    根据系统E-R图,需要设计4个数据表来存放学生的信息。为了系统的完整,系统中包括了应用程序设计中所需的4个外部数据表。为了优化数据表结构,部分字段采用代码形式,因此需要附加3个代码表。这11个数据表如表1到表11所示。

    表1 student学生个人信息表
    在这里插入图片描述
    表2 studentxj学籍变更信息表
    在这里插入图片描述
    表3 reward奖励记录信息表
    在这里插入图片描述
    表4 punishment处罚记录信息表
    在这里插入图片描述
    表5 class班级信息表
    在这里插入图片描述
    表6 department院系信息表
    在这里插入图片描述
    表7 change_code学籍变动代码表
    在这里插入图片描述
    表8 reward_levels奖励等级代码表
    在这里插入图片描述
    表9 punish_levels处罚等级代码表
    在这里插入图片描述
    表10 studentdlb学生账号密码登录表
    在这里插入图片描述
    表11 teacherdlb老师账号密码登录表
    在这里插入图片描述
    4.1、学生和教务办老师的账号密码登陆界面
    学生和教务办老师的账号密码登陆界面请见如图3-1学生和教务办老师的账号密码登陆界面。这个界面是进入学生信息管理系统的钥匙并且设置了教务办老师和学生两个权限,为了实现不同权限的登录功能,所以在数据库中设计了学生账号密码登录表和老师账号密码登录表两个表格,然后用户可以选择自己的身份权限输入自己的账号密码进行登录,然后系统通过连接数据库的两个表格去和用户输入的账号密码去相应匹配,只有匹配成功之后才会出现不同的用户主界面,然后才可以进行数据操作。(用户名的填写格式界面文本框有提示)
    实现学生和教务办老师的账号密码登陆界面的全部代码:

    package xr06;
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.Vector;
    import javax.swing.*;
    
    import xr06.DbProcess;
    public class Student_management_login_system extends JFrame implements ActionListener {
    
    	JButton jb1,jb2,jb3=null;  
        JRadioButton jrb1,jrb2=null;  
        JPanel jp0,jp1,jp2,jp3,jp4=null;  
        JTextField jtf=null;  
        JLabel jlb0,jlb1,jlb2,jlb3=null;  
        JPasswordField jpf=null;  
        ButtonGroup bg=null;
        private static DbProcess dbProcess;
        public static void main(String[] args) {  
    
    		Student_management_login_system smls=new Student_management_login_system();  
        }  
        public Student_management_login_system()
        {
        	setIconImage(Toolkit.getDefaultToolkit().getImage("G:\\timg-1.jpg"));//图片可以自己选择换
     
        	jb1=new JButton("登录 (login)");  
        	jb1.setBounds(32, 5, 150, 27);
        	jb1.setBackground(Color.ORANGE);
            jb2=new JButton("重置 (resetting)"); 
            jb2.setBounds(196, 5, 204, 27);
            jb2.setBackground(Color.ORANGE);
            jb3=new JButton("退出 (exit)");
            jb3.setBounds(414, 5, 150, 27);
            jb3.setForeground(Color.BLACK);
            jb3.setBackground(Color.ORANGE);
            jb1.addActionListener(this);  
            jb2.addActionListener(this);  
            jb3.addActionListener(this);  
            jrb1=new JRadioButton("教务办老师 (teacher)");  
            jrb1.setFont(new Font("宋体", Font.BOLD, 15));
            jrb1.setBounds(216, 30, 201, 27);
            jrb1.setBackground(new Color(255, 255, 153));
            jrb2=new JRadioButton("学生 (student)");  
            jrb2.setFont(new Font("宋体", Font.BOLD, 15));
            jrb2.setBounds(423, 30, 163, 27);
            jrb2.setBackground(new Color(255, 255, 153));
            bg=new ButtonGroup();  
            bg.add(jrb1);  
            bg.add(jrb2);  
            jrb2.setSelected(true);
            jp0=new JPanel(); 
            jp0.setBounds(0, 0, 602, 100);
            jp0.setBackground(new Color(255, 255, 153));
            jp1=new JPanel();  
            jp1.setBounds(0, 99, 602, 55);
            jp1.setBackground(new Color(255, 255, 153));
            jp2=new JPanel();  
            jp2.setBounds(0, 152, 602, 70);
            jp2.setBackground(new Color(255, 255, 153));
            jp3=new JPanel();  
            jp3.setBounds(0, 221, 602, 86);
            jp3.setBackground(new Color(255, 255, 153));
            jp4=new JPanel(); 
            jp4.setBounds(0, 307, 602, 93);
            jp4.setBackground(new Color(255, 255, 153));
            jlb0=new JLabel("\u5B66\u751F\u4FE1\u606F\u7BA1\u7406\u7CFB\u7EDF");
            jlb0.setFont(new Font("方正舒体", Font.BOLD, 40));
            jlb0.setBounds(129, 36, 351, 51);
            jlb1=new JLabel("用户名 (user name):");  
            jlb1.setFont(new Font("宋体", Font.BOLD, 18));
            jlb1.setBounds(54, 25, 236, 18);
            jlb2=new JLabel("\u5BC6  \u7801 (pass-word)\uFF1A");  
            jlb2.setFont(new Font("宋体", Font.BOLD, 18));
            jlb2.setBounds(54, 35, 227, 18);
            jlb3=new JLabel("\u8EAB   \u4EFD (Identity)\uFF1A"); 
            jlb3.setFont(new Font("宋体", Font.BOLD, 15));
            jlb3.setBounds(29, 26, 201, 34);
            jtf=new JTextField(15);  
            jtf.setBounds(253, 24, 281, 24);
            jpf=new JPasswordField(15); 
            jpf.setBounds(253, 34, 281, 24);
            jtf.addFocusListener(new JTextFieldHintListener("请输入学号/教职工号", jtf));
            jp0.setLayout(null);
            jp0.add(jlb0);
            jp1.setLayout(null);
            
            jp1.add(jlb1);  
            jp1.add(jtf);  
            jp2.setLayout(null);
    
            jp2.add(jlb2);  
            jp2.add(jpf);  
            jp3.setLayout(null);
    
            jp3.add(jlb3);      //添加标签
            jp3.add(jrb1);  
            jp3.add(jrb2);  
            jp4.setLayout(null);
    
            jp4.add(jb1);       //添加按钮
            jp4.add(jb2);  
            jp4.add(jb3);
            getContentPane().setLayout(null);
            getContentPane().add(jp0);
            getContentPane().add(jp1);  
            getContentPane().add(jp2);  
            getContentPane().add(jp3);  
            getContentPane().add(jp4);
            this.setTitle("学生信息管理系统 ");          
            this.setSize(605,433);         
            this.setLocation(700, 300);           
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);    //设置当关闭窗口时,保证JVM也退出 
            this.setVisible(true);  
            this.setResizable(false); 
        }
    	public void actionPerformed(ActionEvent e) {
    		if(e.getActionCommand().equals("登录 (login)")  
    				&& !jtf.getText().isEmpty()&&!jpf.getText().isEmpty()){
    				System.out.println("actionPerformed(). 登录 (login)");
    				String jtfQueryField = jtf.getText().trim();
    				String jpfQueryField = jpf.getText().trim();
    				queryProcess(jtfQueryField,jpfQueryField);
    				
    				}
    		else if(e.getActionCommand().equals("登录 (login)")  
    				&& jtf.getText().isEmpty()&&!jpf.getText().isEmpty()){
    			JOptionPane.showMessageDialog(null,"请输入用户名!","提示消息",JOptionPane.WARNING_MESSAGE);  
    			}//只有用户名没有输入
    		else if(e.getActionCommand().equals("登录 (login)")  
    				&& jtf.getText().isEmpty()&& jpf.getText().isEmpty()){
    			JOptionPane.showMessageDialog(null,"请输入用户名和密码!","提示消息",JOptionPane.WARNING_MESSAGE);  
    			}//用户名和密码都没有输入
    		else if(e.getActionCommand().equals("登录 (login)")  
    				&& !jtf.getText().isEmpty()&&jpf.getText().isEmpty()){
    			JOptionPane.showMessageDialog(null,"请输入密码!","提示消息",JOptionPane.WARNING_MESSAGE);  
    			}//只有密码没有输入
    		else if(e.getActionCommand().equals("重置 (resetting)")){
    	        jtf.setText("");  
    	        jpf.setText("");  
    			}
    		else{
    			int n=JOptionPane.showConfirmDialog(null,"确定退出系统登陆界面?", "学生信息管理系统",JOptionPane.YES_NO_OPTION);
    			if(n==0) {
    				this.setVisible(false);
    			}
    		}
    	}	
    		public void queryProcess(String jtfQueryField,String jpfQueryField)
    		{
    			if(jrb1.isSelected())  
                {  
    				try{
    					// 建立查询条件
    					String jtfsql = "select * from teacherdlb where ";
    					jtfsql = jtfsql + "tuserNo";
    					jtfsql = jtfsql + " = ";
    					jtfsql = jtfsql + "'" + jtfQueryField + "';";
    					System.out.println("queryProcess(). jtfsql = " + jtfsql);
    					dbProcess = new DbProcess();
    					dbProcess.connect();
    					ResultSet jtfrs = dbProcess.executeQuery(jtfsql);
    					jtfrs.next();
    					System.out.print(jpfQueryField);
    					if(jtfrs.getString("tuserNo").equals(jtfQueryField)&&jtfrs.getString("tpswd").equals(jpfQueryField))  
    			        {            
    			            JOptionPane.showMessageDialog(null,"登录成功!","提示消息",JOptionPane.WARNING_MESSAGE);           
    			            dispose();        
    			            jtf.setText("");  
    				        jpf.setText("");             
    				        Teacher t=new Teacher();       //创建新界面  
    			        }else 
    			        {  
    			            JOptionPane.showMessageDialog(null,"密码错误!请重新输入密码!","提示消息",JOptionPane.WARNING_MESSAGE); 
    			            jpf.setText("");
    			        }
    					dbProcess.disconnect();
    				}catch(SQLException sqle){
    					System.out.println("sqle = " + sqle);
    					JOptionPane.showMessageDialog(null,
    						"用户名或者密码错误!","错误",JOptionPane.ERROR_MESSAGE);
    				}catch(Exception e){
    					System.out.println("e = " + e);
    					JOptionPane.showMessageDialog(null,
    						"用户名或者密码错误!","错误",JOptionPane.ERROR_MESSAGE);
    				}                              //连接到教师的方法 页面
                }
    			if(jrb2.isSelected()) //学生在登录系统  
                {  
                	try{
        				// 建立查询条件
        				String jtfsql = "select * from studentdlb where ";
        				jtfsql = jtfsql + "suserNo";
        				jtfsql = jtfsql + " = ";
        				jtfsql = jtfsql + "'" + jtfQueryField + "';";
        				System.out.println("queryProcess(). jtfsql = " + jtfsql);
        				dbProcess = new DbProcess();
        				dbProcess.connect();
        				ResultSet jtfrs = dbProcess.executeQuery(jtfsql);
        				jtfrs.next();
        				System.out.print(jpfQueryField);
        				if(jtfrs.getString("suserNo").equals(jtfQueryField)&&jtfrs.getString("spswd").equals(jpfQueryField))  
        		        {            
        		            JOptionPane.showMessageDialog(null,"登录成功!","提示消息",JOptionPane.WARNING_MESSAGE);           
        		            dispose();        
        		            jtf.setText("");  
        			        jpf.setText("");             
        		            Student ui=new Student();      //创建新界面  
        		        }else 
        		        {  
        		            JOptionPane.showMessageDialog(null,"密码错误!请重新输入密码!","提示消息",JOptionPane.WARNING_MESSAGE); 
        		            jpf.setText("");
        		        }
        				dbProcess.disconnect();
        			}catch(SQLException sqle){
        				System.out.println("sqle = " + sqle);
        				JOptionPane.showMessageDialog(null,
        					"用户名或者密码错误!","错误",JOptionPane.ERROR_MESSAGE);
        			}catch(Exception e){
        				System.out.println("e = " + e);
        				JOptionPane.showMessageDialog(null,
        					"用户名或者密码错误!","错误",JOptionPane.ERROR_MESSAGE);
        			}                              //连接到学生的方法 页面
                }  
    
    
    			
    		}
    
    }
    
    

    图3-1学生和教务办老师的账号密码登陆界面
    在这里插入图片描述
    4.2、学生用户主界面
    学生用户主界面请见如图3-2学生用户主界面。首先这个界面是在选择学生权限用户登录之后出现的,这个界面可以供用户选择查询各式个人信息以及了解学校学院相关的一些常识或者退出系统(点击相应的按钮,然后会出现相应的功能界面),同时为了使界面更加优化,特别插入了“超越梦想”为主题的图片,希望学生用户能够好好提升自己,为梦想努力奋斗,超越自我,迎来美丽人生。
    实现学生用户主界面的全部代码:

    package xr06;
    import java.util.Vector;
    import java.awt.BorderLayout;
    import java.awt.EventQueue;
    
    import javax.swing.JFrame;
    import javax.swing.JPanel;
    import javax.swing.border.EmptyBorder;
    import javax.swing.JLabel;
    import javax.swing.JOptionPane;
    import javax.swing.JButton;
    import java.awt.event.ActionListener;
    import java.awt.event.ActionEvent;
    import java.awt.Color;
    import java.awt.Font;
    import java.awt.event.MouseAdapter;
    import java.awt.event.MouseEvent;
    import javax.swing.ImageIcon;
    import java.awt.Toolkit;
    
    public class Student extends JFrame implements ActionListener {
    
    	private JPanel contentPane;
    
    	/**
    	 * Launch the application.
    	 */
    	public static void main(String[] args) {
    		
    		Student ui=new Student();
    						
    	}
    	/**
    	 * Create the frame.
    	 */
    	public Student() {
    		setIconImage(Toolkit.getDefaultToolkit().getImage("G:\\timg-1.jpg"));//插入图片
    		this.setResizable(false);
    		setTitle("学生信息管理系统");
    		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		setBounds(700, 320, 579, 409);
    		contentPane = new JPanel();
    		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
    		setContentPane(contentPane);
    		contentPane.setLayout(null);
    		
    		JPanel panel = new JPanel();
    		panel.setBackground(new Color(255, 255, 153));
    		panel.setBounds(0, 0, 573, 374);
    		contentPane.add(panel);
    		panel.setLayout(null);
    			
    		
    		JLabel lblNewLabel = new JLabel("同学你好!欢迎登陆学生信息管理系统");
    		lblNewLabel.setFont(new Font("宋体", Font.BOLD, 20));
    		lblNewLabel.setForeground(new Color(255, 255, 0));
    		lblNewLabel.setBounds(94, 24, 366, 32);
    		panel.add(lblNewLabel);
    		
    		JButton button_1 = new JButton("个人信息查询");
    		button_1.addActionListener(new ActionListener() {
    			public void actionPerformed(ActionEvent e) {
    				dispose();
    				Personcx px = new Personcx();
    			}
    		});
    		button_1.setBounds(86, 90, 167, 32);
    		panel.add(button_1);
    		
    		JButton button_2 = new JButton("个人奖励记录");
    		button_2.addMouseListener(new MouseAdapter() {
    			@Override
    			public void mouseClicked(MouseEvent e) {
    				dispose();
    				Personjl xj = new Personjl();
    			}
    		});
    		button_2.setBounds(86, 148, 167, 32);
    		panel.add(button_2);
    		
    		JButton button_3 = new JButton("个人学籍变更记录");
    		button_3.addMouseListener(new MouseAdapter() {
    			@Override
    			public void mouseClicked(MouseEvent e) {
    				dispose();
    				Personxj xj = new Personxj();
    			}
    		});
    		button_3.setBounds(293, 90, 167, 32);
    		panel.add(button_3);
    		
    		JButton button_4 = new JButton("个人处分记录");
    		button_4.addMouseListener(new MouseAdapter() {
    			@Override
    			public void mouseClicked(MouseEvent e) {
    				dispose();
    				Personcf cf = new Personcf();
    			}
    		});
    		button_4.setBounds(293, 148, 167, 32);
    		panel.add(button_4);
    		
    		JButton button_5 = new JButton("退出");
    		button_5.addMouseListener(new MouseAdapter() {
    			@Override
    			public void mouseClicked(MouseEvent e) {
    				int n=JOptionPane.showConfirmDialog(null,"确定退出该系统?", "学生信息管理系统",JOptionPane.YES_NO_OPTION);
    				if(n==0) {
    					dispose();
    					Student_management_login_system sm=new Student_management_login_system();
    				}
    			}
    		});
    		button_5.setForeground(Color.RED);
    		button_5.setBounds(293, 206, 167, 32);
    		panel.add(button_5);
    		
    		JLabel label = new JLabel("         温馨提示:新生个人登陆系统之后请先查看入学须知");
    		label.setFont(new Font("宋体", Font.PLAIN, 16));
    		label.setForeground(new Color(153, 255, 51));
    		label.setBounds(25, 277, 487, 41);
    		panel.add(label);
    		
    		JButton button = new JButton("入学须知");
    		button.addMouseListener(new MouseAdapter() {
    			@Override
    			public void mouseClicked(MouseEvent e) {
    				dispose();
    				Personrx rx = new Personrx();
    			}
    		});
    		button.setBounds(86, 206, 167, 32);
    		panel.add(button);
    		
    		JLabel lblNewLabel_1 = new JLabel("New label");
    		lblNewLabel_1.setIcon(new ImageIcon("C:\\Users\\\u8C22\u5112\\Pictures\\Camera Roll\\29755920_1478787143469_1024x1024.jpg"));
    		lblNewLabel_1.setBounds(0, 0, 573, 400);
    		panel.add(lblNewLabel_1);
    		this.setVisible(true);
    	}
    
    	@Override
    	public void actionPerformed(ActionEvent e) {
    		// TODO Auto-generated method stub
    		
    	}
    }
    
    

    图3-2学生用户主界面
    在这里插入图片描述
    3.3、老师学生账号密码界面
    老师学生账号密码界面请见如图3-3老师学生账号密码界面。这个界面的设计同样是专门为教务办用户设计,能通过点击全部查询,查询到系统录入的所有同学和教务办老师的账号密码,这个界面信息显示也采用了多表查询,将学生账号密码登录表、老师账号密码登录表两个表格联合查询;然后也可以通过下拉框选择相应想要选择查询的内容比如老师账号,然后点击查询获取相对应的老师账号密码信息。如果修改了账号和密码点击更新按钮,又确认实施该操作,那么会退出系统返回到原始登录界面,其它按钮的功能同上。
    实现老师学生账号密码界面的全部代码:

    package xr06;
    import java.util.Vector;
    import java.awt.*;
    import javax.swing.*;
    import javax.swing.table.DefaultTableModel;
    import org.omg.CORBA.PUBLIC_MEMBER;
    import java.awt.color.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.ItemEvent;
    import java.awt.event.ItemListener;
    import java.awt.event.MouseAdapter;
    import java.awt.event.MouseEvent;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    public class Studentzh extends JFrame implements ActionListener {
    	// 定义基本信息组件
    		JLabel jLStudentxjTable = null;// 学生学籍表
    		JLabel jLSelectQueryField = null;// 选择
    		JLabel mh = null;// :
    		JLabel teacherzh = null;// 老师账号
    		JLabel teachermm = null;// 老师密码
    		JLabel studentzh = null;// 学生账号
    		JLabel studentmm = null;// 学生密码
    		JLabel ms = null;// 描述
    		JLabel dm = null;// 代码
    		JLabel sm = null;// 说明
    		/// 定义文本框
    		JTextField jTFQueryField = null;// 查询字段
    		JTextField jTFSTz = null;// 老师账号
    		JTextField jTFSTP = null;// 老师密码
    		JTextField jTFSSZ = null;// 学生账号
    		JTextField jTFSSP = null;// 学生密码
    		JTextField jTFSDES = null;// 描述
    		JTextField jTFSCode = null;// 代码
    		JTextField jTFSsm = null;// 说明
    		// 定义按钮
    		JButton jb5 = null;// 顶部选择的四个表+1个菜单
    		JButton jBQuery = null;// 查询
    		JButton jBQueryAll = null;// 查询所有记录
    		JButton jBInsert = null;// 插入
    		JButton jBUpdate = null;// 更新
    		JButton jBDeleteCurrentRecord = null;// 删除当前记录
    		JButton jBDeleteAllRecords = null;// 删除所有记录
    		JButton EXIT = null;// 退出
    		// 定义其他
    		JComboBox<String> jCBSelectQueryField = null;// 查询字段
    		JComboBox<String> jCBsexQueryField = null;// 
    		JPanel jP1, jP2, jP3, jP4, jP5, jP6, jP8 = null;
    		JPanel jPTop, jPBottom = null;
    		DefaultTableModel studentTableModel = null;
    		JTable studentJTable = null;
    		JScrollPane studentJScrollPane = null;
    		Vector studentVector = null;
    		Vector titleVector = null;
    		private static DbProcess dbProcess;
    		String SelectQueryFieldStr = "老师账号";
    		public static void main(String[] args) {
    			Studentzh ss = new Studentzh();
    		}
    
    		// ****************************事件判断**********************
    		public Studentzh() {
    			setIconImage(Toolkit.getDefaultToolkit().getImage("G:\\timg-1.jpg"));
    			this.setResizable(false);
    			jLSelectQueryField = new JLabel("选择");
    			jLSelectQueryField.setBounds(5, 9, 30, 18);
    			mh = new JLabel(" : ");
    			mh.setBounds(192, 9, 24, 18);
    			teacherzh = new JLabel("老师账号:");
    			teacherzh.setBounds(5, 25, 68, 18);
    			teachermm = new JLabel("老师密码:");
    			teachermm.setBounds(323, 25, 68, 18);
    			// 文本框创建
    			jTFQueryField = new JTextField(10);// 查询字段
    			jTFQueryField.setBounds(214, 6, 106, 24);
    			jTFSTz = new JTextField(15);// 老师账号
    			jTFSTz.setBounds(79, 18, 215, 24);
    			jTFSTP = new JTextField(15);// 老师密码
    			jTFSTP.setBounds(395, 18, 215, 24);
    			jBQuery = new JButton("查询选择内容");
    			jBQuery.setBounds(334, 5, 155, 27);
    			jBQuery.setFont(new Font("宋体", Font.BOLD, 15));
    			jBQueryAll = new JButton("查询所有记录");
    			jBQueryAll.setBounds(503, 5, 155, 27);
    			jBQueryAll.setFont(new Font("宋体", Font.BOLD, 15));
    			jBQuery.addActionListener(this);
    			jBQueryAll.addActionListener(this);
    			// 建立下拉框
    			jCBSelectQueryField = new JComboBox<String>();// 查询字段
    			jCBSelectQueryField.setBounds(37, 6, 155, 24);
    			jCBSelectQueryField.addItem("老师账号");
    			jCBSelectQueryField.addItem("老师密码");
    			jCBSelectQueryField.addItem("学生账号");
    			jCBSelectQueryField.addItem("学生密码");
    			jCBSelectQueryField.addItemListener(new ItemListener() {// 下拉框事件监听
    				public void itemStateChanged(ItemEvent event) {
    					switch (event.getStateChange()) {
    					case ItemEvent.SELECTED:
    						SelectQueryFieldStr = (String) event.getItem();
    						System.out.println("选中:" + SelectQueryFieldStr);
    						break;
    					case ItemEvent.DESELECTED:
    						System.out.println("取消选中:" + event.getItem());
    						break;
    					}
    				}
    			});
    
    			studentVector = new Vector();
    			titleVector = new Vector();
    			// 定义表头
    			titleVector.add("老师账号");
    			titleVector.add("老师密码");
    			titleVector.add("学生账号");
    			titleVector.add("学生密码");
    			studentJTable = new JTable(studentVector, titleVector);
    			studentJTable.setPreferredScrollableViewportSize(new Dimension(400, 160));
    			studentJScrollPane = new JScrollPane(studentJTable);
    			studentJScrollPane.setBounds(0, 0, 480, 172);
    			// 分别设置水平和垂直滚动条自动出现
    			studentJScrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
    			studentJScrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
    
    			// 为表格添加监听器
    			studentJTable.addMouseListener(new MouseAdapter() {
    				public void mouseClicked(MouseEvent e) {
    					int row = ((JTable) e.getSource()).rowAtPoint(e.getPoint()); // 获得行位置
    					System.out.println("mouseClicked(). row = " + row);
    					Vector v = new Vector();
    					v = (Vector) studentVector.get(row);
    
    					jTFSTz.setText((String) v.get(0));// 老师账号
    					jTFSTP.setText((String) v.get(1));// 老师密码
    					jTFSSZ.setText((String) v.get(2));// 学生账号
    					jTFSSP.setText((String) v.get(3));// 学生密码
    				}
    			});
    
    			jP1 = new JPanel();
    			jP1.setBounds(356, 17, 8, 2);
    			jP3 = new JPanel();
    			jP3.setBounds(98, 55, 480, 172);
    			jP3.setBackground(new Color(204, 51, 0));
    			jP4 = new JPanel();
    			jP4.setBackground(new Color(255, 255, 102));
    			jP4.setBounds(0, 13, 682, 45);
    			jP5 = new JPanel();
    			jP5.setBackground(new Color(255, 255, 153));
    			jP5.setBounds(0, 69, 682, 45);
    			jP6 = new JPanel();
    			jP6.setBackground(new Color(255, 255, 153));
    			jP6.setBounds(0, 113, 682, 79);
    			jPTop = new JPanel();
    			jPTop.setBackground(new Color(255, 255, 102));
    			jPBottom = new JPanel();
    			jPBottom.setBackground(new Color(255, 255, 51));
    			jP3.setLayout(null);
    			jP3.add(studentJScrollPane);
    			jP1.setLayout(new FlowLayout(FlowLayout.CENTER, 4, 1));
    			jP4.setLayout(null);
    	//底部的五部分
    			// 第四行
    			jP4.add(jLSelectQueryField);// 文字“选择”
    			jP4.add(jCBSelectQueryField);// 下拉框
    			jP4.add(mh);
    			jP4.add(jTFQueryField);
    			jP4.add(jBQuery);
    			jP4.add(jBQueryAll);
    			jP4.setPreferredSize(new Dimension(20, 20));
    			jP5.setLayout(null);
    			// 第五行
    			jP5.add(teacherzh);
    			jP5.add(jTFSTz);
    			jP5.add(teachermm);
    			jP5.add(jTFSTP);
    			jP5.setPreferredSize(new Dimension(20, 20));
    			jP6.setLayout(null);
    			studentzh = new JLabel("学生账号:");
    			studentzh.setBounds(5, 32, 68, 18);
    			jP6.add(studentzh);
    			jTFSSZ = new JTextField(15);// 学生账号
    			jTFSSZ.setBounds(79, 29, 215, 24);
    			jP6.add(jTFSSZ);
    			studentmm = new JLabel("学生密码:");
    			studentmm.setBounds(323, 32, 68, 18);
    			jP6.add(studentmm);
    			jP6.setPreferredSize(new Dimension(20, 20));
    			jPTop.setLayout(null);
    			// 命名组件
    			jLStudentxjTable = new JLabel("账户密码表");
    			jLStudentxjTable.setBounds(14, 13, 130, 26);
    			jLStudentxjTable.setFont(new Font("华文新魏", Font.BOLD, 25));
    			jP2 = new JPanel();
    			jP2.setBackground(new Color(255, 255, 102));
    			jP2.setBounds(258, 0, 165, 50);
    			jP2.setLayout(null);
    			jP2.add(jLStudentxjTable);
    			jPTop.add(jP2);
    			// 设置顶部
    			jPTop.add(jP1);
    			jPTop.add(jP3);
    			jPBottom.setLayout(null);
    			jPBottom.add(jP4);
    			jPBottom.add(jP5);
    			jPBottom.add(jP6);
    			jTFSSP = new JTextField(15);
    			jTFSSP.setBounds(395, 29, 215, 24);
    			jP6.add(jTFSSP);
    			// 设置大局面
    			getContentPane().add("North", jPTop);
    			
    			JLabel lblNewLabel = new JLabel("   \u6CE8\u610F\u4E8B\u9879\uFF1A\u8D26\u53F7\u5BC6\u7801\u6D89\u53CA\u4F7F\u7528\u8005\u548C\u7BA1\u7406\u8005\u9690\u79C1\uFF0C\u8BF7\u52FF\u6CC4\u9732\u5916\u4F20\uFF01");
    			lblNewLabel.setBounds(79, 224, 523, 36);
    			jPTop.add(lblNewLabel);
    			lblNewLabel.setForeground(new Color(255, 0, 0));
    			lblNewLabel.setFont(new Font("华文宋体", Font.BOLD, 17));
    			getContentPane().add("South", jPBottom);
    			jBInsert = new JButton("插入");
    			jBInsert.setBounds(10, 205, 80, 27);
    			jPBottom.add(jBInsert);
    			jBInsert.setFont(new Font("宋体", Font.BOLD, 15));
    			jBUpdate = new JButton("更新");
    			jBUpdate.setBounds(95, 205, 80, 27);
    			jPBottom.add(jBUpdate);
    			jBUpdate.setFont(new Font("宋体", Font.BOLD, 15));
    			jBDeleteCurrentRecord = new JButton("删除当前记录");
    			jBDeleteCurrentRecord.setBounds(189, 205, 155, 27);
    			jPBottom.add(jBDeleteCurrentRecord);
    			jBDeleteCurrentRecord.setFont(new Font("宋体", Font.ITALIC, 15));
    			jBDeleteCurrentRecord.setForeground(Color.RED);
    			jBDeleteAllRecords = new JButton("删除所有记录");
    			jBDeleteAllRecords.setBounds(358, 205, 155, 27);
    			jPBottom.add(jBDeleteAllRecords);
    			jBDeleteAllRecords.setFont(new Font("宋体", Font.ITALIC, 15));
    			jBDeleteAllRecords.setForeground(Color.RED);
    			EXIT = new JButton("返回主页面");
    			EXIT.setBounds(527, 205, 155, 27);
    			jPBottom.add(EXIT);
    			EXIT.addMouseListener(new MouseAdapter() {
    				@Override
    				public void mouseClicked(MouseEvent e) {
    					dispose();                    
    					Teacher ui=new Teacher();
    				}
    			});
    			
    			EXIT.setFont(new Font("宋体", Font.BOLD, 15));
    			EXIT.setForeground(Color.RED);
    			EXIT.addActionListener(this);
    			jBDeleteAllRecords.addActionListener(this);
    			jBDeleteCurrentRecord.addActionListener(this);
    			jBUpdate.addActionListener(this);
    			jBInsert.addActionListener(this);
    
    			getContentPane().setLayout(new GridLayout(2, 1));
    			this.setTitle("账号密码查改");
    			this.setSize(700, 568);// 改表的大小
    			this.setLocation(630, 180);// 改表的位置
    			this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    			this.setVisible(true);// 使页面显示
    			// this.setVisible(false);使页面消失
    
    			dbProcess = new DbProcess();
    
    		}
    
    		// 监听器事件
    		public void actionPerformed(ActionEvent e) { // 事件判断
    
    			if (e.getActionCommand().equals("查询选择内容") && !jTFQueryField.getText().isEmpty()) {
    				System.out.println("actionPerformed(). 查询选择内容");
    				String sQueryField = jTFQueryField.getText().trim();
    				int n=JOptionPane.showConfirmDialog(null,"确定查询该选项?", "账号密码记录",JOptionPane.YES_NO_OPTION);
    				if(n==0) {
    					queryProcess(sQueryField);
    					jTFQueryField.setText("");
    				}
    			} if (e.getActionCommand().equals("查询所有记录")) {
    				System.out.println("actionPerformed(). 查询所有记录");
    				int n=JOptionPane.showConfirmDialog(null,"确定查询所有记录?", "账号密码记录",JOptionPane.YES_NO_OPTION);
    				if(n==0) {
    					queryAllProcess();
    				}
    			} if (e.getActionCommand().equals("插入") && !jTFSTz.getText().isEmpty() && !jTFSTP.getText().isEmpty()
    					&& !jTFSSZ.getText().isEmpty() && !jTFSSP.getText().isEmpty() ) {
    				System.out.println("actionPerformed(). 插入");
    				int n=JOptionPane.showConfirmDialog(null,"确定插入该条记录?", "账号密码记录",JOptionPane.YES_NO_OPTION);
    				if(n==0) {
    					insertProcess();
    					JOptionPane.showMessageDialog(null, "                                插入成功", "插入成功", JOptionPane.PLAIN_MESSAGE);
    				} 
    			} if (e.getActionCommand().equals("更新") && !jTFSTz.getText().isEmpty() && !jTFSTP.getText().isEmpty()
    					&& !jTFSSZ.getText().isEmpty() && !jTFSSP.getText().isEmpty() ) {
    				System.out.println("actionPerformed(). 更新");
    				int n=JOptionPane.showConfirmDialog(null,"确定更新该条记录?", "账号密码记录",JOptionPane.YES_NO_OPTION);
    				if(n==0) {
    					JOptionPane.showMessageDialog(null, "                                更新成功", "更新成功", JOptionPane.PLAIN_MESSAGE);
    					updateProcess();
    					dispose();
    					Student_management_login_system sm=new Student_management_login_system();
    				} 
    			}  if (e.getActionCommand().equals("删除当前记录")) {
    				System.out.println("actionPerformed(). 删除当前记录");
    				int n=JOptionPane.showConfirmDialog(null,"注意:确定删除该条记录?", "账号密码记录",JOptionPane.YES_NO_OPTION);
    				if(n==0) {
    					JOptionPane.showMessageDialog(null, "                                删除成功", "删除成功", JOptionPane.PLAIN_MESSAGE);
    					deleteCurrentRecordProcess();
    				} 
    			} if (e.getActionCommand().equals("删除所有记录"))   {
    				System.out.println("actionPerformed(). 删除所有记录");
    				int n=JOptionPane.showConfirmDialog(null,"注意:确定删除所有记录?", "账号密码记录",JOptionPane.YES_NO_OPTION);
    				if(n==0) {
    					JOptionPane.showMessageDialog(null, "                                全部删除成功", "全部删除成功", JOptionPane.PLAIN_MESSAGE);
    					deleteAllRecordsProcess();
    				}
    			}
    
    		}
    
    		// “查询”程序
    		public void queryProcess(String sQueryField) {
    			try {
    				// 建立查询条件
    				if(SelectQueryFieldStr=="老师账号"||SelectQueryFieldStr=="老师密码") {
    				String sql = "SELECT `teacherdlb`.tuserNo,`teacherdlb`.tpswd FROM `teacherdlb`  WHERE teacherdlb.tpswd IS NOT NULL  AND ";
    				String queryFieldStr = jCBSelectQueryFieldTransfer(SelectQueryFieldStr);
    				System.out.println(queryFieldStr);
    
    				
    					sql = sql + queryFieldStr;
    					sql = sql + " = ";
    					sql = sql + "'" + sQueryField + "';";
    			
    				String sql1 = "SELECT `studentdlb`.suserNo,`studentdlb`.spswd FROM `studentdlb`  WHERE studentdlb.spswd IS NOT NULL ; ";
    				System.out.println("queryProcess(). sql = " + sql);
    
    				dbProcess.connect();
    				ResultSet rs = dbProcess.executeQuery(sql);
    				ResultSet rs1 = dbProcess.executeQuery(sql1);
    
    				// 将查询获得的记录数据,转换成适合生成JTable的数据形式
    				studentVector.clear();
    				while (rs.next()&&rs1.next()) {
    					Vector v = new Vector();
    					v.add(rs.getString("tuserNo"));
    					v.add(rs.getString("tpswd"));
    					v.add(rs1.getString("suserNo"));
    					v.add(rs1.getString("spswd"));
    					
    					studentVector.add(v);//显示表
    				}
    
    				studentJTable.updateUI();
    
    				dbProcess.disconnect();}
    				
    				if(SelectQueryFieldStr=="学生账号"||SelectQueryFieldStr=="学生密码") {
    					String sql = "SELECT `studentdlb`.suserNo,`studentdlb`.spswd FROM `studentdlb`  WHERE studentdlb.spswd IS NOT NULL  AND ";
    					String queryFieldStr = jCBSelectQueryFieldTransfer(SelectQueryFieldStr);
    					System.out.println(queryFieldStr);
    
    					
    						sql = sql + queryFieldStr;
    						sql = sql + " = ";
    						sql = sql + "'" + sQueryField + "';";
    				
    					String sql1 = "SELECT `teacherdlb`.tuserNo,`teacherdlb`.tpswd FROM `teacherdlb`  WHERE teacherdlb.tpswd IS NOT NULL ; ";
    					System.out.println("queryProcess(). sql = " + sql);
    
    					dbProcess.connect();
    					ResultSet rs = dbProcess.executeQuery(sql);
    					ResultSet rs1 = dbProcess.executeQuery(sql1);
    
    					// 将查询获得的记录数据,转换成适合生成JTable的数据形式
    					studentVector.clear();
    					while (rs.next()&&rs1.next()) {
    						Vector v = new Vector();
    						v.add(rs1.getString("tuserNo"));
    						v.add(rs1.getString("tpswd"));
    						v.add(rs.getString("suserNo"));
    						v.add(rs.getString("spswd"));
    						
    						studentVector.add(v);//显示表
    					}
    
    					studentJTable.updateUI();
    
    					dbProcess.disconnect();}
    				
    			} catch (SQLException sqle) {
    				System.out.println("sqle = " + sqle);
    				JOptionPane.showMessageDialog(null, "数据操作错误", "错误", JOptionPane.ERROR_MESSAGE);
    			} catch (Exception e) {
    				System.out.println("e = " + e);
    				JOptionPane.showMessageDialog(null, "数据操作错误", "错误", JOptionPane.ERROR_MESSAGE);
    			}
    		}
    
    		// “查询全部”程序
    		public void queryAllProcess() {
    			try {
    				// 建立查询条件
    				String sql = "SELECT `studentdlb`.suserNo,`studentdlb`.spswd FROM `studentdlb`  WHERE studentdlb.spswd IS NOT NULL  ;";
    				String sql1 = "SELECT `teacherdlb`.tuserNo,`teacherdlb`.tpswd FROM `teacherdlb`  WHERE teacherdlb.tpswd IS NOT NULL ; ";
    				System.out.println("queryProcess(). sql = " + sql);
    
    				dbProcess.connect();
    				ResultSet rs = dbProcess.executeQuery(sql);
    				ResultSet rs1 = dbProcess.executeQuery(sql1);
    
    				// 将查询获得的记录数据,转换成适合生成JTable的数据形式
    				studentVector.clear();
    				while (rs.next()&&rs1.next()) {
    					Vector v = new Vector();
    					v.add(rs1.getString("tuserNo"));
    					v.add(rs1.getString("tpswd"));
    					v.add(rs.getString("suserNo"));
    					v.add(rs.getString("spswd"));
    					studentVector.add(v);//显示表
    				}
    
    				studentJTable.updateUI();
    
    				dbProcess.disconnect();
    			} catch (SQLException sqle) {
    				System.out.println("sqle = " + sqle);
    				JOptionPane.showMessageDialog(null, "数据操作错误", "错误", JOptionPane.ERROR_MESSAGE);
    			}
    		}
    
    		// “插入”程序
    		public void insertProcess() {
    			String tuserNo = jTFSTz.getText().trim();
    			String tpswd = jTFSTP.getText().trim();
    			String suserNo = jTFSSZ.getText().trim();
    			String spswd = jTFSSP.getText().trim();
    
    			// 建立插入条件
    			String sql = "insert into `teacherdlb` values('";
    			sql = sql + tuserNo + "','";
    			sql = sql + tpswd + "');";
    			
    			String sql1 = "insert into `studentdlb` values('";
    			sql1 = sql1 + suserNo + "','";
    			sql1 = sql1 + spswd + "');";
    			System.out.println("insertProcess(). sql = " + sql+"insertProcess(). sql1 = " + sql1);
    			try {
    				if (dbProcess.executeUpdate(sql) < 1||dbProcess.executeUpdate(sql1) < 1) {
    					System.out.println("insertProcess(). insert database failed.");
    				}
    			} catch (Exception e) {
    				System.out.println("e = " + e);
    				JOptionPane.showMessageDialog(null, "数据操作错误", "错误", JOptionPane.ERROR_MESSAGE);
    			}
    			queryAllProcess();
    		}
    
    		// “更新”程序
    		public void updateProcess() {
    			String tuserNo = jTFSTz.getText().trim();
    			String tpswd = jTFSTP.getText().trim();
    			String suserNo = jTFSSZ.getText().trim();
    			String spswd = jTFSSP.getText().trim();
    
    			// 建立更新条件
    			String sql = "update teacherdlb set tpswd = '";
    			sql = sql + tpswd + "'";
    			sql = sql + " WHERE tuserNo = '" + tuserNo + "';";
    			
    			String sql1 = "update studentdlb set spswd = '";
    			sql1 = sql1 + spswd + "'";
    			sql1 = sql1 + " WHERE suserNo = '" + suserNo + "';";
    			
    			System.out.println("updateProcess(). sql = " + sql+"updateProcess(). sql1 = " + sql1);
    			try {
    				if (dbProcess.executeUpdate(sql) < 1||dbProcess.executeUpdate(sql1) < 1) {
    					System.out.println("updateProcess(). update database failed.");
    				}
    			} catch (Exception e) {
    				System.out.println("e = " + e);
    				JOptionPane.showMessageDialog(null, "数据操作错误", "错误", JOptionPane.ERROR_MESSAGE);
    			}
    			queryAllProcess();
    		}
    
    		// “删除”程序
    		public void deleteCurrentRecordProcess() {
    			String tuserNo = jTFSTz.getText().trim();
    			String suserNo = jTFSSZ.getText().trim();
    
    			// 建立删除条件
    			String sql = "delete from teacherdlb where tuserNo = '" + tuserNo + "';";
    			String sql1 = "delete from studentdlb where suserNo = '" + suserNo + "';";
    			System.out.println("deleteCurrentRecordProcess(). sql = " + sql+"deleteCurrentRecordProcess(). sql1 = " + sql1);
    			try {
    				if (dbProcess.executeUpdate(sql) < 1||dbProcess.executeUpdate(sql1) < 1) {
    					System.out.println("deleteCurrentRecordProcess(). delete database failed.");
    				}
    			} catch (Exception e) {
    				System.out.println("e = " + e);
    				JOptionPane.showMessageDialog(null, "数据操作错误", "错误", JOptionPane.ERROR_MESSAGE);
    			}
    			queryAllProcess();
    		}
    
    		// “删除全部”程序
    		public void deleteAllRecordsProcess() {
    			// 建立删除条件
    			String sql = "delete from teacherdlb;";
    			String sql1 = "delete from studentdlb;";
    			System.out.println("deleteAllRecordsProcess(). sql = " + sql+"deleteAllRecordsProcess(). sql1 = " + sql1);
    			try {
    				if (dbProcess.executeUpdate(sql) < 1||dbProcess.executeUpdate(sql1) < 1) {
    					System.out.println("deleteAllRecordsProcess(). delete database failed.");
    				}
    			} catch (Exception e) {
    				System.out.println("e = " + e);
    				JOptionPane.showMessageDialog(null, "数据操作错误", "错误", JOptionPane.ERROR_MESSAGE);
    			}
    			queryAllProcess();
    		}
    
    		public String jCBSelectQueryFieldTransfer(String InputStr) {
    			String outputStr = "";
    			System.out.println("jCBSelectQueryFieldTransfer(). InputStr = " + InputStr);
    
    			if (InputStr.equals("老师账号")) {
    				outputStr = "tuserNo";
    			} else if (InputStr.equals("老师密码")) {
    				outputStr = "tpswd";
    			} else if (InputStr.equals("学生账号")) {
    				outputStr = "suserNo";
    			} else if (InputStr.equals("学生密码")) {
    				outputStr = "spswd";
    			} 
    			System.out.println("jCBSelectQueryFieldTransfer(). outputStr = " + outputStr);
    			return outputStr;
    		}
    
    		// 退出程序
    		public void close() {
    			System.exit(0);
    		}
    }
    
    
    

    图3-3老师学生账号密码界面
    在这里插入图片描述
    3.4、新生信息输入界面
    新生信息输入界面请见如图3-4新生信息输入界面。这个界面的设计同样是专门为教务办用户设计,首先这个界面是一个录入新生信息的界面,在每一个文本框都有相应输入的数据格式的提示比如生日的文本框所提示的内容是“2013-05-20”这种格式,因为在数据库中的学生信息表格中设计的时间的数据类型是date类型,所以必须用这种数据格式的填写才能成功插入到数据库相应的表格里面去。只有当所有的文本框中都输有正确数据,然后点击确认键,然后会弹出一个窗口让用户再确认一次是否允许该操作的执行,减少用户操作失误的几率。插入数据成功之后界面的所有文本框会清空,用户可以再继续将其他学生信息插入到学生信息表中;也可以点击返回,然后返回主界面。
    实现新生信息输入界面的全部代码:

    package xr06;
    
    import java.awt.BorderLayout;
    import java.awt.EventQueue;
    
    import javax.swing.JFrame;
    import javax.swing.JPanel;
    import javax.swing.border.EmptyBorder;
    import javax.swing.JLabel;
    import javax.swing.JOptionPane;
    
    import java.awt.Font;
    import java.awt.Color;
    import java.awt.SystemColor;
    import javax.swing.JTextField;
    import javax.swing.ButtonGroup;
    import javax.swing.JButton;
    import java.awt.event.MouseAdapter;
    import java.awt.event.MouseEvent;
    import javax.swing.JRadioButton;
    import javax.swing.ImageIcon;
    import java.awt.Toolkit;
    
    public class Newstudent extends JFrame {
    	static String select="男";
    	ButtonGroup bg=null;
    	private static DbProcess dbProcess;
    	private JPanel contentPane;
    	private JTextField textField;
    	private JTextField textField_1;
    	private JTextField textField_3;
    	private JTextField textField_4;
    	private JTextField textField_5;
    	private JTextField textField_6;
    
    	/**
    	 * Launch the application.
    	 */
    	public static void main(String[] args) {
    		
    					Newstudent f = new Newstudent();
    					
    	}
    
    	/**
    	 * Create the frame.
    	 */
    	public Newstudent() {
    		setIconImage(Toolkit.getDefaultToolkit().getImage("G:\\timg-1.jpg"));
    		
    		
    		this.setResizable(false);
    		setFont(new Font("Dialog", Font.BOLD, 25));
    		setTitle("新生信息输入");
    		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		setBounds(700, 200, 570, 533);
    		contentPane = new JPanel();
    		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
    		setContentPane(contentPane);
    		contentPane.setLayout(null);
    		
    		JPanel panel = new JPanel();
    		panel.setBackground(new Color(255, 255, 153));
    		panel.setBounds(0, 0, 566, 498);
    		contentPane.add(panel);
    		panel.setLayout(null);
    		
    		JLabel lblNewLabel = new JLabel("新生信息输入");
    		lblNewLabel.setBounds(182, 13, 197, 36);
    		lblNewLabel.setBackground(Color.LIGHT_GRAY);
    		lblNewLabel.setFont(new Font("华文新魏", Font.BOLD, 30));
    		panel.add(lblNewLabel);
    		
    		JLabel lblNewLabel_1 = new JLabel("学号:");
    		lblNewLabel_1.setFont(new Font("宋体", Font.BOLD, 20));
    		lblNewLabel_1.setBounds(92, 76, 71, 18);
    		panel.add(lblNewLabel_1);
    		
    		JLabel label = new JLabel("姓名:");
    		label.setFont(new Font("宋体", Font.BOLD, 20));
    		label.setBounds(92, 126, 74, 18);
    		panel.add(label);
    		
    		JLabel label_1 = new JLabel("性别:");
    		label_1.setFont(new Font("宋体", Font.BOLD, 20));
    		label_1.setBounds(92, 176, 70, 18);
    		panel.add(label_1);
    		
    		JLabel label_2 = new JLabel("生日:");
    		label_2.setFont(new Font("宋体", Font.BOLD, 20));
    		label_2.setBounds(92, 226, 77, 18);
    		panel.add(label_2);
    		
    		JLabel label_3 = new JLabel("地址:");
    		label_3.setFont(new Font("宋体", Font.BOLD, 20));
    		label_3.setBounds(92, 276, 66, 18);
    		panel.add(label_3);
    		
    		textField = new JTextField();
    		textField.setBounds(162, 74, 255, 24);
    		panel.add(textField);
    		textField.setColumns(10);
    		textField.addFocusListener(new JTextFieldHintListener("新生学号 如 1705", textField));
    		
    		textField_1 = new JTextField();
    		textField_1.addFocusListener(new JTextFieldHintListener("新生姓名 如 XR", textField_1));
    		textField_1.setColumns(10);
    		textField_1.setBounds(162, 124, 255, 24);
    		
    		panel.add(textField_1);
    		
    		
    		textField_3 = new JTextField();
    		textField_3.addFocusListener(new JTextFieldHintListener("新生生日 如 2013-05-20", textField_3));
    		textField_3.setColumns(10);
    		textField_3.setBounds(162, 224, 255, 24);
    		panel.add(textField_3);
    		
    		textField_4 = new JTextField();
    		textField_4.addFocusListener(new JTextFieldHintListener("新生地址籍贯 如 湖南长沙", textField_4));
    		textField_4.setColumns(10);
    		textField_4.setBounds(162, 274, 255, 24);
    		panel.add(textField_4);
    		
    		JLabel label_4 = new JLabel("院系:");
    		label_4.setFont(new Font("宋体", Font.BOLD, 20));
    		label_4.setBounds(92, 326, 66, 18);
    		panel.add(label_4);
    		
    		textField_5 = new JTextField();
    		textField_5.addFocusListener(new JTextFieldHintListener("新生院系 如 0101", textField_5));
    		textField_5.setColumns(10);
    		textField_5.setBounds(162, 324, 255, 24);
    		panel.add(textField_5);
    		
    		JLabel label_5 = new JLabel("班名:");
    		label_5.setFont(new Font("宋体", Font.BOLD, 20));
    		label_5.setBounds(92, 376, 66, 18);
    		panel.add(label_5);
    		
    		textField_6 = new JTextField();
    		textField_6.addFocusListener(new JTextFieldHintListener("新生班名 如 01", textField_6));
    		textField_6.setColumns(10);
    		textField_6.setBounds(162, 374, 255, 24);
    		panel.add(textField_6);
    		
    		JButton btnNewButton = new JButton("确认");
    		btnNewButton.addMouseListener(new MouseAdapter() {
    			@Override
    			public void mouseClicked(MouseEvent e) {
    				if ( !textField.getText().isEmpty() && !textField_1.getText().isEmpty()
    						 && !textField_3.getText().isEmpty() && !textField_4.getText().isEmpty()
    						&& !textField_5.getText().isEmpty() && !textField_6.getText().isEmpty()) {
    					System.out.println("mouseClicked(). 确认");
    					int n=JOptionPane.showConfirmDialog(null,"确定录入该生信息?", "新生信息录入",JOptionPane.YES_NO_OPTION);
    					if(n==0) {
    						insertProcess();
    						JOptionPane.showMessageDialog(null, "                   录入信息成功", "输入信息成功", JOptionPane.PLAIN_MESSAGE); 
    						textField.setText("");
    						textField_1.setText("");
    						textField_3.setText("");
    						textField_4.setText("");
    						textField_5.setText("");
    						textField_6.setText("");
    					}
    				}
    				else {JOptionPane.showMessageDialog(null, "                   请输入完整数据,谢谢", "请输入完整数据", JOptionPane.PLAIN_MESSAGE); }
    		}
    			});
    		btnNewButton.setForeground(Color.BLACK);
    		btnNewButton.setBackground(Color.ORANGE);
    		btnNewButton.setFont(new Font("宋体", Font.BOLD, 20));
    		btnNewButton.setBounds(322, 433, 95, 35);
    		panel.add(btnNewButton);
    		
    		JButton button = new JButton("返回");
    		button.addMouseListener(new MouseAdapter() {
    			@Override
    			public void mouseClicked(MouseEvent e) {
    				dispose();
    				Teacher t = new Teacher();
    			}
    		});
    		button.setForeground(Color.RED);
    		button.setFont(new Font("宋体", Font.BOLD, 20));
    		button.setBackground(Color.ORANGE);
    		button.setBounds(438, 433, 95, 35);
    		panel.add(button);
    		
    		
    		JRadioButton rdbtnNewRadioButton = new JRadioButton("男");
    		rdbtnNewRadioButton.addMouseListener(new MouseAdapter() {
    			@Override
    			public void mouseClicked(MouseEvent e) {
    				System.out.println("选择“男”");
    				select="男";
    			}
    		});
    		rdbtnNewRadioButton.setFont(new Font("宋体", Font.BOLD, 17));
    		rdbtnNewRadioButton.setBackground(new Color(255, 255, 153));
    		rdbtnNewRadioButton.setBounds(162, 174, 77, 27);
    		panel.add(rdbtnNewRadioButton);
    		
    		JRadioButton rdbtnNewRadioButton_1 = new JRadioButton("女");
    		rdbtnNewRadioButton_1.addMouseListener(new MouseAdapter() {
    			@Override
    			public void mouseClicked(MouseEvent e) {
    				System.out.println("选择“女”");
    				select="女";
    			}
    		});
    		
    		rdbtnNewRadioButton_1.setFont(new Font("宋体", Font.BOLD, 17));
    		rdbtnNewRadioButton_1.setBackground(new Color(255, 255, 153));
    		rdbtnNewRadioButton_1.setBounds(238, 174, 157, 27);
    		panel.add(rdbtnNewRadioButton_1);
    		this.setVisible(true);
    		bg=new ButtonGroup();  
            bg.add(rdbtnNewRadioButton);  
            bg.add(rdbtnNewRadioButton_1);  
            rdbtnNewRadioButton.setSelected(true);
    		dbProcess = new DbProcess();
    		
    	}
    	public void insertProcess() {
    		
    		String Sno = textField.getText().trim();
    		String Sname = textField_1.getText().trim();
    		String Ssex = select;
    		String Sbirth = textField_3.getText().trim();
    		String Sadd = textField_4.getText().trim();
    		String Sacademy = textField_5.getText().trim();
    		String Scla = textField_6.getText().trim();
    
    		// 建立插入条件
    		String sql = "insert into student values('";
    		sql = sql + Sno + "','";
    		sql = sql + Sname + "','";
    		sql = sql + Ssex + "','";
    		sql = sql + Sbirth + "','";
    		sql = sql + Sadd + "','";
    		sql = sql + Sacademy + "','";
    		sql = sql + Scla + "');";
    
    		System.out.println("insertProcess(). sql = " + sql);
    		try {
    			if (dbProcess.executeUpdate(sql) < 1) {
    				System.out.println("insertProcess(). insert database failed.");
    			}
    		} catch (Exception e) {
    			System.out.println("e = " + e);
    			JOptionPane.showMessageDialog(null, "数据操作错误", "错误", JOptionPane.ERROR_MESSAGE);
    		}
    	}
    }
    
    

    图3-4新生信息输入界面
    在这里插入图片描述

    以上只是数据库课设之学生信息管理系统部分设计内容和源代码资源,如果想要学生信息管理系统全部资源请点击下面资源链接进行下载,希望能帮助到你!

    独家资源:点击资源下载链接

    同时在完成相关设计可能会用到的博主博客中的文章内容:

    1、Navicat for MySQL资源分享和下载以及SQL文件的导入导出

    2、Eclipse最新最简最详细安装教程

    各位大佬如有更好的建议或者不清楚的地方让各位产生了疑问,各位可以在评论中提出!

    展开全文
  • 学生成绩管理系统数据库设计--MySQL

    万次阅读 多人点赞 2020-06-18 13:02:04
    MySQL/SQL Server 数据库设计(学生成绩管理系统) 设计大纲 1. 项目背景及需求分析 1.1 项目背景 1.2 需求分析 1.2.1 信息需求 1.2.2 功能需求 1.2.3 安全性与完整性需求 2. 概念结构设计 2.1 抽象出系统实体 2.2 ...
  • 四大基本概念(1)数据--Data① 数据的定义② 数据的种类③ 数据的特点④ 数据举例(2)数据库--Database① 数据库的定义② 数据库的基本特征(3)数据库管理系统--DataBase Management System① 什么是DBMS?...
  • 系统在Windows10开发环境下,利用Visual Studio 2015 开发工具,并使用SQL Server2012作为数据库管理系统,来现班级管理系统的各个功能。
  • 学生管理系统设计(数据库连接C#版)

    万次阅读 多人点赞 2017-12-02 21:02:52
    目录 一.课程设计说明 1 1.1项目概述 1 1.2设计任务和要求 1 1.3开发环境说明 1 二....2.1项目介绍 2 2.2数据需求分析 2 三....3.2数据库设计 5 ...四....4.1学生信息管理系统 12 4.2学生信息查询 12
  • 链接MYSql数据库学生选课管理系统

    千次阅读 2013-10-26 17:37:37
    学生管理系统 Java老师给我们小组安排了课程最后的一个实验课,做一个链接数据库(mysql或者sql server)的学生选课管理系统个人从周三开始用零碎的时间,慢慢动手今天终于大致全部功能都完成了,有点小bug在选择的时候,...
  • 数据库学生档案管理系统(续)

    万次阅读 多人点赞 2013-03-23 00:39:39
    参见前一篇:【数据库学生档案管理系统 数据库表的设计及分析 在此我们仅对关键表进行分析 学生关系拥有14个属性,其中学号为主键,是学生唯一的标识。外键班级号引用了班级表中的中的主键——班级号 该关系不...
  • 用python自带的sqlite3轻量级数据库(MySQL也是一样,要安装MySQL connection),完成学生信息的存储和基本数据库操作。 用try捕获异常。 要点: 1、每次打开要关闭。 2、delete和update也是一样的,写sql语句,然后...
  • Qt数据库使用之学生管理系统

    千次阅读 2017-04-13 17:12:45
    数据库的使用主要是实现增,删,查,改,下面通过设计一个学生信息管理系统,来实现了这些操作。 1.新建工程,选择应用程序,Qt WidgetsApplication ,类名可不更改Widget,基类为Widget。 2.在UI中拖入控件,4个...
  • 本系统是学生成绩管理系统,所以应该做到可以录入学生成绩,修改学生成绩,删除学生成绩,查询学生成绩,以及最后的所有学生按照GPA排名。 本系统的数据来源期末考试成绩,用来实现录入,查询,修改,删除,以及排名...
  • 从小型单项事务处理系统到大型信息系统,从联机事务处理到联机分析处理,从一般企业管理到计算机辅助设计与制造,计算机集成制造系统,电子政务,电子商务,地理信息系统等,越来越多的应用领域采用数据库技术来存储...
  • 大二的一名菜鸡程序员完成的数据库实验报告…就自己用tkinker做的窗口对接了本地的数据库,界面很丑。。但基本功能能够实现哈哈哈~ 首先需要两个库,pymysql和tkinter,pymysql可以用其他连接数据库的代替。 import ...
  • 一步一步教你C#连接Oracle数据库制作学生成绩管理系统 需要下载的软件 最近通过网络学习了该怎么用C#连接Oracle数据库制作一个管理软件,说实话,网络上连接Oracle的教程非常少,一般都是使用MYSQL,但是我通过学习...
  • 数据库课程设计——学生宿舍信息管理系统

    万次阅读 多人点赞 2018-09-17 23:33:00
    数据库课程设计——学生宿舍信息管理系统 目录  1.设计目的... 2 2、任务与要求... 2 3、学生宿舍管理系统课程设计... 2 3.1 引言... 2 3.2需求分析... 2 3.2.1....
  • C#.net实验——数据库应用管理系统

    千次阅读 2014-05-28 18:04:52
     掌握并运用ADO.NET技术,实现一个C/S版本的信息管理系统。 (1)设计一个学生成绩管理信息系统,能对学生的成绩记录进行方便的输入、查询、修改等操作,以及综合统计查询等。 (2)对学生成绩的综合查询,如查询个人的...
  • //0代表查询学生,1代表添加学生 intent.putExtra("id", contactsId[position]); startActivity(intent); 触发器为ListView的Item的单机触发器,其实也可以使用选择触发器,下面还要说一说主界面...
  • 无后端数据库版本的----学生信息管理系统 文末下载地址 这学期的前端作业很奇怪,不用数据库实现学生信息管理系统,随便写了下。 具体功能如下: 实现了查看信息(单击查看按钮,查看具体信息,且为不可修改格式...
  • 1 概述 1.1 设计目标 熟悉数据库设计基本原理 熟悉数据库设计基本过程及方法 ... 掌握数据库设计基本技巧及设计工具 ...对大学生社团管理系统进行数据库设计,要包括以下内容: 分析大学生社团管理应包含...
  • 学生信息管理系统(7)——应用程序与数据库连接

    千次阅读 热门讨论 2014-06-30 18:30:16
    大家在敲学生信息管理系统的时候也有配置数据源,可是大家在敲红皮书实例实例时并没有配置ODBC数据源也可以连上数据库啊!这就引出连接数据库的两种方式:有源链接和无源连接。  有源链接和无源连接的根本区别:...
  • 在Android上做了个小程序——学生管理系统,下面分享一点开发经验。 SQLite数据库操作  Android 提供了 SQLiteOpenHelper 帮助你创建一个数据库,你只要继承 SQLiteOpenHelper 类,就可以轻松的创建数据库。...
  • 数据库课程设计 C# 学生选课管理系统

    万次阅读 多人点赞 2010-10-03 00:21:00
    学生选课管理系统的设计为选课及成绩管理提供了一个良好的工具,此系统基本实现了设计的要求,即登录系统(通过用户名和密码),管理(录入、查询、修改和删除)学生、课程基本资料,管理(录入、查询、修改和删除)...
  • 用了 几个小时时 间写了一个AndoidSQlite的数据库应用,学生管理系统。 1.用到类似表单的界面。界面美观清晰。 2.搭建ListView WIdget组件。单击列表项即可对其删除修改。 3.实现了对学生信息的增,删,...
  • 学生宿舍管理系统,涉及的部分信息如下: 学生:学号,姓名,性别,专业,班级。 寝室:寝室号,房间电话。 管理员:员工号,姓名,联系电话。 其中:每个寝室可同时住宿多名学生,每名学生只分配一个寝室;每个...
  • 从刚开始做红皮书、五个小例子到SQL入门经典 再到学生信息管理系统,有几个东东经常出现在我的眼前。它们是ODBC 、 OLEDB、ADO、ADODB 既然这么有缘,在不上去和它交个朋友就不是我的脾气了。  先让这几个朋友自我...
  • C#数据库图书管理系统

    万次阅读 多人点赞 2016-09-19 16:50:30
    通过模拟图书管理系统,实现以下功能 学生账号的注册 学生对馆藏图书状况的查询 学生借书,还书状态的查询 学生借书以及归还图书 学生欠款的查询 二,框架分析 数据库主要包括: 学生表:学生学号,...
  • c#实现简单学生信息管理系统

    万次阅读 多人点赞 2019-06-06 21:40:37
    登录、添加学生信息、修改学生信息、删除学生信息、查询学生信息 三、实现步骤 1、登陆界面功能实现 老规矩,先贴下主要代码: //构造方法 public Login() { InitializeComponent(); this.label3.Parent = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 64,154
精华内容 25,661
关键字:

数据库应用学生管理系统