Generic class that extends class and implements interface

Question

To reduce dependece of class, I want to send parameter (using generic class) to constructor that extends some class and implements interface, for example

public          


        

Answer 1

Do you want to do something like this?

class SomeClass {}

interface SomeInterface{
    public void someMethod();
}

class AGenericClass<T> extends SomeClass implements SomeInterface {
    public void someMethod() {}
}

This is allowed.

But what's Android specific about your question? I think I must be missing something so can you provide some more details?

update below

I'm still not totally sure what you want to do, and I'm also not sure you need to worry about the dependence right away, but this is also legal, using bounded type parameters:

interface SomeInterface{
    public void someMethod();
}

class Fragment {
    public void aMethodInFragment() { }
}

public class SomeClass <T extends Fragment & SomeInterface> {
    public SomeClass(T parent) {
        parent.someMethod();
        parent.aMethodInFragment();
    }
}

The type parameter <T extends Fragment & SomeInterface> specifies that T should be a subclass of Fragment and implement SomeInterface.

Answer 2

It's easy if i understand you correct you to have some type T which is extending Fragment and implementing some interface. So you have to write something like that.

abstract class TemplateFragment extends Fragment implements SomeInterface{}

and then in your classes

class SomeClass<T extends TemplateFragment> {
...
}

It will do the trick.

Answer 3

T must extend Fragment and implement SomeInterface

In that case you could declare SomeClass as the following:

public class SomeClass<T extends Fragment & SomeInterface>

That would require an object of type T to both extend Fragment and implement SomeInterface.

Further, using my T class, I want to create views, using T.getActivity() as Context.

I'm unfamiliar with Android, but if getActivity() is a public instance method declared in Fragment then will be entirely possible to call it on an instance of T, since the compiler will know all Ts must inherit that method.

Answer 4

For Kotlin you can use such syntax:

class MyClass<T> where T: AnotherClass, T: SomeInterface