Programe con Eclipse

Requisitos del sistema

Para completar los ejercicios de este tutorial, instale y establezca un entorno de desarrollo que consista en:

• JDK 6 de Sun/Oracle.
• IDE Eclipse para desarrolladores Java.

En el tutorial, se incluyen instrucciones de descarga e instalación para ambos.

La configuración recomendada del sistema es la siguiente:

• Un sistema que soporte Java SE 6 con al menos 1GB de memoria principal. Java 6 tiene soporte en Linux®, Windows® y Solaris®.
• Al menos 20MB de espacio en disco para instalar los componentes y ejemplos del software.

Visión general de la plataforma Java

La tecnología Java se usa para desarrollar aplicaciones para un amplio alcance de entornos, desde dispositivos del consumidor hasta sistemas empresariales heterogéneos. En esta sección, obtenga una vista de alto nivel de la plataforma Java y sus componentes. Vea Recursos para aprender más acerca de los componentes de la plataforma Java discutidos en esta sección.

El lenguaje Java

Conozca las API de Java

La mayoría de los desarrolladores Java hacen referencia constantemente a la documentación API de Java online oficial, — también llamada el Javadoc (vea Recursos). De forma predeterminada, usted ve tres marcos en el Javadoc. El marco superior izquierdo muestra todos los paquetes en la API y debajo están las clases en cada paquete. El marco principal (a la derecha) muestra detalles del paquete o de la clase seleccionada actualmente. Por ejemplo, si selecciona el paquete java.util en el marco superior izquierdo y luego selecciona la clase ArrayList que aparece debajo de él, en el marco derecho, verá detalles acerca del ArrayList, que incluyen una descripción de lo que hace, cómo usarlo y sus métodos.

Como cualquier lenguaje de programación, el lenguaje Java tiene su propia estructura, reglas de sintaxis y paradigma de programación. El paradigma de programación del lenguaje Java se basa en el concepto de programación orientada a objetos (OOP), que las funciones del lenguaje soportan.

El lenguaje Java es un derivado del lenguaje C, por lo que sus reglas de sintaxis se parecen mucho a C: por ejemplo, los bloques de códigos se modularizan en métodos y se delimitan con llaves ({ y }) y las variables se declaran antes de que se usen.

Estructuralmente, el lenguaje Java comienza con paquetes. Un paquete es el mecanismo de espacio de nombres del lenguaje Java. Dentro de los paquetes se encuentran las clases y dentro de las clases se encuentran métodos, variables, constantes, entre otros. En este tutorial, aprenderá acerca de las partes del lenguaje Java.

El compilador Java

Cuando usted programa para la plataforma Java, escribe el código de origen en archivos .java y luego los compila. El compilador verifica su código con las reglas de sintaxis del lenguaje, luego escribe los códigos byte en archivos .class. Los códigos byte son instrucciones estándar destinadas a ejecutarse en una Java Virtual Machine (JVM). Al agregar este nivel de abstracción, el compilador Java difiere de los otros compiladores de lenguaje, que escriben instrucciones apropiadas para el chipset de la CPU en el que el programa se ejecutará.

La JVM

Al momento de la ejecución, la JVM lee e interpreta archivos .class y ejecuta las instrucciones del programa en la plataforma de hardware nativo para la que se escribió la JVM. La JVM interpreta los códigos byte del mismo modo en que una CPU interpretaría las instrucciones del lenguaje del conjunto. La diferencia es que la JVM es un software escrito específicamente para una plataforma particular. La JVM es el corazón del principio "escrito una vez, ejecutado en cualquier lugar" del lenguaje Java. Su código se puede ejecutar en cualquier chipset para el cual una implementación apropiada de la JVM está disponible. Las JVM están disponibles para plataformas principales como Linux y Windows y se han implementado subconjuntos del lenguaje Java en las JVM para teléfonos móviles y aficionados de chips.

El recolector de basura

En lugar de forzarlo a mantenerse a la par con la asignación de memoria (o usar una biblioteca de terceros para hacer esto), la plataforma Java proporciona una gestión de memoria lista para usar. Cuando su aplicación Java crea una instancia de objeto al momento de ejecución, la JVM asigna automáticamente espacio de memoria para ese objeto desde el almacenamiento dinámico, que es una agrupación de memoria reservada para que use su programa. El recolector de basura Java se ejecuta en segundo plano y realiza un seguimiento de cuáles son los objetos que la aplicación ya no necesita y recupera la memoria que ellos ocupan. Este abordaje al manejo de la memoria se llama gestión de la memoria implícita porque no le exige que escriba cualquier código de manejo de la memoria. La recogida de basura es una de las funciones esenciales del rendimiento de la plataforma Java.

