CURSO DE JAVA

Desde cero hasta conexiones con

bases de datos MySQL

Este curso de Java trata de ser una gua paso a paso, desde cero, para
crear una aplicacin de escritorio que se conecte al servidor de MySQL;
est dirigido a quienes dominan los fundamentos de programacin en
algn otro lenguaje, que adems tienen los rudimentos de las consultas
a las bases de datos relacionales. A lo largo del curso se usan diversas
libreras de la Java Estandar Edition tales como java.lang, java.awt,
javax.swing y java.sql de las que se estudian, ejemplifican y aplican las
clases esenciales.

La estructura del texto sigue el modelo de enseanza de los tres

primeros mdulos de Java impartidos por el Ing. Jorge Snchez
Barrueta, profesor de 3CT.
Julio Csar Lpez Dvila pertenece a la plantilla de profesores de Java
SE y EE en 3CT; adems, imparte all mismo los cursos de
Fundamentos de programacin y XHTML, de los servidores de bases
de datos MySQL y SQL Server, as como de los lenguajes de
programacin PHP y .NET.

Presentacin

Qu y para qu es Java?

Al hablar de Java, nos estamos refiriendo a tres cosas asociadas con la programacin de
software: un lenguaje, una plataforma y un fenmeno. La eficacia y la flexibilidad del
lenguaje permitieron crear una plataforma tan extensa que tiene alcance lo mismo para
aplicaciones de propsito general en computadoras personales, para el funcionamiento
de dispositivos mviles y aparatos electrnicos, y hasta para sitios web; este alcance ha
creado un verdadero fenmeno tecnolgico; tanto, que hoy por hoy hay ms de 4 500
millones de equipos que tienen instalado Java. Entonces, en estricto sentido, esta
tecnologa sirve para hacer aplicaciones, virtualmente, para cualquier componente que
tenga un procesador de software.
La plataforma para el desarrollo de Java est dividida en tres ediciones: la estndar
(JSE), la empresarial (JEE) y la de dispositivos mviles (JME). La primera contiene,
entre muchas otras cosas, los elementos del lenguaje, los objetos para las interfaces
grficas y los mecanismos de conexin a base de datos, que son lo primero que debe

de este modelo de diseo de software o a que se asuma su conocimiento. Sin embargo,

hay una ambigedad en la iniciacin en Java porque sus aplicaciones deben orientarse a
objetos pero para explicar lo esencial no es necesario. De tal manera que se pueden
crear programas sencillos sin seguir ningn patrn, pero esto impide la compresin de la
parte no trivial del lenguaje. Por eso, en este curso, presentaremos una introduccin a la
POO y los programas de la aplicacin de ejemplo se apegarn a ella, incluso los de la
introduccin a los elementos, aunque, para facilitar el aprendizaje, a menudo haremos
demostraciones sencillas sin orientacin alguna.
Ahora bien, es del conocimiento general que la curva de aprendizaje de Java es ardua.
Esto se debe principalmente a que los desarrolladores no trabajan con el lenguaje en s
sino con la plataforma. En el momento que iniciamos una aplicacin debemos usar
algunos objetos preexistentes que son parte de la edicin estndar y que realizan las
labores comunes; adems, es necesario elegir de entre varios cientos de otros objetos
aqullos que son tiles para alcanzar las metas del sistema. As que en la edicin
estndar hay un amplio nmero de libreras que contienen una multitud de objetos que
se deben conocer suficientemente para comenzar a programar.
As que hay que aprender mucho antes de lograr una aplicacin robusta; la tarea puede
ser agotara y confusa, y los resultados, muy pobres. Ante esto, la metodologa de este

Primera parte. Iniciacin al

lenguaje Java

Instalacin

Java funciona mediante un software conocido como la mquina virtual (JVM por sus
siglas en ingls), que es el corazn del entorno de ejecucin y que debe estar instalado
en el sistema operativo para que las aplicaciones Java se ejecuten. En Windows est en
una ruta semejante a esta:
C:\Program Files\Java\jre[versin]
En la que la versin es una sucesin de nmeros como 1.4.5.6 , 1.6.0_07, etc.
Para que los programas puedan ejecutarse hay que asegurarse que el JRE (java run
enviroment) est instalado (que es lo ms probable); si no, se descarga de
www.java.com que es un sitio dedicado exclusivamente a la disponibilidad de la
mquina virtual de Java.
Para programar es necesario el kit de desarrollo (JDK) que sirve para crear y probar las
aplicaciones y que ya incluye el JRE. En el momento de la escritura de este curso la
URL de descarga es:

Hay otras descargas que tienen JFX, JEE o NetBeans pero son ms grandes y los
complementos que ofrecen no son necesarios para los objetivos de este curso, aunque
cualquiera de ellas sirve igual.
Una vez instalado el JDK estar en un subdirectorio semejante a este al que se le conoce
como [JAVA-HOME]:
C:\Program Files\Java\jdk[versin]
En cuanto al desarrollo de aplicaciones, aunque es posible trabajar los archivos de Java
con cualquier editor de texto plano, aqu lo haremos con la versin LE de JCreator cuya
pgina de descarga es:
http://www.jcreator.com/download.htm
JCreator no debe instalarse antes del JDK porque no funcionar.
Para probar que todo est como se espera debemos ejecutar JCreator y crear un archivo
nuevo vaco:

Oprimimos <Next> y en el Name escribimos HolaMundo, as, todo junto y respetando

las maysculas. Adems, elegimos el subdirectorio donde se debe guardar el archivo y
oprimimos <Finish>:

En seguida, copiamos y pegamos el siguiente programa:

public class HolaMundo{
public static void main(String[] args){
System.out.println("Hola mundo");
}
}

Obsrvese que el nombre de la clase y el del archivo son el mismo. Ejecutamos y

compilamos con los botones que indica la figura siguiente y debe aparecer el mensaje
Hola mundo en la ventana General Output:

Si no se obtiene este resultado, es intil seguir adelante. Los errores los marcar
JCreator y pueden deberse a que no est instalado el JDK o a que el programa se
escribi

a mano

y tiene errores.

El compilador crea un archivo

llamado

HolaMundo.class que es el que contiene el programa y el que la mquina virtual puede

interpretar.

Definicin breve de la Programacin Orientada a Objetos (POO)

Antes de establecer los elementos del lenguaje, es necesario tener presentes los
conceptos bsicos de la programacin orientada a objetos porque la sintaxis y el formato
de Java estn plenamente apegados a ellos.

Para empezar, todo parte del hecho de que el desarrollo de la programacin de

computadoras entr en crisis en los aos 60 y 70 del s. XX porque las aplicaciones a
menudo hacan cosas raras. Un caso es el del Centro de Cmputo Noruego en Oslo en el
que desarrollaban simuladores de vuelo; suceda, cuando los ejecutaban, que las naves
colisionaban. Un anlisis del problema prob que la aplicacin confunda las
caractersticas entre uno y otro objeto simulado; es decir, que la cantidad de
combustible, la posicin en el espacio o la velocidad de una nave eran atribuidas a otra.
Se concluy que esto se deba al modo como programaban y que los lenguajes de
entonces eran incapaces de resolver el problema. Ante esto, los expertos del Centro
Noruego desarrollaron Simula 67 que fue el primer lenguaje orientado a objetos.

As que la POO es una manera de disear y desarrollar software que trata de imitar la

Se debe tener presente que los objetos, sean reales o su proyeccin en software, se
abstraen en clases. Por ejemplo: de la clase perro pueden existir dos objetos Fido y
Firulis (esta es su identidad). Fido es un san bernardo enorme, pinto, de 5 aos de
edad; mientras que Firulis es un labrador, negro, de 3 aos (este es su estado). Ambos
perros ladran, merodean, juguetean, comen y duermen (este es su comportamiento).

Si nos pidieran que hiciramos un programa orientado a objetos que simulara lo anterior
haramos la clase Perro que tendra las variables raza, color y edad, y los mtodos
ladrar(), merodear(), juguetear(), comer() y dormir(). Firulis y Fido son los
identificadores que podramos usar en una aplicacin que pretenda mostrar dos objetos
de la clase Perro.

El programa Hola Mundo y los conceptos de abstraccin y

encapsulamiento

Otros conceptos de la POO son el de abstraccin y el de encapsulamiento, que estn

muy ligados y tienen que ver con el diseo de programas. Ambos se refieren a que los
objetos deben hacer tareas que les son propias y no de otros. Por lo comn, los objetos
de la realidad no dan problemas porque ya existen. No fue difcil abstraer la clase Perro

Entonces, abstrayendo esto, podemos decir que el comportamiento de los objetos del
tipo Hola Mundo es mostrar un mensaje y su caracterstica, el mensaje mismo.

Lo que sigue es mostrar cmo los elementos de lenguaje Java nos permiten apegarnos a
la orientacin a objetos; para eso es necesario conocer dichos elementos, pero antes,
para finalizar, un breve resumen.

Hemos introducido cinco conceptos de la POO:

1. La identidad, que es el nombre que distingue a los objetos

2. El estado, que se refiere a sus caractersticas o atributos

3. El comportamiento, que indica los mtodos que se deben programar para que
los objetos realicen acciones

4. La abstraccin, que es el mecanismo mental para aislar su naturaleza

5. El encapsulamiento, que exige que sus caractersticas y mtodos estn bien

definidos y no se confundan con los de otros

/*Aunque el compilador importa la librera java.lang completa

*es conveniente importarla explcitamente por razones didcticas*/
import java.lang.*;
public class HolaMundoOO{
String saludo; //La clase Sring la importamos de java.lang
public void mostrarSaludo(){
saludo=Hola mundo;
System.out.println(saludo);//La clase System la importamos de java.lang
}
}

Y est conformado por los siguientes elementos:

Identificadores

Sentencias

Bloques de cdigo

Comentarios

Expresiones

Operadores

Metacaracteres
Explicaremos cul es el uso de cada uno de ellos y, despus, como funcionan en el
Palabras reservadas
HolaMundo.java.

Identificadores

Son los nombres que pueden tener las clases, los mtodos y las variables y no pueden
contener espacios ni caracteres especiales. Estos nombres deben respetar ciertas
convenciones segn la siguiente tabla:
Tipodeidentificador
Convencin

Ejemplo

Clase

Comienzaconmayscula

HolaMundoOO

Mtodo

Comienzaconminscula

mostrarSaludo()

Variable

Comienzaconminscula

saludo

Si el identificador est formado por ms de un vocablo, a partir del segundo las iniciales
deben ser maysculas. Adems, se recomienda que los nombres de las clases sean
sustantivos, los de los mtodos verbos y que las variables expresen con claridad su
contenido.

Sentencias

Son las rdenes que se deben ejecutar en el programa y terminan siempre con un punto
y coma:

Bloques de cdigo

Son el principal mecanismo de encapsulamiento y se forman con un grupo de sentencias

y de otros bloques de cdigo delimitados por una llave de apertura y una de cierre
(considerados metacaracteres en java, como veremos ms adelante):

{}

Por ejemplo:

{
saludo=Hola mundo;
System.out.println(saludo);//La clase System la importamos de java.lang
}
Tipo

Caracteresque
losidentifican

Ejemplo

Deuna
solalnea

//

//LaclaseSringlaimportamosdejava.lang

Devarias
/**/
Comentarios
lneas

/*Aunqueelcompiladorimportalalibrerajava.lang
completaesconvenienteimportarlaexplcitamentepor
razonesdidcticas*/

Son lneas de texto insertas en el programa para documentarlo y facilitar su lectura. Los
tipos de comentarios ms usados son:

Expresiones

Las expresiones son entidades formadas por dos o ms miembros separados entre s por
operadores que los evalan y los relacionan.

Por ejemplo;

saludo=Hola Mundo;

Operadores

Los operadores son signos especiales para hacer acciones especficas y son el
mecanismo con el cual los objetos interactan relacionando los datos y devolviendo
nuevos valores; los mostraremos conforme los necesitemos. Se clasifican as:

Aritmticos

De comparacin y lgicos

De asignacin

Tipos de datos
Metacaracteres

Sentencias condicionales

Sentencias iterativas

Tratamiento de las excepciones

Estructura de datos

A continuacin, una imagen que esquematiza los elementos en la clase HolaMundoOO

Modificadores y control de acceso

(Obsrvese que la lnea saludo= Hola mundo; es, adems, una expresin porque
utiliza el operador de igual (=))

La imagen anterior muestra que, a pesar de la sencillez del programa, son muchos los
elementos que estn involucrados. Las reglas de organizacin de dichos elementos
conforman la sintaxis cuya comprensin nos obligar a desmenuzar el programa

Sintaxis

Para comprender mejor la sintaxis del programa debemos pensar en trminos de mbito
o alcance. Primero hay que saber que los comentarios estn fuera del programa, no
estn dentro de su mbito, el compilador no los interpreta, son seales que el
programador usa para facilitar la comprensin del cdigo.
El mbito ms externo es donde importamos los recursos que se requerirn para el
programa y donde declaramos el programa mismo. Aqu est el principio de todo. En
Java siempre desarrollaremos clases, y siempre usaremos clases ya hechas que
importaremos. Los recursos mnimos para programar estn en el paquete lang de la
librera java que el compilador importa por omisin, aunque aqu (ya lo decamos en un
comentario de la clase HolaMundoOO) lo haremos explcitamente por razones
didcticas.
As que al comenzar a desarrollar un programa debemos primero determinar las clases
externas necesarias para ayudar a la clase que crearemos nosotros, y despus crear sta.
Para la primera labor usamos la palabra reservada import y todas las clases invocadas
as podrn ser utilizadas en cualquier lugar del bloque de cdigo de la clase; para la
segunda, empleamos las palabras reservadas

public class seguidas del nombre que

deseemos asignarle; debe ser nico, preferentemente un sustantivo, iniciar con

El rectngulo representa el mbito o alcance. Los objetos del paquete lang estn
disponibles en todos lados.
Dentro del bloque de la clase est el lugar donde deben crearse las propiedades o
atributos y declararse los mtodos. Las propiedades deben escribirse primero, fuera de
cualquier mtodo y su alcance ser toda la clase, que es lo que significa el rectngulo
interno en la siguiente figura.

Aqu hace falta hablar de la sintaxis de la creacin e inicializacin de las variables. En

Java, toda variable se crea estableciendo su tipo seguido de un nombre, que deber ser
nico en el mbito donde se le declara; se inicializan siempre con una expresin. Crear
significa asignarles un espacio en memoria, mientas que inicializar es darles un valor:
String saludo; Crea una variable llamada saludo.
saludo= Hola mundo; La inicializa
Cuando las variables son atributos deben crearse nicamente y debe hacerse fuera de los

String muestra= Esto es una muestra;

Los mtodos, por su parte, se declaran estableciendo primero el nivel de acceso. En este
caso mostrarSaludo() tiene acceso pblico (para eso usamos la palabra reservada
public), que significa que cualquier objeto externo puede invocar la tarea encapsulada
en el mtodo. Hay otras posibilidades, por ejemplo prvate, que es tambin una palabra
reservada, y que significa que el mtodo slo puede ser usado al interior de la clase en
la que es declarado. Despus del nivel de acceso, est el tipo de datos que el mtodo
devuelve; mostrarSaludo() no regresa ningn valor; para indicar esto se usa otra palabra
reservada: void, que, como veremos despus, podr ser sustituida por cualquier tipo de
datos. Todos los mtodos deben tener su propio bloque de cdigo, en el que, como ya
dijimos, est encapsulada su tarea. El mtodo en cuestin inicializa saludo, e invoca la
clase System (que importamos del paquete lang al principio) cuyo atributo out es un
objeto que tiene el mtodo println(cadena) cuya tarea es imprimir una lnea con el texto
que recibe como

