BLOG-2

前言

这次BLOG要总结的题目是PTA-4、PTA-5以及面向对象程序设计课的期中考试。其中，PTA-4有一道题目，是菜单计价程序4；PTA-5有一道题目，是菜单计价程序5；期中考试有4道题目，分别是：测验1-圆类设计、测验2-类结构设计、测验3-继承与多态和测验4-抽象类与接口。

在这几次作业（考试）中，难度较大的是PTA-4和PTA-5，即菜单计价程序-4和菜单计价程序5这两道题。期中考试的四道题难度相对来说要简单。

我的作业（考试）完成情况也和题目难度相对应：菜单计价程序-4和菜单计价程序5这两道题目都只能拿到三十分以下，完成度很低，情况比较差；期中考试除了第四题有几个测试点一直未能通过，扣掉7分外，其余三道题都拿了满分。

这三次作业（考试）涉及到的知识点主要是：Java语言程序设计基础、面向对象程序设计基础、面向对象三大特征（封装、继承、多态）、抽象类和接口等等。

设计与分析

（1）PTA-5

源码：

import java.time.DateTimeException;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
public static boolean isNumeric(String string) {
int intValue;
try {
intValue = Integer.parseInt(string);
return true;
} catch (NumberFormatException e) {
return false;
}
}

