devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

满汉楼（餐厅系统）——纯JAVA后端项目_满汉楼java项目

作者：花生_TL007 | 2024-06-14 05:42:34

赞

踩

满汉楼java项目

项目涉及知识点：MySQL数据库，JDBC连接，面向对象（oop)...

 在观看完韩顺平老师的满汉楼项目之后我也是动手跟着写了一下，顺便也是融入了自己的思考使得项目更加完善

1，账单显示时间问题

在写代码的时候就发现这个问题了，由于mysql5版本以上不支持Java的Date类型到数据库的Date类型，因此载Bill类中定义BillDate的时候可以使用LocalDateTime来定义就不会报错了。

2，新增能够重复点餐功能

自己新增多次点菜功能，其实就是一次while,continue循环来点多份菜品：
 

while (looping) {
            System.out.print("请输入点餐的菜品号（-1退出）：");
            int orderMenuId = Utility.readInt();
            if (orderMenuId == -1) {
                System.out.println("============取消点餐============");
                return;
            }
            System.out.print("请输入点餐的菜品量（-1退出）：");
            int orderNums = Utility.readInt();
            if (orderNums == -1) {
                System.out.println("============取消点餐============");
                return;
            }

            //验证餐桌号是否存在
            DiningTable diningTable = diningTableService.getDiningTableById(orderDiningTableId);
            if (diningTable == null) {
                System.out.println("============餐桌号不存在============");
                return;
            }
            //验证菜品编号
            Menu menu = menuService.getMenuById(orderMenuId);
            if (menu == null) {
                System.out.println("============菜品号不存在============");
                return;
            }

            //点餐
            if (billService.orderMenu(orderMenuId, orderNums, orderDiningTableId)) {
                System.out.println("============点餐成功============");
            } else {
                System.out.println("============点餐失败============");
            }

            //新增是否还要继续点餐功能，用循环实现
            System.out.print("请确认是否还要继续点餐(Y/N): ");
            Scanner scanner = new Scanner(System.in);
            String continueOrdering = scanner.nextLine().trim().toUpperCase();
            if (continueOrdering.equals("Y")) {
                continue;
            } else if (continueOrdering.equals("N")) {
                looping = false;
            }
        }

在进入点餐服务并输入餐桌号后开始进入循环
looping = true; //切记不要忘记在最后要把looping即循环条件重新置为true
具体实现如下图： 

 

细节：我将while循环放在了输入点餐桌号之后的代码里，这样就不用再次输入一次餐桌号点餐了，也符合连续点餐的逻辑。

3，消除账单

--在观看过程中我也是想到既然已经成功支付了账单，那按逻辑来说这一个餐桌的账单就应该从数-据库中被抹除，不然会造成账单冗余问题。
--方法依旧是非常简单，其实就是一个对表的删除语句编写。
--我同样是写在了BillService的类中，新增一个方法用于传给数据库删除的sql语句。

//完成结账后将账单删除的方法
    public void deleteBill(int diningTableId) {
        int update = billDAO.update("DELETE FROM bill WHERE diningTableId=?", diningTableId);
    }
 

 

然后在界面类中结账完成之后对方法进行一次调用即可
billService.deleteBill(diningTableId);
具体实现如下图所示：

 4，视频最后分表查询功能扩展问题

 最后老韩布置的任务即分表查询问题，我的思路是创建了一张detailEmployee表显示雇员的详细信息
然后在java 中创建对应的domain和DAO来对员工的详细信息进行查询
我将界面菜单设置成了这样两层（如下）

1代表顾客登录进行点餐等一些列操作， 2代表员工登录并显示该员工的详细信息，然后进行判断是否要显示该员工的详细信息（如下）

 

case "2":
                    while (loop3) {
                        System.out.print("输入员工号：");
                        String empId = Utility.readString(50);
                        System.out.print("输入密  码：");
                        String pwd = Utility.readString(50);
                        Employee employee = employeeService.getEmployeeByIdAndPwd(empId, pwd);
                        if (employee != null) {
                            System.out.println("===============登陆成功[" + employee.getName() + "]===============\n");
                            System.out.print("是否要显示员工信息(Y/N):");
                            Scanner scanner = new Scanner(System.in);
                            String emp = scanner.nextLine().trim().toUpperCase();
                            if (emp.equals("Y")) {
                                List<DetailedEmployeeTable> list = detailedEmployeeService.PersonManage(empId);
                                System.out.println("员工编号\t\t员工姓名\t\t岗位\t\t学历\t\t电话号码\t\t\t结婚情况");
                                for (DetailedEmployeeTable detailedEmployeeTable : list) {
                                    System.out.println(detailedEmployeeTable.getEmpId() + "\t\t" + detailedEmployeeTable.getName()
                                            + "\t\t\t" + detailedEmployeeTable.getJob() + "\t\t" + detailedEmployeeTable.getEducation()
                                            + "\t\t" + detailedEmployeeTable.getTel() + "\t\t" + detailedEmployeeTable.getMarry());
                                }
                                System.out.println("==========显示完毕==========");
                                break;
                            } else if (emp.equals("N")) {
                                break;
                            }
                        } else {
                            System.out.println("登陆失败");
                            loop3 = false;
                        }
                    }
                    break; 

如上将登录操作和查询详细表的操作放在一个case情况下完成分表查询的任务 。

5，SQL语句实现

