Deux méthodes par défaut qui s'appellent

Question

j'ai une interface comme ceci:

public interface Foobar 
    { 
     default void foo(Bar bar) 
     { 
      foo(bar, 1); 
     } 

     default void foo(Bar bar, int n) 
     { 
      for (int i = 0; i < n; i++) 
      { 
       foo(bar); 
      } 
     } 
    } 

Au début je pensais que ce serait bien aussi:

default void foo(byte[] b) 
    { 
     foo(b, 0, b.length); 
    } 

    void foo(byte[] b, int off, int len); 

Mon problème est que je veux exécutez foo fois ou n fois. Toute classe d'implémentation peut remplacer l'une ou l'autre ou les deux. (La seconde méthode existe pour le traitement par lots dans un système de performance critique)

Mais il semble que ma solution utilisant default ne soit pas un bon style car il est possible de ne remplacer aucun d'entre eux et d'appeler l'un ou l'autre des fils vers une boucle infinie (et finalement à un StackOverflow). Donc, ma question est: Quel serait le bon compromis de style POO?

Answer 1

Votre interface IFoo peut ressembler à ceci -

public interface IFoo { 

    default void foo(Bar bar, int n) { 
     for (int i = 0; i < n; i++) { 
      foo(bar); 
     } 
    } 

    void foo(Bar bar); 

} 

et votre classe Foo implémentant l'interface IFoo peut être comme ça -

public class Foo implements IFoo{ 

    @Override 
    public void foo(Bar bar) { 
     // process foo logic 

    } 

} 

Vous n'avez pas besoin d'appliquer la logique de boucle unique à l'intérieur l'interface, au lieu d'appeler le foo tout de suite.