10

I want to run certain tests in Lists. The Lists can contain entirely different classes.

I have one method to check the consistency of the list - not null, not empty, no more than x elements. This is common to all the lists. Then I want to test each of the objects, using overloading.

The idea would be something like:

public static <T> void check(List<T> list) {

    //do general checks

    for (T element : list) {
        check(element);
    }
}

and then

public static void check(SomeType element) {...}

public static void check(SomeOtherType element) {...}

But I also had to add a method like this:

public static void check(T element) {...}

And this was called at runtime - not my other methods with the specific classes. Although the class was exactly the same. I'm evidently missing some generics understanding.

Now if I don't use the general method at all and try to solve it this way:

    public static void check(List<SomeType> list) {...}

    public static void check(List<SomeOtherType> list) {...}

Compiler error - "Method check(List) has the same erasure check(List) as another method..."

So is there any elegant solution for this? I could just use different method names but would like to know how it's possible without that.

Thanks!

Improve this question
4
  • 3
    Do you have a known, static, finite list of possible types that will be contained in the list? Commented Jan 30, 2013 at 15:56
  • @mellamokb yes. But I also would like to know the answer if I hadn't one Commented Jan 30, 2013 at 15:57
  • @lxx You say that you are running specific tests on each element but your unique class overrides were not being called. Was the code within the function itself identical in this case or were there different function bodies? I can see the runtime behavior acting like you describe when the function bodies are the same... What kind of operations are you running on the specific classes? Something that could be simplified with a good inheritance structure? Commented Jan 30, 2013 at 16:01
  • @TheCapn I'm just writing a very simple class to check the responses of some webservices for consistency. Normally I would have all checks in each test case, but some webservices can return the same objects, so I just want to put the common checks in static methods. Don't want to go in complex structures for this. Commented Jan 30, 2013 at 16:08

5 Answers 5

Reset to default
10

This isn't something about generics that you're missing. Java does not have double dispatch. The call to check must be resolved at compile-time, and check(T) is the only match since the compiler can't tell if T is SomeType or SomeOtherType in a given scenario. It needs to choose one method to call that will work for all possible Ts.

This is sometimes solved using the visitor pattern.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Ahh... I see. Now I finally got some practical understanding of "type erasure" (heard a lot about it but never understood really). +1
@Ixx: It does have to do with type erasure, yes, in that there isn't different bytecode for each possible T in check(List<T>). But the problem you're encountering isn't unique to generics. If you had a check(List<Base>) and you wanted to call check(Sub1) or check(Sub2) depending on the type of the element, you would run into the same problem.
4

The problem should be solved by the caller. When it instanciate your class with a concrete type for T, it should also pass an instance of Checker<T> with the same concrete type:

public class SomeClass<T> {
    private List<T> list;
    private Checker<T> checker;

    public SomeClass(Checker<T> checker) {
        this.checker = checker;
    }

    public void check() {
        checker.check(list);
    }
}

public interface Checker<T> {
    public void check(List<T> list);
}

...

SomeClass<Foo> someClass = new SomeClass<Foo>(new Checker<Foo>() {
    @Override 
    public void check(List<Foo> list) {
        // do whatever you want here
    }
});
Improve this answer

2 Comments

But my SomeClass is a domain object, don't want to put a checker variable there... I just wanted to write an utility class with all the checks as static methods, one after the other :/ For my current case this is clear and easy to use.
Maybe I just go with different method names.
4

You can use instanceof to dispatch:

public static <T> void check(List<T> list) {
  for (T element : list) {
    check(element);
  }
}

public static void check(T t) {
  if (t instanceof SomeType) {
    SomeType someType = (SomeType) t;
    // code for SomeType ...
  } else if (t instanceof OtherType) {
    OtherType otherType = (OtherType) t;
    // code for OtherType ...
  } else {
    // we got a type that we don't have a method for
  }
}
Improve this answer

1 Comment

(Simplified my answer, since in this case you don't actually need the Class object. JB Nizet's answer is also a good idea.)
2

With generics, the type parameter is actually erased during compilation, and the list object don't know anything about the static type of the object it contains. Since it doesn't know it, it can not use overloading to call methods with different parameters, because Java doesn't support multiple dispatch.

You have then three choices:

  • Make your objects implement a Checked interface with a check method that does the check logic. Downside is that the check logic is now dispersed in several places and it is not practical if you have objects of classes you don't have control of.
  • Use instanceof to call explicitly the check methods according to the dynamic type of the object. Downside is you potentially end up with a big if/else block a bit harder to maintain.
  • Implement the visitor pattern. Downside is that you have to change the object classes too, but the check logic stay in a single place.
Improve this answer

Comments

1

Since the type of the variable is lost in check(List<T> list) you have two options:

1. Do different things by checking runtime type 

check(T element) {
  if (element.getClass().equals(SomeType.class)) {
    check((SomeType) element);
  } elseif (element.getClass().equals(SomeOtherType.class)) {
    check((SomeOtherType) element);
  }

This can be made a little more sophisticated, for example by wrapping each check in a Callable and using a Map<Class, Callable>

This is similar to visitor pattern.

2. Calling a virtual method on the element to be checked itself

If the checking logic can be pushed to the object to be checked itself (this is not necessarily a bad thing) then you don't need to check types:

interface Checkable { void check(); }
class SomeType implements Checkable { .... }
class SomeOtherType implements Checkable { .... }

Then:

public static <T extends Checkable> void check(List<T> list) {
    for (T element : list) {
        element.check();
    }
}

These are the only two options, any implementation has to be a variation on one of these

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.