制作简单的图书管理系统

Posted fish1217

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了制作简单的图书管理系统相关的知识，希望对你有一定的参考价值。

 

 1 package libray;
 2 
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;
 7 import java.sql.Statement;
 8 
 9 public class DbConn 
10     
11         private static final String DRIVER="com.mysql.jdbc.Driver";
12         private static final String URL="jdbc:mysql://localhost:3306/book";
13         private static final String USER="root";
14         private static final String PASS="root";
15          static
16              //初始化 
17              try 
18                 Class.forName(DRIVER);
19              catch (ClassNotFoundException e) 
20                 System.out.println("加载驱动异常");
21                 e.printStackTrace();
22             
23          
24          
25          public static Connection getConn()
26              Connection conn=null;
27              try 
28                conn = DriverManager.getConnection(URL,USER , PASS);
29               catch (SQLException e) 
30                 System.out.println("获取数据库连接时有异常");
31                 e.printStackTrace();
32              
33              return conn;
34          
35          
36          public static void off(Connection conn,Statement stat,ResultSet rs)
37              try 
38                  if(rs !=null) rs.close();
39                  if(stat !=null) stat.close();
40                  if(conn != null) conn.close();
41              catch (SQLException e) 
42                 System.out.println("关闭资源异常");
43                 e.printStackTrace();
44             
45          
46 
47

此类用于连接数据库。

package libray;

public class Book 
    private int bno;
    private String bname;
    private int count;
    private int kno;
    public int getBno() 
        return bno;
    
    public void setBno(int bno) 
        this.bno = bno;
    
    public String getBname() 
        return bname;
    
    public void setBname(String bname) 
        this.bname = bname;
    
    public int getCount() 
        return count;
    
    public void setCount(int count) 
        this.count = count;
    
    public int getKno() 
        return kno;
    
    public void setKno(int kno) 
        this.kno = kno;
    
    

package libray;

public class Kind 
    
    
    private int kno;
    private String kname;
    private String com;
    
    
    public int getKno() 
        return kno;
    
    public void setKno(int kno) 
        this.kno = kno;
    
    public String getKname() 
        return kname;
    
    public void setKname(String kname) 
        this.kname = kname;
    
    public String getCom() 
        return com;
    
    public void setCom(String com) 
        this.com = com;
    
    

package libray;

import java.util.List;
import java.util.Scanner;

public class BookService 
    private Scanner sc=new Scanner(System.in);
    
     public void BookMain()
         System.out.println("^^^欢迎来到书籍管理系统^^^");
         System.out.println("1.添加书籍    2.根据书籍编号删除书籍   3.借还书籍（修改书籍数目）     4.根据编号查询书籍   5.查询所有书籍");
         System.out.println("请输入你的操作指令：");
         int command = sc.nextInt();
         switch (command) 
        case 1:
            //添加书籍
             add();
            break;
        case 2:
            //根据书籍种类编号删除书籍
              del();
            break;
        case 3:
            //借还书籍
            upd();
            break;
        case 4:
            //根据编号查询书籍
            queryById();
            break;
        case 5:
            //查询所有书籍
            queryAll();
            break;
        default:
            System.out.println("指令错误");
            break;
        
     
     private void queryAll() 
         List list = new BookDAO().queryAll();
         for(int i=0;i<list.size();i++)
            Object obj=list.get(i);
            Book xy=(Book)obj;
            System.out.println("书籍编号："+xy.getBno()+",书籍名："+xy.getBname()+
                    ",数量:"+xy.getCount()+",书籍种类:"+xy.getKno());
        
    
    private void upd() 
        System.out.println("请输入书籍编号：");
        int xyno = sc.nextInt();
        Object obj = new BookDAO().queryById(xyno);
        Book xy = (Book)obj;
        if(new BookDAO().upd(xy))
            System.out.println("成功");
        else
            System.out.println("失败");
        
    
    private void del() 
        System.out.println("请输入需要删除的书籍编号：");
        int id = sc.nextInt();
        if(new BookDAO().del(id)) 
            System.out.println("删除成功");
        else 
            System.out.println("删除失败");
        
    
    public void queryById() 
          System.out.println("请输入查找的书籍编号：");
          int id = sc.nextInt();
          Object obj = new BookDAO().queryById(id);
          Book xy = (Book)obj;
          System.out.println("书籍编号："+xy.getBno()+",书籍名："+xy.getBname()+
                  ",数量:"+xy.getCount()+",书籍种类编号:"+xy.getKno());
    
    public void add()
            Book xy=new Book();
            System.out.println("请输入增加的书籍名：");
            Scanner sc=new Scanner(System.in);     
            String xyname = sc.next();
            System.out.println("请输入书籍数量：");
            int count = sc.nextInt();
            System.out.println("请输入书籍种类编号：");
            int kno = sc.nextInt();
            xy.setBname(xyname);
            xy.setCount(count);
            xy.setKno(kno);
            if(new BookDAO().add(xy))
                System.out.println("添加成功");
            else
                System.out.println("添加失败");
            
     

