com.fasterxml.jackson.databind.introspect

## Class AnnotatedMethod

- java.lang.Object
- - com.fasterxml.jackson.databind.introspect.Annotated
  - - com.fasterxml.jackson.databind.introspect.AnnotatedMember
    - - com.fasterxml.jackson.databind.introspect.AnnotatedWithParams
      - - com.fasterxml.jackson.databind.introspect.AnnotatedMethod

All Implemented Interfaces:
  Serializable

    public final class AnnotatedMethod
    extends AnnotatedWithParams
    implements Serializable

See Also:
  Serialized Form

### Field Summary

Fields
`protected Method` `_method`
`protected Class<?>[]` `_paramClasses`
`protected com.fasterxml.jackson.databind.introspect.AnnotatedMethod.Serialization` `_serialization` Field that is used to make JDK serialization work with this object.

### Fields inherited from class com.fasterxml.jackson.databind.introspect.AnnotatedWithParams

`_paramAnnotations`

### Fields inherited from class com.fasterxml.jackson.databind.introspect.AnnotatedMember

`_annotations, _context`

### Constructor Summary

Constructors
`` `AnnotatedMethod(AnnotatedClass ctxt, Method method, AnnotationMap classAnn, AnnotationMap[] paramAnnotations)`
`protected` `AnnotatedMethod(com.fasterxml.jackson.databind.introspect.AnnotatedMethod.Serialization ser)` Method used for JDK serialization support

### Method Summary

Methods
`Object` `call()` Method that can be used to (try to) call this object without arguments.
`Object` `call(Object[] args)` Method that can be used to (try to) call this object with specified arguments.
`Object` `call1(Object arg)` Method that can be used to (try to) call this object with single arguments.
`boolean` `equals(Object o)`
`Method` `getAnnotated()` Method that can be used to find actual JDK element that this instance represents.
`Class<?>` `getDeclaringClass()` Actual physical class in which this memmber was declared.
`String` `getFullName()`
`Type` `getGenericParameterType(int index)`
`Type[]` `getGenericParameterTypes()`
`Type` `getGenericReturnType()`
`Type` `getGenericType()` For methods, this returns declared return type, which is only useful with getters (setters do not return anything; hence "void" type is returned here)
`Method` `getMember()`
`int` `getModifiers()`
`String` `getName()`
`int` `getParameterCount()`
`Class<?>` `getRawParameterType(int index)`
`Class<?>[]` `getRawParameterTypes()`
`Class<?>` `getRawReturnType()`
`Class<?>` `getRawType()` For methods, this returns declared return type, which is only useful with getters (setters do not usually return anything; hence "void" type is returned here)
`JavaType` `getType(TypeBindings bindings)` As per [JACKSON-468], we need to also allow declaration of local type bindings; mostly it will allow defining bounds.
`Object` `getValue(Object pojo)` Optional method that can be used to access the value of this member on given object, if this is a supported operation for member type.
`int` `hashCode()`
`boolean` `hasReturnType()` Helper method that can be used to check whether method returns a value or not; if return type declared as `void`, returns false, otherwise true
`void` `setValue(Object pojo, Object value)` Optional method that can be used to assign value of this member on given object, if this is a supported operation for member type.
`String` `toString()`
`AnnotatedMethod` `withAnnotations(AnnotationMap ann)` Fluent factory method that will construct a new instance that uses specified instance annotations instead of currently configured ones.
`AnnotatedMethod` `withMethod(Method m)` Method that constructs a new instance with settings (annotations, parameter annotations) of this instance, but with different physical `Method`.

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

`addOrOverrideParam, getAnnotation, getAnnotationCount, getParameter, getParameterAnnotations, getType, replaceParameterAnnotations, resolveParameterType`

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

`addIfNotPresent, addOrOverride, annotations, fixAccess, getAllAnnotations, getContextClass`

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

`hasAnnotation, isPublic, withFallBackAnnotationsFrom`

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

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

### Field Detail

#### _method

    protected final transient Method _method

#### _paramClasses

    protected Class<?>[] _paramClasses

#### _serialization

    protected com.fasterxml.jackson.databind.introspect.AnnotatedMethod.Serialization _serialization

Field that is used to make JDK serialization work with this object.

Since:
  2.1

### Constructor Detail

#### AnnotatedMethod

    public AnnotatedMethod(AnnotatedClass ctxt,
                   Method method,
                   AnnotationMap classAnn,
                   AnnotationMap[] paramAnnotations)

#### AnnotatedMethod

    protected AnnotatedMethod(com.fasterxml.jackson.databind.introspect.AnnotatedMethod.Serialization ser)

Method used for JDK serialization support

Since:
  2.1

### Method Detail

