【项目实战】太强大了，Java外卖点餐初级系统【附源码】

谁践踏了优雅 2023-01-09 03:57 109阅读 0赞

## 傻瓜式外卖点餐系统------(无数据库) ##

*tips*：

*  菜品类(菜品id，菜品名，菜品类型，上架时间，单价，月销售，总数量)
 *  管理员类(管理员id，账号，密码)
 *  客户类(客户id，客户名，性别，密码，送餐地址，手机号，创建时间)
 *  订单类(订单号，订单创建时间，菜品id，购买数，客户id，总价格，订单状态)  
    说明：

1.  菜品类型可自行设计数据类型(int或String)，如1：面食 2：米饭 3：湘菜 …
2.  菜品上架时间、客户创建时间、订单创建时间根据添加时间自动分配系统时间
3.  订单状态类型为int（0:未支付 1：已支付 2：配送中 3：已完成）  
    要求实现如下功能：
4.  实现不同角色用户登录系统  
    (1) 管理员登录系统看到如下菜单：  
    ① 添加菜品  
    ② 查看所有菜品信息(包含分页功能)  
    ③ 查看指定类别的菜品信息  
    ④ 根据菜品id修改菜品价格  
    ⑤ 删除指定id的菜品  
    ⑥ 添加客户  
    ⑦ 查看客户列表  
    ⑧ 删除指定id的客户  
    ⑨ 订单列表显示  
    ⑩ 根据订单id修改订单状态  
    11 退出  
    (2) 客户登录看到如下菜单：  
    ① 显示所有菜品(按菜品销量从高到低排序输出)  
    \-------->点餐（输入菜品id和购买数量）  
    ② 根据菜品类别显示所有菜品  
    ③ 查看所有订单(当前登录用户的)  
    ④ 修改密码（当前登录用户的）  
    ⑤ 个人信息显示

以上就是全部要求，首先咱们可以先建一个接口，方便对四个管理类进行操作；

package com.softeem.lesson23.test2;
    
    import java.util.List;
    
    public interface DAO<T> {
    	void insert(T t);
    	T findById(String id);
    	List<T> findAll();
    	void delete(String id);
    }

一、再根据要求，先把四个类的属性类建立起来：  
1.Admin类（管理员类）

package com.softeem.lesson23.test2;
    
    public class Admin {
    	private String aID;
    	private String account;
    	private String apwd;
    	public Admin() {
    		// TODO Auto-generated constructor stub
    	}
    	public Admin(String aID, String account, String apwd) {
    		super();
    		this.aID = aID;
    		this.account = account;
    		this.apwd = apwd;
    	}
    	public String getaID() {
    		return aID;
    	}
    	public void setaID(String aID) {
    		this.aID = aID;
    	}
    	public String getAccount() {
    		return account;
    	}
    	public void setAccount(String account) {
    		this.account = account;
    	}
    	public String getApwd() {
    		return apwd;
    	}
    	public void setApwd(String apwd) {
    		this.apwd = apwd;
    	}
    	@Override
    	public String toString() {
    		return "Admin [aID=" + aID + ", account=" + account + ", apwd=" + apwd + "]";
    	}
    
    }

2.Dishes类（菜品类）

package com.softeem.lesson23.test2;
    
    import java.time.LocalDate;
    
    public class Dishes {
    	private String dID;
    	private String dname;
    	private String dtype;
    	private LocalDate dtime;
    	private double price;
    	private int dsales;
    	private int dstocks;
    
    	public Dishes() {
    		// TODO Auto-generated constructor stub
    	}
    
    	public Dishes(String dID, String dname, String dtype, LocalDate dtime, double price, int dsales, int dstocks) {
    		super();
    		this.dID = dID;
    		this.dname = dname;
    		this.dtype = dtype;
    		this.dtime = dtime;
    		this.price = price;
    		this.dsales = dsales;
    		this.dstocks = dstocks;
    	}
    
    	public String getdID() {
    		return dID;
    	}
    
    	public void setdID(String dID) {
    		this.dID = dID;
    	}
    
    	public String getDname() {
    		return dname;
    	}
    
    	public void setDname(String dname) {
    		this.dname = dname;
    	}
    
    	public String getDtype() {
    		return dtype;
    	}
    
    	public void setDtype(String dtype) {
    		this.dtype = dtype;
    	}
    
    	public LocalDate getDtime() {
    		return dtime;
    	}
    
    	public void setDtime(LocalDate dtime) {
    		this.dtime = dtime;
    	}
    
    	public double getPrice() {
    		return price;
    	}
    
    	public void setPrice(double price) {
    		this.price = price;
    	}
    
    	public int getDsales() {
    		return dsales;
    	}
    
    	public void setDsales(int dsales) {
    		this.dsales = dsales;
    	}
    
    	public int getDstocks() {
    		return dstocks;
    	}
    
    	public void setDstocks(int dstocks) {
    		this.dstocks = dstocks;
    	}
    
    	@Override
    	public String toString() {
    		return "Dishes [菜品id：" + dID + ", 菜品名：" + dname + ", 菜品类型：" + dtype + ", 上架时间：" + dtime + ", 单价：" + price
    				+ ", 月销量：" + dsales + ", 总数量：" + dstocks + "]";
    	}
    
    }

