ResolvableType (Spring Framework API)

java.lang.ObjectSE
- org.springframework.core.ResolvableType

実装されたすべてのインターフェース:
SerializableSE
```
public class ResolvableType
extends ObjectSE
implements SerializableSE
```
Java TypeSE をカプセル化し、supertypes、interfaces、generic parameters へのアクセスを提供し、最終的に resolve から ClassSE への機能を提供します。
ResolvableType は、フィールド、メソッドパラメーター、メソッドの戻り型、またはクラスから取得できます。このクラスのほとんどのメソッドは、それ自体が ResolvableType を返し、簡単なナビゲーションを可能にします。例：
```
 private HashMap<Integer, List<String>> myMap;

 public void example() {
     ResolvableType t = ResolvableType.forField(getClass().getDeclaredField("myMap"));
     t.getSuperType(); // AbstractMap<Integer, List<String>>
     t.asMap(); // Map<Integer, List<String>>
     t.getGeneric(0).resolve(); // Integer
     t.getGeneric(1).resolve(); // List
     t.getGeneric(1); // List<String>
     t.resolveGeneric(1, 0); // String
 }
 
```
導入:
4.0
作成者:
Phillip Webb, Juergen Hoeller, Stephane Nicoll
関連事項:
forField(Field), forMethodParameter(Method, int), forMethodReturnType(Method), forConstructorParameter(Constructor, int), forClass(Class), forType(Type), forInstance(Object), ResolvableTypeProvider, 直列化された形式

フィールドサマリー
フィールド
修飾子と型フィールドと説明
static ResolvableType NONE
ResolvableType は、使用できる値がない場合に返されます。

フィールド
修飾子と型	フィールドと説明
`static ResolvableType`	`NONE` `ResolvableType` は、使用できる値がない場合に返されます。

メソッドのサマリー

