clase genérica que se extiende clase y aperos de interfaz

Question

Para reducir dependece de clase, quiero enviar parámetros (usando clase genérica) al constructor que se extiende un poco de clase e implementa la interfaz, por ejemplo

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); 
} 

¿Es posible?

Futher, utilizando mi clase T, quiero crear vistas, usando T.getActivity() como Contexto.

Answer 1

T debe extenderse Fragmento e implementar SomeInterface

En ese caso, se podría declarar SomeClass como los siguientes:

public class SomeClass<T extends Fragment & SomeInterface> 

que requeriría un objeto de tipo T que se extienden ambas Fragment y implementar SomeInterface.

Además, utilizando mi clase T, quiero crear vistas, usando T.getActivity() como Contexto.

estoy familiarizado con Android, pero si getActivity() es un método de instancia pública declarada en Fragment entonces será totalmente posible llamarlo en una instancia de T, ya que el compilador sabrá todos T s debe heredar ese método .

Answer 2

¿Desea hacer algo como esto?

class SomeClass {} 

interface SomeInterface{ 
    public void someMethod(); 
} 

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

Esto está permitido.

¿Pero cuál es Android específico acerca de tu pregunta? Creo que me debe estar perdiendo algo, así que ¿puedes proporcionar más detalles?

actualización continuación

Todavía no estoy totalmente seguro de lo que quiere hacer, y también estoy seguro de que no necesita preocuparse por la dependencia de inmediato, pero esto también es legal, utilizando 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(); 
    } 
} 

El tipo de parámetro <T extends Fragment & SomeInterface> especifica que T debería ser una subclase de Fragment y aplicar SomeInterface.

Answer 3

Es fácil si entiendo que corrija que tenga algún tipo T que extienda Fragmento e implemente alguna interfaz. Entonces tienes que escribir algo así.

abstract class TemplateFragment extends Fragment implements SomeInterface{} 

y luego en sus clases

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

que va a hacer el truco.