Memoria del curso de

JAVA en la AEPI
Luis Snchez Martn

Madrid, Agosto de 2016

Contenido
1.

Sobre programacin y lenguajes de programacin en general. ........................................... 3

2.

Aspectos bsicos de JAVA ..................................................................................................... 3

3.

Tipos de datos en JAVA ......................................................................................................... 4

4.

Conversiones de tipos ........................................................................................................... 6

5.

Operadores............................................................................................................................ 7

6.

7.

8.

9.

5.1.

Operador asignacin ..................................................................................................... 8

5.2.

Operadores aritmticos ................................................................................................ 8

5.3.

Operadores incrementales............................................................................................ 8

5.4.

Operadores de comparacin ......................................................................................... 9

5.5.

Operadores lgicos........................................................................................................ 9

5.6.

Operador condicional .................................................................................................. 10

Estructuras de control ......................................................................................................... 11

6.1.

Estructuras secuenciales ............................................................................................. 11

6.2.

Estructuras condicionales ........................................................................................... 11

6.2.1.

Condicional simple: ............................................................................................. 12

6.2.2.

Condicional doble: ............................................................................................... 13

6.2.3.

Condicional mltiple: .......................................................................................... 13

6.3.

Estructuras de decisin (switch) ................................................................................. 15

6.4.

Estructuras de repeticin (for, while, do-while) ......................................................... 17

6.4.1.

For ....................................................................................................................... 17

6.4.2.

While ................................................................................................................... 18

6.4.3.

Do-while .............................................................................................................. 19

Arrays .................................................................................................................................. 19
7.1.

Declarar un array ......................................................................................................... 20

7.2.

Crear un array.............................................................................................................. 20

7.3.

Inicializar y usar los elementos del array .................................................................... 20

7.4.

Arrays multidimensionales .......................................................................................... 21

7.5.

Arrays dinmicos (Vectores) ....................................................................................... 22

Programacin estructurada Arquitectura de proyectos JAVA ......................................... 23

8.1.

Clases ........................................................................................................................... 24

8.2.

Atributos...................................................................................................................... 24

8.3.

Mtodos ...................................................................................................................... 24

Programacin orientada a objetos ...................................................................................... 25

9.1.

Encapsulacin .............................................................................................................. 25

9.2.

Herencia ...................................................................................................................... 26

9.3.

Abstraccin.................................................................................................................. 29

9.4.

Polimorfismo ............................................................................................................... 29

10.

Estructuras de datos dinmicas ...................................................................................... 31

10.1.

ArrayList .................................................................................................................. 32

10.2.

LinkedList ................................................................................................................. 33

11.

Excepciones ..................................................................................................................... 36

11.1.

Bloque try ................................................................................................................ 36

11.2.

Bloque catch ............................................................................................................ 37

11.3.

Bloque finally ........................................................................................................... 37

11.4.

Excepciones ms comunes en JAVA ........................................................................ 37

12.

Ficheros (lectura y escritura) ........................................................................................... 39

13.

Bases de datos ................................................................................................................. 41

13.1.
13.1.1.

Sentencia SELECT................................................................................................. 41

13.1.2.

Sentencia INSERT................................................................................................. 42

13.1.3.

Sentencia DELETE ................................................................................................ 42

13.1.4.

Sentencia UPDATE ............................................................................................... 43

13.2.
13.2.1.
13.3.
14.

Instrucciones SQL en JAVA ...................................................................................... 43

Posicionamiento en un ResultSet ........................................................................ 44
Implementacin de sentencias SQL en nuestra aplicacin JAVA ............................ 46

Interfaces grficas de usuario (GUI: Graphic User Interface) ......................................... 48

14.1.
15.

Introduccin a instrucciones SQL ............................................................................ 41

GUIs en NetBeans................................................................................................... 50

Bibliografa ...................................................................................................................... 52

1. Sobre programacin y lenguajes de programacin en general.

Programar: Es dar instrucciones a una mquina mediante lenguaje
mquina.
Lenguaje mquina: Es el que conocemos como lenguaje binario (0s y
1s), pero resulta muy poco prctico para llevar a cabo directamente la
tarea de programar.

Ensamblador: es el lenguaje de programacin utilizado para escribir

programas informticos de bajo nivel, y constituye la representacin ms
directa del cdigo mquina especfico para cada arquitectura de
computadoras legible por un programador.

Lenguaje de alto nivel: Es un lenguaje con instrucciones ms cercanas

al lenguaje humano. JAVA es uno de este tipo de lenguajes.

Compilar: Es traducir de un lenguaje de alto nivel al cdigo binario. Al

compilar, JAVA no genera un archivo ejecutable (.exe); sino que genera
un cdigo intermedio entre ambos que queda almacenado en un fichero
con formato .class.

La medida en que un lenguaje de programacin sea de alto nivel

determina como de rpido o de lento es en tiempo de ejecucin. Por
ste motivo, JAVA es (relativamente) lento en ese sentido.

2. Aspectos bsicos de JAVA

Compilar y ejecutar en JAVA en modo consola:
-

Para compilar se utiliza javac NombreArchivo.java

Para ejecutar se escribe java NombreArchivo

El mtodo main es el punto de acceso e inicio de nuestro programa.

El nombre de nuestra clase debe coincidir con el nombre del

