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

PROGRAMACIÓN ORIENTADA A OBJETOS
PROGRAMACIÓN ORIENTADA A OBJETOS
APLICADA A BASES DE DATOS
APLICADA A BASES DE DATOS
Por
LAURA NOUSSAN LETTRY
JDBC – Java Database Connectiviy
Parte 1
Aviso Legal
El presente libro electrónico
se distribuye bajo
Attribution-NonCommercial-
NoDerivs 3.0 Unported
2013-2020

PROGRAMACIÓN III - POO APLICADA A BASES DE DATOS
ÍNDICE
JDBC (Java Database Connectivity) – 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. Formularios y Paquete Java Swing
4. Menús y Paquete Java Swing.
5. Aplicación Didáctica – Diferentes Vistas: Aplicación, Negocio y Datos.
Vista de Negocio: Clases Base
2
4
15
20
23
FUENTES Bibliográficas Consultadas
 Documentación Java en general:
 The Java tutorial: https://docs.oracle.com/javase/tutorial/
 Documentación sobre Swing:
 https://docs.oracle.com/javase/tutorial/uiswing/index.html
 API JDBC:
 https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/
 https://docs.oracle.com/javase/tutorial/jdbc/basics/
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
Parte 1 Lectura, trabajos y prácticas propuestas en el Website de la
Materia y autoevaluaciones disponibles en el aula virtual
(*): website de la materia: https://lnoussanl.org/javabd/
Profesora Lic. Laura Noussan-Lettry Página 1

JDBC - Java Database Connectivity – PARTE 1
INTRODUCCIÓN
Sería arriesgado abordar de lleno el estudio de JDBC (Java Database Connectivity) sin
repasar conceptos básicos del Paradigma de Programación Orientada a Objetos, y en
particular sin utilizar Java como lenguaje.
Este AṔ I de Java 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 paquete java.sql.
Asimismo en la actualidad está presente en los diferentes entornos o plataformas de
desarrollo: JavaSE, JavaME y JavaEE.
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 a
un nivel lógico. Lo importante es que la capa de aplicación que se utilice es independiente
de estas clases que son las que resuelven el problema. Es decir se puede encarar la
interfaz de aplicación con Swing, Jsp, Jfc, etc.
La imagen siguiente es un esquema de esto ya que trabajaremos con Swing. Las clases
base, son las indicadas en amarillo y configuran un nexo entre los formularios a nivel de
capa de aplicación y el middleware, desarrollado por nosotros, que permite gestionar la
complejidad de los datos en el nivel más bajo de esta estructura en lugar de hacerlo en el
nivel de la capa de aplicación.

1
1-
- NOCIONES BÁSICAS DE LA PROGRAMACIÓN ORIENTADA
NOCIONES BÁSICAS DE LA PROGRAMACIÓN ORIENTADA
A OBJETOS.
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.
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.
Las características de un lenguaje basado en el paradigma de programación orientado a objetos,
básicamente debe contar con los siguientes elementos:
1. 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
1. Una clase se define con atributos y métodos.
2. 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.
2. 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.
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:
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
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.
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.
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.
2
2-
- ¿QUÉ ES JAVA?
¿QUÉ ES JAVA?
Concepto. Diseño de Clases
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 mediante este apunte los distintos tópicos sobre Java y la POO. Así mismo para ahondar
en estos temas y otros que no se encaran en este apunte, como los tipos de datos en Java y las
estructuras de control de flujo, tienen que consultar la solapa Java del sitio web de la materia:
https://lnoussanl.org/javabd/java.php
Comenzaremos con un ejemplo básico, de diseñar una 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.
Entonces el primer paso para poder diseñar una clase es que tenemos que tener en cuenta el objeto del
mundo real que queremos diseñar.
Como atributos básicos de un persona pues podríamos considerar lo siguientes: 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, ya que la idea es que el ejemplo sea claro.
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.
Como una buena práctica de programación, en el curso, seguiremos estas sencillas reglas:
 El nombre de la clase siempre va en singular y la primera letra en mayúscula;
 Los atributos y métodos de las clases se escribirán con su primera letra en minúscula;
 Las clases que representen los objetos con los que trabajaremos compartirán un mismo
espacio, en principio, llamado paquete;
 Las clases además estarán escritas por separado en archivos *.java separados del archivo
que inicie el objeto llamado aplicación, con lo cual se garantiza la modularidad;
 Los nombres de los métodos, así como los nombres de las clases, deben ser significativos
de lo que representan;
 Los nombres de los métodos es importante que si son largos rompan la monotonía
intercalando mayúsculas. Por ejemplo getNombreMascota() indica claramente que el
método devuelve el nombre de la mascota, que es además fácilmente legible.
A continuación transcribo los archivos java originales que describen el problema planteado.
 Archivo Persona.java:
1 package javabd_ejemplo1;
2
3 /**
4 * @author Laura Noussan Lettry <laura@lnoussanl.org>
5 * @Name Persona
6 * @version 2020 18/06/2020 (package javabd_ejemplo1)
7 * version anterior:
8 * @version 2013 16/02/2013 (package toi_2013.ejemplo1)

9 */
10 public class Persona {
11 //atributos inicializados a sus valores por defecto
12 //ver tipos de datos
13 private String apellido="";
14 private String nombre="";
15 private String fecha_nac=" / / ";
16 private int documento=0;
17
18 //métodos
19 //constructor (ver por qué se usa la palabra this)
20 public Persona(String ape,String nom,String fecha, int doc){
21 this.apellido=ape;
22 this.nombre=nom;
23 this.fecha_nac=fecha;
24 this.documento=doc;
25 }
26 //métodos get (que nos devuelven información)
27 public int getDocumeto(){ return this.documento;}
28 public String getApellido(){return this.apellido;}
29 public String getNombre(){return this.nombre;}
30 public String getFechaNac(){return this.fecha_nac;}
31 //un método especial que devolverá todos los datos de un objeto
32 //ojo porque no devuelve el objeto en sí.
33 public String mostrarDatos(){
34 return "Los datos de la Persona son:n "
35 + "Apellido: "+this.apellido+
36 "n Nombre: "+this.nombre+
37 "n Fecha de Nacimiento: "+this.fecha_nac.toLowerCase()+
38 "n Documento: "+this.documento;
39 }
40 //método que devuelve un objeto Persona
41 public Persona getPersona(){return this;}
42 }//fin clase Persona
Este ejemplo es un poco más elaborado que el que figura en el sitio web simplemente porque por
ejemplo al crear las variables de clase las inicializamos con un valor por defecto, lo cual es recomendable
realmente.
Además, si bien no es estrictamente necesario, es conveniente utilizar la palabra reservada this (este) ya
que con la misma hacemos referencia al atributo o al método del objeto actualmente en ejecución.
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 Persona ya que así ser organiza mejor el código y la modularidad.
 Archivo Ejemplo1.java