El kit de desarrollo de Java

Cuando usted descarga un kit de desarrollo de Java (JDK), obtiene, — además del compilador y otras herramientas, — una librería de clase completa de programas de utilidad preconstruidos que lo ayudan a cumplir cualquier tarea común al desarrollo de aplicaciones. El mejor modo para tener una idea del ámbito de los paquetes y bibliotecas JDK es verificar la documentación API JDK (vea Recursos).

El Java Runtime Environment

El Java Runtime Environment (JRE, también conocido como el Java Runtime) incluye las bibliotecas de códigos de la JVM y los componentes que son necesarios para programas en ejecución escritos en el lenguaje Java. Está disponible para múltiples plataformas. Puede redistribuir libremente el JRE con sus aplicaciones, de acuerdo a los términos de la licencia del JRE, para darles a los usuarios de la aplicación una plataforma en la cual ejecutar su software. El JRE se incluye en el JDK.

Configuración de su entorno de desarrollo de Java

En esta sección, tendrá instrucciones para descargar e instalar el JDK 6 y el lanzamiento actual de IDE Eclipse y para configurar su entorno de desarrollo de Eclipse.

Si usted ya ha instalado el JDK e IDE Eclipse, tal vez quiera saltar a la sección Getting started with Eclipse o a la que le sigue, Object-oriented programming concepts.

Su entorno de desarrollo

El JDK incluye un conjunto de herramientas de línea de comandos para compilar y ejecutar su código Java, que incluye una copia completa del JRE. Aunque usted ciertamente puede usar estas herramientas para desarrollar sus aplicaciones, la mayoría de los desarrolladores valoran la funcionalidad adicional, la gestión de tareas y la interfaz visual de un IDE.

Eclipse es un IDE de código abierto popular para el desarrollo Java. Maneja las tareas básicas, tales como la compilación de códigos y la configuración de un entorno de depuración, para que pueda centrase en escribir y probar códigos. Además, puede usar Eclipse para organizar archivos de códigos de origen en proyectos, compilar y probar esos proyectos y almacenar archivos de proyectos en cualquier cantidad de repositorios de origen. Necesita tener instalado un JDK para usar Eclipse para el desarrollo Java.

Instale JDK 6

Siga estos pasos para descargar e instalar JDK 6:

1. Navegue hasta Java SE Downloads y haga clic en el recuadro Java Platform (JDK) para visualizar la página de descarga de la última versión del JDK (JDK 6, actualización 21 al momento de escritura).
2. Haga clic en el botón Download.
3. Seleccione la plataforma del sistema operativo que necesita.
4. Se le pedirá el nombre de usuario y contraseña de su cuenta. Ingréselos si tiene una cuenta, regístrese si no la tiene o puede hacer clic en Continue para saltar este paso y continuar para hacer la descarga.
5. Guarde el archivo en su unidad de disco duro cuando se lo solicite.
6. Cuando se complete la descarga, ejecute el programa de instalación. (El archivo que acaba de descargar es un archivo ZIP autoextraíble que también es el programa de instalación). Instale el JDK en su unidad de disco duro en un una ubicación fácil de recordar (por ejemplo, C:\home\jdk1.6.0_20 en Windows o ~/jdk1.6.0_20 en Linux). Es una buena idea codificar el número de actualización en el nombre del directorio de instalación que usted elija.

Ahora tiene un entorno Java en su máquina. A continuación, instalará el IDE Eclipse.

Instale Eclipse

Para descargar e instalar Eclipse, siga estos pasos:

1. Navegue hasta Eclipse Galileo Sr2 Packages.
2. Haga clic en Eclipse IDE for Java Developers.
3. Bajo los Enlaces de descarga en el lado derecho, seleccione su plataforma.
4. Seleccione la réplica desde la cual quiere hacer la descarga, luego guarde el archivo en su unidad de disco duro.
5. Extraiga los contenidos del archivo .zip a una ubicación en su disco duro que pueda recordar fácilmente (por ejemplo, C:\home\eclipse en Windows o ~/eclipse en Linux).

Configure Eclipse

El IDE Eclipse se coloca encima del JDK como una extracción útil pero todavía necesita acceder al JDK y sus diversas herramientas. Antes de que pueda usar Eclipse para escribir el código Java, tiene que indicarle dónde está ubicado el JDK.

Para configurar su entorno de desarrollo Eclipse:

1. Inicie Eclipse al hacer doble clic en eclipse.exe (o el ejecutable equivalente para su plataforma).
2. Aparecerá el Iniciador del espacio de trabajo, que le permitirá seleccionar una carpeta raíz para sus proyectos Eclipse. Elija una carpeta que recuerde fácilmente, por ejemplo C:\home\workspace en Windows o ~/workspace en Linux.
3. Descarte la pantalla Bienvenido a Eclipse.
4. Haga clic en Window > Preferences > Java > Installed JREs. La Ilustración 1 muestra la pantalla de configuración para el JRE:

   Ilustración 1. Configuración del JDK que Eclipse utiliza.

   
5. Eclipse indicará un JRE instalado. Necesita asegurarse de usar el que descargó con JDK 6. Si Eclipse no detecta automáticamente el JDK que usted instaló, haga clic en Add... y en el siguiente diálogo Standard VM, luego haga clic en Next.
6. Especifique el directorio de inicio del JDK (por ejemplo, C:\home\jdk1.6.0_20 en Windows), luego haga clic en Finish.
7. Confirme que el JDK que quiere usar esté seleccionado y haga clic en OK.

Ahora Eclipse está configurado y listo para que usted cree proyectos y compile y ejecute códigos Java. La siguiente sección lo familiarizará con Eclipse.

Comenzar a usar Eclipse

Eclipse no es solo un IDE, es todo un ecosistema de desarrollo. Esta sección es una breve introducción práctica para usar Eclipse para el desarrollo Java. Vea Recursos si quiere aprender más acerca de Eclipse.

El entorno de desarrollo de Eclipse

El entorno de desarrollo de Eclipse tiene cuatro componentes principales:

• Espacio de trabajo
• Proyectos
• Perspectivas
• Vistas

La unidad primaria de organización en Eclipse es el espacio de trabajo. Un espacio de trabajo contiene todos sus proyectos. Una perspectiva es un modo de observar cada proyecto (de ahí el nombre) y dentro de una perspectiva hay una o más vistas.

La perspectiva Java

La Ilustración 2 muestra la perspectiva Java, que es la perspectiva predeterminada para Eclipse. Debería ver esta perspectiva cuando inicie Eclipse.

Ilustración 2. Perspectiva Java de Eclipse

La perspectiva Java contiene las herramientas que necesita para comenzar a escribir las aplicaciones Java. Cada pestaña que se muestra en la Ilustración 2 es una vista para la perspectiva Java. Package Explorer y Outline son dos vistas particularmente útiles.

El entorno Eclipse tiene un alto grado de configuración. Cada vista es acoplable, por lo que puede desplazarla alrededor de la perspectiva Java y ubicarla donde quiera. Aunque por ahora, quédese con la configuración predeterminada de la perspectiva y de la vista.

Cree un proyecto

Siga estos pasos para crear un proyecto Java nuevo:

1. Haga clic en File > New > Java Project ... y verá un recuadro de diálogo que se abre como el que se muestra en la Ilustración 3:

   Ilustración 3. Asistente para el proyecto Java nuevo

   
2. Ingrese Intro como nombre del proyecto y haga clic en Finish.
3. Si quiere modificar los parámetros predeterminados del proyecto, haga clic en Next. (Esto se recomienda solo si tiene experiencia con el IDE Eclipse).
4. Haga clic en Finish para aceptar la configuración del proyecto y crear el proyecto.

Ahora ha creado un nuevo proyecto Java de Eclipse y carpeta de origen. Su entorno de desarrollo está listo para actuar. Sin embargo, una comprensión del paradigma OOP, — que se cubre en las siguientes dos secciones de este tutorial, — es esencial. Si usted está familiarizado con los conceptos y principios de OOP, tal vez quiera saltar a Getting started with the Java language.

Archivo del código Java

Ahora que ha aprendido un poco sobre la escritura de aplicaciones Java, puede que se esté preguntando cómo empaquetarlas para que otros desarrolladores puedan usarlas o cómo importar códigos de otros desarrolladores en sus aplicaciones. Esta sección le muestra cómo.

JAR

El JDK se envía con una herramienta llamada JAR, que significa Java Archive (archivo Java). Use esta herramienta para crear archivos JAR. Una vez que haya empaquetado su código en un archivo JAR, otros desarrolladores pueden simplemente dejar el archivo JAR en sus proyectos y configurar sus proyectos para usar su código.

Crear un archivo JAR en Eclipse es facilísimo. En su espacio de trabajo, haga clic derecho en el paquete com.makotogroup.intro y seleccione Export. Verá el diálogo que se muestra en la Ilustración 8. Elija Java > JAR file.