archivo.java en que se encuentre.
Para imprimir podemos usar la funcin print y tambin println (esta ltima
introduce un salto de lnea.
Soporta comentarios de varios tipos:
-

// para comentarios de una sola lnea.

/**/ para comentarios de varias lneas.

/**

* para que JAVA documente automticamente (JAVADOC)

*/

3. Tipos de datos en JAVA

Variables: datos que guardamos en memoria y como su nombre indica se

pueden modificar. Para aquellas que deban tener valor constante
utilizaremos la palabra reservada final.
Literales: Un literal es un valor constante formado por una secuencia de
caracteres. Cualquier declaracin en Java que defina un valor constante un valor que no pueda ser cambiado durante la ejecucin del programa- es
literal.
Para declarar las variables no pueden usarse caracteres especiales ni las
palabras reservadas del lenguaje JAVA. Adems, resulta conveniente que
sean representativos, y aunque no hay lmite de extensin, no es
recomendable que los nombres de las variables y literales sean
excesivamente largos.
Las palabras reservadas del lenguaje JAVA son las utilizadas para modelar
su sintaxis. En la tabla situada justo debajo se pueden ver dichas palabras
por orden alfabtico:

Tambin son importantes los caracteres especiales. Estos se escriben

como secuencias de escape. Algunos de los diferentes caracteres que se
pueden emplear en una expresin regular en JAVA son:
-

\n

coincide con el carcter de salto de lnea.

\f

coincide con el carcter de salto de forma.

\r

coincide con el carcter de retorno de carro.

\t

coincide con el carcter de tabulacin horizontal.

\v

coincide con el carcter de tabulacin vertical.

En JAVA hay dos tipos de datos: primitivos y String.

Los tipos de datos primitivos son boolean (true o false segn tablas de
verdad OR, AND, y XOR), char (caracteres ASCII Unicode); y numricos,
que pueden ser enteros (byte, short, int y long) y con precisin decimal
(float y double).
En la tabla situada justo debajo se ilustran los tipos de datos primitivos que
dispone JAVA.

El tipo String lo utilizamos para representar cadenas de caracteres. La

clase String proporciona numerosos mtodos para manipular dichas
cadenas de caracteres. En el siguiente fragmento de cdigo se pueden ver
algunos de ellos:

4. Conversiones de tipos

Si el tipo de dato al que queremos convertir es superior al que tenemos

actualmente (por ejemplo de un dato de 8 bits a uno de 32 bits) la
conversin no implicar ningn problema. En caso contrario s, debido a
posibles prdidas de precisin. Para su mejor comprensin se acompaa le
explicacin con el siguiente ejemplo:

byte v1 = 15;
short v2 = v1;
En el caso anterior el tipo short tiene una extensin mayor que la del tipo
byte, por lo que puede realizarse la conversin directamente.
float superficie = 5.72f; //los decimales por defecto son de tipo double; para
//indicar que son float se debe poner el carcter f al final.
int aproximacin = (int) superficie; //aproximacin vale 5
En este caso s hay prdida de precisin, por lo que es necesario emplear
un casting (ponemos entre parntesis el tipo de dato al que queremos
transformar y forzamos la conversin).
La operacin opuesta a la conversin requiere del uso de wrappers
(envoltorios). Cada tipo de datos dispone de uno de ellos (int -> Int;
float ->Float; double ->Double ).
Los wrappers proveen un mecanismo para que los tipos primitivos puedan
ser utilizados en operaciones reservadas para objetos. Tambin permiten
conversiones de tipos primitivos desde, y a objetos String.

5. Operadores

Un operador lleva a cabo operaciones sobre uno (operador unario), dos

(operador binario) o tres (operador ternario) datos u operandos de tipo
primitivo devolviendo un valor determinado tambin de un tipo primitivo. El

tipo de valor devuelto tras la evaluacin depende del operador y del tipo de
los operandos.
5.1.

Operador asignacin

Es el operador unario = y sirve, como su nombre indica, para asignar

un valor a una variable. En caso de asignar a una variable el valor de
otra (copia), es el valor situado a la derecha del operando el que se
asigna a la variable situada a su izquierda.
5.2.

Operadores aritmticos

Son operadores unarios y binarios que realizan operaciones sobre tipos

de datos numricos (en el caso del operador + tambin se utiliza para
concatenar cadenas de caracteres).

5.3.

Operadores incrementales

Son operadores unarios que realizan las operaciones de evaluar y

modificar una variable, o bien modificarla primero y evaluarla despus.
El orden de estas operaciones depende de la posicin (a la izquierda o a
la derecha de la variable) en que est situado el operando. En la tabla
situada debajo se pueden ver algunos ejemplos:

5.4.

Operadores de comparacin

Los operadores de comparacin son smbolos que se usan en JAVA

para efectuar una comparacin lgica: el resultado es verdadero o falso.
En la tabla de abajo que contiene los operadores lgicos, notar que el
radio de un crculo no puede ser negativo, de ah la lgica aplicada en
los ejemplos.

5.5.

Operadores lgicos

Se utilizan para construir las expresiones lgicas, combinando valores

lgicos (true y/ false) o los resultados de los operaciones relacionales.
En la siguiente tabla se detallan los operadores lgicos:

5.6.

Operador condicional

Es un operador ternario que devuelve (ver estructura debajo) una

expresin (expresin_1) si expresionLogica toma el valor de true, y
devuelve otra expresin (expresin_2) si expresionLogica toma el valor
de false.
expresionLogica ? expresin_1 : expresin_2
Ejemplos de operador condicional:
a=4;
b = a ==4 ? a+5 : 6-a; // b vale 9 (a+5) porque a vale 4
b =a >4 ? a*7 : a+8;// b vale 12 (a+8) porque a no es mayor de 4
Como se ver en el punto siguiente, el operador lgico puede modelarse
como una estructura condicional if-else:
if(expresionLogica)
valor = expresin_1;
else
valor = expresin_2;

10

6. Estructuras de control
Las estructuras de control determinan la secuencia de ejecucin de las
sentencias de un programa.
Las estructuras de control se dividen en tres categoras: secuenciales,
condicionales, de decisin y repetitivas.

6.1.

Estructuras secuenciales

Se ejecutan de arriba hacia abajo en secuencia, es decir, una detrs de

otra segn el orden en que aparezcan escritas en el programa. Cada
una de las instrucciones estn separadas por el carcter punto y coma
(;).
Las instrucciones se suelen agrupar en bloques. El bloque de sentencias
se define por el carcter llave de apertura ({) para marcar el inicio del
mismo, y el carcter llave de cierre (}) para marcar el final.
Ejemplo:
{
instruccin 1;
instruccin 2;
instruccin 3;
}
En Java si el bloque de sentencias est constituido por una nica
sentencia no es obligatorio el uso de las llaves de apertura y cierre ({ }),
aunque s recomendable.

6.2.

Estructuras condicionales

Las estructuras de control pueden ser del tipo:

-

Condicional simple: if

Condicional doble: if ... else ...

Condicional mltiple: if else if else

11

La condicin debe ser una expresin booleana es decir debe dar como
resultado un valor booleano (true false).

6.2.1. Condicional simple: se evala la condicin y si sta se cumple se

ejecuta una determinada accin o grupo de acciones. En caso
contrario se saltan dicho grupo de acciones.

if(expresin_booleana){
instruccin 1
instruccin 2
.......
}
Ejemplo:

A la vista del cdigo anterior, dado que la variable de tipo entero x

toma el valor 15, el resultado de la ejecucin ser la impresin por
pantalla de la frase esto es una sentencia if. En caso de que no se
cumpliera que x<30 no se imprimira nada por pantalla.

Si el bloque de instrucciones tiene una sola instruccin no es

necesario escribir las llaves { } aunque para evitar confusiones se
recomienda escribir las llaves siempre.

12

6.2.2.

Condicional doble: se evala la condicin y si sta se

cumple se ejecuta una determinada instruccin o grupo de

instrucciones. Si no se cumple se ejecuta otra instruccin o grupo de
instrucciones.

if(expresin booleana){
instrucciones 1
}
else{
instrucciones 2
}

Ejemplo:

En el cdigo mostrado, dado que el valor de la variable de tipo entero

x es 40, se ejecutar el cdigo que se encuentra dentro de la clausula
else dado que x no es menor que 10. El resultado de ejecutar el
programa ser la impresin por pantalla de la frase Esto es una
sentencia else.

6.2.3.

Condicional mltiple: se obtiene anidando sentencias if ...

else. Permite construir estructuras de seleccin ms complejas.

13

if (expresion_booleana1)
instruccion1;
else if (expresion_booleana2)
instruccion2;
else
instruccion3;

Cada else se corresponde con el if ms prximo que no haya sido

emparejado.
Una vez que se ejecuta un bloque de instrucciones, la ejecucin
contina en la siguiente instruccin que aparezca despus de las
sentencias if- else anidadas.

En el ejemplo que se muestra a continuacin primeramente se declara

y se asigna el valor 45 a la variable de tipo entero x. Despus se
procede a evaluar si el valor de x es 15; como no es as se pasa a
evaluar si x tiene valor 30; como de nuevo esa condicin no se
cumple, se pasa a evaluar si x=45. Al ser cierta esta condicin se
pasa a ejecutar el cdigo que se halla dentro de esta ltima condicin.

14

6.3.

Estructuras de decisin (switch)

Se utiliza para seleccionar una de entre mltiples alternativas.

La forma general de la instruccin switch en Java es la siguiente:

switch (expresin){
case valor 1:
instrucciones;
break;
case valor 2:
instrucciones;
break;

default:
instrucciones;
}

La instruccin switch (expresin) se puede usar con datos de tipo byte,

short, char e int y String. Tambin con las clases envolventes (wrappers)
Character, Byte, Short e Integer. Tambin pueden usarse datos de tipo
String en un switch.

Funcionamiento de la instruccin switch:

- Primero se evala la expresin y se salta al case cuya constante
coincida con el valor de la expresin.
Se ejecutan las instrucciones que siguen al case seleccionado hasta
que se encuentra un break o hasta el final del switch. El break produce
un salto a la siguiente instruccin a continuacin del switch.

15

 Si ninguno de estos casos se cumple se ejecuta el bloque default (si

existe). No es obligatorio que exista un bloque default y no tiene porqu
ponerse siempre al final, aunque es lo habitual y recomendable.
En java hay dos sentencias que nos permiten forzar la salida de un
case dentro de un switch (o de un bucle), y estas sentencias son
break (para salir completamente del bucle) y continue (para salir de la
iteracin actual y saltar directamente a la siguiente).

Ejemplo de uso de estructura switch:

16

Como se puede observar, dado el valor que se le asigna a la variable de

tipo char departamento, en el switch se va a ejecutar el cdigo que se
encuentra dentro del case B, es decir, que se imprimir por pantalla
Recursos Humanos.

6.4.

Estructuras de repeticin (for, while, do-while)

Una estructura de repeticin o bucle nos permite ejecutar un nmero de

veces determinado una serie de instrucciones. La mayor utilidad es
evitar la repeticin de lneas de cdigo iguales. Para salir del bucle, se
indica una condicin, si esa condicin no se cumple se sale del bucle.
Las estructuras de repeticin son:
6.4.1. For
Este tipo de bucle, adems de la condicin de finalizacin, incluye una
inicializacin de una variable y un incremento o decremento de la
misma. Cada parte se separa con un ; . NOTA: cuando salimos del
bucle, la variable inicializada no existe. Su sintaxis es:

for (inicializacin; condicin; incremento){

instrucciones;
}

En el siguiente ejemplo se muestra un bucle for en el que se cuentan e imprimen

nmeros desde el 1 hasta el que indiquemos en la variable numero.

En este caso se muestra un bucle for mejorado: se recorren los

elementos de un array cuyos elementos son los das de la semana
(de tipo String).

17

6.4.2. While
En la estructura de repeticin while indicamos una condicin que se
ejecutara hasta que la condicin sea falsa, es importante que la
variable que este en la condicin, vare para que no se produzca
un bucle infinito. Su sintaxis es:

while (condicion){
instrucciones;
}

Un ejemplo prctico de este bucle sera el siguiente:

En dicho ejemplo se pide al usuario un nmero que sea positivo, y se

le pedir reiteradamente mientras que el nmero que introduzca no
cumpla esa condicin.

18

6.4.3. Do-while
Esta estructura repetitiva, tiene una caracterstica especial y es que
como mnimo las instrucciones dentro de la estructura repetitiva se
ejecutarn al menos una vez, mientras que el while sus instrucciones
pueden ejecutarse 0 o N veces. Se sale del bucle cuando
la condicin del while no se cumple. Su sintaxis es:

do{
instrucciones;
}while(condicion);

En el bucle do-while mostrado en el ejemplo se debe generar un

nmero aleatorio comprendido entre 0 y un nmero entero que se
pasa a la funcin numeroPar por parmetro. Dicho nmero aleatorio
debe ser impar. El nmero aleatorio se generar tantas veces como
sea necesario hasta que cumpla esta ltima condicin.

7. Arrays
Un array es un instrumento que utilizamos para guardar un conjunto de
datos u objetos de la misma clase. Se accede a cada elemento individual
del array mediante un nmero entero denominado ndice. 0 es el ndice del
primer elemento y n-1 es el ndice del ltimo elemento, siendo n, la

19

dimensin del array. Los arrays son objetos en Java y como tales se deben
seguir varios pasos para usarlos convenientemente:

Declarar el array

Crear el array

Inicializar los elementos del array

Usar el array

7.1.

Declarar un array

Para declarar un array se escribe:

tipo_de_dato[] nombre_del_array;
Para declarar un array de enteros por ejemplo escribimos:
int[ ] numeros;

7.2.

Crear un array

Para crear un array por ejemplo de 4 nmero enteros escribimos:

numeros=new int[4];
La declaracin y la creacin del array se pueden hacer en una misma
lnea:
int[] numeros =new int[4];

7.3.

Inicializar y usar los elementos del array

Para inicializar el array de 4 enteros escribimos:

numeros[0]=2;
numeros[1]=-4;

20

numeros[2]=15;
numeros[3]=-25;
Se pueden inicializar en un bucle for como resultado de alguna
operacin
for(int i=0; i<4; i++){
numeros[i]=i*i+4;
}
No necesitamos recordar el nmero de elementos del array, su miembro
dato length nos proporciona la dimensin del array. Podemos escribir de
forma equivalente lo siguiente:
for(int i=0; i<numeros.length; i++){
numeros[i]=i*i+4;
}
Los arrays se pueden declarar, crear e inicializar en una misma lnea, del
siguiente modo
int[] numeros={2, -4, 15, -25};
String[] nombres={"Juan", "Jos", "Miguel", "Antonio"};
Para imprimir a los elementos de array nombres se escribe
for(int i=0; i<nombres.length; i++){
System.out.println(nombres[i]);
}
Java verifica que el ndice no sea mayor o igual que la dimensin del
array, de manera que si se intenta acceder a una posicin del array que
exceda de su longitud se producir un error.
7.4.

Arrays multidimensionales

21

Una matriz bidimensional puede tener varias filas, y en cada fila no tiene
por qu haber el mismo nmero de elementos o columnas. Por ejemplo,
podemos declarar e inicializar la siguiente matriz bidimensional:
double[ ][ ] matriz={{1,2,3,4},{5,6},{7,8,9,10,11,12},{13}};

La primer fila tiene cuatro elementos {1,2,3,4}

La segunda fila tiene dos elementos {5,6}

La tercera fila tiene seis elementos {7,8,9,10,11,12}

La cuarta fila tiene un elemento {13}

Para mostrar los elementos de este array bidimensional escribimos el
siguiente cdigo:
for (int i=0; i < matriz.length; i++) {
for (int j=0; j < matriz[i].length; j++) {
System.out.print(matriz[i][j]+"\t");
}
System.out.println("");
}
Como podemos apreciar, matriz.length nos proporciona el nmero de
filas (cuatro), y matriz[i].length, nos proporciona el nmero de elementos
en cada fila.
Mostramos los elementos de una fila separados por un tabulador usando
la funcin print. Una vez completada una fila se pasa a la siguiente
mediante println.

7.5.

Arrays dinmicos (Vectores)

Los arrays en Java son suficientes para guardar tipos bsicos de datos,
y objetos de una determinada clase cuyo nmero conocemos de
antemano. Sin embargo, algunas veces deseamos guardar objetos en
un array pero no sabemos cuntos objetos vamos a guardar. Una
solucin es la de crear un array cuya dimensin sea ms grande que el
nmero de elementos que necesitamos guardar. Pero con este

22

procedimiento somos ineficientes en lo que a gestin de memoria se

refiere
La clase Vector nos proporciona una solucin alternativa a este
problema. Un vector es similar a un array, la diferencia estriba en que un
vector crece automticamente cuando alcanza la dimensin inicial
mxima. Adems, proporciona mtodos adicionales para aadir, eliminar
elementos, e insertar elementos entre otros dos existentes.
En la imagen abajo se ilustra una clase en JAVA que implementa un
Vector:

Como se puede ver, mediante el mtodo addElement() aade un nuevo

elemento al Vector, mientras que el mtodo removeElement() lo borra.
Tambin se puede insertar indicando la posicin en la que deseamos
realizar la insercin mediante el mtodo insertElementAt().

8. Programacin estructurada Arquitectura de proyectos JAVA

23

8.1.

Clases

Una clase es la unidad bsica que encapsula toda la informacin de un

Objeto (un objeto es una instancia de una clase). A travs de ella
podemos modelar el entorno en estudio (una Casa, un Auto, una Cuenta
Corriente, etc). Para definir las clases utilizaremos el modificador public.
8.2.

Atributos

Los atributos o caractersticas de una Clase pueden ser de tres tipos,

segn su grado de comunicacin y visibilidad de ellos con el entorno:
public: Indica que el atributo ser visible tanto dentro como fuera de la
clase.
private: Indica que el atributo slo ser accesible desde dentro de la
clase.
protected: Indica que el atributo no ser accesible desde fuera de la
clase, pero si podr ser accedido por mtodos de la clase adems de las
subclases que se deriven.
8.3.

Mtodos

Los mtodos u operaciones de una clase son la forma en cmo sta

interacta con su entorno, stos pueden tener los siguientes
modificadores:
public: Indica que el mtodo ser visible tanto dentro como fuera de la
clase, es decir, es accesible desde todos lados.
private: Indica que el mtodo slo ser accesible desde dentro de la
clase (slo otros mtodos de la clase lo pueden acceder).
protected: Indica que el mtodo no ser accesible desde fuera de la
clase, pero si podr ser accedido por mtodos de la clase adems de
mtodos de las subclases que se deriven.

24

9. Programacin orientada a objetos

Ahora ya definido el concepto de Clase, es necesario explicar cmo se

pueden interrelacionar dos o ms clases. Para ello se procede a definir
cuatro conceptos fundamentales de la programacin orientada a objetos:
encapsulacin, herencia, abstraccin y polimorfismo.
9.1.

Encapsulacin

En JAVA, si las variables son pblicas (modificador public, o bien no

indicar modificador) pueden ser accedidas directamente a travs de una
instancia de la clase en la que estas se encuentran, sin que se produzca
error de compilacin alguno. Sin embargo, qu pasa si ingresamos un
valor que no se supone que debe de tener una variable (por ejemplo un
valor numrico cuando lo esperado es una cadena de caracteres)? En
estos casos, la nica manera de proteger el cdigo es escribiendo unos
mtodos que nos permitan regular los valores que cada variable puede
tener y escondiendo las variables para que no se pueda acceder a ellas
de manera directa, lo cual se conoce como el principio bsico de
encapsulamiento.

Si se desea flexibilidad, buen mantenimiento y extensibilidad, nuestro

diseo en el cdigo debe de incluir encapsulamiento, para ello debemos
de hacer lo siguiente:
1.

Mantener las variables de instancia protegidas haciendo uso de

los modificadores de acceso (private, protected).

2.

Hacer mtodos de acceso pblicos para forzar al acceso a las

variables por medio de dichos mtodos en lugar de acceder

directamente.
3.

Utilizar las convenciones de cdigo para los nombres de los

mtodos. Para el acceso al valor de la variable utiliza el mtodo

getNombre_Variable() y para la modificacin de dicho valor el mtodo
setNombre_Variable().

25

9.2.

Herencia

La herencia se define como la transmisin de los mtodos y atributos de

una clase (Padre) a otra (Hija). Es adems un mecanismo exigido a
cualquier lenguaje que pretenda ser orientado a objetos. Gracias a la
herencia se pueden establecer jerarquas entre clases. En concreto, La
herencia nos permite definir una jerarqua en la que existirn clases
padre y clases hijo, pudiendo ser una clase padre de otra clase, e hijo de
otra clase a la vez. No deben definirse jerarquas de herencia en la que
una clase sea padre e hijo de la misma clase.
En la imagen abajo se ilustra un ejemplo mediante un diagrama para su
mejor comprensin:

En la figura se especifica que Auto y Camin heredan de Vehculo, es

decir, Auto posee las Caractersticas de Vehculo (Precio, VelMax, etc)
adems posee algo particular que es Descapotable, en cambio Camin

26

tambin hereda las caractersticas de Vehculo (Precio, VelMax, etc)

pero posee como particularidad propia Acoplado, Tara y Carga.
Cabe destacar que fuera de este entorno, lo nico "visible" es el mtodo
Caractersticas aplicable a instancias de Vehculo, Auto y Camin, pues
tiene definicin pblica, en cambio atributos como Descapotable no son
visibles por ser privados.
Existen 2 tipos de herencia: La herencia simple (una clase slo puede
tener una clase padre) y la herencia mltiple (una clase puede tener ms
de una clase padre). La herencia mltiple no existe como tal en JAVA,
pero se puede simular mediante la interfaz como se puede ver en el
ejemplo a continuacin:

Las clases Cuadrado y Triangulo pueden sobreescribir y utilizar los

mtodos de la interfaz IFiguraGeometrica que implementan (modificador
implements) y tambin de la clase Padre de la cual heredan (modificador
extends).

27

28

En caso de que la clase padre sea abstracta (veremos la abstraccin a

continuacin), la clase hija correspondiente puede redefinir los mtodos
diferidos de su clase padre abstracta.
Estos mtodos deben redefinirse con los mismos parmetros que el
mtodo diferido, de lo contrario se estara definiendo otro mtodo
(sobrecarga).

Es

aqu

donde

aparece

el

concepto

de super.

Esta palabra reservada hace referencia a un mtodo perteneciente a la

clase padre de la clase del objeto en cuestin.

9.3.

Abstraccin

La abstraccin es una herramienta muy potente en programacin, pues

reduce considerablemente el trabajo de implementacin y aumenta la
portabilidad del cdigo. Dicho de forma ms prctica, la clave de la
programacin orientada a objetos est en abstraer los mtodos y los
datos comunes a un conjunto de objetos y agruparlos en una clase.
Gracias a este nivel de abstraccin, aadir o eliminar un objeto nuevo
supondr muy poco esfuerzo.
A travs de la abstraccin conseguimos extraer las cualidades
principales sin detenernos en los detalles. Conseguimos a partir de un
tema determinado, generalizar y obtener una visin global del tema.
Cuando montamos un ordenador ensamblamos los componentes
necesarios para construir el ordenador. Utilizamos una placa base, un
disco duro, memoria, etc. Manejamos estos dispositivos a un nivel
funcional. Es decir, abstraemos las funciones de cada dispositivo para
trabajar con ellos. En ningn momento nos paramos a pensar cmo
funcionan internamente o de cuntos condensadores y transistores est
compuesto.
9.4.

Polimorfismo

Esta caracterstica permite definir distintos comportamientos para un

mtodo dependiendo de la clase sobre la que se realiza la

29

implementacin. En todo momento tenemos un nico medio de acceso,

sin embargo se podr acceder a mtodos distintos.
Veamos el siguiente ejemplo, en el que se define una clase forma de la
que se heredan las clases crculo y cuadrado.

La clase forma define los mtodos dibujar y borrar. En la definicin de

estos mtodos se implementar el cdigo comn a todos los objetos de
la clase. Sin embargo cuando definamos las clases hijas, crculo y
cuadrado, ser necesario modificar estos mtodos para adaptarlos a las
nuevas subclases. El mtodo de la clase padre implementa aquellas
acciones comunes. Las clases hijas aaden las operaciones particulares
que necesiten. Cuando utilicemos los mtodos de la clase Forma no
tendremos que hacer distincin entre cuadrados y crculos. Gracias al
polimorfismo se ejecutar el mtodo adecuado en funcin de la subclase
a la que pertenezca el objeto.
Por tanto cuando creamos esa nueva subclase (o clase hija) hacemos
uso de dos mecanismos. Por un lado la herencia para reutilizar las
partes comunes de la super-clase (o clase padre). Y por otro el
polimorfismo, es decir el cambio en la forma en la que se implementa la
superclase. Como vemos al crear una subclase podemos sobrescribir los
mtodos de la clase aadiendo nuevas funcionalidades, pero no
cambiarlo.
A la hora de implementar el polimorfismo tendremos dos mecanismos de
los que echar mano para sobrescribir una clase: reemplazar la
implementacin de un mtodo o aadir funcionalidades a un mtodo.

30

En la imagen abajo se implementan las clases Revista y Libro, las cuales

ambas heredan de la clase Publicacion:

La superclase Publicacion implementaba un mtodo llamado toString()

que devolva una cadena compuesta en base al identificador, ttulo y autor
de una publicacin. Al sobreescribir el mtodo se utiliza el cdigo de la
superclase y se aade a la cadena el nmero de pginas.
Veamos ahora como afecta la sobrescritura a la subclase Revista:

En

este

caso

vemos

como

se

reemplaza

completamente

la

implementacin dada por la super-clase para el mtodo toString().

Normalmente las revistas no son firmadas por un nico autor, por tanto
es un campo que no vamos a utilizar. Es necesario reescribir
completamente el mtodo y aadirle la periodicidad de la revista, campo
que s es importante en este tipo de publicaciones.

10. Estructuras de datos dinmicas

En este punto de la memoria vamos a centrarnos en las clases ArrayList y
LinkedList que proporciona JAVA.

31

10.1. ArrayList
La clase ArrayList en Java, es una clase que permite almacenar datos
en memoria de forma similar a los Arrays, con la ventaja de que el
nmero de elementos que almacena, lo hace de forma dinmica, es
decir, que no es necesario declarar su tamao como pasa con los
Arrays.
Los principales mtodos para trabajar con los ArrayList son los
siguientes:
Declaracin de un ArrayList de "String". Puede ser de cualquier otro
Elemento u Objeto (float, Boolean, Object, ...):
ArrayList<String> nombreArrayList = new ArrayList<String>();
Aade el elemento al ArrayList:
nombreArrayList.add("Elemento");
Aade el elemento al ArrayList en la posicin 'n':
nombreArrayList.add(n, "Elemento 2");
Devuelve el nmero de elementos del ArrayList:
nombreArrayList.size();
Devuelve el elemento que est en la posicin '2' del ArrayList:
nombreArrayList.get(2);
Comprueba se existe del elemento ('Elemento') que se le pasa como
parmetro:
nombreArrayList.contains("Elemento");
Devuelve la posicin de la primera ocurrencia ('Elemento') en el
ArrayList:

32

nombreArrayList.indexOf("Elemento");
Devuelve la posicin de la ltima ocurrencia ('Elemento') en el ArrayList:
nombreArrayList.lastIndexOf("Elemento");
Borra el elemento de la posicin '5' del ArrayList:
nombreArrayList.remove(5);
Borra la primera ocurrencia del 'Elemento' que se le pasa como
parmetro:
nombreArrayList.remove("Elemento");
Borra todos los elementos de ArrayList:
nombreArrayList.clear();
Devuelve True si el ArrayList est vaco. Si no Devuelve False:
nombreArrayList.isEmpty();
Copiar un ArrayList:
ArrayList arrayListCopia = (ArrayList) nombreArrayList.clone();
Pasa el ArrayList a un Array:
Object[] array = nombreArrayList.toArray();
Otra cosa muy importante a la hora de trabajar con los ArrayList son los
iteradores (Iterator). Los iteradores sirven para recorrer los ArrayList y
poder trabajar con ellos. Los iteradores solo tienen tres mtodos que son
el hasNext() para comprobar que siguen quedando elementos en el
iterador, el next() para que nos d el siguiente elemento del iterador; y
el remove() que sirve para eliminar el elemento del iterador.
10.2. LinkedList

33

Una lista enlazada es una de las estructuras de datos fundamentales, y

puede ser usada para implementar otras estructuras de datos. Consiste
en una secuencia de nodos, en los que se guardan campos de datos
arbitrarios y una o dos referencias (punteros) al nodo anterior o
posterior.

Generalmente se usa una lista enlazada cuando no sabemos de

antemano el nmero de datos u objetos que queremos almacenar.
La clase miclase implementada a continuacin muestra ejemplos de uso
de los mtodos ms comunes de las listas enlazadas sobre dicha
estructura de datos.
public class miclase {
int id_class;
String nombre;
public miclase(int id, String nom){
this.id_class=id;
this.nombre=nom;
}
}
//ahora vamos a hacer algunas operaciones sobre esta lista
public static void main(String[] args) {

34

LinkedList lista = new LinkedList();

//agregando datos a la lista
lista.add(new miclase(1,clase1));
lista.add(new miclase(2,clase2));
lista.add(new miclase(3,clase3));
//accediendo al primer elemento de la lista
System.out.println(lista.getFirst().nombre);
//eliminando primer dato de la lista
lista.removeFirst();
//eliminando ltimo dato de la lista
lista.removeLast();
//eliminando todos los datos de la lista
lista.clear();
for(int i =0; i<lista.size(); i++){
//accediendo al dato en la posicion i
System.out.println(lista.get(i).nombre);
}
}

35

11. Excepciones

El control de flujo de un programa Java sabemos hasta ahora que se lleva

a cabo con sentencias del tipo if, while, for, return, break, etc Estas
sentencias forman un conjunto de palabras reservardas que determinan
cierta funcionalidad. Sin embargo, ninguna de ellas tiene en cuenta que se
puedan producir errores en tiempo de ejecucin de un programa y por tanto
JAVA necesita de un conjunto de palabras para tener en cuenta que
cualquier cdigo puede fallar o ser mal interpretado en tiempo de ejecucin.
Tres de las palabras reservadas para tratamiento de excepciones de las
que hace uso JAVA son:

- Try.
- Catch.
- Finally.

Existen dos formas de tratar errores en Java: capturarlos o lanzarlos. El

uso de try catch finally corresponde a la captura de errores. Un error es
algo inesperado. Cuando nos encontramos con un error podemos
capturarlo o lanzarlo (hacer que salga fuera del lugar donde se encuentra).

11.1. Bloque try

el cdigo que vaya dentro de esta sentencia ser el cdigo sobre el que
se intentar capturar el error si se produce y una vez capturado hacer
algo con l. Lo ideal es que no ocurra un error, pero en caso de que
ocurra un bloque try nos permite estar preparados para capturarlo y
tratarlo. As un ejemplo sera:
try {
System.out.println(bloque de cdigo donde pudiera saltar un
error);
}

36

11.2. Bloque catch

En este bloque definimos el conjunto de instrucciones necesarias o de
tratamiento del problema capturado con el bloque try anterior. Es decir,
cuando se produce un error o excepcin en el cdigo que se encuentra
dentro de un bloque try, pasamos directamente a ejecutar el conjunto de
sentencias que tengamos en el bloque catch:

catch (Exception e) {
System.out.println(bloque de cdigo donde se trata el problema);
}

Exception e significa que cuando se produce un error Java genera un

objeto de tipo Exception con la informacin sobre el error y este objeto
se enva al bloque catch.

11.3. Bloque finally

El bloque finally que es un bloque donde podremos definir un conjunto
de instrucciones necesarias tanto si se produce error o excepcin como
si no y que por tanto se ejecuta siempre.

finally {
System.out.println(bloque de cdigo ejecutado siempre);
}
11.4. Excepciones ms comunes en JAVA
ArrayIndexOutOfBoundsException: es lanzada cuando intentamos
acceder a un array con un index invlido (menor que 0 o mayor que la
longitud del array).
ClassCastException: lanzada cuando intentamos hacer cast a una
variable de referencia que no pasa el test IS-A

37

IllegalArgumentException: lanzada cuando un mtodo recibe un

argumento formateado de diferente manera del que el mtodo espera.
IllegalStateException: lanzada cuando el estado del entorno no coincide
con la operacin que se intenta llevar a cabo. (Usar un Scaner que no ha
sido cerrado)
NullPointerException: lanzada cuando intentamos acceder a un objeto
con una variable de referencia cuyo valor actual es null.
NumberFormatException: lanzada cuando un mtodo convierte un String
a un nmero y ese String no puede ser convertido.
AssertionError: lanzada cuando una sentencia que comprueba un
booleano devuelve false.
ExceptionInInitializerError: lanzada cuando intentamos inicializar una
variable static en un bloque de inicializacin.
StackOverflowError: tpicamente lanzada cuando un mtodo es muy
recursivo y cada llamada se va aadiendo al stack.
NoClassDefFoundError: lanzada cuando la JVM no puede encontrar la
clase que se necesita, porque hay un error en la linea de comandos, o
un problema con el classpath, o un archivo .class que no se encuentra.
ClassNotFoundException: lanza la excepcin cuando la clase no ha sido
cargada por que la definicin de la clase no ha sido encontrada.
IOException: lanza la excepcin cuando ocurre un fallo o es interrumpida
la operacin en curso. 2 comunes subtipos de excepcin de IOException
son EOFException y FileNotFoundException.
FileNotFoundException: lanza la excepcin cuando al abrir un archivo no
es encontrado.
SQLException: lanza la excepcin cuando ocurre un error en la Base de
Datos.
InterruptedException: lanza la excepcin cuando el Hilo es interrumpido.

38

NoSuchMethodException: lanza la excepcin cuando se llama a un

mtodo y este no es encontrado

12. Ficheros (lectura y escritura)

Podemos abrir un fichero de texto para leer usando la clase FileReader.

Esta clase tiene mtodos que nos permiten leer caracteres. Sin embargo,
suele ser habitual querer las lneas completas, bien porque nos interesa la
lnea completa, bien para poder analizarla luego y extraer campos de
ella. FileReader no contiene mtodos que nos permitan leer lneas
completas, para ese caso necesitaremos hacer uso de la
clase BufferedReader. Podemos construir un BufferedReader a partir
del FileReader de la siguiente forma:
File archivo = new File (fichero.txt);
FileReader fr = new FileReader (archivo);
BufferedReader br = new BufferedReader(fr);
String lnea = br.readLine();

La apertura del fichero y su posterior lectura pueden lanzar excepciones

que debemos capturar. Por ello, la apertura del fichero y la lectura debe
meterse en un bloque try-catch.
Adems, el fichero hay que cerrarlo cuando terminemos con l, tanto si
todo ha ido bien como si ha habido algn error en la lectura despus de
haberlo abierto. Por ello, se suele poner al try-catch un bloque finally y
dentro de l, el close() del fichero.
El siguiente es un cdigo completo con todo lo mencionado respecto a la
lectura de caracteres por separado.

39

La lectura de los datos de un fichero por lneas aparece ilustrada en el

cdigo abajo:

En ambos casos en el momento de la escritura, si se desea borrar el

contenido previo del fichero basta con cambiar en la lnea:
BufferedWriter fichero2 = new BufferedWriter(c:\\fichero.txt,true));
el atributo true por false.

