POOABD (POO Aplicada a B Datos) - API JDBC - Parte 1

PROGRAMACIÓN ORIENTADA A OBJETOS
PROGRAMACIÓN ORIENTADA A OBJETOS
APLICADA A BASES DE DATOS
APLICADA A BASES DE DATOS

Por
LAURA NOUSSAN LETTRY

API JDBC - Parte 1

Aviso Legal
El presente libro electrónico
se distribuye bajo
Attribution-NonCommercialNoDerivs 3.0 Unported

POO APLICADA A BASES DE DATOS

ÍNDICE

API JDBC – PARTE 1
Introducción
1.

Nociones básicas de la Programación Orientada a Objetos. Concepto.
Diferencias con la programación procedimental.
2. Qué es Java. Concepto. Creación de clases, uso de paquetes.
3. Utilización de Formularios y Menús para manipular datos. Paquete Java
Swing.
4. Creación de una conexión con la API JDBC. Aplicación de SQL-DML a través
de Java

1
2
9
16

FUENTES Bibliográficas Consultadas
1. Documentación Java en general:
The Java Tutorials:
http://docs.oracle.com/javase/tutorial
2. Documentación sobre Swing:
http://docs.oracle.com/javase/tutorial/uiswing/index.html
3. API JDBC:
http://www.oracle.com/technetwork/java/overview-141217.html
The Java Tutorial:
http://docs.oracle.com/javase/tutorial/jdbc/index.html

BIBLIOGRAFÍA para el Alumno
1.

Contenidos de esta Unidad

2.

Programas fuentes linkeados en el site web de la materia y que son
complementarios al contenido.

3.

Demás material bibliográfico linkeado en el sitio web de la materia.

(*)

ACTIVIDADES
Unidad 2

Parte 1

Tareas
Lectura, trabajos, prácticas propuestas en el Website de la Materia.

(*): En el Website de la materia:

http://www.lnoussanl.com.ar/javabd/
http://www.lnoussanl.com.ar/java&bd


API JDBC – PARTE 1
INTRODUCCIÓN
Sería arriesgado abordar de lleno el estudio del API JDBC sin repasar
conceptos básicos del Paradigma de Programación Orientada a Objetos, y en
particular sin utilizar Java como lenguaje.
El API JDBC permite la conexión con cualquier RDBMS que tenga
implementado el Driver JDBC siguiendo las clases del API. Cabe aclarar
además, que el API es parte integrante de los primeros desarrollos de la
plataforma Java, mediante el paqute java.sql. Asimismo en la actualidad está
presente en los diferentes entornos o plataformas de desarrollo: JavaSE,
JavaME y JavaEE.
Por lo antes expresado, a modo de repaso se plantea el uso de java con
programación orientada a objetos. Primero se encara la solución de problemas
sencillos utilizando sólo código, para pasar con posterioridad a la utilización de
Formularios, y en este caso de la librería JavaSwing, por ser una librería ideal
para el desarrollo de aplicaciones de escritorio.
A través de los diferentes ejemplos desarrollados, el estudiante comprenderá
que las clases bases, es decir, aquellas que algorítmicamente resuelven el
planteo del problema, son fundamentales y ciertamente el medio que usemos
para construir la aplicación, es independiente de ellas; ya sea que se trate de
aplicaciones Swing, Jsp o Applets de Java.
En el último punto se aborda una introducción, con un ejemplo práctico, del
API JDBC creando una conexión que permite devolver los datos de una
consulta realizada sobre un RDBMS. Siguiendo la metodología empleada en los
capítulos anteriores, se realiza la conexión sobre los dos RDBMS vistos con
anterioridad: MySQL y SQL Server.
En la segunda parte se abordará con más profundidad la temática de las
Excepciones puesto que el API ha sido construido y pensado para darle
robustez al sistema transaccional. Lógicamente también se abordará en detalle
el API JDBC y se utilizarán objetos Statements que permiten realizar
inserciones, actualizaciones y eliminaciones de tablas.

API JDBC

Le
ttr

y

NOCIONES BÁSICAS DE LA PROGRAMACIÓN ORIENTADA A OBJETOS. Concepto.
Diferencias con la programación procedimental.

La programación orientada a objetos (POO) es un paradigma de programación que enfoca el desarrollo
de aplicaciones de manera integral.
No se puede encarar el estudio y utilización del API JDBC de Java sin hacer un repaso de conceptos
básicos de lo que es la POO; partiendo de la base de que el API es parte integrante de la plataforma Java
en sus diferentes versiones: JavaSE, JavaEE y JavaME.

an

A diferencia de la programación procedimental, en la programación orientada a objetos se gestionan los
atributos y métodos de un objeto en forma conjunta y atómica. Un objeto considera ambos aspectos
como fundamentales y los trata en conjunto, es decir, los atributos y métodos del objeto están diseñados
para trabajar en conjunto en una plantilla llamada clase. Cuando se ejecuta el programa, se instancia al
objeto definido en la plantilla.
En cambio, en la programación procedimental, los procedimientos y funciones están separados de los
atributos de los ‘objetos’ que gestionan, y todo el sistema se controla mediante los mismos. Por lo tanto,
los datos se suelen tratar en forma independiente del proceso, en cierto modo restándole importancia, y
focalizando en realidad todo el esfuerzo en el proceso.

ss

Las características de un lenguaje basado en el paradigma de programación orientado a objetos,
básicamente debe contar con los siguientes elementos:
CLASE: una clase es un modelo o plantilla para representar un objeto. Se puede decir entonces
que es el molde básico para luego crear los objetos
Una clase se define con atributos y métodos.

o

Los atributos son las propiedades que van a caracterizar al objeto en forma general y los
métodos son las funciones u operaciones que van a poder realizar el objeto.

ou

o

OJETO: es una ENTIDAD, es decir, es “algo concreto” obtenido de la plantilla; por lo tanto
también podríamos decir que una CLASE es una abstracción de un objeto.

aN

