JAVASE点餐系统源码

最新推荐文章于 2024-07-18 10:35:20 发布
最新推荐文章于 2024-07-18 10:35:20 发布
阅读量521 收藏 15
点赞数 3
分类专栏： 项目练习 笔记 文章标签： java 集合 面向对象编程 正则表达式 intellij idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36827283/article/details/122317837
版权

点餐系统JAVASE点餐系统,java基础项目练习-Java文档类资源-CSDN下载

一,知识点

集合框架,IO流,序列化,反序列化,面向对象,接口,实现类

二,功能

1.用户

1)登录注册

2)查看所有菜品

3)购买菜品

4)查看购买状态(正在派送,已接收)

5)根据条件查看订单

2.商家(兼职管理员)

1)登录

2)查看已上架的菜品

3)更新菜品

4)更新用户信息

5)更新订单状态

三,实体类设计

//省略get/set
public class User implements Serializable {
    private String tel;
    private String pwd;
    private String name;
    private String address;
}
​
public class Admin implements Serializable {
    private String account;
    private String pwd;
​
}
​
public class Cuisine implements Serializable {
    private int cid;
    private String cName;
    private double price;
    private String introduce;
    private String stock;
​
​
}
public class Order implements Serializable{
    private int oId;
    private String tel;//用户的编号
    private int cId;//菜品编号
    private int num;
    private Date date;//日期
    private double sum;//总价
    private int state;//派送状态 0已付款  1.派送中 2.已接收 
    private int abandon;//是否弃用  0正常  1弃用
}

四,创建工具类

package com.sk.util;
​
import com.sk.entity.Admin;
import com.sk.entity.User;
​
import java.io.*;
​
import java.util.ArrayList;
import java.util.List;
​
/**
 * ClassName: UserUtil <br/>
 * Description: <br/>
 * date: 2022/1/3 9:21<br/>
 *
 * @author 斑马<br />
 */
