Come gestite quando l'implementazione per un metodo di interfaccia è la stessa per alcune classi?

Question

Si supponga di aver definito l'interfaccia ISomeInterface con i metodi foo e bar.
E.g.

Diciamo che ho le classi A e B che per loro ha senso sia implementare l'interfaccia. Ma non ha senso avere un'implementazione diversa per foo().
Tenendo conto che derivare A da B o B da A è errato/strano c'è una pratica di codifica standard per questo progetto?
presumo ho potuto creare qualche classe utilità per implementare foo() e chiamarlo come delegato, ma mi chiedevo se tutta questa struttura può essere trattata in modo diverso

Aggiornamento:
Per dare una piena comprensione della mia domanda mi sono imbattuto in questo: http://perlbuzz.com/2010/07/why-roles-in-perl-are-awesome.html e stavo cercando di capire se questa funzione viene a mancare dai tradizionali concetti OO, come li usiamo in Java o no

Answer 1

deciso di trasformare il mio commento in una risposta:

Si potrebbe utilizzare una classe astratta anziché un'interfaccia:

public abstract class FooBar { 
     public void foo(){ 
     //your implementation goes here 
     } 

     abstract void bar(); 
    } 

    public class A extends FooBar{ 

     @Override 
     public void bar(){ 

     } 
    } 

Answer 2

Perché non qualcosa di simile:

public class abstract SomeAbstractClass { 
    public void foo(){ 
     //implementation 
    } 
    public abstract void bar(); 
} 

class A extends SomeAbstractClass { 

} 

class B extends SomeAbstractClass { 

} 

Answer 3

public abstract class SomeClass implements ISomeInterface { 
    public void foo() { 
     // I do stuff.. 
    } 
} 

public class A extends SomeClass { 
    public void bar() { 
     // A specific impl. of bar.. 
    } 
} 

public class B extends SomeClass { 
    public void bar() { 
     // B specific impl. of bar.. 
    } 
} 

Answer 4

In alternativa, se non si vuole A e B per essere legato estendendo una classe astratta puoi semplicemente usare la composizione. Ciò fornisce anche la flessibilità di modificare il comportamento di IFoo in fase di esecuzione se si immette lo FooImpl come parte del costruttore. In questo esempio ho appena cablato il FooImpl per brevità.

public class B implements ISomeInterface { 

    private IFoo foo = new FooImpl(); 

    public void foo() { 
     foo.doSomethingFooey(); 
    } 

    public void bar() { 
     // B specific implementation   
    } 
} 

public class A implements ISomeInterface { 

    private IFoo foo = new FooImpl(); 

    public void foo() { 
     foo.doSomethingFooey(); 
    } 

    public void bar() { 
     // A specific implementation 
    } 
} 

Answer 5

La modifica suggerisce che la vostra vera domanda è: "c'è un equivalente per i ruoli Perl in Java"

Poiché Java 8 ha introdotto i metodi default nelle interfacce, le interfacce con i metodi predefiniti sembrano un ottimo equivalente per i ruoli. In particolare, si può fare quello che vuoi nel tuo esempio: fornire un'implementazione di default per foo():

interface ISomeInterface { 
    public default void foo(){ /* your default impl goes here */} 
    public void bar(); // Abstract, must be implemented by subclasses 
} 

class A implements ISomeInterface { 
    // must only implement bar, can reuse foo's default impl 
} 

class B implements ISomeInterface { 
    // must only implement bar, can reuse foo's default impl 
} 

Se c'è una caratteristica di ruoli che mi manca per favore fatemelo sapere. Altrimenti, penso che le interfacce Java8 siano un surrogato abbastanza buono per i ruoli.