Ilustración 8. Recuadro de diálogo de exportación.

Cuando se abra el siguiente recuadro de diálogo, navegue hasta la ubicación donde quiere almacenar su archivo JAR y coloque el nombre que quiera al archivo. La extensión .jar es la predeterminada, que recomiendo usar. Haga clic en Finish.

Verá su archivo JAR en la ubicación que seleccionó. Puede usar las clases en él desde su código si lo pone en su ruta de desarrollo en Eclipse. Hacer eso es facilísimo también, como verá a continuación.

Uso de aplicaciones de terceros

Mientras usted se siente más y más cómodo al escribir aplicaciones Java, querrá usar más y más aplicaciones de terceros para soportar su código. A modo de ejemplo, digamos que usted quiere usar joda-time, una biblioteca de sustitución JDK para hacer manejo de fecha/tiempo, manipulaciones y cálculos.

Supongamos que ya ha descargado joda-time, que se almacena en un archivo JAR. Para usar las clases, su primer paso es crear un directorio lib en su proyecto y dejar el archivo JAR en él:

1. Haga clic derecho en la carpeta raíz Intro en la vista Project Explorer.
2. Elija New > Folder y llame la carpeta lib.
3. Haga clic en Finish.

La carpeta nueva aparece al mismo nivel que src. Ahora copie el archivo .jar joda-time en su nuevo directorio lib. Para este ejemplo, el archivo se llama joda-time-1.6.jar. (Al nombrar un archivo JAR es común incluir el número de la versión).

Ahora todo lo que necesita hacer es comunicarle a Eclipse que incluya las clases del archivo joda-time-1.6.jar en su proyecto:

1. Haga clic derecho en el proyecto Intro en su espacio de trabajo, luego seleccione Properties.
2. En el recuadro de diálogo de Propiedades, seleccione la pestaña de Bibliotecas, como se muestra en la Ilustración 9:

   Ilustración 9. Properties > Java Build Path

   
3. Haga clic en el botón Add External JARs, luego navegue hasta el directorio lib del proyecto, seleccione el archivo joda-time-1.6.jar y haga clic en OK.

Una vez que Eclipse haya procesado los códigos (es decir, los archivos de clases) en el archivo JAR, están disponibles para hacer referencia (importar) desde su código Java. Observe en Project Explorer que hay una carpeta nueva llamada Bibliotecas referenciadas que contiene el archivo joda-time-1.6.jar.

¿Qué es un bucle?

Un bucle es una construcción de programación que se ejecuta repetidamente mientras se cumple alguna condición (o conjunto de condiciones). Por ejemplo, puede pedirle a un programa que lea todos los registros hasta el final de un archivo o que realice un bucle por todos los elementos de una matriz, procesando cada uno. (Aprenderá acerca de las matrices en la sección Java Collections de este tutorial).

Bucles for

La construcción de bucle básico en el lenguaje Java es la sentencia for, que le permite iterar un rango de valores para determinar cuántas veces ejecutar un bucle. La sintaxis abstracta para un bucle for es:

1 2 3

for (initialization; loopWhileTrue; executeAtBottomOfEachLoop) {   statementsToExecute }

Al comienzo del bucle, se ejecuta la sentencia de inicialización (las sentencias de inicialización múltiples se pueden separar con comas). Mientras loopWhileTrue (una expresión condicional de Java que debe evaluar ya sea como verdadero o falso) sea verdadero, el bucle se ejecutará. Al final del bucle, se ejecuta executeAtBottomOfEachLoop.

Ejemplo de un bucle for

Si usted quisiera cambiar a un método main() para que se ejecute tres veces, podría usar un bucle for, como se muestra en el Listado 9:

Listado 9. Un bucle for

1 2 3 4 5 6 7 8 9 10 11 12 13

