Cuando creamos una interface, lo que estamos realizando es un contrato de lo que la clase que implementa dicha interface tiene que hacer sin decir nada acerca de como la clase lo hará, en pocas palabras la interface indica que se va a hacer y la clase que implementa dicha interface indica como se va implementar, de esto concluimos que una interface es un contrato que la clase que lo implementa debe de cumplir. Por ejemplo si tenemos la interface Imprimible definida de la siguiente manera:
public interface Imprimible{
public void imprimirAPdf();
public void imprimirAExcel();
}
Y una clase Libro que implementa la interface anterior de la siguiente manera:
public class Libro implements Imprimible{
public void imprimirAPdf(){
-- Aqui va el código que imprime el libro en formato pdf
}
public void imprimirAExcel(){
-- Aqui va el código que imprime el libro en formato excel
}
}
La clase al implementar la interface debe de cumplir con el contrato, es decir debe de proveer una forma de implementación para cada uno de los métodos de la interface, en el ejemplo vemos que la clase implementa los métodos declarando código entre las llaves de apertura y cerradura de dichos métodos, en la interface después de los parentesis termina su declaración con un punto y coma.
Podemos pensar en las interfaces como clases 100% abstractas, asi como una clase abstracta una interface define métodos abstractos que toman la siguiente forma:
abstract void nombreMetodo();
Pero mientras que una clase abstracta puede definir tanto métodos abstractos como no abstractos, una interface solo puede tener métodos abstractos, es decir podemos tener una clase abstracta de la siguiente manera:
public abstract class Libro{
-- Método abstracto:
public abstract void calcularCosto();
-- Método no abstracto:
public void calcularVentas(){
--Aquí la implementación del método.
}
}
Pero no podemos hacer una interface parcialmente abstracta, las interfaces son 100% abstractas, es decir todos sus métodos son abstractos(no tienen una implementación { ... } ), por lo que la siguiente interface es incorrecta:
public interface Imprimible{
-- Método abstracto:
public abstract void imprimirAPdf();
-- Método no abstracto:
public void imprimirAExcel(){
--Aquí la implementación del método.
}
}
Algunas reglas más sobre la declaración de las interfaces son las siguientes:
1. Todos los métodos de las interfaces son implicitamente públicos y abstractos, en otras palabras no necesitamos escribir los modificadores public y abstract en la declaración del método, el método siempre será públic y abstracto. Veamos, si tenemos la siguiente interface:
public interface Imprimible{
void imprimirAPdf();
int imprimirAExcel();
}
Entonces lo que el compilador realmente analizará es:
public interface Imprimible{
public abstract void imprimirAPdf();
public abstract int imprimirAExcel();
}
2. Todas las variables definidas en una interface deben ser públicas estáticas y finales, en otras palabras las interfaces pueden declarar solo constantes, no variables de instancia.
--Recordar una variable de instancia;
public class Libro{
-- variable de instancia:
private int ancho;
}
3. Los métodos de las interfaces no deben ser estáticos. No podemos hacer lo siguiente:
public interface Imprimible{
public static void imprimir();
}
4. Como los métodos de las interfaces son abstractos entonces no podemos definirlos tambien como finales final, strictfp ó native.
5. Una interface puede extender una o más interfaces, es decir podemos hacer lo siguiente:
public interface interface1{
void metodo1();
}
public interface interface2{
void metodo2();
}
public interface interface3 extends interface1,interface2{
void metodo1();
void metodo2();
void metodo3();
}
6. Una interface solo puede extender interfaces no puede extender clases, por ejemplo si tenemos la clase:
public class Descargable{
protected int descargar(){
-- XXX
}
}
entonces la siguiente declaración de interface es incorrecta:
public interface interface3 extends Descargable{
protected int descargar();
}
7. Una interface no puede implementar otra interface o una clase, no podemos hacer lo siguiente:
public interface interface3 implements interface1,interface2{
void metodo1();
void metodo2();
void metodo3();
}
8. Una interface debe ser declarada con la palabra clave interface.
Declarando constantes en interfaces
Nosotros podemos declarar constantes en una interface, haciendolo garantizamos que cualquier clase que implementa la interface tendrá acceso a la misma constante, la regla principal para las constantes es la siguiente:
public static final = ;
Por ejemplo si tenemos la siguiente interface:
public interface Imprimible{
int ancho = 100;
int largo = 170;
public void imprimir( );
}
y la siguiente clase:
public class Libro implements Imprimible{
public void imprimir(){
--Nosotros podemos usar las constantes
System.out.println(ancho*largo):
--Pero no podemos asignarles un valor porque las declaraciones int ancho = 100;
--el compilador lo analiza como public static final int ancho = 100; es decir es
--declarado como final y estático ya no podemos modificarlo, por lo tanto es incorrecto:
ancho = 666;
}
}