我使用的是NaviCat，但是sql语句都大相径庭，操作方面NaviCat想要写sql语句需要点击数据库并新建一个查询（如图所示）

  1. --创建emp表（主键id，empid，name，pwd，job等
  2. CREATE TABLE employee(
  3.     id INT PRIMARY KEY AUTO_INCREMENT, -- 自增
  4.     empId VARCHAR(50) UNIQUE NOT NULL DEFAULT '', -- 员工号
  5.     pwd CHAR(32) NOT NULL DEFAULT '', -- 密码md5
  6.     name VARCHAR(50) NOT NULL DEFAULT '', -- 姓名
  7.     job VARCHAR(50) NOT NULL DEFAULT '' -- 岗位
  8. ) CHARACTER SET utf8;
  9.  
  10. --添加测试数据
  11. INSERT INTO employee VALUES(NULL, '6668612',MD5('123456'),'张三丰','经理');
  12. INSERT INTO employee VALUES(NULL, '6668622',MD5('123456'),'小龙女','服务员');
  13. INSERT INTO employee VALUES(NULL, '6668633',MD5('123456'),'张无忌','收银员');
  14. INSERT INTO employee VALUES(NULL, '666666',MD5('123456'),'老韩','经理');
  15.  
  16. SELECT* FROM diningTable;
  17. SELECT* FROM employee;
  18. DROP TABLE bill;
  19. DROP TABLE diningTable;
  20.  
  21. --创建diningTable表(id,state,orderName,orderTel...)
  22. CREATE TABLE diningTable(
  23. 				id INT PRIMARY KEY AUTO_INCREMENT, #自增，表示餐桌编号
  24. 				state VARCHAR(20) NOT NULL DEFAULT '', #餐桌的状态
  25. 				orderName VARCHAR(50) NOT NULL DEFAULT '', #预定人的名字
  26. 				orderTel VARCHAR(20) NOT NULL DEFAULT '' #电话号码
  27. ) CHARACTER SET utf8;
  28. 	
  29. INSERT INTO diningTable VALUES (NULL, '空','','');
  30. INSERT INTO diningTable VALUES (NULL, '空','','');
  31. INSERT INTO diningTable VALUES (NULL, '空','','');
  32.  
  33. update diningTable SET state = '空', orderName='', orderTel='' where id=1;
  34.  
  35. --创建menu表(id,name,type,price)
  36. #菜谱
  37. CREATE TABLE menu (
  38. 				id INT PRIMARY KEY AUTO_INCREMENT, #自增，表示菜谱编号
  39. 				NAME VARCHAR(50) NOT NULL DEFAULT '', #菜品名称
  40. 				TYPE VARCHAR(50) NOT NULL DEFAULT '', #菜品种类
  41. 				price DOUBLE NOT NULL DEFAULT 0 #价格
  42. ) CHARACTER SET utf8;
  43. #测试数据 
  44. INSERT INTO menu VALUES(NULL, '八宝饭', '主食', 10);
  45. INSERT INTO menu VALUES(NULL, '叉烧包', '主食', 20);
  46. INSERT INTO menu VALUES(NULL, '宫保鸡丁', '热菜', 30);
  47. INSERT INTO menu VALUES(NULL, '山药鲅鱼', '凉菜', 14);
  48. INSERT INTO menu VALUES(NULL, '银丝卷', '甜食', 9);
  49. INSERT INTO menu VALUES(NULL, '水煮鱼', '热菜', 26);
  50. INSERT INTO menu VALUES(NULL, '甲鱼汤', '汤类', 100);
  51. INSERT INTO menu VALUES(NULL, '鸡蛋汤', '汤类', 16);
  52.  
  53. SELECT * FROM menu;
  54.  
  55. #增加表bill账单表(id,billId,menuId,nums,billDate,money,state,diningTableId)
  56. CREATE TABLE bill (
  57. 				id INT PRIMARY KEY AUTO_INCREMENT, #自增主键
  58. 				billID VARCHAR(50) NOT NULL DEFAULT '', #账单号可以按照自己的规则生成 UUID
  59. 				menuId INT NOT NULL DEFAULT 0, #菜品的编号，也可以使用外键
  60. 				nums INT NOT NULL DEFAULT 0, #份数
  61. 				money DOUBLE NOT NULL DEFAULT 0, #金额
  62. 				diningTableId INT NOT NULL DEFAULT 0, #餐桌
  63. 				billDate DATETIME NOT NULL, #订单日期
  64. 				state VARCHAR(50) NOT NULL DEFAULT '' #状态'未结账', '已经结账', '挂单'
  65. ) CHARACTER SET utf8;
  66.  
  67. SELECT * FROM bill;
  68.  
  69. #分表查询，先将详细的雇员表建起来然后后面再根据雇员的id进行对详细雇员表的查询
  70. CREATE TABLE detailEmployee(
  71.     /* 自增 */ id INT PRIMARY KEY AUTO_INCREMENT,
  72.     /* 员工号 */ empId VARCHAR(50) UNIQUE NOT NULL DEFAULT '',
  73.     /* 姓名 */ name VARCHAR(50) NOT NULL DEFAULT '',
  74.     /* 岗位 */ job VARCHAR(50) NOT NULL DEFAULT '',
  75.     /* 学历 */ education VARCHAR(50) NOT NULL DEFAULT '',
  76.     /* 电话号码 */ Tel INT NOT NULL DEFAULT 0,
  77.     /* 是否结婚 */ Marry VARCHAR(50) NOT NULL DEFAULT ''
  78. ) CHARACTER SET utf8;
  79.  
  80. #添加数据进表
  81. INSERT INTO detailEmployee VALUES(NULL, '6668612','张三丰','经理','博士','13333333','已婚');
  82. INSERT INTO detailEmployee VALUES(NULL, '6668622','小龙女','服务员','大专','13455555','未婚');
  83. INSERT INTO detailEmployee VALUES(NULL, '6668633','张无忌','收银员', '本科','1223455','未婚');
  84. INSERT INTO detailEmployee VALUES(NULL, '666666','老韩','经理','硕士','66668788','已婚');
  85.  
  86. SELECT * FROM detailEmployee;

 以上是所有表和其中数据的sql代码。

6，具体代码实现

Utils类

JDBCUtilsByDruid

  1. import com.alibaba.druid.pool.DruidDataSourceFactory;
  2.  
  3. import javax.sql.DataSource;
  4. import java.io.FileInputStream;
  5. import java.io.IOException;
  6. import java.sql.Connection;
  7. import java.sql.ResultSet;
  8. import java.sql.SQLException;
  9. import java.sql.Statement;
  10. import java.util.Properties;
  11.  
  12. /**
  13.  * 基于 Druid数据库连接池的工具类
  14.  */
  15. public class JDBCUtilsByDruid {
  16.  
  17.     private static DataSource ds;
  18.  
  19.     //在静态代码块完成ds初始化
  20.     static {
  21.         Properties properties = new Properties();
  22.         try {
  23.             properties.load(new FileInputStream("src\\druid.properties"));
  24.             ds = DruidDataSourceFactory.createDataSource(properties);
  25.         } catch (Exception e) {
  26.             throw new RuntimeException(e);
  27.         }
  28.     }
  29.  
  30.     //编写getConnection方法
  31.     public static Connection getConnection() throws SQLException {
  32.         return ds.getConnection();
  33.     }
  34.  
  35.     //关闭连接，在数据库连接池技术中，close不是真的断掉连接，而是把Connection放回连接池
  36.     public static void close(ResultSet resultSet, Statement statement, Connection connection) {
  37.  
  38.         try {
  39.             if (resultSet != null) {
  40.                 resultSet.close();
  41.             }
  42.             if (statement != null) {
  43.                 statement.close();
  44.             }
  45.             if (connection != null) {
  46.                 connection.close();
  47.             }
  48.         } catch (SQLException e) {
  49.             throw new RuntimeException(e);
  50.         }
  51.     }
  52. }

