Breaking

Post Top Ad

Your Ad Spot

jueves, 19 de diciembre de 2019

Interfaz de Java

En este tutorial, aprenderemos sobre las interfaces Java. Aprenderemos cómo implementar interfaces y cuándo usarlas en detalle con la ayuda de ejemplos
En Java, una interfaz define un conjunto de especificaciones que otras clases deben implementar. Por ejemplo,
  1. interface Polygon {
  2. public void getArea();
  3. }
Aquí, Polygon es una interfaz. Hemos utilizado la interfacepalabra clave para declarar una interfaz.
El getArea()método es una especificación definida en la interfaz Polygon . Todas las clases que usan esta interfaz deben implementar el getArea()método.
Una interfaz puede incluir métodos abstractos y constantes. Por ejemplo,
  1. interface Polygon {
  2. public static final String color = "blue";
  3. public void getArea();
  4. }
En el ejemplo anterior, hemos creado una interfaz Polygon . Incluye un color variable constante y un método abstracto getArea().
Es importante tener en cuenta que, todos los métodos dentro de una interfaz están implícitamente publicy todos los campos están implícitamente public static finalPor lo tanto, no es necesario especificar el especificador de acceso dentro de las interfaces. Por ejemplo, podemos escribir el código anterior como
  1. interface Polygon {
  2. String color = "blue";
  3. void getArea();
  4. }

implementa palabra clave en la interfaz

Al igual que las clases abstractas, no podemos crear objetos de interfaces. Sin embargo, podemos implementar interfaces en otras clases. En Java, usamos la implementspalabra clave para implementar interfaces. Por ejemplo,
  1. interface Polygon {
  2. void getArea(int length, int breadth);
  3. }
  4. class Rectangle implements Polygon {
  5. public void getArea(int length, int breadth) {
  6. System.out.println("The area of the rectangle is " + (length * breadth));
  7. }
  8. }
  9. class Main {
  10. public static void main(String[] args) {
  11. Rectangle r1 = new Rectangle();
  12. r1.getArea(5, 6);
  13. }
  14. }
Salida
El área del rectángulo es 30
En el programa anterior, hemos creado una interfaz Polygon . La interfaz Polygon tiene un método abstracto getArea().
Esto significa que cualquier clase que implemente Polygon debe proporcionar una implementación para el getArea()método.
Tenga en cuenta que la clase Rectangle (que implementa la interfaz Polygon ) tiene el método getArea()con implementación.

¿Por qué usar interfaces?

Ahora que sabemos qué son las interfaces, aprendamos por qué las interfaces se usan en Java.
Las interfaces proporcionan especificaciones que una clase (que la implementa) debe seguir.
En nuestro ejemplo anterior, hemos utilizado getArea()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. Por lo tanto, cualquier clase que implemente la interfaz Polygon debe proporcionar una implementación para el getArea()método.
Al igual que las clases abstractas, las interfaces nos ayudan a lograr la abstracción en Java. Aquí, sabemos que 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 el uno del otro.
Las interfaces también se utilizan para lograr la herencia múltiple en Java. Si una subclase se hereda de dos o más clases, es herencia múltiple.
En Java, la herencia múltiple no es posible al extender las clases. Sin embargo, una clase puede implementar múltiples interfaces. Esto nos permite obtener la funcionalidad de herencia múltiple en Java. Por ejemplo,
  1. interface Line {
  2. ...
  3. }
  4. interface Polygon {
  5. ...
  6. }
  7. class Rectangle implements Line, Polygon{
  8. ...
  9. }
Aquí, Rectangle tiene que proporcionar una implementación para todos los métodos de Line y Polygon .

Métodos privados y estáticos en la interfaz

Con el lanzamiento de Java 8, las interfaces ahora pueden incluir métodos estáticos.
Similar a una clase, podemos acceder a métodos estáticos de una interfaz usando sus referencias. Por ejemplo,
  1. Polygon.staticMethod();
Además, las interfaces admiten métodos privados con el lanzamiento de Java 9. Ahora puede usar métodos privados y métodos estáticos privados en las interfaces.
Como no puede crear instancias de interfaces, los métodos privados se utilizan como métodos auxiliares que brindan soporte a otros métodos en las interfaces.

métodos predeterminados en interfaces

Con el lanzamiento de Java 8, se introdujeron métodos con implementación (métodos predeterminados) dentro de una interfaz. Antes de eso, todos los métodos eran abstractos en Java.
Para declarar métodos predeterminados dentro de las interfaces, usamos la defaultpalabra clave. Por ejemplo,
  1. public default void getSides() {
  2. // body of getSides()
  3. }

¿Por qué métodos predeterminados?

