Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * Copyright (c) 1996, 2010, 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
 
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
     // Generics infrastructure
78
     // Accessor for factory
79
     private GenericsFactory getFactory() {
80
         // create scope and factory
81
         return CoreReflectionFactory.make(this, ConstructorScope.make(this));
82
     }
83
 
84
     // Accessor for generic info repository
85
     private ConstructorRepository getGenericInfo() {
86
         // lazily initialize repository if necessary
87
         if ( == null) {
88
             // create and cache generic info repository
89
              =
90
                 ConstructorRepository.make(getSignature(),
91
                                            getFactory());
92
         }
93
         return ; //return cached repository
94
     }
95
 
96
     private volatile ConstructorAccessor constructorAccessor;
97
     // For sharing of ConstructorAccessors. This branching structure
98
     // is currently only two levels deep (i.e., one root Constructor
99
     // and potentially many Constructor objects pointing to it.)
100
    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. 
107
    Constructor(Class<T> declaringClass,
108
                Class<?>[] parameterTypes,
109
                Class<?>[] checkedExceptions,
110
                int modifiers,
111
                int slot,
112
                String signature,
113
                byte[] annotations,
114
                byte[] parameterAnnotations)
115
    {
116
        this. = declaringClass;
117
        this. = parameterTypes;
118
        this. = checkedExceptions;
119
        this. = modifiers;
120
        this. = slot;
121
        this. = signature;
122
        this. = annotations;
123
        this. = parameterAnnotations;
124
    }

    
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. 
131
    Constructor<T> copy() {
132
        // This routine enables sharing of ConstructorAccessor objects
133
        // among Constructor objects which refer to the same underlying
134
        // method in the VM. (All of this contortion is only necessary
135
        // because of the "accessibility" bit in AccessibleObject,
136
        // which implicitly requires that new java.lang.reflect
137
        // objects be fabricated for each reflective call on Class
138
        // objects.)
139
        Constructor<T> res = new Constructor<>(,
140
                                                ,
141
                                                , , ,
142
                                                ,
143
                                                ,
144
                                                );
145
        res.root = this;
146
        // Might as well eagerly propagate this if already present
147
        res.constructorAccessor = ;
148
        return res;
149
    }

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

    
Returns the name of this constructor, as a string. This is the binary name of the constructor's declaring class. 
163
    public String getName() {
164
        return getDeclaringClass().getName();
165
    }

    
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
174
    public int getModifiers() {
175
        return ;
176
    }

    
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
Since:
1.5
193
    public TypeVariable<Constructor<T>>[] getTypeParameters() {
194
      if (getSignature() != null) {
195
        return (TypeVariable<Constructor<T>>[])getGenericInfo().getTypeParameters();
196
      } else
197
          return (TypeVariable<Constructor<T>>[])new TypeVariable[0];
198
    }


    
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
210
    public Class<?>[] getParameterTypes() {
211
        return (Class<?>[]) .clone();
212
    }


    
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
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
242
    public Type[] getGenericParameterTypes() {
243
        if (getSignature() != null)
244
            return getGenericInfo().getParameterTypes();
245
        else
246
            return getParameterTypes();
247
    }


    
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
259
    public Class<?>[] getExceptionTypes() {
260
        return (Class<?>[]).clone();
261
    }


    
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 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
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
286
      public Type[] getGenericExceptionTypes() {
287
          Type[] result;
288
          if (getSignature() != null &&
289
              ( (result = getGenericInfo().getExceptionTypes()).length > 0  ))
290
              return result;
291
          else
292
              return getExceptionTypes();
293
      }

    
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. 
301
    public boolean equals(Object obj) {
302
        if (obj != null && obj instanceof Constructor) {
303
            Constructor<?> other = (Constructor<?>)obj;
304
            if (getDeclaringClass() == other.getDeclaringClass()) {
305
                /* Avoid unnecessary cloning */
306
                Class<?>[] params1 = ;
307
                Class<?>[] params2 = other.parameterTypes;
308
                if (params1.length == params2.length) {
309
                    for (int i = 0; i < params1.length; i++) {
310
                        if (params1[i] != params2[i])
311
                            return false;
312
                    }
313
                    return true;
314
                }
315
            }
316
        }
317
        return false;
318
    }

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

    
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. 

