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

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

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

DECLARACIÓN DE UNA VARIABLE........................................................... 13

ASIGNAR VALORES ....................................................................................... 16
AÑADIR COMENTARIOS............................................................................... 17
MOSTRAR DATOS POR LA PANTALLA...................................................... 18
EXPRESIONES ARITMÉTICAS...................................................................... 19
EXPRESIONES CONDICIONALES ................................................................ 21
VIII JAVA 2. LENGUAJE Y APLICACIONES

ESCRIBIR NUESTROS PROPIOS MÉTODOS ............................................... 23

EJERCICIOS PROPUESTOS ............................................................................ 25

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

PENSAR EN OBJETOS .................................................................................... 28

Clases y objetos ............................................................................................. 28
Mensajes y métodos ...................................................................................... 29
DISEÑO DE UNA CLASE DE OBJETOS........................................................ 30
CONSTRUCTORES .......................................................................................... 37
HERENCIA........................................................................................................ 40
EJERCICIOS RESUELTOS .............................................................................. 47
EJERCICIOS PROPUESTOS ............................................................................ 52

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

CARACTERES DE JAVA................................................................................. 53
TIPOS DE DATOS ............................................................................................ 54
LITERALES....................................................................................................... 55
Literales enteros ............................................................................................ 55
Literales reales............................................................................................... 56
Literales de un solo carácter .......................................................................... 57
Literales de cadenas de caracteres ................................................................. 57
IDENTIFICADORES......................................................................................... 58
PALABRAS CLAVE ......................................................................................... 58
DECLARACIÓN DE CONSTANTES SIMBÓLICAS ..................................... 59
¿Por qué utilizar constantes? ......................................................................... 60
VARIABLES...................................................................................................... 60
CONVERSIÓN ENTRE TIPOS DE DATOS .................................................... 62
OPERADORES.................................................................................................. 63
Operadores lógicos ........................................................................................ 63
Operadores unitarios...................................................................................... 64
Operadores a nivel de bits ............................................................................. 64
Operadores de asignación.............................................................................. 65
Operador condicional .................................................................................... 67
PRIORIDAD Y ORDEN DE EVALUACIÓN................................................... 68
EJERCICIOS RESUELTOS .............................................................................. 69
EJERCICIOS PROPUESTOS ............................................................................ 71
 CONTENIDO IX

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

ESTRUCTURA DE UN PROGRAMA JAVA .................................................. 73

Paquetes y protección de clases..................................................................... 77
Protección de una clase ................................................................................. 78
Sentencia import............................................................................................ 78
Definiciones y declaraciones ......................................................................... 80
Sentencia simple............................................................................................ 80
Sentencia compuesta o bloque....................................................................... 81
Métodos ......................................................................................................... 81
Definición de un método .......................................................................... 81
Método main.................................................................................................. 82
Crear objetos de una clase ............................................................................. 82
Cómo acceder a los miembros de un objeto .................................................. 83
Protección de los miembros de una clase ...................................................... 84
Miembro de un objeto o de una clase ............................................................ 86
Referencias a objetos ..................................................................................... 88
Pasando argumentos a los métodos ............................................................... 92
EJERCICIOS RESUELTOS .............................................................................. 93
EJERCICIOS PROPUESTOS ............................................................................ 94

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

ENTRADA Y SALIDA...................................................................................... 95
Flujos de entrada ........................................................................................... 97
Flujos de salida.............................................................................................. 98
Excepciones................................................................................................... 98
Flujos estándar de E/S ................................................................................... 100
BufferedInputStream ................................................................................ 101
BufferedReader ........................................................................................ 101
PrintStream............................................................................................... 103
Trabajar con tipos de datos primitivos........................................................... 105
Clases que encapsulan los tipos primitivos .............................................. 106
Clase Leer...................................................................................................... 109
¿DÓNDE SE UBICAN LAS CLASES QUE DAN SOPORTE? ....................... 112
Variable CLASSPATH ................................................................................. 112
CARÁCTER FIN DE FICHERO ....................................................................... 113
CARACTERES \r\n............................................................................................ 115
ALTERNATIVA A LOS FLUJOS DE E/S ....................................................... 116
Entrada de datos ............................................................................................ 117
Salida con formato......................................................................................... 118
MÉTODOS MATEMÁTICOS........................................................................... 119
X JAVA 2. LENGUAJE Y APLICACIONES

EJERCICIOS RESUELTOS .............................................................................. 120

