src/share/classes/java/lang/reflect/Constructor.java
Print this page
*** 1,7 ****
/*
! * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
--- 1,7 ----
/*
! * Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
*** 25,41 ****
package java.lang.reflect;
import sun.reflect.ConstructorAccessor;
import sun.reflect.Reflection;
import sun.reflect.generics.repository.ConstructorRepository;
import sun.reflect.generics.factory.CoreReflectionFactory;
import sun.reflect.generics.factory.GenericsFactory;
import sun.reflect.generics.scope.ConstructorScope;
import java.lang.annotation.Annotation;
- import java.util.Map;
- import sun.reflect.annotation.AnnotationParser;
import java.lang.annotation.AnnotationFormatError;
import java.lang.reflect.Modifier;
/**
* {@code Constructor} provides information about, and access to, a single
--- 25,40 ----
package java.lang.reflect;
import sun.reflect.ConstructorAccessor;
import sun.reflect.Reflection;
+ import sun.reflect.annotation.AnnotationParser;
import sun.reflect.generics.repository.ConstructorRepository;
import sun.reflect.generics.factory.CoreReflectionFactory;
import sun.reflect.generics.factory.GenericsFactory;
import sun.reflect.generics.scope.ConstructorScope;
import java.lang.annotation.Annotation;
import java.lang.annotation.AnnotationFormatError;
import java.lang.reflect.Modifier;
/**
* {@code Constructor} provides information about, and access to, a single
*** 55,69 ****
* @see java.lang.Class#getDeclaredConstructors()
*
* @author Kenneth Russell
* @author Nakul Saraiya
*/
! public final
! class Constructor<T> extends AccessibleObject implements
! GenericDeclaration,
! Member {
!
private Class<T> clazz;
private int slot;
private Class<?>[] parameterTypes;
private Class<?>[] exceptionTypes;
private int modifiers;
--- 54,64 ----
* @see java.lang.Class#getDeclaredConstructors()
*
* @author Kenneth Russell
* @author Nakul Saraiya
*/
! public final class Constructor<T> extends Executable {
private Class<T> clazz;
private int slot;
private Class<?>[] parameterTypes;
private Class<?>[] exceptionTypes;
private int modifiers;
*** 109,120 ****
Class<?>[] checkedExceptions,
int modifiers,
int slot,
String signature,
byte[] annotations,
! byte[] parameterAnnotations)
! {
this.clazz = declaringClass;
this.parameterTypes = parameterTypes;
this.exceptionTypes = checkedExceptions;
this.modifiers = modifiers;
this.slot = slot;
--- 104,114 ----
Class<?>[] checkedExceptions,
int modifiers,
int slot,
String signature,
byte[] annotations,
! byte[] parameterAnnotations) {
this.clazz = declaringClass;
this.parameterTypes = parameterTypes;
this.exceptionTypes = checkedExceptions;
this.modifiers = modifiers;
this.slot = slot;
*** 147,290 ****
res.constructorAccessor = constructorAccessor;
return res;
}
/**
! * Returns the {@code Class} object representing the class that declares
! * the constructor represented by this {@code Constructor} object.
*/
public Class<T> getDeclaringClass() {
return clazz;
}
/**
* Returns the name of this constructor, as a string. This is
* the binary name of the constructor's declaring class.
*/
public String getName() {
return getDeclaringClass().getName();
}
/**
! * Returns the Java language modifiers for the constructor
! * represented by this {@code Constructor} object, as an integer. The
! * {@code Modifier} class should be used to decode the modifiers.
! *
! * @see Modifier
*/
public int getModifiers() {
return modifiers;
}
/**
! * Returns an array of {@code TypeVariable} objects that represent the
! * type variables declared by the generic declaration represented by this
! * {@code GenericDeclaration} object, in declaration order. Returns an
! * array of length 0 if the underlying generic declaration declares no type
! * variables.
! *
! * @return an array of {@code 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
! * <cite>The Java™ Virtual Machine Specification</cite>
* @since 1.5
*/
public TypeVariable<Constructor<T>>[] getTypeParameters() {
if (getSignature() != null) {
return (TypeVariable<Constructor<T>>[])getGenericInfo().getTypeParameters();
} else
return (TypeVariable<Constructor<T>>[])new TypeVariable[0];
}
/**
! * Returns an array of {@code Class} objects that represent the formal
! * parameter types, in declaration order, of the constructor
! * represented by this {@code Constructor} object. Returns an array of
! * length 0 if the underlying constructor takes no parameters.
! *
! * @return the parameter types for the constructor this object
! * represents
*/
public Class<?>[] getParameterTypes() {
return (Class<?>[]) parameterTypes.clone();
}
-
/**
! * Returns an array of {@code Type} objects that represent the formal
! * parameter types, in declaration order, of the method represented by
! * this {@code Constructor} object. Returns an array of length 0 if the
! * underlying method takes no parameters.
! *
! * <p>If a formal parameter type is a parameterized type,
! * the {@code Type} object returned for it must accurately reflect
! * the actual type parameters used in the source code.
! *
! * <p>If a formal parameter type is a type variable or a parameterized
! * type, it is created. Otherwise, it is resolved.
! *
! * @return an array of {@code Type}s 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
! * <cite>The Java™ Virtual Machine Specification</cite>
! * @throws TypeNotPresentException if any of the parameter
! * types of the underlying method refers to a non-existent type
! * declaration
! * @throws 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
*/
public Type[] getGenericParameterTypes() {
if (getSignature() != null)
return getGenericInfo().getParameterTypes();
else
return getParameterTypes();
}
-
/**
! * Returns an array of {@code Class} objects that represent the types
! * of exceptions declared to be thrown by the underlying constructor
! * represented by this {@code Constructor} object. Returns an array of
! * length 0 if the constructor declares no exceptions in its {@code throws} clause.
! *
! * @return the exception types declared as being thrown by the
! * constructor this object represents
*/
public Class<?>[] getExceptionTypes() {
return (Class<?>[])exceptionTypes.clone();
}
/**
! * Returns an array of {@code Type} objects that represent the
! * exceptions declared to be thrown by this {@code Constructor} object.
! * Returns an array of length 0 if the underlying method declares
! * no exceptions in its {@code throws} clause.
! *
! * <p>If an exception type is a type variable or a parameterized
! * type, it is created. Otherwise, it is resolved.
! *
! * @return 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
! * <cite>The Java™ Virtual Machine Specification</cite>
! * @throws TypeNotPresentException if the underlying method's
! * {@code throws} clause refers to a non-existent type declaration
! * @throws MalformedParameterizedTypeException if
! * the underlying method's {@code throws} clause refers to a
! * parameterized type that cannot be instantiated for any reason
* @since 1.5
*/
public Type[] getGenericExceptionTypes() {
Type[] result;
if (getSignature() != null &&
( (result = getGenericInfo().getExceptionTypes()).length > 0 ))
return result;
--- 141,222 ----
res.constructorAccessor = constructorAccessor;
return res;
}
/**
! * {@inheritDoc}
*/
+ @Override
public Class<T> getDeclaringClass() {
return clazz;
}
/**
* Returns the name of this constructor, as a string. This is
* the binary name of the constructor's declaring class.
*/
+ @Override
public String getName() {
return getDeclaringClass().getName();
}
/**
! * {@inheritDoc}
*/
+ @Override
public int getModifiers() {
return modifiers;
}
/**
! * {@inheritDoc}
* @since 1.5
*/
+ @Override
public TypeVariable<Constructor<T>>[] getTypeParameters() {
if (getSignature() != null) {
return (TypeVariable<Constructor<T>>[])getGenericInfo().getTypeParameters();
} else
return (TypeVariable<Constructor<T>>[])new TypeVariable[0];
}
/**
! * {@inheritDoc}
*/
+ @Override
public Class<?>[] getParameterTypes() {
return (Class<?>[]) parameterTypes.clone();
}
/**
! * {@inheritDoc}
* @since 1.5
*/
+ @Override
public Type[] getGenericParameterTypes() {
if (getSignature() != null)
return getGenericInfo().getParameterTypes();
else
return getParameterTypes();
}
/**
! * {@inheritDoc}
! * @since 1.5
*/
+ @Override
public Class<?>[] getExceptionTypes() {
return (Class<?>[])exceptionTypes.clone();
}
/**
! * {@inheritDoc}
* @since 1.5
*/
+ @Override
public Type[] getGenericExceptionTypes() {
Type[] result;
if (getSignature() != null &&
( (result = getGenericInfo().getExceptionTypes()).length > 0 ))
return result;
*** 300,319 ****
*/
public boolean equals(Object obj) {
if (obj != null && obj instanceof Constructor) {
Constructor<?> other = (Constructor<?>)obj;
if (getDeclaringClass() == other.getDeclaringClass()) {
! /* Avoid unnecessary cloning */
! Class<?>[] params1 = parameterTypes;
! Class<?>[] params2 = other.parameterTypes;
! if (params1.length == params2.length) {
! for (int i = 0; i < params1.length; i++) {
! if (params1[i] != params2[i])
! return false;
! }
! return true;
! }
}
}
return false;
}
--- 232,242 ----
*/
public boolean equals(Object obj) {
if (obj != null && obj instanceof Constructor) {
Constructor<?> other = (Constructor<?>)obj;
if (getDeclaringClass() == other.getDeclaringClass()) {
! return equalParamTypes(parameterTypes, other.parameterTypes);
}
}
return false;
}
*** 341,372 ****
* {@code private}. Only one of these may appear, or none if the
* constructor has default (package) access.
*/
public String toString() {
try {
! StringBuffer sb = new StringBuffer();
int mod = getModifiers() & Modifier.constructorModifiers();
if (mod != 0) {
sb.append(Modifier.toString(mod) + " ");
}
sb.append(Field.getTypeName(getDeclaringClass()));
sb.append("(");
! Class<?>[] params = parameterTypes; // avoid clone
! for (int j = 0; j < params.length; j++) {
! sb.append(Field.getTypeName(params[j]));
! if (j < (params.length - 1))
! sb.append(",");
! }
sb.append(")");
! Class<?>[] exceptions = exceptionTypes; // avoid clone
! if (exceptions.length > 0) {
sb.append(" throws ");
! for (int k = 0; k < exceptions.length; k++) {
! sb.append(exceptions[k].getName());
! if (k < (exceptions.length - 1))
! sb.append(",");
! }
}
return sb.toString();
} catch (Exception e) {
return "<" + e + ">";
}
--- 264,285 ----
* {@code private}. Only one of these may appear, or none if the
* constructor has default (package) access.
*/
public String toString() {
try {
! StringBuilder sb = new StringBuilder();
int mod = getModifiers() & Modifier.constructorModifiers();
if (mod != 0) {
sb.append(Modifier.toString(mod) + " ");
}
sb.append(Field.getTypeName(getDeclaringClass()));
sb.append("(");
! separateWithCommas(parameterTypes, sb);
sb.append(")");
! if (exceptionTypes.length > 0) {
sb.append(" throws ");
! separateWithCommas(exceptionTypes, sb);
}
return sb.toString();
} catch (Exception e) {
return "<" + e + ">";
}
*** 403,412 ****
--- 316,326 ----
* @return a string describing this {@code Constructor},
* include type parameters
*
* @since 1.5
*/
+ @Override
public String toGenericString() {
try {
StringBuilder sb = new StringBuilder();
int mod = getModifiers() & Modifier.constructorModifiers();
if (mod != 0) {
*** 524,556 ****
}
return (T) ca.newInstance(initargs);
}
/**
! * Returns {@code true} if this constructor was declared to take
! * a variable number of arguments; returns {@code false}
! * otherwise.
! *
! * @return {@code true} if an only if this constructor was declared to
! * take a variable number of arguments.
* @since 1.5
*/
public boolean isVarArgs() {
! return (getModifiers() & Modifier.VARARGS) != 0;
}
/**
! * Returns {@code true} if this constructor is a synthetic
! * constructor; returns {@code false} otherwise.
! *
! * @return true if and only if this constructor is a synthetic
! * constructor as defined by
! * <cite>The Java™ Language Specification</cite>.
* @since 1.5
*/
public boolean isSynthetic() {
! return Modifier.isSynthetic(getModifiers());
}
// NOTE that there is no synchronization used here. It is correct
// (though not efficient) to generate more than one
// ConstructorAccessor for a given Constructor. However, avoiding
--- 438,462 ----
}
return (T) ca.newInstance(initargs);
}
/**
! * {@inheritDoc}
* @since 1.5
*/
+ @Override
public boolean isVarArgs() {
! return super.isVarArgs();
}
/**
! * {@inheritDoc}
* @since 1.5
*/
+ @Override
public boolean isSynthetic() {
! return super.isSynthetic();
}
// NOTE that there is no synchronization used here. It is correct
// (though not efficient) to generate more than one
// ConstructorAccessor for a given Constructor. However, avoiding
*** 602,667 ****
byte[] getRawParameterAnnotations() {
return parameterAnnotations;
}
- /**
- * @throws NullPointerException {@inheritDoc}
- * @since 1.5
- */
- public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
- if (annotationClass == null)
- throw new NullPointerException();
-
- return (T) declaredAnnotations().get(annotationClass);
- }
-
- /**
- * @since 1.5
- */
- public Annotation[] getDeclaredAnnotations() {
- return AnnotationParser.toArray(declaredAnnotations());
- }
-
- private transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;
-
- private synchronized Map<Class<? extends Annotation>, Annotation> declaredAnnotations() {
- if (declaredAnnotations == null) {
- declaredAnnotations = AnnotationParser.parseAnnotations(
- annotations, sun.misc.SharedSecrets.getJavaLangAccess().
- getConstantPool(getDeclaringClass()),
- getDeclaringClass());
- }
- return declaredAnnotations;
- }
/**
! * Returns an array of arrays that represent the annotations on the formal
! * parameters, in declaration order, of the method represented by
! * this {@code 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.
! *
! * @return 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
*/
public Annotation[][] getParameterAnnotations() {
int numParameters = parameterTypes.length;
if (parameterAnnotations == null)
return new Annotation[numParameters][0];
! Annotation[][] result = AnnotationParser.parseParameterAnnotations(
! parameterAnnotations,
! sun.misc.SharedSecrets.getJavaLangAccess().
! getConstantPool(getDeclaringClass()),
! getDeclaringClass());
if (result.length != numParameters) {
Class<?> declaringClass = getDeclaringClass();
if (declaringClass.isEnum() ||
declaringClass.isAnonymousClass() ||
declaringClass.isLocalClass() )
--- 508,530 ----
byte[] getRawParameterAnnotations() {
return parameterAnnotations;
}
/**
! * {@inheritDoc}
* @since 1.5
*/
+ @Override
public Annotation[][] getParameterAnnotations() {
int numParameters = parameterTypes.length;
if (parameterAnnotations == null)
return new Annotation[numParameters][0];
! Annotation[][] result = parseParameterAnnotations(parameterAnnotations);
!
if (result.length != numParameters) {
Class<?> declaringClass = getDeclaringClass();
if (declaringClass.isEnum() ||
declaringClass.isAnonymousClass() ||
declaringClass.isLocalClass() )
*** 678,683 ****
--- 541,551 ----
}
}
}
return result;
}
+
+ @Override
+ byte[] getAnnotationBytes() {
+ return annotations;
+ }
}