public static void main(String[] args) {   Logger l = Logger.getLogger(Person.class.getName());   for (int aa = 0; aa < 3; aa++) {     Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");     l.info("Loop executing iteration# " + aa);     l.info("Name: " + p.getName());     l.info("Age:" + p.getAge());     l.info("Height (cm):" + p.getHeight());     l.info("Weight (kg):" + p.getWeight());     l.info("Eye Color:" + p.getEyeColor());     l.info("Gender:" + p.getGender());   } }

La variable local aa se inicializa en cero al comienzo del listado. Esta sentencia se ejecuta solo una vez, cuando se inicializa el bucle. Luego, el bucle continúa tres veces y cada vez se incrementa aa en uno.

Como verá más adelante, una sintaxis alternativa de bucle for está disponible para realizar un bucle por las construcciones que implementan la interfaz Iterable (tales como matrices y otras clases de programas de utilidad Java). Por ahora, solo observe el uso de la sintaxis del bucle for en el Listado 9.

Bucles while

La sintaxis para un bucle while es:

1 2 3

while (loopWhileTrue) {   statementsToExecute }

Como puede sospechar, while loopWhileTrue evalúa como verdadero, por lo tanto el bucle se ejecutará. En la parte superior de cada iteración (es decir, antes de que se ejecute cualquier sentencia), se evalúa la condición. Si es verdadero, el bucle se ejecuta. Por lo que es posible que un bucle while nunca se ejecute si su expresión condicional no es verdadera por lo menos una vez.

Observe de nuevo el bucle for en el Listado 9. Por comparación, el Listado 10 lo codifica usando un bucle while:

Listado 10. Un bucle while

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public static void main(String[] args) {   Logger l = Logger.getLogger(Person.class.getName());   int aa = 0;   while (aa < 3) {     Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");     l.info("Loop executing iteration# " + aa);     l.info("Name: " + p.getName());     l.info("Age:" + p.getAge());     l.info("Height (cm):" + p.getHeight());     l.info("Weight (kg):" + p.getWeight());     l.info("Eye Color:" + p.getEyeColor());     l.info("Gender:" + p.getGender());     aa++;   }

Como puede ver, un bucle while requiere un poco más de mantenimiento que un bucle for. Usted debe inicializar la variable aa y también recordar incrementarla al final del bucle.

Bucles do...while

Si usted quiere un bucle que se ejecute siempre una vez y luego verifique su expresión condicional, pruebe usar un bucle do...while, como se muestra en el Listado 11:

Listado 11. Un bucle do...while

1 2 3 4 5 6 7 8 9 10 11 12

int aa = 0; do {   Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");   l.info("Loop executing iteration# " + aa);   l.info("Name: " + p.getName());   l.info("Age:" + p.getAge());   l.info("Height (cm):" + p.getHeight());   l.info("Weight (kg):" + p.getWeight());   l.info("Eye Color:" + p.getEyeColor());   l.info("Gender:" + p.getGender());   aa++; } while (aa < 3);

La expresión condicional (aa < 3) no se verifica hasta el final del bucle.

Ramificación del bucle

Hay momentos en los que necesita retirarse de un bucle antes de que la expresión condicional evalúe como falso. Esto podría suceder si usted estuviera buscando una matriz de Strings para un valor particular y, una vez que lo encontrara, no le importara los otros elementos de la matriz. Para aquellos momentos en que usted solo quiere retirarse, el lenguaje Java proporciona la sentencia break, como se muestra en el Listado 12:

Listado 12. Una sentencia break

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public static void main(String[] args) {   Logger l = Logger.getLogger(Person.class.getName());   int aa = 0;   while (aa < 3) {     if (aa == 1)       break;     Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");     l.info("Loop executing iteration# " + aa);     l.info("Name: " + p.getName());     l.info("Age:" + p.getAge());     l.info("Height (cm):" + p.getHeight());     l.info("Weight (kg):" + p.getWeight());     l.info("Eye Color:" + p.getEyeColor());     l.info("Gender:" + p.getGender());     aa++;   }

La sentencia break lo lleva a la siguiente sentencia ejecutable fuera del bucle en el que se ubica.

Continuación del bucle

En el ejemplo (simplista) del Listado 12, usted solo quiere ejecutar el bucle una vez y retirarse. También puede saltar una sola iteración de un bucle pero continúa ejecutando el bucle. Para eso, necesita la sentencia continue, que se muestra en el Listado 13:

Listado 13. Una sentencia continue

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public static void main(String[] args) { Logger l = Logger.getLogger(Person.class.getName()); int aa = 0; while (aa < 3) {   if (aa == 1)     continue;   else     aa++;   Person p = new Person("Joe Q Author", 42, 173, 82, "Brown", "MALE");   l.info("Loop executing iteration# " + aa);   l.info("Name: " + p.getName());   l.info("Age:" + p.getAge());   l.info("Height (cm):" + p.getHeight());   l.info("Weight (kg):" + p.getWeight());   l.info("Eye Color:" + p.getEyeColor());   l.info("Gender:" + p.getGender()); }

En el Listado 13, usted salta la segunda iteración de un bucle pero continúa con la tercera. continue es de ayuda cuando está, digamos, procesando registros y se encuentra con un registro que definitivamente no quiere procesar. Solo salte ese registro y siga con el siguiente.