*
* 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 modifiers;
}
/**
* 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()
{
return Method.GetParameterTypesHelper(methodCookie);
}
/**
* 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()
{
ClassLoader loader = getDeclaringClass().getClassLoader();
String[] ex = Method.GetExceptionTypes(methodCookie);
Class[] exc = new Class[ex.length];
for(int i = 0; i < ex.length; i++)
{
try
{
exc[i] = Class.forName(ex[i], false, loader);
}
catch(ClassNotFoundException x)
{
throw new NoClassDefFoundError(ex[i]);
}
}
return exc;
}
/**
* 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. This ignores different
* exception clauses, but since you can't create a Method except through the
* VM, this is just the == relation.
*
* @param o the object to compare to
* @return true if they are equal; false if not.
*/
public boolean equals(Object o)
{
if(o instanceof Constructor)
{
return methodCookie == ((Constructor)o).methodCookie;
}
return false;
}
/**
* 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 getDeclaringClass().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()
{
StringBuffer sb = new StringBuffer();
Modifier.toString(getModifiers(), sb).append(' ');
sb.append(getDeclaringClass().getName()).append('(');
Class[] c = getParameterTypes();
if (c.length > 0)
{
sb.append(c[0].getName());
for (int i = 1; i < c.length; i++)
sb.append(',').append(c[i].getName());
}
sb.append(')');
c = getExceptionTypes();
if (c.length > 0)
{
sb.append(" throws ").append(c[0].getName());
for (int i = 1; i < c.length; i++)
sb.append(',').append(c[i].getName());
}
return sb.toString();
}
/**
* Create a new instance by invoking the constructor. Arguments are
* automatically unwrapped and widened, if needed.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 Object newInstance(Object args[])
throws InstantiationException, IllegalAccessException,
InvocationTargetException
{
if(!isAccessible() && (!Modifier.isPublic(modifiers) || !classIsPublic))
VMFieldImpl.checkAccess(modifiers, null, declaringClass, VMStackWalker.getCallingClass());
int mods = declaringClass.getModifiers() | Method.GetRealModifiers(declaringClass);
if(Modifier.isAbstract(mods) || Modifier.isInterface(mods))
{
throw new InstantiationException();
}
return Method.Invoke(methodCookie, null, args);
}
}