How to do method chaining with subclasses in Java 8

Question

I followed this pattern to implement method chaining with subclasses in Java. The goal is that I have a method on a superclass, but can assign the subclass, like:

interface Screen {
    <T extends Screen> T setBrightness(int value);
    <T extends Screen> T setContrast(int value);
}

class CrtScreen implements Screen {

    @SuppressWarnings("unchecked")
    @Override
    public <T extends Screen> T setBrightness(int value) {
        // ...
        return (T) this;
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T extends Screen> T setContrast(int value) {
        // ...
        return (T) this;
    }
}

class ColorCrt extends CrtScreen { /* ... */ }

public static void main(String[] args) {
    ColorCrt cc = new ColorCrt().setBrightness(50).setContrast(50);
}

Now I also have container objects that I want to add my objects to, like:

class Stuff {
    Stuff add(Screen s) {
        // ...
        return this;
    }

    Stuff add(String s) {
        // ...
        return this;
    }

    Stuff add(int i) {
        // ...
        return this;
    }
}

public static void main(String[] args) {
    new Stuff().add(new ColorCrt().setBrightness(50).setContrast(50)).add(25).add("...");
}

This now does no longer work in Java 8, giving me The method add(Screen) is ambiguous for the type Stuff. I understand the reason as explained here. I only see two options at the moment:

• I don’t use <T extends, but just Screen setBrightness(value). It takes me the option to assign my implementing class to an according variable, and I have to cast it when I want to execute an implementation-specific method.

• I have to add casts or type parameters in my method chaining. This is very ugly to read and hard to fix for large constructs (many levels of boxing) that have to be ported from Java 7.

Is there a way to implement method chaining in Java 8 so that I still have both features? If not, can one of the both approaches be considered more intended?

Answer 1

In your code:

class CrtScreen implements Screen {

    @SuppressWarnings("unchecked")
    @Override
    public <T extends Screen> T setBrightness(int value) {
        // ...
        return (T) this;
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T extends Screen> T setContrast(int value) {
        // ...
        return (T) this;
    }
}

Your member functions setContrast and setBrightness don't need to be generic, and if it is generic, you need to specify what the type is (at the call site). I've used this approach that rather makes the interface generic, which means the methods need'nt be:

interface Screen<T extends Screen> {
    T setBrightness(int value);
    T setContrast(int value);
}

class CrtScreen implements Screen<CrtScreen> {
    @SuppressWarnings("unchecked")
    @Override
    public CrtScreen setBrightness(int value) {
        // ...
        return this;
    }

    @SuppressWarnings("unchecked")
    @Override
    public CrtScreen setContrast(int value) {
        // ...
        return this;
    }
}

If you want to proceed doing it your way, you would need to specify which type applies to the generic (see below):

public static void main(String[] args) {
    new Stuff()
     .add(new ColorCrt().<ColorCrt>setBrightness(50))
     .add(25).add("...");
}

Answer 2

Finally I found a solution that works for me by making the interface an abstract class. This seems to be specific enough to satisfy the Java 8 compiler.

Proof of concept:

static abstract class Screen {
    abstract <T extends Screen> T setBrightness(int value);
    abstract <T extends Screen> T setContrast(int value);
}

static class CrtScreen extends Screen {

    @SuppressWarnings("unchecked")
    @Override
    public <T extends Screen> T setBrightness(int value) {
        // ...
        return (T) this;
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T extends Screen> T setContrast(int value) {
        // ...
        return (T) this;
    }
}

static class ColorCrt extends CrtScreen { /* ... */ }

static class Stuff {
    Stuff add(Screen s) {
        return this;
    }

    Stuff add(String s) {
        return this;
    }

    Stuff add(int i) {
        return this;
    }
}

public static void main(String[] args) {
    ColorCrt cc = new ColorCrt().setBrightness(50).setContrast(50);
    new Stuff().add(new ColorCrt().setBrightness(50).setContrast(50)).add(25).add("...");
}