package libray;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class BookDAO 
    private Connection conn=null;
    private PreparedStatement ps=null;
    private ResultSet rs=null;
    
    public boolean add(Object obj) 
        boolean flag=false;
        try 
            //sql
            String sql="insert into book(bname,count,kno) value(?,?,?)";
            //获取连接
            conn = DbConn.getConn();
            ps = conn.prepareStatement(sql);
            Book xy=(Book)obj;
            ps.setString(1, xy.getBname());
            ps.setInt(2,xy.getCount());
            ps.setInt(3, xy.getKno());
            int rows = ps.executeUpdate();
            if(rows > 0)
                flag=true;
            
         catch (SQLException e) 
            e.printStackTrace();
        finally 
            DbConn.off(conn, ps, null);
        
        return flag;
    

    public boolean del(int id) 
        boolean flag=false;
        try 
            //获得连接
            conn = DbConn.getConn();
            ps=conn.prepareStatement("delete from book where bno="+id);
            int rows=ps.executeUpdate();
            if(rows>0)
                flag=true;
            
         catch (SQLException e) 
            e.printStackTrace();
        finally
                DbConn.off(conn, ps, null);
        
        return flag;
    
    
    public boolean upd(Object obj) 
        boolean flag=false;
        try 
            Book xy=(Book)obj;
            conn = DbConn.getConn();
            Scanner sc=new Scanner(System.in);
            System.out.println("1.借书    2.还书");
            System.out.println("请输入操作指令：");
            int no = sc.nextInt();
            if(no == 1) 
                System.out.println("请输入借书数目");
                int shumu = sc.nextInt();
                int count = xy.getCount() - shumu;
                if(count < 0) 
                    System.out.println("所存余量不足");
                else 
                    String sql="update book set count=? where bno="+xy.getBno();
                    ps = conn.prepareStatement(sql);
                    ps.setInt(1, count);
                    //执行修改
                    int rows = ps.executeUpdate();
                    if(rows > 0)
                        flag=true;
                    
                
            
            if(no == 2) 
                System.out.println("请输入还书数目");
                int shumu = sc.nextInt();
                int count = xy.getCount() +shumu;
                String sql="update book set count=? where bno="+xy.getBno();
                ps = conn.prepareStatement(sql);
                ps.setInt(1, count);
                //执行修改
                int rows = ps.executeUpdate();
                if(rows > 0)
                    flag=true;
                
                
         catch (SQLException e) 
            e.printStackTrace();
        finally
            DbConn.off(conn, ps, null);
        
        return flag;
    

    public List queryAll() 
        Book xy=null;
        List list = new ArrayList();
        try 
            conn = DbConn.getConn();
            ps = conn.prepareStatement("select * from book");
            rs = ps.executeQuery();
            while(rs.next())
                xy = new Book();
                int bno=rs.getInt(1);
                String bname = rs.getString(2);
                int count = rs.getInt(3);
                int kno=rs.getInt(4);
                xy.setBno(bno);
                xy.setBname(bname);
                xy.setCount(count);
                xy.setKno(kno);
                list.add(xy);
            
         catch (SQLException e) 
            e.printStackTrace();
        finally
            DbConn.off(conn, ps, null);
        
        return list;
    

    public Object queryById(int id) 
        Book xy=null;
        try   
            conn = DbConn.getConn();
            ps=conn.prepareStatement("select * from book where bno="+id);
            //结果集
            rs = ps.executeQuery();
            rs.next();
            int bno = rs.getInt("bno");
            String bname = rs.getString("bname");
            int count=rs.getInt(3);
            int kno=rs.getInt(4);
            xy=new Book();
            xy.setBno(bno);
            xy.setBname(bname);
            xy.setCount(count);
            xy.setKno(kno);
         catch (SQLException e) 
            e.printStackTrace();
        finally
            DbConn.off(conn, ps, null);
        
        return xy;
    

