El rey actual de los lenguajes de programación, Java, se está convirtiendo por méritos propios en el imprescindible protagonista de todos los cursos, asignaturas y módulos profesionales que versan sobre iniciación a la programación. Pero Java es un lenguaje orientado a objetos, y esto supone un desafío para todos aquellos que, incluso teniendo gran experiencia en lenguajes estructurados como Pascal o C, quieren aprenderlo o enseñarlo. Las peculiaridades de este tipo de lenguajes han motivado la aparición de entornos de programación específicamente adaptados para su enseñanza: este monográfico te presenta dos de los más utilizados ( BlueJ y jGrasp) confrontándolos con un entorno de desarrollo profesional (NetBeans).

1. Introducción

Hasta hace no demasiados años, los compiladores se utilizaban introduciendo órdenes escritas en la línea de comandos. El proceso no era sencillo: para empezar, el programador tenía que preparar el código fuente usando alguno de los rudimentarios editores de texto existentes; a continuación abandonaba el editor para ejecutar la llamada al compilador y obtener el código compilado. Después solía ser necesario utilizar otra herramienta para el ensamblado del programa. Finalmente, podía probar (también desde la línea de comandos) el archivo ejecutable: pero ante cualquier error detectado, debía volver a empezar este proceso.

No es de extrañar, por tanto, que poco a poco fuera desarrollándose el concepto de lo que se ha terminado llamando IDE (Integrated Development Environment o entorno de desarrollo integrado). Como su nombre indica, su objetivo es integrar en una misma aplicación las herramientas necesarias para realizar todo el proceso de programación: edición, compilación, revisión de errores, depuración, ejecución.... El resultado es que utilizando un IDE, compilar y ejecutar un programa requiere únicamente pulsar un botón.

Existen muchísimos entornos para cada lenguaje de programación, y cada uno de ellos ofrece al usuario unas determinadas funcionalidades. Escoger uno u otro dependerá tanto de nuestras necesidades como de lo intuitivo y agradable que resulte trabajar en uno u otro entorno. Normalmente el programador va probando entornos hasta que encuentra aquel con el que se encuentra más cómodo, pero en el caso que nos ocupa (la enseñanza de Java) nos interesa ir sobre seguro y escoger un entorno que ofrezca al alumno sencillez de uso, facilidad para comprender las ideas subyacentes en el proceso de programación, y estimulación para animarse a hacer programas por sí mismo. Cualquiera de los tres entornos que se presentan en este monográfico será una buena elección de cara a la enseñanza del lenguaje.

Antes de empezar, ten en cuenta que un entorno de desarrollo no es más que una fachada para el proceso de compilación y ejecución de un programa. Eso quiere decir que no basta con tener un IDE instalado en el ordenador para empezar a trabajar: previamente debemos instalar el compilador, un proceso que en Java suele generar bastante confusión.

En esta primera entrega nos centraremos precisamente en eso: la instalación del compilador en nuestro equipo. Además, se explicarán las particularidades de los lenguajes orientados a objetos que tendremos en cuenta a la hora de escoger nuestro entorno.

2. A vueltas con las siglas: ¿JRE ó JDK?

Si has intentado alguna vez abordar la programación en Java quizá te hayas desanimado antes de empezar, y es que la instalación de Java resulta algo compleja: veamos por qué.

Sabemos que existen lenguajes compilados y lenguajes interpretados:

¿Y qué es Java? ¿Compilado o interpretado? Pues ninguna de las dos, o mejor dicho las dos a la vez. Java compila el programa a un lenguaje intermedio predigerido llamado bytecode (archivos con extensión .class) común a todas las plataformas. A partir de ahí funciona como un lenguaje interpretado gracias al entorno de ejecución de Java, un intérprete diferente para cada plataforma y que deberá estar instalado en nuestro ordenador si queremos ejecutar programas escritos en Java. Las continuas mejoras en esta máquina virtual realizadas por Sun, la empresa creadora del lenguaje, hacen que las diferencias de velocidad de ejecución entre Java y un lenguaje totalmente compilado (como C) sean cada vez menores.

El resultado es el exhibido por el lema de Java: compile o­nce, run anywhere. Es decir, sólo necesitas compilar el programa una vez y podrá ejecutar en múltiples y diversas máquinas, siempre que éstas tengan instalado el entorno de ejecución.

Ahora podemos comprender mejor los dos paquetes que nos ofrece Sun para instalar Java:

Hemos dicho que los entornos de desarrollo requieren tener instalado el compilador. Por ejemplo, si intentas ejecutar BlueJ sin haber instalado previamente el JDK, obtendrás este mensaje:

Algo parecido ocurre en jGrasp:

Entonces, ¿qué debemos hacer? Si contamos con el consentimiento del resto de usuarios del equipo, lo mejor es desinstalar todas las versiones existentes de Java y reinstalar únicamente el JDK más actual. Por ejemplo, en la siguiente figura conviven dos entornos de ejecución, uno antiguo (versión 1.4) y otro más moderno (versión 6 actualización 3), así como un JDK (versión 6, actualización 4). No te preocupes demasiado por Java DB: se trata de un añadido para bases de datos que se instala junto con el JDK. Por tanto, en este caso desinstalaríamos los cuatro elementos que empiezan por Java:

A continuación, accedemos a la página oficial de Java dentro de la web de Sun y escogemos la versión SE (Standard Edition) frente a otras como la versión empresarial (EE):

Ahora nos encontramos en la página de descargas de la versión estándar (SE) de Java. Aquí debemos hacer nuevas elecciones: tenemos el JRE (que como ya hemos visto no nos interesa, pues sólo nos serviría para ejecutar programas), el JDK y los paquetes JDK (bundles), que incluyen algún añadido en la misma descarga. ¿Cuál escogeremos? Depende. Si tienes intención de probar el entorno NetBeans, escoge el lote que lo lleva incluido. En caso contrario, escoge únicamente el JDK. No te preocupes demasiado por tu elección, ya que si más adelante cambias de idea puedes instalar (o desinstalar) NetBeans sin problemas.

Como se ve en la imagen, en el momento de escribir este artículo la última versión era la 6, actualización 14. Para mayor confusión, 6 es el número de la versión de cara al público, pero el número con el que Sun identifica internamente esta versión es 1.6, siendo el auténtico nombre de este JDK "1.6_14" ó "1.6.0_14". Conviene estar familiarizado con este detalle: mira de nuevo las pantallas de error de jGrasp y BlueJ un poco más arriba. Cuando nos dicen que se requiere JDK 1.5 o superior, se nos pide haber instalado el JDK 5 o superior. Otro ejemplo: mira ahora la imagen de la ventana Agregar o quitar programas que mostramos anteriormente. Observa que uno de los dos JREs instalados en este equipo tiene como versión "1.4", lo que correspondería al nombre de cara al público JDK 4.

3. El problema de las versiones

El proceso de instalación del JDK es trivial, y no reviste ninguna dificultad. Sin embargo, cuando empieces a trabajar es posible que te enfrentes a ciertos problemas relativos a las distintas versiones existentes en los equipos tanto del JDK como del JRE. Este apartado te previene para que no desesperes si te ocurren y sepas reaccionar, pero si lo deseas puedes posponer su lectura y regresar sólo si encuentras dificultades.

Supongamos que hemos estado desarrollando un programa en el ordenador del centro de trabajo, y nos lo llevamos a casa. Es posible que al intentar ejecutarlo en tu equipo encuentres este críptico mensaje de error: Unsupported major.minor version. ¿Cómo es posible, si en el centro ejecutaba perfectamente? Se trata de un error muy común, y la explicación es la siguiente: con un JRE moderno puedes ejecutar programas compilados con un JDK antiguo, pero no sucede lo mismo al revés. Un JRE antiguo no sabrá ejecutar programas compilados con un JDK moderno. En nuestro caso de ejemplo, en el equipo de casa teníamos una versión de Java más antigua, y eso ha motivado el problema. ¿La solución? Lo ideal será instalar en casa la última versión de Java, pero existe una alternativa más rápida: elimina los archivos compilados (.class) del proyecto para forzar a tu equipo a recompilar las clases usando el compilador más antiguo.

Este problema afecta también con frecuencia a quienes prefieren trabajar a la antigua usanza, es decir, con la línea de comandos. El caso típico es el siguiente: tenemos instalada  la última versión del JDK, compilamos el programa pero no conseguimos hacerlo ejecutar. El motivo es el mismo: tratamos de ejecutar un programa con un JRE obsoleto, seguramente sin darnos cuenta. El diagnóstico es sencillo: ejecuta el comando java -version y sabrás qué versión del JRE estás utilizando:

Si al hacerlo ves una versión antigua (por ejemplo 1.4), ya has detectado el problema. Pero ¿cómo es posible, si instalaste la última versión de Java? Ten en cuenta que algunas aplicaciones (por ejemplo ciertos paquetes del gestor de bases de datos Oracle) pueden llevar incluido un entorno de ejecución sin que a veces seamos conscientes de ello, y por llevar instalados más tiempo en nuestro equipo, su ruta aparece antes en la variable de sistema PATH. La solución es sencilla: edita esta variable y sitúa al principio del todo la ruta a nuestra última versión de Java.

Volviendo a la actualización, seguramente estés pensando: ¿puedo realmente actualizar el JRE y el JDK sin perjudicar a otras personas que utilicen el mismo equipo? La respuesta, siempre que actualicemos a versiones más modernas, es sí; pero estrictamente hablando debemos matizar esta afirmación. Como todos los lenguajes Java va evolucionando, y algunas características se convierten en obsoletas (deprecated). Es posible que, al cabo de algunas versiones, al intentar compilar un programa muy antiguo haya alguna sentencia que con la nueva versión provoque un fallo de compilación. Sin embargo, es prácticamente imposible que eso ocurra en el nivel en que nos encontramos y además, incluso en ese caso, lo correcto sería corregir las escasas líneas que dieran problemas para actualizarlas según la sintaxis actual del lenguaje. Así que no temas actualizar el JDK: siempre será una buena idea.

4. Las peculiaridades de enseñar Java

Cuando una persona aprende a programar en Pascal, Modula 2 ó C, no está simplemente aprendiendo esos lenguajes: está comprendiendo también el paradigma de programación estructurada, y por tanto sabrá pasar de un lenguaje a otro con gran facilidad, tan pronto como se acostumbre a las peculiaridades sintácticas de cada lenguaje. De igual forma, cuando aprendemos Java debemos desentrañar el paradigma de programación orientada a objetos, que difiere bastante del anterior. Por tanto debemos tener en cuenta que, incluso si nuestros alumnos tienen nociones de programación en lenguajes estructurados - o nosotros mismos como docentes las tenemos - será necesario cierto esfuerzo para cambiar el enfoque sobre la forma de diseñar y abordar nuestros programas.

Explicar las características de Java excede el propósito de este monográfico, pero es interesante destacar algunos aspectos que afectarán a la decisión de qué entorno de trabajo escoger. Y es que si en los lenguajes clásicos nos enfrentábamos a un problema pensando cómo hay que resolverlo, en Java pensaremos qué necesitamos para resolverlo. En efecto, un programa en Java es como una obra de teatro en la que debemos preparar primero cada personaje, definir qué características tiene y qué va a saber hacer: una vez ese trabajo previo esté realizado, la obra se desarrollará sacando personajes a escena y haciéndoles interactuar.

Cuando hablamos de preparar personajes, nos referimos a programar clases. Igual que tenemos un tipo de datos entero para representar números y un tipo String para representar cadenas de texto, ¿no sería perfecto disponer de un tipo Cuadrado, Persona, Avión, Factura, ListaDeClientes, etc. según las necesidades de nuestro problema? Pues eso es precisamente lo que haremos en Java: crearemos una clase Rectángulo y definiremos sus atributos (la base, la altura, el color...) y sus métodos (lo que sabe hacer: calcular su área, dibujarse en la pantalla...). Una vez esté hecha, en mi programa principal podré crear todos los objetos que quiera de esa clase y personalizarlos con sus distintos atributos. Así, las clases y los objetos son el equivalente a tipos y variables: igual que declaro una variable entera x del tipo entero, creo un objeto juan de la clase Cliente. La diferencia es que el objeto juan no es una simple variable: incluye todos sus datos personales, y es capaz de hacer cosas como calcular su edad - con el código juan.calcularEdad()-, imprimir sus ventas - juan.imprimirDatosVentas() -, y todo aquello para lo que le hayamos preparado.

Pero si lo que definimos son únicamente tipos, ¿dónde está el auténtico programa principal? Debe existir un método especial, llamado main, que sí nos recordará a los lenguajes estructurados; sólo que en este caso su misión consistirá únicamente en crear objetos a imagen de la clase (sacarlos a escena) y pedirles que hagan cosas. Es aconsejable incluir este método especial en una clase aparte con un nombre significativo como Test o Principal, para que el alumno entienda que esa clase no representa ningún concepto (una figura, una persona) sino que simplemente alberga el método principal.

Una de las grandes ventajas de Java es que las empresas pueden repartir el trabajo de programación, encargando el desarrollo de diferentes clases a diferentes personas. La integración del trabajo es sencilla dado que las clases son cajas negras: sólo necesitas saber qué atributos tiene la clase Cuadrado y qué métodos posee. Pero por complicado que fuese para quien lo programó, no necesitas saber cómo resolvió el método calcularArea de una figura: te basta con saber que está disponible.

¿Y en qué afecta todo esto a nuestra labor docente y al entorno? Veamos algunas conclusiones interesantes:

• La fase previa a la programación en Java es muy creativa: se trata de diseñar las clases que voy a necesitar, y modelarlas según el problema que quiero resolver. ¿Qué es para mí un cuadrado? Si mi problema es trigonométrico,su atributo será el lado. Pero en otros contextos quizá necesite conocer el material de que está hecho, o su color. Algo parecido pasa con los métodos. ¿Qué voy a querer pedirle a un cuadrado? Quizá que calcule su área, o quizá que se dibuje en la pantalla.
• Las clases están pensadas para ser reutilizadas por otras personas distintas a aquella que la programó. Para ello es fundamental documentar nuestro trabajo: el programador, de un vistazo, debe poder saber qué atributos tiene la clase y de qué métodos dispone. Existen dos herramientas básicas para esta misión: la documentación JavaDoc (una página web estándar en la que se resume todo el contenido de la clase, cuyo uso no será cubierto en este artículo) y los diagramas de clases, que muestran para cada clase sus atributos, sus métodos y su relación con otras clases. Dichos diagramas pueden tener este aspecto:

Por tanto, conviene habituar al alumno a comenzar su trabajo diseñando las clases sobre el papel utilizando este tipo de diseños. Será interesante que el entorno sea capaz de crear por sí mismo diagramas a partir del código introducido, para que el alumno pueda contrastar su idea original con la clase que realmente está programando. Una buena práctica consistirá en que un alumno trate de utilizar una clase programada por otro compañero, disponiendo únicamente del diagrama de clases. Pero sigamos con las conclusiones:

5. Escogiendo un entorno de desarrollo

Ya estamos listos para empezar: con el JDK instalado, y teniendo en mente los aspectos que debemos destacar en la enseñanza de Java, pasaremos a analizar tres entornos de desarrollo en sendas entregas de este monográfico. Para cada uno de ellos encontrarás las siguientes secciones:

Un último apunte: aunque los tres entornos estudiados tienen versiones para Linux, las explicaciones se han hecho sobre la versión de Windows, por ser el sistema operativo más frecuentemente encontrado a día de hoy en los centros educativos.

Entorno de desarrollo jGrasp

jGrasp es un entorno de programación ligero surgido en el ámbito universitario, concretamente en la universidad de Auburn. Te permitirá trabajar con distintos lenguajes de programación, aunque lógicamente en el contexto de este monográfico nos centraremos en sus posibilidades de cara al lenguaje Java.

1. Puesta a punto

Lo primero que haremos será acudir a su página web y descargar la última versión disponible. La instalación es sencilla y no se nos preguntará nada durante el proceso; por otra parte, si instalaste el JDK previamente como hemos sugerido, jGrasp lo detectará automáticamente y no tendrás que configurarlo. En cualquier caso y si tuvieras varias versiones de JDK conviviendo en el equipo, siempre puedes acceder a la opción Settings > Compiler Settings para cerciorarte de qué JDK estás utilizando. Es el momento de arrancar el programa:

La pantalla principal está dividida en tres partes, que pueden redimensionarse en cualquier momento según nos interese:

Es posible que no te satisfaga la estética del entorno de trabajo, y es que éste no es sin duda el punto fuerte de jGrasp. Sin embargo, a través del menú Settings > Look and feel, puedes elegir entre cinco temas visuales hasta encontrar uno que te guste más:

Volvamos al aspecto original para comenzar a editar nuestro primer programa. Accede al menú File > New > Java y teclea un programa, guardándolo después con el icono del diskette o a través del menú File > Save. Recuerda que en Java es fundamental que el nombre del archivo coincida exactamente con el nombre de la clase, respetando las mayúsculas. Los convenios nos dicen que todas los nombres de clase empiezan por mayúscula, mientras que los métodos y atributos lo hacen en minúscula. También puedes recuperar una clase guardada mediante el icono de la carpeta o el menú File > Open. En esta imagen verás los tres botones con los que vamos a trabajar: compilar (cruz verde), ejecutar (un hombre corriendo, del inglés run para ejecutar) y depurar el programa (un insecto, del término inglés bug utilizado para designar fallos de programación).

Inevitablemente, todos cometemos errores al programar. jGrasp nos irá informando de nuestras equivocaciones con el mayor detalle posible, indicándonos el número de línea en que ha detectado el error, la posición exacta del mismo, y un mensaje explicativo. Ten en cuenta que los mensajes no siempre serán precisos, ni siquiera el número de línea: muchas veces un fallo se achaca a una línea cuando el auténtico motivo del error se encontraba en la anterior.

Aunque jGrasp nos resaltará en color gris la línea conflictiva, suele resultar útil activar la numeración de líneas en el código para localizar los fallos más fácilmente. Podrás hacerlo con el menú View > Line numbers.

Cuando todo salga bien, es el momento de ejecutar el programa:

¡Ya hemos terminado! Tu primera clase ha sido compilada y ejecutada con éxito; veamos ahora funcionalidades algo más avanzadas.

2. Sacándole partido

Hemos dicho que los programas en Java están normalmente constituidos por varias clases. Por ello, todos los entornos de desarrollo permiten crear proyectos para tener rápido acceso a todas las clases que van a participar en nuestro programa. jGrasp no es una excepción, así que vamos a ver cómo podemos dar forma a un sencillo proyecto Java. Para empezar, accede al menú Project > New > New Standard Project:

A continuación añadirás las clases que quieres utilizar. Si aún no las has programado, podrás irlas incorporando después. Ten en cuenta que las clases del proyecto pueden estar repartidas por tus unidades de disco, aunque te resultará más cómodo agruparlas en tu directorio de trabajo. Observa ahora en la parte izquierda la ventana proyectos abiertos, en la que tienes acceso rápido a los archivos que has incluido en el proyecto.

Se echa de menos, sin embargo, una diferenciación visual de los paquetes. En Java, cuando tenemos un conjunto de clases que están relacionadas entre sí, solemos agruparlas en paquetes (un concepto similar al de librería). Por ejemplo, las clases Círculo, Cuadrado y Rectángulo podrían agruparse en un paquete llamado figuras. Esta agrupación exige dos cosas:

Una de las ventajas de esta agrupación es que desde una clase puedes referenciar a otra del mismo paquete sin necesidad de importarla. jGrasp permite esto, pero lo lógico sería que en la ventana de proyecto las clases estuviesen agrupadas visualmente por paquetes, y eso no ocurre.

Entre las funcionalidades más interesantes de jGrasp está su diseño automático de diagramas UML (el estándar más utilizado para esquematizar programas) para tu proyecto, mostrando además las relaciones entre las clases.  

Cuando pulsas en una clase, a la izquierda verás con todo detalle sus atributos y sus métodos. El alumno podrá contrastar así el diagrama de clases que realizó antes de programar, y el resultado que ha obtenido finalmente:

jGrasp ofrece otro tipo de diagramas, llamados de estructuras de control (CSD), accesibles a través el botón señalado en la siguiente figura. Siguiendo una notación que puedes estudiar en la documentación del programa, el alumno podrá ver representadas gráficamente las distintas estructuras de control de flujo, tanto de selección (if, switch) como de iteración (while,for). Adicionalmente, unas flechas horizontales identifican los puntos en que un método recibe o devuelve valores. Este tipo de diagramas puede plegarse y desplegarse con el ratón para facilitar la visión global de la clase. Cuando un fragmento de código está oculto, aparece un signo +.

Sigamos con funcionalidades interesantes de cara a la docencia: ya dijimos que Java desafía la paciencia del programador aficionado, ya que hasta que todas las clases no están listas no podemos programar un método principal que resuelva problemas. Para aliviar esta espera, jGrasp incorpora una interfaz visual para crear objetos sobre la marcha, poniéndolos en un banco de trabajo (ventana izquierda) y permitiendo interactuar con ellos. En la siguiente imagen puedes ver cómo creamos un objeto de la clase Triángulo, indicando los valores necesarios para construirlo. Una vez creado, puedes examinar los atributos del objeto e invocar sus métodos pulsando el botón derecho del ratón y escogiendo Invoke method.

Observa también en la imagen anterior el recuadro Evaluar expresión, también en la ventana izquierda: nos servirá para escribir breves fragmentos de código Java para probar su funcionamiento. Estos fragmentos pueden aludir a los objetos creados en el banco de trabajo.

El banco de objetos es sin duda un gran arma didáctica de la que el profesor podrá sacar mucho partido, incorporada primero por BlueJ y añadida después (de una forma menos intuitiva, todo hay que decirlo) en el entorno que ahora nos ocupa. Aunque no lo haremos en este monográfico, te recomendamos probar más adelante las opciones de visualización para estructuras de almacenamiento (como un ArrayList).

La última funcionalidad que vamos a repasar es la depuración, que nos ayuda a localizar en qué punto de nuestro programa se encuentra ese fallo que no conseguimos encontrar. La base de toda depuración consiste en los llamados breakpoints o puntos de ruptura: simplemente haz click en la columna gris a la izquierda de la línea de código en la que sospechas que puede haber problemas, y verás cómo aparece un círculo rojo. Si una vez hecho esto ejecutas el programa pulsando en el icono de depuración, verás cómo la ejecución se detiene cuando el programa llegue a la línea que has marcado. Es como pulsar el botón de pausa mientras vemos una película: ahora, en la ventana izquierda, podremos inspeccionar el estado de nuestros objetos, comprobando si tienen los valores que deberían tener y permitiéndonos así localizar la causa del error.

Como se muestra en la imagen, los botones superiores nos permitirán reanudar controladamente la ejecución a partir de este punto, ofreciendo múltiples opciones: desde seguir paso a paso, ejecutando instrucción por instrucción, hasta continuar la ejecución abandonando la depuración. También podemos decidir si, en caso de que la siguiente línea corresponda a una llamada a un método, queremos introducirnos en el código de dicho método paso a paso o preferimos que lo ejecute normalmente pero se detenga al terminar. Las opciones en depuradores profesionales son muchas más, pero jGrasp ofrece las más utilizadas: es más, seguramente para el usuario medio sobran la mitad de los botones de que disponemos.

Terminaremos lamentando la ausencia de documentación sobre este programa en español: si bien existen tutoriales y un manual de uso, a día de hoy todos están en lengua inglesa.

3. Valoración

A continuación se indican los aspectos que sobresalen en jGrasp, para bien o para mal, respecto al resto de entornos estudiados:

Puntos fuertes de jGrasp

Puntos débiles de jGrasp

Entorno de desarrollo BlueJ

BlueJ es un sencillo entorno de programación exclusivamente diseñado para la enseñanza y el aprendizaje de Java. Se trata de un proyecto nacido en el seno de un grupo de investigación universitario integrado por miembros británicos y australianos. Por sus novedosas características, en poco tiempo BlueJ alcanzó una gran popularidad en entornos docentes.

1. Puesta a punto

Lo primero que haremos será descargar el programa de su página web y proceder a instalarlo. El procedimiento es trivial y, asumiendo que ya tuvieses instalado el JDK, no tendrás que configurar absolutamente nada para empezar a trabajar; pero antes de programar nuestra primera clase, debemos hacer una aclaración previa.

La pantalla principal aparecerá en gris hasta que creemos un proyecto. En BlueJ existe una desafortunada confusión entre el término proyecto, tal y como suele entenderse en los IDEs, y el concepto de paquete, antes explicado. Así, un proyecto BlueJ es igual que un paquete, pero en aras de simplificar se eliminan las líneas de código package, obligatorias según la norma de Java. Si trabajar con paquetes es prioritario para ti, BlueJ no es definitivamente la mejor opción. ¿Significa esto que no podemos utilizar en BlueJ paquetes de clases programados en otros entornos? Existe una forma de incluirlos en nuestro proyecto, Project > Open non BlueJ, pero sin duda no resulta nada intuitivo.

No nos quedemos con este defecto, sin duda uno de los pocos que presenta el entorno: creemos un nuevo proyecto con Project > New Project y ya podremos empezar a trabajar. La pantalla se mostrará así:

Como ves, la pantalla principal es tremendamente sencilla. A la izquierda tenemos los botones de nueva clase y compilar; a la derecha la ventana principal, en la que veremos el esquema de clases. Abajo está el banco de objetos, similar al de jGrasp, que se estudiará más adelante. Por último, una barra gris cambiará de color y se pondrá en movimiento cuando haya un programa en ejecución.

Existen dos formas de añadir una clase al proyecto: la primera es crearla nosotros mismos, mediante el botón New Class. La segunda es añadir una clase existente, mediante el menú Edit > Add class from file. Ten en cuenta que esta clase se copiará al directorio del proyecto actual, mientras que en jGrasp esto no ocurría: simplemente se utilizaba la clase desde su ubicación original. Por otra parte no hace falta que te preocupes de guardar las clases, ya que BlueJ lo hará por ti cada vez que compiles o cuando cierres el programa.

El entorno incluye un sencillo asistente para crear clases, cuya misión es proporcionarte un modelo o esqueleto de código sobre el que trabajar. Este borrador será distinto si queremos hacer una clase estándar o, por ejemplo, un applet (aplicación gráfica de ventana). Sin embargo, y ya que la misión es aprender, quizá sea mejor borrar la propuesta y comenzar a trabajar con el editor en blanco.

Las clases que añadimos al proyecto se representan mediante un rectángulo marrón: en la imagen anterior aparece rayado porque aún no lo hemos compilado. Para editar el programa debes hacer doble click con el ratón sobre el rectángulo, apareciendo una nueva ventana de edición. En BlueJ, cada clase se edita en una ventana independiente, lo que puede ser realmente engorroso en programas complejos.

Para compilar nuestras clases tenemos dos opciones: el botón de la izquierda compilará todas las clases del proyecto, mientras que si pulsamos sobre el rectángulo de una clase con el botón derecho del ratón, podremos compilar por separado dicha clase. Este mismo menú nos permitiría también eliminar la clase del proyecto.

¿Y la ejecución? Localiza la clase en la que esté el método principal, pulsa sobre su rectángulo con el botón derecho, y selecciona el método main: verás que la ejecución provoca la aparición de una ventana independiente (sí, otra más), en la que aparecerá el resultado de ejecutar tu programa.

Sencillo, ¿verdad? Veamos a continuación opciones algo más avanzadas.

2. Sacándole partido

Retomemos un proyecto completo, que involucre distintas clases:

Observa que los diagramas que ofrece BlueJ no son completos (no muestran los métodos ni los atributos de cada clase): únicamente se contemplan dos tipos de flechas para representar las relaciones entre clase, que caen fuera del alcance de este artículo. Podemos reorganizar los rectángulos en la ventana para que las flechas se vean con claridad. Observa también esa hoja de papel que aparece en la esquina superior izquierda: se trata de un archivo Readme.txt que se incluye por defecto en todos los proyectos. Su misión es únicamente permitir al autor del programa escribir notas sobre el mismo.

Volvamos al proceso de compilación. Cuando sucede un error, BlueJ resaltará la línea errónea y mostrará un mensaje. En ocasiones, un símbolo de interrogación nos permitirá obtener una explicación más detallada del problema (en inglés, eso sí).

Al igual que jGrasp, BlueJ no muestra por defecto los números de línea al editar un archivo. Si deseas que aparezcan, accede al menú Tools > Preferences y marca la opción Display line numbers.

A estas alturas ya te habrás dado cuenta de que la sencillez ha guiado el diseño de este entorno: ahora comprobarás lo intuitivo y fácil que resulta interactuar con los objetos sin necesidad de un método principal. Haz click con el botón derecho sobre una clase y tendrás acceso al método constructor (new...). Además del nombre del objeto, es probable que tengas que introducir algunos valores iniciales:

A continuación puedes ver el aspecto del banco de trabajo en la parte inferior de la pantalla, después de crear algunos objetos:

Sin necesidad de escribir un programa principal, puedes interactuar con estos objetos pulsando sobre ellos con el botón derecho y ejecutando cualquiera de sus métodos:

También puedes examinar sus atributos mediante la opción Inspect:

A través del menú View > Show Code Pad accederás a una nueva ventana en la que puedes ejecutar expresiones sencillas y también referenciar a los objetos creados en el banco. Recuerda que esta funcionalidad también la ha incorporado jGrasp, como se vio anteriormente.

El banco de objetos es una herramienta muy poderosa y cómoda para probar clases, pero no está pensada para desarrollar complejas ejecuciones. Imagina que tu problema requiere crear 10 objetos distintos, dar valores a sus atributos, y luego interactuar entre ellos: cada vez que detectes un fallo y recompiles, los objetos desaparecerán y tendrás que crearlos de nuevo. Por tanto, el banco de objetos en ningún caso sustituye la necesidad de escribir un método principal que guíe la ejecución del programa.

Una puntualización sobre este método principal: el lenguaje pide que main reciba un conjunto de cadenas de texto como parámetros, para permitir la recepción de datos externos al ejecutar el programa. Además, main debe declararse como método estático (enseguida aclararemos qué es eso). La cabecera del método main debería ser siempre, por tanto, public static void main(String[] args). Sin embargo, para aislar al estudiante de ciertas complejidades, BlueJ admite la siguiente cabecera: public void main(). Ten muy presente que un código como este no compilará en otros entornos de programación, por tanto se recomienda respetar la sintaxis original de Java.

Por ser un método estático, para ejecutar el método main basta (como dijimos anteriormente) con pulsar con el botón derecho sobre la clase principal y escoger el método main:

Si main fuese un método convencional, tendríamos que crear primero un objeto miTest de la clase Test, para a continuación invocar el método. Ahí está el problema: en programación orientada a objetos tiene sentido crear objetos que representen cuadrados o personas, pero ¿qué representaría un objeto test, o un objeto matemáticas? ¿Puede haber varias matemáticas? Esta es la razón de ser de métodos estáticos como el main de Test, o las funciones matemáticas de la clase Math.

Sólo nos queda repasar las funciones de depuración, que son muy parecidas a las que ofrece jGrasp. Pulsando en la columna izquierda del editor de una clase, marcamos uno o varios puntos de ruptura:

A continuación ejecutamos el programa y, automáticamente, la ejecución se detendrá al llegar al primer punto de ruptura. En ese momento aparecerá la ventana de depuración y podremos inspeccionar el estado de nuestros objetos:

Observa que los botones de control de ejecución se han reducido al mínimo: avanzar una instrucción (step), ejecutar una llamada a un método paso a paso (step into), continuar hasta el siguiente punto de ruptura, y abortar la ejecución.

Ha quedado clara la obsesión de los creadores de BlueJ por simplificar, y en el caso de la depuración no podemos criticar su elección: están las opciones justas, y resultan muy intuitivas para el usuario.

Hay una última ventaja de este entorno que aún no hemos comentado: y es que si bien el manual de referencia está en inglés, el tutorial oficial está traducido al castellano y es accesible desde la página web del programa. Además, y también en castellano, existe un libro de introducción a la programación en Java utilizando precisamente este entorno, lo que puede sin duda facilitar la tarea al profesor.

3. Valoración

Destaquemos para terminar los puntos fuertes y débiles de este entorno:

Puntos fuertes de BlueJ

• Su sencillez y facilidad de manejo resultan simplemente inigualables
• Sus funciones de creación visual de objetos están integradas de forma fácil e intuitiva para el usuario
• Existe documentación oficial en castellano

Puntos débiles de BlueJ

Entorno de desarrollo NetBeans

Existen varios entornos que han encontrado aceptación por profesionales y aficionados. Los más conocidos son probablemente Eclipse, NetBeans y IntelliJ IDEA. Los dos primeros resultan más interesantes por ser de código abierto, y para este artículo se ha escogido NetBeans por presentar una ventaja adicional: al ser desarrollado por la compañía Sun, la misma que creó Java, puede descargarse e instalarse en un mismo paquete con el kit de desarrollo JDK, lo cuál simplificará su instalación a los alumnos.

1. Puesta a punto

Al igual que con los otros entornos estudiados, la instalación de NetBeans no presenta ninguna complicación, incluso si se escoge descargarlo por separado desde la web del programa. Sin embargo, al abrir NetBeans nos encontramos una pantalla algo más confusa que en los anteriores entornos:

Al igual que en BlueJ, para empezar debemos crear un nuevo proyecto mediante el menú File > New project, indicando en este caso de qué tipo va a ser. Ya desde el principio, advertirás muchas opciones y posibilidades en el entorno, seguramente más de las que en muchos casos nos interesaría:

En una ventana posterior daremos nombre al proyecto y escogeremos una ubicación en el disco para almacenarlo. También nos dará la opción para crear automáticamente una clase principal, la que hasta ahora hemos llamado Test, y que aquí por defecto se llamará Main. Una vez hecho esto, la ventana de trabajo nos resultará sin duda compleja, pero también familiar:

NetBeans nos ofrece un esqueleto de clase Main, que podemos utilizar para hacer nuestra primera prueba. Por defecto, NetBeans compila automáticamente los archivos en el momento en que los grabas (icono del diskette), de forma que únicamente necesitamos utilizar el botón que representa una flecha verde, como el play de un mando a distancia. Verás el resultado de la ejecución en la ventana inferior:

Como ves, no ha sido nada difícil empezar a trabajar con NetBeans; en la siguiente sección esbozaremos las capacidades de esta potente aplicación.

2. Sacándole partido

Examinemos en detalle la carpeta de proyecto. Verás que se han creado múltiples subcarpetas en tu directorio de trabajo:

De ellas sólo nos van a interesar dos: en src se encuentran los archivos fuente de nuestro programa, mientras que en build es donde guarda NetBeans los archivos compilados (.class). Para añadir una nueva clase al proyecto sólo tienes que utilizar el botón New Class; si lo que quieres es agregar al proyecto clases ya existentes, la forma más rápida consiste en copiarlas directamente a la carpeta src.

Si examinamos en detalle la ventana de trabajo, apreciaremos lo siguiente:

• A diferencia de los entornos anteriormente estudiados, en NetBeans puedes ver las clases en la parte izquierda agrupadas por el paquete al que pertenecen
• La clase que contiene el método principal main está destacada con una flecha verde en su icono
• La parte inferior izquierda es como un diagrama de clase: incluye toda la información sobre atributos y métodos de la clase que estemos editando
• NetBeans también puede mostrar números de línea, mediante el menú View > Show line numbers.

Como se ha dicho antes, en NetBeans no existe la necesidad explícita de compilar, puesto que cuenta con una función de autocompilado. Piensa en un editor de textos avanzado: según vas escribiendo, el programa comprueba tu ortografía y, si has cometido una falta, la destaca en rojo sobre la marcha. NetBeans funciona exactamente igual; es más, la forma en que resalta los errores sigue la misma estética que los correctores ortográficos. Si queremos saber el motivo del problema, bastará con situar el cursor sobre una de las marcas de error:

En jGrasp o BlueJ, el primer error de compilación provocará la detención del proceso: aquí puedes seguir trabajando aunque se acumulen varios errores, corrigiéndolos después en el orden que quieras. Fíjate en la parte izquierda de la ventana: NetBeans distinguirá con iconos aquellas clases que presentan errores de compilación. Y puesto que la clase pertenece al paquete figuras, también marca el paquete completo como erróneo. De igual forma, el proyecto trigonometría queda marcado en rojo por la existencia de al menos un error en sus archivos.

