java.lang.Object
- com.github.javaparser.resolution.types.ResolvedReferenceType

All Implemented Interfaces:

ResolvedTypeParameterValueProvider, ResolvedTypeParametrized, ResolvedType

Direct Known Subclasses:

ReferenceTypeImpl
```
public abstract class ResolvedReferenceType
extends Object
implements ResolvedType, ResolvedTypeParametrized, ResolvedTypeParameterValueProvider
```
A ReferenceType like a class, an interface or an enum. Note that this type can contain also the values specified for the type parameters.

Author:

Federico Tomassetti

Field Summary

Fields
Modifier and Type	Field	Description
`protected static String`	`JAVA_LANG_ENUM`
`protected static String`	`JAVA_LANG_OBJECT`
`protected static String`	`JAVA_LANG_RECORD`
`protected ResolvedReferenceTypeDeclaration`	`typeDeclaration`
`protected ResolvedTypeParametersMap`	`typeParametersMap`

Constructor Summary

Constructors
Constructor	Description
`ResolvedReferenceType(ResolvedReferenceTypeDeclaration typeDeclaration)`
`ResolvedReferenceType(ResolvedReferenceTypeDeclaration typeDeclaration, List<ResolvedType> typeArguments)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`ResolvedReferenceType`	`asReferenceType()`
`protected boolean`	`compareConsideringTypeParameters(ResolvedReferenceType other)`
`protected abstract ResolvedReferenceType`	`create(ResolvedReferenceTypeDeclaration typeDeclaration)`
`protected ResolvedReferenceType`	`create(ResolvedReferenceTypeDeclaration typeDeclaration, ResolvedTypeParametersMap typeParametersMap)`
`protected abstract ResolvedReferenceType`	`create(ResolvedReferenceTypeDeclaration typeDeclaration, List<ResolvedType> typeParameters)`
`abstract ResolvedReferenceType`	`deriveTypeParameters(ResolvedTypeParametersMap typeParametersMap)`
`String`	`describe()`
`boolean`	`equals(Object o)`
`ResolvedType`	`erasure()`
`abstract List<ResolvedReferenceType>`	`getAllAncestors()`	Return all ancestors, that means all superclasses and interfaces.
`abstract List<ResolvedReferenceType>`	`getAllAncestors(Function<ResolvedReferenceTypeDeclaration,List<ResolvedReferenceType>> traverser)`	Return all ancestors, that means all superclasses and interfaces.
`List<ResolvedReferenceType>`	`getAllClassesAncestors()`
`List<ResolvedFieldDeclaration>`	`getAllFieldsVisibleToInheritors()`	Fields which are visible to inheritors.
`List<ResolvedReferenceType>`	`getAllInterfacesAncestors()`
`List<ResolvedMethodDeclaration>`	`getAllMethods()`	Get a list of all the methods available on this type.
`List<ResolvedMethodDeclaration>`	`getAllMethodsVisibleToInheritors()`
`abstract Set<ResolvedFieldDeclaration>`	`getDeclaredFields()`	Fields declared on this type.
`abstract Set<MethodUsage>`	`getDeclaredMethods()`	Methods declared on this type.
`abstract List<ResolvedReferenceType>`	`getDirectAncestors()`	Return direct ancestors, that means the superclasses and interfaces implemented directly.
`Optional<ResolvedType>`	`getFieldType(String name)`	The type of the field could be different from the one in the corresponding FieldDeclaration because type variables would be solved.
`Optional<ResolvedType>`	`getGenericParameterByName(String name)`	Get the type associated with the type parameter with the given name.
`String`	`getId()`	Id of the declaration.
`String`	`getQualifiedName()`	Qualified name of the declaration.
`Optional<ResolvedReferenceTypeDeclaration>`	`getTypeDeclaration()`	Corresponding TypeDeclaration
`List<Pair<ResolvedTypeParameterDeclaration,ResolvedType>>`	`getTypeParametersMap()`	Get the values for all type parameters declared on this type.
`int`	`hashCode()`
`boolean`	`hasName()`	Has the TypeDeclaration a name?
`abstract boolean`	`isAssignableBy(ResolvedType other)`	This method checks if ThisType t = new OtherType() would compile.
`protected boolean`	`isCorrespondingBoxingType(String typeName)`
`boolean`	`isJavaLangEnum()`
`boolean`	`isJavaLangObject()`	We don't make this _ex_plicit in the data representation because that would affect codegen and make everything generate like `<T extends Object>` instead of `<T>`
`boolean`	`isJavaLangRecord()`
`boolean`	`isRawType()`
`boolean`	`isReferenceType()`	Can this be seen as a ReferenceTypeUsage?
`boolean`	`isUnboxable()`
`boolean`	`isUnboxableTo(ResolvedPrimitiveType primitiveType)`
`ResolvedType`	`replaceTypeVariables(ResolvedTypeParameterDeclaration tpToReplace, ResolvedType replaced, Map<ResolvedTypeParameterDeclaration,ResolvedType> inferredTypes)`	Replace all variables referring to the given TypeParameter with the given value.
`String`	`toDescriptor()`
`abstract ResolvedType`	`toRawType()`
`String`	`toString()`
`Optional<ResolvedPrimitiveType>`	`toUnboxedType()`
`abstract ResolvedType`	`transformTypeParameters(ResolvedTypeTransformer transformer)`	Execute a transformation on all the type parameters of this element.
`ResolvedTypeParametersMap`	`typeParametersMap()`
`List<ResolvedType>`	`typeParametersValues()`	Get the values for all type parameters declared on this type.
`Optional<ResolvedType>`	`typeParamValue(ResolvedTypeParameterDeclaration typeParameterDeclaration)`	Calculate the value for the given type parameter.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.github.javaparser.resolution.types.ResolvedType
arrayLevel, asArrayType, asConstraintType, asPrimitive, asTypeParameter, asTypeVariable, asUnionType, asWildcard, isArray, isConstraint, isInferenceVariable, isNull, isNumericType, isPrimitive, isReference, isTypeVariable, isUnionType, isVoid, isWildcard, mention, replaceTypeVariables, solveGenericTypes

Methods inherited from interface com.github.javaparser.resolution.types.parametrization.ResolvedTypeParameterValueProvider
useThisTypeParametersOnTheGivenType

- Field Detail
  - JAVA_LANG_ENUM
```
protected static String JAVA_LANG_ENUM
```
  - JAVA_LANG_OBJECT
```
protected static String JAVA_LANG_OBJECT
```
  - JAVA_LANG_RECORD
```
protected static String JAVA_LANG_RECORD
```
  - typeDeclaration
```
protected ResolvedReferenceTypeDeclaration typeDeclaration
```
  - typeParametersMap
```
protected ResolvedTypeParametersMap typeParametersMap
```
- Constructor Detail
  - ResolvedReferenceType
```
public ResolvedReferenceType(ResolvedReferenceTypeDeclaration typeDeclaration)
```
  - ResolvedReferenceType
```
public ResolvedReferenceType(ResolvedReferenceTypeDeclaration typeDeclaration,
                             List<ResolvedType> typeArguments)
