Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

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. Create new class from a Variable in Java
Is there a way to create a new class from a String variable in Java? String className = "Class1"; //pseudocode follows Object xyz = new className(param1, param2); Also, if possible does the resulting object have to be of type Object? There may be a better way, but I want to be able to retrieve values from an XML file, then create the classes named after those strings. Each of classes all im...
3. Is it possible to create an instance of nested class using Java Reflection?
Sample of code: public class Foo { public class Bar { public void printMesg(String body) { System.out.println(body); } } public static void main(String[] args) { // Creating new instance of 'Bar' using Class.forname - how? } } Is it possible to create new instance of class Bar giving its name? I tried to use: C...
4. How does the syntax `new Class[]{}` work?
In the first code example of this beginners guide to Dependency Injection I encountered some new constructs of which I am not sure that I totally understand: // Instantiate CabAgency, and satisfy its dependency on an airlineagency. Constructor constructor = cabAgencyClass.getConstructor (new Class[]{AirlineAgency.class}); cabAgency = (CabAgency) constructor.newInstance (new Object[]{ai...
5. How to loop over a Class attributes in Java?
How can I loop over a class attributes in java dynamically. For eg : public class MyClass { private type1 att1; private type2 att2; ... public void function() { for(var in MyClass.Attributes) { System.out.println(var.class); } } } is this possible in Java?
6. Using Reflection: java.reflection.Constructor.newInstance()
I'm trying to instantiate a class using the Constructor.newInstance() method but am running into trouble properly providing the parameters for the constructor. The problem is, the constructor parameters are made available as a String[] array, the elements of which I have to cast to their corresponding types. This works for objects, but what if some of the parameters are primitive types? Here's...
7. Returning and instance of a Class given its .class (MyClass.class)
I have an enum that will hold my algorithms. I cannot instantiate these classes because I need the application context which is only available once the application has started. I want to load the class at runtime when I choose by calling getAlgorithm(Context cnx). How do I easily instantiate a class at runtime given its .class (and my constructor takes arguments)? All my classes are subcl...
8. Java - getConstructor()?
I wrote the question as a comment in the code, I think its easier to understand this way. public class Xpto{ protected AbstractClass x; public void foo(){ // AbstractClass y = new ????? Car or Person ????? /* here I need a new object of this.x's type (which could be Car or Person) I know that with x.getClass() I get the x's Class (which will be Car or ...
9. Java: newInstance of class thas has no default constructor
I'm trying to build an automatic testing framework (based on jUnit, but that's no important) for my student's homework. They will have to create constructors of some classes, and add them methods. Then, with the testing functions I provide, they will check if they went allright. What I want to do is, by reflection, create a new instance of some class I want to test. The problem is that, somet...
10. Problem with constructing class using reflection and array arguments
running the folowing code: public class Test { public Test(Object[] test){ } public static void main(String[] args) throws Exception{ Constructor cd = Test.class.getConstructor(Object[].class); Object[] objs = {1, 2, 3, 4, 5, 6, 7, 8}; cd.newInstance(objs); } } I get the error : Exception in thread "main" java.lang.IllegalArgument...
11. How can I create an instance of type dynamically in Java
In my Java application I have method public <T extends Transaction> boolean appendTransaction(T transaction) { ... } and inside of this method I need to create an instance of object T which extends Transaction Is it correct to do it in this way T newTransaction = (T) transaction.getClass().newInstance();
12. Java: do methods inherit a JRE super class, like classes inherit Object?
As far as I know, everything is an object in Java. I am looking through the java JDK and am experimenting with creating a custom JDK that allows me to perform more debugging operations. For example, I can manipulate every object by changing the Object.java class. My question is: do methods inherit a class from the JRE as well, so that I can modify this parent to eg. make a method save it's mo...
13. Java: How to use non-primitive types for constructor.newInstance() in Java Reflection?
After a long day of searching, I still can't figure out how I can instanciate a new object from a selfmade class, if the constructor takes non-primitive arguments. Now I start doubting if this is possible at all?! In the Documentation of Reflection, they only talk about primitive types (like int, float, boolean, etc.) as far as I saw. And all other information/website/workshop/example I found ...
14. Class at runtime
Is there a way to create Java classes @ at runtime (classes methods n variables), with using Java reflection API
15. Creating an instance using the class name and calling constructor
Is there a way to create an instance of a particular class given the class name (dynamic) and pass parameters to it's constructor. Something like: Object object = createInstance("mypackage.MyClass","MyAttributeValue"); MyAttributeValue is the an argument to the constructor of MyClass.
16. Intializing a class with Class.forName() and which have a constructor which takes arguments
I am instantiating a class like this. myObj = (myObj) Class.forName("fully qualified class name here").newInstance(); My doubt here is if we have a constructor which takes arguments how can we instantiate it like above one. Thanks, Narendra
17. Java Generics - any run time benefits
I wanted to know if there are any run time advantages to Generics provided from Java5. I mean, I know that we can achieve type safety for classes/collections and allow a range of possible objects for a generic, but are there any benefits that we get at Run time ahead of compilation time?
18. Why can't Constructors objects be serialized in Java?
I have a class that implements Serializable, it's part of a bigger mesh of objects, it contains a Constructor field, but when it's the Constructors turn to be serialized it throws the NotSerializableException. I guess I'll have to write the logic myself and recreate the constructor myself every time I deserialize the containing object, but why the heck on earth would the designers of Java wann...
19. Reflection: How to find a constructor that takes a list of objects?
I have a class that takes a List in the constructor; public class MyClass { private List<Structure> structures; public MyClass(List<Structure> structures) { this.structures = structures; } } that I need to instantiate via reflection. How do I define the call to class.getConstructor() to find this? Regards
20. How to convert comma delimited String to List of T in Core Java
"first time long time" as they say on the radio talk shows... I'm trying to parse a delimited property into a List. Simple enough, but for some reason I can't figure how to do this in a generic fashion using only Core Java. By generic, I mean the type of List to create may be a List< String >, List< Integer >, or List< Double >. My latest stab at it below gives runtime exceptions w...
21. Can I Instantiate a class using the class object? What about Constructors?
I am storing a list of classes through (Classname.class) and would like to instantiate one? Is this possible? newInstance seems to the method I am after but it doesn't support a constructor? 
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
 
35
 import java.util.Map;
Constructor provides information about, and access to, a single constructor for a class.

Constructor permits widening conversions to occur when matching the actual parameters to newInstance() with the underlying constructor's formal parameters, but throws an IllegalArgumentException if a narrowing conversion would occur.

Parameters:
<T> the class in which the constructor is declared
Author(s):
Kenneth Russell
Nakul Saraiya
See also:
Member
java.lang.Class
java.lang.Class.getConstructors()
java.lang.Class.getConstructor(java.lang.Class[])
java.lang.Class.getDeclaredConstructors()
59
 
60
 public final
61
     class Constructor<T> extends AccessibleObject implements
62
                                                     GenericDeclaration,
63
                                                     Member {
64
 
65
     private Class<T>            clazz;
66
     private int                 slot;
67
     private Class[]             parameterTypes;
68
     private Class[]             exceptionTypes;
69
     private int                 modifiers;
70
     // Generics and annotations support
71
     private transient String    signature;
72
     // generic info repository; lazily initialized
73
     private transient ConstructorRepository genericInfo;
74
     private byte[]              annotations;
75
     private byte[]              parameterAnnotations;
76
 
77
     // For non-public members or members in package-private classes,
78
     // it is necessary to perform somewhat expensive security checks.
79
     // If the security check succeeds for a given class, it will
80
     // always succeed (it is not affected by the granting or revoking
81
     // of permissions); we speed up the check in the common case by
82
     // remembering the last Class for which the check succeeded.
83
     private volatile Class securityCheckCache;
84
 
85
     // Modifiers that can be applied to a constructor in source code
86
     private static final int LANGUAGE_MODIFIERS =
87
         .         | .    | .;
88
 
89
     // Generics infrastructure
90
     // Accessor for factory
91
     private GenericsFactory getFactory() {
92
         // create scope and factory
93
         return CoreReflectionFactory.make(this, ConstructorScope.make(this));
94
     }
95
 
96
     // Accessor for generic info repository
97
     private ConstructorRepository getGenericInfo() {
98
         // lazily initialize repository if necessary
99
         if ( == null) {
100
            // create and cache generic info repository
101
             =
102
                ConstructorRepository.make(getSignature(),
103
                                           getFactory());
104
        }
105
        return ; //return cached repository
106
    }
108
    private volatile ConstructorAccessor constructorAccessor;
109
    // For sharing of ConstructorAccessors. This branching structure
110
    // is currently only two levels deep (i.e., one root Constructor
111
    // and potentially many Constructor objects pointing to it.)
112
    private Constructor<T>      root;

    
Package-private constructor used by ReflectAccess to enable instantiation of these objects in Java code from the java.lang package via sun.reflect.LangReflectAccess. 
119
    Constructor(Class<T> declaringClass,
120
                Class[] parameterTypes,
121
                Class[] checkedExceptions,
122
                int modifiers,
123
                int slot,
124
                String signature,
125
                byte[] annotations,
126
                byte[] parameterAnnotations)
127
    {
128
        this. = declaringClass;
129
        this. = parameterTypes;
130
        this. = checkedExceptions;
131
        this. = modifiers;
132
        this. = slot;
133
        this. = signature;
134
        this. = annotations;
135
        this. = parameterAnnotations;
136
    }

    
Package-private routine (exposed to java.lang.Class via ReflectAccess) which returns a copy of this Constructor. The copy's "root" field points to this Constructor. 
143
    Constructor<T> copy() {
144
        // This routine enables sharing of ConstructorAccessor objects
145
        // among Constructor objects which refer to the same underlying
146
        // method in the VM. (All of this contortion is only necessary
147
        // because of the "accessibility" bit in AccessibleObject,
148
        // which implicitly requires that new java.lang.reflect
149
        // objects be fabricated for each reflective call on Class
150
        // objects.)
151
        Constructor<T> res = new Constructor<T>(,
152
                                                ,
153
                                                , , ,
154
                                                ,
155
                                                ,
156
                                                );
157
        res.root = this;
158
        // Might as well eagerly propagate this if already present
159
        res.constructorAccessor = ;
160
        return res;
161
    }

    
Returns the Class object representing the class that declares the constructor represented by this Constructor object. 
167
    public Class<T> getDeclaringClass() {
168
        return ;
169
    }

    
Returns the name of this constructor, as a string. This is always the same as the simple name of the constructor's declaring class. 
176
    public String getName() {
177
        return getDeclaringClass().getName();
178
    }

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

See also:
Modifier
187
    public int getModifiers() {
188
        return ;
189
    }

    
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
206
    public TypeVariable<Constructor<T>>[] getTypeParameters() {
207
      if (getSignature() != null) {
208
        return (TypeVariable<Constructor<T>>[])getGenericInfo().getTypeParameters();
209
      } else
210
          return (TypeVariable<Constructor<T>>[])new TypeVariable[0];
211
    }


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

Returns:
the parameter types for the constructor this object represents
223
    public Class<?>[] getParameterTypes() {
224
        return (Class<?>[]) .clone();
225
    }


    
Returns an array of Type objects that represent the formal parameter types, in declaration order, of the method represented by this Constructor 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 edition
java.lang.TypeNotPresentException if any of the parameter types of the underlying method refers to a non-existent type declaration
MalformedParameterizedTypeException if any of the underlying method's parameter types refer to a parameterized type that cannot be instantiated for any reason
Since:
1.5
254
    public Type[] getGenericParameterTypes() {
255
        if (getSignature() != null)
256
            return getGenericInfo().getParameterTypes();
257
        else
258
            return getParameterTypes();
259
    }


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

Returns:
the exception types declared as being thrown by the constructor this object represents
271
    public Class<?>[] getExceptionTypes() {
272
        return (Class<?>[]).clone();
273
    }


    
Returns an array of Type objects that represent the exceptions declared to be thrown by this Constructor 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 edition
java.lang.TypeNotPresentException if the underlying method's throws clause refers to a non-existent type declaration
MalformedParameterizedTypeException if the underlying method's throws clause refers to a parameterized type that cannot be instantiated for any reason
Since:
1.5
301
      public Type[] getGenericExceptionTypes() {
302
          Type[] result;
303
          if (getSignature() != null &&
304
              ( (result = getGenericInfo().getExceptionTypes()).length > 0  ))
305
              return result;
306
          else
307
              return getExceptionTypes();
308
      }

    
Compares this Constructor against the specified object. Returns true if the objects are the same. Two Constructor objects are the same if they were declared by the same class and have the same formal parameter types. 
316
    public boolean equals(Object obj) {
317
        if (obj != null && obj instanceof Constructor) {
318
            Constructor other = (Constructor)obj;
319
            if (getDeclaringClass() == other.getDeclaringClass()) {
320
                /* Avoid unnecessary cloning */
321
                Class[] params1 = ;
322
                Class[] params2 = other.parameterTypes;
323
                if (params1.length == params2.length) {
324
                    for (int i = 0; i < params1.length; i++) {
325
                        if (params1[i] != params2[i])
326
                            return false;
327
                    }
328
                    return true;
329
                }
330
            }
331
        }
332
        return false;
333
    }

    
Returns a hashcode for this Constructor. The hashcode is the same as the hashcode for the underlying constructor's declaring class name. 
340
    public int hashCode() {
341
        return getDeclaringClass().getName().hashCode();
342
    }

    
Returns a string describing this Constructor. The string is formatted as the constructor access modifiers, if any, followed by the fully-qualified name of the declaring class, followed by a parenthesized, comma-separated list of the constructor's formal parameter types. For example: 
    public java.util.Hashtable(int,float)

The only possible modifiers for constructors are the access modifiers public, protected or private. Only one of these may appear, or none if the constructor has default (package) access. 

359
    public String toString() {
360
        try {
361
            StringBuffer sb = new StringBuffer();
362
            int mod = getModifiers() & ;
363
            if (mod != 0) {
364
                sb.append(Modifier.toString(mod) + " ");
365
            }
366
            sb.append(Field.getTypeName(getDeclaringClass()));
367
            sb.append("(");
368
            Class[] params = ; // avoid clone
369
            for (int j = 0; j < params.length; j++) {
370
                sb.append(Field.getTypeName(params[j]));
371
                if (j < (params.length - 1))
372
                    sb.append(",");
373
            }
374
            sb.append(")");
375
            Class[] exceptions = ; // avoid clone
376
            if (exceptions.length > 0) {
377
                sb.append(" throws ");
378
                for (int k = 0; k < exceptions.length; k++) {
379
                    sb.append(exceptions[k].getName());
380
                    if (k < (exceptions.length - 1))
381
                        sb.append(",");
382
                }
383
            }
384
            return sb.toString();
385
        } catch (Exception e) {
386
            return "<" + e + ">";
387
        }
388
    }

    
Returns a string describing this Constructor, including type parameters. The string is formatted as the constructor access modifiers, if any, followed by an angle-bracketed comma separated list of the constructor's type parameters, if any, followed by the fully-qualified name of the declaring class, followed by a parenthesized, comma-separated list of the constructor'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 constructor 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 thrown exception types.

The only possible modifiers for constructors are the access modifiers public, protected or private. Only one of these may appear, or none if the constructor has default (package) access.

Returns:
a string describing this Constructor, include type parameters
Since:
1.5
418
    public String toGenericString() {
419
        try {
420
            StringBuilder sb = new StringBuilder();
421
            int mod = getModifiers() & ;
422
            if (mod != 0) {
423
                sb.append(Modifier.toString(mod) + " ");
424
            }
425
            TypeVariable<?>[] typeparms = getTypeParameters();
426
            if (typeparms.length > 0) {
427
                boolean first = true;
428
                sb.append("<");
429
                for(TypeVariable<?> typeparm: typeparms) {
430
                    if (!first)
431
                        sb.append(",");
432
                    // Class objects can't occur here; no need to test
433
                    // and call Class.getName().
434
                    sb.append(typeparm.toString());
435
                    first = false;
436
                }
437
                sb.append("> ");
438
            }
439
            sb.append(Field.getTypeName(getDeclaringClass()));
440
            sb.append("(");
441
            Type[] params = getGenericParameterTypes();
442
            for (int j = 0; j < params.length; j++) {
443
                String param = (params[j] instanceof Class<?>)?
444
                    Field.getTypeName((Class<?>)params[j]):
445
                    (params[j].toString());
446
                sb.append(param);
447
                if (j < (params.length - 1))
448
                    sb.append(",");
449
            }
450
            sb.append(")");
451
            Type[] exceptions = getGenericExceptionTypes();
452
            if (exceptions.length > 0) {
453
                sb.append(" throws ");
454
                for (int k = 0; k < exceptions.length; k++) {
455
                    sb.append((exceptions[k] instanceof Class)?
456
                              ((Class)exceptions[k]).getName():
457
                              exceptions[k].toString());
458
                    if (k < (exceptions.length - 1))
459
                        sb.append(",");
460
                }
461
            }
462
            return sb.toString();
463
        } catch (Exception e) {
464
            return "<" + e + ">";
465
        }
466
    }

    
Uses the constructor represented by this Constructor object to create and initialize a new instance of the constructor's declaring class, with the specified initialization 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 number of formal parameters required by the underlying constructor is 0, the supplied initargs array may be of length 0 or null.

If the constructor's declaring class is an inner class in a non-static context, the first argument to the constructor needs to be the enclosing instance; see The Java Language Specification, section 15.9.3.

If the required access and argument checks succeed and the instantiation will proceed, the constructor's declaring class is initialized if it has not already been initialized.

If the constructor completes normally, returns the newly created and initialized instance.

Parameters:
initargs array of objects to be passed as arguments to the constructor call; values of primitive types are wrapped in a wrapper object of the appropriate type (e.g. a float in a Float)
Returns:
a new object created by calling the constructor this object represents
Throws:
java.lang.IllegalAccessException if this Constructor object enforces Java language access control and the underlying constructor is inaccessible.
java.lang.IllegalArgumentException 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; if this constructor pertains to an enum type.
java.lang.InstantiationException if the class that declares the underlying constructor represents an abstract class.
InvocationTargetException if the underlying constructor throws an exception.
java.lang.ExceptionInInitializerError if the initialization provoked by this method fails.
516
    public T newInstance(Object ... initargs)
519
    {
520
        if (!) {
521
            if (!Reflection.quickCheckMemberAccess(, )) {
522
                Class caller = Reflection.getCallerClass(2);
523
                if ( != caller) {
524
                    Reflection.ensureMemberAccess(caller, , null, );
525
                     = caller;
526
                }
527
            }
528
        }
529
        if ((.getModifiers() & .) != 0)
530
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
531
        if ( == null) acquireConstructorAccessor();
532
        return (T) .newInstance(initargs);
533
    }

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

Returns:
true if an only if this constructor was declared to take a variable number of arguments.
Since:
1.5
544
    public boolean isVarArgs() {
545
        return (getModifiers() & .) != 0;
546
    }

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

Returns:
true if and only if this constructor is a synthetic constructor as defined by the Java Language Specification.
Since:
1.5
556
    public boolean isSynthetic() {
557
        return Modifier.isSynthetic(getModifiers());
558
    }
560
    // NOTE that there is no synchronization used here. It is correct
561
    // (though not efficient) to generate more than one
562
    // ConstructorAccessor for a given Constructor. However, avoiding
563
    // synchronization will probably make the implementation more
564
    // scalable.
565
    private void acquireConstructorAccessor() {
566
        // First check to see if one has been created yet, and take it
567
        // if so.
568
        ConstructorAccessor tmp = null;
569
        if ( != null) tmp = .getConstructorAccessor();
570
        if (tmp != null) {
571
             = tmp;
572
            return;
573
        }
574
        // Otherwise fabricate one and propagate it up to the root
575
        tmp = .newConstructorAccessor(this);
576
        setConstructorAccessor(tmp);
577
    }
579
    // Returns ConstructorAccessor for this Constructor object, not
580
    // looking up the chain to the root
582
        return ;
583
    }
585
    // Sets the ConstructorAccessor for this Constructor object and
586
    // (recursively) its root
588
         = accessor;
589
        // Propagate up
590
        if ( != null) {
591
            .setConstructorAccessor(accessor);
592
        }
593
    }
595
    int getSlot() {
596
        return ;
597
    }
600
            return ;
601
   }
603
    byte[] getRawAnnotations() {
604
        return ;
605
    }
607
    byte[] getRawParameterAnnotations() {
608
        return ;
609
    }

    

Throws:
java.lang.NullPointerException
Since:
1.5
615
    public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
616
        if (annotationClass == null)
617
            throw new NullPointerException();
619
        return (T) declaredAnnotations().get(annotationClass);
620
    }
