java

o

JAVA

2015

Autor: Sergio Santos Gil

2

-Valor Creativo-

Sergio Santos Gil - JAVA -

JAVA

Introducción ...................................................................................................................

JAVA ..............................................................................................................................................

IDE .................................................................................................................................................

Variables .........................................................................................................................................

Mostrar por pantalla ........................................................................................................................

Operadores ......................................................................................................................................

Sentencia .........................................................................................................................................

if, esleif, else ............................................................................................................................................

switch ......................................................................................................................................................

while ........................................................................................................................................................

do…while ................................................................................................................................................

for ............................................................................................................................................................

Ámbito ............................................................................................................................................

Objetos...........................................................................................................................

Atributos ........................................................................................................................

Composición de objetos ...........................................................................................................................

Métodos .........................................................................................................................

Método main ...................................................................................................................................

Métodos Constructores ....................................................................................................................

Sobrecarga ......................................................................................................................................

Métodosgetting y setting..................................................................................................................

Herencia .........................................................................................................................

3

-Valor Creativo-


Upcasting y Downcasting ..............................................................................................

Operador instanceof ........................................................................................................................

Sobreescritura ................................................................................................................

Método super...................................................................................................................................

Organización del código ................................................................................................

Ficheros.jar......................................................................................................................................

Encapsulación y Visibilidad ...........................................................................................

public ..............................................................................................................................................

protected .........................................................................................................................................

package ...........................................................................................................................................

private .............................................................................................................................................

Clases Especiales ...........................................................................................................

Clase String .....................................................................................................................................

Clase Object ....................................................................................................................................

Clase Date .......................................................................................................................................

Clase Random .................................................................................................................................

Clase BigInteger y BigDecimal ......................................................................................................

Claseswrapper .................................................................................................................................

Clases Abstractas ...........................................................................................................

Interfaces .......................................................................................................................

InterfazComparable .........................................................................................................................

Polimorfismo .................................................................................................................

Excepciones ...................................................................................................................

try y catch........................................................................................................................................

Clase Exception ...............................................................................................................................

Arrays ............................................................................................................................

Argumentos de entrada en main .......................................................................................................

Colecciones de Objetos ..................................................................................................

Collection ........................................................................................................................................

Map .................................................................................................................................................

Iteradores ........................................................................................................................................

Listas, pilas y colas ..........................................................................................................................

4

-Valor Creativo-


Clases Genéricas ............................................................................................................

Almacenamiento de Datos .............................................................................................

Clases para almacenamiento de datos ..............................................................................................

Lectura de un fichero de texto ..................................................................................................................

Escritura en un fichero de texto ................................................................................................................

Lectura/Escritura de un fichero de texto ...................................................................................................

Acceso a una Base de Datos ............................................................................................................

Conexión Base de Datos Access ...............................................................................................................

Conexión Base de Datos MySQL ..............................................................................................................

SentenciasSQL .........................................................................................................................................

Serialización de Objetos .................................................................................................

InterfazSerializable ..........................................................................................................................

Interfaz Gráfica ..............................................................................................................

JFrame ............................................................................................................................................

JPanel .............................................................................................................................................

LayoutManager ...............................................................................................................................

JLabel .............................................................................................................................................

JTextField .......................................................................................................................................

JButton ............................................................................................................................................

Menús .............................................................................................................................................

Otros componentes ..........................................................................................................................

Graphics .........................................................................................................................................

Tipos Enumerados .........................................................................................................

Manejo de Eventos .........................................................................................................

Servlet ............................................................................................................................

Subir ficheros ...........................................................................................................................................

Cookies ....................................................................................................................................................

Sesiones ...................................................................................................................................................

Acceso a BBDD .......................................................................................................................................

JSP ..................................................................................................................................................

JSTL ...............................................................................................................................................

Hibernate .......................................................................................................................

POJO ...............................................................................................................................................

5

-Valor Creativo-


Introducción

JAVA

Es un lenguaje de programación orientado a objetos, cuyo objetivo es crear aplicaicones

independientes de la plataforma (SO y CPU) subyacentes.

El compilador de JAVA crea un código llamado bytecode, que no contiene isntrucciones de

máquina inteligibles por la CPU.

Para que un bytecode pueda ser ejecutado en un procesador concreto, necesita ser traducido

al lenguaje máquina que entiende dicho precesador. El encargado de hacer esto es un

programa llamado JVM (Java Virtual Machine) máquina virtual deJava.

Sobre la JVM no sólo podemos correr programas creados por el lenguaje de JAVA, existen

otros lenguajes que se pueden compilar a bytecodes, como por ejemplo Jython, JRoby y

Grooovy.

Un archivo que contenga código fuente en JAVA (.java) contiene clases.Cada clase

contenida va precedida de la palabra class.

Cada archivo fuente de JAVA puede contener múltiples clases, sin embargo tan sólo puede

contene una clase de tipo pública: public class.

Los archivos deben llamarse exactamente igual que la única clase pública del código.

Un programa en JAVA constará habitualmente de un archivo MiClase.java y una clase

pública, sin código public class MiClase{}.

Para que pueda ejecutarse la clase MiClase.java, ésta ha de contener un método especial

llamado main: public static void main(String[] args){}.

6

-Valor Creativo-


El código en un programa en JAVA, consiste en un conjunto de sentencias que se le dan en

un lenguaje homanamente inteligible al ordenador para que realice una serie de cálculos o

acciones.

IDE (IntegredDevelopmentEnvironment)

Un IDE es una aplicación que facilita la labor de desarrollo de una aplicación en un lenguaje

determinado.

Necesitan que exista un compilador de dicho lenguaje. No sustiyuyen su labor, tan sólo la

complementan.

Gracias a estos programas podremos crear códigosJAVA.

Existen varios IDE, como por ejemplo:

NetBeans

Eclipse

JGrasp

https://netbeans.org/downloads/7.0.1/

http://www.eclipse.org/downloads/

http://spider.eng.auburn.edu/user-cgi/grasp/grasp.pl?;dl=download_jgrasp.html

7

-Valor Creativo-


Variables

Una variable es la representación simbólica de un dato. Se manifiesta en el código por

medio de identificadores determinados por las siguientes reglas:

Se componen de uno o más caracteres: letras de Aa-Zz, número 0-9, _ y $.

No pueden comenzar por un número.

Son sensibles a las mayúsculas.

No pueden coincidir con ninguna palabra reservada.

También existen ciertas reglas de estilo asumida por la mayoría de los programadores:

La primera letra del identificador ha de estar en minúsculafecha

Para concatenar los identificadores compuestos de varias palabras, se pone en

mayúscula la primera letra de cada palabrafechaDeNacimiento

Los tokens o estructuras que pueden contener el código de un método son:

Parlabas reservadas: for, while, super,…

Literales: 123, “Hola”, „a‟, 14.25,…

Identificadores: saldo, fechaDeNacimiento,…

Operadores: +, -, *, /,..

Separadores: {}, ; , :

Comentarios: //de línea; /*de cloque */

8

-Valor Creativo-


Tipo

Es de tipo carácter simple donde sus valores se expresan entre comillas simple („ „).

Sus valores son los caracteres codificados según el código ASCII, por ejemplo, el carácter

„A‟ equivale al número 65 del código.

Tipo

El tipo String, aunque verdaderamente no es un tipo si no una clase, sirve para almacenar

cadena de caracteres.

Tipos , , y

byte: valor numérico en el que es capaz de almacenar valores desde -128 a127 de un

byte.

short: valor numérico desde -32.000 hasta 32.000 de dos bytes.

int: valor numérico desde -2.000.000 hasta 2.000.000 de cuatro bytes.

long: valor numérico de más de2.000.000 de ocho bytes. En este caso, el valor de un

long tiene que ir acompañado de “L” para que coja un valor de ocho bytes.

9

-Valor Creativo-


Tipos y

Estos tipos también almacenan valores numéricos, pero con decimales. El tipo float

almacena hasta cuatro bytes y el tipo double de ocho bytes.

En este caso, el tipo float tiene que ir acompañado de la letra “f” para especificar que es de

ese tipo, ya que, por defecto, JAVA interpreta un decimal como tipo double.

Tipo

Variable booleana que declara si un valor es falso (false) o verdadero (true).

Operadores

Los operadores son símbolos que representan un tipo de operación y que nos sirven para

crear expresiones más complejas:

( )operador de agrupación + suma o concatenación de caracteres

- resta de dígitos * multiplicación / división

% resto de una división && “y” “and” || “o” “or”

== comparación de igualdad != distinto de > mayor que

<menor que >= mayor o igual <= menor o igual

? :ternario condicional. Antes de la interrogación, se pone una expresión

booleana, es decir, se compara lo que deseemos, y si es verdadera la comparación,

devuelve el tipo situado a la izquierda de los dos puntos, en cambio, si la

comparación es falsa, devuelve el segundo tipo situado a la derecha de los dos

puntos.

10

-Valor Creativo-


Mostrar por pantalla

Las sentenias System.out.print( ) y System.out.println( ) sirve para mostrar por pantalla lo

que especifiquemos entre los paréntesis.

Para sacar por pantalla una instrucción mediante el teclado, tenemos que seguir los

sigioentes pasos:

Introducir antes de la clase pública import java.util.*;

Gracias al comando anterior, podrá funcionar el siguiente comando que permite la

