5

データのストリームを解析するクラスがあります。データの各チャンクは。と呼ばれますBox。Boxesにはさまざまな種類があります。Parser箱の種類ごとに違うものが欲しいです。したがって、基本的には、Registryそれぞれに適切なパーサーを引き出すことができるようなものが必要Boxです。これが私の問題の単純化されたバージョンです：

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();
    }
}

そのコードを取得してコンパイルしようとすると、次のエラーが表示されます。

タイプGenericsTest.Parserのメソッドparse（capture＃4-of？extends GenericsTest.Box）は、引数には適用できません（capture＃5-of？extends GenericsTest.Box）

だから問題は、どうやって

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

異なり

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

？

そして、私のRegistryアプローチよりも、？の使用を必要としないより良い方法はあり@SuppressWarnings( "unchecked" )ますか？

4

2 に答える 2

4

まず、OPの質問に答えましょう。(capture#4-of ? extends GenericsTest.Box)との違いは何(capture#5-of ? extends GenericsTest.Box)ですか？

コンパイラは、渡されたクラスオブジェクトが不明な拡張のregistry.get()型を持っていることを認識します。したがって、型推論はwithの型をインスタンス化し、それが返すパーサーは同じ拡張の型を持っていると結論付けます。（コンパイラが「capture＃4-of？」のような用語を「x4のようないくつかのx4の場合」を意味するために使用しているのは残念です。）これまでのところ、とても良いです。Class<x>xBoxTget()xParser<x>xBox

一般的に起こることは、タイプがワイルドカードタイプであると推測される2つの別々の式（構文的に同一の式でさえ）があるときはいつでも、存在変数は独立してキャプチャされるということです。式がワイルドカード以外のコンテキスト（通常は別のジェネリックメソッド）で発生する場合は、これらの変数を「統合」できます。

これをチェックしてください：

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
    }
}

この：

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
    }
}

2番目の例は、ここで関連する例です。次の変換は、レジストリですでに抑制している警告を除くすべての警告を取り除きます。

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
    }
}

2番目の質問については、バリアント型（ボックス）に相当するものを介してアドホック多相を実行しようとしています。タイプの警告なしでそのようなことを達成する2つの方法があります：

  1. 質問から収集している従来のOO分解（つまり、にparseSelfメソッドを追加する）は機能せず、 APIが乱雑になりますBoxBox
  2. 少なくとも2つの欠点があるビジターパターン：
    1. のすべてのフレーバーにビジターアクセプターを追加する必要がありますBox。これは、従来のOO分解と同じ理由で問題のようです。
    2. Boxビジターインターフェイスを定義するときは、考えられるすべての種類のesを事前に知っておく必要があります
于 2012-07-15T05:42:05.467 に答える
2

ワイルドカードを使用すると、IDが「失われる」可能性があります。式でワイルドカードを使用すると、ワイルドカードを含む新しいタイプが生成される可能性がありますが、そのワイルドカードが元のワイルドカードと同じであるとはわかりません（同じであることがわかっている場合があります）。

あなたの場合の問題は、タイプにclazzワイルドカードが含まれていてclazz、2つの場所で使用されていることですが、それらが再び出会うまでに、コンパイラーはそれらが同じタイプであることを認識しなくなります。

できることは、キャプチャヘルパーを作成することです。これは、このメソッド内でワイルドカードのIDが失われるのを防ぐ、明示的な型パラメーター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);
}

無関係なことに、Registryクラスのメソッドのタイプは安全ではありません。たとえばget、どの引数にも存在しないタイプSを返すため、メソッドの呼び出し元は結果として拡張する任意のタイプを要求でき、メソッドはそのタイプを返します。Parser<T>どうすれば安全ですか？次のように書く必要があります。

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

また、このadd方法は不必要に冗長です。これは次のように簡略化できます（完全に同等）：

<T extends Box> void add( Class<T> clazz, Parser<T> parser ) {
    unsafeMap.put( clazz, parser );
}
于 2012-07-15T08:34:53.483 に答える