Generic class that extends class and implements interface

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 interface SomeInterface{
    public void someMethod();
}

public class MyFragment extends Fragment implements SomeInterface{
    //implementation
}

//here is classs, that I need to create. T must extend Fragment and implements 
//SomeInterface. But, I'm afraid, if I'll use MyFragment directly, it will create a
//dependence of SomeClass from MyFragment.

public class SomeClass /*generic?*/ {
    public SomeClass(T parent);
}

Is it possible?

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

> 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.

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.

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.

For Kotlin you can use such syntax:

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

The Kotlin equivalent would be:

class SomeClass<T>() where T: Fragment, T: SomeInterface