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

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úsculafecha
Para concatenar los identificadores compuestos de varias palabras, se pone en
mayúscula la primera letra de cada palabrafechaDeNacimiento
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 Stringscan.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.
UpcastingPadre 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()
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: BuildRun ArgumentsIntroducir 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”); }

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

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.

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

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (11)

Similar a JAVA

Similar a JAVA (20)

Más de Sergio Santos

Más de Sergio Santos (16)

Último

Último (20)

JAVA