EJERCICIOS PROPUESTOS ............................................................................ 124

CAPÍTULO 7. SENTENCIAS DE CONTROL .................................................. 127

SENTENCIA if .................................................................................................. 127

ANIDAMIENTO DE SENTENCIAS if............................................................. 130
ESTRUCTURA else if ....................................................................................... 132
SENTENCIA switch........................................................................................... 134
SENTENCIA while ............................................................................................ 138
Bucles anidados ............................................................................................. 141
SENTENCIA do ... while ................................................................................... 143
SENTENCIA for ................................................................................................ 146
SENTENCIA break ............................................................................................ 150
SENTENCIA continue ....................................................................................... 150
SENTENCIAS try ... catch................................................................................. 151
EJERCICIOS RESUELTOS .............................................................................. 153
EJERCICIOS PROPUESTOS ............................................................................ 158

CAPÍTULO 8. MATRICES.................................................................................. 161

INTRODUCCIÓN A LAS MATRICES ............................................................ 162

MATRICES NUMÉRICAS UNIDIMENSIONALES ....................................... 163
Declarar una matriz ....................................................................................... 163
Crear una matriz ............................................................................................ 164
Iniciar una matriz........................................................................................... 165
Acceder a los elementos de una matriz.......................................................... 165
Métodos de una matriz .................................................................................. 166
Trabajar con matrices unidimensionales........................................................ 167
CADENAS DE CARACTERES ........................................................................ 170
Clase String ................................................................................................... 172
String(String valor) .................................................................................. 172
String toString()........................................................................................ 173
String concat(String str) ........................................................................... 173
int compareTo(String otroString) ............................................................. 173
int length()................................................................................................ 175
String toLowerCase() ............................................................................... 175
String toUpperCase()................................................................................ 175
String trim().............................................................................................. 175
boolean startsWith(String prefijo) ............................................................ 175
boolean endsWith(String sufijo)............................................................... 175
 CONTENIDO XI

String substring(int IndiceInicial, int IndiceFinal) ................................... 176

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

CAPÍTULO 9. MÉTODOS................................................................................... 201

PASAR UNA MATRIZ COMO ARGUMENTO A UN MÉTODO ................... 201

MÉTODO QUE RETORNA UNA MATRIZ .................................................... 203
REFERENCIA DE UN TIPO PRIMITIVO ........................................................ 205
ARGUMENTOS EN LA LÍNEA DE ÓRDENES ............................................. 207
MÉTODOS RECURSIVOS ............................................................................... 210
MÉTODOS SOBRECARGADOS ..................................................................... 211
NÚMERO VARIABLE DE PARÁMETROS.................................................... 213
VISUALIZAR DATOS CON FORMATO ........................................................ 215
LA CLASE Arrays ............................................................................................. 218
binarySearch.................................................................................................. 218
equals............................................................................................................. 218
XII JAVA 2. LENGUAJE Y APLICACIONES

fill .................................................................................................................. 219

sort................................................................................................................. 219
COLECCIONES................................................................................................. 220
EJERCICIOS RESUELTOS .............................................................................. 221
EJERCICIOS PROPUESTOS ............................................................................ 225

CAPÍTULO 10. TRABAJAR CON FICHEROS ................................................ 229

VISIÓN GENERAL DE LOS FLUJOS DE E/S ................................................ 231

ABRIENDO FICHEROS PARA ACCESO SECUENCIAL ............................. 231
Flujos de bytes............................................................................................... 232
FileOutputStream ..................................................................................... 232
FileInputStream........................................................................................ 235
Clase File....................................................................................................... 237
Flujos de datos de tipos primitivos ................................................................ 240
DataOutputStream .................................................................................... 240
DataInputStream....................................................................................... 241
Un ejemplo de acceso secuencial .................................................................. 243
Escribir en un fichero ............................................................................... 243
Más sobre excepciones ............................................................................. 246
Leer de un fichero .................................................................................... 247
ABRIENDO FICHEROS PARA ACCESO ALEATORIO ............................... 249
La clase RandomAccessFile .......................................................................... 250
La clase CPersona.......................................................................................... 252
La clase CListaTfnos..................................................................................... 254
Constructor CListaTfnos .......................................................................... 254
Escribir un registro en el fichero .............................................................. 256
Añadir un registro al final del fichero ...................................................... 257
Leer un registro del fichero ...................................................................... 258
Eliminar un registro del fichero................................................................ 258
¿Hay registros marcados para eliminar?................................................... 259
Buscar un registro en el fichero................................................................ 259
Un ejemplo de acceso aleatorio a un fichero ................................................. 260
Modificar un registro................................................................................ 263
Actualizar el fichero ................................................................................. 265
UTILIZACIÓN DE DISPOSITIVOS ESTÁNDAR .......................................... 266
EJERCICIOS RESUELTOS .............................................................................. 267
EJERCICIOS PROPUESTOS ............................................................................ 273
 CONTENIDO XIII