すべてのメソッド静的メソッドインスタンスメソッド具象メソッド
修飾子と型	メソッドと説明
`ResolvableType`	`as(ClassSE<?> type)` この型を指定されたクラスの `ResolvableType` として返します。
`ResolvableType`	`asCollection()` この型を解決可能な `Collection`SE 型として返す簡易メソッド。
`ResolvableType`	`asMap()` この型を解決可能な `Map`SE 型として返す簡易メソッド。
`static void`	`clearCache()` 内部 `ResolvableType`/`SerializableTypeWrapper` キャッシュをクリアします。
`boolean`	`equals(ObjectSE other)`
`static ResolvableType`	`forArrayComponent(ResolvableType componentType)` `ResolvableType` を指定された `componentType` の配列として返します。
`static ResolvableType`	`forClass(ClassSE<?> clazz)` 割り当て可能性チェックのための完全な汎用型情報を使用して、指定された `Class`SE の `ResolvableType` を返します。
`static ResolvableType`	`forClass(ClassSE<?> baseType, ClassSE<?> implementationClass)` 特定の実装クラスを使用して、指定された基本型（インターフェースまたは基本クラス）の `ResolvableType` を返します。
`static ResolvableType`	`forClassWithGenerics(ClassSE<?> clazz, ClassSE<?>... generics)` 事前宣言されたジェネリクスを使用して、指定された `Class`SE の `ResolvableType` を返します。
`static ResolvableType`	`forClassWithGenerics(ClassSE<?> clazz, ResolvableType... generics)` 事前宣言されたジェネリクスを使用して、指定された `Class`SE の `ResolvableType` を返します。
`static ResolvableType`	`forConstructorParameter(ConstructorSE<?> constructor, int parameterIndex)` 指定された `Constructor`SE パラメーターの `ResolvableType` を返します。
`static ResolvableType`	`forConstructorParameter(ConstructorSE<?> constructor, int parameterIndex, ClassSE<?> implementationClass)` 指定された実装で、指定された `Constructor`SE パラメーターの `ResolvableType` を返します。
`static ResolvableType`	`forField(FieldSE field)` 指定された `Field`SE の `ResolvableType` を返します。
`static ResolvableType`	`forField(FieldSE field, ClassSE<?> implementationClass)` 特定の実装で、指定された `Field`SE の `ResolvableType` を返します。
`static ResolvableType`	`forField(FieldSE field, int nestingLevel)` 指定されたネストレベルで、指定された `Field`SE の `ResolvableType` を返します。
`static ResolvableType`	`forField(FieldSE field, int nestingLevel, ClassSE<?> implementationClass)` 指定された `Field`SE の `ResolvableType` を、指定された実装と指定されたネストレベルで返します。
`static ResolvableType`	`forField(FieldSE field, ResolvableType implementationType)` 特定の実装で、指定された `Field`SE の `ResolvableType` を返します。
`static ResolvableType`	`forInstance(ObjectSE instance)` 指定されたインスタンスの `ResolvableType` を返します。
`static ResolvableType`	`forMethodParameter(MethodSE method, int parameterIndex)` 指定された `Method`SE パラメーターの `ResolvableType` を返します。
`static ResolvableType`	`forMethodParameter(MethodSE method, int parameterIndex, ClassSE<?> implementationClass)` 指定された実装で、指定された `Method`SE パラメーターの `ResolvableType` を返します。
`static ResolvableType`	`forMethodParameter(MethodParameter methodParameter)` 指定された `MethodParameter` の `ResolvableType` を返します。
`static ResolvableType`	`forMethodParameter(MethodParameter methodParameter, ResolvableType implementationType)` 特定の実装型で指定された `MethodParameter` の `ResolvableType` を返します。
`static ResolvableType`	`forMethodParameter(MethodParameter methodParameter, TypeSE targetType)` 指定された `MethodParameter` の `ResolvableType` を返し、ターゲット型をオーバーライドして、特定の型で解決します。
`static ResolvableType`	`forMethodReturnType(MethodSE method)` 指定された `Method`SE 戻り値の型の `ResolvableType` を戻します。
`static ResolvableType`	`forMethodReturnType(MethodSE method, ClassSE<?> implementationClass)` 指定された `Method`SE 戻り値の型の `ResolvableType` を戻します。
`static ResolvableType`	`forRawClass(ClassSE<?> clazz)` 指定された `Class`SE の `ResolvableType` を返し、生のクラスに対してのみ割り当て可能性チェックを実行します（これはラッパーとして機能する `Class.isAssignableFrom(java.lang.Class<?>)`SE に類似しています）。
`static ResolvableType`	`forType(ParameterizedTypeReference<?> typeReference)` 指定された `ParameterizedTypeReference` の `ResolvableType` を返します。
`static ResolvableType`	`forType(TypeSE type)` 指定された `Type`SE の `ResolvableType` を返します。
`static ResolvableType`	`forType(TypeSE type, ResolvableType owner)` 指定された所有者型に基づく指定された `Type`SE の `ResolvableType` を返します。
`ResolvableType`	`getComponentType()` 配列のコンポーネント型を表す ResolvableType を返します。この型が配列を表していない場合は `NONE` を返します。
`ResolvableType`	`getGeneric(int... indexes)` 指定されたインデックスのジェネリクスパラメーターを表す `ResolvableType` を返します。
`ResolvableType[]`	`getGenerics()` この型のジェネリクスパラメーターを表す `ResolvableTypes` の配列を返します。
`ResolvableType[]`	`getInterfaces()` この型によって実装される直接インターフェースを表す `ResolvableType` 配列を返します。
`ResolvableType`	`getNested(int nestingLevel)` 指定されたネストレベルの `ResolvableType` を返します。
`ResolvableType`	`getNested(int nestingLevel, MapSE<IntegerSE, IntegerSE> typeIndexesPerLevel)` 指定されたネストレベルの `ResolvableType` を返します。
`ClassSE<?>`	`getRawClass()` 管理されている基になる Java `Class`SE を返します（利用可能な場合）。それ以外の場合は `null`。
`ObjectSE`	`getSource()` 解決可能な型の基になるソースを返します。
`ResolvableType`	`getSuperType()` この型の直接のスーパー型を表す `ResolvableType` を返します。
`TypeSE`	`getType()` 管理されている下層の Java `Type`SE を返します。
`boolean`	`hasGenerics()` この型にジェネリクスパラメーターが含まれている場合は `true` を返します。
`int`	`hashCode()`
`boolean`	`hasUnresolvableGenerics()` 基になる型に解決できないジェネリクスがあるかどうかを判断します。型自体の解決できない型変数を使用するか、ジェネリクスインターフェースをそのままの方法で実装します。
`boolean`	`isArray()` この型が配列を表すクラスに解決される場合、`true` を返します。
`boolean`	`isAssignableFrom(ClassSE<?> other)` この `ResolvableType` が指定された他の型から割り当て可能かどうかを判別します。
`boolean`	`isAssignableFrom(ResolvableType other)` この `ResolvableType` が指定された他の型から割り当て可能かどうかを判別します。
`boolean`	`isInstance(ObjectSE obj)` 指定されたオブジェクトがこの `ResolvableType` のインスタンスであるかどうかを判別します。
`ClassSE<?>`	`resolve()` この型を `Class`SE に解決し、型を解決できない場合は `null` を返します。
`ClassSE<?>`	`resolve(ClassSE<?> fallback)` この型を `Class`SE に解決し、型を解決できない場合は指定された `fallback` を返します。
`ClassSE<?>`	`resolveGeneric(int... indexes)` `get` と `resolve` が特定のジェネリクスパラメーターを使用する便利なメソッド。
`ClassSE<?>[]`	`resolveGenerics()` `get` および `resolve` ジェネリクスパラメーターになる簡易メソッド。
`ClassSE<?>[]`	`resolveGenerics(ClassSE<?> fallback)` 型を解決できない場合に指定された `fallback` を使用して、`get` および `resolve` ジェネリクスパラメーターを処理する簡易メソッド。
`ClassSE<?>`	`toClass()` この型を解決された `Class` として返し、特定のクラスを解決できない場合は `Object`SE にフォールバックします。
`StringSE`	`toString()` この型の文字列表現を完全に解決された形式で返します（すべてのジェネリクスパラメーターを含む）。

