吃货联盟项目用Apache DBUtils工具改写

最基础的是创建一个数据库，用来存储要用到的数据

#创建数据库 CREATE DATABASE IF NOT EXISTS ChiHuoSystem;

#订单序号（id）、订餐人姓名（name）、菜品信息（dishMegs）、送餐时间（time）、 #送餐地址（addresses）、订单状态（states）、订单总价格（sumPrices） #创建Order表，将id设置为自增长，其他均设置为非空

CREATE TABLE IF NOT EXISTS order

( id INT PRIMARY KEY AUTO_INCREMENT,

name VARCHAR(10) NOT NULL,

dishMegs VARCHAR(20) NOT NULL,

fen INT NOT NULL,

time INT,

addresses VARCHAR(30) NOT NULL,

states INT NOT NULL COMMENT '只能填写1(已完成)或0(未完成)',

sumPrices DOUBLE NOT NULL );

#菜品序号（cid）、菜品名称（dishNames）、菜品单价（prices）、菜品点赞数（praiseNum） #初始化两条订单信息，向表中插入，使用不带字段名的插入方式，需和表中字段名顺序一致 INSERT INTO order VALUES(1,'张三','红烧肉',2,12,'北大青鸟',1,60);

INSERT INTO order VALUES(2,'李四','鱼香肉丝',2,18,'怡园小区',1,56);

#创建Food表，将cid设置为自增长，其他均设置为非空order

CREATE TABLE IF NOT EXISTS food

( cid INT PRIMARY KEY AUTO_INCREMENT,

dishNames VARCHAR(20) NOT NULL,

prices DOUBLE NOT NULL,

praiseNum INT NOT NULL COMMENT '点赞数' );

#罗列三个菜的菜品信息，菜的名称，单价，点赞数,插入表中，使用不带字段名的插入方式(多条一起插入)，需和表中字段名顺序一致

INSERT INTO food VALUES(1,'红烧肉',30,70);

INSERT INTO food VALUES(2,'西红柿炒蛋',18,99);

INSERT INTO food VALUES(3,'鱼香肉丝',28,66);

INSERT INTO food VALUES(4,'特色地锅鸡',79,289);

之后就是Java代码的编写部分：

首先创建一个项目chlm-ApacheDBUtils，并在新建一个lib目录导入三个jar包commons-dbutils-1.7 (1).jar，druid-1.2.8 (1).jar，mysql-connector-j-8.0.33.jar。并将三个jar包添加为库。

第二步：在默认文件src文件下创建一个包，包名自定义，再创建一个db.properties文件，里面是关于数据库访问文件的配置。然后在包里创建5个包，分别为Dao包(Data Access Object的缩写，代表数据访问对象层，主要负责与数据库进行交互，封装了与数据库的连接、查询、更新等操作。)，entity包(实体层，放置一个个实体类，这些类通常对应于数据库中的表，包含了表中的字段和相关的getter和setter方法。)，service包(业务逻辑层，封装了数据库底层操作的更高级的操作，将Dao层和Entity层整合起来，进行再次封装，封装成一个方法，以便于业务逻辑的实现)，utils包(工具类层，包含一些常用的工具方法，如字符串处理、日期处理、文件操作等，用于辅助开发人员快速完成开发任务。 )，view包(表示层，存放与用户界面相关的类或组件，有时也用于存放DTO（Data Transfer Object）或VO（Value Object），用于数据的传输和展示,这里一般用来作为测试类)。

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/chihuosystem
username=root
password=CSY123
​
# ???????????????这里粘贴过去就是会变乱码，不过是注释无所谓
initialSize=10
​
#?????
maxActive=30
​
#??????
maxIdle=5
​
#?????????????
maxWait=3000

我这里用的数据库是8.0版本的，所以数据库注册驱动是com.mysql.cj.jdbc.Driver，地址是本地地址加数据库，mysql一般默认3306.不同版本不一样，同时用户名密码也是自己设置的。