entrada por teclado: Scanner scan = new Scanner(System.in);

A continuación, se declara una variable según el tipo de dato que procedemos a

introducir: String variable; int variable; doublevariable.

Después recogemos el dato introducido por el usuario en la variable preparada

utilizando la opción adecuada en función del tipo del comando scan.next();:

- Para Stringscan.next();

- Para valor numérico entero (int) scan.nextInt();

- Para decimales (double) scan.nextDouble();

Las expresiones son conjuntos de tokens que el programa resolverá en un valor

concreto. La expresión más simple consiste en un literal, que será resuelto al valor que

representa.

11

-Valor Creativo-


Sentencias

La sentencia es uno de los elementos fundamentales de cualquier programa, ya que

simboliza una acción simple que el programa puede realizar. Se separan unas de otras

mediante “ ;“. Tipos de sentencias:

Declaración de variables: int y; , String x;

Asignación: y = 123; , x = “Nombre”;

De control: if {} , for() {}

Paso de mensajes:clase.metodo();

Cuando queremos que un conjunto de sentencias se ejecuten como un bloque, de principio a

fin, podemos agruparlos en un par de llaves “{}”. El agrupamiento de sentencias sirve para:

Clarificar lujos complejos de ejecución

Ocultar cierta información innecesaria para ciertos bloques

Se define ámbito como la “zona” o bloque donde una variable es accesible.

Una variableno puede tener el mismo nombre que otra declarada en el ámbito del

método al que pertenece, aunque podría llamarse igual que otra de otro método.

Si se declara una variable en un ámbito más interno, no se podrá acceder a la misma

desde un ámbito más externo:

Sin embargo, desde un ámbito interno se podría acceder a las variables del ámbito más

externo:

12

-Valor Creativo-


if, elseif, else

La sentencia if obliga a evaluar la expresión que haya entre paréntesis y, si se cumple la

condición, ejecuta un bloque de código. Si por el contrario dicha condición no se cumple, el

bloque de código será ignorado gracias a else.

Esta instrucción es similar a la anterior, con la diferencia que nos permite introducir en la

misma línea de la instrucción condicional más casos de condiciones. Es decir, evaluamos una

expresión gracias a if, si no se cumple dicha expresión evaluamos otra expresión con elseif,

como tantas condiciones deseemos, y si no, los bloques serán ignorados mediante else.

También podemos encontrarnos con solo un if, sin el acompañamiento del else, esto indica

que si se cumple la condición, se ejecuta el código del interior, y si no, pues sigue con el

resto del código.

13

-Valor Creativo-


switch

La sentencia switch es una forma distinta y más comprensible para evaluar una variable

frente a multitud de opciones. En muchos casos, queremos comparar la misma variable con

infinidad de expresiones, ejecutando la parte del código correspondiente a la opción elegida.

Se declara el comando switch seguido de la variable a comparar. Después se utiliza la

expresión case, seguido de dos puntos, para indicar la opción de la variable. Cada caso

case, van separados con la cláusula break, que permite salir fuera delswitch, ya que si no se

utiliza se ejecutan el resto de declaraciones. Y por último, se utiliza la cláusula default,

donde se especifica el bloque de código que se ejecutará si no cumple algunas de las

condiciones del switch.

14

-Valor Creativo-


while

El bucle while es el más sencillo de utilizar, se utiliza siempre y cuando la condición sea

verdadera, para ejecutar las instrucciones que contiene dentro de él.

El valor de la expresión es comprobado cada vez al principio del bucle, incluso si este

valor cambia durante la ejecución de las sentencias. La ejecución no parará hasta el fin de

la repetición.

15

-Valor Creativo-


do… while

Este bucle es casi igual que el anterior, pero con la diferencia de que aquí la condición se

evalúa después de ejecutar el código. Se especifica do seguido del código que se va a

ejecutar, y después con el while se especifica cuando parar el bucle.

16

-Valor Creativo-


for

La sentencia for es uno de los bucles más complejos, el cual toma tres parámetros

separados entre ellos mediante un punto y coma, estos parámetros son:

Valor inicial de la variable de control.

Valor final de la variable de control, el cual especifica cuando terminar el bule.

Y el incremento o decremento de dicha variable.

La primera expresión que se evalúa es el “valor_inicial”, y se hace una sola vez al

comienzo del bucle. A continuación, al comienzo de cada iteración es evaluada

“valor_final” y si dicha evaluación resulta verdadera, el bucle sigue su curso al igual que las

sentencias anidadas. Pero si la evaluación resulta que es falsa, la ejecución del bucle finaliza.

17

-Valor Creativo-


OBJETOS

El objeto es un elemento estructural fundamental de la programación orientada a objetos.

Se trata de una entidad informativa que posee individualidad (identidad), características

o estado (atributos) y comportamientos (métodos).

Los objetos viven o existen en la memoria RAM del ordenador. Su identidad vendrá

definida por la dirección de memoria en la que están ubicados, lo que se denomina

comonombres simbólicos.

Para crear objetos en otras clases o ficheros, se emplea el comando new el cual nos

permitirá crear tantos objetos como queramos: MiObjeto nombre = new MiObjeto();

Los datos que poseen un objeto pueden ser múltiples y estructurados de forma

versátil.

Los datos de un objeto siempre irán acompañados de las acciones que tiene sentido

realizar con esos datos.

18

-Valor Creativo-


ATRIBUTOS

Los atributos de un objeto son las características que definen al objeto, suelen ser

variables. Se compone de un nombre, el identificador que permite diferenciar un atributo

de otro; y del tipo, indica la naturaleza y estructura de los valores concretos que puede

tomar el atributo.

El tipo puede ser simple, es decir, un entero, una cadena de caracteres,…; o puede ser

compuesto, es decir, podemos definir las características de un objeto en función de otros.

Para leer un atributo se emplea la sintaxis objeto.atributo, y para dar un valor a un

atributose emplea mediante objeto.atributo = valor.

Si queremos evitar que se pueda cambiar el valor de un atributo, una vez después de

inicializado, emplearemos el modificador final.

Cuando asignemos el valor a un atributo, añadimos al princpo de la inicialización el

modificadorfinal, y gracias a éste, cuándo intentemos otorgar otro valor a ese atributo,

provocará un error de compilación.

19

-Valor Creativo-


Cuando un atributo de un objeto no es tipo simple, sino una referencia a otro objeto, se

dice que estamos realizando composición de objetos, es decir, un objeto que se compone de

o contiene a otros objetos.

En realidad no lo contiene, tan sólo sabe dónde está, aunque si es el único que sabe dónde

está, si el objeto contenedor se borra y desaparece la referencia, el recolector de basuras

se encargará de borrar el objeto referido, así que en cierto modo está fuertemente vinculado

a su contenedor.

Hay que tener en cuenta que los atributos que son referencias a objetos, se inicializan a null.

Si queremos que apunten a un objeto real, alguien necesita crearlos y darle a conocer su

dirección al objeto que quiere contenerlos. Normalmente, el responsable de crearlos será el

propio objeto contenedor, y lo hará en sus métodos constructores.

20

-Valor Creativo-


Métodos

Todo objeto debe ser capaz de ofrecer unos servicios a otros objetos. A cada uno de estos

servicios se le denomina método.

Los métodos son susceptibles de realizar acciones distintas en función de los parámetros de

entrada que tenga, que también pueden ser objetos complejos.

Un método puede devolver un valor al acabar, pudiendo ser este otro objeto. Para invocar la

ejecución de un métodose indica la siguiente sintaxis:clase.método(mensaje), que el

mensaje es el tipo de atributo que pide el método para ejecutarse, o puede ser vacío.

Lo importante de un objeto es conocer su interfaz: nombre y tipodeatributos, y sobre todo

el nombre, parámetros y tipo que devuelvensusmétodos.

Esto proporciona la ocultación del código fuente, ya que se podrán invocar los servicios de

un objeto siempre y cuando se sepa cómo invocarlos (nombre del método, númeroy tipo de

cada parámetro de entrada, y tipo de dato de salida)

No nos interesa saber cómo hacen las cosas los objetos, tan sólo cómo pedirles que las hagan.

21

-Valor Creativo-


Método

Es un método especial estático que hace ejecutar una clase en JAVA, por lo que siempre

laclase pública que vaya a ser ejecutada debe tenerestemétodo. Su prototipo es:

public static void main(String[] args)

Métodos Constructores

Son métodos que se tienen que llamar exactamente igual que la clase a la que pertenecen.

Estosmétodosno devuelven nada, ni siquiera void.

Existe siempre un método constructor para todas las clases que creamos cuyo código está

vacío. Si construimos cualquier constructor personalizado, aunque no sea un constructor sin

parámetros, el constructor por defecto desaparece.

Son los primeros que se ejecutan para cualquier objeto que se cree de esa clase.Al igual que

los métodos normales, también pueden sobrecargarse.

Cuando se crea un objeto, con el comando new, se ha de indicar a continuación cuál de todos

los constructores de la clase queremos utilizar.

El código que contiene, se suele utilizar para inicializar los atributos del objeto.

El comando this hace referencia a los atributos de la clase.

22

-Valor Creativo-


Métodos Getting y Setting

Para favorecer la encapsulación y ocultación de la arquitectura interna de una clase hacia el

exterior, los atributos suelen tener acceso privado, para que de esta manera, cuando desde el

exterior mediante un programa u otra clase quieran modificar o consultar los atributos, no

podrán acceder a ellos.

23

-Valor Creativo-


Para que desde el exterior se pueda consultar o modificar los atributos se suele crear métodos

getting y setting, que son métodos públicos que permiten acceder a los atributos privados de

determinadas clases.

Métodos get: Se emplean para poder visualizar los atributos desde el exterior.

Métodos set: Se emplean para poder modificar los atributos.

24

-Valor Creativo-


SOBRECARGA

En JAVA se puede sobrecargar un método, es decir, que puede haber dos métodos en una

misma clase que se llamen igual.

Para que se sepa cuál de los dos códigos ejecutarse, es necesario que se diferencien en el tipo

y/o númerodeparámetros de entrada. Se generará un error si los métodos sólo varían en el

tipo de retorno.

Puede haber tantos métodos sobrecargados de un mismo método como se desee.

También se puede sobrecargar los constructores de las clases. Cuando en una clase existen

constructores múltiples, se dice que hay sobrecarga de constructores.

25

-Valor Creativo-


HERENCIA

Es el mecanismo que proveen los lenguajes orientados a objetos para reutilizar código

existente, de forma sencilla.

Pone en conexión a una clase (clase hijo), con otra clase (clase padre), de manera que al

conectarlas entre sí, la clase hijo“hereda” todos los atributos y métodos de la clase padre.

Para ello, tenemos que tener acceso al fichero .class de la clase de la cual se va a heredar, es

decir, de la clase padre.

Es como si hubiéramos hecho un “copiar y pegar” de todo el código fuente de la clase padre

a la clase hijo, pero sin necesidad de hacerlo.

Para que una clase herede de otra, emplearemos la palabra extends detrás del nombre de la

clase hijo para conectarla con la clase padre.

En JAVA, sólo las clases hijos conocen a su padre y sólo pueden tener uno, pero una clase

padre puede tener todos los hijos que quiera, sin saber quiénes son.

26

-Valor Creativo-


Upcasting y downcasting

Son mecanismos que tienen que ver con la herencia.

En función del tipo de la variable-referencia que utilicemos para guardar la dirección de un

objeto que ha heredado código, se podrán acceder a unos métodos o atributos en concretos.

Sea un objeto A de la clase Padre y un objeto B de la clase Hijo, se pueden dar cuatro casos

posibles:

Referenciar al objeto B, con una variable de tipo “Hijo”.

Se puede acceder a todos los métodos y atributos del hijo y del padre. Si hay

métodos sobrescritos, sólo se puede acceder a los del hijo.

Referenciar al objeto A, con una variable del tipo “Padre”.

Se puede acceder sólo a los métodos y atributos del padre. Es imposible acceder a los

del hijo.

27

-Valor Creativo-


Referenciar al objeto B, con una variable del tipo “Padre”, lo que se denomina como

Upcasting.

Se puede acceder sólo a los métodos y atributos del padre, no se pude acceder a

métodos y atributos del hijo, a no ser que se haga previamente un Downcasting

explícito.

Referenciar al objeto A, con una variable del tipo “Hijo”. Lo que es imposible, da un

error de compilación.

Se puede decir que la naturaleza de un objeto la marca el constructor que se utiliza en el

“new” y durante la vida del mismo se puede “disfrazar” de otras clases, es decir, que puede

obtener los métodos y atributos de una clase pertenecientea su jerarquía de herencia,

cambiando el tipo de si variable de referencia.

Para hacer un Downcasting en JAVA, hay que poner a la izquierda de la referencia que

queremos “bajar” en la jerarquía de herencia el nombre de la clase entre paréntesis hasta la

que la queremos y podemos bajar.

UpcastingPadre r = new Hijo();

Downcasting( (Hijo)r)

28

-Valor Creativo-


Operador instanceof

Como un objeto puede tener múltiples “disfraces”, es decir, puede ser referenciado por

variables de distintas clases de las que herede o interfaces que implemente, a veces es

difícil saber cuál es su naturaleza real, cuando se hizo el “new”.

El operador instanceof sirve para consultar si un objeto es una instancia de una clase

determinada.

29

-Valor Creativo-


SOBREESCRITURA

Una clase hijopuede volver a escribir el código de un método que ya existía en la clase

padre. El resultado es que el código de la clasepadrequeda oculto por el de la clase hijo, y

será éste último el que se ejecute.

Si quisiéramos ejecutar el código original oculto de la clase padredesde el código de la clase

hijo, lo podemos hacer usando la referencia especial del método super().

Cuando se ejecuta un constructor de una clase hijo, se ejecuta implícita y previamente el

constructor de la clase padre. Si queremos controlar cuál de todos los constructores de la

clase padre ejecutar, también podemos emplear el método especial super().

30

-Valor Creativo-


ORGANIZACIÓN DEL CÓDIGO

El código de un proyecto JAVA consistirá en un montón de clases, cada una escrita en un

fichero .java. Como el número de clases puede ser muy grande, y además, las tareas que

realiza cada clase no tienen por qué ser conceptualmente similares, JAVA nos permite

organizar las clases en una entidad superior denominada paquete.

Para hacer que un par de clases pertenezcan a un mismo paquete, se emplea el comando

packageseguido del nombre del paqueteantes de la definición de ambas clases.

Los paquetes pueden organizarse por niveles, utilizando como el separador un punto “.”. Si

se organizan por niveles, esta misma estructura se ha de reflejar en los directorios que

contengan los ficheros .class que vayamos creando.

Para que funcione todo, la variable CLASSPATH debe contener el directorio desde el cual

comienza la estructura.

31

-Valor Creativo-


Para poder utilizar una clase que está en alguna de estas estructuras hay que escribir el

comando import, seguido de la ruta donde está ubicada, y así evitar escribir la ruta

completa cada vez.

Se pueden transportar y compartir programas o libreríasJAVA con estructuras

complejas, utilizando tan sólo un fichero con extensión .jar.

Este es un fichero comprimido, lo cual favorece su velocidad de transporte en una red.

La utilidad para empaquetarlos es jar.exe cuyas sintaxis son parecidas al del comando tar del

sistema operativo LINUX. Podemos emplear su ejecución, si añadimos a los valores de

entorno de nuestro ordenador, la ruta de la carpeta bin de Java.

Para la creación de un fichero.jar se emplea la sentencia jarcvf archivo.jar clase1claseN.

Y para ver el contenido de un fichero .jarse emplea la sentenciajartvf archivo.jar.

32

-Valor Creativo-


ENCAPSULACIÓN Y VISIBILIDAD

Siempre que tengamos una referencia a un objeto, podemos acceder a cualquiera de sus

métodos o atributos. En la mayoría de los casos querremos proteger a un objeto del acceso

libre de sus atributos, así como de sus métodos.

Para discriminar quién puede acceder o no, utilizaremos los modificadores de acceso:

o public: Todo el mundo puede acceder a este método o atributo.

o protected: Sólo se puede acceder desde clases descendientes, es decir, si es una clase

hija, o del mismo paquete.

o package: Sólo se puede acceder desde clases pertenecientes al mismo paquete. Este

método se deja en blando, es decir, no se declara que es de paquete ya que, por defecto

se consideran de paquete a los métodos.

33

-Valor Creativo-


o private: No se puede acceder salvo que sea desde la misma clase.

También se puede modificar el permiso de creación de objetos, cambiando el acceso a los

métodos constructores de una clase:

o public: Se puede hacer “new” desde cualquier clase.

o protected: Puede hacerse “new” desde cualquier clase que se declare como clase hija

de ésta, aunque no esté en el mismo paquete.

34

-Valor Creativo-


o package: Como en el caso de los métodos, sólo pueden hacer “new” desde clases

pertenecientes al mismo paquete que ésta.

o private: No puede hacer “new” nadie, sólo el propio objeto. Esto sólo tiene sentido

combinando con métodos o atributos estáticos.

Aparte de los métodos, atributos y constructores de una clase, también podemos modificar

el acceso a la clase entera, aunque aquí, sólo se podrían utilizar dos modificadores:

o public: todo el mundo puede acceder al código de dicha clase.

o package: sólo se podrá acceder desde clases del mismo paquete.

35

-Valor Creativo-


CLASES ESPECIALES

Clase

Es una clase de la API de JAVA cuyos objetos contienen una cadena de caracteres.

Tiene variosconstructores, aunque el más utilizado se le pasa unalista de caracteres entre

comillas dobles (“”).

Métodosde la clase :

isEmpty() indica si el String está o no vacío, es decir, devuelve un booleano.

length() muestra el número de caracteres (char) que contiene el String.

charAt(int) devuelve el carácter del String en la posición indicada.

replace(char, char) reemplaza el segundo carácter de la sentencia en el String por el

primer carácter.

36

-Valor Creativo-


replace (String, String) reemplaza el segundo String por el primer String.

substring(int, int) devuelve del String los caracteres desde la posición del primer

entero introducido hasta el otro entero menos uno.

toUpperCase() convierte los caracteres del String a mayúsculas.

toLowerCase() convierte los caracteres del String a minúsculas.

valueof(<tipo>) convierte el tipo indicado en un String.

37

-Valor Creativo-


Clase

Es la clase más alta en cualquier jerarquía de herencia. Al crear una nueva clase,

automáticamente dicha clase hereda de la clase Object.

Todos los objetos heredan de Object implícitamente.

Métodosde la clase :

toString()es un método que devuelve, por defecto, un String en el que aparece el

nombre del objeto referenciado junto al carácter “@”, seguido de la dirección de

memoria que ocupa el objeto creado.

Cuando indicamos que queremos ver el objeto creado, automáticamente nos muestra

la dirección de memoria donde está ubicado, es decir, nos ejecuta el método

toString(). Para poder editar dicho método tenemos que sobrescribir su prototipo:

publicStringtoString().

38

-Valor Creativo-


equals()devuelve un boolean al comparar dos objetos o dos cadenas de caracteres

(String). Al comparar dos objetos, compara la dirección de memoria dónde están

ubicados y no tiene en cuenta sus atributos ni métodos.

Si queremos editar el método equals(), podemos hacerlo a través de su prototipo:

publicbooleanequals (Object objeto). Pero al comparar los atributos del objeto

introducido en el método, nos dará error ya que, en el prototipo se tiene que usar la

clase Object y no contiene las características de nuestro objeto.

Para poder comprarlo, tenemos que hacer un downcasting, es decir, transformar el

objeto de la clase Object a la clase deseada: (NuestroObjeto)objeto.

39

-Valor Creativo-


Clase

Tiene la doble misión de capturar el momento actual así como de manejar y convertir

diferentes formatos de fechas y tiempo en general. Para su uso, hay que importarlo desde

la librería JAVA.

El constructor por defecto genera un objeto que captura el instante en el que fue creado.

La mayoría de sus métodos están en desuso,aunque destacan:

setTime()devuelve el número de milisegundos desde 1 de Enero de 1970 (Tiempo

UNIX).

toString() indica la fecha al generar el método con el formato año-mes-día.

40

-Valor Creativo-


Clase

Sus objetos contienen secuencias de números pseudoaleatorios generados a partir de un

número, denominado semilla. Este número se puede proporcionar en un constructor

parametrizado, o bien, dejar que JAVA la genere a raíz de la fecha/hora del sistema del

sistema con el constructor sin parámetros.

Para poder emplear la clase Random tenemos que importarlo a través de la librería de

JAVA: importjava.util.Random;

Su métodonextInt(int) devuelve un número aleatorio desde el 0 hasta el número entero

proporcionado menos 1.

Clase y

Son clases de grandes números enteros o decimales, que no caben en un long o en un

double. Son muchos más lentos, ya que requieren una operación de cada dígito.

Para su utilización necesitan ser importados por la librería de JAVA. Se pueden crear

utilizando un String que representa dicho número.

Para operar con ellos hace falta usar sus métodos, entre los que destacan:

add() sirve para la suma de dos números.

substract() sirve para restar.

multiply() multiplica dos números.

divide() sirve para la división entre dos valores.

41

-Valor Creativo-


Clases

Los tipos de datos primitivos no son objetos, pero en ocasiones es necesario tratarlos como

tales. Por ejemplo, hay determinadas clases que manipulan objetos.

Para poder utilizar tipos primitivos con estas clases,JAVA provee las llamadas clases

envolventes, también llamadas clases wrappers. Estas clases “envuelven” un valor del tipo

simple al que representan en un objeto, para poder trabajar con ellos como si fueran

objetos.

Cada tipo primitivo tiene su correspondiente clase wrapper:

Tipo primitivo Clase Envolvente

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

Tienen un método estáticoque comienza por parse que sirve para convertir un String al

tipo simple envuelto. Su prototipo es: ClaseEnvolventeparseTipo(valor).

42

-Valor Creativo-


CLASES Abstractas

Son clases cuya descripción es incompleta. Una clase abstractadeclara métodos, pero no

tiene que implementarlos. Se caracterizan por:

Suelen contener algún método abstracto, en el cuál no existe código escrito.

No se pueden crear objetos de dicha clase.

Es posible declarar referencias del tipo de la clase abstracta.

Para definir un método o claseabstracta en JAVA, basta con anteponer la palabra reservada

abstract delante del método o clase.

En el caso de declarar un método abstracto, no se debe escribir código para el mismo, ni

siquiera código vacío si no que se declara con punto y coma.

43

-Valor Creativo-


Si queremos utilizar sus funcionalidades, estamos obligados a crear una clase que herede de

la clase abstracta, y que sobrescriba los métodos abstractos que tuvieran.

44

-Valor Creativo-


Interfaces

Es un concepto similar al de clase abstracta, es decir, es un molde que define una

estructura formal de métodos para una clase, aunque no especifica su código. Su principal

función es establecer y estabilizar prototipos de métodos de una clase que está por

desarrollar, y así coordinar varios equipos de trabajo.

Se parecen a las clases abstractas, pero a diferencia de éstas, todos sus métodos son

obligatoriamente abstractos y públicos.

Sirven para implementar un mecanismo similar al de herencia múltiple de otros lenguajes

orientados a objetos.

En JAVA se declaran utilizando la palabra reservada interface.

Para crear una clase que escriba código para los métodos de una interfaz, se utiliza la palabra

implements para implementar la interfaz.

Se pueden declarar referencias a objetos cuyo tipo sea una interface en lugar de una clase.

Esta forma de proceder tiene sentido para definir un objeto en función de un tipo más

genérico para utilizar mecanismos como el polimorfismo.

Viento

public void tocar() public String sonido()

public void ajustar()

<<interface>>

Instrumento public void tocar();

public String sonido();

public void ajustar();

Percusión public void tocar()

public String sonido()


Cuerda public void tocar()



implements

implements

implements

Saxofón public void tocar()


Ukelele

public void tocar()


extends

extends

45

-Valor Creativo-


Interfaz

La interfaz Comparable sirve para dotar de un orden natural a los objetos de una clase

determinada.

Las clases que la implementen, serán moldes para objetos que son susceptibles de ser

comparados entre sí, y por tanto, ordenados.

Tiene un solo método denominado compareTo(Object) que devuelve un número entero al

comparar los dos objetos:

Devuelve un número negativo si la referencia del objeto (this) es menor que el

objeto al comparar.

Devuelve un 0 si los objetos son iguales.

O devuelve un número positivo si thises mayor que el objeto a comparar.

46

-Valor Creativo-


POLIMORFISMO

El polimorfismo es un mecanismo que proveen los lenguajes orientados a objetos, para tratar

de forma similar a los objetos de diferentes clases.

Consiste en crear un objeto de una clase baja en una jerarquía y guardar su referencia

en una variable más alta en la jerarquía.

Cuando se pida la ejecución de un método rescrito en el “Hijo”, se ejecutará este último, no

el del “Padre”.

El punto está en que si se define otro objeto de otra clase distinta (Hijo2), pero que hereda

del mismo “Padre”, y rescribe un método del “Padre”, cuando se pida la ejecución al

“Hijo2” de dicho método, ejecutará el del “Hijo2” y no el del “Padre”.

47

-Valor Creativo-


La gran ventaja estriba en construir colecciones de objetos, por ejemplo con un array, de

naturaleza diversa pero homogeneizadas bajo un mismo tipo (el del “Padre” común a todas

las clases que se quieran contener), de esta forma, polimórficamente se accederán a los

métodos reales de cada objeto, utilizando un código común para todos ellos.

48

-Valor Creativo-


EXCEPCIONES

En programación se entiende “excepción” como un error (fallo del programa) que ocurre en

tiempo de ejecución y no pudo ser previsto cuando se compiló.

Cuando un programa muestra un comportamiento excepcional y falla, lo que ocurre

normalmente es que el sistema operativo detiene la ejecución del mismo, proporcionando

algún mensaje que muestre la causa del fallo.

Si compila: Pero, da un error al ejecutarlo:

JAVA provee de un mecanismo de manejo de errores o excepciones que permiten al

programador controlar en su código fuente situaciones que normalmente provocarían la

interrupción de ejecución, permitiendo recomponerse y continuar con el desarrollo

normal del programa.

o Estrategia de manejo pesimista:

La forma clásica de evitar un error en tiempo de ejecución es mediante esta estrategia

que consiste en proteger zonas “peligrosas” del código con sentencias “if “que se

aseguren de que los datos con los que van a tratar son los adecuados.

Este método contiene varias desventajas:

Dificultad de prevención de todos los posibles fallos.

Como los datos suelen ser correctos, se ejecuta innecesariamente el “if” con la

consiguiente penalización en el rendimiento.

49

-Valor Creativo-


o Estrategia de manejo optimista:

Las técnicas de manejo de excepciones siguen esta estrategia y asumen en un gran

porcentaje de casos el código “peligroso” no provocará fallo, pero en caso de que

ocurran, se ejecutará otra porción de código, en lugar de abortarse la ejecución.

Para ello, en JAVA se protege el código peligroso con un bloque “try{código

peligroso}”, y a continuación se escribe un bloque “catch (Excepcion e){código de

manejo de error}”en el que escribiremos el código de lo que queremos hacer en caso

de que ocurra el fallo.

Clase

Cuando ocurre una excepción, la máquina virtual de JAVAcrea un objeto de la

claseException, o más habitualmente, un objeto de una clase “descendente” de Exception.

En este objeto, la máquina virtual de JAVAencapsula toda la información relevante del

