好的，餐饮管理系统可以包括以下功能：
1. 菜单管理：可以添加、修改、删除菜品，以及菜品分类管理；
2. 订单管理：记录所有订单信息，包括下单时间、顾客信息、菜品信息、订单状态等；
3. 库存管理：记录所有原材料的进出库情况，以及菜品所需原材料的库存情况；
4. 会员管理：记录顾客的会员信息，包括会员等级、积分等；
5. 报表统计：根据时间、菜品、顾客等维度进行统计分析，生成营业额、热销菜品、顾客偏好等报表。
以下是一个简单的 Java 实现：
```java
import java.util.*;
class MenuItem {
private String name;
private double price;
private String category;
public MenuItem(String name, double price, String category) {
this.name = name;
this.price = price;
this.category = category;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
public String getCategory() {
return category;
}
}
class Order {
private int id;
private Date date;
private List<MenuItem> items;
private String status;
private String customerName;
private String customerPhone;
public Order(int id, Date date, List<MenuItem> items, String status, String customerName, String customerPhone) {
this.id = id;
this.date = date;
this.items = items;
this.status = status;
this.customerName = customerName;
this.customerPhone = customerPhone;
}
public int getId() {
return id;
}
public Date getDate() {
return date;
}
public List<MenuItem> getItems() {
return items;
}
public String getStatus() {
return status;
}
public String getCustomerName() {
return customerName;
}
public String getCustomerPhone() {
return customerPhone;
}
}
class Stock {
private Map<String, Integer> ingredients;
public Stock(Map<String, Integer> ingredients) {
this.ingredients = ingredients;
}
public void addIngredient(String name, int quantity) {
if (ingredients.containsKey(name)) {
ingredients.put(name, ingredients.get(name) + quantity);
} else {
ingredients.put(name, quantity);
}
}
public void removeIngredient(String name, int quantity) {
if (ingredients.containsKey(name)) {
int remaining = ingredients.get(name) - quantity;
if (remaining >= 0) {
ingredients.put(name, remaining);
} else {
throw new RuntimeException("Insufficient stock");
}
} else {
throw new RuntimeException("Ingredient not found");
}
}
public int getIngredientQuantity(String name) {
if (ingredients.containsKey(name)) {
return ingredients.get(name);
} else {
throw new RuntimeException("Ingredient not found");
}
}
}
class Member {
private String name;
private String phone;
private int level;
private int points;
public Member(String name, String phone, int level, int points) {
this.name = name;
this.phone = phone;
this.level = level;
this.points = points;
}
public String getName() {
return name;
}
public String getPhone() {
return phone;
}
public int getLevel() {
return level;
}
public int getPoints() {
return points;
}
public void addPoints(int amount) {
points += amount;
}
}
class Report {
public static double calculateRevenue(List<Order> orders, Date startDate, Date endDate) {
double revenue = 0.0;
for (Order order : orders) {
if (order.getDate().after(startDate) && order.getDate().before(endDate)) {
for (MenuItem item : order.getItems()) {
revenue += item.getPrice();
}
}
}
return revenue;
}
public static Map<String, Integer> calculateQuantityByCategory(List<Order> orders, Date startDate, Date endDate) {
Map<String, Integer> quantityByCategory = new HashMap<>();
for (Order order : orders) {
if (order.getDate().after(startDate) && order.getDate().before(endDate)) {
for (MenuItem item : order.getItems()) {
String category = item.getCategory();
if (quantityByCategory.containsKey(category)) {
quantityByCategory.put(category, quantityByCategory.get(category) + 1);
} else {
quantityByCategory.put(category, 1);
}
}
}
}
return quantityByCategory;
}
public static Map<String, Integer> calculateQuantityByCustomer(List<Order> orders, Date startDate, Date endDate) {
Map<String, Integer> quantityByCustomer = new HashMap<>();
for (Order order : orders) {
if (order.getDate().after(startDate) && order.getDate().before(endDate)) {
String customerName = order.getCustomerName();
if (quantityByCustomer.containsKey(customerName)) {
quantityByCustomer.put(customerName, quantityByCustomer.get(customerName) + 1);
} else {
quantityByCustomer.put(customerName, 1);
}
}
}
return quantityByCustomer;
}
}
class Restaurant {
private List<MenuItem> menu;
private List<Order> orders;
private Stock stock;
private List<Member> members;
public Restaurant(List<MenuItem> menu, Stock stock) {
this.menu = menu;
this.orders = new ArrayList<>();
this.stock = stock;
this.members = new ArrayList<>();
}
public void addMenuItem(MenuItem item) {
menu.add(item);
}
public void removeMenuItem(String name) {
menu.removeIf(item -> item.getName().equals(name));
}
public void placeOrder(Order order) {
for (MenuItem item : order.getItems()) {
String ingredient = item.getName();
int quantity = 1;
stock.removeIngredient(ingredient, quantity);
}
orders.add(order);
}
public void addMember(Member member) {
members.add(member);
}
public void removeMember(String phone) {
members.removeIf(member -> member.getPhone().equals(phone));
}
public List<MenuItem> getMenu() {
return menu;
}
public List<Order> getOrders() {
return orders;
}
public Stock getStock() {
return stock;
}
public List<Member> getMembers() {
return members;
}
}
public class Main {
public static void main(String[] args) {
// create menu
List<MenuItem> menu = new ArrayList<>();
menu.add(new MenuItem("Hamburger", 8.0, "Fast Food"));
menu.add(new MenuItem("Pizza", 10.0, "Fast Food"));
menu.add(new MenuItem("Steak", 20.0, "Main Course"));
menu.add(new MenuItem("Salad", 6.0, "Appetizer"));
// create stock
Map<String, Integer> ingredients = new HashMap<>();
ingredients.put("Beef", 50);
ingredients.put("Bread", 100);
ingredients.put("Cheese", 20);
ingredients.put("Tomato", 30);
Stock stock = new Stock(ingredients);
// create restaurant
Restaurant restaurant = new Restaurant(menu, stock);
// create orders
List<Order> orders = new ArrayList<>();
orders.add(new Order(1, new Date(), Arrays.asList(menu.get(0), menu.get(3)), "Pending", "John Smith", "1234567890"));
orders.add(new Order(2, new Date(), Arrays.asList(menu.get(1), menu.get(2)), "Completed", "Jane Doe", "0987654321"));
// add members
List<Member> members = new ArrayList<>();
members.add(new Member("Tom Lee", "1111111111", 1, 100));
members.add(new Member("Mary Wong", "2222222222", 2, 200));
members.add(new Member("Jack Chan", "3333333333", 3, 300));
// add menu items, place orders, and add members to the restaurant
for (MenuItem item : menu) {
restaurant.addMenuItem(item);
}
for (Order order : orders) {
restaurant.placeOrder(order);
}
for (Member member : members) {
restaurant.addMember(member);
}
// generate reports
Date startDate = new Date(2021, 1, 1);
Date endDate = new Date();
double revenue = Report.calculateRevenue(orders, startDate, endDate);
Map<String, Integer> quantityByCategory = Report.calculateQuantityByCategory(orders, startDate, endDate);
Map<String, Integer> quantityByCustomer = Report.calculateQuantityByCustomer(orders, startDate, endDate);
// print reports
System.out.println("Revenue: " + revenue);
System.out.println("Quantity by category: " + quantityByCategory);
System.out.println("Quantity by customer: " + quantityByCustomer);
}
}
```
注意，这只是一个简单的实现，仅供参考。具体的需求和业务流程可能因餐厅的不同而有所不同，需要根据实际情况进行调整。
1180
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