3.Order类（订单类）

package com.softeem.lesson23.test2;
    
    import java.time.LocalDateTime;
    
    public class Order {
    	private String OrderID;
    	private LocalDateTime utime;
    	private Dishes dishes;
    	private int Ordernum;
    	private String uID;
    	private Double Orderprice;
    	private int OrderValue;
    
    	public Order() {
    		// TODO Auto-generated constructor stub
    	}
    
    	public Order(String orderID, LocalDateTime utime, Dishes dishes, int ordernum, String uID, Double orderprice,
    			int orderValue) {
    		super();
    		OrderID = orderID;
    		this.utime = utime;
    		this.dishes = dishes;
    		Ordernum = ordernum;
    		this.uID = uID;
    		Orderprice = orderprice;
    		OrderValue = orderValue;
    	}
    
    	public String getOrderID() {
    		return OrderID;
    	}
    
    	public void setOrderID(String orderID) {
    		OrderID = orderID;
    	}
    
    	public LocalDateTime getUtime() {
    		return utime;
    	}
    
    	public void setUtime(LocalDateTime utime) {
    		this.utime = utime;
    	}
    
    	public Double getOrderprice() {
    		return Orderprice;
    	}
    
    	public void setOrderprice(Double orderprice) {
    		Orderprice = orderprice;
    	}
    
    	public Dishes getDishes() {
    		return dishes;
    	}
    
    	public void setDishes(Dishes dishes) {
    		this.dishes = dishes;
    	}
    
    	public int getOrdernum() {
    		return Ordernum;
    	}
    
    	public void setOrdernum(int ordernum) {
    		Ordernum = ordernum;
    	}
    
    	public String getuID() {
    		return uID;
    	}
    
    	public void setuID(String uID) {
    		this.uID = uID;
    	}
    
    	public int getOrderValue() {
    		return OrderValue;
    	}
    
    	public void setOrderValue(int orderValue) {
    		OrderValue = orderValue;
    	}
    
    	@Override
    	public String toString() {
    		return "Order [OrderID=" + OrderID + ", utime=" + utime + ", dishes=" + dishes + ", Ordernum=" + Ordernum
    				+ ", uID=" + uID + ", Orderprice=" + Orderprice + ", OrderValue=" + OrderValue + "]";
    	}
    
    }

4.User类（用户类）

package com.softeem.lesson23.test2;
    
    import java.time.LocalDateTime;
    
    public class User {
    	private String uID;
    	private String uname;
    	private String usex;
    	private String upwd;
    	private String uadress;
    	private String utel;
    	private LocalDateTime utime;
    
    	public User() {
    		// TODO Auto-generated constructor stub
    	}
    
    	public User(String uID, String uname, String usex, String upwd, String uadress, String utel, LocalDateTime utime) {
    		super();
    		this.uID = uID;
    		this.uname = uname;
    		this.usex = usex;
    		this.upwd = upwd;
    		this.uadress = uadress;
    		this.utel = utel;
    		this.utime = utime;
    	}
    
    	public String getuID() {
    		return uID;
    	}
    
    	public void setuID(String uID) {
    		this.uID = uID;
    	}
    
    	public String getUname() {
    		return uname;
    	}
    
    	public void setUname(String uname) {
    		this.uname = uname;
    	}
    
    	public String getUsex() {
    		return usex;
    	}
    
    	public void setUsex(String usex) {
    		this.usex = usex;
    	}
    
    	public String getUpwd() {
    		return upwd;
    	}
    
    	public void setUpwd(String upwd) {
    		this.upwd = upwd;
    	}
    
    	public String getUadress() {
    		return uadress;
    	}
    
    	public void setUadress(String uadress) {
    		this.uadress = uadress;
    	}
    
    	public String getUtel() {
    		return utel;
    	}
    
    	public void setUtel(String utel) {
    		this.utel = utel;
    	}
    
    	public LocalDateTime getUtime() {
    		return utime;
    	}
    
    	public void setUtime(LocalDateTime utime) {
    		this.utime = utime;
    	}
    
    	@Override
    	public String toString() {
    		return "User [uID=" + uID + ", uname=" + uname + ", usex=" + usex + ", upwd=" + upwd + ", uadress=" + uadress
    				+ ", utel=" + utel + ", utime=" + utime + "]";
    	}
    
    }

