如何对列表使用子类型多态和泛型？

Question

I'm learning Java, and have read about inheritance and subtype polymorphism. Now I'm just starting to learn about generics, and I'm trying to put the pieces together, but am stuck.

Say I've an abstract parent class AbstractEdibles , and there are two children that extend from it: Food and Drink . Also, I've a Store that has two List s: one to store Food and one to store Drink .

Now, I want my Store to be able to have behaviors, such as adding to its stock. My desired approach is to define one method to take in a product and put it in the appropriate list. If it's a Food type, put it in the food list. If it's of type Drink , put it in the drink list.

I'm sure I need to use generics and subtype polymorphism. Here's a snippet of my code:

public class Store {

  private List<AbstractEdible> foodStock = new ArrayList<>();
  private List<AbstractEdible> drinkStock = new ArrayList<>();

  /**
   * A constructor for a new store inventory that has food and drink.
   *
   * @param foodStock   the list of food items in stock
   * @param drinkStock  the list of drink items in stock
   */
  public Store(List<AbstractEdible> foodStock, List<AbstractEdible> drinkStock) {
    this.foodStock = foodStock;
    this.drinkStock = drinkStock;
  }

  /**
   * Given an edible food, add it to its respective stock list.
   *
   * @param edible an edible item
   */
  public void addItemToStock(AbstractEdible edible) {
    if (product instanceof Food) {
      this.foodStock.add(product);
    } else if (product instanceof Drink) {
      this.drinkStock.add(product);
    }
  }
}

This doesn't give errors, but I'm unhappy with how loose I'm being with the types, and I think it could be made more optimal.

For starters, I'd prefer to allow my list to only allow that specific type of edible . That is, foodStock will only allow Food to be added, and drinkStock will only allow Drink to be added. What I tried was:

private List<AbstractEdible> foodStock = new ArrayList<Food>();
private List<AbstractEdiblet> drinkStock = new ArrayList<Drink>();

gives me a red underline in my IDE. So then I changed to:

private List<Food> foodStock = new ArrayList<Food>();
private List<Drink> drinkStock = new ArrayList<Drink>();

this works, but then my addItemToStock() method complains that the edible I'm trying to add is of type Edible and can't be added to a List containing type Food . (This is expected, because Edible is the parent of Food ; ie not every Edible is a Food , but every Food is Edible .)

Up/Down casting edible doesn't help, either. I then thought Upper Bounded Wildcards was what I was looking for, but that also didn't work.

Besides that, I'm also unsure if using instanceof is the best way to classify/sort objects.

What am I missing here? What concept am I not understanding?

Answer 1

If you want to ensure that foodStock stores Food only and drinkStock stores Drink only, then you'll have to initialize your lists like this:

private List<Food> foodStock = new ArrayList<>();
private List<Drink> drinkStock = new ArrayList<>();

If they are coming from constructor, just declare them:

private List<Food> foodStock;
private List<Drink> drinkStock;

and then assign them in constructor:

public Store(List<Food> foodStock, List<Drink> drinkStock) {
    this.foodStock = foodStock;
    this.drinkStock = drinkStock;
}

And once you have used instanceOf , it is safe to use casting:

public void addItemToStock(AbstractEdible product) {
    if (product instanceof Food) {
        this.foodStock.add((Food) product);
    } else if (product instanceof Drink) {
        this.drinkStock.add((Drink) product);
    }
}

---

You could also create a generic Stock class:

public class Stock<T extends AbstractEdible> {

    private List<T> items;

    public Stock() {
        items = new ArrayList<>();
    }

    public void addItem(T item) {
        this.items.add(item);
    }

    public List<T> getItems() {
        return items;
    }
}

and use it in your Store as:

public class Store {
    private Stock<Food> foodStock;
    private Stock<Drink> drinkStock;

    public Store() {
        this.foodStock = new Stock<>();
        this.drinkStock = new Stock<>();
    }

    public Store(Stock<Food> foodStock, Stock<Drink> drinkStock) {
        this.foodStock = foodStock;
        this.drinkStock = drinkStock;
    }

    public void addItemToStock(AbstractEdible product) {
        if (product instanceof Food) {
            this.foodStock.addItem((Food) product);
        } else if (product instanceof Drink) {
            this.drinkStock.addItem((Drink) product);
        }
    }
}