Práctica Prog Distri Modo Gráfico Parte03 PDF

IESTP “Ayaviri” Computación e Informática IV - Semestre
021.- Cuadros de Diálogo
Cuadros de Diálogo
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 clase llamada JDialog. Estos objetos
pueden ser diseñados como si fueran ventanas, aunque representan realmente cuadros de diálogo.
1
Ejercicio:
1. Crea un nuevo proyecto en NetBeans.

2. Dentro de paqueteInicial crea un JFrame Form y llamalo CuadroDialogo.
4. Diseña el JFrame Form (VentanaInicial) de forma que la ventana tenga el siguiente
aspecto:
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.
5. 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 IGV y el Descuento a
aplicar. Estos dos valores serán variables globales, ya que se usarán en distintos lugares del
programa.
6. Así pues entra en el código y declara una variable global igv y otra descuentotal
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):
2
7. Cuando el programa arranque, interesará que el igv por defecto sea 0, y que
el descuento por defecto sea 0 también, así que en el método constructor, inicializaremos
las variables globales igv y descuento a 0:
8. Vamos a programar el botón btnCalcular. Entra en su evento actionPerformed y

allí se programará la realización del cálculo de la siguiente forma:
double unidades;
double precio;
double total;
double igvImporte;
double descuentoImporte;
double totalSinIgv;
//Almacenamos los valores de los cuadros de texto convirtiéndolos

//a tipo double en las variables respectivas.
unidades = Double.parseDouble(txtUnidades.getText());
precio = Double.parseDouble(txtPrecio.getText());
//Calculamos el total sin igv, el importe del igv y el importe del

descuento.
totalSinIgv = unidades * precio;
igvImporte = totalSinIgv * igv / 100;
descuentoImporte = totalSinIgv * descuento / 100;
//Calculamos el importe total.

total = totalSinIgv + igvImporte - descuentoImporte;
//Mostramos el total en la etiqueta.

etiTotal.setText(total + "");
3
9. Puedes ejecutar el programa y comprobar que el botón Calcular funciona, aunque

el cálculo que realiza lo hace con un igv igual a 0 y un descuento igual a 0.
10. Seguidamente programaremos el botón Configuración de forma que nos permita

decidir qué igv y qué descuento queremos aplicar. Este botón mostrará un CUADRO DE
DIÁLOGO que permita al usuario configurar estos datos.
11. Para añadir un cuadro de diálogo al proyecto, se tiene que añadir un objeto del
tipo JDialog sobre el JFrame.
12. 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 el inspector, allí verás el JDialog que has añadido:
13. Cámbiale el nombre. Lo llamaremos dialogoConfiguracion.
14. Los cuadros de diálogo generalmente traen por defecto el layout BorderLayout.
Para nuestro ejemplo cambiaremos el layout del JDialog por el Diseño Libre:
4
15. 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.
16. 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 IGV: txtPorcentajeIgv.
- El cuadro de texto del DESCUENTO: txtPorcentajeDescuento.
- El botón Aceptar: btnAceptar.
- El botón Cancelar: btnCancelar.
Si observas el Inspector debe tener el siguiente aspecto:
17. Se pretende 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:
5
18. Para conseguir esto, debes programar en el evento actionPerformed del

botón btnConfiguracion lo siguiente:
dialogoConfiguracion.setSize(300, 220);
dialogoConfiguracion.setLocation(100, 100);
dialogoConfiguracion.setVisible(true);
19. El código anterior hace lo siguiente:
- A través del método setSize se asigna un tamaño de 300 x 220 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.
20. Ejecuta el programa y observa lo que sucede cuando pulsas el botón Configuración
… . Debería aparecer el cuadro de diálogo en la posición establecida y con el tamaño
definido:
21. 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.
22. 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 eventoactionPerformed del
botón Cancelar del diálogo:
dialogoConfiguracion.dispose();
6
El método dispose se usa para cerrar un cuadro de diálogo. También se puede usar para
cerrar un JFrame.
23. Ejecuta el programa de nuevo y comprueba el funcionamiento del

botónCancelar del cuadro de diálogo.
24. Ahora programaremos el botón Aceptar. Cuando el usuario pulse este botón, se
actualizará el valor del igv y del descuento por los que haya introducido. Es decir, se
traspasarán los valores introducidos en los cuadros de

textotxtPorcentajeIgv y txtPorcentajeDescuento a las variables globales igv y descuento.
Una vez que se haya hecho esto, el cuadro de diálogo se debe cerrar.
25. Este es el código que hace lo anterior. Debe programarlo en el

eventoactionPerformed del botón Aceptar:
igv = Double.parseDouble(txtPorcentajeIgv.getText());
descuento = Double.parseDouble(txtPorcentajeDescuento.getText());
dialogoConfiguracion.dispose();
26. 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.
27. 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 igv ni descuento al empezar
el programa)
d. Ahora pulse el botón Configuración, e introduzca un igv del 18. El

descuento déjelo a 0. Acepte.
e. Ahora vuelva a calcular. Observe como ahora el total es 118.0, ya que se
tiene en cuenta el igv configurado.
f. Pruebe a configurar un descuento y vuelva a calcular.
28. 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 igv y descuento”.
29. Vuelva a ejecutar el programa. Observe la barra de título del cuadro de diálogo:
7
30. 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.
31. 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.
d. Esto es posible gracias a que el cuadro de diálogo es no modal.
8
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:
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.
32. 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.
33. 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.
9
34. Ahora ejecuta el programa y 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 que
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.
c. Solo cuando pulses Aceptar o Cancelar, o cierres el cuadro de diálogo, podrás
seguir trabajando con tu ventana.
CONCLUSIONES:
Los Cuadros de Diálogo son ventanas simplificadas que muestran distintas opciones al usuario.
La clase JDialog es la 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 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.
10
022.- Diseño de Formularios Desde Código
La Ventana de Diseño
La ventana de diseño 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 texto, 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.
Ejercicio N° 1:
2. Dentro de paqueteInicial crea un JFrame Form y llamalo FormDeCodigo.
3. Añade en la FormDeCodigo una etiqueta (JLabel), un cuadro de texto (JTextField)

