Genricos

Los mtodos y clases ordinarios funcionan con tipos especficos: con tipos
primitivos o con clases.
Una de las formas en que los lenguajes orientados a objetos permiten la
generalizacin es a travs del polimorfismo.
Los genricos implementan el concepto de tipos parametrizados, que permiten
crear componentes(especialmente
contenedores) que resultan fciles de utilizar con mltiples tipos.
El termino "genrico significa perteneciente o apropiado a grandes grupos de
clases".
La intencin original de los genricos en los lenguajes de programacin era
dotar el programador de la mayor
capacidad expresiva posible a la hora de escribir clases o mtodos, relajando
las restricciones que afectan a los tipos
con los que esas clases o mtodos pueden funcionar.
Existen una serie de convenciones para nombrar a los genricos:
E Element (usado bastante por Java Collections Framework)
K Key (Llave, usado en mapas)
N Number (para nmeros)
T Type (Representa un tipo, es decir, una clase)
V Value (representa el valor, tambin se usa en mapas)
S,U,V etc. usado para representar otros tipos.

Genricos Simples
Java Generics o simplemente clases Genricas.
Vamos a escribir algunos artculos hablando de este tema .Para empezar con
ello vamos a construir la clase Bolsa que es una clase sencilla que nos
permitir almacenar objetos de varios tipos.

Esta clase tendr un lmite de objetos a almacenar . Alcanzado el limite no se

podrn aadir mas .Vamos a ver su cdigo fuente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package com.arquitecturajava;
import java.util.ArrayList;
import java.util.Iterator;
public class Bolsa implements Iterable{
private ArrayList lista= new ArrayList();
private int tope;
public Bolsa(int tope) {
super();
this.tope = tope;
}
public void add(Object objeto ) {
if (lista.size()<=tope) {
lista.add(objeto);
}else {
throw new RuntimeException("no caben mas");
}
}
public Iterator iterator() {
return lista.iterator();
}
}

En nuestro caso vamos a disponer de dos clases con las cuales rellenar la bolsa
. La clase Golosina y la clase Chocolatina.

Vamos a ver su cdigo fuente :

1
2
3
4

package com.arquitecturajava;
public class Chocolatina {
private String marca;

5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public String getMarca() {

return marca;
}
public void setMarca(String marca) {
this.marca = marca;
}
public Chocolatina(String marca) {
super();
this.marca = marca;
}
}

package com.arquitecturajava;
public class Golosina {
private String nombre;
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public Golosina(String nombre) {
super();
this.nombre = nombre;
}
}
&nbsp;
&nbsp;

Es momento de crear un sencillo programa que llene la Bolsa de Chocolatinas

y Golosinas para luego recorrer los elementos que estn en la bolsa y sacarlos
por pantalla.

1
2
3
4

package com.arquitecturajava;
public class Principal {

5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public static void main(String[] args) {

Bolsa bolsa= new Bolsa(5);
Chocolatina c= new Chocolatina("milka");
Chocolatina c1= new Chocolatina("milka");
Chocolatina c2= new Chocolatina("ferrero");
Golosina g1= new Golosina("gominola");
Golosina g2= new Golosina("chicle");
bolsa.add(c);
bolsa.add(c1);
bolsa.add(c2);
bolsa.add(g1);
bolsa.add(g2);
for (Object o :bolsa) {
if( o instanceof Chocolatina) {
Chocolatina chocolatina= (Chocolatina)o;
System.out.println(chocolatina.getMarca());
}else {
Golosina golosina= (Golosina)o;
System.out.println(golosina.getNombre());
}
}
}
}

El programa funcionar correctamente, pero nos podremos dar cuenta que resulta bastante poco
amigable la estructura if /else en la cual se chequean cada uno de los tipos a la hora de
presentarlo por pantalla.
Para solventar este problema podemos construir una clase Genrica .Este tipo de clase nos
permitir definir una Bolsa de un tipo concreto . Puede ser una bolsa de Golosinas o una bolsa de
Chocolatinas pero NO de las dos cosas a la vez .Esto en un principio puede parecer poco
flexible pero si nos ponemos a pensar cuando programamos solemos imprimir una lista de Facturas
o una lista de Compras no una lista mixta. As pues el enfoque parece razonable. Vamos a ver el
cdigo fuente y comentarlo:
package com.arquitecturajava.genericos;
1

