Vamos a empezar preguntándonos, ¿Qué son las interfaces? Las interfaces son una herramienta más de la programación en Java que nos va a permitir obligar que las clases que implementen interfaces tengan unas funcionalidades determinadas.
Vale, esta definición ahora os puede sonar un poco a chino, pero vosotros quedaros con esta definición, más adelante la comprenderéis. Vamos a ver qué características tienen las interfaces.
CARACTERÍSTICAS DE LAS INTERFACES.
- Las interfaces sólo tienen métodos abstractos y constantes. Por lo tanto no se pueden instanciar objetos de interfaces.
- Todos los métodos son public y abstract. Si no se indica estos modificadores se da por supuesto.
- En Java vienen predefinidas muchísimas interfaces en la API, pero nosotros podremos crear nuestras propias interfaces.
Viendo las características de las interfaces os podría sonar a que son parecidas a las clases abstractas que vimos en el tutorial anterior, y así es, entonces os podríais preguntar, ¿Que diferencia hay en utilizar las clases abstractas o interfaces?
Cuando vimos las clases abstractas vimos que podía estar formada sin que tuviera métodos abstractos, las interfaces nos obliga a que todos los métodos sean abstractos. Entonces, ¿Por qué no podemos utilizar las clases abstractas en vez de interfaces? Las interfaces solucionan el problema de la herencia simple. Imagínate que tienes una clase que hereda de otra clase, pero quieres que tu clase tenga un determinado comportamiento, una funcionalidad. No puedes heredar de otra clase porque como vimos, java no permite la herencia múltiple, pero Java sí que permite implementar tantas interfaces como queramos. Es decir, una clase puede estar heredando de otra clase y, a su vez, implementar una interface, dos, o las que necesitemos. En este sentido Java sí que nos permite una especia de herencia múltiple con interfaces.
La sintaxis para implementar una interface en Java es la siguiente:
public class NombreClase implements NombreInterface {
}
Si queremos implementar más de una interface:
public class NombreClase implements Interface1, Interface2 {
}
Si una clase hereda de una clase e implementa una interface:
public class NombreClase extends ClasePadre implements NombreInterface {
}
Ahora que ya habéis visto un poco de teoría y la sintaxis de las interfaces, vamos a ver a continuación un ejemplo de una interface que viene ya en Java y que es la interface Comparable. La interface Comparable se utiliza para ordenar objetos. En nuestro ejemplo vamos a crear la clase Trabajador para ordenarlos luego por salario.
public class Trabajador {
//Atributos de un trabajador
String nombre;
String puesto;
double salario;
//Constructor para inicializar los valores
public Trabajador(String nombre, String puesto, double salario) {
this.nombre = nombre;
this.puesto = puesto;
this.salario = salario;
}
}
Ahora en una clase llamada Empresa vamos a crear un array de 6 elementos que contendrá objetos de la clase Trabajador.
public class Empresa {
public static void main(String[] args) {
//Creamos el array con capacidad de 6 trabajadores
Trabajador[] trabajadores = new Trabajador[6];
//Creamos trabajadores y los introducimos en el array
trabajadores[0] = new Trabajador("Jose Martinez Navarro", "Dependiente", 1200);
trabajadores[1] = new Trabajador("María Sánchez Giménez", "Encargada de tienda", 1358.45);
trabajadores[2] = new Trabajador("Sonia Alfaro Mínguez", "Reponedora", 985.73);
trabajadores[3] = new Trabajador("Alberto Pérez Portur", "Repartidor", 1025.99);
trabajadores[4] = new Trabajador("Javier Ortega Navas", "Gerente", 2127.77);
trabajadores[5] = new Trabajador("Carmen Serrano Córcoles", "Limpiadora", 868.91);
//bucle for each para recorrer el array
for(Trabajador e : trabajadores) {
//Imprime los trabajadores en orden de introdución
System.out.println(e.nombre + ", " + e.puesto + ", " + e.salario + "€");
}
}
}
Como vemos, así se imprimen los trabajadores en orden en el que los hemos introducido, pero lo que queremos es que nos lo muestre en función del salario. ¿Cómo hacemos esto? Para esto vamos a tener que hacer uso de la clase Arrays y su método sort. Vamos a dirigirnos a la documentación de Java para ver con más detalle esto.
Veámos que nos dice la descripción de este método:
Observamos que el método es estático, esto quiere decir que para invocar dicho método en la clase Empresa tenemos que hacerlo con el nombre de la clase, es decir, Arrays.sort(Object[]).
import java.util.Arrays;
public class Empresa {
public static void main(String[] args) {
//Creamos el array con capacidad de 6 trabajadores
Trabajador[] trabajadores = new Trabajador[6];
//Creamos trabajadores y los introducimos en el array
trabajadores[0] = new Trabajador("Jose Martinez Navarro", "Dependiente", 1200);
trabajadores[1] = new Trabajador("María Sánchez Giménez", "Encargada de tienda", 1358.45);
trabajadores[2] = new Trabajador("Sonia Alfaro Mínguez", "Reponedora", 985.73);
trabajadores[3] = new Trabajador("Alberto Pérez Portur", "Repartidor", 1025.99);
trabajadores[4] = new Trabajador("Javier Ortega Navas", "Gerente", 2127.77);
trabajadores[5] = new Trabajador("Carmen Serrano Córcoles", "Limpiadora", 868.91);
//Invocamos el método Arrays.sort(Object[])
Arrays.sort(trabajadores);
//bucle for each para recorrer el array
for(Trabajador e : trabajadores) {
//Imprime los trabajadores en orden de introdución
System.out.println(e.nombre + ", " + e.puesto + ", " + e.salario + "€");
}
}
}
Por lo tanto, debemos de implementar esta interface en la clase Trabajador, que es la clase que contiene el array. Cuando implementemos este interfaz en la clase Trabajador tendremos que sobrescribir todos los métodos que contenga la interfaz, recuerda que los métodos de las interfaces son abstractos y por lo tanto tienen que ser implementados en la clase que implemente la interfaz. Al ser métodos abstractos, tenemos que escribir el cuerpo del método en la clase Trabajador.
Veámos antes, en la documentación de Java qué métodos tenemos para esta interfaz Comparable y qué es lo que hace.
La interfaz comparable sólamente tiene un método, el método compareTo(T o). Al método se le pasa un parámetro de tipo T. Esto quiere decir que T puede ser cualquier objeto, pero no os preocupéis porque la programación genérica la veremos más adelante. Solamente quedaros que se le pasa como argumento cualquier tipo de objeto, en nuestro caso un tipo de dato Trabajador. Veámos qué tiene que hacer este método:
Volvamos a la clase Trabajador e implementemos esta interfaz y sobrescribamos el método y veamos cómo quedaría la clase Trabajador.
public class Trabajador implements Comparable{
//Atributos de un trabajador
String nombre;
String puesto;
double salario;
//Constructor para inicializar los valores
public Trabajador(String nombre, String puesto, double salario) {
this.nombre = nombre;
this.puesto = puesto;
this.salario = salario;
}
@Override
public int compareTo(Object o) {
//Primero debemos hacer un casting porque vamos a comparar tipos
//de datos Trabajador
Trabajador t = (Trabajador) o;
//Ahora comparamos el salario y devolvemos un entero negativo
//cero o un entero positivo
if(this.salario < t.salario){
return -1;
}else if(this.salario > t.salario){
return 1;
}else{
return 0;
}
}
}
Ahora ya tenemos todo terminado, si ejecutamos la clase Empresa veremos cómo se muestran los trabajadores en orden según su salario.
Bueno, pues ya hemos visto un poco qué son las interfaces y sus características, cómo es su sintaxis y también hemos visto un ejemplo de uso de una interfaz que viene en la API de Java
Si tenéis alguna duda no dudéis en dejad en los comentarios y recordad que me podéis seguir en Facebook.
No hay comentarios:
Publicar un comentario