#### withMethod

    public AnnotatedMethod withMethod(Method m)

Method that constructs a new instance with settings (annotations, parameter annotations) of this instance, but with different physical `Method`.

#### withAnnotations

    public AnnotatedMethod withAnnotations(AnnotationMap ann)

Description copied from class: `Annotated`
Fluent factory method that will construct a new instance that uses specified instance annotations instead of currently configured ones.

Specified by:
  `withAnnotations` in class `Annotated`

#### getAnnotated

    public Method 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`

#### getGenericType

    public Type getGenericType()

For methods, this returns declared return type, which is only useful with getters (setters do not return anything; hence "void" type is returned here)

Specified by:
  `getGenericType` in class `Annotated`

#### getRawType

    public Class<?> getRawType()

For methods, this returns declared return type, which is only useful with getters (setters do not usually return anything; hence "void" type is returned here)

Specified by:
  `getRawType` in class `Annotated`

#### getType

    public JavaType getType(TypeBindings bindings)

As per [JACKSON-468], we need to also allow declaration of local type bindings; mostly it will allow defining bounds.

Overrides:
  `getType` in class `Annotated`

#### call

    public final Object call()
                      throws Exception

Description copied from class: `AnnotatedWithParams`
Method that can be used to (try to) call this object without arguments. This may succeed or fail, depending on expected number of arguments: caller needs to take care to pass correct number. Exceptions are thrown directly from actual low-level call.

Note: only works for constructors and static methods.

Specified by:
  `call` in class `AnnotatedWithParams`
Throws:
  `Exception`

#### call

    public final Object call(Object[] args)
                      throws Exception

Description copied from class: `AnnotatedWithParams`
Method that can be used to (try to) call this object with specified arguments. This may succeed or fail, depending on expected number of arguments: caller needs to take care to pass correct number. Exceptions are thrown directly from actual low-level call.

Note: only works for constructors and static methods.

Specified by:
  `call` in class `AnnotatedWithParams`
Throws:
  `Exception`

#### call1

    public final Object call1(Object arg)
                       throws Exception

Description copied from class: `AnnotatedWithParams`
Method that can be used to (try to) call this object with single arguments. This may succeed or fail, depending on expected number of arguments: caller needs to take care to pass correct number. Exceptions are thrown directly from actual low-level call.

Note: only works for constructors and static methods.

Specified by:
  `call1` in class `AnnotatedWithParams`
Throws:
  `Exception`

#### getDeclaringClass

    public Class<?> getDeclaringClass()

Description copied from class: `AnnotatedMember`
Actual physical class in which this memmber was declared. Note that this may be different from what `AnnotatedMember.getContextClass()` returns; "owner" may be a sub-type of "declaring class".

Specified by:
  `getDeclaringClass` in class `AnnotatedMember`

#### getMember

    public Method getMember()

Specified by:
  `getMember` in class `AnnotatedMember`

#### setValue

    public void setValue(Object pojo,
                Object value)
                  throws IllegalArgumentException

Description copied from class: `AnnotatedMember`
Optional method that can be used to assign value of this member on given object, if this is a supported operation for member type.

This is implemented for fields and single-argument member methods; but not for constructor parameters or other types of methods (like static methods)

Specified by:
  `setValue` in class `AnnotatedMember`
Throws:
  `IllegalArgumentException`

#### getValue

    public Object getValue(Object pojo)
                    throws IllegalArgumentException

Description copied from class: `AnnotatedMember`
Optional method that can be used to access the value of this member on given object, if this is a supported operation for member type.

This is implemented for fields and no-argument member methods; but not for constructor parameters or other types of methods (like static methods)

Specified by:
  `getValue` in class `AnnotatedMember`
Throws:
  `IllegalArgumentException`

#### getParameterCount

    public int getParameterCount()

Specified by:
  `getParameterCount` in class `AnnotatedWithParams`

#### getFullName

    public String getFullName()

#### getRawParameterTypes

    public Class<?>[] getRawParameterTypes()

#### getGenericParameterTypes

    public Type[] getGenericParameterTypes()

#### getRawParameterType

    public Class<?> getRawParameterType(int index)

Specified by:
  `getRawParameterType` in class `AnnotatedWithParams`

#### getGenericParameterType

    public Type getGenericParameterType(int index)

Specified by:
  `getGenericParameterType` in class `AnnotatedWithParams`

#### getRawReturnType

    public Class<?> getRawReturnType()

#### getGenericReturnType

    public Type getGenericReturnType()

#### hasReturnType

    public boolean hasReturnType()

Helper method that can be used to check whether method returns a value or not; if return type declared as `void`, returns false, otherwise true

Since:
  2.4

#### 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`