2
3
4

import java.util.ArrayList;
import java.util.Iterator;

5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public class Bolsa<T> implements Iterable<T>{

private ArrayList<T> lista= new ArrayList<T>();
private int tope;

public Bolsa(int tope) {

super();
this.tope = tope;
}
public void add(T objeto ) {
if (lista.size()<=tope) {
lista.add(objeto);
}else {
throw new RuntimeException("no caben mas");
}
}
public Iterator<T> iterator() {
return lista.iterator();
}
}

La clase es un poco peculiar ya que al no saber de entrada de que tipo va a ser la bolsa debemos
declarar un tipo Genrico T a nivel de clase y que ser repetido en cada uno de los mtodos
que lo usen.

De esta manera cuando construyamos un objeto de esta clase ser el momento de especificar el
tipo de Bolsa que deseamos .En el siguiente ejemplo hemos elegido Chocolatina como tipo para
la Bolsa . De esta manera la bolsa solo admitir este tipo de objetos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package com.arquitecturajava.genericos;
import com.arquitecturajava.Chocolatina;
import com.arquitecturajava.Golosina;
public class Principal {
public static void main(String[] args) {
Bolsa<Chocolatina> bolsa= new Bolsa<Chocolatina>();
Chocolatina c= new Chocolatina("milka");
Chocolatina c1= new Chocolatina("milka");
Chocolatina c2= new Chocolatina("ferrero");
bolsa.add(c);
bolsa.add(c1);
bolsa.add(c2);
for (Chocolatina chocolatina:bolsa) {
System.out.println(chocolatina.getMarca());
}
}
}

Acabamos de construir nuestra primera clase Generica y hemos usado un bucle forEach para
recorrerla de una forma sencilla.

Tuplas:
Es un grupo de objetos que se envuelven juntos dentro de otro objeto nico.
El receptor del objeto estar autorizado a leer los elementos, pero no a
introducir otros nuevos( este
Concepto tambin se conoce como Objeto de transferencia de datos o
Mensajero).
Tuplas puede tener, normalmente, cualquier longitud, y cada objeto de la tupla
puede tener un tipo distinto.
Para tratar con el problema de las mltiples longitudes, podemos crear
mltiples tuplas diferentes.
He aqu una que almacena dos objetos.