package libray;

import java.util.List;
import java.util.Scanner;

public class KindService 
    
    private Scanner sc=new Scanner(System.in);
    
     public void KindMain()
         System.out.println("^^^欢迎来到书籍种类管理系统^^^");
         System.out.println("1.添加书籍种类    2.根据种类编号删除书籍种类   3.修改备注     4.根据编号查询书籍种类   5.查询所有书籍种类");
         System.out.println("请输入你的操作指令：");
         int command = sc.nextInt();
         switch (command) 
        case 1:
            //添加书籍种类 
             add();
            break;
       case 2:
            //根据种类编号删除书籍种类
               del();
            break;
        case 3:
            //修改书籍种类
            upd();
            break;
        case 4:
            //根据编号查询书籍种类
            queryById();
            break;
        case 5:
            //查询所有书籍种类
            queryAll();
            break;
        default:
            System.out.println("指令错误");
            break;
        
     
     private void queryAll() 
         List list = new KindDAO().queryAll();
         for(int i=0;i<list.size();i++)
            Object obj=list.get(i);
            Kind xy=(Kind)obj;
            System.out.println("书籍种类编号："+xy.getKno()+",书籍种类名："+xy.getKname()+",备注:"+xy.getCom());
        
    
    private void upd() 
        queryAll();
        System.out.println("请输入需要修改的书籍种类编号：");
        int xyno = sc.nextInt();
        Kind xy=new Kind();
        xy.setKno(xyno);
        if(new KindDAO().upd(xy))
            System.out.println("修改成功");
        else
            System.out.println("修改失败");
        
    
    private void del() 
        System.out.println("请输入需要删除的书籍种类编号：");
        int id = sc.nextInt();
        if(new KindDAO().del(id)) 
            System.out.println("删除成功");
        else 
            System.out.println("删除失败");
        
    
    public void queryById() 
          System.out.println("请输入查找的书籍种类编号：");
          int id = sc.nextInt();
          Object obj = new KindDAO().queryById(id);
          Kind xy = (Kind)obj;
          System.out.println("书籍种类编号："+xy.getKno()+",书籍种类名名："
          +xy.getKname()+",备注:"+xy.getCom());
    
    public void add()
            Kind xy=new Kind();
            System.out.println("请输入增加的书籍种类名：");
            Scanner sc=new Scanner(System.in);     
            String xyname = sc.next();
            System.out.println("请输入书籍种类备注：");
            String com = sc.next();
            xy.setKname(xyname);
            xy.setCom(com);
            if(new KindDAO().add(xy))
                System.out.println("添加成功");
            else
                System.out.println("添加失败");
            
     

package libray;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class KindDAO 
    private Connection conn=null;
    private PreparedStatement ps=null;
    private ResultSet rs=null;
    
    public boolean add(Object obj) 
        boolean flag=false;
        try 
            
            String sql="insert into kind(kname,com) value(?,?)";
            //获取连接
            conn = DbConn.getConn();
            ps = conn.prepareStatement(sql);
            Kind xy=(Kind)obj;
            ps.setString(1, xy.getKname());
            ps.setString(2,xy.getCom());
            int rows = ps.executeUpdate();
            if(rows > 0)
                flag=true;
            
         catch (SQLException e) 
            e.printStackTrace();
        finally 
            DbConn.off(conn, ps, null);
        
        return flag;
    

    public boolean del(int id) 
        boolean flag=false;
        try 
            //获得连接
            conn = DbConn.getConn();
            ps=conn.prepareStatement("delete from kind where kno="+id);
            int rows=ps.executeUpdate();
            if(rows>0)
                flag=true;
            
         catch (SQLException e) 
            e.printStackTrace();
        finally
                DbConn.off(conn, ps, null);
        
        
        return flag;
    
    
    public boolean upd(Object obj)  
        //修改简介
        boolean flag=false;
        try 
            Kind xy=(Kind)obj;
            conn = DbConn.getConn();
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入改成的备注：");
            String com = sc.next();
            String sql="update kind set com=? where kno="+xy.getKno();
            ps = conn.prepareStatement(sql);
            ps.setString(1, com);
            //执行修改
            int rows = ps.executeUpdate();
            if(rows > 0)
                flag=true;
            
         catch (SQLException e) 
            e.printStackTrace();
        finally
            DbConn.off(conn, ps, null);
        
        return flag;
    

    public List queryAll()  //显示全部
        Kind xy=null;
        List list = new ArrayList();
        try 
            conn = DbConn.getConn();
            ps = conn.prepareStatement("select * from kind");
            rs = ps.executeQuery();
            while(rs.next())
                xy = new Kind();
                int xyno=rs.getInt(1);
                String name = rs.getString(2);
                String com = rs.getString(3);
                xy.setKno(xyno);
                xy.setKname(name);
                xy.setCom(com);
                list.add(xy);
            
         catch (SQLException e) 
            e.printStackTrace();
        finally
            DbConn.off(conn, ps, null);
        
        return list;
    

    public Object queryById(int id)  //筛选
        Kind xy=null;
        try   
            conn = DbConn.getConn();
            ps=conn.prepareStatement("select *  from kind where kno="+id);
            //结果集
            rs = ps.executeQuery();
            rs.next();
            int xyid = rs.getInt("kno");
            String name = rs.getString("kname");
            String com2=rs.getString(3);
            
            xy=new Kind();
            xy.setKno(xyid);
            xy.setKname(name);
            xy.setCom(com2);
    
         catch (SQLException e) 
            e.printStackTrace();
        finally
            DbConn.off(conn, ps, null);
        
        return xy;
    

package libray;

import java.util.Scanner;

public class Main 

    public static void main(String[] args) 
        
          System.err.println("^^^^^^欢迎来到图书管理系统^^^^^^");
        
          boolean flag=false;
          while(true)
              System.out.println("你想进入哪个系统？请输入对应的序号：");
              System.out.println("1.书籍种类管理系统  2.书籍管理系统   3.退出");
              Scanner sc=new Scanner(System.in);
              int command = sc.nextInt();
              switch (command) 
                    case 1:
                        //书籍种类管理  
                        new KindService().KindMain();
                        break;
                    case 2:
                        //书籍管理
                        new BookService().BookMain();
                        break;
                    case 3:
                        //退出
                        flag=true;
                        System.out.println("退出成功");
                        break;
                
                    default:
                        System.out.println("输入错误");
                        break;
              
              //退出
              if(flag)
                  break;

设计完成任务基本类

（1）数据库连接类

（2）Book类——书籍属性

（3）Kind类——书籍种类属性

（4）BookService类——书籍管理系统界面，输入指令

（5）BookDAO类——写有操作书籍信息的方法

（6）KindService类——书籍种类管理界面，输入指令

（7）KindDAO类——写有操作书籍种类信息的方法

（8）Main类——图书管理系统界面，选择想进入的系统

设计指令对应的方法

（1）增加书籍种类、增加书籍——add(Object obj)

（2）删除——del(int id)

（3）更改信息——upd(Object obj)

