Interfaz
Paradigmas de Lenguajes
3er Año LCC- Facultad CEFyN - UNSJ -
Concepto:
Hay situaciones en la ingeniería de software donde es
importante para grupos dispares de programadores
acordar un "contrato" que explica a qué debe
responder su software.
Cada grupo debe poder escribir su código sin ningún
conocimiento de cómo se escribe el código del otro
grupo.
“En términos generales, las interfaces son
contratos”
[Link]
class Modelo
«interface»
Mascota Mov ilidad Persona
- nombre: String «realize»
+ avanzar(): void - nombre: String
+ retroceder(): void
Vehiculo
- patente: String
Ejemplo:
class Modelo
package clases;
«interface»
Mov ilidad public interface Movilidad {
+ avanzar(): void void avanzar();
+ retroceder(): void void retroceder();
}
Una Interfaz:
No puede ser instanciada.
Sus atributos son implícitamente public, static y final
Una interfaz especifica comportamiento y no el estado
de un obj.
Todos los métodos son públicos implícitamente.
(Se puede omitir el modificador. Solo se escribe por claridad)
La clase que implemente los métodos de la interface
debe declararlos como públicos.
class Modelo
«interface»
Mascota Mov ilidad
- nombre: String «realize»
+ avanzar(): void
+ retroceder(): void
Todas las clases cuyos objetos se pueden movilizar deben
implementar la interfaz Movilidad.
Al implementar una interfaz, una clase garantiza que
proporcionará una implementación para todos los métodos
abstractos declarados en la interfaz o la clase se declarará
abstracta.
Una clase puede implementar una o más interfaces utilizando
la palabra clave implements en su declaración.
package modelo;
public class Mascota implements Movilidad {
private String nombre;
{… constructor, getter y setter …}
@Override
public void avanzar() {
[Link](nombre + “ avanza
caminado en 4 patas.”);
}
@Override
public void retroceder() {
[Link](“Caminado.”);
}
public int raza() {…}
}
package modelo; package modelo;
public class Mascota implements Movilidad { public class Persona implements Movilidad {
private String nombre; private String nombre;
{… constructor, getter y setter …} {… constructor, getter y setter …}
@Override @Override
public void avanzar() { public void avanzar() {
[Link](nombre + “ avanza [Link](nombre + “avanza
caminado en 4 patas.”); caminado con dos piernas.”);
} }
@Override @Override
public void retroceder() { public void retroceder() {
[Link](“Caminado.”); [Link](“Caminado.”);
} }
public int raza() {…} public String ocupacion() {…}
} public String intereses() {…}
}
Operaciones:
Movilidad m; // Ok
m = new Movilidad(); // Error
m = new Persona(“Juan”); //Ok
m = new Mascota(“Silvestre”); // Ok
m = new Vehiculo(“AA 170 BB”); // Ok
m = new Object(); // ….
Operaciones:
Movilidad m; // Ok
m = new Movilidad(); // Error
m = new Persona(“Juan”); //Ok
m = new Mascota(“Silvestre”); // Ok
m = new Vehiculo(“AA 170 BB”); // Ok
m = new Object(); // Error
package interfaces;
import modelo.*;
import [Link];
public class Interfaces {
public static void main(String[] args) {
[Link]<Movilidad> m = new ArrayList<>();
[Link](new Persona(“Juan”));
[Link](new Mascota(“Silvestre”));
[Link](new Vehiculo(“AA 170 BB”));
//Dejamos que todos se muevan
mover(m);
}
private static void mover(Movilidad[] m) {
for (Movilidad mover : m) {
[Link]();
}
}
}
Interfaces en Java
Una interfaz puede tener alcance public - o por defecto alcance
package.
Una interfaz es implícitamente abstract - Esta obsoleto usar la
palabra clave explícitamente.
Los miembros de una interfaz son tres:
1. Atributos constantes
2. Métodos, que pueden ser: abstractos, estáticos, predeterminados, privados
3. Clases y/o interfaces anidadas.
Para Java 8 todos los miembros son implícitamente públicos.
Java 9 ya permite tener métodos privados
Ejemplo: Miembros constantes
package [Link];
public interface SwingConstants {
int NORTH = 1;
int NORTH_EAST = 2;
int EAST = 3;
...
}
public static void main(String[] args) {
[Link]([Link]);
}
Ejemplo: Miembros métodos
package clases;
public interface Movilidad {
void avanzar();
void retroceder();
}
… antes de java 8
“Todos los métodos eran abstractos”
El objetivo principal de declarar una interfaz es crear una
especificación abstracta del comportamiento que se espera de
algunos objetos
Nota: pueden incluir parámetros, tipo de retorno y la clausula throws.
Ejemplo: Miembros métodos desde
Java 8 ...
Métodos estáticos: Antes un método estático no encajaba en la vista de las
interfaces como especificaciones abstractas. Ese pensamiento ahora ha
evolucionado.
Son implícitamente públicos.
Solo se puede invocarse usando el nombre de la interfaz:
Porque No se extiende a la clase que la implementa, ni a una subInterface
Metodos por defecto: Agrega funcionalidad a una interfaz y asegura
compatibilidad con la versiones existentes. Provee una implementación
predeterminada para un método de interfaz. Debe etiquetar dicho método con
el modificador default.
La clase que implementa la interfaz “puede sobrescribir o no el método”.
[Link]
Ejemplo: Miembros métodos desde
Java 9 ...
Métodos privados: Pueden solamente ser usados por lo métodos
de la interfaz.
Pueden ser static pero… no puede ser default porque no puede
sobrescribirse.
Modificador Soportado? Descripción
public static Si Soportado desde JDK 8
public abstract Si Soportado desde JDK 1
public default Si Soportado desde JDK 8
private static Si Soportado desde JDK 9
private Si Soportado desde JDK 9. Método no abstracto
Esto no tiene sentido. Un método privado no
private abstract No puede sobrescribirse, y uno abstracto debe
ser sobrescrito.
Esto no tiene sentido. Un método
private default No predeterminado puede sobrescribirse si fuese
necesario.
Cuestiones avanzadas
1. Una clase puede implementar varias interfaces
Si una clase implementa dos interfaces, una de las cuales
tiene un método predeterminado y la otra un método
(predeterminado o no) con el mismo nombre y tipos de
parámetros, entonces la clase debe resolver el conflicto.
1. Una interfaz puede heredar de múltiples
interfaces.
Si hereda el mismo método de dos interfaces (abstract-
default, default - default), debe sobrescribir el método
como abstract o default
Ejercicios: LINK
[Link]
1. ¿Qué métodos debería implementar una clase que implementa
la interfaz [Link]?
2. ¿Cuál es el error con la siguiente interfaz?
public interface SomethingIsWrong {
void unMetodo (int aValue) {
[Link]("Hola Mundo…");
}
}
1. Que cambios haría en la interfaz anterior?
2. ¿Es válida la siguiente interfaz?
public interface Marca {
}
5. Considere la siguiente declaración:
public interface Saludo{
default void saludar() {
[Link]("Hola");
}
}
public class Argentina implements Saludo{
public class Ingles implements Saludo{
@Override
public void saludar() {
[Link](“Hello");
}
}
• Indica posible errores y propone una solución.
• Cual es la salida al ejecutar el código?
Saludo[] a = {new Argentina(), new Ingles()};
a[0].saludar();
a[1].saludar();
6. Escriba una clase que implemente la interfaz CharSequence que se
encuentra en el paquete [Link]. Su implementación debe
devolver la cadena al revés.
Escribe un pequeño método principal para evaluar tu clase;
asegúrese de llamar a los cuatro métodos.
6. Supongamos que ha escrito un servidor de tiempo que notifica
periódicamente a sus clientes sobre la fecha y hora actuales.
Escriba una interfaz que el servidor podría usar para imponer un
protocolo particular en sus clientes.
Referencia: LINK