Texto de Programacion Visual II

Texto para el curso de
Programación Visual II
del IV ciclo de la escuela
de Ingeniería de
Sistemas de la ULADECH
VISUAL JAVA CON BASE

DE DATOS USANDO
NETBEANS
Contiene el uso de objetos del paquete swing, conexión y acceso a la base de datos
usando el DBMS MySql, mantenimiento de datos, consultas de datos, reportes de
datos. Uso de procedimientos almacenados
Elaborado por:
Ing. Martín Salcedo

Quiñones
Universidad Católica Los Ángeles de Chimbote – Programación Visual II
INDICE
Página
CAPITULO I: Otros objetos del paquete swing 03

Los objetos JTextArea y JToolBar 04
Objetos JSlider y JPregressBar 12
Objetos JPasswordField y JInternalFrame 21
Objetos JDialog, JTree y JformattedTextField 30
CAPITULO II: Acceso y Mantenimiento de Datos 42
Conexión a la Base de Datos con JDBC 43
Acceso a la Base de Datos con JDBC 61
Objeto JTable y comandos SQL en Mantenimiento de Datos 75
Uso de comandos SQL para Mantenimiento de datos de varias tablas 91
Procedimientos almacenados para mantenimiento de datos 106
CAPITULO III: Consulta de datos 125
Objeto JTable y comando Select en Consulta de Datos 126
Uniones y subconsultas en consulta de datos 136
Procedimientos almacenados en consulta de datos 149
CAPITULO IV: Reporte y Desarrollo de un Sistema 163
Diseño de reportes con Ireport 164
JaspertReport y SubReports con Ireport 181
Desarrollo de un Sistema 202
Ing. Martín Salcedo Quiñones Página 2

CAPITULO I
OTROS OBJETOS DEL PAQUETE SWING

LOS OBJETOS JTEXTAREA Y JTOOLBAR
Objeto JTextArea
JTextArea es un componente que crea un área de texto; este componente

pertenece al paquete java.lang.Object y tiene algunas propiedades que debemos
conocer:
La primera es que su tamaño es el justo para el texto que lleva dentro. Es decir,
inicialmente, su tamaño es de una fila de letras de alto y cero pixeles de ancho, ya
que no tiene texto. Según vamos escribiendo, va cambiando de tamaño. No es
buena idea dejarlo así, ya que nos pueden pasar cosas raras. En el constructor del
JTextArea podemos decirle cuántas filas queremos que tenga y cuántas columnas.
En el ejemplo vamos a poner 10 filas y 50 columnas, pero también se puede
agregar algún texto en nuestros JTextArea, como se verá a continuación:

JTextArea jtx = new JTextArea(); //sin parámetros
JTextArea jtx = new JTextArea(10,50); //número de filas y columnas
JTextArea jtx = new JTextArea( "Texto dentro de JTextArea" ); //cadena de texto
La segunda es que un JTextArea no tiene barras de scroll, así que si escribimos

más de la cuenta, simplemente dejaremos de ver lo que escribimos. Para poner
barras de scroll tenemos en Java el JScrollPane, un panel que admite dentro un
componente. Para ingresar nuestro JTextArea dentro del JScrollPane debemos
agregarlo como parámetro, y para que se activen los scroll debemos agregarle un
comando específico para ello, este método se llama setViewportView() del
JScrollPane y se implementa de la siguiente forma:
JScrollPane scroll = new JScrollPane();

scroll.setViewportView(jtx);
La tercera cosa que debemos saber es que el JTextArea por defecto no hace
automáticamente los saltos de líneas. Es decir, si nosotros no hacemos de forma
manual los saltos de línea, nuestro texto se escribirá en una línea de varios
kilómetros. Para solucionar esto existen dos métodos: el primero corta las líneas de
forma automática, pero no respeta las palabras, es decir las corta al momento de
llegar al final de la línea sin importar si hay un espacio o no; el segundo método
complementa al primero haciendo que las palabras de corten sólo cuando
encuentra un espacio cerca. Los métodos son los siguientes:
// Para que haga el salto de línea en cualquier parte de la palabra:

jtx.setLineWrap(true);
// Para que haga el salto de línea buscando espacios entre las palabras
jtx.setWrapStyleWord(true);
Con todo esto, la forma de crear el JTextArea y añadirlo al JFrame será así:
import javax.swing.*;
import java.awt.*;
public class VentanaEjemplo1{
public static void main(String[] args) {
JFrame ventana = new JFrame("Mi Ventana");

ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JTextArea jtx = new JTextArea(10,50);
jtx.setLineWrap(true);
jtx.setWrapStyleWord(true);
JScrollPane scroll = new JScrollPane(jtx);
ventana.getContentPane().add(scroll, BorderLayout.CENTER);
ventana.add(scroll);
ventana.pack();//método utilizado para que se muestren los //elementos de la ventana
ventana.setVisible(true);
Una vez ejecutado esta programación, se visualiza lo siguiente (en ejecución

agrego mi nombre):
Lo cuarto es que nuestros JTextArea pueden ser editados por el usuario o puede
ser de sólo lectura, dependiendo de la propiedad setEditable(), el valor booleano
false sólo da permiso de lectura:
texto.setEditable(false);
La quinta cosa importante que debemos mencionar es que podemos modificar es

que podemos modificar muchas cosas a nuestro JTextArea, entre ellas están el
tamaño, el tipo y la fuente de la letra como también podemos modificar el color de
la letra y del fondo; la forma más simple de modificar las letras es crear un tipo de
letra y luego entregarla como parámetro:
Font font = new Font("Verdana", Font.ITALIC, 12);
jtx.setFont(font);
Cuando creamos el tipo de fuente primero debemos entregar el nombre de la

fuente, luego el formato en que la queremos:
Normal=PLAIN
Cursiva=ITALIC
Negrita=BOLD
Y finalmente el tamaño de la letra. Para cambiar el color de la letra debemos utilizar

el método:
jtx.setForeground(Color.white);
Para cambiar el color de fondo de nuestro JTextArea debemos utilizar el método:

jtx.setBackground(Color.black);
Finalmente veamos un ejemplo donde se muestran la mayoría de los componentes:
import java.awt.*;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
public class JTextAreaTest{
public static void main (String [] args) {
//Método para cambiar la decoración de la ventana en sí,

//si ponemos el valor en falso la ventana se verá de la forma predeterminada de
Windows
JFrame.setDefaultLookAndFeelDecorated(true);
//creamos el JFrame principal donde agregaremos el resto de objetos
JFrame frame = new JFrame ("JTextArea Test");
frame.setLayout (new FlowLayout ());
frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
String text = "Un objeto JTextArea es una área multilínea para escribir texto. "
+ "Se puede cambiar el número de líneas que se mostrarán, "
+ "y también el numero de columnas. Puedes cambiar las fuentes y tamaños de

letras. "
+ "Y puedes agregar tu TextArea en un JScrollPane para poder mover las zonas de
texto." ;
//creamos un area de texto normal no redimensionable
JTextArea textAreal = new JTextArea(text,20,10);
textAreal.setPreferredSize(new Dimension (10,100));
//creamos otra área de texto con un JScrollPane, sólo es agregado
JTextArea textArea2 = new JTextArea(text,20,10);
JScrollPane scroll = new JScrollPane(textArea2);
frame.getContentPane().add(scroll, BorderLayout.CENTER);
frame.add(scroll);
//El método setLineWrap lo que hace es ordenar las palabras para que no se salgan
de los márgenes,
//si lo desactivamos(false), el texto se escribirá hacia el lado(en una línea) y no se

vería todo si el //texto es muy largo
textAreal.setLineWrap (true);
textArea2.setLineWrap (true);
textAreal.setWrapStyleWord(true);
textArea2.setWrapStyleWord(true);
//agregamos los area de texto al frame principal,
//nota: el textArea2 está dentro de un JScrollPane, por eso éste es el que agregamos
al frame
frame.add(textAreal);
frame.add(scroll);
//el metodo pack sirve para dejar todo dentro del frame
frame.pack();
//y finalmente el metodo setVisible es para que se visualice la ventana
frame.setVisible(true) ;
Una vez ejecutado la programación se visualiza:

Objeto JToolBar
Esta clase implementa una barra de herramientas, formada normalmente por

botones o controles que incluyen iconos y que aparecen organizados como una fila
o una columna dependiendo de la zona de la pantalla donde se coloque.
Una barra de herramientas que puede cambiarse de situación por los diferentes
bordes de su contenedor, e, incluso, llevarse fuera (este comportamiento puede
variarse: método setFloatable). Las herramientas suelen ser (aunque no
necesariamente) botones. Útil para proporcionar controles que dan acceso rápido a
acciones, normalmente disponibles a través de menú. Mediante el método
addSeparator es posible añadir separadores. JToolBar es, en realidad, una
especialización de Box. A continuación un ejemplo:
import java.lang.*;
import java.awt.*;
import java.awt.event.*;
public class EjemploJToolbar {
public static void main(String[] args){

// area de definicion de propiedades de el objeto
JFrame ventana = new JFrame();
ventana.setTitle("Ejemplo de JToolBar");
ventana.setDefaultCloseOperation(ventana.EXIT_ON_CLOSE);
ventana.setBounds(200,250,200,70);
// llamada JToolBar
JToolBar barra = new JToolBar("barra");
//creación de botones
JButton copiar = new JButton("Copiar");
JButton cortar = new JButton("Cortar");
JButton pegar = new JButton("Pegar");
//cargando toolbar panel con sus componentes
barra.add(copiar);

barra.add(cortar);
barra.add(pegar);
// cargando la ventana con el toolbar
ventana.getContentPane().add(barra);
ventana.setResizable(false);
}
}
Una vez ejecutado el programa se muestra lo siguiente:
También se puede considerar utilizar las siguientes opciones para JToolbar:
barra.addSeparator(); //añade un separador
barra.setFloatable(false); //impide que se pueda mover de su sitio
barra.setOrientation(JToolBar.VERTICAL); //pone la orientación vertical

OBJETOS JSLIDER Y JPROGRESSBAR
Objeto JSlider
Se utiliza un JSlider para permitir que el usuario introduzca un valor numérico

limitado por un valor máximo y un valor mínimo. Mediante la utilización de un Slider
en vez de TextField, se eliminan errores de entrada.

Primero construyamos una clase que llamaremos “JSlider”, e importamos todas las
clases que usaremos: javax.swing.* y javax.swing.event.* como también java.awt.*
y java.awt.event.* De igual manera importaremos la clase JSlider y JFrame aunque
estas vengan en javax.swing.*, por si a alguien le causa problemas. Todo esto
debiera quedar así:
import javax.swing.event.*;
import java.awt.*;
import javax.swing.JSlider;
public class Slider{
//código
Ahora en la sección de “//código” se realizara todo lo que tenga que ver con nuestro
JSlider, y los detalles para poder verlos en una ventana como en la imagen anterior.
Crearemos rápidamente un JFrame, un Jpanel para poder pegar y visualizar

nuestro JSlider
//código:
JFrame ventana = new JFrame("COme On!!");

ventana.setSize(400, 400);
JPanel panel = new JPanel();
//Crearemos nuestro JSlider a continuación, cada línea con una breve descripción, luego
se explicara con más //detalles
slider = new JSlider(JSlider.VERTICAL, 0, 100, 25); /*(posición vertical, comienza,
termina, donde comienza al iniciar programa)*/
slider.setInverted(false); //se invierte el relleno del JSlider (desde donde comienza)
slider.setPaintTicks(true); //las rayitas que marcan los números
slider.setMajorTickSpacing(25); // de cuanto en cuanto los números en el slider
slider.setMinorTickSpacing(5); //las rayitas de cuanto en cuanto
slider.setPaintLabels(true); //si se ve los números del slider
slider.addChangeListener(new MiAccion()); //Agrega un escuchador al slider creado, lo
cual se usara luego
/*Ahora, aunque no pertenece a la clase JSlider, crearemos un JLabel en el cuál se
mostrara el numero en el cual se encuentre el slider en ese momento*/
label = new JLabel("LEts Go!!°"); /*Crea un JLabel el cual muestra el numero en el que
esta el JSlider y de inicia con la frase LEts Go!!° */
Explicaremos un poco más detallado el constructor presente y cada método (el

método se encontrara en cursiva):
Constructor:

slider = new JSlider(JSlider.VERTICAL, 0, 100, 25): Se inicializa el objeto del
JSlider con nombre slider con los siguientes parámetro: _JSlider.VERTICAL, este
parámetro especifica la forma del nuestro slider si se crea en forma Vertical u
Horizontal (JSlider.HORIZONTAL).
*0, el segundo parámetro indica el tamaño mínimo de el JSlider.
*100, el tercer parámetro indica el tamaño máximo de el JSlider.
*25, el cuarto parámetro indica la posición en la cual se inicia el JSlider.
Métodos:
_ slider.setPaintLabels(true): Muestra una etiqueta con números designados en el

método setMajorTickSpacing(25) el cual el numero 25 indica mostrar numero de 25
en 25 partiendo del minimo establecido en el JSlider.
_ slider.setInverted(false) : Recibe una variable Booleana (true o false),

dependiendo cual sea su parámetro el JSlider tendrá su mínimo en un lado o el
otro.
_ slider.setPaintTicks(true): Este método muestra Ticks (líneas) que delimitan se

según los métodos setMajorTickSpacing() y setMinorTickSpacing().
_ slider.setMinorTickSpacing(5): Este método muestra Ticks (líneas), los cuales

equivalen a avanzar de 5 en 5 en este caso (se necesita método setPaintTicks()
con parámetro true).
_ slider.setMajorTickSpacing(25): Muestra Ticks mayores, con un numero al lado,

de 25 en 25, en este caso, partiendo del valor mínimo dado al JSlider (si el método
setPaintTicks() esta con parámetro false, solo se mostraran el numero
correspondiente).
Luego de haber explicado los métodos usados en nuestro JSlider (no son los
únicos métodos existentes a todo esto), continuaremos con el fin del programa que
consiste en: Luego de haber creado nuestro JSlider, y nuestro JLabel, lo siguiente

será agregar estos elementos al JPanel creado anteriormente, para luego agregar
el JPanel a la ventana (JFrame), para poder visualizar nuestra creación.
Y esto se realiza con el siguiente código:
panel.add(label); // add sirve para agregar nuestro label al panel creado

panel.add(slider); /*Ahora ya están agregados tanto el label como nuestro slider al
panel*/
Luego agregamos a nuestro panel (JPanel) a la ventana (JFrame), puesto que gracias a
está podemos ver nuestro JSlider en acción, esto se realiza Con el siguiente código:
ventana.add(panel); //Agrega panel a la ventana(JFrame).

ventana.setVisible(true); //Hace que la ventana sea “visible a nuestros ojos”.
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); /*Al presionar la X de la
ventana el programa terminara (al cerrar la ventana).*/
Luego de haber generado el código para el JSlider, se procederá a crear el método,

el cuál logra hacer q nuestra label se valla actualizando y lanzando el número en la
cual se valla posicionando nuestro JSlider.
public static class MiAccion implements ChangeListener{ /*aquí se empieza a crear el

método. */
public void stateChanged(ChangeEvent e){
int evaluo = slider.getValue(); /*toma el valor que tiene el slider y lo guarda como
entero */
String nose = Integer.toString(evaluo); /*En nose guarda nuestro entero evaluo como
un string */
label.setText(nose); /*actualiza nuestro label al valor en el que se encuentra nuestro
JSlider */
}
}
Luego de haber visto por partes nuestro código vamos a ajustar nuestros últimos
detalles en el código completo.
import javax.swing.event.*;
import java.awt.*;
import javax.swing.JSlider;
public class Slider{
static JSlider slider; /*se deben instanciar antes para poder usarlos en el método creado
mas abajo */
static JLabel label; /*y a la vez estaticos (static) también para poder ser usados en
nuestro método creado. */
public static void main(String[] args){
JFrame ventana = new JFrame("COme On!!");
ventana.setSize(400, 400);

slider = new JSlider(JSlider.VERTICAL, 0, 100, 25);
slider.setInverted(false);
slider.setPaintTicks(true); slider.setMajorTickSpacing(25);
slider.setMinorTickSpacing(5); slider.setPaintLabels(true);
slider.addChangeListener(new MiAccion());
label = new JLabel("LEts Go!!°");
panel.add(label);
panel.add(slider);
ventana.add(panel);
}
public static class MiAccion implements ChangeListener{
public void stateChanged(ChangeEvent e){
int evaluo = slider.getValue();
String nose = Integer.toString(evaluo);
label.setText(nose);
}
}
}
Al momento de la ejecución de la programación antes analizada, se visualiza la

siguiente ventana:
Objeto JProgressBar
Seguramente, todos alguna vez hemos grabado o cargado un nuevo programa en
nuestro equipo, y mientras se realizaba esa grabación algo nos indicaba cuánto se
llevaba completado de la operación o cuánto faltaba. Este es sólo un ejemplo de los
muchos casos en los que los indicadores de progreso son útiles.
Por norma general, un buen programa o un programa amigable utilizará estas
herramientas cuando una operación tarde en completarse un tiempo prudencial.

Java, a través de su paquete Swing, proporciona la clase JProgressBar. Una barra
de progreso no es más que una barra que nos indica el tanto por ciento de la tarea
que se lleva realizada.
Una aplicación sencilla en la que un botón hará que el incremento de la barra de

progreso progresivamente de 0 a 100 en cinco segundos. Esto le introducirá otra
lección importante en Java: multithreading, que permite ejecutar múltiples tareas en
su aplicación.
Iniciamos por colocar lo siguiente:

import java.awt.*;
public class Ejemp1{

public static void main (String[] args){
//codigo
}
}
Tenemos que declarar todos los componentes GUI. Declaramos, por supuesto, un
JFrame y un CONTAINER, y también necesitamos un botón y una barra de
progreso.
import java.awt.*;

//Declarar componentes GUI
static JFrame frmMain;
static Container pane;
static JButton btnDo;
static JProgressBar barDo;

//codigo...
}
}
Vamos a crear una instancia de todos los componentes, añadirlos, a continuación, y

también la posición de ellos.
import java.awt.*;


//Crear los componentes

frmMain = new JFrame("Progreso");
frmMain.setSize(300, 100); // Tamaño de la ventana 300x100 pixels
pane = frmMain.getContentPane();
pane.setLayout(null); //aplicar nulllayout
frmMain.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); btnDo = new
JButton("Apreta!!!!!!");
barDo = new JProgressBar(0, 100); //Valor mínimo: 0 Valor máximo: 100
//Añadir componentes al panel

pane.add(btnDo);
pane.add(barDo);
//Controles de posición (X, Y, ancho, altura)

barDo.setBounds(10, 10, 280, 20);
btnDo.setBounds(100, 35, 100, 25);
//Marco visible
frmMain.setResizable(false);
frmMain.setVisible(true);
//addActionListener
btnDo.addActionListener(new btnDoAction());
}
}
El acción del botón de comando lo dejamos de la siguiente manera:

public static class btnDoAction implements ActionListener{
public void actionPerformed (ActionEvent e){
//….
}
}
Tendrá que aplicar lo que sabe para el método de ejecución de un Runnable, que
es un thread (hilo)
public static class thread1 implements Runnable{
public void run(){
}
}

Como habrá intuido, el run () que está vacío contendrá los diversos acontecimientos
que ocurren una vez que este thread(o hilo) se comenzó a usar, su método start ().
Para iniciar este Thread, tendremos que utilizar:
new Thread(new thread1()).start();
En el thread, vamos a poner el código para incrementar la barra de progreso

for (int i=0; i<=100; i++){ barDo.setValue(i); barDo.repaint(); try{Thread.sleep(50);}
catch (InterruptedException err){} }
El barDo.setValue (i) la línea cambia el valor de ProgressBar i, que es la variable

de incremento, de modo que se incrementa la barra.
El repaint () método actualiza los gráficos de la barra, esto es algo importante a
considerar como actualizar algunos de los componentes gráficos.
El try ... catch cosas es también parte de los fundamentos.
Usamos Thread.sleep (50) para hacer el sueño de hilo 50 milésimas de segundo, o
1 / 20 de segundo.
Tenemos que controlar el error InterruptedException que pueden ser lanzados por
esta instrucción.
Uniendo todo el código se tiene:
import java.awt.*;


//Crear todos los componentes

frmMain = new JFrame("Barra de progreso");
frmMain.setSize(300, 100);
pane = frmMain.getContentPane();
pane.setLayout(null);
frmMain.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); btnDo = new

JButton("TOUCH ME!!");
barDo = new JProgressBar(0, 100);
pane.add(btnDo);
pane.add(barDo);
barDo.setBounds(10, 10, 280, 20);

btnDo.setBounds(100, 35, 100, 25);
frmMain.setResizable(false);
frmMain.setVisible(true);
btnDo.addActionListener(new btnDoAction());
}
public static class btnDoAction implements ActionListener{

public void actionPerformed (ActionEvent e){
new Thread(new thread1()).start();
}
}
public static class thread1 implements Runnable{

public void run(){
for (int i=0; i<=100; i++){ barDo.setValue(i); barDo.repaint(); try{Thread.sleep(50);}
catch (InterruptedException err){} } } } }
Ejecutando el programa se visualiza lo siguiente:
Al dar clic en el botón de comando se inicia la barra de progreso:

OBJETOS JPASSWORDFIELD Y JINTERNALFRAME
Objeto JPasswordField
Este componente pertenece a la clase JTextField que permite al usuario ingresar

una contraseña, la cual se verá como puntos o asteriscos para la seguridad de él.

Estos datos ingresados, el objeto JPasswordField lo recibe como un arreglo para
que después los pueda utilizar. Para crear un objeto JPasswordField se necesita
crear una ventana (objeto JFrame) donde puedes agregar objetos que permita al
usuario ingrese su nombre, puedes agregarle un botón, pudiendo validar sus datos
como por ejemplo que la contraseña sean puros números o puras letras.
Veamos a continuación un ejemplo sencillo de uso del objeto JPasswordField.

Ejemplo 1
import java.awt.*;
public class Password

{
public static void main(String [ ] args)
{
//instanciando o creando una ventana
JFrame ventana = new JFrame(“Probando un JPasswordField”);
//instanciando o creando un objeto cuadro de texto

JTextField texto = new JTextField(“Password”);
//posición del texto
texto.setBounds(50,40,100,30);
//creamos el campo contraseña

JPasswordField contraseña = new JPasswordField();
contraseña.setBounds(70,25,150,25);
//agregamos el objeto contraseña al objeto ventana

ventana.add(contraseña);
//visualización del texto en la ventana
ventana.add(texto);
//el tamaño de la ventana queda invariable
//el texto no puede ser modificado
texto.setEditable(false);
//la ventana lo hacemos visible
}
}
Ejecutando el código, se muestra la siguiente ventana:

Veamos otro ejemplo usando JPasswordField.

Ejemplo 2
// creamos un método llamado passwordCorrecta
public boolean passwordCorrecta(char[] clave) {
boolean esCorrecta = true;
// la clave por defecto es 1234 almacena en un vector de tipo char
char[] claveCorrecta = { '1', '2', '3', '4' };
// evaluamos si tamaño del parámetro clave es desigual al vector claveCorrecta
if (clave.length != claveCorrecta.length) {
esCorrecta = false;
} else {
// el método equals evalua si es igual el parámetro clave y el vector claveCorrecta
esCorrecta = Arrays.equals(clave, claveCorrecta);
}
return esCorrecta;
}
// ya dentro del método main o de la programación de un botón de comando indicamos:

// con getPassword() obtenemos el dato ingresado como password y lo pasamos al vector
char [] claveEntrada = jPasswordField.getPassword();
// hacemos uso del método passwordCorrecta
if(passwordCorrecta(claveEntrada)){
JOptionPane.showMessageDialog(null, "La contraseña entrada es correcta.");
}else{
JOptionpane.showMessageDialog(null,"La contraseña entrada es errónea.");
}
Objeto JInternalFrame
Este componente proviene de la clase JFrame , el cual crea ventanas que van
apareciendo en una barra de herramientas. Es una ventana dentro de otra
ventana. Con esta interfaz podemos permitir al usuario tener varias ventanas
abiertas que se procesan al mismo (llamadas ventanas hijas), pero dentro de
otra ventana (llamada ventana padre). Lo importante es darle el tamaño y la
posición al JInternalFrame , ya que si no lo damos lo veremos de tamaño 0 y en
la posición (0,0) y por lo tanto no aparecerá. El tamaño máximo que pueden
alcanzar las ventanas de tipo JInternalFrame es el tamaño de la ventana padre.
Por defecto el objeto JInternalFrame no es redimensionable ni se puede cerrar
ni tiene botones de maximizar y minimizar. Es necesario conocer los métodos
adecuados para el manejo de este tipo de ventanas.

Para hacer uso de un objeto JInternalFrame debes crear una ventana padre, es
decir, una ventana com{un y corriente con el objeto JFrame, para que pueda
contener al JInternalFrame, ya que si esta ventana no existiese no se podrá
crear una ventana del tipo JInternalFrame. El tiempo de vida que tendrán las
ventanas de tipo JInternalFrame va depender de la ventana padre, ya que si
cerramos esta ventana, cerraremos todo lo que está dentro de ella.
Veamos a continuación un ejemplo de cómo usar JInternalFrame:

Ejemplo 1
import java.awt.*;
public class Internal

{
public static void main(String [] args)
{
JFrame ventana=new JFrame("Probando una ventana JInternalFrame");
//el Desktop funciona como el administrador de ventana hijas
JDesktopPane dp = new JDesktopPane();
ventana.getContentPane().add(dp);
//creación de una etiqueta que irá dentro del objeto JInternalFrame
panel.setLayout(new FlowLayout());
panel.add(new JLabel("Una etiqueta"));
panel.add(new JTextField(10));
//creación de otra etiqueta para una nueva JInternalFrame
JPanel panel1 = new JPanel();
panel1.setLayout(new FlowLayout());
panel1.add(new JLabel("Una Etiqueta"));
panel1.add(new JTextField(10));
//creación de un botón de comando
panel2.add(new JButton("Ingresa"));
panel2.setBounds(30,30,30,20);
//Se construye el JInternalFrame
JInternalFrame internal = new JInternalFrame("Un Internal Frame",true,true,true,true);
internal.add(panel);
JInternalFrame internal1 = new JInternalFrame("Un Internal Frame",true,true,true,true);

internal1.add(panel1);
JInternalFrame internal2 = new JInternalFrame("Un Internal Frame",true,true,true,true);
//tamaño de la ventana
internal.setBounds(50,30,250,90);
internal1.setBounds(60,130,250,90);
//para que JInternalFrame sea redimensionable
internal.setResizable(true);
internal1.setResizable(true);
internal2.setResizable(true);
//se mete el JInternalFrame en el JDesktopPane
dp.add(internal);
dp.add(internal1);
dp.add(internal2);
//visualización de la ventana
internal.setVisible(true);
internal1.setVisible(true);
}
}
Ejecutando el código, se muestra la siguiente ventana:

Si procedemos a minimizarlo quedaría de la siguiente manera:
Ejemplo 2

Otro ejemplo usando JInternalFrame
import java.awt.BorderLayout;
import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;
import javax.swing.JLabel;
public class DesktopInternalFrameStyleSample {
public static void main(final String[] args) {

JFrame frame = new JFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JDesktopPane desktop = new JDesktopPane();

JInternalFrame internalFrames[] = { new JInternalFrame("Can Do All", true, true, true, true),
new JInternalFrame("Not Resizable", false, true, true, true),
new JInternalFrame("Not Closable", true, false, true, true),
new JInternalFrame("Not Maximizable", true, true, false, true),
new JInternalFrame("Not Iconifiable", true, true, true, false) };
int pos = 0;
for (JInternalFrame internalFrame : internalFrames) {
desktop.add(internalFrame);
internalFrame.setBounds(pos * 25, pos * 25, 200, 100);

pos++;
JLabel label = new JLabel(internalFrame.getTitle(), JLabel.CENTER);

internalFrame.add(label, BorderLayout.CENTER);
internalFrame.setVisible(true);
}
frame.add(desktop, BorderLayout.CENTER);
frame.setSize(500, 300);
frame.setVisible(true);
}
}
Ejecutando el código, se muestra la siguiente ventana

Ejemplo 3
Usando los objetos JPasswordField y JInternalFrame
import java.awt.*;
public class ProbandoPasswordInternal

{
public static void main(String[] args)
{
JFrame ventana = new JFrame("Prueba JInternalFrame");
JDesktopPane dp = new JDesktopPane();
ventana.getContentPane().add(dp);
JTextField texto = new JTextField("Password:");
texto.setBounds(50,150,100,30);
JPasswordField contraseña = new JPasswordField();
contraseña.setBounds(70,20,130,20);
//Creación de JPasswordField y una etiqueta
JTextField texto1 = new JTextField("Password:");
texto1.setBounds(50,150,100,30);
JPasswordField contraseña2 = new JPasswordField();
contraseña2.setBounds(70,20,130,20);
panel1.add(new JLabel("Una etiqueta"));
panel1.add(new JTextField(10));
//Construyendo loos objetos JInternalFrame
JInternalFrame internal = new JInternalFrame("Un Internal Frame",true,true,false, true);
JInternalFrame internal2 = new JInternalFrame("Un Internal Frame",true,true,false,true);
JInternalFrame internal3 = new JInternalFrame("Un Internal Frame",true,true,false,true);
internal.setBounds(50,30,250,90);

internal.add(contraseña);
internal.add(texto);
internal3.add(contraseña2);
internal3.add(texto1);
dp.add(internal);
dp.add(internal2);
dp.add(internal3);
//sentencia que se utiliza para que un texto no se pueda modificar
texto.setEditable(true);
texto1.setEditable(false);
//sentencia utilizada para que no se puedan redimensionar
internal.setResizable(false);
internal2.setResizable(false);
internal3.setResizable(false);
internal.setVisible(true);
}
}
Ejecutando el código se muestra la siguiente ventana:

OBJETOS JDIALOG, JTREE Y JFORMATTEDTEXTFIELD

Objeto JDialog
En una aplicación java con ventanas debería haber un único JFrame,
correspondiente a la ventana principal de la aplicación. El resto de ventanas
secundarias deberían ser JDialog. Por supuesto, podemos usar JInternalFrame, si
lo deseamos sin ningún problema, pero en ésta sesión nos referimos sólo a
ventanas "reales", a las que el sistema operativo trata como tales.
Un JFrame en una ventana que en Windows crea, en la barra de herramientas,
donde está el menú de "inicio" y las aplicaciones que tenemos abiertas, un nuevo
botón de aplicación abierta. En una aplicación lo normal es que sólo haya un botón
ahí. Si creamos varios JFrame en nuestra aplicación, aparecerán varios botones,
uno por cada JFrame.
El JDialog no muestra este botón. Por ello, el resto de las ventanas de nuestra
aplicación deberías ser JDialog.
Hay otro motivo más. Un JFrame no admite a ninguna otra ventana como padre. El
JDialog sí admite como padres un JFrame u otros JDialog. Esto es importante
porque una ventana hija siempre quedará por encima de su ventana padre. Si al
crear los JDialog les pasamos el JFrame como padre, los JDialog siempre estarán
visibles por encima del JFrame. No se podrán ir "detrás" de él. Si además, en el
constructor del JDialog ponemos a true el flag que indica que es modal, además de
pasarle una ventana padre, entonces el JDialog impedirá el acceso a las otras
ventanas hasta que se cierre. Otra ventaja de admitir un padre es que heredan el
icono de él. Si hemos cambiado el icono del JFrame con el método
setIconImage(), entonces todos los JDialog que hagamos como hijos de este
JFrame heredarán el icono. Todas las ventanas de nuestra aplicación tendrán el
mismo icono en lugar de la taza de café por defecto.

Un JDialog puede ser modal, pasándole un true en el constructor en el sitio
adecuado o haciéndolo modal con el método setModal(). Si hacemos un JDialog
modal, todas las demás ventanas se deshabilitarán hasta que el usuario de nuestro
programa cierre el JDialog. Esto está estupendo para pedir un dato al usuario y
evitar que toque otras cosas hasta que haya introducido el dato. Sin embargo, tiene
un peligro.
Supongamos un JDialog que lo hacemos modal para pedir unos datos al usuario.
Este JDialog tiene un botón de "Aceptar" para que el usuario lo pulse cuando haya
terminado de introducir los datos. Supongamos que en el código de ese botón
"Aceptar" comprobamos los datos que ha metido el usuario y vemos que son
incorrectos. Le sacamos un segundo JDialog modal para indicarle el error y no
cerramos el primero.
¿Quién debe ser el padre de ese segundo JDialog modal?. Si hacemos que el
padre sea el JFrame tendremos dos JDialog modales hijos del JFrame, es decir,
dos JDialog modales hermanos. Esto nos dará problemas, como que ambas
ventanas queden deshabilitadas, que al cerrar una de ellas se nos oculten todas,
que parte de la ventana quede deshabilitada mientras que otra parte no, etc.
Entonces, ¿cómo hacemos?. Para que java no haga cosas raras, el padre del
segundo JDialog modal debe ser el primer JDialog modal. De esta forma, el
segundo tiene "prioridad" sobre el primero. Todo queda deshabilitado excepto este
segundo JDialog. Cuando lo cerremos, será el primero el que mande.
Resumiendo, si queremos varias ventanas modales simultáneamente en pantalla,
cada ventana que se muestre debe ser padre de la siguiente, de forma que la
cadena de ventanas modales sean padre, hijo, nieto, etc. Tener dos ventanas
modales simultaneas que sean hermanas o primas o cualquier otra relación que no
sea directa, nos dará problemas
Veamos a continuación un ejemplo sencillo usando JDialog

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.WindowConstants;
public class DosVentanas {

private JFrame ventanaPrincipal;

private JDialog ventanaSecundaria;

{
new DosVentanas();
}
public DosVentanas()
{
// Construcción de ventana principal
ventanaPrincipal = new JFrame("Ventana principal");
JButton boton = new JButton("Abre secundaria");
ventanaPrincipal.getContentPane().add(boton);
ventanaPrincipal.pack();
// Construcción de ventana secundaria

ventanaSecundaria = new JDialog(ventanaPrincipal,"Ventana secundaria");
JLabel etiqueta = new JLabel("Hola");
ventanaSecundaria.getContentPane().add(etiqueta);
ventanaSecundaria.pack();
// Hacer que el botón abra la ventana secundaria y cierre la principal

boton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
ventanaPrincipal.setVisible(false);
ventanaSecundaria.setVisible(true);
}
});
// Hacer que al cerrarse la secundaria con la x de arriba a la

// derecha, se muestre la primaria
ventanaSecundaria.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
ventanaPrincipal.setVisible(true);
ventanaSecundaria.setVisible(false);
}
public void windowClosed(WindowEvent e) {

ventanaSecundaria.setVisible(false);
}
});
// Mostrar la ventana principal

ventanaPrincipal.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}

}
Al momento de ejecutar el código antes indicado, se visualiza:
Al dar clic en el botón de comando “Abre secundaria” se muestra:
Objeto JTree
El JTree es el componente java visual (como los botoncitos, listas, menús, etc) que
nos permite visualizar un árbol. En él podemos ver el típico árbol de datos en el que
podemos abrir cada uno de los nodos para ver qué tiene dentro, cerrarlos, etc.
Similar al árbol de directorios que nos muestran algunas aplicaciones para elegir un
fichero.
Como en casi todos los componentes visuales de java, hay dos clases importantes
implicadas. Por un lado tenemos "la vista", que es la clase java que se ve. Esta
clase es el JTree y es lo que se ve en la pantalla, en nuestra ventana. Por otro lado
tenemos el "modelo de datos". Esta clase de java puede ser cualquier clase que
implemente la interface TreeModel, pero java nos ofrece ya implementada la clase
DefaultTreeModel. Esta clase es la que contiene los datos que queremos
visualizar en "la vista". Contiene los datos que visualizaremos en el JTree.
Puesto que vamos a hacer un árbol, admite datos que se puedan asociar entre sí
como padres e hijos. No valen datos cualesquiera. Esos datos deben implementar
la interface TreeNode. Cualquier clase que implemente esta interface, tendrá
métodos para interrogarle sobre quién es su padre, si tiene hijos, etc. Estos
métodos será los que acabe usando JTree para saber qué debe pintar, quién es
hijo de quién y quién es padre de quién. Existe otro tipo de dato también
importante, el MutableTreeNode. Este es igual que el anterior, pero además tiene
métodos para modificar las asociaciones entre padres e hijos. Permite añadir
nuevos hiijos a los padres, cambiar el padre de los hijos y cualquier otro tipo de

indecencia que se nos ocurra. Si nuestro árbol va a cambiar sobre la marcha, nos
interesa usar datos (nodos) que implementen esta interface. Java nuevamente nos
ofrece una clase que ya implementa MutableTreeNode y por tanto tiene todos los
métodos necesarios para saber quién es hijo de quién y los métodos necesarios
para cambiar estas asociaciones. Esta clase es DefaultMutableTreeNode. Tiene
además un método intereseante, que es setUserObject(). Este método nos permite
guardar dentro la información que queramos. Esta información será nuestro dato
real, lo que realmente nos interesa. DefaultMutableTreeNode únicamente nos
ahorrará escribir el código necesario para mantener asociaciones entre padres e
hijos, además de hacer de almacén de nuestro dato.
Vamos a proceder a construir un árbol que tenga la siguiente apariencia:
Primero instanciamos nuestro modelo de datos, el DefaultTreeModel y la parte

visual, el JTree. Metemos el primero dentro del segundo. La clase
DefaultTreeModel necesita en su constructor el nodo raíz del árbol, es decir, el dato
que hace de padre de todos los demás, el de más alto nivel. Por ello, debemos
instanciar este primer dato para poder construir el DefaultTreeModel. Ese primer
dato será un DefaultMutableTreeNode. A este DefaultMutableTreeNode podemos
pasarle el dato que queramos bien a través del método que comentamos
setUserObject(), bien a través del constructor. Nuestro dato será un simple String
que diga "abuelo" y lo meteremos en el constructor.
El código quedaría así
DefaultMutableTreeNode abuelo = new DefaultMutableTreeNode("abuelo");