public class DataUtil {
    public static final String USER="user.data";
    public static final String ADMIN="admin.data";
    public static final String CUISINE="cuisine.data";
    public static final String ORDER="user.data";
​
    public static <E> void write(List<E> list, String url){
        try (OutputStream ob =new FileOutputStream(url);
             ObjectOutputStream out=new ObjectOutputStream(ob);) {
            out.writeObject(list);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    public static <E> List<E> read(String url){
        try (InputStream is = new FileInputStream(url);
        ObjectInputStream in=new ObjectInputStream(is)) {
            List<E> list= (List<E>) in.readObject();
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}
​

五,实现管理员登录

1.实现dao

public interface AdminDao {
    /**根据账户密码查找管理员*/
    Admin findAdminByAccAndPwd(String account,String pwd);
}
public class AdminDaoImpl implements AdminDao {
    @Override
    public Admin findAdminByAccAndPwd(String account, String pwd) {
        List<Admin> list= DataUtil.read(DataUtil.ADMIN);
        for (int i=0;i<list.size();i++){
            Admin ad=list.get(i);
            if(ad.getAccount().equals(account)&&ad.getPwd().equals(pwd)){
                return ad;
            }
        }
        return null;
    }
}

2.实现service

public interface AdminService {
    /**根据账户密码查找管理员*/
    Admin findAdminByAccAndPwd(String account, String pwd);
}
public class AdminServiceImpl implements AdminService {
    @Override
    public Admin findAdminByAccAndPwd(String account, String pwd) {
        return new AdminDaoImpl().findAdminByAccAndPwd(account,pwd);
    }
}

3.实现view

public class AdminView {
    Scanner sc=new Scanner(System.in);
    AdminService adminService=new AdminServiceImpl();
    public void login(){
        System.out.println("***********管理员登录***********");
        System.out.println("请输入账户:");
        String account=sc.next();
        System.out.println("请输入密码:");
        String pwd=sc.next();
        Admin ad=adminService.findAdminByAccAndPwd(account,pwd);
        if(ad==null){
            System.out.println("登录失败!");
            login();
        }else{
            System.out.println("欢迎管理员:\t"+ad.getAccount()+"\t使用本系统");
        }
    }
​
}

4.测试

public class Test {
    /**初始化管理员信息*/
    public static void inintAdmin(){
        Admin ad1=new Admin("admin","admin");
        Admin ad2=new Admin("zs","zs");
        List<Admin> list=new ArrayList<>();
        list.add(ad1);
        list.add(ad2);
        DataUtil.write(list,DataUtil.ADMIN);
    }
    /**开始程序*/
    public static void main(String[] args) {
        //inintAdmin();
        AdminView adminView=new AdminView();
        adminView.login();
    }
}
​

六,实现菜品更新

1.实现dao

public interface CuisineDao {
    /**添加*/
    public boolean addCuisine(Cuisine cuisine);
    /**自增的id*/
    public int autoCId();
    /**下架*/
    public boolean updateStateById(int cId,int state);
    /**修改*/
    public boolean updateById(Cuisine cuisine);
    /**根据状态查看菜品*/
    public List<Cuisine> showCuisineByState(int state);
    /**查看所有菜品*/
    public List<Cuisine> showCuisines();
}
public class CuisineDaoImpl implements CuisineDao {
    @Override
    public boolean addCuisine(Cuisine cuisine) {
        List<Cuisine> list= DataUtil.read(DataUtil.CUISINE);
        list.add(cuisine);
        DataUtil.write(list,DataUtil.CUISINE);
        return true;
    }
​
    @Override
    public int autoCId() {
        List<Cuisine> list= DataUtil.read(DataUtil.CUISINE);
        int id= new Random().nextInt();
        for (Cuisine c:list){
            if(c.getCid()==id){
                autoCId();
            }
        }
        return id;
    }
​
    @Override
    public boolean updateStateById(int cId, int state) {
        List<Cuisine> list= DataUtil.read(DataUtil.CUISINE);
        for (Cuisine c:list){
            if(c.getCid()==cId){//cid相同
                c.setState(state);//修改状态
                DataUtil.write(list,DataUtil.CUISINE);
                return true;
            }
        }
        return false;
    }
​
    @Override
    public boolean updateById(Cuisine cuisine) {
        List<Cuisine> list= DataUtil.read(DataUtil.CUISINE);
        for (int i=0;i<list.size();i++){
            Cuisine c=list.get(i);
            if(c.getCid()==cuisine.getCid()){//cid相同
                list.set(i,cuisine);
                DataUtil.write(list,DataUtil.CUISINE);
                return true;
            }
        }
        return false;
    }
​
    @Override
    public List<Cuisine> showCuisineByState(int state) {
        List<Cuisine> list= DataUtil.read(DataUtil.CUISINE);
        List<Cuisine> newList=new ArrayList<>();//用来存不同状态的菜品
        for (Cuisine c:list){
            if(c.getState()==state){//状态相同
                newList.add(c);//添加到新的集合中
            }
        }
        return newList;
    }
​
    @Override
    public List<Cuisine> showCuisines() {
        List<Cuisine> list= DataUtil.read(DataUtil.CUISINE);
        return list;
    }
}

2.实现service

public interface CuisineService {
    /**添加*/
    public void addCuisine(Cuisine cuisine);
    /**下架*/
    public boolean updateStateById(int cId,int state);
    /**修改*/
    public boolean updateById(Cuisine cuisine);
    /**根据状态查看菜品*/
    public List<Cuisine> showCuisineByState(int state);
    /**查看所有菜品*/
    public List<Cuisine> showCuisines();
}
public class CuisineServiceImpl implements CuisineService {
    CuisineDao cuisineDao=new CuisineDaoImpl();
    @Override
    public void addCuisine(Cuisine cuisine) {
        int cid=cuisineDao.autoCId();//获取id
        cuisine.setCid(cid);//随机的id
        cuisine.setState(0);//默认状态是  上架
        cuisineDao.addCuisine(cuisine);
    }
    //可以把上架的下架,把下架的上架
    @Override
    public boolean updateStateById(int cId, int state) {
        return cuisineDao.updateStateById(cId,state);
    }
​
    @Override
    public boolean updateById(Cuisine cuisine) {
        return cuisineDao.updateById(cuisine);
    }
​
    @Override
    public List<Cuisine> showCuisineByState(int state) {
        return cuisineDao.showCuisineByState(state);
    }
​
    @Override
    public List<Cuisine> showCuisines() {
        return cuisineDao.showCuisines();
    }
}

3.实现view

package com.sk.view;
​
import com.sk.entity.Cuisine;
import com.sk.service.CuisineService;
import com.sk.service.impl.CuisineServiceImpl;
​
import java.util.List;
import java.util.Scanner;
​
/**
 * ClassName: CuisineView <br/>
 * Description: <br/>
 * date: 2022/1/3 15:04<br/>
 *
 * @author 斑马<br />
 */
public class CuisineView {
    Scanner sc = new Scanner(System.in);
    CuisineService cuisineService = new CuisineServiceImpl();
​
    /**
     * 上架新菜品
     */
    public void addCuisine() {
        System.out.println("**********菜品添加***********");
        System.out.println("请输入菜品名称:");
        String cName = sc.next();
        System.out.println("请输入菜品价格:");
        double price = sc.nextDouble();
        System.out.println("请输入菜品原料:");
        String stock = sc.next();
        System.out.println("请输入菜品介绍:");
        String introduce = sc.next();
        Cuisine c = new Cuisine(0, cName, price, introduce, stock, 0);
        cuisineService.addCuisine(c);
        System.out.println("上架成功!");
​
    }
​
    /**
     * 下架
     */
    public void updateStateById() {
        System.out.println("**************下架***************");
        //显示已经上架的
        showCuisine0();
        System.out.println("请选中要下架的商品编号:");
        int cId=sc.nextInt();
        boolean flag=cuisineService.updateStateById(cId,1);
        if(flag){
            System.out.println("菜品已下架!");
        }else {
            System.out.println("下架失败!");
        }
    }
    /**
     * 重新上架
     */
    public void updateStateById1() {
        System.out.println("**************重新上架***************");
        //显示已经下架的
        showCuisine1();
        System.out.println("请选中要重新上架的商品编号:");
        int cId=sc.nextInt();
        boolean flag=cuisineService.updateStateById(cId,0);
        if(flag){
            System.out.println("菜品已上架!");
        }else {
            System.out.println("上架失败!");
        }
    }
​
    /**
     * 修改
     */
    public void updateById() {
        System.out.println("**********修改菜品***********");
        System.out.println("请输入要修改的菜品编号:");
        int cid=sc.nextInt();
        System.out.println("请输入修改后的菜品名称:");
        String cName = sc.next();
        System.out.println("请输入修改后的菜品价格:");
        double price = sc.nextDouble();
        System.out.println("请输入修改后的菜品原料:");
        String stock = sc.next();
        System.out.println("请输入修改后的菜品介绍:");
        String introduce = sc.next();
        System.out.println("请选择菜品状态0.已上架1.已下架");
        int state=sc.nextInt();
        Cuisine c = new Cuisine(cid, cName, price, introduce, stock, state);
        boolean flag=cuisineService.updateById(c);
        if(flag){
            System.out.println("修改成功!");
        }else {
            System.out.println("修改失败!");
        }
    }
​
    /**
     * 查看已上架菜品
     */
    public void showCuisine0() {
        System.out.println("**************已上架菜品***************");
        List<Cuisine> list = cuisineService.showCuisineByState(0);
        for (Cuisine c : list) {
            System.out.println("编号:" + c.getCid() + "\t名称:" + c.getcName() + "\t价格:" + c.getPrice());
            System.out.println("原料:" + c.getStock() + "\t状态:已上架");
            System.out.println("简介:" + c.getIntroduce());
            System.out.println("---------------------------");
        }
    }
    /**
     * 查看已下架菜品
     */
    public void showCuisine1() {
        System.out.println("**************已下架菜品***************");
        List<Cuisine> list = cuisineService.showCuisineByState(1);
        for (Cuisine c : list) {
            System.out.println("编号:" + c.getCid() + "\t名称:" + c.getcName() + "\t价格:" + c.getPrice());
            System.out.println("原料:" + c.getStock() + "\t状态:已下架");
            System.out.println("简介:" + c.getIntroduce());
            System.out.println("---------------------------");
        }
    }
​
    /**
     * 查看所有菜品
     */
    public void showCuisines() {
        System.out.println("*********查看所有菜品*********");
        List<Cuisine> list = cuisineService.showCuisines();
        for (Cuisine c : list) {
            if (c.getState() == 0) {//上架
                System.out.println("编号:" + c.getCid() + "\t名称:" + c.getcName() + "\t价格:" + c.getPrice());
                System.out.println("原料:" + c.getStock() + "\t状态:已上架");
                System.out.println("简介:" + c.getIntroduce());
            } else {//已下架
                System.out.println("编号:" + c.getCid() + "\t名称:" + c.getcName() + "\t价格:" + c.getPrice());
                System.out.println("原料:" + c.getStock() + "\t状态:已下架");
                System.out.println("简介:" + c.getIntroduce());
            }
            System.out.println("---------------------------");
        }
    }
}
​

4.初始化数据

public static void inintCuisine(){
        Cuisine c1=new Cuisine(1,"红烧肉",30,"很好吃,吃不死人","豆腐",0);
        Cuisine c2=new Cuisine(2,"红烧人肉",300000,"吃人犯法","豆腐",1);
        List<Cuisine>list=new ArrayList<>();
        list.add(c1);
        list.add(c2);
        DataUtil.write(list,DataUtil.CUISINE);
    }

七,实现用户的登录注册

1.实现dao

public interface UserDao {
    /**查找用户*/
    public User findUserByTelAndPwd(String tel,String pwd);
    /**添加用户*/
    public void addUser(User user);
    /**根据手机号查找用户*/
    public User findUserByTel(String tel);
    /**根据手机号修改用户信息*/
    public void updateUserByTel(User user);
​
}
package com.sk.dao.impl;
​
import com.sk.dao.UserDao;
import com.sk.entity.User;
import com.sk.util.DataUtil;
​
import java.util.List;
​
/**
 * ClassName: UserDaoImpl <br/>
 * Description: <br/>
 * date: 2022/1/4 8:19<br/>
 *
 * @author 斑马<br />
 */
public class UserDaoImpl implements UserDao {
    @Override
    public User findUserByTelAndPwd(String tel, String pwd) {
        List<User> list= DataUtil.read(DataUtil.USER);
        for (User u:list){
            if(u.getTel().equals(tel)&&u.getPwd().equals(pwd)){
                return u;
            }
        }
        return null;
    }
​
    @Override
    public void addUser(User user) {
        List<User> list= DataUtil.read(DataUtil.USER);
        list.add(user);
        DataUtil.write(list,DataUtil.USER);
    }
​
    @Override
    public User findUserByTel(String tel) {
        List<User> list= DataUtil.read(DataUtil.USER);
        for (User u:list){
            if(u.getTel().equals(tel)){
                return u;
            }
        }
        return null;
    }
​
    @Override
    public void updateUserByTel(User user) {
        List<User> list= DataUtil.read(DataUtil.USER);
        for (int i=0;i<list.size();i++){
            User u=list.get(i);
            if(u.getTel().equals(user.getTel())){
                list.set(i,user);
                DataUtil.write(list,DataUtil.USER);
            }
        }
    }
}
​

2.实现service

package com.sk.service;
​
import com.sk.entity.User;
​
/**
 * ClassName: UserService <br/>
 * Description: <br/>
 * date: 2022/1/4 8:33<br/>
 *
 * @author 斑马<br />
 */
public interface UserService {
    /**查找用户*/
    public User findUserByTelAndPwd(String tel, String pwd);
    /**添加用户*/
    public void addUser(User user);
    /**根据手机号查找用户*/
    public User findUserByTel(String tel);
    /**根据手机号修改用户信息*/
    public void updateUserByTel(User user);
}
package com.sk.service.impl;
​
import com.sk.dao.UserDao;
import com.sk.dao.impl.UserDaoImpl;
import com.sk.entity.User;
import com.sk.service.UserService;
​
/**
 * ClassName: UserServiceImpl <br/>
 * Description: <br/>
 * date: 2022/1/4 8:35<br/>
 *
 * @author 斑马<br />
 */
public class UserServiceImpl implements UserService {
    UserDao userDao=new UserDaoImpl();
    @Override
    public User findUserByTelAndPwd(String tel, String pwd) {
        return userDao.findUserByTelAndPwd(tel,pwd);
    }
​
    @Override
    public void addUser(User user) {
        userDao.addUser(user);
    }
​
    @Override
    public User findUserByTel(String tel) {
        return  userDao.findUserByTel(tel);
    }
​
    @Override
    public void updateUserByTel(User user) {
        userDao.updateUserByTel(user);
    }
}
​

3.实现view

public class UserView {
    Scanner sc=new Scanner(System.in);
    UserService userService=new UserServiceImpl();
    CuisineView cuisineView=new CuisineView();
    OrderView orderView=new OrderView();
    /**登录菜单*/
    public void star(){
        System.out.println("************用户界面***************");
        System.out.println("1.登录");
        System.out.println("2.注册");
        System.out.println("请选择(其他选项退出):");
        int num=sc.nextInt();
        switch (num){
            case 1:
                login();
                break;
            case 2:
                addUser();
                break;
            default:
                System.out.println("欢迎下次使用!");
                System.exit(0);
        }
        System.out.println("是否返回用户界面?y/n");
        String str=sc.next();
        if(str.equals("y")){
            star();
        }
    }
    /**登录*/
    public void login(){
        System.out.println("******************用户登录*****************");
        System.out.println("请输入手机号:");
        String tel=sc.next();
        System.out.println("请输入密码:");
        String pwd=sc.next();
        User user=userService.findUserByTelAndPwd(tel,pwd);
        if(user==null){
            System.out.println("登录失败,手机号或密码错误!");
        }else{
            System.out.println("***********欢迎用户:\t"+user.getName()+"\t使用本系统*****************");
            menu(user);
        }
    }
    /**注册*/
    public void addUser(){
        System.out.println("******************用户注册*****************");
        System.out.println("请输入手机号:");
        String tel=sc.next();
        //验证手机号格式
        if(tel.matches("^1\\w{10}$")){
            User u=userService.findUserByTel(tel);
            if(u!=null){
                System.out.println("手机号已存在!");
                addUser();
            }else {
                System.out.println("请输入密码:");
                String pwd=sc.next();
                System.out.println("请再次输入密码:");
                String pwd1=sc.next();
                if(pwd1.equals(pwd)){
                    System.out.println("请输入昵称:");
                    String name=sc.next();
                    System.out.println("请输入收货地址:");
                    String address=sc.next();
                    User user=new User(tel,pwd,name,address);
                    userService.addUser(user);
                    System.out.println("注册成功!");
                }else{
                    System.out.println("密码不一致!");
                    addUser();
                }
            }
​
        }else{
            System.out.println("手机号格式错误!");
            addUser();
        }
​
    }
}

4.初始化数据并测试

/**初始化数据*/
    public static void inintUser(){
        User u1=new User("1","1","张三","天津");
        List<User> list=new ArrayList<>();
        list.add(u1);
        DataUtil.write(list,DataUtil.USER);
    }

八,实现用户的其他功能

后续会省略已经存在的代码

1.查看所有菜品

1)CuisineDao

public interface CuisineDao {
/**根据状态查看菜品*/
    public List<Cuisine> showCuisineByState(int state);
}
    
public class CuisineDaoImpl implements CuisineDao {
    @Override
    public List<Cuisine> showCuisineByState(int state) {
        List<Cuisine> list= DataUtil.read(DataUtil.CUISINE);
        List<Cuisine> newList=new ArrayList<>();//用来存不同状态的菜品
        for (Cuisine c:list){
            if(c.getState()==state){//状态相同
                newList.add(c);//添加到新的集合中
            }
        }
        return newList;
    }
}

2)CuisineService

public interface CuisineService {
/**根据状态查看菜品*/
    public List<Cuisine> showCuisineByState(int state);
    }
}
public class CuisineServiceImpl implements CuisineService{
@Override
    public List<Cuisine> showCuisineByState(int state) {
        return cuisineDao.showCuisineByState(state);
    }
}

3)CuisineView

