37、Java——吃货联盟订餐系统（JDBC+MySQL+Apache DBUtils）

✅作者简介：热爱国学的Java后端开发者，修心和技术同步精进。
🍎个人主页：​​Java Fans的博客​​ 🍊个人信条：不迁怒，不贰过。小知识，大智慧。
💞当前专栏：Java案例分享专栏
✨特色专栏：国学周更-心性养成之路
🥭本文内容：轻松学习jQuery控制DOM
更多内容点击👇
      一个案例学会三层架构对数据表的增删改查

文章目录

• ​​⛳️项目需求​​
• ​​⛳️项目环境准备​​
• ​​⛳️案例覆盖的技能点​​
• ​​⛳️难点分析​​

• ​​ ❤️1、环境搭建和相关配置​​
• ​​ ❤️2、使用数据库保存Order订单以及Food菜单信息​​
• ​​ ❤️3、Dao层实现类中的增删改查方法的编写​​

• ​​⛳️项目实现思路​​

• ​​ ❤️1、 数据初始化​​
• ​​ ❤️2、 实现菜单切换​​
• ​​ ❤️3、 实现查看餐袋​​
• ​​ ❤️4、 实现我要订餐​​
• ​​ ❤️5、 实现签收订单​​
• ​​ ❤️6、 实现删除订单​​
• ​​ ❤️7、 实现我要点赞​​

• ​​⛳️代码展示​​

• ​​ ❤️1、订单信息：Order类​​
• ​​ ❤️2、菜品信息：Food类​​
• ​​ ❤️3、定义FoodDao接口​​
• ​​ ❤️4、定义FoodDaoImpl实现类​​
• ​​ ❤️5、定义OrderDao接口​​
• ​​ ❤️6、定义OrderDaoImpl实现类​​
• ​​ ❤️7、定义FoodService接口​​
• ​​ ❤️8、定义FoodServiceImpl实现类​​
• ​​ ❤️9、定义OrderService接口​​
• ​​ ❤️10、定义OrderServiceImpl实现类​​
• ​​ ❤️11、定义FoodMgr操作类​​
• ​​ ❤️12、定义OrderMgr操作类​​

⛳️项目需求

  （1）现今已经进入网络时代，人们的日常生活已经离不开网络，如网上购物、看新闻、交友等。
  （2）“只要点点手指，就能送餐上门”，网上订餐越来越受到都市年轻人的青睐。
  （3）现要求开发一个网上订餐系统，需要实现我要订餐、查看餐袋、签收订单、删除订单、我要点赞和退出系统6个功能。

⛳️项目环境准备

  （1）开发工具：MyEclipse，JDK1.7。
  （2）开发语言：Java。

⛳️案例覆盖的技能点

  （1）理解程序基本概念——程序、变量、数据类型。
  （2）会使用顺序、选择、循环、跳转语句编写程序。
  （3）了解类、对象、方法、私有变量等相关知识。
  （4）掌握数据库、JDBC、三层架构等相关知识。
  （5）掌握Druid连接池、Apache的DBUtils使用 。

⛳️难点分析

  （1）添加需要的jar包到项目中，将lib文件夹中的jar文件通过鼠标右单击选择Build Path的方式添加到你设置的eatJar文件目录里。

  （2）创建database.properties文件，用来配置注册驱动和数据库连接对象的相关数据。

driver=com.mysql.jdbc.Driver
 
url=jdbc:mysql://localhost:3306/java221804
 
username=root
 
password=huanghuang
 
initialSize=10
 
maxActive=30
 
maxIdle=5
 
maxWait=3000

  （3）添加需要的工具类DBUtils类

package cn.eat.utils;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import javax.sql.DataSource;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

public class DBUtils {

  private static DruidDataSource druidDataSource;

