JAVA大作业1
前言
通过对大作业4，5和期中考试的题目集的学习，我有以下心得：
1.三次题目集的知识点我觉得有这些（1）：输入语句的使用。
（2）：java中多个if（）判断语句的使用。
（3）：java中的if（）和else语句的嵌套使用，这在第一次作业的7-7中用到了该方法来判断三角形的类型。
（3）：java中的四则运算。
（4）：java中的for()循环语句的使用。
（5）：java中的switch()语句的使用。
（6）：java中的一些对字符串处理的方法，例如：a.substring(0,2)，该方法的作用是将字符串a中的第一二位的字符提取出来。
c.equals(s)，该方法是对字符串进行比对的方法，如果字符串c与字符串s相等，则返回true，否则返回false。
a.charAt(i)，该方法是对字符串提取的作用，它可以将字符串a中的第i为提取出来。
（7）：在第一次作业的7-8中，我发现原来java中的浮点数据会有误差，在完成作业的时候应该考虑到精度问题。并且还学会了java中的一中数学处理方法，Math.abs(),该 方法是对括号内的数进行取绝对值的处理。
（8）：在第二次作业中的第一和第二题中我学会了对一道很复杂的题目进行面对对象的程序设计，并且明白面对对象的程序设计与面对过程的程序设计直接的差别。
（9）：在第二次作业的第三题我学会了如何通过基年法来判断该天是周几和通过基年法计算两个日期之间相差的天数。
（10）：java中的分割字符串的方法a.split(" ")，该方法的作用是将字符串a按空格进行分割。
（11）：java中的Arrays.sort（），该方法是将括号内的数进行排序处理。
（12）：java中对数据进行封装（private）
（13）含参构造和无参构造。
（14）正则表达式的使用。在一些需要对输入进行判断时我们就可以用到正则表达式。
（15）继承的使用（父类与子类）继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
继承的作用：通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。
（16）在这几次的大作业学习和期中考试当中，我也充分的理解了类与类之间的关系：
继承关系：继承指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力。
实现关系：实现指的是一个class类实现interface接口（可以是多个）的功能，实现是类与接口之间最常见的关系。
依赖关系：依赖就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A。
关联关系：关联体现的是两个类之间语义级别的一种 强依赖关系，关联可以是单向、双向的。
聚合关系：聚合是关联关系的一种特例，它体现的是整体与部分的关系，即 has-a 的关系。此时整体与部分之间是可分离的，它们可以具有各自的生命周期，部分可以属于 多个整体对象，也可以为多个整体对象共享。
组合关系：组合也是关联关系的一种特例，这种关系比聚合更强，也称为强聚合。它同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也 就意味着部分的生命周期结束。
这两次大次作业的题量还好，主要是第四次作业的判断输入实在是有点恶心，搞了变天也不知道从和开始，最后很无奈，只是写了个System.out.printlnln("wrong format")拿了个15分，现在想起来后悔死了。在写写第五次大作业时候，第一天晚上我花了大概三小时在点菜3的基础上将输入搞好了，当时写这个大作业的时候我还是有很大的动力的，因为我觉得我肯定能拿到及格分，所以每次在我碰到困难的时候我都没有想要放弃，而是遇到困难时静下心来好好想想问题出现在了哪里，然后实在是不知道哪里有问题之后才会找同学问问测试点在哪里，然后一点点拿分，星期五晚上我是0分，星期天晚上我是57分，星期一晚上我就是60分，星期二晚上我是67分 后面到了最后一个晚上，我终于干到了74分，虽然和其他人还是有些差距，但是和上一次大作业相比，我觉得我还是进步了很大。期中考试的话还好，挺简单的，就是在提交最后一题的时候，老是有两个测试点过不去，我就很着急，最后我突然想到原来矩形的面积我还没有加绝对值，这样会导致输出的矩形面积为负数，于是我加上了个Math.abs()成功将测试点拿下得到了100分。
设计与分析
第四次大作业：我设计了7个类，类图如下：
代码如下：
主类：
主类的作用是用来判断输入的输入的：判断输入的是否为菜单，输入的是否为加桌，输入的是否为点菜记录，输入的是否为带点菜，输入的是否为特色菜菜单，输入的是否为带点菜信息，以及判断输入结束end
import java.util.*;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
String[] a=new String[50];//确定一个可以输入50行的数组
int[]b=new int[50];//数组b是用来判断这一行的输入是否合法，是的话这一行变成1，不是的话这一行为0
Menu c=new Menu();
table[] t=new table[50];//桌号数组
Dish g=new Dish();
int i=0;//桌号
int j=0;//菜数
int p=0;//当前处理桌号
int lastdish=0;
int dc1=0,dc2=0,dc3=0,dd1=0,dd2=0,dd3=0,dd4=0;
//输入
int inputnum=0;//输入的行数
int h;
a[0]=in.nextLine();//一行一行的输入
b[0]=0;
while(!a[inputnum].equals("end"))
{
inputnum++;
a[inputnum]=in.nextLine();
b[inputnum]=0;
}
//判断非法
Worn w=new Worn();
w.worninput(a,inputnum,b);//a为输入的一行字符串,inputnum为输入的行数,b
//开始执行
for(h=0;h<inputnum;h++)
{
boolean flagerror=false;//flagerror为false表示输入无误，flagerror为true表示输入无误表示输入有误
if(a[h].matches(""))//其他错误
{
System.out.println("wrong format");
continue;
}
//分割字符
String[] arr = a[h].split(" | | | ");
if(arr.length==4||arr[0].charAt(0)=='t')
{
if(arr[0].equals("table"))//加桌
{
flagerror=true;
lastdish=0;
table x=new table();
x.input(a[h],b[h]);
if(i!=0)
p=t[i-1].searchtime(t,x,i);
if(p==i)//加新桌
{
t[i]=new table();
t[p]=x;
i++;
lastdish=0;//初始化
if(t[p].flag)
System.out.println("table "+t[p].tablenum+": ");
}
else
{
if(t[p].flag)
System.out.println("table "+t[p].tablenum+": ");
lastdish=0;
}
}
else if(arr[0].matches("^[1-9][0-9]{0,1}$"))//自己点菜
{
if(b[h]==1)
{
flagerror=true;
if(i!=0&&t[p].flag)
{
System.out.println("wrong format");
}
continue;
}
dc1=Integer.parseInt(arr[0]);
dc2=Integer.parseInt(arr[2]);
dc3=Integer.parseInt(arr[3]);
if(i!=0&&t[p].flag)
{
if(i!=0)
{
if(dc1<=lastdish)
{
System.out.println("record serial number sequence error");
}
else
{
t[p].selforder.addARecord(0,dc1,arr[1],dc2,dc3,true);
g=c.searthDish(arr[1]);
if(g!=null&&t[p].flag)
{
if(dc2>3&&dc2<10||dc2<=0&&dc2>-10)//情况9
{
System.out.println(dc1+" portion out of range "+dc2);
}
else if(dc3>15)
{
System.out.println(dc1+" num out of range "+dc3);
}
else
{
t[p].selforder.records[t[p].k].d=g;
int x=t[p].selforder.records[t[p].k].getPrice();
lastdish=dc1;
System.out.println(dc1+" "+arr[1]+" "+x);
}
}
t[p].k++;
}
}
}
}
else
{
System.out.println("wrong format");
flagerror=true;
}
}
else if(arr.length==5)//代点
{
if(b[h]==1)
{
flagerror=true;
if(i!=0&&t[p].flag)
{
System.out.println("wrong format");
}
continue;
}
dd1=Integer.parseInt(arr[0]);
dd2=Integer.parseInt(arr[1]);
dd3=Integer.parseInt(arr[3]);
dd4=Integer.parseInt(arr[4]);
if(t[p].searthtable(t,dd1,p)==true)
{
t[p].selforder.addARecord(dd2, dd1, arr[2], dd3,dd4,false);
g=c.searthDish(arr[2]);
if(g!=null)
{
t[p].selforder.records[t[p].k].d=g;
int x=t[p].selforder.records[t[p].k].getPrice();
System.out.println(dd2+" table "+t[p].tablenum+" pay for table "+dd1+" "+x);
}
t[p].k++;
}
}
else if(arr.length==2)
{
if(arr[1].equals("delete"))//删菜
{
if(i!=0)
{
if(b[h]==1)
{
flagerror=true;
if(i!=0)
{
System.out.println("wrong format");
}
continue;
}
if(t[p].flag)
t[p].selforder.delARecordByOrderNum(Integer.parseInt(arr[0]),t[p]);
}
}
else//输入菜单
{
if(b[h]==1)
{
flagerror=true;
System.out.println("wrong format");
continue;
}
if(i!=0&&t[p].flag)//情况1
{
System.out.println("invalid dish");
}
else
{
if(Integer.parseInt(arr[1])>0&&Integer.parseInt(arr[1])<300)
{
c.addDish(arr[0], Integer.parseInt(arr[1]),false);
j++;
}
else
{
System.out.println(arr[0]+" price out of range "+arr[1]);
}
}
}
}
else if(arr.length==3)//特色菜
{
if(b[h]==1)
{
flagerror=true;
System.out.println("wrong format");
continue;
}
if(i!=0&&t[p].flag)
{
System.out.println("invalid dish");
}
else
{
if(arr[2].equals("T"))
{
if(Integer.parseInt(arr[1])>0&&Integer.parseInt(arr[1])<300)
{
c.addDish(arr[0], Integer.parseInt(arr[1]),true);
j++;
}
else
{
System.out.println(arr[0]+" price out of range "+arr[1]);
}
}
}
}
if(flagerror==false&&b[h]==1||a[h].matches("\n| | |null"))//其他错误
{
System.out.println("wrong format");
}
}
for(int l=0;l<i;l++)
{
t[l].getTotalPrice();
}
}
}
Dish类：
Dish类就很简单了，和之前点菜的作用一样
public class Dish {
String name="";//菜品名称
int unit_price;
boolean special=false;//特色菜，true为是
//单价
int getPrice(int portion)
{
int 菜价=0;
//单菜价格
switch(portion)
{
case 1: 菜价=unit_price;break;
case 2: 菜价=(int)Math.ceil(1.0*unit_price*3/2);break;
case 3: 菜价=unit_price*2;break;
}
return 菜价;
}
}
Menu类：
也是和之前的一样
public class Menu {
Dish[] dishs =new Dish[20];
int i=0;//用于记录菜品总数
void addDish(String dishName,int unit_price,Boolean ts)
{
dishs[i]=new Dish();
dishs[i].name=dishName;
dishs[i].unit_price=unit_price;
dishs[i].special=ts;
i++;
}
//菜品数组，保存所有菜品信息
Dish searthDish(String dishName) //根据菜名在菜谱中查找菜品信息，返回Dish对象。
{
int j=0;
int flag=0;
for(j=i-1;j>=0;j--)//从未末端开始查找比对
{
if(dishName.compareTo(dishs[j].name)==0)
{
flag=1;
break;
}
}
if(flag==1)
return dishs[j];
else
{
System.out.println(dishName+" does not exist");
return null;
}
}
}
Order类：
也是和之前的一样
public class Order {
Record[] records=new Record[20];
int j=0;
int[] deletenum=new int[50];//删除序号
//添加一条菜品信息到订单中。
void addARecord(int tablenum,int orderNum,String dishName,int portion,int num,boolean self)//添加一条菜品信息到订单中。
{
records[j]=new Record();
records[j].tablenum=tablenum;//桌号
records[j].orderNum=orderNum;//序号
records[j].d.name=dishName;//菜名
records[j].portion=portion;//份额
records[j].num=num;//份数
records[j].self=self;
j++;//点菜记录加1
}
boolean srarchdelete(int orderNum)//找到返回true
{
int i=0;
for(i=0;i<50;i++)
{
if(deletenum[i]!=0)
{
if(orderNum==deletenum[i])
{
return true;
}
}
else break;
}
deletenum[i]=orderNum;
if(i==0)
{
return false;
}
return false;
}
void delARecordByOrderNum(int orderNum,table t)//根据序号删除一条记录
//试试直接总价减去删除菜
{
if(srarchdelete(orderNum)==false)
{
for(int i=0;i<j;i++)
{
if(t.selforder.records[i].orderNum==orderNum)
{
t.selforder.records[i].num=0;
}
}
}
else//情况4
{
System.out.println("deduplication "+orderNum);
}
}
void srarchrecord(Record g,int k)
{
for(int i=0;i<k;i++)
{
if(g.d.name.equals(records[i].d.name)&&g.portion==records[i].portion&&records[i].self==true)
{
records[i].num+=g.num;
g.num=0;
break;
}
}
}
}
Record类：
public class Record {
Dish d=new Dish();//菜品
int orderNum=0;//序号
int portion=0;//份额
int num=0;//份数
int tablenum=0;//桌号//没什么用
boolean self=true;
int getPrice()
{
int n=0;
n=num*d.getPrice(portion);
return n;
}//计价，计算本条记录的价格
}
table类：
package 点菜4;
import java.util.Calendar;
public class table {
int tablenum;//桌号
String time;//点菜时间
int year=0,month=0,day=0,ww=0,hh=0,mm=0,ss=0;
boolean flag=false;//判断时间是否正确
double count=0;//普通菜折扣
double specialcount=1;//特殊折扣
Order selforder=new Order();//本桌订单
int sum=0;//计算总价
int truesum=0;//未打折价
int k=0;//点菜次数
int sumdish=0;//菜总数
void input(String time,int b)//预处理
{
String[] arr1=time.split(" ");
int blank=0;
for(int bk=0;bk<time.length();bk++)
{
if(time.charAt(bk)==' ')
{
blank++;
}
}
//桌号
if(blank!=3||!arr1[1].matches("^[1-9][0-9]{0,}$")||arr1.length!=4)
{
System.out.println("wrong format");
}
else
{
this.time=arr1[2]+" "+arr1[3];
tablenum=Integer.parseInt(arr1[1]);
if(tablenum<=55&&tablenum>=1)
{
if(this.time.matches("^([0-9]{4}/[0-9]{1,2}/[0-9]{1,2}) ([0-9]{1,2}/[0-9]{1,2}/[0-9]{1,2})$"))
{
if(arr1[2].matches("^(([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3})/((([0]{0,1}[13578]|1[02])/([0]{0,1}[1-9]|[12][0-9]|3[01]))|(([0]{0,1}[469]|11)/([0]{0,1}[1-9]|[12][0-9]|30))|([0]{0,1}2/([1-9]|[1][0-9]|2[0-8]))))|((([0-9]{2})([48]|[0]{0,1}[2468][048]|[0]{0,1}[13579][26])|(([48]|[2468][048]|[3579][26])00))/[0]{0,1}2/29)$")&&arr1[3].matches("^([0-9]|([01][0-9])|(2[0-3]))/([0-9]|([0-5][0-9]))/([0-9]|([0-5][0-9]))$"))
{
boolean flag1=judgetime1();
if(flag1==true)//时间有效
{
timechange();
jscount();
pdflag();
if(b==1)
System.out.println("wrong format");
}
else
{
System.out.println("not a valid time period");
}
}
else
System.out.println(tablenum+" date error");
}
else
System.out.println("wrong format");
}
else
{
System.out.println(arr1[1] +" table num out of range");
}
}
}
boolean judgetime1()//是否有效//使用正则表达式
{
String[] arr=time.split(" ");
boolean flag=arr[0].matches("^(2022|2023)/(([13578]|0[13578]|10|12)/(([1-9]|0[1-9])|([12][0-9])|3[01])|([469]|0[469]|11)/(([1-9]|0[1-9])|([12][0-9])|30)|(2|02)/(([1-9]|0[1-9])|(1[0-9])|(2[0-8])))$");
boolean flag1=arr[1].matches("^([0-9]|([01][0-9])|(2[0-3]))/([0-9]|([0-5][0-9]))/([0-9]|([0-5][0-9]))$");
return (flag&&flag1);
}
void getTotalPrice()//计算桌总价
{
if(flag)
{
int j=selforder.j;
for(int i=j-1;i>=0;i--)
{
selforder.srarchrecord(selforder.records[i],i);
}
for(int i=0;i<j;i++)
{
int x=0;
x=selforder.records[i].getPrice();
//
truesum+=x;
// {
if(selforder.records[i].d.special==true)//特色菜
{
sum+=(int)(x*specialcount+0.5);
}
else
sum+=(int)(x*count+0.5);
}
System.out.println("table "+tablenum+": "+truesum+" "+sum);
}
}
void jscount()//运用时间计算折扣
{
if(ww>=1&&ww<=5)
{
specialcount=0.7;
if(hh>=17&&hh<20)
count=0.8;
else if(hh==20&&mm<30)
count=0.8;
else if(hh==20&&mm==30&&ss==0)
count=0.8;
else if(hh>=11&&hh<=13||hh==10&&mm>=30)
count=0.6;
else if(hh==14&&mm<30)
count=0.6;
else if(hh==14&&mm==30&&ss==0)
count=0.6;
}
else
{
specialcount=1;
if(hh>=10&&hh<=20)
count=1.0;
else if(hh==9&&mm>=30)
count=1.0;
else if(hh==21&&mm<30||hh==21&&mm==30&&ss==0)
count=1.0;
}
}
void pdflag()//判断时间是否正确
{
if(count==0)
{
System.out.println("table "+tablenum+" out of opening hours");
flag=false;
}
else
flag=true;
}
void timechange()//时间转换
{
String[] arr=time.split(" ");
String[] arr1=arr[0].split("/");
String[] arr2=arr[1].split("/");
year=Integer.parseInt(arr1[0]);//时间
month=Integer.parseInt(arr1[1]);
day=Integer.parseInt(arr1[2]);
Calendar c = Calendar.getInstance();
c.set(year,month-1,day);//设置时间
ww=c.get(Calendar.DAY_OF_WEEK);
hh=Integer.parseInt(arr2[0]);//时间
mm=Integer.parseInt(arr2[1]);
ss=Integer.parseInt(arr2[2]);
if(ww==1)
ww=7;
else
ww--;
}
boolean searthtable(table[]t,int num,int p)
{
for(int i=0;i<50;i++)
{
if(t[i]!=null&&i!=p)
{
if(t[i].tablenum==num&&t[i].flag)
return true;
}
else
break;
}
System.out.println("Table number ："+num+" does not exist");
return false;
}
int searchtime(table[]t,table a,int sumtable)//若找到返回对应桌,找不到返回下一个空桌
{
for(int i=0;i<sumtable;i++)
{
if(a.tablenum==t[i].tablenum)
if(a.year==t[i].year)
{
if(a.day==t[i].day)
{
if(a.ww>=1&&a.ww<=5)//周1~5
{
if(a.hh<=14&&t[i].hh<=14||a.hh>14&&t[i].hh>14)//在同一时段
{
return i;
}
}
else//周末
{
if(Math.abs((a.hh-t[i].hh)*60*60+(a.mm-t[i].mm)*60)+(a.ss-t[i].ss)<60*60)//在同一时段
{
return i;
}
}
}
}
}
return sumtable;
}
}
worn类：
这个类我设计的目的就是用来判断非法输入的，将输入的内容都过一遍这个类，就可以知道输入是合格的
public class Worn {
void worninput(String[]a,int num,int[]b)//num为输入行数
{
for(int i=0;i<num;i++)
{
String[] arr=a[i].split(" ");
boolean flag=false;
if(arr.length>5)
{
b[i]=1;//输入个数大于5输入错误
}
if(a[i].matches("^[\u4e00-\u9fa5]{1,} ([1-9][0-9]{0,2})$")==true)//普通菜存入
{
flag=true;
}
else if(a[i].matches("^[\u4e00-\u9fa5]{1,4} ([1-9][0-9]{0,2}) [T]$")==true)//特色菜存入
{
flag=true;
}
else if(arr[0].equals("table")==true)//桌
{
int blank=0;
for(int bk=0;bk<a[i].length();bk++)
{
if(a[i].charAt(bk)==' ')
{
blank++;
}
}
if(arr[1].matches("^([1-9][0-9]{0,})$")&&blank==3)
flag=true;
}
else if(a[i].matches("^[1-9][0-9]{0,2} [\u4e00-\u9fa5]{1,} [1-9] ([1-9][0-9]{0,1})$")==true)//自己点菜
{
flag=true;
}
else if(a[i].matches("^([1-9][0-9]{0,1}) [1-9][0-9]{0,2} [\u4e00-\u9fa5]{1,} [1-9] ([1-9][0-9]{0,1})$")==true)//待点菜
{
flag=true;
}
else if(a[i].matches("^([1-9][0-9]{0,1}) delete$")==true)//删菜
{
flag=true;
}
else if(a[i].matches("^end$")==true)//结尾
{
flag=true;
}
if(flag==false)
{
b[i]=1;
}
}
}
}
第五次大作业：我设计了8个类，类图如下：
代码如下：
Dish类：
package 点菜3;
public class Dish {
String name="";//菜品名称
int unit_price;//菜品单价
int getPrice(int portion)
{
int 菜价=0;
//单菜价格
switch(portion)
{
case 1: 菜价=unit_price;break;
case 2: 菜价=(int)(1.0*unit_price*3/2+0.5);break;//Math.ceil（）为向上取整方法
case 3: 菜价=unit_price*2;break;
}
return 菜价;
}
}
主类：
package 点菜3;
import java.util.*;
class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
String a;
int weidao=0;
Menu c=new Menu();//菜谱对象
table[] t=new table[20];//创立桌号数组
Dish g=new Dish();//普通菜对象
SpecialDish d=new SpecialDish();//特色菜对象
People[] e=new People[100];
int i=0;//桌号
int j=0;//特色菜单菜数
int m=0;//普通菜单菜数
int l=0;
int caiflag=0;
int dcxh=0,dcfe=0,dcfs=0,dd1=0,dd2=0,dd3=0,dd4=0,dd5=0;
a=in.nextLine();
while(!a.equals("end"))
{
//分割字符
String[] arr = a.split(" ");
//判断情况
if(arr.length==7)//加桌
{
i++;//桌号加1
t[i]=new table();//开第一桌
t[i].input(a);
if(t[i].flag&&caiflag==0&&t[i].bigflag==0) {
System.out.println("table "+t[i].tablenum+": ");//输出第一个桌号
}
if(t[i].bigflag==1)
System.out.println("wrong format");
for(i=0;i<caiflag;i++)
System.out.println("wrong format");
}
if(arr.length==4)
{
if(arr[3].equals("T"))//输入特色菜单
{
c.addspecialDish(arr[0],arr[1], Integer.parseInt(arr[2]));//arr[0]为菜名，arr[1]为菜系，Integer.parseInt(arr[1])为菜单价格
j++;//特色菜单数加1
}
else//点普通菜
{
if(t[i].flag&&caiflag==0) {
dcxh=Integer.parseInt(arr[0]);//序号
dcfe=Integer.parseInt(arr[2]);//份额
dcfs=Integer.parseInt(arr[3]);//份数
t[i].selforder.addRecord(i,dcxh,arr[1],dcfe,dcfs);//添加本桌普通菜
g=c.searthDish(arr[1]);//根据菜名查找普通菜
if(g!=null)
{
t[i].selforder.records[t[i].selforder.j].d=g;//如果找到了就将这个普通菜放到点菜记录中去
int x=t[i].selforder.records[t[i].selforder.j].getPrice();//计算该条记录的价钱
if(t[i].flag&&(t[i].selforder.k+t[i].selforder.j)!=0&&t[i].bigflag==0&&caiflag==0) {
System.out.println(dcxh+" "+arr[1]+" "+x);//输出普通菜信息
t[i].sum+=x;
//System.out.println(t[i].sum);
t[i].countsum+=(int)(x*t[i].count+0.5);//本桌价钱相加
}
}
}
}
}
else if(arr.length==5)//点特色菜
{
if(t[i].flag&&caiflag==0&&t[i].bigflag==0) {//桌号信息正确
dcxh=Integer.parseInt(arr[0]);//序号
weidao=Integer.parseInt(arr[2]);//辣/酸/甜度值
dcfe=Integer.parseInt(arr[3]);//份额
dcfs=Integer.parseInt(arr[4]);//份数
t[i].selforder.addSpecialRecord(i,dcxh,arr[1],weidao,dcfe,dcfs);//添加本桌特色菜到订单中去
d=c.searthDish1(arr[1]);//根据菜名查找特色菜
if(d!=null)
{
if(d.caixi.equals("川菜"))
{
if(t[i].selforder.specialrecord[t[i].selforder.k].weidao>5||t[i].selforder.specialrecord[t[i].selforder.k].weidao<0)//t[i].selforder.k为本桌特色订单数
{//时间存在，点菜人姓名和电话号码正确，该桌点菜数不为0，该条记录口味超限，输入的菜单也正确
System.out.println("spicy num out of range :"+t[i].selforder.specialrecord[t[i].selforder.k].weidao);
t[i].selforder.specialrecord[t[i].selforder.k].weidao=0;
t[i].selforder.specialrecord[t[i].selforder.k].num=0;
t[i].selforder.k--;
}
else if(t[i].selforder.specialrecord[t[i].selforder.k].weidao<6&&t[i].selforder.specialrecord[t[i].selforder.k].weidao>=0)
{//时间存在，点菜人姓名和电话号码正确，该桌点菜数不为0，该条记录口味没有超限，输入的菜单也正确
t[i].ladu+=t[i].selforder.specialrecord[t[i].selforder.k].weidao*t[i].selforder.specialrecord[t[i].selforder.k].num;//本桌川菜口味相加
t[i].chuancainumber+=t[i].selforder.specialrecord[t[i].selforder.k].num;//川菜数相加
t[i].selforder.specialrecord[t[i].selforder.k].s=d;//如果找到了就将这个特色菜放到对应桌的点菜记录中去
int x=t[i].selforder.specialrecord[t[i].selforder.k].getspecialPrice();//计算该条记录的价钱
if((t[i].selforder.k+t[i].selforder.j)!=0) {
System.out.println(dcxh+" "+arr[1]+" "+x);//输出特色菜信息
t[i].sum1+=x;
//System.out.println(t[i].sum1);
t[i].countsum1+=(int)(x*t[i].tesecount+0.5);//本桌价钱
}
}
}
if(d.caixi.equals("晋菜"))
{
if(t[i].selforder.specialrecord[t[i].selforder.k].weidao>4||t[i].selforder.specialrecord[t[i].selforder.k].weidao<0)
{//时间存在，点菜人姓名和电话号码正确，该桌点菜数不为0，该条记录口味超限，输入的菜单也正确
System.out.println("acidity num out of range :"+t[i].selforder.specialrecord[t[i].selforder.k].weidao);
t[i].selforder.specialrecord[t[i].selforder.k].weidao=0;
t[i].selforder.specialrecord[t[i].selforder.k].num=0;
t[i].selforder.k--;
}
else if(t[i].selforder.specialrecord[t[i].selforder.k].weidao<5&&t[i].selforder.specialrecord[t[i].selforder.k].weidao>=0)
{//时间存在，点菜人姓名和电话号码正确，该桌点菜数不为0，该条记录口味没有超限，输入的菜单也正确
t[i].suandu+=t[i].selforder.specialrecord[t[i].selforder.k].weidao*t[i].selforder.specialrecord[t[i].selforder.k].num;//本桌晋菜口味相加
t[i].jingcainumber+=t[i].selforder.specialrecord[t[i].selforder.k].num;//晋菜数相加
t[i].selforder.specialrecord[t[i].selforder.k].s=d;//如果找到了就将这个特色菜放到对应桌的点菜记录中去
int x=t[i].selforder.specialrecord[t[i].selforder.k].getspecialPrice();//计算该条记录的价钱
if((t[i].selforder.k+t[i].selforder.j)!=0) {
System.out.println(dcxh+" "+arr[1]+" "+x);//输出特色菜信息
t[i].sum1+=x;
t[i].countsum1+=(int)(x*t[i].tesecount+0.5);//本桌价钱
}
}
}
if(d.caixi.equals("浙菜"))
{//时间存在，点菜人姓名和电话号码正确，该桌点菜数不为0，该条记录口味超限，输入的菜单也正确
if(t[i].selforder.specialrecord[t[i].selforder.k].weidao>3||t[i].selforder.specialrecord[t[i].selforder.k].weidao<0)
{
System.out.println("sweetness num out of range :"+t[i].selforder.specialrecord[t[i].selforder.k].weidao);
t[i].selforder.specialrecord[t[i].selforder.k].weidao=0;
t[i].selforder.specialrecord[t[i].selforder.k].num=0;
t[i].selforder.k--;
}
else if(t[i].selforder.specialrecord[t[i].selforder.k].weidao<4&&t[i].selforder.specialrecord[t[i].selforder.k].weidao>=0)
{ //时间存在，点菜人姓名和电话号码正确，该桌点菜数不为0，该条记录口味没有超限，输入的菜单也正确
t[i].tiandu+=t[i].selforder.specialrecord[t[i].selforder.k].weidao*t[i].selforder.specialrecord[t[i].selforder.k].num;//本桌浙菜口味相加
t[i].zhecainumber+=t[i].selforder.specialrecord[t[i].selforder.k].num;//浙菜数相加
t[i].selforder.specialrecord[t[i].selforder.k].s=d;//如果找到了就将这个特色菜放到对应桌的点菜记录中去
int x=t[i].selforder.specialrecord[t[i].selforder.k].getspecialPrice();//计算该条记录的价钱
if((t[i].selforder.k+t[i].selforder.j)!=0)
{
System.out.println(dcxh+" "+arr[1]+" "+x);//输出特色菜信息
t[i].sum1+=x;
t[i].countsum1+=(int)(x*t[i].tesecount+0.5);//本桌价钱
}
}
}
}
}
}
else if(arr.length==5&&Integer.parseInt(arr[0])>0&&Integer.parseInt(arr[0])<100&&
Integer.parseInt(arr[1])>0&&Integer.parseInt(arr[1])<100)//代点普通菜(前两个字符为数字)
{
//桌号+英文空格+序号+英文空格+菜品名称**+英文空格+辣/酸/甜度值+**英文空格+份额+英文空格+份数
dd1=Integer.parseInt(arr[0]);//桌号
dd2=Integer.parseInt(arr[1]);//序号
dd3=Integer.parseInt(arr[3]);//份额
dd4=Integer.parseInt(arr[4]);//份数
t[dd1].selforder.addRecord(dd1,dd2,arr[2],dd3,dd4);//添加对应桌普通菜
g=c.searthDish(arr[2]);//查找带点菜菜名是否存在
if(g!=null)
{
t[dd1].selforder.records[t[dd1].selforder.j].d=g;//如果找到了就将这个普通菜放到点菜记录中去
int x=t[dd1].selforder.records[t[dd1].selforder.j].getPrice();//计算该条记录的价钱
if(t[dd1].flag&&(t[dd1].selforder.k+t[dd1].selforder.j)!=0&&t[dd1].bigflag==0&&caiflag==0) {
System.out.println(dd2+" table "+i+" pay for table "+dd1+" "+x);
t[dd1].sum+=x;
t[dd1].countsum+=(int)(x*t[dd1].count+0.5);//价钱计算到当前这一桌
}
}
}
else if(arr.length==6&&Integer.parseInt(arr[0])>0&&Integer.parseInt(arr[0])<100&&
Integer.parseInt(arr[1])>0&&Integer.parseInt(arr[1])<100)//代点特色菜(前两个字符为数字)
{
if(t[i].flag&&caiflag==0&&t[i].bigflag==0) {
dd1=Integer.parseInt(arr[0]);//桌号
dd2=Integer.parseInt(arr[1]);//序号
dd3=Integer.parseInt(arr[3]);//辣/酸/甜度值
dd4=Integer.parseInt(arr[4]);//份额
dd5=Integer.parseInt(arr[5]);//份数
t[dd1].selforder.addSpecialRecord(dd1,dd2,arr[2],dd3,dd4,dd5);//添加到对应桌特色菜
d=c.searthDish1(arr[2]);//查找特色菜
if(d!=null)
{
if(d.caixi.equals("川菜"))
{
if(t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao>5||t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao<0)//川菜代点菜口味超限
{//时间存在，点菜人姓名和电话号码正确，该桌点菜数不为0，该条记录口味超限，输入的菜单也正确
System.out.println("spicy num out of range :"+t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao);
t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao=0;
t[dd1].selforder.specialrecord[t[dd1].selforder.k].num=0;
t[dd1].selforder.k--;
}
else if(t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao<6&&t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao>=0)
{ //时间存在，点菜人姓名和电话号码正确，该桌点菜数不为0，该条记录口味没有超限，输入的菜单也正确
t[dd1].ladu+=t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao*t[dd1].selforder.specialrecord[t[dd1].selforder.k-1].num;//本桌川菜口味相加
t[dd1].chuancainumber+=t[dd1].selforder.specialrecord[t[dd1].selforder.k].num;//川菜数相加
t[dd1].selforder.specialrecord[t[dd1].selforder.k].s=d;//如果找到了就将这个特色菜放到对应桌的点菜记录中去
int x=t[dd1].selforder.specialrecord[t[dd1].selforder.k].getspecialPrice();//计算该条记录的价钱
if(t[i].flag&&t[i].bigflag==0) {
System.out.println(dd2+" table "+i+" pay for table "+dd1+" "+x);//输出信息
t[i].sum1+=x;//价钱加到本桌
t[i].countsum1+=(int)(x*t[i].tesecount+0.5);//价钱计算到当前这一桌
}
}
}
if(d.caixi.equals("晋菜"))
{
//spicy/acidity/sweetness
if(t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao>4||t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao<0)//晋菜代点菜口味超限
{//时间存在，点菜人姓名和电话号码正确，该桌点菜数不为0，该条记录口味超限，输入的菜单也正确
System.out.println("acidity num out of range :"+t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao);
t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao=0;
t[dd1].selforder.specialrecord[t[dd1].selforder.k].num=0;
t[dd1].selforder.k--;//将这条记录去掉
}
else if(t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao<5&&t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao>=0)
{//时间存在，点菜人姓名和电话号码正确，该桌点菜数不为0，该条记录口味没有超限，输入的菜单也正确
t[dd1].ladu+=t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao*t[dd1].selforder.specialrecord[t[dd1].selforder.k-1].num;//本桌晋菜口味相加
t[dd1].chuancainumber+=t[dd1].selforder.specialrecord[t[dd1].selforder.k].num;//晋菜数相加
t[dd1].selforder.specialrecord[t[dd1].selforder.k].s=d;//如果找到了就将这个特色菜放到对应桌的点菜记录中去
int x=t[dd1].selforder.specialrecord[t[dd1].selforder.k].getspecialPrice();//计算该条记录的价钱
//System.out.println("t[i].bigflag");
if(t[i].flag&&t[i].bigflag==0) {
//System.out.println("1233321165");
System.out.println(dd2+" table "+i+" pay for table "+dd1+" "+x);
t[i].sum1+=x;
t[i].countsum1+=(int)(x*t[i].tesecount+0.5);//价钱计算到当前这一桌
}
}
}
if(d.caixi.equals("浙菜"))
{
if(t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao>3||t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao<0)//代点菜口味超限
{//时间存在，点菜人姓名和电话号码正确，该桌点菜数不为0，该条记录口味超限，输入的菜单也正确
System.out.println("sweetness num out of range :"+t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao);
t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao=0;
t[dd1].selforder.specialrecord[t[dd1].selforder.k].num=0;
t[dd1].selforder.k--;
}
else if((t[i].selforder.k+t[i].selforder.j)!=0&&t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao<4&&t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao>=0)
{//时间存在，点菜人姓名和电话号码正确，该桌点菜数不为0，该条记录口味没有超限，输入的菜单也正确
t[dd1].ladu+=t[dd1].selforder.specialrecord[t[dd1].selforder.k].weidao*t[dd1].selforder.specialrecord[t[dd1].selforder.k].num;//本桌浙菜口味相加
t[dd1].chuancainumber+=t[dd1].selforder.specialrecord[t[dd1].selforder.k].num;//浙菜份数相加
t[dd1].selforder.specialrecord[t[dd1].selforder.k].s=d;//如果找到了就将这个特色菜放到对应桌的点菜记录中去
int x=t[dd1].selforder.specialrecord[t[dd1].selforder.k].getspecialPrice();//计算该条记录的价钱
if(t[dd1].flag&&t[dd1].bigflag==0) {
System.out.println(dd2+" table "+i+" pay for table "+dd1+" "+x);
t[i].sum1+=x;
t[i].countsum1+=(int)(x*t[i].tesecount+0.5);//价钱计算到当前这一桌
}
}
}
}
}
}
else if(arr.length==3)
{
if(!arr[1].equals("川菜")||!arr[1].equals("晋菜")||!arr[1].equals("浙菜"))//判断特色菜菜单是否输入正确
{
caiflag++;//为1代表这条菜单输入错误
}
}
else if(arr.length==2)
{
if(arr[1].equals("delete"))//删菜
{
if(t[i].flag&&t[i].bigflag==0&&caiflag==0&&t[i].selforder.findRecordByNum(Integer.parseInt(arr[0]))==null&&t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0]))==null)
System.out.println("delete error");
else
{
if(t[i].selforder.findRecordByNum(Integer.parseInt(arr[0]))!=null)//普通菜不为空
{
int y=t[i].selforder.findRecordByNum(Integer.parseInt(arr[0])).getPrice();
t[i].totalsum1+=y;
t[i].totalsum2+=(int)(y*t[i].tesecount+0.5);
}
if(t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0]))!=null)//特色菜不为空
{
if(t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0])).s.caixi.equals("川菜"))
{
t[i].ladu-=t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0])).weidao*t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0])).num;//本桌川菜口味相加
t[i].chuancainumber-=t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0])).num;//川菜数相减
int y=t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0])).getspecialPrice();
t[i].totalsum1+=y;
t[i].totalsum2+=(int)(y*t[i].tesecount+0.5);
}
if(t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0])).s.caixi.equals("晋菜"))
{
t[i].suandu-=t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0])).weidao*t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0])).num;//本桌川菜口味相加
t[i].jingcainumber-=t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0])).num;//川菜数相减
int y=t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0])).getspecialPrice();
t[i].totalsum1+=y;
t[i].totalsum2+=(int)(y*t[i].tesecount+0.5);
}
if(t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0])).s.caixi.equals("浙菜"))
{
t[i].tiandu-=t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0])).weidao*t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0])).num;//本桌川菜口味相加
t[i].zhecainumber-=t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0])).num;//川菜数相减
int y=t[i].selforder.specialfindRecordByNum(Integer.parseInt(arr[0])).getspecialPrice();
t[i].totalsum1+=y;
t[i].totalsum2+=(int)(y*t[i].tesecount+0.5);
}
}
}
}
else//输入普通菜单
{
c.addDish(arr[0], Integer.parseInt(arr[1]));//arr[0]为菜名，Integer.parseInt(arr[1])为菜单价格
m++;//普通菜单数加1
}
}
a=in.nextLine();
}
for(l=1;l<=i;l++)//i为桌号
{
if(t[l].bigflag==0&&caiflag==0) //桌信息正确
{
t[l].getTotalPrice();//输出对应桌号的价钱
System.out.print("\n");
}
}
for(int h=1;h<=i;h++)
t[h].p.peoplesum=t[h].totalcountsum;
for(int h=1;h<=i;h++)
{
for(int u=h+1;u<=i;u++)
{
if(t[h].name.equals(t[u].name))
{
t[h].p.peoplesum+=t[u].totalcountsum;
t[u].p.peoplesum=0;
break;
}
}
}
Arrays.sort(t,1,i+1,new cmp());
for(l=1;l<=i;l++)
{
if(t[l].flag&&t[l].bigflag==0&&caiflag==0)
{
if(t[l].selforder.k+t[l].selforder.k==0)
System.out.println(t[l].name+" "+t[l].phone+" "+"0");//如果点菜数为零
if(t[l].p.peoplesum!=0)
System.out.println(t[l].name+" "+t[l].phone+" "+t[l].p.peoplesum);
}
}
}
}
class cmp implements Comparator<table>
{
@Override
public int compare(table a,table b)
{
// return b.p.name.compareTo(a.p.name);
for(int i=0;i<a.name.length()&&i<b.name.length();i++)
{
if(a.name.charAt(i)!=b.name.charAt(i))
return a.name.charAt(i)-b.name.charAt(i);
}
return a.name.length()-a.name.length();
}
}
menu类：
package 点菜3;
public class Menu {
Dish[] dishs =new Dish[20];//普通菜单
SpecialDish[] dishs1=new SpecialDish[20];//特色菜单
String []ladu=new String[20];
String []suandu=new String[20];
String []tiandu=new String[20];
// 川菜增加辣度值：辣度0-5级；对应辣度水平为：不辣、微辣、稍辣、辣、很辣、爆辣；
//
// 晋菜增加酸度值，酸度0-4级；对应酸度水平为：不酸、微酸、稍酸、酸、很酸；
//
// 浙菜增加甜度值，甜度0-3级；对应酸度水平为：不甜、微甜、稍甜、甜；
int i=0;//用于记录普通菜品总数
int n=0;//用于计算特色菜品总数
void addDish(String dishName,int unit_price)//普通菜菜单
{
dishs[i]=new Dish();
dishs[i].name=dishName;//保存菜名
dishs[i].unit_price=unit_price;//保存单价
i++;
}
void addspecialDish(String dishName,String caixi,int unit_price)//特色菜菜单
{
dishs1[n]=new SpecialDish();
dishs1[n].name=dishName;//保存菜名
dishs1[n].caixi=caixi;//保存菜系
dishs1[n].unit_price=unit_price;//保存单价
n++;
}
//菜品数组，保存所有菜品信息
Dish searthDish(String dishName) //根据菜名在普通菜谱中查找菜品信息，返回Dish对象。
{
int j=0;
int flag=0;
for(j=i-1;j>=0;j--)//从未末端开始查找比对
{
if(dishName.compareTo(dishs[j].name)==0)//查找普通菜
{
flag=1;
break;
}
}
if(flag==1)
return dishs[j];
else//没找到输出does not exist
{
System.out.println(dishName+" does not exist");
return null;
}
}
SpecialDish searthDish1(String dishName) //根据菜名在特色菜谱中查找菜品信息，返回SpecialDish对象。
{
int j=0;
int flag=0;
for(j=n-1;j>=0;j--)//从未末端开始查找比对
{
if(dishName.compareTo(dishs1[j].name)==0)//查找特色菜
{
flag=2;
break;
}
}
if(flag==2)
return dishs1[j];
else//没找到输出does not exist
{
System.out.println(dishName+" does not exist");
return null;
}
}
void ladu() {
this.ladu[0]="不辣";this.ladu[1]="微辣";this.ladu[2]="稍辣";this.ladu[3]="辣";this.ladu[4]="很辣";this.ladu[5]="爆辣";
}
void suandu() {
this.suandu[0]="不酸";this.suandu[1]="微酸";this.suandu[2]="稍酸";this.suandu[3]="酸";this.suandu[4]="很酸";
}
void tiandu() {
this.tiandu[0]="不甜";this.tiandu[1]="微甜";this.tiandu[2]="稍甜";this.tiandu[3]="甜";
}
}
Order类：
package 点菜3;
public class Order {
Record[] records=new Record[20];//普通菜记录
Record[] specialrecord=new Record[20];//特色菜记录
int orderNum=0;//点菜序号
int k=0;//特色菜数量
int j=0;//普通菜数量
int flag=0;
int i=0;
void addRecord(int tablenum,int orderNum,String dishName,int portion,int num)//添加一条菜品信息到订单中。
{
j++;//普通菜数量加1
records[j]=new Record();
records[j].tablenum=tablenum;//桌号
records[j].orderNum=orderNum;//点菜的序号
records[j].d.name=dishName;//点菜的菜名
records[j].portion=portion;//点菜的份额
records[j].num=num;//点菜的份数
}
void addSpecialRecord(int tablenum,int orderNum,String dishName,int weidao,int portion,int num)//添加一条特色菜品信息到订单中。
{
k++;//特色菜数量加1
specialrecord[k]=new Record();
specialrecord[k].tablenum=tablenum;//桌号
specialrecord[k].orderNum=orderNum;//点菜的序号
specialrecord[k].s.name=dishName;//点菜的菜名
specialrecord[k].weidao=weidao;//点菜的口味
specialrecord[k].portion=portion;//点菜的份额
specialrecord[k].num=num;//点菜的份数
}
Record findRecordByNum(int orderNum)//根据序号查找普通记录
{
for(i=1;i<=j;i++)
{
if(records[i].orderNum==orderNum)
{
return records[i];
}
}
return null;
}
Record specialfindRecordByNum(int orderNum)//根据序号查找普通记录
{
for(i=1;i<=k;i++)
{
if(specialrecord[i].orderNum==orderNum)
{
return specialrecord[i];
}
}
return null;
}
}
People类：
package 点菜3;
public class People {
int peoplesum=0;
}
Recorder类：
package 点菜3;
public class Record {
Dish d=new Dish();//菜品
SpecialDish s=new SpecialDish();
int orderNum=0;//序号
String caixi="";
int weidao=0;
int portion=0;//份额
int num=0;//份数
int tablenum=0;//桌号
int getPrice()
{
int n=0;
n=num*d.getPrice(portion);
//2 油淋生菜 27
return n;
}//计价，计算本条记录的价格
int getspecialPrice()
{
int m=0;
m=num*s.getPrice(portion);
return m;
}//计价，计算本条记录的价格
}
SpecialDish类：
public class SpecialDish {
String name="";//菜品名称
String caixi="";//菜系名称
int unit_price;//菜品单价
int getPrice(int portion)
{
int 菜价=0;
//单菜价格
switch(portion)
{
case 1: 菜价=unit_price;break;
case 2: 菜价=(int)(1.0*unit_price*3/2+0.5);break;//Math.ceil（）为向上取整方法
case 3: 菜价=unit_price*2;break;
}
return 菜价;
}
}
Table类：
package 点菜3;
import java.util.Calendar;
public class table {
int tablenum;//桌号
String time;//点菜时间
String name="";//点菜人姓名
String phone="";//点菜人电话号码
int year=0,month=0,day=0,ww=0,hh=0,mm=0,ss=0;
boolean flag=true;//判断时间是否正确
int ladu=0,chuancainumber=0;//辣度，川菜数量
int suandu=0,jingcainumber=0;//酸度，晋菜数量
int tiandu=0,zhecainumber=0;//甜度，浙菜数量
double count=0;//折扣
double tesecount=0;
Order selforder=new Order();//本桌订单
Menu q=new Menu();
People p=new People();//每一桌只能有一个名字
int sum=0;//计算普通菜总价
int sum1=0;//计算特色菜总价
int totalsum=0;//计算没打折之前的总价
int countsum=0;//计算折扣后普通菜的总价
int countsum1=0;//计算折扣后特色菜的价格
int totalcountsum=0;//计算折扣后的总价
int bigflag=0;//判断姓名和电话号码是否合法
// int chuantotalsum=0,chuantotalsum1=0;
// int jingtotalsum=0,jingtotalsum1=0;
// int zhetotalsum=0,zhetotalsum1=0;
int totalsum1=0;
int totalsum2=0;
void input(String time)//预处理
{
this.time=time;
timechange();//时间转换
jscount();//计算折扣
pdflag();//判断时间是否有效
pdnameandphone();//判断电话号码和名字
q.ladu();
q.suandu();
q.tiandu();
}
void getTotalPrice()//计算桌总价
{
if(flag&&bigflag==0)
{
totalsum=sum+sum1-totalsum1;//所以价钱相加
totalcountsum=countsum+countsum1-totalsum2;
if(chuancainumber==0&&jingcainumber==0&&zhecainumber==0)
System.out.print("table "+tablenum+": "+totalsum+" "+totalcountsum+" ");//依次输出桌号和折扣前的价格，折扣后的价格
else
System.out.print("table "+tablenum+": "+totalsum+" "+totalcountsum);//依次输出桌号和折扣前的价格，折扣后的价格
for(int i=1;i<=selforder.k;i++)//输出川菜
{
if(selforder.specialrecord[i].s.caixi.equals("川菜")&&chuancainumber!=0)
{
System.out.print(" "+selforder.specialrecord[i].s.caixi);//输出菜系
System.out.print(" "+chuancainumber+" "+q.ladu[(int)(1.0*ladu/chuancainumber+0.5)]);//输出份数和平均口味
break;
}
else
continue;
}
for(int i=1;i<=selforder.k;i++)//输出晋菜
{
if(selforder.specialrecord[i].s.caixi.equals("晋菜")&&jingcainumber!=0)
{
System.out.print(" "+selforder.specialrecord[i].s.caixi);//输出菜系
System.out.print(" "+jingcainumber+" "+q.suandu[(int)(1.0*suandu/jingcainumber+0.5)]);//输出份数和平均口味
break;
}
else
continue;
}
for(int i=1;i<=selforder.k;i++)//输出浙菜
{
if(selforder.specialrecord[i].s.caixi.equals("浙菜")&&zhecainumber!=0)
{
System.out.print(" "+selforder.specialrecord[i].s.caixi);//输出菜系
System.out.print(" "+zhecainumber+" "+q.tiandu[(int)(1.0*tiandu/zhecainumber+0.5)]);//输出份数和平均口味
break;
}
else
continue;
}
}
else
System.out.print("table "+tablenum+" out of opening hours");
}
void jscount()//运用时间计算折扣
{
if(ww>=1&&ww<=5)
{
if(hh>=17&&hh<20)
count=0.8;
else if(hh==20&&mm<30)
count=0.8;
else if(hh==20&&mm==30&&ss==0)
count=0.8;
else if(hh>=11&&hh<=13||hh==10&&mm>=30)
count=0.6;
else if(hh==14&&mm<30)
count=0.6;
else if(hh==14&&mm==30&&ss==0)
count=0.6;
}
else
{
if(hh>=10&&hh<=20)
count=1.0;
else if(hh==9&&mm>=30)
count=1.0;
else if(hh==21&&mm<30||hh==21&&mm==30&&ss==0)
count=1.0;
}
if(ww>=1&&ww<=5)
tesecount=0.7;
else
tesecount=1;
}
void pdflag()//判断时间是否正确
{
if(count==0)//因为在计算折扣方法中会对折扣进行赋值，如果没赋值，折扣初始值是为0的，这就会间接导致日期无效（因为日期无效是不能对折扣进行赋值）
flag=false;
else
flag=true;
}
void timechange()//时间转换
{
String[] arr1=time.split(" ");
//table 1 : tom 13605054400 2023/5/1 18/30/00
//arr1[0]=="table"
//arr1[1]==桌号
//arr1[2]==":"
//arr1[3]==name
//arr1[4]==phone
//arr1[5]==日期1
//arr1[6]==日期2
if(!arr1[1].matches("[0123456789]{100}"))
{
bigflag=1;
}
else
{
tablenum=Integer.parseInt(arr1[1]);//桌号
}
name=arr1[3];
phone=arr1[4];
//System.out.println(phone);
String[] arr2=arr1[5].split("/");//分割日期
String[] arr3=arr1[6].split("/");//分割时间
year=Integer.parseInt(arr2[0]);//时间
month=Integer.parseInt(arr2[1]);
day=Integer.parseInt(arr2[2]);
Calendar c = Calendar.getInstance();
c.set(year,month-1,day);//设置时间
ww=c.get(Calendar.DAY_OF_WEEK);
hh=Integer.parseInt(arr3[0]);//时间
mm=Integer.parseInt(arr3[1]);
ss=Integer.parseInt(arr3[2]);
if(ww==1)
ww=7;
else
ww--;
}
void pdnameandphone()//判断姓名
{
if(name.length()>10||!phone.matches("(18[019]{1}|13[356]{1})([0-9]{8})"))
{
bigflag=1;
//System.out.println("wrong format");
}
}
}
这次的大作业，是我有史以来花时间最多1的一次，虽然只有可怜的70分，但是这是我从15分慢慢进步过来的。
主要困难
这三次作业当中的主要困难还是有关类的设计，我对类的设计还不是很熟悉，目前还停留在了c语言面向过程设计的地方，这导致我每次做题目时我都想用面向过程的方法来写题目，可是小题目还好，可是到了大题目的话我就有点稀里糊涂了，摸不着方向，不知道该从何先手。尤其点菜类那三道大题，我是一点头绪都没有。
改进建议
在以后的写作业过程中，要多习惯使用面向对象的方法来解题，不应该老是想着用面向过程的方法来写题目。还是要多加练习，之前那几次大作业是我的态度不够端正才导致我的份数那么难看，以后的大作业我要好好端正我的态度，争取下次大作业的分数超过70分。加油！
总结
1.学到了什么：
（1）：输入语句的使用。
（2）：java中多个if（）判断语句的使用。
（3）：java中的if（）和else语句的嵌套使用，这在第一次作业的7-7中用到了该方法来判断三角形的类型。
（3）：java中的四则运算。
（4）：java中的for()循环语句的使用。
（5）：java中的switch()语句的使用。
（6）：java中的一些对字符串处理的方法，例如：a.substring(0,2)，该方法的作用是将字符串a中的第一二位的字符提取出来。
c.equals(s)，该方法是对字符串进行比对的方法，如果字符串c与字符串s相等，则返回true，否则返回false。
a.charAt(i)，该方法是对字符串提取的作用，它可以将字符串a中的第i为提取出来。
（7）：在第一次作业的7-8中，我发现原来java中的浮点数据会有误差，在完成作业的时候应该考虑到精度问题。并且还学会了java中的一中数学处理方法，Math.abs(),该 方法是对括号内的数进行取绝对值的处理。
（8）：在第二次作业中的第一和第二题中我学会了对一道很复杂的题目进行面对对象的程序设计，并且明白面对对象的程序设计与面对过程的程序设计直接的差别。
（9）：在第二次作业的第三题我学会了如何通过基年法来判断该天是周几和通过基年法计算两个日期之间相差的天数。
（10）：java中的分割字符串的方法a.split(" ")，该方法的作用是将字符串a按空格进行分割。
（11）：java中的Arrays.sort（），该方法是将括号内的数进行排序处理。
（12）：java中对数据进行封装（private）
（13）含参构造和无参构造。
（14）正则表达式的使用。在一些需要对输入进行判断时我们就可以用到正则表达式。
（15）继承的使用（父类与子类）继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
继承的作用：通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。
（16）在这几次的大作业学习和期中考试当中，我也充分的理解了类与类之间的关系：
继承关系：继承指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力。
实现关系：实现指的是一个class类实现interface接口（可以是多个）的功能，实现是类与接口之间最常见的关系。
依赖关系：依赖就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A。
关联关系：关联体现的是两个类之间语义级别的一种 强依赖关系，关联可以是单向、双向的。
聚合关系：聚合是关联关系的一种特例，它体现的是整体与部分的关系，即 has-a 的关系。此时整体与部分之间是可分离的，它们可以具有各自的生命周期，部分可以属于 多个整体对象，也可以为多个整体对象共享。
组合关系：组合也是关联关系的一种特例，这种关系比聚合更强，也称为强聚合。它同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也 就意味着部分的生命周期结束。
建议：我希望老师在课堂上能和我们一起写一些代码，将我们带入到写代码中去，这样就很有利于我们对面向对象这一方法的理解，而不是一直给我们灌输面向对象思想，这种对象很抽象，就算你举了春游的例子来帮助我们理解，可是看到的东西是要比听到的东西好很多的，所以我希望老师在课堂上能够加一下写代码的环节。谢谢老师！
作业的话我希望老师能够给多点时间，我看有一些班级的老师给他们的时间比我们多多了，就比如第二次作业：有的班比我们晚交了4天。我希望老师多给我们一些时间去写。说不定多给几天时间，有些有思路了的同学就能够写出来了，我好几次都是有一些思路的时候结果就是题目马上要截至了，我完不成了。
实验的话我也希望老师能够讲解一些，而不是直接将实验甩给我们让我们自己思考，这对于我们这些基础比较差的同学来说真的很吃力。
希望老师能够看到我的建议，也希望老师在看到我的建议之后能够有所改变，谢谢老师！
浙公网安备 33010602011771号