这一步没什么难度，直接把每一个属性都设置一下，然后设置为私有，**注意属性的数据类型**，这个很重要，方便后期管理类对其进行操作。  
二、属性管理类  
这个是整个demo比较难得地方，我的想法是建立Admin属性管理类，Order属性管理类，Dishes属性类，User属性管理类，再在Admin属性管理类里把Order属性管理类，Dishes属性类，User属性管理类先new出来，然后，每个属性管理类实现各自的方法，只需要在Admin属性管理类中调用各个属性管理类的方法，就可以实现通过Admin类管理其他类的数据，但是，每个类需要建一个Map集合，存储各自的元素，**此处应该注意每个属性管理类Map的键**方便后期对Map进行操作，然后建立菜单类，规定User和Admin能调用的方法。  
话不多说，直接上代码，一下代码是通过Admin管理类延伸的，所以先看Admin管理类。  
1.Admin管理类

package com.softeem.lesson23.test2;
    
    import java.time.LocalDate;
    import java.time.LocalDateTime;
    //import java.util.ArrayList;
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Scanner;
    //import java.util.Set;
    
    public class AdminSys implements DAO<Admin> {
    	static Map<String, Admin> map = new HashMap<>();
    //	static Set<String> keys = map.keySet();
    	UserSys u = new UserSys();
    	OrderSys o = new OrderSys();
    	DishesSys d = new DishesSys();
    	Scanner sc = new Scanner(System.in);
    
    	/**
    	 * 添加菜品
    	 */
    	public void addDishes() {
    		System.out.println("请输入您要添加的菜品:(按照:菜品ID/菜品名/菜品类型/单价/月销量/总数量)");
    		String str = sc.next();
    		String[] info = str.split("/");
    		//
    		if (info.length < 6) {
    			System.out.println("天啦撸，输入失败啦，请重新输入！");
    			addDishes();
    		} else {
    			LocalDate dtime = LocalDate.now();
    			Dishes t = new Dishes(info[0], info[1], info[2], dtime, Double.parseDouble(info[3]),
    					Integer.parseInt(info[4]), Integer.parseInt(info[5]));
    			d.insert(t);
    			System.out.println("小主,恭喜你！添加成功了");
    		}
    	}
    
    	/**
    	 * 查看所有菜品信息(包含分页功能)
    	 */
    	public void showAllDishes(int pageSize) {
    		List<Dishes> list = d.findAll();
    		int start = 0;
    		//先写一个死循环，进入else后break掉
    		while (true) {
    			if (list.size() > (pageSize + start)) {
    				System.out.println(list.subList(start, pageSize + start));
    
    			} else {
    				System.out.println(list.subList(start, list.size()));
    				break;
    			}
    			start = start + pageSize;
    		}
    	}
    
    	/**
    	 * 查看指定类别的菜品信息
    	 * 
    	 */
    	public void selecBytypeOfAdmin() {
    		System.out.println("请输入您要查询菜品的类别：");
    		String typename = sc.next();
    		d.selectBytype(typename);
    	}
    
    	/**
    	 * 根据菜品id修改菜品价格
    	 */
    	public void selectByDishesID() {
    		System.out.println("请输入您要查询的菜品id：");
    		String id = sc.next();
    		Dishes dish = d.findById(id);
    		if (dish == null) {
    			System.out.println("没有当前id的菜品呢");
    		} else {
    			System.out.println("当前菜品为：" + dish);
    			System.out.println("请输入新的菜品单价：");
    			double newprice = sc.nextDouble();
    			Dishes t = new Dishes(dish.getdID(), dish.getDname(), dish.getDtype(), dish.getDtime(), newprice,
    					dish.getDsales(), dish.getDstocks());
    			d.insert(t);
    			System.out.println("修改成功" + d.findById(t.getdID()));
    		}
    	}
    
    	/**
    	 * 删除指定id的菜品
    	 * 
    	 * @param args
    	 */
    	public void deleteDishes() {
    		System.out.println("请输入您要删除的菜品id");
    		String id = sc.next();
    		d.delete(id);
    		System.out.println("删除成功！！");
    	}
    
    	/**
    	 * 添加客户
    	 */
    	public void addUser() {
    		System.out.println("请输入您要添加的用户:按照(id/姓名/性别/密码/送餐地址/手机号)");
    		String str = sc.next();
    		String[] info = str.split("/");
    		if (info.length < 6) {
    			System.out.println("您输入的信息有误，请重新输入....");
    			addUser();
    		} else {
    			LocalDateTime utime = LocalDateTime.now();
    			u.insert(new User(info[0], info[1], info[2], info[3], info[4], info[5], utime));
    			System.out.println("添加成功");
    		}
    	}
    
    	/**
    	 * 查看客户列表
    	 */
    	public void findUser() {
    		List<User> userlist = u.findAll();
    		for (User user : userlist) {
    			System.out.println(user);
    		}
    	}
    
    	/**
    	 * 根据id查找指定用户
    	 */
    	public User findUserByid(String id) {
    		return u.findById(id);
    	}
    
    	/**
    	 * 删除指定id的客户
    	 */
    	public void deleteUserByAdmin() {
    		System.out.println("请输入您要删除的id：");
    		String id = sc.next();
    		u.delete(id);
    	}
    
    	/**
    	 * 订单列表显示
    	 */
    	public void showAllOrder() {
    		List<Order> allOrder = o.findAll();
    		for (Order order : allOrder) {
    			System.out.println(order);
    		}
    	}
    
    	/**
    	 * 根据订单id修改订单状态
    	 */
    	public void changeOrderValue() {
    		System.out.println("请输入您要修改状态的订单id");
    		String id = sc.next();
    		Order order = o.findById(id);
    		if (order == null) {
    			System.out.println("没有当前id的订单，请检查输入");
    		} else {
    			System.out.println("已找到当前id订单" + order);
    			System.out.println("请输入您要修改的状态：0:未支付 1：已支付 2：配送中 3：已完成");
    			int value = sc.nextInt();
    			Order t = new Order(order.getOrderID(), order.getUtime(), order.getDishes(), order.getOrdernum(),
    					order.getuID(), order.getOrderprice(), value);
    			o.insert(t);
    			System.out.println("修改成功了！！！");
    		}
    
    	}
    	/**
    	 * 显示所有菜品(按菜品销量从高到低排序输出)
    	 */
    	public void showAllDishesByUser() {
    		List<Dishes> list = d.findAll();
    		Collections.sort(list, (p1, p2) -> p1.getDsales() - p2.getDsales());
    		System.out.println(list);
    	}
    
    	/**
    	 * 点餐（输入菜品id和购买数量）
    	 */
    	public void shopDishes(User user) {
    		showAllDishesByUser();
    		System.out.println("请输入您要购买的id和数量：按照(id/数量)");
    		String str = sc.next();
    		String[] info = str.split("/");
    		// 判断输入是否符合要求，不符合则要求重新输入
    		if (info.length < 2) {
    			System.out.println("输入有误，请重新输入：");
    			shopDishes(user);
    		} else {
    			LocalDateTime l = LocalDateTime.now();
    			// String orderID, LocalDateTime utime, Dishes dishes, int ordernum, String uID,
    			// Double orderprice,int orderValue
    			Order t = new Order(info[0], l, d.findById(info[0]), Integer.parseInt(info[1]), user.getuID(),
    					o.findById(info[0]).getOrderprice(), o.findById(info[0]).getOrderValue());
    			o.insert(t);
    			System.out.println("订单已生成！！！" + o.findById(info[0]));
    		}
    	}
    
    	/**
    	 * 根据菜品类别显示所有菜品
    	 */
    	public void ShowOfTypeByUser() {
    		System.out.println("请输入您要查找的类别：");
    		String str = sc.next();
    		System.out.println(d.findByType(str));
    
    	}
    
    	/**
    	 * 查看所有订单(当前登录用户的)
    	 */
    	public void showAllOrderByUser(User user) {
    		List<Order> list = o.findByuId(user.getuID());
    		for (Order order : list) {
    			System.out.println(order);
    		}
    	}
    
    	/**
    	 * 修改密码（当前登录用户的）
    	 */
    	public void changePwdByUser(User user) {
    		u.changepwd(user.getuID());
    		System.out.println("修改成功！！");
    	}
    
    	/**
    	 * 个人信息显示
    	 */
    	public void showByUser(User user) {
    		User findById = u.findById(user.getuID());
    		System.out.println(findById);
    	}
       //待补充功能，删除管理员
    	@Override
    	public void delete(String id) {
    
    	}
      //待补充功能，添加管理员
    	@Override
    	public void insert(Admin t) {
    		// TODO Auto-generated method stub
    
    	}
      //待补充功能，通过id即账号查找管理员
    	@Override
    	public Admin findById(String id) {
    
    		return map.get(id);
    	}
      //待补充功能，显示所有管理员
    	@Override
    	public List<Admin> findAll() {
    		// TODO Auto-generated method stub
    		return null;
    	}
         //先设置系统默认数据
    	public void addMessage() {
    		map.put("qwl", new Admin("10086", "qwl", "123456"));
    		LocalDate time = LocalDate.now();
    		Dishes d1 = new Dishes("1", "红烧猪蹄", "肉类", time, 12.5, 20, 30);
    		d.insert(d1);
    		Dishes d2 = new Dishes("2", "鸡公煲", "肉类", time, 21.5, 30, 20);
    		d.insert(d2);
    		Dishes d3 = new Dishes("3", "麻辣香锅", "火锅类", time, 30, 5, 10);
    		d.insert(d3);
    		Dishes d4 = new Dishes("4", "水煮肉片", "肉类", time, 15, 12, 15);
    		d.insert(d4);
    		Dishes d5 = new Dishes("5", "水果沙拉", "水果类", time, 6, 70, 60);
    		d.insert(d5);
    		// String orderID, LocalDateTime utime, Dishes dishes, int ordernum, String uID,
    		// Double orderprice,int orderValue
    		LocalDateTime localdatetime = LocalDateTime.now();
    		Order o1 = new Order("1", localdatetime, d1, 10, "1001", 60.0, 1);
    		o.insert(o1);
    		Order o2 = new Order("2", localdatetime, d2, 5, "1002", 50.0, 10);
    		o.insert(o2);
    		Order o3 = new Order("3", localdatetime, d3, 5, "1003", 40.0, 5);
    		o.insert(o3);
    		Order o4 = new Order("4", localdatetime, d4, 5, "1004", 30.0, 6);
    		o.insert(o4);
    		Order o5 = new Order("5", localdatetime, d5, 5, "1005", 20.0, 8);
    		o.insert(o5);
    		// String uID, String uname, String usex, String upwd, String uadress, String
    		// utel, LocalDateTime utime
    		User u1 = new User("1001", "张三", "男", "123456", "湖北", "13545286487", localdatetime);
    		u.insert(u1);
    		User u2 = new User("1002", "李四", "男", "234567", "湖南", "15927948976", localdatetime);
    		u.insert(u2);
    		User u3 = new User("1003", "王五", "男", "345678", "江苏", "15927986854", localdatetime);
    		u.insert(u3);
    		User u4 = new User("1004", "刘柳", "女", "456789", "浙江", "18771580860", localdatetime);
    		u.insert(u4);
    		User u5 = new User("1005", "赵琦", "女", "567890", "新疆", "18771580750", localdatetime);
    		u.insert(u5);
    	}
    
    }