Por lo tanto, un objeto cuenta con una identidad (a través de uno o más valores de sus atributos que lo
diferencia de otros), con un estado que viene dado a través de los datos del objeto (del conjunto de
valores de sus atributos) y de un comportamiento (a través de sus métodos).
Sin embargo la POO se basa en algunos postulados, que también la diferencian de la programación
estructurada, siendo los más importantes los siguientes:

ur

1) Abstracción: se definen las características esenciales del objeto (tanto atributos como
comportamiento)
2) Encapsulamiento: todos los elementos de una misma entidad están al mismo nivel de
abstracción

La

3) Aislamiento: los objetos están aislados del entorno o contexto que los rodea, lo que
permite proteger sus atributos y métodos
4) Modularidad: es más fácil dividir una aplicación grande en componentes debido a que
unos objetos se pueden ensamblar unos con otros, ya que se comunican mediante
mensajes;
5) Herencia: significa en concreto que una clase hija heredará todos los atributos y
métodos de la clase padre.

of.

6) Polimorfismo: el significado obvio de esta palabra es “varias formas” y quiere decir que
un objeto puede tener métodos con el mimo nombre que otros objetos diferentes y no
interferirán entre sí; por ejemplo.

Pr

7) Recolección de basura: es una característica importante y que en los hechos significa
que aquél objeto que no es utiliza se destruye.

Veremos ejemplos prácticos de estas características, para lo cual hay que comprender que las clases no
se diseñan solas y se debe especificar el nivel de ocultamiento o aislamiento que el objeto tendrá. Esto lo
veremos a través de ejemplos con Java.

El API JDBC – parte 1 pág. 1/19

QUÉ ES JAVA. Concepto. Diseño de Clases. Los calificadores de acceso. Herencia y
Polimorfismo. Uso de paquetes

Le
ttr

y

Java es mucho más que un lenguaje de programación, es una Plataforma de Desarrollo de Software
multiplataforma y gratuita. Como ya anticipáramos, en la actualidad cuenta con distintas plataformas de
desarrollo dependiendo del tipo de usuario y de lo que se necesite desarrollar. Así por ejemplo existe una
plataforma de desarrollo para móviles, para empresas, etc. No ahondaremos en ello puesto que no es
nuestro objetivo y todo lo que uno quiera saber puede encontrarlo en la web de Oracle.
Al ser Java un lenguaje totalmente orientado a objetos nos permite crear las clases o plantillas y
posteriormente crear los objetos.
Vamos a encarar los distintos tópicos en base a ejemplos que se pueden descargar desde el sitio web de
la materia: http://www.lnoussanl.com.ar/java&bd

an

Para poder diseñar una clase tenemos que tener en cuenta el objeto del mundo real que queremos
diseñar. El primer ejemplo, que es básico, se trata de diseñar la Clase Persona. Como todos sabemos
una persona tiene ciertas características que la diferencian de otra y el proceso de analizar cuáles son las
características que hacen que sea una persona es lo que se llama Abstracción.
Como atributos básicos pues podemos mencionar: el apellido, el nombre y la fecha de nacimiento.
Lógicamente una persona tiene otras características por, ejemplo, el color de cabello y de ojos, los
estudios que cuenta, etc. Sin embargo para el ejemplo utilizaremos los tres primeros.

ss

En el mundo real sabemos que una persona puede tener el mismo nombre y apellido que otra persona,
siendo mucho más difícil que coincida con la fecha de nacimiento, pero nada nos asegura que no pueda
suceder esto. De hecho, el motivo por el cual las personas tienen un número de documento es
justamente para evitar ambigüedades en cuanto a su identificación.
Así pues el otro atributo básico que necesitamos, es el número de documento.

ou

Como una buena práctica de programación, en el curso, seguiremos estas sencillas reglas:
1. El nombre de la clase siempre va en singular y la primera letra en mayúscula
2. Los atributos y métodos de las clases se escribirán con su primera letra en minúscula.

aN

3. Las clases que representen los objetos con los que trabajaremos compartirán un mismo
espacio, en principio, llamado paquete.
4. Las clases además estarán escritas por separado en archivos *.java separados del archivo
que inicie el objeto llamado aplicación.
A continuación transcribo los archivos java que describen el problema planteado:

Archivo Persona.java:

Pr

of.

La

ur

1 package TOI_2013.ejemplo1;
2
3 /**
4 *
5 * @author Laura Noussan Lettry
6 */
7 public class Persona {
8 //atributos
9 private String apellido="";
10 private String nombre="";
11 private String fecha_nac=" / / ";
12 private int documento=0;
13
14 //métodos
15 //constructor
16 public Persona(String a,String n,String f, int d){
17
apellido=a;
18
nombre=n;
19
fecha_nac=f;
20
documento=d;
21 }
22
23 public String mostrarDatos(){
24
return "Los datos de la Persona son:n "
25
+ "Apellido: "+this.apellido.toString()+
26
"n Nombre: "+this.nombre.toString()+



y

27
"n Fecha de Nacimiento: "+this.fecha_nac.toLowerCase()+
28
"n Documento: "+this.documento;
29 }
30 }//fin clase Persona

Archivo Ejemplo1.java

ss

an

2 import javax.swing.JOptionPane;
3
4 /**
6 */
7 public class Ejemplo1 {
8
9 /**
10
* @param args the command line arguments
11
*/
12 public static void main(String[] args) {
13
//aquí se utiliza el constructor diseñado
14
Persona Pedro= new Persona("Moreno","Pedro","20/05/1996",42500333);
15
JOptionPane.showMessageDialog(null,Pedro.mostrarDatos() ) ;
16 }
17 }//fin clase Ejemplo1

Le
ttr

La clase runtime o clase de la Aplicación está diseñada en el archivo Ejemplo1.java, es decir va por fuera
de la clase en un archivo aparte.

ou

Análisis de las clases:

La clase Persona creará un objeto persona que tendrá los atributos apellido, nombre, fecha de nacimiento
y documento.
La creación del objeto se lleva a cabo mediante un método especial, llamado constructor. El constructor
ha sido diseñado de modo tal que recibe las variables que se asignarán a los atributos.

aN

