Tecnicas de Programacion Paso A Paso Con Java - Publicado

TECNICAS AVANZADAS DE
PROGRAMACION CON JAVA
NIVEL BASICO
GUIA PARA ESTUDIANTES
ISBN: 978-958-46-6827-1
John Carlos Arrieta Arrita

Dato Catalograficos
Arrieta Arrieta John Carlos
TÉCNICAS DE PROGRAMACIÓN PASO A PASO CON JAVA
Nivel Básico – Guía para el Estudiante
Primera Edicion.
ISBN: 978-958-46-6827-1
Formato 17.9 x 22.9 cm Páginas: 391
Editor
John Calos Arrieta Arrieta
[email protected]
TÉCNICAS DE PROGRAMACIÓN PASO A PASO CON JAVA

Nivel Básico - Una Guía Para El Estudiante
Autor: John Carlos Arrieta Arrieta

Derechos Reservados: John Carlos Arrieta Arrieta
Blog personal: www.youtube.com/arrietajohn
Primera Edición
ISBN: 978-958-46-6827-1
Derechos Reservados:
Esta obra es propiedad intelectual de sus autores y así como los derechos de
publicación en cualquier idioma. Prohibida su reproducción parcial o total por
cualquier medio, sin autorización escrita de su legítimo titular de derechos del
Copyright.
Nota Importante:
La información contenida en esta obra tiene un fin exclusivamente didáctico y
formativo, el autor aprueba su aprovechamiento a nivel profesional o industrial.
Las indicaciones técnicas y programas incluidos, han sido elaborados con gran
cuidado por el autor y reproducidos bajo estrictas normas de control. El autor no
será jurídicamente responsable por: errores u omisiones, daños y perjuicios que
se pudieran atribuir al use de la información comprendida en este libro, ni por la
utilización indebida que pudiera dársele.
Tecnicas de programación paso paso con Java – Nivel Basico
Una guía para el Estudiante
Dedicación de John Carlos Arrieta Arrieta
La vida de toda persona sea cual sea su condición sexual,

económica, religiosa, social o física, está motivada por
propósitos que se constituyen en retos no solo personales,
sino que involucran directa o indirectamente a otras persona
a su alrededor, muchas veces el cumplimiento de dichas metas
nos exige sacrificar un poco de tiempo y espacio para
compartir con estas personas, a tal punto que nos sentimos
frustrados y deseamos abandonar dichos proyectos, solo por
el deseo y fin poder dedicar más tiempo aquellos que amamos
y nos aman. Es aquí donde nos damos cuenta que el tiempo y
el horario que la vida no otorga para estar con ellos en
realidad el combustible que energiza el motor interno que
nos moviliza para poder alcanzar cada una de nuestra mestas,
pero lamentablemente este preciado e invaluable recurso
llamado tiempo se nos es entregado de manera limitada, con
una la desagradable e inviolable regla que nos imposibilita
volver a recuperarlo o reclamarlo cuando no lo utilicemos.
Es por eso que a través de los años he aprendido a sacar
provecho del tiempo, a organizar más mis actividades y
prioridades, a trabajar, estudiar y aprender mucho cuando
otros están durmiendo, porque deseo y procuro dejar más
tiempo libre para compartir mi vida con los que me necesitan
y con los que yo necesito.
Agradezco infinitamente a Dios, a mis padres, suegros,
amigos, colegas, y por supuesto a mis alumnos en particular
y especialmente dedico a mi amada esposa e hijos cada una de
las metas que he conquistado.
Simple y sinceramente muchas gracias a todos.
5
John Carlos Arrieta Arrieta
Sobre el Autor.
Ingeniero John Carlos Arrieta Arrieta.
Cuanta con 10 años de experiencia como docente investigador en varias facultades

de Ingeniería de importantes Universidades ubicadas en Cartagena Colombia.
Su objeto de estudio y enseñanza se enfoca en el desarrollo de sistemas y
soluciones informáticas eficientes, que faciliten en gran medida los procesos
operativos, cíclicos y rutinarios realizados por la personas en escenario,
permitiéndoles concentrar sus capacidades intelectuales, experiencia y creatividad
en pro de otras actividades que requieren más atención y destrezas cognitivas .
A impartido docencia en asignaturas con modalidad presencial, a distancia, virtual y
personalizada, tales como Lógica algorítmica, Lenguajes de Programación,
Desarrollo, Ingeniería y Calidad del Software, Control Interno y auditoria a los
Sistemas de Información, Inteligencia Artificial, Teoría General de Sistemas,
Patrones de diseño, Gerencia de Proyectos y Asesor de Trabajos de Grado .
Titulado como Ingeniero de Sistemas en 2004 por la Universidad Politécnico de
Colombia, continuo su estudio inclinado por el desarrollo de sistemas al titularse
como Especialista en Ingeniería del Software por la Universidad del Norte en 2005,
posteriormente en 2009 logra el grado de Magister en Ingeniería del Software Libre y
en la actualidad cursa estudios postgraduales en Ingeniería Telemática .
Posee un blog académico en www.youtube.com/arrietajohn
6
Prologo.
Este libro fue escrito como necesidad del autor de poner a disposición de sus
alumnos y personas interesad en desarrollar software, una herramienta de
aprendizaje que les permitiera desarrollar sus competencias rápidamente
mediante la didáctica de hacer y aprender mientras leen.
El libro cuanta con muchos ejemplos guiados paso a paso simples y cortos sobre
cada uno de los temas tratados y organizados en su interior, los cuales pueden
apreciarse en el respectivo índice del presente libro.
El capítulo 1 describe el proceso básico para que se requiere para desarrollar

software sin entrar en detalles técnicos, simplemente se presentan mediante un
ejemplo simple desde donde iniciar, como organizar las ideas, proceso y
recursos, cuales herramientas y tecnologías se pueden utilizar, comprender el
proceso, materializarlo en un algoritmo mediante Diagrama de Flujos,
Seudocódigo, realizar las pruebas básicas, luego implementarlo en un lenguaje
de programación como Java necesarias, todo el proceso es analizado y
comparado nivel tras nivel y paso a paso.
El capítulo 2 trata de una introducción breve sobre los principales elementos y

técnicas para diseñar algoritmos, igualmente usando ejemplos guiados paso a
paso.
En el capítulo 3 explora mediante ejemplos descritos y detallados línea por línea

las herramientas y procesos para construir un programa en el lenguaje de
programación Java, presentando los aspectos básicos de instalación,
configuración y montaje de un espacio básico de trabajo con Java, haciendo
énfasis en las reglas más importantes de la sintaxis de este lenguaje, el cual es
el que se utiliza a lo largo de los siguientes capítulos.
El Cuarto 4 se enfoca en cómo utilizar y sacar ventaja de una herramienta

profesional de Código Abierto como los es Entorno Integrado de Desarrollo
Netbeans, el cual facilita enormemente la labor de desarrollar software, dado
que, agrupa e integra todos los procesos descritos anteriormente, colocando a
disposición del programador un amplio y variado número de herramientas muy
intuitivas que trivializan y hacen muy transparentes muchos procesos, como por
ejemplo la escritura de código, diseño de Interfaces Graficas de Usuario,
7
documentar, depurar, compilar, empaquetar, probar y modificar un proyecto de

Software.
En este capítulo el lector podrá aprender a utilizar y trabajar con los elementos
más importantes de Java para desarrollar Aplicaciones con Interfaces de
Usuario Graficas de una manera muy simple, mediante la metodología de
seleccionar, arrastrar, soltar, configurar, probar y personalizar. Cada uno de los
ejemplos presentados en este capítulo como los anteriores está bien
documentado paso a paso, de tal manera que el lector podrá disfrutar
didácticamente su aprendizaje.
En el capítulo 5 entramos en más detalle y profundidad al explicar igualmente

paso a paso la escritura de código Java necesario para poder diseñar y construir
Formularios e Interfaces Graficas de Usuario sin ayuda de las herramientas
generadoras de código provistas por el Entorno Integrado de Desarrollo
Netbeans. Utilizando ejemplos prácticos explicados detalladamente el lector
podrá comprender y aprender los elementos de código propios del lenguaje de
programación Java, que hacen posible el desarrollo de Aplicaciones de para PC
con Interfaces Graficas Intuitivas.
En el capítulo 6 veremos cómo trabajar con estructuras de datos de tipo Arreglo,

declaraciones, dimensiones, asignaciones, recorridos, etc. Veremos también
como utilizarlos para generar GUI dinámicamente, al crear arreglos de
componentes.
El en capítulo 7 tratamos en detalle mediante ejemplo la conceptualización

relacionada con la metodología de programación orientada a objetos como
Clase, Objeto, Instancia, Propiedades, Métodos, Herencia, Abstracción,
Polimorfismo, Sobrecarga, Constructores,
8
INDICE DE CONTENIDO
CAPITULO 1: LO QUE ESTA DETRÁS DE LA MAGIA 10

INTRODUCCIÓN AL DESARROLLO DE SOFTWARE 10
CAPITULO 2: TODO SE BASA EN USO DE LA LOGICA 29
INTRODUCCION A LA CONSTRUCCIÓN DE ALGORITMOS EN DIAGRAMA DE FLUJO Y
PSEUDOCÓDIGO. 29
CAPITULO 3: INTRODUCCION A JAVA 42
INTRODUCCION AL LENGUAJE DE PROGRAMACION JAVA Y EL USO DE ENTORNO
INTEGRADO DE DESARROLLO 42
ANLISIS Y RECONOCIMIENTO DE LA ESTRUCTURA Y PARTES DE UN PROGRAMA
ESCRITO EN JAVA 64
PUNTO DE INICIO O EJECUCION DE UN PROGRAMA. 82
OTROS CONCEPTOS MUY IMPORTANTES QUE SE DEBEN TENER CLAROS:
84
INTALACION Y CONFIGURACION DEL IDE NETBEANS 91
INTRODUCCION AL USO BASICO DEL IDE NETBEANS PARA CREAR APLICACIONES
JAVA 96
INTRODUCCION A LA ENTRADA Y SALIDA DE DATOS 101
CAPTURA DE DATOS DE ENTRADA Y DE SALIDA MEDIANTE VENTANAS DE OPCION O
DE NOTIFICACION. 116
OTROS COMPONENTES DE INTERFAZ GRAFICA DE USUARIO UTILES PARA ENTRADA
Y SALIDA DE INFORMACION 123
CAPITULO 4: WYSIWYG - LO QUE VES ES LO QUE OBTIENES 134
COMPONENTES GUI DE TIPO BOTONES DE ESTADO (JToggleButton, JCkeckBox y
JRadioButton) 134
TRABAJAR CON CUADROS DE VERIFICACIÓN: 135
TRABAJAR CON BOTONES DE RADIO 137
TRABAJAR CON BOTONONES DE PALANCA (JToggleButton) 143
LISTA Y COMBOS DE OPCIONES (JList y JComboBox) 148
TRABAJAR CON LISTAS DE OPCIONES 150
TRABAJAR CON MODELOS DE DATOS PARA LISTAS DE OPCIONES 154
TRABAJAR CON COMBOS DE OPCIONES 158
TRABAJAR CON MODELOS DE DATOS PARA COMBOS DE OPCIONES 163
ELEMENTOS DE PRECISIÓN (Deslizador, Hilador y Barra de Desplazamiento)
166
TRABAJAR CON DESLIZADORES (JSliders) 167
TRABAJAR CON HILADOR (JSpinner) 172
TRABAJAR CON BARRAS DE DESPLAZAMIENTO (JScrollBar) 176
ELEMENTOS DE MENU (JMenuBar, JMenu, JMenuItem, JMenuPopup y JSeparator )
182
9
TRABAJAR CON MENUS (JMenuBar, JMenu, JMenuItem y JMenuPopup ) 183

TRABAJAR CON MENU EMERGENTE (JMenuPopup) 192
TRABAJAR CON BARRAS DE HERRAMIENTAS (JTollBar) 196
VENTANAS Y CUADROS DE DIALOGO (JFrame, JDialog, JOptionPane, JFileChoser y
JColorChoser) 201
TRABAJAR CON VENTANAS NORMALES (JFrame) 202
TRABAJAR CON VENTANAS DE DIALOGO PARA FORMULARIOS (JDialog)
204
TRABAJAR CON VENTANAS PARA SELECCIONAR ARCHIVOS 219
TRABAJAR CON VENTANAS PARA SELECCIONAR COLOR 223
TRABAJAR CON VENTANAS DE ALERTAS Y DE OPCIONES 227
TRABAJAR CON VENTANAS DE INTERNAS (JInternalFrame) 231
PANELES O CONTENEDORES (JPanel, JTabbedPane) 250
TRABAJAR CON PANEL DE DESPLAZAMIENTO (JSCROLLPANE) 253
LIENZOS PARA ADMINISTRAR LA POSICION Y DISTRIBUCION DE LOS COMPONENTES
DENTRO DE LOS CONTENEDORES 260
TRABAJAR CON LAYOUT DE DISEÑO LIBRE 267
TRABAJAR CON LAYOUT FLUIDO (FlowLayout) 270
TRABAJAR CON LAYOUT DE REJILLA (GridLayout) 271
TRABAJAR CON LAYOUT DE BORDES (BorderLayout) 274
PROPIEDADES DE UNA CLASE (Variables Globales o Miembros) 284
COMO DISTRIBUIR Y DISEÑAR EL CODIGO PARA QUE SEA REUTILIZABLE
290
CAPITULO 5: REVELANDO LOS TRUCOS (EL CODIGO) QUE ESTAN DETRÁS DEL MAGO
(EL PROGRAMADOR) 301
DISEÑAR Y CONSTRUIR FORMULARIOS GUI DESDE CODIGO (SIN USO DEL
DISEÑADOR DE NETBEANS) 301
ESCUCHAR, MANEJAR Y CONTROLAR LOS EVENTOS DESDE EL CODIGO
319
DETECTAR Y ACTUAR SOBRE LOS EVENTOS DE ACCIÓN 322
actionPerformed 322
DETECTAR Y ACTUAR SOBRE LOS EVENTOS DEL RATON 331
TENER EN CUENTA UNOS ASPECTOS COMUNES PARA TRABAJAR CON EVENTOS /
OYENTES / MANEJADORES 339
CAPITULO 6: ESTRUCTURA DE DATOS (VECTORES) 344
ARREGLOS DE COMPONENTES 347
ARREGLOS DE COMPONENTES GUI Y SUS EVENTOS 354
CAPITULO 7: FUNDAMENTOS DE ORIENTACIÓN A OBJETOS 359
DEFINICIÓN DE OBJETOS 359
DEFINICIÓN DE CLASE 362
COMO DISEÑAR NUESTRAS PROPIAS CLASES PERSONALIZADAS 366
10
UN EJEMPLO DE LA APLICACIÓN DE LA ORIENTACIÓN A OBJETOS EN JAVA

367
CONSTRUIR LOS ELEMENTOS DEL PROYECTO EJEMPLO (LAS CLASES Y OBJETOS)
374
11
CAPITULO 1: Los trucos del Mago
INTRODUCCIÓN AL DESARROLLO DE SOFTWARE
Un programa de cómputo no es más que un conjunto de instrucciones escritas

en un lenguaje especial denominado Lenguaje de Programación, dichas
instrucciones se escriben siguiendo un orden, una secuencia y lógica especifica
denominada Algoritmo, los cuales se diseña con el fin de realizar o ejecutar un
conjunto de acciones de manera sistemática y automática.
Cuando un computador ejecuta un programa generalmente sigue la siguiente
realiza las siguientes operaciones:
1. El programa (instrucciones codificadas en lenguaje binario, previamente
escritas en un lenguaje de programación) se encuentra almacenado en
archivos ubicados en un medio o dispositivo de almacenamiento (disco o
cinta magnética, CD, chip de memoria, etc.).
2. Cuando el programa es ejecutado o utilizado por el PC o un Usuario, este
es copiado y cargado en la memoria RAM, pero el contenido original del
código del programa permanece intacto en los archivos desde donde fue
copiado.
3. El microprocesador o CPU ejecuta línea a línea cada una de las
instrucciones de programa ubicado en la memoria RAM, enviando en
cada ejecución ordenes o señales a cada una de las diferentes partes del
PC, clasificadas básicamente en tres grupo, Entrada o Captura de datos
(desde el exterior como el teclado, marón, escáner, cámara, micrófono,
etc, desde red de computo, o desde una unidad o medio de
almacenamiento), Procesamiento (cálculos, comparaciones, condiciones,
asignaciones, conversiones, ciclos o iteraciones, etc.) y Salida de datos
(hacia un dispositivo externo como la pantalla, la impresora, parlantes,
etc, hacia una red de computo o hacia un dispositivo o medio de
almacenamiento).
4. Cuando el programa finaliza su ejecución, todo su código binario
(instrucciones ejecutables, archivos de imágenes, de texto, de videos, de
sonidos, etc.) son retirados de la Memoria RAM.
5. Los pasos del 1 a 4 se repiten cada vez que el programa es ejecutado
El proceso para construir un programa básicamente sigue los siguientes pasos:
12
1. Se identifican las necesidades (requisitos o requerimientos) que debe

satisfacer el programa.
Por ejemplo:
Calcular la nota definitiva de una asignatura partiendo de 3 calificaciones

parciales obtenidas por un estudiante.
2. Se identifican y clasifican los tipos de usuarios que van a utilizar el

programa, esta clasificación se hace agrupándolos según las funciones u
operaciones que cada usuario puede utilizar en dicho programa.
Por ejemplo:
Docente (introduce las 3 notas parciales y su respectivo porcentaje),

Estudiante (Consulta sus calificaciones y su calificación definitiva)
3. Se identifican los datos que necesita el programa para realizar sus

operaciones.
Por ejemplo:
El software debe solicitar al docente que ingrese los datos de entrada, cada
dato debe ser almacenado en una variable con el fin de poder manipularlos
fácilmente.
El nombre del ESTUDIANTE, el nombre de la ASIGNATURA las 3 notas

parciales NOTA1, NOTA2 y NOTA3, y sus respectivos porcentajes
PORCENTAJE1, PORCENTAJE2, PORCENTAJE3.
Estas instrucciones se pueden expresar de la siguiente manera:
Leer ESTUDIANTE
Leer ASIGNATURA
Leer NOTA1
Leer PORCENTAJE1
Leer NOTA2
Leer PORCENTAJE2
Leer NOTA3
13
Leer PORCENTAJE3
4. Se identifican, se analizan, se comprenden, se resuelven y se expresan en

instrucciones todas las operaciones que se desean sistematizar mediante
uso del programa.
Por ejemplo:
Se calcula la calificación definitiva correspondiente a cada NOTA parcial,

para ello, cada NOTA parcial se multiplica por su respectivo PORCENTAJE y
cada resultado se almacena en una variable de forma independiente.
La anterior operación se puede expresar mediante las siguientes

instrucciones:
DEFINITIVA1 = NOTA1 * PORCENTAJE1

Luego la Calificación Definitiva se calcula sumando las notas parciales

DEFINITIVAS, así:
NOTADEFINITVA = DEFINITIVA1 + DEFINITIVA2 +

DEFINITIVA3
Si la NOTADEFINITVA es menor que 3.0, entonces el estudiante debe

repetir la asignatura, de lo contrario el estudiante ha aprobado el curso.
Si NOTADEFINITVA >= 3.0 Entonces

Mostrar " Usted ha perdido la asignatura”
SINO
Mostrar " Usted No Aprobó la asignatura”
5. Se identifican los datos que el programa genera como salida, mensajes o

respuesta en cada una de las operaciones.
Por ejemplo:
14
El software debe mostrar mensajes por pantalla con el fin de solicitar al

Docente que debe ingresar o digitar por teclado los datos de Entrada:
Las siguientes instrucciones expresan la ejecución de las anteriores

operaciones:
Mostrar “Digite El nombre del Estudiante: “

Mostrar “Digite El nombre de la Asignatura: “
Mostrar “Digite la Primera Nota Parcial: “
Mostrar “Digite el Porcentaje de la Primera Nota: “
Mostrar “Digite la Segunda Nota Parcial: “
Mostrar “Digite el Porcentaje de la Segunda Nota: “
Mostrar “Digite la Tercera Nota Parcial: “
Mostrar “Digite el Porcentaje de la Tercera Nota: “
Luego el software o programa debe mostrar ordenadamente los datos de

entrada leídos o capturados por teclado (ESTUDIANTE, ASIGNATURA,
NOTA1, NOTA2, NOTA3, PROCENTAJE1, PORCENTAJE2, PORCENTAJE3)
seguido del resultado de las operaciones o cálculos realizados con estos
datos (DEFINITIVA1, DEFINITIVA2, DEFINITIVA3 Y NOTADEFINITVA)
Las siguientes instrucciones pueden representar las anteriores operaciones:
Mostrar "Nombre: ", ESTUDIANTE

Mostrar "Materia: ", ASIGNATURA
Mostrar "Primera Nota Parcial: ", NOTA1, " * ", (PORCENTAJE1 * 100), "% =
", DEFINITIVA1
Mostrar "Segunda Nota Parcial: ", NOTA2, " * ", (PORCENTAJE2* 100), "% =
", DEFINITIVA2
Mostrar "Tercera Nota Parcial: ", NOTA3, " * ", (PORCENTAJE3 * 100), "% =
", DEFINITIVA3
Mostrar " Nota Definitiva = ", NOTADEFINITVA
15
6. Se organizan las instrucciones Entrada, Proceso y Salida analizadas

anteriormente, y se expresan en forma de algoritmo en Diagrama de Flujo
(secuencia de instrucciones sistemáticas que siguen un orden, una
secuencia y una lógica específica):
La siguiente imagen muestra un ejemplo de algoritmo en Diagrama de Flujos

diseñado para el anterior algoritmo escrito y explicado en Seudocódigo:
16
Imagen: Ejemplo de Algoritmo representado en Diagrama de Flujos
Indicar el punto de inicio del programa
Indicar uno de los posibles puntos de finalización del

programa
Indica el flujo suculencia o continuidad del programa
17
Indica la información de salida, es decir, los datos que van a salir del programa
para ser enviados al exterior del PC (generalmente un menaje o información que
se envía a un dispositivo de salida, por ejemplo una pantalla, impresora,
parlantes, dispositivo de almacenamiento, red de cómputo, etc.).
Observen la flecha con dirección de salida, es decir, estos datos se enviaran a

un dispositivo de salida, de presentación o almacenamiento de datos.
Indica la información de Entrada, es decir, el dato proveniente del exterior del PC

necesarios para que el programa pueda realizar sus operaciones, (generalmente
provienen de un dispositivo como el teclado, el ratón, un escáner, la cámara, un
dispositivo de almacenamiento o una red de computo, etc.).
Observe la flecha con dirección de entrada, es decir, el programa está esperando

que el usuario introduzca algún dato utilizando algún dispositivo de entrada, de
captura de datos o dispositivo de almacenamiento.
Indica una operación de proceso o cálculo, la cual siempre genera un valor como
resultado y puede ser asignado a una variable.
Observe la flecha con dirección hacia la variable DEFINITIVA1, es decir, el

resultado generado por la operación NOTA1 * PORCENTAJE1 es asignado o
guardado en la variable DEFINITIVA1.
Otra característica distintiva es que no posee con dirección entrante o saliente, lo

cual indica que es una instrucción de procesamiento.
18
CONDICIONAL
Indica que el programa debe ejecutar una situación condicional, en la cual se

debe comprar, calidad o verificar SI el valor almacenado en la variable
NOTADEFINITVA es MAYOR > o IGUAL = a 3.0, SI esto es VERDADERO,
ENTONCES, el programa debe ejecutar las instrucciones indicadas por la flecha
etiquetada con la letra V, SINO es VERDADERO, ENTONCES es FALSO, por lo cual
el programa debe ejecutar las instrucciones indicadas por la flecha etiquetada
con la letra F.
El algoritmo en Diagrama de Flujo es expresado posteriormente en un algoritmo

de PSEUDOCODIGO, el cual permite interpretar y representar algoritmo
utilizando instrucciones escritas en lenguaje natural y simple, por ejemplo en
idioma español, línea por línea. Al conjunto de todas estas líneas de
instrucciones codificadas en un lenguaje textual entendible fácilmente por un
Programador de Software, se le conoce como CODIGO FUENTE del programa.
A continuación veremos el algoritmo del cálculo de la nota definitiva pero esta
vez escrito en Seudocódigo del IDE PSeint.
19
Imagen: Ejemplo de Algoritmo en Seudocódigo para calcular la Calificación
Luego el programa pasa por una seria de pruebas con el fin de determinar su
correcto funcionamiento o posibles problemas o errores y así poder corregir y
volver a probar hasta que está correctamente elaborado.
20
El proceso de construcción del ALGORITMO en DIAGRAMA DE FLUJO o

ALGORITMO en PSEUDOCODIGO se puede hacer mediante herramientas
simples como papel y lápiz, o utilizando herramientas más especializadas,
avanzadas y muy útiles como por ejemplo un editor de Algoritmos, algunos
ejemplos bajo licencia de libre uso o gratuito son:
 PSeInt o PseudoInterpreter, mediante el cual he diseñado los ejemplos
presentados en este material académico, que usted como lector ha
podido apreciar, esta herramienta nos permite diseñar algoritmos
mediante Diagramas de Flujos y obtener el correspondiente
Seudocódigo, o viceversa. (Sitio Web Oficial y de descarga
http://pseint.sourceforge.net/ )
 SLE, posee un conjunto más amplio de operaciones y funciones que el

anterior, pero no posee la capacidad de generar el Diagrama de Flujo.
(Sitio Web Oficial y de Descarga http://pseint.sourceforge.net/ )
Imagen: Ejemplo de la Salida al ejecutar y probar el Algoritmo anterior en PSint
El Algoritmo es la base de todo Programa de Computo, el Seudocódigo solo se

utiliza para tratar de entender e interpretar el problema que deseamos
sistematizar, pues su estructura es muy primaria, básica y provee al programador
un conjunto muy pero muy reducido de instrucciones, herramientas y utilidades
21
para desarrollar un Software, sin embargo es supremamente necesario traducir

cada instrucción del algoritmo en Seudocódigo a instrucciones escritas en un
lenguaje de programación más avanzado, potente y robusto, de los cuales hoy
día existen un amplio número ellos, siendo los más populares Java, C + + , C#,
Visual Basic, PHP, Python, Perls, Ruby, ObjetiveC, Delphy, JavaScript, entre
otros, cada uno de ellos posee reglas de sintaxis particulares, muchísimas
utilidades que nos facilitan facilitar el desarrollo de programas sofisticado y
modernos, pero también poseen ventajas y desventajas, siendo la debilidad de
uno la fortaleza de otro y viceversa.
Un lenguaje de programación es como todo lenguaje, es decir posee sintaxis,

estrucutura y semántica que nos permite comunicarnos con otro fácilmente con
otra entidad que conoce e interpreta el mismo leguaje. Ese ente puede ser
directamente la maquina (El Harware del PC o dispositivo) o un compilador.
En el caso de la maquina, esta solo conoce e interpreta comunicación (Ordenes)
enviadas lenguaje Binario, el cual es un sistema de numeración cuyos números o
cifras solo se pueden expresas mediante combinaciones de 0 y 1, los cuales
pueden ser interpretados como OFF o 0 (apagado, verdadero, señal eléctrica
baja) y ON o 1 (encendido, verdadero, señal eléctrica alta).
Por el contrario un un compilador, es una especie de traductor entre el
programador y la maquina, ya que para el programador es extremadamente
tedidoso y complicado hablar en lenguaje binario, por tal motivo los
programadores utilizan un lenguaje mas comodo y parecido al lenguaje de
comunicación que habla de forma natural, a este leguaje se le conoce como
Lenguaje de Programación de Alto Nivel, el cual es desconocido por la Maquina,
es aquí donde actua el compilador quien interpreta las ordenes del programador
emitidas o escritas en un lenguaje de Programacion de Alto Nivel y las traduce a
lenguaje de Maquina (lenguaje de bajo nivel) también conocido como lenguaje
binario.
La mayoría de los programas de computo se contruyen escribiendo sus
instrucciones en lenguajes de alto nivel, las cuales se almacenan en archivos
llamados Archivos de Código Fuente. Estos archivos son la fuente de
información utilizada por los Compiladores para generar el código Binario
almacenado en otros archivos llamados común ente Librerias o Ejercutables,
estos a su vez son utilizados por ¡la Maquina para ejecutar la instrucciones de
que realiza el programa final.
A continuación podemos observar el algoritmo tratado anteriormente pero esta
vez escrito en código fuente del lenguaje de programación Java:
22
23
24
25
Imagen: Ejemplo del Algoritmo del cálculo de la Nota Definitiva escrito en Java
En el capítulo dedicado al aprendizaje del Lenguaje de Programación Java, se

encuentra la explicación detallada línea a línea sobre el código fuente de este
programa ejemplo, pero el momento esta sería la apariencia del programa en
ejecución.
26
Lo primero que notamos es una Interfaz de Usuario (ventana, campos de texto,

etiquetas de texto, botones de acción, menús, listas, iconos, colores, etc.) mucho
más sofisticada y bonita que el programa escrito en Pseudocódigo.
Aunque también podemos notar que el código fuente del programa escrito en
Java es notablemente más extenso y se encuentra en idioma Ingles, pero son
detalles casi insignificantes comparados con la infinidad de opciones avanzadas,
sofisticadas y agradables apariencias que podemos diseñar para nuestros
programas.
Imagen: Ejecución y prueba del programa del Cálculo de la nota Definitiva escrito en java
Un programa se construye por partes, pues generalmente un programa de

computo ejecuta un conjunto finito de operaciones (módulos), cada operación
cumple uno o varios objetivos pequeños que hacen parte de un macro objetivo.
27
Cada módulo que se va construyendo se debe ir probando, esto con el fin de ir

midiendo y evaluando el programa de forma progresiva y no en forma general.
Para probar cada parte del programa es necesario someter al código fuente a un
proceso de depuración en busca y corrección de errores, este proceso se llama
compilación, el cual es realizado de forma automática por otro programa
especializado llamado compilador.
Un compilador tiene como objetivo verificar cada línea o instrucción del código
fuente del programa, buscando posibles errores de sintaxis (violación de las
reglas) de escritura del lenguaje de programación, si al menos un error es
encontrado, el compilador detiene el proceso y muestra información útil sobre las
posibles causas del error, lugar o línea del código fuente donde fue detectado y
algunos muestran posibles soluciones.
Si por el contrario todo el código fuente se encuentra escrito con 0 errores, el
compilador genera las mismas instrucciones pero traducidas a lenguaje binario
(lenguaje maquina), el cual si es entendido y conocido por el procesador.
Algunos lenguajes de programación generan el código binario en tiempo de
ejecución, es decir, el programa se ejecuta utilizando el código fuente, el cual es
convertido (interpretado) a código binario línea por línea, a medida que el
procesador va solicitando y ejecutando las instrucciones que lo conforman.
Existen lenguajes que necesitan compilación de su código fuente por ejemplo
Java, C + + , VB, Delphy, C#, ObjetiveC.
Existen otros lenguajes de programación que cuyo código fuente no requieren
ser compilado (no generan archivos de código binario), sino que su código fuente
es interpretado y traducido a código binario al mismo tiempo que es ejecutado
por el procesador, ejemplo de ellos son: JavaScript, PHP, HTML, CSS, VBScript,
Bash, Shell, etc.
Ejercicio Práctico:
Sigue los siguientes pasos para aprender compilar y ejecutar de forma tradicional
(sin herramientas avanzadas) un programa escrito en el lenguaje de
programación Java:
1. Descargar e instalar el JSDK (Java Developer Kit o Caja de Herramientas
Java para Desarrollar Software)
http://www.oracle.com/technetwork/java/javase/downloads/index.html
2. Ir al menú inicio y dar clic derecho sobre el icono Equipo (en Win7) o Mi
PC (en WinXP), seleccionar y dar clic en la opción Propiedades.
3. Se presenta la siguiente ventana
28
Dar clic en la opción de la Izquierda Configuración Avanzada del

Sistema
Dar clic en la opción (pestaña) Opciones Avanzadas en la parte superior

y luego dar clic en la el botón Variables de Entorno
29
En la parte inferior Variables del Sistema buscar y seleccionar una

variable llamada PATH, dar clic en el botón Editar o doble clic sobre la
variable.
Ir al campo de texto Valor de la Variable: colocar; (punto y coma) y

escribir o copiar y pegar la ruta de instalación del JSDK C:\Program
30
Files\Java\jdk1.7.0_10\bin; y luego dar clic en los botones

Aceptar de las tres ventanas que abrimos.
7. Crear una carpeta por ejemplo dentro de mis documentos, colocarle

nombre por ejemplo programas, luego crear 3 archivos de texto, uno
llamado CalculoNotaDefinitiva.java, otro llamado compilar.bat y el
ultimo llamado ejecutar.bat, todos dentro de la carpeta programas,
prestar especial atención al nombre del primer archivo, debe ser escrito
exactamente igual como aparece aquí, es decir con las letras Mayúsculas
y minúsculas correspondientes.
En el archivo CalculoNotaDefinitiva.java se debe escribir y guardar el

código fuente Java del programa ejemplo anterior, para evitar errores de
sintaxis en la compilación del programa, es estrictamente necesario
escribir el código fuente Java exactamente igual a como aparece en el
ejemplo. En el archivo compilar.bat dar clic derecho sobre su icono y
seleccionar la opción editar, luego escribir y guardar la siguiente
instrucción:
javac CalculoNotaDefinitiva.java
pause;
Igualmente se debe hacer con el archivo ejecutar.bat, pero en su interior

se debe escribir la siguiente instrucción:
java CalculoNotaDefinitiva
pause;
8. El siguiente paso ejecutar el proceso de Compilación, para ello se deben

guardar todos los cambios hechos en estos tres archivos, luego dar doble
31
clic en el archivo compilar.bat, seguidamente aparecerá una ventana de

fondo negro como la siguiente:
Si todo aparece tal cual, quiere decir que el código fuente Java del
programa en el archivo CalculoNotaDefinitiva.java ha sido escrito y
compilado correctamente, de lo contrario aparecerán en mensajes sobre
los posibles errores en el código fuente.
Si no hay problemas, el proceso de compilación generaría uno o varios
archivos con extensión .class, tal como aparece en la siguiente imagen:
Los archivos compilados .class, poseen el código binario que será

interpretado y ejecutado por el Microprocesador, mientras que los
archivos .java contienen solo el código fuente del programa, este código
Java solo es comprendido por el Hombre (programador) y no por el
Computador, por eso es que pasa por un proceso de compilación para
ser traducido a lenguaje binario, el cual es el idioma entendido por el
computador.
Por último ejecutamos el programa dando doble clic en el archivo ejecutar.bat,

de esta manera podremos probar y usar el programa escrito como ejemplo de
este capítulo.
32
CAPITULO 2: TODO SE BASA EN USO DE LA LÓGICA
INTRODUCCIÓN A LA CONSTRUCCIÓN DE ALGORITMOS EN DIAGRAMA DE FLUJO Y

PSEUDOCÓDIGO.
En algoritmo Pseudocódigo existen otras instrucciones muy útiles a la hora de

construir un programa, estas instrucciones son1:
CONDICIONAL SI-ENTONCES
La secuencia de instrucciones ejecutadas por la instrucción Si-Entonces-Sino

depende del valor de una condición lógica.
Si <condición>
Entonces
<instrucciones>
Sino
<instrucciones>
FinSi
Al ejecutarse esta instrucción, se evalúa la condición y se ejecutan las

instrucciones que correspondan: las instrucciones que le siguen al Entonces si la
condición es verdadera, o las instrucciones que le siguen al Sino si la condición
es falsa. La condición debe ser una expresión lógica, que al ser evaluada
retorna Verdadero o Falso. La cláusula Entonces debe aparecer siempre, pero
1 Las siguientes definiciones sobre SI (Condicionales) Según (Selección Multiple), Ciclo Mientras, Ciclo
Repetir y Ciclo Para fueron tomadas textualmente de la documentación suministrada en el manual de
Usuario del Software PSeInt licenciado a la fecha de 17-01-2013 como Software Libre GPL v.3,
http://pseint.sourceforge.net/index.php?page=pseudocodigo.php
33
la cláusula Sino puede no estar. En ese caso, si la condición es falsa no se

ejecuta ninguna instrucción y la ejecución del programa continúa con la
instrucción siguiente.
Ejemplo:
Diseñar un algoritmo que dado un Numero, indique si este es PAR o IMPAR
Imagen: Ejemplo del uso de Condicional en Seudocódigo
Imagen: Ejemplo del uso de Condicional en Diagrama de Flujos
34
Ejemplo:
Diseñar un algoritmo que permita traducir los nombres de los días en español en
minúscula a ingles en mayúscula.
Imagen: Ejemplo del uso de Condicional Anidados en Seudocódigo
Observemos el ejemplo anterior, en el podemos notar las siguientes partes o

instrucciones:
 Líneas 1 y 28: INICIO y FIN del algoritmo, todas las instrucciones en su
interior forman la lógica propia del algoritmo.
 Líneas 2 a 5: Instrucciones de SALIDA por pantalla, en las cuales se

muestran una serie de mensajes al usuario.
Línea 6: Instrucción de ENTRADA o Captura de Datos por teclado, cuyo valor

será almacenado o asignado al variable día.
35
Línea 7 a 9 y 9 a 27: Instrucción CONDICIONAL
SI/SINO, la cual verifica SI es VERDADERO que la
variable día es igual a Lunes, en caso positivo muestra
un mensaje, en caso Negativo o FALSE, entonces,
vuelve a preguntar mediante un CONDICIONAL
ANIDADO dentro del SINO anterior SI es
VERDADERO que la variable día es igual a Martes, SI
es VERDADERO muestra un mensaje, pero SINO
ósea es FALSO, entonces vuelva a preguntar el valor
de la variable día mediante otro SI/SINO ANIDADO, y
así sucesivamente cuando haya terminado de verificar
todos los SI/SINO.
Imagen; Ejemplo de Diagrama de Flujo del Algorimto para Traducir los días de la semana a ingles
36
Del ejercicio anterior analicemos un poco el Diagrama de Flujo y su respectivo

Seudocódigo:
Esta imagen del Diagrama de flujo corresponde a las siguientes líneas de

instrucciones en Seudocódigo.
Línea 1: equivale al nombre e Inicio del algoritmo o proceso.

Línea 2: Instrucción de salida, en pseudocódigo las instrucciones MOSTRAR,
ESCRIBIR e IMPRIMIR son equivalentes, iguales o sinónimos, es decir
significan y realizan la misma operación, se utilizan para enviar mensajes al
dispositivo de salida estándar conectado al PC, en general dicho dispositivo es el
Monitor o Pantalla, los cuales son visualizados por el usuario.
37
Línea 3: Es igual a la línea 2, la diferencia es que el mensaje que se envía es

una secuencia de o cadena del carácter – (guion), el objetivo es simular una
línea horizontal.
Línea 4: Muestra una línea en blanco con el fin de simular un espacio en blanco
entre el mensaje de la línea 3 y la línea 5.
Línea 5: Muestra un mensaje al usuario solicitando que ingrese un día de la

semana en español minúscula, este mensaje hará que el usuario este tentado a
digitar por teclado el nombre de un día de la semana.
Línea 6: Instrucción de Entrada, en Pseudocódigo las instrucciones LEER,
CAPTURAR y DIGITAR son equivalentes, similares o sinónimos, es decir
significan y realizan la misma operación, se utilizan para recuperar, o capturar
información suministrada desde el dispositivo de entrada estándar conectado al
PC, el cual generalmente es el teclado. La palabra día es el nombre de una
variable utilizada en el programa para guardar el nombre del día de la semana
ingresado por el usuario.
38
Línea 7: Instrucción Condicional SI–SINO–FINSI, la Instrucción SI de

Pseudocódigo (representada por un Rombo en Diagrama de Flujo) se utiliza para
verificar valores Positivos (VERDADERO) o Negativos (FALSO), si el resultado
de la validación o verificación retorna un valor VERDADERO, entonces el
programa se irá por el flujo de la flecha etiquetada con la letra V, SI es FALSO,
entonces se ira por el flujo de la flecha etiquetada con la letra F. En este ejemplo
la instrucción de la línea 7 verifica la variable día tiene como valor igual a al texto
lunes, si esto es Verdadero (el usuario ingreso lunes), entonces el programa
ejecutara la instrucción en la línea 8 hasta la línea 9, que como ya sabemos es
una instrucción de salida y luego el flujo salta hasta la el FINSI y
FINPROCESO cuya instrucción está en la líneas 19 y 20 línea del algoritmo, es
decir no ejecuta las líneas 9,10, 11, 12, 13, 14, 15, 16, 17 y 18.
Línea 9: Continuación de la instrucción SI–SINO-FINSI, si por el contrario, en la

línea 7 el algoritmo verifica que el valor de la variable día es diferente al texto
lunes, es decir es FALSO (el usuario puedo ingresar martes o miércoles u otra
cosa), entonces el programa ejecuta el flujo de instrucciones indicados en la
flecha etiquetada con la letra F hasta la línea 20
Líneas, 10, 12 y 18: es una instrucción SI–SINO-FINSI anidada (incluida) dentro

de otra instrucción SINO, es decir, si el día ingresado no es el lunes, entonces,
SINO SI el día ingresado es igual a martes, (VERDADERO), entonces se
ejecuta la instrucción en la línea 11 y salta hasta las líneas 18, 19 y 20, es
decir sin ejecutar las instrucciones en las líneas 12, 13, 14, 15, 16 y 17.
39
Líneas 13, 14, 15, 16 y 17: Es similar a lo explicado en las líneas 10, 12, y 18, es
decir, es otra instrucción condicional SI-SINO-FINSI anidada dentro de un SINO,
es decir, SI el día ingresado no es el martes (el SI de la línea 10 es FALSO),
entonces en la línea 13 se verifica si posiblemente ingreso el miércoles, si es
VERDADERO se muestra el mensaje de la línea 14 saltando a las líneas 17, 18,
19 y 20 finalizando el algoritmo. SINO (FALSO) línea 15, es porque el día
ingresado no es lunes, ni martes, ni miércoles, entonces se muestra un
mensaje en la línea 16, finalizando con las líneas 17, 18, 19 7 20.
Al ejecutar y probar el Algoritmo en la herramienta PSint podemos observar las

siguientes salidas por ejemplo:
En caso de que digitemos el día Martes
En caso de que digitemos el día Lunes
40
En caso de que digitemos el día Miércoles
Como ejercicio, toma el simple reto de terminar el algoritmo con los días de la
semana que faltan, jueves, viernes, sábado y Domingo.
SELECCIÓN MULTIPLE O BIFURCACIONES
Esta estructura de control muy utilizada en programación se reconoce con varios

nombre, entre los que se encuentran, Lazos múltiples, Selector de Casos o
Bifurcaciones, es una secuencia de instrucciones ejecutada por una
instrucción que escoge un posible camino según y dependiendo del valor de una
variable numérica.
Según <variable> Hacer

<número1>: <instrucciones>
<número2>,<número3>: <instrucciones>
<...>
De Otro Modo: <instrucciones>
FinSegun
Esta instrucción permite ejecutar opcionalmente varias acciones posibles,

dependiendo del valor almacenado en una variable de tipo numérico. Al
ejecutarse, se evalúa el contenido de la variable y se ejecuta la secuencia de
instrucciones asociada con dicho valor.
Cada opción está formada por uno o más números separados por comas, dos
puntos y una secuencia de instrucciones. Si una opción incluye varios números,
41
la secuencia de instrucciones asociada se debe ejecutar cuando el valor de la

variable es uno de esos números.
Opcionalmente, se puede agregar una opción final, denominada De Otro Modo,

cuya secuencia de instrucciones asociada se ejecutará sólo si el valor
almacenado en la variable no coincide con ninguna de las opciones anteriores.
CICLOS O ITEREACIONES MIENTRAS QUE
Esta estructura de control de programación pertenece a la familia de los ciclos o

iteraciones, la cual ejecuta una secuencia de instrucciones y las repite ciclo a
ciclo cada vez que la expresión lógica sea evaluada como Verdadera, de allí su
nombre, Mientras Que expresión Lógica sea Verdadera haga las siguientes
instrucciones.
Mientras <condición> Hacer

<instrucciones>
FinMientras
Primero se evalúa la condición, si esta es verdadera, entonces se ejecutan las

instrucciones dentro ubicadas entre el HACER Y EL FINMIENTRAS, al finalizar
la ejecución de dichas instrucciones, el flujo de ejecución del programa vuelve a
evaluar nuevamente la Condición y el ciclo de ejecución de las instrucciones se
volverá a repetir una vez más, así continuaría hasta que la Condición sea
evaluada como FALSE.
Note que las instrucciones del cuerpo del ciclo pueden no ejecutarse nunca, si al
evaluar por primera vez la Condición esta resulta ser FALSA.
42
Si la condición siempre es VERDADERA, el proceso de ejecución de las

instrucciones dentro del Mientas se ejecutara indefinidamente, provocando lo
que se conoce como un Ciclo Infinito, causando muy posiblemente lentitud en
el PC o en el peor y muy común de los casos puede Bloquearlo hasta lograr que
se reinicie. Para evitar esta situación, las instrucciones del cuerpo del ciclo deben
contener alguna instrucción que modifique la o las variables involucradas en la
Condición, de modo que ésta sea falsificada (Evaluada como FALSA) en algún
momento y así finalice la ejecución del ciclo.
CICLO O ITERACIONES REPETIR HASTA QUE
Esta estructura de control cíclica es homologa a la vista anteriormente (el

Mientras Que), con la diferencia que funciona de forma contraria, es decir, en
vez de evaluar primero la Condición para poder iniciar con la ejecución de las
instrucciones en su interior, primero se ejecutan al menos la primera vez el
conjunto de instrucciones y al finalizar estas se procede con la evaluación de la
Condición, Si la evaluación da como resultado VERDADERO entonces no de
vuelven a ejecutar las instrucción, de lo contrario, si la Condición es FALSA,
entonces, se vuelve a ejecutar las instrucciones nuevamente, al finalizar vuelve a
repetir la Evaluación de la Condición, si es VERDADERA finaliza el ciclo y si es
FALSA vuelve a iniciar un nuevo ciclo de ejecuciones.
Repetir
<instrucciones>
Hasta Que <condición>
43
Al ejecutarse esta instrucción, la secuencia de instrucciones que forma el cuerpo

del ciclo se ejecuta una vez y luego se evalúa la condición. Si la condición es
falsa, el cuerpo del ciclo se ejecuta nuevamente y se vuelve a evaluar la
condición. Esto se repite hasta que la condición sea verdadera.
Note que, dado que la condición se evalúa al final, las instrucciones del cuerpo
del ciclo serán ejecutadas al menos una vez.
Además, a fin de evitar ciclos infinitos, el cuerpo del ciclo debe contener alguna
instrucción que modifique la o las variables involucradas en la condición de
modo que en algún momento la condición sea verdadera y se finalice la
ejecución del ciclo. Si analizamos su comportamiento con un poco más de
profundidad, podemos observar que REPETIR HASTA QUE y MIESTRAS QUE
se utilizan cuando no tenemos certeza alguna de cuantos ciclos se pueden
ejecutar, esto debido a que el Condicional está sujeto que pueda o no ser
evaluada como FALSO o VERDADERO y puede darse el caso que se ejecuten
muchos ciclos antes de que el condicional pueda ser Evaluado como FALSO
(Para el caso del MIESTRAS QUE) o VERDADERO (para el caso del REPETIR
HASTA QUE).
CICLOS PARA HASTA
Esta estructura de control cíclica a diferencia del MIENTRAS QUE y REPETIR

HASTA QUE siempre debe saber cuántos ciclos o iteraciones máximos debe
poder realizar, esto gracias a que requiere de una Condición que evalúa si un
contador (que incrementa o decremento según sea el caso) sea igual o Mayor
(en caso de Incremento) o Menor o Igual (en caso de Decremento) con el fin de
44
suspender las iteraciones o ciclos. De esta manera la instrucción PARA

HASTA ejecuta una secuencia de instrucciones un número determinado de
veces.
Para <variable> <- <inicial> Hasta <final> (Con Paso <paso> ) Hacer
<instrucciones>
FinPara
Al ingresar al bloque, la variable <variable> recibe el valor <inicial> y se ejecuta

la secuencia de instrucciones que forma el cuerpo del ciclo. Luego se incrementa
la variable <variable> en <paso> unidades y se evalúa si el valor almacenado en
<variable> superó al valor <final>. Si esto es falso se repite hasta que <variable>
supere a <final>. Si se omite la cláusula Con Paso <paso>, la variable <variable>
se incrementará en 1.
Ejercicio práctico.
Teniendo en cuenta las anteriores definiciones y utilizando el Software PSeInt

Editor de Algoritmos en Pseudocódigo y Diagrama de Flujo, agregar las
siguientes funcionalidades al ejemplo del Cálculo de la Nota Definitiva:
 El software debe mostrar un menú principal indicando las siguientes
opciones:

1. Calcular Una Nota Definitiva
2. Consultar la Última Nota Definitiva Calculada
3. Salir
Digite el número de una opción para continuar:

 Cuando el docente escoja la opción 1, el sistema debe ejecutar el
algoritmo tal y como se explicó en este capítulo, pero al terminar le debe
preguntar:
1. Volver a Calcular otra Nota Definitiva

2. Volver al Menú Principal
3. Salir
Digite el número de una opción para continuar:

 Cuando el Docente escoja la opción 1 del menú anterior, el sistema debe
volver a repetir las instrucciones para calcular otra nota definitiva
45
 Cuando el docente escoja la opción 2, el sistema debe mostrarle el

menú principal
 Cuando el Docente escoja la opción 3, el sistema simplemente finalizara
su ejecución.
 Cuando el Estudiante escoja la opción 2 del menú principal, el sistema
mostrara los datos del nombre del estudiante, asignatura, notas
parciales y nota definitiva del último estudiante al cual se le calculo la
nota definitiva.
 Cuando alguien escoja la opción 3 del menú principal, el sistema
simplemente finalizara su ejecución.
46
CAPITULO 3: INTRODUCCIÓN A JAVA
INTRODUCCIÓN AL LENGUAJE DE PROGRAMACIÓN JAVA Y EL USO DE ENTORNO

INTEGRADO DE DESARROLLO
En este capítulo aprenderemos a preparar un entorno de programación de Java

muy básico, también aprenderemos a reconocer cada una de los procesos de
compilación, ejecución y empaquetado de un programa escrito en este fabuloso
lenguaje de programación.
Herramientas:
Un entono de trabajo básico para desarrollar Aplicaciones Java requiere que
tengamos disponibles las siguientes herramientas:
 PC con buenas condiciones de Hardware y Sistema Operativo
(GNU/Linux cualquier distribución o Microsoft Windows XP, 7, 8 en
adelante o Apple Macintosh), en este capítulo utilizamos Windows.
 JSDK o Java Software Developer Kit (Herramientas de Desarrollo de
Software Java) versión 1.6.x en adelante.
 Un Entorno Integrado de Desarrollo o IDE por sus siglas, el cual permita
editar el código fuente, compilar, depurar y ejecutar las aplicaciones que
estemos desarrollando, en este capítulo veremos cómo crear un IDE
básico usando el Block de Notas, el JSDK y archivos de comandos por
lotes.
DESCARGAR E INSTALAR EL JSDK JAVA SOFTWARE DEVELOPER KIT:
JSDK significa en español, Kit de desarrollo de software Java, esta utilidad es

fundamental para poder construir software mediante el lenguaje de programación
Java. Su instalación en sistemas operativos Microsoft Windows es muy intuitiva,
rápida y simple, solo basta con descargar el instalador desde el sitio Web de
descarga Oficial de Oracle
http://www.oracle.com/technetwork/es/java/javase/downloads/index.html,
ejecutarlo una vez termine la descarga y precederemos a seguir los pasos que
indica el asistente (Wizard) de instalación. A continuación se presenta la
secuencia de pasos necesarios para una correcta instalación del JSDK.
47
Nos aparece una página en la cual debemos dar clic en la opción señalada en la
imagen anterior, luego nos aparece otra página web en la que debemos aceptar
los términos de la licencia, tal como indica en la siguiente imagen:
Al aceptar los términos de la licencia de Oracle, procedemos a seleccionar la

versión del JDK adecuada para nuestro sistema operativos Windows, en el
desarrollo de esta sección se utilizó un S.O Windows 7 de 64 bit
Para saber cuál versión del sistema operativo tenemos instalada en nuestro PC
podemos dar clic derecho en el icono Equipo que está en el Menú Inicio y
escoger la opción Propiedades, como se aprecia en la siguiente imagen:
48
Una vez descargado el JSDK procedemos a instalarlos en nuestro PC, el JSDK

nos permite utilizar un abundante conjunto de herramientas y utilidades que
agilizan el desarrollo de nuestros programas, algunas de estas herramientas son:
Java.exe: Programa que interpreta el código compilado (archivos.class) de
nuestros programas y los hace ejecutables dentro del PC.
Javac.exe: Programa que interpreta línea por línea el código fuente
(archivos.java) de nuestro programa y lo convierte en código compilado
(archivos.java).
Jar.exe: programa que empaqueta en un único archivo ejecutable (archivo.jar)
los archivos de nuestro programa.
Javaw.exe: Programa similar a java.exe pero que en este caso es utilizado para
ejecutar programas que utilizan ventanas (Windows en inglés, por eso la w)
Paso 1: Inicio de asistente de instalación del JSDK
49
Paso 2: Seleccionar los componentes de Instalación, es recomendable dejarlo

tal y como aparece por defecto, es decir, seleccionar todos los componentes, se
puede ver que en el inferior de esa ventana se muestra la ruta de instalación por
defecto del JDK, el cual instala también el JRE, o Java Runtime Environment que
significa Entorno de Ejecución Java, también conocidos como JVM o Java Virtual
Machine que significa Máquina Virtual Java. La ruta de instalación se puede
cambiar por otra una ruta preferida, para ellos solo se debe seleccionar en el
botón Change… y escoger la ruta deseada.
Paso 3: El proceso de instalación comienza a descomprimir los archivos

necesarios en el disco duro del PC
Paso 4: El asistente muestra la ruta de instalación por defecto de la Máquina

Virtual Java o JRE o JVM, esta ruta de instalación se puede cambiar por otra una
50
ruta preferida, para ellos solo se debe seleccionar en el botón Change… y

escoger la ruta deseada.
Paso 5: Terminada la Instalación de JSDK y la JVM, el asistente de instalación

solicita el registro en su sistema de usuarios de Java, operación que se puede
rechazar o aceptar según se crea conveniente.
CONFIGURAR LAS VARIABLES DE ENTORNO
Configurar las variables de entorno del SO para poder ejecutar y compilar

programas java, java utiliza al menos 3 variables de entorno, una propia del SO
llamada PATH, la cual es utilizada para almacenar las rutas de disco completa
(absoluta) donde se encuentran almacenados los programas a los que se desea
tener acceso desde la línea de comando o DOS, para el caso de java estos
programas se encuentran en la carpeta BIN, ubicada en la carpeta donde se
instaló el JSDK, las otras dos variables son propias de Java, una llamada
JAVA_HOME y la otra CLASSPATH, en JAVA_HOME se debe almacenar la ruta de
disco absoluta de la carpeta donde se instaló el JSDK, mientras que la variable
CLASSPATH es utilizada para almacenar la ruta de disco absoluta donde se
encuentran los archivos de código compilado (código obtenido al depurar el
código fuente), que para el caso de java estos archivos pueden terminar en
extensión .class o .jar, este último es solo un repositorio o contenedor de varios
archivos .class y otros archivos necesarios por el programa en construcción.
La configuraciones de estas variables se puede hacer por línea de comandos ya
se digitando directamente las instrucciones necesarias por consola (pantalla
51
DOS) o bien, almacenándolas en un archivo con extensión .bat (archivo con

instrucciones ejecutables por consola).
En Windows desde Windows 2000 en adelante no hay necesidad de realizar el

proceso de la variable JAVA_HOME, ya que el mismo JSDK lo realiza al
momento de su instalación, por el contrario si se debe realizar el proceso de
configuración de las variables PATH y CLASSPATH según nuestras
conveniencias, esto se puede realizar de la forma anterior o bien de forma
imagen, como explico a continuación:
Ir a las propiedades del EQUIPO, dando clic derecho en el icono Equipo del
menú inicio y escoger la opción Propiedades, luego escoger la opción
Configuración Avanzada del Sistema, tal como aparece en las siguientes
imágenes consecutivas:
Nos aparece la siguiente ventana de configuración avanzada del sistema
52
Seleccionamos la pestaña Opciones Avanzadas y luego pulsamos el botón

Variables de Entrono.
En la lista de Variables del Sistema debemos buscar la variable PATH, luego

pulsamos el botón Editar.
En la ventana que aparece debemos colocar ;(punto y coma) y la ruta de la

carpeta bin del JSDK y luego otro: (punto y coma) y aceptamos.
53
La ruta del JDK por defecto se instala en la ruta C:\archivos de

programas\java\jdk1.7.x\bin, tal como se aprecia en la siguiente
imagen:
Y hora procedemos a crear la variable CLASSPATH, haciendo clic en el botón

Nuevo de la lista de Variables de Entorno del Usuario
54
En la ventana que aparece debemos escribir el nombre de la variable de entorno

y en su valor la ruta donde se encuentran las librerías o clases o directorio de
trabajo de nuestro proyecto java.
Aceptamos todas las ventanas anteriores y listas.

Para realizar una prueba y verificar si el proceso anterior se efectuó
satisfactoriamente, debemos abrir una ventana de líneas de comandos, haciendo
clic en el Menú Inicio, luego en la opción Ejecutar, luego escribir cmd, como se
puede apreciar en la siguiente imagen.
Luego en la ventana del D.O.S que nos aparece podemos invocar el programa
javac.exe
55
Si hasta el momento todo está bien, podemos dar enter y veremos la ayuda del
programa Javac.exe, tal como se parecía en la siguiente imagen, esta ayuda
nos proporciona información de cómo utilizar este programa y sus opciones para
poder compilar el código fuente de nuestros programas y convertirlo en código
binario (bytecode)
Si existe algún problema con los pasos hechos anteriormente, deberíamos ver
algo así:
Para solucionarlo, debemos seguir los pasos descritos estrictamente en ese

orden, luego volvemos a probar.
56
PREPARAR LA CARPETA DE TRABAJO

Ahora procedemos a crear una carpeta de trabajo, por ejemplo en C: en el
desarrollo de esta sección se creó una carpeta llamada guias_java.
Luego repetimos los pasos que realizamos para configurar la variable PATH,
pero en este caso crearemos una nueva variable llamada CLASSPATH y le
colocamos como valor la ruta de nuestra carpeta de trabajo, esto se puede
apreciar en la siguientes tres imágenes consecutivas:
57
Pausando click en el botón Nueva…
En el campo Nombre de la variable colocamos CLASSPATH

En el campo Valor de la variable colocamos la ruta donde creamos nuestra
carpeta de trabajo. Recordemos que en esta carpeta es donde colocaremos los
archivos de nuestra aplicación.
ESCRIBIR LOS ARCHIVOS DE CÓDIGO FUENTE

El proceso que sigue a continuación es utilizar el block de notas para editar o
escribir el código fuente de nuestra aplicación, para ellos, abrimos una ventana
del block de notas ingresando el comando notepad.exe en el menú inicio, tal
como se aprecia en las siguientes imágenes consecutivas:
Ejecutar el Block de Notas desde el menú Inicio o digitando el comando

NotePad
58
En este editor escribimos el código fuente y lo guardamos dentro de la carpeta

de trabajo guias_java en un archivo con extensión .java.
En la siguiente imagen veremos un ejemplo del código necesario para crear una
ventana que muestre la hora del PC justo en el momento en que se haga visible
dicha ventana. No es el momento de detenernos en comprender el código fuente
java de este ejemplo (aunque si lo deseas estaría bien hacerlo), pues de este
aspecto nos vamos a dedicar ampliamente en el siguiente capítulo, por ahora lo
importante es que comprendan el proceso de escritura, edición, compilación,
ejecución y empaquetado del código fuente y generación de código binario de un
programa escrito en el lenguaje de programación Java.
Imagen: Código fuente de la aplicación ejemplo para mostrar una ventana
59
El archivo de código fuente lo debemos guardar dentro de la carpeta de trabajo

(guias_java) en un archivo cuyo nombre debe ser exactamente igual que el
nombre de la clase (algoritmo), en este caso la clase y el archivo se llaman
VentanaHora.java, luego de este proceso aparecerá un archivo con este
nombre dentro de nuestra carpeta de trabajo.
CREAR UN ARCHIVO PARA COMPILAR EL CÓDIGO FUENTE

Ahora procedemos a crear el archivo que utilizaremos para invocar el comando
javac.exe, el cual como ya se explicó en el pasado, es el responsable de
convertir nuestro código fuente en código binario.
60
Para crear el archivo de compilación procedemos a abrir una ventana del block
de notas y escribir el comando javacVentanaHora.java, es decir, invocamos el
programa javac.exe y seguidamente le pasamos el nombre del archivo de
código fuente que deseamos compile, el comando pause se utiliza en D.O.S
para pedirle al usuario que oprima una tecla e impedir que el programa se cierre
una vez termine su ejecución, esto es importante porque de lo contrario no
podremos observar los mensajes de error si los hubiese.
El archivo se debe guardar con la extensión .bat dentro de la carpeta
guias_Java, por ejemplo Compilar.bat.
Ahora tendremos dos archivos dentro de la carpeta java, el archivo de código
fuente VentanaHora.java y el archivo compilar.bat como se aprecia en la
siguiente imagen:
61
COMPILAR EL CODIGO FUENTE:

El proceso de compilación consiste básicamente en utilizar un software
especializado llamado compilador (el compilador de java se llama javac.exe)
para verificar cada línea del código fuente, el objetivo es comprobar si el código
fuente escrito cumple con las reglas de sintaxis exigidas por el lenguaje de
programación (en este caso es el lenguaje Java), si el compilador no encuentra
problemas en el código fuente del programa, entonces traduce cada instrucción
de código fuente en instrucciones de código binario (en el caso de java el código
binario se llama bytecode) y el resultado es almacenado en archivos especiales
(en java estos archivos terminan en extensión .class).
Si por el contrario, el compilador encuentra el mínimo error o falla de sintaxis
dentro del archivo de código fuente .java, entonces detiene el proceso de
compilación, no genera los archivos de código binario y genera un reporte de los
errores encontrados y una breve descripción de los mismos.
Para iniciar el proceso de compilación de nuestro archivo VentanaHora.java
procedemos a dar doble clic en el archivo compilar.bat, entonces se abre una
ventana del D.O.S indicando que se ha ejecutado el programa javac.exe sobre el
archivo VentanaHora.java, si todo está bien, se muestra una ventana con un
mensaje similar al siguiente:
Lo cual quiere decir que dentro de la carpeta de trabajo guias_java se ha

generado al menos un archivo compilado llamado VentanaHora.class, el cual
contiene el código binario o bytecode del proceso de compilación positivo del
archivo de código fuente llamado VentanaHora.java, como se aprecia en la
siguiente imagen:
62
La siguiente imagen muestra un ejemplo del mensaje de error en caso de que el

compilador hubiese encontrado un error en el código fuente, para el ejemplo he
modificado el código fuente a propósito, he cambiado el nombre de la clase
quitando la letra V mayúscula por v minúscula y en el método Constructor de la
clase, pero el nombre del archivo de código fuente sigue escrito con V
mayúscula, esto genera un error de sintaxis el cual veremos con más detalle en
los próximos capítulos.
Imagen: Ejemplo de mensajes de error emitidos por el compilador Javac.exe al

encontrar un error en el código fuente que se está depurando para ser compilado
CREAR UN ARCHIVO PARA EJECUTAR EL CÓDIGO COMPILADO O

BINARIO
Una vez tengamos nuestro código fuente escrito y guardado en un archivo .java
y un archivo para compilar el código fuente, todo dentro de nuestra carpeta de
trabajo guias_java, procedemos a crear un archivo que en su interior invoque al
programa java.exe pasándole como parámetro en nombre del archivo de código
compilado VentanaHora.class, tal como se muestra en la siguiente imagen:
63
Este archivo debe guardarse con un nombre (por ejemplo ejecutar.bat) y

extensión .bat, los archivos .bat son utilizados para ejecutar un conjunto de
comandos o programas en forma conjunta, evitando tener que volver escribirlos
cada vez deseemos ejecutarlos.
Si todo va bien, en este punto del proceso deberíamos tener al menos 4 archivos
dentro de la carpeta de trabajo guias_java, los cuales son:
EJECUTAR EL PROGRAMA
Si hemos leído y realizado juiciosamente todos los pasos descritos a en esta

sección, a este punto no deberíamos tener ninguna problema y podremos
ejecutar y probar nuestra pequeña aplicación, lo que sigue es dar doble clic en el
archivo ejecutar.bat, entonces se abrirán dos ventanas, la primera es indica que
se está invocando el programa java.exe sobre el archivo VentanaHora.class y la
segunda es la ventana de nuestro programa, el cual simplemente muestra la
hora exacta en la que se ejecutó el programa en el PC.
La explicación del código fuente y el funcionamiento del programa los veremos
en la próxima sección.
64
Como vemos el archivo Ejecutar.bat simplemente ejecuta el comando java.exe

pasándole como parámetro el nombre del archive compilado con extensión
.class, esta operación da instrucciones a la JVM o Máquina Virtual Java para
que interprete y ejecute cada instrucción de código binaria ByteCode dentro del
archivo VentanaHora.class y el resultado se puede apreciar en la siguiente
imagen.
Imagen: Ejemplo de la aplicación ejecutándose
POSIBLES PROBLEMAS AL MOMENTO DE EJECUTAR

Es posible que puedan ocurrir algunos problemitas al momento de ejecutar
nuestro programa, los más comunes podrían ser:
Esto indica que NO se registró correctamente la carpeta de trabajo guias_java

en la variables de entorno CLASSPATH, por lo cual el programa java.exe no
65
puede encontrar el archivo compilado VentanaHora.class, si este es el caso, al

momento de ejecutar el programa (dar doble clic en el archivo ejecutar.bat)
saldrá la anterior ventana de error, esto se puede solucionar siguiendo
estrictamente los pasos definidos durante anteriormente para la variable
CLASSPATH.
EMPAQUETAR LOS ARCHIVOS DEL PROGRAMA Y CREAR UN ÚNICO

EJECUTABLE
No es normal distribuir (vender o regalar) nuestros programas en una carpeta
con todos los archivos sueltos y en desorden, pues el usuario podría perderse
intentando adivinar cuál de todos estos archivos es el que necesita abrir para
poder iniciar con el uso del programa, por otro lado, también puede ocurrir que el
usuario por accidente elimine o dañe uno de los archivos necesarios (imágenes,
código compilado, sonido, video, archivo de datos, etc.), por estos motivos es
que necesitamos empaquetar los archivos (solo los necesarios para que
funcione, el código fuente es opcional) dentro de un único archivo distribuible,
por ejemplo un .DLL, un .exe y en caso de java un .jar, esta operación es la que
vamos a realizar a continuación.
CREAR UN ARCHIVO .BAT PARA INVOCAR EL PROGRAMA JAR.EXE
Abrir una ventana del block de notas y escribir lo siguiente:
Guardar el archivo con el nombre MANIFIEST.MF.

Haremos lo mismo para crear un archivo llamado crear_ejecutable.bat que nos
permita invocar el comando jar.exe cfmv miprograma.jar Manifest.mf *.class
66
Al ejecutar este archivo se ejecutara este comando jar, al cual se le pasan los
parámetros cfmv, donde c significa create (crear), f significa file (archivo), m
significa manifest (manifiesto) y v significa view (ver), esta combinación hará
que se cree un archivo llamado miprograma.jar el cual contendrá el archivo
manifest.mf creado anteriormente y todos los archivos compilados .class dentro
de la carpeta guias_java.
Al ejecutar el archivo crear_ejecutable.batobtendremos el siguiente resultado:
Esto genera un nuevo archivo ejecutable llamado miprograma.jar dentro de la

carpeta guias_java, como se aprecia la siguiente imagen:
67
Los archivos .JAR no son más que una especie de empaquetador (como .zip .rar
.dll .gz .cab .os .bin .dmg .iso .deb .rpm, etc) incluso pueden comprimir su
contenido.
Ahora solo tenemos que dar doble clic al archivo miprograma.jar y se ejecutara la
muestro programita, sin la fastidiosa ventana negra del D.O.S que vimos
anteriormente, y nuestra aplicación se ejecutara de una forma más sencilla:
Imagen: Ejemplo de la aplicación ejecutándose
Por último, el archivo miprograma.jar es el que venderemos, regalaremos o

publicaremos en internet para que sea instalado, y ejecutado en cualquier PC,
el resto de archivos (los códigos fuentes) son importantes para hacer
mantenimiento al programa y crear nuevas versiones.
RESUMEN:
En este capítulo aprendimos a preparar nuestro PC tener un entorno de trabajo
muy básico de aplicaciones escritas en Java, donde básicamente aprendimos
entre otras cosas:
 Descargar e instalar el JSDK.
 Configurar las variable de entorno PATH para que el S.O pueda conocer
la ruta donde se encuentra instalado el JDK y sus programa Java.exe,
Javac.exe, Javaw.exe y Jar.exe, de igual forma configuremos la variable
de entorno CLASSPATH, en la cual indicamos cual es la ruta de nuestra
carpeta de trabajo, de tal manera que los programas Javac.exe, Java.exe
y Jar.exe pueden encontrar las clases de nuestro programa al momento
de compilar, ejecutar y crear el archivo de distribución.
 Crear y utilizar archivos .bat para compilar los archivos de código fuente
.java invocando al programa Javac.exe, para ejecutar los archivos de
68
código compilado o binario .class invocando al programa Java.exe y para

crear el archivo de distribución o empaquetado .jar.
 Aprendimos que el código fuente de un programa Java debe ser

almacenado dentro de un archivo con extensión .java, que el código
compilado se genera en archivo .class a partir del código fuente bien
escrito y que los programas se recomiendan empaquetarlos dentro de
archivos .jar, con el fin de facilitar su distribución, instalación y ejecución.
Ejercicio propuesto:
1. Modificar el código fuente para la aplicación pueda hacer lo siguiente:
 Mostar la fecha y la hora, para ello debes investigar sobre los parámetros
de la clase SimpleDateFormat para dar formato a la fechas de la clase
Date.
 Cambiar el color de fondo de la ventana por color Verde.
 Cambiar el color del texto de la etiquete por el color Rojo
 Mostrar la fecha y la hora a la izquierda de la ventana.
 La fecha y la hora deben estar en tamaño 28 y deben estar subrayados,
para ello deben investigar sobre la clase Font, con la que se puede
cambiar el tipo de letra, su tamaño y estilo.
2. Construir otra aplicación que permita mostrar una ventana codos etiquetas
Jlabel, en la primera se debe mostrar el tu nombre completo de color Naranja
y la fecha de color Azul claro, la primera etiqueta debe aparecer en el Norte
de la ventana y la segunda en el Sur, para ello deben investigar sobre el
gestor de posicionamiento BorderLayout.
ANLISIS Y RECONOCIMIENTO DE LA ESTRUCTURA Y PARTES DE UN PROGRAMA

ESCRITO EN JAVA
En esta sección aprenderemos a analizaremos cada una de las partes del código
fuente de la aplicación VentanaHora construida como ejemplo de la sección
anterior, de esta manera aprenderemos como está formada la estructura de una
aplicación escrita con el Lenguaje de Programación Java.
69
Objetivos:
Al culminar la lectura de esta sección comprenderemos los siguientes conceptos
de programación en Java entre otras cosas:
 Que es un archivo de código fuente.
 Que es una clase e identificar sus elementos (propiedades y operaciones)
 Como escribir un clase adecuadamente sin violar las reglas de sintaxis de
Java.
 Como nombrar clases publica igual al nombre de su archivo de código
fuente .java.
 Que es un comentario de un o varias líneas.
 Que es un paquete java
 Como importar clases ubicadas dentro paquetes java con el fin de reutilizar
sus elementos
 Como reutilizar los elementos de una clase en otra me diente el uso de la
herencia
 Que es una propiedad y que es una operación
 Como utilizar la clase JFrame del paquete javax.swing para crear objetos de
Interfaz Imagen de Usuario (GUI) de tipo Ventana o Marco y utilizar
propiedades y operaciones para establecerle un título, un tamaño, una
posición y hacerla visible y agregarles otro componentes GUI.
 Como utilizar la clase Date del paquete java.util para obtener la fecha y hora
actual del PC.
 Como utilizar la clase SimpleDateFormat del paquete java.text para dar
formato variado a una fecha y hora.
 Como utilizar la clase JLabel del paquete javax.swing para crear objetos de
tipo Etiqueta y utilizar sus propiedades y operaciones para establecerle un
color de fondo, un texto, una orientación, un tipo de letra, un estilo y un color
al texto.
 Como utilizar la clase SwingConstants del paquete del paquete javax.swing
para establecer algunas características de los componentes GUI.
Un tema muy importante pendiente al que debemos dedicar mucho tiempo de

lectura, investigación y sobre todo practica es el concerniente a trata de
comprender la estructura y las partes del código fuente de una aplicación
escrita en Java, en este caso trataremos de explicar, analizar y comprender la
aplicación que desarrollamos como ejemplo de la sección anterior, donde
básicamente escribimos código java (también llamado código fuente Java) para
crear y mostrar una ventana en cuyo interior aparece la hora actual del PC.
70
Código fuente Java del ejemplo usado en la sección anterior
Primero que todo hagamos un reconocimiento general al código fuente, el cual

se muestra en la imagen anterior. He colocado las palabras de color azul y los
caracteres reservados de color rojo con el fin de resaltarlas dentro del código
fuente.
Observemos que el código está organizado en dos partes importantes:
 La primera parte del código fuente hace referencia a las instrucciones
import
 La segunda corresponde a la definición de la clase VentanaHora
71
public class VentanaHora extends JFrame {

// Aquí se debe escribir el cuerpo de esta clase
}
Las la primera llave abierta { indica el inicio del cuerpo de la clase, mientras que
la última llave cerrada } indica el fin del cuerpo de la clase.
Observemos que el contenido o cuerpo de la clase son todas las sentencias
(definiciones, declaraciones e instrucciones) escritas dentro de la clase y
encerradas entre e inicio { y el fin }. Observemos que dentro del cuerpo de
la clase VentanaHora podemos encontrar otros bloques de código que llevan un
inicio y un fin, se trata de las definiciones de tres operaciones que pertenecen a
dicha clase:
public VentanaHora( ){
// Aquí se debe escribir el cuerpo de esta operación
}
public void prepararVentana( ){

}
public static void main( String arg[ ] ){

}
Las anteriores sentencias definen 3 operaciones para la clase VentanaHora,

cada una de ellas posee un cuerpo, es decir un inicio y un fin, y cada operación
tiene un objetivo específico dentro del programa ejemplo escrito en la sección
anterior y que ahora estamos analizando. Más adelante trataremos en detalle
cada una de estas sentencias, sus instrucciones y su funcionamiento.
Notemos que el archivo donde guaramos el código fuente es exactamente igual

al nombre de la clase, es decir, el archivo se llama VentanaHora, incluyendo
minúsculas y mayúsculas, la diferencia entre ambos radica en que el nombre del
archivo debe llevar la extensión .java, pero el nombre de la clase no.
Lo anterior es una de varias REGLA DE LA SINTAXIS que posee el lenguaje
Java, reglas que debemos aprender, cumplir y acatar muy pero muy
estrictamente de lo contrario nuestros programas nunca funcionaran.
72
Cuando estamos escribiendo un programa utilizando un lenguaje de

programación como Java, primero que todo debemos diseñar nuestros
algoritmos usando una metodología llamada Diseño Orientado a Objeto, que de
determina que todo algoritmo se debe escribir siguiendo una estructura
especifica denominada clases, cuyas variables y funciones se denominan
propiedades y operaciones respectivamente, al definir una clase igualmente
estamos definiendo un nuevo tipo de dato, las variables declaradas de una clase
concreta se les denomina referencias, mientras que al valor asignado a dicha
referencia se le denomina objeto.
Cada algoritmo java (de ahora en adelante llamado clase) se debe escribir en un
archivo cuya extensión termina en .java, a estos archivos se les llama código
fuente, cada uno de los cuales puede contener una o varias clases, pero al
menos una de sus clases debe ser pública y debe llamarse igual que el nombre
de su archivo, por eso es que nuestra clase ejemplo inicia public class
VentanaHora y la guardamos en un archivo llamado VentanaHora.java, de
lo contrario violaríamos esta regla y el código fuente estaría mal escrito,
presentado un error de sintaxis, el nombre del archivo debe ser exactamente
igual al nombre de la clase tanto Mayúsculas como Minúsculas.
La primera línea del código fuente:
// VentanaHora.java, observemos que inicia con los caracteres // pegados,
esto le indica al compilador que toda esta línea es un comentario, o una especie
de nota en la que deseamos explicar algo, en este caso estamos comentando
que el nombre del archivo se debe llamar VentanaHora.java. Los comentarios no
son instrucciones Java propiamente dicha, es decir no generan ninguna orden al
computador, por lo tanto el compilador Javac.exe no los tienen en cuenta y
simplemente los ignora, solo sirven para etiquetar o explicar fracciones del
código fuente.
Existen dos tipos de comentario, los de una sola línea, como el ejemplo anterior
y los que ocupan varias líneas los cuales se deben ir encerrándolos entre /*
slash asterisco y asterisco slash */, como por ejemplo el siguiente comentario:
/*
Si necesitásemos comentar o explicar algo más
O menos amplio, entonces Escribir un comentario
En varias líneas, como este ejemplo que están leyendo
*/
// Este las dos barras para explicar algo muy corto
73
Las líneas de código siguientes:
import javax.swing.*;
import java.util.*;
import java.text.*;
import java.awt.*;
Son instrucciones utilizadas para indicar que deseamos reutilizar o importar el

código de otras clases dentro del cuerpo de nuestra clase VentanaHora, las
clases a reutilizar deben estar previamente compiladas y almacenadas en
carpeta o empaquetadas en archivos .jar o .zip dentro del PC donde estamos
escribiendo y donde vamos a ejecutar el programa, en java a estos archivos o
carpetas se les llama paquetes, es decir, con la palabra import podemos
reutilizar el código compilado de otras clases, pero debemos indicar cuál es la
ruta de paquetes donde se encuentran dichas clases. En el ejemplo anterior
deseamos reutilizar todos las clases (o archivos de código java) ubicados en los
paquetes javax.swing, java.util, java.text y java.awt. Si por el
contrario solo quisiéramos reutilizar una o solo algunas de las clases y no todas
dentro de cada paquete, lo padreamos hacer de la siguiente manera:
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import java.awt.Font;
import java.awt.Color;
import java.util.Date;
import javax.text.SimpleDateFormat;
Lo anterior quiere decir que deseamos importar y reutilizar el código dentro de

un archivo llamado JFrame.class, lo cual a su vez nos indica que dentro de
este archivo debe existir una clase llamada JFrame, pero además, dicha clase
se encuentra ubicada dentro de un paquete llamado swing, el cual a su vez está
dentro de otro paquete llamad javax.
La mayoría de las clases que necesitamos reutilizar dentro de nuestros
programas se encuentran ubicadas en los paquetes java y javax, los tenemos
disponibles en nuestro PC desde el mismo momento en que instalamos el JDK.
74
Podremos intuir estamos reutilizando otras clases del paquete javaz.swing,

estas clases son JLabel y SwingConstants, además podemos ver también
importamos las clases Font y Color del paquete java.awt, la clase Date del
paquete java.util y la clase SimpleDateFormat del paquete java.text. A
medida que vallamos avanzando en esta sección veremos para que utilizamos
cada una de estas clases dentro del código de nuestra clase VentanaHora.
Es importante anotar que el uso de la palabra import no es obligatorio y solo
es necesaria en caso de que queramos reutilizar o importar otras clases dentro
del cuerpo de las nuestras, pero una vez utilizada la palabra import debe ir
justamente antes de la cabecera de nuestra clase, es decir antes de la línea
public class VentanaHora.
Otro punto importante a recordar siempre es que en java las palabras
minúsculas son diferentes a las palabras mayúsculas, lo cual quiere decir por
ejemplo que las palabras miVentana, MiVENTANA, miventana son totalmente
diferentes, por lo tanto el compilador las identifica de forma independiente una
de la otra.
La siguiente línea:
El nombre de la claseEs la clase que contiene propiedades y operaciones que

van a ser heredadas por la clase VentanaHora
public class VentanaHora extends JFrame { Es el inicio del

cuerpo de la clase
Ámbito o acceso Indica que el algoritmo Indica que la clase

a la clase es una clase va a heredar de otra
Es la cabecera de nuestra clase, en la cual indicamos que la clase es publica

public pudiéndose reutilizar o importar dentro del cuerpo de cualquier otra
clase, también indicamos que la clase se va a llamar VentanaHora y a heredar
(extends) parte del código de otra clase llamada JFrame, clase que se utiliza
para trabajar con ventanas o marco, la { indica el inicio del cuerpo o contenido
de la clase VentanaHora, cuerpo que finaliza con la última } que aparece en el
código fuente de esta ejemplo.
75
Todas las instrucciones de código que se encuentra dentro del cuerpo { } de la

clase pertenecen a dicha clase.
Una gran fortaleza que poseen los lenguajes Orientados a Objetos como Java es
la capacidad de reutilizar el código de otras clases, ya sea importando o
heredando dichas clases, ambas técnicas permiten aprovechar el código java
escrito por otros programadores, incluso el código java que nosotros mismos
hemos escrito en este u otros programas.
Si el cuerpo de la clase VentanaHora estuviese vacío y no heredara de ninguna

otra clase, sería como el siguiente ejemplo:
Observemos que siguiera siendo pública pues su archivo tiene mismo nombre,
pero además observémonos que no tendría la palabra reservada extends, no el
nombre de la clase JFrame de la cual hereda.
La instrucción:
Define una operación, función o método especial llamada constructor de la

clase VentanaHora. Una clase puede tener propiedades también llamadas
variables o atributos, los cuales almacenan valores específicos, también puede
contener operaciones, igualmente llamadas funciones o métodos, los cuales
generalmente realizan cálculos y procesos sobre los valores almacenados en las
propiedades, pero existen operaciones especiales como las denominadas
constructores, quienes son responsables de crear objetos (variables
compuestas por las propiedades sus valores de una respectiva clase).
76
Observemos que existen diferencias y similitudes entre la cabecera de la clase y

la cabecera del método constructor:
public class VentanaHora extends JFrame{ La cabecera o firma de la

clase lleva la palabra
class y no tiene ( ).
}
Mientras que la cabecera o firma del método no lleva la palabra class,
} lleva paréntesis y además siempre debe ir definido dentro del cuerpo { }
de la clase
Un ejemplo de cómo utilizar el método u operación constructor es el que vemos

en la siguiente instrucción:
VentanaHora ventana = new VentanaHora( );
La clase tipo La variable referencia al Invocamos al constructor

de dato objeto de tipo VentanaHora para crear el objeto de tipo
VentanaHora
Las instrucciones de programación Java y en general en todos los lenguajes de

programación son mas entendibles si las interpretamos de derecha a izquierda y
luego de izquierda a derecha, por ejemplo la anterior instrucción quiere decir
(derecha a inquiera) que invocamos el constructor de la clase VentanaHora
creando un nuevo objeto de dicha clase, es decir un objeto de tipo
VentanaHora, el cual asignamos a una variable llamada ventana declarada de
tipo VentanaHora.
De Izquierda a derecha quiere decir que utilizamos la clase VentanaHora para

declarar una variable referencia llamada ventana a la cual le asignamos un
nuevo objeto creado al invocar el constructor de la clase VentanaHora.
Utilizamos = new para asignar un nuevo objeto a una variable referencia

declarada del mismo tipo de dicho objeto.
77
Pensemos en la variable ventana como una referencia o una forma de acceder a

los datos (propiedades y operaciones) de una ventana creada y colocada en la
memoria del PC, ventana a la que luego le daremos un tamaño, un título y la
haremos visible en la pantalla, pero además le agregaremos una etiqueta GUI
con la hora actual del PC. En las siguientes instrucciones:
Definimos una operación o método llamado prepararVentana, cuyo cuerpo { } o

interior contiene una serie de instrucciones (líneas de código java terminadas en
; punto y coma) que son ejecutadas cada vez que invoquemos el nombre de la
operaciones prepararVentana( ).
Analicemos una a una las instrucciones que escritas en el cuerpo de la operación
anterior:
La cabecera del método u operación:
public void prepararVentana( ) es la cabecera del método

(recordemos que método es un sinónimo de operación, así como función
también lo es) y la utilizamos para invocar la operación donde queramos ejecutar
las instrucciones incluidas en su cuerpo { }, contenido o interior, la cabecera
consta del ámbito, el cual representa una especie de restricción que determina
donde podemos o no invocar dicha operación, el ámbito se indica aplicando una
de las siguientes palabras reservadas de java:
78
public : podemos invocar la operación en cualquier parte de este

programa o en cualquier otro.
protected : solo podemos invocar la operación en el cuerpo de una
clase hija de la clase VentanaHora, es decir en una clase que herede de
la clase esta, de lo contrario el compilador emitirá un mensaje de error.
private : solo podemos invocar la operación dentro de cuerpo de la
clase la clase donde fue declarada, es decir en la clase VentanaHora, de
lo contrario el compilador emitirá un mensaje de error.
void : quiere decir que el método u operación no debe retornar o devolver

ningún tipo de dato o valor al momento de ser invocada, en caso de que
quisiéramos que la operación retorne o devuelva un valor especifico, debemos
reemplazar la palabra void por el tipo de dato del valor a retornar, por ejemplo:
public int sumar( int numero1, int numero2){

int resultado = numero1 = numero2;
return resultado;
}
Al invocar esta operación retornara un valor entero resultado de sumar el valor

de sus variables parámetros numero1 y numero2, un ejemplo de cómo
podríamos invocar esta operación pasándole 7 como valor del parámetro
numero1 y 8 como valor del parámetro numero2, y el resultado devuelto por la
operación lo asignaremos a una variable entera llamada resultado:
int resultado = sumar( 7, 5);
prepararVentana : es el nombre que libremente le colocamos a la operación,

nombre que debe seguir la regla de no tener espacios, no iniciar con numero, ni
tener cualquiera de estos caracteres ! " · % & / ( ) = ? ¿ ¡ ' ¬ # @
| \º ª<, ; > : . - { ] } + * ^ ya que la mayoría son caracteres
reservados del lenguaje Java.
( ) : En el centro de ellos colocamos los parámetros de entrada de la

operaciones, con los cuales generalmente realizamos cálculos o cualquier tipo
de proceso según sea la necesidad del programador, como en el ejemplo de la
operación suma donde utilizamos dos parámetros de tipo entero, los cuales
79
utilizamos para sumarlos y devolver el resultado de dicha suma. No es

obligatorio que toda operación tenga parámetros de entrada, pero si decidimos
utilizarlos, estos deben ser declarados como una variable de un tipo específico y
deben estar separados por , coma. En este caso la operación prepararVentana
no recibe ningún parámetro, lo cual explica por qué hemos dejado los paréntesis
vacíos.
{ Es el inicio del cuerpo o contenido de la operación, todas las instrucciones que

realiza una operación deben ir después de esta llave.
} Es el fin del cuerpo o contenido de la operación, todas las instrucciones que

realiza una operación deben ir antes de esta llave. En general el nombre de una
operación define su objetivo, es decir nos da una idea de las operaciones o
instrucciones que ejecutara y el resultado puede o no devolver al ser invocada.
Todas las instrucciones que realiza una operación deben ir entre { }.
Toda operación debe ser definida (cabecera y cuerpo) dentro del cuerpo de su
clase, hacerlo por fuera generaría un error de sintaxis.
El cuerpo de la operación
El cuerpo contiene todas las instrucciones que se deben ejecutar cada vez que la
invocamos la operación. En síntesis el cuerpo es lo más importante de toda
operación, pues en su interior es donde se coloca el código java escrito para
realizar algún proceso, cálculo o actividad específica.
A continuación comprenderemos el significado de cada instrucción escrita en el
cuerpo de la operación prepararVentana( ), recordemos que para entender
cada instrucción de forma más clara y fácil debemos interpretarlas de izquierda a
derecha y viceversa.
this.setTitle("Hora del PC");
Es la primera instrucción defina dentro del cuerpo de la operación

prepararVentana, de derecha a izquierda indica un literal "" que contiene el
texto Hora del PC, el cual pasamos como parámetro de la operación setTitle,
operación que invocamos con la variable objeto de esta (this en java) clase
VentanaHora.
De izquierda a derecha, esta clase posee una operación llamada setTitle, la
cual invocamos pasándole como parámetro el literal de texto "Hora del PC".
80
Observen como utilizamos el carácter . punto para indexar o conectar el objeto

this con sus operaciones o con sus propiedad, las cuales están definidas en el
cuerpo de la clase con la que fue declarada dicha variable objeto this, en este
caso la clase VentanaHora.
La operación setTitle es utilizada para establecer (set en Ingles) el titulo
(Title en Ingles) de la ventana, este método pertenece a la clase JFrame, es
decir que está definido de dicha clase, pero como nuestra clase VentanaHora
hereda (extends en Java) de la clase JFrame, entonces esta operación ahora
también pertenece automáticamente a la clase VentanaHora por ser hija de la
clase JFrame.
La instrucción:
SimpleDateFormat formatoFecha = new SimpleDateFormat("hh:mm:ss

a");
De derecha a izquierda, el literal de texto "hh:mm:ss a" lo pasamos como

parámetro del constructor de la clase SimpleDateFormat, el cual invocamos
para crear un nuevo objeto de esta clase (es decir de este tipo), objeto que
asignamos a una variable referencia llamada formatoFecha declarada
igualmente de tipo SimpleDateFormat.
De izquierda a derecha, utilizamos las clase SimpleDateFormat para declarar
una variable referencia llamada formatoFecha, es decir esta variable es de tipo
SimpleDateFormat, luego asignamos un nuevo objeto de esta misma clase
invocando su constructor, quien recibe como parámetro un literal de texto que
contiene el formato en hora que le daremos a la fecha.
La clase SimpleDateFormat es utilizada para dar formato a objetos de la clase
Date (Fecha en inglés), en este caso estamos indicando que el formato de la
fecha será para obtener solo la hora (hh), los minutos (mm), los segundos (ss)
en hora meridiano (a), ósea AM/PM, la hora debe ir separada por : dos puntos.
Esta clase se encuentra en el paquete java.text el cual está disponible desde
que la instalación del JDK en nuestro PC, es por esta razón que al inicio de la
clase utilizamos la instrucción:
import java.text.*;
También podernos hacer lo mismo o usando la instrucción:
81
import java.text. SimpleDateFormat;
La instruction:
Date fechaPC = new Date ( );
De derecha a izquierda indica que invocamos al constructor sin parámetros de la

clase Date, creado un nuevo objeto de esta clase, el cual asignamos una
variable referencia llamada fechaPC declarada de tipo Date.
De izquierda a derecha quiere decir que utilizamos la clase Date para declarar
una variable referencia llamada fechaPC a la cual se asignamos un nuevo
objeto creado con el constructor sin paramentos de la clase Date.
La clase Date pertenece al paquete java.util. del JDK y es utilizada para
crear objetos cuyas propiedades contienen información sobre una fecha
específica y cuyas operaciones nos permiten realizar calculo con fechas, entre
otras utilidades. Algunas de sus propiedades son YEAR, MONTH, DAY, HOURS,
MINUTES, SECONDS, con las cuales podemos saber el año, el mes, el día, la
horas, los minutos y segundos de una determinada fecha respectivamente,
mientras que algunas de sus operaciones como getTime( ) nos devuelven la
fecha convertida en milisegundos, before( Date fecha2) no permite saber
si la fecha es menor que fecha2, after( Date fecha2) no permite saber si
la fecha es mayor que fecha2, etc.
JLabel etiquetaHora = new JLabel( );
En esta instrucción invocamos al constructor sin parámetros de la clase JLabel

para crear un nuevo objeto Etiqueta (Label en inglés) el cual es asignado a una
variable referencia llamada etiquetaHora declarada de tipo JLabel.
La clase JLabel pertenece al paquete javax.swing y es utilizada para trabajar
con objetos GUI que nos permiten visualizar etiquetas que pueden o no contener
Texto o Iconos o ambos, un objeto de esta clase lo podemos agregar como
componentes de una Ventana (objetos creados con las clases JFrame,
JWindow, JDialog, JInternalFrame o JOptionPane) o componente de un
Panel (objetos creados con las clases JPanel, JDesktopPane, JTabbedPane,
JRootPane, etc).
Como veremos más adelante la clase JLabel posee propiedades y operaciones
que nos permiten establecer el contenido y características del texto y su icono,
82
como por ejemplo el tipo de fuente o letra, su color, el estilo, tamaño y alineación,
etc.
La instrucción:
String horaPC = formatoFecha.format( fechaPC );
De derecha a izquierda indica que la variable objeto fechaPC de tipo Date la

utilizamos como parámetro al invocar o llamar la operación format del objeto
formatoFecha de tipo SimpleDateFormat, esta operación retorna como texto
la fecha que recibe un su parámetro de entrada, según el formato indicado en el
constructor SimpleDateFormat, en este caso devuelve la
hora:minutos:segundos am/pm de la fecha actual del PC, el valor devuelto
es asignado a una variable llamada horaPC declarada de tipo String, es decir
de tipo cadena de texto.
De izquierda a derecha indica que utilizamos la clase String para declarar una
variable llamada horaPC, a la cual le asignamos el texto devuelto por la llamada
o invocación de la operación format del objeto formatoFecha creado de tipo
SimpleDateFormat, la operación format recibe como parámetro un objeto de
tipo Date, en este caso fechaPC el cual contienen información sobre la fecha al
que deseamos dar el formato hh:mm:ss a.
La clase String es utilizada por trabajar con variables o literales de texto, por lo
que posee un conjunto de propiedades y operaciones para trabajar con cadenas
(sinónimo de literal ) que pueden contener cualquier cantidad o combinación de
carácter alfabéticos (de la aA a la zZ), numéricos negativos o positivos o
caracteres especiales o de puntuación (! " · % & / ( ) = ? ¿ ¡ ' ¬ #
@ | \º ª<, ; > : . - { ] } + * ^) incluyendo espacios en blanco,
por ejemplo:
Strig nombre = "John Arrieta";

String nombreMayus = nombre.upperCase( ); // "JOHN
ARRIETA"
String nombreMinus = nombre.lowerCase( ); // "john
arrieta"
String soloNombre = nombre.subString(0,4); // "John"
83
String soloApellido = nombre.subString(6); // "Arrieta"

int tamañoDelNombre = nombre.length; // 12
boolean iguales = nombre.equals("Yenys "); // false
int posicion = nombre.indexOf("h"); // 2
char segundaInicial = nombre.charAt(5); // A
Paquete java.lang, el cual no es necesario importar pues es importado

implícita y automáticamente por el compilador javac.exe, por eso no aparece en
las sentencias import al inicio de esta clase.
La instrucción:
etiquetaHora.setText( horaPC );
De derecha a izquierda indica que utilizamos la variable horaPC de tipo String

como parámetro de la llamada o invocación de la operación setText del objeto
etiquetaHora, este objeto fue creado anteriormente como de tipo JLabel.
De izquierda a Derecha indica que utilizamos el objeto etiquetaHora de tipo
JLabel para invocar su operación setText a la cual le pasamos como
parámetro la variable horaPC.
La operación setText de la clase JLable estable (set en Ingles) el texto que
será mostrado por el objeto etiquetaHora, en este caso el texto representa la
hora actual del PC en formato hh:mm:ss a.
La instrucción:
etiquetaHora.setFont ( new Font("Consola", Font.BOLD,

37));
De derecha a izquierda indica que creamos un nuevo objeto de la clase Font

(tipo de letra o fuente) al invocar su constructor que recibe 3 parámetros, el
primero es el nombre del tipo de letra en este caso es "Consola", el segundo
es el estilo de la letra, en este caso Font.BOLD (en español Fuente Negrita), y
el tercer parámetro es tamaño del tipo de letra, en este caso es 37 puntos. El
nuevo objeto de tipo Font es asignado como parámetro de la operación
setFont invocada utilizando el objeto etiquetaHora de tipo JLabel.
84
La clase Font está ubicada en el paquete java.awt incluido en el JDK, por eso
debemos importarla mediante la import java.awt.*; Esta clase es utilizada
para trabajar con diferentes tipos de Fuente o tipos de Letra, por ejemplo Arial,
Times New Roman, Calibri, Comic Sans, Helvetica, Lucida, Consola,
etc.
El método u operación setFont(Font tipoLetra)pertenece a la clase

JLabel, la cual hereda de la clase JComponente quien es la clase padre de
todas las clases que se utilizan para trabajar con componentes GUI (interfaz
Imagen de Usuario) generalmente incluidas en los paquetes javax.swing,
como es el caso de las clases JButton (botón), JMenu (menú), JWindow
(ventana), JTextField (campo de texto), JCheckbox (caja de verificación),
JLabel (etiqueta), etc. Esto quiere decir que la todos estas clases son hijas de
la clase JComponente, por ende todas poseen la operación setFont, en otras
palabras, los objetos creados con estas clases se les puede establecer un tipo
de letra con un estilo y tamaño especifico.
La instrucción:
etiquetaHora.setForeground(Color.BLUE);
De derecha a izquierda en esta instrucción utilizamos la propiedad BLUE de la

clase Color y la pasamos como parámetro de la llamada a la operación
setForeground invocada mediante la variable objeto etiquetaHora de tipo
JLabel.
De izquierda a derecha quiere decir que la clase utilizamos el objeto
etiquetaHora de tipo JLabel para invocar la operación setForeground y le
pasamos como parámetro la propiedad BLUE de la clase Color.
La operación setForeground( Color unColor) es utilizada para establecer el
Color del tipo de fuente o letra del texto mostrado dentro de la etiquetaHora,
esta operación pertenece a la clase JLabel y al igual que la operación setFont
esta también es heredada de su clase padre JComponente.
La clase Color al igual que la clase Font pertenece al paquete java.awt, pero
a diferencia de Font esta clase se utiliza para trabajar con los diferentes
colores que soporta nuestro PC, esta clase posee un conjunto de propiedades
públicas cada una con el nombre de un color particular, por ejemplo
85
Color.BLUE que representa el color AZUL, Color.RED el color ROJO,

Color.GREEN el VERDE, Color.BLACK el NEGRO, Color.YELLOW el
AMARILLO, Color.WHITE el BLACO, Color.ORANGE el NARANJA,
Color.PINK el ROSADO.
La instrucción:
etiquetaHora.setHorizontalAlignment(JLabel.CENTER
);
De derecha a izquierda utilizamos la propiedad CENTER de la clase JLabel

como parámetro de la llamada a la operación setHorizontalAlignment
invocada por el objeto etiquetaHora de la clase JLabel.
De izquierda a derecha quiere decir que utilizamos el objeto etiquetaHora de
tipo JLabel para invocar su operación setHorizontalAlignment que
recibe como parámetro la propiedad CENTER de la clase JLabel.
La operación setHorizontalAlignment establece la alineación horizontal del

texto que se visualiza dentro de la etiqueta, esta alineación se debe indicar
mediante el uso de una de las siguientes propiedades de la clase JLabel,
JLabel.LEFT (izquierda), JLabel.RIGHT (derecha) y JLabel.CENTER
(centro), o utilizando estas mismas propiedades de la clase SwingConstants
del paquete import javax.swing.
La instrucción:
this.getContentPane( ).add( etiquetaHora );
En esta instrucción de derecha a izquierda lo que hacemos es utilizar la variable

objeto etiquetaHora de tipo JLabel como parámetro de la llamada a la
operación add [agregar en español] del objeto de tipo JPanel, objeto que es
obtenido (get en ingles) o devuelto al invocar la operación getContentPane de
esta (this en ingles) clase VentanaHora, operación que es heredada de su
clase padre JFrame.
De izquierda a derecha quiere decir que en esta (this en ingles) clase (ósea
donde estamos escribiendo el código) invocamos su operación
getContentPane para obtener (get en ingles) el panel de contenidos que
86
posee la ventana en su interior, de este objeto panel invocamos su operación

add (agregar en español) y le pasamos como parámetro la variable objeto
etiquetaHora, esto permite agregarle al panel de contenidos de esta ventana
el objeto etiquetaHora, el cual contiene el texto de la hora actual del PC en
color AZUL, tipo de letra "Consola", negrita y con 37 puntos de tamaño.
La anterior instrucción esta resumida o abreviada en una única instrucción de

código, pero para mayor claridad podemos expresarla en dos líneas o
instrucciones como se muestra a continuación:
JPanel panelDeContenido = (JPanel) this.getContentPane( );

panelDeContenido.add( etiquetaHora );
Como podremos deducir, en la primera instrucción mediante la llamada o

invocación de la operación getContentPane obtenemos el objeto Panel de
Contenido de esta ventana, ósea de la clase VentanaHora y lo convertimos a
un objeto de tipo JPanel mediante un castin (JPanel), ya que en realidad el
Panel de Contenidos de una ventana es un objeto de la clase JRootPane, clase
hija de la clase JPanel, luego lo asignamos a una variable referencia llamada
panelDeContenido de tipo JPanel.
En la segunda instrucción simplemente invocamos al método u operación add
del objeto panelDeContenido de tipo JPanel para pasarle como parámetro el
objeto etiquetaHora, con el fin de colocar dicha etiqueta dentro del panel de
contendidos de la VentanaHora.
La instrucción:
this.setSize( 300, 200);
En la anterior instrucción indicamos que esta (this en ingles) clase posee una
operación llamada setSize, la cual al ser invocada establece (set en ingles) el
tamaño (size en ingles) de la ventana en 300 pixeles de ancho y 200 pixeles de
alto.
La instrucción:
this.setLocationRelativeTo( null );
87
Indicamos que para esta ventana invocamos su operación

setLocationRelativeTo para establecer (set en ingles) la posición
(Location en ingles) relativa (Relative en ingles) a (To en ingles) de la
ventana, en este caso le pasamos como parámetro la palabra reservada null
(nada en español) para indicarle que deseamos colocar la ventana en una
posición relativa centro de la pantalla del PC.
this.setVisible( true );
Por último invocamos la operación setVisible de esta clase y le pasamos

como parámetro el valor true (verdadero en español) la ventana es pintada
automáticamente en la pantalla del PC, por si por el contrario le pasamos como
parametro el valor false (falso en español), entonces la ventana deja de ser
visible en la pantalla del PC y aún sigue abierta pero de forma invisible.
PUNTO DE INICIO O EJECUCION DE UN PROGRAMA.
Para que nuestro programa escrito en Java pueda ser utilizado o ejecutado como
una aplicación de escritorio, por ejemplo en los Sistemas Operativos más
populares del mundo como Windows, GNU/Linux, Mac OSx, Unix, Solaris, etc,
debemos definir una operación especial denominada PUNTO DE INICIO o
PUNTO DE EXECUCION la cual es invocada automáticamente al hacer doble
clic sobre el icono del programa.
Esta operación especial de Java y de otros lenguajes de programación como C,
C + + , C# y Visual Basic entre otros, contiene las primeras instrucciones que
serán ejecutadas al iniciar un programa.
A continuación veremos la definición de la operación Punto de Inicio de nuestro
ejemplo:
88
Repasando algunas cosas vistas anteriormente en esta sección, podemos

identificar la mayoría las partes que conforman a esta operación:
 La cabecera indica que es una operación pública (public).

 No retorna o devuelve (void) ningún valor.
 main es el nombre de la operación.
 Recibe como parámetro un valor de tipo texto o String, el cual es
asignado a una variable llamada arg[ ], los corchetes indican que la
variable arg es un arreglo o vector (concepto que veremos en otra
sección dedicada a los arreglos).
 La palabra static (concepto que veremos en una sección posterior
dedicada a las propiedades y operaciones staticas) indica que la
operación no requiere ser invocada o llamada por una variable objeto
creada con el mismo tipo de la clase donde está definida esta función, en
este caso nos referimos a la clase VentanaHora,
 El inicio { y el fin } del cuerpo de la operación está formado por todas las
instrucciones que se encuentra dentro de las llaves { }.
En este caso el cuerpo solo consta de dos instrucciones:
VentanaHora ventana = new VentanaHora( );
ventana.prepararVentana( );
En la primera instrucción invocamos el método u operación constructor sin

parámetros de la clase VentanaHora, esta llamada crea un nuevo objeto de tipo
VentanaHora el cual es asignado a una variable llamada ventana, la cual es
declarada del mismo tipo del objeto que le es asignado.
En la segunda instrucción utilizamos la variable referencia del objeto

VentanaHora creado anteriormente para poder invocar la operación
prepararVentana que definimos y explicamos anteriormente, la cual al ser
invocada básicamente realiza las siguientes acciones:
 Establece el título de la ventana
89
 Obtiene la fecha y hora actual del PC y le da formato de

hora:minutos:segundos am/pm
 Crea una componente GUI de tipo etiqueta y establece como texto la
hora del PC, tipo de letra Consola para el texto, con estilo Negrita,
tamaño de 37 puntos, color Azul y alineación central.
 Agrega la etiqueta al panel de contenido de la ventana
 Establece el tamaño de la ventana a 300 puntos de ancho y 200 de alto.
 Establece la posicion de la ventana relativa al centro de la pantalla del
PC
 Establece la ventana como Visible en la pantalla del PC.
El resultado es el que se muestra en la siguiente imagen:
OTROS CONCEPTOS MUY IMPORTANTES QUE SE DEBEN TENER CLAROS:
El lenguaje de programación Java posee un conjunto de palabras reservadas o

propias del mismo lenguaje, por lo tanto nosotros no podemos utilizarlas de
forma arbitraria dentro del código fuente, pues cada una de ellas se utiliza para
una fin, objetivo o propósito específico y todas debemos escribirlas
completamente en minúscula, algunas de las palabras reservadas utilizadas en
nuestro ejemplo son:
 import : utilizada para reutilizar el código de otros archivos compilados
ubicados en una ruta de paquetes específica, la cual se debe indicar justo
después de la palabra import y terminar con ; (punto y coma), en este
ejemplo la palabra import indica que deseamos reutilizar el código de los
90
archivos ubicados en los paquetes javax.swing, java.util, java.text

y java.awt.
 public : utilizada para indicar que el código que se está escribiendo puede
ser reutilizado por cualquiera, en cualquier otro programa o archivo de código
java. En este ejemplo la palabra public indica que el algoritmo que
estamos escribiendo puede ser reutilizado de forma pública en cualquier otro
algoritmo o programa.
 class : indica que el código que se está escribiendo es una clase. Una
clase es una nueva forma más simple de escribir, estructurar y diseñar
algoritmos, a los cuales se les debe dar un nombre específico para poder
ser identificados y reutilizados sin necesidad de tener que saber muchos
detalles de su contendido o funcionamiento, en este ejemplo la palabra
class indica que el algoritmo o clase se debe llamar VentanaHora.
 extends : utilizada para indicar que el algoritmo o clase que estamos
escribiendo va a heredar el ciertos variables, comportamiento, código y
funcionamiento de otra clase específica, la herencia es un mecanismo
poderoso que nos permite simplificar y reducir el código de nuestros
programas, en este ejemplo la palabra extends indica que la clase
VentanaHora va a heredar variables y comportamientos definidos en la clase
JFrame, cuyo código se encuentra escrito en el archivo JFrame.class
ubicado en el paquete javax.swing. Un JFrame es una clase o algoritmo
diseñado para poder utilizar y trabajar con Ventanas dentro de nuestros
programas, esto quiere decir que al momento de definir public class
VentanaHora extends JFrame estamos indicando que el algoritmo o clase
VentanaHora hereda de una Ventana y por lo tanto también será una
Ventana y podrá comportarse como tal.
 void : utilizada para indicar que no se va a retornar o devolver ningún valor.
 this : utilizada para indicar que deseamos utilizar las variables y
operaciones definidas como propiedades y métodos respectivamente dentro
de esta misma clase. this es una variable reservada de Java.
 new : utilizada para crear una nueva variable a partir del código definido en
una clase, a esta variable se le conoce como objeto y el nombre de la clase
utilizada para crearla se le conoce como el tipo de la variable.
 true : utilizada para indicar un valor Verdadero, lo contrario sería false o
falso
 null : utilizada para indicar que no hay valor, que una variable aún no se le
ha asignado dato o valor.
91
 { : se utiliza para indicar el inicio de un bloque de código, el cual puede ser el

cuerpo de una clase, de un método (función u operación), el cuerpo de un
condicional if (SI), una bifurcación selectiva switch (según), el cuerpo de
un ciclo iterativo o repetitivo for (para), de un while (mientras que,)
dowhile(repetir mientras que), un bloque trycatch(intentar y capturar
errores), etc.
 } : es lo contrario de {, es decir se utiliza para indicar el fin de un bloque de
código.
Otras palabras reservadas del lenguaje Java:

abstract, byte, char, int, doublé, boolean, shortlongfloat,
strictfp, if, else, interface, super ,break, switch, case,
default, final, native, synchronized, new, try, catch,
finally, throw, throws, for, private, throws, goto,
protected, transient, const, public, continue, implements,
return, package, import, volatile, do, while, instanceof,
static
Igualmente java posee un conjunto de caracteres reservados + - * / % . ,
;"!= <>>= <= ¡ ( ) ' [ ], ==
En secciones posteriores veremos con más detalle cada una de estas palabras y
caracteres reservados del lenguaje Java.
Una aplicación Java está compuesta un conjunto (al menos uno) de algoritmo
denominados clases, estos algoritmos deben estar escritos respetando
estrictamente unas reglas propias del lenguaje de programación Java, a estas
reglas se les conoce como sintaxis.
Algunas de las reglas aplicadas en la mayoría de los programas son:
 El código que contiene las instrucciones Java (llamado código fuente) se

debe guardar en archivos con extensión .java.
 Cada archivo debe contener al menos una clase marcada con ámbito
público, donde el nombre de la clase debe ser exactamente igual al
nombre del archivo.
 Java es sensible a las letras mayúsculas y minúsculas, por ejemplo la
palabra abc es tratada y reconocido de forma diferente a la palabra Abc,
o aBC o ABC, etc.
92
 El nombre de una clase, operación y propiedad no debe contener los

siguientes caracteres ! " · % & / ( ) = ? ¿ ¡ ' ¬ # @ | \º
ª<, ; > : . - { ] } + * ^
 El nombre de una clase, operación y propiedad no debe iniciar con
numero, pero si puede incluirlos en cualquier otra posición.
 Una clase debe tener un inicio { y un final }, lo que está dentro de estas
llaves se le llama cuerpo o contenido de la clase, por ejemplo:
public class VentanaHora {
 Una clase puede tener propiedades, también llamadas variables

miembros, atributos o variables globales, toda variable propiedad debe
tener un nombre que no inicie con numero, ni contenga espacios, ni
cualquiera de los siguientes caracteres ! " · % & / ( ) =
? ¿ ¡ ' ¬ # @ | \º ª<, ; > : . - { ] } + * ^,toda
propiedad debe ser declarada dentro del cuerpo de la clase y fuera del
cuerpo de una operación, por ejemplo:

String tituloVentana;
}
 Una clase puede tener operaciones, también llamadas métodos o

funciones, cada operación posee ámbito (public, protected o private),
debe tener un nombre que no inicie con numero, ni contenga espacios, ni
cualquiera de los siguientes caracteres ! " · % & / ( ) = ? ¿ ¡ '
¬ # @ | \º ª<, ; > : . - { ] } + * ^, toda operación (a
excepción de los constructores) justo antes de su nombre deben indicar
el tipo de dato que retorna, si no retorna o devuelve algún valor, entonces
debe indicarlo con la palabra reservada void, toda operación debe incluir
( ) justo despees de su nombre, dentro de ellos se declaran los
parámetros que recibe separados por , coma, si no llegase a recibir
parámetros entonces los ( ) se dejan vacíos. Toda operación debe ser
declarada dentro del cuerpo de la clase, por ejemplo:
93

String titulo;
public void setTitulo( String nuevoTitulo ){
titulo = nuevoTitulo;
}
}
 Una variable es una referencia, llave o identificador que nos permite

acceder a datos almacenado en memoria RAM del PC, es como una
cajita que puede guardar varias cosas durante el tiempo, pero solo una
cosa a la vez y del mismo tipo, cuyo valor podemos cambiar cuantas
veces sea necesario, en cualquier momento del tiempo una variable
puede tener valor, como también puede estar vacía, cada variable solo
puede guardar valores de un único tipo de datos, por ejemplo la variable
salario solo puede guardar valores numéricos de los posibles salarios
que hallan, pero no puede guardar el nombre del dueño de dicho salario
porque el nombre no es de tipo numérico, sino de tipo texto o cadena de
caracteres, toda variable debe ser declarada de la siguiente manera:
tipoDeDato nombreDeLaVariable;
Donde tipoDeDato puede ser de dos clases:

Tipos básicos o simples, por ejemplo los datos numéricos como el byte
para un valor entero entre -128 y 127, short para un valor entero
entre -32768 y 32767, int para un valor entero entre -2147483648 y
2147483647, long para un valor entero muy grande, float para un
valor decimal con pocos números después del punto o coma, double
un valor decimar con muchos números después de la coma o punto,
char para guardar un carácter cualquiera de la tabla ASCII, y boolean
para guardar fase (falso) o guardar true (verdadero).
Tipos de datos compuestos llamados objetos, por ejemplo String para
guardar muchos caracteres o cadena texto, Array para guardar vectores
o arreglos, JFrame para guardar ventanas, Date para guardar fechas,
Color para guardar colores, Font para guardar tipos de fuente o letra,
VentanaHora para guardar una ventana especial que hereda todo lo de
una ventana JFrame, JLabel para guardar etiquetas visuales de texto,
etc.
94
Donde nombreDeLaVariable puede ser cualquier palabra que no sea una

palabra reservada de java, ni tampoco tenga espacios, no inicie con
número y mucho menos tenga los siguientes caracteres reservados por
java ! " · % & / ( ) = ? ¿ ¡ ' ¬ # @ | \º ª<, ; > : . -
{ ] } + * ^, por ejemplo:
byte horasDelDia = 24;

byte tuEdad;
short diasDelAño = 365;
short añoActual;
int segundosDelAño = 31536000;
int numeroDeAutosEnBogota;
long segundosDelSiglo = 3153600000;
long numeroDeUsuariosFacebook;
float miAltura =1.7f;
float pesoDeUnAutoMovil;
double numeroPI = 3.14159265358979323846;
double diesEntre3;
char letraMayuscula = 'J';
char otraLetra = 's';
char simboloDePuntuacion = ':';
char letraDeLaCalificacion;
char arroba = '@';
boolean casado = false;
boolean creeEnDios = true;
boolean usaLentes;
String miNombre = "John Carlos Arrieta Arrieta";
String direccion = "Torres de la plazuela Torre 1
piso 7";
String genero = "M";
String email;
JFrame unaVentana = new JFrame( );
JFrame igualOtraVentana = unaVentana;
Date fechaActual = new Date( );
VentanaHora miVentanaEspecial = new VentanaHora(
);
Font tipoDeLetra;
JLabel etiTelefono = new JLabel("Telefono: ");
String nombres[ ] = new String[4];
95
String ciudades[ ] = {"Sincé",

"Cartagena","Pereira","Cali"};
 Toda variable se debe declarar dentro de las llaves de una clase, pero las
variables que se declaran dentro de las { } de una clase y fuera de las
{ } de una operación, se les denomina propiedades, variable miembro,
atributos de la clase o simplemente variables globales, mientras que toda
variable que se declare dentro de las { } de una operación se le
denomina variable local, y solo es visible, existe y se puede usar dentro
de las llaves de dicha operación, no fuera de ella.
 Una aplicación Java para escritorio inicia por una operación especial
denominada punto de inicio, esta operación se llama main, cuya
cabecera debe ser escrita de la siguiente manera:
public static void main( String arg[ ]) {
 La operación main se ejecuta automáticamente cuando el programa es

iniciado
 La cabecera de una clase debe llevar la palabra public siempre y cuando
su nombre es igual que el nombre del archivo donde será guardada, y la
palabra class seguida del NombreDeLaClase, por ejemplo:
public class VentanaHora
 Si una clase hereda propiedades y operaciones de otra, esta clase debe

incluir en su cabecera la palabra reservada extends justo después de su
nombre y justo después de esta palabra debe llevar el nombre de la clase
Padre, por ejemplo:
public class VentanaHora extends JFrame
 Una instrucción Java es una orden, una línea de código, un mandato a

ejecutar por el PC y cada instrucción debe terminar en ; punto y coma,
por ejemplo:
this.setTitle("Hora del PC");
96
 Las clases permiten definir y crear nuevas variables compuestas por

otras variables llamadas propiedades y operaciones llamadas métodos,
una variable creada mediante una clase se denomina variable objeto.
 Para crear un objeto es necesario invocar utilizar la palabra new segunda
de la invocación o llamada de una operación especial denominada
constructor de la clase, por ejemplo:
VentanaHora miVentana = new VentanaHora(

);
 Una variable es una referencia que permite acceder a datos almacenado

en memoria RAM del PC.
INTALACION Y CONFIGURACION DEL IDE NETBEANS
NetBeans es Software Libre, por lo cual podemos descargarlo, instalarlo cuantas

veces queramos, regalarlo, obtener y modificar su código fuente siempre y
cuando el producto resultado de dicha modificación también será software libre,
todas estas bondades están protegidas y legalizadas en su licencia, la cual es
GLP o Licencia Publica Global. A la fecha Netbeans ha madurado enormemente,
gracias a que es un producto desarrollado por un grupo relativamente grande de
programadores, diseñadores, lingüista, traductores, ingenieros, entre otra amplia
lista de varios profesionales, la metodología utilizada para su desarrollo es
conocida como el bazar, utilizada desde hace más de dos décadas en la
construcción de otros proyectos de software libre exitosamente activos y en
constate evolución hoy día, tal es el caso de GNU/Linux, PostgreSQL.
Subversion, etc. el bazar consta de reuniones abiertas en línea y a distancia,
utilizando herramientas como correos, listas de correos, chats, foros, grupos etc.
Netbeans es forma parte de un amplio grupo de aplicaciones denominadas IDE o
Entornos Integrados de Desarrollo, se denominan así porque ofrecen una gran
cantidad utilidades y herramientas en un único entorno para desarrollar
generalmente software, pero en el mercado se encuentran IDE para el diseño de
circuitos electrónicos, producción y edición de películas, videos, animaciones en
2D y 3D, imagines y sonido, diseño de estructuras civiles como puentes,
edificios, casas, vías, etc.
Netbeans proporciona la capacidad de desarrollar software de pequeña, mediana
y gran envergadura y complejidad en más de un lenguaje como Java, PHP, C/C
97
+ + , HTML, JavaScript, CSS, SQL, XML, entre otros, integrándose con gran
facilidad motores y servidor de bases de datos, servidores web, servidores FTP,
Servidores de Correo, Servidores de Versiones y contenidos, dispositivos
móviles y emuladores móviles, etc., pero además este IDE nos permite
aumentar sus funcionalidades básicas gracias a la capacidad de integrarse
fácilmente con multitud de complementos agregados o plugins, los cuales son
módulos de software especializados, donde cada uno de ellos es desarrollado
para ofrecernos soporte y apoyo una labor específica, como por ejemplo la
edición, optimización y generación de código fuente de forma asistida o
automática, generador de instaladores y distribuidores de software, conexión y
comunicación con otros software y otro programadores en línea, etc.
Instalación del IDE NetBeans sobre el Sistema Operativo Microsoft

Windows
Para poder iniciar con la instalación del IDE Netbeans lo primero que debemos
hacer es descargarla la versión más completa desde su sitio Web oficial
http://netbeans.org/downloads/start.html?platform=windows&lang=es&option=all
Paso 1: Inicio y bienvenida del proceso de Instalación de Netbeans
Paso 2: Selección de las Opciones de Instalación, para ello se da clic en el

botón Personalizar… de la ventana anterior, como se puede observar en esta
ventana se encuentran todas las opciones que están disponibles con la
98
instalación que se descargó desde la página web oficial de Netbeans, si se

desea se puede seleccionar todas, como en este caso, o simplemente se deja
las opciones necesarias para desarrollar programas en Java, y omitiendo las
opciones de Ruby, C/C + + , Groovy y PHP, luego pulsas siguiente y aceptas los
términos de la licencia de Netbeans.
Paso 3: Se nos solicita aceptar los términos de licencia de JUnit (Software

necesario para realizar Pruebas Unitarias en Aplicaciones Java), licencia que
aceptamos y pulsamos Siguiente, solicita indicar la ruta de instalación de
Netbeans e indicar la ruta donde se encuentra instalado el JSDK (instalado en el
capítulo 2).
99
Si este último se encuentra bien instalado en el PC, el asistente de instalación de

Netbeans lo detectara automáticamente mostrándolo en el campo de JDK para
Netbeans IDE, es recomendable dejar estos valores por defecto, tal y como los
muestra la ventana del asistente.
Paso 4: Si el Paso 2 escogimos o seleccionamos instalar el Servidor de

aplicaciones GlashFish, aquí se nos presenta y solicita confirmación o cambio
de la ruta instalación del mismo es recomendable dejar los datos por defecto tal
y como aparecen en la ventana del asistente de instalación. GlashFish es el
servidor de aplicaciones utilizado por defecto en aplicaciones bajo plataforma
Java Enterprise Edition más conocido como Arquitectura Java EE. Aun que es
Open Source Oracle posee la gran mayoría de potestad o derechos para
determinar su destino, ya que Software libre no es lo mismo que Código abierto.
Paso 5: Si el Paso 2 escogimos o seleccionamos instalar el Servidor de
Aplicaciones Apache Tomcat, en esta ventana se nos presenta y solicita
confirmación o cambio de la ruta de instalación del servidor de aplicaciones
Apache Tomcat, es recomendable dejar los datos por defecto tal y como
aparecen en la ventana del asistente de instalación. Apache Tomcat es la
alternativa de Software Libre bajo licencia GPL (no es Open Source, no tiene un
máximo propietario, nos pertenece a todos), su desarrollo es liderado por una
amplia comunidad de profesionales (en especial desarrolladores) distribuidos en
todo el planeta. Tanto GlashFish como Apache Tomcat soportan y reconocen
100
aplicaciones Java para Internet, ya sea mediante el uso de tecnología

Servlet/JSP, JSF, WebServices, Web Socket, JMS, RMI, entre otras. En el paso
4 y este pulsamos en Siguiente.
Paso 7: Se presenta un resumen de los parámetros de instalación seleccionado,

con el fin de proceder a instalarlos archivos de Netbeans dentro del disco duro
del PC.
INTRODUCCION AL USO BASICO DEL IDE NETBEANS PARA CREAR

APLICACIONES JAVA
Para iniciar con el desarrollo de aplicaciones escritas en Java utilizando el IDE

Netbeans primero debemos crear un proyecto, veremos los pasos para llevar a
cabo nuestro primer proyecto en este IDE. Al iniciar el IDE desde su icono en el
menú inicio o en el escritorio, procedemos a dar clic en el icono Nuevo proyecto
de la barra de herramientas que aparece en la parte superior Izquierda de la
ventana del IDE, justo debajo de la barra de menú
101
Estos tres iconos en su orden se utilizan frecuentemente Crear un Nuevo

Archivo, Crear un Nuevo Proyecto de Aplicación y Abrir un Proyecto de
Aplicación Existente, ellos también se pueden encontrar en el Menú Archivo
Al dar clic aquí nos aparece una ventana llamada Proyecto Nuevo, tal como se
aprecia en la siguiente imagen, en esta ventana debemos seleccionar la opción
Java en la lista de categorías, y luego la opción Java Aplicación en la lista de
Proyectos, hecho esto procedemos a dar clic en el botón siguiente:
Luego nos aparece una ventana llamada Nueva Aplicación Java
102
1). En esta ventana debemos indicar el Nombre del Proyecto (no puede tener
espacios, no puede tener caracteres especiales, si puede tener numero pero no
puede tenerlos al inicio, puede tener cualquier combinación de letras y números)
el cual debe ser coherente con el objetivo del proyecto.
2). Por defecto un proyecto de software hecho con el IDE NetBeans se guarda
en una carpeta llamada NetBeansProyects, pero si lo deseamos podemos
elegir otra carpeta se puede elegir otra carpeta.
3). Cuando se crea un proyecto de software NetBeans crea una carpeta con el
mismo nombre del proyecto y dentro de dicha carpeta crea una serie de
directorios y archivos que conforman la estructura de proyecto en sí mismo.
Todo proyecto de software Java que vaya a ser utilizado como aplicación del
escritorio Windows, GNU/Linux, Mac OSx, Solaris o cualquier otro sistema
operativo para PC, debe tener un archivo que contenga el código por donde
inicia o comienza la ejecución del programa, NetBeans puede crear
automáticamente dicho archivo en una carpeta cuyo nombre es igual al nombre
del proyecto, este archivo es el que contiene el punto de inicio o ejecución, el
cual corresponde al método main (visto en el capítulo 2). Antes de iniciar
necesitamos establecer algunas convenciones o acuerdos:
 En este libro todos los ejemplos de proyecto Java tendrá una clase
llamada 4). Principal, la cual contendrá el método main o punto de
inicio de la aplicación.
 A las carpetas donde guardamos los archivos que contienen el código
Java de nuestros programas las llamaremos Paquetes.
 Al primer paquete donde se guardan el resto de paquetes de nuestro
proyecto, lo llamaremos Paquete Raíz.
 Todos los proyectos los guardaremos en la carpeta por defecto de
Netbeans llamada NetbeansProyects.
 Todos los paquetes, variables y métodos estarán escritos en letra
minúscula
 Si el nombre de un paquete, variable, método o clase tiene varias
palabras, solo la primera letra de cada palabra debe iniciar con letra
103
Mayúscula y estas palabras deben estar unidas sin espacios, ni guion de

piso.
 Solo el nombre de las clases debe iniciar con letra Mayúscula, los
paquetes, métodos y variables deben iniciar con letra minúscula.
Ingresados los anteriores datos procedemos a dar clic en el botón Finalizar.
Ahora el IDE nos genera un entorno de trabajo con todo lo necesario para poder
construir nuestro Software escrito en Java, algunas de las zonas más
importantes con las que contamos en el IDE son:
El Panel Del Proyecto
1). Corresponde el
nombre del proyecto al
mismo tiempo que a
su carpeta donde esta
guardado
2). Es el paquete Raiz,
1 generalmente todos
los archivos de código
fuente del proyecto los
2 ubiamos dentro de
este paquete
3 3). Es la clase Punto
4 de Inicio, la que
contiene el mentodo
5 main.
4). Corresponde a la carpeta libo, en la cual colocamos todas las librerías o

bibliotecas de clases externas que debe llevar nuestro proyecto, algunas son
utilerías que realizan acciones específicas previamente programadas y nosotros
simplemente las reutilizamos para evitar reprogramas, así ganamos tiempo extra
para terminar en menos tiempo nuestra aplicación.
5). Es la librería o biblioteca de clases base o núcleo de JDK en su versión 1.7
104
El Panel para Editar el Código
1). El panel de Edición de Código Fuente: En este panel podemos realizar un

amplio número de operaciones que nos facilitan en gran medida la escritura y
depuración de código Fuente Java para nuestra aplicación. Para acceder a este
panel debemos ir al Panel de Proyectos y dar doble clic en el archivo que
queremos editar y luego en SORUCE o Fuente (Ubicado en la parte superior
izquierda de la anterior imagen).
2). Es el código Fuente de la clase Principal, observemos y recordemos lo visto

en el capítulo 2, se pueden observar los elementos más importantes de la clase.
El Panel para Navegar en el 1). Es el Panel de navegacion, en el cual

Código podemos navegar y movernos entre las
diferentes partes de la clase sobre la
1 cual estemos trabajando.
2 2). Es la clase como tal. 3). Es uno de
3 los miembros de la clase, en este caso el
método main
4). Cada botón muestra u oculta del
4 panel un miembreo especifico de la clase
105
El Panel de Propiedades
1). El Panel de propiedades se

1 encuentra el borde derecho de
la ventana de Netbeans y con el
podemos establecer el valor de
las propiedades de lo que
tengamos seleccionado en el
panel de diseño o de edición de
código
El Panel de Propiedades consta

de dos columnas, la primera
contiene el nombre de las
propiedades y la segunda
contiene el respectivo valor de
cada propiedad
La barra de Herramientas para Compilar, Ejecutar o generar el Ejecutable
1 2 3 4
1). Es el botón para construir el archivo ejecutable del proyecto
2). Tiene el mismo objetivo del primero, pero la diferencia es que el segundo
borra o elimina todos los ejecutables creados anteriormente y en su lugar genera
uno archivo ejecutable nuevo.
3). Se utiliza para Ejecutar o probar el funcionamiento de nuestro programa.
4). Se utiliza para compilar (depurar línea a línea el código fuente) de nuestro
programa, si en el proceso se encuentra algún error de sintaxis en el código
fuente, el proceso suspende la compilación (generación de archivos de código
ejecutable o binario) mostrando mensajes que explican y detallan las líneas
donde se encontraron los errores, las posibles causas y unas cuantas
alternativas para darles solución, esta información se puede apreciar en el Panel
de Salida ubicado en la parte inferior de la ventana del IDE
106
Panel de Salida (Depuración)

1). En este panel
podemos apreciar los
generados durante el
proceso de compilación
1 del programa, en este
ejemplo podemos ver
que todo ha salido bien
INTRODUCCION A LA ENTRADA Y SALIDA DE DATOS
En esta sección aprenderemos algunas de las técnicas disponibles más

comunes para introducir datos por teclado en una aplicación escrita en lenguaje
Java, entre las que se encuentran las siguientes:
 Introducir datos por consola
 Introducir datos usando Componentes de Interfaz Imagen de Usuario
(GUI), tales como Campos de Texto, Cajas de Texto, Campos de
Password y Ventanas de Opcionales.
También aprenderemos otros temas como declaraciones de variables y sus tipos

de datos, Castin o conversión de variables de un tipo de dato especifico a otros
tipo de dato diferente pero compatible, además, en el transcurso de cada
sección iremos familiarizándonos cada vez más con temas básicos como el
diseño y definición de clases, creación de objetos, definir e invocar o llamar
operaciones (sinónimo de funciones y métodos), captura y manejo de eventos
generados por el teclado, el ratón, trabajar con ventas, etc.
Iniciamos esta sección de aprendizaje para desarrollar programas en Java
contextualizándonos sobre el tipo de ejercicios que vamos a realizar, los cuales
tienen como objetivo principal facilitarnos el aprendizaje de deferentes las
técnicas para trabajar con entradas de datos en nuestros programas escritos en
Java. En primer lugar vamos a realizar una primera y muy común aplicación
donde el usuario introduzca una cantidad de dinero y esta sea convertida de
Pesos a Dólares, de Pesos a Euros, esta aplicación la haremos usando la
entrada de datos por consola eligiendo el Block de Notas como IDE, tal como lo
aprendimos en la primera sección, luego la volvemos a reconstruir usando la
entrada de datos por ventanas de opciones eligiendo el Netbeasn como IDE y
por último la volveremos a reconstruir usando la entrada de campos de texto
nuevamente utilizando el IDE Netbeans, así que manos a la obra.
107
ANÁLISIS DEL PROBLEMA
Para poder tener todo muy claro, todas las piezas y elementos en orden, es
necesario hacer un breve pero necesario análisis de la situación problemita que
deseamos apoyar mediante el desarrollo de un programa, en este caso el
problema trata de realizar convertir una valor dado en pesos colombianos a su
correspondiente valor en dólares y su equivalente valor en euros, para ellos
debemos identificar tres elementos muy importantes en todo programa de
computo, estos elementos hacen referencia a los Datos de Entrada, el Proceso
a Realizar y los Datos de Salida.
Datos de Entrada:
Corresponden a todos aquellos datos o información que el programa requiere del
exterior, para poder realizar sus operaciones, esta información generalmente es
introducida atreves de un teclado, el ratón, una cámara, un escáner, un medio de
almacenamiento, desde la conexión de red, un escáner de huella dactilar, etc.
En nuestro ejemplo el único dato de entrada que requerimos es la cifra en pesos
colombianos sobre la cual deseamos calcular su equivalencia a dólares o a
euros.
Procesos a Realizar:
Corresponden a todas aquellas operaciones, procedimientos, cálculos,
actividades o tareas que debe realizar el programa con los datos de entrada, con
el fin de obtener un resultado y lograr su objetivo, en nuestro ejemplo el proceso
no es otra cosa que realizar los cálculos matemáticos necesarios para poder
convertir un valor en pesos a su equivalente en dólares y su equivalente euros,
esto se hace mediante el uso de una regla de tres simple:
Si a la fecha $1801 pesos equivale a $1 Dólar, entonces ¿X cantidad de pesos a
cuantos Dólares equivale?, simplificado quedaría así:
CO $1801 = UD $1
CO $X = UD $?
Despejando quedaría así: UD $? = (CO $X * UD $1) / CO $1801

Podemos dar nombres más simples a las variables de la anterior ecuación, como
por ejemplo:
108
UD $? La llamamos como valorEnDolareResultante

CO $X La llamamos como valorEnPososConocido
CO $1801 La llamamos unDolarEquivalenciaEnPesos
Entonces la ecuación se podría escribir así:
unDolarEquivalenciaEnPesos = 1801
valorEnDolareResultante =(valorEnPososConocido*1)/
unDolarEquivalenciaEnPesos
Lo cual sería lo mismo que:
valorEnDolareResultante = valorEnPososConocido /
unDolarEquivalenciaEnPesos
Para el caso de conversión de pesos a euros el proceso es similar al

anterior, el resultado nos daría una ecuación como la siguiente:
unEuroEquivalenciaEnPesos = 2331
valorEnEurosResultante = valorEnPesosConocido / unEuroEquivalenciaEnPesos
Datos de Salida:
Corresponden a todos aquellos datos o información que el programa envía hacia
el exterior, como producto del resultado sus operaciones, esta información
generalmente es enviada hacia una pantalla, una impresora, parlantes, un medio
de almacenamiento, o hacia la conexión de red, etc. En nuestro ejemplo los
datos de salida son las variables valorEnDolareResultante y
valorEnEurosResultante, la primera contiene información el resultado de
convertir x cantidad conocida de Pesos a dólares, y la segunda el resultado en
euros.
Observemos que hemos hecho un análisis del problema, lo hemos dividido en
problemas más simples para poder comprender mejor cada una sus partes y
poder tener así una visión más clara de toda la situación.
La técnica más utilizada en ingeniería para poder resolver un problema consiste
en analizarlo detalladamente dividiéndolo en problemas más pequeños y simples
de resolver, si alguno de estos subproblemas no lo podemos comprender muy
109
bien, entonces lo subdividimos en problemas más pequeños que podamos

resolver con mayor facilidad, cuando tengamos todos los subproblemas
resueltos, entonces podemos decir con seguridad que tenemos una solución
general, partiendo de soluciones pequeñas. A esta técnica se le conoce como
divide y vencerás. Si plasmamos un algoritmo grafico de los pasos que
debemos realizar para resolver según nuestro análisis, podríamos obtener un
diagrama de flujo como el siguiente:
Imagen: Algoritmo en Diagrama de Flujos para el problema del ejemplo
110
Los bloques con una flechita hacia adentro, significan Datos de Entrada,
mientras que los bloques con una flechita hacia afuera significan Datos de Salida
y los bloques que carecen de fecha significan Procesos, los cuales pueden ser
declaraciones e inicializaciones de variables, cálculos matemáticos, etc.
Si estos pasos los representamos en un lenguaje más simple como el de
Pseudocódigo, del cual podríamos obtener un algoritmo como el siguiente:
Imagen: Algoritmo en Seudocódigo para el problema del ConvertidorDeMoneda.
Al e llevarlo a la práctica y utilizarlo en un PC podríamos obtener el siguiente

programa:
111
Imagen: Salida al Ejecutar e incluir datos en el Algoritmo del

ConvertidorDeMoneda
Observemos que primero declaramos las variables que vamos a utilizar, luego
mostramos un mensaje de salida por pantalla, seguidamente leemos o
capturamos los Datos de Entrada por teclado, luego realizamos el Proceso, es
decir los cálculos necesario con los datos de entrada y mostramos la información
resultantes como Datos de Salida utilizando un mensajes en la pantalla. Ahora
nuestro próximo paso será codificar el algoritmo en lenguaje de programación
Java. Para comenzar a escribir el programa en java utilizando el block de notas
como IDE, es importante consultar la primera sección, pues asumo que ya lo
han hecho, procedemos a realizar los siguientes pasos:
1. Crear una carpeta llamada por ejemplo convertidor_de_moneda.
2. Asignar la ruta de la carpeta en la variable de entorno CLASSPATH
3. crear un archivo de código fuente llamado por ejemplo
ConvertidorDeMoneda.java
4. Abrir el archivo de código fuente y escribir y guardar el siguiente código
Java:
/**
* @author JohnArrieta-PC
* ConvertidorDeMoneda.java
*/
// IMPORTAMOS LAS CLASES NECESARIAS

import java.util.Scanner;
// ESTA ES LA CABECERA DE LA CLASE

public class ConvertidorDeMoneda {
// OPERACION PARA REALUZAR EL PROCESO DE CONVERSION

public void convertir( ) {
// DECLARAMOS LAS VARIABLES NECESARIAS

float valorEnPesosConocido = 0.0f;
float valorEnDolareResultante = 0.0f;
float unDolarEquivalenciaEnPesos = 1801.0f;
112
float valorEnEuroResultante = 0;
float unEuroEquivalenciaEnPesos = 2331.0f;
// PREPARAR LA ENTRADA DE DATOS DESDE EL TECLADO

Scanner entrada = new Scanner(System.in);
// MOSTRAR SALIDA POR PANTALLA

System.out.println("Ingrese el valor a convertir en Dolares y Euros");
//CAPTURAR ENTRASA POR TECLADO

valorEnPesosConocido = entrada.nextFloat( );
// REALIZAR EL PROCESO O LOS CALCULOS

valorEnDolareResultante = valorEnPesosConocido / unDolarEquivalenciaEnPesos;
valorEnEuroResultante = valorEnPesosConocido / unEuroEquivalenciaEnPesos;
//MOSTRAR LA SALIDA O RESULTADOS POR PANTALLA

System.out.println("CO$ " + valorEnPesosConocido + " --> USD$ " +
valorEnDolareResultante);
System.out.println("CO$ " + valorEnPesosConocido + " --> EUR$ " +
valorEnEuroResultante);
// CERRAMOS LA ENTRADA DE DATOS POR TECLADO
entrada.close( );
}
// PUNTO DE INICIO DEL PROGRAMA

public static void main(String arg[ ]) {
// CREAMOS UNA INSTANCIA U OBJETO DE LA CLASE

ConvertidorDeMoneda convertidor = new ConvertidorDeMoneda( );
// USAMOS LA INSTANCIA PARA INVOCAR SU METODO convertir

convertidor.convertir( );
}
}
113
5. Crear un archivo para compilar el código fuente

ConvertidorDeMoneda.java y lo compilamos
6. Crear un archivo para ejecutar el código dentro del archivo llamado

ConvertidorDeMoneda.class, el cual se genera después del proceso
satisfactorio de compilación
7. Si todo va bien, tal como lo vimos en la sección 1, deberíamos tener una
carpeta llamada convertidor_de_moneda con los siguientes archivos en
su interior:
8. Al ejecutar el programa deberíamos ver una ventana de consola D.O.S

como la que se muestra a continuación:
Imagen: Salida al Ejecutar e incluir datos en el Programa Java del

ConvertidorDeMoneda
114
Si no podemos llegar a este punto las razones pueden ser:

 Se debe realizar bien los pasos descritos en al Capítulo 3 para poder
realizarlos en esta sección.
 Escribir el código fuente de este ejemplo exactamente igual como aquí se
presenta
ANALICEMOS UN POCO EL CÓDIGO FUENTE:

Observemos algunos conceptos previamente aprendidos sobre una clase Java:
La clase es pública y se llama ConvertidorDeMoneda, por ende el archivo se
debe llamar igual ConvertidorDeMoneda.java
La clase ConvertidorDeMoneda importa la clase Scanner del paquete
java.util con el fin de reutilizara dentro del código de la clase
ConvertidorDeMoneda, la clase Scanner se utiliza para capturar datos de
entrada provenientes de varias fuentes como por ejemplo el teclado, un archivo
en el disco u otro medio de almacenamiento, desde una escáner de códigos de
barra, etc.
La clase ConvertidorDeMoneda no hereda explícitamente de ninguna otra
clase, por ende implícitamente es hija de la clase Object del paquete
java.langh.
La clase ConvertidorDeMoneda no posee propiedades pero si posee dos
operaciones, una llamada convertir y la otra es el PUNTO DE INICIO del
programa, es decir la operación main
La operación o método convertir no recibe parámetros pues sus ( ) están
vacíos, tampoco retorna ningún tipo de valor, por eso se coloca la palabra
reservada void.
En el cuerpo de la operación convertir se declaran 5 variables, lo que las hace

accesibles o utilizables solo y únicamente dentro del cuerpo de la operación
convertir, es decir, son Variable Locales de la operación convertir estas
variables son todas de tipo flota, es decir, solo pueden almacenar valores
numéricos decimales, ósea los que llevan punto:
// Declarar las variables necesarias de tipo decimal

115
Observemos que la palabra float está en minúscula y siempre debe utilizarse
antes del nombre de la variable que deseamos declarar como decimal.
Notemos que al declarar una variable local (las que se declaran dentro del
cuerpo de una operación y no fuera de ellas) siempre debemos asignarles un
valor, en este caso, como la variable es float debemos asignarle un valor
decimar terminado en letra f minúscula, por ejemplo 0.0f para indicar 0.0, o por
ejemplo 1801.0f, para indicar en este caso que el valor es 1801.0 para el
caso.
Recordemos que los nombres de las variables, de las operaciones y de las
clases no pueden tener espacios en blanco, no pueden tener ninguno de los
siguientes caracteres especiales ! " · % & / ( ) = ? ¿ ¡ ' ¬ # @ | \º
ª<, ; > : . - { ] } + * ^ y tampoco puede iniciar con número, pero si
los puede en cualquier cantidad y en cualquier parte menos al comienzo.
Los Datos de Salidas por consola, es decir por pantalla del D.O.S de Windows o
Terminal de GNU/Linux, se realizan utilizando la clase System del paquete
java.lang invocando su propiedad out, invocando a la vez su operación
println( String mensaje), la cual recibe como parámetro un literal de texto o
una variable de texto de tipo String, tal como se aprecia a continuación:
System.out.println( "Ingrese el valor a convertir en Dólares y Euros" );

Una técnica para capturar los Datos de Entrada por consola es utilizar un objeto
de la clase Scanner, el cual se construye invocando su constructor y pasándole
como parámetro la propiedad in de la clase System, la propiedad in contiene
información sobre el flujo de entrada de byte estándar, es decir el teclado.
Capturar el próximo dato de tipo float, es decir un numero decimal introducido

por el teclado, esto se hace invocando la operación nextFloat( );
116
Cerrar el flujo de Datos de Entrada, esto se hace invocando la operación close(

) de la clase Scanner
entrada.close( );
Realizar los cálculos matemáticos para obtener la conversión de pesos a dólares

y de pesos a euros.
unDolarEquivalenciaEnPesos = valorEnPesosConocido /
unDolarEquivalenciaEnPesos;
Enviar los Datos de Salida hacia la pantalla, mediante el flujo de salida estándar,
ósea la pantalla, esto lo hacemos invocando la operación println( String
datos) de la propiedad out de la clase System.Por último definimos la
operación o método que funciona como PUNTO DE INICIO, es decir la operación
especial main, la cual se ejecuta automática al ejecutar el programa.
public static void main( String arg[ ])

{
// crear un objeto de la clase ConvertidorDeMoneda
// invocar la operacion para convertir
}
Observemos que dentro del cuerpo del método main primero declaramos una
variable llamada convertidor de tipo ConvertidorDeMoneda, a la cual se
asignamos un nuevo objeto creado con el constructor de esta misma clase, luego
utilizamos la variable objeto convertidor para invocar al método u operación
convertir( ), llamada que ejecuta todo el código que está definido dentro del
cuerpo de dicha operación.
Para probar nuestro programa damos clic en el archivo Ejecutar.bat, e

introducimos un valor por ejemplo $70000 damos enter entonces veremos la
siguiente imagen:
117
Es notable el inconveniente limitante que posee el programa en esta primera

versión, en la cual cada vez que deseamos realizar otro calculo debemos
nuevamente ejecutar el programa, dado que al llegar a las instrucciones de
salida en la que se presenta el resultado por pantalla, el no existen más
instrucciones que ejecutar y termina. Veamos otra prueba con el valor $590000:
Vamos a agregar un ciclo de tipo HACER HASTA QUE o do { } while como se

le conoce en Java, de tal manera que nos permita realizar al menos un cálculo la
primera vez y después que muestre el resultado pregunte si deseamos realizar
otro nuevo cálculo, si la opción es Si, entonces volvemos a iterar (repetir el
proceso) para un nuevo cálculo. A continuación veamos el código del programa
modificado para que pueda iterar en un ciclo repetitivo el cual finaliza cuando el
usuario digite 1 como opción para finalizar. He colocado los cambios en negrita
para poder identificarlos mejor. Es importante leer los comentarios // dentro del
código:
118
/**
* @author JohnArrieta-PC
* ConvertidorDeMoneda.java
*/
// IMPORTAMOS LA CLASE Scanner para capturar datos por Teclado
import java.util.Scanner;
public class ConvertidorDeMoneda

{
// OPERACION PARA REALiZAR EL PROCESO DE CONVERSION
// DECLARAMOS ESTA VARIABLE FUERA DEL CICLO PARA QUE PERDURE SU

VALOR
int opcion = 0;

do {

System.out.println("\nIngrese el valor a convertir en Dolares y Euros");



119

System.out.println("Digite 0 para repetir\nDigite otro numero para Terminar");
// ENTRADA O CAPTURA DE LA OPCION DEL USUARIO
opcion = entrada.nextInt( );
} while (opcion == 0);
entrada.close( );
}
// operacion PUNTO DE INICIO DEL PROGRAMA

public static void main(String arg[ ]) {
// CREAMOS UNA INSTANCIA DE LA CLASE ConvertidorDeMoneda

// USAMOS LA INSTANCIA PARA INVOCAR SU METODO convetir( )

}
}
Observemos los cambios más importantes que realizamos en el código, los

cuales básicamente son:
 Dentro del cuerpo de la operación o método convertir( ) colocamos una
estructura repetitiva, cíclica o iterativa llamada REPETIR MIENTRAS QUE el
cual en Java tiene la siguiente sintaxis:
do {
// Instrucciones que se repetirán siempre que
// condición_verdadera_falsa sea evaluada como
TRUE
} while( condicion_verdadera_o_falsa );
 Dentro del cuerpo de esta estructura repetitiva colocamos el código que

deseamos sea ejecutado tantas veces como el usuario así lo desee el
usuario, pero también sacamos algunas instrucciones que queremos solo
120
sean ejecutadas una sola vez, como por ejemplo, la instrucción donde
creamos el objeto que captura los Datos de Entrada:
Y la llamada a la operación que cierra el flujo de Datos de Entrada
entrada.close( );
Esto lo hacemos así para evitar que por cada iteración, ciclo o repetición dentro
de bloque do{ } while ( Condición) tengamos que crear un nuevo
objeto Scannes y cerrar su flujo de Lectura o Datos de Entrada.
También observamos que declaramos una nueva variable local llamada opción
de tipo entero, pero lo hacemos fuera del cuerpo de la estructura repetitiva, esta
variable la utilizaremos para almacenar el numero 0 si el usuario desea volver a
repetir el proceso de conversión o cualquier otro número si el usuario terminar la
ejecución del programa. Por lo tanto, esa decisión la comprobamos en la
condición del while, siendo que si opción == 0 es verdadero el ciclo vuelve a
iniciar desde la { llave de inicio que está justo después de la palabra do hasta la
} llave de cierre que va justamente antes de la palabra while, luego se vuelve
a verificar la decisión tomada por el usuario y si es verdadera nuevamente se
realiza otro ciclo o iteración, por el contrario, si la condición que verifica opción
== 0 es falsa, entonces el ciclo termina y no se vuelven a ejecutar más
iteraciones, continuando con la ejecución de la siguiente línea o instrucción
ubicada justo después del ; punto y coma de la palabra while. Resumiendo las
partes más importantes sobre los cambios realizados al código de la operación
convertir( ) son (Leer los comentarios):
// OPERACION PARA Realizar EL PROCESO DE CONVERSION

// DECLARAMOS ESTA VARIABLE FUERA DEL CICLO PARA QUE PERDURE SU
VALOR
int opcion = 0;
do {
121

System.out.println("\nIngrese el valor a convertir en Dolares y Euros");
System.out.println("Digite 0 para repetir\nDigite otro numero para Terminar");
// ENTRADA O CAPTURA DE LA OPCION DEL USUARIO
opcion = entrada.nextInt( );
} while (opcion == 0);
entrada.close( );
}
Cada vez que se ejecuta el código de la operación convertir, el programa entra al

bloque o cuerpo { } del do... while, lo cual nos permite realizar una primera
conversión, luego de enviar por Datos de Salida el resultado de la primera
conversión, muestra por Datos de Salida dos mensajes, uno para decir que 0
para repetir y cualquier otro número para terminar, dato que es capturado
por opción = entrada.nextFloat( ); y seguidamente preguntamos si la
opción digitada es igual (con los ==) a 0, entonces volvemos a repetir el
cuerpo del do... while.
Si damos doble clic sobre el archivo ejecutar podemos probar nuestro programa
y según los Datos de Entrada que le ingresemos, podremos una ventana más o
menos parecida a la siguiente:
122
Imagen: Salida al Ejecutar e incluir datos en el Programa Java del

ConvertidorDeMoneda modificado para que pueda iterar las veces que el usuario lo
desee.
CAPTURA DE DATOS DE ENTRADA Y DE SALIDA MEDIANTE VENTANAS DE OPCION O DE

NOTIFICACION.
A continuación veremos las instrucciones necesarias para capturar los Datos de

Entrada utilizando Ventanas de Opción, las cuales podemos manipular mediante
operaciones y propiedades de la clase JOptionPane.
A continuación se presentan el código del programa ConvertidorDeMoneda pero

esta vez esta modificado para permitir que el usuario pueda ingresar los datos
más cómodamente usando ventanas, observemos que es muy poco lo que
cambia, incluso ahora parece ser más corto, he colocado en negrita las únicas
123
líneas que fueron agregadas como reemplazo a las instrucciones de captura de

datos por teclado y muestra de mensajes por pantalla D.O.S:
import javax.swing.JOptionPane;
public class ConvertidorDeMoneda2

{
// operación para realizar la converion al menos una vez

int opcion = 0;
// INICIAMOS LAS ITERACIONES O CLICLOS, EL PRIMERO SIEMPRE SE
REALIZA
do
{
// declarar las variables necesarias de tipo decimal
// Enviar un mensaje de salida por pantalla en una ventana emergente

// Que al mismo tiempo solicita introducir un dato
String valor = JOptionPane.showInputDialog( null, "Digite el Valor a converir:" );
// La informacion que retorna el mentodo showInputDialog esta en formato texto

// aunque lo que se intruduzca sea números y debemos convertir al tipo de numero
que
// deseamos en este caso float, eso se realiza mediante el método parseFloat
valorEnPesosConocido = Float.parseFloat( valor );
// Realiar los calculos

valorEnDolareResultante = valorEnPesosConocido /
124
// Pegamos en una sola variable de tipo Cadena de Texto o String toda la

informacion
// a mostrar en la ventanan, observemos la importancia de las “ “ y el operador +
String resultado = "CO$ " + valorEnPesosConocido +
" = USD$ " + valorEnDolareResultante + "\n" +
"CO$ " + valorEnPesosConocido + " = EUR$ " +
valorEnEuroResultante;
// Enviar el resultado como Datos de Salida en una ventana emergente

JOptionPane.showMessageDialog(null, resultado ) ;
// Enviar un mensaje como Dato de Salida y

// capturar una de dos Opciones Seleccionadas como Datos de Entrada
opcion = JOptionPane.showConfirmDialog(null, "¿Dese Continuar?",

"Menu", JOptionPane.YES_NO_OPTION);
}
while(opcion == JOptionPane.YES_OPTION);
}
// operacion PUNTO DE INICIO DEL PROGRAMA

{
// crear un objeto de la clase ConvertidorDeMoneda
ConvertidorDeMoneda2 convertidor = new ConvertidorDeMoneda2( );
// invocar la operacion para convertir

}
}
Observemos y analicemos el código de la clase ConvertidorDeMoneda2

modificado para que la captura de Datos de Entrada y Datos de Salida podamos
realizarla mediante el uso de ventanas de Opción, podemos notar breves
cambios sobre todo en las instrucciones que solicitan el valor a convertir, la
opción del menú para repetir o continuar y las instrucciones que envían el
resultado por pantalla, así como la que muestra el menú.
125
Todas utilizan operaciones de la clase JOptionPane, clase que fue

especialmente diseñada para que podamos trabajar con un conjunto predefinido
y configurable de ventanas emergentes tipo, Mensaje de Alerta, Mensaje de
Error, Mensaje de Pregunta o decisión, Mensaje Informativo, Mensaje
Entrada de Datos.
Veamos las instrucciones más importantes:
Importamos la clase JOptionPane del paquete javax.swing con el fin de

reutilizar sus propiedades y operaciones dentro del cuerpo de nuestra clase
ConvertidorDeMoneda2.
public class ConvertidorDeMoneda2

{
// aquí va el cuerpo de la clase
}
Aquí definimos la clase ConvertidorDeMoneda2
public void convertir( )

{
// aquí va el cuerpo de la operación o métod
}
Aquí definimos la operación convertir, la cual es pública, no retorna ningún tipo

de dato y no recibe parámetros.

{
// aquí va el cuerpo de la operación o método
}
126
Aquí definimos la operación PUNTO DE INICIO del programa
int opcion = 0;
Estés la primera instrucción dentro del cuerpo de la operación convertir, en

esta instrucción simplemente declaramos una variable de tipo entero llamada
opción y le asignamos como valor 0, esta variable es local, pues está declarada
dentro del cuerpo de la operación, es decir dentro de las { } de la operación o
método y no fuera de ella que sería entonces dentro de las { } de la clase. Las
variables locales solo existen o son visibles dentro del cuerpo de la operación
donde fueron declaradas, es decir, una vez finalice la ejecución del cuerpo de la
operación, automáticamente desaparecen sus variables locales y sus respectivos
valores, al igual que los parámetros de una operación, ósea las variables
declaradas en los paréntesis de la operación ( ) puesto que estas también son
variables locales.
do
{
// aquí va el cuerpo de la estructura repetitiva
// do ... while o hacer mientras que
}
while(opcion == JOptionPane.YES_OPTION);
Cada instrucción colocada dentro de las { } del cuerpo de esta estructura cíclica
o iterativa será repetida cada vez que de verdadero o true el resultado de
evaluar la expresión que está dentro de los paréntesis del while, si el resultado
de esta expresión es falso, entonces se terminan las iteraciones, o ciclos o
repeticiones del código que está dentro de las { }, por eso a esta estructura se
le conoce como Hacer (do en ingles) Mientras que (while en ingles) el valor sea
verdadero, de lo contrario no siga repitiendo.
En este caso lo que deseamos evaluar como verdadero o falso es si la opción
escogida por el usuario es igual o diferente al valor de la propiedad YES_OPTION
de la clase JOptionPane, si son iguales, es decir verdadero, entonces
vuélvenos a ejecutar las instrucciones dentro del cuerpo de do while, si no son
127
iguales, entonces se ejecutan las instrucciones siguientes o después del ; punto

y como del while ( )

En estas 5 instrucciones simplemente declaramos 5 variables locales de tipo

número float o decimal, a las cuales les asignamos un valor respecto, cuyo
objetivo lo explicamos anteriormente.
String valor = JOptionPane.showInputDialog( null, "Digite el Valor a

convertir:" );
En esta instrucción invocamos o llamamos la operación showInputDialog de

la clase JOptionPane pasándole como parámetro null o nada y un literal de
texto correspondiente al mensaje que deseamos mostrar por pantalla, el llamado
de esta operación pinta por pantalla una ventana similar a esta:
Imagen: Programa Java del ConvertidorDeMoneda mod ificado para poder capturar datos de
una manera más cómoda y agradable
La cual como vemos presenta el mensaje de texto que le pasamos como

parámetro, presenta además un campo de texto donde podemos ingresar un
Dato de Entrada, el cual es retornado el código del programa como un valor de
texto de la clase String cuando el usuario pulsa el botón con la etiqueta Aceptar,
128
en este caso dicho valor introducido lo asignamos a la variable local llamada

valor de tipo String.
El primer parámetro que recibe esta operación el componente sobre el cual

será mostrada la ventana, este componente puede ser cualquier objeto hijo de la
clase JComponent, es decir, puede ser una Ventana de tipo JFrama, JDialog,
JWindows, JInternalFrame, un panel de tipo JPanel, JDesktopPane,
JTabbedPane, JLayeredPane, JGlassPane, un campo de texto del tipo
JTextField, JPasswordField, JTextArea, JSpiner, JTextPane,
JEditorPane, JComboBox, un botón de tipo JButton, JToggleButton,
JRadioButton, JCheckBox, JSlider, una lista seleccionable de tipo JList,
una tabla de datos de tipo JTable o una etiquete de tipo JLabel. Cuando no
deseamos que la ventana de opciones sea colocada y presentada detrás de
algún componente específico, entonces le pasamos null como valor de su
primer parámetro.
El segundo parámetro que recibe esta operación es un texto ya sea de tipo

literal, es decir explícitamente y encerrado entre "", o incluido en alguna variable
de tipo String, este texto es el que será mostrado en la ventana como leyenda
del mensaje que queremos emitir cuando la ventana aparezca en la pantalla del
PC.
Existen otros parámetros recibidos por la operación showInputDialog los
cuales permitan establecer el título de la ventana de opciones, el tipo de icono
que será mostrado en la ventana y el número de botones de opciones que tendrá
dicha ventana.
valorEnPesosConocido = Float.parseFloat( valor );
Con esta instrucción estamos invocando la operación parseFloat de la clase

Float con el fin de convertir en decimal el valor ingresado desde la ventana de
Opciones, valor que asignamos a la variable valorEnPesosConocido
declarada de tipo float. Esta operación solo puede convertir en decimal valores
de texto que solo contengan números decimales, es decir solo números que
puede contener solo un punto como representación decimal, por ejemplo
"88.9", "0.0", "0.79", etc.
129
unDolarEquivalenciaEnPesos = valorEnPesosConocido /
valorEnEuroResultante = valorEnPesosConocido /
unEuroEquivalenciaEnPesos;
En estas dos instrucciones realizamos los cálculos necesarios para obtener la

cantidad equivalente a dólares y euros del valor capturado como Dato de
Entrada.
String resultado = "CO$ " + valorEnPesosConocido + " = USD$ " +

valorEnDolareResultante + "\n CO$ " + valorEnPesosConocido + " = EUR$ "
+ valorEnEuroResultante;
Esta es una sola instrucción pero los bastante larga que ocupa más de una línea,
pues observemos que tiene un solo ; punto y comal al final.
Aquí simplemente declaramos una variable local de tipo String o texto llamada
resultado, a la cual se asignamos un texto formado por partes literales (es
decir explícitamente encerado entre comillas dobles) a los cuales se le pega o
concatena (con el uso del carácter + ) el valor de las variables
valorEnPesosConocido, valorEnDolareResultante y
valorEnEuroResultante.
Explicado más detalladamente la variable resultado es inicializada con el

texto literal "CO$ " al cual se le pega el valor de la variable
valorEnPesosConocido, al cual se le concatena el literal de texto "= USD
$", al cual se le pega el valor de la variable valorEnDolareResultante, al
cual se le concatena "\n CO$ ", donde \n significa saltar a la siguiente nueva
línea, valorEnEuroResultante, al cual se le pega "= USD$" y por último se
le concatena el valor de la variable valorEnEuroResultante
JOptionPane.showMessageDialog(null, resultado ) ;
Con esta operación emitimos un Dato de Salida por pantalla mostrado en una
ventana como la que se muestra a continuación:
130
Imagen: Programa Java del ConvertidorDeMoneda modificado para poder Mostrar

datos de una manera mas cómoda y agradable
El mensaje a mostrar es pasado en el segundo parámetro, en este caso es el

texto contenido en la variable resultado declarada anteriormente como de tipo
String.
Con esta instrucción mostramos una Ventana de Opciones para confirmar o

negar una acción específica, el texto de la acción es el segundo parámetro que
le pasamos a la operación showConfirmDialog de la clase JOptionPane, el
tercer parámetro es el texto que deseamos aparezca en la barra de título de la
ventana de opciones y el cuarto parámetro es una propiedad llamada
YES_NO_OPTION de la clase JOptionPane, esta propiedad indica los botones
que utilizara el usuario para indicar su decisión.
131
Imagen: Programa Java del ConvertidorDeMoneda modificado para poder

Interactuar con el Usuario de una manera más cómoda y agradable
El resultado de dicha decisión SI o NO, lo asignamos a una variable local

llamada opción de tipo int o entero, donde 0 es NO y 1 es SI, el cual posterior
mente comparamos dentro del while con la propiedad YES_OPTION de la clase
JOptionPane, si son iguales entonces el usuario desea volver a repetir otro
cálculo de conversión de moneda colombiana a dólares y euros.
OTROS COMPONENTES DE INTERFAZ GRAFICA DE USUARIO UTILES PARA ENTRADA Y

SALIDA DE INFORMACION
A lo lardo de estos 3 capítulos hemos aprendido los pasos, técnicas, elementos y

procesos más importantes del desarrollo de un programa o aplicación para
computador, ya sea compuesta por Interfaces de usuario muy simples y
limitadas, como dotada de elementos de Interfaz Gráfica de Usuario o GUI más
sofisticados y avanzados, los cuales trataremos uno a uno en detalle en el
siguientes capitulo.
Esta sección la vamos a dedicar a explorar superficialmente cuales son esos
componentes de GUI que dan vida, flexibilidad, usabilidad y simplicidad a
nuestra aplicación. Ellos nos permiten diseñar formularios o formatos
compuestos por diversos componentes pensados para simplificar las tareas que
comúnmente realizan los Usuarios, como los Introducir y Mostrar Datos (Entrada
y Salida) en el mimo tiempo posible y con una mejor y agradable apariencia.
Existen un conjunto amplio de componentes GUI soportados por el lenguaje
Java, cada uno de ellos está representado por una clase concreta, la mayoría de
estas clases se encuentran en el paquete javax.swing y java.awt, dichos
componentes se clasifican en componentes tipo Contenedor y componentes tipo
Controles. Algunas de las clases más utilizadas para construir GUI en
aplicaciones de escritorio son:
JWindow: [Ventana en español] Es una ventana sin marco (ni bordes, ni barra
de titulo), esta ventana al igual que sus hijas poseen un contenedor en su interior
el cual permita colocarle diversidad de componentes (paneles y controles)
JFrame: [Marco en español] Es una ventana hija de JWindow, pero esta si
posee marco, el cual nos permite encogerla, estirarla, moverla, arrastrarla,
132
cerrarla, minimizarla, maximizarla, restaurarla, colocarle icono y título, es la clase

más utilizada para trabajar con ventanas en la mayoría de los proyectos Java.
Contenedor de tipo JFrame, es una

ventana
Contenedor de tipo JPanel dentro de la

ventana, contiene los Componentes que se
le colocan a la ventana
JDialog: [Dialogo en español] Es una ventana hija de JFrame con la

particularidad que no podemos maximizar, ni minimizar, ni restaurar, pero que
además, podemos colocarla sobre otra ventana de tipo JWindow, JFrame e
incluso de su mismo tipo JDialog y hacerla modal, es decir, no podemos utilizar
la ventana de atrás hasta que la ventana de tipo JDialog sea cerrada por
completo.
Contenedor de tipo JDialog, hereda o es hija de
JFrame, solo posee un botón de control, a
diferencia de JFrame que posee 3 botones de
control en la parte superior (cerrar, maximizar y
minimizar)
dentro de la ventana, contiene los
Componentes que se le Colocan a una ventana
JPanel: [Panel en español] Es una componente de tipo contenedor sobre el cual

podemos colocar cualquier cantidad y tipo de otros componentes incluyendo
otros JPanel, generalmente los objetos de tipo JPanel se colocan dentro de
Ventanas. De esta clase heredan otras clases que actúan como paneles, tal es el
caso de JTabbedPane permite trabajar con pestañas, JDesktopPane para
trabajar con paneles tipo escritorio, donde se pueden arrastrar y soltar iconos y
otros elementos, JScrollPane permite trabajar con paneles que poseen una
barra de desplazamiento vertical y otra horizontal, las cuales aparecen
automáticamente si el componente que colocamos dentro de este panel es más
grande que el mismo panel, entre otras clases.
133
Componente de tipo JFrame
Contenedor de tipo JPanel

dentro del Panel de Contenidos
de la ventana.Contenedor
Componente de tipo JPanel
JMenuBar: [Barra de Menú en español] es un componente que nos permite

trabajar con Barras de Menú, a los cuales podemos colocarle varios Menú u
objetos de la clase JMenu.
Componente de tipo JMenuBar
Componente de tipo JMenu dentro de

la barra de Menu
JMenu: [Menú en español] es un componente que nos permite colocar menús

de opciones en una barra de menú colocada en la parte superior de una ventana.
Un objeto de la clase JMenu puede contener varios items (elementos en
español) los cuales son objetos de la clase JMenuItem y submenús de la clase
JMenu,
Componente de tipo
JMenu Componente de tipo JFrama
Componente de tipo JMenuBar
Componente de tipo JMenu

Para crear un submenu
Componente de tipo
JMenuItem
134
JMenuItem: [Elemento de Menú en español] es un componente que nos permite

colocar opciones o items en los menús de nuestros programa, estas opciones
generalmente son utilizadas para iniciar una operación específica. Existen dos
clases que heredan de JMenuItem, estas clases son JRadioButtonMenuItem
y JCheckBoxMenuItem.
JTextField: [Campo de Texto en español].

Componente de tipo JLabel dentro de un
JPanel
Componente de tipo JPanel dentro
del panel de contenidos de la ventana
Componente de tipo JTextField

dentro de un JPanel
Componente de tipo JPasswordField

dentro de un JPanel
Componente de tipo JFormattedTextField

dentro de un JPanel
Es un componente que nos permite introducir Datos de Entrada al programa

mediante el uso de una pequeña cajita donde se puede ingresar texto (cualquier
cosa que se puede ingresar con el teclado) en forma lineal, es decir en una única
línea.
De esta clase heredan dos clases más, una llamada JPasswordField y
JFormattedTextField, la primera la podemos utilizar para trabajar con
campos donde podemos escribir contraseñas ocultas a la vista de la pantalla, y
la segunda nos permite trabajar con campos en los cuales podemos decidir el
formato de los Datos de Entrada que deseamos enviar a nuestra aplicación, por
ejemplo, aceptar email, fechas o números bien formados, etc.
JLabel: [Etiqueta en español] es un componente que nos permite mostrar Datos

de Salida en la pantalla del PC, estos datos pueden ser Texto o Imágenes o
ambos.
135
Componente de tipo JLabel con

Incono y Texto
JRadioButton Y JCheckBox: [Botón de Radio y Caja de Verificación en

español].
Componentes de tipo JRadioButton

dentro de un JPanel
Componentes de tipo JPanel dentro

del panel de contenidos de la ventana
Componentes de tipo
JCheckBox dentro de un JPanel
Son componentes diferentes pero heredan de la mima clase JToggleButton,

estos componentes nos permiten trabajar con botones que pueden quedar
seleccionado o no indicando que algo está activo, habilitado, seleccionado o
desactivado, deshabilitado o sin seleccionar, estos componentes puede tener o
no un texto que los describe, o una imagen, o ambos al tiempo.
Los objetos de la clase JRadioButton son muy utilizados para seleccionar una
y solo una de varias opciones de un mismo grupo, mientras que los objetos de la
clase JCheckBox se utilizan para escoger una, ninguna o varias opciones entre
de un mismo grupo, el grupo de indica con un objeto de la clase ButtonGroup,
136
grupo al cual se agregan los componentes que deseamos sean mutuamente

excluyentes, es decir que al seleccionar uno de deshabiliten los demás.
La clase ButtonGroup se utiliza simplemente para agrupar varios botones en un

único conjunto, de tal manera que estos sean mutuamente excluyentes, es decir,
que solo puede estar seleccionado uno de entre todos lo del grupo, o ninguno.
JButton y JToggleButton [Botón y Botón de Palanca en español]:
Componente de tipo JLabel dentro de un Componente de tipo JFrame

JPanel
Componente de tipo
JTextField dentro de un
JPanel
Componentes de tipo JPanel
dentro del panel de contenidos de
la ventana
Componente de tipo JButton Y otro

de tipo JToggleButton dentro de un
JPanel
Son componentes que nos permiten trabajar con botones para iniciar le
ejecución de una operación específica, JButton es uno de los componentes
más comunes en cualquier aplicación GUI, mientras que JToggleButton es
menos común pues funciona de forma similar a un JRadioButton o un
JCheckBox, pues si este es pulsado queda hundido hasta que se vuelva
presionar nuevamente para que vuelva a su estado normal.
Es muy común verlo en aplicaciones como ofimáticas como por ejemplo el botón
de la Negrita, el de la Cursiva y el Subrayado, los cuales al ser presionado
quedan hundidos indicando que su respectiva operación está activa.
JComboBox: [Caja Combinada en español].
137
Componentes de tipo JLabel dentro de un JPanel

dentro de un JPanel
dentro del panel de contenidos de
la ventana
Componente de tipo
JPasswordField dentro de un
JPanel
Componente de tipo JComboBox dentro
de un JPanel
Es un componente que nos permite trabar un botón de opciones las cuales se

pueden seleccionar o escoger de forma combinada, dependiendo de si está o no
activada la opción MULTIPLE_INTERVAL del objeto JComboBox, para
seleccionar más de una opción se da clic en las opciones deseadas mientras al
mismo tiempo se mantiene pulsada la tecla Shif del PC, este componente es
muy útil en el caso de que tengamos un amplio número de opciones para
escoger y no queramos hacerlo utilizando JRadioButton o JCheckBox, ya que
el JComboBox mantiene oculta la lista de opciones o Items y solo son visibles si
damos clic en él.
JList: [Lista en español].
Componente de tipo JPanel dentro del panel

de contenidos de l JFrame
Componente de tipo JScrollPaneMdentro de
un JPanel
Componente de tipo JList dentro de un

JScrollPane
138
Es un componente similar al JComboBox, la diferencia principal radica en que un

JList oculta parcialmente lista de opciones, no de forma completa, por lo tanto
no tiene el efecto de desplegar hacia abajo la lista de item, pues el programador
elige cuantas opciones de la lista serán visibles en el JList, el resto de opciones
ocultas puede ser visibles pulsando las flechas de dirección arriba y abajo, o
dando clic en la barra de desplazamiento, generalmente un JList es agregado
a un contenedor de tipo JScrollPane para que este coloque de forma
automática las barras de desplazamiento verticales y horizontales en caso de
que la lista tenga más item que los que está visualizando.
JTextArea: [Área de Texto en español] este componente es similar al

componente JTextField, en el sentido que nos permite introducir como Datos
de Entrada todo el texto que nos permita el teclado, la diferencia es que el
JTextArea nos permite hacerlo en varias líneas y no en una sola como lo hace
el Campo de Texto, generalmente este componente es colocado dentro un
JScrollPane para que este active de forma automática la barra de
desplazamiento vertical y la barra de desplazamiento Horizontal, en caso de que
el usuario escriba más líneas de texto de las que son visibles en la pantalla.
Componente de tipo
JFrame
Componente de tipo JPanel dentro del
panel de contenidos de l JFrame
Componente de tipo JScrollPane

dentro de un JPanel
Componente de tipo JTextArea
dentro de un JScrollPane
JTable: [Tabla en español] es uno de los componentes más sofisticados que

posee el paquete java.swing del JDK, es una tabla compuesta por cabecera,
filas, columnas y celdas, en las cuales se pueden ingresar o mostrar información
estructurada por ejemplo proveniente de una base de datos, se debe colocar
dentro de un JScrollPane
139
Componente de tipo JPanel dentro

del panel de contenidos de l JFrame
Componente de tipo JScrollPane dentro

de un JPanel
Componente de tipo JTable dentro de
un JScrollPane
Componente de tipo JLabel dentro de
un JPanel
JSpinner, JSlider y JProgressBar: [Marcador, Deslizador y Barra de Progreso

en español] son componentes utilizados para indicar metas y datos de precisión,
los tres trabajan con un rango de valores que van desde un dato inicial, un dato
actual y un dato final.
Componentes de tipo JLabel
dentro de un JPanel Componente de tipo JFrame
Componente de tipo JPanel dentro del

panel de contenidos de l JFrame
Componente de tipo JSpinner dentro
de un JPanel
Componente de tipo JSlider dentro de
un JPanel
Componente de tipo JProgressBar dentro
de un JPanel
JTree: [Árbol en español].

Componente de tipo JPanel dentro del panel de

contenidos de l JFrame
Componente de tipo JScrollPane dentro de un

JPanel
Componente de tipo JTre dentro de un

JScrollPane
140
Es un componente que nos permite trabajar con elementos cuya estructura es

jerárquica, en forma de árbol, iniciando por un único elemento llamado Nodo
Raíz, el cual puede tener varios Nodos hijos o Ramas, y estas a su vez pueden
contener otros nodos hijos, hasta llegar a un nodo Terminal llamado u Sección.
Un uso muy común que se le da a los JTree es la representación del sistema de
directorios y archivos de un PC, donde toda la estructura inicia desde un
directorio Raíz, el cual a su vez contiene 0 o muchos directorios algunos son
subdirectorios Ramas otros son terminales u Seccións, los subdirectorios o
ramas pueden tener otros directorios y archivos terminales, generándose así una
ramificación jerárquica entre directorios y archivos.
JTabbedPane: [Panel con Pestañas en español] este componente hace parte de

los contenedores del paquete javax.swing, su clase padre es JPanel, por lo
tanto hereda todas las propiedades y operaciones protegidas por JPanel, pero
se especializa en un comportamiento particular, en realidad un JTabbedPane es
un conjunto de JPanel agrupados en un único Panel, cada JPanel posee una
pestaña con titulo desde la cual podemos ver y acceder a su contenido.
Componente de tipo Componente de tipo JFrame

JLabel dentro de un
JPanel pestaña del Componente de tipo JTabbedPane
JTabbedPane dentro del panel de contenidos del
JFrame
Como pestañas del JTabbedPane
Componente de tipo JLabel con texto e

icono dentro de un JPanel pestaña del
JTabbedPane
dentro de un JPanel pestaña del
JTabbedPane
141
JERARQUIA DE CLASE CONTENDORES GUI PARA APLICACIONES JAVA
La siguiente imagen muestra la jerarquía de clases (Clase Padre y sus Clases

Hijas) que conforman los componentes de interfaz Gráfica más populares y útiles
al memento de desarrollar aplicaciones para PC (GNU/Linux, MS Windows y
Apple Macintosh) escritas en lenguaje de programación Java. Estas clases esta
organizadas en dos paquetes dentro del JSDK, el paquete java.awt y el paquete
javax.swing. Estas últimas prácticamente que descontinuaron a las primeras,
esto gracias su que son más funcionales, adaptables y visiblemente más
agradable e intuitivas para el usuario.
java.a
wt
javax.swi
ng
Imagen: Jerarquía de Clases para trabajar con componentes GUI
142
CAPITULO 4: WYSIWYG - LO QUE VES ES LO QUE OBTIENES
COMPONENTES GUI DE TIPO BOTONES DE ESTADO (JToggleButton, JCkeckBox y

JRadioButton)
Los botones de estado son objetos o elementos de Interfaz Gráfica tipo Botón
que al ser pulsados quedan en dicho estado (seleccionado) y vuelven al estado
normal (no seleccionados) cuando el usuario los vuelve a pulsar.
Java proporciona tres clases para trabajar con botones de estado, estas son
JToggleButton (Botón de Palanca), JCkeckBox (Caja o casilla de Verificación)
y JRadioButton (Botón de Radio), los objetos o instancias de estas clases
poseen métodos propios pero en su mayoría son heredados de desde la clase
AbstractButton que a su vez los hereda de JComponent.
Los métodos más utilizados al trabajar con estos objetos son:
Nombre Parámetro Retorno Descripción

isSelected Ninguno Booleano Devuelve verdadero (true) si
el botón esta seleccionado y
falso (false) en caso contrario
setSelected Boolean Ninguno Si recibe un parámetro
verdadero el botón será
seleccionado, y
deseleccionado si recibe falso
addActionListener ActionListener Ninguno Agrega un Oyente de Acción
al botón escuchar los eventos
del clic que suceden sobre el
botón cuando este sea o no
seleccionado.
setIcon ImageIcon Ninguno Agrega un icono al botón
setText String Ninguno Agrega una etiqueta de texto
sobre el botón
getText Ninguno String Devuelve el texto sobre el
botón
updateUI Ninguno Ninguno Actualiza los cambios hechos
143
TRABAJAR CON CUADROS DE VERIFICACIÓN:
Los Cuadros de Verificación son instancias de la clase JCheckBox cuyas

instancias son objetos de Interfaz gráfica, los cuales se utilizan para ofrecer al
usuario un grupo pequeño de opciones permitiéndole escoger una, varias o
ningún.
El siguiente ejemplo nos presenta los pasos básicos para trabajar con
JCkeckBox, el programa de este ejemplo será como el que se muestra en la
siguiente imagen:
1. Realiza un nuevo proyecto.

2. En la ventana principal debes añadir lo siguiente:
a. Un botón “Aceptar” llamado btnAceptar.
b. Una etiqueta con borde llamada etiResultado
3. Añade también tres cuadros de verificación. Estos cuadros son objetos
del tipo JCheckBox.
144
4. Añade tres JCheckBox y cambia el texto de ellos, de forma que aparezca

“Perro”, “Gato” y “Ratón”.
5. Debe cambiar el nombre de cada uno de ellos. Se llamarán: chkPerro,
chkGato, chkRaton.
6. La ventana tendrá el siguiente aspecto cuando termine:
7. El programa debe funcionar de la siguiente forma:

Cuando el usuario pulse aceptar, en la etiqueta aparecerá un mensaje
indicando qué animales han sido “seleccionados”. Para ello hay que
programar el evento actionPerformed del botón Aceptar. En ese evento
añada el siguiente código:
String mensaje="Animales elegidos: ";
if (chkPerro.isSelected( )) {
mensaje=mensaje + "Perro ";
if (chkGato.isSelected( )) {
mensaje=mensaje + "Gato ";
if (chkRaton.isSelected( )) {
mensaje=mensaje + "Raton ";
145
etiResultado.setText(mensaje);
8. Observa el código. En él se hace lo siguiente:

a. Se crea una variable de cadena llamada mensaje.
b. En esa variable se introduce el texto “Animales elegidos: “
c. Luego, compruebo si está seleccionada la casilla de verificación
chkPerro. Si es así concateno a la cadena mensaje la palabra
“Perro”.
d. Luego compruebo si está seleccionada la casilla de verificación
chkGato y hago lo mismo.
e. Lo mismo con la casilla chkRaton.
f. Finalmente presento la cadena mensaje en la etiqueta
etiResultado.
9. Observa el método isSelected( ) propio de las casillas de verificación,
permiten saber si una casilla está activada o no.
10. Ejecute el programa. Seleccione por ejemplo las casillas Gato y Ratón. Al
pulsar Aceptar el resultado debe ser el siguiente:
TRABAJAR CON BOTONES DE RADIO
Los Botones de Opción son instancias de la clase JRadioButton cuyas

instancias son objetos de Interfaz gráfica, los cuales se utilizan para ofrecer al
usuario un grupo pequeño de opciones permitiéndole escoger una y solo una o
ninguna de ellas, se utilizan junto a otra clase llamada BotonGroup, la cual
permite agrupar las instancias de botones para que sean mutualmente
excluyentes, es decir, que al momento de seleccionar un botón del grupo el resto
no lo estará.
JRadioButton:
a. Un botón “Aceptar” llamado btnAceptar.
b. Una etiqueta con borde llamada etiResultado.
3. Añade un panel. Un panel es una zona rectangular que puede contener
elementos (botones, etiquetas, etc) La forma de poner un panel es a
través del objeto JPanel
146
4. Una vez añadido el panel en el JFrame, le pondremos un borde para

poder localizarlo fácilmente. Debes hacer lo siguiente:
a. Selecciona el panel que has añadido.
b. Activa la propiedad Border (botón con tres puntos)
c. Busca el tipo de borde llamado TitledBorder (borde con título) y
pon el título colores.
147
5. Tu ventana debe quedar más o menos así:
6. Ahora debes añadir tres botones de opción (botones de radio) dentro del
panel. Estos botones son objetos del tipo JRadioButton.
7. Añade tres JRadioButton y cambia el texto de ellos, de forma que

aparezca “Rojo”, “Verde” y “Azul”.
8. Debe cambiar el nombre de cada uno de ellos. Se llamarán: optRojo,
optVerde, optAzul.
9. La ventana tendrá el siguiente aspecto cuando termine:
148
10. Si ejecuta el programa, observará que pueden seleccionarse varios

colores a la vez. Esto no es interesante, ya que los botones de opción se
usan para activar solo una opción entre varias.
11. Hay que hacer que solo un botón de opción pueda estar seleccionado a
la vez. Para ello, debe añadir un nuevo objeto. Realice los siguientes
pasos:
a. Añada un objeto del tipo ButtonGroup al formulario. ¡Atención!
Este objeto es invisible, y no se verá en el formulario, sin
embargo, lo podréis ver en el Inspector, en la parte de “Otros
Componentes”:
b. Tienes que darle un nombre al ButtonGroup. El nombre será

“grupoColores”.
c. Ahora, hay que conseguir que los tres botones pertenezcan al
mismo grupo. Es decir, que pertenezcan al grupo
grupoColores.
149
d. Selecciona el botón de opción optRojo y cambia su propiedad

buttonGroup, indicando que pertenece al grupo colores
(observa la imagen):
e. Haz lo mismo con los botones optVerde y optAzul.
12. Acabas de asociar los tres botones de opción a un mismo grupo. Esto
produce que solo una de las tres opciones pueda estar activada.
Pruébelo ejecutando el programa.
13. Ahora interesa que la opción “Rojo” salga activada desde el principio.
Una forma de hacer esto es programando en el “Constructor” lo siguiente:
optRojo.setSelected(true);
El método setSelected hace que se pueda activar o desactivar un botón

de opción.
Prueba el programa. Observa como la opción Rojo está activada
inicialmente.
150
14. El programa no está terminado aún. Interesa que cuando el usuario pulse
el botón Aceptar, en la etiqueta aparezca el color elegido. Para ello, en el
actionPerformed del botón Aceptar programe lo siguiente:
String mensaje="Color elegido: ";
if (optRojo.isSelected( )) {
mensaje=mensaje + "Rojo";
} else if (optVerde.isSelected( )) {
mensaje=mensaje + "Verde";
} else if (optAzul.isSelected( )) {
mensaje=mensaje + "Azul";
15. Observa el código. En él se hace lo siguiente:

b. En esa variable se introduce el texto “Color elegido: “
c. Luego se comprueba que opción está seleccionada, usando el
método isSelected de los botones de opción. Este método te
dice si un botón está seleccionado o no.
d. Según la opción que esté seleccionada, se añade un texto u otro
a la cadena mensaje.
e. Finalmente se muestra la cadena mensaje en la etiqueta
etiResultado.
16. Ejecute el programa. Seleccione por ejemplo la Verde. Al pulsar Aceptar

el resultado debe ser el siguiente:
151
Es interesante que los botones de radio aparezcan dentro de un panel JPanel.

Se recomienda colocar un borde al panel.
Es totalmente necesario añadir un objeto del tipo ButtonGroup, y hacer que los
botones de radio pertenezcan a dicho grupo. En caso contrario, será posible
activar varios botones de opción a la vez.
TRABAJAR CON BOTONONES DE PALANCA (JToggleButton)
Lo Botones de Palanca son instancias u objetos de la clase JToggleButton la

cual a su vez es la clase padre de los Botones de Estado vistos anteriormente
JCheckBox y JRadioButton, pero a diferente estos los JToggleButton tienen
más apariencia de un Botón de Acción o JButton siendo que al ser pulsado
queda unidos hasta que se vuelva a pulsar.
JToggleButton:
2. Crearás una ventana como la que sigue
teniendo en cuenta lo siguiente:
a) Se añadirá una etiqueta con el texto “Precio
Base”. No hace falta cambiarle su nombre.
b) Se añadirá un cuadro de texto llamado
txtPrecioBase.
c) Se creará un botón “Calcular”, llamado
btnCalcular.
d) Se creará una etiqueta vacía y con borde
llamada etiTotal. Use la propiedad font de esta
etiqueta para hacer que el texto tenga un mayor tamaño.
152
e) Debes añadir también tres botones, con el texto “Instalación”,

“Formación” y “Alimentación BD” respectivamente.
Estos botones no son botones normales, son botones del tipo JToggleButton.
Usa este tipo de objeto para crearlos.
Estos botones, se diferencian de los
botones normales en que se quedan
pulsados cuando se hace un clic sobre
ellos, y no vuelven a su estado normal
hasta que no se vuelve a hacer clic
sobre ellos
Los tres botones se llamarán
respectivamente: tbtnInstalacion,
tbtnFormacion, tbtnAlimentacionBD.
a. Añade finalmente tres etiquetas
conteniendo los números 40, 200, 200.
La primera se llamará
etiPrecioInstalacion, la segunda
etiPrecioFormacion y la tercera etiPrecioAlimentacionBD.
3. Prueba el programa y comprueba el funcionamiento de los botones

JToggleButton:
Observa como al pulsar los

JToggledButton estos se quedan
pulsados.
Si se vuelven a activar se
“despulsan”.
Es esto se le conoce como quedar
con y sin estado.
El estado de los JToggleButton,
JCheckBox y JRadioButon se
puede saber enviando el método
isSelected() de cada instancia de
esta clases, este método retorna
true si el botón esta seleccionado o
pulsado y false en caso contrario
153
4. Se pretende que el programa funcione de la siguiente forma:

a. El usuario introducirá un precio base para el servicio que se
vende.
b. A continuación, si el cliente quiere la instalación, activará el botón
Instalación.
c. Si el cliente quiere la formación, activará el botón Formación.
d. Si el cliente quiere la Alimentación de Base de Datos, activará el
botón Alimentación BD.
e. Ten en cuenta que el cliente puede querer una o varias de las
opciones indicadas.
f. Finalmente se pulsará el botón calcular y se calculará el precio
total. Este precio se calcula de la siguiente forma:
Precio Total = Precio Base + Precio Extras.
El precio de los Extras dependerá de las opciones elegidas por el

usuario. Por ejemplo, si el usuario quiere Instalación y Formación,
los extras costarán 240 euros.
5. Así pues, se programará el actionPerformed del botón Calcular de la
siguiente forma:
double precio_base;
double precio_instal; //precio instalación
double precio_for; //precio formacion
double precio_ali; //precio alimentacion
//Recojo datos desde la ventana:
precio_base = Double.parseDouble(txtPrecioBase.getText( ));
precio_instal = Double.parseDouble(etiPrecioInstalacion.getText( ));
precio_for = Double.parseDouble(etiPrecioFormacion.getText( ));
precio_ali = Double.parseDouble(etiPrecioAlimentacionBD.getText( ));
154
//Ahora que tengo los datos, puedo hacer cálculos.
//Al precio base se le van añadiendo precio de extras
//según estén o no activados los JToggleButtons
double precio_total;
precio_total = precio_base;
if (tbtnInstalacion.isSelected( )) {
//Si se seleccionó instalación
precio_total = precio_total + precio_instal;
if (tbtnFormacion.isSelected( )) {
//Si se seleccionó formación
precio_total = precio_total + precio_for;
if (tbtnAlimentacionBD.isSelected( )) {
//Si se seleccionó Alimentación BD
precio_total = precio_total + precio_ali;
//Finalmente pongo el resultado en la etiqueta
etiTotal.setText(precio_total + " €");
6. Veamos una explicación del código:
a. Primero se crean variables doubles (ya que se admitirán

decimales) para poder hacer los cálculos.
155
b. Se extraerán los datos de la ventana y se almacenarán en dichas

variables. Para ello, hay que convertir desde cadena a double:
precio_base = Double.parseDouble(txtPrecioBase.getText( ));

precio_instal = Double.parseDouble(etiPrecioInstalacion.getText( ));
precio_for = Double.parseDouble(etiPrecioFormacion.getText( ));
precio_ali = Double.parseDouble(etiPrecioAlimentacionBD.getText( ));
c. Una vez obtenidos los datos en forma numérica, ya se pueden

hacer cálculos con ellos. El programa declara una nueva variable
precio_total donde se introducirá el resultado. En primer lugar se
introduce en esta variable el precio base.
double precio_total;
precio_total = precio_base;
A continuación se le suma al precio_total los precios de los extras

si el botón correspondiente está seleccionado. Esto se hace a
través de if. Por ejemplo, para sumar el extra por instalación:
if (tbtnInstalacion.isSelected( )) {
//Si se seleccionó instalación
precio_total = precio_total + precio_instal;
}
Esto significa: “Si el botón instalación está seleccionado, añade al

precio total el precio por instalación”
Observa el uso del método isSelected para saber si el botón
tbtnInstalacion ha sido seleccionado.
d. Finalmente el resultado se muestra en la etiqueta de total.
7. Comprueba el funcionamiento del programa…
156
Introduce una cantidad

(usa el punto para los
decimales)
Selecciona los extras que
desees.
Pulsa Calcular y obtendrás
el resultado.
8. Supongamos que normalmente (en el 90 por ciento de los casos) la

instalación es solicitada por el usuario. Podría ser interesante que el
botón Instalación ya saliera activado al ejecutarse el programa. Para ello,
añade en el Constructor la siguiente línea.
tbtnInstalacion.setSelected(true);
Esta línea usa el método setSelected para activar al botón tbtnInstalación.
Comprueba esto ejecutando el programa.
Los JToggleButton son botones que pueden quedarse pulsados. A través del
método isSelected podemos saber si un JToggleButton está seleccionado.
También puedes usar el método setSelected para seleccionar o no un botón de
este tipo. Realmente, estos botones no suelen ser muy usados, ya que pueden
ser sustituidos por Cuadros de Verificación (JCheckBox) que son más
conocidos.
LISTA Y COMBOS DE OPCIONES (JList y JComboBox)
Hay momentos en que se requiere presentar al usuario un conjunto amplio de

opciones que resulta muy difícil organizar y mostrar en la ventana de una
157
aplicación, ya que resulta visualmente inapropiado, esta situación no se puede

resolver usando grupo de Botones de estado (JToggleButton, JCheckBox y
JRadioButton) ya que generalmente se trata de abundante información y los
componentes anteriores se utilizan para presentar pocas opciones, en su lugar
Java dispone de dos clases de componentes especializados en esta tarea, esto
son JList y JComboBox, ambos componentes nos permiten manejar y mostrar
gran cantidad de opciones al usuario y este puede seleccionar una o varias de
ellas, pero no todas son visibles de forma directa, pues están ocultas y para
poder verlas se utiliza una lista de opciones que se desplaza de arriba hacia
abajo y viceversa.
Básicamente ambos componentes funcionan igual, la diferencia más importante

es que un JList permite mostrar un conjunto reducido de sus opciones,
ocultando el resto hasta que el usuario decida desplazar la lista de arriba hacia
abajo, mientras que un JComboBox
Nombre Parámetros Retorno Descripción

setSelectionBackground Color Ninguno Cambia el color
de las opciones
seleccionadas
setSelectionMode int Ninguno Cambia el modo
de selección el
cual puede ser 0
para Simple o 1
para Múltiples
setListData String[ ] Ninguno Agrega una lista
de Item u
Opciones de
datos a la lista
setModel DefaultListModel para Ninguno Agrega a la lista
JList o combo un
DefaultComboBoxModel modelo de datos
para JComboBox
getSelectedValue Ninguno Object Devuelve el
valor del ítem u
opción
seleccionada en
la JList y
158
JComboBox
getSelectedIndex Ninguno int Devuelve el
índice o posición
del ítem u opción
seleccionada en
la JList y
JComboBox
setSelectedIndex int Ninguno Selecciona la
opción en la
posición
específica de la
lista o del
Combo
addItem Object Ninguno Agrega un Item
a la lista,
generalmente el
tipo del Item es
String
TRABAJAR CON LISTAS DE OPCIONES
El siguiente ejemplo nos muestra cómo trabajar con componentes de tipo JList
usando el IDE Netbeans
1. Realiza un nuevo proyecto
2. En la ventana principal debes
añadir lo siguiente:
a. Un botón “Aceptar”
llamado btnAceptar.
b. Una etiqueta con
borde llamada etiResultado.
3. Añade un cuadro de lista. Los
cuadros de listas son objetos JList.
1. Cámbiale el nombre al JList.

Ten cuidado, ya que en los JList
aparecen siempre dentro de otro
objeto llamado jScrollPane. Si miras
en el Inspector, verás que al pulsar
159
en el botón + del jScrollPane aparecerá tu JList:

El JScrollPane es un Contenedor que se utiliza para colocar aquello
componentes que son muy grandes para poder mostrarlos en la zona de pantalla
que le asignamos, por ejemplo una imagen, una tabla, un árbol de ítems, un
panel de edición de texto, una lista, etc.
2. Aprovecha para cambiarle el nombre al JList. El nuevo nombre será

lstColores.
3. Si te fijas en el JList, consiste en un cuadro que contiene una serie de
Items. Estos elementos pueden ser cambiados a través de la propiedad
Model del JList.
4. Busca la propiedad Model y haz clic en el botón de los tres puntos.
Aparecerá un cuadro de diálogo parecido al siguiente. Solo tienes que
seleccionar los elementos que quieras y pulsar el botón “Borrar”
(Remove) para eliminarlos de la lista.
5. Puedes añadir elementos escribiéndolos en el cuadro Artículo y luego
pulsando el botón “Añadir” (Add).
160
6. Debes hacer que la lista sea la siguiente:

Rojo
Verde
Azul
7. Ahora programaremos el actionPerformed del botón Aceptar. Debes

introducir el siguiente código:
String mensaje;
mensaje="El color seleccionado es: " + lstColores.getSelectedValue( ).toString( );
8. Observa el código:
b. Y dentro de esta variable se introduce una concatenación de
cadenas.
161
c. Observa la parte: lstColores.getSelectedValue( ), esta

parte devuelve el valor seleccionado de la lista.
d. Hay que tener en cuenta que este valor no es una cadena, por
eso hay que convertirla a cadena añadiendo .toString( ).
e. De esta manera puedes extraer el elemento seleccionado de un
cuadro de lista.
f. Luego simplemente ponemos la cadena mensaje dentro de la
etiqueta.
9. Ejecuta el programa y observa su funcionamiento. Por ejemplo, si
seleccionas el color verde y pulsas aceptar el resultado será el siguiente:
10. Vamos a mejorar el programa. Puede suceder que el usuario no

seleccione ningún valor del cuadro de lista, y sería interesante en este
caso que el programa avisara de ello. Cambie el código del botón
Aceptar por este otro código:
String mensaje;
if (lstColores.getSelectedIndex( )==-1) {
mensaje="No hay un color seleccionado.";
162
} else {
mensaje="El color seleccionado es: " + lstColores.getSelectedValue( ).toString( );

a. El método getSelectedIndex me dice el índice del elemento
que está seleccionado.
b. Por ejemplo, si está seleccionado el primero el índice es 0, si está
seleccionado el segundo el índice es 1, etc.
c. Si este método devuelve -1, entonces es señal de que no hay
ningún elemento seleccionado.
d. Aprovecho esto para mostrar un mensaje indicando lo sucedido.
12. Si ejecuta el programa y pulsa el botón Aceptar sin seleccionar nada el
resultado debería ser el siguiente:
163
13. Se podría haber prescindido del botón aceptar si el código anterior se

hubiera puesto en el evento mouseClicked del cuadro de lista en vez
de en el actionPerformed del botón Aceptar. En este caso, cada vez
que se seleccionara un elemento de la lista, automáticamente aparecería
el mensaje en la etiqueta.
¿Te animas a que realice esta modificación?
El objeto JList permite crear cuadros de lista. Estos objetos contienen una
serie de elementos que pueden ser seleccionados.
A través del método getSelectedValue se puede obtener el elemento que
está seleccionado. (Recuerda convertirlo a cadena con toString)
A través del método getSelectedIndex se puede saber la posición del
elemento seleccionado. Si este índice es -1, entonces sabremos que no hay
ningún elemento seleccionado.
TRABAJAR CON MODELOS DE DATOS PARA LISTAS DE OPCIONES
El ejemplo anterior pudimos apreciar la simplicidad de trabajar con Listas de

Opciones, pero en la mayoría de los casos tendremos la necesidad de tomar control
de forma dinámica sobre los datos contenidos en la lista, ya sea para eliminar,
agregar y ordinar los Items de dicha lista, para ellos necesitamos trabajar con
instancias de la clase DefaultListModel. En el siguiente ejemplo veremos cómo
hacerlo:
1. Realiza un nuevo
proyecto.
2. En la ventana principal
debes añadir lo siguiente:
a. Una etiqueta con
borde llamada etiResultado.
3. Añade un cuadro de lista
al formulario (JList).
4. Borra todo el contenido
de la lista (propiedad model) y
cámbiale el nombre a la lista. La
lista se llamará lstNombres.
Recuerda que las listas
aparecen dentro de un objeto
del tipo JScrollPane.
164
Recuerda agregar un Item por cada línea dentro del asistente para llenar
el modelo de la lista.
No dejes líneas en blanco porque estas aparecerán en la lista como
Items en blanco.
5. Añade dos botones al formulario. Uno de ellos tendrá el texto “Curso 1” y

se llamará btnCurso1 y el otro tendrá el texto “Curso 2” y se llamará
btnCurso2.
6. En el evento actionPerformed del botón “Curso 1” programa lo

siguiente:
DefaultListModel modelo = new DefaultListModel( );
modelo.addElement("Juan");
modelo.addElement("María");
165
modelo.addElement("Luis");
lstNombres.setModel(modelo);
7. En el evento actionPerformed del botón “Curso 2” programa lo

siguiente:
DefaultListModel modelo = new DefaultListModel(

);
modelo.addElement("Ana");
modelo.addElement("Marta");
modelo.addElement("Jose");
8. Explicación de los códigos anteriores:

a. Lo que hace cada botón es rellenar el cuadro de lista con una
serie de nombres. En el caso del botón “Curso 1”, la lista se
rellena con los nombres Juan, María y Luis, mientras que en el
caso del botón “Curso 2”, la lista se rellena con los nombres Ana,
Marta y José.
b. El contenido de un cuadro de lista es lo que se denomina un
“modelo”. El “modelo” es un objeto que contiene el listado de
elementos de la lista.
c. Los modelos de las listas son objetos del tipo DefaultListModel.
d. Lo que hace el programa es crear un “modelo”. Luego rellena el
“modelo” con datos, y finalmente asocia el “modelo” al cuadro de
lista. Veamos cómo se hace todo esto.
e. Primero se crea el “modelo”, a través de la siguiente instrucción
(será necesario añadir el import correspondiente, atento a la
bombillita):
DefaultListModel modelo = new DefaultListModel( );
166
f. El “modelo” tiene un método llamado addElement que permite

introducir datos dentro de él. Así pues usamos este método para
añadir los datos al modelo.
modelo.addElement("Ana");
modelo.addElement("Marta");
modelo.addElement("José");
g. Finalmente asociamos el “modelo” creado al cuadro de lista de la

siguiente forma:
h. Así pues, aquí tienes una forma de cambiar el contenido de un

cuadro de lista desde el propio programa.
9. Prueba a ejecutar el programa. Observa como cuando pulsas cada botón

cambia el contenido de la lista:
Click y cambia el
listado.
10. Ahora añade el siguiente código al evento mouseClicked del cuadro de

lista:
167
etiResultado.setText(lstNombres.getSelectedValue( ).toString( ));
Esta instrucción hace que al seleccionar un elemento del cuadro de lista éste
aparezca en la etiqueta etiResultado. Recuerda que el método
getSelectedValue permite recoger el elemento seleccionado (hay que
convertirlo a cadena con toString)
11. Ejecuta el programa:
12. Una propuesta.

Añada un botón “Vaciar”
llamado btnVaciar. Este
botón vaciará el contenido
Click y aparece de la lista. Para esto lo
el elemento único que tiene que hacer
seleccionado en es crear un modelo y, sin
la etiqueta. introducir ningún valor en
él, asociarlo al cuadro de
lista.
Un cuadro de lista es un
objeto que contiene a su
vez otro objeto
denominado “modelo”.
El objeto “modelo” es el que realmente contiene los datos de la lista.
Cuadro de lista Modelo Datos
Se puede crear un “modelo” y luego introducir datos en él. Luego se puede

asociar ese “modelo” a la lista. De esta manera se puede cambiar el contenido
de la lista en cualquier momento.
TRABAJAR CON COMBOS DE OPCIONES
Los JComboBox o Combos de Opciones al igual que los JList nos permiten
disponer de una lista vertical de Opciones o Items, pero a diferencia de los JList
dicha lista está oculta pudiéndose desplegar o hacer visible al pulsar clic en el botón
de dicho Combo.
168
El siguiente ejemplo e ejemplo nos muestra cómo trabajar con Combos

de Opciones
1. Realiza un nuevo
proyecto.
2. En la ventana
principal debes añadir lo
siguiente:
3. Una etiqueta con
borde llamada
etiResultado.
4. Añade un cuadro
combinado (combo). Los
cuadros combinados son
objetos del tipo
JComboBox. Básicamente,
un combo es una lista desplegable.
5. Cámbiale el nombre al JComboBox. El nombre será cboColores. Tu

programa debe tener más o menos este aspecto.
La interfaz gráfica debe tener apariencia similar a la siguiente imagen,
6. Los elementos del cboColores pueden ser cambiados a través de la

propiedad Model. Selecciona el combo y activa la propiedad Model (el
botoncito con los tres puntos) Aparecerá lo siguiente:
169
7. Al igual que pasaba con los cuadros de lista, se pueden eliminar los
elementos que contiene el combo y añadir elementos propios. Use los
botones Añadir y Eliminar para añadir la siguiente lista de elementos:
Rojo
Verde
Azul
8. Ejecuta el programa y observa el funcionamiento del Combo de

Opciones.
Es importante que recuerdes agregar un Item por cada línea dentro del
asistente para llenar el modelo de la lista.
No dejes líneas en blanco porque estas aparecerán en la lista como

Items en blanco.
170
9. Vamos a hacer que cuando se elija un elemento del desplegable, en la

etiqueta aparezca un mensaje indicando el color elegido.
Para ello, debes programar el evento actionPerformed del combo y
añadir el siguiente código:
String mensaje="El color elegido es ";

mensaje=mensaje + cboColores.getSelectedItem( ).toString( );
10. Este código hace lo siguiente:
a. Crea una variable de cadena.

b. Concatena dentro de ella el mensaje “El color elegido es” con el
color seleccionado.
c. Observa el método getSelectedItem, se usa para saber el
elemento seleccionado del combo. Es necesario convertirlo a
texto con toString.
d. Finalmente se coloca el mensaje en la etiqueta.
11. Ejecuta el programa y comprueba su funcionamiento. Por ejemplo, si

elegimos el color verde, el aspecto del programa será el siguiente:
171
12. Los cuadros

combinados pueden
funcionar también como
cuadros de texto. Es
decir, pueden permitir que
se escriba texto dentro de
ellos. Para hacer esto,
basta con cambiar su
propiedad “editable” y
activarla.
Si deseamos que esta funcionalidad de Campo de texto se active en tiempo de

ejecución, debemos invocar el método:
objetoCombo.setEditable( true) ;
Donde objeto combo se debe reemplazar por el nombre de la instancia del

combo al cual queremos sea un campo editable.
13. Ejecuta el
programa y observa
cómo se puede escribir
dentro del combo. Al
pulsar Enter, el
programa funciona
igualmente con el texto
escrito.
Con un poco más de

código podemos
elaborar un Combo que
sea auto completable,
es decir que a medida
que vallamos
escribiendo en su
172
campo editable, el combo valla cargando sus ítems con palabras que coincidan,
inicien o contengan las letras que vamos digitando en su campo editable,
Este tipo de funcionalidad es muy común encontrarlas en aplicaciones
modernas, sobre todo aquellas que mejan mucha información contendía en
Bases de datos.
Los combos son listas

desplegables donde se puede
elegir una de las opciones
propuestas.
Los combos pueden funcionar
también como cuadros de
textos, si se activa la opción
Se escribe
aquí y se pulsa editable.
enter A través del método
getSelectedItem se puede
extraer la opción
seleccionada o el texto escrito
en el combo.
TRABAJAR CON MODELOS DE DATOS PARA COMBOS DE OPCIONES
El ejemplo anterior pudimos apreciar la simplicidad de trabajar con Combos de

Opciones, pero en la mayoría de los casos tendremos la necesidad de tomar
control de forma dinámica sobre los datos contenidos en la lista, ya sea para
eliminar, agregar y ordinar los Items de dicha lista, para ellos necesitamos
trabajar con instancias de la clase DefaultComboBoxModel. En el siguiente
ejemplo veremos cómo hacerlo:
a. Un combo llamado cboNumeros.

b. Un botón “Pares” llamado btnPares.
c. Un botón “Impares” llamado btnImpares.
d. Una etiqueta con borde llamada etiResu|ltado.
3. Elimina todos los elementos que contenga el combo. Recuerda, debes

usar la propiedad “model” del combo para cambiar sus elementos.
173
4. Después de haber hecho todo esto, tu ventana debe quedar más o

menos así:
5. En el evento actionPerformed del botón Pares, programa lo siguiente:
int i;
DefaultComboBoxModel modelo = new DefaultComboBoxModel(

);
for (i=0;i<10;i+=2) {
modelo.addElement("Nº " + i);
cboNumeros.setModel(modelo);
6. Observa lo que hace este código:

a. Crea un objeto “modelo” para el combo.
Al igual que pasa con los cuadros de lista, los combos tienen un
objeto “modelo” que es el que realmente contiene los datos. En el
caso de los combos, para crear un objeto “modelo” se usará esta
instrucción:
DefaultComboBoxModel modelo = new DefaultComboBoxModel( );
174
b. A continuación, se usa el objeto “modelo” creado y se rellena de

datos. Concretamente, se rellena con los números pares
comprendidos entre 0 y 10.
c. Observa el uso de la propiedad addElement para añadir un

elemento al modelo del combo.
d. Se ha usado un bucle for para hacer la introducción de datos en
el modelo más fácil.
e. Finalmente, se asocia el modelo al combo a través de la siguiente
línea, con lo que el combo aparece relleno con los elementos del
modelo:
7. Ejecuta el programa y observa el funcionamiento del botón Pares.
Se pulsa y se rellena
automáticamente
8. El botón Impares es similar. Programa su actionPerformed como sigue:
int i;
DefaultComboBoxModel modelo = new DefaultComboBoxModel(

);
for (i=1;i<10;i +=2) {
175
modelo.addElement("Nº " + i);
9. La única diferencia de este código es el for, que está diseñado para que
se introduzcan los números impares comprendidos entre 0 y 10 dentro
del modelo.
10. Finalmente se programará el actionPerformed del combo para que al
seleccionar un elemento este aparezca en la etiqueta. Esto se hace con
una simple instrucción:
etiResultado.setText(cboNumeros.getSelectedItem( ).toString( ));

Recuerda el uso de getSelectedItem( ) para recoger el elemento
seleccionado, y el uso de toString( ) para convertirlo a texto.
11. Prueba el programa. Prueba los botones Pares e Impares y prueba el
combo.
12. Sería interesante añadir un botón “Vaciar” llamado btnVaciar que vaciara
el contenido del combo. Esto se haría simplemente creando un modelo
vacío y asignarlo al combo. Se anima al alumno a que realice esta
mejora.
176
Un combo, al igual que las JList, es un objeto que contiene a su vez otro objeto
denominado “modelo”. El objeto “modelo” es el que realmente contiene los datos
del combo. Combo Modelo Datos. Se puede crear un “modelo” y luego
introducir datos en él. Luego se puede asociar ese “modelo” al combo. De esta
manera se puede cambiar el contenido del combo en cualquier momento.
ELEMENTOS DE PRECISIÓN (Deslizador, Hilador y Barra de Desplazamiento)
En muchas ocasiones necesitamos elementos de interfaz gráfica que nos

permitan seleccionar un dato de entre rango con límite inferior y superior, esto
puede ser por ejemplo para proporcionar datos de calibración o de medidas.
Para este tipo de casos podemos utilizar dos componentes llamados JSlider
(Deslizador) y JPinner (Hiladero).
TRABAJAR CON DESLIZADORES (JSliders)
Un JSlider es un componente GUI que contiene una muesca que puede ser
deslizada sobre una línea recta vertical u horizontal, cada desplazamiento
representa un paso o fracción entre un los limites A y B.
La siguiente imagen es una muestra de un componente JSlider
Estos elementos tienen un pequeño recuadro que se puede arrastrar a derecha o

izquierda. Según la posición del recuadro, el JSlider tendrá un valor concreto.
El JSlider se puede configurar para que muestre los distintos valores que puede
tomar:
También se puede configurar de forma que los valores mínimo y máximo sean
distintos:
177
El valor que tiene un JSlider es el valor al que apunta el recuadro del JSlider.
En la imagen anterior, el JSlider tiene un valor de 85.
A continuación mediante un ejemplo veremos las características más
interesantes de los JSlider y como programarlos, debemos seguir los siguientes
pasos:
1. Crea un nuevo proyecto.
2. Añade en él un JSLider. Su nombre será slDeslizador.
3. Añade una etiqueta con borde. Su nombre será etiValor.

4. La ventana tendrá el siguiente aspecto:
5. Un JSlider tiene un valor mínimo y un valor máximo. El valor mínimo es

el valor que tiene cuando el recuadro está pegado a la parte izquierda,
mientras que el valor máximo es el valor que tiene cuando el recuadro
está pegado a la parte derecha.
178
El valor mínimo y máximo del JSlider se puede cambiar. Busca las

propiedades maximum y minimum del JSlider y asigna los siguientes
valores:
Máximo: 500
Mínimo: 100
6. Se puede asignar un valor inicial al JSlider a través de su propiedad

value. Busque esta propiedad y asigne un valor de 400. Observe donde
se sitúa el recuadro del JSlider.
7. Se puede mejorar el JSlider definiendo unas divisiones (medidas) Por

ejemplo, haremos que cada 50 unidades aparezca una división. Para ello
use la propiedad majorTickSpacing y asigne un 50.
8. Esto, en realidad, no produce ningún cambio en el JSlider. Para que las

divisiones se vean, es necesario que active también la propiedad
paintTicks. Esta propiedad pintará divisiones en el JSlider:
179
Medidas
cada 50
unidades
9. Aún se puede mejorar la presentación del JSlider, si hacemos que

aparezca el valor de cada división. Para ello debes activar la propiedad
paintLabel.
10. Ejecuta el programa para ver el funcionamiento del Deslizador y su

aspecto. Debe ser parecido al siguiente:
180
11. Bien. Ahora se pretende que cuando el usuario arrastre el deslizador, en

la etiqueta aparezca el valor correspondiente. Para ello tendrá que
programar el evento stateChanged del JSlider.
El evento stateChanged sucede cuando el usuario arrastra el recuadro
del deslizador.
En este evento programe lo siguiente:
etiValor.setText("El valor es: " +

slDeslizador.getValue( ));
12. Ejecute el programa y observe lo que sucede cuando arrastra el

deslizador.
13. La explicación del código es la siguiente:
a. El método getValue del deslizador nos devuelve el valor que

tiene actualmente el deslizador.
b. Este valor es concatenado a la cadena “El valor es:” y es
mostrado en la etiqueta a través del conocido setText.
Movemos aquí.
Y aparece el valor
correspondiente
aquí.
14. A continuación se mencionan otras propiedades interesantes de los

JSlider que puedes probar por tu cuenta:
orientation
Permite cambiar la orientación del JSlider. Podrías por ejemplo hacer
que el JSlider estuviera en vertical.
181
minorTickSpacing
Permite asignar subdivisiones a las divisiones ya asignadas. Prueba por
ejemplo a asignar un 10 a esta propiedad y ejecuta el programa. Observa
las divisiones del JSlider.
snapToTicks
Cuando esta propiedad está activada, no podrás colocar el deslizador
entre dos divisiones. Es decir, el deslizador siempre estará situado sobre
una de las divisiones. Prueba a activarla.
paintTrack
Esta propiedad permite pintar o no la línea sobre la que se desliza el
JSlider. Prueba a desactivarla.
Los JSliders son objetos “deslizadores”. Permiten elegir un valor arrastrando un

pequeño recuadro de derecha a izquierda o viceversa
El valor de un JSliders puede ser obtenido a través de su método getValue.
Si quieres programar el cambio (el arrastre) en el deslizador, tienes que
programar el evento llamado stateChange
TRABAJAR CON HILADOR (JSpinner)
Un JSpinner no posee una muesca que se pueda desplazar por fracciones de

valores entre sus límites, en su reemplazo posee un campo de texto y dos
botones para introducir las fracciones de valores entre sus límites A y B, un
botón para avanzar hacia el límite superior y otro botón para retroceder hacia el
límite inferior.
La clase JSpinner permite crear cuadros como el siguiente:
Son elementos muy comunes en los programas. A través de los dos botones
triangulares se puede hacer que el valor del cuadro aumente o disminuya.
También se puede escribir directamente un valor dentro del cuadro.
A continuación con un ejemplo veremos cómo trabajar con JSpinne

2. Añade en él un JSpinner. Su nombre será spiValor.
182
3. Añade una etiqueta con borde. Su nombre será etiValor.

4. La ventana tendrá el siguiente aspecto:
5. Interesa que cuando cambie el JSpinner (ya sea porque se pulsaron los
botones triangulares o porque se escribió dentro) aparezca el valor
correspondiente dentro de la etiqueta. Para ello, tendrá que programar el
evento stateChanged del JSpinner.
En el evento stateChanged introduzca el siguiente código:
etiValor.setText("Valor : " +
spiValor.getValue( ).toString( ));
6. Como puedes observar, lo que hace el programa es recoger el valor que

tiene el JSpinner a través del método getValue y luego se lo asigna a la
etiqueta con el clásico setText. (Es muy parecido a los deslizadores)
Debes tener en cuenta que el valor devuelto no es un número ni una

cadena, así que en el ejemplo se ha usado el método toString( ) para
convertirlo a una cadena.
7. Prueba el programa y observa su funcionamiento:
183
El usuario
modifica el valor
del JSpinner..
Y aquí aparece el
valor
seleccionado.
8. Observa como los valores del JSpinner aumentan o disminuyen en 1.

Por otro lado, no parece haber un límite para los valores del JSpinner.
La pregunta ahora es: ¿Se puede modificar el contenido del JSpinner de
forma que tenga unos valores concretos? La respuesta es sí. Veamos
como hacerlo.
9. Entra dentro del código del programa y, dentro del constructor, añade
este código debajo de initComponents:
SpinnerNumberModel nm = new SpinnerNumberModel( );

nm.setMaximum(10);
nm.setMaximum(0);
spiValor.setModel(nm);
10. Este código hace lo siguiente:
a. El JSpinner, al igual que los JList y los JComboBox, es un

objeto que contiene otro objeto “modelo”, y es el objeto “modelo”
el que contiene los números visualizados en el JSpinner.
b. En el código anterior se crea un “modelo” para el JSpinner, se
definen los valores que contendrá, y luego se asigna al JSpinner.
Estudiemos las líneas del código.
c. La primera línea crea un “modelo” llamado nm. Los modelos de
los JSpinner son del tipo SpinnerNumberModel. Necesitarás
incluir el import correspondiente (atento a la bombilla)
d. En la segunda línea se define como valor máximo del modelo el
10, a través de un método llamado setMaximum.
184
e. En la tercera línea se define como valor mínimo del modelo el 0,

a través de un método llamado setMaximum.
f. Finalmente se asigna el modelo creado al JSpinner.
g. Este código, en definitiva, hará que el JSpinner muestre los
valores comprendidos entre 0 y 10.
11. Prueba el programa y observa los valores que puede tomar el JSpinner.
Ahora los valores

están
comprendidos
entre 0 y 10
12. Vamos a añadir otra mejora. Cambie el código del constructor por este
otro. (Observa que solo se ha añadido una línea):
SpinnerNumberModel nm = new
SpinnerNumberModel( );
nm.setMaximum(10);
nm.setMaximum(0);
nm.setStepSize(2);
spiValor.setModel(nm);
13. La línea añadida es:
nm.setStepSize(2);
Esta línea usa un método del modelo del JSpinner que permite definir el
valor de cambio del JSPinner. Dicho de otra forma, esta línea hace que
los valores del JSpinner salten de 2 en 2.
14. Ejecuta el programa de nuevo y observa cómo cambian los valores del
JSpinner.
185
15. El modelo del JSpinner tiene también un método llamado setValue que
permite asignar un valor inicial al modelo. Pruebe a usar este método
para hacer que el JSpinner muestre desde el principio el valor 4.
Los JSpinners son objetos que permiten seleccionar un número, ya sea

escribiéndolo en el recuadro, o bien a través de dos botones triangulares que
permiten aumentar o disminuir el valor actual. Los JSpinners son objetos con
“modelo”. Es decir, este objeto contiene a su vez otro objeto “modelo” que es el
que realmente contiene los datos.
Datos Modelo JSpinner
Para definir el contenido del JSpinner es necesario crear un modelo del tipo
SpinnerNumberModel. Se le asigna al modelo los números deseados, y
finalmente se une el modelo con el JSpinner. El objeto modelo del JSpinner
permite definir el valor mínimo y el valor máximo, así como el intervalo de
aumento de los valores.
TRABAJAR CON BARRAS DE DESPLAZAMIENTO (JScrollBar)
La clase JScrollBar permite crear barras de desplazamiento independientes,

como la que se muestra a continuación:
La barra tiene un valor mínimo, que se consigue haciendo que el recuadro de la

barra de desplazamiento esté pegado a la parte izquierda.
Valor mínimo
186
Cuando se pulsa algunos de los botones de la barra de desplazamiento, el valor

de la barra se incrementa / decremento poco a poco. A este incremento /
decremento lo llamaremos incremento unitario.
Decrementa el valor Incrementa el valor

poco a poco poco a poco
(incremento unitario) (incremento unitario)
Cuando se pulsa directamente sobre la barra, el valor de la barra se incrementa /

decremento en mayor cantidad. A este incremento / decremento lo llamaremos
incremento en bloque.
Al pulsar directamente sobre la Al pulsar directamente sobre la

barra se decrementa en mayor barra se incremente en mayor
cantidad (incremento en bloque) cantidad (incremento en bloque)
1. Para comprender mejor el funcionamiento de las barras de

desplazamiento se creará un proyecto nuevo.
2. Añade en el proyecto una barra de desplazamiento (JScrollBar) y

llámala desValor.
3. La barra de desplazamiento aparecerá en vertical. Use la propiedad de la

barra llamada Orientation para hacer que la barra aparezca en posición
horizontal.
187
4. Añade también una etiqueta con borde y llámala etiValor.

5. La ventana debe quedar más o menos así:
6. Interesa que cuando el usuario cambie de alguna manera la barra de

desplazamiento, en la etiqueta aparezca el valor de la barra.
Para ello, se debe programar el evento AdjustmentValueChanged de la
barra de desplazamiento.
En este evento programa lo siguiente:
etiValor.setText("El valor es: "+desValor.getValue( ));
7. Como ves, se coloca en la etiqueta el valor de la barra. El valor de la

barra se obtiene con el método getValue. Ejecuta el programa para ver
su funcionamiento.
Pulsa aquí y
observa como el
valor cambia
poco a poco…
Pero si pulsas aquí

el valor cambia en
mayor cantidad…
188
8. Sigamos estudiando el programa. Se pide que cambies las siguientes

propiedades de tu barra:
Minimum – Permite asignar el valor mínimo de la barra. Escribe un

50
Maximum – Permite asignar el valor máximo de la barra. Escribe un
150
UnitIncrement – Permite cambiar el incremento unitario. Escribe un 2.
BlockIncrement – Permite cambiar el incremento en bloque. Escribe un 20.
VisibleAmount – Permite cambiar el ancho del recuadro de la barra.

Escribe un 5.
189
9. Ejecuta ahora el programa y comprueba su funcionamiento:
Si pulsas aquí, el
valor se incrementa
de 2 en 2, ya que el
incremento unitario
se configuró en 2.
Si pulsas aquí, el
valor se incrementa
de 20 en 20, ya que
el incremento en
bloque es de 20.
Si llevas la barra de desplazamiento al mínimo, su valor

será de 50, ya que se configuró así con la propiedad
minimum…
190
Observa lo que sucede cuando llevas la barra de

desplazamiento al máximo: aparece un valor de 145, cuando
el valor máximo que asignamos fue de 150 ¿por qué?
10. Tal como se ha indicado anteriormente, pasa algo raro con la barra de
desplazamiento cuando esta está al máximo. Se esperaba que alcanzara
el valor 150, y sin embargo, el valor máximo alcanzado fue de 145. La
explicación es la siguiente
Valor máximo (150)

*
5 ***
Valor de la barra (145) **
* Nuestra barra tiene un valor máximo de 150.

** Sin embargo, el valor de la barra viene indicado por el lado izquierdo del
recuadro interno.
*** Como el recuadro interno tiene un ancho definido a través de la propiedad

VisibleAmount, el valor máximo que la barra puede alcanzar es de:
191
Valor = ValorMáximo – Ancho del recuadro.

Es decir,
Valor alcanzable = 150 – 5 = 145
A través del método setValue de la barra de desplazamiento se puede asignar

un valor inicial a la barra. Programe en el constructor de su programa lo
necesario para que la barra de desplazamiento tenga un valor de 70 al empezar
el programa.
Las JScrollBars son barras de desplazamiento independientes. Al igual que
los JSliders, las JScrollBars tienen un valor concreto, que puede ser
obtenido a través del método getValue.
Entre las características programables de una barra de desplazamiento, tenemos
las siguientes:
 Valor mínimo (propiedad Minimum)
 Valor máximo (propiedad Maximum)
 Incremento unitario (propiedad UnitIncrement)
 Incremento en bloque (propiedad BlockInc|rement)
 Tamaño del recuadro de la barra (propiedad VisibleAmount)
ELEMENTOS DE MENU (JMenuBar, JMenu, JMenuItem, JMenuPopup y JSeparator)
Toda aplicación de software posee unas funciones u operaciones (Llamados

Casos de Uso o requerimientos según el punto de vista del usuario), estas
funciones son equivalentes a los palillos que se ofrecen en un restaurante, los
cuales se presentan al cliente o comensales organizadas en Menús a la Carta
para que este seleccione cuales platos desea consumir. No es muy diferente la
situación al momento de utilizar un software sobre el cual deseamos utilizar o
realizar X operación, proceso o función, estas funciones deben ser presentadas
al usuario en Menús organizan por categorías según su función.
Java nos proporciona un conjunto de clases que nos permiten trabajar con
componentes GUI del tipo Menú, estos clases son JMenuBar (Barra de Menú),
192
JMenu (Menú), JMenuItem (Ítem de Menú), JCheckBoxMenuItem (Ítem de

Menú Verificable), JRadioButtonMenuItem (Ítem de menú seleccionable),
JMenuPopup (Menú Emergente) y JSeparator (Separador).
TRABAJAR CON MENUS (JMenuBar, JMenu, JMenuItem y JMenuPopup)
Estas clases trabajan como una estructura anidada contenidos uno dentro del
otro, en este caso para trabajar con Menú primero se debe seguir los siguientes
pasos:
1. Crear una instancia de JMenuBar

2. Agregar el JMenuBar a una ventana mediante el método setJMenuBar
3. Crear al menos una instancia de la clase JMenu.
4. Agregarle una etiqueta de texto al menú mediante el método setText
5. Agregar la instancia del JMenu a la instancia de la JMenuBar mediante
el método add( )
6. Crear al menos una instancia de la clase JMenuItem o
JCheckBoxMenuItem o JRadioButtonMenuItem
7. Agregarle una etiqueta de texto al item mediante el método setText
8. Agregar la instancia del de JMenuItem a la instancia de la JMenu
mediante el método add( )
9. Opcionalmente si se desea organizar el ítem dentro del menú, podemos
crear una instancia de JSeparator y agregar dicha instancia a la
instancia del JMenu.
10. De igual forma sucede si opcionalmente deseamos crear un Submenu,
pera ellos repetimos los pasos del 3 al 8, pero en el paso 5 agregamos la
instancia del JMenu al otro JMenu donde deseamos que aparezca dicho
submenú.
11. Por ultimo debemos agregar un oyente de evento al cada Ítem de Menu,
para ello creamos una instancia de una clase anónima o que implemente
de la interfaz ActionListener e implementar el método:
public void actionPerformed( ActionEvent evento) { }
Mediante los siguientes pasos veremos cómo trabajar con Menús:
La barra de menús nos permitirá acceder a las opciones más importantes del
programa. Todo programa de gran envergadura suele tener una barra de menús.
193
1. Veamos como añadir una barra de menús a nuestras aplicaciones. En

primer lugar, crea un proyecto con el NetBeans.
2. Añade a tu ventana un objeto JMenuBar
3. En la parte superior de tu ventana aparecerá esto:
4. En el inspector (parte inferior izquierda) observarás como aparece un

objeto JMenuBar, y, dentro de él, un objeto del tipo JMenu. Los objetos
JMenu representan las opciones principales contenidas dentro de la
barra de menús.
5. Aprovecha el Inspector para cambiar el nombre al objeto JMenuBar.

Llámalo barraMenus.
6. Cambia también el nombre al objeto JMenu. Asígnale el nombre
menuArchivo. El Inspector tendrá el siguiente aspecto:
194
7. Ahora, la única opción de la barra de menús muestra el texto “Menu”.

Esto se puede cambiar seleccionándola y cambiando su propiedad text.
Asígnale el texto “Archivo” a la opción del menú:
8. Ahora el aspecto de la barra de menús será el siguiente:
9. Puedes añadir más opciones principales a la barra de menús haciendo

clic con el derecho sobre el objeto de la barra de menús y activando la
opción “Añadir JMenu”.
10. Añada dos opciones más a la barra de menús. El inspector debe tener
ahora el siguiente aspecto:
195
11. Y la barra de menús presentará este otro aspecto:
12. Cambia los nombres de las dos nuevas opciones. Sus nombres serán:
menuEdicion y menuInsertar.
13. Cambia los textos de ambas opciones. Sus textos serán: “Edición” e
“Insertar”.
14. Ya tenemos creada la barra de menús (JMenuBar) con sus opciones

principales (JMenu). Ahora se tendrán que definir las opciones
contenidas en cada opción principal. Por ejemplo, crearemos las
opciones contenidas en el menú Archivo.
15. Haz clic con el botón derecho sobre el objeto menuArchivo y activa la
opción “Añadir – JMenuItem”.
196
Los JMenuItem son objetos que representan las opciones contenidas en los
menús desplegables de la barra de menús.
16. Añade un JMenuItem más al menuArchivo y luego cambia el nombre a
ambos. Sus nombres serán menuItemAbrir y menuItemGuardar. El
aspecto del Inspector será el siguiente:
17. Usa ahora la propiedad Text de ambos JMenuItem para asignarles un

texto. El primero tendrá el texto “Abrir” y el segundo el texto “Guardar”.
18. Ya podemos ejecutar el programa para ver qué es lo que se ha
conseguido. Use el menú:
197
Observa como la opción Archivo se despliega mostrando dos submenús:

Abrir y Guardar.
19. Seguiremos añadiendo elementos al menú. Ahora haga clic con el
derecho sobre el elemento menuArchivo y añada un JSeparator.
Los JSeparator son objetos que definen una separación entre las opciones de
un menú. Cámbiele el nombre y llámelo “separador1”:
20. Añada un nuevo JMenuItem al menú Archivo y ponle el nombre
menuSalir. El texto de esta opción será “Salir” (use su propiedad text) El
aspecto del Inspector será el siguiente:
21. Ejecuta el programa y observa el contenido de la opción Archivo del

menú:
198
Observa el efecto que produce el separador.

22. Un JMenu representa las opciones
principales de la barra de menús. A su vez, un
JMenu contiene JMenuItem, que son las
opciones contenidas en cada opción principal, y
que se ven cuando se despliega el menú.
Sin embargo, un JMenu puede contener a otros JMenu, que a su vez
contendrán varios JMenuItem. Usando el botón derecho del ratón y la
opción “Añadir”, añade un JMenu dentro de menuEdicion:
23. Llama al nuevo JMenu menuColores y asígnale el texto “Colores”.
24. Ahora añade dentro del menuColores tres JMenuItem llamados

respectivamente: menuItemRojo, menuItemVerde, menuItemAzul. Sus
textos serán “Rojo”, “Verde” y “Azul”.
199
25. Ejecuta el programa y observa como ha quedado el menú Edición:
La opción Edición (JMenu) contiene una opción Colores (JMenu) que a

su vez contiene las opciones Rojo, Verde y Azul (JMenuItems)
26. De nada sirve crear un menú si luego este no reacciona a las pulsaciones
del ratón. Cada objeto del menú tiene un evento ActionPerformed que
permite programar lo que debe suceder cuando se active dicha opción
del menú.
27. Marque en el inspector el objeto menuItemRojo y acceda a su evento

ActionPerformed. Dentro de él programe este sencillo código:
this.getContentPane( ).setBackground(Color.RED);
Este código cambia el color de fondo de la ventana a rojo.

28. Compruebe el funcionamiento de la opción “Rojo” del menú ejecutando el
programa.
29. Programa tú mismo las opciones “Verde” y “Azul”.
200
Las barras de menús son un conjunto de objetos de distinto tipo que se

contienen unos a los otros: La barra en sí está representada por un objeto del
tipo JMenuBar. La barra contiene opciones principales, representadas por
objetos JMenu. Las opciones principales contienen opciones que aparecen al
desplegarse el menú. Estas opciones son objetos del tipo JMenuItem. Un
JMenu también puede contener otros JMenu, que a su vez contendrán
JMenuItems. También puede añadir separadores (JSeparator) que permiten
visualizar mejor las opciones dentro de un menú.
TRABAJAR CON MENU EMERGENTE (JMenuPopup)
Muchas veces queremos que algunas de las funciones incluidas y organizadas

en los diferentes Menús de la aplicación aparezcan al dar clic derecho en
cualquier parte de la aplicación.
El evento mouseClicked es capaz de capturar un clic del ratón sobre un
determinado elemento de la ventana.
Este evento recibe como parámetro un objeto del tipo MouseEvent, y gracias a
él se puede conseguir información como la siguiente:
 Qué botón del ratón fue pulsado.

 Cuantas veces (clic, doble clic, etc)
 En qué coordenadas fue pulsado el botón.
 Etc.
Se puede usar esta información para saber por ejemplo si se pulsó el botón
derecho del ratón, y sacar en este caso un menú contextual en pantalla.
En este ejercicio guiado se estudiarán las posibilidades del evento

mouseClicked y se aplicarán a la creación y visualización de menús
contextuales (o emergentes):

2. No hace falta que añada nada a la ventana.
3. Programaremos la pulsación del ratón sobre el formulario, así que haga
clic sobre el formulario y active el evento mouseClicked.
4. Observe el código del evento:
201
private void formMouseClicked(java.awt.event.MouseEvent evt)

{
// TODO add your handling code here:
}
Este evento recibe como parámetro un objeto llamado evt del tipo
MouseEvent (en rojo en el código) que nos permite saber en qué
condiciones se hizo clic.
5. Dentro del evento programe lo siguiente:
if (evt.getButton( )==1) {
JOptionPane.showMessageDialog(null,"Pulso el
izquierdo");
} else if (evt.getButton( )==2) {
JOptionPane.showMessageDialog(null,"Pulso el central");
} else if (evt.getButton( )==3) {
JOptionPane.showMessageDialog(null,"Pulso el derecho");
}
6. Ejecuta el programa y haz clic sobre el formulario con el botón derecho,

con el izquierdo y con el central. Observa el resultado.
7. Ahora quizás puedas comprender el código anterior. En él, se usa el
método getButton del objeto evt para saber qué botón se pulsó. El
método getButton devuelve un entero que puede ser 1, 2 o 3 según el
botón pulsado.
8. Se puede aprovechar el método getButton para controlar la pulsación
del botón derecho del ratón y así sacar un menú contextual. Pero antes,
es necesario crear el menú.
9. Agrega a tu formulario un objeto del tipo JPopupMenu. Estos objetos
definen menús emergentes.
10. Los objetos JPopupMenu no se muestran en el formulario, pero puedes
verlo en el Inspector dentro de la rama de Otros Componentes:
202
11. Aprovecharemos el inspector para cambiar el nombre al menú. Llámalo

menuEmergente.
12. Los menús emergentes se crean igual que las opciones de menús
normales, añadiendo con el botón derecho del ratón objetos JMenuItem.
13. Añada al menú emergente tres JMenuItem, y asígneles los siguientes
nombres a cada uno: menuRojo, menuVerde, menuAzul. El inspector
debería tener el siguiente aspecto:
14. Tienes que cambiar la propiedad text de cada opción del menú.
Recuerda que esta propiedad define lo que aparece en el menú.
Asignarás los siguientes textos: “Rojo”, “Verde” y “Azul”.
15. El menú emergente ya está construido. Ahora tenemos que hacer que
aparezca cuando el usuario pulse el botón derecho del ratón sobre el
formulario. Para ello, entraremos de nuevo en el evento mouseClicked
del formulario y cambiaremos su código por el siguiente:
menuEmergente.show(this,evt.getX( ),evt.getY( ));
16. Este código significa lo siguiente:
 El método show le da la orden al menuEmergente para que se

muestre.
 El método show recibe tres elementos: por un lado la ventana donde
actúa (this)
 Por otro lado la posición x donde debe mostrarse el menú. Esta
posición es aquella donde se pulsó el ratón, y se puede conseguir
gracias al método getX del objeto evt.
 Por último se necesita la posición y. Esta posición se puede
conseguir gracias al método getY del objeto evt.
203
Es decir, decidimos mostrar el menú emergente justo en las coordenadas

donde se hizo clic.
17. Ejecuta el programa y observa el resultado.
Al hacer clic con el derecho se mostrará el menú contextual.
18. Para hacer que al pulsarse una opción suceda algo, solo hay que activar
el método actionPerformed del JMenuItem correspondiente. Por
ejemplo, active el actionPerformed del menuRojo y dentro programe lo
siguiente:
this.getContentPane( ).setBackground(Color.RED);
19. Ejecuta el programa y comprueba lo que sucede al pulsar la opción Rojo

del menú contextual.
Los menús contextuales son objetos del tipo JPopupMenu. Estos objetos
contienen JMenuItem al igual que las opciones de menú normales. Cuando se
asigna un JPopupMenu a un formulario, no aparece sobre la ventana, pero sí en
el inspector. Para hacer que aparezca el menú emergente, es necesario
programar el evento mouseClicked del objeto sobre el que quiera que aparezca
el menú. Tendrá que usar el método show del menú emergente para mostrar
dicho menú.
204
TRABAJAR CON BARRAS DE HERRAMIENTAS (JTollBar)
Las barras de menú nos permiten acceder de forma fácil a un conjunto de

Funciones u Operaciones del sistema comúnmente utilizadas, las cuales están
disponibles en una barra de botones generalmente con iconos ubicada
justamente debajo de la barra de menú de la aplicación. Cada una de los
botones representa funciones particulares del sistema.
Una barra de herramientas es básicamente un contenedor de botones y otros
elementos propios de la ventana.
A través de estos botones se pueden activar de forma rápida las opciones del
programa, las cuales suelen estar también incluidas dentro de la barra de menús.
El siguiente ejemplo muestra los pasos básicos para trabajar con barras de
herramientas:
1. Veamos como añadir una barra de herramientas a nuestras aplicaciones.
En primer lugar, crea un proyecto con el NetBeans.
2. Añade a tu ventana un objeto JMenuBar (una barra de menús)
3. En la parte superior de tu ventana aparecerá esto:
4. Debajo de la barra de menús colocaremos una barra de herramientas,

así que añade un objeto del tipo JToolBar. Haz que la barra se coloque
debajo de la barra de menús y que alcance desde la parte izquierda de la
ventana a la parte derecha.
La ventana quedará así:
205
5. Las barras de herramientas son simples contenedoras de objetos. Dentro

de ellas se pueden colocar botones, combos, etiquetas, etc.
Normalmente, las barras de herramientas contienen botones. Así que
añade cuatro botones (JButton) dentro de la barra. Solo tienes que
colocarlos dentro de ella.
6. Puedes ver si los botones están bien colocados observando el Inspector:

Observa como los botones colocados se encuentran dentro de la barra.
7. Aprovecharemos el inspector para cambiar el nombre a la barra y a cada

botón. A la barra la llamaremos barraHerramientas, y a los botones los
llamaremos btnUno, btnDos, btnTres y btnCuatro:
206
8. Cambia el texto de los botones. Estos contendrán el texto: “Uno”, “Dos”,

“Tres” y “Cuatro”.
9. Ejecuta el programa y observa el resultado.
10. La forma de programar cada botón no varía, aunque estos se encuentren

dentro de la barra herramientas. Solo hay que seleccionar el botón y
acceder a su evento actionPerformed.
11. Solo como demostración de esto último, entra en el actionPerformed del
primer botón y programa esto:
JOptionPane.showMessageDialog(null,"Activaste el botón
uno");
Luego ejecuta el programa y comprueba el funcionamiento del botón.

12. Los botones de la barra de herramientas normalmente no contienen
texto, sino que contienen un icono que representa la función que realiza.
La forma de colocar un icono dentro de un botón es a través de su
propiedad icon.
13. A través de la propiedad icon de un botón podrá seleccionar un archivo
de imagen que contenga la imagen a mostrar en el botón.
14. Activa la propiedad icon del primer botón. Luego elige la opción Archivo y
pulsa el botón Seleccionar Archivo para buscar un archivo con imagen.
Nota: Busca un archivo de imagen que sea del tipo .gif o .jpg.
Nota: Procura que la imagen sea pequeña.
Nota: Se recomienda buscar imágenes .gif en Internet para practicar.
207
15. Una vez colocadas las imágenes a los botones, se puede quitar el texto
de estos. Un ejemplo de cómo podría quedar la barra de herramientas es
este:
Las barras de herramientas son simplemente contenedores de objetos.

Normalmente botones. Los elementos de la barra de herramientas se manejan
de la misma forma que si no estuvieran dentro de la barra. Lo normal es hacer
que los botones de la barra no tengan texto y tengan iconos asociados.
208
VENTANAS Y CUADROS DE DIALOGO (JFrame, JDialog, JOptionPane, JFileChoser y

JColorChoser)
La información en una aplicación debe poder presentarse en Elementos de

Interfaz de Usuario que permitan una experiencia de uso con cualidades de
fluidez, simplicidad e intuitividad, por ello existen elementos llamados Ventanas
en las que se puede colocar y mostrar todos los Elementos de Interfaz de
usuario que se utilizan en una aplicación, estas se pueden abrir, cerrar, cambiar
de tamaño, organizar, etc. Aunque existen muchos otros elementos de interfaz
disponibles en una aplicación, sin dudas las Ventanas son los más importantes,
ya que ellas contenedores sobre los que se puede presentar cualesquiera varios
grupos de elementos de Interfaz de usuario.
En Java existen varias clases para trabajar con Ventanas y unas heredan de
otras en la siguiente secuencia:
JWindow (Ventana sin Marco), JFrame (Ventana con marco), JDialog (Ventana
con marco para Formularios), JOptionPane (Ventana con Opciones),
JFileChoser (Ventana para seleccionar Archivo), JColorChoser (Ventana para
Seleccionar Color).
Alguno de los métodos más utilizados para trabajar con ventanas son:
Métodos Parámetros Retorno Descripción
setVisible Booleano Ninguno Si recibe true la ventana
será presentada en la
pantalla del PC, si recibe
false la ventana será
ocultada
setLocation Int x, int y Ninguno Recibe las coordenadas
x,y de la pantalla donde
será colocada la esquina
superior de la Ventana
setLocationRelativT JComponent Ninguno Recibe el componente
o GUI sobre el cual será
centrada la Pantalla
cuando sea visible, si
recibe null la Ventana
será centrada sobre la
209
pantalla del PC
setExtendedState int Ninguno Recibe
JFrame.MAXIMIZE_BOT
H para maximizar la
Ventana conforme al
ancho y alto de la
Pantalla.
pack Ninguno Ninguno Le da el tamaño a la
ventana conforme al
tamaño de los elementos
que contiene.
getContentPane Ninguno JContaine Devuelve el Panel
r contenedor donde se
colocan los elementos
dentro de la Ventana
setLayout LayoutManage Ninguno Establece el Layout
r (Lienzo) que determinara
la posición, número y
organización de los
elementos dentro de la
Ventana
setResizable Boolean Ninguno Si recibe un parámetro
true la ventana podrá
cambiar de tamaño, false
para un tamaño fijo
setImageIcon ImageIcon Ninguno Permite cambiar el icono
de la ventana
setTitle String Ninguno Establece el título que
tendrá la ventana
TRABAJAR CON VENTANAS NORMALES (JFrame)
Es muy simple, veamos el siguiente: Creamos una Ventana de tamaño 400

pixeles de ancho x 300 de alto, la cual será centrada en la pantalla del PC:
// Crear la instancia de la ventana

JFrame miVentana = new JFrame( );
// Establecer el título de la ventana
210
miVentana.setTitle(“:: Ejemplo de una Ventana Centrada”);

// Establecer el tamaño de la Ventana
miVentana.setSize(400, 300);
// Centrar la ventana sobre la Pantalla
miVentana.setLocationRelativeTo(null);
// Mistrar la ventana
miVentana.setVisible(true);
Otra forma de crear Ventanas es diseñando una clase que herede de JFrame:
public class VentanaPrincipal extends JFrame{

// Este es el constructor de la clase
public VentanaPrincipal ( ) {
// this se utiliza para invocar sus propias propiedades y metodos
this.setTitle(“:: Ejemplo de una Ventana Centrada”);
this.setSize(400, 300);
this.setLocationRelativeTo(null);
this.setVisible(true);
}
// Este es el metodo principal para poder ejecutar la aplicacion
public static void main(String arg [ ] ){
// Creamos un instancia de la Clase hija de JFrame
VentanaPrincipal ventana = new VentanaPrincipal( );
}
}
TRABAJAR CON VENTANAS DE DIALOGO PARA FORMULARIOS (JDialog)
Las ventanas de dialogo son Hijas de las JFrame, su clase se llama JDialog
debido a que se utilizan especialmente para diseñar formularios con
Componentes GUI para Entrada o captura de Datos y así como para Salida o
presentación de datos. Estas ventanas tienen la calidad de estar en estado
Modal o no Modal. Si la ventana está en estado Modal indica que la Ventana que
está detrás de la misma no podrá utilizarse mientras la ventana de Dialogo Modal
este abierta, el caso contrario permite poder interactuar tanto con la Ventana de
Dialogo como con la Ventana desde la cual fue abierta dicha ventana de dialogo.
211
El siguiente ejemplo de código permite crear una instancia u objeto de tipo

JDialog en estado Modal a partir de una Ventana JFrame previamente abierta:
public class VentanaPrincipal extends JFrame{

// Esta es una propiedad de tipo JDialog
JDialog ventana2;
// Este es el constructor de la clase
public VentanaPrincipal ( ) {
// se crea una instancia de tipo JDialog Modal en VentanaPrincipal
ventana2 = new JDialog(this, true);
JMenuBar barraMenu = new JMenuBar( ); // la barra de menu
miVentana.setJMenuBar(barraMenu); // agrega la barra a la ventana
JMenu menuAyuda = new JMenu(“Ayuda”); // El Menu
barraMenu.add( menuAyuda ); // agrega el Menu a la Barra de Menu
JMenuItem itemAcercaDe = new JMenuItem(“Creditos”); // el Item
menuAyuda.add(itemAcercaDe ); // agrega el Item el Menu
// agrega un Oyente de acción para escuchar y procesar eventos
// de clic sobre el ítemAcercaDe del menuAyuda
menuAcercaDe.addActionListener( new ActionListener( ){
public void actionListener(ActionEvent evento){
// se establece el titulo, tamaño posicion y visibilidad
// de la ventana2 de tipo JDialog
ventana2.setTitle(“Los Creditos”);
ventana2.setSize(200,100);
ventana2.setLocationRelativeTo(VentanaPrincipal.this);
ventana2.setVisible(true);
}
});
}
// Este es el metodo principal para poder ejecutar la aplicacion
public static void main(String arg [ ] ){
// Creamos un instancia de la Clase hija de JFrame
VentanaPrincipal ventana = new VentanaPrincipal( );
}}
212
Un cuadro de diálogo es un cuadro con opciones que aparece normalmente

cuando se activa una opción del menú principal del programa.
Los cuadros de diálogo tienen forma de ventana aunque no poseen algunas
características de estas. Por ejemplo, no pueden ser minimizados ni
maximizados.
Los cuadros de diálogo, aparte de las opciones que muestran, suelen contener
dos botones típicos: el botón Aceptar y el botón Cancelar. El primero de ellos da
por válidas las opciones elegidas y cierra el cuadro de diálogo. El segundo
simplemente cierra el cuadro de diálogo sin hacer ninguna modificación.
He aquí algunos ejemplos de cuadros de diálogo del programa Word:
Para crear cuadros de diálogo en Java, se usa un tipo de objetos llamado

JDialog. Estos objetos pueden ser diseñados como si fueran ventanas, aunque
representan realmente cuadros de diálogo.
1. Crea un nuevo proyecto en java.

2. Diseña el JFrame de forma que la ventana tenga el siguiente aspecto:
213
Los elementos de la ventana tendrán los siguientes nombres:
 Cuadro de texto de unidades: txtUnidades.

 Cuadro de texto de precio: txtPrecio.
 Etiqueta con borde del total: etiTotal.
 Botón Calcular: btnCalcular.
 Botón Configuración: btnConfiguracion.
3. Se pretende que cuando se pulse el botón Calcular se calcule el total de

la venta (esto se hará luego) Para hacer el cálculo se tendrán en cuenta
el IVA y el Descuento a aplicar. Estos dos valores serán variables
globales, ya que se usarán en distintos lugares del programa.
4. Así pues entra en el código y declara una variable global iva y otra
descuento tal como se indica a continuación (recuerda que las variables
globales se colocan justo después de la línea donde se define la clase
principal public class):
214
5. Cuando el programa arranque, interesará que el iva por defecto sea 0, y

que el descuento por defecto sea 0 también, así que en el constructor,
inicializaremos las variables globales iva y descuento a 0:
6. Estamos ya preparados para programar el botón btnCalcular. Entra en

su actionPerformed y allí se programará la realización del cálculo de la
siguiente forma:
double unidades;
double precio;
double total; //total
double cantiva; //cantidad iva
double cantdes; //cantidad descuento
double totalsiniva; //total sin iva
//Recojo los datos de los cuadros de textos (convirtiendolos a números)

unidades = Double.parseDouble(txtUnidades.getText( ));
precio = Double.parseDouble(txtPrecio.getText( ));
//Calculo el total sin iva, la cantidad de iva y la cantidad de descuento

totalsiniva=precio*unidades;
cantiva=totalsiniva*iva/100;
cantdes=totalsiniva*descuento/100;
//Ahora calculo el precio total:
215
total = totalsiniva+cantiva-cantdes;
//Coloco el total en la etiqueta:

etiTotal.setText(""+total);
7. Puedes ya ejecutar el programa y comprobar que el botón Calcular

funciona, aunque el cálculo que realiza lo hace con un iva 0 y un
descuento 0.
8. A continuación se programará el botón Configuración de forma que nos
permita decidir qué iva y qué descuento queremos aplicar. Este botón
mostrará un CUADRO DE DIÁLOGO que permita al usuario configurar
estos datos.
9. Para añadir un cuadro de diálogo al proyecto, se tiene que añadir un
objeto del tipo JDialog sobre el JFrame.
10. Los JDialog son objetos ocultos, es decir, objetos que se colocan en la
parte del Inspector llamada Otros Componentes, al igual que sucede con
los menús contextuales o los JFileChooser. Observa tu inspector, allí
verás el JDialog que has añadido:
La variable de
tipo JDialog
216
11. Cámbiale el nombre. Lo llamaremos dialogoConfiguracion.

12. Los diálogos normalmente traen por defecto el layout BorderLayout.
Para nuestro ejemplo cambiaremos el layout del JDialog por el Diseño
Libre:
13. Los JDialog se pueden diseñar independientemente, al igual que los

JPanel. Solo tienes que hacer doble clic sobre el dialogoConfiguracion
(en el inspector) y este aparecerá en el centro de la ventana.
14. Así pues debes diseñar el dialogoConfiguracion para que quede de la
siguiente forma:
Los elementos del cuadro de diálogo tienen los siguientes nombres:

 El cuadro de texto del Iva: txtIva.
 El cuadro de texto del Descuento: txtDescuento.
217
 El botón Aceptar: btnAceptar.

 El botón Cancelar: btnCancelar.
Si observas el Inspector debe tener el siguiente aspecto:
15. Se ha dicho que cuando se pulse el botón Configuración en la ventana

principal, debe aparecer el cuadro de diálogo dialogoConfiguracion,
que acabas de diseñar:
Haces clic
sobre
Configuració
n y aparece
el diálogo
218
16. Para conseguir esto, debes programar el actionPerformed del botón

btnConfiguracion de la siguiente forma:
dialogoConfiguracion.setSize(250,200);
dialogoConfiguracion.setLocation(100,100);
dialogoConfiguracion.setVisible(true);
17. El código anterior hace lo siguiente:

 A través del método setSize se asigna un tamaño de 250 x 200 al
cuadro de diálogo.
 A través del método setLocation se determina que el cuadro de
diálogo aparecerá en la posición (100, 100) de la pantalla.
 A través del método setVisible hacemos que el cuadro de diálogo se
muestre.
18. Ejecuta el programa y observa lo que sucede cuando pulsas el botón

Configurar. Debería aparecer el cuadro de diálogo en la posición
programada y con el tamaño programado:
219
19. Los botones Aceptar y Cancelar del cuadro de diálogo aún no hacen
nada. Así que los programaremos. Empezaremos por el más sencillo, el
botón Cancelar.
20. El botón Cancelar de un cuadro de diálogo simplemente cierra dicho
cuadro de diálogo. Para ello, debes añadir el siguiente código en el
actionPerformed del botón Cancelar del diálogo:
dialogoConfiguracion.dispose( );
El método dispose se usa para cerrar un cuadro de diálogo. También se

puede usar con un JFrame para cerrarlo.
21. Ejecuta el programa de nuevo y comprueba el funcionamiento del botón
Cancelar del cuadro de diálogo.
22. Ahora se programará el botón Aceptar. Cuando el usuario pulse este
botón, se confirmará el valor del iva y del descuento que haya
introducido. Es decir, se traspasarán los valores introducidos en los
cuadros de texto txtIva y txtDescuento a las variables globales iva y
descuento.
Una vez que se haya hecho esto, el cuadro de diálogo se debe cerrar.
23. Este es el código que hace lo anterior. Debe programarlo en el
actionPerformed del botón Aceptar:
iva = Double.parseDouble(txtIva.getText( ));
descuento=Double.parseDouble(txtDescuento.getText( ));
dialogoConfiguracion.dispose( );
24. Observe el código. Primero se traspasa los valores de los cuadros de

texto a las variables globales y luego se cierra el cuadro de diálogo.
25. Compruebe el funcionamiento del programa de la siguiente forma:
a. Ejecute el programa.
b. Introduzca 5 unidades y 20 de precio.
c. Si pulsa calcular, el total será 100. (No hay ni iva ni descuento al
empezar el programa)
d. Ahora pulse el botón Configuración, e introduzca un iva del 16. El
descuento déjelo a 0. Acepte.
220
e. Ahora vuelva a calcular. Observe como ahora el total es 116, ya que se

tiene en cuenta el iva configurado.
f. Pruebe a configurar un descuento y vuelva a calcular.
26. Se pretende ahora mejorar un poco el cuadro de diálogo, añadiéndole un

título. Seleccione el cuadro de diálogo en el Inspector y luego busque su
propiedad title. En ella escriba “Configuración de iva y descuento”.
27. Vuelva a ejecutar el programa. Observe la barra de título del cuadro de
diálogo:
La ventana se activa colocándose

por encima del cuadro de diálogo.
28. Ahora se estudiará
el concepto de cuadro de
diálogo modal y cuadro de
diálogo no modal.
 Un cuadro de
diálogo no modal. Es aquel
que permite activar la
ventana desde la que
apareció. Los cuadros de
diálogo añadidos a un
proyecto son por defecto no
modales.
29. Ejecuta el programa

y prueba a hacer lo
siguiente:
a. Pulsa el botón
Configurar. Aparecerá el
cuadro de diálogo.
b. Pulsa sobre la
ventana.
c. Observarás que la
ventana se activa,
colocándose sobre el
cuadro de diálogo.
221
d. Esto es posible gracias

a que el cuadro de diálogo es
no modal.
e. A veces, puede ser
interesante que se active la
ventana pero que el cuadro de
diálogo siga delante de ella.
Para conseguir esto, es
necesario activar la propiedad
del cuadro de diálogo llamada
alwaysOnTop. Activa esta
propiedad:
f. Ahora ejecuta el
programa de nuevo y haz que se
visualice el cuadro de diálogo de
configuración. Podrás comprobar
que se puede activar la ventana
e incluso escribir en sus cuadros
de textos, y que el cuadro de
diálogo sigue visible:
Se puede activar la ventana

trasera, e incluso escribir en ella.
Esto es gracias a que el cuadro
de diálogo es no modal.
Por otro lado, el cuadro de

diálogo sigue mostrándose
delante de la ventana. Esto es
gracias a la propiedad
alwaysOnTop
g. Es muy común, cuando tenemos un cuadro de diálogo no modal,

usar la propiedad alwaysOnTop, para que siempre aparezca
delante de la ventana.
222
30. Ahora se estudiará el concepto de cuadro de diálogo modal.
 Un cuadro de diálogo modal es aquel que no permite que se active otra

ventana hasta que este no se haya cerrado.
31. Para convertir nuestro cuadro de diálogo en modal, será necesario que lo
selecciones en el inspector y busques la propiedad modal. Debes activar
esta propiedad.
32. Ahora ejecuta el programa comprueba lo siguiente:

a. Haz que se visualice el cuadro de diálogo de configuración.
b. A continuación intenta activar la ventana haciendo clic sobre ella.
Verás como no es posible activarla. Es más, intenta escribir en
sus cuadros de texto. No será posible hacerlo. (Incluso
observarás un parpadeo en el cuadro de diálogo avisándote de
ello). Esto es debido a que ahora nuestro cuadro de diálogo es
modal.
Aunque intentes activar la ventana o escribir en ella, no podrás, ya que el cuadro de
diálogo es modal.
Incluso verás un parpadeo en el cuadro de diálogo cuando intentas activar la otra
ventana.
Se podría decir que un cuadro de
diálogo modal es un acaparador,
y que no te deja usar otro
elemento hasta que no acabes
con él.
Solo cuando cierres el cuadro de
diálogo podrás seguir trabajando
con la ventana.
c. Solo cuando
pulses, Aceptar, o Cancelar, o
cierres el cuadro de diálogo,
podrás seguir trabajando con tu
ventana.
223
Los Cuadros de Diálogo son ventanas simplificadas que muestran distintas

opciones al usuario. Los objetos JDialog son los que permiten la creación y uso
de cuadros de diálogo en un proyecto java. Para visualizar un JDialog será
necesario llamar a su método setVisible. También son interesantes los métodos
setSize para asignarles un tamaño y setLocation para situar el cuadro de
diálogo en la pantalla. Para cerrar un JDialog será necesario invocar a su
método dispose. Existen dos tipos de cuadros de diálogo: los modales y no
modales. Los cuadros de diálogo modales no permiten que se active otra
ventana hasta que el cuadro de diálogo no se haya cerrado. Los cuadros de
diálogo no modales permiten trabajar con otra ventana a pesar de que el propio
cuadro de diálogo no haya sido cerrado.
TRABAJAR CON VENTANAS PARA SELECCIONAR ARCHIVOS

(JFileChoser)
Las opciones Abrir y Guardar son opciones muy comunes en las aplicaciones.
Estas opciones permiten buscar en el árbol de carpetas del sistema un archivo
en concreto y abrirlo, o bien guardar una información dentro de un archivo en
alguna carpeta. Java proporciona una clase llamada JFileChooser (elegir
Archivo) que permite mostrar la ventana típica de Abrir o Guardar:
Ventana Abrir Archivo:
224
La ventana de guardar es la misma, solo que muestra en su barra de título la

palabra Guardar. El objeto JFileChooser nos facilita la labor de elegir el archivo,
pero no realiza la apertura o la acción de guardar la información en él. Esto
tendrá que ser programado.
El siguiente ejemplo nos muestra cómo trabajar con Ventanas de selección de
Archivos:
1. Vamos a practicar con el JFileChooser. Para ello, crea un nuevo

proyecto.
2. Añade en el proyecto los siguientes elementos:
a. Una barra de menús. Llámala barraMenus.
b. Dentro de ella una opción “Archivo” llamada menuArchivo.
c. Dentro de la opción “Archivo”, introduce los siguientes elementos:
i. Una opción “Abrir”, llamada menuAbrir.
ii. Un separador (llámalo como quieras)
iii. Una opción “Salir”, llamada menuSalir.
3. Una vez hecho esto tu formulario tendrá la siguiente forma:
4. Si ejecutas el programa el menú se verá así:
5. Si observas el Inspector, tendrá un aspecto parecido al siguiente:
225
6. Para que al pulsar la opción “Abrir” de nuestro programa aparezca el

diálogo de apertura de archivos, es necesario añadir a nuestro programa
un objeto del tipo JFileChooser.
Los objetos JFileChooser se añadirán en la zona de “Otros
Componentes” del inspector.
7. Haz clic con el derecho sobre la zona de “otros componentes” y activa la
opción Agregar desde Paleta – Swing – JFileChooser:
8. Aparecerá entonces un objeto JFileChooser dentro de Otros

Componentes. Aprovecha para cambiarle el nombre a este objeto. Su
nombre será elegirArchivo.
El inspector quedará así:
226
9. Una vez hecho esto, ya podemos programar la opción Abrir del menú.
Activa el evento actionPerformed de la opción “Abrir” y programa dentro
de él lo siguiente:
int resp;
resp=elegirArchivo.showOpenDialog(this);
if (resp==JFileChooser.APPROVE_OPTION) {
JOptionPane.showMessageDialog(null,elegirArchivo.getSelectedFile( ).toString( ));
} else if (resp==JFileChooser.CANCEL_OPTION) {
JOptionPane.showMessageDialog(null,"Se pulsó la opción Cancelar");
}
10. Ejecuta el código y prueba la opción “Abrir” del menú. Prueba a elegir
algún archivo y abrirlo. Prueba a cancelar la ventana de apertura. Etc
11. Analicemos el código anterior:
int resp;
resp = elegirArchivo.showOpenDialog(this);
 Estas dos líneas crean una variable entera resp (respuesta) y a

continuación hacen que se muestre la ventana “Abrir Archivo”. Observa
que para conseguirlo hay que usar el método showOpenDialog del
objeto elegirArchivo. Este método lleva como parámetro la ventana actual
(this)
 El método showOpenDialog no solo muestra la ventana “Abrir Archivo”
sino que también devuelve un valor entero según el botón pulsado por el
usuario en esta ventana. Esto es: botón “Abrir” o botón “Calcular”.
227
 Se pueden usar dos if para controlar lo que sucede si el usuario pulsó el

botón “Abrir” o el botón “Calcular” de la ventana “Abrir Archivo”:
if (resp==JFileChooser.APPROVE_OPTION) {
JOptionPane.showMessageDialog(null,elegirArchivo.getSelectedFile( ).toString( ));
} else if (resp==JFileChooser.CANCEL_OPTION) {
JOptionPane.showMessageDialog(null,"Se pulsó la opción Cancelar");
}
 En el primer if se compara la variable resp con la constante

JFileChooser.APPROVE_OPTION, para saber si el usuario pulsó
“Abrir”.
 En el segundo if se compara la variable resp con la constante
JFileChooser.CANCEL_OPTION, para saber si el usuario pulsó
“Calcular”.
 En el caso de que el usuario pulsara “Abrir”, el programa usa el método
getSelectedFile del objeto elegirArchivo para recoger el camino del
archivo elegido. Este camino debe ser convertido a cadena con el
método toString.
 El programa aprovecha esto para mostrar dicho camino en pantalla
gracias al típico JOptionPane.
 En el caso del que el usuario pulsara el botón “Cancelar” el programa
muestra un mensaje indicándolo.
12. Hay que volver a dejar claro que el cuadro de diálogo “Abrir” realmente
no abre ningún archivo, sino que devuelve el camino del archivo elegido
usando el código:
elegirArchivo.getSelectedFile( ).toString( )
Luego queda en manos del programador el trabajar con el archivo

correspondiente de la forma que desee.
Los objetos JFileChooser permiten mostrar el cuadro de diálogo “Abrir Archivo”
o “Guardar Archivo”. Estos objetos no abren ni guardan archivos, solo permiten
al usuario elegir el archivo a abrir o guardar de forma sencilla. El JFileChooser
devuelve el camino del archivo elegido, y luego el programador trabajará con
dicho archivo como mejor le interese.
228
TRABAJAR CON VENTANAS PARA SELECCIONAR COLOR

(JColorChooser)
Un componente GUI algo interesante resulta ser el Selector de Color el cual se

materializa en la clase JColorChooser, cuyas instancias se utilizan para mostrar
una ventana que contiene una paleta de colores en varias tonalidades e incluso
el usuario puede configurar y crear el color que desee, esta clase posee un
método static llamado showDialog el cual muestra la ventana para seleccionar
y suspende la ejecución secuencial del programa hasta que el usuario realice
una de las siguientes opciones:
 Seleccione un color y pulse el botón Aceptar
 Seleccione un color dando doble click en el mismo
 Cierre la ventana desde el botón cerrar sin seleccionar un color
 Cierre la ventana desde el botón cancelar.
Si ocurre la primera o segunda situación, el método showDialog retorna el color

escogido por el usuario y se guarda en una variable. En Java los colores están
representados por el tipo de dato Color, el cual es una clase del paquete
java.awt.
Una vez cerrada la ventana ya sea seleccionado o no un color, la ejecución
secuencial del programa continua justo después de la línea de código donde fue
invocado el método showDialog.
A continuación veremos un ejemplo de cómo trabajar con el Selector de Color.
El siguiente código ejemplo inicia:
Importando las clases necesarias BorderLayout y Color del paquete
java.awt, ActionEvent y ActionListener del paquete java.awt.event
y JButton, JColorChooser, JFrame del paquete javax.swing.
1. Definimos una clase llamada Principal la cual posee un único método,
en este caso el método main o método de ejecución de la aplicación.
2. Dentro del cuerpo `método main declaramos e inicializamos una
instancia de tipo JFrame con el fin de poder mostrar una ventana.
3. Utilizamos la instancia de la ventana para configurar su tamaño a 200
pixeles de ancho y 100 pixeles de alto, además colocarla en el centro de
la pantalla.
4. Declaramos e inicializamos una instancia de la clase JButton, es decir
un Botón de Acción, al cual le colocamos una etiqueta “Ejemplo de
Color”.
229
5. Utilizamos la instancia del JButton para agregarle una instancia de

ActionListener para que escuche los eventos que de Click o Enter
que sucedan sobre el botón.
6. La acción de mejoramiento o actionPerformance que se ejecutara
cuando se pulse el botón será:
7. Mostrar una ventana para selección de color con título “Ejemplo de Color”
y color azul por defecto.
8. Cuando el usuario seleccione el Color este será asignado a la variable
col.
9. Obtenemos el Panel de Contenidos de la ventana y a este le cambiamos
el Color de Fondo por el color seleccionado.
10. Luego de definir la operación de mejoramiento para el evento del botón,
agregamos el botón al Panel de Contenido la Ventana en la parte Norte
de dicha ventana.
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JColorChooser;
import javax.swing.JFrame;
public class Principal {
public static void main(String[ ] args) {

// TODO code application logic her
JFrame ventana = new JFrame("Ejemplo de Color");
ventana.setSize(200, 100);
ventana.setLocationRelativeTo(null);
JButton boton = new JButton("Color aqui");
boton.addActionListener(new ActionListener( ) {
@Override
public void actionPerformed(ActionEvent e) {
Color col = JColorChooser.showDialog(null, "Ejemplo de Color", Color.BLUE);
ventana.getContentPane( ).setBackground(col);
}
230
});
ventana.getContentPane( ).add(boton,BorderLayout.NORTH);
ventana.setVisible(true);
}
}
Al compilar y ejecutar la aplicación podremos observar la siguiente secuencia de

ventanas:
 Primero nos aparee la ventana con el botón para que pulsemos y
seleccionemos el botón.
 Pulsar el botón nos aparece una Ventana para Seleccionar un Color,

observemos que esta ventana no proporciona una gran variedad
opciones para seleccionar un color
231
Al seleccionar el color verde por ejemplo, este se coloca en el panel de colores

recientes y en el Panel de Vista Previa.
Al pulsar en el botón Aceptar, la Ventana de Selección de Color se cierra y el

Color de fondo de la Ventana inicial se torna del color seleccionado.
TRABAJAR CON VENTANAS DE ALERTAS Y DE OPCIONES (JOptionPane)
Todas las aplicaciones requieren presentar información al usuario sobre Alertas

del sistema o simples notificaciones de Advertencia, Error, Información,
Conformación o Simplemente para Solicitar la introducción de un dato
específico, para estos casos Java proporciona una clase llamada JOptionPane,
232
la cual posee un conjunto de métodos de clase (static, es decir, que se pueden

invocar solo con el nombre de la clase) apropiados para cada uno de los casos
descritos anteriormente.
Métodos Parámetros Retorno Descripción

showMessageDialo JComponent Ninguno Permite mostrar una
g e: es el Ventana de Alerta centrada
elemento que sobre el componente que
estará detrás le pasemos como
de esta parámetro, mostrando el
ventana de mensaje que igual le
Alerta pasemos como parámetro.
String: es el
Mensaje que
mostraremos
como Alerta
showInputDialog JComponent String Permite mostrar una

e, String Ventana de que posee un
Es el dato Campo de Texto para
Iguales al que fue ingresar el Dato solicitado,
anterior ingresado está centrada sobre el
en la componente que le
ventana pasemos como parámetro,
mostrando el mensaje que
igual le pasemos como
parámetro, retornando
dicho dato como de tipo
String
showConfirmDialo JComponent Int Permite mostrar una
g e, String, int Ventana de en la cual se
Los dos La solicita conformar una
primeros son respuesta Acción específica
iguales al escogida usualmente mediante un
anterior. por el botón SI y otro NO. Si
El parametro usuario responde SI retorna 1, lo
entero indica que es igual a
233
la respuesta JOptionPane.YES_OPTIO
seleccionada N, o retorna 0 si la
por el usuario respuesta es NO, lo que
equivale a
JOptionPane.NO_OPTIO
N. Esta ventana estará
centrada sobre el
componente que le
pasemos como parámetro,
mostrando el mensaje que
igual le pasemos como
parámetro.
showOptionDialog JComponent Object Es igual a las anteriores
e, String, con la diferencia de que le
Object [ ] Correspond podemos configurar y
e a la cambiar cuales y cuantas
Opción opciones puede escoger el
escogida usuario como respuesta,
por el las opciones deben ir como
usuario un Arreglo de tipo Object
que bien podrían ser String
o Números, etc
* Cada uno de los métodos anteriormente descritos esta sobre cardado (posee
más de una versión o firma, los cuales se diferencian en el número, orden y de
sus parámetros de entrada), favor consultar la documentación de JSDK online
para conocer más al respecto.
Los siguientes ejemplos nos permitirán observar lo fácil que es trabajar con estas
ventanas:
El siguiente código nos presenta un ejemplo de cómo podemos trabajar con los
métodos de la clase JOptionPane para mostrar pequeñas ventanas de Alerta o
Informativa:
1. Importamos las clases necesarias JOptionPane y Color del paquete
javax.swing.
2. Definimos una clase llamada Principal la cual posee un único método,
en este caso el método main o método de ejecución de la aplicación.
3. Dentro del cuerpo método main declaramos mostramos una ventana de
mensaje tipo información.
234
4. Luego mostramos una Ventana de tipo Conformación con un mensaje y

la opción seleccionada por el usuario SI o NO o Cancelar se almacena en
una variable int.
5. Si la opción seleccionada en la Ventana de conformación es igual a SI (el
usuario escogió y pulso el botón SI), entonces mostramos una Ventana
de Mensaje
6. Sin importar la opción escogida por el usuario sea SI o NO seguidamente
mostramos una Ventana de Entrada de Datos mostrando la información
ingresada por el usuario.
public class Principal {
public static void main(String[ ] args) {
// TODO code application logic her
JOptionPane.showMessageDialog(null, "Ejemplo de Alerta", "Saludos",

JOptionPane.INFORMATION_MESSAGE);
int opcion = JOptionPane.showConfirmDialog(null, "¿Te gusta la programacion?");
if(opcion == JOptionPane.YES_OPTION){
JOptionPane.showMessageDialog(null, "Vas por buen camino");
String dato = JOptionPane.showInputDialog(null, "Digite algo");
JOptionPane.showMessageDialog(null, "Usted ha digitado "+dato);
Al ejecutarlo muestra los siguientes mensajes:

Nos aparecer una Ventana de Mensaje, al pulsar en el botón aceptar esta se
cierra
235
Luego nos aparece una ventana de pregunta, la cual muestra por defecto 3
botones.
Luego si pulsamos o escogemos la opción Si, entonces no aparece otra ventana

de mensaje.
Al cerrar la ventana anterior nos aparece otra nueva ventana, pero esta vez es
una ventana de Entrada de Datos, la cual viene acompañada de un mensaje y un
campo de texto para introducir la información que se nos pida.
236
Al introducir el dato y pulsar en el botón Aceptar la Ventana de Entrada de datos

se cierra y aparece una nueva Ventana de Mensaje mostrando la información
que introducimos en la Ventana anterior.
Se puede cambiar el tipo de icono Usando cambiando

INFORMATION_MESSAGE por ERROR_MESSAGE o por
QUESTION_MESSAGE o por WARNING_MENSSAGE o PLAIN_MESSAGE
TRABAJAR CON VENTANAS DE INTERNAS (JInternalFrame)
Todo programa tiene una interfaz gráfica de usuario (GUI) la cual permite a este
manejar el programa de forma sencilla. La interfaz gráfica de usuario consta de
la ventana principal, cuadros de diálogo, botones, cuadros de texto, etc…
Según el tipo de interfaz que tenga el programa, las aplicaciones se suelen
dividir en dos tipos: Aplicaciones SDI y Aplicaciones MDI.
237
Interfaces de Usuario con Simple Documento o SDI

SDI se puede traducir como interfaz de documento único. Esto quiere decir que
las aplicaciones SDI solo pueden mostrar el contenido de un documento a la vez.
Un ejemplo práctico de aplicación SDI es el bloc de notas de Windows. Si en el
bloc de notas quieres escribir un nuevo documento, tienes que cerrar antes el
documento con el que estás trabajando, ya que este programa no admite el
manipular varios escritos a la vez.
Hasta el momento, las aplicaciones de manejo de documentos que hemos
realizado hasta ahora han sido de tipo SDI.
Interfaces de Usuario con Múltiples Documentos o MDI

MDI se puede traducir como interfaz de múltiples documentos. Esto quiere decir
que las aplicaciones MDI pueden mostrar varios documentos a la vez. Un
ejemplo práctico de aplicación MDI es el programa de Seccións de cálculo
Microsoft Excel, en el cual podemos tener varios libros de cálculo abiertos y
trabajar con todos ellos pasando de uno a otro.
Las aplicaciones MDI normalmente constan de una ventana principal, la cual,
puede contener otras ventanas interiores. Cada documento que se abre aparece
en una ventana interior.
En este ejercicio guiado, se explicarán las nociones básicas para crear una
aplicación MDI en Java con NetBeans.
Toda esta teoría es más simple comprenderla mediante ejemplos como el que
veremos a continuación:
Se pretende crear un visor de imágenes MDI, es decir, que permita la
visualización de varias imágenes a la vez. El programa constará de una ventana
principal con un menú. Las opciones de este menú permitirán al usuario abrir
varias imágenes y cerrarlas a su gusto.
Al ser un proyecto MDI, las imágenes se abrirán en ventanas internas. Estas
ventanas internas tendrán que ser diseñadas de forma adecuada.
Para crear este proyecto, tendremos que seguir tres pasos generales:
 Diseño de la ventana principal.
 Diseño de las ventanas internas.
 Programación de la ventana principal / internas.
Diseño de la ventana principal

1. Crea un nuevo proyecto. El nombre del proyecto será VisorFotos. Añade
un paquete llamado paqueteprincipal. Dentro de dicho paquete añade un
JFrame llamado ventanaprincipal.
238
2. Añade a la ventana principal una barra de

menús, con una única opción Archivo, que contenga a
su vez las siguiente opciones:
Asigna los siguientes nombres a cada elemento del

menú:
3. Establece un layout de tipo BorderLayout al JFrame. Recuerda que este

tipo de distribución divide la ventana en cinco zonas: norte, sur, este,
oeste y centro.
239
4. En la zona central de la ventana principal colocaremos un panel, pero no

será un JPanel, como siempre, sino otro tipo de panel. Debes colocar un
panel del tipo JDesktopPane:
Este tipo de panel es usado como contenedor de las ventanas internas

de una aplicación MDI. En NetBeans este tipo de panel se muestra de
color azul, para distinguirlo de los paneles normales, por eso, cuando
añadas el panel al JFrame este quedará así:
240
5. Cámbiale el nombre al JDesktopPane y asígnale el nombre

panelInterno:
6. Si ejecutas el programa ahora, verás que la ventana sale reducida al

mínimo tamaño posible. Esto lo vamos a evitar haciendo que la ventana
aparezca maximizada al ejecutarse el programa. También le
asignaremos un tamaño inicial. Para ello, acude al constructor del
JFrame y programa lo siguiente:
Llamada a un método
ConfiguracionVentana
Programación de dicho método.
Como ves, en el constructor se llama a un método ConfiguracionVentana y en

este método se asigna un tamaño por defecto a la ventana de 800x600 y se
maximiza.
241
Como diseñar las ventanas internas

Se pretende que cuando se abra una imagen, el programa muestre una ventana
interna que contenga la imagen y nada más. La barra de título de esta ventana
interna contendrá el camino de la imagen.
Para diseñar la ventana interna de la aplicación, sigue los pasos que se indican a
continuación:
1. Una ventana interna de una aplicación MDI es un objeto de la clase

JInternalFrame. Será necesario añadir esta clase al proyecto. Para ello,
haz clic con el derecho sobre el paqueteprincipal y elige Nuevo
Archivo/Carpeta.
2. Luego elige Formularios GUI Java y dentro de esta categoría Formulario

JInternalFrame.
El nombre que le pondremos a este tipo de formulario será el de

ventanainterna.
242
Si observas la ventana de proyecto, verás que ahora tenemos dos clases: la

ventana principal, y la ventana interna. Ahora diseñaremos la ventana interna,
para ello, haz doble clic sobre ventanainterna.
Como se dijo anteriormente, las ventanas internas mostrarán simplemente la

imagen que se abra. Para ello, solo hace falta introducir una etiqueta (JLabel)
que será la que contenga la imagen. Esta etiqueta debe ocupar toda la ventana,
no tendrá ningún texto dentro, y su nombre será etiImagen.
243
La etiqueta se llamará etiImagen…
Y ocupará todo el JInternalFram
3. En las Seccións guiadas anteriores, se ha hablado de la programación

orientada a objetos, y se ha comentado que los objetos poseen
propiedades. Estas propiedades son básicamente variables globales
internas. Para poder acceder a estas propiedades, es necesario
programar métodos set. Pues bien, la etiqueta etiImagen de la clase
ventanainterna, no es más que una propiedad de la ventana interna,
y para poder trabajar con ella, será necesario programar un método set
que permita modificar la etiqueta a nuestro antojo.
Básicamente, este método set debe ser capaz de introducir en la etiqueta
una imagen. Haremos que este método reciba como parámetro el camino
de la imagen a mostrar. Así pues, entra en la zona de código de la
ventanainterna y añade después del constructor el siguiente método:
Método para
acceder a la
etiqueta
etiImagen
244
4. En la programación MDI, será habitual crear métodos para poder acceder

a los distintos elementos de la ventana interna (etiquetas, cuadros de
texto, etc) En otras ocasiones, tendremos que crear métodos get para
obtener información de las ventanas internas. Es algo muy similar a la
programación de diálogos propios que se vio en Seccións anteriores.
5. Bien, con la programación de este método de acceso a la etiqueta de la
ventana interna, hemos terminado con el diseño de esta ventana, ahora
empezaremos a programar la ventana principal. Vuelve a ella haciendo
doble clic sobre la ventanaprincipal en la zona de proyectos:
PROGRAMACIÓN DE LA VENTANA Principal
Se pretende ahora programar la opción Abrir del menú de forma que se elija el
archivo de imagen a mostrar y se muestre este en una ventana interna.
La opción Cerrar del menú permitirá cerrar la ventana interna activa en un
momento determinado.
Sigue los pasos que se describen a continuación:
1. Ya estamos preparados para programar las opciones del menú.

Empezaremos por la opción Abrir. Accede al actionPerformed de la
opción Abrir y programa lo siguiente:
245
2.
La opción Abrir se encargará de abrir un archivo de imagen y mostrarlo en una

ventana interna del programa. Lo primero que hace esta opción es mostrar el
cuadro de diálogo Abrir, que se usa para indicar el archivo que se quiere abrir.
Se crea un objeto del tipo JFileChooser a través de la línea:
JFileChooser abrir = new JFileChooser( );
Luego se le da la orden de que muestre el cuadro de diálogo Abrir. La variable

boton recoge el botón pulsado por el usuario (Aceptar / Cancelar)
int boton = abrir.showOpenDialog(null);
Luego, a través de un if, compruebo si se ha pulsado el botón Aceptar…
if (boton==JFileChooser.APPROVE_OPTION) {
Dentro de este if tendremos que programar la acción correspondiente a

abrir la imagen y mostrarla en pantalla. Vamos a ello.
3. Programa dentro del if anterior lo siguiente. El código se comentará a

continuación.
246
Atento a este código, porque define la creación de ventanas internas,

conteniendo la imagen elegida para mostrar. Es el corazón del
programa…
La primera instrucción, crea una ventana interna llamada vi. Como
puedes observar, es la creación de un objeto vi de la clase
ventanainterna.
ventanainterna vi = new ventanainterna( );
Lo siguiente que se hace con el objeto vi creado, es definir sus

características como ventana. Concretamente se decide que sea una
ventana con posibilidad de cambiar de tamaño (setResizable), una
ventana que pueda ser maximizada (setMaximizable), una ventana
247
que pueda ser minimizada (setIconifiable) y finalmente que pueda

ser cerrada (setClosable)
vi.setResizable(true);
vi.setMaximizable(true);
vi.setIconifiable(true);
vi.setClosable(true);
Una vez definidas dichas características de la ventana interna, esta se

añade al panel interno de la ventana principal, al que le dimos el nombre
panelInterno.
panelInterno.add(vi);
Ahora hay que introducir la imagen elegida dentro de la etiqueta de la

ventana. Primero hay que recoger el camino del archivo de imagen
elegido en el cuadro de diálogo abrir.
String camino = abrir.getSelectedFile( ).toString( );
Ahora aprovechamos el método setImagen que programamos

oportunamente dentro de la clase ventanainterna para situar dicha
imagen dentro de la etiqueta.
vi.setImagen(camino);
Colocamos el camino de la imagen en la barra de título de la ventana

interna:
vi.setTitle(camino);
Finalmente hacemos visible la ventana interna.
vi.setVisible(true);
4. Ejecuta el programa y prueba a abrir varios archivos de imagen.

Observa la creación de las ventanas internas.
248
Observa como todas tienen el mismo aspecto (una etiqueta única en la

ventana conteniendo la imagen)
Observa la posibilidad de moverlas, cambiarlas de tamaño, maximizarlas,
minimizarlas y cerrarlas.
Observa como todas las ventanas internas están encerradas dentro de
los límites del panel interno de la ventana principal:
5. Este proyecto se usará en las próximas Seccións. Guárdalo.
La programación MDI consiste en crear aplicaciones capaces de abrir varios

archivos y mostrarlos en distintas ventanas internas.
Una aplicación MDI cuenta con dos elementos básicos:
 Un panel interno JDesktopPane, el cual contendrá las ventanas

internas.
 Una clase del tipo JInternalFrame, la cual definirá el diseño de las
ventanas internas.
La clase JInternalFrame que añadamos, tendrá el nombre que queramos

asignarle y nos servirá de plantilla para crear las ventanas internas de nuestro
proyecto. Esta clase podrá tener métodos internos para acceder a los elementos
de las ventanas internas. Desde la ventana principal, se crearán objetos de la
clase ventana interna, y se definirán opciones relativas a la posibilidad de
249
maximizar, cerrar, minimizar, etc, dichas ventanas. Desde la ventana principal

se usarán los métodos programados en la ventana interna para poder manejarla
con facilidad.
Tal como se explicó anteriormente, una aplicación MDI contiene un panel del tipo
JDesktopPane, dentro del cual se depositan objetos del tipo
JInternalFrame. Los objetos JInternalFrame son ventanas internas.
El programador debe añadir a su proyecto una clase heredada de
JInternalFrame. Esta clase será la ventana interna. El programador diseña el
aspecto de esta ventana y añade los métodos que considere necesarios para el
manejo de dichas ventanas internas.
En la Sección anterior se creó un pequeño proyecto “Visor de Fotos” donde
hicimos todo esto. Este programa es capaz de abrir varias fotos en sus
correspondientes ventanas internas.
En esta Sección veremos cómo podemos actuar sobre las distintas ventanas
internas que han sido abiertas en el JDesktopPane, y para ello usaremos de
nuevo el proyecto “Visor de Fotos”.
En este ejercicio guiado inicial, programaremos la opción Cerrar del proyecto
“Visor de Fotos”. Esta opción debe ser capaz de cerrar la ventana interna que
esté activa en ese momento.
Se sabe cuál es la ventana interna activa porque aparece por encima de las
demás, y porque tiene su barra de título de color azul, mientras que las demás
aparecen en gris. La forma de seleccionar una ventana interna es simplemente
hacer clic sobre ella.
Ventana interna activa
250
1. Abre el proyecto VisorFotos que realizó en la Sección anterior.

2. Accede a la ventana principal del proyecto, haciendo doble clic sobre la
clase ventanaprincipal.
3. Accede al evento actionPerformed de la opción del menú Cerrar y
programa lo siguiente:
4. Ejecuta el programa y comprueba el funcionamiento de la opción Cerrar.

Se recomienda que abra varias imágenes en su programa y luego
seleccione una de ellas. Active la opción Cerrar y observe como la
ventana interna se cierra.
5. El funcionamiento del código que acaba de programar es el siguiente:
El panel interno panelInterno es un objeto del tipo JDesktopPane. Estos
paneles son paneles especiales preparados para contener ventanas
internas (JInternalFrame) y poseen algunos métodos muy útiles para
manipular las ventanas internas que contienen.
Uno de los métodos que más usaremos será getSelectedFrame. Este
método devuelve la ventana interna seleccionada ahora mismo, o null
si no hay ninguna seleccionada. En el código anterior, observarás que
creamos un objeto vactiva del tipo ventanainterna, y dentro de él
metemos la ventana interna seleccionada en este momento, ejecutando
el método getSelectedFrame:
ventanainterna vactiva = (ventanainterna) panelInterno.getSelectedFrame( );
Ahora ya podemos trabajar con vactiva sabiendo que se refiere a la

ventana activa. Lo que se hace a continuación es cerrar la ventana activa
vactiva usando el método dispose típico de los objetos de ventana.
251
Esto se hace, claro está suponiendo que haya alguna ventana activa, por
eso se comprueba que getSelectedFrame no haya devuelto null,
porque en ese caso es que no hay ventana interna activada y por tanto
no se puede cerrar.
6. Este código es muy común a la hora de trabajar en aplicaciones MDI.

Primero se comprueba cual es la ventana activa y luego se actúa sobre
ella. Veamos ahora otro ejemplo. Añade al menú la opción Info:
7. Accede al evento actionPerformed de esta nueva opción y programa
lo siguiente:
8. Este código muestra el camino del archivo de la imagen que está

seleccionada en este momento. Observa que el proceso es el mismo.
252
Primero se extrae la ventana activa, usando el método

getSelectedFrame, almacenándola en una variable llamada vactiva.
ventanainterna vactiva = (ventanainterna) panelInterno.getSelectedFrame( );
Si esta variable es null, entonces es que no hay ninguna ventana

activa.
Si es distinta de null, se trabaja con ella. En el ejemplo anterior
extraemos el texto de la barra de título de la ventana y lo mostramos en
un JOptionPane. (Recuerda que hemos programado la apertura de las
ventanas internas de forma que en la barra de título aparezca el camino
de la imagen)
9. Ejecuta el programa y comprueba el funcionamiento de la opción del
menú Info.
10. Se ha visto que a través del método getSelectedFrame propio de los
JDesktopPane se puede acceder a la ventana activa. Pero, ¿cómo
puedo acceder a otra ventana interna aunque no esté activa?
Para hacer esto, la clase JDesktopPane posee un método llamado
getAllFrames la cual devuelve un vector conteniendo todas las
ventanas internas que hay actualmente en el JDesktopPane.
11. Para practicar con el método indicado en el punto anterior, añade al
menú Archivo una nueva opción llamada Cerrar Todo:
12. Accede al evento actionPerformed de la nueva opción y programa lo

siguiente:
253
13. Analicemos el código anterior.

Lo primero que tienes que observar es el uso de getAllFrames. Este
método devuelve un vector conteniendo todas las ventanas internas
actuales. En nuestro código, almacenamos estas ventanas en un vector
llamado v.
JInternalFrame v[ ] = panelInterno.getAllFrames( );
A continuación, recorremos todo el vector y vamos cerrando cada

ventana almacenada en el vector. Como puedes observar, este código
hace que se cierren todas las ventanas de imagen abiertas.
14. Ejecuta el programa y comprueba el funcionamiento de la opción Cerrar
Todo.
15. Este código es un ejemplo de actuación sobre todas las ventanas
internas abiertas. A continuación usaremos esta misma idea para
organizar las ventanas dentro del panel interno. Añade las siguientes
opciones al menú:
16. La opción Cascada organizará las ventanas internas abiertas en

cascada. Para ello entra en el evento actionPerformed de la opción y
programa lo siguiente:
254
17. Analicemos el código.

Observa de nuevo el uso de getAllFrames para almacenar todas las
ventanas internas abiertas en un vector v:
JInternalFrame v[ ] = panelInterno.getAllFrames( );
A continuación se recorre el vector y se asigna a cada ventana interna

(cada elemento del vector) un tamaño con el método setSize y una
255
posición con el método setLocation. Las posiciones de cada ventana

van variando para situar cada ventana una encima de la otra. El vector se
recorre al revés, desde la última ventana a la primera para mejorar la
visualización de dichas ventanas.
18. Ejecuta el programa y prueba el funcionamiento de la opción Cascada.

Se recomienda que primero abra varias ventanas y luego pulse esta
opción.
En la programación MDI siempre actúan dos elementos:
 Un panel interno JDesktopPane, el cual contendrá las ventanas

internas.
 Una clase del tipo JInternalFrame, la cual definirá el diseño de las
ventanas internas.
El panel interno posee diversos métodos que permiten acceder a las ventanas
actualmente abiertas dentro de él. Entre estos métodos podemos destacar:
 getSelectedFrame, que devuelve la ventana interna activa en el momento

actual.
 getAllFrames, que devuelve un vector de JDesktopPane, conteniendo
todas las ventanas internas abiertas en el panel interno.
Gracias a estos dos métodos podemos acceder a las ventanas internas y actuar
sobre ellas.
PANELES O CONTENEDORES (JPanel, JTabbedPane)
Todos los componentes GUI vistos hasta ahora requieren ser colocados dentro
otros componentes de tipo Contenedor, los cuales fueron diseñado
especialmente para poder colocarles otros componentes incluso otros
contenedores, por ejemplo:
Si diseñamos un formulario de login para iniciar sesión en nuestras
aplicaciones, como mínimo necesitamos de los siguientes componentes:
256
Contenedor de tipo JFrame
Contenedor de tipo JPanel
Etiqueta de Texto JLabel
Campos de JTexto JTextField
Campo de JPasswordField
Botones de Accion JButton
 Dos Etiquetas de Texto de tipo JLabel, uno para la etiqueta ID y otro

para Password.
 Un campo de texto de tipo JTextField para poder escribir el ID
 Un campo de Contraseña de tipo JPasswordField para poder escribir la

clave
 Dos botones de tipo JButton, uno para la acción Aceptar y otro para la
acción Cancelar.
 Para poder mostrar estos componentes en pantalla se requiere que

estén ubicados en algún tipo de contenedor, por ejemplo una ventana o
un panel, pero los paneles requieren estar dentro de otro una ventana
para poder visualizarse.
En ventana anterior los elementos están ubicados siguiendo el siguiente orden:
JFrame ventana
JRootPanel panelDeVentana
JLabel etiquetaID
JLabel etiquetaClave
JTextField campoID
JPasswordField campoClave
JButton botonAceptar
JButton botonCancelar
257
 Las dos Etiquetas de Texto, los dos Campos de Texto y los dos Botones
de Acción fueron agregados a un Contenedor de tipo JRootPanel, el
cual se encuentra ubicado a su vez dentro de otro contenedor de tipo
Ventana JFrame.
 A un contenedor se le pueden agregar componentes u otros

contenedores mediante el método add(JComponent componente),
este método es común para todos los tipos de contendor ya que
pertenece originalmente a la clase Container, quien a su vez es la
clase Padre de todos los contenedores, es decir, que las clases de tipo
Contenedor heredan de Container.
 Java proporciona en su SDK muchos componentes de tipo Contenedor,

los más utilizados son:
 JWindow: Una ventana sin marco, sin barra de título, ni botones para
maximizar, restaurar, minimizar y cerrar. No podemos incluir o agregar
una ventana dentro de otra ventana, solo podemos agregarle
Contenedores y Componentes.
 JFame: Una ventana hija de JWindow, es una ventana común y

corriente, con marco, barra de título, bordes y botones para cerrar,
minimizar, maximizar y restaurar.
 JDialog: Una ventana hija de JFrame, solo posee un boton para cerrar y
carece de los otros dos botones.
 JPanel: No es una ventana, es una panel por defecto de forma

rectangular, en el cual se pueden agregar otros Paneles u otro
Componentes como los vistos hasta ahora.
 No podemos agregar una ventana dentro de un panel, pero si podemos

agregarle otros Paneles o Componentes como los vistos en las
secciones anteriores.
 No podemos mostrar un panel en la pantalla a menos que este dentro de

una ventana, de igual forma sucede con los Componentes de entrada y
salida, los cuales solo podemos visualizar si están dentro de un Panel el
cual debe estar dentro de una Ventana.
258
 JTabbedPane: Es un panel especial al cual solo le podemos agregar
otros paneles y estos se visualizan en forma de pestañas o tarjetas.
 JRootPane: Este panel es hijo de JPanel y viene incluido por defecto

dentro de toda ventana JWindow, JFrame o JDialog, este panel se
puede visualizar al abrir una ventana pues corresponde a toda la zona
dentro de la misma. Cada componente o contenedor que agregamos a
una ventana en realidad los estamos agregando a su JRootPane.
 Podemos acceder a este objeto usando el método getContentPane de

la clase JWindow, JFrame o JDialog, este método retorna un objeto de
tipo Container, el cual podemos convertir a JPanel, por ejemplo:
JPanel panelDeVentana = ventana.getContentPane();
 JGlassPane: Es una panel Hijo de JPanel, el cual tiene como

particularidad que
 su fondo es transparente, esta transparencia se puede configurar en

varios niveles de intensidad.
 JDescktopPane: Es un panel hijo de JPanel, con la particularidad de

que funciona similar al Escritorio de un Sistema Operativo, el cual nos
permite mover (Arrastrar u Soltar) los componentes y contenedores que
agreguemos en su interior, también le podemos colocar imágenes de
fondo muy fácilmente.
 JTextPane: Es un panel especial que además nos permite agregarle

Texto y editarlo, el texto se puede orientar a la izquierda, derecha, arriba,
abajo detrás o sobre los componentes agregados dentro de este panel.
 JEditorPane: Es un panel hijo de JTextPane, con la particularidad

adicional que nos permite editar y dar formato al texto que agreguemos
en su interior, incluyendo imágenes, código HTML, CSS y RTF, tiene las
funciones básicas de un Procesador de Texto como Word. Podemos
utilizar este Panel si deseamos hacer un simple navegador Web, ya que
posee un método llamado setPage el cual recibe una URL de internet o
archive local de Pagina Web y lo visualiza tal y como lo hace cualquier
navegador.
259
 JScrollPane: Este panel solo nos permite agregarle un solo elemento, si
el tamaño del elemento es más grande que el tamaño del mismo panel,
entonces este agrega de forma automática dos barras de
desplazamiento, una pera poder desplazarlo horizontalmente y otro para
desplazarlo verticalmente, de manera que podamos observar todo el
elemento.
TRABAJAR CON PANEL DE DESPLAZAMIENTO (JSCROLLPANE)
Llamaremos paneles de desplazamiento a paneles que contienen elementos tan

grandes que no pueden ser mostrados en su totalidad. Estos paneles contienen
entonces dos barras de desplazamiento que permiten visualizar el interior del
panel de desplazamiento correctamente. Por ejemplo, un panel de
desplazamiento podría contener una imagen tan grande que no se viera entera:
Los paneles de desplazamiento son objetos del tipo JScrollPane.
El siguiente ejemplo nos mostrara como trabajar con este tipo de Contenedor:
1. Vamos a practicar con los JScrollPane. Para ello, crea un nuevo

proyecto.
2. Añade en el proyecto un JScrollPane.
3. Un JScrollPane, por sí mismo, no contiene nada. Es necesario añadir
dentro de él el objeto que contendrá. Para nuestro ejemplo añadiremos
dentro de él una etiqueta (JLabel)
4. El formulario debe tener ahora este aspecto:
260
5. Si observas el Inspector
verás claramente la distribución de
los objetos:
Observa como tienes un
JScrollPane que contiene una
etiqueta.
6. Aprovechemos el Inspector para cambiar el nombre a cada objeto. Al

JScrollPane le llamaremos scpImagen y a la etiqueta etiImagen.
7. Elimina el texto contenido

en la etiqueta etiImagen. Solo
tienes que borrar el contenido de la
propiedad text.
8. Luego introduciremos una imagen dentro de la etiqueta, a través de la

propiedad icon. La imagen la introduciremos desde fichero, y elegiremos
la siguiente imagen de tu disco duro:
Mis Documentos / Mis Imágenes / Imágenes de Muestra / Nenúfares.jpg
9. Esta imagen es tan grande que no se podrá ver entera dentro del panel
de desplazamiento. Ejecuta el programa y observarás el uso de las
barras de desplazamiento dentro del panel.
261
10. Puedes mejorar el programa si agrandas el panel de desplazamiento de
forma que ocupe todo el formulario:
De esta forma, cuando ejecutes el programa, al agrandar la ventana, se

agrandará el panel de desplazamiento, viéndose mejor la imagen
contenida.
11. Ejecuta el programa y compruébalo.
Este Segundo ejemplo veremos cómo agregar Componentes diferentes a

Imágenes.
Los JScrollPane no solo están diseñados para contener imágenes. Pueden

contener cualquier otro elemento. Vamos a ver, con otro proyecto de
ejemplo, otro uso de los JScrollPane.

2. Añade a la ventana una etiqueta con el texto “Ejemplo 2 de JScrollPane”
y un JScrollPane de forma que esté asociado a los límites de la ventana.
Observa la imagen:
262
3. Ahora añade dentro del JScrollPane un panel normal (JPanel). En la
ventana no notarás ninguna diferencia, pero en el Inspector debería
aparecer esto:
4. Como ves, el
JScrollPane contiene a un
objeto JPanel.
5. Aprovechemos para
cambiar el nombre a ambos
objetos. Al JScrollPane lo
llamaremos scpDatos y al
JPanel lo llamaremos panelDatos.
6. Los JPanel son

objetos contenedores. Es
decir, pueden contener otros
objetos como por ejemplo
botones, etiquetas, cuadros
de texto, etc.
7. Además, los JPanel
pueden ser diseñados
independientemente de la ventana. Haz doble clic sobre el panelDatos
en el Inspector y observa lo que ocurre:
263
8. En la pantalla aparecerá únicamente el JPanel, para que puede ser
diseñado aparte de la ventana completa:
 Para distinguirlo de
lo que es en sí la ventana,
haremos las siguientes
cosas con el panel:
 Cambia el color de
fondo y asígnale un color
verde.
 Añade en él una
etiqueta con el texto
“Panel de Datos”.
 Añade varias
etiquetas y cuadros de
textos correspondientes a
los días de la semana.
 Agranda el panel.
 El panel debería quedar así. Toma
como referencia esta imagen:
Es muy interesante que observes el

Inspector. En él podrás observar la
distribución de los objetos en la ventana.
Podrás ver como el JFrame contiene un
JScrollPane (scpDatos) que a su vez
contiene un JPanel (panelDatos) que a
su vez contiene una serie de etiquetas y
cuadros de textos a los que aún no les
hemos asignado un nombre:
9. Haz doble clic sobre el JFrame (en el Inspector) para poder ver
globalmente la ventana. En la pantalla debería aparecer esto:
Como ves, el JPanel contenido en el JScrollPane es más grande que él,

por lo que no se podrá visualizar completamente. Será necesario usar las
barras de desplazamiento del JScrollPane.
10. Ejecuta el programa para entender esto último.
264
Los objetos JScrollPane son
paneles de desplazamiento.
Estos paneles pueden contener
objetos mayores que el propio
panel de desplazamiento.
Cuando esto sucede, el panel
muestra barras de
desplazamiento para poder
visualizar todo el contenido del
panel.
Los JScrollPane son ideales para
mostrar imágenes, paneles y
otros elementos cuyo tamaño
pueda ser mayor que la propia
ventana.
LIENZOS PARA ADMINISTRAR LA POSICION Y DISTRIBUCION DE LOS COMPONENTES

DENTRO DE LOS CONTENEDORES
Cuando agregamos elementos (Componentes o Contenedores) a cualquier

Contenedor lo hacemos usando una de dos formas:
 Sin utilizar Layout (lienzo): Indicando las coordenadas X (horizontales), Y
(Verticales), el ancho y el alto del componente dentro del contenedor,
mediante el método setBounds(x, y, width, height);
265
 Utilizando uno o varios Layout (lienzo)
Supongamos que deseamos construir un formulario para iniciar sesión tal y
como se muestra en la siguiente imagen:
 El cual posee los siguientes

componentes:
 Una Ventana de tipo JFrame
 Dos JLabel para el texto ID y el Texto

Password
 Un JTextField para ingresar el ID
 Un JPasswordField para ingresar la

Clave
 Dos botones para registrar y otro

para Entrar.
Para diseñarlo sin utilizar Layout necesitamos conocer el tamaño (Ancho y Alto)
en pixeles del Contenedor sobre el cual vamos a agregar elementos GUI, luego
seguimos los siguientes pasos:
1. Crear la ventana y establecer sus dimensiones.
JFrame ventana = new JFrame(“Inicio de Sesión”);

2. Obtener el contendor Raíz de la Ventana para poder agregarle lo

componentes.
JPanel panelVentana = (JPanel) ventana.getContentPane();
3. Establecer que el panel de la Ventana no tendrá Layout
panelVentana.setLayout(null);
4. Crear los Componentes
JLabel etiquetaID = new JLabel(“User”);
266
JLabel etiquetaClave = new JLabel(“Password”);
JTextField campoID = new JTextField ();
JPasswordField campoClave = new JPasswordField ();
JButton botonEntrar = new JButton(“Login”);
JButton botonRegistrar = new JButton(“Register”);
5. Establecer la posición y dimensiones de cada componente dentro del

Contenedor.
int x = 10;
int y = 10;
int ancho = 70;
int alto = 30;
etiquetaID.setBounds( x, y, ancho, alto); // 10,10, 70,30
campoID.setBounds( x+90, y, ancho+50, alto);
// 100, 10, 120, 30
etiquetaClave.setBounds( x, y+40, ancho, alto);
// 10, 50, 70, 30
campoClave.setBounds( x+90, y+40, ancho+50, alto);
//100, 150, 120, 30
botonEntrar.setBounds( x, y+90, ancho, alto);
// 10, 100, 70, 30
botonRegistrar.setBounds( x+90, y+90, ancho, alto);
//100, 100, 70, 30
6. Agregar los componentes al Contenedor.
panelVentana.add(etiquetaID);
panelVentana.add(campoID);
panelVentana.add(etiquetaClave);
panelVentana.add(campoClave);
panelVentana.add(botonEntrar);
panelVentana.add(botonRegistrar);
7. Colocar la ventana en el centro de la pantalla
ventana.setLocationRelativeTo(null);
267
8. Mostrar la ventana
ventana.setVisible(true);
Para probar que la ventana queda igual a la que se muestra en la imagen

anterior, debes:
1. Crear un proyecto de NetBeans tipo Aplicación, Categoría Aplicación

Java
2. En el método main de la clase Principal escribe las instrucciones de
código que están descritas anteriormente
3. Importa las clases necesarias
4. Compila y ejecuta la aplicación.
Como veras, todo esto es tedioso muy tedioso, ya que debemos llevar la cuenta
de las coordenadas que aplicamos a cada componente para que no queden
montados uno sobre el otro, pero además debemos tener en cuenta que las
dimensiones y coordenadas no superen las dimensiones del componente.
Por ejemplo:
La ventana tiene un ancho de 250 pixeles de ancho y 150 pixeles de alto, por lo
tanto la primera coordenada del eje X es 0 y la última es 249, mientras que las
coordinadas del eje Y van desde 0 hasta 149.
int x = 10;
int y = 10;
Las variables X y Y nos servirán para irnos desplazando en las coordinadas de

los respectivos ejes, y las inicializamos en los pixeles 10.
panelVentana.setLayout(null);
Para poder agregar los componentes al Panel debemos primero establecer su

layout en null, es decir que no tenga layout.
Establecemos en que coordenadas deseamos ubicar a cada componente dentro
de la Ventana, para ello utilizamos el método setBound de cada componente,
este método recibe 4 parámetros, el primero es la coordinada X, el segundo es la
268
coordenada Y, el tercero es el ancho en pixeles del componente sobre el eje X
partiendo de la coordinada X, el cuarto y último parámetro es el alto en pixeles
del componente sobre el eje Y de la ventana, igualmente partiendo del valor de
la coordinada Y.
etiquetaID.setBounds( x, y, ancho, alto); // 10,10, 70,30
La etiquetaID la vamos a ubicar en el Pixel 10 del eje X y del eje Y, el ancho

será de 70 pixeles (a la izquierda) a partir del pixel 10, ósea, desde el Pixel 10
hasta el pixel 80 del eje X y tendrá un alto o grosor de 30 pixeles (Hacia abajo),
desde el pixel 10 hasta el pixel 40 en el eje Y.
campoID.setBounds( x+90, y, ancho+50, alto);

// 100, 10, 120, 30
El campoID lo vamos colocar en el pixel 100 del eje X y el pixel 10 del eje Y,
tendrá un ancho de 120, y un grosor de 30, esto quiere decir que entre la
etiquetaID y el campoID habrán 10 pixeles de especio que los separe, ya que
en la etiquetaID estará ubicada desde el punto 20 hasta el en el eje X
mientras que el campoID está ubicado desde el punto 100 hasta el punto 220 en
el mismo eje.
etiquetaClave.setBounds( x, y+40, ancho, alto);

// 10, 50, 70, 30
La etiquetaClave la colocaremos 10 pixeles debajo de la etiquetaID, por lo tanto

su coordenada en el eje Y iniciara en el pixel 50 y como su alto es de 30,
entonces el grosor ira desde el pixel 50 hasta el pixel 80 en el eje Y, debido a
que el grosor de la etiquetaID va desde el pixel 10 hasta el pixel 40 del eje Y (su
grosor es de 30 a partir de 10 = 40). Su ancho será desde el pixel 10 hasta el
pixel 80 en el eje X.
campoClave.setBounds( x+90, y+40, ancho+50, alto);

//100, 150, 120, 30
Para el caso del campoClave, este lo debemos desplazar hasta el pixel 100 del
eje X y desde allí tendrá un ancho de 120 pixeles, es decir que ira desde el 100
269
hasta el 220 sobre el eje X. Su grosor iniciara desde el pixel 50 del eje Y y
avanzara 30 pixeles hacia abajo hasta llegar al pixel 80 en el eje Y.
Partiendo de esta explicación es fácil calcular los datos para los dos botones.
botonEntrar.setBounds( x, y+90, ancho, alto);

// 10, 100, 70, 30
botonRegistrar.setBounds( x+90, y+90, ancho, alto);
//100, 100, 70, 30
Uno de los problemas que más quebraderos de cabeza dan al programador es el

diseño de las ventanas y la situación de los distintos componentes en ellas.
Para diseñar más cómodamente las ventanas, Java proporciona una serie de
objetos denominados Layouts, que definen la forma que tendrán los elementos
de situarse en las ventanas. Así pues, un Layout define de qué forma se
colocarán las etiquetas, botones, cuadros de textos y demás componentes en la
ventana que diseñamos.
Por fortuna existen Herramientas muy intuitivas, simples de utilizar y efectivas
que nos permiten diseñar Interfaces de Usuario sin tener que preocuparnos por
llevar estos cálculo, solo tenemos que cambiar establecer el Layout a null en el
contenedor sobre el cual estamos trabajando, luego vamos a la paleta de
componentes GUI escogemos un Componente arrastrándolo y soltándolo sobre
dicho Contenedor (generalmente un JPanel u derivado del mismo), el IDE va
generando el código de forma automática.
Otra alternativa un poco más simple de utilizar para evitar el uso de coordinadas
sobre los Contenedores, es el uso de Lienzos o Layout, los cuales son clases
especialmente diseñadas que nos permiten de manera predefinida ubicar los
compontes en zonas específicas del Contenedor. Por ejemplo, para el ejemplo
anterior podemos hacer lo mismo utilizando uno o varios Layout según nuestra
necesidad, en este caso el más útil seria el GridLayout, el organiza los
Componentes dentro de un contenedor en celdas conformadas por filas y
columnas invisibles, así:
Creamos un objeto o instancia de tipo GridLayout con 3 filas y 2 columnas, el
primer parámetro del constructo corresponde al número de filas y el segundo al
número de columnas.
GridLayout rejilla = new GridLayout(3,2);
270
Seguidamente establecemos que este será el lienzo para panel contenedor de la
ventana.
panelVentana.setLayout( rejilla );
Después de crear los componentes debemos asignarles una dimensión preferida

a cada uno para que no tengan el mismo tamaño todos, debido a que por
defecto una vez colocados dentro del Contenedor estos tomaran el mismo ancho
y alto de las celdas del lienzo, las cuales tienen todas el mismo tamaño.
etiquetaID.setPreferredSize( 70, 30); // ancho, grueso
campoID.setPreferredSize( 120, 30); ); // ancho, grueso
// …
Luego agregamos cada componente al Contenedor en el mismo orden que

queremos aparezcan siguiendo la secuencia por filas, desde la primera hasta la
última de izquierda a derecha.
// será colocada en la primera celda de la primera fila
panelVentana.add( etiquetaID );
// será colocado en la segunda celda de la primera fila
panelVentana.add( campoID );
// será colocada en la primera celda de la segunda fila
panelVentana.add( etiquetaClave );
// será colocado en la segunda celda de la segunda fila
panelVentana.add( campoClave );
// será colocado en la primera celda de la tercera fila
panelVentana.add( botonEntrar );
// será colocado en la segunda celda de la tercera fila
panelVentana.add( botonRegistrar ) ;
271
El uso de layout tiene muchos beneficios para mejorar la portabilidad de nuestras
aplicaciones, entre los que se encuentran:
 Los componentes siempre estarán en la posición donde deseamos que
estén, sin importar el sistema operativo donde estemos ejecutando la
aplicación o el tipo de pantalla que tenga instalado el PC.
 Si la ventana o contenedor aumenta o disminuye su tamaño, los
componentes en su interior se ajustaran al nuevo tamaño.
 No es necesario dar dimensiones a la Ventana invocando el método
setSize, en su lugar se invoca el método pack() el cual calcula
automáticamente el tamaño que debe tener la ventana según las
dimensiones de los componentes en su interior
TRABAJAR CON LAYOUT DE DISEÑO LIBRE
Durante el desarrollo del siguiente ejemplo veremos cómo trabajar diseñar

Interfaces de Usuario en forma libre, sin utilizar layout, pero esto será con ayuda
del magnífico IDE Netbeans, que como ya sabemos nos hace feliz la vida a
facilitarnos muchas tareas.

2. Añade una etiqueta y un botón. Muévelos a la posición que se indica en
la imagen. Deben aparecer las líneas “guía” de color azul que se
muestran:
272
3. Las líneas azules que aparecen indican con qué otro elemento está
relacionado un componente de la ventana. La situación de un elemento
dependerá siempre de la situación del otro.
Dicho de otra forma, las líneas azules indican las distancias que siempre
se respetarán. Observa la siguiente imagen:
Tanto el botón como la

etiqueta estarán siempre
a esta distancia del borde
derecho de la ventana…
El botón siempre
estará a esta
distancia de la
etiqueta…
El botón siempre
estará a esta distancia
del borde inferior de la
ventana…
4. Ejecuta el programa y prueba a ensanchar (o achicar) la ventana por el

lado derecho y por el lado inferior. Debes observar como la etiqueta y el
botón mantienen sus distancias relativas entre sí y con los bordes
derecho e inferior de la ventana.
Siempre se mantienen las distancias

relativas definidas en el diseño
aunque el tamaño de la ventana
cambie.
273
5. Este comportamiento de los elementos en la ventana viene dado por una
opción del NetBeans llamada Diseño Libre (Free Design)
TRABAJAR CON LAYOUT DE DISEÑO LIBRE
El Diseño Libre permite que los elementos de una ventana mantengan una
distribución relativa da igual el tamaño que tenga la ventana. Dicho de otra
forma, los elementos se redistribuyen al cambiar el tamaño de la ventana. El
problema del Diseño Libre es el poco control que se tiene sobre los elementos
que se añaden a la ventana. Se puede observar como a veces los elementos no
se colocan en la posición que deseamos o como cambian de tamaño de forma
inesperada. Todo esto es debido a la necesidad de dichos elementos de
mantener unas distancias relativas con otros elementos de la ventana. Cuantos
más elementos tengamos en una ventana, más difícil será el colocarlos usando
el Diseño Libre.
El Diseño Libre es la opción que está activada por defecto cuando se crea un
proyecto en NetBeans. Sin embargo, esta opción se puede cambiar por distintos
“Layouts” o “Distribuciones”.
1. En el Inspector de tu proyecto pulsa el botón derecho del ratón sobre el

objeto JFrame y activa la opción Establecer Disposición – AbsoluteLayout.
Este layout es similar a trabajar sin layout, siendo que este utiliza sus propios
sistemas de coordinadas dentro del contenedor. Hoy día podemos encontrar
muchas clases de Layout, todos derivados de las Clases de Layout que
ofrece Java en su SDK.
274
2. El Inspector tendrá la siguiente forma ahora en su árbol de jerarquía de
componentes agregados a la Ventana:
Como ves, aparece un objeto

dentro del JFrame llamado
AbsoluteLayout. Este objeto
define otra forma de situar los
elementos en la ventana.
2 Concretamente, la distribución
AbsoluteLayout permite al
programador colocar cada
elemento donde él quiera, sin
restricciones, sin tener en
cuenta distancias relativas.
3. Sitúa la etiqueta y el botón donde quieras. Observa que no aparece

ninguna línea guía que defina distancias relativas, eso se debe a que la
posición de los componentes es absoluta dentro de las coordinadas del
contenedor, en este caso el Panel Raíz de la ventana:
275
4. La ventana de definir una distribución AbsoluteLayout es la facilidad para
colocar cada elemento en la ventana (no tendrás los problemas del
Diseño Libre). Sin embargo, la desventaja es que los elementos no
mantienen una distribución relativa respecto al tamaño de la ventana.
5. Ejecuta el programa y reduce su ancho. Observa lo que ocurre:
Verás que los elementos de la ventana son inamovibles aunque la
ventana cambie de tamaño. En cambio, en el Diseño Libre los elementos
intentaban siempre estar dentro de la ventana.
TRABAJAR CON LAYOUT FLUIDO (FlowLayout)
Practiquemos ahora con otro tipo de distribución. Accede al Inspector y pulsa el

botón derecho del ratón sobre el objeto JFrame. Activa la opción Establecer
Disposición – FlowLayout.
276
1. Observa como el layout “AbsoluteLayout” es sustituido por la distribución
“FlowLayout”. Un elemento solo puede tener un tipo de distribución a la
vez.
2. Observa la ventana. Los elementos se han colocado uno detrás de otro.

Se han colocado “en línea”. Esto es lo que hace el “FlowLayout”. Fuerza
a los distintos elementos a que se coloquen en fila.
277
3. Si seleccionas el FlowLayout en el Inspector, podrás acceder a sus
propiedades (los layout son objetos como los demás) Una de las
propiedades del FlowLayout se llama alineación y permite que los
elementos estén alineados a la izquierda, derecha o centro. El
FlowLayout tiene una alineación centro por defecto.
4. El FlowLayout no permite controlar la posición de los elementos en la

ventana, pero sí procura que los elementos estén siempre visibles
aunque la ventana se cambie de tamaño. Ejecuta el programa y observa
el comportamiento del FlowLayout al agrandar o achicar la ventana:
En el FlowLayout,
los elementos
intentan siempre
estar dentro de la
ventana, aunque
esta se cambie de
tamaño…
TRABAJAR CON LAYOUT DE REJILLA (GridLayout)
1. Otra distribución que se puede usar es la distribución GridLayout. Esta

distribución coloca a los elementos en filas y columnas, como si formaran
parte de una tabla. Al añadir esta distribución es necesario indicar
cuantas filas y columnas tendrá la rejilla.
2. Cambia el layout del JFrame por un GridLayout:
278
3. Marca el GridLayout y cambia sus propiedades Filas y Columnas.
Asigna a la propiedad Filas un 2 y a la propiedad Columnas un 3.
279
4. Al asignar 2 filas y 3 columnas al GridLayout, conseguiremos que los
elementos de la ventana se distribuyan en una tabla como la siguiente:
Los distintos elementos se adaptarán al espacio que tienen asignado,

cada celda, o lo spodemos cambiar se tamaño invocando el método
setPreferredSize(new Dimension(alto, ancho)).
5. Ya que solo tienes dos elementos en la ventana (una etiqueta y un

botón), añade otros cuatro elementos más (cuatro botones) para
observar cómo se distribuyen en la cuadrícula.
280
6. En un GridLayout, los elementos estarán situados siempre en una
casilla de la rejilla, ocupando todo su espacio. El programador no tiene
mucho control sobre la disposición de los elementos.
7. Ejecuta el programa y agranda y achica la ventana. Observa como los

elementos siempre mantienen su disposición en rejilla y siempre
aparecen dentro de la ventana aunque el tamaño de esta varíe.
Con un GridLayout los

elementos aparecen en
filas y columnas.
Siempre aparecen
dentro de la ventana
aunque el tamaño de
esta cambie.
TRABAJAR CON LAYOUT DE BORDES (BorderLayout)
Otra de las distribuciones posibles es la llamada BorderLayout. Esta

distribución coloca los elementos de la ventana en cinco zonas:
281
 Zona norte (parte superior de la ventana)
 Zona sur (parte inferior de la ventana)
 Zona este (parte derecha de la ventana)
 Zona oeste (parte izquierda de la ventana)
 Zona centro.
1. Haz clic con el derecho sobre el JFrame y asigna una distribución

“BorderLayout”.
2. Para poder entender el funcionamiento del BorderLayout, se

recomienda que el JFrame contenga únicamente 5 botones (elimine los
elementos que tiene ahora y añada cinco botones)
La ventana tendrá un aspecto parecido al siguiente:
282
3. Como se puede observar, cada botón se ha colocado en una zona, y su
tamaño ha variado hasta ocupar la zona entera. Tenemos un botón en el
norte, otro al sur, uno al este, otro al oeste y uno en el centro.
El programador no tiene mucho control sobre la disposición de los
elementos en la ventana al usar esta distribución.
4. Ejecuta el programa y observa como los elementos siempre se
mantienen dentro de la ventana aunque esta cambie de tamaño.
Con un GridLayout los

elementos aparecen
zonas.
Siempre aparecen
dentro de la ventana
aunque el tamaño de
esta cambie.
283
El diseño de la ventana viene definido por los Layouts o distribuciones.
 Diseño Libre – Esta distribución viene activada por defecto en el

NetBeans, y define una distribución de componentes en la que se
respetan las distancias entre ellos cuando la ventana cambia de tamaño.
 AbsoluteLayout – En esta distribución el programador puede colocar

cada elemento en la posición que desee de la ventana. Los distintos
elementos mantienen su posición aunque la ventana cambie de tamaño,
lo que puede hacer que si la ventana se reduce de tamaño algunos
elementos no se vean.
 FlowLayout – En esta distribución los elementos se colocan uno detrás

de otro. Los elementos intentarán estar dentro de la ventana aunque esta
se reduzca de tamaño.
 GridLayout – Esta distribución coloca a los elementos en filas y

columnas. Los elementos siempre estarán dentro de la ventana aunque
esta se reduzca de tamaño.
 BorderLayout – Esta distribución coloca a los elementos en zonas. Los

elementos siempre estarán dentro de la ventana aunque esta se reduzca
de tamaño.
A la hora de diseñar una ventana o formulario se debe tener en cuenta dos

cosas:
 La facilidad a la hora de colocar muchos componentes en la ventana.

 Que dichos componentes estén siempre visibles independientemente del
tamaño de la ventana.
La distribución AbsoluteLayout por ejemplo nos da mucha facilidad a la hora de

colocar los elementos en la ventana, pero sin embargo los componentes no se
adaptan a los cambios de tamaño. El Diseño Libre en cambio permite crear
ventanas en las que sus componentes se “recolocan” según el tamaño de estas
pero a cambio crece la dificultad del diseño.
Para aprovechar las ventajas de los distintos layouts y minimizar sus

inconvenientes, es habitual en java crear una estructura de paneles cada uno de
ellos con un layout distinto, según nuestras necesidades.
284
Normalmente, al JFrame se le asigna un layout que lo divida en zonas, como
puede ser el BorderLayout o el GridLayout. Luego, dentro de cada una de
estas zonas se introduce un panel (objeto JPanel). Y a cada uno de estos
paneles se le asigna el layout que más le convenga al programador
(FlowLayout, Diseño Libre, AbsoluteLayout, etc…) Finalmente, dentro de cada
panel se añaden los componentes de la ventana.
JFrame
(BorderLayout o GridLayout)
JPanel 1 JPanel 2 etc…

(Diseño Libre, AbsoluteLayout o (Diseño Libre, AbsoluteLayout o
FlowLayout) FlowLayout)
Componentes Componentes
El diseño de Interfaces de Graficas de Usuario se basa en gran medida en

realizar un boceto en papel de dicha GUI y luego combinar Paneles y Layout.
El siguiente ejemplo veremos el uso de diferentes Layout y diferentes Paneles

Se pretende crear un proyecto con una ventana de diseño complejo.
Para ello sigue los siguientes pasos:
2. En primer lugar, asigna un BorderLayout al JFrame :
285
3. El BorderLayout divide la ventana principal en zonas. Ahora añade un
panel (JPanel) a la zona norte de la ventana. (Propiedades )
Panel en la zona norte.
4. Cambia el nombre a este panel y llámalo panelTitulo, ya que contendrá el

nombre del programa.
5. Añade otro panel, esta vez a la parte central. El panel se llamará

panelDatos:
6. Añade un nuevo panel en la parte sur de la ventana. Su nombre será

panelEstado.
286
NOTA. A veces resulta complicado agregar un panel en una zona de la ventana
cuando tenemos un BorderLayout. Puedes entonces hacer clic con el derecho
sobre JFrame en el Inspector y activar la opción Agregar desde paleta – Swing
– JPanel.
7. Si el panel no se coloca en el sitio deseado, se puede seleccionar en el

Inspector y activar su propiedad Dirección, e indicar la zona donde se
quiere colocar:
El panel debería estar situado finalmente en el sur de la ventana:

8. El Inspector tendrá la siguiente forma ahora:
9. Añade ahora tú solo un panel en la zona oeste llamado panelBotonera y

otro en la zona está llamado panelVerificacion. El Inspector debería tener
la siguiente forma al finalizar:
287
10. Cada panel puede ser diseñado de forma individual, simplemente
haciendo doble clic sobre él. Así pues, empezaremos diseñando el panel
panelBotonera. Haz doble clic sobre él.
11. En la parte izquierda del NetBeans aparecerá únicamente el

panelBotonera. Agrándalo para que tenga la siguiente forma:
12. A cada panel se le puede asignar un Layout distinto. A este panel le

asignaremos un AbsoluteLayout para poder colocar cada elemento
donde quiera. Asigna un AbsoluteLayout al panel haciendo clic con el
derecho sobre él en el Inspector. El Inspector debería quedar así:
Ahora añade cuatro botones al panel. Observa como tienes libertad total
para colocar cada botón donde quieras. Procura que el panel quede así:
288
(No nos vamos a preocupar en este ejercicio de los nombres de los
componentes)
13. Ahora diseña el panel panelVerificación haciendo doble clic sobre él.
14. Asígnale también un layout AbsoluteLayout.
15. Coloca en él cuatro casillas de verificación. El aspecto del panel al
terminar debe ser parecido al siguiente:
Y el Inspector debe tener un estado

similar a este:
16. Ahora se diseñará el

panelTitulo. Haz doble clic sobre él.
289
17. En este caso se le añadirá un FlowLayout. Recuerda que este layout
hace que cada elemento se coloque uno detrás de otro.
18. Añade al panel dos etiquetas como las que siguen. Ponle un borde a
cada una:
El Inspector tendrá este aspecto en lo que se refiere al panelTitulo...
19. El panelEstado lo diseñaremos sin asignar ningún layout, es decir,

usando el Diseño Libre. En él añadiremos tres etiquetas de forma que
estas mantengan una distancia relativa con respecto al límite derecho del
panel. Dicho de otra forma, que siempre estén pegadas a la parte
derecha del panel:
Observa las líneas “guía”. Indican que las etiquetas dependen de la parte
derecha del panel. A su vez cada una depende de la otra. Es como si
estuvieran “enganchadas”, como los vagones de un tren.
20. El panelDatos lo vamos a complicar un poco. Haz doble clic sobre él para
diseñarlo y asígnale un GridLayout.
290
21. Marca el GridLayout y asígnale 2 filas y 2 columnas, para que
interiormente tenga forma de una rejilla como esta:
22. A cada una de las divisiones del GridLayout del panelDatos le

asignaremos un nuevo panel. Añade al panelDatos cuatro paneles. Esto
lo puedes hacer fácilmente haciendo clic con el botón derecho del ratón
sobre el panelDatos en el Inspector y eligiendo la opción Añadir desde
paleta – Swing – JPanel.
El aspecto del inspector debería ser como el que sigue, en lo que se

refiere al panelDatos:
23. Asignaremos a cada uno de los cuatro paneles los siguientes nombres:
panelEtiqueta1, panelCuadro1, panelEtiqueta2, panelCuadro2. El panel
quedará así en el Inspector.
291
Así pues, el panel panelDatos tiene forma de rejilla con cuatro celdas, y
en cada celda hay un panel. Puede imaginarse el panelDatos así:
panelDatos
PanelEtiqueta1 PanelCuadro1
PanelEtiqueta2 PanelCuadro2
24. Ahora añada etiquetas al panelEtiqueta1 y al panelEtiqueta2. Y cuadros

de textos al panelCuadro1 y panelCuadro2. El panel panelDatos debe
quedar así:
25. Finalmente ejecuta el programa y comprueba cómo se comportan los

elementos según el panel donde se encuentre y el layout asignado a
cada uno.
Para el diseño de ventanas muy complejas, ser suelen definir layouts que dividan
en zonas el JFrame , como por ejemplo el BorderLayout o el GridLayout.
Dentro de cada una de dichas zonas se añade un JPanel, al que se le asigna un
AbsoluteLayout, un FlowLayout o se mantiene el Diseño Libre.
292
Es posible asignar a un panel un layout de zonas, como el GridLayout, y, a su
vez, introducir en él nuevos paneles, y así sucesivamente.
PROPIEDADES DE UNA CLASE (Variables Globales o Miembros)
Las propiedades de la clase en java es el equivalente a las variables globales en

lenguajes estructurados como el C. Una propiedad es una variable que puede
ser accedida desde cualquier evento programado. Esta variable se inicializa a un
valor cuando se ejecuta el programa y los distintos eventos pueden ir cambiando
su valor según se necesite. Veamos un ejemplo para entender el funcionamiento
de las propiedades de la clase / variables globales.
Mediante el siguiente ejemplo aprenderemos a utilizar las Propiedades de una

clase, también llamadas Variables Globales o Variables Miembro:
1. Crea un nuevo proyecto llamado ProyectoParking. Dentro de él añade un

paquete llamado paqueteParking. Y finalmente añade un JFrame
llamado Parking. El aspecto de tu proyecto será el siguiente:
Clase Principal
2. Tu clase principal es la clase Parking.
3. Se pretende hacer un pequeño programa que controle los coches que

van entrando y van saliendo de un parking. En todo momento el
programa debe decir cuántos coches hay dentro del parking. Para ello
debes crear una ventana como la que sigue:
293
4. Esta ventana contiene lo siguiente:
 Un botón “Entró un coche” llamado btnEntro.

 Un botón “Salió un coche” llamado btnSalio.
 Un botón “Reiniciar” llamado btnReiniciar.
 Una etiqueta con el texto “Coches en el Parking”.
 Una etiqueta con borde llamada etiCoches que contenga un “0”.
5. Se pretende que el programa funcione de la siguiente forma:
a. Cuando el usuario pulse el botón “Entró un coche”, el número de

coches del parking aumenta en 1, mostrándose en la etiqueta
etiCoches.
b. Si el usuario pulsa el botón “Salió un coche”, el número de
coches del parking disminuye en 1, mostrándose en la etiqueta
etiCoches.
c. El botón Reiniciar coloca el número de coches del parking a 0.
6. Para poder controlar el número de coches en el Parking, es necesario

que nuestra clase principal Parking tenga una propiedad (variable global)
a la que llamaremos coches. Esta variable será entera (int).
294
Esta variable contendrá en todo momento los coches que hay
actualmente en el Parking. Esta variable podrá ser usada desde
cualquier evento.
7. Para crear una variable global haz clic en el botón “Origen” para acceder
al código:
8. Luego busca, al comienzo del código una línea que comenzará por
public class
Seguida del nombre de tu clase principal “Parking”.

Debajo de dicha línea es donde se programarán las propiedades de la
clase (las variables globales)
Aquí se declaran las variables

globales, también llamadas
propiedades de la clase.
9. En dicho lugar declararás la variable coches de tipo int:
295
Declaración de una
variable global int
llamada coches.
10. Cuando el programa arranque, será necesario que la variable global

coches tenga un valor inicial. O dicho de otra forma, será necesario
inicializar la variable. Para inicializar la variable iremos al constructor.
Añade lo siguiente al código:
Inicialización de la
propiedad coches.
Inicializamos a cero ya que se supone que cuando arranca el programa

no hay ningún coche dentro del parking.
11. Ahora que ya tenemos declarada e inicializada la variable global coches,

esta puede ser usada sin problemas desde cualquier evento que
programemos.
296
Por ejemplo, empezaremos programando la pulsación del botón “Entró
un coche”. Acceda a su evento actionPerformed y programe esto:
coches=coches+1;
etiCoches.setText(“”+coches);
Como ves, se le añade a la variable coches uno más y luego se coloca

su valor actual en la etiqueta.
12. Ejecuta el programa y prueba este botón varias veces.
Pulsas, y aparece
aquí el valor de la
propiedad coches.
13. Ahora programaremos el botón “Salió un coche” de la siguiente forma:
if (coches>0) {
coches=coches-1;
etiCoches.setText(“”+coches);
297
Como ves, se accede igualmente a la propiedad coches pero esta vez
para restarle una unidad. Luego se muestra el valor actual de coches en
la etiqueta correspondiente.
Se usa un if para controlar que no pueda restarse un coche cuando el

parking esté vacío. (Si hay cero coches en el parking no se puede restar
uno)
14. Ejecuta el programa y prueba los dos botones. Observa como la cantidad
de coches del parking aumenta o disminuye.
Al pulsar aquí
aumentas en uno la
propiedad coches.
Al pulsar aquí
disminuyes en uno la
propiedad coches.
Lo realmente interesante de esto es que desde dos eventos distintos (desde

dos botones) se puede usar la variable coches. Esto es así gracias a que ha
sido creada como variable global, o dicho de otro modo, ha sido creada
como propiedad de la clase Parking.
15. Finalmente se programará el botón Reiniciar. Este botón, al ser pulsado,

debe colocar la propiedad coches a cero. Programa dentro de su
actionPerformed lo siguiente:
coches=0;
etiCoches.setText(“0”);
298
Simplemente introduzco el valor cero en la variable global y actualizo la
etiqueta.
16. Ejecuta el programa y comprueba el funcionamiento de este botón.
Las variables globales, también llamadas propiedades de la clase, son variables

que pueden ser usadas desde cualquier evento del programa. Estas variables
mantienen su valor hasta que otro evento lo modifique.
Las variables globales se declaran justo después de la línea public class.
La inicialización de estas variables se realiza en el constructor.
COMO DISTRIBUIR Y DISEÑAR EL CODIGO PARA QUE SEA

REUTILIZABLE
Muchas veces los programadores nos perdemos en la cantidad de código que

escribimos o el que es generado por el IDE, incluso se nos presenta el problema
habitual en Java que varios eventos tengan que ejecutar el mismo código. En
este caso se plantea la necesidad de “copiar y pegar” ese código en los distintos
eventos a programar:
Evento 1
Código A
Evento 2
Código B
Evento 3
Código A
Esta es una mala forma de programación, ya que se necesitara modificar el

código, sería necesario realizar la modificación en cada copia del código. Es muy
fácil que haya olvidos y aparezcan errores en el programa que luego son muy
difíciles de localizar.
Lo mejor es que el código que tenga que ser ejecutado desde distintos eventos
aparezca solo una vez, y sea llamado desde cada evento:
299
Evento 1
Evento 2 Código A
Evento 3
Veamos algunos ejemplos en los que el código se puede repetir y como evitar
esta repetición.
Mediante el siguiente ejemplo aprenderemos como organizar y diseñar nuestros

métodos, en especial los métodos manejadores de Eventos para que puedan ser
Reutilizados por otros Eventos.
1. Crea un nuevo proyecto en java que se llame ProyectoCalculos. Este

proyecto tendrá un paquete llamado PaqueteCalculos. Y dentro de él
creará un JFrame llamado VentanaCalculos. El proyecto tendrá el
siguiente aspecto:
2. La VentanaCalculos debe
estar diseñada de la siguiente
forma:
X4
Esta ventana contiene los

siguientes elementos:
 Una barra de menús a la
que puede llamar menuBarra.
 La barra de menús
300
contiene un JMenu con el texto “Calcular” y que se puede llamar
menuCalcular
 El menuCalcular contendrá tres

JMenuItem, llamados
respectivamente: menuSumar,
menuRestar, menuBorrar y con
los textos “Sumar”, “Restar” y
“Borrar”.
 Una etiqueta con el texto
“Número 1”. (no importa su
nombre)
 Una etiqueta con el texto
“Número 2”. (no importa su
nombre)
 Un cuadro de texto con un 0 y

con el nombre txtNumero1.
 Un cuadro de texto con un 0 y
con el nombre txtNumero2.
 Una etiqueta con el nombre
etiResultado.
 Un botón “Sumar” con el nombre btnSumar.

 Un botón “Restar” con el nombre btnRestar.
 Un botón “Borrar” con el nombre btnBorrar.
3. Aquí puedes ver la ventana en ejecución con el menú “Calcular”

desplegado
4. El objetivo de programa es el siguiente:
a. El usuario introducirá dos números en los cuadros de texto.

b. Si pulsa el botón Sumar, se calculará la suma.
c. Si pulsa el botón Restar, se calculará la resta.
d. Si pulsa el botón Borrar, se borrarán ambos cuadros de texto.
e. Si elige la opción del menú Calcular-Sumar entonces se calculará
la suma.
301
f. Si elige la opción del menú Calcular-Restar entonces se calculará
la resta.
g. Si elige la opción del menú Calcular-Borrar entonces se borrarán
ambos cuadros de texto.
h. Si se pulsa enter en alguno de los dos cuadros de texto se
debería calcular la suma.
5. Este es un ejemplo en el que al activarse uno de varios eventos distintos

se tiene que ejecutar el mismo código. Observa el caso de la suma:
Pulsar Botón Sumar
Activar Calcular – Sumar

en el menú
Calcular la suma y
mostrarla en la etiqueta
de resultado
Pulsar enter en el primer
cuadro de texto
Pulsar enter en el segundo

cuadro de texto
6. Para que el código esté “centralizado”, es decir, que aparezca solo una
vez, será necesario construir en la clase un método. Un método en java
es el equivalente de una función o procedimiento en C. Veamos cómo
hacerlo:
7. Accede al código de tu programa a través del botón Origen.
8. Un buen sitio para programar tus procedimientos puede ser debajo del
constructor. Puedes distinguir fácilmente al constructor porque tiene el
mismo nombre que la clase que estás programando, o dicho de otro
modo, tiene el mismo nombre que la ventana que estás programando:
VentanaCalculos.
302
Este es el Método
Constructor de Instancias u
Objetos de esta Clase
Este es un buen sitio para
crear tus propios
procedimientos o metodos
9. Se va a programar un procedimiento que se encargue de recoger los

valores de los cuadros de texto. Calculará la suma de dichos valores, y
luego mostrará la suma en la etiqueta de resultados.
Los procedimientos en java tienen prácticamente la misma estructura que
en C. Programe lo siguiente:
Este es el procedimiento que

tienes que introducir en el
programa.
303
10. Si observas el código, es el típico procedimiento de C, cuya cabecera
comienza con void y el nombre que le hayas asignado (en nuestro caso
Sumar)
void Sumar() {
....
}
Si estudias las líneas del código, verás que lo que hace es recoger el
contenido de los dos cuadros de texto en dos variables de cadena
llamadas cad1 y cad2.
Luego convierte dichas cadenas en números que almacena en dos

variables enteras llamadas a y b.
Finalmente calcula la suma en una variable s y presenta el resultado en

la etiqueta etiResultado.
11. Hay que destacar que este código no pertenece ahora mismo a ningún
evento en concreto, por lo que no tiene efecto ninguno sobre el
programa. Será necesario pues asociar los eventos correspondientes
con este procedimiento.
12. Interesa que al pulsar el botón “Sumar” se ejecute la suma, así pues
entre en el evento actionPerformed del botón “Sumar” y añada la
siguiente línea:
Sumar();
13. Como también interesa que al pulsar la opción del menú “Calcular-
Sumar” se ejecute la suma, entre en el evento actionPerformed de la
opción del menú “Sumar” y añade de nuevo la siguiente línea:
Sumar();
14. También se quiere que al pulsar la tecla enter en el cuadro de texto del
número 1 se ejecute la suma. Por lo tanto, en el evento actionPerformed
del cuadro de texto txtNumero1 hay que añadir la siguiente línea:
304
Sumar();
15. Y como también se quiere que al pulsar la tecla enter en el cuadro de

texto del número 2 se ejecute la suma, también habrá que introducir en
su actionPerformed la siguiente línea:
Sumar();
16. Antes de continuar, ejecute el programa, introduzca dos números, y

compruebe como se calcula la suma al pulsar el botón Sumar, o al
activar la opción del menú Calcular–Sumar, o al pulsar Enter en el primer
cuadro de texto, o al pulsar Enter en el segundo cuadro de texto.
En cada uno de los eventos hay una llamada al procedimiento Sumar,
que es el que se encarga de realizar la suma.
actionPerformed btnSumar
actionPerformed menuSumar
Método o Procedimiento
Sumar()
actionPerformed txtNumero1
actionPerformed txtNumero2
17. En el caso de la resta sucede igual. Tenemos que varios eventos

distintos deben provocar que se realice una misma operación. En este
caso tenemos lo siguiente:
305
Pulsar Botón Restar
Calcular la resta y mostrar el

resultado
Restar()
Activar Calcular – Restar

en el menú
18. Para centralizar el código, crearemos un método Restar que se

encargará de hacer la resta de los números introducidos en los cuadros
de texto. Este método se puede colocar debajo del anterior método
Sumar:
Codigo de este
Método o
procedimiento.
306
19. El código de este procedimiento es prácticamente idéntico al del
procedimiento Sumar, así que no se comentará.
20. Ahora, es necesario que cuando se activen los eventos indicados antes,
estos hagan una llamada al procedimiento Restar para que se efectúe la
resta. Así pues, entre en el evento actionPerformed del botón “Restar” y
añada esta línea de código:
Restar();
21. Igualmente, entre en el evento actionPerformed de la opción del menú

“Calcular – Restar” y añada la misma llamada:
Restar();
22. Ejecute el programa y compruebe cómo funciona el cálculo de la resta,

da igual que lo haga pulsando el botón “Restar” o la opción del menú
“Restar”. Ambos eventos llaman al mismo método:
actionPerformed btnRestar
Restar
actionPerformed menuRestar
23. Finalmente se programará el borrado de los cuadros de texto a través del

botón “Borrar” y de la opción del menú “Borrar”. En primer lugar,
programa el siguiente método (puedes hacerlo debajo del método
“Restar”):
307
24. Ahora programa las llamadas al procedimiento borrar desde los distintos
eventos. En el evento actionPerformed del botón “Borrar” y en el evento
actionPerformed de la opción del menú “Borrar” programa la siguiente
llamada:
Borrar();
25. Ejecuta el programa y prueba su funcionamiento.
En java se pueden programar procedimientos al igual que en C. Normalmente,

estos procedimientos se programarán debajo del constructor, y tienen la misma
estructura que en C.
Se puede llamar a un mismo procedimiento desde distintos eventos, evitando así
la repetición de código.
CAPITULO 5: REVELANDO LOS TRUCOS (EL CODIGO) QUE ESTAN

DETRÁS DEL MAGO (EL PROGRAMADOR)
DISEÑAR Y CONSTRUIR FORMULARIOS GUI DESDE CODIGO (SIN USO

DEL DISEÑADOR DE NETBEANS)
Hasta este punto del libro, desdese el Capítulo 4 en adelante, hemos aprendido
a Diseñar y construir GUI (Interfaces Graficas de Usuario) trabajado con los
elementos más importantes y comunes como Ventanas, Contenedor y
Componentes, pero todo lo hemos hecho de la manera WYSIWYG ( What You
See Is What You Get) que he español significa LO QUE VES ES LO QUE
OPTINES. Esta técnica avanzada provista por la mayoría de IDE nos ofrece una
forma un tanto transparente de desarrollar GUI, en nuestro caso en la mayoría
de los ejemplos utilizamos el Diseñador de GUI (Interfaces Graficas de Usuario)
que nos proporciona el IDE NetBeans.
Esta herramienta es muy poderosa a la hora de desarrollar aplicaciones en el
ámbito profesional, ya que nos ofrece un buen número de ventajas como lo son:
 Ahorro de tiempo en la escritura de código durante el Diseño y

Construcción de las GUI, al generar código necesario y muchas veces
optimo por cada vez que seleccionamos, Arrastramos y Soltamos un
Elemento GUI sobre el panel de Diseño.
308
 Acceso rápido y documentado a las propiedades de cada elemento GUI,
con el fin de configurar o establecer sus respectivos valores según
nuestra necesidad.
 Previsualizacion y prueba instantánea de las GUI que vallamos

generando, sin tener que ejecutar toda la aplicación, sino que solo
ejecutamos o Previsualizamos la parte del programa que estamos
desarrollando.
 Acceso rápido y documentado a los Oyentes o manejadores de Eventos

que posee cada elemento que agregamos a nuestra GUI, generando el
código necesario para poder insertar la operación que sea de nuestro
interés según sea el caso.
 Es muy fácil reutilizar los Componentes GUI diseñados y programados

por nosotros, así como también los diseñados y programados por otros
programadores, los cuales podemos encontrar en internet disponibles en
variedad de licencias de Software Libre, de Código Abierto (recordemos
que no es lo mismo que Software Libre), Gratis (no es ni Libre ni
OpenSource) o Privativas.
Esta herramienta de Diseño GUI es una gran herramienta que nos permite
diseñar formularios de forma relativamente sencilla. Simplemente tenemos que
añadir los componentes del formulario: botones, etiquetas, cuadros de textos,
etc, y cambiar sus propiedades según nos interese.
Todo esto tiene un código asociado que se genera de forma automática, y del
que no nos hemos preocupado hasta el momento.
Por ejemplo, cada vez que añades un botón o una etiqueta, se generan
automáticamente las instrucciones de código que permiten crear dicho botón o
dicha etiqueta. También se genera el código que permite cambiar el texto del
botón, o cambiar el texto de la etiqueta.
Bueno, tal y como lo esperas, vamos a explicar todo mediante ejemplos simples,
que nos permiten comprobar lo descrito anteriormente:
1. Crea un proyecto y añade en su ventana un botón (JButton), una etiqueta

(JLabel) y un cuadro de texto (JTextField).
2. El nombre del botón será “btnBoton”, el de la etiqueta “etiEtiqueta” y el
del cuadro de texto “txtCuadroTexto”.
3. A continuación asigna un texto a cada elemento. La ventana final podría
tener un aspecto como el que sigue:
309
4. Todas estas operaciones que
has realizado tienen asociado unas
instrucciones de código que se han
generado automáticamente. Para
estudiar estas instrucciones, activa el
botón Origen en la parte superior de
la pantalla:
5. En el código, observarás una línea llamada Código Generado. Esta línea

está señalada en color azul (al igual que todas las instrucciones generadas
automáticamente) Observarás que tiene un + en la parte izquierda. Si haces clic
sobre el signo + aparecerá el código generado automáticamente:
Haz clic en el + para ver

el código generado.
310
6. El código generado (señalado en azul) no puede ser modificado, sin
embargo es interesante estudiarlo para entenderlo. En él puedes
encontrar como se crean los componentes, como se asigna el texto a
éstos etc.
Aquí se crea el botón, la

etiqueta y el cuadro de
texto…
Aquí se asigna el texto a

cada elemento…
En esta explicación guiada, se diseñará el formulario entero directamente desde

código, sin usar la ventana de diseño. De esta forma, se podrá entender mejor la
generación de código del NetBeans y se tendrá más control sobre los
componentes.
Es muy importante que siguas al pie de la letra cada uno de los siguientes
pasos:
A. CREACIÓN DEL PROYECTO
1. Crear un nuevo proyecto con las siguientes características:

a. El nombre del proyecto será OPERACIONES.
b. El nombre del paquete será VENTANAS.
c. El nombre del formulario será VENTANAPRINCIPAL.
El aspecto que tendrá la ventana de proyectos debe ser el siguiente:
311
Nombre del proyecto.
Nombre del paquete.
Nombre del formulario.
2. Una vez creado el proyecto, iremos directamente a la ventana de código,

pulsando el botón Origen. No usaremos la ventana de diseño en este
proyecto.
B. ESTRUCTURA DEL CÓDIGO (estructura de una clase)

1. Analizaremos el código del programa ahora. Empezaremos por arriba:
En la parte superior del código verás

un comentario.
En este comentario aparece el nombre
del fichero que contiene el código, que
como puedes observar tiene el mismo
que el del JFrame.
También aparece la fecha de creación

del fichero.
Observarás también una instrucción

que indica que este fichero
(ventanaprincipal.java) pertenece al
paquete ventanas.
También verás otro comentario donde aparece el nombre del autor. Este comentario se
puede cambiar para que aparezca tu nombre.
312
2. Un proyecto en java está formado por módulos denominados CLASES.
El proyecto que acabamos de crear tiene un solo módulo: el JFrame que
define la ventana principal, llamado precisamente ventanaprincipal. Por
tanto, se puede decir que nuestro proyecto tiene una clase llamada
ventanaprincipal.
El proyecto operaciones
tiene una clase llamada
ventanaprincipal, que
pertenece al paquete
ventanas.
3. Para programar una clase se sigue la siguiente sintaxis:
public class nombredelaclase {
…programación de la clase…
}
4. Esto lo puedes observar claramente en el código de tu proyecto
Dentro de la clase, tenemos una serie de funciones y procedimientos

llamados MÉTODOS. Es en los métodos donde se programan los
eventos que pueden suceder sobre el formulario.
Hay un método especial muy importante denominado CONSTRUCTOR.
Dentro de este método se programa el diseño de la ventana y las
características iniciales de la ventana.
El constructor se puede distinguir fácilmente porque tiene el mismo

nombre que la clase. En nuestro ejemplo, ventanaprincipal.
Observarás que el constructor contiene una llamada a un método

llamado initComponents. El método initComponents define
características iniciales de la ventana, y es código generado
313
automáticamente. Si quieres verlo, solo tienes que desplegar la parte de
Código Generado:
Cuerpo de la
Clase
ventanaprincipal
314
Clic aquí para ocultar

El método initComponents al que hace referencia el constructor
es un método generado automáticamente, y no puede ser
modificado.
Puedes verlo dentro de la sección de Código Generado.
Este método define algunas características iniciales de la
ventana.
El contenido del método initComponents no resulta interesante para el
ejercicio que estamos realizando, así que puedes ocultar de nuevo el
Código Generado, haciendo clic en el símbolo menos -
5. Otro método importante que hay que mencionar es el método main. Este
método es el que se ejecuta cuando arranca el programa. Se puede decir
que el programa parte de aquí.
La tarea que desempeña este método es la de generar la ventana
principal y mostrarla en pantalla.
El método main, es similar a la función main del lenguaje C. En el caso
del java, el NetBeans genera automáticamente el método main, de forma
que no tendremos que hacer cambios en él.
315
C. DISEÑO DE LA VENTANA DESDE CÓDIGO
Vamos ahora a diseñar la ventana de nuestro programa (sin usar la ventana de
diseño, solo a partir de código). Al final de esta explicación, la ventana del
Para conseguir esto, sigue los siguientes pasos:
6. Para realizar el diseño de la ventana, crearemos un método propio al que
llamaremos por ejemplo CreacionVentana. Un buen sitio para colocar
este método puede ser debajo del constructor:
El método donde
diseñaremos nuestra
ventana…
7. Lo primero que se va a hacer es definir características propias de la

ventana, como por ejemplo su título, tamaño, etc. Recuerda que la forma
de hacer referencia a la propia ventana es a través de la palabra
reservada this. Así pues, programa lo siguiente dentro del método
CreacionVentana:
Este código hace lo siguiente:
316
 Usa el método setTitle de la ventana para definir el texto de la barra de
título.
 Usa el método setSize de la ventana para definir un tamaño de 500x300.
 Usa el método setLocation de la ventana para definir la posición de la
ventana en la posición (100,100) de la pantalla.
Con setLocation Con setTitle

decides la posición de cambias la barra de
la ventana… título…
Con setSize defines el

ancho y alto de la
ventana…
8. Para que esto tenga efecto, es necesario que el método CrearVentana

sea llamado desde el constructor, al igual que sucede con el método
initComponents:
317
9. Ya puedes ejecutar el programa. En el momento en que se ejecuta el
programa, el constructor llama al método CreacionVentana y se definen
las características programadas.
10. Ahora vamos a empezar a añadir componentes a la ventana.

Concretamente, empezaremos creando la etiqueta que contiene el texto
“Número 1:” y luego definiremos algunas características propias para
finalmente situarla en la ventana.
Al comienzo de la clase, después del public class, donde se suelen
definir las variables globales, añade el siguiente código:
Este código declara una variable de tipo JLabel (etiqueta) y le da el

nombre etiNum1.
11. Al escribir este código, aparecerá un error en la línea, ya que será

necesario importar la librería donde se encuentra el tipo de objeto JLabel.
318
Podrás usar la bombilla del NetBeans para agregar el import
correspondiente automáticamente.
12. Los imports aparecerán en la parte superior del código. Puedes

observarlo:
Importación de la librería
para el objeto JLabel, que
define las etiquetas.
(Agregada
automáticamente al pulsar
la bombilla del NetBeans)
13. Ahora agrega este código a tu método CreacionVentana:
14. La explicación del código es la siguiente:
319
 La primera línea construye la etiqueta llamada etiNum1 que fue
delarada antes.
etiNum1 = new JLabel();
 Generalizando: para crear un objeto llamado xxx del tipo tipoobjeto,
se tendrá que hacer lo siguiente:
o En la zona de las variables globales se declarará la variable

del objeto de la siguiente forma:
tipoobjeto xxx;
o Luego, dentro de la clase, se construye el objeto siguiendo la
siguiente sintaxis:
xxx = new tipoobjeto();

 En el ejemplo, la etiqueta creada, cuyo nombre es etiNum1, tiene que
contener el texto “Número 1:”. Esto lo hacemos con el típico método
setText:
etiNum1.setText(“Número 1: “);
 Hay que definir la posición que tendrá el objeto y el tamaño. Para
ello, se usará el método setBounds. Este método recibe la posición
(x, y) del objeto y el ancho y el alto. En el ejemplo, la etiqueta está
situada en la posición (10,10) de la ventana y tiene un ancho de 100
y un alto de 20:
etiNum1.setBounds(10,10,100,20);
 Finalmente, hay que colocar la etiqueta en el panel de contenidos de
la ventana. Para ello, se usa el método add del panel de contenidos.
Recuerda que para obtener este panel se usa el método
getContentPane:
this.getContentPane().add(etiNum1);
15. Es buena idea que ejecutes el programa para ver el aspecto de la
ventana ahora.
16. Hemos añadido una etiqueta. Ahora añadiremos la siguiente. Para ello,
primero tienes que declarar la etiqueta en la zona de las variables
globales:
320
17. Luego, en el método ConstruirVentana, añadiremos el siguiente código:
18. Este código es prácticamente igual al anterior. En él se constuye la

etiqueta declarada antes con el nombre etiNum2. Luego se le asigna el
texto “Número 2:”, luego se usa el método setBounds para situarla en la
posición (10, 60) y asignarle un ancho de 100 y un alto de 20. Finalmente
se añade la etiqueta al panel de contenidos de la ventana.
19. Ejecuta el programa y observa el aspecto de la ventana ahora:
321
20. Sigamos añadiendo elementos. Ahora añadiremos un cuadro de texto
llamado txtNum1. Primero declara la variable del cuadro de diálogo en la
zona de variables globales:
Tendrás que agregar el import correspondiente para el tipo de objeto

JTextField.
21. Luego añade el siguiente código en el método CreacionVentana:
22. Este código realiza lo siguiente:
322
 La primera línea construye el cuadro de texto llamado txtNum1. Los
JTextField son objetos del tipo cuadro de texto.
 Esta línea se subrayará en rojo ya que será necesario añadir el import
para la librería de los JTextField.
 La siguiente línea introduce la cadena “0” dentro del cuadro de texto.
 La siguiente línea asigna la posición y el tamaño a través del método
setBounds.
 Y finalmente, la última línea añade el cuadro de texto al panel de
contenidos de la ventana.
23. Ejecuta el programa y comprueba el funcionamiento de este código.
24. Ahora se añadirá un nuevo cuadro de texto llamado txtNum2. El código

es similar. Declara la variable global:
25. Y ahora añade el código que construye el objeto en el método

ConstruirVentana. Este código es similar al del cuadro de texto anterior.
Solo cambia el nombre del objeto y la posición donde se colocará:
323
26. Ejecuta el programa y comprueba cómo va el diseño de la ventana:
27. Ahora le toca el turno a los botones. Primero declararemos una variable
del tipo JButton en la zona de variables globales (será necesario añadir
el import correspondiente a la clase JButton a través de la bombilla). El
botón se llamará btnSumar:
324
28. Y a continuación construiremos y le daremos forma al botón, añadiendo
el siguiente código en el método ConstruirVentana:
29. La explicación del código anterior es similar a los anteriores:
 La primera línea construye el botón btnSumar.

 A continuación se asigna el texto “Sumar” al botón.
 Luego se asigna la posición y el tamaño del botón con el método
setBounds.
 Finalmente se añade el botón al panel de contenido de la ventana.
30. Ejecuta el programa y observa el aspecto de la ventana.
31. Ahora se añadirá otro botón llamado btnRestar. Declara la variable
JButton:
325
32. Tienes que escribir el siguiente código:
33. El código es prácticamente igual que el del primer botón. Solo cambia el
nombre del botón, el texto y la posición y tamaño del botón.
34. Ejecuta el programa para ver cómo queda la ventana.
326
La ventana de diseño de NetBeans es una herramienta que nos permite diseñar
las ventanas sin tener que programar código.
Es posible prescindir de la ventana de diseño y realizar todo el diseño de la
ventana programando.
El diseño de la ventana se tiene que hacer en el constructor de la clase.
Los componentes de una ventana son variables globales cuyo tipo se
corresponde a distintas clases de objetos: JLabel, JTextField, JButton, etc...
Para construir un objeto hay que declararlo como una variable global:
TipoObjeto NombreObjeto;
Y luego, dentro de la clase, construirlo, usando la siguiente sintaxis:
NombreObjeto = new TipoObjeto();
Luego se pueden usar distintos métodos del objeto para trabajar con él.
ESCUCHAR, MANEJAR Y CONTROLAR LOS EVENTOS DESDE EL CODIGO
La ventana de diseño de NetBeans nos permite crear cada componente,

colocarlo en la ventana y acceder a los eventos que necesitemos fácilmente para
programar en ellos las acciones que se tengan que realizar.
Sin embargo, si el diseño de la ventana se ha realizado directamente desde
código, será necesario crear también desde código los distintos eventos a usar, y
asociarlos al componente correspondiente.
Para programar eventos hay que tener en cuenta lo siguiente:
 Un evento pertenece a un objeto “Oyente” (Listener) o a un objeto
“Adaptador” (Adapter)
327
 El objeto oyente/adaptador hay que asociarlo al elemento sobre el que
sucede el evento.
Por ejemplo: Programar la pulsación de un botón btnSumar.

La pulsación de un botón es un evento actionPerformed como ya se sabe.
El evento actionPerformed pertenece a un objeto llamado ActionListener. El
objeto ActionListener es lo que se denomina un oyente.
El objeto ActionListener se asociará al botón btnSumar
La programación de eventos es compleja, ya que cada evento pertenece a un
oyente/adaptador, y a su vez, hay que asociar cada oyente/adaptador al
componente que responde al evento.
Un Evento es un suceso que ocurre ya sea dentro de la aplicación o fuera de
ella, el cual es notificado mediante señales, por ejemplo:
Eventos Externos:
 Cuando pulsamos, soltamos una tecla o un tipo de tecla.
 Cuando movemos, arrastramos, soltamos el raton, o pulsamos,

sostenemos, soltamos sus botones o despazamos su perilla.
 Cuando conectamos un dispositivo a los puertos USB del PC.
Cuando nos conectamos, recibimos o transmitimos datos por la Red

Eventos Internos.
 Cuando abrimos, movemos, activamos, desactivamos o cerramos una
ventana.
 Cuando pulsamos, seleccionamos, movemos, clickeamos o cambiamos

de valor a un componente GUI.
 Cuando desde nuestra aplicacion abrimos, leemos, escribimos,

cerramos, creamos, movemos, modificamos o eliminamos un archivo.
 Cuando desde nuestra aplicación enviamos o recibimos informacion por

algun puerto o dispositivo conectado al PC.
 Etc.
Cada una de las acciones anteriorer son Eventos, para los cuales Java posee
una clase generica o Super Clase para ellos, llamada Event, de ella derivan o
herredan todos los eventos especializados en un suceso especifico.
Java tambien proporciona otras clases denominadas Oyentes de Eventos o
Listener, las cuales tienen como propocito escuchar y detectar eventos de tipo
Event, cada evento tiene relacionado un Oyente especifico, los cuales poseen
328
una serie de metodos (funciones u operaciones) que reaccionan
automanticamente jusnto cuando el Oyente detecta la ocurrencia de un Evento
de su interes. A estos metodos se les conoce como Manejadores de Eventos o
Disparadores, mientras que el codigo que colocamos en su interior (denominado
Adaptador) es el encargado de manejar o realizar las acciones que deseamos se
ejecuten cuando ocurra X evento.
Nuestra tarea al trabajar con Eventos conciste basicamente en:
1. Identificar los Elementos o procesos susceptibles de generar Eventos
(botones, Item de Menu, Campos de Texto, Listas, Tablas, archivos, etc).
2. Seleccionar el Oyente de Evento que deseamos agregar a dicho

componente o proceso.
3. Programar su Manejador o Disparador con el codigo necesario para que

realice las acciones que desamos y se adapte a nuestras necesidades.
Por otro lado, la sintaxis de programación para los eventos es distinta a lo que se
ha visto hasta ahora, por lo que puede resultar bastante oscura, aunque por otro
lado, siempre sigue el mismo patrón.
Para simplificar el estudio de la programación de eventos, nos limitaremos a los
eventos más usados, los cuales pueden clasificarse en los siguientes grupos:
NOMBRE DEL
NOMBE DE LA CLASE MOMENTO EN QUE SE DISPARA O
METODO
OYENTE EJECUTA
MANEJADOR
ActionListener Cuando deseamos Activar un
actionPerformed
(Eventos de Acción) componente (pulsación de botón,
enter en un cuadro de texto)
KeyListener Cuando Se pulsó una tecla, pero no
keyPressed
(Eventos de Teclado) se soltó.
keyReleased Cuando Se soltó una tecla.
keyTyped Cuando Se pulsó y soltó una tecla.
MouseListener mousePressed Cuando Se pulsó un botón del ratón

(Eventos de Ratón) mouseReleased Cuando Se soltó un botón del ratón
mousePressed Cuando Se pulsó y soltó un botón de
ratón
mouseEntered Cuando El ratón entró en la superficie
del control
mouseExited Cuando El ratón salió de la superficie
del control.
329
WindowListener windowOpened Cuando Se abrió la ventana
(Eventos de Ventana) windowActivated Cuando Se activó la ventana
windowClosing Cuando Se cerró la ventana

windowDeactivated Cuando Se desactivó la ventana
Durante el desarrollo del siguiente ejemplo veremos e Oyente de Acción:
DETECTAR Y ACTUAR SOBRE LOS EVENTOS DE ACCIÓN
Un evento de acción hace referencia a la activación de un objeto (un botón, un

cuadro de texto, un combo, etc...)
Solo existe un tipo de evento de acción, llamado actionPerformed.
El evento actionPerformed pertenece a un objeto oyente llamado ActionListener.
Disparador Oyente/Adaptador
actionPerformed Se programa dentro de ActionListener
La forma de programar el evento actionPerformed de un componente xxx es la

siguiente:
xxx.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
xxxActionPerformed(evt);
}
});
Para entender la sintaxis de la programación de un evento de acción,
supongamos el siguiente ejemplo:
Se quiere programar el evento de un botón llamado btnSumar desde código. He
aquí el código para crear el evento:
btnSumar.addActionListener(new ActionListener() {
btnSumarActionPerformed(evt);
}
});
Una explicación del código:
La instancia del componente El metodo que asigna La instancia del Oyento que va
al que desemos escuchar un Oyente al a escuchar el evento de interes
sus eventos Eventos componente para nosotros
330
} El metodo disparador del Oyente
}); que actuara automaticamente Este es el Manejador del Evento, en
cuando el vento ocurra. Recibe caso dentro del cuerpo del metodo
como argumento una instancia del Disparador invocamos otro metodo
El código anterior
Evento permite
ocurridocrearla y cual
asignar el evento que
esta actionPerformed al botón
contiene el código que realizara
btnSumar, pero no programa
representada por laelvariable
evento. las el
evtPara programar acciones
evento que deseamos se
es necesario
crear el procedimiento cuya llamada se incluye ejecuten cuando
dentro delel evento
eventoocurra
actionPerformed:
public void btnSumarActionPerformed(ActionEvent evt) {
… aquí se programa el evento actionPerformed del botón btnSumar …
}
A pesar de lo complicado que resulta, hay que tener en cuenta que siempre se
programa de la misma forma. Solo hay que cambiar el componente que se
quiere programar y asignar un nombre a la función donde se programará el
evento.
Hay que tener en cuenta que en el código expuesto antes participan nuevas
clases como son ActionEvent y ActionListener, y se tendrán que agregar los
import correspondientes.
El siguiente ejemplo nos puede ilustrar major el proceso de programar un Oyente
de Evento y su respectivo método manejador
1. Abra el proyecto Operaciones que se hizo en el ejercicio guiado de la
hoja anterior.
2. En el ejercicio guiado anterior se diseñó desde código la ventana de
dicho proyecto. Esta ventana tiene el siguiente aspecto (Se indica
también el nombre de los distintos componentes):
331
txtNum1 y txtNum2 son
los cuadros de texto.
btnSumar es el btnRestar es el
botón Sumar botón Restar
3. El objetivo del ejercicio es programar la pulsación del botón btnSumar

para que aparezca un JOptionPane con la suma calculada. Luego
haremos lo mismo con el botón btnRestar. Todo esto se hará desde
código.
4. Para recordar, he aquí el código programado hasta ahora. Tenemos una

llamada desde el constructor a un método CreacionVentana donde
diseñamos cada uno de los elementos de la ventana:
/** Creates new form ventanaprincipal */
public ventanaprincipal() {
En el constructor hacemos una
llamada a nuestro método
initComponents(); CreacionVentana
CreacionVentana();
332
public void CreacionVentana() {
Programamos
this.setTitle("Programa Operaciones"); algunos detalles
de la ventana
principal…
this.setSize(500,300);
this.setLocation(100,100);

Creamos la etiqueta
etiNum1.setText("Número 1:"); “Número 1”…
etiNum2.setText("Número 2:");
Creamos la etiqueta
“Número 2”…
txtNum1 = new JTextField();

Creamos el primer cuadro de
txtNum1.setText("0"); texto…
txtNum1.setBounds(110,10,100,20);
this.getContentPane().add(txtNum1);
333
txtNum2 = new JTextField();
Creamos el segundo…
txtNum2.setText("0");
txtNum2.setBounds(110,60,100,20);
this.getContentPane().add(txtNum2);
btnSumar = new JButton(); Creamos el botón Sumar…
btnSumar.setText("Sumar");
btnSumar.setBounds(10,120,100,20);
this.getContentPane().add(btnSumar);
btnRestar = new JButton(); Creamos el botón Restar…
btnRestar.setText("Restar");
btnRestar.setBounds(150,120,100,20);
this.getContentPane().add(btnRestar);
5. Ahora asignaremos un evento actionPerformed al botón btnSumar. Esto

lo haremos al final del método CreacionVentana, El código que debe
añadir para el evento actionPerformed del botón btnSumar es el
siguiente:
334
}
});
(Recuerda que el código es siempre igual, solo hay que indicar el nombre
del botón y el nombre del procedimiento al que se llama)
6. Será necesario añadir un import para el objeto oyente ActionListener y
para la clase ActionEvent.
7. Ahora que se ha definido un evento actionPerformed para el botón

btnSumar, será necesario programarlo. Esto se hace creando el
procedimiento al que llama el código del actionPerformed. A este
procedimiento le hemos dado de nombre btnSumarActionPerformed.
Así pues, añade el siguiente procedimiento a la clase. (No te vayas a

equivocar, el siguiente código está fuera del método CreacionVentana)
Hay que
programar el
método al que
llama el evento…
Este es el código que

tienes que añadir
335
8. Es precisamente en este nuevo procedimiento que hemos creado donde
se programa el evento actionPerformed del botón btnSumar. Lo que se
pretende que haga el programa es que aparezca un JOptionPane con la
suma de los números introducidos. Para ello, añade el siguiente código:
Programa el
código de lo que
tiene que hacer el
evento.
9. Bien, hemos programado la pulsación del botón Sumar. Hemos seguido

dos pasos:
a. Primero hemos creado el evento actionPerformed y se lo hemos
asignado al botón. Esto lo hemos hecho dentro del método
CreacionVentana. Este evento hace una llamada al
procedimiento donde se programará la respuesta al evento.
b. Luego hemos creado ese procedimiento y hemos programado en
él el código correspondiente a la pulsación del botón.
Ejecuta el programa y comprueba el funcionamiento del botón Sumar.
10. Ahora programaremos el botón btnRestar. Primero se tendrá que definir
el evento actionPerformed y asignárselo al botón. Esto se hace
añadiendo el código de creación del evento al final del método
CreacionVentana.
336
btnRestar.addActionListener(new ActionListener() {
btnRestarActionPerformed(evt);
}
});
(Observa que es idéntico al código de asignación del evento del botón

btnSumar, solo cambia el nombre del botón y el nombre del
procedimiento al que se llama)
11. Y ahora, hay que programar el procedimiento al que llama el evento
actionPerformed. Es aquí donde se programa la respuesta al evento. En
nuestro ejemplo, queremos que al pulsar el botón Restar se resten los
números introducidos.
public void btnRestarActionPerformed(ActionEvent evt) {

double a,b,r;
a=Double.parseDouble(txtNum1.getText());
b=Double.parseDouble(txtNum2.getText());
r=a-b;
JOptionPane.showMessageDialog(null,"La resta es "+r);
}
12. Ejecuta el programa y comprueba el funcionamiento del botón Restar.
13. Resumiendo una vez más. Para programar un evento sobre un

componente, primero hay que enlazar el oyente del evento con el
componente, y luego programar el método al que llama el evento.
Observa el código que hemos programado:
a. El método addActionListener Agrega un oyente ActionListener

al boton btnSumar, este oyente reacciona cuando dan click
sobre dicho boton, invocando automáticamente al método
manejador actionPerformed, quien a su vez invoca al método
btnSumarActionPerformed que realiza la operación de Sumar
b. De igual forma el método addActionListener Agrega un oyente

ActionListener al boton btnRestar, este oyente reacciona
cuando dan click sobre dicho boton, invocando automáticamente
al método manejador actionPerformed, quien a su vez invoca al
337
método btnRestarActionPerformed que realiza la operación de
Restar
338
Cada evento pertenece a un objeto oyente, y es el oyente el que se asigna al
componente de la ventana que se quiere programar.
El evento actionPerformed pertenece al oyente ActionListener.
Para enlazar el oyente ActionListener a un componente XXX hay que usar el
siguiente código:
XXX.addActionListener(new ActionListener() {
XXXActionPerformed(evt);
}
});
El enlace de un evento a un componente se hace en el constructor. Esta
asignación hace una llamada a un procedimiento XXXActionPerformed, (donde
XXX representa el nombre del componente que se programa) Es en este
procedimiento donde realmente se programa el evento.
DETECTAR Y ACTUAR SOBRE LOS EVENTOS DEL RATON
Uno de los dispositivos de entrada más importante en un PC es el Ratón o

Mouse, el cual ofrece una experiencia de usabilidad muy directa y agradable.
A parte de escribir texto, la gran mayoría de operaciones que realizamos en una
computadora requieren del uso del Ratón, por ende una aplicación por muy
simple que no debe pasar por alto ofrecer funcionalidad para disco dispositivo.
En esta sección veremos los elementos de programación Java más importantes
que debemos conocer para poder trabajar con los Eventos del Ratón.
En la sección anterior aprendimos la forma de programar eventos desde el
código. Concretamente se estudió como programar eventos de acción (Enter y
Click) sobre un componente. Ahora aprenderemos como programar eventos
sobre ratón.
Nombre del Método Momento en que se Dispara o

Disparador ejecuta
Cuando Se pulsó un botón del ratón
mousePressed
sobre un Componente
Cuando Se soltó un botón del ratón
mouseReleased
sobre un Componente
mousePressed Cuando Se pulsó y soltó un botón del
ratón sobre un Componente
mouseEntered Cuando El ratón entró en la superficie
del Componente
mouseExited Cuando El ratón salió de la superficie
del Componente.
339
Como se dijo en la hoja anterior, todos los eventos pertenecen a un objeto
“oyente” o “adaptador”. En este caso concreto, todos los eventos del ratón
pertenecen a un objeto “adaptador” llamado MouseAdapter.
Cada uno de los eventos se programará dentro del adaptador MouseAdapter.
Cada evento es en realidad un procedimiento que recibe un parámetro con
información sobre el evento. Este parámetro, en el caso de los eventos del ratón,
es del tipo MouseEvent.
Cada evento a su vez hace una llamada a un procedimiento, y es en este
procedimiento donde realmente se programa la respuesta al evento.
Todo esto resulta complicado al principio, pero verás que en realidad siempre es
igual. Solo hay que conocer el nombre de cada evento, el adaptador u oyente al
que pertenece y el tipo de parámetro que recibe cada evento.
COMO ENLAZAR EVENTOS DE RATÓN CON UN COMPONENTE
Supongamos que tenemos un componente (botón, etiqueta, etc...) llamado XXX.

Si queremos asociarle eventos de ratón, tendremos que añadir el siguiente
código dentro del constructor:
XXX.addMouseListener(new MouseAdapter() {
public void mouseEntered(MouseEvent evt) {
XXXMouseEntered(evt);
}
public void mouseExited(MouseEvent evt) {

XXXMouseExited(evt);
}
public void mousePressed(MouseEvent evt) {
XXXMousePressed(evt);
}
public void mouseReleased(MouseEvent evt) {
XXXMouseReleased(evt);
}
public void mouseClicked(MouseEvent evt) {
XXXMouseClicked(evt);
}
});
Veamos este mismo código comentado:
Los eventos de ratón pertenecen al
Para asignar el Oyente de Ratón al elemento adaptador llamado MouseAdapter
XXX se usa el método addMouseListener
public void mouseEntered(MouseEvent evt) { Estos son los
XXXMouseEntered(evt); eventos de
ratón que
pertenecen al
adaptador
340 MouseAdapter.
En realidad no
hay que
ponerlos todos,
}
XXXMouseExited(evt);
}

XXXMousePressed(evt); Cada Método
} Disparador
recibe como
public void mouseReleased(MouseEvent evt) { parámetro un
XXXMouseReleased(evt); objeto del tipo
} MouseEvent al
que por
convención se
le suele llamar
XXXMouseClicked(evt);
evt.
} Este objeto
suele contener
}); Cada evento hace una llamada a un procedimiento, cuyo información
nombre puede ser cualquiera, aunque suele construirse sobre la
uniendo el nombre del componente XXX junto con el pulsación del
nombre del
Como siempre, es evento.
mejor un ejemplo para poder comprender los conceptos
ratón (qué botón
Esun
1. Crea luego en estos
nuevo procedimientos donde se programa la
proyecto. se ha pulsado,
respuesta a cada evento. cuantas veces,
2. Accede al código del proyecto. etc...)
3. Inserta una llamada dentro del constructor a un procedimiento

CreacionVentana de la siguiente forma:
341
La llamada...
La definicion del metodo

o procedimiento.
4. La ventana va a contener dos etiquetas, que tendremos que declarar en

la zona de variables globales:
La propiedades o variables
globales o miembros de la clase.
5. Ahora vamos a diseñar la ventana. Introduce el siguiente código dentro

del procedimiento CreacionVentana:
342
Configuramos las
propiedades de la
ventana
Creamos la
instancai de la
primera etiqueta y
configuramos sus
propiedades, la
agregamos al
contenido de la
ventana
Igual hacemos con
la segunda etiqueta
6. Ejecuta ya el programa para observar el resultado de nuestro diseño. El

aspecto debe ser el siguiente:
343
7. El objetivo del programa es simple. Queremos que al entrar el ratón
dentro de la superficie de la etiqueta roja, aparezca un mensaje en la otra
etiqueta indicándolo. También queremos que aparezca un mensaje al
salir el ratón de la etiqueta. Y también al pulsar un botón del ratón sobre
la etiqueta.
8. Para hacer esto, necesitamos crear un MouseAdapter que contenga los

siguientes eventos: mouseEntered, mouseExited y mousePressed.
Observa que no es necesario que contenga el mouseReleased ni el
mouseClicked.
Luego, el MouseAdapter se asignará a la etiqueta roja etiZona.

9. Primero programaremos el enlace del adaptador MouseAdapter con la
etiqueta etiZona. Programa al final del método CreacionVentana lo
siguiente:
344
etiZona instancia de
tipo JLabel le
agregamos un de
Oyente de Eventos
del Ratón, para ello
creamos una
instancia de tipo
MouseAdapter o de
MouseListener.
Implementamos los
Disparadores y n su
interior escribimos e
código del
manejador o
invoamos un metodo
con dicho código
a. Se añade un MouseAdapter al objeto etiZona.
b. El MouseAdapter que se añade solo contiene los tres eventos

que necesitamos: mouseEntered, mouseExited y mousePressed.
c. Será necesario añadir imports para las clases MouseAdapter y

MouseEvent.
d. Es normal que las llamadas a los procedimientos de cada evento

den error ya que todavía no han sido programadas.
11. Ahora se programará cada procedimiento que es llamado desde cada

evento. Recuerda que esto debe hacerse fuera del método
CreaciónVentana. Aquí tienes lo que debes programar:
345
(Llave que cierra el método CreacionVentana)
Debemos
programar
estos tres
metodos
que seran
los
Manejador
es de cada
Evento y
seran
invocador
por los
disparador
es
12. Ahora ya puedes ejecutar el programa y comprobar lo que sucede

cuando interactúas con el ratón sobre la etiqueta de color rojo.
13. Vamos a añadir una pequeña mejora que nos servirá para estudiar ese
objeto llamado evt del tipo MouseEvent que llevan todos los eventos de
ratón como parámetro.
Se dijo antes que este parámetro contiene información sobre la acción
del ratón. Por ejemplo, nos puede servir para saber cuantas veces se
pulsó el ratón, con qué botón, etc. Aprovecharemos este parámetro para
indicar qué botón del ratón es el que se ha pulsado sobre la etiqueta.
Cambia el procedimiento etiZonaMousePressed y déjalo de la siguiente
forma:
346
14. En el código anterior aprovechamos los métodos que tiene el objeto
MouseEvent para averiguar que botón se ha pulsado. Usamos el método
getButton que nos dice el botón pulsado. Aprovechamos las constantes
de la clase MouseEvent para saber si se pulsó el botón izquierdo, central
o derecho.
15. Ejecuta el programa y comprueba el funcionamiento.
Hay grupos de eventos que pertenecen a un mismo oyente o adaptador. Por

ejemplo, los eventos de ratón pertenecen al adaptador llamado MouseAdapter.
Si se quiere asignar eventos de ratón a un componente XXX, hay que usar el
siguiente código:
XXXMouseEvent(evt);
}
... otros eventos de ratón...
});
Ten en cuenta que solo añades al adaptador aquellos eventos que necesites.
Cada evento de ratón lleva como parámetro un objeto evt del tipo MouseEvent
que contiene información sobre el evento: qué botón del ratón se pulsó, cuantas
veces, etc.
TENER EN CUENTA UNOS ASPECTOS COMUNES PARA TRABAJAR CON

EVENTOS / OYENTES / MANEJADORES
Se finalizará el estudio de los eventos desde código, planteando de forma

general el código necesario para programarlos.
347
A la hora de programar eventos sobre un componente concreto, será necesario
tener en cuenta lo siguiente:
 Primero hay que enlazar el componente con el oyente o adaptador
correspondiente al evento.
 El oyente o adaptador contendrá aquellos eventos que interesen
programar.
 Cada evento tiene un parámetro asociado con información sobre el
evento.
 Cada evento realiza una llamada a un procedimiento y es en este
procedimiento donde se programa la respuesta al evento.
La sintaxis general de programación de eventos es la siguiente:

Componente.MetodoParaAñadirOyente(new TipoOyente() {
public void evento1(TipoEvento evt) {

LlamadaAProcedimiento1(evt);
}
public void evento2(TipoEvento evt) {

LlamadaAProcedimiento2(evt);
}
...otros eventos...
});
Para poder programar un evento es necesario conocer lo siguiente:
 El componente sobre el que se programará.
 El tipo oyente o adaptador al que pertenece el evento.
 El método usado para asignar el oyente al componente.
 El nombre del evento.
 El tipo de evento para el parámetro.
EVENTOS DEL TECLADO

Los eventos de ratón son: mouseEntered, mouseExited, mousePressed,
mouseReleased, mouseClicked.
Pertenecen al adaptador MouseAdapter.
El adaptador se asigna al componente con el método addMouseListener.

Los métodos llevan como parámetro un objeto del tipo MouseEvent.
Conociendo esto, si queremos programar los eventos del ratón de una etiqueta
llamada etiTexto, solo tenemos que hacer lo siguiente:
etiTexto.addMouseListener(new MouseAdapter() {
348
etiTextoMouseEntered(evt);
}
etiTextoMouseExited(evt);
}
etiTextoMousePressed(evt);
}
public void mouseReleased(MouseEvent evt) {
etiTextoMouseReleased(evt);
}
etiTextoMouseClicked(evt);
}
});
EVENTOS DEL TECLADPO
Los eventos de teclado controlan las pulsaciones de tecla. Entre ellos, podemos
mencionar a los siguientes:
- keyPressed, que define la pulsación de una tecla.

- keyReleased, que define el momento en que se suelta una tecla.
- keyTyped, que define el pulsar-soltar una tecla.
Los eventos de teclado pertenecen al adaptador KeyAdapter.

El adaptador anterior se asigna a un componente a través del método
addKeyListener.
Los eventos de teclado llevan como parámetro un objeto del tipo KeyEvent.
Sabiendo lo anterior, si se quisieran programar los eventos de teclado de un
cuadro de texto llamado txtDato el código necesario sería el siguiente:
txtDato.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent evt) {
txtDatoKeyPressed(evt);
}
public void keyReleased(KeyEvent evt) {
txtDatoKeyReleased(evt);
}
public void keyTyped(KeyEvent evt) {
txtDatoKeyTyped(evt);
}
});
Como puedes observar, la programación de eventos siempre se hace de la
misma forma, solo tienes que conocer el adaptador/oyente, el método para
349
asignar dicho adaptador/oyente, el nombre de los eventos, y el tipo de objeto que
llevan como parámetro.
Sabiendo estos datos, la programación siempre se hace igual.
El problema que se plantea en cambio es el siguiente:
Si surge un nuevo evento X el cual quiero usar desde código, ¿cómo puedo
saber cual es su adaptador/oyente, el método para asignar dicho
adaptador/oyente al componente, y el tipo de datos del parámetro?
Para este caso, se aconseja crear un proyecto de prueba desde la ventana de
diseño y asignar el evento X que se quiere estudiar a un componente. Luego
simplemente hay que analizar el código generado por el NetBeans.
EN RESUMEN
Para programar desde código un evento es necesario conocer lo siguiente:
 El nombre del evento / eventos del mismo grupo.
 El oyente/adaptador al que pertenece el evento / eventos.
 El método para asignar el oyente/adaptador al componente sobre el que

actúa el evento.
 El tipo de datos de objeto recibido como parámetro por el evento.
Conociendo estos datos, la programación siempre se hace igual:

Componente.MetodoParaAñadirOyente(new NombreOyenteAdaptador() {
public void nombreEvento1(TipoDatoParametro evt) {
LlamadaAProcedimientoEvento1(evt);
}
public void nombreEvento2(TipoDatoParametro evt) {
LlamadaAProcedimientoEvento2(evt);
}
});
Se puede aprender mucho sobre los eventos asociándolos desde diseño y luego
mirando en el código generado.
350
CAPITULO 6: ESTRUCTURA DE DATOS (VECTORES)
En este capitulo abordaremos un tema muy importante y verdaderamente útil en

el desarrollo de software usando cualquier lenguaje de programación que exista
en la actualidad, se trata de los Vectores, también conocidos como Arreglos,
tablas o matrices.
Los Vectores non son otras cosas que una estructura e datos que almacena más
de un valor al mismo tiempo, en Java los vectores se pueden trabajar de varias
maneras:
 Vectores estáticos o de tamaño fijo y almacenan único tipo de dato, a
esto se les conoce como Arreglos.
 Vectores de tamaño dinámico y almacenan cualquier variedad de tipos

de datos, a estos se les conoce como Colecciones de Datos. Son un
conjunto de clases ubicadas en el paquete java.util, las entre las cuales
se encuentran la clase Vector, List, ArrayList, LinkedList, Set, SordSet,
Map, HashMap, Stack, deque, Iterator, HashTable, EntySet, entre otras.
El manejo de vectores en Java es similar al manejo de vectores en otros

lenguajes tradicionales como C. Solo hay que tener en cuenta que un vector en
Java se tiene primero que declarar, y luego se tiene que construir, ya que los
vectores son, al igual que todo en Java, objetos.
Declaración de un vector
Para declarar un vector se seguirá la siguiente sintaxis:
tipodatos nombrevector[];
- tipodatos es el tipo de datos de los elementos del vector (int, double,
String, etc.)
- nombrevector es el nombre que le quieras darle a tu vector.
Por ejemplo, supongamos que queremos crear un vector de enteros llamado v.

La declaración será la siguiente:
int v[];
Como puedes ver, en la declaración de un vector no se indica la dimensión, de
éste, es decir, el número de elementos que tiene. Esto se hace en la
construcción del vector.
Construcción de un vector
Para construir un vector que ya haya sido declarado se sigue la siguiente
sintaxis:
351
nombrevector = new tipodatos[dim];
 nombrevector es el nombre del vector a construir.

 tipodatos es el tipo de datos del vector.
 dim es la dimensión del vector (el número de elementos)
Por ejemplo, si queremos que el vector v declarado antes tenga 10 elementos,

tendremos que hacer lo siguiente:
v = int[10];
En el momento de la construcción del vector, podemos usar una variable entera

para asignar el número de elementos que se quiera.
Por ejemplo, en el siguiente caso el número de elementos del vector v viene
dado por la variable num:
v = int[num];
Acceso a los elementos de un vector

Una vez declarado el vector y construido, este se puede usar de la misma
manera que en C. Se puede acceder a un elemento del vector escribiendo el
nombre del vector y entre corchetes el índice del elemento que quieres usar.
Recuerda que los índices comienzan a numerarse en 0.
Ejemplo 1:
etiResultado.setText(“El resultado es: “+v[3]);
Aquí se coloca en una etiqueta el valor contenido en el elemento de la posición

cuarta del vector v.
Ejemplo 2:
for (i=0;i<10;i++) {
v[i]=0;
}
Este código recorre un vector de 10 elementos y almacena en dichos 10

elementos un 0.
Longitud de un vector
Una forma rápida de saber la longitud que tiene un vector es usar lo siguiente:
nombrevector.length
352
Por ejemplo, si el vector se llama v, su longitud (el número de elementos que
tiene) sería:
v.length
El siguiente código rellena el vector v con ceros, da igual el número de

elementos que tenga:
for (i=0;i<v.length;i++) {
v[i]=0;
}
Creación de un vector e inicialización con datos al mismo tiempo

Es posible crear un vector e introducir datos directamente en él al mismo tiempo.
La forma general de hacerlo sería la siguiente:
tipodatos nombrevector[] = {elemento1, elemento2, elemento3, …,

elemento n};
Por ejemplo:
int v[] = {5, 2, 7, 6};
Este código crea un vector con cuatro números enteros: 5, 2, 7, 6.
Ejemplo 2:
String dias[] = {“Lunes”, “Martes”, “Miércoles”, “Jueves”, “Viernes”, “Sábado”,
“Domingo”};
Este código crea un vector que contiene 7 cadenas, correspondientes a los días
de la semana.
ARREGLOS DE COMPONENTES
En Java, se pueden crear vectores de etiquetas, botones, cuadros de textos, etc.

Esto es tremendamente útil cuando se tienen que definir muchos componentes
con una función parecida, y que tengan que ser tratados en conjunto.
Por otro lado, nos ahorra mucho tiempo ya que no se tienen que diseñar estos
elementos en la misma ventana de diseño.
Los vectores de componentes se usan igual que se ha indicado antes. Observa
el siguiente ejemplo:
JLabel veti[]; //aquí se crea un vector de etiquetas llamado veti
veti=new JLabel[3]; //aquí se construye el vector, asignando 3 etiquetas
//ahora trabajamos con las etiquetas del vector
//usando el típico for
for (i=0;i<veti.length;i++) {
353
veti[i]= new JLabel(); //se construye cada etiqueta
veti[i].setBounds(10,10+i*30,100,20); //se asigna posición y tamaño
veti[i].setText(“Etiqueta “+i); //se asigna un texto
this.getContentPane().add(veti[i]); //se coloca en la ventana
}
Comencemos la practica explicando todo mediante un ejemplo simple:
1. Empecemos definiendo desde código las características de la ventana.
Crearemos el método CreacionVentana, y lo llamaremos desde el
constructor del proyecto:
2. Vamos a situar en la ventana 10 cuadros de verificación (JCheckBox).

Para ello, usaremos un vector de 10 JCheckBox. Este vector se
declarará en la zona de variables globales (será necesario añadir el
típico import):
354
3. La construcción de los vectores de componentes, se realiza en el mismo
constructor (en nuestro caso en el método CreaciónVentana, que es
llamado desde el constructor). Construiremos el vector de forma que
contenga 10 JCheckBox
355
4. Se acaba de construir un vector con 10 cuadros de verificación. Ahora,
es necesario construir cada uno de los cuadros del vector y asignarle
ciertas propiedades. Esto se hace con un for que recorre los elementos
del vector. (Añade el siguiente código dentro de CreacionVentana):
356
5. Analiza este código que se acaba de añadir:
a. Observa como cada elemento del vector debe ser construido:
vcuadros[i] = new JCheckBox();
b. El texto que tendrá cada elemento será: “Opción 0”, “Opción 1”,
etc…
vcuadros[i].setText(“Opción “+i);
c. Los cuadros de verificación se colocan uno debajo de otro.

Estudia la línea siguiente y observa como varía la posición
vertical de cada cuadro:
vcuadros[i].setBounds(10, 10+30*i, 100, 20);

6. Ejecuta el programa y observa el resultado:
357
7. Mejoremos la presentación de los cuadros cambiando los rótulos de cada
uno. Para ello, será necesario usar otro vector auxiliar que contenga los
textos de cada uno de los cuadros. Modifica el código anterior de forma
que quede así:
358
8. En este código puedes observar como se usa un vector de String que se
crea conteniendo 10 colores. Luego, ese vector se usa para asignar cada
color al texto de cada cuadro. Si ahora ejecutas el programa, verás que
cada cuadro tiene su texto correspondiente a un color.
359
9. Ahora añade un botón con su evento actionPerformed. Añade en la zona
de variables globales lo siguiente:
JButton btnAceptar;
Y luego, dentro de CreacionVentana, añade el siguiente código:
360
10. Ahora programaremos la respuesta al evento actionPerformed de forma
que el programa diga cuantos cuadros hay seleccionados. Para ello, se
tendrá que programar el procedimiento btnAceptarActionPerformed, cuya
llamada se encuentra en el código anterior (la línea que da error):
Así pues, fuera de CreacionVentana, programa el siguiente

procedimiento:
11. En este código se puede observar como se usa un for para recorrer
fácilmente el vector de cuadros y averiguar cuales de ellos está activado.
Aumentamos un contador y lo demás es sencillo.
Si este programa se hubiera hecho desde diseño, el código para contar

el número de cuadros activados sería mucho más engorroso. Piénsalo.
12. Ejecuta el programa. Selecciona varios cuadros y pulsa el botón Aceptar.

Observa el resultado:
361
En Java, los vectores debe declararse y luego construirse. Es en la construcción
del vector cuando a este se le asigna un número de elementos.
Los vectores en Java pueden ser usados de la misma forma que en C.
En Java se pueden crear vectores de componentes: etiquetas, botones, etc,
facilitando luego el trabajo con todos estos elementos en conjunto y facilitando
las labores de diseño.
ARREGLOS DE COMPONENTES GUI Y SUS EVENTOS
362
En Java se pueden crear vectores de componentes, como ya se vio
anteriormente anterior. Estos vectores pueden contener un grupo de etiquetas, o
botones, cuadros de textos, etc.
Gracias a los vectores de componentes se pueden crear rápidamente por código
estos componentes y trabajar sobre ellos sin tener que usar muchas líneas de
código.
En esta sección se verá cómo se pueden asignar eventos a los componentes de
un vector.
El siguiente ejemplo aprenderemos cómo hacerlo:
Empecemos definiendo desde código las características de la ventana.

Crearemos el método CreacionVentana, y lo llamaremos desde el
constructor del proyecto:
2. Vamos a situar en la ventana 5 botones, y para ello usaremos un vector

de botones, que tendremos que declarar en la zona de variables
globales:
363
3. Dentro del procedimiento CreacionVentana construiremos el vector y
construiremos cada uno de los botones que contiene, asignando las
distintas características de cada uno. Debes añadir el siguiente código a
CreacionVentana:
En el código anterior se crea un vector de cadenas (String) con el texto

de cada botón.
4. Luego se construye el vector de botones, asignándole 5 botones.
A continuación, usando un for, construimos cada botón del vector, le

asignamos el texto correspondiente, le asignamos su posición y su
tamaño, y lo colocamos en el panel de contenido de la ventana.
Ejecuta el programa para observar su aspecto hasta ahora:
364
Ahora, interesaría asignar un evento actionPerformed a cada botón. Esto se hará
aprovechando el que todos los botones pertenezcan a un vector, usando un
bucle for. Añade el siguiente código al final de CreacionVentana:
Este código asigna a cada botón un evento actionPerformed que hace una
llamada a un procedimiento al que se le ha llamado botonesActionPerformed.
(Esta llamada da error porque aún no ha sido programado el procedimiento. Esto
se hará a continuación.)
Hay que tener en cuenta que cuando se pulse cualquiera de los botones, se
ejecutará el procedimiento botonesActionPerformed. Programa este
procedimiento (fuera de CreacionVentana, por supuesto) de la siguiente forma:
Ejecuta el programa y observa el resultado. Cuando pulsas cualquiera de los

botones, se ejecuta la respuesta al evento y esta lo que hace es mostrar un
mensaje a través de un JOptionPane donde aparece el texto “Has pulsado uno
de los botones”.
365
El procedimiento botonesActionPerformed sirve como respuesta para todos los
botones. El problema que plantea esto es, ¿cómo saber qué botón se ha
pulsado? Es aquí donde entra en funcionamiento el parámetro evt que suelen
llevar todos los eventos.
Modifica el procedimiento botonesActionPerformed de forma que quede así:
Este código resulta muy interesante. El parámetro evt tiene siempre un método
llamado getSource que devuelve el componente de la ventana sobre el que ha
sucedido el evento. De esta manera obtenemos el botón que ha sido pulsado.
(Observa que es necesario hacer un cast) Aprovechamos esto para introducir el
botón en una variable auxiliar que hemos llamado botonPulsado.
Luego solo hay que usar la variable botonPulsado como un botón normal y
corriente. Por ejemplo, la usamos en el JOptionPane mostrando el texto que
contiene el botón pulsado con el método getText.
Ejecuta el programa y observa el resultado.
EN RESUMEN
Se pueden asignar eventos a los elementos de un vector a través de un for que
recorra los distintos elementos del vector y le asigne el evento o eventos
necesarios.
Cuando se asigna un mismo procedimiento de respuesta a eventos a varios
componentes, es necesario usar el parámetro evt junto con el método getSource
para averiguar el componente sobre el que ha sucedido el evento.
La forma general de acceder al elemento sobre el que sucedió el evento es la
siguiente:
TipoComponente variable = (TipoComponente) evt.getSource();
La variable variable contendrá el componente activado.
366
CAPITULO 7: FUNDAMENTOS DE ORIENTACIÓN A OBJETOS
Durante el desarrollo de todo los temas y sus respectivos ejemplo expuestos a lo

largo de este libro hemos mencionado y quizás explicado brevemente los
conceptos de Clase, Objeto, Instancia, Propiedades, Métodos, Herencia,
Abstracción, Polimorfismo, Sobrecarga, Constructores, etc. Bueno llego la hora
de conocer en detalle todos estos conceptos teóricos y metodológicos que giran
alrededor del desarrollo moderno de Software, conceptos que no son para nada
modernos, puesto que llevan más de 30 años, cuando apareció por primera vez
con el lenguaje de programación Simula 67 y SmaltTack, hoy prácticamente
extinto por otros lenguajes como C++, Java y C#.
En los siguientes apartados y secciones aprenderemos los conceptos básicos de

esta metodología de programación Orienta a Objetos, iniciando con decir que su
nombre se debe a que en un programa en ejecución Orientado a Objeto todo
absolutamente todo lo que posee información en RAM debería ser un Objeto, tal
y como los es en aplicaciones escritas en C#, mientras que en Java existen
Objetos y variables primitivas o simples que no son objetos.
La programación orientada a objetos es una nueva forma de entender la

creación de programas. Esta filosofía de programación se basa en el concepto
de objeto.
DEFINICIÓN DE OBJETOS
Un objeto se define como un elemento que tiene unas propiedades y métodos.

Un objeto posee unas características (ancho, alto, color, etc…) A las
características de un objeto se les llama propiedades.
Un objeto es un elemento “inteligente”. A un objeto se le puede dar órdenes y él
obedecerá. A estas órdenes se les llama métodos. Con los métodos podemos
cambiar las características del objeto, pedirle información, o hacer que el objeto
reaccione de alguna forma.
En Java todo son objetos. Veamos algunos ejemplos de uso de objetos en Java:
PRIMER EJEMPLO
Supongamos que tenemos una etiqueta llamada etiTexto. Esta etiqueta es un
objeto.
Como objeto que es, la etiqueta etiTexto tiene una serie de características, como
por ejemplo: el color de fondo, el tamaño, la posición que ocupa en la ventana, el
ser opaca o no, el ser invisible o no, etc… Son las propiedades de la etiqueta.
367
A una etiqueta le podemos dar órdenes, a través de métodos.
A través de los métodos podemos por ejemplo cambiar las características del
objeto. Por ejemplo, se puede cambiar el tamaño y posición de la etiqueta
usando el método setBounds:
etiTexto.setBounds(10,20,100,20);
Normalmente, los métodos que permiten cambiar las características del objeto
son métodos cuyo nombre empieza por set.
Los métodos también permiten pedirle al objeto que me de información. Por
ejemplo, podríamos usar el conocido método getText para recoger el texto que
contenga la etiqueta y almacenarlo en una variable:
String texto;
texto = etiTexto.getText();
Los métodos que le piden información al objeto suelen tener un nombre que
empieza por get.
Los métodos también sirven para ordenarle al objeto que haga cosas. Por
ejemplo, podemos ordenar a la etiqueta etiTexto que se vuelva a pintar en la
ventana usando el método repaint:
etiTexto.repaint();
Segundo ejemplo
Supongamos que tenemos un cuadro de texto llamado txtCuadro. Como todo en
Java, un cuadro de texto es un objeto.
Un objeto tiene propiedades, es decir, características. Nuestro cuadro de texto

txtCuadro tiene características propias: un color de fondo, un ancho, un alto, una
posición en la ventana, el estar activado o no, el estar visible o no, etc…
A un objeto se le puede dar órdenes, llamadas métodos. Estas órdenes nos
permiten cambiar las características del objeto, pedirle información, o
simplemente pedirle al objeto que haga algo.
Por ejemplo, podemos cambiar el color de fondo del cuadro de texto txtCuadro
usando el método llamado setBackground:
txtCuadro.setBackground(Color.RED);
Otros métodos que permiten cambiar las propiedades del objeto txtCuadro son:
setVisible - permite poner visible / invisible el cuadro de texto
setEnabled - permite activar / desactivar el cuadro de texto
setEditable - permite hacer que se pueda escribir o no en el cuadro de texto
setText - permite introducir un texto en el cuadro de texto
setBounds - permite cambiar el tamaño y posición del objeto
setToolTipText - permite asociar un texto de ayuda al cuadro de texto
etc…
Un objeto nos da información sobre él. Para pedirle información a un objeto
usaremos métodos del tipo get. Por ejemplo, para pedirle al cuadro de texto el
texto que contiene, usaremos el método getText:
String cadena = txtCuadro.getText();
368
Otros métodos que le piden información al cuadro de texto son:
getWidth - te dice la anchura que tiene el cuadro de texto
getHeight - te dice el alto que tiene el cuadro de texto
getSelectedText - te devuelve el texto que está seleccionado dentro del
cuadro de texto
getToolTipText - te dice el texto de ayuda que tiene asociado el cuadro de
texto
etc…
También se le puede dar al objeto simplemente órdenes para que haga algo. Por
ejemplo, podemos ordenar al cuadro de texto txtCuadro que seleccione todo el
texto que contiene en su interior a través del método selectAll:
txtCuadro.selectAll();
Otros métodos que ordenan al cuadro de texto son:
repaint - le ordena al cuadro de texto que se vuelva a pintar
copy - le ordena al cuadro de texto que copie el texto que
tengaseleccionado
cut - le ordena al cuadro de texto que corte el texto que tenga
seleccionado
paste - le ordena al cuadro que pegue el texto que se hubiera
copiado o cortado
etc…
DEFINICIÓN DE CLASE
Todo objeto es de una “clase” determinada, o dicho de otra forma, tiene un “tipo
de datos” determinado.
Por ejemplo, las etiquetas que se usan en las ventanas son objetos que
pertenecen a la clase JLabel. Los cuadros de texto en cambio son objetos de la
clase JTextField.
Para poder usar un objeto hay que declararlo y construirlo.
Declarar un Objeto
La declaración de un objeto es algo similar a la declaración de una variable. Es
en este momento cuando se le da un nombre al objeto. Para declarar un objeto
se sigue la siguiente sintaxis:
Clase nombreobjeto;
Por ejemplo, para declarar la etiqueta del ejemplo 1, se usaría el siguiente
código:
JLabel etiTexto;
Para declarar, en cambio, el cuadro de texto del ejemplo 2, se usaría el siguiente
código:
369
JTextField txtCuadro;
Construir un Objeto
En el momento de la “construcción” de un objeto, se le asignan a este una serie
de propiedades iniciales. Es decir, unas características por defecto. Se puede
decir que es el momento en que “nace” el objeto, y este nace ya con una forma
predeterminada, que luego el programador podrá cambiar usando los métodos
del objeto.
Es necesario construir el objeto para poder usarlo. La construcción del objeto se
hace a través del siguiente código general:
nombreobjeto = new Clase();
Por ejemplo, para construir la etiqueta del ejemplo 1, se haría lo siguiente:
etiTexto = new JLabel();
Para construir el cuadro de texto del ejemplo 2, se haría lo siguiente:
txtCuadro = new JTextField();
NOTA. En algunos casos, la sintaxis de la declaración y la construcción se une
en una sola línea. Por ejemplo, supongamos que queremos declarar la etiqueta
etiTexto y construirla todo en una línea, entonces se puede hacer lo siguiente:
JLabel etiTexto = new JLabel();
En general, para declarar y construir un objeto en una sola línea se sigue la
siguiente sintaxis:
Clase nombreobjeto = new Clase();
La Clase como generadora de objetos

Conociendo la Clase, se pueden crear tantos objetos de dicha Clase como se
quiera. Es decir, la Clase de un objeto funciona como si fuera una plantilla a
partir de la cual fabricamos objetos iguales. Todos los objetos creados a partir de
una clase son iguales en un primer momento (cuando se construyen) aunque
luego el programador puede dar forma a cada objeto cambiando sus
propiedades.
Por ejemplo, la Clase JLabel define etiquetas. Esto quiere decir que podemos
crear muchas etiquetas usando esta clase:
JLabel etiTexto = new JLabel();
JLabel etiResultado = new JLabel();
JLabel etiDato = new JLabel();
En el ejemplo se han declarado y construido tres etiquetas llamadas etiTexto,
etiResultado y etiDato. Las tres etiquetas en este momento son iguales, pero a
través de los distintos métodos podemos dar forma a cada una:
etiTexto.setBackground(Color.RED);
etiTexto.setText(“Hola”);
etiResultado.setBackground(Color.GREEN);
370
etiResultado.setText(“Error”);
etiDato.setBackground(Color.BLUE);
etiDato.setText(“Cadena”);
En el ejemplo se le ha dado, usando el método setBackground, un color a cada
etiqueta. Y se ha cambiado el texto de cada una. Se le da forma a cada etiqueta.
Tercer Ejemplo
Hasta ahora ha usado objetos aunque no tenga mucha conciencia de ello. Por
ejemplo ha usado botones. Como ejercicio se propone lo siguiente:
 ¿Cuál es el nombre de la clase de los botones normales que usa en sus

ventanas?
 ¿Cómo declararía un botón llamado btnAceptar, y otro llamado
btnCancelar?
 ¿Cómo construiría dichos botones?
 Indique algunos métodos para cambiar propiedades de dichos botones
(métodos set)
 Indique algunos métodos para pedirle información a dichos botones
(métodos get)
 Indique algún método para dar órdenes a dichos botones (algún método
que no sea ni set ni get)
Un Objeto es un elemento que tiene una serie de características llamadas

PROPIEDADES.
Por otro lado, al objeto se le pueden dar órdenes que cumplirá de inmediato. A
dichas órdenes se les denomina MÉTODOS.
Los métodos se pueden dividir básicamente en tres tipos:
 Para cambiar las propiedades del objeto (Métodos set)
 Para pedir información al objeto (Métodos get)
 Para dar órdenes al objeto.
Todo objeto pertenece a una CLASE.

La CLASE nos permite declarar objetos y construirlos:
Declaración:
CLASE nombreobjeto;
Construcción:
nombreobjeto = new CLASE();
Declaración y Construcción en una misma línea
CLASE nombreobjeto = new CLASE(),
371
En la construcción de un objeto se asignan unas propiedades (características)
por defecto al objeto que se construye, aunque luego, estas características
pueden ser cambiadas por el programador.
COMO DISEÑAR NUESTRAS PROPIAS CLASES PERSONALIZADAS
Hasta el momento, todos los objetos que ha usado a la hora de programar en

Java, han sido objetos incluidos en el propio lenguaje, que se encuentran
disponibles para que el programador los use en sus programas.
Estos objetos son: las etiquetas (JLabel), botones (JButton), los
cuadros de texto (JTextField), cuadros de verificación
(JCheckBox), botones de opción (JRadioButton), colores
(Color), imágenes de icono (ImageIcon), modelos de lista
(DefaultListModel), etc, etc.
Todos estos objetos, por supuesto, pertenecen cada uno de ellos a una Clase:
Las etiquetas son objetos de la clase JLabel, los botones son
objetos de la clase JButton, etc.
Todos estos objetos tienen propiedades que pueden ser cambiadas en la
ventana de diseño:
Ancho, alto, color, alineación, etc.
Aunque también poseen métodos que nos permiten cambiar estas propiedades
durante la ejecución del programa:
setText cambia el texto del objeto, setBackground cambia el
color de fondo del objeto, setVisible hace visible o invisible al
objeto, setBounds cambia el tamaño y la posición del objeto, etc.
En cualquier momento le podemos pedir a un objeto que nos de información
sobre sí mismo usando los métodos get:
getText obtenemos el texto que tenga el objeto, getWidth
obtenemos la anchura del objeto, getHeight obtenemos la altura
del objeto, etc.
Los objetos son como “pequeños robots” a los que se les puede dar órdenes,
usando los métodos que tienen disponible.
Por ejemplo, le podemos decir a un objeto que se pinte de nuevo
usando el método repaint, podemos ordenarle a un cuadro de
texto que coja el cursor, con el método requestFocus, etc.
Todos estos objetos, con sus propiedades y métodos, nos facilitan la creación de
nuestros programas. Pero a medida que nos vamos introduciendo en el mundo
de la programación y nos especializamos en un tipo de programa en concreto,
puede ser necesaria la creación de objetos propios, programados por nosotros
mismos, de forma que puedan ser usados en nuestros futuros programas.
A la hora de diseñar un objeto de creación propia, tendremos que pensar qué

propiedades debe tener dicho objeto, y métodos serán necesarios para poder
372
trabajar con él. Dicho de otra forma, debemos pensar en qué características
debe tener el objeto y qué órdenes le podré dar.
Para crear objetos propios hay que programar la Clase del objeto. Una vez
programada la Clase, ya podremos generar objetos de dicha clase,
declarándolos y construyéndolos como si de cualquier otro objeto se tratara.
A continuación se propondrá un caso práctico de creación de objetos propios,
con el que trabajaremos en las próximas hojas.
Lo que viene a continuación es un planteamiento teórico de diseño de una Clase
de Objetos.
UN EJEMPLO DE LA APLICACIÓN DE LA ORIENTACIÓN A OBJETOS EN

JAVA
Los requerimientos
Los Multicines Avenida nos encargan un programa para facilitar las distintas
gestiones que se realizan en dichos multicines.
El multicine cuenta con varias salas, y cada una de ellas genera una serie de
información. Para facilitar el control de la información de cada sala
programaremos una Clase de objeto a la que llamaremos SalaCine.
La Clase SalaCine
La Clase SalaCine definirá características de una sala de cine, y permitirá crear
objetos que representen salas de cine. Cuando la Clase SalaCine esté
programada, se podrán hacer cosas como las que sigue:
Los Multicines Avenida tienen una sala central donde se proyectan normalmente
los estrenos. Se podría crear un objeto llamado central de la clase SalaCine de
la siguiente forma:
SalaCine central;
Por supuesto, este objeto puede ser construido como cualquier otro:
central = new SalaCine();
El objeto central representará a la sala de cine central de los Multicines Avenida.
Otro ejemplo. Los Multicines Avenida tienen una sala donde proyectan versiones
originales. Se podría crear un objeto llamado salaVO de la clase SalaCine de la
siguiente forma:
SalaCine salaVO; //declaración
salaVO = new SalaCine(); //construcción
Propiedades de los objetos de la clase SalaCine

A la hora de decidir las propiedades de un objeto de creación propia, tenemos
que preguntarnos, ¿qué información me interesa almacenar del objeto?
Trasladando esta idea a nuestro caso práctico, ¿qué información me interesaría
tener de cada sala de cine?
373
Para este ejemplo supondremos que de cada sala de cine nos interesa tener
conocimiento de las siguientes características (propiedades):
 Aforo: define el número de butacas de la sala (un número entero).
 Ocupadas: define el número de butacas ocupadas (un número entero).
 Película: define la película que se está proyectando en el momento en la
sala (una cadena de texto)
 Entrada: define el precio de la entrada (un número double)
Valores por defecto de los objetos SalaCine

Cuando se construye un objeto, se asignan unos valores por defecto a sus
propiedades. Por ejemplo, cuando se construye una etiqueta (Clase JLabel),
esta tiene un tamaño inicial definido, un color, etc.
Lo mismo se tiene que hacer con los objetos propios que definimos. Es
necesario decidir qué valores tendrá las propiedades del objeto al construirse.
En nuestro caso, las características de un objeto SalaCine en el momento de
construirse serán las siguientes:
Aforo: 100
Ocupadas: 0
Película: “” (la cadena vacía)
Entrada: 5,00
Observa este código, en él construimos el objeto correspondiente a la sala

central del multicine:
SalaCine central;
central = new SalaCine();
En este momento (en el que el objeto central está recién construido) este objeto
tiene asignado un aforo de 100, el número de butacas ocupadas es 0, la película
que se proyecta en la sala central es “” y la entrada para esta sala es de 5 euros.
Los valores por defecto que se asignan a los objetos de una clase son valores
arbitrarios que el programador decidirá según su conveniencia.
Métodos de los objetos SalaCine

Para comunicarnos con los objetos de la Clase SalaCine que construyamos,
tendremos que disponer de un conjunto de métodos que nos permitan asignar
valores a las propiedades de los objetos, recoger información de dichos objetos y
que le den órdenes al objeto.
Será el programador el que decida qué métodos le interesará que posea los
objetos de la Clase que está programando.
Para nuestro caso particular, supondremos que los objetos de la Clase SalaCine
deberán tener los siguientes métodos:
374
Métodos de cambio de propiedades (Métodos set)
setAforo - asignará un aforo a la sala de cine
setOcupadas - asignará una cantidad de butacas ocupadas a la sala de cine
setLibres - asignará una cantidad de butacas libres a la sala de cine
setPelicula - asignará un título de película a la sala de cine
setEntrada - fijará el precio de las entradas a la sala de cine
Gracias a estos métodos podemos dar forma a un objeto SalaCine recién
creado.
Por ejemplo, supongamos que queremos crear el objeto que representa la sala
de versiones originales. Resulta que esta sala tiene de aforo 50 localidades, que
se está proyectando la película “Metrópolis” y que la entrada para ver la película
es de 3 euros. La sala está vacía de momento.
Para crear el objeto, se usaría el siguiente código:
//Se construye el objeto
SalaCine salaVO;
salaVO = new SalaCine();
//Se le asignan características
salaVO.setAforo(50); //aforo 50
salaVO.setPelicula(“Metrópolis”); //la película que se proyecta
salaVO.setEntrada(3); //entrada a 3 euros
Al construir el objeto salaVO tiene por defecto los valores siguientes en sus
propiedades:
Aforo: 100
Ocupadas: 0
Película: “”
Entrada: 5,00
Gracias a los métodos disponibles hemos asignados estos nuevos valores:
Aforo: 50
Ocupadas: 0
Película: “Metrópolis”
Entrada: 3,00
Métodos para pedirle información al objeto (Métodos get)

Se programarán los siguientes métodos get en la clase SalaCine:
getAforo - devuelve el aforo que tiene el objeto
getOcupadas - devuelve el número de butacas ocupadas que tiene el objeto
getLibres - devuelve el número de butacas que tiene libres el objeto
getPorcentaje - devolverá el porcentaje de ocupación de la sala
getIngresos - devolverá los ingresos producidos por la sala (entradas
vendidas por precio)
getPelicula - devolverá el título de la película que se está proyectando
getEntrada - devolverá el precio de la entrada asignado al objeto
375
Estos métodos nos permitirán obtener información de un objeto del tipo
SalaCine. Por ejemplo, supongamos que tenemos el objeto llamado central
(correspondiente a la sala principal del multicine), para obtener la película que se
está proyectando en dicha sala solo habría que usar este código:
String peli; //una variable de cadena
peli = central.getPelicula();
O, por ejemplo, para saber los ingresos producidos por la sala central…
double ingresos;
ingresos = central.getIngresos();
Métodos para dar órdenes al objeto
Se programarán los siguientes métodos para dar órdenes a los objetos de la
clase SalaCine.
vaciar
- Este método pondrá el número de plazas ocupadas a cero y le asignará
a la película la cadena vacía.
entraUno
- Este método le dice al objeto que ha entrado una nueva persona en la
sala. (Esto debe producir que el número de plazas ocupadas aumente en
uno)
RESUMEN SALACINE
He aquí un resumen de la Clase de objetos SalaCine, la cual se programará en
la próxima hoja:
Clase de objetos: SalaCine
Propiedades de los objetos SalaCine:
Aforo - número entero (int)
Ocupadas - número entero (int)
Película - cadena (String)
Entrada - número decimal (double)
Valores por defecto de los objetos del tipo SalaCine:
Aforo: 100
Ocupadas: 0
Película: (cadena vacía)
Entrada: 5
Métodos de los objetos del tipo SalaCine:
Métodos de asignación de propiedades (set)
setAforo - modifica la propiedad Aforo
setOcupadas - modifica la propiedad Ocupadas
setLibres - modifica la propiedad Ocupadas también
setPelicula - modifica la propiedad Película
setEntrada - modifica la propiedad Entrada
Métodos de petición de información (get)
getAforo - devuelve el valor de la propiedad Aforo
376
getOcupadas - devuelve el valor de la propiedad Ocupadas
getLibres - devuelve el número de butacas libres
getPorcentaje - devuelve el porcentaje de ocupación de la sala
getIngresos - devuelve los ingresos obtenidos por la venta de entradas
getPelicula - devuelve el valor de la propiedad Película
getEntrada - devuelve el valor de la propiedad Entrada
Métodos de orden
Vaciar - vacía la ocupación de la sala y borra la película
entraUno - le indica al objeto que ha entrado una persona más en la
sala
Ejercicio Propuesto
Supongamos que programamos una Clase de objetos llamada Rectangulo, la
cual permitirá construir objetos que representen a rectángulos.
1. ¿Cómo declararía y construiría un objeto llamado suelo del tipo
Rectangulo?
2. Supongamos que las propiedades de los objetos de la clase Rectangulo

sean las siguientes:
a. Base (double)
b. Altura (double)
¿Qué métodos de tipo set programaría para cambiar las propiedades de
los objetos del tipo Rectangulo?
3. Como ejemplo de los métodos anteriores, suponga que quiere asignar al
objeto suelo una base de 30 y una altura de 50. ¿Qué código usaría?
4. Teniendo en cuenta que nos puede interesar conocer el área de un

objeto Rectangulo y su perímetro, y teniendo en cuenta que los objetos
Rectangulo tienen dos propiedades (Base y Altura), ¿qué cuatro métodos
get serían interesantes de programar para los objetos del tipo
Rectangulo?
5. Teniendo en cuenta los métodos del punto 4. Supongamos que quiero

almacenar en una variable double llamada area el área del objeto suelo.
¿Qué código usaría? Y si quiero almacenar el perímetro del objeto suelo
en una variable llamada peri?
Para crear un objeto propio, necesita tener claro lo siguiente:

 Nombre de la Clase del objeto.
 Propiedades que tendrán los objetos de dicha clase.
377
 Valores iniciales que tendrán las propiedades cuando se construya cada
objeto.
Métodos que serán interesantes de programar:

 Métodos de ajuste de propiedades (set)
 Métodos de petición de información (get)
 Métodos de orden
Una vez que se tenga claro lo anterior, se podrá empezar la programación de la

Clase de objetos.
CONSTRUIR LOS ELEMENTOS DEL PROYECTO EJEMPLO (LAS CLASES

Y OBJETOS)
En este ejercicio guiado, crearemos la Clase SalaCine, que hemos descrito en la

hoja anterior. Luego, a partir de esta clase, fabricaremos objetos representando
salas de cine, y los usaremos en un proyecto Java.
Recuerda las características que hemos decidido para la Clase SalaCine en la
hoja anterior:
CLASE SALACINE
Nombre de la Clase: SalaCine
Propiedades de los objetos SalaCine:
Aforo - número entero (int)
Ocupadas - número entero (int)
Película - cadena (String)
Entrada - número decimal (double)
Valores por defecto de los objetos del tipo SalaCine:
Aforo: 100
Ocupadas: 0
Película: (cadena vacía)
Entrada: 5
Métodos de los objetos del tipo SalaCine:
Métodos de asignación de propiedades (set)
setAforo - modifica la propiedad Aforo
setOcupadas - modifica la propiedad Ocupadas
setLibres - modifica la propiedad Ocupadas también
setPelicula - modifica la propiedad Película
setEntrada - modifica la propiedad Entrada
Métodos de petición de información (get)
getAforo - devuelve el valor de la propiedad Aforo
378
getOcupadas - devuelve el valor de la propiedad Ocupadas
getLibres - devuelve el número de butacas libres
getPorcentaje - devuelve el porcentaje de ocupación de la sala
getIngresos - devuelve los ingresos obtenidos por la venta de entradas
getPelicula - devuelve el valor de la propiedad Película
getEntrada - devuelve el valor de la propiedad Entrada
Métodos de orden
Vaciar - vacía la ocupación de la sala y borra la película
entraUno - le indica al objeto que ha entrado una persona más en la
sala
Fichero de la Clase
La programación de una clase de objetos se realiza en un fichero aparte, cuyo
nombre es exactamente el mismo que el de la propia clase, y cuya extensión es
.java.
Por ejemplo, si queremos programar la clase SalaCine, esto se debe hacer en un
fichero llamado:
SalaCine.java
Cuando programemos esta clase dentro de NetBeans, veremos las facilidades
que nos proporciona este para la creación de la clase. De momento, solo
veremos de forma teórica como hay que programar la clase. (No tiene que
introducir lo que viene a continuación en ningún sitio)
Estructura básica de la Clase

Dentro del fichero de la clase, comenzará la programación de esta de la
siguiente forma:
public class SalaCine {

// AQUÍ VA EL CUERPO DE LA CLASE
// COMPUESTO POR PROPIEDADES Y MÉTODOS
}
La programación de una clase comienza siempre con una línea de código como
la que sigue:
public class NombreDeLaClase {
// AQUÍ VA EL CUERPO DE LA CLASE
// COMPUESTO POR PROPIEDADES Y MÉTODOS
}
Toda la programación de la clase se introducirá dentro de las dos llaves.
Propiedades de la Clase
Lo primero que se debe introducir en la clase que se está programando son las
propiedades. Las propiedades de una clase son básicamente variables globales
379
de ésta. Si introducimos las propiedades de la clase SalaCine, esta nos quedaría
así:
// ESTAS SON LAS PROPIEDADES
int Aforo;
int Ocupadas;
String Película;
double Entrada;
}
Constructor de la Clase
Cuando se planteó la clase SalaCine, se tuvo que decidir qué valores iniciales
deberían tener las propiedades de la clase. Para asignar estos valores iniciales,
es necesario programar lo que se denomina el Constructor. El Constructor de
una clase es un método (un procedimiento para entendernos) un poco especial,
ya que debe tener el mismo nombre de la clase y no devuelve nada, pero no
lleva la palabra void. Dentro del constructor se inicializan las propiedades de la
clase. En general, la programación del constructor sigue la siguiente sintaxis:
public NombreDeLaClase() {
propiedad1 = valor;
propiedad2 = valor;
etc…
}
La clase SalaCine, añadiendo el Constructor, tendrá el siguiente aspecto:
// ESTAS SON LAS PROPIEDADES
int Aforo;
int Ocupadas;
String Película;
double Entrada;
// ESTE ES EL CONSTRUCTOR
public SalaCine() {
Aforo = 100;
Ocupadas = 0;
Pelicula = “”;
Entrada = 5.0;
}
}
Observa como usamos el constructor de la clase SalaCine para asignar a cada

propiedad los valores por defecto decididos en el diseño de la clase que se hizo
en la hoja anterior.
380
Métodos del tipo set
Todas las clases suelen contener métodos del tipo set. Recuerda que estos
métodos permiten asignar valores a las propiedades de la clase.
Debes tener en cuenta también que cuando se habla de método de una clase,
en realidad se está hablando de un procedimiento o función, que puede recibir
como parámetro determinadas variables y que puede devolver valores.
Los métodos del tipo set son básicamente procedimientos que reciben valores
como parámetros que introducimos en las propiedades. Estos métodos no
devuelven nada, así que son void.
Se recomienda, que el parámetro del procedimiento se llame de forma distinta a
la propiedad que se asigna.
Veamos la programación del método setAforo, de la clase SalaCine:
public void setAforo(int afo) {
Aforo = afo;
}
Observa este método:
 Es void, es decir, no devuelve nada (el significado de la palabra public se
verá más adelante)
 El método recibe como parámetro una variable del mismo tipo que la
propiedad que queremos modificar (en este caso int) y un nombre que se
recomienda que no sea igual al de la propiedad (en nuestro caso, afo, de
aforo)
 Puedes observar que lo que se hace simplemente en el método es
asignar la variable pasada como parámetro a la propiedad.
La mayoría de los procedimientos set usados para introducir valores en las

propiedades tienen la misma forma. Aquí tienes la programación de los demás
procedimientos set de la clase SalaCine.
//Método setOcupadas
public void setOcupadas(int ocu) {
Ocupadas = ocu;
}
//Método setPelicula
public void setPelicula(String peli) {
Pelicula = peli;
}
//Método setEntrada
public void setEntrada(double entra) {
Entrada = entra;
}
381
Hay un método set de la clase SalaCine llamado setLibres cuya misión es
asignar el número de localidades libres del cine. Sin embargo la clase SalaCine
no tiene una propiedad “Libres”. En realidad, este método debe modificar el
número de localidades ocupadas. Observa su programación:
//Método setLibres
public void setLibres(int lib) {
int ocu;
ocu = Aforo – lib;
Ocupadas = ocu;
}
Al asignar un número de localidades ocupadas, estamos asignando

indirectamente el número de localidades libres. Como puedes observar en el
método, lo que se hace es calcular el número de localidades ocupadas a partir
de las libres, y asignar este valor a la propiedad Ocupadas.
No se pensó en crear una propiedad de la clase llamada Libres ya que en todo
momento se puede saber cuantas localidades libres hay restando el Aforo
menos las localidades Ocupadas.
La clase SalaCine, añadiendo los métodos set, quedaría de la siguiente forma:
int Aforo;
int Ocupadas;
String Película;
double Entrada;
//Constructor
public SalaCine() {
Aforo = 100;
Ocupadas = 0;
Pelicula = “”;
Entrada = 5.0;
}
//Métodos set
//Método setAforo
Aforo = afo;
}
Ocupadas = ocu;
}
382
Pelicula = peli;
}
Entrada = entra;
}
//Método setLibres
int ocu;
Ocupadas = ocu;
}
}
Métodos del tipo get

Al igual que los métodos set, los métodos get son muy fáciles de programar ya
que suelen tener siempre la misma forma.
Estos métodos no suelen llevar parámetros y devuelven el valor de la propiedad
correspondiente usando la típica instrucción return usada tanto en las funciones.
Por tanto, un método get nunca es void. Siempre será del mismo tipo de datos
que la propiedad que devuelve.
Veamos la programación del método getAforo:

//Método getAforo
public int getAforo() {
return Aforo;
}
Como puedes ver el método simplemente devuelve el valor de la propiedad
Aforo. Como esta propiedad es int, el método es int.
Los métodos que devuelven el resto de las propiedades son igual de sencillos de
programar:
//Método getOcupadas
public int getOcupadas() {
return Ocupadas;
}
//Método getPelicula
public String getPelicula() {
return Película;
}
//Método getEntrada
public double getEntrada() {
return Entrada;
383
}
Todos estos métodos son iguales. Solo tienes que fijarte en el tipo de datos de la
propiedad que devuelven.
Existen otros métodos get que devuelven cálculos realizados con las
propiedades. Estos métodos realizan algún cálculo y luego devuelven el
resultado. Observa el siguiente método get:
//Método getLibres
public int getLibres() {
int lib;
lib = Aforo – Ocupadas;
return lib;
}
No existe una propiedad Libres, por lo que este valor debe ser calculado a partir
del Aforo y el número de localidades Ocupadas. Para ello restamos y
almacenamos el valor en una variable a la que hemos llamado lib. Luego
devolvemos dicha variable.
Los dos métodos get que quedan por programar de la clase SalaCine son
parecidos:
//Método getPorcentaje
public double getPorcentaje() {
double por;
por = (double) Ocupadas / (double) Aforo * 100.0;
return por;
}
Este método calcula el porcentaje de ocupación de la sala (es un valor double)
//Método getIngresos
public double getIngresos() {
double ingre;
ingre = Ocupadas * Entrada;
return ingre;
}
Los ingresos se calculan multiplicando el número de entradas por lo que vale

una entrada.
La clase SalaCine una vez introducidos los métodos get quedaría de la siguiente
forma:
int Aforo;
int Ocupadas;
String Película;
double Entrada;
//Constructor
384
public SalaCine() {
Aforo = 100;
Ocupadas = 0;
Pelicula = “”;
Entrada = 5.0;
}
//Métodos set
//Método setAforo
Aforo = afo;
}
Ocupadas = ocu;
}
Pelicula = peli;
}
Entrada = entra;
}
//Método setLibres
int ocu;
Ocupadas = ocu;
}
//Métodos get //Método getAforo
return Aforo;
}
return Ocupadas;
}

return Película;
}
385
return Entrada;
}
//Método getLibres
int lib;
return lib;
}
double por;
return por;
}
double ingre;
return ingre; } }
Métodos de orden
Para finalizar la programación de la clase SalaCine, se programarán los dos
métodos de orden que hemos indicado en el planteamiento de la clase. Estos
métodos suelen realizar alguna tarea que involucra a las propiedades de la
clase, modificándola internamente. No suelen devolver ningún valor, aunque
pueden recibir parámetros.
Veamos la programación del método Vaciar, cuyo objetivo es vaciar la sala y
quitar la película en proyección:
//Método Vaciar
public void Vaciar() {
Ocupadas = 0;
Película = “”;
}
Como se puede observar, es un método muy sencillo, ya que simplemente

cambia algunas propiedades de la clase.
El método entraUno es también muy sencillo de programar. Este método le
indica al objeto que ha entrado un nuevo espectador. Sabiendo esto, el objeto
debe aumentar en uno el número de localidades ocupadas:
//Método entraUno
386
public void entraUno() {
Ocupadas++;
}
Añadiendo estos dos últimos métodos, la programación de la clase SalaCine

quedaría finalmente como sigue:
// LAS PROPIEDADES
int Aforo;
int Ocupadas;
String Película;
double Entrada;
//EL CONSTRUCTOR
public SalaCine() {
Aforo = 100;
Ocupadas = 0;
Pelicula = “”;
Entrada = 5.0;
}
//Métodos SET //Método setAforo
Aforo = afo;
}
Ocupadas = ocu;
}
Pelicula = peli;
}
Entrada = entra;
}
//Método setLibres
int ocu;
Ocupadas = ocu;
}
//Métodos get
//Método getAforo
387
return Aforo; Métodos Get
}
return Ocupadas;
}
return Película;
}
return Entrada;
}
//Método getLibres
int lib;
return lib;
}
double por;
return por;
}
double ingre;
return ingre;
}
//Métodos de orden //Método Vaciar
public void Vaciar() {
Ocupadas = 0;
Película = “”; }
//Método entraUno
public void entraUno() {
Ocupadas++;
}
}
Ejercicios Propuesto
388
Supongamos que tenemos una clase llamada Rectangulo que nos permitirá
generar objetos de tipo rectángulo.
Sea el planteamiento de la clase Rectangulo el que sigue:
CLASE RECTANGULO
Nombre de la clase: Rectangulo
Propiedades de los objetos de la clase Rectangulo:
Base (double)
Altura (double)
Valores iniciales de las propiedades de los objetos de la clase Rectangulo:
Base – 100
Altura – 50
Métodos:
Métodos set:
setBase – permite asignar un valor a la propiedad Base.
setAltura – permite asignar un valor a la propiedad Altura.
Métodos get:
getBase – devuelve el valor de la propiedad Base
getAltura – devuelve el valor de la propiedad Altura
getArea – devuelve el área del rectángulo
getPerímetro – devuelve el perímetro del rectángulo
Otros métodos:
Cuadrar – este método debe hacer que la Altura tenga el valor de la Base
La programación de una clase se realiza en un fichero que tiene el mismo

nombre que la clase y extensión .java
La estructura general de una clase es la siguiente:
public class NombreClase {
Propiedades (variables globales)
Constructor
Métodos set
Métodos get
Métodos de orden y otros métodos
}
El Constructor es un procedimiento que no devuelve nada pero que no es void.
El constructor debe llamarse igual que la clase y se usa para asignar los valores
iniciales a las propiedades.
Los métodos set son void y reciben como parámetro un valor que se asigna a la
propiedad correspondiente.
Los métodos get no tienen parámetros y devuelven el valor de una propiedad de
la clase, aunque también pueden realizar cálculos y devolver sus resultados.
Los métodos de orden realizan alguna tarea específica y a veces modifican las
propiedades de la clase de alguna forma.
389
390
391

Tecnicas de Programacion Paso A Paso Con Java - Publicado

Cargado por

Copyright:

Formatos disponibles

Tecnicas de Programacion Paso A Paso Con Java - Publicado

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tecnicas de Programacion Paso A Paso Con Java - Publicado

Cargado por

Copyright:

Formatos disponibles

TECNICAS AVANZADAS DE

PROGRAMACION CON JAVA

John Carlos Arrieta Arrita

TÉCNICAS DE PROGRAMACIÓN PASO A PASO CON JAVA

Autor: John Carlos Arrieta Arrieta

Dedicación de John Carlos Arrieta Arrieta

La vida de toda persona sea cual sea su condición sexual,

Ingeniero John Carlos Arrieta Arrieta.

Cuanta con 10 años de experiencia como docente investigador en varias facultades

El capítulo 1 describe el proceso básico para que se requiere para desarrollar

El capítulo 2 trata de una introducción breve sobre los principales elementos y

En el capítulo 3 explora mediante ejemplos descritos y detallados línea por línea

El Cuarto 4 se enfoca en cómo utilizar y sacar ventaja de una herramienta

documentar, depurar, compilar, empaquetar, probar y modificar un proyecto de

En el capítulo 5 entramos en más detalle y profundidad al explicar igualmente

En el capítulo 6 veremos cómo trabajar con estructuras de datos de tipo Arreglo,

El en capítulo 7 tratamos en detalle mediante ejemplo la conceptualización

CAPITULO 1: LO QUE ESTA DETRÁS DE LA MAGIA 10

TRABAJAR CON MENUS (JMenuBar, JMenu, JMenuItem y JMenuPopup ) 183

UN EJEMPLO DE LA APLICACIÓN DE LA ORIENTACIÓN A OBJETOS EN JAVA

CAPITULO 1: Los trucos del Mago

INTRODUCCIÓN AL DESARROLLO DE SOFTWARE

Un programa de cómputo no es más que un conjunto de instrucciones escritas

El proceso para construir un programa básicamente sigue los siguientes pasos:

1. Se identifican las necesidades (requisitos o requerimientos) que debe

Calcular la nota definitiva de una asignatura partiendo de 3 calificaciones

2. Se identifican y clasifican los tipos de usuarios que van a utilizar el

Docente (introduce las 3 notas parciales y su respectivo porcentaje),

3. Se identifican los datos que necesita el programa para realizar sus

El nombre del ESTUDIANTE, el nombre de la ASIGNATURA las 3 notas

Estas instrucciones se pueden expresar de la siguiente manera:

4. Se identifican, se analizan, se comprenden, se resuelven y se expresan en

Se calcula la calificación definitiva correspondiente a cada NOTA parcial,

La anterior operación se puede expresar mediante las siguientes

DEFINITIVA1 = NOTA1 * PORCENTAJE1

Luego la Calificación Definitiva se calcula sumando las notas parciales

NOTADEFINITVA = DEFINITIVA1 + DEFINITIVA2 +

Si la NOTADEFINITVA es menor que 3.0, entonces el estudiante debe

Si NOTADEFINITVA >= 3.0 Entonces

5. Se identifican los datos que el programa genera como salida, mensajes o

El software debe mostrar mensajes por pantalla con el fin de solicitar al

Las siguientes instrucciones expresan la ejecución de las anteriores

Mostrar “Digite El nombre del Estudiante: “

Luego el software o programa debe mostrar ordenadamente los datos de

Las siguientes instrucciones pueden representar las anteriores operaciones:

Mostrar "Nombre: ", ESTUDIANTE

Mostrar " Nota Definitiva = ", NOTADEFINITVA

6. Se organizan las instrucciones Entrada, Proceso y Salida analizadas

La siguiente imagen muestra un ejemplo de algoritmo en Diagrama de Flujos

Imagen: Ejemplo de Algoritmo representado en Diagrama de Flujos

Indicar el punto de inicio del programa

Indicar uno de los posibles puntos de finalización del

Indica el flujo suculencia o continuidad del programa

Observen la flecha con dirección de salida, es decir, estos datos se enviaran a

Indica la información de Entrada, es decir, el dato proveniente del exterior del PC

Observe la flecha con dirección de entrada, es decir, el programa está esperando

Observe la flecha con dirección hacia la variable DEFINITIVA1, es decir, el

Otra característica distintiva es que no posee con dirección entrante o saliente, lo

Indica que el programa debe ejecutar una situación condicional, en la cual se