然后就是要先创建第二个包，实体类的包

分别根据数据库提供的数据创建出两个实体类，分别为Food和Order类

public class Food {
    private int cid;
    private String dishNames;
    private double prices;
    private int praiseNum;
​
    public Food() {
    }
    //不包含cid的构造方法
​
    public Food(String dishNames, double prices, int praiseNum) {
        this.dishNames = dishNames;
        this.prices = prices;
        this.praiseNum = praiseNum;
    }
​
​
//包含cid的构造方法
​
​
    public Food(int cid, String dishNames, double prices, int praiseNum) {
        this.cid = cid;
        this.dishNames = dishNames;
        this.prices = prices;
        this.praiseNum = praiseNum;
    }
    //只含cid和的praiseNum的构造方法
​
​
    public Food(int cid, int praiseNum) {
        this.cid = cid;
        this.praiseNum = praiseNum;
    }
​
    public int getCid() {
        return cid;
    }
​
    public void setCid(int cid) {
        this.cid = cid;
    }
​
    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 getPraiseNum() {
        return praiseNum;
    }
​
    public void setPraiseNum(int praiseNum) {
        this.praiseNum = praiseNum;
    }
​
    @Override
    public String toString() {
        return "Food{" +
                "cid=" + cid +
                ", dishNames='" + dishNames + '\'' +
                ", prices=" + prices +
                ", praiseNum=" + praiseNum +
                '}';
    }
}

public class Order {
    private int id;
    private String name;
    private String dishMegs;
    private int fen;
    private int time;
    private String addresses;
    private int states;
    private double sumPrices;
    //定义构造方法
​
​
    public Order() {
    }
​
    //不包含id的构造方法
    public Order(String name, String dishMegs, int fen, int time, String addresses, int states, double sumPrices) {
        this.name = name;
        this.dishMegs = dishMegs;
        this.fen = fen;
        this.time = time;
        this.addresses = addresses;
        this.states = states;
        this.sumPrices = sumPrices;
    }
​
    //包含id的构造方法
​
​
    public Order(int id, String name, String dishMegs, int fen, int time, String addresses, int states, double sumPrices) {
        this.id = id;
        this.name = name;
        this.dishMegs = dishMegs;
        this.fen = fen;
        this.time = time;
        this.addresses = addresses;
        this.states = states;
        this.sumPrices = sumPrices;
    }
​
    public int getId() {
        return id;
    }
​
    public void setId(int id) {
        this.id = id;
    }
​
    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 getFen() {
        return fen;
    }
​
    public void setFen(int fen) {
        this.fen = fen;
    }
​
    public int getTime() {
        return time;
    }
​
    public void setTime(int time) {
        this.time = time;
    }
​
    public String getAddresses() {
        return addresses;
    }
​
    public void setAddresses(String addresses) {
        this.addresses = addresses;
    }
​
    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{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", dishMegs='" + dishMegs + '\'' +
                ", fen=" + fen +
                ", time=" + time +
                ", addresses='" + addresses + '\'' +
                ", states=" + states +
                ", sumPrices=" + sumPrices +
                '}';
    }
}

这里注意生成构造方法的时候要生成带主键和不带主键的。

然后就是创建Dao包，分别根据实体类创建两个daoimpl包，分别对应两个接口的实现类，也就是编写2个实体类的接口，并将接口的实现类定义出来。FoodDaoImpl.java。OrderDaoImpl.java。FoodDao.java。OrderDao.java。

public interface FoodDao {
    // 定义更新点赞数的方法
    int update(Food food);
    // 定义查询单个食品的方法
    Food selectOneFood(int cid);
    // 定义查询所有食品的方法
    List<Food> selectAllFood();
}

public interface OrderDao {
    // 定义添加订单的方法
    int insert(Order order);
    // 定义删除订单的方法
    int delete(int id);
    // 定义修改订单的方法
    int update(Order order);
    // 定义查询单个订单的方法
    Order selectOneOrder(int id);
    // 定义查询所有订单的方法
    List<Order> selectAllOrder();
}