//: net/mindview/til/Twotuple.java
Public class TwoTuple<A,B> {
Public final A first;
Public final B second;
Public TwoTuple (A a, B b) ( first = a; second = b;)
Public String ToString () {
Return {+ first + ,+ second +};
}
}///:Pilas - Stack:
La clase Stack que implementaba la pila se construyo componiendo una clase
genrica(Stack<T>) con otra clase genrica(LinkedList<T>).
En dicho ejemplo, observar que ( con unas cuantas excepciones que
posteriormente realizaremos) un tipo genrico no es otra cosa que un tipo
normal.
//: generics/LinkedStack.java
//Una pila implementada con una estructura enlazada interna.
public class LinkStack<T> {
pirvate static class Node<U> (
U item;
Node <U> next;
Noode ( U item, item, Node <U> next) {
this.item = item;
this.next = next;
}

boolean end () (return item == null && next == null;)

}
pirvateNode <T> top = new Node <T> (); // Indicador de fin
public void push(T item) {
top = new Node <T> (item, top);
}
public T pop {
T result + top.item;
if (!top.end()}
top = top.next;
return result;
}
Public static void main (String [] args) {
LinkedStack<String> lss = new LinkedStack<String> ();
for (String s ;"Phasers on stun!".split("")}
lss.push(s);
String s;
while{(s=lss.pop() !=null)
System.out.println(s);
}/* Output:
}
stun!
on Phasers*/////:La clase interna Node Tambin es un genrico y tiene su propio parmetro de
tipo.
Este ejemplo hace uso de un indicador de fin para determinar cuando la pila es
vaca.

RamdonLisT:
Ahora para expandir las funcionalidades de la clase desarrollamos un mtodo
que recibe y procesa u item de un tipo generico:
public class miClase<T> {
private ArrayList<T> lista;
public miClase() {
lista = new ArrayList<T>();
}
public void add(T element) {
lista.add(element);

Recordemos que no estamos tratando explcitamente con una clase llamada

T. De hecho T es una convencin para cualquier clase usada cuando alguien
crea una instancia de miClase (La especificacin Java permite utilizar cualquier
identificador que deseemos).

Interfaces Genricas:

Las interfaces genricas se declaran de la "misma manera" que una clase genrica,
veamos la sintaxis general:
interface nombre-interfaz<T1, T2, T3...>{
metodo1();
metodo2();
}
Donde T1, T2, T3... son los tipos parametrizados.
Aunque no siempre se as, una clase que implementa esta interfaz debe ser en forma
general:

class nombre-clase<T1, T2, T3...>

implements nombre-interfaz<T1, T2, T3...>{
metodo1Implementado(){}
metodo2Implementado(){}
}

Si crea una clase genrica en Java (la clase de los parmetros de tipo
genrico), puede utilizar los mtodos genricos (el mtodo tiene parmetros de
tipo genrico)?

Mtodos Genricos:

Un mtodo genrico que el mtodo vari independientemente de la clase.

Considere el siguiente ejemplo:
public class MyClass {
public <K> K doSomething(K k){
return k;
}
}

public class MyGenericClass<T> {

public <K> K doSomething(K k){
return k;
}

public <K> List<K> makeSingletonList(K k){

return Collections.singletonList(k);
}
}
Como es de esperar en un mtodo genrico, puedo llamar a doSomething(K) en las
instancias deMyClass con cualquier objeto:

La Clase GenericMethods no est parametrizada, aunque es perfectamente posible

parametrizar simultneamente tanto una clase como sus mtodos.

Varargars y mtodos Genricos:

Los mtodo genericos y las listas de argumentos variables pueden coexistir
perfectamente:

Un mtodo para utilizar con gneradores:

Resulta bastante cmo utilizar un generador para rellenar un objeto Collection, y
tambin tiene bastante sentido hacer genrica esta operacin:

Un generador de propsito general:

Esta clase proporciona una implementacin bsica que producir objetos de una clase
que(1) sea pblica (ya que BasicGenerator esta en un paquete separado. La clase en
cuestin debe tener acceso pblico y no simplemente de paquete) y (2) tenga un
constructor predeterminado ( uno que no tome ningn argumento).

Una Utilidad SET

Otro ejemplo del uso mtodo genrico. Estos conjuntos pueden definirse de forma
cmoda como mtodo genrico, para utilizarlos con todos los diferentes tipos:
Los primeros tres mtodos duplican el primer argumento copiando sus referencias en
un nuevo objeto HashSet, de modo que los conjuntos utilizados como argumentos no
se modifican directamente. El valor de retorno ser, por tanto, un nuevo objeto Set.
Los cuatro mtodos representan las operaciones matemticas de conjuntos: unin()
devuelve un objeto Set que contiene la combinacin, Difference() resta los elementos
subset de superset complemente() devuelve un objeto Set con todos los elementos
que no conformen parte de la interseccin.

Clases internas annimas:

Los genricos tambin pueden utilizarse con las clases internas y con las clases
internas annimas.
He aqu un ejemplo de implementa la interfaz Generator utilizando clases internas
annimas.
Tanto Customer como Teller tienen constructores privados, lo que nos obliga a utilizar
objetos
Generator. Customer tiene un mtodo generator() que genera un nuevo mtodo
Generator<Customer> cada vez que lo invocamos. Puede que no necesitemos
mltiples objetos Generator, y Teller crea un objeto generator pblico.
Puesto que el mtodo generato() de Customer como el objeto Generator de Teller son
estticos, no pueden
Formar parte de una interfaz, asi que no hay forma de hacer genrica esta funcin
concreta. A pesar de ello funciona razonablemente bien con el mtodo fill().