Java 创建新对象将覆盖与以前对象关联的ObservableList

我正在从事一个项目，在该项目中，我创建的“产品”由可观察列表“部件”组成

我创建了一个产品并添加了一个部件。您可以在这里看到，我将部件“螺丝刀”添加到产品TESTPROD1中。

接下来，我创建TESTPROD2并向其添加零件“扳手”。

最后，我回去修改原始产品（TESTPROD1），它应该只包含“螺丝刀”，但它同时包含“螺丝刀”和“扳手”。

这里是我在按下“保存”按钮时创建产品的地方

private void addProductSaveHandler(ActionEvent event) throws IOException {
        
        Product p = new Product(
                Integer.parseInt(addProductIdTextField.getText()),
                addProductNameTextField.getText(),
                Double.parseDouble(addProductPriceTextField.getText()),
                Integer.parseInt(addProductInvTextField.getText()),
                Integer.parseInt(addProductMinTextField.getText()),
                Integer.parseInt(addProductMaxTextField.getText())
        );
        
        
        
        Inventory.addProduct(p);
        
        for (Part addedPs : tableSelectedParts){
            //Inventory.lookupProduct(p.getId()).addAssociatedPart(addedPs);
            Inventory.lookupProduct(Integer.parseInt(addProductIdTextField.getText())).addAssociatedPart(addedPs);
            
        }
        
        tableSelectedParts.clear();
        
        
        //Return to main screen
        stage = (Stage)((Button)event.getSource()).getScene().getWindow();
        scene = FXMLLoader.load(getClass().getResource("/view/MainForm.fxml"));
        stage.setScene(new Scene(scene));
        stage.show();
        
    }
@FXML
private void addPartHandler(ActionEvent event) {
        
        
        tableSelectedParts.add(addProductAllPartsTable.getSelectionModel().getSelectedItem());
        
    }
    

公共类目录{
私有静态ObservableList allParts=FXCollections.observableArrayList（）；
私有静态ObservableList allProducts=FXCollections.observableArrayList（）；
公共静态无效添加部件（部件新建部件）{
所有零件。添加（新零件）；
}
公共静态无效添加产品（产品新产品）{
添加（新产品）；
}
公共静态部分lookupPart（内部部分）{
返回所有零件。获取（partId）；
}
公共静态产品lookupProduct（int-productId）{
int productLocation=0；
对于（int i=0；i

公共类产品{
私有静态ObservableList associatedParts=FXCollections.observableArrayList（）；
私有int-id；
私有字符串名称；
私人双价；
私人股票；
私用int min；
私人int max；
公共产品（整数id、字符串名称、双倍价格、整数库存、整数最小值、整数最大值）{
this.id=id；
this.name=名称；
这个价格=价格；
这个。股票=股票；
this.min=min；
this.max=max；
}
/**
*@返回id
*/
公共int getId（）{
返回id；
}
/**
*@param id要设置的id
*/
公共无效集合id（内部id）{
this.id=id；
}
/**
*@返回名称
*/
公共字符串getName（）{
返回名称；
}
/**
*@param name要设置的名称
*/
公共void集合名（字符串名）{
this.name=名称；
}
/**
*@还钱
*/
公开双价{
退货价格；
}
/**
*@param price要设置的价格
*/
公共定价（双倍价格）{
这个价格=价格；
}
/**
*@还股票
*/
public int getStock（）{
退货；
}
/**
*@param stock要设置的股票
*/
公共无效集合库存（内部库存）{
这个。股票=股票；
}
/**
*@return-min
*/
公共int getMin（）{
返回最小值；
}
/**
*@param min要设置的最小值
*/
公共无效设置最小值（整数最小值）{
this.min=min；
}
/**
*@返回最大值
*/
公共int getMax（）{
返回最大值；
}
/**
*@param max要设置的最大值
*/
公共void setMax（int max）{
this.max=max；
}
公共静态无效添加关联部分（部分）{
关联部件。添加（部件）；
}
公共布尔deleteAssociatedPart（Part）{
关联部件。移除（部件）；
//不确定以下内容-稍后再来
返回false；
}
公共静态观察列表getAllAssociatedParts（）{
退回相关零件；
}
}

---

出于某种原因，创建新产品会覆盖与以前产品关联的零部件的可观察列表。几个小时以来我一直在想为什么会这样。任何帮助都将不胜感激。

您的类

产品

声明

关联部件

为

静态

。这意味着每个JVM只有一个列表，而不是每个产品有一个列表

---

换句话说：删除

static

关键字，每个产品都将有自己的关联部件。

您的类

product

将

关联部件声明为
static
。这意味着每个JVM只有一个列表，而不是每个产品有一个列表

换句话说：删除
static
关键字，每个产品都有自己的关联部件

public class Inventory {
    
    private static ObservableList<Part> allParts = FXCollections.observableArrayList();
    private static ObservableList<Product> allProducts = FXCollections.observableArrayList();
    
    public static void addPart(Part newPart){
        allParts.add(newPart);
    }
    
    public static void addProduct(Product newProduct){
        allProducts.add(newProduct);
    }
    
    public static Part lookupPart(int partId){
        return allParts.get(partId);
    }
    
    public static Product lookupProduct(int productId){
        int productLocation = 0;
        for (int i = 0; i < allProducts.size(); i++){
            if (allProducts.get(i).getId() == productId){
                
                productLocation = i;
            }
            
        }
        return allProducts.get(productLocation);
        
        
    }
    public static ObservableList<Product> lookupProduct(String productName){
        ObservableList<Product> matchingProduct = FXCollections.observableArrayList();
        for (int i = 0; i < allProducts.size(); i++){
            if (allProducts.get(i).getName().contains(productName)){
                matchingProduct.add(allProducts.get(i));
            }
        }
        
        return matchingProduct;
        
    }
}

public class Product {
    private static ObservableList<Part> associatedParts = FXCollections.observableArrayList();
    private int id;
    private String name;
    private double price;
    private int stock;
    private int min;
    private int max;    
    public Product(int id, String name, double price, int stock, int min, int max) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.stock = stock;
        this.min = min;
        this.max = max;
    }

    /**
     * @return the id
     */
    public int getId() {
        return id;
    }

    /**
     * @param id the id to set
     */
    public void setId(int id) {
        this.id = id;
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the price
     */
    public double getPrice() {
        return price;
    }

    /**
     * @param price the price to set
     */
    public void setPrice(double price) {
        this.price = price;
    }
    
    /**
     * @return the stock
     */
    public int getStock() {
        return stock;
    }

    /**
     * @param stock the stock to set
     */
    public void setStock(int stock) {
        this.stock = stock;
    }

    /**
     * @return the min
     */
    public int getMin() {
        return min;
    }

    /**
     * @param min the min to set
     */
    public void setMin(int min) {
        this.min = min;
    }

    /**
     * @return the max
     */
    public int getMax() {
        return max;
    }

    /**
     * @param max the max to set
     */
    public void setMax(int max) {
        this.max = max;
    }
    
    public static void addAssociatedPart(Part part){
        associatedParts.add(part);
    }
    
    public boolean deleteAssociatedPart(Part part){
        associatedParts.remove(part);
        //not sure about this below - come back later
        return false;
    }
    
     public static ObservableList<Part> getAllAssociatedParts(){
         return associatedParts;
     }
}