Question

我正在为简单的系统编写一些代码。我目前有ArrayList种蔬菜。蔬菜只有名称和价格作为参数。

    vegList.add(new Vegetable("Aubergine", 1.50));
    vegList.add(new Vegetable("Tomato", 1));
    vegList.add(new Vegetable("Cucumber", 0));

目前我的购物车上有三个Aubegines和一个番茄。

我有一种方法可以识别手推车中蔬菜的名称，然后返回价格，但我的问题是......我有三个茄子，并且被告知Aubergines是两个1英镑。

如何修改我的方法，以便在我的数量变量达到2时将price参数更改为1，然后继续以1.50英镑的价格添加Aubergines，直到当然再次达到2的倍数（在这种情况下为4）。请参阅下面的代码......

  public double getVegetablePrice(String name) {
    // Iterate through ArrayList
    // Get current index
    // Get Fruit name
    // Get price based on Fruit name
    // return price of Fruit

    double price = 0;
    double count = 0;
    double quantity = 0;

    for(int i = 0; i < vegList.size(); i++){
        Vegetable tempVeg = vegList.get(i);

        if(tempVeg.getName() == name){
            if(name.equals("Tomato")) {
                count = tempVeg.getPrice();
                price += (count * 1.0); //£1 per kg
            }

            else if(name.equals("Aubergine")) {
                quantity++; //ADD TO QUANTITY
                if(quantity == 2) {
                    price = 1.0;
                }
                else {
                    price = tempVeg.getPrice();
                }
            }
        }

        else{
            // do nothing
        }
    }
    return price;
}

请注意，我正在为JUnit测试写这个assertTrue(vegTotal == 3.50)，目前总共获得5.50英镑。

Answer 1

对于茄子，定价数量应为：

int pricingQuantity = quantity / 2 + quantity % 2;

如何合并我留给你的。

您的设计中存在一些使您的代码混乱的缺陷。考虑为您的杂货商品设立一个具有“n for 1”值的类，以及另一个具有使用上述计算的价格方法的购物车商品类。

Answer 2

我认为您可以从ShoppingCart课程中受益，该课程将ArrayList包裹起来，并在向购物车添加商品时控制数量。这样，您就可以简化场景中的项目捆绑计算。

例如，一个简单的（注意：未经测试）实现可以解决您的情况：

class ShoppingCart
    private List<Vegetable> items;
    private Map<String, Integer> quantities;

    public ShoppingCart() {
        items = new ArrayList<Vegetable>();
        quantities = new HashMap<String, Integer>();
    }

    public addItem(Vegetable v) {
        items.add(v);
        //Update quantities
        if (quantities.containsKey(v.getName()) {
            quantities.put(v.getName(), ++quantities.get(v.getName()));
        } else {
            quantities.put(v.getName(), 1);
        }
    }

    //TODO: Implement removeItem() and decrement quantities

    public Double getItemPrice(Vegetable v) {
        return items.contains(v) ? v.getPrice() : 0;
    }


    public Double getItemPrice(Vegetable v) {
        itemPrice = getItemPrice(v);

        if (itemPrice > 0) {
            int quantity = quantities.get(v.getName());

            if (v.getName().equals("Aubergine")) {
                int bundles = quantity / 2;
                int remaining = quantity % 2;
                return bundles * 1 + remaining * itemPrice; 
            }

            //do the rest of the code here

        }
    }

}

但您还应该在Vegetable课程中实施“捆绑”定价的逻辑。理想情况下，你应该使Vegetable成为一个抽象类，让你的每一个蔬菜成为一个实现它的类。

例如，如果您使Aubergine成为实现Vegetable的类，则可以创建getBundlePrice(int quantity)实现的抽象方法Aubergine，以定义其价格为1数量参数2.

这样，您无需在getItemPrice()方法中对蔬菜类型进行所有检查。相反，您可以调用v.getBundlePrice(quantity)自动计算它。

希望它有所帮助。

如何确定何时在Java中提供两个优惠

2 个答案: