Ir a contenido principal

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

La primera vez que inicie sesión en developerWorks, se creará un perfil para usted. Cierta información de su perfil de developerWorks será mostrada públicamente, pero usted puede editar la información en cualquier momento. Su nombre, apellido (a menos que usted elija ocultarlo) y nombre de usuario acompañarán el contenido que usted publique.

Toda la información enviada es segura.

  • Cerrar [x]

La primera vez que inicia sesión en developerWorks se crea un perfil para usted, teniendo que elegir un nombre para mostrar en el mismo. Este nombre acompañará el contenido que usted publique en developerWorks.

Por favor elija un nombre de 3 - 31 caracteres. Su nombre de usuario debe ser único en la comunidad developerWorks y debe ser distinto a su dirección de email por motivos de privacidad.

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

Toda la información enviada es segura.

  • Cerrar [x]

Introducción a la programación Java, parte 2: Construcciones para aplicaciones del mundo real

Funciones más avanzadas del lenguaje Java

J. Steven Perry, Consultor Director, Makoto Consulting Group, Inc.
J. Steven Perry
J. Steven Perry es desarrollador de software, arquitecto y fanático general de Java que ha estado desarrollando software profesionalmente desde 1991. Sus intereses profesionales abarcan desde el funcionamiento interno de la JVM hasta el modelo UML y todo lo que está en el medio. Steve tiene una pasión por escribir y ser mentor. Es el autor de Java Management Extensions (O'Reilly), Log4j (O'Reilly) y los artículos de developerWorks de IBM "Joda-Time" y OpenID for Java Web applications". Pasa tiempo libre con sus tres hijos, anda en bicicleta y enseña yoga.

Resumen:  En la Parte 1 de este tutorial, el programador Java™ profesional J. Steven Perry presentó la sintaxis del lenguaje Java y las bibliotecas que usted necesita para escribir aplicaciones Java simples. La Parte 2, todavía orientada a desarrolladores nuevos en el desarrollo de aplicaciones Java, presenta las construcciones de programación más sofisticadas requeridas para crear complejas aplicaciones Java del mundo real. Los temas que se cubren incluyen manejo de excepciones, herencia y abstracción, expresiones regulares, genéricos, E/S Java y serialización Java.

Ver más contenido de esta serie

Fecha:  10-12-2012
Nivel:  Introductoria PDF:  A4 and Letter (927 KB | 54 páginas)Get Adobe® Reader®

Comentario:  

Genéricos

La introducción de los genéricos en JDK 5 marcó un gran avance para el lenguaje Java. Si usted ha usado plantillas C++, descubrirá que los genéricos en el lenguaje Java son similares, pero no exactamente iguales. Si no ha usado plantillas C++, entonces no se preocupe: Esta sección ofrece una introducción de alto nivel a los genéricos en el lenguaje Java.

¿Qué son los genéricos?

Con el release de JDK 5, el lenguaje Java de repente germinó una nueva sintaxis extraña y emocionante. Básicamente, algunas clases JDK familiares se sustituyeron por sus equivalentes genéricos.

Generics es un mecanismo compilador por el cual usted puede crear (y usar) tipos de elementos (tales como clases e interfaces) de un modo genérico al cosechar el código común y parametrizar (o hacer plantillas) el resto.

Genéricos en funcionamiento

Para ver la diferencia que hacen los genéricos, considere el ejemplo de una clase que ha estado en el JDK por mucho tiempo: java.util.ArrayList, que es una Lista de objetos que está respaldada por una matriz.

El Listado 12 muestra cómo java.util.ArrayList se crea como instancia:


Listado 21. Instanciación de una ArrayList

ArrayList arrayList = new ArrayList();
arrayList.add("A String");
arrayList.add(new Integer(10));
arrayList.add("Another String");
// So far, so good.

Como puede ver, la ArrayList es heterogénea: contiene dos tipos de String y un tipo de Integer. Antes de JDK 5, no había nada en el lenguaje Java para restringir este comportamiento, lo cual causó muchos errores de codificación. En el Listado 21, por ejemplo, todo parece estar bien hasta el momento. Pero, ¿qué tal si se accede a los elementos de la ArrayList, lo que el Listado 22 intenta hacer?


