abstract class AbstractEntity { /* shared implementation for all entities */ }

class EntityA extends AbstractEntity { /* specific members for this entity */ }
class EntityB extends AbstractEntity { /* specific members for this entity   */ }

abstract class AbstractEntityResource { /* base class for serializable entities */ }

class EntityAResource extends AbstractEntityResource { /* includes members of entityA that should be serialized */ }
class EntityBResource extends AbstractEntityResource { /* includes members of entityB that should be serialized */ }

public interface TransformStrategy<S, T> {
    public T transform(S model);
    boolean canTransform(Class<?> clazz);
}

public abstract class AbstractTransformStrategy<S, T> implements TransformStrategy<S, T> {

    private final Class<? extends S> sourceClass;

    public AbstractTransformStrategy(Class<? extends S> sourceClass) {
        this.sourceClass = sourceClass;
    }

    @Override
    public boolean canTransform(Class<?> clazz) {
        return sourceClass.equals(clazz);
    }
}

public abstract class AbstractModelTransformer<S, T> {

    private final List<TransformStrategy<S, T>> transformStrategies;

    protected AbstractModelTransformer(List<TransformStrategy<S, T>> transformStrategies) {
        this.transformStrategies = transformStrategies;
    }

    public T transform(S model) {
        TransformStrategy<S, T> transformStrategy = transformStrategies.stream().filter(ts -> ts.canTransform(model.getClass())).findFirst().orElseThrow( () -> new IllegalStateException(String.format("No transformer supporting %s could be found", model.getClass().getSimpleName())));
        return transformStrategy.transform(model);
    }
}

public class EntityATransformStrategy extends AbstractTransformStrategy<AbstractEntity, AbstractEntityResource> {
    public LengthConstraintTransformStrategy() {
        super(EntityA.class);
    }

    @Override
    public AbstractEntityResource transform(AbstractEntity model) {
        return new LengthConstraintResource(((EntityA) model));
    }
}

public class AbstractEntityModelTransformer extends AbstractModelTransformer<AbstractEntity, AbstractEntityResource> {

    private static final List<TransformStrategy<AbstractEntity, AbstractEntityResource>> STRATEGIES = new ArrayList<>(
            Arrays.asList(
                    new EntityATransformStrategy()
            )
    );

    public AbstractEntityModelTransformer() {
        super(STRATEGIES);
    }
}

abstract class Base { }
class Concrete extends Base { }

interface Something<T> { /* some method */ }
class Implementation implements Something<Concrete> { /* implementation */}

class Main {
    public static void main(String[] args) {

        List<Something<Base>> list = new ArrayList<>();

        // this fails although Base is the supertype of Concrete
        list.add(new Implementation());
    }
}