类的Java泛型映射<；T>；到解析器<；T>；

我有一个分析数据流的类。每个数据块称为一个

框

。有许多不同种类的

Box

es。我想为每种类型的框使用不同的

解析器。所以基本上我需要一个
注册表
或者类似的东西，让我为每个
框
拉出正确的解析器。以下是我的问题的简化版本：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class GenericsTest {
    class Box {
        private String data;

        public String getData() {
            return data;
        }
    }

    class BoxA extends Box {
        private String adata;

        BoxA( String adata ) {
            this.adata = adata;
        }

        public String getAData() {
            return adata;
        }
    }

    class BoxB extends Box {
        private String bdata;

        BoxB( String bdata ) {
            this.bdata = bdata;
        }

        public String getBData() {
            return bdata;
        }
    }

    interface Parser<T> {
        public void parse( T box );
    }

    class ParserA implements Parser<BoxA> {
        @Override
        public void parse( BoxA box ) {
            System.out.print( "BoxA: " + box.getAData() );
        }
    }

    class ParserB implements Parser<BoxB> {
        @Override
        public void parse( BoxB box ) {
            System.out.print( "BoxB: " + box.getBData() );
        }
    }

    class Registry {
        Map<Class<?>, Parser<?>> unsafeMap = new HashMap<>();

        <T extends Box, S extends Parser<T>> void add( Class<T> clazz, S parser ) {
            unsafeMap.put( clazz, parser );
        }

        <T extends Box> boolean containsKey( Class<T> clazz ) {
            return unsafeMap.containsKey( clazz );
        }

        @SuppressWarnings( "unchecked" )
        <T extends Box, S extends Parser<T>> S get( Class<T> clazz ) {
            return (S) unsafeMap.get( clazz );
        }
    }

    public void runTest() {
        Registry registry = new Registry();
        registry.add( BoxA.class, new ParserA() );
        registry.add( BoxB.class, new ParserB() );

        List<Box> boxes = new ArrayList<>();
        boxes.add( new BoxA( "Silly" ) );
        boxes.add( new BoxB( "Funny" ) );
        boxes.add( new BoxB( "Foo" ) );
        boxes.add( new BoxA( "Bar" ) );

        for ( Box box : boxes ) {
            Class<? extends Box> clazz = box.getClass();
            registry.get( clazz ).parse( clazz.cast( box ) );
        }
    }

    public static void main( String[] args ) {
        new GenericsTest().runTest();
    }
}

不同于

