1 /*
  2  * Copyright (c) 1996, 2021, Oracle and/or its affiliates. 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.  Oracle designates this
  8  * particular file as subject to the "Classpath" exception as provided
  9  * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 22  * or visit www.oracle.com if you need additional information or have any
 23  * questions.
 24  */
 25 
 26 package java.lang.reflect;
 27 
 28 import jdk.internal.access.SharedSecrets;

 29 import jdk.internal.reflect.CallerSensitive;

 30 import jdk.internal.reflect.MethodAccessor;
 31 import jdk.internal.reflect.Reflection;
 32 import jdk.internal.vm.annotation.ForceInline;
 33 import jdk.internal.vm.annotation.IntrinsicCandidate;
 34 import jdk.internal.vm.annotation.Stable;
 35 import sun.reflect.annotation.ExceptionProxy;
 36 import sun.reflect.annotation.TypeNotPresentExceptionProxy;
 37 import sun.reflect.generics.repository.MethodRepository;
 38 import sun.reflect.generics.factory.CoreReflectionFactory;
 39 import sun.reflect.generics.factory.GenericsFactory;
 40 import sun.reflect.generics.scope.MethodScope;
 41 import sun.reflect.annotation.AnnotationType;
 42 import sun.reflect.annotation.AnnotationParser;
 43 import java.lang.annotation.Annotation;
 44 import java.lang.annotation.AnnotationFormatError;
 45 import java.nio.ByteBuffer;
 46 import java.util.StringJoiner;
 47 
 48 /**
 49  * A {@code Method} provides information about, and access to, a single method
 50  * on a class or interface.  The reflected method may be a class method
 51  * or an instance method (including an abstract method).
 52  *
 53  * <p>A {@code Method} permits widening conversions to occur when matching the
 54  * actual parameters to invoke with the underlying method's formal
 55  * parameters, but it throws an {@code IllegalArgumentException} if a
 56  * narrowing conversion would occur.
 57  *
 58  * @see Member
 59  * @see java.lang.Class
 60  * @see java.lang.Class#getMethods()
 61  * @see java.lang.Class#getMethod(String, Class[])
 62  * @see java.lang.Class#getDeclaredMethods()
 63  * @see java.lang.Class#getDeclaredMethod(String, Class[])
 64  *
 65  * @author Kenneth Russell
 66  * @author Nakul Saraiya
 67  * @since 1.1
 68  */
 69 public final class Method extends Executable {
 70     @Stable
 71     private Class<?>            clazz;
 72     private int                 slot;
 73     // This is guaranteed to be interned by the VM in the 1.4
 74     // reflection implementation
 75     private String              name;
 76     private Class<?>            returnType;
 77     private Class<?>[]          parameterTypes;
 78     private Class<?>[]          exceptionTypes;
 79     @Stable
 80     private int                 modifiers;
 81     // Generics and annotations support
 82     private transient String              signature;
 83     // generic info repository; lazily initialized
 84     private transient MethodRepository genericInfo;
 85     private byte[]              annotations;
 86     private byte[]              parameterAnnotations;
 87     private byte[]              annotationDefault;
 88     @Stable
 89     private MethodAccessor      methodAccessor;
 90     // For sharing of MethodAccessors. This branching structure is
 91     // currently only two levels deep (i.e., one root Method and
 92     // potentially many Method objects pointing to it.)
 93     //
 94     // If this branching structure would ever contain cycles, deadlocks can
 95     // occur in annotation code.
 96     private Method              root;
 97 
 98     // Generics infrastructure
 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     @Override
109     MethodRepository getGenericInfo() {
110         // lazily initialize repository if necessary
111         if (genericInfo == null) {
112             // create and cache generic info repository
113             genericInfo = MethodRepository.make(getGenericSignature(),
114                                                 getFactory());
115         }
116         return genericInfo; //return cached repository
117     }
118 
119     /**
120      * Package-private constructor
121      */
122     Method(Class<?> declaringClass,
123            String name,
124            Class<?>[] parameterTypes,
125            Class<?> returnType,
126            Class<?>[] checkedExceptions,
127            int modifiers,
128            int slot,
129            String signature,
130            byte[] annotations,
131            byte[] parameterAnnotations,
132            byte[] annotationDefault) {

133         this.clazz = declaringClass;
134         this.name = name;
135         this.parameterTypes = parameterTypes;
136         this.returnType = returnType;
137         this.exceptionTypes = checkedExceptions;
138         this.modifiers = modifiers;
139         this.slot = slot;
140         this.signature = signature;
141         this.annotations = annotations;
142         this.parameterAnnotations = parameterAnnotations;
143         this.annotationDefault = annotationDefault;
144     }
145 
146     /**
147      * Package-private routine (exposed to java.lang.Class via
148      * ReflectAccess) which returns a copy of this Method. The copy's
149      * "root" field points to this Method.
150      */
151     Method copy() {
152         // This routine enables sharing of MethodAccessor objects
153         // among Method objects which refer to the same underlying
154         // method in the VM. (All of this contortion is only necessary
155         // because of the "accessibility" bit in AccessibleObject,
156         // which implicitly requires that new java.lang.reflect
157         // objects be fabricated for each reflective call on Class
158         // objects.)
159         if (this.root != null)
160             throw new IllegalArgumentException("Can not copy a non-root Method");
161 
162         Method res = new Method(clazz, name, parameterTypes, returnType,
163                                 exceptionTypes, modifiers, slot, signature,
164                                 annotations, parameterAnnotations, annotationDefault);
165         res.root = this;
166         // Might as well eagerly propagate this if already present
167         res.methodAccessor = methodAccessor;
168         return res;
169     }
170 
171     /**
172      * Make a copy of a leaf method.
173      */
174     Method leafCopy() {
175         if (this.root == null)
176             throw new IllegalArgumentException("Can only leafCopy a non-root Method");
177 
178         Method res = new Method(clazz, name, parameterTypes, returnType,
179                 exceptionTypes, modifiers, slot, signature,
180                 annotations, parameterAnnotations, annotationDefault);
181         res.root = root;
182         res.methodAccessor = methodAccessor;
183         return res;
184     }
185 
186     /**
187      * @throws InaccessibleObjectException {@inheritDoc}
188      * @throws SecurityException {@inheritDoc}
189      */
190     @Override
191     @CallerSensitive
192     public void setAccessible(boolean flag) {
193         AccessibleObject.checkPermission();
194         if (flag) checkCanSetAccessible(Reflection.getCallerClass());
195         setAccessible0(flag);
196     }
197 
198     @Override
199     void checkCanSetAccessible(Class<?> caller) {
200         checkCanSetAccessible(caller, clazz);
201     }
202 
203     @Override
204     Method getRoot() {
205         return root;
206     }
207 
208     @Override
209     boolean hasGenericInformation() {
210         return (getGenericSignature() != null);
211     }
212 
213     @Override
214     byte[] getAnnotationBytes() {
215         return annotations;
216     }
217 
218     /**
219      * Returns the {@code Class} object representing the class or interface
220      * that declares the method represented by this object.
221      */
222     @Override
223     public Class<?> getDeclaringClass() {
224         return clazz;
225     }
226 
227     /**
228      * Returns the name of the method represented by this {@code Method}
229      * object, as a {@code String}.
230      */
231     @Override
232     public String getName() {
233         return name;
234     }
235 
236     /**
237      * {@inheritDoc}
238      * @jls 8.4.3 Method Modifiers
239      */
240     @Override
241     public int getModifiers() {
242         return modifiers;
243     }
244 
245     /**
246      * {@inheritDoc}
247      * @throws GenericSignatureFormatError {@inheritDoc}
248      * @since 1.5
249      * @jls 8.4.4 Generic Methods
250      */
251     @Override
252     @SuppressWarnings({"rawtypes", "unchecked"})
253     public TypeVariable<Method>[] getTypeParameters() {
254         if (getGenericSignature() != null)
255             return (TypeVariable<Method>[])getGenericInfo().getTypeParameters();
256         else
257             return (TypeVariable<Method>[])new TypeVariable[0];
258     }
259 
260     /**
261      * Returns a {@code Class} object that represents the formal return type
262      * of the method represented by this {@code Method} object.
263      *
264      * @return the return type for the method this object represents
265      */
266     public Class<?> getReturnType() {
267         return returnType;
268     }
269 
270     /**
271      * Returns a {@code Type} object that represents the formal return
272      * type of the method represented by this {@code Method} object.
273      *
274      * <p>If the return type is a parameterized type,
275      * the {@code Type} object returned must accurately reflect
276      * the actual type arguments used in the source code.
277      *
278      * <p>If the return type is a type variable or a parameterized type, it
279      * is created. Otherwise, it is resolved.
280      *
281      * @return  a {@code Type} object that represents the formal return
282      *     type of the underlying  method
283      * @throws GenericSignatureFormatError
284      *     if the generic method signature does not conform to the format
285      *     specified in
286      *     <cite>The Java Virtual Machine Specification</cite>
287      * @throws TypeNotPresentException if the underlying method's
288      *     return type refers to a non-existent class or interface declaration
289      * @throws MalformedParameterizedTypeException if the
290      *     underlying method's return type refers to a parameterized
291      *     type that cannot be instantiated for any reason
292      * @since 1.5
293      */
294     public Type getGenericReturnType() {
295       if (getGenericSignature() != null) {
296         return getGenericInfo().getReturnType();
297       } else { return getReturnType();}
298     }
299 
300     @Override
301     Class<?>[] getSharedParameterTypes() {
302         return parameterTypes;
303     }
304 
305     @Override
306     Class<?>[] getSharedExceptionTypes() {
307         return exceptionTypes;
308     }
309 
310     /**
311      * {@inheritDoc}
312      */
313     @Override
314     public Class<?>[] getParameterTypes() {
315         return parameterTypes.clone();
316     }
317 
318     /**
319      * {@inheritDoc}
320      * @since 1.8
321      */
322     public int getParameterCount() { return parameterTypes.length; }
323 
324 
325     /**
326      * {@inheritDoc}
327      * @throws GenericSignatureFormatError {@inheritDoc}
328      * @throws TypeNotPresentException {@inheritDoc}
329      * @throws MalformedParameterizedTypeException {@inheritDoc}
330      * @since 1.5
331      */
332     @Override
333     public Type[] getGenericParameterTypes() {
334         return super.getGenericParameterTypes();
335     }
336 
337     /**
338      * {@inheritDoc}
339      */
340     @Override
341     public Class<?>[] getExceptionTypes() {
342         return exceptionTypes.clone();
343     }
344 
345     /**
346      * {@inheritDoc}
347      * @throws GenericSignatureFormatError {@inheritDoc}
348      * @throws TypeNotPresentException {@inheritDoc}
349      * @throws MalformedParameterizedTypeException {@inheritDoc}
350      * @since 1.5
351      */
352     @Override
353     public Type[] getGenericExceptionTypes() {
354         return super.getGenericExceptionTypes();
355     }
356 
357     /**
358      * Compares this {@code Method} against the specified object.  Returns
359      * true if the objects are the same.  Two {@code Methods} are the same if
360      * they were declared by the same class and have the same name
361      * and formal parameter types and return type.
362      */
363     public boolean equals(Object obj) {
364         if (obj instanceof Method other) {
365             if ((getDeclaringClass() == other.getDeclaringClass())
366                 && (getName() == other.getName())) {
367                 if (!returnType.equals(other.getReturnType()))
368                     return false;
369                 return equalParamTypes(parameterTypes, other.parameterTypes);
370             }
371         }
372         return false;
373     }
374 
375     /**
376      * Returns a hashcode for this {@code Method}.  The hashcode is computed
377      * as the exclusive-or of the hashcodes for the underlying
378      * method's declaring class name and the method's name.
379      */
380     public int hashCode() {
381         return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
382     }
383 
384     /**
385      * Returns a string describing this {@code Method}.  The string is
386      * formatted as the method access modifiers, if any, followed by
387      * the method return type, followed by a space, followed by the
388      * class declaring the method, followed by a period, followed by
389      * the method name, followed by a parenthesized, comma-separated
390      * list of the method's formal parameter types. If the method
391      * throws checked exceptions, the parameter list is followed by a
392      * space, followed by the word "{@code throws}" followed by a
393      * comma-separated list of the thrown exception types.
394      * For example:
395      * <pre>
396      *    public boolean java.lang.Object.equals(java.lang.Object)
397      * </pre>
398      *
399      * <p>The access modifiers are placed in canonical order as
400      * specified by "The Java Language Specification".  This is
401      * {@code public}, {@code protected} or {@code private} first,
402      * and then other modifiers in the following order:
403      * {@code abstract}, {@code default}, {@code static}, {@code final},
404      * {@code synchronized}, {@code native}, {@code strictfp}.
405      *
406      * @return a string describing this {@code Method}
407      *
408      * @jls 8.4.3 Method Modifiers
409      * @jls 9.4 Method Declarations
410      * @jls 9.6.1 Annotation Interface Elements
411      */
412     public String toString() {
413         return sharedToString(Modifier.methodModifiers(),
414                               isDefault(),
415                               parameterTypes,
416                               exceptionTypes);
417     }
418 
419     @Override
420     void specificToStringHeader(StringBuilder sb) {
421         sb.append(getReturnType().getTypeName()).append(' ');
422         sb.append(getDeclaringClass().getTypeName()).append('.');
423         sb.append(getName());
424     }
425 
426     @Override
427     String toShortString() {
428         return "method " + getDeclaringClass().getTypeName() +
429                 '.' + toShortSignature();
430     }
431 
432     String toShortSignature() {
433         StringJoiner sj = new StringJoiner(",", getName() + "(", ")");
434         for (Class<?> parameterType : getParameterTypes()) {
435             sj.add(parameterType.getTypeName());
436         }
437         return sj.toString();
438     }
439 
440     /**
441      * Returns a string describing this {@code Method}, including type
442      * parameters.  The string is formatted as the method access
443      * modifiers, if any, followed by an angle-bracketed
444      * comma-separated list of the method's type parameters, if any,
445      * including informative bounds of the type parameters, if any,
446      * followed by the method's generic return type, followed by a
447      * space, followed by the class declaring the method, followed by
448      * a period, followed by the method name, followed by a
449      * parenthesized, comma-separated list of the method's generic
450      * formal parameter types.
451      *
452      * If this method was declared to take a variable number of
453      * arguments, instead of denoting the last parameter as
454      * "<code><i>Type</i>[]</code>", it is denoted as
455      * "<code><i>Type</i>...</code>".
456      *
457      * A space is used to separate access modifiers from one another
458      * and from the type parameters or return type.  If there are no
459      * type parameters, the type parameter list is elided; if the type
460      * parameter list is present, a space separates the list from the
461      * class name.  If the method is declared to throw exceptions, the
462      * parameter list is followed by a space, followed by the word
463      * "{@code throws}" followed by a comma-separated list of the generic
464      * thrown exception types.
465      *
466      * <p>The access modifiers are placed in canonical order as
467      * specified by "The Java Language Specification".  This is
468      * {@code public}, {@code protected} or {@code private} first,
469      * and then other modifiers in the following order:
470      * {@code abstract}, {@code default}, {@code static}, {@code final},
471      * {@code synchronized}, {@code native}, {@code strictfp}.
472      *
473      * @return a string describing this {@code Method},
474      * include type parameters
475      *
476      * @since 1.5
477      *
478      * @jls 8.4.3 Method Modifiers
479      * @jls 9.4 Method Declarations
480      * @jls 9.6.1 Annotation Interface Elements
481      */
482     @Override
483     public String toGenericString() {
484         return sharedToGenericString(Modifier.methodModifiers(), isDefault());
485     }
486 
487     @Override
488     void specificToGenericStringHeader(StringBuilder sb) {
489         Type genRetType = getGenericReturnType();
490         sb.append(genRetType.getTypeName()).append(' ');
491         sb.append(getDeclaringClass().getTypeName()).append('.');
492         sb.append(getName());
493     }
494 
495     /**
496      * Invokes the underlying method represented by this {@code Method}
497      * object, on the specified object with the specified parameters.
498      * Individual parameters are automatically unwrapped to match
499      * primitive formal parameters, and both primitive and reference
500      * parameters are subject to method invocation conversions as
501      * necessary.
502      *
503      * <p>If the underlying method is static, then the specified {@code obj}
504      * argument is ignored. It may be null.
505      *
506      * <p>If the number of formal parameters required by the underlying method is
507      * 0, the supplied {@code args} array may be of length 0 or null.
508      *
509      * <p>If the underlying method is an instance method, it is invoked
510      * using dynamic method lookup as documented in The Java Language
511      * Specification, section {@jls 15.12.4.4}; in particular,
512      * overriding based on the runtime type of the target object may occur.
513      *
514      * <p>If the underlying method is static, the class that declared
515      * the method is initialized if it has not already been initialized.
516      *
517      * <p>If the method completes normally, the value it returns is
518      * returned to the caller of invoke; if the value has a primitive
519      * type, it is first appropriately wrapped in an object. However,
520      * if the value has the type of an array of a primitive type, the
521      * elements of the array are <i>not</i> wrapped in objects; in
522      * other words, an array of primitive type is returned.  If the
523      * underlying method return type is void, the invocation returns
524      * null.
525      *
526      * @param obj  the object the underlying method is invoked from
527      * @param args the arguments used for the method call
528      * @return the result of dispatching the method represented by
529      * this object on {@code obj} with parameters
530      * {@code args}
531      *
532      * @throws    IllegalAccessException    if this {@code Method} object
533      *              is enforcing Java language access control and the underlying
534      *              method is inaccessible.
535      * @throws    IllegalArgumentException  if the method is an
536      *              instance method and the specified object argument
537      *              is not an instance of the class or interface
538      *              declaring the underlying method (or of a subclass
539      *              or implementor thereof); if the number of actual
540      *              and formal parameters differ; if an unwrapping
541      *              conversion for primitive arguments fails; or if,
542      *              after possible unwrapping, a parameter value
543      *              cannot be converted to the corresponding formal
544      *              parameter type by a method invocation conversion.
545      * @throws    InvocationTargetException if the underlying method
546      *              throws an exception.
547      * @throws    NullPointerException      if the specified object is null
548      *              and the method is an instance method.
549      * @throws    ExceptionInInitializerError if the initialization
550      * provoked by this method fails.
551      */
552     @CallerSensitive
553     @ForceInline // to ensure Reflection.getCallerClass optimization
554     @IntrinsicCandidate
555     public Object invoke(Object obj, Object... args)
556         throws IllegalAccessException, IllegalArgumentException,
557            InvocationTargetException
558     {




































559         if (!override) {
560             Class<?> caller = Reflection.getCallerClass();
561             checkAccess(caller, clazz,
562                         Modifier.isStatic(modifiers) ? null : obj.getClass(),
563                         modifiers);
564         }
565         MethodAccessor ma = methodAccessor;             // read volatile
566         if (ma == null) {
567             ma = acquireMethodAccessor();
568         }
569         return ma.invoke(obj, args);










570     }
571 
572     /**
573      * {@return {@code true} if this method is a bridge
574      * method; returns {@code false} otherwise}
575      *
576      * @apiNote
577      * A bridge method is a {@linkplain isSynthetic synthetic} method
578      * created by a Java compiler alongside a method originating from
579      * the source code. Bridge methods are used by Java compilers in
580      * various circumstances to span differences in Java programming
581      * language semantics and JVM semantics.
582      *
583      * <p>One example use of bridge methods is as a technique for a
584      * Java compiler to support <i>covariant overrides</i>, where a
585      * subclass overrides a method and gives the new method a more
586      * specific return type than the method in the superclass.  While
587      * the Java language specification forbids a class declaring two
588      * methods with the same parameter types but a different return
589      * type, the virtual machine does not. A common case where
590      * covariant overrides are used is for a {@link
591      * java.lang.Cloneable Cloneable} class where the {@link
592      * Object#clone() clone} method inherited from {@code
593      * java.lang.Object} is overridden and declared to return the type
594      * of the class. For example, {@code Object} declares
595      * <pre>{@code protected Object clone() throws CloneNotSupportedException {...}}</pre>
596      * and {@code EnumSet<E>} declares its language-level {@linkplain
597      * java.util.EnumSet#clone() covariant override}
598      * <pre>{@code public EnumSet<E> clone() {...}}</pre>
599      * If this technique was being used, the resulting class file for
600      * {@code EnumSet} would have two {@code clone} methods, one
601      * returning {@code EnumSet<E>} and the second a bridge method
602      * returning {@code Object}. The bridge method is a JVM-level
603      * override of {@code Object.clone()}.  The body of the {@code
604      * clone} bridge method calls its non-bridge counterpart and
605      * returns its result.
606      * @since 1.5
607      *
608      * @jls 8.4.8.3 Requirements in Overriding and Hiding
609      * @jls 15.12.4.5 Create Frame, Synchronize, Transfer Control
610      * @jvms 4.6 Methods
611      * @see <a
612      * href="{@docRoot}/java.base/java/lang/reflect/package-summary.html#LanguageJvmModel">Java
613      * programming language and JVM modeling in core reflection</a>
614      */
615     public boolean isBridge() {
616         return (getModifiers() & Modifier.BRIDGE) != 0;
617     }
618 
619     /**
620      * {@inheritDoc}
621      * @since 1.5
622      * @jls 8.4.1 Formal Parameters
623      */
624     @Override
625     public boolean isVarArgs() {
626         return super.isVarArgs();
627     }
628 
629     /**
630      * {@inheritDoc}
631      * @jls 13.1 The Form of a Binary
632      * @jvms 4.6 Methods
633      * @see <a
634      * href="{@docRoot}/java.base/java/lang/reflect/package-summary.html#LanguageJvmModel">Java
635      * programming language and JVM modeling in core reflection</a>
636      * @since 1.5
637      */
638     @Override
639     public boolean isSynthetic() {
640         return super.isSynthetic();
641     }
642 
643     /**
644      * Returns {@code true} if this method is a default
645      * method; returns {@code false} otherwise.
646      *
647      * A default method is a public non-abstract instance method, that
648      * is, a non-static method with a body, declared in an interface.
649      *
650      * @return true if and only if this method is a default
651      * method as defined by the Java Language Specification.
652      * @since 1.8
653      * @jls 9.4 Method Declarations
654      */
655     public boolean isDefault() {
656         // Default methods are public non-abstract instance methods
657         // declared in an interface.
658         return ((getModifiers() & (Modifier.ABSTRACT | Modifier.PUBLIC | Modifier.STATIC)) ==
659                 Modifier.PUBLIC) && getDeclaringClass().isInterface();
660     }
661 
662     // NOTE that there is no synchronization used here. It is correct
663     // (though not efficient) to generate more than one MethodAccessor
664     // for a given Method. However, avoiding synchronization will
665     // probably make the implementation more scalable.
666     private MethodAccessor acquireMethodAccessor() {
667         // First check to see if one has been created yet, and take it
668         // if so
669         Method root = this.root;
670         MethodAccessor tmp = root == null ? null : root.getMethodAccessor();
671         if (tmp != null) {
672             methodAccessor = tmp;
673         } else {
674             // Otherwise fabricate one and propagate it up to the root
675             tmp = reflectionFactory.newMethodAccessor(this);
676             setMethodAccessor(tmp);


677         }
678 
679         return tmp;
680     }
681 
682     // Returns MethodAccessor for this Method object, not looking up
683     // the chain to the root
684     MethodAccessor getMethodAccessor() {
685         return methodAccessor;
686     }
687 
688     // Sets the MethodAccessor for this Method object and
689     // (recursively) its root
690     void setMethodAccessor(MethodAccessor accessor) {
691         methodAccessor = accessor;
692         // Propagate up
693         Method root = this.root;
694         if (root != null) {
695             root.setMethodAccessor(accessor);
696         }
697     }
698 
699     /**
700      * Returns the default value for the annotation member represented by
701      * this {@code Method} instance.  If the member is of a primitive type,
702      * an instance of the corresponding wrapper type is returned. Returns
703      * null if no default is associated with the member, or if the method
704      * instance does not represent a declared member of an annotation type.
705      *
706      * @return the default value for the annotation member represented
707      *     by this {@code Method} instance.
708      * @throws TypeNotPresentException if the annotation is of type
709      *     {@link Class} and no definition can be found for the
710      *     default class value.
711      * @since  1.5
712      * @jls 9.6.2 Defaults for Annotation Type Elements
713      */
714     public Object getDefaultValue() {
715         if  (annotationDefault == null)
716             return null;
717         Class<?> memberType = AnnotationType.invocationHandlerReturnType(
718             getReturnType());
719         Object result = AnnotationParser.parseMemberValue(
720             memberType, ByteBuffer.wrap(annotationDefault),
721             SharedSecrets.getJavaLangAccess().
722                 getConstantPool(getDeclaringClass()),
723             getDeclaringClass());
724         if (result instanceof ExceptionProxy) {
725             if (result instanceof TypeNotPresentExceptionProxy proxy) {
726                 throw new TypeNotPresentException(proxy.typeName(), proxy.getCause());
727             }
728             throw new AnnotationFormatError("Invalid default: " + this);
729         }
730         return result;
731     }
732 
733     /**
734      * {@inheritDoc}
735      * @throws NullPointerException {@inheritDoc}
736      * @since 1.5
737      */
738     @Override
739     public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
740         return super.getAnnotation(annotationClass);
741     }
742 
743     /**
744      * {@inheritDoc}
745      * @since 1.5
746      */
747     @Override
748     public Annotation[] getDeclaredAnnotations()  {
749         return super.getDeclaredAnnotations();
750     }
751 
752     /**
753      * {@inheritDoc}
754      * @since 1.5
755      */
756     @Override
757     public Annotation[][] getParameterAnnotations() {
758         return sharedGetParameterAnnotations(parameterTypes, parameterAnnotations);
759     }
760 
761     /**
762      * {@inheritDoc}
763      * @since 1.8
764      */
765     @Override
766     public AnnotatedType getAnnotatedReturnType() {
767         return getAnnotatedReturnType0(getGenericReturnType());
768     }
769 
770     @Override
771     boolean handleParameterNumberMismatch(int resultLength, Class<?>[] parameterTypes) {
772         throw new AnnotationFormatError("Parameter annotations don't match number of parameters");
773     }
774 }
--- EOF ---