error: quién lo ha producido, en qué instante, por qué causa,..

Un mismo código “peligroso”, puede producir excepciones de naturalezas muy diferentes.

Por cada una de ellas, la máquina virtual de JAVA creará un objeto de una subclase de

Exception distinta.

Para cada bloque try, podemos escribir un bloque catch para cada excepción de naturaleza

diferente que se pueda producir, de esta manera, trataremos excepciones diferentes de

maneras diferentes.

Adicionalmente se puede escribir detrás de los catch un bloque finally, que se ejecutará

siempre.

50

-Valor Creativo-


Métodos de la claseException:

getMessage(): devuelve un String que sugiere la razón por la que ha ocurrido la

excepción.

toString(): devuelve la clase de la excepción concatenada con el String que devuelve

getMessage().

Exception(String):constructor de la clase que sirve para crear una excepción con un

mensaje personalizado, el cual devuelve getMessage().

printStackTrace(): muestra por pantalla la cadena de excepciones que han llevado al

lanzamiento de ésta.

51

-Valor Creativo-


Se pueden lanzar excepciones con el comando throwobjetoException. El objeto que se le

pasa a throw tiene que ser de la clase Exception o de cualquier subclase que la “extienda”.

Si en el código de un método se lanza una excepción de su clase, en el prototipo del método

debemos indicarlo con la palabra reservada throws.

Cuando en un código utilizados métodos que lanzan potencialmenteexcepciones, es decir,

que en su prototipo tengan throws, estamos obligados a hacer una de estas dos cosas:

Proteger la llamada a dicho método con un bloque try…catch.

O indicar en el prototipo del método invocante que puede lanzar una excepción,

gracias a throws.

Podemos crear nuevas excepciones, no previstas por JAVA o que sólo tienen sentido en

nuestro código, basta con crear clases y heredar de la clase Exception.

Lo que se suele hacer cuando se crea una excepción personalizada es crear un constructor

de la clase creada, ygracias al método super() ,utilizar el constructordeException para que

se puedan crear objetos de nuestra clase con un mensaje personalizado de getMessage().

También para asociar un mensaje personalizado a nuestra excepción sería sobrescribir el

método getMessage(); o bien, sobrescribir el método toString(). Aunque, el inconveniente

de esta técnica, es que todas las excepciones de esta clase compartirían el mismo mensaje.

52

-Valor Creativo-


ARRAYS

Un array es una variable que contiene varios valores bajo un único nombre. Aunque, en

realidad son objetos que ocupan una dirección de memoria.

Un array es como una “caja” con múltiples compartimentos numerados desde el 0 hasta

el numero de compartimentos menos uno. Una vez conocido el nombre o referencia de un

array, podemos acceder a cada uno de sus compartimentos individualmente para leer o

escribir en ellos.

Declaración: tipo[] nombreArray;

Inicialización: nombreArray = new tipo[tamaño];

Asignación de valores: nombreArray[númeroCelda]=valor;

O todo en una vez: tipo[] nombreArray = {valor1, valor2,…, valorN};De esta manera,

cuando indicamos los valores, automáticamente crear el tamaño del array.

Para poder visualizar el contenido de un array no es posible hacerlo directamente, es decir,

invocándolo solo por su nombre, ya que lo que se muestra seria la dirección de memoria

que ocupa el array. Por lo que, para mostrar su contenido se emplea su método estático

toString(array) de la clase Arrays.

Los valores contenidos en un array también pueden ser referidos a objetos. Téngase en

cuenta que al pasar un array a un método se le pasa su dirección de memoria, y el código

del método podría modificar el contenido del array.

53

-Valor Creativo-


Se pueden trabajar con arrays de más de una dimensión, al estilo de las matrices de

matemáticas.

Se específica la dimensión en la declaración del array, concretamente con los corchetes[],

por ejemplo, para una bidimensional se utilizan dos corchetes ([][]), para tridimensional tres

corchetes ([][][]), etc.

Después de inicializarla, se procede a dar el tamaño de las dimensiones dentro de los

corchetes: [valor1][valor2].

Y por último, se les asigna los valores en los distintos huecos de las dimensiones.

54

-Valor Creativo-


Argumentos de entrada en

El método main de una clase es el primero y único que se ejecuta, al solicitar desde el

sistema operativo, la ejecución de esa clase sobre la JVM.

Al igual que el resto de métodos, el método main también tiene argumentos de entrada, en

concreto uno, que es de un array de tipo String y se suele llamar args.

En cada casilla de este array, la JVM copiará cada palabra “extra” que aparezca en el

comando de ejecución de la clase sobre la JVM.

De esta manera podremos suministrarle a la clase que estamos ejecutando, datos externos,

para que se comporte de una manera diferente en cada ejecución.

Para que los datos sean útiles, si no queremos tratarlos como tipo String, utilizaremos los

métodos estáticos parse... de las clases wrapper, explicadas anteriormente.

55

-Valor Creativo-


Como introducir argumentos de entrada:

Mediante comandos: Una vez compilado el archivo .java, al ejecutar el programa

mediante el comando java, después del nombre del fichero, se introduce los parámetros

de entrada.

Mediante el programa de JGRASP: BuildRun ArgumentsIntroducir valores

56

-Valor Creativo-


Colecciones de objetos

Las colecciones de objetos en la programación orientada a objetos son clases predefinidas,

cuyos objetos proporcionan la funcionalidad de compilar, recoger o coleccionar otros

objetos. Intuitivamente se pueden entender como clases que crean objetos-bolsa, dentro de

los cuales meteremos otros objetos.

Como las clases de tipo colección, pueden contener a priori cualquier clase de objetos, su

contenido son objetos de a clase Object, ya que es la única superclase común a todas las

demás.

JAVA provee de dos tipos diferenciados de colecciones:

Colecciones de objetos simples (Collection)

Colecciones de pares de objetos (clave, objeto) (Map)

La diferencia entre ambas es que Map está pensada para guardar junto al objeto principal,

otro objeto (clave) que me permita acceder al primero de forma directa.

Es como un array en el que la casillas, en lugar de ir numeradas van identificadas por el

objeto clave.

La interfaz Collection colecciona objetos simples. Existen otras interfaces que lo

implementan, y de cada una implementan unas clases especiales.

Se crea un objeto de la clase Collection, escogiendo uno de sus descendientes, guardando

la referencia en una variable del mismo tipo que la clase referida o alguno de sus

antecesores.

57

-Valor Creativo-


En general, se suele optar por una referencia más genérica o más alta, ya que permite

cambiar la implementación de la colección en el futuro. Cuando se necesite utilizar un

método propio de cada implementación siempre se puede hacer un Downcasting.

Una vez creada la colección, se añaden objetos utilizando el método add().

Normalmente, cada colección contendrá objetos de una misma clase. Los objetos de otras

clases sufrirán un Upcasting hacia Object al introducirse dentro de una colección.

Las implementaciones habituales de Collection suelen tener rescrito su método toString(), de

manera que es sencillo ver el contenido de una colección rápidamente. Esto mostrará una

lista de objetos contenidos entre corchetes y separados por comas.

58

-Valor Creativo-


Métodos de

inthashCode(): Devuelve un número entero característico de cada objeto. Por defecto,

este número es la posición de memoria que ocupa el objeto.

Una función hash sirve para “mapear” o asociar conjuntos infinitos a conjuntos

finitos, por tanto puede haber dos elementos distintos que compartan el mismo

código hash. La función será mejor cuantas menos colisiones genere.

Si queremos que dos objetos involucrados en una colección implementada con

funciones hash se consideren iguales, su función hash debe devolver el mismo

número para ambos objetos. Como tener el mismo código hash no significa

necesariamente que sean iguales, también deberán tener el método equals() bien

definido.

booleanadd(Object):Añade un nuevo elemento al final de la colección.

booleanaddAll(Collection):Añade todos los elementos de la colección especificada a

esta colección

voidclear():Elimina todos los elementos de la colección.

booleancontains(Object): Comprueba si el elemento especificado es parte de la

colección.

booleanisEmpty(): Comprueba si la colección está vacía o no.

intsize(): Devuelve el número de elementos que se encuentran actualmente en la

colección.

booleanremove(Object): Elimina la primera ocurrencia del elemento indicado. Si se

encontró y se borró el elemento, devuelve true, en caso contrario devuelve false.

booleanremoveAll(Collection): Elimina todos los elementos contenidos en la

colección.

booleanretainAll(Collection): Conserva sólo los elementos que están contenidos en

el argumento.

Object[] toArray(): Devuelve un array con todos los elementos de la colección.

Object[] toArray(Object[] tipo): Devuelve un array, del tipo especificado, con

todos los elementos de la colección.

59

-Valor Creativo-


Interfaz

El orden es la característica más importante de List, que se compromete a mantener los

elementos en una secuencia particular.

List contiene una serie de métodos para Collection que permiten la inserción y extracción

de elementos en el medio de una lista. List producirá un ListIterator que permite recorrer

una colección en ambas direcciones, así como insertar y quitar elementos de la

colección.

ArrayList: Permite un rápido acceso aleatorio de los elementos de una colección,

pero es lento al insertar o extraer elementos.

LinkedList: Proporciona acceso secuencial óptimo, con inserciones y eliminaciones

de elementos en las colecciones de bajo costo.

Métodos de List:

get(index:int): Devuelve el objeto que se encuentre en la posición index.

set(int, Object): Introduce un objeto en una posición y devuelve el que estaba antes.

indexOf(Object): Devuelve la primera posición en la que se encuentra un

determinado objeto.

sort(List): Permite ordenar una colección List.

Interfaz

En las interfaces Set no permite duplicados, es decir, cada objeto agregado debe ser único,

de lo contrario, no se agregará el objeto duplicado. Los objetos que se agreguen a un Set

deben definir equals() para establecer singularidad.

HashSet: Permite un rápido acceso de búsqueda rápida. Los objetos deben definir

el método hashCode().

TreeSet: Permite un conjunto de objetos ordenados. Los objetos deben

implementar la interfaz Comparable.

LinkedHashSet: Tiene la velocidad de búsqueda de un HashSet, pero mantiene el

orden en que se agregan los elementos, internamente usando una lista enlazada.

Así, cuando recorre en iteración el conjunto, los resultados aparecen en la orden de

inserción.

60

-Valor Creativo-


La interfaz Map está pensada para guardar junto al objeto principal, otro objeto (clave) que

permite acceder al primero de forma directa, es decir, almacena una serie de clave/valor. Las

claves, al identificar a cada objeto, deben ser únicas.

Como caso práctico, la clave puede ser el carnet de identidad de una persona, y como valor,

el objeto que contiene toda la información y métodos de una persona.

Las clases que implementan la interfaz Map son:

HashMap: no existe orden en la clave (necesita definir hashCode()).

TreeMap: sí existe orden en la clave (necesita implementar Comparable).

Para crear un Map se tiene que especificar el tipo de la clave y el tipo del valor:

Map<tipo_clave, tipo_valor> m = new clase_implementa<tipo_clave, tipo_valor>

Métodos de Map:

put(valor_clave, valor_valor): añade elementos a la colección.

get(clave): obtiene el valor de la clave especificada.

constainsKey(<tipo_clave> clave): comprueba si en la colección está o no la clave

especificada.

constainsValue(<tipo_valor> valor): comprueba si en la colección está o no el valor

especificado.

keySet(): devuelve un conjunto con las claves de la colección.

values(): devuelve un conjunto con todos los valores de la colección.

remove(<tipo_clave> clave): elimina el objeto de la colección asociado con la clave

especificada.

61

-Valor Creativo-


Iteradores

Son objetos de la clase Iterator asociados a las colecciones que sirven para recorrerlas.

De esta manera, el código es homogéneo para recorrer cualquier clase de colección.

La forma de usarse es:

Pedir a la colección que te proporcione un Iterator usando un método llamado

iterator().

Comprobar si queda algún objeto con el método hasNext() del Iterator, para

comprobar si la colección está vacía.

Obtener el siguiente elemento de la colección con el método next(), que

automáticamente avanza a la siguiente posición.

Se puede borrar el último elemento devuelto por el Iterator con remove().

Otra forma de recorrer una colección es utilizar un for mejorado que ofrece JAVA:

for (Object objeto : coleccion) {…}

62

-Valor Creativo-


Listas, pilas y colas

Son tipos abstractos de datos o estructuras de datos informáticas que sirven para gestionar

el trasiego de datos en múltiples sistemas y situaciones. Todas ellas coleccionan datos.

Listas ( )

Los datos nuevos se ubican al final de la lista, o bien, en su posición adecuada, si la lista

es ordenada. Permiten almacenar elementos duplicados, aunque depende de la

implementación.

Se puede consultar cualquier elemento de la lista. También se puede eliminar cualquier

elemento de la lista, reajustándose el resto a la nueva situación.

Pilas ( )

Son estructuras tipo LIFO, es decir, el último elemento que entra, es el primer elemento

que sale. Son estructuras usadas habitualmente por los

compiladores y los sistemas operativos.

Los elementos nuevos siempre entran al final de la pila (apilar).

Sólo se puede consultar el último elemento de la pila. Los

demás elementos quedan ocultos tras él.

Y sólo se pueden borrar el elemento de la cabeza de la pila

(desapilar), pasando a ser la nueva cabeza el penúltimo elemento introducido.

Colas ( )

Son estructuras de tipo FIFO, es decir, el primer elemento que entra, es el primer

elemento en salir. Son estructuras típicas de sistemas de mensajería asíncronos o buffers, en

el que es importante conservar el orden de llegada de los elementos.

Los nuevos elementos siempre entran al final de la cola (encolar).

Solo se suele poder consultar el primer elemento de la cola. Los

demás elementos quedan ocultos tras él.

Sólo se puede borrar el primer elemento de la cola (desencolar),

pasado a ser la nueva cabeza el elemento anterior a éste.

Encolar

Desencolar

63

-Valor Creativo-


Clases genéricas

Son técnicas que se incorporan desde JAVA 5, especialmente útiles en colecciones de

objetos. Se utilizan con clases compuestas: clases que contienen o usan referencias a

objetos de otras clases.

Suponen un mecanismo alternativo al uso de Object cuando queremos trabajar con objetos

genéricos, independientemente de su naturaleza.

En el caso de las colecciones son muy útiles porque permiten saber en tiempo de

compilación el tipo de los objetos contenidos en una colección, y poder detectar errores de

compilación.

Hacen totalmente innecesario el Downcasting desde Object, ya que la colección no contiene

Object, sino del tipo de clase especificado.

Los que desarrollan clases genéricas indican que el tipo del elemento es <E> (de element) en

lugar de Object. Cuando se declara y se instancia la clase genérica se está obligando a indicar

entre “<…>” que clase queremos que sustituya a<E>, cosa que ocurre antes del proceso de

compilación, es como si hiciera un copia y pega del nombre de la clase real en toda las

apariciones de <E>.

64

-Valor Creativo-


Almacenamiento de datos

Existen varias maneras para conservar los valores de un dato en un dispositivo de

almacenamiento:

Creando un archivo y guardando en él los datos tal cuales o en modo texto.

Deberemos controlar nosotros el formato de dicho archivo.

Pidiéndole a la máquina virtual de JAVA que almacene todos los datos del

objeto en un archivo, pero dejando que gestione la propia máquina virtual el

formato.

O pidiéndole a un sistema gestor de bases de datos que almacene los datos

en alguna de sus estructuras en una base de datos: tablas, vistas, índices,…

Clases para almacenamiento de datos

InputStream: Encapsula un flujo de bits para leer, que pueden provenir del teclado,

de un fichero o de una conexión de red. Proporciona métodos para leerlos byte a byte.

InputStreamReader: Igual que el anterior, pero está pensado para interpretar los

bytes como caracteres. Proporciona métodos para ir leyendo caracteres.

BufferedReader: Igual que los dos anteriores, pero está mejorado para poder leer

líneas enteras de caracteres como Strings, gracias a sus métodos.

FileInputSteam y FileReader: Cuando el flujo de caracteres provienen de un fichero,

podemos utilizar estas clases especializadas en la lectura de ficheros.

PrintWriter: Imprime o escribe datos en una secuencia de texto de salida.

FileWriter: Permite la creación o sobre escritura de un fichero de texto para el

almacenamiento de datos.

65

-Valor Creativo-


Lectura de un fichero de texto

66

-Valor Creativo-


Escritura de un fichero de texto

67

-Valor Creativo-


Lectura/Escritura de un fichero binario

68

-Valor Creativo-


Acceso a una Base de Datos

Para almacenar o consultar información de Base de Datos desde un programa hecho en

JAVA, debemos conectar entre sí los estándares que conectan a una base de datos de

JAVA (JDBC) y del sistema operativo (ODBC).

Existen drivers que permiten esta conexión entre los estándares que se pueden descargar de

la página oficial de la base de datos con la que vayamos a trabajar.

Conectar a una base de datos Access:

Cargar Driver ODBC:

69

-Valor Creativo-


Conectar a una base de datos MySQL:

Cargar Driver JDBC:

1. Descargar driver e instalar 2. Añadir .jarMySQL en el Path

70

-Valor Creativo-


Sentencias SQL

Una vez conectados a la base de datos, podemos interactuar con ella para realizar consultas,

inserciones, modificaciones y borrados de las tablas.

Para ello, se emplea la variable PreparedStatement, la cual almacena la correspondiente

sentencia SQL que vayamos a ejecutar.

En el caso de las consultas SQL (SELECT) se emplea el método executeQuery()en vez de

execute().

71

-Valor Creativo-


Serialización de Objetos

La serialización de un objeto consiste en obtener una secuencia de bytes que represente el

estado de dicho objeto. Al poder convertir el objeto a bytes, ese objeto se puede enviar a

través de la red, guardarlo y leerlo de un fichero,…

Para que un objeto sea serializable, debe implementar la interfaz Serializable (paquete

java.io), la cual no define ningún método. Simplemente se usa para “marcar” aquellas

clases cuyas instancias pueden ser convertidas a secuencias de bytes.

Para escribir en un documento los objetos, necesitamos declarar la clase

ObjectOutputStream, donde irá almacenado el fichero (FileOutputStream).

72

-Valor Creativo-


En cambio, para la lectura de los objetos almacenados en un fichero, se emplea la clase

ObjectInputStream, donde irá almacenado el fichero a leer (FileInputStream).

73

-Valor Creativo-


Interfaz gráfica