parmetro

en

la salida estndar del sistema.

El mtodo

mostrarSaludo() y su alcance estn representados en el rectngulo ms interno de la

En cuanto a la sintaxis, falta decir que otra de las responsabilidades de cualquier clase
siguiente figura.
es autoconstruirse por lo que tendr un mtodo que se llamar igual que la clase misma,
deber ser pblico, no tiene modificador del tipo que devuelve y lo llamamos el
constructor, con lo anterior la clase queda como sigue (obsrvese que en este mtodo

import java.lang.*;
public class HolaMundoOO{
String saludo; //La clase Sring la importamos de java.lang
//Creamos el mtodo constructor con el mismo nombre de la clase
public HolaMundoOO(){
saludo="Hola mundo";//En el constructor se inicializan las propiedades
}
public void mostrarSaludo(){
System.out.println(saludo);//La clase System la importamos de java.lang
}
}

Finalmente, otro mecanismo de encapsulamiento es crear paquetes para guardar en ellos

las clases que hacen labores afines. Esto se logra con la palabra reservada package
seguida del nombre que identificar al paquete; stos se escriben slo con minsculas.
La versin final de la clase HolaMundoOO que queda encapsulada en el paquete
holamundo, que importa de java.lang las clases String y System, que tiene el atributo
saludo de tipo String, que se autoconstruye e inicializa la propiedad, que tiene un
mtodo que muestra saludo usando la clase System queda as (Atindanse los
comentarios):
package holamundo;//Los paquetes son subdirectorios
import java.lang.String;
import java.lang.System;
public class HolaMundoOO{
String saludo;

Si aplicamos al programa anterior los mismos pasos del apartado de instalacin para
probar JCreator, excepto el de ejecucin; es decir, crear un nuevo documento vaco con
el mismo nombre de la clase, copiar el cdigo anterior y oprimir el botn de
compilacin debemos obtener algo parecido a esto:

El efecto de compilar es que se crea un archivo .java y el paquete es un subdirectorio:

Dentro del paquete queda el archivo .class, que es el que la mquina virtual puede
interpretar:

Ejecucin y flujo de datos

Ejecucin

Falta decir que en toda aplicacin Java debe haber una clase que tenga un mtodo main
que es el primero que se ejecuta. La clase que hemos creado no lo tiene porque no es su
responsabilidad, si nos apegamos al proceso de abstraccin segn el cual la diseamos.
Para eso haremos otra clase llamada EjecutorHolaMundoOO cuya responsabilidad ser
correr el programa y que tendr como propiedad un objeto de la clase HolaMundoOO.
Esto nos servir como prctica de sintaxis y para analizar el flujo de datos en Java.
Hagmoslo por pasos, mbito por mbito:

1. Empaquetamos en util, importamos HolaMundoOO y declaramos la clase:

package util;
import holamundo.HolaMundoOO;
public class EjecutorHolaMundoOO {

3. Aadimos los mtodos:

3.1 Agregamos el constructor en el que inicializamos la propiedad hola e
invocamos el mtodo mostrarSaludo() de dicho objeto, utilizando el punto(.),
que es el metacaracter que nos permite invocar los atributos y los mtodos de los
objetos:
package util;
import holamundo.HolaMundoOO;
public class EjecutorHolaMundoOO {
HolaMundoOO hola;
public EjecutorHolaMundoOO(){
hola=new HolaMundoOO();
hola.mostrarSaludo();
}
}

3.2 Agregamos el mtodo main. Ni la palabra reservada static ni lo escrito en

los parntesis del mtodo debe inquietarnos. Por el momento, basta con saber
que la sintaxis es rigurosa. El mtodo que ejecuta la aplicacin debe escribirse
as, lo nico que cambia es el contenido del bloque de cdigo:
package util;
import holamundo.HolaMundoOO;
public class EjecutorHolaMundoOO {
HolaMundoOO hola;

En JCreator, en un archivo vaco llamado igual que la clase (EjecutorHolaMundoOO) y

que debe estar en el mismo subdirectorio que el HolaMundoOO.java, escribimos el
cdigo; Compilamos y ejecutamos el programa, con lo que debemos obtener el
siguiente resultado:

La estructura de directorios debe presentar los archivos .java y los dos subdirectorios de
los paquetes dentro de los cuales debe estar cada uno de los archivos .class:

Flujo de datos

Lo que sigue es explicar cmo funciona lo anterior. Cuando oprimimos el botn

ejecutar, el compilador de Java busca el mtodo main, si no lo encuentra, mostrar un
error. En nuestro caso, esta es la sucesin de pasos:

1. Comienza a recorrer el bloque de cdigo del mtodo main que contiene un

objeto de la clase EjecutorHolaMundoOO que llamamos ejecutor y que
inicializamos usando la palabra reservada new y el mtodo constructor de dicha
clase.

2. Esto inicializa el objeto hola con el constructor de la clase HolaMundoOO,

Tipos de datos

Generalidades

En Java, las variables podrn ser de dos tipos: objetos y tipos primitivos. Hay
diferencias entre unos y otros. En realidad las primeras clases que conforman la
plataforma estn hechas slo de tipos primitivos. Estos se obtienen con las palabras
reservadas: byte, short, int, long, float, double, char y bolean. En este curso usaremos
solamente int para enteros, double para nmeros con punto decimal, y bolean para los
valores lgicos. Por su parte, los objetos siempre son tomados de una clase que lo
mismo puede estar en alguna librera del JDK o en algn archivo creado por nosotros.
Siempre que se necesite una variable debe ser declarada especificando su tipo seguido

cadena= palabras Le asigna un valor

Ya antes dijimos que ambas tareas se pueden hacer en la misma lnea:
int valor=12
La diferencia central entre los tipos primitivos y los objetos es que stos disponen de los
atributos y los mtodos que les confieren las clases a las que pertenecen; como tambin
ya dijimos, para acceder a ellos se usa el metacaracter (.):
cadena.length()
Aqu debemos hablar de las Java Fundation Classes (JFC) y de su Application
Programming Interface (API); es decir, de las clases base de Java y su interfaz de
programacin de aplicaciones. La descripcin de los mtodos, de los atributos y de las
propias clases base con las que programaremos estn en la API, que est publicada en:
http://java.sun.com/javase/api/
Las JFC en s estn en el JDK y por eso lo descargamos e instalamos. Hemos usado dos
de ellas: String y System; slo hemos invocado la propiedad out de sta; no obstante,
cada una tiene muchos mtodos y muchas propiedades que estn descritas en la API; de
cuyo conocimiento dependen las alternativas de programacin de las que disponemos.
Cada mtodo o propiedad mencionados aqu sern explicados sencillamente. La
profundizacin en todas las posibilidades de cada clase es responsabilidad del

Los tipos de datos y los mtodos

Ya dijimos que los mtodos pueden devolver cualquier tipo de datos; falta agregar que
Sintaxis
Devuelvevalo
Recibeparmetro
tambin pueden recibir
parmetros. Esto hace
que existan cuatro
tipos de mtodos:
r
s
voidtarea()

No

No

Tipotarea()

No

voidtarea(Tipoparametro)

No

Tipometodo(Tipoparametro)

El primero de ellos lo usamos en la clase HolaMundoOO y es muestraSaludo(). Veamos

un demo para cada una de los otros casos.

Caso de mtodo que s devuelve un tipo y no recibe parmetros

Estdiese el siguiente programa:

DemoMetodoSiTipoNoParametros.java

public class DemoMetodoSiTipoNoParametros {

String saludo;
public DemoMetodoSiTipoNoParametros() {
/*En la expresin siguiente el atributo

muestraSaludo();
}
//Obsrvese que el mtodo devuelve un objeto de la clase String
public String devuelveHolaMundo(){
String hola="Hola mundo";
/*return es obligatorio si el mtodo devuelve
*un valor. El modificador de return debe ser del mismo
*tipo que el valor devuelto
*/
return hola;
}
public void muestraSaludo(){
System.out.println(saludo);
}
public static void main(String[] args) {
new DemoMetodoSiTipoNoParametros();
}
}

En este cdigo, la propiedad saludo es inicializada no con una cadena sino con el valor
que regresa el mtodo devuelveHolaMundo() cuyo tipo es String. En dicho mtodo
hemos creado otra variable del mismo tipo, y la hemos inicializado con la cadena Hola
mundo. La palabra reservada return sirve para indicar cul es el valor que devolvern
los mtodos.

public class DemoMetodoNoTipoSiParametros {

String saludo;
public DemoMetodoNoTipoSiParametros() {
saludo="Hola mundo";
//Se enva la variable 'saludo' para que el mtodo la use como parmetro
muestraSaludo(saludo);
}
/*El contenido de 'saludo' es escrito en la variable
'recibido' del parmetro del mtodo muestraSaludo()*/
public void muestraSaludo(String recibido){
System.out.println(recibido);
}
public static void main(String[] args) {
new DemoMetodoNoTipoSiParametros();
}
}

Caso de mtodo que s devuelve un tipo y s recibe parmetros

Es fcil deducir de los ejemplos anteriores el ltimo caso. No obstante, falta decir que
mientras que los mtodos pueden devolver slo un tipo, el nmero de parmetros puede
ser mltiple. Vase el ejemplo que calcula el rea de un tringulo con la base y la altura
como argumentos:

DemoMetodoSiTipoSiParametros.java

double area =(base*altura)/2;

return area;
}
public static void main(String[] args) {
new DemoMetodoSiTipoSiParametros();
}
}

Falta decir solamente que los parmetros no deben ser necesariamente del mismo tipo y
que cuando son ms de uno se usa el metacaracter coma (,).
Un comentario final sobre la API. Cuando buscamos los atributos y los mtodos de una
clase, en la URL en cuestin se mostrar el tipo (aun si es void); y en el caso particular
de los mtodos se indicarn, tambin, los parmetros con su tipo. A partir de ahora,
siempre que citemos una clase nueva de las JFC, ser con un enlace a la API.

Estructuras de control

Introduccin

Para terminar la seccin de iniciacin al lenguaje es necesario explicar cmo se controla

usuario, respectivamente; para ver cmo operan haremos una clase que ser otra
variante de nuestro tan trado HolaMundo, que primero pedir el nombre del usuario y
luego lo saludar.
Antes de seguir, hagamos un poco de abstraccin. Obsrvese que lo que queremos hacer
es una demostracin de cmo la clase JOptionPane sirve como mecanismo de entrada y
salida de datos, por eso la llamaremos DemoIOJOptionPane (IO de Input/Ouput); sus
responsabilidades sern pedirle su nombre al usuario, y saludarlo en pantalla; dicho
nombre ser una propiedad. Cabe aclarar que como el sentido de la clase ser dar una
demostracin, el mtodo main s entra dentro de sus capacidades.
DemoIOJOptionPane.java
package cursojava.demos; //La encapsulamos en un lugar para todos los demos
import javax.swing.JOptionPane; //Importamos la clase JOptionPane
public class DemoIOJOptionPane {
String nombre; //Este ser la informacin para el I/O
public DemoIOJOptionPane() {
//El constructor llama a sus mtodos
pideNombre();
muestraSaludo();
}
/*La palabra reservada null del primer atributo en los dos mtodos
*de JOptionPane es porque, por lo comn, esta clase es llamada desde una ventana
* que es su propietario como no tenemos tal ventana, lo indicamos as.
* El segundo parmetro es el mensaje que aparecer en el cuadro de dilogo.
*/
private void pideNombre(){

Al ejecutar el programa, aparece un cuadro de dilogo con el mensaje que le mandamos

como segundo parmetro al mtodo showInputDialog():

Dentro del cuadro de texto se debe escribir un nombre y oprimir el botn <aceptar>:

Luego de lo cual aparecer otro cuadro de dilogo con la cadena Hola concatenada
(usando el operador +) con el nombre escrito por el usuario; el valor obtenido de esta
concatenacin es lo

que mandamos

como segundo

parmetro

del

mtodo

showMessageDialog():

Con esto podemos empezar a trabajar con el flujo de datos. Si se ejecuta el programa y
en el primer cuadro de dilogo se oprime <cancelar> en lugar de <aceptar>, la cadena
que mostrar despus ser Hola null, que no es el resultado esperado, si se quisiera
controlar esto, se tendra que controlar el flujo. Existen varias posibilidades para esto y
las veremos en seguida.

El bloque ifelse

Analice y ejecute el siguiente programa (que es una variante del anterior) oprimiendo el
botn cancelar:

package cursojava.demos; //La encapsulamos en un lugar para todos los demos

import javax.swing.JOptionPane; //Importamos la clase JOptionPane
public class DemoIfElse {
String nombre; //Este ser la informacin para el I/O
public DemoIfElse () {
//El constructor llama a sus mtodos
pideNombre();
muestraSaludo(); {//Obsrvese que el operador de comparacin es == (doble igual)
if(nombre==null)
JOptionPane.showMessageDialog(null,"Oprimiste cancelar");//Mensaje por la cancelacin

}else
{
private void pideNombre(){
nombre=JOptionPane.showInputDialog(null,"Escribe
tu nombre");//Pide
el nombre
JOptionPane.showMessageDialog(null,"Hola "+nombre);//Saluda
en pantalla
}

private//Fin
voiddemuestraSaludo(){
la estructura
}

//Inicio de la estructura de control ifelse

public static void main(String[] args) {
new DemoIfElse ();
}

En este caso, si el usuario decide no escribir el nombre y cancelar, el programa lo

muestra.

if.. else anidado

Aunque hemos avanzado, el programa sigue teniendo problemas. Si el usuario no

escribe el nombre pero oprime el botn aceptar, la cadena mostrada ser Hola
solamente; si queremos que aparezca otro mensaje para este caso, hay ms de una
solucin; una de ellas es anidar un ifelse dentro del que ya hicimos:

DemoIfElseAnidado.java

package cursojava.demos; //La encapsulamos en un lugar para todos los demos

import javax.swing.JOptionPane; //Importamos la clase JOptionPane
public class DemoIfElseAnidado{
String nombre; //Este ser la informacin para el I/O
public DemoIfElseAnidado() {
//El constructor llama a sus mtodos
pideNombre();
muestraSaludo();
}
/*La palabra reservada null del primer atributo en los dos mtodos

JOptionPane.showMessageDialog(null,"Oprimiste aceptar sin escribir tu nombre");

}else{

JOptionPane.showMessageDialog(null,"Hola "+nombre);//Saluda en pantalla

}
}
}
public static void main(String[] args) {
new DemoIfElseAnidado();
}
}

En este caso, el programa podr enviar tres respuestas distintas:

1. Mandar el saludo

2. Indicar que se oprimi cancelar

3. Indicar que no se escribi el nombre

Operadores lgicos

Operad
or

Significado

Estruecuando:

Esfalsecuando:

Negacin.Cambiaelvalor
deverdaddelobjetoque
modifica

Elobjetoquemodificaes
falso

Elobjetoquemodificaes
verdadero

==

Comparasilosmiembros
queestnaambosladosson
iguales

Ambosobjetossoniguales

Losobjetossondistintos

!=

Comparasilosmiembros
queestnaambosladosson
distintos

Losobjetossondistintos

Ambosobjetosson
iguales

>

Comparasielobjetodela
izquierdaesmayorqueel
deladerecha

Sielobjetodelaizquierdaes
mayorqueeldeladerecha

Sielobjetodela
izquierdanoesmayor
queeldeladerecha

<

Comparasielobjetodela
izquierdaesmenorqueelde
laderecha

Sielobjetodelaizquierdaes
menorqueeldeladerecha

Sielobjetodela
izquierdanoesmenor
queeldeladerecha

>=

Comparasielobjetodela
izquierdaesmayoroigual
queeldeladerecha

Sielobjetodelaizquierdaes
mayoroigualqueeldela
derecha

Sielobjetodela
izquierdanoesmayorni
igualqueeldeladerecha

<=

Comparasielobjetodela
izquierdaesmenoroigual
queeldeladerecha

Sielobjetodelaizquierdaes
menoroigualqueeldela
derecha

Sielobjetodela
izquierdanoesmenorni
igualqueeldeladerecha

Junto con estos, existen otros que sirven para hacer operaciones entre objetos bolanos.
Los ms importantes se presentan a continuacin

AND

Operado
Resultad
El operador ANDOperando
se representa
en JavaOperando
con un doble
ampersand (&&) y su
1
r
2
o
True con la&&
True
funcionamiento es de acuerdo
siguiente tabla:

True

False

&&

True

False

True

&&

False

False

False

&&

False

False

OR

El operador OR se representa en Java con un doble pipe (||. Este caracter normalmente
est en la misma tecla del nmero 1. Es esa lnea vertical cortada en el centro. Su cdigo
Operando Operado Operando
Resultad
1
r
2
o
ASCII es 124); funciona de acuerdo con la siguiente tabla:
True

||

True

True

False

||

True

True

True

||

False

True

False

||

False

False

Con lo anterior podemos hacer una nueva versin del programa en el que, en lugar de
anidar las estructuras de control, usaremos el operador OR (||):

DemoIfElseOr.java
package cursojava.demos; //La encapsulamos en un lugar para todos los demos
import javax.swing.JOptionPane; //Importamos la clase JOptionPane
public class DemoIfElseOr{
String nombre;
public DemoIfElseOr() {
pideNombre();
muestraSaludo();
}
private void pideNombre(){
nombre=JOptionPane.showInputDialog(null,"Escribe tu nombre");//Pide el nombre
}
private void muestraSaludo(){
if(nombre==null || nombre.equals("")){//Uso del operador OR

}
public static void main(String[] args) {
new DemoIfElseOr();
}
}

La estructura de control while

Si suponemos que en el programa anterior el usuario debe escribir su nombre, podemos

hacer que el flujo de datos repita la operacin de solicitarlo mientras el usuario no
proporcione la informacin. Para eso usamos while:

DemoWhile.java

package cursojava.demos; //La encapsulamos en un lugar para todos los demos

import javax.swing.JOptionPane; //Importamos la clase JOptionPane
public class DemoWhile{
String nombre;
public DemoWhile() {
pideNombre();
muestraSaludo();
}
private void pideNombre(){
nombre=JOptionPane.showInputDialog(null,"Escribe tu nombre");//Pide el nombre
}
private void muestraSaludo(){

El programa anterior mostrar reiterativamente el cuadro de dilogo que solicita el

nombre, mientras el usuario no escriba una cadena.

La estructura de control trycatch

El bloque trycatch es un poco ms complejo que el for y el switch, que veremos

despus, pero el uso combinado con try catch facilita su comprensin por lo que
veremos primero ste.

La estructura de control en cuestin se usa para capturar el flujo de datos cuando, por la
intervencin del usuario o de algn dispositivo externo, sucede un error. Por ejemplo,
supongamos una aplicacin de frmulas matemticas en la que el usuario debe ingresar
valores numricos, lo que normalmente sucede es que el sistema recibir cadenas que
debern ser convertidas a un tipo til para las operaciones; pero si el usuario ingresa
algo distinto a un dgito o a un operador, el programa fallar. Veamos un ejemplo:

DemoErrorNumero.java

import javax.swing.JOptionPane;
public class DemoErrorNumero {
String mensaje;
public DemoErrorNumero() {
String valorCadena=JOptionPane.showInputDialog(null,"Escribe un entero");

Al ejecutar este programa, si en el primer cuadro de dilogo escribimos un entero,

aparecer un segundo cuadro de dilogo indicando el valor; si, por el contrario,
escribimos otra cosa, el programa se detiene y en la ventana de General Output de
JCreator se mostrar el siguiente mensaje:
--------------------Configuration: <Default>-------------------Exception in thread "main" java.lang.NumberFormatException: For input string: "Juanito"
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)
at java.lang.Integer.parseInt(Integer.java:447)
at java.lang.Integer.parseInt(Integer.java:497)
at DemoErrorNumero.<init>(DemoErrorNumero.java:6)
at DemoErrorNumero.main(DemoErrorNumero.java:10)

La lnea que esta subrayada indica cul fue el error: la cadena Juanito (que fue lo que
recibi la variable valorCadena) tiene un formato numrico incorrecto; java.lang es la
librera en la que est la clase NumberFormatException que es capaz capturar esos
errores y se usa con el trycatch como se muestra en el siguiente ejemplo:

DemoTryCatch.java
import javax.swing.JOptionPane;
public class DemoTryCatch {
String mensaje;
public DemoTryCatch() {
String valorCadena=JOptionPane.showInputDialog(null,"Escribe un entero");

}
public static void main(String[] args) {
new DemoTryCatch();
}
}

Se debe saber que existe la clase Exception que captura todos los errores, y que
derivadas de ella hay muchas otras para atender faltas especficas, como el caso que
acabamos de probar. Ms adelante en este curso, veremos algunas otras excepciones.

Parmetr
o

Utilidad

Primero
El bloque Inicializaelcontadorydebeserunentero
for
Segundo

Establecemedianteunoperadorbolano(>,<,<=,etc)ellmitefinaldel
contador

Tercero

Estableceelritmodeincremento

El bloque for sirve para hacer ciclos controlados por un contador. La sintaxis que exige
en sus parmetros es ms compleja que las anteriores:

La expresin de i++ significa que al valor de i debe agregrsele 1. ++ es el operador de

incremento; tambin existe el de decremento (--) que resta en uno al valor que modifica.

Para ver cmo funciona el bucle for hagamos un ejemplo combinado con un trycatch
que nos muestre la tabla de multiplicar solicitada:

import javax.swing.JOptionPane;
public class DemoFor {
String mensaje;
public DemoFor() {
String valorCadena=JOptionPane.showInputDialog(null,"Qu tabla de multiplicar que desea");
try{
int valorEntero=Integer.parseInt(valorCadena);//Si esto falla, entra al catch
mensaje= "Tabla del "+valorCadena+"\n";// \n agrega un fin de lnea a las cadenas
for(int i=1;i<=10;i++){
/*La siguiente lnea se repetir diez veces y concatenar
*cadenas del tipo 5x4=20 a la cabecera puesta antes del bucle
*/
mensaje=mensaje+i+"x"+valorCadena+"="+(i*valorEntero)+"\n";
}
}catch(NumberFormatException ex){
mensaje="No es un entero";
}
JOptionPane.showMessageDialog(null,mensaje);
}
public static void main(String[] args) {
new DemoFor();
}
}

Este programa muestra la tabla de multiplicar solicitada en un cuadro de dilogo, a

menos que el usuario no haya escrito un nmero, ante lo cual mostrar el mensaje No

la opcin default; gracias al bloque trycatch, si el usuario no ingresa un nmero,

aparece un mensaje indicndoselo. Prubese varias veces el siguiente programa
ingresando diferentes valores para ver su funcionamiento pleno:

DemoSwitch.java

import javax.swing.JOptionPane;
public class DemoSwitch {
String mensaje;
public DemoSwitch() {
String califCadena=JOptionPane.showInputDialog(null, "Escriba la calificacin con nmero");
try{
int califNum=Integer.parseInt(califCadena);//Si esta lnea falla entra al catch
String calif;
switch(califNum){
/*Los casos se eligen en virtud del valor
*de la variable califNum
*/
case 0: calif="NA";break;
case 1: calif="NA";break;
case 2: calif="NA";break;
case 3: calif="NA";break;
case 4: calif="NA";break;
case 5: calif="NA";break;
case 6: calif="S";break;
case 7: calif="S";break;
case 8: calif="B";break;
case 9: calif="MB";break;
case 10: calif="MB";break;
default: calif="Invlida";break;

JOptionPane.showMessageDialog(null,mensaje);
}
public static void main(String[] args) {
new DemoSwitch();
}
}

Con esto terminamos el tema de las estructuras de control. Tngase en cuenta que en
todos los casos el flujo de datos puede cambiar en virtud de las posibles respuestas del
usuario; y que todas las estructuras vistas aqu son anidables prcticamente sin
restricciones.

Segunda parte. Aplicacin de

ejemplo

Como hasta ahora, cuando mencionemos una clase de la API, aparecer en una liga que
nos remitir a la pgina web que la describe. No obstante, pondremos en el cdigo una
descripcin de lo que hace cada uno de los mtodos usados aun cuando en muchos de
ellos es obvio. Adems, antes de cada clase haremos una descripcin de su
funcionamiento. Sin embargo, antes de comenzar a mostrar la aplicacin hay ciertos
temas que es necesario agregar para comprender mejor su funcionamiento.

Consideraciones preliminares

Herencia y polimorfismo

Para facilitar el diseo de una aplicacin, se debe usar la herencia de la programacin

orientada a objetos. Para explicar este trmino, haremos otro Hola Mundo que usar una
ventana, que contendr una etiqueta; esto requiere tres clases de la librera swing:
JFrame, JPanel y JLabel. Veamos la primera versin, sin orientacin a objetos ni

ventana.pack();
//Asigna el estado de visibilidad de la ventana a verdadero
ventana.setVisible(true);
}
public static void main(String[] args) {
new DemoClasesColaborando();
}
}

Despus de compilar y ejecutar el cdigo anterior, se presenta la siguiente ventana en la

esquina superior derecha de la pantalla:

Cada una de las clases que estamos usando pertenece a tres mbitos distintos: JFrame
es una ventana que sirve como contenedor principal; JPanel es un contenedor de
propsito general que se usar para albergar a los componentes como JLabel, o los
botones, los campos de texto, etc. Todas estn colaborando con la clase que acabamos
de compilar (de ah su nombre) para lograr el objetivo de mostrar en la etiqueta la
cadena Hola mundo. Es posible continuar en este camino y agregar otros
componentes al panel, ms paneles a la ventana y, por supuesto, ms componentes a
cada uno de stos nuevos contenedores. No obstante, esto es una mala prctica. Muy

Object si no se indica otra cosa; dicha clase tiene casi una docena de mtodos que estn
disponibles

incluso

antes

de que escribamos

miembros

con

nuestra propia

programacin. Una de las ventajas de la herencia es que las clases se pueden ir

especializando. Como ejemplo, presentamos enseguida todo el linaje de la clase JFrame:

Object
Component
Container
Window
Frame
JFrame

De tal manera que esta clase tiene todos los mtodos de las que le anteceden, adems de
los propios (que, en total, resultan ser cientos). Este beneficio lo tienen todas las
instancias de JFrame (incluida la que colabora en el programa anterior). Pero las
ventajas de la herencia van ms lejos. Sucede que si yo quiero tratar al objeto ventana
como Object lo puede hacer, como se muestra en el siguiente cdigo:

DemoVentanaComoObjeto.java

String claseObjeto=objetoVentana.getClass().toString();
etiqueta.setText(claseObjeto);
panel.add(etiqueta);
ventana.add(panel);
ventana.pack();
ventana.setVisible(true);
}
public static void main(String[] args) {
new DemoVentanaComoObjeto();
}
}

Este programa usa los mtodos de la clase Object para obtener el nombre de la clase a la
que pertenece el objeto ventana. Lo anterior significa que la herencia vuelve
polimrficas a las clases: se les puede tratar como si fueran cualquiera de aquellas que
estn en su linaje (y de hecho son cada una de ellas).

Muy frecuentemente ser conveniente hacer clases que hereden de otra. En un buen
diseo, si necesitamos usar una ventana, conviene que la clase sea un JFrame. La
herencia se logra con la palabra reservada extends escrita a regln seguido despus del
nombre de la clase y slo se puede heredar de otra. El cdigo siguiente es nuestro tan
trado Hola Mundo pero ahora usando los conceptos que estamos explicando.

*del linaje de JFrame

*/
organizaComponentes();
pack();
setVisible(true);
}
private void organizaComponentes(){
JPanel panel=new JPanel();
JLabel etiqueta= new JLabel();
etiqueta.setText("Hola mundo");
add(panel);
panel.add(etiqueta);
}

public static void main(String[] args) {

new DemoHeredaJFrame();
}
}

En este caso hemos encapsulado la tarea de agregar los componentes de la ventana en

un mtodo para mostrar que, en trminos de sintaxis, los mtodos propios de las clases
se portan igual que los heredados. Por otro lado, al haber extendido los alcances de
nuestra clase para heredar los de JFrame, se convierte en parte su linaje; ahora es
polimrfica porque es cada una de las que presentamos a continuacin:

sistemas operativos comunes de la actualidad. Junto con estos conceptos, que se

relacionan con objetos visuales, est el tema de los eventos que se desencadenan por las
acciones del usuario sobre stos con los dispositivos de entrada tales como el teclado y
el Mouse entre otros.

De dichos eventos el ms usado es, precisamente, el clic del Mouse, de cuya

programacin se pueden obtener muchos beneficios; de hecho, en nuestra aplicacin de
ejemplo slo usaremos este caso. Para hacer que una clase capture los eventos es
necesario usar otra palabra reservada: implements, que sirve para agregar interfaces a las
clases, y que se usa tambin en la lnea de la declaracin de stas, despus de la
sentencia extends (si existe); es til decir que se puede implementar ms de una interfaz.
Todos los programas que requieran responder al clic del Mouse usarn la interfaz
ActionListener que nos obliga a agregar el mtodo actionPerformed() a nuestra clase
(Las interfaces son clases especiales que es intil explicar aqu y que casi siempre
exigen que se agreguen mtodos especficos). Los clics capturados remitirn el flujo del
programa al mtodo actionPerformed() que recibe como parmetro objetos de la clase
ActionEvent .

Para mostrar esto haremos una clase que sea un JFrame, que contenga un JButton y que

*despus de la definicin de extends */

public class DemoEventoCapturado extends JFrame implements ActionListener{
JButton elBoton;//Es atributo porque se usa en organizaComponentes() y en el actionPerformed()
public DemoEventoCapturado() {
organizaComponentes();
pack();
setVisible(true);
}
private void organizaComponentes(){
JPanel panel=new JPanel();
elBoton=new JButton("Haz clic");
/*A los objetos que pueden recibir el clic
*debe agregrseles un ActionListener
*que lo reciben de la implementacin de
*la clase actual (this)*/
elBoton.addActionListener(this);
add(panel);
panel.add(elBoton);
}
/*Todos los objetos que tienen un ActionListener de la clase
*remitirn el flujo del programa a este mtodo
*que es obligatorio y su sintaxis es as como se muestra
*/
public void actionPerformed(ActionEvent evt){
JOptionPane.showMessageDialog(this,"Gracias");

}
public static void main(String[] args) {
new DemoEventoCapturado();
}
}

Aplicacin de ejemplo

Abstraccin

Para mostrar una aplicacin funcional haremos un visor de resulsets para el servidor de
bases de datos MySQL y trataremos de que est orientado a objetos. Visualmente, no es
difcil ver que se necesitarn al menos dos ventanas: aqulla para la autenticacin del
usuario y la que sirve para escribir las consultas y mostrar sus resultados. Desde esta
perspectiva, podemos establecer cuatro mbitos:

Conexin a datos

Autenticacin de usuario

Consultas SQL

Vista de resultados

Con esto hemos encapsulado lo que podramos llamar los meta-objetos de nuestra
aplicacin. Esto significa que cada uno de los tems anteriores se debe estructurar con al

Hecho lo cual, estamos listos para escribir el siguiente cdigo:

Conector.java

package visorconsultas.controlador;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class Conector {
Connection conexion;
String error;
/*Creamos un constructor que recibe cuatro parmetros:
*El nombre del servidor MySQL, el del usuario, la contrasea, y
*la base de datos*/
public Conector(String host, String usuario, String pw, String base) {
try {
/*Esta lnea crea una asociacin entre nuestra aplicacin
* y la clase Driver que est empaquetada en el jar de conexin.*/
Class.forName("com.mysql.jdbc.Driver");
/*La conexn se obtiene con una cadena que usa
*los parmetros que recibe el constructor*/
conexion=DriverManager.getConnection("jdbc:mysql://"+host+"/"+base,usuario,pw);

}
catch(ClassNotFoundException e){//Sucede si no se encuentra el driver
error=e.getMessage();
}
catch(SQLException e){//Sucede si la conexin falla
error=e.getMessage();
}
}

}
}
//Este mtodo devuelve el error que impide la conexin
public String getMensajeError(){
return error;
}