Utility

  1. /**
  2.  * 工具类的作用:
  3.  * 处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。
  4.  */
  5.  
  6. import java.util.Scanner;
  7.  
  8. /**
  9.  *
  10.  */
  11. public class Utility {
  12.     //静态属性。。。
  13.     private static Scanner scanner = new Scanner(System.in);
  14.  
  15.  
  16.     /**
  17.      * 功能：读取键盘输入的一个菜单选项，值：1——5的范围
  18.      *
  19.      * @return 1——5
  20.      */
  21.     public static char readMenuSelection() {
  22.         char c;
  23.         for (; ; ) {
  24.             String str = readKeyBoard(1, false);//包含一个字符的字符串
  25.             c = str.charAt(0);//将字符串转换成字符char类型
  26.             if (c != '1' && c != '2' &&
  27.                     c != '3' && c != '4' && c != '5') {
  28.                 System.out.print("选择错误，请重新输入：");
  29.             } else break;
  30.         }
  31.         return c;
  32.     }
  33.  
  34.     /**
  35.      * 功能：读取键盘输入的一个字符
  36.      *
  37.      * @return 一个字符
  38.      */
  39.     public static char readChar() {
  40.         String str = readKeyBoard(1, false);//就是一个字符
  41.         return str.charAt(0);
  42.     }
  43.  
  44.     /**
  45.      * 功能：读取键盘输入的一个字符，如果直接按回车，则返回指定的默认值；否则返回输入的那个字符
  46.      *
  47.      * @param defaultValue 指定的默认值
  48.      * @return 默认值或输入的字符
  49.      */
  50.  
  51.     public static char readChar(char defaultValue) {
  52.         String str = readKeyBoard(1, true);//要么是空字符串，要么是一个字符
  53.         return (str.length() == 0) ? defaultValue : str.charAt(0);
  54.     }
  55.  
  56.     /**
  57.      * 功能：读取键盘输入的整型，长度小于2位
  58.      *
  59.      * @return 整数
  60.      */
  61.     public static int readInt() {
  62.         int n;
  63.         for (; ; ) {
  64.             String str = readKeyBoard(10, false);//一个整数，长度<=10位
  65.             try {
  66.                 n = Integer.parseInt(str);//将字符串转换成整数
  67.                 break;
  68.             } catch (NumberFormatException e) {
  69.                 System.out.print("数字输入错误，请重新输入：");
  70.             }
  71.         }
  72.         return n;
  73.     }
  74.  
  75.     /**
  76.      * 功能：读取键盘输入的 整数或默认值，如果直接回车，则返回默认值，否则返回输入的整数
  77.      *
  78.      * @param defaultValue 指定的默认值
  79.      * @return 整数或默认值
  80.      */
  81.     public static int readInt(int defaultValue) {
  82.         int n;
  83.         for (; ; ) {
  84.             String str = readKeyBoard(10, true);
  85.             if (str.equals("")) {
  86.                 return defaultValue;
  87.             }
  88.  
  89.             //异常处理...
  90.             try {
  91.                 n = Integer.parseInt(str);
  92.                 break;
  93.             } catch (NumberFormatException e) {
  94.                 System.out.print("数字输入错误，请重新输入：");
  95.             }
  96.         }
  97.         return n;
  98.     }
  99.  
  100.     /**
  101.      * 功能：读取键盘输入的指定长度的字符串
  102.      *
  103.      * @param limit 限制的长度
  104.      * @return 指定长度的字符串
  105.      */
  106.  
  107.     public static String readString(int limit) {
  108.         return readKeyBoard(limit, false);
  109.     }
  110.  
  111.     /**
  112.      * 功能：读取键盘输入的指定长度的字符串或默认值，如果直接回车，返回默认值，否则返回字符串
  113.      *
  114.      * @param limit        限制的长度
  115.      * @param defaultValue 指定的默认值
  116.      * @return 指定长度的字符串
  117.      */
  118.  
  119.     public static String readString(int limit, String defaultValue) {
  120.         String str = readKeyBoard(limit, true);
  121.         return str.equals("") ? defaultValue : str;
  122.     }
  123.  
  124.  
  125.     /**
  126.      * 功能：读取键盘输入的确认选项，Y或N
  127.      * 将小的功能，封装到一个方法中.
  128.      *
  129.      * @return Y或N
  130.      */
  131.     public static char readConfirmSelection() {
  132.         System.out.print("确认是否预定(Y/N): ");
  133.         char c;
  134.         for (; ; ) {//无限循环
  135.             //在这里，将接受到字符，转成了大写字母
  136.             //y => Y n=>N
  137.             String str = readKeyBoard(1, false).toUpperCase();
  138.             c = str.charAt(0);
  139.             if (c == 'Y' || c == 'N') {
  140.                 break;
  141.             } else {
  142.                 System.out.print("选择错误，请重新输入：");
  143.             }
  144.         }
  145.         return c;
  146.     }
  147.  
  148.     /**
  149.      * 功能： 读取一个字符串
  150.      *
  151.      * @param limit       读取的长度
  152.      * @param blankReturn 如果为true ,表示 可以读空字符串。
  153.      *                    如果为false表示 不能读空字符串。
  154.      *                    <p>
  155.      *                    如果输入为空，或者输入大于limit的长度，就会提示重新输入。
  156.      * @return
  157.      */
  158.     private static String readKeyBoard(int limit, boolean blankReturn) {
  159.  
  160.         //定义了字符串
  161.         String line = "";
  162.  
  163.         //scanner.hasNextLine() 判断有没有下一行
  164.         while (scanner.hasNextLine()) {
  165.             line = scanner.nextLine();//读取这一行
  166.  
  167.             //如果line.length=0, 即用户没有输入任何内容，直接回车
  168.             if (line.length() == 0) {
  169.                 if (blankReturn) return line;//如果blankReturn=true,可以返回空串
  170.                 else continue; //如果blankReturn=false,不接受空串，必须输入内容
  171.             }
  172.  
  173.             //如果用户输入的内容大于了 limit，就提示重写输入
  174.             //如果用户如的内容 >0 <= limit ,我就接受
  175.             if (line.length() < 1 || line.length() > limit) {
  176.                 System.out.print("输入长度（不能大于" + limit + "）错误，请重新输入：");
  177.                 continue;
  178.             }
  179.             break;
  180.         }
  181.  
  182.         return line;
  183.     }
  184. }

DAO类

