制作简单的图书管理系统

 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）代码不够简洁。