T
- the class in which the constructor is declaredpublic final class Constructor<T> extends AccessibleObject implements GenericDeclaration, Member
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
Constructor against the specified object. |
<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 all annotations that are directly present on this
element.
|
Class<T> |
getDeclaringClass()
Returns the
Class object representing the class that declares
the constructor represented by this Constructor object. |
Class<?>[] |
getExceptionTypes()
Returns an array of
Class objects that represent the types
of exceptions declared to be thrown by the underlying constructor
represented by this Constructor object. |
Type[] |
getGenericExceptionTypes()
Returns an array of
Type objects that represent the
exceptions declared to be thrown by this Constructor object. |
Type[] |
getGenericParameterTypes()
Returns an array of
Type objects that represent the formal
parameter types, in declaration order, of the method represented by
this Constructor object. |
int |
getModifiers()
Returns the Java language modifiers for the constructor
represented by this
Constructor object, as an integer. |
String |
getName()
Returns the name of this constructor, as a string.
|
Annotation[][] |
getParameterAnnotations()
Returns an array of arrays that represent the annotations on the formal
parameters, in declaration order, of the method represented by
this
Constructor object. |
Class<?>[] |
getParameterTypes()
Returns an array of
Class objects that represent the formal
parameter types, in declaration order, of the constructor
represented by this Constructor object. |
TypeVariable<Constructor<T>>[] |
getTypeParameters()
Returns an array of
TypeVariable objects that represent the
type variables declared by the generic declaration represented by this
GenericDeclaration object, in declaration order. |
int |
hashCode()
Returns a hashcode for this
Constructor . |
boolean |
isSynthetic()
Returns
true if this constructor is a synthetic
constructor; returns false otherwise. |
boolean |
isVarArgs()
Returns
true if this constructor was declared to take
a variable number of arguments; returns false
otherwise. |
T |
newInstance(Object... initargs)
Uses the constructor represented by this
Constructor object 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 . |
getAnnotations, isAccessible, isAnnotationPresent, setAccessible, setAccessible
public Class<T> getDeclaringClass()
Class
object representing the class that declares
the constructor represented by this Constructor
object.getDeclaringClass
in interface Member
public String getName()
public int getModifiers()
Constructor
object, as an integer. The
Modifier
class should be used to decode the modifiers.getModifiers
in interface Member
Modifier
public 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 GenericDeclaration
TypeVariable
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 constructor
represented by this Constructor
object. Returns an array of
length 0 if the underlying constructor takes no parameters.public Type[] getGenericParameterTypes()
Type
objects that represent the formal
parameter types, in declaration order, of the method represented by
this Constructor
object. Returns an array of length 0 if the
underlying method 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.
Type
s that represent the formal
parameter types of the underlying method, 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 method refers to a non-existent type
declarationMalformedParameterizedTypeException
- if any of
the underlying method'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 constructor
represented by this Constructor
object. Returns an array of
length 0 if the constructor declares no exceptions in its throws
clause.public Type[] getGenericExceptionTypes()
Type
objects that represent the
exceptions declared to be thrown by this Constructor
object.
Returns an array of length 0 if the underlying method 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.
GenericSignatureFormatError
- if the generic method signature does not conform to the format
specified in
The Java™ Virtual Machine SpecificationTypeNotPresentException
- if the underlying method's
throws
clause refers to a non-existent type declarationMalformedParameterizedTypeException
- if
the underlying method'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 Object
obj
- the reference object with which to compare.true
if this object is the same as the obj
argument; false
otherwise.Object.hashCode()
,
HashMap
public int hashCode()
Constructor
. The hashcode is
the same as the hashcode for the underlying constructor's
declaring class name.hashCode
in class Object
Object.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.
Constructor
,
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 constructor was declared to take
a variable number of arguments; returns false
otherwise.true
if an only if this constructor was declared to
take a variable number of arguments.public boolean isSynthetic()
true
if this constructor is a synthetic
constructor; returns false
otherwise.isSynthetic
in interface Member
public <T extends Annotation> T getAnnotation(Class<T> annotationClass)
AnnotatedElement
getAnnotation
in interface AnnotatedElement
getAnnotation
in class AccessibleObject
annotationClass
- the Class object corresponding to the
annotation typeNullPointerException
- if the given annotation class is nullpublic Annotation[] getDeclaredAnnotations()
AnnotatedElement
getDeclaredAnnotations
in interface AnnotatedElement
getDeclaredAnnotations
in class AccessibleObject
public Annotation[][] getParameterAnnotations()
Constructor
object. (Returns an array of length zero if the
underlying method is parameterless. If the method 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. 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, 2020, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.