diff options
Diffstat (limited to 'libjava/java/lang/reflect/Constructor.java')
| -rw-r--r-- | libjava/java/lang/reflect/Constructor.java | 236 |
1 files changed, 172 insertions, 64 deletions
diff --git a/libjava/java/lang/reflect/Constructor.java b/libjava/java/lang/reflect/Constructor.java index 4a30e2ae394..53db35a6975 100644 --- a/libjava/java/lang/reflect/Constructor.java +++ b/libjava/java/lang/reflect/Constructor.java @@ -1,6 +1,6 @@ // Constructor.java - Represents a constructor for a class. -/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation +/* Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation This file is part of libgcj. @@ -11,88 +11,196 @@ details. */ package java.lang.reflect; /** - * @author Tom Tromey <tromey@cygnus.com> - * @date December 12, 1998 + * The Constructor class represents a constructor of a class. It also allows + * dynamic creation of an object, via reflection. Invocation on Constructor + * objects knows how to do widening conversions, but throws + * {@link IllegalArgumentException} if a narrowing conversion would be + * necessary. You can query for information on this Constructor regardless + * of location, but construction access may be limited by Java language + * access controls. If you can't do it in the compiler, you can't normally + * do it here either.<p> + * + * <B>Note:</B> This class returns and accepts types as Classes, even + * primitive types; there are Class types defined that represent each + * different primitive type. They are <code>java.lang.Boolean.TYPE, + * java.lang.Byte.TYPE,</code>, also available as <code>boolean.class, + * byte.class</code>, etc. These are not to be confused with the + * classes <code>java.lang.Boolean, java.lang.Byte</code>, etc., which are + * real classes.<p> + * + * 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 <ebb9@email.byu.edu> + * @author Tom Tromey <tromey@redhat.com> + * @see Member + * @see Class + * @see java.lang.Class#getConstructor(Object[]) + * @see java.lang.Class#getDeclaredConstructor(Object[]) + * @see java.lang.Class#getConstructors() + * @see java.lang.Class#getDeclaredConstructors() + * @since 1.1 + * @status updated to 1.4 */ -/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 - * "The Java Language Specification", ISBN 0-201-63451-1 - * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. - * Status: Incomplete: needs a private constructor, and - * newInstance() needs to be written. - */ - public final class Constructor extends AccessibleObject implements Member { - public boolean equals (Object obj) - { - if (! (obj instanceof Constructor)) - return false; - Constructor c = (Constructor) obj; - return declaringClass == c.declaringClass && offset == c.offset; - } + /** + * This class is uninstantiable except from native code. + */ + private Constructor () + { + } + /** + * Gets the class that declared this constructor. + * @return the class that declared this member + */ public Class getDeclaringClass () - { - return declaringClass; - } - - public Class[] getExceptionTypes () - { - if (exception_types == null) - getType(); - return (Class[]) exception_types.clone(); - } - - public native int getModifiers (); + { + return declaringClass; + } + /** + * Gets the name of this constructor (the non-qualified name of the class + * it was declared in). + * @return the name of this constructor + */ public String getName () { return declaringClass.getName(); } + /** + * Gets the modifiers this constructor uses. Use the <code>Modifier</code> + * 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 native int getModifiers (); + + /** + * 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(); - } + { + 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 <code>true</code> if they are equal; <code>false</code> 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. + * + * @return the hash code for the object + */ public int hashCode () - { - // FIXME. - return getName().hashCode() + declaringClass.getName().hashCode(); - } + { + // FIXME. + return getName().hashCode() + declaringClass.getName().hashCode(); + } - // Update cached values from method descriptor in class. - private native void getType (); + /** + * 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.<br> Example: + * <code>public java.io.FileInputStream(java.lang.Runnable) + * throws java.io.FileNotFoundException</code> + * + * @return the String representation of the Constructor + */ + public String toString () + { + if (parameter_types == null) + getType (); + StringBuffer b = new StringBuffer (); + Modifier.toString(getModifiers(), 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(); + } + /** + * Create a new instance by invoking the constructor. Arguments are + * automatically unwrapped and widened, if needed.<p> + * + * If this class is abstract, you will get an + * <code>InstantiationException</code>. If the constructor takes 0 + * arguments, you may use null or a 0-length array for <code>args</code>.<p> + * + * If this Constructor enforces access control, your runtime context is + * evaluated, and you may have an <code>IllegalAccessException</code> 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 + * <code>ExceptionInInitializerError</code>.<p> + * + * 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 <code>InvocationTargetException</code>. + * + * @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 Object newInstance (Object[] args) throws InstantiationException, IllegalAccessException, - IllegalArgumentException, InvocationTargetException; + IllegalArgumentException, InvocationTargetException; - public String toString () - { - if (parameter_types == null) - getType (); - StringBuffer b = new StringBuffer (); - Modifier.toString(getModifiers(), 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(); - } - - // Can't create these. - private Constructor () - { - } + // Update cached values from method descriptor in class. + private native void getType (); // Declaring class. private Class declaringClass; |
