0

为了进一步了解我的问题：

我在 Java 教科书中遇到了一个问题，它要求我编写一个名为GroceryList的类，它代表从市场上购买的商品列表，还有另一个名为GroceryItemOrder的类，它代表购买特定商品的请求给定数量（例如：四个单位的橙子）。根据进一步的指示，我将开发一个客户端来测试并打印所有已实现方法的结果。

免责声明：我没有要求任何人为我解决这个问题。我只是想请一位导师澄清我如何根据我的客户GroceryListClient的指示将我的GroceryItemOrder类中的实例方法实现到我的GroceryList类中。

我的GroceryList类中的代码：

public class GroceryList_test {
    public GroceryList_test() {
        GroceryItemOrder_test[] GroceryList = new GroceryItemOrder_test[10];
    }

    public void add(GroceryItemOrder_test item) {
        GroceryItemOrder_test[] GroceryList = new GroceryItemOrder_test[10];
        GroceryList[1] = item;
        System.out.println(GroceryList[1]);
    }

    /*public double getTotalCost(GroceryItemOrder_test item) {
    }*/
}

在实例方法add(GroceryItemOrder_test item)下：

  • 如果列表中的项目少于 10 个，则将给定的项目顺序（按照GroceryListClient访问GroceryItemOrder类时的指示）添加到此列表（不要担心此元素；我可以使用if 语句和空异常来执行此操作）。

每次我在GroceryListClient客户端中指示它这样做时，我希望此方法将商品订单从GroceryItemOrder_test (String name, int quantity, double priceperunit)动态加载到数组中，稍后将访问该客户端以计算总成本下面的TotalCost()实例方法。

我的GroceryItemOrder类中的代码：

public class GroceryItemOrder_test {
    String itemID;
    int NumberofItems;
    double priceperunit;

    public GroceryItemOrder_test(String name, int quantity, double pricePerUnit) {
        this.itemID = name;
        System.out.println("Item: " + itemID);
        this.NumberofItems = quantity;
        System.out.println("Quantity: " + NumberofItems);
        this.priceperunit = pricePerUnit;
        System.out.println("Price per unit: $" + priceperunit);
    }

    public double getCost() {
        return ((NumberofItems * priceperunit) * 100.0) / 100.0;
    }
    public void setQuantity(int quantity) {
    }
 }

在公共类public GroceryItemOrder_test(String name, int quantity, double pricePerUnit) 下：

  • 构造一个项目订单，以给定名称以给定数量购买项目，每单位成本为给定价格。

我希望将此方法加载到GroceryList类的实例方法 add(GroceryItemOrder_test item) 中的数组中。

我的GroceryListClient客户端的代码： 

public class GroceryListClient {
    public static void main(String[] args) {
        GroceryList_test addorder = new GroceryList_test();
        GroceryItemOrder(addorder);
    }
    public static void GroceryItemOrder(GroceryList_test addorder) {
        GroceryItemOrder_test Oranges = new GroceryItemOrder_test("oranges", 3, 2.46);
        System.out.println("Total cost of " + Oranges.itemID + " = $" + Oranges.getCost());
        addorder.add(Oranges);
        System.out.println();
        GroceryItemOrder_test Grapes = new GroceryItemOrder_test("grapes", 15, 0.55);
        System.out.println("Total cost of " + Grapes.itemID + " = $" + Grapes.getCost());
        addorder.add(Grapes);
    }
 }

在GroceryItemOrder(GroceryList_test addorder)方法下：

GroceryItemOrder_test Oranges = new GroceryItemOrder_test("oranges", 3, 2.46);
System.out.println("Total cost of " + Oranges.itemID + " = $" + Oranges.getCost());
addorder.add(Oranges);

特别是语句addorder.add(Oranges); ：

这应该将项目作为“项目”指定的“对象”添加到add(GroceryItemOrder_test item)方法下的数组中。

这些是我无法弄清楚如何执行的条件。如果可能，请提供任何帮助。

不要建议使用ArrayList，因为我还没有做到这一点，并且在进一步的研究中，我认为它不会很容易地用于此目的。

4

1 回答 1

0

如果我理解您的意思，您希望GroceryList存储不同的GroceryItemOrder对象。

您即将在代码中找到解决方案。但是，请看这里：

public void add(GroceryItemOrder_test item) {
    GroceryItemOrder_test[] GroceryList = new GroceryItemOrder_test[10];
    GroceryList[1] = item;
    System.out.println(GroceryList[1]);
}

如果你跟踪它是如何工作的，那么每次你输入这个add()方法时，都会创建一个包含十个空元素的新数组。当方法退出时，您将立即丢失对此的所有引用，因为它将超出范围并最终被垃圾收集。

为了解决这个问题，您需要使用一个保持在范围内的变量。GroceryList我为您的类推荐一个实例变量，如下所示：

public class GroceryList {

    private GroceryItemOrder[] list = null;

    public GroceryList() {
        list = new GroceryItemOrder[10];
    }

    public void add(GroceryItemOrder item) {
        for(int i=0; i<list.length; i++) {
            if(list[i] == null) {
                list[i] = item;
                System.out.println(item);
                break;
            }
        }
    }
}

现在在这种add()方法中，我们只查看已经存在和持续存在的list变量，而不是创建一个新变量。我们循环遍历它以找到一个可用的插槽（如果有的话），然后执行其余的处理。该break语句是必要的，以便列表中的每个项目都不会设置为您要添加的一个项目。

然后你的类可以随心所欲GroceryClient地创建对象并使用（因为它是）中的方法。GroceryItemOrderadd()GroceryListpublic

ArrayList请注意，与您在帖子结束评论中所说的相反，使用 确实会容易得多。

于 2013-03-05T21:05:00.410 回答