4

随着泛型的引入，我不愿意尽可能多地执行 instanceof 或强制转换。但是在这种情况下，我看不到解决方法：

for (CacheableObject<ICacheable> cacheableObject : cacheableObjects) {
    ICacheable iCacheable = cacheableObject.getObject();
    if (iCacheable instanceof MyObject) {
        MyObject myObject = (MyObject) iCacheable;
        myObjects.put(myObject.getKey(), myObject);
    } else if (iCacheable instanceof OtherObject) {
        OtherObject otherObject = (OtherObject) iCacheable;
        otherObjects.put(otherObject.getKey(), otherObject);
    }
}

在上面的代码中，我知道我的 ICacheables 应该只是 MyObject 或 OtherObject 的实例，并且根据这一点，我想将它们放入 2 个单独的映射中，然后进一步执行一些处理。

如果没有我的 instanceof 检查，如果有另一种方法可以做到这一点，我会很感兴趣。

谢谢

4

3 回答 3

2

您可以使用双重调用。没有承诺这是一个更好的解决方案，但它是一个替代方案。

代码示例

import java.util.HashMap;

public class Example {

    public static void main(String[] argv) {
        Example ex = new Example();
        ICacheable[] cacheableObjects = new ICacheable[]{new MyObject(), new OtherObject()};

        for (ICacheable iCacheable : cacheableObjects) {
            // depending on whether the object is a MyObject or an OtherObject,
            // the .put(Example) method will double dispatch to either
            // the put(MyObject) or  put(OtherObject) method, below
            iCacheable.put(ex);
        }

        System.out.println("myObjects: "+ex.myObjects.size());
        System.out.println("otherObjects: "+ex.otherObjects.size());
    }

    private HashMap<String, MyObject> myObjects = new HashMap<String, MyObject>();
    private HashMap<String, OtherObject> otherObjects = new HashMap<String, OtherObject>();

    public Example() {

    }

    public void put(MyObject myObject) {
        myObjects.put(myObject.getKey(), myObject);
    }

    public void put(OtherObject otherObject) {
        otherObjects.put(otherObject.getKey(), otherObject);
    }

}

interface ICacheable {
    public String getKey();
    public void put(Example ex);
}

class MyObject implements ICacheable {

    public String getKey() {
        return "MyObject"+this.hashCode();
    }

    public void put(Example ex) {
        ex.put(this);
    }
}

class OtherObject implements ICacheable {

    public String getKey() {
       return "OtherObject"+this.hashCode();
    }

    public void put(Example ex) {
        ex.put(this);
    }

}

这里的想法是 - 而不是强制转换或使用instanceof- 您调用iCacheable对象的.put(...)方法，该方法将自身传递回Example对象的重载方法。调用哪个方法取决于该对象的类型。

另请参阅访问者模式。我的代码示例有异味，因为该ICacheable.put(...)方法没有凝聚力 - 但是使用访问者模式中定义的接口可以清除这种异味。

为什么我不能直接this.put(iCacheable)从Example课堂上打电话？

在 Java 中，覆盖总是在运行时绑定，但重载稍微复杂一些：动态调度意味着方法的实现将在运行时选择，但方法的签名仍然在编译时确定。（查看Java 语言规范，第 8.4.9 章了解更多信息，还可以查看Java Puzzlers书第 137 页上的谜题“Making a Hash of It” 。）

于 2012-11-02T23:10:57.420 回答
1

有没有办法将每个地图中的缓存对象组合成一张地图？他们的密钥可以将它们分开，因此您可以将它们存储在一张地图中。如果你不能这样做，那么你可以有一个

Map<Class,Map<Key,ICacheable>>

然后这样做：

Map<Class,Map<Key,ICacheable>> cache = ...;

public void cache( ICacheable cacheable ) {
   if( cache.containsKey( cacheable.getClass() ) {
      cache.put( cacheable.getClass(), new Map<Key,ICacheable>() );
   }
   cache.get(cacheable.getClass()).put( cacheable.getKey(), cacheable );
}
于 2012-11-02T23:28:53.530 回答
0

您可以执行以下操作：

  1. 向您的界面添加一个方法，该方法ICachableInterface将处理将对象放置到两个 Map 之一中，作为方法的参数给出。
  2. 在您的两个实现类中的每一个中实现此方法，让每个类决定将自己放入哪个 Map。
  3. 删除instanceoffor 循环中的检查，并将该put方法替换为对步骤 1 中定义的新方法的调用。

然而，这不是一个好的设计，因为如果您曾经有另一个实现此接口的类和第三个映射，那么您需要将另一个映射传递给您的新方法。

于 2012-11-02T23:12:40.290 回答