Además del constructor también se ha diseñado el método mostrarDatos() que permite ver los datos de
la persona.
En la clase Ejemplo1 podemos ver que se crea el objeto Persona y luego, mediante un control
JOptionPane (de la librería Swing de Java) se muestran los datos.

Figura 1: ejecución Ejemplo1.java

of.

La

ur

Aquí es importante entender que tanto los atributos como los métodos de la clase Persona están
afectados por calificadores de acceso o visibilidad, que veremos a continuación.

Los calificadores de acceso: private, protected, public y package
¿Qué significa que un atributo sea privado?: quiere decir que el atributo sólo podrá ser accesible por un
método de la clase; es decir, son sólo visibles para la clase.

Pr

Con el calificador protected, los atributos sólo son visibles para la clase y clases hijas.

El calificador package es el utilizado por omisión si no se especifica otro y la visibilidad abarca a todas las
clases del mismo paquete.
El calificador public implica que los miembros de una clase son visibles desde cualquier código.



Le
ttr

y

Vamos a crear otro ejemplo con la Clase Persona, donde vamos a tener dos constructores, el anterior y
uno que aparentemente no hace nada, pero sí que hace: construye el objeto con los valores que hemos
inicializado los atributos. Para que no haya problemas, hemos creado las clases Persona.java y
Ejemplo2.java en otro paquete:

Archivo Persona.java

aN

ou

ss

an

2
3 /**
4 *
6 */
7 class Persona {
8 //atributos
9 private String apellido="";
10 private String nombre="";
11 private String fecha_nac=" / / ";
12 private int documento=0;
13
14 //métodos
15 //constructores
16 Persona(){
17
18 }
19 Persona(String a,String n,String f, int d){
20
apellido=a;
21
nombre=n;
22
fecha_nac=f;
23
documento=d;
24 }
25
26 String mostrarDatos(){
27
return "Los datos de la Persona son:n "
28
+ "Apellido: "+this.apellido.toString()+
29
"n Nombre: "+this.nombre.toString()+
30
"n Fecha de Nacimiento: "+this.fecha_nac.toLowerCase()+
31
"n Documento: "+this.documento;
32 }
33 }//fin clase Persona

ur

archivo Ejemplo2.java

Pr

of.

La

3
4 /**
5 *
7 */
8 class Ejemplo2 {
9
10 /**
11
12
*/
14
15
Persona Desconocida= new Persona();
16
JOptionPane.showMessageDialog(null ,Desconocida.mostrarDatos(),"Mensaje 1",1 ) ;
17
Persona Martin = new Persona("Carrera","Martin","12/05/1996",43000000);
18
JOptionPane.showMessageDialog(null,Martin.mostrarDatos(),new String("Mensaje 2"),1 ) ;
19
20 }
21 }//fin clase Ejemplo2



y

Además de crear otro constructor en la Clase Persona también hemos quitado los calificadores de acceso
public de la clase y de los métodos; salvo el método principal de la aplicación. Por lo tanto, por omisión,
la clase Persona y la clase Ejemplo2 utilizan el calificador Packaged

Le
ttr

También hemos usado una variante más elaborada de la clase JOptionPane que nos permite agregarle un
título al mensaje:
JOptionPane.showMessageDialog(null ,Desconocida.mostrarDatos(),"Mensaje 1",1 )

JOptionPane.showMessageDialog(null,Martin.mostrarDatos(),new String("Mensaje 2"),1 )

El número 1, al final de la lista de argumentos, significa que la ventana será del tipo Información con un
ícono “I”. Pueden consultar la documentación de java o bien probar con otros números.

ss

an

En la siguiente figura se muestra las dos ventanas que se muestran al ejecutar el programa.

Figura 2: ejecución de Ejemplo2.java

ou

Herencia y Polimorfismo en Java

Vamos a utilizar otro ejemplo para poder mostrar en forma clara qué es la herencia y qué es el
polimorfismo.
Herencia

aN

La HERENCIA es una de las relaciones que se pueden dar entre clases. Otras relaciones que se pueden
dar son la DEPENDENCIA y la AGREGACIÓN.
Ahora veremos solamente la herencia.

Para entender qué es la HERENCIA vamos a crear una clase llamada VehiculoTerrestre, y otras cuatro
clases más llamadas Auto, Moto, Carreta y Cuatriciclo.

ur

La lógica nos indica que tanto un auto como una moto o un cuatriciclo son vehículos a motor, por lo tanto
tendrán un motor; en cambio la carreta no tiene motor. Esta ya es una diferencia entre las clases hijas.
La clase madre tendrá en principio tres atributos básicos: patente, color y cantidad de ruedas (ya que
todo vehículo terrestre tiene ruedas).

La

La clases hijas a su vez tendrán atributos que las identifican como una auto, como un cuatriciclo, o como
una moto o una carreta. Una de ellas es la cantidad de ruedas, pero supondremos que la carreta no tiene
patente.

of.

La idea es que una moto tiene dos ruedas y un auto cuatro ruedas, pero me dirán un cuatriciclo también
tiene cuatro ruedas. ¡¡Sí!!, tiene los mismos atributos que un auto salvo porque no tiene techo ni
ventanas. ¡¡Sí!!, entonces se podría pensar que un cuatriciclo hereda esos atributos de un auto!! Pues
No!!. Aquí viene lo importante de la POO: se trata de hacer una abstracción de la realidad, no de forzar la
realidad para tener una abstracción para usar la herencia sólo para heredar métodos. Lo que corresponde
para un cuatriciclo es considerar que no tiene techo, en todo caso y no se puede decir, en lenguaje
coloquial que un cuatriciclo es un auto ¿no? Por eso es que
¡¡NO HAY QUE USAR LA HERENCIA DE CUALQUIER MANERA!!

Pr

Así pues tenemos dos alternativas claras: el atributo que represente si el objeto tiene techo o no, puede
estar en la clase Cuatriciclo o en la clase VehiculoTerrestre. Lo más práctico es que esté en la clase
madre, en realidad. Los vehículos a motor tendrán o no techo, dependiendo del tipo de vehículo. Es lo
más realista.
Lo más fácil es elegir la primera opción, más que nada por cuestiones didácticas.
Veamos la clase madre: archivo VehiculoTerrestre.java



