diff options
Diffstat (limited to 'libjava/java/lang/reflect/Method.java')
| -rw-r--r-- | libjava/java/lang/reflect/Method.java | 228 |
1 files changed, 177 insertions, 51 deletions
diff --git a/libjava/java/lang/reflect/Method.java b/libjava/java/lang/reflect/Method.java index 7bd0a312511..3e0507fcaa1 100644 --- a/libjava/java/lang/reflect/Method.java +++ b/libjava/java/lang/reflect/Method.java @@ -1,6 +1,6 @@ // Method.java - Represent method of class or interface. -/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation +/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation This file is part of libgcj. @@ -13,43 +13,92 @@ package java.lang.reflect; import gnu.gcj.RawData; /** - * @author Tom Tromey <tromey@cygnus.com> - * @date December 12, 1998 + * The Method class represents a member method of a class. It also allows + * dynamic invocation, via reflection. This works for both static and + * instance methods. Invocation on Method 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 Method regardless of location, but invocation 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#getMethod(String,Object[]) + * @see java.lang.Class#getDeclaredMethod(String,Object[]) + * @see java.lang.Class#getMethods() + * @see java.lang.Class#getDeclaredMethods() + * @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: Complete, but not correct: access checks aren't done. - */ - public final class Method extends AccessibleObject implements Member { - public boolean equals (Object obj) + /** + * This class is uninstantiable. + */ + private Method () { - if (! (obj instanceof Method)) - return false; - Method m = (Method) obj; - return declaringClass == m.declaringClass && offset == m.offset; } + /** + * Gets the class that declared this method, or the class where this method + * is a non-inherited member. + * @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(); - } + /** + * Gets the name of this method. + * @return the name of this method + */ + public native String getName (); + /** + * Gets the modifiers this method uses. Use the <code>Modifier</code> + * class to interpret the values. A method can only have a subset of the + * following modifiers: public, private, protected, abstract, static, + * final, synchronized, native, and strictfp. + * + * @return an integer representing the modifiers to this Member + * @see Modifier + */ public native int getModifiers (); - public native String getName (); - - private native void getType (); + /** + * Gets the return type of this method. + * @return the type of this method + */ + public Class getReturnType () + { + if (return_type == null) + getType(); + return return_type; + } + /** + * Get the parameter list for this method, in declaration order. If the + * method takes no parameters, returns a 0-length array (not null). + * + * @return a list of the types of the method's parameters + */ public Class[] getParameterTypes () { if (parameter_types == null) @@ -57,43 +106,57 @@ public final class Method extends AccessibleObject implements Member return (Class[]) parameter_types.clone(); } - public Class getReturnType () + /** + * Get the exception types this method says it throws, in no particular + * order. If the method has no throws clause, returns a 0-length array + * (not null). + * + * @return a list of the types in the method's throws clause + */ + public Class[] getExceptionTypes () { - if (return_type == null) + if (exception_types == null) getType(); - return return_type; + return (Class[]) exception_types.clone(); } - public int hashCode () + /** + * Compare two objects to see if they are semantically equivalent. + * Two Methods are semantically equivalent if they have the same declaring + * class, name, and parameter list. This ignores different exception + * clauses or return types. + * + * @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) { - // FIXME. - return getName().hashCode() + declaringClass.getName().hashCode(); + if (! (obj instanceof Method)) + return false; + Method m = (Method) obj; + return declaringClass == m.declaringClass && offset == m.offset; } - public native Object invoke (Object obj, Object[] args) - throws IllegalAccessException, IllegalArgumentException, - InvocationTargetException; - - // Append a class name to a string buffer. We try to print the - // fully-qualified name, the way that a Java programmer would expect - // it to be written. Weirdly, Class has no appropriate method for - // this. - static void appendClassName (StringBuffer buf, Class k) + /** + * Get the hash code for the Method. + * + * @return the hash code for the object + */ + public int hashCode () { - if (k.isArray ()) - { - appendClassName (buf, k.getComponentType ()); - buf.append ("[]"); - } - else - { - // This is correct for primitive and reference types. Really - // we'd like `Main$Inner' to be printed as `Main.Inner', I - // think, but that is a pain. - buf.append (k.getName ()); - } + // FIXME. + return getName().hashCode() + declaringClass.getName().hashCode(); } + /** + * Get a String representation of the Method. A Method's String + * representation is "<modifiers> <returntype> + * <methodname>(<paramtypes>) throws <exceptions>", where + * everything after ')' is omitted if there are no exceptions.<br> Example: + * <code>public static int run(java.lang.Runnable,int)</code> + * + * @return the String representation of the Method + */ public String toString () { if (parameter_types == null) @@ -128,8 +191,71 @@ public final class Method extends AccessibleObject implements Member return b.toString(); } - private Method () + /** + * Invoke the method. Arguments are automatically unwrapped and widened, + * and the result is automatically wrapped, if needed.<p> + * + * If the method is static, <code>o</code> will be ignored. Otherwise, + * the method uses dynamic lookup as described in JLS 15.12.4.4. You cannot + * mimic the behavior of nonvirtual lookup (as in super.foo()). This means + * you will get a <code>NullPointerException</code> if <code>o</code> is + * null, and an <code>IllegalArgumentException</code> if it is incompatible + * with the declaring class of the method. If the method takes 0 arguments, + * you may use null or a 0-length array for <code>args</code>.<p> + * + * Next, if this Method enforces access control, your runtime context is + * evaluated, and you may have an <code>IllegalAccessException</code> if + * you could not acces this method in similar compiled code. If the method + * is static, and its class is uninitialized, you trigger class + * initialization, which may end in a + * <code>ExceptionInInitializerError</code>.<p> + * + * Finally, the method is invoked. If it completes normally, the return value + * will be null for a void method, a wrapped object for a primitive return + * method, or the actual return of an Object method. If it completes + * abruptly, the exception is wrapped in an + * <code>InvocationTargetException</code>. + * + * @param o the object to invoke the method on + * @param args the arguments to the method + * @return the return value of the method, wrapped in the appropriate + * wrapper if it is primitive + * @throws IllegalAccessException if the method could not normally be called + * by the Java code (i.e. it is not public) + * @throws IllegalArgumentException if the number of arguments is incorrect; + * if the arguments types are wrong even with a widening conversion; + * or if <code>o</code> is not an instance of the class or interface + * declaring this method + * @throws InvocationTargetException if the method throws an exception + * @throws NullPointerException if <code>o</code> is null and this field + * requires an instance + * @throws ExceptionInInitializerError if accessing a static method triggered + * class initialization, which then failed + */ + public native Object invoke (Object obj, Object[] args) + throws IllegalAccessException, IllegalArgumentException, + InvocationTargetException; + + private native void getType (); + + // Append a class name to a string buffer. We try to print the + // fully-qualified name, the way that a Java programmer would expect + // it to be written. Weirdly, Class has no appropriate method for + // this. + static void appendClassName (StringBuffer buf, Class k) { + if (k.isArray ()) + { + appendClassName (buf, k.getComponentType ()); + buf.append ("[]"); + } + else + { + // This is correct for primitive and reference types. Really + // we'd like `Main$Inner' to be printed as `Main.Inner', I + // think, but that is a pain. + buf.append (k.getName ()); + } } // Declaring class. |