public class CuisineView {
public void showCuisine0() {
        System.out.println("**************已上架菜品***************");
        List<Cuisine> list = cuisineService.showCuisineByState(0);
        for (Cuisine c : list) {
            System.out.println("编号:" + c.getCid() + "\t名称:" + c.getcName() + "\t价格:" + c.getPrice());
            System.out.println("原料:" + c.getStock() + "\t状态:已上架");
            System.out.println("简介:" + c.getIntroduce());
            System.out.println("---------------------------");
        }
    }
}

4)用户菜单

public class UserView {
/**用户菜单*/
    public void menu(User user){
        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("请选择:");
        int num=sc.nextInt();
        switch (num){
            case 1:
                cuisineView.showCuisine0();
                break;
            case 2:
                orderView.addOrder(user);
                break;
            case 3:
                orderView.receiving(user);
                break;
            case 4:
                orderView.showOrder(user);
                break;
            case 5:
                orderView.delete(user);
                break;
            default:
                System.out.println("输入错误!请重新输入!");
                menu(user);
        }
        System.out.println("是否返回用户菜单?y/n");
        String str=sc.next();
        if(str.equals("y")){
            menu(user);
        }
    }
}

2.实现点餐

OrderDao

public interface OrderDao {
    /**添加订单*/
    public void addOrder(Order order);
    /**自增主键*/
    public int autoId();
    /**根据订单编号修改订单状态*/
    public boolean updateStateById(int id,int state);
}
public class OrderDaoImpl implements OrderDao {
    @Override
    public void addOrder(Order order) {
        List<Order> list= DataUtil.read(DataUtil.ORDER);
        list.add(order);
        DataUtil.write(list,DataUtil.ORDER);
    }
​
    @Override
    public int autoId() {
        List<Order> list= DataUtil.read(DataUtil.ORDER);
        //获取最后一个订单
        Order o= list.get(list.size()-1);
        //获取id
        int id=o.getoId();
        return id+1;
    }
​
    @Override
    public boolean updateStateById(int id, int state) {
        List<Order> list= DataUtil.read(DataUtil.ORDER);
        for (int i=0;i<list.size();i++){
            Order o=list.get(i);
            if(o.getoId()==id){
                o.setState(state);
                DataUtil.write(list,DataUtil.ORDER);
                return true;
            }
        }
​
        return false;
    }
}

