Creo que estoy un poco confundido por la introducción de métodos predeterminados para las interfaces en Java. Según tengo entendido, la idea es que los métodos predeterminados se pueden introducir en las interfaces existentes sin romper el código existente.

Si implemento una interfaz con una clase no abstracta, yo (por supuesto) tengo que definir implementaciones de todos los métodos abstractos en la interfaz. Si la interfaz define un método predeterminado, heredo la implementación de ese método.

Si implemento dos interfaces, obviamente tengo que implementar la unión de los métodos abstractos definidos en ambas interfaces. Heredo la implementación de todos los métodos predeterminados; sin embargo, si se produce una colisión entre los métodos predeterminados en las dos interfaces, debo anular ese método en mi clase de implementación.

Esto suena bien, pero ¿qué pasa con el siguiente escenario?

Supongamos que hay una interfaz:

package com.example ;
/** 
* Version 1.0
*/
public interface A {
  public void foo() ;
  /**
  * The answer to life, the universe, and everything.
  */
  public default int getAnswer() { return 42 ;}
}

y una segunda interfaz

package com.acme ;
/** 
* Version 1.0
*/
public interface B {
  public void bar() ;
}

Entonces puedo escribir lo siguiente:

package com.mycompany ;
public class C implements com.example.A, com.acme.B {
  @Override
  public void foo() {
    System.out.println("foo");
  }
  @Override
  public void bar() {
    System.out.println("bar");
  }
  public static void main(String[] args) {
    System.out.println(new C().getAnswer());
  }
}

Entonces eso debería estar bien, y de hecho

java com.mycompany.C 

muestra el resultado 42.

Pero ahora supongamos que acme.com realiza el siguiente cambio a B:

package com.acme ;
/** 
* Version 1.1
*/
public interface B {
  public void bar() ;
  /**
  * The answer to life, the universe, and everything
  * @since 1.1
  */
  public default int getAnswer() {
    return 6*9;
  }
}

Según tengo entendido, se supone que la introducción de este método es segura. Pero si ahora ejecuto el com.mycompany.C existente contra la nueva versión, aparece un error de tiempo de ejecución:

Exception in thread "main" java.lang.IncompatibleClassChangeError: Conflicting default methods: com/example/A.getAnswer com/acme/B.getAnswer
at com.mycompany.C.getAnswer(C.java)
at com.mycompany.C.main(C.java:12)

Eso no es del todo sorprendente, pero ¿no significa que la introducción de métodos predeterminados en las interfaces existentes siempre corre el riesgo de romper el código existente? ¿Qué me estoy perdiendo?