CODEWITHSUNDEEP
javadesign-patternsjava-8default-method
Yiqing Zhu
Yiqing Zhu

Reputation: 31

Java 8: Automatically composite default methods of multiple interfaces

I have class implements multiple interfaces which have a same default default method. I am wondering how can I composite the default method from all the interfaces. For example: 

interface IA {
    default void doA() {} 
    default void process() { 
        // do something 
    }
}

interface IB { 
    default void doB() {}
    default void process() { 
        // do something 
    }
}

interface IC {
    default void doC() {} 
    default void process() { 
        // do something 
    }
}

// other similar interfaces
....    

class MyClass implements IA, IB, IC, ... {
    public void process() {
       // question: how to avoid iterate all the interfaces? 
       IA.super.process();       
       IB.super.process();
       IC.super.process();
       ...
    }
}

class AnotherClass implements IA, ID, IF, IH, ... {
    public void process() {
        IA.super.process();
        ID.super.process();
        IF.super.process();
        IH.super.process();
        ...
    }
}

In the implementation the method is simply compositing process() from all interfaces. However I have to call IA.super.process(), IB.super.process(), IC.super.process() explicitly. If the interface list is long it's painfully to write all of them. Also I may have different classes to implement different combination of interfaces. Is there other syntax sugar/design pattern/library that allows me to do it automatically?

Update: compare with Composite pattern

Composite pattern is also considerable. But I want to use default method as mixin to give classes different behaviors, while composite pattern doesn't give me static type checking here. Composite pattern also introduces extra memory footprint.

Upvotes: 3

Views: 482

Answers (1)

Michael
Michael

Reputation: 44090

I think your mistake is defining multiple interfaces which are effectively identical (aside from differing default behaviour). It seems wrong in my mind and violates DRY.

I would structure this using the composite pattern:

interface Processable
{
    void process();
}
public interface IA extends Processable //and IB, IC etc.
{
    default void doA()
    {
        // Do some stuff
    }
}


final class A implements IA
{
    void process() { /* whatever */ }
}


class Composite implements IA //, IB, IC etc. 
{
    List<Processable> components = Arrays.asList(
         new A(), new B(), ...
    );

    void process()
    {
         for(Processable p : components) p.process();
    }
}

Upvotes: 7

Related Questions