El cdigo anterior trata de obtener una conexin a MySQL usando las clases Class,
Connection, DriverManager, ClassNotFoundException y SQLException; el mecanismo
es como sigue:

1. Con el mtodo forname() de Class, se crea una asociacin entre nuestra clase
Conector y el driver de conexin MySQL. Si no lo logra, el error es capturado
con la ClassNotFoundException

2. La conexin se realiza con el mtodo getConnection() de DriverManager; si el

servidor no est disponible o refuta la solicitud, la conexin no se consuma y se

Consultas SQL

Para hacer consultas a la base de datos hacen falta una serie de clases que colaboran
para hacer acciones sucesivas: Connection, Statement, ResultSet, ResultSetMetaData y
la SQLException.

ConsultasSQL.java

package visorconsultas.controlador;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
public class ConsultaSQL {
private Connection conexion;
private ResultSet resultadoConsulta;
private ResultSetMetaData metaDatos;
private String consulta;
//Crea dos arreglos
private String[][] datosDevueltos;
private String [] nombresColumnas;
private String error;
public ConsultaSQL(Connection conRecibida, String consultaRecibida){
conexion=conRecibida;
consulta=consultaRecibida;
try {
//Crea una instancia para mandar sentencias al servidor MySQL
Statement sentencia=conexion.createStatement();
//Ejecuta la consulta y devuelve el ResultSet

public String[][] getDatosDevueltos(){

if(error==null){
try {
//Devuelve el nmero de columnas del resultset
int columnas=metaDatos.getColumnCount();
//Lleva el cursor a la ltima fila del resultset
resultadoConsulta.last();
//Obtiene el nmero de fila actual( que aqu es la ltima)
int filas=resultadoConsulta.getRow();
//Dimensiona el arreglo datosDevueltos con los enteros obtenidos
datosDevueltos=new String[filas][columnas];
//Ubica el cursor antes del a primera fila
resultadoConsulta.beforeFirst();
for(int i=0;i<filas;i++){
//Va a la siguiente fila
resultadoConsulta.next();
for(int j=0;j<columnas;j++){
//Obtiene el valor de cada una de las columnas en la fila actual
datosDevueltos[i][j]=resultadoConsulta.getString(j+1);
}
}
}
catch (Exception e){
}
}
return datosDevueltos;
}
public String[] getNombresColumnas(){
if(error==null){
try{
//Devuelve el nmero de columnas
int columnas=metaDatos.getColumnCount();
nombresColumnas=new String[columnas];

return nombresColumnas;
}
public String getMensajeError(){
return error;
}
}

El constructor de la clase ConsultaSQL recibe como parmetro un objeto de tipo

Connection y otro de String; ste contendr una sentencia SELECT; Statement es una
interfaz que puede ejecutar sentencias en lenguaje SQL a travs de una conexin; su
mtodo executeQuery() recibe la cadena SELECT y devuelve un objeto de tipo
ResultSet, que contiene una imagen de los datos devueltos por el servidor MySQL en
formato de tabla, es decir, filas y columnas; adems los ResultSet tienen un apuntador o
cursor que sirve para recorrer los registros de la tabla; el recorrido se hace con mtodos
como next(). No obstante, no toda la informacin necesaria est en los datos que ya se
obtuvieron (por ejemplo, falta el nombre de las columnas); para obtener dicha
informacin se usan los objetos del tipo ResultSetMetaData.

En la clase que acabamos de escribir, hay dos mtodos: getDatosDevueltos() y

getNombresColumnas() que darn la informacin solicitada con la consulta en dos

String[][] datosDevueltos

Una vez que el arreglo ha sido declarado, se debe dimensionar:

datosDevueltos= new String[5][4];

Hecho lo cual, se debe inicializar cada uno de los elementos agregando el ndice
correspondiente en los corchetes:

datosDevueltos[0][0]=Hola

Como en todos los lenguajes de programacin, los arreglos se leen o escriben casi
siempre usando el bucle for como lo hicimos en el cdigo anterior.

Autenticacin

Como ya vimos, para que el servidor de MySQL permita el acceso se necesitan cuatro
datos: Nombre del servidor, nombre del usuario, contrasea y nombre de la base de
datos; mismos que conviene pedir desde un cuadro de dilogo que se presente antes de
que la ventana principal aparezca. Para esto crearemos dos clases: un panel para los
componentes y un cuadro de dilogo para mostrarlos.

import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.JPasswordField;
import javax.swing.JButton;
import java.awt.GridLayout;

//Obsrvese que esta clase es un panel

public class PanelAutenticador extends JPanel {
//Crea los componentes necesarios:
//3 cuadros de texto
public JTextField servidor, usuario, base;
//Un cuadro de texto para contraseas
public JPasswordField password;
//Dos botones
public JButton aceptar, cancelar;
public PanelAutenticador() {
iniciaComponentes();
agregaComponentes();
}
private void iniciaComponentes(){
servidor=new JTextField();
usuario=new JTextField();
password=new JPasswordField();
base=new JTextField();

aceptar=new JButton("Aceptar");
aceptar.setMnemonic('a');//Subraya la A para activar el atajo de tecla <ALT-a>
cancelar=new JButton("Cancelar");
cancelar.setMnemonic('c'); //Subraya la C para activar el atajo de tecla <ALT-c>

add(new JLabel("Usuario",JLabel.RIGHT));
add(usuario);
add(new JLabel("Contrasea",JLabel.RIGHT));
add(password);
add(new JLabel("Base de datos",JLabel.RIGHT));
add(base);
add(aceptar);
add(cancelar);
}
}

Dilogo autenticador

Despus creamos un cuadro de dilogo que lo nico que hace es contener y mostrar al
panel anterior:

package visorconsultas.vista;
import javax.swing.JDialog;
public class DialogoAutenticador extends JDialog {//Obsrvese que hereda de JDialog
public PanelAutenticador panel;
/*Este programa slo sirve para
*mostrar el panel autenticador
*en un cuadro de dilogo*/
public DialogoAutenticador() {
panel=new PanelAutenticador();//Una instancia de nuestro panel autenticador
add(panel);//agrega el panel autenticador
setSize(300,150); //Dimensiona el dilog
}

rea de texto para las consultas

Como los objetos de tipo JTextArea son multilnea, puede suceder que el contenido
exceda la zona visible; por eso se deben poner dentro de un objeto de la clase
JScrollPane, que es un panel que pone a la disposicin de los componentes con partes
ocultas las barras de desplazamiento horizontal y vertical.
AreaConsulta.java
package visorconsultas.vista;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
public class AreaConsulta extends JScrollPane{//Esta clase es un panel desplazable
public JTextArea texto;
public AreaConsulta() {
texto=new JTextArea(4,30);
texto.setLineWrap(true);//Hace que las lneas corten en el lmite del rea
texto.setWrapStyleWord(true);//Hace que corten slo en palabras completas
setViewportView(texto);//Dentro de las barras se ver le rea de texto
}
}

Tabla para mostrar los resultados

Las JTable tambin deben estar dentro de un JScrollPane y su funcin principal es

mostrar los datos guardados en objetos del tipo DefaultTableModel; stos almacenan los

//Dimensiona la tabla para la presentacin inicial

setColumnCount(7);
setRowCount(30);
}
}

Tabla

TablaResultados.java

package visorconsultas.vista;
import javax.swing.JTable;
import javax.swing.JScrollPane;
import visorconsultas.modelo.ModeloTabla;
import javax.swing.table.TableModel;
public class TablaResultados extends JScrollPane {
public ModeloTabla modelo;//Crea una instancia del modelo
public JTable tabla;
public TablaResultados() {
modelo=new ModeloTabla();
tabla=new JTable(modelo);//Se asigna el modelo a la tabla al momento de construirla
//Las columnas se autoajustan
tabla.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
setViewportView(tabla); //La tabla se ver dentro del panel de barras de desplazamiento
}
}

Panel de botones

import javax.swing.JPanel;
import javax.swing.JButton;
public class PanelBotonesConsulta extends JPanel{
public JButton consultar, salir;
public PanelBotonesConsulta() {
iniciaComponentes();
agregaComponentes();
}
private void iniciaComponentes(){
consultar =new JButton("Consultar");
consultar.setMnemonic('c');
salir =new JButton("Salir");
salir.setMnemonic('s');
}
private void agregaComponentes(){
add(consultar);
add(salir);
}
}

Ventana de consultas

La ventana para mostrar las consultas contiene al rea de texto, a los botones y a la tabla
que acabamos de hacer. Es pertinente decir aqu que los objetos del tipo JFrame usan el
manejador de diseo BorderLayout que usa los bordes de los contendores para su
ordenamiento. Por eso, el mtodo add() recibe como segundo parmetro cul borde

El mtodo inicio() hace visible a la ventana pero le sobrepone al dilogo autenticador,

que es modal, es decir, que toma el control de la aplicacin. Ser la intervencin del
usuario la que determinar el flujo del sistema.
Por el ltimo es de notar que las lneas que se refieren al Controlador estn comentadas
porque esta clase no existe todava.

VentanaConsultas.java
package visorconsultas.vista;
import javax.swing.JFrame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
//
//import visorconsultas.controlador.Controlador;
public
Controlador controlDe;
public class
VentanaConsultas
extends JFrame implements ActionListener {
public VentanaConsultas() {
public DialogoAutenticador autenticador;
iniciaComponentes();
public TablaResultados resultados;
agregaComponentes();
public AreaConsulta area;
agregaListeners();
public PanelBotonesConsulta botones;
inicio();
}
private void iniciaComponentes(){
autenticador=new DialogoAutenticador();
resultados=new TablaResultados();
area=new AreaConsulta();
botones=new PanelBotonesConsulta();
}
private void agregaComponentes(){
add(resultados,"South");
add(area,"West");
add(botones,"East");

public void inicio(){

controlDe=new Controlador();
setVisible(true);
autenticador.setLocationRelativeTo(this);
autenticador.setModal(true);
autenticador.setVisible(true);
}
public void actionPerformed(ActionEvent evt){
//controlDe.acciones(this,evt);
}

//

Controlador

Hasta ahora tenemos los mecanismos de conexin a base de datos y la posibilidad de

mostrarlos; toca a una clase controladora llevar el proceso de autenticacin y de
obtencin de la informacin. Esto se realiza con el mtodo acciones() que discrimina
cada uno de los cuatro botones en la aplicacin (aqullos a los que le agregamos listener
en la ventana y a los que nos referiremos con su nombre en cursiva). Los objetos
cancelar y salir, cerrarn la aplicacin. Por su parte, aceptar tomar los valores de los

ConsultaSQL que muestra los datos en la tabla si los obtiene, si no, indica a su vez el
error en otro cuadro de dilogo.

Controlador.java

package visorconsultas.controlador;
import visorconsultas.vista.VentanaConsultas;
import java.awt.event.ActionEvent;
public class Controlador {
Conector conMySQL;
public Controlador() {
}
public void acciones(VentanaConsultas visor, ActionEvent evt){
Object clicado=evt.getSource();
if(clicado==visor.autenticador.panel.aceptar){
String host=visor.autenticador.panel.servidor.getText();
String usuario=visor.autenticador.panel.usuario.getText();
String pw=new String(visor.autenticador.panel.password.getPassword());
String base=visor.autenticador.panel.base.getText();
conMySQL=new Conector(host,usuario,pw,base);
if(conMySQL.getConexion()!=null)
visor.autenticador.dispose();
else
muestraError("El error que manda MySQL es:\n"+conMySQL.getMensajeError());

}
if(clicado==visor.botones.consultar){
ConsultaSQL consulta=
new ConsultaSQL(conMySQL.getConexion(),visor.area.texto.getText());
if(consulta.getMensajeError()==null)

javax.swing.JOptionPane.showMessageDialog(null,e);
}
public static void main(String[] args){
new visorconsultas.vista.VentanaConsultas();
}
}

Compilacin y ejecucin

Cada una de las clases que acabamos de crear debe ser compilada en el orden sucesivo
en que se presenta. Al final, a VentanaConsulta deben quitrsele las diagonales de
comentarios de las lneas que invocan al Controlador y debe volverse a compilar;
despus de lo cual, sta ltima clase se puede ejecutar, en tanto que es ella la que tiene
el mtodo main().
La apariencia inicial es como sigue:

Y este es el resultado despus de hacer una consulta:

ndice

Presentacin...................................................................................................................... 1
Qu y para qu es Java?.............................................................................................. 2
Objetivos y metodologa del curso............................................................................... 2
Primera parte. Iniciacin al lenguaje Java........................................................................ 4
Instalacin..................................................................................................................... 4
Definicin breve de la Programacin Orientada a Objetos (POO) .............................. 8
El programa Hola Mundo y los conceptos de abstraccin y encapsulamiento ........ 9
Elementos del lenguaje Java....................................................................................... 11
Identificadores........................................................................................................ 12
Sentencias............................................................................................................... 12
Bloques de cdigo .................................................................................................. 13
Comentarios............................................................................................................ 13
Expresiones............................................................................................................. 14
Operadores.............................................................................................................. 14

Los tipos de datos y los mtodos............................................................................ 28

Caso de mtodo que s devuelve un tipo y no recibe parmetros....................... 28
Caso de mtodo que no devuelve un tipo y s recibe parmetros....................... 29
Caso de mtodo que s devuelve un tipo y s recibe parmetros........................ 30
Estructuras de control................................................................................................. 31
Introduccin............................................................................................................ 31
El bloque ifelse.................................................................................................... 34
if.. else anidado....................................................................................................... 35
Operadores lgicos................................................................................................. 36
AND ................................................................................................................... 37
OR....................................................................................................................... 38
La estructura de control while ................................................................................ 39
La estructura de control trycatch ........................................................................ 40
El bloque for........................................................................................................... 42
El bloque switch ..................................................................................................... 43
Segunda parte. Aplicacin de ejemplo........................................................................... 46

Dilogo autenticador........................................................................................... 61
Vista de resultados.................................................................................................. 61
rea de texto para las consultas ......................................................................... 62
Tabla para mostrar los resultados....................................................................... 62
Panel de botones................................................................................................. 63
Ventana de consultas.......................................................................................... 64
Controlador............................................................................................................. 66
Compilacin y ejecucin.................................................................................... 68
Y este es el resultado despus de hacer una consulta:............................................ 70
ndice.............................................................................................................................. 71