前三次题目集总结BLOG
前言：
在这个学期第一次接触java语言，到现在看来，在面向对象之前所学的C语言和java只有部分的语法差别，不同的语言肯定有不同的语法规则。而在接触面向对象之后，java的特点才会展现出来;继承，多态以及封装。私以为只要有关面对对象的的编程思维转变过来理解过来，java就不会太难。
第一次题目集：
题目概览：身体质量指数（BMI）测算，长度质量计量单位换算，奇数求和，房产税费计算2022，游戏角色选择，学号识别，巴比伦法求平方根近似值，二进制数值提取，判断三角形类型（部分题目我有在博客写过）
知识点：java语言的大致结构（不涉及面向对象和类），for循环，if语句，switch，这些都是在C语言大致接触过的，写这些题目可以更快适应java的语法。（这里就不多赘述这些简单的，重头戏在菜单）
题量：9，难度：一般般把，有的甚至CSDN上可以查到
第二次题目集：
题目概览：菜单计价程序-1，菜单计价程序-2，jmu-java-日期类的基本的使用，小明走格子
这里先单列一下：小明走格子（因为错了）
7-4 小明走格子
分数 15
全屏浏览题目
切换布局
作者 朱允刚
单位 吉林大学
从A点到B点有n个格子，小明现在要从A点到B点，小明吃了些东西，补充了一下体力，他可以一步迈一个格子，也可以一步迈两个格子，也可以一步迈3个格子，也可以一步迈4个格子。请编写程序计算小明从A点到B点一共有多少种走法。
输入格式:
输入包含多组数据，第一行为一个整数m，m不超过10000，表示输入数据组数。接下来m行，每行为一个整数n（保证对应的输出结果小于231），表示从A点到B点的格子数。
输出格式:
输出为m个整数，表示对于每组数据小明从A点到B点的走法数。
输入样例:
2
5
3
输出样例:
15
4
import java.util.Scanner;
public class Main{
public static void main(String[] args){
//这道题使用动态规划
Scanner input =new Scanner(System.in);
int n= input.nextInt();
int[] a=new int[200]; //m行
long[] b=new long[2000];
b[0]=1;
b[1]=1;
b[2]=2;
b[3]=4;
b[4]=8;
for(int i=1;i<=n;i++)
a[i]=input.nextInt(); //输入m行，每行为一个n整数
for(int j=1;j<=n;j++)
{
if(a[j]>=5)
{
for(int k=5;k<=a[j];k++)
b[k]=2*b[k-1]-b[k-5];
int d = a[j];
System.out.println(b[d]);
}
else{
int d = a[j];
System.out.println(b[d]);
}
}
}
}
因为一开始不知道动态规划，所以时间太长，实际上这道题要使用算法中的动态规划（如果你用的一开始和我一样是递归的话时间会出奇的长。因为采用递归的方法，会深入每一条路径，存在大量的重复计算，时间复杂度是2的N次方。）
但是如果采用动态规划的方法，可以大大减少时间的复杂度，这里附上一篇CSDN的链接帮助大家更好理解动态规划。http://t.csdn.cn/BfP8N
接下来是菜单计价程序，
7-1 菜单计价程序-1
分数 30
作者 蔡轲
单位 南昌航空大学
某饭店提供4种菜，每种菜品的基础价格如下：
西红柿炒蛋 15
清炒土豆丝 12
麻婆豆腐 12
油淋生菜 9
设计点菜计价程序，根据输入的订单，计算并输出总价格。
订单由一条或多条点菜记录组成，每条记录一行，最后以"end"结束
每条点菜记录包含：菜名、份额两个信息。
份额可选项包括：1、2、3，分别代表小、中、大份）
不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。
参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}
菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}
点菜记录类：保存订单上的一道菜品记录
Record {
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}
订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(String dishName,int portion)
//添加一条菜品信息到订单中。
}
输入格式:
每条点菜记录的格式：
菜名+空格（英文）+份额
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
最后一条记录以“end”结束。
输出格式:
订单上所有菜品的总价（整数数值），每份菜
如果订单中包含不能识别的菜名，则在总价之前输出“** does not exist”，**是不能识别的菜名
输入样例:
在这里给出一组输入。例如：
麻婆豆腐 2
西红柿炒蛋 3
end
输出样例:
在这里给出相应的输出。例如：
48
输入样例1:
订单中包含不存在的菜品记录。例如：
麻婆豆腐 2
炒脆肚 2
西红柿炒蛋 3
end
输出样例1:
在这里给出相应的输出。例如：
炒脆肚 does not exist
48
以下我建的类图（感觉画的不太行）
现附上源码：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner output=new Scanner(System.in);
String dish;
String []menu =new String[]{"清炒土豆丝","西红柿炒蛋","油淋生菜","麻婆豆腐"};
int price=0,size1;
for(;;){
int count=0;
dish=output.next();
if(dish.equals("end"))break;
size1=output.nextInt();
if(dish.equals(menu[1])){
count=1;
if(size1==1)price=price+15;
if(size1==2)price=price+23;
if(size1==3)price=price+30;
}
else if(dish.equals(menu[0])){
count=1;
if(size1==1)price=price+12;
if(size1==2)price=price+18;
if(size1==3)price=price+24;
}
else if(dish.equals(menu[3])){
count=1;
if(size1==1)price=price+12;
if(size1==2)price=price+18;
if(size1==3)price=price+24;
}
else if(dish.equals(menu[2])){
count=1;
if(size1==1)price=price+9;
if(size1==2)price=price+14;
if(size1==3)price=price+18;
}
if(count==0)System.out.print(dish+"does"+" "+"not"+" "+"exist");
}
System.out.println(price);
}
}
这里是我提交的源码，因为当时没太了解面向对象的概念,所以直接用了面向过程的写法写了这个，放心到后面我就会开始建类写的。
7-2 菜单计价程序-2
分数 40
作者 蔡轲
单位 南昌航空大学
设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。
菜单由一条或多条菜品记录组成，每条记录一行
每条菜品记录包含：菜名、基础价格 两个信息。
订单分：点菜记录和删除信息。每一类信息都可包含一条或多条记录，每条记录一行。
点菜记录包含：序号、菜名、份额、份数。
份额可选项包括：1、2、3，分别代表小、中、大份。
删除记录格式：序号 delete
标识删除对应序号的那条点菜记录。
不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。
参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份） }
菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu { Dish[] dishs ;//菜品数组，保存所有菜品信息 Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。 Dish addDish(String dishName,int unit_price)//添加一道菜品信息 }
点菜记录类：保存订单上的一道菜品记录
Record { int orderNum;//序号\ Dish d;//菜品\ int portion;//份额（1/2/3代表小/中/大份）\ int getPrice()//计价，计算本条记录的价格\ }
订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(int orderNum,String dishName,int portion,int num)//添加一条菜品信息到订单中。
delARecordByOrderNum(int orderNum)//根据序号删除一条记录
findRecordByNum(int orderNum)//根据序号查找一条记录
}
输入格式:
菜品记录格式：
菜名+英文空格+基础价格
如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。
点菜记录格式：
序号+英文空格+菜名+英文空格+份额+英文空格+份数
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
删除记录格式：序号 +英文空格+delete
最后一条记录以“end”结束。
输出格式:
按顺序输出每条订单记录的处理信息，
每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品*份数，序号是之前输入的订单记录的序号。
如果订单中包含不能识别的菜名，则输出“** does not exist”，**是不能识别的菜名
如果删除记录的序号不存在，则输出“delete error”
最后输出订单上所有菜品的总价（整数数值），
本次题目不考虑其他错误情况，如：菜单订单顺序颠倒、不符合格式的输入、序号重复等。
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Menu menu = new Menu();
Scanner input = new Scanner(System.in);
Order order = new Order(menu);
String nextLine = input.nextLine();
while (!nextLine.equals("end")) {
String[] lineArray = nextLine.split(" ");
if (lineArray.length > 2) {
int orderNum = Integer.parseInt(lineArray[0]);
String dishName = lineArray[1];
int parseInt = Integer.parseInt(lineArray[2]);
int parseInt1 = Integer.parseInt(lineArray[3]);
order.addARecord(orderNum, dishName, parseInt, parseInt1);
} else if ("delete".equals(lineArray[1])) {
order.delARecordByOrderNum(Integer.parseInt(lineArray[0]));
} else {
menu.addDish(lineArray[0], Integer.parseInt(lineArray[1]));
}
nextLine = input.nextLine();
}
System.out.println(order.getTotalPrice());
}
}
class Menu {
private List<Dish> dishs = new ArrayList<>();//菜品数组，保存所有菜品信息
Dish searthDish(String dishName) {
for (Dish dish : dishs) {
if (dish.getDishname().equals(dishName)) {
return dish;
}
}
return null;
}
//添加一道菜品信息
Dish addDish(String dishName, int unit_price) {
for (Dish dish : dishs) {
if (dish.getDishname().equals(dishName)) {
dish.setUnit_price(unit_price);
return dish;
}
}
Dish dish = new Dish(dishName, unit_price);
dishs.add(dish);
return dish;
}
}
class Dish {
String dishname;//菜品名称
int unit_price; //单价
public String getDishname() {
return dishname;
}
public int getUnit_price() {
return unit_price;
}
public void setDishname(String dishname) {
this.dishname = dishname;
}
public void setUnit_price(int unit_price) {
this.unit_price = unit_price;
}
public Dish(String name, int unit_price) {
this.dishname = name;
this.unit_price = unit_price;
}
public Dish() {
}
//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
int getPrice(int portion) {
float botsum[] = {1, 1.5f, 2};
return Math.round((unit_price * botsum[portion - 1]));
}
}
class Record {
private int numOrder;//序号\
private Dish d;//菜品\
private int portion;//份额（1/2/3代表小/中/大份）\
private int num;
private boolean isDelete = false;
public boolean isNotFound() {
return notFound;
}
public void setNotFound(boolean notFound) {
this.notFound = notFound;
}
private boolean notFound = false;
public Record(int orderNum, Dish d, int portion, int num) {
this.numOrder = orderNum;
this.d = d;
this.portion = portion;
this.num = num;
}
public Record(Dish d, int portion) {
this.d = d;
this.portion = portion;
}
//计价，计算本条记录的价格
int getPrice() {
return d.getPrice(portion) * this.num;
}
public void setNumOrder(int numOrder) {
this.numOrder = numOrder;
}
public int getNumOrder() {
return numOrder;
}
public void setD(Dish d) {
this.d = d;
}
public void setPortion(int portion) {
this.portion = portion;
}
public int getPortion() {
return portion;
}
public void setDelete(boolean delete) {
isDelete = delete;
}
public boolean isDelete() {
return isDelete;
}
public void setNum(int num) {
this.num = num;
}
public int getNum() {
return num;
}
}
class Order {
private Menu menu;
private static List<Record> records = new ArrayList<>();//保存订单上每一道的记录
public Order(Menu menu) {
this.menu = menu;
}
//计算订单的总价
int getTotalPrice() {
int sum = 0;
for (Record record : records) {
int price = record.getPrice();
if (!record.isDelete()) {
sum = sum + price;
}
}
return sum;
}
//添加一条菜品信息到订单中。
Record addARecord(int orderNum, String dishName, int portion, int num) {
Dish dish = menu.searthDish(dishName);
if (dish == null) {
System.out.println(dishName + " does not exist");
return null;
}
Record record = new Record(orderNum, dish, portion, num);
records.add(record);
int price = record.getPrice();
System.out.println(record.getNumOrder() + " " + record.getD().getDishname() + " " + price);
return record;
}
public boolean delARecordByOrderNum(int orderNum) {
for (Record record : records) {
if (!record.isNotFound() && !record.isDelete() && record.getNumOrder() == orderNum) {
record.setDelete(true);
return true;
}
}
System.out.println("delete error;");
return false;
}
}
在这个菜单中，很明显的我运用了面向对象的原理，建立了不同的类并且在类里面声明了不同的方法与对象。
相比于菜单一，我觉得菜单二有很多必须讲一讲的东西，以下是菜单里的重点难点：
1.arraylist
比如定义数组的arraylist，这个数组可以用来储存菜品信息，并且能通过一些方法快速完成排序。而这也要比普通的数组储存高效很多(附上代码）
class Menu {
private List<Dish> dishs = new ArrayList<>();//菜品数组，保存所有菜品信息
Dish searthDish(String dishName) {
for (Dish dish : dishs) {
if (dish.getDishname().equals(dishName)) {
return dish;
}
}
return null;
}
//添加一道菜品信息
Dish addDish(String dishName, int unit_price) {
for (Dish dish : dishs) {
if (dish.getDishname().equals(dishName)) {
dish.setUnit_price(unit_price);
return dish;
}
}
Dish dish = new Dish(dishName, unit_price);
dishs.add(dish);
return dish;
}
}
这里附上arraylist的详解网址：http://t.csdn.cn/riUGL
2.boolean 类（布尔类型）
Java 语言中布尔类型的值只包括 true 和 false，没有其他值，不包括 1 和 0，布尔类型的数据在开发中主要使用在逻辑判断方面。
public class BooleanTest1 {
public static void main(String[] args) {
boolean isRain = true;
if(isRain){
System.out.println("外面下雨了，出门要带一把雨伞哦！");
}else{
System.out.println("外面天气晴朗，走起吧！");
}
boolean sex = true;
if(sex){
System.out.println("哥们你好");
}else{
System.out.println("姐们你好");
}
}
}
下面附上详解网址：http://t.csdn.cn/9DdH2
第三次题目集：
题目内容：有重复的数据，去掉重复的数据，单词统计与排序，面向对象编程（封装性），GPS测绘中分度秒转换，判断两个日期的先后，计算间隔天数周数。
在这些题目中：去重复数据中应用了HashSet,建立hashSet中可以高效去重。
示例如下：
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner input=new Scanner(System.in);
int n= input.nextInt();
input.nextLine();
String[] strings=input.nextLine().split(" ");
HashSet<String> set=new HashSet<>();
for (int j = 0; j < n; j++) {
set.add(strings[j]);
}
if (set.size()!=n) System.out.println("YES");
else System.out.println("NO");
}
}
在这道题目中用普通数列，效率太低，就像我第一次写的，还会被测试点卡住。
下面进入第三次菜单
7-1 菜单计价程序-3
分数 30
作者 蔡轲
单位 南昌航空大学
设计点菜计价程序，根据输入的信息，计算并输出总价格。
输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。
菜单由一条或多条菜品记录组成，每条记录一行
每条菜品记录包含：菜名、基础价格 两个信息。
订单分：桌号标识、点菜记录和删除信息、代点菜信息。每一类信息都可包含一条或多条记录，每条记录一行或多行。
桌号标识独占一行，包含两个信息：桌号、时间。
桌号以下的所有记录都是本桌的记录，直至下一个桌号标识。
点菜记录包含：序号、菜名、份额、份数。份额可选项包括：1、2、3，分别代表小、中、大份。
不同份额菜价的计算方法：小份菜的价格=菜品的基础价格。中份菜的价格=菜品的基础价格1.5。小份菜的价格=菜品的基础价格2。如果计算出现小数，按四舍五入的规则进行处理。
删除记录格式：序号 delete
标识删除对应序号的那条点菜记录。
如果序号不对，输出"delete error"
代点菜信息包含：桌号 序号 菜品名称 份额 分数
代点菜是当前桌为另外一桌点菜，信息中的桌号是另一桌的桌号，带点菜的价格计算在当前这一桌。
程序最后按输入的先后顺序依次输出每一桌的总价（注意：由于有代点菜的功能，总价不一定等于当前桌上的菜的价格之和）。
每桌的总价等于那一桌所有菜的价格之和乘以折扣。如存在小数，按四舍五入规则计算，保留整数。
折扣的计算方法（注：以下时间段均按闭区间计算）：
周一至周五营业时间与折扣：晚上（17：00-20：30）8折，周一至周五中午（10:30--14:30）6折，其余时间不营业。
周末全价，营业时间：9:30-21:30
如果下单时间不在营业范围内，输出"table " + t.tableNum + " out of opening hours"
参考以下类的模板进行设计：菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份） }
菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish
dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
Dish addDish(String dishName,int unit_price)//添加一道菜品信息
}
点菜记录类：保存订单上的一道菜品记录
Record {
int orderNum;//序号\\
Dish d;//菜品\\
int portion;//份额（1/2/3代表小/中/大份）\\
int getPrice()//计价，计算本条记录的价格\\
}
订单类：保存用户点的所有菜的信息。
Order {
Record
records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(int orderNum,String dishName,int portion,int num)//添加一条菜品信息到订单中。
delARecordByOrderNum(int orderNum)//根据序号删除一条记录
findRecordByNum(int orderNum)//根据序号查找一条记录
}
### 输入格式:
桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）
菜品记录格式：
菜名+英文空格+基础价格
如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。
点菜记录格式：序号+英文空格+菜名+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
删除记录格式：序号 +英文空格+delete
代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称+英文空格+份额+英文空格+分数
最后一条记录以“end”结束。
### 输出格式:
按输入顺序输出每一桌的订单记录处理信息，包括：
1、桌号，格式：table+英文空格+桌号+”:”
2、按顺序输出当前这一桌每条订单记录的处理信息，
每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品\*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“\*\* does not exist”，\*\*是不能识别的菜名
如果删除记录的序号不存在，则输出“delete error”
最后按输入顺序一次输出每一桌所有菜品的总价（整数数值）格式：table+英文空格+桌号+“:”+英文空格+当前桌的总价
本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求。
输入格式:
桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）
菜品记录格式：
菜名+英文空格+基础价格
如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。
点菜记录格式：序号+英文空格+菜名+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
删除记录格式：序号 +英文空格+delete
代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称+英文空格+份额+英文空格+分数
最后一条记录以“end”结束。
输出格式:
按输入顺序输出每一桌的订单记录处理信息，包括：
1、桌号，格式：table+英文空格+桌号+“:”+英文空格
2、按顺序输出当前这一桌每条订单记录的处理信息，
每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品\*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“\*\* does not exist”，\*\*是不能识别的菜名
如果删除记录的序号不存在，则输出“delete error”
最后按输入顺序一次输出每一桌所有菜品的总价（整数数值）格式：table+英文空格+桌号+“:”+英文空格+当前桌的总价
本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求。
class Dish {
String name;//菜品名称
int unit_price; //单价
//int num;
int getPrice(int portion) {
int peic = 0;
if (portion == 1) {
peic = unit_price ;
} else if (portion == 2) {
peic = Math.round((float) (unit_price * 1.5)) ;
} else if (portion == 3) {
peic = (unit_price * 2) ;
}
return peic;//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}
}
class Menu {
Dish[] dishs = new Dish[10];//菜品数组，保存所有菜品信息
int count = 0;
Dish searthDish(String dishName){
Dish temd = null;
for(int i=count-1;i>=0;i--){
if(dishName.equals(dishs[i].name)){
temd = dishs[i];
break;
}
}
if(temd==null){
System.out.println(dishName+" does not exist");
}
return temd;
}//根据菜名在菜谱中查找菜品信息，返回Dish对象。
Dish addDish(String dishName,int unit_price){
Dish dh = new Dish();
dh.name = dishName;
dh.unit_price = unit_price;
count++;
return dh;
}//添加一道菜品信息
}
class Record {
int orderNum;//序号\
//int AntherOrderNum;
Dish d = new Dish();//菜品\
int num = 0;
int portion;//份额（1/2/3代表小/中/大份）\
//int exist = 1;
int getPrice(){
return d.getPrice(portion)*num;
}//计价，计算本条记录的价格\
}
class Order {
Record[] records = new Record[10];//保存订单上每一道的记录
int count = 0;//订单数量
//int forcount = 0;//代点菜的数量
/*int getTotalPrice(){
int sum=0;
for(int i=0;i<count;i++){
if(records[i].exist==0)
continue;
sum=sum+records[i].getPrice();
}
return sum;
}//计算订单的总价*/
void addARecord(int orderNum,String dishName,int portion,int num){
records[count] = new Record();
records[count].d.name = dishName;
records[count].orderNum = orderNum;
records[count].portion = portion;
records[count].num = num;
count++;
}//添加一条菜品信息到订单中。
/*Record TakeOdfor(int AnotherNUm,int orderNum,String dishName,int portion,int num){
Record rd2 = new Record();
rd2.d.name = dishName;
rd2.orderNum = orderNum;
rd2.portion = portion;
rd2.d.num = num;
rd2.AntherOrderNum = AnotherNUm;
//forcount++;
return rd2;
}*/
int delARecordByOrderNum(int orderNum){
if(orderNum>count||orderNum<=0){
System.out.println("delete error;");
return 0;
}else {
return records[orderNum - 1].getPrice();
}
}//根据序号删除一条记录
}
class Table {
int tableNum;
String tableDtime;
int year,month,day,week,hh,mm,ss;
int sum = 0;//一桌价格 ；
// boolean f = true;
Order odt = new Order();
//Order odre = new Order();
float discnt = -1;
void Gettottalprice(){
if(discnt>0){
sum = Math.round(sum*discnt);
System.out.println("table " + tableNum + ": " + sum);
}else {
System.out.println("table " + tableNum + " out of opening hours");
}
}
void AheadProcess(String tableDtime){
this.tableDtime = tableDtime;
processTime();
discount();
//CheckAtime();
}
void processTime(){//处理时间
String[] temp = tableDtime.split(" ");
tableNum = Integer.parseInt(temp[1]);
String[] temp1 = temp[2].split("/");
String[] temp2 = temp[3].split("/");
year = Integer.parseInt(temp1[0]);
month = Integer.parseInt(temp1[1]);
day = Integer.parseInt(temp1[2]);
Calendar c = Calendar.getInstance();
c.set(year, (month-1), day);
week = c.get(Calendar.DAY_OF_WEEK);
if(week==1)
week = 7;
else
week--;
hh = Integer.parseInt(temp2[0]);
mm = Integer.parseInt(temp2[1]);
ss = Integer.parseInt(temp2[2]);
}
//void CheckAtime(){
// f= !(discnt < 0);
// }
void discount(){
if(week>=1&&week<=5)
{
if(hh>=17&&hh<20)
discnt=0.8F;
else if(hh==20&&mm<30)
discnt=0.8F;
else if(hh==20&&mm==30&&ss==0)
discnt=0.8F;
else if(hh>=11&&hh<=13||hh==10&&mm>=30)
discnt=0.6F;
else if(hh==14&&mm<30)
discnt=0.6F;
else if(hh==14&&mm==30&&ss==0)
discnt=0.6F;
}
else
{
if(hh>=10&&hh<=20)
discnt= 1.0F;
else if(hh==9&&mm>=30)
discnt= 1.0F;
else if(hh==21&&mm<30||hh==21&&mm==30&&ss==0)
discnt= 1.0F;
}
}
}
import java.util.Calendar;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Menu mu = new Menu();
Table[] tablemes = new Table[10];
int j = 0;//菜单数
int l = 0;//订单数
int k = 0;//代点菜数
Dish tt;
//int sum = 0;
int cntTable = 0;//桌号
int count;
String[] temp;
int a1,a2,a3,a4,a5;
while (true) {
String st = sc.nextLine();
temp = st.split(" ");
if(st.equals("end"))
break;
count = temp.length;
if (count == 2) {//一个空格
//String[] temp1 = st.split(" ");
if (temp[1].equals("delete")) {//第二个为delete
a1 = Integer.parseInt(temp[0]);
int c = tablemes[cntTable].odt.delARecordByOrderNum(a1);
tablemes[cntTable].sum-=c;
} else {//菜单添加
a2 = Integer.parseInt(temp[1]);
mu.dishs[j] = mu.addDish(temp[0], a2);
j++;
}
//continue;
}
else if (count == 4) {//三个空格
//String[] temp2 = st.split(" ");
if (temp[0].equals("table")) {//桌号
cntTable++;//跳过0;
l = 0;
tablemes[cntTable] = new Table();
//tablemes[cntTable].tableDtime = st;
tablemes[cntTable].AheadProcess(st);
System.out.println("table " + cntTable + ": ");
} else {//增加订单的情况；
a3 =Integer.parseInt(temp[0]);
a4 = Integer.parseInt(temp[2]);
a5=Integer.parseInt(temp[3]);
tablemes[cntTable].odt.addARecord(a3, temp[1],a4 , a5);
tt = mu.searthDish(temp[1]);
if (tt != null) {
tablemes[cntTable].odt.records[l].d = tt;
int a = tablemes[cntTable].odt.records[l].getPrice();
System.out.println(tablemes[cntTable].odt.records[l].orderNum + " " + tt.name + " " +a );
tablemes[cntTable].sum +=a;
}
l++;
}
//continue;
}
else if (count == 5) {//代点菜
//String[] temp3 = st.split(" ");
a1 = Integer.parseInt(temp[1]);
a2 = Integer.parseInt(temp[3]);
a3 = Integer.parseInt(temp[4]);
tablemes[cntTable].odt.addARecord( a1, temp[2], a2, a3);
tt = mu.searthDish(temp[2]);
if (tt != null) {
tablemes[cntTable].odt.records[l].d.unit_price = tt.unit_price;
int b = tablemes[cntTable].odt.records[l].getPrice();
System.out.println(temp[1] + " table " + tablemes[cntTable].tableNum + " pay for table " + temp[0] + " " + b);
tablemes[cntTable].sum += b;
}
l++;
}
//st = sc.nextLine();
}
for (int i = 1; i < cntTable + 1; i++) {
tablemes[i].Gettottalprice();
}
}
}
以下是我用prosesson写的类图：
菜单三分析：
1.主类过于冗余，判断在输出的信息，应该提取在多个方法中。
2.定义的gettotalprice();注释掉了，使用了一个单独变量作为价格总和。面向过程的代码，复用率低。
3.日期的判断采用的提取字符串。可用Java自带的日期类减少代码量和复杂度。
4.程序时间复杂度高。过测试点过的很极限。
5.桌类的定义没有很好的与前几个类组合一起，方法的定义很长
菜单一，二，三的总结：
在菜单二中，我运用了面向对象的语言去编写程序，通过书写类，对象，类中的方法，我逐步克服菜单中的难点：
1.返回值出错，由其他类返回到其他类的返回值可能因为private的缘故出错
2.书写boolean类，巧妙的运用布尔类型可以返回很多需要判断的问题以及数据
3.类方法的调用，在调用类方法的时候，或者写对象的属性的时候，经常会出错，因为写代码中总是因为自己原因写的不正规
在克服这些困难中，我不断去查代码，学习新知识，查算法，学习arraylist,huahset,hashmap,boolean或者询问别人，通过学习他人的代码，结合自己的理解，将代码不断修改完全，从不会书写类，到学习修改报错，对于idea的使用，比如调试，插件的安装与查找等技能，得到了很好的锻炼。现在可以做到以idea调试独自解决代码出现的问题，很多问题通过百度可以解决。自身解决问题能力大大提升。