Convert custom adapter to use generics in Java

Question

I have a Adapter in my Android app and I want to make it Generic.

Basiclly the Adapter looks like that:

public class myAdapter extends FragmentStatePagerAdapter {

DataTypaA myFragment;
DataTypeB data;
DataTypeC items;

public myAdapter(FragmentManager fm, DataTypaA fragment) {
        data = new SparseArray<DataTypeB>();
        myFragment = fragment;
        items = myFragment.getData();
    }

    public DataTypeB getItem(int position) {
        return data.get(position);
    }

    @Override
    public int getCount() {
        return items.getList().size();
    }


public void setData () {

items = myFragment.getItems ()  //getItems return DataTypeC
data.setTheData (items) 
}
}

I changed it to generic

public class myAdapter <A,B,C> extends FragmentStatePagerAdapter {

A myFragment;
B data;
C items;

public myAdapter(FragmentManager fm, A fragment) {
        data = new SparseArray<B>();
        myFragment = fragment;
        items =  (C) myFragment.getData();
    }

    public B getItem(int position) {
        return data.get(position);
    }

    @Override
    public int getCount() {
        return items.getList().size();
    }


public void setData () {

items = myFragment.getItems ()  //getItems return DataTypeC
data.setTheData (items) 
}
}

but I'm getting different errors, when methods should get DataTypeC parameter and I passing it parameter type C ( data.setTheData (items) ) that is actually type DataTypeC the compiler suggest to cast C to type DataTypeC. and in getCount() I have also error suggesting to convert items to DataTypeC.

for example when I try to override getItem I getting mistakes, but when I create the same method with other name it compiles.

//Error - "The return type is incompatible with FragmentStatePagerAdapter.getItem(int)"
@Override
    public B getItem(int position) {
        return (B) data.get(position);
    }

//compiles
    public B getItemTest(int position) {
        return data.get(position);
    }

Any ideas how to fix it so it will be 100% generic?

ADDED: After your answer I changes it to support return of generic type :

   public class TypeA <T> {
    private T mData;

        public T getData() { return mData;; }
    }



    public class myAdapter <A,B,C> extends FragmentStatePagerAdapter {

        A myFragment;
        B data;
        C items;

        public myAdapter(FragmentManager fm, A fragment) {
                data = new SparseArray<B>();
                myFragment = fragment;
                items = myFragment.getData(); //Error - The method getData() is undefined for the type T
            }

}

I'm getting compile error... when I run it of course <T> and <C> are the same type.

Answer 1

The first problem is that your non-generic code doesn't compile. You have a field DataTypeB data; which you then assign a SparseArray<DataTypeB> to. Also, setData doesn't compile at all.

Ignoring this... you have declared type parameters A, B, C and changed your instance field types, but you still try and assign DataTypaA to A myFragment in your constructor, and a SparseArray<DataTypeB> to B data. When you migrate code to generics you need to approach it like you would refactoring - one step at a time.

For instance, by diving in as you have now take a look at items = (C)myFragment.getData(). As fragment is still of type DataTypaA then presumably its getData() method doesn't return a generic type. Something is going to have to change.

You have a lot of work to do, so to repeat myself - treat this as a refactoring exercise and go step by step.

1. Get your non-generic type to compile.
2. Change myFragment to be a A myFragment and declare a type parameter <A extends DataTypaA. See what needs to be done to get this to compile before moving on.
3. Now look at moving data to be SparseArray<B> data. Presumably this needs to a SparseArray<T> where T is a DataTypeB, or subtype thereof. That means you are going to need a wildcard-based bound on B. Something like B extends SparseArray<? extends DataTypeB>
4. Now look at items. You know that it is returned from your new generic type variable A extends DataTypeA, so DataTypeA needs to be generic and have a generic type variable returned from getData. Let's say it is declared as DataTypeA<T extends DataTypeC> with public T getData() { ... }.

So now your type parameter sections change to:

class DataTypaA<T extends DataTypeC>
...
class myAdapter <A extends DataTypaA<C>, 
                 B extends SparseArray<? extends DataTypeB>, 
                 C extends DataTypeC> 
    extends FragmentStatePagerAdapter { 
    A myFragment;
    SparseArray<B> data;
    C items;
...

It's hard to go too far with this given the code you have posted - not all the classes and information is there, but this is the process you will have to follow.

For instance: you may not need to restrict C to DataTypeC. This then changes the type parameter sections on myAdapter and DataTypeA. My assumption about SparseArray<B> may also be incorrect - but your code doesn't compile at the moment so I can't tell. A final implementation may go something like:

class myAdapter <A extends DataTypaA<C>, 
                 B extends SparseArray<? extends DataTypeB, 
                                       ? extends DataTypeC>, 
                 C extends DataTypeC> 
    extends FragmentStatePagerAdapter {

    A myFragment;
    SparseArray<B, C> data;
    C items;

    public myAdapter(FragmentManager fm, A fragment) {
        data = new SparseArray<B, C>();
        myFragment = fragment;
        items =  myFragment.getData();
    }

    public B getItem(int position) {
        return data.get(position);
    }

    @Override
    public int getCount() {
        return items.getList().size();
    }   

    public void setData () {
        items = myFragment.getItems ();  //getItems return DataTypeC
        data.setTheData(items);
    }
}

For this I used the fake classes:

class DataTypaA<T extends DataTypeC> {
    public T getData() { return null; }
    public T getItems() { return null; }
}
class SparseArray<T, S> {
    public T get(int foo) { return null; }
    public void setTheData(S items){}
}
class DataTypeB {
}
class DataTypeC {
    // do NOT use the raw type List - just done to get your code to compile
    public List getList() { return null; }
}
abstract class FragmentStatePagerAdapter {
    public abstract int getCount();
}
class FragmentManager {
}

Answer 2

When "genericizing" classes, you should replace all instances of genericized types by their generic: DataTypaA becomes A, etc.

You also need to make sure return types from methods you call on other objects (like fragment.getData()) are compatible with the generic. For that you can indicate the generic type extends a known class:

public class MyAdapter<A extends MyData,B extends MyData,...>

The Java Tutorial on generics is good for more information.