com.fasterxml.jackson.databind.type

## Class TypeFactory

- java.lang.Object
- - com.fasterxml.jackson.databind.type.TypeFactory

All Implemented Interfaces:
  Serializable

    public class TypeFactory
    extends Object
    implements Serializable

Class used for creating concrete `JavaType` instances, given various inputs.

Instances of this class are accessible using `ObjectMapper` as well as many objects it constructs (like `DeserializationConfig` and `SerializationConfig`)), but usually those objects also expose convenience methods (`constructType`). So, you can do for example:

       JavaType stringType = mapper.constructType(String.class);

However, more advanced methods are only exposed by factory so that you may need to use:

       JavaType stringCollection = mapper.getTypeFactory().constructCollectionType(List.class, String.class);

See Also:
  Serialized Form

### Field Summary

Fields
`protected ClassLoader` `_classLoader` ClassLoader used by this factory [databind#624].
`protected TypeModifier[]` `_modifiers` Registered `TypeModifier`s: objects that can change details of `JavaType` instances factory constructs.
`protected TypeParser` `_parser`
`protected LookupCache<Object,JavaType>` `_typeCache` Since type resolution can be expensive (specifically when resolving actual generic types), we will use small cache to avoid repetitive resolution of core types
`protected static SimpleType` `CORE_TYPE_BOOL`
`protected static SimpleType` `CORE_TYPE_CLASS` Cache `Class` because it is nominally parametric, but has no really useful information.
`protected static SimpleType` `CORE_TYPE_COMPARABLE` Cache `Comparable` because it is both parameteric (relatively costly to resolve) and mostly useless (no special handling), better handle directly
`protected static SimpleType` `CORE_TYPE_ENUM` Cache `Enum` because it is parametric AND self-referential (costly to resolve) and useless in itself (no special handling).
`protected static SimpleType` `CORE_TYPE_INT`
`protected static SimpleType` `CORE_TYPE_JSON_NODE` Cache `JsonNode` because it is no critical path of simple tree model reading and does not have things to override
`protected static SimpleType` `CORE_TYPE_LONG`
`protected static SimpleType` `CORE_TYPE_OBJECT`
`protected static SimpleType` `CORE_TYPE_STRING`
`protected static TypeBindings` `EMPTY_BINDINGS`
`protected static TypeFactory` `instance` Globally shared singleton.

### Constructor Summary

Constructors
`protected` `TypeFactory(LookupCache<Object,JavaType> typeCache)`
`protected` `TypeFactory(LookupCache<Object,JavaType> typeCache, TypeParser p, TypeModifier[] mods, ClassLoader classLoader)`
`protected` `TypeFactory(LRUMap<Object,JavaType> typeCache)` Deprecated. Since 2.12
`protected` `TypeFactory(LRUMap<Object,JavaType> typeCache, TypeParser p, TypeModifier[] mods, ClassLoader classLoader)` Deprecated. Since 2.12

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
`protected JavaType` `_applyModifiers(Type srcType, JavaType resolvedType)`
`protected JavaType` `_constructSimple(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)` Factory method to call when no special `JavaType` is needed, no generic parameters are passed.
`protected Class<?>` `_findPrimitive(String className)`
`protected JavaType` `_findWellKnownSimple(Class<?> clz)` Helper method called to see if requested, non-generic-parameterized type is one of common, "well-known" types, instances of which are pre-constructed and do not need dynamic caching.
`protected JavaType` `_fromAny(ClassStack context, Type srcType, TypeBindings bindings)` Factory method that can be used if type information is passed as Java typing returned from `getGenericXxx` methods (usually for a return or argument type).
`protected JavaType` `_fromArrayType(ClassStack context, GenericArrayType type, TypeBindings bindings)`
`protected JavaType` `_fromClass(ClassStack context, Class<?> rawType, TypeBindings bindings)`
`protected JavaType` `_fromParamType(ClassStack context, ParameterizedType ptype, TypeBindings parentBindings)` This method deals with parameterized types, that is, first class generic classes.
`protected JavaType` `_fromVariable(ClassStack context, TypeVariable<?> var, TypeBindings bindings)`
`protected JavaType` `_fromWellKnownClass(ClassStack context, Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)` Helper class used to check whether exact class for which type is being constructed is one of well-known base interfaces or classes that indicates alternate `JavaType` implementation.
`protected JavaType` `_fromWellKnownInterface(ClassStack context, Class<?> rawType, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)`
`protected JavaType` `_fromWildcard(ClassStack context, WildcardType type, TypeBindings bindings)`
`protected JavaType` `_newSimpleType(Class<?> raw, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces)` Factory method that is to create a new `SimpleType` with no checks whatsoever.
`protected JavaType` `_resolveSuperClass(ClassStack context, Class<?> rawType, TypeBindings parentBindings)`
`protected JavaType[]` `_resolveSuperInterfaces(ClassStack context, Class<?> rawType, TypeBindings parentBindings)`
`protected JavaType` `_unknownType()`
`protected Class<?>` `classForName(String name)`
`protected Class<?>` `classForName(String name, boolean initialize, ClassLoader loader)`
`void` `clearCache()` Method that will clear up any cached type definitions that may be cached by this `TypeFactory` instance.
`ArrayType` `constructArrayType(Class<?> elementType)` Method for constructing an `ArrayType`.
`ArrayType` `constructArrayType(JavaType elementType)` Method for constructing an `ArrayType`.
`CollectionLikeType` `constructCollectionLikeType(Class<?> collectionClass, Class<?> elementClass)` Method for constructing a `CollectionLikeType`.
`CollectionLikeType` `constructCollectionLikeType(Class<?> collectionClass, JavaType elementType)` Method for constructing a `CollectionLikeType`.
`CollectionType` `constructCollectionType(Class<? extends Collection> collectionClass, Class<?> elementClass)` Method for constructing a `CollectionType`.
`CollectionType` `constructCollectionType(Class<? extends Collection> collectionClass, JavaType elementType)` Method for constructing a `CollectionType`.
`JavaType` `constructFromCanonical(String canonical)` Factory method for constructing a `JavaType` out of its canonical representation (see `ResolvedType.toCanonical()`).
`JavaType` `constructGeneralizedType(JavaType baseType, Class<?> superClass)` Method similar to `constructSpecializedType(com.fasterxml.jackson.databind.JavaType, java.lang.Class<?>)`, but that creates a less-specific type of given type.
`MapLikeType` `constructMapLikeType(Class<?> mapClass, Class<?> keyClass, Class<?> valueClass)` Method for constructing a `MapLikeType` instance
`MapLikeType` `constructMapLikeType(Class<?> mapClass, JavaType keyType, JavaType valueType)` Method for constructing a `MapLikeType` instance
`MapType` `constructMapType(Class<? extends Map> mapClass, Class<?> keyClass, Class<?> valueClass)` Method for constructing a `MapType` instance
`MapType` `constructMapType(Class<? extends Map> mapClass, JavaType keyType, JavaType valueType)` Method for constructing a `MapType` instance
`JavaType` `constructParametricType(Class<?> parametrized, Class<?>... parameterClasses)` Factory method for constructing `JavaType` that represents a parameterized type.
`JavaType` `constructParametricType(Class<?> rawType, JavaType... parameterTypes)` Factory method for constructing `JavaType` that represents a parameterized type.
`JavaType` `constructParametricType(Class<?> rawType, TypeBindings parameterTypes)` Factory method for constructing `JavaType` that represents a parameterized type.
`JavaType` `constructParametrizedType(Class<?> parametrized, Class<?> parametersFor, Class<?>... parameterClasses)` Deprecated. since 2.9 Use `constructParametricType(Class,Class...)` instead
`JavaType` `constructParametrizedType(Class<?> parametrized, Class<?> parametersFor, JavaType... parameterTypes)` Deprecated. since 2.9 Use `constructParametricType(Class,JavaType...)` instead
`CollectionLikeType` `constructRawCollectionLikeType(Class<?> collectionClass)` Method that can be used to construct "raw" Collection-like type; meaning that its parameterization is unknown.
`CollectionType` `constructRawCollectionType(Class<? extends Collection> collectionClass)` Method that can be used to construct "raw" Collection type; meaning that its parameterization is unknown.
`MapLikeType` `constructRawMapLikeType(Class<?> mapClass)` Method that can be used to construct "raw" Map-like type; meaning that its parameterization is unknown.
`MapType` `constructRawMapType(Class<? extends Map> mapClass)` Method that can be used to construct "raw" Map type; meaning that its parameterization is unknown.
`JavaType` `constructReferenceType(Class<?> rawType, JavaType referredType)` Method for constructing a `ReferenceType` instance with given type parameter (type MUST take one and only one type parameter)
`JavaType` `constructSimpleType(Class<?> rawType, Class<?> parameterTarget, JavaType[] parameterTypes)` Deprecated. Since 2.7
`JavaType` `constructSimpleType(Class<?> rawType, JavaType[] parameterTypes)` Method for constructing a type instance with specified parameterization.
`JavaType` `constructSpecializedType(JavaType baseType, Class<?> subclass)` Factory method for creating a subtype of given base type, as defined by specified subclass; but retaining generic type information if any.
`JavaType` `constructSpecializedType(JavaType baseType, Class<?> subclass, boolean relaxedCompatibilityCheck)` Factory method for creating a subtype of given base type, as defined by specified subclass; but retaining generic type information if any.
`JavaType` `constructType(Type type)`
`JavaType` `constructType(Type type, Class<?> contextClass)` Deprecated. Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)
`JavaType` `constructType(Type type, JavaType contextType)` Deprecated. Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)
`JavaType` `constructType(com.fasterxml.jackson.core.type.TypeReference<?> typeRef)`
`JavaType` `constructType(Type type, TypeBindings bindings)` Deprecated. Since 2.12
`static TypeFactory` `defaultInstance()` Method used to access the globally shared instance, which has no custom configuration.
`Class<?>` `findClass(String className)` Low-level lookup method moved from `ClassUtil`, to allow for overriding of lookup functionality in environments like OSGi.
`JavaType[]` `findTypeParameters(Class<?> clz, Class<?> expType)` Deprecated. Since 2.7 resolve raw type first, then find type parameters
`JavaType[]` `findTypeParameters(Class<?> clz, Class<?> expType, TypeBindings bindings)` Deprecated. Since 2.7 resolve raw type first, then find type parameters
`JavaType[]` `findTypeParameters(JavaType type, Class<?> expType)` Method that is to figure out actual type parameters that given class binds to generic types defined by given (generic) interface or class.
`ClassLoader` `getClassLoader()`
`JavaType` `moreSpecificType(JavaType type1, JavaType type2)` Method that can be called to figure out more specific of two types (if they are related; that is, one implements or extends the other); or if not related, return the primary type.
`static Class<?>` `rawClass(Type t)` Static helper method that can be called to figure out type-erased call for given JDK type.
`JavaType` `resolveMemberType(Type type, TypeBindings contextBindings)` Method to call when resolving types of `Member`s like Fields, Methods and Constructor parameters and there is a `TypeBindings` (that describes binding of type parameters within context) to pass.
`JavaType` `uncheckedSimpleType(Class<?> cls)` Deprecated. Since 2.8, to indicate users should never call this method.
`static JavaType` `unknownType()` Method for constructing a marker type that indicates missing generic type information, which is handled same as simple type for `java.lang.Object`.
`TypeFactory` `withCache(LookupCache<Object,JavaType> cache)` Mutant factory method that will construct new `TypeFactory` with identical settings except for different cache; most likely one with bigger maximum size.
`TypeFactory` `withCache(LRUMap<Object,JavaType> cache)` Deprecated. Since 2.12
`TypeFactory` `withClassLoader(ClassLoader classLoader)` "Mutant factory" method which will construct a new instance with specified `ClassLoader` to use by `findClass(java.lang.String)`.
`TypeFactory` `withModifier(TypeModifier mod)` "Mutant factory" method which will construct a new instance with specified `TypeModifier` added as the first modifier to call (in case there are multiple registered).

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### instance

    protected static final TypeFactory instance

