--- title: Interface en Java 8 -Método Default- con ejemplos url: https://jarroba.com/interface-en-java8-metodo-default-con-ejemplos/ author: Richard [Admin Jarroba] date: 2014-09-10 modified: 2026-10-21 language: es license: CC BY-NC-SA 3.0 (https://creativecommons.org/licenses/by-nc-sa/3.0/) — attribution: "Interface en Java 8 -Método Default- con ejemplos", Richard [Admin Jarroba], jarroba.com categories: Ingeniería del Software, Lenguajes de Programación tags: herencia, interface, java, java 8, polimorfismo, poo, programación, programación orientada a objetos repository: https://github.com/jarroba/InterfaceJava8 --- # Interface en Java 8 -Método Default- con ejemplos > Aprende qué es el método default de las interfaces en Java 8, cómo añadir comportamiento sin tocar las clases que las implementan y simular herencia múltiple. El proyecto de este post lo puedes descargar pulsando [AQUI](https://github.com/jarroba/InterfaceJava8). En esta entrada vamos a hablar de un cambio bastante interesante que han integrado en Java 8, como es el método «***default***" de las nuevas interfaces. Como ya se comentó en las entradas en las que hablamos de [polimorfismo](https://jarroba.com/polimorfismo-en-java-interface-parte-ii-con-ejemplos/), una clase "***interface***" es **una clase abstracta pura en la que todos sus métodos son abstractos y por tanto no se pueden implementar en la clase Interface.**Pues bien, ahora en Java 8 se ha incluido el método "***default***" que se puede implementar en la clase interface y que su implementación será común para todas las clases que implementen esa interface. Dicho así, uno puede pensar que con este método se rompe con la premisa de que las clases interface son abstractas puras, pero la inclusión de este nuevo método en las interfaces de java 8 tienen dos propósitos interesantes como son: 1. ***No modificar las clases que usen esa interface***. 2. ***Simular una "Seudo Herencia Múltiple"***, ya que java no dispone de herencia múltiple como tal. Sobre este punto hablaremos más adelante para aclarar ese concepto de seudo herencia múltiple. El punto 1 (aunque puede sonar chapucero) tiene bastante sentido y más hoy en día en que es muy importante la rápida respuesta al cambio, ya que supongamos un caso en el que hayamos desarrollado una interface que la implementan 20 clases y necesitemos a última hora añadir una nueva funcionalidad que deben de tener todas las clases que implementan nuestra interface. Pues en este caso con implementar un método «default» en la interface nos valdría para solucionar el problema y adaptarnos rápidamente al cambio. Esta sería una solución rápida aunque si fuésemos muy puristas, con más tiempo deberíamos reescribir esos métodos en las clases que implementan la interface. Para ver esto vamos a dar una solución rápida al ejemplo puesto en la entrada de "[Polimorfismo en Java -Interface- (Parte II), con ejemplos](https://jarroba.com/polimorfismo-en-java-interface-parte-ii-con-ejemplos/)", en la que simulábamos el comportamiento de la selección española de fútbol. En este ejemplo implementamos el comportamiento expuesto en el siguiente diagrama de clases: [![Interface_java_jarroba](https://jarroba.com/wp-content/uploads/2014/04/Interface_java_jarroba.jpg)](https://jarroba.com/wp-content/uploads/2014/04/Interface_java_jarroba.jpg) Como vemos tenemos tres clases que implementan una misma interface, pero ahora queremos añadir 2 nuevos comportamientos que son comunes para las 3 clases que implementan la interface como son dar una rueda de prensa (ruedaPrensa()) y hacer un vídeo publicitario (videoPublicitario()). Pues bien para ello nos creamos estos dos métodos en la interface y los implementamos ahí; quedando el diagrama de clases de la siguiente manera: [![interface_default_static_jarroba](https://jarroba.com/wp-content/uploads/2014/09/interface_default_static_jarroba.png)](https://jarroba.com/wp-content/uploads/2014/09/interface_default_static_jarroba.png) A nivel de código la interface quedaría implementada de la siguiente manera: ```java public interface IntegranteSeleccionFutbol { void concentrarse(); void viajar(); void entrenar(); void jugarPartido(); default void ruedaPrensa(){ System.out.println(" da una rueda de prensa (desde la Interface)"); } default void videoPublicitario (){ System.out.println(" hacer un video publicitario (desde la Interface)"); } } ``` En el método MAIN nos creamos un objeto de cada clase y ejecutamos los métodos implementados en la interface de la siguiente manera: ```java // ArrayList de objetos SeleccionFutbol. Idenpendientemente de la clase hija a la que pertenezca el objeto public static ArrayList integrantes = new ArrayList(); public static void main(String[] args) { SeleccionFutbol delBosque = new Entrenador(1, "Vicente", "Del Bosque", 60, 28489); SeleccionFutbol iniesta = new Futbolista(2, "Andres", "Iniesta", 29, 6, "Interior Derecho"); SeleccionFutbol raulMartinez = new Masajista(3, "Raúl", "Martinez", 41, "Licenciado en Fisioterapia", 18); integrantes.add(delBosque); integrantes.add(iniesta); integrantes.add(raulMartinez); // RUEDA DE PRENSA CON EL MÉTODO DEFAULT System.out.println("Todos los integrantes dan una rueda de prensa. (Todos ejecutan el mismo método)"); for (SeleccionFutbol integrante : integrantes) { System.out.print(integrante.getNombre() + " " + integrante.getApellidos() + " -> "); integrante.ruedaPrensa(); } // VIDEO PUBLICITARIO CON EL MÉTODO DEFAULT System.out.println("Todos los integrantes graban un video publicitario. (Todos ejecutan el mismo método)"); for (SeleccionFutbol integrante : integrantes) { System.out.print(integrante.getNombre() + " " + integrante.getApellidos() + " -> "); integrante.videoPublicitario(); } ................................... } ``` Como salida a la ejecución de este fragmento de código tenemos el comportamiento implementado en la clase interface: ```text Todos los integrantes dan una rueda de prensa. (Todos ejecutan el mismo método) Vicente Del Bosque -> da una rueda de prensa (desde la Interface) Andres Iniesta -> da una rueda de prensa (desde la Interface) Raúl Martinez -> da una rueda de prensa (desde la Interface) Todos los integrantes graban un video publicitario. (Todos ejecutan el mismo método) Vicente Del Bosque -> hacer un video publicitario (desde la Interface) Andres Iniesta -> hacer un video publicitario (desde la Interface) Raúl Martinez -> hacer un video publicitario (desde la Interface) ``` Como vemos hemos podido implementar un nuevo comportamiento desde una interface y que este se pueda usar en cada una de las clases que implementan esa interface. Por otro lado hemos dicho que con las nuevas interfaces de java 8 podemos simular una "***Seudo Herencia Múltiple***«. Dicho esto hay que matizar un poco estas palabras de la seudo herencia múltiple. Sabemos que la [herencia](https://jarroba.com/herencia-en-la-programacion-orientada-a-objetos-ejemplo-en-java/) "*permite compartir automáticamente los atributos y métodos de la clase padre a las clases hijas*«. Por otro lado sabemos que Java no soporta herencia múltiple ya que solo permite heredar métodos y atributos de una sola clase; es decir, que solo tiene una clase padre. Con las nuevas interfaces de java 8 podemos hacer que una clase implemente todas las interfaces que quiera y al haber métodos «default» en las interfaces, todas las clases que implementen esa interface tendrán esos métodos, los cuales no tendrán que ser sobreescritos. Dicho en otras palabras; ***con las interfaces de java 8 podemos tener herencia múltiple aplicada exclusivamente a métodos, pero no a atributos***. En el proyecto en Java 8 que hemos compartido al principio, hemos implementado un ejemplo para ver esto de la seudo herencia múltiple. Fijémonos en el siguiente diagrama de clases, en el que vemos que tenemos dos interfaces llamadas «DeportistaInterface» e «IntegranteInterface» y en ellas tenemos dos métodos «default». Vemos que «FutbolistaHM» y «EntrenadorHM» implementan las dos interfaces, por lo tanto tendrán los métodos «default» de las dos interfaces; es decir, que es como si heredasen los métodos de la interface. Por otro lado la clase «MasajistaHM» solo implementa la interface «IntegranteInterface» y con esta solo «hereda» los métodos «default» de esta interface. En resumen hemos simulado una herencia de métodos pero no de atributos que hemos «heredado» de la clase interface. [![interface_java8_seudo_herencia_multiple_jarroba](https://jarroba.com/wp-content/uploads/2014/09/interface_java8_seudo_herencia_multiple_jarroba.jpeg)](https://jarroba.com/wp-content/uploads/2014/09/interface_java8_seudo_herencia_multiple_jarroba.jpeg) A continuación vamos a ver como hemos implementado las interfaces: | ```java public interface IntegranteInterface { default void concentrarse() { System.out.println("Concentrarse (Interface IntegranteInterface)"); } default void viajar() { System.out.println("Viajar (Interface IntegranteInterface)"); } } ``` | ```java public interface DeportistaInterface { default void entrenar() { System.out.println("Entrenar (Interface DeportistaInterface)"); } default void jugarPartido() { System.out.println("Jugar Partido (Interface DeportistaInterface)"); } } ``` | | --- | --- | Vemos como hemos implementado en los métodos default un comportamiento que van a «heredar» las clases que implementen esa interface. A continuación mostramos la implementación de las clases «FutbolistaHM», «EntrenadorHM» y «MasajistaHM»: | ```java public class FutbolistaHM extends SeleccionFutbolHM implements DeportistaInterface, IntegranteInterface { private int dorsal; private String demarcacion; // constructor, getter y setter } ``` | ```java public class EntrenadorHM extends SeleccionFutbolHM implements DeportistaInterface, IntegranteInterface { private int idFederacion; // constructor, getter y setter } ``` | ```java public class MasajistaHM extends SeleccionFutbolHM implements IntegranteInterface { private String titulacion; private int aniosExperiencia; // constructor, getter y setter } ``` | | --- | --- | --- | Como vemos, cada una de las clases implementa la interface que le interesa. Veamos ahora como cada una de estas clases ejecuta los métodos de la interface con el siguiente fragmento de código escrito en el método MAIN: ```java // ArrayList de objetos SeleccionFutbol. Idenpendientemente de la clase hija // a la que pertenezca el objeto public static ArrayList integrantes = new ArrayList(); public static void main(String[] args) { SeleccionFutbolHM delBosque = new EntrenadorHM(1, "Vicente", "Del Bosque", 60, 28489); SeleccionFutbolHM iniesta = new FutbolistaHM(2, "Andres", "Iniesta", 29, 6, "Interior Derecho"); SeleccionFutbolHM raulMartinez = new MasajistaHM(3, "Raúl", "Martinez", 41, "Licenciado en Fisioterapia", 18); integrantes.add(delBosque); integrantes.add(iniesta); integrantes.add(raulMartinez); // VIAJE System.out.println("Todos los integrantes viajan para jugar un partido. (Todos ejecutan el mismo método)"); for (SeleccionFutbolHM integrante : integrantes) { System.out.print(integrante.getNombre() + " " + integrante.getApellidos() + " -> "); ((IntegranteInterface) integrante).viajar(); } // ENTRENAR System.out.println("nSolo Del Bosque e Iniesta entrenan ya que el masajista no tienen el método entrenar"); System.out.print(delBosque.getNombre() + " " + delBosque.getApellidos() + " -> "); ((DeportistaInterface) delBosque).entrenar(); System.out.print(iniesta.getNombre() + " " + iniesta.getApellidos() + " -> "); ((DeportistaInterface) iniesta).entrenar(); } ``` Vemos en este fragmento de código que todos son capaces de ejecutar el método "viajar()" de la interface "IntegrantesInterface", ya que todos implementan esta interface y solo los objetos de la clase "FutbolistaHM" y "EntrenadorHM" pueden ejecutar el método "entrenar()" de la interface "DeportistaInterface". Como resultado a este código tenemos lo siguiente: ```text Todos los integrantes viajan para jugar un partido. (Todos ejecutan el mismo método) Vicente Del Bosque -> Viajar (Interface IntegranteInterface) Andres Iniesta -> Viajar (Interface IntegranteInterface) Raúl Martinez -> Viajar (Interface IntegranteInterface) Solo Del Bosque e Iniesta entrenan ya que el masajista no tienen el método entrenar Vicente Del Bosque -> Entrenar (Interface DeportistaInterface) Andres Iniesta -> Entrenar (Interface DeportistaInterface) ``` Esto es un poco en resumen lo que nos permiten hacer las nuevas interfaces de java 8, que nos permiten ser un poco más ágiles a la hora de hacer cambios de última hora y medio simular una herencia múltiple.