Laboratorio presentación herramienta:

Oracle JDeveloper 9

Descripción

En este laboratorio se va a presentar una herramienta de desarrollo de software. En concreto, se trata de Oracle JDeveloper 9.i que es uno de los entornos visuales existentes en el mercado que permiten desarrollar aplicaciones en Java.  Este tipo de herramientas permite generar código de manera automática, con el consiguiente ahorro de tiempo y esfuerzo.

Objetivos

Los objetivos de este laboratorio son:

• Tener una primera toma de contacto con un entorno de desarrollo visual Java que se va a utilizar durante los laboratorios de la asignatura.

•  Mostrar las ventajas del uso de estas herramientas: generación automática de código y facilidades de compilación, ejecución, depuración de programas.

•  Señalará las facilidades para consulta, en forma on- line, la documentación sobre Java.

•  Mostrar las posibilidades de generación automática de documentación para nuestra aplicación, extraída de los comentarios escritos en los programas fuente.

•  Obtener un programa “ejecutable” para poder lanzar la aplicación desde fuera de la herramienta de desarrollo.

 Para ello realizaremos una implementación de un ejercicio clásico como es el de calcular el número Fibonacci de un número. A continuación se creará una interfaz de usuario gráfica sencilla desde donde se llamará al módulo anterior. Es en esta segunda parte del laboratorio donde se verán más claramente las ventajas de la herramienta visual al comprobar que genera código de manera automática. Por último, veremos cómo crear documentación usando Javadoc y cómo crear un fichero .jar.

 

Procedimiento a Seguir

 1. Crear una carpeta de trabajo. Debemos crear una carpeta en nuestro equipo (por ejemplo de nombre lab1) para guardar en ella todo lo que generemos durante el laboratorio. En ella a su vez haremos cuatro subcarpetas: misclases, misfuentes, misproyectos y misdocs. No es obligatorio que tengan esos nombres, pero sí conviene que estén en distintos directorios para tenerlo más organizado.

 

2. Abrir el Entorno de Desarrollo Integrado del JDeveloper. 

 

2.1. Crear un nuevo espacio de trabajo (workspace). El concepto de espacio de trabajo es similar al de “escritorio” donde tenemos a la vista uno o varios proyectos en los que se está trabajando en un momento dado, y que pueden formar parte de la aplicación que se está desarrollando.

a) Dado que se desea crear una nueva aplicación vamos a cerrar todo lo que se encuentre abierto en la herramienta (los posibles proyectos y clases Java actualmente abiertas y que forman el espacio de trabajo actual). Para cerrar un proyecto, espacio de trabajo o clase Java hay que posicionarse sobre el mismo en la ventana System-Navigator y cerrarlo con la opción File => Close (o bien, pulsando al icono con una X en rojo).

b) Para crear un nuevo espacio de trabajo ejecutaremos desde el Menú de Comandos: File/ New. En la ventana que aparece, elegiremos la categoría Projects y el Item Workspace. Pinchamos en OK y se abre una nueva ventana. Pinchamos en Browse y seleccionamos la carpeta que hemos creado en el paso 1 (lab1). El espacio de trabajo se puede guardar en un fichero con extensión .jws (por ejemplo lab1.jws). Para terminar, nos aseguramos que ninguna de las opciones de abajo está seleccionada (para no introducir ahora un proyecto en el espacio de trabajo) y pinchamos en OK.

 

2.2. Crear un nuevo proyecto vacío utilizando el asistente. Se puede crear un nuevo proyecto con File/New y seleccionando dentro de la categoría Projects: “Project Containing a New Application”. Hay que dar un nuevo nombre al proyecto, por ejemplo lab1.jpr, pero aseguraros de que se va a guardar dentro de la subcarpeta creada anteriormente misproyectos. Los proyectos se guardan en ficheros con extensión .jpr. A continuación (pinchar en next) hay que indicar tres datos:

 

a) El primero es el paquete (package) por defecto del proyecto (todas las clases Javas creadas en el proyecto serán incluidas automáticamente en dicho paquete). Escoged por ejemplo el siguiente nombre: laboratorio1.

 

b) El segundo es el directorio donde se van a guardar todos los programas fuentes Java (ficheros .java) que se creen en el proyecto. Escoged en este caso el subdirectorio misfuentes. Nota: en realidad los fuentes Java se guardarán en el subdirectorio misfuentes\laboratorio1. Para ello pinchad en Add entry, y seleccionar el directorio en cuestión. Para terminar, eliminad el directorio que ponía JDeveloper por defecto, de tal manera que sólo quede el directorio que queremos.

 