Tomemos un escenario para entender por qué los métodos predeterminados se introducen 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 implementaran 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 normales.
Tomemos un ejemplo para comprender mejor los métodos predeterminados.

Ejemplo 2: Método predeterminado

  1. interface Polygon {
  2. void getArea();
  3. default void getSides() {
  4. System.out.println("I can get sides of polygon.");
  5. }
  6. }
  7. class Rectangle implements Polygon {
  8. public void getArea() {
  9. int length = 6;
  10. int breadth = 5;
  11. int area = length * breadth;
  12. System.out.println("The area of the rectangle is "+area);
  13. }
  14. public void getSides() {
  15. System.out.println("I have 4 sides.");
  16. }
  17. }
  18. class Square implements Polygon {
  19. public void getArea() {
  20. int length = 5;
  21. int area = length * length;
  22. System.out.println("The area of the square is "+area);
  23. }
  24. }
  25. class Main {
  26. public static void main(String[] args) {
  27. Rectangle r1 = new Rectangle();
  28. r1.getArea();
  29. r1.getSides();
  30. Square s1 = new Square();
  31. s1.getArea();
  32. }
  33. }
Salida
El área del rectángulo es 30
Tengo 4 lados
El área de la plaza es 25
En el ejemplo anterior, hemos creado una interfaz Polygon . Polygon tiene un método predeterminado getSides()y un método abstracto getArea().
La clase Rectángulo luego implementa Polígono . Rectángulo proporciona una implementación para el método abstracto getArea()y anula el método predeterminado getSides().
Hemos creado otra clase Square que también implementa Polygon . Aquí, Square solo proporciona una implementación para el método abstracto getArea().

Ejemplo práctico de interfaz

Veamos un ejemplo más práctico de la interfaz Java.
  1. // To use the sqrt function
  2. import java.lang.Math;
  3. interface Polygon {
  4. void getArea();
  5. // calculate the perimeter of a Polygon
  6. default void getPerimeter(int... sides) {
  7. int perimeter = 0;
  8. for (int side: sides) {
  9. perimeter += side;
  10. }
  11. System.out.println("Perimeter: " + perimeter);
  12. }
  13. }
  14. class Triangle implements Polygon {
  15. private int a, b, c;
  16. private double s, area;
  17. // initializing sides of a triangle
  18. Triangle(int a, int b, int c) {
  19. this.a = a;
  20. this.b = b;
  21. this.c = c;
  22. s = 0;
  23. }
  24. // calculate the area of a triangle
  25. public void getArea() {
  26. s = (double) (a + b + c)/2;
  27. area = Math.sqrt(s*(s-a)*(s-b)*(s-c));
  28. System.out.println("Area: " + area);
  29. }
  30. }
  31. class Main {
  32. public static void main(String[] args) {
  33. Triangle t1 = new Triangle(2, 3, 4);
  34. // calls the method of the Triangle class
  35. t1.getArea();
  36. // calls the method of Polygon
  37. t1.getPerimeter(2, 3, 4);
  38. }
  39. }
Salida
Área: 2.9047375096555625
Perímetro: 9
En el programa anterior, hemos creado una interfaz Polygon . Incluye un método predeterminado getParameter()y un método abstracto getArea().
Podemos calcular el perímetro de todos los polígonos de la misma manera por lo que se implementó el cuerpo de getPerimeter()en Polígono . Ahora, todos los polígonos que implementan Polygon pueden usar getPerimeter()para calcular el perímetro.
Sin embargo, el área se calcula de manera diferente para diferentes polígonos, ya que la regla para calcular el área es diferente para diferentes polígonos. Por lo tanto, getArea()se incluye sin implementación en Polygon . Y, cualquier clase que implemente la interfaz Polygon debe proporcionar una implementación de getArea().

extiende la palabra clave en la interfaz

Similar a las clases, las interfaces pueden extender otras interfaces. La extendspalabra clave se utiliza para ampliar las interfaces. Por ejemplo,
  1. interface Line {
  2. //members of Line interface
  3. }
  4. interface Polygon extends Line {
  5. //members of Polygon interface and Line interface
  6. }
En el ejemplo anterior, la interfaz Polygon extiende la interfaz Line . Ahora, si una clase implementa Polygon , debería proporcionar implementaciones para todas las clases abstractas de Line y Polygon .
Tenga en cuenta que una interfaz puede extender múltiples interfaces similares a una clase que implementa múltiples interfaces. Por ejemplo,
  1. interface A {
  2. ...
  3. }
  4. interface B {
  5. ...
  6. }
  7. Interface C extends A, B {
  8. ...
  9. }

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Post Top Ad

Your Ad Spot

Páginas