Constructor(Class<T> declaringClass,
    Class<?>[] parameterTypes,
    Class<?>[] checkedExceptions,
    int modifiers,
    int slot,
    String signature,
    byte[] annotations,
    byte[] parameterAnnotations) 
{
        this.clazz = declaringClass;
        this.parameterTypes = parameterTypes;
        this.exceptionTypes = checkedExceptions;
        this.modifiers = modifiers;
        this.slot = slot;
        this.signature = signature;
        this.annotations = annotations;
        this.parameterAnnotations = 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.

 Constructor<T> copy() 
{
        // This routine enables sharing of ConstructorAccessor objects
        // among Constructor objects which refer to the same underlying
        // method in the VM. (All of this contortion is only necessary
        // because of the "accessibility" bit in AccessibleObject,
        // which implicitly requires that new java.lang.reflect
        // objects be fabricated for each reflective call on Class
        // objects.)
        Constructor< T > res = new Constructor<  >(clazz,
                                                parameterTypes,
                                                exceptionTypes, modifiers, slot,
                                                signature,
                                                annotations,
                                                parameterAnnotations);
        res.root = this;
        // Might as well eagerly propagate this if already present
        res.constructorAccessor = constructorAccessor;
        return res;
}

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) 
{
        if (obj != null && obj instanceof Constructor) {
            Constructor< ? > other = (Constructor< ? >)obj;
            if (getDeclaringClass() == other.getDeclaringClass()) {
                /* Avoid unnecessary cloning */
                Class< ? >[] params1 = parameterTypes;
                Class< ? >[] params2 = other.parameterTypes;
                if (params1.length == params2.length) {
                    for (int i = 0; i <  params1.length; i++) {
                        if (params1[i] != params2[i])
                            return false;
                    }
                    return true;
                }
            }
        }
        return false;
}

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) 
{
        if (annotationClass == null)
            throw new NullPointerException();
        return (T) declaredAnnotations().get(annotationClass);
}

 ConstructorAccessor getConstructorAccessor() 
{
        return constructorAccessor;
}

 public Annotation[] getDeclaredAnnotations() 
{
        return AnnotationParser.toArray(declaredAnnotations());
}

 public Class<T> getDeclaringClass() 
{
        return clazz;
}

Returns the {@code Class} object representing the class that declares the constructor represented by this {@code Constructor} object.

 public Class<?>[] getExceptionTypes() 
{
        return (Class< ? >[])exceptionTypes.clone();
}

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() 
{
          Type[] result;
          if (getSignature() != null &&
              ( (result = getGenericInfo().getExceptionTypes()).length  > 0  ))
              return result;
          else
              return getExceptionTypes();
}

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() 
{
        if (getSignature() != null)
            return getGenericInfo().getParameterTypes();
        else
            return getParameterTypes();
}

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() 
{
        return modifiers;
}

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() 
{
        return getDeclaringClass().getName();
}