40

13. Bases de datos

Existen libreras en JAVA que proporcionan conexiones a una base de

datos, y tambin el tratamiento y manipulacin de los mismos mediante
instrucciones SQL.
13.1. Introduccin a instrucciones SQL
En este apartado se explican brevemente y se dan ejemplos de las
sentencias SQL ms bsicas:
13.1.1.

Sentencia SELECT

La sentencia SELECT nos permite consultar los datos almacenados

en una tabla de la base de datos. Ejemplos:
SELECT matricula, marca, modelo, color, numero_kilometros,
num_plazas FROM tCoches ORDER BY marca, modelo;
SELECT matricula, marca, modelo, color, numero_kilometros,
num_plazas FROM tCoches WHERE matricula = M-1023-TS OR
matricula = M-1255-PF;
Con la palabra clave SELECT indicamos que la sentencia SQL que
queremos ejecutar es de seleccin. Si utilizamos el smbolo * tras la
palabra SELECT la consulta nos devuelve todos los campos.
Con la palabra clave FROM indicamos la tabla (o tablas) de la que
queremos recuperar los datos. En el caso de que exista ms de una
tabla se denomina a la consulta consulta combinada o join. En las
consultas combinadas es necesario aplicar una condicin de
combinacin a travs de una clausula WHERE (que vemos a
continuacin).

