Package org.apache.commons.lang3.reflect

# Class TypeLiteral<T>

java.lang.Object
org.apache.commons.lang3.reflect.TypeLiteral<T>

Type Parameters:
  `T` - the type

All Implemented Interfaces:
  `Typed<T>`

public abstract class TypeLiteral<T> extends Object implements Typed<T>
Type literal comparable to `javax.enterprise.util.TypeLiteral`, made generally available outside the JEE context. Allows the passing around of a "token" that represents a type in a typesafe manner, as opposed to passing the (non-parameterized) `Type` object itself. Consider:

You might see such a typesafe API as:

     class Typesafe {
       <T> T obtain(Class<T> type, ...);
     }

Consumed in the manner of:

     Foo foo = typesafe.obtain(Foo.class, ...);

Yet, you run into problems when you want to do this with a parameterized type:

     List<String> listOfString = typesafe.obtain(List.class, ...); // could only give us a raw List

`java.lang.reflect.Type` might provide some value:

     Type listOfStringType = ...; // firstly, how to obtain this? Doable, but not straightforward.
     List<String> listOfString = (List<String>) typesafe.obtain(listOfStringType, ...); // nongeneric Type would necessitate a cast

The "type literal" concept was introduced to provide an alternative, i.e.:

     class Typesafe {
       <T> T obtain(TypeLiteral<T> type, ...);
     }

Consuming code looks like:

     List<String> listOfString = typesafe.obtain(new TypeLiteral<List<String>>() {}, ...);

This has the effect of "jumping up" a level to tie a `java.lang.reflect.Type` to a type variable while simultaneously making it short work to obtain a `Type` instance for any given type, inline.

Additionally `TypeLiteral` implements the `Typed` interface which is a generalization of this concept, and which may be implemented in custom classes. It is suggested that APIs be defined in terms of the interface, in the following manner:

       <T> T obtain(Typed<T> typed, ...);

Since:
  3.2

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `final Type`
  `value`
  Represented type.

- ## Constructor Summary

  Constructors
  Modifier
  Constructor
  Description
  `protected`
  `TypeLiteral()`
  The default constructor.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `final boolean`
  `equals(Object obj)`
  `Type`
  `getType()`
  Gets the `Type` represented by this entity.
  `int`
  `hashCode()`
  `String`
  `toString()`

  ### Methods inherited from class java.lang.Object

  `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- ## Field Details

  - ### value

    public final Type value
    Represented type.

- ## Constructor Details

  - ### TypeLiteral

    protected TypeLiteral()
    The default constructor.

- ## Method Details

  - ### equals

    public final boolean equals(Object obj)
    Overrides:
      `equals` in class `Object`

  - ### getType

    public Type getType()
    Description copied from interface: `Typed`
    Gets the `Type` represented by this entity.
    Specified by:
      `getType` in interface `Typed<T>`
    Returns:
      Type

  - ### hashCode

    public int hashCode()
    Overrides:
      `hashCode` in class `Object`

  - ### toString

    public String toString()
    Overrides:
      `toString` in class `Object`