4.3 DECLARACIÓN DE INTERFACES

CLICK AQUI PARA REGRESAR AL ÍNDICE

 DECLARACIÓN DE INTERFACES

Cuando se crea una interface, se está definiendo un “contrato” por el cual se establece lo que una clase puede hacer, sin hacer mención de como la clase lo hará.

Por ejemplo, puedes crear una interface llamada Bounceable, y todas las clases que implementen estar interfaz tienen que tener codificada todos los métodos definidos en esta clase.

Las interfaces pueden ser implementadas por todas las clases de cualquier árbol de herencia. Esto te deja tener clases radicalmente diferentes y darles un comportamiento común.

Por ejemplo puedes tener dos clases, una llamada Balon y otra llamada Neumatico, ninguna de estas clases viene de las misma línea de herencia, ni existe relación entre ambas, por ejemplo Balon es una subclase de la superclase Juguete y Neumatico es una subclase de java.lang.Object. Pero haciendo que las clases Neumatico y Balon implementen la interface Bounceable, se está diciendo que ambas clases Neumatico y Balon, son cosas que pueden rebotar (sino sabias Bounceable es el inglés de rebotable, es decir la capacidad de algo de rebotar :D).

La siguiente figura ilustra la relación entre las clases y las interfaces:

Se debe pensar en un interface como en 100% clase abstracta, ya que como una abstract class una interface define métodos abstractos con la siguiente forma:

Abstract void rebotar();  //Termina con un punto y coma en vez de con corchetes

Pero mientras una class abstract puede defibir tanto métodos abstractos como métodos no-abstractos, una interface solo puede definir abstract metódos.

A continuación se muestran algunas reglas para definir una interface:

• Todos los métodos de las interfaces son public y abstract.
• Todas las variables definifas en una interface deben de ser public, static y final, en otras palabras solo se puede declaran constantes, no variables de instancia.
• Los métodos de una interface no deben de ser nunca static.
• Ya que los métodos de una interface son abstract, ellos no pueden ser marcados con final, strictfp o native (Estos modificadores se verán después)
• Una interface solo puede extender de otras interface.
• Una interface no puede implementar ninguna otra clase o interface.
• Una interface debe ser declarada con la palabra reservada interface.
• Los tipo interface pueden ser usados polifórmicamente (Se verá más adelante)

La siguiente es una correcta declaración de un interface:

public abstract interface Rollable { }

Tipear abstract es considerado redundante, ya que por definición una interface es abstract, ya sea se ponga el modificador o no. Entonces la declaración podría ser también:

Public interface Rollable { }

Ahora para hacer un poco más interesante el código agreguemos algunos métodos:

public interface Rollable {
public abstract void bounce();
public abstract void setBounceFactor();
 }

Pero otra vez poner public  y abstract en la declaración de un método dentro de una iinterfaz, es redundante ya que por definición un método en una interface es abstract y public. Entonces la declaración podría ser también:

public interface Rollable {
void bounce();
void setBounceFactor();
 }

Ejemplos de otras declaraciones correctas para métodos en una interface:

void bounce();
public void bounce();
abstract void bounce();
abstract public bounce();

Ejemplos de otras declaraciones incorrectas para métodos en una interface:

final void bounce();
static void bounce();
private void bounce();
protected void bounce();

DECLARACION CONSTANTES EN UNA INTERFACE

Se permite poner constantes en una interface, ya que haciendo eso se garantiza que todas las clases que implementan la interface tengan acceso a las mismas constantes declaradas ahí.
La única regla que debes recordar es que las constantes en una interface, son siempre:

public static final

Sin importar si pones esos modificadores o no, en la declaración de las constante.

Como ejemplo te dejo declaraciones de constantes en una interface, todas son correctas y son la misma declaración:

public int x = 1; // No parecen ser static o final, pero lo son
int x = 1; // No parecen ser static, public o final, pero lo son
static int x = 1; // No se muestra final o public
final int x = 1; // No se muestra static o public
public static int x = 1; // No se muestra  final
public final int x = 1; // No se muestra static
static final int x = 1 // No se muestra public
public static final int x = 1; //Declaración correcta pero redundante