GrepCode: java.lang.reflect.Method (.java) - Class

JDK
/
jdk / openjdk
/
6-b14

7-b147
6-b14
/
java.lang.reflect.Method

Find Usages

Diff

Raw

Download

HTML Widget

Stack Overflow Q&A

Stack Overflow Questions

1. Examples of GoF Design Patterns

I am learning GoF Java Design Patterns and I want to see some real life examples of them. Can you guys point to some good usage of these Design Patterns.(preferably in Java's core libraries). Thank you

2. Java generics - type erasure - when and what happens

I read about Java's type erasure on Sun's website (http://java.sun.com/docs/books/tutorial/java/generics/erasure.html). I have the following question : When does type erasure occur - at compile time / runtime:when the class is loaded / runtime:when the class is instantiated. A lot of sites (including the Sun tutorial mentioned above) say type erasure occurs at compile time. If the type infor...

3. Can I obtain method parameter name using Java reflection?

If I have a class like this: public class Whatever { public void aMethod(int aParam); } is there any way to know that aMethod uses a parameter named aParam, that is of type int?

4. Calling methods reflectivly or using fixed methods with inheritance?

I'm working on a tiny web library and wonder wheter I should call the HTTP handler methods for GET, POST, PUT etc. reflectivly or not. Fixed Methods First the variant with an if else ... block calling methods given in the base class where they have a default implementation returning an error to the client. Since a request to an unsupported method needs a header with the allowed methods, I nee...

5. Java: Calling a super method which calls an overridden method

public class SuperClass { public void method1() { System.out.println("superclass method1"); this.method2(); } public void method2() { System.out.println("superclass method2"); } } public class SubClass extends SuperClass { @Override public void method1() { System.out.println("subclass method1"); super.method1(); ...

6. How can I find all the methods that call a given method in Java?

I need to get a list of all caller methods for a method of interest for me in Java. Is there a tool that can help me with this? Edit: I forgot to mention that I need to do this from a program. I'm usig Java Pathfinder and I want to run it an all the methods that call my method of interest.

7. Java reflection: How to get methods with no parameters only

I'm working on a school assignment about Java reflection. The details are below: Write a console program that asks the user for a class name, loads that class and creates an instance of it. We assume that the class has a constructor without any parameters. Then, the program prints out the names and values of the public variables of the created object, and also a list of the public m...

8. Can I pass a Method as parameter of another method in java?

I am trying to measure the execution time for several methods. so I was thinking to make a method instead of duplicate same code many times. Here is my code: private void MeasureExecutionTime(Method m) { startTime = System.nanoTime(); try { m(); } finally { endTime = System.nanoTime(); } elapsedTime = endTime - startTime; System.out.println(...

9. Is it possible to get a reference to a Java method to invoke it later?

Is it possible to obtain references to an object's methods? For example, I'd like to have a method that invokes other methods as callbacks. Something like: public class Whatever { public void myMethod(Method m,Object args[]) { } } Is this possible? EDIT: I meant an object's methods. I take it it's not possible?

10. How to determine by reflection if a Method returns 'void'

I have a java.lang.reflect.Method object and I would like to know if it's return type is void. I've checked the Javadocs and there is a getReturnType() method that returns a Class object. The thing is that they don't say what would be the return type if the method is void. Thanks!

11. Java: comparing classes with == or .equals(): is there a difference?

Possible Duplicate: Does Java guarantee that Object.getClass() == Object.getClass()? I know you're supposed to use equals() in general, but is there any way two Class<?> objects could be equal with equals() but not equal with ==? edit: I am specifically looking to find out whether two class objects exist such that Class<?> cl1 = ... Class<?> cl2 = ... cl1.equals(c...

12. How to check if a parameter of the current method has an annotation and retrieve that parameter value in Java?

Consider this code: public example(String s, int i, @Foo Bar bar) { /* ... */ } I want to check if the method has an annotation @Foo and get the argument or throw an exception if no @Foo annotation is found. My current approach is to first get the current method and then iterate through the parameter annotations: import java.lang.annotation.Annotation; import java.lang.reflect.Method; c...

13. Java reflection issue

I have this code: public static final <TypeVO extends BaseVo> List<SelectItem> populateSelectBoxForType( final Class<TypeVO> voClass, final String fieldName) { List<SelectItem> listSelectBox = null; final List<TypeVO> vosList = GenericEjbProxyFactory .getGenericTopValueObjectProxy(voClass) .getAllValueObj...

14. Java: How to find if a method is overridden from base class?

How to find out if a method is overridden by child classes? For example, public class Test { static public class B { public String m() {return "From B";}; } static public class B1 extends B { } static public class B2 extends B { public String m() {return "from B2";}; } /** * @param args * @throws FileNotFoundException */ public static void main(String[] args) { B b1 = n...

15. Java - Method Invocation & Execution

What is the difference between the invocation and execution of a method ? Are two the same thing ?

16. Java reflection: how do the Method.getGenericXXXXX methods work?

I just noticed there's a Method.getGenericReturnType() as well as Method.getReturnType() and similar pairs for exception types and parameter types. I thought generics in Java worked via type erasure. So how would these methods work at runtime? (and what would I use them for at runtime?)

17. Compile a Java class against an interface even if none was specified

I'm teaching an intro to programming course and we're using Java. I want to help the students learn how to translate a written class specification into a working program. I will provide the written specification. It specifies the name of the class and behavior in the form of method signatures. I want the students to translate that into a working Java class. I could provide them an interface an...

18. How to call a superclass method using Java reflection

I have two classes. public class A { public Object method() {...} } public class B extends A { @Override public Object method() {...} } I have an instance of B. How do I call A.method() from b? Basically, the same effect as calling super.method() from B. B b = new B(); Class<?> superclass = b.getClass().getSuperclass(); Method method = superclass.getMethod("method", Arr...

19. Java dynamic function calling

I have a String array that contains names of method in the yyyyyy class In the xxxxxx class I'm making a yyyyyy instance (say obj). Now I can call obj.function_name(), except I want to read function_name from the String array in a loop. Is this possible?

20. Java Methods - Taking a method AS AN ARGUMENT

I've come across some code that I can't share here but it declares a method WITHIN the paramter list of another method. I didnt even know that was possible. I dont really understand why its doing that. Can someone please explain to me some possible uses that you as a programmer would have for doing that? (Note: Since I can't show the code I dont expect an in-context explanation just generally) ...

21. How would one find out if a method is static using Java's reflection API?

The title says it all. If I didn't know that the sleep method on java.lang.Thread was static, how could I find out?

1
  /*
2
   * Copyright 1996-2006 Sun Microsystems, Inc.  All Rights Reserved.
3
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
   *
5
   * This code is free software; you can redistribute it and/or modify it
6
   * under the terms of the GNU General Public License version 2 only, as
7
   * published by the Free Software Foundation.  Sun designates this
8
   * particular file as subject to the "Classpath" exception as provided
9
   * by Sun in the LICENSE file that accompanied this code.
10
  *
11
  * This code is distributed in the hope that it will be useful, but WITHOUT
12
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
  * version 2 for more details (a copy is included in the LICENSE file that
15
  * accompanied this code).
16
  *
17
  * You should have received a copy of the GNU General Public License version
18
  * 2 along with this work; if not, write to the Free Software Foundation,
19
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
  *
21
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
  * CA 95054 USA or visit www.sun.com if you need additional information or
23
  * have any questions.
24
  */
25
 
26
 package java.lang.reflect;
27
 
28
 import sun.reflect.MethodAccessor;
29
 import sun.reflect.Reflection;
30
 import sun.reflect.generics.repository.MethodRepository;
31
 import sun.reflect.generics.factory.CoreReflectionFactory;
32
 import sun.reflect.generics.factory.GenericsFactory;
33
 import sun.reflect.generics.scope.MethodScope;
34
 import sun.reflect.annotation.AnnotationType;
35
 import sun.reflect.annotation.AnnotationParser;
36
 import java.lang.annotation.Annotation;
37
 import java.lang.annotation.AnnotationFormatError;
38
 import java.nio.ByteBuffer;
39
 import java.util.Map;

 A Method provides information about, and access to, a single method
 on a class or interface.  The reflected method may be a class method
 or an instance method (including an abstract method).

 A Method permits widening conversions to occur when matching the
 actual parameters to invoke with the underlying method's formal
 parameters, but it throws an IllegalArgumentException if a
 narrowing conversion would occur.

 
 Author(s):Kenneth RussellNakul Saraiya See also:Memberjava.lang.Classjava.lang.Class.getMethods()java.lang.Class.getMethod(java.lang.String,java.lang.Class[])java.lang.Class.getDeclaredMethods()java.lang.Class.getDeclaredMethod(java.lang.String,java.lang.Class[])
60
 
61
 public final
62
     class Method extends AccessibleObject implements GenericDeclaration,
63
                                                      Member {
64
     private Class               clazz;
65
     private int                 slot;
66
     // This is guaranteed to be interned by the VM in the 1.4
67
     // reflection implementation
68
     private String              name;
69
     private Class               returnType;
70
     private Class[]             parameterTypes;
71
     private Class[]             exceptionTypes;
72
     private int                 modifiers;
73
     // Generics and annotations support
74
     private transient String              signature;
75
     // generic info repository; lazily initialized
76
     private transient MethodRepository genericInfo;
77
     private byte[]              annotations;
78
     private byte[]              parameterAnnotations;
79
     private byte[]              annotationDefault;
80
     private volatile MethodAccessor methodAccessor;
81
     // For sharing of MethodAccessors. This branching structure is
82
     // currently only two levels deep (i.e., one root Method and
83
     // potentially many Method objects pointing to it.)
84
     private Method              root;
85
 
86
     // More complicated security check cache needed here than for
87
     // Class.newInstance() and Constructor.newInstance()
88
     private Class securityCheckCache;
89
     private Class securityCheckTargetClassCache;
90
 
91
     // Modifiers that can be applied to a method in source code
92
     private static final int LANGUAGE_MODIFIERS =
93
         Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
94
         Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
95
         Modifier.SYNCHRONIZED   | Modifier.NATIVE;
96
 
97
    // Generics infrastructure
98
 
99
     private String getGenericSignature() {return signature;}
100
101
    // Accessor for factory
102
    private GenericsFactory getFactory() {
103
        // create scope and factory
104
        return CoreReflectionFactory.make(this, MethodScope.make(this));
105
    }
106
107
    // Accessor for generic info repository
108
    private MethodRepository getGenericInfo() {
109
        // lazily initialize repository if necessary
110
        if (genericInfo == null) {
111
            // create and cache generic info repository
112
            genericInfo = MethodRepository.make(getGenericSignature(),
113
                                                getFactory());
114
        }
115
        return genericInfo; //return cached repository
116
    }

    
 Package-private constructor used by ReflectAccess to enable
 instantiation of these objects in Java code from the java.lang
 package via sun.reflect.LangReflectAccess.
 
122
123
    Method(Class declaringClass,
124
           String name,
125
           Class[] parameterTypes,
126
           Class returnType,
127
           Class[] checkedExceptions,
128
           int modifiers,
129
           int slot,
130
           String signature,
131
           byte[] annotations,
132
           byte[] parameterAnnotations,
133
           byte[] annotationDefault)
134
    {
135
        this.clazz = declaringClass;
136
        this.name = name;
137
        this.parameterTypes = parameterTypes;
138
        this.returnType = returnType;
139
        this.exceptionTypes = checkedExceptions;
140
        this.modifiers = modifiers;
141
        this.slot = slot;
142
        this.signature = signature;
143
        this.annotations = annotations;
144
        this.parameterAnnotations = parameterAnnotations;
145
        this.annotationDefault = annotationDefault;
146
    }

    
 Package-private routine (exposed to java.lang.Class via
 ReflectAccess) which returns a copy of this Method. The copy's
 "root" field points to this Method.
 
152
153
    Method copy() {
154
        // This routine enables sharing of MethodAccessor objects
155
        // among Method objects which refer to the same underlying
156
        // method in the VM. (All of this contortion is only necessary
157
        // because of the "accessibility" bit in AccessibleObject,
158
        // which implicitly requires that new java.lang.reflect
159
        // objects be fabricated for each reflective call on Class
160
        // objects.)
161
        Method res = new Method(clazz, name, parameterTypes, returnType,
162
                                exceptionTypes, modifiers, slot, signature,
163
                                annotations, parameterAnnotations, annotationDefault);
164
        res.root = this;
165
        // Might as well eagerly propagate this if already present
166
        res.methodAccessor = methodAccessor;
167
        return res;
168
    }

    
 Returns the Class object representing the class or interface
 that declares the method represented by this Method object.
 
173
174
    public Class<?> getDeclaringClass() {
175
        return clazz;
176
    }

    
 Returns the name of the method represented by this Method
 object, as a String.
 
181
182
    public String getName() {
183
        return name;
184
    }

    
 Returns the Java language modifiers for the method represented
 by this Method object, as an integer. The Modifier class should
 be used to decode the modifiers.

 
 See also:Modifier
192
193
    public int getModifiers() {
194
        return modifiers;
195
    }

    
 Returns an array of TypeVariable objects that represent the
 type variables declared by the generic declaration represented by this
 GenericDeclaration object, in declaration order.  Returns an
 array of length 0 if the underlying generic declaration declares no type
 variables.

 
 Returns:an array of TypeVariable objects that represent
     the type variables declared by this generic declaration Throws:GenericSignatureFormatError if the generic
     signature of this generic declaration does not conform to
     the format specified in the Java Virtual Machine Specification,
     3rd edition Since:1.5
211
212
    public TypeVariable<Method>[] getTypeParameters() {
213
        if (getGenericSignature() != null)
214
            return (TypeVariable<Method>[])getGenericInfo().getTypeParameters();
215
        else
216
            return (TypeVariable<Method>[])new TypeVariable[0];
217
    }

    
 Returns a Class object that represents the formal return type
 of the method represented by this Method object.

 
 Returns:the return type for the method this object represents
224
225
    public Class<?> getReturnType() {
226
        return returnType;
227
    }

    
 Returns a Type object that represents the formal return
 type of the method represented by this Method object.

 If the return type is a parameterized type,
 the Type object returned must accurately reflect
 the actual type parameters used in the source code.

 
If the return type is a type variable or a parameterized type, it
 is created. Otherwise, it is resolved.

 
 Returns:a Type object that represents the formal return
     type of the underlying  method Throws:GenericSignatureFormatError
     if the generic method signature does not conform to the format
     specified in the Java Virtual Machine Specification, 3rd editionjava.lang.TypeNotPresentException if the underlying method's
     return type refers to a non-existent type declarationMalformedParameterizedTypeException if the
     underlying method's return typed refers to a parameterized
     type that cannot be instantiated for any reason Since:1.5
251
252
    public Type getGenericReturnType() {
253
      if (getGenericSignature() != null) {
254
        return getGenericInfo().getReturnType();
255
      } else { return getReturnType();}
256
    }


    
 Returns an array of Class objects that represent the formal
 parameter types, in declaration order, of the method
 represented by this Method object.  Returns an array of length
 0 if the underlying method takes no parameters.

 
 Returns:the parameter types for the method this object
 represents
267
268
    public Class<?>[] getParameterTypes() {
269
        return (Class<?>[]) parameterTypes.clone();
270
    }

    
 Returns an array of Type objects that represent the formal
 parameter types, in declaration order, of the method represented by
 this Method object. Returns an array of length 0 if the
 underlying method takes no parameters.

 If a formal parameter type is a parameterized type,
 the Type object returned for it must accurately reflect
 the actual type parameters used in the source code.

 
If a formal parameter type is a type variable or a parameterized
 type, it is created. Otherwise, it is resolved.

 
 Returns:an array of Types that represent the formal
     parameter types of the underlying method, in declaration order Throws:GenericSignatureFormatError
     if the generic method signature does not conform to the format
     specified in the Java Virtual Machine Specification, 3rd editionjava.lang.TypeNotPresentException if any of the parameter
     types of the underlying method refers to a non-existent type
     declarationMalformedParameterizedTypeException if any of
     the underlying method's parameter types refer to a parameterized
     type that cannot be instantiated for any reason Since:1.5
297
298
    public Type[] getGenericParameterTypes() {
299
        if (getGenericSignature() != null)
300
            return getGenericInfo().getParameterTypes();
301
        else
302
            return getParameterTypes();
303
    }


    
 Returns an array of Class objects that represent
 the types of the exceptions declared to be thrown
 by the underlying method
 represented by this Method object.  Returns an array of length
 0 if the method declares no exceptions in its throws clause.

 
 Returns:the exception types declared as being thrown by the
 method this object represents
315
316
    public Class<?>[] getExceptionTypes() {
317
        return (Class<?>[]) exceptionTypes.clone();
318
    }

    
 Returns an array of Type objects that represent the
 exceptions declared to be thrown by this Method object.
 Returns an array of length 0 if the underlying method declares
 no exceptions in its throws clause.

 If an exception type is a parameterized type, the Type
 object returned for it must accurately reflect the actual type
 parameters used in the source code.

 
If an exception type is a type variable or a parameterized
 type, it is created. Otherwise, it is resolved.

 
 Returns:an array of Types that represent the exception types
     thrown by the underlying method Throws:GenericSignatureFormatError
     if the generic method signature does not conform to the format
     specified in the Java Virtual Machine Specification, 3rd editionjava.lang.TypeNotPresentException if the underlying method's
     throws clause refers to a non-existent type declarationMalformedParameterizedTypeException if
     the underlying method's throws clause refers to a
     parameterized type that cannot be instantiated for any reason Since:1.5
344
345
      public Type[] getGenericExceptionTypes() {
346
          Type[] result;
347
          if (getGenericSignature() != null &&
348
              ((result = getGenericInfo().getExceptionTypes()).length > 0))
349
              return result;
350
          else
351
              return getExceptionTypes();
352
      }

    
 Compares this Method against the specified object.  Returns
 true if the objects are the same.  Two Methods are the same if
 they were declared by the same class and have the same name
 and formal parameter types and return type.
 
359
360
    public boolean equals(Object obj) {
361
        if (obj != null && obj instanceof Method) {
362
            Method other = (Method)obj;
363
            if ((getDeclaringClass() == other.getDeclaringClass())
364
                && (getName() == other.getName())) {
365
                if (!returnType.equals(other.getReturnType()))
366
                    return false;
367
                /* Avoid unnecessary cloning */
368
                Class[] params1 = parameterTypes;
369
                Class[] params2 = other.parameterTypes;
370
                if (params1.length == params2.length) {
371
                    for (int i = 0; i < params1.length; i++) {
372
                        if (params1[i] != params2[i])
373
                            return false;
374
                    }
375
                    return true;
376
                }
377
            }
378
        }
379
        return false;
380
    }

    
 Returns a hashcode for this Method.  The hashcode is computed
 as the exclusive-or of the hashcodes for the underlying
 method's declaring class name and the method's name.
 
386
387
    public int hashCode() {
388
        return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
389
    }

    
 Returns a string describing this Method.  The string is
 formatted as the method access modifiers, if any, followed by
 the method return type, followed by a space, followed by the
 class declaring the method, followed by a period, followed by
 the method name, followed by a parenthesized, comma-separated
 list of the method's formal parameter types. If the method
 throws checked exceptions, the parameter list is followed by a
 space, followed by the word throws followed by a
 comma-separated list of the thrown exception types.
 For example:
     public boolean java.lang.Object.equals(java.lang.Object)
 The access modifiers are placed in canonical order as
 specified by "The Java Language Specification".  This is
 public, protected or private first,
 and then other modifiers in the following order:
 abstract, static, final,
 synchronized, native.
 
412
413
    public String toString() {
414
        try {
415
            StringBuffer sb = new StringBuffer();
416
            int mod = getModifiers() & LANGUAGE_MODIFIERS;
417
            if (mod != 0) {
418
                sb.append(Modifier.toString(mod) + " ");
419
            }
420
            sb.append(Field.getTypeName(getReturnType()) + " ");
421
            sb.append(Field.getTypeName(getDeclaringClass()) + ".");
422
            sb.append(getName() + "(");
423
            Class[] params = parameterTypes; // avoid clone
424
            for (int j = 0; j < params.length; j++) {
425
                sb.append(Field.getTypeName(params[j]));
426
                if (j < (params.length - 1))
427
                    sb.append(",");
428
            }
429
            sb.append(")");
430
            Class[] exceptions = exceptionTypes; // avoid clone
431
            if (exceptions.length > 0) {
432
                sb.append(" throws ");
433
                for (int k = 0; k < exceptions.length; k++) {
434
                    sb.append(exceptions[k].getName());
435
                    if (k < (exceptions.length - 1))
436
                        sb.append(",");
437
                }
438
            }
439
            return sb.toString();
440
        } catch (Exception e) {
441
            return "<" + e + ">";
442
        }
443
    }

    
 Returns a string describing this Method, including
 type parameters.  The string is formatted as the method access
 modifiers, if any, followed by an angle-bracketed
 comma-separated list of the method's type parameters, if any,
 followed by the method's generic return type, followed by a
 space, followed by the class declaring the method, followed by
 a period, followed by the method name, followed by a
 parenthesized, comma-separated list of the method's generic
 formal parameter types.

 A space is used to separate access modifiers from one another
 and from the type parameters or return type.  If there are no
 type parameters, the type parameter list is elided; if the type
 parameter list is present, a space separates the list from the
 class name.  If the method is declared to throw exceptions, the
 parameter list is followed by a space, followed by the word
 throws followed by a comma-separated list of the generic thrown
 exception types.  If there are no type parameters, the type
 parameter list is elided.

 The access modifiers are placed in canonical order as
 specified by "The Java Language Specification".  This is
 public, protected or private first,
 and then other modifiers in the following order:
 abstract, static, final,
 synchronized native.

 
 Returns:a string describing this Method,
 include type parameters Since:1.5
477
478
    public String toGenericString() {
479
        try {
480
            StringBuilder sb = new StringBuilder();
481
            int mod = getModifiers() & LANGUAGE_MODIFIERS;
482
            if (mod != 0) {
483
                sb.append(Modifier.toString(mod) + " ");
484
            }
485
            TypeVariable<?>[] typeparms = getTypeParameters();
486
            if (typeparms.length > 0) {
487
                boolean first = true;
488
                sb.append("<");
489
                for(TypeVariable<?> typeparm: typeparms) {
490
                    if (!first)
491
                        sb.append(",");
492
                    // Class objects can't occur here; no need to test
493
                    // and call Class.getName().
494
                    sb.append(typeparm.toString());
495
                    first = false;
496
                }
497
                sb.append("> ");
498
            }
499
500
            Type genRetType = getGenericReturnType();
501
            sb.append( ((genRetType instanceof Class<?>)?
502
                        Field.getTypeName((Class<?>)genRetType):genRetType.toString())  + " ");
503
504
            sb.append(Field.getTypeName(getDeclaringClass()) + ".");
505
            sb.append(getName() + "(");
506
            Type[] params = getGenericParameterTypes();
507
            for (int j = 0; j < params.length; j++) {
508
                String param = (params[j] instanceof Class)?
509
                    Field.getTypeName((Class)params[j]):
510
                    (params[j].toString());
511
                sb.append(param);
512
                if (j < (params.length - 1))
513
                    sb.append(",");
514
            }
515
            sb.append(")");
516
            Type[] exceptions = getGenericExceptionTypes();
517
            if (exceptions.length > 0) {
518
                sb.append(" throws ");
519
                for (int k = 0; k < exceptions.length; k++) {
520
                    sb.append((exceptions[k] instanceof Class)?
521
                              ((Class)exceptions[k]).getName():
522
                              exceptions[k].toString());
523
                    if (k < (exceptions.length - 1))
524
                        sb.append(",");
525
                }
526
            }
527
            return sb.toString();
528
        } catch (Exception e) {
529
            return "<" + e + ">";
530
        }
531
    }

    
 Invokes the underlying method represented by this Method
 object, on the specified object with the specified parameters.
 Individual parameters are automatically unwrapped to match
 primitive formal parameters, and both primitive and reference
 parameters are subject to method invocation conversions as
 necessary.

 If the underlying method is static, then the specified obj
 argument is ignored. It may be null.

 
If the number of formal parameters required by the underlying method is
 0, the supplied args array may be of length 0 or null.

 
If the underlying method is an instance method, it is invoked
 using dynamic method lookup as documented in The Java Language
 Specification, Second Edition, section 15.12.4.4; in particular,
 overriding based on the runtime type of the target object will occur.

 
If the underlying method is static, the class that declared
 the method is initialized if it has not already been initialized.

 
If the method completes normally, the value it returns is
 returned to the caller of invoke; if the value has a primitive
 type, it is first appropriately wrapped in an object. However,
 if the value has the type of an array of a primitive type, the
 elements of the array are not wrapped in objects; in
 other words, an array of primitive type is returned.  If the
 underlying method return type is void, the invocation returns
 null.

 
 Parameters:obj  the object the underlying method is invoked fromargs the arguments used for the method call Returns:the result of dispatching the method represented by
 this object on obj with parameters
 args Throws:java.lang.IllegalAccessException    if this Method object
              enforces Java language access control and the underlying
              method is inaccessible.java.lang.IllegalArgumentException  if the method is an
              instance method and the specified object argument
              is not an instance of the class or interface
              declaring the underlying method (or of a subclass
              or implementor thereof); if the number of actual
              and formal parameters differ; if an unwrapping
              conversion for primitive arguments fails; or if,
              after possible unwrapping, a parameter value
              cannot be converted to the corresponding formal
              parameter type by a method invocation conversion.InvocationTargetException if the underlying method
              throws an exception.java.lang.NullPointerException      if the specified object is null
              and the method is an instance method.java.lang.ExceptionInInitializerError if the initialization
 provoked by this method fails.
589
590
    public Object invoke(Object obj, Object... args)
591
        throws IllegalAccessException, IllegalArgumentException,
592
           InvocationTargetException
593
    {
594
        if (!override) {
595
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
596
                Class caller = Reflection.getCallerClass(1);
597
                Class targetClass = ((obj == null || !Modifier.isProtected(modifiers))
598
                                     ? clazz
599
                                     : obj.getClass());
600
601
                boolean cached;
602
                synchronized (this) {
603
                    cached = (securityCheckCache == caller)
604
                            && (securityCheckTargetClassCache == targetClass);
605
                }
606
                if (!cached) {
607
                    Reflection.ensureMemberAccess(caller, clazz, obj, modifiers);
608
                    synchronized (this) {
609
                        securityCheckCache = caller;
610
                        securityCheckTargetClassCache = targetClass;
611
                    }
612
                }
613
            }
614
        }
615
        if (methodAccessor == null) acquireMethodAccessor();
616
        return methodAccessor.invoke(obj, args);
617
    }

    
 Returns true if this method is a bridge
 method; returns false otherwise.

 
 Returns:true if and only if this method is a bridge
 method as defined by the Java Language Specification. Since:1.5
626
627
    public boolean isBridge() {
628
        return (getModifiers() & Modifier.BRIDGE) != 0;
629
    }

    
 Returns true if this method was declared to take
 a variable number of arguments; returns false
 otherwise.

 
 Returns:true if an only if this method was declared to
 take a variable number of arguments. Since:1.5
639
640
    public boolean isVarArgs() {
641
        return (getModifiers() & Modifier.VARARGS) != 0;
642
    }

    
 Returns true if this method is a synthetic
 method; returns false otherwise.

 
 Returns:true if and only if this method is a synthetic
 method as defined by the Java Language Specification. Since:1.5
651
652
    public boolean isSynthetic() {
653
        return Modifier.isSynthetic(getModifiers());
654
    }
655
656
    // NOTE that there is no synchronization used here. It is correct
657
    // (though not efficient) to generate more than one MethodAccessor
658
    // for a given Method. However, avoiding synchronization will
659
    // probably make the implementation more scalable.
660
    private void acquireMethodAccessor() {
661
        // First check to see if one has been created yet, and take it
662
        // if so
663
        MethodAccessor tmp = null;
664
        if (root != null) tmp = root.getMethodAccessor();
665
        if (tmp != null) {
666
            methodAccessor = tmp;
667
            return;
668
        }
669
        // Otherwise fabricate one and propagate it up to the root
670
        tmp = reflectionFactory.newMethodAccessor(this);
671
        setMethodAccessor(tmp);
672
    }
673
674
    // Returns MethodAccessor for this Method object, not looking up
675
    // the chain to the root
676
    MethodAccessor getMethodAccessor() {
677
        return methodAccessor;
678
    }
679
680
    // Sets the MethodAccessor for this Method object and
681
    // (recursively) its root
682
    void setMethodAccessor(MethodAccessor accessor) {
683
        methodAccessor = accessor;
684
        // Propagate up
685
        if (root != null) {
686
            root.setMethodAccessor(accessor);
687
        }
688
    }

    
 Throws:java.lang.NullPointerException Since:1.5
693
694
    public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
695
        if (annotationClass == null)
696
            throw new NullPointerException();
697
698
        return (T) declaredAnnotations().get(annotationClass);
699
    }
700
701
    private static final Annotation[] EMPTY_ANNOTATION_ARRAY=new Annotation[0];

    
 Since:1.5
705
706
    public Annotation[] getDeclaredAnnotations()  {
707
        return declaredAnnotations().values().toArray(EMPTY_ANNOTATION_ARRAY);
708
    }
709
710
    private transient Map<Class, Annotation> declaredAnnotations;
711
712
    private synchronized  Map<Class, Annotation> declaredAnnotations() {
713
        if (declaredAnnotations == null) {
714
            declaredAnnotations = AnnotationParser.parseAnnotations(
715
                annotations, sun.misc.SharedSecrets.getJavaLangAccess().
716
                getConstantPool(getDeclaringClass()),
717
                getDeclaringClass());
718
        }
719
        return declaredAnnotations;
720
    }

    
 Returns the default value for the annotation member represented by
 this Method instance.  If the member is of a primitive type,
 an instance of the corresponding wrapper type is returned. Returns
 null if no default is associated with the member, or if the method
 instance does not represent a declared member of an annotation type.

 
 Returns:the default value for the annotation member represented
     by this Method instance. Throws:java.lang.TypeNotPresentException if the annotation is of type
     java.lang.Class and no definition can be found for the
     default class value. Since:1.5
735
736
    public Object getDefaultValue() {
737
        if  (annotationDefault == null)
738
            return null;
739
        Class memberType = AnnotationType.invocationHandlerReturnType(
740
            getReturnType());
741
        Object result = AnnotationParser.parseMemberValue(
742
            memberType, ByteBuffer.wrap(annotationDefault),
743
            sun.misc.SharedSecrets.getJavaLangAccess().
744
                getConstantPool(getDeclaringClass()),
745
            getDeclaringClass());
746
        if (result instanceof sun.reflect.annotation.ExceptionProxy)
747
            throw new AnnotationFormatError("Invalid default: " + this);
748
        return result;
749
    }

    
 Returns an array of arrays that represent the annotations on the formal
 parameters, in declaration order, of the method represented by
 this Method object. (Returns an array of length zero if the
 underlying method is parameterless.  If the method has one or more
 parameters, a nested array of length zero is returned for each parameter
 with no annotations.) The annotation objects contained in the returned
 arrays are serializable.  The caller of this method is free to modify
 the returned arrays; it will have no effect on the arrays returned to
 other callers.

 
 Returns:an array of arrays that represent the annotations on the formal
    parameters, in declaration order, of the method represented by this
    Method object Since:1.5
766
767
    public Annotation[][] getParameterAnnotations() {
768
        int numParameters = parameterTypes.length;
769
        if (parameterAnnotations == null)
770
            return new Annotation[numParameters][0];
771
772
        Annotation[][] result = AnnotationParser.parseParameterAnnotations(
773
            parameterAnnotations,
774
            sun.misc.SharedSecrets.getJavaLangAccess().
775
                getConstantPool(getDeclaringClass()),
776
            getDeclaringClass());
777
        if (result.length != numParameters)
778
            throw new java.lang.annotation.AnnotationFormatError(
779
                "Parameter annotations don't match number of parameters");
780
        return result;
781
    }
782
}