Método creado con la firma como List

Question

Soy muy nuevo en el lenguaje de programación Java así que esta es probablemente una pregunta tonta, pero tengo que preguntarlo porque no puedo resolverlo por mi cuenta. Aquí está el trato.

Quiero crear un método que extraiga cierto tipo de objeto de una lista. Por lo tanto, el método debe recibir List como argumento, lo que significa que la lista debe contener Object1 u Object2. He tratado de esta manera:

public Object1 extractObject(List<Object>){ 
    //some pseudo-code 
    ... loop trough list and check if list item is instance of object one return that instance 
    } 

El problema con el método de declarar con List<?> como argumento de un método es que recibo error de compilación de Eclipse Syntax error on token ">", VariableDeclaratorId expected after this token.

¿Cómo configuro correctamente la firma del método para aceptar tipos de objetos, ya sea Object1 u Object2? Gracias

Este es mi Código:

protected Object1 getObject1(List<Object> list){ 
     for(Object obj : list) { 
      if(obj instanceof Object1) { 
       return (Object1) obj; 
      } 
     } 
     return null; 
    } 

Editar - ¿cuál es la diferencia entre estos 2:

public Object1 getObject1(List<Object> list){ 
     for(Object obj : list) { 
      if(obj instanceof Object1) { 
       return (Object1) obj; 
      } 
     } 
     return null; 
    } 

public Object1 extractObject(List<Object> list, Class<Object1> type) { 
    for(Object obj : list) { 
     if(type.isInstance(obj)) { 
      return (Object1)obj; 
     } 
    } 
    return null; // no match found 
} 

Answer 1

public Object1 extractObject(List<?> list){ 
    //some pseudo-code 
    ... loop trough list and check if list item is instance of object one return that instance 
    return null; 
} 

Usted necesita una variable para la instancia

Y un regreso.

Answer 2

Haría algo como esto - nota, mi sintaxis podría estar equivocada, pero la idea es la misma.

// this works for any type - just pass in an Object1 
public Object extractObject(List<?> list, Class clazz) { 
    for(Object obj : list) { 
     if(obj.getClass().equals(clazz) { 
      return obj; 
     } 
    } 
    return null; // no match found 
} 

Y no genérico:

// this works for just one type 
public Object1 extractObject(List<?> list) { 
    for(Object obj : list) { 
     if(obj.getClass().equals(Object1) { 
      return obj; 
     } 
    } 
    return null; // no match found 
} 

probó los conceptos con este controlador:

public static void main(String[] args) { 
    Class c = "".getClass(); 
    if("".getClass().equals(c)) System.out.println("true"); 
    else System.out.println("false"); 
} 

De los comentarios, considere clazz.isAssignableFrom(otherClazz) también.

Answer 3

Como está utilizando los genéricos, que puede hacer

public <T> T extractObject(List<?> list, Class<T> type) { 
    for(Object obj : list) { 
     if(type.isInstance(obj)) { 
      return (T)obj; 
     } 
    } 
    return null; // no match found 
} 

Esto hará que el tipo de retorno de su método, el mismo que el tipo que busca.

Gracias a los genéricos, podemos usar el mismo método para extraer diferentes tipos de objetos:

Object1 object1 = extractObject(list, Object1.class); 
Object2 object2 = extractObject(list, Object2.class); 

Esto se prefiere en el disco de codificación de la comprobación de tipo mediante el uso de obj instanceof Object1 desde haciendo que resultaría en la necesidad de un distinto método por tipo, todos ellos casi idénticos aparte del tipo de devolución y la instancia de verificación.

Answer 4

La diferencia entre los dos es nada. De acuerdo con javadoc, This method is the dynamic equivalent of the Java language instanceof operator.