2.Order属性管理类

package com.softeem.lesson23.test2;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Objects;
    import java.util.Set;
    
    public class OrderSys implements DAO<Order> {
    	static Map<String, Order> ordermap = new HashMap<>();
    	static List<Order> orderlist = new ArrayList<>();
    	/**
    	 * 新增订单
    	 */
    	@Override
    	public void insert(Order t) {
    		ordermap.put(t.getOrderID(), t);
    
    	}
    	/**
    	 * 通过订单id查找订单
    	 */
    	@Override
    	public Order findById(String id) {
    		if (ordermap.get(id) == null) {
    			return null;
    		} else {
    			return ordermap.get(id);
    		}
    
    	}
    	/**
    	 * 通过用户id查询用户的所有订单，并返回一个list集合
    	 * @param uid
    	 * @return
    	 */
    	public List<Order> findByuId(String uid) {
    		List<Order> list = new ArrayList<>();
    		Set<String> keys = ordermap.keySet();
    		for (String key : keys) {
    			if (Objects.equals(uid, ordermap.get(key).getuID())) {
    				list.add(ordermap.get(key));
    			}
    		}
    		return list;
    	}
    
    	/**
    	 * 显示所有订单
    	 */
    	@Override
    	public List<Order> findAll() {
    		Set<String> keys = ordermap.keySet();
    		for (String key : keys) {
    			orderlist.add(ordermap.get(key));
    		}
    		return orderlist;
    	}
    	/**
    	 * 待完成功能，删除订单
    	 */
    	@Override
    	public void delete(String id) {
    		// TODO Auto-generated method stub
    
    	}
    }

