T - the class in which the constructor is declaredpublic final class Constructor<T> extends Executable
Constructor provides information about, and access to, a single
 constructor for a class.
 Constructor permits widening conversions to occur when matching the
 actual parameters to newInstance() with the underlying
 constructor's formal parameters, but throws an
 IllegalArgumentException if a narrowing conversion would occur.
| Modifier and Type | Method and Description | 
|---|---|
| boolean | equals(Object obj)Compares this  Constructoragainst the specified object. | 
| AnnotatedType | getAnnotatedReceiverType()Returns an  AnnotatedTypeobject that represents the use of a
 type to specify the receiver type of the method/constructor represented
 by this Executable object. | 
| AnnotatedType | getAnnotatedReturnType()Returns an  AnnotatedTypeobject that represents the use of a type to
 specify the return type of the method/constructor represented by this
 Executable. | 
| <T extends Annotation> | getAnnotation(Class<T> annotationClass)Returns this element's annotation for the specified type if
 such an annotation is present, else null. | 
| Annotation[] | getDeclaredAnnotations()Returns annotations that are directly present on this element. | 
| Class<T> | getDeclaringClass()Returns the  Classobject representing the class or interface
 that declares the executable represented by this object. | 
| Class<?>[] | getExceptionTypes()Returns an array of  Classobjects that represent the
 types of exceptions declared to be thrown by the underlying
 executable represented by this object. | 
| Type[] | getGenericExceptionTypes()Returns an array of  Typeobjects that represent the
 exceptions declared to be thrown by this executable object. | 
| Type[] | getGenericParameterTypes()Returns an array of  Typeobjects that represent the formal
 parameter types, in declaration order, of the executable represented by
 this object. | 
| int | getModifiers()Returns the Java language modifiers for
 the executable represented by this object. | 
| String | getName()Returns the name of this constructor, as a string. | 
| Annotation[][] | getParameterAnnotations()Returns an array of arrays of  Annotations that
 represent the annotations on the formal parameters, in
 declaration order, of theExecutablerepresented by
 this object. | 
| int | getParameterCount()Returns the number of formal parameters (whether explicitly
 declared or implicitly declared or neither) for the executable
 represented by this object. | 
| Class<?>[] | getParameterTypes()Returns an array of  Classobjects that represent the formal
 parameter types, in declaration order, of the executable
 represented by this object. | 
| TypeVariable<Constructor<T>>[] | getTypeParameters()Returns an array of  TypeVariableobjects that represent the
 type variables declared by the generic declaration represented by thisGenericDeclarationobject, in declaration order. | 
| int | hashCode()Returns a hashcode for this  Constructor. | 
| boolean | isSynthetic()Returns  trueif this executable is a synthetic
 construct; returnsfalseotherwise. | 
| boolean | isVarArgs()Returns  trueif this executable was declared to take a
 variable number of arguments; returnsfalseotherwise. | 
| T | newInstance(Object... initargs)Uses the constructor represented by this  Constructorobject to
 create and initialize a new instance of the constructor's
 declaring class, with the specified initialization parameters. | 
| String | toGenericString()Returns a string describing this  Constructor,
 including type parameters. | 
| String | toString()Returns a string describing this  Constructor. | 
getAnnotatedExceptionTypes, getAnnotatedParameterTypes, getAnnotationsByType, getParametersgetAnnotations, getDeclaredAnnotation, getDeclaredAnnotationsByType, isAccessible, isAnnotationPresent, setAccessible, setAccessibleclone, finalize, getClass, notify, notifyAll, wait, wait, waitgetAnnotations, getDeclaredAnnotation, getDeclaredAnnotationsByType, isAnnotationPresentpublic Class<T> getDeclaringClass()
Class object representing the class or interface
 that declares the executable represented by this object.getDeclaringClass in interface MembergetDeclaringClass in class Executablepublic String getName()
getName in interface MembergetName in class Executablepublic int getModifiers()
getModifiers in interface MembergetModifiers in class ExecutableModifierpublic TypeVariable<Constructor<T>>[] getTypeParameters()
TypeVariable objects that represent the
 type variables declared by the generic declaration represented by this
 GenericDeclaration object, in declaration order.  Returns an
 array of length 0 if the underlying generic declaration declares no type
 variables.getTypeParameters in interface GenericDeclarationgetTypeParameters in class ExecutableTypeVariable objects that represent
     the type variables declared by this generic declarationGenericSignatureFormatError - if the generic
     signature of this generic declaration does not conform to
     the format specified in
     The Java™ Virtual Machine Specificationpublic Class<?>[] getParameterTypes()