public static void main(String[] args) {
Menu menu = new Menu();
ArrayList<Table> tables = new ArrayList<Table>();
ArrayList<User> users = new ArrayList<User>();
Scanner input = new Scanner(System.in);
String str1 = new String();
int i = 0;
int portion = 0, quota = 0;
while (true) {// 输入菜单
Dish temp = new Dish();
int isRepeat = -1;
str1 = input.nextLine();
if (str1.matches("[\\S]* [1-9][\\d]*")) {
String[] token = str1.split(" ");
temp.name = token[0];
temp.unit_price = Integer.parseInt(token[1]);
temp.isT = false;
isRepeat = menu.searchDish(temp.name);
if (isRepeat != -1) {
menu.dishs.remove(isRepeat);
}
menu.dishs.add(temp);
} else if (str1.matches("[\\S]* [\\S]* [\\d]* T")) {
String[] token = str1.split(" ");
temp.name = token[0];
temp.unit_price = Integer.parseInt(token[2]);
temp.isT = true;
switch (token[1]) {
case "川菜":
temp.FlavorType = "spicy";
temp.MaxFlavor = 5;
break;
case "晋菜":
temp.FlavorType = "acidity";
temp.MaxFlavor = 4;
break;
case "浙菜":
temp.FlavorType = "sweetness";
temp.MaxFlavor = 3;
break;
default :str1 = input.nextLine();
System.out.println("wrong format");
continue;

}
isRepeat = menu.searchDish(temp.name);
if (isRepeat != -1) {
menu.dishs.remove(isRepeat);
}
menu.dishs.add(temp);
} else if (str1.equals("end")) {
break;
} else if (str1.matches("tab.*")) {
break;

} else {
str1 = input.nextLine();
System.out.println("wrong format");
continue;
}
}
while (!str1.equals("end")) {
Table temp = new Table();
boolean isRepeat = false;
int repeatNum = 0;
if (str1.matches(".*t.*a.*")) {
if (str1.matches(
"table [1-9][\\d]* : [\\S]* [\\d]* [\\d]*/[\\d][\\d]?/[\\d][\\d]? [\\d][\\d]?/[\\d][\\d]?/[\\d][\\d]?")) {
String[] token = str1.split(" ");
temp.userName = token[3];
if(token[3].length()>10) {
str1 = input.nextLine();
System.out.println("wrong format");
continue;
}
temp.callNum = token[4];
if(token[4].length()!=11) {
str1 = input.nextLine();
System.out.print("wrong format");
continue;
}
String headNum = token[4].substring(0, 3);
if(!headNum.equals("180")&&!headNum.equals("181")&&!headNum.equals("189")&&!headNum.equals("133")&&!headNum.equals("135")&&!headNum.equals("136")) {
str1 = input.nextLine();
System.out.println("wrong format");
continue;
}
String[] Date = token[5].split("/");
String[] Time = token[6].split("/");
int[] intDate = new int[5];
int[] intTime = new int[6];
for (i = 0; i < 3; i++) {
intDate[i] = Integer.parseInt(Date[i]);
intTime[i] = Integer.parseInt(Time[i]);
}
temp.num = Integer.parseInt(token[1]);
try {
temp.time = LocalDateTime.of(intDate[0], intDate[1], intDate[2], intTime[0], intTime[1],
intTime[2]);
temp.getWeekDay();
} catch (DateTimeException e) {
System.out.println(temp.num + " date error");
str1 = input.nextLine();
continue;
}
if (!temp.isOpen()) {
System.out.println("table " + temp.num + " out of opening hours");
str1 = input.nextLine();
continue;
}

System.out.println("table " + temp.num + ": ");

} else {
System.out.println("wrong format");
str1 = input.nextLine();
continue;
}
// 本桌开始点菜
while (true) {
str1 = input.nextLine();
//判断是否为非特色菜
if (str1.matches("[1-9][\\d]* [\\S]* [\\d] [1-9][\\d]*")) {
String[] token = str1.split(" ");
portion = Integer.parseInt(token[2]);
quota = Integer.parseInt(token[3]);
if (menu.searchDish(token[1]) == -1) {
System.out.println(token[1] + " does not exist");
continue;
}
Record tempRecord = new Record();
tempRecord.d = menu.dishs.get(menu.searchDish(token[1]));
tempRecord.orderNum = Integer.parseInt(token[0]);
tempRecord.portion = portion;
tempRecord.quota = quota;
temp.records.add(tempRecord);
System.out.println(tempRecord.orderNum +" "+token[1]+ " " +tempRecord.getPrice());
}
//判断是否为特色菜
else if(str1.matches("[1-9][\\d]* [\\S]* [\\d] [\\d] [1-9][\\d]*")) {
String[] token = str1.split(" ");
if (menu.searchDish(token[1]) == -1) {
System.out.println(token[1] + " does not exist");
continue;
}
int FlavorNum = Integer.parseInt(token[2]);
if(FlavorNum<0||FlavorNum>menu.dishs.get(menu.searchDish(token[1])).MaxFlavor) {
System.out.println(menu.dishs.get(menu.searchDish(token[1])).FlavorType+" num out of range :"+FlavorNum);
continue;
}
portion = Integer.parseInt(token[3]);
quota = Integer.parseInt(token[4]);
if (menu.searchDish(token[1]) == -1) {
System.out.println(token[1] + " does not exist");
continue;
}
Record tempRecord = new Record();
tempRecord.d = menu.dishs.get(menu.searchDish(token[1]));
tempRecord.FlavorNum = FlavorNum;
tempRecord.orderNum = Integer.parseInt(token[0]);
tempRecord.portion = portion;
tempRecord.quota = quota;
temp.records.add(tempRecord);
System.out.println(tempRecord.orderNum +" "+token[1]+" "+ tempRecord.getPrice());
}
// 判断是否为删除订单
else if (str1.matches("[1-9][\\d]* delete")) {
String[] token = str1.split(" ");
int delNum = Integer.parseInt(token[0]);
for(i=0;i<temp.records.size();i++) {
if(temp.records.get(i).orderNum==delNum) {
if(!temp.records.get(i).isDeleted) {
temp.records.get(i).isDeleted = true;
}
else System.out.println("delete error");
break;
}
if(i==temp.records.size())System.out.println("delete error");
}

}
// 判断是否为代点
else if (str1.matches("[\\d]* [\\d]* [\\S].*")) {
String[] token = str1.split(" ");
// 判断代点桌号是否存在
boolean exist = false;
int j = 0;
for (j = 0; j < tables.size(); j++) {
if (tables.get(j).num == Integer.parseInt(token[0])) {
exist = true;
break;
}
}
if (exist) {
System.out.print(Integer.parseInt(token[1]) + " table " + temp.num + " pay for table "
+ Integer.parseInt(token[0]) + " ");
Record treat = new Record();
treat.d = menu.dishs.get(menu.searchDish(token[2]));
if(treat.d.isT) {
treat.FlavorNum = Integer.parseInt(token[3]);
treat.portion = Integer.parseInt(token[4]);
treat.quota = Integer.parseInt(token[5]);
if(treat.d.FlavorType.equals("spicy")) {
tables.get(j).ChuanNum+=treat.quota;
tables.get(j).spicyType +=treat.FlavorNum*treat.quota;
}
if(treat.d.FlavorType.equals("acidity")) {
tables.get(j).JinNum+=treat.quota;
tables.get(j).spicyType +=treat.FlavorNum*treat.quota;
}
if(treat.d.FlavorType.equals("sweetness")) {
tables.get(j).ZheNum+=treat.quota;
tables.get(j).spicyType +=treat.FlavorNum*treat.quota;
}
}
else {
treat.portion = Integer.parseInt(token[3]);
treat.quota = Integer.parseInt(token[4]);
}
System.out.print(treat.getPrice() + "\n");
treat.isTreat = true;
temp.records.add(treat);
}
// 若不存在则输出内容
else {
System.out.println("Table number ：" + Integer.parseInt(token[0]) + " does not exist");
}

} else if (str1.equals("end")) {
break;
} else if (str1.matches("table.*")) {
break;
} else {
System.out.println("wrong format");
continue;
}
}
// 本桌点菜结束，进入下一桌
tables.add(temp);
} else {
str1 = input.nextLine();
}
}

// 最终输出桌号订单信息
for (i = 0; i < tables.size(); i++) {
if (tables.get(i).isOpen()) {
tables.get(i).getSum();
tables.get(i).getFlavorNum();
if(i!=0)System.out.print("\n");
tables.get(i).showEnd();
boolean isRepeat = false;
for(int j=0;j<users.size();j++) {
if(tables.get(i).userName.equals(users.get(j).userName)) {
users.get(j).paidMoney+=tables.get(i).sum;
isRepeat = true;
break;
}
}
if(!isRepeat) {
User tempUser = new User();
tempUser.userName = tables.get(i).userName;
tempUser.callNum = tables.get(i).callNum;
tempUser.paidMoney = tables.get(i).sum;
users.add(tempUser);
}
}

}
users.sort(new Comparator<User>() {
public int compare(User a,User b) {
return a.userName.compareTo(b.userName);
}
});
for(i=0;i<users.size();i++) {
System.out.print("\n"+users.get(i).userName +" "+ users.get(i).callNum +" "+ users.get(i).paidMoney);
}
}

static class Dish {
String name;
String FlavorType;
int MaxFlavor;
int unit_price;
boolean isT = false;
}

static class Record {
int orderNum;
Dish d;
int FlavorNum;
int portion;
int quota;
boolean isDeleted = false;
boolean isTreat = false;

int getPrice() {
if (portion == 2)
return (int) Math.round(1.5 * d.unit_price) * quota;
else if (portion == 3)
return 2 * d.unit_price * quota;
else
return d.unit_price * quota;
}
}