Globally shared singleton. Not accessed directly; non-core code should use per-ObjectMapper instance (via configuration objects). Core Jackson code uses `defaultInstance()` for accessing it.

#### EMPTY_BINDINGS

    protected static final TypeBindings EMPTY_BINDINGS

#### CORE_TYPE_BOOL

    protected static final SimpleType CORE_TYPE_BOOL

#### CORE_TYPE_INT

    protected static final SimpleType CORE_TYPE_INT

#### CORE_TYPE_LONG

    protected static final SimpleType CORE_TYPE_LONG

#### CORE_TYPE_STRING

    protected static final SimpleType CORE_TYPE_STRING

#### CORE_TYPE_OBJECT

    protected static final SimpleType CORE_TYPE_OBJECT

#### CORE_TYPE_COMPARABLE

    protected static final SimpleType CORE_TYPE_COMPARABLE

Cache `Comparable` because it is both parameteric (relatively costly to resolve) and mostly useless (no special handling), better handle directly

Since:
  2.7

#### CORE_TYPE_ENUM

    protected static final SimpleType CORE_TYPE_ENUM

Cache `Enum` because it is parametric AND self-referential (costly to resolve) and useless in itself (no special handling).

Since:
  2.7

#### CORE_TYPE_CLASS

    protected static final SimpleType CORE_TYPE_CLASS

