En este tutorial, aprenderemos sobre las interfaces de Java. Aprenderemos cómo implementar interfaces y cuándo usarlas en detalle con la ayuda de ejemplos.
Una interfaz es una clase completamente abstracta que incluye un grupo de métodos sin cuerpo.
En Java, una interfaz define un conjunto de especificaciones que deben implementar otras clases. Por ejemplo,
interface Language ( public void getName(); )
Aquí, hemos utilizado la interfacepalabra clave para crear una interfaz llamada Idioma. La interfaz de idioma define una especificación getName().
Ahora, cada clase que use esta interfaz debería implementar la getName()especificación.
Ejemplo: interfaz Java
// create an interface interface Language ( void getName(String name); ) // class implements interface class ProgrammingLanguage implements Language ( // implementation of abstract method public void getName(String name) ( System.out.println("Programming Language: " + name); ) ) class Main ( public static void main(String() args) ( ProgrammingLanguage language = new ProgrammingLanguage(); language.getName("Java"); ) )
Salida
Lenguaje de programación: Java
En el ejemplo anterior, hemos creado una interfaz denominada Idioma. La interfaz incluye un método abstracto getName().
Aquí, la clase ProgrammingLanguage implementa la interfaz y proporciona la implementación del método.
No es obligatorio utilizar abstractpalabras clave al declarar métodos abstractos dentro de una interfaz. Es porque una interfaz solo incluye métodos abstractos, no métodos regulares.
Nota : Todos los métodos dentro de una interfaz son implícitos publicy todos los campos son implícitos public static final. Por ejemplo,
interface Language ( // by default public static final String type = "programming language"; // by default public void getName(); )
Implementar una interfaz
Como las clases abstractas, no podemos crear objetos de una interfaz. Sin embargo, podemos implementar una interfaz.
Usamos la implementspalabra clave para implementar una interfaz. Por ejemplo,
// create an interface interface Polygon ( void getArea(int length, int breadth); ) // implement the Polygon interface class Rectangle implements Polygon ( // implementation of abstract method public void getArea(int length, int breadth) ( System.out.println("The area of the rectangle is " + (length * breadth)); ) ) class Main ( public static void main(String() args) ( // create an object Rectangle r1 = new Rectangle(); r1.getArea(5, 6); ) )
Salida
El área del rectángulo es 30
En el ejemplo anterior, hemos creado una interfaz llamada Polygon. La interfaz contiene un método abstracto getArea().
Aquí, la clase Rectangle implementa Polygon. Y proporciona la implementación del getArea()método.
Nota : una clase puede implementar múltiples interfaces. Por ejemplo,
interface A ( // members of A ) interface B ( // members of B ) class C implements A, B ( // abstract members of A // abstract members of B )
Ampliación de una interfaz
Al igual que las clases, las interfaces pueden ampliar otras interfaces. La extendspalabra clave se utiliza para ampliar interfaces. Por ejemplo,
interface Line ( // members of Line interface ) // extending interface interface Polygon extends Line ( // members of Polygon interface // members of Line interface )
Aquí, la interfaz Polygon amplía la interfaz Line. Ahora, si alguna clase implementa Polygon, debería proporcionar implementaciones para todos los métodos abstractos de Line y Polygon.
Nota : una interfaz puede ampliar varias interfaces. Por ejemplo,
interface A (… ) interface B (… ) interface C extends A, B (… )
Ventajas de la interfaz en Java
Ahora que sabemos qué son las interfaces, aprendamos por qué se utilizan las interfaces en Java.
- Las interfaces proporcionan especificaciones que debe seguir una clase (que las implementa).
En nuestro ejemplo anterior, lo hemos utilizadogetArea()como especificación dentro de la interfaz Polygon. Esto es como establecer una regla que debería poder obtener el área de cada polígono.
Ahora, cualquier clase que implemente la interfaz Polygon debe proporcionar una implementación para elgetArea()método. - De manera similar a las clases abstractas, las interfaces nos ayudan a lograr la abstracción en Java .
Aquí, sabemos quegetArea()calcula el área de polígonos, pero la forma en que se calcula el área es diferente para diferentes polígonos. Por lo tanto, la implementación degetArea()es independiente entre sí. - Las interfaces también se utilizan para lograr una herencia múltiple en Java. Por ejemplo,
interface Line (… ) interface Polygon (… ) class Rectangle implements Line, Polygon (… )
Aquí, la clase Rectangle implementa dos interfaces diferentes. Así es como logramos la herencia múltiple en Java.
métodos predeterminados en interfaces Java
Con el lanzamiento de Java 8, ahora podemos agregar métodos con implementación dentro de una interfaz. Estos métodos se denominan métodos predeterminados.
Para declarar métodos predeterminados dentro de las interfaces, usamos la defaultpalabra clave. Por ejemplo,
public default void getSides() ( // body of getSides() )
¿Por qué métodos predeterminados?
Tomemos un escenario para entender por qué se introducen métodos predeterminados en Java.
Supongamos que necesitamos agregar un nuevo método en una interfaz.
Podemos agregar el método en nuestra interfaz fácilmente sin implementación. Sin embargo, ese no es el final de la historia. Todas nuestras clases que implementan esa interfaz deben proporcionar una implementación para el método.
Si una gran cantidad de clases estaban implementando esta interfaz, necesitamos rastrear todas estas clases y hacer cambios en ellas. Esto no solo es tedioso sino también propenso a errores.
Para resolver esto, Java introdujo métodos predeterminados. Los métodos predeterminados se heredan como los métodos ordinarios.
Tomemos un ejemplo para comprender mejor los métodos predeterminados.
Ejemplo: método predeterminado en la interfaz Java
interface Polygon ( void getArea(); // default method default void getSides() ( System.out.println("I can get sides of a polygon."); ) ) // implements the interface class Rectangle implements Polygon ( public void getArea() ( int length = 6; int breadth = 5; int area = length * breadth; System.out.println("The area of the rectangle is " + area); ) // overrides the getSides() public void getSides() ( System.out.println("I have 4 sides."); ) ) // implements the interface class Square implements Polygon ( public void getArea() ( int length = 5; int area = length * length; System.out.println("The area of the square is " + area); ) ) class Main ( public static void main(String() args) ( // create an object of Rectangle Rectangle r1 = new Rectangle(); r1.getArea(); r1.getSides(); // create an object of Square Square s1 = new Square(); s1.getArea(); s1.getSides(); ) )
Salida
El área del rectángulo es 30. Tengo 4 lados. El área del cuadrado es 25. Puedo obtener los lados de un polígono.
In the above example, we have created an interface named Polygon. It has a default method getSides() and an abstract method getArea().
Here, we have created two classes Rectangle and Square that implement Polygon.
The Rectangle class provides the implementation of the getArea() method and overrides the getSides() method. However, the Square class only provides the implementation of the getArea() method.
Now, while calling the getSides() method using the Rectangle object, the overridden method is called. However, in the case of the Square object, the default method is called.
private and static Methods in Interface
The Java 8 also added another feature to include static methods inside an interface.
Similar to a class, we can access static methods of an interface using its references. For example,
// create an interface interface Polygon ( staticMethod()(… ) ) // access static method Polygon.staticMethod();
Note: With the release of Java 9, private methods are also supported in interfaces.
We cannot create objects of an interface. Hence, private methods are used as helper methods that provide support to other methods in interfaces.
Practical Example of Interface
Let's see a more practical example of Java Interface.
// To use the sqrt function import java.lang.Math; interface Polygon ( void getArea(); // calculate the perimeter of a Polygon default void getPerimeter(int… sides) ( int perimeter = 0; for (int side: sides) ( perimeter += side; ) System.out.println("Perimeter: " + perimeter); ) ) class Triangle implements Polygon ( private int a, b, c; private double s, area; // initializing sides of a triangle Triangle(int a, int b, int c) ( this.a = a; this.b = b; this.c = c; s = 0; ) // calculate the area of a triangle public void getArea() ( s = (double) (a + b + c)/2; area = Math.sqrt(s*(s-a)*(s-b)*(s-c)); System.out.println("Area: " + area); ) ) class Main ( public static void main(String() args) ( Triangle t1 = new Triangle(2, 3, 4); // calls the method of the Triangle class t1.getArea(); // calls the method of Polygon t1.getPerimeter(2, 3, 4); ) )
Output
Area: 2.9047375096555625 Perimeter: 9
In the above program, we have created an interface named Polygon. It includes a default method getPerimeter() and an abstract method getArea().
We can calculate the perimeter of all polygons in the same manner so we implemented the body of getPerimeter() in Polygon.
Now, all polygons that implement Polygon can use getPerimeter() to calculate perimeter.
Sin embargo, la regla para calcular el área es diferente para diferentes polígonos. Por lo tanto, getArea()se incluye sin implementación.
Cualquier clase que implemente Polygon debe proporcionar una implementación de getArea().