41

Mediante la palabra clave WHERE especificamos una condicin que

debe cumplirse para que los datos sean devueltos por la consulta.
Admite los operadores lgicos AND y OR.
A travs del binomio de palabras clave ORDER BY podemos obtener
el resultado de la consulta ordenado por las columnas indicadas. El
orden puede expresarse con ASC (orden ascendente) y DESC (orden
descendente). El valor predeterminado es ASC.
13.1.2.

Sentencia INSERT

Para almacenar datos en una base de datos debemos insertar filas en

las celdas. Para ello SQL pone a nuestra disposicin la sentencia
INSERT. Para realizar la insercin individual de filas SQL posee la
instruccin INSERT INTO. La insercin individual de filas es la que
ms comnmente utilizaremos. Su sintaxis es la siguiente:
INSERT INTO tCoches (matricula, marca, modelo, color,
numero_kilometros) VALUES (M1111CA, RENAULT, MEGANE
TR100, NEGRO DIAMANTE, 78000);
Como se puede observar la sentencia tiene dos partes claramente
diferenciadas, por un lado la propia INSERT INTO seguida de la lista
de campos en los que queremos insertar los datos, y por otro la lista
de valores que queremos insertar en los campos.
13.1.3.

Sentencia DELETE

Para borrar los datos de una tabla, debemos utilizar la sentencia