La UI (User Interface) es la parte de un sistema que gestiona la

interacción del usuario humano con el mismo. Pertenece al

sistema, pero está en el límite, es decir, es la capa más externa de

nuestro desarrollo.

Las librerías que se han de importar normalmente para trabajar con

entorno gráfico son:

java.awt.*;

java.awt.event.*;

javax.swing.*;

javax.swing.event. *;

JFrame

La clase JFrame representa a una ventana. Es el principal contenedor del resto de

componentes de una UI.

Una UI puede tener varias ventanas, y la transición entre ellas debe estar controlada por

una máquina de estados o por las propias ventanas.

Métodosbásicos:

getContentPane(): Devuelve el panel de contenido asociado al JFrame.

add(JComponent): Añade un componente a la ventana. En realidad, lo añade a su

panel de contenido.

setTitle(String): Añade un título a la ventana.

setSize(ancho, alto): Otorga dimensión a la ventana.

setLocation(x, y): Ubica la ventana.

setVisible(boolean): Activa o desactiva la ventana.

setMenuBar(JMenuBar): Añade a la ventana un menú.

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): Consigue que la ventana

se cierre(finalizar la ejecución) cuando pulsemos el aspa roja, de cerrar ventana.

74

-Valor Creativo-


JPanel

Es un contenedor, en el cuál, van los distintos componentes, incluyendo otros JPanel,

aportando la capacidad de poder controlar su aspecto, como por ejemplo color, distancia

entro los objetos añadidos,…

Métodos básicos:

add(JComponent): Añade componentes al panel, ubicándose éstos, en el lugar que

le corresponde en función de su gestor de distribución LayoutManager.

setBackground(Color):Cambia el color de fondo del panel.

setLayout(LayoutManager): Configura la forma en la que se distribuirán los

componentes que se añadan al panel.

setBorder(BorderFactory):Configura la línea que bordea al panel, o sirve para

crear un borde invisible, de manera que los componentes añadidos no se ajusten

totalmente al panel.

LayoutManager

Es una clase de fabricación pura que representa el aspecto, forma y el orden en el que se

distribuirán los componentes de un panel. Están pensadas para evitar la ubicación de

componentes en función de unas coordenadas absolutas.

Para establecer el gestor de posicionamiento en un contenedor se utiliza el método

setLayout() con un objeto de las clases que implementan a LayoutManager.

Clases que implementan la interfaz LayoutManager:

FlowLayout: Distribución horizontal. Uno detrás de otro, dejando un espacio entre

ellos.

75

-Valor Creativo-


BoxLayout: Muestra los componentes en una única fila (X_AXIS) o columna

(Y_AXIS), dependiendo de la constante a utilizar. Su constructor necesita un

argumento con el contenedor a utilizar y la constante que determina la orientación.

GridLayout: Se crea una rejilla de unas determinadas dimensiones y se van ubicando

los componentes de izquierda a derecha y, de arriba abajo (columnas, filas).

BorderLayout: Define 5 zonas (norte, sur, este, oeste, centro) y hay que decir en cada

caso dónde se ubicará cada componente. Para añadir los componentes se utiliza el

método add(Component, BorderLayout.ZONA).

76

-Valor Creativo-


CardLayout: Se apilan unos componentes encima de los otros, quedando sólo el

primero añadido visible. Es el Layout por defecto de la clase JFrame.

SpingLayout, GrindBagLayout: Layouts más complejos que permiten más

flexibilidad a la hora de ubicar elementos.

JLabel

Puede contener un texto, un icono o ambos a la vez.

Para que pueda contener una imagen, en el constructor del JLabel, añadimos un objeto

ImageIcon, en el cual indicamos la ruta de la imagen en su constructor. La imagen que

vayamos a utilizar, debe estar en el mismo paquete dónde se encuentra nuestro

archivo.java.

Métodos:

JLabel(String): Constructor que crea una etiqueta con el texto proporcionado.

setText(String):Cambia el texto de un determinado JLabel.

setForeground(Color):Cambia el color de la fuente del texto.

setFont(String, Font, int): Cambia el formato del texto, especificando el tipo de

letra, la fuente y el tamaño.

77

-Valor Creativo-


JTextField

Es un campo de edición de texto. Es como un JLabel, pero el texto se puede editar desde la

interfaz gráfica.

Métodos:

JTextField(String): Constructor que crea un campo de edición de texto, con texto

incluido a través de un String.

JTextField(int): Constructor que crea un campo de edición de texto vacío, cuyo

tamaño es el especificado, a través de número de caracteres.

setText(String): Cambia el texto contenido por el introducido.

getText(): Obtiene el texto contenido.

JButton

Simboliza un botón hardware que se puede presionar y que, normalmente, va etiquetado

con un texto o una imagen. Es uno de los principales componentes utilizados para iniciar

acciones y solicitar servicios a la capa de reglas de negocio.

Métodos:

JButton(String): Constructor que crea un botón etiquetado con el String

proporcionado.

JButton(Icon): Constructor que crea un botón etiquetado con la imagen

proporcionada.

78

-Valor Creativo-


Menús

JMenuBar. Es el elemento principal cuando vamos a crear menús, ya que provee la

barra donde se alojaran cada uno de los ítems u opciones deseadas.

JMenu. Contiene los componentes del menú, a este se le agregan el resto de

opciones. Permite agregar los elementos correspondientes, así como otros JMenus.

JMenu(String): Constructor que crea un componente al menú con nombre.

add(JMenuItem): Añade un ítem al menú.

addSeparator():Añade una línea de separación entre componentes.

JMenuItem. Representan ítems u opciones del menú. Cuando creamos un JMenu

decimos que tipo de opciones puede contener, y al crear un JMenuItem decimos

cuales son las opciones para ese menú.

JMenuItem(String): Constructor que crea una opción con el nombre

introducido.

JMenuItem(String, Icon): Constructor que crea una opción, y además del

nombre, añade una imagen.

JRadioButtonMenuItem. Componente con RadioButton.

JCheckBoxMenuItem. Componente con casillas de verificación.

79

-Valor Creativo-


Otros Componentes

JSeparator. Introduce una línea separadora en el panel o contenedor al que sea

añadido.

Métodos:

JSeparator(SwingConstants.HORIZONTAL): Constructor que crea un

separador con la orientación horizontal.

JSeparator(SwingConstants.VERTICAL): Constructor que crea un

separador con la orientación vertical.

JCheckBox. Permite implementar un cuadro de selección.

JRadioButton. Permite mostrar RadioButton.

JColorChooser. Proporciona un panel de controles diseñados para permitir a un

usuario seleccionar un color.

JComboBox. Lista desplegable en la cual el usuario puede seleccionar un valor.

ListModel y JList. Componente que muestra una lista de objetos y permite al usuario

seleccionar uno o más elementos.

JProgressBar. Muestra visualmente el progreso de una tarea.

JScrollBar y JScrollPane. Barras de desplazamiento.

JTabbedPane. Es un componente que permite a un usuario estarse intercambiando

entre grupos de componentes que se encuentran en una especie de folders, cada uno

de ellos con su propia pestaña.

JTree. Componente que muestra un conjunto de datos jerárquicos, como un

esquema.

80

-Valor Creativo-


Clase Graphics

Es una clase abstracta, que encapsula un objeto en el que se pueden realizar dibujo

sutilizando sus métodos, es como una especie de lienzo.

Una forma de poder dibujar gráficos es haciéndolo sobre el propio gráfico correspondiente a

un componente, rescribiendo su método paint(Graphics). El componente habitual sobre el

que dibujar es un JPanel, pero en principio podemos hacerlo en cualquiera.

Hay eventos que redibujan un componente, pero si nos interesa redibujar algo por código,

llamaremos al método repaint() del componente a repintar.

Algunos de los métodos que permiten dibujar gráficos:

drawLine(x. y, vertical, horizontal): Dibuja una línea en las coordenadas

otorgadas(horizontal, vertical), especificando su oblicuidad.

drawArc(x, y, ancho, alto, anguloInicial, anguloArco): Dibuja un arco.

drawOval(x, y, ancho, alto): Dibuja un óvalo.

drawRect(x, y, ancho, alto): Dibuja un rectángulo en las posiciones indicadas.

drawString(String, x, y):Dibuja el texto especificado en las coordenadas.

81

-Valor Creativo-


Tipos enumerados

JAVA permite que una variable tenga solo un valor dentro de un conjunto de valores

predefinidos, en otras palabras, valores dentro de una lista enumerada. Esto se da gracias a

los tipos enumerados, que sirven para expresar conjuntos finitos de valores a medida.

Se declaran fuera o dentro de una clase, pero nunca dentro de un método. Se declaran gracias

al comando enum: enum nombre {VALOR1, VALOR2,…, VALORn}. Por convenio, se

suelen escribir los valores en mayúsculas ya que se tratan de constantes.

Se pueden declarar variables o atributos de tipos enumerados como de cualquier otro tiple

simple u objetos. También se pueden asignar valores a sus variables y compararlas entre sí.

82

-Valor Creativo-


Manejo de eventos

Cuando el usuario hace “click” con el ratón sobre un botón, pulsa “ENTER” tras escribir algo

en un cuadro de texto, selecciona una opción de un menú,… genera un evento que puede ser

detectado y manejado por la máquina virtual de JAVA.

