How created method with signature as List

I'm very new to Java programming language so this is probably dumb question but I have to ask it because I can't figure it out on my own. Here is the deal.

I want to create method which extracts certain object type from a list. So the method should receive List as argument, meaning list should contain either Object1 or Object2. I've tried like this :

   public Object1 e开发者_开发技巧xtractObject(List<Object>){
    //some pseudo-code 
   ... loop trough list and check if list item is instance of object one return that instance
    }

The problem with declaring method with List<?> as method argument is that I receive compilation error from eclipse Syntax error on token ">", VariableDeclaratorId expected after this token.

How do I set the method signature properly to accept object types either Object1 or Object2 ? Thank you

This is my Code :

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

Edit - what is the difference between these 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
}

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;
}

You need a variable for your instance

And a return.

I'd do something like this - note, my syntax might be wrong, but the idea is the same.

// 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
}

And non-generic:

// 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
}

Tested the concepts with this driver:

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

From the comments, consider clazz.isAssignableFrom(otherClazz) as well.

As you are using generics, you can do

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
}

This will make the return type of your method the same as the type you are looking for.

Thanks to generics, we can use the same method to extract different types of objects:

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

This is preferred to hard-coding the type check by using obj instanceof Object1 since doing that would result in needing a distinct method per type, all of them almost identical apart from the return type and the instanceof check.

The difference between the two is nothing. According to the javadoc, This method is the dynamic equivalent of the Java language instanceof operator.