2 import javax.swing.JOptionPane;
3
4 /**
5 * @author Laura Noussan Lettry
6 */
7 public class JAVABD_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 Persona Maria = new Persona("Moreno","Maria","14/10/1998",44300200);
17 System.out.println(Maria.mostrarDatos());
18 }
19 }//fin clase Ejemplo1
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.
Además del constructor y los métodos get habituales, aquellos que devuelven el valor de un atributo,
también se ha diseñado el método mostrarDatos() que permite ver los datos de la persona.
Pero además de estos métodos get habituales y le método mostrarDatos() tenemos el método
getPersona() que lo que hace es realmente devolver un objeto de tipo persona en forma encapsulada.
En la clase Ejemplo1 podemos ver que se crean dos objetos Persona:
uno de los objetos lo hemos llamado Pedro y el otro Maria.
En el caso del objeto Pedro luego mediante un control JOptionPane (de la librería Swing de Java que
debemos importar) se muestran los datos en forma gráfica llamando al método mostrarDatos del objeto,
en este caso Pedro.
En el caso del objeto María también mostramos los datos pero mediante la sentencia System.out.println
que es uno de los métodos de Java que utiliza la salida estándar (la pantalla) pero en modo texto.
Si se corre el programa veremos lo siguiente:
Figura 1: ejecución Ejemplo1.java
El programa primero muestra en modo gráfico los datos de Pedro y luego los de María en la salida
estándar modo texto de Netbeans.
Figura2: Proyecto Netbeans y carpetas
Navegamos por el sistema de archivos de Linux Mint para buscar el
proyecto Netbeans. Vemos que cuenta con varias carpetas, una
llamada dist. Esta carpeta contiene un archivo jar (archivo
empaquetado de java o un ejecutable java).
Mediante la terminal podemos ejecutar el ejemplo llamando al
archivo jar escribiendo la siguiente sentencia:
java -jar JAVABD_ejemplo1.jar

Figura 3: ejecución Ejemplo1:
La ejecución nos muestra primero los datos del objeto Pedro utilizando la interfaz gráfica Swing
Figura 4: sigue la ejecución de Ejemplo1.java:
Continúa la ejecución y ya no vemos la ventana gráfica pero sí la salida estándar con los datos del
objeto Maria.
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
Los calificadores de acceso son: 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.
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.
La siguiente tabla nos muestra el nivel de acceso a los miembros que permite cada calificador de acceso.
Niveles de Acceso
Siguiendo el tutorial de Oracle tenemos, para cada modificador, diferentes niveles de acceso:

Modificador Clase Paquete Subclase El mundo
public Sí Sí Sí Sí
protected Sí Sí Sí No
sin modificador Sí Sí No No
private Sí No No No
Fuente: https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html
 La primera columna indica que la misma clase tiene acceso a los miembros definidos con cierto
alcance; o dicho de otra forma, la clase tiene acceso a todos sus miembros independientemente
del tipo de modificador aplicado. Como se puede apreciar una clase siempre tiene acceso a sus
propios miembros.
 La segunda columna implica ponerse en un nivel superior al de la clase, si la clase en cuestión
forma parte de un paquete con otras clases, estas otras clases tendrán acceso a los miembros de
la clase excepto a aquellos que hayan sido calificados con private.
 La tercera columna nos indica las relaciones de herencia que en Java se establecen entre una
clase y sus clases hijas. En Java además una subclase sólo puede tener una clase padre o madre,
se mire como se mire, es una sola clase de la que hereda todos sus miembros y atributos. En
este caso las subclases tienen acceso a todos los miembros de la clase padre en la medida que el
alcance sea public o protected. Este caso también es válido si existen subclases definidas en otro
paquete.
 La cuarta columna indica que cualquier otra clase fuera del paquete, es decir de cualquier otro
lado, tendrá acceso a un atributo definido como public, motivo por el cual no es conveniente
utilizar este tipo de calificadores.
Los niveles de acceso nos afectan en dos formas:
 cuando utilizamos clases que provienen de otra fuente como por ejemplo las clases definidas en
la plataforma Java, que son externas a nuestra aplicación y por lo tanto el nivel de acceso
determinará cuáles miembros de dichas clases podrán ser utilizados por nuestras propias clases.
Este no es un tema menor ya que todo el mundo tiene acceso a esta información puesto que la
plataforma java es de código abierto;
 cuando escribamos nuestras clases tendremos que decidir qué nivel de acceso deberá tener cada
