PTA题目集4、5、6以及期中考试的总结

一、前言

在过去做完的PTA题目集4、5、6以及期中考试,相比前几次的题目集来说难度都相对提高了许多，对于基础相对比较薄弱的我做起来也比较吃力，但是题量比之前都少了很多，后两次题目集都只有菜单计价程序一题，最主要的也还是菜单计价程序这一类题目，代码量很大。这类题目对于类的考察相当之高，类与类之间的调用对我们来说令整体难度加深了许多，对我们的java能力有着很大的考验。

二、设计与分析

第四次题目集

7-1菜单计价程序-3

这一道题相对于菜单几家程序-2增加的部分要求为：

代点菜信息包含：桌号 序号 菜品名称 份额 分数代点菜是当前桌为另外一桌点菜，信息中的桌号是另一桌的桌号，带点菜的价格计算在当前这一桌。程序最后按输入的先后顺序依次输出每一桌的总价（注意：由于有代点菜的功能，总价不一定等于当前桌上的菜的价格之和）。每桌的总价等于那一桌所有菜的价格之和乘以折扣。如存在小数，按四舍五入规则计算，保留整数。折扣的计算方法（注：以下时间段均按闭区间计算）：周一至周五营业时间与折扣：晚上（17：00-20：30）8折，周一至周五中午（10:30--14:30）6折，其余时间不营业。周末全价，营业时间：9:30-21:30如果下单时间不在营业范围内，输出"table " + t.tableNum + " out of opening hours"

分析：菜单计价程序-3相较于2新增加了桌号标以及代点菜等信息，营业时间等。对于前面来说，虽说是延续着之前的模板，但难度也还是增加了不少，不仅对于功能的增加过多，同时需要根据时间来将之前的菜品打折扣，某方面来说要更改先前部分的逻辑，增添新的东西，进而使得闭环更加复杂。

类图：

