11.21号吃货联盟订餐系统

<吃货联盟订餐系统>
package day17;
public class day17_03 {
public static void main(String[]args){
day17_01 a=new day17_01(); /定义程序的类
a.huanying(); /调用程序的方法，方法名是huanying
/ 程序开始
/ 欢迎用户
/ 显示功能菜单
/ 接收用户的选择
/ 1.我要订餐
/ 2.查看餐袋
/ 3.签收订单
/ 4.删除订单
/ 5.商家评论
/ 6.退出系统
/ 其他：非法输入，重新输入
/ 选择完毕，重新选择
/
}

程序的类文件
数据初始化：定义数组，保存订单信息，菜单和商家评论

import java.util.Scanner; /接收键盘输入
public class day17_01 {
String ks=“Game”;

/一组订单信息
String[] name=new String[10];        /保存订单人名称
String[] shangjia=new String[10];    /保存订单选择的商家名称
String[] xinxi=new String[10];       /保存选择的菜品和份数的信息
int[] shijian=new int[10];           /保存送餐时间
String[] dizhi=new String[10];       /保存送餐地址
double[] money=new double[10];       /保存订单的总金额
int[] zhuangtai=new int[10];         /保存订单状态，0表示已预定，1表示已完成

/菜单信息
String[] caiming=new String[5];      /保存菜单的5个菜名
double[] money1=new double[5];       /保存菜单的5个单价
int[] xiaoliang=new int[5];          /保存菜单的5个销量
int[] kongge=new int[5];             /保存5个菜名的空格，让长短不一的菜名保持垂直
String shangjia_;                    /保存商家名称

/评论信息
String[] pinglun1=new String[50];       /记录华莱士.炸鸡汉堡，的评论，最多50
String[] pinglun2=new String[50];       /记录三国龙虾.烧烤.虾蟹，的评论，最多50
String[] pinglun3=new String[50];       /记录铁板炒饭，的评论，最多50
String[] pinglun4=new String[50];       /记录襄阳牛肉面，的评论，最多50
String[] pinglun5=new String[50];       /记录吾饮良品.水果茶，的评论，最多50
String[] pinglun6=new String[50];       /记录尊宝比萨，的评论，最多50

Scanner a=new Scanner(System.in);

实现欢迎的方法，入口文件会调用该方法，让程序开始

实现功能菜单，用于选择功能

public void gongneng(){            /写一个功能菜单的方法，用于选择功能
    b:while(true){            /循环包裹，用于输入错误，重复执行
        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("请选择：");

        int xz=a.nextInt();        /接收键盘输入的数字，用于选择功能
        switch(xz){
            case 1:                                            /输入数字是1，进入选择商家的方法
                System.out.println("***我要订餐***");
                shangjia();
                break;
            case 2:                                            /输入数字是2，进入查看订单的方法
                System.out.println("***查看订单***");
                chakan();
                break;
            case 3:                                            /输入数字是3，进入签收订单的方法
                System.out.println("***签收订单***");
                qianshou();
                break;
            case 4:                                            /输入数字是4，进入删除订单的方法
                System.out.println("***删除/退单***");
                shanchu();
                break;
            case 5:                                            /输入数字是5，进入商家评价的方法
                System.out.println("***商家评论***");
                pinglun();
                break;
            case 6:                                            /输入数字是6，结束程序
                System.out.println("***退出系统***");
                System.out.println("谢谢使用，欢迎下次使用！");
                break b;              /结束b标记位，也就是外围循环
            default:
                System.out.println("***输入有误，请重新输入***");   /输入其他，重新输入
        }
    }
}

实现我要订单的功能：第一步选择商家菜单，第二步订餐
一：选择商家订单

public void shangjia(){       /写一个选择商家的方法，用于选择商家的菜单
    while(true){        /最外层循环包裹
    
    	/打印商家菜单
        System.out.println("序号"+"\t\t"+"商家"+"\t\t\t\t"+"评分"+"\t\t\t"+"月售");
        System.out.println(" 1"+"\t"+"<华莱士.全鸡汉堡>"+"\t\t"+"4.6分"+"\t\t"+"3749"+"\n"+" 2"+"\t"+"<三国龙虾.烧烤.虾蟹>"+"\t"+"4.4分"+"\t\t"+"2372");
        System.out.println(" 3"+"\t"+"<铁板炒饭>"+"\t\t\t"+"4.7分"+"\t\t"+"3177"+"\n"+" 4"+"\t"+"<襄阳牛肉面>"+"\t\t\t"+"4.3分"+"\t\t"+"4703");
        System.out.println(" 5"+"\t"+"<吾饮良品.水果茶>"+"\t\t"+"4.7分"+"\t\t"+"3294"+"\n"+" 6"+"\t"+"<尊宝比萨>"+"\t\t\t"+"4.7分"+"\t\t"+"1169\n");
        System.out.print("请选择你要查看的商家(返回：7)：");
        
        int xz=a.nextInt();        /接收键盘输入的数字，用于选择商家
        switch(xz){
            case 1:                     /输入数字是1，修改菜单为华莱士.全鸡汉堡，并调用订餐的方法
                System.out.println("***华莱士.全鸡汉堡***");
                caiming[0]="香辣鸡腿汉堡\t\t";        /修改菜品名称，水平制表\t可以让菜品名称垂直对齐
                caiming[1]="香辣鸡翅(1对)\t";
                caiming[2]="藤椒脆骨(8个)\t";
                caiming[3]="薯条\t\t\t\t";
                caiming[4]="秘制烤全鸡\t\t";
                money1[0]=13.9;                      /修改菜品价格为华莱士.全鸡汉堡的5个菜的价格
                money1[1]=13.9;
                money1[2]=11.9;
                money1[3]=11.9;
                money1[4]=23.8;
                xiaoliang[0]=749;                    /修改菜品销量为华莱士.全鸡汉堡的5个菜的销量
                xiaoliang[1]=602;
                xiaoliang[2]=531;
                xiaoliang[3]=444;
                xiaoliang[4]=1136;
                kongge[0]=2;                         /记录菜品空格，以便知道有几个水平制表，方便在订单信息后面添加
                kongge[1]=1;						 /作用：输出订单时，让长短不一的菜品名称垂直对齐
                kongge[2]=1;
                kongge[3]=4;
                kongge[4]=2;
                shangjia_="华莱士.全鸡汉堡\t\t";
                dincan();
            case 2:                     /输入数字是2，修改菜单为三国龙虾.烧烤.虾蟹，并进入订餐的方法
                System.out.println("***三国龙虾.烧烤.虾蟹***");
                caiming[0]="油闷大虾*15\t\t";
                caiming[1]="麻辣虾尾*70\t\t";
                caiming[2]="秘制大闸蟹*5\t\t";
                caiming[3]="牛肉小串*30\t\t";
                caiming[4]="麻辣小田螺\t\t";
                money1[0]=51.1;
                money1[1]=67.3;
                money1[2]=44.7;
                money1[3]=20;
                money1[4]=15.9;
                xiaoliang[0]=549;
                xiaoliang[1]=302;
                xiaoliang[2]=414;
                xiaoliang[3]=581;
                xiaoliang[4]=536;
                kongge[0]=2;
                kongge[1]=2;
                kongge[2]=2;
                kongge[3]=2;
                kongge[4]=2;
                shangjia_="三国龙虾.烧烤.虾蟹\t\t";
                dincan();
            case 3:                     /输入数字是3，修改菜单为铁板炒饭，并进入订餐的方法
                System.out.println("***铁板炒饭***");
                caiming[0]="鸡蛋牛肉炒饭\t\t";
                caiming[1]="火腿里脊肉炒饭\t\t";
                caiming[2]="鸡蛋蟹排炒饭\t\t";
                caiming[3]="鸡蛋火腿炒饭\t\t";
                caiming[4]="腊味双拼炒饭\t\t";
                money1[0]=16.8;
                money1[1]=16.8;
                money1[2]=15.8;
                money1[3]=14.8;
                money1[4]=17.8;
                xiaoliang[0]=598;
                xiaoliang[1]=520;
                xiaoliang[2]=453;
                xiaoliang[3]=967;
                xiaoliang[4]=638;
                kongge[0]=2;
                kongge[1]=2;
                kongge[2]=2;
                kongge[3]=2;
                kongge[4]=2;
                shangjia_="铁板炒饭\t\t\t\t";
                dincan();
            case 4:                     /输入数字是4，修改菜单为襄阳牛肉面，并进入订餐的方法
                System.out.println("***襄阳牛肉面***");
                caiming[0]="红油牛肉粉面\t\t";
                caiming[1]="红油牛杂粉面\t\t";
                caiming[2]="豆腐海带粉面\t\t";
                caiming[3]="牛肉牛杂双拼\t\t";
                caiming[4]="飘香杂酱面\t\t";
                money1[0]=13.92;
                money1[1]=13.92;
                money1[2]=10;
                money1[3]=24;
                money1[4]=11.8;
                xiaoliang[0]=1219;
                xiaoliang[1]=952;
                xiaoliang[2]=816;
                xiaoliang[3]=611;
                xiaoliang[4]=472;
                kongge[0]=2;
                kongge[1]=2;
                kongge[2]=2;
                kongge[3]=2;
                kongge[4]=2;
                shangjia_="襄阳牛肉面\t\t\t";
                dincan();
            case 5:                     /输入数字是5，修改菜单为吾饮良品.水果茶，并进入订餐的方法
                System.out.println("***吾饮良品.水果茶***");
                caiming[0]="珍珠奶茶\t\t\t";
                caiming[1]="芋圆波波奶茶\t\t";
                caiming[2]="奥利奥乌云玛奇朵\t";
                caiming[3]="草莓玛奇朵\t\t";
                caiming[4]="满杯烧仙草\t\t";
                money1[0]=10;
                money1[1]=11;
                money1[2]=13;
                money1[3]=14;
                money1[4]=11;
                xiaoliang[0]=542;
                xiaoliang[1]=810;
                xiaoliang[2]=914;
                xiaoliang[3]=432;
                xiaoliang[4]=478;
                kongge[0]=3;
                kongge[1]=2;
                kongge[2]=1;
                kongge[3]=2;
                kongge[4]=2;
                shangjia_="吾饮良品.水果茶\t\t";
                dincan();
            case 6:                     /输入数字是6，修改菜单为尊宝比萨，并进入订餐的方法
                System.out.println("***尊宝比萨***");
                caiming[0]="奥尔良比萨8英寸\t";
                caiming[1]="水果比萨8英寸\t\t";
                caiming[2]="榴莲比萨8英寸\t\t";
                caiming[3]="奶酪比萨8英寸\t\t";
                caiming[4]="香肠比萨8英寸\t\t";
                money1[0]=23.9;
                money1[1]=23.9;
                money1[2]=31.9;
                money1[3]=23.9;
                money1[4]=23.9;
                xiaoliang[0]=342;
                xiaoliang[1]=216;
                xiaoliang[2]=460;
                xiaoliang[3]=63;
                xiaoliang[4]=21;
                kongge[0]=1;
                kongge[1]=2;
                kongge[2]=2;
                kongge[3]=2;
                kongge[4]=2;
                shangjia_="尊宝比萨\t\t\t\t";
                dincan();
            case 7:                     /输入数字是7，返回到功能菜单
                System.out.println("***返回***");
                gongneng();
            default:                    /输入其他，重新输入
                System.out.println("***输入有误，请重新输入***");
        }
    }

二：订餐

public void dincan(){         /写一个订餐的方法，用于订餐
    boolean jc=false;           /写一个布尔值，判断订餐的数组有没有空位
    for(int i=0;i<name.length;i++){
        if(name[i]==null){                /遍历查找存订单的数组有没有空位，有的话，就把用户的订单存在这个空位
            jc=true;                      /订餐成功true
            System.out.println("请输入订餐人姓名：");
            String name_=a.next();        /接收输入的订餐人姓名
            
            /打印菜单
            System.out.println("序号"+"\t\t"+"菜名"+"\t\t\t"+"单价"+"\t\t"+"销量");
            for(int j=0;j<caiming.length;j++){        /遍历打印菜名，单价，销量
                System.out.println(" "+(j+1)+"\t"+caiming[j]+money1[j]+"\t"+xiaoliang[j]);
            }
            
            System.out.print("请选择您要点的菜品编号：");
            int bianhao=a.nextInt();                  /接收输入的菜品编号
            while(bianhao>5||bianhao<1){              /循环判断编号是不是1-5，不是就重新输入
                System.out.println("您的输入有误，请输入菜品编号1-5");
                bianhao=a.nextInt();
            }
            
            System.out.print("请选择您需要的份数,最多20份：");
            int fenshu=a.nextInt();                   /接收输入的份数
            while(fenshu>20||fenshu<1){               /循环判断份数是不是1-20
                System.out.println("您的输入有误，请输入份数1-20");
                fenshu=a.nextInt();
            }
            
            String xinxi_= caiming[bianhao-1]+" "+fenshu+"份";    /用于临时保存选择的菜品和份数的信息
            int peisong=0;                                        /配送费，默认0元
            double money_=money1[bianhao-1]*fenshu+fenshu;        /用于临时保存订单的总金额
            
            System.out.print("请输入送餐时间(夜间配送,加收配送费)：");
            int shijian_=a.nextInt();                 /接收输入的送餐时间
            while(shijian_>24||shijian_<0){           /循环判断时间是不是0-24
                    System.out.println("您的输入有误，请输入送餐时间0-24");
                    shijian_=a.nextInt();
            }
            if(shijian_>=22||shijian_<=5) {           /时间在晚22点至早5点，加收6元配送费
                System.out.println("夜间配送，加收6元配送费");
                peisong+=6;                           /配送费+6元
                money_ +=peisong;                     /总金额+6元
            }
            
            System.out.print("请输入送餐地址；");
            String dizhi_=a.next();                 /接收输入的送餐地址
            System.out.println("***订餐成功***\t<"+xinxi_+">");
            
            for(int kong=0;kong<kongge[bianhao-1];kong++){
                xinxi_+="\t";          /在信息后面添加水平制表，用于垂直对齐
            }
            
            /打印收费表
            System.out.println("送餐时间\t\t\t\t<"+shijian_+":00>");
            System.out.println("主食\t\t\t\t\t￥"+money1[bianhao-1]*fenshu+"\n包装费\t\t\t\t￥"+fenshu+"\n配送费(吃货联盟快送)\t￥"+peisong+"\n合计\t\t\t\t\t<￥"+money_+">");
            
            /添加订单数据，订单状态无需添加，默认是0，既已预定状态
            name[i]=name_;             /名称
            xinxi[i]=xinxi_;           /菜品和份数的信息
            shijian[i]=shijian_;       /送餐时间
            dizhi[i]=dizhi_;           /送餐地址
            money[i]=money_;           /总金额
            shangjia[i]=shangjia_;     /选择的商家
            break;
        }
    }
    if(!jc){             /订单的数组没有空位，提示订单已满
        System.out.println("对不起，您的餐袋已满！");
        fanhui();             /调用返回的方法;
    }else{               /否则不提示
        fanhui();             /调用返回的方法;
    }
}

写一个返回的方法，用于返回到功能菜单

public void fanhui(){      /写一个返回的方法，用于返回到功能菜单
    System.out.print("输入任意符返回");
    String fh=a.next();       /接收键盘输入
    gongneng();               /调用功能菜单的方法
}

实现查看订单的功能

public void chakan(){     /写一个查看订单的方法，用于查看订单
    System.out.println("序号\t\t商家\t\t\t\t\t订餐人\t餐品信息\t\t\t\t送餐时间\t送餐地址\t总金额\t订单状态");
    
    for(int i=0;i<name.length;i++){
        if(name[i]!=null){               /判断name数组有没有值，有就打印订单
            String jc=(zhuangtai[i]==0)?"已预定":"已送达";    /判断订单状态是0赋值已预定，1赋值已送达
            String shijian_= shijian[i]+":00";               /赋值送餐时间为1：00格式
            String zong="￥"+money[i];                       /赋值总金额为￥10格式
            
            订单人名称长度为2，的打印格式
            if(name[i].length()>2){
                System.out.println(" "+(i+1)+"\t\t"+shangjia[i]+name[i]+"\t"+xinxi[i]+shijian_+"\t"+dizhi[i]+"\t"+zong+"\t"+jc);
            订单人名称长度为3，的打印格式
            }else if(name[i].length()<=2){
                System.out.println(" "+(i+1)+"\t\t"+shangjia[i]+name[i]+"\t\t"+xinxi[i]+shijian_+"\t"+dizhi[i]+"\t"+zong+"\t"+jc);
            }
        }
    }
    fanhui();             /调用返回的方法;
}

实现签收订单的功能

public void qianshou(){          /写一个签收订单的方法，用于签收订单
    boolean qianshou=false;           /写一个布尔值，判断订单有没有找到
    System.out.print("请选择要签收的订单序号：");
    int xuhao=a.nextInt();            /接收输入的订单序号
    
    for(int i=0;i<name.length;i++){
        if(name[i]!=null&&zhuangtai[i]==0&&xuhao==i+1){      /判断订单是否存在，且状态为已预定
            qianshou=true;		           /找到订单true
            zhuangtai[i]=1;                /订单状态改为已预定
            System.out.println("订单签收成功！");
            System.out.println("商家："+shangjia[i]+"餐品："+xinxi[i]+"\n请给商家评论打分");
            
            /开始评论打分
            while(true){
                System.out.println("打分1-5：");
                double fen=a.nextDouble();        /接收输入的打分
                if(fen>5||fen<1){                 /打分不在1-5重新输入
                    System.out.println("您的输入有误，请给商家打分1-5");
                }else{
                
                	/打分完，开始评论
                    while(true){
                        System.out.println("评论：");
                        String pinglun_=a.next();        /接收输入的评论
                        System.out.println("评论并打分成功,您的评论是；"+pinglun_+"\t\t\t"+fen+"分");
                        
						/打分评论完成，评论添加在商家里，if判断添加在哪个商家
                        if(shangjia[i].equals("华莱士.全鸡汉堡\t\t")){    /判断订单的商家名称是否相等
                            for(int pl_=49;pl_>=0;pl_--){          /添加评论，从数组后面往前添加
                                if(pinglun1[pl_]==null){           /找到空位，开始添加
                                    pinglun1[pl_]=pinglun_+"\t\t\t"+fen+"分";
                                    fanhui();             /调用返回的方法;
                                }
                            }
                        
                        /后面道理相同
                        }else if(shangjia[i].equals("三国龙虾.烧烤.虾蟹\t\t")){
                            for(int pl_=49;pl_>=0;pl_--){
                                if(pinglun2[pl_]==null){
                                    pinglun2[pl_]=pinglun_+"\t\t\t"+fen+"分";
                                    fanhui();
                                }
                            }
                        }else if(shangjia[i].equals("铁板炒饭\t\t\t\t")){
                            for(int pl_=49;pl_>=0;pl_--){
                                if(pinglun3[pl_]==null){
                                    pinglun3[pl_]=pinglun_+"\t\t\t"+fen+"分";
                                    fanhui();
                                }
                            }
                        }else if(shangjia[i].equals("襄阳牛肉面\t\t\t")){
                            for(int pl_=49;pl_>=0;pl_--){
                                if(pinglun4[pl_]==null){
                                    pinglun4[pl_]=pinglun_+"\t\t\t"+fen+"分";
                                    fanhui();
                                }
                            }
                        }else if(shangjia[i].equals("吾饮良品.水果茶\t\t")){
                            for(int pl_=49;pl_>=0;pl_--){
                                if(pinglun5[pl_]==null){
                                    pinglun5[pl_]=pinglun_+"\t\t\t"+fen+"分";
                                    fanhui();
                                }
                            }
                        }else if(shangjia[i].equals("尊宝比萨\t\t\t\t")){
                            for(int pl_=49;pl_>=0;pl_--){
                                if(pinglun6[pl_]==null){
                                    pinglun6[pl_]=pinglun_+"\t\t\t"+fen+"分";
                                    fanhui();
                                }
                            }
                        }
                    }
                }
            }
        }else if(name[i]!=null&&zhuangtai[i]==1&&xuhao==i+1){       /订单存在，但状态为已送达，提示签收过了
            System.out.println("您选择的订单已完成签收，不能再次签收！");
        }
    }
    if(!qianshou){		  /未找到订单，提示订单不存在
        System.out.println("您选择的订单不存在!");
    }
    fanhui();             /调用返回的方法;
}

实现删除订单 / 退单功能

public void shanchu(){          /写一个删除订单的方法，用于删除订单
    boolean shanchu=false;                /写一个布尔值，判断订单有没有找到
    System.out.print("请选择要删除/退单的订单序号：");
    int xuhao=a.nextInt();                /接收输入的订单序号
    a:for(int i=0;i<name.length;i++){
        if(name[i]!=null&&zhuangtai[i]==1&&xuhao==i+1){      /判断订单是否存在，且状态为已签收
        	shanchu=true;                 /找到订单true
            System.out.println("订单状态已送达，您确定要删除订单吗？\t确定/取消：Y/N");
            String qr=a.next();           /接收输入的Y或N
            
            while(true){
                if(qr.equals("Y")){           /输入为Y，执行删除操作：删除位置后的元素依次前移
                    for(int j=xuhao-1;j<name.length-1;j++){    /从输入的订单所在的下标后的元素，依次前移
                        name[j]=name[j+1];            /数组元素前移一位
                        shangjia[j]=shangjia[j+1];
                        zhuangtai[j]=zhuangtai[j+1];
                        xinxi[j]=xinxi[j+1];
                        shijian[j]=shijian[j+1];
                        dizhi[j]=dizhi[j+1];
                        money[j]=money[j+1];
                    }
                    
                    /数组最后一位清空
                    int zuihou=name.length-1;      /计算出最后一位下标
                    name[zuihou]=null;
                    shangjia[zuihou]=null;
                    xinxi[zuihou]=null;
                    shijian[zuihou]=0;
                    dizhi[zuihou]=null;
                    money[zuihou]=0;
                    zhuangtai[zuihou]=0;
                    System.out.println("订单删除成功！");
                    break a;                            /结束外层循环，然后调用返回的方法
                    
                }else if(qr.equals("N")){               /输入为N,直接调用返回的方法
                    System.out.println("订单未变更");
                    break a;
                }else{
                    System.out.println("您的输入有误，请输入Y/N");
                    qr=a.next();                        /输入不为Y或N，重新输入
                }
            }
        }else if(name[i]!=null&&zhuangtai[i]==0&&xuhao==i+1){
            System.out.println("订单状态已预定，您确定要退单吗？\t确定/取消：Y/N");
            String qr=a.next();           /接收输入的Y或N
            while(true){
                if(qr.equals("Y")){           /输入为Y，执行删除操作：删除位置后的元素依次前移
                    for(int j=xuhao-1;j<name.length-1;j++){
                        name[j]=name[j+1];
                        shangjia[j]=shangjia[j+1];
                        zhuangtai[j]=zhuangtai[j+1];
                        xinxi[j]=xinxi[j+1];
                        shijian[j]=shijian[j+1];
                        dizhi[j]=dizhi[j+1];
                        money[j]=money[j+1];
                    }
                    
                    /数组最后一位清空
                    int zuihou=name.length-1;      /计算出最后一位下标
                    name[zuihou]=null;
                    shangjia[zuihou]=null;
                    xinxi[zuihou]=null;
                    shijian[zuihou]=0;
                    dizhi[zuihou]=null;
                    money[zuihou]=0;
                    zhuangtai[zuihou]=0;
                    System.out.println("订单已退款并删除成功！");
                    break a;                            /结束外层循环，然后调用返回的方法
                    
                }else if(qr.equals("N")){               /输入为N,直接调用返回的方法
                    System.out.println("订单未变更");
                    break a;
                }else{
                    System.out.println("您的输入有误，请输入Y/N");
                    qr=a.next();                        /输入不为Y或N，重新输入
                }
            }
        }
    }
    if(!shanchu){		  /未找到订单，提示订单不存在
        System.out.println("您选择的订单不存在!");
    }
    fanhui();             /调用返回的方法;
}

实现查看评论功能，最后一个功能

public void pinglun(){          /写一个查看评论的方法，用于查看评论
    while(true){          /循环包裹，用于输入错误，重复执行
        System.out.println("序号"+"\t\t"+"商家"+"\t\t\t\t"+"评分"+"\t\t\t"+"月售");
        System.out.println(" 1"+"\t"+"<华莱士.全鸡汉堡>"+"\t\t"+"4.6分"+"\t\t"+"3749"+"\n"+" 2"+"\t"+"<三国龙虾.烧烤.虾蟹>"+"\t"+"4.4分"+"\t\t"+"2372");
        System.out.println(" 3"+"\t"+"<铁板炒饭>"+"\t\t\t"+"4.7分"+"\t\t"+"3177"+"\n"+" 4"+"\t"+"<襄阳牛肉面>"+"\t\t\t"+"4.3分"+"\t\t"+"4703");
        System.out.println(" 5"+"\t"+"<吾饮良品.水果茶>"+"\t\t"+"4.6分"+"\t\t"+"3294"+"\n"+" 6"+"\t"+"<尊宝比萨>"+"\t\t\t"+"4.4分"+"\t\t"+"1169\n");
        System.out.print("请选择你要查看评论的商家(返回：7)：");
        int xz=a.nextInt();           				  /接收输入的数字，用于选择商家
        switch(xz){
            case 1:                            		  /输入数字是1，打印华莱士.全鸡汉堡的评论
                System.out.println("***华莱士.全鸡汉堡***");
                for(int dy=0;dy<pinglun1.length;dy++){       /遍历记录<华莱士.全鸡汉堡>评论的数组
                    if(pinglun1[dy]!=null){                  /打印有记录的评论
                        System.out.println(pinglun1[dy]);
                    }
                }
                fanhui();
            case 2:                            		  /输入数字是2，打印三国龙虾.烧烤.虾蟹的评论
                System.out.println("***三国龙虾.烧烤.虾蟹***");
                for(int dy=0;dy<pinglun2.length;dy++){       /遍历记录<三国龙虾.烧烤.虾蟹>评论的数组
                    if(pinglun2[dy]!=null){                  /打印有记录的评论
                        System.out.println(pinglun2[dy]);
                    }
                }
                fanhui();
            case 3:                            		  /输入数字是3，打印铁板炒饭的评论
                System.out.println("***铁板炒饭***");
                for(int dy=0;dy<pinglun3.length;dy++){       /遍历记录<铁板炒饭>评论的数组
                    if(pinglun3[dy]!=null){                  /打印有记录的评论
                        System.out.println(pinglun3[dy]);
                    }
                }
                fanhui();
            case 4:                            		  /输入数字是4，打印襄阳牛肉面的评论
                System.out.println("***襄阳牛肉面***");
                for(int dy=0;dy<pinglun4.length;dy++){       /遍历记录<襄阳牛肉面>评论的数组
                    if(pinglun4[dy]!=null){                  /打印有记录的评论
                        System.out.println(pinglun4[dy]);
                    }
                }
                fanhui();
            case 5:                            		  /输入数字是5，打印吾饮良品.水果的评论
                System.out.println("***吾饮良品.水果茶***");
                for(int dy=0;dy<pinglun5.length;dy++){       /遍历记录<吾饮良品.水果>评论的数组
                    if(pinglun5[dy]!=null){                  /打印有记录的评论
                        System.out.println(pinglun5[dy]);
                    }
                }
                fanhui();
            case 6:                            		  /输入数字是6，打印尊宝比萨的评论
                System.out.println("***尊宝比萨***");
                for(int dy=0;dy<pinglun6.length;dy++){       /遍历记录<尊宝比萨>评论的数组
                    if(pinglun6[dy]!=null){                  /打印有记录的评论
                        System.out.println(pinglun6[dy]);
                    }
                }
                fanhui();
            case 7:                            		  /输入数字是7，返回到功能菜单
                System.out.println("***返回***");
                gongneng();							  /调用功能菜单的方法
            default:                            	  /输入其他，重新输入
                System.out.println("***输入有误，请重新输入***");
        }
    }
}