atributo y cada método.
¿Qué nivel de acceso elegir?
En esto lo mejor es elegir, siempre que sea posible, el nivel de acceso más restrictivo que tenga sentido
para un miembro en particular; es decir, usar el calificador private.
Esto puede resumirse diciendo que hay que evitar utilizar atributos con el calificador public, excepto
para el caso de constantes. Inclusive el uso de constantes públicas no es una buena idea para un
código en producción.
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
2
3 /**
5 * @Name Persona
9 */
10 class Persona {
11 //atributos inicializados a los valores por defecto
12 private String apellido="";
13 private String nombre="";
14 private String fecha_nac=" / / ";
15 private int documento=0;
16

17 //métodos
18 //constructores
19 Persona(){} //este constructor usará los valores por defecto
20 Persona(String ape,String nom,String fecha, int doc){
21 this.apellido=ape;
22 this.nombre=nom;
23 this.fecha_nac=fecha;
24 this.documento=doc;
25 }
26 //métodos get (que nos devuelven información)
27 int getDocumeto(){ return this.documento;}
28 String getApellido(){return this.apellido;}
29 String getNombre(){return this.nombre;}
30 String getFechaNac(){return this.fecha_nac;}
31 String mostrarDatos(){
32 return "Los datos de la Persona son:n "
33 + "Apellido: "+this.apellido+
34 "n Nombre: "+this.nombre+
35 "n Fecha de Nacimiento: "+this.fecha_nac.toLowerCase()+
36 "n Documento: "+this.documento;
37 }
38 //método que devuelve un objeto Persona
39 Persona getPersona(){return this;}
40 }//fin clase Persona
 archivo Ejemplo2.java
3
4 /**
5 *
7 */
8 class JAVABD_ejemplo2 {
9
10 /**
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(), "Mensaje 2",1 ) ;
19 //Ahora vamos a usar sólo la salida estándar con la persona Desconocida y con Martin:
20 System.out.println(Desconocida.mostrarDatos());
21 System.out.println(Martin.mostrarDatos());
22
23 }
24 }//fin clase Ejemplo2
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 Package.
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.
Pero también se muestra la ejecución mediante la salida estándar (la consola) con el método
System.out.println.

En la siguiente figura se muestra las dos ventanas y la salida estándar al ejecutar el programa desde
Netbeans. Lógicamente se puede utilizar la terminal como en el caso anterior si navegamos por el sistema
de archivos Linux hasta la subcarpeta Dist del proyecto.
Figura 5: ejecución de Ejemplo2.java
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
La HERENCIA es una de las relaciones que se pueden dar entre clases.
La herencia en Java es simple, es decir una clase sólo puede heredar de otra clase y no de muchas otras.
La clase hija hereda todos los miembros de la clase padre/madre, es decir, tanto
atributos como sus métodos, excepto el constructor o constructores que si bien son
métodos particulares, no se heredan.
Uno de los grandes aciertos de la herencia es que agiliza el desarrollo de software y evita repetir código
que ya está escrito; sin embargo ello no quiere decir que hay forzar la herencia así como así. En
realidad en cursos avanzados de Java se ven otras relaciones además de la herencia, como la agregación
y la composición.
Para que haya herencia en el código tiene que haber una relación que implique que la clase que hereda
tiene elementos de la clase padre o madre que 'naturalmente' hereda.
Un típico ejemplo sería que presentamos en la solapa Java del sitio web con la clase Vertebrado, la clase
Equino que hereda de Vertebrado y la clase Caballo que hereda de Equino.
En una palabra es posible decir que un equino es un vertebrado, un caballo es un equino y por lo tanto
también que un caballo es un vertebrado. La herencia en el ejemplo es natural, es decir, no está forzada
y de hecho no debería forzarse.
Pero para entender bien qué la herencia vamos a crear una clase llamada VehiculoTerrestre, y otras
cuatro clases más llamadas Auto, Moto, Carreta y Cuatriciclo.
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 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.
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!!. Este es un ejemplo muy claro para comprender qué es 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!!
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
 Archivo VehiculoTerrestre.java
2
3 /**
5 * @Name Persona
9 */
10 public class VehiculoTerrestre {
12 protected String patente="";
13 protected String color="";
14 protected int ruedas=0;
15 protected boolean techo=false;
16 //métodos
17 //constructor
18 public VehiculoTerrestre(String pat, String col, int ruedas,boolean techo){
19 this.patente=pat;
20 this.color=col;
21 this.ruedas=ruedas;
22 this.techo=techo;
23 }
24 public String getPatente(){
25 return this.patente;
26 }
28 return "Patente: "+getPatente()+"n Color: "+this.color+
29 "n Cantidad de Ruedas: "+this.ruedas;
30 }
31 public String soyUn(){
32 String cadena;
33 switch (this.ruedas){
34 case 2://tanto la moto como la carreta tienen dos ruedas
35 if(this.patente.equals(""))
36 cadena = "Soy una CARRETA";
37 else
38 cadena="Soy una MOTO";
39 break;
40 case 3://no esta implementada esta clase
41 cadena ="Soy un TRICICLO";
42 break;
43 case 4://tanto el cuatriciclo como el auto tienen 4 ruedas
44 if(this.techo)
45 cadena = "Soy un AUTO";

46 else
47 cadena = "Soy un CUATRICICLO";
48 break;
49 default:
50 cadena = "SOY UN OVNI";
51
52 }//fin switch
53
54 return cadena;
55 }//fin soyUn()
56 }//fin clase VehiculoTerrestre
En cuanto a las clases hijas, las transcribimos a continuación:
 Archivo Auto.java
2
3 /**
5 * @Name Persona
9 */
10 public class Auto extends VehiculoTerrestre {
11 //atributos inicializados a los valores por defecto
12 private boolean motor=false;
13 private int puertas=0;
14 //métodos
15 //constructor
16 public Auto(String pat, String c, int r,int p){
17 super(pat,c,r,true);//suponemos que un auto tiene techo
18 this.motor=true;
19 this.puertas=p;
20
21 }
22 @Override//sobreescribe al mismo método con el mismo nombre de la clase madre
24 String cadena1 = super.mostrarDatos(); //va a mostrar los datos del vehículo
25 //esta es para los datos del auto
26 String cadena2="n tiene Motor: "+this.motor+
27 "n y tiene: "+this.puertas+" puertas.";
28 return cadena1+cadena2;
29 }
30
31 }//fin clase auto
 El archivo Moto.java