Le
ttr

of.

La

ur

aN

ou

ss

an

1 package ejemplo3;
2
3 /**
4 *
6 */
7 public class VehiculoTerrestre {
8 //atributos
9 protected String patente;
10 protected String color;
11 protected int ruedas;
12 protected boolean techo;
13 //métodos
14 //constructor
15 public VehiculoTerrestre(String p, String c, int r,boolean t){
16
patente=p;
17
color=c;
18
ruedas=r;
19
techo=t;
20 }
21 public String getPatente(){
22
return this.patente;
23 }
25
return new String("Patente: "+getPatente()+"n Color: "+this.color+
26
"n Cantidad de Ruedas: "+this.ruedas);
27 }
28 public String soyUn(){
29
String cadena;
30
switch (this.ruedas){
31
case 2:
32
if(this.patente.equals(""))
33
cadena = new String("Soy una CARRETA");
34
else
35
cadena=new String("Soy una MOTO");
36
break;
37
case 3:
38
cadena = new String("Soy un TRICICLO");
39
break;
40
case 4:
41
if(this.techo)
42
cadena = new String("Soy un AUTO");
43
else
44
cadena =new String("Soy un CUATRICICLO");
45
break;
46
default:
47
cadena = new String("SOY UN OVNI");
48
49
}//fin switch
50
51
return cadena;
52 }//fin soyUn()
53 }//fin clase VehiculoTerrestre

y

Archivo VehiculoTerrestre.java

En cuanto a las clases hijas, las transcribimos a continuación:
Archivo Auto.java

Pr

1 package ejemplo3;
2
3 /**
4 *
6 */
7 public class Auto extends VehiculoTerrestre {
8 //atributos


an

Le
ttr

9 private boolean motor;
10 private int puertas;
11 //métodos
12 //constructor
13 public Auto(String pat, String c, int r,int p){
14
super(pat,c,r,true);//suponemos que un auto tiene techo
15
motor=true;
16
puertas=p;
17
18 }
19 @Override//sobreescribe al mismo método con el mismo nombre de la clase madre
21 String cadena1 =super.mostrarDatos(); //va a mostrar los datos del vehículo
22 //esta es para los datos del auto
23 String cadena2="n tiene Motor: "+this.motor+
24
"n y tiene: "+this.puertas+" puertas.";
25 return cadena1+cadena2;
26 }
27
28 }//fin clase auto

y


El archivo Moto.java

La

ur

aN

ou

ss

1 package ejemplo3;
2
3 /**
4 *
6 */
7 public class Moto extends VehiculoTerrestre {
8 //atributos
10 //métodos
11 //constructor
12 public Moto(String p, String c, int r){
13
super(p,c,r,false);//una moto no tiene techo
14
motor=true;
15
16 }
20 //esta es para los datos de la moto
21 String cadena2="n tiene Motor: "+this.motor;
23 }
24
25 }//fin clase Moto

El archivo Cuatriciclo.java

Pr

of.

1 package ejemplo3;
2
3 /**
4 *
6 */
7 public class Cuatriciclo extends VehiculoTerrestre {
8 //atributos
10
11 //métodos
12 //constructor
13 public Cuatriciclo(String p, String c, int r){
14
super(p,c,r,false);//un cuatriciclo no tiene techo
15
motor=true;
16


Le
ttr

17 }
21 //esta es para los datos del cuatriciclo
22 String cadena2="n y tiene Motor: "+this.motor;
24 }
25
26 }//fin clase Cuatriciclo

y


El archivo Carreta.java

aN

ou

ss

an

1 package ejemplo3;
2
3 /**
4 *
5 * @author Laura
6 */
7 public class Carreta extends VehiculoTerrestre {
8 //atributos
10 //métodos
11 //constructor
12 public Carreta(String pat, String c, int r){
13
super(pat,c,r,false);//la carreta no tiene techo
14
motor=false;
15
16 }
20 //esta es para los datos de la carreta
21 String cadena2="n tiene Motor: "+this.motor;
23 }
24 }//fin clase carreta

La palabra reservada this (este) hace referencia al atributo o método del objeto actualmente en
ejecución.
La palabra reservada extends (extiende en español) es la que permite definir a una clase como hija de
otra, ya que extiende tanto sus métodos como sus atributos.

ur

La palabra reservada super(argumentos) permite pasar al constructor de la clase madre los valores de
los atributos

La

El método mostrarDatos() está presente tanto en las clases hijas como en la clase madre. Dicho
método de la clase madre lo que hace es mostrar información del objeto madre; y en las clases hijas se
llama a método del mismo nombre pero de la clase.
En las clases hijas el método está sobrescribiendo al de la clase madre, de allí que se diga que redefine o
se sobrescribe e método. Esto se indica con la siguiente cláusula: @Override (ver la línea de código 17 ó
18, según el archivo de las clases hijas)

of.

Polimorfismo en Java

Pr

Este método mostrarDatos, presente en todas las clases, es un claro ejemplo de Polimorfismo. Es fácil
entender el por qué no hay ambigüedad cuando se ejecuta el programa; simplemente dichos métodos,
con el mismo nombre, forman parte de una clase particular; y por lo tanto, cuando el objeto en cuestión
se crea, están encapsulados tanto sus atributos como sus métodos. Esto no es posible en la
programación estructurada.

El calificador de acceso protected
Para que la herencia pueda funcionar es necesario que archivos externos a la clase VehiculoTerrestre
puedan acceder a sus atributos, para lo cual es necesario que dichos atributos estén declarados con éste.



y

De esta manera, las clases hijas pueden acceder a los atributos de la clase madre, de lo contrario, no se
podría (con el calificador private) y no tendría sentido por cuestiones de seguridad utilizar el calificador
public en dichos atributos. Si así hiciéramos, cualquier otra clase y no sólo las hijas e inclusive clases de
otros paquetes podrían acceder a los atributos.