Class objects that represent the formal
 parameter types, in declaration order, of the executable
 represented by this object.  Returns an array of length
 0 if the underlying executable takes no parameters.getParameterTypes in class Executablepublic int getParameterCount()
getParameterCount in class Executablepublic Type[] getGenericParameterTypes()
Type objects that represent the formal
 parameter types, in declaration order, of the executable represented by
 this object. Returns an array of length 0 if the
 underlying executable takes no parameters.
 If a formal parameter type is a parameterized type,
 the Type object returned for it must accurately reflect
 the actual type parameters used in the source code.
 
If a formal parameter type is a type variable or a parameterized type, it is created. Otherwise, it is resolved.
getGenericParameterTypes in class ExecutableTypes that represent the formal
     parameter types of the underlying executable, in declaration orderGenericSignatureFormatError - if the generic method signature does not conform to the format
     specified in
     The Java™ Virtual Machine SpecificationTypeNotPresentException - if any of the parameter
     types of the underlying executable refers to a non-existent type
     declarationMalformedParameterizedTypeException - if any of
     the underlying executable's parameter types refer to a parameterized
     type that cannot be instantiated for any reasonpublic Class<?>[] getExceptionTypes()
Class objects that represent the
 types of exceptions declared to be thrown by the underlying
 executable represented by this object.  Returns an array of
 length 0 if the executable declares no exceptions in its throws clause.getExceptionTypes in class Executablepublic Type[] getGenericExceptionTypes()
Type objects that represent the
 exceptions declared to be thrown by this executable object.
 Returns an array of length 0 if the underlying executable declares
 no exceptions in its throws clause.
 If an exception type is a type variable or a parameterized type, it is created. Otherwise, it is resolved.
getGenericExceptionTypes in class ExecutableGenericSignatureFormatError - if the generic method signature does not conform to the format
     specified in
     The Java™ Virtual Machine SpecificationTypeNotPresentException - if the underlying executable's
     throws clause refers to a non-existent type declarationMalformedParameterizedTypeException - if
     the underlying executable's throws clause refers to a
     parameterized type that cannot be instantiated for any reasonpublic boolean equals(Object obj)
Constructor against the specified object.
 Returns true if the objects are the same.  Two Constructor objects are
 the same if they were declared by the same class and have the
 same formal parameter types.equals in class Objectobj - the reference object with which to compare.true if this object is the same as the obj
          argument; false otherwise.Object.hashCode(), 
HashMappublic int hashCode()
Constructor. The hashcode is
 the same as the hashcode for the underlying constructor's
 declaring class name.hashCode in class ObjectObject.equals(java.lang.Object), 
System.identityHashCode(java.lang.Object)public String toString()
Constructor.  The string is
 formatted as the constructor access modifiers, if any,
 followed by the fully-qualified name of the declaring class,
 followed by a parenthesized, comma-separated list of the
 constructor's formal parameter types.  For example:
 
    public java.util.Hashtable(int,float)
 
 The only possible modifiers for constructors are the access
 modifiers public, protected or
 private.  Only one of these may appear, or none if the
 constructor has default (package) access.
public String toGenericString()
Constructor,
 including type parameters.  The string is formatted as the
 constructor access modifiers, if any, followed by an
 angle-bracketed comma separated list of the constructor's type
 parameters, if any, followed by the fully-qualified name of the
 declaring class, followed by a parenthesized, comma-separated
 list of the constructor's generic formal parameter types.
 If this constructor was declared to take a variable number of
 arguments, instead of denoting the last parameter as
 "Type[]", it is denoted as
 "Type...".
 A space is used to separate access modifiers from one another
 and from the type parameters or return type.  If there are no
 type parameters, the type parameter list is elided; if the type
 parameter list is present, a space separates the list from the
 class name.  If the constructor is declared to throw
 exceptions, the parameter list is followed by a space, followed
 by the word "throws" followed by a
 comma-separated list of the thrown exception types.
 The only possible modifiers for constructors are the access
 modifiers public, protected or
 private.  Only one of these may appear, or none if the
 constructor has default (package) access.