BasicDAO

  1. import com.ryy.mhl.utils.JDBCUtilsByDruid;
  2. import org.apache.commons.dbutils.QueryRunner;
  3. import org.apache.commons.dbutils.handlers.BeanHandler;
  4. import org.apache.commons.dbutils.handlers.BeanListHandler;
  5. import org.apache.commons.dbutils.handlers.ScalarHandler;
  6.  
  7. import java.sql.Connection;
  8. import java.sql.SQLException;
  9. import java.util.List;
  10.  
  11. /**
  12.  * 开发BasicDAo，是其他DAO的父类
  13.  *
  14.  * @param <T>
  15.  */
  16. public class BasicDAO<T> {
  17.     private QueryRunner qr = new QueryRunner();
  18.  
  19.     //开发通用的dml方法，针对任意的表
  20.     public int update(String sql, Object... parameters) {
  21.         Connection connection = null;
  22.         try {
  23.             connection = JDBCUtilsByDruid.getConnection(); //通过Druid连接池拿到连接
  24.             int update = qr.update(connection, sql, parameters); //执行dml操作的方法
  25.             return update;
  26.         } catch (SQLException e) {
  27.             throw new RuntimeException(e);
  28.         } finally {
  29.             JDBCUtilsByDruid.close(null, null, connection);
  30.         }
  31.     }
  32.  
  33.     //如果是执行SELECT语句返回多行多列
  34.  
  35.     /**
  36.      * @param sql        sql语句，可以有？
  37.      * @param clazz      传入一个类的class对象 比如Actor.class
  38.      * @param parameters 传入？的具体的值，可以是多个
  39.      * @return 根据Actor.class返回对应的ArrayList集合
  40.      */
  41.     public List<T> queryMulti(String sql, Class<T> clazz, Object... parameters) {
  42.         Connection connection = null;
  43.         try {
  44.             connection = JDBCUtilsByDruid.getConnection(); //通过Druid连接池拿到连接
  45.             return qr.query(connection, sql, new BeanListHandler<T>(clazz), parameters);
  46.         } catch (SQLException e) {
  47.             throw new RuntimeException(e);
  48.         } finally {
  49.             JDBCUtilsByDruid.close(null, null, connection);
  50.         }
  51.     }
  52.  
  53.     //返回单行多列
  54.     public T querySingle(String sql, Class<T> clazz, Object... parameters) {
  55.         Connection connection = null;
  56.         try {
  57.             connection = JDBCUtilsByDruid.getConnection(); //通过Druid连接池拿到连接
  58.             return qr.query(connection, sql, new BeanHandler<T>(clazz), parameters);
  59.         } catch (SQLException e) {
  60.             throw new RuntimeException(e);
  61.         } finally {
  62.             JDBCUtilsByDruid.close(null, null, connection);
  63.         }
  64.     }
  65.  
  66.     //若要返回单值
  67.     public Object queryScalar(String sql, Object... parameters) {
  68.         Connection connection = null;
  69.         try {
  70.             connection = JDBCUtilsByDruid.getConnection(); //通过Druid连接池拿到连接
  71.             return qr.query(connection, sql, new ScalarHandler(), parameters);
  72.         } catch (SQLException e) {
  73.             throw new RuntimeException(e);
  74.         } finally {
  75.             JDBCUtilsByDruid.close(null, null, connection);
  76.         }
  77.     }
  78. }

BillDAO

DetailedEmployeeTableDAO

DiningTableDAO

 EmployeeDAO

MenuDAO

MultiTableDAO

以上这些DAO全部都只需要继承BasicDAO即可，没有其他多余代码

domain类

Bill

  1. import java.time.LocalDateTime;
  2. import java.util.Date;
  3.  
  4. /**
  5.  * javabean 和bill表对应
  6.  */
  7. public class Bill {
  8.     private Integer id;
  9.     private String billId;
  10.     private Integer menuId;
  11.     private Integer nums;
  12.     private Double money;
  13.     private Integer diningTableId;
  14.     private LocalDateTime billDate;
  15.     private String state;
  16.  
  17.     public Bill() {
  18.     }
  19.  
  20.     public Bill(Integer id, String billId, Integer menuId, Integer nums, Double money,
  21.                 Integer diningTableId, LocalDateTime billDate, String state) {
  22.         this.id = id;
  23.         this.billId = billId;
  24.         this.menuId = menuId;
  25.         this.nums = nums;
  26.         this.money = money;
  27.         this.diningTableId = diningTableId;
  28.         this.billDate = billDate;
  29.         this.state = state;
  30.     }
  31.  
  32.     public Integer getId() {
  33.         return id;
  34.     }
  35.  
  36.     public void setId(Integer id) {
  37.         this.id = id;
  38.     }
  39.  
  40.     public String getBillId() {
  41.         return billId;
  42.     }
  43.  
  44.     public void setBillId(String billId) {
  45.         this.billId = billId;
  46.     }
  47.  
  48.     public Integer getMenuId() {
  49.         return menuId;
  50.     }
  51.  
  52.     public void setMenuId(Integer menuId) {
  53.         this.menuId = menuId;
  54.     }
  55.  
  56.     public Integer getNums() {
  57.         return nums;
  58.     }
  59.  
  60.     public void setNums(Integer nums) {
  61.         this.nums = nums;
  62.     }
  63.  
  64.     public Double getMoney() {
  65.         return money;
  66.     }
  67.  
  68.     public void setMoney(Double money) {
  69.         this.money = money;
  70.     }
  71.  
  72.     public Integer getDiningTableId() {
  73.         return diningTableId;
  74.     }
  75.  
  76.     public void setDiningTableId(Integer diningTableId) {
  77.         this.diningTableId = diningTableId;
  78.     }
  79.  
  80.     public LocalDateTime getBillDate() {
  81.         return billDate;
  82.     }
  83.  
  84.     public void setBillDate(LocalDateTime billDate) {
  85.         this.billDate = billDate;
  86.     }
  87.  
  88.     public String getState() {
  89.         return state;
  90.     }
  91.  
  92.     public void setState(String state) {
  93.         this.state = state;
  94.     }
  95.  
  96.     @Override
  97.     public String toString() {
  98.         return  id +
  99.                 "\t\t" + menuId +
  100.                 "\t\t\t" + nums +
  101.                 "\t\t\t" + money +
  102.                 "\t" + diningTableId +
  103.                 "\t\t" + billDate +
  104.                 "\t\t" + state ;
  105.     }
  106. }

DetailedEmployeeTable

  1. public class DetailedEmployeeTable {
  2.     private Integer id;
  3.     private String empId;
  4.     private String name;
  5.     private String job;
  6.     private String education;
  7.     private Integer Tel;
  8.     private String Marry;
  9.  
  10.     public DetailedEmployeeTable() {
  11.     }
  12.  
  13.     public DetailedEmployeeTable(Integer id, String empId, String name,
  14.                                  String job, String education, Integer tel, String marry) {
  15.         this.id = id;
  16.         this.empId = empId;
  17.         this.name = name;
  18.         this.job = job;
  19.         this.education = education;
  20.         Tel = tel;
  21.         Marry = marry;
  22.     }
  23.  
  24.     public Integer getId() {
  25.         return id;
  26.     }
  27.  
  28.     public void setId(Integer id) {
  29.         this.id = id;
  30.     }
  31.  
  32.     public String getEmpId() {
  33.         return empId;
  34.     }
  35.  
  36.     public void setEmpId(String empId) {
  37.         this.empId = empId;
  38.     }
  39.  
  40.     public String getName() {
  41.         return name;
  42.     }
  43.  
  44.     public void setName(String name) {
  45.         this.name = name;
  46.     }
  47.  
  48.     public String getJob() {
  49.         return job;
  50.     }
  51.  
  52.     public void setJob(String job) {
  53.         this.job = job;
  54.     }
  55.  
  56.     public String getEducation() {
  57.         return education;
  58.     }
  59.  
  60.     public void setEducation(String education) {
  61.         this.education = education;
  62.     }
  63.  
  64.     public Integer getTel() {
  65.         return Tel;
  66.     }
  67.  
  68.     public void setTel(Integer tel) {
  69.         Tel = tel;
  70.     }
  71.  
  72.     public String getMarry() {
  73.         return Marry;
  74.     }
  75.  
  76.     public void setMarry(String marry) {
  77.         Marry = marry;
  78.     }
  79. }