Cache `Class` because it is nominally parametric, but has no really useful information.

Since:
  2.7

#### CORE_TYPE_JSON_NODE

    protected static final SimpleType CORE_TYPE_JSON_NODE

Cache `JsonNode` because it is no critical path of simple tree model reading and does not have things to override

Since:
  2.10

#### _typeCache

    protected final LookupCache<Object,JavaType> _typeCache

Since type resolution can be expensive (specifically when resolving actual generic types), we will use small cache to avoid repetitive resolution of core types

#### _modifiers

    protected final TypeModifier[] _modifiers

Registered `TypeModifier`s: objects that can change details of `JavaType` instances factory constructs.

#### _parser

    protected final TypeParser _parser

#### _classLoader

    protected final ClassLoader _classLoader

ClassLoader used by this factory [databind#624].

### Constructor Detail

#### TypeFactory

    @Deprecated
    protected TypeFactory(LRUMap<Object,JavaType> typeCache)

Deprecated. Since 2.12

Since:
  2.8

#### TypeFactory

    protected TypeFactory(LookupCache<Object,JavaType> typeCache)

Since:
  2.12

#### TypeFactory

    @Deprecated
    protected TypeFactory(LRUMap<Object,JavaType> typeCache,
                                      TypeParser p,
                                      TypeModifier[] mods,
                                      ClassLoader classLoader)

Deprecated. Since 2.12

#### TypeFactory

    protected TypeFactory(LookupCache<Object,JavaType> typeCache,
                          TypeParser p,
                          TypeModifier[] mods,
                          ClassLoader classLoader)

Since:
  2.12

### Method Detail

#### withModifier

    public TypeFactory withModifier(TypeModifier mod)

"Mutant factory" method which will construct a new instance with specified `TypeModifier` added as the first modifier to call (in case there are multiple registered).

#### withClassLoader

    public TypeFactory withClassLoader(ClassLoader classLoader)

"Mutant factory" method which will construct a new instance with specified `ClassLoader` to use by `findClass(java.lang.String)`.

#### withCache

    @Deprecated
    public TypeFactory withCache(LRUMap<Object,JavaType> cache)

Deprecated. Since 2.12
Mutant factory method that will construct new `TypeFactory` with identical settings except for different cache; most likely one with bigger maximum size.

Since:
  2.8

#### withCache

    public TypeFactory withCache(LookupCache<Object,JavaType> cache)

Mutant factory method that will construct new `TypeFactory` with identical settings except for different cache; most likely one with bigger maximum size.

Since:
  2.12

#### defaultInstance

    public static TypeFactory defaultInstance()

Method used to access the globally shared instance, which has no custom configuration. Used by `ObjectMapper` to get the default factory when constructed.

#### clearCache

    public void clearCache()

Method that will clear up any cached type definitions that may be cached by this `TypeFactory` instance. This method should not be commonly used, that is, only use it if you know there is a problem with retention of type definitions; the most likely (and currently only known) problem is retention of `Class` instances via `JavaType` reference.

Since:
  2.4.1

#### getClassLoader

    public ClassLoader getClassLoader()

#### unknownType

    public static JavaType unknownType()

Method for constructing a marker type that indicates missing generic type information, which is handled same as simple type for `java.lang.Object`.

#### rawClass

    public static Class<?> rawClass(Type t)

Static helper method that can be called to figure out type-erased call for given JDK type. It can be called statically since type resolution process can never change actual type-erased class; thereby static default instance is used for determination.

#### findClass

    public Class<?> findClass(String className)
                       throws ClassNotFoundException

Low-level lookup method moved from `ClassUtil`, to allow for overriding of lookup functionality in environments like OSGi.

Throws:
  `ClassNotFoundException`
Since:
  2.6

#### classForName

    protected Class<?> classForName(String name,
                                    boolean initialize,
                                    ClassLoader loader)
                             throws ClassNotFoundException

Throws:
  `ClassNotFoundException`

#### classForName

    protected Class<?> classForName(String name)
                             throws ClassNotFoundException

Throws:
  `ClassNotFoundException`

#### _findPrimitive

    protected Class<?> _findPrimitive(String className)

#### constructSpecializedType

    public JavaType constructSpecializedType(JavaType baseType,
                                             Class<?> subclass)
                                      throws IllegalArgumentException

Factory method for creating a subtype of given base type, as defined by specified subclass; but retaining generic type information if any. Can be used, for example, to get equivalent of "HashMap<String,Integer>" from "Map<String,Integer>" by giving `HashMap.class` as subclass. Short-cut for:

     constructSpecializedType(baseType, subclass, class);

that is, will use "strict" compatibility checking, usually used for deserialization purposes (but often not for serialization).

Throws:
  `IllegalArgumentException`

#### constructSpecializedType

    public JavaType constructSpecializedType(JavaType baseType,
                                             Class<?> subclass,
                                             boolean relaxedCompatibilityCheck)
                                      throws IllegalArgumentException

Factory method for creating a subtype of given base type, as defined by specified subclass; but retaining generic type information if any. Can be used, for example, to get equivalent of "HashMap<String,Integer>" from "Map<String,Integer>" by giving `HashMap.class` as subclass.

Parameters:
  `baseType` - Declared base type with resolved type parameters
  `subclass` - Runtime subtype to use for resolving
  `relaxedCompatibilityCheck` - Whether checking for type-assignment compatibility should be "relaxed" (`true`) or "strict" (`false`): typically serialization uses relaxed, deserialization strict checking.
Returns:
  Resolved sub-type
Throws:
  `IllegalArgumentException`
Since:
  2.11

#### constructGeneralizedType

    public JavaType constructGeneralizedType(JavaType baseType,
                                             Class<?> superClass)

Method similar to `constructSpecializedType(com.fasterxml.jackson.databind.JavaType, java.lang.Class<?>)`, but that creates a less-specific type of given type. Usually this is as simple as simply finding super-type with type erasure of `superClass`, but there may be need for some additional work-arounds.

Parameters:
  `superClass` -
Since:
  2.7

#### constructFromCanonical

    public JavaType constructFromCanonical(String canonical)
                                    throws IllegalArgumentException

Factory method for constructing a `JavaType` out of its canonical representation (see `ResolvedType.toCanonical()`).

Parameters:
  `canonical` - Canonical string representation of a type
Throws:
  `IllegalArgumentException` - If canonical representation is malformed, or class that type represents (including its generic parameters) is not found

#### findTypeParameters

    public JavaType[] findTypeParameters(JavaType type,
                                         Class<?> expType)

Method that is to figure out actual type parameters that given class binds to generic types defined by given (generic) interface or class. This could mean, for example, trying to figure out key and value types for Map implementations.

Parameters:
  `type` - Sub-type (leaf type) that implements `expType`

#### findTypeParameters

    @Deprecated
    public JavaType[] findTypeParameters(Class<?> clz,
                                                     Class<?> expType,
                                                     TypeBindings bindings)

Deprecated. Since 2.7 resolve raw type first, then find type parameters

#### findTypeParameters

    @Deprecated
    public JavaType[] findTypeParameters(Class<?> clz,
                                                     Class<?> expType)

Deprecated. Since 2.7 resolve raw type first, then find type parameters

#### moreSpecificType

    public JavaType moreSpecificType(JavaType type1,
                                     JavaType type2)

Method that can be called to figure out more specific of two types (if they are related; that is, one implements or extends the other); or if not related, return the primary type.

Parameters:
  `type1` - Primary type to consider
  `type2` - Secondary type to consider
Since:
  2.2

#### constructType

    public JavaType constructType(Type type)

#### constructType

    public JavaType constructType(com.fasterxml.jackson.core.type.TypeReference<?> typeRef)

#### resolveMemberType

    public JavaType resolveMemberType(Type type,
                                      TypeBindings contextBindings)

Method to call when resolving types of `Member`s like Fields, Methods and Constructor parameters and there is a `TypeBindings` (that describes binding of type parameters within context) to pass. This is typically used only by code in databind itself.

Parameters:
  `type` - Type of a `Member` to resolve
  `contextBindings` - Type bindings from the context, often class in which member declared but may be subtype of that type (to bind actual bound type parametrers). Not used if `type` is of type `Class<?>`.
Returns:
  Fully resolve type
Since:
  2.12 as replacement for deprecated `constructType(Type, TypeBindings)`

#### constructType

    @Deprecated
    public JavaType constructType(Type type,
                                              TypeBindings bindings)

Deprecated. Since 2.12
Method that you very likely should NOT be using -- you need to know a lot about internal details of `TypeBindings` and even then it will probably not do what you want. Usually you would instead want to call one of `constructXxxType()` methods (where `Xxx` would be "Array", "Collection[Like]", "Map[Like]" or "Parametric").

#### constructType

    @Deprecated
    public JavaType constructType(Type type,
                                              Class<?> contextClass)

Deprecated. Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)

