外卖点餐系统

最新推荐文章于 2023-05-28 15:35:39 发布
最新推荐文章于 2023-05-28 15:35:39 发布
阅读量172 收藏
点赞数
原文链接：https://blog.csdn.net/weixin_44219955/article/details/110260435?utm_medium=distribute.pc_category.none-task-blog-hot-7.nonecase&depth_1-utm_source=distribute.pc_category.none-task-blog-hot-7.nonecase
版权

外卖系统 菜品管理 订单管理 用户管理 无数据库
关键词由CSDN通过智能技术生成
  • 傻瓜式外卖点餐系统------(无数据库)
    tips：

菜品类(菜品id，菜品名，菜品类型，上架时间，单价，月销售，总数量)
管理员类(管理员id，账号，密码)
客户类(客户id，客户名，性别，密码，送餐地址，手机号，创建时间)
订单类(订单号，订单创建时间，菜品id，购买数，客户id，总价格，订单状态)
说明：
菜品类型可自行设计数据类型(int或String)，如1：面食 2：米饭 3：湘菜 …
菜品上架时间、客户创建时间、订单创建时间根据添加时间自动分配系统时间
订单状态类型为int（0:未支付 1：已支付 2：配送中 3：已完成）
要求实现如下功能：
实现不同角色用户登录系统
(1) 管理员登录系统看到如下菜单：
① 添加菜品
② 查看所有菜品信息(包含分页功能)
③ 查看指定类别的菜品信息
④ 根据菜品id修改菜品价格
⑤ 删除指定id的菜品
⑥ 添加客户
⑦ 查看客户列表
⑧ 删除指定id的客户
⑨ 订单列表显示
⑩ 根据订单id修改订单状态
11 退出
(2) 客户登录看到如下菜单：
① 显示所有菜品(按菜品销量从高到低排序输出)
-------->点餐（输入菜品id和购买数量）
② 根据菜品类别显示所有菜品
③ 查看所有订单(当前登录用户的)
④ 修改密码（当前登录用户的）
⑤ 个人信息显示
以上就是全部要求，首先咱们可以先建一个接口，方便对四个管理类进行操作；

package com.softeem.lesson23.test2;

import java.util.List;

public interface DAO {
void insert(T t);
T findById(String id);
List findAll();
void delete(String id);
}

1
2
3
4
5
6
7
8
9
10
11
一、再根据要求，先把四个类的属性类建立起来：
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 + “]”;
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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 + "]";
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
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 + "]";
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
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 + "]";
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
这一步没什么难度，直接把每一个属性都设置一下，然后设置为私有，注意属性的数据类型，这个很重要，方便后期管理类对其进行操作。
二、属性管理类
这个是整个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 {
static Map<String, Admin> map = new HashMap<>();
// static Set 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 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);
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
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 {
static Map<String, Order> ordermap = new HashMap<>();
static List 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

}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
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 {
static Map<String, User> usermap = new HashMap<>();
List 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);
	}

}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
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 {
// 建立一个菜品的map集合，其中菜品的id为map的键，整个菜品对象为map的值
static Map<String, Dishes> dishesmap = new HashMap<>();
Set 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);
	}

}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
以上基本就是代码的核心部分，剩下的部分就简化很多了，建立一个菜单类，分别对其进行不同调用就行了
三、菜单类

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();
	}
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
这里switch采取String（jdk1.7以后才支持）可以让用户就算输入错误也不会报错导致程序运行终止，又要重新输入（我摊牌了，就是懒）。
四、测试类

package com.softeem.lesson23.test2;

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

1
2
3
4
5
6
7
8
9
五、实现部分界面截图
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
以上就是全部代码。

