How to give the And condition in Generics in java

Question

We have a class structure like A<-B<-C<-D<-E<-F ( B extends A, C extends B and so on ).

I need to create a method acceptList(List<> list) in such a way that it can accept the List of Class A,C,E and do not accept List of B,D,F.

This question was asked to me in an interview.

That’s impossible. And it doesn’t seam to make much sense either. — Holger, Aug 28 '13 at 10:44
What do you mean by saying that a method can *accept* some parameters? Should (in case of wrong argument types) the invocation be rejected by the type checker at compile time? Or should it throw InvalidArgumentExceptions? Or maybe something else? — proskor, Aug 28 '13 at 10:58
Are you required to differentiate on the type of the list (e.g. `A` in `List`) or on the type of the *elements* in the list (e.g. a `B` inside a `List<>`)? — Mattias Buelens, Aug 28 '13 at 10:58
I think by accept means "return true" rather that accept parameters. Could you be more precise. — le-doude, Aug 28 '13 at 11:00
There's just too much ambiguity. Assuming that the runtime type of the elements should be checked, what should be done with an empty list? Or a list of mixed elements (`A`s and `B`s)? — Mattias Buelens, Aug 28 '13 at 11:02
I believe this was a case in which you should have asked "What do you mean by ``accept``?". I bet they expected you to ask this question. — le-doude, Aug 28 '13 at 11:05

score 2 · Answer 1 · edited Aug 28 '13 at 11:43

2

Some trick like this might work, bear in mind that interfaces will always beat reflection ... thus if you can implement those type dependent functions in your interfaces directly then do it.

First your implementation of the classes:

public class A {

public boolean isAcceptable() {
    return true;
}

static class B extends A {

    @Override
    public boolean isAcceptable() {
        return !super.isAcceptable();
    }
}

static class C extends B {
    @Override
    public boolean isAcceptable() {
        return !super.isAcceptable();
    }
}

static class D extends C {
    @Override
    public boolean isAcceptable() {
        return !super.isAcceptable();
    }
}

static class E extends D {
    @Override
    public boolean isAcceptable() {
        return !super.isAcceptable();
    }
}

static class F extends E {
    @Override
    public boolean isAcceptable() {
        return !super.isAcceptable();
    }
}

}

then your acceptList(~):

public static boolean acceptList(List<? extends A> list){
    for (A a : list) {
        if(!a.isAcceptable()){
            return false;
        }
    }
    return true;
}

edited Aug 28 '13 at 11:43

allprog

16,540
9
56
97

answered Aug 28 '13 at 10:54

le-doude

3,345
2
25
55

This is not a type safe solution. Incompatibility will be revealed only at runtime. This may answer the question but is a practice that should be avoided whenever possible. – allprog Aug 28 '13 at 10:56
Absolutely right, but I believe the nature of is question is "at runtime", from the name of the function. Or else it is a bad case of the "bad-name-itis". – le-doude Aug 28 '13 at 10:59
@allprog could you explaing your "disclaimer"? – le-doude Aug 28 '13 at 11:09
Don't know whether it really answers the question, but I find the idea is just great! :) – proskor Aug 28 '13 at 11:18
@le_douard forget it, this is a great solution. It would be better if the value of acceptable did not rely so heavily on the actual hierarchy as it make the function really brittle. Suppose the next question was to implement the same functionality but all interfaces simply extended A. – allprog Aug 28 '13 at 12:06

score 1 · Answer 2 · answered Aug 28 '13 at 10:44

1

Maybe the usage of condition - if and isInstance() ?

answered Aug 28 '13 at 10:44

Pawel

1,457
1
11
22

3

`instanceof` does not work for generic types, you can't test for `instanceof List`. One solution would be to test the run-time class of the list's elements (e.g. `list.get(0)`), but even then you could have `B` elements inside a `List `. – Mattias Buelens Aug 28 '13 at 10:46
I think the interview question is probing to see if the interviewee will say "type erasure", and point out that generic restrictions will only be checked at compile time – Graham Griffiths Aug 28 '13 at 10:51
No, it won't help a thing. You can't say *anything* about the element type of an empty list at run-time, and even if there are elements in the list you can't conclude anything about the element type of the list. You won't notice *any* difference between a `List` full of `B`s and a `List` full of `B`s at run-time. I agree with @GrahamGriffiths, this looks like a trick question. – Mattias Buelens Aug 28 '13 at 10:52
Looking at the question again, it doesn't clarify if the method should accept based on the *generic type* or on the *type of the elements in the list*. The first cannot be done, the second can be done by checking the `getClass()` of each element. I added a comment to the OP. – Mattias Buelens Aug 28 '13 at 11:00
You are rigth. The List of A can contain B elements. We can only check the objects inside the list. – Pawel Aug 28 '13 at 11:02

score 0 · Answer 3 · edited Aug 28 '13 at 10:45

0

Not possible, you can only specify allowed classes not classes that are not allowed.

Futhermore once a method is defined to accept a List<? extends A> it accepts List<A>, List<B>, List<C>,...

edited Aug 28 '13 at 10:45

Rohit Jain

209,639
45
409
525

answered Aug 28 '13 at 10:44

GerritCap

1,606
10
9

score 0 · Answer 4 · edited May 23 '17 at 10:32

Generics do not allow differentiation. The type erasure will play its tricks.. I would suggest you to write a custom logic like the below:

public class Test {

public boolean accept(List<? extends A> list) {
    for (Object o : list) {
        if (o instanceof E && !(o instanceof F))
            return true;
        else if (o instanceof C && !(o instanceof D) && !(o instanceof F))
            return true;
        else if (o instanceof A && !(o instanceof B) && !(o instanceof D) && !(o instanceof F))
            return true;
        return false;
    }
    return false;

}

}

class A {

}

class B extends A {

}

class C extends B {

}

class D extends C {

}

class E extends D {

}

class F extends E {

}

Test Method to test the above code:

public static void main(String [] args){

    Test t = new Test();

    List<F> listF = new ArrayList<F>();
    listF.add(new F());
    System.out.println("List of F returns "+ t.accept(listF));

    List<E> listE = new ArrayList<E>();
    listE.add(new E());
    System.out.println("List of E returns "+ t.accept(listE));

    List<D> listD = new ArrayList<D>();
    listD.add(new D());
    System.out.println("List of D returns "+ t.accept(listD));

    List<C> listC = new ArrayList<C>();
    listC.add(new C());
    System.out.println("List of C returns "+ t.accept(listC));

    List<B> listB = new ArrayList<B>();
    listB.add(new B());
    System.out.println("List of B returns "+ t.accept(listB));

    List<A> listA = new ArrayList<A>();
    listA.add(new A());
    System.out.println("List of A returns "+ t.accept(listA));
}

Output of the test:

List of F returns false
List of E returns true
List of D returns false
List of C returns true
List of B returns false
List of A returns true

EDIT:

If you want to do some more research, this might help you . Get generic type of java.util.List

1) D is instance of C, B is instance fo A, it will always return true. 2) List can contain B elements. — Pawel, Aug 28 '13 at 11:00
It partially works. It works for the objects inside the list, not the list itself. For example: `List listA = new ArrayList (); listA.add(new B());`, because B is A — Pawel, Aug 28 '13 at 11:38
You can achieve this only if you have the list as a field in the class. For method parameters even reflection wont help. — dharam, Aug 28 '13 at 11:50

How to give the And condition in Generics in java

4 Answers4