DELETE. El siguiente sera un ejemplo de ella:
DELETE FROM tCoches WHERE marca = SEAT;
Es buena idea especificar en la sentencia WHERE los campos que
forman la clave primaria de la tabla para evitar borrar datos que no se
quieren eliminar.

42

La sentencia DELETE FROM nombre_tabla borra todo el contenido

de la tabla.
13.1.4.

Sentencia UPDATE

Para la actualizacin de datos SQL dispone de la sentencia UPDATE.

La sentencia UPDATE permite a la actualizacin de uno o varios de
una nica tabla. La sintaxis de la sentencia UPDATE es la siguiente:
UPDATE tCoches SET marca = 1 WHERE marca = FORD;
Notar que los valores para el campo marca aparecen entrecomillados,
ya que es un campo de tipo varchar. Los valores con los que
actualicemos los datos deben ser del tipo campo. Si no colocamos en
la instruccin UPDATE la clausula WHERE se actualiza toda la tabla.
13.2. Instrucciones SQL en JAVA
Las sentencias que hemos visto en el apartado anterior se utilizan en las
aplicaciones JAVA para acceder y tratar los datos de una tabla de una
determinada base de datos. En todas las operaciones la secuencia a
seguir es indicar en qu entorno de trabajo se encuentra nuestra base
de datos a la que queremos que se conecte (en nuestro caso sqlite),
para despus indicar la tabla a la que queremos acceder, lo cual se
guarda es un objeto de la clase Connection. El resultado de esta
solicitud (si se ha establecido con xito una conexin o si por el contrario
se ha producido un problema) se guarda en una instancia de la clase
Statement. Finalmente se almacena en una variable de tipo ResultSet el
resultado de ejecutar la instruccin SQL lo que resulta, como veremos a
continuacin, un puntero que apunta a segn qu filas y columnas
dependiendo de la instruccin SQL ejecutada, bien con el mtodo
executeQuery (para sentencias SELECT) o bien con el mtodo
executeUpdate (para sentencias INSERT, UPDATE y DELETE).
Al igual que suceda con los ficheros, es muy recomendable que el
bloque de cdigo en el que se ejecuten estas operaciones se site
dentro de un bloque try-catch-finally en el que se capturen las