2
3 /**
5 * @Name Persona
9 */
10 public class Moto extends VehiculoTerrestre {
11 //atributos inicializados a su valor por defecto
13 //métodos
14 //constructor
15 public Moto(String pat, String col, int ruedas){
16 super(pat,col,ruedas,false);//una moto no tiene techo
17 this.motor=true;
18
19 }

22 String cadena1 =super.mostrarDatos(); //va a mostrar los datos del vehículo
23 //esta es para los datos de la moto
24 String cadena2="n tiene Motor: "+this.motor;
26 }
27
28 }//fin clase Moto
 El archivo Cuatriciclo.java
2
3 /**
5 * @Name Persona
9 */
10 public class Cuatriciclo extends VehiculoTerrestre {
13
14 //métodos
15 //constructor
16 public Cuatriciclo(String pat, String col, int ruedas){
17 super(pat,col,ruedas,false);//un cuatriciclo no tiene techo
18 this.motor=true;
19
20 }
24 //esta es para los datos del cuatriciclo
25 String cadena2="n y tiene Motor: "+this.motor;
27 }
28
29 }//fin clase Cuatriciclo
 El archivo Carreta.java
2
3 /**
5 * @Name Persona
9 */
10 public class Carreta extends VehiculoTerrestre {
11 //atributos inicializados a su valor por defecto
13 //métodos
14 //constructor
15 public Carreta(String col, int rue){
16 super("",col,rue,false);//la carreta no tiene techo y como no tiene patente pero
17 //la clase madre si lo tiene como atributo pasamos la cadena vacía
18 this.motor=false;
19
20 }
24 //esta es para los datos de la carreta

25 String cadena2="n tiene Motor: "+this.motor;
27 }
28 }//fin clase carreta
La palabra reservada this (este), como ya vimos, 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.
La palabra reservada super(argumentos) permite pasar al constructor de la clase madre los valores de
los atributos
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 se
redefine o se sobrescribe e método. Esto se indica con la siguiente cláusula: @Override (ver la línea de
código 20, 21 ó 22 según el archivo de las clases hijas)
Polimorfismo en Java
La palabra polimorfismo proviene de la biología e implica que una especie puede tener diferentes formas
o estados.
Aplicado a la POO quiere decir que una subclase puede tener un método con el mismo nombre que su
clase padre/madre y, sin embargo, presentar un comportamiento diferente. Esto es posible sólo con la
herencia, de modo tal que los métodos no interferirán entre sí. Es decir, es una consecuencia de la
herencia: lo que hemos visto en el ejemplo anterior con el método mostrarDatos.
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 este
calificador.
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.
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
3
4 /**
5 *
7 */
8 public class JAVABD_ejemplo3 {
9 /**
11 */
13
14 VehiculoTerrestre V1 = new Auto("GEP022","BLANCO",4,3);
15 VehiculoTerrestre V2 = new Moto("EWKJ36","ROJO",2);
16 VehiculoTerrestre V3 = new Carreta ("GRIS",2);
17 VehiculoTerrestre V4 = new Cuatriciclo ("AAIW77","AMARILLO",4);

18 JOptionPane.showMessageDialog(null,V1.mostrarDatos(),V1.soyUn(),1 ) ;
22 }
23 }//fin clase ejemplo3
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).
La salida del programa se muestra en la siguiente figura.
Figura 6: ejecución del programa Ejemplo3.java
Del ejemplo se puede concluir que:
 La herencia en Java se establece con la palabra reservada extends;
 Que la clase hija hereda todos los atributos y métodos de la clase madre/padre;
 Que no se hereda el constructor de la clase padre/madre, por ello los datos se pasan desde
constructor de la clase hija al constructor de la clase madre con la palabra reservada super;
 Que si queremos cambiar un método de la clase padre/madre en una clase hija (puesto que se
heredará) debemos utilizar la sobre-escritura de métodos (se indica con la palabra reservada
@Overide).
Además de este ejemplo que pude descargarse desde el sitio web, también en la solapa Java del sitio
web hay más ejemplos de herencia se presentan en forma incremental con Videos y Código fuente.
3- Formularios y Paquete Java Swing.
3- Formularios y 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 la base de datos 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. O sea, la vista de aplicación
involucra a los formularios y utilizaremos el paquete Java Swing.
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 estas
clases (que podríamos llamar, clases base ya que son las que resuelven el problema) de otra manera,
por ejemplo mediante interactiva y visual.
La Clase runtime será un JFrame que nos permitirá crear los distintos objetos con el fin de crear un
Auto, una carreta u otro vehículo terrestre. Esto nos servirá como ejemplo inicial de cómo trabajar con
los formularios Java ya que el objetivo final es conseguir la estructura que simboliza la imagen de la
Introducción.

En la siguiente imagen se puede apreciar la estructura del Proyecto y del formulario JFrame
JFrame
Figura 7: JFrame del programa Ejemplo4.java
En la izquierda podemos ver que tenemos el formulario ejecutable o runtime que es el JFrame, debajo
tenemos la Navegación de los componentes que tiene el JFrame y a la derecha estamos viendo la vista
Diseño de dicho formulario (estamos posicionados sobre el JFrame). Es importante notar que el JFrame
tiene una vista de Código o Source que nos permitirá agregar código Java propio.
La vista de diseño del formulario es fundamental ya que nos permite diseñar el formulario siguiendo las
buenas prácticas, lo que se puede apreciar en la Navegación (Navigator) debajo a la izquierda.
De esta estructura podemos ver que el Formulario tiene un contenedor JDesktopPanel que hemos
llamado JDesktopPanelVehiculos (que es el nombre de variable del contenedor) y que está contenido
dentro del JFrame.
Pero además, dentro del JDesktopPanel tenemos otros objetos que están contenidos en éste: 1 JLabel y 4
JButton. En todos los casos hemos utilizado nombres de variables que indican qué tipo de clase Java
estamos usando:
 al JLabel lo hemos llamado o le hemos designado un nombre de variable significativo: rotInfo
 a cada botón (clase JButton) le hemos designado un nombre que empieza con un nemotécnico