クラス java.lang.ObjectSE から継承されたメソッド
cloneSE, finalizeSE, getClassSE, notifySE, notifyAllSE, waitSE, waitSE, waitSE

- フィールドの詳細
  - NONE
```
public static final ResolvableType NONE
```
    ResolvableType は、使用可能な値がない場合に返されます。NONE は null よりも優先的に使用されるため、複数のメソッド呼び出しを安全にチェーンできます。
- メソッドの詳細
  - getType
```
public TypeSE getType()
```
    管理されている下層の Java TypeSE を返します。
  - getRawClass
```
@Nullable
public ClassSE<?> getRawClass()
```
    管理されている基になる Java ClassSE を返します（利用可能な場合）。それ以外の場合は null。
  - getSource
```
public ObjectSE getSource()
```
    解決可能な型の基になるソースを返します。ResolvableType の構築方法に応じて、FieldSE、MethodParameter、TypeSE を返します。NONE 定数を除いて、このメソッドは null を返しません。このメソッドは主に、代替の JVM 言語が提供する可能性がある追加の型情報またはメタデータへのアクセスを提供するためのものです。
  - toClass
```
public ClassSE<?> toClass()
```
    この型を解決された Class として返し、特定のクラスを解決できない場合は ObjectSE にフォールバックします。
    戻り値:
    解決された ClassSE または Object フォールバック
    導入:
    5.1
    関連事項:
    getRawClass(), resolve(Class)
  - isInstance
```
public boolean isInstance(@Nullable
                          ObjectSE obj)
```
    指定されたオブジェクトがこの ResolvableType のインスタンスであるかどうかを判別します。
    パラメーター:
    obj - チェックするオブジェクト
    導入:
    4.2
    関連事項:
    isAssignableFrom(Class)
  - isAssignableFrom
```
public boolean isAssignableFrom(ClassSE<?> other)
```
    この ResolvableType が指定された他の型から割り当て可能かどうかを判別します。
    パラメーター:
    other - チェックする型 (Class として)
    導入:
    4.2
    関連事項:
    isAssignableFrom(ResolvableType)
  - isAssignableFrom
```
public boolean isAssignableFrom(ResolvableType other)
```
    この ResolvableType が指定された他の型から割り当て可能かどうかを判別します。
    resolved Class が指定された型の assignable fromSE であるかどうか、およびすべての generics が割り当て可能かどうかを考慮して、Java コンパイラーと同じ規則に従うことを試みます。
    パラメーター:
    other - チェックする型 (ResolvableType として)
    戻り値:
    指定された他の型をこの ResolvableType に割り当てることができる場合は true。それ以外の場合は false
  - isArray
```
public boolean isArray()
```
    この型が配列を表すクラスに解決される場合、true を返します。
    関連事項:
    getComponentType()
  - getComponentType
```
public ResolvableType getComponentType()
```
    配列のコンポーネント型を表す ResolvableType を返します。この型が配列を表していない場合は NONE を返します。
    関連事項:
    isArray()
  - asCollection
