制作简单的图书管理系统

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

原文地址：https://www.cnblogs.com/fish1217/p/11484091.html

时间： 2024-10-10 04:36:12

制作简单的图书管理系统的相关文章

jsp数据库增删改查——简单的图书管理系统网页版

登录(指定登录号密码的简单判断): 1 <%@ page language="java" import="java.sql.*" pageEncoding="gb2312"%> 2 <html> 3 <head> 4 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">

简单的图书管理系统

自写的极其简陋的图书管理系统,代码不太规范,在学习中慢慢改 现在还存在两个问题: 1.还书还的是null2.借书传的不是书的编号 在周末之前解决 如有疑问或建议欢迎留言 LibMain.java import java.util.Scanner; /* * * 图书管理系统 * 1.登录和注册 * 2.登录成功后 * a.显示所有图书列表 添加 查询 修 删除 * b.借阅图书 需要绑定借阅人账号 * c.查看已借阅图书列表 归还图书 * 3.退出当前登录的账号 */ public class

图书管理系统

该图书馆里系统能实现基本的对图书信息的操作和借阅.归还功能. 一.主要内容: 本课程设计结合本学期所学C语言知识,数组.函数.结构体.指针.链表.文件读取操作等等,准备设计开发一个简单的图书管理系统.设计开发这个系统需要用到链表.文件读取操作.结构体.函数.指针.等C语言知识.本课程设计将会实现对图书信息的账号登录.注册账号.密码修改.密码查找.查找.输出.排序.备份.恢复.图书借阅和归还功能.本着简单.易用的设计原则,本课程设计在尽量优化界面在保证输入输出美观的同时又不失友好的交互界面. 本次

图书管理系统的设计

1.导言 1.1.目的 1.2.范围 2.系统定义 2.1.项目来源背景 2.2.项目要达到的目标 2.3.系统整体结构 3.应用环境 3.1.系统运行网络环境 3.2.系统运行硬件环境 3.3.系统运行软件环境 4.功能规格 4.1.XXX模块功能说明 5.性能需求 5.1.界面需求 6.产品提交 7.实现约束       1.目 的 1.1.目 的    为了方便借阅图书,制定了图书管理系统,可以从网上直接进行预定借阅,y在网上阅读电子版的书籍. 1.2.范 围 适用于本校学生,和老师,以及

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

上一篇讲解了制作图书管理系统的初衷与要求,和app首页的代码. 下面来介绍图书管理系统的服务对象:学生 学生类的设计: 个人信息:账号.密码.姓名.学号.邮箱.年龄. 借阅信息:借阅总数(不超过十本).借阅书籍的ID(数组).借阅书籍的日期(数组). 源码在此: 1 package com.example.administrator.library1; 2 3 import org.litepal.LitePal; 4 import org.litepal.crud.DataSupport; 5

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

前两篇介绍了主页面和Student,这一篇来讲Book类和工作人员. Book是图书管理系统的核心,查书,借书,还书,增加书都与Book类息息相关.Book类的设计很简单:包含信息:名称.作者.页数.价钱.出版日期.数量.在架数量. Book类的代码: 1 package com.example.administrator.library1; 2 3 import org.litepal.annotation.Column; 4 import org.litepal.crud.LitePalSu

简单工厂的使用（图书管理系统）

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例.简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现. 场景:有一个图书管理系统,需要进行书本管理,所有对书本的操作都进行归类,大致可以分成入账.预定.借用.续借.归还.领料.清退.转移.核销等操作,每一次的操作认为是一个订单,订单有创建,审批.取消.拒绝等状态.每一个订单包含一个或者以上的书本信息,简单工厂,先根据订单类型来创建完订单,需要先构建好入参,如下所示 strUserDoc 主要是当前操作人信息

对于使用javaweb技术制作简单管理系统的学习

近期在老师的引导下我们学习了利用Javaweb技术制作简单的管理系统,其中涉及到的技术很多,由于大多都是自学 对这些技术的理解还太浅显但能实现一些相关功能的雏形. (一).登录功能 在登陆功能中通过与数据库的连接实现了验证用户账号与密码是否正确的功能,并添加了简易的权限设置使 不同用户登录成功后所呈现的主界面是不同的:同时还有验证码功能能检测验证码是否输入正确. 数据库: jsp: 1 <%@ page language="java" contentType="text

图书管理系统-python简单实现

import sys books=[['红楼梦','曹雪芹',50],['三国义','罗贯中',55],['西游记','吴承恩',60],['水浒传','施耐庵',65]] users=[['Tom','123'],['Mike','321']] flag=False def login(): print('请输入用户名:',end='') username=input() print('请输入用户密码:',end='') password=input() if [username,passwo