(que viene en realidad de la programación basada en objetos de Visual Basic donde ya
aseplicaban hacer rato las buenas prácticas):btn. Entonces btnAuto es el nombre del variable del
botón a nivel código que gestionará el objeto Auto, el btnMoto el objeto Moto, etc.
¿Pero cómo se gestionaran esas clases base, por ejemplo Auto? A través de un formulario interno que
estará contenido dentro del JFrame en tiempo de ejecución: GesAuto. Este formulario no es ejecutable y
la clase se llama JinternalFrame.
JInternalFrame

Figura 8: JInternalFrame de GesAuto del programa Ejemplo4.java
Como podemos apreciar tenemos la solapa de Proyectos y de Navegación del lado izquierdo y del derecho
la vista diseño del formulario interno
Podemos apreciar en la ventana Navigator que el formulario interno tiene dos componentes o clases Java
que son contenedoras: 2 paneles (clase JPanel). Cada uno de dichos paneles tiene sus propios
elementos.
Según el constructor Auto de la clase base, pues necesitamos 4 atributos, motivo por el cual necesitamos
cuatro cuadros de texto con sus correspondientes labels.
Por ejemplo los cuadros de texto donde el usuario ingresará los datos (JTextField) les hemos asignado
nombres de variables acordes a lo que representan y lo mismo los botones (JButton). Los rótúlos sin
embargo no tienen dicho criterio lo cual puede ser un problema. Se han dejado así para que vean que a
medida que vamos arrastrando los elementos dentro de la vista de Diseño Netbeans les va colocando un
nombre de variable equivalente al nombre de la clase y numerándolos en forma correlativa (lo mismo
que hacía Visual Basic, realmente). Esto digamos que con un rótulo no es tal vez tan grave, pero sí con
un botón ya que al programar es importante mantener la lógica y las buenas prácticas para reconocer las
variables directamente por su nombre. Como por lo general no programamos los rótulos, no es
significativo pero si lo quisiéramos hacer el nombre de variable JLabel3 no nos dice nada realmente.
Lo que sí debe quedar claro aquí es que las clases originales, las clases base, no se modifican
para nada!!!.
Vista de Diseño y de Código – Ventana Propiedades
Del lado derecho tenemos las propiedades del elemento. Por ejemplo si nos posicionamos sobre el cuadro
de texto de la Patentente (TextField) tiene un nombre de variable: patente y un tipo de acceso: private.
Esto se puede ver en Propierties (solapa Code). Pero lo cierto es que el tipo de acceso lo coloca NetBeans
por omisión. Lo mismo hace con el nombre de variable también lo coloca por omisión (JTextField1,
JTextField2,…., JTextFieldN) pero, nosotros como programadores pues tenemos que cambiado para que
sea coherente con el dato que queremos manipular… o sea, aplicar las buenas prácticas.

Figura 9: Ventana de Propiedades de GesAuto del programa Ejemplo4.java
En definitiva existen varias maneras de cambiar el nombre de variable de un elemento que vamos a
codificar o manipular, también mediante las opciones de código que tiene la ventana de Propiedades.
Lógicamente ampliaremos en clase todas estas posibilidades. Si es importante entender que cuando
trabajamos con la vista de diseño arrastrando componentes a un JFrame o a un JInternalFrame,
Netbeans escribe el código fuente con nombres por omisión de variables y que los podemos modificar
usando la vista de diseño pero no la vista de código (Source) ya que todo lo que figura en fondo gris no
es posible modificar, como se puede apreciar en la siguiente figura.
Figura 10: Source (vista de código) de GesAuto del programa Ejemplo4.java
Estamos en la vista de código de GesAuto (JInternalFrame) y al final de la clase. Como se podemos
apreciar los nombres de variables y el acceso están sombreados en gris, no son modificables por código
sino desde la vista de diseño. El código de más abajo, si lo hemos agregado ya que se puede (fondo
blanco) y es necesario contar con la variable VehiculoTerrestre (clase base) y los métodos que
necesitamos ya que los cuadros de texto, que no son textos equivalentes al String de Java, no nos larguen
error. Ciertamente es necesario convertirlos a String, int, short, etc; o sea al tipo de datos que necesitamos
para que no nos de errores en tiempo de ejecución, más todavía cuando trabajamos con bases de datos.

Corriendo la aplicación: se ve que es un MDI, puedo tener ambos formularios internos abiertos y contenidos.
Ahora minimizando el formulario GesMoto lo vemos minimizado dentro de la App. Al usar formularios MDI
es fundamental no olvidarnos de los nombres que el ve el usuario de los formularios ni de los botones
minimizar, maximizar o cerrar.
Figuras 11 y 12: corriendo la aplicación