```
public ResolvableType asCollection()
```
    この型を解決可能な CollectionSE 型として返す簡易メソッド。
    この型が CollectionSE を実装または拡張しない場合、NONE を返します。
    関連事項:
    as(Class), asMap()
  - asMap
```
public ResolvableType asMap()
```
    この型を解決可能な MapSE 型として返す簡易メソッド。
    この型が MapSE を実装または拡張しない場合、NONE を返します。
    関連事項:
    as(Class), asCollection()
  - as
```
public ResolvableType as(ClassSE<?> type)
```
    この型を指定されたクラスの ResolvableType として返します。supertype および interface 階層を検索して一致を見つけ、この型が指定されたクラスを実装または拡張していない場合は NONE を返します。
    パラメーター:
    type - 必要な型 (通常狭くなります)
    戻り値:
    このオブジェクトを指定された型として表す ResolvableType、またはその型として解決できない場合は NONE
    関連事項:
    asCollection(), asMap(), getSuperType(), getInterfaces()
  - getSuperType
```
public ResolvableType getSuperType()
```
    この型の直接のスーパー型を表す ResolvableType を返します。
    使用可能なスーパー型がない場合、このメソッドは NONE を返します。
    メモ: 結果の ResolvableType インスタンスは SerializableSE ではない場合があります。
    関連事項:
    getInterfaces()
  - getInterfaces
```
public ResolvableType[] getInterfaces()
```
    この型によって実装される直接インターフェースを表す ResolvableType 配列を返します。この型がインターフェースを実装していない場合、空の配列が返されます。
    メモ: 結果の ResolvableType インスタンスは SerializableSE ではない場合があります。
    関連事項:
    getSuperType()
  - hasGenerics
```
public boolean hasGenerics()
```
    この型にジェネリクスパラメーターが含まれている場合は true を返します。
    関連事項:
    getGeneric(int...), getGenerics()
  - hasUnresolvableGenerics
```
public boolean hasUnresolvableGenerics()
```
    基になる型に解決できないジェネリクスがあるかどうかを判断します。型自体の解決できない型変数を使用するか、ジェネリクスインターフェースをそのままの方法で実装します。つまり、そのインターフェースの型変数を置き換えません。結果は、これらの 2 つのシナリオでのみ true になります。
  - getNested
```
public ResolvableType getNested(int nestingLevel)
```
    指定されたネストレベルの ResolvableType を返します。
    詳細は getNested(int, Map) を参照してください。
    パラメーター:
    nestingLevel - 入れ子レベル
    戻り値:
    ResolvableType 型、または #NONE
  - getNested
```
public ResolvableType getNested(int nestingLevel,
                                @Nullable
                                MapSE<IntegerSE,IntegerSE> typeIndexesPerLevel)
```
    指定されたネストレベルの ResolvableType を返します。
    ネストレベルは、返されるべき特定のジェネリクスパラメーターを指します。ネストレベルが 1 の場合はこの型、2 の場合は最初のネストされたジェネリクス、3 の場合は 2 番目のジェネリクスとなります。例: 与えられた List<Set<Integer>> のレベル 1 は List を、レベル 2 は Set を、レベル 3 は Integer を参照します。
    typeIndexesPerLevel マップは、指定されたレベルの特定のジェネリクスを参照するために使用できます。例: インデックス 0 は Map キーを参照します。一方、1 は値を参照します。マップに特定のレベルの値が含まれていない場合は、最後のジェネリクスが使用されます（Map 値など）。
    ネストレベルは、配列型にも適用されます。たとえば、String[] の場合、ネストレベル 2 は String を参照します。
    型が contain ジェネリクスでない場合、supertype 階層が考慮されます。
    パラメーター:
    nestingLevel - 現在の型の場合は 1、最初のネストされたジェネリクスの場合は 2、2 番目の場合は 3 というようにインデックスが付けられた、必要なネストレベル
    typeIndexesPerLevel - 指定されたネストレベルの汎用インデックスを含むマップ (null の場合があります)
    戻り値:
    ネストされたレベルの ResolvableType、または NONE
  - getGeneric