static class Menu {
ArrayList<Dish> dishs = new ArrayList<Dish>();
int searchDish(String dishName) {
for (int i = 0; i < dishs.size(); i++) {
if (dishName.equals(dishs.get(i).name)) {
return i;
}
}
return -1;
}
}

static class User{
String userName;
String callNum;
long paidMoney;
}
static class Table {
ArrayList<Record> records = new ArrayList<Record>();
int num;
String userName;
String callNum;
LocalDateTime time;
int weekday;
int ChuanNum = 0;
float spicyType = 0;
int JinNum = 0;
float acidType = 0;
int ZheNum = 0;
float sweetType = 0;
long sum = 0;
long origSum = 0;

void getWeekDay() {
weekday = time.getDayOfWeek().getValue();
}
void getFlavorNum() {
for(int i=0;i<records.size();i++) {
if(records.get(i).d.isT&&!records.get(i).isDeleted&&!records.get(i).isTreat) {
if(records.get(i).d.FlavorType.equals("spicy")) {
ChuanNum+=records.get(i).quota;
spicyType +=records.get(i).FlavorNum*records.get(i).quota;
}
if(records.get(i).d.FlavorType.equals("acidity")) {
JinNum+=records.get(i).quota;
acidType +=records.get(i).FlavorNum*records.get(i).quota;
}
if(records.get(i).d.FlavorType.equals("sweetness")) {
ZheNum+=records.get(i).quota;
sweetType +=records.get(i).FlavorNum*records.get(i).quota;
}
}
}
if(ChuanNum!=0)spicyType = Math.round(spicyType/ChuanNum*1.0);
if(JinNum!=0)acidType = Math.round(acidType/JinNum*1.0);
if(ZheNum!=0)sweetType = Math.round(sweetType/ZheNum*1.0);
}
void showEnd() {
System.out.print("table " + num + ": " + origSum + " " + sum);
//输出川菜
if(ChuanNum!=0) {
System.out.print(" 川菜 "+ChuanNum);
switch((int)spicyType) {
case 0 :System.out.print(" 不辣");break;
case 1 :System.out.print(" 微辣");break;
case 2 :System.out.print(" 稍辣");break;
case 3 :System.out.print(" 辣");break;
case 4 :System.out.print(" 很辣");break;
case 5 :System.out.print(" 爆辣");break;
}
}
//输出晋菜
if(JinNum!=0) {
System.out.print(" 晋菜 "+JinNum);
switch((int)acidType) {
case 0 :System.out.print(" 不酸");break;
case 1 :System.out.print(" 微酸");break;
case 2 :System.out.print(" 稍酸");break;
case 3 :System.out.print(" 酸");break;
case 4 :System.out.print(" 很酸");break;
}
}
//输出浙菜
if(ZheNum!=0) {
System.out.print(" 浙菜 "+ZheNum);
switch((int)sweetType) {
case 0 :System.out.print(" 不甜");break;
case 1 :System.out.print(" 微甜");break;
case 2 :System.out.print(" 稍甜");break;
case 3 :System.out.print(" 甜");break;
}
}

}
void getSum() {
for (int i = 0; i < records.size(); i++) {
if (!records.get(i).isDeleted) {
origSum += records.get(i).getPrice();
if (records.get(i).d.isT) {
if (weekday > 0 && weekday < 6) {
sum += Math.round(records.get(i).getPrice() * 0.7);
} else {
sum += records.get(i).getPrice();
}
} else {
if (weekday > 0 && weekday < 6) {
if (time.getHour() >= 17 && time.getHour() < 20)
sum += Math.round(records.get(i).getPrice() * 0.8);
if (time.getHour() == 20) {
if (time.getMinute() <= 30)
sum += Math.round(records.get(i).getPrice() * 0.8);
}
if (time.getHour() >= 10 && time.getHour() < 14)
sum += Math.round(records.get(i).getPrice() * 0.6);
if (time.getHour() == 14) {
if (time.getMinute() <= 30)
sum += Math.round(records.get(i).getPrice() * 0.6);
}
} else
sum += records.get(i).getPrice();
}
}
}

}

boolean isOpen() {
if (weekday > 0 && weekday < 6) {
if (time.getHour() >= 17 && time.getHour() < 20)
return true;
if (time.getHour() == 20) {
if (time.getMinute() <= 30)
return true;
}
if (time.getHour() > 10 && time.getHour() < 14)
return true;
if (time.getHour() == 10) {
if (time.getMinute() >= 30)
return true;
}
if (time.getHour() == 14) {
if (time.getMinute() <= 30)
return true;
}
} else {
if (time.getHour() > 9 && time.getHour() < 21)
return true;
if (time.getHour() == 9) {
if (time.getMinute() >= 30)
return true;
}
if (time.getHour() == 21) {
if (time.getMinute() <= 30)
return true;
}
}
return false;

}
}
}

这段代码是一个Java程序，它包含了一个名为Main的公共类。在这个类中，定义了两个静态方法：isNumeric和main。

isNumeric方法接受一个字符串作为参数，并尝试将其转换为整数。如果转换成功，则返回true，否则返回false。

main方法是程序的入口点。它首先创建了一个名为menu的Menu对象，以及两个ArrayList：一个用于存储Table对象，另一个用于存储User对象。然后，它创建了一个Scanner对象来读取用户输入。

接下来，程序进入了一个无限循环，用于读取菜单信息。在循环中，首先创建了一个Dish对象，并初始化了一个名为isRepeat的变量。然后，读取一行输入并将其存储在变量str1中。

