首页 > 编程语言 >Java 期中考试及pta4、5总结

Java 期中考试及pta4、5总结

时间：2023-06-30 22:22:55浏览次数：60  
标签：Java 期中考试 double new 空格 pta4 input public 输入

菜单计价1~3

（1）前言：

　　期中考试的题目比较简单但是具有典型意义，ptA的题和之前的大差不差，所以会省略一些

　　总体来说这几次作业还是对Java的学习有较大的帮助的，需要认真对待

（2）设计与分析：

　　一测验1-圆类设计

　　下面是题目要求：

　　7-1 测验1-圆类设计 　　分数 12 　　作者 段喜龙 　　单位 南昌航空大学

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

　　输入格式:

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

　　输出格式:

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

　　输入样例:

　　在这里给出一组输入。例如：

　　2.35

输出样例:

　　在这里给出相应的输出。例如：

　　17.35

　　先贴代码

　　

import java.util.Scanner;

public 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 scanner = new Scanner(System.in);
        double radius = scanner.nextDouble();
        scanner.close();

        if (radius <= 0) {
            System.out.println("Wrong Format");
        } else {
            Main circle = new Main(radius);
            double area = circle.getArea();
            System.out.printf("%.2f", area);
        }
    }
}

　　

这份代码主要实现了一个圆形类（Circle），包含了私有属性radius表示圆的半径。代码通过从控制台输入一个半径值，然后计算并输出对应圆的面积。

代码的主要思路如下：

  1. 导入需要使用的Scanner类，它能够从控制台读取用户输入。
  2. 创建一个名为Circle的类，并在类中定义一个私有属性radius表示圆的半径。
  3. 在Circle类中编写一个构造方法，用于初始化圆的半径。
  4. 在Circle类中编写一个公共方法getArea，用于计算圆的面积。面积的计算公式为π * 半径 * 半径，其中π可以使用Math.PI获取。
  5. 在Circle类的main方法中，先创建一个Scanner对象用于读取用户的输入。
  6. 使用scanner.nextDouble()方法从控制台读取一个double类型的值，即圆的半径。
  7. 关闭Scanner对象，释放资源。
  8. 判断输入的半径是否合法。如果小于等于0，则输出"Wrong Format"。
  9. 如果输入的半径合法，则创建一个Circle对象，并将输入的半径作为参数传递给构造方法。
  10. 使用getArea方法计算圆的面积，并将结果保留两位小数输出，使用System.out.printf("%.2f", area)实现。
  11. 程序结束。

这份代码使用面向对象的思想，将圆形的属性（半径）和行为（计算面积）封装在一个类中，使得代码结构更加清晰和可维护。同时，通过使用Scanner类从控制台读取用户输入，可以方便地获取需要的数值进行计算。

　　

　　二.测验2-类结构设计

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


image.png

　　输入格式:

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

　　输出格式:

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

　　输入样例:

　　在这里给出一组输入。例如：

　　6 5.8 -7 8.9

　　输出样例:

　　在这里给出相应的输出。例如：

　　40.30

　　代码如下：

import java.util.Scanner;

public class Main {
    private double x1;
    private double y1;
    private double x2;
    private double 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();
        scanner.close();

        Main rectangle = new Main(x1, y1, x2, y2);
        double area = rectangle.getArea();
        System.out.printf("%.2f", area);
    }
}

　　

这份代码的思路如下：

  1. 导入必要的类：导入java.util.Scanner类，以便从控制台获取用户的输入。

  2. 定义Main类：创建一个名为Main的类，用于表示矩形对象。

  3. 定义属性：在Main类中定义私有属性x1、y1、x2、y2，分别表示矩形的左上角和右下角的坐标。

  4. 定义构造方法：创建具有四个参数的构造方法，用于初始化矩形对象的坐标属性。

  5. 定义计算面积的方法：在Main类中定义一个公共方法getArea()，用于计算矩形的面积。该方法通过计算矩形的宽度（width）和高度（height），并返回二者相乘的结果，即矩形的面积。

  6. 定义main()方法：在Main类中定义main()方法作为程序的入口点。

  7. 创建Scanner对象：在main()方法中创建一个Scanner对象scanner，用于从控制台读取用户输入。

  8. 获取用户输入：使用scanner.nextDouble()方法分别获取用户输入的四个浮点数，分别表示矩形的两个坐标点的x和y值。

  9. 关闭Scanner对象：在获取用户输入后，使用scanner.close()方法关闭Scanner对象，以释放资源。

  10. 创建Main对象并计算面积：使用获取到的用户输入的坐标值创建一个Main对象rectangle。然后调用rectangle.getArea()方法计算矩形的面积。

  11. 格式化输出矩形的面积：使用System.out.printf()方法将计算得到的矩形面积输出到控制台，并保留两位小数。