modelo = new DefaultTreeModel(abuelo);
JTree tree = new JTree(modelo);

Ahora sólo nos queda ir añadiendo el resto de los datos del árbol. Lo único que
tenemos que hacer es ir creando los nodos, como DefaultMutableTreeNode. A cada
uno de ellos meterle el dato que queramos, bien en el constructor, bien con el
método setUserObject(). En nuestro caso usaremos un simple String con el texto
que queremos que se muestre. Finalmente, hay que ir asociando estos datos. El
abuelo ya lo tenemos creado, así que el código de creación de los demás nodos
puede ser este:
DefaultMutableTreeNode padre = new DefaultMutableTreeNode("padre");

DefaultMutableTreeNode tio = new DefaultMutableTreeNode("tio");
DefaultMutableTreeNode hijo=new DefaultMutableTreeNode("hijo");
DefaultMutableTreeNode hija=new DefaultMutableTreeNode("hija");
Para asociar estos datos tenemos dos opciones:

1. Usar los métodos add(), insert() y setParent() de DefaultMutableTreeNode
para ir añadiendo unos nodos a otros.
2. Usar el método insertNodeInto() de DefaultTreeModel. A este método le
pasamos nodo padre e hijo que queremos asociar y el se encarga de hacer la
asociación.
La diferencia de hacerlo de una manera u otra es que JTree se entera
automáticamente de cambios de DefaultTreeModel y los refleja automáticamente
en pantalla, pero no se entera de los cambios en los DefaultMutableTreeNode y por
tanto no los refresca en pantalla.
Puesto que estamos haciendo un ejemplo simple y es más simple, usaremos el

método insertNodeInto() para hacer la asociación. Este método lleva tres
parámetros:
 Nodo que queremos que sea hijo
 Nodo que queremos que sea padre
 En qué posición queremos que esté el hijo respecto a otros hijos. Dicho de
otra forma, cuando despleguemos un padre que tiene por ejemplo cuatro
hijos, en qué posición queremos que esté este nuevo hijo: el primero, en
medio, el último.
El código para estas asociaciones es sencillo:

modelo.insertNodeInto(padre,abuelo,0);
modelo.insertNodeInto(tio, abuelo, 1);
modelo.insertNodeInto(hijo, padre, 0);
modelo.insertNodeInto(hija, padre, 1);
Por lo tanto, el código quedaría de la siguiente manera:

import javax.swing.JTree;
import javax.swing.WindowConstants;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
public class PruebaJTree
{
{
// Construccion del arbol
DefaultMutableTreeNode abuelo = new DefaultMutableTreeNode("abuelo");
DefaultTreeModel modelo = new DefaultTreeModel(abuelo);
JTree tree = new JTree(modelo);
// Construccion de los datos del arbol

DefaultMutableTreeNode padre = new DefaultMutableTreeNode("padre");
DefaultMutableTreeNode tio = new DefaultMutableTreeNode("tio");
modelo.insertNodeInto(padre, abuelo, 0);
modelo.insertNodeInto(tio, abuelo, 1);
DefaultMutableTreeNode hijo = new DefaultMutableTreeNode("hijo");

DefaultMutableTreeNode hija = new DefaultMutableTreeNode("hija");
modelo.insertNodeInto(hijo, padre, 0);
modelo.insertNodeInto(hija, padre, 1);
// Construccion y visualizacion de la ventana

JFrame v = new JFrame();
JScrollPane scroll = new JScrollPane(tree);
v.getContentPane().add(scroll);
v.pack();
v.setVisible(true);
v.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
}
Al momento de ejecutar el código antes indicado, se visualiza:

Objeto JFormattedTextField
El JFormattedTextField es un componente java un paso más evolucionado que un

JTextField normal. El JTextField permite al usuario ingresar texto. Cuando desde
nuestro código le pedimos el contenido, nos devuelve el texto introducido por el
usuario como String. Cuando desde código le decimos lo que queremos que
muestre, debemos pasarle un String. El JTextField, además, no hace ningún tipo
de comprobación sobre el texto.
El JFormattedTextField da un paso más allá. Aunque el usuario mete un texto, el
JFormattedTextField lo convierte a la clase que nosotros queramos (un Integer,
Float, Date o incluso una clase nuestra propia). Cuando queramos pasarle algo, le
podemos pasar directamente cualquiera de estas clases y él se encarga de la
conversión a texto para mostrar.
Para editar cualquier tipo básico de java, estilo Integer, Float, Double, Date, etc,
basta con llamar al método setValue() del JFormattedTextField pasándole uno de
estos tipos de datos, o bien pasárselo en el constructor. Por ejemplo, para Integer, nos
bastaría con cualquiera de los dos casos siguientes:

JFormattedTextField textField1 = new JFormattedTextField (new Integer(3));
// o bien ....
JFormattedTextField textField2 = new JFormattedTextField ();
textField2.setValue(new Integer(3));
Con esto ya tenemos un editor que nos permite recoger Integer directamente
cuando el usuario lo edite:
Integer valor = textField1.getValue();
Supongamos que el usuario escribe algo en el JFormattedTextField y luego

pincha con el ratón en otros sitio (se dice que el JFormattedTextField pierde el
foco), por ejemplo, en un botón de "Aceptar" los cambios introducidos. En el
momento que el JFormattedTextField pierde el foco, comprueba el texto escrito
por el usuario. Si es correcto, lo guarda de forma que el método getValue() nos
devolverá el nuevo valor. Si es incorrecto, pondrá automáticamente el último valor
bueno, deshaciendo el cambio hecho por el usuario.
Este comportamiento puede cambiarse con el método setFocusLostBehavior(), al

que podemos pasar varios valores:
 JFormattedTextField.COMMIT. Si el texto introducido es correcto, se

guarda para devolverlo cuando se haga getValue(). Si es incorrecto, no se
hace nada, el texto en pantalla queda como esta, o sea, mal. getValue() nos
devolverá el último valor correcto, independientemente de lo que se muestre
en pantalla.
 JFormattedTextField.REVERT. Cuando hacemos click en otro sitio, el
editor vuelve automáticamete a su último valor bueno, descartando todas
nuestras ediciones, sean correctas o no. Para que esta opción tenga sentido,
debemos llamar desde código al método commitEdit() sin que el
JFormattedTextField pierda el foco, por ejemplo, cuando se pulsa <intro>
sobre el editor, validando así los cambios realizados.
 JFormattedTextField.COMMIT_OR_REVERT. Esta es la opción por defecto
y la más útil. Si el texto introducido es incorrecto, se vuelve automáticamente
al último valor bueno conocido. Si el texto no es válido, se muestra el último
valor bueno conocido.<>

 JFormattedTextField.PERSIST. Esta opción no hace nada con el texto
introducido, independientemente de que esté bien o mal. getValue() siempre
devolverá el último valor bueno conocido. Para que el editor recoga el nuevo
valor, debemos llamar a commitEdit() previamente.
Existen varios JFormattedTextField.AbstractFormatter además de los que podamos

hacernos nosotros. Uno de los más conocidos es el MaskFormatter. Este formateador
restringe el texto válido incluso mientras lo estamos tecleando. Al instanciar el
MaskFormatter le damos un "patrón" sobre cómo queremos que sea el texto. Una vez
configurado todo, el usuario no podrá escribir en el FormattedTextField nada que se salga
de ese "patrón". Veamos con un ejemplo qué quiero decir.
Supongamos que quiero un editor que me permita escribir un número con dos cifras
enteras y dos decimales. No queremos que el usuario escriba algo que no sea un
número y no queremos que escriba ni más ni menos de las cifras de las indicadas.
El editor debe admitir y devolvernos con setValue() y getValue() un Float.
Para conseguir esto, basta instanciar un MaskFormatter y pasárselo al

JFormattedTextField en el constructor. Para evitar problemas, le damos un valor
válido inicial válido al editor. El new MaskFormatter lanza una excepción, así que
debemos capturarla.
try
{
/* El "patrón" para el editor. Las # representan cifras. En la API puedes ver más. Ojo con el punto
decimal, según el idioma puede ser una coma.*/
MaskFormatter mascara = new MaskFormatter("##.##");
// Se construye el JFormattedTextField pasándole la máscara
JFormattedTextField textField = new JFormattedTextField(mascara);
// Se da un valor inicial válido para evitar problemas
textField.setValue(new Float("12.34"));
}
catch (...)
Ya está listo. Nuestro editor sólo admite números de dos cifras enteras y dos
decimales y no nos deja escribir otra cosa. Los métodos getValue() y setValue()
devuelven y admiten Floats.
AUTOEVALUACION

a) Responde a las siguientes preguntas:
1. Método que permite que un formulario sea de tipo respuesta, se denomina

___________________
2. Método del objeto Slider que permite colocar las rayitas que marcan los números,
se denomina __________________
3. El método constructor permite crear o instanciar objetos a partir de una clase

(verdadero o falso) ___________________
4. Objeto que permite diseñar una barra de herramientas, se denomina

_______________
5. Método que permite visualizar un objeto del tipo JinternalFrame, se denomina

_______________
b) Desarrolla las siguientes aplicaciones:
1. Construye un formulario que a través de una etiqueta indique la expresión

"comentarios" y agrega un objeto JTextArea para que el usuario pueda escribir en
varias lineas el comentario respectivo.
2. Diseña y ejecuta la aplicación referida a JSlider y cambia dicho objeto de vertical
a horizontal y que los intervalos ya no sea de 25 a 25 sino de 20 a 20.
3. Construye una ventana JDialog para el acceso de un Sistema, es decir, que
permita el ingreso del usuario y del password

CAPITULO II
ACCESO Y MANTENIMIENTO DE DATOS
CONEXION A LA BASE DE DATOS CON JDBC

¿Qué es un JDBC?
La conectividad de la base de datos de Java (JDBC , Java Database Connectivity)

es un marco de programación para los desarrolladores de Java que escriben los
programas que tienen acceso a la información guardada en bases de datos, hojas
de cálculo, y archivos "planos". JDBC se utiliza comúnmente para conectar un
programa del usuario con una base de datos por “detrás de la escena”, sin importar
qué software de administración o manejo de base de datos se utilice para
controlarlo.
Para la gente del mundo Windows, JDBC es para Java lo que ODBC es para
Windows. Windows en general no sabe nada acerca de las bases de datos, pero
define el estándar ODBC consistente en un conjunto de primitivas que cualquier
driver o fuente ODBC debe ser capaz de entender y manipular. Los programadores
que a su vez deseen escribir programas para manejar bases de datos genéricas en
Windows utilizan las llamadas ODBC.
Con JDBC ocurre exactamente lo mismo: JDBC es una especificación de un

conjunto de clases y métodos de operación que permiten a cualquier programa
Java acceder a sistemas de bases de datos de forma homogénea. Lógicamente, al

igual que ODBC, la aplicación de Java debe tener acceso a un driver JDBC
adecuado. Este driver es el que implementa la funcionalidad de todas las clases de
acceso a datos y proporciona la comunicación entre el API JDBC y la base de datos
real.
ODBC es un interfaz escrito en lenguaje C, que al no ser un lenguaje portable,

haría que las aplicaciones Java también perdiesen la portabilidad. Y además,
ODBC tiene el inconveniente de que se ha de instalar manualmente en cada
máquina; al contrario que los drivers JDBC, que al estar escritos en Java son
automáticamente instalables, portables y seguros. La conectividad de bases de
datos de Java se basa en sentencias SQL, por lo que se hace imprescindible un
conocimiento adecuado de SQL para realizar cualquier clase de operación de
bases de datos. Aunque, afortunadamente, casi todos los entornos de desarrollo
Java ofrecen componentes visuales que proporcionan una funcionalidad
suficientemente potente sin necesidad de que sea necesario utilizar SQL, aunque
para usar directamente el JDK se haga imprescindible
Acceso a base de datos con JDBC
A continuación vemos los modelos diferentes de acceso a base de datos:
Modelo de 2 capas
El presente modelo se basa en que la conexión se presenta entre la aplicación Java

o el applet (que se ejecuta en el navegador), se conectan directamente a la base de
datos.

Como sabemos en Java se puede tener dos tipos de aplicaciones: la aplicación

Java propiamente dico y una aplicación applet, esta última que se ejecuta en un
navegador. Observamos en la figura que el driver o controlador JDBC debe residir
en la computadora local. La base de datos puede estar en cualquier otra máquina y
se accede a ella mediante la red. Esta es la configuración de típica Cliente/Servidor:
el programa cliente envía instrucciones SQL a la base de datos, ésta las procesa y
envía los resultados de vuelta a la aplicación
Modelo de 3 capas
El presente modelo, las instrucciones son enviadas a una capa intermedia entre
Cliente y Servidor, que es la que se encarga de enviar las sentencias SQL a la base
de datos y recoger el resultado desde la base de datos. En este caso el usuario no
tiene contacto directo, ni a través de la red, con la máquina donde reside la base de
datos.

Comparando con el modelo anterior, se observa que el driver o controlador JDBC

se encuentra junto al servidor de aplicaciones, esto hace que la máquina del cliente
no se preocupe por instalar el controlador. El nivel intermedio mantiene en todo
momento el control del tipo de operaciones que se realizan contra la base de datos
Cargar el controlador JDBC
Para trabajar con el API JDBC se tiene que importar el paquete java.sql, tal y como
se indica a continuación:
import java.sql.*;
En este paquete se definen los objetos que proporcionan toda la funcionalidad que
se requiere para el acceso a bases de datos. El siguiente paso después de importar
el paquete java.sql consiste en cargar el controlador JDBC, es decir un objeto
Driver específico para una base de datos que define cómo se ejecutan las
instrucciones para esa base de datos en particular.
Hay varias formas de hacerlo, pero la más sencilla es utilizar el método forName()
de la clase Class:
Class.forName("Controlador JDBC");
para el caso particular del controlador para MySQL, Connector/J, se tiene lo

siguiente:

Class.forName("com.mysql.jdbc.Driver");
Debe tenerse en cuenta que el método estático forName() definido por la clase
Class genera un objeto de la clase especificada. Cualquier controlador JDBC tiene
que incluir una parte de iniciación estática que se ejecuta cuando se carga la clase.
En cuanto el cargador de clases carga dicha clase, se ejecuta la iniciación estática,
que pasa a registrarse como un controlador JDBC en el DriverManager.
En toda aplicación de bases de datos con MySQL es indispensable poder

establecer la conexión al servidor para posteriormente enviarle las consultas. Los
programas en Java no son la excepción. El siguiente código nos servirá para
verificar que podemos establecer una conexión a nuestra base de datos
transportes
import java.sql.*;
public class TestConnection
{
static String bd=”transportes”;
static String login=”bingo”;
static String password=”hola”;
static String url=”jdbc:mysql://localhost/”+bd;
public static void mian(String[ ] args)throws IOException

{
Connection conn = null;
try
{
Class.forName(“com.mysql.jdbc.Driver);
conn = DriverManager.getConnection(url,login,password);
if (conn != null)
{
System.out.println(“Conexión a la base de datos ”+bd+”... OK”);
conn.close();
}
}
catch(SQLException ex)
{
System.out.println(ex);
}
catch(ClassNotFoundException ex)
{
System.out.println(ex);
}
}
}
En esta programación se inicia importanto el paquete sql perteneciente a java. El

signo del asterisco significa que el programa puede hacer uso de culaquier clase
contenida en el paquete sql. Se construye la clase TextConnection, estableciendo 4
variables o atributos de tipo String donde se almacena el nombre de la base de
datos, el login, la contraseña o password y el url.
Una vez en el método principal llamado main se declara la variable objeto conn y a
través de la instrucción try se busca proteger la ejecución ante posibles errores (lo
que se denomina manejo de excepciones).
Con la instrucción: Class.forName(“com.mysql.jdbc.Driver).newInstance();, se

establece el driver para el gestor de base de datos MySql. Luego en la siguiente
línea de programación se establece la conexión con la base de datos a través del
método getConnection perteneciente a la clase DriverManager. A través de la
sentencia selectiva if se evalúa el éxito de la conexión, por lo tanto, si la variable
conn es diferente de null significa que se logró la conexión, caso contrario se
mostrará mensajes de error, gracias a la instrucción catch.
Conector a la base de datos
Una aplicación en Java para que logre comunicarse con una base de datos usando
la API
JDBC, se requiere de un conector. Ese conector es específico para el manejador de

base de datos y viene en la forma de un archivo “.jar” o “.zip”. El conector para la
base de datos MySQL, está en el archivo:
mysql-connector-java-5.0.XX.jar
Existe versiones superiores como la versión 5.0 para dicho conector. NetBeans nos
permite la tarea de conectar una aplicación a una base de datos
Conexión de una Aplicación a una base de datos creada en MySql
Para conectar a una aplicación a una base de datos, se requiere:

1. Agregarle a NetBeans el conector como una biblioteca o librería. Esto permite
que el conector esté disponible para los proyectos.
2. Agregarle a un proyecto el conector. Esto permite que la aplicación se pueda

conectar a la base de datos.
A continuación procedemos agregarle a NetBeans un conector a una base de datos

MySql:
a. Seleccione la opción Herramientas/Bibliotecas de la barra de menú del entorno

de NetBeans.
b. Se visualiza un cuadro de diálogo que permite administrar las librerías o

bibliotecas de NetBeans. En la ventana, al lado izquierdo se observa las
librerías agregadas a NetBeans. Del lado derecho aparece el nombre de la
biblioteca y la trayectoria del archivo con la biblioteca. Para agregar el conector
a MySQL a NetBeans presione el botón de comando Biblioteca Nueva ...

c. Se mostrará un cuadro de diálogo donde se establecerá el nombre que daremos

al conector, como por ejemplo MySQL y luego damos click en el botón de
comando Aceptar.
d. Se cierra el cuadro de diálogo y volvemos a la ventana anterior donde se

observará la nueva librería MySQL. Posteriormente procedemos a dar clic en el
botón de comando Agregar archivo JAR/Carpeta ...

e. Buscamos el conector mysql-connector-java-5.0.7- bin.jar
f. Al dar clic en Agregar archivo JAR / Carpeta volvemos a la ventana anterior.

Cabe señalar que en las últimas versiones de NetBeans ya existe una librería o
biblioteca para la conexión a una base de datos de MySql, denominada Driver
MySQL JDBC.

Damos click en el botón de comando Aceptar y vamos a crear un proyecto:
1. Seleccionamos la opción Archivo/Nuevo Proyecto de la barra de menú del

entorno de NetBeans.
2. Seleccionamos en Categorías: Java y como proyecto: Aplicación Java. Luego

damos click en el botón de comando Siguiente.

3. Luego indicamos como nombre del proyecto universidad y posteriormente

damos clic en el botón de comando Terminar, quedando el entorno de NetBeans
de la siguiente manera:
4. En Bibliotecas lo seleccionamos y damos clic con el botón de derecho y

