laboratorio de interfaces

1. INTERFACES
Se ha preguntado ¿qué haría si varias clases que no están relacionadas por medio de superclases, necesitan
cumplir con el mismo diseño? Las interfaces definen y estandarizan las formas en que pueden interactuar los
objetos y clases entre sí.
Los objetos de software también se comunican a través de interfaces. Una interfaz de Java describe un
conjunto de métodos (y constantes) que pueden llamarse sobre un objeto; por ejemplo, para indicar al objeto
que realice cierta tarea, o que devuelva cierta pieza de información.
La declaración de una interfaz empieza con la palabra clave interface y sólo puede contener constantes y
métodos abstract. A diferencia de las clases, todos los miembros de la interfaz deben ser public, y las
interfaces no pueden especificar ningún detalle de implementación, como las declaraciones de métodos
concretos y variables de instancia. Todos los métodos que se declaran en una interfaz son public y abstract de
manera implícita, y todos los campos son implícitamente public, static y final.
Es un estilo apropiado declarar los métodos de una interfaz sin las palabras clave public y abstract, ya
que son redundantes en las declaraciones de los métodos de la interfaz. De manera similar, las constantes
deben declararse sin las palabras clave public, static y final, ya que también son redundantes.
Para utilizar una interfaz, una clase debe especificar que implementa (implements) a esa interfaz y debe
declarar cada uno de sus métodos con la firma especificada en la declaración de la interfaz. Para especificar
que una clase implementa a una interfaz, agregamos la palabra clave implements y el nombre de la interfaz al
final de la primera línea de la declaración de nuestra clase. Una clase que no implementa a todos los métodos
de la interfaz es una clase abstracta, y debe declararse como abstract. Implementar una interfaz es como
firmar un contrato con el compilador que diga, “Declararé todos los métodos especificados por la interfaz, o
declararé mi clase como abstract”.
Por lo general, una interfaz se utiliza cuando clases dispares (es decir, no relacionadas) necesitan
compartir métodos y constantes comunes. Esto permite que los objetos de clases no relacionadas se
procesen en forma polimórfica; los objetos de clases que implementan la misma interfaz pueden responder a
las mismas llamadas a métodos. Usted puede crear una interfaz que describa la funcionalidad deseada y
después implementar esta interfaz en cualquier clase que requiera esa funcionalidad.
A menudo, una interfaz se utiliza en vez de una clase abstract cuando no hay una implementación
predeterminada que heredar, esto es, no hay campos ni implementaciones de métodos predeterminados.
UML expresa la relación entre una clase y una interfaz a través de una relación conocida como realización. Se
dice que una clase “realiza”, o implementa, los métodos de una interfaz. En la siguiente figura se muestra un
ejemplo de esta relación.
Lenguaje de
programación
Técnica profesional en desarrollo de software
Profesor: Andrés Herrera R. Mail: jherrera@eam.edu.co
Laboratorio
Polimorfismo
Nombre:_________________________________________________________________________

2. 2
Figura 1. Ejemplo de representación gráfica de la interfaz.
En la Figura 1 se puede interpretar que la configuración de la impresora usa un diseño que ofrece la
impresora.
Todos los objetos de una clase que implementan varias interfaces tienen la relación es un con cada tipo de
interfaz implementada. Al utilizar una referencia a la interfaz, podemos invocar de manera polimórfica a
cualquier método declarado en la interfaz y en la clase Object; una variable de un tipo de interfaz debe
hacer referencia a un objeto para llamar a los métodos, y todos los objetos contienen los métodos de la
clase Object.
Es importante aclara que, a diferencia de la herencia, un objeto en Java si puede implementar varias
interfaces al tiempo. A continuación, se muestra un ejemplo de cómo sería la estructura del código:
public class NombreClase extends NombreSuperClase implements
Primeralnterfaz,Segundalnterfaz, ...
Una clase puede implementar todas las interfaces que requiera,
simulando un poco la herencia múltiple, tal como se muestra en el siguiente gráfico.
Figura 2. Simulación de la herencia múltiple en Java.
Patrón: interfaces marcadoras (etiquetado de interfaces)
Una interfaz marcadora es una interfaz que no contiene ningún método. A priori esto puede parecer
extraño y algunos incluso lo consideran un antipatrón, ya que un interfaz por definición es un contrato, y un
contrato que no dice nada es un contrato un poco raro. Al implementar la interfaz no necesitamos implementar
ningún método, simplemente estamos marcando (de ahí el nombre) la clase como una implementación del
interfaz.
La ventaja de esta solución es que nos permite aprovechar la comprobación de tipos en tiempo de
compilación para asegurarnos de que ciertas operaciones sólo se realizan sobre las clases adecuadas. Un
ejemplo de este patrón es la interfaz Serializable.