```
- Method Detail
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - isReferenceType
```
public final boolean isReferenceType()
```
    Description copied from interface: ResolvedType
    
    Can this be seen as a ReferenceTypeUsage? In other words: is this a reference to a class, an interface or an enum?
    
    Specified by:
    
    isReferenceType in interface ResolvedType
  - asReferenceType
```
public ResolvedReferenceType asReferenceType()
```
    Specified by:
    
    asReferenceType in interface ResolvedType
  - describe
```
public String describe()
```
    Specified by:
    
    describe in interface ResolvedType
  - transformTypeParameters
```
public abstract ResolvedType transformTypeParameters(ResolvedTypeTransformer transformer)
```
    Execute a transformation on all the type parameters of this element.
  - replaceTypeVariables
```
public ResolvedType replaceTypeVariables(ResolvedTypeParameterDeclaration tpToReplace,
                                         ResolvedType replaced,
                                         Map<ResolvedTypeParameterDeclaration,ResolvedType> inferredTypes)
```
    Description copied from interface: ResolvedType
    
    Replace all variables referring to the given TypeParameter with the given value. By replacing these values I could also infer some type equivalence. Those would be collected in the given map.
    
    Specified by:
    
    replaceTypeVariables in interface ResolvedType
  - isAssignableBy
```
public abstract boolean isAssignableBy(ResolvedType other)
```
    This method checks if ThisType t = new OtherType() would compile.
    
    Specified by:
    
    isAssignableBy in interface ResolvedType
  - getAllAncestors
```
public abstract List<ResolvedReferenceType> getAllAncestors()
```
    Return all ancestors, that means all superclasses and interfaces. This list should always include Object (unless this is a reference to Object). The type typeParametersValues should be expressed in terms of this type typeParametersValues. The default order of presenting ancestors corresponds to a search in depth.
    For example, given:
    class Foo<A, B> {} class Bar<C> extends Foo<C, String> {}
    a call to getAllAncestors on a reference to Bar having type parameter Boolean should include Foo<Boolean, String>.
  - getAllAncestors
```
public abstract List<ResolvedReferenceType> getAllAncestors(Function<ResolvedReferenceTypeDeclaration,List<ResolvedReferenceType>> traverser)
```
    Return all ancestors, that means all superclasses and interfaces. This list should always include Object (unless this is a reference to Object). The type typeParametersValues should be expressed in terms of this type typeParametersValues.
  - getDirectAncestors
```
public abstract List<ResolvedReferenceType> getDirectAncestors()
```
    Return direct ancestors, that means the superclasses and interfaces implemented directly. This list should include Object if the class has no other superclass or the interface is not extending another interface. There is an exception for Object itself.
  - getAllInterfacesAncestors
```
public final List<ResolvedReferenceType> getAllInterfacesAncestors()
```
  - getAllClassesAncestors
```
public final List<ResolvedReferenceType> getAllClassesAncestors()
```
  - getGenericParameterByName
```
public Optional<ResolvedType> getGenericParameterByName(String name)
```
    Get the type associated with the type parameter with the given name. It returns Optional.empty unless the type declaration declares a type parameter with the given name.
    
    Specified by:
    
    getGenericParameterByName in interface ResolvedTypeParameterValueProvider
  - typeParametersValues
```
public List<ResolvedType> typeParametersValues()
```
    Get the values for all type parameters declared on this type. The list can be empty for raw types.
  - getTypeParametersMap
```
public List<Pair<ResolvedTypeParameterDeclaration,ResolvedType>> getTypeParametersMap()
```
    Get the values for all type parameters declared on this type. In case of raw types the values correspond to TypeVariables.
  - typeParametersMap
```
public ResolvedTypeParametersMap typeParametersMap()
```
    Specified by:
    
    typeParametersMap in interface ResolvedTypeParametrized
  - getTypeDeclaration
```
public final Optional<ResolvedReferenceTypeDeclaration> getTypeDeclaration()
```
    Corresponding TypeDeclaration
  - getFieldType
```
public Optional<ResolvedType> getFieldType(String name)
```
    The type of the field could be different from the one in the corresponding FieldDeclaration because type variables would be solved.
  - hasName
```
public boolean hasName()
```
    Has the TypeDeclaration a name? Anonymous classes do not have one.
  - getQualifiedName
```
public String getQualifiedName()
```
    Qualified name of the declaration.
  - getId
```
public String getId()
```
    Id of the declaration. It corresponds to the qualified name, unless for local classes.
  - getDeclaredMethods
```
public abstract Set<MethodUsage> getDeclaredMethods()
```
    Methods declared on this type.
  - getDeclaredFields
```
public abstract Set<ResolvedFieldDeclaration> getDeclaredFields()
```
    Fields declared on this type.
  - isRawType
```
public boolean isRawType()
```
  - typeParamValue
```
public Optional<ResolvedType> typeParamValue(ResolvedTypeParameterDeclaration typeParameterDeclaration)
```
    Description copied from interface: ResolvedTypeParameterValueProvider
    
    Calculate the value for the given type parameter. It could be inherited.
    
    Specified by:
    
    typeParamValue in interface ResolvedTypeParameterValueProvider
  - toRawType
```
public abstract ResolvedType toRawType()
```
    Returns:
    
    A copy of the current reference type, without type parameters.
  - getAllMethods
```
public List<ResolvedMethodDeclaration> getAllMethods()
```
    Get a list of all the methods available on this type. This list includes methods declared in this type and methods inherited. This list includes methods of all sort of visibility. However it does not include methods that have been overwritten.
  - getAllFieldsVisibleToInheritors
```
public List<ResolvedFieldDeclaration> getAllFieldsVisibleToInheritors()
```
    Fields which are visible to inheritors. They include all inherited fields which are visible to this type plus all declared fields which are not private.
  - getAllMethodsVisibleToInheritors
```
public List<ResolvedMethodDeclaration> getAllMethodsVisibleToInheritors()
```
  - create
```
protected abstract ResolvedReferenceType create(ResolvedReferenceTypeDeclaration typeDeclaration,
                                                List<ResolvedType> typeParameters)