43

excepciones que puedan producirse. Adems, tanto si el bloque de

cdigo se ha ejecutado sin incidencias o con ellas, debemos cerrar la
conexin que hemos abierto para el acceso a la tabla. Este ltimo
proceso de cerrar la conexin lo ideal sera ubicar el cdigo fuente en el
bloque finally, ya que lo que est contenido dentro de l siempre se
ejecuta.
13.2.1.

Posicionamiento en un ResultSet

El objeto ResultSet gestiona un puntero de registro que determina

sobre qu registro van a intervenir los mtodos ejecutados sobre el
propio ResultSet. Este registro se llama a veces registro activo o
registro en curso. El objeto ResultSet contiene siempre dos registros
ficticios que sirven de referencia para el principio del ResultSet (BOF)
y para el final del ResultSet (EOF). El puntero de registro se puede
colocar sobre uno de estos dos registros pero nunca antes del registro
BOF ni despus del registro EOF. Estos registros no contienen datos
y una operacin de lectura o escritura sobre estos registros genera
una excepcin. En el momento de la creacin del ResultSet el puntero
se coloca antes del primer registro (BOF). Existen muchos mtodos
disponibles para gestionar el puntero de registros:
boolean absolute(int position): desplaza el puntero de registro sobre el
registro especificado. La numeracin de los registros empieza en 1. Si
el valor del argumento posicin es negativo, se efecta el
desplazamiento partiendo del final del ResultSet. Si el nmero de
registro no existe, se coloca el puntero sobre el registro BOF si el
valor es negativo e inferior al nmero de registros, o sobre el registro
EOF si el valor es positivo y superior al nmero de registros. Este
mtodo devuelve true si el puntero est colocado en un registro vlido
y false en el caso contrario (BOF o EOF).
boolean relative(int deplacement): desplaza el cursor del nmero de
registros especificados por el argumento deplacement. Si el valor de
este argumento es positivo, el cursor baja en el juego de registros, y si