（4）查询所有——queryAll()

（5）根据编号查询——queryById(int id)

系统功能的实现

（1）添加书籍种类

 

 1 public void KindMain()
 2          System.out.println("^^^欢迎来到书籍种类管理系统^^^");
 3          System.out.println("1.添加书籍种类    2.根据种类编号删除书籍种类   3.修改备注     4.根据编号查询书籍种类   5.查询所有书籍种类");
 4          System.out.println("请输入你的操作指令：");
 5          int command = sc.nextInt();
 6          switch (command) 
 7         case 1:
 8             //添加书籍种类 
 9              add();
10             break;
11        case 2:
12             //根据种类编号删除书籍种类
13                del();
14             break;
15         case 3:
16             //修改书籍种类
17             upd();
18             break;
19         case 4:
20             //根据编号查询书籍种类
21             queryById();
22             break;
23         case 5:
24             //查询所有书籍种类
25             queryAll();
26             break;
27         default:
28             System.out.println("指令错误");
29             break;
30         
31

 

编写switch结构，根据用户输入的指令进行不同的操作。

 

public void add()
            Kind xy=new Kind();
            System.out.println("请输入增加的书籍种类名：");
            Scanner sc=new Scanner(System.in);     
            String xyname = sc.next();
            System.out.println("请输入书籍种类备注：");
            String com = sc.next();
            xy.setKname(xyname);
            xy.setCom(com);
            if(new KindDAO().add(xy))
                System.out.println("添加成功");
            else
                System.out.println("添加失败");

 

创建Kind对象xy，用户根据提示输入信息，将信息赋值给xy，接着调用KindDAO类的add方法。

 

public boolean add(Object obj) 
        boolean flag=false;
        try 
            
            String sql="insert into kind(kname,com) value(?,?)";
            //获取连接
            conn = DbConn.getConn();
            ps = conn.prepareStatement(sql);
            Kind xy=(Kind)obj;
            ps.setString(1, xy.getKname());
            ps.setString(2,xy.getCom());
            int rows = ps.executeUpdate();
            if(rows > 0)
                flag=true;
            
         catch (SQLException e) 
            e.printStackTrace();
        finally 
            DbConn.off(conn, ps, null);
        
        return flag;

 

xy对象的信息传递给obj，连接数据库，将值传入数据库中，若数据库表格被影响的行数大于零则说明传入成功。

（2）删除书籍种类

private void del() 
        System.out.println("请输入需要删除的书籍种类编号：");
        int id = sc.nextInt();
        if(new KindDAO().del(id)) 
            System.out.println("删除成功");
        else 
            System.out.println("删除失败");
        
    
public boolean del(int id) 
        boolean flag=false;
        try 
            //获得连接
            conn = DbConn.getConn();
            ps=conn.prepareStatement("delete from kind where kno="+id);
            int rows=ps.executeUpdate();
            if(rows>0)
                flag=true;
            
         catch (SQLException e) 
            e.printStackTrace();
        finally
                DbConn.off(conn, ps, null);
        
        
        return flag;

根据用户输入的指令利用switch结构调用此类的del方法。用户根据提示输入想删除的书籍种类编号，接着调用KindDAO类的del方法：根据传入的id值进行数据库操作，若数据库表格被影响的行数大于零则说明传入成功。

（3）查询书籍种类

查询所有书籍种类

 private void queryAll() 
         List list = new KindDAO().queryAll();
         for(int i=0;i<list.size();i++)
            Object obj=list.get(i);
            Kind xy=(Kind)obj;
            System.out.println("书籍种类编号："+xy.getKno()+",书籍种类名："+xy.getKname()+",备注:"+xy.getCom());
        
public List queryAll()  //显示全部
        Kind xy=null;
        List list = new ArrayList();
        try 
            conn = DbConn.getConn();
            ps = conn.prepareStatement("select * from kind");
            rs = ps.executeQuery();
            while(rs.next())
                xy = new Kind();
                int xyno=rs.getInt(1);
                String name = rs.getString(2);
                String com = rs.getString(3);
                xy.setKno(xyno);
                xy.setKname(name);
                xy.setCom(com);
                list.add(xy);
            
         catch (SQLException e) 
            e.printStackTrace();
        finally
            DbConn.off(conn, ps, null);
        
        return list;

