Interfaces

"¡Hola, amigo! Hoy vas a hacer algunos descubrimientos. El tema de hoy, redoble de tambores, por favor, es interfaces " .

"Sí. Un día tan maravilloso que me dirijo a casa para tomar un baño".

" Una interfaz es hija de Abstracción y Polimorfismo. La interfaz es muy parecida a una clase abstracta donde todos los métodos son abstractos. Se declara de la misma manera que una clase, pero con la palabra clave . Aquí hay algunos ejemplos: interface"

interface Drawable
{
void draw();
}
interface HasValue
{
int getValue();
}

interface Element extends Drawable, HasValue
{
int getX();
int getY();
}

class abstract ChessItem implements Drawable, HasValue
{
private int x, y, value;

public int getValue()
{
return value;
}

public int getX()
{
return x;
}

public int getY()
{
return y;
}

}

"Interesante. Pero, ¿por qué necesitamos interfaces? ¿Cuándo se usan?"

"Las interfaces tienen dos fuertes ventajas sobre las clases:"

1) Separación de "definiciones de métodos" de implementaciones de métodos.

Anteriormente le dije que si desea permitir que otras clases llamen a los métodos de su clase, debe marcarlos comopublic . Si desea que determinados métodos se llamen solo desde su propia clase, deben marcarse como private. En otras palabras, estamos dividiendo los métodos de la clase en dos categorías: «para todos» y «solo para mí».

Podemos usar interfaces para fortalecer aún más esta separación. Haremos una "clase para todos" especial que heredará una segunda "clase solo para mí". Eso se vería así:

class Student
{
 private String name;

 public Student(String name)
 {
  this.name = name;
 }

 public String getName()
 {
  return this.name;
 }

 private void setName(String name)
 {
  this.name = name;
 }

interface Student
{
 public String getName();
}

class StudentImpl implements Student
{
 private String name;
 public StudentImpl(String name)
 {
  this.name = name;
 }
 public String getName()
 {
  return this.name;
 }
 private void setName(String name)
 {
  this.name = name;
 }
}

public static void main(String[] args)
{
 Student student =
               new Student("Alibaba");
 System.out.println(student.getName());
}

public static void main(String[] args)
{
 Student student =
               new StudentImpl("Ali");
 System.out.println(student.getName());
}

Dividimos nuestra clase en dos partes: una interfaz y una clase que implementa la interfaz.

"Entonces, ¿cuál es la ventaja?"

"La misma interfaz puede ser implementada (heredada) por diferentes clases. Y cada clase puede tener su propio comportamiento. Al igual que ArrayList y LinkedList , son dos implementaciones diferentes de la interfaz List " .

Por lo tanto, estamos ocultando no solo las diferentes implementaciones, sino también las clases que contienen las implementaciones (podemos usar interfaces en todas partes del código). Esto nos permite reemplazar de manera muy flexible algunos objetos con otros objetos mientras el programa se está ejecutando, cambiando el comportamiento de un objeto sin el conocimiento de ninguna de las clases que lo usan.

En combinación con el polimorfismo, esta es una técnica muy poderosa. Por el momento, está lejos de ser obvio por qué tendríamos que hacer esto. Primero debe encontrar programas que consisten en docenas o cientos de clases para apreciar cómo las interfaces pueden simplificar enormemente su vida.

2) Herencia múltiple.

En Java, cada clase solo puede tener una clase principal. En otros lenguajes de programación, las clases a menudo pueden tener varias clases principales. Esto es muy conveniente, pero también crea muchos problemas.

Java ofrece un compromiso:   no puede heredar varias clases, pero puede implementar varias interfaces. Una interfaz puede tener varias interfaces principales.  Una clase puede implementar múltiples interfaces y heredar solo una clase principal.