Save This Page
Home » openjdk-7 » java » lang » reflect » [javadoc | source]
java.lang.reflect
public final class: Constructor [javadoc | source]
java.lang.Object
   java.lang.reflect.AccessibleObject
      java.lang.reflect.Constructor

All Implemented Interfaces:
    GenericDeclaration, Member, AnnotatedElement

{@code Constructor} provides information about, and access to, a single constructor for a class.

{@code Constructor} permits widening conversions to occur when matching the actual parameters to newInstance() with the underlying constructor's formal parameters, but throws an {@code IllegalArgumentException} if a narrowing conversion would occur.

Fields inherited from java.lang.reflect.AccessibleObject:
override,  reflectionFactory,  securityCheckCache
Constructor:
 Constructor(Class<T> declaringClass,
    Class<?>[] parameterTypes,
    Class<?>[] checkedExceptions,
    int modifiers,
    int slot,
    String signature,
    byte[] annotations,
    byte[] parameterAnnotations) 
    Package-private constructor used by ReflectAccess to enable instantiation of these objects in Java code from the java.lang package via sun.reflect.LangReflectAccess.
Method from java.lang.reflect.Constructor Summary:
copy,   equals,   getAnnotation,   getConstructorAccessor,   getDeclaredAnnotations,   getDeclaringClass,   getExceptionTypes,   getGenericExceptionTypes,   getGenericParameterTypes,   getModifiers,   getName,   getParameterAnnotations,   getParameterTypes,   getRawAnnotations,   getRawParameterAnnotations,   getSignature,   getSlot,   getTypeParameters,   hashCode,   isSynthetic,   isVarArgs,   newInstance,   setConstructorAccessor,   toGenericString,   toString
Methods from java.lang.reflect.AccessibleObject:
checkAccess,   getAnnotation,   getAnnotations,   getDeclaredAnnotations,   isAccessible,   isAnnotationPresent,   setAccessible,   setAccessible,   slowCheckMemberAccess
Methods from java.lang.Object:
clone,   equals,   finalize,   getClass,   hashCode,   notify,   notifyAll,   toString,   wait,   wait,   wait
Method from java.lang.reflect.Constructor Detail:
 Constructor<T> copy() 
    Package-private routine (exposed to java.lang.Class via ReflectAccess) which returns a copy of this Constructor. The copy's "root" field points to this Constructor.
 public boolean equals(Object obj) 
    Compares this {@code Constructor} against the specified object. Returns true if the objects are the same. Two {@code Constructor} objects are the same if they were declared by the same class and have the same formal parameter types.
 public T getAnnotation(Class<T> annotationClass) 
 ConstructorAccessor getConstructorAccessor() 
 public Annotation[] getDeclaredAnnotations() 
 public Class<T> getDeclaringClass() 
    Returns the {@code Class} object representing the class that declares the constructor represented by this {@code Constructor} object.
 public Class<?>[] getExceptionTypes() 
    Returns an array of {@code Class} objects that represent the types of exceptions declared to be thrown by the underlying constructor represented by this {@code Constructor} object. Returns an array of length 0 if the constructor declares no exceptions in its {@code throws} clause.
 public Type[] getGenericExceptionTypes() 
    Returns an array of {@code Type} objects that represent the exceptions declared to be thrown by this {@code Constructor} object. Returns an array of length 0 if the underlying method declares no exceptions in its {@code throws} clause.

    If an exception type is a type variable or a parameterized type, it is created. Otherwise, it is resolved.

 public Type[] getGenericParameterTypes() 
    Returns an array of {@code Type} objects that represent the formal parameter types, in declaration order, of the method represented by this {@code 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 {@code 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.

 public int getModifiers() 
    Returns the Java language modifiers for the constructor represented by this {@code Constructor} object, as an integer. The {@code Modifier} class should be used to decode the modifiers.
 public String getName() 
    Returns the name of this constructor, as a string. This is the binary name of the constructor's declaring class.
 public Annotation[][] getParameterAnnotations() 
    Returns an array of arrays that represent the annotations on the formal parameters, in declaration order, of the method represented by this {@code 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.
 public Class<?>[] getParameterTypes() 
    Returns an array of {@code Class} objects that represent the formal parameter types, in declaration order, of the constructor represented by this {@code Constructor} object. Returns an array of length 0 if the underlying constructor takes no parameters.
 byte[] getRawAnnotations() 
 byte[] getRawParameterAnnotations() 
 String getSignature() 
 int getSlot() 
 public TypeVariable<T>[] getTypeParameters() 
    Returns an array of {@code TypeVariable} objects that represent the type variables declared by the generic declaration represented by this {@code GenericDeclaration} object, in declaration order. Returns an array of length 0 if the underlying generic declaration declares no type variables.
 public int hashCode() 
    Returns a hashcode for this {@code Constructor}. The hashcode is the same as the hashcode for the underlying constructor's declaring class name.
 public boolean isSynthetic() 
    Returns {@code true} if this constructor is a synthetic constructor; returns {@code false} otherwise.
 public boolean isVarArgs() 
    Returns {@code true} if this constructor was declared to take a variable number of arguments; returns {@code false} otherwise.
 public T newInstance(Object initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException 
    Uses the constructor represented by this {@code 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 {@code 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.

  void setConstructorAccessor(ConstructorAccessor accessor) 
 public String toGenericString() 
    Returns a string describing this {@code 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 "{@code throws}" followed by a comma-separated list of the thrown exception types.

    The only possible modifiers for constructors are the access modifiers {@code public}, {@code protected} or {@code private}. Only one of these may appear, or none if the constructor has default (package) access.

 public String toString() 
    Returns a string describing this {@code 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 {@code public}, {@code protected} or {@code private}. Only one of these may appear, or none if the constructor has default (package) access.