Returns the name of this constructor, as a string. This is the binary name of the constructor's declaring class.

 public Annotation[][] getParameterAnnotations() 
{
        int numParameters = parameterTypes.length;
        if (parameterAnnotations == null)
            return new Annotation[numParameters][0];
        Annotation[][] result = AnnotationParser.parseParameterAnnotations(
            parameterAnnotations,
            sun.misc.SharedSecrets.getJavaLangAccess().
                getConstantPool(getDeclaringClass()),
            getDeclaringClass());
        if (result.length != numParameters) {
            Class< ? > declaringClass = getDeclaringClass();
            if (declaringClass.isEnum() ||
                declaringClass.isAnonymousClass() ||
                declaringClass.isLocalClass() )
                ; // Can't do reliable parameter counting
            else {
                if (!declaringClass.isMemberClass() || // top-level
                    // Check for the enclosing instance parameter for
                    // non-static member classes
                    (declaringClass.isMemberClass() &&
                     ((declaringClass.getModifiers() & Modifier.STATIC) == 0)  &&
                     result.length + 1 != numParameters) ) {
                    throw new AnnotationFormatError(
                              "Parameter annotations don't match number of parameters");
                }
            }
        }
        return result;
}

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() 
{
        return (Class< ? >[]) parameterTypes.clone();
}

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() 
{
        return annotations;
}

 byte[] getRawParameterAnnotations() 
{
        return parameterAnnotations;
}

 String getSignature() 
{
            return signature;
}

 int getSlot() 
{
        return slot;
}

 public TypeVariable<T>[] getTypeParameters() 
{
      if (getSignature() != null) {
        return (TypeVariable< Constructor< T > >[])getGenericInfo().getTypeParameters();
      } else
          return (TypeVariable< Constructor< T > >[])new TypeVariable[0];
}

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() 
{
        return getDeclaringClass().getName().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() 
{
        return Modifier.isSynthetic(getModifiers());
}

Returns {@code true} if this constructor is a synthetic constructor; returns {@code false} otherwise.

 public boolean isVarArgs() 
{
        return (getModifiers() & Modifier.VARARGS) != 0;
}

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 
{
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class< ? > caller = Reflection.getCallerClass(2);
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        return (T) ca.newInstance(initargs);
}

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) 
{
        constructorAccessor = accessor;
        // Propagate up
        if (root != null) {
            root.setConstructorAccessor(accessor);
        }
}

 public String toGenericString() 
{
        try {
            StringBuilder sb = new StringBuilder();
            int mod = getModifiers() & Modifier.constructorModifiers();
            if (mod != 0) {
                sb.append(Modifier.toString(mod) + " ");
            }
            TypeVariable< ? >[] typeparms = getTypeParameters();
            if (typeparms.length  > 0) {
                boolean first = true;
                sb.append("< ");
                for(TypeVariable< ? > typeparm: typeparms) {
                    if (!first)
                        sb.append(",");
                    // Class objects can't occur here; no need to test
                    // and call Class.getName().
                    sb.append(typeparm.toString());
                    first = false;
                }
                sb.append(" > ");
            }
            sb.append(Field.getTypeName(getDeclaringClass()));
            sb.append("(");
            Type[] params = getGenericParameterTypes();
            for (int j = 0; j <  params.length; j++) {
                String param = (params[j] instanceof Class< ? >)?
                    Field.getTypeName((Class< ? >)params[j]):
                    (params[j].toString());
                if (isVarArgs() && (j == params.length - 1)) // replace T[] with T...
                    param = param.replaceFirst("\\[\\]$", "...");
                sb.append(param);
                if (j <  (params.length - 1))
                    sb.append(",");
            }
            sb.append(")");
            Type[] exceptions = getGenericExceptionTypes();
            if (exceptions.length  > 0) {
                sb.append(" throws ");
                for (int k = 0; k <  exceptions.length; k++) {
                    sb.append((exceptions[k] instanceof Class)?
                              ((Class< ? >)exceptions[k]).getName():
                              exceptions[k].toString());
                    if (k <  (exceptions.length - 1))
                        sb.append(",");
                }
            }
            return sb.toString();
        } catch (Exception e) {
            return "< " + e + " >";
        }
}

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() 
{
        try {
            StringBuffer sb = new StringBuffer();
            int mod = getModifiers() & Modifier.constructorModifiers();
            if (mod != 0) {
                sb.append(Modifier.toString(mod) + " ");
            }
            sb.append(Field.getTypeName(getDeclaringClass()));
            sb.append("(");
            Class< ? >[] params = parameterTypes; // avoid clone
            for (int j = 0; j <  params.length; j++) {
                sb.append(Field.getTypeName(params[j]));
                if (j <  (params.length - 1))
                    sb.append(",");
            }
            sb.append(")");
            Class< ? >[] exceptions = exceptionTypes; // avoid clone
            if (exceptions.length  > 0) {
                sb.append(" throws ");
                for (int k = 0; k <  exceptions.length; k++) {
                    sb.append(exceptions[k].getName());
                    if (k <  (exceptions.length - 1))
                        sb.append(",");
                }
            }
            return sb.toString();
        } catch (Exception e) {
            return "< " + e + " >";
        }
}

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.