Ceballos: Java 2 - Lenguaje y aplicaciones

Java 2 ™

Lenguaje y aplicaciones Fco. Javier Ceballos Sierra Profesor titular de la Escuela Politécnica Superior Universidad de Alcalá

http://www.fjceballos.es

Java 2. Lenguaje y aplicaciones. © Fco. Javier Ceballos Sierra © De la edición: RA-MA 2006 MARCAS COMERCIALES: Las marcas de los productos citados en el contenido de este libro (sean o no marcas registradas) pertenecen a sus respectivos propietarios. RA-MA no está asociada a ningún producto o fabricante mencioado en la obra, los datos y los ejemplos utilizados son ficticios salvo que se indique lo contrario. RA-MA es una marca comercial registrada. Se ha puesto el máximo empeño en ofrecer al lector una información completa y precisa. Sin embargo, RA-MA Editorial no asume ninguna responsabilidad derivada de su uso, ni tampoco por cualquier violación de patentes ni otros derechos de terceras partes que pudieran ocurrir. Esta publicación tiene por objeto proporcionar unos conocimientos precisos y acreditados sobre el tema tratado. Su venta no supone para el editor ninguna forma de asistencia legal, administrativa ni de ningún otro tipo. En caso de precisarse asesoría legal u otra forma de ayuda experta, deben buscarse los servicios de un profesional competente. Reservados todos los derechos de publicación en cualquier idioma. Según lo dispuesto en el Código Penal vigente ninguna parte de este libro puede ser reproducida, grabada en sistema de almacenamiento o transmitida en forma alguna ni por cualquier procedimiento, ya sea electrónico, mecánico, reprográfico, magnético o cualquier otro, sin autorización previa y por escrito de RA-MA; su contenido está protegido por la Ley vigente que establece penas de prisión y/o multas a quienes intencionadamente, reprodujeren o plagiaren, en todo o en parte, una obra literaria, artística o científica. Editado por: RA-MA Editorial C/ Jarama, 3A, Polígono industrial Igarsa 28860 PARACUELLOS DEL JARAMA, Madrid Teléfono: 91 658 42 80 Telefax: 91 662 81 39 Correo electrónico: [email protected] Internet: www.ra-ma.es y www.ra-ma.com ISBN: 84-7897-745-7 Depósito Legal: M-46224-2006 Autoedición: Fco. Javier Ceballos Filmación e impresión: Albadalejo, S.L. Impreso en España Primera impresión: Noviembre 2006

CONTENIDO PRÓLOGO............................................................................................................. XV CAPÍTULO 1. FASES EN EL DESARROLLO DE UN PROGRAMA ...........

1

QUÉ ES UN PROGRAMA ................................................................................ QUÉ ES JAVA ................................................................................................... REALIZACIÓN DE UN PROGRAMA EN JAVA ........................................... Cómo crear un programa ............................................................................... Interfaz de línea de órdenes ........................................................................... ¿Qué hace este programa? ........................................................................ Guardar el programa escrito en el disco ................................................... Compilar y ejecutar el programa .............................................................. Biblioteca de clases .................................................................................. Guardar el programa ejecutable en el disco.............................................. Depurar un programa................................................................................ Entorno de desarrollo integrado .................................................................... EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

1 2 2 4 4 5 6 6 8 8 9 9 9 11

CAPÍTULO 2. FUNDAMENTOS DE JAVA ......................................................

13

DECLARACIÓN DE UNA VARIABLE........................................................... ASIGNAR VALORES ....................................................................................... AÑADIR COMENTARIOS............................................................................... MOSTRAR DATOS POR LA PANTALLA...................................................... EXPRESIONES ARITMÉTICAS...................................................................... EXPRESIONES CONDICIONALES ................................................................

13 16 17 18 19 21

VIII

JAVA 2. LENGUAJE Y APLICACIONES

ESCRIBIR NUESTROS PROPIOS MÉTODOS ............................................... EJERCICIOS PROPUESTOS ............................................................................

23 25

CAPÍTULO 3. PROGRAMACIÓN ORIENTADA A OBJETOS.....................

27

PENSAR EN OBJETOS .................................................................................... Clases y objetos ............................................................................................. Mensajes y métodos ...................................................................................... DISEÑO DE UNA CLASE DE OBJETOS........................................................ CONSTRUCTORES .......................................................................................... HERENCIA........................................................................................................ EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

28 28 29 30 37 40 47 52

CAPÍTULO 4. ELEMENTOS DEL LENGUAJE ..............................................

53

