java.lang.reflect.Parameter class provides Information about method parameters, including their name and modifiers. It also provides an alternate means of obtaining attributes for the parameter.
Some useful methods of Parameter class are:
- public int getModifiers(): It returns the modifier flags for the parameter represented by this Parameter object.
- public String getName(): It returns the name of the method parameter.
- public Type getParameterizedType(): It returns the type of the parameter.
All the methods of java.lang.reflect.Parameter class is listed below as follows: Â
| Method | Description |
|---|---|
| equals(Object obj) | Compares based on the executable and the index. |
| getAnnotatedType() | Returns an AnnotatedType object that represents the use of a type to specify the type of the formal parameter represented by this Parameter. |
| getAnnotation(Class<T> annotationClass) | Returns this element’s annotation for the specified type if such an annotation is present, else null. |
| getAnnotations() | Returns annotations that are present on this element. |
| getAnnotationsByType(Class<T> annotationClass) | Returns annotations that are associated with this element. |
| getDeclaredAnnotations() | Returns annotations that are directly present on this element. |
| getDeclaredAnnotation(Class<T> annotationClass) | Returns this element’s annotation for the specified type if such an annotation is directly present, else null. |
| getDeclaringExecutable() | Return the Executable which declares this parameter. |
| getDeclaredAnnotationsByType(Class<T> annotationClass) | Returns this element’s annotation(s) for the specified type if such annotations are either directly present or indirectly present. |
| getModifiers() | Get the modifier flags for this parameter represented by this Parameter object. |
| getName() | Returns the name of the parameter. |
| getParameterizedType() | Returns a Type object that identifies the parameterized type for the parameter represented by this Parameter object. |
| getType() | Returns a Class object that identifies the declared type for the parameter represented by this Parameter object. |
| hashCode() | Returns a hash code based on the executable’s hash code and the index. |
| isImplicit() | Returns true if the parameter is implicitly declared in the source code else returning false |
| isNamePresent() | Returning true if the parameter has the name in accordance with the class file |
| isVarArgs() | Returning true if this parameter represents a variable argument list. |
| isSynthetic() | Returning true if a parameter is not implicitly nor explicitly declared else false |
| toString() | Returns a string describing this parameter |
Example:
Java
// Java program to illustrate Parameter class of// java.lang.reflect packageÂ
// Importing java.lang.reflect package to// obtain reflective information about classes and objectsimport java.lang.reflect.*;Â
// Class 1// Helper classclass Calculate {Â
    // Function 1    // To add to numbers    int add(int a, int b)    {Â
        // Returning the sum        return (a + b);    }Â
    // Function 2    // To multiply two numbers    int mul(int a, int b)    {Â
        // Returning the number obtained        // after multiplying numbers        return (b * a);    }Â
    // Function 3    // Subtracting two numbers    long subtract(long a, long b)    {        // Return the numbers after subtracting        // second number from the first number        return (a - b);    }}Â
// Class 2// Main classpublic class GFG {Â
    // Main driver method    public static void main(String[] args)    {        // Creating object of helper class        // in the main method        Class cls = Calculate.class;Â
        // Getting all the methods of        // a particular class        Method[] methods = cls.getDeclaredMethods();Â
        // Iterating over each method        // using the for each loop        for (Method method : methods) {Â
            // Print and display the method name            // using getName() method            System.out.print(                "Method Name: " + method.getName() + " ");Â
            // Getting all the parameters of            // a particular method            Parameter parameters[] = method.getParameters();Â
            // Print and display            System.out.println("\nparameters of "                               + method.getName()                               + "() methods: ");Â
            // Iterating over parameters            // using for each loop            for (Parameter parameter : parameters) {Â
                // Display the type of parameters                System.out.print(                    parameter.getParameterizedType() + " ");Â
                // Print the parameters of method                System.out.print(parameter.getName() + " ");            }Â
            // New line            System.out.print("\n\n");        }    }} |
Output
Method Name: subtract parameters of subtract() methods: long arg0 long arg1 Method Name: add parameters of add() methods: int arg0 int arg1 Method Name: mul parameters of mul() methods: int arg0 int arg1
Â