如果输入的字符串匹配正则表达式"[\S]* [1-9][\d]*"，则将其分割为两个字符串，并将第一个字符串赋值给Dish对象的name属性，将第二个字符串转换为整数并赋值给Dish对象的unit_price属性。然后，将Dish对象的isT属性设置为false，并调用menu对象的searchDish方法来搜索菜单中是否已经存在具有相同名称的菜品。如果存在，则从菜单中删除该菜品，并将新创建的Dish对象添加到菜单中。

如果输入的字符串匹配正则表达式"[\S]* [\S]* [\d]* T"，则将其分割为四个字符串，并将第一个字符串赋值给Dish对象的name属性，将第三个字符串转换为整数并赋值给Dish对象的unit_price属性。然后，根据第二个字符串的值设置Dish对象的FlavorType和MaxFlavor属性。最后，将Dish对象的isT属性设置为true，并调用menu对象的searchDish方法来搜索菜单中是否已经存在具有相同名称的菜品。如果存在，则从菜单中删除该菜品，并将新创建的Dish对象添加到菜单中。

如果输入的字符串等于"end"，则跳出循环。

如果输入的字符串匹配正则表达式"tab.*"，则跳出循环。

否则，读取下一行输入并输出"wrong format"。

在退出循环后，程序进入了另一个循环，用于处理桌子信息。在循环中，首先创建了一个Table对象，并初始化了两个变量：isRepeat和repeatNum。

如果输入的字符串匹配正则表达式".t.a."且匹配正则表达式"table [1-9][\d] : [\S]* [\d]* [\d]*/[\d][\d]?/[\d][\d]? [\d][\d]?/[\d][\d]?/[\d][\d]?“，则将其分割为八个字符串，并将第四个字符串赋值给Table对象的userName属性。然后检查userName属性是否超过10个字符。如果超过，则读取下一行输入并输出"wrong format”。

（2）PTA-5

源码：

import java.text.ParseException;
import java.time.DateTimeException;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.ArrayList;

import java.util.Calendar;
import java.util.Scanner;
class Dish {
String name;
int unit_price;
boolean isT = false;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getUnit_price() {
return unit_price;
}

public void setUnit_price(int unit_price) {
this.unit_price = unit_price;
}

public boolean isT() {
return isT;
}

public void setT(boolean t) {
isT = t;
}
}
class Record {
int orderNum;
Dish d;
int portion;
int quota;
boolean isDeleted = false;

public int getOrderNum() {
return orderNum;
}

public void setOrderNum(int orderNum) {
this.orderNum = orderNum;
}

public Dish getD() {
return d;
}

public void setD(Dish d) {
this.d = d;
}

public int getPortion() {
return portion;
}

public void setPortion(int portion) {
this.portion = portion;
}

public int getQuota() {
return quota;
}

public void setQuota(int quota) {
this.quota = quota;
}

public boolean isDeleted() {
return isDeleted;
}

public void setDeleted(boolean deleted) {
isDeleted = deleted;
}

int getPrice() {
if (portion == 2)
return (int) Math.round(1.5 * d.getUnit_price()) * quota;
else if (portion == 3)
return 2 * d.getUnit_price() * quota;
else
return d.getUnit_price() * quota;
}
}

class Menu {
public ArrayList<Dish> getDishs() {
return dishs;
}

public void setDishs(ArrayList<Dish> dishs) {
this.dishs = dishs;
}

ArrayList<Dish> dishs = new ArrayList<Dish>();

Dish searchDish(String dishName) {
for (Dish d:dishs){
if (dishName.equals(d.name)) {
return d;
}
}

return null;
}

Dish addDish(String dishName, int unit_price) {
Dish newDish = new Dish();
newDish.setName(dishName);
newDish.setUnit_price(unit_price);
return newDish;
}
}

class Order {
public ArrayList<Record> getRecords() {
return records;
}

public void setRecords(ArrayList<Record> records) {
this.records = records;
}

// Record[] records = new Record[20];
ArrayList<Record> records = new ArrayList<Record>();

Record addARecord(int orderNum, String dishName, int portion, int quota, Menu menu) {
Record newRecord = new Record();
newRecord.orderNum = orderNum;
newRecord.d = menu.searchDish(dishName);
newRecord.portion = portion;
newRecord.quota = quota;
System.out.println(newRecord.orderNum + " " + newRecord.d.name + " " + newRecord.getPrice());
return newRecord;
}

int searchRecord(String name) {
int i=0;
for (Record r:records) {
if (r.getD().getName().equals(name) ) {
return i;
}
i++;
}
return -1;
}

void delARecordByOrderNum(int orderNum) {
int i = 0, flag = 0;
for (Record r:records){
if (r.getOrderNum() == orderNum) {
if (!r.isDeleted()) {
r.setDeleted(!r.isDeleted());
} else {
System.out.println("deduplication " + orderNum);
}
flag++;
}
}

if (flag == 0) {
System.out.println("delete error;");
}
}
}

