Genéricos de Java: directrices para el uso de comodines
Los comodines se pueden utilizar de tres formas:
- Upper bound Wildcard-? extiende Tipo. 
- Lower bound Wildcard-? super Type. 
- Unbounded Wildcard -? 
Para decidir qué tipo de comodín se adapta mejor a la condición, primero clasifiquemos el tipo de parámetros pasados a un método como in y out parámetro.
- in variable- Una variable in proporciona datos al código. Por ejemplo, copy (src, dest). Aquí src actúa como una variable que es un dato a copiar. 
- out variable- Una variable de salida contiene datos actualizados por el código. Por ejemplo, copy (src, dest). Aquí, dest actúa como una variable que ha copiado datos. 
Directrices para comodines.
- Upper bound wildcard - Si una variable es de in categoría, use la palabra clave extiende con comodín. 
- Lower bound wildcard - Si una variable es de out categoría, use super palabra clave con comodín. 
- Unbounded wildcard - Si se puede acceder a una variable mediante el método de clase de objeto, utilice un comodín independiente. 
- No wildcard - Si el código está accediendo a la variable en ambos in y out categoría, entonces no utilice comodines. 
Ejemplo
El siguiente ejemplo ilustra los conceptos mencionados anteriormente.
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
public class GenericsTester {
   //Upper bound wildcard
   //in category
   public static void deleteCat(List<? extends Cat> catList, Cat cat) {
      catList.remove(cat);
      System.out.println("Cat Removed");
   }
   //Lower bound wildcard
   //out category
   public static void addCat(List<? super RedCat> catList) {
      catList.add(new RedCat("Red Cat"));
      System.out.println("Cat Added");
   }
   //Unbounded wildcard
   //Using Object method toString()
   public static void printAll(List<?> list) {
      for (Object item : list)
         System.out.println(item + " ");
   }
   public static void main(String[] args) {
      List<Animal> animalList= new ArrayList<Animal>();
      List<RedCat> redCatList= new ArrayList<RedCat>();
      //add list of super class Animal of Cat class
      addCat(animalList);
      //add list of Cat class
      addCat(redCatList);  
      addCat(redCatList);  
      //print all animals
      printAll(animalList);
      printAll(redCatList);
      Cat cat = redCatList.get(0);
      //delete cat
      deleteCat(redCatList, cat);
      printAll(redCatList); 
   }
}
class Animal {
   String name;
   Animal(String name) { 
      this.name = name;
   }
   public String toString() { 
      return name;
   }
}
class Cat extends Animal { 
   Cat(String name) {
      super(name);
   }
}
class RedCat extends Cat {
   RedCat(String name) {
      super(name);
   }
}
class Dog extends Animal {
   Dog(String name) {
      super(name);
   }
}Esto producirá el siguiente resultado:
Cat Added
Cat Added
Cat Added
Red Cat 
Red Cat 
Red Cat 
Cat Removed
Red Cat