根据用户输入的指令利用switch结构调用此类的queryAll方法。接着调用KindDAO类的queryAll方法：创建list集合，连接数据库，运用while循环获取数据库xy对象的信息，将xy加入集合中，整个方法返回一个包含数据库信息的集合。最后利用for循环将集合中的信息按照规定模式打印出来。

根据编号查询书籍种类

public void queryById() 
          System.out.println("请输入查找的书籍种类编号：");
          int id = sc.nextInt();
          Object obj = new KindDAO().queryById(id);
          Kind xy = (Kind)obj;
          System.out.println("书籍种类编号："+xy.getKno()+",书籍种类名名："
          +xy.getKname()+",备注:"+xy.getCom());

 

public Object queryById(int id)  //筛选
        Kind xy=null;
        try   
            conn = DbConn.getConn();
            ps=conn.prepareStatement("select *  from kind where kno="+id);
            //结果集
            rs = ps.executeQuery();
            rs.next();
            int xyid = rs.getInt("kno");
            String name = rs.getString("kname");
            String com2=rs.getString(3);
            
            xy=new Kind();
            xy.setKno(xyid);
            xy.setKname(name);
            xy.setCom(com2);
    
         catch (SQLException e) 
            e.printStackTrace();
        finally
            DbConn.off(conn, ps, null);
        
        return xy;

根据用户输入的指令利用switch结构调用此类的queryById方法。用户根据提示输入书籍种类编号，接着调用KindDAO类的queryById方法，传入id的值，连接数据库，将信息存入Kind类对象xy中，返回xy，然后按照指定模式输出xy。

（4）更改书籍种类的信息

根据用户输入的指令利用switch结构调用此类的upd方法。

 

private void upd() 
        queryAll();
        System.out.println("请输入需要修改的书籍种类编号：");
        int xyno = sc.nextInt();
        Kind xy=new Kind();
        xy.setKno(xyno);
        if(new KindDAO().upd(xy))
            System.out.println("修改成功");
        else
            System.out.println("修改失败");

 

此类upd方法中先调用queryAll方法输出所有数据库信息，接着用户根据提示输入编号，将编号存入Kind类对象xy的xyno属性中，再调用KindDAO类的upd方法。

 

public boolean upd(Object obj)  
        //修改简介
        boolean flag=false;
        try 
            Kind xy=(Kind)obj;
            conn = DbConn.getConn();
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入改成的备注：");
            String com = sc.next();
            String sql="update kind set com=? where kno="+xy.getKno();
            ps = conn.prepareStatement(sql);
            ps.setString(1, com);
            //执行修改
            int rows = ps.executeUpdate();
            if(rows > 0)
                flag=true;
            
         catch (SQLException e) 
            e.printStackTrace();
        finally
            DbConn.off(conn, ps, null);
        
        return flag;

 

用户根据提示输入改成的备注，连接数据库执行修改，若数据库被影响的行数大于零则修改成功，否则修改失败。

（5）添加书籍

编写一个switch结构，根据用户输入的指令利用switch结构调用此类的add方法。

 

public void BookMain()
         System.out.println("^^^欢迎来到书籍管理系统^^^");
         System.out.println("1.添加书籍    2.根据书籍编号删除书籍   3.借还书籍（修改书籍数目）     4.根据编号查询书籍   5.查询所有书籍");
         System.out.println("请输入你的操作指令：");
         int command = sc.nextInt();
         switch (command) 
        case 1:
            //添加书籍
             add();
            break;
        case 2:
            //根据书籍种类编号删除书籍
              del();
            break;
        case 3:
            //借还书籍
            upd();
            break;
        case 4:
            //根据编号查询书籍
            queryById();
            break;
        case 5:
            //查询所有书籍
            queryAll();
            break;
        default:
            System.out.println("指令错误");
            break;

 