class Table {
Order order = new Order();
int num;
LocalDateTime time;
int weekday;
long sum = 0;
long origSum = 0;

public long getSum() {
return sum;
}

public Order getOrder() {
return order;
}

public void setOrder(Order order) {
this.order = order;
}

public int getNum() {
return num;
}

public void setNum(int num) {
this.num = num;
}

public LocalDateTime getTime() {
return time;
}

public void setTime(LocalDateTime time) {
this.time = time;
}

public int getWeekDay() {
return weekday;
}

public void setWeekday(int weekday) {
this.weekday = weekday;
}

public void setSum(long sum) {
this.sum = sum;
}

public long getOrigSum() {
return origSum;
}

public void setOrigSum(long origSum) {
this.origSum = origSum;
}

void od(Menu menu, String str1, String str2, int portion, int quota) {
{
order.getRecords().add(order.addARecord(Integer.parseInt(str1), str2, portion, quota, menu));

}
}

void getWeekDay2() {
weekday = time.getDayOfWeek().getValue();
}

void getSum2() {
for (Record r:order.records) {
if (!r.isDeleted()) {
origSum += r.getPrice();
if (r.getD().isT()) {
if (weekday > 0 && weekday < 6) {
sum += Math.round(r.getPrice() * 0.7);
} else {
sum += r.getPrice();
}
} else {
if (weekday > 0 && weekday < 6) {
if (time.getHour() >= 17 && time.getHour() < 20)
sum += Math.round(r.getPrice() * 0.8);
if (time.getHour() == 20) {
if (time.getMinute() <= 30)
sum += Math.round(r.getPrice() * 0.8);
}
if (time.getHour() >= 10 && time.getHour() < 14)
sum += Math.round(r.getPrice() * 0.6);
if (time.getHour() == 14) {
if (time.getMinute() <= 30)
sum += Math.round(r.getPrice() * 0.6);
}
} else
sum += r.getPrice();
}
}
}

}

private Calendar getTimeCalendar(String time) {
String[] arr = time.split("/");
Calendar cal = Calendar.getInstance();
cal.set(Calendar.HOUR_OF_DAY, Integer.parseInt(arr[0]));
cal.set(Calendar.MINUTE, Integer.parseInt(arr[1]));
cal.set(Calendar.SECOND, Integer.parseInt(arr[2]));
return cal;
}

public int getSale() {

String dayTime = null;
String timeStr= String.valueOf(time);
String[] dayArray = timeStr.split("/");
Calendar calendar = Calendar.getInstance();

calendar.set(Calendar.DAY_OF_MONTH, 32);

calendar.set(Integer.parseInt(dayArray[0]), Integer.parseInt(dayArray[1])-1, Integer.parseInt(dayArray[2]));

Calendar now = getTimeCalendar(dayTime);

int weekDay = calendar.get(Calendar.DAY_OF_WEEK) - 1;
//周末全價且在營業時間内
if (weekDay == 0 || weekDay == 6) {
if (!now.before(getTimeCalendar("9/30/0")) && !now.after(getTimeCalendar("21/00/00"))) {
return 10;
}
} else {
if (!now.before(getTimeCalendar("17/00/00")) && !now.after(getTimeCalendar("20/30/00"))) {
return 8;
}
if (!now.before(getTimeCalendar("10/30/00")) && !now.after(getTimeCalendar("14/30/00"))) {
return 6;
}
}
// 表示不营业
return 0;
}

else {

if (time.getHour() > 9 && time.getHour() < 21)
return true;
if (time.getHour() == 9) {
if (time.getMinute() >= 30)
return true;
}
if (time.getHour() == 21) {
if (time.getMinute() <= 30)
return true;
}
}
return false;

}
}
public class Main {

public static void main(String[] args) throws ParseException {
Menu menu = new Menu();
ArrayList<Table> tables = new ArrayList<Table>();
Scanner scanner = new Scanner(System.in);
String str1;
int i = 0;
int portion = 0, quota = 0;
while (true) {// 输入菜单
Dish tempDish = new Dish();
Dish isRepeat = null;
str1 = scanner.nextLine();

if (str1.matches("[\\S]* [1-9][\\d]*")) {
String[] token = str1.split(" ");
tempDish.setName(token[0]);
tempDish.setUnit_price(Integer.parseInt(token[1]));
if (tempDish.getUnit_price() > 300) {
System.out.println(tempDish.getName() + " price out of range " + tempDish.getUnit_price());
continue;
}
tempDish.setT(false);
isRepeat = menu.searchDish(tempDish.getName());
if (isRepeat != null) {
menu.dishs.remove(isRepeat);
}
menu.getDishs().add(tempDish);
} else if (str1.matches("[\\S]* [\\d]* T")) {
String[] token = str1.split(" ");
tempDish.setName(token[0]);
tempDish.setUnit_price(Integer.parseInt(token[1]));
if (tempDish.getUnit_price() > 300) {
System.out.println(tempDish.getName() + " price out of range " + tempDish.getUnit_price());
continue;
}
tempDish.setT(true);
if (isRepeat != null) {
menu.dishs.remove(isRepeat);
}
menu.dishs.add(tempDish);
} else if (str1.equals("end")) {
break;
} else if (str1.matches("tab.*")) {
break;
} else {
System.out.println("wrong format");
continue;
}
}
while (!str1.equals("end")) {
Table tempTable = new Table();
boolean isRepeat = false;
int repeatNum = 0;
if(str1.matches("table.*")) {
if (str1.matches("table [1-9][\\d]* [\\d]*/[\\d][\\d]?/[\\d][\\d]? [\\d][\\d]?/[\\d][\\d]?/[\\d][\\d]?")) {
String[] token = str1.split(" ");
String[] Date = token[2].split("/");
String[] Time = token[3].split("/");
int[] intDate = new int[3];
int[] intTime = new int[3];
for (i = 0; i < 3; i++) {
intDate[i] = Integer.parseInt(Date[i]);
intTime[i] = Integer.parseInt(Time[i]);
}
tempTable.setNum(Integer.parseInt(token[1]));
if (tempTable.num > 55) {
System.out.println(tempTable.num + " table num out of range");
str1 = scanner.nextLine();
continue;

}

try {
tempTable.setTime(LocalDateTime.of(intDate[0], intDate[1], intDate[2], intTime[0], intTime[1], intTime[2]));
tempTable.getWeekDay2();
} catch (DateTimeException e) {
System.out.println(tempTable.num + " date error");
str1 = scanner.nextLine();
continue;
}

if (!tempTable.isOpen()) {
System.out.println("table " + tempTable.getNum() + " out of opening hours");
str1 = scanner.nextLine();
continue;
}
if (!(tempTable.time.isAfter(LocalDateTime.of(2022, 1, 1, 0, 0, 0))
&& tempTable.time.isBefore(LocalDateTime.of(2024, 1, 1, 0, 0, 0)))) {
System.out.println("not a valid time period");
str1 = scanner.nextLine();
continue;
}
// 判断桌号是否重复
if (tempTable.isOpen()) {

for (Table t:tables) {
// 有重复的桌号
if (tempTable.getNum() == t.getNum() && t.isOpen()) {
Duration duration = Duration.between(tempTable.getTime(), t.getTime());
// 同一天
if (duration.toDays() == 0) {
// 在周一到周五
if (tempTable.getWeekDay() > 0 && tempTable.getWeekDay() < 6) {
// 在同一时间段
if (tempTable.getTime().getHour() < 15 && t.getTime().getHour() < 15) {
isRepeat = true;
repeatNum = i;
break;
}
}
// 在周末
else {
// 时间相差小于一小时
if (duration.toHours() < 3600) {
repeatNum = i;
isRepeat = true;
break;
}
}
}
}
}
}
System.out.println("table " + tempTable.getNum() + ": ");

} else {
System.out.println("wrong format");
str1 = scanner.nextLine();
continue;
}
// 本桌开始点菜
while (true) {
str1 = scanner.nextLine();
if (str1.matches("[1-9][\\d]* [\\S]* [\\d] [1-9][\\d]*")) {
String[] token = str1.split(" ");
portion = Integer.parseInt(token[2]);
quota = Integer.parseInt(token[3]);
if (tempTable.getOrder().getRecords().size() > 0) {
if (Integer
.parseInt(token[0]) <= tempTable.getOrder().getRecords().get(tempTable.getOrder().getRecords().size() - 1).getOrderNum()) {
System.out.println("record serial number sequence error");
continue;
}
}
if (menu.searchDish(token[1]) == null) {
System.out.println(token[1] + " does not exist");
continue;
}
if (portion > 3 || portion < 1) {
System.out.println(Integer.parseInt(token[0]) + " portion out of range " + portion);
continue;
}
if (quota > 15) {
System.out.println(Integer.parseInt(token[0]) + " num out of range " + quota);
continue;
}
tempTable.od(menu, token[0], token[1], portion, quota);
}
// 判断是否为删除订单
else if (str1.matches("[1-9][\\d]* delete")) {
String[] token = str1.split(" ");
tempTable.order.delARecordByOrderNum(Integer.parseInt(token[0]));
}
// 判断是否为夹杂菜单
else if (str1.matches("[\\S]* [\\d]*")) {
System.out.println("invalid dish");
continue;
} else if (str1.matches("[\\S]* [\\d]* T")) {
System.out.println("invalid dish");
continue;
}
// 判断是否为代点
else if (str1.matches("[\\d]* [\\d]* [\\S]* [\\d] [1-9][\\d]*")) {
String[] token = str1.split(" ");
// 判断代点桌号是否存在
boolean exist = false;
for (Table t:tables) {
if (t.getNum() == Integer.parseInt(token[0])) {
exist = true;
break;
}
}
if (exist) {
System.out.print(Integer.parseInt(token[1]) + " table " + tempTable.num + " pay for table "+ Integer.parseInt(token[0]) + " ");
Record treat = new Record();
treat.setD( menu.searchDish(token[2]));
portion = Integer.parseInt(token[3]);
quota = Integer.parseInt(token[4]);
treat.setPortion(portion);
treat.setQuota(quota);
System.out.print(treat.getPrice() + "\n");
tempTable.setOrigSum(tempTable.getOrigSum()+treat.getPrice());
}
// 若不存在则输出内容
else {
System.out.println("Table number ：" + Integer.parseInt(token[0]) + " does not exist");
}

} else if (str1.equals("end")) {
break;
} else if (str1.matches("table.*")) {
break;
} else {
System.out.println("wrong format");
continue;
}
}
// 本桌点菜结束，进入下一桌
if (isRepeat) {
for (i = 0; i < tables.get(repeatNum).getOrder().getRecords().size(); i++) {
for (int j = 0; j < tempTable.getOrder().getRecords().size(); j++) {
if (tables.get(repeatNum).getOrder().getRecords().get(i).d.name == tempTable.getOrder().getRecords().get(j).d.getName()) {
if (tables.get(repeatNum).getOrder().getRecords().get(i).portion == tempTable.getOrder().getRecords()
.get(j).portion) {
tables.get(repeatNum).getOrder().getRecords().get(i).quota += tempTable.getOrder().getRecords().get(j).getQuota();
tempTable.getOrder().getRecords().remove(j);
}
}
}

}
tables.get(repeatNum).getOrder().getRecords().addAll(tempTable.getOrder().getRecords());
continue;
}
tables.add(tempTable);
}
else {
str1 = scanner.nextLine();
}
}

for (Table t:tables){
if (t.isOpen()){
t.getSum2();
System.out.println("table " + t.getNum() + ": " + t.getOrigSum() + " " + t.getSum());
}
}

// 最终输出桌号订单信息

}

这段代码定义了四个类：Dish，Record，Menu和Order。

Dish类表示菜品，包含名称、单价和一个布尔值isT。它有一些getter和setter方法来获取和设置这些属性。

Record类表示订单记录，包含订单号、菜品、份数、数量、是否删除等信息。它也有一些getter和setter方法来获取和设置这些属性。此外，它还有一个getPrice方法，用于根据份数和数量计算订单的价格。

Menu类表示菜单，包含一个Dish类型的ArrayList。它有一个getDishs方法来获取菜单中的所有菜品，以及一个setDishs方法来设置菜单中的所有菜品。此外，它还有一个searchDish方法，用于根据菜品名称查找菜品；以及一个addDish方法，用于添加新的菜品。

Order类表示订单，包含一个Record类型的ArrayList。它有一个getRecords方法来获取订单中的所有记录，以及一个setRecords方法来设置订单中的所有记录。此外，它还有一个addARecord方法，用于添加新的订单记录；一个searchRecord方法，用于根据菜品名称查找订单记录；以及一个delARecordByOrderNum方法，用于根据订单号删除订单记录。

（3）期中考试

1）测验1-圆类设计

这道题目要求创建一个圆形类（Circle），其中包含一个私有属性为圆的半径。然后，从控制台输入圆的半径，计算并输出圆的面积。

首先，在定义的圆形类中，我们将半径作为私有属性来存储。这样可以确保只能通过类的方法来访问和修改半径的值。

然后，我们需要在圆形类中定义一个公有方法（例如getArea()），用于计算圆的面积。面积的计算公式是π * r^2，其中π是常量3.14159，r是圆的半径。

接下来，在main方法中，我们使用Scanner类从控制台读取一个双精度浮点数作为圆的半径输入。然后，我们创建一个圆形对象，将输入的半径作为参数传入。

最后，我们调用圆形对象的getArea()方法来计算圆的面积，并使用String.format("%.2f", area)来将面积保留两位小数并输出。

需要注意的是，题目要求输入的半径必须在(0,+∞)范围内。如果输入的数据非法（负数或零），则程序应该输出"Wrong Format"。

以下是源码：

import java.util.Scanner;
import java.util.concurrent.Callable;

public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
double r=in.nextDouble();
if(r<=0){
System.out.println("Wrong Format");
}else {
Circle c=new Circle(r);
c.s();
}
}
}
class Circle{
private double r;

public Circle(double r) {
this.r = r;
}
public Circle(){

}
public void s(){
double s=Math.PI*r*r;
System.out.println(String.format("%.2f",s));
}
}