public class FoodDaoImpl implements FoodDao {
    // 创建QueryRunner对象，需要传递数据源
    private QueryRunner queryRunner = new QueryRunner(DBUtils.getDataSource());
​
    // 实现更新点赞数的方法
    @Override
    public int update(Food food) {
        // 准备SQL更新语句
        String sql = "update `food` set praiseNum=? where cid=?";
        // 准备参数数组
        Object[] args = {food.getPraiseNum(), food.getCid()};
        try {
            // 执行更新操作，返回受影响的行数
            return queryRunner.update(sql, args);
        } catch (SQLException e) {
            // 异常处理，抛出运行时异常
            throw new RuntimeException(e);
        }
    }
​
    // 实现查询单个食品的方法
    @Override
    public Food selectOneFood(int cid) {
        // 创建BeanHandler对象，用于处理查询结果
        BeanHandler<Food> beanHandler = new BeanHandler<Food>(Food.class);
        // 准备SQL查询语句
        String sql = "select * from `food` where cid=?";
        try {
            // 执行查询操作，返回单个Food对象
            return queryRunner.query(sql, beanHandler, cid);
        } catch (SQLException e) {
            // 异常处理，抛出运行时异常
            throw new RuntimeException(e);
        }
    }
​
    // 实现查询所有食品的方法
    @Override
    public List<Food> selectAllFood() {
        // 创建BeanListHandler对象，用于处理查询结果
        BeanListHandler<Food> beanListHandler = new BeanListHandler<Food>(Food.class);
        // 准备SQL查询语句
        String sql = "select * from `food`";
        try {
            // 执行查询操作，返回Food对象列表
            return queryRunner.query(sql, beanListHandler);
        } catch (SQLException e) {
            // 异常处理，抛出运行时异常
            throw new RuntimeException(e);
        }
    }
}
​
    