public void add()
            Book xy=new Book();
            System.out.println("请输入增加的书籍名：");
            Scanner sc=new Scanner(System.in);     
            String xyname = sc.next();
            System.out.println("请输入书籍数量：");
            int count = sc.nextInt();
            System.out.println("请输入书籍种类编号：");
            int kno = sc.nextInt();
            xy.setBname(xyname);
            xy.setCount(count);
            xy.setKno(kno);
            if(new BookDAO().add(xy))
                System.out.println("添加成功");
            else
                System.out.println("添加失败");

此类add方法创建Book对象xy，用户根据提示输入书籍名、书籍数量、书籍编号以及所属的书籍种类编号，将信息存入对象xy中，接着调用BookDAO类的add方法。

public boolean add(Object obj) 
        boolean flag=false;
        try 
            //sql
            String sql="insert into book(bname,count,kno) value(?,?,?)";
            //获取连接
            conn = DbConn.getConn();
            ps = conn.prepareStatement(sql);
            Book xy=(Book)obj;
            ps.setString(1, xy.getBname());
            ps.setInt(2,xy.getCount());
            ps.setInt(3, xy.getKno());
            int rows = ps.executeUpdate();
            if(rows > 0)
                flag=true;
            
         catch (SQLException e) 
            e.printStackTrace();
        finally 
            DbConn.off(conn, ps, null);
        
        return flag;

add方法通过参数将对象xy传递给obj，连接数据库执行，若数据库被影响的行数大于零则添加成功，否则添加失败。

（6）删除书籍

private void del() 
        System.out.println("请输入需要删除的书籍编号：");
        int id = sc.nextInt();
        if(new BookDAO().del(id)) 
            System.out.println("删除成功");
        else 
            System.out.println("删除失败");
        
    
public boolean del(int id) 
        boolean flag=false;
        try 
            //获得连接
            conn = DbConn.getConn();
            ps=conn.prepareStatement("delete from book where bno="+id);
            int rows=ps.executeUpdate();
            if(rows>0)
                flag=true;
            
         catch (SQLException e) 
            e.printStackTrace();
        finally
                DbConn.off(conn, ps, null);
        
        return flag;

根据用户输入的指令利用switch结构调用此类的del方法。用户根据提示输入需要删除的书籍编号，接着调用BookDAO类的del方法:连接数据库执行，若数据库被影响的行数大于零则删除成功，否则删除失败。

（7）查询书籍

查询所有书籍

private void queryAll() 
         List list = new BookDAO().queryAll();
         for(int i=0;i<list.size();i++)
            Object obj=list.get(i);
            Book xy=(Book)obj;
            System.out.println("书籍编号："+xy.getBno()+",书籍名："+xy.getBname()+
                    ",数量:"+xy.getCount()+",书籍种类:"+xy.getKno());
        
    
public List queryAll() 
        Book xy=null;
        List list = new ArrayList();
        try 
            conn = DbConn.getConn();
            ps = conn.prepareStatement("select * from book");
            rs = ps.executeQuery();
            while(rs.next())
                xy = new Book();
                int bno=rs.getInt(1);
                String bname = rs.getString(2);
                int count = rs.getInt(3);
                int kno=rs.getInt(4);
                xy.setBno(bno);
                xy.setBname(bname);
                xy.setCount(count);
                xy.setKno(kno);
                list.add(xy);
            
         catch (SQLException e) 
            e.printStackTrace();
        finally
            DbConn.off(conn, ps, null);
        
        return list;

根据用户输入的指令利用switch结构调用此类的queryAll方法。接着调用BookDAO类的queryAll方法。此方法创建list集合，连接数据库，运用while循环将数据库信息一一保存至集合中，返回集合。 再根据规定形式运用for循环输出。

根据编号查询书籍

 

