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

    public final class AnnotatedMethod

extends AnnotatedWithParams

Field Summary
`protected Method` `_method`
`protected Class<?>[]` `_paramClasses`

Fields inherited from class com.fasterxml.jackson.databind.introspect.AnnotatedWithParams
`_paramAnnotations`

Fields inherited from class com.fasterxml.jackson.databind.introspect.AnnotatedMember
`_annotations`

Constructor Summary
`AnnotatedMethod(Method method, AnnotationMap classAnn, AnnotationMap[] paramAnnotations)`

Method Summary
`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.
`Method` `getAnnotated()` Method that can be used to find actual JDK element that this instance represents.
`Class<?>` `getDeclaringClass()`
`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.
`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, fixAccess, getAllAnnotations`

Methods inherited from class com.fasterxml.jackson.databind.introspect.Annotated
`hasAnnotation, isPublic, withFallBackAnnotationsFrom`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Field Detail

### _method

    protected final Method _method

### _paramClasses

    protected Class<?>[] _paramClasses

Constructor Detail

### AnnotatedMethod

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

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

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

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

Copyright © 2012 fasterxml.com. All Rights Reserved.