  static {
    Properties properties = new Properties();

    try {
      InputStream is = DBUtils.class
          .getResourceAsStream("/database.properties");
      properties.load(is);
      druidDataSource = (DruidDataSource) DruidDataSourceFactory
          .createDataSource(properties);
    } catch (IOException e) {
      e.printStackTrace();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  public static DataSource getDataSource(){
    return druidDataSource;
  }

}

  （1）创建数据表：Order表和Food表

# 创建订单表order表
CREATE TABLE IF NOT EXISTS `order`(
`oid` INT PRIMARY KEY AUTO_INCREMENT COMMENT '订单编号',
`name` VARCHAR(20) NOT NULL COMMENT '订餐人姓名',
`dishMegs` VARCHAR(20) NOT NULL COMMENT '餐品信息',
`time` INT NOT NULL COMMENT '送餐时间', 
`address` VARCHAR(30) NOT NULL COMMENT '送餐地址',
`states` INT NOT NULL COMMENT '订单状态，0表示已预订，1表示已完成',
`sumPrices` DOUBLE NOT NULL COMMENT '订单总金额'
);

# 创建Food表
CREATE TABLE IF NOT EXISTS `food`(
`fid` INT PRIMARY KEY AUTO_INCREMENT COMMENT '菜品编号',
`dishNames` VARCHAR(20) NOT NULL COMMENT '菜品名称',
`prices` DOUBLE NOT NULL COMMENT '菜品单价',
`praiseNums` INT NOT NULL COMMENT '菜品点赞数'
);

  （2）根据本项目的需求分析可知，每条订单的信息都包括订餐人姓名、选择菜品及份数、送餐时间、送餐地址、订单状态、总金额，并且会有多条订单信息，可以定义一个Order类和一个Food类，在类中将各个属性设置为私有属性，再添加这些属性的有参构造方法以及Get/Set方法，然后重写toString()方法。

  （1）首先创建QueryRunner对象。

private QueryRunner queryRunner = new QueryRunner(DBUtils.getDataSource());

  （2）增删改查方法的编写(以FoodDaoImpl类为例)

• 增删改用queryRunner.update(sql, args);方法获取。
   
  Object[] args = { food.getDishNames(),food.getPrices(),food.getPraiseNums()};
• 查一个用queryRunner.query(sql, new BeanHandler(Food.class), dishName);
   
  public Food selectOneFood(String dishName) {
  String sql=“select * from food where dishNames=?;”;
  try {
  return queryRunner.query(sql, new BeanHandler(Food.class), dishName);
  } catch (SQLException e) {
  e.printStackTrace();
  }
  return null;
  }
• 查全部用queryRunner.query(sql, new BeanListHandler(Food.class) );
   
  public List selectAllFood() {
  String sql = “SELECT * FROM ​​​food​​​;”;
  try {
  return queryRunner.query(sql, new BeanListHandler(Food.class) );
  } catch (SQLException e) {
  e.printStackTrace();
  }
  return null;
  }

⛳️项目实现思路

  （1）创建Food和Order实体类
  （2）创建数据访问层Dao层的接口和实现类
  （3）创建业务逻辑层Service层的接口和实现类
  （4）创建视图表示层View层相关操作类。

  执行程序，输出系统主菜单。用户根据显示的主菜单，输入功能编号实现菜单的显示和菜单的切换，具体要求如下：
  （1）当输入1~5时，输出相关的菜单项信息。
  （2）显示“输入0返回”。输入0，则返回主菜单，否则，退出系统，终止程序的运行，输出提示信息“谢谢使用，欢迎下次光临！”。

  遍历系统中已有的订单，并逐条显示输出，内容包括序号、订餐人姓名、订餐信息（菜品名和份数）、送餐时间、送餐地址、总金额、订单状态（已预订或已完成）。

  为用户显示系统中提供的菜品信息，获得订餐人信息，形成订单。每条订单包含如下信息。
  （1）订餐人姓名：要求用户输入。
  （2）选择菜品及份数：显示3个供选择菜品的序号、名称、单价、点赞数，提示用户输入要选择的菜品序号及份数。
  （3）送餐时间：当天10:00-20:00间整点送餐，要求用户输入10-20的整数，输入错误，重新输入。
  （4）送餐地址：要求用户输入。
  （5）状态：订单的当前状态。订单有两种状态，0为已预订状态（默认状态），1为已完成（订单已签收）。
  （6）总金额：订单总金额。总金额 = 菜品单价*份数+送餐费。其中，当单笔订单金额达到50元时，免收送餐费；否则，需交纳5元送餐费。
  各数组中相同下标的数据组成一条订单信息，因此向每个数组相同下标的位置各增加一条数据并保存。

  送餐完成后，要将用户签收订单的状态由“已预订”修改为“已完成”。业务要求如下：
  （1）如果订单的当前状态为：“已预订”且数组下标为用户输入的订单序号减1，就签收。
  （2）如果订单的当前状态为：“已完成”且数组下标为用户输入的订单序号减1，不可签收。
  控制台接收要签收的订单序号。利用for循环结构遍历全部订单，利用if选择结构判断names数组中订餐人姓名是否为null，订单状态是否为已预订且数组下标是指定订单序号减1。
  如果条件成立，该订单的状态值修改为1（即已完成）。

  选择执行“我要点赞”菜单项。
  （1）界面显示菜品序号、菜品名、单价、点赞数（如为0可不显示），提示用户输入要点赞的菜品序号。
  （2）接收要点赞的菜品序号。
  （3）praiseNums中对应菜品的点赞数加1。

⛳️代码展示

package cn.eat.entity;

public class Order {
  private int oid;
  private String name;
  private String dishMegs;
  private int times;
  private String address;
  private int states;//
  private double sumPrices;

  public Order() {
    super();
  }

  public Order(String name, String dishMegs, int times, String address,
      int states, double sumPrices) {
    super();
    this.name = name;
    this.dishMegs = dishMegs;
    this.times = times;
    this.address = address;
    this.states = states;
    this.sumPrices = sumPrices;
  }

  public Order(int oid, String name, String dishMegs, int times,
      String address, int states, double sumPrices) {
    super();
    this.oid = oid;
    this.name = name;
    this.dishMegs = dishMegs;
    this.times = times;
    this.address = address;
    this.states = states;
    this.sumPrices = sumPrices;
  }


  public int getOid() {
    return oid;
  }

  public void setOid(int oid) {
    this.oid = oid;
  }

  public String getName() {
    return name;
  }

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

  public String getDishMegs() {
    return dishMegs;
  }

  public void setDishMegs(String dishMegs) {
    this.dishMegs = dishMegs;
  }

  public int getTimes() {
    return times;
  }

  public void setTimes(int times) {
    this.times = times;
  }

  public String getAddress() {
    return address;
  }

  public void setAddress(String address) {
    this.address = address;
  }

  public int getStates() {
    return states;
  }

  public void setStates(int states) {
    this.states = states;
  }

  public double getSumPrices() {
    return sumPrices;
  }

  public void setSumPrices(double sumPrices) {
    this.sumPrices = sumPrices;
  }

  @Override
  public String toString() {
    return "Order [oid=" + oid + ", name=" + name + ", dishMegs="
        + dishMegs + ", times=" + times + ", address=" + address
        + ", states=" + states + ", sumPrices=" + sumPrices + "]";
  }
  
  

}

package cn.eat.entity;

public class Food {

  private String dishNames;
  private double prices;
  private int praiseNums;

  public Food() {
    super();
  }

  public Food(String dishNames, double prices, int praiseNums) {
    super();
    this.dishNames = dishNames;
    this.prices = prices;
    this.praiseNums = praiseNums;
  }

  public String getDishNames() {
    return dishNames;
  }

  public void setDishNames(String dishNames) {
    this.dishNames = dishNames;
  }

  public double getPrices() {
    return prices;
  }

  public void setPrices(double prices) {
    this.prices = prices;
  }

  public int getPraiseNums() {
    return praiseNums;
  }

  public void setPraiseNums(int praiseNums) {
    this.praiseNums = praiseNums;
  }

  @Override
  public String toString() {
    return "Food [dishNames=" + dishNames + ", prices=" + prices
        + ", praiseNums=" + praiseNums + "]";
  }
  
}

package cn.eat.dao;

import java.util.List;

import cn.eat.entity.Food;


public interface FoodDao {
  //增
  int insertFood(Food food);
  
  //删
  int deleteFood(String dishName);
  
  //改
  int updateFood(Food food);
  
  //查一个
  Food selectOneFood(String dishName);
  
  //查全部
  List<Food> selectAllFood();
}

package cn.eat.dao.impl;

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

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import cn.eat.dao.FoodDao;
import cn.eat.entity.Food;
import cn.eat.entity.Order;
import cn.eat.utils.DBUtils;

public class FoodDaoImpl implements FoodDao {
  private QueryRunner queryRunner = new QueryRunner(DBUtils.getDataSource());
  @Override
  public int insertFood(Food food) {
    String sql = "INSERT INTO `food`(`dishNames`,`prices`,`praiseNums`) VALUES(?,?,?);";
    Object[] args = { food.getDishNames(),food.getPrices(),food.getPraiseNums()};

    try {
      return queryRunner.update(sql, args);
    } catch (SQLException e) {
      e.printStackTrace();
    }
    return 0;
  }

  @Override
  public int deleteFood(String dishName) {
    String sql="delete from food where dishNames=?;";
    try {
      return queryRunner.update(sql,dishName);
    } catch (SQLException e) {
      e.printStackTrace();
    }
    return 0;
  }

  @Override
  public int updateFood(Food food) {
    String sql="update food set prices=?,praiseNums=? where dishNames=?;";
    Object[] args={food.getPrices(),food.getPraiseNums(),food.getDishNames()};
    try {
      return queryRunner.update(sql, args);
    } catch (SQLException e) {
      e.printStackTrace();
    }
    return 0;
  }

  @Override
  public Food selectOneFood(String dishName) {
    String sql="select * from food where dishNames=?;";
    try {
      return queryRunner.query(sql, new BeanHandler<Food>(Food.class), dishName);
    } catch (SQLException e) {
      e.printStackTrace();
    }
    return null;
  }

  @Override
  public List<Food> selectAllFood() {
    String sql = "SELECT * FROM `food`;";
    try {
      return queryRunner.query(sql, new BeanListHandler<Food>(Food.class) );
    } catch (SQLException e) {
      e.printStackTrace();
    }   
    return null;
  }
}

package cn.eat.dao;

import java.util.List;

import cn.eat.entity.Order;

public interface OrderDao {
  //增
  int insert(Order order);
  
  //删
  int delete(int oid);
  
  //改
  int update(Order order);
  
  //查一个
  Order selectOne(int oid);
  
  //查全部
  List<Order> selectAll();
}

package cn.eat.dao.impl;

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

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import cn.eat.dao.OrderDao;
import cn.eat.entity.Order;
import cn.eat.utils.DBUtils;

public class OrderDaoImpl implements OrderDao {
  private QueryRunner queryRunner = new QueryRunner(DBUtils.getDataSource());

  //增
  @Override
  public int insert(Order order) {
    String sql = "INSERT INTO `order`(`name`,`dishMegs`,`time`,`address`,`states`,`sumPrices`) VALUES(?,?,?,?,?,?);";
    Object[] args = { order.getName(), order.getDishMegs(),
        order.getTimes(), order.getAddress(), order.getStates(),
        order.getSumPrices() };

    try {
      return queryRunner.update(sql, args);
    } catch (SQLException e) {
      e.printStackTrace();
    }
    return 0;
  }

  //删
  @Override
  public int delete(int oid) {
    String sql = "DELETE FROM `order` WHERE `oid`=?;";
    try {
      return queryRunner.update(sql, oid);
    } catch (SQLException e) {
      e.printStackTrace();
    }
    return 0;
  }

  //改
  @Override
  public int update(Order order) {
    String sql = "UPDATE `order` SET `name` = ?,`dishMegs`=?,`time`=?,`address`=?,`states`=?,`sumPrices`=? WHERE `oid`=?;";
    Object[] args = { order.getName(), order.getDishMegs(),
        order.getTimes(), order.getAddress(), order.getStates(),
        order.getSumPrices(), order.getOid() };
    try {
      return queryRunner.update(sql, args);
    } catch (SQLException e) {
      e.printStackTrace();
    }
    return 0;
  }

  //查一个
  @Override
  public Order selectOne(int oid) {
    String sql = "SELECT * FROM `order` WHERE `oid` = ?";
    try {
      return queryRunner.query(sql,new BeanHandler<Order>(Order.class),oid);
    } catch (SQLException e) {
      e.printStackTrace();
    }
    return null;
  }

  //查全部
  @Override
  public List<Order> selectAll() {
    String sql = "SELECT * FROM `order`;";
    try {
      return queryRunner.query(sql, new BeanListHandler<Order>(Order.class) );
    } catch (SQLException e) {
      e.printStackTrace();
    }
    
    return null;
  }
}

package cn.eat.service;

import java.util.List;

import cn.eat.entity.Food;

//对菜品进行增删改查的业务
public interface FoodService {

  //添加
  int addFood(Food food);
  
  //删除
  int deleteFood(String dishName);
  
  //修改
  int updateFood(Food food);
  
  //查一个
  Food selectFoodByFid(String dishName);
  
  //查全部
  List<Food> selectAllFood();
}

package cn.eat.service.Impl;

import java.util.List;

import cn.eat.dao.FoodDao;
import cn.eat.dao.impl.FoodDaoImpl;
import cn.eat.entity.Food;
import cn.eat.service.FoodService;

public class FoodServiceImpl implements FoodService {

  //创建FoodDaoImpl对象；
  FoodDao foodDao=new FoodDaoImpl();
  
  @Override
  public int addFood(Food food) {
    //判断表中是否存在将要添加的菜品
    if(food!=null){
      Food food1=foodDao.selectOneFood(food.getDishNames());
      if(food1!=null){
        System.out.println("菜品已存在，不能添加！");
      }else{
        System.out.println("添加成功！");
        return foodDao.insertFood(food);
      }
    }
    return 0;
  }

  @Override
  public int deleteFood(String dishName) {
    //判断表中是否存在将要删除的菜品
    Food food1=foodDao.selectOneFood(dishName);
    if(food1!=null){
      System.out.println("删除成功！");
      return foodDao.deleteFood(dishName);
    }else{
      System.out.println("菜品不存在，无法删除！");
    }
    return 0;
  }

  @Override
  public int updateFood(Food food) {
    //判断表中是否存在将要修改的菜品
    Food food1=foodDao.selectOneFood(food.getDishNames());
    if(food1!=null){
      System.out.println("修改成功！");
      return foodDao.updateFood(food);
    }else{
      System.out.println("菜品不存在，不能修改！");
    }
    return 0;
  }

  @Override
  public Food selectFoodByFid(String dishName) {
    return foodDao.selectOneFood(dishName);
  }

  @Override
  public List<Food> selectAllFood() {
    List<Food> listFoods= foodDao.selectAllFood();
    return listFoods;
  }
}

package cn.eat.service;

import java.util.List;

import cn.eat.entity.Order;

public interface OrderService {
  
  //增
  int insertOrder(Order order);
  
  //删
  int delOrder(int oid);
  
  //改
  int updateOrder(Order order);
  
  //查一个
  Order selectOneOrder(int oid);
  
  //查全部
  List<Order> selectAllOrder();
  
}

package cn.eat.service.Impl;

import java.util.List;

import cn.eat.dao.OrderDao;
import cn.eat.dao.impl.OrderDaoImpl;
import cn.eat.entity.Order;
import cn.eat.service.OrderService;

public class OrderServiceImpl implements OrderService {

  OrderDao orderDao=new OrderDaoImpl();
  @Override
  public int insertOrder(Order order) {
    System.out.println("添加成功！");
    return orderDao.insert(order);
  }

  @Override
  public int delOrder(int oid) {
    Order order=orderDao.selectOne(oid);
    if(order==null){
      System.out.println("您要删除的订单信息不存在，无法删除！");
    }else if(order.getStates()==0){
      System.out.println("该订单仍在预定状态，不能删除！");
    }else{
      System.out.println("删除成功！");
      return orderDao.delete(oid);
    }
    return 0;
  }

  @Override
  public int updateOrder(Order order) {
    if(order==null){
      System.out.println("你要签收的订单信息不存在，无法签收！");
    }else if(order.getStates()==1){
      System.out.println("你选择的订单已完成，不能再次签收订单！");
    }else{
      System.out.println("签收成功！");
      order.setStates(1);
      return orderDao.update(order);
    }
    return 0;
  }

  @Override
  public Order selectOneOrder(int oid) {
    return orderDao.selectOne(oid);
  }

  @Override
  public List<Order> selectAllOrder() {
    List<Order> listOrders=orderDao.selectAll();
    
    return listOrders;
  }
}

package cn.eat.view;

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

import cn.eat.entity.Food;
import cn.eat.service.FoodService;
import cn.eat.service.Impl.FoodServiceImpl;

public class FoodMgr {
  FoodService foodS = new FoodServiceImpl();
  Scanner sc = new Scanner(System.in);

  // 定义一个欢迎菜单方法
  public void showMenu() {
    System.out.println(" ————————欢迎使用菜品管理系统————————");
    System.out.println("-------------------------");
    System.out.println("1.添加菜品");
    System.out.println("2.删除菜品");
    System.out.println("3.修改菜品");
    System.out.println("4.查看菜单");
    System.out.println("5.退出系统");
    System.out.println("-------------------------");
  }

  // 1、添加菜品方法
  public void addFood() {
    System.out.println("请输入菜品名称：");
    String foodName = sc.next();
    System.out.println("请输入菜品价格：");
    double foodPrice = sc.nextDouble();
    Food food = new Food(foodName, foodPrice, 0);
    foodS.addFood(food);
  }
  
  // 2、删除菜品方法
  public void delFood(){
    System.out.println("请输入需要删除的菜品名称：");
    String foodName=sc.next();
    foodS.deleteFood(foodName);
  }
  
  // 3、修改菜品方法
  public void updateFood() {
    System.out.println("请输入需要修改的菜品名称：");
    String foodName=sc.next();
    System.out.println("请输入需要修改的菜品价格：");
    double foodPrice=sc.nextDouble();
    System.out.println("请输入需要修改菜品点赞数：");
    int foodPraise=sc.nextInt();
    Food food=new Food(foodName, foodPrice, foodPraise);
    foodS.updateFood(food);
  }
  
  // 4、查看菜单方法
  public List<Food> showFood(){
    List<Food> listFoods=foodS.selectAllFood();
    System.out.println("序号\t名称\t\t单价\t点赞数");
    int i=1;
    for (Food food : listFoods) {
      System.out.println((i) + "\t" + food.getDishNames()
          + "\t\t" + food.getPrices() + "\t"
          + food.getPraiseNums());
      i++;
    }
    return listFoods;


  }

  // 定义方法实现菜品管理系统
  public void startFood() {
    // 默认初始值
    boolean flag = true;
    // 循环初始值
    int num = -1;
    do {
      // 首先显示菜单管理系统
      showMenu();
      System.out.println("请输入菜单操作项：");
      int choose = sc.nextInt();
      switch (choose) {
      case 1:
        // 添加菜品
        addFood();
        break;
      case 2:
        // 删除菜品
        delFood();
        break;
      case 3:
        // 修改菜品
        updateFood();
        break;
      case 4:
        // 查看菜品
        showFood();
        break;
      case 5:
        // 退出系统
        flag = false;
        break;
      default:
        flag = false;
        break;
      }

      if (flag) {
        System.out.println("输入0返回：");
        num = sc.nextInt();
      } else {

        break;
      }
    } while (num == 0);
    System.out.println("谢谢使用，欢迎下次光临");
  }

  public static void main(String[] args) {
    FoodMgr fm = new FoodMgr();
    fm.startFood();

  }
}

package cn.eat.view;

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

import cn.eat.entity.Food;
import cn.eat.entity.Order;
import cn.eat.service.FoodService;
import cn.eat.service.OrderService;
import cn.eat.service.Impl.FoodServiceImpl;
import cn.eat.service.Impl.OrderServiceImpl;

public class OrderMgr {

  OrderService od = new OrderServiceImpl();
  FoodService foodS = new FoodServiceImpl();
  Scanner input = new Scanner(System.in);
  FoodMgr fm = new FoodMgr();

  // 定义一个订餐使用系统
  public static void showSystem() {
    // 输出欢迎菜单
    System.out.println("欢迎使用吃货联盟订餐系统");
    System.out.println("-------------------------");
    System.out.println("1.我要订餐");
    System.out.println("2.查看餐带");
    System.out.println("3.签收订单");
    System.out.println("4.删除订单");
    System.out.println("5.我要点赞");
    System.out.println("6.退出系统");
    System.out.println("-------------------------");
  }

  // 定义方法实现订餐管理系统
  public void startFood() {
    // 默认初始值
    boolean flag = true;
    // 循环初始值
    int num = -1;
    do {
      // 首先显示菜单管理系统
      showSystem();
      System.out.println("请输入订单操作项：");
      int choose = input.nextInt();
      switch (choose) {
      case 1:
        // 我要订餐
        addOrder();
        break;
      case 2:
        // 查看餐带
        showOrder();
        break;
      case 3:
        // 签收订单
        updateOrder();
        break;
      case 4:
        // 删除订单
        delOrder();
        break;
      case 5:
        // 我要点赞
        orderLike();
        break;
      case 6:
        // 退出系统
        flag = false;
        break;
      default:
        flag = false;
        break;
      }

      if (flag) {
        System.out.println("输入0返回：");
        num = input.nextInt();
      } else {

        break;
      }
    } while (num == 0);
    System.out.println("谢谢使用，欢迎下次光临");
  }

  // 1.我要订餐
  public void addOrder() {
    System.out.println("--新增订单--");
    // (1)订餐人姓名
    System.out.println("请输入订餐人姓名：");
    String orderName = input.next();
    // orders[i].setName(orderName);

    // (2)选择菜品及份数
    List<Food> foods = fm.showFood();
    System.out.println("请选择菜品序号：");
    int caiNum = input.nextInt();
    System.out.println("选择份数：");
    int fenNum = input.nextInt();
    String dishFen = foods.get(caiNum - 1).getDishNames() + " " + fenNum
        + "份";

    // (3)送餐时间
    System.out.println("请选择送餐时间（10:00-20:00整点送餐）：");
    int orderTime = input.nextInt();
    while (orderTime < 10 || orderTime > 20) {
      System.out.println("输入错误，请重新输入：");
      orderTime = input.nextInt();
      // orders[i].setTime(input.nextInt());
    }

    // (4)送餐地址
    System.out.println("请输入送餐地址：");
    String orderAddress = input.next();
    // orders[i].setAddress(input.next());

    // (5)状态（新增时，订单状态均为默认状态0）
    // orders[i].setState(0);

    // (6)总金额 =
    // 菜品单价*份数+送餐费。其中，当单笔订单金额达到50元时，免收送餐费；否则，需交纳5元送餐费。
    double caiPrices = foods.get(caiNum - 1).getPrices() * fenNum;
    if (caiPrices < 50) {
      caiPrices = caiPrices + 5;
      // orders[i].setSumPrices(caiPrices);
    }

    // 将订餐数据插入到数据库
    Order order = new Order(orderName, dishFen, orderTime, orderAddress, 0,
        caiPrices);
    od.insertOrder(order);
  }

  // 2.查看餐带
  public void showOrder() {
    List<Order> orders = od.selectAllOrder();
    System.out.println("--查看餐袋--");
    System.out
        .println("序号\t\t订餐人\t\t餐品信息\t\t\t送餐时间\t\t送餐地址\t\t\t总金额\t\t订单状态");
    for (int i = 0; i < orders.size(); i++) {
      if (orders.get(i) != null) {
        String time = orders.get(i).getTimes() + "点";
        String sumPrice = orders.get(i).getSumPrices() + "元";
        String state;
        if (orders.get(i).getStates() == 0) {
          state = "已预订";
        } else {
          state = "已完成";
        }
        System.out.println((i + 1) + "\t\t" + orders.get(i).getName()
            + "\t\t" + orders.get(i).getDishMegs() + "\t\t" + time
            + "\t\t" + orders.get(i).getAddress() + "\t\t"
            + sumPrice + "\t\t" + state);
      }
    }
  }

  // 3.签收订单
  public void updateOrder() {
    System.out.println("--签收订单--");
    System.out.println("请选择需要签收的订单序号：");
    int orderNum = input.nextInt();
    Order order = od.selectOneOrder(orderNum);
    od.updateOrder(order);
  }

  // 4.删除订单
  public void delOrder() {
    System.out.println("--删除订单--");
    System.out.println("请选择需要删除的订单序号：");
    int orderNum = input.nextInt();
    od.delOrder(orderNum);
  }

  // 5.我要点赞
  public void orderLike() {
    System.out.println("--我要点赞--");
    List<Food> foods = fm.showFood();
    System.out.println("请选择点赞的菜品序号：");
    int caiZanNum = input.nextInt();
    for (int j = 0; j < foods.size(); j++) {
      if (caiZanNum == j + 1) {
        foods.get(j).setPraiseNums(foods.get(j).getPraiseNums() + 1);
        Food food = new Food(foods.get(j).getDishNames(), foods.get(j)
            .getPrices(), foods.get(j).getPraiseNums());
        foodS.updateFood(food);
      }
    }
    System.out.println("点赞后的菜品展示：");
    System.out.println("序号\t名称\t\t单价\t点赞数");
    for (int j = 0; j < foods.size(); j++) {
      System.out.println((j + 1) + "\t" + foods.get(j).getDishNames()
          + "\t\t" + foods.get(j).getPrices() + "\t"
          + foods.get(j).getPraiseNums());
    }
  }

  public static void main(String[] args) {
    OrderMgr om = new OrderMgr();
    om.startFood();
  }

}

Java系列知识，点击​​关注博主​​，博主带你零基础学习Java知识。与此同时，对于日常生活有困扰的朋友，欢迎阅读我的第四栏目：​​《国学周更—心性养成之路》​​，学习技术的同时，我们也注重了心性的养成。