我的源码：

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.*;
class Main{
public static void main(String[] args) {
int countOfOrder = 0;
Menu menu = new Menu();
Order order = new Order();
operator operator = new operator();
operator.recorddish(menu);
operator.recordorderNum(order);
operator.recordtime(order);
operator.orderdish(order,menu);

operator.output(order);
}

}
class operator {
Scanner in = new Scanner(System.in);
public void output(Order order) {
boolean flag = true;
for (int j = 0; flag; j++) {
float totalCost = 0;
if(order.judgeTime(order) == -1){
System.out.println("table " + order.getTableNum() + " out of opening hours");
}else {
System.out.println("table " + order.getTableNum() + ": ");
for (int i = 0; ; i++) {
if (order.record[i].getOrderNum() != -1) {
if (order.record[i].getIsValue() == 1) {
totalCost = totalCost + order.record[i].getPrice();
}
System.out.println(order.record[i].orderNum + " " + order.record[i].getD().getName() + " " + order.record[i].getPrice());
} else {
totalCost = totalCost * order.judgeTime(order);
if (totalCost - (int) totalCost >= 0.5) {
totalCost = (int) totalCost + 1;
}

System.out.println("table " + order.getTableNum() + ": " + (int) totalCost);
break;
}
}
}
flag = false;
}

}
public void recorddish(Menu menu) {
int price;
String name;
for (int i = 0; ; i++) {
name = in.next();
if (name.equals("table")) {
break;
}
price = in.nextInt();
menu.addDish(name, price);
}
}

public void recordorderNum(Order order) {
order.setTablenum(in.nextInt());
}

public void recordtime(Order order) {
int Year = 0,Month = 0,Day = 0,Hour = 0,Min = 0,Sec = 0;
String[] time = in.nextLine().replace("/"," ").split(" ");
Year = Integer.parseInt(time[1]);
Month = Integer.parseInt(time[2]);
Day = Integer.parseInt(time[3]);
Hour = Integer.parseInt(time[4]);
Min = Integer.parseInt(time[5]);
Sec = Integer.parseInt(time[6]);
order.setYear(Year);
order.setMonth(Month);
order.setDay(Day);
order.setHours(Hour);
order.setMin(Min);
order.setSec(Sec);
}

boolean orderdish(Order order, Menu menu) {
boolean result = true;
for (int i = 0; result; i++) {
int Num = 0;
String Nums = in.next();
if (Nums.equals("end")){
result = false;
break;
}else{
Num = Integer.parseInt(Nums);
}
String dish = in.next();
if(dish.equals("delete")){
order.delARecordByOrderNum(Num);
} else {
order.record[i].isValue = 1;
order.record[i].setOrderNum(Num);
order.record[i].setD(menu.searchDish(dish));
order.record[i].setPortion(in.nextInt());
order.record[i].setOrderQuantity(in.nextInt());
}
}
return result;
}

void deleteRecord(Order order, int recordNum) {
order.delARecordByOrderNum(recordNum);
}

}
class Dish {
Dish(String name, int unit_price) {
this.name = name;
this.unit_price = unit_price;
}

String name;

int unit_price;

int getprice(int portion) {
double cost = 0;
if (portion == 1) {
cost = unit_price;
} else if (portion == 2) {
cost = unit_price * 1.5;
} else if (portion == 3) {
cost = unit_price * 2;
}
int result = 0;
if (cost - (int) cost >= 0.5) {
result = (int) cost + 1;
} else {
result = (int) cost;
}
return result;
}

String getName() {
return name;
}

int getUnit_price() {
return unit_price;
}

}
class Menu {
Dish[] dishs = new Dish[1000];
int dishIndex = 0;

Dish searchDish(String dishName) {
boolean existDish = false;
Dish result = new Dish("0", 0);
for (int i = 0; i < 1000 ; i++) {
if (this.dishs[i].getName().equals(dishName)) {
result = dishs[i];
existDish = true;
break;
}
}
if (existDish == false) {
System.out.println(dishName + "does not exist");
}
return result;
}

void addDish(String dishName, int unit_price) {
dishs[dishIndex] = new Dish(dishName, unit_price);
dishIndex++;
}

}
class Record {
int orderNum;
Dish d;
int orderQuantity;
int isValue = 0;
int portion;
int getPrice() {
return this.orderQuantity * d.getprice(portion);
}
Record(){

}
Record(int orderNum, String name, int orderQuantity, int portion) {
setOrderNum(orderNum);
setPortion(portion);
setOrderQuantity(orderQuantity);
}

int getOrderNum() {
return orderNum;
}

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

int getIsValue() {
return isValue;
}

void setIsValue(int isValue) {
this.isValue = isValue;
}

Dish getD() {
return d;
}

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

int getOrderQuantity() {
return orderQuantity;
}

void setOrderQuantity(int orderQuantity) {
this.orderQuantity = orderQuantity;
}

int getPortion() {
return portion;
}

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

}
class Order {
Record[] record = new Record[100];

int tableNum;

Order(){
for(int i = 0 ;i < 100 ;i++){
this.record[i] = new Record(-1,"1",-1,-1);// 实例化创建内存
}
}
float judgeTime(Order order) {
int week = 3;
float discount = 1;
LocalDate timeStander = LocalDate.of(1898, 12, 19);// 设置参照时间1000年1月1 星期三
LocalDate time = LocalDate.of(order.getYear(), order.getMonth(), order.getDay());
week = ((int) timeStander.until(time, ChronoUnit.DAYS) + week) % 7;// 计算当前星期几
if (week >= 1 && week <= 5) {
if (order.getHours() >= 17 && order.getHours() < 20 && order.getMin() < 60 && order.getMin() >= 0 || order.getHours() == 20 && order.getMin() <= 30 && order.getMin() >= 0) {
discount = 0.8F;
}
else if (order.getHours() > 10 && order.getHours() < 14 && order.getMin() < 60 && order.getMin() >= 0 || order.getHours() == 10 && order.getMin() <= 30 && order.getMin() >= 0 || order.getHours() == 14 && order.getMin() <= 30 && order.getMin() >= 0) {
discount = 0.6F;
}
else {
discount = -1;
}

} else {
if (order.getHours() > 9 && order.getHours() < 21 && order.getMin() < 60 && order.getMin() >= 0 || order.getHours() == 9 && order.getMin() <= 30 && order.getMin() >= 0) {
discount = 1;
}
else {
discount = -1;
}
}
return discount;
}
int getTableNum() {
return tableNum;
}

void setTablenum(int tableNum) {
this.tableNum = tableNum;
}

int year, month, day, hours, min, sec;

int getYear() {
return year;
}

void setYear(int year) {
this.year = year;
}

int getMonth() {
return month;
}

void setMonth(int month) {
this.month = month;
}

int getDay() {
return day;
}

void setDay(int day) {
this.day = day;
}

int getHours() {
return hours;
}

void setHours(int hours) {
this.hours = hours;
}

int getMin() {
return min;
}

void setMin(int min) {
this.min = min;
}

int getSec() {
return sec;
}

void setSec(int sec) {
this.sec = sec;
}

int getTotalPrice() {
int sum = 0;
for (int i = 0; i <= recordindex; i++) {
if(record[i].getIsValue() == 1){
sum = sum + record[i].getPrice();
}
}
return sum;
}

static int recordindex = 0;

Record addARecord(int orderNum, String name, int orderQuantity, int portion, Menu menu) {
this.record[recordindex] = new Record(orderNum, name, orderQuantity, portion);
recordindex++;
return this.record[recordindex - 1];
}

void delARecordByOrderNum(int orderNum) {
int i = 0;
for (i = 0; ; i++) {
if (record[i].orderNum == orderNum) {
record[i].setIsValue(0);
break;
}
}
}

Record findRecordByNum(int orderNum) {
int i = 0;
for (i = 0; ; i++) {
if (orderNum == record[i].orderNum) {
record[i].isValue = 0;
break;
}
}
return record[i];
}

}