Le
ttr

Las clases hijas son clases externas a la clase VehiculoTerrestre, pero todas forman parte del mismo
paquete, este es otro de los requisitos.

Un paquete reúne clases vinculadas y puede considerarse como una carpeta o directorio.

Finalmente falta la clase runtime. Declarada en el archivo ejemplo3.java

ou

ss

an

1 package ejemplo3;
2
4
5 /**
6 *
7 * @author Laura
8 */
9 public class Ejemplo3 {
10 /**
11
12
*/
14
15
VehiculoTerrestre V1 = new Auto("GEP022","BLANCO",4,3);
16
VehiculoTerrestre V2 = new Moto("EWKJ36","ROJO",2);
17
VehiculoTerrestre V3 = new Carreta ("","GRIS",2);
18
VehiculoTerrestre V4 = new Cuatriciclo ("AAIW77","AMARILLO",4);
19
JOptionPane.showMessageDialog(null,V1.mostrarDatos(),V1.soyUn(),1 ) ;
20
21
22
23 }
24 }//fin clase ejemplo3

aN

Aquí hemos utilizado otra variante del método showMessageDialog del componente JOptionPane de
modo tal que el título de la ventana muestre el tipo de objeto (método soyUn de la clase madre), y que la
ventana sea del tipo información
(el número 1).

Figura 3: ejecución del programa Ejemplo3.java

Pr

of.

La

ur

La salida del programa se muestra
en la figura 3

Utilización de Formularios y Menús para manipular datos. Paquete Java
Swing.
El objetivo de la materia es gestionar bases de datos con Java mediante el API JDBC. Para ello es
necesario manejar bien los objetos, ya que las conexiones a bases de datos utilizan objetos Java para


manejar los datos que se encuentran en RDBMS, pero también es necesario poder manipular los
formularios y menús que obtendrán los datos del usuario o de las consultas que éste haga al RDBMS.

y

Para encarar la creación de formularios y menús, y poder gestionar una aplicación, utilizaremos para
crear la Vista del Usuario el paquete Java Swing.

Le
ttr

Formularios en Java

Utilizaremos las mismas clases utilizadas en el ejemplo anterior: Auto, Moto, Carreta, Cuatriciclo y
VehiculoTerrestre; lo que cambia es la clase runtime, en realidad, ya que necesitamos gestionar las
clases base de otra manera, mediante una aplicación interactiva y visual.
La Clase runtime será un Jframe para crear un Auto, como ejemplo inicial de cómo hay que trabajar con
formularios Java.
Cabe aclarar que NetBeans presenta con la librería Swing la facilidad de diseñar gráficamente el
formulario y automáticamente agrega el código necesario de los diferentes componentes (Paneles,
cuadros de texto, etc.)

an

Lo primero que hay que hacer es crear un nuevo paquete que llamaré Ejemplo4 y allí copiar las cinco
clases antes mencionadas.

aN

ou

ss

Lo segundo es crear un Jframe, que será la clase runtime para crear y mostrar un Auto

Figura 4: creación de un formulario JFrame al que le hemos agregado un Panel y un Botón. Hay

ur

que notar que tenemos muchos componentes Swing: contenedores, controles y menús.

La

Se puede apreciar que el Panel tiene un borde, para lo cual basta con pulsar sobre éste y mediante el
botón derecho del ratón seleccionar la
opción propiedades dentro del menú
desplegable y allí ir a Borde. Algo
parecido ocurre con el Botón, hay que
modificar
las
propiedades
para
colocarle un título apropiado.
Finalmente el Formulario nos quedará
como lo muestra la Figura 5.

of.

Según el constructor Auto, pues
necesitamos 4 atributos, motivo por
el cual necesitamos cuatro cuadros de
texto con sus correspondientes labels.

Pr

Después, si recordamos el ejemplo
anterior, por un lado hay que crear el
objeto y por otro queremos mostrar
los datos del objeto; esto se logra con
los botones.
A continuación hemos copiado el
código fuente (el que se puede ver en

Figura 5: Diseño del Formulario para crear un Auto

NetBeans, y lógicamente agregar código y/o modificar) pulsando sobre la solapa denominada Source ya
que hasta ahora hemos estado en Design

y

En la vista Diseño del formulario además hemos modificado las propiedades, primero para utilizar
nombres de variables que nos indiquen para qué sirven.

aN

ou

ss

an

Le
ttr

En la siguiente figura 6, si hacemos zoom, podremos ver que el JTextField tiene un nombre de variable:
patente y un tipo de acceso: private. El tipo de acceso lo coloca NetBeans por omisión pero el nombre de
variable también lo coloca por omisión, lo hemos cambiado para que sea coherente con el dato que
queremos manipular.

Figura 6: modificar las propiedades de los controles Swing
Las clases originales no se modifican para nada!!!.
A continuación se transcribe el código de la clase runtime; es decir la del formulario:

Pr

of.

La

ur

