| Methods Summary |
|---|
| private void | acquireConstructorAccessor()
// First check to see if one has been created yet, and take it
// if so.
ConstructorAccessor tmp = null;
if (root != null) tmp = root.getConstructorAccessor();
if (tmp != null) {
constructorAccessor = tmp;
return;
}
// Otherwise fabricate one and propagate it up to the root
tmp = reflectionFactory.newConstructorAccessor(this);
setConstructorAccessor(tmp);
|
| java.lang.reflect.Constructor | 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.
// 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<T>(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;
|
| private synchronized java.util.Map | declaredAnnotations()
if (declaredAnnotations == null) {
declaredAnnotations = AnnotationParser.parseAnnotations(
annotations, sun.misc.SharedSecrets.getJavaLangAccess().
getConstantPool(getDeclaringClass()),
getDeclaringClass());
}
return declaredAnnotations;
|
| public boolean | equals(java.lang.Object obj)Compares this 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.
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;
|
| public T | getAnnotation(java.lang.Class annotationClass)
if (annotationClass == null)
throw new NullPointerException();
return (T) declaredAnnotations().get(annotationClass);
|
| sun.reflect.ConstructorAccessor | getConstructorAccessor()
return constructorAccessor;
|
| public java.lang.annotation.Annotation[] | getDeclaredAnnotations()
return declaredAnnotations().values().toArray(EMPTY_ANNOTATION_ARRAY);
|
| public java.lang.Class | getDeclaringClass()Returns the Class object representing the class that declares
the constructor represented by this Constructor object.
return clazz;
|
| public java.lang.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. Returns an array of
length 0 if the constructor declares no exceptions in its throws clause.
return (Class<?>[])exceptionTypes.clone();
|
| private sun.reflect.generics.factory.GenericsFactory | getFactory()
// Generics infrastructure
// Accessor for factory
// create scope and factory
return CoreReflectionFactory.make(this, ConstructorScope.make(this));
|
| public java.lang.reflect.Type[] | getGenericExceptionTypes()Returns an array of 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 parameterized type, the Type
object returned for it must accurately reflect the actual type
parameters used in the source code.
If an exception type is a type variable or a parameterized
type, it is created. Otherwise, it is resolved.
Type[] result;
if (getSignature() != null &&
( (result = getGenericInfo().getExceptionTypes()).length > 0 ))
return result;
else
return getExceptionTypes();
|
| private sun.reflect.generics.repository.ConstructorRepository | getGenericInfo()
// lazily initialize repository if necessary
if (genericInfo == null) {
// create and cache generic info repository
genericInfo =
ConstructorRepository.make(getSignature(),
getFactory());
}
return genericInfo; //return cached repository
|
| public java.lang.reflect.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. 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.
if (getSignature() != null)
return getGenericInfo().getParameterTypes();
else
return getParameterTypes();
|
| public int | getModifiers()Returns the Java language modifiers for the constructor
represented by this Constructor object, as an integer. The
Modifier class should be used to decode the modifiers.
return modifiers;
|
| public java.lang.String | getName()Returns the name of this constructor, as a string. This is
always the same as the simple name of the constructor's declaring
class.
return getDeclaringClass().getName();
|
| public java.lang.annotation.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. (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.
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;
|
| public java.lang.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. Returns an array of
length 0 if the underlying constructor takes no parameters.
return (Class<?>[]) parameterTypes.clone();
|
| byte[] | getRawAnnotations()
return annotations;
|
| byte[] | getRawParameterAnnotations()
return parameterAnnotations;
|
| java.lang.String | getSignature()
return signature;
|
| int | getSlot()
return slot;
|
| public java.lang.reflect.TypeVariable[] | 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. Returns an
array of length 0 if the underlying generic declaration declares no type
variables.
if (getSignature() != null) {
return (TypeVariable<Constructor<T>>[])getGenericInfo().getTypeParameters();
} else
return (TypeVariable<Constructor<T>>[])new TypeVariable[0];
|
| public int | hashCode()Returns a hashcode for this Constructor. The hashcode is
the same as the hashcode for the underlying constructor's
declaring class name.
return getDeclaringClass().getName().hashCode();
|
| public boolean | isSynthetic()Returns true if this constructor is a synthetic
constructor; returns false otherwise.
return Modifier.isSynthetic(getModifiers());
|
| public boolean | isVarArgs()Returns true if this constructor was declared to take
a variable number of arguments; returns false
otherwise.
return (getModifiers() & Modifier.VARARGS) != 0;
|
| public T | newInstance(java.lang.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.
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 The Java Language
Specification, section 15.9.3.
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.
if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class caller = Reflection.getCallerClass(2);
if (securityCheckCache != caller) {
Reflection.ensureMemberAccess(caller, clazz, null, modifiers);
securityCheckCache = caller;
}
}
}
if ((clazz.getModifiers() & Modifier.ENUM) != 0)
throw new IllegalArgumentException("Cannot reflectively create enum objects");
if (constructorAccessor == null) acquireConstructorAccessor();
return (T) constructorAccessor.newInstance(initargs);
|
| void | setConstructorAccessor(sun.reflect.ConstructorAccessor accessor)
constructorAccessor = accessor;
// Propagate up
if (root != null) {
root.setConstructorAccessor(accessor);
}
|
| public java.lang.String | toGenericString()Returns a string describing this 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. 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.
try {
StringBuilder sb = new StringBuilder();
int mod = getModifiers() & LANGUAGE_MODIFIERS;
if (mod != 0) {
sb.append(Modifier.toString(mod) + " ");
}
Type[] typeparms = getTypeParameters();
if (typeparms.length > 0) {
boolean first = true;
sb.append("<");
for(Type typeparm: typeparms) {
if (!first)
sb.append(",");
if (typeparm instanceof Class)
sb.append(((Class)typeparm).getName());
else
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++) {
sb.append((params[j] instanceof Class)?
Field.getTypeName((Class)params[j]):
(params[j].toString()) );
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 + ">";
}
|
| public java.lang.String | toString()Returns a string describing this 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.
try {
StringBuffer sb = new StringBuffer();
int mod = getModifiers() & LANGUAGE_MODIFIERS;
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 + ">";
}
|
