0

我似乎让自己陷入了一个快乐的转折中。我的情况如下：

public class Parameter<T> {
   public Parameter(String value, Verifier<T> verif){
       //stuff, lots of stuff!
   }
}

public interface Verifier<T>{
   //definition
}

public enum StringVerif implements Verifiier<String>{
    INSTANCE;
    //some static functions on my singleton
}

public abstract class ParamFactory{
    private static ArrayDeque<Verifier<?>> verifList...
    ...
    for(Verifier<?> ver : verifList){
        if(ver.isapplicable(someData){
            //now I'm stuck!
        }
    }
}

简而言之，我需要做的是根据通过测试的验证器的类型创建正确的类型化参数。例如，对于验证者，我需要能够创建参数，对于验证者，我需要能够创建参数。然后这些参数将被发送到另一个集合。本质上它是一个带有验证器和处理器模块的可扩展工厂，可以根据需要解析不同的类型参数，非常强大。问题是我不仅要通过反射获得泛型类型，还要从这种类型创建泛型类型。

关于从哪里开始做这件事的任何想法？很久没有深入研究泛型了

4

2 回答 2

0

原来我一直在错误地接近这个。正确的技术是每个验证器都负责调用构造函数，并且由于每个验证器已经知道它自己的类型，因此只需几行代码。它在某种程度上打破了工厂概念，除非您认为这些验证器真正成为工厂的组成部分

public interface Verifier<T>{
   //definition
   public Err buildParaList(String value, Single<Parameter<?>> output);
}

public enum StringVerif implements Verifiier<String>{
    INSTANCE;
    //some static functions on my singleton
    @Override
    public Err buildParaList(String value, Single<Parameter<?>> output){
        output.elem = new Parameter<String>(value, INSTANCE);
        return Err.success();
    }
}
public abstract class ParamFactory{
    private static ArrayDeque<Verifier<?>> verifList...
    ...
    for(Verifier<?> ver : verifList){
        if(ver.isapplicable(someData){
            Single<Parameter<?>> param = new Single<Parameter<?>>();
            Err e = ver.buildParameter(value, param);
            //checks
            paramList.add(param.elem);
        }
    }
}

好的，我的实际用法比示例更复杂，但它仍然有效。我之前真的应该想到这一点，我想我昨晚没那么警觉。感谢您的支持。

于 2012-06-26T04:27:25.817 回答
0

扩展我之前关于HLists 的评论：（这对于评论来说太大了，因此将其发布为答案。）

我在代码示例中使用了 Scala，因为它对正在讨论的想法有很好的支持。所有代码示例都在控制台输入。

当你有一个 type 的对象Dog和另一个 type 的对象时Tiger，如果你把它们放在同一个协变列表中，结果列表的类型List[Animal]将Animal是它们共同的超类型。因为这个列表是同质的，所以原始类型丢失了。请注意以下列表的推断类型：

scala> class Animal
defined class Animal

scala> class Dog extends Animal
defined class Dog

scala> class Tiger extends Animal
defined class Tiger

scala> List(new Tiger, new Dog)
res0: List[Animal] = List(Tiger@a32604, Dog@1150b68)

同样Verifier[Int]，Verifier[String]当放入单个同质列表时，将采用 type Verifier[Any]。（在 Scala 中，Any类位于对象层次结构的顶部。）请参阅：

scala> class Verifier[+T](value: T) {
     |   override def toString = "Verifier(" + value.toString + ")"
     | }
defined class Verifier

scala> List(new Verifier(6), new Verifier("hello"))
res1: List[Verifier[Any]] = List(Verifier(6), Verifier(hello))

如果要保留静态类型，并将它们用于以后的计算，则应使用异构列表。或HList简称。

scala> new Verifier(6) :: new Verifier("hello") :: HNil
res2: shapeless.::[Verifier[Int],shapeless.::[Verifier[java.lang.String],shapeless.HNil]] = Verifier(6) :: Verifier(hello) :: HNil

以下是多态映射的工作原理：

scala> class Parameter[+T](value: String, verif: Verifier[T]) {
     |   override def toString = "P(" + value + ", " + verif + ")"
     | }
defined class Parameter

scala> object mapper extends (Verifier ~> Parameter) {
     |   def apply[A](v: Verifier[A]): Parameter[A] = new Parameter("k", v)
     | }
defined module mapper

scala> res2 map mapper
res3: mapper.Out = P(k, Verifier(6)) :: P(k, Verifier(hello)) :: HNil

我们保留了类型参数，并使用给定的更高级别的函数作用于列表的每个元素。这让我们返回了 a HListof Parameters，其中保留了正确的类型。

请注意，HList可以在 Java 中实现的概念，但是您不能在结构上定义许多有用的操作。Java 的类型系统无法做到这一点。如果您有兴趣，这里有一篇关于该主题的精彩文章。

希望这在某种程度上有所帮助。

于 2012-06-26T06:15:30.193 回答