*
* Note: This class returns and accepts types as Classes, even
* primitive types; there are Class types defined that represent each
* different primitive type. They are java.lang.Boolean.TYPE,
* java.lang.Byte.TYPE,, also available as boolean.class,
* byte.class, etc. These are not to be confused with the
* classes java.lang.Boolean, java.lang.Byte, etc., which are
* real classes.
*
* Also note that this is not a serializable class. It is entirely feasible
* to make it serializable using the Externalizable interface, but this is
* on Sun, not me.
*
* @author John Keiser
* @author Eric Blake
*
* If this class is abstract, you will get an
*
*
* If this Constructor enforces access control, your runtime context is
* evaluated, and you may have an
*
* Then, the constructor is invoked. If it completes normally, the return
* value will be the new object. If it completes abruptly, the exception is
* wrapped in an Modifier
* class to interpret the values. A constructor can only have a subset of the
* following modifiers: public, private, protected.
*
* @return an integer representing the modifiers to this Member
* @see Modifier
*/
public int getModifiers ()
{
return getModifiersInternal() & CONSTRUCTOR_MODIFIERS;
}
/**
* Return true if this constructor is synthetic, false otherwise.
* A synthetic member is one which is created by the compiler,
* and which does not appear in the user's source code.
* @since 1.5
*/
public boolean isSynthetic()
{
return (getModifiersInternal() & Modifier.SYNTHETIC) != 0;
}
/**
* Return true if this is a varargs constructor, that is if
* the constructor takes a variable number of arguments.
* @since 1.5
*/
public boolean isVarArgs()
{
return (getModifiersInternal() & Modifier.VARARGS) != 0;
}
/**
* Get the parameter list for this constructor, in declaration order. If the
* constructor takes no parameters, returns a 0-length array (not null).
*
* @return a list of the types of the constructor's parameters
*/
public Class[] getParameterTypes ()
{
if (parameter_types == null)
getType ();
return (Class[]) parameter_types.clone();
}
/**
* Get the exception types this constructor says it throws, in no particular
* order. If the constructor has no throws clause, returns a 0-length array
* (not null).
*
* @return a list of the types in the constructor's throws clause
*/
public Class[] getExceptionTypes ()
{
if (exception_types == null)
getType();
return (Class[]) exception_types.clone();
}
/**
* Compare two objects to see if they are semantically equivalent.
* Two Constructors are semantically equivalent if they have the same
* declaring class and the same parameter list.
*
* @param o the object to compare to
* @return true if they are equal; false if not.
*/
public boolean equals (Object obj)
{
if (! (obj instanceof Constructor))
return false;
Constructor c = (Constructor) obj;
return declaringClass == c.declaringClass && offset == c.offset;
}
/**
* Get the hash code for the Constructor. The Constructor hash code is the
* hash code of the declaring class's name.
*
* @return the hash code for the object
*/
public int hashCode ()
{
return declaringClass.getName().hashCode();
}
/**
* Get a String representation of the Constructor. A Constructor's String
* representation is "<modifier> <classname>(<paramtypes>)
* throws <exceptions>", where everything after ')' is omitted if
* there are no exceptions.
Example:
* public java.io.FileInputStream(java.lang.Runnable)
* throws java.io.FileNotFoundException
*
* @return the String representation of the Constructor
*/
public String toString()
{
if (parameter_types == null)
getType ();
StringBuffer b = new StringBuffer ();
int mods = getModifiers();
if (mods != 0)
{
Modifier.toString(mods, b);
b.append(" ");
}
Method.appendClassName (b, declaringClass);
b.append("(");
for (int i = 0; i < parameter_types.length; ++i)
{
Method.appendClassName (b, parameter_types[i]);
if (i < parameter_types.length - 1)
b.append(",");
}
b.append(")");
return b.toString();
}
static InstantiationException. If the constructor takes 0
* arguments, you may use null or a 0-length array for args.IllegalAccessException if
* you could not create this object in similar compiled code. If the class
* is uninitialized, you trigger class initialization, which may end in a
* ExceptionInInitializerError.InvocationTargetException.
*
* @param args the arguments to the constructor
* @return the newly created object
* @throws IllegalAccessException if the constructor could not normally be
* called by the Java code (i.e. it is not public)
* @throws IllegalArgumentException if the number of arguments is incorrect;
* or if the arguments types are wrong even with a widening
* conversion
* @throws InstantiationException if the class is abstract
* @throws InvocationTargetException if the constructor throws an exception
* @throws ExceptionInInitializerError if construction triggered class
* initialization, which then failed
*/
public native T newInstance (Object... args)
throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException;
/**
* Returns an array of TypeVariable objects that represents
* the type variables declared by this constructor, in declaration order.
* An array of size zero is returned if this constructor has no type
* variables.
*
* @return the type variables associated with this constructor.
* @throws GenericSignatureFormatError if the generic signature does
* not conform to the format specified in the Virtual Machine
* specification, version 3.
* @since 1.5
*/
public TypeVariableType objects that represents
* the exception types declared by this constructor, in declaration order.
* An array of size zero is returned if this constructor declares no
* exceptions.
*
* @return the exception types declared by this constructor.
* @throws GenericSignatureFormatError if the generic signature does
* not conform to the format specified in the Virtual Machine
* specification, version 3.
* @since 1.5
*/
public Type[] getGenericExceptionTypes()
{
String sig = getSignature();
if (sig == null)
return getExceptionTypes();
MethodSignatureParser p = new MethodSignatureParser(this, sig);
return p.getGenericExceptionTypes();
}
/**
* Returns an array of Type objects that represents
* the parameter list for this constructor, in declaration order.
* An array of size zero is returned if this constructor takes no
* parameters.
*
* @return a list of the types of the constructor's parameters
* @throws GenericSignatureFormatError if the generic signature does
* not conform to the format specified in the Virtual Machine
* specification, version 3.
* @since 1.5
*/
public Type[] getGenericParameterTypes()
{
String sig = getSignature();
if (sig == null)
return getParameterTypes();
MethodSignatureParser p = new MethodSignatureParser(this, sig);
return p.getGenericParameterTypes();
}
public