elegimos la opción Agregar Biblioteca

5. Aparece un cuadro de diálogo para seleccionar la librería a agregar, en este

caso MySQL (en las últimas versiones de NetBeans tenemos el conector Driver
MySQL JDBC) y damos clic en Agregar Biblioteca
6. Volvemos al entorno de NetBeans y se observa la nueva librería agregada

7. Ahora procedemos a la conexión de una base de datos, que en este caso será
la base de datos transportes, la misma que ya se encuentra creada
conjuntamente con las tablas de Ciudad y Ruta. Seleccionamos la pestaña
Prestaciones y en Base de Datos seleccionamos la carpeta Controladores.
8. Para agregar el conector MySQL, haga clic en el botón derecho del mouse en el
nodo o carpeta Controladores y seleccione la opción Nuevo Controlador

9. Aparecerá el cuadro de diálogo para agregar un conector. Dar clic en el botón

de comando Agregar.
10. Navegar hasta encontrar el conector, seleccionado y dando clic en Abrir.

11. En el cuadro de diálogo para agregar el conector se mostrará la información del

conector seleccionado. Luego dar clic en el botón de comando Aceptar.
12. Un nuevo nodo para el conector a MySql, aparecerá en la pestaña

Prestaciones

13. Ahora procederemos a conectarnos con la base de datos de universidad.

Seleccionamos el driver MySQL y damos clic botón derecho y elegimos la
opción Conecting using
14. Se muestra un cuadro de diálogo para establecer el URL de la base de datos

usando el siguiente formato:
jdbc:mysql://servidor:puerto/baseDatos
donde servidor es la dirección IP (o nombre de dominio del servidor), en

caso que el servidor esté en la misma computadora que NetBeans utiliza el
nombre: localhost; puerto es el puerto empleado por el servidor. Si el

servidor utiliza el puerto predefinido, se puede omitir; baseDatos es la base de
datos a la que se desea conectar.
15. Damos clic en el botón de comando OK. A continuación aparecerá una ventana
confirmando la conexión con la base de datos de universidad. Luego damos clic
en el botón de comando Aceptar
16. En el entorno de NetBeans se mostrará un nuevo nodo de conexión a la base

de datos.

17. Si damos click en + respecto al nodo creado se visualizará la tabla existente en

la base de datos de universidad.

ACCESO A LA BASE DE DATOS CON JDBC
Acceso a la base de datos desde NetBeans
NetBeans nos permite hacer operaciones sobre la base de datos como crear y
borrar, tablas, agregar y eliminar columnas, agregar, modificar y eliminar registros
de datos como realizar consultas.
Vamos a proceder hacer algunas operaciones:
1. Expanda el nodo con la conexión a la base de datos.

2. Observamos en la figura anterior las carpetas referidas a Tablas, Vistas y

Procedimientos. Si expandimos el nodo referido a Tablas, veremos las tablas
docente, escuela, facultad, profesión y sede.
3. Si seleccionamos el nodo referido a Tablas y damos clic botón derecho, se

muestra un menú flotante y luego elegimos la opción Crear Tabla.

4. Vamos a proceder a crear la tabla de Area con los campos idarea char(2),
descripcion varchar(28). Una vez indicado los campos damos clic en el botón de
comando Aceptar.
5. Volvemos al entorno de NetBeans y observamos en la pestaña de Prestaciones

la nueva tabla de Area.

6. Si deseamos insertar un registro a una de las tablas a través del comando

insert, seleccionamos el nodo referido a Tablas. Dando clic botón derecho se
muestra un menú flotante y luego seleccionamos la opción Executar
Comando...
7. Escribimos el comando para insertar un nuevo registro en la tabla de Facultad,

luego procedemos a ejecutarlo.

Dar clic aquí
para ejecutar
el comando
8. Luego si escribimos el comando select para consultar los datos de la tabla

Facultad, observaremos el contenido de dicha tabla
9. Como verán el entorno de NetBeans nos ofrece la oportunidad de acceder y

manipular los datos y las estructuras de los elementos que conforman una base
de datos. Ahora ustedes mismos, en base a la experiencia de los conocimientos
adquiridos en los cursos referentes a base de datos, procedan a experimentar el
entorno gráfico que nos ofrece NetBeans.

Paquete Java.SQL para trabajar con base de datos
Para realizar una aplicación para que realice cualquier operación de lo más sencilla
posible se necesita de la utilización de varias clases e interfases. JDBC ofrece el
paquete java.sql en la que existen clases e interfaces muy útiles para trabajar con
base de datos. Veamos las más importantes clases o interfases y en la medida en
que se desarrolle las sesiones se detallarán más mencionando los métodos que
tienen para hacer fácil el acceso a la base de datos.
 La clase DriverManager , permite llevar a cabo una conexión con la base de

datos logrando cargar un driver. Existen varios métodos para ello, entre las
cuales se destacan:
public static synchronized Connection getConnection(String url) throws

SQLException
public static synchronized Connection getConnection(Strin url,String user,

String password) throws
El primero de los métodos recibe como parámetro la dirección URL que

identifica la base de datos. En el caso en que sea necesario proporcionar un
usuario y una contraseña para acceder a la base de datos (como sucede en
MySql) se utiliza el segundo de los métodos. Una dirección URL JDBC
proporciona un método de localización de bases muy parecido al que
representan las direcciones URL que identifican sitios Web de Internet. Los
controladores JDBC tienen que ser capaces de conectar con la base de
datos a partir de la información contenida en la dirección URL JDBC de la
misma, por lo que son los desarrolladores los que fijan en la mayoría de los
casos la sintaxis.
 La interfaz Connection, cuando se utiliza uno de los métodos anteriormente

mencionados se obtiene un objeto de tipo Connection que representa como
es de esperar la conexión con la base de datos. El objeto obtenido cuenta
con varios métodos. Dos de los más importantes son:
public abstract Statement createStatement() throws SQLException

public abstract void close() throws SQLException
El primero de los métodos sirve para crear un objeto del tipo Statement. Las
frases SQL se ejecutan normalmente mediante la utilización de objetos del
tipo Statement. Finalmente, es conveniente cerrar las conexiones tan pronto
como dejen de utilizarse para liberar recursos. No obstante, ha de tenerse en
cuenta que establecer una conexión es una operación costosa, por lo que
tampoco se debe estar abriendo y cerrando la conexión con frecuencia.
 La interfaz Statement, los objetos de tipo Statement permiten realizar

consultas y efectuar operaciones de actualización, borrado o inserción de
datos. En algunos casos es interesante también fijar ciertos parámetros
vinculados con la consulta que se desea realizar, como por ejemplo el
tiempo que estamos dispuestos a esperar a que el gestor de la base de
datos devuelva el resultado de la consulta. Los métodos que se citan a
continuación son algunos de los más importantes para llevar a cabo todas
estas acciones.
public abstract ResultSet executeQuery(String sql) throws SQLException
Ejecuta una senetencia SELECT y devuelve el resultado mediante la interfaz

ResultSet
public abstract int executeUpdate(String sql) throws SQLException
Ejecuta una sentencia UPDATE, DELETE, INSERT o cualquier otra

sentencia SQL que no devuelva un conjunto de registros, y devuelve el
número de registros afectados por la sentencia.
public abstract void setMaxRows(int max) throws SQLException
Establece el número máximo de registros que puede devolver

executeQuery()
public abstract int getMaxRows() throws SQLException

Devuelve el número máximo de registros que puede devolver
executeQuery()
public abstract void setQueryTimeout(int seconds) throws SQLException
Establece el tiempo en segundos que el controlador esperará hasta que el

sistema gestor de bases de datos devuelva un resultado
public abstract int getQueryTimeout() throws SQLException
Devuelve el tiempo en segundos que el controlador esperará hasta que el

sistema gestor de bases de Datos devuelva un resultado
Libera los recursos asociados a la sentencia
 La interfaz ResultSet, el método executeQuery que se utiliza para ejecutar

sentencias SQL devuelve un objeto de tipo ResultSet. Éste contiene las filas
o registros obtenidos al ejecutar una sentencia SELECT. Para recuperar los
datos contamos con muchas opciones. Todos los métodos funcionan de la
misma manera. Toman como parámetro el índice o el nombre del campo que
se desea obtener y devuelven el dato en cuestión.
public abstract String getString(int columnIndex) throws SQLException

public abstract String getString(String columnName) throws SQLException
public abstract int getInt(int columnIndex) throws SQLException
public abstract int getInt(String columnName) throws SQLException
Además, existen otros métodos gracias a los cuales es posible recorrer los
resultados guardados en el objeto de tipo ResultSet.
public abstract int findColumn(String columnName) throws SQLException
Devuelve el número de columna cuyo nombre se pasa como parámetro
public abstract boolean next() throws SQLException

Un objeto de tipo ResultSet puede contener más de un resultado. Para ir
avanzando por la lista de resultados utilizamos este método, que devuelve
un valor indicando si existe otro resultado o no.
public abstract boolean wasNull() throws SQLException
Indica si el contenido de la última columna accedida es NULL SQL
Libera los recursos asociados al ResultSet
Vamos a proceder a visualizar en objetos Jlist, los datos contenidos de la tabla de

Escuela.
1. Creamos un objeto Jframe para abrir un nuevo formulario.
Selecciona Formulario JFrame
2. Indicamos como nombre de clase formulario: frmverEscuelas. Luego damos

click en el botón de comando Finalizar.

Quedando el entorno de NetBeans de la siguiente manera:
3. Damos clic botón derecho sobre el diseño del formulario para cambiar el
Asignar Diseño a Diseño Absoluto, lo cual nos permitirá usar los objetos de
control más libremente.

4. Colocamos los objetos de control quedando el diseño del formulario de la

siguiente manera:
5. Borramos los Items de cada objeto Jlist y colocamos los nombres a cada objeto
de control. Recuerden que para eliminar los items de cada Jlist hay que hacer
uso de model que se encuentra en la ventana de propiedades.

lstCod
lstEsc
lstFac
6. A continuación procedemos a colocar la programación.

En la primera llave (color rojo) observamos que importamos los paquetes
java.sql (todo lo que acabamos de ver) y el paquete javax.swing para poder
utilizar la clase JoptionPane para la visualización de un mensaje a través de
su método ShowMessageDialog. En la segunda llave se define las variables
que se van a usar. Vendría hacer los atributos de la clase frmverEscuelas.
Como tenemos establecer conexión usaremos un objeto Connection (conn),
para hacer una operación de consulta usaremos un objeto Statement (st) y
para almacenar los resultados de la consulta usaremos un objeto ResultSet
(rs). Como la aplicación hace uso de los Jlist se tiene crear 3 objetos
instanciados de la clase DefaultListModel (mayor información en la sesión 4
del curso de Programación Visual I). Posteriormente preparamos variables
para indicar el nombre de la base de datos, el login, el password y el url. En
la tercera llave se ha diseñado un método denominado Enlace que permitirá
establecer conexión con la base de datos universidad.
7. La clase frmverEscuela tienen un método del mismo nombre frmverEscuela(),

esto es lo que se denomina método constructor. Deseamos que los datos se
muestren en los objetos Jlist al momento de la ejecución del formulario debemos
programar en el método antes mencionado.

Los objetos instanciados de la clase DefaultListModel deben ser vinculados a
cada uno de las cajas de listas. Luego usando el bloque try{ } que por cierto
sirve para interceptar errores y si lo hubiera ejecutaría lo programado en el
bloque catch{ }, establecemos la conexión usando el método Enlace,
creamos el objeto st de tipo Statement (se encuentra listo para realizar una
operación) y luego ejecutamos una sentencia de consulta con select cuyo
resultado va ocasionar que los datos se almacenen en el objeto rs del tipo
ResultSet. Finalmente con el método next se logra desplazar a través de los
registros de datos para ir llenado los objetos modelo1, modelo2, modelo3 y
modelo4 y de esta forma llenamos los objetos Jlist lo que nos permitirá ver
en el formulario los datos de la tabla de Equipo.
8. Luego de ingresar cuatro registros en la tabla de Escuelas y si ejecutamos la

aplicación observamos lo siguiente:

OBJETO JTABLE Y COMANDOS SQL EN

MANTENIMIENTO DE DATOS
Objeto de control JTable
Un JTable es un componente visual de java que nos permite dibujar una tabla, de
forma que en cada fila/columna de la tabla podamos poner el dato que queramos;
un nombre, un apellido, una edad, un número, etc.
Como muchos componentes de java, se ha seguido una separación modelo-vista.

La vista es el componente visual que vemos en pantalla, el modelo es una clase
que contiene los datos que luego se verán en pantalla. El modelo de datos
únicamente contiene los datos.
El DefaultTableModel es una clase que implementa TableModel que contiene

todos los métodos necesarios para modificar datos en su interior, añadir filas o
columnas y darle a cada columna el nombre que se desee. Para utilizar

DefaultTableModel debemos importarla y luego declararla para luego poder usar la
clase JTable
El siguiente gráfico intenta mostrar cómo cada componente JTable obtiene siempre
sus datos desde un modelo de tabla.
El TableModel se implementa a partir de la clase AbstractTableModel, aunque

existe un modelo de tabla predeterminado denominado la clase DefaultTableModel.
Las propiedad más usada es model que permite definir el numero de filas y
columnas, siendo los métodos más usados: setModel(), que permite vincular un
modelo al obejto Jtable y getRowCount(), devuelve el número de filas en la tabla.
Para la clase DefaultTableModel los métodos más utilizados son: AddRow(), añade
una fila al final del modelo, getRowCount() devuelve el número de filas de la tabla
de datos, getValueAt() devuelve el dato ubicado en la posición fila y columna y
removeRow() elimina una fila del modelo según posición indicada.
Veamos a continuación un programa que hace uso del objeto JTable y llena al
mismo a través de una matriz y agrega una columna a través de un vector.
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;
import javax.swing.JPanel;
import java.awt.*;
public class EjemploTabla extends JFrame {

public EjemploTabla() {
super("Tabla de usuarios");
//array bidimencional de objetos con los datos de la tabla
Object[][] data = {{"Daniel", "Villar","Esquiar", new Integer(5), new Boolean(false)},

{"Carlos", "Villar","Patinar", new Integer(3), new Boolean(true)},
{"Karinna", "Villar","Escalar", new Integer(2), new Boolean(false)},
{"Mario", "Diaz","Correr", new Integer(7), new Boolean(true)},
{"Sylvia", "Uribe","Modelar", new Integer(4), new Boolean(false)}};
//array de String's con los títulos de las columnas
String[] columnNames = {"Nombre","Apellido","Pasatiempo","Años de Practica","Soltero(a)"};

//creamos el Modelo de la tabla con los datos anteriores
DefaultTableModel dtm= new DefaultTableModel(data, columnNames);

//se crea la Tabla con el modelo DefaultTableModel
final JTable table = new JTable(dtm);

// una vez creada la tabla con su modelo
// podemos agregar columnas
String[] newColumn= {"Flan","Pastel","Helado","Barquillo","Manzana" };

dtm.addColumn("Postre",newColumn);
//filas
Object[] newRow={"Pepe", "Grillo","Tenis", new Integer(5), new Boolean(false), "Pera"};

dtm.addRow(newRow);
//o modificar una celda en especifico
dtm.setValueAt("Catherine", 1, 1);
//se define el tamaño
table.setPreferredScrollableViewportSize(new Dimension(500, 70));

//Creamos un JscrollPane y le agregamos la JTable
JScrollPane scrollPane = new JScrollPane(table);

//Agregamos el JScrollPane al contenedor
getContentPane().add(scrollPane, BorderLayout.CENTER);
//manejamos la salida
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
EjemploTabla frame = new EjemploTabla();
frame.pack();
frame.setVisible(true);
}
}

Como podrás observar se tiene una matriz de datos del tipo Object, se crea un
vector, columnNames, para los nombres de cada una de las columnas que será
para el objeto JTable a través de su modelo. Por lo tanto la línea de programación:
DefaultTableModel dtm= new DefaultTableModel(data, columnNames);
Permite que la matriz data sea el contenido del modelo dtm y el vector
columnNames sea los títulos de cada columna del mismo modelo dtm. Luego en
la programación se desea crear una nueva columna con su nombre de columna y
sus datos y esto se logra escribiendo:
String[] newColumn= {"Flan","Pastel","Helado","Barquillo","Manzana" };
dtm.addColumn("Postre",newColumn);
La nueva columna se describe como Postre y los datos de dicha columna se

encuentran en el vector newColumn.
Mantenimiento de Datos usando JTable como vista de datos
Un mantenimiento de datos consiste en grabar datos en una tabla, eliminar datos

correspondientes a un registro de datos, como también modificar datos ya
almacenados. Pero para eliminar datos o modificar datos se supone que los datos
ya existen en la tabla de datos entonces se procederá hacer búsquedas sencillas
para lograr su ubicación y proceder a su eliminación o modificación de datos. En
esta sesión haremos uso del reciente explicado objeto JTable para visualizar los
datos contenidos en una tabla. A continuación vamos a seguir usando la base de
datos de universidad:
1. Vamos a mantener los datos de la tabla de facultad perteneciente a la base

de datos universidad. Establecemos la conexión con la base de datos de
universidad en el entorno de NetBeans.

Volvamos a la pestaña Proyects donde vamos a crear métodos en la clase Acceso,

necesarios para la conexión con la base de datos y el enlace con la tabla de
facultad.
2. Volvamos a la pestaña Proyectos donde vamos a crear métodos para la

conexión con la base de datos y el enlace con la tabla Facultad. Estos
métodos se crearán dentro de una clase llamada Acceso.

Agregamos los paquetes: java.io, java.sql y javax.swing. Este último paquete

es necesario para el uso de los objetos del paquete swing principalmente el
JOptionPane para la visualización de posibles mensajes de error. Estando
dentro de la clase Acceso establecemos las variables conn del tipo
Connection, st del tipo Statement y rs del tipo ResultSet ya descritos y
esplicados en las sesiones anteriores. También definimos las variables bd,
login, password y url.
A continuación creamos el primer método estático denominado Enlace que

devolverá un objeto del tipo Connection. Este método nos ayudará
establecer la conexión con la base de datos universidad. Seguimos a
continuación agregando más métodos a la clase Acceso.

Se crea el método sta que devolverá un objeto del tipo Statement.

Básicamente permite crear el objeto del tipo Statement a partir del objeto
connection a través del método createStatement(). Finalmente se necesita
tener un método denominado EnlFac que permitirá enlazarnos con la tabla
de Facultad aplicando el método executeQuery() estableciendo a través del
comando select a todos los campos de la tabla de Facultad.
Si observamos en cada uno de los métodos se está usando throws

SQLException, esto quiere decir que los métodos usan excepciones
(intercepción de errores) para los errores que se pueden presentar durante la
conexión y acceso de datos.
3. Vamos a diseñar el siguiente formulario al cual llamaremos frmMantFacultad

dando los nombres, correspondientes a cada uno de los objetos de control
dibujados.