CARACTERES DE JAVA................................................................................. TIPOS DE DATOS ............................................................................................ LITERALES....................................................................................................... Literales enteros ............................................................................................ Literales reales............................................................................................... Literales de un solo carácter .......................................................................... Literales de cadenas de caracteres ................................................................. IDENTIFICADORES......................................................................................... PALABRAS CLAVE ......................................................................................... DECLARACIÓN DE CONSTANTES SIMBÓLICAS ..................................... ¿Por qué utilizar constantes? ......................................................................... VARIABLES...................................................................................................... CONVERSIÓN ENTRE TIPOS DE DATOS .................................................... OPERADORES.................................................................................................. Operadores lógicos ........................................................................................ Operadores unitarios...................................................................................... Operadores a nivel de bits ............................................................................. Operadores de asignación.............................................................................. Operador condicional .................................................................................... PRIORIDAD Y ORDEN DE EVALUACIÓN................................................... EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

53 54 55 55 56 57 57 58 58 59 60 60 62 63 63 64 64 65 67 68 69 71

CONTENIDO

IX

CAPÍTULO 5. ESTRUCTURA DE UN PROGRAMA ..........................................

73

ESTRUCTURA DE UN PROGRAMA JAVA .................................................. Paquetes y protección de clases..................................................................... Protección de una clase ................................................................................. Sentencia import............................................................................................ Definiciones y declaraciones ......................................................................... Sentencia simple............................................................................................ Sentencia compuesta o bloque....................................................................... Métodos ......................................................................................................... Definición de un método .......................................................................... Método main.................................................................................................. Crear objetos de una clase ............................................................................. Cómo acceder a los miembros de un objeto .................................................. Protección de los miembros de una clase ...................................................... Miembro de un objeto o de una clase ............................................................ Referencias a objetos ..................................................................................... Pasando argumentos a los métodos ............................................................... EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

73 77 78 78 80 80 81 81 81 82 82 83 84 86 88 92 93 94

CAPÍTULO 6. CLASES DE USO COMÚN........................................................

95

ENTRADA Y SALIDA...................................................................................... Flujos de entrada ........................................................................................... Flujos de salida.............................................................................................. Excepciones................................................................................................... Flujos estándar de E/S ................................................................................... BufferedInputStream ................................................................................ BufferedReader ........................................................................................ PrintStream............................................................................................... Trabajar con tipos de datos primitivos........................................................... Clases que encapsulan los tipos primitivos .............................................. Clase Leer...................................................................................................... ¿DÓNDE SE UBICAN LAS CLASES QUE DAN SOPORTE? ....................... Variable CLASSPATH ................................................................................. CARÁCTER FIN DE FICHERO ....................................................................... CARACTERES \r\n............................................................................................ ALTERNATIVA A LOS FLUJOS DE E/S ....................................................... Entrada de datos ............................................................................................ Salida con formato......................................................................................... MÉTODOS MATEMÁTICOS...........................................................................

95 97 98 98 100 101 101 103 105 106 109 112 112 113 115 116 117 118 119

X


EJERCICIOS RESUELTOS .............................................................................. 120 EJERCICIOS PROPUESTOS ............................................................................ 124 CAPÍTULO 7. SENTENCIAS DE CONTROL .................................................. 127 SENTENCIA if .................................................................................................. ANIDAMIENTO DE SENTENCIAS if............................................................. ESTRUCTURA else if ....................................................................................... SENTENCIA switch........................................................................................... SENTENCIA while ............................................................................................ Bucles anidados ............................................................................................. SENTENCIA do ... while ................................................................................... SENTENCIA for ................................................................................................ SENTENCIA break ............................................................................................ SENTENCIA continue ....................................................................................... SENTENCIAS try ... catch................................................................................. EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

127 130 132 134 138 141 143 146 150 150 151 153 158

CAPÍTULO 8. MATRICES.................................................................................. 161 INTRODUCCIÓN A LAS MATRICES ............................................................ MATRICES NUMÉRICAS UNIDIMENSIONALES ....................................... Declarar una matriz ....................................................................................... Crear una matriz ............................................................................................ Iniciar una matriz........................................................................................... Acceder a los elementos de una matriz.......................................................... Métodos de una matriz .................................................................................. Trabajar con matrices unidimensionales........................................................ CADENAS DE CARACTERES ........................................................................ Clase String ................................................................................................... String(String valor) .................................................................................. String toString()........................................................................................ String concat(String str) ........................................................................... int compareTo(String otroString) ............................................................. int length()................................................................................................ String toLowerCase() ............................................................................... String toUpperCase()................................................................................ String trim().............................................................................................. boolean startsWith(String prefijo) ............................................................ boolean endsWith(String sufijo)...............................................................