y un botón (JButton).
5. El nombre de la etiqueta será “etiEtiqueta”, del cuadro de texto “txtCuadroTexto”

y del botón será “btnBoton”.
6. A continuación asigna un texto a cada elemento. La ventana debe tener un aspecto

como el siguiente:
7. 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 (Source) en la parte superior de la pantalla:
11
8. En el código, observarás una línea llamada Código Generado (Generated Code). Esta
línea está encerrada por un rectángulo. Observarás que tiene un +en la parte izquierda. Si
haces clic sobre el signo + aparecerá el código generado automáticamente:
9. El código generado 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.
12
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.
Ejercicio N° 2:
A. CREACIÓN DEL PROYECTO:
1. Crear un nuevo proyecto con las siguientes características:
a. El nombre del proyecto será ProyectoOperaciones.
b. El nombre del paquete será paqueteVentanas.
c. El nombre del formulario será VentanaInicial.
El aspecto que tendrá la ventana de proyectos debe ser el siguiente:
2. Una vez creado el proyecto, iremos directamente a la ventana de código, pulsando

el botón Origen (Source). No usaremos la ventana de diseño en este proyecto.
B. ESTRUCTURA DEL CÓDIGO (estructura de una clase):
3. Analizaremos el código del programa ahora. Empezaremos por arriba:
13
4. 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 inicial,
llamado precisamente VentanaInicial. Por tanto, se puede decir que nuestro proyecto tiene
una clase llamada VentanaInicial.
5. Para programar una clase se sigue la siguiente sintaxis:

public class NombreDeLaClase {
…programación de la clase…
}
6. Esto lo puedes observar claramente en el código de tu proyecto:
7. 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.
14
8. 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, VentanaInicial.
Observarás que el método 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 automáticamente. Si quieres verlo, solo tienes que desplegar la parte
de Código Generado:
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
(-).
9. 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í.
15
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 de java, el NetBeans
genera automáticamente el método main, de forma que no tendremos que hacer cambios en él.
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 proyecto tendrá el siguiente aspecto:
Para conseguir esto, sigue los siguientes pasos:

10. 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 método constructor:
11. 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:
16
Este código hace lo siguiente:

- 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.
12. Para que esto tenga efecto, es necesario que el método creacionVentana sea llamado
desde el método constructor, al igual que sucede con el métodoinitComponents:
13. Ya puedes ejecutar el programa. En el momento en que se ejecuta el programa, el

método constructor llama al método creacionVentana y se definen las características
programadas.
14. 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.
17
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 etiNumero1.
15. Al escribir este código, aparecerá un error en la línea, ya que será necesario
importar la biblioteca donde se encuentra el tipo de objeto JLabel. Podrás usar la bombilla
del NetBeans para agregar el import correspondiente automáticamente.
16. Los imports aparecerán en la parte superior del código. Puedes observarlo:
17. Ahora agrega este código a tu método creacionVentana:
18. La explicación del código es la siguiente:
- La primera línea construye la etiqueta llamada etiNumero1 que fue declarada antes.
etiNumero1 = new JLabel();

- Generalizando: para crear un objeto llamado nombreObjeto del tipo tipoObjeto, se
tendrá que hacer lo siguiente:
 En la zona de las variables globales se declarará la variable del objeto de la siguiente
forma:
tipoObjeto nombreObjeto;
 Luego, dentro de la clase, se construye el objeto siguiendo la siguiente sintaxis:
nombreObjeto = new tipoObjeto();
18
- En el ejemplo, la etiqueta creada, cuyo nombre es etiNumero1, tiene que contener

el texto “Número 1:”. Esto lo hacemos con el típico método setText:
etiNumero1.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:
etiNumero1.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(etiNumero1);
19. Es buena idea que ejecutes el programa para ver el aspecto de la ventana ahora.
20. 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:
21. Luego, en el método creacionVentana, añadiremos el siguiente código:
22. Este código es prácticamente igual al anterior. En él se construye la etiqueta

declarada antes con el nombre etiNumero2. 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
23. Ejecuta el programa y observa el aspecto de la ventana ahora:
24. Sigamos añadiendo elementos. Ahora añadiremos un cuadro de texto

llamadotxtNumero1. Primero declara la variable del cuadro de texto en la zona de
variables globales:
Tendrás que agregar el import correspondiente para el tipo de objetoJTextField.
25. Luego añade el siguiente código en el método creacionVentana:
26. Este código realiza lo siguiente:
- La primera línea construye el cuadro de texto llamado txtNumero1. 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
biblioteca 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.
27. Ejecuta el programa y comprueba el funcionamiento de este código.
28. Ahora se añadirá un nuevo cuadro de texto llamado txtNumero2. El código es

similar. Declara la variable global:
20
29. Y ahora añade el código que construye el objeto en el método creacionVentana. Este
código es similar al del cuadro de texto anterior. Solo cambia el nombre del objeto y la
posición donde se colocará:
30. Ejecuta el programa y comprueba como va el diseño de la ventana:
31. 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:
32. Y a continuación construiremos y le daremos forma al botón, añadiendo el siguiente

código en el método creacionVentana:
33. 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.
21
- 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.
34. Ejecuta el programa y observa el aspecto de la ventana.
35. Ahora se añadirá otro botón llamado btnRestar. Declara la variable JButton:
36. Tienes que escribir el siguiente código:
37. El código es prácticamente igual que el del primer botón. Solo cambia el nombre
del botón, el texto, la posición y tamaño del botón.
38. Ejecuta el programa para ver como queda la ventana.
CONCLUSIONES:
Es posible prescindir de la ventana de diseño y realizar todo el diseño de la ventana desde código.
El diseño de la ventana se tiene que hacer en el método 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.
22
023.- Creación de Eventos Desde Código
Creación de eventos desde código

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)
- 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
Programación de eventos
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.
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:
- Eventos de Acción:
o actionPerformed
 Activar un componente (pulsación de botón, enter en un cuadro de texto)
- Eventos de Teclado:
o keyPressed
 Se pulsó una tecla, pero no se soltó.