#### constructType

    @Deprecated
    public JavaType constructType(Type type,
                                              JavaType contextType)

Deprecated. Since 2.7 (accidentally removed in 2.7.0; added back in 2.7.1)

#### constructArrayType

    public ArrayType constructArrayType(Class<?> elementType)

Method for constructing an `ArrayType`.

NOTE: type modifiers are NOT called on array type itself; but are called for element type (and other contained types)

#### constructArrayType

    public ArrayType constructArrayType(JavaType elementType)

Method for constructing an `ArrayType`.

NOTE: type modifiers are NOT called on array type itself; but are called for contained types.

#### constructCollectionType

    public CollectionType constructCollectionType(Class<? extends Collection> collectionClass,
                                                  Class<?> elementClass)

Method for constructing a `CollectionType`.

NOTE: type modifiers are NOT called on Collection type itself; but are called for contained types.

#### constructCollectionType

    public CollectionType constructCollectionType(Class<? extends Collection> collectionClass,
                                                  JavaType elementType)

Method for constructing a `CollectionType`.

NOTE: type modifiers are NOT called on Collection type itself; but are called for contained types.

#### constructCollectionLikeType

    public CollectionLikeType constructCollectionLikeType(Class<?> collectionClass,
                                                          Class<?> elementClass)

Method for constructing a `CollectionLikeType`.

NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

#### constructCollectionLikeType

    public CollectionLikeType constructCollectionLikeType(Class<?> collectionClass,
                                                          JavaType elementType)

Method for constructing a `CollectionLikeType`.

NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

#### constructMapType

    public MapType constructMapType(Class<? extends Map> mapClass,
                                    Class<?> keyClass,
                                    Class<?> valueClass)

Method for constructing a `MapType` instance

NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

#### constructMapType

    public MapType constructMapType(Class<? extends Map> mapClass,
                                    JavaType keyType,
                                    JavaType valueType)

Method for constructing a `MapType` instance

NOTE: type modifiers are NOT called on constructed type itself.

#### constructMapLikeType

    public MapLikeType constructMapLikeType(Class<?> mapClass,
                                            Class<?> keyClass,
                                            Class<?> valueClass)

Method for constructing a `MapLikeType` instance

NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

#### constructMapLikeType

    public MapLikeType constructMapLikeType(Class<?> mapClass,
                                            JavaType keyType,
                                            JavaType valueType)

Method for constructing a `MapLikeType` instance

NOTE: type modifiers are NOT called on constructed type itself.

#### constructSimpleType

    public JavaType constructSimpleType(Class<?> rawType,
                                        JavaType[] parameterTypes)

Method for constructing a type instance with specified parameterization.