162 163 163 164 165 165 166 167 170 172 172 173 173 173 175 175 175 175 175 175

CONTENIDO

String substring(int IndiceInicial, int IndiceFinal) ................................... char charAt(int índice).............................................................................. int indexOf(int car)................................................................................... int indexOf(String str) .............................................................................. String replace(char car, char nuevoCar) ................................................... static String valueOf(tipo dato) ................................................................ char[] toCharArray()................................................................................. byte[] getBytes()....................................................................................... Clase StringBuffer ......................................................................................... StringBuffer([arg]) ................................................................................... int length()................................................................................................ int capacity()............................................................................................. StringBuffer append(tipo x) ..................................................................... StringBuffer insert(int índice, tipo x) ....................................................... StringBuffer delete(int p1, int p2) ............................................................ StringBuffer replace(int p1, int p2, String str).......................................... StringBuffer reverse()............................................................................... String substring(int IndiceInicial, int IndiceFinal) ................................... char charAt(int índice).............................................................................. void setCharAt(int índice, char car) ......................................................... String toString()........................................................................................ Trabajar con cadenas de caracteres................................................................ MATRICES DE REFERENCIAS A OBJETOS ................................................ Matrices numéricas multidimensionales........................................................ Matrices de cadenas de caracteres ................................................................. Matrices de objetos String ............................................................................. EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

XI

176 176 176 176 176 177 177 177 177 177 178 178 178 178 179 179 179 180 180 180 180 180 183 184 188 190 193 198

CAPÍTULO 9. MÉTODOS................................................................................... 201 PASAR UNA MATRIZ COMO ARGUMENTO A UN MÉTODO ................... MÉTODO QUE RETORNA UNA MATRIZ .................................................... REFERENCIA DE UN TIPO PRIMITIVO ........................................................ ARGUMENTOS EN LA LÍNEA DE ÓRDENES ............................................. MÉTODOS RECURSIVOS ............................................................................... MÉTODOS SOBRECARGADOS ..................................................................... NÚMERO VARIABLE DE PARÁMETROS.................................................... VISUALIZAR DATOS CON FORMATO ........................................................ LA CLASE Arrays ............................................................................................. binarySearch.................................................................................................. equals.............................................................................................................

201 203 205 207 210 211 213 215 218 218 218

XII


fill .................................................................................................................. sort................................................................................................................. COLECCIONES................................................................................................. EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

219 219 220 221 225

CAPÍTULO 10. TRABAJAR CON FICHEROS ................................................ 229 VISIÓN GENERAL DE LOS FLUJOS DE E/S ................................................ ABRIENDO FICHEROS PARA ACCESO SECUENCIAL ............................. Flujos de bytes............................................................................................... FileOutputStream ..................................................................................... FileInputStream........................................................................................ Clase File....................................................................................................... Flujos de datos de tipos primitivos ................................................................ DataOutputStream .................................................................................... DataInputStream....................................................................................... Un ejemplo de acceso secuencial .................................................................. Escribir en un fichero ............................................................................... Más sobre excepciones ............................................................................. Leer de un fichero .................................................................................... ABRIENDO FICHEROS PARA ACCESO ALEATORIO ............................... La clase RandomAccessFile .......................................................................... La clase CPersona.......................................................................................... La clase CListaTfnos..................................................................................... Constructor CListaTfnos .......................................................................... Escribir un registro en el fichero .............................................................. Añadir un registro al final del fichero ...................................................... Leer un registro del fichero ...................................................................... Eliminar un registro del fichero................................................................ ¿Hay registros marcados para eliminar?................................................... Buscar un registro en el fichero................................................................ Un ejemplo de acceso aleatorio a un fichero ................................................. Modificar un registro................................................................................ Actualizar el fichero ................................................................................. UTILIZACIÓN DE DISPOSITIVOS ESTÁNDAR .......................................... EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

231 231 232 232 235 237 240 240 241 243 243 246 247 249 250 252 254 254 256 257 258 258 259 259 260 263 265 266 267 273

CONTENIDO

XIII

