Java外卖点餐系统

>>强大,10k+点赞的 SpringBoot 后台管理系统竟然出了详细教程!

Java外卖点餐系统

来源:blog.csdn.net/weixin_44219955


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

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和购买数量)
    ② 根据菜品类别显示所有菜品
    ③ 查看所有订单(当前登录用户的)
    ④ 修改密码(当前登录用户的)
    ⑤ 个人信息显示

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

1
2
3
4
5
6
7
8
9
10
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类(管理员类)

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
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类(菜品类)

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
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类(订单类)

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
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类(用户类)

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
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管理类

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
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属性管理类

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
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属性管理类

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
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属性管理类

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

 

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

 

三、菜单类

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
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以后才支持)可以让用户就算输入错误也不会报错导致程序运行终止,又要重新输入(我摊牌了,就是懒)。

四、测试类

1
2
3
4
5
6
7
8
package com.softeem.lesson23.test2;
 
public class Test {
  public static void main(String[] args) {
    Menu m = new Menu();
    m.showMenu();
  }
}

 

五、实现部分界面截图


Java外卖点餐系统

Java外卖点餐系统
Java外卖点餐系统
Java外卖点餐系统
Java外卖点餐系统
Java外卖点餐系统
Java外卖点餐系统
Java外卖点餐系统
以上就是全部代码。

END

推荐好文

强大,10k+点赞的 SpringBoot 后台管理系统竟然出了详细教程!

为什么MySQL不推荐使用uuid或者雪花id作为主键?

为什么建议大家使用 Linux 开发?爽(外加七个感叹号)

IntelliJ IDEA 15款 神级超级牛逼插件推荐(自用,真的超级牛逼)

炫酷,SpringBoot+Echarts实现用户访问地图可视化(附源码)

记一次由Redis分布式锁造成的重大事故,避免以后踩坑!

十分钟学会使用 Elasticsearch 优雅搭建自己的搜索系统(附源码)

Java外卖点餐系统

原文始发于微信公众号(Java笔记虾):Java外卖点餐系统