4- Menús. Paquete Java Swing
4- Menús. Paquete Java Swing
Como ya se expresó, el objetivo de la materia es gestionar bases de datos con Java mediante el API
JDBC. Para ello es necesario manejar bien los objetos entre los que está el Menú, el cual no es un tema
menor.
La creación de Menús es sumamente fácil e intuitiva con la librería Java Swing. El aspecto de crear una
Aplicación MDI es un poco más complicado, pero no mucho más!. Hay que recordar, que una aplicación
MDI (Interfaz Múltiple de Documentos) es aquella que contendrá todos los formularios dentro de ella
misma.
Utilizaremos la aplicación didáctica como solemos hacer en clase. De hecho se ha usado antes el mismo
sistema cuando la materia se desarrollaba con Visual Basic, ya que las buenas prácticas son generales,
sin importar el software que utilicemos. Para orientarnos utilizaremos la siguiente imagen que describe la
arquitectura de software del Caso Guía de la Materia: Escuela.
Figura 13 Arquitectura de software del proyecto didáctico. Componentes y clases del Menú.
Para que sea intuitivo y fácil de usar hay que tener en cuenta que se actualizarán datos; es decir, que se
leerá y escribirán datos en la base de datos.
Entonces sabemos que debemos manejar 4 tablas: Alumnos, Materias, Localidades y Notas; por ende
tendremos menús para poder gestionar dichas tablas en forma separadas unas de otras. Además
debemos poder conectarnos a la aplicación, para lo cual se diseña un ítem de menú llamado DBMS. Este
ítem de menú, como los otros, tiene sub-items o sub elementos de menú. En este caso para poder
conectarnos o desconectarnos de la base de datos. En el caso de los otros ítems de menú como el
ejemplo que se puede apreciar: Materias, tiene dos sub-ítems: ABM Materias y Consultar Materias. Esto
significa que el primer sub-ítem llamará a un formulario que nos permitirá gestionar las Altas,
Modificaciones y Bajas; y en otro formulario las consultas. Este esquema se repite en los siguientes ítems
de menú.
El tema aquí importante es cómo nombrar los nombres de variables de los distintos componentes Java
Swing del Menú.
Los nombres de variables de todos los ítems de menú empiezan con mnu entonces así podemos
fácilmente reconocer el identificador dentro del código si necesitamos editarlo. La siguiente imagen
muestra la barra de Menú principal del formulario JFrame MDI del proyecto didáctico. Del lado izquierdo

pueden verse las clases del proyecto y más abajo el Navegador, como están todos los componentes del
menú expandidos pueden verse que todos los nombres de variable empiezan así. Además los nombres de
variables completos indican claramente qué hace el ítem de menú de que se trate.
Figura 14 Vista jerárquica del menú principal de la Aplicación Didáctica
La siguiente figura muestra el ítem de menú Alumnos en forma desplegada visualmente. Observar que a
su vez se selecciona el objeto en forma automática en el Navegador.
Ciertamente en las clases veremos cómo se crea fácilmente el Menú Principal de la aplicación.

Figura 15 El menú Alumnos expandido
Sí es importante ver cómo se crea el vínculo desde el ítem de menú al formulario que gestionará las ABM
de los Alumnos. Basta con hacer doble click sobre el ítem de menú ABM Alumnos (cuyo nombre de
variable es mnuAlumnosABM) o bien posicionándonos sobre el Navegador en dicha variable y con el
botón derecho del ratón seleccionar del menú contextual Eventos Action ActionPerformed
→ →
Este proceso hará que se cree el método correspondiente: Netbeans aúna los nombres de variables del
ítem de menú con el nombre por omisión del método. Entonces debemos concluir que el nombre de las
variables, siguiendo las buenas prácticas, es un tema relevante ya que está muy bueno que Netbeans
piense por sí mismo pero es más importante que el programador piense antes!! O sea, debemos tener
control sobre el código que desarrollamos y esto también tiene que ver con el diseño realmente.

Figura 16 Los nombres de las variables sí son importantes
El método que llamará al formulario que gestiona las ABM de los alumnos tiene un nombre bien
representativo: Netbeans une el nombre de variable del ítem de menú desde donde se llama
(mnuAlumnosABM) y le agrega el nombre por omisión del método (ActionPerformed), en definitiva el
método en cuestión se llama: mnuAlumnosActionPerformed.
La explicación del código dentro de dicho método es bien simple e intuitiva si recordamos que en Java
todo es un objeto.
Tenemos el formulario GesAlumnos.java (*) que es el que gestiona las ABM de los Alumnos y sabemos
que es también una clase: GesAlumnos, entonces la línea 176 lo que hace es crear el objeto GesAlumnos
dentro del MDI
GesAlumnos alu = new GesAlumnos(); //el nombre de variable del formulario es alu
La siguiente línea sí es relevante para que el JFrame de la aplicación (que es donde tenemos el memú)
sea realmente un formulario MDI. Entonces lo que hace es añadir el objeto alu al JdesktopPanel de la
aplicación:
JdesktopPaneEscuela.add(alu);
La última línea es para hacer visible el objeto: alu.setVisible(true);
5- Aplicación Didáctica –
5- Aplicación Didáctica – Diferentes Vistas: Aplicación, Negocio y
Datos. Vista de Negocio: Clases Base
Como ya se expresó, el objetivo de la materia es gestionar bases de datos con Java mediante el API
JDBC. Para ello es necesario manejar bien los objetos entre los que está el Menú, el cual no es un tema
menor, y los formularios. Pero en Java todo es un objeto, el menú y los formularios también y
ciertamente si la aplicación va a comunicarse con la base de datos es necesario recapitular el diseño de
las clases.
La imagen de la Figura 13 nos muestra la arquitectura. A nivel superior; es decir, a nivel de capa de
aplicación tenemos formularios diseñados con Swing. En una capa intermedia tenemos unas clases java
(las que tienen color amarillo) que son las clases base y en el nivel más bajo encontramos la base de
datos y el API JDBC.
O Sea, como adelanto de lo que sigue, baste decir que tenemos varias capas de software que son de
diferente nivel.
Lo que hemos vistos hasta ahora: el formulario principal con su menú y los formularios internos
constituyen la Vista de Aplicación ya que es lo que ve el usuario cuando ejecuta la aplicación.