CAPÍTULO 11. INTERFACES GRÁFICAS ...................................................... 277 FORMULARIOS ............................................................................................... BIBLIOTECA JFC ............................................................................................. DISEÑO DE UNA APLICACIÓN CON INTERFAZ GRÁFICA..................... Contenedores ................................................................................................. Ejecutar la aplicación .................................................................................... Editar el código fuente................................................................................... Añadir los componentes al contenedor.......................................................... Dibujar los componentes .......................................................................... Asignar un administrador de diseño ......................................................... Añadir una etiqueta y editar sus propiedades ........................................... Redimensionamiento automático ............................................................. Añadir un botón y editar sus propiedades ................................................ Asignar manejadores de eventos a un objeto................................................. Eliminar un método añadido por el asistente................................................. Añadir otro código......................................................................................... Compilar la aplicación................................................................................... Depurar la aplicación..................................................................................... Administradores de diseño nulo y absoluto................................................... AÑADIR OTROS CONTROLES ...................................................................... Dibujar los controles...................................................................................... Escribir los controladores de eventos ............................................................ Añadir una barra de menús............................................................................ AÑADIR OTROS FORMULARIOS A LA APLICACIÓN .............................. Mostrar ventanas de diálogo.......................................................................... EJERCICIOS RESUELTOS .............................................................................. EJERCICIOS PROPUESTOS ............................................................................

279 281 282 283 286 286 287 289 290 291 292 292 293 296 296 297 298 300 301 302 304 307 309 310 311 315

CAPÍTULO 12. APLICACIONES WEB............................................................. 317 APLICACIÓN WEB .......................................................................................... Crear una aplicación Web ............................................................................. Editar los ficheros fuente de la aplicación Web ............................................ Editar una página JSP de una aplicación Web............................................... Crear una página JSP para una aplicación Web ............................................ Ejecutar la aplicación Web ............................................................................

317 318 319 320 322 323

XIV


CAPÍTULO 13. ACCESO A UNA BASE DE DATOS....................................... 325 SQL .................................................................................................................... GESTOR DE BASES DE DATOS MySQL ...................................................... Instalación ..................................................................................................... Poner en marcha MySQL en Windows ......................................................... UTILIDADES DE MySQL ................................................................................ CREAR UNA BASE DE DATOS ..................................................................... UTILIZAR EL CONTROLADOR MySQL CON NetBeans ............................. ACCESO A UNA BASE DE DATOS CON JDBC ........................................... EJERCICIOS PROPUESTOS ............................................................................

326 328 329 329 330 331 332 333 341

APÉNDICES A. ENTORNO DE DESARROLLO INTEGRADO PARA JAVA .................... 343 DISEÑO DE UNA APLICACIÓN DE CONSOLA........................................... DEPURAR UNA APLICACIÓN CON NETBEANS........................................ VARIABLE CLASSPATH ................................................................................ OPCIONES DEL ENTORNO DE DESARROLLO .......................................... PROYECTOS..................................................................................................... COMPLETAR EL CÓDIGO MIENTRAS SE ESCRIBE ................................. OBTENER AYUDA ..........................................................................................

343 346 348 349 350 351 352

B. AYUDA .............................................................................................................. 355 OBTENER AYUDA DESDE NETBEANS....................................................... 356 C. PLATAFORMAS UNIX/LINUX..................................................................... 357 INSTALACIÓN DE J2SEDK MÁS NETBEANS............................................. 357 D. CÓDIGOS DE CARACTERES....................................................................... 359 UTILIZACIÓN DE CARACTERES ANSI CON WINDOWS ......................... JUEGO DE CARACTERES ANSI .................................................................... UTILIZACIÓN DE CARACTERES ASCII ...................................................... JUEGO DE CARACTERES ASCII ................................................................... JUEGO DE CARACTERES UNICODE ...........................................................

359 360 361 362 363

