Genericos

Los mtodos genricos y clases genricas permiten a los programadores especificar, con la declaracin de
un solo mtodo, un conjunto de mtodos relacionados o, con la declaracin de una sola clase , un conjunto
de tipos relacionados, respectivamente.

Mtodos Sobrecargados comunes

// MetodosSobrecargados.java
// Uso de mtodos sobrecargados para imprimir arreglos de distintos tipos.
public class MetodosSobrecargados
{
// mtodo imprimirArreglo para imprimir arreglo Integer
public static void imprimirArreglo( Integer[] arregloEntrada )
{
// muestra los elementos del arreglo
for ( Integer elemento : arregloEntrada )
System.out.printf( "%s ", elemento );
System.out.println();
} // fin del mtodo imprimirArreglo
// mtodo imprimirArreglo para imprimir arreglo Double
public static void imprimirArreglo( Double[] arregloEntrada )
{
// muestra los elementos del arreglo
for ( Double elemento : arregloEntrada )
System.out.printf( "%s ", elemento );
System.out.println();
} // fin del mtodo imprimirArreglo
// mtodo imprimirArreglo para imprimir arreglo Character
public static void imprimirArreglo( Character[] arregloEntrada )
{
// muestra los elementos del arreglo
for ( Character elemento : arregloEntrada )
System.out.printf( "%s ", elemento );
System.out.println();
} // fin del mtodo imprimirArreglo
public static void main( String args[] )
{
// crea arreglos de objetos Integer, Double y Character
Integer[] arregloInteger = { 1, 2, 3, 4, 5, 6 };
Double[] arregloDouble = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7 };
Character[] arregloCharacter = { 'H', 'O', 'L', 'A' };
System.out.println( "El arreglo arregloInteger contiene:" );
imprimirArreglo( arregloInteger ); // pasa un arreglo Integer
System.out.println( "\nEl arreglo arregloDouble contiene:" );
imprimirArreglo( arregloDouble ); // pasa un arreglo Double
System.out.println( "\nEl arreglo arregloCharacter contiene:" );
imprimirArreglo( arregloCharacter ); // pasa un arreglo Character
} // fin de main
} // fin de la clase MetodosSobrecargados

Mtodos Genricos
Todas las declaraciones de mtodos genricos tienen una seccin de parmetros de tipos, delimitadas por
signos que se anteponen al tipo de valor de retorno del mtodo. Cada seccin de parmetro de tipo
contiene uno o ms parmetros de tipo (tambin llamados parmetros de tipo formal), separados por
comas. Un parmetro de tipo conocido tambin como variable de tipo, es un identificador que especifica el
nombre de un tipo genrico. Los parmetros de tipo se pueden utilizar para declarar el tipo de valor de
retorno.
// Uso de mtodos genricos para imprimir arreglos de distintos tipos.
public class PruebaMetodoGenerico
{
// mtodo genrico imprimirArreglo
public static < E > void imprimirArreglo( E[] arregloEntrada )
{
// muestra los elementos del arreglo
for ( E elemento : arregloEntrada )
System.out.printf( "%s ", elemento );
System.out.println();
} // fin del mtodo imprimirArreglo
public static void main( String args[] )
{
// crea arreglos de objetos Integer, Double y Character
Integer[] arregloInteger = { 1, 2, 3, 4, 5, 6 };
Double[] arregloDouble = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7 };
Character[] arregloCharacter = { 'H', 'O', 'L', 'A' };
System.out.println( "El arreglo arregloInteger contiene:" );
imprimirArreglo( arregloInteger ); // pasa un arreglo Integer
System.out.println( "\nEl arreglo arregloDouble contiene:" );
imprimirArreglo( arregloDouble ); // pasa un arreglo Double
System.out.println( "\nEl arreglo arregloCharacter contiene:" );
imprimirArreglo( arregloCharacter ); // pasa un arreglo Character
} // fin de main
} // fin de la clase PruebaMetodoGenerico

Se puede obtener lo mismo con Object. Un mtodo genrico es importante cuando utiliza un parmetro de
tipo como el tipo de valor de retorno del mtodo.

Parmetro de tipo genrico como tipo de valor de retorno