总结：这一道题我做的并不是很好，我新建了Table类来处理不同桌可能会出现的不同的问题，使对应其桌号来统计订单，而让Order类的属性，来记录Table类中对应不同桌号的点菜记录，但还是有相当多的测试点出错，对我来说难度还是比较大的，无法顺利完成。

 7-3判断两个日期的先后，计算间隔天数、周数

这一题是这三个题目集相对来说难度适中的题目，考察的范围也不多，做起来也相对轻松点。

从键盘输入两个日期，格式如：2022-06-18。判断两个日期的先后，并输出它们之间间隔的天数、周数（不足一周按0计算）。

分析：了解Scanner类中nextLine()等方法、String类中split()等方法、Integer类中parseInt()等方法的用法，了解LocalDate类中of()、isAfter()、isBefore()、until()等方法的使用规则，了解ChronoUnit类中DAYS、WEEKS、MONTHS等单位的用法。

我的具体思路为：先将数据通过split（）分割，将数据转化为int类型，再调用LocalDate类中合适的方法达到题目要求。

源码：

import java.util.Scanner;
import java.time.*;
import java.time.temporal.ChronoUnit;
public class Main{
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
String Date1 = input.nextLine();
String Date2 = input.nextLine();
String []split1 = Date1.split("-");
String []split2 = Date2.split("-");
LocalDate date1 = LocalDate.of(Integer.parseInt(split1[0]),Integer.parseInt(split1[1]),Integer.parseInt(split1[2]));
LocalDate date2 = LocalDate.of(Integer.parseInt(split2[0]),Integer.parseInt(split2[1]),Integer.parseInt(split2[2]));
if(date1.isAfter(date2)) {
System.out.println("第一个日期比第二个日期更晚");
System.out.println("两个日期间隔" + ChronoUnit.DAYS.between(date2, date1) + "天");
System.out.print("两个日期间隔" + ChronoUnit.WEEKS.between(date2, date1) + "周");
}
else {
System.out.println("第一个日期比第二个日期更早");
System.out.println("两个日期间隔" + ChronoUnit.DAYS.between(date1, date2) + "天");
System.out.print("两个日期间隔" + ChronoUnit.WEEKS.between(date1, date2) + "周");
}
}
}