o keyReleased
 Se soltó una tecla.
o keyTyped
 Se pulsó y soltó una tecla.
23
- Eventos de Ratón:
o mousePressed
 Se pulsó un botón del ratón.
o mouseReleased
 Se soltó un botón del ratón.
o mousePressed
 Se pulsó y soltó un botón del ratón.
o mouseEntered
 El ratón entró en la superficie del control.
o mouseExited
 El ratón salió de la superficie del control.
- Eventos de Ventana:
o windowOpened
 Se abrió la ventana
o windowClosing
 Se cerró la ventana
o windowActivated
 Se activó la ventana
o windowDeactivated
 Se desactivó la ventana
En esta explicación guiada nos limitaremos a estudiar los eventos de acción.
PROGRAMACIÓN DE 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.).
Sólo existe un tipo de evento de acción, llamado actionPerformed.
El evento actionPerformed pertenece a un objeto oyente llamado ActionListener.
Eventos de Acción:
Eventos Oyente/Adaptador
Se programan dentro ActionListener

actionPerformed de...
La forma de programar el evento actionPerformed de un componente yyy es la siguiente:
24
yyy.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
yyyActionPerformed(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:
El código anterior permite crear y asignar el evento actionPerformed al botónbtnSumar, pero

no programa el evento. Para programar el evento es necesario crear el procedimiento cuya
llamada se incluye dentro del evento actionPerformed:
public void btnSumarActionPerformed(ActionEvent evt) {

… aquí se programa el evento actionPerformed del botón btnSumar …
}
25
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
al método 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.
EJERCICIO:
1. Abra el proyecto Operaciones que se hizo en el ejercicio anterior.
2. En el ejercicio 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):
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 método constructor a un método creacionVentana donde diseñamos cada uno de
los elementos de la ventana:
/**
* Creates new form VentanaInicial
*/
public VentanaInicial() {
initComponents();
creacionVentana();
}
public void creacionVentana() {

this.setTitle("Programa Operaciones");
this.setSize(500, 300);
this.setLocation(100, 100);

26

txtNumero1 = new JTextField();

txtNumero1.setText("0");
txtNumero1.setBounds(110, 10, 100, 30);
this.getContentPane().add(txtNumero1);
txtNumero2 = new JTextField();

txtNumero2.setText("0");
txtNumero2.setBounds(110, 60, 100, 30);
this.getContentPane().add(txtNumero2);
btnSumar = new JButton();

btnSumar.setText("Sumar");
btnSumar.setBounds(10, 120, 100, 30);
this.getContentPane().add(btnSumar);
btnRestar = new JButton();

btnRestar.setText("Restar");
btnRestar.setBounds(150, 120, 100, 30);
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:
btnSumar.addActionListener(new ActionListener() {
btnSumarActionPerformed(evt);
}
});
(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.
27
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).
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:
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.
28
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.
btnRestar.addActionListener(new ActionListener() {
btnRestarActionPerformed(evt);
}
});
(Observa que es idéntico al código de asignación del evento del botónbtnSumar, sólo 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 num1, num2, resta;
num1 = Double.parseDouble(txtNumero1.getText());
num2 = Double.parseDouble(txtNumero2.getText());
resta = num1 - num2;
JOptionPane.showMessageDialog(null, "La resta es: " + resta);
}
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:
29
CONCLUSIONES:
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 YYY hay que usar el siguiente código:
YYY.addActionListener(new ActionListener() {
YYYActionPerformed(evt);
}
});
El enlace de un evento a un componente se hace en el método constructor. Esta asignación hace

una llamada a un procedimiento YYYActionPerformed, (donde YYY representa el nombre del
componente que se programa). Es en este procedimiento donde realmente se programa el evento.
30
024.- Creación de Eventos del Ratón Desde Código

EVENTOS DEL RATÓN DESDE CÓDIGO:
Se estudió en el post anterior la forma de programar eventos desde código. Concretamente se

estudió como programar eventos de acción. En esta hoja se estudiará como programar eventos
de ratón.
Los eventos de ratón son los siguientes:
- mouseEntered
 Indica que el puntero del ratón entró en la superficie del elemento (etiqueta, botón, etc)
- mouseExited
 Indica que el puntero del ratón salió de la superficie del elemento (etiqueta, botón, etc)
- mousePressed
 Indica que un botón del ratón ha sido presionado sobre el elemento.
- mouseReleased
 Indica que un botón del ratón ha sido soltado sobre el elemento.
- mouseClicked
 Indica que se ha pulsado y soltado un botón del ratón.
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 método, 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 YYY.

Si queremos asociarle eventos de ratón, tendremos que añadir el siguiente código dentro del
método constructor:
31
YYY.addMouseListener(new MouseAdapter() {
public void mouseEntered(MouseEvent evt) {

YYYMouseEntered(evt);
}
public void mouseExited(MouseEvent evt) {

YYYMouseExited(evt);
}
public void mousePressed(MouseEvent evt) {

YYYMousePressed(evt);
}
public void mouseReleased(MouseEvent evt) {

YYYMouseReleased(evt);
}
public void mouseClicked(MouseEvent evt) {

YYYMouseClicked(evt);
}
});
Veamos este mismo código comentado:
32
EJERCICIO:
2. Accede al código del proyecto.
3. Inserta una llamada dentro del método constructor a un

método creacionVentana de la siguiente forma:
4. La ventana va a contener dos etiquetas, que tendremos que declarar en la zona de

variables globales:
5. Ahora vamos a diseñar la ventana. Introduce el siguiente código dentro del

procedimiento creacionVentana:
6. Ejecuta ya el programa para observar el resultado de nuestro diseño. El aspecto

debe ser el siguiente:
33
7. El objetivo del programa es simple. Queremos que al entrar el puntero del ratón
dentro de la superficie de la etiqueta azul, aparezca un mensaje en la otra etiqueta
indicándolo. También queremos que aparezca un mensaje cuando sale el puntero del ratón
de la etiqueta. Y también al pulsar un botón del ratón sobre dicha 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 elmouseClicked.
Luego, el MouseAdapter se asignará a la etiqueta azul etiColor.
9. Primero programaremos el enlace del adaptador MouseAdapter con la