1 package ejemplo4;
2
4 import javax.swing.JTextField;
5
6 /**
7 *
9 */
10 public class CrearAuto extends javax.swing.JFrame {
11
12 /**
13
* Creates new form
14
*/
15 public CrearAuto() {
16
initComponents();
17 }
18
19 /**
20
* This method is called from within the constructor to initialize the form.
21
* WARNING: Do NOT modify this code. The content of this method is always
22
* regenerated by the Form Editor.
23
*/
24 @SuppressWarnings("unchecked")
25 // <editor-fold defaultstate="collapsed" desc="Generated Code">
26 private void initComponents() {
27



Pr

of.

La

ur

aN

ou

ss

an

Le
ttr

y

28
jPanel1 = new javax.swing.JPanel();
29
patente = new javax.swing.JTextField();
30
jLabel1 = new javax.swing.JLabel();
31
32
33
34
color = new javax.swing.JTextField();
35
cantRuedas = new javax.swing.JTextField();
36
cantPuertas = new javax.swing.JTextField();
37
jToggleButton1 = new javax.swing.JToggleButton();
38
jButton1 = new javax.swing.JButton();
39
40
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
41
setTitle("AUTO");
42
43
jPanel1.setBorder(javax.swing.BorderFactory.createBevelBorder(javax.swing.border.BevelBorder.RAISED));
44
45
jLabel1.setText("Patente");
46
47
jLabel2.setText("Color");
48
49
jLabel3.setText("Cantidad de Ruedas");
50
51
jLabel4.setText("Cantidad de Puertas");
52
53
javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
54
jPanel1.setLayout(jPanel1Layout);
55
jPanel1Layout.setHorizontalGroup(
56
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
57
.addGroup(jPanel1Layout.createSequentialGroup()
58
.addContainerGap()
59
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
60
61
.addComponent(jLabel1)
62
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
63
.addComponent(patente))
64
65
66
67
.addComponent(color))
68
69
70
71
.addComponent(cantRuedas, javax.swing.GroupLayout.PREFERRED_SIZE, 32,
javax.swing.GroupLayout.PREFERRED_SIZE))
72
73
74
.addGap(18, 18, 18)
75
.addComponent(cantPuertas)))
76
.addContainerGap(170, Short.MAX_VALUE))
77
);
78
jPanel1Layout.setVerticalGroup(
79
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
80
81
.addGap(30, 30, 30)
82
.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
83
.addComponent(patente, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
84
.addComponent(jLabel1))
85
.addGap(18, 18, 18)
86
87
88
.addComponent(color, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
89
.addGap(18, 18, 18)
90
91
92
.addComponent(cantRuedas, javax.swing.GroupLayout.PREFERRED_SIZE,



Pr

of.

La

ur

aN

ou

ss

an

Le
ttr

y

93
.addGap(18, 18, 18)
94
95
96
.addComponent(cantPuertas, javax.swing.GroupLayout.PREFERRED_SIZE,
97
98
);
99
100
jToggleButton1.setText("Crear Auto");
101
jToggleButton1.addActionListener(new java.awt.event.ActionListener() {
102
public void actionPerformed(java.awt.event.ActionEvent evt) {
103
jToggleButton1ActionPerformed(evt);
104
}
105
});
106
107
jButton1.setText("Ver Auto");
108
jButton1.addActionListener(new java.awt.event.ActionListener() {
109
public void actionPerformed(java.awt.event.ActionEvent evt) {
110
jButton1ActionPerformed(evt);
111
}
112
});
113
114
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
115
getContentPane().setLayout(layout);
116
layout.setHorizontalGroup(
117
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
118
.addGroup(layout.createSequentialGroup()
119
.addContainerGap()
120
.addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
121
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 49, Short.MAX_VALUE)
122
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
123
.addComponent(jToggleButton1, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
124
.addComponent(jButton1, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
125
.addGap(39, 39, 39))
126
);
127
layout.setVerticalGroup(
128
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
129
130
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
131
132
.addGap(36, 36, 36)
133
.addComponent(jToggleButton1)
134
.addGap(18, 18, 18)
135
.addComponent(jButton1))
136
137
.addContainerGap()
138
.addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)))
139
140
);
141
142
pack();
143 }// </editor-fold>
144
145 private void jToggleButton1ActionPerformed(java.awt.event.ActionEvent evt) {
146
auto = new
Auto(obtenerCadena(this.patente),obtenerCadena(this.color),obtenerEntero(this.cantRuedas),obtenerEntero(this.cantPu
ertas));
147 }
148
149 private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
150
151
JOptionPane.showMessageDialog(null,auto.mostrarDatos() , auto.soyUn(), 1);
152
153 }
154



Pr

of.

La

ur

aN

ou

ss

an

Le
ttr

y

155 /**
156
157
*/
158 public static void main(String args[]) {
159
/*
160
* Set the Nimbus look and feel
161
*/
162
//<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
163
/*
164
* If Nimbus (introduced in Java SE 6) is not available, stay with the
165
* default look and feel. For details see
166
* http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
167
*/
168
try {
169
for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
170
if ("Nimbus".equals(info.getName())) {
171
javax.swing.UIManager.setLookAndFeel(info.getClassName());
172
break;
173
}
174
}
175
} catch (ClassNotFoundException ex) {
176
java.util.logging.Logger.getLogger(CrearAuto.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
177
} catch (InstantiationException ex) {
178
179
} catch (IllegalAccessException ex) {
180
181
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
182
183
}
184
//</editor-fold>
185
186
/*
187
* Create and display the form
188
*/
189
java.awt.EventQueue.invokeLater(new Runnable() {
190
191
public void run() {
192
new CrearAuto().setVisible(true);
193
}
194
});
195 }
196 // Variables declaration - do not modify
197 private javax.swing.JTextField cantPuertas;
198 private javax.swing.JTextField cantRuedas;
199 private javax.swing.JTextField color;
200 private javax.swing.JButton jButton1;
201 private javax.swing.JLabel jLabel1;
205 private javax.swing.JPanel jPanel1;
206 private javax.swing.JToggleButton jToggleButton1;
207 private javax.swing.JTextField patente;
208 // End of variables declaration
209
210 // atributos que vienen de las clases
211
212 VehiculoTerrestre auto=null;
213 ///métodos propios
214 private int obtenerEntero(JTextField cadena) {
215 return Integer.parseInt(cadena.getText());
216 }
217 private String obtenerCadena(JTextField cadena){
218
return cadena.getText();
219 }
220
221 }


IMPORTANTE

Le
ttr

y

Casi todo el código ha sigo creado por NetBeans, en base al diseño que llevamos a cabo o la
configuración que hicimos de las propiedades y eventos que tienen o manejan los diferentes controles y
componentes Swing que agregamos al formulario. En particular el código que está sombreado con
color gris, no lo podemos modificar en forma directa, sólo cambiando las propiedades del control o
componente Swing, lo podemos modificar o bien eliminar.

El código que sí hemos añadido es el siguiente:
•

En la línea 212 hemos declarado la variable auto así:
VehiculoTerrestre auto=null;

•