public class PruebaMaximo
{
// determina el mayor de tres objetos Comparable
public static < T extends Comparable< T > > T maximo( T x, T y, T z )
{
T max = x; // asume que x es el mayor, en un principio
if ( y.compareTo( max ) > 0 )
max = y; // y es el mayor hasta ahora
if ( z.compareTo( max ) > 0 )
max = z; // z es el mayor
return max; // devuelve el objeto ms grande
} // fin del mtodo maximo
public static void main( String args[] )
{

System.out.printf( "Maximo de %d, %d y %d es %d\n\n", 3, 4, 5,

maximo( 3, 4, 5 ) );
System.out.printf( "Maximo de %.1f, %.1f y %.1f es %.1f\n\n",
6.6, 8.8, 7.7, maximo( 6.6, 8.8, 7.7 ) );
System.out.printf( "Maximo de %s, %s y %s es %s\n", "pera",
"manzana", "naranja", maximo( "pera", "manzana", "naranja" ) );
} // fin de main
} // fin de la clase PruebaMaximo

Los mtodos genricos tambin se pueden sobrecargar.

Clases Genricas
Proporcionan medios para describir el concepto de una clase en forma independiente de su tipo. As
podemos crear instancias de objetos con tipos especiales de clase genrica. Estas clases se conocen como
clases parametrizadas o tipos parametrizados.

Archivo ExcepcionPilaLlena.java
// Indica que una pila est llena.
public class ExcepcionPilaLlena extends RuntimeException
{
// constructor sin argumentos
public ExcepcionPilaLlena()
{
this( "La Pila esta llena" );
} // fin del constructor de ExcepcionPilaLlena sin argumentos
// constructor con un argumento
public ExcepcionPilaLlena( String excepcion )
{
super( excepcion );
} // fin del constructor de ExcepcionPilaLlena sin argumentos
} // fin de la clase ExcepcionPilaLlena

Archivo ExcepcionPilaVacia.java
public class ExcepcionPilaVacia extends RuntimeException
{
// constructor sin argumentos
public ExcepcionPilaVacia()
{
this( "La Pila esta vacia" );
} // fin del constructor de ExcepcionPilaVacia sin argumentos
// constructor con un argumento
public ExcepcionPilaVacia( String excepcion )
{
super( excepcion );
} // fin del constructor de ExcepcionPilaVacia con un argumento
}

Archivo Pila.java
// La clase genrica Pila.
public class Pila< E >
{
private final int tamanio; // nmero de elementos en la pila
private int superior; // ubicacin del elemento superior
private E[] elementos; // arreglo que almacena los elementos de la pila

// el constructor sin argumentos crea una pila del tamao predeterminado

public Pila()
{
this( 10 ); // tamao predeterminado de la pila
} // fin del constructor de Pila sin argumentos
// constructor que crea una pila del nmero especificado de elementos
public Pila( int s )
{
tamanio = s > 0 ? s : 10; // establece el tamao de la Pila
superior = -1; // al principio, la Pila est vaca
elementos = ( E[] ) new Object[ tamanio ]; // crea el arreglo
} // fin del constructor de Pila sin argumentos
// mete un elemento a la pila; si tiene xito, devuelve verdadero;
// en caso contrario, lanza excepcin ExcepcionPilaLlena
public void push( E valorAMeter )
{
if ( superior == tamanio - 1 ) // si la pila est llena
throw new ExcepcionPilaLlena( String.format(
"La Pila esta llena, no se puede meter %s", valorAMeter ) );
elementos[ ++superior ] = valorAMeter; // coloca valorAMeter en la Pila
} // fin del mtodo push
// devuelve el elemento superior si no est vaca; de lo contrario lanza
ExcepcionPilaVacia
public E pop()
{
if ( superior == -1 ) // si la pila est vaca
throw new ExcepcionPilaVacia( "La Pila esta vacia, no se puede sacar" );
return elementos[ superior-- ]; // elimina y devuelve el elemento superior de la
Pila
} // fin del mtodo pop
} // fin de la clase Pila< E >

Mtodos genricos para la clase Pila< E >

// Programa de prueba de la clase genrica Pila.
public class PruebaPila2
{
private Double[] elementosDouble = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6 };
private Integer[] elementosInteger =
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
private Pila< Double > pilaDouble; // pila que almacena objetoss Double
private Pila< Integer > pilaInteger; // pila que almacena objetos Integer
// prueba los objetos Pila
public void probarPilas()
{
pilaDouble = new Pila< Double >( 5 ); // Pila de objetos Double
pilaInteger = new Pila< Integer >( 10 ); // Pila de objetos Integer
probarPush( "pilaDouble", pilaDouble, elementosDouble );
probarPop( "pilaDouble", pilaDouble );
probarPush( "pilaInteger", pilaInteger, elementosInteger );
probarPop( "pilaInteger", pilaInteger );
} // fin del mtodo probarPilas
// el mtodo genrico probarPush mete elementos en una Pila
public < T > void probarPush( String nombre, Pila< T > pila,
T[] elementos )