toGenericString in class ExecutableConstructor,
 include type parameterspublic T newInstance(Object... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
Constructor object to
 create and initialize a new instance of the constructor's
 declaring class, with the specified initialization parameters.
 Individual parameters are automatically unwrapped to match
 primitive formal parameters, and both primitive and reference
 parameters are subject to method invocation conversions as necessary.
 If the number of formal parameters required by the underlying constructor
 is 0, the supplied initargs array may be of length 0 or null.
 
If the constructor's declaring class is an inner class in a non-static context, the first argument to the constructor needs to be the enclosing instance; see section 15.9.3 of The Java™ Language Specification.
If the required access and argument checks succeed and the instantiation will proceed, the constructor's declaring class is initialized if it has not already been initialized.
If the constructor completes normally, returns the newly created and initialized instance.
initargs - array of objects to be passed as arguments to
 the constructor call; values of primitive types are wrapped in
 a wrapper object of the appropriate type (e.g. a float
 in a Float)IllegalAccessException - if this Constructor object
              is enforcing Java language access control and the underlying
              constructor is inaccessible.IllegalArgumentException - if the number of actual
              and formal parameters differ; if an unwrapping
              conversion for primitive arguments fails; or if,
              after possible unwrapping, a parameter value
              cannot be converted to the corresponding formal
              parameter type by a method invocation conversion; if
              this constructor pertains to an enum type.InstantiationException - if the class that declares the
              underlying constructor represents an abstract class.InvocationTargetException - if the underlying constructor
              throws an exception.ExceptionInInitializerError - if the initialization provoked
              by this method fails.public boolean isVarArgs()
true if this executable was declared to take a
 variable number of arguments; returns false otherwise.isVarArgs in class Executabletrue if an only if this executable was declared
 to take a variable number of arguments.public boolean isSynthetic()
true if this executable is a synthetic
 construct; returns false otherwise.isSynthetic in interface MemberisSynthetic in class Executablepublic <T extends Annotation> T getAnnotation(Class<T> annotationClass)
getAnnotation in interface AnnotatedElementgetAnnotation in class ExecutableT - the type of the annotation to query for and return if presentannotationClass - the Class object corresponding to the
        annotation typeNullPointerException - if the given annotation class is nullpublic Annotation[] getDeclaredAnnotations()
getDeclaredAnnotations in interface AnnotatedElementgetDeclaredAnnotations in class Executablepublic Annotation[][] getParameterAnnotations()
Annotations that
 represent the annotations on the formal parameters, in
 declaration order, of the Executable represented by
 this object.  Synthetic and mandated parameters (see
 explanation below), such as the outer "this" parameter to an
 inner class constructor will be represented in the returned
 array.  If the executable has no parameters (meaning no formal,
 no synthetic, and no mandated parameters), a zero-length array
 will be returned.  If the Executable has one or more
 parameters, a nested array of length zero is returned for each
 parameter with no annotations. The annotation objects contained
 in the returned arrays are serializable.  The caller of this
 method is free to modify the returned arrays; it will have no
 effect on the arrays returned to other callers.
 A compiler may add extra parameters that are implicitly
 declared in source ("mandated"), as well as parameters that
 are neither implicitly nor explicitly declared in source
 ("synthetic") to the parameter list for a method.  See Parameter for more information.getParameterAnnotations in class ExecutableParameter, 
Parameter.getAnnotations()public AnnotatedType getAnnotatedReturnType()
AnnotatedType object that represents the use of a type to
 specify the return type of the method/constructor represented by this
 Executable.
 If this Executable object represents a constructor, the AnnotatedType object represents the type of the constructed object.
 If this Executable object represents a method, the AnnotatedType object represents the use of a type to specify the return
 type of the method.getAnnotatedReturnType in class ExecutableExecutablepublic AnnotatedType getAnnotatedReceiverType()
AnnotatedType object that represents the use of a
 type to specify the receiver type of the method/constructor represented
 by this Executable object. The receiver type of a method/constructor is
 available only if the method/constructor has a receiver
 parameter (JLS 8.4.1).
 If this Executable object represents a constructor or instance
 method that does not have a receiver parameter, or has a receiver
 parameter with no annotations on its type, then the return value is an
 AnnotatedType object representing an element with no
 annotations.
 If this Executable object represents a static method, then the
 return value is null.getAnnotatedReceiverType in class ExecutableExecutable Submit a bug or feature 
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
 Copyright © 1993, 2025, Oracle and/or its affiliates.  All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.