Listado 22. Un intento para acceder a los elementos en la ArrayList

ArrayList arrayList = new ArrayList();
arrayList.add("A String");
arrayList.add(new Integer(10));
arrayList.add("Another String");
// So far, so good.
*processArrayList(arrayList);
*// In some later part of the code...
private void processArrayList(ArrayList theList) {
   for (int aa = 0; aa < theList.size(); aa++) {
     // At some point, this will fail...
     String s = (String)theList.get(aa);
   }
}

Sin conocimiento previo de lo que está en la ArrayList, se debe verificar el elemento al que quiere acceder para ver si puede manejar su tipo o enfrentar una posible ClassCastException.

Con los genéricos, usted puede especificar el tipo de elemento que se puso en la ArrayList. El Listado 23 muestra cómo:


Listado 23. Un segundo intento, con el uso de genéricos

ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("A String");
arrayList.add(new Integer(10));// compiler error!
arrayList.add("Another String");
// So far, so good.
*processArrayList(arrayList);
*// In some later part of the code...
private void processArrayList(ArrayList<String> theList) {
   for (int aa = 0; aa < theList.size(); aa++) {
     // No cast necessary...
     String s = theList.get(aa);
   }
}

Iteración con genéricos

Los genéricos mejoran el lenguaje Java con una sintaxis especial para lidiar con entidades como Lists que usted comúnmente quiere seguir paso a paso, elemento por elemento. Si quiere iterar por la ArrayList, por ejemplo, podría reescribir el código del Listado 23 del siguiente modo:

private void processArrayList(ArrayList<String> theList) {
 for (String s : theList) {
   String s = theList.get(aa);
 }
}

Esta sintaxis funciona para cualquier tipo de objeto que sea Iterable (es decir, implementa la interfaz Iterable).


Clases parametrizadas

Las clases parametrizadas realmente brillan cuando se trata de colecciones, por lo tanto así es como usted las observará. Considere la interfaz de List (real). Representa una colección ordenada de objetos. En el caso de uso más común, se agregan elementos a la List y luego se accede a aquellos elementos ya sea por índice o por iterar por la List.

Si está pensando en parametrizar una clase, considere si aplican los siguientes criterios:

  • Una clase principal se encuentra en el centro de algún tipo de derivador: es decir, la "cosa" en el centro de la clase puede aplicarse ampliamente y las funciones (por ejemplo, los atributos) que la rodean son idénticas.
  • Comportamiento común: usted realiza prácticamente las mismas operaciones sin tener en cuenta la "cosa" en el centro de la clase.

Al aplicar estos dos criterios, es bastante evidente que una colección concuerde con la cuenta:

  • La "cosa" es la clase de la cual consta la colección.
  • Las operaciones (tales como add, remove, size, y clear) son prácticamente las mismas sin importar el objeto del que consta la colección.

Una List parametrizada

En la sintaxis de genéricos, el código para crear una List se parece a este:

List<E> listReference = new concreteListClass<E>();

La E, que significa Elemento, es la "cosa" que mencioné anteriormente. La concreteListClass es la clase del JDK que usted está creando como instancia. El JDK incluye varias implementaciones List<E> pero usted usará ArrayList<E>. Otra forma en que podría ver que se discute una clase genérica es Class<T>, donde T significa Tipo. Cuando ve E en el código Java, normalmente se está refiriendo a una colección de algún tipo. Y cuando ve T, está denotando una clase parametrizada.

Por lo tanto, para crear una ArrayList de, digamos, java.lang.Integer, usted haría lo siguiente:

List<Integer> listOfIntegers = new ArrayList<Integer>();

SimpleList: Una clase parametrizada

Ahora suponga que quiere crear su propia clase parametrizada llamada SimpleList, con tres métodos:

  • add() agrega un elemento al final de la SimpleList.
  • size() retorna la cantidad actual de elementos en la SimpleList.
  • clear() borra por completo los contenidos de la SimpleList.