以下是类图：

------------------------------------
| Main |
------------------------------------
| - main(String[] args): void |
------------------------------------

------------------------------------
| Circle |
------------------------------------
| - r: double |
------------------------------------
| + Circle(double r) |
| + Circle() |
| + s(): void |
------------------------------------

2）测验2-类结构设计

这道题目要求设计一个矩形类，其中矩形的属性由矩形的左上角和右下角坐标点组成。需要编写一个程序，输入两个坐标点的坐标值（x1，y1，x2，y2），计算并输出该矩形的面积。

首先，我们可以定义一个矩形类Rectangle，其中包含两个属性：左上角坐标点(x1，y1)和右下角坐标点(x2，y2)。这两个坐标点的属性可以是实型数。

然后，我们需要在矩形类中定义一个公有方法来计算矩形的面积。面积的计算可以通过计算矩形的宽度和高度，并将宽度乘以高度得到。

在main方法中，我们可以使用Scanner类从控制台读取四个实数作为两个坐标点的坐标值（x1，y1，x2，y2）的输入。

接下来，我们创建一个矩形对象，将输入的坐标值作为参数传入。

最后，我们调用矩形对象的计算面积的方法，并使用String.format("%.2f", area)将面积值保留两位小数并输出。

需要注意的是，题目没有指明矩形的坐标点的位置关系，所以在计算宽度和高度时需要考虑参数的顺序。一种常见的做法是将x1，y1作为左上角坐标点，x2，y2作为右下角坐标点，然后计算宽度为x2-x1，高度为y2-y1。

