blog-2

前言

  1. 必修课、选修课的概念：

    • Java中可以使用类和接口来实现必修课和选修课的概念。例如，可以创建一个基础课程的抽象类，然后派生出具体的必修课和选修课。

  2. 考试、考察的概念：

    • Java中可以使用条件语句（if-else语句）来模拟考试和考察的不同考核方式。例如，通过判断条件来选择使用不同的计分方式计算总成绩。

  3. 总成绩计算公式：

    • 在Java中，你可以使用变量、运算符和控制流语句来实现总成绩的计算公式。根据给定的权重和成绩，使用算术运算符来进行加权和求和的操作。

设计与分析

  1. 题目设计：

    • 需要考虑题目的清晰度和准确性，确保学生能够理解题目的要求。
    • 题目应该包括必要的背景和条件，以便学生能够正确理解问题，并根据给定的知识点进行解答。
    • 考虑使用具体的例子或案例来帮助学生更好地理解题目，并引导他们进行思考和分析。

  2. 答案分析：

    • 对于涉及计算的问题，需要给出具体的计算公式、步骤和解答过程，以便学生理解问题的求解方法。
    • 对于涉及选择的问题，需要提供选项和相应的解析，让学生了解每个选项的含义和正确与错误之间的区别。
    • 鼓励学生通过自己的思考和分析，对问题进行进一步的思考和讨论，从而培养他们的问题分析和解决能力。

  3. 难度控制：

    • 需要考虑题目的难度适合目标学生群体的学习能力和知识水平。
    • 可以设计不同难度级别的题目，以满足学生的不同需求和学习进展。
    • +-----------------+                  +------------------+
|     菜单                    |                  |       订单               |
+-----------------+                  +------------------+
| - 菜品列表                  |                  | - 桌号                        |
|                                |                  | - 时间                         |
| + 添加菜品()                |                  | - 点菜记录列表           |
| + 删除菜品()                |                  | - 删除记录列表           |
|                                |                  |                                  |
+-----------------+                  +------------------+
    • 7-1 测验1-圆类设计
       

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

      输入格式:

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

      输出格式:

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

      import java.util.Scanner;

public class Circle {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    public double getArea() {
        return Math.PI * radius * radius;
    }
    
    // Getters and setters (optional)
    public double getRadius() {
        return radius;
    }
    
    public void setRadius(double radius) {
        this.radius = radius;
    }
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入圆的半径: ");
        double radius = scanner.nextDouble();
        
        Circle circle = new Circle(radius);
        double area = circle.getArea();
        
        System.out.println("圆的面积为: " + area);
    }
}

       

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

       

      public class Rectangle {
    private double x1, y1; // 左上角坐标
    private double x2, y2; // 右下角坐标
    
    public Rectangle(double x1, double y1, double x2, double y2) {
        this.x1 = x1;
        this.y1 = y1;
        this.x2 = x2;
        this.y2 = y2;
    }
    
    public double getArea() {
        double width = Math.abs(x2 - x1);
        double height = Math.abs(y2 - y1);
        
        return width * height;
    }
    
    // Getters and setters (optional)
    public double getX1() {
        return x1;
    }
    
    public void setX1(double x1) {
        this.x1 = x1;
    }
    
    public double getY1() {
        return y1;
    }
    
    public void setY1(double y1) {
        this.y1 = y1;
    }
    
    public double getX2() {
        return x2;
    }
    
    public void setX2(double x2) {
        this.x2 = x2;
    }
    
    public double getY2() {
        return y2;
    }
    
    public void setY2(double y2) {
        this.y2 = y2;
    }
}

      public class Main {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle(0, 0, 5, 3);
        double area = rectangle.getArea();
        System.out.println("矩形的面积为：" + area);
    }
}

      在个例中，Rectangle 类具有四个属性 (x1、y1、x2、y2)，表示矩形的左上角和右下角坐标。getArea() 方法用于计算该矩形的面积，它通过计算矩形的宽度和高度的乘积来实现。你可以使用 set 和 get 方法来设置和获取矩形的坐标属性。

       

      下面是一个简单的类图，描述了矩形类的设计：

      +-------------------------------------+