La capa de más bajo nivel en el diagrama de la figura 13 es la Vista de Datos que está formada por la
base de datos en sí y el API-JDBC que veremos en el siguiente apunte ya que para esto es preciso
entender qué son las Excepciones en Java, entre otros temas.
La vista intermedia está formada por las Clases Bases y el Paquete Core formado por dos clases básicas:
Conexion y UsarConexion. Esta vista intermedia suele llamarse Vista de Negocio.
La vista de negocio es aquella que resuelve el problema, en nuestro caso, poder manipular una
base de datos mediante una aplicación Java. Para ello es necesario poder mapear las tablas,
objetos reales que son permanentes, en objetos de la aplicación.
Sin embargo, hay que aclarar que la vista de aplicación, es decir, las pantallas que verá el usuario, son
las que se comunican con éste y con los objetos java intermedios, que gestionan a las clases base de
java y a su vez cómo estas se comunican con objetos de bases de datos (conexión, sentencias,
resultados). En una palabra la Vista de Aplicación se comunica con la Vista de Negocio y ésta con la Vista
de Datos.
La pregunta lógica es ¿Cómo mapear las tablas de la base de datos a clases Java?
La forma profesional de hacerlo es modelando todo el problema mediante el Lenguaje UML (Unified
Modeling Language), pero esto excede el ámbito de nuestra materia. Baste decir que utilizando UML se
puede modelar todo el sistema mediante diferentes diagramas, uno de ellos el Diagrama de Clases.
Si bien no vamos a utilizar Diagramas de Clases, sí podemos tener en cuenta que una clase que
representa a una tabla, por lo menos debe tener los mismos atributos que la tabla. La clase como
plantilla podrá tener más atributos pero no menos que los que tenga la tabla a la cual estamos
“mapeando”. Lógicamente, una tabla no tiene métodos, pero una clase pues debe tenerlos, por lo menos
el constructor y métodos que nos permitan acceder a los atributos. Aquí hay que tener en cuenta todo lo
visto sobre calificadores de acceso.
El MER de la figura corresponde a nuestro ejemplo didáctico: la base de datos Escuela.
Figura 17: MER para la BD Escuela
En el MER podemos ver que tenemos 4 tablas y para hacer el Mapeo tendremos en cuenta los atributos
de cada una de ellas. Esto quiere decir que no sólo tenemos que tener en cuenta el MER sino también el
Diccionario de datos.
Hay que tener en cuenta el tipo de datos que usamos en cada tabla para encontrar una equivalencia con
los tipos de datos que usaremos en Java para que no tengamos problema cuando codifiquemos, motivo
por el cual también hay que tener en cuenta el Diseño Físico para MySQL que se muestra en la Figura 19.
A estas clases las llamaremos Clases Base.

Figura 18: diseño lógico – diccionario de datos de la BD Escuela
Figura 19: Diccionario de datos físico para MySQL
Iremos creando las Clases Base, que son las que mapean las tablas, y agregándolas al proyecto donde ya
tenemos la Vista de Aplicación.
Empezaremos por la tabla Materias que es la menos compleja. La clase base se llamará Materia.java (en
singular ya que creará un objeto Materia en memoria).

Para agregar crear una clase base al proyecto simplemente nos posicionamos sobre el paquete de la
aplicación (el paquete principal) y con el botón derecho del ratón seleccionamos (o buscamos) Nueva
Clase Java que lanzará un formulario que nos permite nombrar a la clase. Cambiamos NewClass por
Materia y luego apretamos el botón Finalizar
Figura 20: Crear nueva clase de código para la clase base Materia.java
Seguidamente mostramos el código de la clase Materia.java, Localidad.java, Alumno.java y Nota.java
que son las cuatro clases base que requiere la aplicación didáctica.
 Archivo Materia.java
1 package app_escuela_2020_vers1;
2
3 /**
4 *
6 * @Name Materia
7 * @Created ON 25/07/2016 (actualizado)
8 * @version 2019 18/09/2019 (actualizado)
10 * *****************************
11 * Clase base --> tabla Materias
12 * ********************************
13 */
14 public class Materia {
15 //atributos
16 private short idmateria;
17 private String nom_materia;
18 //métodos
19 //constructor base
20 public Materia(short id, String nom){
21 this.idmateria=id;
22 this.nom_materia=nom;

23 }//fin constructor
24 //constructor para clonar
25 public Materia(Materia mat){
26 this.idmateria=mat.idmateria;
27 this.nom_materia=mat.nom_materia;
28 }
29 //constructor que solo pasa el id de la mteria
30 public Materia(short id){
31 this.idmateria=id;
32 this.nom_materia=""; //valor por omisión, cadena vacía
33 }
34 //métodos get
35 //método para devolver la clave primaria
36 public int getId(){
37 return this.idmateria;
38 }
39 public String getNomMateria(){
40 return this.nom_materia;
41 }
42 //método para devolver todo el objeto ( 1 registro)
43 public Materia getMateria(){
44 return new Materia(this.idmateria,this.nom_materia);
45 }
46 //métodos set(para modificar algún dato cuando el objeto ya existe en memoria
47 //prácticamente no los usamos ya que tratamos de hacer una actualización glogal
48 //sobre el registro.
49 public void setIdMateria(short IdMat){ this.idmateria=IdMat;}
50 public void setNombreMateria(String nomMat){this.nom_materia=nomMat;}
51 }
 Archivo Localidad.java
2
3 /**
4 *
6 * @Name Localidad
10 * ********************************
11 * Clase Base --> tabla Localidades
12 * ********************************
13 */
14 public class Localidad {
15 //atributos básicos
16 private short idlocalidad;
17 private String nom_localidad;
18 private short cod_post;
19 //Constructor: las variables se pasan desde la clase gestionadora
20 public Localidad(short idLoc, String nom,short codPost){
21 this.idlocalidad=idLoc;
22 this.nom_localidad=nom;
23 this.cod_post=codPost;
24 }//fin constructor
25 //otro constructor para poder pasar un objeto ya construido
26 public Localidad(Localidad loc){
27 this.idlocalidad=loc.idlocalidad;
28 this.nom_localidad=loc.nom_localidad;
29 this.cod_post=loc.cod_post;
30 }
31 //constructor con un sólo parámetro: la clave primaria

32 public Localidad(short idLoc){
33 this.idlocalidad=idLoc;
34 }
35 //métodos get
36 //métodos para recuperar los atributos
37 public int getIdLocalidad(){
38 return this.idlocalidad;
39 }//fin método getIdLocalidad
40 public String getNomLocalidad(){
41 return this.nom_localidad;
42 }//fin método getNomLocalidad
43 public short getCodPost(){
44 return this.cod_post;
45 }//fin método getCodPost
46 //método para recuperar un objeto Localidad
47 public Localidad getLocalidad(){
48 return this;
49 }
53 public void setIdLocalidad(short idLoc){this.idlocalidad=idLoc;}
54 public void setNombreLocalidad(String nom){this.nom_localidad=nom;}
55 public void setCodigoPostal(short cod){this.cod_post=cod;}
56 }
 Archivo Alumno.java