PRÓLOGO Java, junto con C#, es actualmente uno de los lenguajes de programación más popular en Internet. Pero, además, está disponible para el desarrollo de programas de uso general. Conocer esta faceta del lenguaje Java, sin olvidar que tiene un alcance completo sobre la Web, es la idea fundamental de esta obra. Cuando Java se introdujo de forma importante, allá por 1995, fue cuando su uso en el diseño de páginas Web revolucionó la naturaleza de éstas. ¿Recuerda? Todo el mundo hablaba de applets, esos pequeños programas que se ejecutan en el contexto de una página Web en cualquier ordenador, introduciendo animación y efectos especiales. Y quizás, esta idea esté enmascarando que “Java” no sólo es eso. Java está también disponible para desarrollar aplicaciones de uso general; esto es, como muchos lenguajes, permite trabajar con todo tipo de datos, crear estructuras dinámicas, trabajar con ficheros, atacar a bases de datos, diseñar interfaces gráficas de usuario, etc. Más aún, Java es un lenguaje simple, potente y orientado a objetos. Su sintaxis incita al programador a generar programas modulares y fácilmente mantenibles. Este libro ha sido escrito con la versión 5.0 del J2SEDK (Java 2 Platform Standard Edition Development Kit), lo que Sun Microsystems, introductora de este lenguaje, denomina Java 2, y su propósito es ayudar al lector a aprender a programar utilizando Java. Para ello, ¿qué debe hacer? Pues simplemente leer ordenadamente los capítulos del libro, resolviendo cada uno de los ejemplos que en ellos se detallan. El autor considera importante no privar al lector de saber que Java aún proporciona mucho más que lo aprendido con este libro. Por eso si quiere profundizar más en este lenguaje le aconsejo mis otros libros titulados Java 2 - Curso de programación y Java2 – Interfaces gráficas y aplicaciones para Internet.

XVI


Agradecimientos He recibido ayuda de algunas personas durante la preparación de este libro, y por ello estoy francamente agradecido. También, expresar mi agradecimiento a Sun Microsystems por poner a mi disposición en particular y de todos los lectores en general, los productos que la creación y el estudio de esta obra requiere. Francisco Javier Ceballos Sierra

http://www.telefonica.net/web2/fjcs/

APÉNDICE A © F.J.Ceballos/RA-MA

ENTORNO DE DESARROLLO INTEGRADO PARA JAVA Evidentemente, para poder escribir programas se necesita un entorno de desarrollo Java. Sun Microsystems, propietario de Java, proporciona uno de forma gratuita, J2SE Development Kit 5.0 (JDK 5.0) para Microsoft Windows, en todas sus versiones, y para Linux. En el capítulo 1 se explicó como obtenerlo en instalarlo. Opcionalmente, puede instalar un entorno de desarrollo integrado (EDI) que le facilite las tareas de creación de la interfaz gráfica de usuario, edición del código, compilación, ejecución y depuración, como por ejemplo: NetBeans de Sun Microsystems. Para instalarlo, ejecute el fichero jdk-1_5_0-nb-5_0-win-ml.exe desde el CD. Este paquete incluye el JDK 5.0, el EDI y, además, el servidor de aplicaciones Tomcat 5. Esto es, instalando este paquete, no necesita instalar previamente J2SE Development Kit 5.0. Asegúrese de que las variables de entorno PATH y CLASSPATH están perfectamente establecidas (en el caso de instalar NetBeans esta operación se realizará automáticamente).

DISEÑO DE UNA APLICACIÓN DE CONSOLA Cuando se utiliza un entorno de desarrollo integrado (EDI), lo primero que hay que hacer una vez instalado es asegurarse de que las rutas donde se localizan las herramientas, las bibliotecas, la documentación y los ficheros fuente hayan sido establecidas; algunos EDI sólo requieren la ruta donde se instaló el compilador. Este proceso normalmente se ejecuta automáticamente durante el proceso de instalación de dicho entorno. Si no es así, el entorno proporcionará algún menú con las órdenes apropiadas para realizar dicho proceso. Por ejemplo, en el EDI Net-

344


Beans que se presenta a continuación, esas rutas a las que nos referimos quedan establecidas durante la instalación del mismo.

Para personalizar el EDI, ejecute la orden Options del menú Tools. Para editar y ejecutar la aplicación HolaMundo realizada en el capítulo 1 utilizando este EDI, los pasos a seguir se indican a continuación: 1. Suponiendo que ya se está visualizando el entorno de desarrollo, ejecute la orden File > New Project (Archivo > Nuevo Proyecto). Se muestra la ventana New Project. 2. Seleccione General en la lista Categories, y en la lista Projects (Proyectos) seleccione Java Application (Aplicación Java). Después haga clic en el botón Next (siguiente). Se muestra la ventana New Java Application. 3. Escriba el nombre del proyecto (Project Name); en nuestro caso será HolaMundo y, a continuación, seleccione la carpeta donde quiere guardarlo. 4. Asegúrese de que las casillas Set as Main Project (declararlo como proyecto principal) y Create Main Class (crear clase principal) están marcadas. 5. Observe la caja de texto correspondiente al nombre de la clase principal; muestra holamundo.Main. Esto significa que la clase principal se llama Main y que pertenece al paquete holamundo. Asumiremos el paquete por omisión,

APÉNDICE A: ENTORNO DE DESARROLLO INTEGRADO PARA JAVA

345