DiningTable

  1. /**
  2.  * 这是一个javabean和diningTable对应
  3.  */
  4.     public class DiningTable {
  5.     private Integer id;
  6.     private String state;
  7.     private String orderName;
  8.     private String oderTel;
  9.  
  10.     public DiningTable() {
  11.     }
  12.  
  13.     public DiningTable(Integer id, String state, String orderName, String oderTel) {
  14.         this.id = id;
  15.         this.state = state;
  16.         this.orderName = orderName;
  17.         this.oderTel = oderTel;
  18.     }
  19.  
  20.     public Integer getId() {
  21.         return id;
  22.     }
  23.  
  24.     public void setId(Integer id) {
  25.         this.id = id;
  26.     }
  27.  
  28.     public String getState() {
  29.         return state;
  30.     }
  31.  
  32.     public void setState(String state) {
  33.         this.state = state;
  34.     }
  35.  
  36.     public String getOrderName() {
  37.         return orderName;
  38.     }
  39.  
  40.     public void setOrderName(String orderName) {
  41.         this.orderName = orderName;
  42.     }
  43.  
  44.     public String getOderTel() {
  45.         return oderTel;
  46.     }
  47.  
  48.     public void setOderTel(String oderTel) {
  49.         this.oderTel = oderTel;
  50.     }
  51.  
  52.     @Override
  53.     public String toString() {
  54.         return id + "\t\t\t" + state;
  55.     }
  56. }

Employee

  1. /**
  2.  * 这是一个javabean和 employee表对应
  3.  */
  4. public class Employee {
  5.     private Integer id;
  6.     private String empId;
  7.     private String pwd;
  8.     private String name;
  9.     private String job;
  10.  
  11.     public Employee() { //一定先提供无参构造器，底层apache-dbutils反射需要
  12.     }
  13.  
  14.     public Employee(Integer id, String empId, String pwd, String name, String job) {
  15.         this.id = id;
  16.         this.empId = empId;
  17.         this.pwd = pwd;
  18.         this.name = name;
  19.         this.job = job;
  20.     }
  21.  
  22.     public Integer getId() {
  23.         return id;
  24.     }
  25.  
  26.     public void setId(Integer id) {
  27.         this.id = id;
  28.     }
  29.  
  30.     public String getEmpId() {
  31.         return empId;
  32.     }
  33.  
  34.     public void setEmpId(String empId) {
  35.         this.empId = empId;
  36.     }
  37.  
  38.     public String getPwd() {
  39.         return pwd;
  40.     }
  41.  
  42.     public void setPwd(String pwd) {
  43.         this.pwd = pwd;
  44.     }
  45.  
  46.     public String getName() {
  47.         return name;
  48.     }
  49.  
  50.     public void setName(String name) {
  51.         this.name = name;
  52.     }
  53.  
  54.     public String getJob() {
  55.         return job;
  56.     }
  57.  
  58.     public void setJob(String job) {
  59.         this.job = job;
  60.     }
  61. }

Menu

  1. public class Menu {
  2.     private Integer id;
  3.     private String name;
  4.     private String type;
  5.     private Double price;
  6.  
  7.     public Menu() {
  8.     }
  9.  
  10.     public Menu(Integer id, String name, String type, Double price) {
  11.         this.id = id;
  12.         this.name = name;
  13.         this.type = type;
  14.         this.price = price;
  15.     }
  16.  
  17.     public Integer getId() {
  18.         return id;
  19.     }
  20.  
  21.     public void setId(Integer id) {
  22.         this.id = id;
  23.     }
  24.  
  25.     public String getName() {
  26.         return name;
  27.     }
  28.  
  29.     public void setName(String name) {
  30.         this.name = name;
  31.     }
  32.  
  33.     public String getType() {
  34.         return type;
  35.     }
  36.  
  37.     public void setType(String type) {
  38.         this.type = type;
  39.     }
  40.  
  41.     public Double getPrice() {
  42.         return price;
  43.     }
  44.  
  45.     public void setPrice(Double price) {
  46.         this.price = price;
  47.     }
  48.  
  49.     @Override
  50.     public String toString() {
  51.         return id + "\t\t\t" + name + "\t\t" + type + "\t\t" + price;
  52.     }
  53. }

MultiTableBean

  1. import java.time.LocalDateTime;
  2.  
  3. /**
  4.  * 这是一个javabean 可以和多张表进行对应
  5.  */
  6. public class MultiTableBean {
  7.     private Integer id;
  8.     private String billId;
  9.     private Integer menuId;
  10.     private Integer nums;
  11.     private Double money;
  12.     private Integer diningTableId;
  13.     private LocalDateTime billDate;
  14.     private String state;
  15.     //增加一个来自menu表的列 name
  16.     private String name;
  17.  
  18.     public MultiTableBean() {
  19.     }
  20.  
  21.     public MultiTableBean(Integer id, String billId, Integer menuId, Integer nums, Double money,
  22.                           Integer diningTableId, LocalDateTime billDate, String state, String name) {
  23.         this.id = id;
  24.         this.billId = billId;
  25.         this.menuId = menuId;
  26.         this.nums = nums;
  27.         this.money = money;
  28.         this.diningTableId = diningTableId;
  29.         this.billDate = billDate;
  30.         this.state = state;
  31.         this.name = name;
  32.     }
  33.  
  34.     public String getName() {
  35.         return name;
  36.     }
  37.  
  38.     public void setName(String name) {
  39.         this.name = name;
  40.     }
  41.  
  42.     public Integer getId() {
  43.         return id;
  44.     }
  45.  
  46.     public void setId(Integer id) {
  47.         this.id = id;
  48.     }
  49.  
  50.     public String getBillId() {
  51.         return billId;
  52.     }
  53.  
  54.     public void setBillId(String billId) {
  55.         this.billId = billId;
  56.     }
  57.  
  58.     public Integer getMenuId() {
  59.         return menuId;
  60.     }
  61.  
  62.     public void setMenuId(Integer menuId) {
  63.         this.menuId = menuId;
  64.     }
  65.  
  66.     public Integer getNums() {
  67.         return nums;
  68.     }
  69.  
  70.     public void setNums(Integer nums) {
  71.         this.nums = nums;
  72.     }
  73.  
  74.     public Double getMoney() {
  75.         return money;
  76.     }
  77.  
  78.     public void setMoney(Double money) {
  79.         this.money = money;
  80.     }
  81.  
  82.     public Integer getDiningTableId() {
  83.         return diningTableId;
  84.     }
  85.  
  86.     public void setDiningTableId(Integer diningTableId) {
  87.         this.diningTableId = diningTableId;
  88.     }
  89.  
  90.     public LocalDateTime getBillDate() {
  91.         return billDate;
  92.     }
  93.  
  94.     public void setBillDate(LocalDateTime billDate) {
  95.         this.billDate = billDate;
  96.     }
  97.  
  98.     public String getState() {
  99.         return state;
  100.     }
  101.  
  102.     public void setState(String state) {
  103.         this.state = state;
  104.     }
  105.  
  106.     @Override
  107.     public String toString() {
  108.         return id +
  109.                 "\t\t" + menuId +
  110.                 "\t\t\t" + nums +
  111.                 "\t\t\t" + money +
  112.                 "\t" + diningTableId +
  113.                 "\t\t" + billDate +
  114.                 "\t\t" + state +
  115.                 "\t" + name;
  116.     }
  117. }