De la línea 145/147: es un método que maneja el evento de pulsar el ratón o presionar Enter
sobre el primer botón, Crear Auto. La firma del método lo escribe automáticamente el
software y deja espacio para que nosotros lo configuremos.

an

Allí hemos ingresado el código necesario para poder crear el objeto Auto:
Auto = new Auto(obtenerCadena(this.patente),obtenerCadena(this.color),
obtenerEntero(this.cantRuedas),obtenerEntero(this.cantPuertas));
•

De la línea 149/153: es un método que maneja el evento del botón Ver Auto y el código que
hemos ingresado es compatible con el visto en el ejemplo anterior.

De la línea 214/219 hemos creado estos dos métodos que nos permiten convertir el
contenido de las variables de tipo JTextField (es decir, los cuadros de texto) a String o a int
ya que la clase Auto pasa a su clase madre, VehiculoTerrestre, dos atributos que son String y
dos atributos que son enteros.

ou

•

ss

JOptionPane.showMessageDialog(null,auto.mostrarDatos(), auto.soyUn(), 1);

of.

La

ur

aN

A continuación se muestra la ejecución del programa (el único archivo que es ejecutable es el
formulario):

Pr

Figura 7: ingresando los datos de un auto para luego apretar el botón CrearAuto


ss

an

Le
ttr

y


ou

Figura 8: Una vez creado el auto pulsamos el botón VerAuto para ver los datos.

aN

Todo sin modificar una sola línea de las clases que resuelven el problema!! ¿por qué? Pues
porque ese problema es resuelto por estas cinco clases que en conjunto representan el algoritmo. En
cambio, cómo se capturan los datos, con qué y todo el manejo de eventos puede ser gestionado por un
JFrame, por un Applet, por un Jsp, etc.

Creación de una conexión con la API JDBC. Aplicación de SQL-DML a través
de Java
En la primera y segunda parte hemos visto qué es un RDBMS y cómo se puede diseñar el modelo de
datos y cómo se puede convertir en un diseño físico a través de SQL para crear una base de datos
relacional.

ur

La cuarta parte abarcará aspectos conceptuales y prácticos del API JDBC que nos permite conectarnos,
mediante la plataforma java, a cualquier RDBMS que haya implementado esta API.

La

El BrowserSQL que utilizamos para crear las bases de datos vistas con anterioridad se basa en esta API,
por eso mismo se pueden no sólo realizar las conexiones a la base de datos, sino aplicar directamente el
lenguaje SQL tanto DML como DDL.
Lo que se intenta ahora es mostrar cómo crear una conexión JDBC y cómo devolver una consulta sobre
una o más tablas del RDBMS. Ya sabemos, al haber utilizado el BrowserSQL, que JDBC crea un objeto
que es la conexión misma y necesita dos cosas básicas: a) el Driver (que el programa lo busca en forma
automática) y la cadena de conexión con el usuario y su contraseña.

of.

O sea, por un lado necesitamos crear un objeto conexión, que tendrá un objeto Connection, que
pertenece al API JDBC. Así mismo este objeto tiene otros objetos, por ejemplo un objeto Statement que
sirve para ejecutar setencias SQL y un objeto ResultSet que devuelve los datos de una consulta. Un
objeto Statement sirve tanto para utilizar SQL DDL como SQL DML, el ResultSet devuelve los datos de
una consulta,

Pr

Con esta API se puede hacer mucho más de lo que vamos a ver aquí: vamos a crear una clase base
Conexión con un atributo Connection y vamos a mostrar el resultado de una consulta. Por ahora nada
más.



Pr

of.

La

ur

aN

ou

ss

an

Le
ttr

1 package toi_conexion;
2
3 import java.awt.HeadlessException;
4 import java.sql.Connection;
5 import java.sql.DriverManager;
6 import java.sql.ResultSet;
7 import java.sql.SQLException;
8 import java.sql.Statement;
9 import java.util.logging.Level;
10 import java.util.logging.Logger;
12 /**
14 * esta clase maneja la conexión en el nivel más bajo.
15 * Se necesitan importar los paquetes java.sql más importantes
16 * del API JDBC
17 */
18 public class Conexion {
19 //atributos con los que vamos a crear un objeto Connection
20 private Connection conn=null;//variable que maneja la conexion
21 //constructor
22 public Conexion(String driver, String cadena, String usuario, String clave){
23
//primero setear el Driver
24
//pero tenemos que usar excepciones, no hay otra
25
try{
26
String controlador = new String(driver);
27
Class.forName(controlador).newInstance();
28
//si ya tenemos el controlador instanciado podemos crear la conexión
29
try{
30
conn=DriverManager.getConnection(cadena,usuario,clave);
31
JOptionPane.showMessageDialog(null,"Conectado!!","Información",1 ) ;
32
33
}//fin try por conexion ya establecido el driver
34
catch (SQLException | HeadlessException e){
35
String mensajeExcepcion="Error al realizar la Conexión: n"+
36
e.getMessage()+
37
"nLocalización: "+
38
e.getLocalizedMessage();
39
JOptionPane.showMessageDialog(null,mensajeExcepcion,"Excepción !!",1 ) ;
40
}
41
}//fin try por Driver
42
catch(ClassNotFoundException | InstantiationException | IllegalAccessException e){
43
String mensajeExcepcion="Error al cargar el controlador: n"+
44
e.getMessage()+
45
"nLocalización: "+
46
47
JOptionPane.showMessageDialog(null,mensajeExcepcion,"Excepción !!",1 ) ;
48
}
49 }//fin constructor
50 public void Desconectar(){
51
try {
52
if(conn != null){
53
conn.close();
54
String mensaje="Desconectado!!";
55
JOptionPane.showMessageDialog(null,mensaje,"Información",1 ) ;
56
}//fin if
57
}//fin try
58
catch (SQLException | HeadlessException e){
59
String mensajeExcepcion="Error al Desconectar: n"+
60
e.getMessage()+
61
"nLocalización: "+
62
63
JOptionPane.showMessageDialog(null,mensajeExcepcion,"Excepciñon !!",1 ) ;
64
65
}//fin catch
66 }//fin método Desconectar()

y

Archivo Conexión.java


Le
ttr

public String mostrarSQL(String cadena){
String miConsulta="";
try {
Statement sql = conn.createStatement(); //se crea un Statement para la conexión
sql.executeQuery(cadena); //se ejecuta la consulta
ResultSet r=sql.getResultSet(); //se obtiene el resultado de la consulta
String tupla[]= new String [2];//para tomar los datos del resultset

while (r.next()){
tupla[0]=r.getString("idmateria");
tupla[1]=r.getString("nom_materia");
miConsulta=miConsulta+"n"+
tupla[0]+" | "+tupla[1];
}//fin while
//ahora agregamos los titulos al comienzo de la cadena
miConsulta=titulos[0]+" | "+titulos[1]+"n"+
miConsulta;

an

String titulos[]= new String[2];//para mostrar los títulos de la consulta
titulos[0]="Id materia";
titulos[1]="nom_materia";

}//fin try
catch (SQLException ex) {
Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE, null, ex);
}
return miConsulta;
}//fin método mostrarSQL()