CAPÍTULO 11. INTERFACES GRÁFICAS ...................................................... 277

FORMULARIOS ............................................................................................... 279

BIBLIOTECA JFC ............................................................................................. 281
DISEÑO DE UNA APLICACIÓN CON INTERFAZ GRÁFICA..................... 282
Contenedores ................................................................................................. 283
Ejecutar la aplicación .................................................................................... 286
Editar el código fuente................................................................................... 286
Añadir los componentes al contenedor.......................................................... 287
Dibujar los componentes .......................................................................... 289
Asignar un administrador de diseño ......................................................... 290
Añadir una etiqueta y editar sus propiedades ........................................... 291
Redimensionamiento automático ............................................................. 292
Añadir un botón y editar sus propiedades ................................................ 292
Asignar manejadores de eventos a un objeto................................................. 293
Eliminar un método añadido por el asistente................................................. 296
Añadir otro código......................................................................................... 296
Compilar la aplicación................................................................................... 297
Depurar la aplicación..................................................................................... 298
Administradores de diseño nulo y absoluto................................................... 300
AÑADIR OTROS CONTROLES ...................................................................... 301
Dibujar los controles...................................................................................... 302
Escribir los controladores de eventos ............................................................ 304
Añadir una barra de menús............................................................................ 307
AÑADIR OTROS FORMULARIOS A LA APLICACIÓN .............................. 309
Mostrar ventanas de diálogo.......................................................................... 310
EJERCICIOS RESUELTOS .............................................................................. 311
EJERCICIOS PROPUESTOS ............................................................................ 315

CAPÍTULO 12. APLICACIONES WEB............................................................. 317

APLICACIÓN WEB .......................................................................................... 317

Crear una aplicación Web ............................................................................. 318
Editar los ficheros fuente de la aplicación Web ............................................ 319
Editar una página JSP de una aplicación Web............................................... 320
Crear una página JSP para una aplicación Web ............................................ 322
Ejecutar la aplicación Web ............................................................................ 323
XIV JAVA 2. LENGUAJE Y APLICACIONES

CAPÍTULO 13. ACCESO A UNA BASE DE DATOS....................................... 325

SQL .................................................................................................................... 326

GESTOR DE BASES DE DATOS MySQL ...................................................... 328
Instalación ..................................................................................................... 329
Poner en marcha MySQL en Windows ......................................................... 329
UTILIDADES DE MySQL ................................................................................ 330
CREAR UNA BASE DE DATOS ..................................................................... 331
UTILIZAR EL CONTROLADOR MySQL CON NetBeans ............................. 332
ACCESO A UNA BASE DE DATOS CON JDBC ........................................... 333
EJERCICIOS PROPUESTOS ............................................................................ 341

APÉNDICES

A. ENTORNO DE DESARROLLO INTEGRADO PARA JAVA .................... 343

DISEÑO DE UNA APLICACIÓN DE CONSOLA........................................... 343

DEPURAR UNA APLICACIÓN CON NETBEANS........................................ 346
VARIABLE CLASSPATH ................................................................................ 348
OPCIONES DEL ENTORNO DE DESARROLLO .......................................... 349
PROYECTOS..................................................................................................... 350
COMPLETAR EL CÓDIGO MIENTRAS SE ESCRIBE ................................. 351
OBTENER AYUDA .......................................................................................... 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 ......................... 359

JUEGO DE CARACTERES ANSI .................................................................... 360
UTILIZACIÓN DE CARACTERES ASCII ...................................................... 361
JUEGO DE CARACTERES ASCII ................................................................... 362
JUEGO DE CARACTERES UNICODE ........................................................... 363
 PRÓLOGO