public class OrderDaoImpl implements OrderDao {
    //定义一个私有对象，方便后面的方法的调用,且传递一个数据源对象
    private QueryRunner queryRunner=new QueryRunner(DBUtils.getDataSource());
    //增删改调用update的方法，查询调用Query方法
​
    //方法一 添加订单数据
    @Override
    public int insert(Order order) {
        //准备sql语句,id是自增长
        String sql="insert into `Order` (name,dishMegs,fen,time,addresses,states,sumPrices) values(?,?,?,?,?,?,?)";
        //准备一个可变数组,对占位符进行赋值，占位符的赋值来源于Order对象
        Object[] args={order.getName(),order.getDishMegs(),order.getFen(),order.getTime(),order.getAddresses(),order.getStates(),order.getSumPrices()};
​
        try {
            //传入一个sql语句和一个可变数组,并抛出异常,添加受影响的是行数
            int result=queryRunner.update(sql,args);
            return  result;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
​
    @Override
    public int delete(int id) {
        //准备sql语句,id是自增长
        String sql="delete from `order` where id=?";
        //删除数据不需要对象，是根据id进行删除的，故不需要可变数组
        try {
            //使用queryRunner调用update方法，返回值是受影响的行数
            int result=queryRunner.update(sql,id);
            //返回结果
            return  result;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
​
    @Override
    public int update(Order order) {
        //准备sql语句,id是自增长
        String sql="update `order` set states=? where id=?";
       //准备一个可变数组
        Object [] args={order.getStates(),order.getId()};
        try {
            //使用queryRunner调用update方法，返回值是受影响的行数
             return  queryRunner.update(sql,args);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
​
    @Override
    public Order selectOneOrder(int id) {
        //创建beanHandler泛型集合对象
        BeanHandler<Order> beanHandler=new BeanHandler<>(Order.class);
        //使用queryRunner调用query方法，返回值是一个结果集，即Order对象
        //准备sql语句
        String sql="select * from `order` where id=?";
        //查询单个不需要准备可变数组，直接使用id查询，返回的是一个对象Order
        try {
            return  queryRunner.query(sql,beanHandler,id);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
​
    }
​
    @Override
    public List<Order> selectAllOrder() {
        //创建beanListHandler泛型集合对象
        BeanListHandler<Order> beanListHandler=new BeanListHandler<Order>(Order.class);
        //准备一个sql语句
        String sql="select * from `Order`";
        //查询无占位符，故不需要准备可变数组
        //使用queryRunner调用query方法，返回值是一个结果集，即多个Order对象，可组装成为一个集合
​
        try {
            return  queryRunner.query(sql,beanListHandler);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

之后再创建一个服务类service，同样是创建2个2个service接口，以及2个实现类。分别为FoodServiceImpl.java OrderServiceImpl.java FoodService.java OrderService.java。这个包是业务逻辑层，封装了数据库底层操作的更高级的操作，将Dao层和Entity层整合起来，进行再次封装，封装成一个方法，以便于业务逻辑的实现

public class FoodServiceImpl implements FoodService {
    //实现规范服务类方法的接口
    //定义FoodDao对象，指向其实现类，方便调用方法
    FoodDao foodDao=new FoodDaoImpl();
    //创建scanner对象
    Scanner scanner=new Scanner(System.in);
    Food food=new Food();
    @Override
    public int updateFood() {
        System.out.println("请输入你要点赞的菜品序号");
        int id=scanner.nextInt();
        //根据用户输入的id，调用查询方法查询菜品存在与否
        Food food1=foodDao.selectOneFood(id);
        if (food1==null){
            System.out.println("对不起，你输入的菜品不存在，无法点赞");
        }else {
            food1.setPraiseNum(food1.getPraiseNum()+1);
            //存在则调用修改方法
            int result= foodDao.update(food1);
            return result;
        }
        return 0;
    }
​
    @Override
    public Food selectOneFood(int cid) {
        Food food1=foodDao.selectOneFood(food.getCid());
        return food1;
    }
​
    @Override
    public List<Food> selectAllFood() {
        List<Food> foodList=foodDao.selectAllFood();
        return null;
    }
​
​
}

public class OrderServiceImpl implements OrderService {
    //实现规范服务类方法的接口
    //创建OrderDao对象，指向其实现类，方便调用其中的方法
    OrderDao orderDao=new OrderDaoImpl();
    //创建FoodDao对象，指向其实现类，方便调用其中的方法
    FoodDao foodDao=new FoodDaoImpl();
​
    //创建order的对象
    Order order=new Order();
    //因为订餐等数据来源于用户从键盘输入，创建Scanner对象
    Scanner scanner=new Scanner(System.in);
    //添加订单，首先需要查看系统是否有此订单
    @Override                                                                                                                                     
    public int add() {
            //使用foodDao调用查询所有方法，返回一个food集合对象
            List<Food> foodList=foodDao.selectAllFood();
            System.out.println("请输入订餐人姓名：");
            String name =scanner.next();
            System.out.println("请选择你要点的菜（输入序号）：");
            int dishChoose=scanner.nextInt();
​
            Food food = foodDao.selectOneFood(dishChoose);
​
            //通过food对象获取用户点的什么菜，并定义变量接收
            String dishNames=food.getDishNames();
            //通过food对象获取该菜品的价格
            double newPprices=food.getPrices();
            Syst
                
                em.out.println("请输入你要点餐的份数");
            int fen=scanner.nextInt();
​
            System.out.println("请输入您的送餐时间(请输入10~22的整数)");
            int time=scanner.nextInt();
            //对用户输入的时间进行判断
            while (time <10 && time>22){
                System.out.println("对不起，您输入的时间不在配送范围内(请重新输入)");
                int ErrTime=scanner.nextInt();
            }
            System.out.println("请输入你的配送地址");
            String addresses=scanner.next();
            //设置订单状态
            order.setStates(0);
            //计算订单价格，从对象之中获取的菜品价格 * 用户输入的份数
            double sumPrices=newPprices * fen;
            double newSumPrices= 0;
            //对价格进行判断，如果订单总金额大于50，免配送费，否则收取配送费6元
            if (sumPrices>=50){
                newSumPrices=sumPrices;
                System.out.println("订单总金额为"+newSumPrices);
​
            }else {
                //订单总金额小于50时，加配送费6元
                newSumPrices=sumPrices+6;
                System.out.println("订单总金额为"+newSumPrices);
            }
            //将获取到的总金额添加到对象之中，再将对象添加到数据库之中
            Order order2=new Order(name,dishNames,fen,time,addresses,0,newSumPrices);
            //使用orderDao调用添加方法，将组成的对象添加进数据库之中
            int rows=orderDao.insert(order2);
            System.out.println(rows==0?"点餐失败":"点餐成功");
​
​
​
        return 0;
    }
    //删除订单
    @Override
    public int delete() {
        System.out.println("请输入您要删除的订单编号");
        int id1=scanner.nextInt();
        //使用 orderDao调用方法查询系统内部是否有此订单,返回一个order的对象
        Order order1=orderDao.selectOneOrder(id1);
        //对返回的结果进行判断，若系统内部无此订单，则不可以删除，反之有订单则可删除
        if (order1==null){
            System.out.println("对不起，订单不存在，不可删除");
        }else {
​
            //调用方法执行删除
            int result =orderDao.delete(id1);
            return  result;
        }
        return 0;
    }
    //签收订单（修改订单）
    @Override
    public int update() {
        System.out.println("请输入你要签收的订单号");
        int id =scanner.nextInt();
        //使用 orderDao调用方法查询系统内部是否有此订单,返回一个order的对象
        Order order1=orderDao.selectOneOrder(id);
        //对返回的结果进行判断，若系统内部无此订单，则不可以签收，反之有订单则可签收
        //设置订单状态为1,1表示已签收，0表示未签收
        if (order1==null){
            System.out.println("对不起，您要签收的订单不存在");
        }else {
            //调用修改方法，进行修改订单状态,返回受影响的行数
            order1.setStates(1);
            int result=orderDao.update(order1);
            return  result;
​
        }
        return 0;
    }
    //查看餐袋
    @Override
    public Order selectOneOrder(int id) {
        //使用 orderDao调用查询单个方法查询系统内部是否有此订单,返回一个order的对象
        Order order1=orderDao.selectOneOrder(id);
        return order1;
    }
​
    @Override
    public List<Order> selectAllOrder() {
        //使用 orderDao调用查询所有方法查询系统内部是否有此订单,返回一个List<Order>的泛型集合
        List<Order> orderList=orderDao.selectAllOrder();
        return orderList;
    }
​
    @Override
    public void showOrder() {
        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("-------------------------------------------");
        System.out.println("请小主选择菜单，输入序号即可");
    }
​
}

import com.bdqn.Entity.Food;
​
import java.util.List;
​
public interface FoodService {
    //规范一下服务类的方法
    int updateFood();
    Food selectOneFood(int cid);
    List<Food> selectAllFood();
}

public interface OrderService {
    //规范一下服务类的方法
    int add();//添加
    int delete();//删除
    int update();//修改
    Order selectOneOrder(int id); //查单个
    List<Order> selectAllOrder(); //查所有
​
    void showOrder();
}

接下来就是工具类

date工具类和DBUtils工具类

import java.text.ParseException;
import java.text.SimpleDateFormat;
​
/**
 * 日期时间工具类DateUtils
 *
 *
 *
 */
public class DateUtils {
​
    private static final SimpleDateFormat SIMPLEDATEFORMAT = new SimpleDateFormat("yyyy-MM-dd");
​
    // 字符串转换为java.util.Date类型日期时间
    public static java.util.Date strDateToUtilDate(String strDate) {
        try {
            return SIMPLEDATEFORMAT.parse(strDate);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
​
    // java.util.Date类型日期时间转换为java.sql.Date类型日期时间
    public static java.sql.Date utilDateToSqlDate(java.util.Date date) {
        // long date.getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT以来此 Date对象表示的毫秒数
        return new java.sql.Date(date.getTime());
    }
​
    // java.util.Date类转换为字符串类型
    public static String utilDateToString(java.util.Date date) {
        return SIMPLEDATEFORMAT.format(date);
    }
​
​
}

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;
​
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
​
public class DBUtils {
​
    // 声明一个连接池对象
    private static DruidDataSource druidDataSource;
​
    static {
        // 实例化配置文件对象
        Properties properties = new Properties();
​
        try {
            // 加载配置文件内容
            InputStream is = DBUtils.class.getResourceAsStream("/db.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;
    }
​
}

最后也就是view类，也就是测试类

public class chiHuoSystemTest {

    public static void main(String[] args) {

        //因为订餐等数据来源于用户从键盘输入，创建Scanner对象

        Scanner scanner=new Scanner(System.in);

        //定义一个num的值用来控制while循环

        int num=-1;

        //定义一个布尔值用来退出系统

        boolean isExit=false;

        //创建OrderServiceImpl对象，方便后面的方法调用

        OrderServiceImpl orderService=new OrderServiceImpl();

        //创建FoodServiceImpl对象，方便后面的方法调用

        FoodServiceImpl foodService=new FoodServiceImpl();

        System.out.println("--------------------------------------------欢迎光临牛逼外卖---------------------------------------------");

        do {

            orderService.showOrder();

            //定义变量用来接收用户输入的订单序号

            int choose=scanner.nextInt();

            switch(choose){

                case 1:

                    //具体功能表现

                    System.out.println("---------------------------------我要订餐---------------------------------");

​

                    //调用方法实现我要点餐

                    orderService.add();

                    break;//该break的作用是用来结束整个switch选择结构

                case 2:

                    //具体功能表现

                    System.out.println("---------------------------------查看餐袋---------------------------------");

                    //调用方法查询数据库，实现查询餐袋，这里需要对集合进行遍历，输出集合（数据库）里面已经有的对象

                    List<Order> orderList =orderService.selectAllOrder();

                    orderList.forEach(System.out::println);

                    break;//该break的作用是用来结束整个switch选择结构

                case 3:

                    //具体功能表现

                    System.out.println("---------------------------------签收订单---------------------------------");

                    //调用修改的方法

                    int rows=orderService.update();

                    System.out.println(rows==0?"签收失败":"签收成功");

                    break;//该break的作用是用来结束整个switch选择结构

                case 4:

                    //具体功能表现

                    System.out.println("---------------------------------删除订单---------------------------------");

                    //调用删除的方法

                    int result=orderService.delete();

                    System.out.println(result==0?"删除失败":"删除成功");

                    break;//该break的作用是用来结束整个switch选择结构

                case 5:

                    //具体功能表现

                    System.out.println("---------------------------------我要点赞---------------------------------");

                    //调用food之中修改的方法

                    int result1=foodService.updateFood();

                    System.out.println(result1==0?"点赞失败":"点赞成功");

                    break;//该break的作用是用来结束整个switch选择结构

                case 6:

                    //具体功能表现

                    System.out.println("---------------------------------退出系统---------------------------------");

                    isExit=true;

                    break;//该break的作用是用来结束整个switch选择结构

                default:

                    System.out.println("退出系统");

                    isExit=true;

                    break;

            }

            if (!isExit){

                System.out.println("------------输入0返回------------");

                //定义变量接收用户输入的数字

                num=scanner.nextInt();

            }else {

                break;

            }

        }while(num==0);

        System.out.println("----------------------------------------欢迎下次光临----------------------------------------");

    }

}