暴躁的阿姐³
关注
基于JAVA的外卖点餐系统
QQ346127357的博客
02-23 316
整个外卖系统采用的是ssm框架技术，以JAVA作为编程语言，参考现有市场比较完善外卖系统，开发的一个适用于山大商院师生使用的网上外卖订餐系统，本系统主要实现了订餐用户的基本订餐需求以及管理人员的后台数据管理需求，为解决就餐时段排长队的问题起到了很大作用，同时也给师生能够按时就餐带去了福音。本文提出了基于JAVA的外卖系统，该系统可以改善缓解山大商院师生的就餐问题，提供就餐效率。7.商院外卖系统的测试和维护 12。4.商院外卖系统概要设计 3。7.3 系统维护 13。
Java外卖点餐系统-毕业设计
qq_41606417的博客
04-04 842
前后端分离的外卖点餐订餐系统、校园点餐、骑手配送，有用户端、骑手端和商家端，基于SpringBoot+Vue，Java、SSM。
Java实训项目-外卖点餐系统（部分步骤，完整版已发布）
qq_70311894的博客
05-16 955
Java实训项目-外卖点餐系统
年轻人不讲武德，where 1=1 是什么鬼？
欢迎关注公众号：【码农突围】，回复9999，可以获取一份LeetCode刷题笔记
12-03 429
点击上方“码农突围”，马上关注这里是码农充电第一站，回复“666”，获取一份专属大礼包真爱，请设置“星标”或点个“在看”来源：cloud.tencent.com/developer/ar...
宿递大学生食堂外卖点餐系统 （基于LayUI + SSM的前后台一体外卖点餐系统）.zip
05-08
宿递大学生食堂外卖点餐系统 （基于LayUI + SSM的前后台一体外卖点餐系统） 宿递大学生食堂外卖点餐系统 （基于LayUI + SSM的前后台一体外卖点餐系统） 宿递大学生食堂外卖点餐系统 （基于LayUI + SSM的前后台一体...
Java毕业设计：外卖点餐系统（springboot+vue+vant+element-ui）.zip
05-03
Java毕业设计：外卖点餐系统（springboot+vue+vant+element-ui） Java毕业设计：外卖点餐系统（springboot+vue+vant+element-ui） Java毕业设计：外卖点餐系统（springboot+vue+vant+element-ui） Java毕业设计：...
毕设项目——基于SSM的大学生食堂外卖点餐系统（内含搭建流程）
05-04
大学生食堂外卖点餐系统，食堂管理员管理菜品、类别，配送管理，优惠劵发放，投诉查看、数据统计等。学生用户浏览菜单（图文）、地址管理、查看购物车，外卖配送情况。管理员负责一些系统基础数据的维护。是一个类似...
基于微信小程序外卖点餐系统的设计与实现.rar(毕业设计论文+程序源码)
03-13
1.2系统开发背景 1.3系统开发意义 第2章 相关技术介绍及系统环境开发 2.1 相关技术介绍 2.2 系统环境开发条件 第3章 需求分析 3.1 可行性分析 3.1.1技术性 3.1.2经济性 3.1.3操作性 3.2需求分析 第4章 系统...
java开发毕业设计-基于SpringBoot+Vue的外卖点餐系统源码+数据库
04-23
外卖点餐系统，主要包括管理员、用户、商家、骑手四个用户角色，对于用户角色不同，所使用的功能模块相应不同。 管理员；首页、个人中心、用户管理、商家管理、菜品分类管理、骑手管理、系统管理、菜品管理、订单...
Java外卖系统
04-24
一个简单的java外卖系统，包含前后台页面 前台首页/userLogin.jsp 后台首页/adminLogin.jsp
java点餐系统
03-01
java点餐系统，基于tomcat+sqlservice实现
基于java的点餐系统
05-25
点餐管理系统，使用Java语言编写，sql存储，sql使用视图、触发器、存储过程等。
基于Java+SpringBoot+Vue+ElementUI的外卖点餐系统
不懂代码的胖子Q的博客
05-28 558
随着人们生活习惯的变更，使用线上点餐的频率越来越高，外卖点餐系统逐渐成为生活中不可或缺的一部分。为此移动端的外卖点餐系统是解决实际生活需求的一个重要工具。
小项目，吃货联盟，java初级小项目，源代码
weixin_30566063的博客
06-27 173
1：项目的实现效果、功能如图所示。 2：项目的源代码如下： 1 import java.util.Scanner; 2 3 /** 4 * 吃货联盟订餐管理系统 5 * 6 */ 7 public class OrderingMsg { 8 public static void main(String[] args)...
python外卖点餐系统
最新发布
01-09
根据提供的引用内容，我无法直接回答关于Python外卖点餐系统的问题。引用内容提到了外卖点餐系统的发展和管理制度，但没有提供具体的Python实现或示例代码。如果你对Python外卖点餐系统感兴趣，我可以为你提供一些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值