public void queryById() 
          System.out.println("请输入查找的书籍编号：");
          int id = sc.nextInt();
          Object obj = new BookDAO().queryById(id);
          Book xy = (Book)obj;
          System.out.println("书籍编号："+xy.getBno()+",书籍名："+xy.getBname()+
                  ",数量:"+xy.getCount()+",书籍种类编号:"+xy.getKno());

 

public Object queryById(int id) 
        Book xy=null;
        try   
            conn = DbConn.getConn();
            ps=conn.prepareStatement("select * from book where bno="+id);
            //结果集
            rs = ps.executeQuery();
            rs.next();
            int bno = rs.getInt("bno");
            String bname = rs.getString("bname");
            int count=rs.getInt(3);
            int kno=rs.getInt(4);
            xy=new Book();
            xy.setBno(bno);
            xy.setBname(bname);
            xy.setCount(count);
            xy.setKno(kno);
         catch (SQLException e) 
            e.printStackTrace();
        finally
            DbConn.off(conn, ps, null);
        
        return xy;

根据用户输入的指令利用switch结构调用此类的queryById方法。用户根据提示输入编号，接着调用BookDAO类的queryById方法：连接数据库，执行语句，将信息存入Book类对象xy中，返回对象xy。再按照规定形式输出。

（8）借还书籍

private void upd() 
        System.out.println("请输入书籍编号：");
        int xyno = sc.nextInt();
        Object obj = new BookDAO().queryById(xyno);
        Book xy = (Book)obj;
        if(new BookDAO().upd(xy))
            System.out.println("成功");
        else
            System.out.println("失败");
        
    
public boolean upd(Object obj) 
        boolean flag=false;
        try 
            Book xy=(Book)obj;
            conn = DbConn.getConn();
            Scanner sc=new Scanner(System.in);
            System.out.println("1.借书    2.还书");
            System.out.println("请输入操作指令：");
            int no = sc.nextInt();
            if(no == 1) 
                System.out.println("请输入借书数目");
                int shumu = sc.nextInt();
                int count = xy.getCount() - shumu;
                if(count < 0) 
                    System.out.println("所存余量不足");
                else 
                    String sql="update book set count=? where bno="+xy.getBno();
                    ps = conn.prepareStatement(sql);
                    ps.setInt(1, count);
                    //执行修改
                    int rows = ps.executeUpdate();
                    if(rows > 0)
                        flag=true;
                    
                
            
            if(no == 2) 
                System.out.println("请输入还书数目");
                int shumu = sc.nextInt();
                int count = xy.getCount() +shumu;
                String sql="update book set count=? where bno="+xy.getBno();
                ps = conn.prepareStatement(sql);
                ps.setInt(1, count);
                //执行修改
                int rows = ps.executeUpdate();
                if(rows > 0)
                    flag=true;
                
                
         catch (SQLException e) 
            e.printStackTrace();
        finally
            DbConn.off(conn, ps, null);
        
        return flag;

根据用户输入的指令利用switch结构调用此类的upd方法。用户根据提示输入书籍编号，接着调用BookDAO类的queryById方法，将此书籍信息存入Book类对象xy中，再调用BookDAO类的upd方法：用户根据提示输入指令，若输入1，则实行借书操作，根据提示输入借书数目，若库存不足则输出“所存余量不足”，若库存足够则减少库存数量；若输入2，则实行还书操作，用户根据提示输入还书数目，count增加，连接数据库执行语句，库存数量增加。

设计存在的问题

（1）更改信息：在书籍种类管理中只能更改书籍种类的备注，在书籍管理中只能更改书籍库存数量，其他信息不能修改。

（2）代码不够简洁。

 

 

 

 

 

 

技术图片

 

以上是关于制作简单的图书管理系统的主要内容，如果未能解决你的问题，请参考以下文章

基于Android平台的图书管理系统的制作

基于Android平台的图书管理系统的制作

基于Android平台的图书管理系统的制作

【速求C/C++】制作一个图书馆管理系统，其功能包括增加、删除、修改图书、图书统计、查阅图书、借书、还书

求access数据库制作的图书管理系统，有增删改查功能

简单的图书管理系统