第五次题目集

7-1 菜单计价程序-4

这次菜单计价题目相较于上次有了很大的完善，虽然还有个别测试点没过，但功能也还算比较齐全，完成度还可以。这次是上次的加强版，加了一些新功能和一堆新的判断，PTA中测试点也是围绕这些新的判断来进行评测得分的。改变最大的的便是信息输入问题得到解决，通过字符串分割后数组中的一些特殊信息来相对准确的对号入座，循环也是借此来输入多条类似信息，保证信息能够准确的输入。

类图：

 我的源码：

import java.text.ParseException;
import java.time.DateTimeException;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.ArrayList;
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) throws ParseException {
Menu menu = new Menu();
ArrayList<Table> tables = new ArrayList<Table>();
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]);
if (temp.unit_price > 300) {
System.out.println(temp.name + " price out of range " + temp.unit_price);
continue;
}
temp.isT = false;
isRepeat = menu.searchDish(temp.name);
if (isRepeat != -1) {
menu.dishs.remove(isRepeat);
}
menu.dishs.add(temp);
} else if (str1.matches("[\\S]* [\\d]* T")) {
String[] token = str1.split(" ");
temp.name = token[0];
temp.unit_price = Integer.parseInt(token[1]);
if (temp.unit_price > 300) {
System.out.println(temp.name + " price out of range " + temp.unit_price);
continue;
}
temp.isT = true;
if (isRepeat != -1) {
menu.dishs.remove(isRepeat);
}
menu.dishs.add(temp);
} else if (str1.equals("end")) {
break;
} else if (str1.matches("tab.*")) {
break;

} else {
System.out.println("wrong format");
continue;
}
}
while (!str1.equals("end")) {
Table temp = 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]);
}
temp.num = Integer.parseInt(token[1]);
if (temp.num > 55) {
System.out.println(temp.num + " table num out of range");
str1 = input.nextLine();
continue;

}
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.time.isAfter(LocalDateTime.of(2022, 1, 1, 0, 0, 0))
&& temp.time.isBefore(LocalDateTime.of(2024, 1, 1, 0, 0, 0)))) {
System.out.println("not a valid time period");
str1 = input.nextLine();
continue;
}
// 判断桌号是否重复
if (temp.isOpen()) {
for (i = 0; i < tables.size(); i++) {
// 有重复的桌号
if (temp.num == tables.get(i).num && tables.get(i).isOpen()) {
Duration duration = Duration.between(temp.time, tables.get(i).time);
// 同一天
if (duration.toDays() == 0) {
// 在周一到周五
if (temp.weekday > 0 && temp.weekday < 6) {
// 在同一时间段
if (temp.time.getHour() < 15 && tables.get(i).time.getHour() < 15) {
temp = tables.get(i);
isRepeat = true;
repeatNum = i;
break;
}
}
// 在周末
else {
// 时间相差小于一小时
if (duration.toHours() < 3600) {
temp = tables.get(i);
repeatNum = i;
isRepeat = true;
break;
}
}
}
}
}
}
if(!isRepeat) {
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 (temp.order.records.size() > 0) {
if (Integer.parseInt(
token[0]) <= temp.order.records.get(temp.order.records.size() - 1).orderNum) {
System.out.println("record serial number sequence error");
continue;
}
}
if (menu.searchDish(token[1]) == -1) {
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;
}
temp.od(menu, token[0], token[1], portion, quota);
}
// 判断是否为删除订单
else if (str1.matches("[1-9][\\d]* delete")) {
String[] token = str1.split(" ");
temp.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 (int 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]));
portion = Integer.parseInt(token[3]);
quota = Integer.parseInt(token[4]);
treat.portion = portion;
treat.quota = quota;
System.out.print(treat.getPrice() + "\n");
temp.sum += 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("ta.*")){
break;

}
else {
System.out.println("wrong format");
continue;
}
}
} else if (str1.matches("t.*")) {
isRepeat = true;
temp = tables.get(tables.size());
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 (temp.order.records.size() > 0) {
if (Integer.parseInt(
token[0]) <= temp.order.records.get(temp.order.records.size() - 1).orderNum) {
System.out.println("record serial number sequence error");
continue;
}
}
if (menu.searchDish(token[1]) == -1) {
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;
}
temp.od(menu, token[0], token[1], portion, quota);
}
// 判断是否为删除订单
else if (str1.matches("[1-9][\\d]* delete")) {
String[] token = str1.split(" ");
temp.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 (int 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]));
portion = Integer.parseInt(token[3]);
quota = Integer.parseInt(token[4]);
treat.portion = portion;
treat.quota = quota;
System.out.print(treat.getPrice() + "\n");
temp.sum += treat.getPrice();
}
// 若不存在则输出内容
else {
System.out.println("Table number ：" + Integer.parseInt(token[0]) + " does not exist");
}

} else if (str1.equals("end")) {
break;
} else {
System.out.println("wrong format");
continue;
}
}
if (tables.size() != 0) {
tables.get(tables.size() - 1).order.records.addAll(temp.order.records);
}
} else {
str1 = input.nextLine();
continue;
}

