JBCalvert

Vista previa del material en texto

Aprenda JBuilder con
Charlie Calvert
Charlie Calvert y
Margie Calver
Danypress - Danysoft Internacional
www.danypress.com
DERECHOS RESERVADOS.
El contenido de esta publicación tiene todos los derechos reservados, por lo que no se puede reproducir,
transcribir, transmitir, almacenar en un sistema de recuperación o traducir a otro idioma de ninguna forma o
por ningún medio mecánico, manual, electrónico, magnético, químico, óptico, o de otro modo. La persecución
de una reproducción no autorizada tiene como consecuencia la cárcel y/o multas.
LIMITACIÓN DE LA RESPONSABILIDAD.
Tantos los autores como el equipo de Danysoft hemos revisado el texto para evitar cualquier tipo de error, pero
no podemos prometerle que el libro estará siempre libre de errores. Por ello, y para que esto no sea una
molestia para usted, hemos habilitado en un apartado especial para que cada libro que publiquemos
permanezca “vivo”. Asimismo, podrá enviarnos por e-mail a sus comentarios sobre el libro.
DESCUENTOS ESPECIALES.
Recuerde que Danypress ofrece descuentos especiales a centros de formación y en compras por volumen. Para
más detalles, consulte con en España o con en Latinoamérica.
Todos los productos y marcas se mencionan únicamente con fines de identificación y están registrados por sus
respectivas compañías.
Copyright versión en castellano © 2003 Danysoft Internacional
Avda. España, 17 – 28100 Alcobendas, Madrid. España.
ISBN: 84-932720-6-X
Depósito Legal:
Traducido de: Charlie Calvert’s Learn JBuilder
©Wordware Publishing – ISBN: 1-55622-330-7
IMPRESO EN ESPAÑA – PRINTED IN SPAIN
ii
Prólogo
Presentar este libro a la comunidad de desarrolladores españoles representa una
satisfacción desde distintos puntos de vista.
En primer lugar, porque es muy agradecido hablar del autor dada su merecida fama
tanto internacional como entre nosotros. Charlie Calvert, además de ser largamente
conocido por su trabajo dentro de Borland, nos ha visitado en repetidas ocasiones para
traernos de primera mano las novedades tecnológicas que se estaban fraguando dentro
de Borland, posiblemente por su capacidad de aunar el más detallado conocimiento con
exposiciones claras que facilitan tanto la familiaridad con el producto.
También es grato comprobar el continuo desempeño de Danysoft en acercar los libros
más sobresalientes sobre las herramientas Borland a los desarrolladores de habla
española. A las cuidadas ediciones que vienen publicando desde tiempo atrás de libros
sobre Delphi o Kylix, ahora suman este primero de JBuilder, en lo que a mi entender ha
sido una acertada elección.
Por último, pero quizás lo principal, confiamos en que este libro suponga una ayuda
relevante para usted, ya sea desarrollador en Java o no siéndolo aún, va a utilizarlo
como guía en el apasionante viaje que se dispone a emprender. La calidad de JBuilder
es motivo de orgullo en Borland, tanto más por el reconocimiento del que ha sido objeto
por parte de sus usuarios y de la industria en general. Esta obra realmente se constituirá
en su referencia para comenzar a extraer el potencial que JBuilder le ofrece, y que con
seguridad, podrá seguir ampliando hasta metas que en este punto de partida, aún no
sospecha.
Esperamos que a través de sus páginas, usted también llegue a hacerse partícipe del
entusiasmo que todos, autores, editores, y fabricante, hemos depositado en Jbuilder.
Nestor Miranda Carús
Director General
Borland Ibérica
iii
Prólogo
iv
Dedicatorias
A mi hermano Jim: buen amigo, sabio consejero.
Charlie Calvert
A mi maravillosa y querida madre, Clazine Masselink.
Margie Calvert
Agradecimientos
Me gustaría agradecer a Wes Beckwith de Wordware, quien me animó en mis peores
momentos. Beth Kohler hizo un maravilloso trabajo editando el libro y siempre actuó con una
profesionalidad inspirante y elegante. Y un agradecimiento especial a Jim Hill, por reunir todo
esto y por todos los libros maravillosos que ha ayudado a crear.
Gracias a Lonnie Heinke por ayudar a Margie a aprender Java. Gracias a Dan Horn por su
soporte técnico y por enseñar a Charlie a ser un mejor programador. Gracias a todas las
comunidades de Java y Linux por su inspiración y soporte. Gracias a Dean Williams por su
paciencia y buen humor. Gracias a todos los que ayudaron a crear JBuilder en Borland. Es una
excelente herramienta y facilita el mejor desarrollo Java del mundo. Tanto John Kaster como
Anders Ohlsson me proporcionaron soporte más allá de su deber durante el desarrollo de este
libro.
Charlie y Margie querían agradecerse mutuamente el uno al otro, por haber sido capaces
de sobrevivir a esta enorme empresa sin perder en absoluto su sentido de la perspectiva y del
humor.
v
Dedicatorias
vi
Contents
Capítulo 1 Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Público al que va dirigido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Contenido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Propósito del libro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Vista general de JBuilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
El mito de los formatos propietarios . . . . . . . . . . . . . . . . . . . . . . . . . 5
Gestión de proyectos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Algunas palabras sobre las ediciones de JBuilder . . . . . . . . . . . . . . . . . . 6
Sobre Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
La cambiante especificación de Java. . . . . . . . . . . . . . . . . . . . . . . . . . 8
Los letrados del lenguaje Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
El libro y el lenguaje Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
JBuilder y Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
¿Qué pienso de Java? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
¿Qué pienso de Bill y Linus? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
CD de herramientas/Contactar con el autor . . . . . . . . . . . . . . . . . . . . . . . . 12
Yo no soy abogado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Mi –o nuestro- estilo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Capítulo 2 Instalación y configuración . . . . . . . . . . . . . . . . . . . 15
Vista general de la instalación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Requerimientos de hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Instalando el JDK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
La instalación de JBuilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Descargando e instalando JBuilder Edición Personal . . . . . . . . . . . . . . . . 17
Notas sobre la instalación de JBuilder en Windows. . . . . . . . . . . . . . . . . 17
Notas sobre la instalación de JBuilder en Linux. . . . . . . . . . . . . . . . . . . 19
La instalación alternativa desde un fichero zip . . . . . . . . . . . . . . . . . . . 19
Asegurando que las aplicaciones y applets básicas funcionan . . . . . . . . . . . . . . 19
Configurando JBuilder desde la línea de comandos . . . . . . . . . . . . . . . . . . . . 21
Configurando correctamente la memoria . . . . . . . . . . . . . . . . . . . . . . . . . 22
Problemas con font.properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Utilizando Ant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
CodeBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Capítulo 3 Creandoapplets y aplicaciones por defecto . . . . . . . . . . 27
Vista general . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Creando un nuevo proyecto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Paso opcional para facilitar la documentación Javadoc . . . . . . . . . . . . . . . 31
Creando una nueva aplicación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Creando una nueva applet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Visualizando su applet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Visualizando la applet con un navegador . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Cambio de JDK en aplicaciones y applets . . . . . . . . . . . . . . . . . . . . . . . . . 39
Applets y JDKs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Applets e instalación automática de JREs en tiempo de ejecución. . . . . . . . . 40
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Capítulo 4 Usando el IDE . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Definiendo términos: el IDE y el Visualizador de aplicaciones. . . . . . . . . . . . . . 43
El Visualizador de Aplicaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Explorando un proyecto simple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
El Panel de Mensajes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Las pestañas de visualización de ficheros . . . . . . . . . . . . . . . . . . . . . . . . . 49
Automatización: Creación de una clase . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Breve introducción a CodeInsight . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Capítulo 5 Vista general de JBuilder . . . . . . . . . . . . . . . . . . . . 59
El menú Archivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
La Galería de Objetos - Versiones Personal, Developer y Enterprise . . . . . . . 61
La ficha General. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
La ficha Proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
La ficha Web. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
La ficha XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
La ficha CORBA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
La ficha Generar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
La ficha Enterprise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
La ficha Test. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
El menú Buscar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Buscar en vía de acceso. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Búsqueda Incremental . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Ir a la Línea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Buscar Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
El menú Proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Personalización del entorno JBuilder . . . . . . . . . . . . . . . . . . . . . . . . 66
El menú Ejecutar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
El menú Equipo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
El menú Asistentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
El menú Herramientas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Añadiendo una herramienta de terceros al sistema de menús de JBuilder . . . . 71
El menú Ventana. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
El menú Ayuda. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
El API OpenTools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Capítulo 6 El Diseñador IU . . . . . . . . . . . . . . . . . . . . . . . . . 75
Una teoría sobre el diseño de interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . 76
viii
Bases del Diseñador IU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Arrastrando componentes sobre el Diseñador IU . . . . . . . . . . . . . . . . . . . . . 79
Visualizando el código que JBuilder genera . . . . . . . . . . . . . . . . . . . . . 80
El constructor de Frame1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Entendiendo jbInit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Más sobre la edición manual de código IU. . . . . . . . . . . . . . . . . . . . . . 85
Comprendiendo processWindowEvent . . . . . . . . . . . . . . . . . . . . . . . 88
Técnicas y trucos de programación visual . . . . . . . . . . . . . . . . . . . . . . . . . 91
Selección múltiple de componentes . . . . . . . . . . . . . . . . . . . . . . . . . 91
Borrado de componentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
¡El Panel de Estructura manda! . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
El Inspector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Creando un manejador de sucesos sencillo . . . . . . . . . . . . . . . . . . . . . 93
Usando JTabbedPane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Configurando su classpath dentro del IDE. . . . . . . . . . . . . . . . . . . . . . . . . 95
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Capítulo 7 Usando el editor . . . . . . . . . . . . . . . . . . . . . . . . . 97
Configuración de teclado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
JBuilder y las macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Plantillas de código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Configurando los tabuladores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Configurando los retornos de carro . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Error Insight . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Permitiendo a JBuilder escribir sus bloques try..catch . . . . . . . . . . . . . . . . . 102
Permitiendo que JBuilder escriba sus sentencias de importación . . . . . . . . . . . 103
Más sobre las sentencias de importación . . . . . . . . . . . . . . . . . . . . . 104
Optimizando las importaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
CodeInsight. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
MemberInsight. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
ClassInsight . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
ParameterInsight . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
Buscar definición. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Buscar referencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Integración con el panel de estructura . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Conjuntos de recursos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Modificar métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Implementando interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Integración con emacs y otros editores. . . .. . . . . . . . . . . . . . . . . . . . . . 114
Usando Favoritos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Acceso a Javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Visualizando Javadoc con la tecla F1 . . . . . . . . . . . . . . . . . . . . . . . . 115
Visualizando Javadoc con las pestañas de visualización de ficheros . . . . . . . 115
Visualizando Javadoc descomprimiendo un fichero JAR. . . . . . . . . . . . . . 116
Encontrando errores después de compilar . . . . . . . . . . . . . . . . . . . . . 116
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
ix
Capítulo 8 Java básico: clases, métodos e interfaces . . . . . . . . . . . 118
La analogía de los siguientes tres capítulos . . . . . . . . . . . . . . . . . . . . . . . 118
Comprendiendo las clases Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Sintaxis básica de las clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
El ámbito de una clase: por defecto vs. public . . . . . . . . . . . . . . . . . . . . . . 121
Clases anidadas: no cubiertas en este capítulo. . . . . . . . . . . . . . . . . . . 122
Creando y destruyendo clases. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
Declarando métodos en una clase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
Trabajando con cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
Declarando el tipo de un método . . . . . . . . . . . . . . . . . . . . . . . . . . 124
Usando una clase en una aplicación . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
Constructores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Clases públicas, su primer paquete . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
Herencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
Interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
Capítulo 9 Tipos simples . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Los tipos básicos Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Una clase que usa todos los tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
Declarando los tipos simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
Inicializando los tipos simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
Pensando en booleans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Pensando en chars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Trabajando con bytes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Trabajando con short, int y long . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
¿Qué debo usar: byte, short, int o long? . . . . . . . . . . . . . . . . . . . . . . . . . 148
Trabajando con float y double . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Un programa para probar la clase MyTypes . . . . . . . . . . . . . . . . . . . . . . . 149
Trabajando con menús . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
El código de la aplicación CallMyTypes. . . . . . . . . . . . . . . . . . . . . . . . . . 162
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Capítulo 10 Sentencias, expresiones y palabras clave . . . . . . . . . . . 167
Sentencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
Ejemplos de sentencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
Sentencias compuestas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
Expresiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
Palabras clave. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
Aserciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Capítulo 11 Bucles, operadores y tipos monetarios . . . . . . . . . . . . 175
Bucles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Bucles for. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Bucles while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Comprendiendo los operadores matemáticos . . . . . . . . . . . . . . . . . . . . . . 179
x
Usando operadores matemáticos . . . . . . . . . . . . . . . . . . . . . . . . . . 179
Operadores de multiplicación y enteros . . . . . . . . . . . . . . . . . . . . . . 184
Operaciones de coma flotante y precisión . . . . . . . . . . . . . . . . . . . . . . . . 186
Tipos de coma flotante y de moneda: BigDecimal . . . . . . . . . . . . . . . . . 186
Revisión de promoción y conversión de tipos . . . . . . . . . . . . . . . . . . . . . . 188
Operadores de asignación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
Capítulo 12 Gestores de layout . . . . . . . . . . . . . . . . . . . . . . . 192
Teoría de layouts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
Teoría sobre contenedores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
GridBagLayout vs. el mundo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
Un layout es una clase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
Usando clases Borland en sus programas . . . . . . . . . . . . . . . . . . . . . 194
BorderLayout. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
GridLayout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
FlowLayout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
Apariencia de una ventana básica con FlowLayout . . . . . . . . . . . . . . . . . . . 203
Apariencia de una ventana básica con VerticalFlowLayout. . . . . . . . . . . . 205
Boxes, más boxes y BoxLayouts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
Usando el contenedor Box . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
BoxLayout2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
Usando la clase Box con BoxLayout2 . . . . . . . . . . . . . . . . . . . . . . . 211
Botones a la derecha en una ventana con BoxLayout . . . . . . . . . . . . . . 214
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
Capítulo 13 Más sobre layouts y menús. . . . . . . . . . . . . . . . . . . 219
Null y XYLayout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
GridBagLayout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
CardLayout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
Gestores de layout en ediciones Developer y Enterprise. . . . . . . . . . . . . 235
El Diseñador de Menús . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
Capítulo 14 Manejo de sucesos . . . . . . . . . . . . . . . . . . . . . . . 239
Manejo de sucesos básico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
Cómo son llamados los sucesos. . . . . . . . . . . . . . . . . . . . . . . . . . . 241
Adaptadores anónimos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
Adaptadores anónimos vs. adaptadoresestándar . . . . . . . . . . . . . . . . . 245
La clase ActionEvent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
Usando otros sucesos estándar . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
Personalizando el mecanismo de manejo de sucesos de JBuilder . . . . . . . . 248
Interfaces listener y clases adaptadores . . . . . . . . . . . . . . . . . . . . . . . . . 250
KeyListener, MouseListener, MouseWheelListener y MouseMotionListener . 251
Entendiendo el programa MouseKey . . . . . . . . . . . . . . . . . . . . . . . 251
Interfaz KeyListener . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
Creando el KeyPanel y MousePanel . . . . . . . . . . . . . . . . . . . . . . . . 254
xi
Registrando un listener . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
Usando KeyPanel y MousePanel . . . . . . . . . . . . . . . . . . . . . . . . . . 255
Escritorios virtuales : Programas JDesktop, JInternalFrame y MDI . . . . . . . . . . 257
Adaptadores de Ratón . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
Capítulo 15 Lanzando sucesos . . . . . . . . . . . . . . . . . . . . . . . 261
El programa de ejemplo Send Event . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
El método que envía el mensaje . . . . . . . . . . . . . . . . . . . . . . . . . . 263
Enviando mensajes personalizados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
Entendiendo la clase PoetEvent . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Disparando un suceso personalizado en un hilo de ejecución. . . . . . . . . . . 275
Usando hilos de ejecución para crear un temporizador . . . . . . . . . . . . . . 275
Consideraciones sobre la arquitectura del suceso Poet . . . . . . . . . . . . . . 279
Monitorizando sucesos personalizados . . . . . . . . . . . . . . . . . . . . . . . 279
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
Capítulo 16 Botones de radio y casillas . . . . . . . . . . . . . . . . . . . 285
Creando una aplicación que usa botones de radio y casillas . . . . . . . . . . . . . . . 285
Añadiendo menús . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
Añadiendo sucesos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
Manejando los sucesos de un JCheckBox . . . . . . . . . . . . . . . . . . . . . 292
Manejadores de sucesos para elementos de un menú. . . . . . . . . . . . . . . 294
Botones de radio y tipos enumerados. . . . . . . . . . . . . . . . . . . . . . . . . . . 296
Conflictos de tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
Haciendo público su tipo enumerado . . . . . . . . . . . . . . . . . . . . . . . . 300
El código del ejemplo RadioButtonApplet . . . . . . . . . . . . . . . . . . . . . 300
Los manejadores de sucesos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
Capítulo 17 Diseño visual y reutilización . . . . . . . . . . . . . . . . . . 309
Usando el componente JSlider en una applet. . . . . . . . . . . . . . . . . . . . . . . 309
Creando la interfaz. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
Añadiendo sucesos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
Conectando múltiples controles al mismo suceso . . . . . . . . . . . . . . . . . 313
Añadiendo MyColorSlider a la ventana principal de la applet . . . . . . . . . . . 314
Probando la applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
Creando su applet a partir de múltiples componentes. . . . . . . . . . . . . . . 316
Intermedio: Applet, JApplet y Swing . . . . . . . . . . . . . . . . . . . . . . . . 321
Cuadros de lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
Creando el ejemplo ListBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
Añadiendo objetos a un JList . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
Añadiendo gráficos a JList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
Renderizadores de celdas: creando los componentes para que sean mostrados en un
JList. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329
xii
Capítulo 18 El arte del botón . . . . . . . . . . . . . . . . . . . . . . . . 331
Trabajando con botones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
HTML, nemotécnicos y la respuesta a la tecla Alt . . . . . . . . . . . . . . . . 332
Bitmaps en botones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
Configurando un IconImage para su aplicación . . . . . . . . . . . . . . . . . . 335
Usando GridBagLayout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
Configurando botones con bitmaps . . . . . . . . . . . . . . . . . . . . . . . . 338
Convirtiendo un JPanel en un botón . . . . . . . . . . . . . . . . . . . . . . . . 339
Manejo de sucesos en un botón JPanel . . . . . . . . . . . . . . . . . . . . . . . 343
Dibujando el botón JPanel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
Usando sus propios Java Beans en su programa . . . . . . . . . . . . . . . . . . 345
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
Capítulo 19 Creando diálogos. . . . . . . . . . . . . . . . . . . . . . . . 347
Comenzando la aplicación DialogDemo. . . . . . . . . . . . . . . . . . . . . . . . . . 347
Usando la ventana Acerca de . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
Usando JOptionPane para crear ventanas de entrada . . . . . . . . . . . . . . . 349
Ventanas de entrada y mensajes . . . . . . . . . . . . . . . . . . . . . . . . . . 349
Usando JOptionPane para mostrar una ventana de confirmación . . . . . . . . . 351
CodeInsight monta en un caballo blanco . . . . . . . . . . . . . . . . . . . . . . 352
Una buena ventana de mensajes . . . . . . . . . . . . . . . . . . . . . . . . . . 352
Ventanas JOptionPane personalizadas . . . . . . . . . . . . . . . . . . . . . . . 353
Creando una ventana personalizada . . . . . . . . . . . . . . . . . . . . . . . . 355
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
Capítulo 20 Componiendo Java . . . . . . . . . . . . . . . . . . . . . . . 366
Código Cold Mountain . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
Temas cubiertos en este capítulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
Simplificar, simplificar, simplificar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
Java al rescate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
Convenios de nombres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
Lenguaje abstracto vs. lenguaje específico. . . . . . . . . . . . . . . . . . . . . 369
Usando JBuilder para suavizar la programación de "fuerza bruta" . . . . . . . . 370
Encontrando un remedio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
Epílogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
Nombres de variables y métodos de acceso . . . . . . . . . . . . . . . . . . . . 372
Argumentos de métodos: convenios de nombres malos, regulares y buenos . . . . . 373
¿Por qué usan mal los programadores los convenios de nombres? . . . . . . . . 374
¿Es alguna vez correcto usar nombres de variables imprecisos? . . . . . . . . . 375
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
Capítulo 21 Comentarios y Javadoc . . . . . . . . . . . . .. . . . . . . . 377
Comentando su código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
El hombre vs. la máquina . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Los tres niveles de comentarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Código sin comentarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
Comentando cada objeto y método . . . . . . . . . . . . . . . . . . . . . . . . . 379
xiii
Comentando completamente su código . . . . . . . . . . . . . . . . . . . . . . 380
La tecnología detrás de la teoría . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
JBuilder y los comentarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
Usando Javadoc. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
Doclets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
El Asistente Javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
Generando documentación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386
Comprendiendo los ficheros Javadoc . . . . . . . . . . . . . . . . . . . . . . . . 388
Comentarios a nivel de paquete . . . . . . . . . . . . . . . . . . . . . . . . . . 390
Comentarios a nivel Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . 392
Los tags de Javadoc y sintaxis de apariencia resaltada . . . . . . . . . . . . . . 393
Opciones Javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
Visualizando los ficheros Javadoc en un navegador . . . . . . . . . . . . . . . . . . . 395
Trabajando con Javadoc desde la línea de comandos. . . . . . . . . . . . . . . . 396
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
Capítulo 22 Modularidad . . . . . . . . . . . . . . . . . . . . . . . . . . 399
La estética de la programación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
La estética del divide y vencerás . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
Utilizable, extensible y abstracto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
Objetos y ámbito: oculte todo lo que pueda . . . . . . . . . . . . . . . . . . . . . . . 401
Rendimiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402
¿Cuánta complejidad es suficiente?. . . . . . . . . . . . . . . . . . . . . . . . . 403
Java al rescate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
Planificando su código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
Descubriendo los objetos en un problema . . . . . . . . . . . . . . . . . . . . . 404
Imaginando la solución . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
Creando los métodos públicos de una clase . . . . . . . . . . . . . . . . . . . . 405
Creando métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
Nunca copie código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
Tareas discretas aisladas . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
Sobre los métodos largos . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
Use paquetes para las tareas principales . . . . . . . . . . . . . . . . . . . . . . 409
La locura de los sucesos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
El programa FileRename . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
Capítulo 23 Creando aplicaciones simples . . . . . . . . . . . . . . . . . 414
¿Qué son los ficheros JPR y JPX? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
Aplicaciones simples sin paquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
Explorando su nuevo proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
Ejecutando su código: Configurando la clase principal del proyecto . . . . . . . 418
El Asistente de Proyecto para código existente . . . . . . . . . . . . . . . . . . 421
Moviendo un proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
Creando un proyecto simple sin paquetes . . . . . . . . . . . . . . . . . . . . . . . . 421
Creando un proyecto tipo JBuilder sin paquetes . . . . . . . . . . . . . . . . . . . . . 423
Compilando desde la línea de comandos . . . . . . . . . . . . . . . . . . . . . . . . . 426
xiv
Colocando múltiples proyectos en un directorio . . . . . . . . . . . . . . . . . . . . . 427
Ejecutando demos simples del JDK desde JBuilder . . . . . . . . . . . . . . . . . . . 429
Ejecutando la demo Animator . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
Ejecutando la applet ArcTest . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431
Ejecutando aplicaciones desde el JDK . . . . . . . . . . . . . . . . . . . . . . . . . . 432
Dando sentido a las opciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
Capítulo 24 La estructura del proyecto por defecto de JBuilder . . . . . . 435
Proyectos por defecto de JBuilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
Creando una aplicación por defecto . . . . . . . . . . . . . . . . . . . . . . . . . 436
Localizando sus ficheros en el disco duro . . . . . . . . . . . . . . . . . . . . . . . . 437
Vías de acceso por defecto de sus ficheros. . . . . . . . . . . . . . . . . . . . . 437
Cambiando la localización por defecto de sus proyectos . . . . . . . . . . . . . 437
Notas en proyectos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
Pensando en ficheros JPX y JPR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
Compilando proyectos desde la línea de comandos . . . . . . . . . . . . . . . . . . . 444
Temas de configuración . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
¿Cómo guardo un fichero?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
JBuilder y los caracteres de fin de línea . . . . . . . . . . . . . . . . . . . . . . 445
¿Cómo apago los efectos de sonido? . . . . . . . . . . . . . . . . . . . . . . . . 446
¿Cómo indico a JBuilder el fichero principal de mi proyecto?. . . . . . . . . . . 446
Híbridos de applets y aplicaciones . . . . . . . . . . . . . . . . . . . . . . . . . 446
¿Y sobre cambios de JDK? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448
Capítulo 25 Creando proyectos complejos . . . . . . . . . . . . . . . . . 449
Proyectos complejos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449
Añadiendo, borrando y actualizando ficheros de proyecto . . . . . . . . . . . . . . . . 450
JBuilder y los paquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451
Importando paquetes automáticamente en JBuilder. . . . . . . . . . . . . . . . 451
Comprendiendo los paquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453
Introduciendo CodeBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453
Creando proyectos complejos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
Examinando StringTest01 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
Sucesos de StringTest01 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
Caminos más complejos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
Classpaths en la aplicación Timer . . . . . . . . . . . . . . . . . . . . . . . . . 471
Rutas fuera de su proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472
Creando clases fuera del directorio de su proyecto actual . . . . . . . . . . . . 478
Resumen . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478
Capítulo 26 Desarrollo en equipo . . . . . . . . . . . . . . . . . . . . . . 479
Por qué usar CVS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 479
Terminología . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
Añadiendo un proyecto y ficheros a CVS . . . . . . . . . . . . . . . . . . . . . . . . . 480
Añadiendo una aplicación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483
xv
Examinar cambios del proyecto. . . . . . . . . . . . . . . . . . . . . . . . . . . 484
Confirmar proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484
Más sobre Examinar cambios del proyecto. . . . . . . . . . . . . . . . . . . . . . . . 486
Borrando un fichero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
Etiquetas de versión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
Check-out y actualizando un proyecto . . . . . . . . . . . . . . . . . . . . . . . . . . 487
Resolviendo conflictos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490
Usando CVS con JBuilder Personal y Developer . . . . . . . . . . . . . . . . . . . . 493
Recursos e información básica . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
Herramientas de interfaz gráfica . . . . . . . . . . . . . . . . . . . . . . . . . . 493
Trabajando con CVS desde la línea de comandos. . . . . . . . . . . . . . . . . . . . . 494
Inicializando un repositorio CVS para PServer . . . . . . . . . . . . . . . . . . 494
Conectando a un PServer del CVS . . . . . . . . . . . . . . . . . . . . . . . . . 495
Creando un proyecto CVS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
Haciendo check-out de un proyecto CVS . . . . . . . . . . . . . . . . . . . . . 496
Confirmando su trabajo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
Obteniendo actualizaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
Añadiendo ficheros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
Borrando ficheros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497
Obteniendo el estado de un fichero . . . . . . . . . . . . . . . . . . . . . . . . . 497
Obteniendo el estado de un directorio o de un proyecto entero . . . . . . . . . 497
Marcando un fichero como binario después de que haya sido introducido . . . . 497
Obteniendo una etiqueta de versión . . . . . . . . . . . . . . . . . . . . . . . . 497
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
Capítulo 27 Trabajando con ficheros JAR . . . . . . . . . . . . . . . . . . 499
Comprendiendo los ficheros JAR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
¿Por qué usar paquetes? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
Ficheros JAR y los classpaths . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501
Creando y usando ficheros JAR . . . . . . . . . . . . . . . . . . . . . . . . . . . 503
Configurando el programa de prueba . . . . . . . . . . . . . . . . . . . . . 503
Creando el fichero JAR CodeBox . . . . . . . . . . . . . . . . . . . . . . . 507
Creando CodeBoxSimple.jar desde la línea de comandos . . . . . . . . . . 508
El fichero descriptor o manifiesto . . . . . . . . . . . . . . . . . . . . . . 510
Probando su fichero JAR . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
Configurando su classpath: las bibliotecas de JBuilder . . . . . . . . . . . . . . 511
Usando su fichero JAR en el IDE de JBuilder . . . . . . . . . . . . . . . . 512
Bibliotecas que contienen sólo ficheros .class . . . . . . . . . . . . . . . . 513
Compilando TimeIt desde la línea de comandos . . . . . . . . . . . . . . . 514
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
Capítulo 28 Desplegando applets, aplicaciones y ejecutables Java . . . . 517
Creando un recurso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
Creando un botón con Paint Shop Pro . . . . . . . . . . . . . . . . . . . . . . . 518
Creando un botón con GIMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
Creando la aplicación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
Integrando un recurso en su aplicación . . . . . . . . . . . . . . . . . . . . . . 520
xvi
Configurando el botón . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521
Desplegando la aplicación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
Creando el fichero JAR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
Visualizando el archivo creado . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
Creando un ejecutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 529
Comprendiendo los ejecutables de JBuilder . . . . . . . . . . . . . . . . . 529
Creando un fichero JAR desde la línea de comandos . . . . . . . . . . . . . . . 530
Creando un archivo con Ant. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
Incluyendo una applet en un fichero JAR. . . . . . . . . . . . . . . . . . . . . . 532
Creando el fichero JAR para una applet . . . . . . . . . . . . . . . . . . . . . . 532
Usando el archivo en un navegador. . . . . . . . . . . . . . . . . . . . . . . . . 533
ExitApplet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 534
Aplicaciones Web Start . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538
Dificultades. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539
Capítulo 29 El depurador . . . . . . . . . . . . . . . . . . . . . . . . . . 524
Los tipos duros no usan depuradores . . . . . . . . . . . . . . . . . . . . . . . . . . . 524
Técnicas sencillas de depuración . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525
Escribiendo en la salida estándar . . . . . . . . . . . . . . . . . . . . . . . . . . 525
Escribiendo en ficheros de registro. . . . . . . . . . . . . . . . . . . . . . . . . 527
Niveles en los ficheros de registro . . . . . . . . . . . . . . . . . . . . . . 529
Aserciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530
El depurador de JBuilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
Lanzando el depurador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
Encontrando su lugar en el depurador . . . . . . . . . . . . . . . . . . . . . . . 533
Controlando el depurador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535
Las vistas del depurador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537
Vistas de Salida, Entrada y Errores de Consola . . . . . . . . . . . . . . . 538
Vista Puntos de Observación de Datos . . . . . . . . . . . . . . . . . . . . 538
Vista Puntos de Interrupción de Datos y Código . . . . . . . . . . . . . . 539
Vista Clases Cargadas y Datos Estáticos . . . . . . . . . . . . . . . . . . . 543
Vista Clases con Inspección Desactivada. . . . . . . . . . . . . . . . . . . 543
Hagamos inventario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
Encontrando el error en un programa . . . . . . . . . . . . . . . . . . . . . . . 543
Depurando hilos de ejecución . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547
Recordatorios y claves . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
Recolección de basura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
Capítulo 30 Unit Testing con JUnit . . . . . . . . . . . . . . . . . . . . . 555
Unit Testing en la versiónEnterprise . . . . . . . . . . . . . . . . . . . . . . . . . . 555
Añadiendo tests a la clase CodeBox . . . . . . . . . . . . . . . . . . . . . . . . 559
Métodos de prueba que devuelven Strings . . . . . . . . . . . . . . . . . . . . 565
Montajes de tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566
Conjuntos de tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566
Ejecución de tests JUnit desde la línea de comandos . . . . . . . . . . . . . . . . . . 567
xvii
Ejecutando tests en modo texto . . . . . . . . . . . . . . . . . . . . . . . . . . 569
JUnit y Ant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 569
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570
Capítulo 31 Refactorización y UML . . . . . . . . . . . . . . . . . . . . . 571
Refactorizando paquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571
Preparaciones para la refactorización. . . . . . . . . . . . . . . . . . . . . . . . 572
Renombrando en la edición Enterprise. . . . . . . . . . . . . . . . . . . . 572
Renombrando en la edición Developer . . . . . . . . . . . . . . . . . . . . 573
Continuando la refactorización . . . . . . . . . . . . . . . . . . . . . . . . . . . 573
Renombrando clases, métodos y campos . . . . . . . . . . . . . . . . . . . . . . . . . 575
Renombrando el fichero .jpx. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
Renombrando el directorio raíz de su proyecto . . . . . . . . . . . . . . . . . . . . . 576
Deshaciendo una refactorización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 576
Usando el navegador de paquetes para indicar su clase principal . . . . . . . . . . . . 576
La necesidad de generar de nuevo . . . . . . . . . . . . . . . . . . . . . . . . . 578
La mala forma de renombrar una clase . . . . . . . . . . . . . . . . . . . . . . . . . . 578
La buena forma de renombrar una clase . . . . . . . . . . . . . . . . . . . . . . . . . 579
Refactorización usando JBuilder Personal . . . . . . . . . . . . . . . . . . . . . . . . 580
Cambiando el nombre de un paquete usando JRefactory . . . . . . . . . . . . . 581
Cambiando el nombre de una clase usando JRefactory . . . . . . . . . . . . . . 582
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583
Capítulo 32 Introducción al API OpenTools . . . . . . . . . . . . . . . . . 585
Qué puede hacer con la API OpenTools . . . . . . . . . . . . . . . . . . . . . . . . . 585
Creando un proyecto OpenTools simple . . . . . . . . . . . . . . . . . . . . . . . . . 586
Implementando una OpenTool sencilla de línea de comandos . . . . . . . . . . 586
Trabajando con la interfaz Command . . . . . . . . . . . . . . . . . . . . . . . . 587
Registrando su OpenTool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 589
Usando JBuilder para crear una OpenTool . . . . . . . . . . . . . . . . . . . . . . . . 590
Ejecutando un proyecto sencillo OpenTools . . . . . . . . . . . . . . . . . . . . . . . 592
El fichero classes.opentools. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
OpenTools y el Creador de recopilatorios . . . . . . . . . . . . . . . . . . . . . 593
Creando un fichero JAR OpenTools desde la línea de comandos . . . . . . . . . 595
Ejecutando una OpenTool desde el directorio de su proyecto . . . . . . . . . . 596
Creando un proyecto OpenTools con interfaz de usuario . . . . . . . . . . . . . . . . 597
Usando JBuilder para crear una OpenTool . . . . . . . . . . . . . . . . . . . . . 597
El código de la OpenTool con GUI . . . . . . . . . . . . . . . . . . . . . . . . . 597
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601
Capítulo 33 Bases de los Java Beans . . . . . . . . . . . . . . . . . . . . 602
Vista general . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602
¿Qué es BeansExpress? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
Beans y la edición Personal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
Definiendo nuestros términos . . . . . . . . . . . . . . . . . . . . . . . . . . . 604
Creando un bean simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605
Probando su bean con BeanInsight . . . . . . . . . . . . . . . . . . . . . . . . . 606
xviii
Añadiendo una propiedad a su bean . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
Ficheros BeanInfo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
Comprendiendo SimpleBeanInfo . . . . . . . . . . . . . . . . . . . . . . . . . . 613
Exponiendo y ocultando propiedades del ancestro . . . . . . . . . . . . . . . . 614
Usando su bean. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616
Mejorando su bean. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
Propiedades monitorizables y restringidas . . . . . . . . . . . . . . . . . . . . . . . . 622
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
Capítulo 34 La cosecha de Java Beans . . . . . . . . . . . . . . . . . . . 625
Encapsulando Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
ElfListBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
List Boxes, ArrayList y los flujos (streams) . . . . . . . . . . . . . . . . . . . . 632
ElfScrollListBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636
Marcando código como obsoleto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
Directorios ext . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
El futuro del desarrollo visual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639
Capítulo 35 Java Beans y propiedades . . . . . . . . . . . . . . . . . . . 641
El bean Clock. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641
Añadiendo propiedades a un bean . . . . . . . . . . . . . . . . . . . . . . . . . 642
Inicializando el reloj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 643
Mejorando el componente Clock . . . . . . . . . . . . . . . . . . . . . . . . . . 645
Redefiniendo una oropiedad existente . . . . . . . . . . . . . . . . . . . . 645
Dibujando el texto directamente en el control . . . . . . . . . . . . . . . . 649
Redefiniendo el método paint . . . . . . . . . . . . . . . . . . . . . . . . . 649
Mejorando el control. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 650
Exponiendo propiedades del nuevo reloj . . . . . . . . . . . . . . . . . . . . . . 652
Exponiendo sucesos del nuevo reloj . . . . . . . . . . . . . . . . . . . . . . . . 654
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659
Capítulo 36 Java Beans, paquetes y Java 2D. . . . . . . . . . . . . . . . 661
Creando la versión 1.0 del reloj . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661
Moviendo ficheros a un nuevo paquete. . . . . . . . . . . . . . . . . . . . . . . 661
Temas de rutas: Creando ficheros en un nuevo directorio . . . . . . . . . . . . 663
Actualizando la interfaz visual del reloj . . . . . . . . . . . . . . . . . . . . . . . . . . 665
Dibujando números LCD con Graphics2D . . . . . . . . . . . . . . . . . . . . . 677
El tipo enumerado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 680
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 681
Capítulo 37 BeanInsight y ficheros JAR . . . . . . . . . . . . . . . . . . 683
Usando BeanInsight. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683
Comprendiendo los ficheros JAR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 686
Creando un fichero JAR para su bean. . . . . . . . . . . . . . . . . . . . . . . . 687
Creando ficheros JAR desde la línea de comandos. . . . . . . . . . . . . . 688
xix
Usando el Creador de recopilatorios para crear un fichero JAR. . . . . . . 689
Colocando el bean en la Paleta de componentes . . . . . . . . . . . . . . . . . . 690
Creando una applet de prueba. . . . . . . . . . . . . . . . . . . . . . . . . . . . 692
Añadiendo iconos a su bean . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692
Creando un buen fichero descriptor . . . . . . . . . . . . . . . . . . . . . . . . 694
Trabajando con ficheros Ant. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 695
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 696
Capítulo 38 Introducción a la programación de bases de datos . . . . . . 694
Público objetivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 694
¿Qué es JDBC y qué tiene que ver con DataExpress?. . . . . . . . . . . . . . . . . . 695
¿Qué es un servidor de bases de datos? . . . . . . . . . . . . . . . . . . . . . . . . . 695
Servidores SQL y bases de datos locales. . . . . . . . . . . . . . . . . . . . . . 696
¿Qué es una base de datos relacional? . . . . . . . . . . . . . . . . . . . . . . . 696
¿Qué es SQL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 697
¿Qué es un dataset? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698
Manteniendo la integridad de una base de datos relacional . . . . . . . . . . . . . . . 699
Borrados en cascada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699
Claves e índices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 700
Chequeos de validez, claves y diferencias entre bases de datos . . . . . . . . . 700
¿Qué es un controlador? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704
JDBC vs. ODBC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704
Capítulo 39 Configuración de bases de datos . . . . . . . . . . . . . . . 705
Trabajando con diferentes bases de datos . . . . . . . . . . . . . . . . . . . . . . . . 706
Configurando MySQL en Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706
Ejecutando MySQL como una aplicación en Windows . . . . . . . . . . . . . . 709
Apagando MySQL como aplicación en Windows. . . . . . . . . . . . . . . . . . 710
Ejecutando y apagando MySQL como servicio Windows . . . . . . . . . . . . . 710
Configurando MySQL sobre Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711
Una GUI para MySQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 714
Creando usuarios y contraseñas en MySQL . . . . . . . . . . . . . . . . . . . . . . . 716
Más sobre cuentas de usuarios . . . . . . . . . . . . . . . . . . . . . . . . . . . 718
Creando bases de datos y tablas sencillas . . . . . . . . . . . . . . . . . . . . . . . . 722
Introducción a InterBase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723
Descargando InterBase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724
Instalando InterBase en Windows y Linux . . . . . . . . . . . . . . . . . . . . . 725
Probando InterBase en Windows y Linux . . . . . . . . . . . . . . . . . . . . . 726
Creando datos para usar con este libro . . . . . . . . . . . . . . . . . . . . . . . . . . 727
Creando tablas para MySQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . 729
Creando tablas para InterBase . . . . . . . . . . . . . . . . . . . . . . . . . . . 732
Creando tablas para Access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 735
Cargando los datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 737
Configurando su entorno Windows . . . . . . . . . . . . . . . . . . . . . . . . . 737
Configurando su entorno Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . 739
Configurando Ant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 740
xx
¿Demasiadas opciones? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 741
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 742
Capítulo 40 Conectando a bases de datos desde JBuilder . . . . . . . . . 743
Instalando los controladores para MySQL . . . . . . . . . . . . . . . . . . . . . . . . 744
Instalando mm.mysql . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744
Trabajando con el Controlador mm.mysql . . . . . . . . . . . . . . . . . . 745
Instalando MyODBC sobre Windows o Linux . . . . . . . . . . . . . . . . . . . 747
Configurando InterBase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 749
Configurando InterClient sobre Windows . . . . . . . . . . . . . . . . . . . . . 749
Configurando InterClient sobre Linux . . . . . . . . . . . . . . . . . . . . . . . 750
Probando InterClient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751
InterBase y JBuilder sobre Windows . . . . . . . . . . . . . . . . . . . . . . . . 752
InterBase y JBuilder sobre Linux. . . . . . . . . . . . . . . . . . . . . . . . . . 753
Instalando ODBC para Access. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 753
Probando su trabajo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 754
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 757
Capítulo 41 Introducción a aplicaciones de bases de datos . . . . . . . . 759
Módulos de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 759
Creando un módulo de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 759
Antes de cerrar el modelador de datos . . . . . . . . . . . . . . . . . . . . . . . 762
Permitiendo que JBuilder construya su aplicación . . . . . . . . . . . . . . . . . . . . 763
Guardando datos: la barra de navegación. . . . . . . . . . . . . . . . . . . . . . 764
Una manera singular de crear un módulo de datos. . . . . . . . . . . . . . . . . . . . 765
Abriendo una base de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 767
QueryDataSet y consultas a una base de datos . . . . . . . . . . . . . . . . . . 769
Cómo obtiene datos JBuilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . 771
Monitorizando la actividad SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . 772
Métodos de acceso a un DataModule . . . . . . . . . . . . . . . . . . . . . . . . 774
Examinando la aplicación generada . . . . . . . . . . . . . . . . . . . . . . . . . . . . 774
Generación de código y plantillas . . . . . . . . . . . . . . . . . . . . . . . . . . 776
ClientResource. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 776
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 778
Capítulo 42 Técnicas de bases de datos . . . . . . . . . . . . . . . . . . 779
Relaciones uno-a-muchos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 779
Creando una relación uno-a-muchos con el Modelador de datos . . . . . . . . . 779
Creando relaciones uno-a-muchos manualmente . . . . . . . . . . . . . . . . . 781
Examinando el conjunto de recursos . . . . . . . . . . . . . . . . . . . . . . . . 783
Mostrando la relación uno-a-muchos al usuario . . . . . . . . . . . . . . . . . . . . . 785
Campos calculados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 788
Editando sus datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 792
Editando los campos calculados. . . . . . . . . . . . . . . . . .. . . . . . . . . 793
Usando DBDisposeMonitor y otras utilidades . . . . . . . . . . . . . . . . . . . . . . 802
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 806
xxi
Capítulo 43 Estrategias de bases de datos. . . . . . . . . . . . . . . . . 807
Búsquedas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 807
Usando JdbNavField . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 807
Búsquedas con locate y lookup . . . . . . . . . . . . . . . . . . . . . . . . . . . 809
Lookups y picklists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 814
Creando un programa que contiene campos de búsqueda. . . . . . . . . . . . . 816
Una introducción al objeto Column de JBuilder . . . . . . . . . . . . . . . . . . 821
Restaurando su programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 822
Empaquetando su aplicación en un fichero JAR o ejecutable . . . . . . . . . . . . . . 823
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 826
Capítulo 44 Control de datos . . . . . . . . . . . . . . . . . . . . . . . . 827
Actualizando, insertando y eliminando . . . . . . . . . . . . . . . . . . . . . . . . . . 827
Inserciones y campos autoincrementales . . . . . . . . . . . . . . . . . . . . . 828
Creando un programa de autoincremento . . . . . . . . . . . . . . . . . . 829
Eliminando una fila . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 832
Insertando una fila . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 833
Volviendo a encontrar la posición en un conjunto de datos con búsquedas simples
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838
Un primer intento de obtener un valor autoincremental en un servidor . . . . . 840
Una mejor forma de obtener un valor autoincremental de un servidor . . . . . 841
Añadiendo una fila a un conjunto de datos . . . . . . . . . . . . . . . . . . . . . 842
Actualizando una fila . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 844
Vaciando un conjunto de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . 845
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 845
Capítulo 45 Consultas SQL, consultas parametrizadas, columnas y
transacciones . . . . . . . . . . . . . . . . . . . . . . . . . . 847
Mayor control sobre las consultas SQL. . . . . . . . . . . . . . . . . . . . . . . . . . 847
Bloqueando tablas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 849
Consultas parametrizadas y objetos Column . . . . . . . . . . . . . . . . . . . . . . . 855
Añadiendo un encuentro (join) a los parámetros de programa . . . . . . . . . . 860
Más sobre la clase Column . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 862
Un vistazo rápido al programa EasySQL . . . . . . . . . . . . . . . . . . . . . . 863
Transacciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 865
Niveles de aislamiento de transacciones . . . . . . . . . . . . . . . . . . . . . . 867
Programas adicionales de ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 868
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 872
Apéndice A Recursos técnicos adicionales . . . . . . . . . . . . . . . . . 873
Información del JDK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 873
Especificación JavaBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 873
Grupos de noticias Java y Comunidad . . . . . . . . . . . . . . . . . . . . . . . . . . 874
OpenTools y descargas de código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 874
Sitios web Java de propósito general . . . . . . . . . . . . . . . . . . . . . . . . . . . 874
Libros completos disponibles en la web de Sun . . . . . . . . . . . . . . . . . . . . . 875
Sitio web de Borland de publicaciones técnicas . . . . . . . . . . . . . . . . . . . . . 875
xxii
Apéndice B Vista General del CD . . . . . . . . . . . . . . . . . . . . . . 877
Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 877
Noticias de última hora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 877
Vista general del CD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 878
Disposición de los proyectos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 879
Usando la edición Personal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 879
Programas extra: Juegos e Internet . . . . . . . . . . . . . . . . . . . . . . . . 879
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 880
xxiii
xxiv
Parte IParte I
Introducción
1
Capítulo 1 Introducción
Capítulo 2 Instalación y configuración
Capítulo 3 Creando aplicaciones y applets por defecto
Capítulo 4 Usando el IDE
Capítulo 5 Vista general de JBuilder
Capítulo 6 El Diseñador IU
Capítulo 7 Usando el editor
Capítulo 1
Introducción
Charlie Calvert
Este libro está pensado para ser una ayuda a los desarrolladores de JBuilder. Téngalo cerca de
su escritorio, úselo como referencia rápida, revise los ejemplos de código, y utilícelo siempre
que necesite ver cómo funciona un aspecto particular de JBuilder. O, si lo desea, puede leerlo
desde el principio al fin para obtener una completa vista general de una herramienta de
desarrollo Java muy poderosa.
Público al que va dirigido
Este libro contiene una introducción general de JBuilder para programadores principiantes,
intermedios y avanzados. Asumo que los lectores de este libro saben cómo programar pero no
conocen nada sobre JBuilder.
Los programadores profesionales y estudiantes serios del lenguaje se sentirán muy
cómodos con este texto; está diseñado para hacer hincapié en los puntos que necesita conocer
para empezar a trabajar.
Si está siguiendo un curso de Java de nivel inicial y quiere aprender cómo usar JBuilder, en
este libro encontrará mucho material que puede encontrar útil. Yo conozco lo que necesitará
hacer con JBuilder, y todo el esfuerzo se ha centrado en incluir esa información.
Este libro está dividido equitativamente entre secciones teóricas y secciones que
pretenden ser interactivas. También he intentado mantener razonablemente cortos la mayoría
de los capítulos e incluir uno o más programas de ejemplo para la mayoría de los capítulos no
introductorios. Por ello, recomendaría dedicar 10 ó 15 minutos para leer un capítulo de
principio a fin. A continuación encender el ordenador, e intentar duplicar los programas o
ejercicios descritos en el capítulo.
En la mayoría de los casos, incluyo breves tutoriales o programas de ejemplo dentro de los
capítulos. Pienso que es una excelente idea que intente repetir los programas de ejemplo
usted mismo. En los primeros capítulos, dedicados a describir el producto, recomiendo
verificar si puede localizar las características descritas y usarlas.
Para resumir, pienso que este libro le será más útil si combina períodos de lectura del texto
con períodos prácticos. La lectura es un ejercicio muy importante, pero no hay nada más
importante que practicar con el propio JBuilder y escribir algo de código.
Dicho esto, me gustaría añadir que he intentado crear capítulos leíbles. Quiero que
entienda que esto no es sólo un tutorial o una referencia, se trata de un libro que usted puede
leer con, al menos, cierto grado de placer.
Contenido
El libro está dividido en las siguientes secciones:
2
Parte I: Comenzando - Aprenda sobre el IDE de JBuilder y cómo realizar funciones básicas
en él.
Parte II: El lenguaje Java - Una introducción a la sintaxis básica del lenguaje Java.
Parte III: Fundamentos de JBuilder - Aprenda cómo crear aplicaciones y applets sencillas
usando JBuilder. Lea sobre el uso del DiseñadorIU para crear las interfaces visuales de su
aplicación. Si está interesado en las bases de Swing, ésta es una buena sección del libro para
explorar.
Parte IV: Arquitectura de proyectos - Contiene una visión general de las técnicas,
convenios y sintaxis usados por los programas de este libro. También es una introducción a las
bases de la buena programación en Java.
Parte V: Gestión de proyectos - Cómo manejar aplicaciones simples y complejas con
JBuilder. Muchos desarrolladores están acostumbrados a crear programas Java desde la línea
de comandos; esta sección explica cómo crear aplicaciones de todas las formas y tamaños
desde JBuilder. Si no entiende completamente los paquetes, éste es el lugar para
comprenderlos de una vez por todas. En esta sección también se discutirá el despliegue de
aplicaciones.
Parte VI: Prueba, depuración y mantenimiento - Aprenda a usar las potentes
herramientas de JBuilder para mantener su programa libre de errores.
Parte VII: JavaBeans - Cómo crear componentes reutilizables. El manejo de sucesos
también será cubierto en esta sección.
Parte VIII: Bases de datos - Cómo crear aplicaciones que acceden a bases de datos SQL.
Las herramientas de bases de datos son parte de las ediciones Developer y Enterprise de
JBuilder. Por ello, ésta es la sección del libro que no le será de mucha ayuda a usuarios de
JBuilder Personal. Puede escribir código de acceso a bases de datos con JBuilder Personal,
pero tendrá que hacerlo todo manualmente. JBuilder no presentará ningún problema, pero
tampoco le servirá de gran ayuda.
El Apéndice ofrece un listado de recursos técnicos adicionales.
Propósito del libro
Como ha podido ver en la sección anterior, la gran mayoría del libro gira alrededor del uso de
JBuilder. El lenguaje Java se trata únicamente en la Parte II: El lenguaje Java. La Parte VII:
JavaBeans tiene muchas secciones específicas dedicadas al lenguaje, pero también tiene lar-
gos pasajes sobre el uso de JavaBeans Express de JBuilder. La Parte V: Gestión de proyectos
incluye largos pasajes sobre el trabajo con paquetes y sentencias de importación, por lo que
también es relativamente específica al lenguaje.
El propósito principal del libro, sin embargo, es la descripción de JBuilder. JBuilder es un
producto amplísimo con características muy potentes. Obtener una idea general de lo que
puede hacer por usted es un gran avance.
Ya que JBuilder es el centro de este libro, me gustaría entrar en una nueva sección del
capítulo que describa el propio JBuilder. Después de leer esta sección, debería comprender
mejor el contenido de este libro.
Introducción 3
P
a
rt
e
I
Vista general de JBuilder
JBuilder es una herramienta que puede ayudarle a construir aplicaciones robustas y de fácil
mantenimiento. Lo hace de tres modos distintos:
� Ofrece un potente editor y depurador. El editor y las herramientas relacionadas, como
CodeInsight, pueden ayudarle a analizar su código y descubrir los objetos y métodos
disponibles en su programa. También puede explorar automáticamente métodos u
objetos en el JDK o en cualquier otra herramienta de terceros que pueda estar
utilizando. Si usa JBuilder nunca tendrá que preguntarse cómo o dónde fue definida
una clase o cómo o dónde se definió una variable. JBuilder siempre conoce todos los
identificadores válidos en su programa. Puede llevarle a su declaración
instantáneamente. El depurador le permite moverse por su código, explorar los hilos
de ejecución de su programa, visualizar variables y realizar otras tareas útiles.
� JBuilder puede ayudarle a generar la interfaz de su programa a través de una serie de
herramientas de diseño visual. Estas herramientas le pueden liberar de la necesidad de
memorizar y buscar los detalles sobre las bibliotecas AWT y Swing. Las herramientas
generan código Java estándar y no le encierran en un formato propietario.
� JBuilder también contiene una serie de asistentes que pueden ayudarle a automatizar
ciertas tareas repetitivas. Por ejemplo, JBuilder le facilita la generación de Javadoc, una
forma de comentar su código. También puede ayudarle a crear ficheros JAR y a
desplegar su aplicación. Otras herramientas en las versiones avanzadas de JBuilder
pueden ayudarle a crear aplicaciones de bases de datos o distribuidas.
Todos estos conceptos, excepto el último mencionado (las aplicaciones distribuidas), serán
cubiertos con profundidad en este libro.
JBuilder no es una varita mágica que puede hacer que un mal programador pase a ser un
buen programador. Yo creo que puede ayudar a los estudiantes a aprender sobre Java y puede
ayudar a acelerar la producción de aplicaciones. No puede, sin embargo, hacer que un
programador mediocre pase a ser un buen programador, así como un procesador de texto no
puede hacer un buen escritor de un mal escritor. Un buen editor puede ayudar a un buen
escritor a ser mejor, y una buena herramienta de programación puede ayudar al buen
programador a ser mejor. No existe un sustituto a las buenas técnicas de aprendizaje de
programación y las reglas que gobiernan el lenguaje Java.
JBuilder no puede reemplazar por arte de magia la necesidad de conocer los detalles del
lenguaje Java. En cambio, JBuilder puede ayudarle a crear programas más rápidamente y con
menos esfuerzo. De nuevo, una buena analogía es un procesador de texto. Ernest Hemingway
iba a ser un gran escritor ya usase una máquina de escribir, un procesador de texto o una
pluma. Sin embargo, un buen escritor puede producir buen texto más rápidamente con un
procesador de texto que con un papel y un lápiz.
Existe una gran complejidad en cualquier tarea de programación seria. Si JBuilder le
ilumina el camino en ciertas áreas del desarrollo, ya es algo positivo.
La mayoría de las funcionalidades avanzadas de JBuilder pueden ser utilizadas o no,
dependiendo de su gusto. Pero incluso si rechaza el 75% de las características de JBuilder,
usted será más productivo usando JBuilder que si usase el Bloc de Notas o incluso un potente
editor como emacs o Visual Slick Edit. Mi punto de vista es que las características básicas del
editor y depurador son suficientes para hacer que cualquier persona que trabaje con un editor
de texto y la línea de comandos se pase a la creación de aplicaciones con JBuilder.
4 Capítulo 1
El mito de los formatos propietarios
Algunas personas tienen la idea de que JBuilder les va a atrapar dentro de algún tipo de
formato propietario. Esto, simplemente, no es cierto. La gran mayoría de las aplicaciones que
he creado con JBuilder compilan absolutamente bien desde la línea de comandos con el JDK
estándar de Sun.
Es posible añadir clases especiales de Borland a su proyecto si usted lo desea, pero no
tiene por qué usarlas si no quiere. Y por supuesto, estas clases especiales de Borland
compilan bien con el JDK de Sun, si incluye los ficheros JAR necesarios en su proyecto. Si no
quiere usar las clases de Borland no tiene por qué hacerlo. No está obviando ninguna
característica de JBuilder si no las usa. Esas clases están disponibles por si desea utilizarlas,
como cualquier otra herramienta de terceros como Xerces, JUnit o Ant. En la mayor parte del
libro, no se usará prácticamente ningún código especial de Borland. La única excepción
importante es la sección de base de datos, que utiliza intensivamente varias bibliotecas muy
útiles de Borland. Sin embargo, no hay que pagar derechos de uso por las herramientas de
bases de datos que discutiremos.
NOTA: Existe una herramienta de bases de datos Java no gratuita de Borland llamada JDataStore.
JDataStore no es, sin embargo, un aspecto que cubriré en este libro. Me gusta la tecnología
JDataStore, pero quiero enfocar este libro al uso de JBuilder para la creación de aplicaciones Java
típicas. No quería complicarlo usando código propietario.
También discutiré JUnit y Ant, que son productos de código abierto, y las herramientas de
bases de datos de Borland, aunque no son parte del JDK. Sin embargo, su uso es