Miércoles, 11 Diciembre 2024
MONOGRÁFICO: JAVA - Entorno de desarrollo jGrasp PDF Imprimir Correo
SOFTWARE - Programación
Escrito por Alberto Ruiz   
Viernes, 21 de Agosto de 2009 00:00
Indice del artículo
MONOGRÁFICO: JAVA
Entorno de desarrollo jGrasp
Entorno de desarrollo BlueJ
Entorno de desarrollo NetBeans
Conclusiones
Todas las páginas

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
 

Revista INTEFP

Marcadores Sociales

Facebook MySpace Twitter Delicious Google Bookmarks 

Artículos relacionados