// 本桌点菜结束，进入下一桌
if (isRepeat) {
tables.remove(repeatNum);
}
temp.getSum();
tables.add(temp);
}
// 最终输出桌号订单信息
for (i = 0; i < tables.size(); i++) {
if (tables.get(i).isOpen()) {
System.out
.println("table " + tables.get(i).num + ": " + tables.get(i).origSum + " " + tables.get(i).sum);
} else
System.out.println("table " + tables.get(i).num + " out of opening hours");
}
}

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

static class Record {
int orderNum;
Dish d;
int portion;
int quota;
boolean isDeleted = 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;
}

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

static class Order {
// 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.dishs.get(menu.searchDish(dishName));
newRecord.portion = portion;
newRecord.quota = quota;
System.out.println(newRecord.orderNum + " " + newRecord.d.name + " " + newRecord.getPrice());
return newRecord;
}

int searchReocrd(String name) {
for (int i = 0; i < records.size(); i++) {
if (records.get(i).d.name == name) {
return i;
}
}
return -1;
}

boolean delARecordByOrderNum(int orderNum) {
int i = 0, flag = 0;
for (i = 0; i < records.size(); i++) {
if (records.get(i).orderNum == orderNum) {
if (records.get(i).isDeleted == false) {
records.get(i).isDeleted = true;
} else {
System.out.println("deduplication " + orderNum);
}
flag++;
}
}
if (flag == 0) {
System.out.println("delete error;");
return false;
}
return true;
}
}

static class Table {
Order order = new Order();
int num;
LocalDateTime time;
int weekday;
long sum = 0;
long origSum = 0;
void od(Menu menu, String str1, String str2, int portion, int quota) {
{
order.records.add(order.addARecord(Integer.parseInt(str1), str2, portion, quota, menu));

}
}

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

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

}
}
}

期中考试：

期中考试的题目集都并不是很难，偏基础，考察了类的结构设计与继承，堕胎还有抽象类和接口等的基本用法

7-1测验1-圆类设计

创建一个圆形类（Circle），私有属性为圆的半径，从控制台输入圆的半径，输出圆的面积

输入格式:

输入圆的半径，取值范围为(0,+∞)，输入数据非法，则程序输出Wrong Format，注意：只考虑从控制台输入数值的情况

输出格式:

输出圆的面积（保留两位小数，可以使用String.format(“%.2f”,输出数值）控制精度）

源代码：

import java.util.*;
class Main{
private double radius ;
//构造方法
public Main(double radius)
{
this.radius=radius;
}
//计算面积
public double getArea(){
return Math.PI*radius*radius;
}
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
System.out.print("");
double radius = input.nextDouble();
if(radius<0){
System.out.print("Wrong Format");
}
else {
Main circle = new Main(radius);
double area = circle.getArea();
System.out.print(""+String.format("%.2f",area));
}
}
}

7-2 测验2-类结构设计

设计一个矩形类，其属性由矩形左上角坐标点（x1，y1）及右下角坐标点（x2，y2）组成，其中，坐标点属性包括该坐标点的X轴及Y轴的坐标值（实型数），求得该矩形的面积。类设计如下图：

输入格式:

分别输入两个坐标点的坐标值x1，y1，x2，y2。

输出格式:

输出该矩形的面积值（保留两位小数）。

源码：

import java.util.Scanner;

public class Main {
private double x1, y1; // 左上角坐标点
private double x2, y2; // 右下角坐标点

// 构造方法
public Main(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 = Math.abs(x2 - x1); // 求矩形宽度
double height = Math.abs(y2 - y1); // 求矩形高度
return width * height; // 面积为宽度乘以高度
}

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();
System.out.print("");
Main rectangle = new Main(x1, y1, x2, y2);
double area = rectangle.getArea();
System.out.println("" + String.format("%.2f", area));
}
}

7-3 测验3-继承与多态

将测验1与测验2的类设计进行合并设计，抽象出Shape父类（抽象类），Circle及Rectangle作为子类，类图如下所示：

输入格式:

输入类型选择（1或2，不考虑无效输入）
对应图形的参数（圆或矩形）

输出格式:

图形的面积（保留两位小数）

源码：

import java.util.Scanner;

abstract class Shape {
public abstract double getArea();
}

class Circle extends Shape {
private double radius;

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

@Override
public double getArea() {
return Math.PI * radius * radius;
}
}

class Rectangle extends Shape {
private Point leftTopPoint;
private Point lowerRightPoint;

public Rectangle(Point leftTopPoint, Point lowerRightPoint) {
this.leftTopPoint = leftTopPoint;
this.lowerRightPoint = lowerRightPoint;
}

@Override
public double getArea() {
double width = Math.abs(lowerRightPoint.getX() - leftTopPoint.getX());
double height = Math.abs(lowerRightPoint.getY() - leftTopPoint.getY());
return width * height;
}
}

class Point {
private double x, y;

public Point(double x, double y) {
this.x = x;
this.y = y;
}

public double getX() {
return x;
}

public double getY() {
return y;
}
}

public class Main {

public static void printArea(Shape shape) {
double area = shape.getArea();
System.out.println("" + String.format("%.2f", area));
}

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
int choice = input.nextInt();

switch (choice) {
case 1: // Circle
double radius = input.nextDouble();
Shape circle = new Circle(radius);
printArea(circle);
break;
case 2: // Rectangle
double x1 = input.nextDouble();
double y1 = input.nextDouble();
double x2 = input.nextDouble();
double y2 = input.nextDouble();

Point leftTopPoint = new Point(x1, y1);
Point lowerRightPoint = new Point(x2, y2);

Shape rectangle = new Rectangle(leftTopPoint, lowerRightPoint);
printArea(rectangle);
break;
}

input.close();
}
}

分析：主要考察抽象类和多态类的理解及应用

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

在测验3的题目基础上，重构类设计，实现列表内图形的排序功能（按照图形的面积进行排序）。
提示：题目中Shape类要实现Comparable接口。

其中，Main类源码如下（可直接拷贝使用）：

public class Main {
    public static void main(String\[\] args) {
        // TODO Auto-generated method stub
        Scanner input = new Scanner(System.in);
        ArrayList<Shape> list = new ArrayList<>();    

        int choice = input.nextInt();

        while(choice != 0) {
            switch(choice) {
            case 1://Circle
                double radiums = input.nextDouble();
                Shape circle = new Circle(radiums);
                list.add(circle);
                break;
            case 2://Rectangle
                double x1 = input.nextDouble();
                double y1 = input.nextDouble();
                double x2 = input.nextDouble();
                double y2 = input.nextDouble();            
                Point leftTopPoint = new Point(x1,y1);
                Point lowerRightPoint = new Point(x2,y2);
                Rectangle rectangle = new Rectangle(leftTopPoint,lowerRightPoint);
                list.add(rectangle);
                break;
            }
            choice = input.nextInt();
        }    

        list.sort(Comparator.naturalOrder());//正向排序

        for(int i = 0; i < list.size(); i++) {
            System.out.print(String.format("%.2f", list.get(i).getArea()) + " ");
        }    
    }    
}

