用Java语言编写一个库房出入货物程序设计，要对华为和小米两种手机产品进行入库，要求编写一个模拟商品入库的程序，可以在控制台输入入库商品的数量，最后打印出仓库中所有商品详细信息以及所有商品的总库存数和库存商品总金额。 商品信息如下： 品牌型号：华为，小米 尺寸：5.5，5.0 价格：3688.88，2988.88 配置：8+128G 全面刘海屏，4+64G 全面屏 入库：2，3 总价：7377.76，8966.64

<think>嗯，用户希望用Java编写一个库房出入货物程序，主要是针对华为和小米两种手机的入库操作。需要在控制台输入数量，然后输出详细信息、总库存和总金额。首先，我得分析用户的需求，确保程序结构合理，符合面向对象的设计。 首先，商品信息包括品牌、尺寸、价格、配置，这些应该作为属性封装在类里。可能需要一个商品类，比如Phone，包含品牌型号、尺寸、价格、配置这些字段。然后，入库的数量和总价可能需要另一个类来管理，比如库存类Inventory，用来记录各个商品的库存数量和总金额。 接下来，用户提到可以在控制台输入数量，所以需要考虑如何从控制台读取输入。Java中可以用Scanner类来处理。然后需要根据输入的数据更新库存，这里要注意输入的数据如何与具体的商品对应起来。比如，用户输入2和3，分别对应华为和小米的入库数量，所以程序需要明确这两个数字对应的商品。 然后，输出部分需要显示每个商品的详细信息，包括品牌、尺寸、价格、配置、库存数量以及该商品的总金额，最后是所有商品的总库存和总金额。这里可能需要遍历库存中的每个商品，输出其信息，并累加总库存和总金额。 另外，商品的总金额是单价乘以数量，所以在每次入库的时候需要更新该商品的总金额，同时累加到总金额中。库存类需要记录每个商品的库存数量，以及所有商品的总库存数和总金额。 可能的结构是：Phone类有品牌、尺寸、价格、配置四个属性。Inventory类包含一个Phone到库存数量和该商品总金额的映射，比如用HashMap<Phone, int[]>，其中int数组第一个元素是数量，第二个是该商品的总金额。或者，可能更清晰的是创建一个StockItem类，包含Phone实例、库存数量、该商品总金额，然后Inventory管理一个StockItem的列表。 不过，为了简化，可能直接在Inventory类中用两个数组或两个变量来分别存储华为和小米的库存，因为用户明确只有两种商品。但更好的做法是使用面向对象的方式，允许扩展更多的商品类型。所以，可能还是用集合来存储不同的商品及其库存信息。 接下来，考虑程序的流程：初始化两种手机的信息，创建Inventory实例，从控制台读取入库数量，更新库存，然后输出详细信息。 需要注意的是，价格和总金额都是浮点数，处理时可能会有精度问题，但在实际商业应用中通常用BigDecimal，不过用户给出的示例用了double类型，如3688.88，所以这里可能直接用double来处理，但要注意四舍五入的问题。 然后，具体步骤： 1. 创建Phone类，包含品牌、尺寸、价格、配置。 2. 创建Inventory类，管理多个Phone的库存，提供入库方法，计算总库存和总金额。 3. 主程序里初始化华为和小米的Phone实例。 4. 使用Scanner读取用户输入的两个整数，分别对应华为和小米的入库数量。 5. 调用Inventory的入库方法，更新库存。 6. 最后输出每个商品的详细信息，总库存和总金额。 可能的错误点：输入的顺序是否正确，比如第一个数字是华为，第二个是小米。用户示例中的入库数量是2和3，对应华为和小米，总价分别是7377.76（2*3688.88）和8966.64（3*2988.88），总金额是两者之和。所以必须确保输入顺序正确。 在代码中，可能需要将华为和小米的Phone实例按顺序处理，所以在读取输入时，第一个数字对应华为，第二个对应小米。 测试用例：输入2和3，总库存是5，总金额是7377.76+8966.64=16344.40。 现在，开始编写代码结构。 Phone类： 属性：brand（String），size（double），price（double），configuration（String） Inventory类： 属性：一个列表或Map来存储各个Phone及其库存数量和总金额。比如，可以用List<StockEntry>，其中StockEntry包含Phone对象，库存数量，该商品总金额。 或者更简单的，因为只有两种商品，可以用两个变量分别存储华为和小米的库存数量和总金额。但这样扩展性不好。更好的做法是使用集合。 所以StockEntry类可能包含： Phone phone; int quantity; double totalPrice; 然后Inventory有一个List<StockEntry> entries。 但为了简化，可能直接在Inventory中使用一个Map<Phone, StockEntry>，这样方便根据Phone查找对应的库存信息。 入库方法：接收Phone和数量，更新对应的StockEntry的数量和总金额。 然后，总库存数是所有StockEntry的quantity之和，总金额是各个totalPrice之和。 主程序中： 创建华为和小米的Phone实例。 然后，读取两个整数，假设第一个是华为的数量，第二个是小米的数量。 然后，调用Inventory的addStock方法，分别传入华为和对应的数量，小米和对应的数量。 然后输出时，遍历Inventory中的每个StockEntry，打印详细信息。 现在，编写代码的大纲： Phone.java: public class Phone { private String brand; private double size; private double price; private String configuration; public Phone(String brand, double size, double price, String configuration) { this.brand = brand; this.size = size; this.price = price; this.configuration = configuration; } // getters 方法 } StockEntry.java: public class StockEntry { private Phone phone; private int quantity; private double totalPrice; public StockEntry(Phone phone) { this.phone = phone; this.quantity = 0; this.totalPrice = 0.0; } public void addQuantity(int amount) { this.quantity += amount; this.totalPrice += amount * phone.getPrice(); } // getters } Inventory.java: import java.util.ArrayList; import java.util.List; public class Inventory { private List<StockEntry> stockEntries; public Inventory() { stockEntries = new ArrayList<>(); } public void addStock(Phone phone, int amount) { for (StockEntry entry : stockEntries) { if (entry.getPhone().equals(phone)) { // 需要Phone类正确实现equals方法 entry.addQuantity(amount); return; } } // 如果不存在，添加新的StockEntry StockEntry newEntry = new StockEntry(phone); newEntry.addQuantity(amount); stockEntries.add(newEntry); } public int getTotalQuantity() { int total = 0; for (StockEntry entry : stockEntries) { total += entry.getQuantity(); } return total; } public double getTotalAmount() { double total = 0.0; for (StockEntry entry : stockEntries) { total += entry.getTotalPrice(); } return total; } public List<StockEntry> getStockEntries() { return stockEntries; } } 主程序： import java.util.Scanner; public class Main { public static void main(String[] args) { Phone huawei = new Phone("华为", 5.5, 3688.88, "8+128G 全面刘海屏"); Phone xiaomi = new Phone("小米", 5.0, 2988.88, "4+64G 全面屏"); Inventory inventory = new Inventory(); inventory.addStock(huawei, 0); // 初始库存为0？ inventory.addStock(xiaomi, 0); Scanner scanner = new Scanner(System.in); System.out.println("请输入华为手机的入库数量："); int huaweiAmount = scanner.nextInt(); System.out.println("请输入小米手机的入库数量："); int xiaomiAmount = scanner.nextInt(); inventory.addStock(huawei, huaweiAmount); inventory.addStock(xiaomi, xiaomiAmount); System.out.println("-------------库存明细-------------"); for (StockEntry entry : inventory.getStockEntries()) { Phone phone = entry.getPhone(); System.out.printf("品牌型号：%s 尺寸：%.1f 价格：%.2f 配置：%s 入库数量：%d 总价：%.2f%n", phone.getBrand(), phone.getSize(), phone.getPrice(), phone.getConfiguration(), entry.getQuantity(), entry.getTotalPrice()); } System.out.println("---------------------------------"); System.out.printf("总库存数：%d%n", inventory.getTotalQuantity()); System.out.printf("库存商品总金额：%.2f%n", inventory.getTotalAmount()); } } 不过，这里有几个问题需要处理： 1. Phone类的equals方法需要正确重写，否则在inventory.addStock时无法正确判断是否是同一个手机。因为用户的需求中，华为和小米是不同的实例，所以当在Inventory的addStock方法中查找是否存在该Phone时，默认的equals方法（比较对象地址）可能无法正确识别。因此，应该在Phone类中重写equals和hashCode方法，根据品牌、尺寸、价格、配置来判断是否相等。 但在这个案例中，用户可能只需要两种特定的手机，所以可能不需要动态添加其他型号。因此，可能可以直接在Inventory初始化时添加这两个手机，然后在入库时根据输入的顺序来分别处理。或者，在输入的时候，用户输入的两个数字分别对应华为和小米，所以不需要通过equals判断，而是直接按顺序处理。 这可能更简单。因为用户明确要处理华为和小米两种，所以可以不需要用Map来查找，而是直接按顺序处理。例如，库存中有两个固定的条目，华为和小米，按顺序添加数量。 这样的话，代码可以简化。例如，Inventory类中维护两个StockEntry，一个华为，一个小米。或者直接在Inventory中使用两个变量。 这可能更直接，但扩展性不好。但根据用户的需求，可能足够。 或者，主程序中，在调用addStock时，直接按顺序处理输入的数量。例如，用户输入的两个数，第一个是华为，第二个是小米，那么在添加库存时，分别调用addStock(huawei, huaweiAmount)和addStock(xiaomi, xiaomiAmount)，并且Inventory中的addStock方法会找到对应的条目。 但需要确保Inventory中存在这两个Phone的条目。因此，在初始化Inventory时，可能需要预先添加这两个手机，库存为0，或者当第一次调用addStock时自动创建条目。 根据之前的Inventory类设计，当第一次添加某个Phone时，会自动创建StockEntry。因此，在主程序中，可能不需要预先添加库存为0，而是在用户输入数量后，调用addStock方法，传入数量。例如： inventory.addStock(huawei, huaweiAmount); 如果Inventory中还没有这个Phone的条目，就会创建新的StockEntry，并添加数量。这样，初始库存为0的情况下，第一次添加数量就是入库数量。例如，如果初始库存是0，用户输入2，那么库存变为2，总价是2*价格。 但根据用户示例，入库数量是2和3，总价是7377.76和8966.64，这正好是2*3688.88和3*2988.88，所以初始库存是0，然后添加数量。这样设计是正确的。 但问题在于，如果用户多次运行程序，或者多次入库，每次都是新增数量，而不是设置数量。所以addStock方法中的addQuantity是正确的，因为它累加数量。 不过，在用户的需求中，可能每次运行程序都是一次独立的入库操作，所以不需要考虑多次入库的情况。但按照题目描述，“可以在控制台输入入库商品的数量”，可能意味着每次运行程序时输入的数量是当次入库的数量，总库存是该次入库后的结果。例如，运行程序，输入2和3，总库存是2和3，总金额是7377.76+8966.64。如果再次运行程序，输入1和1，那么总库存是1和1，而不是累加。或者，可能题目中的入库是每次入库的数量，总库存是累加的。但根据用户示例，入库数量是2和3，总库存是5，总金额是16344.40。所以可能需要将每次的输入视为新增数量，即库存是累加的。 不过，根据问题描述，可能程序每次运行都是一次独立的操作，即输入当次入库的数量，然后显示当前总库存（即当次入库后的数量）。或者，是否总库存是每次运行程序后的累加？这需要明确。但根据示例，入库数量是2和3，总库存数是5，所以程序应该将输入的数量视为当次要入库的数量，并显示入库后的总库存。 因此，Inventory中的addStock方法应该将传入的数量累加到现有库存中。例如，如果库存中已经有华为的2台，再次调用addStock(huawei,3)，则总库存变为5。 但根据用户示例，当输入2和3时，总库存是5，所以可能程序每次运行都是单次入库操作，总库存是当次输入的数量。或者，可能程序中的库存是每次运行独立计算的，即每次运行程序时，初始库存为0，输入的数量就是当次的入库数量，总库存等于输入的数量之和。例如，用户输入2和3，总库存是5，总金额是2*3688.88 +3*2988.88。 根据用户提供的示例，总价是7377.76和8966.64，这正好是2*3688.88和3*2988.88，所以程序中的库存数量是当次入库的数量，而不是累加。因此，可能程序中的库存数量是当次输入的数值，而并不是累加历史记录。因此，每次运行程序时，输入的数量是当次要入库的数量，总库存就是这些数量的总和。 因此，在Inventory中，每次addStock时，是设置数量还是累加数量？ 根据用户示例，入库数量是2和3，总库存是5，总金额是两商品各自的数量乘单价之和。所以，如果用户运行程序，输入2和3，库存数量是2和3，总库存是5。如果再次运行程序，输入1和1，库存数量是1和1，总库存是2，总金额是3688.88+2988.88=6677.76。 这表明，每次运行程序时，输入的数量是当次入库的数量，程序中的库存是当次的数量，而不是累加。因此，Inventory中的库存数量应该是当次添加的数量，而不是累加。所以，在addStock方法中，应该设置数量为传入的值，而不是累加。 但用户问题中要求的是“模拟商品入库的程序”，可能入库是多次的，但这里可能简化为每次运行程序进行一次入库操作，并显示当前总库存。或者，可能用户希望每次入库的数量是累加的，但根据示例，总库存是2+3=5，所以可能程序中的库存是每次输入的数量的总和，即每次运行程序时，输入的数量会被累加到库存中。 但示例中的总库存是5，而用户给出的入库数量是2和3，所以可能程序中的库存是累加的。因此，Inventory中的addStock方法应该将传入的数量加到现有库存中。 但根据示例，入库数量是2和3，总库存是5，总金额是这两个数量乘以单价的总和。因此，如果库存初始为0，然后addStock(2)和addStock(3)，那么库存数量就是2和3，总和是5。这说明每次运行程序时，输入的数量是当次新增的数量，而程序中的库存是这些数量的总和。因此，Inventory中的addStock方法应该将数量累加。 因此，在代码中，StockEntry的addQuantity方法应该将传入的amount加到现有的quantity上。这样，如果多次调用addStock，数量会累加。 但用户的问题可能希望每次运行程序时，输入的是当次入库的数量，而程序显示的是当前仓库中的总库存。例如，第一次运行输入2和3，总库存是5。第二次运行输入1和1，总库存是6。但程序作为一次执行，可能无法保存状态，所以每次运行都是独立的。因此，可能用户的问题中，每次运行程序都是独立的一次入库操作，即输入的数量是当次要入库的数量，总库存就是这些数量的总和，而不是历史累加。例如，输入2和3，总库存是5，总金额是两者的总和。而再次运行程序时，输入1和1，总库存是2，总金额是3688.88 + 2988.88=6677.76。 这可能更符合示例的情况，因为用户给出的总库存数是5，总金额是16344.40，这正好是2和3的数量之和。因此，在程序中，库存数量就是当次输入的数量，而不是历史累加。所以，Inventory中的addStock方法应该设置数量为传入的值，而不是累加。 但是，这样的话，如果多次调用addStock，后面的调用会覆盖前面的值。例如，如果先调用addStock(huawei,2)，然后调用addStock(huawei,3)，那么库存数量是3，而不是5。 这显然不符合用户示例中的情况，因为用户示例中的入库数量是2和3，总库存是5，所以需要累加。 这里可能存在矛盾，需要明确用户的需求。根据问题描述，“可以在控制台输入入库商品的数量，最后打印出仓库中所有商品详细信息以及所有商品的总库存数和库存商品总金额。”这里的入库操作是单次还是多次？例如，用户可能希望程序允许用户多次输入入库数量，直到选择退出，然后显示总库存。但根据问题描述，可能是一次性输入当次的入库数量，然后显示总库存。因此，每次运行程序时，用户输入的是当次要入库的数量，程序显示入库后的总库存，即总库存等于当次输入的数量之和。 例如，用户运行程序，输入2和3，程序显示总库存5，总金额16344.40。再次运行程序，输入1和1，显示总库存2，总金额6677.76。这种情况下，Inventory在每次运行时都是新的，初始库存为0，然后添加当次的数量。 因此，在程序中，每次运行都是独立的一次入库操作，库存初始为0，用户输入的数量被添加到库存中，最终显示总库存是输入的数量之和。 因此，Inventory中的addStock方法应该将传入的数量设置为当次入库的数量，或者累加到现有库存中？ 根据用户示例，入库数量是2和3，所以华为的库存是2，小米是3，总库存5。这表明，当次入库的数量是2和3，所以程序中的库存数量就是这两个数字。因此，Inventory中的addStock方法应该将传入的数量设置为当前库存，而不是累加。但这样的话，如果程序允许多次入库（比如在一个运行周期内多次输入），则每次输入会覆盖之前的库存。不过，根据问题描述，程序可能只需要一次输入，然后显示结果，因此，在代码中，直接将用户输入的数量作为当次入库的数量，设置库存为这些值。 因此，Inventory中的addStock方法应该设置库存为传入的数量，而不是累加。例如： 在StockEntry类中： public void setQuantity(int amount) { this.quantity = amount; this.totalPrice = amount * phone.getPrice(); } 然后，在Inventory的addStock方法中，找到对应的StockEntry，并设置数量。 但这样，如果多次调用addStock，最后一次调用会覆盖之前的数量。 或者，用户可能希望每次入库是增加库存，而不是设置。例如，第一次入库2台华为，第二次入库3台，总库存是5。但根据问题描述中的示例，可能用户希望当次入库的数量是2和3，总库存是这两个数的总和，而不是多次入库的结果。因此，在程序中，当用户运行程序时，输入的数量是当次要入库的数量，总库存就是这些数量的总和，而无需考虑之前的库存，因为程序不保存状态。 因此，正确的做法是将用户输入的数量作为当次入库的数量，直接设置为库存的数量，而不是累加。因此，在代码中，每次调用addStock时，设置库存为传入的数量，而不是累加。 但这样的话，如果用户多次调用addStock，比如先加2，再加3，总库存会是3，而不是5。这可能不符合用户示例。 看来这里存在歧义，必须根据用户提供的示例来判断。用户示例中的入库数量是2和3，总库存是5，所以华为和小米的数量分别是2和3，总库存5。因此，程序中的库存数量是用户输入的数值，而总库存是它们的总和。因此，正确的做法是将用户输入的数量作为当次入库的数量，直接设置到库存中，即库存数量等于输入的数量。因此，每次运行程序时，用户输入的数量是当次入库的数量，库存显示这些数量的总和。 这种情况下，Inventory中的addStock方法应该设置库存为传入的数量，而不是累加。例如： 在StockEntry类中： public void setQuantity(int amount) { this.quantity = amount; this.totalPrice = amount * phone.getPrice(); } Inventory的addStock方法： public void addStock(Phone phone, int amount) { for (StockEntry entry : stockEntries) { if (entry.getPhone().equals(phone)) { entry.setQuantity(amount); return; } } StockEntry newEntry = new StockEntry(phone); newEntry.setQuantity(amount); stockEntries.add(newEntry); } 这样，每次调用addStock(phone, amount)时，会设置该phone的库存为amount，而不是累加。 但用户示例中的总库存数是5，即2+3，这表示华为和小米的数量分别是2和3，所以总库存是它们的总和。如果Inventory中的addStock方法是将传入的数量设置为该phone的库存，而不是累加，那么这符合用户示例。例如，用户输入2和3，调用addStock(huawei, 2)和addStock(xiaomi,3)，库存数量分别是2和3，总库存5。 因此，这样的设计是正确的。 综上，代码中的addStock方法应设置库存数量为传入的amount，而不是累加。因此，StockEntry的setQuantity方法会计算总价。 因此，StockEntry类中的方法应该是setQuantity，而不是addQuantity。 现在，调整代码： StockEntry.java: public class StockEntry { private Phone phone; private int quantity; private double totalPrice; public StockEntry(Phone phone) { this.phone = phone; this.quantity = 0; this.totalPrice = 0.0; } public void setQuantity(int quantity) { this.quantity = quantity; this.totalPrice = quantity * phone.getPrice(); } // getters... } Inventory.java中的addStock方法： public void addStock(Phone phone, int amount) { for (StockEntry entry : stockEntries) { if (entry.getPhone().equals(phone)) { entry.setQuantity(amount); return; } } StockEntry newEntry = new StockEntry(phone); newEntry.setQuantity(amount); stockEntries.add(newEntry); } 这样，当调用inventory.addStock(huawei, 2)时，华为的库存数量设置为2，总价为2*3688.88=7377.76。同样，小米设置为3，总价为3*2988.88=8966.64。总库存数是5，总金额16344.40，符合用户示例。 但是，这样设计的话，如果多次调用addStock，后面的调用会覆盖前面的值。例如，如果先调用addStock(huawei,2)，再调用addStock(huawei,3)，库存数量会是3，而不是5。这在用户示例中是正确的，因为用户示例中的入库数量是2和3，总库存是5，即两个不同的商品的库存相加。 因此，这样的设计符合用户的需求。 接下来，处理Phone类的equals方法。由于在Inventory的addStock方法中，需要通过Phone对象来判断是否已经存在该商品的库存条目，因此需要正确实现equals和hashCode方法。否则，默认的equals方法（比较对象引用）会导致无法正确识别相同的手机型号。 例如，如果在主程序中创建了huawei和xiaomi对象，然后在调用addStock时，每次传入的是同一个对象，那么equals会比较引用，从而正确找到对应的StockEntry。但在当前代码中，主程序中的huawei和xiaomi是固定的，因此在Inventory的stockEntries中，对应的Phone对象是同一个，所以即使没有重写equals方法，也能正确找到。例如： Phone huawei = new Phone(...); inventory.addStock(huawei, 2); inventory.addStock(huawei, 3); // 这会找到之前创建的StockEntry，并设置数量为3，覆盖之前的2。 但如果Phone类的equals没有正确重写，而用户创建了新的Phone实例，例如： Phone huawei1 = new Phone("华为",5.5,3688.88, "..."); Phone huawei2 = new Phone("华为",5.5,3688.88, "..."); inventory.addStock(huawei1,2); inventory.addStock(huawei2,3); // 这会认为这是两个不同的Phone，从而创建两个StockEntry。 这显然不符合预期。因此，为了正确判断两个Phone对象是否代表同一商品，必须重写equals和hashCode方法，根据品牌、尺寸、价格、配置来判断是否相等。 因此，在Phone类中，需要添加： @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Phone phone = (Phone) o; return Double.compare(phone.size, size) == 0 && Double.compare(phone.price, price) == 0 && Objects.equals(brand, phone.brand) && Objects.equals(configuration, phone.configuration); } @Override public int hashCode() { return Objects.hash(brand, size, price, configuration); } 这样，当两个Phone对象的品牌、尺寸、价格、配置相同时，被认为是同一个商品，从而在Inventory中会合并到同一个StockEntry中。 不过，在用户的需求中，华为和小米的配置不同，所以它们的Phone实例是不同的，这符合预期。 综上，现在的代码应该可以正确处理用户的示例。 测试运行： 输入华为数量2，小米数量3。 库存条目： 华为：数量2，总价7377.76 小米：数量3，总价8966.64 总库存5，总金额16344.40 输出应该如示例所示。 因此，代码是正确的。 最后，主程序中的Inventory初始化可能不需要预先添加StockEntry，因为当调用addStock方法时，如果不存在，会自动添加。 但在用户示例中，总库存数是当次输入的数量之和，因此代码是正确的。 综上，完整的Java代码如下：</think>以下是用Java实现库房货物入库管理的完整代码，分为四个类文件： ```java // Phone.java public class Phone { private String brand; private double size; private double price; private String configuration; public Phone(String brand, double size, double price, String configuration) { this.brand = brand; this.size = size; this.price = price; this.configuration = configuration; } // Getters public String getBrand() { return brand; } public double getSize() { return size; } public double getPrice() { return price; } public String getConfiguration() { return configuration; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Phone phone = (Phone) o; return Double.compare(phone.size, size) == 0 && Double.compare(phone.price, price) == 0 && brand.equals(phone.brand) && configuration.equals(phone.configuration); } @Override public int hashCode() { return Objects.hash(brand, size, price, configuration); } } // StockEntry.java public class StockEntry { private Phone phone; private int quantity; private double totalPrice; public StockEntry(Phone phone) { this.phone = phone; } public void setQuantity(int quantity) { this.quantity = quantity; this.totalPrice = quantity * phone.getPrice(); } // Getters public Phone getPhone() { return phone; } public int getQuantity() { return quantity; } public double getTotalPrice() { return totalPrice; } } // Inventory.java import java.util.ArrayList; import java.util.List; public class Inventory { private final List<StockEntry> entries = new ArrayList<>(); public void addStock(Phone phone, int quantity) { for (StockEntry entry : entries) { if (entry.getPhone().equals(phone)) { entry.setQuantity(quantity); return; } } StockEntry newEntry = new StockEntry(phone); newEntry.setQuantity(quantity); entries.add(newEntry); } public int getTotalQuantity() { return entries.stream().mapToInt(StockEntry::getQuantity).sum(); } public double getTotalAmount() { return entries.stream().mapToDouble(StockEntry::getTotalPrice).sum(); } public List<StockEntry> getEntries() { return new ArrayList<>(entries); } } // WarehouseApp.java import java.util.Scanner; public class WarehouseApp { public static void main(String[] args) { Phone huawei = new Phone("华为", 5.5, 3688.88, "8+128G 全面刘海屏"); Phone xiaomi = new Phone("小米", 5.0, 2988.88, "4+64G 全面屏"); Inventory inventory = new Inventory(); Scanner scanner = new Scanner(System.in); System.out.print("请输入华为手机入库数量: "); inventory.addStock(huawei, scanner.nextInt()); System.out.print("请输入小米手机入库数量: "); inventory.addStock(xiaomi, scanner.nextInt()); System.out.println("\n-------------库存明细-------------"); for (StockEntry entry : inventory.getEntries()) { Phone p = entry.getPhone(); System.out.printf("品牌: %s 尺寸: %.1f 价格: %.2f 配置: %s\n入库数量: %d 总价: %.2f\n", p.getBrand(), p.getSize(), p.getPrice(), p.getConfiguration(), entry.getQuantity(), entry.getTotalPrice()); } System.out.println("---------------------------------"); System.out.printf("总库存数: %d\n", inventory.getTotalQuantity()); System.out.printf("库存总金额: %.2f\n", inventory.getTotalAmount()); } } ``` ### 运行效果示例 ``` 请输入华为手机入库数量: 2 请输入小米手机入库数量: 3 -------------库存明细------------- 品牌: 华为 尺寸: 5.5 价格: 3688.88 配置: 8+128G 全面刘海屏 入库数量: 2 总价: 7377.76 品牌: 小米 尺寸: 5.0 价格: 2988.88 配置: 4+64G 全面屏 入库数量: 3 总价: 8966.64 --------------------------------- 总库存数: 5 库存总金额: 16344.40 ``` ### 程序特点 1. **面向对象设计** - `Phone`类封装商品基本信息 - `StockEntry`类管理单品库存信息 - `Inventory`类实现库存管理核心逻辑 2. **扩展性强** 通过重写`equals`和`hashCode`方法，支持后续添加新商品型号 3. **数值精确性** 使用`double`类型处理金额，满足常规精度需求（生产环境建议使用`BigDecimal`） 4. **交互友好** 控制台输入提示清晰，输出排版工整 5. **健壮性** 使用`stream`进行集合操作，代码简洁且不易出错 可以通过修改`Phone`类的属性和增加新的`Phone`实例来扩展支持更多商品类型。