3.User属性管理类

package com.softeem.lesson23.test2;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Scanner;
    import java.util.Set;
    
    //客户id，客户名，性别，密码，送餐地址，手机号，创建时间
    public class UserSys implements DAO<User> {
    	static Map<String, User> usermap = new HashMap<>();
    	List<User> list = new ArrayList<>();
    	Scanner sc = new Scanner(System.in);
    
    	/**
    	 * 添加客户
    	 */
    	@Override
    	public void insert(User t) {
    		usermap.put(t.getuID(), t);
    
    	}
    
    	/**
    	 * 查看客户列表
    	 */
    	@Override
    	public List<User> findAll() {
    		Set<String> keys = usermap.keySet();
    		for (String str : keys) {
    			list.add(usermap.get(str));
    		}
    		return list;
    	}
    
    	/**
    	 * 删除指定id的客户
    	 */
    	@Override
    	public void delete(String id) {
    		if (usermap.get(id) == null) {
    			System.out.println("没有当前id的客户");
    		} else {
    			System.out.println(usermap.get(id) + "已删除！！！");
    			usermap.remove(id);
    		}
    
    	}
    
    	/**
    	 * 修改密码（当前登录用户的）
    	 */
    	public void changepwd(String id) {
    		User user = findById(id);
    		System.out.println("请输入新密码：");
    		String str = sc.next();
    		User t = new User(user.getuID(), user.getUname(), user.getUsex(), str, user.getUadress(), user.getUtel(),
    				user.getUtime());
    		usermap.put(id, t);
    
    	}
    
    	/**
    	 * 通过id查找对应客户
    	 */
    	@Override
    	public User findById(String id) {
    		if (usermap.get(id) == null) {
    			return null;
    		} else {
    			return usermap.get(id);
    		}
    
    	}
    
    }

