I have and abstract class Image which has two implementations: CTImage and CRImage. Specific type of Image is a part of Series (also abstract) with two implementations: CTSeries and CRSeries. When the object of specific Image is created it should create proper Series object, and add itself to proper implementation of Series .

我有一个抽象类Image，它有两个实现：CTImage和CRImage。具体类型的Image是Series(也是抽象的)的一部分，有两个实现：CTSeries和CRSeries。在创建特定图像的对象时，应该创建适当的Series对象，并将其自身添加到Series的正确实现中。

Code I produced does not compile. Line `this.series.addImage(this); produces:

我生成的代码不能编译。行`this.Series.addImage(This)；生成：

Required type:
capture of ? extends Image<S>

Provided:
Image<S>

The workaround is to add image to series in every implementation (commented lines) but that makes me reapeat myself. I just can't figure out what's the problem and how to fix it.

解决办法是在每个实现(注释行)中将图像添加到系列中，但这会让我收获颇丰。我就是想不出问题出在哪里，也不知道怎么解决。

import java.util.ArrayList;
import java.util.List;

abstract class Series<T extends Image<?>> {
    protected List<T> images = new ArrayList<>();

    public void addImage(T img) {
        this.images.add(img);
    }

    public List<T> getImages() {
        return images;
    }
}

class CTSeries extends Series<CTImage> {
}

class CRSeries extends Series<CRImage> {
}

abstract class Image<S extends Series<? extends Image<S>>> {
    protected S series;

    public Image() {
        this.series = createSeries();
        this.series.addImage(this);
    }

    public S getSeries() {
        return series;
    }

    protected abstract S createSeries();

}

class CTImage extends Image<CTSeries> {

    public CTImage() {
//        series.addImage(this);
    }

    @Override
    protected CTSeries createSeries() {
        return new CTSeries();
    }
}

class CRImage extends Image<CRSeries> {

    public CRImage() {
//        series.addImage(this);
    }

    @Override
    protected CRSeries createSeries() {
        return new CRSeries();
    }
}

This can be done, but the types get a little complex, and there is still a small amount of necessary duplication.

这是可以做到的，但是类型变得有点复杂，并且仍然有少量必要的重复。

import java.util.ArrayList;
import java.util.List;

abstract class Series<S extends Series<S, I>, I extends Image<I, S>> {
    protected List<I> images = new ArrayList<>();

    public void addImage(I img) {
        this.images.add(img);
    }

    public List<I> getImages() {
        return images;
    }
}

class CTSeries extends Series<CTSeries, CTImage> {
}

class CRSeries extends Series<CRSeries, CRImage> {
}

abstract class Image<I extends Image<I, S>, S extends Series<S, I>> {
    protected S series;

    public Image() {
        this.series = createSeries();
        this.series.addImage(thisImage());
    }

    protected abstract I thisImage();

    public S getSeries() {
        return series;
    }

    protected abstract S createSeries();

}

class CTImage extends Image<CTImage, CTSeries> {

    public CTImage() {
    }

    @Override
    public CTImage thisImage() {
        return this;
    }

    @Override
    protected CTSeries createSeries() {
        return new CTSeries();
    }
}

class CRImage extends Image<CRImage, CRSeries> {

    public CRImage() {
    }

    @Override
    public CRImage thisImage() {
        return this;
    }

    @Override
    protected CRSeries createSeries() {
        return new CRSeries();
    }
}

Other than the self-referential type parameters, the major change is the addition of the abstract thisImage method, which is used instead of this in the call to this.series.addImage. This is because there is no way in Java to express "the type of this object". The concrete implementations all need to implement this method as return this;. There's no way for it to be inherited from the Image base class, as the compiler can't enforce that all possible subclasses will specify their own type as the value of I.

除了自引用类型参数之外，主要的更改是添加了抽象的thisimage方法，而不是在对this.Series.addImage的调用中使用该方法。这是因为在Java中没有表示“该对象的类型”的方法。具体的实现都需要将该方法实现为返回This；。它不可能从Image基类继承，因为编译器不能强制所有可能的子类都将自己的类型指定为I的值。