Interfases en Java

CARLOS CHAVEZ 0

Interfaces en Java Comparable y compareTo()

Carlos Chavez 6/19/15 E.P.N.

P a g e 1 | 9

Programación Orientada a Objetos

Contenido Marco Teórico ....................................................................................... 2

Declaración y Uso ................................................................................ 2

Porqué interfaces? ............................................................................... 3

Interfaz Comparable ............................................................................. 3

Ejemplo .............................................................................................. 4

Conclusiones......................................................................................... 9

P a g e 2 | 9


Interfaces

Marco Teórico

El concepto de Interface lleva un paso más adelante la idea de las clases abstractas. En Java una interface

es una clase abstracta pura, es decir una clase donde todos los métodos son abstractos (no se implementa

ninguno). Permite al diseñador de clases establecer la forma de una clase (nombres de métodos, listas

de argumentos y tipos de retorno, pero no bloques de código). Una interface puede también contener

datos miembro, pero estos son siempre static y final. Una interface sirve para establecer un 'protocolo'

entre clases.

Para crear una interface, se utiliza la palabra clave interface en lugar de class. La interface puede

definirse public o sin modificador de acceso, y tiene el mismo significado que para las clases. Todos los

métodos que declara una interface son siempre public.

Para indicar que una clase implementa los métodos de una interface se utiliza la palabra clave

implements. El compilador se encargará de verificar que la clase efectivamente declare e implemente

todos los métodos de la interface. Una clase puede implementar más de una interface.

Declaración y Uso

Una interface se declara:

interface nombre_interface { tipo_retorno nombre_metodo ( lista_argumentos ) ; . . . }

Por ejemplo: interface InstrumentoMusical { void tocar(); void afinar(); String tipoInstrumento(); } Y una clase que implementa la interface: class InstrumentoViento extends Object implements InstrumentoMusical { void tocar() { . . . }; void afinar() { . . .}; String tipoInstrumento() {} } class Guitarra extends InstrumentoViento { String tipoInstrumento() {

return "Guitarra"; } }

P a g e 3 | 9


La clase InstrumentoViento implementa la interface, declarando los métodos y escribiendo el código

correspondiente. Una clase derivada puede también redefinir si es necesario alguno de los métodos de

la interface.

Porqué interfaces?

Porque al definir interfaces permitimos la existencia de variables polimórficas y la invocación polimórfica

de métodos.

Un aspecto fundamental de las interfaces en Java es hacer lo que ya hemos dicho que hace una interfaz

de forma genérica: separar la especificación de una clase (qué hace) de la implementación (cómo lo

hace). Esto se ha comprobado que da lugar a programas más robustos y con menos errores.

Recordar que por ser una interfaz; todos los métodos son abstractos, aunque no se indique

específicamente en la documentación del API de Java. Recordar también que una interfaz no tiene

constructores y no es instanciable. Al ver la documentación del API nos puede parecer una clase, pero la

ausencia de constructor (aparte del propio nombre en el encabezado) delata que no se trata de una clase.

Interfaz Comparable

Esta interfaz consiste únicamente de un método abstracto y no contiene constantes. Si un objeto es de

una clase que implementa “Comparable”, entonces ese objeto puede ser: menor que, igual o mayor que

algún objeto de esa misma clase.

compareTo() retorna un entero que lo mostraremos en la siguiente tabla:

Si deseamos que cualquiera de nuestras clases acceda a éste método abstracto contenido en la interfaz

Comparable, debemos implementarlo al declarar nuestra clase, de la siguiente manera:

public class Nombre_de_la_Clase implements Comparable<Objeto_de_la_Clase>

De esta forma estamos implementando la interfaz Comparable en nuestra clase llamada estudiante que

posee atributos y métodos propios así como también el método abstracto compareTo() que se nos pedirá

que lo implementemos. Este método puede ser modificado a conveniencia nuestra para realizar las tareas

que necesitemos que nuestro programa realice.

Relación ObjectA.compareTo(ObjectB)

ObjetoA Menor que ObjetoB Entero Negativo

ObjetoA Igual ObjetoB Cero

ObjetoA Mayor que ObjetoB Entero Positivo

P a g e 4 | 9


En el siguiente ejemplo se explicará paso a paso la implementación y modificación del método

compareTo() y de la utilización de la interfaz Comparable.

Ejemplo Realizar un programa que ordene objetos de tipo Estudiante que contendrán como atributos el nombre,

fecha de nacimiento, promedio IRA y su número único. El programa contendrá también un método que

calcule la edad de cada Estudiante. La clase Curso contendrá un ArrayList de Estudiantes y contendrá

los métodos de ordenamiento así como de impresión de los objetos. Se debe implementar la clase

abstracta Comparable y modificar el método abstracto compareTo(). Se espera obtener a la salida una

lista ordenada por edad, nombre e IRA respectivamente.

1. La clase Estudiante es creada y declarados sus atributos, ésta clase implementará el método

abstracto compareTo(), es por eso que se escribe “implements”.

2. Getters & Setters, así como el método toString() y los constructores son declarados.

P a g e 5 | 9


3. Es necesario crear un método que calcule la edad de los Estudiantes, esto lo realizamos de la

siguiente manera:

P a g e 6 | 9


4. Como se mostró en el paso 1 la clase Estudiante implementa de la interface Comparable por lo

que se debe declarar y modificar el método abstracto compareTo(). Este método será modificado

independientemente 3 veces ya que el requerimiento del ejercicio es que se ordene los objetos

de manera ascendente y de acuerdo a sus atributos de nombre, edad e IRA.

Edad

Nombre

IRA

5. La clase Curso viene dada de la siguiente manera: contendrá sus respectivos getters & setters,

constructores y métodos que gestionarán tanto la impresión, agregación de objetos tipo

Estudiante así como también el método de ordenamiento.

P a g e 7 | 9


Es importante denotar que en el método sortList() se utiliza la un objeto de la clase Collections el cual

nos permite realizar un proceso sencillo de ordenamiento de ArrayLists.

P a g e 8 | 9


6. El programa contiene también una clase gestora que será la encargada llamar a los métodos de

la clase Curso, con esto podremos notar y comprobar que el ordenamiento de objetos por sus

atributos se haya realizado correctamente. Esta clase se llamará Application.

7. Las salidas serán las siguientes:

Edad

P a g e 9 | 9


Nombre

IRA

Conclusiones

La Interfaz Comparable es muy útil cuando se trata de ordenar objetos por sus

atributos puesto que es para lo que esta interfaz fue creada.

El hacer que el método compareTo() retorne un entero hace que la programación sea

más sencilla.

Es importante entender el funcionamiento del método toString() puesto que sin él este

ejercicio presentaría una excepción NullPointer.

Interfases en Java

Documents

Transcript of Interfases en Java