3. 3
Interfaces más comunes de Java
INTERFAZ DESCRIPCIÓN
Comparable La interfaz Comparable se utiliza para permitir que los objetos de una clase
que implementa a la interfaz se comparen entre sí. La interfaz Comparable
se utiliza comúnmente para ordenar objetos en una colección, como un
arreglo.
Serializable Una interfaz que se utiliza para identificar clases cuyos objetos pueden
escribirse en (serializarse), o leerse desde (deserializarse) algún tipo de
almacenamiento (archivo en disco, campo de base de datos) o transmitirse
a través de una red.
Runnable La implementa cualquier clase para la cual sus objetos deban poder
ejecutarse en paralelo, usando una técnica llamada multihilos.
Interfaces de
escucha de eventos
de la GUI
Cada interfaz de escucha de eventos especifica uno o más métodos que
deben implementarse para responder a las interacciones de los usuarios.
SwingConstants Contiene un conjunto de constantes que se utilizan en la programación de
GUI para posicionar los elementos de la GUI en la pantalla.
PRACTICA
1- Cree un proyecto que con nombre <<Prueba-Comparable>>.
2- Cree un paquete de nombre <<com.eam.lenguaje>>. Dentro del anterior paquete cree los paquetes <<vo>> y
<<business>>.
3- Agregue en <<vo>> la clase Estudiante y añada como atributo de clase id, nombre, edad y promedio de notas. Programe el
método constructor con todos los parámetros, además todos los métodos get y set.
4- Cree en el paquete <<business>> la clase LenguajeDeProgramacion y añada como atributo de clase una ArrayList de
Estudiantes. Programe el método constructor de la clase.
5- Inicialice en el método constructor siete estudiantes diferentes y agréguelos en el ArrayList.
6- Programe un método que muestre por consola los nombre y las notas de cada estudiante.
7- Programe un método que ordene el ArrayList de estudiantes de menor a mayor según su nombre.
8- Implemente en la clase Estudiante la interfaz Comparable y su método obligatorio. Modifique el método compareTo por lo
siguiente:
@Override
public int compareTo(Estudiante o) {
if( o.getNombre().compareTo(nombre) > 0 )
return -1;
else
return 1;
}
Agregue la siguiente línea de código, ¿en que consiste su funcionamiento?

4. 4
9- Programé la clase Aplicación y cree en ella el método main. Llame y compruebe el funcionamiento de los métodos
programados.
El uso de interfaces permite acelerar el desarrollo de software tal y como se puedo notar con Comparable. Ahora es
momento de identificar como se debe implementar una interfaz.
------------------------------------------------------------------------------------------------------------
10- Cree un proyecto de nombre <<Empresa>>. Recuerde que todas las clases e interfaces se debe documentar.
11- Cree un paquete de nombre <<com.eam.isyc.lenguaje.empresa>>. Dentro cree los paquetes <<vo>>, <<interfaz>>,
<<business>>.
12- Cree una clase abstracta de nombre <<Persona>>. Agregue el atributo de clase nombre, el método constructor (usando el
campo nombre) y los respectivos métodos getters y setters.
13- Programe la interfaz <<ICliente>> en el paquete <<interfaz>> con base a lo especificado la Figura 3 (getEmail es tipo
String).
Figura 3. Representación de la interfaz ICliente.
14- Programe la clase <<Cliente>> en el paquete <<vo>>, herede de <<Persona>> y de <<ICliente>>. Siga el formato de la
clase en la Figura 4. No olvide el método constructor con sus correspondientes parámetros (getEmail() retorna String).
Figura 4. Representación de la clase Cliente.
15- Programe la interfaz <<IEmpleado>> según lo especificado en la Figura 5.

