com.fasterxml.jackson.databind.introspect

## Class AnnotatedClass

- java.lang.Object
- - com.fasterxml.jackson.databind.introspect.Annotated
  - - com.fasterxml.jackson.databind.introspect.AnnotatedClass

All Implemented Interfaces:
  TypeResolutionContext

    public final class AnnotatedClass
    extends Annotated
    implements TypeResolutionContext

### Nested Class Summary

Nested Classes
`static class` `AnnotatedClass.Creators`

### Nested classes/interfaces inherited from interface com.fasterxml.jackson.databind.introspect.TypeResolutionContext

`TypeResolutionContext.Basic, TypeResolutionContext.Empty`

### Field Summary

Fields
`protected AnnotationIntrospector` `_annotationIntrospector` Filter used to determine which annotations to gather; used to optimize things so that unnecessary annotations are ignored.
`protected TypeBindings` `_bindings` Type bindings to use for members of `_class`.
`protected Class<?>` `_class` Class for which annotations apply, and that owns other components (constructors, methods)
`protected Annotations` `_classAnnotations` Combined list of Jackson annotations that the class has, including inheritable ones from super classes and interfaces
`protected boolean` `_collectAnnotations` Flag that indicates whether (fulll) annotation resolution should occur: starting with 2.11 is disabled for JDK container types.
`protected AnnotatedClass.Creators` `_creators`
`protected List<AnnotatedField>` `_fields` Member fields of interest: ones that are either public, or have at least one annotation.
`protected AnnotatedMethodMap` `_memberMethods` Member methods of interest; for now ones with 0 or 1 arguments (just optimization, since others won't be used now)
`protected ClassIntrospector.MixInResolver` `_mixInResolver` Object that knows mapping of mix-in classes (ones that contain annotations to add) with their target classes (ones that get these additional annotations "mixed in").
`protected Boolean` `_nonStaticInnerClass` Lazily determined property to see if this is a non-static inner class.
`protected Class<?>` `_primaryMixIn` Primary mix-in class; one to use for the annotated class itself.
`protected List<JavaType>` `_superTypes` Ordered set of super classes and interfaces of the class itself: included in order of precedence
`protected JavaType` `_type`
`protected TypeFactory` `_typeFactory`

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
`Iterable<Annotation>` `annotations()` Deprecated.
`static AnnotatedClass` `construct(JavaType type, MapperConfig<?> config)` Deprecated. Since 2.9, use methods in `AnnotatedClassResolver` instead.
`static AnnotatedClass` `construct(JavaType type, MapperConfig<?> config, ClassIntrospector.MixInResolver mir)` Deprecated. Since 2.9, use methods in `AnnotatedClassResolver` instead.
`static AnnotatedClass` `constructWithoutSuperTypes(Class<?> raw, MapperConfig<?> config)` Deprecated. Since 2.9, use methods in `AnnotatedClassResolver` instead.
`static AnnotatedClass` `constructWithoutSuperTypes(Class<?> raw, MapperConfig<?> config, ClassIntrospector.MixInResolver mir)` Deprecated. Since 2.9, use methods in `AnnotatedClassResolver` instead.
`boolean` `equals(Object o)`
`Iterable<AnnotatedField>` `fields()`
`AnnotatedMethod` `findMethod(String name, Class<?>[] paramTypes)`
`Class<?>` `getAnnotated()` Method that can be used to find actual JDK element that this instance represents.
`<A extends Annotation> A` `getAnnotation(Class<A> acls)`
`Annotations` `getAnnotations()`
`List<AnnotatedConstructor>` `getConstructors()`
`AnnotatedConstructor` `getDefaultConstructor()`
`List<AnnotatedMethod>` `getFactoryMethods()`
`int` `getFieldCount()`
`int` `getMemberMethodCount()`
`int` `getModifiers()`
`String` `getName()`
`Class<?>` `getRawType()` "Raw" type (type-erased class) of the annotated element; definition of what exactly this means depends on sub-class.
`List<AnnotatedMethod>` `getStaticMethods()` Deprecated. Since 2.9; use `getFactoryMethods()` instead.
`JavaType` `getType()` Full generic type of the annotated element; definition of what exactly this means depends on sub-class.
`boolean` `hasAnnotation(Class<?> acls)`
`boolean` `hasAnnotations()`
`int` `hashCode()`
`boolean` `hasOneOf(Class<? extends Annotation>[] annoClasses)`
`boolean` `isNonStaticInnerClass()`
`Iterable<AnnotatedMethod>` `memberMethods()`
`JavaType` `resolveType(Type type)`
`String` `toString()`

### Methods inherited from class com.fasterxml.jackson.databind.introspect.Annotated

`isPublic, isStatic`

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

`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

### Field Detail

#### _type

    protected final JavaType _type

Since:
  2.7

#### _class

    protected final Class<?> _class

Class for which annotations apply, and that owns other components (constructors, methods)

#### _bindings

    protected final TypeBindings _bindings

Type bindings to use for members of `_class`.

Since:
  2.7

#### _superTypes

    protected final List<JavaType> _superTypes

Ordered set of super classes and interfaces of the class itself: included in order of precedence

#### _annotationIntrospector

    protected final AnnotationIntrospector _annotationIntrospector

Filter used to determine which annotations to gather; used to optimize things so that unnecessary annotations are ignored.

#### _typeFactory

    protected final TypeFactory _typeFactory

Since:
  2.7

#### _mixInResolver

    protected final ClassIntrospector.MixInResolver _mixInResolver

Object that knows mapping of mix-in classes (ones that contain annotations to add) with their target classes (ones that get these additional annotations "mixed in").

#### _primaryMixIn

    protected final Class<?> _primaryMixIn

Primary mix-in class; one to use for the annotated class itself. Can be null.

#### _collectAnnotations

    protected final boolean _collectAnnotations

Flag that indicates whether (fulll) annotation resolution should occur: starting with 2.11 is disabled for JDK container types.

Since:
  2.11

#### _classAnnotations

    protected final Annotations _classAnnotations

Combined list of Jackson annotations that the class has, including inheritable ones from super classes and interfaces

#### _creators

    protected AnnotatedClass.Creators _creators

Since:
  2.9

#### _memberMethods

    protected AnnotatedMethodMap _memberMethods

Member methods of interest; for now ones with 0 or 1 arguments (just optimization, since others won't be used now)

#### _fields

    protected List<AnnotatedField> _fields

Member fields of interest: ones that are either public, or have at least one annotation.

#### _nonStaticInnerClass

    protected transient Boolean _nonStaticInnerClass

Lazily determined property to see if this is a non-static inner class.

Since:
  2.8.7

### Method Detail

#### construct

    @Deprecated
    public static AnnotatedClass construct(JavaType type,
                                                       MapperConfig<?> config)

Deprecated. Since 2.9, use methods in `AnnotatedClassResolver` instead.

#### construct

    @Deprecated
    public static AnnotatedClass construct(JavaType type,
                                                       MapperConfig<?> config,
                                                       ClassIntrospector.MixInResolver mir)

Deprecated. Since 2.9, use methods in `AnnotatedClassResolver` instead.

#### constructWithoutSuperTypes

    @Deprecated
    public static AnnotatedClass constructWithoutSuperTypes(Class<?> raw,
                                                                        MapperConfig<?> config)

Deprecated. Since 2.9, use methods in `AnnotatedClassResolver` instead.
Method similar to `construct(com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.cfg.MapperConfig<?>)`, but that will NOT include information from supertypes; only class itself and any direct mix-ins it may have.

#### constructWithoutSuperTypes

    @Deprecated
    public static AnnotatedClass constructWithoutSuperTypes(Class<?> raw,
                                                                        MapperConfig<?> config,
                                                                        ClassIntrospector.MixInResolver mir)

Deprecated. Since 2.9, use methods in `AnnotatedClassResolver` instead.

#### resolveType

    public JavaType resolveType(Type type)

Specified by:
  `resolveType` in interface `TypeResolutionContext`

#### getAnnotated

    public Class<?> getAnnotated()

Description copied from class: `Annotated`
Method that can be used to find actual JDK element that this instance represents. It is non-null, except for method/constructor parameters which do not have a JDK counterpart.

Specified by:
  `getAnnotated` in class `Annotated`

#### getModifiers

    public int getModifiers()

Specified by:
  `getModifiers` in class `Annotated`

#### getName

    public String getName()

Specified by:
  `getName` in class `Annotated`

#### getAnnotation

    public <A extends Annotation> A getAnnotation(Class<A> acls)

Specified by:
  `getAnnotation` in class `Annotated`

#### hasAnnotation

    public boolean hasAnnotation(Class<?> acls)

Specified by:
  `hasAnnotation` in class `Annotated`

#### hasOneOf

    public boolean hasOneOf(Class<? extends Annotation>[] annoClasses)

Specified by:
  `hasOneOf` in class `Annotated`

#### getRawType

    public Class<?> getRawType()

Description copied from class: `Annotated`
"Raw" type (type-erased class) of the annotated element; definition of what exactly this means depends on sub-class.

Specified by:
  `getRawType` in class `Annotated`

#### annotations

    @Deprecated
    public Iterable<Annotation> annotations()

Deprecated.
Description copied from class: `Annotated`
Accessor that can be used to iterate over all the annotations associated with annotated component.

Specified by:
  `annotations` in class `Annotated`

#### getType

    public JavaType getType()

Description copied from class: `Annotated`
Full generic type of the annotated element; definition of what exactly this means depends on sub-class.

Specified by:
  `getType` in class `Annotated`

#### getAnnotations

    public Annotations getAnnotations()

#### hasAnnotations

    public boolean hasAnnotations()

#### getDefaultConstructor

    public AnnotatedConstructor getDefaultConstructor()

#### getConstructors

    public List<AnnotatedConstructor> getConstructors()

#### getFactoryMethods

    public List<AnnotatedMethod> getFactoryMethods()

Since:
  2.9

#### getStaticMethods

    @Deprecated
    public List<AnnotatedMethod> getStaticMethods()

Deprecated. Since 2.9; use `getFactoryMethods()` instead.

#### memberMethods

    public Iterable<AnnotatedMethod> memberMethods()

#### getMemberMethodCount

    public int getMemberMethodCount()

#### findMethod

    public AnnotatedMethod findMethod(String name,
                                      Class<?>[] paramTypes)

#### getFieldCount

    public int getFieldCount()

#### fields

    public Iterable<AnnotatedField> fields()

#### isNonStaticInnerClass

    public boolean isNonStaticInnerClass()

Since:
  2.9

#### toString

    public String toString()

Specified by:
  `toString` in class `Annotated`

#### hashCode

    public int hashCode()

Specified by:
  `hashCode` in class `Annotated`

#### equals

    public boolean equals(Object o)

Specified by:
  `equals` in class `Annotated`