etiqueta etiColor. Programa al final del método creacionVentana lo siguiente:
10. Observa el código:
a. Se añade un MouseAdapter al objeto etiColor.
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
(subrayado con líneas rojas) ya que todavía no han sido programados.
34
11. Ahora se programará cada procedimiento que es llamado desde cada evento.
Recuerda que esto debe hacerse fuera del método creacionVentana. Aquí tienes lo que
debes programar:
12. Ahora ya puedes ejecutar el programa y comprobar lo que sucede cuando

interactúas con el ratón sobre la etiqueta de color azul.
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 método etiColorMousePressed y déjalo de la siguiente forma:
14. En el código anterior aprovechamos los métodos que tiene el objeto evt 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.
35
CONCLUSIONES:
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 YYY, hay que usar el siguiente código:
YYY.addMouseListener(new MouseAdapter() {

YYYMouseEvent(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 ocurrido (qué botón del ratón se pulsó, cuantas veces, etc.).
36
025.- Creación de Eventos en General Desde Código

EVENTOS DESDE CÓDIGO - CONSIDERACIONES GENERALES
Se finalizará el estudio de los eventos desde código, planteando de forma general el código
necesario para programarlos.
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 método y es en este método 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.
EJEMPLO 1 (EVENTOS DEL RATÓN):

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 etiMensaje, sólo tenemos que hacer lo siguiente:
37
etiMensaje.addMouseListener(new MouseAdapter() {
etiMensajeMouseEntered(evt);
}
public void mouseExited(MouseEvent evt) {

etiMensajeMouseExited(evt);
}
public void mousePressed(MouseEvent evt) {

etiMensajeMousePressed(evt);
}
public void mouseReleased(MouseEvent evt) {

etiMensajeMouseReleased(evt);
}
public void mouseClicked(MouseEvent evt) {

etiMensajeMouseClicked(evt);
}
});
EJEMPLO 2 (EVENTOS DEL TECLADO):
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);
}
});
38
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 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 YY el cual quiero usar desde código, ¿cómo puedo saber cuál 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 YY que se quiere estudiar a un componente. Luego simplemente hay que analizar el código
generado por el NetBeans.
CONCLUSIONES:
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.
39
026.- Vectores, Matrices o Arrays

El manejo de vectores en Java es similar al manejo de vectores en el lenguage de programación
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 tú 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:
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 = new 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 = new 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 desde 0.
40
Ejemplo N° 1:
etiMensaje.setText("El Valor es: " + v[6]);
Aquí se coloca en una etiqueta el valor contenido en la sétima posición del vector v.
Ejemplo N° 2:
for (int i = 0; i < 10; i++) {
v[i] = 100;
}
Este código recorre un vector de 10 elementos y almacena en dichos 10 elementos el número

100.
Longitud de un vector:
Una forma rápida de saber la longitud que tiene un vector es usar lo siguiente:
nombreVector.length
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 (int 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, …, elementoN};
Por ejemplo:
int v[] = {6, 3, 1, 2};
Este código crea un vector con cuatro números enteros: 6, 3, 1, 2.
Ejemplo 2:
String coloresArcoiris[] = {"Rojo", "Naranja", "Amarillo", "Verde", "Azul",
"Añil", "Violeta"};
Este código crea un vector que contiene 7 cadenas, correspondientes a los colores del arcoíris.
VECTORES DE COMPONENTES:
En Java, se pueden crear vectores de etiquetas, cuadros de texto, botones, 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.
41
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 vectorEtiquetas[]; //aquí se crea un vector de etiquetas llamado
vectorEtiquetas
vectorEtiquetas = new JLabel[6]; //aquí se construye el vector, asignando 6

etiquetas
//ahora trabajamos con las etiquetas del vector usando el bucle for
for (int i = 0; i < vectorEtiquetas.length; i++) {
vectorEtiquetas[i] = new JLabel(); //se construye cada etiqueta
vectorEtiquetas[i].setBounds(10, 10 + i * 30, 100, 20); //se asigna posición
y tamaño
vectorEtiquetas[i].setText("Etiqueta " + i); //se asigna un texto
this.getContentPane().add(vectorEtiquetas[i]);//se coloca en la ventana
}
Realiza el siguiente ejercicio para entender el ejemplo:
Ejercicio:
1. Crea un nuevo proyecto en java.
2. Empecemos definiendo desde código las características de la ventana. Crearemos el
método crearVentana, y lo llamaremos desde el método constructor del proyecto:
3. 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):
42
4. La construcción de los vectores de componentes, se realiza en el método constructor

(en nuestro caso en el método crearVentana, que es llamado desde el método constructor).
Construiremos el vector de forma que contenga 10 JCheckBox:
5. 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 bucle for que recorre los elementos del vector. (Añade el siguiente código dentro
del método crearVentana):
6. Analiza este código que se acaba de añadir:

a. Observa como cada elemento del vector debe ser construido:
vectorCuadros[i] = new JCheckBox();
b. El texto que tendrá cada elemento será: “Cuadro de Verificación: 0”,