(capture#5-of ? extends GenericsTest.Box)

?

还有，有没有比我的
注册表
方法更好的方法不需要使用
@SuppressWarnings（“unchecked”）
。
（capture#4-of？extends GenericsTest.Box）
和
（capture#5-of？extends GenericsTest.Box）
之间有什么区别

编译器计算出传递到
registry.get（）
的类对象对于某些未知的
x
扩展
Box
具有类型
class
。因此，类型推断用
x
实例化
get（）
的类型
T
，并得出结论，它返回的解析器对于相同的
x
扩展
框
，具有类型
parser
。（不幸的是，编译器使用了“capture#4-of？”这样的术语来表示“对于某些x4这样的x4”。）到目前为止，一切都很好

通常情况下，只要有两个单独的表达式（即使是语法相同的表达式），其类型被推断为通配符类型，存在变量就会被独立捕获。如果表达式出现在非通配符上下文（通常是单独的泛型方法）中，则可以“统一”这些变量

看看这个：

public class WildcardTest {
    private < T > void two( Class< T > t1, Class< T > t2 ) {}
    private < T > void one( Class< T > t1 ) {
        two( t1, t1 ); // compiles; no wildcards involved
    }
    private void blah() {
        two( WildcardTest.class, WildcardTest.class ); // compiles
        one( WildcardTest.class );                     // compiles

        Class< ? extends WildcardTest > wc = this.getClass();
        two( wc, wc ); // won't compile! (capture#2 and capture#3)
        one( wc );     // compiles
    }
}

公共类通配符测试{
私有voidtwo（类t1，类t2）{
私有无效一级（类t1）{
两个（t1，t1）；//编译；不涉及通配符
}
私人空间{
两个（WildcardTest.class，WildcardTest.class）；//编译
一个（WildcardTest.class）；//编译
类<？扩展通配符测试>wc=this.getClass（）；
两个（wc，wc）；//无法编译！（捕获#2和捕获#3）
一（wc）；//编译
}
}

这是：

public class WildcardTest {
    interface Thing< T > {
        void consume( T t );
    }
    private < T > Thing< T > make( Class< T > c ) {
        return new Thing< T >() {
            @Override public void consume(T t) {}
        };
    }
    private < T > void makeAndConsume( Object t, Class< T > c ) {
        make( c ).consume( c.cast( t ) );
    }

    private void blah() {
        Class< ? extends WildcardTest > wc = this.getClass();
        make( wc ).consume( wc.cast( this ) ); // won't compile! (capture#2 and capture#3)
        makeAndConsume( this, wc );            // compiles
    }
}

公共类通配符测试{
接口事物{
空耗（T）；
}
私人物品制造（类别c）{
返回新事物（）{
@重写公共无效消耗（T）{}
};
}
私有void makeAndConsume（对象T，类c）{
制造（c）、消耗（c、铸造（t））；
}
私人空间{
类<？扩展通配符测试>wc=this.getClass（）；
make（wc.consume（wc.cast（this））；//不会编译！（捕获2和捕获3）
makeAndConsume（this，wc）；//编译
}
}

第二个例子就是这里的相关例子。以下转换将消除除已在注册表中抑制的警告之外的所有警告：

private < T extends Box > void getParserAndParse(
    Registry registry, Class< T > clazz, Object box
) {
    registry.get( clazz ).parse( clazz.cast( box ) );
}
public void runTest() {
    Registry registry = new Registry();
    registry.add( BoxA.class, new ParserA() );
    registry.add( BoxB.class, new ParserB() );

    List<Box> boxes = new ArrayList< Box >();
    boxes.add( new BoxA( "Silly" ) );
    boxes.add( new BoxB( "Funny" ) );
    boxes.add( new BoxB( "Foo" ) );
    boxes.add( new BoxA( "Bar" ) );

    for ( Box box : boxes ) {
        Class< ? extends Box > clazz = box.getClass();
        getParserAndParse( registry, clazz, box ); // compiles
    }
}

privatevoid getParserAndParse(
注册表，类clazz，对象框
) {
registry.get（clazz.parse）（clazz.cast（box））；
}
公共无效运行测试（）{
注册表=新注册表（）；
add（BoxA.class，new ParserA（））；
add（BoxB.class，newparserb（））；
列表框=新的ArrayList（）；
框。添加（新框A（“傻”）；
框。添加（新框B（“有趣”）；
框。添加（新框B（“Foo”）；
方框。添加（新方框A（“条形”）；
用于（盒子：盒子）{
类<？扩展框>clazz=Box.getClass（）；
getParserAndParse（注册表、分类、框）；//编译
}
}

至于您的第二个问题，您正试图通过相当于一个变体类型（框）来执行特殊多态性。有两种方法可以在没有类型警告的情况下实现此目的：

经典的OO分解（即，将
parseSelf
方法添加到
Box
），我从问题中收集到的方法不适用于您，并且会使
Box
API变得混乱
访问者模式至少有两个缺点：
您必须在所有风格的
框中添加访问者接受者，这似乎是一个问题，原因与经典的OO分解相同

在定义访问者界面时，您必须事先了解所有可能的
框
es类型

使用通配符时，它们可能会“丢失”其标识。一旦在表达式中使用了通配符，它可能会生成一个包含通配符的新类型，但不知道该通配符与原始通配符相同（您可能知道它们是相同的）

您案例中的问题是
clazz
的类型包含一个通配符，并且
clazz
在两个位置使用，但是当它们再次相遇时，编译器不再知道它们是同一类型

您可以做的是编写一个capture helper，这是一个带有显式类型参数T的私有泛型方法，它可以防止通配符的标识在该方法中丢失。由于捕获的原因，您仍然可以将包含通配符的变量传递到此方法中

private <T extends Box> void helperMethod(Class<T> clazz, Box box, Registry registry) {
    registry.get( clazz ).parse( clazz.cast( box ) );
}

// then you use it like in the place you had before:
for ( Box box : boxes ) {
    Class<? extends Box> clazz = box.getClass();
    helperMethod(clazz, box, registry);
}

另外，
add
方法不必要地冗长。可简化为（完全等效）：

void添加（类clazz，解析器）{
unsafeMap.put（clazz，解析器）；
}
您有getAData和getBData方法，如果它们是基类中的getData（），则应该有一个简单的解决方案Box@Serkan，这是一个过于简化的案例，只是为了说明问题。我无法控制Box类，它们都比一个
getData（）
方法复杂得多。我应该在问题中说明这一点……感谢您的建议，我将按照建议清理注册表，不确定
S扩展解析器的方式/原因
private <T extends Box> void helperMethod(Class<T> clazz, Box box, Registry registry) {
    registry.get( clazz ).parse( clazz.cast( box ) );
}

// then you use it like in the place you had before:
for ( Box box : boxes ) {
    Class<? extends Box> clazz = box.getClass();
    helperMethod(clazz, box, registry);
}

@SuppressWarnings( "unchecked" )
<T extends Box> Parser<T> get( Class<T> clazz ) {
    return (Parser<T>) unsafeMap.get( clazz );
}

<T extends Box> void add( Class<T> clazz, Parser<T> parser ) {
    unsafeMap.put( clazz, parser );
}