4.Dishes属性管理类

package com.softeem.lesson23.test2;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Objects;
    import java.util.Set;
    
    public class DishesSys implements DAO<Dishes> {
    	// 建立一个菜品的map集合，其中菜品的id为map的键，整个菜品对象为map的值
    	static Map<String, Dishes> dishesmap = new HashMap<>();
    	Set<String> keys = dishesmap.keySet();
    
    	/**
    	 * 添加菜品
    	 */
    	@Override
    	public void insert(Dishes t) {
    		dishesmap.put(t.getdID(), t);
    
    	}
    
    	/**
    	 * 通过id来寻找菜品
    	 */
    
    	@Override
    	public Dishes findById(String id) {
    		if (dishesmap.get(id) == null) {
    			return null;
    		} else {
    			return dishesmap.get(id);
    		}
    	}
    
    	/**
    	 * 根据菜品类型查找菜品
    	 */
    	public List<Dishes> findByType(String type) {
    		List<Dishes> list = new ArrayList<>();
    		for (String key : keys) {
    			if (Objects.equals(type, dishesmap.get(key).getDtype())) {
    				list.add(dishesmap.get(key));
    			}
    
    		}
    		return list;
    	}
    
    	/**
    	 * 查询所有菜品
    	 */
    	@Override
    	public List<Dishes> findAll() {
    		List<Dishes> list = new ArrayList<>();
    
    		for (String str : keys) {
    			list.add(dishesmap.get(str));
    		}
    		return list;
    	}
    
    	public void selectBytype(String typename) {
    		int count = 0;
    		for (String key : keys) {
    			if (Objects.equals(dishesmap.get(key).getDtype(), typename)) {
    				System.out.println(dishesmap.get(key));
    				count++;
    			}
    		}
    		if (count == 0) {
    			System.out.println("没有当前类别的菜品！");
    		}
    	}
    
    	/**
    	 * 删除指定id菜品
    	 */
    	@Override
    	public void delete(String id) {
    		if (dishesmap.get(id) == null) {
    			System.out.println("输入id错误...");
    		} else {
    			dishesmap.remove(id);
    		}
    
    	}
    }