输入格式:

输入图形类型（1:圆形；2：矩形；0：结束输入）

输入图形所需参数

输出格式:

按升序排序输出列表中各图形的面积（保留两位小数），各图形面积之间用空格分隔。

源码：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

abstract class Shape implements Comparable<Shape> {
public abstract double getArea();

@Override
public int compareTo(Shape shape) {
double area1 = this.getArea();
double area2 = shape.getArea();

if (area1 < area2) {
return -1;
} else if (area1 > area2) {
return 1;
} else {
return 0;
}
}
}

class Circle extends Shape {
private double radius;

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

@Override
public double getArea() {
return Math.PI * radius * radius;
}
}

class Rectangle extends Shape {
private Point leftTopPoint;
private Point lowerRightPoint;

public Rectangle(Point leftTopPoint, Point lowerRightPoint) {
this.leftTopPoint = leftTopPoint;
this.lowerRightPoint = lowerRightPoint;
}

@Override
public double getArea() {
double width = Math.abs(lowerRightPoint.getX() - leftTopPoint.getX());
double height = Math.abs(lowerRightPoint.getY() - leftTopPoint.getY());
return width * height;
}
}

class Point {
private double x, y;

public Point(double x, double y) {
this.x = x;
this.y = y;
}

public double getX() {
return x;
}

public double getY() {
return y;
}
}

public class Main {

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
ArrayList<Shape> list = new ArrayList<>();

int choice = input.nextInt();

while (choice != 0) {
switch (choice) {
case 1: // Circle
double radius = input.nextDouble();
Shape circle = new Circle(radius);
list.add(circle);
break;
case 2: // Rectangle
double x1 = input.nextDouble();
double y1 = input.nextDouble();
double x2 = input.nextDouble();
double y2 = input.nextDouble();
Point leftTopPoint = new Point(x1, y1);
Point lowerRightPoint = new Point(x2, y2);
Rectangle rectangle = new Rectangle(leftTopPoint,lowerRightPoint);
list.add(rectangle);
break;
}
choice = input.nextInt();
}

list.sort(Comparator.naturalOrder());

for (Shape shape : list) {
System.out.print(String.format("%.2f", shape.getArea()) + " ");
}
}
}

分析：主要考察对接口类的理解和应用，要写好对应的方法。

期中考试总结分析：期中考试的四道题目整体来说难度不大，考察的内容也相对基础但是对于类的结构设计等要求也比较高，四道题环环相扣联系紧密。

第六次题目集
7-1 菜单计价程序-5

本题在菜单计价程序-3的基础上增加了部分内容，增加的内容用加粗字体标识。

注意不是菜单计价程序-4，本题和菜单计价程序-4同属菜单计价程序-3的两个不同迭代分支。

@Override
public int compareTo(Student o) {
    return this.score - o.score;
}

    return this.name.compareTo(o.name);
}
最开始做题目的时候未能及时想到这两个办法，一味的用简单排序。
四、改进建议
还是课上要认真听课做笔记，闲暇时间要多花时间看看题目代码，多分析下类与类的结构功能啥的，也建议老师在每次作业结束后及时给出正确答案以供参考，或者在课上进行讲解
，以便我们学生的问题困惑可以及时解决

五、总结

总的来说这几次题目集还是相当有难度的，而且量也是相当的多，通过这几次的作业以及期中考试，我学会了接口，多态，类与类结构等等的
概念和应用，对java的理解和使用又熟悉了许多，相信之后的学习也可以更加熟练。