EJERCICIO GUIADO. JAVA: CUADROS DE VERIFICACIÓN
1. Realiza un nuevo proyecto. 2. En la ventana principal debes añadir lo siguiente: a. Un botón “Aceptar” llamado btnAceptar. b. Una etiqueta con borde llamada etiResultado. 3. Añade también tres cuadros de verificación. Estos cuadros son objetos del tipo JCheckBox.
4. Añade tres JCheckBox y cambia el texto de ellos, de forma que aparezca “Perro”, “Gato” y “Ratón”. 5. Debe cambiar el nombre de cada uno de ellos. Se llamarán: chkPerro, chkGato, chkRaton. 6. La ventana tendrá el siguiente aspecto cuando termine:
7. El programa debe funcionar de la siguiente forma: Cuando el usuario pulse aceptar, en la etiqueta aparecerá un mensaje indicando qué animales han sido “seleccionados”. Para ello hay que programar el evento actionPerformed del botón Aceptar. En ese evento añada el siguiente código: String mensaje="Animales elegidos: "; if (chkPerro.isSelected()) { mensaje=mensaje+"Perro "; } if (chkGato.isSelected()) { mensaje=mensaje+"Gato "; } if (chkRaton.isSelected()) { mensaje=mensaje+"Raton "; } etiResultado.setText(mensaje);
8. Observa el código. En él se hace lo siguiente: a. Se crea una variable de cadena llamada mensaje. b. En esa variable se introduce el texto “Animales elegidos: “ c. Luego, compruebo si está seleccionada la casilla de verificación chkPerro. Si es así concateno a la cadena mensaje la palabra “Perro”. d. Luego compruebo si está seleccionada la casilla de verificación chkGato y hago lo mismo. e. Lo mismo con la casilla chkRaton. f. Finalmente presento la cadena mensaje en la etiqueta etiResultado. 9. Observa el método isSelected() propio de las casillas de verificación, permiten saber si una casilla está activada o no. 10. Ejecute el programa. Seleccione por ejemplo las casillas Gato y Ratón. Al pulsar Aceptar el resultado debe ser el siguiente:
CONCLUSIÓN Los cuadros de verificación (JCheckBox) se usan cuando quieres seleccionar varias opciones.
EJERCICIO GUIADO. JAVA: BOTONES DE OPCIÓN 1. Realiza un nuevo proyecto. 2. En la ventana principal debes añadir lo siguiente: a. Un botón “Aceptar” llamado btnAceptar. b. Una etiqueta con borde llamada etiResultado. 3. Añade un panel. Un panel es una zona rectangular que puede contener elementos (botones, etiquetas, etc) La forma de poner un panel es a través del objeto JPanel.
4. Una vez añadido el panel en el JFrame, le pondremos un borde para poder localizarlo fácilmente. Debes hacer lo siguiente: a. Selecciona el panel que has añadido. b. Activa la propiedad Border (botón con tres puntos) c. Busca el tipo de borde llamado TitledBorder (borde con título) y pon el título colores.
5. Tu ventana debe quedar más o menos así:
6. Ahora debes añadir tres botones de opción (botones de radio) dentro del panel. Estos botones son objetos del tipo JRadioButton.
7. Añade tres JRadioButton y cambia el texto de ellos, de forma que aparezca “Rojo”, “Verde” y “Azul”. 8. Debe cambiar el nombre de cada uno de ellos. Se llamarán: optRojo, optVerde, optAzul. 9. La ventana tendrá el siguiente aspecto cuando termine:
10. Si ejecuta el programa, observará que pueden seleccionarse varios colores a la vez. Esto no es interesante, ya que los botones de opción se usan para activar solo una opción entre varias.
11. Hay que hacer que solo un botón de opción pueda estar seleccionado a la vez. Para ello, debe añadir un nuevo objeto. Realice los siguientes pasos: a. Añada un objeto del tipo ButtonGroup al formulario. ¡Atención! Este objeto es invisible, y no se verá en el formulario, sin embargo, lo podréis ver en el Inspector, en la parte de “Otros Componentes”:
b. Tienes que darle un nombre al ButtonGroup. El nombre será “grupoColores”. c. Ahora, hay que conseguir que los tres botones pertenezcan al mismo grupo. Es decir, que pertenezcan al grupo grupoColores. d. Selecciona el botón de opción optRojo y cambia su propiedad buttonGroup, indicando que pertenece al grupo colores (observa la imagen):
e. Haz lo mismo con los botones optVerde y optAzul.
12. Acabas de asociar los tres botones de opción a un mismo grupo. Esto produce que solo una de las tres opciones pueda estar activada. Pruébelo ejecutando el programa.
13. Ahora interesa que la opción “Rojo” salga activada desde el principio. Una forma de hacer esto es programando en el “Constructor” lo siguiente: optRojo.setSelected(true); El método setSelected hace que se pueda activar o desactivar un botón de opción. Prueba el programa. Observa como la opción Rojo está activada inicialmente.
14. El programa no está terminado aún. Interesa que cuando el usuario pulse el botón Aceptar, en la etiqueta aparezca el color elegido. Para ello, en el actionPerformed del botón Aceptar programe lo siguiente: String mensaje="Color elegido: "; if (optRojo.isSelected()) { mensaje=mensaje+"Rojo"; } else if (optVerde.isSelected()) { mensaje=mensaje+"Verde"; } else if (optAzul.isSelected()) { mensaje=mensaje+"Azul"; } etiResultado.setText(mensaje);
15. Observa el código. En él se hace lo siguiente: a. Se crea una variable de cadena llamada mensaje. b. En esa variable se introduce el texto “Color elegido: “ c. Luego se comprueba que opción está seleccionada, usando el método isSelected de los botones de opción. Este método te dice si un botón está seleccionado o no. d. Según la opción que esté seleccionada, se añade un texto u otro a la cadena mensaje. e. Finalmente se muestra la cadena mensaje en la etiqueta etiResultado.
16. Ejecute el programa. Seleccione por ejemplo la Verde. Al pulsar Aceptar el resultado debe ser el siguiente:
CONCLUSIÓN Los botones de opción, también llamados botones de radio (JRadioButton) se usan cuando quieres que el usuario pueda elegir una opción de entre varias. Es interesante que los botones de radio aparezcan dentro de un panel JPanel. Se recomienda colocar un borde al panel. Es totalmente necesario añadir un objeto del tipo ButtonGroup, y hacer que los botones de radio pertenezcan a dicho grupo. En caso contrario, será posible activar varios botones de opción a la vez.
EJERCICIO GUIADO. JAVA: CUADROS DE LISTA 1. Realiza un nuevo proyecto. 2. En la ventana principal debes añadir lo siguiente: a. Un botón “Aceptar” llamado btnAceptar. b. Una etiqueta con borde llamada etiResultado. 3. Añade un cuadro de lista. Los cuadros de listas son objetos JList.
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. 8. Puedes añadir elementos escribiéndolos en el cuadro Artículo y luego pulsando el botón “Añadir” (Add).
9. Debes hacer que la lista sea la siguiente: Rojo Verde Azul 10. Ahora programaremos el actionPerformed del botón Aceptar. Debes introducir el siguiente código: String mensaje; mensaje="El color seleccionado es: "+lstColores.getSelectedValue().toString(); etiResultado.setText(mensaje);
11. Observa el código: a. Se crea una variable de cadena llamada mensaje. b. Y dentro de esta variable se introduce una concatenación de cadenas. c. Observa la parte: lstColores.getSelectedValue(), esta parte devuelve el valor seleccionado de la lista. d. Hay que tener en cuenta que este valor no es una cadena, por eso hay que convertirla a cadena añadiendo .toString(). e. De esta manera puedes extraer el elemento seleccionado de un cuadro de lista. f. Luego simplemente ponemos la cadena mensaje dentro de la etiqueta. 12. Ejecuta el programa y observa su funcionamiento. Por ejemplo, si seleccionas el color verde y pulsas aceptar el resultado será el siguiente:
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);
14. Observa el código: a. El método getSelectedIndex me dice el índice del elemento que está seleccionado.
b. Por ejemplo, si está seleccionado el primero el índice es 0, si está seleccionado el segundo el índice es 1, etc. c. Si este método devuelve -1, entonces es señal de que no hay ningún elemento seleccionado. d. Aprovecho esto para mostrar un mensaje indicando lo sucedido. 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. Se anima a que realice esta modificación.
CONCLUSIÓN El objeto JList permite crear cuadros de lista. Estos objetos contienen una serie de elementos que pueden ser seleccionados. A través del método getSelectedValue se puede obtener el elemento que está seleccionado. (Recuerda convertirlo a cadena con toString) A través del método getSelectedIndex se puede saber la posición del elemento seleccionado. Si este índice es -1, entonces sabremos que no hay ningún elemento seleccionado.
EJERCICIO GUIADO. JAVA: CUADROS COMBINADOS 1. Realiza un nuevo proyecto. 2. En la ventana principal debes añadir lo siguiente: a. Una etiqueta con borde llamada etiResultado. 3. Añade un cuadro combinado (combo). Los cuadros combinados son objetos del tipo JComboBox. Básicamente, un combo es una lista desplegable.
4. Cámbiale el nombre al JComboBox. El nombre será cboColores. Tu programa debe tener más o menos este aspecto.
5. Los elementos del cboColores pueden ser cambiados a través de la propiedad Model. Selecciona el combo y activa la propiedad Model (el botoncito con los tres puntos) Aparecerá lo siguiente:
6. Al igual que pasaba con los cuadros de lista, se pueden eliminar los elementos que contiene el combo y añadir elementos propios. Use los botones Añadir y Eliminar para añadir la siguiente lista de elementos: Rojo Verde Azul 7. Ejecuta el programa y observa el funcionamiento del desplegable...
8. Vamos a hacer que cuando se elija un elemento del desplegable, en la etiqueta aparezca un mensaje indicando el color elegido. Para ello, debes programar el evento actionPerformed del combo y añadir el siguiente código: String mensaje="El color elegido es "; mensaje=mensaje+cboColores.getSelectedItem().toString(); etiResultado.setText(mensaje);
9. Este código hace lo siguiente: a. Crea una variable de cadena. b. Concatena dentro de ella el mensaje “El color elegido es” con el color seleccionado. c. Observa el método getSelectedItem, se usa para saber el elemento seleccionado del combo. Es necesario convertirlo a texto con toString. d. Finalmente se coloca el mensaje en la etiqueta. 10. Ejecuta el programa y comprueba su funcionamiento. Por ejemplo, si elegimos el color verde, el aspecto del programa será el siguiente:
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. A través del método getSelectedItem se puede extraer la opción seleccionada o el texto escrito en el combo.
EJERCICIO GUIADO. JAVA: MODELOS DE CUADRO DE LISTA 1. Realiza un nuevo proyecto. 2. En la ventana principal debes añadir lo siguiente: a. Una etiqueta con borde llamada etiResultado. 3. Añade un cuadro de lista al formulario (JList).
4. Borra todo el contenido de la lista (propiedad model) y cámbiale el nombre a la lista. La lista se llamará lstNombres. Recuerda que las listas aparecen dentro de un objeto del tipo JScrollPane.
5. Añade dos botones al formulario. Uno de ellos tendrá el texto “Curso 1” y se llamará btnCurso1 y el otro tendrá el texto “Curso 2” y se llamará btnCurso2.
6. En el evento actionPerformed del botón “Curso 1” programa lo siguiente: DefaultListModel modelo = new DefaultListModel(); modelo.addElement("Juan"); modelo.addElement("María"); modelo.addElement("Luis"); lstNombres.setModel(modelo);
7. En el evento actionPerformed del botón “Curso 2” programa lo siguiente: DefaultListModel modelo = new DefaultListModel(); modelo.addElement("Ana"); modelo.addElement("Marta"); modelo.addElement("Jose"); lstNombres.setModel(modelo);
8. Explicación de los códigos anteriores: a. Lo que hace cada botón es rellenar el cuadro de lista con una serie de nombres. En el caso del botón “Curso 1”, la lista se rellena con los nombres Juan, María y Luis, mientras que en el caso del botón “Curso 2”, la lista se rellena con los nombres Ana, Marta y Jose. b. El contenido de un cuadro de lista es lo que se denomina un “modelo”. El “modelo” es un objeto que contiene el listado de elementos de la lista. c. Los modelos de las listas son objetos del tipo DefaultListModel. d. Lo que hace el programa es crear un “modelo”. Luego rellena el “modelo” con datos, y finalmente asocia el “modelo” al cuadro de lista. Veamos como se hace todo esto.
e. Primero se crea el “modelo”, a través de la siguiente instrucción (será necesario añadir el import correspondiente, atento a la bombillita): DefaultListModel modelo = new DefaultListModel(); f.
El “modelo” tiene un método llamado addElement que permite introducir datos dentro de él. Así pues usamos este método para añadir los datos al modelo.
modelo.addElement("Ana"); modelo.addElement("Marta"); modelo.addElement("Jose"); g. Finalmente asociamos el “modelo” creado al cuadro de lista de la siguiente forma: 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 Un cuadro de lista es un objeto que contiene a su vez otro objeto denominado “modelo”. El objeto “modelo” es el que realmente contiene los datos de la lista. Cuadro de lista Modelo Datos Se puede crear un “modelo” y luego introducir datos en él. Luego se puede asociar ese “modelo” a la lista. De esta manera se puede cambiar el contenido de la lista en cualquier momento.
EJERCICIO GUIADO. JAVA: MODELOS DE CUADRO DE LISTA 1. Realiza un nuevo proyecto. 2. En la ventana principal debes añadir lo siguiente: a. b. c. d.
Un combo llamado cboNumeros. Un botón “Pares” llamado btnPares. Un botón “Impares” llamado btnImpares. Una etiqueta con borde llamada etiResultado.
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í:
5. En el evento actionPerformed del botón Pares, programa lo siguiente: int i; DefaultComboBoxModel modelo = new DefaultComboBoxModel(); for (i=0;i<10;i+=2) { modelo.addElement("Nº "+i); } cboNumeros.setModel(modelo);
6. Observa lo que hace este código: a. Crea un objeto “modelo” para el combo. Al igual que pasa con los cuadros de lista, los combos tienen un objeto “modelo” que es el que realmente contiene los datos. En el caso de los combos, para crear un objeto “modelo” se usará esta instrucción: DefaultComboBoxModel modelo = new DefaultComboBoxModel();
b. A continuación, se usa el objeto “modelo” creado y se rellena de datos. Concretamente, se rellena con los números pares comprendidos entre 0 y 10. c. Observa el uso de la propiedad addElement para añadir un elemento al modelo del combo. d. Se ha usado un bucle for para hacer la introducción de datos en el modelo más fácil. e. Finalmente, se asocia el modelo al combo a través de la siguiente línea, con lo que el combo aparece relleno con los elementos del modelo: cboNumeros.setModel(modelo);
7. Ejecuta el programa y observa el funcionamiento del botón Pares.
Se pulsa y se rellena automáticamente
8. El botón Impares es similar. Programa su actionPerformed como sigue: int i; DefaultComboBoxModel modelo = new DefaultComboBoxModel(); for (i=1;i<10;i+=2) { 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.
10. Finalmente se programará el actionPerformed del combo para que al seleccionar un elemento este aparezca en la etiqueta. Esto se hace con una simple instrucción:
etiResultado.setText(cboNumeros.getSelectedItem().toString());
Recuerda el uso de getSelectedItem() para recoger el elemento seleccionado, y el uso de toString() para convertirlo a texto.
11. Prueba el programa. Prueba los botones Pares e Impares y prueba el combo.
12. Sería interesante añadir un botón “Vaciar” llamado btnVaciar que vaciara el contenido del combo. Esto se haría simplemente creando un modelo vacío y asignarlo al combo. Se anima al alumno a que realice esta mejora.
CONCLUSIÓN Un combo, al igual que los cuadros de lista, es un objeto que contiene a su vez otro objeto denominado “modelo”. El objeto “modelo” es el que realmente contiene los datos del combo. Combo Modelo Datos Se puede crear un “modelo” y luego introducir datos en él. Luego se puede asociar ese “modelo” al combo. De esta manera se puede cambiar el contenido del combo en cualquier momento.
EJERCICIO GUIADO. JAVA: TOGGLEBUTTONS 1. Realiza un nuevo proyecto. 2. Crearás una ventana como la que sigue teniendo en cuenta lo siguiente: a. Se añadirá una etiqueta con el texto “Precio Base”. No hace falta cambiarle su nombre. b. Se añadirá un cuadro de texto llamado txtPrecioBase. c. Se creará un botón “Calcular”, llamado btnCalcular. d. Se creará una etiqueta vacía y con borde llamada etiTotal. Use la propiedad font de esta etiqueta para hacer que el texto tenga un mayor tamaño.
e. Debes añadir también tres botones, con el texto “Instalación”, “Formación” y “Alimentación BD” respectivamente. Estos botones no son botones normales, son botones del tipo JToggleButton. Usa este tipo de objeto para crearlos. Estos botones, se diferencian de los botones normales en que se quedan pulsados cuando se hace un clic sobre ellos, y no vuelven a su estado normal hasta que no se vuelve a hacer clic sobre ellos. Los tres botones se llamarán respectivamente: tbtnInstalacion, tbtnFormacion, tbtnAlimentacionBD.
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.
3. Prueba el programa y comprueba el funcionamiento de los botones JToggleButton:
Observa como al pulsar los JToggledButton estos se quedan pulsados. Si se vuelven a activar se “despulsan”.
4. Se pretende que el programa funcione de la siguiente forma: a. b. c. d.
El usuario introducirá un precio base para el servicio que se vende. A continuación, si el cliente quiere la instalación, activará el botón Instalación. Si el cliente quiere la formación, activará el botón Formación. Si el cliente quiere la Alimentación de Base de Datos, activará el botón Alimentación BD. e. Ten en cuenta que el cliente puede querer una o varias de las opciones indicadas. f. Finalmente se pulsará el botón calcular y se calculará el precio total. Este precio se calcula de la siguiente forma: Precio Total = Precio Base + Precio Extras. El precio de los Extras dependerá de las opciones elegidas por el usuario. Por ejemplo, si el usuario quiere Instalación y Formación, los extras costarán 240 euros.
5. Así pues, se programará el actionPerformed del botón Calcular de la siguiente forma:
double double double double
precio_base; precio_instal; //precio instalación precio_for; //precio formacion precio_ali; //precio alimentacion
//Recojo datos desde la ventana: precio_base = Double.parseDouble(txtPrecioBase.getText()); precio_instal = Double.parseDouble(etiPrecioInstalacion.getText()); precio_for = Double.parseDouble(etiPrecioFormacion.getText()); precio_ali = Double.parseDouble(etiPrecioAlimentacionBD.getText()); //Ahora que tengo los datos, puedo hacer cálculos. //Al precio base se le van añadiendo precio de extras //según estén o no activados los JToggleButtons double precio_total; precio_total = precio_base; if (tbtnInstalacion.isSelected()) { //Si se seleccionó instalación precio_total = precio_total+precio_instal; } if (tbtnFormacion.isSelected()) { //Si se seleccionó formación precio_total = precio_total+precio_for; } if (tbtnAlimentacionBD.isSelected()) { //Si se seleccionó Alimentación BD precio_total = precio_total+precio_ali; }
//Finalmente pongo el resultado en la etiqueta etiTotal.setText(precio_total+" €");
6. Veamos una explicación del código: a. Primero se crean variables doubles (ya que se admitirán decimales) para poder hacer los cálculos. b. Se extraerán los datos de la ventana y se almacenarán en dichas variables. Para ello, hay que convertir desde cadena a double: precio_base = Double.parseDouble(txtPrecioBase.getText()); precio_instal = Double.parseDouble(etiPrecioInstalacion.getText()); precio_for = Double.parseDouble(etiPrecioFormacion.getText()); precio_ali = Double.parseDouble(etiPrecioAlimentacionBD.getText());
c. Una vez obtenidos los datos en forma numérica, ya se pueden hacer cálculos con ellos. El programa declara una nueva variable precio_total donde se introducirá el resultado. En primer lugar se introduce en esta variable el precio base. double precio_total; precio_total = precio_base;
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: if (tbtnInstalacion.isSelected()) { //Si se seleccionó instalación precio_total = precio_total+precio_instal; }
Esto significa: “Si el botón instalación está seleccionado, añade al precio total el precio por instalación” Observa el uso del método isSelected para saber si el botón tbtnInstalacion ha sido seleccionado. e. Finalmente el resultado se muestra en la etiqueta de total.
7. Comprueba el funcionamiento del programa… Introduce una cantidad (usa el punto para los decimales) Selecciona los extras que desees. Pulsa Calcular y obtendrás el resultado.
8. Supongamos que normalmente (en el 90 por ciento de los casos) la instalación es solicitada por el usuario. Podría ser interesante que el botón Instalación ya saliera activado al ejecutarse el programa. Para ello, añade en el Constructor la siguiente línea. tbtnInstalacion.setSelected(true);
Esta línea usa el método setSelected para activar al botón tbtnInstalación. Comprueba esto ejecutando el programa.
CONCLUSIÓN Los JToggleButton son botones que pueden quedarse pulsados. A través del método isSelected podemos saber si un JToggleButton está seleccionado. También puedes usar el método setSelected para seleccionar o no un botón de este tipo. Realmente, estos botones no suelen ser muy usados, ya que pueden ser sustituidos por Cuadros de Verificación (JCheckBox) que son más conocidos.
EJERCICIO GUIADO. JAVA: SLIDERS
Introducción a los JSliders La clase JSlider permite crear objetos como el siguiente:
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. Se verá a continuación las características más interesantes de los JSlider y como programarlos.
Ejercicio guiado 1. Crea un nuevo proyecto. 2. Añade en él un JSLider. Su nombre será slDeslizador.
3. Añade una etiqueta con borde. Su nombre será etiValor. 4. La ventana tendrá el siguiente aspecto:
5. Un JSlider tiene un valor mínimo y un valor máximo. El valor mínimo es el valor que tiene cuando el recuadro está pegado a la parte izquierda, mientras que el valor máximo es el valor que tiene cuando el recuadro está pegado a la parte derecha. El valor mínimo y máximo del JSlider se puede cambiar. Busca las propiedades maximum y minimum del JSlider y asigna los siguientes valores: Máximo: 500 Mínimo: 100
6. Se puede asignar un valor inicial al JSlider a través de su propiedad value. Busque esta propiedad y asigne un valor de 400. Observe donde se sitúa el recuadro del JSlider.
7. Se puede mejorar el JSlider definiendo unas divisiones (medidas) Por ejemplo, haremos que cada 50 unidades aparezca una división. Para ello use la propiedad majorTickSpacing y asigne un 50.
8. Esto, en realidad, no produce ningún cambio en el JSlider. Para que las divisiones se vean, es necesario que active también la propiedad paintTicks. Esta propiedad pintará divisiones en el JSlider:
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. El evento stateChanged sucede cuando el usuario arrastra el recuadro del deslizador. En este evento programe lo siguiente: etiValor.setText("El valor es: "+slDeslizador.getValue());
12. Ejecute el programa y observe lo que sucede cuando arrastra el deslizador. 13. La explicación del código es la siguiente: a. El método getValue del deslizador nos devuelve el valor que tiene actualmente el deslizador. b. Este valor es concatenado a la cadena “El valor es:” y es mostrado en la etiqueta a través del conocido setText.
Movemos aquí. Y aparece el valor correspondiente aquí.
14. A continuación se mencionan otras propiedades interesantes de los JSlider que puedes probar por tu cuenta: orientation Permite cambiar la orientación del JSlider. Podrías por ejemplo hacer que el JSlider estuviera en vertical. 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 Los JSliders son objetos “deslizadores”. Permiten elegir un valor arrastrando un pequeño recuadro de derecha a izquierda o viceversa. El valor de un JSliders puede ser obtenido a través de su método getValue. Si quieres programar el cambio (el arrastre) en el deslizador, tienes que programar el evento llamado stateChanged.
EJERCICIO GUIADO. JAVA: SPINNER
Introducción a los JSpinner La clase JSpinner permite crear cuadros como el siguiente:
Son elementos muy comunes en los programas. A través de los dos botones triangulares se puede hacer que el valor del cuadro aumente o disminuya. También se puede escribir directamente un valor dentro del cuadro.
Ejercicio guiado 1. Crea un nuevo proyecto. 2. Añade en él un JSpinner. Su nombre será spiValor.
3. Añade una etiqueta con borde. Su nombre será etiValor. 4. La ventana tendrá el siguiente aspecto:
5. Interesa que cuando cambie el JSpinner (ya sea porque se pulsaron los botones triangulares o porque se escribió dentro) aparezca el valor correspondiente dentro de la etiqueta. Para ello, tendrá que programar el evento stateChanged del JSpinner. En el evento stateChanged introduzca el siguiente código: etiValor.setText("El valor es: "+spiValor.getValue().toString());
6. Como puedes observar, lo que hace el programa es recoger el valor que tiene el JSpinner a través del método getValue y luego se lo asigna a la etiqueta con el clásico setText. (Es muy parecido a los deslizadores) Debes tener en cuenta que el valor devuelto no es un número ni una cadena, así que en el ejemplo se ha usado el método toString() para convertirlo a una cadena.
7. Prueba el programa y observa su funcionamiento: El usuario modifica el valor del JSpinner...
Y aquí aparece el valor seleccionado.
8. Observa como los valores del JSpinner aumentan o disminuyen en 1. Por otro lado, no parece haber un límite para los valores del JSpinner. La pregunta ahora es: ¿Se puede modificar el contenido del JSpinner de forma que tenga unos valores concretos? La respuesta es sí. Veamos como hacerlo.
9. Entra dentro del código del programa y, dentro del constructor, añade este código debajo de initComponents: SpinnerNumberModel nm = new SpinnerNumberModel(); nm.setMaximum(10); nm.setMinimum(0); spiValor.setModel(nm);
10. Este código hace lo siguiente: a. El JSpinner, al igual que los JList y los JComboBox, es un objeto que contiene otro objeto “modelo”, y es el objeto “modelo” el que contiene los números visualizados en el JSpinner. b. En el código anterior se crea un “modelo” para el JSpinner, se definen los valores que contendrá, y luego se asigna al JSpinner. Estudiemos las líneas del código. c. La primera línea crea un “modelo” llamado nm. Los modelos de los JSpinner son del tipo SpinnerNumberModel. Necesitarás incluir el import correspondiente (atento a la bombilla)
d. En la segunda línea se define como valor máximo del modelo el 10, a través de un método llamado setMaximum. e. En la tercera línea se define como valor mínimo del modelo el 0, a través de un método llamado setMinimum. f.
Finalmente se asigna el modelo creado al JSpinner.
g. Este código, en definitiva, hará que el JSpinner muestre los valores comprendidos entre 0 y 10.
11. Prueba el programa y observa los valores que puede tomar el JSpinner.
Ahora los valores están comprendidos entre 0 y 10
12. Vamos a añadir otra mejora. Cambie el código del constructor por este otro. (Observa que solo se ha añadido una línea): SpinnerNumberModel nm = new SpinnerNumberModel(); nm.setMaximum(10); nm.setMinimum(0); nm.setStepSize(2); spiValor.setModel(nm);
13. La línea añadida es: nm.setStepSize(2);
Esta línea usa un método del modelo del JSpinner que permite definir el valor de cambio del JSPinner. Dicho de otra forma, esta línea hace que los valores del JSpinner salten de 2 en 2. 14. Ejecuta el programa de nuevo y observa 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. Datos Modelo JSpinner Para definir el contenido del JSpinner es necesario crear un modelo del tipo SpinnerNumberModel. Se le asigna al modelo los números deseados, y finalmente se une el modelo con el JSpinner. El objeto modelo del JSpinner permite definir el valor mínimo y el valor máximo, así como el intervalo de aumento de los valores.
EJERCICIO GUIADO. JAVA: SCROLLBARS
Introducción a las JscrollBars (Barras de desplazamiento) La clase JScrollBar permite crear barras de desplazamiento independientes, como la que se muestra a continuación:
La barra tiene un valor mínimo, que se consigue haciendo que el recuadro de la barra de desplazamiento esté pegado a la parte izquierda.
Valor mínimo
Cuando se pulsa algunos de los botones de la barra de desplazamiento, el valor de la barra se incrementa / decrementa poco a poco. A este incremento / decremento lo llamaremos incremento unitario.
Decrementa el valor poco a poco (incremento unitario)
Incrementa el valor poco a poco (incremento unitario)
Cuando se pulsa directamente sobre la barra, el valor de la barra se incrementa / decrementa en mayor cantidad. A este incremento / decremento lo llamaremos incremento en bloque.
Al pulsar directamente sobre la barra se decrementa en mayor cantidad (incremento en bloque)
Al pulsar directamente sobre la barra se incremente en mayor cantidad (incremento en bloque)
Ejercicio guiado 1. Para comprender mejor el funcionamiento de las barras de desplazamiento se creará un proyecto nuevo. 2. Añade en el proyecto una barra de desplazamiento (JScrollBar) y llámala desValor.
3. La barra de desplazamiento aparecerá en vertical. Use la propiedad de la barra llamada Orientation para hacer que la barra aparezca en posición horizontal.
4. Añade también una etiqueta con borde y llámala etiValor. 5. La ventana debe quedar más o menos así:
6. Interesa que cuando el usuario cambie de alguna manera la barra de desplazamiento, en la etiqueta aparezca el valor de la barra. Para ello, se debe programar el evento AdjustmentValueChanged de la barra de desplazamiento. En este evento programa lo siguiente: etiValor.setText("El valor es: "+desValor.getValue());
7. Como ves, se coloca en la etiqueta el valor de la barra. El valor de la barra se obtiene con el método getValue. Ejecuta el programa para ver su funcionamiento. Pulsa aquí y observa como el valor cambia poco a poco…
Pero si pulsas aquí el valor cambia en mayor cantidad…
8. Sigamos estudiando el programa. Se pide que cambies las siguientes propiedades de tu barra: Minimum – Permite asignar el valor mínimo de la barra. Escribe un 50 Maximum – Permite asignar el valor máximo de la barra. Escribe un 150
UnitIncrement – Permite cambiar el incremento unitario. Escribe un 2.
BlockIncrement – Permite cambiar el incremento en bloque. Escribe un 20.
VisibleAmount – Permite cambiar el ancho del recuadro de la barra. Escribe un 5.
5
9. Ejecuta ahora el programa y comprueba su funcionamiento: Si pulsas aquí, el valor se incrementa de 2 en 2, ya que el incremento unitario se configuró en 2.
Si pulsas aquí, el valor se incrementa de 20 en 20, ya que el incremento en bloque es de 20.
Si llevas la barra de desplazamiento al mínimo, su valor será de 50, ya que se configuró así con la propiedad minimum…
Observa lo que sucede cuando llevas la barra de desplazamiento al máximo: aparece un valor de 145, cuando el valor máximo que asignamos fue de 150 ¿por qué?
10. Tal como se ha indicado anteriormente, pasa algo raro con la barra de desplazamiento cuando esta está al máximo. Se esperaba que alcanzara el valor 150, y sin embargo, el valor máximo alcanzado fue de 145. La explicación es la siguiente: Valor máximo (150)
*
5
***
Valor de la barra (145) **
* Nuestra barra tiene un valor máximo de 150. ** Sin embargo, el valor de la barra viene indicado por el lado izquierdo del recuadro interno. *** Como el recuadro interno tiene un ancho definido a través de la propiedad VisibleAmount, el valor máximo que la barra puede alcanzar es de: Valor = ValorMáximo – Ancho del recuadro. Es decir, Valor alcanzable = 150 – 5 = 145
11. A través del método setValue de la barra de desplazamiento se puede asignar un valor inicial a la barra. Programe en el constructor de su programa lo necesario para que la barra de desplazamiento tenga un valor de 70 al empezar el programa.
CONCLUSIÓN Las JScrollBars son barras de desplazamiento independientes. Al igual que los JSliders, las JScrollBars tienen un valor concreto, que puede ser obtenido a través del método getValue. Entre las características programables de una barra de desplazamiento, tenemos las siguientes: - Valor mínimo (propiedad Minimum) - Valor máximo (propiedad Maximum) - Incremento unitario (propiedad UnitIncrement) - Incremento en bloque (propiedad BlockIncrement) - Tamaño del recuadro de la barra (propiedad VisibleAmount)
EJERCICIO GUIADO. JAVA: BARRA DE MENUS
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. 2. Añade a tu ventana un objeto JMenuBar
3. En la parte superior de tu ventana aparecerá esto:
4. En el inspector (parte inferior izquierda) observarás como aparece un objeto JMenuBar, y, dentro de él, un objeto del tipo JMenu. Los objetos JMenu representan las opciones principales contenidas dentro de la barra de menús.
5. Aprovecha el Inspector para cambiar el nombre al objeto JMenuBar. Llámalo barraMenus. 6. Cambia también el nombre al objeto JMenu. Asígnale el nombre menuArchivo. El Inspector tendrá el siguiente aspecto:
7. Ahora, la única opción de la barra de menús muestra el texto “Menu”. Esto se puede cambiar seleccionándola y cambiando su propiedad text. Asígnale el texto “Archivo” a la opción del menú:
8. Ahora el aspecto de la barra de menús será el siguiente:
9. Puedes añadir más opciones principales a la barra de menús haciendo clic con el derecho sobre el objeto de la barra de menús y activando la opción “Añadir JMenu”.
10. Añada dos opciones más a la barra de menús. El inspector debe tener ahora el siguiente aspecto:
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ú:
Observa como la opción Archivo se despliega mostrando dos submenús: Abrir y Guardar.
19. Seguiremos añadiendo elementos al menú. Ahora haga clic con el derecho sobre el elemento menuArchivo y añada un JSeparator.
Los JSeparator son objetos que definen una separación entre las opciones de un menú. Cámbiele el nombre y llámelo “separador1”:
20. Añada un nuevo JMenuItem al menú Archivo y ponle el nombre menuSalir. El texto de esta opción será “Salir” (use su propiedad text) El aspecto del Inspector será el siguiente:
21. Ejecuta el programa y observa el contenido de la opción Archivo del menú:
Observa el efecto que produce el separador.
22. Un JMenu representa las opciones principales de la barra de menús. A su vez, un JMenu contiene JMenuItem, que son las opciones contenidas en cada opción principal, y que se ven cuando se despliega el menú. Sin embargo, un JMenu puede contener a otros JMenu, que a su vez contendrán varios JMenuItem. Usando el botón derecho del ratón y la opción “Añadir”, añade un JMenu dentro de menuEdicion:
23. Llama al nuevo JMenu menuColores y 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”.
25. Ejecuta el programa y observa como ha quedado el menú Edición:
La opción Edición (JMenu) contiene una opción Colores (JMenu) que a su vez contiene las opciones Rojo, Verde y Azul (JMenuItems)
26. De nada sirve crear un menú si luego este no reacciona a las pulsaciones del ratón. Cada objeto del menú tiene un evento ActionPerformed que permite programar lo que debe suceder cuando se active dicha opción del menú.
27. Marque en el inspector el objeto menuItemRojo y acceda a su evento ActionPerformed. Dentro de él programe este sencillo código: this.getContentPane().setBackground(Color.RED); Este código cambia el color de fondo de la ventana a rojo. 28. Compruebe el funcionamiento de la opción “Rojo” del menú ejecutando el programa. 29. Programa tu mismo las opciones “Verde” y “Azul”.
CONCLUSIÓN Las barras de menús son un conjunto de objetos de distinto tipo que se contienen unos a los otros: La barra en sí está representada por un objeto del tipo JMenuBar. La barra contiene opciones principales, representadas por objetos JMenu. Las opciones principales contienen opciones que aparecen al desplegarse el menú. Esta opciones son objetos del tipo JMenuItem. Un JMenu también puede contener otros JMenu, que a su vez contendrán JMenuItems. También puede añadir separadores (JSeparator) que permiten visualizar mejor las opciones dentro de un menú.
EJERCICIO GUIADO. JAVA: BARRA DE HERRAMIENTAS
Barras de herramientas Una barra de herramientas es básicamente un contenedor de botones y otros elementos propios de la ventana. A través de estos botones se pueden activar de forma rápida las opciones del programa, las cuales suelen estar también incluidas dentro de la barra de menús.
Ejercicio guiado 1. Veamos como añadir una barra de herramientas a nuestras aplicaciones. En primer lugar, crea un proyecto con el NetBeans. 2. Añade a tu ventana un objeto JmenuBar (una barra de menús) 3. En la parte superior de tu ventana aparecerá esto:
4. Debajo de la barra de menús colocaremos una barra de herramientas, así que añade un objeto del tipo JToolBar. Haz que la barra se coloque debajo de la barra de menús y que alcance desde la parte izquierda de la ventana a la parte derecha. La ventana quedará así:
5. Las barras de herramientas son simples contenedoras de objetos. Dentro de ellas se pueden colocar botones, combos, etiquetas, etc. Normalmente, las barras de herramientas contienen botones. Así que añade cuatro botones (JButton) dentro de la barra. Solo tienes que colocarlos dentro de ella.
6. Puedes ver si los botones están bien colocados observando el Inspector: Observa como los botones colocados se encuentran dentro de la barra.
7. Aprovecharemos el inspector para cambiar el nombre a la barra y a cada botón. A la barra la llamaremos barraHerramientas, y a los botones los llamaremos btnUno, btnDos, btnTres y btnCuatro:
8. Cambia el texto de los botones. Estos contendrán el texto: “Uno”, “Dos”, “Tres” y “Cuatro”. 9. Ejecuta el programa y observa el resultado.
10. La forma de programar cada botón no varía, aunque estos se encuentren dentro de la barra herramientas. Solo hay que seleccionar el botón y acceder a su evento actionPerformed.
11. Solo como demostración de esto último, entra en el actionPerformed del primer botón y programa esto: JOptionPane.showMessageDialog(null,"Activaste el botón uno");
Luego ejecuta el programa y comprueba el funcionamiento del botón.
12. Los botones de la barra de herramientas normalmente no contienen texto, sino que contienen un icono que representa la función que realiza. La forma de colocar un icono dentro de un botón es a través de su propiedad icon. 13. A través de la propiedad icon de un botón podrá seleccionar un fichero de imagen que contenga la imagen a mostrar en el botón. 14. Activa la propiedad icon del primer botón. Luego elige la opción 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. Nota: Procura que la imagen sea pequeña. Nota: Se recomienda buscar imágenes .gif en Internet para practicar.
15. Una vez colocadas las imágenes a los botones, se puede quitar el texto de estos. Un ejemplo de cómo podría quedar la barra de herramientas es este:
CONCLUSIÓN Las barras de herramientas son simplemente contenedores de objetos. Normalmente botones. Los elementos de la barra de herramientas se manejan de la misma forma que si no estuvieran dentro de la barra. Lo normal es hacer que los botones de la barra no tengan texto y tengan iconos asociados.
EJERCICIO GUIADO. JAVA: MENUS EMERGENTES
El evento mouseClicked El evento mouseClicked es capaz de capturar un clic del ratón sobre un determinado elemento de la ventana. Este evento recibe como parámetro un objeto del tipo MouseEvent, y gracias a él se puede conseguir información como la siguiente: -
Qué botón del ratón fue pulsado. Cuantas veces (clic, doble clic, etc) En qué coordenadas fue pulsado el botón. Etc.
Se puede usar esta información para saber por ejemplo si se pulsó el botón derecho del ratón, y sacar en este caso un menú contextual en pantalla. En este ejercicio guiado se estudiarán las posibilidades del evento mouseClicked y se aplicarán a la creación y visualización de menús contextuales (o emergentes)
Ejercicio guiado 1. Crea un nuevo proyecto. 2. No hace falta que añada nada a la ventana. 3. Programaremos la pulsación del ratón sobre el formulario, así que haga clic sobre el formulario y active el evento mouseClicked. 4. Observe el código del evento: private void formMouseClicked(java.awt.event.MouseEvent evt) { // TODO add your handling code here: }
Este evento recibe como parámetro un objeto llamado evt del tipo MouseEvent (en rojo en el código) que nos permite saber en qué condiciones se hizo clic.
5. Dentro del evento programe lo siguiente: if (evt.getButton()==1) { JOptionPane.showMessageDialog(null,"Pulso el izquierdo"); } else if (evt.getButton()==2) { JOptionPane.showMessageDialog(null,"Pulso el central"); } else if (evt.getButton()==3) { JOptionPane.showMessageDialog(null,"Pulso el derecho"); }
6. Ejecuta el programa y haz clic sobre el formulario con el botón derecho, con el izquierdo y con el central. Observa el resultado. 7. Ahora quizás puedas comprender el código anterior. En él, se usa el método getButton del objeto evt para saber qué botón se pulsó. El método getButton devuelve un entero que puede ser 1, 2 o 3 según el botón pulsado.
8. Se puede aprovechar el método getButton para controlar la pulsación del botón derecho del ratón y así sacar un menú contextual. Pero antes, es necesario crear el menú. 9. Agrega a tu formulario un objeto del tipo JPopupMenu. Estos objetos definen menús emergentes. 10. Los objetos JPopupMenu no se muestran en el formulario, pero puedes verlo en el Inspector dentro de la rama de Otros Componentes:
11. Aprovecharemos el inspector para cambiar el nombre al menú. Llámalo menuEmergente. 12. Los menús emergentes se crean igual que las opciones de menús normales, añadiendo con el botón derecho del ratón objetos JMenuItem. 13. Añada al menú emergente tres JMenuItem, y asígneles los siguientes nombres a cada uno: menuRojo, menuVerde, menuAzul. El inspector debería tener el siguiente aspecto:
14. Tienes que cambiar la propiedad text de cada opción del menú. Recuerda que esta propiedad define lo que aparece en el menú. Asignarás los siguientes textos: “Rojo”, “Verde” y “Azul”. 15. El menú emergente ya está construido. Ahora tenemos que hacer que aparezca cuando el usuario pulse el botón derecho del ratón sobre el formulario. Para ello, entraremos de nuevo en el evento mouseClicked del formulario y cambiaremos su código por el siguiente: menuEmergente.show(this,evt.getX(),evt.getY());
16. Este código significa lo siguiente: -
El método show le da la orden al menuEmergente para que se muestre. El método show recibe tres elementos: por un lado la ventana donde actúa (this) Por otro lado la posición x donde debe mostrarse el menú. Esta posición es aquella donde se pulsó el ratón, y se puede conseguir gracias al método getX del objeto evt. Por último se necesita la posición y. Esta posición se puede conseguir gracias al método getY del objeto evt. Es decir, decidimos mostrar el menú emergente justo en las coordenadas donde se hizo clic.
17. Ejecuta el programa y observa el resultado.
Al hacer clic con el derecho se mostrará el menú contextual. 18. Para hacer que al pulsarse una opción suceda algo, solo hay que activar el método actionPerformed del JMenuItem correspondiente. Por ejemplo, active el actionPerformed del menuRojo y dentro programe lo siguiente: this.getContentPane().setBackground(Color.RED);
19. Ejecuta el programa y comprueba lo que sucede al pulsar la opción Rojo del menú contextual.
CONCLUSIÓN Los menús contextuales son objetos del tipo JPopupMenu. Estos objetos contienen JMenuItem al igual que las opciones de menú normales. Cuando se asigna un JPopupMenu a un formulario, no aparece sobre la ventana, pero sí en el inspector. Para hacer que aparezca el menú emergente, es necesario programar el evento mouseClicked del objeto sobre el que quiera que aparezca el meú. Tendrá que usar el método show del menú emergente para mostrar dicho menú.
EJERCICIO GUIADO. JAVA: FILECHOOSER
Cuadros de diálogo Abrir y Guardar 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: Ventana Abrir fichero:
(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 1. Vamos a practicar con el JFileChooser. Para ello, crea un nuevo proyecto. 2. Añade en el proyecto los siguientes elementos: a. Una barra de menús. Llámala barraMenus. b. Dentro de ella una opción “Archivo” llamada menuArchivo. c. Dentro de la opción “Archivo”, introduce los siguientes elementos: - Una opción “Abrir”, llamada menuAbrir. - Un separador (llámalo como quieras) - Una opción “Salir”, llamada menuSalir. 3. Una vez hecho esto tu formulario tendrá la siguiente forma:
4. Si ejecutas el programa el menú se verá así:
5. Si observas el Inspector, tendrá un aspecto parecido al siguiente:
6. Para que al pulsar la opción “Abrir” de nuestro programa aparezca el diálogo de apertura de ficheros, es necesario añadir a nuestro programa un objeto del tipo JFileChooser. Los objetos JFileChooser se añadirán el la zona de “Otros Componentes” del inspector.
7. Haz clic con el derecho sobre la zona de “otros componentes” y activa la opción Agregar desde Paleta – Swing – JFileChooser:
8. Aparecerá entonces un objeto JFileChooser dentro de Otros Componentes. Aprovecha para cambiarle el nombre a este objeto. Su nombre será elegirFichero. El inspector quedará así:
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) { JOptionPane.showMessageDialog(null,"Se pulsó la opción Cancelar"); }
10. Ejecuta el código y prueba la opción “Abrir” del menú. Prueba a elegir algún fichero y abrirlo. Prueba a cancelar la ventana de apertura. Etc 11. Analicemos el código anterior: 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)
-
El método showOpenDialog no solo muestra la ventana “Abrir Fichero” sino que también devuelve un valor entero según el botón pulsado por el usuario en esta ventana. Esto es: botón “Abrir” o botón “Calcelar”.
-
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) { JOptionPane.showMessageDialog(null,"Se pulsó la opción Cancelar"); }
-
En el primer if se compara la variable resp con la constante JFileChooser.APPROVE_OPTION, para saber si el usuario pulsó “Abrir”.
-
En el segundo if se compara la variable resp con la constante JFileChooser.CANCEL_OPTION, para saber si el usuario pulsó “Calcelar”.
-
En el caso de que el usuario pulsara “Abrir”, el programa usa el método getSelectedFile del objeto elegirFichero para recoger el camino del fichero elegido. Este camino debe ser convertido a cadena con el método toString.
-
El programa aprovecha esto para mostrar dicho camino en pantalla gracias al típico JOptionPane.
-
En el caso del que el usuario pulsara el botón “Cancelar” el programa muestra un mensaje indicándolo.
12. Hay que volver a dejar claro que el cuadro de diálogo “Abrir” realmente no abre ningún fichero, sino que devuelve el camino del fichero elegido usando el código: elegirFichero.getSelectedFile().toString()
Luego queda en manos del programador el trabajar con el fichero correspondiente de la forma que desee.
CONCLUSIÓN Los objetos JFileChooser permiten mostrar el cuadro de diálogo “Abrir Fichero” o “Guardar Fichero”. Estos objetos no abren ni guardan ficheros, solo permiten al usuario elegir el fichero a abrir o guardar de forma sencilla. El JFileChooser devuelve el camino del fichero elegido, y luego el programador trabajará con dicho fichero como mejor le interese.
EJERCICIO GUIADO. JAVA: PANELES DE DESPLAZAMIENTO
Paneles de Desplazamiento Llamaremos paneles de desplazamiento a paneles que contienen elementos tan grandes que no pueden ser mostrados en su totalidad. Estos paneles contienen entonces dos barras de desplazamiento que permiten visualizar el interior del panel de desplazamiento correctamente. Por ejemplo, un panel de desplazamiento podría contener una imagen tan grande que no se viera entera: Los paneles de desplazamiento son objetos del tipo JScrollPane.
Ejercicio guiado 1 1. Vamos a practicar con los JScrollPane. Para ello, crea un nuevo proyecto. 2. Añade en el proyecto un JScrollPane. 3. Un JScrollPane, por sí mismo, no contiene nada. Es necesario añadir dentro de él el objeto que contendrá. Para nuestro ejemplo añadiremos dentro de él una etiqueta (JLabel) 4. El formulario debe tener ahora este aspecto:
5. Si observas el Inspector verás claramente la distribución de los objetos:
Observa como tienes un JScrollPane que contiene una etiqueta.
6. Aprovechemos el Inspector para cambiar el nombre a cada objeto. Al JScrollPane le llamaremos scpImagen y a la etiqueta etiImagen.
7. Elimina el texto contenido en la etiqueta etiImagen. Solo tienes que borrar el contenido de la propiedad text. 8. Luego introduciremos una imagen dentro de la etiqueta, a través de la propiedad icon. La imagen la introduciremos desde fichero, y elegiremos la siguiente imagen de tu disco duro: Mis Documentos / Mis Imágenes / Imágenes de Muestra / Nenúfares.jpg 9. Esta imagen es tan grande que no se podrá ver entera dentro del panel de desplazamiento. Ejecuta el programa y observarás el uso de las barras de desplazamiento dentro del panel.
10. Puedes mejorar el programa si agrandas el panel de desplazamiento de forma que ocupe todo el formulario:
De esta forma, cuando ejecutes el programa, al agrandar la ventana, se agrandará el panel de desplazamiento, viéndose mejor la imagen contenida.
11. Ejecuta el programa y compruébalo.
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.
1. Crea un nuevo proyecto. 2. Añade a la ventana una etiqueta con el texto “Ejemplo 2 de JScrollPane” y un JScrollPane de forma que esté asociado a los límites de la ventana. Observa la imagen:
3. Ahora añade dentro del JScrollPane un panel normal (JPanel). En la ventana no notarás ninguna diferencia, pero en el Inspector debería aparecer esto:
4. Como ves, el JScrollPane contiene a un objeto JPanel. 5. Aprovechemos para cambiar el nombre a ambos objetos. Al JScrollPane lo llamaremos scpDatos y al JPanel lo llamaremos panelDatos.
6. Los JPanel son objetos contenedores. Es decir, pueden contener otros objetos como por ejemplo botones, etiquetas, cuadros de texto, etc. Además, los JPanel pueden ser diseñados independientemente de la ventana. Haz doble clic sobre el panelDatos en el Inspector y observa lo que ocurre:
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: -
Cambia el color de fondo y asígnale un color verde. Añade en él una etiqueta con el texto “Panel de Datos”. Añade varias etiquetas y cuadros de textos correspondientes a los días de la semana. Agranda el panel. El panel debería quedar así. Toma como referencia esta imagen:
Es muy interesante que observes el Inspector. En él podrás observar la distribución de los objetos en la ventana. Podrás ver como el JFrame contiene un JScrollPane (scpDatos) que a su vez contiene un JPanel (panelDatos) que a su vez contiene una serie de etiquetas y cuadros de textos a los que aún no les hemos asignado un nombre:
9. Haz doble clic sobre el JFrame (en el Inspector) para poder ver globalmente la ventana. En la pantalla debería aparecer esto:
Como ves, el JPanel contenido en el JScrollPane es más grande que él, por lo que no se podrá visualizar completamente. Será necesario usar las barras de desplazamiento del JScrollPane. 10. Ejecuta el programa para entender esto último.
CONCLUSIÓN Los objetos JScrollPane son paneles de desplazamiento. Estos paneles pueden contener objetos mayores que el propio panel de desplazamiento. Cuando esto sucede, el panel muestra barras de desplazamiento para poder visualizar todo el contenido del panel. Los JScrollPane son ideales para mostrar imágenes, paneles y otros elementos cuyo tamaño pueda ser mayor que la propia ventana.
EJERCICIO GUIADO. JAVA: VARIABLES GLOBALES
Variables Globales / Propiedades de la Clase Las propiedades de la clase en java es el equivalente a las variables globales en lenguajes estructurados como el C. Una propiedad es una variable que puede ser accedida desde cualquier evento programado. Esta variable se inicializa a un valor cuando se ejecuta el programa y los distintos eventos pueden ir cambiando su valor según se necesite. Veamos un ejemplo para entender el funcionamiento de las propiedades de la clase / variables globales.
Ejercicio guiado 1 1. Crea un nuevo proyecto llamado ProyectoParking. Dentro de él añade un paquete llamado paqueteParking. Y finalmente añade un JFrame llamado Parking. El aspecto de tu proyecto será el siguiente:
Clase Principal
2. Tu clase principal es la clase Parking. 3. Se pretende hacer un pequeño programa que controle los coches que van entrando y van saliendo de un parking. En todo momento el programa debe decir cuantos coches hay dentro del parking. Para ello debes crear una ventana como la que sigue:
4. Esta ventana contiene lo siguiente: -
Un botón “Entró un coche” llamado btnEntro. Un botón “Salió un coche” llamado btnSalio. Un botón “Reiniciar” llamado btnReiniciar. Una etiqueta con el texto “Coches en el Parking”. Una etiqueta con borde llamada etiCoches que contenga un “0”.
5. Se pretende que el programa funcione de la siguiente forma: a. Cuando el usuario pulse el botón “Entró un coche”, el número de coches del parking aumenta en 1, mostrándose en la etiqueta etiCoches. b. Si el usuario pulsa el botón “Salió un coche”, el número de coches del parking disminuye en 1, mostrándose en la etiqueta etiCoches. c. El botón Reiniciar coloca el número de coches del parking a 0.
6. Para poder controlar el número de coches en el Parking, es necesario que nuestra clase principal Parking tenga una propiedad (variable global) a la que llamaremos coches. Esta variable será entera (int). Esta variable contendrá en todo momento los coches que hay actualmente en el Parking. Esta variable podrá ser usada desde cualquier evento. 7. Para crear una variable global haz clic en el botón “Origen” para acceder al código:
8. Luego busca, al comienzo del código una línea que comenzará por public class Seguida del nombre de tu clase principal “Parking”. Debajo de dicha línea es donde se programarán las propiedades de la clase (las variables globales) Aquí se declaran las variables globales, también llamadas propiedades de la clase.
9. En dicho lugar declararás la variable coches de tipo int:
Declaración de una variable global int llamada coches.
10. Cuando el programa arranque, será necesario que la variable global coches tenga un valor inicial. O dicho de otra forma, será necesario inicializar la variable. Para inicializar la variable iremos al constructor. Añade lo siguiente al código:
Inicialización de la propiedad coches.
Inicializamos a cero ya que se supone que cuando arranca el programa no hay ningún coche dentro del parking.
11. Ahora que ya tenemos declarada e inicializada la variable global coches, esta puede ser usada sin problemas desde cualquier evento que programemos. Por ejemplo, empezaremos programando la pulsación del botón “Entró un coche”. Acceda a su evento actionPerformed y programe esto: coches=coches+1; etiCoches.setText(“”+coches);
Como ves, se le añade a la variable coches uno más y luego se coloca su valor actual en la etiqueta. 12. Ejecuta el programa y prueba este botón varias veces.
Pulsas, y aparece aquí el valor de la propiedad coches.
13. Ahora programaremos el botón “Salió un coche” de la siguiente forma:
if (coches>0) { coches=coches-1; etiCoches.setText(“”+coches); }
Como ves, se accede igualmente a la propiedad coches pero esta vez para restarle una unidad. Luego se muestra el valor actual de coches en la etiqueta correspondiente. Se usa un if para controlar que no pueda restarse un coche cuando el parking esté vacío. (Si hay cero coches en el parking no se puede restar uno)
14. Ejecuta el programa y prueba los dos botones. Observa como la cantidad de coches del parking aumenta o disminuye.
Al pulsar aquí aumentas en uno la propiedad coches. Al pulsar aquí disminuyes en uno la propiedad coches.
Lo realmente interesante de esto es que desde dos eventos distintos (desde dos botones) se puede usar la variable coches. Esto es así gracias a que ha sido creada como variable global, o dicho de otro modo, ha sido creada como propiedad de la clase Parking.
15. Finalmente se programará el botón Reiniciar. Este botón, al ser pulsado, debe colocar la propiedad coches a cero. Programa dentro de su actionPerformed lo siguiente: coches=0; etiCoches.setText(“0”);
Simplemente introduzco el valor cero en la variable global y actualizo la etiqueta. 16. Ejecuta el programa y comprueba el funcionamiento de este botón.
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. Las variables globales se declaran justo después de la línea public class. La inicialización de estas variables se realiza en el constructor.
EJERCICIO GUIADO. JAVA: CENTRALIZAR CÓDIGO
El problema de la repetición de código 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:
Esta ventana contiene los siguientes elementos: -
Una barra de menús a la que puede llamar menuBarra. La barra de menús contiene un JMenu con el texto “Calcular” y que se puede llamar menuCalcular El menuCalcular contendrá tres JMenuItem, llamados respectivamente: menuSumar, menuRestar, menuBorrar y con los textos “Sumar”, “Restar” y “Borrar”. Una etiqueta con el texto “Número 1”. (no importa su nombre) Una etiqueta con el texto “Número 2”. (no importa su nombre) Un cuadro de texto con un 0 y con el nombre txtNumero1. Un cuadro de texto con un 0 y con el nombre txtNumero2. Una etiqueta con el nombre etiResultado. Un botón “Sumar” con el nombre btnSumar. Un botón “Restar” con el nombre btnRestar. Un botón “Borrar” con el nombre btnBorrar.
3. Aquí puedes ver la ventana en ejecución con el menú “Calcular” desplegado:
4. El objetivo de programa es el siguiente: a. b. c. d. e. f. g.
El usuario introducirá dos números en los cuadros de texto. Si pulsa el botón Sumar, se calculará la suma. Si pulsa el botón Restar, se calculará la resta. Si pulsa el botón Borrar, se borrarán ambos cuadros de texto. Si elige la opción del menú Calcular-Sumar entonces se calculará la suma. Si elige la opción del menú Calcular-Restar entonces se calculará la resta. Si elige la opción del menú Calcular-Borrar entonces se borrarán ambos cuadros de texto. h. Si se pulsa enter en alguno de los dos cuadros de texto se debería calcular la suma.
5. Este es un ejemplo en el que al activarse uno de varios eventos distintos se tiene que ejecutar el mismo código. Observa el caso de la suma: Pulsar Botón Sumar Activar Calcular – Sumar en el menú
Calcular la suma y mostrarla en la etiqueta de resultado
Pulsar enter en el primer cuadro de texto
Pulsar enter en el segundo cuadro de texto
6. Para que el código esté “centralizado”, es decir, que aparezca solo una vez, será necesario construir en la clase un método. Un método en java es el equivalente de una función o procedimiento en C. Veamos 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 Este es un buen sitio para crear tus propios procedimientos
9. Se va a programar un procedimiento que se encargue de recoger los valores de los cuadros de texto. Calculará la suma de dichos valores, y luego mostrará la suma en la etiqueta de resultados. Los procedimientos en java tienen prácticamente la misma estructura que en C. Programe lo siguiente:
Este es el procedimiento que tienes que introducir en el programa.
10. Si observas el código, es el típico procedimiento de C, cuya cabecera comienza con void y el nombre que le hayas asignado (en nuestro caso Sumar) void Sumar() { .... } Si estudias las líneas del código, verás que lo que hace es recoger el contenido de los dos cuadros de texto en dos variables de cadena llamadas cad1 y cad2. Luego convierte dichas cadenas en números que almacena en dos variables enteras llamadas a y b. Finalmente calcula la suma en una variable s y presenta el resultado en la etiqueta etiResultado. 11. Hay que destacar que este código no pertenece ahora mismo a ningún evento en concreto, por lo que no tiene efecto ninguno sobre el programa. Será necesario pues asociar los eventos correspondientes con este procedimiento. 12. Interesa que al pulsar el botón “Sumar” se ejecute la suma, así pues entre en el evento actionPerformed del botón “Sumar” y añada la siguiente línea: Sumar();
13. Como también interesa que al pulsar la opción del menú “Calcular-Sumar” se ejecute la suma, entre en el evento actionPerformed de la opción del menú “Sumar” y añade de nuevo la siguiente línea: Sumar();
14. También se quiere que al pulsar la tecla enter en el cuadro de texto del número 1 se ejecute la suma. Por lo tanto, en el evento actionPerformed del cuadro de texto txtNumero1 hay que añadir la siguiente línea: 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:
Pulsar Botón Restar Activar Calcular – Restar en el menú
Calcular la resta y 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.
19. El código de este procedimiento es prácticamente idéntico al del procedimiento Sumar, así que no se comentará. 20. Ahora, es necesario que cuando se activen los eventos indicados antes, estos hagan una llamada al procedimiento Restar para que se efectúe la resta. Así pues, entre en el evento actionPerformed del botón “Restar” y añada esta línea de código: Restar(); 21. Igualmente, entre en el evento actionPerformed de la opción del menú “Calcular – Restar” y añada la misma llamada: Restar();
22. Ejecute el programa y compruebe 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();
25. Ejecuta el programa y prueba su funcionamiento.
CONCLUSIÓN En java se pueden programar procedimientos al igual que en C. Normalmente, estos procedimientos se programarán debajo del constructor, y tienen la misma estructura que en C. Se puede llamar a un mismo procedimiento desde distintos eventos, evitando así la repetición de código.
EJERCICIO GUIADO. JAVA: LAYOUTS
El problema de la distribución de elementos en las ventanas Uno de los problemas que más quebraderos de cabeza da al programador es el diseño de las ventanas y la situación de los distintos componentes en ellas. Para diseñar más cómodamente las ventanas, Java proporciona una serie de objetos denominados Layouts, que definen la forma que tendrán los elementos de situarse en las ventanas. Así pues, un Layout define de qué forma se colocarán las etiquetas, botones, cuadros de textos y demás componentes en la ventana que diseñamos.
Ejercicio guiado “Diseño Libre” 1. Crea un nuevo proyecto en java. 2. Añade una etiqueta y un botón. Muévelos a la posición que se indica en la imagen. Deben aparecer las líneas “guía” de color azul que se muestran:
3. Las líneas azules que aparecen indican con qué otro elemento está relacionado un componente de la ventana. La situación de un elemento dependerá siempre de la situación del otro. Dicho de otra forma, las líneas azules indican las distancias que siempre se respetarán. Observa la siguiente imagen:
Tanto el botón como la etiqueta estarán siempre a esta distancia del borde derecho de la ventana…
El botón siempre estará a esta distancia de la etiqueta…
El botón siempre estará a esta distancia del borde inferior de la ventana…
4. Ejecuta el programa y prueba a ensanchar (o achicar) la ventana por el lado derecho y por el lado inferior. Debes observar como la etiqueta y el botón mantienen sus distancias relativas entre sí y con los bordes derecho e inferior de la ventana.
Siempre se mantienen las distancias relativas definidas en el diseño aunque el tamaño de la ventana cambie.
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. Se puede observar como a veces los elementos no se colocan en la posición que deseamos o como cambian de tamaño de forma inesperada. Todo esto es debido a la necesidad de dichos elementos de mantener unas distancias relativas con otros elementos de la ventana. Cuantos más elementos tengamos en una ventana, más difícil será el colocarlos usando el Diseño Libre.
“AboluteLayout. Posiciones Absolutas”
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”. 7. En el Inspector de tu proyecto pulsa el botón derecho del ratón sobre el objeto JFrame y activa la opción Establecer Disposición – AbsoluteLayout.
8. El Inspector tendrá la siguiente forma ahora:
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. 11. Ejecuta el programa y reduce su ancho. Observa lo que ocurre:
Verás que los elementos de la ventana son inamovibles aunque la ventana cambie de tamaño. En cambio, en el Diseño Libre los elementos intentaban siempre estar dentro de la ventana.
“Distribución en línea. FlowLayout” 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.
15. Si seleccionas el FlowLayout en el Inspector, podrás acceder a sus propiedades (los layout son objetos como los demás) Una de las propiedades del FlowLayout se llama alineación y permite que los elementos estén alineados a la izquierda, derecha o centro. El FlowLayout tiene una alineación centro por defecto.
16. El FlowLayout no permite controlar la posición de los elementos en la ventana, pero sí procura que los elementos estén siempre visibles aunque la ventana se cambie de tamaño. Ejecuta el programa y observa el comportamiento del FlowLayout al agrandar o achicar la ventana: En el FlowLayout, los elementos intentan siempre estar dentro de la ventana, aunque esta se cambie de tamaño…
“Distribución en rejilla. GridLayout”
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. 18. Cambia el layout del JFrame por un GridLayout:
19. Marca el GridLayout y cambia sus propiedades Filas y Columnas. Asigna a la propiedad Filas un 2 y a la propiedad Columnas un 3.
20. Al asignar 2 filas y 3 columnas al GridLayout, conseguiremos que los elementos de la ventana se distribuyan en una tabla como la siguiente:
Los distintos elementos se adaptarán al espacio que tienen asignado, y cambiarán de tamaño. 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. Siempre aparecen dentro de la ventana aunque el tamaño de esta cambie.
“BorderLayout”
24. Otra de las distribuciones posibles es la llamada BorderLayout. Esta distribución coloca los elementos de la ventana en cinco zonas: -
Zona norte (parte superior de la ventana) Zona sur (parte inferior de la ventana) Zona este (parte derecha de la ventana) Zona oeste (parte izquierda de la ventana) Zona centro.
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) La ventana tendrá un aspecto parecido al siguiente:
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. El programador no tiene mucho control sobre la disposición de los elementos en la ventana al usar esta distribución.
28. Ejecuta el programa y observa como los elementos siempre se mantienen dentro de la ventana aunque esta cambie de tamaño.
Con un GridLayout los elementos aparecen zonas. Siempre aparecen dentro de la ventana aunque el tamaño de esta cambie.
CONCLUSIÓN El diseño de la ventana viene definido por los Layouts o distribuciones. Diseño Libre – Esta distribución viene activada por defecto en el NetBeans, y define una distribución de componentes en la que se respetan las distancias entre ellos cuando la ventana cambia de tamaño. AbsoluteLayout – En esta distribución el programador puede colocar cada elemento en la posición que desee de la ventana. Los distintos elementos mantienen su posición aunque la ventana cambie de tamaño, lo que puede hacer que si la ventana se reduce de tamaño algunos elementos no se vean. FlowLayout – En esta distribución los elementos se colocan uno detrás de otro. Los elementos intentarán estar dentro de la ventana aunque esta se reduzca de tamaño. GridLayout – Esta distribución coloca a los elementos en filas y columnas. Los elementos siempre estarán dentro de la ventana aunque esta se reduzca de tamaño. BorderLayout – Esta distribución coloca a los elementos en zonas. Los elementos siempre estarán dentro de la ventana aunque esta se reduzca de tamaño.
EJERCICIO GUIADO. JAVA: LAYOUTS Y PANELES
Técnicas de distribución de elementos en las ventanas A la hora de diseñar una ventana se tienen en cuenta dos cosas: -
La facilidad a la hora de colocar muchos componentes en la ventana. Que dichos componentes estén siempre visibles independientemente del tamaño de la ventana.
La distribución AbsoluteLayout por ejemplo nos da mucha facilidad a la hora de colocar los elementos en la ventana, pero sin embargo los componentes no se adaptan a los cambios de tamaño. El Diseño Libre en cambio permite crear ventanas en las que sus componentes se “recolocan” según el tamaño de estas pero a cambio crece la dificultad del diseño. Para aprovechar las ventajas de los distintos layouts y minimizar sus inconvenientes, es habitual en java crear una estructura de paneles cada uno de ellos con un layout distinto, según nuestras necesidades. Normalmente, al JFrame se le asigna un layout que lo divida en zonas, como puede ser el BorderLayout o el GridLayout. Luego, dentro de cada una de estas zonas se introduce un panel (objeto JPanel). Y a cada uno de estos paneles se le asigna el layout que más le convenga al programador (FlowLayout, Diseño Libre, AbsoluteLayout, etc…) Finalmente, dentro de cada panel se añaden los componentes de la ventana. JFrame (BorderLayout o GridLayout)
JPanel 1 (Diseño Libre, AbsoluteLayout o FlowLayout)
Componentes
JPanel 2 (Diseño Libre, AbsoluteLayout o FlowLayout)
Componentes
etc…
Ejercicio guiado
1. Crea un nuevo proyecto en java. Se pretende crear un proyecto con una ventana de diseño complejo. Para ello sigue los siguiente pasos: 2. En primer lugar, asigna un BorderLayout al JFrame:
3. El BorderLayout divide la ventana principal en zonas. Ahora añade un panel (JPanel) a la zona norte de la ventana.
Panel en la zona norte.
4. Cambia el nombre a este panel y llámalo panelTitulo, ya que contendrá el nombre del programa.
5. Añade otro panel, esta vez a la parte central. El panel se llamará panelDatos:
6. Añade un nuevo panel en la parte sur de la ventana. Su nombre será panelEstado.
NOTA. A veces resulta complicado agregar un panel en una zona de la ventana cuando tenemos un BorderLayout. Puedes entonces hacer clic con el derecho sobre JFrame en el Inspector y activar la opción Agregar desde paleta – Swing – JPanel.
7. Si el panel no se coloca en el sitio deseado, se puede seleccionar en el Inspector y activar su propiedad Dirección, e indicar la zona donde se quiere colocar:
El panel debería estar situado finalmente en el sur de la ventana:
8. El Inspector tendrá la siguiente forma ahora:
9. Añade ahora tu solo un panel en la zona oeste llamado panelBotonera y otro en la zona esta llamado panelVerificacion. El Inspector debería tener la siguiente forma al finalizar:
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. 15. Asígnale también un layout AbsoluteLayout. 16. Coloca en él cuatro casillas de verificación. El aspecto del panel al terminar debe ser parecido al siguiente:
Y el Inspector debe tener un estado similar a este:
17. Ahora se diseñará el panelTitulo. Haz doble clic sobre él. 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:
El Inspector tendrá este aspecto en lo que se refiere al panelTitulo...
20. El panelEstado lo diseñaremos sin asignar ningún layout, es decir, usando el Diseño Libre. En él añadiremos tres etiquetas de forma que estas mantengan una distancia relativa con respecto al límite derecho del panel. Dicho de otra forma, que siempre estén pegadas a la parte derecha del panel:
Observa las líneas “guía”. Indican que las etiquetas dependen de la parte derecha del panel. A su vez cada una depende de la otra. Es como si estuvieran “enganchadas”, como los vagones de un tren.
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
25. Ahora añada al panelEtiqueta1 y al panelEtiqueta2 sendas etiquetas. Y al panelCuadro1 y panelCuadro2 sendos cuadros de textos. El panel panelDatos debe quedar así:
26. Finalmente ejecuta el programa y comprueba como se comportan los elementos según el panel donde se encuentre y el layout asignado a cada uno.
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. Dentro de cada una de dichas zonas se añade un JPanel, al que se le asigna un AbsoluteLayout, un FlowLayout o se mantiene el Diseño Libre. Es posible asignar a un panel un layout de zonas, como el GridLayout, y, a su vez, introducir en él nuevos paneles, y así sucesivamente.
EJERCICIO GUIADO. JAVA: DIÁLOGOS
Cuadros de Diálogo Un cuadro de diálogo es un cuadro con opciones que aparece normalmente cuando se activa una opción del menú principal del programa. Los cuadros de diálogo tienen forma de ventana aunque no poseen algunas características de estas. Por ejemplo, no pueden ser minimizados ni maximizados. Los cuadros de diálogo, aparte de las opciones que muestran, suelen contener dos botones típicos: el botón Aceptar y el botón Cancelar. El primero de ellos da por válidas las opciones elegidas y cierra el cuadro de diálogo. El segundo simplemente cierra el cuadro de diálogo sin hacer ninguna modificación. He aquí algunos ejemplos de cuadros de diálogo del programa Word:
Para crear cuadros de diálogo en Java, se usa un tipo de objetos llamado JDialog. Estos objetos pueden ser diseñados como si fueran ventanas, aunque representan realmente cuadros de diálogo.
Ejercicio guiado
1. Crea un nuevo proyecto en java. 2. Diseña el JFrame de forma que la ventana tenga el siguiente aspecto:
Los elementos de la ventana tendrán los siguientes nombres: -
Cuadro de texto de unidades: txtUnidades. Cuadro de texto de precio: txtPrecio. Etiqueta con borde del total: etiTotal. Botón Calcular: btnCalcular. Botón Configuración: btnConfiguracion.
3. Se pretende que cuando se pulse el botón Calcular se calcule el total de la venta (esto se hará luego) Para hacer el cálculo se tendrán en cuenta el IVA y el Descuento a aplicar. Estos dos valores serán variables globales, ya que se usarán en distintos lugares del programa. 4. Así pues entra en el código y declara una variable global iva y otra descuento tal como se indica a continuación (recuerda que las variables globales se colocan justo después de la línea donde se define la clase principal public class):
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
6. Estamos ya preparados para programar el botón btnCalcular. Entra en su actionPerformed y allí se programará la realización del cálculo de la siguiente forma: double double double double double double
unidades; precio; total; //total cantiva; //cantidad iva cantdes; //cantidad descuento totalsiniva; //total sin iva
//Recojo los datos de los cuadros de textos (convirtiendolos a números) unidades = Double.parseDouble(txtUnidades.getText()); precio = Double.parseDouble(txtPrecio.getText()); //Calculo el total sin iva, la cantidad de iva y la cantidad de descuento totalsiniva=precio*unidades; cantiva=totalsiniva*iva/100; cantdes=totalsiniva*descuento/100; //Ahora calculo el precio total: total = totalsiniva+cantiva-cantdes; //Coloco el total en la etiqueta: etiTotal.setText(""+total);
7. Puedes ya ejecutar el programa y comprobar que el botón Calcular funciona, aunque el cálculo que realiza lo hace con un iva 0 y un descuento 0. 8. A continuación se programará el botón Configuración de forma que nos permita decidir qué iva y qué descuento queremos aplicar. Este botón mostrará un CUADRO DE DIÁLOGO que permita al usuario configurar estos datos.
9. Para añadir un cuadro de diálogo al proyecto, se tiene que añadir un objeto del tipo JDialog sobre el JFrame.
10. Los JDialog son objetos ocultos, es decir, objetos que se colocan en la parte del Inspector llamada Otros Componentes, al igual que sucede con los menús contextuales o los JFileChooser. Observa tu inspector, allí verás el JDialog que has añadido:
11. Cámbiale el nombre. Lo llamaremos dialogoConfiguracion. 12. Los diálogos normalmente traen por defecto el layout BorderLayout. Para nuestro ejemplo cambiaremos el layout del JDialog por el Diseño Libre:
13. Los JDialog se pueden diseñar independientemente, al igual que los JPanel. Solo tienes que hacer doble clic sobre el dialogoConfiguracion (en el inspector) y este aparecerá en el centro de la ventana.
14. Así pues debes diseñar el dialogoConfiguracion para que quede de la siguiente forma:
Los elementos del cuadro de diálogo tienen los siguientes nombres: -
El cuadro de texto del Iva: txtIva. El cuadro de texto del Descuento: txtDescuento. El botón Aceptar: btnAceptar. El botón Cancelar: btnCancelar. Si observas el Inspector debe tener el siguiente aspecto:
15. Se ha dicho que cuando se pulse el botón Configuración en la ventana principal, debe aparecer el cuadro de diálogo dialogoConfiguracion, que acabas de diseñar:
Haces clic sobre Configuración y aparece el diálogo
16. Para conseguir esto, debes programar el actionPerformed del botón btnConfiguracion de la siguiente forma: dialogoConfiguracion.setSize(250,200); dialogoConfiguracion.setLocation(100,100); dialogoConfiguracion.setVisible(true);
17. El código anterior hace lo siguiente: -
A través del método setSize se asigna un tamaño de 250 x 200 al cuadro de diálogo. A través del método setLocation se determina que el cuadro de diálogo aparecerá en la posición (100, 100) de la pantalla. A través del método setVisible hacemos que el cuadro de diálogo se muestre.
18. Ejecuta el programa y observa lo que sucede cuando pulsas el botón Configurar. Debería aparecer el cuadro de diálogo en la posición programada y con el tamaño programado:
19. Los botones Aceptar y Cancelar del cuadro de diálogo aún no hacen nada. Así que los programaremos. Empezaremos por el más sencillo, el botón Cancelar. 20. El botón Cancelar de un cuadro de diálogo simplemente cierra dicho cuadro de diálogo. Para ello, debes añadir el siguiente código en el actionPerformed del botón Cancelar del diálogo: dialogoConfiguracion.dispose();
El método dispose se usa para cerrar un cuadro de diálogo. También se puede usar con un JFrame para cerrarlo. 21. Ejecuta el programa de nuevo y comprueba el funcionamiento del botón Cancelar del cuadro de diálogo. 22. Ahora se programará el botón Aceptar. Cuando el usuario pulse este botón, se confirmará el valor del iva y del descuento que haya introducido. Es decir, se traspasarán los valores introducidos en los cuadros de texto txtIva y txtDescuento a las variables globales iva y descuento. Una vez que se haya hecho esto, el cuadro de diálogo se debe cerrar. 23. Este es el código que hace lo anterior. Debe programarlo en el actionPerformed del botón Aceptar: iva = Double.parseDouble(txtIva.getText()); descuento=Double.parseDouble(txtDescuento.getText()); dialogoConfiguracion.dispose();
24. Observe el código. Primero se traspasa los valores de los cuadros de texto a las variables globales y luego se cierra el cuadro de diálogo.
25. Compruebe el funcionamiento del programa de la siguiente forma: a. Ejecute el programa. b. Introduzca 5 unidades y 20 de precio. c. Si pulsa calcular, el total será 100. (No hay ni iva ni descuento al empezar el programa) d. Ahora pulse el botón Configuración, e introduzca un iva del 16. El descuento déjelo a 0. Acepte. e. Ahora vuelva a calcular. Observe como ahora el total es 116, ya que se tiene en cuenta el iva configurado. f. Pruebe a configurar un descuento y vuelva a calcular.
26. Se pretende ahora mejorar un poco el cuadro de diálogo, añadiéndole un título. Seleccione el cuadro de diálogo en el Inspector y luego busque su propiedad title. En ella escriba “Configuración de iva y descuento”. 27. Vuelva a ejecutar el programa. Observe la barra de título del cuadro de diálogo:
28. Ahora se estudiará el concepto de cuadro de diálogo modal y cuadro de diálogo no modal. •
Un cuadro de diálogo no modal. Es aquel que permite activar la ventana desde la que apareció. Los cuadros de diálogo añadidos a un proyecto son por defecto no modales.
29. Ejecuta el programa y prueba a hacer lo siguiente: a. Pulsa el botón Configurar. Aparecerá el cuadro de diálogo. b. Pulsa sobre la ventana.
Pulsa sobre la ventana.
c. Observarás que la ventana se activa, colocándose sobre el cuadro de diálogo.
La ventana se activa colocándose por encima del cuadro de diálogo.
d. Esto es posible gracias a que el cuadro de diálogo es no modal. e. A veces, puede ser interesante que se active la ventana pero que el cuadro de diálogo siga delante de ella. Para conseguir esto, es necesario activar la propiedad del cuadro de diálogo llamada alwaysOnTop. Activa esta propiedad:
f.
Ahora ejecuta el programa de nuevo y haz que se visualice el cuadro de diálogo de configuración. Podrás comprobar que se puede activar la ventana e incluso escribir en sus cuadros de textos, y que el cuadro de diálogo sigue visible:
Se puede activar la ventana trasera, e incluso escribir en ella. Esto es gracias a que el cuadro de diálogo es no modal. Por otro lado, el cuadro de diálogo sigue mostrándose delante de la ventana. Esto es gracias a la propiedad alwaysOnTop
g. Es muy común, cuando tenemos un cuadro de diálogo no modal, usar la propiedad alwaysOnTop, para que siempre aparezca delante de la ventana.
30. Ahora se estudiará el concepto de cuadro de diálogo modal. •
Un cuadro de diálogo modal es aquel que no permite que se active otra ventana hasta que este no se haya cerrado.
31. Para convertir nuestro cuadro de diálogo en modal, será necesario que lo selecciones en el inspector y busques la propiedad modal. Debes activar esta propiedad.
32. Ahora ejecuta el programa comprueba lo siguiente: a. Haz que se visualice el cuadro de diálogo de configuración. b. A continuación intenta activar la ventana haciendo clic sobre ella. Verás como no es posible activarla. Es más, intenta escribir en sus cuadros de texto. No será posible hacerlo. (Incluso observarás un parpadeo en el cuadro de diálogo avisándote de ello). Esto es debido a que ahora nuestro cuadro de diálogo es modal.
Aunque intentes activar la ventana o escribir en ella, no podrás, ya que el cuadro de diálogo es modal. Incluso verás un parpadeo en el cuadro de diálogo cuando intentas activar la otra ventana. Se podría decir que un cuadro de diálogo modal es un acaparador, y que no te deja usar otro elemento hasta que no acabes con él. Solo cuando cierres el cuadro de diálogo podrás seguir trabajando con la ventana.
c. Solo cuando pulses, Aceptar, o Cancelar, o cierres el cuadro de diálogo, podrás seguir trabajando con tu ventana.
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. Para cerrar un JDialog será necesario invocar a su método dispose. Existen dos tipos de cuadros de diálogo: los modales y no modales. Los cuadros de diálogo modales no permiten que se active otra ventana hasta que el cuadro de diálogo no se haya cerrado. Los cuadros de diálogo no modales permiten trabajar con otra ventana a pesar de que el propio cuadro de diálogo no haya sido cerrado.
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. Un buen ejercicio para comprobar esto puede ser el siguiente: Ejercicio guiado 1. 1. Crea un proyecto y añade en su ventana un botón (JButton), una etiqueta (JLabel) y un cuadro de texto (JTextField). 2. El nombre del botón será “btnBoton”, el de la etiqueta “etiEtiqueta” y el del cuadro de texto “txtCuadroTexto”. 3. A continuación asigna un texto a cada elemento. La ventana final podría tener un aspecto como el que sigue:
4. Todas estas operaciones que has realizado tienen asociado unas instrucciones de código que se han generado automáticamente. Para estudiar estas instrucciones, activa el botón Origen en la parte superior de la pantalla:
5. En el código, observarás una línea llamada Código Generado. Esta línea está señalada en color azul (al igual que todas las instrucciones generadas automáticamente) Observarás que tiene un + en la parte izquierda. Si haces clic sobre el signo + aparecerá el código generado automáticamente:
Haz clic en el + para ver el código generado.
6. El código generado (señalado en azul) no puede ser modificado, sin embargo es interesante estudiarlo para entenderlo. En él puedes encontrar como se crean los componentes, como se asigna el texto a éstos etc. Aquí se crea el botón, la etiqueta y el cuadro de texto…
Aquí se asigna el texto a cada elemento…
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 A. CREACIÓN DEL PROYECTO 1. Crear un nuevo proyecto con las siguientes características: a. El nombre del proyecto será OPERACIONES. b. El nombre del paquete será VENTANAS. c. El nombre del formulario será VENTANAPRINCIPAL. El aspecto que tendrá la ventana de proyectos debe ser el siguiente: Nombre del proyecto. Nombre del paquete. Nombre del formulario.
2. Una vez creado el proyecto, iremos directamente a la ventana de código, pulsando el botón Origen. No usaremos la ventana de diseño en este proyecto.
B. ESTRUCTURA DEL CÓDIGO (estructura de una clase)
3. Analizaremos el código del programa ahora. Empezaremos por arriba: En la parte superior del código verás un comentario. En este comentario aparece el nombre del fichero que contiene el código, que como puedes observar tiene el mismo que el del JFrame. También aparece la fecha de creación del fichero.
Observarás también una instrucción que indica que este fichero (ventanaprincipal.java) pertenece al paquete ventanas.
También verás otro comentario donde aparece el nombre del autor. Este comentario se puede cambiar para que aparezca tu nombre.
4. Un proyecto en java está formado por módulos denominados CLASES. El proyecto que acabamos de crear tiene un solo módulo: el JFrame que define la ventana principal, llamado precisamente ventanaprincipal. Por tanto, se puede decir que nuestro proyecto tiene una clase llamada ventanaprincipal.
El proyecto operaciones tiene una clase llamada ventanaprincipal, que pertenece al paquete ventanas.
5. Para programar una clase se sigue la siguiente sintaxis: public class nombredelaclase { …programación de la clase… }
6. Esto lo puedes observar claramente en el código de tu proyecto:
Programación de la clase ventanaprincipal
7. Dentro de la clase, tenemos una serie de funciones y procedimientos llamados MÉTODOS. Es en los métodos donde se programan los eventos que pueden suceder sobre el formulario. 8. Hay un método especial muy importante denominado CONSTRUCTOR. Dentro de este método se programa el diseño de la ventana y las características iniciales de la ventana. El constructor se puede distinguir fácilmente porque tiene el mismo nombre que la clase. En nuestro ejemplo, ventanaprincipal.
Observarás que el constructor contiene una llamada a un método llamado initComponents. El método initComponents define características iniciales de la ventana, y es código generado automáticamente. Si quieres verlo, solo tienes que desplegar la parte de Código Generado:
Clic aquí para ocultar el código generado
El método initComponents al que hace referencia el constructor es un método generado automáticamente, y no puede ser modificado. Puedes verlo dentro de la sección de Código Generado. Este método define algunas características iniciales de la ventana.
El contenido del método initComponents no resulta interesante para el ejercicio que estamos realizando, así que puedes ocultar de nuevo el Código Generado, haciendo clic en el símbolo menos -
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í. La tarea que desempeña este método es la de generar la ventana principal y mostrarla en pantalla. El método main, es similar a la función main del lenguaje C. En el caso del java, el NetBeans genera automáticamente el método main, de forma que no tendremos que hacer cambios en él.
C. DISEÑO DE LA VENTANA DESDE CÓDIGO
Vamos ahora a diseñar la ventana de nuestro programa (sin usar la ventana de diseño, solo a partir de código). Al final de esta explicación, la ventana del proyecto tendrá el siguiente aspecto:
Para conseguir esto, sigue los siguientes pasos:
10. Para realizar el diseño de la ventana, crearemos un método propio al que llamaremos por ejemplo CreacionVentana. Un buen sitio para colocar este método puede ser debajo del constructor:
El método donde diseñaremos nuestra ventana…
11. Lo primero que se va a hacer es definir características propias de la ventana, como por ejemplo su título, tamaño, etc. Recuerda que la forma de hacer referencia a la propia ventana es a través de la palabra reservada this. Así pues, programa lo siguiente dentro del método CreacionVentana:
Este código hace lo siguiente: -
Usa el método setTitle de la ventana para definir el texto de la barra de título. Usa el método setSize de la ventana para definir un tamaño de 500x300. Usa el método setLocation de la ventana para definir la posición de la ventana en la posición (100,100) de la pantalla.
Con setLocation decides la posición de la ventana…
Con setTitle cambias la barra de título…
Con setSize defines el ancho y alto de la 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:
13. Ya puedes ejecutar el programa. En el momento en que se ejecuta el programa, el constructor llama al método CreacionVentana y se definen las características programadas.
14. Ahora vamos a empezar a añadir componentes a la ventana. Concretamente, empezaremos creando la etiqueta que contiene el texto “Número 1:” y luego definiremos algunas características propias para finalmente situarla en la ventana. 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:
Importación de la librería para el objeto JLabel, que define las etiquetas. (Agregada automáticamente al pulsar la bombilla del NetBeans)
17. Ahora agrega este código a tu método CreacionVentana:
18. La explicación del código es la siguiente: -
La primera línea construye la etiqueta llamada etiNum1 que fue delarada antes. etiNum1 = new JLabel();
-
Generalizando: para crear un objeto llamado xxx del tipo tipoobjeto, se tendrá que hacer lo siguiente:
o
En la zona de las variables globales se declarará la variable del objeto de la siguiente forma: tipoobjeto xxx;
o
Luego, dentro de la clase, se construye el objeto siguiendo la siguiente sintaxis: xxx = new tipoobjeto();
-
En el ejemplo, la etiqueta creada, cuyo nombre es etiNum1, tiene que contener el texto “Número 1:”. Esto lo hacemos con el típico método setText: etiNum1.setText(“Número 1: “);
-
Hay que definir la posición que tendrá el objeto y el tamaño. Para ello, se usará el método setBounds. Este método recibe la posición (x, y) del objeto y el ancho y el alto. En el ejemplo, la etiqueta está situada en la posición (10,10) de la ventana y tiene un ancho de 100 y un alto de 20: etiNum1.setBounds(10,10,100,20);
-
Finalmente, hay que colocar la etiqueta en el panel de contenidos de la ventana. Para ello, se usa el método add del panel de contenidos. Recuerda que para obtener este panel se usa el método getContentPane: this.getContentPane().add(etiNum1);
19. Es buena idea que ejecutes el programa para ver el aspecto de la ventana ahora.
20. Hemos añadido una etiqueta. Ahora añadiremos la siguiente. Para ello, primero tienes que declarar la etiqueta en la zona de las variables globales:
21. Luego, en el método ConstruirVentana, añadiremos el siguiente código:
22. Este código es prácticamente igual al anterior. En él se constuye la etiqueta declarada antes con el nombre etiNum2. Luego se le asigna el texto “Número 2:”, luego se usa el método setBounds para situarla en la posición (10, 60) y asignarle un ancho de 100 y un alto de 20. Finalmente se añade la etiqueta al panel de contenidos de la ventana. 23. Ejecuta el programa y observa el aspecto de la ventana ahora:
24. Sigamos añadiendo elementos. Ahora añadiremos un cuadro de texto llamado txtNum1. Primero declara la variable del cuadro de diálogo en la zona de variables globales:
Tendrás que agregar el import correspondiente para el tipo de objeto JTextField. 25. Luego añade el siguiente código en el método CreacionVentana:
26. Este código realiza lo siguiente: -
La primera línea construye el cuadro de texto llamado txtNum1. Los JTextField son objetos del tipo cuadro de texto.
-
Esta línea se subrayará en rojo ya que será necesario añadir el import para la librería de los JTextField.
-
La siguiente línea introduce la cadena “0” dentro del cuadro de texto.
-
La siguiente línea asigna la posición y el tamaño a través del método setBounds.
-
Y finalmente, la última línea añade el cuadro de texto al panel de contenidos de la ventana.
27. Ejecuta el programa y comprueba el funcionamiento de este código. 28. Ahora se añadirá un nuevo cuadro de texto llamado txtNum2. El código es similar. Declara la variable global:
29. Y ahora añade el código que construye el objeto en el método ConstruirVentana. Este código es similar al del cuadro de texto anterior. Solo cambia el nombre del objeto y la posición donde se colocará:
30. Ejecuta el programa y comprueba como va el diseño de la ventana:
31. Ahora le toca el turno a los botones. Primero declararemos una variable del tipo JButton en la zona de variables globales (será necesario añadir el import correspondiente a la clase JButton a través de la bombilla). El botón se llamará btnSumar:
32. Y a continuación construiremos y le daremos forma al botón, añadiendo el siguiente código en el método ConstruirVentana:
33. La explicación del código anterior es similar a los anteriores: -
La primera línea construye el botón btnSumar. A continuación se asigna el texto “Sumar” al botón. Luego se asigna la posición y el tamaño del botón con el método setBounds. Finalmente se añade el botón al panel de contenido de la ventana.
34. Ejecuta el programa y observa el aspecto de la ventana. 35. Ahora se añadirá otro botón llamado btnRestar. Declara la variable JButton:
36. Tienes que escribir el siguiente código:
37. El código es prácticamente igual que el del primer botón. Solo cambia el nombre del botón, el texto y la posición y tamaño del botón. 38. Ejecuta el programa para ver como queda la ventana.
CONCLUSIÓN La ventana de diseño de NetBeans es una herramienta que nos permite diseñar las ventanas sin tener que programar código. Es posible prescindir de la ventana de diseño y realizar todo el diseño de la ventana programando. El diseño de la ventana se tiene que hacer en el constructor de la clase. Los componentes de una ventana son variables globales cuyo tipo se corresponde a distintas clases de objetos: JLabel, JTextField, JButton, etc... Para construir un objeto hay que declararlo como una variable global: TipoObjeto NombreObjeto; Y luego, dentro de la clase, construirlo, usando la siguiente sintaxis: NombreObjeto = new TipoObjeto(); Luego se pueden usar distintos métodos del objeto para trabajar con él.
EJERCICIO GUIADO. JAVA: EVENTOS DESDE CÓDIGO
Eventos desde código La ventana de diseño de NetBeans nos permite crear cada componente, colocarlo en la ventana y acceder a los eventos que necesitemos fácilmente para programar en ellos las acciones que se tengan que realizar. Sin embargo, si el diseño de la ventana se ha realizado directamente desde código, será necesario crear también desde código los distintos eventos a usar, y asociarlos al componente correspondiente. Para programar eventos hay que tener en cuenta lo siguiente: -
Un evento pertenece a un objeto “Oyente” (Listener) o a un objeto “Adaptador” (Adapter)
-
El objeto oyente/adaptador hay que asociarlo al elemento sobre el que sucede el evento.
Por ejemplo: Programar la pulsación de un botón btnSumar. La pulsación de un botón es un evento actionPerformed como ya se sabe. El evento actionPerformed pertenece a un objeto llamado ActionListener. El objeto ActionListener es lo que se denomina un oyente. El objeto ActionListener se asociará al botón btnSumar
Programación de eventos La programación de eventos es compleja, ya que cada evento pertenece a un oyente/adaptador, y a su vez, hay que asociar cada oyente/adaptador al componente que responde al evento. Por otro lado, la sintaxis de programación para los eventos es distinta a lo que se ha visto hasta ahora, por lo que puede resultar bastante oscura, aunque por otro lado, siempre sigue el mismo patrón. Para simplificar el estudio de la programación de eventos, nos limitaremos a los eventos más usados, los cuales pueden clasificarse en los siguientes grupos: -
Eventos de Acción: o
-
actionPerformed Activar un componente (pulsación de botón, enter en un cuadro de texto)
Eventos de Teclado: o
keyPressed Se pulsó una tecla, pero no se soltó.
o o
keyReleased Se soltó una tecla. 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 o o o
windowOpened Se abrió la ventana windowClosing Se cerró la ventana windowActivated Se activó la ventana windowDeactivated Se desactivó la ventana
En esta explicación guiada nos limitaremos a estudiar los eventos de acción.
PROGRAMACIÓN DE EVENTOS DE ACCIÓN Un evento de acción hace referencia a la activación de un objeto (un botón, un cuadro de texto, un combo, etc...) Solo existe un tipo de evento de acción, llamado actionPerformed. El evento actionPerformed pertenece a un objeto oyente llamado ActionListener. Eventos de Acción Eventos
Oyente/Adaptador Se programan dentro de...
actionPerformed
ActionListener
La forma de programar el evento actionPerformed de un componente xxx es la siguiente: xxx.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { xxxActionPerformed(evt); } }); Para entender la sintaxis de la programación de un evento de acción, supongamos el siguiente ejemplo:
Se quiere programar el evento de un botón llamado btnSumar desde código. He aquí el código para crear el evento:
btnSumar.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { btnSumarActionPerformed(evt); } });
Una explicación del código: El componente cuyo evento se quiere programar. En este ejemplo, el botón btnSumar
El método addActionListener permite asignar el oyente al botón.
El evento actionPerformed pertenece a un objeto oyente llamado ActionListener.
btnSumar.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { btnSumarActionPerformed(evt); } }); El evento actionPerformed, es en Dentro del procedimiento actionPerformed se hace una llamada a otro procedimiento. El nombre de este otro procedimiento puede ser cualquiera, pero usaremos el nombre del componente seguido de “ActionPerformed”
realidad un procedimiento, que tiene como parámetro un objeto del tipo ActionEvent al que llamaremos evt por convención.
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: public void btnSumarActionPerformed(ActionEvent evt) { … aquí se programa el evento actionPerformed del botón btnSumar … }
A pesar de lo complicado que resulta, hay que tener en cuenta que siempre se programa de la misma forma. Solo hay que cambiar el componente que se quiere programar y asignar un nombre a la función donde se programará el evento. Hay que tener en cuenta que en el código expuesto antes participan nuevas clases como son ActionEvent y ActionListener, y se tendrán que agregar los import correspondientes.
EJERCICIO GUIADO 1. Abra el proyecto Operaciones que se hizo en el ejercicio guiado de la hoja anterior. 2. En el ejercicio guiado anterior se diseñó desde código la ventana de dicho proyecto. Esta ventana tiene el siguiente aspecto (Se indica también el nombre de los distintos componentes):
txtNum1 y txtNum2 son los cuadros de texto.
btnSumar es el botón Sumar
btnRestar es el botón Restar
3. El objetivo del ejercicio es programar la pulsación del botón btnSumar para que aparezca un JOptionPane con la suma calculada. Luego haremos lo mismo con el botón btnRestar. Todo esto se hará desde código.
4. Para recordar, he aquí el código programado hasta ahora. Tenemos una llamada desde el constructor a un método CreacionVentana donde diseñamos cada uno de los elementos de la ventana: /** Creates new form ventanaprincipal */ public ventanaprincipal() { initComponents(); CreacionVentana(); }
En el constructor hacemos una llamada a nuestro método CreacionVentana
public void CreacionVentana() { this.setTitle("Programa Operaciones"); this.setSize(500,300); this.setLocation(100,100);
Programamos algunos detalles de la ventana principal…
etiNum1 = new JLabel(); etiNum1.setText("Número 1:"); etiNum1.setBounds(10,10,100,20); this.getContentPane().add(etiNum1);
Creamos la etiqueta “Número 1”…
etiNum2 = new JLabel(); etiNum2.setText("Número 2:"); etiNum2.setBounds(10,60,100,20); this.getContentPane().add(etiNum2);
Creamos la etiqueta “Número 2”…
txtNum1 = new JTextField(); txtNum1.setText("0"); txtNum1.setBounds(110,10,100,20); this.getContentPane().add(txtNum1);
Creamos el primer cuadro de texto…
txtNum2 = new JTextField(); txtNum2.setText("0"); txtNum2.setBounds(110,60,100,20); this.getContentPane().add(txtNum2); btnSumar = new JButton(); btnSumar.setText("Sumar"); btnSumar.setBounds(10,120,100,20); this.getContentPane().add(btnSumar); btnRestar = new JButton(); btnRestar.setText("Restar"); btnRestar.setBounds(150,120,100,20); this.getContentPane().add(btnRestar);
Creamos el segundo…
Creamos el botón Sumar…
Creamos el botón Restar…
}
5. Ahora asignaremos un evento actionPerformed al botón btnSumar. Esto lo haremos al final del método CreacionVentana, El código que debe añadir para el evento actionPerformed del botón btnSumar es el siguiente:
btnSumar.addActionListener(new ActionListener() { 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. 7. Ahora que se ha definido un evento actionPerformed para el botón btnSumar, será necesario programarlo. Esto se hace creando el procedimiento al que llama el código del actionPerformed. A este procedimiento le hemos dado de nombre btnSumarActionPerformed. Así pues, añade el siguiente procedimiento a la clase. (No te vayas a equivocar, el siguiente código está fuera del método CreacionVentana)
Este es el final del método CreacionVentana …
Hay que programar el método al que llama el evento…
Este es el código que tienes que añadir
8. Es precisamente en este nuevo procedimiento que hemos creado donde se programa el evento actionPerformed del botón btnSumar. Lo que se pretende que haga el programa es que aparezca un JOptionPane con la suma de los números introducidos. Para ello, añade el siguiente código:
Programa el código de lo que tiene que hacer el evento.
9. Bien, hemos programado la pulsación del botón Sumar. Hemos seguido dos pasos: a. Primero hemos creado el evento actionPerformed y se lo hemos asignado al botón. Esto lo hemos hecho dentro del método CreacionVentana. Este evento hace una llamada al procedimiento donde se programará la respuesta al evento. b. Luego hemos creado ese procedimiento y hemos programado en él el código correspondiente a la pulsación del botón. Ejecuta el programa y comprueba el funcionamiento del botón Sumar.
10. Ahora programaremos el botón btnRestar. Primero se tendrá que definir el evento actionPerformed y asignárselo al botón. Esto se hace añadiendo el código de creación del evento al final del método CreacionVentana. 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)
11. Y ahora, hay que programar el procedimiento al que llama el evento actionPerformed. Es aquí donde se programa la respuesta al evento. En nuestro ejemplo, queremos que al pulsar el botón Restar se resten los números introducidos.
public void btnRestarActionPerformed(ActionEvent evt) { double a,b,r; a=Double.parseDouble(txtNum1.getText()); b=Double.parseDouble(txtNum2.getText()); r=a-b; JOptionPane.showMessageDialog(null,"La resta es "+r); }
12. Ejecuta el programa y comprueba el funcionamiento del botón Restar. 13. Resumiendo una vez más. Para programar un evento sobre un componente, primero hay que enlazar el oyente del evento con el componente, y luego programar el método al que llama el evento. Observa el código que hemos programado: Asignación de un actionPerformed al botón btnSumar. (Se hace una llamada al método btnSumarActionPerformed)
Asignación de un actionPerformed al botón btnRestar. (Se hace una llamada al método btnRestarActionPerformed)
Programación del método btnSumarActionPerformed (respuesta a la pulsación del botón btnSumar)
Programación del método btnRestarActionPerformed (respuesta a la pulsación del botón btnRestar)
CONCLUSIÓN Cada evento pertenece a un objeto oyente, y es el oyente el que se asigna al componente de la ventana que se quiere programar. El evento actionPerformed pertenece al oyente ActionListener. Para enlazar el oyente ActionListener a un componente XXX hay que usar el siguiente código: XXX.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) { XXXActionPerformed(evt); } }); El enlace de un evento a un componente se hace en el constructor. Esta asignación hace una llamada a un procedimiento XXXActionPerformed, (donde XXX representa el nombre del componente que se programa) Es en este procedimiento donde realmente se programa el evento.
EJERCICIO GUIADO. JAVA: EVENTOS DESDE CÓDIGO. EVENTOS DE RATÓN
Eventos desde código Se estudió en la hoja de teoría anterior la forma de programar eventos desde código. Concretamente se estudió como programar eventos de acción. En esta hoja se estudiará como programar eventos de ratón. Los eventos de ratón son los siguientes: -
mouseEntered 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. Cada evento a su vez hace una llamada a un procedimiento, y es en este procedimiento donde realmente se programa la respuesta al evento. Todo esto resulta complicado al principio, pero verás que en realidad siempre es igual. Solo hay que conocer el nombre de cada evento, el adaptador u oyente al que pertenece y el tipo de parámetro que recibe cada evento.
Como enlazar eventos de ratón con un componente Supongamos que tenemos un componente (botón, etiqueta, etc...) llamado XXX. Si queremos asociarle eventos de ratón, tendremos que añadir el siguiente código dentro del constructor: XXX.addMouseListener(new MouseAdapter() { public void mouseEntered(MouseEvent evt) { XXXMouseEntered(evt); } public void mouseExited(MouseEvent evt) { XXXMouseExited(evt); } public void mousePressed(MouseEvent evt) { XXXMousePressed(evt); } public void mouseReleased(MouseEvent evt) { XXXMouseReleased(evt); } public void mouseClicked(MouseEvent evt) { XXXMouseClicked(evt); } });
Veamos este mismo código comentado: Para asignar el adaptador al elemento XXX se usa el método addMouseListener
Los eventos de ratón pertenecen al adaptador llamado MouseAdapter
XXX.addMouseListener(new MouseAdapter() { public void mouseEntered(MouseEvent evt) { XXXMouseEntered(evt); } public void mouseExited(MouseEvent evt) { XXXMouseExited(evt); } public void mousePressed(MouseEvent evt) { XXXMousePressed(evt); } public void mouseReleased(MouseEvent evt) { XXXMouseReleased(evt); }
Estos son los eventos de ratón que pertenecen al adaptador MouseAdapter. En realidad no hay que ponerlos todos, solo hay que añadir los que necesites.
public void mouseClicked(MouseEvent evt) { XXXMouseClicked(evt); } }); Cada evento hace una llamada a un procedimiento, cuyo nombre puede ser cualquiera, aunque suele construirse uniendo el nombre del componente XXX junto con el nombre del evento. Es luego en estos procedimientos donde se programa la respuesta a cada evento.
Cada evento recibe como parámetro un objeto del tipo MouseEvent al que por convención se le suele llamar evt. Este objeto suele contener información sobre la pulsación del ratón (qué botón se ha pulsado, cuantas veces, etc...)
EJERCICIO GUIADO 1. Crea un nuevo proyecto. 2. Accede al código del proyecto.
3. Inserta una llamada dentro del constructor a un procedimiento CreacionVentana de la siguiente forma: La llamada...
Y el procedimiento.
4. La ventana va a contener dos etiquetas, que tendremos que declarar en la zona de variables globales:
5. Ahora vamos a diseñar la ventana. Introduce el siguiente código dentro del procedimiento CreacionVentana:
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:
7. El objetivo del programa es simple. Queremos que al entrar el ratón dentro de la superficie de la etiqueta roja, aparezca un mensaje en la otra etiqueta indicándolo. También queremos que aparezca un mensaje al salir el ratón de la etiqueta. Y también al pulsar un botón del ratón sobre la etiqueta. 8. Para hacer esto, necesitamos crear un MouseAdapter que contenga los siguientes eventos: mouseEntered, mouseExited y mousePressed. Observa que no es necesario que contenga el mouseReleased ni el mouseClicked. Luego, el MouseAdapter se asignará a la etiqueta roja etiZona. 9. Primero programaremos el enlace del adaptador MouseAdapter con la etiqueta etiZona. Programa al final del método CreacionVentana lo siguiente:
10. Observa el código: a. Se añade un MouseAdapter al objeto etiZona. b. El MouseAdapter que se añade solo contiene los tres eventos que necesitamos: mouseEntered, mouseExited y mousePressed. c. Será necesario añadir imports para las clases MouseAdapter y MouseEvent. d. Es normal que las llamadas a los procedimientos de cada evento den error ya que todavía no han sido programadas. 11. Ahora se programará cada procedimiento que es llamado desde cada evento. Recuerda que esto debe hacerse fuera del método CreaciónVentana. Aquí tienes lo que debes programar: (Llave del método CreacionVentana)
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. Cambia el procedimiento etiZonaMousePressed y déjalo de la siguiente forma:
14. En el código anterior aprovechamos los métodos que tiene el objeto MouseEvent para averiguar que botón se ha pulsado. Usamos el método getButton que nos dice el botón pulsado. Aprovechamos las constantes de la clase MouseEvent para saber si se pulsó el botón izquierdo, central o derecho. 15. Ejecuta el programa y comprueba el funcionamiento.
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() { public void mouseEntered(MouseEvent evt) { XXXMouseEvent(evt); } ... otros eventos de ratón... }); Ten en cuenta que solo añades al adaptador aquellos eventos que necesites. Cada evento de ratón lleva como parámetro un objeto evt del tipo MouseEvent que contiene información sobre el evento: qué botón del ratón se pulsó, cuantas veces, etc.
EJERCICIO GUIADO. JAVA: EVENTOS DESDE CÓDIGO. IDEAS GENERALES
Eventos desde código. Consideraciones Generales Se finalizará el estudio de los eventos desde código, planteando de forma general el código necesario para programarlos. A la hora de programar eventos sobre un componente concreto, será necesario tener en cuenta lo siguiente: -
Primero hay que enlazar el componente con el oyente o adaptador correspondiente al evento.
-
El oyente o adaptador contendrá aquellos eventos que interesen programar.
-
Cada evento tiene un parámetro asociado con información sobre el evento.
-
Cada evento realiza una llamada a un procedimiento y es en este procedimiento donde se programa la respuesta al evento.
La sintaxis general de programación de eventos es la siguiente:
Componente.MetodoParaAñadirOyente(new TipoOyente() { public void evento1(TipoEvento evt) { LlamadaAProcedimiento1(evt); } public void evento2(TipoEvento evt) { LlamadaAProcedimiento2(evt); } ...otros eventos... });
Para poder programar un evento es necesario conocer lo siguiente: -
El componente sobre el que se programará. El tipo oyente o adaptador al que pertenece el evento. El método usado para asignar el oyente al componente. El nombre del evento. El tipo de evento para el parámetro.
Ejemplo 1. Eventos del Ratón Los eventos de ratón son: mouseEntered, mouseExited, mousePressed, mouseReleased, mouseClicked. Pertenecen al adaptador MouseAdapter. El adaptador se asigna al componente con el método addMouseListener. Los métodos llevan como parámetro un objeto del tipo MouseEvent. Conociendo esto, si queremos programar los eventos del ratón de una etiqueta llamada etiTexto, solo tenemos que hacer lo siguiente:
etiTexto.addMouseListener(new MouseAdapter() { public void mouseEntered(MouseEvent evt) { etiTextoMouseEntered(evt); } public void mouseExited(MouseEvent evt) { etiTextoMouseExited(evt); } public void mousePressed(MouseEvent evt) { etiTextoMousePressed(evt); } public void mouseReleased(MouseEvent evt) { etiTextoMouseReleased(evt); } public void mouseClicked(MouseEvent evt) { etiTextoMouseClicked(evt); } });
Ejemplo 2. Eventos del teclado Los eventos de teclado controlan las pulsaciones de tecla. Entre ellos, podemos mencionar a los siguientes: -
keyPressed, que define la pulsación de una tecla. keyReleased, que define el momento en que se suelta una tecla. keyTyped, que define el pulsar-soltar una tecla.
Los eventos de teclado pertenecen al adaptador KeyAdapter. El adaptador anterior se asigna a un componente a través del método addKeyListener. Los eventos de teclado llevan como parámetro un objeto del tipo KeyEvent.
Sabiendo lo anterior, si se quisieran programar los eventos de teclado de un cuadro de texto llamado txtDato el código necesario sería el siguiente: txtDato.addKeyListener(new KeyAdapter() { public void keyPressed(KeyEvent evt) { txtDatoKeyPressed(evt); } public void keyReleased(KeyEvent evt) { txtDatoKeyReleased(evt); } public void keyTyped(KeyEvent evt) { txtDatoKeyTyped(evt); } });
Como puedes observar, la programación de eventos siempre se hace de la misma forma, solo tienes que conocer el adaptador/oyente, el método para asignar dicho adaptador/oyente, el nombre de los eventos, y el tipo de objeto que llevan como parámetro. Sabiendo estos datos, la programación siempre se hace igual. El problema que se plantea en cambio es el siguiente: Si surge un nuevo evento 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 Para programar desde código un evento es necesario conocer lo siguiente: * El nombre del evento / eventos del mismo grupo. * El oyente/adaptador al que pertenece el evento / eventos. * El método para asignar el oyente/adaptador al componente sobre el que actúa el evento. * El tipo de datos de objeto recibido como parámetro por el evento. Conociendo estos datos, la programación siempre se hace igual: Componente.MetodoParaAñadirOyente(new NombreOyenteAdaptador() { public void nombreEvento1(TipoDatoParametro evt) { LlamadaAProcedimientoEvento1(evt); } public void nombreEvento2(TipoDatoParametro evt) { LlamadaAProcedimientoEvento2(evt); } });
Se puede aprender mucho sobre los eventos asociándolos desde diseño y luego mirando en el código generado.
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 Para declarar un vector se seguirá la siguiente sintaxis: tipodatos
-
nombrevector[];
tipodatos es el tipo de datos de los elementos del vector (int, double, String, etc.) nombrevector es el nombre que tu quieras darle a tu vector.
Por ejemplo, supongamos que queremos crear un vector de enteros llamado v. La declaración será la siguiente: int v[];
Como puedes ver, en la declaración de un vector no se indica la dimensión, de éste, es decir, el número de elementos que tiene. Esto se hace en la construcción del vector.
Construcción de un vector Para construir un vector que ya haya sido declarado se sigue la siguiente sintaxis: nombrevector = new tipodatos[dim];
-
nombrevector es el nombre del vector a construir. tipodatos es el tipo de datos del vector. dim es la dimensión del vector (el número de elementos)
Por ejemplo, si queremos que el vector v declarado antes tenga 10 elementos, tendremos que hacer lo siguiente: v = int[10]; En el momento de la construcción del vector, podemos usar una variable entera para asignar el número de elementos que se quiera. Por ejemplo, en el siguiente caso el número de elementos del vector v viene dado por la variable num: v = int[num];
Acceso a los elementos de un vector Una vez declarado el vector y construido, este se puede usar de la misma manera que en C. Se puede acceder a un elemento del vector escribiendo el nombre del vector y entre corchetes el índice del elemento que quieres usar. Recuerda que los índices comienzan a numerarse en 0. Ejemplo 1: etiResultado.setText(“El resultado es: “+v[3]);
Aquí se coloca en una etiqueta el valor contenido en el elemento de la posición cuarta del vector v. Ejemplo 2: for (i=0;i<10;i++) { v[i]=0; }
Este código recorre un vector de 10 elementos y almacena en dichos 10 elementos un 0.
Longitud de un vector Una forma rápida de saber la longitud que tiene un vector es usar lo siguiente: nombrevector.length 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
Creación de un vector e inicialización con datos al mismo tiempo Es posible crear un vector e introducir datos directamente en él al mismo tiempo. La forma general de hacerlo sería la siguiente: tipodatos nombrevector[] = {elemento1, elemento2, elemento3, …, elemento n};
Por ejemplo: int v[] = {5, 2, 7, 6};
Este código crea un vector con cuatro números enteros: 5, 2, 7, 6. Ejemplo 2: String dias[] = {“Lunes”, “Martes”, “Miércoles”, “Jueves”, “Viernes”, “Sábado”, “Domingo”};
Este código crea un vector que contiene 7 cadenas, correspondientes a los días de la semana.
VECTORES DE COMPONENTES En Java, se pueden crear vectores de etiquetas, botones, cuadros de textos, etc. Esto es tremendamente útil cuando se tienen que definir muchos componentes con una función parecida, y que tengan que ser tratados en conjunto. Por otro lado, nos ahorra mucho tiempo ya que no se tienen que diseñar estos elementos en la misma ventana de diseño. Los vectores de componentes se usan igual que se ha indicado antes. Observa el siguiente ejemplo: JLabel veti[];
//aquí se crea un vector de etiquetas llamado veti
veti=new JLabel[3]; //aquí se construye el vector, asignando 3 etiquetas //ahora trabajamos con las etiquetas del vector //usando el típico for for (i=0;i
Realiza el siguiente ejercicio guiado para entender el ejemplo:
Ejercicio guiado
1. Crea un nuevo proyecto en java. 2. Empecemos definiendo desde código las características de la ventana. Crearemos el método CreacionVentana, y lo llamaremos desde el constructor del proyecto:
3. Vamos a situar en la ventana 10 cuadros de verificación (JCheckBox). Para ello, usaremos un vector de 10 JCheckBox. Este vector se declarará en la zona de variables globales (será necesario añadir el típico import):
4. La construcción de los vectores de componentes, se realiza en el mismo constructor (en nuestro caso en el método CreaciónVentana, que es llamado desde el constructor). Construiremos el vector de forma que contenga 10 JCheckBox:
5. Se acaba de construir un vector con 10 cuadros de verificación. Ahora, es necesario construir cada uno de los cuadros del vector y asignarle ciertas propiedades. Esto se hace con un for que recorre los elementos del vector. (Añade el siguiente código dentro de CreacionVentana):
6. Analiza este código que se acaba de añadir: a. Observa como cada elemento del vector debe ser construido: vcuadros[i] = new JCheckBox();
b. El texto que tendrá cada elemento será: “Opción 0”, “Opción 1”, etc… vcuadros[i].setText(“Opción “+i);
c. Los cuadros de verificación se colocan uno debajo de otro. Estudia la línea siguiente y observa como varía la posición vertical de cada cuadro: vcuadros[i].setBounds(10, 10+30*i,
100, 20);
7. Ejecuta el programa y observa el resultado:
8. Mejoremos la presentación de los cuadros cambiando los rótulos de cada uno. Para ello, será necesario usar otro vector auxiliar que contenga los textos de cada uno de los cuadros. Modifica el código anterior de forma que quede así:
9. En este código puedes observar como se usa un vector de String que se crea conteniendo 10 colores. Luego, ese vector se usa para asignar cada color al texto de cada cuadro. Si 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;
Y luego, dentro de CreacionVentana, añade el siguiente código:
11. Ahora programaremos la respuesta al evento actionPerformed de forma que el programa diga cuantos cuadros hay seleccionados. Para ello, se tendrá que programar el procedimiento btnAceptarActionPerformed, cuya llamada se encuentra en el código anterior (la línea que da error): Así pues, fuera de CreacionVentana, programa el siguiente procedimiento:
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 En Java, los vectores debe declararse y luego construirse. Es en la construcción del vector cuando a este se le asigna un número de elementos. Los vectores en Java pueden ser usados de la misma forma que en C. En Java se pueden crear vectores de componentes: etiquetas, botones, etc, facilitando luego el trabajo con todos estos elementos en conjunto y facilitando las labores de diseño.
EJERCICIO GUIADO. JAVA: VECTORES Y EVENTOS
Asignación de eventos a los elementos de un vector de componentes En Java se pueden crear vectores de componentes, como ya se vio en la hoja guiada anterior. Estos vectores pueden contener un grupo de etiquetas, o botones, cuadros de textos, etc. Gracias a los vectores de componentes se pueden crear rápidamente por código estos componentes y trabajar sobre ellos sin tener que usar muchas líneas de código. En esta hoja se verá como se pueden asignar eventos a los componentes de un vector.
Ejercicio guiado
1. Crea un nuevo proyecto en java. 2. Empecemos definiendo desde código las características de la ventana. Crearemos el método CreacionVentana, y lo llamaremos desde el constructor del proyecto:
3. Vamos a situar en la ventana 5 botones, y para ello usaremos un vector de botones, que tendremos que declarar en la zona de variables globales:
4. Dentro del procedimiento CreacionVentana construiremos el vector y construiremos cada uno de los botones que contiene, asignando las distintas características de cada uno. Debes añadir el siguiente código a CreacionVentana:
5. En el código anterior se crea un vector de cadenas (String) con el texto de cada botón. Luego se construye el vector de botones, asignándole 5 botones. A continuación, usando un for, construimos cada botón del vector, le asignamos el texto correspondiente, le asignamos su posición y su tamaño, y lo colocamos en el panel de contenido de la ventana.
6. Ejecuta el programa para observar su aspecto hasta ahora:
7. Ahora, interesaría asignar un evento actionPerformed a cada botón. Esto se hará aprovechando el que todos los botones pertenezcan a un vector, usando un bucle for. Añade el siguiente código al final de CreacionVentana:
Este código asigna a cada botón un evento actionPerformed que hace una llamada a un procedimiento al que se le ha llamado botonesActionPerformed. (Esta llamada da error porque aún no ha sido programado el procedimiento. Esto se hará a continuación.) Hay que tener en cuenta que cuando se pulse cualquiera de los botones, se ejecutará el procedimiento botonesActionPerformed. Programa este procedimiento (fuera de CreacionVentana, por supuesto) de la siguiente forma:
8. Ejecuta el programa y observa el resultado. Cuando pulsas cualquiera de los botones, se ejecuta la respuesta al evento y esta lo que hace es mostrar un mensaje a través de un JOptionPane donde aparece el texto “Has pulsado uno de los botones”. El procedimiento botonesActionPerformed sirve como respuesta para todos los botones. El problema que plantea esto es, ¿cómo saber qué botón se ha pulsado? Es aquí donde entra en funcionamiento el parámetro evt que suelen llevar todos los eventos. 9. Modifica el procedimiento botonesActionPerformed de forma que quede así:
Este código resulta muy interesante. El parámetro evt tiene siempre un método llamado getSource que devuelve el componente de la ventana sobre el que ha sucedido el evento. De esta manera obtenemos el botón que ha sido pulsado. (Observa que es necesario hacer un cast) Aprovechamos esto para introducir el botón en una variable auxiliar que hemos llamado botonPulsado. Luego solo hay que usar la variable botonPulsado como un botón normal y corriente. Por ejemplo, la usamos en el JOptionPane mostrando el texto que contiene el botón pulsado con el método getText. 10. Ejecuta el programa y observa el resultado.
CONCLUSIÓN Se pueden asignar eventos a los elementos de un vector a través de un for que recorra los distintos elementos del vector y le asigne el evento o eventos necesarios. Cuando se asigna un mismo procedimiento de respuesta a eventos a varios componentes, es necesario usar el parámetro evt junto con el método getSource para averiguar el componente sobre el que ha sucedido el evento. La forma general de acceder al elemento sobre el que sucedió el evento es la siguiente: TipoComponente variable = (TipoComponente) evt.getSource(); La variable variable contendrá el componente activado.
EJERCICIO GUIADO. JAVA: INTRODUCCIÓN A LA POO
Introducción a la Programación Orientada a Objetos La programación orientada a objetos es una nueva forma de entender la creación de programas. Esta filosofía de programación se basa en el concepto de objeto. Objeto Un objeto se define como un elemento que tiene unas propiedades y métodos. Un objeto posee unas características (ancho, alto, color, etc…) A las características de un objeto se les llama propiedades. Un objeto es un elemento “inteligente”. A un objeto se le puede dar órdenes y él obedecerá. A estas órdenes se les llama métodos. Con los métodos podemos cambiar las características del objeto, pedirle información, o hacer que el objeto reaccione de alguna forma. En Java todo son objetos. Veamos algunos ejemplos de uso de objetos en Java:
Ejemplo 1 Supongamos que tenemos una etiqueta llamada etiTexto. Esta etiqueta es un objeto. Como objeto que es, la etiqueta etiTexto tiene una serie de características, como por ejemplo: el color de fondo, el tamaño, la posición que ocupa en la ventana, el ser opaca o no, el ser invisible o no, etc… Son las propiedades de la etiqueta. A una etiqueta le podemos dar órdenes, a través de métodos. A través de los métodos podemos por ejemplo cambiar las características del objeto. Por ejemplo, se puede cambiar el tamaño y posición de la etiqueta usando el método setBounds: etiTexto.setBounds(10,20,100,20); Normalmente, los métodos que permiten cambiar las características del objeto son métodos cuyo nombre empieza por set. Los métodos también permiten pedirle al objeto que me de información. Por ejemplo, podríamos usar el conocido método getText para recoger el texto que contenga la etiqueta y almacenarlo en una variable: String texto; texto = etiTexto.getText();
Los métodos que le piden información al objeto suelen tener un nombre que empieza por get. Los métodos también sirven para ordenarle al objeto que haga cosas. Por ejemplo, podemos ordenar a la etiqueta etiTexto que se vuelva a pintar en la ventana usando el método repaint: etiTexto.repaint();
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: setVisible setEnabled setEditable setText setBounds setToolTipText etc…
- permite poner visible / invisible el cuadro de texto - permite activar / desactivar el cuadro de texto - permite hacer que se pueda escribir o no en el cuadro de texto - permite introducir un texto en el cuadro de texto - permite cambiar el tamaño y posición del objeto - permite asociar un texto de ayuda al cuadro de texto
Un objeto nos da información sobre él. Para pedirle información a un objeto usaremos métodos del tipo get. Por ejemplo, para pedirle al cuadro de texto el texto que contiene, usaremos el método getText: String cadena = txtCuadro.getText(); Otros métodos que le piden información al cuadro de texto son: getWidth getHeight getSelectedText getToolTipText etc…
- te dice la anchura que tiene el cuadro de texto - te dice el alto que tiene el cuadro de texto - te devuelve el texto que está seleccionado dentro del cuadro de texto - te dice el texto de ayuda que tiene asociado el cuadro de texto
También se le puede dar al objeto simplemente órdenes para que haga algo. Por ejemplo, podemos ordenar al cuadro de texto txtCuadro que seleccione todo el texto que contiene en su interior a través del método selectAll: txtCuadro.selectAll(); Otros métodos que ordenan al cuadro de texto son: repaint copy cut paste etc…
- le ordena al cuadro de texto que se vuelva a pintar - le ordena al cuadro de texto que copie el texto que tenga seleccionado - le ordena al cuadro de texto que corte el texto que tenga seleccionado - le ordena al cuadro que pegue el texto que se hubiera copiado o cortado
Clase Todo objeto es de una “clase” determinada, o dicho de otra forma, tiene un “tipo de datos” determinado. Por ejemplo, las etiquetas que se usan en las ventanas son objetos que pertenecen a la clase JLabel. Los cuadros de texto en cambio son objetos de la clase JTextField. Para poder usar un objeto hay que declararlo y construirlo. Declarar un Objeto La declaración de un objeto es algo similar a la declaración de una variable. Es en este momento cuando se le da un nombre al objeto. Para declarar un objeto se sigue la siguiente sintaxis: Clase nombreobjeto;
Por ejemplo, para declarar la etiqueta del ejemplo 1, se usaría el siguiente código: JLabel etiTexto; Para declarar, en cambio, el cuadro de texto del ejemplo 2, se usaría el siguiente código: JTextField txtCuadro;
Construir un Objeto En el momento de la “construcción” de un objeto, se le asignan a este una serie de propiedades iniciales. Es decir, unas características por defecto. Se puede decir que es el momento en que “nace” el objeto, y este nace ya con una forma predeterminada, que luego el programador podrá cambiar usando los métodos del objeto. Es necesario construir el objeto para poder usarlo. La construcción del objeto se hace a través del siguiente código general: nombreobjeto = new Clase(); Por ejemplo, para construir la etiqueta del ejemplo 1, se haría lo siguiente: etiTexto = new JLabel(); Para construir el cuadro de texto del ejemplo 2, se haría lo siguiente: txtCuadro = new JTextField();
NOTA. En algunos casos, la sintaxis de la declaración y la construcción se une en una sola línea. Por ejemplo, supongamos que queremos declarar la etiqueta etiTexto y construirla todo en una línea, entonces se puede hacer lo siguiente: JLabel etiTexto = new JLabel(); En general, para declarar y construir un objeto en una sola línea se sigue la siguiente sintaxis: Clase nombreobjeto = new Clase();
La Clase como generadora de objetos Conociendo la Clase, se pueden crear tantos objetos de dicha Clase como se quiera. Es decir, la Clase de un objeto funciona como si fuera una plantilla a partir de la cual fabricamos objetos iguales. Todos los objetos creados a partir de una clase son iguales en un primer momento (cuando se construyen) aunque luego el programador puede dar forma a cada objeto cambiando sus propiedades. Por ejemplo, la Clase JLabel define etiquetas. Esto quiere decir que podemos crear muchas etiquetas usando esta clase: JLabel etiTexto = new JLabel(); JLabel etiResultado = new JLabel(); JLabel etiDato = new JLabel(); En el ejemplo se han declarado y construido tres etiquetas llamadas etiTexto, etiResultado y etiDato. Las tres etiquetas en este momento son iguales, pero a través de los distintos métodos podemos dar forma a cada una: etiTexto.setBackground(Color.RED); etiTexto.setText(“Hola”); etiResultado.setBackground(Color.GREEN); etiResultado.setText(“Error”); etiDato.setBackground(Color.BLUE); etiDato.setText(“Cadena”);
En el ejemplo se le ha dado, usando el método setBackground, un color a cada etiqueta. Y se ha cambiado el texto de cada una. Se le da forma a cada etiqueta.
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 Un Objeto es un elemento que tiene una serie de características llamadas PROPIEDADES. Por otro lado, al objeto se le pueden dar órdenes que cumplirá de inmediato. A dichas órdenes se les denomina MÉTODOS. Los métodos se pueden dividir básicamente en tres tipos: Para cambiar las propiedades del objeto (Métodos set) Para pedir información al objeto (Métodos get) Para dar órdenes al objeto. Todo objeto pertenece a una CLASE. La CLASE nos permite declarar objetos y construirlos: Declaración: CLASE nombreobjeto; Construcción: nombreobjeto = new CLASE(); Declaración y Construcción en una misma línea CLASE nombreobjeto = new CLASE(), En la construcción de un objeto se asignan unas propiedades (características) por defecto al objeto que se construye, aunque luego, estas características pueden ser cambiadas por el programador.
EJERCICIO GUIADO. JAVA: POO. CLASES PROPIAS
Objetos propios del lenguaje Hasta el momento, todos los objetos que ha usado a la hora de programar en Java, han sido objetos incluidos en el propio lenguaje, que se encuentran disponibles para que el programador los use en sus programas. Estos objetos son: las etiquetas (JLabel), botones (JButton), los cuadros de texto (JTextField), cuadros de verificación (JCheckBox), botones de opción (JRadioButton), colores (Color), imágenes de icono (ImageIcon), modelos de lista (DefaultListModel), etc, etc. Todos estos objetos, por supuesto, pertenecen cada uno de ellos a una Clase: Las etiquetas son objetos de la clase JLabel, los botones son objetos de la clase JButton, etc. Todos estos objetos tienen propiedades que pueden ser cambiadas en la ventana de diseño: Ancho, alto, color, alineación, etc. Aunque también poseen métodos que nos permiten cambiar estas propiedades durante la ejecución del programa: setText cambia el texto del objeto, setBackground cambia el color de fondo del objeto, setVisible hace visible o invisible al objeto, setBounds cambia el tamaño y la posición del objeto, etc. En cualquier momento le podemos pedir a un objeto que nos de información sobre sí mismo usando los métodos get: getText obtenemos el texto que tenga el objeto, getWidth obtenemos la anchura del objeto, getHeight obtenemos la altura del objeto, etc. Los objetos son como “pequeños robots” a los que se les puede dar órdenes, usando los métodos que tienen disponible. Por ejemplo, le podemos decir a un objeto que se pinte de nuevo usando el método repaint, podemos ordenarle a un cuadro de texto que coja el cursor, con el método requestFocus, etc. Todos estos objetos, con sus propiedades y métodos, nos facilitan la creación de nuestros programas. Pero a medida que nos vamos introduciendo en el mundo de la programación y nos especializamos en un tipo de programa en concreto, puede ser necesaria la creación de objetos propios, programados por nosotros mismos, de forma que puedan ser usados en nuestros futuros programas.
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. Lo que viene a continuación es un planteamiento teórico de diseño de una Clase de Objetos.
CASO PRÁCTICO: MULTICINES AVENIDA
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: central = new SalaCine(); El objeto central representará a la sala de cine central de los Multicines Avenida.
Otro ejemplo. Los Multicines Avenida tienen una sala donde proyectan versiones originales. Se podría crear un objeto llamado salaVO de la clase SalaCine de la siguiente forma: SalaCine salaVO;
//declaración
salaVO = new SalaCine(); //construcción
Propiedades de los objetos de la clase SalaCine A la hora de decidir las propiedades de un objeto de creación propia, tenemos que preguntarnos, ¿qué información me interesa almacenar del objeto? Trasladando esta idea a nuestro caso práctico, ¿qué información me interesaría tener de cada sala de cine? Para este ejemplo supondremos que de cada sala de cine nos interesa tener conocimiento de las siguientes características (propiedades): -
Aforo: define el número de butacas de la sala (un número entero). Ocupadas: define el número de butacas ocupadas (un número entero). Película: define la película que se está proyectando en el momento en la sala (una cadena de texto) Entrada: define el precio de la entrada (un número double)
Valores por defecto de los objetos SalaCine Cuando se construye un objeto, se asignan unos valores por defecto a sus propiedades. Por ejemplo, cuando se construye una etiqueta (Clase JLabel), esta tiene un tamaño inicial definido, un color, etc. Lo mismo se tiene que hacer con los objetos propios que definimos. Es necesario decidir qué valores tendrá las propiedades del objeto al construirse. En nuestro caso, las características de un objeto SalaCine en el momento de construirse serán las siguientes: Aforo: 100 Ocupadas: 0 Película: “” Entrada: 5,00
(la cadena vacía)
Observa este código, en él construimos el objeto correspondiente a la sala central del multicine: SalaCine central; central = new SalaCine(); En este momento (en el que el objeto central está recién construido) este objeto tiene asignado un aforo de 100, el número de butacas ocupadas es 0, la película que se proyecta en la sala central es “” y la entrada para esta sala es de 5 euros. Los valores por defecto que se asignan a los objetos de una clase son valores arbitrarios que el programador decidirá según su conveniencia.
Métodos de los objetos SalaCine Para comunicarnos con los objetos de la Clase SalaCine que construyamos, tendremos que disponer de un conjunto de métodos que nos permitan asignar valores a las propiedades de los objetos, recoger información de dichos objetos y que le den órdenes al objeto. Será el programador el que decida qué métodos le interesará que posea los objetos de la Clase que está programando. Para nuestro caso particular, supondremos que los objetos de la Clase SalaCine deberán tener los siguientes métodos:
Métodos de cambio de propiedades (Métodos set) setAforo setOcupadas setLibres setPelicula setEntrada
- asignará un aforo a la sala de cine - asignará una cantidad de butacas ocupadas a la sala de cine - asignará una cantidad de butacas libres a la sala de cine - asignará un título de película a la sala de cine - fijará el precio de las entradas a la sala de cine
Gracias a estos métodos podemos dar forma a un objeto SalaCine recién creado. Por ejemplo, supongamos que queremos crear el objeto que representa la sala de versiones originales. Resulta que esta sala tiene de aforo 50 localidades, que se está proyectando la película “Metrópolis” y que la entrada para ver la película es de 3 euros. La sala está vacía de momento.
Para crear el objeto, se usaría el siguiente código: //Se construye el objeto SalaCine salaVO; salaVO = new SalaCine(); //Se le asignan características salaVO.setAforo(50); salaVO.setPelicula(“Metrópolis”); salaVO.setEntrada(3);
//aforo 50 //la película que se proyecta //entrada a 3 euros
Al construir el objeto salaVO tiene por defecto los valores siguientes en sus propiedades: Aforo: 100 Ocupadas: 0 Película: “” Entrada: 5,00 Gracias a los métodos disponibles hemos asignados estos nuevos valores: Aforo: 50 Ocupadas: 0 Película: “Metrópolis” Entrada: 3,00
Métodos para pedirle información al objeto (Métodos get) Se programarán los siguientes métodos get en la clase SalaCine: getAforo getOcupadas getLibres getPorcentaje getIngresos getPelicula getEntrada
- devuelve el aforo que tiene el objeto - devuelve el número de butacas ocupadas que tiene el objeto - devuelve el número de butacas que tiene libres el objeto - devolverá el porcentaje de ocupación de la sala - devolverá los ingresos producidos por la sala (entradas vendidas por precio) - devolverá el título de la película que se está proyectando - devolverá el precio de la entrada asignado al objeto
Estos métodos nos permitirán obtener información de un objeto del tipo SalaCine. Por ejemplo, supongamos que tenemos el objeto llamado central (correspondiente a la sala principal del multicine), para obtener la película que se está proyectando en dicha sala solo habría que usar este código: String peli; //una variable de cadena peli = central.getPelicula(); O, por ejemplo, para saber los ingresos producidos por la sala central… double ingresos; ingresos = central.getIngresos();
Métodos para dar órdenes al objeto Se programarán los siguientes métodos para dar órdenes a los objetos de la clase SalaCine. vaciar -
Este método pondrá el número de plazas ocupadas a cero y le asignará a la película la cadena vacía.
entraUno -
Este método le dice al objeto que ha entrado una nueva persona en la sala. (Esto debe producir que el número de plazas ocupadas aumente en uno)
RESUMEN SALACINE He aquí un resumen de la Clase de objetos SalaCine, la cual se programará en la próxima hoja: Clase de objetos: SalaCine Propiedades de los objetos SalaCine: Aforo Ocupadas Película Entrada
- número entero (int) - número entero (int) - cadena (String) - número decimal (double)
Valores por defecto de los objetos del tipo SalaCine: Aforo: 100 Ocupadas: 0 Película: (cadena vacía) Entrada: 5 Métodos de los objetos del tipo SalaCine: Métodos de asignación de propiedades (set) setAforo setOcupadas setLibres setPelicula setEntrada
- modifica la propiedad Aforo - modifica la propiedad Ocupadas - modifica la propiedad Ocupadas también - modifica la propiedad Película - modifica la propiedad Entrada
Métodos de petición de información (get) getAforo getOcupadas getLibres getPorcentaje getIngresos getPelicula getEntrada
- devuelve el valor de la propiedad Aforo - devuelve el valor de la propiedad Ocupadas - devuelve el número de butacas libres - devuelve el porcentaje de ocupación de la sala - devuelve los ingresos obtenidos por la venta de entradas - devuelve el valor de la propiedad Película - devuelve el valor de la propiedad Entrada
Métodos de orden Vaciar entraUno
- vacía la ocupación de la sala y borra la película - le indica al objeto que ha entrado una persona más en la sala
EJERCICIO PRÁCTICO
Supongamos que programamos una Clase de objetos llamada Rectangulo, la cual permitirá construir objetos que representen a rectángulos. 1. ¿Cómo declararía y construiría un objeto llamado suelo del tipo Rectangulo?
2. Supongamos que las propiedades de los objetos de la clase Rectangulo sean las siguientes: a. Base (double) b. Altura (double) ¿Qué métodos de tipo set programaría para cambiar las propiedades de los objetos del tipo Rectangulo?
3. Como ejemplo de los métodos anteriores, suponga que quiere asignar al objeto 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 Para crear un objeto propio, necesita tener claro lo siguiente: Nombre de la Clase del objeto. Propiedades que tendrán los objetos de dicha clase. Valores iniciales que tendrán las propiedades cuando se construya cada objeto. Métodos que serán interesantes de programar: Métodos de ajuste de propiedades (set) Métodos de petición de información (get) Métodos de orden Una vez que se tenga claro lo anterior, se podrá empezar la programación de la Clase de objetos.
EJERCICIO GUIADO. JAVA: POO. PROGRAMACIÓN DE UNA CLASE
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 Nombre de la Clase: SalaCine Propiedades de los objetos SalaCine: Aforo Ocupadas Película Entrada
- número entero (int) - número entero (int) - cadena (String) - número decimal (double)
Valores por defecto de los objetos del tipo SalaCine: Aforo: 100 Ocupadas: 0 Película: (cadena vacía) Entrada: 5 Métodos de los objetos del tipo SalaCine: Métodos de asignación de propiedades (set) setAforo setOcupadas setLibres setPelicula setEntrada
- modifica la propiedad Aforo - modifica la propiedad Ocupadas - modifica la propiedad Ocupadas también - modifica la propiedad Película - modifica la propiedad Entrada
Métodos de petición de información (get) getAforo getOcupadas getLibres getPorcentaje getIngresos getPelicula getEntrada
- devuelve el valor de la propiedad Aforo - devuelve el valor de la propiedad Ocupadas - devuelve el número de butacas libres - devuelve el porcentaje de ocupación de la sala - devuelve los ingresos obtenidos por la venta de entradas - devuelve el valor de la propiedad Película - devuelve el valor de la propiedad Entrada
Métodos de orden Vaciar entraUno
- vacía la ocupación de la sala y borra la película - le indica al objeto que ha entrado una persona más en la sala
PROGRAMACIÓN DE UNA CLASE
Fichero de la Clase La programación de una clase de objetos se realiza en un fichero aparte, cuyo nombre es exactamente el mismo que el de la propia clase, y cuya extensión es .java. Por ejemplo, si queremos programar la clase SalaCine, esto se debe hacer en un fichero llamado: SalaCine.java Cuando programemos esta clase dentro de NetBeans, veremos las facilidades que nos proporciona este para la creación de la clase. De momento, solo veremos de forma teórica como hay que programar la clase. (No tiene que introducir lo que viene a continuación en ningún sitio)
Estructura básica de la Clase Dentro del fichero de la clase, comenzará la programación de esta de la siguiente forma: public class SalaCine {
} La programación de una clase comienza siempre con una línea de código como la que sigue: public class NombreDeLaClase {
} Toda la programación de la clase se introducirá dentro de las dos llaves.
Propiedades de la Clase Lo primero que se debe introducir en la clase que se está programando son las propiedades. Las propiedades de una clase son básicamente variables globales de ésta. Si introducimos las propiedades de la clase SalaCine, esta nos quedaría así: public class SalaCine { int Aforo; int Ocupadas; String Película; double Entrada; }
Constructor de la Clase Cuando se planteó la clase SalaCine, se tuvo que decidir qué valores iniciales deberían tener las propiedades de la clase. Para asignar estos valores iniciales, es necesario programar lo que se denomina el Constructor.
El Constructor de una clase es un método (un procedimiento para entendernos) un poco especial, ya que debe tener el mismo nombre de la clase y no devuelve nada, pero no lleva la palabra void. Dentro del constructor se inicializan las propiedades de la clase. En general, la programación del constructor sigue la siguiente sintaxis: public NombreDeLaClase() { propiedad1 = valor; propiedad2 = valor; etc… } La clase SalaCine, añadiendo el Constructor, tendrá el siguiente aspecto: public class SalaCine { int Aforo; int Ocupadas; String Película; double Entrada; //Constructor public SalaCine() { Aforo = 100; Ocupadas = 0; Pelicula = “”; Entrada = 5.0; }
Constructor
} 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.
Métodos del tipo set Todas las clases suelen contener métodos del tipo set. Recuerda que estos métodos permiten asignar valores a las propiedades de la clase. Debes tener en cuenta también que cuando se habla de método de una clase, en realidad se está hablando de un procedimiento o función, que puede recibir como parámetro determinadas variables y que puede devolver valores. Los métodos del tipo set son básicamente procedimientos que reciben valores como parámetros que introducimos en las propiedades. Estos métodos no devuelven nada, así que son void. Se recomienda, que el parámetro del procedimiento se llame de forma distinta a la propiedad que se asigna. Veamos la programación del método setAforo, de la clase SalaCine: public void setAforo(int afo) { Aforo = afo; } Observa este método: -
Es void, es decir, no devuelve nada (el significado de la palabra public se verá más adelante)
-
El método recibe como parámetro una variable del mismo tipo que la propiedad que queremos modificar (en este caso int) y un nombre que se recomienda que no sea igual al de la propiedad (en nuestro caso, afo, de aforo)
-
Puedes observar que lo que se hace simplemente en el método es asignar la variable pasada como parámetro a la propiedad.
La mayoría de los procedimientos set usados para introducir valores en las propiedades tienen la misma forma. Aquí tienes la programación de los demás procedimientos set de la clase SalaCine. //Método setOcupadas public void setOcupadas(int ocu) { Ocupadas = ocu; } //Método setPelicula public void setPelicula(String peli) { Pelicula = peli; } //Método setEntrada public void setEntrada(double entra) { Entrada = entra; } Hay un método set de la clase SalaCine llamado setLibres cuya misión es asignar el número de localidades libres del cine. Sin embargo la clase SalaCine no tiene una propiedad “Libres”. En realidad, este método debe modificar el número de localidades ocupadas. Observa su programación: //Método setLibres public void setLibres(int lib) { int ocu; ocu = Aforo – lib; Ocupadas = ocu; }
Al asignar un número de localidades ocupadas, estamos asignando indirectamente el número de localidades libres. Como puedes observar en el método, lo que se hace es calcular el número de localidades ocupadas a partir de las libres, y asignar este valor a la propiedad Ocupadas. No se pensó en crear una propiedad de la clase llamada Libres ya que en todo momento se puede saber cuantas localidades libres hay restando el Aforo menos las localidades Ocupadas. La clase SalaCine, añadiendo los métodos set, quedaría de la siguiente forma:
public class SalaCine { 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; ocu = Aforo – lib; Ocupadas = ocu; }
}
Métodos del tipo get Al igual que los métodos set, los métodos get son muy fáciles de programar ya que suelen tener siempre la misma forma. Estos métodos no suelen llevar parámetros y devuelven el valor de la propiedad correspondiente usando la típica instrucción return usada tanto en las funciones. Por tanto, un método get nunca es void. Siempre será del mismo tipo de datos que la propiedad que devuelve. Veamos la programación del método getAforo:
//Método getAforo public int getAforo() { return Aforo; } Como puedes ver el método simplemente devuelve el valor de la propiedad Aforo. Como esta propiedad es int, el método es int. Los métodos que devuelven el resto de las propiedades son igual de sencillos de programar: //Método getOcupadas public int getOcupadas() { return Ocupadas; } //Método getPelicula public String getPelicula() { return Película; } //Método getEntrada public double getEntrada() { return Entrada; } Todos estos métodos son iguales. Solo tienes que fijarte en el tipo de datos de la propiedad que devuelven. Existen otros métodos get que devuelven cálculos realizados con las propiedades. Estos métodos realizan algún cálculo y luego devuelven el resultado. Observa el siguiente método get: //Método getLibres public int getLibres() { int lib; lib = Aforo – Ocupadas; return lib; } No existe una propiedad Libres, por lo que este valor debe ser calculado a partir del Aforo y el número de localidades Ocupadas. Para ello restamos y almacenamos el valor en una variable a la que hemos llamado lib. Luego devolvemos dicha variable. Los dos métodos get que quedan por programar de la clase SalaCine son parecidos: //Método getPorcentaje public double getPorcentaje() { double por; por = (double) Ocupadas / (double) Aforo * 100.0; return por; } Este método calcula el porcentaje de ocupación de la sala (es un valor double) //Método getIngresos public double getIngresos() { double ingre; ingre = Ocupadas * Entrada; return ingre; } Los ingresos se calculan multiplicando el número de entradas por lo que vale una entrada.
La clase SalaCine una vez introducidos los métodos get quedaría de la siguiente forma: public class SalaCine { 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; 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étodos Get
//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; double Entrada;
Propiedades (variables globales)
//Constructor public SalaCine() { Aforo = 100; Ocupadas = 0; Pelicula = “”; Entrada = 5.0; }
Constructor
//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 Set
//Métodos get //Método getAforo public int getAforo() { return Aforo; } //Método getOcupadas public int getOcupadas() { return Ocupadas; }
Métodos Get
//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étodo entraUno public void entraUno() { Ocupadas++; }
}
Métodos de orden y otros métodos.
EJERCICIOS RECOMENDADOS
Supongamos que tenemos una clase llamada Rectangulo que nos permitirá generar objetos de tipo rectángulo. Sea el planteamiento de la clase Rectangulo el que sigue:
CLASE RECTANGULO Nombre de la clase: Rectangulo Propiedades de los objetos de la clase Rectangulo: Base (double) Altura (double) Valores iniciales de las propiedades de los objetos de la clase Rectangulo: Base – 100 Altura – 50 Métodos: Métodos set: setBase – permite asignar un valor a la propiedad Base. setAltura – permite asignar un valor a la propiedad Altura. Métodos get: getBase – devuelve el valor de la propiedad Base getAltura – devuelve el valor de la propiedad Altura getArea – devuelve el área del rectángulo getPerímetro – devuelve el perímetro del rectángulo Otros métodos: Cuadrar – este método debe hacer que la Altura tenga el valor de la Base.
SE PIDE: Realiza (en papel) la programación de la clase Rectangulo a partir del planteamiento anterior.
CONCLUSIÓN La programación de una clase se realiza en un fichero que tiene el mismo nombre que la clase y extensión .java La estructura general de una clase es la siguiente: public class NombreClase { Propiedades (variables globales) Constructor Métodos set Métodos get Métodos de orden y otros métodos }
El Constructor es un procedimiento que no devuelve nada pero que no es void. El constructor debe llamarse igual que la clase y se usa para asignar los valores iniciales a las propiedades. Los métodos set son void y reciben como parámetro un valor que se asigna a la propiedad correspondiente. Los métodos get no tienen parámetros y devuelven el valor de una propiedad de la clase, aunque también pueden realizar cálculos y devolver sus resultados. Los métodos de orden realizan alguna tarea específica y a veces modifican las propiedades de la clase de alguna forma.
EJERCICIO GUIADO. JAVA: POO. USAR CLASES PROPIAS EN UN PROYECTO Aplicación de una Clase Propia 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 btnCentralOcupacion btnCentralVaciar btnCentralIngresos btnCentralCambiar
Etiqueta: etiCentralPelicula
Panel: panelCentral
Panel: panelVOriginal
Botones: btnOriginalNueva btnOriginalOcupacion btnOriginalVaciar btnOriginalIngresos btnOriginalCambiar
Botón btnIngresosTotales
Etiqueta: etiOriginalPelicula
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:
5. Elegiremos la opción Nuevo / Clase Java…
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.
El fichero de la 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
Preparación del constructor
9. Ahora ya solo tendremos que completar la programación de la clase, añadiendo las propiedades, completando el constructor, y añadiendo los distintos métodos que programamos en la hoja anterior. Debes modificar el fichero SalaCine para que quede así:
/* * SalaCine.java * * Created on 2 de agosto de 2007, 12:14 * * To change this template, choose Tools | Template Manager * and open the template in the editor. */ package paqueteprincipal; /** * * @author didact */ public class SalaCine { //propiedades int Aforo; int Ocupadas; String Pelicula; double Entrada;
/** Creates a new instance of SalaCine */ //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; 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. 13. Para ello, acude a la ventana de código de la ventana principal:
14. En la zona de variables globales de la ventana principal declararemos dos objetos del tipo SalaCine:
Creamos dos objetos “sala de cine”
15. Es en el constructor de nuestra ventana principal donde construiremos nuestros objetos de tipo sala. (Recuerda que el constructor de tu ventana principal se suele usar para construir los objetos que vas a usar en tu programa y asignarle las características que tendrán dichos objetos al inicio)
Construimos los objetos.
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: Aforo 100, Ocupación 0, Película (cadena vacía) y Entrada 5.0 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: Aforo: 500 y un precio de entrada de 8 euros. 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: Aforo: 80. Precio entrada: 6.0 euros. 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. 19. Empezaremos programando el botón btnCentralCambiar. El objetivo de este botón es asignar a la sala central un título de película. Ese título se debe mostrar también en la etiqueta etiCentralPelicula:
Cambia el título de la película de la sala central.
20. Entra en el actionPerformed del botón btnCentralCambiar y programa lo siguiente:
El código de este botón hace lo siguiente: -
Le pide al usuario que introduzca un título para la película, usando un JOptionPane.showInputDialog. El título introducido se recoge en una variable de cadena llamada titulo.
-
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.
-
Y finalmente se coloca el título en la etiqueta para que el usuario pueda verlo.
21. Ejecuta el programa y observa el funcionamiento del botón. 22. Ahora se programará el botón btnCentralNueva:
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. Así pues, programe el actionPerformed del botón btnCentralNueva de la siguiente forma:
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: Película que se está proyectando. Aforo total de la sala. Butacas Ocupadas. Butacas Libres. Porcentaje de ocupación. 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. Estudia atentamente la programación del botón btnCentralOcupacion:
Observa el código: -
Primero se crea una variable de cadena llamada info (información)
-
A continuación, se van concatenando textos a la variable de cadena. Recuerda que los \n permiten añadir saltos de línea.
-
Observa como se va pidiendo información al objeto a través de métodos get y se va concatenando esta información a la variable info.
-
Finalmente se presenta el texto de la variable info en un JOptionPane.
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
Pulsa este botón varias veces, para simular la venta de varias entradas.
Pulsa aquí para ver información actualizada sobre la ocupación de la
25. A continuación se programará el botón Vaciar de correspondiente a la sala central (btnCentralVaciar) Este botón debe situar la ocupación de la sala a cero y quitar la película asignada a la sala central. Programa en el actionPerformed del botón lo siguiente:
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 vende varias entradas…
…luego comprueba el % de ocupación y los ingresos…
…prueba a vaciar la sala y luego vuelve a comprobar la ocupación y los ingresos…
EJERCICIO El segundo de los paneles hace referencia a la sala de versiones originales. Su funcionamiento es el mismo que el de la sala central. Se pide que programe todos los botones correspondientes a la sala de versiones originales. La programación es prácticamente igual, solo hay que actuar sobre el objeto vo en vez del objeto central.
EJERCICIO El botón IngresosTotales de la ventana, debería mostrar en un JOptionPane la suma de los ingresos actuales de ambas salas. Programe dicho botón. Solo tiene que pedirle a cada objeto: central y vo que le de sus ingresos, y sumar ambos.
CONCLUSIÓN Se pueden añadir a un proyecto Java clases programadas por uno mismo. 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 solución a este problema es la Herencia. Básicamente, lo que necesitamos es mejorar la Clase JButton, la cual define botones normales y corrientes, de forma que estos botones admitan también los métodos indicados antes. 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.
Programación de la Clase BotonContador
Creación de la clase derivada La programación de la clase derivada BotonContador se hará en un fichero aparte, al igual que la programación de las clases de creación propia. Se comenzará definiendo el comienzo de la clase y añadiendo las llaves que limitan su contenido:
public class BotonContador extends JButton {
}
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. public class BotonContador extends JButton { int pulsaciones;
} Inicialización de las propiedades de la clase derivada Nuestra propiedad pulsaciones debe ser inicializada en el constructor de la clase. Para ello crea el constructor de la clase:
public class BotonContador extends JButton { int pulsaciones; public BotonContador() { pulsaciones=0; } } Añadir métodos propios a la clase derivada Se añadirán los nuevos métodos que queremos que la clase BotonContador posea. Estos son los siguientes: setPulsaciones getPulsaciones incrementa decrementa reiniciar aumentar disminuir
- asigna un número de pulsaciones al botón. - devuelve el número de pulsaciones del botón. - suma uno a las pulsaciones del botón - resta uno a las pulsaciones del botón - pone a cero las pulsaciones del botón - aumenta en una cantidad las pulsaciones del botón. - disminuye en una cantidad las pulsaciones del botón.
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 //asigna una cantidad de pulsaciones public void setPulsaciones(int p) { pulsaciones=p; } //devuelve las pulsaciones del botón public int getPulsaciones() { return pulsaciones; } //incrementa en uno las pulsaciones public void incrementa() { pulsaciones++; } //decrementa en uno las pulsaciones public void decrementa() { pulsaciones--; } //pone las pulsaciones a cero public void reiniciar() { pulsaciones=0; } //aumenta las pulsaciones en una cantidad c public void aumenta(int c) { pulsaciones=pulsaciones+c; } //disminuye las pulsaciones en una cantidad c public void disminuye(int c) { pulsaciones=pulsaciones-c; } }
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: public class BotonContador extends JButton {
Uso de la clase BotonContador
Usaremos la clase BotonContador en un simple proyecto de prueba para que puedas observar sus posibilidades.
Para ello, sigue los pasos que se indican a continuación:
1. Crea un proyecto llamado Contadores, que tenga un paquete principal llamado paqueteprincipal y un JFrame llamado ventanaprincipal:
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:
3. Antes de empezar con el diseño de la ventana principal programa la clase BotonContador. Debes hacer doble clic sobre el fichero BotonContador.java e introducir en él la clase BotonContador que hemos diseñado anteriormente usando herencia. El fichero BotonContador.java debería quedar así:
/* * BotonContador.java * * Created on 6 de agosto de 2007, 10:59 * * To change this template, choose Tools | Template Manager * and open the template in the editor. */ package paqueteprincipal; import javax.swing.JButton; /** * * @author didact */ public class BotonContador extends JButton { //propiedades int pulsaciones; //constructor public BotonContador() { pulsaciones=0; } //asigna una cantidad de pulsaciones public void setPulsaciones(int p) { pulsaciones=p; } //devuelve las pulsaciones del botón public int getPulsaciones() { return pulsaciones; } //incrementa en uno las pulsaciones public void incrementa() { pulsaciones++; } //decrementa en uno las pulsaciones public void decrementa() { pulsaciones--; } //pone las pulsaciones a cero public void reiniciar() { pulsaciones=0; } //aumenta las pulsaciones en una cantidad c public void aumenta(int c) { pulsaciones=pulsaciones+c; } //disminuye las pulsaciones en una cantidad c public void disminuye(int c) { pulsaciones=pulsaciones-c; } }
4. Ahora programaremos el diseño de la ventana. Lo haremos desde código. Entra en el módulo ventanaprincipal.java y pasa a la zona de código:
5. En la zona de código programaremos el típico método CreacionVentana, llamado desde el constructor, donde se programará el diseño de la ventana:
6. Nuestro programa tendrá dos botones del tipo BotonContador. Declara estos botones como variables globales de la clase:
7. En el método CreacionVentana definiremos características de la ventana y construiremos estos botones y los situaremos en la ventana:
8. Como puedes ver, los botones contadores se construyen igual que los JButton, y, de hecho, tienen los mismos métodos que los JButton, ya que derivan de ellos. Así pues, un botón contador tiene un método setText, setBounds, etc… 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. Accede al actionPerformed del botón Ver Pulsaciones y programa lo siguiente:
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.
16. Ejecuta el programa y prueba lo siguiente: -
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…
…y luego pulsa el botón Ver Pulsaciones. 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. 18. Accede al actionPerformed del botón Reiniciar y programa lo siguiente:
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… … al ver las pulsaciones, estas deben ser cero…
EJERCICIO
Se propone al alumno que añada las siguientes modificaciones al programa: -
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… Y al pulsar iniciar, los contadores internos de los botones se inicializan al valor introducido
CONCLUSIÓN 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 en la línea de creación de la clase. La clase creada así obtendrá características de la clase de la que hereda. Aparte, esta clase tendrá métodos propios añadidos por el programador.
EJERCICIO GUIADO. JAVA: POO. HERENCIA. DIALOGOS PROPIOS 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.
Cuadro de Diálogo Propio 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.
3. En la ventana que aparece, escogeremos en la parte izquierda la opción Formularios GUI Java, y en la parte derecha escogeremos la opción Formulario JDialog. Luego activa el botón Siguiente.
4. A continuación tendremos que indicar el nombre que tendrá la clase correspondiente a nuestro cuadro de diálogo propio. En nuestro caso llamaremos a esta clase dialogoFecha.
5. Y pulsa el botón Terminar. Observarás que se ha creado una nueva Clase dentro del proyecto llamada dialogoFecha.
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: -
El cuadro de texto para el día se llamará: txtDia El cuadro de texto para el mes se llamará: txtMes El cuadro de texto para el año se llamará: txtAnio El botón Aceptar se llamará btnAceptar El botón Cancelar se llamará btnCancelar
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() -
Este método devolverá una cadena con la fecha en el siguiente formato: Dia de Mes(en letras) de Año
getBotonPulsado() -
Este método devolverá el valor de la propiedad BotonPulsado. Esta propiedad podrá tener un 0 o un 1. Tendrá un 0 si se pulsa el botón Aceptar, y un 1 si se pulsa el botón Cancelar.
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.
Como puedes observar en el código, asigno el 1 a la propiedad BotonPulsado y luego uso el método dispose para cerrar el cuadro de diálogo.
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. Accede al actionPerformed del botón btnAceptar y programa lo siguiente…
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.
17. Y ya para terminar con la programación de nuestro dialogoFecha, programaremos el método getBotonPulsado, que básicamente devuelve la propiedad BotonPulsado, la cual contiene un
0 si se pulsó Aceptar y un 1 si se pulsó Cancelar. La programación de este método es muy sencilla:
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:
19. Diseña esta ventana para que tenga la siguiente forma:
El botón se llamará btnFechaNacimiento y la etiqueta con borde se llamará etiFechaNacimiento.
20. El programa funcionará de la siguiente forma: -
Al pulsar el botón Introducir Fecha Nacimiento aparecerá un cuadro de diálogo del tipo dialogoFecha, donde el usuario introducirá la fecha de nacimiento.
-
Al pulsar Aceptar, dicha fecha aparecerá en la etiqueta etiFechaNacimiento.
-
Al pulsar Cancelar, la etiqueta etiFechaNacimiento se borrará.
21. Nuestro programa necesitará un cuadro de diálogo del tipo dialogoFecha. Este cuadro lo declararemos en la zona de variables globales de la ventana principal y lo llamaremos nacimiento…
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…
3) El programa le pide información al cuadro de diálogo para saber que debe colocar en la etiqueta.
2) Al pulsar Aceptar o Cancelar, el cuadro de diálogo modifica sus propiedades internas (dia, mes, año y botón pulsado) y se cierra
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. Estos cuadros de diálogo son clases que derivan de la clase JDialog. 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 La reutilización de código consiste en aprovechar lo que ya tenemos programado (así como aprovechar lo que han programado otros) para así poder finalizar los proyectos en menos tiempo. La filosofía de esto es: ¿por qué programar lo que ya está programado? A lo largo de la vida profesional de un programador, este se va haciendo con un conjunto de Clases que son capaces de generar objetos que pueden ser usados en los nuevos proyectos que el programador realice. Cuantas más clases coleccione, más herramientas dispondrá para crear los nuevos proyectos. 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. Si despliegas el proyecto Fecha, tu ventana de proyectos tendrá un aspecto similar al siguiente:
Proyecto Fecha
Proyecto Reutilizacion
Observarás que el proyecto Fecha incluye la clase dialogoFecha dentro de su paquete principal.
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…
4. Y luego Pega en el paquete principal del proyecto Reutilizacion.
4. Observarás como se añade una copia de dialogoFecha al paquete principal del proyecto Reutilizacion.
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)
6. Supongamos que necesitamos también la clase BotonContador creada en la hoja guiada nº 31. Solo tendremos que abrir el proyecto llamado Contadores, que se programó en dicha hoja…
7. Y luego copiar la clase BotonContador desde Contadores a Reutilizacion. Hágalo y luego cierre la clase Contadores. Su ventana de proyectos debería quedar así:
8. A partir de este momento, puede crear botones contadores y cuadros de diálogo de introducción de fechas en el proyecto Reutilizacion sin tener que haber programado ni una línea de código. 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)
11. El nombre del paquete será elementosventana. Su proyecto quedará así:
12. En el nuevo paquete que hemos creado, introduciremos las clases BotonContador y dialogoFecha. De esta forma, tendremos organizadas nuestras clases. Por un lado la clase de la ventana principal, en el paqueteprincipal, y por otro lado, los elementos de las ventanas de creación propia en el paquete elementosventana. Para introducir las clases en el paquete elementosventana puede hacerlo cortando y pegando. Cuando intente pegar una clase en otro paquete aparecerá un cuadro de opciones como el siguiente:
Desactiva la opción Previsualizar todos los cambios y pulsa Siguiente. 13. Una vez movidas las dos clases al paquete elementosventana, su proyecto debe quedar así:
Ahora tiene mejor clasificadas sus clases en su proyecto. 14. Guarde el proyecto, pero no lo cierre, ya que se usará a continuación.
EJERCICIO GUIADO 2
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. Veremos en este ejercicio guiado como crear una Biblioteca. 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.
2. Pulsa el botón Siguiente y asigna a la biblioteca el nombre MisClases. Pulsa Terminar.
Observarás que ha aparecido un nuevo proyecto, llamado MisClases.
3. A este nuevo proyecto le agregaremos el paquete elementosventana que tenemos en el proyecto Reutilizacion. Solo hay que copiar…:
4. Y luego Pegar…
5. Y el resultado es que hemos añadido un paquete a la biblioteca MisClases:
6. Se podría agregar más paquetes de clases a la biblioteca. A medida que vayamos programando clases útiles para nuestro trabajo, deberíamos incluirlas en la biblioteca. Se consigue así tener todas las clases reunidas en un solo proyecto.
7. Cierre el proyecto Reutilizacion, pero no el proyecto MisClases porque lo usaremos a continuación.
EJERCICIO GUIADO 3
1. Para facilitar la inclusión de una biblioteca en un proyecto, se suele compactar la biblioteca en un fichero de tipo JAR. Para conseguir esto, configura el proyecto MisClases como proyecto principal.
2. A continuación pulsa el botón de la barra de herramientas Limpiar y Construir proyecto principal:
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. 6. Dentro del NetBeans, cierre el proyecto MisClases. 7. Crea un nuevo proyecto, que se llamará UsoLibreria. Dentro de él añade un paqueteprincipal y dentro del paquete principal un JFrame llamado ventanaprincipal. El aspecto de su ventana de proyecto será el siguiente:
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.
9. Busca en el escritorio el fichero MisClases.JAR y ábrelo.
10. En este momento, la librería de clases llamada MisClases ha sido añadida a tu proyecto, y esto significa que podrás usar cualquier clase que contenga MisClases. Es decir, podrás usar la clase BotonContador y dialogoFecha para crear tus objetos, así como cualquier otra clase que estuviera incluida en MisClases.
11. Resumiendo: -
Un programador crea muchas clases propias a lo largo de su trabajo. Estas clases pueden ser usadas en otros proyectos. Es conveniente reunir las clases en paquetes, y reunir paquetes en bibliotecas (también llamadas librerías) Las bibliotecas se pueden compactar en un solo fichero .JAR Al incluir un fichero de biblioteca en un proyecto, puedes usar las clases que estén contenidas en dicha biblioteca.
CONCLUSIÓN En NetBeans puedes abrir varios proyectos y copiar los ficheros de clases de uno a otro. Si un proyecto tiene muchas clases, interesa clasificarlas en paquetes. Es interesante reunir las clases que más uses en un solo proyecto de tipo biblioteca, para poder acceder a ellas fácilmente. Una biblioteca se puede compactar en un solo fichero de tipo .JAR Al asociar un fichero de biblioteca .JAR a un proyecto, hacemos que en dicho proyecto se puedan usar las clases contenidas en dicha biblioteca. Todas estas ideas hacen efectiva la reutilización de código, es decir, el aprovechar lo ya programado, para no tener que volverlo a programar.
EJERCICIO GUIADO. JAVA: PROGRAMACIÓN MDI Programación SDI y Programación MDI 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. Aplicaciones SDI (Single Document Interface) 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. Aplicaciones MDI (Multiple Documento Interface) MDI se puede traducir como interfaz de múltiples documentos. Esto quiere decir que las aplicaciones MDI pueden mostrar varios documentos a la vez. Un ejemplo práctico de aplicación MDI es el programa de retoque fotográfico Photoshop. En él, el usuario puede abrir varias fotos y trabajar con todas ellas. 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: -
Diseño de la ventana principal. Diseño de las ventanas internas. Programación de la ventana principal / internas.
Diseño de la ventana principal
1. Crea un nuevo proyecto. El nombre del proyecto será VisorFotos. Añade un paquete llamado paqueteprincipal. Dentro de dicho paquete añade un JFrame llamado ventanaprincipal.
2. Añade a la ventana principal una barra de menús, con una única opción Archivo, que contenga a su vez las siguiente opciones:
Asigna los siguientes nombres a cada elemento del menú:
3. Establece un layout de tipo BorderLayout al JFrame. Recuerda que este tipo de distribución divide la ventana en cinco zonas: norte, sur, este, oeste y centro.
4. En la zona central de la ventana principal colocaremos un panel, pero no será un JPanel, como siempre, sino otro tipo de panel. Debes colocar un panel del tipo JDesktopPane:
Este tipo de panel es usado como contenedor de las ventanas internas de una aplicación MDI. En NetBeans este tipo de panel se muestra de color azul, para distinguirlo de los paneles normales, por eso, cuando añadas el panel al JFrame este quedará así:
5. Cámbiale el nombre al JDesktopPane y asígnale el nombre panelInterno:
6. Si ejecutas el programa ahora, verás que la ventana sale reducida al mínimo tamaño posible. Esto lo vamos a evitar haciendo que la ventana aparezca maximizada al ejecutarse el programa. También le asignaremos un tamaño inicial. Para ello, acude al constructor del JFrame y programa lo siguiente:
Llamada a un método ConfiguracionVentana
Programación de dicho método.
Como ves, en el constructor se llama a un método ConfiguracionVentana y en este método se asigna un tamaño por defecto a la ventana de 800x600 y se maximiza.
Diseño de las ventanas internas Se pretende que cuando se abra una imagen, el programa muestre una ventana interna que contenga la imagen y nada más. La barra de título de esta ventana interna contendrá el camino de la imagen. Para diseñar la ventana interna de la aplicación, sigue los pasos que se indican a continuación:
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.
La etiqueta se llamará etiImagen…
Y ocupará todo el JInternalFrame
12. En las hojas guiadas anteriores, se ha hablado de la programación orientada a objetos, y se ha comentado que los objetos poseen propiedades. Estas propiedades son básicamente variables globales internas. Para poder acceder a estas propiedades, es necesario programar métodos set. Pues bien, la etiqueta etiImagen de la clase ventanainterna, no es 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:
Método para acceder a la etiqueta etiImagen
14. En la programación MDI, será habitual crear métodos para poder acceder a los distintos elementos de la ventana interna (etiquetas, cuadros de texto, etc) En otras ocasiones, tendremos que crear métodos get para obtener información de las ventanas internas. Es algo muy similar a la programación de diálogos propios que se vio en hojas anteriores.
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. Sigue los pasos que se describen a continuación:
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. Se crea un objeto del tipo JFileChooser a través de la línea: JFileChooser abrir = new JFileChooser(); Luego se le da la orden de que muestre el cuadro de diálogo Abrir. La variable boton recoge el botón pulsado por el usuario (Aceptar / Cancelar) int boton = abrir.showOpenDialog(null); Luego, a través de un if, compruebo si se ha pulsado el botón Aceptar… if (boton==JFileChooser.APPROVE_OPTION) { } Dentro de este if tendremos que programar la acción correspondiente a abrir la imagen y mostrarla en pantalla. Vamos a ello.
17. Programa dentro del if anterior lo siguiente. El código se comentará a continuación.
Atento a este código, porque define la creación de ventanas internas, conteniendo la imagen elegida para mostrar. Es el corazón del programa… La primera instrucción, crea una ventana interna llamada vi. Como puedes observar, es la creación de un objeto vi de la clase ventanainterna. ventanainterna vi = new ventanainterna(); Lo siguiente que se hace con el objeto vi creado, es definir sus características como ventana. Concretamente se decide que sea una ventana con posibilidad de cambiar de tamaño (setResizable), una ventana que pueda ser maximizada (setMaximizable), una ventana 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. String camino = abrir.getSelectedFile().toString(); Ahora aprovechamos el método setImagen que programamos oportunamente dentro de la clase ventanainterna para situar dicha imagen dentro de la etiqueta. vi.setImagen(camino);
Colocamos el camino de la imagen en la barra de título de la ventana interna: vi.setTitle(camino); Finalmente hacemos visible la ventana interna. vi.setVisible(true);
18. Ejecuta el programa y prueba a abrir varios ficheros de imagen. Observa la creación de las ventanas internas. Observa como todas tienen el mismo aspecto (una etiqueta única en la ventana conteniendo la imagen) Observa la posibilidad de moverlas, cambiarlas de tamaño, maximizarlas, minimizarlas y cerrarlas. Observa como todas las ventanas internas están encerradas dentro de los límites del panel interno de la ventana principal:
19. Este proyecto se usará en las próximas hojas. Guárdalo.
CONCLUSIÓN La programación MDI consiste en crear aplicaciones capaces de abrir varios ficheros y mostrarlos en distintas ventanas internas. Una aplicación MDI cuenta con dos elementos básicos: - Un panel interno JDesktopPane, el cual contendrá las ventanas internas. - Una clase del tipo JInternalFrame, la cual definirá el diseño de las ventanas internas.
La clase JInternalFrame que añadamos, tendrá el nombre que queramos asignarle y nos servirá de plantilla para crear las ventanas internas de nuestro proyecto. Esta clase podrá tener métodos internos para acceder a los elementos de las ventanas internas. Desde la ventana principal, se crearán objetos de la clase ventana interna, y se definirán opciones relativas a la posibilidad de maximizar, cerrar, minimizar, etc, dichas ventanas. Desde la ventana principal se usarán los métodos programados en la ventana interna para poder manejarla con facilidad.
EJERCICIO GUIADO. JAVA: PROGRAMACIÓN MDI CONTINUACIÓN 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.
Ventana interna activa
1. Abre el proyecto VisorFotos que realizó en la hoja anterior. 2. Accede a la ventana principal del proyecto, haciendo doble clic sobre la clase ventanaprincipal. 3. Accede al evento actionPerformed de la opción del menú Cerrar y programa lo siguiente:
4. Ejecuta el programa y comprueba el funcionamiento de la opción Cerrar. Se recomienda que abra varias imágenes en su programa y luego seleccione una de ellas. Active la opción Cerrar y observe como la ventana interna se cierra. 5. El funcionamiento del código que acaba de programar es el siguiente: El panel interno panelInterno es un objeto del tipo JDesktopPane. Estos paneles son paneles especiales preparados para contener ventanas internas (JInternalFrame) y poseen algunos métodos muy útiles para manipular las ventanas internas que contienen. Uno de los métodos que más usaremos será getSelectedFrame. Este método devuelve la ventana interna seleccionada ahora mismo, o null si no hay ninguna seleccionada. En el código anterior, observarás que creamos un objeto vactiva del tipo ventanainterna, y dentro de él metemos la ventana interna seleccionada en este momento, ejecutando el método getSelectedFrame: ventanainterna vactiva = (ventanainterna) panelInterno.getSelectedFrame();
Ahora ya podemos trabajar con vactiva sabiendo que se refiere a la ventana activa. Lo que se hace a continuación es cerrar la ventana activa vactiva usando el método dispose típico de los objetos de ventana. 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. Primero se extrae la ventana activa, usando el método getSelectedFrame, almacenándola en una variable llamada vactiva. ventanainterna vactiva = (ventanainterna) panelInterno.getSelectedFrame();
Si esta variable es null, entonces es que no hay ninguna ventana activa. Si es distinta de null, se trabaja con ella. En el ejemplo anterior extraemos el texto de la barra de título de la ventana y lo mostramos en un JOptionPane. (Recuerda que hemos programado la apertura de las ventanas internas de forma que en la barra de título aparezca el camino de la imagen)
9. Ejecuta el programa y comprueba el funcionamiento de la opción del menú Info. 10. Se ha visto que a través del método getSelectedFrame propio de los JDesktopPane se puede acceder a la ventana activa. Pero, ¿cómo puedo acceder a otra ventana interna aunque no esté activa? Para hacer esto, la clase JDesktopPane posee un método llamado getAllFrames la cual devuelve un vector conteniendo todas las ventanas internas que hay actualmente en el JDesktopPane.
11. Para practicar con el método indicado en el punto anterior, añade al menú Archivo una nueva opción llamada Cerrar Todo:
12. Accede al evento actionPerformed de la nueva opción y programa lo siguiente:
13. Analicemos el código anterior. Lo primero que tienes que observar es el uso de getAllFrames. Este método devuelve un vector conteniendo todas las ventanas internas actuales. En nuestro código, almacenamos estas ventanas en un vector llamado v. JInternalFrame v[] = panelInterno.getAllFrames(); A continuación, recorremos todo el vector y vamos cerrando cada ventana almacenada en el vector. Como puedes observar, este código hace que se cierren todas las ventanas de imagen abiertas.
14. Ejecuta el programa y comprueba el funcionamiento de la opción Cerrar Todo. 15. Este código es un ejemplo de actuación sobre todas las ventanas internas abiertas. A continuación usaremos esta misma idea para organizar las ventanas dentro del panel interno. Añade las siguientes opciones al menú:
16. La opción Cascada organizará las ventanas internas abiertas en cascada. Para ello entra en el evento actionPerformed de la opción y programa lo siguiente:
17. Analicemos el código. Observa de nuevo el uso de getAllFrames para almacenar todas las ventanas internas abiertas en un vector v: JInternalFrame v[] = panelInterno.getAllFrames(); A continuación se recorre el vector y se asigna a cada ventana interna (cada elemento del vector) un tamaño con el método setSize y una posición con el método setLocation. Las posiciones de cada ventana van variando para situar cada ventana una encima de la otra. El vector se recorre al revés, desde la última ventana a la primera para mejorar la visualización de dichas ventanas.
18. Ejecuta el programa y prueba el funcionamiento de la opción Cascada. Se recomienda que primero abra varias ventanas y luego pulse esta opción.
CONCLUSIÓN En la programación MDI siempre actúan dos elementos: - Un panel interno JDesktopPane, el cual contendrá las ventanas internas. - Una clase del tipo JInternalFrame, la cual definirá el diseño de las ventanas internas. El panel interno posee diversos métodos que permiten acceder a las ventanas actualmente abiertas dentro de él. Entre estos métodos podemos destacar: - getSelectedFrame, que devuelve la ventana interna activa en el momento actual. - getAllFrames, que devuelve un vector de JDesktopPane, conteniendo todas las ventanas internas abiertas en el panel interno. Gracias a estos dos métodos podemos acceder a las ventanas internas y actuar sobre ellas.
EJERCICIO GUIADO. BASES DE DATOS
Recapitulando… GUI y PROCESO 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… Hay que distinguir por tanto entre el GUI y el Proceso de Datos. El GUI (interfaz gráfica de usuario) es el conjunto de elementos que permiten al usuario comunicarse con el programa. Estos elementos le permiten al usuario introducir datos, dar órdenes al programa y visualizar los resultados obtenidos. Para entendernos, el GUI es básicamente el diseño de las ventanas del programa. 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. Todo lo anterior se puede representar gráficamente de la siguiente forma:
Datos, órdenes
Datos, órdenes
Resultados
Resultados Usuario
Cálculos, procesos, acciones…
GUI Interfaz de usuario Ventanas, botones, menús, etc…
Programación interna: Procedimientos, 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: -
Almacenar datos producidos por la empresa: facturas, datos de clientes, productos, gastos, ingresos, trabajadores, etc…
-
Visualizar dichos datos.
-
Modificar / Eliminar dichos datos.
-
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. Una Base de Datos no es solamente un conjunto de datos almacenados en un mismo sitio. Hay que tener en cuenta que para que estos datos sean fáciles de manipular, es necesario que tengan una organización determinada. Una Base de Datos mal organizada se convierte simplemente en un cajón de sastre donde resulta imposible encontrar lo que se busca. 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 Añadiendo el concepto de Base de Datos a la idea de usuario, GUI y Proceso de Datos, podemos representar gráficamente un programa como sigue:
Datos, órdenes, consultas a la base de datos
Datos, órdenes, consultas a la base de datos
Resultados
Resultados Usuario
Cálculos, procesos, acciones, Acceso a la base de datos
GUI Interfaz de usuario Ventanas, botones, menús, etc…
Resultados de la consulta a la base de datos
BASE
Programación interna: Procedimientos, funciones, clases, etc…
SQL
Consultar la base de datos. Añadir, modificar, eliminar datos.
DE DATOS
Analicemos el gráfico anterior: 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. 6. Para acceder a la base de datos, el módulo de Proceso de Datos usará un lenguaje ideado para el acceso a bases de datos llamado SQL. 7. Gracias al lenguaje SQL, el módulo de Proceso de Datos obtendrá los datos necesarios que pedía el usuario (por ejemplo el listado de clientes) o bien los datos necesarios para realizar el cálculo (los ingresos de cada día del mes) 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.
Teniendo en cuenta lo visto, para la creación de un programa hay que: -
Diseñar un GUI agradable, cómodo y fácil de usar. Diseñar la base de datos de forma que el acceso a datos sea rápido. Hacer el programa de forma que responda a las peticiones del usuario transmitidas por el GUI accediendo a la base de datos y obteniendo información de ella, o bien realizando acciones en ella.
GESTOR DE BASE DE DATOS 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.
DISEÑO DE BASE DE DATOS. MODELO ENTIDAD - RELACIÓN 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 La empresa MANEMPSA (Mantenimiento de empresas S.A.) se encarga de realizar todo tipo de reparaciones y limpieza en los locales de sus clientes. 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. A la empresa le interesa almacenar información sobre las entidades. Es decir, le interesa almacenar información sobre los clientes, los trabajadores, los servicios y los coches. La información que se quiere almacenar de cada entidad se denomina atributos de una Entidad. Por ejemplo, de los clientes, se quiere almacenar las siguientes propiedades: el CIF de la empresa, el nombre, etc... A continuación se indican los atributos que se almacenarán de cada entidad, teniendo en cuenta el supuesto: Entidad Clientes Atributos: CIF, nombre empresa, dirección, teléfono1, teléfono2. Entidad Trabajadores Atributos: nombre, apellidos, DNI, sueldo, fecha de entrada. Entidad Servicios Atributos: fecha, tipo, cantidad, comentario. Entidad Coches Atributos: matrícula, marca, modelo, año de compra.
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. Los Atributos Clave distinguen a cada elemento 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. Es conveniente asignar un atributo clave para cada entidad. En algunos casos podemos elegir uno de los atributos de la entidad como atributo clave, en otros casos ninguno de los atributos de la entidad podrá ser atributo clave y entonces tendremos que añadir uno nosotros. Veamos los atributos clave de cada entidad: Entidad Clientes: El atributo clave será el CIF. Entidad Trabajadores: Se puede elegir como atributo clave el DNI. Entidad Coches: Se puede elegir como atributo clave la matrícula.
Entidad Servicios. 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 tener el mismo comentario, o no tener comentario en absoluto: el atributo comentario 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”. En nuestro ejemplo, añadiremos un atributo “número” que será el número de servicio realizado. Cada servicio tendrá un número distinto, por lo que el atributo número será el atributo clave. Así pues, los atributos de la entidad Servicios serán los siguientes: Entidad Servicios Atributos: fecha, tipo, cantidad, comentario, número. Y el atributo número será su atributo clave.
5. Relaciones entre entidades. Las entidades se relacionan entre sí. Es necesario distinguir en el supuesto cuales son estas relaciones. Veamos: Un Trabajador realiza Servicios. Por lo tanto, las entidades Trabajadores y Servicios ser relacionan. Un Servicio se realiza a un Cliente. Por lo tanto las entidades Servicios y Clientes se relacionan. Un Coche lo usa un Trabajador. Por lo tanto las entidades Coche y Trabajadores se relacionan. Estas son las relaciones: Coches --- Trabajador --- Servicios --- Clientes
6. Cuando se establecen las relaciones, hay relaciones que están implícitas. Por ejemplo, no se ha establecido una relación entre Trabajadores y Clientes: “Un Trabajador hace trabajos a Clientes.” No está establecida una relación directa entre ambas entidades, pero sí se relacionan a través de la entidad Servicios: Trabajador --- Servicios --- Clientes Así pues, en realidad, trabajadores y clientes se relacionan, a través de la entidad servicios.
7. Cardinalidad de las relaciones o Tipo de relaciones. Según la forma en que se relacionen dos entidades, tenemos tres tipos de relaciones: Relaciones 1 a 1 En este tipo de relación, un elemento de la primera entidad se relaciona con un elemento de la segunda entidad, y viceversa. En nuestro ejemplo, la relación entre Coches y Trabajadores es del tipo 1 a 1, ya que un coche pertenece a un solo trabajador, y ese trabajador solo usa ese coche. Relaciones 1 a Muchos En este tipo de relación, un elemento de la primera entidad se relaciona con muchos elementos de la segunda, pero un elemento de la segunda, se relaciona con uno solo de la primera. En nuestro ejemplo, la relación Trabajadores – Servicios es del tipo 1 a Muchos. Observa: un trabajador realiza a lo largo de su vida laboral muchos servicios, pero un servicio es realizado solo por un trabajador (por lo que nos dice el supuesto). La relación entre Clientes y Servicios es también del tipo 1 a Muchos. Observa: un cliente solicita a lo largo de su existencia muchos servicios a la empresa, pero cada servicio se realiza a un solo cliente (por lo que nos dice el supuesto). Relaciones Muchos a 1 Este tipo de relación es el mismo que el anterior. Basta con “darle la vuelta” a la relación. Por ejemplo, se ha visto que la relación Trabajadores – Servicios es del tipo 1 a Muchos. Por tanto, la relación Servicios – Trabajadores es del tipo Muchos a 1. Relaciones Muchos a Muchos En este tipo de relación un elemento de la primera entidad se relaciona con muchos elementos de la segunda entidad, y viceversa. En nuestro supuesto no tenemos ninguna relación de este tipo, pero supongamos la siguiente relación entre Profesores y Cursos:
“Un profesor puede dar varios cursos, y un curso es impartido por varios profesores” Esta relación sería del tipo Muchos a Muchos.
8. Averiguar el tipo de relaciones. 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. En nuestro supuesto, las relaciones tienen el siguiente tipo: Coches -1---1- Trabajadores -1---M- Servicios -M---1- Clientes Relación Coches – Trabajadores. Tipo 1 a 1. Relación Trabajadores – Servicios. Tipo 1 a Muchos. Relación Servicios – Clientes. Tipo Muchos a 1.
9. Intercambio de atributos clave entre entidades relacionadas. Para hacer efectivas las relaciones de la base de datos, es necesario intercambiar los atributos claves entre las entidades relacionadas siguiendo ciertas reglas. Las reglas son las siguientes: -
Primera Regla. Si dos entidades se relacionan de forma 1 – 1, entonces debe pasarse el atributo clave de una de ellas a la otra, y viceversa. En nuestro ejemplo, las entidades Coches y Trabajadores se relacionan de forma 1 a 1. Esto implica que es necesario añadir el atributo clave de Coches a Trabajadores, y viceversa. Así pues, será necesario añadir el atributo matrícula a Trabajadores, y el atributo DNI a Coches. Por tanto, las entidades Trabajadores y Coches quedarán así: Entidad Trabajadores Atributos: nombre, apellidos, DNI, sueldo, fecha de entrada, matricula Entidad Coches Atributos: matrícula, marca, modelo, año de compra, DNI
-
Segunda Regla. Si dos entidades se relacionan de forma 1 – Muchas, entonces, se debe pasar el atributo clave de la entidad de la parte de la relación 1, a la entidad de la parte de la relación Muchas.
En nuestro ejemplo, las entidades Trabajadores --- Servicios se relacionan de forma 1 a Muchas, por tanto, será necesario traspasar el atributo clave de la entidad Trabajadores a la entidad Servicios, con lo que quedarán así:
Entidad Trabajadores Atributos: nombre, apellidos, DNI, sueldo, fecha de entrada, matricula Entidad Servicios Atributos: fecha, tipo, cantidad, comentario, número, DNI. 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 Atributos: fecha, tipo, cantidad, comentario, número, DNI, CIF. Entidad Clientes Atributos: CIF, nombre empresa, dirección, teléfono1, teléfono2.
10. Claves Foráneas. La razón de traspasar el atributo clave de una entidad a otra es que exista un elemento de unión, en ambas entidades relacionadas. 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 Atributos: matrícula, marca, modelo, año de compra, DNI Entidad Trabajadores Atributos: nombre, apellidos, DNI, sueldo, fecha de entrada, matricula Entidad Servicios Atributos: fecha, tipo, cantidad, comentario, número, DNI, CIF.
Entidad Clientes Atributos: CIF, nombre empresa, dirección, teléfono1, teléfono2.
No confundas el concepto de atributo clave, con el concepto de clave foránea.
11. Modelo E-R. 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
Servicios
Trabajadores M
1
1
1
Clientes
Coches DNI
matrícula año
marca
CIF
M
1
modelo
Tfno2
CIF Tfno1
nombre dirección
El gráfico anterior es lo que se llama un Modelo Entidad Relación y es una representación de la base de datos que acabamos de diseñar. En este gráfico observarás lo siguiente: -
Las entidades se representan en recuadros. Los atributos de cada entidad se representan en óvalos. El atributo clave de cada entidad se subraya. Las relaciones entre entidades se representan usando líneas con rombos. Se indica el tipo de relación (1 a 1, o 1 a Muchos) añadiendo a la línea de la relación un 1 o una M para indicar el tipo de relación.
CONCLUSIÓN Las Bases de Datos son elementos vitales en la creación de aplicaciones para empresas. Para diseñar una Base de Datos hay que especificar los siguientes elementos: - Entidades cuya información queremos almacenar. - Atributos de dichas entidades. - Atributos claves para dichas entidades. - Relaciones entre entidades. - Definir el tipo de relaciones. - Asignar las claves foráneas según el tipo de relación. Una vez especificados estos elementos, todo el diseño se puede representar gráficamente a través de un modelo gráfico llamado Modelo Entidad-Relación.
EJERCICIO GUIADO. BASES DE DATOS. Traspaso a tablas del Modelo E-R
Bases de Datos Relacionales Como se ha comentado en la hoja anterior, una base de datos consiste en un conjunto de datos bien organizados. La forma de organizar estos datos es a través de tablas. Estas tablas contendrán la información que se desea almacenar. 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.
Traspaso a Tablas de un Modelo E-R 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
Servicios
Trabajadores M
1
1
1
Clientes
Coches DNI
matrícula año
marca
CIF
M
1
modelo
Tfno2
CIF Tfno1
nombre dirección
1. Tablas de la base de datos. 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: Tabla Coches, Tabla Trabajadores, Tabla Servicios, Tabla Clientes. 2. Cabecera de la tabla. Campos. 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. Los Campos se corresponden con las distintas columnas de la tabla. En un Modelo E-R los campos vienen representados por los atributos de las entidades. 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 Matrícula
Marca
Modelo
Año
DNI
Tabla Trabajadores DNI
Nombre
Apellidos
Sueldo
Fecha
Matrícula
Tabla Servicios Número
Fecha
Tipo
Cantidad
Comentario DNI
CIF
Tabla Clientes CIF
Nombre
Dirección
Tfno 1
Tfno 2
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. Sin embargo, de momento, no es necesario hacer nada más.
5. Veamos un ejemplo del aspecto que podría tener la base de datos en un momento dado. Como podrás observar, las tablas estarán rellenas de información:
Tabla Coches Matrícula 3322-ASR 4433-ABB
Marca SEAT CITROEN
Modelo Ibiza Saxo
Año 2000 2001
DNI 21.123.123-A 12.321.567-B
Tabla Trabajadores DNI Nombre 21.123.123-A Ana 12.321.567-B Juan
Apellidos Ruiz Pérez
Sueldo 1200 1120
Fecha 02-03-2002 04-05-2002
Matrícula 3322-ASR 4433-ABB
Tabla Servicios Número
Fecha
Tipo
Cantidad
1 2
12-04-2004 22-05-2005
Limpieza Fontanería
300 238
3
21-12-2005
Electricidad
130
4
10-11-2006
Fontanería
250
Comentario DNI Arreglo tuberías Revisión cableado
CIF
21.123.123-A 12.321.567-B
B11223212 B22334466
21.123.123-A
B33221111
12.321.567-B
B11223212
Tabla Clientes CIF B11223212 B22334466 B33221111
Nombre Seguros Segasa Academia La Plata Papelería Cuatro
Dirección C/Ancha 2 C/La Plata 10 C/Larga 8
Tfno 1 956344334 956302323 956305060
Tfno 2 629234323
Si observas las tablas y sus claves foráneas, puedes llegar a conclusiones que afectan a varias tablas. Por ejemplo: Observando las tablas Coches y Trabajadores, puedes llegar a la conclusión de que Ana conduce el SEAT y Juan el Citroen. Observando las tablas Servicios, Clientes y Trabajadores, puedes llegar a la conclusión de que el servicio de Fontanería realizado el 22 de mayo de 2005 lo realizó el trabajador Juan a la empresa Academia La Plata. Etc. Estas conclusiones se producen al relacionar las tablas gracias a la existencia de campos de unión entre ellas (claves foráneas)
CONCLUSIÓN Las Bases de Datos que se usarán son del tipo Relacional. 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: - Cada entidad se corresponde con una tabla. - Los atributos de una entidad son los campos de una tabla. - La existencia de claves foráneas en las tablas garantizan que se puedan relacionar.
EJERCICIO GUIADO. BASES DE DATOS. Relaciones Muchas a Muchas
El problema de las relaciones Muchas a Muchas En las hojas anteriores se ha visto que entre las entidades se pueden establecer relaciones de tres tipos: Relaciones 1 a 1. Relaciones 1 a Muchas (o Muchas a 1). Relaciones Muchas a Muchas.
De forma premeditada, se ha evitado tanto en las explicaciones como en los ejercicios la aparición de relaciones Muchas a Muchas, ya que estas relaciones presentan muchos problemas a la hora de realizar su traspaso a tablas para luego crear la base de datos e introducirla en un programa gestor de bases de datos. Así pues las relaciones Muchas a Muchas se consideran relaciones “prohibidas” que deben ser evitadas a toda costa. Básicamente, las relaciones Muchas a Muchas pueden ser anuladas convirtiéndolas en relaciones 1 a Muchas (o Muchas a 1) De hecho, una buena base de datos solo contendrá relaciones 1 a 1 o 1 a Muchas, y se considera que ha sido mal diseñada si aparece alguna relación Muchas a Muchas. En esta hoja guiada se verá qué hacer cuando aparezca una relación Muchas a Muchas
EJERCICIO GUIADO Nº 1
SUPUESTO “ACADEMIA” Interesa almacenar cierta información sobre una academia. Concretamente se quiere almacenar la siguiente información: Interesa almacenar información sobre los alumnos de la academia. Interesa almacenar el nombre del alumno, los apellidos, el DNI y la fecha de nacimiento. Interesa almacenar información sobre los cursos que se da en la academia. Interesa almacenar el código del curso, el nombre del curso, el número de horas y el nombre del profesor que lo imparte. 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.
PASO A MODELO ENTIDAD – RELACIÓN 1. Entidades participantes: Estudiando el supuesto anterior, se ve claro que existen tres entidades claras: alumnos, cursos y libros. 2. Atributos de cada entidad y Atributo clave: No es complicado deducir los atributos de cada entidad. Son los siguientes (subrayado el atributo clave): 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: Veamos las 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. Y no hay más relaciones en la base de datos.
4. Tipos de relaciones.
Veamos la relación “los alumnos hacen cursos”: Un alumno puede apuntarse a muchos cursos. Por otro lado, en un curso se apuntan muchos alumnos. Es una relación Muchas a Muchas:
Alumnos
M
M
Cursos
Veamos ahora la relación “los libros se prestan a los alumnos”: 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) Por tanto tenemos también relación Muchas a Muchas:
Alumnos
M
M
Libros
5. Prohibición de las relaciones Muchas a Muchas. Tal como se ha explicado al principio de la hoja guiada, las relaciones Muchas a Muchas están prohibidas y tienen que ser eliminadas del Modelo Entidad Relación. 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. La aparición de relaciones Muchas a Muchas es debido a la existencia de una entidad intermedia que no hemos tenido en cuenta, ya sea por la falta de información del enunciado, o bien porque se ha dado por sabida. 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:
Entidad 1
M
M
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.
7. Eliminación de la relación Muchas a Muchas “los alumnos hacen cursos”. 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. Estas reservas o matrículas (o como quiera llamarlo) es la entidad intermedia que habíamos pasado por alto, y que nos resuelve el problema de la relación Muchas a Muchas. Veamos que sucede si ponemos la entidad matrículas entre las entidades alumnos y cursos.
Alumnos
Matrículas
Cursos
Aparecen dos nuevas relaciones: “los alumnos se matriculan”, y “una matrícula es para un curso”.
8. Estudio de las nuevas relaciones. Cuando añadimos la entidad intermedia a la relación Muchas a Muchas, aparecen dos relaciones nuevas que suelen ser del tipo 1 a Muchas. Veamos: Relación “los alumnos se matriculan”. Un alumno puede matricularse muchas veces (se puede apuntar a muchos cursos). Así pues un alumno realiza o rellena varias matrículas. Sin embargo, una matrícula pertenece a un solo alumno. Por tanto es una relación 1 a Muchas:
Alumnos
1
M
Matrículas
Cursos
Relación “una matrícula es para un curso”. 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) Por tanto es una relación 1 a Muchas:
Alumnos
1
M
Matrículas
M
1
Cursos
9. Solución del problema Muchas a Muchas: Finalmente, al descubrir la entidad intermedia de la relación Muchas a Muchas, esta relación ha desaparecido y se ha convertido en dos relaciones 1 a Muchas, solucionándose el problema.
10. Atributos de la Entidad Intermedia. Habrá que asignar primero un atributo clave a la entidad intermedia. En el ejemplo, será interesante asignar un número de matrícula, de forma que no haya dos matrículas con el mismo número. En la entidad matrículas se puede almacenar otras informaciones, como por ejemplo lo que paga el alumno por hacer el curso.
También se podría almacenar la nota final obtenida por el alumno. 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…
Alumnos
1
M
Matrículas
M
1
Cursos
…tendremos que pasar el campo DNI desde la entidad alumnos a matrículas, y el campo código curso desde la entidad cursos a matrículas, debido a la regla correspondiente a las relaciones 1 a Muchas. 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)
11. Solución de la relación “libros son prestados a alumnos” Veamos la solución de la otra relación problemática Muchas a Muchas:
Alumnos
M
M
Libros
12. Entidad intermedia… Si estudiamos bien la relación entre alumnos y libros de la biblioteca, nos daremos cuenta que existe una entidad intermedia que hace referencia a cada préstamo del libro. 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. Con esta entidad, la relación queda así:
Alumnos
Préstamos
Libros
13. Estudio de las nuevas relaciones… Relación Alumnos – Préstamos: “Los alumnos piden préstamos de 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. Relación Préstamos – Libros: “Un préstamo es de un libro” Un libro puede participar en muchos préstamos (realizados a distintos alumnos en momentos diferentes), pero cada préstamo en concreto hace referencia a un libro solamente. Relación 1 a Muchas.
Alumnos
1
M
Préstamos
M
1
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. La idea de “ficha” es equivalente a la idea de “préstamo”. O aun mejor, se podría hablar de “ficha de préstamos”.
14. Atributos de la nueva entidad. Así pues, con la creación de la entidad préstamos se ha solucionado el problema de la relación Muchas a Muchas. Ahora hay que determinar los atributos que tendrá la nueva entidad préstamos. Atributo clave. Se puede asignar un número de préstamo a cada préstamo para distinguirlos entre sí. 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) Otros atributos interesantes. Se puede añadir a esta entidad atributos como fecha de préstamo, fecha de devolución para controlar aún mejor la información de cada préstamo en concreto.
Por lo tanto, la entidad Préstamos del ejemplo quedará con los siguientes atributos:
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 código curso
pago
Cursos
1
número
M código curso
DNI
Matrículas
nombre
M
autor fecha DNI
tema
1 1
M
Alumnos
Préstamos
M
1 Libros
nombre apellidos
código libro
número
título código libro
DNI fecha préstamo
fecha devolución
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 Al realizar el diseño de una Base de Datos pueden aparecer relaciones Muchas a Muchas. 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. Al añadir la entidad intermedia, desaparece la relación Muchas a Muchas y aparecen dos relaciones 1 a Muchas, solucionándose el problema. 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
Gestor de Base de Datos. 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. El objetivo de esto, es facilitar la creación de la base de datos en el programa gestor de base de datos que se vaya a usar. 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) Es necesario tener claro el diseño (organización en tablas) de la base de datos antes de poder crear esta usando el programa gestor de base de datos elegido.
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. Este programa permite la definición de las tablas, la creación de consultas y el acceso a la base de datos usando el lenguaje SQL, vital para el manejo de la base de datos desde la aplicación. 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
En hojas anteriores se creó la base de datos de la empresa MANEMPSA, una empresa encargada de proporcionar servicios de mantenimiento a otras empresas. Después de realizar el Modelo Entidad – Relación y de hacer el traspaso a tablas, el resultado fue el siguiente:
Tabla Coches Matrícula
Marca
Modelo
Año
DNI
Tabla Trabajadores DNI
Nombre
Apellidos
Sueldo
Fecha
Matrícula
Tabla Servicios Número
Fecha
Tipo
Cantidad
Comentario DNI
CIF
Tabla Clientes CIF
Nombre
Dirección
Tfno 1
Tfno 2
En este ejercicio guiado se creará la base de datos MANEMPSA formada por las tablas anteriores usando el programa Access. Para ello, siga los pasos que se indican a continuación: 1. Abra el programa Access.
2. Para crear una base de datos nueva, active la opción del menú Archivo – Nuevo. Y en la parte derecha de la ventana Base de Datos en Blanco.
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 Matrícula
Marca
Para ello, haga lo siguiente:
Modelo
Año
DNI
6. Introduzca el nombre del primer campo: “Matricula”, y a continuación elija el tipo de datos Texto. En la zona de comentarios no escriba nada. 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. Así pues cambia el valor 50 por 10.
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. Es habitual confundirse y asignar el tipo de datos Numérico a un DNI, pero tenga en cuenta que un DNI contiene una letra, y puede contener espacios o guiones según la forma en que lo represente. Esto hace que un DNI no sea un número válido desde un punto de vista matemático. El DNI en realidad es del tipo de datos Texto. No ponga DNI con puntos, ya que los nombres de campos en Access no admiten puntos. El tamaño del DNI será de 15:
12. Ya están añadidos todos los campos de la tabla, ahora hay que indicar cual de ellos es el campo clave. El campo clave de la tabla es la matrícula, tal como se definió a la hora de crear el modelo e-r. Así pues, haz clic sobre matrícula y pulsa el botón con forma de llave amarilla, llamado Clave Principal. Aparecerá una llave pequeña al lado del campo y de esta forma el campo matrícula quedará marcado como campo clave.
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.
14. Introduce el nombre de la tabla: “Coches”.
15. Acabas de crear la primera tabla de la base de datos. En la ventana principal de Access verás en el listado de tablas la tabla que acabas de crear.
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 DNI
Nombre
Apellidos
Sueldo
Fecha
Matrícula
19. Active la opción Crear Tabla en Vista Diseño. 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:
25. Haz que el campo DNI sea el campo clave:
26. Cierra la ventana de diseño y guarda la tabla con el nombre Trabajadores:
27. Ya tenemos creadas dos de las cuatro tablas de la base de datos:
28. Ahora le toca el turno a la tabla “Clientes”, la cual se muestra a continuación: Tabla Clientes CIF
Nombre
Dirección
Tfno 1
Tfno 2
29. Activa la opción Crear Tabla en Vista Diseño. 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. Tenga en cuenta que si quiere almacenar un teléfono de esta forma: 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 Número
Fecha
Tipo
Cantidad
36. Activa la opción Crear Tabla en Vista Diseño.
Comentario DNI
CIF
37. Añade el campo Número. Su tipo de datos será Autonumérico: 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. El problema es que no podemos controlar el número que se asigna a cada servicio. Por ejemplo, si el siguiente servicio debe tener el número 54 y queremos asignarle el número 100, no podremos hacerlo. Para nuestro ejemplo, el tipo de datos Autonumérico será suficiente.
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:
Luego cierra la ventana de la tabla Trabajadores. 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:
Luego cierra la ventana de introducción de coches.
49. Haz ahora doble clic sobre la tabla Clientes. Introduciremos los datos de varios de los clientes de la empresa:
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. El concepto de registro hace referencia a las filas de una tabla. 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. 53. La base de datos que ha creado es un fichero llamado MANEMPSA. Al crearlo lo guardó dentro de la carpeta Mis Documentos. Eche un vistazo al contenido de la carpeta Mis Documentos y busque allí el fichero MANEMPSA. Si hace doble clic sobre el fichero volverá a abrir la base de datos.
NOTA: Al abrir un fichero de base de datos de Access de la versión 2003 el programa le hará varias preguntas, las cuales tendrá que contestar de la siguiente forma: Advertencia de seguridad, las expresiones no seguras no están bloqueadas ¿Desea bloquearlas? NO ¿Desea abrir el archivo? SI ¿Desea abrir el archivo o cancelar la operación? Abrir
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.
NOTA. El programa Microsoft Access es muy amplio y contiene múltiples opciones de manejo de bases de datos, aunque solo lo usaremos para la creación de tablas y de consultas. Se recomienda al alumno buscar información adicional sobre este programa. En Internet podrá encontrar múltiples tutoriales de aprendizaje de Access.
CONCLUSIÓN La información caótica proporcionada por el cliente que encarga el programa se organiza en tablas. Estas tablas conforman la base de datos. La base de datos hay que introducirla en un programa gestor de bases de datos, como por ejemplo Access. En Access se crea el fichero que contendrá la base de datos, y dentro de él se diseñan las distintas tablas de la base de datos. 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.
Las tablas contendrán filas de información llamadas registros. Es posible introducir registros directamente en las tablas creadas desde Access. 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
Operaciones básicas en una base de datos El trabajo con una base de datos consiste básicamente en hacer lo siguiente: -
Añadir nuevos registros a las tablas (guardar nueva información) Eliminar registros de las tablas (eliminar información de la base de datos) Modificar registros (modificar la información guardada) Consultar las tablas.
Consultas En esta hoja guiada nos centraremos en la realización de 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. 2. Para crear una consulta active la opción Consultas en la parte izquierda:
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:
Aparece un recuadro con los campos de la tabla Servicios
7. Como no queremos consultar más tablas podemos pulsar el botón Cerrar.
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. Accede a la casilla de Criterios que se encuentra debajo del campo Cantidad y escribe allí la siguiente condición: > 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:
15. Ahora estamos de nuevo dentro de la ventana de diseño:
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).
23. Vuelve a la ventana de diseño pulsando el botón Vista:
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. Activa de nuevo el botón Mostrar Tabla y agrega la tabla Clientes.
25. Observa la relación automática que aparece entre Clientes y Servicios. Esto es gracias al campo de unión que es el campo CIF.
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:
27. Añade el campo Nombre de la tabla Clientes y comprueba el resultado.
28. Vuelve a la vista de diseño.
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
A continuación se muestran otras formas de indicar criterios en las consultas
Criterios para campos numéricos
Campos
Coste
Criterios
200
Campos
Coste
Criterios
>200
Campos
Coste
Criterios
>=200
Campos
Coste
Criterios
<200
Campos
Coste
Criterios
<=200
Buscar aquellos registros cuyo Coste sea igual a 200
Buscar aquellos registros cuyo Coste sea mayor a 200
Buscar aquellos registros cuyo Coste sea mayor o igual a 200
Buscar aquellos registros cuyo Coste sea menor a 200
Buscar aquellos registros cuyo Coste sea menor o igual a 200
Campos
Coste
Criterios
<>200
Campos
Coste
Criterios
Between 200 and 300
Buscar aquellos registros cuyo Coste sea distinto de 200
Buscar aquellos registros cuyo Coste esté entre 200 y 300
Criterios para campos de tipo Fecha/Hora 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:
> 10-12-2007
Posterior al 10 del 12 del 2007
>= 10-12-2007
Posterior al 10 del 12 del 2007 (incluyendo dicha fecha)
< 10-12-2007
Anterior al 10 del 12 del 2007
<= 10-12-2007
Anterior al 10 del 12 del 2007 (incluyendo dicha fecha)
<> 10-12-2007
Distinto de 10 del 12 del 2007
Between 10-12-2007 and 20-12-2007
Entre el 10 del 12 del 07 y el 20 del 12 del 07
Criterios para campos de tipo Texto o Memo En los campos de tipo texto se pueden usar asteriscos para definir búsquedas más extensas. Observa los siguientes ejemplos:
Campos
Nombre
Criterios
José Manuel
Campos
Nombre
Criterios
José*
Buscar aquellos registros cuyo Nombre sea exactamente José Manuel: -
Encontraría a los que tengan de nombre José Manuel. No encontraría a los que se llamaran José a secas, o Manuel a secas.
Buscar aquellos registros cuyo Nombre empiece por José: -
Encontraría a los José Manuel, José María, José Luis, etc. No encontraría a los Manuel José, Antonio José, etc.
Campos
Nombre
Buscar aquellos registros cuyo Nombre termine en José: -
Criterios
*José
Campos
Nombre
Criterios
*José*
-
Encontraría a los Manuel José, Antonio José, María José, etc. No encontraría a los José Manuel, José Antonio, etc.
Buscar aquellos registros cuyo Nombre contenga la palabra José en cualquier parte: -
Encontraría a los José Manuel, Antonio José, María José, Antonio José de los Santos, etc.
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:
Campos
Criterios
Nombre
*José
Sueldo
>1000
Busca aquellas personas que tengan un nombre que termine en José y cobren más de 1000 euros.
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
Criterios
*José
>1000 300
Antonio
Muestra aquellas personas que tengan un nombre que termine en José y cobren más de 1000 euros. Muestra también aquellas personas que cobran 300 euros Y muestra también aquellas personas que se llamen Antonio.
NOTA. La creación de consultas en Microsoft Access es un campo amplio. Se recomienda al alumno buscar información adicional sobre el tema. En Internet podrá encontrar múltiples tutoriales de aprendizaje de Access.
CONCLUSIÓN Una consulta muestra una parte de información de toda la base de datos. Se muestran determinados campos y también aquellos registros que cumplan un criterio determinado. En Access se pueden diseñar consultas y almacenarlas permanentemente. 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: - Indicar las tablas que contienen los campos necesarios. - Indicar los campos que se quieren visualizar. - Indicar el criterio de selección de registros. 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
Lenguaje de Consulta SQL El lenguaje SQL (lenguaje de consulta estructurado) es un lenguaje que permite “actuar” sobre una base de datos. Con este lenguaje se pueden construir órdenes que permiten hacer lo siguiente (entre otras cosas): -
Añadir registros a las tablas. Modificar registros de las tablas. Eliminar registros de las tablas. Realizar Consultas sobre las tablas.
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.
Programa Java
ÓRDENES SQL añadir, modificar, eliminar
Base de Datos
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 Java
Base de 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. A continuación se comentarán las reglas básicas de este lenguaje.
Creación de consultas en SQL
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)
Código base en SQL para realizar consultas Para consultar una base de datos usará un código general como el que sigue: SELECT campos a visualizar FROM tablas donde se encuentran dichos campos WHERE condiciones que deben cumplir los registros ORDER BY forma de ordenar la consulta; 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. Este código debe terminar siempre con punto y coma ; A continuación se verán ejemplos de uso de este código general.
Visualizar una tabla entera (todos los campos y todos los registros) Ejemplo: “Visualizar la tabla Clientes” 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) Ejemplo: “Visualizar CIF, nombre y Direccion de todos los clientes” SELECT clientes.CIF, clientes.nombre, clientes.direccion FROM clientes;
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 la cláusula WHERE para aplicar una condición al resultado.
Ejemplo: “Visualizar el nombre, apellido y sueldo de aquellos trabajadores que cobren un sueldo entre 800 y 2000 euros” SELECT trabajadores.nombre, trabajadores.apellidos, trabajadores.sueldo FROM trabajadores WHERE trabajadores.sueldo BETWEEN 800 AND 2000;
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
Visualizar el contenido de una tabla ordenado Ejemplo: “Visualizar la tabla de trabajadores ordenada por sueldo de menor a mayor” 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” SELECT trabajadores.nombre, trabajadores.apellidos, trabajadores.sueldo FROM trabajadores ORDER BY trabajadores.sueldo DESC;
Observa el uso de DESC para indicar una ordenación descendente.
Ejemplo: “Visualizar nombre, apellidos y sueldo de los trabajadores que cobren más de 1000 euros, ordenados por apellidos y nombre” SELECT trabajadores.nombre, trabajadores.apellidos, trabajadores.sueldo FROM trabajadores WHERE trabajadores.sueldo > 1000 ORDER BY trabajadores.apellidos ASC, trabajadores.nombre ASC;
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.
Visualizar datos de varias tablas 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” SELECT trabajadores.nombre, servicios.fecha, servicios.tipo FROM trabajadores, servicios WHERE trabajadores.DNI=servicios.DNI;
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” SELECT trabajadores.nombre, servicios.tipo, clientes.nombre FROM trabajadores, servicios, clientes WHERE trabajadores.DNI=servicios.DNI AND clientes.CIF=servicios.CIF;
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” SELECT servicios.fecha, clientes.nombre, servicios.cantidad FROM servicios, clientes WHERE servicios.CIF=clientes.CIF AND servicios.cantidad>200 ORDER BY servicios.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 Operador =
Significa… Igual que
Ejemplos WHERE cantidad = 200 WHERE tipo = ‘Limpieza’ WHERE fecha = #8-5-2006#
>
Mayor que (para números)
WHERE cantidad > 200 WHERE fecha > #8-5-2006#
Posterior a (para fechas) >=
Mayor o igual que (para números)
WHERE cantidad >= 200 WHERE fecha >= #8-5-2006#
Esa fecha o posterior (para fechas) <
Menor que (para números)
WHERE cantidad < 200 WHERE fecha < #8-5-2006#
Anterior a (para fechas) <=
Menor o igual que (para números)
WHERE cantidad <= 200 WHERE fecha <= #8-5-2006#
Esa fecha o anterior (para fechas) <>
Distinto de (para fechas, números y textos)
WHERE cantidad <> 200 WHERE fecha <> #8-5-2006# WHERE tipo <> ‘Limpieza’
Entre valor1 y valor2 (aplicable a números y fechas)
WHERE cantidad BETWEEN 100 AND 200
Like ‘cadena*’
Que empiece por cadena (aplicable a textos)
WHERE nombre LIKE ‘Jose*’
Like ‘*cadena’
Que termine por cadena (aplicable a textos)
WHERE nombre LIKE ‘*Jose’
Between...and
WHERE fecha BETWEEN #8-5-2006# AND #1-12-2006#
Like ‘*cadena*’
Que contenga cadena (aplicable a textos)
WHERE nombre LIKE ‘*Jose*’
IS NULL
Que el campo esté vacío (aplicable a números, textos, fechas)
WHERE telefono IS NULL
NOT ... IS NULL
Que el campo no esté vacío (aplicable a números, textos, fechas)
WHERE NOT telefono IS NULL
Operadores Lógicos Operador
Significa…
Ejemplos
AND
Obliga a que se cumplan las dos condiciones que une.
WHERE cantidad > 200 AND tipo = ‘Limpieza’
(Debe cumplirse que la cantidad sea mayor de 200 y que el tipo de servicio sea Limpieza)
OR
NOT
Basta con que se cumpla una sola de las dos condiciones que une.
WHERE cantidad > 200 OR tipo = ‘Limpieza’
Si no se cumple la condición, la condición global se cumple.
WHERE NOT cantidad > 200
(Basta con que la cantidad sea mayor de 200, o que el tipo de servicio sea Limpieza para que se cumpla la condición)
(Se cumple la condición si la cantidad NO es mayor de 200)
Forma de indicar los valores 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: WHERE cantidad > 200.12 Valores de texto Los valores de texto se indican rodeándolos entre comillas simples: ‘ Ejemplos: WHERE nombre = ‘Jose’
WHERE dirección LIKE ‘*avenida*’
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: Mes – Dia – Año
Ejemplos: WHERE fecha > #02-01-2005# (Significa que la fecha debe ser posterior al 1 de febrero de 2005) WHERE fecha <> #10-12-2006# (Significa que la fecha debe ser distinta del 12 de Octubre de 2006)
Forma de indicar los campos Normalmente los campos que se usan en el WHERE (y en otras cláusulas) se indican de la siguiente forma: Tabla.Campo Por ejemplo, WHERE trabajadores.sueldo > 1000 (Sueldo es un campo de la tabla trabajadores) 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, WHERE sueldo > 1000 (No existe otro campo sueldo en otras tablas de la consulta) En el caso de que el nombre del campo contenga espacios, entonces tendremos que rodear el campo con corchetes. Por ejemplo, WHERE [sueldo del trabajador] > 1000 (El campo se llama sueldo del trabajador)
EJERCICIO GUIADO Nº 1 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. 1. Entre en Mis Documentos. Allí verá la base de datos MANEMPSA. Ábrala. 2. Active la opción de Consultas para acceder al listado de consultas de la base de datos.
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.
5. El resultado es que aparece la ventana de diseño de consultas. En la parte superior izquierda de esa ventana podrás ver un botón con el texto SQL. Este botón nos permitirá crear la consulta usando el lenguaje SQL. Púlsalo.
6. Aparecerá una pantalla casi en blanco donde escribirá la consulta SQL. Observe que ya aparece la cláusula SELECT escrita:
7. Para empezar mostraremos el contenido de la tabla Trabajadores. Para ello, debe escribir la siguiente consulta SQL: 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:
9. El resultado es que verá el contenido de la tabla Trabajadores:
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: SELECT trabajadores.nombre, trabajadores.apellidos, trabajadores.sueldo, trabajadores.fecha FROM trabajadores;
13. Usa el botón Vista para ver el resultado de la consulta. Observa como ahora solo vemos los campos indicados:
14. Vuelve a la zona de edición de consultas SQL y cambia la consulta para que quede así: SELECT trabajadores.nombre, trabajadores.apellidos, trabajadores.sueldo, trabajadores.fecha FROM trabajadores WHERE trabajadores.apellidos LIKE '*ez';
Como ves, hemos añadido una cláusula where, para buscar solo aquellos trabajadores cuyo apellido termine en ez.
15. Comprueba el resultado:
16. Vuelve a la zona de edición SQL. Vamos a complicar un poco la consulta. 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. Supongamos que queremos ver el tipo de servicio realizado y el coste de cada servicio. Por otro lado, de cada trabajador solo queremos ver el nombre y los apellidos. 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. La consulta debe quedar así: SELECT trabajadores.nombre, trabajadores.apellidos, servicios.tipo, servicios.cantidad FROM trabajadores, servicios WHERE trabajadores.apellidos LIKE '*ez' AND trabajadores.DNI=servicios.DNI;
(Observa la inclusión en el FROM de la tabla servicios, y como se ha añadido una condición de unión entre la tabla trabajadores y servicios a través del campo DNI)
17. Visualiza el resultado de la consulta (botón Vista) Aparecerá lo siguiente:
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. Esto implica la inclusión de una nueva tabla (clientes) y la necesidad de relacionar la tabla servicios con la tabla clientes según el modelo E-R de esta base de datos. El campo de unión es el CIF.
Modifica la consulta para que quede de la siguiente forma: SELECT trabajadores.nombre, trabajadores.apellidos, servicios.tipo, servicios.cantidad, clientes.nombre FROM trabajadores, servicios, clientes WHERE trabajadores.apellidos LIKE '*ez' AND trabajadores.DNI=servicios.DNI AND servicios.CIF=clientes.CIF;
(Observa la inclusión de la tabla clientes en la cláusula FROM, y la adición de una nueva condición de unión, entre la tabla servicios y la tabla clientes en la cláusula WHERE. Esta condición de unión une ambas tablas usando el campo CIF)
19. Veamos el resultado de la consulta:
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. Ahora estableceremos un orden. Concretamente, ordenaremos el resultado de la consulta según apellidos del trabajador. Para ello tendremos que añadir una cláusula ORDER BY: SELECT trabajadores.nombre, trabajadores.apellidos, servicios.tipo, servicios.cantidad, clientes.nombre FROM trabajadores, servicios, clientes WHERE trabajadores.apellidos LIKE '*ez' AND trabajadores.DNI=servicios.DNI AND servicios.CIF=clientes.CIF ORDER BY trabajadores.apellidos ASC;
21. Ejecuta la consulta y observa el resultado. Ahora el listado de servicios aparece ordenado según el apellido del trabajador que lo realiza, alfabéticamente.
22. Hemos finalizado con la consulta. Ciérrela y guárdela. Puede ponerle de nombre Servicios realizados por trabajadores ez.
23. Este ha sido un ejemplo de consulta realizada en Access usando el lenguaje de consulta SQL. Este lenguaje será vital para hacer que nuestra aplicación java manipule la base de datos correspondiente.
NOTA. En Internet se pueden encontrar múltiples manuales sobre SQL. Se recomienda buscar información sobre el tema para ampliar los conocimientos aquí expuestos.
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 El lenguaje de consulta SQL permite manipular la base de datos. A través de este lenguaje, se pueden crear órdenes que permitan: - Introducir nuevos datos en la base de datos. - Eliminar datos de la base de datos. - Modificar datos de la base de datos. - Realizar consultas sobre la base de datos. Para realizar consultas en la base de datos usando el lenguaje SQL es necesario usar instrucciones SELECT, las cuales tienen la siguiente forma general: SELECT campos a visualizar FROM tablas a las que pertenecen dichos campos WHERE condiciones a cumplir, condiciones de unión de tablas ORDER BY campos por los que se ordena 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 En la hoja guiada anterior se ha visto como se pueden crear instrucciones usando el lenguaje SQL para consultar una base de datos, y, de esta forma, extraer información de ella. 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): -
Añadir nuevos registros a una tabla. Eliminar registros de una tabla. Modificar datos de una tabla.
Programa Java
ÓRDENES SQL añadir, modificar, eliminar
Base de Datos
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. Código base en SQL para añadir nuevos registros Para añadir un registro en una tabla se usa la siguiente sintaxis: INSERT INTO tabla VALUES (valor1, valor2, valor3, ..., valor n); 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: INSERT INTO trabajadores VALUES (’30.234.234-A’, ‘María’, ‘ López’, 1250.45, #01/02/2006# ‘4455-RSD’);
En esta instrucción se está introduciendo un nuevo trabajador en la tabla trabajadores. Concretamente se está introduciendo un trabajador con las siguientes características: 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: INSERT INTO tabla (campo a, campo b, campo c) VALUES (valor del campo a, valor del campo b, valor del campo c); 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: INSERT INTO trabajadores (DNI, Apellidos, Sueldo) VALUES (’30.234.234-A’, ‘ López’, 1250.45); 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. Recuerda que debes seguir ciertas reglas para introducir valores: Las cadenas se escriben entre comillas simples. Por ejemplo: ‘López’ Se usa el punto decimal en los números reales: Por ejemplo: 1250.45 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: INSERT INTO trabajadores (DNI, Apellidos, Sueldo) VALUES (’30.234.234-A’, NULL, 1250.45); Los apellidos del trabajador están vacíos en este ejemplo.
EJERCICIO GUIADO Nº 1
1. Entra en la base de datos MANEMPSA de la carpeta Mis Documentos. 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.
4. Pulsa el botón SQL que se encuentra en la parte superior izquierda de la ventana para crear una consulta SQL.
5. Aparecerá entonces el editor de consultas SQL. En él, escribe la siguiente instrucción SQL: INSERT INTO trabajadores VALUES ('33.444.333-B','Antonio','Romero',1300.5,#01/02/2006#,NULL);
Verás que lo que se pretende es introducir un nuevo trabajador. Este trabajador tendrá los siguientes datos: 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:
8. Se acaba de ejecutar la consulta. Para comprobar el resultado tendremos que ver el contenido de la tabla Trabajadores y observaremos que hay un nuevo trabajador añadido. Primero cierra la consulta, pero no la guardes.
9. Accede a la zona de tablas de la base de datos.
10. Abre la tabla trabajadores. Observa el nuevo trabajador que se ha añadido:
11. Cierra la base de datos.
Modificación de registros en SQL 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. Código base en SQL para modificar registros Para modificar los datos de los registros de una tabla se usará el siguiente código general: UPDATE tabla a modificar SET campo1 = nuevovalor1, campo2 = nuevovalor2, …, campon = nuevovalorn WHERE condición;
En la cláusula UPDATE se indica la tabla cuyos registros se van a modificar. 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 1. Entra en la base de datos MANEMPSA. 2. Accede a la zona de consultas y crea una consulta en vista diseño. 3. No agregues ninguna tabla y pulsa directamente el botón Cerrar. 4. Pulsa el botón SQL para entrar en la zona de edición de consulta SQL.
5. Escribe la siguiente instrucción SQL: 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: 7. Access avisará de que va a actualizar una fila en la tabla trabajadores y pedirá confirmación para hacerlo. Acepte la confirmación. 8. El resultado de esta instrucción SQL de acción es que se habrán modificado los datos del trabajador con DNI 33.444.333-B. Para comprobarlo accederemos a la tabla trabajadores y observaremos su contenido. 9. Cierre la consulta que está realizando (no hace falta que la guarde) 10. Acceda a la zona de tablas de la base de datos y entre en la tabla trabajadores, observe su contenido. El trabajador con DNI 33.444.333-B habrá cambiado:
11. Cierra la base de datos.
Eliminación de registros en SQL 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. Código base en SQL para eliminar registros Para eliminar registros de una tabla se usará el siguiente código general:
DELETE FROM tabla de la que se quiere eliminar WHERE condición de los registros que se eliminarán; En la cláusula DELETE FROM se indica la tabla de la que eliminaremos registros. En la cláusula WHERE se indica la condición que deben cumplir los registros que eliminaremos. Por ejemplo:
DELETE FROM trabajadores WHERE sueldo>1000; En este ejemplo se están eliminando de la tabla trabajadores aquellos trabajadores cuyo sueldo sea superior a 1000. 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. Por ejemplo, si queremos eliminar un trabajador en concreto, indicaremos su DNI en la condición:
DELETE FROM trabajadores WHERE DNI=’33.444.555-A’; 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:
DELETE FROM trabajadores; Esta instrucción eliminaría todos los registros de la tabla trabajadores.
EJERCICIO GUIADO Nº 3
11. Entra en la base de datos MANEMPSA. 12. Accede a la zona de consultas y crea una consulta en vista diseño. 13. No agregues ninguna tabla y pulsa directamente el botón Cerrar. 14. Pulsa el botón SQL para entrar en la zona de edición de consulta SQL.
15. Escribe la siguiente instrucción SQL: DELETE FROM trabajadores WHERE DNI = '33.444.333-B';
Como puedes observar, esta instrucción eliminará al trabajador con DNI 33.444.333B, que es precisamente el trabajador que se añadió en el ejercicio guiado 1.
16. Ejecuta esta instrucción de acción activando el botón Ejecutar:
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. 19. Abra la tabla trabajadores. Observe como el trabajador ha desaparecido:
20. Cierre Access.
CONCLUSIÓN El lenguaje de consulta SQL no solo permite extraer información de una base de datos, sino que también permite realizar acciones sobre la base de datos: - Introducir nuevos datos en la base de datos. - Eliminar datos de la base de datos. - Modificar datos de la base de datos. 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
Acceso a Base de Datos desde una aplicación Java 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: 1. Cargar el controlador de la base de datos. 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. 2. Crear un objeto conexión (Connection) 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. 3. Crear un objeto sentencia (Statement) 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. Es decir, a través del objeto sentencia introduciremos datos en la base de datos, eliminaremos datos, haremos modificaciones, y extraeremos datos de la base de datos. 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.
1. Entre en NetBeans. Crea un nuevo proyecto llamado AccesoBD. Dentro de este proyecto crea un paquete principal llamado paqueteprincipal y dentro de él un JFrame llamado ventanaprincipal:
2. En la parte superior de la ventana añade un botón con el texto Ver Datos Trabajadores que se llame btnVerDatos.
3. Se pretende simplemente que al pulsar el botón btnVerDatos aparezcan en un JOptionPane datos sobre los trabajadores almacenados en la base de datos.
SITUACIÓN DEL FICHERO DE BASE DE DATOS 4. Antes de empezar con la programación de nuestra aplicación, introduciremos el fichero de base de datos en la carpeta del proyecto java que estamos haciendo. Para ello, accede a la carpeta del proyecto AccesoBD. Esta carpeta se encontrará allá donde estés guardando tus proyectos:
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. 9. Ahora ya podemos volver al NetBeans y continuar con nuestro trabajo.
PREPARACIÓN DE LA APLICACIÓN JAVA PARA EL ACCESO A LA BASE DE DATOS 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 y java.sql.Statement Agrega los import correspondientes para eliminar los errores. 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
Y la forma de activar dicho controlador es a través de la instrucción: Class.forName(controlador).newInstance(); Donde controlador es una variable de cadena que contiene la cadena anterior.
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. En nuestro caso siempre usaremos Access. También puedes observar que es obligatorio encerrar el código de la carga del controlador entre try … catch para capturar cualquier error imprevisto.
15. Ahora añade el siguiente código a continuación del anterior:
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:
String user = “”; •
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:
String password = “”; •
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: "jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ="
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. Observa como indicamos el camino del fichero: Base\\MANEMPSA.MDB 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. En el código podrás ver la creación de la DSN: String DSN = "jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ="+ "Base\\MANEMPSA.MDB"; Finalmente se usa la instrucción 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. En este ejercicio guiado usaremos el objeto sentencia para averiguar información acerca de los trabajadores.
REALIZAR CONSULTAS SQL USANDO EL OBJETO SENTENCIA
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: ResultSet r = sentencia.executeQuery(“select * from trabajadores order by nombre”);
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. El método executeQuery recibe como parámetro una cadena representando la consulta SQL. No es necesario indicar el punto y coma final de la consulta SQL. El resultado de la consulta se guarda en un objeto del tipo ResultSet al que se ha llamado simplemente “r”. Los objetos ResultSet almacenan el resultado de una consulta SQL. (Será necesario incluir el import necesario para la clase ResultSet) 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. El objeto r por tanto podría representarse así:
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. 22. Añade la siguiente línea al código del actionPerformed:
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:
Lo que se ha hecho primero es declarar una variable de cadena llamada info. Luego, a esta variable se le ha asignado una concatenación de cadenas: info="El trabajador se llama "+r.getString("nombre")+" "+r.getString("apellidos")+ " y cobra "+r.getString("sueldo");
Lo interesante de esto es el método getString del objeto ResultSet r. El método getString permite extraer una cadena con el valor del campo indicado como parámetro. En nuestro caso: r.getString(“nombre”) r.getString(“apellidos”) r.getString(“sueldo”)
Extrae el nombre del trabajador actual (“Ana”) Extrae los apellidos del trabajador actual (“Ruiz”) Extrae el sueldo del trabajador actual (“1200”)
Luego se muestra la cadena info en un simple JOptionPane.
24. Ya puedes ejecutar el programa.
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): r.next(); r.previous(); r.first(); r.last(); r.beforeFirst() r.afterLast() r.absolute(n)
Mueve la flecha a la siguiente fila Mueve la flecha a la fila anterior Mueve la flecha a la primera fila Mueve la flecha a la última fila Mueve la flecha a la fila BOF Mueve la flecha a la fila EOF Mueve la flecha a la fila n del ResultSet. Las filas se empiezan a numerar por 1.
29. Haga el siguiente cambio en el actionPerformed simplemente para experimentar:
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:
En este código se ha inicializado la variable info a la cadena vacía “” y luego se ha añadido un bucle bastante interesante: r.beforeFirst(); while (r.next()) { info=info+r.getString("nombre")+" "+r.getString("apellidos")+" "+r.getString("sueldo")+"\n"; }
Analicemos este bucle: -
Lo primero que se hace es colocar explícitamente la flecha en la fila BOF, es decir, antes del primer trabajador: r.beforeFirst();
-
Luego tenemos un bucle mientras que comienza así: 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";
-
Finalmente se visualiza la variable info en un JOptionPane.
33. Ejecuta el programa y comprueba su funcionamiento. Al pulsar el botón… Aparecen los datos de todos los trabajadores de la base de datos.
34. El bucle que acabas de programar es un código “clásico” para manipular un ResultSet. Siempre que quieras recorrer todas las filas del ResultSet harás algo como esto: 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”) y getDouble(“campo”) para obtener el dato en entero o double, respectivamente. Esto nos permite el realizar operaciones con los datos extraídos del ResultSet.
37. Como ejemplo de esto último, realice la siguiente mejora al programa:
En este nuevo código se ha añadido una variable double acumuladora llamada totalsu, donde sumaremos todos los sueldos. 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. Ejecuta el programa y comprueba su funcionamiento.
38. Una vez finalizado el programa, es una buena costumbre cerrar la base de datos que estamos manejando. Esto se hace cerrando la “conexión” con la base de datos. Para hacer esto se usa el método close del objeto conexión. Esto se hará en el momento en que se finalice el programa, es decir, en el evento windowClosing de la ventana principal:
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: - Colocar el fichero de base de datos en una subcarpeta de la carpeta del proyecto java. - Preparar el acceso a la base de datos (en el constructor) * Se crearán dos objetos: conexión (Connection) y sentencia (Statement) * Se cargará el controlador del tipo de base de datos a usar * Se creará el objeto conexión indicando el fichero de la base de datos. * Se creará el objeto sentencia a partir del objeto conexión - Se usará el objeto sentencia para ejecutar consultas SQL en la base de datos. - Las consultas SQL ejecutadas en la base de datos se almacenan en objetos del tipo ResultSet
- Un objeto ResultSet tiene forma de tabla conteniendo el resultado de la consulta SQL * Los objetos ResultSet tienen métodos para seleccionar el registro de la tabla * Los objetos ResultSet tienen métodos que permiten extraer el dato de un campo en concreto.
EJERCICIO GUIADO. JAVA. ACCESO A BASE DE DATOS
Recapitulando… Para hacer una aplicación java que acceda a una base de datos se tiene que… -
Introducir la base de datos en una subcarpeta del proyecto. Preparar la base de datos desde el constructor. Usar el objeto sentencia cada vez que se quiera consultar la base de datos o actuar sobre ella. Los resultados de las consultas ejecutadas sobre la base de datos se recogerán en objetos ResultSet que contendrán los datos devueltos por la consulta. Cerrar la conexión a la base de datos cuando ya no haya que usarla más.
Consultar la Base de Datos 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. El contenido del ResultSet tiene forma de tabla, y podemos extraer la información colocándonos en la fila correspondiente del ResultSet y luego usando los métodos: 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:
1. Entre en NetBeans. Crea un nuevo proyecto llamado ServiciosBD. Dentro de este proyecto crea un paquete principal llamado paqueteprincipal y dentro de él un JFrame llamado ventanaprincipal:
2. En la parte superior de la ventana añade un botón con el texto Ver Datos Servicios que se llame btnServicios.
3. Se pretende simplemente que al pulsar el botón btnServicios aparezcan en un JOptionPane datos sobre los servicios almacenados en la base de datos.
SITUACIÓN DEL FICHERO DE BASE DE DATOS 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. Así pues, entre en la carpeta de proyecto ServiciosBD
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
6. Ahora ya podemos volver al NetBeans y continuar con nuestro trabajo.
PREPARACIÓN DE LA APLICACIÓN JAVA PARA EL ACCESO A LA BASE DE DATOS 7. Preparar nuestro proyecto para que permita el acceso a la base de datos MANEMPSA.MDB es un proceso complejo, aunque afortunadamente siempre se hace igual. Solo tiene que añadir el siguiente código a su ventana principal:
Declara los objetos globales conexión y sentencia
Haz la llamada al método PrepararBaseDatos
Recuerda que el método PrepararBaseDatos siempre será igual, solo tienes que indicar aquí el nombre de la base de datos a usar.
REALIZAR CONSULTAS SQL USANDO EL OBJETO SENTENCIA 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 select * from servicios order by cantidad la cual extrae todos los servicios almacenados en la tabla servicios ordenados por cantidad de menor a mayor. El resultado de esta consulta se almacena en un ResultSet y se usa un bucle típico que recorre el ResultSet y muestra el tipo de cada servicio y la cantidad: while (r.next()) { info=info+r.getString("tipo")+" "+r.getString("cantidad")+"\n"; }
Puedes ejecutar el programa para ver como funciona.
9. Aunque no es vital para el programa, añadamos el cierre de la conexión de la base de datos en el windowClosing de nuestra ventana:
EXTRAER FECHAS DEL RESULTSET 10. Se va a mejorar el programa de forma que se muestre de cada servicio el tipo, la cantidad y la fecha en que se hizo. Por tanto, haz el siguiente cambio en el código del actionPerformed del botón btnServicios:
Simplemente estamos cambiando la concatenación de la cadena info de forma que aparezca la fecha de cada servicio, el tipo y la cantidad.
11. Ejecuta el programa y observa el resultado.
Como se puede ver, las fechas aparecen en orden cambiado (año-mes-dia) Y además incluyen el formato de hora.
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:
Observa como ahora las fechas aparecen correctamente…
13. Estudiemos el código que acabamos de añadir: Lo primero que se ha hecho es crear varias variables de cadenas para contener el día, mes y año de la fecha así como la fecha completa. String String String String
cadfecha; //cadena para fechas caddia; //cadena para el dia cadmes; //cadena para el mes cadanio; //cadena para el año
Dentro del bucle extraemos la fecha del ResultSet y la almacenamos en la variable cadfecha: cadfecha=r.getString("fecha"); Ahora mismo, la variable cadfecha contendrá una cadena como la siguiente: 2
0
0
5
-
1
2
-
2
1
-
0
0
:
0
0
:
0
0
Para extraer el año de la cadena, extraemos los caracteres comprendidos entre la posición 0 y la posición 3. Esto se hace usando el método substring de la siguiente forma: cadanio=cadfecha.substring(0,4); Para extraer el mes de la cadena, tendremos que extraer los caracteres comprendidos entre la posición 5 y la posición 6. Esto se hace usando el método substring de la siguiente forma: 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: info=info+cadfecha+" "+r.getString("tipo")+" "+ r.getString("cantidad")+"\n";
PRESENTACIÓN DE COMAS DECIMALES 14. Ahora mejoraremos el programa para que los costes de los servicios aparezcan con coma decimal, en vez de punto decimal:
Haremos que aquí aparezcan comas, en vez de puntos…
Modifica el código de la siguiente forma:
Se ha añadido una variable de cadena llamada cadcoste que almacenará el coste de cada servicio. En el código del bucle, recogemos la cantidad en dicha variable y luego usamos el método de cadena replace para reemplazar los puntos por comas: cadcoste=r.getString("cantidad"); cadcoste=cadcoste.replace(".",",");
Finalmente, mostramos la cadena de coste en la concatenación: info=info+cadfecha+" "+r.getString("tipo")+" "+cadcoste+"\n";
Ejecuta el programa y observa el resultado:
Ahora ya tenemos las comas decimales…
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. 17. Al pulsar este botón aparecerá el listado de clientes de la empresa. Concretamente debe aparecer el nombre del cliente, el teléfono 1 y el teléfono 2. Para ello añade el siguiente código dentro del evento actionPerformed del botón.
Este código es prácticamente igual que el anterior. Simplemente ejecuta una consulta SQL usando el objeto sentencia que permite extraer el contenido de la tabla clientes, y luego recorre el ResultSet mostrando los campos nombre, teléfono 1 y teléfono 2 en un JOptionPane. 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. El resultado de la consulta se almacena en un objeto del tipo ResultSet. Al extraer el valor de un campo fecha desde el objeto ResultSet observaremos que tiene el siguiente formato: Año – Mes – Dia – Hora : Minutos : Segundos Así pues puede ser necesario realizar cambios en esta cadena. Al extraer el valor de un campo numérico real, obtendremos un número con punto decimal. Quizás sea necesario cambiar este punto por una coma decimal. Cuando un campo está vacío, al intentar extraer su valor obtendremos el valor null.
EJERCICIO GUIADO. JAVA. ACCESO A BASE DE DATOS
Recapitulando. Ejecución de consultas desde la aplicación. 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. La cadena consulta puede ser construida a través de concatenaciones de cadenas. Observa atentamente este ejemplo. Es parecido al anterior pero tiene una ligera diferencia:
//Supongamos que txtTabla es un cuadro de texto String consulta; consulta=”select * from ” + txtTabla.getText(); ResultSet r = sentencia.executeQuery(consulta);
En este caso, la cadena consulta es la concatenación de… “select * from “ con lo que contenga el cuadro de texto txtTabla - es decir, txtTabla.getText()
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.
La construcción de consultas SQL a partir de la concatenación de cadenas y datos proporcionados por el usuario es algo muy usado en los programas de base de datos. En esta hoja guiada se insistirá en esta idea.
EJERCICIO GUIADO Nº 1 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.
1. Entre en NetBeans. Crea un nuevo proyecto llamado TrabajadoresBD. Dentro de este proyecto crea un paquete principal llamado paqueteprincipal y dentro de él un JFrame llamado ventanaprincipal:
2. Añade a la ventana un JTextPane y un botón de momento:
El botón se llamará btnTodos y el JTextPane se llamará txtPanel.
3. Para que este programa pueda trabajar con la base de datos MANEMPSA tendrá que prepararlo haciendo lo siguiente: -
Crear la subcarpeta Base y copiar en ella el fichero de base de datos MANEMPSA.MDB que tiene en la carpeta Mis Documentos.
-
Añadir al programa los objetos conexión (Connection) y sentencia (Statement) como globales.
-
Crear el procedimiento PrepararBaseDatos y llamarlo desde el constructor.
-
Cerrar la conexión desde el evento windowClosing
Realice estos cuatro pasos que se han indicado antes de continuar. 4. Ya se puede programar el botón btnTodos. Se pretende que al pulsar este botón aparezca en el panel txtPanel el contenido de la tabla trabajadores. Para ello, programe el siguiente código dentro del actionPerformed del botón btnTodos:
Si analiza este código, verá que es igual al que hemos realizado en hojas anteriores. Básicamente lo que hace es lo siguiente: -
Ejecuta la consulta “select * from trabajadores order by sueldo”
-
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
-
Finalmente se muestra el resultado de la consulta en el JTextPane: txtPanel. (Antes de mostrarlo se borra todo lo que hubiera en el panel)
5. Ejecuta el programa y prueba el funcionamiento de este botón:
Al pulsar el botón, se muestran los datos de todos los trabajadores.
6. Se va a mejorar el programa. Añada un cuadro de texto llamado txtSueldo y luego tres botones llamados respectivamente btnMayor, btnMenor y btnIgual. La parte inferior de la ventana quedará así:
7. Se pretende que estos botones funcionen de la siguiente forma: -
El usuario introducirá un sueldo en el cuadro de texto txtSueldo. Luego, si pulsa el botón Igual, aparecerá en el panel todos los trabajadores que tengan un sueldo igual al introducido. En cambio, si pulsa el botón Mayor, aparecerá en el panel todos los trabajadores que tengan un sueldo mayor que el introducido. Y si pulsa el botón Menor, aparecerá en el panel todos los trabajadores que tengan un sueldo menor que el introducido.
Se empezará programando el botón Igual.
8. Programe en el actionPerformed del botón btnIgual lo siguiente. (Nota: El código siguiente es prácticamente igual al anterior, solo se hace un pequeño cambio. Puede copiar y pegar y luego hacer la modificación que se indica)
Estudiemos detenidamente el código remarcado: 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: select * from trabajadores where sueldo =
con lo que contenga el cuadro de texto sueldo – es decir txtSueldo.getText()
Si el cuadro de texto del sueldo contuviera un 1000, entonces la cadena resultante sería: select * from trabajadores where sueldo = 1000
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. Es decir, si el usuario introdujera un 1000 en el cuadro de texto del sueldo, el resultado de la concatenación en la variable consulta sería la siguiente cadena: select * from trabajadores where sueldo > 1000
11. Prueba a ejecutar el programa introduciendo el valor 1000 en el sueldo y luego pulsando el botón Mayor que. El resultado será que aparece en el panel de texto los trabajadores que cobran más de 1000 euros. 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:
El cuadro de texto se llamará txtNombre mientras que el botón “Igual a “ se llamará btnNombreIgual y el botón “Contiene a” se llamará btnContiene.
14. Estos botones funcionarán de la siguiente forma: -
El usuario introducirá un nombre en el cuadro de texto txtNombre.
-
Si luego pulsa el botón Igual a, entonces aparecerán todos aquellos trabajadores que tengan exactamente dicho nombre.
-
Si en cambio pulsa el botón Contiene a, entonces aparecerán todos aquellos trabajadores cuyo nombre contenga la palabra que se haya escrito en el cuadro de texto.
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): Primera cadena: select * from trabajadores where nombre = ‘ Segunda cadena: lo que contenga el cuadro de texto: txtNombre.getText() Tercera cadena: ‘ Supongamos que el cuadro de texto contiene la palabra Ana, el resultado de la concatenación sería: select * from trabajadores where nombre = ’Ana’
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 (‘) Esa es la razón por la que se tienen que concatenar dos ‘
16. Ejecuta el programa y prueba a escribir en el cuadro de texto del nombre Ana. Luego pulsa el botón Igual a…
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. Por ejemplo, si el usuario introduce el texto “an” en el cuadro, al pulsar Contiene a aparecerán los trabajadores que se llamen: Juan, Antonio, Antonia, Manolo, Ana, etc (todos contienen el texto ‘an’)
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) Primera cadena: select * from trabajadores where nombre like ‘% Segunda cadena: lo que contenga el cuadro de texto: txtNombre.getText() Tercera cadena: %‘ Supongamos que escribimos en el cuadro de texto del nombre la palabra an, el resultado de la concatenación sería el siguiente: select * from trabajadores where nombre like ‘%an%’ La condición nombre like ‘%an%’ significa que contenga la palabra an. 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: nombre like ‘*an*’ 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:
txtDia
txtMes
txtAnio
btnAnterior
btnDespues
21. El objetivo de estos elementos añadidos es el siguiente: -
El usuario introducirá una fecha (día, mes y año) en los cuadros de texto txtDia, txtMes, txtAnio.
-
Luego, si pulsa el botón Anterior, aparecerán los trabajadores que hayan entrado en la empresa antes de la fecha indicada.
-
Si pulsa el botón Después, en cambio, aparecerán los trabajadores que hayan entrado en la empresa después de la fecha indicada.
22. Empezaremos programando el botón Anterior. Accede a su actionPerformed e incluye el siguiente código (es un código similar al anterior, solo tienes que realizar un pequeño cambio):
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. Esto se consigue concatenando varias cadenas (se indican a continuación en distintos colores para facilitar la comprensión)
Primera cadena: select * from trabajadores where fecha < # Segunda cadena: lo que contiene el cuadro de texto del mes: txtMes.getText() Tercera cadena: / Cuarta cadena: lo que contiene el cuadro de texto del día: txtDia.getText() Quinta cadena: / Sexta cadena: lo que contiene el cuadro de texto del año: txtAnio.getText() Séptima cadena: # Por ejemplo, supongamos que: -
en el cuadro txtDia se introdujo un 20. en el cuadro txtMes se introdujo un 12. En el cuadro txtAnio se introdujo un 2005.
Entonces, la cadena resultante de la concatenación será: select * from trabajadores where fecha < #12/20/2006#
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. Esta consulta SQL viene expresada como una cadena. Se puede construir una consulta SQL a través de la concatenación de varias cadenas. Estas cadenas pueden ser datos introducidos por el usuario en cuadros de textos u otros controles. Al hacer que el usuario pueda participar en la construcción de la consulta aportando sus propios datos, le damos la posibilidad de que él decida la información que se quiere extraer de la base de datos. De esta manera se consigue que el programa sea más potente. 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: - Los valores tipo texto se indicarán entre comillas simples ‘ - El operador like se usa con porcentajes (%) en vez de con asteriscos (*) - Las fechas van rodeadas por almohadillas (#) - Las fechas tienen que indicarse con el formato mes/dia/año
EJERCICIO GUIADO. JAVA. ACCESO A BASE DE DATOS
Recapitulando. Consultas de selección. Consultas de Acción. Al estudiar SQL, vimos que existían dos tipos de instrucciones. -
Consultas de selección (SELECT) 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 no afectan a la base de datos, simplemente muestran información sobre la propia base de datos.
-
Consultas de acción. (INSERT, DELETE, UPDATE) Estas consultas realizan una acción sobre la base de datos. Esta acción puede ser: o o o
Insertar un nuevo registro en una tabla (INSERT) Borrar un registro o registros de una tabla (DELETE) Modificar los datos de un registro o registros de la tabla (UPDATE)
Ejecución de consultas de selección y de consultas de acción. 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: ResultSet r = sentencia.executeQuery(“select . . .”);
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. Así pues, para realizar un alta en la base de datos se usará: sentencia.executeUpdate(“insert . . .”); Para realizar una modificación en la base de datos se usará: sentencia.executeUpdate(“update . . . “); Para realizar una eliminación en la base de datos se usará: 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. 1. Entre en NetBeans. Crea un nuevo proyecto llamado GestionTrabajadores. Dentro de este proyecto crea un paquete principal llamado paqueteprincipal y dentro de él un JFrame llamado ventanaprincipal:
2. Añade a la ventana un JTextPane y un botón de momento:
El botón se llamará btnTrabajadores y el JTextPane se llamará panelTexto.
3. Para que este programa pueda trabajar con la base de datos MANEMPSA tendrá que prepararlo haciendo lo siguiente: -
Crear la subcarpeta Base y copiar en ella el fichero de base de datos MANEMPSA.MDB que tiene en la carpeta Mis Documentos.
-
Añadir al programa los objetos conexión (Connection) y sentencia (Statement) como globales.
-
Crear el procedimiento PrepararBaseDatos y llamarlo desde el constructor.
-
Cerrar la conexión desde el evento windowClosing
Realice estos cuatro pasos que se han indicado antes de continuar. 4. Ya se puede programar el botón btnTrabajadores. Se pretende que al pulsar este botón aparezca en el panel panelTexto el contenido de la tabla trabajadores. Para ello, en el actionPerformed del botón btnTrabajadores programe lo siguiente:
5. Como puede ver, es una llamada a un método al que se le ha dado el nombre MostrarTodos. Este método se encargará de mostrar todos los trabajadores en el panelTexto. Programe el método MostrarTodos de la siguiente forma:
El código de este método no debe resultarle ya desconocido. 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”. La razón por la que se ha programado este código en un método aparte llamado MostrarTodos en vez de hacerlo directamente en el actionPerformed del botón se entenderá más adelante, cuando avancemos en el ejercicio guiado.
6. Ejecute el programa y pruebe el botón btnTrabajadores. Compruebe que realiza su cometido.
7. Ahora que ya tenemos un programa capaz de visualizar a los trabajadores, añada los siguientes elementos a la ventana principal:
Panel: panelAlta Cuadros de Texto: txtDNI txtNombre txtApellidos txtSueldo
txtDia txtMes txtAnio txtMatricula Botón: btnAlta
8. El objetivo de estos elementos es el siguiente: El usuario introducirá los datos de un nuevo trabajador en las casillas indicadas. 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. Para ello tendrás que programar en el botón Alta lo siguiente:
Analicemos este código detenidamente. 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()+”’,”;
que poner esto: consulta = consulta + “’”+txtDNI.getText()+”’,”;
Solo que el uso de += acorta las instrucciones. Si se analiza la concatenación de las cadenas, se observará que el resultado es una instrucción SQL del tipo INSERT INTO. Es decir, una instrucción SQL que permite la inserción de un nuevo registro en la tabla trabajadores. Por ejemplo, supongamos que introducimos los siguientes valores en los cuadros de texto: txtDNI txtNombre txtApellidos txtSueldo txtDia txtMes txtAnio txtMatricula
11.111.111-A María Ruiz 1100 10 4 2001 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): insert into trabajadores values (‘11.111.111-A’,’María’,’Ruiz’,1100,#4/10/2001#,’4433RET’)
Es decir, se sigue la misma estrategia que en la hoja anterior. Se concatenan trozos de cadenas y datos introducidos por el usuario hasta conseguir una cadena con forma de instrucción SQL. En este ejemplo, la instrucción SQL construida por concatenación es una instrucción INSERT INTO que permite introducir en la tabla trabajadores los datos de un nuevo trabajador. 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. La razón de que se programara aparte el método MostrarTodos para mostrar el listado completo de trabajadores ha sido debido a la intención de llamar a este método desde otros lugares del programa. Es decir, la intención ha sido centralizar código y evitar su repetición. 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.
9. Finalmente ejecute el programa y compruebe su funcionamiento añadiendo varios trabajadores a la tabla:
Introduce datos y pulsa el botón Alta.
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. Para este tipo de instrucciones hay que usar el método executeUpdate. Normalmente, será necesario construir una cadena de consulta a través de la concatenación de subcadenas y datos introducidos por el usuario en cuadros de texto. Este tipo de instrucciones SQL no devuelven ningún ResultSet, ya que no extraen datos de las tablas, sino que modifican el contenido de éstas.
EJERCICIO GUIADO. JAVA. ACCESO A BASE DE DATOS
Consultas de Acción. Bajas. 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 . . . “); Al ejecutar estas consultas se cambiará el contenido de las tablas de la base de datos y no se devolverá ningún ResultSet.
EJERCICIO GUIADO Nº 1 PLANTEAMIENTO Se mejorará el proyecto realizado en la hoja anterior de forma que no solo admita la inserción de nuevos trabajadores en la tabla trabajadores de la base de datos MANEMPSA, sino que también permite eliminar a trabajadores de la tabla.
1. Entre en NetBeans. Abre el proyecto llamado GestionTrabajadores que se programó en la hoja anterior. 2. Añade en la parte inferior de la ventana un nuevo panel:
Panel: panelBajas Cuadro de texto: txtDNIEliminar Botón: btnEliminar
3. La mejora que se pretende hacer es la siguiente: -
El usuario introducirá en el cuadro de texto txtDNIEliminar el DNI del trabajador que quiere eliminar.
-
Al pulsar el botón Eliminar el trabajador con dicho DNI se eliminará de la tabla.
-
Antes de eliminar al trabajador, se le pedirá al usuario una confirmación, para evitar un borrado accidental.
-
Si el DNI introducido no se correspondiera con ningún trabajador de la tabla, entonces se mostrará un mensaje indicándolo.
4. Para hacer esto, entre en el actionPerformed del botón Eliminar y programe lo siguiente:
Se va a analizar este código. Estúdielo con detenimiento: Lo primero interesante que encontrará es la construcción de una consulta de selección (SELECT) usando la típica concatenación de cadenas: consulta="select * from trabajadores where DNI='"+txtDNIEliminar.getText()+"'"; ResultSet r=sentencia.executeQuery(consulta);
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. Observe el código que viene a continuación: 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) {
Este trozo de código le pregunta al usuario si quiere borrar realmente al trabajador. Si la respuesta es sí (YES_OPTION) se efectuará el borrado tal como se indica a continuación: consulta="delete from trabajadores where DNI='"+txtDNIEliminar.getText()+"'"; sentencia.executeUpdate(consulta); //se ejecuta la eliminacion MostrarTodos(); //y se muestra la tabla de nuevo
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. En caso de que el usuario no haya confirmado el borrado, el código muestra un mensaje “Borrado cancelado por el usuario”. Por otro lado, todo este código es susceptible de sufrir errores inesperados, por lo que está rodeado por un try ... catch.
5. Ejecute el programa y pruebe a eliminar trabajadores de la tabla. Se recomienda que pruebe a introducir DNIs inexistentes, para ver que ocurre. Pruebe también la confirmación del borrado: responda a veces que sí y otras veces que no.
Introduzca el DNI del trabajador que quiere borrar y luego pulse Eliminar. Al hacerlo el listado se actualizará y ya no mostrará el trabajador con dicho DNI ya que habrá sido borrado. Si el DNI no existiera el borrado no se produciría y mostraría un mensaje de error.
CONCLUSIÓN Se pueden ejecutar instrucciones SQL del tipo DELETE (borrar registros) usando el objeto sentencia. Para este tipo de instrucciones hay que usar el método executeUpdate. Normalmente, será necesario construir una cadena de consulta DELETE a través de la concatenación de subcadenas y datos introducidos por el usuario en cuadros de texto. Este tipo de instrucciones SQL no devuelven ningún ResultSet, ya que no extraen datos de las tablas, sino que modifican el contenido de éstas. 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. También se recomienda pedir confirmación al usuario antes de realizar borrados en las tablas.
EJERCICIO GUIADO. JAVA. ACCESO A BASE DE DATOS
Consultas de Acción. Modificaciones. Las consultas SQL de acción son: -
INSERT INTO (permiten introducir nuevos registros en las tablas) DELETE (permiten eliminar registros de las tablas) UPDATE (permiten modificar los registros de las tablas)
Estas consultas SQL se ejecutan desde el programa a través del método executeUpdate propio del objeto sentencia. Estas instrucciones SQL afectan al contenido de la base de datos y no devuelven ningún resultado. Es decir, no extraen datos, y por tanto no devuelven un ResultSet. 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.
1. Entre en NetBeans. Abre el proyecto llamado GestionTrabajadores que se programó en la hoja anterior. 2. Modifique la ventana principal añadiendo un nuevo panel con los siguientes componentes: Nuevo panel
El panel se llamará panelModificar El botón es btnBuscar Los cuadros de texto se llaman respectivamente: txtModDNI txtModNombre txtModApellidos txtModSueldo txtModDia txtModMes txtModAnio txtModMatricula El botón es btnModificar
3. La mejora que se pretende hacer es la siguiente: -
El usuario introducirá en el cuadro de texto txtModDNI el DNI del trabajador cuyos datos se quieren modificar.
-
Al pulsar el botón Buscar, el resto de cuadros de texto se rellenarán con los datos del trabajador al que pertenece dicho DNI. (Si dicho DNI no existiera, se mostraría un mensaje de error)
-
Cuando aparezcan los datos del trabajador en los cuadros de texto, el usuario podrá realizar las modificaciones pertinentes.
-
Al pulsarse el botón Efectuar Modificación se modificarán los datos en la tabla.
4. Primero programaremos el botón de búsqueda. Entre en el actionPerformed de este botón y programe lo siguiente:
Estudiemos atentamente el código anterior:
Lo primero que hace el código es construir una consulta de selección que busque a todos los trabajadores que tengan el DNI introducido en el cuadro de texto txtModDNI. Ejecuta la consulta y almacena el resultado en un típico ResultSet. Luego comprueba a través del siguiente if si no existe un trabajador con dicho DNI en el ResultSet: if (!r.first()) {
En ese caso muestra un mensaje de error indicando que no se ha encontrado dicho trabajador. 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”));
Recoge el valor del campo nombre, y lo sitúa en el cuadro de texto txtModNombre. En el caso de la fecha de entrada del trabajador, se extrae la fecha y luego se extrae de la cadena el día, el mes y el año, situando cada dato en su cuadro de texto correspondiente. 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);
Recuerda que cuando se extrae una fecha de un ResultSet, su formato es: año-mes-dia-hora:minutos Por ejemplo: 2001-12-23-00:00 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. Si existe un trabajador con ese DNI, sus datos aparecerán en los cuadros de texto.
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.
7. Para hacer esto, entre en el actionPerformed del botón Efectuar Modificación y programe lo siguiente:
Se va a analizar este código. Estúdielo con detenimiento: 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 La instrucción ya construida por concatenación sería la siguiente: 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.
8. Comprueba el funcionamiento del programa ejecutándolo. Debes introducir un DNI y pulsar el botón Buscar para que se rellenen los cuadros de texto con los datos del trabajador. Luego cambia algún dato de los que han aparecido en los cuadros de texto y pulsa el botón Efectuar Modificación. Si observas el panel de texto deberá aparecer la lista completa de trabajadores y en ella podrás observar la modificación que se ha realizado en el trabajador correspondiente.
Se introduce un DNI y se le da a Buscar. Los cuadros de texto se rellenan con los datos del trabajador. 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. Para este tipo de instrucciones hay que usar el método executeUpdate. Normalmente, será necesario construir una cadena de consulta UPDATE a través de la concatenación de subcadenas y datos introducidos por el usuario en cuadros de texto. Este tipo de instrucciones SQL no devuelven ningún ResultSet, ya que no extraen datos de las tablas, sino que modifican el contenido de éstas. 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
1. Crear un nuevo proyecto en NetBeans. En la ventana principal de dicho proyecto agregue un objeto JTable:
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...
3. Aprenderemos ahora a configurar determinados aspectos de la tabla que vamos a usar. Para ello añada al constructor una llamada a un método PrepararTabla que programaremos a continuación.
4. Programa ahora el método PrepararTabla de la siguiente forma:
La primera línea del código define un array de String con los títulos de la tabla, es decir, con las columnas de la tabla. A continuación, se construye un objeto del tipo DefaultTableModel, o dicho de otra manera, un modelo de tabla. El objeto m está declarado como variable global. 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. En el código, se define como global un objeto llamado m, de tipo DefaultTablaModel. Luego, al construir el objeto se deben indicar dos parámetros: null y el vector de títulos de columnas: DefaultTableModel m = new DefaultTableModel(null,titulos); 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.
5. Ejecuta el programa y observa el resultado:
Como puedes observar, se ha creado una tabla vacía con cinco columnas correspondientes al vector de títulos. 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(); El resultado de esta instrucción es que volvemos a tener disponible el modelo de la tabla en la variable m, y por tanto, podemos manipular los datos contenidos en la tabla a través de esta variable. 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): String filavacia[]=new String[5]; 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...
8. Para entender bien el funcionamiento de la inserción de filas en la tabla, añada otro botón llamado btnNuevoElemento con el texto Nuevo Elemento:
9. En este botón programe lo siguiente:
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. Si no hubiera ninguna fila seleccionada, el método getSelectedRow devuelve el valor –1. Esto lo usamos en el if que viene a continuación para mostrar un mensaje de error diciendo que es necesario seleccionar la fila que se va a borrar. 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.
Al pulsar eliminar fila se eliminará la fila que esté seleccionada de la tabla. 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:
txtFila txtColumna
btnVerValor
etiValor
15. Lo que se pretende es lo siguiente: El usuario introducirá un valor en la fila y la columna, por ejemplo: Fila 3, columna 4, y al pulsarse el botón Ver Valor aparecerá en la etiqueta Valor el contenido de la casilla situada en la posición 3, 4 (fila 3 columna 4) Así pues programe lo siguiente en el botón Ver Valor:
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. Por tanto se quiere ver el valor de la casilla 2,1 (tanto las filas como las columnas empiezan en 0)
17. Sigamos experimentando. Añade lo siguiente a la ventana:
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. El resultado será que se introduce el valor escrito en la posición de la tabla indicada por la fila y columna introducida. Para hacer esto, programe lo siguiente dentro del botón btnIntroducir:
Estudiemos el código detenidamente. 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. Luego introduce un dato. Y al pulsar el botón Introducir el resultado es que el dato se introduce en la celda indicada por la fila y columna. Recuerda que las filas y columnas empiezan a numerarse por 0 en un JTable.
CONCLUSIÓN 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. Los objetos JTable contienen un modelo de datos de tipo DefaultTableModel. 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
Representación de Tablas en un JTable 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. El proceso será básicamente el siguiente:
Base de Datos
ResultSet
JTable
EJERCICIO GUIADO Nº 1
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 b. Declarar los dos objetos globales: conexión y sentencia. c. Programar el método PrepararBaseDatos de forma que el programa acceda a la base de datos y se construyan los objetos conexión y sentencia. d. Programar el evento windowClosing de la ventana principal de forma que se cierre la conexión.
2. Una vez hecho esto, añade a la ventana principal un objeto JTable y llámalo simplemente tabla. 3. Añade en la parte inferior un botón llamado btnTrabajadores. La ventana principal quedará así:
4. Agregaremos al proyecto un objeto “modelo de tabla” (DefaultTableModel) llamado m que sea global. También añadiremos en el constructor una llamada a un método PrepararTabla y programaremos dicho método de la siguiente forma:
Si observas el código, verás que en el método PrepararTabla se crea un vector de cadenas con cuatro elementos pero que no contiene nada. Luego se crea el modelo de tabla a partir de este vector vacío. Y se asigna finalmente a la 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)
5. Ejecuta el programa para ver su aspecto de momento.
Debido a que hemos asignado un vector de títulos sin contenido, las columnas tienen como título letras.
6. Bien, ahora programaremos el botón btnTrabajadores de forma que al pulsarlo se muestre el contenido de la tabla Trabajadores. Programe lo siguiente:
Estudiemos el código detenidamente. Lo primero que se hace es extraer el contenido de la tabla Trabajadores de la base de datos, ejecutando una consulta SQL usando el objeto sentencia. El resultado de dicha consulta se almacenará en un objeto ResultSet llamado r. ResultSet r = sentencia.executeQuery("select * from trabajadores");
A continuación, se extraerá información del ResultSet y se introducirá en la tabla. Lo primero que se hace es crear el modelo de la tabla definiendo la cabecera. Observa el código. String titulos[] = {"DNI","Nombre","Apellidos","Sueldo","Fecha","Matrícula"}; m=new DefaultTableModel(null,titulos); tabla.setModel(m);
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. Finalmente asignamos el modelo creado a la tabla.
7. Ejecute el programa de momento. Observe como al pulsar el botón Trabajadores la cabecera de la tabla pasa a contener los campos indicados en el vector títulos.
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. Luego construimos un modelo de tabla (DefaultTableModel) llamado m usando un vector de títulos, que se corresponde a los campos de la tabla trabajadores. 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) Luego se añade el vector que se ha construido al modelo de la tabla. Así pues, en cada vuelta se añadirá un registro más al modelo m. Estos registros son extraídos del ResultSet. Cuando el bucle ha terminado, el modelo de la tabla contiene exactamente lo mismo que el ResultSet. Es decir, contiene la tabla trabajadores, ya que este fue el resultado de la consulta SQL ejecutada. Ya solo tenemos que asignar el modelo de la tabla al JTable correspondiente, es decir, a la tabla, con lo que esta visualizará los datos del modelo. 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: Base de Datos ResultSet Vector Modelo de Tabla JTable
-
De la base de datos extraemos datos a un ResultSet. (Esto se hace ejecutando una consulta SQL de tipo SELECT a través del objeto sentencia)
-
Del ResultSet extraemos los datos a un modelo de tabla. (Esto se hace recorriendo el ResultSet y almacenando cada registro en un vector)
-
Almacenamiento del vector en el modelo de tabla. (Cada vector extraido del ResultSet se inserta como fila en el modelo de tabla)
-
Se asigna el modelo de tabla al objeto JTable. (Al hacer esto el objeto JTable muestra el contenido del modelo)
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.
11. Si observa la tabla verá que la fecha aparece en el formato estándar de almacenamiento: Año-mes-dia hora:min:seg Y que los sueldos aparecen con punto decimal. Mejore estos detalles haciendo los siguientes cambios en el botón Trabajadores:
Como se puede observar, antes de almacenar los sueldos en el modelo de la tabla se reemplazan el punto decimal por una coma. Y en el caso de la fecha, se extrae de la cadena el año, mes y día y se concatenan en un formato más habitual: dia/mes/año. 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.
-
Recorrer el ResultSet almacenando cada una de sus filas en un vector y luego traspasando este vector a un modelo de tabla.
-
Una vez que el modelo de tabla está relleno, asignar el modelo a un JTable.
EJERCICIO GUIADO. JAVA. ACCESO A BASE DE DATOS
Gestión de una tabla 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. Por ejemplo, si eliminamos un registro sería interesante que automáticamente viéramos la tabla actualizada en el JTable. En esta hoja guiada se mejorará la aplicación de la hoja guiada anterior, dotándola de opciones para la gestión de la tabla Trabajadores.
EJERCICIO GUIADO Nº 1
1. Abrir la aplicación de la hoja guiada anterior. 2. El primer objetivo será hacer que al ejecutar el programa aparezca automáticamente el contenido de la tabla Trabajadores en el JTable. Para ello, realice los siguientes cambios en el código del programa:
Añade una llamada a un método MostrarTrabajadores, en el constructor del programa.
3. Crea el método MostrarTrabajadores:
4. Copia en él el código del actionPerformed del botón btnTrabajadores:
5. Lo que produce esta modificación del código es que al ejecutarse el programa se ejecute el método MostrarTrabajadores con lo que se ejecutará el código que hicimos en la hoja anterior para mostrar los datos de la tabla trabajadores en el JTable. Ejecuta el programa y comprueba el resultado.
6. Puesto que la tabla trabajadores se muestra al empezar el programa, la existencia del botón Trabajadores no tiene sentido, así pues elimina el botón Trabajadores de la ventana.
7. Añade ahora en la parte inferior un panel llamado panelAcciones y un botón Eliminar Trabajador llamado btnEliminar:
8. Se pretende que el usuario seleccione uno de los trabajadores de la tabla y al pulsar el botón Eliminar dicho trabajador se elimine de la base de datos. Esta eliminación por supuesto se verá reflejada en el JTable. Para ello, programe en el botón Eliminar lo siguiente:
Estudiemos con detenimiento el código programado. Lo primero que se hace es recoger la fila seleccionada de la tabla usando el método getSelectedRow. Si el valor devuelto es –1 entonces es que no hay ninguna fila seleccionada. El programa avisa de esta circunstancia. Si se seleccionó a un trabajador, entonces podemos borrar. Pero antes, es interesante pedir confirmación. Esto es lo que se hace con el JOptionPane.showConfirmDialog. Si el usuario acepta la eliminación del trabajador, entonces la llevamos a cabo. Observa el proceso: -
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:
sentencia.executeUpdate("delete from trabajadores where dni='"+dni+"'");
-
Y finalmente se llama al procedimiento MostrarTabla para que se extraiga de la base de datos y muestre de nuevo la tabla trabajadores. Esto actualizará el JTable, y se podrá ver que el trabajador ha sido eliminado.
-
Todo esto está dentro de un try...catch para capturar errores inesperados.
9. Ejecuta el programa y prueba a eliminar algún trabajador. Observa como el JTable se actualiza cuando se produce la eliminación.
10. Ahora añade otro botón llamado btnNuevo:
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 txtNuevoDia txtNuevoMes txtNuevoAnio 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. Si el usuario pulsa Cancelar, entonces no se hará nada. El JTable se actualizará para mostrar el resultado de la inserción del nuevo trabajador. Así pues, entre en el actionPerformed del botón btnNuevo y programe lo siguiente:
Este código empieza asignando un tamaño al cuadro de diálogo dialogoNuevo. 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. Luego se muestra dicho cuadro de diálogo. Y finalmente se actualiza el JTable por si se hubiera introducido un nuevo trabajador.
14. Ahora programemos los botones del cuadro de diálogo dialogoNuevo. Empecemos por el botón Cancelar:
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:
Vamos a analizar detenidamente este código. 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. Se ejecuta dicha instrucción SQL. Y se cierra el cuadro de diálogo. Por supuesto, es necesario un try...catch para evitar problemas inesperados.
16. Ejecuta el programa y prueba a introducir nuevos 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” Los nombres para los cuadros de texto y botones serán: txtModDni (Desactiva su propiedad editable) txtModNombre txtModApellidos txtModSueldo txtModDia txtModMes txtModAnio 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. Entra en el actionPerformed del botón Modificar y programa lo siguiente:
Estudiemos el código. Primero se comprueba el número de la fila seleccionada. Si no hubiera ninguna se muestra un mensaje de error, ya que es necesario modificar la fila del trabajador que se quiere modificar. 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 finalmente se prepara el cuadro de diálogo dialogoModificar y se muestra en la pantalla. Una vez realizada la modificación (no programada aún) se muestran los trabajadores en la tabla llamando al método MostrarTrabajadores.
25. Puedes comprobar el funcionamiento del programa de momento. Prueba a seleccionar una fila de la tabla y al pulsar el botón Modificar.
Selecciona... 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. Si se pulsa Cancelar no sucede nada. Simplemente se cerrará el cuadro de diálogo.
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. Programa el siguiente código en el botón Aceptar:
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. Finalmente se cierra el cuadro de diálogo. Todo este código es susceptible de sufrir fallos por lo que está rodeado de un try...catch.
29. Ejecuta el programa y comprueba el funcionamiento de la actualización de trabajadores. Prueba a realizar varias actualizaciones. Observa como el JTable se actualiza con las nuevas modificaciones realizadas.
CONCLUSIÓN 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
Es muy interesante que la aplicación muestre en pantalla continuamente un JTable con el contenido de la tabla de la base de datos sobre la que se está trabajando. El JTable nos permite visualizar los datos de la tabla y seleccionar rápidamente el registro que queramos manipular. Para la inserción de nuevos registros en la tabla se recomienda la creación de un cuadro de diálogo que muestre un formulario donde el usuario pueda introducir los datos del nuevo registro cómodamente. Para la modificación de un registro, se recomienda la creación de otro cuadro de diálogo que muestre los datos del registro que se quiere modificar.
EJERCICIO GUIADO. JAVA. ACCESO A BASE DE DATOS
Filtrados sobre una tabla 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. En todo momento se mostraba en un JTable el listado de trabajadores de la empresa. La eliminación y modificación de un trabajador se podía realizar simplemente haciendo clic sobre la fila del trabajador correspondiente en el JTable y luego activando el botón Eliminar o Modificar. Sin embargo, en el momento en que tengamos una gran cantidad de trabajadores almacenados en la tabla, puede resultar un poco complicado encontrar al trabajador en concreto que se quiere eliminar o modificar. 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
1. Abrir la aplicación de la hoja guiada anterior. 2. Primero debes añadir un botón btnFiltar a la ventana:
3. Al pulsar este botón aparecerá un cuadro de diálogo que contenga opciones de filtrado, de forma que el usuario pueda decidir qué trabajadores quiere ver. Por lo tanto, tendrá que añadir un nuevo cuadro de diálogo (JDialog) y asígnele el nombre dialogoFiltrar.
4. Haz doble clic sobre este diálogo y diséñelo de la siguiente forma:
txtFiltrarDni txtFiltrarNombre txtFiltrarApellidos comboSueldo txtFiltrarSueldo comboFecha txtFiltrarDia txtFiltrarMes txtFiltrarAnio txtFiltrarMatricula btnFiltrarAceptar btnFiltrarVerTodos btnFiltrarCancelar
NOTA: Los dos combos del cuadro de diálogo deben contener los siguientes elementos: =
>
<
>=
<=
<>
Es decir, cuando se desplieguen aparecerá esto:
5. La idea es la siguiente. Cuando el usuario pulse el botón Filtrar, se mostrará este cuadro de diálogo. Entonces el usuario introducirá las condiciones de búsqueda y pulsará Aceptar, y entonces se visualizarán en el JTable aquellos registros que cumplan la condición. Si el usuario pulsa el botón Ver Todos, entonces se mostrarán en el JTable todos los trabajadores. Si el usuario pulsa el botón Cancelar, entonces el cuadro de diálogo de filtrado se cierra sin más.
6. Empezaremos programando el botón Filtrar de la ventana principal. Introduzca en él el siguiente código:
Lo único que hace este código es asignar un tamaño al cuadro de diálogo, configurarlo como modal, y finalmente presentarlo en pantalla.
7. Ejecute el programa si quiere ver el funcionamiento de este botón.
Se pulsa el botón Filtrar y aparece el cuadro de diálogo de filtrado.
8. Programemos ahora el botón Cancelar del cuadro de diálogo de filtrado. La programación de este botón es muy sencilla:
Como puede ver consiste simplemente en cerrar el cuadro de diálogo de filtrado.
9. Se programará ahora el botón Aceptar, pero antes, es necesario entender como funcionará 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:
Como puede ver, empezamos recogiendo el contenido de los cuadros de texto en distintas variables. También recogemos los valores seleccionados en los combos del sueldo y fecha. 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:
Agrega estas dos variables en la parte inicial del método.
........... código anterior...........
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. Se han añadido dos variables: -
La variable sql es una variable de cadena que contendrá la instrucción SELECT que efectuará el filtrado (la consulta)
-
La variable ncond (número de condiciones) es una variable numérica que va contando cuantas condiciones hay. Ten en cuenta que habrá una condición cada vez que un cuadro de texto esté relleno con algún dato. 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): select * from trabajadores where condicion1
La condición 2, condición 3, etc llevan el “and” delante. Por ejemplo, la segunda condición tendría esta forma (en azul): select * from trabajadores where condicion1 and condicion2
Si añadiéramos una tercera condición también llevaría el “and” (en verde): select * from trabajadores where condicion1 and condicion2 and condicion3
Etc. Resumiendo, la primera condición vendrá antecedida de “where”, mientras que el resto de las condiciones vendrán antecedidas del “and”.
Si se observa el código añadido al final del método, en él se empieza construyendo el comienzo de la consulta SELECT: “select * from trabajadores” y luego se añaden condiciones según si el cuadro de texto correspondiente está vacío o no. 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. Observa como cuando se añade una condición, se comprueba con un if el número de condiciones (ncond) para saber si hay que concatenar la condición con el “where” o con el “and”. 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.
12. Añada al final del código anterior el siguiente código:
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. Se incrementa el contador de condiciones en uno y si estamos ante la primera condición esta se concatena usando “where”, y si no, esta se concatena usando “and”.
13. Añada al final del código anterior el siguiente código:
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) Como en los casos anteriores, se suma uno al contador de condiciones y, si estamos ante la primera condición se concatena con “where”, y si no, se concatena con “and”. 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: =, >, <, >=, <= , <>
14. Añada al final del código anterior el siguiente código:
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. Como en los casos anteriores, se suma uno al contador de condiciones y se comprueba si estamos ante la primera condición. En este caso se concatena la condición usando “where” y en caso contrario se concatena la condición usando “and”. 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.
En este caso tenemos la construcción de la condición correspondiente a la matrícula del coche del trabajador. Por supuesto, esta condición solo se construye si se ha escrito algo en el cuadro de texto de la matrícula. Como en los casos anteriores se suma uno al contador de condiciones y si estamos ante la primera condición entonces la condición se construirá usando “where”, y en caso contrario añadiremos esta condición usando “and”. 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:
En este código se ejecuta la consulta creada y el resultado se introduce en un ResultSet r. Ahora hay que mostrar el contenido del ResultSet r en el JTable de la ventana principal. 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:
Este código ya debe resultar conocido, ya que se usó también en el método MostrarTrabajadores, encargado de mostrar toda la tabla trabajadores en el JTable. 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. Cada fila extraída se introduce en el modelo m de la tabla. 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. La razón de que aparezcan tantos errores es porque aún no hemos añadido el try...catch. Esto lo haremos al final.
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. Añade por tanto el siguiente código:
19. Todo el código programado en el botón Aceptar es bastante delicado y pude dar gran cantidad de errores, por lo que será necesario rodearlo dentro de un try...catch:
.... resto del código...
20. El código que se acaba de programar es un poco enrevesado y largo, pero le da al programa una potencia tremenda, ya que permite al usuario realizar fácilmente búsquedas y filtrados en la tabla trabajadores. Ejecuta el programa y haz lo siguiente:
Pulsa Filtrar para ver el cuadro de diálogo de filtrado.
Queremos buscar a los trabajadores que tengan una “a” en el nombre y cobren menos de 1500 euros. (Recuerda activar el combo)
Pulsa Aceptar para ver el resultado.
21. Como habrá podido observar en este ejemplo, se pueden realizar búsquedas en la tabla trabajadores gracias al código programado. Esto es muy útil sobre todo en el momento en que la tabla contenga muchos registros. Pruebe a ejecutar más veces el programa y realice varios filtrados.
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:
Como ves aprovechamos el método ya programado MostrarTrabajadores que se encarga de mostrar todos los trabajadores en el JTable. Luego solo tenemos que descargar el cuadro de diálogo de filtrado.
23. Ejecuta el programa y prueba lo siguiente: -
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... Pulsa ahora Filtrar
Pulsa Ver Todos para volver a ver todos los trabajadores.
Y el resultado será que se quita el filtrado y se vuelven a mostrar todos los trabajadores
CONCLUSIÓ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. Las opciones de filtrado consistirán básicamente en la construcción de una consulta SELECT a través de concatenaciones de cadenas. 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
1. Abrir la aplicación de la hoja guiada anterior. 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. Para ello, añada lo siguiente al diálogo de filtrado:
panelOrdenacion cboCamposOrdenacion radioASC radioDESC
NOTA Nº1: El combo cboCamposOrdenacion contendrá los siguientes elementos: (Sin Ordenación), DNI, Nombre, Apellidos, Sueldo, Fecha, Matricula:
NOTA Nº2: Es necesario añadir un ButtonGroup al programa, al que llamaremos grupoOrdenacion. Los botones de opción radioASC y radioDESC deben pertenecer a dicho grupo.
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):
Estudiemos el código. Lo primero que se hace es extraer el valor del combo desplegable de los campos de ordenación. Si este combo no contiene el valor “(Sin ordenación)” significará que se desea realizar una ordenación por el campo seleccionado. Así pues se concatena a la variable sql la cláusula order by con el campo que se ha seleccionado en el combo. Se controla también la forma de ordenación teniendo en cuenta el botón de opción que esté activado, y según esto, se añade la cadena “ASC” o “DESC” para ordenar ascendentemente o descendentemente.
4. Ejecuta el programa y prueba a hacer un filtrado eligiendo un campo para ordenar y observa el resultado:
En este ejemplo se pretende visualizar a todos los trabajadores que contengan una “a” en su nombre...
... y el listado saldrá ordenado por el campo sueldo descendentemente.
5. Una ventaja de esto es que se puede mostrar el listado completo de trabajadores ordenado por el campo que se quiera siempre y cuando no se indique ninguna condición:
En este ejemplo aparecerían todos los trabajadores, ya que no se ha indicado ninguna condición.
... y el listado saldrá ordenado por el nombre ascendentemente.
6. Ahora vamos a añadir una nueva mejora al programa. La idea es que se visualice junto al JTable de trabajadores los siguientes datos: el número de trabajadores que se muestra y la media de los sueldos. Para ello, añade las siguientes modificaciones en el diseño de la ventana principal:
Etiquetas con borde:
etiNumeroTrab
etiSueldoMedio
7. Ahora programaremos un método que sea capaz de calcular el número de trabajadores y el sueldo medio a partir del contenido de un ResultSet. 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. Accede al código de tu programa y añade el siguiente procedimiento:
Este código básicamente toma el ResultSet pasado como parámetro y lo recorre aumentando en uno la variable ntrab cada vez que se pasa al siguiente trabajador. 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.
9. También interesa que cuando se realice un filtrado aparezca el número de trabajadores y el sueldo medio correspondiente al listado que se acaba de filtrar. Para ello debes añadir la siguiente línea al código del botón Aceptar del cuadro de diálogo de filtrado:
De nuevo se realiza la llamada al método de los cálculos justamente después de colocar en la tabla el listado de trabajadores, en este caso filtrado.
10. Ejecuta el programa y observa como al iniciar el programa ya aparecen en las etiquetas los cálculos (ya que el constructor llama al método MostrarTrabajadores que a su vez llama al método HacerCalculos) También puedes comprobar como al hacer un filtrado se muestran los cálculos correspondientes al listado filtrado, ya que en el botón Aceptar del dialogo de filtrado se hace una llamada al método HacerCalculos.
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 Todo programa de gestión de datos de una tabla debería tener opciones de ordenación para mostrar los datos de la tabla ordenados como el usuario quiera. 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 la creación de informes para nuestras aplicaciones usaremos un programa gratuito llamado IReport. El fichero de instalación para este programa lo encontrará en la subcarpeta Herramientas de la carpeta compartida. 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
1. En primer lugar copie el fichero de instalación del programa IREPORT a su ordenador, e instale el programa. 2. Una vez instalado, ejecútelo. La pantalla principal del IReport es la siguiente (es relativamente parecida a la pantalla principal de NetBeans):
En esta zona aparecerán los informes que se están diseñando.
Aquí aparecerán los distintos elementos que forman el informe.
Esta es la zona de diseño, donde se definen las características del informe.
En esta parte aparecerán las propiedades del objeto seleccionado.
Y aquí tenemos la salida, lugar donde aparecen los mensajes informativos y de error.
3. Cierre el programa IReport. Lo usaremos más adelante.
Aquí tendremos un listado con los campos de las tablas que podremos incluir en el informe, entre otras cosas.
EJERCICIO GUIADO Nº 2. CREACIÓN DE UN DSN
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.
1. Para crear un DSN acceda al Panel de Control. 2. Dentro del Panel de Control active el icono Herramientas Administrativas.
3. Dentro de Herramientas Administrativas active el icono Orígenes de datos.
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:
7. Usando la ventana de exploración que aparece, busca la base de datos MANEMPSA que se encuentra en Mis Documentos. Selecciónala y pulsa Aceptar.
8. Esta es toda la información que necesitaremos para crear el DSN de la base de datos MANEMPSA. Ahora ya solo queda darle un nombre al DSN. El nombre será BaseEjemplo. Escribe el nombre del DSN en la casilla correspondiente:
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. Aparecerá un mensaje preguntándole si quiere borrar el DSN. Debe responder NO ya que usaremos el DSN a continuación. (Si lo borrara no sería algo grave. Simplemente se tendría que crear de nuevo con los pasos indicados antes)
EJERCICIO GUIADO Nº 3. CONEXIÓN DE IREPORT CON UNA BASE DE DATOS
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. En este ejercicio guiado conectaremos el programa iReport con la base de datos MANEMPSA. Para ello entre otra vez en el programa iReport.
2. Para crear esta conexión, active la opción Datos – Conexiones / Fuentes de Datos
3. Debe activar el botón Nuevo para crear una nueva conexión...
4. Para base de datos de Access, debes activar la opción Conexión Base de Datos JDBC y pulsar Próximo.
5. Ahora le daremos un nombre a la conexión que realizaremos con la base de datos MANEMPSA. El nombre será simplemente: “Conexión con MANEMPSA”.
6. Lo siguiente es indicar el controlador (driver) de la base de datos. Para las bases de datos de Access el controlador que tendremos que indicar es sun.jdbc.odbc.JdbcOdbcDriver
7. Y finalmente hay que indicar el DSN que le hemos asociado a la base de datos MANEMPSA. Como vio en el ejercicio anterior, el DSN que se creó tenía de nombre BaseEjemplo. Tiene que cambiar la palabra DSNAME por BaseEjemplo:
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)
9. Se acaba de establecer una conexión entre el informe que estamos haciendo y la base de datos MANEMPSA. Es muy interesante comprobar que todos los pasos que hemos seguido son correctos. Para ello, pulse el botón Prueba, y si todo ha ido bien, debe aparecer un mensaje indicándolo:
10. La conexión con la base de datos MANEMPSA está ya configurada. Solo tiene que pulsar el botón Salvar para que quede guardada. 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)
12. Cierra el cuadro de conexiones. Ya tenemos el programa iReport preparado para la creación de informes con la base de datos MANEMPSA.
EJERCICIO GUIADO Nº 4. CREACIÓN RÁPIDA DE INFORMES 1. Ahora que tenemos configurado el iReport para acceder a la base de datos MANEMPSA, podemos crear informes con los datos de esta base de datos. En este ejercicio guiado se creará simplemente un informe que muestre un listado de los trabajadores de la empresa. 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. 5. Una vez elegida la base de datos (indicando su conexión correspondiente) tenemos que extraer de ella los datos que queremos que aparezcan en el informe (listado) Y para ello tendremos que hacerlo indicando una consulta SQL de tipo SELECT. 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:
6. Ya podemos ir al siguiente paso del asistente pulsando el botón Próximo. 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: El botón > añade de uno en uno. El botón >> los añade todos. El botón < quita un campo del informe. El botón << los quita todos.
8. Una vez elegidos los campos puede pulsar el botón Próximo para ir al siguiente paso. 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: -
En columnas. Esta distribución crea “fichas” individuales de cada registro (en nuestro ejemplo de cada trabajador)
-
Tabulada. La distribución tabular presenta el típico listado con una cabecera.
Para nuestro ejemplo escogeremos la distribución Tabulada. Dentro de la distribución Tabulada se pueden elegir entre algunas variantes. Dejaremos activado el formato ClassicT.xml
11. Active el botón Próximo para acceder al quinto y último paso del asistente. En este paso iReport le felicita porque acaba de crear el informe. Aquí solo tiene que pulsar el botón Terminar.
12. Una vez finalizado el asistente, volveremos a la pantalla principal de iReport. En ella, verá como ha aparecido el diseño del informe que acaba de crear.
Diseño del informe
En próximas hojas guiadas se estudiará la forma de modificar el diseño y de crear un informe desde cero. 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. Debe tener en cuenta que si ha cambiado el contenido de la base de datos MANEMPSA entonces es posible que le aparezcan otros trabajadores. Observe como el título del listado no es muy adecuado. Lo cambiaremos a continuación.
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:
19. Ahora el informe tendrá mejor aspecto:
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 Todo programa de gestión de datos de una tabla debería tener opciones de ordenación para mostrar los datos de la tabla ordenados como el usuario quiera. 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 En la hoja anterior se aprendió a realizar un informe usando el mago de informes. Este asistente crea un informe predefinido a partir de los campos de la tabla que indiquemos. 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
En este ejercicio guiado se creará un informe usando el mago de informes. Concretamente, se creará un informe que muestre el listado de los coches de la empresa MANEMPSA. Luego, una vez creado dicho listado, lo modificaremos. 1. Abra el programa iReport. 2. Active la opción Fichero – Mago de Informes.
3. Aparecerá el asistente para la creación de informes. En el primer paso tiene que elegir la conexión correspondiente a la base de datos MANEMPSA (que es donde se encuentra la tabla coches)
4. Ahora tendremos que escribir la consulta SELECT para extraer el listado completo de coches. Haremos que este listado se presente ordenado por marca. Para ello, introduzca la siguiente instrucción SQL:
5. Pulsa el botón Próximo para pasar al siguiente paso del asistente. 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. 9. En el paso 4 del asistente tendremos que elegir la distribución del informe. Escogeremos una distribución tabulada y de tipo ClassicT.
10. Active Próximo para ir al 5 y último paso del asistente y pulse Terminar. 11. Acabamos de crear el informe. Observe su diseño.
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:
Activa la propiedad primer plano (en el botón con los tres puntos) y escoge un color verde. Activa la propiedad fondo y escoge un color amarillo. Desactiva la propiedad Transparente.
Pon un tamaño de 28, y negrilla. Activa la itálica (cursiva) y el subrayado. Asigna una alineación izquierda.
22. Si observas el título del informe, verás que tendrá el siguiente aspecto ahora:
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í:
24. Visualiza el informe para ver el resultado:
25. El informe tendrá el siguiente aspecto:
Como ve, hemos cambiado la forma y posición del título. Observa. No aparece el campo matrícula!, Esto es debido a que es demasiado grande y no cabe aquí.
26. Vamos a solucionar el problema del campo Matrícula. Cierra la ventana del listado y en la ventana de diseño haz que el campo matrícula tenga un tamaño de letra de 10:
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:
Este cuadro se corresponde al conjunto de datos de la columna matrícula.
29. Haz que sus propiedades sean las siguientes: 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:
Si observas el listado verás que todos los datos de la columna matrícula tiene ahora las propiedades asignadas.
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. En la parte superior de la ventana de iReport tiene una barra de herramientas que puede usar también para realizar cambios en los elementos:
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. Una vez creado el informe, puede realizar modificaciones en su diseño seleccionando cada elemento y cambiando sus propiedades en la zona de propiedades. También puede mover y cambiar de tamaño los distintos elementos del informe. De esta forma, puede crear rápidamente un listado para luego personalizarlo.
EJERCICIO GUIADO. JAVA. INFORMES DE BASE DE DATOS
Creación de un informe desde cero 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. En esta hoja se verá un ejemplo de creación de informe desde cero.
EJERCICIO GUIADO Nº 1. CREACIÓN DE UN INFORME DESDE CERO
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. 3. Para ello, active la opción Fichero – Nuevo Documento.
4. El nombre del informe será serviciosjuan:
5. Al pulsar OK, observará que aparece un informe en blanco:
6. Este informe está dividido en zonas, cada una con un cometido distinto (lo iremos estudiando a medida que realicemos el informe) 7. En la barra de herramientas debe indicar la conexión a la base de datos que quiere usar. En nuestro caso la conexión se llama Conexión con Manempsa.
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: select * from trabajadores, servicios where trabajadores.dni=servicios.dni and trabajadores.dni=’12.321.567-B’ order by servicios.fecha
Si en la parte inferior aparece el listado de campos seleccionados en la consulta, entonces es indicativo de que todo va bien.
10. Pulsa OK. Acabamos de indicarle al informe que estamos realizando la base de datos de donde tomaremos los datos y la consulta para extraer dichos datos. Si observa la parte izquierda de la ventana del iReport, verá una opción Campos:
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. Arrastra el campo número desde la zona de campos a la zona de detalle:
13. Haz lo mismo con los otros campos que queremos mostrar: el tipo y la cantidad: El detalle quedará así:
14. Visualice el informe resultante. serviciosjuan.
iReport le pedirá que guarde el informe. Llámelo
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. b. c. d. e. f.
Un tamaño de letra de 24 Agranda el cuadro de forma que ocupe prácticamente toda la zona de título. Centra el título en el recuadro. Subráyalo. Asigna un color de fondo gris claro. Desactiva la opción transparente.
Si todo va bien, su título tiene que haber quedado así:
29. Visualice el listado. Su aspecto debe ser más o menos el siguiente:
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. La diferencia entre Título y Encabezado de Página es que lo que escriba en el título aparecerá en la parte superior de la primera página (y ninguna más), mientras que lo que escriba en el encabezado de página aparecerá en la parte superior de todas las páginas del listado. 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:
En el ejemplo, se ha asignado un tamaño de letra de 12, y además se ha puesto en negrita el texto del primer cuadro.
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. El resultado será el siguiente:
37. Visualice el resultado del informe. Debe tener el siguiente aspecto:
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í:
39. La imagen del logotipo aparecerá en el recuadro que acabamos de hacer. Es necesario que se copie el fichero de la imagen en la misma carpeta que donde está guardado el informe. En nuestro caso, en la carpeta Mis Documentos. Usaremos la imagen nenúfares.jpg que se suele encontrar en la carpeta Mis Imágenes como logotipo para el informe. Así pues, copie el fichero nenúfares.jpg desde la carpeta Mis Imágenes a la carpeta Mis Documentos.
40. Una vez copiado el fichero de la imagen en la misma carpeta que el informe, tenemos ahora que usar la propiedad del cuadro de imagen llamada Expresión Imagen, en ella tendrá que escribir el nombre del fichero de imagen entre comillas dobles:
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.
Pie de columna (columnFooter) Lo que se coloque aquí aparecerá siempre debajo del listado de datos, en todas las páginas. Título (title) Aquí se coloca el título del informe. Aparecerá en la parte superior de la primera página únicamente.
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 Página (pageFooter) Lo que se coloque aquí aparecerá en la parte inferior de todas las páginas (menos en la última). Ideal para colocar números de página.
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 iReport permite la creación de informes desde cero, lo que da más versatilidad a la hora de diseñar el listado. 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. El informe se divide en zonas, y los elementos se colocarán en dichas zonas según donde queramos que aparezcan dichos elementos en el informe final. Para introducir texto en el informe se usará la opción texto estático. Si se quiere que aparezca un dato de la base de datos, entonces habrá que introducir un campo. También se pueden colocar líneas, recuadros, imágenes, etc. 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. 2. Vamos a crear un informe desde cero donde aparezca el listado de servicios realizados. Interesa en principio que aparezca la fecha del servicio el tipo del servicio y la cantidad cobrada. Para ello active la opción Fichero – Nuevo Documento. 3. Asigne el nombre informeservicios al informe. 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. 6. En la pantalla que aparece debes introducir la siguiente consulta SQL: select * from servicios order by fecha
7. Acepta la pantalla anterior. Ya podemos empezar a diseñar el informe. Empezaremos por poner un título. El título será “Listado de Servicios”. Agrande la letra del título y céntrelo.
8. Ahora añadiremos los textos de la cabecera. En la zona de Encabezado de columna (columnHeader) añadiremos los siguientes cuadros de texto estático:
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. 12. El listado tendrá la siguiente forma:
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:
Aplica los cambios. 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) Lo que introduzca en la zona pageFooter aparecerá en la parte inferior de cada página en todas las páginas del listado excepto en la última página. En el caso de la última página la zona que hace esta función es la zona llamada lastPageFooter (último pie de página) Para que la zona pageFooter afecte a todas las páginas del informe incluyendo la última, es necesario ocultar la zona lastPageFooter. Veamos como se hace esto: 20. Haga clic con el botón derecho del ratón sobre la zona lastPageFooter y elija Propiedades de banda.
21. Aparecerá un cuadro de opciones donde se podrá elegir el tamaño de la zona. En nuestro caso indicaremos un cero y aplicaremos. Luego cerraremos el cuadro de opciones.
22. Se podrá observar entonces como hemos ocultado la zona lastPageFooter. Al hacer esto, la zona pageFooter tendrá control sobre todas las páginas incluyendo la última.
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.
26. El pie tiene que haber quedado más o menos así:
27. Ahora visualice el informe y observe la parte inferior (si cambia el zoom al 50% podrá tener una vista global del informe):
Verá que en la parte inferior aparece el número de la página y la fecha en el formato indicado.
28. Supongamos ahora que nos interesa tener una columna IVA en la que aparezca el 16% de IVA de cada una de las cantidades. Desgraciadamente, este campo no existe en la tabla servicios, de la que hemos extraído los datos. Sin embargo, es posible crear este campo directamente en la consulta SQL realizando el cálculo. Active la opción Datos – Consulta del Informe para acceder a la consulta que introducimos al principio.
29. Cambie la consulta por la siguiente instrucción SELECT (respete mayúsculas y minúsculas): 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
Cálculo que se realiza
Nombre del campo calculado
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.
31. Por supuesto, sería interesante añadir un texto estático en el encabezado de columnas:
32. Visualice el informe resultante:
33. Para hacer otro ejemplo de campos calculados, entre en la consulta del informe y modifique la instrucción SQL de forma que quede así: select Fecha, Tipo, Cantidad, Cantidad*0.16 as IVA, IVA+Cantidad as Total from servicios order by fecha
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:
35. Visualice el informe. Debe tener este aspecto:
36. Hemos aprendido a agregar campos calculados a partir de otros campos, y añadirlos al listado. Ahora aprenderemos a realizar cálculos de totales, o cálculos resumen. 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) 37. Empezaremos agregando en la zona summary una línea corta:
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.
43. El informe está terminado. Guárdelo y ciérrelo.
CONCLUSIÓN SQL permite la creación de campos calculados a partir de otros campos en una consulta SELECT. Esta característica es muy útil por ejemplo en el caso de los informes, ya que nos permite mostrar cálculos en ellos. iReport, además, proporciona la posibilidad de realizar sumas totales de campos. Recuerde también el uso de las distintas zonas del informe: -
Title – Título: Usado para colocar el título del informe. Aparece en la primera página únicamente.
-
pageHeader – Encabezado de página: En el se coloca aquello que deba aparecer en la parte superior de todas las páginas.
-
columnHeader – Encabezado de columna: Usado para colocar la cabecera del listado.
-
Detail – Detalle: Usado para colocar los datos (campos)
-
columnFooter – Pie de Columna: En el se coloca aquello que deba aparecer en la parte inferior del listado en todas las páginas.
-
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.
-
lastPageFooter – Ultimo pie de página: Es el pie de página de la última página. Si se desactiva, entonces es sustituido por el pageFooter.
-
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... Es decir, el listado de trabajadores se dividiría en grupos según las distintas profesiones de los trabajadores. En esta hoja guiada se verá como realizar este tipo de listados.
EJERCICIO GUIADO Nº 1. CREACIÓN DE UN INFORME AGRUPADO
1. Entra en iReport. 2. Crearemos un informe en el que aparezca el listado de servicios realizados. Usaremos el mago de informes para hacer este listado. Para ello active la opción Fichero – Mago de informes. 3. La conexión a usar será Conexión con MANEMPSA. Y la consulta SQL será la siguiente: select * from servicios order by tipo (Nota: observe que hemos ordenado la consulta por tipo. Luego verá por qué) Pulse el botón Próximo. 4. Los campos a añadir al listado serán: Número, Fecha, Tipo y Cantidad. Pulse el botón Próximo. 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”:
8. Visualice el informe y observe el resultado (al visualizarlo iReport le pedirá que lo guarde. Guárdelo con el nombre serviciosagrupados):
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: Es posible agregar distintos niveles de agrupamiento a un informe. Usando el ejemplo del inicio de esta hoja, podríamos tener un listado de trabajadores agrupado por profesiones y por estado civil. En este caso, aparecería un grupo por cada profesión, y, cada grupo, estaría a su vez subdividido en grupos según el estado civil. Por ejemplo, el grupo de bomberos podría tener el siguiente aspecto: 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. En el ejemplo de los trabajadores, la consulta podría tener este aspecto: select * from trabajadores order by profesión, estado Se anima al alumno que experimente con esta posibilidad.
CONCLUSIÓN Un informe agrupado es aquel en que los registros aparecen en distintos grupos. Los elementos de un grupo tienen la misma característica. Se puede decir que un informe agrupado consiste en una serie de sub-listados. 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
Conexión con Informes desde Java 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
1. Entra en iReport y abra el informe serviciosagrupados (se encontrará en la carpeta Mis Documentos) 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.
(Nota: Si le echa un vistazo a la carpeta Mis Documentos, verá también un fichero llamado serviciosagrupados.bak. Este fichero es simplemente una copia de seguridad que se crea automáticamente al guardar el informe.) 2. Vamos a ver el aspecto del informe. Pulse el botón: 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 4. Los ficheros .jasper generados se suelen almacenar dentro de la carpeta del programa iReport, sin embargo, nosotros configuraremos el programa iReport para que los ficheros compilados se almacenen directamente en la carpeta Mis Documentos, de forma que estén más accesibles. Para ello, active la opción Opciones – Opciones:
5. En el cuadro de opciones que aparece active la pestaña Compilador.
6. En el primer recuadro que aparece se tiene que indicar el directorio donde aparecerán los ficheros compilados. Para ello, pulse el botón Explorar y seleccione la carpeta Mis Documentos. Si todo va bien, el resultado será parecido al siguiente:
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
1. Entra en NetBeans y crea un nuevo proyecto Java. El proyecto se llamará PruebaInformes y contendrá un paqueteprincipal. Este paquete a su vez contendrá una ventanaprincipal.
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. Como ve, es algo parecido a lo que hacemos con la base de datos. Así pues crea la carpeta Informes dentro de la carpeta de proyecto y copia el fichero serviciosagrupados.jasper dentro de ella. 5. Crea un botón en la ventana de tu proyecto. El botón contendrá el texto “Informe Agrupado” y su nombre será btnInformeAgrupado.
6. El objetivo es hacer que aparezca el informe serviciosagrupados cuando se pulse este botón. Para ello, programe lo siguiente en el actionPerformed del botón:
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:
JasperPrint informe = JasperFillManager.fillReport(rutainforme,null,conexión);
•
Esta línea es la que genera el informe que se va a mostrar. El informe en java es un objeto del tipo JasperPrint y es creado a través de otro objeto del tipo JasperFillManager.
•
Es interesante que observes el uso de un método llamado fillReport (rellenar informe) que se encarga de rellenar el informe con datos.
•
Este método necesita tres parámetros: -
•
El sitio donde se encuentra el fichero del informe. Los parámetros (Null en nuestro ejemplo. Los parámetros se estudiarán en próximas hojas guiadas) Y el objeto conexión, que le permite a java acceder a la base de datos para recoger los datos que se presentarán en el informe.
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.
JasperViewer ventanavisor = new JasperViewer(informe,false);
•
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 Empezaremos añadiendo el fichero commons-collections-2.1. Selecciónelo y active Abrir:
10. Observará que se ha agregado el fichero a la zona de bibliotecas:
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:
13. Tiene que agregar el import para la clase JasperFillManager: net.sf.jasperreports.engine.JasperFillManager 14. Ahora agregue el import para la clase JasperPrint: net.sf.jasperreports.engine.JasperPrint 15. Y finalmente agregue el import para la clase JasperViewer: net.sf.jasperreports.view.JasperViewer
16. Los errores han desaparecido. Ya puede ejecutar el programa. 17. Si pulsa sobre el botón Informe Agrupado aparecerá el informe. 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. Veamos como hacer esto. Primero añada otro botón btnImprimirDirectamente a su ventana:
19. Ahora programe dentro de él lo siguiente:
El código es similar al anterior, solo que se elimina todo uso del objeto JasperViewer (ventana visualizadora) ya que el informe ya no debe salir en pantalla. Además se añade una nueva línea: 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:
Si estuviera a false, este cuadro de diálogo no aparecería y el informe se enviaría directamente a la impresora configurada por defecto en el ordenador. En nuestro caso, al tener el valor true, este cuadro sí aparecerá. 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: commons-collections-2.1, commons-logging-1.0.2 y jasperreports-2.0.1 Una vez agregadas estas librerías, el proceso para imprimir un informe es el siguiente: -
Crear un objeto del tipo JasperPrint (el informe) Crear un objeto visor (JasperViewer) que permita visualizar el informe. O bien imprimir directamente el informe con un objeto JasperPrintManager.
EJERCICIO GUIADO. JAVA. INFORMES CON PARÁMETROS
Conexión con Informes desde Java: Parámetros 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. En esta hoja se verá un ejercicio paso a paso de uso de parámetros en la consulta de informe, y de esta manera entender la utilidad de esta característica.
EJERCICIO GUIADO Nº 1. CREACIÓN DE UN INFORME CON PARÁMETROS
1. Entra en iReport y abre el informe llamado serviciosjuan, realizado en una de las últimas hojas guiadas. Este informe, concretamente, fue construido desde cero y mostraba los servicios del trabajador Juan Pérez:
2. Visualízalo para recordar su aspecto:
3. Este informe tiene un gran diseño pero está muy limitado, ya que solo es capaz de mostrar el listado de servicios realizados por el trabajador Juan Pérez (DNI 12.321.567-B) Si quisiéramos sacar el listado de servicios de otro trabajador, este informe no nos serviría. 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. 4. Acceda a la consulta del informe a través de la opción Datos – Consulta de informe y obsérvela:
La consulta SQL extrae información de aquellos servicios que hayan sido realizados por el trabajador con DNI 12.321.567-B.
5. Cambie la consulta para que quede así:
Lo que acaba de añadir es un parámetro llamado DNI. Observe su estructura: $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.
11. Cierre iReport, guarde los cambios y pase al siguiente ejercicio.
EJERCICIO GUIADO Nº 2. USO DE PARÁMETROS DE UN INFORME DESDE JAVA
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. El botón se llamará btnServiciosTrabajador y el cuadro de texto se llamará txtDNI.
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. 3. De momento copie el fichero serviciosjuan.jasper dentro de la carpeta informes de su carpeta de proyecto. 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) 5. Ahora programe el siguiente código en el actionPerformed del botón Servicios Trabajadores.
Estudiemos con detenimiento este código. 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. Observe la segunda línea, en ella se define el parámetro llamado “DNI” y se le asigna a él el valor del cuadro de texto del DNI, es decir, el DNI que haya escrito el usuario. 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. JasperPrint informe = JasperFillManager.fillReport(rutaInforme,parametros,conexion);
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.
6. Ejecute el programa y pruebe a introducir un DNI existente en el cuadro de texto del DNI. Si escribió correctamente el DNI, podrá ver el listado de servicios realizados por el trabajador con dicho DNI. Como puede observar, ahora ya puede visualizar los datos de los servicios de cualquier trabajador y no solo del trabajador Juan Pérez. El uso de parámetros en los informes da potencia y versatilidad a las aplicaciones, y es algo muy usado.
Trabajos realizados por Ana Ruiz
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: select * from trabajadores, servicios where trabajadores.dni=servicios.dni and $P!{COND} order by servicios.fecha
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: Map parametros = new HashMap(); parametros.put(“COND”, “trabajadores.sueldo>200”);
Observa que el valor del parámetro es una condición entera. Cuando se quiera usar un parámetro que represente a un dato, se usará la siguiente sintaxis: $P{nombreparámetro} Cuando se quiera usar un parámetro que represente a una condición, se usará la siguiente sintaxis: $P!{nombreparámetro} (Observa el uso de la admiración !)
CONCLUSIÓN 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. Un parámetro puede referirse a un dato concreto, o a una condición. Si el parámetro se refiere a un dato concreto, entonces tiene la siguiente forma: $P{nombre} Si el parámetro se refiere a una condición, entonces tiene la siguiente forma: $P!{nombre} El parámetro debe ser sustituido por un valor que es proporcionado desde la aplicación java, y es entonces cuando la instrucción SQL se completa y se ejecuta. 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
Distribución e Instalación de programas en Java Una vez que se ha finalizado el programa, debemos prepararlo para la instalación en el ordenador del cliente. Para ello, es necesario tener en cuenta todos aquellos ficheros externos que han sido necesarios para la programación de la aplicación: base de datos, imágenes, informes, etc... A continuación se indican las cosas a tener en cuenta a la hora de realizar una distribución de nuestro proyecto.
1. En primer lugar es necesario pulsar el botón Limpiar y construir proyecto principal. Este botón compila el programa y crea una carpeta llamada dist dentro de la carpeta del proyecto, la cual será la carpeta “distribuible”.
(Si hubiera un error de compilación el proceso se detendría y aparecería un mensaje de error)
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:
3. Entre dentro de esta carpeta y observe su contenido:
4. Observará la existencia de un fichero con extensión .jar. Este fichero se puede decir que es el “ejecutable” del programa. El fichero .jar contiene todas las clases que ha programado en su proyecto. 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 está usando imágenes en su programa (para la presentación, los iconos de los botones de las barras de herramientas, etc.) tendrá que introducir los ficheros de estas imágenes dentro de la carpeta distribuible. 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. Estos ficheros estarán normalmente dentro de una carpeta llamada Informes, si es usted ordenado. En ese caso, copie la carpeta con los informes dentro de la carpeta del distribuible, la cual quedaría ahora así:
9. Imágenes de informes. Si los informes del programa usan imágenes, la situación de estas en la carpeta distribuible depende de la forma en que haya configurado dichas imágenes en el iReport. Normalmente, al crear una imagen en el informe, asignamos simplemente el nombre del fichero de imagen, suponiendo que la imagen se encontrará en la misma carpeta que el informe:
En este ejemplo, el informe usa un fichero de imagen llamado “logo.jpg” que se encuentra en la misma carpeta que donde se ha guardado el informe.
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í:
Se indica que las imagen “logo.jpg” estará dentro de una subcarpeta Imágenes.
12. Si modifica sus informes con imágenes de esta forma y los recompila, entonces podrá organizar su carpeta distribuible de esta manera:
La carpeta Informes contiene los .jasper
La carpeta Imagenes contiene todas las imágenes del programa así como las imágenes usadas por los informes.
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. Antes de hacer esto, se recomienda que compruebe que el programa funciona, ejecutando el fichero .jar de dicha carpeta. Compruebe que la ubicación de la base de datos, los informes y las imágenes es la correcta.
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. La instalación consistirá básicamente en copiar la carpeta dist al ordenador del cliente, y en instalar la máquina virtual de java en el caso de que el cliente no la tenga instalada. 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.
Instalación de programas Java 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. El programa IZPack se proporciona en la carpeta Herramientas de la carpeta compartida del curso, aunque puedes bajarte la última versión de forma gratuita desde esta página web: http://www.izforge.com/izpack/ Antes de empezar con esta hoja guiada instala el programa IZPack en tu ordenador. El programa se instalará en la carpeta Archivos de Programa/Izpack, a no ser que se escoja otro lugar. Dentro de la carpeta Izpack encontrará otra carpeta llamada Bin, y dentro de esta encontrará un fichero .bat llamado compile que será el que use para crear los instalables.
Creación de un Instalable con IZPack. PREPARACIÓN.
1. Lo primero que debes hacer es crear la carpeta Distribuible (dist) de tu programa si es que no la has creado ya. 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. 4. Busca un icono para tu programa y almacénalo también en la carpeta del Distribuible. Este fichero será del tipo ico (fichero de icono) y se guardará con el nombre icono.ico en la carpeta del 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. El contenido de este fichero estará escrito en un lenguaje llamado XML y será el siguiente (no se preocupe si no entiende el contenido, solo fíjese en los textos remarcados):
Nombre del Programa Versión http://www.mipagina.es/
classname="HelloPanel"/> classname="InfoPanel"/> classname="LicencePanel"/> classname="TargetPanel"/> classname="PacksPanel"/> classname="InstallPanel"/> classname="ShortcutPanel" /> classname="SimpleFinishPanel"/>
Ficheros y Carpetas del Programa
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: -
Datos del programador. En la primera parte del fichero se indican los datos del programador y del programa. Observe: Pon aquí el nombre de tu programa.
Nombre del Programa Versión Y aquí la versión http://www.mipagina.es/ Escribe aquí tu nombre, 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:
Ficheros y Carpetas del Programa 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 introducido en la carpeta distribuible.
Usted tendrá que indicar el nombre que le 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):
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:
tu programa, el nombre que le quieras dar al acceso directo, el fichero ejecutable .jar de tu programa (aquí suponemos que se llama gestion.jar, tu tendrás que averiguar como se llama el tuyo) y el nombre del fichero de icono.
Esta parte crea un icono para desinstalar el programa. Debes indicar el nombre que le quieres dar a este acceso directo. Aquí lo hemos nombrado “Desinstalar Taller Mecánico”, porque el programa gestiona un taller. En vuestro caso tendréis que indicar el nombre adecuado según vuestro programa.
Creación de un Instalable con IZPack. GENERACIÓN DEL INSTALABLE.
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
El resultado será que accederás a la carpeta del programa IZPACK:
3. Una vez dentro de la carpeta del programa IzPack, debes ejecutar el siguiente comando: bin\compile
camino\carpeta\install.xml -b
camino\carpeta
Donde camino\carpeta es el camino de la carpeta distribuible de tu proyecto. 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: bin\compile
c:\proyectos\dist\install.xml -b
c:\proyectos\dist
4. Al ejecutar este comando, se generará un fichero llamado install.jar dentro de la carpeta distribuible. Este es el fichero de instalación. 5. Si ejecuta este fichero aparecerá un programa de instalación que le guiará a través de varios pasos por la instalación de su programa. El resultado será que instala su programa en el menú inicio e incluso, si activa la opción correspondiente durante la instalación, se creará un acceso directo en el escritorio a su programa.
Creación de un Instalable con IZPack. DISTRIBUCIÓN DEL 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. 3. Es necesario que el cliente tenga instalada la máquina virtual de java en su ordenador para que la instalación sea posible. Por eso es recomendable incluir en el CD la máquina virtual de java para que el usuario pueda instalarla también antes de instalar su programa.
CONCLUSIÓN La distribución de un programa java es tan sencilla como copiar la carpeta distribuible dist en el ordenador del cliente. Sin embargo, si el cliente carece de conocimientos básicos de informática podemos crear un fichero de instalación dentro de la carpeta distribuible para que el usuario solo tenga que entrar dentro de ella y hacer doble clic sobre el fichero de instalación. Para generar el fichero de instalación, es necesario usar un programa llamado IZPACK. Se introducirán varios ficheros dentro de la carpeta distribuible, necesarios para la creación del instalable, y luego se generará el instalador. Una vez creado el instalador dentro de la carpeta distribuible, esta se copiará en un CD y se pasará al cliente. Es recomendable que el CD contenga la máquina virtual de java para que el cliente también la pueda instalar. 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.