CuisineDao

public interface CuisineDao {
​
    /**根据菜品编号查看菜品*/
    public Cuisine showCuisineByCid(int cid);
}
​
public class CuisineDaoImpl implements CuisineDao {
    @Override
    public Cuisine showCuisineByCid(int cid) {
        List<Cuisine> list= DataUtil.read(DataUtil.CUISINE);
        for (Cuisine c:list){
            if(c.getCid()==cid){//id相同
                return c;
            }
        }
        return null;
    }
}

OrderService

public interface OrderService {
    /**点餐
     */
    public Order addOrder(String tel, int cid, int num);
    /**根据订单编号修改订单状态*/
    public boolean updateStateById(int id,int state);
}
public class OrderServiceImpl implements OrderService {
    OrderDao orderDao=new OrderDaoImpl();
    CuisineDao cuisineDao=new CuisineDaoImpl();
    @Override
    public Order addOrder(String tel, int cid, int num) {
        //判断菜品是否存在
        Cuisine cuisine=cuisineDao.showCuisineByCid(cid);
        if(cuisine!=null){
            if(num>0){//数量大于0
                double sum=cuisine.getPrice()*num;
                Order o=new Order(orderDao.autoId(),tel,cid,num,new Date(),sum,0,0);
                orderDao.addOrder(o);
                return o;
            }
        }
        return null;
    }
​
    @Override
    public boolean updateStateById(int id, int state) {
        return orderDao.updateStateById(id,state);
    }
}