以下是源码：

import java.util.Scanner;

class Rectangle {
private double x1, y1, x2, y2;

public Rectangle(double x1, double y1, double x2, double y2) {
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
}

public double getArea() {
double width = x2 - x1;
double height = y2 - y1;
return width * height;
}
}

public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
double x1 = scanner.nextDouble();
double y1 = scanner.nextDouble();
double x2 = scanner.nextDouble();
double y2 = scanner.nextDouble();

Rectangle rectangle = new Rectangle(x1, y1, x2, y2);
double area = rectangle.getArea();

System.out.println(String.format("%.2f", area));
}
}

```java
import java.util.Scanner;

class Rectangle {
private double x1, y1, x2, y2;

public Rectangle(double x1, double y1, double x2, double y2) {
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
}

public double getArea() {
double width = x2 - x1;
double height = y2 - y1;
return width * height;
}
}

Rectangle rectangle = new Rectangle(x1, y1, x2, y2);
double area = rectangle.getArea();

System.out.println(String.format("%.2f", area));
}
}
以下是类图：

------------------------------------
| Main |
------------------------------------
| + main(String[] args): void |
------------------------------------

上述代码中，我们定义了一个Rectangle类，其中包含了私有属性x1、y1、x2、y2，分别表示矩形的左上角和右下角坐标点。构造函数用于初始化这些属性。

Rectangle类中还定义了一个公有方法getArea()，用于计算矩形的面积。在该方法中，我们根据两个坐标点的差值计算出矩形的宽度和高度，然后将宽度乘以高度得到面积。

在main方法中，我们使用Scanner类从控制台读取四个实数作为两个坐标点的坐标值。然后，我们创建一个Rectangle对象，将输入的坐标值作为参数传入。接下来，我们调用Rectangle对象的getArea()方法计算矩形的面积，并使用String.format("%.2f", area)将面积值保留两位小数并输出。

3）测验3-继承与多态

4）测验4-抽象类与接口

改进建议

1）测验1-圆类设计

对于给定的代码，我有以下几点改进建议：

1. 命名规范：按照Java的命名规范，类名应该以大写字母开头，方法名和变量名应该以小写字母开头，并使用驼峰命名法。所以，建议将类名"Main"改为"MainApp"，将方法名"c.s()"改为"c.calculateArea()"，将变量名"in"改为"scanner"，将变量名"r"改为"radius"。

2. 异常处理：在输入半径r之前，应该先判断是否还有输入，以避免发生NoSuchElementException异常。可以使用scanner的hasNextDouble()方法进行判断。如果没有下一个double类型的输入，可以输出错误信息并退出程序。

3. 使用try-with-resources：在使用Scanner类时，应该使用try-with-resources语句来自动关闭Scanner对象。这样可以确保资源被正确释放，而不需要手动调用scanner的close()方法。

4. 添加注释：为了提高代码的可读性，建议在关键的地方添加注释，解释代码的功能和意图。

改进后的代码如下：

```java
import java.util.Scanner;