El Listado 24 muestra la sintaxis para parametrizar la SimpleList:


Listado 24. Parametrización de la SimpleList

package com.makotogroup.intro;
import java.util.ArrayList;
import java.util.List;
public class SimpleList<E> {
 private List<E> backingStore;
 public SimpleList() {
   backingStore = new ArrayList<E>();
 }
 public E add(E e) {
   if (backingStore.add(e))
     return e;
   else
     return null;
 }
 public int size() {
   return backingStore.size();
 }
 public void clear() {
   backingStore.clear();
 }
}

SimpleList puede parametrizarse con cualquier subclase de Object. Para crear y usar una SimpleList de, digamos, objetos java.math.BigDecimal, usted haría lo siguiente:

public static void main(String[] args) {
 SimpleList<BigDecimal> sl = new SimpleList<BigDecimal>();
 sl.add(BigDecimal.ONE);
 log.info("SimpleList size is : " + sl.size());
 sl.add(BigDecimal.ZERO);
 log.info("SimpleList size is : " + sl.size());
 sl.clear();
 log.info("SimpleList size is : " + sl.size());
}

Y obtendría esta salida:

May 5, 2010 6:28:58 PM com.makotogroup.intro.Application main
INFO: El tamaño de la SimpleList es: 1
May 5, 2010 6:28:58 PM com.makotogroup.intro.Application main
INFO: El tamaño de la SimpleList es: 2
May 5, 2010 6:28:58 PM com.makotogroup.intro.Application main
INFO: El tamaño de la SimpleList es: 0


Tipos de enumeración

En JDK 5, un nuevo tipo de datos se agregó al lenguaje Java, denominado enum. No se lo debe confundir con java.util.Enumeration, enum representa un conjunto de objetos constantes que están todos relacionados con un concepto particular, cada uno de los cuales representa un valor constante diferente en ese conjunto. Antes de que se introdujera enum al lenguaje Java, usted habría definido un conjunto de valores constantes para un concepto (por ejemplo, gender) del siguiente modo:

public class Person {
 public static final String MALE = "male";
 public static final String FEMALE = "female";
}

Cualquier código que se necesite para hacer referencia a ese valor constante se habría escrito más o menos del siguiente modo:

public void myMethod() {
 //. . .
 String genderMale = Person.MALE;
 //. . .
}

Definición de constantes con enum

Usar el tipo enum hace que definir constantes sea mucho más formal y también más poderoso. Aquí está la definición de enum para Gender:

public enum Gender {
 MALE,
 FEMALE
}

Eso es solo el comienzo de lo que puede hacer con enums. De hecho, las enums son muy parecidas a las clases, por lo tanto pueden tener constructores, atributos y métodos:

package com.makotogroup.intro;

public enum Gender {
 MALE("male"),
 FEMALE("female");

 private String displayName;
 private Gender(String displayName) {
   this.displayName = displayName; 
 }

 public String getDisplayName() {
   return this.displayName;
 }
}

Una diferencia entre una clase y una enum es que el constructor de una enum debe declararse private y no puede extender (o heredar de) otras enums. Sin embargo, una enum puede implementar una interfaz.

Una enum implementa una interfaz.

Suponga que usted define una interfaz, Displayable:

package com.makotogroup.intro;
public interface Displayable {
 public String getDisplayName();
}

Su enum Gender podría implementar esta interfaz (así como también cualquier otra enum que se necesite para producir un nombre de pantalla amigable), como del siguiente modo:

package com.makotogroup.intro;

public enum Gender implements Displayable {
 MALE("male"),
 FEMALE("female");

 private String displayName;
 private Gender(String displayName) {
   this.displayName = displayName; 
 }
 @Override
 public String getDisplayName() {
   return this.displayName;
 }
}

Vea Resources para aprender más acerca de genéricos).

9 de 14 | Anterior | Siguiente

Comentario



static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=90
Zone=tecnologia Java
ArticleID=850709
TutorialTitle=Introducción a la programación Java, parte 2: Construcciones para aplicaciones del mundo real
publish-date=12102012
author1-email=steve.perry@makotoconsulting.com
author1-email-cc=