OrderView

public class OrderView {
    Scanner sc=new Scanner(System.in);
    OrderService orderService=new OrderServiceImpl();
    /**点餐*/
    public void addOrder(User user){
        //显示商品
        new CuisineView().showCuisine0();
        System.out.println("请输入要购买的菜品编号:");
        int cid=sc.nextInt();
        System.out.println("请输入购买数量:");
        int num=sc.nextInt();
        Order o=orderService.addOrder(user.getTel(),cid,num);
        if(o!=null){
            System.out.println("点餐成功!总金额:"+o.getSum());
            System.out.println("是否付款?y/n");
            String  str=sc.next();
            if(str.equals("y")){
                orderService.updateStateById(o.getoId(),1);
                System.out.println("付款成功!");
            }else{
                System.out.println("付款失败!");
            }
        }else{
            System.out.println("点餐失败!菜品不存在!");
        }
    }
}

3.实现确认收货

OrderView

public class OrderView {
    public void receiving(User user){
        //显示未收货的列表
        List<Order> list=orderService.showOrderByTelAndState(user.getTel(),2);
        CuisineService service=new CuisineServiceImpl();
        System.out.println("订单编号:\t菜品名称\t菜品单价\t购买数量\t总价\t配送状态\t购买日期");
        for (Order o:list){
            //根据菜品编号找到对应的菜品
            Cuisine c=service.showCuisineByCid(o.getcId());
            Date date=o.getDate();
            SimpleDateFormat sm=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String d=sm.format(date);//格式化日期类型
            System.out.println(o.getoId()+"\t"+c.getcName()+"\t"+c.getPrice()+"\t"+o.getNum()
                    +"\t"+o.getSum()+"\t"+"配送中\t"+d
            );
        }
        System.out.println("请输入要确认收货的订单编号:");
        int oid=sc.nextInt();
        boolean flag=orderService.updateStateById(oid,3);
        if(flag){
            System.out.println("签收成功!");
        }else {
            System.out.println("签收失败!");
        }
    }
}
    

​

4.实现查看订单

OrderDao

public interface OrderDao { 
    /**根据用户id 查看订单*/
    public List<Order> showOrderByTel(String tel);
}
public class OrderDaoImpl implements OrderDao {
​
    @Override
    public List<Order> showOrderByTel(String tel) {
        List<Order> list= DataUtil.read(DataUtil.ORDER);
        List<Order> newList=new ArrayList<>();
        for (Order o:list){
            if(o.getTel().equals(tel)){
                newList.add(o);
            }
        }
        return newList;
    }
}

OrderService

