public class UnaClaseCualquiera<String> {
}

public class UnaClaseCualquiera <String> {
}

public class Caja<T> {

  private T t;

  public T get() { return t; }
  public void set(T t) { this.t = t; }
}


public interface Par<K, V> {
  public K getKey();
  public V getValue();
}


public class ParOrdenado<K, V> implements Par<K, V> {

  private K key;
  private V value;

  public ParOrdenado(K key, V value) {
    this.key = key;
    this.value = value;
  }

  public K getKey() { return key; }
  public V getValue() { return value; }
}

Caja<Integer> integerBox1 = new Caja<Integer>();
Caja<Integer> integerBox2 = new Caja<>();
ParOrdenado<String, Integer> p1 = new ParOrdenado <>("UnPar", 22);

Caja rawCaja = new Caja();

public static <K, V> boolean comparar(Par<K, V> p1, Par<K, V> p2) {
  return p1.getKey().equals(p2.getKey()) && p1.getValue().equals(p2.getValue());
}

Par<Integer, String> p1 = new ParOrdenado <>(1, "apple");
Par<Integer, String> p2 = new ParOrdenado <>(2, "pear");
boolean igual = Util.<Integer, String>comparar(p1, p2);

boolean igual = Util.comparar(p1, p2);

public class CajaBounds<T> {

  private T t;

  public void set(T t) {
    this.t = t;
  }

  public T get() {
    return t;
  }

  public <U extends Number> void inspect(U u){
    System.out.println("T: " + t.getClass().getName());
    System.out.println("U: " + u.getClass().getName());
  }

  public static void main(String[] args) {
    Caja<Integer> integerCaja = new Caja<Integer>();
    integerCaja.set(new Integer(10));
    integerCaja.inspect("some text"); // error: this is still String!
  }
}

<T extends B1 & B2 & B3>

Class A { /* ... */ }
interface B { /* ... */ }
interface C { /* ... */ }

class D <T extends A & B & C> { /* ... */ }

Object object = new Object();
Integer integer = new Integer(10);
object = integer;

interface PayloadList<E,P> extends List<E> {
  void setPayload(int index, P val);
  ...
}

PayloadList<String,String>
PayloadList<String,Integer>
PayloadList<String,Exception>

public static void process(List<? extends Number> list) { /* ... */ }

List<? extends Integer> intList = new ArrayList<>();
List<? extends Number>  numList = intList;

// TypeErasure to Object
public class Node<T> {

  private T data;
  private Node<T> next;

  public Node(T data, Node<T> next) }
    this.data = data;
    this.next = next;
  }

  public T getData() { return data; }
  // ...
}

// Node type erased
public class Node {

  private Object data;
  private Node next;

  public Node(Object data, Node next) {
    this.data = data;
    this.next = next;
  }

  public Object getData() { return data; }
  // ...
}

// TypeErasure to Comparable
public class Node<T extends Comparable<T>> {

  private T data;
  private Node<T> next;

  public Node(T data, Node<T> next) {
    this.data = data;
    this.next = next;
  }

  public T getData() { return data; }
  // ...
}

// Node type erased
public class Node {

  private Comparable data;
  private Node next;

  public Node(Comparable data, Node next) {
    this.data = data;
    this.next = next;
  }

  public Comparable getData() { return data; }
  // ...
}

List<String> lista = new ArrayList<String>();

List<String> lista = new ArrayList<>();

List<Integer> listaEnteros = new ArrayList<>();
List<Persona> listaPersonas = new ArrayList<>();

E: elemento de una colección.
K: clave.
N: número.
T: tipo.
V: valor.
S, U, V etc: para segundos, terceros y cuartos tipos.

Comprobación de tipos más fuerte en tiempo de compilación.
Eliminación de casts aumentando la legibilidad del código.
Posibilidad de implementar algoritmos genéricos, con tipado seguro.

public void create(Persona persona) {
                getEntityManager().persist(persona );
            }

            public void edit(Persona persona) {
                getEntityManager().merge(persona);
            }

public void create(Animales animales) {
                getEntityManager().persist(animales);
            }

            public void edit(Animales animales) {
                getEntityManager().merge(animales);
            }

public abstract class AbstractFacade<T> {

protected abstract EntityManager getEntityManager();

public void create(T entity) {
        getEntityManager().persist(entity);
    }

    public void edit(T entity) {
        getEntityManager().merge(entity);
    }

}