```
public ResolvableType getGeneric(@Nullable
                                 int... indexes)
```
    指定されたインデックスのジェネリクスパラメーターを表す ResolvableType を返します。インデックスはゼロベースです。たとえば、型 Map<Integer, List<String>> を指定すると、getGeneric(0) は Integer にアクセスします。ネストされたジェネリクスには、複数のインデックスを指定してアクセスできます。たとえば、getGeneric(1, 0) はネストされた List から String にアクセスします。便宜上、インデックスが指定されていない場合、最初のジェネリクスが返されます。
    指定されたインデックスで使用可能なジェネリクスがない場合、NONE が返されます。
    パラメーター:
    indexes - ジェネリクスパラメーターを参照するインデックス (最初のジェネリクスを返すために省略できます)
    戻り値:
    指定されたジェネリクスの ResolvableType、または NONE
    関連事項:
    hasGenerics(), getGenerics(), resolveGeneric(int...), resolveGenerics()
  - getGenerics
```
public ResolvableType[] getGenerics()
```
    この型のジェネリクスパラメーターを表す ResolvableTypes の配列を返します。ジェネリクスがない場合、空の配列が返されます。特定のジェネリクスにアクセスする必要がある場合は、getGeneric(int...) メソッドを使用することを検討してください。これにより、ネストされたジェネリクスへのアクセスが可能になり、IndexOutOfBoundsExceptions から保護されます。
    戻り値:
    ジェネリクスパラメーターを表す ResolvableTypes の配列 (非 null)
    関連事項:
    hasGenerics(), getGeneric(int...), resolveGeneric(int...), resolveGenerics()
  - resolveGenerics
```
public ClassSE<?>[] resolveGenerics()
```
    get および resolve ジェネリクスパラメーターになる簡易メソッド。
    戻り値:
    解決されたジェネリクスパラメーターの配列 (結果の配列は null にはなりませんが、null 要素が含まれる場合があります。})
    関連事項:
    getGenerics(), resolve()
  - resolveGenerics
```
public ClassSE<?>[] resolveGenerics(ClassSE<?> fallback)
```
    型を解決できない場合に指定された fallback を使用して、get および resolve ジェネリクスパラメーターを処理する簡易メソッド。
    パラメーター:
    fallback - 解決が失敗した場合に使用するフォールバッククラス
    戻り値:
    解決されたジェネリクスパラメーターの配列
    関連事項:
    getGenerics(), resolve()
  - resolveGeneric
```
@Nullable
public ClassSE<?> resolveGeneric(int... indexes)
```
    get と resolve が特定のジェネリクスパラメーターを使用する便利なメソッド。
    パラメーター:
    indexes - ジェネリクスパラメーターを参照するインデックス (最初のジェネリクスを返すために省略できます)
    戻り値:
    解決済みの ClassSE または null
    関連事項:
    getGeneric(int...), resolve()
  - resolve
```
@Nullable
public ClassSE<?> resolve()
```
    この型を ClassSE に解決し、型を解決できない場合は null を返します。このメソッドは、直接解決が失敗した場合に TypeVariablesSE および WildcardTypesSE の境界を考慮します。ただし、Object.class の境界は無視されます。
    このメソッドが null 以外の Class を返し、hasGenerics() が false を返す場合、指定された型はプレーン Class を効果的にラップし、必要に応じてプレーン Class 処理を可能にします。
    戻り値:
    解決された ClassSE、または解決できない場合は null
    関連事項:
    resolve(Class), resolveGeneric(int...), resolveGenerics()
  - resolve
```
public ClassSE<?> resolve(ClassSE<?> fallback)
```
    この型を ClassSE に解決し、型を解決できない場合は指定された fallback を返します。このメソッドは、直接解決が失敗した場合に TypeVariablesSE および WildcardTypesSE の境界を考慮します。ただし、Object.class の境界は無視されます。
    パラメーター:
    fallback - 解決が失敗した場合に使用するフォールバッククラス
    戻り値:
    解決された ClassSE または fallback
    関連事項:
    resolve(), resolveGeneric(int...), resolveGenerics()
  - equals
```
public boolean equals(@Nullable
                      ObjectSE other)
```
    オーバーライド:
    クラス ObjectSE の equalsSE
  - hashCode
```
public int hashCode()
```
    オーバーライド:
    クラス ObjectSE の hashCodeSE
  - toString
```
public StringSE toString()
```
    この型の文字列表現を完全に解決された形式で返します（すべてのジェネリクスパラメーターを含む）。
    オーバーライド:
    クラス ObjectSE の toStringSE
  - forClass