btnBuscar
btnVer
btnCerrar
txtCodFac
txtNombre
btnNuevo
btnEliminar
btnModificar
btnGrabar
btnCancelar
tablaFacultad
4. Vamos a proceder a programar, colocando las siguientes líneas de código.
Importamos los paquetes java.sql (para acceder a base de datos),

javax.swing (para el uso de los controles visuales), javax.swing.table para el
manejo de las clases del paquete table y el paquete universidad que

contiene a la clase Acceso con lo cual podremos hacer uso de todos los
métodos que tenga.
Iniciamos la construcción de la clase frmMantFacultad, estableciendo como

variables o atribnbutos conn, st y rs. Como se está utilizando un objeto
JTable se define la variable dtm del tipo DefaulTableModel. En el método
constructor hacemos uso del método activabotones (programación que
veremos luego), se establece un vector o arreglo del tipo String donde se
coloca los títulos que serán de cada una de las columnas del objeto JTable.
A partir del método setColumnIdentifiers indicamos los datos del vector
titulos al objeto dtm y con el método setModel vinculamos el objeto dtm al
objeto JTable denominado tablaFacultad. Los métodos setSize y
setLocation es para establecer el tamaño y la localización del formulario en
la pantalla del computador.

El método activaBotones es para habilitar o inhabilitar el uso de los botones

de comando, esto dependerá en qué circunstancias nos encontremos en la
ejecución de la aplicación de mantenimiento de datos de Facultad. Con el
método limpiarDatos se limpia los cuadros de textos.
En el botón de comando btnBuscar si está habilitado después de dar clic en

dicho botón, se procederá a la conexión con la base de datos, luego en la
variable rs se almacenará los datos provenientes de la tabla de Facultad. En
la variable b se coloca el valor ingresado en el cuadro de texto txtCodEst.
Se define una variable boleana encuentra para manejar la situación de éxito
o fracaso de la búsqueda. En la sentencia while utilizamos el método next
que pertenece al objeto rs, es decir, es un método de la interfaz ResulSet. El
método next devuelve verdadero si encuentra la primera fila de información,
las siguientes veces se desplaza en cada registro almacenado en el rs. La
sentencia if que se encuentra dentro del while, su condición lógica se hará
verdadero cuando encuentre el código de facultad buscado, haciendo que
los cuadros de textos se muestren los demás datos, es entonces que la
variable encuentra recién se hace verdadero.
El botón de comando btnVer (Ver Lista de Facultades), consiste en aumentar

el tamaño del formulario para visualizar el objeto JTable. Posteriormente se
establece la conexión con la base de datos y en la variable rs se almacena
los datos provenientes de la tabla de Facultad. Se define un vector
denominado datos de tamaño 2 elementos del tipo String que servirá colocar
los datos de una fila para luego agregarlo al objeto dtm que está vinculado al
objeto JTable llamado tablaFacultad. Pero antes de agregarlo debemos
asegurarnos que no exista fila alguna de datos en el modelo dtm y por ende
en la tablaFacultad. El bucle de la sentencia while permite colocar en cada

elemento del arreglo los datos extraídos de una fila que almacena el objeto
rs, esto es posible ya que el método getString, indicando la posición de la
columna, podemos obtener el dato de la fila actual.
Con el método addRow logramos crear una fila con los datos del vector
datos en el objeto dtm y como está vinculado a la tablaFacultad entonces se
podrá ver los registros agregados.
Para el botón de comando btnNuevo, limpiamos los cuadros de textos con el

método limpiarObjetos. Se habilita el cuadro de texto txtCodFac y se envía
el cursor al cuadro de texto txtCodFac. Se inhabilta los botones de comando
a excepción de grabar ya que estamos en el momento de ingresar nuevos
datos y proceder a almacenar.

En el botón de comando btnGrabar se inicia visualizando un mensaje de
confirmación para proceder a grabar, esto se logra usando el método
showConfirmDialog de la clase JOptionPane. Si la respuesta es Sí
entonces la sentencia if su condición lógica se hará verdadera y por lo tanto
establecemos conexión con la base de datos universidad, pasamos los datos
ingresados a variables como cod y nom. En la variable comando
establecemos la instrucción con el comando INSERT para luego usar el
método executeUpdate quien procederá a grabar los datos. Posteriormente
se procede a cerrar la conexión con el método close del objeto connection
conn.
En el botón de comando btnEliminar, también se procede a través de un

mensaje confirmar si procede la eliminación de los datos del Facultad. Si la
respuesta es afirmativa se procede a conectarse a la base de datos y en la
variable de memoria cod se almacenada el código de la facultad ingresado a
través del cuadro de texto txtCodFac. Se construye la instrucción usando el
comando DELETE, luego ejecutamos la eliminación física haciendo que el
campo idFacultad sea igual a cod y luego se cierra la conexión con la base
de datos.

En el botón de comando btnModificar, al igual que de grabar o eliminar se

procede a confirmar a través de un mensaje si se procede a la modificación
de datos. Una vez salvados los datos ingresados en los cuadros de textos en
variables de memoria se prepara la instrucción en la variable de memoria
comando. Usamos el comando UPDATE para actualizar los datos. Se
procede a ejecutar el comando con el método executeUpdate y se cierra la
conexión con el método close.
En el botón de comando Cancelar, luego de dar respuesta afirmativa se

procede a limpiar los cuadros de textos, habilita el cuadro de texto txtCodFac
para su uso y se vuelve a su estado inicial la habilitación de los botones de
comando.

El botón de comando btnCerrar, con el método dispose se cierra la ventana

o formulario.
5. Procedemos a ejecutar el formulario, seleccionando Ejecutar Archivo.
6. Observamos el formulario ejecutado.

7. Al dar clic en el botón de comando Nuevo podemos proceder a ingresar
datos. Una vez ingresado damos clic en el botón de comando Grabar.
8. Se muestra una confirmación para la grabación de datos.

USO DE COMANDOS SQL PARA MANTENIMIENTO DE

DATOS DE VARIAS TABLAS
Los objetos Swing Menus
En todo desarrollo de un proyecto de un sistema informático se debe construir

menús que permita al usuario interaccionar con las opciones del sistema.
Tenemos el JmenuBar que permite iniciar el diseño del menú, Se crea por defecto
un objeto Jmenu que permitirá a partir de este crear las opciones, las cuales se
crearán con los objetos JmenuItem.

No es mi intención detallar las distintas clases que tenemos para usar en el diseño
de un menú, pero si deseas conocer más sobre los Swing Menus, pueden revisar
las sesiones 10 y 11 del curso de Programación Visual I.
Mantenimiento de datos usando varias tablas
Esta sesión abarca el desarrollo de un mantenimiento de datos usando más de una

tabla
Siguiendo la sesión anterior haremos uso de la base de datos universidad de

MySql, Usar varias tablas no implica que se deba hacer mantenimiento de datos a
todas a la vez. La base de datos de universidad ya tiene la tabla de Facultad y la
tabla de Escuela. Para hacer el mantenimiento de datos de la tabla de Escuela
necesitaremos saber qué facultades están disponibles.
Vamos a proceder a realizar el mantenimiento de la tabla de Escuela:
1. Establecemos la conexión con la base de datos universidad.

2. Creamos un formulario denominado frmPrincipal donde diseñaremos un

menú.
3. Diseñamos el siguiente formulario que se denominará frmMantEscuela.

txtCodEsc
btnBuscar
btnVer
btnCerrar
txtNom
cboFac
btnNuevo
btnEliminar
btnModificar
btnGrabar
btnCancelar
tablaEscuela
4. Vamos a utilizar una vista para mostrar los datos de la tabla de Escuela en el
objeto JTable. Estando en la ficha de Prestaciones en la carpeta Vistas
damos clic botón derecho con el mouse y seleccionamos Crear Vista.

A continuación se visualiza una ventana para definir la vista denominada

v_escuelasprofesionales. Luego damos clic en el botón de comando Aceptar.
En la ficha de Prestaciones observamos la siguiente estructura.

5. Vamos a proceder a agregar métodos en la clase Acceso que utilizaremos

para el mantenimiento de datos de la tabla de Escuela.
El método EnlEsc es para obtener los registros de datos de la tabla de

Escuela.
El método obtenerCodFac es para obtener el código de facultad dado el

nombre de la facultad. Esto permitirá para la inserción o modificación de
datos en la tabla de Escuela.

El método obtenerNomFac es para obtener el nombre de la facultad dado el

código de facultad.
El método obtenerFacultades es para encontrar todos los nombres de las

facultades y poder llenar al objeto JComboBox cboFac.
El método obtenerVistaEscuelas permite conseguir los registros de la vista

v_escuelasprofesionales.
6. Veamos a continuación la programación que tendrá el formulario

frmMantEscuela.

a. Agregar los paquetes necesarios para el desarrollo de la aplicación.
b. Definir los atributos o variables a usar en los distintos métodos que forma
la clase frmMantEscuela.
Se utilizarán dos modelos uno para el JTable donde se visualizará la vista

diseñada anteriormente y otro modelo para el JComboBox que mostrará
las facultades existentes en la tabla de Facultad.
c. El método constructor debe quedar de la siguiente manera:

La mayor novedad en la programación del constructor es el llenado del

objeto cboFac usando el objeto rs y la visualización de los datos en el
objeto JTable usando la vista diseñada.
d. Procedemos a construir los métodos activabotones() y limpiarObjetos().

e. El botón de comando Buscar es para encontrar una escuela profesional
dado el valor de su código en el cuadro de texto txtCodEsc.
En la búsqueda es necesario tomar el código de facultad y encontrar el

nombre para que sea mostrado en el objeto cboFac.
f. En el botón de comando Ver Lista de Escuelas se visualizará los datos de

la tabla Escuela a través de la vista diseñada.

g. En los botones de comando Cerrar y Nuevo colocaremos el siguiente

código:
h. En el botón de comando Eliminar haremos uso del comando SQL

DELETE con la cláusula WHERE para remover un registro de datos.

i. Para el botón de comando Cancelar es para abortar el proceso actual

que estemos haciendo en la interacción con el formulario.
j. Para el botón de comando Modificar hacemos uso del comando SQL

UPDATE con la cláusula WHERE para actualizar un registro de datos.

En el proceso de modificación de datos dado que la facultad se

selecciona de un objeto JComboBox (cboFac), éste dato es el nombre de
la facultad y para modificar los datos se necesita el código de la facultad.
Es por ello la imperiosa necesidad de hacer uso del método
obtenerCodFac para encontrar el código de la facultad dado el nombre.
Lo mismo sucederá cuando se haga el proceso de grabación de datos.
k. Para el botón de comando grabar hacemos uso del comando SQL

INSERT con la cláusula INTO para insertar un nuevo registro de datos.

7. Vamos a proceder a ejecutar el formulario desde el menú de una ventana

denominada frmPrincipal.
8. Inicialmente se mostrará la ventana de mantenimiento de datos de Escuelas

de la siguiente forma:

Si damos clic en el botón de comando Ver Lista de Escuelas se visualizará lo

siguiente:

PROCEDIMIENTOS ALMACENADOS PARA

MANTENIMIENTO DE DATOS
Procedimientos almacenados
Poco a poco las empresas y muchas personas en general empiezan a mirar más
hacia el Software Libre y se dan cuenta que existen excelentes alternativas a
distintos programas que para ellos son de uso frecuente en otro Sistema Operativo,
como pueden ser OpenOffice, Mozilla Firefox, Eclipse, NetBeans, PostgreSQL,
PHP y MySQL por citar algunos, en esta nota hablaré un poco del Manejador de
Bases de datos MySQL, que en los últimos años ha tenido grandes avances en su
desarrollo y actualmente es uno de los DBMS más usados en sitios web y que en
sus últimas versiones ha incorporado nuevas características como la
implementación de las tablas, disparadores, funciones y procedimientos
almacenados. Los procedimientos almacenados son de gran utilidad para realizar
tareas frecuentes en una base de datos, es sorprendente la cantidad de tiempo que

se puede llegar a ahorrar al hacer uso de este mecanismo. Tambièn haremos uso
de vistas dentro de la estructura de un procedimiento almacenado.
Interface PreparedStatement
Este componente permitirá hacer uso de los procedimientos almacenados. Una vez
instanciado el objeto usaremos el método preparedStatement para invocar el uso
de un procedimiento almacenado. También se hará uso de los métodos setString(),
setInt(), setDate(), etc para indicar la posición del parámetro y el valor de dicho
parámetro. Finalmente usaremos el método executeUpdate() para ejecutar el
procedimiento almacenado.
A continuación, procedemos a diseñar el mantenimiento de datos de la tabla de

Plan_Estudios usando procedimientos almacenados:
1. Creamos la tabla Plan_Estudios dentro de la base de datos universidad:
Al dar clic en el botón de comando Aceptar, debe quedar la ficha de Servicios

así:

2. Procedemos a crear un procedimiento almacenado sp_insertaPlan que permitirá

la grabación de datos en la tala de plan_estudios.
Una vez ejecutado la creación del procedimiento almacenado se observará en la

pestaña de Prestaciones que dicho procedimiento se ha creado.

3. Luego, procedemos a crear el procedimiento almacenado sp_modificaPlan que
permitirá modificar o actualizar los datos de la tabla plan_estudios.
4. Posteriormente procedemos a crear el procedimiento almacenado

sp_eliminaPlan que permitirá hacer una eliminación física de registro de datos.
Una vez ejecutado la creación del procedimiento almacenado se observará en la

pestaña de Prestaciones los procedimientos creados.
5. En el formulario frmPrincipal que contiene el diseño del menú, ubicamos la

opción Plan de Estudios dentro de Mantenimientos.

6. Creamos el formulario frmMantPlan, luego seleccionas la opción Plan de

Estudios del menú y dando clic en el botón derecho del mouse elegimos
Eventos/Action/ActionPerformed.
7. Vamos a proceder a crear una vista para mostrar los datos del plan de estudios.
Estando en la ficha de Prestaciones y en la conexión de universidad
seleccionamos la carpeta Vistas y damos clic botón derecho del mouse.

A continuación se muestra la ventana para crear la vista. Usaremos las tablas
plan_estudios, escuela y curso para el diseño de la vista, la cual la
denominaremos v_plandeestudios.
Al dar clic en el botón de comando Aceptar, la ventana de prestaciones en la

carpeta vistas lo volvemos a seleccionar y dando clic botón derecho elegimos la
opción Actualizar y se mostrará lo siguiente:
8. Diseñamos el formulario frmMantPlan.

txtNroPlan
btnBuscar
btnVer
btnCerrar
cboEsc
cboCur
txtCiclo
txtHorasT
txtHorasP
txtHorasL
txtNroCre
btnNuevo
btnEliminar
btnModificar
btnGrabar
btnCancelar

tablaPlan
9. En la clase Acceso colocar el método obtenerVistaPlanes()
Para la grabación y modificación de datos se necesitará obtener el código de la

escuela dado el nombre de la escuela seleccionada y el código del nombre del
curso seleccionado. Entonces debemos hacer uso de dos métodos más.
También debemos obtener los nombres de las escuelas profesionales y los

nombres de los cursos para las listas desplegables cboEsc y cboCur.

10. Veamos a continuación la programación que tendrá el formulario frmMantPlan.
Importamos los paquetes java.sql (para acceder a base de datos), javax.swing

(para el uso de los controles visuales), javax.swing.table para el manejo de las
clases del paquete table y el paquete universidad que contiene a la clase
Acceso con lo cual podremos hacer uso de todos los métodos que tenga.
Establecemos los atributos o variables a usar en la conexión y acceso a la base

de datos, como también los modelos de datos para los objetos tablaPlan,
cboEsc y cboCur.

Se prepara los títulos del objeto tablaPlan en el vector títulos, se vincula los
modelos de datos a los objetos tablaPlan, cboEsc y cboCur. Luego se llena los
nombres de las escuelas profesionales en la lista desplegable cboEsc y de igual
modo se hace con la lista desplegable cboCur. También se llena de datos en el
objeto tablaPlan.

Los métodos activabotones() permitirá gestionar el uso de los botones de

comando y el método limpiarObjetos() es para limpiar los cuadros de textos.

En la búsqueda se hará por el número de plan, el nombre de la escuela

profesional y el nombre del curso. Se define una variable boleana encuentra
para manejar la situación de éxito o fracaso de la búsqueda. En la sentencia
while utilizamos el método next() que pertenece al objeto rs, es decir, es un
método de la interfaz ResulSet. El método next devuelve verdadero si
encuentra la primera fila de información, las siguientes veces se desplaza en
cada registro almacenado en el rs. La sentencia if que se encuentra dentro del
while, su condición lógica se hará verdadero cuando encuentre el número de
plan, la escuela profesional y el curso buscado, haciendo que los cuadros de
textos se muestren los demás datos, es entonces en que la variable encuentra
recién se hace verdadero.

El botón de comando btnVer (Ver Lista de Planes de Estudios), consiste en

aumentar el tamaño del formulario para visualizar el objeto JTable.
Posteriormente se establece la conexión con la base de datos y en la variable
rs se almacena los datos provenientes de la vista v_plandeestudios. Se define
un vector denominado datos de tamaño 8 elementos del tipo String que servirá
colocar los datos de una fila para luego agregarlo al objeto dtm que está
vinculado al objeto JTable llamado tablaPlan. Pero antes de agregarlo debemos
asegurarnos que no exista fila alguna de datos en el modelo dtm y por ende en
la tablaPlan. El bucle de la sentencia while permite colocar en cada elemento
del arreglo los datos extraidos de una fila que almacena el objeto rs, esto es
posible ya que el método getString, indicando la posición de la columna,
podemos obtener el dato de la fila actual. Con el método addRow logramos
crear una fila con los datos del vector datos en el objeto dtm y como está
vinculado a la tablaPlan entonces se podrá observar los registros agregados.
En el botón de comando btnGrabar se inicia visualizando un mensaje de

confirmación para proceder a grabar, esto se logra usando el método
showConfirmDialog de la clase JOptionPane. Si la respuesta es Sí entonces la
sentencia if su condición lógica se hará verdadera y por lo tanto establecemos
conexión con la base de datos universidad, pasamos los datos ingresados a
variables como cod, esc, cur, idesc, idcur, cic, ht, hp, hl y nc. En la variable

pstmt establecemos como procedimiento almacenado a sp_insertaPlan,
colocando 8 signos de interrogación que expresa el manejo de 8 parámetros
que tiene dicho procedimiento. Con los métodos setString() y setInt() del objeto
instanciado pstmt indicamos la posición del parámetro y el valor del parámetro,
así por ejemplo: 1 indica ser el primer parámetro de entrada del procedimiento
almacenado sp_insertaPlan y cod contiene el dato del número de plan que se
asignará al primer parámetro. Una vez indicado los valores a cada uno de los
parámetros se hace uso del método executeUpdate() que permitirá ejecutar el
procedimiento almacenado. Posteriormente se procede a cerrar la conexión con
el método close del objeto connection conn.
Para el botón de comando btnNuevo, limpiamos los cuadros de textos con el

método limpiarObjetos(). Se inhabilita el cuadro de texto txtNroPlan y se envía
el cursor al cuadro de texto txtNroPlan. Se inhabilita los botones de comando a
excepción de grabar.