“Cuadro de Verificación: 1”, “Cuadro de Verificación: 2”, etc…
vectorCuadros[i].setText("Cuadro de Verificació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:
vectorCuadros[i].setBounds(10, 10 + 30 * i, 300, 20);
d. Luego agrego cada cuadro de verificación en el panel de contenidos de la

ventana.
this.getContentPane().add(vectorCuadros[i]);
7. Ejecuta el programa y observa el resultado:
43
8. 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í:
9. 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 ejecutas el programa, verás que cada cuadro tiene su texto correspondiente a
un color.
44
10. 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 crearVentana, añade el siguiente código:
11. 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 crearVentana, programa el siguiente procedimiento:
12. En este código se puede observar como se usa un bucle for para recorrer fácilmente
el vector de cuadros y averiguar cuáles de ellos están seleccionados. 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
seleccionados sería mucho más engorroso. Piénsalo.
13. Ejecuta el programa. Selecciona varios cuadros y pulsa el botón Aceptar. Observa
el resultado:
45
CONCLUSIONES:
En Java, los vectores deben declararse y luego construirse. Es en la construcción del vector cuando
se le asigna a este el número de elementos.
Los vectores en Java pueden ser usados de la misma forma que en el lenguaje de programación
C.
En Java se pueden crear vectores de componentes: etiquetas, cuadros de texto, botones, etc.
facilitando luego el trabajo con todos estos elementos en conjunto y facilitando las labores de
diseño.
46
027.- Vectores de Componentes y Eventos Desde Código

Asignación de eventos a los elementos de un vector de componentes:
En Java se pueden crear vectores de componentes, como ya se vio en el post anterior. Estos
vectores pueden contener un grupo de etiquetas, cuadros de texto, botones, 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 hoja se verá cómo se pueden asignar eventos a los componentes de un vector.
Ejercicio:
1. Crea un proyecto en java.
2. Empecemos definiendo desde código las características de la ventana. Crearemos el

método crearVentana, y lo llamaremos desde el método constructor de la clase:
3. 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 (propiedades de la clase):
4. Dentro del método crearVentana 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 dentro del método crearVentana:
47
5. En el código anterior se crea un vector de cadenas (String) con el texto de cada

botón.
Luego se construye el vector de botones, asignándole 5 botones.

A continuación, usando un bucle 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.
6. Ejecuta el programa para observar su aspecto hasta ahora:
7. 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 del método crearVentana:
Este código asigna a cada botón un evento actionPerformed que hace una llamada a un método
al que he llamado botonActionPerformed. (Esta llamada da error porque aún no ha sido
programado dicho evento. Esto se hará a continuación.)
Hay que tener en cuenta que cuando se pulse cualquiera de los botones, se ejecutará el
método botonActionPerformed. Programa este procedimiento (fuera de crearVentana, por
supuesto) de la siguiente forma:
8. 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.”.
El método botonActionPerformed 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ámetroae (ActionEvent) que suelen llevar todos los eventos.
9. Modifica el método botonActionPerformed de forma que quede así:
48
Este código resulta muy interesante. El parámetro ae 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.
10. Ejecuta el programa y observa el resultado, por ejemplo al pulsar el botón Aplicar
se muestra lo siguiente:
CONCLUSIONES:
Se pueden asignar eventos a los elementos de un vector a través de un bucle for que recorra los
distintos elementos del vector y le asigne el evento o eventos necesarios.
Cuando se asigna un mismo método de respuesta a eventos de varios componentes, es necesario
usar el parámetro ae (ActionEvent) 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 var = (TipoComponente) ae.getSource();
La variable var contendrá el componente activado.
49
028.- Introducción a la Programación Orientada a Objetos

Introducción a la Programación Orientada a Objetos – POO:
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.
OBJETO:
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:
Ejemplo N° 1:
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.
A una etiqueta le podemos dar órdenes, a través de sus 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(20,20,100,30);
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 dé 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 no se muestre en la ventana usando el método setVisible:
50
etiTexto.setVisible(false);
Ejemplo N° 2:
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 textotxtCuadro 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 txtCuadrousando el método
llamado setBackground:
txtCuadro.setBackground(Color.BLUE);
Otros métodos que permiten cambiar las propiedades del objeto cuadro de textoson:
setVisible - permite poner visible o invisible el cuadro de texto

setEnabled - permite activar o desactivar el cuadro de texto
setEditable - permite hacer que se pueda escribir o no en el cuadro de texto
setText - permite modificar el texto del 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();
Otros métodos que devuelven información del cuadro de texto son:
getWidth - devuelve el ancho que tiene el cuadro de texto

getHeight - devuelve el alto que tiene el cuadro de texto
getSelectedText - devuelve el texto que está seleccionado dentro del cuadro de texto
getToolTipText - devuelve el texto de ayuda que tiene asociado el cuadro de texto
etc…
51
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 tenga seleccionado
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…
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.
Declaración de 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 N° 1, se usará el siguiente código:
JLabel etiTexto;
Para declarar, en cambio, el cuadro de texto del ejemplo N° 2, se usará el siguiente código:
JTextField txtCuadro;
Construcción de 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:
52
nombreObjeto = new Clase();
Por ejemplo, para construir la etiqueta del ejemplo N° 1, se hará lo siguiente:
etiTexto = new JLabel();
Para construir el cuadro de texto del ejemplo N° 2, se hará 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 hará 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 etiMensaje = new JLabel();
En el ejemplo se han declarado y construido tres etiquetas

llamadas etiTexto,etiResultado y etiMensaje. Las tres etiquetas al momento de ser creadas 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);
etiResultado.setText(“Error”);
etiMensaje.setBackground(Color.BLUE);
etiMensaje.setText(“Cadena”);
53
En el ejemplo se le ha dado, usando el método setBackground un color distinto a cada etiqueta,

además se ha cambiado el texto de cada una. De este modo se le da forma a cada etiqueta.
Hasta ahora has usado objetos aunque no tengas mucha conciencia de ello. Por ejemplo ha usado
etiquetas, cuadros de texto, botones, botones de opción y demás en los temas anteriores. Como
práctica y para ampliar tus conocimientos investiga y responde las siguientes interrogantes:
- ¿Cuál es el nombre de la clase de los botones normales que usa en sus ventanas?
- ¿Cómo declararías un botón llamado btnAceptar, y otro llamado btnCancelar?
- ¿Cómo construirías dichos botones?
- Indica algunos métodos para cambiar propiedades de dichos botones (métodos set)
- Indica algunos métodos para pedirle información a dichos botones (métodosget)
- Indica algún método para dar órdenes a dichos botones (algún método que no sea ni set ni get)
CONCLUSIONES:
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();
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 según necesidad y
criterio del desarrollador.
54
029.- POO - Clases Propias