```
  - create
```
protected ResolvedReferenceType create(ResolvedReferenceTypeDeclaration typeDeclaration,
                                       ResolvedTypeParametersMap typeParametersMap)
```
  - create
```
protected abstract ResolvedReferenceType create(ResolvedReferenceTypeDeclaration typeDeclaration)
```
  - isCorrespondingBoxingType
```
protected boolean isCorrespondingBoxingType(String typeName)
```
  - compareConsideringTypeParameters
```
protected boolean compareConsideringTypeParameters(ResolvedReferenceType other)
```
  - deriveTypeParameters
```
public abstract ResolvedReferenceType deriveTypeParameters(ResolvedTypeParametersMap typeParametersMap)
```
  - isJavaLangObject
```
public boolean isJavaLangObject()
```
    We don't make this _ex_plicit in the data representation because that would affect codegen and make everything generate like <T extends Object> instead of <T>
    
    Returns:
    
    true, if this represents java.lang.Object
    
    See Also:
    
    ResolvedReferenceTypeDeclaration.isJavaLangObject(), https://github.com/javaparser/javaparser/issues/2044
  - isJavaLangEnum
```
public boolean isJavaLangEnum()
```
    Returns:
    
    true, if this represents java.lang.Enum
    
    See Also:
    
    ResolvedReferenceTypeDeclaration.isJavaLangEnum()
  - isJavaLangRecord
```
public boolean isJavaLangRecord()
```
    Returns:
    
    true, if this represents java.lang.Record
    
    See Also:
    
    ResolvedReferenceTypeDeclaration.isJavaLangRecord()
  - isUnboxable
```
public boolean isUnboxable()
```
  - isUnboxableTo
```
public boolean isUnboxableTo(ResolvedPrimitiveType primitiveType)
```
  - toUnboxedType
```
public Optional<ResolvedPrimitiveType> toUnboxedType()
```
  - erasure
```
public ResolvedType erasure()
```
    Specified by:
    
    erasure in interface ResolvedType
  - toDescriptor
```
public String toDescriptor()
```
    Specified by:
    
    toDescriptor in interface ResolvedType

Class ResolvedReferenceType

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.github.javaparser.resolution.types.ResolvedType

Methods inherited from interface com.github.javaparser.resolution.types.parametrization.ResolvedTypeParameterValueProvider

Field Detail

JAVA_LANG_ENUM

JAVA_LANG_OBJECT

JAVA_LANG_RECORD

typeDeclaration

typeParametersMap

Constructor Detail

ResolvedReferenceType

ResolvedReferenceType

Method Detail

equals

hashCode

toString

isReferenceType

asReferenceType

describe

transformTypeParameters

replaceTypeVariables

isAssignableBy

getAllAncestors

getAllAncestors

getDirectAncestors

getAllInterfacesAncestors

getAllClassesAncestors

getGenericParameterByName

typeParametersValues

getTypeParametersMap

typeParametersMap

getTypeDeclaration

getFieldType

hasName

getQualifiedName

getId

getDeclaredMethods

getDeclaredFields

isRawType

typeParamValue

toRawType

getAllMethods

getAllFieldsVisibleToInheritors

getAllMethodsVisibleToInheritors

create

create

create

isCorrespondingBoxingType

compareConsideringTypeParameters

deriveTypeParameters

isJavaLangObject

isJavaLangEnum

isJavaLangRecord

isUnboxable

isUnboxableTo

toUnboxedType

erasure

toDescriptor