2
3 /**
4 *
6 * @Name Alumno
10 * ********************************
11 * Clase Base --> tabla Alumnos
12 * ********************************
13 */
14 public class Alumno {
15 //atributos
16 private int dni;
17 private String apellido;
18 private String nombre;
19 private String fecha_nac;//las fechas se pueden manejar como cadenas, es mejor a veces
20 private String email;
21 private String telefono;
22 private String direccion;
23 private short idlocalidad;
24 //constructor: las variables son pasadas desde la clase gestionadora
25 public Alumno(int id, String a, String n, String f, String e, String t, String d, short loc){
26 this.dni=id;
27 this.apellido=a;
28 this.nombre=n;
29 this.fecha_nac=f;
30 this.email=e;
31 this.telefono=t;
32 this.direccion=d;
33 this.idlocalidad=loc;//tenemos que modificar la clase Localidad ya que nos conviene

34 //pasar todo el objeto encapsulado
35 }
36 //constructor alternativo para pasar un objeto ya creado
37 public Alumno(Alumno a){
38 this.dni=a.dni;
39 this.apellido=a.apellido;
40 this.nombre=a.nombre;
41 this.fecha_nac=a.fecha_nac;
42 this.email=a.email;
43 this.telefono=a.telefono;
44 this.direccion=a.direccion;
45 this.idlocalidad=a.idlocalidad;
46 }
47 //constructor sólo con un parámetro: la clave primaria
48 public Alumno(int dni){
49 this.dni= dni;
50 //los otros se deberían llegar con los valores por defecto
51 }
52 //métodos get
54 public int getDni(){
55 return this.dni;
56 }
57 public String getApellido(){
58 return this.apellido;
59 }
60 public String getNombre(){
61 return this.nombre;
62 }
63 public String getFechaNac(){
64 return this.fecha_nac;
65 }
66 public String getEmail(){
67 return this.email;
68 }
69 public String getTelefono(){
70 return this.telefono;
71 }
72 public String getDireccion(){
73 return this.direccion;
74 }
75 public short getLocalidad(){
76 return this.idlocalidad;
77 }
78 //método para recuperar un objeto Alumno
79 public Alumno getAlumno(){
80 return this;
81 }
85 public void setDNI(int doc){this.dni=doc;}
86 public void setApellido(String ape){this.apellido=ape;}
87 public void setNombre(String nom){this.nombre=nom;}
88 public void setFechaNac(String fe){this.fecha_nac=fe;}
89 public void setEmail(String mail){this.email=mail;}
90 public void setTelefono(String tel){this.telefono=tel;}
91 public void setDireccion(String dire){this.direccion=dire;}
92 public void setIdLocalidad(short loc){this.idlocalidad=loc;}
93 }

 Archivo Nota.java
2
3 /**
4 *
6 * @Name Nota
10 * ********************************
11 * Clase Base --> tabla Notas
12 * ********************************
13 */
14 public class Nota {
15 private int dni;
16 private short idmateria;
17 private float parcial_1;
18 private float parcial_2;
19 private boolean aprobado; /*se ha agregado este atributo*/
20
21 //constructor: variables pasadas desde la clase gestionadora
22 //constructor básico
23 public Nota(int idA, short idM, float uno, float dos,boolean apro){
24 this.dni=idA;
25 this.idmateria=idM;
26 this.parcial_1=uno;
27 this.parcial_2=dos;
28 this.aprobado=apro;
29 }
30 //constructor con dos párametros: porque la clave primaria es compuesta
31 public Nota(int idA,short idM){
32 this.dni=idA;
34 }
35 //constructor en caso que se pasen las notas
36 //el aprobado se calcula en forma automática con un método privado
37 public Nota(int idA,short idM,float uno, float dos){
38 this.dni=idA;
40 this.parcial_1=uno;
41 this.parcial_2=dos;
42 this.aprobado=calcular(uno,dos);
43 }
44 //constructor para clonar
45 public Nota(Nota n){
46 this.dni=n.dni;
47 this.idmateria=n.idmateria;
48 this.parcial_1=n.parcial_1;
49 this.parcial_2=n.parcial_2;
50 this.aprobado=n.aprobado;
51 }
52
53 //métodos get
55 public int getDNI(){
56 return this.dni;
57 }
58 public int getIdMateria(){

59 return this.idmateria;
60 }
61 public float getParcial_1(){
62 return this.parcial_1;
63 }
64 public float getParcial_2(){
65 return this.parcial_2;
66 }
67 public boolean getAprobado(){
68 return this.aprobado;
69 }
70 private boolean calcular(float parc1,float parc2){
71 if ((parc1+parc2)/2 >= 7)
72 return true;
73 else
74 return false;
75 }
76 //método para recuperar un objeto Nota
77 public Nota getNota(){
78 return this;
79 }
83 public void setDNI(int doc){this.dni=doc;}
84 public void setIdMateria(short idmat){this.idmateria=idmat;}
85 public void setParcial_1(float parc1){this.parcial_1=parc1;}
86 public void setParcial_2(float parc2){this.parcial_2=parc2;}
87 public void setAprobado(){
88 if((this.parcial_1+this.parcial_2)/2>=7)
89 this.aprobado=true;
90 else
91 this.aprobado=false;
92
93 }
94 }
Para poder entender cómo funciona el paquete Core es necesario ver primero el tema de las Excpeciones
que será enfocado en el siguiente capítulo.

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

Más contenido relacionado

La actualidad más candente

Similar a POOABD (POO Aplicada a B Datos) - API JDBC parte 1 -2020

Último

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