Métodos predeterminados en las interfaces

Cada nueva versión de Java difiere de las anteriores. Aquí hay un ejemplo de cambios en el material que hemos cubierto: antes de Java 5, el lenguaje no tenía enums. De manera similar, Java 8 difiere notablemente de Java 7. La mayoría de nuestras lecciones se escribieron para la 7.ª versión del lenguaje, pero, por supuesto, no ignoraremos importantes innovaciones. Como ya estamos hablando de interfaces en esta lección, consideraremos una actualización: métodos predeterminados en interfaces . Ya sabes que una interfaz no implementa comportamiento . Su tarea es describir el comportamiento que deben tener todos los objetos que lo implementan.. Pero los desarrolladores se encontraron frecuentemente con situaciones en las que la implementación de un método es la misma en todas las clases. Consideremos nuestro ejemplo de coche viejo:

public interface Car {

   public void gas();

   public void brake();
}
public class Sedan implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class Truck implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class F1Car implements Car {
   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}

"En tu opinión, ¿cuál es el problema principal con este código? ¡Probablemente notaste que escribimos un montón de código repetido! Este problema es común en la programación y debes evitarlo. Es otro asunto que antes no existían soluciones particulares". Se lanzó Java 8. ¡Con esta versión llegó la capacidad de especificar métodos predeterminados e implementarlos directamente dentro de la interfaz!

public interface Car {

   public default void gas() {
       System.out.println("Gas!");
   }

   public default void brake() {
       System.out.println("Brake!");
   }
}

public class Sedan implements Car {

}

public class Truck implements Car {

}

public class F1Car implements Car {

}

Ahora los métodos gas()y brake(), que eran los mismos para todos los coches, se han movido a la interfaz. No se necesita código repetido. Además, ¡los métodos están disponibles en cada clase!

public class Main {

   public static void main(String[] args) {

       F1Car f1Car = new F1Car();
       Sedan sedan = new Sedan();
       Truck truck = new Truck();
       truck.gas();
       sedan.gas();
       f1Car.brake();
   }
}

¿Qué pasa si hay 100 clases con el gas()método, pero solo 99 de ellas tienen el mismo comportamiento? ¿Eso arruina todo y hace que el método predeterminado no sea apto para esta situación? Por supuesto, no :) Los métodos predeterminados en las interfaces se pueden anular de la misma manera que los ordinarios.

public class UnusualCar implements Car {
   @Override
   public void gas() {
       System.out.println("This car accelerates differently!");
   }

   @Override
   public void brake() {
       System.out.println("This car decelerates differently!");
   }
}

Todos los otros 99 tipos de automóviles implementarán el método predeterminado, y elUnusualCarclass, que es una excepción, no estropeará el panorama general y definirá con calma su propio comportamiento. Herencia múltiple de interfaces. Como ya sabes, Java no admite la herencia múltiple. Hay muchas razones para esto. Los veremos en detalle en una lección separada. Otros lenguajes, como C++, lo admiten. Sin herencia múltiple, surge un problema serio: un objeto puede tener varias características y 'comportamientos' diferentes. He aquí un ejemplo de la vida: somos niños para nuestros padres, estudiantes para nuestros maestros y pacientes para nuestros médicos. En la vida, asumimos diferentes roles y, en consecuencia, nos comportamos de manera diferente: obviamente, no hablaríamos con los maestros de la misma manera que hablamos con nuestros amigos cercanos. Intentemos traducir esto en código. Imagina que tenemos dos clases: Estanque y pajarera. Para el estanque, necesitamos aves acuáticas; para el aviario, necesitamos pájaros voladores. Para hacer esto, hemos creado dos clases base:FlyingBirdy Waterfowl.

public class Waterfowl {
}

public class FlyingBird {
}

En consecuencia, enviaremos aves cuyas clases hereden FlyingBirdal aviario y enviaremos aves que hereden Waterfowlal estanque. Todo parece muy simple. Pero, ¿dónde enviamos un pato? Nada y vuela. Y no tenemos herencia múltiple. Afortunadamente, Java admite múltiples implementaciones de interfaces. Aunque una clase no puede heredar varios padres, ¡puede implementar fácilmente varias interfaces! Nuestro pato puede ser tanto un pájaro volador como un ave acuática :) Simplemente necesitamos crear FlyingBirdinterfaces Waterfowlen lugar de clases para lograr el resultado deseado.

public class Duck implements FlyingBird, Waterfowl {

   // The methods of both interfaces can be easily combined into one class

   @Override
   public void fly() {
       System.out.println("Fly!");
   }

   @Override
   public void swim() {

       System.out.println("Swim!");
   }
}

En consecuencia, nuestro programa conserva la flexibilidad de las clases y, en combinación con los métodos predeterminados, ¡nuestra capacidad para definir el comportamiento de los objetos se vuelve casi ilimitada! :)