Java, junto con C#, es actualmente uno de los lenguajes de programación más po-
pular 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 alcan-
ce 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; es-
to es, como muchos lenguajes, permite trabajar con todo tipo de datos, crear es-
tructuras 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 modu-
lares 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 es-
te lenguaje, denomina Java 2, y su propósito es ayudar al lector a aprender a pro-
gramar 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 pro-
porciona 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 pro-
gramación y Java2 – Interfaces gráficas y aplicaciones para Internet.
XVI JAVA 2. LENGUAJE Y APLICACIONES

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 desarro-
llo Java. Sun Microsystems, propietario de Java, proporciona uno de forma gratui-
ta, 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ódi-
go, 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 pre-
viamente J2SE Development Kit 5.0.

Asegúrese de que las variables de entorno PATH y CLASSPATH están perfec-

tamente 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 ins-
talació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 JAVA 2. LENGUAJE Y APLICACIONES

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 uti-

lizando 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á Hola-
Mundo 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 nues-

tro 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 JAVA 2. LENGUAJE Y APLICACIONES

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 fiche-
ros 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 pue-
den ser necesarias para compilar la aplicación. Finalmente, la ventana que hay de-
bajo 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 HolaMun-

do.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 eje-
cutando 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.
 APÉNDICE A: ENTORNO DE DESARROLLO INTEGRADO PARA JAVA 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 Break-
point (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 órde-
nes del menú Run o los botones correspondientes de la barra de herramientas De-
bug (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 depu-

ració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 so-
bre 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 coinci-
de con una llamada a un método definido por el usuario, dicho método tam-
bién se ejecuta paso a paso.
• Step Over o F8. Ejecuta la aplicación paso a paso. Si la línea a ejecutar coin-
cide 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 invo-
cado 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 JAVA 2. LENGUAJE Y APLICACIONES

Para ver los valores intermedios que van tomando las variables ponga el cur-
sor sobre ellas, o bien utilice las ventanas Watches, Local Variables, etc., del fon-
do 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. Algu-
nas 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.
 APÉNDICE A: ENTORNO DE DESARROLLO INTEGRADO PARA JAVA 349

3. Seleccione la carpeta correspondiente al proyecto, y en el diálogo que se vi-

sualiza observe la lista Project JAR Files (ficheros JAR del proyecto); mues-
tra 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 fi-
chero 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 esta-
blecer las propiedades del entorno de desarrollo integrado:
350 JAVA 2. LENGUAJE Y APLICACIONES

Si hace clic en el botón Advanced Options (opciones avanzadas) se visualiza-

rá 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 te-
ner que especificar los ficheros que incluye, especificar la clase principal del pro-
yecto, ver bajo la pestaña Project del explorador todos los ficheros que componen
el proyecto, configurar el entorno de desarrollo integrado (EDI) para cada proyec-
to, 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.
 APÉNDICE A: ENTORNO DE DESARROLLO INTEGRADO PARA JAVA 351

Puede tener cargados varios proyectos simultáneamente y activar en cada ins-

tante 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 CA-
plicacion(). 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 verifica-

ción Auto Popup Completion Window tiene el valor true. Para verlo, ejecute la or-
den Options del menú Tools y haga clic en el botón Editor > General.
352 JAVA 2. LENGUAJE Y APLICACIONES

OBTENER AYUDA
La orden Javadoc Index Search del menú Tools (Mayúsculas+F1) permite obte-
ner ayuda acerca de múltiples temas. Pero si quiere obtener ayuda acerca de la bi-
blioteca 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 en-
cuentra la ayuda mencionada; si no es así, añádala.

Después del proceso anterior, cuando pulse las teclas Mayúsculas+F1, se vi-
sualizará el panel que se muestra en la figura siguiente, donde podrá solicitar ayu-
da 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.
 APÉNDICE A: ENTORNO DE DESARROLLO INTEGRADO PARA JAVA 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 li-
bros. Por eso este apéndice. Debe acostumbrarse a manejar la ayuda que propor-
ciona 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 JAVA 2. LENGUAJE Y APLICACIONES

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 po-

dremos 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 paque-

tes 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 ejerci-
cios 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 des-
de 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. Cambie a root (administrador): $ su -

2. Sitúese en el directorio donde copió el fichero .bin.
3. Ejecute la orden: # ./ jdk-1_5_0_09-nb-5_0-linux-ml.bin
4. La orden anterior inicia el asistente de instalación.
5. Siga los pasos indicados por el asistente de instalación.
6. Salga de la sesión de root: # exit

La figura siguiente muestra un ejemplo de instalación, la realizada para pro-

bar los ejemplos de este libro:
358 JAVA 2. LENGUAJE Y APLICACIONES

Si a continuación desea instalar la documentación, descomprima (unzip) el fi-

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