以上就是这份代码的主要思路和步骤。它通过获取用户输入的坐标值，创建矩形对象，并计算矩形的面积，最后将面积结果输出到控制台。

 

三.测验3-继承与多态

　　题目如下：　

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


image.png

　　试编程完成如上类图设计，主方法源码如下（可直接拷贝使用）：

    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 radiums = input.nextDouble();
            Shape circle = new Circle(radiums);
            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);
            
            Rectangle rectangle = new Rectangle(leftTopPoint,lowerRightPoint);
            
            printArea(rectangle);
            break;
        }
        
    }
 

　　其中，printArea(Shape shape)方法为定义在Main类中的静态方法，体现程序设计的多态性。

　　输入格式:

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

　　输出格式:

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

　　输入样例1:

　　1
　　5.6

　　输出样例1:

　　在这里给出相应的输出。例如：

　　98.52

　　输入样例2:

　　2
　　5.6
　　-32.5
　　9.4
　　-5.6

　　输出样例2:

　　在这里给出相应的输出。例如：

　　102.22

还是先放代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        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);

                Rectangle rectangle = new Rectangle(leftTopPoint, lowerRightPoint);

                printArea(rectangle);
                break;
        }

        input.close();
    }

    public static void printArea(Shape shape) {
        double area = shape.getArea();
        System.out.printf("%.2f%n", area);
    }
}

interface Shape {
    double getArea();
}

class Circle implements Shape {
    private double radius;

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

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

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

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

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

class Point {
    private double x;
    private double y;

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

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }
}

　　

这份代码的思路如下：

  1. 首先，定义了一个Main类作为程序的入口点。
  2. 在main()方法中，通过创建一个Scanner对象来读取用户输入的选择（1或2）。
  3. 使用switch语句根据选择的值，进入不同的分支。
  4. 若选择为1，表示选择了计算圆的面积。接着读取用户输入的圆的半径，并创建Circle对象。
  5. 若选择为2，表示选择了计算矩形的面积。接着按顺序读取用户输入的矩形的左上角和右下角坐标，并创建Rectangle对象。
  6. 调用printArea()方法并传入相应的图形对象，以打印出图形的面积。
  7. printArea()方法接受一个Shape类型的参数，该参数可以是Circle对象或Rectangle对象，因为它们都实现了Shape接口。通过调用对象的getArea()方法获取面积，并使用System.out.printf()方法格式化输出面积，保留两位小数。
  8. 最后，通过input.close()关闭Scanner对象以释放资源。

整个代码设计遵循了面向对象编程的原则，利用接口、多态和类的继承关系，使得代码结构清晰、易于扩展和维护。通过封装不同的对象和方法，实现了对不同图形面积的计算和输出。

 四.测验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：结束输入）

　　输入图形所需参数

　　输出格式:

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

　　输入样例:

　　在这里给出一组输入。例如：

　　1
　　2.3
　　2
　　3.2
　　3
　　6
　　5
　　1
　　2.3
　　0

　　输出样例:

　　在这里给出相应的输出。例如：

　　5.60 16.62 16.62

　　代码如下：

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

public class Main {
    public static void main(String[] args) {
        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 (int i = 0; i < list.size(); i++) {
            System.out.print(String.format("%.2f", list.get(i).getArea()) + " ");
        }

        input.close();
    }
}

interface Shape extends Comparable<Shape> {
    double getArea();
}

class Circle implements Shape {
    private double radius;

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

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

    public int compareTo(Shape other) {
        return Double.compare(this.getArea(), other.getArea());
    }
}

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

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

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

    public int compareTo(Shape other) {
        return Double.compare(this.getArea(), other.getArea());
    }
}

class Point {
    private double x;
    private double y;

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

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }
}

　　