Service类

BillService

  1. import com.ryy.mhl.dao.BillDAO;
  2. import com.ryy.mhl.dao.MultiTableDAO;
  3. import com.ryy.mhl.domain.Bill;
  4. import com.ryy.mhl.domain.MultiTableBean;
  5.  
  6. import java.util.List;
  7. import java.util.UUID;
  8.  
  9. /**
  10.  * 处理和账单相关的业务逻辑
  11.  */
  12. public class BillService {
  13.     //定义BillDAO属性
  14.     private BillDAO billDAO = new BillDAO();
  15.     //定义MenuService属性
  16.     private MenuService menuService = new MenuService();
  17.     //定义DiningTableService属性
  18.     private DiningTableService diningTableService = new DiningTableService();
  19.     //定义MultiTableDAO属性
  20.     private MultiTableDAO multiTableDAO = new MultiTableDAO();
  21.  
  22.     //编写点餐的方法
  23.     //1.生成账单
  24.     //2.需要更新对应餐桌的状态
  25.     //3.如果成功返回真，失败就返回false
  26.     public boolean orderMenu(int menuId, int nums, int diningTableId) {
  27.         //生成一个账单号，UUID
  28.         String billID = UUID.randomUUID().toString();
  29.  
  30.         //将账单生成到bill表，要求直接计算账单金额
  31.         /*注意此时要拿到菜品的价格就要去MenuService类中再创建一个方法能够返回菜品的价格进行计算*/
  32.         int update = billDAO.update("insert into bill values(null,?,?,?,?,?,now(),'未结账')",
  33.                 billID, menuId, nums, menuService.getMenuById(menuId).getPrice() * nums, diningTableId);
  34.         if (update <= 0) {
  35.             return false;
  36.         }
  37.  
  38.         //需要更新对应餐桌的状态
  39.         return diningTableService.updateDiningTableState(diningTableId, "就餐中");
  40.     }
  41.  
  42.     //返回所有的账单，提供给View调用
  43.     public List<Bill> list() {
  44.         return billDAO.queryMulti("select * from bill", Bill.class);
  45.     }
  46.  
  47.     //使用多表查询返回在一张表内（返回所有账单并显示菜品名
  48.     public List<MultiTableBean> list2() {  //注意在拼接sql语句的时候最后一定要带上空格
  49.         return multiTableDAO.queryMulti("SELECT bill.*,NAME "
  50.                 + "FROM bill,menu "
  51.                 + "WHERE bill.menuId = menu.id",MultiTableBean.class);
  52.     }
  53.  
  54.     //查看某个餐桌是否有未结账的账单
  55.     public boolean hasPayBillByDiningTableId(int diningTableId) {
  56.         Bill bill = billDAO.querySingle("SELECT * FROM bill WHERE diningTableId=? AND state='未结账' LIMIT 0, 1",
  57.                 Bill.class, diningTableId);
  58.         return bill != null;
  59.     }
  60.  
  61.     //完成结账[如果餐桌存在，并且该餐桌有未结账的账单]
  62.     public boolean payBill(int dinningTableId, String payMode) {
  63.         //1. 修改bill表
  64.         int update = billDAO.update("update bill set state=? where diningTableId=? and state='未结账'",
  65.                 payMode, dinningTableId);
  66.         if (update <= 0) { //更新失败情况
  67.             return false;
  68.         }
  69.         //2. 修改diningTable表
  70.         //注：不要直接在这里操作，而应该调用DiningTableService方法,更新餐桌就应该在餐桌类里修改以体现出各司其职
  71.         if (!diningTableService.updateDiningTableToFree(dinningTableId, "空")) {
  72.             return false;
  73.         }
  74.         return true;
  75.     }
  76.  
  77.     //完成结账后将账单删除的方法
  78.     public void deleteBill(int diningTableId) {
  79.         int update = billDAO.update("DELETE FROM bill WHERE diningTableId=?", diningTableId);
  80.     }
  81. }

DetailedEmployeeService

  1. import com.ryy.mhl.dao.DetailedEmployeeTableDAO;
  2. import com.ryy.mhl.domain.DetailedEmployeeTable;
  3.  
  4. import java.util.List;
  5.  
  6. public class DetailedEmployeeService {
  7.     private DetailedEmployeeTableDAO detailedEmployeeTableDAO = new DetailedEmployeeTableDAO();
  8.  
  9.     public List<DetailedEmployeeTable> PersonManage(String empId) {
  10.         List<DetailedEmployeeTable> list =
  11.                 detailedEmployeeTableDAO.queryMulti("select * from detailEmployee where empId=?",
  12.                         DetailedEmployeeTable.class, empId);
  13.         return list;
  14.     }
  15. }

DiningTableService

  1. import com.ryy.mhl.dao.DiningTableDAO;
  2. import com.ryy.mhl.domain.DiningTable;
  3.  
  4. import java.util.List;
  5.  
  6. public class DiningTableService {
  7.     //定义一个DiningTableDAO对象以后要对DAo里面的内容进行调用
  8.     private DiningTableDAO diningTableDAO = new DiningTableDAO();
  9.  
  10.     //返回所有餐桌的信息
  11.     public List<DiningTable> list() {
  12.         List<DiningTable> diningTables =
  13.                 diningTableDAO.queryMulti("select id, state from diningTable", DiningTable.class);
  14.         return diningTables;
  15.     }
  16.  
  17.     //根据id，查询对应餐桌的DiningTable对象
  18.     //如果返回null，表示餐桌的id不存在
  19.     public DiningTable getDiningTableById(int id) {
  20.         return diningTableDAO.querySingle("select * from diningTable where id = ?", DiningTable.class, id);
  21.     }
  22.  
  23.     //如果餐桌可以预定，调用方法，对其状态进行更新（包括预定人的名字和电话）
  24.     public boolean orderDiningTable(int id, String orderName, String orderTel) {
  25.         int update = diningTableDAO.update
  26.                 ("update diningTable set state = '已经预定', orderName=?, orderTel=? where id=?",
  27.                         orderName, orderTel, id);
  28.         return update > 0; //大于0表示更新成功了
  29.     }
  30.  
  31.     //需要提供一个更新餐桌状态的方法
  32.     public boolean updateDiningTableState(int id, String state) {
  33.         int update = diningTableDAO.update("update diningTable set state=? where id=?", state, id);
  34.         return update > 0;
  35.     }
  36.  
  37.     //提供方法，将指定的餐桌设置为空闲状态
  38.     public boolean updateDiningTableToFree(int id, String state) {
  39.         int update = diningTableDAO.update("update diningTable set state=?,orderName='',orderTel='' where id=?", state, id);
  40.         return update > 0;
  41.     }
  42. }