En el botón de comando btnEliminar, también se procede a través de un

mensaje confirmar si procede la eliminación de los datos del Plan de Estudio. Si
la respuesta es afirmativa se procede a conectarse a la base de datos y en la
variable de memoria cod se almacenada el número de plan ingresado, en la
variable esc el nombre de la escuela profesional y en la variable cur el nombre
del curso. Con éstas variables buscamos el código de la escuela profesional y el
código del curso. En la variable pstmt establecemos como procedimiento
almacenado a sp_eliminaPlan, colocando tres signos de interrogación que
expresa el manejo de tres parámetros, luego se usa el método setString() para
indicar el valor de cada parámetro y posteriormente se ejecuta el procedimiento
almacenado.

En el botón de comando btnModificar, al igual que de grabar o eliminar se

procede a confirmar a través de un mensaje si se procede a la modificación de
datos. Una vez salvados los datos ingresados en los cuadros de textos en
variables de memoria se procede a utilizar el procedimiento almacenado
sp_modificaPlan. Pasamos los valores para cada uno de los parámetros. Se

procede a ejecutar el comando con el método executeUpdate y se cierra la
conexión con el método close.
En el botón de comando Cancelar, luego de dar respuesta afirmativa se procede

a limpiar los cuadros de textos, habilita el cuadro de texto txtNroPlan para su
uso y se vuelve a su estado inicial la habilitación de los botones de comando.
El botón de comando btnCerrar, con el método dispose se cierra la ventana o

formulario.
11. Procedemos a ejecutar el formulario desde el menú.

AUTOEVALUACION
1. La clase DriverManager pertenece al paquete java.swing (verdadero o falso)

______________________
2. La interfaz Connection permite crear objetos para establecer conexión con la

base de datos (verdadero o falso)
3. Es la interface que contiene los resultados provenientes de una consulta de

datos usando SELECT, se denomina _________________
4. Método que se usa para establecer la conexión con la base de datos a través del
interface Connection, se denomina ___________________
5. Método estático para definir el controlador JDBC, se denomina ______________
1. Construye una base de datos distinta al caso de universidad y establece

conexión en tiempo de diseño (se debe llegar a visualizar las tablas de la base de
datos en el entorno de NetBeans) y en tiempo de ejecución.
2. Construye una aplicación que permita el mantenimiento de la tabla de bus,
teniendo en cuenta que esta tabla tiene relación con la tabla de Marca. La
estructura de la tabla de Marca es: codmarca char(2), descripcion varchar(24); y la
estructura de la tabla de bus es: codbus char(3), codmarca char(2), nroasientos int,
nroejes int, nropisos int, placa varchar(10).
3. A la aplicación desarrollada en la parte 2 (mantenimiento de la tabla de bus),
cambiar en los procesos de grabación, eliminación y modificación de datos por el
uso de procedimientos almacenados.

CAPITULO III
CONSULTA DE DATOS

OBJETO JTABLE Y COMANDO SELECT EN CONSULTA

DE DATOS
Comando SELECT y sus claúsulas
La sentencia SELECT es usada para obtener la información guardada en una tabla.

La forma general de esta sentencia es:
SELECT LaInformaciónQueDeseamos FROM DeQueTabla WHERE

CondiciónASatisfacer
Aquí, LaInformaciónQueDeseamos es la información que queremos ver. Esta

puede ser una lista de columnas, o un * para indicar "todas las columnas".
DeQueTabla indica el nombre de la tabla de la cual vamos a obtener los datos. La
claúsula WHERE es opcional. Si está presente, la CondiciónASatisfacer especifica
las condiciones que los registros deben satisfacer para que puedan ser mostrados.
Podemos seleccionar sólo registros particulares de una tabla. Por ejemplo, si
deseamos visualizar las escuelas profesionales de la facultad de ingeniería:
Select e.nombre from escuela e, facultad f where e.idfacultad=f.idfacultad

And f.nombre=”Ingenieria”;
Podemos también combinar condiciones, por ejemplo, visualizar los planes de

estudio del primer ciclo, perteneciente a la escuela profesional de Ingeniería de
Sistema:
Select c.nombre, horasteoricas, horaspractica, horaslaboratorio, nrocreditos from
Plan_estudios p, curso c, escuela e where p.idcurso=c.idcurso and
p.idescuela=e.idescuela and e.nombre=”Ingenieria de Sistemas” and ciclo=1;
Se debe notar en los ejemplos anteriores que las filas regresadas son mostradas
sin ningún orden en particular. Sin embargo, frecuentemente es más fácil examinar
la salida de una consulta cuando las filas son ordenadas en alguna forma útil. Para
ordenar los resultados, tenemos que usar una cláusula ORDER BY.
Select e.nombre from escuela e, facultad f where e.idfacultad=f.idfacultad
And f.nombre=”Ingenieria” order by e.nombre;
Podemos ordenar múltiples columnas. Por ejemplo, para ordenar por ciclo de los
planes de estudio y por el número de créditos, el cual se ordenará de forma
descendente, usaremos la siguiente consulta:
Select ciclo,c.nombre, horasteoricas, horaspractica, horaslaboratorio, nrocreditos
from Plan_estudios p, curso c, escuela e where p.idcurso=c.idcurso and
p.idescuela=e.idescuela and e.nombre=”Ingenieria de Sistemas”
order by ciclo, nrocreditos desc;
Consulta de Datos usando PreparedStatement
En esta oportunidad vamos a utilizar el interface PreparedStatement para preparar

la consulta, cuya ejecución devolverá los resultados a un objeto ResultSet.
Seguimos usando la base de datos universidad, construyendo en esta oportunidad

una consulta que muestre los planes de estudio que pertenecen a una escuela
profesional seleccionada.
Para diseñar y desarrollar la aplicación seguiremos los siguientes pasos:
1. En la clase Acceso agregamos el siguiente método BuscaPlanesEscuela:

El método BuscaPlanesEscuela se inicia invocando al método sta() que a su vez

utiliza el método Enlace(), este último establece la conexión con la base de
datos, por lo tanto el objeto conn deja de ser null y contiene la información
necesaria de la conexión con la base de datos universidad. Se declara la
variable sql de tipo String, que contiene una consulta que hace uso de la vista
creada anteriormente en una de las sesiones de este curso. Esta consulta lo
que busca es obtener los datos de los planes de estudio que pertenecen a una
escuela profesional. Luego se declara y se construye una variable objeto ps del
tipo PreparedStatement que a partir del objeto conn de tipo Connection se
indica la sentencia select a ejecutar. Como la sentencia select tiene un signo ?
que indica que falta darle un valor, entonces se procede a usar el método
setString() donde el parámetro nom contiene el valor o dato a reemplazar en ?.
Se ejecuta la consulta usando el método executeQuery(), cuyo resultado se
almacena en el objeto ResultSet llamado rs.

opción Plan de Estudio por Escuela dentro de consultas.
Seleccionamos Plan de Estudio por Escuela damos clic botón derecho del
mouse elegimos Eventos/Action/ActionPerformed

Luego escribimos el siguiente código:
3. Diseñamos el siguiente formulario denominado frmConsPlanXEsc.
cboEscuela
btnConsultar
tablaPlanes
btnCerrar

4. Vamos a proceder a programar el formulario frmConsPlanXEsc colocando las
siguientes líneas de código:

Acceso con lo cual podremos hacer uso de todos los métodos que tenga. A
veces es necesario ser explícitos en señalar el uso de PreparedStatement para
el funcionamiento de los parámetros en la estructura de un comando SELECT.
Se define las variables objeto conn, st, rs del tipo Connection, Statement y
ResultSet inicializando como null. La variable objeto dtm es del tipo
DefaultTableModel para el manejo del objeto Jtable tablaPlanes.

Con la variable arreglo llamado titulos de tipo String, almacenamos los títulos
de cada uno de las columnas. Con el método setColumnIdentifiers() damos el
arreglo titulos para establecer los titulos de cada columna que maneja el
modelo dtm. Con el método setmodel() vinculamos el modelo al objeto Jtable
tablaPlanes. En el bloque try iniciamos con establecer la conexión con la base
de datos universidad. Una vez que se tienen la conexión procedemos a ejecutar
el método EnlEsc() que se encuentra en la clase Acceso que permitirá obtener
todos las escuelas profesionales. Con el método next() se ubica al primer
registro de los resultados devueltos por el método EnlEsc(), de ahí cada vez
que usemos el método next() se desplazará al siguiente registro. Cuando el
método next() devuelva falso terminará la ejecución de la sentencia repetitiva
while. En cada desplazamiento se agregará al objeto JComboBox denominado
cboEscuela el nombre de la escuela profesional.

Se declara la variable nomesc de tipo String, f e i de tipo int. En la variable

nomesc se almacena el nombre de de la escuela profesional seleccionada del
objeto JComboBox denominado cboEscuela. El método getSelectedItem()
obtiene el nombre de la escuela elegida pero lo extrae de tipo Object y al
anteponerle la expresión (String) se comporta como dato de tipo String y lo
asigna a la variable nomesc. En el bloque try establecemos la conexión con la
base de datos universidad y ejecutamos el método BuscaPlanesEscuela()
perteneciente a la clase Acceso que devolverá los datos de los planes de
estudio perteneciente a la escuela seleccionada. Se declara e instancia un
arreglo denominado datos[] que permitirá guardar los datos de un plan de
estudio encontrado en la variable rs, pero antes nos aseguramos que no exista
fila alguna en el objeto JTable tablaPlanes. La sentencia repetitiva while y
usando el método next() del objeto rs es para ubicarnos en la primera fila y en
las siguientes filas de los resultados devueltos por el método
BuscaPlanesEscuela(). En cada interacción se agregará una fila en el objeto
tablaPlanes a través del modelo dtm usando el método addRow().


formulario.
Seleccionamos la escuela de Ingeniería Civil y al dar clic en el botón de

comando Consultar se muestra:
Usando PreparedStatement con otros comandos

Cuando trabajamos con una base de datos es posible que haya sentencias SQL
que tengamos que ejecutar varias veces durante la sesión, aunque sea con
distintos parámetros. Por ejemplo, durante una sesión con base de datos podemos
querer insertar varios registros en una tabla. Cada vez los datos que insertamos
serán distintos, pero la sentencia SQL será la misma: Un INSERT sobre
determinada tabla que será siempre igual, salvo los valores concretos que
queramos insertar.
Casi todas las bases de datos tienen previsto un mecanismo para que en estos
casos la ejecución de esas sentencias repetidas sea más rápida. Si tenemos una
tabla person con un id, una edad, un nombre, un apellido y hacemos, por ejemplo,
varios INSERT así
mysql> INSERT INTO person VALUES (null, 23, 'Pedro', 'Perez');
mysql> INSERT INTO person VALUES (null, 33, 'Rodrigo', 'Rodriquez');
en cada caso la base de datos deberá analizar la sentencia SQL, comprobar que es
correcta, convertir los datos al tipo adecuado (por ejemplo, los enteros a int) y
ejecutar la sentencia.
El mecanismo que preven las bases de datos para hacer más eficiente este
proceso es que le indiquemos, previamente, el tipo de sentencia que vamos a usar,
de forma que la base de datos la "precompila" y la guarda en condiciones de ser
ejecutada inmediatamente, sin necesidad de analizarla en cada caso. Esto es lo
que se conoce como una prepared statement. En el caso de mysql, se haría de
esta forma
mysql> PREPARE insertar FROM "INSERT INTO person VALUES (null, ?, ?, ?)";
mysql> SET @edad=23;
mysql> SET @nombre='Pedro';
mysql> SET @apellido='Perez';
mysql> EXECUTE insertar USING @edad,@nombre,@apellido
mysql> SET @edad=33;
mysql> SET @nombre='Rodrigo';
mysql> SET @apellido='Rodriguez';
mysql> EXECUTE insertar USING @edad,@nombre,@apellido;
mysql> DEALLOCATE PREPARE insertar;
donde hemos preparado una prepared statement de nombre insertar con la SQL del
INSERT, en la que hemos reemplazado los valores concretos por interrogantes.
Fíjate que no hemos puesto comillas entre los interrogantes. Hemos hecho dos

inserciones dando valores a unas variables @edad, @nombre y @apellido, que son
las que se usarán en el EXECUTE de la prepared statement. Una vez finalizadas
las inserciones, avisamos a la base de datos que no vamos a usar más esta
prepared statement con un DEALLOCATE.

UNIONES Y SUBCONSULTAS EN CONSULTA DE DATOS
Uniones
Desde MySQL es posible realizar una consulta que devuelva los valores de una
tabla que está relacionada con otras de una sola vez.
Por ejemplo, tenemos una tabla principal bien normalizada, con muchos campos
que están relacionados mediante un id con otras tablas que contienen los valores
reales.
Lo que necesitamos hacer es convertir esa tabla principal en otra en que los IDs se
conviertan en dichos valores reales, y para ello utilizaremos JOINs:
Para los ejemplos, necesitamos crear y llenar tres tablas. La primera es un catálogo
de las reglas gramaticales para los acentos:
CREATE TABLE regla (
idRegla VARCHAR(1) DEFAULT '' PRIMARY KEY,
nombre VARCHAR(20) DEFAULT '' NOT NULL,
descripcion VARCHAR(250) DEFAULT '' NOT NULL
);
INSERT INTO regla VALUES ('A','aguda','última sílaba');