NOTE: type modifiers are NOT called on constructed type itself.

#### constructSimpleType

    @Deprecated
    public JavaType constructSimpleType(Class<?> rawType,
                                                    Class<?> parameterTarget,
                                                    JavaType[] parameterTypes)

Deprecated. Since 2.7
Method for constructing a type instance with specified parameterization.

Since:
  2.6

#### constructReferenceType

    public JavaType constructReferenceType(Class<?> rawType,
                                           JavaType referredType)

Method for constructing a `ReferenceType` instance with given type parameter (type MUST take one and only one type parameter)

NOTE: type modifiers are NOT called on constructed type itself.

Since:
  2.6

#### uncheckedSimpleType

    @Deprecated
    public JavaType uncheckedSimpleType(Class<?> cls)

Deprecated. Since 2.8, to indicate users should never call this method.
Method that use by core Databind functionality, and that should NOT be called by application code outside databind package.

Unchecked here not only means that no checks are made as to whether given class might be non-simple type (like `CollectionType`) but also that most of supertype information is not gathered. This means that unless called on primitive types or `String`, results are probably not what you want to use.

#### constructParametricType

    public JavaType constructParametricType(Class<?> parametrized,
                                            Class<?>... parameterClasses)

Factory method for constructing `JavaType` that represents a parameterized type. For example, to represent type `List<Set<Integer>>`, you could call

      JavaType inner = TypeFactory.constructParametricType(Set.class, Integer.class);
      return TypeFactory.constructParametricType(List.class, inner);

