满汉楼完整项目流程

界面

用户登录

’

显示餐桌状态

预定餐桌

显示所有菜品

点餐服务

查看账单

结账

退出满汉楼

分层设计

核心类库 libs

右键 add as library

util工具类

读取输入

package com.hspedu.mhl.utils;


/** 
	工具类的作用:
	处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。
*/

import java.util.*;
/**

	
*/
public class Utility {
	//静态属性。。。
    private static Scanner scanner = new Scanner(System.in);
    /** 用户登录
     * 功能：读取键盘输入的一个菜单选项，值：1——2的范围
     * @return char
     *
     */
    public static char readLoginSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false);//包含一个字符的字符串
            c = str.charAt(0);//将字符串转换成字符char类型
            if (c != '1' && c != '2') {
                System.out.print("选择错误，请重新输入：");
            } else break;
        }
        return c;
    }

    /** 满汉楼二级菜单
     * 功能：读取键盘输入的一个菜单选项，值：1——9的范围
     * @return 1——9
     */
	public static char readMenuSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false);//包含一个字符的字符串
            c = str.charAt(0);//将字符串转换成字符char类型
            if (c != '1' && c != '2' && 
                c != '3' && c != '4' && c != '5' && c != '6'
                    && c != '7'&& c != '8'&& c != '9') {
                System.out.print("选择错误，请重新输入：");
            } else break;
        }
        return c;
    }

	/**
	 * 功能：读取键盘输入的一个字符
	 * @return 一个字符
	 */
    public static char readChar() {
        String str = readKeyBoard(1, false);//就是一个字符
        return str.charAt(0);
    }
    /**
     * 功能：读取键盘输入的一个字符，如果直接按回车，则返回指定的默认值；否则返回输入的那个字符
     * @param defaultValue 指定的默认值
     * @return 默认值或输入的字符
     */
    
    public static char readChar(char defaultValue) {
        String str = readKeyBoard(1, true);//要么是空字符串，要么是一个字符
        return (str.length() == 0) ? defaultValue : str.charAt(0);
    }
	
    /**
     * 功能：读取键盘输入的整型，长度小于2位
     * @return 整数
     */
    public static int readInt() {
        int n;
        for (; ; ) {
            String str = readKeyBoard(2, false);//一个整数，长度<=2位
            try {
                n = Integer.parseInt(str);//将字符串转换成整数
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }
    /**
     * 功能：读取键盘输入的 整数或默认值，如果直接回车，则返回默认值，否则返回输入的整数
     * @param defaultValue 指定的默认值
     * @return 整数或默认值
     */
    public static int readInt(int defaultValue) {
        int n;
        for (; ; ) {
            String str = readKeyBoard(10, true);
            if (str.equals("")) {
                return defaultValue;
            }
			
			//异常处理...
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }

    /**
     * 功能：读取键盘输入的指定长度的字符串
     * @param limit 限制的长度
     * @return 指定长度的字符串
     */

    public static String readString(int limit) {
        return readKeyBoard(limit, false);
    }

    /**
     * 功能：读取键盘输入的指定长度的字符串或默认值，如果直接回车，返回默认值，否则返回字符串
     * @param limit 限制的长度
     * @param defaultValue 指定的默认值
     * @return 指定长度的字符串
     */
	
    public static String readString(int limit, String defaultValue) {
        String str = readKeyBoard(limit, true);
        return str.equals("")? defaultValue : str;
    }


	/**
	 * 功能：读取键盘输入的确认选项，Y或N
	 * 将小的功能，封装到一个方法中.
	 * @return Y或N
	 */
    public static char readConfirmSelection() {
        System.out.print("确认是否预订(Y/N): ");
        char c;
        for (; ; ) {//无限循环
        	//在这里，将接受到字符，转成了大写字母
        	//y => Y n=>N
            String str = readKeyBoard(1, false).toUpperCase();
            c = str.charAt(0);
            if (c == 'Y' || c == 'N') {
                break;
            } else {
                System.out.print("选择错误，请重新输入：");
            }
        }
        return c;
    }

    /**
     * 功能： 读取一个字符串
     * @param limit 读取的长度
     * @param blankReturn 如果为true ,表示 可以读空字符串。 
     * 					  如果为false表示 不能读空字符串。
     * 			
	 *	如果输入为空，或者输入大于limit的长度，就会提示重新输入。
     * @return
     */
    private static String readKeyBoard(int limit, boolean blankReturn) {
        
		//定义了字符串
		String line = "";

		//scanner.hasNextLine() 判断有没有下一行
        while (scanner.hasNextLine()) {
            line = scanner.nextLine();//读取这一行
           
			//如果line.length=0, 即用户没有输入任何内容，直接回车
			if (line.length() == 0) {
                if (blankReturn) return line;//如果blankReturn=true,可以返回空串
                else continue; //如果blankReturn=false,不接受空串，必须输入内容
            }

			//如果用户输入的内容大于了 limit，就提示重写输入  
			//如果用户如的内容 >0 <= limit ,我就接受
            if (line.length() < 1 || line.length() > limit) {
                System.out.print("输入长度（不能大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }
}

德鲁伊数据库连接池

package com.hspedu.mhl.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * @author 韩顺平
 * @version 1.0
 * 基于druid数据库连接池的工具类
 */
public class JDBCUtilsByDruid {

    private static DataSource ds;

    //在静态代码块完成 ds初始化
    static {
        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream("src\\druid.properties"));
            ds = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    //编写getConnection方法
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    //关闭连接, 老师再次强调： 在数据库连接池技术中，close 不是真的断掉连接
    //而是把使用的Connection对象放回连接池
    public static void close(ResultSet resultSet, Statement statement, Connection connection) {

        try {
            if (resultSet != null) {
                resultSet.close();
            }
            if (statement != null) {
                statement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

德鲁伊配置文件 -src 目录下

#key=value
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mhl?rewriteBatchedStatements=true
#url=jdbc:mysql://localhost:3306/girls
username=root
password=abc123
#initial connection Size
initialSize=10
#min idle connecton size
minIdle=5
#max active connection size
maxActive=20
#max wait time (5000 mil seconds)
maxWait=5000

View-界面层

控制菜单的显示

Service-业务层

Dao-数据库的表的 CRUD

主要是实现表的增删改查的功能

BasicDAO-核心父类

核心功能，集成了数据库的连接和关闭、增删改查的功能

package com.hspedu.mhl.dao;


import com.hspedu.mhl.utils.JDBCUtilsByDruid;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

/**
 * @author 韩顺平
 * @version 1.0
 * 开发BasicDAO , 是其他DAO的父类
 */
public class BasicDAO<T> { //泛型指定具体类型

    private QueryRunner qr =  new QueryRunner();

    //开发通用的dml方法, 针对任意的表
    public int update(String sql, Object... parameters) {

        Connection connection = null;

        try {
            connection = JDBCUtilsByDruid.getConnection();
            int update = qr.update(connection, sql, parameters);
            return  update;
        } catch (SQLException e) {
           throw  new RuntimeException(e); //将编译异常->运行异常 ,抛出
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }

    }

    //返回多个对象(即查询的结果是多行), 针对任意表

    /**
     *
     * @param sql sql 语句，可以有 ?
     * @param clazz 传入一个类的Class对象 比如 Actor.class
     * @param parameters 传入 ? 的具体的值，可以是多个
     * @return 根据Actor.class 返回对应的 ArrayList 集合
     */
    public List<T> queryMulti(String sql, Class<T> clazz, Object... parameters) {

        Connection connection = null;
        try {
            connection = JDBCUtilsByDruid.getConnection();
            return qr.query(connection, sql, new BeanListHandler<T>(clazz), parameters);

        } catch (SQLException e) {
            throw  new RuntimeException(e); //将编译异常->运行异常 ,抛出
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }

    }

    //查询单行结果 的通用方法
    public T querySingle(String sql, Class<T> clazz, Object... parameters) {

        Connection connection = null;
        try {
            connection = JDBCUtilsByDruid.getConnection();
            return  qr.query(connection, sql, new BeanHandler<T>(clazz), parameters);

        } catch (SQLException e) {
            throw  new RuntimeException(e); //将编译异常->运行异常 ,抛出
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }
    }

    //查询单行单列的方法,即返回单值的方法

    public Object queryScalar(String sql, Object... parameters) {

        Connection connection = null;
        try {
            connection = JDBCUtilsByDruid.getConnection();
            return  qr.query(connection, sql, new ScalarHandler(), parameters);

        } catch (SQLException e) {
            throw  new RuntimeException(e); //将编译异常->运行异常 ,抛出
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }
    }

}

其他 的 Dao -其他子类

每个 Dao 对应 1 个表，负责对表的增删改查以及数据库连接和关闭的功能

domain每个表，对应 1 个对象

package com.hspedu.mhl.view;

import com.hspedu.mhl.utils.Utility;

/**
 * ClassName: MHLView
 * Package: com.hspedu.mhl.view
 * Description:
 * 主界面-菜单
 * @Author 王文福
 * @Create 2024/1/1 14:01
 * @Version 1.0
 */
public class MHLView {
    private static boolean flag = true;

    public void mainMenu(){
        while (flag) {
            System.out.println("==========满汉楼==========");
            System.out.println("\t\t1.登录满汉楼");
            System.out.println("\t\t2.退出满汉楼");
            System.out.print("请输入您的选择");
            char key = Utility.readLoginSelection();
            switch (key){
                case '1':
                    //登录功能
                    login();
                    break;
                case '2':
                    exitMHL();
                    //退出功能
                    break;
            }
        }
    }

    /** 登录满汉楼
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date  14:23
     */
    public void login(){
        while (true) {
            System.out.print("用户名");
            String userName = Utility.readString(3);
            System.out.print("密码");
            String passWord = Utility.readString(6);
            //将用户名与密码建立与数据库的连接-登录数据库
            if("666".equals(userName)&&"123456".equals(passWord)){
                System.out.println("登录成功");
                //显示二级菜单
                secondaryMenu();
                break;
            }else {
                System.out.println("用户或者密码不正确，请重新输入");
            }
        }
    }
    /** 退出满汉楼
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date  14:23
     */
    public void exitMHL(){
        this.flag = false; //控制主菜单的显示
        System.out.println("退出满汉楼系统");
    }
    /** 二级菜单
     * @param :
     * @return void
     * @author "卒迹"
     * @description 登录成功后显示二级菜单
     * @date  15:09
     */
    public void secondaryMenu(){
        System.out.println("==========满汉楼二级菜单==========");
        System.out.println("\t\t1.显示餐桌状态");
        System.out.println("\t\t2.预定餐桌");
        System.out.println("\t\t3.显示所有菜品");
        System.out.println("\t\t4.点餐服务");
        System.out.println("\t\t5.查看账单");
        System.out.println("\t\t6.结账");
        System.out.println("\t\t9.退出满汉楼");
        System.out.print("请输入您的选择:");
        char key = Utility.readMenuSelection();
        switch (key){
            //显示餐桌状态
            case '1':
                break;
            //预定餐桌
            case '2':
                break;
            //显示所有菜品
            case '3':
                break;
            //点餐服务
            case '4':
                break;
            //查看账单
            case '5':
                break;
            //结账
            case '6':
                break;
            //退出满汉楼
            case '9':
                exitMHL();
                break;
        }
    }
}

功能的实现

MHLVIew-菜单的显示

0861_韩顺平Java_满汉楼菜单_哔哩哔哩_bilibili

package com.hspedu.mhl.view;

import com.hspedu.mhl.utils.Utility;

/**
 * ClassName: MHLView
 * Package: com.hspedu.mhl.view
 * Description:
 * 主界面-菜单
 * @Author 王文福
 * @Create 2024/1/1 14:01
 * @Version 1.0
 */
public class MHLView {

    //控制是否退出主菜单
    private static boolean flag = true;
    //控制用户输入的字符长度
    private String key;
    public void mainMenu(){
        while (flag) {
            System.out.println("==========满汉楼==========");
            System.out.println("\t\t1.登录满汉楼");
            System.out.println("\t\t2.退出满汉楼");
            System.out.print("请输入您的选择：");
            key = Utility.readString(1);
            switch (key){
                case "1":
                    //登录功能
                    login();
                    break;
                case "2":
                    exitMHL();
                    //退出功能
                    break;
                default:
                    System.out.println("输入有误!请重新输入");
            }
        }
    }

    /** 登录满汉楼
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date  14:23
     */
    public void login(){
        while (flag) {
            System.out.print("员工名：");
            String emp_Id = Utility.readString(50);
            System.out.print("密码：");
            String passWord = Utility.readString(50);
            //通过用户输入员工号和密码，赋值给当前的emp对象，
            // 然后连接数据库后，使用查询该员工的员工信息
            // 查询用用户输入的员工号，密码是否与数据库中的员工号和密码相互匹配
            // 如果匹配则登录成功，否则登录失败
            if("666".equals(emp_Id)&&"123456".equals(passWord)){
                System.out.println("登录成功");
                //显示二级菜单
                secondaryMenu();
                break;
            }else {
                System.out.println("用户或者密码不正确，请重新输入");
            }
        }
    }
    /** 退出满汉楼
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date  14:23
     */
    public void exitMHL(){
        this.flag = false; //控制主菜单的显示
        System.out.println("退出满汉楼系统");
    }
    /** 二级菜单
     * @param :
     * @return void
     * @author "卒迹"
     * @description 登录成功后显示二级菜单
     * @date  15:09
     */
    public void secondaryMenu(){
        while (flag){
            System.out.println("==========满汉楼二级菜单==========");
            System.out.println("\t\t1.显示餐桌状态");
            System.out.println("\t\t2.预定餐桌");
            System.out.println("\t\t3.显示所有菜品");
            System.out.println("\t\t4.点餐服务");
            System.out.println("\t\t5.查看账单");
            System.out.println("\t\t6.结账");
            System.out.println("\t\t9.退出满汉楼");
            System.out.print("请输入您的选择:");
            key = Utility.readString(1);
            switch (key){
                //显示餐桌状态
                case "1":
                    System.out.println("显示餐桌状态");
                    break;
                //预定餐桌
                case "2":
                    System.out.println("预定餐桌");
                    break;
                //显示所有菜品
                case "3":
                    System.out.println("显示所有菜品");
                    break;
                //点餐服务
                case "4":
                    System.out.println("点餐服务");
                    break;
                //查看账单
                case "5":
                    System.out.println("查看账单");
                    break;
                //结账
                case "6":
                    System.out.println("结账");
                    break;
                //退出满汉楼
                case "9":
                    exitMHL();
                    break;
                default:
                    System.out.println("输入有误，请重新输入");
            }
        }

    }
}

用户登录

0862_韩顺平Java_满汉楼登录_哔哩哔哩_bilibili

创建 employee 员工表

-- 创建满汉楼数据库
CREATE DATABASE `mhl`;
-- 使用满汉楼数据库
USE mhl;


-- 创建员工表employee
-- id，员工号，密码，姓名，工作

#员工表
#comment注释，default默认
CREATE TABLE IF NOT EXISTS `employee`(
 	`id` INT AUTO_INCREMENT COMMENT 'id',   
 	`empId` VARCHAR(50) UNIQUE NOT NULL DEFAULT '' COMMENT '员工号',
 	`pwd` CHAR(32) NOT NULL DEFAULT '' '密码MD5',
 	 	`name` VARCHAR(50) NOT NULL DEFAULT '' COMMENT '姓名',
 	`job` VARCHAR(50) NOT NULL DEFAULT '' COMMENT '岗位',
 	 PRIMARY KEY(`id`) #主键id
# INNODB引擎
# CHARSET字符集（保存字符的大小，gbk1个字符占2个字节，utf-8，1个字符占3个字节）
# 校验规则：utf8_bin（区分大小写）
)ENGINE=INNODB DEFAULT CHARSET=utf8 COLLATE utf8_bin
#查询
SELECT * FROM employee;

#添加测试数据
INSERT INTO employee VALUES(NULL,'6668612',MD5('123456'),'张三丰','经理');
INSERT INTO employee VALUES(NULL,'6668622',MD5('123456'),'小龙女','服务员'); 
INSERT INTO employee VALUES(NULL,'6668633',MD5('123456'),'张无忌','收银员'); 
INSERT INTO employee VALUES(NULL,'6668666',MD5('123456'),'老韩','经理');  

修改德鲁伊配置文件-src 目录下

#key=value
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://本地IP地址:端口号/数据库名称?rewriteBatchedStatements=true
#url=jdbc:mysql://localhost:3306/girls
#数据库用户名
username=root
#数据库密码
password=abc123
#initial connection Size
initialSize=10
#min idle connecton size
minIdle=5
#max active connection size
maxActive=20
#max wait time (5000 mil seconds)
maxWait=5000

创建 enployee 类

在 domain 文件下，新建 employee 类，

该对象的成员变量与数据库中 创建 employee 表的字段一致

package com.hspedu.mhl.domain;

/**
 * @author 韩顺平
 * @version 1.0
 * 这是一个javabean 和 employee对应
 * id int primary key auto_increment, #自增
 * 	empId varchar(50) not null default '',#员工号
 * 	pwd char(32) not null default '',#密码md5
 * 	name varchar(50) not null default '',#姓名
 * 	job varchar(50) not null default '' #岗位
 */
public class Employee {
    private Integer id;
    private String empId;
    private String pwd;
    private String name;
    private String job;

    public Employee() { //无参构造器，底层apache-dbutils反射需要
    }

    public Employee(Integer id, String empId, String pwd, String name, String job) {
        this.id = id;
        this.empId = empId;
        this.pwd = pwd;
        this.name = name;
        this.job = job;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getEmpId() {
        return empId;
    }

    public void setEmpId(String empId) {
        this.empId = empId;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }
}

创建 EmployeeDAO 子类

在 dao 包创建 EmployeeDAO 类，并继承 BasicDAO 父类，

该类实现了数据库的增删改查、连接与关闭的功能

package com.hspedu.mhl.dao;

import com.hspedu.mhl.domain.Employee;

/**
 * ClassName: EmployeeDAO
 * Package: com.hspedu.mhl.dao
 * Description:
 * 继承BasicDAO，
 * 实现了对数据库的增删改查以及连接与关闭数据的功能
 * @Author 王文福
 * @Create 2024/1/1 16:19
 * @Version 1.0
 */
public class EmployeeDAO extends BasicDAO<Employee>{
    //这里可以执行特有的功能
}

创建 EmployeeService 类

在 service 包下创建 EmployeeService 类

该类才是真正执行对员工表增删改查的类

package com.hspedu.mhl.service;

import com.hspedu.mhl.dao.EmployeeDAO;
import com.hspedu.mhl.domain.Employee;

/**
 * ClassName: EmployeeService
 * Package: com.hspedu.mhl.service
 * Description:
 * 业务层-实现对Employee表的增删改查sql语句
 * 该类完成对employee表的各种增删改查(通过调用EmployeeDAO对象完成)
 *
 * @Author 王文福
 * @Create 2024/1/1 16:30
 * @Version 1.0
 */
public class EmployeeService {
    //1.定义1个EmployeeDAO属性对象，实现对Employee表的员工号和密码的增删改查操作
    private EmployeeDAO employeeDAO = new EmployeeDAO();
    /** 2.数据库中查询员工中是否存在该Employee信息
     * @param empID:
     * @param pwd:
     * @return Employee
     * @author "卒迹"
     * @description 该方法通过形参传入员工号和密码，
     *              通过该员工号和密码去数据库查询该员工对象，返回1个Employee对象
     *              如果该对象不为空，则该对象存在，则说明员工号和密码是正确的
     * @date  16:50
     */
    public Employee getIDAndPwd(String empID, String pwd) {
        //查询的当前的员工
        Employee employee =
        //注意：查询的语句中查询的字段要与数据库中表的字段一致
        employeeDAO.querySingle("select * from employee where empID=? 
        and pwd=md5(?)", Employee.class, empID,pwd);
        return employee;
    }
}

调用 EmployeeService 类

在显示层 VIew 中调用当前 Service 类

package com.hspedu.mhl.view;

import com.hspedu.mhl.domain.Employee;
import com.hspedu.mhl.service.EmployeeService;
import com.hspedu.mhl.utils.Utility;

/**
 * ClassName: MHLView
 * Package: com.hspedu.mhl.view
 * Description:
 * 主界面-菜单
 * @Author 王文福
 * @Create 2024/1/1 14:01
 * @Version 1.0
 */
public class MHLView {

    //控制是否退出主菜单
    private static boolean flag = true;
    //控制用户输入的字符长度
    private String key;
    //创建EmployeeService对象，调用登录验证的方法
    private EmployeeService employeeService = new EmployeeService();
    public void mainMenu(){
        while (flag) {
            System.out.println("==========满汉楼==========");
            System.out.println("\t\t1.登录满汉楼");
            System.out.println("\t\t2.退出满汉楼");
            System.out.print("请输入您的选择：");
            key = Utility.readString(1);
            switch (key){
                case "1":
                    //登录功能
                    login();
                    break;
                case "2":
                    exitMHL();
                    //退出功能
                    break;
                default:
                    System.out.println("输入有误!请重新输入");
            }
        }
    }

    /** 登录满汉楼
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date  14:23
     */
    public void login(){
        while (flag) {
            System.out.print("员工名：");
            String emp_Id = Utility.readString(50);
            System.out.print("密码：");
            String passWord = Utility.readString(50);
            // 调用employeeService中的getIDAndPwd方法，返回1个Employee对象
            // 如果该对象不为空，则表示登录成功
            // 得到该员工对象的姓名，并打印输出该对象的员工姓名
            Employee employee = employeeService.getIDAndPwd(emp_Id, passWord);
            if(employee!=null){
                System.out.println("==========登录成功"+"【"+employee.getName()+"】
                                   ==========");
                //显示二级菜单
                secondaryMenu();
                break;
            }else {
                System.out.println("用户或者密码不正确，请重新输入");
            }
        }
    }
    /** 退出满汉楼
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date  14:23
     */
    public void exitMHL(){
        this.flag = false; //控制主菜单的显示
        System.out.println("退出满汉楼系统");
    }
    /** 二级菜单
     * @param :
     * @return void
     * @author "卒迹"
     * @description 登录成功后显示二级菜单
     * @date  15:09
     */
    public void secondaryMenu(){
        while (flag){
            System.out.println("==========满汉楼二级菜单==========");
            System.out.println("\t\t1.显示餐桌状态");
            System.out.println("\t\t2.预定餐桌");
            System.out.println("\t\t3.显示所有菜品");
            System.out.println("\t\t4.点餐服务");
            System.out.println("\t\t5.查看账单");
            System.out.println("\t\t6.结账");
            System.out.println("\t\t9.退出满汉楼");
            System.out.print("请输入您的选择:");
            key = Utility.readString(1);
            switch (key){
                //显示餐桌状态
                case "1":
                    System.out.println("显示餐桌状态");
                    break;
                //预定餐桌
                case "2":
                    System.out.println("预定餐桌");
                    break;
                //显示所有菜品
                case "3":
                    System.out.println("显示所有菜品");
                    break;
                //点餐服务
                case "4":
                    System.out.println("点餐服务");
                    break;
                //查看账单
                case "5":
                    System.out.println("查看账单");
                    break;
                //结账
                case "6":
                    System.out.println("结账");
                    break;
                //退出满汉楼
                case "9":
                    exitMHL();
                    break;
                default:
                    System.out.println("输入有误，请重新输入");
            }
        }

    }
}

显示餐桌的状态

0863_韩顺平Java_满汉楼餐桌_哔哩哔哩_bilibili

1.创建 diningTable 表-数据库

#餐桌表
create table diningTable (
	id int primary key auto_increment, #自增, 表示餐桌编号
	state varchar(20) not null default '',#餐桌的状态
	orderName varchar(50) not null default '',#预订人的名字
	orderTel varchar(20) not null default ''
)charset=utf8;

#餐桌状态-测试数据
insert into diningTable values(null, '空','','');
insert into diningTable values(null, '空','','');
insert into diningTable values(null, '空','','');

2.创建 diningTable 类

在 domian 包中创建 diningTable 类的 JavaBean

该类与 diningTable 表 对应

package com.hspedu.mhl.domain;

/**
 * ClassName: DiningTable
 * Package: com.hspedu.mhl.domain
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/1 17:29
 * @Version 1.0
 */
public class DiningTable {
    //提供无参构造器，为了通过反射得到该类的属性

    public DiningTable() {
    }
    //餐桌编号
    private Integer id;
    //餐桌状态
    private String state;
    //预定人名字
    private  String name;
    //预定电话
    private String phone;
  	//get、set方法
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }
}

3.创建 DiningTableDAO 类

在 dao 包下创建 DiningTableDAO 类

继承 BasicDAO，自动实现对数据库的连接与关闭，以及增删改查功能

package com.hspedu.mhl.dao;

import com.hspedu.mhl.domain.DiningTable;

/**
 * ClassName: DiningTableDAO
 * Package: com.hspedu.mhl.dao
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/1 17:33
 * @Version 1.0
 */
public class DiningTableDAO extends BasicDAO<DiningTable>{
    //扩展其他的功能
}

4.创建 DiningTableService 类

1.创建 DiningTableDAO 对象，

2.定义方法，返回 查询的所有 Dingintable 对象的集合

查询的字段，只需要餐桌 的编号 id 和餐桌的状态 state

package com.hspedu.mhl.service;

import com.hspedu.mhl.dao.DiningTableDAO;
import com.hspedu.mhl.domain.DiningTable;

import java.util.ArrayList;
import java.util.List;

/**
 * ClassName: DiningTableService
 * Package: com.hspedu.mhl.service
 * Description:
 * 对DiningTableDAO的增删改查的sal语句的执行
 * @Author 王文福
 * @Create 2024/1/1 17:38
 * @Version 1.0
 */
public class DiningTableService {
    //1.创建DiningTableDAO对象
    private DiningTableDAO diningTableDAO = new DiningTableDAO();
    //返回所有餐桌的信息
    //2.创建方法，查询DiningTable数据库中表的所有的记录，并得到1个DiningTable对象的集合
    public List<DiningTable> getAllDiningInfo(){
        //查询id和用餐的状态
        List<DiningTable> diningTables = diningTableDAO.queryMulti("select id,state from diningtable", DiningTable.class);
        return  diningTables;
    }
}

5.在显示层 VIew 调用DiningTableService 类中的方法

得到 DiningTable 对象的集合，遍历该集合输出打印其信息

注意：JavaBaen 的对象的字段与数据库中表的字段要一致

package com.hspedu.mhl.view;

import com.hspedu.mhl.domain.DiningTable;
import com.hspedu.mhl.domain.Employee;
import com.hspedu.mhl.service.DiningTableService;
import com.hspedu.mhl.service.EmployeeService;
import com.hspedu.mhl.utils.Utility;

import java.util.List;

/**
 * ClassName: MHLView
 * Package: com.hspedu.mhl.view
 * Description:
 * 主界面-菜单
 * @Author 王文福
 * @Create 2024/1/1 14:01
 * @Version 1.0
 */
public class MHLView {

    //控制是否退出主菜单
    private static boolean flag = true;
    //控制用户输入的字符长度
    private String key;
    //创建EmployeeService对象，调用登录验证的方法
    private EmployeeService employeeService = new EmployeeService();
    //1.创建DiningTableService，调用其用餐状态的方法
    private DiningTableService diningTableService = new DiningTableService();
    public void mainMenu(){
        while (flag) {
            System.out.println("==========满汉楼==========");
            System.out.println("\t\t1.登录满汉楼");
            System.out.println("\t\t2.退出满汉楼");
            System.out.print("请输入您的选择：");
            key = Utility.readString(1);
            switch (key){
                case "1":
                    //登录功能
                    login();
                    break;
                case "2":
                    exitMHL();
                    //退出功能
                    break;
                default:
                    System.out.println("输入有误!请重新输入");
            }
        }
    }

    /** 登录满汉楼
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date  14:23
     */
    public void login(){
        while (flag) {
            System.out.print("员工名：");
            String emp_Id = Utility.readString(50);
            System.out.print("密码：");
            String passWord = Utility.readString(50);
            // 调用employeeService中的getIDAndPwd方法，返回1个Employee对象
            // 如果该对象不为空，则表示登录成功
            // 得到该员工对象的姓名，并打印输出该对象的员工姓名
            Employee employee = employeeService.getIDAndPwd(emp_Id, passWord);
            if(employee!=null){
                System.out.println("==========登录成功"+"【"+employee.getName()+"】==========");
                //显示二级菜单
                secondaryMenu();
                break;
            }else {
                System.out.println("用户或者密码不正确，请重新输入");
            }
        }
    }
    /** 退出满汉楼
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date  14:23
     */
    public void exitMHL(){
        this.flag = false; //控制主菜单的显示
        System.out.println("退出满汉楼系统");
    }
    /** 二级菜单
     * @param :
     * @return void
     * @author "卒迹"
     * @description 登录成功后显示二级菜单
     * @date  15:09
     */
    public void secondaryMenu(){
        while (flag){
            System.out.println("==========满汉楼二级菜单==========");
            System.out.println("\t\t1.显示餐桌状态");
            System.out.println("\t\t2.预定餐桌");
            System.out.println("\t\t3.显示所有菜品");
            System.out.println("\t\t4.点餐服务");
            System.out.println("\t\t5.查看账单");
            System.out.println("\t\t6.结账");
            System.out.println("\t\t9.退出满汉楼");
            System.out.print("请输入您的选择:");
            key = Utility.readString(1);
            switch (key){
                //显示餐桌状态
                case "1":
                    System.out.println("显示餐桌状态");
                    //3.调用显示餐桌状态方法
                    showDiningState();
                    break;
                //预定餐桌
                case "2":
                    System.out.println("预定餐桌");
                    break;
                //显示所有菜品
                case "3":
                    System.out.println("显示所有菜品");
                    break;
                //点餐服务
                case "4":
                    System.out.println("点餐服务");
                    break;
                //查看账单
                case "5":
                    System.out.println("查看账单");
                    break;
                //结账
                case "6":
                    System.out.println("结账");
                    break;
                //退出满汉楼
                case "9":
                    exitMHL();
                    break;
                default:
                    System.out.println("输入有误，请重新输入");
            }
        }

    }


    /** 2.显示用餐状态
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date  18:04
     */
    public void showDiningState(){
        //得到保存用餐状态的集合
        List<DiningTable> diningStateList = diningTableService.getAllDiningState();
        System.out.println("餐桌编号\t\t餐桌状态");
        //遍历该集合，得到每个客人用餐的对象，并打印其id和状态
        for (DiningTable dinging : diningStateList) {
            System.out.println(dinging.getId() + "\t\t\t" + dinging.getState());
        }
        System.out.println("==========显示完毕==========");
    }
}

订餐

0865_韩顺平Java_满汉楼订座2_哔哩哔哩_bilibili

核心思路：将用户输入的数据，插入到 DiningTable 表 中

分析：

dml 的 数据的表为同 1 张表 DiningTable

我们只需要在 DiningTableService 中扩展

1.根据 id，查询当前餐桌表空闲状态

2.根据 id，更新当前餐桌表的数据

思路：

查询当前餐桌的空闲状态，如果空闲则更新该表 的数据

在 DiningTableService 类中新增功能

新增查询方法

1.根据 id，查询当前餐桌表空闲状态

2.根据 id，更新当前餐桌表的数据

package com.hspedu.mhl.service;

import com.hspedu.mhl.dao.DiningTableDAO;
import com.hspedu.mhl.domain.DiningTable;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * ClassName: DiningTableService
 * Package: com.hspedu.mhl.service
 * Description:
 * 对DiningTableDAO的增删改查的sal语句的执行
 * @Author 王文福
 * @Create 2024/1/1 17:38
 * @Version 1.0
 */
public class DiningTableService {
    //1.创建DiningTableDAO对象
    private DiningTableDAO diningTableDAO = new DiningTableDAO();
    //返回所有餐桌的信息
    //2.创建方法，查询DiningTable数据库中表的所有的记录，并得到1个DiningTable对象的集合
    public List<DiningTable> getAllDiningState(){
        //查询id和用餐的状态
        List<DiningTable> diningTables = diningTableDAO.queryMulti("select id,state from diningtable", DiningTable.class);
        return  diningTables;
    }
    // 根据传入的id查询用餐的状态
    // 返回的DiningTable为等于null，该餐位不存在
    // 如果不为null，则说明当前餐为号存在，需要得到该状态
    public DiningTable diningState(int id){
        DiningTable diningTable = diningTableDAO.querySingle
        ("select * from diningtable where id=?;", DiningTable.class, id);
        return  diningTable;
    }
    //如果餐桌是空闲的，调用方法，对其状态进行更新(包括预定人的名字和电话)
    public boolean updateDiningInfo(int orderId,String orderName,String orderTel){
        int update =
                diningTableDAO.update("update diningtable set state='已预定', orderName=?,orderTel=? where id=?", orderName,orderTel,orderId);
        return  update >0;
    }
}

VIew 层创建调用其方法，得到其餐位号的数据对象

1.根据 id，查询当前餐桌表空闲状态

2.根据 id，更新当前餐桌表的数据

package com.hspedu.mhl.view;

import com.hspedu.mhl.domain.DiningTable;
import com.hspedu.mhl.domain.Employee;
import com.hspedu.mhl.service.DiningTableService;
import com.hspedu.mhl.service.EmployeeService;
import com.hspedu.mhl.utils.Utility;

import java.sql.SQLOutput;
import java.util.List;

/**
 * ClassName: MHLView
 * Package: com.hspedu.mhl.view
 * Description:
 * 主界面-菜单
 * @Author 王文福
 * @Create 2024/1/1 14:01
 * @Version 1.0
 */
public class MHLView {

    //控制是否退出主菜单
    private static boolean flag = true;
    //控制用户输入的字符长度
    private String key;
    //创建EmployeeService对象，调用登录验证的方法
    private EmployeeService employeeService = new EmployeeService();
    //创建DiningTableService，调用其用餐状态的方法
    private DiningTableService diningTableService = new DiningTableService();
    public void mainMenu(){
        while (flag) {
            System.out.println("==========满汉楼==========");
            System.out.println("\t\t1.登录满汉楼");
            System.out.println("\t\t2.退出满汉楼");
            System.out.print("请输入您的选择：");
            key = Utility.readString(1);
            switch (key){
                case "1":
                    //登录功能
                    login();
                    break;
                case "2":
                    exitMHL();
                    //退出功能
                    break;
                default:
                    System.out.println("输入有误!请重新输入");
            }
        }
    }

    /** 登录满汉楼
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date  14:23
     */
    public void login(){
        while (flag) {
            System.out.print("员工名：");
            String emp_Id = Utility.readString(50);
            System.out.print("密码：");
            String passWord = Utility.readString(50);
            // 调用employeeService中的getIDAndPwd方法，返回1个Employee对象
            // 如果该对象不为空，则表示登录成功
            // 得到该员工对象的姓名，并打印输出该对象的员工姓名
            Employee employee = employeeService.getIDAndPwd(emp_Id, passWord);
            if(employee!=null){
                System.out.println("==========登录成功"+"【"+employee.getName()+"】==========");
                //显示二级菜单
                secondaryMenu();
                break;
            }else {
                System.out.println("用户或者密码不正确，请重新输入");
            }
        }
    }
    /** 退出满汉楼
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date  14:23
     */
    public void exitMHL(){
        this.flag = false; //控制主菜单的显示
        System.out.println("退出满汉楼系统");
    }
    /** 二级菜单
     * @param :
     * @return void
     * @author "卒迹"
     * @description 登录成功后显示二级菜单
     * @date  15:09
     */
    public void secondaryMenu(){
        while (flag){
            System.out.println("==========满汉楼二级菜单==========");
            System.out.println("\t\t1.显示餐桌状态");
            System.out.println("\t\t2.预定餐桌");
            System.out.println("\t\t3.显示所有菜品");
            System.out.println("\t\t4.点餐服务");
            System.out.println("\t\t5.查看账单");
            System.out.println("\t\t6.结账");
            System.out.println("\t\t9.退出满汉楼");
            System.out.print("请输入您的选择:");
            key = Utility.readString(1);
            switch (key){
                //显示餐桌状态
                case "1":
                    System.out.println("显示餐桌状态");
                    showDiningState();
                    break;
                //预定餐桌
                case "2":
                    System.out.println("预定餐桌");
                    tableReservation();
                    break;
                //显示所有菜品
                case "3":
                    System.out.println("显示所有菜品");
                    break;
                //点餐服务
                case "4":
                    System.out.println("点餐服务");
                    break;
                //查看账单
                case "5":
                    System.out.println("查看账单");
                    break;
                //结账
                case "6":
                    System.out.println("结账");
                    break;
                //退出满汉楼
                case "9":
                    exitMHL();
                    break;
                default:
                    System.out.println("输入有误，请重新输入");
            }
        }

    }


    /** 显示用餐状态
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date  18:04
     */
    public void showDiningState(){
        //得到保存用餐状态的集合
        List<DiningTable> diningStateList = diningTableService.getAllDiningState();
        System.out.println("餐桌编号\t\t餐桌状态");
        //遍历该集合，得到每个用餐的状态，并打印其id和状态
        for (DiningTable dinging : diningStateList) {
            System.out.println(dinging.getId() + "\t\t\t" + dinging.getState());
        }
        System.out.println("==========显示完毕==========");
    }

    /** 预定餐桌
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date  18:48
     */
    public void tableReservation(){
        //过五关斩六将---排除所有错误的可能性
        System.out.println("==========预定餐桌==========");
        System.out.print("请选择要预定餐桌编号(-1退出):");
        int orderId = Utility.readInt();
        if(orderId==-1){
            System.out.println("==========取消餐桌预定==========");
            return;
        }
        //根据传入的id查询当前餐桌的状态
        DiningTable diningTable = diningTableService.diningState(orderId);
        // 如果查询的返回的值是null，则说明输入的餐位号id不存在
        if(diningTable==null){
            System.out.println("==========当前餐桌" + orderId + "不存在==========");
            return;
        }
        //已被预定状态
        if("已预定".equals(diningTable.getState())){
            System.out.println("当前餐位已经被其他客人预定");
            return;
        }
        //非空闲状态
        if(!"空闲中".equals(diningTable.getState())){
            return;
        }
        //排除所有可能性后，则当前餐位是空闲的
        char choose = Utility.readConfirmSelection();
        if(choose != 'Y'){
            //确认是否预定餐位
            return;
        }
        System.out.print("预定人名字");
        String orderName = Utility.readString(50);
        System.out.print("预定人电话");
        String orderTel = Utility.readString(50);
        boolean mark = diningTableService.updateDiningInfo(orderId, orderName, orderTel);
        if(mark){
            System.out.println("==========预定成功==========");
        }else {
            System.out.println("==========预定失败==========");
        }
    }
}

显示菜品

0866_韩顺平Java_满汉楼菜单_哔哩哔哩_bilibili

1.创建菜品表

#菜谱
create table menu (
	id int primary key auto_increment, #自增主键，作为菜谱编号(唯一)
	name varchar(50) not null default '',#菜品名称
	type varchar(50) not null default '', #菜品种类
	price double not null default 0#价格
)charset=utf8; 

insert into menu values(null, '八宝饭', '主食类', 10);
insert into menu values(null, '叉烧包', '主食类', 20);
insert into menu values(null, '宫保鸡丁', '热菜类', 30);
insert into menu values(null, '山药拨鱼', '凉菜类', 14);
insert into menu values(null, '银丝卷', '甜食类', 9);
insert into menu values(null, '水煮鱼', '热菜类', 26);
insert into menu values(null, '甲鱼汤', '汤类', 100);
insert into menu values(null, '鸡蛋汤', '汤类', 16);

SELECT * FROM menu;

2.创建菜品类-JavaBean

包路径-domain

package com.hspedu.mhl.domain;

/**
 * ClassName: Menu
 * Package: com.hspedu.mhl.domain
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/1 21:46
 * @Version 1.0
 * #菜谱
 * create table menu (
 * 	id int primary key auto_increment, #自增主键，作为菜谱编号(唯一)
 * 	name varchar(50) not null default '',#菜品名称
 * 	type varchar(50) not null default '', #菜品种类
 * 	price double not null default 0#价格
 * )charset=utf8;
 */
public class Menu {
    private Integer id; //菜谱编号
    private String name;//菜品名称
    private String type;//菜品种类
    private Double price;//菜品价格
    //提供无参构造器，用于反射得到其属性
    public Menu() {
    }

    public Menu(Integer id, String name, String type, Double price) {
        this.id = id;
        this.name = name;
        this.type = type;
        this.price = price;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }
}

3.创建菜品 DAO

包路径-dao

package com.hspedu.mhl.dao;

import com.hspedu.mhl.domain.Menu;

/**
 * ClassName: MenuDAO
 * Package: com.hspedu.mhl.dao
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/1 21:49
 * @Version 1.0
 */
public class MenuDAO extends BasicDAO<Menu>{
    //可拓展其他功能
}

4.创建菜品 Service

package com.hspedu.mhl.service;

import com.hspedu.mhl.dao.MenuDAO;
import com.hspedu.mhl.domain.Menu;

import java.util.List;

/**
 * ClassName: MenuService
 * Package: com.hspedu.mhl.service
 * Description:
 *
 * @Author 王文福
 * @Create 2024/1/1 21:50
 * @Version 1.0
 */
public class MenuService {
    //创建MenuDAO对象，实现对Menu数据库表的CURD
    private MenuDAO menuDAO = new MenuDAO();
    //查询表中所有的数据-得到保存其Menu对象的集合
    public List<Menu> getAllMenuInfo(){
        List<Menu> menus = menuDAO.queryMulti("select * from menu", Menu.class);
        return menus;
    }
}

5.VIew 层调用 菜品 Serive 方法

package com.hspedu.mhl.view;

import com.hspedu.mhl.domain.DiningTable;
import com.hspedu.mhl.domain.Employee;
import com.hspedu.mhl.domain.Menu;
import com.hspedu.mhl.service.DiningTableService;
import com.hspedu.mhl.service.EmployeeService;
import com.hspedu.mhl.service.MenuService;
import com.hspedu.mhl.utils.Utility;

import java.sql.SQLOutput;
import java.util.List;

/**
 * ClassName: MHLView
 * Package: com.hspedu.mhl.view
 * Description:
 * 主界面-菜单
 *
 * @Author 王文福
 * @Create 2024/1/1 14:01
 * @Version 1.0
 */
public class MHLView {

    //控制是否退出主菜单
    private static boolean flag = true;
    //控制用户输入的字符长度
    private String key;
    //创建EmployeeService对象，调用登录验证的方法
    private EmployeeService employeeService = new EmployeeService();
    //创建DiningTableService，调用其用餐状态的方法
    private DiningTableService diningTableService = new DiningTableService();

    //创建MenyService，调用方法，得到所有菜品集合
    private MenuService menuService = new MenuService();

    public void mainMenu() {
        while (flag) {
            System.out.println("==========满汉楼==========");
            System.out.println("\t\t1.登录满汉楼");
            System.out.println("\t\t2.退出满汉楼");
            System.out.print("请输入您的选择：");
            key = Utility.readString(1);
            switch (key) {
                case "1":
                    //登录功能
                    login();
                    break;
                case "2":
                    exitMHL();
                    //退出功能
                    break;
                default:
                    System.out.println("输入有误!请重新输入");
            }
        }
    }

    /**
     * 登录满汉楼
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date 14:23
     */
    public void login() {
        while (flag) {
            System.out.print("员工名：");
            String emp_Id = Utility.readString(50);
            System.out.print("密码：");
            String passWord = Utility.readString(50);
            // 调用employeeService中的getIDAndPwd方法，返回1个Employee对象
            // 如果该对象不为空，则表示登录成功
            // 得到该员工对象的姓名，并打印输出该对象的员工姓名
            Employee employee = employeeService.getIDAndPwd(emp_Id, passWord);
            if (employee != null) {
                System.out.println("==========登录成功" + "【" + employee.getName() + "】==========");
                //显示二级菜单
                secondaryMenu();
                break;
            } else {
                System.out.println("用户或者密码不正确，请重新输入");
            }
        }
    }

    /**
     * 退出满汉楼
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date 14:23
     */
    public void exitMHL() {
        this.flag = false; //控制主菜单的显示
        System.out.println("退出满汉楼系统");
    }

    /**
     * 二级菜单
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description 登录成功后显示二级菜单
     * @date 15:09
     */
    public void secondaryMenu() {
        while (flag) {
            System.out.println("==========满汉楼二级菜单==========");
            System.out.println("\t\t1.显示餐桌状态");
            System.out.println("\t\t2.预定餐桌");
            System.out.println("\t\t3.显示所有菜品");
            System.out.println("\t\t4.点餐服务");
            System.out.println("\t\t5.查看账单");
            System.out.println("\t\t6.结账");
            System.out.println("\t\t9.退出满汉楼");
            System.out.print("请输入您的选择:");
            key = Utility.readString(1);
            switch (key) {
                //显示餐桌状态
                case "1":
                    System.out.println("显示餐桌状态");
                    showDiningState();
                    break;
                //预定餐桌
                case "2":
                    System.out.println("预定餐桌");
                    tableReservation();
                    break;
                //显示所有菜品
                case "3":
                    System.out.println("显示所有菜品");
                    showAllMenu();
                    break;
                //点餐服务
                case "4":
                    System.out.println("点餐服务");
                    break;
                //查看账单
                case "5":
                    System.out.println("查看账单");
                    break;
                //结账
                case "6":
                    System.out.println("结账");
                    break;
                //退出满汉楼
                case "9":
                    exitMHL();
                    break;
                default:
                    System.out.println("输入有误，请重新输入");
            }
        }

    }


    /**
     * 显示用餐状态
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date 18:04
     */
    public void showDiningState() {
        //得到保存用餐状态的集合
        List<DiningTable> diningStateList = diningTableService.getAllDiningState();
        System.out.println("餐桌编号\t\t餐桌状态");
        //遍历该集合，得到每个用餐的状态，并打印其id和状态
        for (DiningTable dinging : diningStateList) {
            System.out.println(dinging.getId() + "\t\t\t" + dinging.getState());
        }
        System.out.println("==========显示完毕==========");
    }

    /**
     * 预定餐桌
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date 18:48
     */
    public void tableReservation() {
        //过五关斩六将---排除所有错误的可能性
        System.out.println("==========预定餐桌==========");
        System.out.print("请选择要预定餐桌编号(-1退出):");
        int orderId = Utility.readInt();
        if (orderId == -1) {
            System.out.println("==========取消餐桌预定==========");
            return;
        }
        //根据传入的id查询当前餐桌的状态
        DiningTable diningTable = diningTableService.diningState(orderId);
        // 如果查询的返回的值是null，则说明输入的餐位号id不存在
        if (diningTable == null) {
            System.out.println("==========当前餐桌" + orderId + "不存在==========");
            return;
        }
        //已被预定状态
        if ("已预定".equals(diningTable.getState())) {
            System.out.println("当前餐位已经被其他客人预定");
            return;
        }
        //非空闲状态
        if (!"空闲中".equals(diningTable.getState())) {
            return;
        }
        //排除所有可能性后，则当前餐位是空闲的
        char choose = Utility.readConfirmSelection();
        if (choose != 'Y') {
            //确认是否预定餐位
            return;
        }
        System.out.print("预定人名字");
        String orderName = Utility.readString(50);
        System.out.print("预定人电话");
        String orderTel = Utility.readString(50);
        boolean mark = diningTableService.updateDiningInfo(orderId, orderName, orderTel);
        if (mark) {
            System.out.println("==========预定成功==========");
        } else {
            System.out.println("==========预定失败==========");
        }
    }

    public void showAllMenu() {
        //得到Menu集合
        List<Menu> allMenuInfo = menuService.getAllMenuInfo();
        System.out.println("菜品编号\t\t菜品名\t\t类别\t\t价格");
        //遍历集合，得到每条数据，并通过对象得到其属性
        for (Menu menu : allMenuInfo) {
            System.out.println(menu.getId() + "\t\t\t" +
                                menu.getName() + "\t\t" +
                                menu.getType() + "\t\t" +
                                menu.getPrice());
        }
    }
}

点餐

0867_韩顺平Java_满汉楼点餐1_哔哩哔哩_bilibili

重点 -service 层

0868_韩顺平Java_满汉楼点餐2_哔哩哔哩_bilibili

分析：

1.判断当前桌号是否存在

2.判断当前菜品的编号是否存在

3.当点餐成功后，需要将空闲/预定的状态切换成用餐的状态

4.点餐成功后，需要将当前点餐的输入的数据做成 1 张表即账单

初始化项目

1.创建账单 bill 表

#账单流水, 考虑可以分开结账, 并考虑将来分别统计各个不同菜品的销售情况
create table bill (
	id int primary key auto_increment, #自增主键
	billId varchar(50) not null default '',#账单号可以按照自己规则生成 UUID
	menuId int not null default 0,#菜品的编号, 也可以使用外键
	nums SMALLINT not null default 0,#份数
	money double not null default 0, #金额
	diningTableId int not null default 0, #餐桌
	billDate datetime not null ,#订单日期
	state varchar(50) not null default '' # 状态 '未结账' , '已经结账', '挂单'
)charset=utf8;

2.创建 Bill-JavaBean 对象

package com.hspedu.mhl.domain;

import java.time.LocalDateTime;
import java.util.Date;

/**
 * ClassName: Bill
 * Package: com.hspedu.mhl.domain
 * Description:
 * 账单-bill-JavaBean
 *
 * @Author 王文福
 * @Create 2024/1/1 22:28
 * @Version 1.0
 * #账单流水, 考虑可以分开结账, 并考虑将来分别统计各个不同菜品的销售情况
 * create table bill (
 * id int primary key auto_increment, #自增主键
 * billId varchar(50) not null default '',#账单号可以按照自己规则生成 UUID
 * menuId int not null default 0,#菜品的编号, 也可以使用外键
 * nums SMALLINT not null default 0,#份数
 * money double not null default 0, #金额
 * diningTableId int not null default 0, #餐桌
 * billDate datetime not null ,#订单日期
 * state varchar(50) not null default '' # 状态 '未结账' , '已经结账', '挂单'
 * )charset=utf8;
 */
public class Bill {
    private Integer id; //id
    private String billId;//账单号
    private Integer menuId;//菜单编号
    private Integer nums;//份数
    private Double money;//金额
    private Integer diningTableId;//餐桌号
    private LocalDateTime billDate;//订单日期
    private String state;//结账状态

    public Bill() {
    }

    public Bill(Integer id, String billId, Integer menuId, Integer nums, Double money, Integer diningTableId, LocalDateTime billDate, String state) {
        this.id = id;
        this.billId = billId;
        this.menuId = menuId;
        this.nums = nums;
        this.money = money;
        this.diningTableId = diningTableId;
        this.billDate = billDate;
        this.state = state;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getBillId() {
        return billId;
    }

    public void setBillId(String billId) {
        this.billId = billId;
    }

    public Integer getMenuId() {
        return menuId;
    }

    public void setMenuId(Integer menuId) {
        this.menuId = menuId;
    }

    public Integer getNums() {
        return nums;
    }

    public void setNums(Integer nums) {
        this.nums = nums;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    public Integer getDiningTableId() {
        return diningTableId;
    }

    public void setDiningTableId(Integer diningTableId) {
        this.diningTableId = diningTableId;
    }

    public LocalDateTime getBillDate() {
        return billDate;
    }

    public void setBillDate(LocalDateTime billDate) {
        this.billDate = billDate;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

3.创建 BillBAO 对象-实现对表的增删改查

package com.hspedu.mhl.dao;

import com.hspedu.mhl.domain.Bill;

/**
 * ClassName: BillDAO
 * Package: com.hspedu.mhl.dao
 * Description:
 * BIllDAO继承BasicDAO，实现对账单表的增删改查
 * @Author 王文福
 * @Create 2024/1/1 22:35
 * @Version 1.0
 */
public class BillDAO extends BasicDAO<Bill> {
    //支持拓展新功能
}

4.创建 BillService 类，定义方法实现对数据的校验和创建账单表

1.生成账单，分析哪些形参，需要传入，哪些可以自行获取

2.生成账单后，更新其餐位的状态

package com.hspedu.mhl.service;

import com.hspedu.mhl.dao.BillDAO;

import java.util.UUID;

/**
 * ClassName: BillService
 * Package: com.hspedu.mhl.service
 * Description:
 * 业务层-实现对点餐服务的增删改查
 * @Author 王文福
 * @Create 2024/1/1 22:37
 * @Version 1.0
 */
public class BillService {
    //1.定义1个BillDAO实现对Bill表的增删改查
    private BillDAO billDAO = new BillDAO();
    //创建MenuService对象，调用方法，得到当前菜品的单价
    private  MenuService menuService = new MenuService();
    //得到DiningTableService对象，调用其方法修改其就餐的状态
    private  DiningTableService diningTableService = new DiningTableService();
    //2.生成账单
    //分析传入的参数
    // 账单号：通过随机生成
    // 1.菜品的id
    // 2.菜品的数量，
    //3.桌号
    public boolean orderMenu(int menuId,int nums,int diningTableId){
        //生成一个账单号UUID
        String billID= UUID.randomUUID().toString();
        //使用sql语句插入，生成账单
        //插入的参数
        //1.编号，id，默认null，自增长
        //2.账单号(通过UUID随机生成)
        //3.菜品号（形参，用户输入）
        //4.金额 = 单价*数量
        // 单价：通过MenuService层创建1个方法，传入id得到Menu对象，通过Menu对象得到菜品的单价
        //4.桌号（形参用户输入）
        //5.日期（当前日期now()）
        //6.支付状态:默认未结账
        int update = billDAO.update("insert into bill values(null,?,?,?,?,?,now(),'未结账')",
                billID,menuId,nums,menuService.getMenuById(menuId).getPrice()*nums,diningTableId);
        if(update<=0){
            return false;
        }
        //生成账单后，修改该餐位上的状态
        return diningTableService.updateDiningState(diningTableId,"就餐中");
    }
    //3.修改就餐状态
}

 //通过传入的id，和state修改其餐位的状态
    //参数1：餐位号
    //参数2：状态
    public boolean updateDiningState(int id,String state){
        int update = diningTableDAO.update
        ("update diningtable set state = ? where id = ?", state, id);
        return update>0;
    }

//通过传入的id，和state修改其餐位的状态
//参数1：餐位号
//参数2：状态
public boolean updateDiningState(int id,String state){
  int update = diningTableDAO.update("update diningtable set state = ? where id = ?",
                                     state, id);
  return update>0;
}

5.VIew 层的显示

0869_韩顺平Java_满汉楼点餐3_哔哩哔哩_bilibili

package com.hspedu.mhl.view;

import com.hspedu.mhl.domain.DiningTable;
import com.hspedu.mhl.domain.Employee;
import com.hspedu.mhl.domain.Menu;
import com.hspedu.mhl.service.BillService;
import com.hspedu.mhl.service.DiningTableService;
import com.hspedu.mhl.service.EmployeeService;
import com.hspedu.mhl.service.MenuService;
import com.hspedu.mhl.utils.Utility;

import java.sql.SQLOutput;
import java.util.List;

/**
 * ClassName: MHLView
 * Package: com.hspedu.mhl.view
 * Description:
 * 主界面-菜单
 *
 * @Author 王文福
 * @Create 2024/1/1 14:01
 * @Version 1.0
 */
public class MHLView {

    //控制是否退出主菜单
    private static boolean flag = true;
    //控制用户输入的字符长度
    private String key;
    //创建EmployeeService对象，调用登录验证的方法
    private EmployeeService employeeService = new EmployeeService();
    //创建DiningTableService，调用其用餐状态的方法
    private DiningTableService diningTableService = new DiningTableService();

    //创建MenyService，调用方法，得到所有菜品集合
    private MenuService menuService = new MenuService();
    //新建BillService对象，调用方法，点餐完成后新建账单表
    private BillService billService = new BillService();
    public void mainMenu() {
        while (flag) {
            System.out.println("==========满汉楼==========");
            System.out.println("\t\t1.登录满汉楼");
            System.out.println("\t\t2.退出满汉楼");
            System.out.print("请输入您的选择：");
            key = Utility.readString(1);
            switch (key) {
                case "1":
                    //登录功能
                    login();
                    break;
                case "2":
                    exitMHL();
                    //退出功能
                    break;
                default:
                    System.out.println("输入有误!请重新输入");
            }
        }
    }

    /**
     * 登录满汉楼
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date 14:23
     */
    public void login() {
        while (flag) {
            System.out.print("员工名：");
            String emp_Id = Utility.readString(50);
            System.out.print("密码：");
            String passWord = Utility.readString(50);
            // 调用employeeService中的getIDAndPwd方法，返回1个Employee对象
            // 如果该对象不为空，则表示登录成功
            // 得到该员工对象的姓名，并打印输出该对象的员工姓名
            Employee employee = employeeService.getIDAndPwd(emp_Id, passWord);
            if (employee != null) {
                System.out.println("==========登录成功" + "【" + employee.getName() + "】==========");
                //显示二级菜单
                secondaryMenu();
                break;
            } else {
                System.out.println("用户或者密码不正确，请重新输入");
            }
        }
    }

    /**
     * 退出满汉楼
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date 14:23
     */
    public void exitMHL() {
        this.flag = false; //控制主菜单的显示
        System.out.println("退出满汉楼系统");
    }

    /**
     * 二级菜单
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description 登录成功后显示二级菜单
     * @date 15:09
     */
    public void secondaryMenu() {
        while (flag) {
            System.out.println("==========满汉楼二级菜单==========");
            System.out.println("\t\t1.显示餐桌状态");
            System.out.println("\t\t2.预定餐桌");
            System.out.println("\t\t3.显示所有菜品");
            System.out.println("\t\t4.点餐服务");
            System.out.println("\t\t5.查看账单");
            System.out.println("\t\t6.结账");
            System.out.println("\t\t9.退出满汉楼");
            System.out.print("请输入您的选择:");
            key = Utility.readString(1);
            switch (key) {
                //显示餐桌状态
                case "1":
                    System.out.println("显示餐桌状态");
                    showDiningState();
                    break;
                //预定餐桌
                case "2":
                    System.out.println("预定餐桌");
                    tableReservation();
                    break;
                //显示所有菜品
                case "3":
                    System.out.println("显示所有菜品");
                    showAllMenu();
                    break;
                //点餐服务
                case "4":
                    System.out.println("点餐服务");
                    orderIng();
                    break;
                //查看账单
                case "5":
                    System.out.println("查看账单");
                    break;
                //结账
                case "6":
                    System.out.println("结账");
                    break;
                //退出满汉楼
                case "9":
                    exitMHL();
                    break;
                default:
                    System.out.println("输入有误，请重新输入");
            }
        }

    }


    /**
     * 显示用餐状态
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date 18:04
     */
    public void showDiningState() {
        //得到保存用餐状态的集合
        List<DiningTable> diningStateList = diningTableService.getAllDiningState();
        System.out.println("餐桌编号\t\t餐桌状态");
        //遍历该集合，得到每个用餐的状态，并打印其id和状态
        for (DiningTable dinging : diningStateList) {
            System.out.println(dinging.getId() + "\t\t\t" + dinging.getState());
        }
        System.out.println("==========显示完毕==========");
    }

    /**
     * 预定餐桌
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date 18:48
     */
    public void tableReservation() {
        //过五关斩六将---排除所有错误的可能性
        System.out.println("==========预定餐桌==========");
        System.out.print("请选择要预定餐桌编号(-1退出):");
        int orderId = Utility.readInt();
        if (orderId == -1) {
            System.out.println("==========取消餐桌预定==========");
            return;
        }
        //根据传入的id查询当前餐桌的状态
        DiningTable diningTable = diningTableService.diningState(orderId);
        // 如果查询的返回的值是null，则说明输入的餐位号id不存在
        if (diningTable == null) {
            System.out.println("==========当前餐桌" + orderId + "不存在==========");
            return;
        }
        //已被预定状态
        if ("已预定".equals(diningTable.getState())) {
            System.out.println("当前餐位已经被其他客人预定");
            return;
        }
        //非空闲状态
        if (!"空闲中".equals(diningTable.getState())) {
            return;
        }
        //排除所有可能性后，则当前餐位是空闲的
        char choose = Utility.readConfirmSelection();
        if (choose != 'Y') {
            //确认是否预定餐位
            return;
        }
        System.out.print("预定人名字");
        String orderName = Utility.readString(50);
        System.out.print("预定人电话");
        String orderTel = Utility.readString(50);
        boolean mark = diningTableService.updateDiningInfo(orderId, orderName, orderTel);
        if (mark) {
            System.out.println("==========预定成功==========");
        } else {
            System.out.println("==========预定失败==========");
        }
    }
    /** 显示所有的菜品
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date  23:47
     */
    public void showAllMenu() {
        //得到Menu集合
        List<Menu> allMenuInfo = menuService.getAllMenuInfo();
        System.out.println("菜品编号\t\t菜品名\t\t类别\t\t价格");
        //遍历集合，得到每条数据，并通过对象得到其属性
        for (Menu menu : allMenuInfo) {
            System.out.println(menu.getId() + "\t\t\t" +
                                menu.getName() + "\t\t" +
                                menu.getType() + "\t\t" +
                                menu.getPrice());
        }
    }
    /**点餐
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date  23:48
     */
    public void orderIng(){
        System.out.println("==========点餐服务==========");
        System.out.print("请选择点餐的桌号(-1退出):");
        int desksId = Utility.readInt();
        if(desksId==-1){
            System.out.println("==========取消点餐==========");
            return;
        }
        System.out.print("请选择菜品的编号(-1退出):");
        int menuId = Utility.readInt();
        if(menuId==-1){
            System.out.println("==========取消点餐==========");
            return;
        }
        System.out.print("请选择菜品的数量(-1退出):");
        int menuNums = Utility.readInt();
        if(menuNums==-1){
            System.out.println("==========取消点餐==========");
            return;
        }
        //该桌面是否存在
        DiningTable diningTable = diningTableService.diningState(desksId);
        if(diningTable==null){
            System.out.println("当前桌号不存在");
            return;
        }
        //该菜品是否存在
        Menu menu = menuService.getMenuById(menuId);
        if(menu==null){
            System.out.println("当前菜品不存在");
            return;
        }
        //确认是否点这个菜
        char choose = Utility.readConfirmSelection();
        if(choose!='Y'){
            return;
        }
        //排错后，是满足条件的
        //添加账单
        boolean mark = billService.orderMenu(menuId, menuNums, desksId);
        if(mark){
            System.out.println("==========点餐成功==========");
        }else{
            System.out.println("==========点餐失败==========");
        }

    }

}

查看账单明细

0870_韩顺平Java_满汉楼账单_哔哩哔哩_bilibili

在 billService 层创建 1 个查询的方法，返回 1 个对象的集合

在 VIew 层，调用该方法，得到该集合对象，循环遍历打印输出即可

//查看账单明细-根据桌号
    public List<Bill> showBillDetail(int diningTableId){
        List<Bill> bills = billDAO.queryMulti
		("select * from bill where diningTableId = ?", Bill.class,diningTableId);
        return  bills;
    }

package com.hspedu.mhl.view;

import com.hspedu.mhl.domain.Bill;
import com.hspedu.mhl.domain.DiningTable;
import com.hspedu.mhl.domain.Employee;
import com.hspedu.mhl.domain.Menu;
import com.hspedu.mhl.service.BillService;
import com.hspedu.mhl.service.DiningTableService;
import com.hspedu.mhl.service.EmployeeService;
import com.hspedu.mhl.service.MenuService;
import com.hspedu.mhl.utils.Utility;

import java.sql.SQLOutput;
import java.util.List;

/**
 * ClassName: MHLView
 * Package: com.hspedu.mhl.view
 * Description:
 * 主界面-菜单
 *
 * @Author 王文福
 * @Create 2024/1/1 14:01
 * @Version 1.0
 */
public class MHLView {

    //控制是否退出主菜单
    private static boolean flag = true;
    //控制用户输入的字符长度
    private String key;
    //创建EmployeeService对象，调用登录验证的方法
    private EmployeeService employeeService = new EmployeeService();
    //创建DiningTableService，调用其用餐状态的方法
    private DiningTableService diningTableService = new DiningTableService();

    //创建MenyService，调用方法，得到所有菜品集合
    private MenuService menuService = new MenuService();
    //新建BillService对象，调用方法，点餐完成后新建账单表
    private BillService billService = new BillService();

    public void mainMenu() {
        while (flag) {
            System.out.println("==========满汉楼==========");
            System.out.println("\t\t1.登录满汉楼");
            System.out.println("\t\t2.退出满汉楼");
            System.out.print("请输入您的选择：");
            key = Utility.readString(1);
            switch (key) {
                case "1":
                    //登录功能
                    login();
                    break;
                case "2":
                    exitMHL();
                    //退出功能
                    break;
                default:
                    System.out.println("输入有误!请重新输入");
            }
        }
    }

    /**
     * 登录满汉楼
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date 14:23
     */
    public void login() {
        while (flag) {
            System.out.print("员工名：");
            String emp_Id = Utility.readString(50);
            System.out.print("密码：");
            String passWord = Utility.readString(50);
            // 调用employeeService中的getIDAndPwd方法，返回1个Employee对象
            // 如果该对象不为空，则表示登录成功
            // 得到该员工对象的姓名，并打印输出该对象的员工姓名
            Employee employee = employeeService.getIDAndPwd(emp_Id, passWord);
            if (employee != null) {
                System.out.println("==========登录成功" + "【" + employee.getName() + "】==========");
                //显示二级菜单
                secondaryMenu();
                break;
            } else {
                System.out.println("用户或者密码不正确，请重新输入");
            }
        }
    }

    /**
     * 退出满汉楼
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date 14:23
     */
    public void exitMHL() {
        this.flag = false; //控制主菜单的显示
        System.out.println("退出满汉楼系统");
    }

    /**
     * 二级菜单
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description 登录成功后显示二级菜单
     * @date 15:09
     */
    public void secondaryMenu() {
        while (flag) {
            System.out.println("==========满汉楼二级菜单==========");
            System.out.println("\t\t1.显示餐桌状态");
            System.out.println("\t\t2.预定餐桌");
            System.out.println("\t\t3.显示所有菜品");
            System.out.println("\t\t4.点餐服务");
            System.out.println("\t\t5.查看账单");
            System.out.println("\t\t6.结账");
            System.out.println("\t\t9.退出满汉楼");
            System.out.print("请输入您的选择:");
            key = Utility.readString(1);
            switch (key) {
                //显示餐桌状态
                case "1":
                    System.out.println("显示餐桌状态");
                    showDiningState();
                    break;
                //预定餐桌
                case "2":
                    System.out.println("预定餐桌");
                    tableReservation();
                    break;
                //显示所有菜品
                case "3":
                    System.out.println("显示所有菜品");
                    showAllMenu();
                    break;
                //点餐服务
                case "4":
                    System.out.println("点餐服务");
                    orderIng();
                    break;
                //查看账单
                case "5":
                    System.out.println("查看账单");
                    showBillDetail();
                    break;
                //结账
                case "6":
                    System.out.println("结账");
                    break;
                //退出满汉楼
                case "9":
                    exitMHL();
                    break;
                default:
                    System.out.println("输入有误，请重新输入");
            }
        }

    }


    /**
     * 显示用餐状态
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date 18:04
     */
    public void showDiningState() {
        //得到保存用餐状态的集合
        List<DiningTable> diningStateList = diningTableService.getAllDiningState();
        System.out.println("餐桌编号\t\t餐桌状态");
        //遍历该集合，得到每个用餐的状态，并打印其id和状态
        for (DiningTable dinging : diningStateList) {
            System.out.println(dinging.getId() + "\t\t\t" + dinging.getState());
        }
        System.out.println("==========显示完毕==========");
    }

    /**
     * 预定餐桌
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date 18:48
     */
    public void tableReservation() {
        //过五关斩六将---排除所有错误的可能性
        System.out.println("==========预定餐桌==========");
        System.out.print("请选择要预定餐桌编号(-1退出):");
        int orderId = Utility.readInt();
        if (orderId == -1) {
            System.out.println("==========取消餐桌预定==========");
            return;
        }
        //根据传入的id查询当前餐桌的状态
        DiningTable diningTable = diningTableService.diningState(orderId);
        // 如果查询的返回的值是null，则说明输入的餐位号id不存在
        if (diningTable == null) {
            System.out.println("==========当前餐桌" + orderId + "不存在==========");
            return;
        }
        //已被预定状态
        if ("已预定".equals(diningTable.getState())) {
            System.out.println("当前餐位已经被其他客人预定");
            return;
        }
        //非空闲状态
        if (!"空闲中".equals(diningTable.getState())) {
            return;
        }
        //排除所有可能性后，则当前餐位是空闲的
        char choose = Utility.readConfirmSelection();
        if (choose != 'Y') {
            //确认是否预定餐位
            return;
        }
        System.out.print("预定人名字");
        String orderName = Utility.readString(50);
        System.out.print("预定人电话");
        String orderTel = Utility.readString(50);
        boolean mark = diningTableService.updateDiningInfo(orderId, orderName, orderTel);
        if (mark) {
            System.out.println("==========预定成功==========");
        } else {
            System.out.println("==========预定失败==========");
        }
    }

    /**
     * 显示所有的菜品
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date 23:47
     */
    public void showAllMenu() {
        //得到Menu集合
        List<Menu> allMenuInfo = menuService.getAllMenuInfo();
        System.out.println("菜品编号\t\t菜品名\t\t类别\t\t价格");
        //遍历集合，得到每条数据，并通过对象得到其属性
        for (Menu menu : allMenuInfo) {
            System.out.println(menu.getId() + "\t\t\t" +
                    menu.getName() + "\t\t" +
                    menu.getType() + "\t\t" +
                    menu.getPrice());
        }
    }

    /**
     * 点餐
     *
     * @param :
     * @return void
     * @author "卒迹"
     * @description TODO
     * @date 23:48
     */
    public void orderIng() {
        System.out.println("==========点餐服务==========");
        System.out.print("请选择点餐的桌号(-1退出):");
        int desksId = Utility.readInt();
        if (desksId == -1) {
            System.out.println("==========取消点餐==========");
            return;
        }
        //该桌面是否存在
        DiningTable diningTable = diningTableService.diningState(desksId);
        if (diningTable == null) {
            System.out.println("当前桌号不存在");
            return;
        }
        System.out.print("请选择菜品的编号(-1退出):");
        int menuId = Utility.readInt();
        if (menuId == -1) {
            System.out.println("==========取消点餐==========");
            return;
        }
        //该菜品是否存在
        Menu menu = menuService.getMenuById(menuId);
        if (menu == null) {
            System.out.println("当前菜品不存在");
            return;
        }
        System.out.print("请选择菜品的数量(-1退出):");
        int menuNums = Utility.readInt();
        if (menuNums == -1) {
            System.out.println("==========取消点餐==========");
            return;
        }


        //确认是否点这个菜
        char choose = Utility.readConfirmSelection();
        if (choose != 'Y') {
            return;
        }
        //排错后，是满足条件的
        //添加账单
        boolean mark = billService.orderMenu(menuId, menuNums, desksId);
        if (mark) {
            System.out.println("==========点餐成功==========");
        } else {
            System.out.println("==========点餐失败==========");
        }

    }

    //账单明细
    public void showBillDetail() {
        System.out.print("请输入查询账单的桌号(-1退出):");
        int orderID = Utility.readInt();
        //取消查询
        if(orderID==-1){
            System.out.println("==========取消查询账单==========");
            return;
        }
        //桌号不存在
        DiningTable diningTable = diningTableService.diningState(orderID);
        if(diningTable == null){
            System.out.println("当前桌号不存在");
            return;
        }
        //当前桌号处于空闲中
        if("空闲中".equals(diningTable.getState())){
            System.out.println("当前桌号处于空闲状态");
        }
        //排除其他可能后，就一定能查出账单流水
        List<Bill> bills = billService.showBillDetail(orderID);
        System.out.println("编号\t\t菜品号\t\t菜品量\t\t金额\t\t桌号\t\t日期\t\t状态");
        for (Bill bill : bills) {
            System.out.println(bill.getId() + "\t\t" +
                    bill.getMenuId() + "\t\t" +
                    bill.getNums() + "\t\t" +
                    bill.getMoney() + "\t\t" +
                    bill.getDiningTableId() + "\t\t" +
                    bill.getBillDate() + "\t\t" +
                    bill.getState());
        }
        System.out.println("==========显示完毕==========");
    }

}

结账

0872_韩顺平Java_满汉楼结账2_哔哩哔哩_bilibili

思路分析:

1.查询—— 根据餐桌号，查询是否有未结账的账单-返回 1 条即可

2. 修改——如果有未结账的账单，则支付完成后，根据餐桌号修改其支付 的状态

3. 重置餐桌表的状态

//查看某个餐桌是否有未结账的账单
    public boolean hasPayBillByDiningTableId(int diningTableId) {

        Bill bill =
                billDAO.querySingle("SELECT * FROM bill WHERE diningTableId=? 
                    AND state = '未结账' LIMIT 0, 1", Bill.class, diningTableId);
        return bill != null;
    }

    //完成结账[如果餐桌存在，并且该餐桌有未结账的账单]
    //如果成功，返回true, 失败返回 false
    public boolean payBill(int diningTableId, String payMode) {

        //如果这里使用事务的话，需要用ThreadLocal来解决 , 框架中比如mybatis 提供了事务支持
        //1. 修改bill表
        int update = billDAO.update("update bill set state=? 
                where diningTableId=? and state='未结账'", payMode, diningTableId);

        if(update <= 0) { //如果更新没有成功，则表示失败...
            return false;
        }
        //2. 修改diningTable表
        //注意：不要直接在这里操作，而应该调用DiningTableService 方法,完成更新，体现各司其职

        if(!diningTableService.updateDiningTableToFree(diningTableId, "空")) {
            return false;
        }
        return true;

    }

 //提供方法，将指定的餐桌设置为空闲状态
    public boolean updateDiningTableToFree(int id, String state) {

        int update = diningTableDAO.update("update diningTable set 
                        state=?,orderName='',orderTel='' where id=?", state, id);
        return update > 0;
    }

3.结账完成后，

1. 需要根据当前餐桌的编号，修改其餐桌的状态，

2. 将当前预定人和预定的电话重置为空-无需重置也可以

因为餐桌是空闲的，会自动重置餐桌对应行的数据

//完成结账
    public void payBill() {
        System.out.println("==============结账服务============");
        System.out.print("请选择要结账的餐桌编号(-1退出): ");
        int diningTableId = Utility.readInt();
        if (diningTableId == -1) {
            System.out.println("=============取消结账============");
            return;
        }
        //验证餐桌是否存在
        DiningTable diningTable = diningTableService.getDiningTableById(diningTableId);
        if (diningTable == null) {
            System.out.println("=============结账的餐桌不存在============");
            return;
        }
        //验证餐桌是否有需要结账的账单
        if (!billService.hasPayBillByDiningTableId(diningTableId)) {
            System.out.println("=============该餐位没有未结账账单============");
            return;
        }
        System.out.print("结账方式(现金/支付宝/微信)回车表示退出: ");
        String payMode = Utility.readString(20, "");//说明如果回车，就是返回 ""
        if ("".equals(payMode)) {
            System.out.println("=============取消结账============");
            return;
        }
        char key = Utility.readConfirmSelection();
        if (key == 'Y') { //结账

            //调用我们写的方法
            if (billService.payBill(diningTableId, payMode)) {
                System.out.println("=============完成结账============");
            } else {
                System.out.println("=============结账失败============");
            }

        } else {
            System.out.println("=============取消结账============");
        }
    }