Question

我有两个类，它们是抽象类A的子类：

class X extends A {}
class Y extends A {}

我想识别传递给函数的A对象的子类。我可以看到两种选择：

void myfunction(A myobj) {
    if(myobj instanceof X)
        doXStuff((X) myobj);
    if(myobj instanceof Y)
        doYStuff((Y) myobj);
}

或使用不同类型的enum添加A：

abstract class A {
    enum Type { X, Y };
    Type type;
    ...
}

class X extends A {
    type = Type.X;
    ...
}
class Y extends A {
    type = Type.Y;
    ...
}

void myfunction(A myobj) {
    if(myobj.type == Type.X)
        doXStuff((X) myobj);
    if(myobj.type == Type.Y)
        doYStuff((Y) myobj);
}

哪个更好？我倾向于第二个，因为instanceof对生产应用程序感觉不对。还有另一个最好的方法吗？如果第二个更好，是否有更好的地方放置enum？

Answer 1

两者都不好。

在A中定义方法，覆盖X和Y中的方法，并在传入的对象上调用该方法。您将丢弃多态，这是一个基石面向对象编程。

abstract class A {
    void doStuff();
}

class Y extends A {
    @Override
    void doStuff() {
        // Y specific implementation
    }
}

class X extends A {
    @Override
    void doStuff() {
        // X specific implementation
    }
}

使用

调用它

void myfunction(A myobj) {
    myobj.doStuff();
}

Answer 2

简短的回答是：“两者都不好”。

在实施方面它可能是一个很好的解决方案，但我认为它在设计方面不是一个很好的解决方案。

特别是违反单一责任原则。您将外星人代码放入了课程X和Y，但此代码属于使用Client和X的{{1}}。

另一点是你需要在两种情况下都使用铸造。

输入变量vs instanceof进行标识

2 个答案: