MONOGRÁFICO: JAVA Print
SOFTWARE - Programación
Written by Alberto Ruiz   
Friday, 21 August 2009 00:00
There are no translations available.

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).

 

En muy poco tiempo aprenderás a ponerlos en funcionamiento de forma sencilla, y conocerás sus funcionalidades más interesantes de cara a la enseñanza y el aprendizaje de Java. Al acabar de leer estos artículos estarás en condiciones de comenzar a trabajar y, lo más importante, tendrás las claves para escoger el entorno de desarrollo que más se ajuste a tus necesidades.

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.

Java

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:

  • Los lenguajes compilados traducen el programa fuente a código que puede ejecutar el ordenador, y que por tanto es dependiente de la máquina en la que se va a ejecutar o, como mínimo, de su sistema operativo. Por ejemplo, si compilo mi programa en un equipo con Linux no podré utilizar el archivo ejecutable resultante en Windows.
  • Los lenguajes interpretados, por el contrario, se van traduciendo sobre la marcha, por lo que no se necesita compilador pero sí un intérprete que también será diferente en función de la máquina en la que se instale. La interpretación requiere tiempo: por eso la ejecución de los lenguajes interpretados es más lenta que la de sus homólogos compilados.

¿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:

  • JRE (Java Runtime Environment) es el entorno de ejecución necesario para interpretar y ejecutar archivos .class. Es casi seguro que cualquier ordenador que encuentres en el centro de trabajo tendrá instalada una versión (a veces varias) de este complemento.
  • JDK (Java Development Kit) es el kit de desarrollo, es decir, el compilador para poder crear programas en Java. Esta será, por tanto, la opción que tendremos que escoger en nuestro caso. Ten en cuenta que la instalación del JDK ya incluye el entorno de ejecución, por tanto no tendrás que hacer ninguna instalación adicional.

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:

BlueJ sin JDK

Algo parecido ocurre en jGrasp:

jGrasp sin Java

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:

Eliminar versiones anteriores de 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):

Página de Sun

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.

Página de descarga de Sun

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:

java version

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:
Diagrama de clases

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:

  • Frente a los lenguajes estructurados, el programa más sencillo que utilicemos en Java tendrá seguramente un mínimo de tres o cuatro clases, lo cuál requiere que tengamos abiertas un buen número de ventanas a la vez. El entorno de desarrollo debe estar capacitado para permitir manejar cómodamente múltiples archivos abiertos.
  • Java no es un lenguaje para los impacientes. Para resolver un problema sobre trigonometría debo pasar un tiempo diseñando y programando previamente las clases correspondientes a las figuras; pero hemos dicho que una clase es como un tipo de datos, y por sí misma no hace nada, no puede ejecutarse. Será al final, cuando ya tenga todas las clases listas, cuando escriba un programa principal que creará distintos objetos a imagen y semejanza de sus correspondientes clases, y esos objetos sí que harán cosas. Para evitar el desconcierto o aburrimiento del alumno ante esta situación, algunos entornos ofrecen una posibilidad didácticamente interesante: una vez programada la clase Cuadrado, puedo crear gráficamente un objeto miCuadrado e interactuar con él, probando así sus métodos y observando sus atributos, y todo esto a golpe de ratón, sin necesidad de escribir ningún programa principal.

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:

  • Puesta a punto: se trata de una guía rápida que te permitirá ponerte a trabajar en pocos minutos y compilar tu primer programa de prueba.
  • Sacándole partido: incide en las funcionalidades más interesantes que te ofrece la aplicación.
  • Valoración: repaso esquemático por las ventajas e inconvenientes que presenta el entorno frente a las otras opciones, siempre desde el punto de vista de la docencia.

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.

Logo de jGrasp

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:

Pantalla principal

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

  • A la izquierda encontrarás el explorador de archivos, donde podrás seleccionar la clase que quieres editar. Más adelante verás que en esta sección aparece también la ventana de proyecto, donde podrás ver todas las clases pertenecientes al proyecto en el que estás trabajando. Las pestañas inferiores permiten reutilizar esta ventana para otros usos: la depuración y el banco de objetos, que serán explicados después.
  • Abajo tenemos la ventana de mensajes: jGrasp se comunicará con nosotros a través de este espacio, indicándonos los errores de compilación que vayan surgiendo según trabajamos. Cuando nuestro programa esté listo y queramos ejecutarlo, en esta ventana veremos también el resultado de la ejecución.
  • La parte más amplia es el área de edición, donde modificaremos el código de nuestro programa.

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:

Cambiando el aspecto de la pantalla

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).

Editando una clase

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.

Compilando una clase

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

Ejecutando un 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:

Creando un nuevo proyecto

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.

Vista de 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:

  • Al principio de cada una de las clases del paquete debe añadirse la siguiente línea: package figuras
  • Además, las clases del paquete deben estar almacenadas en un directorio que se llame figuras

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.  

Diagrama UML

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:

Detalle del diagrama UML

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 +.

Creando un CSD

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.

Banco de objetos

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.

Depurando un programa

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

  • Su planteamiento y organización es similar al de IDEs como NetBeans o Eclipse, acostumbrando al alumno a entornos más profesionales
  • Permite una cómoda organización cuando hay muchos archivos abiertos
  • Genera automáticamente diagramas de clases UML, de gran utilidad didáctica

Puntos débiles de jGrasp

  • Su aspecto no es demasiado atractivo
  • La gestión de los paquetes podría ser más clara
  • Carece de documentación en español

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.

Logo de BlueJ

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í:

Pantalla principal

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.

Primera clase

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.

Ejecución de un programa

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

2. Sacándole partido

Retomemos un proyecto completo, que involucre distintas clases:

Un proyecto en BlueJ

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í).

Compilando

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:

Creando un objeto

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

Banco de 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:

Utilizando el banco de objetos

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

Inspeccionando un objeto

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.

Code Pad

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:

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:

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:

Depuración en BlueJ

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

  • Se oculta al alumno la gestión de paquetes
  • Las ventanas independientes resultan algo caóticas cuando se manejan muchos archivos a la vez
  • Los diagramas de clases no aportan ninguna información sobre las mismas, resultando de escasa utilidad

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.

Logo de NetBeans

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:

Primera pantalla

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:

Nuevo proyecto

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:

Pantalla principal

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:

Ejecutando

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:

Carpetas generadas por NetBeans

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.

Trabajando con NetBeans

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:

Errores de compilación

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:
Autocompletado

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:

Depuración

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

  • Su consumo de recursos es significativamente mayor que el de las otras alternativas
  • Enfrentarse a un entorno algo complejo como NetBeans puede desanimar o confundir al alumno, especialmente si no tiene nociones de programación
  • Sus múltiples ayudas al programador pueden no ser adecuadas para iniciarse en el lenguaje Java

Conclusiones

Seguramente a estas alturas ya te hayas hecho una idea de qué entorno te interesa más; pero por si acaso, hagamos un repaso final.

  • BlueJ es un entorno visualmente agradable, sencillo, y con potentes añadidos para facilitar la tarea docente; pero el trabajo intensivo resulta más incómodo y en su búsqueda de simplicidad elude algunos aspectos del lenguaje Java.
  • jGrasp es algo menos atractivo y, si bien ofrece también las algunas facilidades interactivas, no quedan tan bien integradas como en BlueJ. Sin embargo, su organización de archivos es mucho más clara, y su uso prepara mejor al alumno para el uso de entornos profesionales.
  • Uno de esos entornos profesionales es NetBeans: todas las funciones avanzadas están presentes en este potente IDE, con la ventaja adicional que ofrece su sencilla instalación junto con el kit de desarrollo. No obstante, utilizar un entorno tan potente para iniciarse quizá sea excesivo y desde luego no es buena idea si se dispone de equipos con características más bien modestas.

La siguiente tabla recoge esquemáticamente algunas de las diferencias entre los entornos estudiados:



Característica BlueJ jGrasp NetBeans
Versión del entorno en castellano No No Algunas versiones
Existencia de documentación oficial en castellano Tutorial y libro No No
Disponibilidad en Linux
Tipo de licencia GNU (software libre) Propietaria (freeware) CDDL y GPL2 (software libre)
Permite trabajar con otros lenguajes de programación No
Generación automática de documentación (JavaDoc)
Información esquemática sobre las clases Escasa Completa (diagrama UML) Abundante
Gestión de paquetes Confusa Regular Buena
Funciones de depuración Muy básicas Básicas Avanzadas
Funcionalidades avanzadas (refactorización, control de versiones...) No No
Creación y manejo de objetos visualmente sin programa principal Muy fácil Fácil No
Espacio aproximado en disco duro 10 MB 6 MB 160 MB
Consumo aproximado de memoria (10 clases abiertas en el editor) 70 MB 50 MB 140 MB
Fiabilidad para uso intensivo en proyectos semi o profesionales No No
Comodidad para trabajar con múltiples archivos abiertos Baja Alta Alta
Complejidad de uso Muy baja Baja Media

Ten muy presente que la facilidad de uso de un programa no puede expresarse en una tabla. Si tienes dudas, lo mejor es instalarlos y hacer unas cuántas pruebas: al final todo es cuestión de gustos, y deberías escoger aquel entorno con el que sientas más seguridad y confianza. ¿Aún no lo tienes claro? Un último criterio: piensa en el motivo por el que tus alumnos aprenderán Java. Si es una mera iniciación a la programación pero no es probable que vayan a programar habitualmente en un futuro próximo, escoge BlueJ; pero si estás preparando a tus alumnos para ser programadores, utiliza NetBeans. Si te encuentras en una situación intermedia, puedes apostar por JGrasp. Cualquiera que sea el entorno elegido, la enseñanza de Java resultará una experiencia estimulante y creativa: y no sólo para los alumnos, sino también para el profesor.