5. 5
Figura 5. Representación de la interfaz IEmpleado.
16- Programe la clase <<Empleado>> en el paquete <<vo>>, herede de <<Persona>> y de <<IEmpleado>>. Siga el formato de
la clase en la Figura 6. No olvide el método constructor con sus correspondientes parámetros.
Figura 6. Representación de la clase Empleado.
17- Programe la clase <<ClienteEmpleado>> en el paquete <<vo>>, herede de <<Cliente>> y de <<IEmpleado>>. No olvide el
método constructor con sus correspondientes parámetros.
18- Cree la clase <<Empresa>> en el paquete <<business>>. Agregue como atributo de clase una matriz de personas.
Inicialice la matriz de tamaño 20X20 en el método constructor.
19- Programe un método que diga el número de empleados que están en la matriz.
20- Retorne el nombre del <<ClienteEmpleado>> o <<Cliente>> que tiene el email más largo y está por debajo de la diagonal
secundaría.
21- Retorne el nombre de la interfaz más usada en la matriz.
22- Programe el método agregar persona. Las personas deben ser agregadas en forma de serpiente, comenzando de arriba
hacia abajo.
23- Programe un método que elimine todos los elementos en la matriz que tiene la misma instancia que un elemento agregado
como parámetro (tenga en cuenta solo las clases).
24- Programe la clase <<Hijo>>. Los hijos tienen: nombre (String), edad (int) y gastos mensuales (double).
25- Agregue un arreglo (tamaño 10) de hijos en <<Persona>>. Programé el método agregarHijo. Los hijos de los de los
empleados se agregan desde la primera posición en adelante. Los hijos de los clientes se agregan desde la última posición
hacia atrás.

6. 6
26- Programe un método que permita agregar un hijo a una persona según un nombre dado como parámetro (el método debe
recibir el nombre de la persona y el hijo). De existir varios nombres iguales, se le debe asignar el hijo a la última persona
que se encuentre.
27- Programe un método que retorne quien tiene más hijos ¿Los clientes o los empleados? No se deben tener en cuenta los
<<ClientesEmpleados>>.
28- Programen un método que le quite todos los hijos a las personas que son instancia especifica de un elemento entrado
como parámetro (pueden entrar un Cliente, un Empleado o un ClienteEmpleado).
29- Programe un método que le quite un hijo a la persona que tiene los hijos con más gastos. Solo debe revisar las posiciones
que están por debajo de la diagonal secundaria y primaria.
30- Programe un método que le cambien el nombre a la persona instancia de <<ClienteEmpleado>> que tiene más hijos (El
nuevo nombre debe ser Diomedes).
31- Programe la excepción propia de nombre <<MasHijosDeLoPosibleException>>. La excepción debe ser lanzada cuando se
desee agregar más de 10 hijos a una persona (este método pude ser programado después de estudiar la guía siete y
ocho).
32- Programe la excepción <<EmailSinFormatoException>>. La excepción debe ser lanzada cuando el email de un cliente no
tenga el formato adecuado (este método pude ser programado después de estudiar la guía siete y ocho).
33- Programe un método que elimine a los hijos más gastadores de todos los descendientes de <<IEmpleado>>.
34- Cree la clase <<Aplicación>> en el paquete general con su respectivo método main y pruebe los métodos programados.
ENTREGABLE
Enviar al correo jherrera@eam.edu.co el proyecto comprimido en zip la Practica realizada en su totalidad.
BIBLIOGRAFÍA
Deitel, P. J. & Deitel, H. M. (2012). Como Programar en java. Novena edición. México: Prentice Hall.