EmployeeService

  1. import com.ryy.mhl.dao.EmployeeDAO;
  2. import com.ryy.mhl.domain.Employee;
  3.  
  4. /**
  5.  * 该类完成对employee表的各种操作（通过调用EmployeeDAO完成）
  6.  */
  7. public class EmployeeService {
  8.  
  9.     //定义一个EmployeeDAO属性
  10.     private EmployeeDAO employeeDAO = new EmployeeDAO();
  11.  
  12.     //方法，根据 empId 和 pwd 返回一个Employee对象
  13.     //如果查询不到就返回null
  14.     public Employee getEmployeeByIdAndPwd(String empId, String pwd) {
  15.         Employee employee = employeeDAO.querySingle("select * from employee where empId=? and pwd=MD5(?)",
  16.                 Employee.class, empId, pwd);
  17.         return employee;
  18.     }
  19. }

MenuService

  1. import com.ryy.mhl.dao.MenuDAO;
  2. import com.ryy.mhl.domain.Menu;
  3.  
  4. import java.util.List;
  5.  
  6. /**
  7.  * 完成对menu表的各种操作（通过调用MenuDAO）
  8.  */
  9. public class MenuService {
  10.  
  11.     //定义MenuDAO属性
  12.     private MenuDAO menuDAO = new MenuDAO();
  13.  
  14.     //返回所有的菜品，返回给界面使用
  15.     public List<Menu> list() {
  16.         return menuDAO.queryMulti("select * from menu", Menu.class);
  17.     }
  18.  
  19.     //需要方法，根据id，返回Menu对象
  20.     //验证菜品是否存在的方法
  21.     public Menu getMenuById (int id) {
  22.         return menuDAO.querySingle("select * from menu where id=?", Menu.class, id);
  23.     }
  24. }

View类

