Beruflich Dokumente
Kultur Dokumente
if (chkGato.isSelected()) {
mensaje=mensaje+"Gato ";
}
if (chkRaton.isSelected()) {
mensaje=mensaje+"Raton ";
}
etiResultado.setText(mensaje);
10. Ejecute el programa. Seleccione por ejemplo las casillas Gato y Ratón.
Al pulsar Aceptar el resultado debe ser el siguiente:
CONCLUSIÓN
12. Acabas de asociar los tres botones de opción a un mismo grupo. Esto produce
que solo una de las tres opciones pueda estar activada. Pruébelo ejecutando el
programa.
13. Ahora interesa que la opción “Rojo” salga activada desde el principio. Una
forma de hacer esto es programando en el “Constructor” lo siguiente:
optRojo.setSelected(true);
14. El programa no está terminado aún. Interesa que cuando el usuario pulse el
botón Aceptar, en la etiqueta aparezca el color elegido. Para ello, en el
actionPerformed del botón Aceptar programe lo siguiente:
if (optRojo.isSelected()) {
mensaje=mensaje+"Rojo";
} else if (optVerde.isSelected()) {
mensaje=mensaje+"Verde";
} else if (optAzul.isSelected()) {
mensaje=mensaje+"Azul";
}
etiResultado.setText(mensaje);
15. Observa el código. En él se hace lo siguiente:
CONCLUSIÓN
Es totalmente necesario añadir un objeto del tipo ButtonGroup, y hacer que los
botones de radio pertenezcan a dicho grupo. En caso contrario, será posible
activar varios botones de opción a la vez.
EJERCICIO GUIADO. JAVA: CUADROS DE LISTA
4. Cámbiale el nombre al JList. Ten cuidado, ya que en los JList aparecen siempre
dentro de otro objeto llamado jScrollPane. Si miras en el Inspector, verás que al
pulsar en el botón + del jScrollPane aparecerá tu JList:
5. Aprovecha para cambiarle el nombre al JList. El nuevo nombre será lstColores.
6. Si te fijas en el JList, consiste en un cuadro que contiene una serie de Items. Estos
elementos pueden ser cambiados a través de la propiedad Model del JList.
7. Busca la propiedad Model y haz clic en el botón de los tres puntos. Aparecerá un
cuadro de diálogo parecido al siguiente. Solo tienes que seleccionar los elementos
que quieras y pulsar el botón “Borrar” (Remove) para eliminarlos de la lista.
Rojo
Verde
Azul
String mensaje;
13. Vamos a mejorar el programa. Puede suceder que el usuario no seleccione ningún
valor del cuadro de lista, y sería interesante en este caso que el programa avisara de
ello. Cambie el código del botón Aceptar por este otro código:
String mensaje;
if (lstColores.getSelectedIndex()==-1) {
mensaje="No hay un color seleccionado.";
} else {
mensaje="El color seleccionado es: "+lstColores.getSelectedValue().toString();
}
etiResultado.setText(mensaje);
15. Si ejecuta el programa y pulsa el botón Aceptar sin seleccionar nada el resultado
debería ser el siguiente:
16. Se podría haber prescindido del botón aceptar si el código anterior se hubiera puesto
en el evento mouseClicked del cuadro de lista en vez de en el actionPerformed del
botón Aceptar. En este caso, cada vez que se seleccionara un elemento de la lista,
automáticamente aparecería el mensaje en la etiqueta.
CONCLUSIÓN
El objeto JList permite crear cuadros de lista. Estos objetos contienen una serie de
elementos que pueden ser seleccionados.
3. Añade un cuadro combinado (combo). Los cuadros combinados son objetos del tipo
JComboBox. Básicamente, un combo es una lista desplegable.
Rojo
Verde
Azul
Para ello, debes programar el evento actionPerformed del combo y añadir el siguiente
código:
mensaje=mensaje+cboColores.getSelectedItem().toString();
etiResultado.setText(mensaje);
11. Los cuadros combinados pueden funcionar también como cuadros de texto. Es decir,
pueden permitir que se escriba texto dentro de ellos. Para hacer esto, basta con
cambiar su propiedad “editable” y activarla.
12. Ejecuta el programa y observa como se puede escribir dentro del combo. Al pulsar
Enter, el programa funciona igualmente con el texto escrito.
Se escribe aquí y
se pulsa enter
CONCLUSIÓN
Los combos son listas desplegables donde se puede elegir una de las opciones
propuestas.
Los combos pueden funcionar también como cuadros de textos, si se activa la opción
editable.
5. Añade dos botones al formulario. Uno de ellos tendrá el texto “Curso 1” y se llamará
btnCurso1 y el otro tendrá el texto “Curso 2” y se llamará btnCurso2.
6. En el evento actionPerformed del botón “Curso 1” programa lo siguiente:
a. Lo que hace cada botón es rellenar el cuadro de lista con una serie de
nombres. En el caso del botón “Curso 1”, la lista se rellena con los nombres
Juan, María y Luis, mientras que en el caso del botón “Curso 2”, la lista se
rellena con los nombres Ana, Marta y Jose.
modelo.addElement("Ana");
modelo.addElement("Marta");
modelo.addElement("Jose");
lstNombres.setModel(modelo);
h. Así pues, aquí tienes una forma de cambiar el contenido de un cuadro de lista
desde el propio programa.
9. Prueba a ejecutar el programa. Observa como cuando pulsas cada botón cambia el
contenido de la lista:
Click y cambia el
listado.
10. Ahora añade el siguiente código al evento mouseClicked del cuadro de lista:
etiResultado.setText(lstNombres.getSelectedValue().toString());
Esta instrucción hace que al seleccionar un elemento del cuadro de lista éste
aparezca en la etiqueta etiResultado. Recuerda que el método getSelectedValue
permite recoger el elemento seleccionado (hay que convertirlo a cadena con toString)
11. Ejecuta el programa:
Click y aparece
el elemento
seleccionado en
la etiqueta.
12. Una propuesta. Añada un botón “Vaciar” llamado btnVaciar. Este botón vaciará el
contenido de la lista. Para esto lo único que tiene que hacer es crear un modelo y, sin
introducir ningún valor en él, asociarlo al cuadro de lista.
CONCLUSIÓN
Se puede crear un “modelo” y luego introducir datos en él. Luego se puede asociar
ese “modelo” a la lista. De esta manera se puede cambiar el contenido de la lista en
cualquier momento.
EJERCICIO GUIADO. JAVA: MODELOS DE CUADRO DE LISTA
3. Elimina todos los elementos que contenga el combo. Recuerda, debes usar la
propiedad “model” del combo para cambiar sus elementos.
4. Después de haber hecho todo esto, tu ventana debe quedar más o menos así:
int i;
for (i=0;i<10;i+=2) {
modelo.addElement("Nº "+i);
}
cboNumeros.setModel(modelo);
Al igual que pasa con los cuadros de lista, los combos tienen un objeto
“modelo” que es el que realmente contiene los datos. En el caso de los
combos, para crear un objeto “modelo” se usará esta instrucción:
cboNumeros.setModel(modelo);
Se pulsa y se rellena
automáticamente
int i;
DefaultComboBoxModel modelo = new DefaultComboBoxModel();
for (i=1;i<10;i+=2) {
modelo.addElement("Nº "+i);
}
cboNumeros.setModel(modelo);
9. La única diferencia de este código es el for, que está diseñado para que se
introduzcan los números impares comprendidos entre 0 y 10 dentro del modelo.
11. Prueba el programa. Prueba los botones Pares e Impares y prueba el combo.
12. Sería interesante añadir un botón “Vaciar” llamado btnVaciar que vaciara el contenido
del combo. Esto se haría simplemente creando un modelo vacío y asignarlo al
combo. Se anima al alumno a que realice esta mejora.
CONCLUSIÓN
Un combo, al igual que los cuadros de lista, es un objeto que contiene a su vez otro
objeto denominado “modelo”.
Se puede crear un “modelo” y luego introducir datos en él. Luego se puede asociar
ese “modelo” al combo. De esta manera se puede cambiar el contenido del combo en
cualquier momento.
EJERCICIO GUIADO. JAVA: TOGGLEBUTTONS
f. Añade finalmente tres etiquetas conteniendo los números 40, 200, 200. La
primera se llamará etiPrecioInstalacion, la segunda etiPrecioFormacion y la
tercera etiPrecioAlimentacionBD.
El precio de los Extras dependerá de las opciones elegidas por el usuario. Por
ejemplo, si el usuario quiere Instalación y Formación, los extras costarán 240
euros.
precio_base = Double.parseDouble(txtPrecioBase.getText());
precio_instal = Double.parseDouble(etiPrecioInstalacion.getText());
precio_for = Double.parseDouble(etiPrecioFormacion.getText());
precio_ali = Double.parseDouble(etiPrecioAlimentacionBD.getText());
double precio_total;
precio_total = precio_base;
precio_base = Double.parseDouble(txtPrecioBase.getText());
precio_instal = Double.parseDouble(etiPrecioInstalacion.getText());
precio_for = Double.parseDouble(etiPrecioFormacion.getText());
precio_ali = Double.parseDouble(etiPrecioAlimentacionBD.getText());
c. Una vez obtenidos los datos en forma numérica, ya se pueden hacer cálculos
con ellos. El programa declara una nueva variable precio_total donde se
introducirá el resultado. En primer lugar se introduce en esta variable el precio
base.
double precio_total;
precio_total = precio_base;
d. A continuación se le suma al precio_total los precios de los extras si el botón
correspondiente está seleccionado. Esto se hace a través de if. Por ejemplo,
para sumar el extra por instalación:
Esto significa: “Si el botón instalación está seleccionado, añade al precio total
el precio por instalación”
tbtnInstalacion.setSelected(true);
Realmente, estos botones no suelen ser muy usados, ya que pueden ser sustituidos
por Cuadros de Verificación (JCheckBox) que son más conocidos.
EJERCICIO GUIADO. JAVA: SLIDERS
Estos elementos tienen un pequeño recuadro que se puede arrastrar a derecha o izquierda.
Según la posición del recuadro, el JSlider tendrá un valor concreto.
El JSlider se puede configurar para que muestre los distintos valores que puede tomar:
También se puede configurar de forma que los valores mínimo y máximo sean distintos:
El valor que tiene un JSlider es el valor al que apunta el recuadro del JSlider. En la imagen
anterior, el JSlider tiene un valor de 85.
Ejercicio guiado
5. Un JSlider tiene un valor mínimo y un valor máximo. El valor mínimo es el valor que
tiene cuando el recuadro está pegado a la parte izquierda, mientras que el valor
máximo es el valor que tiene cuando el recuadro está pegado a la parte derecha.
El valor mínimo y máximo del JSlider se puede cambiar. Busca las propiedades
maximum y minimum del JSlider y asigna los siguientes valores:
Máximo: 500
Mínimo: 100
8. Esto, en realidad, no produce ningún cambio en el JSlider. Para que las divisiones se
vean, es necesario que active también la propiedad paintTicks. Esta propiedad
pintará divisiones en el JSlider:
Medidas cada 50
unidades
9. Aún se puede mejorar la presentación del JSlider, si hacemos que aparezca el valor
de cada división. Para ello debes activar la propiedad paintLabel.
10. Ejecuta el programa para ver el funcionamiento del Deslizador y su aspecto. Debe
ser parecido al siguiente:
11. Bien. Ahora se pretende que cuando el usuario arrastre el deslizador, en la etiqueta
aparezca el valor correspondiente. Para ello tendrá que programar el evento
stateChanged del JSlider.
Movemos aquí.
Y aparece el valor
correspondiente aquí.
orientation
Permite cambiar la orientación del JSlider. Podrías por ejemplo hacer que el JSlider
estuviera en vertical.
minorTickSpacing
Permite asignar subdivisiones a las divisiones ya asignadas. Prueba por ejemplo a
asignar un 10 a esta propiedad y ejecuta el programa. Observa las divisiones del
JSlider.
snapToTicks
Cuando esta propiedad está activada, no podrás colocar el deslizador entre dos
divisiones. Es decir, el deslizador siempre estará situado sobre una de las divisiones.
Prueba a activarla.
paintTrack
Esta propiedad permite pintar o no la línea sobre la que se desliza el JSlider. Prueba
a desactivarla.
CONCLUSIÓN
Son elementos muy comunes en los programas. A través de los dos botones triangulares se
puede hacer que el valor del cuadro aumente o disminuya. También se puede escribir
directamente un valor dentro del cuadro.
Ejercicio guiado
5. Interesa que cuando cambie el JSpinner (ya sea porque se pulsaron los botones
triangulares o porque se escribió dentro) aparezca el valor correspondiente dentro de
la etiqueta. Para ello, tendrá que programar el evento stateChanged del JSpinner.
Debes tener en cuenta que el valor devuelto no es un número ni una cadena, así que
en el ejemplo se ha usado el método toString() para convertirlo a una cadena.
El usuario modifica el
valor del JSpinner...
8. Observa como los valores del JSpinner aumentan o disminuyen en 1. Por otro lado,
no parece haber un límite para los valores del JSpinner.
La pregunta ahora es: ¿Se puede modificar el contenido del JSpinner de forma que
tenga unos valores concretos? La respuesta es sí. Veamos como hacerlo.
9. Entra dentro del código del programa y, dentro del constructor, añade este código
debajo de initComponents:
a. El JSpinner, al igual que los JList y los JComboBox, es un objeto que contiene
otro objeto “modelo”, y es el objeto “modelo” el que contiene los números
visualizados en el JSpinner.
c. La primera línea crea un “modelo” llamado nm. Los modelos de los JSpinner
son del tipo SpinnerNumberModel. Necesitarás incluir el import
correspondiente (atento a la bombilla)
d. En la segunda línea se define como valor máximo del modelo el 10, a través
de un método llamado setMaximum.
11. Prueba el programa y observa los valores que puede tomar el JSpinner.
12. Vamos a añadir otra mejora. Cambie el código del constructor por este otro. (Observa
que solo se ha añadido una línea):
nm.setStepSize(2);
Esta línea usa un método del modelo del JSpinner que permite definir el valor de
cambio del JSPinner. Dicho de otra forma, esta línea hace que los valores del
JSpinner salten de 2 en 2.
14. Ejecuta el programa de nuevo y observa como cambian los valores del JSpinner.
15. El modelo del JSpinner tiene también un método llamado setValue que permite
asignar un valor inicial al modelo. Pruebe a usar este método para hacer que el
JSpinner muestre desde el principio el valor 4.
CONCLUSIÓN
Los JSpinners son objetos que permiten seleccionar un número, ya sea escribiéndolo
en el recuadro, o bien a través de dos botones triangulares que permiten aumentar o
disminuir el valor actual.
Los JSpinners son objetos con “modelo”. Es decir, este objeto contiene a su vez otro
objeto “modelo” que es el que realmente contiene los datos.
Para definir el contenido del JSpinner es necesario crear un modelo del tipo
SpinnerNumberModel. Se le asigna al modelo los números deseados, y finalmente se
une el modelo con el JSpinner.
El objeto modelo del JSpinner permite definir el valor mínimo y el valor máximo, así
como el intervalo de aumento de los valores.
EJERCICIO GUIADO. JAVA: SCROLLBARS
La barra tiene un valor mínimo, que se consigue haciendo que el recuadro de la barra de
desplazamiento esté pegado a la parte izquierda.
Valor mínimo
5
9. Ejecuta ahora el programa y comprueba su funcionamiento:
Si llevas la barra de
desplazamiento al mínimo, su
valor será de 50, ya que se
configuró así con la propiedad
minimum…
5 ***
** Sin embargo, el valor de la barra viene indicado por el lado izquierdo del recuadro
interno.
Es decir,
CONCLUSIÓN
Barras de Menús
La barra de menús nos permitirá acceder a las opciones más importantes del programa.
Todo programa de gran envergadura suele tener una barra de menús.
Ejercicio guiado
1. Veamos como añadir una barra de menús a nuestras aplicaciones. En primer lugar,
crea un proyecto con el NetBeans.
9. Puedes añadir más opciones principales a la barra de menús haciendo clic con el
derecho sobre el objeto de la barra de menús y activando la opción “Añadir JMenu”.
10. Añada dos opciones más a la barra de menús. El inspector debe tener ahora el
siguiente aspecto:
11. Y la barra de menús presentará este otro aspecto:
12. Cambia los nombres de las dos nuevas opciones. Sus nombres serán: menuEdicion
y menuInsertar.
13. Cambia los textos de ambas opciones. Sus textos serán: “Edición” e “Insertar”.
14. Ya tenemos creada la barra de menús (JMenuBar) con sus opciones principales
(JMenu). Ahora se tendrán que definir las opciones contenidas en cada opción
principal. Por ejemplo, crearemos las opciones contenidas en el menú Archivo.
15. Haz clic con el botón derecho sobre el objeto menuArchivo y activa la opción “Añadir
– JMenuItem”.
Los JMenuItem son objetos que representan las opciones contenidas en los menús
desplegables de la barra de menús.
16. Añade un JMenuItem más al menuArchivo y luego cambia el nombre a ambos. Sus
nombres serán menuItemAbrir y menuItemGuardar. El aspecto del Inspector será el
siguiente:
17. Usa ahora la propiedad Text de ambos JMenuItem para asignarles un texto. El
primero tendrá el texto “Abrir” y el segundo el texto “Guardar”.
18. Ya podemos ejecutar el programa para ver que es lo que se ha conseguido. Use el
menú:
19. Seguiremos añadiendo elementos al menú. Ahora haga clic con el derecho sobre el
elemento menuArchivo y añada un JSeparator.
Los JSeparator son objetos que definen una separación entre las opciones de un menú.
Cámbiele el nombre y llámelo “separador1”:
20. Añada un nuevo JMenuItem al menú Archivo y ponle el nombre menuSalir. El texto
de esta opción será “Salir” (use su propiedad text) El aspecto del Inspector será el
siguiente:
Sin embargo, un JMenu puede contener a otros JMenu, que a su vez contendrán
varios JMenuItem. Usando el botón derecho del ratón y la opción “Añadir”, añade un
JMenu dentro de menuEdicion:
23. Llama al nuevo JMenu menuColores y asignale el texto “Colores”.
24. Ahora añade dentro del menuColores tres JMenuItem llamados respectivamente:
menuItemRojo, menuItemVerde, menuItemAzul. Sus textos serán “Rojo”, “Verde” y
“Azul”.
La opción Edición (JMenu) contiene una opción Colores (JMenu) que a su vez
contiene las opciones Rojo, Verde y Azul (JMenuItems)
26. De nada sirve crear un menú si luego este no reacciona a las pulsaciones del ratón.
Cada objeto del menú tiene un evento ActionPerformed que permite programar lo que
debe suceder cuando se active dicha opción del menú.
27. Marque en el inspector el objeto menuItemRojo y acceda a su evento
ActionPerformed. Dentro de él programe este sencillo código:
this.getContentPane().setBackground(Color.RED);
CONCLUSIÓN
Las barras de menús son un conjunto de objetos de distinto tipo que se contienen
unos a los otros:
También puede añadir separadores (JSeparator) que permiten visualizar mejor las
opciones dentro de un menú.
EJERCICIO GUIADO. JAVA: BARRA DE HERRAMIENTAS
Barras de herramientas
A través de estos botones se pueden activar de forma rápida las opciones del programa, las
cuales suelen estar también incluidas dentro de la barra de menús.
Ejercicio guiado
4. Debajo de la barra de menús colocaremos una barra de herramientas, así que añade
un objeto del tipo JToolBar. Haz que la barra se coloque debajo de la barra de menús
y que alcance desde la parte izquierda de la ventana a la parte derecha.
Normalmente, las barras de herramientas contienen botones. Así que añade cuatro
botones (JButton) dentro de la barra. Solo tienes que colocarlos dentro de ella.
6. Puedes ver si los botones están bien colocados observando el Inspector: Observa
como los botones colocados se encuentran dentro de la barra.
10. La forma de programar cada botón no varía, aunque estos se encuentren dentro de la
barra herramientas. Solo hay que seleccionar el botón y acceder a su evento
actionPerformed.
11. Solo como demostración de esto último, entra en el actionPerformed del primer botón
y programa esto:
12. Los botones de la barra de herramientas normalmente no contienen texto, sino que
contienen un icono que representa la función que realiza. La forma de colocar un
icono dentro de un botón es a través de su propiedad icon.
14. Activa la propiedad icon del primer botón. Luego elige la opción Fichero y pulsa el
botón Seleccionar Fichero para buscar un fichero con imagen.
Nota: Busca un fichero de imagen que sea del tipo .gif o .jpg.
CONCLUSIÓN
Lo normal es hacer que los botones de la barra no tengan texto y tengan iconos
asociados.
EJERCICIO GUIADO. JAVA: MENUS EMERGENTES
El evento mouseClicked
Este evento recibe como parámetro un objeto del tipo MouseEvent, y gracias a él se puede
conseguir información como la siguiente:
Se puede usar esta información para saber por ejemplo si se pulsó el botón derecho del
ratón, y sacar en este caso un menú contextual en pantalla.
Ejercicio guiado
3. Programaremos la pulsación del ratón sobre el formulario, así que haga clic sobre el
formulario y active el evento mouseClicked.
Este evento recibe como parámetro un objeto llamado evt del tipo MouseEvent (en
rojo en el código) que nos permite saber en qué condiciones se hizo clic.
if (evt.getButton()==1) {
JOptionPane.showMessageDialog(null,"Pulso el izquierdo");
} else if (evt.getButton()==2) {
JOptionPane.showMessageDialog(null,"Pulso el central");
} else if (evt.getButton()==3) {
JOptionPane.showMessageDialog(null,"Pulso el derecho");
}
6. Ejecuta el programa y haz clic sobre el formulario con el botón derecho, con el
izquierdo y con el central. Observa el resultado.
9. Agrega a tu formulario un objeto del tipo JPopupMenu. Estos objetos definen menús
emergentes.
12. Los menús emergentes se crean igual que las opciones de menús normales,
añadiendo con el botón derecho del ratón objetos JMenuItem.
13. Añada al menú emergente tres JMenuItem, y asígneles los siguientes nombres a
cada uno: menuRojo, menuVerde, menuAzul. El inspector debería tener el siguiente
aspecto:
14. Tienes que cambiar la propiedad text de cada opción del menú. Recuerda que esta
propiedad define lo que aparece en el menú. Asignarás los siguientes textos: “Rojo”,
“Verde” y “Azul”.
15. El menú emergente ya está construido. Ahora tenemos que hacer que aparezca
cuando el usuario pulse el botón derecho del ratón sobre el formulario. Para ello,
entraremos de nuevo en el evento mouseClicked del formulario y cambiaremos su
código por el siguiente:
menuEmergente.show(this,evt.getX(),evt.getY());
16. Este código significa lo siguiente:
18. Para hacer que al pulsarse una opción suceda algo, solo hay que activar el método
actionPerformed del JMenuItem correspondiente. Por ejemplo, active el
actionPerformed del menuRojo y dentro programe lo siguiente:
this.getContentPane().setBackground(Color.RED);
19. Ejecuta el programa y comprueba lo que sucede al pulsar la opción Rojo del menú
contextual.
CONCLUSIÓN
Los menús contextuales son objetos del tipo JPopupMenu. Estos objetos contienen
JMenuItem al igual que las opciones de menú normales.
Tendrá que usar el método show del menú emergente para mostrar dicho menú.
EJERCICIO GUIADO. JAVA: FILECHOOSER
Las opciones Abrir y Guardar son opciones muy comunes en las aplicaciones. Estas
opciones permiten buscar en el árbol de carpetas del sistema un fichero en concreto y
abrirlo, o bien guardar una información dentro de un fichero en alguna carpeta.
Java proporciona una clase llamada JFileChooser (elegir fichero) que permite mostrar la
ventana típica de Abrir o Guardar:
(La ventana de guardar es la misma, solo que muestra en su barra de título la palabra
Guardar)
El objeto JFileChooser nos facilita la labor de elegir el fichero, pero no realiza la apertura o la
acción de guardar la información en él. Esto tendrá que ser programado.
Ejercicio guiado
9. Una vez hecho esto, ya podemos programar la opción Abrir del menú. Activa el
evento actionPerformed de la opción “Abrir” y programa dentro de él lo siguiente:
int resp;
resp=elegirFichero.showOpenDialog(this);
if (resp==JFileChooser.APPROVE_OPTION) {
JOptionPane.showMessageDialog(null,elegirFichero.getSelectedFile().toString());
} else if (resp==JFileChooser.CANCEL_OPTION) {
10. Ejecuta el código y prueba la opción “Abrir” del menú. Prueba a elegir algún fichero y
abrirlo. Prueba a cancelar la ventana de apertura. Etc
int resp;
resp=elegirFichero.showOpenDialog(this);
- Estas dos líneas crean una variable entera resp (respuesta) y a continuación hacen
que se muestre la ventana “Abrir Fichero”. Observa que para conseguirlo hay que
usar el método showOpenDialog del objeto elegirFichero. Este método lleva como
parámetro la ventana actual (this)
- Se pueden usar dos if para controlar lo que sucede si el usuario pulsó el botón “Abrir”
o el botón “Calcelar” de la ventana “Abrir Fichero”:
if (resp==JFileChooser.APPROVE_OPTION) {
JOptionPane.showMessageDialog(null,elegirFichero.getSelectedFile().toString());
} else if (resp==JFileChooser.CANCEL_OPTION) {
- El programa aprovecha esto para mostrar dicho camino en pantalla gracias al típico
JOptionPane.
elegirFichero.getSelectedFile().toString()
CONCLUSIÓN
Estos objetos no abren ni guardan ficheros, solo permiten al usuario elegir el fichero a
abrir o guardar de forma sencilla.
Paneles de Desplazamiento
Por ejemplo, un panel de desplazamiento podría contener una imagen tan grande que no se
viera entera:
Ejercicio guiado 1
1. Vamos a practicar con los JScrollPane. Para ello, crea un nuevo proyecto.
9. Esta imagen es tan grande que no se podrá ver entera dentro del panel de
desplazamiento. Ejecuta el programa y observarás el uso de las barras de
desplazamiento dentro del panel.
10. Puedes mejorar el programa si agrandas el panel de desplazamiento de forma que
ocupe todo el formulario:
Ejercicio guiado 2
Los JScrollPane no solo están diseñados para contener imágenes. Pueden contener
cualquier otro elemento. Vamos a ver, con otro proyecto de ejemplo, otro uso de los
JScrollPane.
6. Los JPanel son objetos contenedores. Es decir, pueden contener otros objetos como
por ejemplo botones, etiquetas, cuadros de texto, etc.
7. En la pantalla aparecerá únicamente el JPanel, para que puede ser diseñado aparte
de la ventana completa:
8. Para distinguirlo de lo que es en sí la ventana, haremos las siguientes cosas con el
panel:
Como ves, el JPanel contenido en el JScrollPane es más grande que él, por lo que no
se podrá visualizar completamente. Será necesario usar las barras de
desplazamiento del JScrollPane.
CONCLUSIÓN
Los JScrollPane son ideales para mostrar imágenes, paneles y otros elementos cuyo
tamaño pueda ser mayor que la propia ventana.
EJERCICIO GUIADO. JAVA: VARIABLES GLOBALES
Una propiedad es una variable que puede ser accedida desde cualquier evento programado.
Esta variable se inicializa a un valor cuando se ejecuta el programa y los distintos eventos
pueden ir cambiando su valor según se necesite.
Ejercicio guiado 1
Clase Principal
3. Se pretende hacer un pequeño programa que controle los coches que van entrando y
van saliendo de un parking. En todo momento el programa debe decir cuantos
coches hay dentro del parking. Para ello debes crear una ventana como la que sigue:
4. Esta ventana contiene lo siguiente:
Esta variable contendrá en todo momento los coches que hay actualmente en el
Parking. Esta variable podrá ser usada desde cualquier evento.
7. Para crear una variable global haz clic en el botón “Origen” para acceder al código:
8. Luego busca, al comienzo del código una línea que comenzará por
public class
10. Cuando el programa arranque, será necesario que la variable global coches tenga un
valor inicial. O dicho de otra forma, será necesario inicializar la variable. Para
inicializar la variable iremos al constructor. Añade lo siguiente al código:
Inicialización de la propiedad
coches.
11. Ahora que ya tenemos declarada e inicializada la variable global coches, esta puede
ser usada sin problemas desde cualquier evento que programemos.
coches=coches+1;
etiCoches.setText(“”+coches);
Como ves, se le añade a la variable coches uno más y luego se coloca su valor
actual en la etiqueta.
if (coches>0) {
coches=coches-1;
etiCoches.setText(“”+coches);
}
Como ves, se accede igualmente a la propiedad coches pero esta vez para restarle
una unidad. Luego se muestra el valor actual de coches en la etiqueta
correspondiente.
Se usa un if para controlar que no pueda restarse un coche cuando el parking esté
vacío. (Si hay cero coches en el parking no se puede restar uno)
14. Ejecuta el programa y prueba los dos botones. Observa como la cantidad de coches
del parking aumenta o disminuye.
Al pulsar aquí aumentas en uno la
propiedad coches.
Lo realmente interesante de esto es que desde dos eventos distintos (desde dos
botones) se puede usar la variable coches. Esto es así gracias a que ha sido creada
como variable global, o dicho de otro modo, ha sido creada como propiedad de la clase
Parking.
15. Finalmente se programará el botón Reiniciar. Este botón, al ser pulsado, debe
colocar la propiedad coches a cero. Programa dentro de su actionPerformed lo
siguiente:
coches=0;
etiCoches.setText(“0”);
CONCLUSIÓN
Las variables globales, también llamadas propiedades de la clase, son variables que
pueden ser usadas desde cualquier evento del programa. Estas variables mantienen
su valor hasta que otro evento lo modifique.
Es muy habitual en Java que varios eventos tengan que ejecutar el mismo código. En este
caso se plantea la necesidad de “copiar y pegar” ese código en los distintos eventos a
programar:
Evento 1 Código A
Evento 2 Código A
Evento 3 Código A
Esta es una mala forma de programación, ya que se necesitara modificar el código, sería
necesario realizar la modificación en cada copia del código. Es muy fácil que haya olvidos y
aparezcan errores en el programa que luego son muy difíciles de localizar.
Lo mejor es que el código que tenga que ser ejecutado desde distintos eventos aparezca
solo una vez, y sea llamado desde cada evento:
Evento 1
Evento 2 Código A
Evento 3
Veamos algunos ejemplos en los que el código se puede repetir y como evitar esta
repetición.
Ejercicio guiado 1
1. Crea un nuevo proyecto en java que se llame ProyectoCalculos. Este proyecto tendrá
un paquete llamado PaqueteCalculos. Y dentro de él creará un JFrame llamado
VentanaCalculos. El proyecto tendrá el siguiente aspecto:
2. La VentanaCalculos debe estar diseñada de la siguiente forma:
5. Este es un ejemplo en el que al activarse uno de varios eventos distintos se tiene que
ejecutar el mismo código. Observa el caso de la suma:
Calcular la suma y
Activar Calcular – Sumar en el menú mostrarla en la etiqueta
de resultado
6. Para que el código esté “centralizado”, es decir, que aparezca solo una vez, será
necesario construir en la clase un método. Un método en java es el equivalente de
una función o procedimiento en C. Veamos como hacerlo:
7. Accede al código de tu programa a través del botón Origen.
8. Un buen sitio para programar tus procedimientos puede ser debajo del constructor.
Puedes distinguir fácilmente al constructor porque tiene el mismo nombre que la
clase que estás programando, o dicho de otro modo, tiene el mismo nombre que la
ventana que estás programando: VentanaCalculos.
Este es el constructor
void Sumar() {
....
}
Si estudias las líneas del código, verás que lo que hace es recoger el contenido de
los dos cuadros de texto en dos variables de cadena llamadas cad1 y cad2.
Luego convierte dichas cadenas en números que almacena en dos variables enteras
llamadas a y b.
11. Hay que destacar que este código no pertenece ahora mismo a ningún evento en
concreto, por lo que no tiene efecto ninguno sobre el programa. Será necesario pues
asociar los eventos correspondientes con este procedimiento.
12. Interesa que al pulsar el botón “Sumar” se ejecute la suma, así pues entre en el
evento actionPerformed del botón “Sumar” y añada la siguiente línea:
Sumar();
13. Como también interesa que al pulsar la opción del menú “Calcular-Sumar” se ejecute
la suma, entre en el evento actionPerformed de la opción del menú “Sumar” y añade
de nuevo la siguiente línea:
Sumar();
14. También se quiere que al pulsar la tecla enter en el cuadro de texto del número 1 se
ejecute la suma. Por lo tanto, en el evento actionPerformed del cuadro de texto
txtNumero1 hay que añadir la siguiente línea:
Sumar();
15. Y como también se quiere que al pulsar la tecla enter en el cuadro de texto del
número 2 se ejecute la suma, también habrá que introducir en su actionPerformed la
siguiente línea:
Sumar();
16. Antes de continuar, ejecute el programa, introduzca dos números, y compruebe como
se calcula la suma al pulsar el botón Sumar, o al activar la opción del menú Calcular–
Sumar, o al pulsar Enter en el primer cuadro de texto, o al pulsar Enter en el segundo
cuadro de texto.
En cada uno de los eventos hay una llamada al procedimiento Sumar, que es el que
se encarga de realizar la suma.
actionPerformed btnSumar
Procedimiento
actionPerformed menuSumar
Sumar()
actionPerformed txtNumero1
actionPerformed txtNumero2
17. En el caso de la resta sucede igual. Tenemos que varios eventos distintos deben
provocar que se realice una misma operación. En este caso tenemos lo siguiente:
Calcular la resta y
Activar Calcular – Restar en el menú mostrar el resultado.
18. Para centralizar el código, crearemos un método Restar que se encargará de hacer la
resta de los números introducidos en los cuadros de texto. Este método se puede
colocar debajo del anterior método Sumar:
Programa este
procedimiento.
20. Ahora, es necesario que cuando se activen los eventos indicados antes, estos hagan
una llamada al procedimiento Restar para que se efectúe la resta. Así pues, entre en
el evento actionPerformed del botón “Restar” y añada esta línea de código:
Restar();
Restar();
22. Ejecute el programa y compruebe como funciona el cálculo de la resta, da igual que
lo haga pulsando el botón “Restar” o la opción del menú “Restar”. Ambos eventos
llaman al mismo método:
actionPerformed btnRestar
Procedimiento
actionPerformed menuRestar
Restar()
23. Finalmente se programará el borrado de los cuadros de texto a través del botón
“Borrar” y de la opción del menú “Borrar”. En primer lugar, programa el siguiente
método (puedes hacerlo debajo del método “Restar”):
Programa el
procedimiento Borrar...
24. Ahora programa las llamadas al procedimiento borrar desde los distintos eventos. En
el evento actionPerformed del botón “Borrar” y en el evento actionPerformed de la
opción del menú “Borrar” programa la siguiente llamada:
Borrar();
CONCLUSIÓN
Para diseñar más cómodamente las ventanas, Java proporciona una serie de objetos
denominados Layouts, que definen la forma que tendrán los elementos de situarse en las
ventanas.
Así pues, un Layout define de qué forma se colocarán las etiquetas, botones, cuadros de
textos y demás componentes en la ventana que diseñamos.
Ejercicio guiado
“Diseño Libre”
3. Las líneas azules que aparecen indican con qué otro elemento está relacionado un
componente de la ventana. La situación de un elemento dependerá siempre de la
situación del otro.
Dicho de otra forma, las líneas azules indican las distancias que siempre se
respetarán. Observa la siguiente imagen:
Tanto el botón como la
etiqueta estarán siempre
a esta distancia del borde
derecho de la ventana…
5. Este comportamiento de los elementos en la ventana viene dado por una opción del
NetBeans llamada Diseño Libre (Free Design)
El Diseño Libre permite que los elementos de una ventana mantengan una
distribución relativa da igual el tamaño que tenga la ventana. Dicho de otra forma, los
elementos se redistribuyen al cambiar el tamaño de la ventana.
El problema del Diseño Libre es el poco control que se tiene sobre los elementos que
se añaden a la ventana.
6. El Diseño Libre es la opción que está activada por defecto cuando se crea un
proyecto en NetBeans. Sin embargo, esta opción se puede cambiar por distintos
“Layouts” o “Distribuciones”.
Como ves, aparece un objeto dentro del JFrame llamado AbsoluteLayout. Este objeto
define otra forma de situar los elementos en la ventana. Concretamente, la
distribución AbsoluteLayout permite al programador colocar cada elemento donde él
quiera, sin restricciones, sin tener en cuenta distancias relativas.
9. Sitúa la etiqueta y el botón donde quieras. Observa que no aparece ninguna línea
guía que defina distancias relativas:
10. La ventana de definir una distribución AbsoluteLayout es la facilidad para colocar
cada elemento en la ventana (no tendrás los problemas del Diseño Libre). Sin
embargo, la desventaja es que los elementos no mantienen una distribución relativa
respecto al tamaño de la ventana.
Verás que los elementos de la ventana son inamovibles aunque la ventana cambie de
tamaño. En cambio, en el Diseño Libre los elementos intentaban siempre estar dentro
de la ventana.
12. Practiquemos ahora con otro tipo de distribución. Accede al Inspector y pulsa el botón
derecho del ratón sobre el objeto JFrame. Activa la opción Establecer Disposición –
FlowLayout.
13. Observa como el layout “AbsoluteLayout” es sustituido por la distribución
“FlowLayout”. Una elemento solo puede tener un tipo de distribución a la vez.
14. Observa la ventana. Los elementos se han colocado uno detrás de otro. Se han
colocado “en línea”. Esto es lo que hace el “FlowLayout”. Fuerza a los distintos
elementos a que se coloquen en fila.
17. Otra distribución que se puede usar es la distribución GridLayout. Esta distribución
coloca a los elementos en filas y columnas, como si formaran parte de una tabla. Al
añadir esta distribución es necesario indicar cuantas filas y columnas tendrá la rejilla.
21. Ya que solo tienes dos elementos en la ventana (una etiqueta y un botón), añade
otros cuatro elementos más (cuatro botones) para observar como se distribuyen en la
cuadrícula.
22. En un GridLayout, los elementos estarán situados siempre en una casilla de la rejilla,
ocupando todo su espacio. El programador no tiene mucho control sobre la
disposición de los elementos.
23. Ejecuta el programa y agranda y achica la ventana. Observa como los elementos
siempre mantienen su disposición en rejilla y siempre aparecen dentro de la ventana
aunque el tamaño de esta varíe.
Con un GridLayout los
elementos aparecen en
filas y columnas.
“BorderLayout”
25. Haz clic con el derecho sobre el JFrame y asigna una distribución “BorderLayout”.
26. Para poder entender el funcionamiento del BorderLayout, se recomienda que el
JFrame contenga únicamente 5 botones (elimine los elementos que tiene ahora y
añada cinco botones)
27. Como se puede observar, cada botón se ha colocado en una zona, y su tamaño ha
variado hasta ocupar la zona entera. Tenemos un botón en el norte, otro al sur, uno
al este, otro al oeste y uno en el centro.
28. Ejecuta el programa y observa como los elementos siempre se mantienen dentro de
la ventana aunque esta cambie de tamaño.
Diseño Libre – Esta distribución viene activada por defecto en el NetBeans, y define
una distribución de componentes en la que se respetan las distancias entre ellos
cuando la ventana cambia de tamaño.
FlowLayout – En esta distribución los elementos se colocan uno detrás de otro. Los
elementos intentarán estar dentro de la ventana aunque esta se reduzca de tamaño.
La distribución AbsoluteLayout por ejemplo nos da mucha facilidad a la hora de colocar los
elementos en la ventana, pero sin embargo los componentes no se adaptan a los cambios
de tamaño.
El Diseño Libre en cambio permite crear ventanas en las que sus componentes se
“recolocan” según el tamaño de estas pero a cambio crece la dificultad del diseño.
Para aprovechar las ventajas de los distintos layouts y minimizar sus inconvenientes, es
habitual en java crear una estructura de paneles cada uno de ellos con un layout distinto,
según nuestras necesidades.
Normalmente, al JFrame se le asigna un layout que lo divida en zonas, como puede ser el
BorderLayout o el GridLayout. Luego, dentro de cada una de estas zonas se introduce un
panel (objeto JPanel). Y a cada uno de estos paneles se le asigna el layout que más le
convenga al programador (FlowLayout, Diseño Libre, AbsoluteLayout, etc…) Finalmente,
dentro de cada panel se añaden los componentes de la ventana.
JFrame
(BorderLayout o GridLayout)
Componentes Componentes
Ejercicio guiado
Se pretende crear un proyecto con una ventana de diseño complejo. Para ello sigue
los siguiente pasos:
4. Cambia el nombre a este panel y llámalo panelTitulo, ya que contendrá el nombre del
programa.
5. Añade otro panel, esta vez a la parte central. El panel se llamará panelDatos:
NOTA. A veces resulta complicado agregar un panel en una zona de la ventana cuando
tenemos un BorderLayout. Puedes entonces hacer clic con el derecho sobre JFrame en
el Inspector y activar la opción Agregar desde paleta – Swing – JPanel.
7. Si el panel no se coloca en el sitio deseado, se puede seleccionar en el Inspector y
activar su propiedad Dirección, e indicar la zona donde se quiere colocar:
10. Cada panel puede ser diseñado de forma individual, simplemente haciendo doble clic
sobre él. Así pues, empezaremos diseñando el panel panelBotonera. Haz doble clic
sobre él.
11. En la parte izquierda del NetBeans aparecerá únicamente el panelBotonera.
Agrándalo para que tenga la siguiente forma:
12. A cada panel se le puede asignar un Layout distinto. A este panel le asignaremos un
AbsoluteLayout para poder colocar cada elemento donde quiera. Asigna un
AbsoluteLayout al panel haciendo clic con el derecho sobre él en el Inspector. El
Inspector debería quedar así:
13. Ahora añade cuatro botones al panel. Observa como tienes libertad total para colocar
cada botón donde quieras. Procura que el panel quede así:
(No nos vamos a preocupar en este ejercicio de los nombres de los componentes)
14. Ahora diseña el panel panelVerificación haciendo doble clic sobre él.
16. Coloca en él cuatro casillas de verificación. El aspecto del panel al terminar debe ser
parecido al siguiente:
18. En este caso se le añadirá un FlowLayout. Recuerda que este layout hace que cada
elemento se coloque uno detrás de otro.
19. Añade al panel dos etiquetas como las que siguen. Ponle un borde a cada una:
Observa las líneas “guía”. Indican que las etiquetas dependen de la parte derecha del
panel. A su vez cada una depende de la otra. Es como si estuvieran “enganchadas”,
como los vagones de un tren.
21. El panelDatos lo vamos a complicar un poco. Haz doble clic sobre él para diseñarlo y
asígnale un GridLayout.
22. Marca el GridLayout y asígnale 2 filas y 2 columnas, para que interiormente tenga
forma de una rejilla como esta:
23. A cada una de las divisiones del GridLayout del panelDatos le asignaremos un nuevo
panel. Añade al panelDatos cuatro paneles. Esto lo puedes hacer fácilmente
haciendo clic con el botón derecho del ratón sobre el panelDatos en el Inspector y
eligiendo la opción Añadir desde paleta – Swing – JPanel.
El aspecto del inspector debería ser como el que sigue, en lo que se refiere al
panelDatos:
24. Asignaremos a cada uno de los cuatro paneles los siguientes nombres:
panelEtiqueta1, panelCuadro1, panelEtiqueta2, panelCuadro2. El panel quedará así
en el Inspector.
Así pues, el panel panelDatos tiene forma de rejilla con cuatro celdas, y en cada
celda hay un panel. Puede imaginarse el panelDatos así:
panelDatos
PanelEtiqueta1 PanelCuadro1
PanelEtiqueta2 PanelCuadro2
CONCLUSIÓN
Para el diseño de ventanas muy complejas, ser suelen definir layouts que dividan en
zonas el JFrame, como por ejemplo el BorderLayout o el GridLayout.
Cuadros de Diálogo
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.
Para crear cuadros de diálogo en Java, se usa un tipo de objetos llamado JDialog. Estos
objetos pueden ser diseñados como si fueran ventanas, aunque representan realmente
cuadros de diálogo.
Ejercicio guiado
4. Así pues entra en el código y declara una variable global iva y otra descuento tal
como se indica a continuación (recuerda que las variables globales se colocan justo
después de la línea donde se define la clase principal public class):
Variables
globales
5. Cuando el programa arranque, interesará que el iva por defecto sea 0, y que el
descuento por defecto sea 0 también, así que en el constructor, inicializaremos las
variables globales iva y descuento a 0:
Inicialización de
variables
globales
double unidades;
double precio;
double total; //total
double cantiva; //cantidad iva
double cantdes; //cantidad descuento
double totalsiniva; //total sin iva
10. Los JDialog son objetos ocultos, es decir, objetos que se colocan en la parte del
Inspector llamada Otros Componentes, al igual que sucede con los menús
contextuales o los JFileChooser. Observa tu inspector, allí verás el JDialog que has
añadido:
12. Los diálogos normalmente traen por defecto el layout BorderLayout. Para nuestro
ejemplo cambiaremos el layout del JDialog por el Diseño Libre:
13. Los JDialog se pueden diseñar independientemente, al igual que los JPanel. Solo
tienes que hacer doble clic sobre el dialogoConfiguracion (en el inspector) y este
aparecerá en el centro de la ventana.
14. Así pues debes diseñar el dialogoConfiguracion para que quede de la siguiente
forma:
dialogoConfiguracion.setSize(250,200);
dialogoConfiguracion.setLocation(100,100);
dialogoConfiguracion.setVisible(true);
18. Ejecuta el programa y observa lo que sucede cuando pulsas el botón Configurar.
Debería aparecer el cuadro de diálogo en la posición programada y con el tamaño
programado:
19. Los botones Aceptar y Cancelar del cuadro de diálogo aún no hacen nada. Así que
los programaremos. Empezaremos por el más sencillo, el botón Cancelar.
dialogoConfiguracion.dispose();
El método dispose se usa para cerrar un cuadro de diálogo. También se puede usar
con un JFrame para cerrarlo.
21. Ejecuta el programa de nuevo y comprueba el funcionamiento del botón Cancelar del
cuadro de diálogo.
22. Ahora se programará el botón Aceptar. Cuando el usuario pulse este botón, se
confirmará el valor del iva y del descuento que haya introducido. Es decir, se
traspasarán los valores introducidos en los cuadros de texto txtIva y txtDescuento a
las variables globales iva y descuento.
Una vez que se haya hecho esto, el cuadro de diálogo se debe cerrar.
23. Este es el código que hace lo anterior. Debe programarlo en el actionPerformed del
botón Aceptar:
iva = Double.parseDouble(txtIva.getText());
descuento=Double.parseDouble(txtDescuento.getText());
dialogoConfiguracion.dispose();
24. Observe el código. Primero se traspasa los valores de los cuadros de texto a las
variables globales y luego se cierra el cuadro de diálogo.
25. Compruebe el funcionamiento del programa de la siguiente forma:
a. Ejecute el programa.
b. Introduzca 5 unidades y 20 de precio.
c. Si pulsa calcular, el total será 100. (No hay ni iva ni descuento al empezar el
programa)
d. Ahora pulse el botón Configuración, e introduzca un iva del 16. El descuento
déjelo a 0. Acepte.
e. Ahora vuelva a calcular. Observe como ahora el total es 116, ya que se tiene
en cuenta el iva configurado.
f. Pruebe a configurar un descuento y vuelva a calcular.
27. Vuelva a ejecutar el programa. Observe la barra de título del cuadro de diálogo:
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.
La ventana se activa
colocándose por encima
del cuadro de diálogo.
e. A veces, puede ser interesante que se active la ventana pero que el cuadro
de diálogo siga delante de ella. Para conseguir esto, es necesario activar la
propiedad del cuadro de diálogo llamada alwaysOnTop. Activa esta
propiedad:
f. Ahora ejecuta el programa de nuevo y haz que se visualice el cuadro de
diálogo de configuración. Podrás comprobar que se puede activar la ventana
e incluso escribir en sus cuadros de textos, y que el cuadro de diálogo sigue
visible:
Se puede activar la
ventana trasera, e
incluso escribir en ella.
Esto es gracias a que el
cuadro de diálogo es no
modal.
Un cuadro de diálogo modal es aquel que no permite que se active otra ventana
hasta que este no se haya cerrado.
31. Para convertir nuestro cuadro de diálogo en modal, será necesario que lo selecciones
en el inspector y busques la propiedad modal. Debes activar esta propiedad.
b. A continuación intenta activar la ventana haciendo clic sobre ella. Verás como
no es posible activarla. Es más, intenta escribir en sus cuadros de texto. No
será posible hacerlo. (Incluso observarás un parpadeo en el cuadro de diálogo
avisándote de ello). Esto es debido a que ahora nuestro cuadro de diálogo es
modal.
Aunque intentes activar la
ventana o escribir en ella, no
podrás, ya que el cuadro de
diálogo es modal.
CONCLUSIÓN
Los Cuadros de Diálogo son ventanas simplificadas que muestran distintas opciones
al usuario.
Los objetos JDialog son los que permiten la creación y uso de cuadros de diálogo en
un proyecto java.
Para visualizar un JDialog será necesario llamar a su método setVisible. También son
interesantes los métodos setSize para asignarles un tamaño y setLocation para situar
el cuadro de diálogo en la pantalla.
Los cuadros de diálogo modales no permiten que se active otra ventana hasta que el
cuadro de diálogo no se haya cerrado.
Los cuadros de diálogo no modales permiten trabajar con otra ventana a pesar de que
el propio cuadro de diálogo no haya sido cerrado.
EJERCICIO GUIADO. JAVA: 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 textos, etc, y cambiar sus propiedades según nos interese.
Todo esto tiene un código asociado que se genera de forma automática, y del que no nos
hemos preocupado hasta el momento.
Por ejemplo, cada vez que añades un botón o una etiqueta, se generan automáticamente las
instrucciones de código que permiten crear dicho botón o dicha etiqueta. También se genera
el código que permite cambiar el texto del botón, o cambiar el texto de la etiqueta.
Ejercicio guiado 1.
4. Todas estas operaciones que has realizado tienen asociado unas instrucciones de
código que se han generado automáticamente. Para estudiar estas instrucciones,
activa el botón Origen en la parte superior de la pantalla:
5. En el código, observarás una línea llamada Código Generado. Esta línea está
señalada en color azul (al igual que todas las instrucciones generadas
automáticamente) Observarás que tiene un + en la parte izquierda. Si haces clic
sobre el signo + aparecerá el código generado automáticamente:
ETC…
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 guiado 2
…programación de la clase…
}
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í.
El método main, es similar a la función main del lenguaje C. En el caso del java, el
NetBeans genera automáticamente el método main, de forma que no tendremos que
hacer cambios en él.
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:
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 constructor:
El método donde
diseñaremos nuestra
ventana…
12. Para que esto tenga efecto, es necesario que el método CrearVentana sea llamado
desde el constructor, al igual que sucede con el método initComponents:
Al comienzo de la clase, después del public class, donde se suelen definir las
variables globales, añade el siguiente código:
Este código declara una variable de tipo JLabel (etiqueta) y le da el nombre etiNum1.
15. Al escribir este código, aparecerá un error en la línea, ya que será necesario importar
la librería donde se encuentra el tipo de objeto JLabel. 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:
- La primera línea construye la etiqueta llamada etiNum1 que fue delarada antes.
- Generalizando: para crear un objeto llamado xxx del tipo tipoobjeto, se tendrá que
hacer lo siguiente:
o En la zona de las variables globales se declarará la variable del objeto de
la siguiente forma:
tipoobjeto xxx;
etiNum1.setText(“Número 1: “);
- Hay que definir la posición que tendrá el objeto y el tamaño. Para ello, se usará el
método setBounds. Este método recibe la posición (x, y) del objeto y el ancho y el
alto. En el ejemplo, la etiqueta está situada en la posición (10,10) de la ventana y
tiene un ancho de 100 y un alto de 20:
etiNum1.setBounds(10,10,100,20);
this.getContentPane().add(etiNum1);
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:
28. Ahora se añadirá un nuevo cuadro de texto llamado txtNum2. El código es similar.
Declara la variable global:
35. Ahora se añadirá otro botón llamado btnRestar. Declara la variable JButton:
37. El código es prácticamente igual que el del primer botón. Solo cambia el nombre del
botón, el texto y la posición y tamaño del botón.
La ventana de diseño de NetBeans es una herramienta que nos permite diseñar las
ventanas sin tener que programar código.
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;
Luego se pueden usar distintos métodos del objeto para trabajar con él.
EJERCICIO GUIADO. JAVA: EVENTOS DESDE CÓDIGO
Programación de eventos
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.
- 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
Eventos de Acción
Eventos Oyente/Adaptador
xxx.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
xxxActionPerformed(evt);
}
});
btnSumar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
btnSumarActionPerformed(evt);
}
});
btnSumar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
btnSumarActionPerformed(evt);
}
}); El evento actionPerformed, es en
Dentro del procedimiento actionPerformed se realidad un procedimiento, que tiene
hace una llamada a otro procedimiento. El como parámetro un objeto del tipo
nombre de este otro procedimiento puede ser ActionEvent al que llamaremos evt por
cualquiera, pero usaremos el nombre del convención.
componente seguido de “ActionPerformed”
El código anterior permite crear y asignar el evento actionPerformed al botón btnSumar, pero
no programa el evento. Para programar el evento es necesario crear el procedimiento cuya
llamada se incluye dentro del evento actionPerformed:
A pesar de lo complicado que resulta, hay que tener en cuenta que siempre se programa de
la misma forma. Solo hay que cambiar el componente que se quiere programar y asignar un
nombre a la función donde se programará el evento.
Hay que tener en cuenta que en el código expuesto antes participan nuevas clases como
son ActionEvent y ActionListener, y se tendrán que agregar los import correspondientes.
EJERCICIO GUIADO
txtNum1 y txtNum2
son los cuadros de
texto.
btnSumar es el btnRestar es el
botón Sumar botón Restar
3. El objetivo del ejercicio es programar la pulsación del botón btnSumar para que
aparezca un JOptionPane con la suma calculada. Luego haremos lo mismo con el
botón btnRestar. Todo esto se hará desde código.
4. Para recordar, he aquí el código programado hasta ahora. Tenemos una llamada
desde el constructor a un método CreacionVentana donde diseñamos cada uno de
los elementos de la ventana:
btnSumar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
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.
Hay que
programar el
método al que
llama el evento…
Este es el código
que tienes que
añadir
9. Bien, hemos programado la pulsación del botón Sumar. Hemos seguido dos pasos:
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() {
public void actionPerformed(ActionEvent evt) {
btnRestarActionPerformed(evt);
}
});
(Observa que es idéntico al código de asignación del evento del botón btnSumar, solo
cambia el nombre del botón y el nombre del procedimiento al que se llama)
a=Double.parseDouble(txtNum1.getText());
b=Double.parseDouble(txtNum2.getText());
r=a-b;
JOptionPane.showMessageDialog(null,"La resta es "+r);
}
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:
Asignación de un actionPerformed
al botón btnSumar.
Asignación de un actionPerformed
al botón btnRestar.
Para enlazar el oyente ActionListener a un componente XXX hay que usar el siguiente
código:
XXX.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
XXXActionPerformed(evt);
}
});
- mouseEntered
o Indica que el ratón entró en la superficie del elemento (etiqueta, botón, etc)
- mouseExited
o Indica que el ratón salió de la superficie del elemento (etiqueta, botón, etc)
- mousePressed
o Indica que un botón del ratón ha sido presionado sobre el elemento.
- mouseReleased
o Indica que un botón del ratón ha sido soltado sobre el elemento.
- mouseClicked
o Indica que se ha pulsado/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.
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
Si queremos asociarle eventos de ratón, tendremos que añadir el siguiente código dentro del
constructor:
XXX.addMouseListener(new MouseAdapter() {
});
XXX.addMouseListener(new MouseAdapter() {
La llamada...
Y el procedimiento.
Detalles de la ventana
Se diseña la primera
etiqueta
Se diseña la segunda
etiqueta
6. Ejecuta ya el programa para observar el resultado de nuestro diseño. El aspecto
debe ser el siguiente:
8. Para hacer esto, necesitamos crear un MouseAdapter que contenga los siguientes
eventos: mouseEntered, mouseExited y mousePressed. Observa que no es
necesario que contenga el mouseReleased ni el mouseClicked.
d. Es normal que las llamadas a los procedimientos de cada evento den error ya
que todavía no han sido programadas.
11. Ahora se programará cada procedimiento que es llamado desde cada evento.
Recuerda que esto debe hacerse fuera del método CreaciónVentana. Aquí tienes lo
que debes programar:
Debes
programar
este código
12. Ahora ya puedes ejecutar el programa y comprobar lo que sucede cuando interactúas
con el ratón sobre la etiqueta de color rojo.
13. Vamos a añadir una pequeña mejora que nos servirá para estudiar ese objeto
llamado evt del tipo MouseEvent que llevan todos los eventos de ratón como
parámetro.
Se dijo antes que este parámetro contiene información sobre la acción del ratón. Por
ejemplo, nos puede servir para saber cuantas veces se pulsó el ratón, con qué botón,
etc. Aprovecharemos este parámetro para indicar qué botón del ratón es el que se ha
pulsado sobre la etiqueta.
14. En el código anterior aprovechamos los métodos que tiene el objeto MouseEvent
para averiguar que botón se ha pulsado. Usamos el método getButton que nos dice
el botón pulsado. Aprovechamos las constantes de la clase MouseEvent para saber
si se pulsó el botón izquierdo, central o derecho.
CONCLUSIÓN
Hay grupos de eventos que pertenecen a un mismo oyente o adaptador. Por ejemplo,
los eventos de ratón pertenecen al adaptador llamado MouseAdapter.
Si se quiere asignar eventos de ratón a un componente XXX, hay que usar el siguiente
código:
XXX.addMouseListener(new MouseAdapter() {
Ten en cuenta que solo añades al adaptador aquellos eventos que necesites.
Cada evento de ratón lleva como parámetro un objeto evt del tipo MouseEvent que
contiene información sobre el evento: qué botón del ratón se pulsó, cuantas veces,
etc.
EJERCICIO GUIADO. JAVA: EVENTOS DESDE CÓDIGO. IDEAS GENERALES
Se finalizará el estudio de los eventos desde código, planteando de forma general el código
necesario para programarlos.
Componente.MetodoParaAñadirOyente(new TipoOyente() {
...otros eventos...
});
Conociendo esto, si queremos programar los eventos del ratón de una etiqueta llamada
etiTexto, solo tenemos que hacer lo siguiente:
etiTexto.addMouseListener(new MouseAdapter() {
});
Los eventos de teclado controlan las pulsaciones de tecla. Entre ellos, podemos mencionar a
los siguientes:
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() {
});
Si surge un nuevo evento X el cual quiero usar desde código, ¿cómo puedo saber cual es su
adaptador/oyente, el método para asignar dicho adaptador/oyente al componente, y el tipo
de datos del parámetro?
Para este caso, se aconseja crear un proyecto de prueba desde la ventana de diseño y
asignar el evento X que se quiere estudiar a un componente. Luego simplemente hay que
analizar el código generado por el NetBeans.
--- NO HAY EJERCICIO GUIADO EN ESTA HOJA ---
CONCLUSIÓN
Componente.MetodoParaAñadirOyente(new NombreOyenteAdaptador() {
Se puede aprender mucho sobre los eventos asociándolos desde diseño y luego
mirando en el código generado.
EJERCICIO GUIADO. JAVA: VECTORES
Vectores en Java
El manejo de vectores en Java es similar al manejo de vectores en 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
tipodatos nombrevector[];
- tipodatos es el tipo de datos de los elementos del vector (int, double, String, etc.)
- nombrevector es el nombre que tu quieras darle a tu vector.
int v[];
Construcción de un vector
Para construir un vector que ya haya sido declarado se sigue la siguiente sintaxis:
Por ejemplo, si queremos que el vector v declarado antes tenga 10 elementos, tendremos
que hacer lo siguiente:
v = int[10];
En el momento de la construcción del vector, podemos usar una variable entera para
asignar el número de elementos que se quiera.
Por ejemplo, en el siguiente caso el número de elementos del vector v viene dado por la
variable num:
v = int[num];
Acceso a los elementos de un vector
Una vez declarado el vector y construido, este se puede usar de la misma manera que en C.
Se puede acceder a un elemento del vector escribiendo el nombre del vector y entre
corchetes el índice del elemento que quieres usar. Recuerda que los índices comienzan a
numerarse en 0.
Ejemplo 1:
Aquí se coloca en una etiqueta el valor contenido en el elemento de la posición cuarta del
vector v.
Ejemplo 2:
for (i=0;i<10;i++) {
v[i]=0;
}
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 (i=0;i<v.length;i++) {
v[i]=0;
}
Creación de un vector e inicialización con datos al mismo tiempo
Por ejemplo:
Ejemplo 2:
Este código crea un vector que contiene 7 cadenas, correspondientes a los días de la
semana.
VECTORES DE COMPONENTES
Esto es tremendamente útil cuando se tienen que definir muchos componentes con una
función parecida, y que tengan que ser tratados en conjunto.
Por otro lado, nos ahorra mucho tiempo ya que no se tienen que diseñar estos elementos en
la misma ventana de diseño.
Los vectores de componentes se usan igual que se ha indicado antes. Observa el siguiente
ejemplo:
for (i=0;i<veti.length;i++) {
veti[i]= new JLabel(); //se construye cada etiqueta
veti[i].setBounds(10,10+i*30,100,20); //se asigna posición y tamaño
veti[i].setText(“Etiqueta “+i); //se asigna un texto
this.getContentPane().add(veti[i]); //se coloca en la ventana
}
b. El texto que tendrá cada elemento será: “Opción 0”, “Opción 1”, etc…
vcuadros[i].setText(“Opción “+i);
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 ahora ejecutas el programa, verás que cada cuadro tiene su texto
correspondiente a un color.
10. Ahora añade un botón con su evento actionPerformed. Añade en la zona de variables
globales lo siguiente:
JButton btnAceptar;
12. En este código se puede observar como se usa un for para recorrer fácilmente el
vector de cuadros y averiguar cuales de ellos está activado. Aumentamos un
contador y lo demás es sencillo.
Si este programa se hubiera hecho desde diseño, el código para contar el número de
cuadros activados sería mucho más engorroso. Piénsalo.
13. Ejecuta el programa. Selecciona varios cuadros y pulsa el botón Aceptar. Observa el
resultado:
CONCLUSIÓN
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á como se pueden asignar eventos a los componentes de un vector.
Ejercicio guiado
Hay que tener en cuenta que cuando se pulse cualquiera de los botones, se ejecutará
el procedimiento botonesActionPerformed. Programa este procedimiento (fuera de
CreacionVentana, por supuesto) de la siguiente forma:
Este código resulta muy interesante. El parámetro evt tiene siempre un método
llamado getSource que devuelve el componente de la ventana sobre el que ha
sucedido el evento. De esta manera obtenemos el botón que ha sido pulsado.
(Observa que es necesario hacer un cast) Aprovechamos esto para introducir el
botón en una variable auxiliar que hemos llamado botonPulsado.
Luego solo hay que usar la variable botonPulsado como un botón normal y corriente.
Por ejemplo, la usamos en el JOptionPane mostrando el texto que contiene el botón
pulsado con el método getText.
Se pueden asignar eventos a los elementos de un vector a través de un for que recorra
los distintos elementos del vector y le asigne el evento o eventos necesarios.
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 posee unas características (ancho, alto, color, etc…) A las características de un objeto se
les llama propiedades.
En Java todo son objetos. Veamos algunos ejemplos de uso de objetos en Java:
Ejemplo 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 través de los métodos podemos por ejemplo cambiar las características del objeto. Por ejemplo, se
puede cambiar el tamaño y posición de la etiqueta usando el método setBounds:
etiTexto.setBounds(10,20,100,20);
Normalmente, los métodos que permiten cambiar las características del objeto son métodos cuyo
nombre empieza por set.
Los métodos también permiten pedirle al objeto que me de información. Por ejemplo, podríamos usar
el conocido método getText para recoger el texto que contenga la etiqueta y almacenarlo en una
variable:
String texto;
texto = etiTexto.getText();
Los métodos que le piden información al objeto suelen tener un nombre que empieza por get.
Los métodos también sirven para ordenarle al objeto que haga cosas. Por ejemplo, podemos ordenar
a la etiqueta etiTexto que se vuelva a pintar en la ventana usando el método repaint:
etiTexto.repaint();
Ejemplo 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 texto txtCuadro tiene
características propias: un color de fondo, un ancho, un alto, una posición en la ventana, el estar
activado o no, el estar visible o no, etc…
A un objeto se le puede dar órdenes, llamadas métodos. Estas órdenes nos permiten cambiar las
características del objeto, pedirle información, o simplemente pedirle al objeto que haga algo.
Por ejemplo, podemos cambiar el color de fondo del cuadro de texto txtCuadro usando el método
llamado setBackground:
txtCuadro.setBackground(Color.RED);
Otros métodos que permiten cambiar las propiedades del objeto txtCuadro son:
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:
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();
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.
Declarar un Objeto
Clase nombreobjeto;
Por ejemplo, para declarar la etiqueta del ejemplo 1, se usaría el siguiente código:
JLabel etiTexto;
Para declarar, en cambio, el cuadro de texto del ejemplo 2, se usaría el siguiente código:
JTextField txtCuadro;
Construir un Objeto
Es necesario construir el objeto para poder usarlo. La construcción del objeto se hace a través del
siguiente código general:
NOTA. En algunos casos, la sintaxis de la declaración y la construcción se une en una sola línea. Por
ejemplo, supongamos que queremos declarar la etiqueta etiTexto y construirla todo en una línea,
entonces se puede hacer lo siguiente:
En general, para declarar y construir un objeto en una sola línea se sigue la siguiente sintaxis:
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:
En el ejemplo se han declarado y construido tres etiquetas llamadas etiTexto, etiResultado y etiDato.
Las tres etiquetas en este momento son iguales, pero a través de los distintos métodos podemos dar
forma a cada una:
etiTexto.setBackground(Color.RED);
etiTexto.setText(“Hola”);
etiResultado.setBackground(Color.GREEN);
etiResultado.setText(“Error”);
etiDato.setBackground(Color.BLUE);
etiDato.setText(“Cadena”);
EJERCICIO
Hasta ahora ha usado objetos aunque no tenga mucha conciencia de ello. Por ejemplo ha usado
botones. Como ejercicio se propone lo siguiente:
- ¿Cuál es el nombre de la clase de los botones normales que usa en sus ventanas?
- ¿Cómo declararía un botón llamado btnAceptar, y otro llamado btnCancelar?
- ¿Cómo construiría dichos botones?
- Indique algunos métodos para cambiar propiedades de dichos botones (métodos set)
- Indique algunos métodos para pedirle información a dichos botones (métodos get)
- Indique algún método para dar órdenes a dichos botones (algún método que no sea ni set ni
get)
CONCLUSIÓN
Por otro lado, al objeto se le pueden dar órdenes que cumplirá de inmediato. A dichas
órdenes se les denomina MÉTODOS.
Declaración:
CLASE nombreobjeto;
Construcción:
Hasta el momento, todos los objetos que ha usado a la hora de programar en Java, han sido objetos
incluidos en el propio lenguaje, que se encuentran disponibles para que el programador los use en
sus programas.
Estos objetos son: las etiquetas (JLabel), botones (JButton), los cuadros de texto
(JTextField), cuadros de verificación (JCheckBox), botones de opción (JRadioButton),
colores (Color), imágenes de icono (ImageIcon), modelos de lista (DefaultListModel),
etc, etc.
Todos estos objetos, por supuesto, pertenecen cada uno de ellos a una Clase:
Las etiquetas son objetos de la clase JLabel, los botones son objetos de la clase
JButton, etc.
Todos estos objetos tienen propiedades que pueden ser cambiadas en la ventana de diseño:
Aunque también poseen métodos que nos permiten cambiar estas propiedades durante la ejecución
del programa:
setText cambia el texto del objeto, setBackground cambia el color de fondo del objeto,
setVisible hace visible o invisible al objeto, setBounds cambia el tamaño y la posición
del objeto, etc.
En cualquier momento le podemos pedir a un objeto que nos de información sobre sí mismo usando
los métodos get:
getText obtenemos el texto que tenga el objeto, getWidth obtenemos la anchura del
objeto, getHeight obtenemos la altura del objeto, etc.
Los objetos son como “pequeños robots” a los que se les puede dar órdenes, usando los métodos que
tienen disponible.
Por ejemplo, le podemos decir a un objeto que se pinte de nuevo usando el método
repaint, podemos ordenarle a un cuadro de texto que coja el cursor, con el método
requestFocus, etc.
Todos estos objetos, con sus propiedades y métodos, nos facilitan la creación de nuestros programas.
Pero a medida que nos vamos introduciendo en el mundo de la programación y nos especializamos
en un tipo de programa en concreto, puede ser necesaria la creación de objetos propios, programados
por nosotros mismos, de forma que puedan ser usados en nuestros futuros programas.
Objetos propios
A la hora de diseñar un objeto de creación propia, tendremos que pensar qué propiedades debe tener
dicho objeto, y métodos serán necesarios para poder trabajar con él. Dicho de otra forma, debemos
pensar en qué características debe tener el objeto y qué órdenes le podré dar.
Para crear objetos propios hay que programar la Clase del objeto. Una vez programada la Clase, ya
podremos generar objetos de dicha clase, declarándolos y construyéndolos como si de cualquier otro
objeto se tratara.
A continuación se propondrá un caso práctico de creación de objetos propios, con el que trabajaremos
en las próximas hojas.
Planteamiento
Los Multicines Avenida nos encargan un programa para facilitar las distintas gestiones que se realizan
en dichos multicines.
El multicine cuenta con varias salas, y cada una de ellas genera una serie de información. Para
facilitar el control de la información de cada sala programaremos una Clase de objeto a la que
llamaremos SalaCine.
La Clase SalaCine
La Clase SalaCine definirá características de una sala de cine, y permitirá crear objetos que
representen salas de cine. Cuando la Clase SalaCine esté programada, se podrán hacer cosas como
las que sigue:
Los Multicines Avenida tienen una sala central donde se proyectan normalmente los estrenos. Se
podría crear un objeto llamado central de la clase SalaCine de la siguiente forma:
SalaCine central;
Por supuesto, este objeto puede ser construido como cualquier otro:
Otro ejemplo. Los Multicines Avenida tienen una sala donde proyectan versiones originales. Se podría
crear un objeto llamado salaVO de la clase SalaCine de la siguiente forma:
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):
Cuando se construye un objeto, se asignan unos valores por defecto a sus propiedades. Por ejemplo,
cuando se construye una etiqueta (Clase JLabel), esta tiene un tamaño inicial definido, un color, etc.
Lo mismo se tiene que hacer con los objetos propios que definimos. Es necesario decidir qué valores
tendrá las propiedades del objeto al construirse.
En nuestro caso, las características de un objeto SalaCine en el momento de construirse serán las
siguientes:
Aforo: 100
Ocupadas: 0
Película: “” (la cadena vacía)
Entrada: 5,00
Observa este código, en él construimos el objeto correspondiente a la sala central del multicine:
SalaCine central;
En este momento (en el que el objeto central está recién construido) este objeto tiene asignado un
aforo de 100, el número de butacas ocupadas es 0, la película que se proyecta en la sala central es “”
y la entrada para esta sala es de 5 euros.
Los valores por defecto que se asignan a los objetos de una clase son valores arbitrarios que el
programador decidirá según su conveniencia.
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:
Gracias a estos métodos podemos dar forma a un objeto SalaCine recién creado.
Por ejemplo, supongamos que queremos crear el objeto que representa la sala de versiones
originales. Resulta que esta sala tiene de aforo 50 localidades, que se está proyectando la película
“Metrópolis” y que la entrada para ver la película es de 3 euros. La sala está vacía de momento.
Para crear el objeto, se usaría el siguiente código:
Al construir el objeto salaVO tiene por defecto los valores siguientes en sus propiedades:
Aforo: 100
Ocupadas: 0
Película: “”
Entrada: 5,00
Aforo: 50
Ocupadas: 0
Película: “Metrópolis”
Entrada: 3,00
Estos métodos nos permitirán obtener información de un objeto del tipo SalaCine. Por ejemplo,
supongamos que tenemos el objeto llamado central (correspondiente a la sala principal del multicine),
para obtener la película que se está proyectando en dicha sala solo habría que usar este código:
O, por ejemplo, para saber los ingresos producidos por la sala central…
double ingresos;
ingresos = central.getIngresos();
Se programarán los siguientes métodos para dar órdenes a los objetos de la clase SalaCine.
vaciar
- 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
Aforo: 100
Ocupadas: 0
Película: (cadena vacía)
Entrada: 5
Métodos de orden
Supongamos que programamos una Clase de objetos llamada Rectangulo, la cual permitirá construir
objetos que representen a rectángulos.
2. Supongamos que las propiedades de los objetos de la clase Rectangulo sean las siguientes:
a. Base (double)
b. Altura (double)
¿Qué métodos de tipo set programaría para cambiar las propiedades de los objetos del tipo
Rectangulo?
3. Como ejemplo de los métodos anteriores, suponga que quiere asignar al objeto suelo una
base de 30 y una altura de 50. ¿Qué código usaría?
4. Teniendo en cuenta que nos puede interesar conocer el área de un objeto Rectangulo y su
perímetro, y teniendo en cuenta que los objetos Rectangulo tienen dos propiedades (Base y
Altura), ¿qué cuatro métodos get serían interesantes de programar para los objetos del tipo
Rectangulo?
5. Teniendo en cuenta los métodos del punto 4. Supongamos que quiero almacenar en una
variable double llamada area el área del objeto suelo. ¿Qué código usaría? Y si quiero
almacenar el perímetro del objeto suelo en una variable llamada peri?
CONCLUSIÓN
Valores iniciales que tendrán las propiedades cuando se construya cada objeto.
Una vez que se tenga claro lo anterior, se podrá empezar la programación de la Clase
de objetos.
EJERCICIO GUIADO. JAVA: POO. PROGRAMACIÓN DE UNA CLASE
En este ejercicio guiado, crearemos la Clase SalaCine, que hemos descrito en la hoja anterior. Luego,
a partir de esta clase, fabricaremos objetos representando salas de cine, y los usaremos en un
proyecto Java.
Recuerda las características que hemos decidido para la Clase SalaCine en la hoja anterior:
CLASE SALACINE
Aforo: 100
Ocupadas: 0
Película: (cadena vacía)
Entrada: 5
Métodos de orden
Fichero de la Clase
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)
La programación de una clase comienza siempre con una línea de código como la que sigue:
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 Ocupadas;
String Película;
double Entrada;
Constructor de la Clase
Cuando se planteó la clase SalaCine, se tuvo que decidir qué valores iniciales deberían tener las
propiedades de la clase. Para asignar estos valores iniciales, es necesario programar lo que se
denomina el Constructor.
El Constructor de una clase es un método (un procedimiento para entendernos) un poco especial, ya
que debe tener el mismo nombre de la clase y no devuelve nada, pero no lleva la palabra void. Dentro
del constructor se inicializan las propiedades de la clase.
public NombreDeLaClase() {
propiedad1 = valor;
propiedad2 = valor;
etc…
}
int Aforo;
int Ocupadas;
String Película;
double Entrada;
//Constructor
public SalaCine() {
Aforo = 100;
Ocupadas = 0; Constructor
Pelicula = “”;
Entrada = 5.0;
}
Observa como usamos el constructor de la clase SalaCine para asignar a cada propiedad los valores
por defecto decididos en el diseño de la clase que se hizo en la hoja anterior.
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.
Aforo = afo;
- Es void, es decir, no devuelve nada (el significado de la palabra public se verá más adelante)
- El método recibe como parámetro una variable del mismo tipo que la propiedad que
queremos modificar (en este caso int) y un nombre que se recomienda que no sea igual al de
la propiedad (en nuestro caso, afo, de aforo)
- Puedes observar que lo que se hace simplemente en el método es asignar la variable pasada
como parámetro a la propiedad.
La mayoría de los procedimientos set usados para introducir valores en las propiedades tienen la
misma forma. Aquí tienes la programación de los demás procedimientos set de la clase SalaCine.
//Método setOcupadas
public void setOcupadas(int ocu) {
Ocupadas = ocu;
}
//Método setPelicula
public void setPelicula(String peli) {
Pelicula = peli;
}
//Método setEntrada
public void setEntrada(double entra) {
Entrada = entra;
}
Hay un método set de la clase SalaCine llamado setLibres cuya misión es asignar el número de
localidades libres del cine. Sin embargo la clase SalaCine no tiene una propiedad “Libres”. En
realidad, este método debe modificar el número de localidades ocupadas. Observa su programación:
//Método setLibres
public void setLibres(int lib) {
int ocu;
No se pensó en crear una propiedad de la clase llamada Libres ya que en todo momento se puede
saber cuantas localidades libres hay restando el Aforo menos las localidades Ocupadas.
int Aforo;
int Ocupadas;
String Película;
double Entrada;
//Constructor
public SalaCine() {
Aforo = 100;
Ocupadas = 0;
Pelicula = “”;
Entrada = 5.0;
}
//Métodos set
//Método setAforo
public void setAforo(int afo) {
Aforo = afo;
}
//Método setOcupadas
public void setOcupadas(int ocu) {
Ocupadas = ocu;
}
//Método setPelicula
public void setPelicula(String peli) {
Pelicula = peli; Métodos Set
}
//Método setEntrada
public void setEntrada(double entra) {
Entrada = entra;
}
//Método setLibres
public void setLibres(int lib) {
int ocu;
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.
Como puedes ver el método simplemente devuelve el valor de la propiedad Aforo. Como esta
propiedad es int, el método es int.
Los métodos que devuelven el resto de las propiedades son igual de sencillos de programar:
//Método getOcupadas
public int getOcupadas() {
return Ocupadas;
}
//Método getPelicula
public String getPelicula() {
return Película;
}
//Método getEntrada
public double getEntrada() {
return Entrada;
}
Todos estos métodos son iguales. Solo tienes que fijarte en el tipo de datos de la propiedad que
devuelven.
Existen otros métodos get que devuelven cálculos realizados con las propiedades. Estos métodos
realizan algún cálculo y luego devuelven el resultado. Observa el siguiente método get:
//Método getLibres
public int getLibres() {
int lib;
lib = Aforo – Ocupadas;
return lib;
}
No existe una propiedad Libres, por lo que este valor debe ser calculado a partir del Aforo y el número
de localidades Ocupadas. Para ello restamos y almacenamos el valor en una variable a la que hemos
llamado lib. Luego devolvemos dicha variable.
Los dos métodos get que quedan por programar de la clase SalaCine son parecidos:
//Método getPorcentaje
public double getPorcentaje() {
double por;
por = (double) Ocupadas / (double) Aforo * 100.0;
return por;
}
//Método getIngresos
public double getIngresos() {
double ingre;
ingre = Ocupadas * Entrada;
return ingre;
}
Los ingresos se calculan multiplicando el número de entradas por lo que vale una entrada.
La clase SalaCine una vez introducidos los métodos get quedaría de la siguiente forma:
int Aforo;
int Ocupadas;
String Película;
double Entrada;
//Constructor
public SalaCine() {
Aforo = 100;
Ocupadas = 0;
Pelicula = “”;
Entrada = 5.0;
}
//Métodos set
//Método setAforo
public void setAforo(int afo) {
Aforo = afo;
}
//Método setOcupadas
public void setOcupadas(int ocu) {
Ocupadas = ocu;
}
//Método setPelicula
public void setPelicula(String peli) {
Pelicula = peli;
}
//Método setEntrada
public void setEntrada(double entra) {
Entrada = entra;
}
//Método setLibres
public void setLibres(int lib) {
int ocu;
//Métodos get
//Método getAforo
public int getAforo() {
return Aforo; Métodos Get
}
//Método getOcupadas
public int getOcupadas() {
return Ocupadas;
}
//Método getPelicula
public String getPelicula() {
return Película;
}
//Método getEntrada
public double getEntrada() {
return Entrada;
} Métodos Get
//Método getLibres
public int getLibres() {
int lib;
lib = Aforo – Ocupadas;
return lib;
}
//Método getPorcentaje
public double getPorcentaje() {
double por;
por = (double) Ocupadas / (double) Aforo * 100.0;
return por;
}
//Método getIngresos
public double getIngresos() {
double ingre;
ingre = Ocupadas * Entrada;
return ingre;
}
Métodos de orden
Para finalizar la programación de la clase SalaCine, se programarán los dos métodos de orden que
hemos indicado en el planteamiento de la clase. Estos métodos suelen realizar alguna tarea que
involucra a las propiedades de la clase, modificándola internamente. No suelen devolver ningún valor,
aunque pueden recibir parámetros.
Veamos la programación del método Vaciar, cuyo objetivo es vaciar la sala y quitar la película en
proyección:
//Método Vaciar
public void Vaciar() {
Ocupadas = 0;
Película = “”;
}
Como se puede observar, es un método muy sencillo, ya que simplemente cambia algunas
propiedades de la clase.
El método entraUno es también muy sencillo de programar. Este método le indica al objeto que ha
entrado un nuevo espectador. Sabiendo esto, el objeto debe aumentar en uno el número de
localidades ocupadas:
//Método entraUno
public void entraUno() {
Ocupadas++;
}
Añadiendo estos dos últimos métodos, la programación de la clase SalaCine quedaría finalmente
como sigue:
public class SalaCine {
int Aforo;
int Ocupadas;
String Película; Propiedades (variables globales)
double Entrada;
//Constructor
public SalaCine() {
Aforo = 100;
Ocupadas = 0; Constructor
Pelicula = “”;
Entrada = 5.0;
}
//Métodos set
//Método setAforo
public void setAforo(int afo) {
Aforo = afo;
}
//Método setOcupadas
public void setOcupadas(int ocu) {
Ocupadas = ocu;
}
//Método setPelicula
public void setPelicula(String peli) {
Pelicula = peli; Métodos Set
}
//Método setEntrada
public void setEntrada(double entra) {
Entrada = entra;
}
//Método setLibres
public void setLibres(int lib) {
int ocu;
//Método getAforo
public int getAforo() {
return Aforo;
}
//Método getOcupadas
public int getOcupadas() {
Métodos Get
return Ocupadas;
}
//Método getPelicula
public String getPelicula() {
return Película;
}
//Método getEntrada
public double getEntrada() {
return Entrada;
}
//Método getLibres
public int getLibres() {
int lib;
lib = Aforo – Ocupadas;
return lib;
}
//Método getPorcentaje
public double getPorcentaje() {
double por;
por = (double) Ocupadas / (double) Aforo * 100.0;
return por;
}
//Método getIngresos
public double getIngresos() {
double ingre;
ingre = Ocupadas * Entrada;
return ingre;
}
//Métodos de orden
//Método Vaciar
public void Vaciar() {
Ocupadas = 0;
Película = “”; Métodos de orden y otros
} métodos.
//Método entraUno
public void entraUno() {
Ocupadas++;
}
}
EJERCICIOS RECOMENDADOS
Supongamos que tenemos una clase llamada Rectangulo que nos permitirá generar objetos de tipo
rectángulo.
CLASE RECTANGULO
Base (double)
Altura (double)
Base – 100
Altura – 50
Métodos:
Métodos set:
Métodos get:
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
Constructor
Métodos set
Métodos get
Los métodos set son void y reciben como parámetro un valor que se asigna a la
propiedad correspondiente.
Los métodos de orden realizan alguna tarea específica y a veces modifican las
propiedades de la clase de alguna forma.
EJERCICIO GUIADO. JAVA: POO. USAR CLASES PROPIAS EN UN PROYECTO
Una vez programada una Clase de creación propia, podremos usar esta en uno de nuestros proyectos
para crear objetos de dicha clase. En este ejercicio guiado veremos un ejemplo sobre cómo usar de
forma práctica la clase SalaCine en un proyecto java hecho con NetBeans.
EJERCICIO GUIADO
El Multicines Avenida nos encarga un programa para gestionar el funcionamiento de las dos salas
con las que cuenta este pequeño multicines.
La primera de las salas es la “sala central”. En ella se proyectan los estrenos. Es una sala grande,
con 500 localidades. El precio para ver una película en esta sala es de 8.00 euros.
La segunda de las salas es la “sala de versiones originales”. En esta sala se proyectan películas
clásicas en versión original. Es una sala con un aforo más pequeño, concretamente, de 80
localidades. El precio para ver una película en esta sala es de 6.00 euros.
Se creará un programa que nos permita controlar la entrada de personas en las salas y podremos
saber en todo momento el porcentaje de ocupación de cada sala y los ingresos obtenidos.
1. Crear un nuevo proyecto. Este proyecto se llamará multicines, contendrá un paquete llamado
paqueteprincipal y este a su vez contendrá un JFrame llamado ventanaprincipal. El aspecto
de la estructura del proyecto al crearlo será la siguiente:
2. Diseñar la ventana principal de forma que quede parecida a la siguiente. Usa la ventana de
diseño para hacer el diseño del formulario. Los nombres de los componentes se indica a
continuación.
Botones:
btnCentralNueva Etiqueta:
btnCentralOcupacion
btnCentralVaciar etiCentralPelicula
btnCentralIngresos
btnCentralCambiar
Panel:
panelCentral
Panel:
panelVOriginal
Botones:
Etiqueta:
Botón
btnOriginalNueva
etiOriginalPelicula
btnOriginalOcupacion btnIngresosTotales
btnOriginalVaciar
btnOriginalIngresos
btnOriginalCambiar
3. Antes de empezar la programación de cada botón del programa, incluiremos en el proyecto la
clase SalaCine, para así poder generar objetos del tipo “sala de cine” y aprovecharlos en
nuestro programa.
4. Para añadir un fichero de clase propio en un proyecto Java con NetBeans, debes hacer clic
con el botón derecho sobre el paquete donde quieras introducir la clase. En nuestro caso,
haremos clic con el botón derecho sobre el paqueteprincipal, que es el único que tenemos:
6. Entonces tendremos que darle un nombre a nuestro fichero de clase. Recuerda que el
nombre debe ser el mismo que el de la clase que queremos programar. En nuestro caso,
SalaCine. Luego se pulsa el botón Terminar.
7. Si vuelves a observar el esquema del proyecto, verás que dentro del paquete principal ha
aparecido un nuevo elemento, llamado SalaCine. Este es el fichero donde programaremos
nuestra clase SalaCine.
8. Si haces doble clic sobre el fichero SalaCine.java, podrás ver en el centro de la ventana de
NetBeans el código de dicha clase. NetBeans añade cierto código a la clase para ahorrarnos
trabajo, por eso ya tendremos programado la instrucción inicial de la clase junto con el
comienzo del constructor y algunos comentarios que se añaden automáticamente:
Esta instrucción, generada por NetBeans,
indica que la clase SalaCine está
programada dentro del paqueteprincipal
Inicio de la clase
package paqueteprincipal;
/**
*
* @author didact
*/
public class SalaCine {
//propiedades
int Aforo;
int Ocupadas;
String Pelicula;
double Entrada;
//Métodos set
//Método setAforo
public void setAforo(int afo) {
Aforo = afo;
}
//Método setOcupadas
public void setOcupadas(int ocu) {
Ocupadas = ocu;
}
//Método setPelicula
public void setPelicula(String peli) {
Pelicula = peli;
}
//Método setEntrada
public void setEntrada(double entra) {
Entrada = entra;
}
//Método setLibres
public void setLibres(int lib) {
int ocu;
ocu = Aforo - lib;
Ocupadas = ocu;
}
//Métodos get
//Método getAforo
public int getAforo() {
return Aforo;
}
//Método getOcupadas
public int getOcupadas() {
return Ocupadas;
}
//Método getPelicula
public String getPelicula() {
return Pelicula;
}
//Método getEntrada
public double getEntrada() {
return Entrada;
}
//Método getLibres
public int getLibres() {
int lib;
lib = Aforo – Ocupadas;
return lib;
}
//Método getPorcentaje
public double getPorcentaje() {
double por;
por = (double) Ocupadas / (double) Aforo * 100.0;
return por;
}
//Método getIngresos
public double getIngresos() {
double ingre;
ingre = Ocupadas * Entrada;
return ingre;
}
//Métodos de orden
//Método Vaciar
public void Vaciar() {
Ocupadas = 0;
Pelicula = "";
}
//Método entraUno
public void entraUno() {
Ocupadas++;
}
}
10. Ya hemos incluido la clase SalaCine en nuestro proyecto. A partir de ahora podremos crear
objetos del tipo SalaCine y aprovechar sus características en nuestro programa.
11. Empezaremos a programar la ventana principal de nuestro programa. Haz doble clic sobre el
fichero ventanaprincipal.java en la ventana de proyectos para pasar al diseño de la ventana
principal:
12. Nuestro programa principal, gestiona el funcionamiento de dos salas de cine: la sala central y
la sala de versiones originales. Para facilitar nuestro trabajo, sería interesante crear dos
objetos globales del tipo SalaCine. Uno de ellos representará la sala central, y el otro la sala
de versiones originales.
14. En la zona de variables globales de la ventana principal declararemos dos objetos del tipo
SalaCine:
16. Recuerda que cuando se construyen objetos, estos tienen por defecto unos valores iniciales.
En el caso de los objetos tipo SalaCine, sus valores son los siguientes:
Será necesario modificar las características de ambas salas ya que no tienen ahora mismo
los valores correctos.
Se dijo al comenzar el ejercicio que la sala central tenía las siguientes características:
Por lo tanto, modificamos las características del objeto en el constructor de la siguiente forma:
Modificamos las
características del objeto
central (sala central)
17. En el caso de la sala de versión original sucede lo mismo. Sus características son la
siguientes:
Por tanto será necesario modificar el objeto vo para asignar estos valores:
Modificamos las
características del objeto
vo (sala versión original)
18. Ya hemos incluido dos objetos del tipo SalaCine en nuestro proyecto. Los hemos declarado
en la ventana principal como globales y los hemos construido dándoles las características
apropiadas. A partir de ahora, usaremos esos objetos en la programación de cada botón de la
ventana.
Cambia el título
de la película de
la sala central.
- Luego se asigna dicho título a la sala central del multicines. Esta línea es interesante, ya que
se usa el método setPelicula del objeto central para asignar el título de la película.
Cada vez que un espectador compre una entrada para la sala central, el usuario del programa
deberá pulsar este botón. Internamente, el programa debe decirle al objeto central que ha
entrado una nueva persona en la sala. Esto se hace con el método entraUno.
Como puedes ver, simplemente se le informa al objeto central (sala central) que ha entrado
una nueva persona usando el método entraUno.
23. Programaremos ahora el botón btnCentralOcupacion. Este botón nos mostrará información
sobre la sala central. Concretamente, este botón debe mostrar lo siguiente:
Para mostrar toda esta información, será necesario pedirle al objeto central (sala central) que
nos de información de la sala. Esto lo conseguiremos usando los distintos métodos get del
objeto.
24. Ejecuta el programa para observar el funcionamiento de los tres botones que se han
programado. Asigna una película a la sala central, luego pulsa varias veces el botón Nueva
Venta y pulsa el botón %Ocupación para ver información sobre la sala:
Cambia el título
de la película
asignada a la sala
central
Como puedes observar, el código es muy simple. Solo tengo que ordenar al objeto central
(sala central) que se vacíe. Debido a que ya no hay película asignada a la sala central, es
conveniente también borrar el contenido de la etiqueta que muestra el título de la película.
26. Programaremos ahora el botón Ingresos del panel de la sala central. Este botón nos debe dar
información sobre los ingresos producidos por la sala en el momento en que se pulsa. Esta
información la mostraremos en un JOptionPane. Programa el actionPerformed de este botón
como sigue:
Como puedes ver, la programación es bastante sencilla. Solo hay que pedirle al objeto central
(sala central) que nos diga los ingresos correspondientes.
Observa la ventaja de usar objetos. No tenemos que hacer ningún cálculo aquí. Solo tenemos
que pedirle al objeto que haga el cálculo necesario por nosotros. Dicho de otra forma,
hacemos que ellos hagan el trabajo por nosotros.
27. Ejecuta el programa para comprobar el funcionamiento de estos botones. Asigna una película
a la sala central, vende algunas entradas, comprueba el porcentaje de ocupación y luego
comprueba los ingresos. Vacía la sala central, y vuelve a comprobar el porcentaje de
ocupación y los ingresos actuales.
Asigna una película y …luego comprueba el …prueba a vaciar la sala y
vende varias % de ocupación y los luego vuelve a comprobar
entradas… ingresos… la ocupación y los
ingresos…
EJERCICIO
La programación es prácticamente igual, solo hay que actuar sobre el objeto vo en vez del objeto
central.
EJERCICIO
Al hacer esto, en el mismo proyecto podemos crear objetos de dichas clases y usarlos
para hacer el programa.
En general, un proyecto java está constituido por un grupo de clases, algunas de las
cuales serán de creación propia. En el programa usaremos objetos derivados de
dichas clases.
EJERCICIO GUIADO. JAVA: POO. HERENCIA
Concepto de Herencia
El concepto de Herencia consiste en crear una nueva Clase a partir de otra. La nueva Clase es una
mejora de la anterior. O dicho de otra manera, es una especialización de la primera Clase.
Concretamente, la Herencia consiste en tomar una Clase inicial, y, a partir de ella, crear otra Clase
que posee las mismas propiedades y métodos que la Clase inicial, además de unas nuevas
propiedades y métodos que la Clase inicial no poseía. La nueva Clase creada puede incluso redefinir
métodos de la Clase inicial.
CLASE BASE
Herencia
CLASE
DERIVADA
La Clase inicial se denomina Clase Base, la Clase creada a partir de la clase base se denomina Clase
Derivada. La Clase Derivada contiene propiedades y métodos de la Clase Base más unas
propiedades y métodos añadidos.
La Herencia es una técnica muy útil que nos permite reutilizar código, es decir, que nos permite usar
de nuevo lo que ya teníamos programado añadiendo simplemente algunos cambios adecuar el código
al proyecto actual.
La Herencia se puede aplicar tanto a Clases Propias, como a Clases propias del lenguaje de
programación Java.
En esta explicación guiada, veremos un ejemplo de uso de la Herencia con clases propias del
lenguaje Java.
EJERCICIO GUIADO
Planteamiento Inicial
“Botones Contadores”
Supongamos que en los proyectos cotidianos se plantea la necesidad de usar botones que guarden el
número de veces que son pulsados. Estos botones funcionarían exactamente igual que los botones
normales (JButton) y tendrían su mismo aspecto, pero sería interesante que además tuvieran los
siguientes métodos:
Método setPulsaciones.
Permitirá asignar un número de pulsaciones al botón.
btnContar.setPulsaciones(3);
//Se asignan 3 pulsaciones al botón btnContar
Método getPulsaciones.
Permitirá saber cuantas pulsaciones tiene un botón.
int p = btnContar.getPulsaciones(3);
//Se recoge el número de pulsaciones del botón btnContar
//en la variable p
Método incrementa.
Permite incrementar en uno las pulsaciones que tiene un botón.
btnContar.incrementa();
//Incrementa en uno las pulsaciones del botón btnContar
Método decrementa.
Permite decrementar en uno las pulsaciones que tiene un botón
btnContar.decrementa();
//Decrementa en uno las pulsaciones del botón btnContar
Método reiniciar.
Permite colocar las pulsaciones de un botón a cero.
btnContar.reiniciar();
//Sitúa a cero las pulsaciones del botón btnContar
Método aumentar.
Permite aumentar en una determinada cantidad las pulsaciones del botón.
btnContar.aumentar(4);
//Aumenta en cuatro las pulsaciones del botón btnContar
Método disminuir.
Permite disminuir en una determinada cantidad las pulsaciones del botón.
btnContar.disminuir(6);
//Disminuye en 6 las pulsaciones del botón btnContar
Los botones de este tipo tendrían una propiedad llamada pulsaciones de tipo entera que se
inicializaría a cero en el momento de construir el botón.
Desgraciadamente no existe un botón de este tipo en Java, así que no podemos acudir a la
ventana de diseño y añadir un botón como este.
Una posibilidad sería la de programar la clase correspondiente a un botón de este tipo desde cero,
pero esto es un trabajo tremendamente complejo.
La idea es crear una nueva clase a partir de la clase JButton. A esta nueva clase la llamaremos
BotonContador y haremos que herede de la clase JButton. Por tanto, la clase BotonContador tendrá
todas las características de los JButton y además le añadiremos los métodos mencionados antes.
JButton
Herencia
BotonContador
Gracias a la herencia, nuestra clase BotonContador poseerá todos los métodos de los JButton
(setText, getText, setForeground, setToolTipText, etc.) sin que tengamos que programar estos
métodos.
Por otro lado, añadiremos a la clase BotonContador nuestros propios métodos (setPulsaciones,
getPulsaciones, etc) y propiedades para que la clase esté preparada para nuestras necesidades.
Resumiendo: programaremos un botón propio, con características necesarias para nuestro trabajo,
aprovechando las características de un botón JButton.
Se comenzará definiendo el comienzo de la clase y añadiendo las llaves que limitan su contenido:
Observa el código añadido: extends JButton antes de la llave de apertura. Este es el código que
le permite indicar a Java que nuestra clase BotonContador derivará de la clase JButton.
Creación de las propiedades de la clase derivada
La clase BotonContador es una clase derivada de la clase JButton, y tendrá las mismas propiedades
que la clase JButton, pero a nosostros nos interesa añadir nuestras propias propiedades. En nuestro
caso, necesitaremos una variable que contenga el número de pulsaciones del botón en todo
momento.
int pulsaciones;
Nuestra propiedad pulsaciones debe ser inicializada en el constructor de la clase. Para ello crea el
constructor de la clase:
int pulsaciones;
public BotonContador() {
pulsaciones=0;
}
Se añadirán los nuevos métodos que queremos que la clase BotonContador posea. Estos son los
siguientes:
Estos métodos trabajan con la propiedad pulsaciones. Una vez programados estos métodos, la clase
quedará de la siguiente forma (observa la programación de los distintos métodos para entenderlos):
public class BotonContador extends JButton {
//propiedades
int pulsaciones;
//constructor
public BotonContador() {
pulsaciones=0;
}
//métodos
Como has podido observar, la creación de una clase heredada es exactamente igual que la creación
de una clase propia. La única diferencia es que hacemos que dicha clase herede de otra clase ya
existente, dándole más posibilidades sin necesidad de programar nada:
Usaremos la clase BotonContador en un simple proyecto de prueba para que puedas observar sus
posibilidades.
2. Añadiremos la Clase BotonContador. Para ello debes hacer clic con el botón derecho sobre el
paqueteprincipal y activar la opción Nuevo Clase Java. El nombre de la clase es
BotonContador:
package paqueteprincipal;
import javax.swing.JButton;
/**
*
* @author didact
*/
public class BotonContador extends JButton {
//propiedades
int pulsaciones;
//constructor
public BotonContador() {
pulsaciones=0;
}
6. Nuestro programa tendrá dos botones del tipo BotonContador. Declara estos botones como
variables globales de la clase:
9. Ejecuta el programa y observa el resultado. Verás que en la ventana aparecen los dos
botones contadores, sin embargo, observarás que tienen el mismo aspecto que los JButton.
Se vuelve a insistir que esto es debido a que la clase BotonContador deriva de la clase
JButton.
10. Ahora se añadirá un actionPerformed a cada botón contador, para controlar sus pulsaciones.
Añade al final de CreacionVentana el siguiente código ya conocido, para la asignación de
eventos actionPerformed a los botones:
11. Se tendrán que programar los procedimientos de respuesta a los eventos, que aquí se han
llamado PulsacionBotonA y PulsacionBotonB. Prográmalos (fuera de CreacionVentana, claro
está) de la siguiente forma:
12. Cada vez que se pulse el botón A, debería aumentar su contador interno de pulsaciones en
uno. Lo mismo debería pasar con el botón B. Esto se hace fácilmente usando el método
incrementa, propio de los botones contadores:
13. Resumiendo, cada vez que se pulsa el botón A, se le da la orden al botón A de que se
incremente su contador interno. Lo mismo sucede con el botón B.
14. Ahora programaremos dos botones más en la ventana, pero estos serán botones normales y
los crearemos desde la ventana de diseño, para facilitar la tarea. Estos botones se llamarán
btnVerPulsaciones y btnReiniciar.
15. Cuando se pulse el botón Ver Pulsaciones debería aparecer un JOptionPane indicando
cuantas veces se ha pulsado el botón A y cuantas el B. Esto se hará simplemente pidiendo a
cada botón su número de pulsaciones almacenadas.
En este botón le pedimos al Botón A que nos diga cuantas pulsaciones tiene anotadas (a
través del método getPulsaciones) y lo mismo hacemos con el Botón B. Esto es posible ya
que ambos botones son del tipo BotonContador, la clase heredada que hemos programado.
- Pulsa varias veces el botón A y el B. Verás que no sucede nada (aunque internamente cada
uno de los botones está guardando el número de pulsaciones en su propiedad pulsaciones)
- Pulsa ahora el botón Ver Pulsaciones y comprobarás como este botón te muestra las veces
que pulsaste cada botón.
Pulsa los botones varias
veces…
Aparecerá un JOptionPane
informando sobre las
pulsaciones realizadas.
17. Ahora programaremos el botón Reiniciar de forma que los contadores internos de ambos
botones A y B se pongan a cero.
19. Puedes comprobar el funcionamiento de este botón ejecutando el programa y pulsando varias
veces los botones A y B. Luego mira las pulsaciones almacenadas en ambos botones. Pulsa
el botón Reiniciar y comprueba las pulsaciones de nuevo. Deberían ser cero en ambos
botones.
Después de pulsar los
botones A y B…
… si se pulsa el botón
Reiniciar…
EJERCICIO
- Añade desde código un nuevo botón Botón C (de tipo BotonContador) que al pulsarse
aumente su número de pulsaciones interno en 2 (usa el método aumentar propio de la clase
BotonContador).
- Cuando se pulse el botón Ver Pulsaciones también debería verse el número de pulsaciones
del botón C.
- Cuando se pulse Reiniciar, el número de pulsaciones del Botón C debería situarse a cero
también.
- Añade desde diseño un cuadro de texto y un botón normal (JButton) llamado Iniciar. En el
cuadro de texto se introducirá un número, y al pulsar el botón Iniciar, los valores internos de
los tres botones A, B y C se inicializarán al número introducido:
Se introduce un número…
La Herencia consiste en crear una clase que obtenga todas las características de otra.
Esta clase a su vez tendrá también características propias.
La clase inicial se denomina clase Base y la clase nueva creada a partir de la clase
base se llama clase Derivada:
CLASE BASE
Herencia
CLASE
DERIVADA
Se puede hacer que una clase de creación propia derive o herede de otra ya existente
añadiendo:
extends NombreClaseBase
Reutilización de código
La gran ventaja de la Herencia es la posibilidad de aprovechar Clases ya creadas (bien sea por
nosotros mismos o por otros programadores) para crear nuevas Clases. De esta forma, no tenemos
que crear la nueva Clase desde el principio, y solo tenemos que añadir algunos cambios a la Clase
original, sin que esta se vea afectada.
De esta manera, podemos tomar Clases de las librerías de Java y crear a partir de ellas nuevas
Clases para nuestras necesidades específicas. Estas clases luego pueden ser incluidas fácilmente en
futuros proyectos.
Como ejemplo de todo esto, crearemos un cuadro de diálogo propio que puede ser usado muy a
menudo en nuestros proyectos. Concretamente, será un cuadro de diálogo que nos permita introducir
una fecha (dia / mes / año)
Debes tener en cuenta que los cuadros de diálogo son objetos de la clase JDialog, por lo que este
cuadro de diálogo propio tendrá que derivar (heredar) de la clase JDialog.
La clase JDialog se comporta como una ventana (un JFrame) así que su programación es
relativamente sencilla.
Veremos el caso concreto de programar un Cuadro de Diálogo Propio a través del ejercicio guiado
que viene a continuación.
EJERCICIO GUIADO
1. Crea un proyecto llamado Fecha, que tenga un paquete principal llamado paqueteprincipal y
un JFrame llamado ventanaprincipal:
2. Para crear un cuadro de diálogo propio, debes hacer clic con el botón derecho del ratón sobre
el paquete principal y activar la opción Nuevo – Archivo/Carpeta. A través de esta opción
accedemos a un menú desde donde podemos añadir a nuestro proyecto distintos tipos de
clases.
6. Es interesante que veas el código de esta clase. Haz doble clic sobre ella:
Si observas el código verás que es muy similar al de las Clases JFrame, es decir, a la de la
clase de la ventana principal.
Debes observar que la clase dialogoFecha que vas a crear es heredada de JDialog, y también
verás que hay un constructor similar al de los JFrame, aunque con parámetros:
Hereda de JDialog
Constructor
7. Además, tenemos la ventaja de poder usar la ventana de diseño para crear nuestro cuadro de
diálogo dialogoFecha:
8. Usaremos la ventana de diseño para darle forma a nuestro cuadro de diálogo. Recuerda que
la finalidad de este cuadro de diálogo será la de permitirle al usuario introducir una fecha.
Diséñalo para que quede así:
9. Asigna nombre a cada elemento:
10. Como ves, hasta ahora la creación de un cuadro de diálogo propio es algo muy sencillo, ya
que es muy similar a la creación de una ventana. En este proceso (al igual que en la creación
de una ventana) participa el concepto de herencia.
11. Ahora hay que dotar a nuestro cuadro de diálogo de las propiedades y los métodos
necesarios para que sea fácil de usar. Antes de programar todo esto, aquí tienes una
descripción de lo que queremos añadir al cuadro de diálogo:
Propiedades:
Dia - entero
Mes - entero
Anio - entero
BotonPulsado - entero
Métodos:
getFecha()
- Este método devolverá una cadena (String) con la fecha en este formato:
dia/mes/año
getFechaLarga()
getBotonPulsado()
12. Bien, empecemos. Programar las propiedades es algo sencillo, ya que son simplemente
variables globales a la clase dialogoFecha:
Propiedades de la clase
dialogoFecha
13. Cuando el usuario pulse el botón Cancelar, el cuadro de diálogo de fecha debe introducir el
valor 1 dentro de su propiedad BotonPulsado, y el cuadro de diálogo se cerrará. Para
programar esto, acude a la ventana de diseño y entra en el actionPerformed del botón
btnCancelar.
14. Cuando el usuario pulse el botón Aceptar, el cuadro de diálogo de fecha debe introducir el
valor de los JTextField txtDia, txtMes y txtAnio en sus respectivas propiedades: Dia, Mes y
Anio. Luego, se debe introducir un 0 en la propiedad BotonPulsado, y finalmente se cerrará el
cuadro de diálogo.
15. Ya hemos programado las acciones a realizar cuando se pulse el botón Aceptar y Cancelar.
Ahora programaremos el resto de los métodos. Empezaremos por el método getFecha.
El método getFecha devolverá una cadena con la fecha en formato dia/mes/año. Por tanto,
este método tendrá la siguiente forma. Debes escribir este código dentro de la clase
dialogoFecha. El mejor sitio puede ser debajo del constructor.
Observa el código. Se unen las propiedades dia, mes y año en una cadena, separadas por el
símbolo “/”. Luego se devuelve la cadena.
16. Ahora programaremos el método getFechaCompleta. Este método devuelve la fecha con
formato largo, usando el mes en letras. El método getFechaCompleta tendrá el siguiente
aspecto. Puedes programarlo a continuación del método del punto anterior:
Como puedes observar, se concatena el día en una cadena y luego, dependiendo del valor de
la propiedad Mes, se concatena un mes en letras. Finalmente se concatena la propiedad Anio
y se devuelve la cadena.
La clase dialogoFecha está terminada. Gracias a ella podremos crear cuadros de diálogo en nuestros
proyectos para introducir fechas. Para probar esta clase, usaremos nuestra ventana principal.
18. Acude a la ventana principal, haciendo doble clic sobre ella en la ventana de proyectos:
22. El objeto nacimiento es del tipo dialogoFecha. Recuerda que los objetos que declaras de
forma global, luego debes construirlos en el constructor. Así pues construiremos el objeto
nacimiento.
Para construir un objeto que sea un cuadro de diálogo hay que añadir dos parámetros: null, y
luego indicar true o false, según quieras que el cuadro de dialogo sea modal o no. En nuestro
caso, queremos que el cuadro de diálogo nacimiento sea modal, por lo que indicaremos true:
Se construye el
cuadro de diálogo
nacimiento. Será
modal (true)
23. Programa el actionPerformed del botón btnFechaNacimiento. Este botón mostrará al cuadro
de diálogo nacimiento, donde el usuario introducirá una fecha. Luego, comprobaremos si el
usuario pulsó Aceptar o Cancelar. En el caso de que pulsara Aceptar, el programa introducirá
en la etiqueta etiFechaNacimiento la fecha escrita por el usuario. Todo esto se hace
preguntando al objeto nacimiento a través de los métodos programados. Observa el código:
24. Ejecuta el programa y observa el funcionamiento del botón btnFechaNacimiento y del cuadro
de diálogo nacimiento
1) Al pulsar el botón
aparece el cuadro de
diálogo diseñado por
nosotros…
EJERCICIO
Añade otra etiqueta a la ventana principal. Modifica el código del botón btnFechaNacimiento de forma
que también aparezca en esta etiqueta la fecha elegida por el usuario en formato largo. Esto debe
suceder solo si el usuario Acepta el cuadro de diálogo. En caso de que el usuario cancele el cuadro
de diálogo esta etiqueta se borrará.
CONCLUSIÓN
Es posible crear cuadros de diálogos propios, con las características que más nos
interesen.
Los cuadros de diálogo se comportan y manejan básicamente igual que las ventanas.
La gran ventaja de crear cuadros de diálogos propios, es que luego se podrán usar en
otros proyectos.
EJERCICIO GUIADO. JAVA: POO. REUTILIZACIÓN DE CÓDIGO
Reutilización de código
En esta hoja guiada veremos algunos ejemplos de como podemos aprovechar una Clase ya creada
en un nuevo proyecto.
EJERCICIO GUIADO 1
1. Crea un nuevo proyecto. El nombre del proyecto será Reutilizacion. Contendrá un paquete
llamado paqueteprincipal y dentro de él introducirás un JFrame al que llamaremos
ventanaprincipal:
2. Supongamos que en este proyecto queremos utilizar cuadros de diálogo para introducir
fechas. Podemos aprovechar la clase dialogoFecha creada en la hoja guiada anterior. Para
ello, abre el proyecto llamado Fecha que hicimos en la hoja anterior.
Proyecto Reutilizacion
3. Para poder aprovechar la clase dialogoFecha en el proyecto Reutilización, solo hay que
copiar el fichero de la clase desde un proyecto a otro. Así pues Copia dialogoFecha…
A partir de ahora, podrás crear objetos de tipo dialogoFecha dentro del proyecto Reutilizacion y
aprovechar sus características, sin tener que programar ningún código adicional.
5. Cierra el paquete Fecha para despejar un poco la ventana de Proyectos (Botón derecho
cerrar proyecto)
9. Cuando tenemos proyectos de gran envergadura, es normal tener gran cantidad de ficheros
de clases. Se hace necesario entonces organizarlos de alguna manera. Esto se hace a través
de la creación de paquetes.
10. Para ver esta idea en nuestro proyecto Reutilizacion, crearemos un nuevo paquete (botón
derecho sobre Paquetes de origen y luego Nuevo Paquete Java)
Cuando intente pegar una clase en otro paquete aparecerá un cuadro de opciones como el
siguiente:
13. Una vez movidas las dos clases al paquete elementosventana, su proyecto debe quedar así:
En el ejercicio guiado 1 hemos visto como podemos añadir a nuestro proyecto clases que se hayan
programado en otros proyectos, de forma que no tengamos que volverlas a programar.
El problema que plantea lo anterior, es que tenemos que acordarnos de donde fue programada la
clase que quiero añadir al proyecto. Es decir, tengo que acordarme del proyecto que contiene la clase.
Sería muy interesante que nuestras clases las tengamos reunidas en un solo proyecto, para no tener
que estar luego buscándolas por distintos proyectos.
Una Biblioteca en Java es un proyecto que contiene una serie de paquetes que a su vez contienen
distintas clases que son normalmente usadas en nuestros proyectos. Al estar reunidas estas clases
en un mismo sitio, son más fáciles de encontrar.
1. Para crear una Biblioteca activa la opción Archivo Nuevo Proyecto, y en la ventana de
opciones que aparece elige General y Biblioteca de clases java.
4. Y luego Pegar…
5. Y el resultado es que hemos añadido un paquete a la biblioteca MisClases:
3. Al pulsar este botón, NetBeans compilará las distintas clases y buscará errores en ellas. Si no
encuentra ninguno mostrará un mensaje en la parte inferior de la pantalla donde se indicará
que la generación ha sido correcta:
4. Si todo ha ido bien, se debe haber generado un fichero llamado MisClases.JAR que contiene
toda la librería. Este fichero se encuentra en una carpeta llamada DIST que a su vez se
encuentra dentro de la carpeta del proyecto.
5. Entra en MiPC y busca la carpeta DIST, que se encontrará dentro de la carpeta del proyecto
MisClases. Dentro de esa carpeta verás el fichero MisClases.JAR. Copia el fichero
MisClases.JAR al escritorio.
Un programador ordenado guardará todos sus ficheros JAR de biblioteca en una carpeta que
tendrá a mano. Para este ejemplo, hemos copiado el fichero MisClases.JAR en el escritorio.
8. Imagine que queremos usar en este proyecto la librería anteriormente creada y compactada.
Para ello, haz clic con el botón derecho sobre el elemento del proyecto llamado Bibliotecas y
activa la opción Agregar Archivo JAR / Carpeta.
11. Resumiendo:
En NetBeans puedes abrir varios proyectos y copiar los ficheros de clases de uno a
otro.
Es interesante reunir las clases que más uses en un solo proyecto de tipo biblioteca,
para poder acceder a ellas fácilmente.
Todo programa tiene una interfaz gráfica de usuario (gui) la cual permite a este manejar el programa
de forma sencilla. La interfaz gráfica de usuario consta de la ventana principal, cuadros de diálogo,
botones, cuadros de texto, etc…
Según el tipo de interfaz que tenga el programa, las aplicaciones se suelen dividir en dos tipos:
Aplicaciones SDI y Aplicaciones MDI.
SDI se puede traducir como interfaz de documento único. Esto quiere decir que las aplicaciones SDI
solo pueden mostrar el contenido de un documento a la vez.
Un ejemplo práctico de aplicación SDI es el bloc de notas de Windows. Si en el bloc de notas quieres
escribir un nuevo documento, tienes que cerrar antes el documento con el que estás trabajando, ya
que este programa no admite el manipular varios escritos a la vez.
Hasta el momento, las aplicaciones de manejo de documentos que hemos realizado hasta ahora han
sido de tipo SDI.
MDI se puede traducir como interfaz de múltiples documentos. Esto quiere decir que las aplicaciones
MDI pueden mostrar varios documentos a la vez.
Las aplicaciones MDI normalmente constan de una ventana principal, la cual, puede contener otras
ventanas interiores. Cada documento que se abre aparece en una ventana interior.
En este ejercicio guiado, se explicarán las nociones básicas para crear una aplicación MDI en Java
con NetBeans.
EJERCICIO GUIADO 1
Se pretende crear un visor de imágenes MDI, es decir, que permita la visualización de varias
imágenes a la vez. El programa constará de una ventana principal con un menú. Las opciones de este
menú permitirán al usuario abrir varias imágenes y cerrarlas a su gusto.
Al ser un proyecto MDI, las imágenes se abrirán en ventanas internas. Estas ventanas internas
tendrán que ser diseñadas de forma adecuada.
Para crear este proyecto, tendremos que seguir tres pasos generales:
1. Crea un nuevo proyecto. El nombre del proyecto será VisorFotos. Añade un paquete llamado
paqueteprincipal. Dentro de dicho paquete añade un JFrame llamado ventanaprincipal.
2. Añade a la ventana principal una barra de menús, con una única opción Archivo, que
contenga a su vez las siguiente opciones:
Este tipo de panel es usado como contenedor de las ventanas internas de una aplicación MDI.
En NetBeans este tipo de panel se muestra de color azul, para distinguirlo de los paneles
normales, por eso, cuando añadas el panel al JFrame este quedará así:
5. Cámbiale el nombre al JDesktopPane y asígnale el nombre panelInterno:
6. Si ejecutas el programa ahora, verás que la ventana sale reducida al mínimo tamaño posible.
Esto lo vamos a evitar haciendo que la ventana aparezca maximizada al ejecutarse el
programa. También le asignaremos un tamaño inicial. Para ello, acude al constructor del
JFrame y programa lo siguiente:
Llamada a un método
ConfiguracionVentana
Programación de dicho
método.
Se pretende que cuando se abra una imagen, el programa muestre una ventana interna que contenga
la imagen y nada más. La barra de título de esta ventana interna contendrá el camino de la imagen.
Para diseñar la ventana interna de la aplicación, sigue los pasos que se indican a continuación:
7. Una ventana interna de una aplicación MDI es un objeto de la clase JInternalFrame. Será
necesario añadir esta clase al proyecto. Para ello, haz clic con el derecho sobre el
paqueteprincipal y elige Nuevo Archivo/Carpeta.
8. Luego elige Formularios GUI Java y dentro de esta categoría Formulario JInternalFrame.
9. El nombre que le pondremos a este tipo de formulario será el de ventanainterna.
10. Si observas la ventana de proyecto, verás que ahora tenemos dos clases: la ventana
principal, y la ventana interna. Ahora diseñaremos la ventana interna, para ello, haz doble clic
sobre ventanainterna.
11. Como se dijo anteriormente, las ventanas internas mostrarán simplemente la imagen que se
abra. Para ello, solo hace falta introducir una etiqueta (JLabel) que será la que contenga la
imagen. Esta etiqueta debe ocupar toda la ventana, no tendrá ningún texto dentro, y su
nombre será etiImagen.
Pues bien, la etiqueta etiImagen de la clase ventanainterna, no es mas que una propiedad de
la ventana interna, y para poder trabajar con ella, será necesario programar un método set
que permita modificar la etiqueta a nuestro antojo.
Básicamente, este método set debe ser capaz de introducir en la etiqueta una imagen.
Haremos que este método reciba como parámetro el camino de la imagen a mostrar.
13. Así pues, entra en la zona de código de la ventanainterna y añade después del constructor el
siguiente método:
15. Bien, con la programación de este método de acceso a la etiqueta de la ventana interna,
hemos terminado con el diseño de esta ventana, ahora empezaremos a programar la ventana
principal. Vuelve a ella haciendo doble clic sobre la ventanaprincipal en la zona de proyectos:
Programación de la ventana principal
Se pretende ahora programar la opción Abrir del menú de forma que se elija el fichero de imagen a
mostrar y se muestre este en una ventana interna.
La opción Cerrar del menú permitirá cerrar la ventana interna activa en un momento determinado.
16. Ya estamos preparados para programar las opciones del menú. Empezaremos por la opción
Abrir. Accede al actionPerformed de la opción Abrir y programa lo siguiente:
La opción Abrir se encargará de abrir un fichero de imagen y mostrarlo en una ventana interna
del programa. Lo primero que hace esta opción es mostrar el cuadro de diálogo Abrir, que se
usa para indicar el fichero que se quiere abrir.
Luego se le da la orden de que muestre el cuadro de diálogo Abrir. La variable boton recoge
el botón pulsado por el usuario (Aceptar / Cancelar)
if (boton==JFileChooser.APPROVE_OPTION) {
La primera instrucción, crea una ventana interna llamada vi. Como puedes observar, es la
creación de un objeto vi de la clase ventanainterna.
Lo siguiente que se hace con el objeto vi creado, es definir sus características como ventana.
Concretamente se decide que sea una ventana con posibilidad de cambiar de tamaño
(setResizable), una ventana que pueda ser maximizada (setMaximizable), una ventana que
pueda ser minimizada (setIconifiable) y finalmente que pueda ser cerrada (setClosable)
vi.setResizable(true);
vi.setMaximizable(true);
vi.setIconifiable(true);
vi.setClosable(true);
Una vez definidas dichas características de la ventana interna, esta se añade al panel interno
de la ventana principal, al que le dimos el nombre panelInterno.
panelInterno.add(vi);
Ahora hay que introducir la imagen elegida dentro de la etiqueta de la ventana. Primero hay
que recoger el camino del fichero de imagen elegido en el cuadro de diálogo abrir.
vi.setImagen(camino);
Colocamos el camino de la imagen en la barra de título de la ventana interna:
vi.setTitle(camino);
vi.setVisible(true);
Observa como todas tienen el mismo aspecto (una etiqueta única en la ventana conteniendo
la imagen)
Observa como todas las ventanas internas están encerradas dentro de los límites del panel
interno de la ventana principal:
- Una clase del tipo JInternalFrame, la cual definirá el diseño de las ventanas internas.
Ventanas Internas
Tal como se explicó en la hoja guiada anterior, una aplicación MDI contiene un panel del tipo
JDesktopPane, dentro del cual se depositan objetos del tipo JInternalFrame. Los objetos
JInternalFrame son ventanas internas.
El programador debe añadir a su proyecto una clase heredada de JInternalFrame. Esta clase será la
ventana interna. El programador diseña el aspecto de esta ventana y añade los métodos que
considere necesarios para el manejo de dichas ventanas internas.
En la hoja anterior se creó un pequeño proyecto “Visor de Fotos” donde hicimos todo esto. Este
programa es capaz de abrir varias fotos en sus correspondientes ventanas internas.
En esta hoja guiada veremos como podemos actuar sobre las distintas ventanas internas que han
sido abiertas en el JDesktopPane, y para ello usaremos de nuevo el proyecto “Visor de Fotos”.
EJERCICIO GUIADO 1
En este ejercicio guiado inicial, programaremos la opción Cerrar del proyecto “Visor de Fotos”. Esta
opción debe ser capaz de cerrar la ventana interna que esté activa en ese momento.
Se sabe cual es la ventana interna activa porque aparece por encima de las demás, y porque tiene su
barra de título de color azul, mientras que las demás aparecen en gris. La forma de seleccionar una
ventana interna es simplemente hacer clic sobre ella.
2. Accede a la ventana principal del proyecto, haciendo doble clic sobre la clase
ventanaprincipal.
El panel interno panelInterno es un objeto del tipo JDesktopPane. Estos paneles son paneles
especiales preparados para contener ventanas internas (JInternalFrame) y poseen algunos
métodos muy útiles para manipular las ventanas internas que contienen.
Uno de los métodos que más usaremos será getSelectedFrame. Este método devuelve la
ventana interna seleccionada ahora mismo, o null si no hay ninguna seleccionada.
En el código anterior, observarás que creamos un objeto vactiva del tipo ventanainterna, y
dentro de él metemos la ventana interna seleccionada en este momento, ejecutando el
método getSelectedFrame:
Ahora ya podemos trabajar con vactiva sabiendo que se refiere a la ventana activa. Lo que se
hace a continuación es cerrar la ventana activa vactiva usando el método dispose típico de los
objetos de ventana.
Esto se hace, claro está suponiendo que haya alguna ventana activa, por eso se comprueba
que getSelectedFrame no haya devuelto null, porque en ese caso es que no hay ventana
interna activada y por tanto no se puede cerrar.
6. Este código es muy común a la hora de trabajar en aplicaciones MDI. Primero se comprueba
cual es la ventana activa y luego se actúa sobre ella. Veamos ahora otro ejemplo. Añade al
menú la opción Info:
7. Accede al evento actionPerformed de esta nueva opción y programa lo siguiente:
8. Este código muestra el camino del fichero de la imagen que está seleccionada en este
momento. Observa que el proceso es el mismo.
Si es distinta de null, se trabaja con ella. En el ejemplo anterior extraemos el texto de la barra
de título de la ventana y lo mostramos en un JOptionPane. (Recuerda que hemos programado
la apertura de las ventanas internas de forma que en la barra de título aparezca el camino de
la imagen)
10. Se ha visto que a través del método getSelectedFrame propio de los JDesktopPane se puede
acceder a la ventana activa. Pero, ¿cómo puedo acceder a otra ventana interna aunque no
esté activa?
Para hacer esto, la clase JDesktopPane posee un método llamado getAllFrames la cual
devuelve un vector conteniendo todas las ventanas internas que hay actualmente en el
JDesktopPane.
11. Para practicar con el método indicado en el punto anterior, añade al menú Archivo una nueva
opción llamada Cerrar Todo:
12. Accede al evento actionPerformed de la nueva opción y programa lo siguiente:
Lo primero que tienes que observar es el uso de getAllFrames. Este método devuelve un
vector conteniendo todas las ventanas internas actuales. En nuestro código, almacenamos
estas ventanas en un vector llamado v.
Como puedes observar, este código hace que se cierren todas las ventanas de imagen
abiertas.
15. Este código es un ejemplo de actuación sobre todas las ventanas internas abiertas. A
continuación usaremos esta misma idea para organizar las ventanas dentro del panel interno.
Añade las siguientes opciones al menú:
16. La opción Cascada organizará las ventanas internas abiertas en cascada. Para ello entra en
el evento actionPerformed de la opción y programa lo siguiente:
17. Analicemos el código.
Observa de nuevo el uso de getAllFrames para almacenar todas las ventanas internas
abiertas en un vector v:
A continuación se recorre el vector y se asigna a cada ventana interna (cada elemento del
vector) un tamaño con el método setSize y una posición con el método setLocation. Las
posiciones de cada ventana van variando para situar cada ventana una encima de la otra.
- Una clase del tipo JInternalFrame, la cual definirá el diseño de las ventanas internas.
El panel interno posee diversos métodos que permiten acceder a las ventanas
actualmente abiertas dentro de él. Entre estos métodos podemos destacar:
Gracias a estos dos métodos podemos acceder a las ventanas internas y actuar sobre
ellas.
EJERCICIO GUIADO. BASES DE DATOS
Un programa básicamente recibe una serie de datos, que introduce el usuario, luego realiza
una serie de cálculos con ellos, y finalmente presenta los resultados en pantalla.
El usuario usa una serie de elementos para introducir los datos en el programa y para darle
las órdenes al programa para que realice los cálculos. Estos elementos son las ventanas con
todos sus componentes: botones, cuadros de diálogos, etiquetas, listas desplegables, etc…
El programa realiza los cálculos con dichos datos y los resultados los presenta en elementos
de la ventana para que el usuario pueda verlos de forma cómoda. Estos elementos donde
aparecen resultados pueden ser etiquetas, cuadros de mensaje, etc…
Un buen diseño del GUI es vital. La interfaz de usuario debe hacer que el programa sea
intuitivo, fácil de usar. Un programa incómodo, por muy bueno que sea, será rechazado por
el usuario.
Aparte del GUI, internamente el programa debe realizar una serie de cálculos para obtener
los resultados pedidos por el usuario. No hace falta decir que la programación de estos
cálculos debe ser precisa y correcta, ya que en caso contrario el programa no serviría para
nada, por muy buena que fuera la interfaz de usuario.
Usuario GUI
Programación
Interfaz de usuario
interna:
Ventanas, botones,
Procedimientos,
menús, etc…
funciones, clases,
etc…
BASES DE DATOS
Ahora se va a dar una vuelta de tuerca más a lo indicado anteriormente añadiendo a todo
este entorno el concepto de Base de Datos.
Hay que tener en cuenta que la mayoría de las aplicaciones que solicitan las empresas son
programas cuya función principal es la de mantener datos de la propia empresa.
Estos programas suelen tener siempre las mismas funciones básicas. Deben ser capaces
de:
- Consultar dichos datos. Es decir, visualizar solo aquellos datos que cumplan una
condición. Por ejemplo: visualizar las facturas del mes de enero, o mostrar los
productos que estén en stock, mostrar los trabajadores que hayan trabajado más de
100 horas, etc…
- Realizar cálculos con los datos. Por ejemplo, calcular el total de ingresos entre dos
fechas, calcular lo que hay que declarar de iva, etc…
Así pues, la mayor parte de las aplicaciones que encarga una empresa son aplicaciones que
deben gestionar una serie de datos. Estos datos deben estar guardados en un fichero o
ficheros. A este conjunto de datos que debe manipular el programa se le denomina BASE
DE DATOS.
Así pues, es necesario tener en cuenta la forma en que se organizarán los datos dentro de la
base de datos, o dicho de otra forma, el diseño de la base de datos.
En las próximas hojas guiadas se verán conceptos básicos para el diseño y creación de una
base de datos, así como un lenguaje de consulta llamado SQL que nos permitirá acceder a
los datos de una base de datos y realizar determinadas acciones sobre la base de datos.
Acceso a la BASE DE DATOS desde la aplicación
Usuario GUI
Programación
Interfaz de usuario
interna:
Ventanas, botones,
Procedimientos,
menús, etc…
funciones, clases,
etc…
Resultados
de la
consulta
a la base
de datos SQL Consultar la base
de datos.
Añadir, modificar,
BASE eliminar datos.
DE
DATOS
1. El usuario le pide algo al programa. Por ejemplo el usuario quiere obtener un listado
de clientes, o quiere saber cuanto se ha ingresado el último mes…
2. Para ello, el usuario activa los elementos del GUI necesarios. Es decir, activará la
opción del menú que corresponda, o el botón de la barra de herramientas, etc. Dicho
de otra manera, el usuario da una orden.
3. Es posible que el usuario tenga que introducir algún dato. Por ejemplo, si quiere
saber los ingresos del mes de enero, tendrá que introducir “enero” para que el
programa sepa de que mes hay que calcular los ingresos. Para ello el usuario usará
un cuadro de texto del GUI, o un desplegable, etc…
4. Hay que tener en cuenta que para obtener un listado de clientes, o el total de
ingresos de un mes, hay que consultar la base de datos. El usuario no se preocupará
de eso ya que será el programa el que haga el trabajo.
5. El GUI traspasa la petición del usuario al módulo de Proceso de Datos. Este módulo
es el corazón del programa, el que se encarga de ejecutar las órdenes. Esta parte del
programa analizará la orden y acto seguido buscará los datos necesarios en la base
de datos.
8. Una vez obtenido los resultados, el módulo de Proceso de Datos se los enviará al
GUI y los presentará de forma agradable para el usuario.
9. El usuario mirará su pantalla, y verá aparecer en la ventana del programa (en el GUI)
el resultado que había pedido.
Un gestor de base de datos es un programa que nos permite crear bases de datos,
mantenerlas, realizar consultas en ellas, etc…
A través de un gestor de base de datos podemos crear la base de datos que usará nuestro
programa.
Existen diversos programas gestores de base de datos, pero el que se usará será el
programa Microsoft Access.
Antes de empezar a crear la base de datos usando el programa Access (o cualquier otro
gestor de base de datos que vaya a usar) es necesario pensar en el diseño que tendrá dicha
base de datos. O dicho de otro modo, como se organizarán los datos en la base de datos.
Para facilitar la tarea de organizar los datos en una base de datos, se usa una
representación gráfica llamada Modelo Entidad – Relación, o simplemente Modelo E-R.
Podríamos comparar el Modelo E-R a los Diagramas de Flujo. El Modelo E-R nos facilita el
diseño de bases de datos mientras que los Diagramas de Flujo nos facilitan el diseño de
algoritmos.
EJERCICIO GUIADO Nº 1
Veremos en este ejercicio guiado como diseñar una base de datos a partir de la información
aportada por una empresa, y un ejemplo de como representar dicha base de datos usando
el Modelo E-R.
Supuesto Inicial
A esta empresa le interesa almacenar los datos de sus clientes. Concretamente le interesa
almacenar el CIF de la empresa del cliente, el nombre de dicha empresa, la dirección y dos
teléfonos de contacto.
Por otro lado, MANEMPSA quiere guardar los datos de los trabajadores que están en
plantilla. Le interesa saber el nombre y apellidos de dichos trabajadores, el DNI, el sueldo y
la fecha en que entraron en la empresa.
MANEMPSA quiere controlar los servicios que realiza cada trabajador. Concretamente,
MANEMPSA quiere almacenar la fecha en que se hizo el servicio, el tipo de servicio que se
hizo (fontanería, limpieza, electricidad, etc…) La cantidad cobrada por el servicio y un
comentario donde se indique qué acciones se realizaron.
Hay que indicar que cada servicio lo realiza un solo trabajador, y que cada servicio se realiza
a una sola empresa.
Cada trabajador tiene asignado un coche de la empresa. Hay un coche por cada trabajador y
cada trabajador siempre usa el mismo coche. A MANEMPSA le interesa almacenar
información de cada coche. Le interesa almacenar la matrícula, la marca, el modelo y el año
de compra.
MANEMPSA le encarga un programa para gestionar toda esta información. Se pide que
diseñe la base de datos correspondiente que se usará en el programa. Represente dicha
base de datos usando el Modelo E-R.
1. Concepto de Entidad.
Entidad. Una entidad es un objeto que se quiere representar a través de una serie de
características.
Las entidades son aquellos elementos que juegan un papel importante en la base de
datos. Son los elementos sobre los que queremos almacenar información.
2. Lo primero que hay que hacer es distinguir las entidades del supuesto. Es decir,
averiguar los elementos que se quieren almacenar en la base de datos.
En el supuesto, las entidades son: los clientes, los trabajadores, los servicios que
realizan los trabajadores y los coches de los trabajadores.
3. Atributos de una Entidad.
Por ejemplo, de los clientes, se quiere almacenar las siguientes propiedades: el CIF
de la empresa, el nombre, etc...
Entidad Clientes
Entidad Trabajadores
Entidad Servicios
Entidad Coches
4. Atributos clave.
Un Atributo Clave es aquel atributo cuyo valor no se repite y no puede estar vacío
para todos los elementos de una entidad.
Por ejemplo, en el caso de la entidad Clientes, el atributo clave será el CIF, ya que no
puede haber dos clientes con CIF iguales, y todos los clientes tendrán CIF. El CIF
permite distinguir a un cliente de otro.
En el caso de la entidad Servicios, tenemos que ninguno de los atributos que posee
puede ser atributo clave. Observa:
- Dos servicios distintos pueden ser realizados en la misma fecha, por lo que dos
servicios pueden tener fechas repetidas: la fecha no puede ser atributo clave.
- Dos servicios distintos pueden ser del mismo tipo, por los que dos servicios pueden
tener el mismo tipo: el atributo tipo no puede ser atributo clave.
- Dos servicios distintos podrían haber costado lo mismo, por lo que el atributo
cantidad no puede ser atributo clave.
No existe para la entidad Servicios un atributo que identifique cada servicio. En estos
casos se suele añadir un atributo que sea atributo clave, es decir, un “código” o
“identificador”.
Entidad Servicios
No está establecida una relación directa entre ambas entidades, pero sí se relacionan
a través de la entidad Servicios:
Según la forma en que se relacionen dos entidades, tenemos tres tipos de relaciones:
Relaciones 1 a 1
Relaciones 1 a Muchos
Relaciones Muchos a 1
Este tipo de relación es el mismo que el anterior. Basta con “darle la vuelta” a la
relación.
Para averiguar el tipo de cada relación, es necesario estudiar bien el enunciado del
supuesto, y pedir información al cliente que nos encarga el programa, de lo contrario,
tendremos que hacer suposiciones para asignar un tipo a cada relación.
Para hacer efectivas las relaciones de la base de datos, es necesario intercambiar los
atributos claves entre las entidades relacionadas siguiendo ciertas reglas.
Así pues, será necesario añadir el atributo matrícula a Trabajadores, y el atributo DNI
a Coches.
Entidad Trabajadores
Entidad Coches
Entidad Trabajadores
Entidad Servicios
Por otro lado, las entidades Servicios --- Clientes se relacionan de forma Muchas a 1.
Por tanto, será necesario traspasar el atributo clave de la entidad Clientes a la
entidad Servicios, con lo que quedarán así:
Entidad Servicios
Entidad Clientes
Cuando una entidad posee un atributo clave de otra entidad, se dice que ese atributo
es una clave foránea.
Después de realizar estos traspasos, nuestras entidades quedan con los siguientes
atributos.
Nota: se subraya con línea continua el atributo clave en cada entidad, y se subraya
con línea de puntos las claves foráneas de cada entidad.
Entidad Coches
Entidad Trabajadores
Entidad Servicios
Una vez definidas las entidades, los atributos, atributos claves, relaciones, tipos de
relaciones, y claves foráneas, todo esto se puede representar de forma gráfica como
sigue:
apellidos
nombre
sueldo
tipo
DNI fecha cantidad
fecha
matrícula comentario
número
DNI
Trabajadores Servicios
1 M
CIF
1 M
1 1
Coches Clientes
Tfno2
matrícula DNI CIF
año Tfno1
marca nombre
modelo dirección
Para diseñar una Base de Datos hay que especificar los siguientes elementos:
Estas tablas se relacionan entre sí, de forma que podamos extraer más información uniendo
las tablas.
A las bases de datos que se organizan a través de tablas que se relacionan entre sí se las
denomina Bases de Datos Relacionales, y son las bases de datos que más se usan.
El Modelo E-R representa el diseño de una base de datos. Este modelo es ideal para
tomarlo como base a la hora de crear las tablas que formarán parte de la base de datos.
En esta hoja guiada se verá como crear las tablas de una base de datos tomando como
referencia el Modelo E-R .
Una vez que tenemos la base de datos representada en forma de tablas, solo tendremos
que introducirlas en un programa Gestor de Bases de Datos como por ejemplo Access.
EJERCICIO GUIADO Nº 1
Dado el Modelo E-R creado en la hoja anterior y que se muestra a continuación, crearemos
las tablas necesarias que formarán parte de la base de datos:
apellidos
nombre
sueldo
tipo
DNI fecha cantidad
fecha
matrícula comentario
número
DNI
Trabajadores Servicios
1 M
CIF
1 M
1 1
Coches Clientes
Tfno2
matrícula DNI CIF
año Tfno1
marca nombre
modelo dirección
Primero hay que tener en cuenta que existirán tantas tablas en la base de datos
como entidades haya en el Modelo E-R.
Por tanto, podemos decir que la base de datos del supuesto tendrá cuatro tablas:
Toda tabla tendrá una cabecera. La cabecera de una tabla define la información que
guardamos de cada elemento. A esta información que se guarda de cada elemento
se la denomina Campo.
Al igual que existe un atributo clave para cada entidad, también existe un campo
clave para cada tabla.
3. Teniendo en cuenta lo anterior, las tablas de la base de datos tendrán las siguientes
cabeceras (se subraya el campo clave) :
Tabla Coches
Tabla Trabajadores
Tabla Servicios
Tabla Clientes
4. Estas tablas ya se pueden relacionar gracias a que contienen las distintas claves
foráneas, las cuales añadimos en el momento de analizar las relaciones en el Modelo
E-R.
Tabla Coches
Tabla Trabajadores
Tabla Servicios
Tabla Clientes
Si observas las tablas y sus claves foráneas, puedes llegar a conclusiones que
afectan a varias tablas. Por ejemplo:
Etc.
Una Base de Datos Relacional está formada por tablas, que son los elementos que
contienen la información.
Una vez realizado el Modelo E-R, resulta muy sencillo hacer el traspaso a tablas. Solo
se debe tener en cuenta lo siguiente:
En las hojas anteriores se ha visto que entre las entidades se pueden establecer relaciones
de tres tipos:
Relaciones 1 a 1.
Así pues las relaciones Muchas a Muchas se consideran relaciones “prohibidas” que deben
ser evitadas a toda costa.
En esta hoja guiada se verá qué hacer cuando aparezca una relación Muchas a Muchas
EJERCICIO GUIADO Nº 1
SUPUESTO “ACADEMIA”
En la academia hay una pequeña biblioteca. Interesa almacenar información sobre los libros
de esta biblioteca. Se almacenará el código del libro, el título, el autor y el tema del libro.
Hay que tener en cuenta que la biblioteca está abierta a los alumnos de la academia y se les
puede hacer préstamos.
1. Entidades participantes:
Alumnos
Nombre
Apellidos
DNI
Fecha de nacimiento
Cursos
Código del curso
Nombre del curso
Número de horas
Nombre del profesor
Libros
Código del libro
Título
Autor
Tema
3. Relaciones:
Los “alumnos hacen cursos” por lo que la entidad Alumnos está relacionada con
Cursos.
Por otro lado los “libros se prestan a los alumnos” por lo que la entidad Alumnos está
relacionada con la entidad Libros.
4. Tipos de relaciones.
Un alumno puede apuntarse a muchos cursos. Por otro lado, en un curso se apuntan
muchos alumnos. Es una relación Muchas a Muchas:
M M
Alumnos Cursos
Un alumno puede pedir prestado varios libros mientras esté en la academia, por otro
lado, un mismo libro puede ser prestado a varios alumnos (No a la vez, claro está. El
libro es prestado a un alumno, y cuando es devuelto se le presta a otro alumno)
M M
Alumnos Libros
En nuestro caso tenemos dos relaciones Muchas a Muchas que serán reconvertidas
a relaciones Muchas a 1 (o 1 a Muchas) para hacerlas desaparecer.
6. Existencia de entidad intermedia.
La aparición de una relación Muchas a Muchas suele ser debido a un “mal diseño de
la base de datos”. Este mal diseño viene dado por la falta de información
proporcionada por el enunciado del supuesto.
Esto será habitual, ya que el cliente que nos encarga el programa no siempre se
explica con la claridad que desearíamos.
Esta entidad intermedia está entre las dos entidades que se relacionan de forma
Muchas a Muchas. Al no tener en cuenta esta entidad intermedia, el resultado
producido es la aparición de la relación Muchas a Muchas:
M M
Entidad 1 Entidad 2
Entidad Intermedia
(ignorada)
Así pues, cuando aparezca una relación Muchas a Muchas, tendremos que averiguar
cual es la entidad intermedia que sin querer hemos ignorado, y añadirla al modelo. Al
hacer esto la relación Muchas a Muchas se sustituirá por dos relaciones 1 a Muchas.
Por otro lado, la entidad intermedia puede contener atributos muy interesantes para la
base de datos, que igualmente hayamos ignorado.
Cada vez que un alumno se apunta a un curso, se matricula, o dicho de otra forma,
rellena una matrícula, o dicho de otra forma, hace una reserva de plaza para el curso.
Veamos que sucede si ponemos la entidad matrículas entre las entidades alumnos y
cursos.
Veamos:
Un alumno puede matricularse muchas veces (se puede apuntar a muchos cursos).
Así pues un alumno realiza o rellena varias matrículas.
1 M
Alumnos Matrículas Cursos
Cada vez que se rellena una matrícula es para un solo curso. (Si pudieras leer el
formulario que rellena el alumno, verías que en el papel se indica el curso al que se
apunta, y solo es uno)
Por otro lado, para un curso se rellenan varias matrículas (tantas como alumnos
quieren apuntarse al curso)
1 M M 1
Alumnos Matrículas Cursos
Finalmente, también hay que asignar a la entidad intermedia las claves foráneas.
Recuerda que en las relaciones 1 a Muchas, hay que pasar la clave de la parte 1 a la
parte Muchas.
Si observas la relación…
1 M M 1
Alumnos Matrículas Cursos
Por lo tanto, la entidad Matrículas del ejemplo quedará con los siguientes atributos:
Matrículas
Número (atributo clave)
Pago
Nota final
DNI (clave foránea de alumnos)
Código Curso (clave foránea de cursos)
M M
Alumnos Libros
Es decir, la entidad intermedia que hemos pasado por alto es Préstamos, la cual
guardará información sobre los préstamos de los libros.
Un alumno puede solicitar varios préstamos mientras está en la academia. Pero cada
préstamo en concreto se hace a un alumno: Relación 1 a Muchas.
1 M M 1
Alumnos Préstamos Libros
Para entender estas relaciones, imagine que cada vez que se solicita un préstamo se
tiene que rellenar una ficha. En esta ficha se escribe el nombre del alumno y el
nombre del libro prestado.
Un alumno tendrá muchas fichas (si ha pedido prestado muchos libros), pero una
ficha concreta solo tiene el nombre de un alumno.
Por otro lado, un libro aparecerá en muchas fichas (ya que el libro es prestado
muchas veces), pero en una ficha concreta solo aparece el nombre de un libro.
Ahora hay que determinar los atributos que tendrá la nueva entidad préstamos.
Atributo clave.
Claves foráneas.
Hay que añadir a la entidad préstamos los atributos DNI y código de libro, debido a
las reglas de claves foráneas de las relaciones 1 a Muchas (recuerde que hay que
pasar el atributo clave desde la parte 1 a la parte Muchas en estas relaciones)
Préstamos
Número (atributo clave)
Fecha préstamo
Fecha devolución
DNI (clave foránea de alumnos)
Código Libro (clave foránea de libros)
15. Después de ha ver resuelto las dos relaciones problemáticas Muchas a Muchas, el
Modelo Entidad Relación resultante será el siguiente (subrayados con línea continua
los atributos clave, subrayados con rayas los atributos claves foráneas):
horas
nota profesor
pago código
curso
1 Cursos
número
M
código
curso
DNI
Matrículas nombre
M
autor tema
fecha
1
DNI 1 M M 1
Alumnos Préstamos Libros
nombre
código título
número libro código
apellidos libro
DNI
fecha
fecha devolución
préstamo
Se puede observar que ya no hay relaciones Muchas a Muchas, y que han aparecido
dos nuevas entidades que no estaban contempladas en un principio en el enunciado.
CONCLUSIÓN
Las Relaciones Muchas a Muchas están prohibidas ya que pueden causar muchos
problemas.
Una relación Muchas a Muchas aparece debido a que hay una entidad intermedia que
no ha sido identificada.
Será necesario añadir a la nueva entidad su atributo clave y las claves foráneas
debidas a las relaciones 1 a Muchas.
También puede ser interesante añadir a la nueva entidad atributos que aporten más
información a la base de datos.
EJERCICIO GUIADO. BASES DE DATOS. ACCESS
En las hojas guiadas anteriores se ha explicado como diseñar una base de datos.
Diseñar una base de datos consiste en organizar la información, en cierta manera caótica,
que nos proporciona el cliente que nos encarga el programa.
Para organizar dicha información usamos una representación gráfica denominada Modelo
Entidad Relación en la que representamos cada uno de los elementos que participan en la
base de datos (entidades), sus características principales (atributos) y las relaciones que
existen entre ellos.
Una vez finalizado el esquema Entidad Relación de la base de datos, se realiza una
representación en forma de tablas a partir de él.
Así pues, diseñar una base de datos consiste en tomar la información caótica proporcionada
por el cliente y organizar esta información en tablas.
Un programa gestor de base de datos permite crear una base de datos a partir de sus tablas.
Y además permite el mantenimiento de dichas tablas (añadir datos, eliminar datos, modificar
datos, realizar consultas, etc)
Microsoft Access
Existen múltiples programas gestores de bases de datos que se pueden usar para crear las
bases de datos de sus aplicaciones.
En los ejercicios guiados que vendrán a continuación se usará el gestor Microsoft Access, el
cual permitirá la creación de forma sencilla de bases de datos adecuadas para las
aplicaciones de base de datos que se realizarán en java.
Por otro lado facilita mucho el manejo de la base de datos, la instalación de ésta en el
ordenador del cliente y las modificaciones posteriores, además de ser un gestor de base de
datos muy extendido y conocido.
En los ejemplos que vendrán a continuación, se usará la versión 2003 de Microsoft Access.
EJERCICIO GUIADO Nº 1
Tabla Coches
Tabla Trabajadores
Tabla Servicios
Tabla Clientes
En este ejercicio guiado se creará la base de datos MANEMPSA formada por las tablas
anteriores usando el programa Access.
3. Lo primero que tendrá que hacer es decidir el lugar donde guardará la base de datos
y el nombre que le dará al fichero. Para nuestro ejemplo, elija la carpeta Mis
Documentos para guardar la base de datos y el nombre que le asignaremos será
MANEMPSA.
4. La Base de Datos MANEMPSA debe contener cuatro tablas, las cuales crearemos a
continuación. Para crear una tabla active la opción Crear Tabla en Vista Diseño en la
ventana principal de Access:
5. La ventana que aparece a continuación nos permitirá definir los campos de la tabla
que vamos a crear. Empezaremos creando la tabla Coches (que se muestra a
continuación).
Tabla Coches
El tipo de datos Texto define un dato que contendrá letras o caracteres no numéricos,
como espacios, guiones, etc. Una matrícula es texto ya que contendrá letras, y puede
ser representada con guiones, espacios, etc.
7. En la parte inferior puede indicar el tamaño que asignará para introducir una
matrícula. Por defecto aparece un valor de 50, pero este tamaño es exageradamente
grande para una matrícula que no suele tener más de 10 caracteres, según la
representemos.
8. El siguiente campo de la tabla es la “Marca”. Este campo será de tipo Texto, ya que
contiene letras y como tamaño dejaremos 50.
9. El siguiente campo es “Modelo”. Igualmente este campo será de tipo Texto debido a
que contiene letras y dejaremos como tamaño 50.
10. El siguiente campo es “Año”. Este campo hace referencia al año de compra del
coche, por lo que es un número. Así pues, elige en el tipo de datos la opción Número,
que define aquellos campos que contendrán números válidos desde un punto de
vista matemático.
En la parte inferior estará definido el tipo Entero largo, que indica que los números
que se introduzcan en este campo serán de tipo entero y no tendrán decimales.
11. El siguiente campo es el DNI. Se recuerda que este campo es una clave foránea, y
hace referencia al DNI del trabajador que conduce este coche.
No ponga DNI con puntos, ya que los nombres de campos en Access no admiten
puntos.
13. El diseño de la tabla Coches está casi terminado, solo hay que darle el nombre y
guardarla. Para ello, cierra la ventana de diseño de la tabla e indica que quieres
guardar los cambios.
16. Incluso, puedes hacer doble clic sobre la tabla para ver su contenido. Por supuesto,
ahora está vacía, ya que acaba de ser creada. No introduzcas nada en la tabla.
17. Cierra la ventana que muestra el contenido de la tabla para volver a la ventana
principal.
18. Ahora crearemos la siguiente tabla de la base de datos: “Trabajadores”, cuyo diseño
se muestra a continuación:
Tabla Trabajadores
20. Introduzca el campo DNI. Su tipo de datos será Texto y pondremos un tamaño de 15:
21. Introduzca los campos Nombre y Apellidos. El tipo de datos será claramente Texto y
el tamaño de cada uno lo dejaremos en 50.
22. Introduzca el campo Sueldo. El tipo de datos que usaremos para este campo será
Número, pero cambiaremos en la parte inferior el tipo de número de Entero Largo a
Doble. El tipo de número Doble permitirá representar números con decimales:
Nota: Existe en Access un tipo de datos propio de aquellos campos que almacenarán
cantidades monetarias. Este tipo de datos se denomina Moneda, pero no será usado en
los ejemplos. En sustitución, se usará el tipo Número que cumple perfectamente con el
mismo cometido.
23. Añade ahora el campo “Fecha”, el cual hace referencia a la fecha de entrada en la
empresa del trabajador.
Para los campos que indiquen fecha, existe un tipo de datos llamado Fecha / Hora.
Será interesante poner un comentario a este campo para indicar que se refiere a la
fecha de entrada en la empresa y no a la fecha de nacimiento del trabajador, por
ejemplo:
24. Añade ahora el campo “Matrícula”.
Se recuerda que este campo es una clave foránea y hace referencia a la matrícula
del coche que conduce el trabajador. Este campo también se encuentra en la tabla
Coches (es el campo clave de la tabla Coches), así pues se definirá aquí de la misma
forma que está definido en la tabla Coches: tipo texto y 10 de tamaño:
Tabla Clientes
30. Añade el campo CIF. Su tipo de datos será Texto (recuerda que lleva una letra) y
asignaremos un tamaño de 15.
31. Añade los campos Nombre y Dirección. Ambos campos serán claramente de tipo
Texto. Asignaremos a ambos un tamaño de 100 caracteres.
32. Añade el campo “Tfno1” y asígnale el tipo de datos “Texto” y un tamaño de 15. Haz lo
mismo con el campo “Tfno2”:
Nota: Los campos “Teléfonos” suelen causar mucha confusión, ya que se pueden definir con
el tipo de datos Número o Texto.
956 30 30 30
o de esta otra:
(956) 30-30-30
Tendría que definirlo como Texto, ya que contiene caracteres no numéricos (los espacios,
los paréntesis, los guiones…)
Si, en cambio, define el teléfono como Número, solo podrá almacenar números así:
956303030
Sin poder usar ni espacios, ni guiones, ni otro carácter que no sea un dígito.
En el ejemplo se han definido como Texto para permitir el uso de caracteres no numéricos.
33. Defina como campo clave el CIF:
34. Cierre y guarde la tabla con el nombre “Clientes”. Ya tiene tres de las cuatro tablas de
la base de datos.
35. Queda por añadir la tabla “Servicios” a la base de datos. Se muestra esta tabla a
continuación:
Tabla Servicios
El tipo de datos Autonumérico hace que cada elemento que se añada a la tabla tenga
un número correlativo.
Este tipo de datos nos ahorra el tener que estar asignando un número cada vez que
se añada un servicio, ya que el número es asignado automáticamente.
38. Añade el campo Fecha. Su tipo de datos será Fecha / Hora, evidentemente.
39. Añade el campo Tipo. El tipo de la reparación es un texto, así que asigna el tipo de
datos Texto. Su tamaño será de 50.
40. Añade el campo Cantidad. Este campo hace referencia al coste de la reparación.
Será un campo Numérico de tipo Doble, ya que puede llevar decimales.
41. El campo Comentario contendrá un texto donde se explicará el servicio realizado.
Debes tener en cuenta aquí que no se puede asignar una longitud mayor de 255
caracteres a un campo de tipo Texto. Por lo tanto, si está previsto que se escriba
mucho texto en el campo Comentario, este tipo de datos no será el adecuado.
Existe otro tipo de datos mucho mejor para aquellos campos que vayan a contener
grandes cantidades de texto. Este tipo de datos se denomina Memo, y será así como
definamos el campo Comentario:
42. Ahora hay que añadir los dos últimos campos, los cuales son claves foráneas que
permitirán relacionar la tabla Servicios con las tablas Clientes y Trabajadores. Estos
campos son el DNI y el CIF.
43. Añade el DNI. Tendrá que ser de tipo Texto y un tamaño de 15:
44. Ahora añade el CIF. Será también de tipo Texto y tendrá un tamaño de 15:
45. Los campos están ya definidos. Ahora activa la opción campo clave para el campo
Numero.
46. Finalmente cierre y guarde la tabla con el nombre Servicios. Y ya tendrá creadas las
cuatro tablas de la base de datos.
47. Como prueba, se pueden introducir algunos datos en las tablas de esta base de
datos directamente desde aquí. Introduciremos dos trabajadores. Haz doble clic
sobre la tabla Trabajadores, e introduce los siguientes datos:
48. Ahora introduciremos los coches de la empresa. Para ello haz doble clic sobre la
tabla Coches e introduce en ella los siguientes datos de los coches:
Después de introducir los datos de los clientes cierra la ventana de la tabla Clientes.
50. Finalmente introduzca los datos de algunos de los servicios prestados. Abra para ello
la tabla Servicios e introduzca los siguientes datos (observa como los números
aparecen de forma automática en el campo Número, esto es debido al tipo de datos
Autonumérico)
51. Los datos que se introducen en una tabla se denominan registros, así pues, si la
tabla Servicios contiene la información de 4 servicios, se dice que la tabla Servicios
contiene 4 registros.
52. Ya tenemos terminada la base de datos MANEMPSA. Hemos creado las tablas que
contiene e incluso hemos introducidos algunos registros en las tablas para no
dejarlas vacías. Ya puede cerrar el programa Access.
54. A la hora de programar una aplicación java de bases de datos, se hará que nuestro
programa acceda al fichero de base de datos que acaba de crear con Access. Así
pues no pierda de vista el fichero de base de datos que acaba de crear, ya que se
usará en posteriores hojas guiadas.
La base de datos hay que introducirla en un programa gestor de bases de datos, como
por ejemplo Access.
Es necesario indicar el tipo de datos que tiene cada campo de una tabla. Puedes usar
los siguientes tipos de datos según necesites:
- Texto.
Campos que almacenarán todo tipo de caracteres, sobre todo letras.
- Número.
Campos que almacenarán solo dígitos numéricos.
Son números con un formato correcto desde el punto de vista matemático.
- Fecha / Hora.
Campos para almacenar fechas.
- Memo.
Campos para almacenar grandes cantidades de texto.
- Autonumérico.
Campo que contendrá números correlativos.
El fichero de base de datos creado desde Access será usado por la aplicación java de
base de datos.
EJERCICIO GUIADO. BASES DE DATOS. CONSULTAS EN ACCESS
Consultas
Una consulta consiste en visualizar aquella información de la base de datos que cumple
determinados requisitos.
Por ejemplo, podría interesar el visualizar las ventas realizadas entre una fecha inicial y otra
final, o ver las ventas hechas a un cliente en concreto, o ver el listado de trabajadores que
tienen turno de mañana, etc…
Hay que tener en cuenta que las tablas de una base de datos contendrán mucha
información, pero no siempre necesitaremos acceder a toda ella. Por eso, la realización de
consultas es una acción habitual en una base de datos.
Por otro lado, la creación de consultas nos permite averiguar determinada información que
no está tan accesible cuando la base de datos es muy grande.
Por ejemplo, podríamos querer ver quienes son los trabajadores que cobran más de una
cantidad de sueldo determinada, o qué clientes no han pagado determinadas ventas, etc…
Consultas en Access
Access permite la creación de consultas de forma sencilla. Estas consultas son almacenadas
en la base de datos como si fueran “otras tablas”, aunque en realidad, no son tablas reales.
En esta hoja guiada se verá la forma de crear consultas permanentes en una base de datos
de Access.
EJERCICIO GUIADO Nº 1
1. Abra el fichero de base de datos MANEMPSA que hizo en la hoja anterior, contenido
en la carpeta Mis Documentos.
3. Aparecerá un listado nuevo de opciones y un listado con las consultas que hay
creadas hasta ahora (ninguna, claro está)
No hay consultas
aún
4. Para crear una consulta, activaremos la opción Crear Consulta en Vista Diseño.
5. Aparecerá un cuadro de diálogo inicial donde se tendrá que indicar la tabla o tablas
que se quieren consultar:
6. Supongamos que queremos consultar la tabla Servicios. Por tanto, haga clic sobre
ella y active el botón Agregar: Observará como aparece un recuadro en la parte
superior izquierda con los campos de la tabla Servicios:
8. Supongamos que queremos ver aquellos servicios que hayan tenido un coste mayor
de 200 euros. Interesa ver la fecha del servicio, el tipo y la cantidad.
9. Teniendo en cuenta lo anterior, tendremos que añadir los campos Fecha, Tipo y
Cantidad, que es la información que se quiere ver. Para ello, despliegue las casillas
de la fila Campo hasta conseguir que aparezcan los tres campos:
10. No se quiere visualizar todos los servicios, sino solamente aquellos cuyo coste haya
sido mayor de 200 euros, por tanto tendremos que indicar dicho criterio de selección
en la consulta.
> 200
Observa:
Estamos indicando que solo se quiere visualizar aquellos servicios cuya cantidad
cobrada sea mayor de 200.
11. Básicamente, para hacer una consulta hay que indicar la tabla que se quiere
consultar, los campos que se quieren visualizar y la condición que se tiene que
cumplir:
Tabla a consultar…
Campos a visualizar…
Condiciones
12. Para ver el resultado de la consulta, puede pulsar el botón Vista que se encuentra en
la parte superior izquierda de la ventana:
13. Al hacer esto verá un listado con los servicios que costaron más de 200 euros.
Observe que solo se visualiza la fecha, el tipo de servicio y la cantidad:
14. Puede hacer clic en el botón Vista de nuevo (que ahora ha cambiado de forma) para
volver a la pantalla de diseño de la consulta:
16. Vamos a mejorar un poco más la consulta. Interesaría que apareciera el nombre del
trabajador que ha realizado el servicio, así pues hay que añadir una nueva tabla a la
consulta: la tabla Trabajadores, ya que es esta tabla la que contiene dicho dato.
17. Para añadir una tabla a la consulta pulse el botón Mostrar Tabla:
18. Aparecerá de nuevo el listado de tablas inicial:
19. Elige la tabla Trabajadores y pulse el botón Agregar. Observarás como aparece un
nuevo recuadro en la parte superior izquierda con los campos de la tabla
Trabajadores.
20. La línea que aparece entre ambas tablas es la relación establecida a través del
campo de unión DNI. Debido a que la tabla servicios tiene incluida la clave foránea
DNI, ambas tablas pueden ser relacionadas.
Relación entre las tablas Servicios y
Trabajadores a través del campo de unión
DNI.
21. Una vez hecho esto, añade el campo Nombre de la tabla Trabajadores a la consulta
(observa como se indica la tabla a la que pertenece, para que no haya confusión):
22. Comprueba de nuevo el resultado de la consulta pulsando el botón Vista. Observa
como ahora tenemos más información de cada servicio (ahora sabemos también el
nombre del trabajador).
24. También sería interesante que apareciera el nombre del cliente al que se le ha
realizado el servicio. Para ello, tendremos que añadir la tabla Clientes que es la que
contiene este campo.
26. Es posible reorganizar las tablas para que las relaciones se vean mejor. Haz clic
sobre ellas y arrástralas hasta que queden en el orden Clientes – Servicios –
Trabajadores:
29. Una vez que una consulta está finalizada, la podremos guardar para usos
posteriores. Para ello, cierra la consulta pulsando en el botón cerrar de la ventana de
diseño.
30. Indica que sí quieres guardar la consulta y escribe el siguiente nombre: Servicios de
mas de 200 euros.
31. Como puedes observar, has creado una consulta en la base de datos. Puedes
visualizar el contenido de esta consulta siempre que quieras haciendo doble clic
sobre ella.
32. Vuelve a la ventana principal cerrando la ventana de visualización de la consulta.
33. En Access puedes diseñar y guardar todas aquellas consultas que puedan resultar
más interesantes para el trabajo diario.
Las consultas, aunque no son tablas, se comportan como tal. Básicamente, se puede
decir que una consulta es una subtabla, que muestra una parte de la información de
la base de datos.
CRITERIOS EN CONSULTAS
En el ejercicio guiado anterior, se realizó una consulta que mostraba los servicios de más de
200 euros de coste. Para ello, en la vista diseño de la consulta se agregó lo siguiente:
Campos Coste
Criterios >200
Campos Coste
Campos Coste
Campos Coste
Campos Coste
Campos Coste
Campos Coste
En el caso de los campos de tipo Fecha los operadores que se usan son los mismos que
para los campos numéricos, solo que el significado es distinto en algunos casos. Ejemplos:
En los campos de tipo texto se pueden usar asteriscos para definir búsquedas más
extensas. Observa los siguientes ejemplos:
Campos Nombre Buscar aquellos registros cuyo Nombre sea exactamente José
Manuel:
Campos Nombre Buscar aquellos registros cuyo Nombre empiece por José:
Criterios complejos
Si se quiere buscar a aquellos registros que cumplan varios criterios a la vez, tendrán que
escribirse dichos criterios en la misma fila. Por ejemplo:
Se pueden establecer varios criterios en una misma consulta colocándolos en filas distintas.
Esto es como mostrar el resultado de varias consultas en una sola. Por ejemplo:
Campos Nombre Sueldo Muestra aquellas personas que tengan un nombre que
termine en José y cobren más de 1000 euros.
Access tiene una zona de consultas donde encontrará el listado de las consultas ya
creadas y donde podrá crear nuevas consultas.
Para crear una consulta en Access básicamente hay que seguir tres pasos:
Las relaciones creadas en Access y almacenadas pueden ser usadas luego desde la
aplicación programada en Java, como si fueran tablas normales y corrientes.
EJERCICIO GUIADO. BASES DE DATOS. SQL
Con este lenguaje se pueden construir órdenes que permiten hacer lo siguiente (entre otras
cosas):
Gracias a este lenguaje, se construirán órdenes desde nuestra aplicación java, que se
aplicarán a la base de datos, actuando sobre ella.
Las órdenes de añadir, modificar, eliminar realizan cambios dentro de la base de datos, pero
no devuelven nada al programa java.
Por otro lado, cuando se da una orden de realizar una consulta, la base de datos nos
devuelve el resultado de dicha consulta:
Consulta SQL
Programa Base de
Java Datos
Resultado de la consulta
Gracias a este lenguaje, nuestra aplicación tiene dominio total sobre la base de datos.
Puede actuar sobre ella introduciendo nuevos datos, o modificando los que había, o
eliminándolos. También puede extraer información de ella accediendo a las consultas de la
base de datos o realizando nuevas consultas.
Se empezará estudiando como realizar consultas sobre una base de datos usando el
lenguaje SQL (más adelante se verá como realizar consultas de acción: añadir, modificar
eliminar)
Para consultar una base de datos usará un código general como el que sigue:
Como puede ver, una consulta en SQL tiene cuatro partes (SELECT, FROM, WHERE y
ORDER BY) de las cuales solo las dos primeras son obligatorias.
Se debe mantener el orden indicado. Es decir, primero SELECT, luego FROM, luego
WHERE y luego ORDER BY.
Visualizar una tabla entera (todos los campos y todos los registros)
SELECT *
FROM clientes;
Observa, el * significa ver todos los campos. En el FROM se indica la tabla que se quiere
ver. Observa como hay que terminar con un ;
Visualizar algunos campos de una tabla (algunos campos y todos los registros)
Observa como se indican los campos a visualizar en la cláusula SELECT. Se indica la tabla
y luego el nombre del campo, separados por un punto.
Visualizar solo aquellos registros de la tabla que cumplan una condición
Ejemplo: “Visualizar todos los campos de aquellos trabajadores que cobren un sueldo
superior a los 1000 euros”
SELECT *
FROM trabajadores
WHERE trabajadores.sueldo > 1000;
Observa el uso de BETWEEN – AND para indicar que el sueldo esté entre 800 y 2000
Nota. Más adelante en este ejercicio guiado se muestran las distintas posibilidades
que tenemos a la hora de indicar criterios en la cláusula WHERE
SELECT *
FROM trabajadores
ORDER BY trabajadores.sueldo ASC;
Observa el uso de la cláusula ORDER BY para indicar que se ordene por sueldo. La palabra
ASC indica “ascendente” (de menor a mayor)
Ejemplo: “Visualizar nombre, apellidos y sueldo de los trabajadores ordenados por sueldos
de mayor a menor”
Observa aquí como ordenar por dos campos, primero por apellidos y luego por nombre. Esto
significa que aquellos trabajadores que tengan el mismo apellido serán ordenados por
nombre.
Ejemplo: “Visualizar todos los servicios. Interesa que aparezca el nombre del trabajador que
hizo el servicio, la fecha del servicio realizado y el tipo de servicio”
Observa aquí como se indica en la cláusula FROM las dos tablas de las que extraemos
datos. Es importante que te fijes también en como se unen ambas tablas igualando en la
cláusula WHERE el campo de unión de ambas tablas, que en el ejemplo es el DNI.
Ejemplo: “Visualizar todos los servicios. Interesa que aparezca el nombre del trabajador que
hizo el servicio, el tipo de servicio y el nombre del cliente al que se le hizo el servicio”
Observa aquí una consulta sobre tres tablas, las cuales aparecen en el FROM. Es necesario
indicar en la cláusula WHERE los campos de unión. La tabla Trabajadores se relaciona con
la tabla Servicios a través del campo DNI, y la tabla Trabajadores se relaciona con Clientes a
través del campo CIF. Observa el uso de AND para unir varias condiciones.
Ejemplo: “Visualizar los servicios que hayan costado más de 200 euros. Interesa ver la fecha
del servicio, el nombre del cliente y el coste ordenado por cantidad”
Observa como la cláusula WHERE contiene por un lado la condición de unión de ambas
tablas y por otro lado la condición que se busca (cantidad > 200)
FORMA DE INDICAR CRITERIOS EN LA CLÁUSULA WHERE
Se van a indicar a continuación una serie de reglas que se deben seguir a la hora de crear
condiciones en la cláusula WHERE de una consulta SQL
Operadores Relacionales
Between...and Entre valor1 y valor2 WHERE cantidad BETWEEN 100 AND 200
(aplicable a números y
fechas) WHERE fecha BETWEEN #8-5-2006# AND #1-12-2006#
Like ‘cadena*’ Que empiece por cadena WHERE nombre LIKE ‘Jose*’
(aplicable a textos)
Like ‘*cadena’ Que termine por cadena WHERE nombre LIKE ‘*Jose’
(aplicable a textos)
Like ‘*cadena*’ Que contenga cadena WHERE nombre LIKE ‘*Jose*’
(aplicable a textos)
NOT ... IS NULL Que el campo no esté vacío WHERE NOT telefono IS NULL
(aplicable a números, textos,
fechas)
Operadores Lógicos
AND Obliga a que se cumplan las WHERE cantidad > 200 AND tipo = ‘Limpieza’
dos condiciones que une.
(Debe cumplirse que la cantidad sea mayor de 200 y que
el tipo de servicio sea Limpieza)
OR Basta con que se cumpla WHERE cantidad > 200 OR tipo = ‘Limpieza’
una sola de las dos
condiciones que une. (Basta con que la cantidad sea mayor de 200, o que el tipo
de servicio sea Limpieza para que se cumpla la condición)
Como puedes observar en los ejemplos anteriores, tendrás que tener en cuenta las
siguientes reglas para indicar valores:
Valores numéricos
Indica los valores numéricos tal cual, teniendo en cuenta que debes usar el punto decimal
cuando quieras representar decimales.
Ejemplo:
Valores de texto
Ejemplos:
Valores de fecha
Las fechas se indican rodeándolas entre almohadillas #. Se debe tener en cuenta que las
fechas deben indicarse separadas por guiones – o barras / y que su formato debe ser el
siguiente:
Ejemplos:
Tabla.Campo
Por ejemplo,
Si tenemos la seguridad de que no existe otro campo de otra tabla que se llame igual,
entonces podemos prescindir del nombre de la tabla.
Por ejemplo,
En el caso de que el nombre del campo contenga espacios, entonces tendremos que rodear
el campo con corchetes.
Por ejemplo,
ACCESS permite la creación de consultas usando SQL. Esto nos permitirá practicar con el
lenguaje SQL antes de que se aplique posteriormente en nuestras aplicaciones Java.
En este ejercicio guiado se explicará como crear una consulta usando el lenguaje SQL en
Access.
3. Vamos a crear una nueva consulta, por lo que tendrá que activar la opción Crear una
consulta en vista Diseño:
4. En el cuadro de elección de tablas no agregaremos ninguna. Así pues pulsaremos
directamente el botón Cerrar.
6. Aparecerá una pantalla casi en blanco donde escribirá la consulta SQL. Observe que
ya aparece la cláusula SELECT escrita:
SELECT *
FROM trabajadores;
8. Para ver el resultado de esta consulta debe pulsar el botón Vista que se encuentra en
la parte superior izquierda de la ventana:
10. Acaba de crear una consulta dentro de Access usando el lenguaje SQL. Para
modificar de nuevo la consulta SQL tendrá que desplegar el botón Vista y activar de
nuevo la opción SQL:
11. De esta manera entrará de nuevo en el editor de consultas SQL de Access, donde
aún permanecerá la consulta creada:
12. Ahora modificaremos la consulta para que solo nos muestre los campos nombre,
apellidos, sueldo y fecha. Para ello tendrá que escribir la siguiente consulta:
14. Vuelve a la zona de edición de consultas SQL y cambia la consulta para que quede
así:
Como ves, hemos añadido una cláusula where, para buscar solo aquellos
trabajadores cuyo apellido termine en ez.
Supongamos que queremos ver los servicios que han realizado cada uno de estos
trabajadores. Para ello tendremos que incluir a la tabla servicios en la consulta.
Hay que tener en cuenta que es necesario añadir en el WHERE una condición que
iguale el campo de unión entre la tabla trabajadores y la tabla servicios. Este campo
de unión es el DNI.
Como ves, aparecen todos los servicios y el nombre y apellidos del trabajador que
hizo cada uno. Solo aparecen los servicios de los trabajadores cuyo apellido termine
en ‘ez’.
18. Vuelve a la vista de edición SQL. Vamos a complicar aún más la consulta. Esta vez
vamos a hacer que aparezca el nombre del cliente al que se le hizo el servicio.
Como se puede observar, aparece el listado de los servicios realizados por los
trabajadores cuyo apellido termine en ‘ez’. Aparece información incluida en tres tablas
distintas: trabajadores, servicios y clientes.
20. Vuelve a la zona de diseño SQL. Añadiremos una última modificación a la consulta y
la finalizaremos.
22. Hemos finalizado con la consulta. Ciérrela y guárdela. Puede ponerle de nombre
Servicios realizados por trabajadores ez.
NOTA.
La sintaxis del lenguaje SQL puede variar según el programa de base de datos que se use.
En este ejercicio guiado se ha usado la sintaxis del SQL incluido en el programa Access.
Tenga en cuenta que puede haber variaciones entre este SQL y el incluido en otro gestor de
base de datos, aunque estas variaciones son mínimas.
CONCLUSIÓN
Para realizar consultas en la base de datos usando el lenguaje SQL es necesario usar
instrucciones SELECT, las cuales tienen la siguiente forma general:
El programa ACCESS permite crear consultas usando el lenguaje SQL, por lo que
puede ser una buena herramienta para practicar este lenguaje.
Nuestro programa de bases de datos java, usará este lenguaje para manipular la base
de datos correspondiente.
EJERCICIO GUIADO. BASES DE DATOS. SQL
Acciones en SQL
Pero el lenguaje SQL no se queda simplemente ahí, sino que proporciona instrucciones que
pueden realizar acciones sobre la base de datos. Estas acciones son (entre otras):
En esta hoja guiada veremos como ejecutar instrucciones SQL que permitan añadir, eliminar
o modificar registros de las tablas de la base de datos.
Alta de registros en SQL
Se empezará estudiando como añadir nuevos registros en una base de datos usado el
lenguaje SQL.
En la cláusula INSERT INTO se indica la tabla que en la que se quiere introducir una nueva
fila (registro), y en la cláusula VALUES se indican los valores de la fila que se quiere insertar.
Estos valores tienen que estar indicados en el orden en el que están definidos los campos
en la tabla correspondiente.
Por ejemplo:
DNI: 30.234.234-A
Nombre: María
Apellidos: López
Sueldo: 1250,45
Fecha de entrada: 02/01/2006
Matrícula: 4455-RSD
Los valores están indicados en el mismo orden en el que están los campos en la tabla: DNI,
Nombre, Apellidos, Sueldo, Fecha, Matrícula.
Si se quiere introducir un nuevo registro, pero indicando solo los valores de algunos campos,
se puede usar entonces esta otra sintaxis para la instrucción INSERT INTO:
En este caso solo se introducen los valores correspondientes a tres campos, el resto de los
campos del registro se quedarán vacíos.
Por ejemplo:
En este caso introducimos a un trabajador de apellido López, con DNI 30.234.234-A que
cobra 1250,45 euros. Tanto la matrícula de su coche como su nombre y la fecha quedan en
blanco.
Formato de los valores.
Las fechas se indicarán entre almohadillas # y hay que indicar primero el mes, luego el día y
finalmente el año. Por ejemplo: #12-20-2007# es 20 de diciembre de 2007.
En el caso de querer especificar explícitamente que un campo esté vacío, se puede indicar
el valor NULL.
Ejemplo:
2. Crearemos una consulta SQL para añadir registros a la tabla trabajadores. Para ello,
accede a la zona de consultas.
3. Crea una consulta en vista Diseño y no agregues ninguna tabla. Simplemente pulsa
el botón Cerrar.
DNI: 33.444.333-B
Nombre: Antonio
Apellidos: Romero
Sueldo 1300,5
Fecha de entrada: 2-1-2006
(Observa como en la cláusula VALUES se indica la fecha en formato mes-dia-año)
Matrícula de su coche: No se indica (NULL)
6. Este tipo de consulta es de acción. Esto significa que no debe mostrar nada,
simplemente ejecuta una acción sobre la base de datos (en este caso, añadir un
registro nuevo en la tabla trabajadores) Para ejecutar esta consulta de acción activa
el botón Ejecutar:
7. Access avisará de que vas a añadir un nuevo registro, y te pide confirmación. Acepta
la acción:
Es posible usar el lenguaje SQL para modificar los datos de una tabla. Se puede incluso
modificar los datos de aquellos registros que cumplan una condición en concreto.
Para modificar los datos de los registros de una tabla se usará el siguiente código general:
La cláusula SET permite indicar los cambios que se realizarán. Se debe indicar el campo
que se va a cambiar y el nuevo valor que se introducirá en el campo. Como puede observar,
se pueden indicar varios campos a modificar.
La cláusula WHERE permite indicar una condición. Esto hará que solo se cambien los
valores de aquellos registros que cumplan la condición. La cláusula WHERE es opcional, y si
no se indicara se cambiarían todos los registros de la tabla.
Ejemplo:
UPDATE trabajadores
SET sueldo = 1200, matricula=’3355-AAA’
WHERE fecha < #01/01/2004#;
En este ejemplo se les asigna un sueldo de 1200 euros y el coche con matrícula 3355-AAA a
todos aquellos trabajadores que hayan entrado en la empresa antes del 1-1-2004.
Ejemplo:
UPDATE trabajadores
SET sueldo = 1300;
En este ejemplo, se les asigna a todos los trabajadores un sueldo de 1300 euros ya que no
se ha indicado cláusula WHERE.
Si se quisiera hacer un cambio puntual a un registro en concreto, tendremos que hacer uso
de su campo clave para indicar la condición. Recuerda que el campo clave es el que
identifica de forma única a un registro de la tabla.
Por ejemplo:
UPDATE trabajadores
SET sueldo = 1300
WHERE DNI=’33.444.333-A’;
En este ejemplo se estoy asignando un sueldo de 1300 al trabajador con DNI 33.444.333-A,
y a ningún otro (ya que se supone que no habrá otro con dicho DNI)
EJERCICIO GUIADO Nº2
UPDATE trabajadores
SET sueldo = 800, matricula=’1111-AAA’
WHERE DNI=’33.444.333-B’;
Como puedes observar, en esta instrucción SQL vamos a asignarle un sueldo de 800
euros y el coche con matricula 1111-AAA al trabajador con DNI 33.444.333-B, que es
precisamente el trabajador que añadimos en el ejercicio guiado anterior.
6. Ejecuta esta consulta de acción pulsando el botón Ejecutar:
9. Cierre la consulta que está realizando (no hace falta que la guarde)
Al igual que podemos añadir nuevos registros (filas) a las tablas usando SQL, también
podemos usar este lenguaje para eliminar registros de las tablas.
Por ejemplo:
Si se quiere eliminar un solo registro de la tabla, será necesario hacer referencia a su campo
clave. Recuerda que el campo clave es el que identifica de forma única a cada registro.
Esta instrucción SQL borra al trabajador con DNI 33.444.555-A (solamente a él, ya que se
supone que no habrá otro trabajador que tenga ese mismo DNI)
En la cláusula WHERE de una instrucción DELETE, las condiciones se indican tal como se
vio en la hoja anterior para las instrucciones SELECT.
Si se quiere eliminar todo el contenido de una tabla, se puede usar una instrucción DELETE
sin indicar ninguna condición. Por ejemplo:
14. Pulsa el botón SQL para entrar en la zona de edición de consulta SQL.
Como puedes observar, esta instrucción eliminará al trabajador con DNI 33.444.333-
B, que es precisamente el trabajador que se añadió en el ejercicio guiado 1.
17. Access avisará de que va a eliminar una fila de la tabla trabajadores, y pedirá
confirmación. Confirme la eliminación.
18. Para comprobar el ejemplo tendrá que acceder a la tabla trabajadores y comprobar
que el trabajador con DNI 33.444.333-B ya no está. Para ello cierre la consulta (no
hace falta que la guarde) y acceda a la zona de tablas.
Para introducir nuevos datos en la base de datos usará la instrucción SQL llamada
INSERT INTO
Para eliminar datos de la base de datos usará la instrucción SQL llamada DELETE
Para modificar datos de la base de datos usará la instrucción SQL llamada UPDATE
EJERCICIO GUIADO. JAVA. ACCESO A BASE DE DATOS
El objetivo de todas las hojas guiadas anteriores dedicadas a las bases de datos, es
finalmente aprender a crear un fichero que contenga toda la información que la empresa
necesita gestionar. Es decir, crear un fichero de base de datos.
Este fichero se incluirá con el programa java que se realice. Nuestro programa java accederá
a este fichero continuamente para añadir nuevos datos, o modificar datos, eliminar datos, o
extraer datos según lo ordene el usuario del programa.
En esta hoja guiada, se verán los pasos necesarios para conectar un proyecto java con un
fichero de base de datos creado en Access.
Pasos Generales para preparar una Aplicación Java para acceder a una Base de Datos
Para preparar nuestra aplicación Java para que pueda acceder a una Base de Datos, es
necesario realizar tres pasos:
El controlador define el tipo de base de datos que se va a usar (base de datos de Access, o
de MySQL, o de cualquier otro gestor de base de datos)
En nuestro caso, tendremos que indicar el controlador para base de datos de Access.
Para crear este objeto hay que indicar la situación del fichero de base de datos, el usuario y
la contraseña de dicha base de datos. El objeto conexión abre el fichero de la base de datos.
El objeto sentencia se crea a partir del objeto conexión anterior. Los objetos sentencia
permiten realizar acciones sobre la base de datos usando instrucciones SQL.
Así pues, este objeto es vital. Este objeto es el que realmente permite el acceso a los datos
de la base de datos y la manipulación de dicha base de datos.
EJERCICIO GUIADO Nº 1
PLANTEAMIENTO
En este ejercicio se pretende crear una pequeña aplicación de bases de datos que permita
simplemente mostrar los datos de los trabajadores almacenados en la base de datos
MANEMPSA.
5. Entra dentro de esta carpeta y observarás una serie de carpetas creadas por el
propio NetBeans. (Entre ellas, la más interesante es la llamada src, la cual es la que
contiene los ficheros con el código java)
6. Para tener todo bien organizado, crearemos una carpeta llamada Base dentro de la
carpeta de proyecto, de manera que su contenido quede así:
7. Ahora lo único que tiene que hacer es copiar el fichero de base de datos
MANEMPSA.MDB que se encuentra en Mis Documentos dentro de la carpeta Base.
(La extensión de los ficheros de base de datos de Access es MDB)
8. De esta manera, tenemos el fichero de base de datos que hemos creado con Access
guardado dentro de la misma carpeta de proyecto java que usará dicha base de
datos. Se recomienda que esto lo haga cada vez que programe una aplicación de
bases de datos Java.
10. Para poder acceder y manipular una base de datos, es necesario tener dos objetos:
- Un objeto del tipo Connection, al que llamaremos conexion. Este objeto define la
conexión con la base de datos.
- Un objeto del tipo Statement, al que llamaremos sentencia. Este objeto permite
manipular la base de datos.
11. Así pues, lo primero que haremos será definir estos objetos como globales en la
clase de la ventana principal, para así poderlos usar desde cualquier lado:
Aparecerán subrayados ya que será necesario indicar el import para las clases
Connection y Statement. Estos import son respectivamente:
java.sql.Connection
java.sql.Statement
12. Una vez definidos los objetos conexión y sentencia, necesarios para el acceso a la
base de datos, prepararemos nuestro programa para que pueda acceder a la base de
datos MANEMPSA.MDB. Esto se hará en el constructor.
13. En primer lugar, añade al constructor una llamada a una función PrepararBaseDatos:
14. Crea el método PrepararBaseDatos debajo del constructor y empieza a programar lo
siguiente:
El código que acabas de programar es el primer paso a realizar para el acceso a una
base de datos: La Carga del Controlador.
Recuerda que el controlador le indica a Java que tipo de base de datos usaremos:
Access, MySQL, etc…
El controlador que le indica al java que usaremos una base de datos de Access viene
definido a través de la siguiente cadena de texto:
sun.jdbc.odbc.JdbcOdbcDriver
Class.forName(controlador).newInstance();
Básicamente, lo que hacen estas dos líneas de código, es preparar a Java para
poder usar Access.
En el caso de que se quisiera usar una base de datos realizada en otro programa que
no fuera Access, habría que cambiar la cadena de texto correspondiente a su
controlador.
Por ejemplo, para usar una base de datos creada con el gestor de base de datos
MySQL se usa la cadena: com.mysql.jdbc.Driver.
El código que acabas de añadir se corresponde con el segundo paso para acceder a una base de
datos: Crear el objeto Conexión.
El objeto conexión es el que efectúa la conexión real con la base de datos. Se podría decir que es el
objeto que permite abrir la puerta del fichero de base de datos para entrar en él. Para construir este
objeto conexión (el cual ya está declarado en la parte global de la clase) hacen falta tres datos:
El nombre del usuario que manipulará la base de datos. En el caso de Access no necesitamos
indicar ningún nombre de usuario, por eso verás la instrucción:
El password del usuario que manipulará la base de datos. En el caso de Access tampoco
necesitaremos ningún password, por eso verás la instrucción:
La DSN de la base de datos. DSN significa “nombre del origen de datos” y es una cadena de texto
algo compleja que contiene información sobre el fichero de base de datos que queremos usar. La
parte inicial de la cadena de la DSN siempre será igual para las bases de datos de Access:
Sin embargo, lo que nos interesa realmente de esta cadena es su parte final, donde hay que indicar el
camino del fichero de base de datos al que accederemos. En nuestro caso, indicaremos el camino de
MANEMPSA.MDB, el fichero de la base de datos.
Base es la carpeta donde hemos guardado el fichero, dentro de nuestro proyecto java, y
MANEMPSA.MDB como ya sabes es el fichero de Access que contiene la base de datos. Observa la
necesidad de escribir dos barras.
conexion=DriverManager.getConnection(DSN,user,password);
para crear la conexión. Será necesario añadir un import para la clase DriverManager.
Al igual que con el primer paso, es necesario rodear la creación de la conexión con un try…catch
para capturar cualquier error inesperado que se pueda producir en este paso.
16. Ahora añade el siguiente código a continuación del anterior:
Este código que acabas de añadir se corresponde con el tercer paso necesario para poder
acceder a una base de datos: Creación del objeto Sentencia.
El objeto sentencia será el que nos permita ejecutar órdenes SQL sobre la base de datos. Es
decir, el objeto que nos permite actuar y manipular la base de datos. Este objeto es vital, y
es el objetivo de toda esta preparación.
El objeto sentencia se crea a partir del objeto conexión creado en el paso anterior, usando la
siguiente instrucción:
sentencia=conexion.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
Y como sucedió en los dos pasos anteriores, es necesario rodear esta instrucción con un
try…catch para capturar cualquier tipo de error inesperado que se pudiera producir.
17. Así pues ya tenemos preparado nuestro programa para acceder a la base de datos.
Esta preparación se realiza en el momento en que se ejecuta el programa, ya que
hemos introducido este código en el constructor.
Es cierto que este código puede resultar bastante abstracto y complejo, pero tiene la
gran ventaja de que siempre es igual.
Para nuestros ejercicios, solo tendremos que cambiar el nombre de la base de datos
que se esté usando en ese momento. El resto del código queda igual.
Observa:
El método PrepararBaseDatos
siempre será igual, solo cambiará el
nombre de la base de datos a usar.
18. El objetivo de todo este código de preparación para el acceso al fichero de la base de
datos es obtener un objeto llamado sentencia que nos posibilitará la manipulación de
los datos de la base de datos, usando órdenes SQL.
19. Cuando se pulse el botón Ver Datos de Trabajadores tendremos que extraer los
datos de la tabla trabajadores para poder mostrarlos. Para ello, escribe el siguiente
código dentro del evento actionPerformed del botón btnVerDatos:
Observa el código:
El objeto sentencia se usa para dar órdenes a la base de datos. Esas órdenes se dan
usando el lenguaje de consulta SQL.
Se usa el método executeQuery del objeto sentencia para ejecutar la consulta SQL
“select * from trabajadores order by nombre”. Esta consulta extraerá
todos los datos de la tabla trabajadores ordenados por nombre.
Y como puedes observar, es necesario rodear la ejecución de una consulta SQL con
un try…catch para capturar errores inesperados al realizar la consulta.
LOS OBJETOS RESULTSET
20. Debes imaginarte el objeto ResultSet r como una tabla que contiene el resultado de
la consulta SQL que se ha ejecutado. En nuestro caso, la consulta SQL que hemos
ejecutado ha extraído toda la tabla trabajadores. Por tanto nuestro ResultSet contiene
toda la tabla trabajadores.
Trabajadores
DNI Nombre Apellidos Sueldo Fecha Matricula
BOF
21.123.123-A Ana Ruiz 1200 02/03/2002 3322-ASR
22.333.444-C Francisco López 1000 01/06/2006 1144-BBB
12.321.567-B Juan Pérez 1120 04/05/2002 4433-ABB
EOF
21. La fila BOF significa “comienzo de fichero” y representa una fila anterior al primer
registro del ResultSet.
La fila EOF significa “final de fichero” y representa una fila posterior al último registro
del ResultSet.
La flecha indica la posición actual donde estamos situados dentro de la tabla del
ResultSet.
El método next del ResultSet hará que avancemos una fila en el ResultSet. Es decir,
ahora estaremos situados en la primera fila del ResultSet (la flecha avanza una
posición)
Trabajadores
DNI Nombre Apellidos Sueldo Fecha Matricula
BOF
21.123.123-A Ana Ruiz 1200 02/03/2002 3322-ASR
22.333.444-C Francisco López 1000 01/06/2006 1144-BBB
12.321.567-B Juan Pérez 1120 04/05/2002 4433-ABB
EOF
23. Ahora que estamos situados en la posición del primer trabajador (Ana), podemos
extraer información referente a sus campos. Añade el siguiente código al
actionPerformed del botón:
En nuestro caso:
Pulsa el botón…
Y aparecerá
información sobre el
primer trabajador de la
base de datos
25. Sigamos haciendo cambios en el código del botón para entender mejor el
funcionamiento de los ResultSet. Añade la siguiente línea:
26. Se ha añadido un segundo next. Esto producirá que la flecha avance dos posiciones
en el ResultSet, y por tanto se coloque en la segunda fila:
Trabajadores
DNI Nombre Apellidos Sueldo Fecha Matricula
BOF
21.123.123-A Ana Ruiz 1200 02/03/2002 3322-ASR
22.333.444-C Francisco López 1000 01/06/2006 1144-BBB
12.321.567-B Juan Pérez 1120 04/05/2002 4433-ABB
EOF
27. Esto quiere decir que si se ejecuta el programa se mostrará información sobre
Francisco López. Compruébalo:
28. Los objetos ResultSet poseen diversos métodos para cambiar la posición actual en la
tabla del ResultSet. Dicho de otro modo: “para mover la flecha”. Veamos algunos de
estos métodos (se supone que el objeto ResultSet se llama r):
En este caso la flecha se coloca en EOF (afterLast) y luego retrocede una fila
(previous). Por tanto, al ejecutar el programa se mostrarán los datos del último
trabajador. Compruebalo.
Trabajadores
DNI Nombre Apellidos Sueldo Fecha Matricula
BOF
21.123.123-A Ana Ruiz 1200 02/03/2002 3322-ASR
22.333.444-C Francisco López 1000 01/06/2006 1144-BBB
12.321.567-B Juan Pérez 1120 04/05/2002 4433-ABB
EOF
30. Otro experimento. Cambie ahora el código de esta forma:
Este código coloca la flecha en la fila 2 ( absolute(2) ), luego avanza una fila
(next), luego retrocede una fila (previous) y finalmente retrocede una fila
(previous)
Así pues, finalmente, la flecha queda colocada en la primera fila. Por lo tanto se
muestran los datos del primer trabajador. Compruébalo.
Trabajadores
DNI Nombre Apellidos Sueldo Fecha Matricula
BOF
21.123.123-A Ana Ruiz 1200 02/03/2002 3322-ASR
22.333.444-C Francisco López 1000 01/06/2006 1144-BBB
12.321.567-B Juan Pérez 1120 04/05/2002 4433-ABB
EOF
31. Como ves, podemos movernos dentro del contenido del ResultSet gracias a todos
estos métodos, para luego poder extraer los datos de la fila correspondiente.
Ahora, estudiaremos la forma de recorrer todas las filas del ResultSet para así extraer
la información de todos sus registros.
32. Vamos a modificar nuestro código para que se muestren todos los trabajadores del
ResultSet. Para ello, realiza el siguiente cambio:
r.beforeFirst();
while (r.next()) {
info=info+r.getString("nombre")+" "+r.getString("apellidos")+"
"+r.getString("sueldo")+"\n";
}
r.beforeFirst();
while (r.next()) {
El método next intenta colocar la flecha en la siguiente fila, y si lo hace bien, devuelve
el valor verdadero. Cuando no se puede avanzar más, el método next devolverá
falso.
Así pues, este while significa “mientras se haya podido avanzar una fila, haz lo
siguiente”. O dicho de otro modo, este bucle se repetirá para cada fila de la tabla del
ResultSet.
- Si analizamos el contenido del bucle, básicamente veremos una concatenación de
cadenas dentro de la variable info. En cada vuelta del bucle se concatenará el
nombre, apellidos y sueldo de cada trabajador.
info=info+r.getString("nombre")+" "+r.getString("apellidos")+"
"+r.getString("sueldo")+"\n";
Al pulsar el botón…
r.beforeFirst();
while (r.next()) {
manipulación de la fila
}
35. Se ha visto que para obtener un dato de la fila actual se usa el método getString
indicando como parámetro el dato que se quiere obtener.
Por ejemplo:
r.getString(“sueldo”);
Obtiene el sueldo del trabajador señalado actualmente con la flecha. Este sueldo se
obtiene convertido en cadena.
36. Los ResultSet poseen otros métodos para obtener los datos convertidos en números
como son:
getInt(“campo”)
getDouble(“campo”)
Esto nos permite el realizar operaciones con los datos extraídos del ResultSet.
Dentro del bucle, se van acumulando el sueldo de cada trabajador. Observa el uso de
getDouble para obtener el campo sueldo de forma numérica, en vez de usar
getString:
totalsu=totalsu+r.getDouble("sueldo");
Y finalmente usamos otro JOptionPane para ver la suma de los sueldos calculada.
Como ves, también hay que encerrar este código entre try…catch para evitar posibles
errores.
CONCLUSIÓN
Para crear un programa Java que pueda usar una base de datos será necesario
realizar los siguientes pasos:
- Las consultas SQL ejecutadas en la base de datos se almacenan en objetos del tipo
ResultSet
Recapitulando…
Para hacer una aplicación java que acceda a una base de datos se tiene que…
En la hoja anterior se vio que se puede usar el objeto sentencia para ejecutar una consulta
SQL en la base de datos. Al hacer esto se consigue un objeto ResultSet que contiene el
resultado de la consulta.
getString
getDouble
getInt
según queramos extraer el dato en forma de cadena, de número real o número entero.
En esta hoja guiada se insistirá sobre la forma de manipular los datos contenidos en un
ResultSet
EJERCICIO GUIADO Nº 1
PLANTEAMIENTO
Se quiere realizar una pequeña aplicación de base de datos que nos muestre información
sobre los servicios realizados en la empresa MANEMPSA. Para ello, siga los pasos que se
indican a continuación:
2. En la parte superior de la ventana añade un botón con el texto Ver Datos Servicios
que se llame btnServicios.
4. Como se vio en la hoja anterior, interesa colocar el fichero de la base de datos que se
va a usar en una subcarpeta de la carpeta de proyecto que se está haciendo.
5. Y dentro de ella crea una carpeta Base. Dentro de la carpeta Base copia el fichero de
base de datos MANEMPSA.MDB, el cual se encuentra dentro de la carpeta Mis
Documentos.
Copia aquí dentro
el fichero de base
de datos
MANEMPSA.MDB
8. Ahora que hemos preparado nuestro proyecto para poder usar la base de datos
MANEMPSA.MDB, ya podemos programar el botón para visualizar los servicios.
Entra dentro del actionPerformed de este botón y programa lo siguiente:
Si observas el código, lo que hace es ejecutar la consulta SQL
la cual extrae todos los servicios almacenados en la tabla servicios ordenados por
cantidad de menor a mayor.
while (r.next()) {
info=info+r.getString("tipo")+" "+r.getString("cantidad")+"\n";
}
12. Como se ha podido observar, las fechas extraídas del ResultSet tienen un formato
distinto al que usamos normalmente.
Para mejorar la presentación de las fechas extraídas del ResultSet haz los siguientes
cambios en el código:
El código se ha mejorado de forma que la fecha aparezca en un formato español
correcto. Ejecuta el programa para comprobar el resultado:
cadfecha=r.getString("fecha");
2 0 0 5 - 1 2 - 2 1 - 0 0 : 0 0 : 0 0
cadanio=cadfecha.substring(0,4);
cadmes=cadfecha.substring(5,7);
Para extraer el dia de la cadena, tendremos que extraer los caracteres comprendidos
entre la posición 8 y la posición 9 de la cadena. Esto se hace usando el método
substring de la siguiente forma:
caddia=cadfecha.substring(8,10);
Una vez extraídos dia, mes y año, de la cadena, podemos concatenarlos formando
una fecha en formato dia/mes/año de la siguiente forma:
cadfecha=caddia+"/"+cadmes+"/"+cadanio;
Así pues, finalmente tenemos una variable cadfecha que será la que se visualizará en
el JOptionPane:
14. Ahora mejoraremos el programa para que los costes de los servicios aparezcan con
coma decimal, en vez de punto decimal:
cadcoste=r.getString("cantidad");
cadcoste=cadcoste.replace(".",",");
VALORES NULOS
15. Es posible que algún campo de algún registro de la tabla esté vacío. Es decir, que
sea nulo. Si esto ocurre, entonces al extraer dicho dato de la tabla usando getString
aparecerá el valor null en el JOptionPane.
16. Para comprobar esta circunstancia, agrega un nuevo botón a la ventana principal con
el texto “Ver Datos de Clientes”. Llámalo por ejemplo btnClientes.
18. Ejecuta el programa ahora y prueba a pulsar este nuevo botón. Observa el resultado.
Cada vez que un cliente no tenga un teléfono, aparecerá el valor “null” en el
JOptionPane:
19. Vamos a arreglar esto de forma que aparezca el texto “no tiene” en vez de la cadena
“null”. Modifique el código como se indica:
Como puedes ver, lo que se hace ahora es comprobar si el valor extraído del
ResultSet es null, y en ese caso, se concatena la cadena no tiene. En caso contrario
se concatena el valor del campo.
CONCLUSIÓN
A través del objeto sentencia podemos ejecutar una consulta SQL en una base de
datos.
Cuando un campo está vacío, al intentar extraer su valor obtendremos el valor null.
EJERCICIO GUIADO. JAVA. ACCESO A BASE DE DATOS
Para ejecutar una consulta sobre la base de datos desde tu aplicación java se tiene que
ejecutar una instrucción usando el objeto sentencia de la siguiente forma:
ResultSet r = sentencia.executeQuery(“consulta_sql”);
La consulta_sql es una cadena que tiene forma de consulta SQL bien escrita (sin fallos). Por
ejemplo:
String consulta;
consulta=”select * from trabajadores”;
ResultSet r = sentencia.executeQuery(consulta);
En este código que se acaba de mostrar, se crea una cadena llamada consulta. Se le asigna
a esta cadena una instrucción SQL para extraer todos los trabajadores, y finalmente se
ejecuta dicha instrucción SQL usando el objeto sentencia.
String consulta;
consulta=”select * from ” + txtTabla.getText();
ResultSet r = sentencia.executeQuery(consulta);
“select * from “
con
La gran ventaja de esto, es que el usuario podrá escribir el nombre de una tabla cualquiera
dentro del cuadro de texto txtTabla y al ejecutarse este código se extraerá el contenido de
dicha tabla.
Es decir, el usuario podrá decidir lo que quiere consultar. El usuario afecta a la construcción
de la consulta SQL, y por tanto, tiene cierto control sobre esta consulta.
PLANTEAMIENTO
Se quiere realizar una aplicación de base de datos que nos muestre información sobre los
trabajadores de la empresa MANEMPSA.
Esta aplicación le dará al usuario la capacidad de elegir la información que quiere extraer de
la base de datos. Es decir, el usuario tendrá cierto control sobre las consultas que se
realicen.
- Luego extrae del ResultSet los campos nombre, apellidos, sueldo y fecha.
- Hay que indicar que al campo sueldo se le cambia el punto decimal por la coma
decimal.
- Por otro lado, la fecha se transforma para que tenga el formato dia/mes/año
String consulta;
consulta = “select * from trabajadores where sueldo = “+txtSueldo.getText();
ResultSet r = sentencia.executeQuery(consulta);
Aquí se crea una variable de texto llamada consulta y luego se concatena en ella la cadena:
con
Si el cuadro de texto del sueldo contuviera un 1000, entonces la cadena resultante sería:
Es decir, se construye una consulta que busca los sueldos de 1000 euros.
9. Prueba a ejecutar el programa. Escribe un valor 1000 en el cuadro de texto y luego
pulsa el botón Igual. El resultado será que aparecen solo los trabajadores que tengan
1000 de sueldo.
Al pulsar el botón
Igual se construye
una consulta usando
el contenido del
cuadro de texto
txtSueldo.
Al ejecutarse la
consulta se muestran
los trabajadores de
1000 euros.
10. Programa ahora el botón Mayor que de la siguiente forma (El código es
prácticamente igual al anterior, así que puedes usar copiar y pegar. Se indica con
una flecha la pequeña diferencia)
Como se puede observar, el código es igual. Simplemente cambia el operador en la
cadena que se concatena. Ahora se usa un mayor que.
12. Como práctica, programe el botón Menor que de forma que muestre aquellos
trabajadores que cobren menos de la cantidad introducida en el cuadro de texto
txtSueldo.
13. Vamos a seguir mejorando el programa. Añada ahora el siguiente cuadro de texto y
los siguientes botones:
15. Empezaremos programando el botón Igual a. Para ello, escriba el siguiente código
dentro del botón (este código es parecido a los anteriores, puede usar copiar y pegar
y luego realizar las modificaciones pertinentes)
Observa la modificación del código. Puedes ver que la consulta SQL se consigue
concatenando tres cadenas (se han puesto en color para facilitar la comprensión):
Es decir, el resultado de la concatenación sería una consulta SQL que muestra aquellos
trabajadores que tengan de nombre Ana.
NOTA:
Recuerda que cuando se especifica un valor de tipo texto en una consulta SQL, es
necesario que esté rodeado de comillas simples (‘)
Se escribe Ana en el
cuadro de texto y al
pulsar el botón Igual
a se construye una
consulta SQL que
muestra a los
trabajadores con el
nombre Ana.
17. Ahora programaremos el botón Contiene a de forma que el usuario escriba un texto
en el cuadro del nombre, y al pulsar el botón Contiene a aparezcan todos aquellos
trabajadores cuyo nombre contenga el texto escrito.
18. Para ello programe lo siguiente en el actionPerformed del botón Contiene a (es un
código muy parecido al anterior, solo tiene que realizar una pequeña modificación)
En este caso, para crear la consulta se concatenan tres cadenas (se indican en color para
facilitar la comprensión)
Supongamos que escribimos en el cuadro de texto del nombre la palabra an, el resultado de
la concatenación sería el siguiente:
NOTA:
Cuando se estudiaron las consultas SQL, se vio que el operador like funcionaba a través de
asteriscos. Es decir, la forma “correcta” de indicar la condición anterior sería la siguiente:
Sin embargo, hay que decir que el asterisco se debe usar solamente cuando estamos
manipulando una base de datos de Access desde dentro. En el caso de que queramos
acceder a ella desde una aplicación java se usarán porcentajes % en vez de asteriscos.
19. Ejecuta el programa y prueba a escribir en el cuadro de texto del nombre el texto fra.
Luego pulsa el botón Contiene a y comprueba el resultado. Deben aparecer todos
aquellos trabajadores cuyo nombre contenga el texto fra. Por ejemplo, Francisco.
Se escribe fra, se
pulsa el botón
Contiene a, y
entonces el
programa construye
una consulta que
muestra los
trabajadores cuyo
nombre contenga
fra.
20. Sigamos mejorando el programa. Añade estos cuadros de texto y estos botones:
- El usuario introducirá una fecha (día, mes y año) en los cuadros de texto
txtDia, txtMes, txtAnio.
Presta mucha atención al código remarcado. En él, se construye una consulta que permite
mostrar aquellos trabajadores cuya fecha de entrada en la empresa sea anterior a la
indicada en los cuadros de texto.
Es decir, la cadena resultante es una consulta SQL que busca los trabajadores cuya fecha
de entrada en la empresa sea anterior al 20 del 12 del 2006
NOTA:
Recuerda que para que Access entienda las fechas al hacer una consulta SQL, es necesario
indicarlas en el formato mes/dia/año.
Por otro lado, recuerda que las fechas deben estar rodeadas por almohadillas #
23. Ejecuta el programa y prueba a introducir una fecha en las casillas correspondientes.
Luego pulsa el botón Anterior y observa como aparecen los trabajadores que
entraron antes de la fecha indicada.
Introduce un día,
mes y año en los
cuadros
correspondientes.
Al pulsar el botón
Anterior, el
programa
mostrará los
trabajadores que
hayan entrado
antes de esa
fecha.
24. Como ejercicio se propone que programe el botón Después. Al pulsar este botón, se
mostrarán los trabajadores que hayan entrado antes de la fecha indicada en los
cuadros de texto. El código es prácticamente igual al código del botón Anterior.
CONCLUSIÓN
A través del objeto sentencia podemos ejecutar una consulta SQL en una base de
datos.
A tener en cuenta lo siguiente acerca de las consultas SQL ejecutadas desde una
aplicación java para acceder a una base de datos de Access:
Estas consultas permiten extraer datos de la base de datos. Dicho de otro modo,
permiten visualizar información de la base de datos que cumpla un criterio.
Estas consultas realizan una acción sobre la base de datos. Esta acción puede ser:
Hasta ahora se han realizado programas java que ejecutaban consultas de selección sobre
la base de datos.
Recuerda que para ejecutar estas consultas se usa el método executeQuery del objeto
sentencia y el resultado de la consulta se almacena en un objeto ResultSet:
En esta hoja guiada veremos la ejecución de consultas de acción sobre la base de datos
desde la aplicación java. Este tipo de consultas se ejecutan usando el método
executeUpdate del objeto sentencia, y no devuelven un resultado concreto, ya que
simplemente actúan sobre la base de datos modificando de alguna manera su contenido.
sentencia.executeUpdate(“insert . . .”);
sentencia.executeUpdate(“update . . . “);
sentencia.executeUpdate(“delete . . . “);
EJERCICIO GUIADO Nº 1
PLANTEAMIENTO
Se quiere realizar una aplicación de base de datos que manipule los datos de los
trabajadores de la base de datos MANEMPSA. Esta aplicación permitirá ver el listado de
trabajadores y además permitirá introducir nuevos trabajadores.
Básicamente lo que hace es ejecutar una consulta SQL que recoge todos los datos de la
tabla trabajadores y luego muestra dichos datos en el panel de la ventana.
Se muestra el listado procurando que las fechas aparezcan con el formato dia-mes-año, que
los sueldos aparezcan con la coma decimal y que si el campo matrícula fuera nulo o la
cadena vacía “”, entonces aparezca el texto “sin coche”.
Panel: panelAlta
Cuadros de Texto:
txtDNI
txtNombre
txtApellidos
txtSueldo
txtDia
txtMes
txtAnio
txtMatricula
Botón: btnAlta
Luego, al pulsar el botón de Alta, se introducirá en la tabla trabajadores los datos del
nuevo trabajador y aparecerá en el panel la lista actualizada de trabajadores
incluyendo al nuevo que se ha añadido.
Lo primero que hay que tener en cuenta es que se realiza una concatenación de cadenas
dentro de la variable consulta.
Observa el uso de += para concatenar. Ten en cuenta que es lo mismo poner esto:
consulta += “’”+txtDNI.getText()+”’,”;
Por ejemplo, supongamos que introducimos los siguientes valores en los cuadros de texto:
txtDNI 11.111.111-A
txtNombre María
txtApellidos Ruiz
txtSueldo 1100
txtDia 10
txtMes 4
txtAnio 2001
txtMatricula 4433RET
La concatenación en la variable consulta resultaría lo siguiente (en azul los valores de los
cuadros de texto, en rosa las cadenas que se concatenan):
El objeto que se encarga de ejecutar dentro de la base de datos la instrucción SQL recién
construida es el objeto sentencia:
sentencia.executeUpdate(consulta);
Como se puede observar, para ejecutar instrucciones SQL de acción ya no se usa el método
executeQuery, sino que se usa el método executeUpdate.
Una vez ejecutada la introducción del nuevo registro en la base de datos, se llama al
procedimiento MostrarTodos el cual se encarga de mostrar todo el contenido de la tabla
trabajadores en el panel de texto. Gracias a este método, veremos como se rellena el panel
y observaremos al nuevo registro recién introducido.
Hay que tener en cuenta que todo este código está rodeado de un try ... catch para evitar
cualquier error inesperado. Ten en cuenta que pueden producirse errores fácilmente si
introducimos valores incorrectos en los cuadros de texto.
En la parte
superior aparecerá
el listado completo
incluyendo al
nuevo trabajador
introducido.
CONCLUSIÓN
Se pueden ejecutar instrucciones SQL del tipo INSERT INTO (insertar registros)
usando el objeto sentencia.
En la hoja guiada anterior se vio como se podían ejecutar consultas SQL de acción del tipo
INSERT INTO (para insertar registros en las tablas de la base de datos)
En esta hoja guiada se practicará con otras consultas SQL de acción. Concretamente con
las del tipo DELETE (usadas para eliminar registros de las tablas de la base de datos)
Al igual que ocurre con las consultas INSERT INTO, las consultas DELETE haya que
ejecutarlas usando el método executeUpdate del objeto sentencia.
sentencia.executeUpdate(“delete . . . “);
PLANTEAMIENTO
Panel: panelBajas
Botón: btnEliminar
Esto se hace para extraer aquellos trabajadores que tengan el DNI introducido en el cuadro
de texto txtDNIEliminar. La idea es saber si existe en la tabla algún trabajador con dicho DNI.
Al ejecutar esta consulta, el ResultSet r se llenará con trabajadores que tengan ese DNI.
if (!r.first()) {
Este if significa: “si no puedo colocarme en el primer elemento del ResultSet r”.
Si no es posible colocarse en el primer elemento del resultado de la consulta será porque no
hay un primer elemento, o dicho de otra forma, porque el ResultSet está vacío, o dicho de
otra forma más, porque no se encontró a nadie que tuviera el DNI indicado.
Si esto fuera así, no existe un trabajador con dicho DNI y por tanto no puede ser borrado. Así
pues se muestra un mensaje con un JOptionPane indicando dicha circunstancia.
En caso contrario, existe ese trabajador y por tanto podemos borrarlo. Observa el contenido
del else:
resp=JOptionPane.showConfirmDialog(null,"¿Confirma el borrado?",
"Borrar",JOptionPane.YES_NO_OPTION);
if (resp==JOptionPane.YES_OPTION) {
Como puede observar, se construye a través de una concatenación, una consulta de acción
SQL del tipo DELETE, que nos permitirá borrar el trabajador con el DNI introducido.
Luego se ejecuta dicha instrucción usando el método executeUpdate del objeto sentencia
(recuerde que usará siempre executeUpdate para ejecutar consultas de acción: altas,
eliminación y modificación)
Finalmente se llama de nuevo al método que creamos en la hoja anterior que muestra todo
el contenido de la tabla trabajadores, y de esta forma podremos comprobar el borrado del
trabajador.
Por otro lado, todo este código es susceptible de sufrir errores inesperados, por lo que está
rodeado por un try ... catch.
Se pueden ejecutar instrucciones SQL del tipo DELETE (borrar registros) usando el
objeto sentencia.
Para realizar borrados será necesario habitualmente el comprobar que los registros a
borrar existen en la tabla. Esto se hará ejecutando una consulta SELECT y
comprobando si el ResultSet resultante contiene algún registro, usando el método
first.
Estas consultas SQL se ejecutan desde el programa a través del método executeUpdate
propio del objeto sentencia.
En las hojas anteriores se ha visto como ejecutar consultas INSERT INTO y DELETE. En
esta hoja guiada veremos como ejecutar consultas de acción de modificación: UPDATE.
EJERCICIO GUIADO Nº 1
PLANTEAMIENTO
Se mejorará el proyecto realizado en la hoja anterior de forma que no solo permita añadir y
borrar trabajadores de la tabla trabajadores de la base de datos MANEMPSA, sino que
también permita realizar modificaciones en los datos de los trabajadores de dicha tabla.
El panel se llamará
panelModificar
El botón es btnBuscar
txtModDNI
txtModNombre
txtModApellidos
txtModSueldo
txtModDia
txtModMes
txtModAnio
txtModMatricula
El botón es btnModificar
3. La mejora que se pretende hacer es la siguiente:
- Cuando aparezcan los datos del trabajador en los cuadros de texto, el usuario
podrá realizar las modificaciones pertinentes.
if (!r.first()) {
En caso contrario muestra los datos del trabajador encontrado en los cuadros de texto. Para
ello, se extrae del ResultSet cada campo y se coloca en el cuadro de texto correspondiente.
Por ejemplo:
txtModNombre.setText(r.getText(“nombre”));
cadefe = r.getString("fecha");
caddia=cadefe.substring(8,10);
cadmes=cadefe.substring(5,7);
cadanio=cadefe.substring(0,4);
txtModDia.setText(caddia);
txtModMes.setText(cadmes);
txtModAnio.setText(cadanio);
año-mes-dia-hora:minutos
Así pues, si el DNI introducido pertenece a uno de los trabajadores de la tabla, sus datos
aparecerán en los cuadros de texto cuando se pulse el botón Buscar.
5. Ejecuta el programa y comprueba su funcionamiento. Escribe un DNI en el cuadro del
DNI de búsqueda y pulsa Buscar.
Se introduce un DNI y
luego se pulsa Buscar.
6. Se supone que cuando aparezcan los datos del trabajador en los cuadros de texto el
usuario los modificará según le interese. Luego, al pulsar el botón Efectuar
Modificación los nuevos datos serán actualizados en la tabla.
Debe observar que lo primero que se hace en este código es crear una consulta de
actualización (UPDATE) a través de una concatenación de cadenas.
Si observa la concatenación, verá que el resultado es una instrucción SQL de tipo UPDATE
en la que los datos que se actualizan son precisamente los datos introducidos en los cuadros
de texto del panel de modificación.
Por ejemplo, si estos fueran los valores de los cuadros de texto del panel de modificación:
txtModDNI 11.111.111-A
txtModNombre Juan
txtModApellidos Perez
txtModSueldo 1100
txtModDia 4
txtModMes 12
txtModAnio 2001
txtModMatricula 1234-ABC
update trabajadores
set nombre=’Juan’,apellidos=’Perez’,sueldo=1100,fecha=#12/4/2001#, matricula=’1234-ABC’
where dni=’11.111.111-A’
Esta instrucción SQL de tipo UPDATE incluye una cláusula WHERE con una condición de
forma que solo se modifica aquel trabajador que tenga el DNI introducido en el cuadro de
texto txtModDNI.
Una vez construida la consulta UPDATE, esta se ejecuta usando el objeto sentencia y luego
se muestra el contenido de la tabla trabajadores en el panel a través de una llamada al
método MostrarTodos.
Todo este código está rodeado de un try...catch para evitar errores inesperados.
Luego cambia algún dato de los que han aparecido en los cuadros de texto y pulsa el
botón Efectuar Modificación.
Se realiza la modificación
que se quiera en los
cuadros de texto.
Finalmente se pulsa
Efectuar Modificación para
que se realice la
modificación.
En el panel aparecerá la
lista actualizada de los
trabajadores.
CONCLUSIÓN
Se pueden ejecutar instrucciones SQL del tipo UPDATE (modificar registros) usando
el objeto sentencia.
Es una buena idea dar alguna opción de búsqueda que permita encontrar al registro a
modificar y que sus datos aparezcan en varios cuadros de texto, de forma que el
usuario tenga más facilidad a la hora de realizar los datos.
EJERCICIO GUIADO. JAVA. ACCESO A BASE DE DATOS
Tablas (JTable)
Como se ha estudiado en las hojas guiadas anteriores, se pueden extraer datos de la base
de datos a través de consultas SQL de tipo SELECT. Los datos extraídos se almacenan en
objetos de tipo ResultSet.
Luego, solo hay que analizar el contenido del objeto ResultSet para extraer los datos que
contiene y trabajar con ellos.
En las hojas anteriores hemos extraído los datos del ResultSet y los hemos presentado en
un JOptionPane o en un JTextPane. Sin embargo, una mejor opción para presentar el
contenido de un ResultSet es usar objetos del tipo JTable, ya que estos objetos tienen forma
de tabla.
En esta hoja guiada se estudiarán los objetos JTable (sin tener en cuenta a las bases de
datos) Una vez que entendamos el funcionamiento de los objetos JTable, los usaremos en
posteriores hojas guiadas para presentar dentro de ellos el contenido de consultas SQL.
EJERCICIO GUIADO Nº 1
El nombre del objeto JTable será simplemente tabla. Debes tener en cuenta que los
objetos JTable se añaden siempre dentro de un panel de desplazamiento JScrollPane:
2. El objeto tabla que se acaba de introducir tiene por defecto cuatro columnas con los
nombres “Título 1”, “Título 2”, “Título 3” y “Título 4”, y contiene cuatro filas vacías.
Puede ejecutar el programa para ver el funcionamiento del objeto tabla. Pruebe a
introducir algún dato en las celdas de la tabla...
Haz doble clic para
introducir datos en
las celdas...
MODELOS (recordatorio)
Hay que recordar que existen objetos en java que contienen un objeto modelo, encargado de
contener los datos del objeto. Un ejemplo de ello son las listas y los combos (cuadros
desplegables)
Para definir los datos contenidos en el objeto, primero había que definir el modelo y luego
asignar el modelo al objeto.
El caso de las tablas es igual. Para introducir datos en la tabla primero hay que configurar su
objeto modelo (que será de la clase DefaultTableModel) y luego asignárselo a la tabla.
El valor null hace que la tabla aparezca vacía en un principio, mientras que el vector títulos
define las columnas que tendrá la tabla.
Una vez construido de esta forma el objeto modelo m, este se asigna al objeto tabla:
tabla.setModel(m);
La razón por la que se ha declarado el objeto modelo m como global es que será usado en
otros métodos del programa.
6. Vamos a añadir un botón a la ventana con el texto Nueva Fila, al cual llamaremos
btnNueva:
7. Dentro del botón btnNueva programa lo siguiente
Este código añadirá una nueva fila en blanco a la tabla. Estudiemos cada línea:
La primera línea recoge el modelo de la tabla a través del método getModel. El modelo es
recogido en la variable global m que creamos anteriormente. Observa como es necesario
realizar un cast (en rojo) a la hora de asignar el modelo a la variable m:
m = (DefaultTableModel) tabla.getModel();
Por ejemplo, se usará el modelo m para añadir una fila en blanco en la tabla. Para ello, basta
con crear un vector de cadenas de 5 elementos (ya que hay cinco columnas):
Y luego, a través del método addRow (añadir fila), añadir una fila correspondiente a los
valores del vector:
m.addRow(filavacia);
Debido a que el vector está vacío, la fila que se añade está vacía también. Si el vector
contuviera algún dato, estos datos aparecerían en la fila que se añade (esto se verá a
continuación)
7. Ejecuta el programa y pulsa varias veces el botón Nueva Fila. Observarás como se
van añadiendo filas vacías a la tabla.
Pulsa el botón y se
añadirán filas en
blanco...
Puedes observar que el código es parecido al anterior, solo que en este caso se añade una
fila correspondiente a un vector relleno de datos. Esto quiere decir que cuando se añada
esta fila al modelo aparecerá con los datos del vector.
10. Ejecuta el programa y comprueba su funcionamiento, observarás que al pulsar el
nuevo botón aparecen filas rellenas.
Cuando se pulsa el
botón Nuevo Elemento
aparecen filas ya
rellenas.
11. Sigamos experimentando con la tabla. Ahora añadiremos un botón btnEliminar con el
texto “Eliminar Fila”:
12. Este botón eliminará la fila que esté seleccionada en ese momento. Para ello
programe en este botón el siguiente código:
Estudiemos este código. En primer lugar usamos un método que poseen los objetos JTable
llamado getSelectedRow que nos dice el número de la fila que está seleccionada en este
momento.
En el caso de que haya alguna fila seleccionada (es decir, que no se haya devuelto el valor
–1) entonces efectuamos el borrado.
Para borrar recogemos el modelo de la tabla y usamos un método llamado removeRow para
borrar la fila seleccionada (la cual se pasa como parámetro)
13. Ejecuta el programa y añade varias filas. Luego prueba a seleccionar alguna y pulsar
el botón Eliminar. Observa también lo que sucede cuando intentas eliminar una fila
cuando no hay ninguna seleccionada.
Si no hubiera ninguna
fila seleccionada
aparecería un
mensaje de error.
14. Sigamos aprendiendo nuevas cualidades de las tablas. Añada lo siguiente a su
ventana:
Estudiemos el código.
Primero, se recogen los valores introducidos en los cuadros de texto de la fila y columna y se
convierten a enteros:
fila = Integer.parseInt(txtFila.getText());
col = Integer.parseInt(txtColumna.getText());
Luego, se extrae el modelo de la tabla y se usa un método llamado getValueAt. Este método
permite extraer el valor de una casilla de la tabla, indicando la fila y columna de esa celda. El
resultado lo hemos almacenado en una variable valor de tipo cadena. Es necesario realizar
un cast (en rojo):
valor = (String) m.getValueAt(fila,col);
Finalmente, una vez extraído el valor de la celda de la posición fila, col este se coloca en la
etiqueta etiValor.
Este código es susceptible de dar error, por ejemplo si el usuario introduce unos valores de
fila y columna incorrectos. Por eso ha sido incluido dentro de un try...catch.
16. Ejecuta el programa y añade varias filas. Introduce algunos valores en las filas.
Luego prueba a introducir un valor de fila y columna y pulsa el botón Ver Valor:
Se introdujo la
posición: 2, 1.
btnIntroducir txtNuevoValor
18. Se pretende lo siguiente. El usuario introducirá un valor de fila y de columna en los
cuadros de texto correspondientes. Luego, el usuario introducirá un valor en el
cuadro de texto txtNuevoValor. Finalmente pulsará el botón btnIntroducir.
Lo primero que se hace es extraer de los cuadros de texto la fila, columna y el valor. La fila y
columna son convertidas a enteros.
fila = Integer.parseInt(txtFila.getText());
col = Integer.parseInt(txtColumna.getText());
valor = txtNuevoValor.getText();
Luego se extrae (como siempre) el modelo de la tabla y se usa un método suyo llamado
setValueAt que permite introducir un valor en una celda de la tabla. Concretamente, se
introduce el valor escrito por el usuario en la celda con fila y columna indicadas:
m=(DefaultTableModel) tabla.getModel();
m.setValueAt(valor,fila,col);
Este código es susceptible de tener errores de ejecución (por ejemplo que el usuario
introduzca un valor equivocado en la fila y columna) por eso está rodeado de un try...catch.
19. Ejecuta el programa. Añade varias filas en blanco. Luego introduce un valor para la
fila y la columna y escribe un valor que quieras introducir. Al pulsar el botón Introducir
dicho valor aparecerá en la celda correspondiente:
Introduce una fila y
columna.
Y al pulsar el botón
Introducir el resultado es
que el dato se introduce
en la celda indicada por la
fila y columna.
Existe una clase llamada JTable que permite crear objetos con forma de tabla.
Estos objetos son ideales para mostrar el contenido de las tablas de una base de
datos, aunque pueden ser usados de forma independiente también para mostrar
cualquier tipo de datos.
Cada vez que se quiera trabajar con una tabla será necesario construir su modelo y
asignárselo a la tabla.
Cada vez que se quiera modificar de alguna forma los datos de una tabla, será
necesario acceder a su modelo y trabajar con él.
A través del modelo de una tabla podemos añadir nuevas filas a la tabla, eliminar filas,
extraer datos de las celdas de la tabla o añadir datos a las celdas de la tabla.
EJERCICIO GUIADO. JAVA. ACCESO A BASE DE DATOS
En la hoja guiada anterior vimos que existe un tipo de objeto llamado JTable que nos permite
introducir tablas en nuestras aplicaciones.
Estos objetos son ideales para mostrar el contenido de una tabla de la base de datos o del
resultado de una consulta.
Recuerda que para extraer datos de la base de datos realizamos una consulta SQL de tipo
SELECT cuyo resultado se almacena en un objeto ResultSet.
Un ResultSet básicamente es una tabla almacenada en memoria (y por tanto no visible) Sin
embargo, en esta hoja guiada veremos como trasladar el contenido de un ResultSet a un
JTable para que el usuario pueda visualizar los datos de forma cómoda.
1. Crear un proyecto java y prepararlo para que pueda acceder a la base de datos
MANEMPSA.MDB:
a. Crear una subcarpeta Base y copiar dentro de ella el fichero de base de datos
MANEMPSA.MDB
2. Una vez hecho esto, añade a la ventana principal un objeto JTable y llámalo
simplemente tabla.
El resultado de esto es que la tabla aparecerá vacía y sin títulos (En realidad, como
títulos aparecen letras: A, B, C, etc)
Como ves, lo que hacemos es definir un vector de cadenas con los títulos correspondientes
a los campos de la tabla, y luego usamos este vector para crear el modelo de la tabla.
8. Ahora ya solo nos queda recoger todo el contenido del ResultSet y mostrarlo en la
tabla. Para ello, modifique el código del actionPerformed del botón Trabajadores para
que quede como sigue:
Si estudiamos el código, veremos que se extrae la tabla trabajadores entera introduciéndola
en un ResultSet llamado r, a través de una instrucción SELECT de SQL.
Una vez hecho esto, creamos un vector de seis elementos, correspondiente a los seis datos
que contiene cada fila, y empezamos a recorrer el ResultSet usando el típico:
while (r.next()) {
En cada vuelta del bucle tomamos los valores de la fila del ResultSet y los almacenamos en
el vector (en la posición correspondiente)
Así pues, en cada vuelta se añadirá un registro más al modelo m. Estos registros son
extraídos del ResultSet.
Todo este proceso se rodea con un try...catch para evitar errores inesperados.
9. Para entender el código anterior aquí tienes un pequeño gráfico explicativo:
10. Ejecute el programa y observe el resultado al pulsar el botón Trabajadores. Como ve,
el objeto tabla muestra entonces el contenido de la tabla Trabajadores.
Año-mes-dia hora:min:seg
12. Ejecuta ahora el programa y observa como se muestran las fechas y los sueldos:
CONCLUSIÓN
El proceso a seguir para mostrar una tabla de una base de datos en un JTable es el
siguiente:
- Realizar una consulta SELECT para extraer los datos de la tabla de la base de
datos. El resultado se almacenará en un ResultSet.
- Una vez que el modelo de tabla está relleno, asignar el modelo a un JTable.
EJERCICIO GUIADO. JAVA. ACCESO A BASE DE DATOS
En la hoja guiada anterior se vio como mostrar el contenido de una tabla de la base de datos
en un JTable de la aplicación java.
Se puede aprovechar esta idea de forma que todas las operaciones que realicemos sobre
una tabla se vean inmediatamente reflejadas en el JTable de la aplicación java.
- Extraemos del modelo del JTable el dni del trabajador seleccionado (este dni se
encuentra en la fila seleccionada –filsel- columna 0 –la primera columna-):
m = (DefaultTableModel) tabla.getModel();
dni = (String) m.getValueAt(filsel,0);
- Ahora se construirá una instrucción de acción SQL del tipo DELETE para que se elimine
el trabajador con el dni extraído. Esto se hace concatenando y ejecutando la instrucción
SQL a través del objeto sentencia:
11. Cuando se pulse el botón Nuevo se pretende que aparezca un formulario donde se
puedan introducir los datos de un nuevo trabajador. Esto se conseguirá añadiendo un
cuadro de diálogo a nuestro proyecto. Para ello, agrega un JDialog al proyecto. Este
diálogo se llamará dialogoNuevo.
12. Haga doble clic en el Inspector sobre el dialogoNuevo para diseñarlo. Debe quedar
como sigue, con los nombres que se indican a continuación:
txtNuevoDni
txtNuevoNombre
txtNuevoApellidos
txtNuevoSueldo
txtNuevoMatricula
btnNuevoAceptar
btnNuevoCancelar
13. La idea es la siguiente. Cuando el usuario pulse el botón Nuevo, aparecerá este
cuadro de diálogo. El usuario introducirá los datos del nuevo trabajador y pulsará
Aceptar, y entonces estos datos se introducirán en la tabla trabajadores.
Luego, se define el dialogoNuevo como Modal. Esto significa que hasta que no se
termine de trabajar con este cuadro de diálogo no se podrá continuar usando el
programa principal.
Como ves, tan sencillo como descargar el cuadro de diálogo. El botón Cancelar debe
limitarse a quitar de la pantalla el cuadro de diálogo dialogoNuevo.
15. Y finalmente se programará el botón Aceptar del cuadro de diálogo. Recuerda que
este botón es el que introduce en la base de datos a un nuevo trabajador. Programa
dentro de este botón lo siguiente:
Lo primero que puedes observar es un conjunto de líneas que copian el contenido de los
cuadros de texto en variables de cadena. Al hacer esto, cambiamos la coma decimal por
punto decimal en el caso del sueldo y configuramos la fecha en el formato que entiende
SQL: mes/dia/año.
Luego, con estas variables, se construye por concatenación una instrucción SQL de tipo
INSERT que permita introducir los datos del nuevo trabajador en la tabla trabajadores.
17. Nuestro programa ya puede hacer altas y bajas. Solo queda que pueda realizar
modificaciones. Para ello añade un nuevo botón a la ventana, llamado btnModificar:
18. Se pretende que el usuario seleccione en la tabla el trabajador cuyos datos quiere
modificar, y luego pulse este botón para efectuar la modificación.
Al pulsar este botón debe aparecer un cuadro de diálogo donde el usuario pueda
cambiar fácilmente los datos.
Ese cuadro de diálogo será muy parecido al que hemos hecho antes, así que
básicamente solo tendrás que hacer una copia de dicho cuadro de diálogo y
modificarlo un poco. A continuación se explica como hacerlo.
19. Haz clic con el derecho sobre el cuadro de diálogo dialogoNuevo y activa Copiar :
20. Luego activa Pegar sobre Otros Componentes:
21. Aparecerá un nuevo cuadro de diálogo que es una copia del anterior. Este cuadro
tendrá como nombre dialogoNuevo1.
22. Sin embargo, le cambiaremos el nombre para que sea más acorde con su función. Le
llamaremos dialogoModificar. Cámbiale el nombre:
23. Vamos a modificar un poco el diseño del dialogoModificar. Haz doble clic sobre él y
realiza las siguientes modificaciones en el diseño:
Cambia el título. Ahora es “Modificar
Trabajador”
txtModNombre
txtModApellidos
txtModSueldo
txtModMatricula
btnModAceptar btnModCancelar
24. Empezaremos programando el botón Modificar. Al pulsar este botón se debe mostrar
el cuadro de diálogo anterior relleno con los datos del trabajador que se quiere
modificar. Se supone que el usuario ha seleccionado a este trabajador en la tabla
anteriormente.
En el caso de que haya una fila seleccionada, se extraen los datos del modelo del JTable y
se almacenan en varias variables de cadena.
Una vez hecho esto, esas mismas variables se almacenan en los cuadros de texto del
cuadro de diálogo dialogoModificar.
Y luego pulsa
modificar.
El resultado es que
aparece el cuadro de
diálogo
dialogoModificar ya
relleno con los datos
del trabajador que se
seleccionó.
26. Lo bueno que tiene el rellenar el cuadro de diálogo dialogoModificar con los datos del
trabajador que se quiere modificar es que no tenemos que escribir todos los datos, y
solo modificar el campo que nos interese.
El usuario realizará los cambios en los cuadros de textos ya rellenos y luego pulsará
el botón Aceptar para que se produzca la modificación.
27. Se empezará programando el botón Cancelar. Este botón debe limitarse a cerrar el
cuadro de diálogo dialogoModificar:
28. Ahora nos centraremos en el botón Aceptar. Este botón debe realizar la modificación,
introduciendo todos los datos de los cuadros de texto en la tabla trabajadores.
El código siguiente tomará como referencia el DNI del trabajador que se está
modificando. Es importante que este DNI no cambie, ya que entonces estaríamos
modificando los datos de otro trabajador.
Esta es la razón por la que el cuadro de texto txtModDni se ha configurado como no
editable, para evitar que el usuario pueda cambiarlo accidentalente.
Estudiemos el código.
Lo primero que se hace es recoger en variables los datos introducidos en los cuadros de
texto.
Luego, con estas variables, se construye una instrucción SQL del tipo UPDATE que
permite modificar los datos del trabajador con el dni indicado en el cuadro de diálogo.
Todo este código es susceptible de sufrir fallos por lo que está rodeado de un try...catch.
La más simple de las aplicaciones de base de datos debe ser capaz de realizar las
siguientes operaciones sobre una tabla:
- Altas
- Bajas
- Modificaciones
En la hoja guiada anterior se realizó una pequeña aplicación de base de datos que permitía
realizar altas, bajas y modificaciones sobre la tabla trabajadores de la base de datos
MANEMPSA.
Aparte, puede ser necesario a veces ver solo determinados registros de la tabla y no toda la
tabla entera.
Se hace necesario pues añadir al programa ciertas opciones de filtrado que nos permitan
visualizar en el JTable solo aquellos registros que más nos interesen.
En esta hoja guiada se mejorará el programa de la hoja anterior de forma que permita al
usuario ciertas opciones de filtrado.
EJERCICIO GUIADO Nº 1
Por lo tanto, tendrá que añadir un nuevo cuadro de diálogo (JDialog) y asígnele el
nombre dialogoFiltrar.
txtFiltrarDni
txtFiltrarNombre
txtFiltrarApellidos
comboSueldo
txtFiltrarSueldo
comboFecha
txtFiltrarMatricula
btnFiltrarAceptar
btnFiltrarVerTodos
btnFiltrarCancelar
NOTA: Los dos combos del cuadro de diálogo deben contener los siguientes elementos:
Si el usuario pulsa el botón Ver Todos, entonces se mostrarán en el JTable todos los
trabajadores.
Se pulsa el botón
Filtrar y aparece el
cuadro de diálogo de
filtrado.
El usuario introducirá los datos que quiere buscar. Ten en cuenta que no tiene por
qué rellenar todas las casillas. Además, puede hacer uso de los combos asignados a
los campos sueldo y fecha. Por ejemplo, supongamos que el usuario introdujera los
siguientes datos:
Si en este momento el usuario pulsara el botón Aceptar, se tendrían que mostrar aquellos
trabajadores que cumplan todas las siguientes condiciones: que tengan de nombre Juan,
que ganen más de 2000 euros de sueldo y que conduzcan un coche cuya matricula
contenga la cadena “CA”.
Las casillas que estén vacías no se tendrán en cuenta a la hora de hacer el filtrado.
Si el usuario introduce una cadena en un campo de tipo texto, se buscará a todos aquellos
trabajadores que contengan dicha cadena. Por ejemplo, si introduzco “Juan” en el nombre, el
programa buscará a los trabajadores cuyo nombre contenga la palabra “Juan”. De esta
manera la búsqueda será mucho más cómoda, al no tener que introducir el texto completo, y
producirá más resultados (se encontrarán a los que se llamen “Juan”, “Juan
Antonio”,”Juana”, etc.
10. El botón Aceptar tendrá que construir una consulta SELECT que incluya estas
condiciones, y luego ejecutarla. Finalmente tendrá que mostrar el resultado de la
consulta en el JTable.
El código de este botón será largo, así que veamos poco a poco como programarlo.
Empiece programando lo siguiente dentro del botón Aceptar:
En el caso de la fecha, recogemos de los cuadros de texto el día, mes y año y los
concatenamos para formar una fecha que Access pueda aceptar: mes/dia/año.
En el caso del sueldo cambiamos la coma decimal (ya que suponemos que el usuario
introducirá el valor en formato español) por el punto, para que no haya problemas a la
hora de ejecutar la consulta SQL.
11. Siga programando en el botón Aceptar de la siguiente forma:
Y en la parte
final del método
añade el
siguiente
código...
Es necesario estudiar muy detenidamente el código que tenemos programado hasta ahora
antes de continuar.
- La variable sql es una variable de cadena que contendrá la instrucción SELECT que
efectuará el filtrado (la consulta)
Esta variable es muy importante, ya que nos permite saber si tenemos que
concatenar una condición con “where” o con “and”. Ten en cuenta que la primera
condición que se añade vendrá precedida por “where”, pero las demás estarán
precedidas por “and”.
La primera condición que se añade a la instrucción SELECT tendrá que tener esta
forma (en rojo):
Etc.
Cada vez que se encuentra un cuadro de texto no vacío, se añade una condición y se
aumenta en 1 el contador de condiciones, es decir, la variable ncond.
Debes observar también como nos decantamos por el uso de LIKE ya que este es más
versátil. Y se recuerda una vez más que cuando usemos LIKE desde java en vez de
asteriscos usaremos el símbolo tanto por ciento (%)
Estudia bien este código para entenderlo. Solo se ha indicado las posibles condiciones para
el DNI y para el Nombre. Sin embargo será necesario añadir más if para el resto de los
campos.
Este código comprueba si hay algún dato en el cuadro de texto apellidos, y, si es así,
entonces crea una condición para filtrar por apellidos.
Este es el código que añade una condición para el sueldo (suponiendo que haya
algún dato en el cuadro de texto del sueldo)
Hay que destacar aquí que, al ser el sueldo un campo numérico, no se usa LIKE, sino
que se usa el operador que el usuario haya escogido dentro del combo del sueldo.
Recuerda que ese operador puede ser uno de los siguientes: =, >, <, >=, <= ,
<>
Este es el código que añade una condición para la fecha (suponiendo que haya algún
dato en los cuadros de texto correspondientes a las fechas)
Aquí hay que tener en cuenta que los valores de los cuadros de texto del día, mes y
año se concatenan dentro de una variable fecha usando la / como separador. Si los
cuadros de texto dia, mes y año estuvieran vacíos, la variable fecha contendría la
cadena “//”. Por eso preguntamos si la variable fecha es distinta de “//” para saber si
es necesario añadir una condición para la fecha.
Observa que para crear la condición se usa el operador que el usuario haya elegido
en el combo de la fecha, el cual puede ser uno de los siguientes: =, >, <, >=, <=
, <>
Ya que estamos manejando fechas recuerda que hay que añadir las almohadillas en
la condición.
15. Añada el siguiente código al final del código anterior.
Como en los demás campos de tipo texto, para construir esta condición se ha
preferido usar LIKE junto con los % (asteriscos en Access), que da más posibilidades
de búsqueda.
16. El resultado final de todo este largo código es que la variable sql contendrá una
instrucción SELECT que realizará un filtrado sobre la tabla trabajadores de la base de
datos de forma que se extraigan a los trabajadores que cumplan las condiciones
indicadas por el usuario en el cuadro de diálogo de filtrado.
Lo que hay que hacer ahora es ejecutar dicha instrucción SELECT. Y como ya sabe,
esto se hace a través del objeto sentencia. Programe lo siguiente a continuación del
código anterior:
Como ve, el código da un error. Esto es debido a que es obligatorio rodear el código
con un try...catch, ya que es susceptible de error. (Esto se hará más adelante)
17. Ahora mostraremos el ResultSet r en el JTable, así que añada el siguiente código a
continuación:
Si observa este código verá que lo que hace es definir un vector de títulos para el
JTable. A partir de este vector de títulos se crea el modelo del JTable
(DefaultTableModel)
Luego se recorre el ResultSet r, que contiene ahora mismo el resultado del filtrado
realizado, y se extrae cada fila almacenándola en un vector al que se ha llamado fila.
Finalmente cuando se han traspasado todas las filas desde el ResultSet r al modelo
m, se asigna dicho modelo al JTable. Esto quiere decir que el JTable debería mostrar
ya el resultado del filtrado.
18. El código programado hasta ahora analiza los datos introducidos en el cuadro de
diálogo de filtrado y construye una consulta SELECT que extrae los trabajadores que
cumplan las condiciones indicadas. Estos datos se muestran finalmente en un
JTable. Lo único que queda por hacer es cerrar el cuadro de diálogo.
22. Solo queda por programar el botón Ver Todos del cuadro de diálogo de filtrado. Al
pulsar este botón se pretende que se visualicen todos los registros de la tabla
trabajadores. El código de este botón es bastante sencillo:
- Haz el filtrado que quieras sobre la tabla trabajadores. Acepta y observa el filtrado en
la tabla.
- Vuelve a filtrar pero esta vez pulsa el botón Ver Todos. Observarás como vuelven a
verse todos los trabajadores en la tabla.
Ejemplo:
Se acaba de realizar un
filtrado, la tabla muestra
solo los trabajadores que
cumplen la condición...
Las tablas que tengan muchos datos son incómodas de manejar, por lo que resulta
muy interesante añadir al programa ciertas opciones de filtrado. Estas opciones
permitirán visualizar solo aquellos registros que cumplan determinadas condiciones.
Una vez construida la cadena SELECT según el filtrado que quiera hacer el usuario, se
tendrá que ejecutar dicha consulta y se tendrá que mostrar el resultado. Normalmente
en un JTable.
EJERCICIO GUIADO. JAVA. ACCESO A BASE DE DATOS
Ordenación y cálculos
Se van a añadir ciertas mejoras al programa que se viene realizando en las últimas hojas
guiadas. En esta hoja programaremos ciertas opciones de ordenación así como
realizaremos determinados cálculos sobre la tabla trabajadores.
EJERCICIO GUIADO Nº 1
2. Vamos a modificar el cuadro de diálogo de filtrado de forma que no solo sea capaz
de filtrar, sino que también permita que el listado que se ha filtrado aparezca
ordenado según un campo.
panelOrdenacion
cboCamposOrdenacion
radioASC
radioDESC
3. La idea es la siguiente. Cuando el usuario quiera hacer un filtrado podrá indicar que
el listado aparezca ordenado por algún campo, seleccionándolo en el combo de
ordenación. También puede indicar la forma de ordenación (ascendente o
descendente) a través de los botones de opción.
Al pulsar Aceptar el listado de trabajadores no solo saldrá filtrado, sino que también
saldrá ordenado.
Para ello tendremos que realizar modificaciones en el código del botón Aceptar.
Añade el siguiente código en el actionPerformed del botón Aceptar (justo antes de la
ejecución de la consulta):
etiNumeroTrab
etiSueldoMedio
Este método recibirá un ResultSet como parámetro, y lo que hará será analizar el
contenido de este ResultSet para calcular y luego mostrar el número de trabajadores
y el sueldo medio.
Por otro lado se calcula la suma de los sueldos de los trabajadores del ResultSet.
Una vez terminado el bucle solo hay que dividir la suma de los sueldos entre el
número de trabajadores para obtener la media, y estos datos se colocan en las
etiquetas correspondientes.
8. Interesa que cada vez que se muestren todos los trabajadores en el JTable se
realicen estos cálculos, así pues debe añadir la siguiente línea en el método
MostrarTrabajadores.
Esa línea es una llamada al método que acabamos de programar, y hará que después de
que se presenten en el JTable todos los trabajadores se rellenen las etiquetas de los
cálculos.
Al iniciarse el programa
aparece el listado
completo de
trabajadores y se
calcula el número de
trabajadores y el sueldo
medio...
Si se hace un filtrado
(en este ejemplo se
visualizan los
trabajadores con menos
de 1000 de sueldo) los
cálculos se
corresponderán con el
listado filtrado...
CONCLUSIÓN
La opción de ordenación puede estar situada junto a las opciones de filtrado para
permitir de esta manera que los filtrados aparezcan ordenados según le interese al
usuario.
Suele ser habitual que al lado del JTable aparezcan ciertos cálculos estadísticos
relativos a la tabla.
EJERCICIO GUIADO. JAVA. INFORMES DE BASE DE DATOS
Informes
Toda aplicación de base de datos necesita imprimir documentos tales como listados, fichas,
gráficos, etc. Estos documentos se rellenan con datos tomados directamente desde la base
de datos. A estos documentos se les denomina de forma general informes.
Para crear estos documentos es necesario usar algún programa de creación de informes.
Estos programas permiten definir la estructura general del informe (sin tener en cuenta los
datos)
Una vez creado el informe, este se enlaza con nuestra aplicación, de forma que cuando el
usuario pulse la opción de imprimir, el informe se rellene con los datos de la base de datos y
luego sea enviado a la impresora.
Para descargar las últimas versiones de este programa puede acudir a la página
http://www.jasperforge.org/sf/projects/ireport
En esta hoja guiada se verán las ideas básicas de manejo del programa IReport.
EJERCICIO GUIADO Nº 1. INSTALACIÓN DE IREPORT
2. Una vez instalado, ejecútelo. La pantalla principal del IReport es la siguiente (es
relativamente parecida a la pantalla principal de NetBeans):
Definición de DSN
DSN significa Data Source Name, es decir, Nombre del origen de datos.
Un DSN define cierta información sobre una base de datos, como por ejemplo el tipo de
base de datos que es y donde se encuentra almacenada en el ordenador.
Toda esta información se agrupa bajo un nombre, y ese nombre precisamente es lo que se
denomina un DSN.
Cuando un programa necesita acceder a una base de datos en concreto, solo hay que
indicarle el nombre del DSN que tiene la información de dicha base de datos. De esta forma,
el programa sabe acceder a la base de datos.
El IReport es un programa que necesita saber el DSN de la base de datos que va a manejar,
por eso es necesario aprender a crear DSNs para base de datos si queremos usar IReport.
En este ejercicio guiado nº 2 aprenderemos los pasos a seguir para crear un DSN para una
base de datos. En nuestro caso, crearemos un DSN para la base de datos MANEMPSA.
4. En la pestaña DSN de Usuario pulse el botón Agregar para añadir un nuevo DSN.
5. Ahora hay que indicar el tipo de la base de datos a la que asignaremos el DSN. En
nuestro caso, como la base de datos MANEMPSA es una base de datos de Access,
tendremos que escoger Microsoft Access Driver (*.mdb) y pulsamos Finalizar.
6. Ahora seleccionaremos el fichero de la base de datos MANEMPSA haciendo clic en
el botón Seleccionar:
9. Pulsa Aceptar las veces que sea necesario y el DSN BaseEjemplo habrá sido creado.
Esto quiere decir, que un programa determinado podrá acceder a la base de datos
MANEMPSA simplemente indicándole el DSN BaseEjemplo.
Este es el caso del programa IReport. Como verás en los pasos siguientes,
tendremos que usar el DSN BaseEjemplo que acabamos de crear para poder realizar
informes sobre la base de datos MANEMPSA.
10. Una vez creado un DSN para una base de datos, este se queda almacenado en el
ordenador. Esto significa que no necesitaremos volver a crear un DSN para la base
de datos MANEMPSA.
11. El DSN se queda almacenado en el ordenador hasta que el propio usuario lo borre.
Para practicar, veremos como borrar el DSN que acabamos de crear (aunque
finalmente no lo borraremos porque lo usaremos más adelante). Para ello entre en
Panel de Control, Herramientas Administrativas, Orígenes de Datos:
12. En la pantalla que aparece verá el listado de DSNs que tiene creadas ahora mismo
en el ordenador actual. Entre ellas verá la DSN llamada BaseEjemplo. Para eliminarla
solo tienes que seleccionarla y pulsar el botón Quitar.
1. Para poder crear informes con datos de una base de datos, es necesario realizar una
conexión entre el programa iReport y la base de datos. Este proceso se tendrá que
realizar antes de crear cualquier informe sobre dicha base de datos, y solo hace falta
hacerlo una vez. Para este proceso, se usará el DSN de la base de datos.
2. Para crear esta conexión, active la opción Datos – Conexiones / Fuentes de Datos
Quedaría así:
8. Finalmente, activaremos la opción Salvar el password para evitar que se nos pida
constantemente una contraseña para acceder a la base de datos (La casilla de la
contraseña –password- se deja en blanco ya que la base de datos MANEMPSA no
tiene contraseña)
11. Al pulsar el botón Salvar volverá a la pantalla inicial. En ella podrá observar que se ha
creado una conexión (la conexión con MANEMPSA) Siguiendo estos mismos pasos
puede crear todas las conexiones que quiera con las bases de datos de su
ordenador.
Una vez creada una conexión, esta se queda guardada y podrá ser usada para la
creación de informes sobre la base de datos con la que conecta.
Conexión
creada.
Listado de
conexiones a
base de
datos (solo
hay una de
momento)
2. Una forma rápida de crear un informe es a través de la opción Mago de Informes que
se encuentra dentro de la opción del menú Fichero. Actívela.
3. La opción Mago de Informes muestra un asistente donde tendrá que indicar algunos
datos necesarios para crear el informe. Lo primero que tiene que indicar es la base
de datos sobre la que quiere realizar el informe. Para ello debe elegir la conexión
correspondiente a dicha base de datos:
4. Hasta el momento solo hemos configurado una conexión en el iReport (la conexión
con MANEMPSA), así que será la única que aparezca al desplegar el listado de
conexiones.
Ya que queremos hacer un listado con todos los trabajadores de la base de datos
tendremos que introducir una consulta SELECT que extraiga a dichos trabajadores:
7. En este nuevo paso tendremos que indicar los campos que queremos que aparezcan
en el listado. Para ello solo tendremos que seleccionar cada campo y pulsar el botón
> para añadirlo. En nuestro ejemplo debes añadir los campos: DNI, Nombre,
Apellidos y Sueldo únicamente.
Nota:
9. En este nuevo paso se tendrá que elegir una forma de agrupamiento para el informe.
En este ejemplo no se estudiará el agrupamiento en informes así que pulse
simplemente el botón Próximo otra vez.
10. El siguiente paso es la distribución del informe. Es decir, la forma de colocar los
datos. Existen dos posibilidades:
13. Vamos a guardar el informe. Para ello activa la opción Fichero – Guardar. El nombre
que le daremos al informe será trabajadores:
14. Ahora que está guardado, vamos a ver como quedaría el listado. Para ello active la
opción Construir – Ejecutar informe (usando la conexión activa) o bien el botón de la
barra de herramientas con el mismo nombre:
15. Al hacer esto aparecerá por fin el listado que ha creado. Este listado aparece en una
ventana nueva y tendrá un aspecto similar al siguiente:
Como puede observar, aparecen los campos que indicó en el asistente. El informe es
tabulado (es decir, tiene forma de listado) y en él aparecen los trabajadores que
tenga en su base de datos MANEMPSA.
16. Cierre la ventana del informe (no la del iReport) y volverá a la pantalla principal de
iReport.
17. Haga doble clic sobre el título del informe y cámbielo por Listado de Trabajadores:
18. Vuelva a visualizar el resultado del informe:
20. Acabamos de crear nuestro primer informe. Un listado con los datos de los
trabajadores. Ya puede cerrar el programa iReport. Guarde todos los cambios.
CONCLUSIÓN
La opción de ordenación puede estar situada junto a las opciones de filtrado para
permitir de esta manera que los filtrados aparezcan ordenados según le interese al
usuario.
Suele ser habitual que al lado del JTable aparezcan ciertos cálculos estadísticos
relativos a la tabla.
EJERCICIO GUIADO. JAVA. INFORMES DE BASE DE DATOS
Diseño de Informes
El mago de informe es una forma rápida de crear informes, aunque el resultado quizás no
sea exactamente lo que buscábamos. Es posible que nos interese cambiar los colores, el
tipo de letra, el formato de los números, etc.
En la hoja guiada anterior vimos un ejemplo de esto. Una vez creado el informe, se tuvo que
cambiar el título ya que el título incluido por defecto no era el adecuado.
En esta hoja guiada se aprenderán algunas técnicas para modificar un informe una vez que
haya sido creado con el mago de informes. Veremos como modificar las propiedades de
cada elemento del informe.
EJERCICIO GUIADO Nº 1. CREACIÓN Y MODIFICACIÓN DE UN INFORME
6. En este paso tendremos que indicar los campos que nos interesa que aparezcan en
el listado. Estos campos serán los siguientes: matrícula, marca, modelo y año.
7. Pulse el botón Próximo para pasar al siguiente paso del asistente:
8. Estamos en el paso 3 del asistente. En este paso hay que indicar el agrupamiento del
informe. En nuestro ejemplo no usaremos agrupamiento así que pulse simplemente
el botón Proximo.
10. Active Próximo para ir al 5 y último paso del asistente y pulse Terminar.
12. Ahora es conveniente guardarlo para evitar problemas. Pulse la opción Fichero –
Guardar y guárdelo con el nombre listadocoches en la carpeta Mis Documentos.
13. Acaba de crear un informe con forma de listado. Para ver el resultado debe pulsar el
botón Ejecutar informe (usando la conexión activa)
14. Ahora podrá ver el informe creado, el cual debe tener el siguiente aspecto (tenga en
cuenta que los elementos del listado pueden variar dependiendo de los datos que
tenga almacenado en su tabla)
15. Ya tenemos el informe creado. Este informe tiene su formato (tipos de letras, colores,
etc) que puede que sea suficiente para nuestras necesidades. Pero, ¿y si
quisiéramos cambiar las características del informe? En los puntos siguientes
veremos como cambiar el aspecto del listado. De momento cierre la ventana del
listado para volver a la pantalla de diseño.
16. Empezaremos cambiando el título del informe. Para ello haremos doble clic sobre el
título y escribiremos “Listado de Coches”:
17. Puede cambiar el aspecto de cada elemento del informe seleccionándolo con un clic
y luego modificando sus propiedades, las cuales aparecerán en la parte derecha de
la ventana. Por ejemplo, seleccione en la cabecera del listado el campo matrícula:
18. En la zona de propiedades (parte derecha) active por ejemplo la propiedad negrilla y
el tipo de letra Comic Sans:
19. Si observa el elemento seleccionado (“Matrícula” en la cabecera) observará que está
ahora en negrita y con el tipo de letra Comic:
20. Selecciona ahora el título, por ejemplo (solo tienes que hacer un clic sobre él)
21. Ahora activa las siguientes propiedades:
23. Vamos a colocar el recuadro del título a la izquierda. Para ello, haz clic sobre el título
y sin soltar el botón del ratón arrástralo a la parte izquierda del informe, para que
quede así:
27. Si ahora visualizas el listado de nuevo, verás como sí aparece el campo matrícula:
28. Sigamos cambiando cosas en el diseño del informe. Ahora vas a seleccionar el
campo matrícula correspondiente no a la cabecera, sino al listado de datos:
Negrita: Activado
Tamaño de letra: 8
Tipo de letra: Courier New
Primer Plano: Azul
30. Una vez cambiadas las propiedades, si visualizas el informe, deberá tener el
siguiente aspecto:
31. Así pues, el diseño del informe que haya creado con el mago de informes puede ser
modificado luego. Básicamente solo tiene que seleccionar el elemento a modificar y
luego cambiar sus propiedades.
Debe tener en cuenta que los elementos del diseño pueden cambiarse de lugar y que
pueden cambiarse de tamaño.
32. Ha terminado de realizar el informe. Puede cerrar iReport y guardar los cambios si
hiciera falta.
CONCLUSIÓN
La forma más sencilla de crear un informe con iReport es a través del mago de
informes.
También puede mover y cambiar de tamaño los distintos elementos del informe.
En hojas anteriores hemos visto que la forma más rápida de crear un informe es usando el
mago de informes de iReport. Luego, con el informe resultante, solo teníamos que cambiar
las propiedades de cada elemento del informe.
En esta hoja veremos como crear un informe empezando desde cero, lo que nos servirá
además para entender las distintas zonas en que se divide un informe.
La creación de informes desde cero es algo tedioso y lento, aunque por otro lado nos da
total libertad a la hora de distribuir cada elemento en el informe.
En muchos casos tendrá que crear los informes desde cero, ya que el cliente le insistirá en
usar un determinado formato para los listados, las facturas y todos aquellos documentos que
deben imprimirse desde el programa. Insistirá en mantener los colores propios de la
empresa (la imagen corporativa) y demás características propias de la empresa. Para hacer
esto a veces lo mejor es crear el informe desde el principio.
1. Entre en iReport
2. Nuestro objetivo será crear un informe que muestre el listado de servicios realizados
por el trabajador Juan Pérez, cuyo número de DNI es 12.321.567-B.
8. Ahora hay que indicar la consulta SQL que nos permita acceder a los datos
necesarios para el informe. Esto se tiene que hacer activando la opción Datos –
Consulta de Informe:
9. En la ventana que aparece tendrá que introducir la siguiente consulta SQL:
11. Pulse en el + para visualizar el listado de campos disponibles. Verá todos los campos
seleccionados en la consulta SQL que acaba de introducir.
12. Nos interesa que en el listado de los servicios de Juan aparezca el número, el tipo de
servicio y la cantidad. Para ello, tendrá que añadir estos datos a la zona de Detalle
(Detail).
La zona de detalle es la zona en la que aparecerán los datos del listado, y por tanto
es allí donde tiene que añadir los campos a mostrar.
14. Visualice el informe resultante. iReport le pedirá que guarde el informe. Llámelo
serviciosjuan.
15. Una vez guardado verá como queda el informe que acaba de hacer:
16. No está muy conseguido, pero solo acabamos de empezar. Recuerde que la zona de
Detalle (Detail) es el sitio donde colocará los campos del listado de datos.
17. Nuestra zona de Detalle es muy grande, por eso los datos salen tan separados.
Puede achicar una zona haciendo clic en la línea de separación y arrastrando.
Pruebe a hacerlo hasta que la zona de Detalle quede así (es posible que necesite
mover los campos):
Clic en la línea de separación y
arrastra.
18. Si visualiza ahora el informe verá que tiene mejor aspecto (los servicios de Juan
aparecen más unidos):
19. Ahora sería interesante que el listado tuviera una cabecera. Para ello, haz clic en el
botón de la barra de herramientas llamado Texto Estático y luego haz clic en la zona
del informe llamada Column Header y arrastre el ratón:
20. Haz doble clic sobre el recuadro que ha aparecido y escriba dentro de él “Nº
Servicio”.
21. La zona del informe llamada Encabezado de Columna (Column Header) es la zona
donde colocará los encabezamientos del listado. Acabamos de colocar el
encabezamiento de la columna número. Ahora repita el proceso para colocar los
otros dos encabezados de columnas:
22. Para destacarlos un poco (ya que son los encabezados), haremos que estén en
negrita y que su tamaño sea un poco más grande (para ello use las propiedades de
dichos elementos) El resultado debe ser similar al siguiente:
23. Visualiza el informe y observa el resultado:
24. Ya tiene un mejor aspecto, pero aún puede mejorarse más. A través del botón Línea
puede dibujar líneas en el informe. Dibuje una línea en la zona del Encabezado de
Columna:
botón línea
NOTA: Para que la línea le salga recta puede dibujarla teniendo pulsada la tecla
Mayúsculas.
25. Visualice el informe:
26. Ahora vamos a colocar un título al informe. El título del informe se coloca en la zona
Título (Title). En nuestro caso vamos a colocar el título “Ficha de Servicios”. Para
introducir un texto tendrá que usar el botón Texto estático que ya usó antes:
Haga clic en este botón y luego haga clic y arrastre en la zona del Título. Se creará
un recuadro:
27. Haz doble clic sobre ese recuadro y escribe “Ficha de Servicios”.
28. Ahora asigna al título las siguientes propiedades:
a. Un tamaño de letra de 24
b. Agranda el cuadro de forma que ocupe prácticamente toda la zona de título.
c. Centra el título en el recuadro.
d. Subráyalo.
e. Asigna un color de fondo gris claro.
f. Desactiva la opción transparente.
30. Ahora introduciremos algunos datos del trabajador (en nuestro caso de Juan Pérez)
La zona que usaremos será el Encabezado de Página (pageHeader)
Debe saber que en el encabezado de página se colocan aquellos datos que deban
aparecer en la parte superior de todas las páginas.
31. Vamos a empezar agrandando la zona del Encabezado de Página. Esto se hace
fácilmente arrastrando la línea límite inferior de la zona:
Haz clic en esta línea y
arrastra hacia abajo.
32. Ahora que tenemos más espacio en el encabezado de página vamos a dibujar en él
un recuadro. Esto lo puede hacer usando el botón Rectángulo de la barra de
herramientas:
Solo tiene que activar este botón y hacer clic y arrastrar en el encabezado. Intente
que quede así:
33. Ahora añada los siguientes cuadros de texto estático dentro del recuadro que acaba
de hacer:
Recuerde que estos cuadros de texto se hacen usando el botón Texto estático de la
barra de herramientas:
34. Ahora, para que salgan los datos propios del empleado, añadiremos los campos
nombre, apellidos y DNI. Empezaremos por añadir el campo DNI. Esto se hace
arrastrando desde la zona de campos:
35. Haga lo mismo con el campo Apellidos y el campo Nombre. El informe quedará así:
36. Ahora se cambiarán algunas propiedades de los campos que hemos añadido:
a. Asigne un tamaño de 12
b. El DNI debe aparecer en negrita.
c. Agrande los cuadros de los campos.
Como puede ver, en la ficha del empleado aparecen sus datos reales.
38. Y ya para terminar agregaremos un logotipo al informe. Dicha imagen se colocará en
la zona del Encabezado de Página, al lado del recuadro. Para ello, tendrá que usar el
botón de la barra de herramientas imagen:
Haga clic en este botón y luego haga clic y arrastre hasta crear un rectángulo en la
zona del Encabezado de Página. Debe quedar así:
41. Ya tiene asociada la imagen con el cuadro de imagen. Ya solo queda visualizar el
informe. Su aspecto será parecido al siguiente:
42. Ha podido observar en este ejemplo los pasos básicos a seguir para crear un informe
desde cero. Como puede ver, es una forma más trabajosa de crear un informe, pero
a cambio disponemos de más libertad a la hora de diseñar el informe.
43. Para finalizar con esta hoja guiada, veamos para que sirve cada una de las zonas del
informe:
Encabezado de Página
(pageHeader)
Lo que se coloque aquí
aparecerá en todas las páginas,
en la parte superior.
Encabezado de columna
(columnHeader)
Se usa para colocar el texto del
encabezado del listado (los
nombres de cada columna)
Detalle (detail)
Aquí aparecerán todos los datos
del listado. Por tanto, aquí se
suelen colocar los campos que
se quieren visualizar.
Resumen (summary)
Aparece cuando finaliza el listado de
datos (en la última página) Esta zona se
usa para colocar cálculos estadísticos,
como suma de cantidades o cuentas y
promedios, etc... que deban aparecer al
final.
Pie de la última página (lastPageFooter)
Es un pie especial, ya que solo aparece en la
parte inferior de la última página.
CONCLUSIÓN
Es necesario indicar la conexión a la base de datos y la consulta SQL para extraer los
datos que aparecerán en el informe.
Si se quiere que aparezca un dato de la base de datos, entonces habrá que introducir
un campo.
Todos los elementos colocados pueden ser modificados a través de sus propiedades.
EJERCICIO GUIADO. JAVA. INFORMES DE BASE DE DATOS
Cálculos
Es muy habitual que un informe no solo muestre datos de las tablas de la base de datos,
sino que también muestre cálculos realizados con esos datos.
Para hacer esos cálculos se puede usar la potencia de SQL por un lado. Podemos generar
esos cálculos directamente en la consulta SQL, con lo cual solo tendremos que mostrar los
resultados en el informe como si fueran otros campos.
Por otro lado también podemos realizar los cálculos directamente en el informe.
En esta hoja se verá como crear un informe con cálculos. Además se aprenderán algunos
conceptos nuevos en lo que se refiere a presentación de datos y uso de las zonas del
informe.
EJERCICIO GUIADO Nº 1. CREACIÓN DE UN INFORME CON CÁLCULOS
1. Entra en iReport.
4. Indique ahora que usará la conexión con la base de datos MANEMPSA. Para ello
puede elegir la “Conexión con MANEMPSA” en el desplegable de conexiones, en la
parte superior derecha de la ventana:
5. Ahora que hemos elegido la conexión, ahora indicaremos la consulta SQL que nos
permita extraer los datos que queremos mostrar en el informe. Para ello, activa la
opción Datos – Consulta de Informe.
9. Ahora para definir los datos del listado, tendremos que añadir campos a la zona del
detalle (detail). Debes arrastrar los campos fecha, tipo y cantidad:
10. La zona del detalle es demasiado grande, así que reduzca su tamaño arrastrando la
línea de separación:
Arrastra la línea del
detalle.
11. Visualice el listado. IReport le pedirá que guarde antes de visualizar. Guarde el
listado con el nombre informeservicios en Mis Documentos.
13. Observe como la fecha muestra también la hora. Antes de continuar, cambiaremos el
formato de la columna de la fecha para que esto no suceda. Para ello seleccione el
campo Fecha:
14. Vamos a modificar una de las propiedades llamada Patrón. Haz clic en el botón con
tres puntos de esta propiedad:
15. Esta propiedad permite cambiar la forma en que se presentan números, fechas y
demás tipos de datos en el informe.
Elige en la zona de categorías la categoría Date (Fecha) y luego escoge el patrón con
forma dia/mes/año:
16. Vuelve a visualizar tu listado. Ahora verás como las fechas aparecen correctamente.
Recuerda esta propiedad, ya que la usarás muchas veces. Sobre todo con fechas y
números. En el caso de los números, se puede usar para decidir algunas
características como los dígitos decimales o si mostrar el punto separador de miles.
17. Vamos a mejorar el listado añadiendo dos líneas. Una línea justamente debajo de la
cabecera y otra en la parte del pie de columna (columnFooter):
18. La línea de la cabecera separará esta de los datos. Por otro lado, la línea del pie de
columna aparecerá en la parte inferior del listado en todas las páginas. Visualiza el
listado:
19. La zona del pie de página pageFooter es ideal para colocar en ella el número de
página del listado. (Tenga en cuenta que el listado puede ser muy largo y tener varias
páginas)
Para que la zona pageFooter afecte a todas las páginas del informe incluyendo la
última, es necesario ocultar la zona lastPageFooter.
20. Haga clic con el botón derecho del ratón sobre la zona lastPageFooter y elija
Propiedades de banda.
23. Ahora arrastra el elemento especial Página X de Y desde la librería hasta el pie de
página. Observa:
24. La Librería contiene una serie de campos especiales que muestran cosas como el
número de la página o la fecha actual. Elementos que suelen ser muy comunes en
los informes.
25. Aprovecha la Librería para agregar en la parte derecha del pie la fecha actual.
Arrastra el elemento Fecha actual a la zona del pie. Entonces verás como aparece un
cuadro donde tendrás que elegir el formato de la fecha. Elige el formato completo.
Active la opción Datos – Consulta del Informe para acceder a la consulta que
introducimos al principio.
select Fecha, Tipo, Cantidad, Cantidad*0.16 as IVA from servicios order by fecha
Esta consulta SELECT muestra la Fecha, Tipo y Cantidad de los servicios, pero además,
verá que realiza un cálculo: multiplica el campo Cantidad por 0.16 y le asigna al resultado del
cálculo el nombre IVA.
Es decir, se crea un nuevo campo (campo calculado) llamado IVA y creado a partir del
producto del campo Cantidad por 0.16
select Fecha, Tipo, Cantidad, Cantidad*0.16 as IVA from servicios order by fecha
Los campos calculados es una característica del lenguaje SQL que aprovecharemos para
realizar cálculos con los campos de las tablas.
30. Pulse Ok y observe la zona de campos. Verá como ha aparecido un nuevo campo
llamado IVA. Tan solo tiene que agregarlo a la zona de detalle como si fuera un
campo más.
En este caso, se está añadiendo otro campo calculado (en rojo) llamado Total. Este
campo es la suma del IVA y la Cantidad. Es decir, es el total con Iva.
34. Al pulsar Ok observará en la zona de campos este nuevo campo. Aproveche esto
para agregar una nueva columna con los totales con iva:
Por ejemplo, sería interesante calcular la suma de todas las cantidades, todos los IVA
y todos los totales más IVA.
Estos totales suelen aparecer en la parte final del listado. En la zona llamada
Resumen (summary)
38. Para agregar un total (una suma) se usa el elemento Total de la Librería. Haga clic en
él y arrástrelo a la zona del resumen.
39. Aparecerá un cuadro de diálogo donde tendrá que indicar el campo que quiere
sumar. Elija el campo Cantidad y acepte.
40. Aparecerá un nuevo recuadro en el resumen. Colóquelo al mismo nivel que la
columna de la cantidad.
41. Haga el mismo proceso para calcular la suma del IVA y del Total. Al final, el diseño
de la zona resumen debe tener el siguiente aspecto:
42. Los elementos situados en la zona del resumen aparecen al final del listado.
Visualice el informe y observe la parte final del listado.
Esta característica es muy útil por ejemplo en el caso de los informes, ya que nos
permite mostrar cálculos en ellos.
- Title – Título: Usado para colocar el título del informe. Aparece en la primera
página únicamente.
- pageFooter – Pie de página: En esta zona se coloca aquello que deba aparecer en
la parte inferior de todas las páginas (menos la última, si está activado el
lastPageFooter) Se usa para colocar el número de página.
- Summary – Resumen: Usado para colocar cálculos de totales. Aparece al final del
listado.
EJERCICIO GUIADO. JAVA. INFORMES DE BASE DE DATOS
Informes Agrupados
Un informe agrupado se puede definir como varios listados en un mismo informe. Los
elementos de cada listado tienen una característica en común, o, dicho de otra forma,
pertenecen a un mismo grupo.
Por ejemplo, si tuviera un listado de trabajadores, podría mostrar dicho listado agrupado
según profesión, y entonces tendríamos el listado de albañiles, el listado de profesores, el
listado de policías, el listado de bomberos, etc...
1. Entra en iReport.
(Nota: observe que hemos ordenado la consulta por tipo. Luego verá por qué)
5. Ahora ya estamos en el paso tercero del asistente. En este paso tendremos que
indicar la forma de agrupar el listado. En el desplegable grupo 1 indique el campo
tipo. Esto significa que el listado saldrá agrupado por tipo de servicio.
Pulse Próximo.
6. Elija una disposición Tabulada del tipo Classic_T. Pulse Próximo y Terminar.
7. Aparecerá el diseño del informe que acaba de crear. Observe que entre las zonas
típicas del informe ha aparecido una nueva zona “de agrupamiento”:
Como ve, aparecen varios sub-listados. Un listado con los servicios de electricidad, otro con
los servicios de fontanería, y otro con los servicios de limpieza. Tenemos un informe en
grupos.
NOTA: Es obligatorio que la consulta del informe esté ordenada según el campo por el que
vayamos a agrupar. Esta es la razón por la que la consulta se ordenó por tipo.
9. Ahora se mejorará un poco el listado que se ha hecho. En primer lugar modifique el
patrón del campo fecha, de forma que aparezca en formato día-mes-año:
10. También puede resultar interesante modificar el patrón de la Cantidad, de forma que
aparezca con dos decimales:
11. Finalmente asigne el título “Listado de Servicios” al informe. Este debe tener ahora el
siguiente aspecto al visualizarlo:
NOTA:
Bomberos
Casados
----
----
Solteros
----
----
Etc...
Para hacer esto basta con indicar varios campos en el paso de agrupamiento del asistente
mago de informes. Pero tenga en cuenta que tendrá que ordenar la consulta SELECT según
dichos campos.
Para crear los grupos se toma como referencia el valor de un determinado campo.
La mejor forma de crear un informe agrupado usando iReport es a través del mago de
informes, ya que este asistente muestra un paso donde se puede elegir el campo
según el que se quiere agrupar.
No olvide que cuando quiera agrupar un listado por un campo es obligatorio que la
consulta SELECT del informe ordene el listado por el campo por el que se quiere
agrupar.
EJERCICIO GUIADO. JAVA. INFORMES DE BASE DE DATOS
Una vez creados los informes con iReport, tendremos que acceder a ellos desde nuestra
aplicación Java.
En esta hoja guiada veremos los pasos básicos necesarios para mostrar un informe desde
una aplicación Java.
Nota: En esta hoja guiada se usará el informe creado en la hoja anterior, llamado
serviciosagrupados.
EJERCICIO GUIADO Nº 1. CREACIÓN DEL INFORME COMPILADO
Los ficheros que contienen un informe son ficheros del tipo .jrxml. Así pues, en la
carpeta Mis Documentos encontrará el fichero serviciosagrupados.jrxml, que es el
que tiene que abrir.
Ya sabe que este botón, llamado Ejecutar informe (usando conexión activa), permite
visualizar el informe relleno con los datos de la base de datos, según la consulta SQL
que haya usado.
3. Sin embargo, este botón no solo sirve para visualizar el informe final, sino que
además actúa como compilador, generando un fichero del tipo .jasper.
Los ficheros .jasper son informes compilados, de forma que puedan ser usados en
aplicaciones java.
Cada vez que ha visualizado un informe, ha generado sin darse cuenta un fichero
.jasper, con el nombre del informe que estaba visualizando. En nuestro ejemplo,
acabamos de generar un fichero serviciosagrupados.jasper
7. Pulse el botón Grabar. A partir de ahora cada vez que visualice un informe el fichero
compilado se guardará en la carpeta Mis Documentos. Lo vamos a comprobar.
Vuelva a visualizar su informe:
8. Acuda a la carpeta Mis Documentos y compruebe que en ella hay ahora un fichero
serviciosagrupados.jasper. Este es el fichero del informe compilado. Este fichero será
el que usará para visualizar informes desde java.
EJERCICIO GUIADO Nº 2. CONEXIÓN CON UN INFORME DESDE JAVA
2. Crea la carpeta Base dentro de la carpeta del proyecto y copia en ella la base de
datos MANEMPSA.
3. Prepara tu proyecto para que pueda acceder a la base de datos MANEMPSA (ya
sabes, crear el objeto conexión, sentencia, etc...)
4. Para que nuestro programa sea capaz de presentar informes, crearemos una carpeta
llamada Informes dentro de la carpeta del proyecto. Y dentro de dicha carpeta
copiaremos los ficheros .jasper de los informes que queremos utilizar. En nuestro
caso, copiaremos el fichero serviciosagrupados.jasper que creamos en el apartado
anterior.
Así pues crea la carpeta Informes dentro de la carpeta de proyecto y copia el fichero
serviciosagrupados.jasper dentro de ella.
Este código le muestra muchos errores, no se preocupe ahora de ellos. En los siguientes
pasos se corregirán. De momento lo que se va a hacer es explicar el código de este evento:
Lo primero que observará es como se usa una variable rutaInforme para almacenar el
camino del informe que queremos mostrar. Observa que dicho informe se especifica con
el fichero .jasper generado con iReport, y que este fichero se encuentra dentro de la
subcarpeta informes.
A continuación viene una línea donde se crea un objeto informe del tipo JasperPrint:
Una vez creado el objeto informe, solo tenemos que presentarlo en pantalla. Los
informes se presentan a través de un objeto del tipo JasperViewer. Los objetos
JasperViewer son ventanas donde se muestran los informes.
Esta línea de código crea una ventana llamada ventanavisor donde se muestra el informe
informe. El parámetro false indica que al cerrarse la ventana del informe no debe acabar
el programa. Si este parámetro fuera true, al cerrar la ventana del informe se cerraría el
programa entero (esto no interesa).
El objeto ventanavisor es una ventana normal y corriente y puede ser visualizada con
setVisible. Por otro lado, se le asigna el título “Informe de servicios” con el método
setTitle.
Todo este código debe estar rodeado de un try...catch para evitar errores inesperados.
7. Todos los errores del código se producen debido a que es necesario indicar los
imports correspondientes a las clases JasperPrint, JasperFillManager, JasperViewer
que participan en el código.
Un import es una línea de código que le dice a java en qué librería debe encontrar la
clase correspondiente.
Normalmente, al hacer clic sobre la línea que da el error, aparece el icono de una
bombilla pequeña en la parte izquierda de la ventana. Al hacer clic sobre esta
bombilla se nos informa de la librería que hace falta importar. Ya sabe que basta
hacer clic sobre esta librería para que se añada la instrucción import correspondiente
de forma automática.
Sin embargo, si prueba esto mismo con las líneas erróneas del código anterior, verá
que no aparece ninguna bombilla. Esto es debido a que las librerías donde se
encuentran las clases JasperPrint, JasperFillManager y JasperViewer no vienen
incluidas en NetBeans, ya que son clases pertenecientes al programa iReport. Así
pues, NetBeans no sabe donde encontrar estas clases.
8. Para evitar este error, es necesario incluir en el proyecto una serie de librerías
propias del programa iReport. Esto se hace de la siguiente forma:
9. Haga clic con el botón derecho del ratón sobre el apartado Bibliotecas de su proyecto
y luego active la opción Agregar archivo JAR/carpeta.
10. Debe acudir a la carpeta del programa iReport para buscar en ella las bibliotecas
necesarias. Concretamente, la carpeta donde se encuentran estas bibliotecas es la
siguiente: Archivos de programa – JasperSoft – iReport-2.0.1 – lib
Archivos de programa – JasperSoft – iReport-2.0.1 – lib
9. Los ficheros que contienen las librerías necesarias para este programa son lo
siguientes: commons-collections-2.1, commons-logging-1.0.2 y jasperreports-2.0.1
11. Repita el proceso para agregar los otros dos ficheros necesarios. Al final, su zona de
Bibliotecas debe quedar así (observe los tres ficheros añadidos):
12. Gracias a la inclusión de estos ficheros, nuestro proyecto ya dispone de las librerías
de clases que contienen a las clases que necesitamos, que recuerda que son:
JasperPrint, JasperFillManager, JasperViewer
Si ahora haces clic sobre la primera línea que da error, verá como ahora NetBeans ya
sabe el import que debe añadirse, y por tanto aparecerá la bombilla. Pulse sobre la
bombilla:
net.sf.jasperreports.engine.JasperFillManager
net.sf.jasperreports.engine.JasperPrint
net.sf.jasperreports.view.JasperViewer
El informe aparece en una ventana (el visor de informes – objeto JasperViewer) que
tiene una pequeña barra de herramientas. En esta barra podrá por ejemplo imprimir
el informe, o cambiar su zoom, entre otras cosas:
Ventana visor de informes (JasperViewer)
Herramientas: guardar, imprimir, zoom, etc...
18. Tal como se ha programado este botón, al pulsarse se visualiza el informe antes de
que el usuario decida imprimirlo o no. En algunos casos, puede ser interesante que el
informe se imprima directamente sin que se visualice antes.
JasperPrintManager.printReport(informe,true);
Esta línea usa un objeto llamado JasperPrintManager que se encarga de imprimir el informe
informe usando el método printReport.
Si el segundo parámetro tiene el valor true, entonces significa que aparecerá el cuadro de
diálogo de impresión:
20. Ejecute el programa y pruebe el nuevo botón. No hace falta que imprima el informe.
CONCLUSIÓN
Para poder imprimir un informe creado con iReport desde una aplicación Java es
necesario agregar ciertas librerías pertenecientes al programa iReport:
Una vez agregadas estas librerías, el proceso para imprimir un informe es el siguiente:
En la hoja guiada anterior se conectó una aplicación Java con un informe realizado con
iReport. La aplicación contaba con un botón que al ser pulsado mostraba el informe.
Hay que tener en cuenta que los datos que se muestran en el informe dependen del
contenido de la base de datos. Es decir, si se añaden nuevos registros a las tablas, estos
registros aparecerán en el informe (no será necesario modificarlo de alguna forma)
Sin embargo, esta forma de trabajar puede ser poco interesante, ya que el usuario no tiene
ningún control sobre el informe que se muestra. En la hoja guiada anterior el informe
mostraba todos los servicios agrupados por tipo, pero, y si el usuario quisiera en un
determinado momento que solo se mostraran los servicios anteriores a una fecha, o que se
mostraran los servicios que costaran más de una cantidad, etc...
El problema está en que la consulta SQL del informe es una consulta fija, y siempre sacará
los mismos datos. El usuario de nuestro programa no tiene forma de modificar esa consulta
para cambiar los datos deben aparecer en el informe.
Para poder hacer esto, es necesario usar parámetros en la consulta SQL del informe. Un
parámetro se podría definir como dato de la consulta que no está definido aún. Es necesario
definir ese dato antes de ejecutar la consulta y extraer los datos que se mostrarán.
Puede ser el usuario de nuestro programa el que aporte ese dato que le falta a la consulta,
de manera que así tenga cierto control sobre la información que aparece en el listado.
Es necesario hacer que este informe sea más versátil, que sea capaz de mostrar el
listado de servicios de cualquier trabajador. Para ello, será necesario crear un
parámetro en la consulta SQL.
La consulta SQL extrae información de aquellos servicios que hayan sido realizados
por el trabajador con DNI 12.321.567-B.
$P{nombredelparámetro}
En nuestro caso el nombre que le hemos dado al parámetro es “DNI”, por lo tanto el
parámetro es:
$P{DNI}
Este parámetro indica que el DNI no está definido aún. Será el usuario el que
introduzca el DNI según el cual habrá que consultar en la base de datos.
6. Pulse OK. Cada vez que use un parámetro hay que definirlo en el programa iReport.
Esto se hace en la zona de campos. Observa que tenemos también una zona de
parámetros:
7. En la carpeta de parámetros haz clic con el botón derecho del ratón e indica la opción
Add – Parameter para añadir un nuevo parámetro:
8. En la ventana que aparece debes indicar el nombre que le has dado al parámetro. En
nuestro caso, el nombre asignado es “DNI”:
9. Ahora ya tiene definido un parámetro que se corresponde con el DNI del trabajador.
El usuario introducirá ese DNI y será sustituido en la consulta SQL. Si intenta
visualizar el informe, no podrá ver nada, ya que el parámetro no tiene ahora ningún
valor. Al visualizar el informe aparecerá el siguiente mensaje:
10. En cualquier caso, se tiene que haber generado el fichero .jasper correspondiente. Si
el iReport sigue configurado tal como se hizo en la hoja guiada anterior, dicho fichero
se tiene que haber guardado en Mis Documentos con el nombre serviciosjuan.jasper.
Este fichero lo usará en el siguiente ejercicio.
1. Abra la aplicación Java que realizó en la hoja guiada anterior. Añada en su ventana
un nuevo botón y un cuadro de texto.
2. El objetivo es hacer que el usuario introduzca un DNI en el cuadro de texto DNI y que
al pulsar el botón Servicios del Trabajador aparezca un informe con el listado de
servicios del trabajador con el DNI introducido.
Para hacer esto es necesario que el DNI introducido en el cuadro de texto txtDNI se
traslade directamente al informe creado anteriormente y se coloque en la posición del
parámetro. Entonces la consulta SQL del informe se completará y se podrá rellenar el
informe con los datos correctos.
4. Nota Importante: Recuerde que el informe contiene una imagen proporcionada por el
fichero nenúfares.jpg. Para que el informe funcione correctamente es necesario que
copie este fichero directamente en la carpeta de su proyecto (no dentro de la carpeta
informes)
En él verá dos líneas nuevas en las que se definen los valores de los parámetros:
Map parametros = new HashMap();
parametros.put(“DNI”,txtDNI.getText());
En la primera de estas dos líneas se define un objeto de tipo Map. Este objeto contendrá el
nombre de cada parámetro que usará y el valor de dicho parámetro.
Si existieran más parámetros habría que definirlos de la misma forma, por ejemplo:
parametros.put(“sueldo”,txtSueldo.getText());
parametros.put(“codigo”,”A-54”);
En este código ficticio se crea un parámetro sueldo al que se le asigna el valor de un cuadro
de texto txtSueldo. Y se crea un parámetro codigo al que se le asigna el valor “A-54”.
En nuestro caso solo necesitamos usar un parámetro llamado DNI. Hay que tener en cuenta
que el nombre del parámetro debe ser el mismo que el nombre usado en iReport.
La siguiente línea es la que crea el objeto informe (JasperPrint) Esta línea crea el informe a
partir del fichero de informe compilado serviciosjuan.jasper, a partir de la base de datos
(representada por el objeto conexión) y lo más interesante ahora es que se indica el conjunto
de parámetros a través del objeto parametro creado antes.
Cuando el informe que se va a mostrar no tiene parámetros, entonces se usa el valor null, en
caso contrario, se usa el objeto parámetro (Map)
El resto del código es igual que los anteriores, se crea el visor de informe conteniendo el
informe y se muestra en pantalla.
Como puede observar, ahora ya puede visualizar los datos de los servicios de
cualquier trabajador y no solo del trabajador Juan Pérez.
NOTA
En los ejemplos guiados que se acaban de proponer, se usa una consulta SQL de informe
que contiene un parámetro equivalente a un dato. Concretamente, a un DNI. Este dato forma
parte de una condición. Observa la consulta SELECT del informe que hemos usado:
parámetro
select * from trabajadores, servicios
where trabajadores.dni=servicios.dni and trabajadores.dni=$P{DNI}
order by servicios.fecha
Condición
En este caso, el DNI será proporcionado por la aplicación java y la condición se completará.
Sin embargo, hay que indicar que también se pueden crear parámetros que sustituyan a una
condición completa, en vez de a un solo dato. Observa el siguiente ejemplo:
En este caso, el parámetro se llama COND y no sustituye a un simple dato, sino que
sustituye a toda la condición. En este caso, la aplicación java mandará una cadena que
tenga forma de condición SQL, como por ejemplo: “trabajadores.sueldo > 200”, que
será reemplazada en el lugar del parámetro.
Para que lo vea claro, el código a usar en la aplicación java para dar valor al parámetro
podría ser como sigue:
$P{nombreparámetro}
Cuando se quiera usar un parámetro que represente a una condición, se usará la siguiente
sintaxis:
$P!{nombreparámetro}
Cuando un informe tiene una instrucción SQL invariable, siempre mostrará los
mismos datos.
Puede resultar interesante que parte de la instrucción SQL del informe pueda variar,
de forma que se pueda extraer distinta información según el dato que varía. Estos
datos variantes se denominan parámetros.
$P{nombre}
$P!{nombre}
En la aplicación java es necesario crear un objeto de tipo Map que contenga los
distintos parámetros con los valores de cada uno para luego enviar este objeto al
informe que se quiere mostrar.
El uso de parámetros en informes hace que estos sean mucho más versátiles y que el
programa tenga más posibilidades.
EJERCICIO GUIADO. JAVA. CARPETA DISTRIBUIBLE
A continuación se indican las cosas a tener en cuenta a la hora de realizar una distribución
de nuestro proyecto.
2. Si realiza esta operación con alguno de sus proyectos, puede acudir a la carpeta del
proyecto y observará la existencia de la carpeta dist:
Debe recordar que los programas java pueden ejecutarse en cualquier entorno. Por
ello, los ejecutables java no tienen una extensión .exe la cual es propia de los
entornos Windows.
Para que un ejecutable .jar pueda ser ejecutado en un determinado sistema, debe
estar instalado en él la máquina virtual de java.
5. Aparte del fichero ejecutable (.jar) el cual tendrá el nombre del proyecto, verá también
una carpeta lib. Esta carpeta contendrá aquellas librerías adicionales que se hayan
incluido en el proyecto.
6. Bases de datos.
Si su programa usa una base de datos, entonces será necesario copiar dicha base de
datos en la carpeta del distribuible.
Si suele crear una carpeta para la base de datos, entonces copie la carpeta con la
base de datos en la carpeta distribuible:
7. Imágenes, Iconos.
Si es ordenado, todas estas imágenes estarán dentro de una misma carpeta (llamada
por ejemplo imágenes) Así pues, copie la carpeta que contiene las imágenes que
está usando dentro la carpeta distribuible:
8. Informes.
Si su programa usa informes, es necesario que los ficheros de estos estén dentro de
la carpeta del distribuible.
Los ficheros de informes necesarios para el funcionamiento del programa son los
ficheros compilados .jasper. Los demás no son necesarios incluirlos.
9. Imágenes de informes.
10. Si estamos ante este caso, para que funcione los informes con imágenes de su
programa es necesario que introduzca las imágenes de los informes directamente en
la carpeta distribuible. En nuestro ejemplo la carpeta distribuible quedaría así:
11. Sin embargo, para mantener una cierta organización de la carpeta distribuible, sería
interesante que las imágenes de los informes estuvieran también dentro de la carpeta
Imágenes. Si quisiera hacer esto, tendría que modificar sus informes con imágenes
de forma que se indicara la carpeta donde estará cada imagen. En nuestro ejemplo,
la imagen del informe se tendría que haber configurado así:
13. Una vez incluidos todos estos elementos ya tendremos la carpeta distribuible
completada.
Solo tiene que copiar la carpeta dist en un CD, USB o disquete para trasladarla al
ordenador del cliente. Si quiere, puede cambiarle el nombre a dicha carpeta.
14. Para la instalación del programa en el ordenador del cliente, solo tiene que copiar la
carpeta distribuible en el disco duro del ordenador del cliente.
Se recomienda que lleve la máquina virtual de java propia del sistema operativo del
cliente por si este no la tuviera instalada en su ordenador. Si este fuera el caso, se
tendría que instalar para que el proyecto pudiera ejecutarse.
CONCLUSIÓN
NetBeans permite crear una carpeta llamada dist la cual será la que copiaremos en el
ordenador del cliente.
Basta que el cliente tenga instalada la máquina virtual de java para que nuestro
proyecto funcione.
A la hora de crear la carpeta dist debe tener en cuenta que debe añadir la base de
datos, los informes y las imágenes del proyecto, si es que este usa alguno de dichos
elementos.
EJERCICIO GUIADO. JAVA. INSTALABLE.
Se ha visto en la hoja guiada anterior que para trasladar el programa java realizado al
ordenador del cliente basta con crear una carpeta “distribuible”. Esta carpeta contiene el
fichero ejecutable .jar que permite ejecutar el programa.
El ordenador del cliente debe tener instalada la máquina virtual de java para que nuestro
programa funcione. Una vez instalada la máquina virtual de java en el ordenador del cliente,
basta con copiar la carpeta “distribuible” en su disco duro.
Aunque este proceso es muy sencillo, puede suceder que el cliente no sea capaz de
realizarlo, en el caso de que carezca de conocimientos informáticos básicos. En este caso,
podría ser interesante automatizar la instalación del programa a través de un fichero de
instalación.
En esta hoja guiada se verá como crear un instalable para un programa java, usando un
programa llamado iZpack.
Qué es IZPACK
IZPack es una aplicación que nos permite crear un fichero de instalación a partir de una
aplicación escrita en java. Esto nos permite que nuestras aplicaciones Java sean más fáciles
de distribuir e instalar.
IZPack crea un fichero .jar, que contiene todos los ficheros necesarios del programa. Basta
con ejecutar este fichero para que el programa java que ha creado se instale.
http://www.izforge.com/izpack/
Antes de empezar con esta hoja guiada instala el programa IZPack en tu ordenador.
Para ello debes abrir tu proyecto en NetBeans y seguir los pasos que se indicaron en
la hoja guiada anterior.
2. Una vez creada la carpeta del Distribuible, crea un fichero usando el Bloc de Notas
llamado Licencia.txt. Este fichero debe contener la licencia de uso del programa. Este
fichero lo guardarás en la carpeta Distribuible.
3. Ahora crea usando el Bloc de Notas un fichero llamado Leeme.txt. Aquí introducirás
algún comentario sobre tu proyecto que consideres útil para el cliente. Por ejemplo
datos de contacto (teléfono, email), información sobre la versión del programa o
cualquier otra información que consideres interesante. Este fichero también lo
guardarás en la carpeta Distribuible.
5. Una vez creados estos dos ficheros de texto, tiene que crear un nuevo fichero
llamado install.xml. Este fichero lo creará usando el Bloc de Notas en la carpeta
Distribuible.
<installation version="1.0">
<info>
<appname>Nombre del Programa</appname>
<appversion>Versión</appversion>
<authors>
<author name="Juan Pérez" email="juanperez@hotmail.com"/>
</authors>
<url>http://www.mipagina.es/</url>
</info>
<locale>
<langpack iso3="spa"/>
</locale>
<resources>
<res id="LicencePanel.licence" src="Licencia.txt"/>
<res id="InfoPanel.info" src="Leeme.txt"/>
<res src="shortcutSpec.xml" id="shortcutSpec.xml"/>
</resources>
<panels>
<panel classname="HelloPanel"/>
<panel classname="InfoPanel"/>
<panel classname="LicencePanel"/>
<panel classname="TargetPanel"/>
<panel classname="PacksPanel"/>
<panel classname="InstallPanel"/>
<panel classname="ShortcutPanel" />
<panel classname="SimpleFinishPanel"/>
</panels>
<packs>
<pack name="Ficheros del Programa" required="yes">
<description>Ficheros y Carpetas del Programa</description>
<file src="lib" targetdir="$INSTALL_PATH"/>
<file src="base" targetdir="$INSTALL_PATH"/>
<file src="informes" targetdir="$INSTALL_PATH"/>
<file src="imagenes" targetdir="$INSTALL_PATH"/>
<file src="gestion.jar" targetdir="$INSTALL_PATH"/>
<file src="icono.ico" targetdir="$INSTALL_PATH"/>
</pack>
</packs>
</installation>
6. El fichero install.xml que acaba de crear en el punto anterior es siempre igual. Solo
tiene que cambiar una serie de datos (los marcados en verde), tal como se indica a
continuación:
En la primera parte del fichero se indican los datos del programador y del
programa. Observe:
y tu email
Y tu página web
- Carpetas de tu programa.
En la parte final del fichero tendrás que indicar las carpetas que forman tu
programa (es decir las carpetas que contiene la carpeta distribuible) Observa:
<packs>
<pack name="Ficheros del Programa" required="yes">
<description>Ficheros y Carpetas del Programa</description>
<file src="lib" targetdir="$INSTALL_PATH"/>
<file src="base" targetdir="$INSTALL_PATH"/>
<file src="informes" targetdir="$INSTALL_PATH"/>
<file src="imagenes" targetdir="$INSTALL_PATH"/>
<file src="gestion.jar" targetdir="$INSTALL_PATH"/>
<file src="icono.ico" targetdir="$INSTALL_PATH"/>
</pack>
</packs>
En este ejemplo se supone que la carpeta
distribuible (dist) contiene:
Tendrá que indicar también el nombre
del fichero executable de su programa, el
- Una carpeta de librería (lib)
cual se encuentra también dentro de la
- Una carpeta para la base de
carpeta distribuible. En este ejemplo se
datos (base)
supone que el fichero se llama
- - Una carpeta para los informes
gestion.jar. Escriba usted el nombre de
(informes)
su programa.
- Una carpeta para las imágenes
(imágenes)
Y este es el fichero de icono que ha Usted tendrá que indicar el nombre que le
introducido en la carpeta distribuible. haya dado a sus subcarpetas.
7. Ahora tiene que añadir un nuevo fichero dentro de la carpeta Distribuible que
configura la creación de accesos directos en el menú inicio cuando el programa se
instala en Windows. Este fichero se llamará shortcutSpec.xml.
Este fichero tiene el siguiente contenido (no es necesario que lo entienda, solo fíjese
en los elementos resaltados):
<shortcuts>
8. Debes crear este fichero con el contenido anterior tal cual. Siempre es igual. Solo
tienes que variar los elementos seleccionados en verde tal como se indica a
continuación:
1. Una vez realizados los pasos anteriores (siempre son los mismos) hay que generar el
fichero Instalable. Para ello debes entrar en el símbolo del sistema.
2. Debes acceder a la carpeta del programa IZPack. Para ello, debes ejecutar el
siguiente comando MS-DOS:
CD C:\ARCHIVOS DE PROGRAMA\IZPACK
3. Una vez dentro de la carpeta del programa IzPack, debes ejecutar el siguiente
comando:
Por ejemplo, supongamos que tienes la carpeta distribuible llamada dist en una
carpeta llamada proyectos en el disco duro. (c:\proyectos\dist) Entonces tendrías que
indicar el siguiente comando para crear el instalable:
1. Una vez creada la carpeta de distribución con el fichero install.jar dentro de ella, solo
hay que guardar esta carpeta en un CD y entregárselo al cliente.
2. El cliente solo tiene que introducir el CD, entrar dentro de él y ejecutar con un doble
clic el fichero de instalación install.jar. Y el programa se instalará automáticamente.
Hay que tener en cuenta que si el cliente no tiene instalada la máquina virtual de java
no se podrá realizar la instalación del programa.