```
public static ResolvableType forClass(@Nullable
                                      ClassSE<?> clazz)
```
    割り当て可能性チェックのための完全な汎用型情報を使用して、指定された ClassSE の ResolvableType を返します。
    次に例を示します: ResolvableType.forClass(MyArrayList.class).
    パラメーター:
    clazz - 内省するクラス (null は、ここでの典型的な使用例では、Object.class と意味的に同等です。)
    戻り値:
    指定されたクラスの ResolvableType
    関連事項:
    forClass(Class, Class), forClassWithGenerics(Class, Class...)
  - forRawClass
```
public static ResolvableType forRawClass(@Nullable
                                         ClassSE<?> clazz)
```
    指定された ClassSE の ResolvableType を返し、生のクラスに対してのみ割り当て可能性チェックを実行します（これはラッパーとして機能する Class.isAssignableFrom(java.lang.Class<?>)SE に類似しています）。
    次に例を示します: ResolvableType.forRawClass(List.class).
    パラメーター:
    clazz - 内省するクラス (null は、ここでの典型的な使用例では、Object.class と意味的に同等です。)
    戻り値:
    指定されたクラスの ResolvableType
    導入:
    4.2
    関連事項:
    forClass(Class), getRawClass()
  - forClass
```
public static ResolvableType forClass(ClassSE<?> baseType,
                                      ClassSE<?> implementationClass)
```
    特定の実装クラスを使用して、指定された基本型（インターフェースまたは基本クラス）の ResolvableType を返します。
    次に例を示します: ResolvableType.forClass(List.class, MyArrayList.class).
    パラメーター:
    baseType - 基本型 (null であってはなりません)
    implementationClass - 実装クラス
    戻り値:
    指定された実装クラスに基づく、指定された基本型の ResolvableType
    関連事項:
    forClass(Class), forClassWithGenerics(Class, Class...)
  - forClassWithGenerics
```
public static ResolvableType forClassWithGenerics(ClassSE<?> clazz,
                                                  ClassSE<?>... generics)
```
    事前宣言されたジェネリクスを使用して、指定された ClassSE の ResolvableType を返します。
    パラメーター:
    clazz - イントロスペクトするクラス（またはインターフェース）
    generics - クラスのジェネリクス
    戻り値:
    特定のクラスとジェネリクスの ResolvableType
    関連事項:
    forClassWithGenerics(Class, ResolvableType...)
  - forClassWithGenerics
```
public static ResolvableType forClassWithGenerics(ClassSE<?> clazz,
                                                  ResolvableType... generics)
```
    事前宣言されたジェネリクスを使用して、指定された ClassSE の ResolvableType を返します。
    パラメーター:
    clazz - イントロスペクトするクラス（またはインターフェース）
    generics - クラスのジェネリクス
    戻り値:
    特定のクラスとジェネリクスの ResolvableType
    関連事項:
    forClassWithGenerics(Class, Class...)
  - forInstance
```
public static ResolvableType forInstance(ObjectSE instance)
```
    指定されたインスタンスの ResolvableType を返します。インスタンスは一般的な情報を伝えませんが、ResolvableTypeProvider を実装する場合、Class instance に基づく単純なものよりも正確な ResolvableType を使用できます。
    パラメーター:
    instance - インスタンス
    戻り値:
    指定されたインスタンスの ResolvableType
    導入:
    4.2
    関連事項:
    ResolvableTypeProvider
  - forField
```
public static ResolvableType forField(FieldSE field)
```
    指定された FieldSE の ResolvableType を返します。
    パラメーター:
    field - ソースフィールド
    戻り値:
    指定されたフィールドの ResolvableType
    関連事項:
    forField(Field, Class)
  - forField
```
public static ResolvableType forField(FieldSE field,
                                      ClassSE<?> implementationClass)
```
    特定の実装で、指定された FieldSE の ResolvableType を返します。
    このバリアントは、フィールドを宣言するクラスに、実装クラスが満たすジェネリクスパラメーター変数が含まれている場合に使用します。
    パラメーター:
    field - ソースフィールド
    implementationClass - 実装クラス
    戻り値:
    指定されたフィールドの ResolvableType
    関連事項:
    forField(Field)
  - forField
```
public static ResolvableType forField(FieldSE field,
                                      @Nullable
                                      ResolvableType implementationType)
```
    特定の実装で、指定された FieldSE の ResolvableType を返します。
    このバリアントは、フィールドを宣言するクラスに、実装型によって満たされるジェネリクスパラメーター変数が含まれている場合に使用します。
    パラメーター:
    field - ソースフィールド
    implementationType - 実装型
    戻り値:
    指定されたフィールドの ResolvableType
    関連事項:
    forField(Field)
  - forField