ss

67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

y


La explicación del código es la siguiente:

ou

Como podemos apreciar en varias partes del código se ha tenido que utilizar excepciones. Cualquier
conexión y operaciones SQL requerirán siempre del uso de excepciones, por lo general SQLException del
paquete java.sql.Exception.

aN

El constructor crea un objeto Conexión cuyo único atributo es una variable de tipo Connection de la
API JDBC. Como puede verse en el código hay un bloque TRY anidado dentro de otro. Esto es porque lo
primero que hay que hacer es establecer el Driver JDBC con el que se quiere conectar. La clase del Driver
depende del RDBMS con el que nos vamos a conectar. Si este bloque faya, directamente se lanza la
excepción y no se crea la conexión. Si este bloque TRY es exitoso se pasa al siguiente bloque TRY donde
se pasan las variables necesarias para establecer la conexión con el RDBMS. Si no se puede establecer la
conexión, entonces se ejecuta el bloque CATCH que captura la Excepción SQL.
El método desconectar() es simple de entender: si existe la conexión, pues la desconecta.

ur

El método mostrarSQL(String cadena) trabaja sobre dos objetos diferentes del objeto conn, que es
de tipo Connection:

La

1. Ejecutar la sentencia SQL mediante un objeto Statement (es un objeto el objeto
Connection), y
2. Consultar al objeto ResultSet (también otro objeto de un objeto Connection) y con él
construir una cadena que es devuelta para su posterior tratamiento. Veremos que la
cadena se usa después en el runtime.
El archivo runtime o aplicación que hemos creado se llama TOI_conexion y no utiliza formularios sino sólo
código.

of.

Archivo TOI_conexion.java

Pr

1 package toi_conexion;
3
4 /**
5 * Runtime para conectarse a dos DBMS utilizando la clase Conexion.java
7 */
8 public class TOI_conexion{
9 /**
10
11
*/



ou

ss

an

Le
ttr

y

13 //variables para los drivers de ambos RDBMS
14 String driverMySQL ="com.mysql.jdbc.Driver";
15 String driverSQLServer ="com.microsoft.sqlserver.jdbc.SQLServerDriver";
16 //cadenas de conexion al servidor y puerto de cada RDBMS para conectarse a Escuela
17 String cadenaMySQL ="jdbc:mysql://localhost:3306/escuela";
18 String cadenaSQLServer ="jdbc:sqlserver://localhost:1433;databaseName=escuela";
19 //cadenas de nombre de usuario
20 String usMySQL="root";
21 String usSQLServer="sa";
22 //cadena de la contraseña
23 String claveMySQL="lacontrasenia";
24 String claveSQLServer="lacontrasenia";
25 //la consulta que vamos a hacer en los 2 DBMS es
26 String consulta="SELECT * FROM MATERIAS";
27
28 //conectarse a MySQL
29 Conexion mysql = new Conexion(driverMySQL,cadenaMySQL,usMySQL,claveMySQL);
30 String resultadoMySQL=mysql.mostrarSQL(consulta);
31 JOptionPane.showMessageDialog(null,resultadoMySQL,"Consulta Materias en MySQL!",1 ) ;
32
33 //conectarse a SQLServer
34 Conexion sqlserver = new Conexion(driverSQLServer,cadenaSQLServer,usSQLServer,claveSQLServer);
35 String resultadoSQLServer=sqlserver.mostrarSQL(consulta);
36 JOptionPane.showMessageDialog(null,resultadoSQLServer,"Consulta Materias en SQL Server!",1 ) ;
37
38 //AHORA DESCONECTAMOS
39 mysql.Desconectar();
40 sqlserver.Desconectar();
41 }//fin main

aN

El código está explicado en el mismo programa.
Para ejecutarlo directamente en otro equipo, pues
se deben cambiar los valores de las cadenas de
conexión, la cadena de usuario y la contraseña. La
cadena del Driver no es necesario cambiarla.

ur

Otro aspecto importante es que en NetBeans
debemos seleccionar las librerías JDBC para cada
driver, como se aprecia en la imagen. En el
BrowserSQL en la carpeta Lib, se encuentran los
drivers JDBC de estos dos DBMS; o bien se puede
bajar el de SQL Server desde la web ya que el de
MySQL viene dentro del paquete Java, pero hay
que linkearlo en la carpeta Libraries del proyecto.

Figura 9: no olvidar los Drivers JDBC o librerías
necesarias

Pr

of.

La

En la figura 10 se muestra la salida del programa
cuando es ejecutado.

Figura 10: el programa muestra los datos de la tabla Materias


Pr

of.

La

ur

aN

ou

ss

an

Le
ttr

y



POOABD (POO Aplicada a B Datos) - API JDBC - Parte 1

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (8)

Ähnlich wie POOABD (POO Aplicada a B Datos) - API JDBC - Parte 1

Ähnlich wie POOABD (POO Aplicada a B Datos) - API JDBC - Parte 1 (20)

POOABD (POO Aplicada a B Datos) - API JDBC - Parte 1