44

el valor es negativo, el cursor sube en el juego de registros. Este

mtodo devuelve true si el puntero est colocado sobre un registro
vlido y false en el caso contrario (BOF o EOF).
void beforeFirst(): desplaza el puntero de registros antes del primer
registro (BOF).
void afterLast(): desplaza el puntero de registros despus del ltimo
registro (EOF).
boolean first(): desplaza el puntero de registros sobre el primer
registro. Este mtodo devuelve true si hay un registro en el ResultSet
y false en caso contrario.
boolean last(): desplaza el puntero de registros sobre el ltimo
registro. Este mtodo devuelve true si hay un registro en el ResultSet
y false en caso contrario.
boolean next(): desplaza el puntero de registros sobre el registro que
sigue al registro actual. Este mtodo devuelve true si el puntero est
en un registro vlido y false en caso contrario (EOF).
boolean previous(): desplaza el puntero de registros sobre el registro
anterior al registro actual. Este mtodo devuelve true si el puntero
est sobre un registro vlido y false en caso contrario (BOF).
Para todos estos mtodos, excepto para el mtodo next, es
absolutamente necesario que el ResultSet sea de tipo
SCROLL_SENSITIVE o SCROLL_INSENSITIVE. Si el ResultSet es
de tipo FORWARD_ONLY, slo el mtodo next funciona y en este
caso los dems mtodos producen una excepcin. Los mtodos
siguientes permiten comprobar la posicin del puntero de registros:
boolean isBeforeFirst(): devuelve true si el puntero est situado antes
del primer registro (BOF).
boolean isAfterLast(): devuelve true si el puntero est situado despus
del ltimo registro (EOF).