NOTE: since 2.11.2 `TypeModifier`s ARE called on result (fix for [databind#2796])

Parameters:
  `parametrized` - Type-erased type to parameterize
  `parameterClasses` - Type parameters to apply
Since:
  2.5 NOTE: was briefly deprecated for 2.6

#### constructParametricType

    public JavaType constructParametricType(Class<?> rawType,
                                            JavaType... parameterTypes)

Factory method for constructing `JavaType` that represents a parameterized type. For example, to represent type `List<Set<Integer>>`, you could

      JavaType inner = TypeFactory.constructParametricType(Set.class, Integer.class);
      return TypeFactory.constructParametricType(List.class, inner);

NOTE: since 2.11.2 `TypeModifier`s ARE called on result (fix for [databind#2796])

Parameters:
  `rawType` - Actual type-erased type
  `parameterTypes` - Type parameters to apply
Returns:
  Fully resolved type for given base type and type parameters

#### constructParametricType

    public JavaType constructParametricType(Class<?> rawType,
                                            TypeBindings parameterTypes)

Factory method for constructing `JavaType` that represents a parameterized type. The type's parameters are specified as an instance of `TypeBindings`. This is useful if you already have the type's parameters such as those found on `JavaType`. For example, you could call

       return TypeFactory.constructParametricType(ArrayList.class, javaType.getBindings());

This effectively applies the parameterized types from one `JavaType` to another class.

Parameters:
  `rawType` - Actual type-erased type
  `parameterTypes` - Type bindings for the raw type
Since:
  2.12

#### constructParametrizedType

    @Deprecated
    public JavaType constructParametrizedType(Class<?> parametrized,
                                                          Class<?> parametersFor,
                                                          JavaType... parameterTypes)

Deprecated. since 2.9 Use `constructParametricType(Class,JavaType...)` instead

Since:
  2.5

#### constructParametrizedType

    @Deprecated
    public JavaType constructParametrizedType(Class<?> parametrized,
                                                          Class<?> parametersFor,
                                                          Class<?>... parameterClasses)

Deprecated. since 2.9 Use `constructParametricType(Class,Class...)` instead

Since:
  2.5

#### constructRawCollectionType

    public CollectionType constructRawCollectionType(Class<? extends Collection> collectionClass)

Method that can be used to construct "raw" Collection type; meaning that its parameterization is unknown. This is similar to using `Object.class` parameterization, and is equivalent to calling:

      typeFactory.constructCollectionType(collectionClass, typeFactory.unknownType());

This method should only be used if parameterization is completely unavailable.

#### constructRawCollectionLikeType

    public CollectionLikeType constructRawCollectionLikeType(Class<?> collectionClass)

Method that can be used to construct "raw" Collection-like type; meaning that its parameterization is unknown. This is similar to using `Object.class` parameterization, and is equivalent to calling:

      typeFactory.constructCollectionLikeType(collectionClass, typeFactory.unknownType());

This method should only be used if parameterization is completely unavailable.

#### constructRawMapType

    public MapType constructRawMapType(Class<? extends Map> mapClass)

Method that can be used to construct "raw" Map type; meaning that its parameterization is unknown. This is similar to using `Object.class` parameterization, and is equivalent to calling:

      typeFactory.constructMapType(collectionClass, typeFactory.unknownType(), typeFactory.unknownType());

This method should only be used if parameterization is completely unavailable.

#### constructRawMapLikeType

    public MapLikeType constructRawMapLikeType(Class<?> mapClass)

Method that can be used to construct "raw" Map-like type; meaning that its parameterization is unknown. This is similar to using `Object.class` parameterization, and is equivalent to calling:

      typeFactory.constructMapLikeType(collectionClass, typeFactory.unknownType(), typeFactory.unknownType());

This method should only be used if parameterization is completely unavailable.

#### _constructSimple

    protected JavaType _constructSimple(Class<?> raw,
                                        TypeBindings bindings,
                                        JavaType superClass,
                                        JavaType[] superInterfaces)

Factory method to call when no special `JavaType` is needed, no generic parameters are passed. Default implementation may check pre-constructed values for "well-known" types, but if none found will simply call `_newSimpleType(java.lang.Class<?>, com.fasterxml.jackson.databind.type.TypeBindings, com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.JavaType[])`

Since:
  2.7

#### _newSimpleType

    protected JavaType _newSimpleType(Class<?> raw,
                                      TypeBindings bindings,
                                      JavaType superClass,
                                      JavaType[] superInterfaces)

Factory method that is to create a new `SimpleType` with no checks whatsoever. Default implementation calls the single argument constructor of `SimpleType`.

Since:
  2.7

#### _unknownType

    protected JavaType _unknownType()

#### _findWellKnownSimple

    protected JavaType _findWellKnownSimple(Class<?> clz)

Helper method called to see if requested, non-generic-parameterized type is one of common, "well-known" types, instances of which are pre-constructed and do not need dynamic caching.

Since:
  2.7

#### _fromAny

    protected JavaType _fromAny(ClassStack context,
                                Type srcType,
                                TypeBindings bindings)

Factory method that can be used if type information is passed as Java typing returned from `getGenericXxx` methods (usually for a return or argument type).

#### _applyModifiers

    protected JavaType _applyModifiers(Type srcType,
                                       JavaType resolvedType)

#### _fromClass

    protected JavaType _fromClass(ClassStack context,
                                  Class<?> rawType,
                                  TypeBindings bindings)

Parameters:
  `bindings` - Mapping of formal parameter declarations (for generic types) into actual types

#### _resolveSuperClass

    protected JavaType _resolveSuperClass(ClassStack context,
                                          Class<?> rawType,
                                          TypeBindings parentBindings)

#### _resolveSuperInterfaces

    protected JavaType[] _resolveSuperInterfaces(ClassStack context,
                                                 Class<?> rawType,
                                                 TypeBindings parentBindings)

#### _fromWellKnownClass

    protected JavaType _fromWellKnownClass(ClassStack context,
                                           Class<?> rawType,
                                           TypeBindings bindings,
                                           JavaType superClass,
                                           JavaType[] superInterfaces)

Helper class used to check whether exact class for which type is being constructed is one of well-known base interfaces or classes that indicates alternate `JavaType` implementation.

#### _fromWellKnownInterface

    protected JavaType _fromWellKnownInterface(ClassStack context,
                                               Class<?> rawType,
                                               TypeBindings bindings,
                                               JavaType superClass,
                                               JavaType[] superInterfaces)

#### _fromParamType

    protected JavaType _fromParamType(ClassStack context,
                                      ParameterizedType ptype,
                                      TypeBindings parentBindings)

This method deals with parameterized types, that is, first class generic classes.

#### _fromArrayType

    protected JavaType _fromArrayType(ClassStack context,
                                      GenericArrayType type,
                                      TypeBindings bindings)

#### _fromVariable

    protected JavaType _fromVariable(ClassStack context,
                                     TypeVariable<?> var,
                                     TypeBindings bindings)

#### _fromWildcard

    protected JavaType _fromWildcard(ClassStack context,
                                     WildcardType type,
                                     TypeBindings bindings)