一、前言
第四次系列作业在前三次作业的基础上增加了正则表达式的使用，对错误输入进行了重新分类，难度偏高；第五次系列作业没有延续第四次作业的使用，是在第三次系列作业上的延申，增加了特色菜的定义，加设了特色菜谱，需要进行分类输入；期中考试题量偏少，知识点攘括了类的使用，继承和多态，接口和抽象类，相对比较全面。
知识点: Java中输入一般是通过Scanner类来实现的：具体步骤如下：
（1）创建Scanner对象，接受从控制台输入 Scanner input=new Scanner(System.in);
（2） 接受String类型 String str=input.next();
（3）接受int类型 int n=input.nextInt();
（4）输出结果 System.out.println(str); System.out.println(n);
条件语句
1.if：
①单条件语句:
if( 条件判断语句 ){
当条件判断语句为true，就执行该代码块，为false就不执行
}
②双条件语句：
if(条件判断语句){
功能语句1，当条件满足时执行该代码块
}else{
功能语句2，当条件不满足时执行该代码块
}
③多条件语句：
if(条件判断语句1){
功能语句1，当条件1满足时执行该代码块
}else if(条件判断2){
功能语句2，当条件2满足时执行该代码块
}else if(条件判断3){
功能语句3，当条件3满足时执行该代码块
}else{
当所有条件都不满足时执行该代码块
}
2.switch:
switch(变量){
case 值1：
功能语句1；
break;
case 值2：
功能语句2；
break;
case 值3：
功能语句3；
break;
default:
功能语句default；
break;
}
循环语句
while 循环
while是最基本的循环，它的结构为：
while( 布尔表达式 ) { //循环内容 }
只要布尔表达式为 true，循环就会一直执行下去。
for循环
虽然所有循环结构都可以用 while 或者 do...while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。
for循环执行的次数是在执行前就确定的。语法格式如下：
for(初始化; 布尔表达式; 更新) { //代码语句 }
关于 for 循环有以下几点说明：
最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
执行一次循环后，更新循环控制变量。
再次检测布尔表达式。循环执行上面的过程。
JAVA中，char占2字节，16位。可在存放汉字
2、char赋值
char a='a'; //任意单个字符，加单引号。
char a='中';//任意单个中文字，加单引号。
char a=111;//整数。0~65535。十进制、八进制、十六进制均可。输出字符编码表中对应的字符。
注：只能放单个字符。
String用法
1 length（）字符串的长度
String a = "Hello Word!";
System.out.println(a.length);
输出的结果是字符串长度10。
2 charAt（）截取一个字符
String a = "Hello Word";
System.out.println(a.charAt(1));
输出的结果是字符串a的下标为1的字符e。
3 getchars（）截取多个字符并由其他字符串接收
String a = "Hello Word";
char[] b = new char[10];
a.getChars(0, 5, b, 0);
System.out.println(b);
输出的结果为Hello，其中第一个参数0是要截取的字符串的初始下标（int sourceStart），第二个参数5是要截取的字符串的结束后的下一个下标（int sourceEnd）也就是实际截取到的下标是int
sourceEnd-1，第三个参数是接收的字符串（char target[]），最后一个参数是接收的字符串开始接收的位置。
4 getBytes()将字符串变成一个byte数组
String a = "Hello Word";
byte b[] = a.getBytes();
System.out.println(new String(b));
输出的结果为Hello Word的byte数组。
5 toCharArray()将字符串变成一个字符数组
String a = "Hello Word";
char[]b = a.toCharArray();
System.out.println(b);
输出的结果为Hello Word字符数组。
6 equals()和equalsIgnoreCase()比较两个字符串是否相等，前者区分大小写，后者不区分
String a = "Hello Word";
String b = "hello word";
System.out.println(a.equals(b));
System.out.println(a.equalsIgnoreCase(b));
输出的结果为第一条为false，第二条为true。
7 startsWith()和endsWith()判断字符串是不是以特定的字符开头或结束
String a = "Hello Word";
System.out.println(a.startsWith("ee"));
System.out.println(a.endsWith("rd"));
输出的结果第一条为false，第二条为true。
8 toUpperCase()和toLowerCase()将字符串转换为大写或小写
String a = "Hello Word";
System.out.println(a.toUpperCase());
System.out.println(a.toLowerCase());
输出的结果第一条为“HELLO WORD”，第二条为“hello word”。
9 concat() 连接两个字符串
String a = "Hello Word";
String b = "你好";
System.out.println(b.concat(a));
输出的结果为“你好Hello Word”。
10 trim()去掉起始和结束的空格
String a = " Hello Word ";
System.out.println(a.trim());
输出的结果为“Hello Word”。
11 substring（）截取字符串
String a = "Hello Word";
System.out.println(a.substring(0, 5));
System.out.println(a.substring(6));
输出的结果第一条为“Hello”,第一个参数0（beginIndex）是开始截取的位置，第二个参数5（endIndex）是截取结束的位置，输出的结果第二条是“Word”，参数6（beginIndex）是开始截取的位置。
12 indexOf()和lastIndexOf()前者是查找字符或字符串第一次出现的地方，后者是查找字符或字符串最后一次出现的地方
String a = "Hello Word";
System.out.println(a.indexOf("o"));
System.out.println(a.lastIndexOf("o"));
输出的结果第一条是4，是o第一次出现的下标，第二条是7，是o最后一次出现的下标。
13 compareTo()和compareToIgnoreCase(）按字典顺序比较两个字符串的大小，前者区分大小写，后者不区分
String a = "Hello Word";
String b = "hello word";
System.out.println(a.compareTo(b));
System.out.println(a.compareToIgnoreCase(b));
输出的结果第一条为-32，第二条为0，两个字符串在字典顺序中大小相同，返回0。
14 replace() 替换
String a = "Hello Word";
String b = "你好";
System.out.println(a.replace(a, b));
System.out.println(a.replace(a, "HELLO WORD"));
System.out.println(b.replace("你", "大家"));
数组
Java 中定义数组的语法有两种：
type arrayName[];
type[] arrayName;
type 为Java中的任意数据类型，包括基本类型和组合类型，arrayName为数组名，必须是一个合法的标识符，[ ] 指明该变量是一个数组类型变量。例如：
demoArray=new int[3];
为一个整型数组分配3个int 型整数所占据的内存空间。
通常，你可以在定义的同时分配空间，语法为：
type arrayName[] = new type[arraySize];
例如：
int demoArray[] = new int[3];
正则表达式是由一些具有特殊含义的字符组成的字符串，多用于查找、替换符合规则的字符串。在表单验证、Url映射等处都会经常用到。
一、元字符
元字符：即为有特定含义的字符，常见的元字符如下
常用的元字符
代码 说明
. 匹配除换行符以外的任意字符
\w 匹配字母或数字或下划线或汉字
\s 匹配任意的空白符
\d 匹配数字
\b 匹配单词的开始或结束
^ 匹配字符串的开始（在集合字符里[^a]表示非（不匹配）的意思
$ 匹配字符串的结束
详解和示例：
（1）. 匹配任何任意字符 例如 . 可以匹配 1，n，*，+，- ,等
（2）\d\w\s 匹配第一个字符为数字，第二个字符为字母或数字、或下划线或汉字，第三字符为空格的字符串 例如：11 ，2a , 1_
（3）^\d\d\d$ 匹配三个全部都为数字的字符串 例如： 123,456,789
还可以用于验证输入的字符串是否符合qq（身份证号）的验证 ：
例如：^\d{8}$ 匹配8位数字的qq号，^\d{15}&匹配15位均为数字的身份证号
（4）\bOlive\b 匹配单词Olive 例如： I Love Oliver and Olive .这个时候返回的是Olive 而不是Oliver,因为\b....\b返回的匹配的单词
二、反义字符
反义字符：多用于查找除某个字符以外其他任意字符均可以的情况
常用的反义字符如下：
常用的反义字符
代码/语法 说明
\W 匹配任意不是字母，数字，下划线，汉字的字符
\S 匹配任意不是空白符的字符
\D 匹配任意非数字的字符
\B 匹配不是单词开头或结束的位置
[^x] 匹配除了x以外的任意字符
[^aeiou] 匹配除了aeiou这几个字母以外的任意字符
详解和示例：
（1）\W 匹配除字母、数字、下划线、汉字以为的字符形如 +，-，*
（2）\S 匹配除空格以外的任意字符形如：1，* ，）
（3）[^abcde]匹配除abcde以为的其他字符 如 e，f，g，h
三、限定字符
限定字符多用于重复匹配次数
常用的限定字符如下
常用的限定符
代码/语法 说明
* 重复零次或更多次
+ 重复一次或更多次
? 重复零次或一次
{n} 重复n次
{n,} 重复n次或更多次
{n,m} 重复n到m次
详解和示例：
（1）\d* 匹配重复0次或多次数字 例如:可能为空 或 任意数字 （2,3。。。。）
（2）\d+ 匹配重复1次或多次数字 例如:可能为1个或多个数字 1,23,234,2345，........
（3）\d? 匹配重复次个或者一次数字 例如：可能为空或者任意的一个数字（1,2，。。。）
（4）\d{8}匹配重复8次数字 例如：123456768
（5）\d{4,}匹配重复至少4次数字 例如：1234,12345,124244,。。。。。
（6）^\d{8,11}$ 匹配重复8-11次数字 例如：12345678,123456789,1234567890,12345678901
四、转义字符
在实际的开发中，可能会遇到要比配元字符的情况，这个时候就需要进行字符转义，如元字符 . * \ 需要转换为\. \* \\
例如： 需要匹配qq邮箱 \d{8,}+qq+\.+com 在这里的. 就需要加斜杠
五、字符分枝
字符分枝多用于满足不同情况的选择，用“|”将不同的条件分割开来，比如有些固定电话区号有三位，有些有四位，这个时候可以采用字符分枝
例如：\d{3}-\d{8}|\d{4}-\d{8} 可以匹配两种不同长度区号的固定电话
下边的IP地址正则表达式也有用到字符分枝
六、字符分组
字符分组多用于将多个字符重复，主要通过使用小括号()来进行分组
形如：（\d\w){3} 重复匹配3次（\d\w)
常用于表示IP地址 形如： ((25[0-5]|2[0-4][0-9]|[0-1]\d\d)\.){3}(25[0-5]|2[0-4][0-9]|[0-1]\d\d)
解析：先把IP地址分为两部分一部分是123.123.123. 另一部分是123，又因Ip最大值为255，所以先使用分组，然后在组里边再进行选择，组里也有三部分，0-199,200-249,250-255，分别和上述的表达是对应，最后还要注意分组之后还要加上一个.，因为是元字符所以要转义故加上\. 然后再把这部分整体看做是一个组，重复三次，再加上仅有数字的一组也就是不带\.的那一组即可完成IP地址的校验
常用分组语法
用分组语法
分类 代码/语法 说明
捕获 (exp) 匹配exp,并捕获文本到自动命名的组里
(?<name>exp) 匹配exp,并捕获文本到名称为name的组里，也可以写成(?'name'exp)
(?:exp) 匹配exp,不捕获匹配的文本，也不给此分组分配组号
零宽断言 (?=exp) 匹配exp前面的位置
(?<=exp) 匹配exp后面的位置
(?!exp) 匹配后面跟的不是exp的位置
(?<!exp) 匹配前面不是exp的位置
注释 (?#comment) 这种类型的分组不对正则表达式的处理产生任何影响，用于提供注释让人阅读
七、懒惰匹配和贪婪匹配
贪婪匹配：正则表达式中包含重复的限定符时，通常的行为是匹配尽可能多的字符。
懒惰匹配，有时候需要匹配尽可能少的字符。
例如： a.*b，它将会匹配最长的以a开始，以b结束的字符串。如果用它来搜索aabab的话，它会匹配整个字符串aabab。但是我们此时可能需要匹配的是ab这样的话就需要用到懒惰匹配了。懒惰匹配会匹配尽可能少的字符
常用的懒惰匹配限定符如下
懒惰限定符
代码/语法 说明
*? 重复任意次，但尽可能少重复
+? 重复1次或更多次，但尽可能少重复
?? 重复0次或1次，但尽可能少重复
{n,m}? 重复n到m次，但尽可能少重复
{n,}? 重复n次以上，但尽可能少重复
八、后向引用
后向引用用于重复搜索前面某个分组匹配的文本。
使用小括号指定一个子表达式后，匹配这个子表达式的文本(也就是此分组捕获的内容)可以在表达式或其它程序中作进一步的处理。默认情况下，每个分组会自动拥有一个组号，规则是：从左向右，以分组的左括号为标志，第一个出现的分组的组号为1，第二个为2，以此类推
示例：\b(\w+)\b\s+\1\b可以用来匹配重复的单词，像go go, 或者kitty kitty。
这个表达式首先是一个单词，也就是单词开始处和结束处之间的多于一个的字母或数字(\b(\w+)\b)，这个单词会被捕获到编号为1的分组中，然后是1个或几个空白符(\s+)，最后是分组1中捕获的内容（也就是前面匹配的那个单词）(\1)。
你也可以自己指定子表达式的组名。要指定一个子表达式的组名，请使用这样的语法：(?<Word>\w+)(或者把尖括号换成'也行：(?'Word'\w+)),这样就把\w+的组名指定为Word了。要反向引用这个分组捕获的内容，你可以使用\k<Word>,所以上一个例子也可以写成这样：\b(?<Word>\w+)\b\s+\k<Word>\b
九、零宽断言
有时候需要查找某些匹配之前或之后的东西，这个时候就需要用到们像\b,^,$那样用于指定一个位置，这个位置应该满足一定的条件(即断言)，因此它们也被称为零宽断言
(?=exp)也叫零宽度正预测先行断言，它断言自身出现的位置的后面能匹配表达式exp。比如\b\w+(?=ing\b)，匹配以ing结尾的单词的前面部分(除了ing以外的部分)，如查找I'm singing while you're dancing.时，它会匹配sing和danc。
(?<=exp)也叫零宽度正回顾后发断言，它断言自身出现的位置的前面能匹配表达式exp。比如(?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分)，例如在查找reading a book时，它匹配ading。
Java中的类
类可以看成是创建Java对象的模板。
一个类可以包含以下类型变量：
局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。
（备注：循环语句，String用法，数组等知识点说明过多，此处不详细展开）
题量和难度:
第四次的编程题，较为困难，需要通过正则表达式对输入样例进行分类，是否为正确输入，然后对数据进行计算得到输出。
第五次的编程题，难度较第四次更加简单一点，加设了特色菜的定义，需要进行分开计算。
期中考试的四道编程题，题量少，较为简单，考察继承和多态，接口和抽象类。
二、设计与分析
第四次系列作业
SourceMonitor报表：
Metrics Details For File 'Main.java'
--------------------------------------------------------------------------------------------
Parameter Value
========= =====
Project Directory C:\Users\平安\IdeaProjects\untitled4\src\
Project Name
Checkpoint Name Baseline
File Name Main.java
Lines 509
Statements 439
Percent Branch Statements 31.7
Method Call Statements 119
Percent Lines with Comments 0.6
Classes and Interfaces 9
Methods per Class 5.67
Average Statements per Method 6.94
Line Number of Most Complex Method 299
Name of Most Complex Method Order.addRecord()
Maximum Complexity 21
Line Number of Deepest Block 75
Maximum Block Depth 6
Average Block Depth 2.28
Average Complexity 4.31
--------------------------------------------------------------------------------------------
Most Complex Methods in 9 Class(es): Complexity, Statements, Max Depth, Calls
Controller.controller() 12, 20, 4, 16
Controller.dealMenu() 6, 12, 3, 10
Controller.dealOrder() 4, 6, 2, 3
Controller.dealPrice() 3, 8, 2, 1
Controller.dealTable() 10, 20, 6, 11
Dish.Dish() 1, 3, 2, 0
Dish.Dish() 1, 3, 2, 0
Dish.getPrice() 3, 13, 4, 1
isLegal.isLeap_year() 3, 1, 2, 0
isLegal.isLegal_data() 4, 4, 2, 2
isLegal.isLegal_Date_data() 18, 12, 3, 5
isLegal.isLegal_Date_format() 5, 5, 2, 4
isLegal.isLegal_format() 5, 4, 2, 3
isLegal.isLegal_tableNum_data() 4, 5, 2, 1
isLegal.isLegal_tableNum_format() 4, 4, 2, 2
isLegal.isLegal_Time_data() 4, 8, 2, 4
isLegal.isLegal_Time_format() 5, 5, 2, 4
isLegal.isLegal_unit_price_data() 4, 5, 2, 1
isLegal.isLegal_unit_price_format() 4, 4, 2, 2
isLegal.not_out_Date_data() 4, 6, 2, 2
Main.main() 1, 2, 2, 1
Menu.addDish() 3, 6, 3, 1
Menu.Menu() 1, 2, 2, 0
Menu.searchDishSymbol() 3, 4, 3, 1
Order.addRecord() 21, 39, 3, 21
Order.delARecordBy_recordNum() 5, 8, 3, 1
Order.findRecordBy_recordNum() 3, 4, 3, 0
Order.getTotalPrice() 1, 2, 2, 1
Order.getTotalPrice_nodiscount() 2, 4, 3, 0
Order.isLegal_number_data() 3, 4, 2, 1
Order.isLegal_number_format() 3, 4, 2, 1
Order.isLegal_portion_data() 3, 4, 2, 1
Order.isLegal_portion_format() 3, 4, 2, 1
Order.isLegal_recordNum_data() 3, 6, 2, 1
Order.isLegal_recordNum_format() 3, 4, 2, 1
Order.Order() 1, 4, 2, 0
Order.searchRecordSymbol() 4, 4, 3, 1
Order.setTotalPrice() 2, 4, 3, 0
Record.addNumber() 1, 1, 2, 0
Record.getPrice() 3, 5, 2, 0
Record.getPrice_noDiscount() 1, 1, 2, 1
Record.Record() 1, 4, 2, 0
Record.Record() 1, 2, 2, 0
Restaurant.addOrder() 1, 2, 2, 0
Restaurant.findorderBy_tableNum() 3, 4, 3, 0
Time.getDiscount() 14, 15, 5, 0
Time.isLeap_year() 3, 1, 2, 0
Time.setSecond() 1, 5, 2, 4
Time.setWeek() 5, 14, 3, 6
Time.Time() 1, 2, 2, 2
Time.yearDay() 16, 41, 4, 1
--------------------------------------------------------------------------------------------
Block Depth Statements
0 10
1 75
2 222
3 72
4 43
5 10
6 7
7 0
8 0
9+ 0
--------------------------------------------------------------------------------------------
类图
第五次系列作业
SourceMonitor报表：
Metrics Details For File 'Main.java'
--------------------------------------------------------------------------------------------
Parameter Value
========= =====
Project Directory C:\Users\平安\IdeaProjects\untitled4\src\
Project Name
Checkpoint Name Baseline
File Name Main.java
Lines 373
Statements 129
Percent Branch Statements 17.1
Method Call Statements 97
Percent Lines with Comments 2.7
Classes and Interfaces 2
Methods per Class 2.50
Average Statements per Method 22.60
Line Number of Most Complex Method 4
Name of Most Complex Method Main.main()
Maximum Complexity 20
Line Number of Deepest Block 167
Maximum Block Depth 9+
Average Block Depth 4.47
Average Complexity 10.50
--------------------------------------------------------------------------------------------
Most Complex Methods in 2 Class(es): Complexity, Statements, Max Depth, Calls
Main.main() 20, 45, 6, 34
Time.getweekday() 1, 0, 0, 0
--------------------------------------------------------------------------------------------
Block Depth Statements
0 4
1 13
2 24
3 33
4 7
5 6
6 4
7 1
8 5
9+ 32
--------------------------------------------------------------------------------------------
类图：
期中考试
SourceMonitor报表：
Metrics Details For File 'Main.java'
--------------------------------------------------------------------------------------------
Parameter Value
========= =====
Project Directory C:\Users\平安\IdeaProjects\untitled4\src\
Project Name
Checkpoint Name Baseline
File Name Main.java
Lines 75
Statements 55
Percent Branch Statements 25.5
Method Call Statements 13
Percent Lines with Comments 4.0
Classes and Interfaces 3
Methods per Class 1.00
Average Statements per Method 14.67
Line Number of Most Complex Method 3
Name of Most Complex Method Main.main()
Maximum Complexity 13
Line Number of Deepest Block 17
Maximum Block Depth 6
Average Block Depth 3.13
Average Complexity 5.00
--------------------------------------------------------------------------------------------
Most Complex Methods in 3 Class(es): Complexity, Statements, Max Depth, Calls
Circle.getArea() 1, 2, 2, 0
Main.main() 13, 40, 6, 13
Rectangle.getArea() 1, 2, 2, 0
--------------------------------------------------------------------------------------------
Block Depth Statements
0 4
1 7
2 13
3 8
4 4
5 15
6 4
7 0
8 0
9+ 0
--------------------------------------------------------------------------------------------
类图：
分析：
此次面向对象设计功能比较完善，但依旧有许多漏洞，复杂度都相对较低，期中考试内容较为简单，设计比较简易。
三、采坑心得
第四次系列作业主要要解决的问题是正则表达式的使用，正常判断分析需要结构更为复杂的代码，第五次系列作业主要增设了特色菜，需要进行分开存入和计算，判断特色菜的时候需要新增特色菜谱，期中考试值得注意的是知识点的运用，继承的使用和接口的使用。
四、改进建议
可以通过继承减少代码量，分模块合作，使用接口解决问题。
五、总结
第四次，第五次作业延续前面的系列，代码量依旧巨大，通过学习使用新方法让程序复杂度下降是相对不错的选择，期中考试更是巩固了继承和接口的学习。
源码附上：
第四次：
import java.util.*;
public class Main{
public static void main(String[] args) {
Controller controller = new Controller();
controller.controller();
}
}
class Controller {
int[] tableNum = new int[100];//存桌号，下标是订单号,[0]不存
int orderNum = 0;//订单号
boolean orderRight = true;
String[] str;
Menu m = new Menu();
Restaurant r = new Restaurant();
isLegal is = new isLegal();
public void controller(){
Scanner in = new Scanner(System.in);
String s = in.nextLine();
while (!(s.equalsIgnoreCase("end"))) {
if(s.length()==0){
System.out.println("wrong format");
s = in.nextLine();
continue;
}
else str = s.split(" ");
if(str[0].charAt(0)=='t') {
dealTable();
}
else if(Character.isDigit(str[0].charAt(0))&&!orderRight) {
}
else if(Character.isDigit(str[0].charAt(0))&&orderRight) {
dealOrder();
}
else if(orderNum==0) {
dealMenu();
}
else System.out.println("invalid dish");
s = in.nextLine();
}
for(int i=1;i<=orderNum;i++){
dealPrice(i);
}
}
public void dealPrice(int i){
int price_noDiscount;
int price;
price_noDiscount = r.orders[i-1].getTotalPrice_nodiscount();
price = r.orders[i-1].getTotalPrice();
if(price==-1)
System.out.printf("table %d out of opening hours\n",tableNum[i]);
else System.out.printf("table %d: %d %d\n",tableNum[i],price_noDiscount,price);
}
public void dealMenu(){
if(!is.isLegal_unit_price_format(str[1])){
System.out.println("wrong format");
return;
}
if(!is.isLegal_unit_price_data(str[1])){
System.out.println(str[0] + " price out of range " + Integer.parseInt(str[1]));
return;
}
if(str.length==2)
m.addDish(str[0],Integer.parseInt(str[1]),false);
else if(str[2].equals("T"))
m.addDish(str[0],Integer.parseInt(str[1]),true);
else System.out.println("wrong format");
}
public void dealTable(){
if(str[0].equalsIgnoreCase("table")){
if(str.length==4&&is.isLegal_format(str[1],str[2],str[3])){
if(is.isLegal_data(str[2],str[3])) {
if(is.isLegal_tableNum_data(str[1])){
orderRight = true;
orderNum++;
tableNum[orderNum] = Integer.parseInt(str[1]);
System.out.printf("table %d: \n",tableNum[orderNum]);
r.addOrder(tableNum[orderNum],str[2],str[3]);
} else {
System.out.println("table num out of range");
orderRight = false;
}
} else {
System.out.println(Integer.parseInt(str[1]) +"date error");
orderRight = false;
}
} else {
System.out.println("wrong format");
orderRight = false;
}
} else System.out.println("wrong format");
}
public void dealOrder(){
if (str[1].equalsIgnoreCase("delete"))
r.orders[orderNum-1].delARecordBy_recordNum(Integer.parseInt(str[0]));
else if(Character.isDigit(str[1].charAt(0)))
r.orders[orderNum-1].addRecord(m, str[1], str[2], str[3], str[4],true, str[0]);
else
r.orders[orderNum-1].addRecord(m, str[0], str[1], str[2], str[3],false,"0");
}
}
//判错
class isLegal{
public boolean isLegal_unit_price_format(String s){
if(s.matches("[\\d]{1,4}")&&s.charAt(0)!='0')
return true;
else return false;
}
public boolean isLegal_unit_price_data(String s){
int a = Integer.parseInt(s);
if(a>0&&a<300)
return true;
else return false;
}
public boolean isLegal_format(String s1,String s2,String s3){
if(isLegal_tableNum_format(s1)&&isLegal_Date_format(s2)&&isLegal_Time_format(s3))
return true;
else return false;
}
public boolean isLegal_data(String s2,String s3){
if(isLegal_Date_data(s2)&&isLegal_Time_data(s3))
return true;
else return false;
}
public boolean isLegal_tableNum_format(String s){
if(s.matches("[\\d]{1,3}")&&s.charAt(0)!='0')
return true;
else return false;
}
public boolean isLegal_tableNum_data(String s){
int a = Integer.parseInt(s);
if(a>=1&&a<=55)
return true;
else return false;
}
public boolean isLegal_Date_format(String s){
String[] str = s.split("/");
if(str[0].matches("[\\d]{4}")&&str[1].matches("[\\d]{1}|[\\d]{2}")&&str[2].matches("[\\d]{1}|[\\d]{2}"))
return true;
else return false;
}
public boolean isLegal_Time_format(String s){
String[] str = s.split("/");
if(str[0].matches("[\\d]{1}|[\\d]{2}")&&str[1].matches("[\\d]{1}|[\\d]{2}")&&str[2].matches("[\\d]{1}|[\\d]{2}"))
return true;
else return false;
}
public boolean isLegal_Date_data(String s){
String[] str = s.split("/");
int m = Integer.parseInt(str[1]);
int d = Integer.parseInt(str[2]);
if (m == 1 || m == 3 || m == 5 || m == 7 || m == 8 || m == 10 || m == 12)
return d > 0 && d < 32;
else if (m == 4 || m == 6 || m == 9 || m == 11)
return d > 0 && d < 31;
else if (m == 2)
if (isLeap_year(Integer.parseInt(str[0]))) return d > 0 && d < 30;
else return d > 0 && d < 29;
return false;
}
public boolean isLeap_year(int year) {
return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
}
public boolean isLegal_Time_data(String s) {
String[] str = s.split("/");
int h = Integer.parseInt(str[0]);
int m = Integer.parseInt(str[1]);
int se = Integer.parseInt(str[2]);
if(h<=23&&h>=0&&m>=0&&m<=59&&se>=0&&se<=59)
return true;
else return false;
}
public boolean not_out_Date_data(String s){
String[] str = s.split("/");
int y = Integer.parseInt(str[0]);
if(y==2022||y==2023)
return true;
else return false;
}
}
class Dish{
String name;
double unit_price;
boolean isT;
public Dish(){
this.name = "";
this.unit_price = 0;
this.isT = false;
}
public Dish(String dishName,double price,boolean T){
name = dishName;
unit_price = price;
isT = T;
}
public int getPrice(int portion,int num){
double n=0;
switch(portion){
case 1:
n = this.unit_price * 1.0;break;
case 2:
n = this.unit_price * 1.5;break;
case 3:
n = this.unit_price * 2.0;break;
}
return (int)Math.round(n)*num;
}
}
class Menu{
Dish[] dishes = new Dish[20];
int menuSize;
public Menu(){
dishes[0] = new Dish();
menuSize = 1;
}
public int searchDishSymbol(String dishName) {
for(int i=menuSize-1;i>=1;i--) {
if (dishes[i].name.equals(dishName))
return i;
}
return -1;
}
public void addDish(String dishName,double unit_price,boolean T) {
int i = searchDishSymbol(dishName);
if(i==-1){
dishes[menuSize] = new Dish(dishName,unit_price,T);
menuSize++;
} else {
dishes[i] = new Dish(dishName,unit_price,T);
}
}
}
class Record{
int recordNum;
Dish d;
int portion;
int number;
public Record(){
this.recordNum = -1;
this.d = new Dish();
}
public Record(int recordNum,Dish dish, int portion,int number){
this.recordNum = recordNum;
this.d = dish;
this.portion = portion;
this.number = number;
}
public void addNumber(int number){
this.number += number;
}
public int getPrice_noDiscount(){
return d.getPrice(portion,number);
}
public int getPrice(Time t){
double i =t.getDiscount(d);
if(i==-1)
return -1;
else return (int)Math.round(d.getPrice(portion,number) * i);
}
}
class Order {
int tableNum;
Time time;
Record[] records = new Record[20];
int orderSize;
int TotalPrice;
public Order(int tableNum,String s1,String s2){
this.tableNum = tableNum;
time = new Time(s1,s2);
records[0] = new Record();
orderSize = 1;
}
public void setTotalPrice(){
int s = 0;
for (int i = 1; i< orderSize; i++) {
s += records[i].getPrice(time);
}
this.TotalPrice = s;
}
public int getTotalPrice(){
setTotalPrice();
return TotalPrice;
}
public int getTotalPrice_nodiscount(){
int s = 0;
for (int i = 1; i< orderSize; i++) {
s += records[i].getPrice_noDiscount();
}
return s;
}
public void addRecord(Menu m,String recordNum,String dishName,String portion,String num,boolean isFor_other,String for_tableNum) {
boolean isError = false;
int i = m.searchDishSymbol(dishName);
if(i==-1){
System.out.println(dishName + " does not exist");
i=0;isError = true;
}
if(!isError&&!isLegal_recordNum_format(recordNum)) {
System.out.println("wrong format");
isError = true;
}
if(!isError&&!isLegal_portion_data(portion)){
System.out.println(recordNum + " portion out of range " + portion);
isError = true;
} else if(!isError&&!isLegal_portion_format(portion)){
System.out.println("wrong format");
isError = true;
} else if(!isError&&!isLegal_number_data(num)){
System.out.println(recordNum + " num out of range " + num);
isError = true;
} else if(!isError&&!isLegal_number_format(num)){
System.out.println("wrong format");
isError = true;
}
if(!isError&&!isLegal_recordNum_data(recordNum)) {
System.out.println("record serial number sequence error");
return;
}
int j =searchRecordSymbol(dishName , Integer.parseInt(portion));
Record newrecord;
if(isError)
newrecord = new Record(Integer.parseInt(recordNum),m.dishes[i], 0,0);
else newrecord = new Record(Integer.parseInt(recordNum),m.dishes[i], Integer.parseInt(portion),Integer.parseInt(num));
if(j == -1){
records[orderSize] = newrecord;
orderSize++;
}else records[j].addNumber(Integer.parseInt(num));
if(isFor_other&&!isError)
System.out.println(recordNum + " table " + tableNum + " pay for table " + for_tableNum + " " + newrecord.getPrice_noDiscount());
else if(!isError)System.out.println(recordNum + " " + dishName + " " + newrecord.getPrice_noDiscount());
}
public int searchRecordSymbol(String dishName,int portion){
for(int i=orderSize-1;i>=1;i--) {
if (records[i].d.name.equals(dishName)&&records[i].portion==portion)
return i;
}
return -1;
}
public Record findRecordBy_recordNum(int recordNum) {
for (int i = 1; i < orderSize; i++) {
if (records[i].recordNum == recordNum)
return records[i];
}
return null;
}
public void delARecordBy_recordNum(int recordNum) {
Record record = findRecordBy_recordNum(recordNum);
if(record!=null){
if(record.number!=0)
record.number=0;
else System.out.println("deduplication " + recordNum);
}
else
System.out.println("delete error;");
}
public boolean isLegal_recordNum_data(String s){
int i = records[orderSize-1].recordNum;
int j = Integer.parseInt(s);
if(j>i)
return true;
else return false;
}
public boolean isLegal_recordNum_format(String s){
if(s.matches("0[\\d]")) return false;
else return true;
}
public boolean isLegal_portion_format(String s){
if(s.matches("[\\d]{1}")) return true;
else return false;
}
public boolean isLegal_portion_data(String s){
if(s.matches("[1-3]{1}")) return true;
else return false;
}
public boolean isLegal_number_format(String s){
if(s.matches("0[\\d]")) return false;
else return true;
}
public boolean isLegal_number_data(String s){
if(Integer.parseInt(s)>15) return false;
else return true;
}
}
class Restaurant{
Order[] orders = new Order[56];
int orderNum = 0;
public void addOrder(int tableNum,String s1,String s2){
orders[orderNum] = new Order(tableNum,s1,s2);
orderNum++;
}
public boolean findorderBy_tableNum(int tableNum){
for (int i = 0; i < orderNum; i++) {
if (orders[i].tableNum == tableNum)
return true;
}
return false;
}
}
class Time {
int week;
int second;
public Time(String s1, String s2) {
setWeek(s1);
setSecond(s2);
}
public void setWeek(String s) {
String[] str = s.split("/");
int year = Integer.parseInt(str[0]);
int month = Integer.parseInt(str[1]);
int day = Integer.parseInt(str[2]);
int sum = 0;
for (int i = 1900; i < year; i++) {
if (isLeap_year(i))
sum++;
}
int D = (year - 1900 - sum) * 365 + sum * 366 + yearDay(year, month, day);
int d = D % 7;
if (d == 0)
week = 7;
else week = d;
}
public boolean isLeap_year(int year) {
return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
}
public int yearDay(int year, int month, int day) {
int d = 0;
switch (month) {
case 1:
d = day;
break;
case 2:
d = 31 + day;
break;
case 3:
d = 60 + day;
break;
case 4:
d = 91 + day;
break;
case 5:
d = 121 + day;
break;
case 6:
d = 152 + day;
break;
case 7:
d = 182 + day;
break;
case 8:
d = 213 + day;
break;
case 9:
d = 244 + day;
break;
case 10:
d = 274 + day;
break;
case 11:
d = 305 + day;
break;
case 12:
d = 335 + day;
break;
}
if (!isLeap_year(year) && month > 2)
d--;
return d;
}
public void setSecond(String s) {
String[] str = s.split("/");
int h = Integer.parseInt(str[0]);
int m = Integer.parseInt(str[1]);
int se = Integer.parseInt(str[2]);
second = h * 3600 + m * 60 + se;
}
public double getDiscount(Dish d) {
if (week == 6 || week == 7)
if (second >= 34200 && second <= 77400)
return 1.0;
else return -1;
else {
if (d.isT)
return 0.7;
else {
if (second >= 37800 && second <= 52200)
return 0.6;
else if(second >= 61200 && second <= 73800)
return 0.8;
else return -1;
}
}
}
}
第五次：
import java.time.LocalDateTime;
import java.util.Scanner;
public class Main{
public static void main(String[]args) {
Scanner in = new Scanner(System.in);
Menu menu=new Menu();
Shop shop=new Shop();
String input;
input=in.nextLine();
String[]k=input.split(" ");
while(true) {
if(input.matches("[\u4e00-\u9fa5]+ \\d+")) {
menu.adddish(k[0], null, Integer.parseInt(k[1]), "m");
}
else if(input.matches("[\u4e00-\u9fa5]+ [\u4e00-\u9fa5]+ \\d+ T")) {
menu.adddish(k[0], k[1], Integer.parseInt(k[2]), k[3]);
}
else if(k[0].equals("table"))
break;
else
System.out.println("wrong format");
input=in.nextLine();
k=input.split(" ");
}
while(!input.equals("end")) {
if(input.matches("table \\d+ : \\w{1,10} ([1][8][1|9|0]|[1][3][3|5|6])\\d{8} \\d{4}/\\d+/\\d+ \\d+/\\d+/\\d+"))
shop.gettable(Integer.parseInt(k[1]), k[3], k[4], k[5], k[6]); //输入桌子信息
else if(input.matches("\\d+ [\\u4e00-\\u9fa5]+ \\d \\d+ \\d+")) //点特色菜
shop.table[shop.num].order.addrecord(shop.table[shop.num].Tablenum , shop.table[shop.num].Tablenum, Integer.parseInt(k[0]), k[1], Integer.parseInt(k[2]), Integer.parseInt(k[3]), Integer.parseInt(k[4]));
else if(input.matches("\\d+ [\\u4e00-\\u9fa5]+ \\d+ \\d+")) //点普通菜
shop.table[shop.num].order.addrecord(shop.table[shop.num].Tablenum , shop.table[shop.num].Tablenum, Integer.parseInt(k[0]), k[1], 0, Integer.parseInt(k[2]), Integer.parseInt(k[3]));
else if(input.matches("\\d+ \\d+ [\\u4e00-\\u9fa5]+ \\d+ \\d+")) //代点普通菜
shop.table[shop.num].order.addrecord(Integer.parseInt(k[0]), shop.table[shop.num].Tablenum, Integer.parseInt(k[1]), k[2], 0, Integer.parseInt(k[3]), Integer.parseInt(k[4]));
else if(input.matches("\\d+ \\d+ [\\u4e00-\\u9fa5]+ \\d+ \\d+ \\d+")) //代点特色菜
shop.table[shop.num].order.addrecord(Integer.parseInt(k[0]), shop.table[shop.num].Tablenum, Integer.parseInt(k[1]), k[2], Integer.parseInt(k[3]), Integer.parseInt(k[4]), Integer.parseInt(k[5]));
else if(input.matches("\\d+ delete")) //删菜
shop.table[shop.num].order.delrecord(Integer.parseInt(k[0]));
else System.out.println("wrong format");
input=in.nextLine();
k=input.split(" ");
try {
if(shop.table[shop.num].time.ying==0) {
shop.num--;
while(!input.equals("end")&&!k[0].equals("table")) {
input=in.nextLine();
k=input.split(" ");
}}
}
catch(Exception ex) {
while(!input.equals("end")&&!k[0].equals("table")) {
input=in.nextLine();
k=input.split(" ");
}
}}
shop.Print();
shop.print();
in.close();
}
}
class Time{
boolean fa=true;
int ying=1;
int year;
int month;
int day;
int hour;
int minute;
int second;
int weekday;
void getweekday() { //获得星期几
this.weekday=LocalDateTime.of(this.year, this.month, this.day, this.hour, this.minute).getDayOfWeek().getValue();
}
void gettime(String time1,String time2) { //获得时间
fa=true;
String[] k=time1.split("/");
year=Integer.parseInt(k[0]);
month=Integer.parseInt(k[1]);
day=Integer.parseInt(k[2]);
String[] l=time2.split("/");
hour=Integer.parseInt(l[0]);
minute=Integer.parseInt(l[1]);
getweekday();
if(year<2022||year>2023) {
System.out.println("not a valid time period");
ying=0;}
if(weekday>=1&&weekday<=5) { //是否营业和营业时间
if((hour>=17&&hour<20)||(hour==20&&minute<=30)) {
ying=1;}
else if((hour==10&&minute>=30)||(hour>=11&&hour<14)||(hour==14&&minute<=30)) {
ying=2;}
else {ying=0;}}
else {
if((hour==9&&minute>=30)||(hour>=10&&hour<21)||(hour==21&&minute<=30)) {
ying=3;}
else {ying=0;}}
}}
class Shop{
int num=-1; //角标
Table[] table=new Table[10];
void print() {
Table m;
if(num>=0) {
for(int i=0;i<num;i++) {
for(int j=0;j<num-i;j++) {
if(table[j].name.compareTo(table[j+1].name)>0) {
m=table[j];
table[j]=table[j+1];
table[j+1]=m;
}
if(table[j].name.compareTo(table[j+1].name)==0) {
table[j].totalprice=table[j].totalprice+table[j+1].totalprice;
table[j+1].name=null;
}
}
}
for(int i=0;i<=num;i++) {
if(table[i].name!=null) {
System.out.println(table[i].name+" "+table[i].telnum+" "+table[i].totalprice);
}
}
}
}
void Print() { //最终处理结果输出
for(int i=0;i<=num;i++) {
for(int j=0;j<table[i].order.num;j++) {
if(table[i].order.record[j].dish.T) {
if(table[i].order.record[j].tnum==table[i].order.tnum) {
if(table[i].order.record[j].dish.wei.equals("川菜")) {
table[i].chuanshu+=table[i].order.record[j].num;
table[i].chuan+=table[i].order.record[j].du*table[i].order.record[j].num;
}
if(table[i].order.record[j].dish.wei.equals("晋菜")) {
table[i].jinshu+=table[i].order.record[j].num;
table[i].jin+=table[i].order.record[j].du*table[i].order.record[j].num;
}
if(table[i].order.record[j].dish.wei.equals("浙菜")) {
table[i].zheshu+=table[i].order.record[j].num;
table[i].zhe+=table[i].order.record[j].du*table[i].order.record[j].num;
}
}
else {
int k=0;
for(int f=0;f<=num;f++) {
if(table[i].order.record[j].tnum==table[f].Tablenum) {
k=f;
break;
}
}
if(table[i].order.record[j].dish.wei.equals("川菜")) {
table[k].chuanshu+=table[i].order.record[j].num;
table[k].chuan+=table[i].order.record[j].du*table[i].order.record[j].num;
}
if(table[i].order.record[j].dish.wei.equals("晋菜")) {
table[k].jinshu+=table[i].order.record[j].num;
table[k].jin+=table[i].order.record[j].du*table[i].order.record[j].num;
}
if(table[i].order.record[j].dish.wei.equals("浙菜")) {
table[k].zheshu+=table[i].order.record[j].num;
table[k].zhe+=table[i].order.record[j].du*table[i].order.record[j].num;
}
}
}
}
}
for(int i=0;i<=num;i++) {
table[i].getallprice();
table[i].gettotalprice();
System.out.print("table "+table[i].Tablenum+": "+table[i].allprice+" "+table[i].totalprice);
if(table[i].chuan!=0) {
if((int)Math.round(table[i].chuan*1.0/table[i].chuanshu)==0)
System.out.print(" 川菜 "+table[i].chuanshu+" 不辣");
if((int)Math.round(table[i].chuan*1.0/table[i].chuanshu)==1)
System.out.print(" 川菜 "+table[i].chuanshu+" 微辣");
if((int)Math.round(table[i].chuan*1.0/table[i].chuanshu)==2)
System.out.print(" 川菜 "+table[i].chuanshu+" 稍辣");
if((int)Math.round(table[i].chuan*1.0/table[i].chuanshu)==3)
System.out.print(" 川菜 "+table[i].chuanshu+" 辣");
if((int)Math.round(table[i].chuan*1.0/table[i].chuanshu)==4)
System.out.print(" 川菜 "+table[i].chuanshu+" 很辣");
if((int)Math.round(table[i].chuan*1.0/table[i].chuanshu)==5)
System.out.print(" 川菜 "+table[i].chuanshu+" 爆辣");
}
if(table[i].jin!=0) {
if((int)Math.round(table[i].jin*1.0/table[i].jinshu)==0)
System.out.print(" 晋菜 "+table[i].jinshu+" 不酸");
if((int)Math.round(table[i].jin*1.0/table[i].jinshu)==1)
System.out.print(" 晋菜 "+table[i].jinshu+" 微酸");
if((int)Math.round(table[i].jin*1.0/table[i].jinshu)==2)
System.out.print(" 晋菜 "+table[i].jinshu+" 稍酸");
if((int)Math.round(table[i].jin*1.0/table[i].jinshu)==3)
System.out.print(" 晋菜 "+table[i].jinshu+" 酸");
if((int)Math.round(table[i].jin*1.0/table[i].jinshu)==4)
System.out.print(" 晋菜 "+table[i].jinshu+" 很酸");
}
if(table[i].zhe!=0) {
if((int)Math.round(table[i].zhe*1.0/table[i].zheshu)==0)
System.out.print(" 浙菜 "+table[i].zheshu+" 不甜");
if((int)Math.round(table[i].zhe*1.0/table[i].zheshu)==1)
System.out.print(" 浙菜 "+table[i].zheshu+" 微甜");
if((int)Math.round(table[i].zhe*1.0/table[i].zheshu)==2)
System.out.print(" 浙菜 "+table[i].zheshu+" 稍甜");
if((int)Math.round(table[i].zhe*1.0/table[i].zheshu)==3)
System.out.print(" 浙菜 "+table[i].zheshu+" 甜");
}
if(table[i].chuanshu==0&&table[i].jinshu==0&&table[i].zheshu==0)
System.out.print(" ");
System.out.println("");
}
}
void gettable(int tablenum,String name,String telnum,String time1,String time2){ //获取桌号、人名、电话和时间
num++; //下一桌
table[num]=new Table();
table[num].time=new Time(); //记得new
table[num].order=new Order();
table[num].ye=true;
table[num].name=name; //获取人名
table[num].telnum=telnum; //获取电话
table[num].Tablenum=tablenum; //获取桌号
table[num].order.tnum=tablenum; //记录桌号
table[num].time.gettime(time1, time2); //获取时间
table[num].time.getweekday(); //获取星期几
if(table[num].time.ying!=0)
System.out.println("table "+tablenum+": ");
else System.out.println("table "+tablenum+" out of opening hours");}}
class Table{
boolean ye=true; //是否营业
String telnum; //电话
String name; //人名
int Tablenum; //记录桌号
int totalprice; //记录总价（折后）
int allprice; //记录总价（折前）
Time time;
Order order;
int chuan=0; //川菜口味度
int chuanshu=0; //川菜数
int jin=0;
int jinshu=0;
int zhe=0;
int zheshu=0;
void getallprice() { //获取总价（折前）
double price=0;
for(int i=0;i<order.num;i++)
price=price+order.record[i].price;
allprice=(int)Math.round(price);
}
void gettotalprice() { //获取总价（折后）
double price=0;
if(time.weekday>=1&&time.weekday<=5) { //工作日计价
if((time.hour>=17&&time.hour<20)||(time.hour==20&&time.minute<=30)) { //下午
for(int i=0;i<order.num;i++) {
if(order.record[i].dish.T==true) //特色菜
{price=price+Math.round(order.record[i].price*0.7);}
else {price=price+Math.round(order.record[i].price*0.8);}}}
else if((time.hour==10&&time.minute>=30)||(time.hour>=11&&time.hour<14)||(time.hour==14&&time.minute<=30)) {//中午
for(int i=0;i<order.num;i++) {
if(order.record[i].dish.T==true)
price=price+Math.round(order.record[i].price*0.7);
else price=price+Math.round(order.record[i].price*0.6);}}
else {ye=false;}}
else { //周末计价
if((time.hour==9&&time.minute>=30)||(time.hour>=10&&time.hour<21)||(time.hour==21&&time.minute<=30)) {
for(int i=0;i<order.num;i++)
price=price+order.record[i].price;}
else ye=false;}
totalprice=(int)Math.round(price);}}
class Order{
Record[]record=new Record[20];
int chuan=0;
int jin=0;
int zhe=0;
Menu menu;
int num=0; //角标
int tnum; //订单桌号
void addrecord(int hao,int tnum,int ordernum,String name,int du,int portion,int num) {
int k=1;
Menu menu=new Menu();
if(menu.search(name)==null) {
System.out.println(name+" does not exist");
}
else {
record[this.num]=new Record();
record[this.num].dish=new Dish();
record[this.num].dish=menu.search(name);
record[this.num].tnum=hao;
record[this.num].ordernum=ordernum;
record[this.num].portion=portion;
record[this.num].num=num;
record[this.num].du=du;
record[this.num].getprice();
if(record[this.num].dish.T&&hao==tnum) {
if(k==1&&record[this.num].dish.wei.equals("川菜")) {
if(du<0||du>5)
{this.num--;System.out.println("spicy num out of range:"+du);k=0;}
}
if(k==1&&record[this.num].dish.wei.equals("晋菜")) {
if(du<0||du>4)
{this.num--;System.out.println("acidity num out of range:"+du);k=0;}
}
if(k==1&&record[this.num].dish.wei.equals("浙菜")) {
if(du<0||du>3)
{this.num--;System.out.println("sweetness num out of range:"+du);k=0;}
}
}
if(k==1&&hao==tnum)
System.out.println(record[this.num].ordernum+" "+record[this.num].dish.name+" "+record[this.num].price);
if(k==1&&hao!=tnum)
System.out.println(record[this.num].ordernum+" table "+tnum+" pay for table "+hao+" "+record[this.num].price);
this.num++;
}}
void delrecord(int m){ //删菜
int a=0;
for(int i=0;i<num;i++) {
if(record[i].ordernum==m) {
record[i].price=0;
record[i].num=0;
a=1;}
}
if(a==0)
System.out.println("delete error");
}
}
class Record{
Dish dish;
int du; //口味度
int tnum; //记录桌号
int ordernum; //记录号
int num; //份数
int portion; //份额
int price; //该记录总价
void getprice(){ //计价
this.price=dish.getprice(this.portion)*num;
}
}
class Dish{
int price; //单价
String name; //菜名
String wei; //口味
boolean T=false; //特色菜判断
int getprice(int portion) { //份额计价
double price;
price=this.price;
price=Math.round(price*(1+portion)/2);
return (int)price;
}
}
class Menu{
public static Dish[] dish=new Dish[20];
static int dishnum=0; //角标
void adddish(String name,String wei,int price,String T) { //菜单加菜
int m=0; //加菜判断
for(int i=0;i<dishnum;i++) { //重复菜名
if(dish[i].name.equals(name)) {
dish[i].price=price;
m=1;
}
}
if(m==0) {
dish[dishnum]=new Dish();
if(T.equals("T")) {
dish[dishnum].T=true;
dish[dishnum].wei=wei;}
dish[dishnum].name=name;
dish[dishnum].price=price;
dishnum++;
}
}
Dish search(String name) { //找菜
for(int i=0;i<dishnum;i++)
if(dish[i].name.equals(name))
return dish[i];
return null;
}
}
期中考试：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
double[] T=new double[100];
double min;
int m=0;
int n=0;
int choice = input.nextInt();
while(choice != 0) {
switch (choice) {
case 1://Circle
Circle c = new Circle();
double t = input.nextDouble();
if (t > 0) {
T[n]= c.getArea(t);
} else {
System.out.println("Wrong Format");
}
break;
case 2://Rectangle
Rectangle rec = new Rectangle();
double x1 = input.nextDouble();
double y1 = input.nextDouble();
double x2 = input.nextDouble();
double y2 = input.nextDouble();
if (rec.getArea(x1, y1, x2, y2) < 0) {
T[n]= -rec.getArea(x1, y1, x2, y2);
} else {
T[n]= rec.getArea(x1, y1, x2, y2);
}
break;
}
n++;
choice = input.nextInt();
}
for(int i=0;i<n;i++)
{
min=T[i];
m=i;
for(int j=i;j<n;j++)
{
if(T[j]<min)
{
min=T[j];
m=j;
}
}
T[m]=T[i];
T[i]=min;
}
for(int i=0;i<n;i++)
{
System.out.print(String.format("%.2f ", T[i]));
}
}
}
class Rectangle{
double x1,x2,y1,y2;
double s;
public double getArea(double x1,double y1,double x2,double y2){
s=(x2-x1)*(y2-y1);
return s;
}
}
class Circle{
private double r;
double s;
public double getArea(double r){
s=Math.PI*r*r;
return s;
}
}