OBJETOS PROPIOS DEL LENGUAJE JAVA:
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..
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 dé 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 grabFocus, etc.
Todos estos objetos, con sus propiedades y métodos, nos facilitan el desarrollo 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 necesario la creación de objetos propios, programados por nosotros
mismos, de forma que puedan ser usados en nuestros futuros programas.
OBJETOS PROPIOS:
A la hora de diseñar un objeto de creación propia, tendremos que pensar qué propiedades debe tener dicho
objeto, y qué métodos serán necesarios para poder 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 propone un caso práctico de creación de objetos propios, con el que trabajaremos en las
próximas entradas.
Lo que viene a continuación es un planteamiento teórico de diseño de una Clase de Objetos.
55
CASO PRÁCTICO: CINES “AMANUVA”:
Planteamiento:
La empresa Cines “AMANUVA” nos encarga desarrollar un programa para facilitar las distintas gestiones
que se realizan en dichos cines.
Cines “AMANUVA” 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 Cines “AMANUVA” tienen una sala central donde se proyectan normalmente las películas de estreno.
Se podría crear un objeto llamado salaCentral de la clase SalaCine de la siguiente forma:
SalaCine salaCentral;
Por supuesto, este objeto puede ser construido como cualquier otro:
salaCentral = new SalaCine();
El objeto salaCentral representará a la sala de cine central de los Cines “AMANUVA”.
Los Cines “AMANUVA” tienen otra sala secundaria donde proyectan películas clásicas. Se podría crear un
objeto llamado salaSecundaria de la clase SalaCine de la siguiente forma:
SalaCine salaSecundaria; //declaración
salaSecundaria = 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?
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).

- butacasOcupadas: define el número de butacas ocupadas (un número entero).
- tituloPelicula: define el título de la película que se está proyectando en determinado momento en la sala
(una cadena de texto).
- precioEntrada: define el precio de la entrada a sala de cine (un número double).
Valores por defecto de las propiedades de los objetos de la clase 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.
56
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 de la clase SalaCine en el momento de construirse serán
las siguientes:
aforo: 100
butacasOcupadas: 0
tituloPelicula: “” (cadena vacía)
precioEntrada: 5.00
Observa este código, en él construimos el objeto correspondiente a la sala central de Cines “AMANUVA”:
SalaCine salaCentral;
salaCentral = new SalaCine();
En este momento (en el que el objeto salaCentral está recién construido) este objeto tiene asignado un
aforo de 100, el número de butacas ocupadas es 0, el título de la película que se proyecta en la sala central
es “” y el precio de la entrada para esta sala es de 5.00 euros.
Los valores por defecto que se asignan a los objetos de una clase son valores arbitrarios que el
programador decidirá según su necesidad.
Métodos de los objetos de la clase 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:
Métodos de cambio de propiedades (Métodos set):
setAforo - asignará un aforo a la sala de cine

setButacasOcupadas - asignará una cantidad de butacas ocupadas a la sala de cine
setButacasLibres - asignará una cantidad de butacas libres a la sala de cine
setTituloPelicula - asignará un título de película a la sala de cine
setPrecioEntrada - fijará el precio de las entradas a la sala de cine
Gracias a estos métodos podemos dar forma a un objeto de la clase SalaCine recién creado.
Por ejemplo, supongamos que queremos crear el objeto que representa la sala secundaria de películas
clásicas. Resulta que esta sala tiene un aforo de 50 localidades, que se está proyectando la película “El
Club de la Pelea” y que la entrada para ver la película es de 3.0 euros. La sala está vacía de momento.
Para crear el objeto, se usaría el siguiente código:
//Se construye el objeto

SalaCine salaSecundaria;
salaSecundaria = new SalaCine();
//Se le asignan características
57
salaSecundaria.setAforo(50); //aforo 50
salaSecundaria.setPelicula(“El Club de la Pelea”); //la película que se proyecta
salaSecundaria.setEntrada(3.0); //entrada a 3.0 euros
Al construir el objeto salaSecundaria tiene por defecto los valores siguientes en sus propiedades:
aforo: 100
butacasOcupadas: 0
tituloPelicula: “”
precioEntrada: 5.00
Gracias a los métodos disponibles hemos asignados estos nuevos valores:

aforo: 50
butacasOcupadas: 0
tituloPelicula: “El Club de la Pelea”
precioEntrada: 3.0
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

getButacasOcupadas - devuelve el número de butacas ocupadas que tiene el objeto
getButacasLibres - devuelve el número de butacas que tiene libres el objeto
getPorcentajeOcupacion - devolverá el porcentaje de ocupación de la sala
getIngresosSala - devolverá los ingresos producidos por la sala (‘entradas vendidas’ multiplicadas
el precio)
getTituloPelicula - devolverá el título de la película que se está proyectando
getPrecioEntrada - devolverá el precio de la entrada asignado al objeto
Estos métodos nos permitirán obtener información de un objeto del tipo SalaCine. Por ejemplo,
supongamos que tenemos el objeto llamado salaCentral (correspondiente a la sala principal de Cines
“AMANUVA”), para obtener el título de la película que se está proyectando en dicha sala solo habría que
usar este código:
String tituloPelicula; //una variable de cadena

tituloPelicula = salaCentral.getTituloPelicula();
Para saber los ingresos producidos por la sala central se usará este código:
double ingresos;
ingresos = salaCentral. getIngresosSala ();
Métodos para dar órdenes al objeto:

Se programarán los siguientes métodos para dar órdenes a los objetos de la clase SalaCine.
vaciarSala
- Este método pondrá el número de plazas ocupadas a cero y le asignará a la película la cadena vacía.
entraUno
58
- 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 entrada de este
blog:
Clase de objetos: SalaCine
Propiedades de los objetos SalaCine:

aforo - número entero (int)
butacasOcupadas - número entero (int)
tituloPelicula - cadena (String)
precioEntrada - número decimal (double)
Valores por defecto de los objetos del tipo SalaCine:

aforo: 100
butacasOcupadas: 0
tituloPelicula: (cadena vacía)
precioEntrada: 5
Métodos de los objetos del tipo SalaCine:
Métodos de asignación de propiedades (set)
setAforo - modifica la propiedad Aforo

