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: editorial@ra-ma.com
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

JAVA 2. LENGUAJE Y APLICACIONES

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

JAVA 2. LENGUAJE Y APLICACIONES

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

JAVA 2. LENGUAJE Y APLICACIONES

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

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

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

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

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

JAVA 2. LENGUAJE Y APLICACIONES

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.

APÉNDICE A: ENTORNO DE DESARROLLO INTEGRADO PARA JAVA

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

JAVA 2. LENGUAJE Y APLICACIONES

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.

APÉNDICE A: ENTORNO DE DESARROLLO INTEGRADO PARA JAVA

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

JAVA 2. LENGUAJE Y APLICACIONES

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.

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

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

JAVA 2. LENGUAJE Y APLICACIONES


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.

Sign up to vote on this title
UsefulNot useful