public class MainApp {
public static void main(String[] args) {
try (Scanner scanner = new Scanner(System.in)) {
if (!scanner.hasNextDouble()) {
System.out.println("Wrong Format");
return;
}

double radius = scanner.nextDouble();

if (radius <= 0) {
System.out.println("Wrong Format");
} else {
Circle circle = new Circle(radius);
circle.calculateArea();
}
}
}
}

class Circle {
private double radius;

public Circle(double radius) {
this.radius = radius;
}

public Circle() {

}

public void calculateArea() {
double area = Math.PI * radius * radius;
System.out.println(String.format("%.2f", area));
}
}
```

通过以上改进，代码更加符合Java的命名规范，异常处理更加健壮，同时添加了注释以提高代码的可读性。

2）测验2-类结构设计

对于给定的代码，我有以下几点改进建议：

1. 命名规范：按照Java的命名规范，类名应该以大写字母开头，方法名和变量名应该以小写字母开头，并使用驼峰命名法。所以，建议将类名"Main"改为"MainApp"，将方法名"getArea()"改为"calculateArea()"，将变量名"x1"、"y1"、"x2"、"y2"改为更具有描述性的名称，例如"length1"、"width1"、"length2"、"width2"。

2. 异常处理：在输入x1、y1、x2、y2之前，应该先判断是否还有输入，以避免发生NoSuchElementException异常。可以使用scanner的hasNextDouble()方法进行判断。如果没有下一个double类型的输入，可以输出错误信息并退出程序。

4. 添加注释：为了提高代码的可读性，建议在关键的地方添加注释，解释代码的功能和意图。

改进后的代码如下：

```java
import java.util.Scanner;

class Rectangle {
private double length1, width1, length2, width2;

public Rectangle(double length1, double width1, double length2, double width2) {
this.length1 = length1;
this.width1 = width1;
this.length2 = length2;
this.width2 = width2;
}

public double calculateArea() {
double width = length2 - length1;
double height = width2 - width1;
return width * height;
}
}

public class MainApp {
public static void main(String[] args) {
try (Scanner scanner = new Scanner(System.in)) {
if (!scanner.hasNextDouble()) {
System.out.println("Wrong Format");
return;
}

double length1 = scanner.nextDouble();
double width1 = scanner.nextDouble();
double length2 = scanner.nextDouble();
double width2 = scanner.nextDouble();

Rectangle rectangle = new Rectangle(length1, width1, length2, width2);
double area = rectangle.calculateArea();

System.out.println(String.format("%.2f", area));
}
}
}
```

通过以上改进，代码更加符合Java的命名规范，异常处理更加健壮，同时添加了注释以提高代码的可读性。

总结

首先，这几次题目集的编程练习对我来说是一次很好的锻炼，让我更加熟练地掌握了Java程序设计基础和面向对象程序设计的理念。通过解决这些题目，我对Java语言的使用和面向对象的思维方式有了更深入的理解和掌握。

其次，我认识到这几次题目集的题量相对较少，但难度较大。对于一些天赋较强的同学来说，这是很好的挑战，可以更好地提高他们的能力。但对于像我这样没有太多天赋的人来说，可能会有一些困难。因此，我希望以后的题目集能够在增加题目数量的同时，降低每道题的难度，并在其中添加一些附加题目，以便不同水平的同学都能够有所收获，全面提升大家的能力。

另外，我觉得这几次题目集的题目类型相对较为单一，主要集中在语法和算法方面。我希望以后的题目集能够更加多样化，包括一些综合性的题目，涉及到实际应用场景的编程问题。这样能够更好地帮助我们将所学的知识应用到实际中，提升解决问题的能力。

最后，我认为在题目解析和讲解方面，可以更加详细和深入一些。有时候在解题过程中会遇到一些疑惑或不理解的地方，希望能够有更多的解题思路和示例代码，以便更好地理解和掌握。这样可以帮助我们更好地消化所学的知识，提高编程能力。

总的来说，这几次题目集对我的编程能力提升有很大的帮助，但也希望在以后的题目集中能够考虑到不同同学的实际情况，提供更多样化和综合性的题目，并加强题目解析和讲解的深度和细节。这样才能更好地促进我们的学习和进步。我相信通过不断的练习和学习，我会不断提升自己的编程能力，成为一名优秀的程序员。

posted @ 2023-06-29 16:26 dadadadida 阅读(43) 评论(0) 收藏举报

刷新页面返回顶部

p1t2s3d4

BLOG-2

公告