c) El tercero es el directorio donde se van a guardar todas las clases compiladas Java (ficheros .class). Escoged en este caso el subdirectorio misclases. Nota: en realidad las clases Java se guardarán en el subdirectorio misclases\laboratorio1.

 

A continuación pinchad en Finish para crear nuestro nuevo proyecto. Veremos que aparece una nueva ventana en la que podemos definir los datos de nuestra nueva aplicación. Pero, en nuestro caso, pincharemos en Cancel, ya que vamos a crear las clases manualmente. 

 

2.3. Crear una nueva clase Java que calcule el fibonacci de un número. Para ello se hace File/New y se escoge dentro de la categoría General => Simple Files el item correspondiente a Java Class . Hay que indicar el nombre de la clase, por ejemplo Fibonacci. Si activamos los atributos opcionales “public”, “generate default constructor” y “generate main function”. Si ahora hacemos doble click dentro del Panel de Navegación del Workspace, sobre el icono de Fibonacci.java, veremos que JDeveloper ha generado algo de código de manera automática y tal vez algunos comentarios con el estilo Javadoc.

 

2.4. Introducir el código. En la ventana de Fibonacci.java añadiremos el método  calcFibonacci y rellenaremos el método principal main:

 

 

 

2.5. Compilar la aplicación. Para ello utilizar el comando Project => Make o Project => Rebuild seleccionando el workspace o el proyecto. Existen dos iconos que permiten hacer lo mismo. Con el comando “Make” se compila solamente aquellas clases fuente que han cambiado, y con el comando “Rebuild” se compilan todas, hayan cambiado o no, por lo que en general será más rápido compilar con “Make”. Comprobad que se  ha creado la clase Fibonacci.class en el directorio misclases\laboratorio, y que se ha guardado el fichero fuente en el fichero Fibonacci.java en el directorio misfuentes\laboratorio. Esto ficheros son guardados dentro de la carpeta laboratorio1 porque la primera instrucción de la clase Fibonacci es:  package laboratorio1;

 

2.6. Ejecutar la aplicación. Para ello utilizar el comando Run: la opción Run => Run lab1.jpr, o bien el icono con forma de semáforo, estando posicionados en el proyecto lab1.jpr en la ventana System - Navigator. En el Área de Mensajes de Texto nos muestra cómo lo ejecuta.  Si no vemos que se nos muestre el resultado de la ejecución, abrir la ventana de mensajes (View/Log Window). Nota: si no hubiéramos compilado previamente la aplicación, entonces, lo haría antes de ejecutar, por lo que podríamos habernos ahorrado el paso previo. Si nos fijamos tenemos la línea de comandos que nos ejecuta la aplicación y a continuación en la línea siguiente nos escribe el resultado de la operación. Probar la aplicación y ver si hay algún problema.

 

2.7. Intentar calcular el Fibonacci de 46, 47, 48. ¿Qué sucede? Para ejecutar con distintos valores se puede hacer de varias formas:

 

a) Modificando la instrucción int numero = XXX; del método main de Fibonacci

 

b) Pasando como parámetro al programa el valor que sea, para lo que hay que sustituir la instrucción  int numero = 4; del método main de Fibonacci por esta:

        int numero = Integer.parseInt (args[0]);

 

El parámetro que se le pasa al programa se escribe así: seleccionar Project / Project Settings... escoger la solapa “Configurations/Developer/Runner” y poner el parámetro en la caja de texto “Program Arguments".

 

c) También se puede leer de la entrada estándar el número

 

Para ello, hay que usar algunas clases del paquete java.io

    import java.io.*

 

Abrir la entrada estándar para leer de ella:

        BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));

 

Leer de la entrada estándar en una variable String:

    String num = entrada.readLine();

 

Y transformar el string en un número entero:

    int numero = Integer.parseInt(num);

 

En estos últimos dos casos hay que tener cuidado y definir qué hacer cuando se produzcan excepciones (no se puede leer, la entrada no es un número, etc.)

 

Aquí se presenta el código anterior tal y como debe aparecer (excepto el método calcFibonacci)

package laboratorio1;
import java.io.*;

public class Fibonacci {
public Fibonacci() {
}

public static void main (String args[]) {
    BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
    try {
        String num = entrada.readLine();
        int numero = Integer.parseInt(num);
        System.out.println (calcFibonacci(numero));
    }    catch (Exception e) {
            System.out.println(e.toString());
    }
} //fin main y continuar con public static int calcFibonacci...

 

Para leer la entrada estándar, en tiempo de ejecución,  hay que configurar el  JDeveloper:

        Project => Project Settings => Runner => Options y hacer click en "Allow Program Input"

 

En tiempo de ejecución, la entrada se realizará en una caja de texto etiquetada con Input (en la parte inferior de la pantalla):

 

3. Ejecutar la aplicación fuera de JDeveloper, invocando directamente a la máquina virtual Java. Para ello hay que:

 

1) Lanzar un intérprete de comandos (Menú Inicio del Sistema Operativo => Ejecutar => cmd)

 

2) Asegurarse de que la herramienta JAVA se puede ejecutar en dicho intérprete de comandos. Escribir el comando java y ver si lo encuentra o no. Si no lo encuentra hay que modificar la variable de entorno PATH del sistema. El PATH se puede cambiar en el PANEL DE CONTROL => Sistema => Seleccionar solapa “Opciones Avanzadas” => Variables de Entorno. Ahí hay que añadir o editar la variable de entorno de usuario PATH para que contenga el directorio donde se encuentra java.exe. Una manera de encontrar la utilidad JAVA es seleccionar el enlace directo a JDeveloper (jdev.exe), hacer click con el botón derecho => Propiedades => “Buscar Destino”. Ese directorio será DIR_JDEVELOPER\jdev\bin.  Pues bien, la herramienta jar se encuentra en el directorio: DIR_JDEVELOPER\jdk\bin. Una vez modificado el PATH, volver a lanzar un intérprete de comandos y comprobar que se ejecuta JAVA.

 

3) Posicionarse en el directorio del CLASSPATH (en nuestro caso en misclases) (con el comando cd del sistema operativo) donde se encuentran todos los ficheros .class, y ejecutar la clase laboratorio1.Fibonacci. java laboratorio1.Fibonacci  (para el ejemplo 2.4.a)  

 

NOTA: Si ejecutamos la versión de Fibonacci que recibe la entrada como parámetro lo haremos de esta forma: java laboratorio1.Fibonacci 5 (por ejemplo) para el ejemplo 2.4.b y java laboratorio1.Fibonacci + enter + 5 (por ejemplo) para el ejemplo 2.4.c

 

NOTA: Si nos aparece una excepción del tipo "java.lang.NoClassDefFoundError" ejecutar la clase así: java -cp . laboratorio1.Fibonacci

 

4. Crear una interfaz de usuario gráfica. Para ello escoger File/ New y dentro de la categoría Client Tier => Swing/AWT seleccionar un Frame. Darle un nombre (por ejemplo FibFrame) y añadir las opciones que se deseen (título, añadir menú, about box, etc.). Se pueden escoger frames estándar de las librerías de Java como AWT o SWING, y otros menos estándar, propios de JDeveloper, pinchar en OK. Se puede comprobar que se ha generado una clase fuente Java con el mismo nombre dado al frame y extensión .java (FibFrame.java). Es posible que se haya generado otra clase dependiendo de si se ha escogido la opción “ About Box”. En ambos casos se ha generado código Java de manera automática. Se puede continuar generando código de manera visual si seleccionamos el frame (haciendo doble click sobre él en el navegador de objetos), pinchamos con el botón derecho y seleccionamos UI Editor , como se va a ver en el siguiente punto.

 

4.1. Diseñar la interfaz del frame. Vamos a diseñar una interfaz gráfica sencilla que nos permita ejecutar la clase Fibonacci anterior. Para ello insertaremos una serie de etiquetas, que nos indicarán los datos que introduciremos en los cuadros de texto que pondremos a su derecha. Por último un botón que al apretarlo con el ratón nos ponga en el segundo campo de texto el número de la serie de Fibonacci correspondiente al número que introduciremos en el primero. Para todo ello elegimos en la Paleta de Componentes la solapa AWT (en el caso en que hayamos escogido un java.awt.Frame), y le indicamos que la propiedad Layout va a ser null (selecionando el modo UI Editor) , para indicar que no queremos un administrador de diseño y así poder colocar los componentes gráficos en donde deseemos dentro del Frame[1]. Para insertar componentes AWT en el frame seleccionar el componente deseado de la Paleta de Componentes y luego dentro del frame hacer click con el botón izquierdo del ratón, modificándolos hasta conseguir el tamaño deseado. Añadimos las etiquetas y los cuadros de texto, cambiando las propiedades necesarias para que contengan en el caso de las etiquetas ( Label) el texto que deseemos presentar, y en el caso de los campos de texto (TextField) para que no aparezca nada en ellos, en ambos se hace en la propiedad text. Añadimos un botón (Button ) de la misma manera y cambiamos el texto de manera que nos indique lo que debemos de hacer. El aspecto que podría tener el frame en estos momentos podría ser el siguiente:

 

 