por lo que en esta caja escribiremos solamente el nombre de la clase; en nuestro caso se llamará HolaMundo.

6. Para finalizar haga clic en el botón Finish. El resultado será el siguiente:

El EDI crea la carpeta Ejemplos\HolaMundo en la que guardará el proyecto compuesto en este caso por un solo fichero, HolaMundo.java, que almacena el código correspondiente a la clase HolaMundo.

346


En la ventana mostrada en la figura anterior distinguimos otras tres ventanas, algunas de ellas, con varios paneles. La que está en la parte superior derecha está mostrando el panel de edición para el código fuente de nuestra aplicación y tiene oculto el panel de bienvenida. La que está en la parte superior izquierda muestra el panel de proyectos; éste lista el nombre del proyecto y el nombre de los ficheros que componen el proyecto. Observe el fichero HolaMundo.java; contiene el código de las acciones que tiene que llevar a cabo nuestra aplicación. También distinguimos un elemento Libraries que hace referencia a las bibliotecas que pueden ser necesarias para compilar la aplicación. Finalmente, la ventana que hay debajo de la de proyectos permite navegar por el código del proyecto. Puede visualizar otras ventanas desde el menú Window; por ejemplo, la ventana Output, que será utilizada para mostrar los resultados de la compilación y de la ejecución. Una vez creado el esqueleto de la aplicación, editamos el código de la misma. En nuestro caso, simplemente hay que completar el método main como se indica a continuación: public static void main(String[] args) { System.out.println("Hola mundo!!!"); }

El paso siguiente es construir el fichero ejecutable (fichero HolaMundo.class). Para ello, ejecute la orden Build > Build Main Project, o bien pulse la tecla F11. Si la compilación es correcta, puede pasar a ejecutar la aplicación ejecutando la orden Run > Run Main Project, o bien pulsando la tecla F6; observe el resultado en la ventana Output. Cuando la aplicación necesite de más de un fichero, el proceso es igual de sencillo. Añadir otro fichero a una aplicación, por ejemplo un nuevo fichero que almacene una nueva clase, supone hacer clic con el botón derecho del ratón sobre el nombre del proyecto, elegir la orden New y seleccionar del menú contextual que se visualiza el tipo de elemento que se desea añadir.

DEPURAR UNA APLICACIÓN CON NETBEANS ¿Por qué se depura una aplicación? Porque los resultados que estamos obteniendo con la misma no son correctos y no sabemos por qué. El proceso de depuración consiste en ejecutar la aplicación paso a paso, indistintamente por sentencias o por métodos, con el fin de observar el flujo seguido durante su ejecución, así como los resultados intermedios que se van sucediendo, con la finalidad de detectar las anomalías que producen un resultado final erróneo.


347

Por ejemplo, para depurar una aplicación utilizando el depurador del entorno de desarrollo NetBeans, debe establecer un punto de parada inicial. Para ello, haga clic con el botón derecho del ratón sobre la sentencia a partir de la cual quiere ejecutar el código de su aplicación paso a paso y ejecute la orden Toggle Breakpoint (poner un punto de parada) del menú contextual que se visualiza, o haga clic en la zona sombreada a su izquierda:

Después, ejecute la orden Run > Debug Main Project, o bien pulse la tecla F5 para iniciar la depuración. Continúe la ejecución paso a paso utilizando las órdenes del menú Run o los botones correspondientes de la barra de herramientas Debug (para saber el significado de cada botón, ponga el puntero del ratón sobre cada uno de ellos).

De forma resumida, las órdenes disponibles para depurar una aplicación son las siguientes: •

Debug Main Project o F5. Inicia la ejecución de la aplicación en modo depuración hasta encontrar un punto de parada o hasta el final si no hay puntos de parada.

•

Toggle Breakpoint o Ctrl+F8. Pone o quita un punto de parada en la línea sobre la que está el punto de inserción.

•

Finish Debugger Session o Mayús+F5. Detiene el proceso de depuración.

•

Step Into o F7. Ejecuta la aplicación paso a paso. Si la línea a ejecutar coincide con una llamada a un método definido por el usuario, dicho método también se ejecuta paso a paso.

•

Step Over o F8. Ejecuta la aplicación paso a paso. Si la línea a ejecutar coincide con una llamada a un método definido por el usuario, dicho método no se ejecuta paso a paso, sino de una sola vez.

•

Step Out o Ctrl+F7. Cuando un método definido por el usuario ha sido invocado para ejecutarse paso a paso, utilizando esta orden se puede finalizar su ejecución en un solo paso.