```
public static ResolvableType forField(FieldSE field,
                                      int nestingLevel)
```
    指定されたネストレベルで、指定された FieldSE の ResolvableType を返します。
    パラメーター:
    field - ソースフィールド
    nestingLevel - 入れ子レベル (外部レベルの場合は 1。ネストされたジェネリクス型の場合は 2。等)
    関連事項:
    forField(Field)
  - forField
```
public static ResolvableType forField(FieldSE field,
                                      int nestingLevel,
                                      @Nullable
                                      ClassSE<?> implementationClass)
```
    指定された FieldSE の ResolvableType を、指定された実装と指定されたネストレベルで返します。
    このバリアントは、フィールドを宣言するクラスに、実装クラスが満たすジェネリクスパラメーター変数が含まれている場合に使用します。
    パラメーター:
    field - ソースフィールド
    nestingLevel - 入れ子レベル (外部レベルの場合は 1。ネストされたジェネリクス型の場合は 2。等)
    implementationClass - 実装クラス
    戻り値:
    指定されたフィールドの ResolvableType
    関連事項:
    forField(Field)
  - forConstructorParameter
```
public static ResolvableType forConstructorParameter(ConstructorSE<?> constructor,
                                                     int parameterIndex)
```
    指定された ConstructorSE パラメーターの ResolvableType を返します。
    パラメーター:
    constructor - ソースコンストラクター (null であってはなりません)
    parameterIndex - パラメーターインデックス
    戻り値:
    指定されたコンストラクターパラメーターの ResolvableType
    関連事項:
    forConstructorParameter(Constructor, int, Class)
  - forConstructorParameter
```
public static ResolvableType forConstructorParameter(ConstructorSE<?> constructor,
                                                     int parameterIndex,
                                                     ClassSE<?> implementationClass)
```
    指定された実装で、指定された ConstructorSE パラメーターの ResolvableType を返します。コンストラクターを宣言するクラスに、実装クラスが満たすジェネリクスパラメーター変数が含まれている場合は、このバリアントを使用します。
    パラメーター:
    constructor - ソースコンストラクター (null であってはなりません)
    parameterIndex - パラメーターインデックス
    implementationClass - 実装クラス
    戻り値:
    指定されたコンストラクターパラメーターの ResolvableType
    関連事項:
    forConstructorParameter(Constructor, int)
  - forMethodReturnType
```
public static ResolvableType forMethodReturnType(MethodSE method)
```
    指定された MethodSE 戻り値の型の ResolvableType を戻します。
    パラメーター:
    method - メソッドの戻り値の型のソース
    戻り値:
    指定されたメソッドの ResolvableType
    関連事項:
    forMethodReturnType(Method, Class)
  - forMethodReturnType
```
public static ResolvableType forMethodReturnType(MethodSE method,
                                                 ClassSE<?> implementationClass)
```
    指定された MethodSE 戻り値の型の ResolvableType を戻します。
    メソッドを宣言するクラスに、実装クラスが満たすジェネリクスパラメーター変数が含まれている場合は、このバリアントを使用します。
    パラメーター:
    method - メソッドの戻り値の型のソース
    implementationClass - 実装クラス
    戻り値:
    指定されたメソッドの ResolvableType
    関連事項:
    forMethodReturnType(Method)
  - forMethodParameter
```
public static ResolvableType forMethodParameter(MethodSE method,
                                                int parameterIndex)
```
    指定された MethodSE パラメーターの ResolvableType を返します。
    パラメーター:
    method - ソースメソッド (null であってはなりません)
    parameterIndex - パラメーターインデックス
    戻り値:
    指定されたメソッドパラメーターの ResolvableType
    関連事項:
    forMethodParameter(Method, int, Class), forMethodParameter(MethodParameter)
  - forMethodParameter
```
public static ResolvableType forMethodParameter(MethodSE method,
                                                int parameterIndex,
                                                ClassSE<?> implementationClass)
```
    指定された実装で、指定された MethodSE パラメーターの ResolvableType を返します。このバリアントは、メソッドを宣言するクラスに、実装クラスが満たすジェネリクスパラメーター変数が含まれている場合に使用します。
    パラメーター:
    method - ソースメソッド (null であってはなりません)
    parameterIndex - パラメーターインデックス
    implementationClass - 実装クラス
    戻り値:
    指定されたメソッドパラメーターの ResolvableType
    関連事項:
    forMethodParameter(Method, int, Class), forMethodParameter(MethodParameter)
  - forMethodParameter