4.2. Programar la respuesta a eventos.   Hay que añadir el código que debe ejecutarse cuando se pulse el botón. Para ello hay que seleccionar primero el botón en la ventana de diseño del frame, y después, en el inspector, hay que pulsar la solapa de eventos (events) y escoger el evento apropiado (mouseClicked). A continuación se puede escribir un nombre para el método que tratará dicho evento, aunque también podemos dejar el que nos crea por defecto. Tras pulsar un return, JDeveloper situará el cursor en la ventana de edición del código fuente correspondiente al frame, justo en el método de respuesta al evento de que se trate. En este punto se debe introducir el código necesario, que puede ser el siguiente:

    int numero = Integer.parseInt(textField1.getText());                

    textField2.setText(Integer.toString(Fibonacci.calcFibonacci(numero)));

4.3. Salvar los ficheros.  Como siempre, es conveniente de vez en cuando salvar los ficheros fuente Java, proyectos, workspaces, para no llevarnos disgustos. En especial es cierto en el caso de trabajar con JDeveloper ya que de vez en cuando se queda colgado… Para ello hay que hacer File / Save All o bien hacer click en el icono correspondiente.

4.5. Añadir una clase principal que contenga la aplicación y que tenga asociada la interfaz gráfica anterior. Para ello hay que hacer File/New y dentro de Client Tier => Swing/AWT escoger Application, darle un nombre (por ejemplo Principal), e indicar que se le desea añadir un frame por defecto. Seleccionar la opción “Existing frame ” y, tras pulsar el botón “Browse” localizar el frame con la interfaz gráfica. Conviene dejar activa la caja de comprobación “Center frame on screen” para que el frame aparezca justo en el centro del monitor cuando se ejecute la aplicación.

4.6. Ejecutar la aplicación. Como hay más de una clase que tiene un método main, hay que seleccionar previamente en el navegador de objetos la clase con la aplicación (Principal), antes de hacer Run.

4.7. Probar la aplicación y ver si hay algún problema. Puede suceder que no siempre se ejecute calcule el fibonacci tras hacer click en el botón (PROBAD A ARRASTRAR EL RATÓN SOBRE EL BOTÓN, ESTO ES, HACER “DRAG” EN VEZ DE “CLICK”). El problema es que EL EVENTO APROPIADO NO ES mouseClicked SINO actionPerformed, que responde a cualquier evento sobre el botón: hacer click en el mismo, arrastrar el ratón dentro del botón (hacer drag), etc. Definir el comportamiento anterior para el evento actionPerformed.

¿Qué sucede si se mete un carácter no numérico en el textField1? Comprobad que se lanza una excepción. Para arreglar el problema hay que cambiar el código, y poner las instrucciones que pueden levantar excepciones dentro de un try{...}, y las instrucciones de atención a la excepción dentro de un bloque catch. En este caso, habría que añadir código con este esquema: try{...} catch(NumberFormatException ex){..}

5.  Consultar la documentación de las API de Java. Comprobar que efectivamente el método parseInt de la clase Integer puede lanzar una excepción NumberFormatException. Para consultar la documentación de las API de Java, se puede usar una opción del JDeveloper (si es que está instalada):  Help / Java Reference y consultar el “Java Platform XX API Specification”. O si no, consultarla directamente en Internet, que a veces es hasta más rápido. Para ello buscar en Google directamente (poniendo "API" y el nombre de la clase, por ejemplo "API Integer").  En el paquete java.lang, encontraremos la clase Integer y dentro de la misma podremos ver que existe un método parseInt que puede lanzar una excepción NumberFormatException. La documentación completa de Java puede ser accedida también a través de Google (buscando “API JDK1.3”) o accediendo a http://java.sun.com/j2se/1.3/docs/api/.

