Question

我偶然发现了这种情况，但我不知道如何以正确的方式处理它：

class Coffee { }
class CoffeeMix extends Coffee {
  public boolean shaken;
}

我将咖啡项目保存在数组列表中：

ArrayList<Coffee> coffees = new ArrayList<Coffee>();

因此在此数组列表中存在普通咖啡对象和咖啡混合对象。现在我要显示所有咖啡混合对象，这些对象是动摇的：

for(Coffee c : coffees) {
  //here is the same problem as above
}

当我在stackoverflow上读到一些答案时：instanceof似乎是一个坏主意，因为它将背后的想法搞砸了。那么如何处理呢？

Answer 1

首先，当我们谈论OO时，我们不应该使用公共领域。我理解你为什么要避免使用实例。在这种情况下，您可以使用多态和动态绑定。您可以将抽象的isShaken方法添加到基类中，在CoffeeMix中将其作为私有方式进行操作并覆盖isShaken（返回抖动）

Answer 2

你确实应该使用多态。这是去这里的最佳方式。但是你想要你也可以使用getclass来检查它是否等于引用的类。

Answer 3

您可以使用访客模式。

以下是如何将其应用于您的案例的示例：

interface CoffeeElement {
    void accept(CoffeeVisitor visitor);
}

interface CoffeeVisitor {
    void visit(Coffee coffee);
    void visit(CoffeeMix coffee);   
}


class Coffee implements CoffeeElement {

    private final String name;

    public Coffee(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public void accept(CoffeeVisitor visitor) {
        visitor.visit(this);
    }

    @Override
    public String toString() {
        return "Coffee [name=" + getName() + "]";
    }
}

class CoffeeMix extends Coffee {

    public CoffeeMix(String name) {
        super(name);
    }

    @Override
    public void accept(CoffeeVisitor visitor) {
        visitor.visit(this);
    }

    @Override
    public String toString() {
        return "CoffeeMix [name=" + getName() + "]";
    }

}

class PrintingCoffeeVisitor implements CoffeeVisitor {

    @Override
    public void visit(Coffee coffee) {
        // ignore regular coffee
    }

    @Override
    public void visit(CoffeeMix mix) {
        System.out.println(mix);
    }

}

class CoffeeTest {

    public static void main(String[] args) {
        List<Coffee> coffee = new ArrayList<Coffee>();
        coffee.add(new Coffee("Java"));
        coffee.add(new Coffee("Molokai"));
        coffee.add(new CoffeeMix("Season Blend"));

        CoffeeVisitor v = new PrintingCoffeeVisitor();
        for (Coffee c : coffee) {
            c.accept(v);
        }
    }

}

您还可以阅读访客模式的此说明。我发现它非常有用。

https://stackoverflow.com/a/2604798/467874

Answer 4

instanceof似乎合适，但如果你真的不想使用它，你可以尝试一些丑陋的东西：

for (Coffee c : coffees) {
    try {
        CoffeeMix blend = (CoffeeMix) c;
        //whatever you want to do with CoffeeMix objects
    } catch (ClassCastException cce) {
        //whatever you want to do with Coffee objects
    }
}

这似乎是治愈比疾病更糟糕的情况，但只要CoffeeMix个对象有一些Coffee个对象无法使用的字段或属性，就应抛出异常，并且你已经完成了分类排序，而没有使用instanceof ，而且费用很高，适当的技术。

子类的Access属性

4 个答案: