Hola a todos, seguimos con la
programación genérica en esta vamos a ver cómo crear clases genéricas, para
ello nos creamos un nuevo paquete en nuestro proyecto ProgramacionGenerica al que vamos a llamar clases_propias y nos creamos una nueva clase sin el método main:
package clases_propias;
public class Pareja {
}
Para convertir esta clase en una clase
genérica indicamos en la definición de la misma entre corchetes angulares el
parámetro de tipo:
package clases_propias;
public class Pareja<T> {
}
A la hora de definir estos argumentos
de tipo genérico se suelen utilizar por convenio letras mayúsculas y suelen ser
la T, U y K. Dentro de esta clase vamos a crear un campo de clase encapsulado:
package clases_propias;
public class Pareja<T>
{
private T primero;
}
Además nos creamos un constructor de
esta clase genérica:
package clases_propias;
public class Pareja<T>
{
public Pareja() {
}
private T primero;
}
Este constructor lo que va a hacer es
darle un estado inicial al campo de clase primero igual a nulo:
package clases_propias;
public class Pareja<T>
{
public Pareja() {
primero
= null;
}
private T primero;
}
Creamos un método setter que sea capaz de cambiar el valor de este campo de clase, es
decir, el valor inicial, después del constructor creamos el método:
public void setPrimero(T nuevoValor) {
primero=nuevoValor;
}
En los parámetros del método le hemos
indicado que va a recibir un argumento de tipo genérico T y lo denominamos nuevoValor y en el método le indicamos
que el campo de clase ha de ser igual al parámetro que le estamos pasando.
A continuación de este método creamos
el método getter que va a ser el
encargado de devolvernos el objeto que estamos manejando en cada ocasión:
public T getPrimero() {
return primero;
}
Para ver el funcionamiento de esta
clase creamos otra clase con el método main a la que llamamos UsoPareja cuyo código es el siguiente:
package clases_propias;
public class UsoPareja {
public static void main(String[] args) {
}
}
class Persona {
public Persona (String
nombre) {
this.nombre = nombre;
}
private String nombre;
}
En este código tenemos la clase
publica UsoPareja con su método main
y luego tenemos la clase Persona con
su constructor de momento está última clase la vamos a ignorar la utilizaremos
después, de momento como si no estuviera.
Vamos al método main y creamos una
instancia de la clase Pareja:
public static void main(String[] args) {
Pareja<String>
una = new
Pareja<String>();
}
La instanciamos indicando que el tipo de dato que va a recibir es un String, esta instancia la denominamos una. Con el método setter cambiamos el valor del campo de clase pero vamos a fijarnos en una cosa:
Al crear el método le hemos indicado
por argumento que el tipo de valor era genérico (T) en cambio al llamar al
método nos pide que sea un valor de tipo String
esto es porque la clase genérica se está adaptando a este objeto de tipo String que hemos indicado al instanciar
la clase por lo que le pasamos un objeto de tipo String:
public static void main(String[] args) {
Pareja<String>
una = new
Pareja<String>();
una.setPrimero("Paco");
}
}
Mediante un System.out llamamos al método getter si observamos de nuevo nos vuelve a indicar que el tipo de objeto es un String:
Indicamos el método:
public static void main(String[] args) {
Pareja<String>
una = new
Pareja<String>();
una.setPrimero("Paco");
System.out.println(una.getPrimero());
}
Probamos:
Para verlo aún más claro vamos a crear una nueva instancia pero utilizando la clase Persona, recordamos la clase Persona:
Lo que hace esta clase es darle al
campo de clase nombre el valor que
le pasemos por argumento al constructor.
public static void main(String[] args) {
Pareja<String>
una = new
Pareja<String>();
una.setPrimero("Paco");
System.out.println(una.getPrimero());
Persona pers1
= new Persona("Ana");
}
Nos creamos una segunda instancia de
nuestra clase genérica pero le vamos a pasar como tipo de objeto Persona.
public static void main(String[] args) {
Pareja<String>
una = new
Pareja<String>();
una.setPrimero("Paco");
System.out.println(una.getPrimero());
Persona
pers1 = new Persona("Ana");
Pareja<Persona>
dos = new
Pareja<Persona>();
}
Llamamos al método setter y vamos a fijarnos el objeto es de tipo Persona:
El método se adapta al argumento que
le estamos pasando.
public static void main(String[] args) {
Pareja<String>
una = new
Pareja<String>();
una.setPrimero("Paco");
System.out.println(una.getPrimero());
Persona
pers1 = new Persona("Ana");
Pareja<Persona>
dos = new
Pareja<Persona>();
dos.setPrimero(pers1);
}
Para que lo imprima en pantalla
llamamos al método getter:
public static void main(String[] args) {
Pareja<String>
una = new
Pareja<String>();
una.setPrimero("Paco");
System.out.println(una.getPrimero());
Persona
pers1 = new Persona("Ana");
Pareja<Persona>
dos = new
Pareja<Persona>();
dos.setPrimero(pers1);
System.out.println(dos.getPrimero());
}
Probamos:
Nos devuelve primero un String que es Paco y luego nos devuelve
el objeto de tipo Persona no el
nombre de Ana que es el que le hemos pasado por parámetro, si queremos que nos
pase el nombre de Ana debemos crear un método que sobrescriba el método
toString, después del constructor de la clase Persona escribimos lo siguiente:
public String toString () {
return nombre;
}
Probamos de nuevo y ahora sí que nos aparece el nombre de Ana:
En resumen, ¡un lío! pero no os desaniméis
mirarlo de nuevo, cambiar el nombre de las clases, los métodos ponerle vuestros
propios nombres, haced ejemplos por vuestra cuenta para verlo más claro y si
tenéis dudas ya sabéis que las podéis indicar en los comentarios del blog. Os
espero en el próximo post. Hasta pronto!
16.1 INTRODUCCIÓN A LA PROGRAMACIÓNGENÉRICA << >> 16.3 MÉTODOS GENÉRICOS
No hay comentarios:
Publicar un comentario