src/share/classes/java/lang/reflect/Method.java

Print this page




 325 
 326     /**
 327      * Returns a string describing this {@code Method}.  The string is
 328      * formatted as the method access modifiers, if any, followed by
 329      * the method return type, followed by a space, followed by the
 330      * class declaring the method, followed by a period, followed by
 331      * the method name, followed by a parenthesized, comma-separated
 332      * list of the method's formal parameter types. If the method
 333      * throws checked exceptions, the parameter list is followed by a
 334      * space, followed by the word throws followed by a
 335      * comma-separated list of the thrown exception types.
 336      * For example:
 337      * <pre>
 338      *    public boolean java.lang.Object.equals(java.lang.Object)
 339      * </pre>
 340      *
 341      * <p>The access modifiers are placed in canonical order as
 342      * specified by "The Java Language Specification".  This is
 343      * {@code public}, {@code protected} or {@code private} first,
 344      * and then other modifiers in the following order:
 345      * {@code abstract}, {@code static}, {@code final},
 346      * {@code synchronized}, {@code native}, {@code strictfp},
 347      * {@code default}.
 348      *
 349      * @return a string describing this {@code Method}
 350      *
 351      * @jls 8.4.3 Method Modifiers
 352      */
 353     public String toString() {
 354         return sharedToString(Modifier.methodModifiers(),
 355                               isDefault(),
 356                               parameterTypes,
 357                               exceptionTypes);
 358     }
 359 
 360     @Override
 361     void specificToStringHeader(StringBuilder sb) {
 362         sb.append(Field.getTypeName(getReturnType())).append(' ');
 363         sb.append(Field.getTypeName(getDeclaringClass())).append('.');
 364         sb.append(getName());
 365     }
 366 
 367     /**
 368      * Returns a string describing this {@code Method}, including
 369      * type parameters.  The string is formatted as the method access
 370      * modifiers, if any, followed by an angle-bracketed
 371      * comma-separated list of the method's type parameters, if any,
 372      * followed by the method's generic return type, followed by a
 373      * space, followed by the class declaring the method, followed by
 374      * a period, followed by the method name, followed by a
 375      * parenthesized, comma-separated list of the method's generic
 376      * formal parameter types.
 377      *
 378      * If this method was declared to take a variable number of
 379      * arguments, instead of denoting the last parameter as
 380      * "<tt><i>Type</i>[]</tt>", it is denoted as
 381      * "<tt><i>Type</i>...</tt>".
 382      *
 383      * A space is used to separate access modifiers from one another
 384      * and from the type parameters or return type.  If there are no
 385      * type parameters, the type parameter list is elided; if the type
 386      * parameter list is present, a space separates the list from the
 387      * class name.  If the method is declared to throw exceptions, the
 388      * parameter list is followed by a space, followed by the word
 389      * throws followed by a comma-separated list of the generic thrown
 390      * exception types.  If there are no type parameters, the type
 391      * parameter list is elided.
 392      *
 393      * <p>The access modifiers are placed in canonical order as
 394      * specified by "The Java Language Specification".  This is
 395      * {@code public}, {@code protected} or {@code private} first,
 396      * and then other modifiers in the following order:
 397      * {@code abstract}, {@code static}, {@code final},
 398      * {@code synchronized}, {@code native}, {@code strictfp},
 399      * {@code default}.
 400      *
 401      * @return a string describing this {@code Method},
 402      * include type parameters
 403      *
 404      * @since 1.5
 405      *
 406      * @jls 8.4.3 Method Modifiers
 407      */
 408     @Override
 409     public String toGenericString() {
 410         return sharedToGenericString(Modifier.methodModifiers(), isDefault());
 411     }
 412 
 413     @Override
 414     void specificToGenericStringHeader(StringBuilder sb) {
 415         Type genRetType = getGenericReturnType();
 416         sb.append( ((genRetType instanceof Class<?>)?
 417                     Field.getTypeName((Class<?>)genRetType):genRetType.toString()))
 418             .append(' ');
 419 
 420         sb.append(Field.getTypeName(getDeclaringClass())).append('.');
 421         sb.append(getName());
 422     }
 423 
 424     /**
 425      * Invokes the underlying method represented by this {@code Method}
 426      * object, on the specified object with the specified parameters.
 427      * Individual parameters are automatically unwrapped to match
 428      * primitive formal parameters, and both primitive and reference
 429      * parameters are subject to method invocation conversions as
 430      * necessary.
 431      *
 432      * <p>If the underlying method is static, then the specified {@code obj}
 433      * argument is ignored. It may be null.
 434      *
 435      * <p>If the number of formal parameters required by the underlying method is
 436      * 0, the supplied {@code args} array may be of length 0 or null.
 437      *
 438      * <p>If the underlying method is an instance method, it is invoked
 439      * using dynamic method lookup as documented in The Java Language
 440      * Specification, Second Edition, section 15.12.4.4; in particular,




 325 
 326     /**
 327      * Returns a string describing this {@code Method}.  The string is
 328      * formatted as the method access modifiers, if any, followed by
 329      * the method return type, followed by a space, followed by the
 330      * class declaring the method, followed by a period, followed by
 331      * the method name, followed by a parenthesized, comma-separated
 332      * list of the method's formal parameter types. If the method
 333      * throws checked exceptions, the parameter list is followed by a
 334      * space, followed by the word throws followed by a
 335      * comma-separated list of the thrown exception types.
 336      * For example:
 337      * <pre>
 338      *    public boolean java.lang.Object.equals(java.lang.Object)
 339      * </pre>
 340      *
 341      * <p>The access modifiers are placed in canonical order as
 342      * specified by "The Java Language Specification".  This is
 343      * {@code public}, {@code protected} or {@code private} first,
 344      * and then other modifiers in the following order:
 345      * {@code abstract}, {@code default}, {@code static}, {@code final},
 346      * {@code synchronized}, {@code native}, {@code strictfp}.

 347      *
 348      * @return a string describing this {@code Method}
 349      *
 350      * @jls 8.4.3 Method Modifiers
 351      */
 352     public String toString() {
 353         return sharedToString(Modifier.methodModifiers(),
 354                               isDefault(),
 355                               parameterTypes,
 356                               exceptionTypes);
 357     }
 358 
 359     @Override
 360     void specificToStringHeader(StringBuilder sb) {
 361         sb.append(getReturnType().getTypeName()).append(' ');
 362         sb.append(getDeclaringClass().getTypeName()).append('.');
 363         sb.append(getName());
 364     }
 365 
 366     /**
 367      * Returns a string describing this {@code Method}, including
 368      * type parameters.  The string is formatted as the method access
 369      * modifiers, if any, followed by an angle-bracketed
 370      * comma-separated list of the method's type parameters, if any,
 371      * followed by the method's generic return type, followed by a
 372      * space, followed by the class declaring the method, followed by
 373      * a period, followed by the method name, followed by a
 374      * parenthesized, comma-separated list of the method's generic
 375      * formal parameter types.
 376      *
 377      * If this method was declared to take a variable number of
 378      * arguments, instead of denoting the last parameter as
 379      * "<tt><i>Type</i>[]</tt>", it is denoted as
 380      * "<tt><i>Type</i>...</tt>".
 381      *
 382      * A space is used to separate access modifiers from one another
 383      * and from the type parameters or return type.  If there are no
 384      * type parameters, the type parameter list is elided; if the type
 385      * parameter list is present, a space separates the list from the
 386      * class name.  If the method is declared to throw exceptions, the
 387      * parameter list is followed by a space, followed by the word
 388      * throws followed by a comma-separated list of the generic thrown
 389      * exception types.

 390      *
 391      * <p>The access modifiers are placed in canonical order as
 392      * specified by "The Java Language Specification".  This is
 393      * {@code public}, {@code protected} or {@code private} first,
 394      * and then other modifiers in the following order:
 395      * {@code abstract}, {@code default}, {@code static}, {@code final},
 396      * {@code synchronized}, {@code native}, {@code strictfp}.

 397      *
 398      * @return a string describing this {@code Method},
 399      * include type parameters
 400      *
 401      * @since 1.5
 402      *
 403      * @jls 8.4.3 Method Modifiers
 404      */
 405     @Override
 406     public String toGenericString() {
 407         return sharedToGenericString(Modifier.methodModifiers(), isDefault());
 408     }
 409 
 410     @Override
 411     void specificToGenericStringHeader(StringBuilder sb) {
 412         Type genRetType = getGenericReturnType();
 413         sb.append(genRetType.getTypeName()).append(' ');
 414         sb.append(getDeclaringClass().getTypeName()).append('.');



 415         sb.append(getName());
 416     }
 417 
 418     /**
 419      * Invokes the underlying method represented by this {@code Method}
 420      * object, on the specified object with the specified parameters.
 421      * Individual parameters are automatically unwrapped to match
 422      * primitive formal parameters, and both primitive and reference
 423      * parameters are subject to method invocation conversions as
 424      * necessary.
 425      *
 426      * <p>If the underlying method is static, then the specified {@code obj}
 427      * argument is ignored. It may be null.
 428      *
 429      * <p>If the number of formal parameters required by the underlying method is
 430      * 0, the supplied {@code args} array may be of length 0 or null.
 431      *
 432      * <p>If the underlying method is an instance method, it is invoked
 433      * using dynamic method lookup as documented in The Java Language
 434      * Specification, Second Edition, section 15.12.4.4; in particular,