{
// mete elementos a la pila
try
{
System.out.printf( "\nMetiendo elementos a %s\n", nombre );
// mete elementos a la Pila
for ( T elemento : elementos )
{
System.out.printf( "%s ", elemento );
pila.push( elemento ); // mete elemento a la pila
}
} // fin de try
catch ( ExcepcionPilaLlena excepcionPilaLlena )
{
System.out.println();
excepcionPilaLlena.printStackTrace();
} // fin de catch ExcepcionPilaLlena
} // fin del mtodo probarPush
// el mtodo genrico probarPop saca elementos de una Pila
public < T > void probarPop( String nombre, Pila< T > pila )
{
// saca elementos de la pila
try
{
System.out.printf( "\nSacando elementos de %s\n", nombre );
T valorASacar; // almacena el elemento eliminado de la pila
// elimina todos los elementos de la Pila
while ( true )
{
valorASacar = pila.pop(); // saca de la pila
System.out.printf( "%s ", valorASacar );
} // fin de while
} // fin de try
catch( ExcepcionPilaVacia excepcionPilaVacia )
{
System.out.println();
excepcionPilaVacia.printStackTrace();
} // fin de catch ExcepcionPilaVacia
} // fin del mtodo probarPop
public static void main( String args[] )
{
PruebaPila2 aplicacion = new PruebaPila2();
aplicacion.probarPilas();
} // fin de main
} // fin de la clase PruebaPila2

Tipos crudos (raw)

Un tipo crudo utiliza de manera implcita el tipo Object.
// Programa de prueba de tipos crudos.
public class PruebaTipoCrudo
{
private Double[] elementosDouble = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6 };
private Integer[] elementosInteger =
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
// mtodo para evaluar Pilas con tipos crudos
public void probarPilas()
{
// Pila de tipos crudos asignada a una variable Pila de tipos crudos

Pila pilaTipoCrudo1 = new Pila( 5 );

// Pila< Double > asignada a una variable Pila de tipos crudos
Pila pilaTipoCrudo2 = new Pila< Double >( 5 );
// Pila de tipos crudos asignada a una variable Pila< Integer >
Pila< Integer > pilaInteger = new Pila( 10 );
probarPush( "pilaTipoCrudo1", pilaTipoCrudo1, elementosDouble );
probarPop( "pilaTipoCrudo1", pilaTipoCrudo1 );
probarPush( "pilaTipoCrudo2", pilaTipoCrudo2, elementosDouble );
probarPop( "pilaTipoCrudo2", pilaTipoCrudo2 );
probarPush( "pilaInteger", pilaInteger, elementosInteger );
probarPop( "pilaInteger", pilaInteger );
} // fin del mtodo probarPilas
// mtodo genrico que mete elementos a la pila
public < T > void probarPush( String nombre, Pila< T > pila,
T[] elementos )
{
// mete elementos a la pila
try
{
System.out.printf( "\nMetiendo elementos a %s\n", nombre );
// mete elementos a la Pila
for ( T elemento : elementos )
{
System.out.printf( "%s ", elemento );
pila.push( elemento ); // mete elemento a la pila
} // fin de for
} // fin de try
catch ( ExcepcionPilaLlena excepcionPilaLlena )
{
System.out.println();
excepcionPilaLlena.printStackTrace();
} // fin de catch ExcepcionPilaLlena
} // fin del mtodo probarPush
// mtodo genrico probarPop para sacar elementos de la pila
public < T > void probarPop( String nombre, Pila< T > pila )
{
// saca elementos de la pila
try
{
System.out.printf( "\nSacando elementos de %s\n", nombre );
T valorASacar; // almacena el elemento eliminado de la pila
// elimina elementos de la Pila
while ( true )
{
valorASacar = pila.pop(); // pop from pila
System.out.printf( "%s ", valorASacar );
} // fin de while
} // fin de try
catch( ExcepcionPilaVacia excepcionPilaVacia )
{
System.out.println();
excepcionPilaVacia.printStackTrace();
} // fin de catch ExcepcionPilaVacia
} // fin del mtodo probarPop
public static void main( String args[] )
{
PruebaTipoCrudo aplicacion = new PruebaTipoCrudo();
aplicacion.probarPilas();
} // fin de main
} // fin de la clase PruebaTipoCrudo

Comodines en mtodos que aceptan parmetros de tipo