✅作者简介：热爱国学的Java后端开发者，修心和技术同步精进。
🍎个人主页：乐趣国学的博客
🍊个人信条：不迁怒，不贰过。小知识，大智慧。
💞当前专栏：Java案例分享专栏
✨特色专栏：国学周更-心性养成之路
🥭本文内容：Java——吃货联盟订餐系统（对象+IO流）
更多内容点击👇
Java——吃货联盟订餐系统（对象+集合）
Java——吃货联盟订餐系统（对象+数组）
目录
⛳️项目需求
⛳️项目环境准备
⛳️案例覆盖的技能点
⛳️难点分析
❤️1、使用IO流保存订单信息
❤️2、访问订单信息
❤️3、删除订单信息
❤️4、计算订单的总金额
⛳️项目实现思路
❤️1、数据初始化
❤️2、实现菜单切换
❤️3、实现查看餐袋
❤️4、实现我要订餐
❤️5、实现签收订单
❤️6、实现删除订单
❤️7、实现我要点赞
⛳️代码展示
❤️1、订单信息：Order类
❤️2、菜品：Food类
❤️3、操作方法：OrderMethod类
❤️4、订餐系统：OrderSystem类
⛳️效果展示
⛳️项目需求
（1）现今已经进入网络时代，人们的日常生活已经离不开网络，如网上购物、看新闻、交友等。
（2）“只要点点手指，就能送餐上门”，网上订餐越来越受到都市年轻人的青睐。
（3）现要求开发一个网上订餐系统，需要实现我要订餐、查看餐袋、签收订单、删除订单、我要点赞和退出系统6个功能。
⛳️项目环境准备
（1）开发工具：MyEclipse，JDK1.7。
（2）开发语言：Java。
⛳️案例覆盖的技能点
（1）理解程序基本概念——程序、变量、数据类型。
（2）会使用顺序、选择、循环、跳转语句编写程序。
（3）会使用集合。
（4）掌握类、对象、方法、私有变量等相关知识。
（5）会使用IO流相关知识。
⛳️难点分析
❤️1、使用IO流保存订单信息
（1）根据本项目的需求分析可知，每条订单的信息都包括订餐人姓名、选择菜品及份数、送餐时间、送餐地址、订单状态、总金额，并且会有多条订单信息，可以定义一个Order类，在Order类中将订单的各个信息设置为私有属性，再添加这些属性的有参构造方法以及Get/Set方法。
private String name;
private String dishMeg;
private int time;
private String address;
private int state;
private double sumPrices;
public Order() {
super();
}
public Order(String name, String dishMeg, int time, String address,
int state, double sumPrices) {
super();
this.name = name;
this.dishMeg = dishMeg;
this.time = time;
this.address = address;
this.state = state;
this.sumPrices = sumPrices;
}
//添加私有变量的Get/Set方法
（2）定义一个两个集合
/** 使用泛型创建集合orders，存储所有订单 */
List<Order> orders = new ArrayList<Order>();
/** 使用泛型创建集合foods，存储所有菜品 */
List<Food> foods = new ArrayList<Food>();
（3）初始化数据，并存入两个集合中；
// 创建2个Order对象，存储到Orders集合中
Order order1 = new Order("张三", "红烧带鱼 2份", 3, "天成路207号", 1, 76.0);
Order order2 = new Order("李四", "鱼香肉丝 2份", 10, "天成路207号", 0, 20.0);
orders.add(order1);
orders.add(order2);
// 创建3个Food对象，存储到Foods集合中
Food food1 = new Food("红烧带鱼", 38.0, 10);
Food food2 = new Food("鱼香肉丝", 20.0, 20);
Food food3 = new Food("时令鲜蔬", 10.0, 0);
foods.add(food1);
foods.add(food2);
foods.add(food3);
（4）定义方法实现向orders.txt文件中写入订单信息；定义方法实现从orders.txt文件中读取订单信息并将读取到的所有订单返回；使用IO流的序列化和反序列化将集合存储和读取。
// 定义方法实现向orders.txt文件中写入订单信息
public boolean writeOrder(List<Order> orders) {
ObjectOutputStream oosOrder = null;
try {
oosOrder = new ObjectOutputStream(
new FileOutputStream("orders.txt"));
oosOrder.writeObject(orders);
} catch (FileNotFoundException e) {
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (oosOrder != null) {
oosOrder.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return false;
}
// 定义方法实现从orders.txt文件中读取订单信息并将读取到的所有订单返回
@SuppressWarnings("resource")
public List<Order> readOrder() {
// 创建输入流
ObjectInputStream oisOrder = null;
try {
oisOrder = new ObjectInputStream(new FileInputStream("orders.txt"));
Object object = oisOrder.readObject();
@SuppressWarnings("unchecked")
ArrayList<Order> al = (ArrayList<Order>) object;
return al;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
（5）定义方法实现向foods.txt文件中写入菜品信息；定义方法实现从foods.txt文件中读取订单信息并将读取到的所有订单返回；使用IO流的序列化和反序列化将集合存储和读取。
// 定义方法实现向foods.txt文件中写入菜品信息
public boolean writeFood(List<Food> foods) {
ObjectOutputStream oosFood = null;
try {
oosFood = new ObjectOutputStream(new FileOutputStream("foods.txt"));
oosFood.writeObject(foods);
} catch (FileNotFoundException e) {
} catch (IOException e) {
e.printStackTrace();
} finally {
if (oosFood != null) {
try {
oosFood.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return false;
}
// 定义方法实现从foods.txt文件中读取订单信息并将读取到的所有订单返回
@SuppressWarnings("resource")
public List<Food> readFood() {
// 创建输入流
ObjectInputStream oisOrder = null;
try {
oisOrder = new ObjectInputStream(new FileInputStream("foods.txt"));
Object object = oisOrder.readObject();
@SuppressWarnings("unchecked")
ArrayList<Food> al = (ArrayList<Food>) object;
return al;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
（6）将两个集合写入本地文件中
// 创建2个Order对象，存储到Orders集合中
writeOrder(orders);
// 创建3个Food对象，存储到Foods集合中
writeFood(foods);
❤️2、访问订单信息
访问 ArrayList<Order>集合中第i+1条订单信息可采用如下方式
订餐人姓名：orders.get(i).getName()
所选菜品信息：orders.get(i).getDishMeg()
送餐时间：orders.get(i).getTime()
送餐地址：orders.get(i).getAddress()
订单状态：orders.get(i).getState()
订单的总金额：orders.get(i).getSumPrices()
❤️3、 删除订单信息
List<Order> orderList = readOrder();//读取
orderList.remove(i);//删除
writeOrder(orderList);//写入
❤️4、 计算订单的总金额
// 总金额 =菜品单价*份数+送餐费。其中，当单笔订单金额达到50元时，免收送餐费；否则，需交纳5元送餐费。
double sumPrice = foodList.get(chooseDish - 1).getPrices() * number;
// 餐费满50元，免送餐费6元
double deliCharge = (sumPrice >= 50) ? 0 : 6;
System.out.println("餐费：" + sumPrice + "元，送餐费" + deliCharge + "元，
总计："+ (sumPrice + deliCharge) + "元。");
⛳️项目实现思路
❤️1、 数据初始化
（1）创建订单类：Order类
订单属性信息有（加private封装）：订餐人姓名（name）、选择菜品信息（dishMeg）、送餐时间（time）、送餐地址（address）、订单状态（state）、总金额（sumPrices）。
（2）创建菜品类：Food类
订单属性信息有（加private封装）：菜品名称（disName）、菜品单价（price）、点赞数（praiseNum）。
（3）创建方法类：OrderMgr类
// 我要订餐
OrderMethod.myOrder(orders, foods);
// 查看餐袋
OrderMethod.lookOrder(orders);
// 签收订单
OrderMethod.signOrder(orders);
// 删除订单
OrderMethod.delOrder(orders);
// 我要点赞
OrderMethod.myLike(orders, foods);
（4）创建测试类：Test
❤️2、 实现菜单切换
执行程序，输出系统主菜单。用户根据显示的主菜单，输入功能编号实现菜单的显示和菜单的切换，具体要求如下：
（1）当输入1~5时，输出相关的菜单项信息。
（2）显示“输入0返回”。输入0，则返回主菜单，否则，退出系统，终止程序的运行，输出提示信息“谢谢使用，欢迎下次光临！”。
❤️3、 实现查看餐袋
遍历系统中已有的订单，并逐条显示输出，内容包括序号、订餐人姓名、订餐信息（菜品名和份数）、送餐时间、送餐地址、总金额、订单状态（已预订或已完成）。
❤️4、 实现我要订餐
为用户显示系统中提供的菜品信息，获得订餐人信息，形成订单。每条订单包含如下信息。
（1）订餐人姓名：要求用户输入。
（2）选择菜品及份数：显示3个供选择菜品的序号、名称、单价、点赞数，提示用户输入要选择的菜品序号及份数。
（3）送餐时间：当天10:00~20:00间整点送餐，要求用户输入10~20的整数，输入错误，重新输入。
（4）送餐地址：要求用户输入。
（5）状态：订单的当前状态。订单有两种状态，0为已预订状态（默认状态），1为已完成（订单已签收）。
（6）总金额：订单总金额。总金额 = 菜品单价*份数+送餐费。其中，当单笔订单金额达到50元时，免收送餐费；否则，需交纳5元送餐费。
各数组中相同下标的数据组成一条订单信息，因此向每个数组相同下标的位置各增加一条数据并保存。
❤️5、 实现签收订单
送餐完成后，要将用户签收订单的状态由“已预订”修改为“已完成”。业务要求如下：
（1）如果订单的当前状态为：“已预订”且数组下标为用户输入的订单序号减1，就签收。
（2）如果订单的当前状态为：“已完成”且数组下标为用户输入的订单序号减1，不可签收。
控制台接收要签收的订单序号。利用for循环结构遍历全部订单，利用if选择结构判断names数组中订餐人姓名是否为null，订单状态是否为已预订且数组下标是指定订单序号减1。
如果条件成立，该订单的状态值修改为1（即已完成）。
❤️6、 实现删除订单
❤️7、 实现我要点赞
选择执行“我要点赞”菜单项。
（1）界面显示菜品序号、菜品名、单价、点赞数（如为0可不显示），提示用户输入要点赞的菜品序号。
（2）接收要点赞的菜品序号。
（3）praiseNums中对应菜品的点赞数加1。
⛳️代码展示
package com.cxyzxc.www.orderingmsg;
import java.io.Serializable;
/**
* 订单类Order类
*
*
*/
public class Order implements Serializable {
private static final long serialVersionUID = 1L;
/** 订餐人姓名 */
private String name;
/** 餐品信息，通过菜品名拼接份数的形式显示 */
private String dishMegs;
/** 订单配送时间 */
private int times;
/** 订单配送地址 */
private String addresses;
/** 订单状态： 0：已预定 1：已完成 */
private int states;//
/** 存放每笔订单的总金额 */
private double sumPrices;
// 无参构造方法
public Order() {
super();
}
// 有参构造方法
public Order(String name, String dishMegs, int times, String addresses,
int states, double sumPrices) {
super();
this.name = name;
this.dishMegs = dishMegs;
this.times = times;
this.addresses = addresses;
this.states = states;
this.sumPrices = sumPrices;
}
// getXxx()/setXxx()方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDishMegs() {
return dishMegs;
}
public void setDishMegs(String dishMegs) {
this.dishMegs = dishMegs;
}
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;
}
}
❤️2、菜品：Food类
package com.cxyzxc.www.orderingmsg;
import java.io.Serializable;
/**
* 菜品类Food类
*
*
*/
public class Food implements Serializable {
private static final long serialVersionUID = 1L;
/** 菜品名称 */
private String dishNames;
/** 菜品单价 */
private double prices;
/** 菜品的点赞数 */
private int praiseNums;
// 无参构造方法
public Food() {
super();
}
// 有参构造方法
public Food(String dishNames, double prices, int praiseNums) {
super();
this.dishNames = dishNames;
this.prices = prices;
this.praiseNums = praiseNums;
}
//getXxx()/setXxx()方法
public String getDishNames() {
return dishNames;
}
public void setDishNames(String dishNames) {
this.dishNames = dishNames;
}
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;
}
}
package com.cxyzxc.www.orderingmsg;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
* 订单管理系统类
*
*
*/
public class OrderMgr {
// 创建键盘录入对象
Scanner input = new Scanner(System.in);
int num = -1; // 用户输入0返回主菜单，否则退出系统
boolean isExit = false; // 标志用户是否退出系统： true:退出系统
boolean isSignFind = false; // 找到要签收的订单，判断要签收的订单是否能找到，true表示能找到，false表示不能找到
boolean isDelFind = false; // 找到要删除的订单，判断要删除的订单是都能找到，true表示能找到，false表示不能找到
// 搭建项目整体流程
public void start() {
do {
// menu()方法和start()方法在同一个类中，并且都是非静态方法，可以直接通过方法名调用
menu();
int choose = input.nextInt();
// 根据用户选择的功能编号执行相应功能
switch (choose) {
case 1:// 订餐
orderFood();
break;// 这个break的作用是跳出switch选择结构
case 2:// 查询订单
queryOrder();
break;// 这个break的作用是跳出switch选择结构
case 3:// 签收订单
signOrder();
break;// 这个break的作用是跳出switch选择结构
case 4:// 删除订单
deleteOrder();
break;// 这个break的作用是跳出switch选择结构
case 5:// 点赞
thumbsUp();
break;// 这个break的作用是跳出switch选择结构
case 6:
// 退出系统
isExit = true;
break;// 这个break的作用是跳出switch选择结构
default:
// 退出系统
isExit = true;
break;// 这个break的作用是跳出switch选择结构
}
// 循环结构中变量的迭代部分
if (!isExit) {
System.out.print("输入0返回：");
num = input.nextInt();
} else {
break;// 这个break的作用是跳出do-while循环结构
}
} while (num == 0);
System.out.println("谢谢使用，欢迎下次光临！");
input.close();
}
// 初始化
public void init() {
/** 使用泛型创建集合orders，存储所有订单 */
List<Order> orders = new ArrayList<Order>();
/** 使用泛型创建集合foods，存储所有菜品 */
List<Food> foods = new ArrayList<Food>();
// 创建2个Order对象，存储到Orders集合中
Order order1 = new Order("张三", "红烧带鱼 2份", 3, "天成路207号", 1, 76.0);
Order order2 = new Order("李四", "鱼香肉丝 2份", 10, "天成路207号", 0, 20.0);
orders.add(order1);
orders.add(order2);
writeOrder(orders);
// 创建3个Food对象，存储到Foods集合中
Food food1 = new Food("红烧带鱼", 38.0, 10);
Food food2 = new Food("鱼香肉丝", 20.0, 20);
Food food3 = new Food("时令鲜蔬", 10.0, 0);
foods.add(food1);
foods.add(food2);
foods.add(food3);
writeFood(foods);
}
// 输出欢迎菜单
public void menu() {
System.out.println("\n欢迎使用“吃货联盟订餐系统”");
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.print("请选择：");
}
// 定义方法实现向orders.txt文件中写入订单信息
public boolean writeOrder(List<Order> orders) {
ObjectOutputStream oosOrder = null;
try {
oosOrder = new ObjectOutputStream(
new FileOutputStream("orders.txt"));
oosOrder.writeObject(orders);
} catch (FileNotFoundException e) {
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (oosOrder != null) {
oosOrder.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return false;
}
// 定义方法实现向foods.txt文件中写入菜品信息
public boolean writeFood(List<Food> foods) {
ObjectOutputStream oosFood = null;
try {
oosFood = new ObjectOutputStream(new FileOutputStream("foods.txt"));
oosFood.writeObject(foods);
} catch (FileNotFoundException e) {
} catch (IOException e) {
e.printStackTrace();
} finally {
if (oosFood != null) {
try {
oosFood.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return false;
}
// 定义方法实现从orders.txt文件中读取订单信息并将读取到的所有订单返回
@SuppressWarnings("resource")
public List<Order> readOrder() {
// 创建输入流
ObjectInputStream oisOrder = null;
try {
oisOrder = new ObjectInputStream(new FileInputStream("orders.txt"));
Object object = oisOrder.readObject();
@SuppressWarnings("unchecked")
ArrayList<Order> al = (ArrayList<Order>) object;
return al;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
// 定义方法实现从foods.txt文件中读取订单信息并将读取到的所有订单返回
@SuppressWarnings("resource")
public List<Food> readFood() {
// 创建输入流
ObjectInputStream oisOrder = null;
try {
oisOrder = new ObjectInputStream(new FileInputStream("foods.txt"));
Object object = oisOrder.readObject();
@SuppressWarnings("unchecked")
ArrayList<Food> al = (ArrayList<Food>) object;
return al;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
// 点餐
public void orderFood() {
// 获取系统中的订单数据和菜品数据
List<Order> orderList = readOrder();
List<Food> foodList = readFood();
// 我要订餐
System.out.println("***我要订餐***");
System.out.print("请输入订餐人姓名：");
String name = input.next();
// 显示供选择的菜品信息
System.out.println("序号" + "\t" + "菜名" + "\t" + "单价" + "\t" + "点赞数");
for (int i = 0; i < foodList.size(); i++) {
String price = foodList.get(i).getPrices() + "元";
String priaiseNum = (foodList.get(i).getPraiseNums()) > 0 ? foodList
.get(i).getPraiseNums() + "赞"
: "";
System.out.println((i + 1) + "\t" + foodList.get(i).getDishNames()
+ "\t" + price + "\t" + priaiseNum);
}
// 用户点菜
System.out.print("请选择您要点的菜品编号:");
int chooseDish = input.nextInt();
System.out.print("请选择您需要的份数:");
int number = input.nextInt();
String dishMeg = foodList.get(chooseDish - 1).getDishNames() + number
+ "份";// 菜品名+份数拼接成菜品信息
double sumPrice = foodList.get(chooseDish - 1).getPrices() * number;
// 餐费满50元，免送餐费6元
double deliCharge = (sumPrice >= 50) ? 0 : 6;
System.out.print("请输入送餐时间（送餐时间是10点至20点间整点送餐）:");
int time = input.nextInt();
while (time < 10 || time > 20) {
System.out.print("您的输入有误，请输入10~20间的整数！");
time = input.nextInt();
}
System.out.print("请输入送餐地址：");
String address = input.next();
// 无需添加状态，默认是0，即已预定状态。
System.out.println("订餐成功！");
System.out.println("您订的是：" + dishMeg);
System.out.println("送餐时间：" + time + "点");
System.out.println("餐费：" + sumPrice + "元，送餐费" + deliCharge + "元，总计："
+ (sumPrice + deliCharge) + "元。");
// 获取订单需要的6个数据后，使用这6个数据利用Order类中的有参构造方法创建Order对象，将对象添加到orders集合中
Order order = new Order(name, dishMeg, time, address, 0, sumPrice
+ deliCharge);
orderList.add(order);
writeOrder(orderList);
System.out.println("订单订购成功");
}
// 查看订单
public void queryOrder() {
List<Order> orderList = readOrder();
// 查看餐袋
System.out.println("***查看餐袋***");
System.out.println("序号\t订餐人\t餐品信息\t\t送餐日期\t送餐地址\t\t总金额\t订单状态");
for (int i = 0; i < orderList.size(); i++) {
String state = (orderList.get(i).getStates() == 0) ? "已预定" : "已完成";
String date = orderList.get(i).getTimes() + "点";
String sumPrice = orderList.get(i).getSumPrices() + "元";
System.out.println((i + 1) + "\t" + orderList.get(i).getName()
+ "\t" + orderList.get(i).getDishMegs() + "\t" + date
+ "\t" + orderList.get(i).getAddresses() + "\t" + sumPrice
+ "\t" + state);
}
}
// 签收订单
public void signOrder() {
List<Order> orderList = readOrder();
// 签收定单
System.out.println("***签收定单***");
System.out.print("请选择要签收的订单序号：");
int signOrderId = input.nextInt();
for (int i = 0; i < orderList.size(); i++) {
// 状态为已预定，序号为用户输入的订单序号：可签收
// 状态为已完成，序号为用户输入的订单序号：不可签收
if (orderList.get(i).getStates() == 0 && signOrderId == (i + 1)) {
orderList.get(i).setStates(1); // 将状态值置为已完成
System.out.println("订单签收成功！");
isSignFind = true;
} else if (orderList.get(i).getStates() == 1
&& signOrderId == (i + 1)) {
System.out.println("您选择的订单已完成签收，不能再次签收！");
isSignFind = true;
}
}
// 未找到的订单序号：不可签收
if (!isSignFind) {
System.out.println("您选择的订单不存在！");
}
writeOrder(orderList);
}
// 删除订单
public void deleteOrder() {
List<Order> orderList = readOrder();
// 删除订单
System.out.println("***删除订单***");
System.out.print("请输入要删除的订单序号:");
int delId = input.nextInt();
for (int i = 0; i < orderList.size(); i++) {
// 状态值为已完成 序号值为用户输入的序号：可删除
// 状态值为已预定 序号值为用户输入的序号：不可删除
if (orderList.get(i).getStates() == 1 && delId == (i + 1)) {
isDelFind = true;// 表示找到了要删除的订单，并且订单可以删除
orderList.remove(i);
System.out.println("删除订单成功！");
break;// 这个break的作用是跳出203行的for循环结构
} else if (orderList.get(i).getStates() == 0 && delId == (i + 1)) {
System.out.println("您选择的订单未签收，不能删除！");
isDelFind = true;// 表示找到了要删除的订单，并且订单不可以删除
break;// 这个break的作用是跳出203行的for循环结构
}
}
// 未找到该序号的订单：不能删除
if (!isDelFind) {// isDelFind=false表示没有找到要删除的订单
System.out.println("您要删除的订单不存在！");
}
writeOrder(orderList);
}
// 点赞
public void thumbsUp() {
List<Food> foodList = readFood();
// 我要点赞
System.out.println("***我要点赞***");
// 显示菜品信息
System.out.println("序号" + "\t" + "菜名" + "\t" + "单价");
// 遍历Foods集合，取出里面的Food对象，输出信息并重新设置点赞数目
for (int i = 0; i < foodList.size(); i++) {
String price = foodList.get(i).getPrices() + "元";
String priaiseNum = (foodList.get(i).getPraiseNums() > 0) ? foodList
.get(i).getPraiseNums() + "赞"
: "";
System.out.println((i + 1) + "\t" + foodList.get(i).getDishNames()
+ "\t" + price + "\t" + priaiseNum);
}
System.out.print("请选择您要点赞的菜品序号：");
int priaiseNum = input.nextInt();
int good = foodList.get(priaiseNum - 1).getPraiseNums() + 1;
foodList.get(priaiseNum - 1).setPraiseNums(good); // 赞数加1
writeFood(foodList);
System.out.println("点赞成功！");
}
}
package com.cxyzxc.www.orderingmsg;
public class Test {
public static void main(String[] args) {
OrderMgr om = new OrderMgr();
//初始化数据
om.init();
//执行订餐系统
om.start();
}
}
⛳️效果展示
码文不易，本篇文章就介绍到这里，如果想要学习更多Java系列知识，请关注博主，博主带你零基础学习Java知识。与此同时，对于日常生活有困扰的朋友，欢迎阅读我的第四栏目：《国学周更—心性养成之路》，学习技术的同时，我们也注重了心性的养成。