这份代码的主要思路如下：

  1. 在主类Main中，首先创建一个Scanner对象用于接收用户的输入，并创建一个空的ArrayList<Shape>对象用于存储图形。
  2. 通过用户输入的选项（1代表圆形，2代表矩形，0代表结束输入），在循环中进行不同的处理：
    • 若用户选择1（圆形），则读取用户输入的半径，并创建一个Circle对象，并将其添加到图形列表中。
    • 若用户选择2（矩形），则依次读取用户输入的四个点的坐标，并创建一个Rectangle对象，并将其添加到图形列表中。
    • 用户选择0时，表示输入结束，跳出循环。
  3. 使用list.sort(Comparator.naturalOrder())对图形列表进行排序。由于Shape接口实现了Comparable接口并重写了compareTo方法，所以可以直接使用列表的sort方法进行排序。
  4. 使用循环遍历列表中的每个图形对象，并调用其getArea()方法打印出面积。
  5. 关闭Scanner对象。

整体思路是通过用户输入构建不同类型的图形对象，并将这些对象添加到列表中。然后使用sort方法对列表进行排序，排序依据是图形的面积大小。最后，按顺序遍历列表中的图形对象，并打印出它们的面积。通过这种方式，实现了按照图形面积进行排序的功能。

五.菜单计价程序-5

下面是相关的异常处理：

　　

1、菜单输入时增加特色菜，特色菜的输入格式：菜品名+英文空格+口味类型+英文空格+基础价格+"T"

例如：麻婆豆腐 川菜 9 T

菜价的计算方法：

周一至周五 7折， 周末全价。

特色菜的口味类型：川菜、晋菜、浙菜

川菜增加辣度值：辣度0-5级；对应辣度水平为：不辣、微辣、稍辣、辣、很辣、爆辣；

晋菜增加酸度值，酸度0-4级；对应酸度水平为：不酸、微酸、稍酸、酸、很酸；

浙菜增加甜度值，甜度0-3级；对应酸度水平为：不甜、微甜、稍甜、甜；    

例如：麻婆豆腐 川菜 9 T

输入订单记录时如果是特色菜，添加口味度（辣/酸/甜度）值，格式为：序号+英文空格+菜名+英文空格+口味度值+英文空格+份额+英文空格+份数

例如：1 麻婆豆腐 4 1 9

单条信息在处理时，如果口味度超过正常范围，输出"spicy/acidity/sweetness num out of range : "+口味度值，spicy/acidity/sweetness（辣度/酸度/甜度）根据菜品类型择一输出，例如：

acidity num out of range : 5

输出一桌的信息时，按辣、酸、甜度的顺序依次输出本桌菜各种口味的口味度水平，如果没有某个类型的菜，对应的口味（辣/酸/甜）度不输出，只输出已点的菜的口味度。口味度水平由口味度平均值确定，口味度平均值只综合对应口味菜系的菜计算，不做所有菜的平均。比如，某桌菜点了3份川菜，辣度分别是1、3、5；还有4份晋菜，酸度分别是，1、1、2、2，辣度平均值为3、酸度平均值四舍五入为2，甜度没有，不输出。

一桌信息的输出格式：table+英文空格+桌号+:+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价+英文空格+"川菜"+数量+辣度+英文空格+"晋菜"+数量+酸度+英文空格+"浙菜"+数量+甜度。

如果整桌菜没有特色菜，则只输出table的基本信息，格式如下，注意最后加一个英文空格：

table+英文空格+桌号+:+英文空格+当前桌的原始总价+英文空格+当前桌的计算折扣后总价+英文空格

例如：table 1: 60 36 川菜 2 爆辣 浙菜 1 微甜

计算口味度时要累计本桌各类菜系所有记录的口味度总和（每条记录的口味度乘以菜的份数），再除以对应菜系菜的总份数，最后四舍五入。

注：本题要考虑代点菜的情况，当前桌点的菜要加上被其他桌代点的菜综合计算口味度平均值。

 

 

2、考虑客户订多桌菜的情况，输入时桌号时，增加用户的信息：

格式：table+英文空格+桌号+英文空格+":"+英文空格+客户姓名+英文空格+手机号+日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）

例如：table 1 : tom 13670008181 2023/5/1 21/30/00

约束条件：客户姓名不超过10个字符，手机号11位，前三位必须是180、181、189、133、135、136其中之一。

输出结果时，先按要求输出每一桌的信息，最后按字母顺序依次输出每位客户需要支付的金额。不考虑各桌时间段的问题，同一个客户的所有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+英文空格+桌号+“:”+英文空格+当前桌的计算折扣后总价+英文空格+辣度平均值+英文空格+酸度平均值+英文空格+甜度平均值+英文空格

 

最后按拼音顺序输出每位客户(不考虑客户同名或拼音相同的情况)的支付金额，格式： 用户姓名+英文空格+手机号+英文空格+支付总金额，按输入顺序排列。

 

