Java 对象模型和类型识别方法

Question

我正在编写一个应用程序，其中有一些代表世界中事物的类。

世界由对象数组表示（世界中存在的所有对象类都继承自该类 - 我们称之为 Thing）。

class World {
  Thing[] myObjects;
}

class Thing {}
class AAA extends Thing {}
class BBB extends Thing {}

在某些时候，我需要知道给定位置的对象是否属于给定类型。

我有一些解决方案，并且想与熟悉 Java 对象模型的人讨论每个解决方案的优点，因为我习惯了与 Java (CLOS) 不同的对象模型。

解决方案#1

在 World 类中定义方法 isAThingAAA(obj) 和 isAThingBBB(obj)。

这些方法将调用 obj.getClass() 并检查返回的类型是 AAA 还是 BBB。

我看到的问题是必须使用“getClass”来实现它。或者还有其他方法来实现吗？

解决方案#2

在 Thing 类中定义方法 isAnAAA () 和 isAnBBB ()，实现返回 false。在各自的类（AAA.isAnAAA 和 BBB.isAnBBB）中重新定义它们以返回 true。

这听起来很奇怪，因为最抽象的类会知道其子类的存在。

其他建议？

提前致谢。

Answer 1

您可以使用instanceof或isInstance http://download.oracle.com/javase/6/docs/api/java/lang/Class.html#isInstance%28java.lang.Object%29

class World {
    Thing[] myObjects;
}
class Thing {}
class AAA extends Thing {}
class BBB extends Thing {}
public class Main {
    public static void main(String[] args) {
        Thing[] things={new AAA(),new BBB()};
        for(Thing thing:things)
            if(thing instanceof AAA)
                System.out.println("i am an AAA");
            else if(thing instanceof BBB)
                    System.out.println("i am a BBB");
        }
}

Answer 2

最简单的方法是使用 Java 的内置 instanceof 运算符。例如：

public boolean isAAA(Thing myThing)
{
  return myThing instanceof AAA;
}

然而，许多人会告诉您，使用instanceof是类设计不佳的症状，而用不同的子类实现不同行为的正确方法是通过多态性。这里的问题是，在 Java 中，让一个类根据它的派生类型做不同的事情是很容易的，但是让其他对象根据它具有句柄的派生类型来不同地处理一个 Thing 就有点棘手了在。这是双重调度问题。

如果在处理 Thing 对象时，您可以将问题分派给其他一些方法，这些方法会根据 Thing 的子类对它执行不同的操作，那就太理想了，如下所示：

public void handleThing(Thing myThing)
{
  reactToThing(myThing);
}

public void reactToThing(AAA myThing)
{
  // Do stuff specific for AAA
}

public void reactToThing(BBB myThing)
{
  // Do stuff specific for BBB
}


public void reactToThing(Thing myThing)
{
  // Do stuff for generic Thing
}

然而，在 Java 中，它只支持单分派，无论 handleThing() 中 myThing 的实际类型如何，reactToThing(Thing) 都将始终被调用，并且您永远不会获得独特的行为。

要解决此问题，您需要做的是使用访问者模式。这仅涉及在您的 Thing 类及其所有子类中添加一些额外的代码，以便为您的reactToThing() 方法提供一些额外的上下文。假设上述方法都在一个名为 Visitor 的类中。我们可以重写上面的方法，首先将问题交给 Thing 对象本身，然后多态性将为我们提供适当的上下文（Thing、AAA 或 BBB），以便对象返回给访问者。

那么，我们可以将上面的例子重写如下：

public class Visitor
{
  // ...

  public void handleThing(Thing myThing)
  {
    myThing.accept(this);
  }

  public void reactToThing(AAA myThing)
  {
    // Do stuff specific for AAA
  }

  public void reactToThing(BBB myThing)
  {
    // Do stuff specific for BBB
  }


  public void reactToThing(Thing myThing)
  {
    // Do stuff for generic Thing
  }
}


public class Thing
{
  // ...

  public void accept(Visitor visitor)
  {
    visitor.reactToThing(this);
  }
}


public class AAA
{
  // ...

  public void accept(Visitor visitor)
  {
    visitor.reactToThing(this);
  }
}


public class BBB
{
  // ...

  public void accept(Visitor visitor)
  {
    visitor.reactToThing(this);
  }
}

那么为什么我需要在两个子类中重写相同的accept()方法呢？因为否则当调用访问者.reactToThing(this) 方法时，对象仍然处于 Thing 上下文中，因此我们会遇到与之前相同的问题。通过在所有三个地方重新实现它，派生类将覆盖父类的实现，并在 Visitor 中调用正确的方法。

当您只想知道正在使用的派生类时，似乎需要做很多工作，但回报是可扩展性和维护性。现在你不需要到处添加 if (something instanceof SomethingElse) 。具体来说，如果您决定将来需要更改某些内容（例如扩展 Visitor），则需要维护的重复代码将减少。

希望能解决您的问题。

Answer 3

在 Thing 类中编写一个抽象方法，然后让 AAA 的实例和 BBB 的实例重新定义它怎么样？您似乎想编写 isAnXXX 方法，也许您可​​以解释原因。

请注意，使用 instance of 运算符和 isAnXXX 方法不会导致多态性。这不是一件好事。你想要多态性，你需要它......咕噜，咕噜。另外，考虑一下明天您想要向您的 World 添加一个 CCC 类。您的设计应保证 World 类不会被触及，如 开放/封闭原则

所以，总结一下，你可以这样做：

在类 Thing 中：

public abstract class Thing{
   abstract void doSomething();
}

然后在子类中重写它

public class AAA extends Thing{

@override
public void doSomething(){ /*do something in AAAs way*/}

}

public class BBB extends Thing{

@override
public void doSomething(){ /*do something in BBBs way*/}

}

然后你可以填充你的 Thing[] 并执行此操作

   for (Thing t:myOBjects){
       t.doSomething()

   }

的每个实例事物知道如何到 doSomething，而无需询问其类型。

Answer 4

另一种选择是根本不使用这些方法。这些方法通常用于决定要做什么。相反

if(thing is a AAA) {
   ((AAA) thing).method();
} else if (thing is a BBB) {
   ((BBB) thing).method();
}

，当需要采取行动时，每个事物都知道该做什么会更好。你应该打电话的是

thing.method(); // each type know what to do.

Answer 5

您应该使用 instanceof 运算

AAA aaa = new AAA();
if(aaa instanceof AAA) {
    //do something different
}

符编辑：汤姆的回答也应该足以解决您的问题，这是很好的做法。