|             Rectangle               |
+-------------------------------------+
| - x1: double                         |
| - y1: double                         |
| - x2: double                         |
| - y2: double                         |
+-------------------------------------+
| + Rectangle(x1: double, y1: double,  |
|     x2: double, y2: double)           |
| + getArea(): double                   |
| + getX1(): double                     |
| + setX1(x1: double): void             |
| + getY1(): double                     |
| + setY1(y1: double): void             |
| + getX2(): double                     |
| + setX2(x2: double): void             |
| + getY2(): double                     |
| + setY2(y2: double): void             |
+-------------------------------------+

      在类图中，矩形类被表示为一个类框，包括类名 “Rectangle”。下面是类的成员：

      • - x1: double、- y1: double、- x2: double、- y2: double：私有属性，表示矩形的左上角和右下角的坐标。

      成员方法包括：

      • + Rectangle(x1: double, y1: double, x2: double, y2: double)：构造函数，用于初始化矩形对象的坐标属性。
      • + getArea(): double：公共方法，用于计算矩形的面积，并返回结果。
      • + getX1(): double、+ setX1(x1: double): void：公共方法，用于获取和设置矩形的左上角 x 坐标。
      • + getY1(): double、+ setY1(y1: double): void：公共方法，用于获取和设置矩形的左上角 y 坐标。
      • + getX2(): double、+ setX2(x2: double): void：公共方法，用于获取和设置矩形的右下角 x 坐标。
      • + getY2(): double、+ setY2(y2: double): void：公共方法，用于获取和设置矩形的右下角 y 坐标。
       
      • import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

class Dish {
    private String name;
    private double basePrice;
    
    public Dish(String name, double basePrice) {
        this.name = name;
        this.basePrice = basePrice;
    }
    
    public String getName() {
        return name;
    }
    
    public double getBasePrice() {
        return basePrice;
    }
}

class Order {
    private int tableNumber;
    private String time;
    private List<Map<String, Object>> orderItems;
    private List<Integer> deleteItems;
    
    public Order(int tableNumber, String time) {
        this.tableNumber = tableNumber;
        this.time = time;
        this.orderItems = new ArrayList<>();
        this.deleteItems = new ArrayList<>();
    }
    
    public void addOrderItem(int serialNumber, String dishName, String portion, int quantity) {
        Map<String, Object> orderItem = new HashMap<>();
        orderItem.put("SerialNumber", serialNumber);
        orderItem.put("DishName", dishName);
        orderItem.put("Portion", portion);
        orderItem.put("Quantity", quantity);
        orderItems.add(orderItem);
    }
    
    public void addDeleteItem(int serialNumber) {
        deleteItems.add(serialNumber);
    }
    
    // 方法用于处理订单，计算总价和打印订单详情
    public void processOrder(List<Dish> menu) {
        double totalPrice = 0.0;
        System.out.println("订单详情：");
        
        for (Map<String, Object> orderItem : orderItems) {
            int serialNumber = (Integer) orderItem.get("SerialNumber");
            String dishName = (String) orderItem.get("DishName");
            String portion = (String) orderItem.get("Portion");
            int quantity = (Integer) orderItem.get("Quantity");
            
            // 检查是否为删除的订单
            if (deleteItems.contains(serialNumber)) {
                System.out.println("删除订单 #" + serialNumber);
                continue;
            }
            
            // 查找菜品
            Dish dish = null;
            for (Dish menuDish : menu) {
                if (menuDish.getName().equals(dishName)) {
                    dish = menuDish;
                    break;
                }
            }
            
            // 如果菜品不存在，输出错误信息
            if (dish == null) {
                System.out.println("菜品不存在：" + dishName);
                continue;
            }
            
            // 根据份额计算菜品价格
            double price = calculatePrice(dish.getBasePrice(), portion);
            double subtotal = price * quantity;
            totalPrice += subtotal;
            
            System.out.println(dishName + " x " + quantity + " (份额: " + portion + ") - 小计: " + subtotal);
        }
        
        System.out.println("总价: " + totalPrice);
    }
    
    private double calculatePrice(double basePrice, String portion) {
        double price = basePrice;
        switch (portion) {
            case "T":
                price *= 1.5;
                break;
            case "L":
                price *= 2.0;
                break;
        }
        
        return Math.round(price * 100.0) / 100.0; // 保留两位小数
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 输入菜单
        System.out.println("请输入菜单：");
        List<Dish> menu = new ArrayList<>();
        while (true) {
            String input = scanner.nextLine();
            if (input.equals("end")) {
                break;
            }
            
            String[] dishInfo = input.split(",");
            String dishName = dishInfo[0].trim();
            double basePrice = Double.parseDouble(dishInfo[1].trim());
            Dish dish = new Dish(dishName, basePrice);
            menu.add(dish);
        }
        
        // 输入订单
        System.out.println("请输入订单：");
        List<Order> orders = new ArrayList<>();
        while (true) {
            String input = scanner.nextLine();
            if (input.equals("end")) {
                break;
            }
            
            String[] orderInfo = input.split(",");
            if (orderInfo.length == 2) { // 新订单
                int tableNumber = Integer.parseInt(orderInfo[0].trim());
                String time = orderInfo[1].trim();
                Order order = new Order(tableNumber, time);
                orders.add(order);
            } else if (orderInfo.length == 4) { // 点菜
                        int serialNumber = Integer.parseInt(orderInfo[0].trim());
                String dishName = orderInfo[1].trim();
                String portion = orderInfo[2].trim();
                int quantity = Integer.parseInt(orderInfo[3].trim());
                Order order = orders.get(orders.size() - 1); // 获取最后一个订单
                order.addOrderItem(serialNumber, dishName, portion, quantity);
            } else if (orderInfo.length == 2 && orderInfo[0].equals("delete")) { // 删除订单
                int serialNumber = Integer.parseInt(orderInfo[1].trim());
                Order order = orders.get(orders.size() - 1); // 获取最后一个订单
                order.addDeleteItem(serialNumber);
            } else {
                System.out.println("输入有误！");
            }
        }
        
        // 处理订单
        for (Order order : orders) {
            System.out.println();
            System.out.println("处理订单：");
            order.processOrder(menu);
        }
    }
}

        • 踩坑心得

          1. 空指针异常（NullPointerException）：

            • 心得体会：在使用对象时，确保前提条件并避免将空对象用于调用方法或访问属性。

          2. 数组越界异常（ArrayIndexOutOfBoundsException）：

            • 心得体会：在访问数组元素时，确保索引值在合法的范围内，避免超出数组的长度。

          3. 类型转换异常（ClassCastException）：

            • 心得体会：在进行类型转换时，应该先使用instanceof关键字进行类型检查，避免错误的类型转换。

        • 改进建议

          1. 代码注释：在关键部分和复杂的逻辑处添加注释，解释代码的用途、实现思路和关键步骤。这可以帮助其他开发人员理解和维护代码，并促进团队合作。

          2. 代码重构：对于冗长、复杂或难以理解的代码块，进行重构。将其分解为更小的函数或方法，使代码结构清晰、可读性强，并且易于维护。

          3. 错误处理：在关键的代码片段添加适当的错误处理机制，例如使用异常处理，以应对潜在的错误情况。这可以增强代码的健壮性和可靠性。代码优化：查找并优化潜在的性能瓶颈和低效的代码段。使用适当的数据结构和算法，避免不必要的循环和重复计算，以提高代码的执行效率。

          4. 代码优化：查找并优化潜在的性能瓶颈和低效的代码段。使用适当的数据结构和算法，避免不必要的循环和重复计算，以提高代码的执行效率。

posted @ 2023-06-30 18:10  每天都要酷酷哒  阅读(18)  评论(0)    收藏  举报