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;
*** 80,90 **** // create scope and factory return CoreReflectionFactory.make(this, ConstructorScope.make(this)); } // Accessor for generic info repository ! private ConstructorRepository getGenericInfo() { // lazily initialize repository if necessary if (genericInfo == null) { // create and cache generic info repository genericInfo = ConstructorRepository.make(getSignature(), --- 75,86 ---- // create scope and factory return CoreReflectionFactory.make(this, ConstructorScope.make(this)); } // Accessor for generic info repository ! @Override ! ConstructorRepository getGenericInfo() { // lazily initialize repository if necessary if (genericInfo == null) { // create and cache generic info repository genericInfo = ConstructorRepository.make(getSignature(),
*** 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; --- 105,115 ---- 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;
*** 146,297 **** // Might as well eagerly propagate this if already present 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&trade; 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&trade; 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&trade; 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; ! else ! return getExceptionTypes(); } /** * Compares this {@code Constructor} against the specified object. * Returns true if the objects are the same. Two {@code Constructor} objects are --- 141,232 ---- // Might as well eagerly propagate this if already present res.constructorAccessor = constructorAccessor; return res; } + @Override + boolean hasGenericInformation() { + return (getSignature() != null); + } + + @Override + byte[] getAnnotationBytes() { + return annotations; + } + /** ! * {@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() { ! return super.getGenericParameterTypes(); } /** ! * {@inheritDoc} ! * @since 1.5 */ + @Override public Class<?>[] getExceptionTypes() { return (Class<?>[])exceptionTypes.clone(); } /** ! * {@inheritDoc} * @since 1.5 */ + @Override public Type[] getGenericExceptionTypes() { ! return super.getGenericExceptionTypes(); } /** * Compares this {@code Constructor} against the specified object. * Returns true if the objects are the same. Two {@code Constructor} objects are
*** 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; } --- 235,245 ---- */ 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; }
*** 340,377 **** * modifiers {@code public}, {@code protected} or * {@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 + ">"; - } } /** * Returns a string describing this {@code Constructor}, * including type parameters. The string is formatted as the --- 266,283 ---- * modifiers {@code public}, {@code protected} or * {@code private}. Only one of these may appear, or none if the * constructor has default (package) access. */ public String toString() { ! return sharedToString(Modifier.constructorModifiers(), ! parameterTypes, ! exceptionTypes); } + + @Override + void specificToStringHeader(StringBuilder sb) { sb.append(Field.getTypeName(getDeclaringClass())); } /** * Returns a string describing this {@code Constructor}, * including type parameters. The string is formatted as the
*** 403,462 **** * @return a string describing this {@code Constructor}, * include type parameters * * @since 1.5 */ public String toGenericString() { ! try { ! StringBuilder sb = new StringBuilder(); ! int mod = getModifiers() & Modifier.constructorModifiers(); ! if (mod != 0) { ! sb.append(Modifier.toString(mod) + " "); ! } ! TypeVariable<?>[] typeparms = getTypeParameters(); ! if (typeparms.length > 0) { ! boolean first = true; ! sb.append("<"); ! for(TypeVariable<?> typeparm: typeparms) { ! if (!first) ! sb.append(","); ! // Class objects can't occur here; no need to test ! // and call Class.getName(). ! sb.append(typeparm.toString()); ! first = false; ! } ! sb.append("> "); ! } ! sb.append(Field.getTypeName(getDeclaringClass())); ! sb.append("("); ! Type[] params = getGenericParameterTypes(); ! for (int j = 0; j < params.length; j++) { ! String param = (params[j] instanceof Class<?>)? ! Field.getTypeName((Class<?>)params[j]): ! (params[j].toString()); ! if (isVarArgs() && (j == params.length - 1)) // replace T[] with T... ! param = param.replaceFirst("\\[\\]$", "..."); ! sb.append(param); ! if (j < (params.length - 1)) ! sb.append(","); ! } ! sb.append(")"); ! Type[] exceptions = getGenericExceptionTypes(); ! if (exceptions.length > 0) { ! sb.append(" throws "); ! for (int k = 0; k < exceptions.length; k++) { ! sb.append((exceptions[k] instanceof Class)? ! ((Class<?>)exceptions[k]).getName(): ! exceptions[k].toString()); ! if (k < (exceptions.length - 1)) ! sb.append(","); ! } ! } ! return sb.toString(); ! } catch (Exception e) { ! return "<" + e + ">"; } } /** * Uses the constructor represented by this {@code Constructor} object to * create and initialize a new instance of the constructor's --- 309,326 ---- * @return a string describing this {@code Constructor}, * include type parameters * * @since 1.5 */ + @Override public String toGenericString() { ! return sharedToGenericString(Modifier.constructorModifiers()); } + + @Override + void specificToGenericStringHeader(StringBuilder sb) { + specificToStringHeader(sb); } /** * Uses the constructor represented by this {@code Constructor} object to * create and initialize a new instance of the constructor's
*** 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&trade; 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 --- 388,412 ---- } 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,683 **** 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() ) ! ; // Can't do reliable parameter counting else { if (!declaringClass.isMemberClass() || // top-level // Check for the enclosing instance parameter for // non-static member classes (declaringClass.isMemberClass() && ((declaringClass.getModifiers() & Modifier.STATIC) == 0) && ! result.length + 1 != numParameters) ) { throw new AnnotationFormatError( "Parameter annotations don't match number of parameters"); } } } - return result; - } } --- 458,492 ---- byte[] getRawParameterAnnotations() { return parameterAnnotations; } /** + * {@inheritDoc} * @since 1.5 */ ! @Override ! public Annotation[][] getParameterAnnotations() { ! return sharedGetParameterAnnotations(parameterTypes, parameterAnnotations); } ! @Override ! void handleParameterNumberMismatch(int resultLength, int numParameters) { Class<?> declaringClass = getDeclaringClass(); if (declaringClass.isEnum() || declaringClass.isAnonymousClass() || declaringClass.isLocalClass() ) ! return ; // Can't do reliable parameter counting else { if (!declaringClass.isMemberClass() || // top-level // Check for the enclosing instance parameter for // non-static member classes (declaringClass.isMemberClass() && ((declaringClass.getModifiers() & Modifier.STATIC) == 0) && ! resultLength + 1 != numParameters) ) { throw new AnnotationFormatError( "Parameter annotations don't match number of parameters"); } } } }