Sin duda, y pese a la complejidad, resulta muy cómodo programar en NetBeans. Se trata de un completo entorno que nos permitirá realizar no sólo programas sencillos sino auténticos proyectos profesionales de programación. Como todos los IDEs dirigidos a programadores profesionales, ofrece herramientas avanzadas que nosotros, en un curso de iniciación a Java, raramente vamos a utilizar. Pero para que te hagas una idea de lo que estamos hablando, repasaremos algunas de sus posibilidades:

• Permite la integración de la herramienta Ant de Apache, que permite automatizar mediante guiones o scripts la compilación de proyectos complejos y realizarla después dándole a un solo botón. Las posibilidades de Ant son enormes, permitiendo especificar, por ejemplo, que los archivos fuente se almacenan en unas determinadas carpetas mientras los compilados se deben copiar a otras. También se pueden programar scripts de limpieza que eliminen todos los archivos compilados o no utilizados.

• Soporta control de versiones con la herramienta gratuita CVS. Esta funcionalidad es extremadamente útil al programar en equipo, y básicamente consiste en tener un único almacén de archivos compartido por todos los colaboradores de un proyecto de programación. El sistema registra todos los cambios realizados de forma que cada programador puede ver resaltado en colores qué cambios ha hecho su compañero en cada archivo. Cuando el equipo se da cuenta de que ha cometido un error, puede dar marcha atrás y recuperar rápidamente una versión anterior, deshaciendo los cambios realizados. Más aún: dos programadores pueden modificar un mismo archivo a la vez. Cuando el segundo intente devolver el archivo modificado al almacén, el programa le facilitará la revisión para mezclar sus cambios con los de su compañero, siempre que no resulten incompatibles.

• Ofrece la posibilidad de refactorizar código. Utilizamos esta palabra para designar cambios menores en el código que, sin modificar la funcionalidad de nuestro programa, lo simplifican o facilitan su legibilidad. El ejemplo más básico de refactorización es cambiar el nombre de una variable: el entorno se ocupará de realizar el cambio en todos los puntos del programa en que aparezca, incluso en otros archivos del proyecto. NetBeans también permite ordenar automáticamente el código, introduciendo tabulaciones y espaciados para que el programa se lea con facilidad.

• Incorpora el autocompletado de código. Imagina que estás escribiendo el nombre de una variable o de un objeto, pero no recuerdas qué nombre le diste exactamente: pues bien, simplemente escribe las primeras letras, pulsa la tecla Control y la barra espaciadora, y el programa te indicará cuáles son los nombres disponibles. Algo parecido sucede con los atributos y métodos de una clase. Si escribimos el nombre de un objeto seguido de un punto, sabemos que a continuación debe ir o bien un atributo o bien un método de los que ofrezca la clase a la que pertenece el objeto en cuestión. Si no recordamos su nombre repetiremos la combinación de teclado y el entorno nos ofrecerá las distintas posibilidades:

Las dos primeras funcionalidades están muy orientadas al uso profesional y tendría poco sentido utilizarlas en un curso de iniciación, pero es posible que algún profesor quiera ilustrar las posibilidades de trabajo en equipo incorporando un servidor de control de versiones. El autocompletado, sin embargo, puede ser utilizado en clase con frecuencia; otra cuestión sería el considerarlo o no adecuado para la labor docente. La función de NetBeans es permitir programar deprisa, y funciones como el formateado automático del texto y el autocompletado de código ahorran al programador tiempo y errores. Algunos profesores considerarán que, cuando empezamos, no deberíamos recibir tantas ayudas y sino enfrentarnos precisamente a esos errores. Otros valorarán estas herramientas para que los alumnos se sientan más guiados en su tarea de programar.

NetBeans no permite la creación interactiva de objetos (una iniciativa interesante a nivel didáctico, pero no tanto en un IDE profesional). Pero podemos completar nuestro paseo por el entorno comprobando cómo funciona la depuración. La forma de realizarla es igual que en los otros entornos, aunque NetBeans proporciona posibilidades de inspección y monitorización mucho más avanzadas. Lo que a nosotros nos interesa, sin embargo, se realiza de forma similar: haz click en la columna gris a la izquierda de las líneas donde quieras añadir puntos de ruptura, y pulsa el icono de depurar programa:

En verde se destaca el punto de ruptura en el que estamos detenidos, y en rojo otros puntos de ruptura que hayamos marcado. En la ventana inferior podremos examinar los valores de todos los objetos en este punto, y a través del menú Debug encontraremos las opciones ya conocidas para controlar la ejecución (step, step into...) aparte de otras posibilidades que sobrepasan nuestros intereses.

Los menús y mensajes de NetBeans están escritos, al igual que su documentación, en inglés. Sin embargo, existe un grupo de trabajo dedicado a traducir el IDE al español, de forma que algunas versiones se encuentran traducidas a nuestro idioma. En cuanto a la documentación, iniciativas personales o universitarias de España o Iberoamérica permiten encontrar en la red ciertos recursos para comprender mejor esta popular y potente plataforma.

3. Valoración

Al igual que con el resto de entornos, terminemos con una breve exposición de sus aspectos más destacados:

Puntos fuertes de NetBeans

• Sin duda, el más completo, estable y fiable de los tres
• Si un alumno necesita programar en su vida profesional y ha aprendido con NetBeans, podrá enfrentarse con confianza a cualquier entorno presente en la empresa, ya que todos son muy parecidos entre sí
• La gestión de paquetes y sus avanzadas detecciones de errores (incluso antes de compilar) resultan más cómodas e intuitivas que en los otros entornos

Puntos débiles de NetBeans