setButacasOcupadas - modifica la propiedad butacasOcupadas
setButacasLibres - modifica la propiedad butacasOcupadas también
setTituloPelicula - modifica la propiedad tituloPelicula
setPrecioEntrada - modifica la propiedad precioEntrada
Métodos de petición de información (get)
getAforo - devuelve el valor de la propiedad aforo

getButacasOcupadas - devuelve el valor de la propiedad butacasOcupadas
getButacasLibres - devuelve el número de butacas libres
getPorcentajeOcupacion - devuelve el porcentaje de ocupación de la sala
getIngresosSala - devuelve los ingresos obtenidos por la venta de entradas
getTituloPelicula - devuelve el valor de la propiedad tituloPelicula
getPrecioEntrada - devuelve el valor de la propiedad precioEntrada
Métodos de orden
vaciarSala - vacía la ocupación de la sala y borra el título de la película

entraUno - le indica al objeto que ha entrado una persona más en la sala
59
EJERCICIO PRÁCTICO
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 suelouna
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?
CONCLUSIONES:
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.
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 orden
Una vez que se tenga claro lo anterior, se podrá empezar la programación de la Clase de objetos.
60
030.- POO - Programación De Una Clase - Java y NetBeans

Programación de una Clase
En este ejercicio guiado, crearemos la Clase SalaCine, que hemos descrito en la entrada 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 el post anterior:
Clase SalaCine
Nombre de la Clase: SalaCine
Propiedades de los objetos SalaCine:
aforo - número entero (int)
butacasOcupadas - número entero (int)
tituloPelicula - cadena (String)
precioEntrada - número decimal (double)
Valores por defecto de los objetos del tipo SalaCine:

aforo: 100
butacasOcupadas: 0
tituloPelicula: (cadena vacía)
precioEntrada: 5.0
Métodos de los objetos del tipo SalaCine:
Métodos de asignación de propiedades (set)

setAforo - modifica la propiedad Aforo
setButacasOcupadas - modifica la propiedad butacasOcupadas
setButacasLibres - modifica la propiedad butacasOcupadas también
setTituloPelicula - modifica la propiedad tituloPelicula
setPrecioEntrada - modifica la propiedad precioEntrada

getAforo - devuelve el valor de la propiedad aforo
getButacasOcupadas - devuelve el valor de la propiedad butacasOcupadas
getButacasLibres - devuelve el número de butacas libres
getPorcentajeOcupacion - devuelve el porcentaje de ocupación de la sala
getIngresosSala - devuelve los ingresos obtenidos por la venta de entradas
getTituloPelicula - devuelve el valor de la propiedad tituloPelicula
getPrecioEntrada - devuelve el valor de la propiedad precioEntrada
Métodos de orden
vaciarSala - vacía la ocupación de la sala y borra el título de la película
entraUno - le indica al objeto que ha entrado una persona más en la sala
61
PROGRAMACIÓN DE UNA CLASE
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 {
La programación de una clase comienza siempre con una línea de código como la que sigue:
public class NombreDeLaClase {
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 de ésta. Si introducimos las propiedades de la
clase SalaCine, esta nos quedaría así:

int aforo;
int butacasOcupadas;
String tituloPelicula;
double precioEntrada;
}
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 método constructor.
El método 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
método constructor se inicializan las propiedades de la clase.
En general, la programación del método constructor sigue la siguiente sintaxis:
62
public NombreDeLaClase() {
propiedad1 = valor1;
propiedad2 = valor2;
etc…
}
La clase SalaCine, añadiendo el método constructor, tendrá el siguiente aspecto:

int aforo;
//Método Constructor:
public SalaCine() {
aforo = 100;
butacasOcupadas = 0;
tituloPelicula = “”;
precioEntrada = 5.0;
}
}
Observa como usamos el método 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 entrada anterior.
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.
63
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 setButacasOcupadas
public void setButacasOcupadas (int ocu) {
butacasOcupadas = ocu;
}
//Método setTituloPelicula
public void setTituloPelicula (String peli) {
tituloPelicula = peli;
}
//Método setPrecioEntrada
public void setPrecioEntrada (double entra) {
precioEntrada = entra;
}
Hay un método set de la clase SalaCine llamado setButacasLibres cuya misión es asignar el número de
localidades libres del cine. Sin embargo la clase SalaCine no tiene una propiedad “butacasLibres”. En
realidad, este método debe modificar el número de localidades ocupadas. Observa su programación:
//Método setButacasLibres
public void setButacasLibres(int lib) {
int ocu;
ocu = aforo – lib;
}
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 butacasOcupadas.
No se pensó en crear una propiedad de la clase llamada butacasLibres 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;
//Método Constructor
public SalaCine() {
aforo = 100;
}
64
//Métodos set
//Método setAforo
aforo = afo;
}
public void setButacasOcupadas(int ocu) {
}
}
public void setPrecioEntrada (double entra) {
}
int 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 de 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 getButacasOcupadas
public int getButacasOcupadas() {
return butacasOcupadas;
}
65
//Método getTituloPelicula
public String getTituloPelicula () {
return tituloPelicula;
}
//Método getPrecioEntrada
public double getPrecioEntrada() {
return precioEntrada;
}
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 getButacasLibres
public int getButacasLibres() {
int lib;
lib = aforo – butacasOcupadas;
return lib;
}
No existe una propiedad butacasLibres, 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 getPorcentajeOcupacion
public double getPorcentajeOcupacion() {
double porc;
porc = (double) butacasOcupadas *100.0 / (double) aforo;
return porc;
}
Este método calcula el porcentaje de ocupación de la sala (es un valor double)
//Método getIngresosSala
public double getIngresosSala() {
double ingre;
ingre = butacasOcupadas * precioEntrada;
return ingre;
}
Los ingresos se calculan multiplicando el número de butacas ocupadas por lo que vale una entrada.
Una vez introducidos los métodos get la clase SalaCine quedaría de la siguiente forma:

int aforo;
66
public SalaCine() {
aforo = 100;
}
//Métodos set
//Método setAforo
aforo = afo;
}
}
}
public void setPrecioEntrada(double entra) {
}
int ocu;
}
//Métodos get
//Método getAforo
return aforo;
}
}
67
public String getTituloPelicula() {
}
public double getPrecioEntrada() {
}
public int getButacasLibres() {
int lib;
return lib;
}
double porc;
porc = (double) butacasOcupadas * 100.0 / (double) aforo;
return porc;
}
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 vaciarSala, cuyo objetivo es vaciar la sala y quitar la película en
proyección:
//Método vaciarSala
public void vaciarSala() {
}
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:
68
//Método entraUno
public void entraUno() {
butacasOcupadas++;
}
Añadiendo estos dos últimos métodos, la programación de la clase SalaCine quedaría finalmente como
sigue:

int aforo;
public SalaCine() {
aforo = 100;
}
//Métodos set
//Método setAforo
aforo = afo;
}
}
public void setTituloPelicula(String peli) {
}
public void setPrecioEntrada(double entra) {
}
int ocu;
}
69
//Métodos get
//Método getAforo
return aforo;
}
}
public String getTituloPelicula() {
}
public double getPrecioEntrada () {
}
public int getButacasLibres () {
int lib;
return lib;
}
double porc;
porc = (double) butacasOcupadas * 100.0 / (double) aforo;
return porc;
}
double ingre;
return ingre;
}
//Métodos de orden
//Método vaciarSala
public void vaciarSala() {
}
70
//Método entraUno
public void entraUno() {
butacasOcupadas++;
}
}
EJERCICIOS RECOMENDADOS
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.
SE PIDE:
Realiza (en papel) la programación de la clase Rectangulo a partir del planteamiento anterior.
CONCLUSIÓN
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)
71
Método Constructor
Métodos set
Métodos get
Métodos de orden y otros métodos
}
El Método Constructor no devuelve nada pero que no es void. Este método 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.
72

Práctica Prog Distri Modo Gráfico Parte03 PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Práctica Prog Distri Modo Gráfico Parte03 PDF

Încărcat de

Drepturi de autor:

Formate disponibile

IESTP “Ayaviri” Computación e Informática IV - Semestre

021.- Cuadros de Diálogo

1. Crea un nuevo proyecto en NetBeans.

Los elementos de la ventana tendrán los siguientes nombres:

8. Vamos a programar el botón btnCalcular. Entra en su evento actionPerformed y

//Almacenamos los valores de los cuadros de texto convirtiéndolos

//Calculamos el total sin igv, el importe del igv y el importe del

//Calculamos el importe total.

//Mostramos el total en la etiqueta.

9. Puedes ejecutar el programa y comprobar que el botón Calcular funciona, aunque

10. Seguidamente programaremos el botón Configuración de forma que nos permita

DIÁLOGO que permita al usuario configurar estos datos.

13. Cámbiale el nombre. Lo llamaremos dialogoConfiguracion.

Los elementos del cuadro de diálogo tienen los siguientes nombres:

17. Se pretende que cuando se pulse el botón Configuración en la ventana principal,

18. Para conseguir esto, debes programar en el evento actionPerformed del

19. El código anterior hace lo siguiente:

la posición (100, 100) de la pantalla.

22. El botón Cancelar de un cuadro de diálogo simplemente cierra dicho cuadro de

23. Ejecuta el programa de nuevo y comprueba el funcionamiento del

traspasarán los valores introducidos en los cuadros de

25. Este es el código que hace lo anterior. Debe programarlo en el

27. Compruebe el funcionamiento del programa de la siguiente forma:

b. Introduzca 5 unidades y 20 de precio.

d. Ahora pulse el botón Configuración, e introduzca un igv del 18. El

f. Pruebe a configurar un descuento y vuelva a calcular.

28. Se pretende ahora mejorar un poco el cuadro de diálogo, añadiéndole un título.

30. Ahora se estudiará el concepto de cuadro de diálogo modal y cuadro de diálogo no

 Un cuadro de diálogo no modal. Es aquel que permite activar la ventana desde la

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

d. Esto es posible gracias a que el cuadro de diálogo es no modal.

f. Ahora ejecuta el programa de nuevo y haz que se visualice el cuadro de

g. Es muy común, cuando tenemos un cuadro de diálogo no modal, usar la

32. Ahora se estudiará el concepto de cuadro de diálogo modal.

34. Ahora ejecuta el programa y comprueba lo siguiente:

a. Haz que se visualice el cuadro de diálogo de configuración.

c. Solo cuando pulses Aceptar o Cancelar, o cierres el cuadro de diálogo, podrás

seguir trabajando con tu ventana.

022.- Diseño de Formularios Desde Código

1. Crea un nuevo proyecto en NetBeans.

2. Dentro de paqueteInicial crea un JFrame Form y llamalo FormDeCodigo.

3. Añade en la FormDeCodigo una etiqueta (JLabel), un cuadro de texto (JTextField)

5. El nombre de la etiqueta será “etiEtiqueta”, del cuadro de texto “txtCuadroTexto”

6. A continuación asigna un texto a cada elemento. La ventana debe tener un aspecto

9. El código generado no puede ser modificado, sin embargo es interesante estudiarlo

A. CREACIÓN DEL PROYECTO:

1. Crear un nuevo proyecto con las siguientes características:

a. El nombre del proyecto será ProyectoOperaciones.

b. El nombre del paquete será paqueteVentanas.

c. El nombre del formulario será VentanaInicial.

El aspecto que tendrá la ventana de proyectos debe ser el siguiente:

2. Una vez creado el proyecto, iremos directamente a la ventana de código, pulsando

B. ESTRUCTURA DEL CÓDIGO (estructura de una clase):

3. Analizaremos el código del programa ahora. Empezaremos por arriba:

4. Un proyecto en java está formado por módulos denominados CLASES. El proyecto

5. Para programar una clase se sigue la siguiente sintaxis:

6. Esto lo puedes observar claramente en el código de tu proyecto:

7. Dentro de la clase, tenemos una serie de funciones y procedimientos llamados

8. Hay un método especial muy importante denominado CONSTRUCTOR. Dentro de

Observarás que el método constructor contiene una llamada a un método