接受两种类型的List的通用方法

Question

I want to write a function that can accept two similar types. But not same.

MyClassA {
  abc()
  a2b()
}

MyClassB {
   abc()
   a3b()
}

One method is same in these two. The function should accept list of any of these two types and I want to invoke abc() on objects in the list.

This does not seem to help:

    private <T> Set<MyclassX> createObject(List<T> classes) {

          Set<MyclassX> x;

          if ( T instanceof MyClassA)  {
               for ( MyClassA a : classes ) {
                    if (a.abc().equals("somethig")) {
                         x.add( t.abc());
                     }   
                }   
           }
           return x;
     }

I don't even need to check instanceof . I just need to iterate through the list and compare the values. if there is a match, then call the method abc()

Answer 1

Just create a common interface and make MyClassA and MyClassB implement it:

interface MyClass {
    void abc();
}

Answer 2

I suggest you to use abstract super class like this:

abstract SuperClass{
  abc();
  abstract ab(); // Only if the other methods share signatures
}

MyClassA extends SuperClass {
  ab();
}

MyClassB extends SuperClass{
  ab();
}

private <T> Set<? extends SuperClass> createObject(List<T> classes) {
   ...
}

If you only want to iterate over a collection that contains instances of MyClassA and MyClassB , then call the method abc() on those instances. This can be work well with JPA because there is an annotation so called MappedSuperclass .

This way you can decompose the same logic from descendant classes in a way that fits with your requirements and can be used with generics. Here is a Hibernate example of how to use

Answer 3

Using generics, you can do this:

private <T> Set<MyclassX> createObject(List<T> classes) {
    Set<MyclassX> x;
    for ( T a : classes ) {
        if (a.abc().equals("somethig")) {
            x.add( t.abc());
        }
    }
}
return x;
}

Assuming that t.abc() returns a MyclassX . (And I mean this literally, I'm not assuming that the X stands for something else.)

Answer 4

Type information can be passed in as an argument

<T> void method(Class<T> clazz, List<T> list)
{             
    if(clazz==MyClassA.class)
    {
        @SuppressWarnings("unchecked)
        List<MyClassA> listA = (List<MyClassA>)list;
        ....
    }
    else if...

A better solution is probably to convert a List<MyClassX> to a List<Abc> before passing it in

interface ABC
    abc()

void method(List<Abc> list)

the conversion is probably going to be easy in java8

List<MyClassA> list1 = ...
method( list1.map( e->e.abc() ) );