La gestión de eventos de los frameworks de JAVA siguen el patrón Observer, en el que hay

clases emisoras de eventos, y clases que se suscriben a la ocurrencia de eventos generados

por las primeras y actúan en consecuencia.

El componente que queremos controlar sus eventos, tiene que implementar la interfaz

ActionListener, ya que para accionar el componente se emplea el método

addActionListener(AcionListener). Al añadir un objeto de ActionListener, todos las

instrucciones que queremos que ejecute el componente se han de especificar dentro del

método actionPerformed(ActionEvent arg0).

83

-Valor Creativo-


Servlet

Un servlet es una clase JAVA que se utiliza para ampliar las capacidades de un servidor.

Dicho servidor es un servidor web, y el servlet es capaz de procesar peticiones HTTP.

Para adquirir estas capacidades, el servlet hereda de la clase HttpServlet.

Métodos de la clase HttpServlet:

init(): se ejecuta una sola vez al cargar el servlet.

service(): es el main() del servlet. NO hay que sobrescribirlo.

destroy(): se ejecuta una vez finalizado el servlet.

doGet(): se ejecuta cuando se recibe una solicitud por el método GET o no se reciban

parámetros.

doPost(): se ejecuta cuando se recibe una solicitud por el método POST.

Estos dos últimos métodos deben ser sobrescritos para personalizar el servlet. Ambos

métodos reciben como argumentos dos objetos llamados:

response: encapsula toda la información de los datos que enviaremos

request: encapsula toda la información de los datos provenientes del invocante.

Este último objeto (request), contiene métodos para la consulta de parámetros de entrada:

getParameter(elemento): obtiene el valor del elemento indicado.

getParameterValues(elemento): obtiene, en un array, los múltiples valores del

elemento. Suele usarse para elementos como un select, checkbox,…

getParameterNames(): obtiene el nombre de todos los parámetros de entrada como

una colección. Las enumeraciones se pueden recorrer con un iterador o un for( : ){}.

setAttribute(„clave‟, „valor‟): envía datos de un servlet a otro, donde cada valor se

asocia a una clave.

getAttribute(„clave‟): obtiene le valor de la clave especificada.

En los servlets no deberían dedicarse a enviar texto HTML, por lo que para mantenerlo

separado, se puede incluir un código HTML estático utilizando el siguiente comando:

request.getRequestDispatcher(“archivo.html”).include(request, response).

84

-Valor Creativo-


Subir ficheros

Tenemos que anotar en el servlet la carpeta donde se almacenará los archivos y el tamaño

máximo de estos:

@MultipartConfig(location = "C:\\carpeta_destino", maxFileSize = 10485760L)

Recuperar el archivo de un formulario:

Part archivo = request.getPart("name_del_campo_file");

Para obtener el nombre original del fichero se suele crear dicho método:

Tenemos que renombrar el fichero temporal, ya que si no se pierde al terminar la ejecución:

archivo.write(devuelveNombreArchivo);

Cookies

Para crear una cookie, se emplea el objeto Cookie otorgando un nombre y un valor:

Cookie c = new Cookie(nombre,valor);

Métodos del objeto Cookie:

setvalue(“valor) Cambia el valor de la cookie

setMaxAge(int) Establece la vida de la cookie

Se envía la cookie al cliente para que la tenga almacenada:

response.addCookie(c);

Podemos obtener las cookies que pueda tener el cliente, en forma de array:

Cookie[] cs = request.getCookies():

Como se obtiene un array, podemos comprobar si existe alguna cookie con el siguiente if:

if (cs != null && cs.length > 0) { }

85

-Valor Creativo-


Sesiones

Para crear u obtener una sesión ya iniciada, se emplea el objeto HttpSession:

HttpSession sesión = request.getSession(true);

Métodos del objeto HttpSession:

getId() Obtiene el identificador de la sesión.

getAttribute(nombre) Recupera el dato de la sesión.

getCreationTime() Obtiene la hora y fecha de la creación de la sesión.

getLastAccesedTime() Devuelve la última vez que el cliente envía una

solicitud asociada con dicha sesión.

setAttribute(nombre , objeto) Guarda datos, en forma de objetos, en la sesión.

removeAttribute(nombre) Elimina el dato especificado de la sesión.

invalídate() Destruye la sesión.

Acceso a BBDD

Para poder acceder desde nuestro servlet a una base de datos, necesitamos tener la librería en

la carpeta lib de nuestro proyecto y cargar dicho driver:

Class.forName(“com.mysql.jdbc.Driver”);

Obtenemos conexión con la base de datos mediante el objeto Conection:

Connection con = DriverManager.getConnection(“jdbc:mysql://localhost/test”,”root”,””)

Crear sentencias SQL normales o preparadas para realizar consultas:

Statement s = con.createStatement(“sentencia_SQL”);

PreparedStatement ps = con.prepareStatement(“sentencia_SQL”)

Rellenar huecos de la sentencia preparada:

ps.setInt(1,unEntero); ps.setString(2,unaCadena);

Ejecutar la sentencia:

s.executeUpdate( );

ps.execute( )

Podemos ejecutar una select y almacenar el resultado en un objeto ResultSet:

ResultSet rs = s.executeQuery( );

ResultSet rs = ps.executeQuery( );

Recorrer el ResultSet y obtener los resultados:

while (rs.next() ) {

rs.getInt(“columna”);

rs.getString(“columna”); }

http://dev.mysql.com/downloads/connector/j

86

-Valor Creativo-


JSP

Un fichero JSP (Java Server Pages) es un servlet que combina HTML con código JAVA

embebido, que nos permite separar servlet de ficheros HTML. El código de un JSP está

separado de la lógica del programa y puede ser actualizado por cualquier diseñador.

Etiquetas Función

<% código_java %> Inserta código JAVA puro.

<%! métodos %> Declaraciones de métodos, cuya validez abarca solamente en el JSP.

<%= expresiones %> Realizan cualquier expresión que pueda ser resulta.

<%-- comentarios --%> Inserta comentarios al código JSP que NO se verán en la página.

Directivas Función

<%@page %> Permite fijar propiedades generales del archivo JSP.

import Importan al JSP clases JAVA accesibles en nuestro classpath.

contentType Indica el tipo de codificación y el tipo de caracteres de la página.

errorPage Redirige las excepciones no manejadas de la página a la otra indicada.

isErrorPage Indica que dicha página es la redirigida por las excepciones no manejadas.

extends Extiende una clase al JSP mediante el mecanismo de herencia.

session Indica si el JSP permite sesiones o no. Por defecto está activado.

language Indica el lenguaje de programación que usa la página.

<%@include %> Sirve para incluir otros ficheros al JSP y sólo permiten contenidos estáticos.

file Permite indicar el nombre del archivo que se incluye en el JSP.

<%@taglib %> Incluye bibliotecas de etiquetas en el JSP.

uri Indica la ubicación de la biblioteca.

prefix Indica el prefijo de las etiquetas.

87

-Valor Creativo-


JSTL

JSTL (JavaServerPages Standar Tag Library) son un conjunto de librerías estándar de

etiquetas que se pueden cargar en el contexto de un JSP para simplificar su sintaxis. Para

poder emplearlo, debemos añadir en nuestro JSP el siguiente taglib:

<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core_rt" %>

Etiquetas básicas:

${variable} Muestra el valor de dicha variable. Esta variable puede ser el nombre de

un atributo pasado vía request.

<c:foreach var=”objeto”

ítems=”${variable}”>

${objeto.atributo}

</c:forEach>

Recorre la colección indicada en items, apuntando a cada objeto recorrido

por la variable objeto. Suele ser una lista de objetos pasado vía request.

${objeto.atributo}: accede al atributo a través de su método get.

<c:if test=”${condicion}”>

</c:if>

Evalúa la condición test, y muestra el contenido en el caso de ser cierto.

JSP SERVLET

http://repo1.maven.org/maven2/jstl/jstl/1.2/jstl-1.2.jar

88

-Valor Creativo-


HIBERNATE

Hibernate es un framework que agiliza la relación entre un servlet y la

base de datos. Permite simplificar el código del servlet de forma que se

separan el código JAVA y el código SQL, de tal forma que Hibernate hace todo trabajo de la

conexión a la base de datos. Para trabajar con Hibernate, hay que descargarse todas las

librerías de la carpeta required.

El fichero hibernate.cfg.xml es el

principal fichero de configuración de

Hibernate. Indica cómo conectarse a la

base de datos, así como las clases que

queremos que sean persistentes.

A la hora de crear el fichero de

configuración, Hibernate muestra las

configuraciones del dialecto, es decir, el

idioma que se utilizará para la conexión y

las configuraciones de la base de datos.

http://hibernate.org/orm/

89

-Valor Creativo-


POJO

Una clase POJO (Plain Old Java Object) es una clase JAVA que deseamos que persista.

Para declarar una clase de este tipo hay que indicar dichos pasos:

La clase tiene que tener un constructor sin

parámetros.

La clase tiene que tener los atributos privados y sus

respectivos métodos get y set.

Tener un atributo denominado id de tipo long, que

será el identificador del objeto.

Especificar la clase con @Enity.

Los métodos get y set del atributo id deben anotarse

con @Id y @GeneratedValue.

Incluir <mapping class=”ruta.clasePojo” /> en el

fichero de configuración.

java

Technology