以上基本就是代码的核心部分，剩下的部分就简化很多了，建立一个菜单类，分别对其进行不同调用就行了  
三、菜单类

package com.softeem.lesson23.test2;
    
    import java.util.Objects;
    import java.util.Scanner;
    
    public class Menu {
    	static AdminSys admin = new AdminSys();
    	Scanner sc = new Scanner(System.in);
    
    	public void showMenu() {
    		admin.addMessage();
    
    		System.out.println("请输入账号和密码：按照(账号/密码)");
    		String str = sc.next();
    		String[] info = str.split("/");
    		if (info.length < 2) {
    			System.out.println("输入有误，请重新输入：");
    			showMenu();
    		} else {
    			if (admin.findById(info[0]) != null && Objects.equals(admin.findById(info[0]).getApwd(), info[1])) {
    				adminMenu();
    			} else if (admin.findUserByid(info[0]) != null
    					&& Objects.equals(info[1], admin.findUserByid(info[0]).getUpwd())) {
    				User user = admin.findUserByid(info[0]);
    				userMenu(user);
    			} else {
    				System.out.println("输入有误，请重新输入....");
    				showMenu();
    			}
    		}
    
    	}
    
    	public void userMenu(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("====【6】退出==================");
    		System.out.println("请输入您要进行的操作：");
    		String n = sc.next();
    		switch (n) {
    		case "1":
    			admin.shopDishes(user);
    			userMenu(user);
    			break;
    		case "2":
    			admin.ShowOfTypeByUser();
    			userMenu(user);
    			break;
    		case "3":
    			admin.showAllOrderByUser(user);
    			userMenu(user);
    			break;
    		case "4":
    			admin.changePwdByUser(user);
    			userMenu(user);
    			break;
    		case "5":
    			admin.showByUser(user);
    			userMenu(user);
    			break;
    		case "6":
    			System.out.println("谢谢使用，再见！");
    			System.exit(0);
    		default:
    			System.out.println("输入错误，请重新输入：");
    			userMenu(user);
    		}
    	}
    
    	public void adminMenu() {
    		System.out.println("=========欢迎您尊贵的管理员=======");
    		System.out.println("====【1】添加菜品===============");
    		System.out.println("====【2】查看所有菜品信息显示=======");
    		System.out.println("====【3】查看指定类别的菜品信息=====");
    		System.out.println("====【4】根据菜品id修改菜品价格=====");
    		System.out.println("====【5】删除指定id的菜品=========");
    		System.out.println("====【6】添加客户================");
    		System.out.println("====【7】查看客户列表=============");
    		System.out.println("====【8】删除指定id的用户==========");
    		System.out.println("====【9】订单列表显示=============");
    		System.out.println("====【10】根据订单id修改订单状态====");
    		System.out.println("====【11】退出=================");
    		String m = sc.next();
    		switch (m) {
    		case "1":
    			admin.addDishes();
    			adminMenu();
    			break;
    		case "2":
    			System.out.println("请输入您需要每行显示多少数据：");
    			int pageSize = sc.nextInt();
    			admin.showAllDishes(pageSize);
    			adminMenu();
    			break;
    		case "3":
    			admin.selecBytypeOfAdmin();
    			adminMenu();
    			break;
    		case "4":
    			admin.selectByDishesID();
    			adminMenu();
    			break;
    		case "5":
    			admin.deleteDishes();
    			adminMenu();
    			break;
    		case "6":
    			admin.addUser();
    			adminMenu();
    			break;
    		case "7":
    			admin.findUser();
    			adminMenu();
    			break;
    		case "8":
    			admin.deleteUserByAdmin();
    			adminMenu();
    			break;
    		case "9":
    			admin.showAllOrder();
    			adminMenu();
    			break;
    		case "10":
    			admin.changeOrderValue();
    			adminMenu();
    			break;
    		case "11":
    			System.out.println("谢谢使用，再见！");
    			System.exit(0);
    			break;
    		default:
    			System.out.println("输入错误，请重新输入：");
    			adminMenu();
    		}
    	}
    }