•

Run to Cursor o F4. Ejecuta el código que hay entre la última línea ejecutada y la línea donde se encuentra el punto de inserción.

348


Para ver los valores intermedios que van tomando las variables ponga el cursor sobre ellas, o bien utilice las ventanas Watches, Local Variables, etc., del fondo del EDI. Para añadir o quitar ventanas ejecute la orden Window > Debuggin.

VARIABLE CLASSPATH La opción –classpath del compilador debe incluir las rutas de todas las carpetas donde se deben buscar las clases necesarias para compilar una aplicación. Algunas de estas clases podrían, incluso, encontrarse empaquetadas en un fichero .jar. Cuando necesite especificar estas rutas: 1. Diríjase al panel del proyecto, haga clic con el botón derecho del ratón sobre el nombre del mismo, y seleccione la orden Properties del menú contextual que se visualiza. Se muestra el diálogo siguiente:

2. Seleccione el nodo Libraries. Haga clic en la pestaña Compile y después en el botón Add Project.


349

3. Seleccione la carpeta correspondiente al proyecto, y en el diálogo que se visualiza observe la lista Project JAR Files (ficheros JAR del proyecto); muestra los ficheros JAR que pueden ser añadidos al proyecto. Observe que se muestra también el fichero JAR correspondiente a nuestra aplicación. Este fichero se crea una vez que hayamos compilado y ejecutado el proyecto.

4. Una vez seleccionado el fichero que desea añadir, haga clic en el botón Add Project JAR Files (añadir ficheros JAR al proyecto), y finalmente cierre el diálogo. El fichero JAR seleccionado será añadido.

OPCIONES DEL ENTORNO DE DESARROLLO La orden Options del menú Tools muestra el siguiente diálogo que permite establecer las propiedades del entorno de desarrollo integrado:

350


Si hace clic en el botón Advanced Options (opciones avanzadas) se visualizará esta otra ventana:

PROYECTOS Un proyecto permite agrupar los ficheros requeridos para producir una aplicación o un applet. Esto presenta ventajas como poder compilar todo el proyecto sin tener que especificar los ficheros que incluye, especificar la clase principal del proyecto, ver bajo la pestaña Project del explorador todos los ficheros que componen el proyecto, configurar el entorno de desarrollo integrado (EDI) para cada proyecto, etc. De esto se deduce que para un determinado proyecto podemos configurar un escenario particular que será guardado cuando se finalice la sesión, lo que permitirá recuperarlo automáticamente la próxima vez que se cargue ese proyecto.


351

Puede tener cargados varios proyectos simultáneamente y activar en cada instante aquél sobre el que desea trabajar. Para ello, tiene que hacer clic sobre el nombre del proyecto que desea sea el actual y ejecutar la orden Set Main Project del menú contextual que se visualiza.

COMPLETAR EL CÓDIGO MIENTRAS SE ESCRIBE NetBeans proporciona la característica de completar el código mientras lo escribe:

Por ejemplo, según puede verse en la figura anterior, cuando haya escrito CAplicacion(). aparecerá una lista de los posibles métodos que pueden ser invocados; seleccione el adecuado y pulse la tecla Entrar. Este tipo de ayuda sólo estará disponible si el valor de la casilla de verificación Auto Popup Completion Window tiene el valor true. Para verlo, ejecute la orden Options del menú Tools y haga clic en el botón Editor > General.

352


OBTENER AYUDA La orden Javadoc Index Search del menú Tools (Mayúsculas+F1) permite obtener ayuda acerca de múltiples temas. Pero si quiere obtener ayuda acerca de la biblioteca de clases de Java (suponiendo que la ha instalado), es preciso que dicho entorno tenga conocimiento de la ruta de acceso a la misma. Para ello, ejecute la orden Java Platform Manager del menú Tools y asegúrese de que en la lista de rutas mostrada en Javadoc hay una que hace referencia a la carpeta donde se encuentra la ayuda mencionada; si no es así, añádala.

Después del proceso anterior, cuando pulse las teclas Mayúsculas+F1, se visualizará el panel que se muestra en la figura siguiente, donde podrá solicitar ayuda acerca de la clase que quiera. También puede dirigirse al editor de código, colocar el cursor sobre el nombre de la clase, método, etc. de la cual quiere ayuda y pulsar las teclas Mayúsculas+F1.


353

Asimismo, puede obtener ayuda acerca del desarrollo de aplicaciones y del EDI pulsando la tecla F1, o bien ejecutando la orden Help Contents del menú Help.