public interface OrderService {
​
    /**根据用户id 查看订单*/
    public List<Order> showOrderByTel(String tel);
}
public class OrderServiceImpl implements OrderService {
    OrderDao orderDao=new OrderDaoImpl();
    @Override
    public List<Order> showOrderByTel(String tel) {
        return orderDao.showOrderByTel(tel);
}

OrderView

public class OrderView {
    /**查看订单*/
    public void showOrder(User user){
        List<Order> list=orderService.showOrderByTel(user.getTel());
        CuisineService service=new CuisineServiceImpl();
        System.out.println("订单编号:\t菜品名称\t菜品单价\t购买数量\t总价\t配送状态\t购买日期");
        for (Order o:list){
            if(o.getAbandon()==1){//弃用
                continue;
            }
            //根据菜品编号找到对应的菜品
            Cuisine c=service.showCuisineByCid(o.getcId());
            Date date=o.getDate();
            SimpleDateFormat sm=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String d=sm.format(date);//格式化日期类型
            String state=null;
            switch (o.getState()){
                case 0:
                    state="未付款";
                    break;
                case 1:
                    state="已付款";
                    break;
                case 2:
                    state="配送中";
                    break;
                case 3:
                    state="已签收";
                    break;
            }
            System.out.println(o.getoId()+"\t"+c.getcName()+"\t"+c.getPrice()+"\t"+o.getNum()
                +"\t"+o.getSum()+"\t"+state+"\t"+d
            );
​
        }
    }
}

5.删除订单

OrderDao

public interface OrderDao {
    /**根据订单编号修改弃用状态*/
    public boolean updateAbandonById(int id,int abandon);
}
public class OrderDaoImpl implements OrderDao {
​
    @Override
    public boolean updateAbandonById(int id, int abandon) {
        List<Order> list= DataUtil.read(DataUtil.ORDER);
        for (int i=0;i<list.size();i++){
            Order o=list.get(i);
            if(o.getoId()==id){
                o.setAbandon(abandon);
                DataUtil.write(list,DataUtil.ORDER);
                return true;
            }
        }
        return false;
    }
}

OrderService

public interface OrderService {
    /**删除订单*/
    public boolean updateAbandonById(int id,int abandon);
}
public class OrderServiceImpl implements OrderService {
​
    @Override
    public boolean updateAbandonById(int id, int abandon) {
        return orderDao.updateAbandonById(id,abandon);
    }
}

OrderView

public class OrderView {
    /**删除订单*/
    public void delete(User user){
        showOrder(user);//显示所有订单
        System.out.println("请输入要删除的订单");
        int oid=sc.nextInt();
        boolean flag=orderService.updateAbandonById(oid,1);
        if(flag){
            System.out.println("删除成功!");
        }else {
            System.out.println("删除失败!");
        }
    }
}

九,实现管理员订单配送

public interface OrderService {
    /**查看所有订单*/
    public List<Order> showOrders();
}
public class OrderServiceImpl implements OrderService {
    OrderDao orderDao=new OrderDaoImpl();
    @Override
    public List<Order> showOrders() {
        return orderDao.showOrders();
    }
}

1.显示所有订单

OrderDao

public interface OrderDao {
   /**查看所有订单*/
   public List<Order> showOrders();
}
public class OrderDaoImpl implements OrderDao {
​
    @Override
    public List<Order> showOrders() {
        return DataUtil.read(DataUtil.ORDER);
    }
}

OrderService

public interface OrderService {
    /**查看所有订单*/
    public List<Order> showOrders();
}
public class OrderServiceImpl implements OrderService {
    OrderDao orderDao=new OrderDaoImpl();
    @Override
    public List<Order> showOrders() {
        return orderDao.showOrders();
    }
}

OrderView

public class OrderView {
    Scanner sc=new Scanner(System.in);
    OrderService orderService=new OrderServiceImpl();
​
    /**显示所有订单*/
    public void showAllOrder(){
        CuisineService service=new CuisineServiceImpl();
        UserService userService=new UserServiceImpl();
        //所有的订单
        List<Order> list=orderService.showOrders();
        System.out.println("订单编号:\t菜品名称\t菜品单价\t购买数量\t总价\t配送状态\t购买日期\t用户\t收货地址");
        for (Order o:list){
            //根据菜品编号找到对应的菜品
            Cuisine c=service.showCuisineByCid(o.getcId());
            Date date=o.getDate();
            SimpleDateFormat sm=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String d=sm.format(date);//格式化日期类型
            User user=userService.findUserByTel(o.getTel());
            String state=null;
            switch (o.getState()){
                case 0:
                    state="未付款";
                    break;
                case 1:
                    state="已付款";
                    break;
                case 2:
                    state="配送中";
                    break;
                case 3:
                    state="已签收";
                    break;
            }
            System.out.println(o.getoId()+"\t"+c.getcName()+"\t"+c.getPrice()+"\t"+o.getNum()
                    +"\t"+o.getSum()+"\t"+state+"\t"+d+"\t"+user.getTel()+"\t"+user.getAddress()
            );
​
        }
    }
}

2.配送订单

OrderDao

public interface OrderDao {
   /**根据状态查看订单*/
   public List<Order> showOrdersByState(int state);
}
public class OrderDaoImpl implements OrderDao {
​
    @Override
    public List<Order> showOrdersByState(int state) {
        List<Order> list= DataUtil.read(DataUtil.ORDER);
        List<Order> newList=new ArrayList<>();
        for (Order o:list){
            if(o.getState()==state){
                newList.add(o);
            }
        }
        return newList;
    }
}

OrderService

public interface OrderService {
    /**根据状态查看订单*/
    public List<Order> showOrdersByState(int state);
}
public class OrderServiceImpl implements OrderService {
    @Override
    public List<Order> showOrdersByState(int state) {
        return orderDao.showOrdersByState(state);
    }
}

OrderView

package com.sk.view;
​
import com.sk.dao.CuisineDao;
import com.sk.dao.impl.CuisineDaoImpl;
import com.sk.entity.Cuisine;
import com.sk.entity.Order;
import com.sk.entity.User;
import com.sk.service.CuisineService;
import com.sk.service.OrderService;
import com.sk.service.UserService;
import com.sk.service.impl.CuisineServiceImpl;
import com.sk.service.impl.OrderServiceImpl;
import com.sk.service.impl.UserServiceImpl;
​
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Scanner;
​
/**
 * ClassName: OrderView <br/>
 * Description: <br/>
 * date: 2022/1/4 10:57<br/>
 *
 * @author 斑马<br />
 */
public class OrderView {
    Scanner sc=new Scanner(System.in);
    OrderService orderService=new OrderServiceImpl();
    /**配送订单*/
    public void distribution(){
        //显示所有需要配送的订单
        List<Order> list=orderService.showOrdersByState(1);
        CuisineService service=new CuisineServiceImpl();
        UserService userService=new UserServiceImpl();
        System.out.println("订单编号:\t菜品名称\t菜品单价\t购买数量\t总价\t配送状态\t购买日期\t手机号\t收货地址");
        for (Order o:list){
            //根据菜品编号找到对应的菜品
            Cuisine c=service.showCuisineByCid(o.getcId());
            Date date=o.getDate();
            SimpleDateFormat sm=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String d=sm.format(date);//格式化日期类型
            User user=userService.findUserByTel(o.getTel());
            System.out.println(o.getoId()+"\t"+c.getcName()+"\t"+c.getPrice()+"\t"+o.getNum()
                    +"\t"+o.getSum()+"\t"+"已付款\t"+d+"\t"+user.getTel()+"\t"+user.getAddress()
            );
        }
        //配送单个订单
        System.out.println("请输入配送的订单编号:");
        int oid=sc.nextInt();
        boolean flag= orderService.updateStateById(oid,2);
        if(flag){
            System.out.println("配送成功");
        }else {
            System.out.println("配送失败");
        }
    }
​
}
​

十,整合项目

package com.sk.view;
​
import java.util.Scanner;
​
/**
 * ClassName: View <br/>
 * Description: <br/>
 * date: 2022/1/5 9:00<br/>
 *
 * @author 斑马<br />
 */
public class View {
    Scanner sc=new Scanner(System.in);
    AdminView adminView=new AdminView();
    UserView userView=new UserView();
    public void menu(){
        System.out.println("*************点餐系统**************");
        System.out.println("1.用户界面");
        System.out.println("2.管理员界面");
        int num=sc.nextInt();
        switch (num){
            case 1:
                userView.star();
                break;
            case 2:
                adminView.login();
                break;
            default:
                System.out.println("输入错误!");
                menu();
        }
        System.out.println("是否返回点餐系统界面?y/n");
        String str=sc.next();
        if("y".equals(str)){
            menu();
        }
    }
}
​

十一,效果示意图

 

斑马有点困
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JAVA计算机毕业设计外卖点餐系统（附源码、数据库）
卓杰计算机毕设
10-30 544
Jdk1.8 + Tomcat8.5 + Mysql + HBuilderX（Webstorm也行）+ Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）。JAVA + mybatis + Maven + Vue 等等组成，B/S模式 + Maven管理等等。2. 前端：vue+css+javascript+jQuery+easyUI+highcharts。其他版本理论上也可以。2. 使用IDEA/Eclipse/MyEclipse导入项目，修改配置，运行项目；
Java点餐系统
emptyset的博客
04-08 2051
System.out.printf("%s 点的菜品为：%s，总价为：%.2f 元\n", username, getDishesString(dishes), totalPrice);System.out.println("请输入要点的菜品编号（输入0结束）：");System.out.println("2. 查看菜单");System.out.println("3. 查看订单");System.out.println("1. 点餐");System.out.println("请输入点餐者姓名：");
点餐系统源代码
01-12
点餐系统毕业设计源代码C# 。
点餐系统源码
08-14
实例为Java语言实现点餐系统, 前台为Bootstrap框架, 后台框架为SSH, 数据库使用mysql, 此套点餐系统可以管理餐馆所有业务，包括每日的营收数据， 月度营收数据, 餐桌信息管理，菜谱信息管理以及订单信息管理, 真正实现餐馆线上一键式管理
PHP点餐源码_外卖点餐小程序源码系统（开源搭建文档数据库和毕业开题设计）
最新发布
gikkees的博客
07-18 838
在开发外卖点餐小程序时，技术栈的选择至关重要。UniApp 的优势在于其统一的开发体验，开发者只需编写一套代码，即可实现多平台的适配，极大地提高了开发效率。通过深入了解外卖点餐小程序源码的构成、开发流程、关键技术以及市场前景和发展趋势，我们可以更好地把握这一领域的机遇和挑战，为用户提供更加优质、便捷的服务体验。开发团队需按照设计文档进行编码实现，包括前端界面的开发、后端逻辑的实现以及数据库的搭建等。通过市场调研和用户访谈等方式，了解用户对外卖点餐小程序的需求和期望，明确小程序的功能和性能要求。
外卖点餐系统源码设计（源码+文档+指导）
jiu89u8的博客
06-11 1225
　　外卖点餐系统源码的目的是利用计算机化设备和成熟的计算机软件，使现有的手动系统自动化，以满足其要求，从而能够更长时间地储存其宝贵的数据/信息，便于存取和操作。网上订购系统的主要目的是保持信息追踪，如商品类别、食品、送货地址、订单和购物车。它跟踪关于商品类别、客户、购物车和商品类别的信息。只有管理员才能访问项目，因为它完全是在行政级别构建的。项目的目的是开发软件，减少手动管理物品类别、食品、客户和送货地址的时间。它保存了送货地址、订单和购物车信息。 　　 　　源码及演示：s.ymzan.top 　　 　　概
智能点餐推荐系统+数据库+源码+说明文档
05-23
系统从业务流程的角度上分析，完成了订餐系统的基本功能，可是使得用户通过互联网进行点餐以及交易。相比于以往的订餐方式，网上订餐更加便捷，高效，对于餐厅更加节省人力，有利于管理，对于顾客更加省时省力。 1 ...
[内附完整源码和文档] 基于JSP的网上订餐管理系统的设计与实现
LEMFOooO的博客
08-28 4466
摘 要 随着科学技术与经济的快速发展，网络信息技术也有了显著的提升与进步，当今的社会是一个集数字化，网络化，信息化的，并且是以网络为核心的现代化社会。伴随信息互联网的高速成长，使得互联网应用也走进家家户户的日常生活。网上订餐作为一种新的生活方式，更加新颖。 毕业设计中，界面的设计主要使用了在jsp插入HTML语言以及JavaScript对系统的页面进行相关的加工处理完善以使得页面实现的效果尽可能的满足美观的要求。而对于后台的设计主要是使用了javaSE基础编程，及javaEE中的Jsp页面的动态编程，ser
餐厅点餐系统源码
08-27
该系统利用SSH框架进行设计，页面进过美化
php点餐系统源码
06-02
php点餐系统 源码基于互联网平台 面向全网用户的点餐系统
点餐项目的源码
05-28
简单的项目练习,有需要的留言,包含前端,后端,这是一个写好的项目,包含SQL
点餐系统Java项目源码
11-21
点餐系统源码，以及项目的思路过程，打法都是的方法是实打实的v
点餐管理系统源码
05-22
本课程设计要求完成一个用于饭店的餐饮管理的系统。 功能要求： 针对饭店具体情况，设置点餐，订餐信息； 设置菜谱和价格信息； 人员管理： 用户管理，职称管理，员工管理，员工信息管理； 用餐管理： 用户可以进行点菜、加菜及取消点菜等操作； 消费清单统计 可以实时显示点餐及订餐的情况； 可以对收入情况进行统计 需求分析 一、登录（ 前台服务员 部门经理 收银员 服务员 厨师） 二、 1、前台管理【会员部分没有做】 ①　预定（属性：客人姓名 预定时间 吃饭时间 台号； ②　点菜、加菜（菜单属性：编号菜编号 数量）； ③　结账收银 （账单编号 开台时间 结账时间 顾客编号 结账员工 酒菜清单 应收金额 实收金额* 找零金额*） ④　前台菜单（点菜时间 酒菜编号 台号* 备注） 2、后台管理 ①　设置菜谱 （菜编号 菜名称 分类 单价 ） 填加菜，修改菜， 删除菜 ②　菜种类管理（菜种类编号，菜种类名称）增加菜种类，修改菜种，删除菜种类 ③　收入管理（订单编号 顾客编号 时间 支付金额） ④　用户管理 （用户名，密码，职位编号）增加用户，删除用户，用户信息的修改 ⑤　职位管理（职位类型编号，职位名称）增加职位，删除职位，职位信息的修改 ⑥　员工管理 （员工编号，员工姓名，性别，年龄，身份证号，联系方式，职位编号）增加员工，删除员工，修改员工信息 数据库文件在DB下，附加即可（MS Sql2008）
Java版点餐小程序2022最新版笔记，Springboot+Mysql+Freemarker+Bootstrap+微信小程序实现扫码点餐小程序
编程小石头
03-19 1万+
今天来给大家讲解一个完整的微信小程序点餐项目。java后台+微信小程序实现点餐系统。 第一章，技术选型 1,后台技术选型： JDK8/Java11 Mysql5.7/Mysql8 Spring-boot2.2.4 Spring-data-jpa Lombok Freemarker Bootstrap4.3 Websocket即时通讯 Tomcat服务器 Excel数据的批量导入与导出 2,小程序端技术选型 微信小程序 css3 JavaScript 第二章，效果图 1， 管理后台 .
外卖点餐系统
热门推荐
weixin_44219955的博客
11-28 1万+
傻瓜式外卖点餐系统------(无数据库) tips： 菜品类(菜品id，菜品名，菜品类型，上架时间，单价，月销售，总数量) 管理员类(管理员id，账号，密码) 客户类(客户id，客户名，性别，密码，送餐地址，手机号，创建时间) 订单类(订单号，订单创建时间，菜品id，购买数，客户id，总价格，订单状态) 说明： 菜品类型可自行设计数据类型(int或String)，如1：面食 2：米饭 3：湘菜 … 菜品上架时间、客户创建时间、订单创建时间根据添加时间自动分配系统时间 订单状态类型为int（0:未支
点餐app源码带点餐系统小程序源码PHP全开源
emmymio的博客
02-28 1216
最好的在线订餐系统程序还允许您按照您想要的方式设计和组织餐厅的菜单，允许您自定义外观、命名部分并选择突出显示的菜肴。为您的客户提供通过您的网站订购的方式对他们来说很方便，但也意味着您的收入增加。在您的网站上找到合适的菜单后，您的客户将在那里下订单，而无需离开您的网站。虽然通常不会存储客户的付款信息，但您可以访问有关客户的订单数据，特别是他们的联系信息、他们订购的商品以及他们使用的付款类型。这将为您和您的客户带来更顺畅的订购体验。通过允许客户通过您的系统下自己的订单，您将减少订购错误，至少在您这边是这样。
javase 点餐gui
07-05
Java SE（标准版Java）中的点餐GUI（图形用户界面）通常是用来创建桌面应用程序的一个示例，用于模拟一个餐厅菜单系统。在这种情况下，开发者可能会使用Swing或JavaFX这样的Java GUI库来构建。 下面是构建Java SE...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

斑马有点困

原创不易,多谢打赏

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值