622
    private static final Annotation[] EMPTY_ANNOTATION_ARRAY=new Annotation[0];

    

Since:
1.5
627
    public Annotation[] getDeclaredAnnotations()  {
629
    }
631
    private transient Map<Class, Annotation> declaredAnnotations;
633
    private synchronized  Map<Class, Annotation> declaredAnnotations() {
634
        if ( == null) {
635
             = AnnotationParser.parseAnnotations(
636
                , sun.misc.SharedSecrets.getJavaLangAccess().
637
                getConstantPool(getDeclaringClass()),
638
                getDeclaringClass());
639
        }
640
        return ;
641
    }

    
Returns an array of arrays that represent the annotations on the formal parameters, in declaration order, of the method represented by this Constructor 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 Constructor object
Since:
1.5
659
    public Annotation[][] getParameterAnnotations() {
660
        int numParameters = .;
661
        if ( == null)
662
            return new Annotation[numParameters][0];
664
        Annotation[][] result = AnnotationParser.parseParameterAnnotations(
665
            ,
666
            sun.misc.SharedSecrets.getJavaLangAccess().
667
                getConstantPool(getDeclaringClass()),
668
            getDeclaringClass());
669
        if (result.length != numParameters) {
670
            Class<?> declaringClass = getDeclaringClass();
671
            if (declaringClass.isEnum() ||
672
                declaringClass.isAnonymousClass() ||
673
                declaringClass.isLocalClass() )
674
                ; // Can't do reliable parameter counting
675
            else {
676
                if (!declaringClass.isMemberClass() || // top-level
677
                    // Check for the enclosing instance parameter for
678
                    // non-static member classes
679
                    (declaringClass.isMemberClass() &&
680
                     ((declaringClass.getModifiers() & .) == 0)  &&
681
                     result.length + 1 != numParameters) ) {
682
                    throw new AnnotationFormatError(
683
                              "Parameter annotations don't match number of parameters");
684
                }
685
            }
686
        }
687
        return result;
688
    }
New to GrepCode? Check out our FAQ X