1 /* 2 * Copyright (c) 2003, 2019, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package java.lang.reflect; 27 28 /** 29 * TypeVariable is the common superinterface for type variables of kinds. 30 * A type variable is created the first time it is needed by a reflective 31 * method, as specified in this package. If a type variable t is referenced 32 * by a type (i.e, class, interface or annotation type) T, and T is declared 33 * by the nth enclosing class of T (see JLS 8.1.2), then the creation of t 34 * requires the resolution (see JVMS 5) of the ith enclosing class of T, 35 * for i = 0 to n, inclusive. Creating a type variable must not cause the 36 * creation of its bounds. Repeated creation of a type variable has no effect. 37 * 38 * <p>Multiple objects may be instantiated at run-time to 39 * represent a given type variable. Even though a type variable is 40 * created only once, this does not imply any requirement to cache 41 * instances representing the type variable. However, all instances 42 * representing a type variable must be equal() to each other. 43 * As a consequence, users of type variables must not rely on the identity 44 * of instances of classes implementing this interface. 45 * 46 * @param <D> the type of generic declaration that declared the 47 * underlying type variable. 48 * 49 * @since 1.5 50 */ 51 public interface TypeVariable<D extends GenericDeclaration> extends Type, AnnotatedElement { 52 /** 53 * Returns an array of {@code Type} objects representing the 54 * upper bound(s) of this type variable. If no upper bound is 55 * explicitly declared, the upper bound is {@code Object}. 56 * 57 * <p>For each upper bound B: <ul> <li>if B is a parameterized 58 * type or a type variable, it is created, (see {@link 59 * java.lang.reflect.ParameterizedType ParameterizedType} for the 60 * details of the creation process for parameterized types). 61 * <li>Otherwise, B is resolved. </ul> 62 * 63 * @throws TypeNotPresentException if any of the 64 * bounds refers to a non-existent type declaration 65 * @throws MalformedParameterizedTypeException if any of the 66 * bounds refer to a parameterized type that cannot be instantiated 67 * for any reason 68 * @return an array of {@code Type}s representing the upper 69 * bound(s) of this type variable 70 */ 71 Type[] getBounds(); 72 73 /** 74 * Returns the {@code GenericDeclaration} object representing the 75 * generic declaration declared for this type variable. 76 * 77 * @return the generic declaration declared for this type variable. 78 * 79 * @since 1.5 80 */ 81 D getGenericDeclaration(); 82 83 /** 84 * Returns the name of this type variable, as it occurs in the source code. 85 * 86 * @return the name of this type variable, as it appears in the source code 87 */ 88 String getName(); 89 90 /** 91 * Returns an array of AnnotatedType objects that represent the use of 92 * types to denote the upper bounds of the type parameter represented by 93 * this TypeVariable. The order of the objects in the array corresponds to 94 * the order of the bounds in the declaration of the type parameter. Note that 95 * if no upper bound is explicitly declared, the upper bound is unannotated 96 * {@code Object}. 97 * 98 * @return an array of objects representing the upper bound(s) of the type variable 99 * @since 1.8 100 */ 101 AnnotatedType[] getAnnotatedBounds(); 102 }