吃货联盟订餐系统
author:luckyboy!
version:1.3
知识储备：变量、数据类型、选择结构、循环结构、数组、面向对象、集合和I/O流
吃货联盟订餐系统概述
现在的互联网时代，足不出户只需要动动手指，就可在点餐并送货上门，这种网上送餐伸手人们的青睐，一起动动手指开发一个网上订餐系统吧！
功能如下：
- 我要订餐
- 查看餐袋
- 签收订单
- 删除订单
- 我要点赞
- 退出系统
创建 .Java 文件：Order类、Food类、OrderingMsg类和test测试类
阶段划分
- 第一阶段：创建用来存储订单信息的Order类
- 第二阶段：创建用来存储餐品信息的Food类
- 第三阶段：实例化Order类和Food类并赋值2条订单信息
- 第四阶段：完成将信息保存到文件
- 第五阶段：完成将信息从文件中取出
- 第六阶段：完成整体框架和退出功能
- 第七阶段：完成我要订餐功能
- 第八阶段：完成查看餐袋功能
- 第九阶段：完成签收订单功能
- 第十阶段：完成删除订单功能
- 第十一阶段：完成我要点赞功能
第一阶段：创建用来存储订单信息的Order类
import java.io.Serializable;
//订单信息类
public class Order implements Serializable{
// 订餐人姓名
private String names;
// 餐品信息
private String menus;
// 送餐时间
private int times;
// 送餐地址
private String addresses;
// 订单状态
private int states;
// 订单总金额
private double sumPrices;
//无参构造方法
public Order() {
super();
}
//有参构造方法
public Order(String names, String menus, int times, String addresses,
int states, double sumPrices) {
super();
this.names = names;
this.menus = menus;
this.times = times;
this.addresses = addresses;
this.states = states;
this.sumPrices = sumPrices;
}
//get和set方法
public String getNames() {
return names;
}
public void setNames(String names) {
this.names = names;
}
public String getMenus() {
return menus;
}
public void setMenus(String menus) {
this.menus = menus;
}
public int getTimes() {
return times;
}
public void setTimes(int times) {
this.times = times;
}
public String getAddresses() {
return addresses;
}
public void setAddresses(String addresses) {
this.addresses = addresses;
}
public int getStates() {
return states;
}
public void setStates(int states) {
this.states = states;
}
public double getSumPrices() {
return sumPrices;
}
public void setSumPrices(double sumPrices) {
this.sumPrices = sumPrices;
}
//toString方法输出集合信息
public String toString() {
return names + "\t" + menus + "\t"
+ times + "\t" + addresses + "\t" + states
+ "\t" + sumPrices;
}
}
第二阶段：创建用来存储餐品信息的Food类
import java.io.Serializable;
//菜品信息类
public class Food implements Serializable{
// 菜品
private String menuNames;
// 单价
private double prices;
// 点赞数
private int praiseNums;
//无参构造方法
public Food() {
super();
}
//有参构造方法
public Food(String menuNames, double prices, int praiseNums) {
super();
this.menuNames = menuNames;
this.prices = prices;
this.praiseNums = praiseNums;
}
//get和set方法
public String getMenuNames() {
return menuNames;
}
public void setMenuNames(String menuNames) {
this.menuNames = menuNames;
}
public double getPrices() {
return prices;
}
public void setPrices(double prices) {
this.prices = prices;
}
public int getPraiseNums() {
return praiseNums;
}
public void setPraiseNums(int praiseNums) {
this.praiseNums = praiseNums;
}
//toString方法输出集合信息
public String toString() {
return menuNames + "\t" + prices
+ "\t" + praiseNums;
}
}
第三阶段：实例化Order类和Food类并赋值2条订单信息
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class OrderingMsg {
Scanner in = new Scanner(System.in);
//创建ArrayList集合用来存放订单信息
List<Order> orderList = new ArrayList<Order>();
//创建LinkedList集合用来存放菜品信息
List<Food> foodList = new LinkedList<Food>();
//初始化方法
public void inti(){
//初始化2条Order类的订单信息
Order ord1 = new Order("小汪", "红烧带鱼 ×1份", 12, "亳州路110号", 1, 76.0);
Order ord2 = new Order("小汪", "鱼香肉丝 ×1份", 12, "亳州路120号", 0, 23.0);
//把订单信息保存到ArrayList集合
orderList.add(ord1);
orderList.add(ord2);
writeOrder(orderList);
//初始化Food类的菜品信息
Food food1 = new Food("红烧带鱼", 38.0, 0);
Food food2 = new Food("鱼香肉丝", 18.0, 0);
Food food3 = new Food("时令蔬菜", 10.0, 0);
//把菜品信息保存到LinkedList集合
foodList.add(food1);
foodList.add(food2);
foodList.add(food3);
writeFood(foodList);
}第四阶段：完成将信息保存到文件
//将orderList集合中的信息保存到Order文件的方法
@SuppressWarnings("resource")
public void writeOrder(List<Order> orderList){
OutputStream os;
try {
os = new FileOutputStream("Order.txt");
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(orderList);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//将foodList集合中的信息保存到Food文件的方法
@SuppressWarnings("resource")
public void writeFood(List<Food> foodList){
OutputStream os;
try {
os = new FileOutputStream("Food.txt");
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(foodList);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}第五阶段：完成将信息从文件中取出
//读取Order文件中的信息保存到集合中的方法
@SuppressWarnings({ "resource", "unchecked" })
public List<Order> readOrder(){
InputStream is;
try {
is = new FileInputStream("Order.txt");
ObjectInputStream ois = new ObjectInputStream(is);
Object object = ois.readObject();
ArrayList<Order> list = (ArrayList<Order>)object;
return list;
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
//读取Food文件中的信息保存到集合中的方法
@SuppressWarnings({ "resource", "unchecked" })
public List<Food> readFood(){
InputStream is;
try {
is = new FileInputStream("Food.txt");
ObjectInputStream ois = new ObjectInputStream(is);
Object object = ois.readObject();
LinkedList<Food> list = (LinkedList<Food>)object;
return list;
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}第六阶段：完成整体框架和退出功能
//整体框架方法
public void start(){
int num;
do{
System.out.println("******************************");
System.out.println("* 吃货联盟订餐系统 *");
System.out.println("* @auther:luckyboy! *");
System.out.println("* version:1.2 *");
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("******************************");
System.out.println("请选择(序号:1-6)：");
int choose = in.nextInt();
//如果用户选择的是1-6以外的数字，则没有此功能将重新选择
while(choose < 1 || choose > 6){
System.out.println("对不起，没有此功能，请重新选择(序号:1-6)：");
choose = in.nextInt();
}
//根据用户选择执行相应的功能
switch(choose){
case 1://我要订餐
order();
break;
case 2://查看餐袋
lookBag();
break;
case 3://签收订单
signFor();
break;
case 4://删除订单
delete();
break;
case 5://我要点赞
like();
break;
case 6://退出系统
System.out.println("* 6-> 退出系统 *");
break;
}
//此程序只有choose变量等于6，跳出循环，程序执行结束
if(choose == 6){
break;
}
System.out.println("输入0返回菜单：");
num = in.nextInt();
//如果num等于0，返回菜单；如果num不等于0，重新输入
while(num != 0){
System.out.println("对不起，输入错误，请输入0返回菜单：");
num = in.nextInt();
}
}while(num == 0);
System.out.println("程序运行结束，感谢使用此程序！");
}//测试类
public class Test {
public static void main(String[] args) {
// 实例化OrderingMsg类
OrderingMsg ord = new OrderingMsg();
//调用初始化方法
ord.inti();
//调用主题框架开始方法
ord.start();
}
}第七阶段：完成我要订餐功能
//我要订餐方法
public void order(){
/*
* 使用集合存储订单信息不需要考虑餐袋满的情况，可以一直添加订单信息，集合没有订单限制
*/
//将Food文件中的信息取出，保存到集合
List<Food> foodList = readFood();
//将Order文件中的信息取出，保存到集合
List<Order> orderList = readOrder();
System.out.println("* 1-> 我要订餐 *");
//输出Food类的菜品信息，供用户选择
System.out.println("序号\t菜品\t 单价");
for (int i = 0; i < foodList.size(); i++) {
System.out.println((i+1) + "\t" +foodList.get(i).getMenuNames() + "\t "
+ foodList.get(i).getPrices());
}
//接收用户输入的订单信息
System.out.println("请选择您要点的餐品序号：");
int menuId = in.nextInt();
System.out.println("请选择您需要的份数：");
int number = in.nextInt();
String menu = foodList.get(menuId-1).getMenuNames() + " ×" + number + "份";
System.out.println("请输入订餐人姓名：");
String name = in.next();
System.out.println("请输入送餐时间(送餐时间是10点至20点间整点送餐)：：");
int time = in.nextInt();
while(time < 10 || time > 20){
System.out.println("对不起，送餐时间是10点至20点间整点送餐，请重新输入送餐时间：");
time = in.nextInt();
}
System.out.println("请输入送餐地址：");
String address = in.next();
//计算订单总金额，餐费 = 菜品单价 × 份数；配送费是餐费>50免配送费，餐费<50收5元配送费
double sumPrice = foodList.get(menuId-1).getPrices() * number;
double shoppingFree = sumPrice > 50 ? 0 : 5.0;
double sum = sumPrice + shoppingFree;
//输出订单信息
System.out.println("订餐成功！");
System.out.println("您订的是："+menu);
System.out.println("订餐人姓名：" + name);
System.out.println("送餐时间：" + time);
System.out.println("送餐地址：" + address);
System.out.println("餐费：" + sumPrice +"，配送费：" + shoppingFree);
System.out.println("订单总金额：" + sum);
//保存用户输入的订单信息
Order order = new Order(name, menu, time, address, 0, sum);
orderList.add(order);
//将集合中的信息保存到Order文件
writeOrder(orderList);
}第八阶段：完成查看餐袋功能
//查看餐袋方法
public void lookBag(){
/*
* 查看餐袋是输出保存在ArrayList集合中的Order订单信息
*/
//将Order文件中的信息取出保存到结合
List<Order> orderList = readOrder();
System.out.println("* 2-> 查看餐袋 *");
System.out.println("序号\t姓名\t餐品\t\t时间\t地址\t\t状态\t总金额");
for (int i = 0; i < orderList.size(); i++) {
String time = orderList.get(i).getTimes() + "点";
String stat = orderList.get(i).getStates() == 0 ? "已预定" : "已完成";
String sumPrice = orderList.get(i).getSumPrices()+"元";
System.out.println((i+1) + "\t" + orderList.get(i).getNames() + "\t" + orderList.get(i).getMenus()
+ "\t" + time + "\t" + orderList.get(i).getAddresses() + "\t" + stat + "\t" + sumPrice);
}
}
第九阶段：完成签收订单功能
//签收订单方法
public void signFor(){
/*
* 用户输入的序号小于集合长度，匹配到订单，订单状态是已预定，可以签收订单，将集合中的此订单状态改为已完成
* 用户输入的序号小于集合长度，匹配到订单，订单状态是已完成，不能签收订单
* 用户输入的序号大于集合长度，没有匹配到订单，此订单不存在，则重新选择
*/
//将Oredr文件中的信息取出保存到集合
List<Order> orderList = readOrder();
System.out.println("* 3-> 签收订单 *");
System.out.println("请输入您要签收的订单序号：");
int number = in.nextInt();
//如果用户输入的订单序号大于存放订单信息集合的长度，则订单不存在，重新输入
while(number > orderList.size() || number < 0){
System.out.println("对不起，订单不存在，请重新输入您要签收的订单序号：");
number = in.nextInt();
}
//匹配用户输入的订单号
for (int i = 0; i < orderList.size(); i++) {
//如果订单状态是已预定，用户输入订单序号和集合订单序号相同，订单可以签收
if(orderList.get(number-1).getStates() == 0 && number == i+1){
orderList.get(i).setStates(1);
//将集合中的信息保存到文件
writeOrder(orderList);
System.out.println("订单签收成功！");
}
//如果订单状态是已完成，用户输入订单序号和集合订单序号相同，订单不能签收
else if(orderList.get(number-1).getStates() == 1 && number == i+1){
System.out.println("对不起，此订单已完成，不能重复签收！");
}
}
}第十阶段：完成删除订单功能
//删除订单方法
public void delete(){
/*
* 用户输入的序号小于集合长度，匹配到订单，订单状态是已完成，可以删除订单，将集合中的此订单信息删除
* 用户输入的序号小于集合长度，匹配到订单，订单状态是已预定，不能删除订单
* 用户输入的序号大于集合长度，没有匹配到订单，此订单不存在，则重新选择
*/
//将Order文件中的信息取出保存到集合中
List<Order> orderList = readOrder();
System.out.println("* 4-> 删除订单 *");
System.out.println("请输入您要签收的订单序号：");
int number = in.nextInt();
//如果用户输入的订单序号大于存放订单信息集合的长度，则订单不存在，重新输入
while(number > orderList.size() || number < 0){
System.out.println("对不起，订单不存在，请重新输入您要删除的订单序号：");
number = in.nextInt();
}
//匹配用户输入的订单号
for (int i = 0; i < orderList.size(); i++) {
//如果订单状态是已完成，用户输入订单序号和集合订单序号相同，订单可以删除
if(orderList.get(number-1).getStates() == 1 && number == i+1){
orderList.remove(number-1);
//将集合中的信息保存到Order文件
writeOrder(orderList);
System.out.println("订单删除成功！");
}
//如果订单状态是已预定，用户输入订单序号和集合订单序号相同，订单不能删除
else if(orderList.get(number-1).getStates() == 0 && number == i+1){
System.out.println("对不起，此订单已预定，不能删除！");
}
}
}第十一阶段：完成我要点赞功能
//我要点赞方法
public void like(){
/*
* 用户输入的序号小于集合长度，匹配到菜品，则菜品赞数加1
* 用户输入的序号大于集合长度，则菜品不存在，重新选择
*/
//将Food文件中的信息取出保存到集合
List<Food> foodList = readFood();
System.out.println("* 5-> 我要点赞 *");
//输出菜品信息
System.out.println("序号\t菜品\t 单价\t赞");
for (int i = 0; i < foodList.size(); i++) {
System.out.println((i+1) + "\t" +foodList.get(i));
}
System.out.println("请选择您需要点赞的菜品序号：");
int number = in.nextInt();
//如果用户输入的菜品序号大于存放菜品信息集合的长度，则菜品不存在，重新输入
while(number > foodList.size() || number < 0){
System.out.println("对不起，菜品不存在，请重新输入您要点赞的菜品序号：");
number = in.nextInt();
}
//将用户需要点赞的菜品赞数取出加1
int sum = foodList.get(number-1).getPraiseNums() + 1;
//再将用户需要点赞的菜品赞数传递回去；
foodList.get(number-1).setPraiseNums(sum);
//将集合中的信息保存到Food文件
writeFood(foodList);
//输出菜品点赞成功
System.out.println(foodList.get(number-1).getMenuNames() +"点赞成功！");
}完整代码如下
Order类
import java.io.Serializable;
//订单信息类
public class Order implements Serializable{
// 订餐人姓名
private String names;
// 餐品信息
private String menus;
// 送餐时间
private int times;
// 送餐地址
private String addresses;
// 订单状态
private int states;
// 订单总金额
private double sumPrices;
//无参构造方法
public Order() {
super();
}
//有参构造方法
public Order(String names, String menus, int times, String addresses,
int states, double sumPrices) {
super();
this.names = names;
this.menus = menus;
this.times = times;
this.addresses = addresses;
this.states = states;
this.sumPrices = sumPrices;
}
//get和set方法
public String getNames() {
return names;
}
public void setNames(String names) {
this.names = names;
}
public String getMenus() {
return menus;
}
public void setMenus(String menus) {
this.menus = menus;
}
public int getTimes() {
return times;
}
public void setTimes(int times) {
this.times = times;
}
public String getAddresses() {
return addresses;
}
public void setAddresses(String addresses) {
this.addresses = addresses;
}
public int getStates() {
return states;
}
public void setStates(int states) {
this.states = states;
}
public double getSumPrices() {
return sumPrices;
}
public void setSumPrices(double sumPrices) {
this.sumPrices = sumPrices;
}
//toString方法输出集合信息
public String toString() {
return names + "\t" + menus + "\t"
+ times + "\t" + addresses + "\t" + states
+ "\t" + sumPrices;
}
}
Food类
import java.io.Serializable;
//菜品信息类
public class Food implements Serializable{
// 菜品
private String menuNames;
// 单价
private double prices;
// 点赞数
private int praiseNums;
//无参构造方法
public Food() {
super();
}
//有参构造方法
public Food(String menuNames, double prices, int praiseNums) {
super();
this.menuNames = menuNames;
this.prices = prices;
this.praiseNums = praiseNums;
}
//get和set方法
public String getMenuNames() {
return menuNames;
}
public void setMenuNames(String menuNames) {
this.menuNames = menuNames;
}
public double getPrices() {
return prices;
}
public void setPrices(double prices) {
this.prices = prices;
}
public int getPraiseNums() {
return praiseNums;
}
public void setPraiseNums(int praiseNums) {
this.praiseNums = praiseNums;
}
//toString方法输出集合信息
public String toString() {
return menuNames + "\t" + prices
+ "\t" + praiseNums;
}
}
OrderingMsg类
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class OrderingMsg {
Scanner in = new Scanner(System.in);
//创建ArrayList集合用来存放订单信息
List<Order> orderList = new ArrayList<Order>();
//创建LinkedList集合用来存放菜品信息
List<Food> foodList = new LinkedList<Food>();
//初始化方法
public void inti(){
//初始化2条Order类的订单信息
Order ord1 = new Order("小汪", "红烧带鱼 ×1份", 12, "亳州路110号", 1, 76.0);
Order ord2 = new Order("小汪", "鱼香肉丝 ×1份", 12, "亳州路120号", 0, 23.0);
//把订单信息保存到ArrayList集合
orderList.add(ord1);
orderList.add(ord2);
writeOrder(orderList);
//初始化Food类的菜品信息
Food food1 = new Food("红烧带鱼", 38.0, 0);
Food food2 = new Food("鱼香肉丝", 18.0, 0);
Food food3 = new Food("时令蔬菜", 10.0, 0);
//把菜品信息保存到LinkedList集合
foodList.add(food1);
foodList.add(food2);
foodList.add(food3);
writeFood(foodList);
}
//将orderList集合中的信息保存到Order文件的方法
@SuppressWarnings("resource")
public void writeOrder(List<Order> orderList){
OutputStream os;
try {
os = new FileOutputStream("Order.txt");
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(orderList);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//将foodList集合中的信息保存到Food文件的方法
@SuppressWarnings("resource")
public void writeFood(List<Food> foodList){
OutputStream os;
try {
os = new FileOutputStream("Food.txt");
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(foodList);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//读取Order文件中的信息保存到集合中的方法
@SuppressWarnings({ "resource", "unchecked" })
public List<Order> readOrder(){
InputStream is;
try {
is = new FileInputStream("Order.txt");
ObjectInputStream ois = new ObjectInputStream(is);
Object object = ois.readObject();
ArrayList<Order> list = (ArrayList<Order>)object;
return list;
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
//读取Food文件中的信息保存到集合中的方法
@SuppressWarnings({ "resource", "unchecked" })
public List<Food> readFood(){
InputStream is;
try {
is = new FileInputStream("Food.txt");
ObjectInputStream ois = new ObjectInputStream(is);
Object object = ois.readObject();
LinkedList<Food> list = (LinkedList<Food>)object;
return list;
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
//整体框架方法
public void start(){
int num;
do{
System.out.println("******************************");
System.out.println("* 吃货联盟订餐系统 *");
System.out.println("* @auther:luckyboy! *");
System.out.println("* version:1.2 *");
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("******************************");
System.out.println("请选择(序号:1-6)：");
int choose = in.nextInt();
//如果用户选择的是1-6以外的数字，则没有此功能将重新选择
while(choose < 1 || choose > 6){
System.out.println("对不起，没有此功能，请重新选择(序号:1-6)：");
choose = in.nextInt();
}
//根据用户选择执行相应的功能
switch(choose){
case 1://我要订餐
order();
break;
case 2://查看餐袋
lookBag();
break;
case 3://签收订单
signFor();
break;
case 4://删除订单
delete();
break;
case 5://我要点赞
like();
break;
case 6://退出系统
System.out.println("* 6-> 退出系统 *");
break;
}
//此程序只有choose变量等于6，跳出循环，程序执行结束
if(choose == 6){
break;
}
System.out.println("输入0返回菜单：");
num = in.nextInt();
//如果num等于0，返回菜单；如果num不等于0，重新输入
while(num != 0){
System.out.println("对不起，输入错误，请输入0返回菜单：");
num = in.nextInt();
}
}while(num == 0);
System.out.println("程序运行结束，感谢使用此程序！");
}
//我要订餐方法
public void order(){
/*
* 使用集合存储订单信息不需要考虑餐袋满的情况，可以一直添加订单信息，集合没有订单限制
*/
//将Food文件中的信息取出，保存到集合
List<Food> foodList = readFood();
//将Order文件中的信息取出，保存到集合
List<Order> orderList = readOrder();
System.out.println("* 1-> 我要订餐 *");
//输出Food类的菜品信息，供用户选择
System.out.println("序号\t菜品\t 单价");
for (int i = 0; i < foodList.size(); i++) {
System.out.println((i+1) + "\t" +foodList.get(i).getMenuNames() + "\t "
+ foodList.get(i).getPrices());
}
//接收用户输入的订单信息
System.out.println("请选择您要点的餐品序号：");
int menuId = in.nextInt();
System.out.println("请选择您需要的份数：");
int number = in.nextInt();
String menu = foodList.get(menuId-1).getMenuNames() + " ×" + number + "份";
System.out.println("请输入订餐人姓名：");
String name = in.next();
System.out.println("请输入送餐时间(送餐时间是10点至20点间整点送餐)：：");
int time = in.nextInt();
while(time < 10 || time > 20){
System.out.println("对不起，送餐时间是10点至20点间整点送餐，请重新输入送餐时间：");
time = in.nextInt();
}
System.out.println("请输入送餐地址：");
String address = in.next();
//计算订单总金额，餐费 = 菜品单价 × 份数；配送费是餐费>50免配送费，餐费<50收5元配送费
double sumPrice = foodList.get(menuId-1).getPrices() * number;
double shoppingFree = sumPrice > 50 ? 0 : 5.0;
double sum = sumPrice + shoppingFree;
//输出订单信息
System.out.println("订餐成功！");
System.out.println("您订的是："+menu);
System.out.println("订餐人姓名：" + name);
System.out.println("送餐时间：" + time);
System.out.println("送餐地址：" + address);
System.out.println("餐费：" + sumPrice +"，配送费：" + shoppingFree);
System.out.println("订单总金额：" + sum);
//保存用户输入的订单信息
Order order = new Order(name, menu, time, address, 0, sum);
orderList.add(order);
//将集合中的信息保存到Order文件
writeOrder(orderList);
}
//查看餐袋方法
public void lookBag(){
/*
* 查看餐袋是输出保存在ArrayList集合中的Order订单信息
*/
//将Order文件中的信息取出保存到结合
List<Order> orderList = readOrder();
System.out.println("* 2-> 查看餐袋 *");
System.out.println("序号\t姓名\t餐品\t\t时间\t地址\t\t状态\t总金额");
for (int i = 0; i < orderList.size(); i++) {
String time = orderList.get(i).getTimes() + "点";
String stat = orderList.get(i).getStates() == 0 ? "已预定" : "已完成";
String sumPrice = orderList.get(i).getSumPrices()+"元";
System.out.println((i+1) + "\t" + orderList.get(i).getNames() + "\t" + orderList.get(i).getMenus()
+ "\t" + time + "\t" + orderList.get(i).getAddresses() + "\t" + stat + "\t" + sumPrice);
}
}
//签收订单方法
public void signFor(){
/*
* 用户输入的序号小于集合长度，匹配到订单，订单状态是已预定，可以签收订单，将集合中的此订单状态改为已完成
* 用户输入的序号小于集合长度，匹配到订单，订单状态是已完成，不能签收订单
* 用户输入的序号大于集合长度，没有匹配到订单，此订单不存在，则重新选择
*/
//将Oredr文件中的信息取出保存到集合
List<Order> orderList = readOrder();
System.out.println("* 3-> 签收订单 *");
System.out.println("请输入您要签收的订单序号：");
int number = in.nextInt();
//如果用户输入的订单序号大于存放订单信息集合的长度，则订单不存在，重新输入
while(number > orderList.size() || number < 0){
System.out.println("对不起，订单不存在，请重新输入您要签收的订单序号：");
number = in.nextInt();
}
//匹配用户输入的订单号
for (int i = 0; i < orderList.size(); i++) {
//如果订单状态是已预定，用户输入订单序号和集合订单序号相同，订单可以签收
if(orderList.get(number-1).getStates() == 0 && number == i+1){
orderList.get(i).setStates(1);
//将集合中的信息保存到文件
writeOrder(orderList);
System.out.println("订单签收成功！");
}
//如果订单状态是已完成，用户输入订单序号和集合订单序号相同，订单不能签收
else if(orderList.get(number-1).getStates() == 1 && number == i+1){
System.out.println("对不起，此订单已完成，不能重复签收！");
}
}
}
//删除订单方法
public void delete(){
/*
* 用户输入的序号小于集合长度，匹配到订单，订单状态是已完成，可以删除订单，将集合中的此订单信息删除
* 用户输入的序号小于集合长度，匹配到订单，订单状态是已预定，不能删除订单
* 用户输入的序号大于集合长度，没有匹配到订单，此订单不存在，则重新选择
*/
//将Order文件中的信息取出保存到集合中
List<Order> orderList = readOrder();
System.out.println("* 4-> 删除订单 *");
System.out.println("请输入您要签收的订单序号：");
int number = in.nextInt();
//如果用户输入的订单序号大于存放订单信息集合的长度，则订单不存在，重新输入
while(number > orderList.size() || number < 0){
System.out.println("对不起，订单不存在，请重新输入您要删除的订单序号：");
number = in.nextInt();
}
//匹配用户输入的订单号
for (int i = 0; i < orderList.size(); i++) {
//如果订单状态是已完成，用户输入订单序号和集合订单序号相同，订单可以删除
if(orderList.get(number-1).getStates() == 1 && number == i+1){
orderList.remove(number-1);
//将集合中的信息保存到Order文件
writeOrder(orderList);
System.out.println("订单删除成功！");
}
//如果订单状态是已预定，用户输入订单序号和集合订单序号相同，订单不能删除
else if(orderList.get(number-1).getStates() == 0 && number == i+1){
System.out.println("对不起，此订单已预定，不能删除！");
}
}
}
//我要点赞方法
public void like(){
/*
* 用户输入的序号小于集合长度，匹配到菜品，则菜品赞数加1
* 用户输入的序号大于集合长度，则菜品不存在，重新选择
*/
//将Food文件中的信息取出保存到集合
List<Food> foodList = readFood();
System.out.println("* 5-> 我要点赞 *");
//输出菜品信息
System.out.println("序号\t菜品\t 单价\t赞");
for (int i = 0; i < foodList.size(); i++) {
System.out.println((i+1) + "\t" +foodList.get(i));
}
System.out.println("请选择您需要点赞的菜品序号：");
int number = in.nextInt();
//如果用户输入的菜品序号大于存放菜品信息集合的长度，则菜品不存在，重新输入
while(number > foodList.size() || number < 0){
System.out.println("对不起，菜品不存在，请重新输入您要点赞的菜品序号：");
number = in.nextInt();
}
//将用户需要点赞的菜品赞数取出加1
int sum = foodList.get(number-1).getPraiseNums() + 1;
//再将用户需要点赞的菜品赞数传递回去；
foodList.get(number-1).setPraiseNums(sum);
//将集合中的信息保存到Food文件
writeFood(foodList);
//输出菜品点赞成功
System.out.println(foodList.get(number-1).getMenuNames() +"点赞成功！");
}
}
Test类
//测试类
public class Test {
public static void main(String[] args) {
// 实例化OrderingMsg类
OrderingMsg ord = new OrderingMsg();
//调用初始化方法
ord.inti();
//调用主题框架开始方法
ord.start();
}
}
3797
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
