实现泛型类型接口

Question

假设我有以下接口：

public interface MvpView { }
public interface MvpPresenter<V extends MvpView> {
void attach(V view);
}

然后是实现MvpPresenter的基类

public class BasePresenter<V extends MvpView> implements MvpPresenter<V> {
private V view;
@Override
public void attach(V view) {
this.view = view;
}
}

最后是以下扩展 BasePresenter 的类

public abstract class BaseFragment<P extends MvpPresenter> implements MvpView {
P presenter;
public void someMethod() {
presenter.attach(this);
}
}

虽然这会编译，但它并不安全，因为无法保证类的实现将实现正确的MvpView(P presenter使用的那个)。为了安全起见，我省略了someMethod代码，每个实现都必须用完全相同的代码填充它presenter.attach(this)

我想做什么，但我不知道是这样的：

public abstract class BaseFragment<V extends MvpView, P extends MvpPresenter<V>> implements V {
P presenter;
public void someMethod() {
presenter.attach(this);
}
}

有什么办法可以做到这一点吗？

Answer 1

像这样声明BaseFragment。

abstract class BaseFragment<P extends MvpPresenter<R>, R extends BaseFragment<P,R>> implements MvpView {
P presenter;
public void someMethod() {
presenter.attach(getThis());
}
abstract R getThis();
}
}

并使用这样的扩展，

class MyFragment extends BaseFragment<MvpPresenter<MyFragment>, MyFragment> {
@Override
MyFragment getThis() {
return this;
}   
}

Answer 2

这将编译：

public abstract class BaseFragment<P extends MvpPresenter<BaseFragment>> implements MvpView {
P presenter;
public void someMethod() {
presenter.attach(this);
}
}

但是我还没有找到实际子类化的方法。我不确定 MvpView 是否真的需要任何东西。也许这样的东西会很有用：

public interface MvpPresenter<V> {
void attach(V view);
}
public class BasePresenter<V> implements MvpPresenter<V> {
private V view;
@Override
public void attach(V view) {
this.view = view;
}
}
public abstract class BaseFragment<R extends BaseFragment>  {
MvpPresenter<R> presenter;
public void someMethod() {
presenter.attach(getThis());
}
abstract R getThis();
}
public class MyBaseFragment extends BaseFragment<MyBaseFragment> {
@Override
MyBaseFragment getThis() {
return this;
}
}

Answer 3

基于boobalan gnanasekaran和user158037的答案，我是这样做的：

public interface MvpView { }
public interface MvpPresenter<V extends MvpView> {
void attach(V view);
}
public class BasePresenter<V extends MvpView> implements MvpPresenter<V> {
private V view;
@Override
public void attach(V view) {
this.view = view;
}
public V getView() {
return view;
}
}
public abstract class BaseFragment<V extends MvpView, P extends MvpPresenter<V>> {
P presenter;
protected abstract V getThis();
public void someMethod() {
presenter.attach(getThis());
}
public P getPresenter() { return presenter; }
}

和一个示例实现

public interface MoviesContract {
interface Presenter extends MvpPresenter<MoviesContract.View> {
void loadMovies();
}
interface View extends MvpView {
void onMoviesLoaded();
}
}
public class MoviesPresenter extends BasePresenter<MoviesContract.View>
implements MoviesContract.Presenter {
@Override
public void loadMovies() {
getView.onMoviesLoaded();
}
}

public class MoviesFragment extends BaseFragment<MoviesContract.View, MoviesContract.Presenter>
implements MoviesContract.View {
@Override
public MoviesContract.View getThis() {
return this;
}
public loadMovies() {
getPresenter().loadMovies();
}
@Override
public void onMoviesLoaded() {
//
}
}