Interfaz Java

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. Incluye un grupo de métodos abstractos (métodos sin cuerpo).

Usamos el interface palabra clave para crear una interfaz en Java. Por ejemplo,

interface Language {
  public void getType();

  public void getVersion();
}

Aquí,

Idioma es una interfaz.
Incluye métodos abstractos:getType() y getVersion() .

Implementación de una interfaz

Al igual que las clases abstractas, no podemos crear objetos de interfaces.

Para usar una interfaz, otras clases deben implementarla. Usamos el implements palabra clave para implementar una interfaz.

Ejemplo 1:Interfaz Java

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) {
    Rectangle r1 = new Rectangle();
    r1.getArea(5, 6);
  }
}

Salida

The area of the rectangle is 30

En el ejemplo anterior, hemos creado una interfaz llamada Polygon . La interfaz contiene un método abstracto getArea() .

Aquí, el Rectángulo clase implementa Polígono . Y proporciona la implementación del getArea() método.

Ejemplo 2: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

Programming Language: Java

En el ejemplo anterior, hemos creado una interfaz llamada Idioma . La interfaz incluye un método abstracto getName() .

Aquí, el ProgrammingLanguage La clase implementa la interfaz y proporciona la implementación del método.

Implementación de múltiples interfaces

En Java, una clase también 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 extender otras interfaces. El extends La palabra clave se utiliza para ampliar las interfaces. Por ejemplo,

interface Line {
  // members of Line interface
}

// extending interface
interface Polygon extends Line {
  // members of Polygon interface
  // members of Line interface
}

Aquí, el Polígono la interfaz extiende la Línea interfaz. Ahora, si alguna clase implementa Polygon , debería proporcionar implementaciones para todos los métodos abstractos de Line y Polígono .

Extensión de múltiples interfaces

Una interfaz puede extender múltiples 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 usan las interfaces en Java.

Al igual que las clases abstractas, las interfaces nos ayudan a lograr abstracción en Java .

Aquí conocemos getArea() calcula el área de los polígonos, pero la forma en que se calcula el área es diferente para diferentes polígonos. Por lo tanto, la implementación de getArea() es independiente uno del otro.
Las interfaces proporcionan especificaciones que una clase (que lo implementa) debe seguir.

En nuestro ejemplo anterior, hemos usado getArea() como especificación dentro de la interfaz Polygon . Esto es como establecer una regla de que deberíamos poder obtener el área de cada polígono.

Ahora cualquier clase que implemente el Polygon la interfaz debe proporcionar una implementación para el getArea() método.
Las interfaces también se utilizan para lograr la herencia múltiple en Java. Por ejemplo,
```
interface Line {
…
}

interface Polygon {
…
}

class Rectangle implements Line, Polygon {
…
}
```
Aquí, la clase Rectángulo está implementando dos interfaces diferentes. Así es como logramos la herencia múltiple en Java.

Nota :Todos los métodos dentro de una interfaz son implícitamente public y todos los campos son implícitamente public static final . Por ejemplo,

interface Language {
  
  // by default public static final
  String type = "programming language";

  // by default public
  void getName();
}

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 el default palabra clave. Por ejemplo,

public default void getSides() {
   // body of getSides()
}

¿Por qué métodos predeterminados?

Consideremos un escenario para comprender 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 estuvieran implementando esta interfaz, necesitamos realizar un seguimiento de todas estas clases y realizar 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 métodos ordinarios.

Tomemos un ejemplo para comprender mejor los métodos predeterminados.

Ejemplo:Método predeterminado en la interfaz de 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

The area of the rectangle is 30
I have 4 sides.
The area of the square is 25
I can get sides of a polygon.

En el ejemplo anterior, hemos creado una interfaz llamada Polygon . Tiene un método por defecto getSides() y un método abstracto getArea() .

Aquí, hemos creado dos clases Rectangle y Cuadrado que implementan Polygon .

El Rectángulo class proporciona la implementación del getArea() y anula el getSides() método. Sin embargo, el Cuadrado class solo proporciona la implementación de getArea() método.

Ahora, mientras llama al getSides() método usando el Rectángulo objeto, se llama al método invalidado. Sin embargo, en el caso del Cuadrado objeto, se llama al método predeterminado.

Métodos privados y estáticos en la interfaz

Java 8 también agregó otra característica para incluir métodos estáticos dentro de una interfaz.

Similar a una clase, podemos acceder a métodos estáticos de una interfaz utilizando sus referencias. Por ejemplo,

// create an interface
interface Polygon {
  staticMethod(){..}
}

// access static method
Polygon.staticMethod();

Nota :Con el lanzamiento de Java 9, los métodos privados también son compatibles con las interfaces.

No podemos crear objetos de una interfaz. Por lo tanto, los métodos privados se utilizan como métodos auxiliares que brindan soporte a otros métodos en las interfaces.

Ejemplo Práctico de Interfaz

Veamos un ejemplo más práctico de Interfaz Java.

// 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);
   }
}

Salida

Area: 2.9047375096555625
Perimeter: 9

En el programa anterior, hemos creado una interfaz llamada Polygon . Incluye un método por defecto getPerimeter() y un método abstracto getArea() .

Podemos calcular el perímetro de todos los polígonos de la misma manera, por lo que implementamos el cuerpo de getPerimeter() en Polígono .

Ahora, todos los polígonos que implementan Polygon puede usar getPerimeter() para calcular el perímetro.

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() .

Clase abstracta de Java y métodos abstractos Polimorfismo de Java

Java