INSERT INTO regla VALUES ('G','grave','penúltima sílaba');
INSERT INTO regla VALUES ('E','esdrújula','antepenúltima sílaba');
INSERT INTO regla VALUES ('S','sobreesdrújula','trasantepenúltima
sílaba');

La segunda tabla es un catálogo de casos especiales, tales como diptongo, hiato y
triptongo
CREATE TABLE caso (
idCaso VARCHAR(1) DEFAULT '' PRIMARY KEY,
nombre VARCHAR(20) DEFAULT '' NOT NULL,
descripcion VARCHAR(250) DEFAULT '' NOT NULL
);
INSERT INTO caso VALUES ('H','hiato','dos vocales fuertes están juntas |

una vocal fuerte está junto con una vocal débil que suena más fuerte (en
este caso siempre se acentúa la vocal débil)');
INSERT INTO caso VALUES ('D','diptongo','');
INSERT INTO caso VALUES ('T','triptongo','');
Y la tercera tabla almacena las palabras que vamos a estudiar.

CREATE TABLE palabra (
cadena VARCHAR(20) DEFAULT '' PRIMARY KEY,
idRegla VARCHAR(1) NULL,
idCaso VARCHAR(1) NULL,
FOREIGN KEY (idRegla) REFERENCES regla (idRegla),
FOREIGN KEY (idCaso) REFERENCES caso (idCaso)
);
INSERT INTO palabra VALUES ('Raúl','A','H');

INSERT INTO palabra VALUES ('baúl','A','H');
INSERT INTO palabra VALUES ('bahía','G','H');
INSERT INTO palabra VALUES ('tía','G','H');
INSERT INTO palabra VALUES ('aéreo','E','H');
INSERT INTO palabra VALUES ('canción','A','D');
INSERT INTO palabra VALUES ('estuvo','G',NULL);
INSERT INTO palabra VALUES ('país','A','H');
INSERT INTO palabra VALUES ('maíz','A','H');
INSERT INTO palabra VALUES ('nunca','G',NULL);

INSERT INTO palabra VALUES ('jamás','A',NULL);
INSERT INTO palabra VALUES ('quiero','G','T');

INSERT INTO palabra VALUES ('ver',NULL,NULL);
INSERT INTO palabra VALUES ('tu',NULL,NULL);
INSERT INTO palabra VALUES ('risa','G',NULL);
INSERT INTO palabra VALUES ('todo','G',NULL);
INSERT INTO palabra VALUES ('el',DEFAULT,DEFAULT);
INSERT INTO palabra VALUES ('día','G','H');
Si seleccionamos todas las palabras tenemos 18 filas.

SELECT *
FROM palabra;
Si seleccionamos todas las palabras que no tiene una regla gramatical tenemos 3
filas.
SELECT *
FROM palabra
WHERE idRegla IS NULL;

Seleccionamos sólo las palabras que tienen regla gramatical.

-- 15 rows (sólo palabras con regla)
SELECT p.cadena, r.nombre
FROM palabra AS p
INNER JOIN regla AS r ON p.idRegla = r.idRegla;
Entonces tenemos 15 filas.

cadena nombre
------- ------
baúl aguda
canción aguda
jamás aguda
maíz aguda
país aguda
Raúl aguda
aéreo esdrújula
bahía grave
día grave
estuvo grave
nunca grave
quiero grave
risa grave
tía grave
todo grave
Ahora seleccionamos todas las palabras aunque no tengan regla gramatical.

-- 18 rows (todas las palabras, aunque no tengan regla)

FROM palabra AS p
LEFT OUTER JOIN regla AS r ON p.idRegla = r.idRegla;

cadena nombre
------- ------
el
tu
ver
baúl aguda
canción aguda
jamás aguda
maíz aguda
país aguda
Raúl aguda
aéreo esdrújula
bahía grave
día grave
estuvo grave
nunca grave
quiero grave
risa grave
tía grave
todo grave
Ahora seleccionamos todas las reglas gramaticales aunque no existan palabras

asociadas.
-- 16 rows (15 palabras con regla + 1 regla sin palabras)
FROM palabra AS p
RIGHT OUTER JOIN regla AS r ON p.idRegla = r.idRegla;

cadena nombre
------- ------
baúl aguda
canción aguda
jamás aguda
maíz aguda
país aguda

Raúl aguda
aéreo esdrújula
bahía grave
día grave
estuvo grave
nunca grave
quiero grave
risa grave
tía grave
todo grave
sobreesdrújula
NATURAL JOIN
El NATURAL JOIN nos ahorra la fastidiosa tarea de escribir las condiciones ON .. si

hemos trabajado correctamente con las llaves primarias ( PRIMARY KEY) y las llaves
foráneas (FOREIGN KEY).
Así que podemos reescribir las consultas anteriores usando la sintaixs del NATURAL
JOIN.
-- 15 rows (sólo palabras con regla)
FROM palabra AS p
NATURAL JOIN regla AS r;
-- 18 rows (todas las palabras, aunque no tengan regla)

FROM palabra AS p
NATURAL LEFT OUTER JOIN regla AS r;
-- 16 rows (15 palabras con regla + 1 regla sin palabras)

FROM palabra AS p
NATURAL RIGHT OUTER JOIN regla AS r;
Subconsultas
Una subconsulta es una sentencia SELECT que aparece dentro de otra sentencia
SELECT. Normalmente se utilizan para filtrar una clausula WHERE o HAVING con
el conjunto de resultados de la subconsulta, aunque también pueden utilizarse en la
lista de selección.
Por ejemplo podríamos consultar el alquiler último de un cliente.
SELECT CO_CLIENTE, NOMBRE, MARCA, MODDELO

FROM ALQUILERES

WHERE CO_CLIENTE = 1
AND FECHA_ALQUILER = (SELECT MAX(FECHA_ALQUILER)
FROM ALQUILERES
WHERE CO_CLIENTE = 1)
En este caso, la subconsulta se ejecuta en primer lugar, obteniendo el valor de la

máxima fecha de alquiler, y posteriormente se obtienen los datos de la consulta
principal.
Una subconsulta tiene la misma sintaxis que una sentencia SELECT normal
exceptuando que aparece encerrada entre paréntesis.
La subconsulta se puede encontrar en la lista de selección, en la cláusula WHERE
o en la cláusula HAVING de la consulta principal.
En este ejemplo la subconsulta aparece en la lista de selección, ejecutandose una
vez por cada fila que devuelve la consulta principal.
SELECT CO_EMPLEADO,
NOMBRE,
(SELECT MIN(FECHA_NOMINA)
FROM NOMINAS
WHERE CO_EMPLEADO = EMPLEADOS.CO_EMPLEADO)
PRIMERA_NOMINA
FROM EMPLEADOS;
Anidar subconsultas: Las subconsultas pueden anidarse de forma que una

subconsulta aparezca en la cláusula WHERE (por ejemplo) de otra subconsulta que
a su vez forma parte de otra consulta principal.
SELECT CO_EMPLEADO,
EMPLEADOS
FROM EMPLEADOS
WHERE CO_EMPLEADO IN (SELECT CO_EMPLEADO
FROM NOMINAS
WHERE ESTADO IN ( SELECT ESTADO
FROM ESTADOS_NOMINAS
WHERE EMITIDO = 'S'

AND PAGADO = 'N')
Reemplace un join con una subconsulta. Por ejemplo, pruebe:

SELECT DISTINCT column1 FROM t1 WHERE t1.column1 IN (
SELECT column1 FROM t2);
En lugar de:
SELECT DISTINCT t1.column1 FROM t1, t2

WHERE t1.column1 = t2.column1;

Use una subconsulta de registro en lugar de una subconsulta correlacionada . Por
ejemplo, use:
SELECT * FROM t1
WHERE (column1,column2) IN (SELECT column1,column2 FROM t2);
En lugar de:
SELECT * FROM t1
WHERE EXISTS (SELECT * FROM t2 WHERE t2.column1=t1.column1
AND t2.column2=t1.column2);
Aplicación
Vamos a proceder a crear una consulta que permita visualizar los palanes de
estudios de una escuela profesional y de un ciclo específico usando uniones y
subconsultas para calcular el total de créditos.
1. En la clase Acceso agregamos el siguiente método BuscaPlanesEscuelaCiclo.
El método BuscaPlanesEscuelaCiclo se inicia invocando al método sta() que a

su vez utiliza el método Enlace(), este último establece la conexión con la base
de datos, por lo tanto el objeto conn deja de ser null y contiene la información
necesaria de la conexión con la base de datos universidad. Se declara la
variable sql de tipo String, que contiene una consulta que hace uso de uniones
con INNER JOIN. Esta consulta lo que busca es obtener los datos de los planes
de estudio que pertenecen a una escuela profesional y aun ciclo determinado.
Luego se declara y se construye una variable objeto ps del tipo
PreparedStatement que a partir del objeto conn de tipo Connection se indica la
sentencia select a ejecutar. Como la sentencia select tiene dos signos ? que
indica que falta darle dos valores, entonces se procede a usar el método
setString() donde el parámetro nom y c contiene el valor o dato a reemplazar
en ?. Se ejecuta la consulta usando el método executeQuery(), cuyo resultado
se almacena en el objeto ResultSet llamado rs.


opción Plan de Estudio por Escuela y Ciclo dentro de consultas.
Seleccionamos Plan de Estudio por Escuela damos clic botón derecho del
mouse elegimos Eventos/Action/ActionPerformed
Luego escribimos el siguiente código:
3. Diseñamos el siguiente formulario denominado frmConsPLanEscCiclo

cboEscuela
cboCiclo
btnConsultar
tablaPlanes
btnCerrar
lblCreditos
4. Vamos a proceder a programar el formulario frmConsPLanEscCiclo colocando

las siguientes líneas de código:

ResultSet inicializando como null. La variable objeto dtm es del tipo
DefaultTableModel para el manejo del objeto Jtable tablaPlanes

Con la variable arreglo llamado titulos de tipo String, almacenamos los títulos
de cada uno de las columnas. Con el método setColumnIdentifiers() damos el
arreglo titulos para establecer los titulos de cada columna que maneja el
modelo dtm. Con el método setmodel() vinculamos el modelo al objeto JTable
tablaPlanes. En el bloque try iniciamos con establecer la conexión con la base
de datos universidad. Una vez que se tienen la conexión procedemos a ejecutar
el método EnlEsc() que se encuentra en la clase Acceso que permitirá obtener
todos las escuelas profesionales. Con el método next() se ubica al primer
registro de los resultados devueltos por el método EnlEsc(), de ahí cada vez
que usemos el método next() se desplazará al siguiente registro. Cuando el
método next() devuelva falso terminará la ejecución de la sentencia repetitiva
while. En cada desplazamiento se agregará al objeto JComboBox denominado
cboEscuela el nombre de la escuela profesional.

Se declara la variable nomesc y ciclo de tipo String, f e i de tipo int. En la

variable nomesc se almacena el nombre de de la escuela profesional
seleccionada del objeto JComboBox denominado cboEscuela y en la variable
ciclo se almacena el ciclo de estudios. El método getSelectedItem() obtiene el
nombre de la escuela elegida pero lo extrae de tipo Object y al anteponerle la
expresión (String) se comporta como dato de tipo String y lo asigna a la variable
nomesc y de igual manera lo hacemos con la variable ciclo. En el bloque try
establecemos la conexión con la base de datos universidad y ejecutamos el
método BuscaPlanesEscuelaCiclo() perteneciente a la clase Acceso que
devolverá los datos de los planes de estudio perteneciente a la escuela
seleccionada y al ciclo indicado. Se declara e instancia un arreglo denominado
datos[] que permitirá guardar los datos de un plan de estudio encontrado en la

variable rs, pero antes nos aseguramos que no exista fila alguna en el objeto
JTable tablaPlanes. La sentencia repetitiva while y usando el método next()
del objeto rs es para ubicarnos en la primera fila y en las siguientes filas de los
resultados devueltos por el método BuscaPlanesEscuelaCiclo(). En cada
interacción se agregará una fila en el objeto tablaPlanes a través del modelo
dtm usando el método addRow(). A través del método BuscaTotalCreditos()
obtenemos el total de créditos del ciclo y la escuela profesional indicado. Con el
método next() del obejto rs1 nos ubicamos en la única fila posible y obtenemos
la suma de los créditos.

formulario.
Seleccionamos la escuela de Ingeniería Civil y 1er ciclo y al dar clic en el botón

de comando Consultar se muestra:


PROCEDIMIENTOS ALMACENADOS EN CONSULTA DE

DATOS
Procedimientos almacenados usando CallableStatement
Los procedimientos almacenados diseñados para consulta de datos deben ser

ejecutados a partir de un objeto instanciado o creado a partir de CallableStatement.
Este interfaz permitirá hacer uso de parámetros de entrada y de salida.
Vamos a construir una consulta que permita visualizar la carga académica de un

docente seleccionado en un semestre indicado y también la carga académica de
una escuela profesional en un semestre dado.
1. Construyamos la siguiente vista para visualizar los datos de la carga académica.

Para la vista v_carga_academica se hace uso de las tablas: carga_academica,

plan_estudios, escuela, curso, docente y sede.
2. Construyamos los siguientes procedimientos almacenados:
Este procedimiento almacenado permitirá obtener la carga académica de un

docente en un semestre indicado para lo cual se hace uso de la vista creada
previamente. En la clase Acceso construye el método BuscaCargaAcademica
Este método permitirá ejecutar el procedimiento almacenado, para ello es

necesario crear un objeto de la interfaz CallableStatement. Con el método
setString indicamos el orden de los parámetros de entrada del procedimiento y
los valores para cada parámetro. El método executeQuery() hace la ejecución
del procedimiento almacenado cuyo resultado se almacena en el objeto rs del
tipo ResultSet.

El procedimiento almacenado sp_cantidad_horas es para obtener la cantidad

de horas asignadas a un docente en un semestre indicado. En la clase Acceso
agrega el método BuscaHorasAsignadas() para hacer uso del procedimiento
almacenado sp_cantidad_horas.
A continuación el procedimiento almacenado para visualizar la carga académica

de una escuela profesional de un semestre indicado.
Para éste procedimiento almacenado en la clase Acceso se crea el método

BuscaCargaEscuela()
3. El objeto JTabbedPanel permite usar un diseño fácil para interactuar con varias
pestañas (llamadas también persianas, páginas, etc.). Vamos ir conociendo o
recordando el uso de este objeto que lo utilizaremos en el diseño de la

aplicación para visualizar la carga académica. Colocamos un objeto
JTabbedPanel en el formulario frmConsCargaAcademica.
Luego selecciona el objeto JTabbedPanel y dando clic botón derecho del mouse
se agrega un objeto JPanel que permitirá crear la primera pestaña.

Se dibujará la primera persiana o pestaña:
4. En la vista de propiedad JPanel1 (tab1), en la propiedad Tab Title (Título de la

Pestaña) coloca la expresión: “Carga Académica por Docente”.

5. Luego de cerrar la ventana anterior, diseña la pestaña de la siguiente manera:
cboDocente
txtSemestre
btnConsultar
tablaCargaDocente
btnCerrar
lblHorasAsig

6. Para agregar una segunda pestaña se debe agregar otro JPanel.
En la propiedad Tab Title (Título de la Pestaña) coloca la expresión: “Carga

Académica por Escuela”.
7. Luego de cerrar la ventana anterior, diseña la segunda pestaña de la siguiente

forma:

cboEscuela
txtSemes
btnMostrar
tablaCargaEscuela
btnSalir
8. A continuación colocar la siguiente programación en el formulario

frmConsCargaAcademica.


ResultSet inicializando como null. Las variables objeto dtmCargaDoc y
dtmCargaEsc es del tipo DefaultTableModel para el manejo de los objetos
Jtable tablaCargaDocente y tablaCargaEscuela. Se crea una matriz para el
manejo de los apellidos y nombres de los docentes.
Agregamos en la clase Acceso el método EnlDoc para obtener los apellidos y
nombres de los docentes.
En el método constructor se escribe:

Con los vectores tituloCargaDoc y tituloCargaEsc se define los títulos de cada

objeto JTable. Los modelos de datos dtmCargaDoc y dtmCargaEsc se le pasa
los títulos con el método setColumnIdentifiers() y luego se les vincula con los
objetos tablaCargaDocente y tablaCargaEscuela. Se establece la conexión
con la base de datos universidad, con la variable rs se almacena los registros de
la tabla de Docente y en la primera sentencia while se procede a llenar la caja
de lista desplegable referido al Docente con los apellidos y nombres de cada
uno de los Docentes. La necesidad de usar una matriz denominado profesor es
para poder manejar los apellidos y nombres de forma separada. Con la variable
rs1 se almacena los registros provenientes de la tabla de Escuela y con la
segunda sentencia while se llena la lista desplegable con los nombres de las
escuelas profesionales.

En las variables de memoria se almacena los apellidos y nombres del docente,

el semestre y la posición del docente seleccionado para poder extraer de la
matriz los apellidos y nombres por separado. Establecido la conexión se busca
la carga académica del docente en el semestre indicado usando el método

BuscaCargaAcademica(), quien a su vez invoca la ejecución del procedimiento
almacenado sp_mostrar_carga_docente. El modelo de datos se elimina todas
las filas de información y se procede a llenar para que sea visto a través del
objeto tablaCargaDocente. Con la variable rs1 se almacena la suma de las
horas teóricas, las horas de práctica y las horas de laboratorio y con la variable
sumahoras, donde se almacena la suma de horas, se procede a mostrar el
resultado en el cuadro de texto txtHorasAsig. En el caso que rs1 no contenga
fila alguna de datos se procede a visualizar un mensaje que indica que no hay
carga asignada.
La interpretación de éste código es similar al botón de comando Consultar,

donde el método BuscaCargaEscuela() se obtiene los datos de la carga
académica dado el nombre de la escuela y el semestre.

9. Se procede finalmente a ejecutar la consulta. Indicar como semestre 201001 y
como docente Salcedo Quiñones Martín Gustavo. Al dar clic en el botón de
comando Consultar se visualiza:
Al seleccionar la siguiente pestaña (Carga académica por Escuela) indicamos

como escuela profesional Ingeniería Civil y como semestre 201001. Al dar clic
en el botón de comando Mostrar se muestra:

AUTOEVALUACION
1. Usando el entorno de Netbeans la creación de una tabla se puede hacer con

Execute Command (verdadero o falso) ____________________
2. El método executeQuery() permite ejecutar una consulta de datos a partir de un

comando SELECT (verdadero o falso) ____________________
3. El método getString permite indicar una valor de un parámetro de entrada de tipo

entero (verdadero o falso) _______________________
4. Paquete que permite trabajar con aplicaciones con base de datos, se denomina-
__________________
5. Método que permite desplazarse dentro del cursor ResultSet registro por registro,
se denomina __________________
1. Construye una aplicación que permita consultar los cursos pertenecientes a una
área específica. Usa la base de datos de universidad.
2. De acuerdo a la aplicación desarrollada en el presente capítulo, cambia la lista
desplegable de escuela profesional y la lista desplegable del ciclo académico por
una caja de Lista y en cuadro de texto respectivamente. Cambiar la programación
que sea necesaria y luego ejecutar la aplicación.
3. A la aplicación desarrollada en la parte 2 donde se mostraba los planes de
estudios luego de seleccionar la escuela profesional e indicar el ciclo, usa un
procedimiento almacenado que siga haciendo la misma consulta

CAPITULO IV
REPORTE Y DESARROLLO DE UN SISTEMA

DISEÑO DE REPORTES CON IREPORT
IReport
IReport es un diseñador visual de código libre para JasperReports escrito en Java.

Es un programa que ayuda a los usuarios y desarrolladores que usan las
bibliotecas o librerías JasperReports para diseñar reportes visualmente. A través de
una interfaz rica y simple de usar, IReport provee las funciones más importantes
para crear reportes en menos tiempo. IReport genera archivos “jasper” y “print” de
prueba. IReport nació como una herramienta de desarrollo, pero puede utilizarse
como una herramienta de oficina para adquirir datos almacenados en una base de
datos, sin pasar a través de alguna otra aplicación.

IReport en NetBeans
Los desarrolladores de iReport sacaron un plugin para NetBeans a finales de

Diciembre del 2007. Para los que programaron en .net habrán usado un
CristalReports, así en Java viene a ser iReport. Pero iReport es un editor visual
para generar los reportes por medio de la librería jasperReport. Después de todo
esto, para lo que usamos NetBeans como entorno de desarrollo quizá no era el
más adecuado tener que usar dos herramientas por separado, sin embargo en
febrero del 2008 sale un plugin de iReport para NetBeans lo cual es una mejora de
los utilitarios que ofrece el entorno NetBeans.
Vamos instalando el plugin o complemento de iReport para NetBeans (se aplica a

partir de la versión 6.0) siguiendo los siguientes pasos:
1. Estando en el entorno de NetBeans, en la barra de menú selecciona la opción

herramientas (tolos) y luego la opción de complementos (plugins).
2. Se apertura una ventana de complementos disponibles, dando la posibilidad de

descargar nuevos complementos. Los complementos (plugins) de IReport para
NetBeans hay que descargarlo de internet a través de la página web de
NetBeans, la misma que te obligará a que te registres previamente.

Después de agregar los complementos referidos a ireport-designer y a

jasperreport, dar clic en el botón de comando Instalar. Se muestra una ventana
indicando los complementos que se quiere instalar.
Dar clic en el botón de comando Siguiente.

Se marca el ChecBox referido a Aceptar los términos de los acuerdos de

licencia y finalmente dar clic en el botón de comando Instalar.
Una vez finalizado la instalación se debe mostrar la ventana de que la

instalación se completó satisfactoriamente. Luego damos clic en el botón de
comando Finalizar (Finish).

Vamos a proceder a usar el archivo conector de mysql (.jar) para IReport.
Seleccionar la opción Herramientas (Tools) / Opciones (Options). Luego
seleccionamos el botón de la barra de herramientas referido a IReport.
Seleccionar la pestaña Classpath.
Ahora agrega el archivo jar a través del botón de comando Add JAR

Damos clic en el botón de comando Aceptar
Finalmente damos clic en el botón de comando Aceptar para cerrar la ventana

Opciones.

3. Estando en el entorno de NetBeans, selecciona nuevamente la opción de
Herramientas y luego la opción referido a la primera opción referido a
DataSources.
A través del botón de comando New procedemos a establecer la conexión con

la base de datos.
4. Debemos tener un proyecto abierto o creamos otro para hacer uso del IReport.
Si tuviéramos un proyecto llamado Reportes, nos ubicamos en el paquete
Reportes y dando clic botón derecho del mouse procedemos a buscar la opción
EmptyReport. Luego de seleccionar EmptyReport, dar clic en el botón de
comando Siguiente e indicamos el nombre de reporte a diseñar. Finalmente dar
clic en el botón de comando Terminar. El entorno de NetBeans se verá el
entorno de IReport.

El modo de uso para diseñar reportes con IReport en el entorno NetBeans es

similar si lo usas como un software aparte.
Usando IReport 3.7.2
Ejecuta el archivo aplicación ireport.
Se muestra el siguiente entorno.

Dar clic aquí

Indicar el nombre de la conexión (jdbcUniversidad), el nombre de la base de datos

en JDBC URL y finalmente el usuario y el password. Dar clic en el botón de
comando Test para verificar la conexión.
Solicitará indicar el password y luego dar clic en el botón de comando OK. Debe
salir un mensaje de conexión satisfactoria.

Nuevamente estando en el entorno de IReport, selecciona.
Al dar clic en el botón de comando Open this Template se muestra

Al dar clic en el botón de comando Terminar, el entorno de IReport se visualia de la

siguiente manera.

Seleccionar la opción Query.
Escribe la sentencia SELECT para visualizar las Escuelas Profesionales

Luego de dar clic en el botón de comando OK.
Seleccionar un objeto Static Text para colocar un título al reporte.

Usando objetos Static Text coloca los títulos para cada uno de los campos.

Usando los campos que se muestran en la vista Report Inspector arrastra los
campos a la zona de Detail del diseño colocando debajo del título.
Procede a hacer una vista preliminar del reporte.

Solicitará el ingreso del password y luego al dar clic en el botón de comando

Aceptar se visualizará el reporte.

JASPERREPORT Y SUBREPORTS CON IREPORT
JasperReports
JasperReports es la mejor herramienta de código libre en Java para generar

reportes. Está completamente escrita en Java y se puede utilizar en una gran
variedad de aplicaciones de Java, inclusive para aplicaciones Web. Se requiere
contar con un JDK 1.4 o superior.
JasperReports trabaja en forma similar a un compilador y a un intérprete. El usuario

diseña un reporte que al ser compilado genera un reporte real. Un archivo jasper es
el compilado de un código fuente. Cuando tenemos un archivo jasper, necesitamos
otra cosa para producir un reporte, necesitamos datos. Una fuente de datos + un
archivo jasper es igual a un “archivo print”. Este “archivo print” puede exportarse en
muchos formatos principalmente en pdf.
Vamos a proceder a ejecutar el reporte que se diseñó en la sesión anterior. IReport

generó dos archivos con la extensión jasper y jrxml y con el nombre
reportEscuelasProfesionales. A continuación en el entorno NetBeans vamos a

preparar una clase denominada reporteEscuelas.class que nos permitirá ejecutar el
reporte elaborado.
1. Selecciona el paquete universidad, al dar clic con el botón derecho del mouse,
selecciona Nuevo/Clase Java.
2. Indicar el nombre de la clase reporteEscuelas. Luego dar clic en el botón de

comando Terminar.
3. Procede a crear una librería o biblioteca con el nombre JasperReport donde se

encontrará todos los archivos de extensión jar para la ejecución de reportes.

Luego de dar clic en el botón de comando Aceptar, selecciona la biblioteca

recién creada.
En la versión 6.5 de NetBeans ya existe una biblioteca llamada JasperReports

3.0.1 al que podemos hacer uso. A la nueva biblioteca debe contener los
archivos jar que lo tiene la biblioteca JasperReports 3.0.1.

4. Como se hizo en sesiones anteriores cuando se tuvo que agregar la librería

MySQL para hacer uso del conector jar para el gestor de base de datos MySql,
ahora procede a agregar la librería o biblioteca que contiene los archivos jar de
JasperReport.
Se abre la ventana Añadir Biblioteca y se selecciona JasperReports 3.0.1

Posteriormente dar clic en el botón de comando Añadir Biblioteca.
5. A continuación procede a programar en la clase reporteEscuelas.class

Importamos los paquetes sql para manejo de base de datos, el paquete swing
que a través de la clase JOptionPane para visualizar mensajes, el paquete util
para manejar los parámetros. Los paquetes net.sf.jasperreports para el manejo
de las clases: JasperFillManager para llenar o administrar los datos
provenientes de la base de datos, JasperPrint para lograr la impresión del
reporte y la clase JasperViewer para la visualización del reporte antes de la
impresión.
Se prepara una variable de tipo Connection llamado conn y en el método

visualiza, en el bloque Try buscamos en establecer la conexión con la base de

datos de universidad. En el siguiente bloque Try instanciamos la variable
parameters a partir de la clase Map, esta variable objeto parameters con el
método put lo inicializamos con “” con lo cual indicamos que no manejamos
parámetros para la consulta. Luego con la variable print de tipo JasperPrint le
indicamos a través del método fillReport la ruta donde se encuentra el archivo
jasper reporte generado por IReport, la variable parameters y la variable de
conexión para poder obtener los datos. Finalmente usando la clase
JasperViewer a través del método viewReport, indicamos la variable print que
contiene información del reporte y con false indicamos que no proceda aún a la
impresión.
6. Agrega en el formulario frmPrincipal, la opción para mostrar el reporte.
Colocar en el evento de actionPerformed la ejecución de la clase

reporteEscuelas.class.
7. Ejecutar el reporte desde el menú.

Reportes y subreportes con IReport
Los informes o reportes resultado de un proceso, más o menos completos, de datos

provenientes de una o varias tablas de una base de datos. No hay mucha diferencia
entre un informe y un subinforme. El informe pasa a convertirse en subinforme
cuando forma parte de otro informe. Se llamará reporte maestro al reporte
propiamente dicho y a los reportes que forman parte del reporte maestro se llamará
subreportes o subinformes.
Procede a crear un informe o reporte en el que se visualice los planes de estudios

por escuela profesional, para lo cual será necesario crear dos informes (dos
archivos jasper) con IReport, para lo cual hacer los siguientes pasos:
1. Estando en el entorno de IReport selecciona de la barra de menú la opción

Archivo/New.

Indicar como nombre de reporte reportEscuelasProfesionales. Luego dar clic en

el botón de comando Siguiente y posteriormente dar clic en Terminar.
2. Como en la sesión anterior se había establecido la conexión usando Report

DataSources, ahora selecciona la opción Query.

3. Construye una sentencia select, consultando los datos de las escuelas

profesionales. Asegúrate antes de escribir la sentencia de desmarcar el
checkbox referido a Automatically Retrieve Fields, para evitar la recuperación de
campos de forma automática. Luego dar clic en el botón de comando Read
Fields para lograr visualizar los campos obtenidos de la consulta.
4. Colocar un título en la zona de Title: Reporte de Planes de Estudios por Escuela

Profesional. Inmediatamente crea un grupo para que exista las zonas Planes
Group Header y Planes Group Footer. Dar clic en el botón derecho del mouse
sobre la plantilla del diseño del reporte para seleccionar la opción Add Report
Group.

Proceder a dar como nombre de grupo Planes.
Luego dar clic en el botón de comando Siguiente.
Posteriormente dar clic en el botón de comando Terminar.
5. Agregar a través de objetos staticText los rótulos: Escuela Profesional y

Facultad. Todos estos títulos colocarlos en la zona Planes Group Header.
Además colocar los campos correspondientes a cada título debajo de éstos.

6. Dejar por un momento el diseño del reporte reportEscuelasProfesionales y

procede a crear otro diseño. El nuevo reporte se denomina reportPlanes.
Procede a seleccionar del menú del entorno IReport la opción New.

Indicar el nombre del archivo para el reporte de los Planes de estudios:
reportPlanes. Posteriormente dar clic en el botón de comando Terminar.
7. Definir un parámetro denominado codescuela.

8. Seleccionar la opción Query. Usar el botón de comando Query Designer puedes
construir la sentencia select.
Seleccionar las tablas plan_estudios, curso y escuela y elegir con un check los
campos.

Elegir la cláusula WHERE y dando clic con el botón derecho selecciona Add
Condition.
Establece la condición de que el código de la escuela profesional de la tabla

plan_estudios es igual al código de la escuela profesional de la tabla Escuela.
Dar clic en el botón de comando OK y nuevamente agrega otra condición

seleccionando Add Condition de la claúsula WHERE. Ahora procede a indicar
que el código de curso de la tabla plan_estudios es igual al código de curso de
la tabla Curso.

Dar clic en el botón de comando OK. Por última vez agregamos otra
condición desde la claúsula WHERE. Indicamos que el código de escuela
profesional de la tabla plan_estudios es igual al parámetro codescuela.
Finalmente cerrar la ventana de diseño de la consulta dando clic en el botón

de comando OK. La ventana Report Query queda de la siguiente manera
luego de dar clic en el botón de comando Read Fields.

Dar clic en el botón de comando OK.
9. Diseñar el reporte usando los campos (Fields) y objetos Static Text.
10. Volver al diseño del reporte anterior (reportEscuelasProfesionales). Agregar un

subreport en la zona Detail.

Indicar el archivo jasper: reportPlanes. Dar clic en el botón de comando

Siguiente.
Hacer uso de la conexión del reporte maestro, es decir, usamos la misma

conexión del reporte reportEscuelasProfesionales. A continuación damos clic en
el botón de comando Siguiente.

Seleccionar la opción Use the same connection used to fill the master report y
luego dar clic en el botón de comando Siguiente.

Posteriormente dar clic en el botón de comando Terminar.
11. Acomodar el subreport en el diseño quedando de la siguiente forma:
12. Procede a hacer una vista previa usando Preview.


DESARROLLO DE UN SISTEMA
Caso Reyser Ingenieros SRL
La Empresa Reyser Ingenieros SRL, inició sus servicios en 1993 con trabajos de
mantenimientos varios en plantas industriales y servicios de saneamiento de agua y
alcantarillado, y durante el año de 1995 ampliaron sus servicios con Hidrandina
S.A. en trabajos comerciales y de control de pérdidas. En el año 2001 Reyser
Ingenieros SRL, obtiene su registro de Consucode y empieza la ejecución de obras
eléctricas y de construcción civil, por lo que para optimizar la calidad de su servicio
establece una alianza estratégica con Sesga Contratistas SAC, con la que atienden
con éxito reconocido a sus clientes; ejecutando servicios de actividades
comerciales con Hidrandina S.A. en Cajamarca, Chepén, Pacasmayo, Paiján y
Control de Pérdidas en Trujillo. El personal profesional y técnico con el que cuenta
el Consorcio inició sus labores con Reyser Ingenieros SRL y fue la base para que
Sesga Contratistas tenga éxito en el servicio a sus clientes; para que en la

actualidad sigan laborando en la superación de los procesos y en la calificando del
personal nuevo que se admita sean ingenieros o técnicos. Esta amplia experiencia
basada en la capacidad, superación, honestidad e identificación, constituye sin
duda alguna su mayor fortaleza.
Como “Consorcio Sesga – Reyser” viene prestando con reconocido éxito servicios
de actividades comerciales y de distribución a Hidrandina S.A. en Cajamarca,
Chimbote, La Libertad Norte y La Libertad.
MISION DEL “CONSORCIO SESGA – REYSER”
El Consorcio está orientado a la realización de las actividades comerciales y de

distribución con acciones eficaces, con personal altamente capacitado y equipado,
para cumplir a satisfacción las exigencias de sus clientes finales.
Su labor está enmarcada con responsabilidad social, cuyos esfuerzos los orienta
en el fortalecimiento institucional que contribuye al desarrollo del capital humano,
conservación de la calidad del servicio y defensa de los intereses de sus clientes a
través de la satisfacción de sus demandas y solución de problemas sean regionales
o nacionales; con estándares de calidad y las mejoras prácticas administrativas,
concordantes con las exigencias del mundo globalizado.
VISION DEL CONSORCIO SESGA – REYSER
La visión del Consorcio es ser reconocida como una empresa líder, por la
certificación de sus procesos y la garantía de brindar un servicio de excelencia a
sus clientes, en el desarrollo sostenible de la Región.
ORGANIGRAMA DEL CONSORCIO SESGA – REYSER

SERVICIOS QUE BRINDA EL CONSORCIO SESGA – REYSER
El Consorcio brinda servicios a Hidrandina S.A. como: Distribución en redes de

M.T. y B.T., así mismo ejecución de proyectos, obras y Servicios comerciales en
B.T.
Gestión Comercial Servicio Eléctrico
Los servicios que realiza en este ámbito son labores como:

 Nuevos Suministros Eléctricos
 Reaperturas de Servicios Eléctricos
 Reubicaciones de Servicios Eléctricos
 Inspecciones de Reclamos sobre el Servicio
 Inspecciones por Factibilidad Eléctrica
 Cortes del servicio Eléctrico por falta de pago
 Reconexiones del servicio
 Reparaciones del servicio eléctrico
 Cambio de Tipo de Conexiones Eléctricas
 Instalaciones de Servicios Temporales
Para la realización de estos trabajos se necesita contar con un sistema para el

registro de los trabajos ejecutados, el cual debe valorizarlos y poder presentar a la
concesionaria un reporte diario de estos trabajos para su revisión, supervisión y
posteriormente presentar una factura por los servicios brindados.
ENTREVISTA CON EL USUARIO DEL SISTEMA A DESARROLLAR
Para la realización del presente trabajo académico se realizo una entrevista a un

usuario del sistema:
DATOS:
 Nombre: Cinhtya Ramos Quispe

 Área de desempeño: Área informática
 Función que realiza: Ingreso de fichas técnicas de intervención de suministro
eléctrico al sistema.
PROCESO DE LA INFORMACION:
En el área informática del Consorcio Sesga – Reyser se procesa la siguiente

información.

 Se recibe las fichas técnicas de intervención de suministro eléctrico, las
mismas que son realizadas en campo por el personal técnico electricista.
 Se ingresa al sistema los datos de la ficha, para su registro, los datos de los
materiales para actualizar el stock de éstos y codificación para la
valorización del trabajo realizado o metrado.
 Se emite un informe diario de las fichas ingresadas al sistema una por cada
actividad (avería, reconexión, nuevo suministro, etc), para su reporte a
Hidrandina S.A.
 Se realiza una valorización de los trabajos realizados, el cual se emite al
supervisor de Hidrandina S.A. para su revisión y aprobación.
 Realizar un resumen o consolidado de las actividades realizadas durante el
mes para su facturación.
 Las fichas técnicas de intervención de suministros que se utilizan son de dos
tipos:
- Para realizar reconexiones de servicio eléctrico
- Para las demás actividades como averías, nuevos suministros, etc.
Diseño de la base de datos

Estructura de las Tablas
Tabla: Actividades

Tabla: Cliente
Tabla: Medida
Tabla: Recursos
Tabla: Medidor

Tabla: Marca
Tabla: Ficha
Tabla: DetalleMedidor

Tabla: DetalleActividades
Tabla: DetalleRecursos
Diseño de Interfaces
Pantalla Principal

Mantenimiento de Marca
Mantenimiento de Medidor

Mantenimiento de Medidas
Mantenimiento de Actividades

Mantenimiento de Recursos
Registro de Fichas

Consulta de Fichas por Suministro

Consulta de Fichas por un rango de fechas

AUTOEVALUACION
1. Si el objeto pstm está creado entonces, la ejecución del procedimiento

almacenado a través de éste objeto sería __________________
2. Para diseñar reportes en Java se hace uso de del IReport (verdadero o falso)
_______________________
3. Permite ejecutar sentencias SQL con parámetros de entrada. Tiene la ventaja de

la rapidez de su ejecución, la interface se denomina
4. Para trabajar con reportes se necesita el archivo jar denominado

_____________________
1. Diseña el reporte indicado en el presente capítulo y luego haz lo mismo con otra
tabla de la base de datos universidad.
2. Usando las tablas de la base de datos diseña y ejecuta un reporte usando
subreportes. La aplicación debe ser diferente al ejemplo usado en el presente
capítulo.
REFERENCIAS BIBLIOGRAFICAS
• Harvey M. Deitel y Paul J.Deitel Cómo programar en Java.Pearson Educación, 5da
edición, 1268p, 2004
• Página oficial de NetBeans. Utilizando el entonr NetBeans
http://wiki.netbeans.org/SpanishTranslationTutorialesAPIPersistenciaVWP
• Página oficial de MySql Descargando el conector para MySql
http://dev.mysql.com/downloads/connector/j/5.0.html
• Ejemplo básico de programación con JDBC y MySql.[19 Noviembre del 2007]
http://casidiablo.net/ejemplo-basico-de-programacion-con-jdbc-y-mysql/
• Sherekan. JDBC y MySql. [27 Agosto del 2008]
http://www.clubdesarrolladores.com/articulos/mostrar/61-jdbc-y-mysql
• Youtube. Instalación de Ireport para NetBenas 6.9 [Abril 2010]
http://www.youtube.com/watch?v=wKimVA6fOBA
Bliblioteca virtual de la ULADECH

1. PROGRAMACION EN JAVA2.Autor: Jesus Sanchez Allende, Gabriel Huecas
Fernandez-Toribio, Pilar Moreno Diaz.Editorial: McGraw-Hill España. Publicacion:
2005.Temas: Java2(lenguaje de programacion) Java(Computer program languaje).
2. Programación orientada a objetos usando java. Autor: Flórez Fernández, Héctor

Arturo.Editorial: Ecoe Ediciones. Fecha de publicación original: 2012. Temas: Programación
orientada a objetos (Computación) Java (Lenguaje de programación de
computadores) Object-oriented programming (Computer science) Java (Computer
program language).

Texto de Programacion Visual II

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Texto de Programacion Visual II

Cargado por

Copyright:

Formatos disponibles

Texto para el curso de

VISUAL JAVA CON BASE

Ing. Martín Salcedo

CAPITULO I: Otros objetos del paquete swing 03

Ing. Martín Salcedo Quiñones Página 2

Ing. Martín Salcedo Quiñones Página 3

LOS OBJETOS JTEXTAREA Y JTOOLBAR

JTextArea es un componente que crea un área de texto; este componente

Ing. Martín Salcedo Quiñones Página 4

La segunda es que un JTextArea no tiene barras de scroll, así que si escribimos

JScrollPane scroll = new JScrollPane();

// Para que haga el salto de línea en cualquier parte de la palabra:

public class VentanaEjemplo1{

public static void main(String[] args) {

JFrame ventana = new JFrame("Mi Ventana");

Ing. Martín Salcedo Quiñones Página 5

JTextArea jtx = new JTextArea(10,50);

JScrollPane scroll = new JScrollPane(jtx);

ventana.pack();//método utilizado para que se muestren los //elementos de la ventana

Una vez ejecutado esta programación, se visualiza lo siguiente (en ejecución

La quinta cosa importante que debemos mencionar es que podemos modificar es

Font font = new Font("Verdana", Font.ITALIC, 12);

Cuando creamos el tipo de fuente primero debemos entregar el nombre de la

Y finalmente el tamaño de la letra. Para cambiar el color de la letra debemos utilizar

Para cambiar el color de fondo de nuestro JTextArea debemos utilizar el método:

public class JTextAreaTest{

public static void main (String [] args) {

//Método para cambiar la decoración de la ventana en sí,

Ing. Martín Salcedo Quiñones Página 7

//creamos el JFrame principal donde agregaremos el resto de objetos

JFrame frame = new JFrame ("JTextArea Test");

frame.setLayout (new FlowLayout ());

+ "Se puede cambiar el número de líneas que se mostrarán, "

+ "y también el numero de columnas. Puedes cambiar las fuentes y tamaños de

//creamos un area de texto normal no redimensionable

JTextArea textAreal = new JTextArea(text,20,10);

textAreal.setPreferredSize(new Dimension (10,100));

//creamos otra área de texto con un JScrollPane, sólo es agregado

JTextArea textArea2 = new JTextArea(text,20,10);

JScrollPane scroll = new JScrollPane(textArea2);

//si lo desactivamos(false), el texto se escribirá hacia el lado(en una línea) y no se

//agregamos los area de texto al frame principal,

//y finalmente el metodo setVisible es para que se visualice la ventana

Una vez ejecutado la programación se visualiza:

Ing. Martín Salcedo Quiñones Página 9

Esta clase implementa una barra de herramientas, formada normalmente por

public class EjemploJToolbar {

public static void main(String[] args){

//cargando toolbar panel con sus componentes

Ing. Martín Salcedo Quiñones Página 10

// cargando la ventana con el toolbar

Una vez ejecutado el programa se muestra lo siguiente:

También se puede considerar utilizar las siguientes opciones para JToolbar:

barra.addSeparator(); //añade un separador

barra.setFloatable(false); //impide que se pueda mover de su sitio

barra.setOrientation(JToolBar.VERTICAL); //pone la orientación vertical

Ing. Martín Salcedo Quiñones Página 11

OBJETOS JSLIDER Y JPROGRESSBAR

Se utiliza un JSlider para permitir que el usuario introduzca un valor numérico

Ing. Martín Salcedo Quiñones Página 12

Crearemos rápidamente un JFrame, un Jpanel para poder pegar y visualizar

JFrame ventana = new JFrame("COme On!!");

Explicaremos un poco más detallado el constructor presente y cada método (el

Ing. Martín Salcedo Quiñones Página 13