MHLView

  1. import com.ryy.mhl.domain.*;
  2. import com.ryy.mhl.service.*;
  3. import com.ryy.mhl.utils.Utility;
  4.  
  5. import java.util.List;
  6. import java.util.Scanner;
  7.  
  8. public class MHLView {
  9.  
  10.     //控制是否退出菜单
  11.     private boolean loop = true;
  12.     private boolean loop2 = true;
  13.     private boolean loop3 = true;
  14.     private String key = ""; //接收用户选择
  15.     //定义EmployeeService属性
  16.     private EmployeeService employeeService = new EmployeeService();
  17.     //调用DiningTable的属性
  18.     private DiningTableService diningTableService = new DiningTableService();
  19.     //定义MenuService属性
  20.     private MenuService menuService = new MenuService();
  21.     //定义BillService属性
  22.     private BillService billService = new BillService();
  23.     //定义DetailedEmployeeService属性
  24.     private DetailedEmployeeService detailedEmployeeService = new DetailedEmployeeService();
  25.  
  26.     public static void main(String[] args) {
  27.         new MHLView().mainMenu();
  28.     }
  29.  
  30.     //完成结账
  31.     public void payBill() {
  32.         System.out.println("============结账服务============");
  33.         System.out.print("请选择要结账的餐桌编号（-1退出）：");
  34.         int diningTableId = Utility.readInt();
  35.         if (diningTableId == -1) {
  36.             System.out.println("============取消结账============");
  37.             return;
  38.         }
  39.         //验证餐桌是否存在
  40.         DiningTable diningTable = diningTableService.getDiningTableById(diningTableId);
  41.         if (diningTable == null) {
  42.             System.out.println("============结账的餐桌不存在============");
  43.             return;
  44.         }
  45.         //验证餐桌是否有需要结账的账单
  46.         if (!billService.hasPayBillByDiningTableId(diningTableId)) {
  47.             System.out.println("============该餐桌没有未结账账单============");
  48.             return;
  49.         }
  50.         System.out.print("结账方式（现金/微信/支付宝）回车表示退出：");
  51.         String payMode = Utility.readString(20, ""); //说明：如果回车，就是返回“”
  52.         if ("".equals(payMode)) {
  53.             System.out.println("============取消结账============");
  54.             return;
  55.         }
  56.         char key = Utility.readConfirmSelection();
  57.         if (key == 'Y') {
  58.             //调用BillService里的结账方法
  59.             if (billService.payBill(diningTableId, payMode)) {
  60.                 System.out.println("============完成结账！============");
  61.                 billService.deleteBill(diningTableId);
  62.             } else {
  63.                 System.out.println("============结账失败...============");
  64.             }
  65.         } else {
  66.             System.out.println("============取消结账============");
  67.         }
  68.     }
  69.  
  70.     //显示账单信息
  71.     public void listBill() {
  72. //        List<Bill> bills = billService.list();
  73. //        System.out.println("\n编号\t\t菜品号\t\t菜品量\t\t金额\t\t桌号\t\t日期\t\t\t\t\t\t状态");
  74. //        for (Bill bill : bills) {
  75. //            System.out.println(bill);
  76. //        }
  77. //        System.out.println("============显示完毕============");
  78.         List<MultiTableBean> multiTableBeans = billService.list2();
  79.         System.out.println("\n编号\t\t菜品号\t\t菜品量\t\t金额\t\t桌号\t\t日期\t\t\t\t\t\t状态\t\t菜品名");
  80.         for (MultiTableBean bill : multiTableBeans) {
  81.             System.out.println(bill);
  82.         }
  83.         System.out.println("============显示完毕============");
  84.     }
  85.  
  86.     //完成点餐
  87.     public void orderMenu() {
  88.         System.out.println("============点餐服务============");
  89.         System.out.print("请输入点餐的桌号（-1退出）：");
  90.         int orderDiningTableId = Utility.readInt();
  91.         if (orderDiningTableId == -1) {
  92.             System.out.println("============取消点餐============");
  93.             return;
  94.         }
  95.         while (loop2) {
  96.             System.out.print("请输入点餐的菜品号（-1退出）：");
  97.             int orderMenuId = Utility.readInt();
  98.             if (orderMenuId == -1) {
  99.                 System.out.println("============取消点餐============");
  100.                 return;
  101.             }
  102.             System.out.print("请输入点餐的菜品量（-1退出）：");
  103.             int orderNums = Utility.readInt();
  104.             if (orderNums == -1) {
  105.                 System.out.println("============取消点餐============");
  106.                 return;
  107.             }
  108.  
  109.             //验证餐桌号是否存在
  110.             DiningTable diningTable = diningTableService.getDiningTableById(orderDiningTableId);
  111.             if (diningTable == null) {
  112.                 System.out.println("============餐桌号不存在============");
  113.                 return;
  114.             }
  115.             //验证菜品编号
  116.             Menu menu = menuService.getMenuById(orderMenuId);
  117.             if (menu == null) {
  118.                 System.out.println("============菜品号不存在============");
  119.                 return;
  120.             }
  121.  
  122.             //点餐
  123.             if (billService.orderMenu(orderMenuId, orderNums, orderDiningTableId)) {
  124.                 System.out.println("============点餐成功============");
  125.             } else {
  126.                 System.out.println("============点餐失败============");
  127.             }
  128.  
  129.             //新增是否还要继续点餐功能，用循环实现
  130.             System.out.print("请确认是否还要继续点餐(Y/N): ");
  131.             Scanner scanner = new Scanner(System.in);
  132.             String continueOrdering = scanner.nextLine().trim().toUpperCase();
  133.             if (continueOrdering.equals("Y")) {
  134.                 continue;
  135.             } else if (continueOrdering.equals("N")) {
  136.                 loop2 = false;
  137.             }
  138.         }
  139.         loop2 = true;
  140.     }
  141.  
  142.     //显示所有菜品
  143.     public void listMenu() {
  144.         List<Menu> list = menuService.list();
  145.         System.out.println("\n菜品编号\t\t菜品名\t\t类别\t\t价格");
  146.         for (Menu menu : list) {
  147.             System.out.println(menu);
  148.         }
  149.         System.out.println("===============显示完毕===============");
  150.     }
  151.  
  152.     //完成定座
  153.     public void orderDiningTable() {
  154.         System.out.println("==========预定餐桌===========");
  155.         System.out.print("请选择要预定的餐桌编号（-1退出）：");
  156.         int orderId = Utility.readInt();
  157.         if (orderId == -1) {
  158.             System.out.println("===============取消预定餐桌===============");
  159.             return;
  160.         }
  161.         char key = Utility.readConfirmSelection();
  162.         if (key == 'Y') {
  163.  
  164.             //根据orderId返回对应的DiningTable对象，如果为null，说明该对象不存在
  165.             DiningTable diningTable = diningTableService.getDiningTableById(orderId);
  166.             if (diningTable == null) {
  167.                 System.out.println("==========预定餐桌不存在==========");
  168.                 return;
  169.             }
  170.             //判断该餐桌的状态是否为“空”
  171.             if (!("空".equals(diningTable.getState()))) { //说明当前这个餐桌不是“空”状态
  172.                 System.out.println("==========该餐桌已被预定或处于就餐中==========");
  173.                 return;
  174.             }
  175.  
  176.             System.out.print("预定人的名字：");
  177.             String orderName = Utility.readString(50);
  178.             System.out.print("预定人的电话：");
  179.             String orderTel = Utility.readString(50);
  180.  
  181.             //更新餐桌状态
  182.             if (diningTableService.orderDiningTable(orderId, orderName, orderTel)) {
  183.                 System.out.println("==========预定餐桌成功==========");
  184.             } else {
  185.                 System.out.println("==========预定失败==========");
  186.             }
  187.  
  188.         } else {
  189.             System.out.println("==========取消预定餐桌==========");
  190.         }
  191.     }
  192.  
  193.     public void listDiningTable() {
  194.         List<DiningTable> list = diningTableService.list();
  195.         System.out.println("\n餐桌编号\t\t餐桌状态");
  196.         for (DiningTable diningTable : list) {
  197.             System.out.println(diningTable);
  198.         }
  199.         System.out.println("===============显示完毕===============");
  200.     }
  201.  
  202.     //显示主菜单
  203.     public void mainMenu() {
  204.         while (loop) {
  205.             System.out.println("===============满汉楼===============");
  206.             System.out.println("\t\t 1 登录满汉楼");
  207.             System.out.println("\t\t 2 登录满汉楼（员工）");
  208.             System.out.println("\t\t 3 退出满汉楼");
  209.             System.out.print("请输入你的选择：");
  210.             key = Utility.readString(1);
  211.             switch (key) {
  212.                 case "1":
  213.                     //显示二级菜单
  214.                     while (loop) {
  215.                         System.out.println("\n===============满汉楼（二级菜单）===============");
  216.                         System.out.println("\t\t 1 显示餐桌状态");
  217.                         System.out.println("\t\t 2 预定餐桌");
  218.                         System.out.println("\t\t 3 显示所有菜品");
  219.                         System.out.println("\t\t 4 点餐服务");
  220.                         System.out.println("\t\t 5 查看账单");
  221.                         System.out.println("\t\t 6 结账");
  222.                         System.out.println("\t\t 9 退出满汉楼");
  223.                         System.out.print("请输入你的选择：");
  224.                         key = Utility.readString(1);
  225.                         switch (key) {
  226.                             case "1":
  227.                                 listDiningTable();
  228.                                 break;
  229.                             case "2":
  230.                                 orderDiningTable();
  231.                                 break;
  232.                             case "3":
  233.                                 listMenu();
  234.                                 break;
  235.                             case "4":
  236.                                 orderMenu();
  237.                                 break;
  238.                             case "5":
  239.                                 listBill();
  240.                                 break;
  241.                             case "6":
  242.                                 payBill();
  243.                                 break;
  244.                             case "9":
  245.                                 loop = false;
  246.                                 break;
  247.                             default:
  248.                                 System.out.println("你的输入有误，请重新输入");
  249.                                 break;
  250.                         }
  251.                     }
  252.                     break;
  253.                 case "2":
  254.                     while (loop3) {
  255.                         System.out.print("输入员工号：");
  256.                         String empId = Utility.readString(50);
  257.                         System.out.print("输入密  码：");
  258.                         String pwd = Utility.readString(50);
  259.                         Employee employee = employeeService.getEmployeeByIdAndPwd(empId, pwd);
  260.                         if (employee != null) {
  261.                             System.out.println("===============登陆成功[" + employee.getName() + "]===============\n");
  262.                             System.out.print("是否要显示员工信息(Y/N):");
  263.                             Scanner scanner = new Scanner(System.in);
  264.                             String emp = scanner.nextLine().trim().toUpperCase();
  265.                             if (emp.equals("Y")) {
  266.                                 List<DetailedEmployeeTable> list = detailedEmployeeService.PersonManage(empId);
  267.                                 System.out.println("员工编号\t\t员工姓名\t\t岗位\t\t学历\t\t电话号码\t\t\t结婚情况");
  268.                                 for (DetailedEmployeeTable detailedEmployeeTable : list) {
  269.                                     System.out.println(detailedEmployeeTable.getEmpId() + "\t\t" + detailedEmployeeTable.getName()
  270.                                             + "\t\t\t" + detailedEmployeeTable.getJob() + "\t\t" + detailedEmployeeTable.getEducation()
  271.                                             + "\t\t" + detailedEmployeeTable.getTel() + "\t\t" + detailedEmployeeTable.getMarry());
  272.                                 }
  273.                                 System.out.println("==========显示完毕==========");
  274.                                 break;
  275.                             } else if (emp.equals("N")) {
  276.                                 break;
  277.                             }
  278.                         } else {
  279.                             System.out.println("登陆失败");
  280.                             loop3 = false;
  281.                         }
  282.                     }
  283.                     break;
  284.                 case "3":
  285.                     loop = false;
  286.                     break;
  287.                 default:
  288.                     System.out.println("你的输入有误，请重新输入...");
  289.             }
  290.             System.out.println("你退出了满汉楼系统");
  291.         }
  292.     }
  293. }

制作不易，喜欢的话请点个赞吧

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/716640
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号