Cuando una clase implementa una interface, obliga a sobrescribir los métodos de esa interface. En Java tenemos muchas interfaces para hacer que nuestras clases tengan una forma común. La interfaz Comparable nos servirá para poder ordenar colecciones de objetos de tipo List<> (Arrays, ArrayLists, LinkedLists, etc.)

La interface Comparable se usa para obligar a las clases que la implementan a definir sus métodos, de cara a poder ser ordenados. Esta interface solo tiene un método: compareTo(), el cual hemos usado en ocasiones anteriores en objetos de otras clases.

https://docs.oracle.com/javase/8/docs/api/java/lang/Comparable.html

Cuando una clase implementa la interface Comparable, es posible ordenar mediante los métodos de las clases de Java, Arrays o colecciones de tipo list, por poner ejemplos.

• Arrays.sort(): recibe un Array y lo ordena.
• Collections.sort(): recibe un elemento de tipo List<> y lo ordena (ArrayList, LinkedList, Stack, etc).

El método compareTo() se usa para saber si un objeto tiene un orden natural mayor o menor que el objeto actual (desde el que se llama al método):

• Devuelve 0 en caso de que ambos objetos tengan el mismo orden (no haya uno mayor que otro)
• Un número entero negativo si el objeto actual es menor al objeto pasado como parámetro
• Un número positivo si el objeto actual es mayor al objeto pasado como parámetro

La interfaz Comparable es implementada por una clase según la siguiente definición:

public class Coche implements Comparable<Coche>{
   …
   public int compareTo(Coche o){
      …
   }
}

Así indicamos que vamos a implementar la interface Comparable en la clase Coche, para el parámetro de tipo Coche.

A continuación, debemos plantearnos qué criterios seguiremos para indicar que un Coche sea mayor que otro dentro de un orden natural. Este criterio atenderá al valor de alguno de sus atributos.

Por ejemplo, podemos definir que un coche con un LocalDate fechaMatriculación mayor que otro, es un coche mayor. O que un coche con un String matrícula menor que otra será un objeto menor, o el nº de km, etc.

Una vez tengamos seleccionado el atributo/s que indicará quien es mayor, debemos implementar el método compareTo() a partir de la comparación de esos atributos. Si el atributo es una referencia a un objeto, podemos usar el método compareTo() de esa clase de objetos, si lo tienen implementado. En el caso de los Strings, ya tienen implementado la interface Comparable, y tienen su propio método compareTo(). Esto mismo ocurrirá con distintos objetos de clases de la API de Java. Si queremos que nuestros objetos sean ordenables deben implementar esta interface.

Ejemplos de implementación del método compareTo():

//Atendiendo a su numero de km int
public int compareTo(Coche otro){
	return this.km – otro.km;	//Resto los km y tendré 0, >0 ó <0
}

//Atendiendo a su fecha de matriculación LocalDate
public int compareTo(Coche otro){
	return fechaMatriculacion.compareTo(otro.fechaMatriculacion);
	// Devuelvo lo que devuelve el método compareTo() de LocalDate
}

//Atendiendo a su matricula String
public int compareTo(Coche otro){
	return matricula.compareTo(otro.matricula);
	// Devuelvo lo que devuelve el método compareTo() de String
}

Además, tal y como se comenta en la API sobre la interface Comparable se debe atender a una serie de reglas:

• compareTo() debe ser reciproco. Se debe cumplir: a.compareTo(b) == - b.compareTo(a) .
• Si el método equals() de la clase que implementa la interface devuelve true, compareTo() debe devolver 0.
• Si el objeto que se recibe por parámetro es null debe lanzar una excepción de tipo NullPointerException. Esto ocurre sin hacer nada, en el momento que accedamos a algún campo del objeto null.
• Si el objeto que se recibe como parámetro no permite ser comparado debe lanzar una excepción de tipo ClassCastException (No existe un criterio común; no es de la misma clase)

© 2024 Fernando Valdeón