6.   Generar documentación de manera automática. Para ello hay que seleccionar el proyecto, hacer clic con el botón derecho y seleccionar “Generate Javadoc”. La documentación se guardará en el directorio que aparezca en las propiedades del proyecto: Project => Project Settings => Javadoc => Destination Path. Aseguraros de que es vuestro directorio misdocs. Cuando termine, podremos comprobar que en el subdirectorio misdocs aparecen varios ficheros .html con la documentación de las clases que hemos creado. Puede verse que se encuentra en el mismo formato que la documentación previamente consultada de las librerías de Java, esto es, el formato de la documentación de Java JDK. Aunque mucha de esta documentación se ha generado de manera automática, es conveniente añadir comentarios Javadoc a las clases fuente de Java para que sean incluidos en la documentación. Por ejemplo, comprobar lo que sucede si se añade el siguiente comentario Javadoc inmediatamente antes del método   public static int calcFibonacci(int n) en la clase Fibonacci:

    /*** Método para calcular el número fibonacci de un número (menor que 47)

    * @param n Número del que quiere calcularse el fibonacci

    * @return Fibonacci de n*/

y se genera de nuevo la documentación con Javadoc. Ver cómo quedaría la documentación. En estas transparencias se muestra un ejemplo de un programa comentado con Javadoc y el resultado de visualizar la documentación en un navegador. Se incluye además un pequeño resumen de algunas palabras reservadas de Javadoc.

7. Generar un fichero .jar ejecutable (en realidad ejecutable por la máquina virtual Java). Para ello hay que:

1) Lanzar un intérprete de comandos (Menú Inicio del Sistema Operativo => Ejecutar => cmd)

2) Asegurarse de que la herramienta JAR se puede ejecutar en dicho intérprete de comandos. Escribir el comando jar y ver si lo encuentra o no. Si no lo encuentra hay que modificar la variable de entorno PATH del sistema. El PATH se puede cambiar en el PANEL DE CONTROL => Sistema => Seleccionar solapa “Opciones Avanzadas” => Variables de Entorno. Ahí hay que añadir o editar la variable de entorno de usuario PATH para que contenga el directorio donde se encuentra jar.exe. Una manera de encontrar la utilidad JAR es seleccionar el enlace directo a JDeveloper (jdev.exe), hacer click con el botón derecho => Propiedades => “Buscar Destino”. Ese directorio será DIR_JDEVELOPER\jdev\bin.  Pues bien, la herramienta jar se encuentra en el directorio: DIR_JDEVELOPER\jdk\bin. Una vez modificado el PATH, volver a lanzar un intérprete de comandos y comprobar que se ejecuta JAR.

3) Posicionarse en el directorio del CLASSPATH (en nuestro caso en misclases) (con el comando cd del sistema operativo) donde se encuentran todos los ficheros .class, crear con un editor de textos un fichero que diga cuál es la clase principal de la aplicación (por ejemplo con el comando edit). Crearemos un fichero (por ejemplo miManifiesto.mf) cuyo contenido sea: Main-Class: laboratorio1.Principal

NOTA: terminad la línea anterior con el carácter RETURN y GUARDAD UN ESPACIO EN BLANCO después de Main-Class: 

Y desde el directorio (misclases), crear el fichero ejecutable (por ejemplo lab1.jar) con el siguiente comando: jar cvfm lab1.jar miManifiesto.mf laboratorio1\*

El comando anterior crea el fichero lab1.jar que incluye de manera comprimida todos los ficheros .class que se encuentran en el paquete laboratorio1, y que contiene así mismo información de cuál será la clase principal se va a ejecutar.

Dicho fichero ejecutable se podrá ejecutar "directamente" con el siguiente comando: java -jar  lab1.jar

También se podrá ejecutar haciendo doble click en dicho fichero, sin necesidad de usar un intérprete de comandos. NOTA: para ello debe estar definido en el sistema operativo que los ficheros de extensión .jar se abren con el programa java.exe y opción –jar. Lamentablemente en el laboratorio esto no es así, sino que están asociados al programa winrar, y no podemos cambiarlo por no tener privilegios de administrador.

8. Reutilización de las clases creadas en este proyecto en otros proyectos.   Después de salvar todo el proyecto, vamos a crear un nuevo proyecto como se ha hecho anteriormente, pero indicando para el mismo otro paquete Java diferente, por ejemplo Laboratorio1Nuevo .. Para que la clase Fibonacci del paquete Laboratorio1 sea accesible a las clases del nuevo proyecto hay que modificar el CLASSPATH de este segundo proyecto. En JDeveloper se hace así: Project / Project Settings. Escoger la solapa “Libraries” y pulsar New e indicar los directorios raíz de las clases compiladas, de los programas fuente y de la documentación. No hay que olvidar que, dentro de las clases que quieran usar la clase Fibonacci hay que añadir la sentencia import correspondiente:   import Laboratorio1.Fibonacci;