APÉNDICE B © F.J.Ceballos/RA-MA

AYUDA En este libro se ha trabajado con los paquetes más comunes en Java y dentro de cada paquete con las clases de uso más frecuente. Evidentemente, a medida que vaya estudiando cada capítulo le van a surgir dudas y curiosidades de por qué esta clase y no otra, o qué otros métodos tiene esta clase y, lógicamente, a muchas de estas cuestiones no va a tener respuesta en el libro. Será consciente de que para abarcar todo lo que se implementa en la biblioteca de Java harían falta varios libros. Por eso este apéndice. Debe acostumbrarse a manejar la ayuda que proporciona Java para tratar de dar solución a las dudas que se le puedan ir planteando. El aspecto de una ventana de ayuda de Java es el siguiente:

356


Los documentos html correspondientes a la API de Java que componen la ayuda de la que estamos hablando, van incluidos en el CD-ROM. Cuando haya instalado esta documentación, si siguió los consejos dados en el capítulo 1, tendrá almacenada la ayuda a la que nos referimos en la carpeta Java\docs: index.html

La forma más directa de visualizar la ventana de ayuda a partir de la cual podremos navegar por la documentación de la API de Java es haciendo doble clic en el fichero index.html localizado en la carpeta api de docs. Si observa esa ventana, verá que se trata del explorador, puesto que estamos tratando con documentos html, y que su área de trabajo se divide en tres partes: •

En la esquina superior izquierda de esta área se muestra la lista de los paquetes que componen la biblioteca de Java. Seleccione el paquete que le interese. Por ejemplo, java.util si quiere consultar algo acerca de la entrada/salida por consola.

•

Cuando haya seleccionado un paquete, las clases que lo componen aparecen en el área que está justamente debajo. Seleccione la clase que le interese. Por ejemplo, Scanner si quiere consultar los atributos y métodos de entrada/salida que proporciona esta clase.

•

En el resto del área de trabajo de la ventana, la parte más grande, mostrará de forma resumida todo lo relativo a la clase que ha seleccionado.

OBTENER AYUDA DESDE NETBEANS Véase el apéndice A.

APÉNDICE C © F.J.Ceballos/RA-MA

PLATAFORMAS UNIX/LINUX Aunque este libro se ha escrito sobre una plataforma Windows, todos los ejercicios han sido probados también en una plataforma Linux; concretamente en un ordenador personal con el sistema operativo Linux. Quiere esto decir, que si su caso es este último, recurra al CD-ROM del libro o a la dirección de Internet de Sun Microsystems, http://www.sun.com, para obtener el JDK que debe instalar. A continuación provéase del editor o del entorno de trabajo de su gusto (en el CD encontrará NetBeans+J2SEDK) y siga el libro normalmente.

INSTALACIÓN DE J2SEDK MÁS NETBEANS Para instalar el entorno de desarrollo integrado NetBeans más el J2SEDK 5.0 desde el fichero jdk-1_5_0_09-nb-5_0-linux-ml.bin proporcionado en el CD-ROM del libro, realice los siguientes pasos: 1. 2. 3. 4. 5. 6.

Cambie a root (administrador): $ su Sitúese en el directorio donde copió el fichero .bin. Ejecute la orden: # ./ jdk-1_5_0_09-nb-5_0-linux-ml.bin La orden anterior inicia el asistente de instalación. Siga los pasos indicados por el asistente de instalación. Salga de la sesión de root: # exit

La figura siguiente muestra un ejemplo de instalación, la realizada para probar los ejemplos de este libro:

358


… Si a continuación desea instalar la documentación, descomprima (unzip) el fichero jdk-1_5_0-doc.zip e instálelo en opt\docs o en la carpeta que usted desee. Para arrancar NetBeans ejecute la orden que se ha añadido al menú. Para compilar y ejecutar un programa desde la línea de órdenes debe definir las variables de entorno JDK_HOME y PATH: $ export JDK_HOME=/usr/java/jdk1.5.0_09 $ export PATH=$PATH:$JDK_HOME/bin

En el capítulo 6 escribirá la clase Leer que después, si lo desea, podrá utilizar en el resto de los capítulos. Para ello, lo más práctico es crear una carpeta jdk1.5.0_09\misClases y copiar el fichero Leer.class en ella y asegurarse antes de realizar cualquier operación de compilación que la variable CLASSPATH tiene asignada la ruta de esta carpeta.

Ceballos: Java 2 - Lenguaje y aplicaciones

Recommend Documents