344
    public String toString() {
345
        try {
346
            StringBuffer sb = new StringBuffer();
347
            int mod = getModifiers() & Modifier.constructorModifiers();
348
            if (mod != 0) {
349
                sb.append(Modifier.toString(mod) + " ");
350
            }
351
            sb.append(Field.getTypeName(getDeclaringClass()));
352
            sb.append("(");
353
            Class<?>[] params = ; // avoid clone
354
            for (int j = 0; j < params.length; j++) {
355
                sb.append(Field.getTypeName(params[j]));
356
                if (j < (params.length - 1))
357
                    sb.append(",");
358
            }
359
            sb.append(")");
360
            Class<?>[] exceptions = ; // avoid clone
361
            if (exceptions.length > 0) {
362
                sb.append(" throws ");
363
                for (int k = 0; k < exceptions.length; k++) {
364
                    sb.append(exceptions[k].getName());
365
                    if (k < (exceptions.length - 1))
366
                        sb.append(",");
367
                }
368
            }
369
            return sb.toString();
370
        } catch (Exception e) {
371
            return "<" + e + ">";
372
        }
373
    }

    
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. If this constructor was declared to take a variable number of arguments, instead of denoting the last parameter as "Type[]", it is denoted as "Type...". 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
408
    public String toGenericString() {
409
        try {
410
            StringBuilder sb = new StringBuilder();
411
            int mod = getModifiers() & Modifier.constructorModifiers();
412
            if (mod != 0) {
413
                sb.append(Modifier.toString(mod) + " ");
414
            }
415
            TypeVariable<?>[] typeparms = getTypeParameters();
416
            if (typeparms.length > 0) {
417
                boolean first = true;
418
                sb.append("<");
419
                for(TypeVariable<?> typeparm: typeparms) {
420
                    if (!first)
421
                        sb.append(",");
422
                    // Class objects can't occur here; no need to test
423
                    // and call Class.getName().
424
                    sb.append(typeparm.toString());
425
                    first = false;
426
                }
427
                sb.append("> ");
428
            }
429
            sb.append(Field.getTypeName(getDeclaringClass()));
430
            sb.append("(");
431
            Type[] params = getGenericParameterTypes();
432
            for (int j = 0; j < params.length; j++) {
433
                String param = (params[j] instanceof Class<?>)?
434
                    Field.getTypeName((Class<?>)params[j]):
435
                    (params[j].toString());
436
                if (isVarArgs() && (j == params.length - 1)) // replace T[] with T...
437
                    param = param.replaceFirst("\\[\\]$", "...");
438
                sb.append(param);
439
                if (j < (params.length - 1))
440
                    sb.append(",");
441
            }
442
            sb.append(")");
443
            Type[] exceptions = getGenericExceptionTypes();
444
            if (exceptions.length > 0) {
445
                sb.append(" throws ");
446
                for (int k = 0; k < exceptions.length; k++) {
447
                    sb.append((exceptions[k] instanceof Class)?
448
                              ((Class<?>)exceptions[k]).getName():
449
                              exceptions[k].toString());
450
                    if (k < (exceptions.length - 1))
451
                        sb.append(",");
452
                }
453
            }
454
            return sb.toString();
455
        } catch (Exception e) {
456
            return "<" + e + ">";
457
        }
458
    }

    
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 section 15.9.3 of The Java™ Language Specification.

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 is enforcing 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.
508
    public T newInstance(Object ... initargs)
