Hola a todos de nuevo, ¿qué tal? Un
método genérico es el que podemos utilizar con cualquier tipo de objeto, estos
métodos no tienen por qué estar creados dentro de las clases genéricas pueden
estar tanto en clases ordinarias como en clases orgánicas.
Para ver el uso de estos métodos vamos
a hacerlos mediante un ejemplo, nos creamos un archivo nuevo con el método main
al que vamos a llamar MetodosGenericos
cuyo código es el siguiente:
package clases_propias;
public class
MetodosGenericos {
public static void main(String[] args) {
}
}
class MisMatrices {
}
A continuación del método principal
main tenemos la clase MisMatrices
esta clase es la que va a contener un método genérico, este método nos va a
devolver un String o cadena de texto
que nos va a decir la longitud que tiene un array que le pasemos por parámetro
a ese método genérico. Así que empezamos a crear el método:
class MisMatrices {
public static <T>
String getElementos(T[]a) {
return "El array
tiene "+a.length+" elementos.";
}
}
Como no sabemos qué tipos de elementos
va a componer el array le indicamos entre corchetes angulares que son datos de
tipo genérico (T) y le pasamos por parámetro que el array va a ser de datos
genérico.
Dentro del método main nos creamos un
array de tipo String:
public static void main(String[] args) {
String
nombres[] = {"Monica", "Luis", "Paco"};
}
Luego llamamos al método para que nos
imprima la longitud del array:
public static void main(String[] args) {
String
nombres[] = {"Monica", "Luis", "Paco"};
String elementos
= MisMatrices.getElementos(nombres);
System.out.println(elementos);
}
Probamos:
La ventaja de ser un método genérico
viene por la prueba que vamos a hacer a continuación nos creamos un array de
tipo Empleado. La clase Empleado
estuvimos trabajando con ella en el bloque de ArrayList, el archivo es Uso_empleado.java
que tiene que estar en el mismo paquete donde estamos trabajando ahora que es clases_propias o si no trabajáis con
paquetes en el mismo proyecto donde estéis trabajando. Creamos el array,
llamamos al método genérico:
public static void main(String[] args) {
String
nombres[] = {"Monica", "Luis", "Paco"};
String
elementos = MisMatrices.getElementos(nombres);
System.out.println(elementos);
Empleado
listaEmpleados[] = {new Empleado("Paco", 25, 1200),
new Empleado("Luis", 21, 995),
new Empleado("Monica", 25, 1100),
new Empleado("Sonia", 28, 1200),
new Empleado("Rocio", 32, 1250),
};
System.out.println(MisMatrices.getElementos(listaEmpleados));
}
}
Probamos:
La ventaja del método es que se adapta
a cualquier tipo de objeto que le estemos pasando por parámetro.
Básicamente esta sería la forma de
crear métodos genéricos, en este caso, lo hemos creado en un ejemplo muy básico
pero si creamos un método genérico un poco más elaborado que realice algo más
nos podemos encontrar con problemas, estos problemas son derivados de que
podemos pasarle por argumentos objetos de cualquier tipo y eso nos puede llevar
a problemas, estos casos también tienen su solución.
Para ello nos vamos a crear un método
genérico que va a decirnos en el array que le pasemos por argumento en el caso
de que le pasemos un array de tipo String que nos indique el elemento menor
ordenado por orden alfabético, si le pasamos un array de fechas nos tiene que
devolver la fecha menor y así con cualquier array que le pudiéramos pasar.
Vamos a reutilizar código, vamos a
borrar todo lo que hay en el método main y solo vamos a dejar el array de
nombres:
String nombres[] = {"Monica", "Luis", "Paco"};
El método genérico lo vamos a
reconstruir ya no nos va a devolver un String lo que me va a devolver es el
elemento del array que sea menor por lo que le tenemos que indicar que el valor
a devolver va a ser genérico:
class MisMatrices {
public static <T> T getMenor(T[]a) {
}
}
Dentro del método mediante un
condicional if le indicamos que si el
array está vació o tiene longitud 0 que este método no devuelva nada:
public static <T> T getMenor(T[]a) {
if(a==null || a.length==0) {
return null;
}
}
Ahora utilizando el método compareTo() lo que hace es comparar los
elementos de un array unos con otros para devolvernos cuál es el menor, nos
creamos una variable de tipo genérico que almacene el elemento menor,
recorremos el array que le hemos pasado por parámetro mediante un bucle for:
T elementoMenor = a[0];
for (int i=1; i<a.length; i++) {
if(elementoMenor.compareTo(a[i])>0) {
elementoMenor=a[i];
}
}
Explicamos este trozo de código: la
variable de tipo T (tipo genérico) almacena el valor mínimo, el elemento menor
y va a estar en la posición 0 del array. Recorremos el array con un bucle for y
empezamos en la posición 1 porque la posición 0 ya la tenemos almacenada en la
variable, que va a empezar comparar el elemento que están en la posición 1 con
el que está en la posición 0, mediante un condicional if le indicamos que lo
que tenemos almacenado en elementoMenor
lo comparamos con el elemento i y es mayor que 0 entonces elementoMenor será igual al elemento menor.
Lo que nos queda es salir del for y
escribir el return:
for (int i=1; i<a.length; i++) {
if(elementoMenor.compareTo(a[i])>0) {
elementoMenor=a[i];
}
}
return elementoMenor;
}
Si habéis observador nos está marcando
error el método compareTo() este
método pertenece a la interfaz Comparable
y eso hace que los objetos que utilicen este método tienen que implementar esta
interfaz y eso se lo indicamos en la definición del método:
public static <T extends Comparable> T getMenor(T[]a) {
Para que nos lo imprima por consola en
el método main:
public static void main(String[] args) {
String
nombres[] = {"Monica", "Luis", "Paco"};
System.out.println(MisMatrices.getMenor(nombres));
}
Si ejecutamos:
Si ahora lo quisiéramos comparar con un array de tipo Empleado:
Nos daría error ya que las instancias
de tipo Empleado no implementan la interfaz Comparable.
Con cualquier duda lo podéis comentar
en los comentarios del post o enviarme un correo a amizba@gmail.com Hasta pronto!
16.2 CREACIÓN CLASES GENÉRICAS
<< >> 16.4 HERENCIA Y TIPOS COMODÍN
No hay comentarios:
Publicar un comentario