```
public static ResolvableType forMethodParameter(MethodParameter methodParameter)
```
    指定された MethodParameter の ResolvableType を返します。
    パラメーター:
    methodParameter - ソースメソッドパラメーター (null であってはなりません)
    戻り値:
    指定されたメソッドパラメーターの ResolvableType
    関連事項:
    forMethodParameter(Method, int)
  - forMethodParameter
```
public static ResolvableType forMethodParameter(MethodParameter methodParameter,
                                                @Nullable
                                                ResolvableType implementationType)
```
    指定された MethodParameter の ResolvableType を、指定された実装型で返します。このバリアントは、メソッドを宣言するクラスに、実装型によって満たされるジェネリクスパラメーター変数が含まれている場合に使用します。
    パラメーター:
    methodParameter - ソースメソッドパラメーター (null であってはなりません)
    implementationType - 実装型
    戻り値:
    指定されたメソッドパラメーターの ResolvableType
    関連事項:
    forMethodParameter(MethodParameter)
  - forMethodParameter
```
public static ResolvableType forMethodParameter(MethodParameter methodParameter,
                                                @Nullable
                                                TypeSE targetType)
```
    指定された MethodParameter の ResolvableType を返し、ターゲット型をオーバーライドして、特定の型で解決します。
    パラメーター:
    methodParameter - ソースメソッドパラメーター (null であってはなりません)
    targetType - 解決する型 (メソッドパラメーターの型の一部)
    戻り値:
    指定されたメソッドパラメーターの ResolvableType
    関連事項:
    forMethodParameter(Method, int)
  - forArrayComponent
```
public static ResolvableType forArrayComponent(ResolvableType componentType)
```
    ResolvableType を指定された componentType の配列として返します。
    パラメーター:
    componentType - コンポーネント型
    戻り値:
    指定されたコンポーネント型の配列としての ResolvableType
  - forType
```
public static ResolvableType forType(@Nullable
                                     TypeSE type)
```
    指定された TypeSE の ResolvableType を返します。
    メモ: 結果の ResolvableType インスタンスは SerializableSE ではない場合があります。
    パラメーター:
    type - ソース型 (潜在的に null)
    戻り値:
    指定された TypeSE の ResolvableType
    関連事項:
    forType(Type, ResolvableType)
  - forType
```
public static ResolvableType forType(@Nullable
                                     TypeSE type,
                                     @Nullable
                                     ResolvableType owner)
```
    指定された所有者型に基づく指定された TypeSE の ResolvableType を返します。
    メモ: 結果の ResolvableType インスタンスは SerializableSE ではない場合があります。
    パラメーター:
    type - ソース型または null
    owner - 変数の解決に使用される所有者型
    戻り値:
    指定された TypeSE および所有者の ResolvableType
    関連事項:
    forType(Type)
  - forType
```
public static ResolvableType forType(ParameterizedTypeReference<?> typeReference)
```
    指定された ParameterizedTypeReference の ResolvableType を返します。
    メモ: 結果の ResolvableType インスタンスは SerializableSE ではない場合があります。
    パラメーター:
    typeReference - ソース型を取得するための参照
    戻り値:
    指定された ParameterizedTypeReference の ResolvableType
    導入:
    4.3.12
    関連事項:
    forType(Type)
  - clearCache
```
public static void clearCache()
```
    内部 ResolvableType/SerializableTypeWrapper キャッシュをクリアします。
    導入:
    4.2

クラス ResolvableType

フィールドサマリー

メソッドのサマリー

クラス java.lang.ObjectSE から継承されたメソッド

フィールドの詳細

NONE

メソッドの詳細

getType

getRawClass

getSource

toClass

isInstance

isAssignableFrom

isAssignableFrom

isArray

getComponentType

asCollection

asMap

as

getSuperType

getInterfaces

hasGenerics

hasUnresolvableGenerics

getNested

getNested

getGeneric

getGenerics

resolveGenerics

resolveGenerics

resolveGeneric

resolve

resolve

equals

hashCode

toString

forClass

forRawClass

forClass

forClassWithGenerics

forClassWithGenerics

forInstance

forField

forField

forField

forField

forField

forConstructorParameter

forConstructorParameter

forMethodReturnType

forMethodReturnType

forMethodParameter

forMethodParameter

forMethodParameter

forMethodParameter

forMethodParameter

forArrayComponent

forType

forType

forType

clearCache