511
    {
512
        if (!) {
513
            if (!Reflection.quickCheckMemberAccess(, )) {
514
                Class<?> caller = Reflection.getCallerClass(2);
516
                checkAccess(caller, , null, );
517
            }
518
        }
519
        if ((.getModifiers() & .) != 0)
520
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
521
        ConstructorAccessor ca = ;   // read volatile
522
        if (ca == null) {
523
            ca = acquireConstructorAccessor();
524
        }
525
        return (T) ca.newInstance(initargs);
526
    }

    
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
537
    public boolean isVarArgs() {
538
        return (getModifiers() & .) != 0;
539
    }

    
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
550
    public boolean isSynthetic() {
551
        return Modifier.isSynthetic(getModifiers());
552
    }
554
    // NOTE that there is no synchronization used here. It is correct
555
    // (though not efficient) to generate more than one
556
    // ConstructorAccessor for a given Constructor. However, avoiding
557
    // synchronization will probably make the implementation more
558
    // scalable.
560
        // First check to see if one has been created yet, and take it
561
        // if so.
562
        ConstructorAccessor tmp = null;
563
        if ( != null) tmp = .getConstructorAccessor();
564
        if (tmp != null) {
565
             = tmp;
566
        } else {
567
            // Otherwise fabricate one and propagate it up to the root
568
            tmp = .newConstructorAccessor(this);
569
            setConstructorAccessor(tmp);
570
        }
572
        return tmp;
573
    }
575
    // Returns ConstructorAccessor for this Constructor object, not
576
    // looking up the chain to the root
578
        return ;
579
    }
581
    // Sets the ConstructorAccessor for this Constructor object and
582
    // (recursively) its root
584
         = accessor;
585
        // Propagate up
586
        if ( != null) {
587
            .setConstructorAccessor(accessor);
588
        }
589
    }
591
    int getSlot() {
592
        return ;
593
    }
596
            return ;
597
   }
599
    byte[] getRawAnnotations() {
600
        return ;
601
    }
603
    byte[] getRawParameterAnnotations() {
604
        return ;
605
    }

    

Throws:
java.lang.NullPointerException
Since:
1.5
611
    public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
612
        if (annotationClass == null)
613
            throw new NullPointerException();
615
        return (T) declaredAnnotations().get(annotationClass);
616
    }

    

Since:
1.5
621
    public Annotation[] getDeclaredAnnotations()  {
622
        return AnnotationParser.toArray(declaredAnnotations());
623
    }
625
    private transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
627
    private synchronized  Map<Class<? extends Annotation>, Annotation> declaredAnnotations() {
628
        if ( == null) {
629
             = AnnotationParser.parseAnnotations(
630
                , sun.misc.SharedSecrets.getJavaLangAccess().
631
                getConstantPool(getDeclaringClass()),
632
                getDeclaringClass());
633
        }
634
        return ;
635
    }

    
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
653
    public Annotation[][] getParameterAnnotations() {
654
        int numParameters = .;
655
        if ( == null)
656
            return new Annotation[numParameters][0];
658
        Annotation[][] result = AnnotationParser.parseParameterAnnotations(
659
            ,
660
            sun.misc.SharedSecrets.getJavaLangAccess().
661
                getConstantPool(getDeclaringClass()),
662
            getDeclaringClass());
663
        if (result.length != numParameters) {
664
            Class<?> declaringClass = getDeclaringClass();
665
            if (declaringClass.isEnum() ||
666
                declaringClass.isAnonymousClass() ||
667
                declaringClass.isLocalClass() )
668
                ; // Can't do reliable parameter counting
669
            else {
670
                if (!declaringClass.isMemberClass() || // top-level
671
                    // Check for the enclosing instance parameter for
672
                    // non-static member classes
673
                    (declaringClass.isMemberClass() &&
674
                     ((declaringClass.getModifiers() & .) == 0)  &&
675
                     result.length + 1 != numParameters) ) {
676
                    throw new AnnotationFormatError(
677
                              "Parameter annotations don't match number of parameters");
678
                }
679
            }
680
        }
681
        return result;
682
    }
New to GrepCode? Check out our FAQ X