　　代码如下：

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]);
            }
        }
    }
}

下面是类图：

 

（3）采坑心得：

　　主要还是对菜单计价程序5分析一下：

　　1.日期判断的类有点小问题，不是很精确，有的时候会出错，下面附一张运行结果的图：

 　　

（4）主要困难以及改进建议：

　　1.主要困难：

　　期中考试真的不难，没有什么太多好说的，至于pta的题目，感觉可以多做一些项目来充实自己，提升熟练度

　　2.改进建议：

　　1.修改日期类，使其更加准确，并加入注释方便阅读和以后的修改。

　　2.主函数里定义了许多变量用来处理每一桌的信息的分割和储存，这部分代码有改进的较大空间，可以将代码封装性加强。

　　3.一个完善的系统应该可以加入保护信息或者反馈错误的功能，可以自己尝试实现。

（5）总结：

　　继续加油，注意细节。

标签：Java,期中考试,double,new,空格,pta4,input,public,输入
From： https://www.cnblogs.com/tzt233/p/17517931.html

相关文章

  • centos7安装java
    1.tar-zxvfjdk-8u11-linux-x64.tar.gz 2.编辑环境变量vim/etc/profile 3.source/etc/profile4.java-version ......
  • [转]前台传递给后台的JSON字符串中的引号 “” 在JAVA后台被转义为 &quot
    1、问题：前台数据，JSON字符串带有引号“”，数据被传递到后台，引号被转义为&quot，后台无法解析。前台数据如下：正常后台数据如下：大部分正常，只有JSON字符串中的“”被转义为&quot2、解决：方法一：使用apache的lang包里的方法StringappJson=StringEscapeUtils.un......
  • pta4,5及期中考试总结
    (1)前言：期中考试的题目比较基础，主要涉及到了基本的面向对象思想和基本语法。pta4与pta5为点菜系列题目难度较大     （2）设计与分析：1.期中考试第一道题目，代码如下importjava.util.Scanner;classCircle{privatedoubleradius;publicCircle(dou......
  • 深入学习 Java 类加载机制
    博主介绍：✌博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，阿里云专家博主，华为云云享专家✌......
  • Java-语法基础
    JDK8复习用Java前置知识JavaSEJavaStandardEdition标准版支持面向桌面级应用（如Windows下的应用程序）的Java平台，提供了完整的Java核心API此版本以前称为J2SEJavaEEJavaEnterpriseEdition企业版一套用于企业环境下的应用程序的应用方案（包含：Servlet、Jsp），主要针......
  • Java基础语法
    1、Java的八种基本数据类型1、byte1字节取值范围：-128~1272、short2字节取值范围：-32768~327673、int4字节取值范围：-231~231-1#int是开发中最常用的，也是Java中默认的数据类型4、long8字节取值范围：-263~263-1#声明超过int取值范围的lon......
  • PTA4,5及期中总结
    1，前言PTA4,5还是继续之前的菜单计价程序，只是在1,2,3的基础上加以完善，增加了更多的新的功能，期中考试则是在测试考核面向对象及接口，继承和多态以及抽象类等等知识点、2，设计与分析 菜单计价程序-4 类图   第一次的课程成绩统计程序较为直观，题目要求中直接给了相关的类图，......
  • PTA 4，5题目集及期中考试总结
    PTA4，5题目集及期中考试总结前言第4次题目集知识点：对象和类的创建和应用，字符串的创建和应用。总共有1题，难度偏高。第5次题目集知识点：对象和类的创建和应用，字符串的创建和应用。总共有1题，难度偏高。期中考试知识点：字符的处理，类的封装，接口的创建和使用。总共有4题，难度偏低......
  • java流程控制
    一、Scanner对象java的一个工具类用来获取用户输入使用方式:导入java.util.Scanner包就能使用基本语法Scanners=newScanner(System.in);通过Scanner类的next()与nextLine()方法获取输入字符串读取值之前我们一般需要使用hasNext()与hasNextLine()判断是......
  • 体系化学习Java（Java面试专题）
    tip:此贴为目录贴，定期更新toNew:时间是最好的答案，它能解决所有问题。坚持！！！**本文章旨在总结Java的知识生态以及帮助需要学习者和求职者，本人从事应用安全和大数据领域，有8年开发经验，5年面试官经验，Java技术专家，有技术相关问题和面试相关问题均可以留言讨论。......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99