是否可以使用仅允许基于键的值类型的映射？

Question

我知道这听起来有点疯狂，但在这里。 我有一个代表一组不同属性的枚举类型。 每个都可能只是一个字符串，但强制执行某种类型的安全性会很好。 因此，基本上检查与每个枚举值关联的类型，如果不匹配则抛出异常。 我想这可以通过实例来完成，但我很好奇是否有另一种方法可以在没有instanceof的情况下执行此操作。 我知道这可能不可能，但我很好奇。

编辑，我创建了一个新的例子，我认为这说明了我更好的问题：

public class CmisProperties {

    public enum CmisPropEnum{
        Name (PropertyIds.NAME, new String() ),
        CreatedBy (PropertyIds.CREATED_BY, new String()  ),
        CreationDate (PropertyIds.CREATION_DATE, new Date() ),
        LastModifiedBy (PropertyIds.LAST_MODIFIED_BY, new String() ),
        LastModificationDate (PropertyIds.LAST_MODIFICATION_DATE, new Date() ),
        ChangeToken (PropertyIds.CHANGE_TOKEN, new String()  );

            private String propId;

        CmisPropEnum ( String propId , Object templateObject ){
            this.propId = propId;
        }

        public <T> String getPropId(){
            return propId;
        }
    }

        private Map<CmisPropEnum, Object> propertyMap = new HashMap<CmisPropEnum, Object>();

    public Object getProperty(CmisPropEnum propEnum){
         return propertyMap.get(propEnum.getPropId());
    }

    public void setProperty( CmisPropEnum propEnum, Object value){
             propertyMap.put(propEnum, value);
    }
}

后来我希望这发生：

CmisProperties props = new CmisProperties();
/* This causes a compile time exception */
props.setProperty(CmisPropEnum.CreationDate, "foobar" );
/* This I want to be ok, because the type matches that in the enum */
props.setProperty(CmisPropEnum.CreationDate, new Date() );

Answer 1

查看Josh Bloch的Effective Java ，第29项，在那里他描述了一个他称之为收藏夹的“类型安全的异构容器”。 API是

public class Favorites {
   public <T> void putFavorite(Class<T> type, T instance);
   public <T> T getFavorite(Class<T> type);
}

我认为它符合您的需求（可能更改名称???）。 你可以打电话

favorite.putFavorite(Name.getClass(), "Fred");
favorite.putFavorite(ADate.getClass(), new Date(1234));

然后

Date date = favorite.getFavorite(ADate.getClass());

Answer 2

正如已经提到的无可争议的，您需要基于类型（即泛型）的类具有可变性。 这是您示例的相应通用版本：

public class Properties {

  public static class Property<E> {
    private Property(String name) { this.name = name; }
    private final String name;
    public String getName() { return name; }
  }
  public static final Property<String> NAME = new Property<String>("name");
  // ... other properties

  private Map<Property<?>, Object> propertyMap = 
    new HashMap<Property<?>, Object>();

  @SuppressWarnings("unchecked") 
  public <E> E getProperty(Property<E> property){
    return (E) propertyMap.get(property);
  }
  public <E> void setProperty(Property<E> property, E value){
    propertyMap.put(property, value);
  } 

}

用法是类型安全的，并在编译时检查：

Properties p = new Properties();
p.setProperty(Properties.NAME, "a string"); // only strings allowed for NAME
String s = p.getProperty(Properties.NAME); // can only get strings for NAME

Answer 3

枚举不能是通用的，所以我们需要一个普通的类

public class Prop<T>
{
    // some predefined props
    static public final Prop<String> NAME = new Prop<>("Name", String.class);
    ...

    public Prop(String name, Class<T> type) // it's ok, anyone can create new kind of Prop
    {...}

    Class<T> getClassT() {...}

}

然后set / get属性方法可以有更强的静态类型检查：

private Map< Prop,Object > propMap = new HashMap<>();

public <T> void setProperty(Prop<T> key, T value){
    propMap.put(key, value);
}

@SuppressWarnings("unchecked")
public <T> T getProperty(Prop<T> key)
{
    return (T)propMap.get(key);
}

所以这不会编译

setProperty(Prop.NAME, new Integer(1)); // fail

int x = getProperty(Prop.NAME); //fail

注意的是，在每个条目propMap具有关键Prop<X>和值X为某些X ，和X可以是从输入到条目不同。 我们无法在Java中真正表达对Map限制; 但是约束确实是由app逻辑强制执行的（即setProperty()只插入这样的条目）

在getProperty我们必须禁止未经检查的警告。 这是合理的，因为我们知道密钥的值必须是T类型，这是由于前面提到的约束。 避免明确抑制警告的一个技巧是Class.cast()

public <T> T getProperty(Prop<T> key)
{
    return key.getClassT().cast( propMap.get(key) );
}

但这只是一个技巧，因为基本上我们将@SupressWarnings移动到了Class.cast() 。 这在性能和语义清晰度方面是更糟糕的版本。