这里switch采取String（jdk1.7以后才支持）可以让用户就算输入错误也不会报错导致程序运行终止，又要重新输入（我摊牌了，就是懒）。  
四、测试类

package com.softeem.lesson23.test2;
    
    public class Test {
    	public static void main(String[] args) {
    		Menu m = new Menu();
    		m.showMenu();
    	}
    }

五、实现部分界面截图  
![在这里插入图片描述][ecae783f95a529549ecb7ff1ed7ea0df.png]

![在这里插入图片描述][0cd28db8392ed6d1651a5a378a1d816e.png]

![在这里插入图片描述][fbf43922ef55fd263017aaa5c76d551f.png]

![在这里插入图片描述][7f07713498e81f1b9015d26cf0ce0ebe.png]

![在这里插入图片描述][5dda6e9a4420330651dcde9adfd425a0.png]

![在这里插入图片描述][03380ede9b66d202d4ea9605c699a85f.png]

![在这里插入图片描述][0765c4cad876d346fed2aba0c32fd9f1.png]

![在这里插入图片描述][36303b562b063657bbcc8e2fdd10d49e.png]

以上就是全部代码。

### 项目推荐： ###

**[2000多G的计算机各行业电子资源分享（持续更新）][2000_G]**

**[2020年微信小程序全栈项目之喵喵交友【附课件和源码】][2020]**

**[Spring Boot开发小而美的个人博客【附课件和源码】][Spring Boot]**

**[Java微服务实战296集大型视频-谷粒商城【附代码和课件】][Java_296_-]**

**[Java开发微服务畅购商城实战【全357集大项目】-附代码和课件][Java_357_-]**

**[最全最详细数据结构与算法视频-【附课件和源码】][-]**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70_pic_center]

[ecae783f95a529549ecb7ff1ed7ea0df.png]: https://img-blog.csdnimg.cn/img_convert/ecae783f95a529549ecb7ff1ed7ea0df.png
[0cd28db8392ed6d1651a5a378a1d816e.png]: /images/20221119/02ba2eead22f48d8a479dd708d917f32.png
[fbf43922ef55fd263017aaa5c76d551f.png]: /images/20221119/30592f31b0004379949fe270ab0b2632.png
[7f07713498e81f1b9015d26cf0ce0ebe.png]: /images/20221119/8b40c2f36c9f4653b9ab47575560d761.png
[5dda6e9a4420330651dcde9adfd425a0.png]: /images/20221119/9b512608014b4c76806ee278a8577a66.png
[03380ede9b66d202d4ea9605c699a85f.png]: /images/20221119/b51a65fd632b414c842c2d0b06ff1cdc.png
[0765c4cad876d346fed2aba0c32fd9f1.png]: /images/20221119/c6e9a562862348e0b15182bbe954cffd.png
[36303b562b063657bbcc8e2fdd10d49e.png]: /images/20221119/0853e464fd66483d86c8c6cd47f415f6.png
[2000_G]: https://mp.weixin.qq.com/s/sP4JgGWkCzpgwKr9sAV2_Q
[2020]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487704&idx=1&sn=5f4b2127c4d49fd07ae072a0721424a2&chksm=e8036fc2df74e6d489c4aa9b06f917ef7cee6027f13e150fca53cf79d5d188d4ccc1af49e098&scene=21#wechat_redirect
[Spring Boot]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487798&idx=2&sn=ac0293b996521b872a9dba5fbb3e65e6&chksm=e8036e2cdf74e73aba104a9a994a5b2e31483e8dcbe0f1d9936f6d5173b887e1560f59d2819c&scene=21#wechat_redirect
[Java_296_-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487674&idx=1&sn=7aff0bdf2bb727303f3d3618995aef21&chksm=e8036fa0df74e6b6d872c7e6ece179c524ed463a4a6b74c96875475c9a3d5ddb903427dd993b&scene=21#wechat_redirect
[Java_357_-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247486376&idx=1&sn=d1fef270c463ea8ac663f6fbfedd70a0&chksm=e80374b2df74fda4d3bafba878a106a19e18c5fcda266008f4f37975847a21bc612ffcd5ff39&scene=21#wechat_redirect
[-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487750&idx=1&sn=747bccbb5f5ea6b58915198de40da777&chksm=e8036e1cdf74e70ae97a5e8e265b49d7236d904d291203309159d07ba1724033062c0e370843&scene=21#wechat_redirect
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70_pic_center]: /images/20221119/5f71f32463d04d7ab2682deee350afd3.png