菜单计价1~3
（1）前言：
pta三次的作业是循循渐进的，题量适中，要求跟课程学习Java基础知识，同时掌握面向对象的相关知识，能使用Java完成一些小的系统（菜单计价），由于是后面才写博客，所以感觉对前几次的题集有点模糊，题量都不大。
1.）第一次作业主要是一些小的算法题难度低
2.）第二次作业主要是在点菜1和点菜2其他的题参考价值不大，两道题不算难但是要打好框架，不然点菜3不好写
3.）第三次作业点菜3的相比较前两次明显复杂很多，需要花点时间，难度偏大
这里的话我主要还是分析一下三道点菜，以及第二次的一道算法题，其他的就不多赘述。。。。。。
总体来说这几次作业还是对Java的学习有较大的帮助的，需要认真对待
（2）设计与分析：
一.菜单计价程序1
比较简单，先贴代码
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
Menu menu = new Menu();
Order order = new Order();
String s; //初始菜名
int portion; //初始份数
while(true){
s = input.nextLine();
String[] split = s.split(" "); //分割符操作
String name = split[0];
if(name.equals("end")) {
break;
}
portion = Integer.parseInt(split[1]);
Dish dish = menu.searthDish(name);
if(dish==null){
System.out.println(name+" does not exist");
}
else{
order.addARecord(name,portion);//添加订单
}
}
int sum=0;
sum= order.getTotalPrice();; //计算总和
System.out.println(sum);
}
}
class Menu {
Dish d1=new Dish("西红柿炒蛋",15);
Dish d2=new Dish("清炒土豆丝",12);
Dish d3=new Dish("麻婆豆腐",12);
Dish d4=new Dish("油淋生菜",9);
Dish[] dishs= {d1,d2,d3,d4};
public Dish searthDish(String dishName){
for(int i=0;i<4;i++) {
if (dishs[i].name.equals(dishName)) {
return dishs[i];
}
}
return null;
}//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}
class Dish {
String name;//菜品名称
int price; //单价
public Dish(String name,int price){
this.name = name;
this.price = price;
}
public int getPrice(int portion){
if(portion==1) {
return price;
}
else if(portion==2) {
int Iprice = (int) (price*1.5);
if(price-Iprice>=0.5){
return Iprice+1;
}
else {
return Iprice;
}
}
else if(portion==3) {
return price*2;
}
return 0;
}//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份;
}
class Order {
Record[] records = new Record[100];//保存订单上每一道的记录
public int getTotalPrice() {
int sum = 0;
for(int i=0;i<records.length;i++) {
if(records[i]!=null) {
records[i].getPrice();
sum+=records[i].getPrice();
}
}
return sum;
}
public Record addARecord(String dishName,int portion){
Menu menu = new Menu();
Dish dish = menu.searthDish(dishName);
Record record = new Record(dish,portion);
for(int i=0;i<records.length;i++){
if(records[i]==null){
records[i] = record;
break;
}
}
return record;
}
//添加一条菜品信息到订单中。
}
class Record {
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
public Record(Dish dish,int portion){
this.d=dish;
this.portion=portion;
}
int getPrice(){
int price =d.getPrice(portion);
return price;
}//计价，计算本条记录的价格
}下面是类图
1.）分隔符操作：算是头一次用，其实菜单1可以不用分隔符操作的，但是之后的题目里没有它是不行的，所以为了架构更清晰，菜单1我也加入了分隔符操作，
String [] split = s.split(" ");对于这个操作是定义一个叫split的字符串数组，分割的就是s这个字符串，他将分割得到的几个字符串存进数组里，方便我们对输入的信息判断，
""之间的就是我们要的分割字符，这意味着字符串之间以该字符进行分割，在这里我们需要空格作为分割符，获取订单的信息，分别是菜名和份额。
2.）类型转换操作：portion = Integer.parseInt(split[1]);这里是因为分割得到的一定是字符，但是实际上它表示的是份额，这是个整数，所以需要进行类型转换，这里给出了
Integer.parselnt就是字符类型转整数类型的前缀，相较于c语言，不是很好记，要多用。
3.）逻辑思路：第一次太简单了，没有什么出错点，所以来梳理一遍整个的思路
首先在Dish类里我们定义了菜品的所有属性，包括它的名字，份额，计算价格的方法，接着在Menu里写个Dish的数组，目的是存菜单上的菜品，题目里已经给了，直接存
然后Record类，及菜品记录类，存下用户点的菜品的名字和对应的份额，这个相对于Dish多了一个用户输入的菜品份额，其实就是一个Dish 2.0，然后因为用户点的菜不止一个，
所以我们用Order类保存所有的点菜记录，Order里开一个Record类的数组就行了，然后对应的在输入一条点菜记录的时候我们需要把它存进Record数组里，因此Order里需要一个
方法addARecord来实现这个功能。那最后就是将Order种Record数组的菜品记录的价格进行求和，同样在Order里有一个计算总价的方法getTotalPrice来实现这一功能。
Ps:）第一次菜单计价虽然简单，但是它让我们意识到了面向对象的真正内核：封装。事实上我们可以用c++（不是面向对象）直接完成这道题，但是当一个系统变得复杂，面向过程
的代码不仅难以修改和维护，而且会让事情变得复杂难以琢磨，甚至眼花缭乱（比如菜单3，就很难完成了），所以，面向对象的重要性就体现出来了，我们看似再做一些无用功，
其实是让代码变得结构清晰，各个功能独立且完善，这样在下一次进阶的点菜系统中就可以很轻松的完成修改，所以接受面向对象的思维是很重要的。
二.菜单计价程序2 && dp算法
1.菜单计价程序2
代码如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
Menu menu = new Menu();
Order order = new Order();
Tranform tranform = new Tranform();
String s;
String name;
int price;
int portion;
int id;
int a;
int dishsum;
while(true){
s = input.nextLine();
String[] split = s.split(" "); //分割符操作
if(split[0].equals("end")){
break;
}
a = tranform.getsize(split);
if(a==1){
name = split[0];
price = Integer.parseInt(split[1]);
menu.addDish(name,price);
}
else if(a==2){
id = Integer.parseInt(split[0]);
name = split[1];
portion = Integer.parseInt(split[2]);
dishsum = Integer.parseInt(split[3]);
Dish dish = menu.searthDish(name);
if(dish==null){
System.out.println(name+" does not exist");
}
else{
System.out.println(id+" "+name+" "+dish.getprice(portion,dishsum));//输出单条订单的价格
order.addARecord(id,dish,portion,dishsum);//添加订单
}
}
else if(a==3) {
id = Integer.parseInt(split[0]);
Record record = order.findRecordByNum(id);
if (record == null) {
System.out.println("delete error");
} else {
order.delARecordByOrderNum(id);
}
}
}
int sum=0;
sum= order.getTotalPrice(); //计算总和
System.out.println(sum);
}
}
class Dish {
String name;//菜品名称
int price; //单价
public Dish(String name,int price){
this.name = name;
this.price = price;
}
public int getprice(int portion,int dishsum){
if(portion==1) {
return price*dishsum;
}
else if(portion==2) {
int Iprice = (int) (price*1.5);
if(price-Iprice>=0.5){
return (Iprice+1)*dishsum;
}
else {
return Iprice*dishsum;
}
}
else if(portion==3) {
return price*2*dishsum;
}
return 0;
}//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份;
}
class Menu {
Dish[] dishs = new Dish[100];
public Dish searthDish(String dishName){
for(int i=0;i<dishs.length;i++) {
if(dishs[i]!=null && dishs[i].name.equals(dishName)) {
return dishs[i];
}
}
return null;
}//根据菜名在菜谱中查找菜品信息，返回Dish对象。
public Dish addDish(String dishName,int price){
Dish dish = new Dish(dishName,price);
for(int i=0;i<dishs.length;i++){
if(dishs[i]==null){
dishs[i] = dish;
break;
}
}
return dish;
}
}
class Order {
Record[] records = new Record[100];//保存订单上每一道的记录
public int getTotalPrice() {
int sum = 0;
for(int i=0;i<records.length;i++) {
if(records[i]!=null) {
records[i].getPrice();
sum+=records[i].getPrice();
}
}
return sum;
}
public Record addARecord(int id,Dish dish,int portion,int dishsum){
//Menu menu = new Menu();
//Dish dish = menu.searthDish(dishName);
Record record = new Record(dish,portion,dishsum);
records[id] = record;
return record;
}
//添加一条菜品信息到订单中。
public Record findRecordByNum(int id){
return records[id];
}
public Record delARecordByOrderNum(int id){
records[id]=null;
return null;
}
}
class Record {
int dishsum;
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
public Record(Dish dish, int portion,int dishsum){
this.dishsum = dishsum;
this.d=dish;
this.portion=portion;
}
int getPrice(){
int price = d.getprice(portion,dishsum);
return price;
}//计价，计算本条记录的价格
}
class Tranform {
public int getsize(String[] split) {
String id = split[0];
String[] arr = {"1", "2", "3", "4", "5", "6", "7", "8", "9"};
for (int i = 0; i < 9; i++) {
if (id.substring(0, 1).equals(arr[i])) {
String cd = split[1];
if (cd.equals("delete")) {
return 3;
} else {
return 2;
}
}
}
return 1;
}
}下面是类图：
1.）题目变化：在菜单计价1中，菜谱是已知的，一共四道菜，但是这一次的题，菜谱要从键盘输入，那么有一个问题：什么时候输入的是菜谱，什么时候是点菜记录？
这是我们主要要考虑的问题。其次，用户可以进行删除某条订单的操作，我们要实现这一功能。
2.）输入类型判断：可以看到在菜单计价2的代码中我们新增了Transform的类，这个类是转换的意思，也就是根据不同的输入转化成对应的数字，并根据它进行下一步的操作
这个类的代码实现同样是通过分隔符来实现的，我们已经知道订单是有单号的，而菜谱输入没有，区别在于分割出的第一个字符串是不同的，菜谱的第一个字符串是一个菜名，
也就是汉字，点菜记录的第一个字符串实际上是一个数字，所以我们可以获取字符串的首字符，若首字符的ASCII值是49到57之间就说明是个数字，我们返回2或者3，菜谱的情况返回1
。因为有删除订单的操作，所以我们不知道返回2（订单），还是3（删除），所以要对第二个字符串进行判断，如果第二个字符串是delete那么就返回3，否则返回2。
3.）遇到的问题：起初我是打算将分割到的第一个字符串转化成数字，对数字的范围进行判断，但是汉字不能转换为数字，所以会报错，这点需要注意。
ps：）相比较于菜单1，其实变化不大，只要细心一点就可以，注意一下传参数时的非零返回就好，因为很难找，最好写的时候就注意，还有Transform的创建，这可以大大节省我们
处理输入的数据的代码，也使代码逻辑更加清楚。
2.小明走格子问题
原题如下：
从A点到B点有n个格子，小明现在要从A点到B点，小明吃了些东西，补充了一下体力，他可以一步迈一个格子，也可以一步迈两个格子，也可以一步迈3个格子，也可以一步迈4个格子。
请编写程序计算小明从A点到B点一共有多少种走法。
分析：这就是一道斐波那契数列变式的问题，大多数人都能写出来，我之所以提这道题主要是因为它是一种最基础的dp算法，虽然和面向对象无关，但是算法方面的东西还是想提一下
dp是什么？dp也叫动态规划，动态规划是运筹学的一个分支，是求解决策过程最优化的数学方法。利用各个阶段之间的关系，逐个求解，最终求得全局最优解，需要确认原问题与子问题、
动态规划状态、边界状态、边界值状态、状态转移方程。对于这道题，小明到第n个台阶的走法等于到第(n-1)、(n-2)、(n-3)、(n-4)个台阶的走法之和
所以状态转移方程就是a[i]=a[i-1]+a[i-2]+a[i-3]+a[i-4];
有关dp，比较经典的还有背包问题，下面列出相关的c++实现供参考：
#include <iostream>
#include <algorithm>//为调用max函数
using namespace std;
int n,v1;//n为物品数量，v1为背包大小
int f[1005][1005];//n件物品放到容量为v1的背包里的最优解
int v[1005];//物品体积数组
int w[1005];//物品价值数组
int main()
{
cin>>n>>v1;//输入物品数量，背包大小
for(int i=1;i<=n;i++){
cin>>v[i]>>w[i];
}
for(int i=1;i<=n;i++){//读取物品
for(int j=1;j<=v1;j++){//背包容量逐渐增加
if(j<v[i])//如果背包容量小于物品体积
//则第i件物品无法装进去。
//所以i的最优解与i-1件物品的最优解相同。
f[i][j]=f[i-1][j];
else
/*第i件物品可以装进去，则判断装与不装谁最优
因为对所有物品只有装与不装
1,不装：不装的话与上面相同，f[i][j]=f[i-1][j];
2，装;f[i][j]=f[i-1][j-v[i]]+w[i];
f[i-1][j-v[i]]是在第i件物品之前的最优解，即i-1的最优解 ,
"-v[i]"是因为需要为第i件物品空出空间，"+w[i]"是把第i件物品选中；
*/
f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
}
}
cout<<f[n][v1];
/*对应上边 "int f[1005][1005];//n件物品放到容量为v1的背包里的最优解 ",
f[n][v1]表示为"n件物品放到v1背包最优解"
*/
return 0;
}ps:JAVA实现的代码也差不多，因为不是面向对象的代码，所以就不写出来了，这题的分析算是我对算法的兴趣，仅作参考
三.菜单计价程序3
还是先放代码：
import java.util.Scanner;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
Menu menu = new Menu();
Order order = new Order();
Tranform tranform = new Tranform();
Table table = new Table();
Date date = new Date();
String s;
String name;
int sum;
int price;//单价
int portion;//份额
int id;//序号
int a;
int dishsum;//份数
int tableid = 0; //桌号
int lazy=0;//标记
double zhekou=1.0;//折扣
int help;//带点菜桌号
while(true){
s = input.nextLine();
String[] split = s.split(" "); //分割符操作
if(split[0].equals("end")){
if(lazy>0){
if(zhekou==0){
table.arr[tableid]=-1;
}
else {
sum= order.getTotalPrice();
int sum_=(int)(sum*1.0*zhekou);
if(sum*1.0*zhekou-sum_>=0.5){
sum=sum_+1;
}
else{
sum=sum_;
}
table.arr[tableid] = sum;
}
}
break;
}
a = tranform.getsize(split);
if(a==1){
name = split[0];
price = Integer.parseInt(split[1]);
menu.addDish(name,price);
}
else if(a==4){
lazy++;
if(lazy>1){
sum= order.getTotalPrice(); //计算总和
if(zhekou==0){
table.arr[tableid]=-1;
}
else{
sum= order.getTotalPrice();
int sum_=(int)(sum*1.0*zhekou);
if(sum*1.0*zhekou-sum_>=0.5){
sum=sum_+1;
}
else{
sum=sum_;
}
table.arr[tableid] = sum;
}
order.dete();
}
tableid = Integer.parseInt(split[1]);
zhekou=date.dateToWeek(split[2]);
zhekou= date.dateToday(split[3],zhekou);
System.out.println("table "+tableid+":");
}
else if(a==5){
help= Integer.parseInt(split[0]);
id = Integer.parseInt(split[1]);
name = split[2];
portion = Integer.parseInt(split[3]);
dishsum = Integer.parseInt(split[4]);
Dish dish = menu.searthDish(name);
if(dish==null){
System.out.println(name+" does not exist");
}
else{
System.out.println(id+" table "+tableid+" pay for table "+help+" "+dish.getprice(portion,dishsum));//输出单条订单的价格//这里是带点菜不输出
order.addARecord(id,dish,portion,dishsum);//添加订单
}
}
else if(a==2){
id = Integer.parseInt(split[0]);
name = split[1];
portion = Integer.parseInt(split[2]);
dishsum = Integer.parseInt(split[3]);
Dish dish = menu.searthDish(name);
if(dish==null){
System.out.println(name+" does not exist");
}
else{
System.out.println(id+" "+name+" "+dish.getprice(portion,dishsum));//输出单条订单的价格
order.addARecord(id,dish,portion,dishsum);//添加订单
}
}
else if(a==3) {
id = Integer.parseInt(split[0]);
Record record = order.findRecordByNum(id);
if (record == null) {
System.out.println("delete error");
} else {
order.delARecordByOrderNum(id);
}
}
}
table.shuchu();
}
}
class Date{
public double dateToWeek(String datetime) {
SimpleDateFormat f = new SimpleDateFormat("yyyy/MM/dd");
int[] weekDays = {7,6,5,4,3,2,1};
Calendar cal = Calendar.getInstance(); // 获得一个日历
java.util.Date datet = null;
try {
datet = f.parse(datetime);
cal.setTime(datet);
} catch (ParseException e) {
e.printStackTrace();
}
int w = cal.get(Calendar.DAY_OF_WEEK) - 1; // 指示一个星期中的某天。
if (w < 0)
w = 0;
if(weekDays[w]>5){
return 1.0;
}
return 0.8;
}
public double dateToday(String daytime,double zhekou){
String[] split = daytime.split("/");
int p= Integer.parseInt(split[0]);
int p1= Integer.parseInt(split[1]);
int p2= Integer.parseInt(split[2]);
if(zhekou==1.0){
if(p==9){
if(p1>=30){
return zhekou*1.0;
}
return 0;
}
else if(p==21){
if(p1<=29){
return 1.0*zhekou;
}
else if(p1==30){
if(p2==0){
return 1.0*zhekou;
}
return 0;
}
return 0;
}
else if(p2>=10 && p<=20){
return 1.0*zhekou;
}
return 0;
}
else if(zhekou==0.8){
if(p==20){
if(p1<=29){
return 1.0*zhekou;
}
else if(p1==30){
if(p2==0){
return 1.0*zhekou;
}
return 0;
}
return 0;
}
else if(p>=17 && p<=19){
return 1.0*zhekou;
}
if(p==10){
if(p1>=30){
return zhekou*0.75;
}
return 0;
}
else if(p==14){
if(p1<=29){
return 0.75*zhekou;
}
else if(p1==30){
if(p2==0){
return 0.75*zhekou;
}
return 0;
}
return 0;
}
else if(p2>=9 && p<=13){
return 0.75*zhekou;
}
return 0;
}
return 0;
}
}
class Dish {
String name;//菜品名称
int price; //单价
public Dish(String name,int price){
this.name = name;
this.price = price;
}
public int getprice(int portion,int dishsum){
if(portion==1) {
return price*dishsum;
}
else if(portion==2) {
int Iprice = (int) (price*1.5);
if(price-Iprice>=0.5){
return (Iprice+1)*dishsum;
}
else {
return Iprice*dishsum;
}
}
else if(portion==3) {
return price*2*dishsum;
}
return 0;
}//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份;
}
class Menu {
Dish[] dishs = new Dish[100];
public Dish searthDish(String dishName){
for(int i=0;i<dishs.length;i++) {
if(dishs[i]!=null && dishs[i].name.equals(dishName)) {
return dishs[i];
}
}
return null;
}//根据菜名在菜谱中查找菜品信息，返回Dish对象。
public Dish addDish(String dishName,int price){
Dish dish = new Dish(dishName,price);
for(int i=0;i<dishs.length;i++){
if(dishs[i]==null){
dishs[i] = dish;
break;
}
}
return dish;
}
}
class Order {
Record[] records = new Record[100];//保存订单上每一道的记录
public int getTotalPrice() {
int sum = 0;
for(int i=0;i<records.length;i++) {
if(records[i]!=null) {
records[i].getPrice();
sum+=records[i].getPrice();
}
}
return sum;
}
public Record addARecord(int id, Dish dish, int portion, int dishsum){
//Menu menu = new Menu();
//Dish dish = menu.searthDish(dishName);
Record record = new Record(dish,portion,dishsum);
records[id] = record;
return record;
}
//添加一条菜品信息到订单中。
public Record findRecordByNum(int id){
return records[id];
}
public Record delARecordByOrderNum(int id){
records[id]=null;
return null;
}
public void dete(){
for(int i=0;i<records.length;i++) {
if(records[i]!=null) {
records[i]=null;
}
}
}
}
class Record {
int dishsum;
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
public Record(Dish dish, int portion, int dishsum){
this.dishsum = dishsum;
this.d=dish;
this.portion=portion;
}
int getPrice(){
int price = d.getprice(portion,dishsum);
return price;
}//计价，计算本条记录的价格
}
class Table {
int arr[] = new int[100];
public void shuchu(){
for(int i=0;i<arr.length;i++) {
if(arr[i] ==-1) {
System.out.println("table "+i+" out of opening hours");
}
else if(arr[i]!=0){
System.out.println("table "+i+": "+arr[i]);
}
}
}
}下面是类图：
1.）题目变化：相对前两次的菜单计价程序，这次的题目明显复杂许多，在菜单计价程序2的基础上，添加了桌号，也就是说订单不再是只对一个用户，而是对若干桌的顾客，而且桌号的条件下
还有代点菜的功能，另一方面，添加了时间的概念，也就是说饭店有固定的开放时间和对应的折扣，这里的内容其实是比较复杂的，最后我们也不再是输出单个的总价，而是要按照
点菜的桌号顺序依次输出每一桌的总价。
2.）判断一个日期是星期几的功能暂时我们自己是不会的，但是Java已经给好了相关的时间类及其方法，不必自己研究一个新的写法
3.）理清逻辑：首先桌号的出现使得我们的Transform类需要再加两种判断，一种是桌号信息的输入，另一种是代点菜信息的输入，判断不难，分割的第一个字符串如果是table，就是桌号信息
的输入，如果第一个字符串是数字，并且第二个分割的字符串是table那么就是代点菜信息的输入，接着新建的Table类里需要有一个arr数组，存放这一桌的总价，如果是-1就表示超出了营业时间
，不计算价格，至于日期类就不说了，判断是否是周末以及计算折扣的类。在这些之中处理table信息是最复杂的，我们需要知道哪一部分的订单时这一桌的，因此我在Mian里写了一种特殊的
方法来解决这一问题，比较偏向算法，没有进一步地封装，算是一点需要改进的地方。
（3）采坑心得：
主要还是对菜单计价程序3分析一下：
1.日期判断的类有点小问题，不是很精确，有的时候会出错，下面附一张运行结果的图：
分析：最后一行本来应该输出table 2: 75，但是却显示超出营业时间，所以日期类其实是有点问题的，我暂时还没有去改正，因为时网上参考的代码不好修改，以后会尝试修改好
2.题目要求了要四舍五入，最开始没有注意，导致错误：
分析：解决的思路各有不同，我的想法是先对单价乘份额后用一个整数保存它的整数部分 ，然后比较整数部分和它本身的差值是否小于0.5，若小于则取其整数部分，否则取整数部分加1
3.分析具体时间段的方法太繁杂，且不宜阅读和修改，下面是该方法的代码：
public double dateToday(String daytime,double zhekou){
String[] split = daytime.split("/");
int p= Integer.parseInt(split[0]);
int p1= Integer.parseInt(split[1]);
int p2= Integer.parseInt(split[2]);
if(zhekou==1.0){
if(p==9){
if(p1>=30){
return zhekou*1.0;
}
return 0;
}
else if(p==21){
if(p1<=29){
return 1.0*zhekou;
}
else if(p1==30){
if(p2==0){
return 1.0*zhekou;
}
return 0;
}
return 0;
}
else if(p2>=10 && p<=20){
return 1.0*zhekou;
}
return 0;
}
else if(zhekou==0.8){
if(p==20){
if(p1<=29){
return 1.0*zhekou;
}
else if(p1==30){
if(p2==0){
return 1.0*zhekou;
}
return 0;
}
return 0;
}
else if(p>=17 && p<=19){
return 1.0*zhekou;
}
if(p==10){
if(p1>=30){
return zhekou*0.75;
}
return 0;
}
else if(p==14){
if(p1<=29){
return 0.75*zhekou;
}
else if(p1==30){
if(p2==0){
return 0.75*zhekou;
}
return 0;
}
return 0;
}
else if(p2>=9 && p<=13){
return 0.75*zhekou;
}
return 0;
}
return 0;
}分析：if语句太多太杂，非常绕，我自己写完也要花点时间爱知道自己写的是什么，主要是没有注释，所以应该在这种代码段里添加注释，方便修改和阅读
（4）主要困难以及改进建议：
1.主要困难：
其实总的来说三次题目都不算很难，我觉得最多的还是Java里有许多简洁的操作对实现代码有帮助，需要一边写一边去查阅资料，不能心急，其次就是非零返回的问题，主要出现在将订单记录
和桌号记录存进数组里，以及查找一条菜品是否存在的处理上，最后就是要细心吧，因为测试点很多，要保证一个系统的完善就要非常细致。
2.改进建议：
1.修改日期类，使其更加准确，并加入注释方便阅读和以后的修改。
2.主函数里定义了许多变量用来处理每一桌的信息的分割和储存，这部分代码有改进的较大空间，可以将代码封装性加强。
3.一个完善的系统应该可以加入保护信息或者反馈错误的功能，可以自己尝试实现。
（5）总结：
这三次的题目，使我逐渐地掌握了Java面向对象的基本知识，同时在这段时间的学习中也培养了自己独立思考和查阅知识的能力，这些小的系统也让我知道了面向对象在处理复杂事物上的能力，
因为写项目和写算法是截然不同的，以前我只喜欢算法，说以学习面向对象的时候是有些排斥的，但是写完这三次题目后我已经能够很好地接受面向对象的思想了。