45

boolean isFirst(): devuelve true si el puntero est situado en el primer

registro.
boolean isLast(): devuelve true si el puntero est situado en el ltimo
registro.
int getRow(): devuelve el nmero del registro sobre el cual se
encuentra el puntero de registros. Si no existe un registro en curso
(BOF o EOF), devuelve el valor 0.
13.3. Implementacin de sentencias SQL en nuestra aplicacin JAVA
A la hora de trabajar con una aplicacin JAVA lo primero que debemos
hacer es importar las libreras necesarias para poder utilizar las
funciones relativas al acceso a bases de datos y ejecucin de sentencias
SQL (con la palabra reservada import se importan las funciones de la
librera que especifiquemos a continuacin de dicha palabra):
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
En las imgenes abajo se implementa la clase BaseDatos, que ilustra
todo lo descrito en el punto 13 de ste escrito:
Mtodo seleccin(), para obtener datos de una tabla mediante una
consulta SQL:

46

Mtodo Insercion(), para insertar un nuevo registro en una tabla:

Mtodo Actualizar(), para modificar uno, varios, o todos los registros de

una tabla

Mtodo Eliminar(), para borrar uno, varios, o todos los registros de una
tabla:

47

14. Interfaces grficas de usuario (GUI: Graphic User Interface)

Hasta ahora hemos desarrollado programas que usan la consola para

interactuar con el usuario, sin tener que tratar al mismo tiempo con ventanas,
botones y otros elementos similares.
La interfaz de usuario es la parte del programa que permite al usuario
interaccionar con l. La API de Java proporciona una biblioteca de clases para
el desarrollo de Interfaces grficas de usuario (en realidad son dos: swing y
awt). La biblioteca proporciona un conjunto de herramientas para la
construccin de interfaces grficas que tienen una apariencia y se comportan
de forma semejante en todas las plataformas en las que se ejecuten. La
estructura bsica de la biblioteca gira en torno a componentes y
contenedores. Los contenedores contienen componentes y son componentes
a su vez, de forma que los eventos pueden tratarse tanto en contenedores
como en componentes.
La API est constituida por clases, interfaces y derivaciones. El esquema
situado abajo muestra la jerarqua de clases utilizadas en las GUI:

48

Component: superclase de todas las clases de interfaz grfica.

Container: para agrupar componentes.
JComponent: superclase de todos los componentes de Swing que se
dibujan directamente en los lienzos (canvas). Sus subclases son los
elementos bsicos de la GUI.
JFrame: ventana que no est contenida en otras ventanas.
JDialog: cuadro de dilogo.
JApplet: subclase de Applet para crear applets tipo Swing.

JPanel: contenedor invisible que mantiene componentes de interfaz y que

se puede anidar, colocndose en otros paneles o en ventanas. Tambin
sirve de lienzo.
Graphics: clase abstracta que proporciona contextos grficos donde dibujar
cadenas de texto, lneas y otras formas sencillas.
Color: color de los componentes grficos.

49

Font: aspecto de los caracteres.

FontMetrics: clase abstracta para propiedades de las fuentes. Categoras
de clases:
-Contenedores: JFrame, JApplet, JWindow, JDialog
-Componentes intermedios: JPanel, JScrollPane
-Componentes: JLabel, JBbutton, JTextField, JTextArea,...
-Clases de soporte: Graphics, Color, Font,...

14.1.

GUIs en NetBeans

NetBeans permite el desarrollo de GUIs con componentes AWT y Swing

de forma grfica: dispone de un Inspector de componentes que permite
visualizar el rbol de componentes y las propiedades de los mismos. La
forma de trabajo es mediante drag & drop de los componentes y facilita
el alineamiento y posicionamiento de componentes. Tambin permite
configurar las propiedades de cada componente y asignar gestores de
eventos.
Los elementos principales de la IDE de NetBeans son:
Palette: contiene todos los compoentes Swing y AWT.
El rea Design: donde se va a construir visualmente la GUI. Tiene dos
vistas: source y design.
Editor Property: permite editar las propiedades de cada componente.
El Inspector: es una visin grfica de los componentes de la aplicacin.
En la siguiente imagen se puede observar en el entorno de trabajo de
NetBeans con componentes JFrame. Notar que en la pestaa de la
izquierda est seleccionada la pestaa Design: es en ella en la que
podemos disear nuestra ventana y ver un diseo previo de la misma.

50

Para acceder al cdigo fuente, basta con seleccionar la pestaa

Source.

Haciendo doble click sobre cada componente se puede modificar el

texto que por defecto coloca el IDE.
Para cambiar los nombres de las variables de cada componente en la
ventana Inspector se hace click-derecho en cada componente y se
selecciona Change variable name.

51

15. Bibliografa

-Apuntes del curso

http://puntocomnoesunlenguaje.blogspot.com.es/2012/04/estructuras-decontrol.html
http://www.ciberaula.com/articulo/encapsulacion_java
http://codehero.co/java-desde-cero-sentencias-if-y-switch/
http://www.ciberaula.com/articulo/herencia
http://www.ciberaula.com/articulo/abstraccion
http://www.ciberaula.com/articulo/polimorfismo
https://www.adictosaltrabajo.com/tutoriales/introduccion-bases-de-datossql/
http://www.fdi.ucm.es/profesor/jpavon/poo/tema6resumido.pdf
http://www.1keydata.com/es/sql/
http://programandoointentandolo.com/java http://codehero.co/java-desdecero-sentencias-if-y-switch/
http://jarroba.com/arraylist-en-java-ejemplos/
http://usandojava.blogspot.com.es/2011/12/implementacion-de-una-listasimple.html

52