Curso Gratuito de Java en Emuladores L2 Java

Kimeraweb Curso de Java

Curso de Java Gratuito orientado a emuladores de Lineage Java para la comunidad de administradores de Lineage2, con ejemplos, desde nivel básico a nivel programador. Incluye ODBC y MySQL. Mi compromiso con el foro de adminsprol2.com

Kimeraweb Estas clases gratuitas pretenden abarcar los aspectos mínimos que hay que conocer para poder programar en cualquier lenguaje usando como herramienta el Lenguaje Java. Como modelo usaré el emulador L2J. El curso está dirigido a todos los niveles de usuarios, desde los que no tienen conocimiento de programación a los programadores habituales.

Kimeraweb email: [email protected] msn: [email protected] f b : k i m e r a k i m e r a w e b 09/10/2012

Curso gratuito de Java en emuladores L2 Java

2012

El índice se irá modificando conforme este manual se expanda. Índice Tema 1, Introducción. 1.1 Conceptos de programación orientada a objetos 1.2 Desarrollo de un objeto 1.3 El cuerpo de un objeto 1.4 Reglas para crear nombres (nomenclatura) Tema 2, las clases 2.1 Alcance de una clase 2.2 Reglas de declaración de una clase 2.3 Creando una clase 2.4 La clase abstracta Tema 3, los métodos 3.1 Funciones de un método 3.2 Modificadores de acceso 3.3 Modificadores que no dan acceso 3.4 Argumentos de los métodos 3.4.1 Pasando variables referenciando a objetos 3.4.2 Pasando variables primitivas 3.5 Constructores Tema 4, las variables 4.1 Variables primitivas 4.2 Variables de instancia 4.3 Variables locales 4.4 Variables de tipo final tipo final , transient y y volatile 4.5 Variables estáticas 4.6 Arrays 4.6.1 Inicializando los elementos en un bucle 4.6.2 Arrays anónimos 4.6.3 Arrays primitivos 4.6.4 Array de referencias a objetos 4.6.5 Asignaciones para arrays de una sola dimensión 4.6.6 Asignaciones para arrays de varias dimensiones Tema 5, Enumeraciones 5.1 Declarando una enumeración 5.2 Declarando métodos y variables en una enumeración Tema 6, usando las características de la POO 6.1 La encapsulación 6.2 Polimorfismo e m a i l : b r u j u l a t o @ y ah o o . e s

Página 1


2012

6.3 Casteo de variables de referencia 6.4 Implementando una interfaz 6.5 Tipos de retornos en constructores sobrecargados 6.5.1 Devolviendo un valor 6.6 Autoboxing Tema 7, los constructores 7.1 Construcción, reglas y sobrecargas de constructores 7.2 Encadenamiento de constructores Tema 8, modificador estático 8.1 Métodos y variables estáticas 8.2 Métodos estáticos y variables Tema 9, recolector de basuras 9.1 Funcionamiento del recolector de basuras 9.1.2 Cómo funciona el recolector de basuras? 9.1.3 Puede una aplicación Java quedarse sin memoria? 9.2 Escribir código que maneje explícitamente objetos elegibles para ser borrados 9.3 Reasignado una variable de referencia 9.4 Aislando una referencia 9.5 Forzando el recolector de basuras 9.6 Limpiar antes de ejecutar el GC - el método finalize() método finalize() Tema 10, operadores 10.1 Operadores de asignación 10.2 Operadores de asignación compuestos 10.3 Operadores relacionales 10.4 Operaciones de igualdad 10.5 Comparación de primitivos 10.6 Igualdad para variables de referencia 10.7 Igualdad para enumeraciones 10.8 Comparación con instanceof() 10.8.1 Errores de compilación con instanceof( ) 10.9 Operadores aritméticos 10.9.1 El operador resto % 10.9.2 Operador de concatenación de cadenas 10.10 Operadores de incremento y decremento 10.11 Operador condicional 10.12 Operadores lógicos 10.13 Operadores e Bitwise 10.14 Atajo para operadores lógicos 10.15 Operadores lógicos sin atajos 10.16 Operadores lógicos ^ y ¡

e m a i l : b r u j u l a t o @ y ah o o . e s

Página 2


2012

Tema 11, Control de flujo 11.1 Estamento if 11.2 Estamento switch 11.2.1 Expresiones válidas para switch switch y y case 11.2.2 Interrupciones y flujo en los boques switch 11.2.3 El caso default 11.3 Estamento while 11.4 Estamento do while 11.5 Estamento for Estamento for , o for-in (el bucle básico) 11.5.1 El for El for mejorado mejorado (para arrays, for each) 11.6 El uso de break y y continue 11.6.1 Estamentos sin etiquetas 11.6.2 Estamento con etiquetas Tema 12, excepciones y aserciones 12.1 El estamento try – – catch 12.1.1 El uso de finally de finally 12.1.2 Programación de excepciones no capturadas 12.1.3 Definiendo excepciones 12.1.4 Jerarquía de las excepciones 12.1.5 Manejando una clase completa de la jerarquía de excepciones 12.1.6 Declaración de Excepciones e Interfaces Públicas 12.1.7 Relanzando la misma excepción 12.1.8 Definición de conceptos, excepción y error 12.1.9 Programando el arrojo de excepciones 12.2 Mecanismo de aserciones 12.2.1 Reglas de expresión de las aserciones 12.2.2 Aserciones, identificados o palabra clave 12.2.3 Ejecución con aserciones 12.2.4 Selector para activar y desactivar los assert 12.2.5 El uso apropiado para las aserciones Tema 13, la clase String, String, StringBuilder y y StringBuffer 13.1 La clase String 13.1.1 String String y y memoria 13.1.2 Métodos importantes de la clase String 13.2 StringBuffer y y StringBuilder 13.2.1 Métodos importantes de las clases StringBuffer y y StringBuilder Tema 14, paquete I/O, lectura y escritura de ficheros 14.1 Resumen de las clases I/O 14.2 Creando ficheros, el uso de la clase File 14.3 El uso de FileWriter y y FileReader 14.4 Combinando clases I/O, BufferedWriter y BufferedReader 14.5 Ficheros y directorios


Página 3


2012

Tema 15, paquete I/O, la serialización 15.1 ObjectOutputStream ObjectOutputStream y y ObjectInputStream 15.2 Objetos gráficos 15.3 El uso de writeObject y y readObject 15.4 La herencia y la serialización 15.5 Serialización y clases estáticas Tema 16, bases de datos en Java: JDBC y SQL 16.1 La tecnología Java Database Conectivity 16.2 El driver JDBC 16.2.1 Estructura y funcionamiento 16.2.2 Tipos de driver JDBC JDBC 16.3 El lenguaje SQL 16.3.1 Consultas 16.3.2 Tipos de sentencias SQL 16.3.3 Sentencias para la manipulación de Datos (DML) 16.4 El API JDBC 16.4.1 Utilización de JDBC para acceder a datos 16.4.2 Gestión con la base de datos 16.4.3 Ejecución de consultas 16.5 Manipulación de registros 16.5.1 Obtener un objeto ResultSet 16.5.2 Desplazamiento por el conjunto de registros 16.5.3 Acceso a los campos 16.5.4 Otros métodos de la interfaz ResultSet 16.5.5 Cierre de un ResultSet 16.5.6 El objeto ResultSetMetaData

Tema 17, fechas números y moneda 17.1 Trabajando con fechas, números y monedas 17.2 La clase Date 17.3 La clase Calendar 17.4 La clase DateFormat 17.5 La clase Locale 17.6 La clase NumberFormat Tema 18, parseado, tokens y formateado 18.1 Un tutorial de búsqueda 18.1.1 Búsquedas simples 18.1.2 Búsqueda usando metacaracteres 18.1.3 Búsqueda usando cuantificadores 18.1.3.1 El punto predeterminado 18.1.3.2 Cuantificadores codiciosos 18.1.4 Cuando los metacaracteres y las cadenas colisionan 18.1.5 Usando Scanner para hacer búsquedas 18.2 Tokenizando 18.2.1 Tokenizando con String.split() e m a i l : b r u j u l a t o @ y ah o o . e s

Página 4


2012

18.2.2 Tokenizando con Scanner 18.2.3 Formateando con printf() y format() Tema 19, Colecciones 19.1 Métodos de Object 19.1.1 El método toString() 19.1.2 Sobrescritura de equals() 19.2 Colecciones La interface List La interface Set La Interface Map La interface Queue 19.2.1 ArrayList 19.2.1 ArrayList La interfaz Comparable Comparator 19.2.2 Arrays 19.2.2 Arrays 19.3 Búsqueda en Arrays en Arrays y y Collections Resumen de métodos para Arrays y Collections. Convirtiendo Arrays a lista de Arrays 19.4 Listas 19.5 Set 19.5 Set 19.6 Map 19.6 Map 19.7 Priority Queue 19.8 El uso de genéricos 19.8.1 Las colecciones al estilo "Legacy" 19.9 Polimórficos y genéricos Métodos genéricos Declaraciones de genéricos Creando tus propias clases genéricas Creando métodos genéricos Tema 20, Clases anidadas 20.1 Las clases internas Escribiendo un código "regular" de una clase interna Instanciando y referenciando una clase interna Métodos locales de las clases internas 20.2 Clases internas anónimas 20.3 Clases estáticas internas Tema 21, Trabajando con hilos 21.1 Creando un hilo Heredando java.lang.Thread java.lang.Thread Implementando java.lang.Runnable java.lang.Runnable 21.2 Instanciando un hilo 21.3 Ejecutando un Thread Iniciando y ejecutando múltiples hilos El administrador de tareas Métodos de java.lang.Thread de java.lang.Thread y y java.lang.Object 21.4 El estado de los hilos y transiciones e m a i l : b r u j u l a t o @ y ah o o . e s

Página 5


2012

Sleeping El método Yield() El método join() 21.5 Sincronizando código Deadlock 21.6 Interacción sobre los hilos El método notifyAll() método notifyAll() El método wait() Tema 22, Compilando y ejecutando nuestro código 22.1 Compilando con javac con javac Compilando con -d 22.2 Lanzando aplicaciones Manejando los argumentos en la línea de comandos 22.3 Ficheros .jar 22.4 Importaciones estáticas


Página 6


2012

Sé que queremos hacer cosas ya, pero este manual no va indicado para personas con inquietudes exprés, es decir, lo leo ya y lo quiero ya. Un buen programador, espero que cuando acabes el manual lo seas, ha de ser meticuloso y usar todas las reglas aceptadas universalmente por los programadores, muy importante cuando se trabaja en equipo o se retoma el trabajo de otra persona, como es nuestro modelo L2J. En este capítulo sabremos que es un objeto, como funciona y reglas de programación. No te preocupes, empezaremos a programar tan pronto tengas la base necesaria. necesaria. Acuérdate de que un gigante con pies de barro...

1.1 Conceptos de la programación orientada a objetos En programación moderna, se usa una estructura llamada programación orientada a objetos. objetos. Esto no es más complicado que decir para programar algo haremos uso de otros códigos que ya existen. Entonces, el concepto de objeto: objeto: ahora mismo diremos que un objeto es un programa que podemos incorporar a nuestro código. En este objeto existen funciones. Una función, tal como su nombre indica es algo que está destinado a hacer, por ejemplo, las funciones de un coche? Frenar, acelerar, girar... Ahora imaginemos algo que podríamos crear en breve, un formulario. Funciones de un formulario? Recoger información, guardar información, recuperar información... Que podría necesitar el formulario para guardar la información al disco? Acceso al disco, obviamente y... tendremos que crearnos un programa para poder grabar al disco? NO!! Afortunadamente, todos los lenguajes tienen incluidos objetos básicos ( realmente no son tan básicos, se podrían escribir miles de páginas... pero de momento lo dejamos aquí ) que usaremos. Os habéis dado cuenta de una cosa? Un objeto que sólo sirve para acceder al disco... y nada más.


Página 7


2012

1.2 Desarrollo de un objeto Los objetos en cualquier lenguaje, y Java no es una excepción, es que deben ser de bajo acoplamiento y alta cohesión. cohesión. Bueno, y esto para qué sirve? Ojo, si no ejecutas esta premisa a la perfección, tu programa va a ser un churro (para que hablar con rodeos). Primero, entremos en detalles, que es bajo acoplamiento? acoplamiento? Un programa de bajo acoplamiento significa, que si el programa se modifica, no afectará al objeto que lo usa. Po r ejemplo, imaginemos que tenemos un objeto llamado “SUMADOR” que

lo único que hace es sumar dos números. Este objeto se invoca por otro objeto llamado “CALCULADORA”. SUMADOR acepta tomar dos números y devolver su suma. Por cualquier

desdicha de la naturaleza, el código de SUMADOR tiene que ser reescrito porque se ha descubierto un fallo en su programación. El bajo acoplamiento significa que aun reescribiendo el código de SUMADOR, CALCULADORA seguirá usando a SUMADOR sin tener que editar su código, resumiendo, SUMADOR es totalmente independiente de CALCULADORA. La alta cohesión significa que el programa hará exactamente exactamente y únicamente eso para para lo que fue diseñado, y nada más; de esta manera, m anera, sabemos que SUMADOR solo suma, y no hará las funciones de RESTADOR (más adelante explicaremos otras ventajas). Con lo explicado aquí, sería censurable que CALCULADORA fuese un objeto que hiciese otra tarea que no fuese calcular, y que su edición forzase a que otro o tro objeto que usase CALCULADORA tuviera que ser editado también.


Página 8


2012

1.3 El cuerpo de un objeto Un objeto común, está compuesto de funciones y variables. Explicado brevemente, el objeto tiene como misión hacer algo, y sus funciones son las tareas que puede realizar. Hay tareas que necesitan guardar alguna información para poder ser realizada, para guardar esta información se usan variables (porque su valor varia al menos, una vez). Entonces, resumiendo porque esto no tiene más:  

Los objetos contienen funciones y contienen variables. Las funciones contienen variables.

Al principio cité “objeto común” porque más adelante veremos otra clase de objetos.


Página 9


2012

1.4 Reglas para crear nombres, o nomenclatura. Como sabemos cuándo leemos un código, si lo que leemos es un objeto, una función o una variable? Es por su nomenclatura (no, no vamos a hacer química... todavía). Las reglas para crear nombres son:   



Un objeto (también se le llama clase) siempre comienza su nombre por mayúsculas. Una función siempre comienza su nombre por minúsculas. _xPos. Una variable de clase irá antecedida con el símbolo de guión bajo “_”, ejemplo _xPos. Este tipo de variables suelen ser privadas. pri vadas. Las veremos más adelante. Las demás variables serán en minúsculas.

Aparte de la nomenclatura, los nombres de las clases tienen que ser descriptivas, es decir, su nombre debe intuir lo que va a hacer, de tal manera, que cualquier lector ajeno al proyecto, pueda saber, sin leer el código, que es o hace la clase. Sus métodos deben ser creados de forma verbal, por ejemplo, las funciones de un coche se llamarán “frenar”, “acelerar” y no “freno” o “aceleracion” . Cuando se quiere obtener o asignar valores, se usan get y y set , seguidos del nombre, get significa obtener, y set, seleccionar. Así que si queremos obtener la velocidad del coche, coc he, getVelocidad . Si lo que deseamos es saber si una operación se está realizando, usaremos is, is, que significa en castellano, ser o estar. Está frenando? -> isFrenando. isFrenando. Debo decir, que en inglés, queda mejor m ejor -> isStopping. isStopping. Si estas fijándote, cuando se unen dos palabras, la segunda se pone en mayúsculas, a esto se le llama camelCase, y también es otra regla que se aplica a todo. Además de las clases y funciones, las variables si van a trabajar durante un periodo largo, también han de ser descriptivas, por ejemplo, fuerzaDeFrenado ejemplo, fuerzaDeFrenado = 100. 100. Para terminar, las constantes de clase en mayúsculas, sin usar camelCase, y su lugar, guion bajo (constante es una variable que una vez asignado su valor, ya no va a cambiarlo) ejemplo: ANCHO_DOCUMENTO.


Página 10


2012

2.1 Asignar el alcance de una clase Estos modificadores también se pueden aplicar a las funciones y variables. Cuando creas un objeto, puedes querer que ese objeto, pueda ser usado o no, dentro de su ámbito. Podemos querer que nuestra clase CALCULADORA sea invisible para la clase INSTRUMENTO MUSICAL y que sea visible para la clase MATEMATICAS por razones evidentes.

Para poder hacer esto, al declarar una clase, podemos hacerlo de diferentes maneras: Public Al declarar una clase como pública, será visible desde cualquier otra clase situada en cualquier otra parte. Sin modificador o Default

Por defecto, una clase es visible en el paquete que se crea únicamente.

Al igual que creamos directorios en Windows (u otro sistema operativo) para agrupar ficheros que son comunes entre sí, o sea, que tienen alguna relación entre ellos, los l os ficheros creados en Java también cumplen la misma lógica. En un paquete Musica podríamos Musica podríamos encontrar los paquetes Instrumento de Percusion, Percusion, Instrumento de viento, Instrumento de cuerda, cuerda, y dentro de cada uno, mas directorios. Cada directorio se denomina paquete denomina paquete..


Página 11


2012

2.2 Reglas de declaración de una clase Antes de crear tu primera clase, aún tienes que conocer unas reglas más, si, lo siento, es pesado pero necesario, pero no te preocupes, sólo con leerlas, te acordarás de ellas, porque a medida que avancemos, verás que son normas evidentes.  



 

 

Sólo puede existir una clase pública por fichero fuente. El nombre de la clase siempre será el mismo que el nombre del fichero que la contiene. Si la clase está dentro de un paquete, el estamento package será lo primero que aparezca en el fichero de la clase conteniendo su ruta. Lo siguiente que aparece después de un package, pac kage, son los comandos import import.. Las instrucciones import y package se aplican a todas las clases del fichero, en otras palabras, no hay manera de declarar diferentes package para cada clase definida en el fichero. Un fichero puede tener más de una clase no pública. Las clases no públicas del fichero pueden tener un nombre distinto al fichero que las contiene.

En un package se inserta la ruta de la clase. Los import se usan para importar otras clases.


Página 12

2012

Curso gratuito de Java en emuladores L2 Java 2.3 Creando una clase

Bien, ya hemos leído todas las normas habidas y por haber para crear una clase. En estos momentos somos unos eruditos en lo que a normas se refiere pero ya vamos a empezar la acción. Nuestra primera clase va a hacer poco, ya que, como dije antes, la programación orientada a objetos se basa en el uso de otras clases para hacer uso de ellas, y como no hemos visto ninguna, no podemos hacer nada. Está fue una gran lección, verdad? Nunca la olvidarás. Pero aun sin conocer ninguna clase, podemos crear un pseudo código que tiene como misión introduciros en el mundo de la programación orientada a objetos, POO. Mi primera ilustración va a consistir en crear un coche y sus funcionalidades. public class Coche

{

public void frenar () { public void acelerar ()

} { }

public String getAceleracion () {return null; public String getFrenada () {return null; }

}

}

Que estamos viendo aquí? Primero, al escribir la clase, se indica su visibilidad. Recuerda que si no se indica, se obtiene un alcance por defecto, es decir, sólo es visible en el paquete que se crea. Después tenemos la instrucción class y el nombre de la clase abriendo y cerrando llaves al final del código, encerrando sus métodos. En sus métodos podemos ver tres palabras que no habíamos visto antes, se trata de void void,, String y return return.. Cuando un método no devuelve nada, al nombre del método le precede la instrucción void void.. Cuando un método devuelve algo, le precede el nombre del tipo que devuelve y entre corchetes la instrucción return seguido de una variable (en este caso, nada, null null). ). El tipo se refiere a la clase de objeto que va a ser devuelto. Clases de tipos son por ejemplo, cadenas (conjunto de letras), números, nombres de clases como String String,, Integer Integer,, Object Object,, etc...


Página 13


2012

2.4 La clase abstracta El único propósito de una clase abstracta es la de crear un patrón para crear clases del mismo tipo y funcionalidad que la clase abstracta. No puede duplicarse. abstract class Coche { private double precio ; private String modelo ; private String year ; public abstract void goFast (); public abstract void goUpHill (); public abstract void impresionarVecinos ();

}

Cuando creas un coche heredando la clase abstracta Coche, Coche, lo que haces es coger un patrón y asimilarlo a tu código. Podrías pensar que, qué utilidad tiene esto? Imagina que eres el programador de Coche, Coche, y has creado un programa que usa los métodos creados en Coche. Coche. Otro programador, podría crear un Coche como Coche como el tuyo, que además volase, pero para que el código ya implementado por ti funcione correctamente en el coche volador, necesita implementar los métodos que tu esperas que estén ahí, como el precio, el modelo, el impresionarVecinos... aparte este nuevo programador, haría que su coche volase sin tener que programar el precio, el modelo, el goFast... que ya están creados por ti. Extrapola esto a un NPC de Lineage, si tienes un NPCWalker que quisieras a la vez que vendiera como un GMShop, que necesitas? Un NPCWalker vendedor, cierto? c ierto? Al implementar esto en tu nuevo coche, inmediatamente se incluirán los códigos necesarios para que tu clase cl ase esté correctamente implementada.

Si te fijas, en cuanto heredo CochePlantilla, me exige “ Add unimplemented methods”, añadir métodos no implementados. En cuanto pulses ahí, se implementarán los métodos, pero el código de su interior, es cosa tuya.


Página 14


2012

Los métodos marcados como abstractos terminan siempre en punto y coma, en lugar de llaves. Si el método estuviera en una clase normal, es decir, con código, con tan sólo un método abstracto que tenga una clase, tiene que ser marcada como abstracta también. Cuando una clase abstracta, lo es al 100%, es decir, que no posee ningún código, algo como esto:

se dice que es una interfaz. Mientras que en una clase abstracta puedes tener funciones con código y funciones abstractas mezcladas, en una interfaz no. También , los métodos de una interfaz son por defecto públicos púb licos y abstractos, abstractos, por lo tanto no tienes que declarar que son públicos y abstractos. La razón es simple, si el método fuera privado, cuando heredases la clase abstracta, las subclases no tendrían acceso a ellos.

En la interfaz, las variables que puedes crear tienen que ser públicas (por lo explicado antes), estáticas (que no cambian su valor) y finales (que no pueden duplicarse). Sin embargo, los métodos no deben ser estáticos, ya que, cuando se hereda la interfaz, los métodos abstractos hay que editarlos. Si fueran estáticos, no se podrían modificar. Una interfaz puede heredar una o más interfaces, además, no puede heredar otra cosa que no sea una interfaz. No confundir heredar con implementar, ya que la interfaz no puede implementar nada. Cuando se declara una interface, debe ser indicado con el modificador interface interface.. e m a i l : b r u j u l a t o @ y ah o o . e s

Página 15


2012

Si quieres que tu interfaz sea accesible desde cualquier parte del código, has de añadir el modificador public public,, sino el acceso por defecto (de paquete, default default)) será seleccionado.

Aunque sea redundante, puedes usar los modificadores public y abstract para declarar una interfaz.

En una interface, como dije antes, puedes declarar constantes. Al hacer esto, se garantiza el acceso a esa variable desde cualquier clase.

Los modificadores que tienes que usar son: public static final, final, es decir, que son públicas, que no varían su valor, y que no se pueden duplicar. Al no poder duplicarse, te aseguras que ninguna clase tenga acceso a la variable y altere su valor.

Si en cualquier caso olvidases esto, no olvides que, aunque no declares la variable como tal, será tomada como public static final irremediablemente:

por lo tanto, al querer modificar la variable:


Página 16


2012

obtenemos un error que nos comunica que borremos el modificador final de VELOCIDAD_MAXIMA,, y como veis en la captura anterior, no existe tal modificador, es decir, VELOCIDAD_MAXIMA se hace evidente que JDK nos ha declarado por defecto que es public public,, static y final final..


Página 17


2012

3.1 Funciones de los métodos. métodos . Sin los métodos, las clases no tendrían mucho sentido. Los métodos son los responsables de que la clase cobre vida, y sentido. Cuando invocamos una clase, actuamos sobre sus métodos. Lo principal que definimos en un método, son las funciones get y y set , encargadas de devolver y actuar sobre las variables de la clase directamente. Es una buena práctica crear las variables de las clases de forma privada, y manipularlas a través de sus métodos para evitar fallos en su uso. Por ejemplo, podríamos usar la clase Coche, Coche, y en su variable VELOCIDAD_MAXIMA VELOCIDAD_MAXIMA,, le pasásemos un valor de cadena en lugar de un valor numérico, tal como se esperaba. Sin duda, acabaría en tragedia:

Para evitar situaciones parecidas, la buena práctica nos obliga a usar un método para prevenir o evitar errores, porque, en lugar de una cadena de texto, podríamos haber pasado como valor un número decimal, pero aun así, sería un valor incorrecto. Las funciones pueden ejecutar una serie de acciones y devolver un valor, o no devolver nada. Para indicar que no devuelve nada, después del modificador, o antes del nombre de la función, indicamos con void nuestra intención, que traducido significa vacío, es decir, devuelve un valor vacío. Cuando queremos devolver el resultado de una operación, de cualquier clase, entonces el lugar de void lo ocupa el tipo de objeto que vamos a devolver, una cadena ( String String), ), un objeto (Object Object)) u cualquier otra cosa que hayamos inventado (un Coche por Coche por ejemplo). Para usar el método de una clase, se usa el nombre de la clase seguido por un punto, y luego el nombre del método. Es como el ejemplo, solo que, una función lleva paréntesis, y las variables no llevan.


Página 18


2012

3.2 Modificadores de acceso Los modificadores de acceso de los métodos son cuatro, en lugar de dos como en las clases (Default y Public Public)) y sus características son compartidas con las variables. Si no defines ningún modificador, el modificador por defecto es Default (te lo recuerdo nuevamente, con Default solo se logra visibilidad dentro del paquete donde se crea). Public Cuando un método o una variable se declara pública puede verse desde cualquier parte del programa. Private Cuando el método o la variable se declara privada, solo es accesible donde es creada. Protected Igual que privada, sólo que también será accesible por sus subclases. Default Por defecto, no estas forzado a declarar una clase Default Default.. Si se omite el modificador, Default es tomado por defecto.


Página 19


2012

3.3 Modificadores que no dan acceso. Estos modificadores se usan para limitar el uso de los métodos, se les denominan Nonaccess y Nonaccess y hay siete clases.

Final Se usa para evitar que el método sea sobrescrito en una subclase. Si se pasa final como parámetro al método, es decir, proporcionarle un valor final, el método no podrá cambiar el valor.

Abstract Un método abstracto se declara pero no se implementa. En otras palabras, es un método no funcional. Recuerda que un método abstracto no lleva llaves, termina en punto y coma. Cuando usas este modificador, lo que buscas es que la subclase implemente estos métodos, forzando a definir las acciones que debe hacer la clase, pero no la manera en que debe hacerlas. Así por ejemplo, nuestro Coche Coche puede obligar a sus subclases a implementar gastarCombustible, gastarCombustible, y dependiendo del coche, podría gastar gasolina, diesel, queroseno, agua, hidrogeno...

Ahora una pregunta de control antes de continuar, podrías crear un método abstracto y final? Piensa en ello, la respuesta más adelante.


Página 20


2012

Synchronized Indica que el método sólo puede ser accedido una vez al tiempo, es decir, que hasta que la tarea con la primera clase que invocó este método no haya acabado, pondrá en espera a los demás hilos que estén esperando ejecutar este hilo. Esto es útil para una tarea como guardar un fichero. Si se están guardando datos, sería un error permitir que otro hilo insertase nuevos datos mientras se lleva a cabo la operación de salvar datos. El resultado final es imprevisible. Las variables no pueden pueden ser declaradas Synchronized Synchronized..

Native Este modificador indica que el método se ha implementado desde otra plataforma de código diferente, normalmente en lenguaje C. También, al igual que Synchronized , es exclusivo de los métodos.

Transient Para entender este, hay que saber primero que es serializar. Cuando se serializa un objeto, se pretende guardar la información que contiene normalmente en disco. Por ejemplo, el objeto Agenda objeto Agenda podría podría contener objetos Personas. Personas. Si queremos guardar el contenido de la agenda, primero, hay que serializar el objeto. Bien, pues Transient indica que ese campo no debe ser serializado por ejemplo, porque sean derivadas de otros campos.

Strictfp Se usa para asegurar que cualquiera que sea la plataforma donde se ejecute el programa, la precisión de un número decimal sea el mismo. Si se omite, la JVM usará la precisión que mejor considere.

Static El más complejo de usar. Resumiré brevemente aunque será comentado en profundidad más adelante. Una variable estática es una variable que pertenece a la clase, no al objeto, quiero decir, una instancia de ese objeto (una instancia, un clon). Las variables estáticas se inicializan una sola vez, al comienzo de la ejecución del programa antes que cualquier otra variable. Un método estático sólo puede acceder a otros métodos estáticos. e m a i l : b r u j u l a t o @ y ah o o . e s

Página 21

2012

Curso gratuito de Java en emuladores L2 Java Un método o variable NombreClase.NombreMetodo.

estática

es

accesible

directamente,

Un método estático no puede usar this o super super.. Se puede marcar como static static::    

Métodos Variables Clases anidadas (no dentro de un método, se verá más adelante) Inicialización de bloques

No se puede marcar como static static::      

Constructores (ya que se usan para crear c rear instancias) Clases (a menos que estén anidadas) Interfaces Métodos locales dentro de las clases (lo ( lo veremos en detalle) Métodos internos de clase y variables de instancia. Variables locales.

La palabra reservada this se usa para referirse a la variable de la clase, y super a la variable de la superclase, es decir, la clase de la que se deriva la clase actual.

La respuesta a la pregunta, se puede declarar un método como abstracto y final es... falso. Ambas declaraciones son opuestas, un método abstracto tiene que ser sobrescrito, recuerda que se declara sin código, mientras que un método final evita ser modificado.


Página 22


2012

3.4 Argumento de los métodos Es común en cualquier lenguaje, que los métodos acepten parámetros, es decir, en un objeto, para que se cree una acción, a veces es necesario decirle alguna información. Por ejemplo, si el método fuera, acelerar, una pregunta obvia sería, “¿cuánto?”

Recordarte antes que nada, que un método se crea primero poniendo su modificador de acceso (que es opcional, sino se elige, la JVM toma Default Default), ), luego el tipo de retorno que podía ser cualquier cosa (si no quieres ningún tipo de retorno, se escribe void void), ), seguido del nombre del método y entre paréntesis los parámetros. Pues en Java, la manera más simple de crear un método es hacer uno que no tome ningún parámetro: public class ejemplos

{

public void digoHola ()

{ System .out.print

("HOLA" );

} }

Explico un poco lo que vemos, primero, la clase, que abre llaves y encierra a un método que no toma parámetros y se cierran las llaves de la clase. En el interior de la clase, el método se declara encerrando entre llaves las acciones. Cuando insertamos un parámetro en el método, debemos decirle a la JVM el tipo de dato que va a ser insertado. Puede ser cualquier cosa que exista. En este ejemplo, será de tipo String String,, que significa cadena de texto. public class ejemplos

{

public void digoHola (String nombre)

{ System .out.print

("HOLA " + nombre);

} }

Ahora podemos ver que al ejecutar nuestro ejemplo, nos pedirá un nombre para incluir, y que en el método usaremos ese nombre para incluir inc luir en el saludo.


Página 23


2012

Continuemos con el ejercicio y ahora tomaremos la edad como siguiente parámetro: public class ejemplos

{

public void digoHola (String nombre, String edad)

{ edad

+ }

System .out.print "años.");

("HOLA " + nombre + ", se que tienes " +

}

Ahora nuestro resultado sería algo como: Hola Maria, se que tienes 17 años. El código para obtener este resultado sería: ejemplos .digoHola ("Maria" ,"17);

Puedes seguir sumando parámetros hasta que la RAM de tu ordenador se quede sin memoria. No hay problema. Si quisiéramos hacer una operación matemática con la edad, usaríamos el tipo int int,, que significa, entero, o mejor dicho, número entero:

La clase main main,, que sería la clase que siempre se ejecuta primero por defecto y porque la JVM busca un método llamado main para ejecutar el programa. Sino existiese ningún método main main,, nos lanzaría un error.


Página 24


2012

La consola nos devuelve el resultado de la operación.

Como colofón de los parámetros hay un argumento denominado var-args, cuando declaramos como parámetro un var-args estamos diciendo que esperamos un número indeterminado de parámetros. Este tipo sólo se acepta una sola vez en un método y siempre tiene que ser declarado el último:

Salida de la consola:

Esta forma var args se forma escribiendo tres puntos puntos después del tipo y en realidad lo que que hace es convertir la variable en un array que se puede recorrer con un for for..


Página 25


2012

Conceptos nuevos: Un array es una variable capaz de almacenar más de un dato. Este for se denomina foreach porque toma un valor del array y lo introduce en una variable. Se trata de un bucle que recorre recor re todos los valores almacenados en la variable, en cada vuelta introduce el valor del array en la variable hasta llegar al último valor. Un bucle es bucle es un bloque de instrucciones que se repite un número de veces. v eces.

Todo esto se verá más en detalle.


Página 26


2012

3.4.1 Pasando variables referenciando a objetos La memoria en Java se divide en 2 partes, la memoria permanente, Heap, Heap, donde viven los objetos, y la memoria Stack , donde viven las variables. Cuando pasas un objeto como argumento a un método, debes tener en cuenta que estás pasando un objeto de referencia, y no el objeto en sí mismo. Recuerda que una variable de referencia almacena los bits que representa (para la JVM) una manera de conseguir ese objeto en la memoria Heap. Heap. Más importante, tienes que recordar que no estás pasando la variable de referencia actual, sino una copia. Una copia significa que consigues el patrón de bits de la variable de referencia, así que cuando pasas una variable de referencia, estas pasando la copia de bits del objeto que representa. representa. En otras palabras, ambos, el invocador invocador y el método invocado tendrán ahora una copia idéntica de la referencia, pero ambos se refieren exactamente al mismo objeto del Heap (no Heap (no a la copia).

3.4.2 Pasando variables primitivas Cuando una variable primitiva se pasa por un método tampoco cambia de valor, ya que se pasa una copia de la variable, al igual que ocurre con los objetos.


Página 27


2012

3.5 Constructores En un lenguaje orientado a objetos la principal característica es que los objetos se instancian para obtener nuevos objetos con distinto comportamiento. c omportamiento. Por ejemplo, si creamos un objeto Coche, Coche, las propiedades del objeto podrían ser, marca, modelo, potencia y velocidad máxima por poner un ejemplo. Si a cada modelo Coche, Coche, le asignamos una marca distinta, estamos creando nuevos modelos de coches, al fin y al cabo son coches con distintas características. No creamos un modelo Ford, otro Ferrari y otro modelo Porche, sino que creamos estos modelos a partir de un objeto que reúne todas las similitudes de un Coche. Coche. Habiendo aclarado que instanciando un objeto Coche Coche podemos crear nuevos coches con distintos comportamiento, es hora de explicar la función de un constructor. Cada vez que instancias un objeto, por decirlo de otra manera, un nuevo clon de un objeto, estás ejecutando un constructor. Si no lo haces tú, la JVM lo hace por ti. La primera cosa que llama la atención es que un constructor se parece horrores a un método, y para diferenciar un método de un constructor nos fijamos que el constructor no lleva return ni lleva void void..

Qué vemos aquí? Pues estamos viendo dos clases, la clase pública Main creando Main creando un Ferrari , y la clase por defecto Coche. Coche. Recuerda que un fichero sólo puede tener una clase pública. Para instanciar un objeto se usa el comando new new.. Para convertir la variable Ferrari en una instancia de coche, primero se usa el nombre del objeto que se va a instanciar, en el ejemplo es Coche, Coche, seguido de la variable, y luego usando new (traducido significa nuevo, nuevo Coche) Coche) seguido del objeto que queremos instanciar (o clonar, como lo veas más claro) y entre paréntesis, las opciones del constructor. Si el constructor no existiese, la JVM implementaría (aunque no aparecerá en el código): public Coche Coche (){}


Página 28


2012

Ahora veamos el código del Coche:

La variable de la clase, tal como indicamos antes, por el convenio de Java, se escribe en mayúsculas y los espacios separados mediante guión bajo, MARCA_DEL_COCHE MARCA_DEL_COCHE.. Luego tenemos el constructor, el nombre es el mismo que el de la l a clase, Coche, y su función es la de asignar la variable de la clase la marca del coche, de esta manera, cada vez que instanciemos un Coche, Coche, tendremos una marca. Luego tenemos un método coche, coche, respetando el convenio de Java para los métodos, el formato del nombre es camelCase. Pero aun respetando el convenio, es una mala práctica nombrar un método con el mismo nombre que su clase, porque sólo es útil para crear confusión, como es este caso. La función de este método es imprimir en pantalla la marca del coche pasada por parámetro. Hay una técnica de programación que se llama sobrecarga de métodos, consiste en crear métodos con el mismo nombre pero aceptando ac eptando diferentes parámetros.

Por ejemplo, aquí declaro dos constructores, el primer constructor (línea 13) construye un coche sin parámetros, en la línea 14 construye un Coche con la MARCA_DEL_COCHE MARCA_DEL_COCHE..


Página 29


2012

Ahora completemos lo que sería un Coche Coche::

Este código es algo más completo definiendo el Coche. Coche. En la clase Coche Coche ahora hay cuatro propiedades en lugar de una. También tenemos un constructor que toma dos parámetros de tipo String (cadena de texto) y dos más de tipo int (números enteros). Para completar, añadimos un método para obtener la información del Coche, Coche, respetando siempre el convenio de Java, usamos get como parte del nombre (traducido significa obtener). Ahora, al instanciar un Coche, Coche, tendremos que introducir toda la información que el constructor de la clase está esperando, sino, nos dará error y no nos dejará compilar. Así que la clase pública Main Main instancia un Coche Coche pasando cuatro parámetros en lugar de dos. Si te fijas, los parámetros que no son cadenas de texto, se pasan sin usar comillas. Sólo las cadenas de texto se rodean con comillas.


Página 30


2012

Ahora hagamos dos coches y probemos el resultado.

La consola arroja:

la especificación de los dos coches. Como ves, el usar un objeto con diferentes propiedades da como resultado nuevos objetos con diferentes comportamientos. Esto es la programación orientada a objetos.


Página 31

2012

Curso gratuito de Java en emuladores L2 Java 4 Las variables

Decíamos antes que las variables son palabras que guardan un valor, y el nombre de la variable debe ser significativo, para relacionar de forma humana lo que guarda.

4.1 Variables primitivas Hay ocho tipos de datos primitivos en Java, son: char:: es un carácter, su rango va desde el 0 al 65,535 char boolean:: es un 0 o un 1, se usa para indicar si una condición es falsa o verdadera. boolean byte:: almacena un valor entre -128 al 127. byte short:: almacena un valor entre -32,768 y 32,767. short 32,767 . int:: almacena un valor entre -2,147,483,648 y 2,147,483,647. int 2,147,48 3,647. long:: almacena un valor entre -9,223,372,036,854,775,808 y 9,223,372,036,854,775,807 long float:: almacena un valor entre 1.40129846432481707e-45 y 3.40282346638528860e+38 float double: double: almacena un 1.79769313486231570e+308d

valor

entre

4.94065645841246544e-324d

y

Aunque para nuestros efectos, usaremos normalmente float float.. Esto sólo es a título informativo, no tendrás que aprendértelo de memoria, aunque si tendrás que aprender bien boolean e int int,, que son los más usados. Si prefieres aprendértelo de otra manera, a mí me gusta más esta:


Página 32


2012

4.2 Variables de instancia Las variables de una instancia (no de una clase), se definen dentro de una clase pero fuera de cualquier método, y se inicializan cuando se inicializa la clase. Qué diferencia hay entre una variable de clase y clase y otra de instancia? instancia? La variable de clase no se instancia, es decir, no se puede clonar con new new.. Muy importante es recordar que las variables de instancia pueden usar cualquiera de los cuatro niveles de acceso (te acuerdas? public public,, private private,, default y protected protected)) y que pueden ser marcadas como final y transient transient.. No puedes declararlas como abstract abstract,, synchronized synchronized,, stricfp stricfp,, native y por supuesto, static static.. Para entender variable de clase y variable de instancia, he modificado el código:

Fíjate que en la variable de instancia, cada modelo de Coche tiene Coche tiene sus propias características, pero al poner como estática una de las variables, automáticamente se transforma en variable de clase, y al asignarle un valor al Ferrari , también se le asigna el valor al Toyota, Toyota, de manera que cuando se ejecuta:

Obtenemos:


Página 33


2012

4.3 Variables locales Las variables locales se encuentran en los métodos, viven y mueren dentro de el, y se destruyen cuando el método ha terminado su tarea. Las variables locales sólo pueden ser marcadas m arcadas como final final.. Al contrario que las variables de clase, las variables locales para poder usarlas, es necesario inicializarlas primero, es decir, asignarle un valor. Que es declarar una variable? Decir que existe sin que contenga un valor, por ejemplo:

Que es inicializar una variable? Asignarle un valor (aunque sea un valor vacío).

También puedes inicializar la variable cuando la declaras:

El resumen de los modificadores que puedes usar:


Página 34


2012

4.4 Variables de tipo final tipo final , transient y volatile El modificador final hace imposible reiniciar la variable una vez que se ha obtenido un valor explícito (que es distinto que un valor por defecto, como ocurre con las variables de clase). Acuérdate que una clase final no puede heredarse, un método final no puede sobrescribirse en una subclase y una variable v ariable final final,, no puede modificar su valor. El modificador transient sirve para decirle a la JVM que ignore la variable cuando se quiere serializar el objeto o deserializarlo. Cuando de/serializas un objeto lo que haces es recuperar/almacenar la información (del/en disco duro por ejemplo). Este recurso tan interesante será visto más adelante en profundidad. El modificador volatile le dice a la JVM que el hilo que accede a la variable debe obtener su propia copia. Esto se usa en procesos multihilos, donde cada hilo de ejecución podrá variar el valor de la variable. Profundizaremos en esto más adelante, ahora solo tienes que saber que existe para ser usados en programación multihilos.


Página 35


2012

4.5 Variables estáticas. El modificador static se usa para crear variables estáticas. Una variable estática pertenece siempre a la clase donde se crea, no a sus instancias (o clones). Como vimos en el ejemplo anterior, al crear una variable estática en la clase Coche, Coche, su valor cambiaba en todas las instancias creadas con Coche, Coche, en el ejemplo, al cambiar el valor en Ferrari , Toyota también Toyota también fue afectado.

4.6 Arrays Los arrays son variables de tipo objeto porque son capaces de guardar múltiples valores o variables al mismo tiempo. Pueden almacenar datos primitivos o referencias a objetos. Esta clase de variables viven en el Heap. Heap. Los arrays se declaran comenzando por el tipo de elemento que el array va va a almacenar, puede ser un objeto o datos primitivos seguidos de llaves cuadradas, luego le l e seguiría el nombre de la variable. Aunque podríamos poner los corchetes al final, resulta menos legible. Si colocamos más corchetes, co rchetes, estamos creando dimensiones.

Podemos hacer cosas absurdas como esta, aunque también son válidas:

Esto es lo mismo que poner dos corchetes juntos. En la declaración nunca se pone el tamaño al contrario que ocurre con otros lenguajes, que se puede iniciar el array declarando declarando la cantidad de slots disponibles en el array . Quiero decir, esto, es ilegal:


Página 36


2012

La forma más directa de construir un array es es usando new seguido del tipo del array.

En este ejemplo hemos creado 11 slots para guardar cadenas de texto en la variable nombre. Digo 11 porque se cuenta a partir del cero, si contamos el cero y el diez, tenemos once slots. Cuando se inicializa una variable, por defecto, en los slots encontraremos los valores por defecto del objeto. Para una cadena es nada, para un número es cero, y para objetos es null null.. Null no significa que nulo, no es un error, como en otros lenguajes, significa que no guarda ninguna referencia a ningún objeto. En los arrays dimensionales podríamos decir que son arrays de arrays de arrays (en arrays (en caso de arrays de dos dimensiones), es como imaginar el juego de hundir la flota. Si declaras una variable de 10 y 10, imagínate un eje X de 10 posiciones y un eje Y de 10 posiciones (10 x 10), son 100 posiciones de memoria reservadas. Los arrays de arrays de dos dimensiones pueden ser declarados de las siguientes maneras:

Es decir, puedes inicializar la cantidad de slots en cada dimensión del array .


Página 37


2012

4.6.1 Inicializando los elementos en un bucle Un bucle es un bloque de instrucciones que se repite mientras se cumple una condición. Veremos las diferentes clases que hay en profundidad. Los objetos de un array ar ray tienen solo una variable pública que devuelve el número de elementos del array. El último valor del índex es siempre uno menos que la longitud del array . Esto se debe a que la posición cero del array se se cuenta en la longitud. Así que, array[3] es es array.lenght = 4, 4, suponiendo que haya un elemento en cada slot del array. La forma más sencilla de recorrer un array es es usar el for de tipo foreach (sería la forma que correspondería a otros lenguajes, en Java no hay distinción).

Lo que vemos aquí es que se ha declarado un array llamado numeros con numeros con 11 slots. El bucle es for y encierra entre llaves la repetición de instrucciones. Dentro de for se declara a para que acepte cada elemento guardado en numeros. numeros. Inicializamos cada slot con el valor guardado en slot, que en cada repetición del bucle suma uno (slot++ (slot++). ). Así que en cada bucle, se está eligiendo un slot para asignarle un valor (numeros[slot]=slot ). ).


Página 38


2012

O sea, esto está haciendo: numeros[0] = 0 numeros[1] = 1 numeros[2] = 2 etc, hasta llegar al último slot del array, el 9. Recuerda, del 0 al 9 son 10 slots. Otra manera es usando la antigua versión de for y la variable len del array.

Lo que estamos viendo aquí es que en el for se inicializa la variable x variable x con con el valor de cero. En segundo lugar se especifica la condición que mientras sea cierta, ejecutará el bloque de instrucciones, esta es que x que x sea sea menor que la longitud de numeros. numeros. Finalmente, le sumamos a la variable x variable x un uno. Dentro del bucle se iguala la variable numeros con numeros con el índice x índice x al al valor de x de x . Es exactamente el mismo proceso que el anterior, sólo que aquí el final del array lo conocemos porque hacemos uso de la propiedad length del array . En for actualizado, esto se hace de forma automática, el bucle se detiene porque conoce el último elemento. Otra manera de declarar e inicializar un array es asignarle los valores en la misma línea:

Al hacer eso, ya le hemos dicho al compilador que nuestro array tendrá 10 elementos. Se pueden crear los elementos in situ:


Página 39


2012

4.6.2 Arrays anónimos La otra manera de crear e inicializar un array se la co noce como array anónimo. Esto sirve para crear un array justo en el momento de su uso, por ejemplo, para dárselo a un método que lo coja como parámetro. El array se crea sin variable de referencia.

4.6.3 Arrays primitivos Los arrays primitivos pueden aceptar cualquier valor que pueda ser promocionado implícitamente al tipo declarado en el array. Por ejemplo, un array de int , puede almacenar cualquier tipo de datos que pueda albergarse en 32bits. Así que el siguiente código es válido:

4.6.4 Array de referencias a objetos Si el tipo de array es una clase, puedes poner objetos de cualquier subclase del tipo declarado en el array. Por ejemplo, si Subaro es Subaro es subclase de Coche, Coche, puedes ponerlo tal como se muestra m uestra en el ejemplo:

Esto ayuda a recordar que los elementos en un Coche son Coche son solo variables de referencia a Coche. Coche. Así que cualquier cosa que pueda ser asignada a Coche, Coche, puede ser asignada a un array de de elementos de tipo Coche. Coche.


Página 40


2012

Si el array es declarado como un tipo de interfaz, los elementos del array pueden referirse a cualquier instancia de cualquier clase que implemente la interfaz. El siguiente código demuestra el uso de una interfaz en un array:

4.6.5 Asignaciones para arrays de una sola dimensión No estamos hablando sobre referencias en el array (en otras palabras, array de elementos), sino más bien una referencia al array. Por ejemplo, si declaras un array int int,, la variable de referencia que declaras puede ser reasignada a cualquier c ualquier array int int (de (de cualquier tamaño), pero no puede ser reasignado a cualquier que no sea un array int int,, incluyendo el valor int int.. Recuerda que todos los arrays son objetos, así que una referencia a un int int no no puede referirse a un número int int.. El siguiente código muestra asignaciones válidas y no válidas para arrays primitivos:


Página 41


2012

Es tentador suponer que porque una variable de tipo byte byte,, short short,, o char puede ser explícitamente casteada y asignada a un int int,, un array de cualquiera de los tipos podría ser asignado a un array int int.. No puedes hacer eso en Java. Los arrays que almacenan referencias a objetos, lo l o opuesto a datos primitivos, no tienen restricción. Así como puedes poner un Honda en Honda en Coche (porque Coche (porque Honda hereda Honda hereda Coche), Coche), puedes asignar un array de tipo Honda a Honda a una variable de referencia tal como sigue:

Aplica el test ES-UN para distinguir lo que se puede de lo que no se puede hacer. Honda ES-UN Honda ES-UN Coche, Coche, así que el array de Honda puede Honda puede ser asignado al array Car . Beer ES-UN ES-UN Coche, Coche, no es cierto, no hereda Coche, Coche, así que no es válido. Las reglas de los arrays se aplican por igual a las interfaces como a las subclases. Un array de interfaces, puede referenciar un array del tipo que haya implementado la interfaz. Recuerda que cualquier objeto de una clase que implementa una interfaz particular pasara el test de ESUN. Por ejemplo, si Box implementa implementa Foldable, Foldable, lo siguiente, es válido:

4.6.6 Asignaciones para arrays de varias dimensiones Cuando asignas un array a un array ya declarado, el array que asignas debe ser de las mismas dimensiones que las referencias que estas asignando. Por ejemplo, un array de dos dimensiones de int no se le puede asignar a un int normal, tal como sigue:


Página 42


2012

Presta una atención en especial a la asignación de los arrays usando dimensiones diferentes. Podrías por ejemplo, confundirte al asignar un array int al primero elemento de un array de int,, como sigue: int

Puedes inicializar los bloques que quieras en una clase. Lo importante a tener en cuenta, es que, al contrario que los métodos o constructores, el orden en el que los bloques aparecen en la clase, si importa. Cuando es la hora en que tienen que ejecutarse los bloques, si la clase tiene más de uno, empezaran a ejecutarse en el orden en que aparecen la clase... en otras o tras palabras, desde arriba hacia abajo. Acuérdate de estas reglas:  

 

Los constructores se ejecutan en el orden o rden en que aparecen. Los bloques estáticos solo se ejecutan una vez, cuando la primera clase se haya cargado. Las instancias de los constructores se ejecutan cada vez que la clase se instancia. Las instancia de los constructores se ejecutan después de la llamada a super() super()..

Este código:

tendrá esta salida:


Página 43


2012

Como puedes ver, las instancias de los bloques init se se han ejecutado dos veces. Instanciar los bloques init son son a menudo usadas en lugar de poner todo el código en los constructores en la clase que deberían compartir. De esa manera, el código no tiene que estar duplicado a través de los constructores. Finalmente, si haces un error en tu bloque estático, la JVM puede arrojar un ExceptionInInitalizationError . Veamos un ejemplo:

produciría un error como:

Los bloques estáticos se ejecutan antes, sin importar si están después:

Este código dará como resultado:


Página 44


2012

5.1 Declaración de una enumeración Una enumeración se usa para minimizar aún más los riesgos de equivocación en un grupo de trabajo. Esta es una buena práctica, además que facilita la lectura del código. En Java se puede restringir una variable para tener unos valores predefinidos, a esto se le llama lista enumerada o enumeraciones. Digamos por ejemplo que tenemos varios tipos de coches que podemos tener, deportivos, turismo y comerciales. Para evitar que otro programador intente obtener un coche que no existe, digamos 4x4, se restringe los valores de la enumeración a los que tengas creados. Declarar una enumeración es tan fácil como esto:

Respetando el convenio de Java, se presentan en mayúsculas. El uso es igual de sencillo, además, cuando declaras una enumeración, el editor (yo uso Eclipse) te ayuda mostrando las opciones disponibles:


Página 45


2012

De tal manera que la única forma de conseguir coches ahora es usar las opciones que nos deja disponible la enumeración:

Los componentes básicos de una enumeración son sus constantes. Pueden ser declaradas como clase propia (como en este ejemplo), miembro de una clase, pero no pueden ser declaradas dentro de un método. Así se declara como miembro de una clase:

Acuérdate que sólo puede existir una clase pública por fichero. Esto sería miembro de una clase:

Es posible que encuentres la declaración de una enumeración terminando en “;” esto es

opcional.


Página 46


2012

Bueno, y una vez que tengo una enumeración, que hago? Antes hay que explicar un poco más. Una enumeración no es un tipo String o int. Cada miembro de una enumeración es una instancia de la misma (o sea, un nuevo clon). Así que DEPORTIVO no es sólo una constante de la enumeración, es un tipo de TiposDeCoches. TiposDeCoches. Es decir, al igual que un tipo es un String o un int int,, pues acabamos de crear tres tipos nuevos de TiposDeCoches. TiposDeCoches. Una enumeración es como una clase, la diferencia es que a cada valor le corresponde una instancia de la enumeración, donde la instancia es estática y final, es decir, no se puede editar su valor, ni se puede hacer una subclase de ella (usar la palabra new new)) así que realmente se tratan como de una constante. A cada valor de la enumeración le corresponde un orden de indexado, es decir, la enumeración sabe en que orden están los tipos de coche. Más adelante profundizaremos en este tema, de momento tienes que saber que existe y cómo funciona básicamente.


Página 47


2012

5.2 Métodos y variables en una enumeración Una enumeración además de declarar tipos estáticos y finales, puede ejecutar acciones al igual que una clase, es decir, podemos usar métodos y variables, y algo raramente conocido como cuerpo de clase constante específica. Esto es útil por ejemplo, si quieres añadir una propiedad a los tipos, como por ejemplo, el número de puertas (por decir algo):

Bien, no te asustes, es sencillo y te lo voy a explicar. A cada tipo le hemos asignado un número, presumiendo que representan el número de puertas de cada tipo de coche. Pero para poder usar estos números es necesario crear un constructor, ese constructor, al igual que en las clases, tiene el mismo nombre que la clase donde se crea. En nuestro caso acepta un parámetro de tipo int que se recoge del valor guardado en el tipo, es decir, nuestro constructor acepta un número que representa la cantidad de puertas del tipo de coche. Al igual que las clases, he incluido un método para saber cuántas puertas tiene ese vehículo, getPuertas. getPuertas. No puedes olvidar que en el constructor no se puede invocar directamente. Se convoca automáticamente con los argumentos que defines en las constantes. Por ejemplo DEPORTIVO(3) invoca al constructor y le pasa el parámetro 3. Esto lo habrás adivinado, y si no es así, es que necesitas practicar esto un poco. Coge Eclipse (u otro editor) y practica un poco. Al igual que en las clases, puedes sobrecargar el constructor, es decir, crear más de uno. También puedes hacer cosas extrañas, como que parezca una clase anónima interna (este tipo de clases la veremos más adelante), se conoce como cuerpo de constante específico y se usa cuando necesitas una constante para definir un método definido en la enumeración. Lo veremos más claro con un ejemplo.


Página 48


2012

Imaginemos que necesitamos devolver el tipo de combustible del coche, por defecto son todos gasolina pero el comercial sería diesel.

Puedes fijarte que a la enumeración se incluye getCombustible, getCombustible, pero en COMERCIAL COMERCIAL se han abierto unas llaves donde se define el mismo método, es decir, lo está sobrescribiendo. Mientras que para el DEPORTIVO DEPORTIVO y el TURISMO TURISMO el combustible devuelto será gasolina, el COMERCIAL devolverá COMERCIAL devolverá diesel.


Página 49


2012

6.1 Encapsulación La encapsulación consiste en el acceso a las variables de la clase mediante un método en lugar de hacerlo directamente. Bueno, y esto para qué sirve? Imagínate que estas creando un código donde estás trabajando con un puñado de personas, que no conocen las clases que has hecho, y la misma situación es la tuya, tu no conoces su trabajo aunque estáis participando en el mismo proyecto, te va sonando L2J? Si accedieses directamente a las variables podrías pasarle tipos erróneos. Que es un tipo? Un tipo es cada clase creada para trabajar con ellas, cada objeto que se crea o existe en Java, es un tipo. Otra ventaja es el mantenimiento del código. Si en tu código hubiera que corregir el código y otro programador usase tu clase mediante los métodos de la clase, este programador no necesitará saber siquiera los cambios que hagas en tu programa, no se enterará. Por ejemplo:

Aquí tenemos el hipotético caso en que un programador ha creado la clase Arma, Arma, y otro programador que la está usando. Como vemos, puede declarar un Arma Arma con una potencia infinita. Si Coder crease un arma con potencia cien millones y resultase que esa arma descompensase el server (porque el jugador se hiciese invulnerable, por ejemplo), habría que arreglar este bug!


Página 50


2012

Como arreglar este bug sin que Coder tenga que editar su código? Bien, pues Magneto lo único que tiene que hacer es limitar la potencia del arma:

Magneto rescribe Magneto rescribe su código, si la potencia es mayor de 100, entonces la potencia es 100. De esta manera Coder no no tiene que editar su código, ni se ha enterado, él sigue haciendo lo suyo sin tener que mirar tu código. Los beneficios que recibes pensando en POO es flexibilidad y mantenimiento. La habilidad de hacer cambios en tu código sin romper el código de otros programadores es la clave de la encapsulación. Cuando creas una serie de métodos accesibles desde otras clases (y manteniendo tus implementaciones ocultas para proteger tu clase), estas creando APIs. Para conseguir mantenimiento, flexibilidad y extensibilidad debes seguir estas premisas: 





Las variables de la instancias deben estar protegidas, el modificador de acceso normalmente, privado. Crea métodos de acceso público para forzar a otros programadores a acceder directamente a los métodos en lugar de a las variables. Usa la convención de JavaBeans, setNombreMetodo, setNombreMetodo, getNombreMetodo. getNombreMetodo.


Página 51


2012

Veamos ejemplos:

Como habíamos dicho antes, las variables de instancia han de ser privadas, de tal manera que el programador no pueda acceder directamente a ella. Ahora la única manera de seleccionar la potencia del arma es mediante el método setPotencia. setPotencia.


Página 52


2012

Encapsulada la variable de clase y protegiendo el exceso de potencia mediante nuestro código, aún tenemos un posible error que controlar, os pongo el código:

El error es que Coder aún podría crear un arma con potencia -100, pero te diste cuenta demasiado tarde, ya están usando el programa. Vas a decirle a Coder que que ha ingresado un valor negativo para el arma y que la gente se está quejando porque su arma no mata m ata sino que cuenta chistes?


Página 53


2012

NO! Magneto rescribe Magneto rescribe su código gracias a que ha hecho uso de la encapsulación.

y Coder ni ni se entera.


Página 54


2012

6.2 Polimorfismo El polimorfismo es la posibilidad de que una clase hereda las características de otra clase para crear una nueva. La clave para usar de buena forma el polimorfismo es preguntarte “ ES UN ”? ”?

Ejemplo, creamos la clase Coche, Coche, y luego creamos Ferrari heredando las características de Coche. Como saber si lo estamos haciendo bien? Plantéate la pregunta, “Es un Ferrari un Coche?” La respuesta es SI . Ahora creas la clase Mercedes Mercedes heredando las características de Ferrari . Ambos son coches, Mercedes es un Ferrari ?” NO,, así parece estar bien, pero si te preguntas “Un Mercedes es ?” La respuesta es NO que estas liando los objetos. Con este truco jamás te equivocarás. Recuerda, R ecuerda, “ES UN ”. ”. Para usar esta característica característica usamos la palabra clave extends extends.. En que consiste la herencia? La herencia consiste en heredar todas las propiedades de una clase. La utilidad de esto es que añadiendo nuevas propiedades creas nuevos objetos. Ejemplo, la clase Coche lleva ruedas, puertas, frenos, motor. La clase Ferrari lleva además de lo que lleva un Coche, un caballo como símbolo, el constructor es Minielli y el diseñador es Montiveri (por decir cualquier cosa). La clase Spider que hereda a Ferrari, además de lo que lleva Ferrari, Ferrari , y de lo que lleva un Coche, mide 5 metros y alcanza los 295Km/h. Podríamos sacar una nueva clase de Ferrari heredando Ferrari, o podríamos sacar un Coche nuevo como Mercedes heredando Coche, o incluso podríamos sacar un CocheVoladorSubmarino heredando Coche y añadiendo las características de un coche que vuele y se sumerja.


Página 55


2012

En este ejemplo vemos cómo se crea Coche, Coche, CocheVolador y y CocheVoladorSubmarino CocheVoladorSubmarino,, donde CocheVolador aparte aparte de tener alas y alas y flaps flaps propias propias de un avión, avión, hereda rueda, rueda, frenos, frenos, puertas y chasis. chasis. Más complejo aun es el CocheVoladorSubmarino CocheVoladorSubmarino,, que aparte de llevar timón, timón, vela y vela y mastil propias de un barco, barco, lleva alas y flaps flaps del CocheVolador , y como el CocheVolador hereda Coche, Coche, CocheVoladorSubmarino CocheVoladorSubmarino tambien tambien hereda ruedas, ruedas, frenos, frenos, puertas y puertas y chasis. chasis. Aparte de sus variables de instancia, también heredarán sus métodos, como podría ser frenar() frenar() (para el Coche), despegar() despegar() (para el coche volador) e inmersión() inmersión() (para el coche volador submarino). Y si quisiera hacer un CocheTanque? CocheTanque? Pues... heredaría las propiedades de un Coche y Coche y le añado las características de un Tanque. Tanque. La única manera de acceder a un objeto es a través de una variable de referencia, es decir, la variable que usas con new new,, en el ejemplo podemos ver que mi referencia a un coche volador submarino es DelfinConAlas. DelfinConAlas. Tienes que saber que la variable de referencia sólo puede ser de un sólo tipo, es decir, aunque DelfinConAlas es el resultado de la herencia de un Coche Coche y de un CocheVolador , el tipo es CocheVoladorSubmarino y CocheVoladorSubmarino y nada más.


Página 56


2012

A la variable de referencia le puedes asignar otros objetos, a menos que sea declarada como final.. Es decir: final

Una variable de referencia también puede referirse a cualquier objeto del mismo tipo declarado en la referencia, incluso puede hacer referencia al subtipo declarado.

A esto se le llama casteo que casteo que lo veremos en profundidad. En el ejemplo vemos que declaro un CocheVoladorSubmarino donde la variable de referencia está referida a un CocheVolador . CocheVoladorSubmarino Como es del mismo subtipo, el compilador no lanza error y lo acepta como correcto. Una variable de referencia también puede ser declarada como un tipo de clase o un tipo de interfaz. Si se declara como un tipo de interfaz puede referenciar cualquier objeto de cualquier clase que implemente la interfaz.


Página 57


2012

En el ejemplo la variable de referencia está declarada como interfaz Frenar pero se inicializa como CocheVoladorSubmarino CocheVoladorSubmarino,, ya que CocheVoladorSubmarino CocheVoladorSubmarino implementa la interfaz Frenar. Al implementar una interfaz (lo habíamos visto antes) se deben implementan los métodos declarados, pero el código de los métodos abstractos tiene que ser escrito por ti. Fíjate que la única clase que implementa los métodos es Coche, CocheVolador y CocheVoladorSubmarino no CocheVoladorSubmarino no lo escriben. Eso es, como ya dije antes, que heredan sus métodos, y no hace falta volver a escribirlos. Es más, si se rescriben, estarías sobrescribiendo los métodos de la clase que se hereda, o sea, creando unos nuevos. Esto está bien cuando el código del método no es suficiente para la clase que lo hereda.


Página 58


2012

6.3 Casteo de variables de referencia Como hemos visto en el tema anterior, un casteo consiste en cambiar de un tipo a otro tipo, siendo el otro tipo un subtipo, subtipo, es decir, un casteo de Ferrari a Coche es posible, pero no uno de Ferrari a CocheVoladorSubmarino. “Es un Ferrari un CocheVoladorSubmarino?”

NO! Acuérdate siempre de este truco. En el casteo existen dos direcciones, subir en la escala de la herencia, que se denomina upcasting y el compilador funciona explícitamente (es decir, no tienes que indicarle que estás haciendo un casteo) y bajar en la escala de herencia, denominado downcasting, donde si tienes que indicar explícitamente el casteo. Ejemplo:

Aquí vemos que se declara c1 como Clase1 y se hace un casteo a la Clase4. Como la herencia es ascendente, no hace falta indicar expresamente el casteo. Pero al hacerlo al revés ( downcasting):

el compilador se queja, indicar el casteo se hace obligatorio.


Página 59


2012

Pero, qué pasa si una vez casteado, queremos usar el método de otro o tro tipo?

El casteo ahora está hecho correctamente, el compilador está feliz por la aclaración, pero al ejecutar el programa, sorpresa...

Por qué ocurre esto? Por qué el compilador no nos ayuda y ver que Clase1 y Clase4 son del mismo subtipo? El compilador lo único que puede hacer es confirmar que ambos tipos pertenecen al mismo árbol de la herencia. En un upcasting, el número de métodos se restringe, así que no existe la posibilidad de que un método de una clase se haya sobrescrito, al contrario que ocurre con un downcasting. El punto es que ninguna referencia de tipo Clase4 puede hacer llamadas seguras a una instancia de Clase1. Ojo, con esto no digo que el downcasting esté prohibido. Si el compilador ve que hay posibilidad de que en tiempo de ejecución funcione, compilará.


Página 60


2012

En este ejemplo vemos como el downcasting si está permitido. Explico el ejemplo. La clase Object es es la clase de la que derivan todas las clases en Java, es la primera clase. La clase String es String es una clase derivada de Object que que contiene cadenas de texto. Como la referencia o es una cadena de texto, cuando hacemos downcasting de Object a a String, String, el compilador ve que la referencia es una cadena de texto, el mismo tipo que hace referencia o, y no da error. Esto compila sin problemas.

Aunque es raro usar esto de esta manera, nunca está de más saber que existe y como funciona.


Página 61


2012

6.4 Implementando una interfaz Al crear interfaces te aseguras que otro programador seguirá las reglas que tu creaste para el comportamiento de una clase. Por ejemplo, si creas una interfaz como “Volador” te aseguras que alguien que cree un objeto

que vuele tenga los métodos que necesitas para poder hacer que ese objeto vuele.

En el ejemplo vemos la implantación forzosa de los métodos que nos supone usar la interfaz Volador. Los comentarios los añade automáticamente Eclipse al aceptar implementar los métodos de la interfaz. @Override significa sobrescribir, y eso es lo que tenemos que hacer, crear código para que esta clase pueda volar. Esos métodos serán invocados desde otras clases que ya presumen que todos los objetos que vuelan podrán realizar las acciones que indica la interfaz.


Página 62


2012

Aunque el compilador no se va a quejar de que no pongas nada en los métodos que implementas, no quiere decir que estés haciendo una buena implementación, por eso hay que seguir esta serie de reglas:   



Proveer de implementaciones no abstractas de todos los métodos de la interfaz. Usar las reglas de la sobrescritura, es decir, debe devolver el mismo tipo. Declarar las excepciones no declaradas en los métodos implantados que son declarados en el método de la interfaz o subclase. Veremos cómo se hace esto más adelante. Mantener el nombre del método de la interfaz y el mismo tipo o subtipo.

Una implementación también puede ser abstracta por si misma, es decir, una interfaz puede heredar otra interfaz, o más de una, y no tiene que declarar los métodos.


Página 63


2012

Mientras que una clase sólo puede heredar una clase, una interfaz puede heredar múltiples clases. Pero una interfaz no puede implementar nada aunque una clase puede implementar múltiples clases.

Las interfaces son siempre públicas, aunque no lo declares explícitamente. Los métodos implementados de la interfaz, han de ser públicos, no puedes usar los modificadores private private,, final final,, protected protected,, o default default.. Recuerda, que extends se usa para heredar otra clase, e implements se usa para clases abstractas o interfaces. Las clases abstractas tienen métodos no implementados (sin cuerpo) y deben ser sobrescritos.


Página 64


2012

6.5 Tipos de retornos en constructores sobrecargados Sobrecargar un método es crear otro método con el mismo nombre pero aceptando diferentes parámetros.

También se puede sobrecargar un método cuando una clase hereda a otra (heredando sus métodos) y rescribes el método.

Cuando se crean métodos que devuelven tipos distintos, según los parámetros dados en el método, el tipo de retorno es distinto.

Lo que no puedes hacer es rescribir el método en lugar de sobrecargarlo, así sin más:


Página 65


2012

Si quieres rescribir el método en tu subclase, es decir, sobrescritura, puedes cambiar el tipo de retorno si el tipo es un subtipo de la superclase.

En este ejemplo int y y byte son byte son distintos tipos, pero pueden ser casteados, es decir, si el valor de int no no supera el valor de 255 que es el rango máximo de byte, byte, puede funcionar sin errores en tiempo de ejecución. Otro ejemplo:

Aquí Main hereda Main hereda Uno, Uno, así que Main automáticamente Main automáticamente es subtipo de Uno, Uno, por eso el retorno del tipo es correcto.

6.5.1 Devolviendo un valor Hay cinco sencillas reglas para devolver un valor. 1. Puedes devolver null en un método con un objeto de referencia de tipo return.


Página 66


2012

2. Puedes devolver un array. Aunque no hemos visto como se construye un array, en el ejemplo se puede observar que se incluye unos corchetes [] al lado del tipo de devolución, para indicar que se trata de un array, y dentro del método, al inicializar la variable con los valores.

3. En un método con tipo t ipo de retorno primitivo, puedes devolver cualquier valor o variable que pueda ser convertida implícitamente al tipo declarado. Esto es lo que vimos antes del casting.

4. Si el método usa void (vacío) se presume que no devuelve nada, o sea, un valor vacío. Hacer que devuelva un valor es ilegal:

5. Un método que use un objeto de referencia, puede devolver cualquier tipo que pueda ser casteado implícitamente al tipo de retorno.


Página 67


2012

6.6 Autoboxing Esta característica consiste en convertir tipos automáticamente, y es una característica añadida en Java 5. Antes de existir esto, era más complicado hacer una conversión evidente:

y ahora:

Donde se puede hacer autoboxing? La regla general es que el boxing y unboxing funcionan cuando normalmente usas un dato primitivo o un envoltorio (o sea, el nombre del objeto como Integer Integer). ).


Página 68


2012

7.1 Construcción, reglas y sobrecargas de constructores

Cuando instancias un objeto con new se invoca el constructor de la clase siempre, pero además de esto, se ejecuta el constructor de la superclase, es decir, se ejecutan todos los constructores de su superclase, y la última clase, de donde nacen todas las clases es Object . Un constructor por defecto es como esto:

Lleva el mismo nombre de la clase y entre llaves no hay nada. Este constructor no es necesario crearlo, el compilador lo hace por ti. Los constructores normalmente se usan para inicializar las variables de la instancia, es decir, los valores de las variables de la clase instanciada:

La palabra clave this se usa para hacer hincapié en que nos referirnos a la variable de instancia, no a las variables del método que tienen el mismo nombre. Además, Eclipse pinta Eclipse pinta de azul las variables de la instancia siempre que entienda que te refieres a ellas.


Página 69


2012

Cuando creas un constructor, el constructor por defecto se omite, así que si quieres crear un Circulo sin Circulo sin pasar los parámetros que has establecido, dará error:

Las opciones que muestra Eclipse para arreglar el error es: Añadir los argumentos que encajen con Circulo(int, int, int) Cambiar el constructor Circulo(int, int, int): Quitar los parámetros int, int, int Crear el constructor Circulo() Como ves, si uno de los consejos es crear el constructor que debería estar por defecto, es que ya no está ahí. Aunque sea deseable siempre tener un constructor sin argumentos para una clase, muchas veces, como en el ejemplo, no tiene sentido u ocasionaría un error. Puedes crear tantos constructores como quieras dentro de una clase. Las reglas para crear un constructor:    



 

  



Los constructores pueden usar cualquier modificador de acceso. El nombre del constructor tiene que ser el mismo que el de la clase. Los constructores no devuelven nada (no tienen ti enen return). Es legal aunque estúpido tener un método con el mismo nombre que la clase. Esto no significa que sea un constructor. Si no se crea un constructor, el compilador crea uno por defecto, aunque no se vea en el código. El constructor por defecto nunca lleva argumentos. Si has escrito un constructor y quieres otro sin argumentos, tendrás que hacerlo tú mismo. Cada constructor invoca implícitamente a this o super super.. Si no incluyes this o super super,, el compilador lo hará por ti, con o sin argumentos. No se puede invocar a ninguna parte de una instancia hasta que su c onstructor se haya ejecutado. Solo las variables estáticas y métodos pueden ser accedidas con super o this this..


Página 70

Curso gratuito de Java en emuladores L2 Java 



2012

Las clases abstractas también tienen constructores, son ejecutados cuando la subclase que los instancia son ejecutadas. Las interfaces no tienen constructores, como no son parte de ningún objeto, no forman parte de ningún árbol de herencia.


Página 71


2012

7.2 Encadenamiento de constructores Los constructores solo se ejecutan cuando usamos new en alguna clase, pero no sólo se ejecuta este único constructor. Al iniciar un constructor, también se inicia el de su superclase, hay un comando que se usa implícitamente, se ejecuta super() super(),, y sirve para invocar a la superclase, y así sucesivamente hasta llegar a la superclase de todas las clases, Object . Para ver el efecto dominó, miremos este ejemplo:

La clase Main Main crea una instancia de la Clase4, Clase4, pero fíjate que antes de ejecutarse el constructor de la clase 4, se ejecuta primero el de la superclase más alta hasta llegar a la clase 4. Cuando se ejecuta un método sin usar super, en este ejemplo, info, info, se ejecuta el de la clase que sobrescribe al de la superclase:


Página 72


2012

Pero si quitamos el método de la clase 4, se ejecuta el de la clase 1, lo mismo que si hubiéramos usado super() super(),, solo que el compilador ya lo hace por nosotros:

Aquí inserto super() en la clase 4:

En este ejemplo, se usa super para invocar al constructor de la superclase, pero si te fijas, al pasarle solo un argumento, se ejecuta el constructor de la clase2 sin arrojar error:

Al pasar 2 argumentos da error, porque no hay constructores con dos argumentos:


Página 73


2012

Finalmente, si instanciamos la clase 1, la clase 2 podrá leer las variables de la superclase:


Página 74


2012

8.1 Métodos y variables estáticas Hay que hacer una distinción entre las variables y variables marcadas como estáticas. Las variables no estáticas se resetean en cada nueva clase instanciada, mientras que la variable estática pertenece a la clase, en lugar de a la instancia. Estudiemos este ejemplo:

Mientras que numero ha sido declarado sin el modificador static, es inicializado en cada instancia de la clase, mientras que conteo suma uno cada vez que se ejecuta el constructor, es decir, cada vez que se usa new. En ambas clases instanciadas, conteo tiene el mismo valor, ya que es estático, no es una variable de la instancia, sino que es una variable estática, que pertenece a la clase, no a sus copias. Esto también es aplicable a los métodos estáticos.


Página 75


2012

8.2 Accediendo a métodos y variables estáticas En el momento en que no necesitas una instancia para acceder a los métodos o variables estáticas usaremos el operador punto(. punto( .). Reglas que debes conocer:

Además los métodos estáticos no pueden ser rescritos.


Página 76


2012

9.1 Funcionamiento del recolector de basuras Vamos a ver lo que queremos decir cuando hablamos del recogedor de basuras en la tierra de Java. A diez mil metros de altura, el recolector de basuras es la frase que se usa para describir el manejo de memoria en Java. Cuando un programa se ejecuta (en Java, C, C++, Lisp, Ruby...) usa la memoria de diferentes maneras. No vamos a meternos en la ciencia 101 de la computación, pero lo típico de la memoria es que se use para crear una pila en el Heap, que es la piscina donde Java pone sus métodos y sus constantes. El Heap es la parte de la memoria donde los objetos de Java viven, y es una y única parte de memoria que esta de cualquier modo envuelta en el proceso del recolector de basuras. Así, que la directiva del recolector de basuras es liberar al Heap, para dejar libre el mayor espacio de memoria disponible. Lo que hace es borrar los objetos que no son alcanzables por el programa Java que está corriendo. Hablaremos más cuando lleguemos al siguiente punto. Cuando el recolector de memoria se ejecuta, su propósito es encontrar y borrar objetos que no pueden ser alcanzados. Imagina un programa Java que es el comienzo de un bucle de creación de objetos (que están en el Heap), y que elimina los objetos cuando no se necesiten más, crear nuevos objetos, descartarlos, etc... la pieza que falta es el recolector de basuras. Cuando se ejecuta, buscara esos objetos descartados y los borrara de la memoria descargándola para que pueda continuar. Ah, el gran circulo de la vida.

9.1.1 Cuando se ejecuta el recolector de basuras? El recolector de basuras funciona bajo el control de la JVM. La JVM decide cuando se ejecuta el recolector de basuras. Dentro de tu programa Java puedes pedir a la JVM que ejecute el recolector de basuras, pero no hay garantías, bajo ninguna circunstancia, de lo que la JVM va a hacer. La JVM ejecutará el recolector cuando la memoria alcance mínimos. La experiencia me indica que cuando le pides a la JVM que ejecute el recolector, la JVM garantiza que será ejecutado en corto plazo y justo cuando crees que puedes contar con ello, JVM omite tu petición

9.1.2 Cómo funciona el recolector de basuras? No puedes estar seguro. Habrás podido escuchar que el recolector de basuras funciona con un algoritmo de barrido, y para cualquier implementación de Java puede ser cierto, pero la especificación de Java no garantiza ninguna implementación en particular. Podrías haber oído que el recolector de basuras usa un conteo de referencia, una vez quizás si, quizás no. El concepto más importante de es: Cuando el objeto es elegido para ser anulado por el recolector de basuras? Para contestar a esta pregunta, tenemos que dar un salto hacia delante y hablar de hilos. En un programa de Java, cada programa tiene desde uno a varios hilos. Cada hilo tiene su propia pequeña pila de ejecución. Normalmente, tu (el programador) crea al menos un hilo para


Página 77


2012

ejecutar el programa, el primero con el método main() main() en el fondo de la pila. Sin embargo, como aprenderás en detalle más adelante, hay muchas razones para lanzar hilos de ejecución adicionales desde tu hilo principal. Aparte de tener su propia pila de ejecución, cada hilo tiene su ciclo de vida. Por ahora, todo lo que necesitamos saber es que los hilos pueden estar vivos o muertos. Con esta información, podemos decir con contundente claridad que un objeto es elegido para el recolector de basuras cuando no hay hilos vivos accediendo a el. Basándonos en esta definición, el recolector de basuras hace algo de magia, operaciones desconocidas, y cuando descubre un objeto que no puede ser alcanzado por un hilo vivo, considera que el objeto es elegible para ser eliminado, puede llegar incluso a borrarlo en el mismo momento. (Si, lo adivinaste, puede ocurrir que tampoco lo llegue a borrar nunca). Cuando hablamos sobre el alcance de un objeto, o bjeto, estamos hablando realmente sobre tener una variable de referencia alcanzable que se refiera al objeto en cuestión. Si nuestro programa Java tiene una variable de referencia que hace referencia al objeto, y esa variable de referencia está disponible en un hilo vivo, entonces ese objeto se le considera alcanzable. Hablaremos más sobre como los objetos puede convertirse en inalcanzables en la siguiente sección. 9.1.3 Puede una aplicación Java quedarse sin memoria? Sí. El recolector de basuras intenta borrar todos los objetos de la memoria cuando no se usan. Sin embargo, si mantienes muchos objetos vivos a la vez (objetos referenciados por otros objetos) el sistema puede llegar a quedarse sin memoria. El recolector de basuras no puede asegurar que haya suficiente memoria, solo que la memoria disponible será manejada de la forma más eficiente posible.

9.2 Escribir código que maneje explícitamente objetos elegibles para ser borrados En esta sección vamos a mostrar cómo hacer objetos elegibles para el recolector de basuras usando el código actual. También vamos a discutir cómo forzar al recolector de basuras si es necesario, y como podemos ejecutar una limpieza adicional en objetos antes de que sean borrados de la memoria. Una referencia nula Como hemos visto antes, un objeto se convierte en apto para ser borrado cuando no hay referencias que lo apunten. Obviamente, sino hay referencias, no importa lo que le ocurra al objeto. Para nuestro propósito es solo algo flotando en el espacio, sin usar, inaccesible y que ha dejado de necesitarse. La primera manera de borrar una referencia a un objeto es seleccionar la variable de referencia que apunta al objeto y volverlo null null.. Examina el siguiente código:


Página 78


2012

El StringBuffer con el valor "hello" se le asigna la variable sb en sb en la tercera linea. Para hacer este objeto apto para el GC (Garbage Collector, recolector de basuras), le asignamos a sb el sb el valor de null,, lo que elimina la única referencia que existía al objeto StringBuffer null StringBuffer.. Una vez que la línea 6 se ejecuta, nuestro pequeño "hello" está condenado para el GC.

9.3 Reasignado una variable de referencia También podemos desemparejar una variable de referencia de un objeto asignándole a la referencia, otro objeto. Examina este código:

Los objetos creados en un método también necesitan ser considerados. Cuando un método se invoca, ninguna variable local existe más allá de la duración del método. Una vez el método ha terminado, el objeto creado en el método es apto para el GC.


Página 79


2012

Hay una excepción obvia. Si se devuelve un objeto del método, su referencia puede ser asignada a una variable de referencia en el método que lo llamó, así que, no será apto para la colección. Examina este código:

En el código hemos creado un método llamado getDate() que getDate() que devuelve un objeto Date. Date. Este método crea dos objetos: un Date Date y un StringBuffer que contiene la información. En el momento que el método devuelve el objeto Date, Date, no será apto para la GC aunque el método se haya completado. El StringBuffer será apto, aunque no lo hayamos hecho explícitamente, la variable ahora tiene asignado un null null..

9.4 Aislando una referencia Hay otra manera en la que los objetos se conviertan en aptos para la GC, aunque tengan unas referencias válidas. Nosotros llamamos a este escenario "isla de la soledad". Un ejemplo simple es que una clase que tiene una variable de instancia que es variable de referencia a otra instancia de la misma clase. Ahora imagínate que las dos instancias de la misma clase existen y que la una y la otra están apuntándose. Si las otras referencias a estos objetos son eliminadas, entonces incluso aunque estas referencias sean válidas, no hay hilo que acceda a estas variables de referencia. Cuando el GC se ejecuta, puede normalmente, encontrar estas islas y eliminarlas. Como te puedes imaginar, estas islas pueden llegar a ser bastante grandes, teóricamente contiene cientos de objetos.


Página 80


2012

Examina el siguiente código:

Cuando el código alcanza // //,, las tres islas previamente conocidas como i2, i2, i3 e i4, i4, tienen variables de instancias que apuntan las unas a las otras, pero sus enlaces hacia el mundo, ha sido anuladas. Estos tres objetos son aptos para la GC. Esto cubre todo lo que necesitaras saber sobre crear objetos aptos para la GC.

9.5 Forzando el recolector de basuras La primera cosa que debería de mencionarse aquí es eso, contrariamente al título de esta sección, el GC no puede ser forzado. Sin embargo, Java provee de métodos que te permiten solicitar que la JVM efectué la ejecución del GC. Por ejemplo, si estas a punto de ejecutar algunas operaciones sensibles, probablemente querrás minimizar el riesgo de lag causado por el recolector de basuras. Pero tienes que recordar que los métodos que Java provee son peticiones, no demandas, la JVM hará lo mejor respecto a lo que solicitas, pero no hay garantías de que efectuará la petición. En realidad, solo es posible sugerir a la JVM que ejecute el GC. Sin embargo tampoco hay garantías de que elimine todos los objetos sin usar de la memoria (aunque ( aunque el GC se ejecute). Es esencial que entiendas ese concepto para el examen. La rutina del GC que Java suministra son miembros de la clase Runtime. Runtime. Esta es una clase especial que solo tiene un objeto (un Singleton) para cada c ada programa. El objeto Runtime provee Runtime provee de mecanismos para comunicar directamente con la máquina virtual. Para conseguir una instancia de Runtime, Runtime, puedes usar el método Runtime.getRuntime(), Runtime.getRuntime(), que te devuelve el Singleton. Una vez que lo tengas, puedes invocar al recolector de basuras usando el método gc(). gc(). Alternativamente, puedes invocar al mismo método en la clase System, System, que es un método estático que puede funcionar obteniendo el Singleton para ti. La manera más simple para pedirle al GC que se ejecute es:


Página 81


2012

Teóricamente, después de llamarlo, tendrás mucha memoria libre. Decimos teóricamente porque esta rutina no funciona siempre de esa manera. Primero, tu JVM no puede tener implementada esta rutina; la especificación del lenguaje no permite hacer nada. Segundo, otro hilo puede ganar un montón de memoria en el momento que se ejecute el GC. Esto no es decir que System.gc() es System.gc() es un método inútil, es mucho mejor que nada. Simplemente no puedes confiar en System.gc() System.gc() para liberar suficiente memoria, así que no tienes que preocuparte sobre quedarte sin memoria. Ahora que de alguna manera nos hemos familiarizado con cómo funciona, hagamos un pequeño experimento para ver si podemos ver los efectos del GC. El siguiente programa nos permitirá saber cuánta memoria tiene disponible la JVM y cuanta ha libreado. Esto va a crear 10.000 objetos Date. Date. Después, le dirá cuanta memoria queda, llamará al GC (el cual decidirá si se va a ejecutar, el programa se detendrá hasta que todos los objetos sean eliminados). La memoria final debería indicarse cuando se haya ejecutado. Veamos el programa:

Ahora veamos el resultado:

Como puede verse, la JVM ha decidido recolectar la basura de los objetos aptos para ser eliminados. En el ejemplo, le sugerimos a la JVM que ejecutase el GC con 458Kb de memoria restante, y nos honró con su aparición. Este programa solo tiene un hilo corriendo, así que no había nada más funcionando cuando fue ejecutado. Ten en mente que el comportamiento de gc() cuando gc() cuando es ejecutado puede ser diferente, así que no hay garantía que los objetos sin uso


Página 82


2012

sean eliminados de la memoria. La única cosa que se garantiza es que el GC funcionara antes de arrojar una excepción OutOfMemoryException OutOfMemoryException..

9.6 Limpiar antes de ejecutar el GC - el método finalize() Java provee de un mecanismo para ejecutar un código justo después de que tu objeto sea borrado por el GC. Este código está en un método llamado finalize() finalize() que todas las clases heredan de Object . Sobre el tapete suena como una gran idea, quizás tu objeto consuma algo más de recursos, y te gustaría cerrarlo antes de que sea borrado. El problema es ese, que no puedes contar con el GC siempre para borrar un objeto. Así, que cualquier código que pongas dentro de tu clase, el método finalize() tampoco finalize() tampoco te garantiza que se vaya a ejecutar, así que tampoco es recomendable que pongas código esencial dentro de este método. El caso, es que recomendamos que no sobrescribas el método finalize() método finalize().. Un pequeño truco para finalize() Hay un par de conceptos concernientes a este método que necesitaras recordar: Para cualquier objeto dado, el método será llamado una vez por el GC. Llamar a este método puede acabar en que el objeto sea salvado del borrado. Miraremos estos estamentos más adelante. Lo primero de todo, recordar que el código que pongas dentro de un método normal, puedes ponerlo en finalize() en finalize().. Por ejemplo, en el método finalize() podrías finalize() podrías escribir el código que pasa una referencia a un objeto en cuestión hacia otro objeto, efectivamente, el objeto acaba en el GC. Si en el mismo punto, más tarde en este mismo objeto se convierte en apto para el GC, el GC puede pausar este proceso y borrarlo. El GC sin embargo recordará, que en este objeto, finalize() ya finalize() ya se estaba ejecutando, y no va a ser ejecutado otra vez.


Página 83


2012

10. Operadores Si tienes variables, tendrás que modificarlas. Necesitarás incrementarlas, sumarlas, compararlas (hay como una docena de formas). En este capítulo, aprenderás como se hace todo eso en Java. Los operadores de Java producen nuevos valores desde uno o más operandos (solo queremos dejarlo todo claro, recuerdo que los operadores son las cosas a la izquierda y derecha del operador). El resultado de la mayoría de las operaciones son un valor booleano o numérico. Ya que sabes que Java no es C++, no vas a sorprenderte de que los operadores de Java no son sobrecargados. Sin embargo existen unas pocas excepciones donde los operadores pueden venir sobrecargados. 



El operador + puede ser usado para añadir dos números o para hacer una concatenación si el operando es una cadena. Los operadores &, |, y ^ pueden ser usados de dos formas distintas, aunque en esta versión del examen, sus capacidades de bit no serán testadas.

10.1 Operadores de asignación Cuando asignamos un valor a un primitivo, el tamaño importa. Pero asegúrate de saber cuándo hay un casteo implícito, cuando es el casteo explícito necesario y cuando puede ocurrir la truncación (por ejemplo, acuérdate de que un int puede entrar en un byte siempre que no supere el rango). Recuerda que una variable de referencia no es un objeto, es una manera de conseguir un objeto. (Sabemos que todos los programadores de C++ se mueren por decirnos que eso es un puntero, pero nosotros no.) Cuando asignamos un valor a una variable de referencia, el tipo importa. Recuerda las reglas para los supertipos, subtipos y arrays. Ahora cubriremos unos pocos de detalles de los operadores de y más adelante, miraremos cómo funciona el asignador = con las cadenas (las cuales, son inmutables).

10.2 Operadores de asignación compuestos Actualmente hay 11 asignadores, pero solo cuatro son los más usados ( += , -= ,*= ,*= y y /= /=) en el examen (depende del objetivo). Los operadores de asignación compuestos son la manera más fácil de ahorrar unos pocos golpes de teclado. Aquí hay varios ejemplos de asignaciones, primero, sin usar el operador de compuesto,


Página 84


2012

Ahora con los operadores compuestos:

Por supuesto, los resultados serán los mismos.

10.3 Operadores relacionales Hay seis operadores relacionales (< ( <, <= <=,, >, >= >=,, == == y y != !=). ). Los operadores relacionales siempre dan como resultado un booleano (true o false). Este valor booleano es usado a menudo como sigue:

pero el valor resultante puede ser también asignado directamente de booleano a primitivo:

Java tiene cuatro operadores relacionales que pueden ser usados para usarse en la comparación de cualquier combinación de enteros, decimales o caracteres:    

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

Observemos algunas comparaciones validas:


Página 85


2012

En el código anterior, usamos una comparación entre caracteres. También es legal comparar un carácter primitivo con un número (aunque no sea un gran estilo de programación). Al ejecutar el código, tendremos la siguiente salida: The animal is a gray elephant

Hemos mencionado que los caracteres pueden ser usados en operadores de comparación. Cuando comparamos un carácter con otro carácter, o un carácter con un número, Java usara el valor Unicode del valor del carácter como valor numérico para la comparación.

10.4 Operaciones de igualdad Java tiene dos operadores de igualdad (también llamados operadores relacionales) que comparan dos cosas similares y devuelve un valor booleano que representa true o false de las cosas que se están comparando. Estos operadores o peradores son:  

== igual (mejor conocido como igual que) == igual que) != no != no igual (mejor conocido como no igual que) que)

Cada comparador individual puede involucrar dos números (incluyendo los caracteres), dos valores booleanos, o dos variables de referencia a objetos. En todo caso, no puedes comparar tipos incompatibles. Cual sería una respuesta si preguntamos si un booleano es igual que un carácter? o si un botón es lo mismo que una cadena de texto? (Exactamente, tonterías, porque no tienen sentido). Hay cuatro tipos diferentes de cosas que pueden ser comparadas:    

números caracteres booleanos primitivos variables de referencia a objetos

Así que, que compara == (son dos signos de =)? El valor en la variable, en otras palabras, el patrón de bits.

10.5 Comparación de primitivos

La mayoría de programadores están familiarizados con la comparación de valores primitivos. El siguiente código muestra algunos test de igualdad sobre variables:


Página 86


2012

El programa mostrara:

character 'a' == 'a'? true character 'a' == 'b'? false 5 != 6? true 5.0 == 5L? true true == false? false Como puedes ver, normalmente si un numero decimal es comparado con un entero y el valor es el mismo, el operador == == (dos (dos signos de igualdad =) devuelve true true,, tal como se esperaba.

10.6 Igualdad para variables de referencia

Tal como vimos antes, las dos variables de referencia pueden referirse al mismo objeto, tal como demuestra este código:

Después de ejecutar este código, ambas variables están apuntando al mismo objeto. Las variables de referencia pueden ser comprobadas para ver si son el mismo objeto usando el operador igual que(==). que(==). Recuerda que este operador examina los bits contenidos en la variable, así que para las variables de referencia significa que si ambas referencias contenidas son iguales, entonces se refieren al mismo objeto. o bjeto. Examina el siguiente código:

Este objeto crea tres variables de referencia. Las primeras dos son dos objetos JButton distintos, mientras que a la tercera t ercera se le asigna la primera referencia. Cuando este programa se ejecuta, se muestra el siguiente resultado: Is reference a == b? false Is reference a == c? true

Esto nos muestra que la primera y tercera referencia son la misma instancia de JButton. JButton. El operador "igual que" no hará la comparación si los objetos son significativamente


Página 87


2012

equivalentes, un concepto que cubriremos con las colecciones, cuando veamos el método equals() método equals() (lo (lo opuesto a lo que estamos viendo aquí).

10.7 Igualdad para enumeraciones Una vez que has declarado una enumeración, no se puede expandir. En tiempo de ejecución no hay manera de añadir nuevas constantes. Naturalmente, puedes tener tantas variables como quieras, así que es importante el poder comparar dos variables de referencia de enumeración para ver si son iguales, por ejemplo, para ver si se refieren a la misma constante de enumeración. También puedes usar el operador == == o o el método equals() equals() para para determinar si las dos variables se están refiriendo a la misma constante de enumeración:

Sabemos que }} es bastante feo de ver, pero te estoy preparando. Esto da como salida: == dot equals

10.8 Comparación con instanceof() Este método se usa solo para las variables de referencia, y puedes usarlo para saber si un objeto es de un tipo particular. Por tipo, queremos decir la clase o la interface, en otras palabras, si el objeto referido por la variable de la izquierda pasa el test de ES-UN para el tipo de clase o interface de la derecha

esto imprime: s is a String

Incluso si el objeto que está siendo testeado no es una instancia del tipo de la clase del lado de la derecha del operador, instanceof devolverá devolverá true si el objeto es compatible con el operando de la derecha.


Página 88


2012

El siguiente ejemplo demuestra el uso normal de instanceof , verificar si un objeto es instancia de uno de sus subtipos antes de intentar hacer un downcasting:

El código anterior compila y muestra: 'a' refers to a B

En el ejemplo, usamos instanceof para para proteger al programa de un downcasting ilegal. Puedes testear un objeto de referencia con su propia clase, o cualquiera de sus subclases. Esto significa que cualquier objeto de referencia será evaluado a true si usas instanceof con el tipo Object Object,, tal como sigue:

lo cual imprime: b is definitely definit ely an Object

Hay que añadir, que un valor null es también valido en una referencia. Esto siempre dará false false::

Esto imprime: false imprime: false false


Página 89


2012

10.8.1 Errores de compilación con instanceof No puedes usar instanceof en dos tipos de jerarquías distintas. Por ejemplo, esto no compilara:

La compilación falla, no hay manera de que d pueda referirse a Cat Cat o o a algún subtipo de Cat Cat.. El siguiente resumen muestra el uso de instanceof en el siguiente código:

10.9 Operadores aritméticos

Estoy seguro de que estas familiarizado con los operadores aritméticos.    

+ sumar - restar * multiplicación / división

Se pueden usar de manera estándar:


Página 90


2012

10.9.1 El operador resto % Este operador puede que no te sea familiar. Lo que hace es obtener el resultado de dividir los operandos, tal como demuestra este código:

Al ejecutar el código, imprime: The result of 15 % 4 is the remainder of 15 divided by 4. The remainder is 3

Recuerda: Las expresiones son evaluadas de izquierda a derecha por defecto, Puedes cambiar esta secuencia añadiendo paréntesis. También recuerda que *,/ y % preceden sobre + y -.

10.9.2 Operador de concatenación de cadenas El signo más puede ser usado para concatenar dos cadenas de caracteres.

La concatenación se pone interesante cuando combinas cadenas y números:

Que hará el operador +? sumar las variables numéricas o concatenara los caracteres? Ok, ya has tenido tiempo de pensarlo. Los valores int serán tratados como caracteres y puestos a la derecha de la cadena, dando de resultado: String37

Así que el código se lee como "empieza con cadena, luego cadena "3" y cadena "7". Sin embargo, si usas los paréntesis alrededor de las variables numéricas tal como se muestra:


Página 91


2012

tendremos: String10 Al usar los paréntesis par éntesis haces que se evalúe primero lo que está entre ellos, así que el operador más a la derecha lo que hace es añadir el resultado del paréntesis. Recuerda esta regla: Si el operador es una cadena, el operador más se convierta en un concatenador de cadenas. Si ambos operadores son números, el operador + hace una suma. Alguna vez encontraras problemas al decidir si el operador de la izquierda es cadena o no. En el examen no lo esperes tan obvio. Observa el siguiente código:

No puedes saber que el operador + se está usando para sumar o concatenar hasta averiguar el tipo de devolución de foo de foo.. Finalmente tienes que saber que es válido usar el operador += += con con cadenas:

Como el operador += += para para hacer una suma, pues el resultado es 1234567.

10.10 Operadores de incremento y decremento Java tiene dos operadores que incrementan o decrementan una variable en 1. Estos operadores están compuestos de dos signos mas o dos menos (++ ( ++ ---). ). El operador se sitúa después del operando, o después para cambiar su valor. Sin embargo, cuando el operador está a un lado u otro, el resultado cambia, veamos este ejemplo:

Observa la 4a línea del programa donde el operador de incremento esta después de la variable player player.. Esto significa que estamos incrementando el valor en 1 pero justamente antes de arrojar el valor en la pantalla. Cuando ejecutamos el programa, aparece esto:


Página 92


2012

%java MathTest players online: onli ne: 0 The value of players is 1 The value of players is now 2

Tienes que advertir que la variable escrita en la pantalla, primero dice el valor, y luego efectúa la operación de incremento si el operador esta después de la variable. La línea 5 no incrementa la variable, solo está haciendo una concatenación. La línea 6 incrementa el valor de la variable antes de ser mostrada en pantalla. Puedes esperar un remix de operadores tal como este ejemplo:

El código imprime: x imprime: x = 3 y = 4 Esto se lee como "Si 3 es igual a 2 O 3 < 4". La primera expresión compara x e y, y el resultado es false false,, porque el incremento de x no sucede hasta que el test == == está está hecho. Lo siguiente que ocurre es que se incrementa x, así que ahora x vale 3. Luego el segundo checkeo dice que x es menor que y, pero ya hemos incrementado y antes en la comparación con x, así que la comparación (3 (3 < 4) 4) es cierta y se muestra el resultado.

10.11 Operador condicional El operador condicional es un operador ternario (tiene tres operandos) y se usa para evaluar una expresión booleana, se parece mucho a if , solo que en lugar de ejecutar un bloque lo que hace es asignarle un valor a la variable. Su construcción es como sigue:

Puedes leer que el número de pets es 3. Los siguiente que hacemos es asignar el estatus a la variable. Si el número de pets es menor que 4, le asigna un mensaje, de otra manera, le asigna el otro. El operador condicional comienza por una operación booleana seguida de dos posibles valores a la izquierda del operador =. El primero valor (el de la izquierda del :) se asigna si la condición se cumple, y el segundo valor se asigna si la condición no se cumple. Puedes incluso anidar operadores condicionales en un solo estamento:


Página 93


2012

10.12 Operadores lógicos Hay seis operadores lógicos (& ( &, | |,,^, !, && &&,, || ||). ). En alguna documentación de Sun se usa otra terminología para estos operadores, pero nuestro propósito son los seis de arriba.

10.13 Operadores e Bitwise Okey, esto puede ser confuso. De los seis operadores lógicos listados arriba, tres de ellos ell os (&, | |,,^) pueden ser usados también como operadores bitwise. Los L os operadores de bitwise fueron incluidos en versiones anteriores del examen, pero no están en el examen de Java 5. Aquí hay varios estamentos que usan operadores de bitwise:

Los operadores de bit comparan dos variables bit a bit, y devuelve una variable cuyos bits han sido basados en cualquier de las dos variables y siendo comparados sus bits con AND (&), otro con OR OR((|) y otro con ON ON((^), la consola muestra: 0 15 1

10.14 Atajo para operadores lógicos Hay cinco operadores lógicos que son usados para evaluar estamentos que contienen más de una expresión booleana. La mayoría de los más usados tienen dos atajos sintácticos, son AND AND,, y OR . Se representan: representan:  

&& AND && AND |||| OR OR


Página 94


2012

Para que la condición AND se cumpla, tiene que ser todo cierto, mientras que con OR es cierto si cualquiera de las comparaciones es verdadera. verdadera. Estos atajos se evalúan desde la izquierda a la derecha, si alguna condición no se cumple, no se sigue evaluando el estamento. class Logical { public static void main(String [] args) { boolean b = true && false; System.out.println("boolean b = " + b); } }

esto no muestra

%java Logical boolean boolean b = false

Presta atención al siguiente ejemplo:

da como resultado

% java TestOR i < 5 Result is true i >= 5 i >= 5


Página 95


2012

Aquí esta lo que ha pasado en el método main(): main(): 1. Cuando llegamos a la línea 3, se evalúa el primer operando con || 2. El método isItSmall(3) método isItSmall(3) se invoca e imprime "i "i < 5 5"" y devuelve true 3. El operando de la línea 3 es cierto, el operador || no evalúa la siguiente comparación así que nunca vemos "i " i >= 5" 5" que se hubiera mostrado si se hubiera ejecutado el segundo estamento. 4. Se evalúa la línea 6, comenzando con el primer operando || 5. El método isItSmall(6) se invoca imprimiendo "i "i >= >= 5 5"" y devolviendo false false.. 6. Como el primer operador || || de de la línea 6 es false false,, el operador || || no no puede saltar el segundo operando, porque todavía hay una expresión que puede ser verdad, si se evalúa el segundo operador dará true true.. 7. Se invoca isItSmall(9) invoca isItSmall(9) que que imprime "i >= 5". 8. El método isItSmall(9) isItSmall(9) devuelve devuelve false false así así que la expresión de la línea 6 es falsa, por lo que la línea 7 nunca se ejecuta.

10.15 Operadores lógicos sin atajos

Hay dos operadores lógicos, &, AND y | y | OR. OR. Estos operadores son usados en expresiones lógicas al igual que && && y y || ||,, pero no son atajos, estos evalúan ambos lados de la expresión siempre. Son ineficientes. Por ejemplo, si el primer operando con expresión & es falso, el segundo operando también se evaluara, aunque el resultado, evidentemente sea false false.. Y el OR también es ineficiente, si el primer operando es true,, JVM todavía evaluara el segundo operador true o perador aun sabiendo que el resultado r esultado dará true.

10.16 Operadores lógicos ^ y !

Los últimos operadores lógicos son: ^ XOR y ! booleano invertido. El OR exclusivo (o XOR) sólo evalúa valores booleanos. El operador ^ es tratado como un operador sin atajo y siempre evalúa ambos operandos en una expresión. Para el XOR, la expresión para que dé true tiene que ser EXACTAMENTE que uno de los operandos sea true true,, por ejemplo:

resulta: xor false La expresión anterior devuelve false porque ambos operandos son verdaderos. El operador ! devuelve el valor contrario del booleano:

se puede leer como "si no es verdad que 7 == 5," y la salida produce e m a i l : b r u j u l a t o @ y ah o o . e s

Página 96


2012

not equal

Aquí hay otro ejemplo de booleano:

da como resultado: ! true false

En el código anterior tienes que fijarte en que el test & es aprobado (imprimiendo true true)) y que el valor de la variable booleana f booleana f no no cambió, así que imprimió false.


Página 97


2012

11 Control de flujo, excepciones y aserciones Como te imaginarias escribiendo un código usando un lenguaje que no te permitiese ejecutar estamentos de forma condicional? El control de flujo es la clave de la mayoría de los lenguajes de programación, y Java ofrece varias maneras de hacerlo. Algo como if o el bucle for for son son estamentos comunes en la mayoría de los lenguajes. Pero Java también arroja un par de controles que podrías no haber usado antes, las excepciones y las aserciones. El estamento if y y switch son de tipo condición/decisión que permite a tu programa tener diferentes comportamientos dependiendo del resultado de un test lógico. Java provee de tres constructores de bucle, for for,, while while y y do do,, así que puedes ejecutar el mismo código una y otra vez dependiendo de que se cumpla una condición. Las excepciones dan una manera simple para organizar el código de forma sencilla que se ocupa de problemas que pudieran surgir durante la ejecución. Finalmente, la aserción, añadido en el lenguaje en el 1.4, te da una manera de comprobar y debuguear en condiciones que tu esperas puedan fallar mientras desarrollas, cuando no necesariamente necesites o quieras sobrecargar el manejo de excepciones. Con estas herramientas, puedes construir un programa robusto que pueda manejar cualquier situación lógica con elegancia.

11.1 Estamento if El if if yy el switch se refieren normalmente a estamentos de decisiones. Cuando usas un estamento de decisión en tu programa, le estas pidiendo al programa que evalúe una expresión dada para determinar qué acción coger. Vamos a ver el estamento if . El formato básico de un estamento if-else La expresión entre paréntesis debe evaluarse a booleano. Normalmente, se usa para evaluar una expresión y ejecutar un bloque u otro según si el resultado es verdadero o falso. El siguiente código demuestra un estamento if-else estamento if-else valido: valido:

El bloque else es opcional, así que también puedes usar lo siguiente:


Página 98


2012

El código asignara un 2 si la evaluación es true true.. Las siguientes líneas fuera de las llaves se ejecutaran sin importar el resultado. resultado. Hasta las llaves son opcionales si solo quieres ejecutar un único estamento (el inmediato justo después del cierre c ierre del paréntesis):

Ten cuidado con el código de arriba, porque puedes pensar que se lee así:

Si x es más grande que 3, entonces poner y a 2, la z a z+8 z+8 y y luego a =y + x. x. Pero en realidad las dos últimas líneas se ejecutarán, no son parte del bloque de condición. Podrías tener la necesidad de anidar estamentos if-else if-else (no (no es recomendado para la lectura). Puedes inicializar un if-else if-else para para evaluar múltiples condiciones. Los siguientes ejemplos usan dos condiciones, así que si el primer test falla, ejecutaremos un segundo test para decidir qué hacer:

Esto podría rescribirse tal como:


Página 99


2012

Hay un par de reglas para el uso de if-else-else de if-else-else if :  

Puedes tener desde cero else hasta uno para cada if , y deben ir después de cada if . Una vez que else es ejecutado, ninguno de los demás else o if serán ejecutados.

11.2 Estamento switch Una manera de simular el uso de switch switch es es usar múltiples if . Echa un vistazo al código if -else else y y fíjate como de confuso puede ser tener if anidados, anidados, incluso con pocos niveles:

y ahora lo mismo representado con switch switch::


Página 100


2012

Por si aún no has pillado la estructura de un switch switch,, te lo explico brevemente. br evemente. Como cualquier bloque, un switch switch rodea rodea entre llaves los códigos. Entre paréntesis, switch switch,, evalúa la variable. En cada caso, case case,, ejecuta las instrucciones cuando el caso coincide, hasta llegar a break break.. Si no se pusiese un break break,, se continuarían ejecutando las demás instrucciones contenidas en los siguientes case case.. Es opcional. Con default default,, te aseguras de ejecutar alguna instrucción si no se cumple ningún caso. Es opcional.

11.2.1 Expresiones válidas para switch y case y case El uso general de switch switch es: es:

Una expresión switch debe evaluar un carácter carácter,, byte byte,, short short,, int o como en Java 5, una enumeración. Eso significa que si no estás usando una enumeración, solo puedes usar variables y valores que puedan ser automáticamente ascendidos (en otras palabras, casteados) a int int . . No va a compilar si usas cualquier otra cosa, incluyendo números long long,, float float o o double double.. El estamento case case evalúa un valor constante del mismo tipo expresado en switch switch,, con algo adicional, y gran, restricción: la constante case debe ser una constante co nstante en tiempo de ejecución! Lo que significa que solo puedes usar variables constantes o finales. No es suficiente con que sea una variable final final,, debe compilar como constante:

switch solo puede evaluar la igualdad. Quiere decir que los operadores como mayor que, switch menor que, etc.. no se pueden usar en case case.. Lo siguiente es una expresión válida usando un método de invocación en el estamento switch. Fíjate que en este código, para que sea válido, el método está siendo invocado en la referencia del objeto, debe devolver un valor compatible con int int..


Página 101


2012

Qué pasa si usas una variable menor que un int en un switch switch?? Observa el ejemplo:

El código no compilará. Aunque el estamento es válido, el byte byte es es implícitamente casteado a int int,, el segundo case (128) es demasiado grande para un byte (hasta 127 positivos) y el compilador lo sabe! Intentar compilar la última instrucción da un error como este:

Tampoco no es válido tener más de un case case usando usando el mismo valor. Por ejemplo el siguiente bloque no compilara porque usa 2 case case con con el valor 80:


Página 102


2012

Es lícito aprovechar la potencia del boxing en una expresión switch switch.. Por ejemplo, esto es válido:

11.2.2 Interrupciones y flujo en los boques switch Ya estamos preparados para discutir el estamento break break,, y mas detalles sobre control de flujo en un switch switch.. Lo más importante a recordar es que la ejecución de un switch switch funciona funciona así: Las constantes en case son evaluadas desde arriba, hacia abajo, y el primer valor evaluado en case que coincida con la expresión switch switch , , será el punto de entrada para ejecutar el bloque case.. case En otras palabras, una vez que un case sea ejecutado, la JVM JVM ejecutará los demás bloques bloques case siguientes, hasta encontrar un estamento break break.. El siguiente ejemplo usa una enumeración en un estamento case case::

En este ejemplo, el case green: green: encaja, así que la l a JVM ejecutará ese bloque y los subsiguientes produciendo la salida: green blue done

De nuevo, cuando el programa encuentra la palabra break break durante durante la ejecución de un estamento switch switch,, la ejecución del bloque case finalizara y saldrá del bloque switch switch.. Si se omite break break,, el programa simplemente, simplemente, ejecutará todos los bloques case case hasta hasta que termine el estamento switch switch.. Observa el siguiente código:


Página 103


2012

mostrará: x is one x is two x is three out of the switch

Esta combinación sucede cuando el código no encuentra el estamento break break,, la ejecución se mantiene hasta el final. Esta clase de ejecución se la conoce como "fall-through "fall-through"" porque la manera de ejecutarse cae desde el primer case ejecutado hasta el último. Recuerda, que el punto de entrada de ejecución es el primer case que coincida con la evaluación de switch switch.. En otras palabras, no puedes pensar "Encuentra la coincidencia, ejecuta el bloque y sal". Porque eso no funciona así. Si tú quieres que funcione así, tienes que usar break break en en cada case case como como en el ejemplo:

Este código mostrará: x is one out of the switch

y ya está. Hemos entrado dentro del bloque switch en el case 1. Porque encaja con la evaluación en switch switch,, hemos conseguido ejecutar el estamento println println,, luego llega a break break y y salta al final de switch switch.. Un ejemplo interesante del uso de este fall through se through se muestra en el siguiente código:


Página 104


2012

El estamento switch switch imprimirá imprimirá "x is an even number" o nada, dependiendo de si el numero esta entre uno y 10 y es par o impar. Por ejemplo, si x vale 4, la ejecución comenzaría por el case case 4 4 hasta el final. Nota: Debido a que el fall-through es menos intuitivo, Sun recomienda que añadas un comentario // fall through cuando through cuando uses esta lógica.

11.2.3 El caso default Qué pasa si en el código anterior, tu querías imprimir "x is an odd number" si ninguno de los casos (incluso los impares) encajaba? No podrías ponerlo después del estamento de switch switch,, o incluso en el último case case,, porque en ambas situaciones, podría imprimir siempre. Para conseguir este comportamiento necesitaras la palabra clave default default.. (Sin embargo, si tú te has preguntado por qué hay una palabra clave default default aunque aunque no lo usemos como modificador de acceso, verás ahora que default default se usa para un propósito completamente distinto). El único cambio que necesitamos hacer es añadir un caso por defecto en el código:


Página 105


2012

Los bucles de Java vienen en tres sabores: while while,, do do y y for for (y (y a partir de Java 5, for tiene dos variantes). Los tres te permiten repetir un bloque de código tantas veces como se cumple la condición, o especificas veces de iteraciones. Probablemente estas familiarizado con los bucles en otros lenguajes, así que si eres nuevo en Java, no será ningún problema pr oblema aprenderlos.

11.3 Estamento while Este bucle es bueno en escenarios donde no sabes la cantidad de veces que un bloque de estamentos tiene que repetirse, pero quieres continuar haciendo el bucle mientras la condición se cumpla. Un estamento while while es es como esto:

ó

En este caso, como en todos los bucles, la expresión debe evaluarse como un resultado booleano. El cuerpo del bucle se ejecutará mientras la expresión resulte true true.. Una vez dentro del bucle, el cuerpo se repetirá hasta que la condición sea evaluada a false false.. En el ejemplo anterior, el programa entrara en el bucle porque x es igual a 2. Sin embargo, x es incrementada en el bucle, así que cuando la condición se comprueba otra vez, la evaluación da false y sale del bucle. Cualquier variable usada en la expresión while debe ser declarada antes de que la expresión sea evaluada, en otras palabras, no puedes decir:

Nuevamente, por qué lo harías? En lugar de evaluar la variable, la declararías y la inicializarías, así que siempre tendría el mismo valor. No se parece mucho a una evaluación! La clave está en recordar que el bucle while while puede ni llegar a ejecutarse. Si la evaluación devuelve false false,, el cuerpo de while while se se ignoraría.


Página 106


2012

El código devuelve: past the loop loo p

Ya que la expresión (x (x > 8) 8) se evalúa falsa falsa,, nada en el interior del cuerpo se ejecuta.

11.4 Estamento do while El uso de do while es while es similar a while while excepto excepto que la expresión no se evalúa hasta que el código dentro del bucle se ejecuta, así que se garantiza que el código del bloque se ejecutará al menos una vez. El siguiente ejemplo muestra un do do--while en acción:

El System.out.println() System.out.println() imprimirá una vez, aunque la expresión se evalúa falsa falsa.. Recuerda, el bucle siempre ejecutará el código del cuerpo por lo menos, una vez. Asegúrate de usar el punto y coma al final de la expresión while while..

El uso de los bucles En Java 5, los bucles for for tienen tienen una segunda estructura. Nosotros llamaremos al viejo estilo, "básico", y al nuevo estilo "bucle "bucle mejorado" aunque Sun se refieren a el como for-each. for-each. Dependiendo de la documentación que uses (Sun incluida) verás los dos términos paralelamente con for-in. Los términos for-in y for-each se refieren al mismo for mejorado. El bucle básico de for es más flexible que su homónimo mejorado, pero el mejorado fue diseñado para realizar iteraciones a través de colecciones y arrays.

11.5 Estamento for, o for-in (el bucle básico) Este estamento es útil cuando sabes de antemano las veces que se ejecutará el código dentro del bloque. Este estamento consta de tres partes además del cuerpo del bucle:


Página 107

Curso gratuito de Java en emuladores L2 Java   

2012

Declaración e inicialización de la variable La expresión booleana La iteración

Las tres partes están separadas por punto y coma. Los siguientes ejemplos demuestran un bucle for for.. El primer ejemplo muestra las partes de un bucle for for en en pseudo código, y la segunda, un ejemplo típico.

El for El for básico: declaración e inicialización La primera parte del estamento te permite declarar e inicializar cero, una o múltiples variables del mismo tipo dentro del paréntesis después de for for.. Si declaras más de una variable del mismo tipo, entonces las tendrás que separar con ; (punto y coma) tal como sigue:

La declaración e inicialización ocurre antes que nada en el bucle. Y mientras las otras dos partes, la evaluación booleana y la iteración, se ejecutarán con cada vuelta de bucle, la declaración sólo sucederá una vez al comienzo. También tienes que saber que la vida de las variables declaradas en el bucle, terminan con el bucle. Este ejemplo lo demuestra:

Test.java:19: cannot resolve symbol symbol : variable x location: class Test System.out.println(x); ^


Página 108


2012

El for El for básico: la expresión booleana La siguiente sección que se ejecuta es la expresión de la condición, la que (como en todos los test condicionales) debe evaluar un valor booleano. Solo puedes tener una expresión lógica, pero puede ser compleja. Observa el código:

Este código era válido, pero el siguiente no lo es:

El compilador arrojará: TestLong.java:20: TestLong.java:20: ';' expected for (int x = 0; (x > 5), (y < 2); x++) { } ^

La regla para recordar esto: Solo puedes tener una expresión lógica. En otras palabras, no puedes usar múltiples evaluaciones separadas por comas, aunque las otras dos partes del estamento puedan tener múltiples partes.

El for El for básico: el operador de iteración Después de cada ejecución del cuerpo del bucle, se ejecuta la expresión de internación. Esto es donde le dices lo que quieres que ocurra en cada iteración del bucle. Recuerda que siempre ocurre después de que el bucle se complete. Mira lo siguiente:

El código precedente se ejecuta solo una vez. La primera vez, dentro del estamento x vale cero, luego se evalúa para ver si es menor que uno (lo que es cierto) para después ejecutar el cuerpo del bucle. Después de que el cuerpo se haya ejecutado, la iteración se ejecuta incrementando x incrementando x en en 1. Lo siguiente que toca es evaluar x , pero el resultado ahora es falso, la ejecución del bucle termina. Ten en cuenta que, salvo una salida forzada, la evaluación de la iteración y la evaluación del booleano son las dos últimas cosas que ocurre en un bucle for bucle for . El ejemplo de salida forzada pueden ser un break break,, un return return,, un System.exit() System.exit() o o una excepción, que causará una salida repentina sin ejecutar la expresión de iteración.


Página 109


2012

Observa este código:

Al ejecutar este código, se arroja en pantalla: in for loop

El estamento imprime una vez, porque un return causa que se abandone la ejecución no solo la iteración sino que también todo el método. Así que la iteración de la expresión nunca se ejecuta en este caso. La siguiente tabla muestra el resultado de una salida forzada del bucle:

El for El for básico: puntualizaciones Ninguna de las tres secciones de la declaración son obligatorias! El siguiente ejemplo es perfectamente válido (aunque no es buena práctica):

En el ejemplo todas las partes están vacías así que este bucle es infinito. Es importante saber que con la ausencia de la inicialización y la sección de incremento, el bucle actuará como bucle while while.. El siguiente ejemplo lo demuestra:


Página 110


2012

El siguiente ejemplo demuestra que un bucle for for con múltiples variables, y deben ser del mismo tipo. Recuerda que las variables declaradas en el estamento for son todas locales y no pueden ser usadas fuera del for for..

La ultima cosa que añadir es que las tres secciones de for for son son independientes unas de otras. Las tres expresiones no necesitan operar la misma variable, aunque es lo típico. Pero hasta el operador de iteración, el cual es llamado erróneamente el operador de incremento, no necesita incrementar o asignar nada, puedes poner un estamento virtual para lo que quieras que ocurra en cada iteración del bucle. Mira lo siguiente:

Lo anterior imprime: iterate iterate

11.5.1 El for mejorado (para arrays, for each) Fue introducido para Java 5 y está especializado en simplificar el trabajo de recorrer una colección o un array en un bucle. En este tema vamos a centrarnos en el uso de este nuevo for for.. Lo visitaremos nuevamente, cuando veamos las colecciones, que es donde esta nueva revisión se siente como en casa. En lugar de tener tres componentes, la versión actualizada tiene dos. Repasemos la vieja forma y luego usaremos la nueva:

Resultado: 12341234


Página 111


2012

Formalmente, vamos a describir cómo funciona:

Las dos piezas del estamento son:





declaración: es declaración: es un bloque recién declarado de una variable, de tipo compatible con los elementos del array al que se está accediendo. Esta variable estará disponible dentro del bloque, y su valor será el mismo que el elemento actual del array. expresión: debe expresión: debe evaluar el array que quieres recorrer. Podría ser un array, o un método que devuelve un array. El array puede ser de cualquier tipo, t ipo, objetos, primitivos o arrays de arrays.

Usando las definiciones anteriores, echemos un vistazo a algunas declaraciones válidas y no válidas:

El for for actualizado actualizado asume que salvo en una salida forzosa del bucle, siempre recorrerás todos los elementos del array. El siguiente apartado de break break y y continue continue se se aplican a los dos tipos de for.. for

11.6 El uso de break y continue El uso de break break y y continue son usadas para parar todo el bucle o sólo la iteración actual (continue continue). ). Normalmente si usas break o continue continue,, lo harás en una evaluación if dentro dentro del bucle, y si alguna condición se convierte en true (o false dependiendo del programa) querrás salir inmediatamente. La diferencia entre ellos es si querrás continuar o no con la iteración o saltar al primer estamento después del bucle y continuar desde allí


Página 112


2012

El estamento break hace que el programa detenga la ejecución de su bucle inmediato y comienza a procesar la siguiente línea de código. El estamento continue hace que sólo la iteración actual del bucle inmediato se detenga y comience por la siguiente evaluación. Cuando usamos un continue en un bucle for for,, tienes que considerar los efectos que continue tiene en la operación del bucle. Examina este ejemplo:

La pregunta es, esto es un bucle sin fin? La respuesta es no. Cuando llegamos al continue continue,, la iteración aun está ejecutándose. Se ejecuta a través de la iteración actual de manera natural. Así que el ejemplo anterior, la variable i todavía incrementará después de que la condición (i (i < 10)) sea evaluada de nuevo. La mayoría de las veces, un continue 10 continue se usa dentro de un if tal tal como se muestra:


Página 113


2012

Como nota personal, tengo que añadir que no vi claro el uso de continue continue,, así que desarrollé el siguiente código:

y esto me produjo la siguiente salida: Inside Wea: 0 Inside Wea: 1 Inside Wea: 2 Inside Wea: 3 Inside Wea: 4 Inside Inside Wea: 6 Inside Wea: 7 Inside Wea: 8 Inside Wea: 9

loop 0 loop 1 loop 2 loop 3 loop 4 loop 5 loop 6 loop 7 loop 8 loop 9

Así pude observar, que cuando la condición se cumple, el resto del bloque no se ejecuta (se ignora cuando i==5), volviendo el punto de ejecución del estamento for for,, donde se continua la iteración hasta el final.


Página 114


2012

11.6.1 Estamentos sin etiquetas Los estamentos break y continue pueden estar etiquetados o no. Quizás lo más común es que no estén etiquetados. Como dijimos antes, un estamento break break (sin (sin etiqueta) saldrá del más inmediato bucle y seguirá con la siguiente línea de código después del cuerpo. El siguiente ejemplo demuestra un estamento break break::

En este ejemplo, el estamento break break esta sin etiquetar. El siguiente ejemplo es un ejemplo de continue continue etiquetado: etiquetado:

En este ejemplo, se está leyendo el campo de un fichero. Cuando encuentra un error, el programa salta al siguiente campo de la fila y usa el estamento continue para volver al bucle (sino es el final de la fila) y mantiene la lectura de varios campos. Si el estamento break break se se hubiera puesto en su lugar, el código habría parado de leer al encontrar el error y se hubiera terminado la lectura del fichero. El estamento continue continue es una manera de decir " Esta iteración en particular necesita parar, pero no todo el conjunto. No quiera finalizar el resto de la iteración".

11.6.2 Estamento con etiquetas Aunque muchos estamentos en Java pueden ser etiquetados, lo más común es usar las etiquetas con bucles como for for o o while while,, en conjunción con break break y y continue continue.. Una etiqueta debe ser puesta justo antes del estamento etiquetado, y consiste en un identificador valido que finaliza con dos puntos (: ( :).


Página 115


2012

Tienes que entender la diferencia entre etiquetado y sin etiquetar. La etiquetación solo son necesarias en situaciones donde tienes un bucle anidado, y necesitas indicar cuál de los bucles quieres romper, o a cuál de ellos quieres continuar en la siguiente iteración. Un estamento break saldrá del bucle etiquetado, etiquetado, lo opuesto al bucle inmediato, inmediato, si un break break esta combinado con una etiqueta. Un ejemplo de como parece una etiqueta es lo siguiente:

La etiqueta debe de cumplir las mismas reglas que las variables en lo que se refiere al nombre. La sintaxis para el uso de la etiqueta en conjunción con un estamento break es la palabra palabra break , , después el nombre de la etiqueta, seguido de un punto y coma. break c oma. Un ejemplo más completo es el que sigue:

El código produce la siguiente salida: Hello Good-Bye


Página 116


2012

En este ejemplo, la palabra Hello Hello será imprimida una vez. Luego la etiqueta de break break será será ejecutada y el flujo saldrá del bucle etiquetado outer outer.. La siguiente línea de código imprimirá Good-Bye Good-Bye.. Veamos lo que pasa si el estamento continue continue se se usa en lugar del break break.. El siguiente código es similar al anterior, con la excepción de la sustitución de break break por continue:: continue

Al ejecutar el código, se imprime: Hello Hello Hello Hello Hello Good-Bye

En este ejemplo, Hello Hello se imprimirá cinco veces. Después de que el estamento continue continue se se haya ejecutado, el flujo continua con la siguiente iteración del bucle identificado en al etiqueta. Finalmente, cuando la condición en el bucle más exterior se evalúa a false false,, este bucle terminara con la impresión de Good-Bye Good-Bye..


Página 117


2012

12. Excepciones Una vieja máxima del desarrollo de software dice que del 80% del trabajo se usa un 20%. El 80% se refiere al esfuerzo para evaluar y manejar errores. En muchos lenguajes, escribir programas que evalúen y manejan errores es tedioso e hincha el código fuente de la aplicación para hacerlo tan confuso como un espagueti. Aun así, la detección y manejo de errores debe ser el ingrediente más importante para la robustez de una aplicación. Java provee a los desarrolladores con elegantes mecanismos de manejo de errores que produce un eficiente y organizado código: manejo de excepciones (exception handling). Las excepciones permiten a los desarrolladores detectar errores fácilmente sin escribir código especial para evaluar valores de retorno. Incluso mejor, te permite manejar la excepción de manera separada y transparente del código generado por la excepción. También te permite usar el mismo manejador de excepciones para hacer frente a una serie de posibles excepciones.

12.1 El estamento try – catch Antes de empezar, introduzcamos algo de terminología. El termino excepción significa condición excepcional, y es un suceso que altera el fluido normal del programa. Un puñado de cosas pueden conducir a una excepción, incluyen fallo de hardware, fuente de recursos agotadas, y unos buenos bugs. Cuando ocurre un evento excepcional en Java, se dice que se ha arrojado una excepción. El código responsable de hacer excepciones se llama "manejador de excepciones" en inglés " exception handler ", ", y atrapa la excepción arrojada. El manejador de excepciones funciona transfiriendo la excepción del programa al manejador de excepciones apropiado cuando sucede el evento. Por ejemplo, si llamas a un método que abre una fila y la fila no puede ser abierta, la ejecución del método se detendrá, y el código que escribiste para manejar la situación se ejecutara. Para ello, necesitamos una manera de decirle a la JVM que el cuando suceda una cierta excepción, ejecute el código. Para hacer esto usamos las palabras claves try try y y catch catch.. El try try se usa para definir un bloque de código donde puede ocurrir la excepción. Este bloque se le llama región guardada (lo que significa que el código peligroso va aquí). Una o más clausulas catch catch especifican la excepción (o grupo de excepciones, más tarde veremos más) a un bloque de código que lo maneje. Aquí se muestra un ejemplo en pseudocódigo:


Página 118


2012

En este pseudocódigo, la línea 2 hasta la 5 constituye la región gobernada por try try.. La línea 7 es el manejador de la excepción de tipo MyFirstException MyFirstException.. La línea 12 es un manejador de excepciones de tipo MySecondException MySecondException.. Date cuenta de que el bloque catch catch sigue sigue al try try.. Esto es obligatorio, si tienes uno o más bloques catch catch,, deben ir inmediatamente detrás de try try.. Además, los bloques catch catch deben ir uno detrás del otro, sin estamentos o bloques de por medio. También el orden de los catch catch importa, importa, como veremos más tarde. La ejecución de la región de seguridad empieza en la línea 2. Si el programa se ejecuta sin excepciones, saltará a la línea 15. Sin embargo, si la primera línea 2 hasta la 5 arroja una excepción de tipo MyFirstException MyFirstException,, la ejecución será inmediatamente transferida a la línea 7. Desde la línea 8 a la 10 se ejecutarán todas las instrucciones del bloque, y luego la ejecución continuara en la línea 15 y continuará. Fíjate que si una excepción ocurre en la línea 3 del bloque, el resto de líneas en el try try no no serán ejecutadas. Una vez que el control salte al bloque catch catch,, no se volverá a ejecutar el bloque try try.. Esto es exactamente lo que tú quieres, creo... Imagina que tu código se parece a esto en pseudo código:


Página 119


2012

El pseudocódigo demuestra cómo funcionan normalmente las excepciones. El código que depende de un riesgo en la operación (como llenar una tabla con los datos de un fichero en internet) esta agrupado dentro del bloque try try de de tal manera que si, por ejemplo, la primera operación fracasa, no vas a intentar continuar ejecutando otro código que seguramente va a fallar también. El pseudocódigo del ejemplo no te va a dejar leer un fichero si no hay internet en primer lugar. Uno de los beneficios de usar un manejador de excepciones es que el código para manejar en cualquier excepción en particular puede ocurrir en la región gobernada, necesite ser reescrita solo una vez. Volviendo a nuestro código anterior, pueden haber tres sitios en nuestro bloque try try que que pueda generar una MyFirstException MyFirstException,, pero si esto ocurre, será manejado en el mismo bloque catch catch (línea (línea 7). Hablaremos de más beneficios de la excepción casi al final de este tema.

12.1.1 El uso de finally de finally Aunque try y catch proveen de un fabuloso mecanismo para atrapar y manejar excepciones, nos queda el problema de como limpiar lo que deja una excepción. Dado que la ejecución dentro del bloque try try se se interrumpe súbitamente si hay una excepción, no podemos limpiar el código del bloque try try y y esperar que sea ejecutado. Casi que es una mala idea poner nuestro código de limpieza en cada bloque catch catch,, veamos el motivo. El manejador de excepciones no son el lugar adecuado para limpiar el bloque try try porque porque cada manejador requiere su propia copia para limpiar el código. Por ejemplo, si algún puerto o fichero se queda abierto en la región de seguridad, cada excepción debería cerrar ese fichero o ese puerto. Sería más fácil olvidar la limpieza y también un montón de código redundante. Para solucionar este problema, Java provee del bloque finally finally.. El bloque finally finally encierra un código que siempre será ejecutado después del bloque try try,, sin importar si hay una excepción o no. Aunque hubiera un return return al final del bloque try try,, se ejecutaría justo después del return return,, y antes de que el return se ejecute! Este es el lugar correcto para meter tu código de limpieza, cerrar tus puertos o cerrar tus ficheros, etc... Si el código se ejecuta sin excepciones, el código finally se ejecutará inmediatamente después. Veamos otro ejemplo:


Página 120


2012

Igual que antes, la ejecución empieza en la primera línea del bloque try try,, la línea 2. Si no hay excepciones en el bloque try try,, la ejecución prosigue por la línea 11, la primera línea del bloque finally finally.. Por otra parte, si MySeconException arroja una excepción mientras el bloque try try se está ejecutando, la ejecución prosigue en la primera línea del manejador de excepciones, la línea 8 de catch catch.. Después de que todo el código en catch catch se se haya ejecutado, el programa prosigue en la línea 11, la primera línea de finally finally.. Repite después de mi: el bloque finally finally siempre siempre se ejecuta! OK, tenemos que afinar un poco, pero por ahora la idea de que finally finally siempre siempre se ejecuta ha quedado clara. Tanto si se coge la excepción, como si no, finally siempre se ejecuta. Más adelante a delante veremos unos pocos escenarios donde finally finally podría podría no completarse. Recuerda, la cláusula finally finally no no es obligatoria. Si no tienes, el código, compilará perfectamente. De hecho, no todos los actos de un código tienen que ser limpiados después de que un bloque try se ejecute, así que la cláusula finally no es obligatoria. o bligatoria. También, porque el compilador no exige tampoco la cláusula catch catch,, algunas veces querrás ejecutar el código que tiene un try try para para terminar en el finally finally.. Esta clase de programación es útil cuando la excepción devuelve el flujo al método que lo invocó, como explicaremos en la siguiente sección. El uso de finally finally te te permite limpiar el código ejecutado aunque no haya clausula catch catch.. Este código muestra un try try con con finally finally pero pero sin catch catch::

Este código muestra un try try,, catch catch y y finally finally::


Página 121


2012

El siguiente código ilegal muestra un try sin catch o finally finally::

El siguiente código ilegal muestra un ejemplo de código fuera de lugar:

12.1.2 Programación de excepciones no capturadas Por qué los catch no son obligatorios? Que ocurre tras una excepción en un bloque try donde no hay catch? No hay requerimientos para que en tu código haya un catch para cada excepción que pueda ser arrojada al correspondiente bloque try try.. El hecho, es que es dudoso que puedas hacer tal hazaña! Si un método no provee de una clausula catch en particular, a ese método se le llama "ducking" y lo que hace es pasarle la pelota a otro método. Así que, qué ocurre? Cuando un método, llama a otro, y esto a otro... la ejecución comienza, obviamente, por el ultimo método invocado. Cuando uno de estos métodos invocados tiene una excepción, esta excepción se recorre hacia atrás, esperando a ser atrapada. Si esta excepción llega al primer método, y no es atrapada, estalla deteniendo la ejecución del programa.


Página 122


2012

Observa este ejemplo donde se crea una clase main main que ejecuta el método reverse reverse sin proporcionarle argumento con el que trabajar (línea 8). De la línea 8 saltamos al método reverse reverse (línea 23) que arroja una excepción de tipo “NadaQueDevolver ”. ”. En la línea 25, comprueba que la longitud de la cadena es menor que uno y arroja la excepción. En la línea 41 se crea la clase NadaQueDevolver que que hereda la clase Exception. Exception. El constructor de la clase hace una llamada (super ( super)) pasándole como parámetro un texto. Volvemos a la línea 10 donde se coge la excepción y se imprime “Excepción arrojada: No hay texto que devolver”.

Finalmente se ejecuta el bloque finally finally..


Página 123


2012

12.1.3 Definiendo excepciones Hemos discutido las excepciones como concepto. Sabemos que se arrojan cuando surge algún tipo de problema, y sabemos el efecto que tienen en el flujo de un programa. En esta sección vamos a desarrollar los conceptos más allá y el uso de excepciones en código Java funcional. Antes dijimos que una excepción es una ocurrencia que altera el flujo normal del programa. Pero desde que estamos usando Java, cualquier cosa que no es un primitivo, es... un objeto. Las excepciones no, bien, esta es la excepción que confirma la regla. Cada excepción es una instancia de la clase Exception Exception en su propio árbol de jerarquía. En otras palabras, las excepciones son siempre una subclase de java.lang.Exception de java.lang.Exception.. Cuando se arroja una excepción, un objeto del subtipo particular se instancia y maneja la excepción como un argumento para la cláusula catch catch.. Un catch se parece a esto:

En este ejemplo, es una instancia de la clase ArrayIndexOutOfBoundsException ArrayIndexOutOfBoundsException.. Como cualquier otro objeto, puedes llamar a sus métodos.

12.1.4 Jerarquía de las excepciones Todas las clases de excepciones son subtipos de la clase Exception Exception.. Esta clase deriva de Throwable (la cual deriva de la clase Object Object). ). Esta imagen representa la jerarquía de las clases Exception Exception::


Página 124


2012

Como puedes observar, hay dos subclases que derivan de Throwable Throwable:: Exception y Error Error.. Las clases que derivan de Error Error representan representan situaciones inusuales que no son causadas por errores del programa, e indican cosas que normalmente no pasarían durante la ejecución de un programa, como por ejemplo, que la JVM se quede sin memoria. Normalmente tu aplicación no puede manejar este tipo de errores, así que no puede recuperarse. No se te pide que los manejes. Si tu código no los maneja, (normalmente no) compilará sin problemas. Quizás hayas pensado en condiciones excepcionales, los errores técnicamente no son excepciones porque no derivan de la clase Exception Exception.. En general, una excepción representa algo que ocurre como resultado no deseado por un error de programación, ya que no se considera alguna condición que pueda estar presente. Por ejemplo, si en tu aplicación se supone que va a comunicarse con otra aplicación en otro ordenador, y este, no contesta, esta excepción no la causa un bug. Estas excepciones son un caso especial porque algunas veces indican error del programa. También pueden presentarse casos raros para manejar excepciones en condiciones excepcionales. En tiempo de ejecución, las excepciones son discutidas con gran detalle, más adelante en este tema. Java provee de muchas clases de excepciones, la mayoría con nombres bastantes descriptivos. Hay dos maneras de conseguir la información de una excepción. La primera es desde el tipo de excepción en si misma. La siguiente es de la información que obtienes del objeto en excepción. La clase Throwable Throwable (en (en lo alto de la herencia) provee a sus descendientes con algunos métodos que son útiles para manejar las excepciones. Uno de ellos es printStackTrace() printStackTrace().. Como imaginabas, puedes invocar los métodos de una excepción, como vimos en un ejemplo anterior, se imprimirá el seguimiento de la excepción. Ya vimos que una llamada a la pila empieza desde abajo para terminar en el primer método que invoco a los demás. Te darás cuenta de que printStackTrace() printStackTrace() imprime imprime la mayoría de los métodos recientes y luego continua descendiendo, imprimiendo el nombre de cada método de la pila.

12.1.5 Manejando una clase completa de la jerarquía de excepciones Ya hemos visto que la palabra clave catch catch te permite especificar un tipo en particular de excepción. Puedes capturar más de un tipo de excepciones en una única cláusula. Si la clase de excepción especificada en catch no tiene subclases, entonces solo se atrapará esa excepción en concreto. Sin embargo, si la clase especificada en catch tiene subclases, las subclases también serán atrapadas. Por ejemplo, la clase IndexOutOfBoundsException (se da cuando el índice especificado de un array sale de su rango) tiene dos subclases, ArrayIndexOutOfBoundsException y StringIndexOutOfBoundsException StringIndexOutOfBoundsException.. Podrías desear escribir un código que maneje la excepción, pero no sabes que excepción se está arrojando (cual subclase). En este caso, puedes escribir un catch catch como como este:


Página 125


2012

Si cualquier código en el bloque try try arroja: arroja: ArrayIndexOutOfBoundsException o StringIndexOutOfBoundsException StringIndexOutOfBoundsException,, la excepción será atrapada y manejada. Esto puede ser conveniente, pero podría ser usado por separado. Al especificar una excepción de la superclase en la cláusula catch catch,, estás descartando información valiosa de tu excepción. Puedes, naturalmente, averiguar como ocurrió esa excepción en la clase, pero si vas a hacer eso, es mejor escribir una clausula catch catch para para cada tipo de excepción. Si tienes una jerarquía de excepciones compuesta de una superclase y un numero de subtipos, y estás interesado en manejar uno de los subtipos de una manera especial, necesitas escribir solo dos clausulas catch catch.. Cuando se arroja una excepción, Java intentará encontrar la excepción del tipo que encaje con la cláusula catch catch.. Si no la hubiese, entonces irá a por su supertipo. Si tampoco existiese, entonces se propagará la excepción hasta que pueda ser manejada llegando a interrumpir la ejecución del programa sino se detuviese. Este proceso se le conoce como la excepción que encaja con la búsqueda. Veamos un ejemplo:


Página 126


2012

Este programa intenta abrir un fichero para lectura de algún dato. Abrir y leer ficheros puede generar muchas excepciones, la mayoría de ellas son de algún tipo de IOException IOException.. Imagina que en este programa estamos interesados en saber sólo cuando hay una excepción en concreto: FileNotFoundException . De otra manera no sabemos de que problema se trata. FileNotFoundException es una subclase de IOException IOException.. Así que podemos manejar en la cláusula catch todos los subtipos de IOException IOException,, pero podríamos evaluar la excepción que determina si fue una FileNotFoundException . Así que codificamos una excepción exclusivamente para FileNotFoundException y separado de la excepción que maneja los demás subtipos de excepción. Este código generado para FileNotFoundException FileNotFoundException será será manejado por catch comenzando en la línea 10. Si genera otra clase de IOException IOException,, a lo mejor, EOFException EOFException,, que es subclase de IOException IOException,, será manejado por el catch de la línea 15. Si cualquier otra excepción es generada, tal como excepciones en tiempo de ejecución, no será capturada y se propagara por la pila. Date cuenta que la cláusula para FileNotFoundException ha sido puesto antes que IOException IOException.. Esto es muy importante. Si no lo hiciéramos, el programa no compilara. Los manejadores específicos de excepciones deben ser puestos delante siempre de los manejadores genéricos. Lo siguiente no compilará:


Página 127


2012

El compilador arrojara esto: TestEx.java:15: exception java.io.FileNotFoundException has already been caught } catch (FileNotFoundExceptio (FileNotFoundException n ex) { ^

12.1.6 Declaración de Excepciones e Interfaces Públicas Como sabemos que métodos que arrojan una excepción y que podemos capturar? Un método debe especificar el tipo y la cantidad de argumentos que acepta y lo que devuelve, las excepciones que un método puede arrojar tienen que ser declaradas (al menos las excepciones son subclases de RunTimeException RunTimeException). ). La lista de excepciones declaradas es una parte de la interfaz pública del método. La palabra clave throws throws se se usa para enumerar la lista de excepciones que un método puede arrojar:

Este método tiene un tipo de retorno void void,, no acepta argumentos y declara que puede arrojar dos tipos de excepciones: MyException1 MyException1 y y MyException2 MyException2.. Solo porque el método declare que arroja excepciones, no quiere decir que siempre las esté arrojando. Solo dice que podría. Supón que tu método no arroja directamente una excepción, pero llama a un método que lo hace. Puedes elegir manejar o no la excepción. Si declaras la excepción que tu método puede conseguir de otro método, y no provees de un try try--catch catch,, entonces el método programará la excepción. Cualquier método que pueda arrojar una excepción (que sea subclase de RunTimeException RunTimeException)) debe declarar la excepción. Eso incluye métodos que no están arrojando excepciones directamente, pero están pasando la excepción a otro método. Si pasas la excepción, estás arrojando RunTimeException RunTimeException.. Como las subclases están exentas de implementarlo, el compilador no va a mirar si lo has hecho. Todas las excepciones RunTimeException son consideradas "comprobadas", porque el compilador lo hace para estar seguro de que has reconocido que algo malo podría pasar aquí. Recuerda:


Página 128


2012

Cada método debe manejar todas las excepciones comprobadas suministrando un catch catch o o listando mediante throws throws cada cada excepción. Esta regla es requerida en Java. Se la conoce como "manejar o declarar", algunas veces se la llama también "atrapar o declarar". Nuevamente, algunas excepciones están exentas de esta regla. Un objeto de tipo RunTimeException puede ser arrojado desde cualquier método sin que se especifique como parte del método o de la interfaz pública (y no se necesita ningún try try--catch catch). ). Incluso si un método no declara RunTimeException , el método que invoca tampoco tiene obligación de declararlo o manejarlo. RunTimeException , Error Error,, y todos sus subtipos de excepciones no comprobadas y esta clase de excepciones no tienen que ser manejadas. Por ejemplo:

Fíjate en myMethod1() myMethod1().. Ya que EOException es subclase de IOException y este es de Exception Exception,, debe ser declarada como una excepción que pueda arrojar este método. Pero de donde viene la excepción? La interfaz publica para el método myMethod2() myMethod2() invocada invocada aquí, declara que una excepción de este tipo puede ser arrojada. Sin embargo ese método actualmente arroja la excepción por si misma o invoca otro método que la arroja que no es importante para nosotros, lo único que sabemos es que tenemos que atrapar la excepción o declarar que se puede arrojar. El método myMethod1() no atrapa la excepción, así que la declara. Ahora veamos otro ejemplo valido:

De acuerdo con lo comentado, este método puede arrojar un NullPointerException NullPointerException.. Ya que RunTimeException es superclase de NullPointerException NullPointerException,, y esto es una excepción no comprobada, no necesita ser declarada. Podemos ver que myMethod3() myMethod3() no no declara ninguna excepción. Las excepciones en tiempo de ejecución son excepciones no comprobadas. Todas las demás excepciones son comprobadas, y no derivan de java.lang.RuntimeException java.lang.RuntimeException.. Una excepción debe ser atrapada en alguna parte del código. Si invocas un método que arroja una excepción pero no la atrapas, el código no compilara. Eso es porque lo llamamos excepciones comprobadas, el compilador se asegura que son manejadas o declaradas. Hay un gran número de métodos en las librerías de Java 2 que arrojan excepciones, así que a menudo escribirás manejadores de excepciones para hacer frente a estas, generados por métodos que ni tan siquiera escribiste. escri biste.


Página 129


2012

También puedes arrojar excepciones tú mismo, y la excepción también puede ya existir en el API de Java, o uno creada por ti. Para crear tus propias excepciones, simplemente heredas Exception (o una de sus subclases) tal como sigue:

Este código mosqueará al compilador: TestEx.java:6: unreported exception MyException; must be caught or declared to be thrown throw new MyException(); MyException(); ^

Necesitas saber cómo se compara un Error con excepciones comprobadas y sin comprobar. Los objetos de tipo Error no son objetos Exception Exception,, aunque ellos presentan unas condiciones especiales. Exception y Error comparten la misma superclase, Throwable y ambas pueden ser arrojadas usando throws throws.. Cuando un Error o una subclase de Error es lanzada, no se comprueba. No se se le requiere atrapar objetos Error o subtipos. También puedes lanzar errores tú mismo (aunque aparte de una AssertionError no creo que quieras usar otra, quizás un OutOfMemoryError OutOfMemoryError?) ?) y puedes capturarla. Lo siguiente compila perfectamente:

Si estuviéramos lanzando una excepción comprobada en lugar de un Error Error,, entonces el método doStuff() doStuff() necesitaría necesitaría declarar la excepción. Pero recuerda, los errores no son subtipos de Exception Exception,, no necesitan ser declarados. Si quieres decláralos, pero al compilador le dará lo mismo quien o de donde sale un error.


Página 130


2012

12.1.7 Relanzando la misma excepción Igual que puedes lanzar una nueva excepción desde un catch catch,, también puedes arrojar la misma excepción que atrapas. Aquí la cláusula catch catch lo lo hace:

Las demás cláusulas catch asociadas con el mismo try serán ignoradas, si existiese un finally finally,, se ejecutaría y la excepción volvería a ser arrojada desde el método que lo invocó. Si lanzas una excepción comprobada desde un catch catch,, debes también declarar la excepción! En otras palabras, debes manejar y declarar, lo opuesto a declarar o manejar. Lo siguiente es ilegal:

El método doStuff() es quien claramente el que atrapa la excepción IOException IOException,, pero el compilador va a decir, "si, muy bien, veo que atraparas la excepción, pero no es suficiente. Si quieres relanzar la excepción, tendrás que declararla".


Página 131


2012

En este programa se le pasa mediante parámetros la comida, y si no es del agrado, lanzará una excepción.


Página 132


2012

A continuación expongo como lanzar una aplicación con Eclipse adjuntando parámetros:


Página 133


2012

y el ejemplo arroja como resultado: No esta mal tu eleccion. Fin de la ejecucion.

Si ponemos otros manjares, como "piedras palos pelo" el programa arroja: Esa comida no nos gusta! Fin de la ejecucion.

12.1.8 Definición de conceptos, excepción y error Comencemos con la excepciones más comunes, NullPointerException NullPointerException.. Tal como vimos, esta excepción ocurre cuando intentas acceder a un objeto usando una variable de referencia con el valor de null null.. No hay manera de que el compilador tenga la esperanza de encontrar este problema antes de ejecutar el programa (o sea, en tiempo de ejecución). Veamos lo siguiente:


Página 134


2012

Seguramente el compilador encontrara el problema en este programita! No, es cosa tuya. El código compilara perfectamente y la JVM arrojara un NullPointerException cuando intente invocar el método length() length().. Antes discutimos la llamada a la pila. Como recordarás, usamos la convención de que main() main() estaría al final de la pila, y que como main() invoca otro método, y ese método invoca otro, etc... la pila crece. Naturalmente la pila reside en la memoria, e incluso si tu sistema operativo te da un 1GB de RAM para tu programa, la cantidad de memoria aun es finita. Es posible crecer la pila hasta ocupar toda la RAM de tu SO para guardar la pila. Cuando esto pasa, lo que obtienes es un (espera para verlo...), StackOverflowError StackOverflowError.. La manera más común para que esto ocurra es crear un método recursivo. Un método recursivo es aquel que se invoca así mismo en el cuerpo del método. Mientras que eso puede sonar a locura, es una técnica muy extendida para buscar y ordenar algoritmos. Mira este código:

Como puedes ver, si cometes el error de invocar al método go() go(),, el programa caerá en un agujero negro, go() go() invocara invocara a go() go() hasta, no importa cuanta memoria tengas, que consigas un StackOverflowError StackOverflowError.. Nuevamente, solo la JVM sabe cuando esto ocurre, y la JVM será la fuente de este error.

12.1.9 Programando el arrojo de excepciones Fíjate que digo "programando" como queriendo decir: "Creado por una aplicación y/o API por un desarrollador" Por ejemplo, muchas clases en el API de Java tienen métodos que toman cadenas como argumento, y convierten estas cadenas en números primitivos. Un buen ejemplo de estas clases son llamadas clases de envoltorio. Algunos programadores escribieron la clase java.lang.Integer clase java.lang.Integer y crearon métodos como parseInt() y valueOf() valueOf().. El sabio programador decidió que si a uno de estos métodos le pasaba una cadena que no podía ser convertida en número, el método arrojaría un NumberFormatException NumberFormatException.. El código parcialmente implementado se parece a esto:


Página 135

2012


Otros ejemplos de excepciones programadas incluye una AssertionError (vale, no es una excepción, pero se arroja programando), y arroja IllegalArgumentsException IllegalArgumentsException.. El hecho, nuestro mítico desarrollador del API podría usar un IllegalArgumentsException para su parseInt() parseInt(),, pero devuelve NumberFormatException que hereda IllegalArgumentsException IllegalArgumentsException,, y es un poco más preciso, así, en este caso, usando NumberFormatException da soporte a la idea discutida antes: que cuando tienes una excepción en una jerarquía, deberías usar la excepción más precisa que puedas. Naturalmente como vimos antes, puedes hacer tus propias excepciones, y arrojarlas cuando quieras. Estas excepciones caseras también entran en la categoría de excepciones programadas. Excepciones más comunes: Excepción ArrayIndexOutOfBoundsException

ClassCastException

IllegalArgumentException

IllegalStateException

NullPointerException

NumberFormatException

AssertionError ExceptionInInitializerError StackOverflowError

NoClassDefFoundError

Descripción Arrojado cuando se intenta acceder a un array con un valor índex equivocado (negativo o mayor que la longitud del array) Arrojado cuando se intenta castear una variable de referencia de un tipo que no pasa el test ES-UN Arrojado cuando un método recibe un argumento formateado de diferente manera que lo que espera el método. Arrojado cuando el elemento de entorno no es el mismo que la operación que se intenta hacer, por ejemplo un Scanner que ha sido cerrado. Arrojado cuando se intenta acceder a un objeto con una variable de referencia null null.. Arrojado cuando un método que convierte una cadena a un número, recibe una cadena que no puede ser convertida. Arrojado cuando el test booleano devuelve falso. Arrojado cuando se intenta inicializar una variable estática o un bloque. Se arroja cuando un método se recurre profundamente. Cada invocación se añade a la pila. Arrojado cuando la JVM no encuentra la clase que necesita por un error en la línea de comando, un problema de classpath o falta una .class.

Arrojado por JVM

JVM

Programado

Programado

JVM

Programado

JVM JVM JVM

JVM


Página 136


2012

12.2 Mecanismo de aserciones Sabes que no debes hacer suposiciones, pero no puedes evitarlo cuando estas escribiendo código. Lo haces poniéndolos en comentarios:

Escribes estamentos con ellos:

Añadido al lenguaje Java 1.4, las aserciones te permiten comprobar supuestos durante el desarrollo, sin el gasto (tu tiempo) de escribir manejadores de excepciones que asumes que nunca pasaran una vez el programa este desarrollado. Se supone que asumes que un número pasado como parámetro a un método nunca será negativo. Mientras compruebas y limpias de errores el código, quieres validar tu suposición, pero no quieres tener que empezar a escribir excepciones o código evaluando cuando ya has hecho el programa. Pero dejar esto sin comprobar es un riesgo. Aserciones al recate! Mira este código:

Ya que supones que estás en lo cierto, no quieres emplear más tiempo para escribir excepciones. Y en tiempo de ejecución no quieres incluir más if -else porque alcanzar el else significa que tu lógica (lo que fuera que estaba ejecutándose antes de que este método fuera invocado) ha fallado. e m a i l : b r u j u l a t o @ y ah o o . e s

Página 137


2012

Las aserciones te permiten comprobar tus suposiciones durante el desarrollo, pero el código de la aserción básicamente se evapora cuando el programa está finalizado, dejando atrás el código debugger (depurador) y borrándolo. Escribamos un método para evaluar que el argumento no daba negativo:

No sólo el hacer aserciones te permite dejar tu código más legible, ya que las aserciones están inactivas a menos que las actives, entonces, el código de arriba cuando lo compiles, quedaría como:

El funcionamiento de las aserciones es bastante simple. La aserción dará siempre true true,, si no, problema! El código continua ejecutándose. Pero si tu aserción no está desactivada y da falso, entonces una excepción tipo "que se pare el mundo" AssertionError se lanza (algo que jamás podrás manejar) entonces, puedes arreglar la lógica que te condujo a este problema. Las aserciones vienen en dos sabores: realmente simple, y simple, como por ejemplo:

y

La diferencia entre los dos es que la versión simple añade una segunda expresión, separado del primero (expresión booleana) por dos puntos, esta expresión de cadena se añade al Stack trace (es el sistema que cuando salta un error, te muestra el recorrido del error). Ambas versiones arrojan inmediatamente AssertionError AssertionError,, pero la versión simple te da una ayuda para depurar el código, mientras que la otra versión, solo te dice que tu lógica ha fallado.


Página 138


2012

12.2.1 Reglas de expresión de las aserciones Las aserciones pueden tener una o dos expresiones, dependiendo de si usas el modo simple, o el realmente simple. La primera expresión debe dar siempre un valor booleano! Sigue las mismas reglas que para el if . Todo lo que hace una aserción es una evaluación, lo que significa que el resultado sólo puede ser verdadero o falso. Si es verdadero, no hay problema. Sino, entonces tu suposición era errónea y consigues un AssertionError AssertionError.. La segunda expresión, solo se usa con el modo simple, que puede ser cualquier cosa que resulte en un valor. Recuerda, la segunda expresión se usa para generar un mensaje de texto que muestre en el Stack trace algo más de información para depurar el código. Funciona como System.out.println() System.out.println() en en el que puedes pasarle un primitivo o un objeto, y lo convertirá a cadena de texto. Debe devolver un valor! Lo siguiente muestra una lista de expresiones válidas y erróneas para ambas clases de aserciones, recuerda que la expresión 2 se usa sólo con el modo simple, donde la segunda expresión solo te da un poco más de información sobre el detalle de la aserción:


Página 139


2012

12.2.2 Aserciones, identificados o palabra clave Si quieres usar aserciones, tienes que pensar primero como compilar con aserciones tu código, y entonces, pensar como ejecutar el programa con las aserciones activadas. Ambas requieren Java 1.4 o superior, que nos trae el primer punto, como compilar con aserciones en tu código . Identificadores contra palabras claves Antes de la versión 1.4, tendrías que haber escrito:

Fíjate que en el código, aserción se usa como un identificador. Esto ya no es un problema en el 1.4. Pero no puedes usar palabras claves o reservadas como identificadores, empezando con assert assert que que es una palabra clave. El dato de esta cuestión es que puedes usar assert assert como como palabra clave o como un identificador, pero no como ambas.

El uso de javac (Compilador de Java) con assert El compilador de Java usará siempre assert assert como como palabra clave por defecto. A menos que le digas lo contrario, el compilador generará un error si encuentra la palabra assert assert usada usada como identificador. Sin embargo, puedes decirle al compilador que le estas dando una código antiguo y que quisieras que lo compilase a la antigua usanza. Digamos que haces un arreglo a un viejo código del 1.3 que usa assert como identificador. En la línea de comandos podrías escribir:

El compilador mostrara mensajes cuando descubra que la palabra assert se usa como identificador, pero el código compilará y se ejecutara. Supón que le dices al compilador que tu código es de la versión 1.4 o posterior, por ejemplo:

En este caso el compilador mostrará errores cuando descubra que estas usando assert como un identificador. Si quieres decirle al compilador que use las reglas de Java 5 puedes hacer una de estas tres cosas: Omitir la opción -source -source la la cual está por defecto, o añadir una de estas dos opciones a source:

Te das cuenta lo claro que es Sun sobre 1.5 y 5?


Página 140


2012

Si quieres usar aserciones como identificadores en tu código, debes compilar usando -source 1.3.. La siguiente tabla resume como el compilador de Java 5 reacciona a assert como 1.3 identificador o palabra clave:

12.2.3 Ejecución con aserciones Aquí tenemos algo bueno. Una vez que has escrito tu código con aserciones puedes elegir entre activarlas o no en tiempo de ejecución! Recuerda que las aserciones están desactivadas por defecto. Activas las aserciones en tiempo de ejecución usando:

o

Enable significa activar, así que "enable "enableassertions" assertions" es "activar aserciones". En eclipse, los parámetros se introducen en este menú:


Página 141


2012

También tienes que conocer la línea de comandos para desactivar las aserciones:

o

12.2.4 Selector para activar y desactivar los assert La línea de comando para aserciones puede ser usada de diferentes maneras: 





Sin argumentos (como argumentos (como en el ejemplo), que activa o desactiva las aserciones en todas las clases, excepto para las clases del sistema. Con el nombre de un paquete, paquete , de esta manera se especifica el paquete donde quieres que actúe (o no) la aserción. Con el nombre de la clase, clase , al igual que con el nombre del paquete.


Página 142


2012

Puedes combinar los interruptores para decirle que active las aserciones en una clase y que no se activen en las demás, tal como:

Esta línea de comando le dice a la JVM que active las aserciones para todo el programa excepto para la clase en com.geeksanonymous.Foo com.geeksanonymous.Foo.. Puedes seleccionar todo el paquete haciendo:

Esta línea le dice a la JVM que active las aserciones, pero que las desactive en el paquete com.geeksanonymous y todos sus subpaquetes. Puede P uede que el término de subpaquetes no te sea familiar, ya que no hemos hablado de ellos. Un subpaquete es un paquete en un directorio del paquete nombrado. Por ejemplo:

Este árbol lista: com geeksanonymous twelvesteps

y tres clases: com.geeksanonymous.Foo com.geeksanonymous.twelvesteps.StepOne com.geeksanonymous.twelvesteps.StepTwo

El subpaquete de com.geeksanonymous com.geeksanonymous es el paquete twelvesteps twelvesteps.. Recuerda que en Java el com.geeksanonymous.twelvesteps se trata como un paquete distinto y que no tiene relación con los paquetes que hay por encima de el, tan sólo están compartiendo directorio. La siguiente tabla muestra ejemplos para activar o desactivar aserciones en la línea de comandos:


Página 143


2012

12.2.5 El uso apropiado para las aserciones No todos los usos válidos de las aserciones se consideran de uso apropiado. Como ocurre con gran parte de Java, se puede abusar del uso de las aserciones a pesar de los esfuerzos de los ingenieros para disuadir de hacer esto. Por ejemplo, nunca te harán manejar una aserción que falle. Esto quiere decir que no deberías atraparla con catch catch para para intentar manejarla. Legalmente, sin embargo, AssertionError es subclase de Throwable Throwable,, asi que puede ser atrapado. Pero no lo hagas!! Si intentas recuperar algo, debería ser una excepción. Para disuadirte de que sustituyas una aserción de una excepción, el AssertionError no te da acceso al objeto que lo generó. Todo lo que consigues en un mensaje de texto.

No use las aserciones para validar argumentos de un método público Esto es un ejemplo de uso inapropiado:

Un método público puede ser invocado desde código que no controlas (o desde un código que jamás has visto). Ya que los métodos públicos son parte de tu interface al mundo exterior, se supone que tienes que garantizar cualquier anomalía en los argumentos que el método sea forzado a tomar. Pero las aserciones no garantizan que se ejecuten (normalmente se desactivan en las aplicaciones), el código no se ejecutaría si las aserciones están desactivadas. No quieres código accesible que funcione solo condicionalmente, dependiendo de si las aserciones están activadas. Si necesitas validar los argumentos de un método público, probablemente arrojarás excepciones, es decir IllegalArgumentException, IllegalArgumentException, si el valor pasado al método público no es válido.

Usar aserciones para validar argumentos en un método privado Si escribes un método privado, seguramente escribirás algún código que lo ejecute. Cuando asumes que la lógica del código es correcta, puedes evaluar la suposición con una aserción de esta manera:

La única diferencia importante entre en el ejemplo anterior y este, es el modificador de acceso. Así, puedes forzar a cumplir las condiciones en los métodos privados, pero no en los métodos públicos.


Página 144


2012

No uses aserciones para validar una línea de comando tomada como argumento Esto es realmente un caso especial. Si tu programa requiere una línea de comandos de argumentos, necesitarás usar excepciones.

No uses aserciones en métodos públicos para evaluar casos que sabes que nunca podrían suceder. Esto incluye bloque de código que nunca podría ser leído, incluyendo el default de un bloque switch switch como como este:

Si asumes que un código en particular podría no ser ejecutado, como en el ejemplo donde hay una aserción, entonces podrías obtener un falso error porque este código nunca sería ejecutado.

No uses una aserción en expresiones que puedan causar efectos colaterales! Esto podría ser muy mala idea:

la regla es, una aserción dejaría el programa en el mismo estado que estaba antes de la expresión! Piensa en ello. Las aserciones no garantizan que se ejecuten siempre, así que si no quieres que tu código tenga un comportamiento distinto dependiendo de si las aserciones están activadas, las aserciones no deben causar c ausar algún efecto.


Página 145


2012

13.1 La clase String La clave del objeto String String,, es que una vez creado, no puede ser cambiado, así que, que es lo que realmente ocurre cuando un objeto String parece que ha cambiado?

Los objetos String inmutables Empezaremos con un poco de información de trasfondo sobre las cadenas. El manejo de caracteres es un aspecto muy fundamental en la mayoría de los l os lenguajes de programación. En Java, cada carácter en una cadena es un carácter Unicode de 16 bits. Ya que los caracteres Unicode son de 16 bits (no los escasos 7 u 8 bits que ASCII provee), el alfabeto internacional de caracteres se representa como Unicode. En Java, las cadenas son objetos. Al igual que cualquier objeto, puedes instanciar una cadena con new new::

Esta línea de código crea un nuevo objeto de la clase String String,, y le asigna la variable de referencia s. Hasta ahora, los objetos String se parecen a cualquier otro objeto. Ahora asignemos una cadena como valor:

Tal como esperabas la clase String tiene un buen puñado de constructores, así que puedes usar el atajo que más te convenga:

y ya que usarás cadenas todo el tiempo, incluso puedes hacer esto:

Hay algunas diferencias entre estas opciones, que veremos más tarde, pero todas tienen en común que crean un nuevo objeto String String,, con el valor abcdef y se le asigna la variable de referencia s. Ahora digamos que quieres una segunda referencia a un objeto String al que se refiere s:

Todo bien hasta ahora. Los objetos String parece que se comportan de la misma manera que los demás objetos, así que, cual es la pega?... La inmutabilidad! (Y qué diablos es la inmutabilidad?) Una vez que has asignado un valor a String String,, el valor nunca cambia, es inmutable, no cede. (Hablaremos de esto más tarde.) Las buenas noticias es que mientras un objeto String es inmutable, su referencia no, así que continuamos con nuestro anterior ejemplo:


Página 146


2012

Ahora espera un minuto, dijimos que era inmutable? Que es lo que pasa con "añadir un literal al final de la cadena?" Excelente pregunta, veamos veamos que ha pasado realmente... La JVM tomó el valor del objeto s y añadió el literal al final, dándonos el valor "abcdef mas cosas". Ya que las cadenas son inmutables, la VM no puede dar este nuevo valor a la variable de referencia así que lo que hace es reasignar la variable de referencia al nuevo valor. Llegados a este punto hay dos objetos de cadena creados, el antiguo y el nuevo. Técnicamente son tres porque el literal para concatenar es otra cadena nueva. Pero sólo tenemos referencias a "abcdef "abcdef " y "abcdef "abcdef mas cosas" cosas" (referenciado ahora por s). Que pasa sino teníamos previsto crear una segunda variable de referencia para "abcdef" antes de que concatenáramos " mas cosas"? En este caso, la cadena original aun estará en memoria pero se la considera "perdida". Ningún código de nuestro programa tiene alguna manera de referenciarla. Acuérdate de que la cadena original, es inmutable, así que no ha cambiado, lo que si ha cambiado es la referencia de la variable s. Otro ejemplo:

ahora:

otro:

Como ves, el uso del método sobre la referencia no implica que la antigua referencia se pierda, al contrario, si la nueva cadena no es referenciada, es la que se pierde. La discusión que sigue contiene las claves de la inmutabilidad de las cadenas de Java. Cubriremos más detalle de la clase String String,, pero no te equivoques, lo que hemos cubierto está lejos de ser la parte más importante para entender cómo funcionan los objetos String en Java. Terminaremos esta sección representando un ejemplo de pregunta endiablada. Toma tu tiempo para escribir en una hoja el resultado de lo siguiente:


Página 147


2012

Cuál sería la salida? Cuantas variables de referencia hay? Cuantos objetos String fueron creados antes de la salida? Respuesta: El Respuesta: El resultado es "spring "spring winter spring summer". summer ". Hay dos variables de referencia, s1 s1 y y s2 s2.. Había en total ocho objetos creados: "spring " spring", ", "summer "summer"" (se pierde), "spring summer" summer" (se pierde), "spring "spring fall" fall" (se pierde), "spring " spring summer spring" spring " (se pierde), "winter winter"" (se pierde), "spring " spring winter" winter" (spring (spring se se pierde aquí). Solo dos de los ocho objetos String String no no se pierden en este proceso.

13.1.1 String y memoria En esta sección vamos a ver como Java maneja los objetos String en memoria, y algunas de las razones que dan a lugar a este comportamiento. Una de las claves de cualquier buen programador es hacer un eficiente uso de la memoria. Ya que la aplicación crece, es normal que las cadenas literales ocupen grandes cantidades de memoria y a menudo son redundantes en el universo de cadenas literales del programa. Para hacer más eficiente el uso de la memoria, la JVM tiene un área especial de memoria llamada "Piscina "Piscina de constantes de String String". ". Cuando el compilador encuentra un String literal, verifica que en la piscina exista otra idéntica. Si existe, la referencia al nuevo literal es dirigida a la ya existente, no a la nueva creada. Ahora podemos empezar a ver por qué hacer a los objetos String inmutables es una buena idea. Si hay varias variables de referencia apuntando a la misma cadena aun sin saberlo, no sería buena idea cambiar el valor de la cadena. Ahora puedes pensar "Bien eso está bien, pero que pasa si alguien sobrescribe la clase String String,, no podría causar eso un error en la pool?" Esa es una de las principales razones por la que la clase String es marcada como final final,, nadie puede sobrescribir el comportamiento de ninguno de los métodos de String String,, así que puedes estar tranquilo que los objetos inmutables, serán, inmutables. Veamos un par de ejemplos de cómo se puede crear un String String,, y asumamos que no existen más objetos en la pool:


Página 148


2012

En este caso, "abc" ira a la pool y s lo referenciara.

En este caso, ya que usamos new usamos new,, Java creará una nueva cadena en la memoria normal (no en la pool), y s la referenciará. Además, "abc" ira a la pool.

13.1.2 Métodos importantes de la clase String Los siguientes métodos son algunos de los más comunes usados en la clase c lase String String::          

charAt() Devuelve el carácter localizado en el índice especificado. charAt() Devuelve concat() Concatena concat() Concatena una cadena con el final de la otra (lo mismo que "a"+"b"). equalIgnoreCase() Determina equalIgnoreCase() Determina la igualdad de dos cadenas c adenas ignorando las mayúsculas. length() Devuelve length() Devuelve el número de caracteres en una cadena. replace() Reemplaza replace() Reemplaza las concurrencias de un carácter con otro carácter. substring() Devuelve substring() Devuelve una parte de la cadena. c adena. toLowerCase() Devuelve toLowerCase() Devuelve una cadena con los caracteres en minúsculas. toString() Devuelve toString() Devuelve el valor en forma de cadena. toUpperCase() El opuesto a toLowerCase(). trim() Elimina los espacios de una cadena.

Veremos los metodos en detalle.

public char charAt(int index) Este método devuelve el carácter localizado local izado en el índice especificado. Recuerda, el primer índice es el cero.

public String concat(String s) Este método devuelve una cadena con el valor del parámetro añadido al final de la cadena.

Los operadores + y += += funcionan funcionan de forma similar:


Página 149


2012

En el ejemplo "atlantic ocean", tienes que darte cuenta del valor de x, ha cambiado. Recuerda que la operación += += es es de asignación, así que realmente está creando la nueva cadena "Atlantic ocean" y asignándole la variable x, quedando "Atlantic" abandonada.

public boolean equalsIgnoreCase(String s) Este método devuelve un valor booleano ( true o false false)) dependiendo de si el valor de la cadena es igual al del método. Este método devolverá true aunque los caracteres sean capitales. Ejemplo:

public int length() Este método devuelve la longitud de la cadena usada para invocar el método, ejemplo:

public String replace(char old, char new) Este método devuelve una cadena cuyo valor es la cadena invocada en el método actualizando la concurrencia. Donde el primer carácter será reemplazado por el segundo:


Página 150


2012

public String substring(int begin) public String substring(int begin, int end) end) Este método devuelve una parte de la cadena suministrada. El primer argumento representa la localización (la primera letra ocupa el índice cero) de la subcadena. Si la llamada tiene solo un argumento, la subcadena se extraerá hasta el final de la cadena original. Si tiene dos argumentos, la subcadena terminara en el carácter localizado en esa posición. Ejemplo:

public String toLowerCase() Este método devuelve una cadena cuyo valor es la cadena usada para invocar el método, pero con todas las letras mayúsculas convertidas a minúsculas. Por ejemplo:

public String toString() Este método devuelve el valor de la cadena usada para invocar el método. Qué? Para que iba yo a necesitar tal cosa? Un método que no hace nada? Todos los objetos en Java tienen un método toString() toString(),, que devuelve una cadena significativa que describe el objeto en cuestión. En caso de una cadena, que más significativo podría ser que el mismo valor de la cadena? Para más inri, un ejemplo:


Página 151


2012

public String toUpperCase() Este método devuelve una cadena cuyo valor es la cadena usada para invocar al método, pero todos los caracteres en minúsculas los lo s devuelve en mayúsculas. Por ejemplo:

public String trim() Este método devuelve una cadena cuyo valor es la cadena usada para invocar el método, pero los espacios en blanco son eliminados. Ejemplo:

13.2 StringBuffer y StringBuilder Las clases java.lang.StringBuffer clases java.lang.StringBuffer y java.lang.StringBuilder se usan cuando tienes que hacer un montón de modificaciones a una cadena de caracteres. Tal como vimos antes, las cadenas son objetos inmutables, si eliges hacer un montón de manipulaciones con objetos de cadena, terminarás con un montón de objetos perdidos en la pool de String String.. (Incluso en estos días de los gigabytes de RAM, no es buena idea desperdiciar la memoria en objetos descartados). Por otra parte, los objetos del tipo StringBuffer y StringBuilder pueden ser modificado tantas veces como quieras sin dejar por detrás ese rastro de objetos descartados. StringBuffer vs StringBuffer vs StringBuilder La clase StringBuilder fue añadida en Java 5. Tiene el mismo API que StringBuffer StringBuffer,, excepto que StringBuilder no es un hilo seguro. En otras palabras, sus métodos no están sincronizados. Sun recomienda que uses StringBuilder en lugar de StringBuffer cuando sea posible porque StringBuilder se ejecuta más rápido. Así que aparte de la sincronización, cualquier cosa que digamos sobre los métodos de StringBuilder valdrá para StringBuffer y viceversa.


Página 152


2012

El uso de StringBuilder StringBuilder y y StringBuffer StringBuffer Hemos visto que en el examen se te va a evaluar la compresión sobre la inmutabilidad de String en fragmentos como este:

Conseguimos una nueva cadena, pero en trasfondo, la cadena "abc" ha quedado perdida en la pool de String String,, malgastando memoria. Si hubiera usado un StringBuffer en lugar de String String,, seria:

Todos los métodos de StringBuffer que discutiremos discutiremos operan sobre sobre el valor de StringBuffer StringBuffer invocado invocado del método. Así que una llamada a sb.append("def"); está añadiendo "def" a si mismo. En efecto, estos métodos pueden ser encadenados unos con otros:

Date cuenta que en los dos ejemplos anteriores, había solo una llamada a new new,, y en cada ejemplo no se han creado objetos o bjetos extras. Cada ejemplo necesitaba solo una línea StringXxx para ejecutarse.

13.2.1 Métodos importantes de las clases StringBuffer StringBuffer y y StringBuilder StringBuilder Los siguientes métodos devuelven un objeto StringXxx con el valor del argumento añadido al valor del objeto que invoca el método.


Página 153


2012

public synchronized StringBuffer append(String s) Como vimos antes, este método actualizará el valor del objeto que invocó el método, dependiendo de si se le asigna una variable al retorno. Este método toma muchos argumentos, incluyendo boolean boolean,, char char,, float float,, int int,, long y otros.

public StringBuilder delete(int start, int int end) Este método devuelve un objeto StringBuilder y actualiza el valor del objeto StringBuilder que invocó la llamada al método. En ambos casos, se elimina una subcadena del objeto original. El índice inicial (el primero es el cero) se define en el primer argumento y el índice final (el primero tiene que ser al menos el 1!) es definido en el segundo argumento. Estudia detenidamente este ejemplo:

public StringBuilder insert(int offset, String String s) Este método devuelve un objeto StringBuilder y actualiza el valor del objeto que invocó la llamada del método. En ambos casos, la cadena pasada en el segundo argumento se inserta dentro del original StringBuilder comenzando en la localización offset representado en el primer argumento (el primero es el cero). También, como segundo argumento puede tomar cualquier tipo de dato, boolean boolean,, char char,, double double,, float float,, int int,, long long...etc... ...etc... pero es el tipo cadena lo que más vas a ver:


Página 154


2012

public synchronized StringBuffer reverse() Este método devuelve un objeto StringBuffer y actualiza el valor del objeto que invocó la llamada del método. En ambos casos, la cadena en StringBuffer es invertida, el primer carácter se convierte en el último:

public String toString() Este método devuelve el valor del objeto StringBuffer que invoco al método como una cadena:

Esto es todo para StringBuffer y StringBuilder StringBuilder.. Recuerda que al contrario de los objetos String String,, StringBuffer y StringBuilder si mutan.


Página 155


2012

14.1 Resumen de las clases I/O













File Este API dice que la clase File es una representación abstracta de un fichero y el nombre de su ruta. La clase File no se usa para leer o escribir datos, se usa para trabajar a alto nivel, creando ficheros vacíos, buscando ficheros, borrando, creando directorios y trabajando con rutas. FileReader Esta clase se usa para leer caracteres de un fichero. El método read() es de bajo nivel, y te permite leer un solo carácter, de toda la cadena de caracteres, o un número fijo de caracteres. Los FileReader se usan para envolver objetos de alto nivel, como BufferedReader BufferedReader,, que dan más rendimiento y proveen de formas más convenientes para trabajar con datos. BufferedReader Esta clase se usa para crear clases Reader de bajo nivel como FileReader FileReader,, más eficientes y fáciles de usar. Comparado a los FileReader FileReader,, BufferedReader es capaz de leer grandes cantidades de datos de una sola vez y ocuparlos en un buffer. Cuando te preguntes por el siguiente carácter o línea de datos, se toma desde el buffer, que minimiza el número de veces de operaciones de lectura. Además, BufferedReader te provee de más eficientes métodos tales como readLine() readLine(),, que te permiten leer la siguiente línea de caracteres de un fichero. FileWritter Esta clase se usa para escribir caracteres a un fichero. Su método write() te permite escribir caracteres o cadenas a un fichero. Los FileWriter son, normalmente, envoltorios para objetos de alto nivel de tipo Writer Writer,, tales como BufferedWriter o PrintWriter PrintWriter,, que proveen de mejor rendimiento y son de alto nivel, con método más flexibles para escribir datos. BufferedWriter Esta clase se usa para crear clases de bajo nivel como FileWriter FileWriter,, mas eficiente y fácil de usar. Comparado a FileWriter FileWriter,, BufferedWriter escriben grandes cantidades de datos en un fichero de una sola vez, minimizando el número de veces, que retrasa, las operaciones de escritura. Además, la clase BufferedWriter provee del método newLine() que hace más fácil crear plataformas específicas que separan las líneas automáticamente. PrintWriter Esta clase ha sido mejorada significativamente en Java 5. Ya que los nuevos método y constructores creados (como PrintWriter con File o String String), ), puedes encontrar que puedes usar PrintWriter en sitios donde antes necesitarías un Writer envuelto con FileWriter y/o un BufferedWriter BufferedWriter.. Nuevos método como format() format(),, printf() y append() hacen de PrintWriter una clase muy flexible y poderosa.


Página 156


2012

14.2 Creando ficheros, el uso de la clase File Los objetos del tipo File se usan para representar el fichero actual (pero no los datos que contiene) o directorios que existen en el disco físico de la computadora. Comencemos con unos pocos ejemplos de creación de ficheros, escribirlos y leerlos. Primero, crearemos un fichero y escribiremos unas líneas en el:

Si ejecutas este programa, cuando mires el contenido de tu directorio actual, descubrirás que no hay absolutamente ninguna indicación de algún fichero llamado fileWrite1.txt llamado fileWrite1.txt.. Cuando creas una instancia de File File,, no estas creando el fichero, sólo el nombre. Una vez que tengas el objeto File File,, hay varias maneras para crear el fichero. Veamos lo que puede hacerse con el objeto File File::

Esto da como salida: false true true

Y también produce un fichero vacío en tu directorio. Si ejecutas el código una segunda vez, se mostrará: true false true


Página 157


2012

Examinemos las ejecuciones: 

Primera ejecución: La primera llamada a exists() devuelve false false,, lo que esperábamos, recuerda, que new File() no crea un fichero en el disco! El método createNewFile() File() createNewFile() crea el fichero, y devuelve true true,, indicando que ha sido creado un nuevo fichero, y que no existía antes. Finalmente, llamamos a exists() otra vez, y esta vez devuelve true true,, indicando que el fichero ya existe en el disco.



Segunda ejecución:

La primera llamada a exists() devuelve true true porque porque nosotros hemos creado el fichero en la primera ejecución. Luego la llamada a createNewFile() devuelve false false ya ya que el método no creó el fichero esta vez. Naturalmente la última llamada a exists() exists() devuelve devuelve true true.. Un par de cosas nuevas han pasado en este código. Lo primero, fíjate que tuvimos que poner nuestro fichero en un try-catch try-catch.. Esto es así para todos los códigos I/O que escribes. I/O es una de esas clases con riesgos inherentes. Seamos simples por ahora, e ignoremos las excepciones, pero aun necesitaremos seguir manejando o declarando la regla para la mayoría de los método I/O que declaren excepciones marcadas. Hablaremos más sobre I/O. Usamos un par de método de la clase File en este código:  

boolean exists() exists(),, este método devuelve true si puede encontrar el fichero. boolean createNewFile() createNewFile(),, este método crea un nuevo fichero si no existe aún.

14.3 El uso de FileWriter y FileReader En la práctica, lo más probable es que no uses FileWriter y FileReader sin envoltorio (en breve se explica mas). Como dije antes, vayamos y hagamos un pequeño fichero I/O:


Página 158


2012

lo que produce la salida: 12 howdy folks

Lo que ha pasado: 

FileWriter fw = new FileWriter(file) hizo FileWriter(file) hizo estas tres cosas: 1. Se creó una variable de referencia fw de tipo FileWriter FileWriter.. 2. Se creó un objeto FileWriter y se asignó a fw. 3. Se creó un fichero vacío en el disco (puedes comprobarlo).



Escribimos 12 caracteres en el fichero con write() write(),, y luego hizimos flush() y close() close()..



Hicimos un objeto FileReader FileReader,, que abrió el fichero para lectura.



El metodo read() leyó todo el fichero, un carácter cada vez, y ponerlo dentro de char[] char[]..



Imprimimos el número de caracteres leídos, e hicimos un bucle en el array para imprimir cada carácter, luego, cerramos el fichero.

Antes de seguir, hablemos sobre flush() y close(). close(). Cuando escribes un dato en una cadena, pueden ocurrir un montón de cosas en el búfer, y nunca sabrás exactamente cuándo se envió el último dato. Podrías ejecutar muchas operaciones de escritura en una cadena antes de cerrarla. Al invocar el método flush() antes de cerrar el fichero, te garantiza que el último dato se ha escrito en el fichero.


Página 159


2012

No importa cómo estés usando un fichero. Para lectura o escritura, tienes que invocar el método close() close().. Cuando estés trabajando con ficheros I/O, estás usando una gran cantidad de recursos del sistema, así que cerrar el fichero liberará las tareas del sistema. Por mi cuenta he practicado un poco lo dicho dic ho aquí, porque no soy persona de estudiar de memoria, sino de comprender y asociar, y sin estudiar, continuar el temario es como leer y tener la cabeza ocupada en coches y motos, terminas el libro y no te has enterado de nada, así que allá voy. Para empezar, acabo de acordarme, que sino inicializas el array, arroja un NullPointerException NullPointerException.. Pensaba que se inicializaría como lo hace PHP , automáticamente dependiendo de la entrada. Pues no. Confirmado. Luego, ¿qué ocurre si declaras un array de 50 bytes y solo ocupas una parte? Bien, este fue el código que hice:

y este fue el resultado:

Podrías haber querido experimentar y darte cuenta que al usar read() sin variable, el código no lanza error, pero, sin una variable que haga referencia al contenido leído, como lograrías tener acceso a esta información, donde está, quien lo sabe?


Página 160


2012

Ahora, volviendo a nuestro último ejemplo del manual. Este programa en realidad, funciona, pero hay un par de cosas dolorosas: 1. Cuando estés escribiendo datos a un fichero, insertamos manualmente los operadores de salto de carro (en nuestro caso \n \n). ). 2. Cuando leemos los datos, los ponemos en un array. Al estar en un array, tuvimos que declarar su tamaño por adelantado, así que tendríamos un problema si no supiéramos el tamaño. Podimos leer los datos de carácter en carácter, buscando el final después de cada read() read(),, pero es bastante doloroso también. Por estas limitaciones, nosotros usamos clases de más alto nivel, como BufferedWriter o BufferedReader en combinación con FileWriter o FileReader FileReader..

14.4 Combinando clases I/O, BufferedWriter y BufferedReader Todo el sistema I/O de Java fue diseñado con la idea de usar varias clases en combinación. Combinar las clases I/O se le llama envolviendo clases y otras veces, encadenando clases. El paquete I/O de Java tiene más o menos 50 clases,10 interfaces, y 10 excepciones. Cada clase en el paquete tiene un propósito específico (creando una alta cohesión) y están diseñadas para ser combinadas unas con otras de incontables maneras para manejar una amplia variedad de situaciones. Cuando llega la hora de hacer algo con I/O en la vida real, sin duda te encontrarás con la duda de que API usar o que clases vas a necesitar y como ponerlas juntas.


Página 161


2012

Ahora, digamos que queremos encontrar una manera menos dolorosa de escribir datos en el fichero y leer el contenido del fichero a la memoria. Empezando por la tarea de escribir datos en un fichero, hay un proceso para determinar que clase necesitaremos, y como juntarlas: 1. Ya sabemos que vamos a usar un objeto File File.. Así que si usamos una u otra clase, una de ellas tiene que llevar un constructor que tome un objeto de tipo File File.. 2. Encontrar un método que suene como el más poderoso, el más fácil de usar para hacer la tarea. Cuando miramos la tabla, podemos ver que BufferedWriter tiene el método newLine() newLine().. Suena algo mejor que tener que hacer un separador a mano en cada línea, pero más abajo vemos que PrintWriter tiene un método llamado println() println().. Parece que esto es lo que más se aproxima de todo lo que tenemos. Vamos con el. 3. Cuando miramos los constructores de PrintWriter PrintWriter,, vemos que puede construir un objeto PrintWriter si tenemos un objeto de tipo File File,, así que todo lo que necesitamos hacer es crear un objeto PrintWriter PrintWriter,, tal como se muestra:

Hora de un poco de historia. Antes de Java 5, PrintWriter no tenía constructores que tomaran String o File File.. Si estuvieras escribiendo algo de I/O en Java 1.4, como harías para conseguir que PrintWriter escribiera datos en File File?? Puedes imaginártelo estudiando la tabla. Aquí hay una manera de resolver este puzle. Primero, sabemos que crearemos un objeto File al final, y que queremos un objeto PrintWriter PrintWriter.. Podemos ver en la tabla que PrintWriter puede también construirse usando un objeto Writer Writer.. Aunque Writer no es una clase tal como vemos en la tabla, vemos que varias clases heredan Writer Writer,, lo que se supone como bueno, cualquier clase que herede Writer es un buen candidato. Mirando más adelante, vemos que FileWriter tiene dos atributos que estamos buscando: 1. En el constructor se usa un File 2. Hereda Writer Dada esta información, podemos poner junto el siguiente código (recuerda que es un ejemplo de Java 4):

Hasta aquí se ve que es fácil encadenar las clases para leer los datos del fichero a la memoria. Nuevamente, vemos que en la tabla, vemos una tabla que se llama readLine() readLine() que que suena mucho mejor para leer datos. Podemos hacer el mismo proceso con el siguiente código:


Página 162


2012

14.5 Ficheros y directorios Antes vimos que la clase File se usa para crear ficheros y directorios. Además, los método de File pueden ser usados para borrar ficheros, renombrar ficheros y determinar si un fichero existe, crear ficheros temporales, cambiar los atributos de un fichero y hacer diferencias entre fichero y directorio. Un punto en el que a menudo se confunde es que un objeto de tipo File se usa para representar un fichero o un directorio. Hablaremos de ambos en breve. Como vimos antes, el estamento:

siempre va a crear un objeto File, y luego pueden pasar una de estas cosas: 1. Si "foo" no existe, no se crea ningun fichero. 2. Si "foo" existe, el nuevo objeto File Fi le apuntara al fichero existente. Hay que fijarse que File file = new File("foo"); NUNCA crea NUNCA crea un fichero. Hay dos maneras de crear un fichero: 



Invocar al método createNewFile() createNewFile(),, por ejemplo:

Crear un objeto Stream Stream,, Reader o Writer Writer.. Concretamente, un FileReader FileReader,, un FileWriter FileWriter,, un PrintWriter PrintWriter,, un FileInputStream o un FileOutputStream FileOutputStream.. Si creas una instancia de alguna de estas clases, estas creando un fichero, a menos que ya exista, por ejemplo:


Página 163


2012

Crear un directorio es similar a crear un fichero. Al igual que un fichero, crear un directorio es un proceso de dos pasos, primero creamos el directorio (usando File File), ), luego creamos un directorio usando el método mkdir() mkdir()..

Una vez que tienes el directorio, pones ficheros dentro, y trabajas con esos ficheros:

Este código crea un fichero en el directorio. Ya que le suministras el directorio al constructor, lo que queda es el objeto File File.. En este caso existe una manera de escribir datos a myFile myFile::

Ten cuidado al crear nuevos directorios! Tal como hemos visto, un Reader o un Writer crearán tu fichero automáticamente si no existe, pero no es el caso de un directorio:

Esto generará una excepción: java.io.IOException: No such file or directory

Puedes referirte a un objeto File existente, ya sea fichero o directorio. Por ejemplo, asumamos que ya tenemos un subdirectorio llamado existingDir existingDir en en la cual existe existingDirFile.txt existingDirFile.txt,, que contiene varias líneas de texto. Cuando ejecutas este código:


Página 164


2012

generará la siguiente salida: true true existing sub-dir data line 2 of text line 3 of text

Presta especial atención a lo que devuelve el método readLine() readLine().. Cuando no hay más líneas, el método devuelve null null,, que es nuestra señal para parar la lectura del fichero. También, no se ha invocado el método flush() flush().. Cuando se lee un fichero, no se requiere, así que no vas a encontrar un flush() en una clase de lectura (Reader ( Reader). ). Además de crear ficheros, la clase File te permite renombrar y borrar ficheros. El siguiente código muestra una de las cosas más comunes como el borrar y renombrar archivos:

da como salida:

delDir is false y te deja un directorio llamado newDir newDir que que contiene un fichero llamado newName.txt newName.txt.. Aquí hay algunas reglas que podemos deducir del resultado:  

delete() Puedes borrar un directorio si está vacío. delete() Puedes renameTo() Le renameTo() Le tienes que pasar un objeto File válido con el nuevo nombre que quieres (Si newName ha sido null null,, podría dar un NPE). También puedes cambiar el nombre de un directorio, aunque no esté vacío.

Hay un montón más para aprender en el paquete IO de Java, pero nos vamos a detener en una cosa más, y es como buscar un fichero. Se asume que tenemos un directorio llamado searchThis searchThis que que queremos buscar, el código usa File.list() para crear un array de tipo String de ficheros y directorios, luego usaremos el for mejorado para recorrer el array e imprimir:


Página 165


2012

Y conseguimos la siguiente salida: found found found found found

dir1 dir2 dir3 file1.txt file2.txt

En esta sección hemos arañado la superficie de lo que hay disponible en el paquete IO de Java. Se podría escribir un libro entero hablando de este paquete, así que obviamente hemos cubierto una muy pequeña parte (pero ( pero usada frecuentemente) del API.


Página 166


2012

15 Paquete I/O, la serialización Imagina que quieres guardar el estado de uno o más objetos. Si Java no tuviese serialización (como vimos, en la 1.4 no lo tiene), tendrías que usar una de las clases I/O para escribir el estado de las variables de instancia de todos los objetos que quieres guardar. La peor parte podría ser la reconstrucción de los objetos que fueron virtualmente creados, idénticos a los que intentas guardar. Necesitarías tu propio protocolo para crear la manera en la que habría que escribir y recuperar el estado de cada objeto, o terminarías inicializando las variables con valores equivocados. Por ejemplo, imagina que guardaste un objeto que tiene variables de instancia para la altura y el peso. A la vez que grabas el estado del objeto, podrías escribir la altura y el peso como dos int en un fichero, pero el orden es crucial. Sería demasiado fácil recrear el objeto sin equivocar la posición de los valores. La serialización te permite decir " graba este objeto y todas sus variables de instancia ". Es un poco más interesante que eso, porque puedes añadir,... a menos que hayas marcado variables explícitamente como transient transient,, lo que da a entender que no se incluirá el valor de esa variable como parte del estado del objeto serializado.

15.1 ObjectOutputStream y ObjectInputStream La magia de la serialización consiste en sólo dos métodos: uno para serializar objetos y escribirlos es un stream stream,, y el otro para leer el stream y deserializar el objeto.

Estas clases son consideradas de alto nivel, y como vimos antes, significa que tendrás que envolverlas en clases de bajo nivel, al igual que las clases java.io.FileOutputStream y java.io.FileInputStream java.io.FileInputStream.. Aquí se muestra un pequeño pequeño programa que crea un gato (Cat) que lo serializa, y deserializa.


Página 167

2012

Curso gratuito de Java en emuladores L2 Java Examinemos los puntos claves de este ejemplo: 







Declaramos que la clase Cat Cat implementa la interfaz Serializable Serializable.. Serializable es una interfaz marcada, no tiene métodos que implementar (En las siguientes secciones cubriremos las reglas que hablan sobre declarar clases Serializable Serializable). ). Creamos

un

nuevo

objeto

Cat ,

que

ya

sabemos

que

es

serializable.

Serializamos el objeto Cat c invocando el método writeObject() writeObject().. Esto tomó cierto trabajo antes de que serializáramos nuestro Cat . Primero, tuvimos que poner todo el código entre try try--catch catch.. Luego habíamos creado un objeto para escribir FileOutputStream.. FileOutputStream Después envolvimos el FileOutputStream en un ObjectOutputStream,, que es la clase que tiene el método mágico de serialización que ObjectOutputStream necesitamos. Recuerda que la invocación de writeObject() tiene dos tareas, serializa el objeto y luego lo escribe en un fichero. Luego deserializamos el objeto invocando readObject() readObject().. El método devuelve un objeto, así que tenemos que castearlo para volverlo Cat . De nuevo, tuvimos que hacer las acciones típicas que requiere el I/O cuando I/O cuando trabajamos con el.

Este ejemplo de serialización ha sido a palo seco. Luego veremos casos más complejos asociados a la serialización. Por cuenta propia quería saber si era posible guardar más de un objeto a la vez, intente hacer un array para guardar todos los objetos del mismo tipo pero no me salió. Sin embargo, este ejercicio me sirvió para saber también, que puedes guardar más de un objeto a la vez y recuperarlos usando la operación inversa. Es decir, guardo dos objetos Gato, y los leo de una sola vez, asignándole una variable de referencia a cada Gato guardado.

Miremos el ejercicio:


Página 168


2012

La otra clase:


Página 169


2012

Interesante, no es cierto? El resultado, por supuesto es correcto: Gatos guardados :) Recuperando los gatos... Tenemos a Miguel y a Juan, gatos Blanco y Marron respectivamente.


Página 170


2012

15.2 Objetos gráficos Que quiere decir realmente guardar un objeto? Si las variables de instancia son todas de tipo primitivo, es bastante directo. Pero qué pasa si las variables de instancia son en si mismas referencias a objetos? Que estamos grabando? Claramente, en Java no tendría sentido grabar los valores actuales de la variable de referencia porque el valor de la referencia tiene solo el contexto de la instancia de la JVM. En otras palabras, intentarías recuperar el objeto en otra instancia de la JVM, que aunque este corriendo en la misma maquina donde el objeto fue serializado, la referencia seria inútil. Que le ocurre al objeto de la variable de referencia referencia que tiene asignada? Miremos esta clase:

Ahora crearemos un perro con un collar, primero, el collar del perro con un tamaño:

luego el perro, y le pasamos un collar y la talla de para el perro:

Ahora que pasa si guardas al perro? Si la finalidad es grabar y recuperar un perro, y el perro recuperado es una duplica exacta del perro que fue guardado, entonces el perro necesita un collar que sea idéntico. Esto significa que el collar del perro debería haberse guardado también. Y qué ocurre si el collar en si mismo también hace referencia a otro objeto? Como el color? Esto se complica rápidamente. Si dependiera del programador saber cómo está estructurado cada objeto que se está refiriendo al perro, tendría que guardar el estado de todos los objetos... que faena. Podría ser una pesadilla con el más simple de los objetos.


Página 171


2012

Afortunadamente, el mecanismo de serialización de Java toma esto en cuenta. Cuando serializas un objeto, la serialización toma el objeto completo de forma gráfica. Esto significa que hace una copia muy profunda de todos los objetos que son necesarios recuperar. Por ejemplo, si serializas un perro, el collar será serializado automáticamente. Y si el collar hiciera referencia a otro objeto, seria serializado también, y así hasta finalizar, siempre que no olvides añadir la interfaz serializable a las demás clases que incluyas en Dog. Dog. Y el único objeto del que tienes que preocuparte es de guardar y leer al perro. Los otros objetos requeridos para reconstruir al perro son guardados y recuperados automáticamente a través de la serialización. Recuerda que tienes que ser consciente de crear objetos serializable implementando la interfaz Serializable Serializable.. Si queremos guardar al perro, tendremos que modificar la clase como sigue:

Si ahora guardamos al perro con el siguiente código:

Cuando ejecutamos el código, tenemos una excepción como esta: java.io.NotSerializableException: Collar

De que nos hemos olvidado? La clase collar tiene tiene que ser Serializable Serializable también, también, si modificamos la clase collar y la hacemos serializable serializable,, no habrá problema:


Página 172


2012

Aquí está la lista completa:

Lo que produce: before: collar coll ar size is 3 after: collar size is 3

Y que pasaría si no tuviéramos acceso al código fuente del collar? En otras palabras, que pasa si hacer el collar serializable no es una opción? Obviamente podríamos crear una subclase collar serializable y luego usar la subclase en lugar del collar. Pero eso no es siempre una opción por varias razones poderosas: 1. El collar podría ser una clase final 2. El collar podría referirse a otro objeto no serializable, y sin conocer la estructura interna, no podrías hacer los arreglos necesarios. 3. Hacer subclases no es una opción por razones de diseño. Así que, qué pasa si queremos guardar al perro? Aquí es donde viene el modificador transient transient.. Si marcas la variable de instancia con transient transient,, la serialización saltara el collar. e m a i l : b r u j u l a t o @ y ah o o . e s

Página 173


2012

Ahora tenemos un perro serializable, con un collar no serializable, pero el perro tiene el collar como transient transient,, la salida es: before: collar size is 3 Exception in thread "main" java.lang.NullPointerException

Y ahora qué hacemos??

15.3 El uso de writeObject y readObject Considera el problema, tenemos un perro que queremos grabar. El perro tiene un collar y el collar debería de ser grabado como parte del perro, pero este collar no es serializable, así que tuvimos que marcarlo como transient transient.. Esto significa que cuando el perro se deserialice, el collar viene null null.. Que podemos hacer para asegurarnos de que cuando el perro se deserialice, tenga un collar que encaje con el mismo collar que tenía el perro cuando fue grabado? Java tiene un mecanismo especial para este caso, un serie de métodos privados que puedes implementar en tu clase que, si están presentes, serán invocados automáticamente durante la serialización y la serialización. Es casi como si los métodos fueran definidos en la interfaz Serializable Serializable,, solo que no lo están. Forman parte de un contrato con el sistema de serialización que básicamente dice "Si tu (el programador) tienes un par de métodos que encajen con esta firma exacta (lo veremos en un momento) estos métodos serán invocados durante la serialización y la serialización". Estos métodos te permiten un paso intermedio en la serialización y la serialización. Son perfectos para el problema del collar del perro. Cuando el perro está siendo grabado, puedes entrar a mitad del proceso y decir "de cualquier manera, me gustaría añadir el estado del collar (un int int)) al stream stream cuando cuando el perro sea serializado". Manualmente has añadido el estado del collar del perro aunque el collar como tal, no se ha grabado. Naturalmente necesitaras recuperar el collar durante la deserialización accediendo en ese paso intermedio y diciendo "Leeré un int extra que guardé en el stream del perro, y lo usaré para crear un collar nuevo, y luego asignare el nuevo collar al perro que está siendo deserializado". Los dos métodos especiales que defines deben ser firmas que son exactamente como esta:


Página 174


2012

Si, vamos a escribir métodos que tienen el mismo nombre como los del ejemplo. Donde se colocan estos métodos? Hagamos un cambio en la clase Dog (perro): Dog (perro):

Echemos un vistazo al código. En nuestro escenario hemos concretado que, por alguna razón real, no podíamos serializar el collar pero, queríamos serializar el perro (Dog ( Dog). ). Para hacer esto, vamos a implementar dos métodos, writeObject() writeObject() y y readObject() readObject().. Al implementar estos métodos, le estas diciendo al compilador "Si alguien invoca writeObject() writeObject() o o readObject() para el objeto Dog, Dog, este código tiene que ser parte de la lectura y la escritura". 1. Como la mayoría de métodos I/O, I/O, writeObject() puede arrojar excepciones. Tienes que declararlas o manejarlas, aunque recomendamos que las manejes. 2. Cuando invocas defaultWriteObject() desde el método writeObject() writeObject(),, le estas diciendo a la JVM que haga una serialización normal para este objeto. Cuando implementas writeObject() writeObject(),, normalmente estas pidiendo un proceso de serialización normal, y además algunos procesos personalizados de escritura y lectura. 3. En este caso hemos decidido escribir un extra int int (el (el tamaño del collar) al stream que se está creando para serializar al perro. Puedes escribir tu código extra antes y/o


Página 175


2012

después de invocar defaultWriteObject() defaultWriteObject().. Pero... cuando lo lees para recuperarlo, tienes que leerlo en el mismo orden que lo grabaste. 4. De nuevo, elegimos manejar y declarar más excepciones. 5. Cuando toca deserializar, defaultReadObject() maneja la deserialización normal que conseguirías sino implementases readObject() readObject().. 6. Finalmente construimos un collar nuevo para el perro usando la talla que habíamos serializado manualmente. (Tuvimos que invocar readInt() después de defaultReadObject() defaultReadObject(),, si no, los datos del stream saldrían desincronizados!) Recuerda, la mayoría de las razones para implementar writeObject() y readObject() son cuando tienes que grabar alguna parte de un objeto de forma manual. Si lo haces, cuando quieras hacer solo una parte de la serialización/deserialización tú mismo, tienes que invocar defaultReadObject() y defaultWriteObject(). Lo que trae otra pregunta, por qué no se pueden serializar todas las clases de Java? Por qué no es Object serializable? Hay muchas cosas en Java que no pueden ser serializadas porque están en un entorno de ejecución específico. Cosas como streams, threads, runtime, etc. y algunas clases GUI (las cuales están conectadas al sistema operativo) no pueden serializarse. Lo que es y no es serializable en Java no tienes que dominarlo, pero necesitarás tenerlo en cuenta si quieres serializar objetos complejos.

15.4 La herencia y la serialización La serialización es algo sensacional, pero para aplicarla efectivamente tienes que entender como la superclase afecta a la serialización. Esto nos trae otro tema clave c lave con la serialización... qué pasa si una superclase no está marcada como Serializable pero su subclase lo está? Puede P uede la subclase ser serializada aunque su superclase no lo sea? Imagínate lo siguiente:

Ahora tú tienes la clase perro serializable, con una superclase no serializable. Esto funciona! Pero hay importantes implicaciones. Para entender estas implicaciones, miremos la diferencias entre un objeto que viene de una serialización, y otro que se ha creado con new new.. Recuerda, cuando un objeto se construye con new new (lo (lo opuesto a uno de una serialización), ocurren estos hechos en este orden: 1. Todas las variables de instancia son iniciadas con el valor por defecto. 2. El constructor es invocado, lo cual implica implic a que se invoca el constructor de la superclase (u otro constructor sobrecargado, hasta que se invoque el constructor de la superclase.) 3. Todos los constructores de la superclase se completan.


Página 176


2012

4. Las variables de instancia inicializadas como parte de su declaración se les asigna su valor inicial (lo contrario a los valores por defecto, son valores dados a priori por los constructores de la superclase.) 5. El constructor finaliza. Pero nada de esto ocurre en un objeto deserializado. Cuando una instancia de una clase serializada se deserializa, el constructor no se ejecuta, y las variables de instancia no se les asigna ningún valor inicial! Piensa en ello, si el constructor fuese invocado, o las variables de instancia se le asignasen los valores iniciales, el objeto que intentas recuperar en el estado que lo grabaste, volvería totalmente alterado. Por ejemplo, imagina que tienes una clase que declara una variable de instancia y le asigna el valor int 3, y le incluyes un método que le cambia el valor a 10:

Obviamente, si serializas Foo después Foo después de que el método changeNum() se changeNum() se ejecute, el valor de la variable nim nim seria 10. Cuando la instancia Foo Foo se deserializa, tú quieres que la variable mantenga su valor de 10! Obviamente no quieres que se inicialice (en este caso, con el 3). Piensa en el constructor y la asignación a la variable de instancia como una parte completada de la inicialización del objeto (y el hecho, es que ellos hacen la inicialización en el bytecode). El punto es, que cuando un objeto se deserializa no queremos que se ejecute la inicialización. No queremos que el constructor se ejecute, y no queremos explícitamente valores declarados. Sólo queremos los valores con los que fue grabado. Naturalmente si tienes variables marcadas como transient transient,, no serán recuperadas con su valor original (a menos que implementes defaultReadObject() defaultReadObject()), ), pero en su lugar, se le darán los valores por defecto para el tipo de dato. En otras palabras, aunque digas:

cuando la instancia de Bar se deserialice, la variable x tendrá el valor cero. Los objetos de referencia marcados como transient siempre se resetearan a null null,, no importa si fueron inicializados en tiempo de declaración de la clase. Así, que esto es lo que ocurre cuando el objeto se deserializa, y la clase serializada directamente hereda Object Object,, o tiene solo clases serializables en su árbol de herencia. Tiene algo de trampa cuando la clase serializable tiene una o más clases no serializables en su superclase. Volviendo a nuestra clase Animal clase Animal con con un Dog serializable: Dog serializable:


Página 177


2012

Ya que Animal no no es serializable, cualquier estado mantenido en Animal , incluso la variable que se hereda en Dog, Dog, no va a ser recuperada cuando se deserialice! La razón es, que la clase Animal (no serializable) que es parte de Dog Dog va a ser reiniciada igual que si estuvieras haciendo un nuevo Dog. Dog. En otras palabras, las variables de instancia de Dog serán Dog serán serializadas y deserializadas correctamente, pero las variables heredadas de Animal de Animal serán serán iniciadas con sus valores por defecto. Si tienes una clase serializable pero tu superclase no lo es, entonces cualquier variable de instancia que heredes de la superclase reseteara sus valores a los suyos por defecto. Esto es porque el constructor de la superclase se ejecutará! De hecho, cada constructor encima de la clase no serializable también se ejecutará, no importa, porque una vez que el primer superconstructor sea invocado, su curso invocará sus superconstructores hasta el principio del árbol de herencia. Necesitarás también reconocer que variables serán recuperadas y cuáles no, así que asegúrate de estudiar el siguiente ejemplo y la salida:


Página 178


2012

Da como resultado: before: Fido 35 after: Fido 42

La clave aquí es Animal es Animal , que no es serializable, cuando el Dog fue Dog fue deserializado, el constructor de Animal de Animal se se ejecutó y reseteo la variable weight weight..

15.5 Serialización y clases estáticas Finalmente, te has podido dar cuenta que hemos hablado solo de variables de instancia, no de variables estáticas. Las variables estáticas deberían ser grabadas aparte del estado del objeto? No es importante que la variable estática sea serializada con el objeto? Si y no. Puede ser importante pero no es una parte del estado de la instancia. Recuerda, que debes pensar que las variables estáticas son puramente variables de clase. Ellas no tienen nada que ver con las instancias individuales. Pero la serialización se aplica solo a los objetos. Y que sucede si deserializa tres instancias distintas de Dog, Dog, que fueron serializados a distinta vez, y que todos fueron grabados con una variable estática en la clase con un valor distinto? Que instancia debería prevalecer? Qué valor estático debería ser usado para reemplazar el actual en cada clase Dog que Dog que está cargado actualmente? ac tualmente? Ves el problema? Las variables estáticas nunca se graban como parte del estado del objeto, porque no pertenecen al objeto!


Página 179


2012

16 Acceso a Datos en Java: JDBC y MySQL En el capítulo anterior estudiamos la forma en que una aplicación Java puede almacenar y recuperar información en ficheros de disco. No obstante, la mayoría de los pro gramas Java que manipulan información del disco, lo hacen con datos almacenados en una base de datos. Para tratar con bases de datos existen unos estándares que facilitan a las aplicaciones informáticas, manipular la información contenida en ellas. En Java disponemos de un API especial basado en estos estándares que permite desarrollar aplicaciones Java para acceder a bases de datos relacionales, se trata del API JDBC. Ahora analizaremos este API, sin ninguna duda uno de los más importantes que incluye la plataforma J2SE.

16.1 La tecnología Java Database Conectivity La mayoría de las aplicaciones necesitan acceder a los datos existentes en un Enterprise Information System, para ello necesitan disponer de alguna tecnología, implementada en una librería de clases, que posibilite el envío de instrucciones SQL a la base de datos y la manipulación de resultados. JDBC proporciona a las aplicaciones Java un mecanismo uniforme para el acceso a datos. La tecnología JDBC consiste en la utilización de un conjunto de clases (API JDBC) que disponen de una serie de métodos para operar con la base de datos. Utilizando estos métodos, la aplicación dirige todas las peticiones hacia un software intermediario, conocido como Driver JDBC , cuya misión es traducir las llamadas a los métodos a órdenes nativas del gestor de la BD (Base de Datos). La principal ventaja que ofrece este sistema es que la aplicación se independiza del tipo de base de datos utilizado para almacenar la información. En otras palabras, no hay que escribir un programa para acceder a Oracle, otro para Sybase, etc... dado que el API JDBC utiliza una serie de clases e interfaces genéricas que actúan sobre el driver, no sobre la base de datos. Tan solo es necesario disponer de un driver específico para el tipo de base de datos con el que se va a trabajar.

16.2 El driver JDBC Como se desprende de lo que hemos comentado, el driver JDBC juega un papel fundamental en las aplicaciones Java de acceso a datos. Por ello, vamos a comentar algunos aspectos relevantes sobre este antes de abordar los aspectos propios de la programación.


Página 180


2012

16.2.1 Estructura y funcionamiento Básicamente, el driver JDBC es una clase Java que implementa toda la funcionalidad del API JDBC, proporcionando la comunicación entre la aplicación y la base de datos. Normalmente, son los fabricantes de bases de datos los que distribuyen los driver JDBC aunque también se pueden encontrar en productos terceros, como entornos de desarrollo (IDE) o servidores de aplicaciones. En un driver JDBC se distinguen dos capas o interfaces: 

Capa de aplicación. En la parte del driver que interactúa con la aplicación, todos los driver JDBC, independientemente del tipo de base de datos para la que hayan diseñado, proporciona la misma interfaz de aplicación.



Capa de base de datos. Esta capa interactúa con la base de datos, por lo que es específica para cada tipo de base de datos.

16.2.2 Tipos de driver JDBC Independientemente del tipo de base de datos para el que se haya diseñado, un driver JDBC puede pertenecer a una de las siguientes categorías: 

Tipo 1: Driver puente JDBC-ODBC. Fueron los primeros tipos de driver JDBC que se lanzaron al mercado. Utilizan como intermediario un driver ODBC. Dada la gran expansión que en aquellos momentos tenía la tecnología ODBC y el amplio número de drivers ODBC existentes, el driver puente JDBC-ODBC puede utilizarse para acceder a la mayoría de los tipos de bases de datos que hay en el mercado. La principal desventaja que tiene este driver es que es necesario configurar un DSN (Data Source Name) utilizado por ODBC, en el equipo donde se va a ejecutar la aplicación. El driver puente JDBC-ODBC se incluye con el conjunto de clases del J2SE, concretamente se trata de la clase sun.jdbc.odbc.JdbcOdbcDriver sun.jdbc.odbc.JdbcOdbcDriver..


Página 181


2012

Tipo 2: Driver nativo El driver nativo convierte las llamadas ll amadas JDBC en llamadas al API nativo del gestor de la base de datos. Su principal inconveniente es la necesidad de instalar el API nativo de la base de datos en el equipo donde reside la aplicación.



Tipo 3: Driver intermedio Este tipo de driver convierte las llamadas JDBC en un protocolo específico del middleware, a su vez, el servidor del middleware se encarga de transformar estas llamadas en el API nativo de la base de datos, proporcionando conectividad para diferentes tipos de bases de datos. La principal característica de este driver es que no requiere ningún tipo de instalación en el equipo donde se instala la aplicación.



Tipo 4: Driver puro-Java Convierte las llamadas JDBC en el protocolo de red utilizado directamente por el servidor de base de datos, permitiendo llamadas directas desde la maquina cliente (aplicación) al servidor de base de datos. Este driver no requiere ningún tipo de configuración especial en la máquina cliente.

16.3 El lenguaje SQL El lenguaje SQL surge ante la necesidad de disponer de un mecanismo para operar con la información almacenada en bases de datos relacionales rel acionales de diferentes fabricantes. Este lenguaje es soportado por la mayoría de gestores de bases de datos relacionales existentes en el mercado. Sus instrucciones, de estructura muy simple, permiten operar sobre un conjunto de datos en vez de tener que hacerlo individualmente.

16.3.1 Consultas Una consulta es cualquier expresión en SQL que defina una operación a realizar sobre la base de datos. Una consulta está compuesta por los siguientes elementos:   

Una acción o verbo que determina la operación a realizar. Por ejemplo SELECT SELECT.. Un objeto, combinación de campos de las tablas de la base de datos. Una cláusula que determina sobre que objetos actúa el verbo. Ejemplo From From tabla. tabla.


Página 182


2012

Las consultas SQL se expresan mediante sentencias de texto (sentencias SQL), estas pueden ser incluidas dentro de un programa Java como parámetro de alguno de los métodos de las clases/interfaces del API JDBC, tal y como veremos en el siguiente apartado.

16.3.2 Tipos de sentencias SQL El juego de sentencias SQL se divide en tres grupos: 





Sentencias DDL: En este grupo se incluyen aquellas sentencias que se encargan de la creación, definición y destrucción de objetos. Entre ellas destacan CREATE y DROP DROP.. Sentencias DCL: Permiten controlar aspectos varios como la confidencialidad de los datos. Entre estas cadenas desatacan GRANT GRANT y y REVOKE REVOKE.. Sentencias DML: Están incluidas en este grupo las sentencias utilizadas para manipulación de datos, como son extracción (SELECT (SELECT), ), modificación (UPDATE (UPDATE), ), inserción (INSERT (INSERT)) y borrado (DELETE DELETE). ).

16.3.3 Sentencias para la manipulación de Datos (DML) Estas son las sentencias que se utilizan en las aplicaciones que acceden a base de datos, por tanto, vamos a comentar más detenidamente el funcionamiento de cada una de ellas. Sentencia SELECT La sentencia SELECT SELECT es la más importante y la más compleja de todas las sentencias que forman SQL. Se utilizan para extraer datos de una o varias tablas de la base de datos, su forma general operando sobre una única tabla es:

Esta instrucción devuelve el conjunto de registros de la tabla indicada en FROM FROM,, que cumplen las condiciones establecidas en WHERE y que están formados por los campos indicados en SELECT SELECT.. Para tomar todos los campos de la tabla se escribirá *, en lugar de los nombres de los campos. Los registros se devolverán ordenados según el campo o campos indicados en ORDER BY. BY. Las cláusulas WHERE WHERE y y ORDER BY son BY son opcionales, por lo que en caso de que no se utilicen, se devolverán todos los registros de la tabla en el orden definido en el interior de la misma. e m a i l : b r u j u l a t o @ y ah o o . e s

Página 183


2012

La siguiente instrucción de ejemplo devolvería el campo " nombre nombre"" y "ciudad ciudad"" de aquellos registros de la tabla "usuarios " usuarios"" cuya ciudad sea "Madrid". Además, las filas se devolverán ordenadas por el "nombre " nombre"" del usuario.

Tanto en este ejemplo como en los demás que irán apareciendo, cada cláusula se escribe en una línea diferente a efectos de una mayor claridad. Además, SQL no es case sensitive por lo que las cláusulas pueden escribirse indiferentemente en mayúsculas o en minúsculas.

Condiciones de selección Las condiciones de selección de registros, llamadas también predicados, se establecen en la cláusula WHERE WHERE mediante un criterio, que es una expresión cuyo resultado se evalúa como verdadero o falso. La forma general es:

A la hora de escribir la condición hay que tener en cuenta que: 

 

Si el valor no es numérico, deberá escribirse entre comillas simples, aunque algunos gestores de BD como Access, obligan a que los valores tipo fecha se escriban delimitados por #. SELECT.. “valor” puede ser el resultado de otra instrucción SELECT La cláusula WHERE WHERE puede incluir varias expresiones de este tipo vinculadas con los operadores AND AND y y OR OR..

Ordenación de registros La cláusula ORDER BY determina BY determina como se van a ordenar los registros según la forma:

donde hay que tener en cuenta que:   

Si dos o más registros poseen el mismo valor de campo1 campo1,, se ordenara según campo2 campo2.. El modo de ordenación puede ser ascendente (ASC ( ASC)) o descendente (DESC ( DESC). ). El modo de ordenación predeterminado es ascendente.


Página 184


2012

Otro ejemplo:

En este caso se están solicitando todos los campos de aquellos registros de la tabla pedidos pedidos cuya cuya fecha sea inferior al 1/1/04 y el campo pendiente sea false false.. Los registros se devolverán ordenados por coste descendente. Consultas SELECT sobre sobre varias tablas Para obtener datos incluidos en distintas tablas, basta con indicar los nombres de estas en la cláusula FROM FROM,, separadas por comas. Si alguno de los campos seleccionados se encuentra en más de una tabla, hay que preceder a su nombre el de la tabla en la que se encuentra separado por un punto ”.”. Cuando se realiza una consulta sobre varias tablas, se debe añadir una condición en la cláusula WHERE WHERE que que ligue a los datos de ambas tablas, de lo contrario la consulta devolverá el producto cartesiano de las filas de ambas tablas. Para poder ligar dos tablas, estas deben tener un campo común, la unión entre ellas se lleva a cabo añadiendo la siguiente expresión en la cláusula WHERE WHERE::

La siguiente instrucción obtiene el nombre de todos los alumnos apuntados al curso de SQL SERVER estando el campo nombre cuyo valor se quiere recuperar, y el campo curso, que contiene la condición en tablas diferentes. Ambas tablas se encuentran relacionadas por un campo común, id:

Instrucciones SELECT subordinadas subordinadas Dentro de la cláusula WHERE de una sentencia SELECT se pueden especificar otras instrucciones SELECT SELECT,, a las que se considera subordinadas de la primera. La instrucción anterior también se puede escribir utilizando un SELECT SELECT subordinado subordinado de la siguiente manera:


Página 185


2012

Operadores Además de los operadores simples ( < ( < , > , = ,...) una cláusula WHERE WHERE puede puede incluir otro tipo de operadores: 







LIKE Se utiliza para buscar campos que contengan combinaciones de caracteres que cumplan ciertas condiciones: Campo LIKE LIKE constante_alfanum constante_alfanum La constante alfanumérica puede contener caracteres cualquiera, e incluir comodines: o % cadena de longitud aleatoria _ carácter carácter no nulo o _ [x-y] carácter carácter dentro del rango x- y o [x-y] BETWEEN Comprueba si el valor está comprendido entre los dos dados: BETWEEN exp2 exp2 AND AND exp3 exp3 o Exp1 [NOT] BETWEEN El resultado es verdadero si exp1 está comprendido entre exp2 y exp3:

IN Comprueba si un valor está incluido en una lista de valores IN (cte1,cte2,cte3...) (cte1,cte2,cte3...) o Expresión IN En lugar de una lista de constantes podría especificarse una sentencia SELECT SELECT subordinada, que no puede incluir la cláusula ORDER BY y BY y debe dar lugar a una tabla con una sola columna:

Sentencia INSERT Permite añadir una o más filas a una tabla. Puede utilizarse tanto para añadir una única fila como para copiar en una tabla un subconjunto de registros proveniente de otra. En el caso de añadir filas individuales se utiliza el formato:

Esta instrucción inserta en una tabla un registro cuyos valores se especifican en VALUES VALUES,, cada valor será asignado a un campo según el orden especificado en la lista de nombres de campos. Si no se especifica la lista de campos, se asume que se suministraran valores en la lista de valores para todos los campos de la tabla.


Página 186


2012

La siguiente instrucción añade un nuevo registro en la tabla clientes:

El formato para insertar varias filas en una tabla es:

La siguiente instrucción añade a la tabla alumnos todos los registros de la tabla alumnos2:



Sentencia DELETE Permite borrar una o varias filas de una tabla. Su formato es:

La instrucción elimina de la tabla a todos los alumnos que hayan cursados Access:



Sentencia UPDATE Su función es modificar los valores de ciertos campos en aquellos registros r egistros que cumplan una determinada condición. El formato de esta instrucción es el siguiente:

Mediante la cláusula SET SET se se indican los valores que se van a asignar los campos. La siguiente consulta aplica un 5% de descuento a los cursos de Access:


Página 187


2012

16.4 El API JDBC Las clases e interfaces que forman parte de este API se encuentran en el paquete java.sql paquete java.sql.. La siguiente tabla contiene los elementos más importantes de este paquete:

16.4.1 Utilización de JDBC para acceder a datos En toda aplicación que utilice JDBC para acceder a datos, se distinguen cuatro fases o pasos a realizar: 1. 2. 3. 4.

Conexión a la base de datos Ejecución de consultas Manipulación de registros Cierre de la conexión

A continuación, describiremos cada uno de ellos, analizando las clases e interfaces implicadas en cada paso.

16.4.2 Gestión con la base de datos Para realizar cualquier operación con la base de datos es necesario primeramente, establecer una conexión con la misma. Esta acción requiere la realización de dos operaciones: 

Carga del driver

Mediante esta opción, se prepara el driver JDBC para que pueda ser utilizado. Esto se realiza mediante el método estático forName() forName() de de la clase java.lang.Class java.lang.Class,, cuyo formato es:

Este método localiza, lee y enlaza dinámicamente con el driver, devolviendo un objeto Class Class asociado a la clase indicada. Se debe tener en cuenta que la llamada a forName() forName() puede puede provocar la excepción ClassNotFoundException ClassNotFoundException,, por lo que deberá ser capturada en la aplicación. La siguiente instrucción realizaría la carga del driver puente JDBC-ODBC proporcionado por Sun:


Página 188


2012

Creación de la conexión Una vez cargado el driver se debe proceder a la conexión con la base de datos, operación que se lleva a cabo con el método estático getConnection() getConnection()de de la clase DriveManager DriveManager del del API JDBC. EL formato del método es:

La cadena url representa la dirección de la base de datos y su formato es:

donde subprotocol subprotocol depende depende del tipo de driver utilizado y base_datos base_datos es es el nombre de la base de datos. En L2J, el driver más utilizado es de MySQL: com.mysql.jdbc.Driver Por otro lado, el método getConnection() devuelve un objeto que implementa la interfaz Connection Connection,, la cual proporciona varios métodos para manejar la conexión. La siguiente instrucción utiliza el driver JDBC-OCDB para establecer una conexión con una base de datos, cuyo nombre de fuente de datos es " empresa empresa": ":

El método getConnection() getConnection() está está sobrecargado, existiendo una versión que además de la url permite suministrar el usuario y la contraseña para acceder a la base de datos. El siguiente ejemplo permitiría establecer una conexión con una base de datos de Oracle llamada info, usando un driver nativo de Oracle:

Class.forName(“oracle.jdbc.driver.oracleDriver”);

Connection cn = Driver Manager.getConnection(“ jdbc:oracle:thin:@miservidor:1521:info”,”scot”,tiger”);

Debe tenerse en cuenta que, al igual que sucede con la mayoría de los métodos de API JDBC, getConnection getConnection puede provocar una excepción de tipo SQLException SQLException que que habrá que capturar.


Página 189


2012

16.4.3 Ejecución de consultas Una vez establecida la conexión con la base de datos, se empleará esta para enviar consultas SQL a la base de datos.

Creación del objeto STATEMENT Las consultas SQL se manejan a través de un objeto que implementa la interfaz Statement Statement,, cuya creación se realiza mediante el método createStatement() createStatement() de de la interfaz Connection Connection::

Puede provocar una excepción de tipo SQLException SQLException..

Ejecución de la consulta SQL La interfaz Statement Statement proporciona proporciona diversos métodos para enviar una consulta SQL a través de la conexión. Los más importantes son: o

boolean execute(String sql) Envía a la base de datos la consulta SQL proporcionada como parámetro. Si se trata de una consulta de acción (Insert (Insert,, Delete Delete o o Update Update)) el método devuelve false false indicando indicando que no se generan resultados. En la consulta de selección (SELECT ( SELECT)) devuelve true true..

o

int executeUpdate(String sql) Envía una consulta de acción a la base de datos, devolviendo el número de registros afectados por la acción.

o

ResultSet ExecuteQuery(String sql) Envía una consulta de selección de registros a la base de datos, devolviendo un objeto ResultSet ResultSet para para su manipulación.

En caso de producirse algún tipo de error en la ejecución de la consulta, los tres métodos generan una excepción SQLException SQLException.. Para enviar una consulta de actualización de la tabla empleados empleados de de la base de datos empresa empresa,, utilizaríamos:


Página 190


2012

Cierre de la conexión Las consultas de acción no devuelven datos a la aplicación para su tratamiento, por lo que una vez ejecutada la consulta/s, se debe proceder al cierre de la conexión. Esto permite liberar recursos de memoria y CPU en la máquina. El cierre de la conexión se realiza mediante el método close() close() de de la interfaz Connection Connection::

Puede provocar una excepción de tipo SQLException SQLException.. La interfaz Statement Statement también también dispone de un método close() close() para para liberar el objeto Statement Statement,, esto debe realizarse antes de cerrar la conexión. Cuando se cierra una conexión, todos los objetos Statement Statement que que queden abiertos serán cerrados automáticamente.

A fin de aclarar lo visto hasta ahora, el siguiente listado representa el método main() main() de de una clase en el que se reflejan todos los pasos para realizar la inserción de un registro en una base de datos. La información es solicitada a través del teclado:


Página 191


2012

Para la correcta ejecución de este script, ha sido necesario configurar ECLIPSE , añadiendo el conector a la librería del programa. Dentro de la carpeta jre/libs/ext carpeta jre/libs/ext he colocado mysql-connector-java-5.1.6-bin.jar, descargado de: http://dev.mysql.com/downloads/connector/j/3.0.html

16.5 Manipulación de registros El envío de una consulta de selección de registros a la base de datos devuelve como resultado un objeto que, además de disponer de un cursor para desplazarse por el conjunto de registros seleccionados, permite acceder a los valores de los campos. Este objeto implementaría la interfaz ResultSet ResultSet.. La interfaz ResultSet ResultSet del API SQL proporciona métodos para desplazarse por el conjunto de registros afectados por la consulta y manipular sus contenidos.

16.5.1 Obtener un objeto ResultSet Un objeto ResultSet ResultSet se se crea al invocar al método executeQuery() executeQuery() del del objeto Statement Statement::

De forma predeterminada, este objeto posee la característica de ser sólo avance y lectur a. Esto implica que el recorrido se deberá hacer siempre desde el primero registro hacia delante y los contenidos de los campos no podrán ser modificados. Desde el punto de vista de la velocidad y el consumo de recursos, esta es la forma más óptima en la que se puede presentar ResultSet ResultSet,, resultando además esta funcionalidad suficiente en la mayoría de los casos. No obstante, en apartados posteriores veremos cómo crear ResultSet ResultSet desplazables desplazables de lectura/escritura.


Página 192


2012

16.5.2 Desplazamiento por el conjunto de registros Una vez obtenido el ResultSet ResultSet,, su cursor se encuentra situado en la posición que está antes del primer registro. Para realizar el desplazamiento por los registros, la interfaz ResultSet proporciona el método next() next().. La llamada a este método desplaza el cursor al siguiente registro del conjunto, devolviendo como resultado un boolean que indica si la nueva posición apuntada se corresponde con el registro (true ( true), ), o si el cursor se ha salido del conjunto ( false false). ). Utilizando este método y una instrucción while while,, es posible recorrer todos los registros desde el primero hasta el último:

16.5.3 Acceso a los campos La interfaz ResultSet proporciona dos grupos de métodos para acceder a los campos del registro actual, el que está siendo apuntado por el cursor (registro actual). Estos métodos se ajustan a los formatos:  

xxx getXxx(int posicion) xxx getXxx(String nombre_campo)

donde xxx puede ser el nombre de cualquiera de los tipos básicos de Java más Date Date,, String String y y Object Object,, debiéndose utilizar aquel método que se corresponda con el tipo almacenado en el campo. El primer grupo de métodos permite obtener el valor de un campo a partir de su posición dentro del registro, siendo 1 la posición del primer campo. Por su parte, el segundo grupo de métodos obtiene el valor del campo a partir del nombre del mismo. El siguiente trozo de código, muestra en pantalla el level de todos los PJs online:

El siguiente programa presenta otro ejemplo de utilización de JDBC para extraer la información de una base de datos. En este caso, se solicita a un usuario que introduzca su usuario y su contraseña por el teclado, utilizando esa información para comprobar si el usuario está o no registrado en la tabla clientes de una base de datos:


Página 193



2012

Página 194


2012

Ejemplo de una consulta con MySQL que muestra los personajes asociados a una cuenta en L2J.

16.5.4 Otros métodos de la interfaz ResultSet

Además de los anteriores, la interfaz ResultSet ResultSet proporciona proporciona los siguientes métodos a través de un cursor de sólo avance y lectura: 









boolean isFirst() Devuelve true true si si el cursor apunta al primer registro. boolean isBeforeFirst() Devuelve true true si si el cursor esta antes del primer registro. boolean isLast() Devuelve true true si si el cursor esta apuntando al último registro. boolean isAfterLast() Devuelve true true si si el cursor esta después del último registro. int getRow() Devuelve la posición del registro actual siendo 1 la posición del primer registro.

Todos los métodos de la interfaz ResultSet ResultSet pueden pueden lanzar una SQLException SQLException..


Página 195


2012

16.5.5 Cierre de un ResultSet

El método close() de la interfaz ResultSet permite cerrar cerr ar el objeto y liberar lib erar los recursos utilizados por este, algo que resulta bastante adecuado para reducir el consumo de recursos y mejorar así el rendimiento de las aplicaciones. Si un mismo objeto Statement se utiliza para crear un segundo ResultSet ResultSet,, el primer ResultSet será cerrado automáticamente aut omáticamente de forma for ma implícita. Esto significa signi fica que si se desea tener dos ResultSet ResultSet abiertos abiertos simultáneamente, habrá que crear dos Statement Statement diferentes. diferentes. De hecho, cualquier operación que se realice con el objeto Statement Statement después después de haber creado un ResultSet ResultSet,, provocará implícitamente el cierre inmediato de este.

16.5.6 El objeto ResultSetMetaData Información sobre los datos Además de los datos en si, el API SQL proporciona una interfaz ResultSetMetaData ResultSetMetaData,, que permite obtener información sobre las características de los datos referenciados por un ResultSet ResultSet.. Obtener objeto ResultSetMetaData Primeramente, necesitamos obtener un objeto ResultSetMetaData ResultSetMetaData para para lo cual utilizaremos el método getMetaData() getMetaData() de de la interfaz ResultSet() ResultSet()::

Acceso a la información La interfaz ResultSetMetaData ResultSetMetaData proporciona proporciona los siguientes sig uientes métodos para obtener información sobre los datos: 





int getColumnCount() Devuelve el número de columnas del conjunto de registros referidos por el ResultSet ResultSet.. String getColumnName(int posición) Devuelve una constante entera que representa el tipo de dato SQL soportado por el campo. Las constantes de los tipos SQL se encuentran definidas en la clase java.sql.Types clase java.sql.Types String getColumnTypeName(int posición) Devuelve el nombre de tipo de dato soportado so portado por el campo, según está definido en el gestor de base de datos.


Página 196


2012

Consultas preparadas Las consultas preparadas se basan en la utilización de consultas SQL precompiladas. La idea es precompilar una instrucción SQL, utilizando parámetros en vez de valores fijos, y sustituir estos por valores concretos en el momento de la aplicación en aquellos casos en que vaya a utilizarse repetidas veces una determinada instrucción. Las consultas preparadas se gestionan mediante la interfaz PreparedStatement PreparedStatement..

Creación de un objeto PreparedStatement . Para la creación de una consulta preparada utilizamos el método preparedStatement preparedStatement de de la interfaz Connection Connection.. Este método recibe como parámetro la consulta SQL para su precompilación:

Como se puede apreciar, los valores de los campos se indican mediante ? en la instrucción para su posterior sustitución. Nótese que la ? hace referencia a un valor, independientemente de su tipo, por ello, no es necesario encerrar este símbolo entre comillas simples cuando se trate de valores de texto.


Página 197


2012

Asignaciones de parámetros Una vez creada la consulta preparada, ya queda para ser ejecutada tantas veces como se requiera. Pero antes, es necesario asignar valores a los parámetros definidos en la instrucción. Esta operación se realiza con el siguiente grupo de métodos existentes en la interfaz PreparedStatement PreparedStatement::

pudiendo ser xxx xxx el el nombre de cualquier de los tipos básicos de Java más Date Date,, Object Object y y String String.. Por otro lado, indice_parametro es la posición que ocupa el parámetro dentro de la instrucción, siendo 1 la posición del primero. Para el ejemplo de la consola anterior, podríamos hacer la siguiente asignación de parámetros:

Ejecución de la consulta Para proceder a la ejecución de la consulta utilizaremos los métodos execute() execute() o o executeQuery() executeQuery(),, dependiendo de si es una consulta de acción o de selección de registros. En el ejemplo que estamos analizando:


Página 198

2012

Curso gratuito de Java en emuladores L2 Java ResultSet desplazable ResultSet desplazable

Como ya hemos visto, los ResultSet que hemos creado hasta el momento, únicamente permiten realizar desplazamientos hacia delante y el acceso de datos es solo lectura. Para disponer de un ResultSet ResultSet con con mayores prestaciones, tendríamos que modificar la forma en que creamos los objetos Statement Statement o o PreparedStatement PreparedStatement,, utilizando las siguientes versiones de métodos de creación de consultas de la interfaz Connection Connection::





Statement createStatement(int resultSetType, int resultSetConcurrency) PreparedStatement prepareStatement(String resultSetConcurrency)

sql,

int

resultSetType,int

El parámetro entero resultSetType resultSetType representa representa el tipo de ResultSet ResultSet que que pueden ser creados con el objeto. Los posibles valores que puede tomar este parámetro están recogidos en las siguientes constantes definidas en la interfaz ResultSet ResultSet::







ResultSet.TYPE_FOWARD_ONLY Los resultados creados son de tipo "solo avance", es el valor por defecto. ResultSet.TYPE_SCROLL_INSESITIVE Permite crear ResultSets que se desplacen en ambas direcciones, aunque no muestra los cambios que puedan realizar otros usuarios en la base de datos mientras el resultSet esté abierto. ResultSet.TYPE_SCROLL_SENSITIVE Permite crear ResultSet ResultSet desplazables desplazables en ambas direcciones y, además, sensibles a los cambios que otros usuarios realicen sobre la base de datos.

En cuanto a resultSetConcurrency resultSetConcurrency,, indica si los datos son solo lectura o de lectura-escritura. Los posibles valores que pueden tomar son: 



ResultSet.CONCUR_READ_ONLY Los campos son solo lectura, es el valor predeterminado. ResultSet.CONCUR_UPDATABLE Los campos son de lectura-escritura, pudiéndose utilizar el objeto ResultSet ResultSet para para realizar modificaciones sobre los mismos.


Página 199


2012

Los ResultSet ResultSet desplazables desplazables pueden utilizar, además de los estudiados, los siguientes métodos de la interfaz ResultSet ResultSet::











void first() Desplaza el cursor hasta el primer registro. void beforeFirst() Desplaza el cursor a la posición anterior al primer registro. void last() Desplaza el cursor hasta el último registro. void afterLast() Desplaza el cursor a la posición posterior al último registro. void absolute(int pos) desplaza el cursor a la posición indicada en pos.


Página 200


2012

17 Manejo de fechas y números con clases El API de Java provee una larga (quizás un poco más de la cuenta) lista de clases para ayudarte con las fechas, los números y la moneda. Cuando hayas terminado esta sección, deberías tener consolidados los fundamentos para tareas como crear una fecha, y usar objetos Date y DateFormat,, convertirlo a cadena y volverlo a convertir en objetos, creando funciones de DateFormat calendario, imprimir correctamente el valor formateado de la moneda y hacer todo esto para que funcione de manera correcta en cualquier país del globo

17.1 Trabajando con fechas, números y monedas Si queremos trabajar con fechas en todo el mundo (y quién no?) necesitarás estar familiarizado con al menos cuatro clases de java.text de java.text y y java.util java.util.. Aquí hay cuatro clases de fecha que necesitaras entender: 









java.util.Date La mayoría de los métodos de esta clase se han quedado obsoletos, java.util.Date pero puedes usar esta clase como puente entre Calendar y DateFormat DateFormat.. Una instancia de Date Date representa representa una fecha y una hora en milisegundos. milisegundos. java.util.Calendar Esta Esta clase tiene una gran variedad de métodos que te ayudarán a convertir y manipular fechas y horas. Por ejemplo, si quieres añadir un mes a una fecha dada, o encontrar que día de la semana cae el 1 de Enero, los métodos de Calendar Calendar pueden pueden hacer casi de todo. java.text.DateFormat Esta clase se usa para formatear fechas, no sólo estilos como "01/01/70 01/01/70"" o "Enero, "Enero, 1, 1970", 1970", sino que también formatea las fechas de forma local en todo el mundo. java.text.NumberFormat Esta Esta clase se usa para formatear números y moneda para todos los países (Locale) del mundo. java.util.Locale Esta java.util.Locale Esta clase se usa conjuntamente con DateFormat y NumberFormat NumberFormat..

Manejando fechas y números con las clases Cuando trabajas con fechas y números, a menudo usarás también clases. Es importante entender cómo funcionan las clases descritas arriba, como se usan unas con las otras. Por ejemplo, necesitarás saber que si quieres hacer un formato especial para un Locale especifico, tendrás que crear un objeto Locale antes que el objeto DateFormat DateFormat,, porque necesitarás el objeto Locale Locale como como argumento para DateFormat DateFormat.. La siguiente tabla es una vista rápida de los casos y soluciones usando estas clases. Esta tabla indudablemente muestra preguntas específicas sobre clases, y profundizaremos en ellas en el siguiente capítulo. Una vez que hayamos visto la discusión entre los niveles de las clases, encontrarás esta tabla como un resumen bastante bueno.


Página 201


2012

17.2 La clase Date La clase Date tiene un pasado con altibajos. El diseño de su API no fue muy bueno en cuanto al manejo de internalizaciones. En su estado actual, la mayoría de sus métodos han quedado obsoletos, y para la mayoría de los propósitos querrás usar Calendar en lugar de Date Date.. La clase Date es interesante por varias razones: puedes encontrarlo en código antiguo, es bastante fácil si quieres una manera rápida y sucia de obtener la fecha y la hora actual, está bien si quieres la hora universal, la cual no está afectada por zonas horarias, y finalmente, lo usarás como puente temporal para formatear un objeto Calendar usando la clase DateFormat DateFormat.. Como hemos dicho antes, una instancia de la clase Date representa una fecha y hora. Internamente, se crea un long long que que guarda el tiempo transcurrido en milisegundos desde el 1 de Enero de 1970. 1970. Has intentando alguna vez imaginarte cómo es de grande el número? e m a i l : b r u j u l a t o @ y ah o o . e s

Página 202


2012

Usemos Date para averiguar la fecha de un trillón de segundos, comenzando desde el 1 de Enero de 1970:

a JVM arroja:

1st date Sat Sep 08 19:46:40 MDT 2001 Bien, para futuras referencias, recuerda que un trillón de milisegundos son 31 años y dos tercios. Quizás la mayoría de los métodos de Date han quedado obsoletos, pero aun es aceptable el uso de getTime() getTime() y y setTime() setTime(),, aunque pronto veremos que es un poco doloroso. Vamos a añadir una hora a nuestra instancia d1 d1 del del ejemplo anterior:

lo que da:

1st date Sat Sep 08 19:46:40 MDT 2001 new time Sat Sep 08 20:46:40 MDT 2001 Date cuenta que setTime() setTime() y y getTime() getTime() se usan en milisegundos, si quieres manipular fechas usando la clase Date Date,, es la única forma que hay. Mientras esto no fue demasiado doloroso, imagina lo divertido que puede ser añadir un año a la fecha. Veremos más tarde la clase Date Date,, por ahora solo lo que necesitas saber es que si quieres crear una instancia de Date para crear la fecha actual, tienes que usar el constructor de Date sin argumentos:

(Nosotros estamos imaginando que si invocas ahora now.getTime() now.getTime(),, conseguirás un numero entre uno y dos trillones.)


Página 203


2012

17.3 La clase Calendar

Hemos visto que manipular fechas usando Date puede resultar engorroso. La clase Calendar fue diseñada para manipular las fechas de manera más sencilla. La clase Calendar tiene un millón de campos y métodos, una vez que manejes unos pocos de ellos, el resto del trabajo funciona de forma similar. Cuando pruebas a usar Calendar Calendar,, puedes darte cuenta que es una clase abstracta, no puedes decir:

Para crear una instancia de Calendar Calendar,, tienes que usar el método sobrecargado so brecargado getInstance() getInstance()::

Cuando tienes una referencia como la de arriba, la variable se está refiriendo a una subclase de Calendar Calendar.. No puedes saber con seguridad que subclase consigues (lo más seguro que sea java.util.GregorianCalendar sea java.util.GregorianCalendar), ), pero eso a ti no te importa (quiero decir que no tienes que reparar cuidado en ello). Estarás un API de Calendar Calendar.. (Java continua distribuyéndose por todo el mundo para mantener una cohesión, puedes encontrar subclases más específicas para Locale). Locale ). Bien, ahora vamos a obtener una instancia de Calendar Calendar,, volvamos a nuestro último ejemplo, y vamos a ver que día de la semana cae nuestro milisegundo número tres mil millones, y añadiremos un mes a esa fecha:

Esto nos da:

1st date Sat Sep 08 19:46:40 MDT 2001 Sunday is the first day of the week trillionth milli day of week is 7 new date Mon Oct 08 20:46:40 MDT 2001 Vamos a examinar el programa centrándonos en las 5 líneas resaltadas:


Página 204


2012

1. Asignamos el Date d1 d1 a a la instancia Calendar c. 2. Usamos el campo SUNDAY SUNDAY para para determinar si, nuestra JVM, considera SUNDAY SUNDAY como como el primer día de la semana. (En algunos sitios, MONDAY es el primer día de la semana). La clase Calendar provee de campos similares para días de la semana, mes y días del mes, el día del año, y así... etc. 3. Usamos DAY_OF_WEEK DAY_OF_WEEK para para averiguar que día de la semana cae el trillisegundo. 4. Hasta ahora hemos usado métodos setter y y getter que que debería ser considerado ya algo intuitivo. Ahora vamos a usar el método add() add() de de Calendar Calendar.. Es un método muy poderoso que nos permite añadir y substraer unidades de tiempo apropiadas para el campo Calendar especifico. Por ejemplo:

5. Convierte el valor de c a una instancia Date Date.. El otro método de Calendar que deberías de conocer es roll() roll().. Funciona igual que add() add() excepto excepto que cuando una parte de la fecha se incrementa o decrementa, la parte más grande de Date no será incrementada o decrementada. Hmmm... por ejemplo:

La salida seria:

new date Fri Jul 08 19:46:40 MDT 2001 Fíjate en que el año no cambió, aunque le añadimos 9 meses a Octubre. De forma similar, funciona roll() roll() con con HOUR HOUR,, no cambiara la fecha, ni el mes o el año. 17.4 La clase DateFormat Habiendo aprendido como crear fechas y manipularlas, vamos a empezar a formatearlas. Aquí se muestra un ejemplo de cómo puede formatearse una fecha de diferentes maneras:


Página 205


2012

lo que produce: 9/8/01 7:46 PM Sep 8, 2001 9/8/01 Sep 8, 2001 September 8, 2001 Saturday, September 8, 2001

Viendo este código nos damos cuenta de un par de cosas. Lo primero que salta es que DateFormat es otra clase abstracta, así que no podemos usar new para crear instancias de DateFormat DateFormat.. En este caso, usamos dos métodos de la factoría, getInstance() getInstance() y y getDateInstance() getDateInstance().. Fíjate que getDateInstance() esta sobrecargado, cuando hablemos de Locale Locale,, veremos la otra versión de getDateInstance() getDateInstance() . . Lo siguiente, es que hemos usados campos estáticos de DateFormat para personalizar nuestras instancias de DateFormat DateFormat.. Cada una de las cuales representa un estilo de formato. En este caso parece como si getDateInstance() sin argumentos no diera el mismo estilo que la versión MEDIUM MEDIUM,, pero eso no es una regla (veremos más cuando hablemos sobre Locale Locale). ). Finalmente usaremos el método format() para crear la representación de cadena de las versiones formateadas de Date cuando estemos trabajando con ella. El ultimo método que te tendría que ser familiar es parse() parse().. Este método toma la cadena formateada en el estilo de la instancia de DateFormat DateFormat,, y convierte la cadena a un objeto Date Date.. Tal como puedes imaginarte, esta operación es arriesgada porque el método parse() parse() podría podría recibir la cadena mal formateada. Por esta razón, parse() parse() arroja arroja ParseException ParseException.. El siguiente código crea una instancia de Date Date,, usa DateFormat DateFormat.format() .format() para para convertirlo a cadena, y luego usa DateFormat DateFormat.parse() .parse() para para pasarlo de nuevo a Date Date::


Página 206


2012

Lo que produce: d1 = Sat Sep 08 19:46:40 MDT 2001 9/8/01 parsed = Sat Sep 08 00:00:00 00:00 :00 MDT 2001

Tienes que darte cuenta de que estamos usando el estilo SHORT SHORT,, hemos perdido algo de precisión cuando convertimos el Date a cadena. Esta pérdida de precisión nos aparece cuando volvimos a poner la cadena como objeto Date Date,, y entonces paso a ser de 7:46 a 00:00 midnight.

17.5 La clase Locale Antes vimos que una gran parte de este objetivo existe para evaluar tu habilidad con algunas tareas básicas internacionales. Espera a que se acabe, Locale es tu ticket para la dominación del mundo. Las clases DateFormat y NumberFormat (las veremos en breve) pueden usar una instancia de Locale para personalizar una salida formateada a un Locale especifico. Podrías preguntarte como Java define un Locale Locale?? El API dice que un Locale es un sitio geográfico específico, político o región cultural. Los dos constructores de Locale que necesitas entender son:

El argumento del lenguaje representa un código del lenguaje ISO 639, así que por ejemplo, si quieres formatear fechas y números en Wallon (un lenguaje usado algunas veces en Bélgica), usarías "wa" en tu String de language. Existen sobre 500 ISO códigos de lenguajes, incluyendo el Klingon ("thl"), aunque desafortunadamente Java no soporta el Klingon. P ensábamos decirte que memorizases todos los códigos pero no queríamos causar más ataques cardiacos. Así que no tienes que memorizar ningún ISO de los 240 que puedes encontrarte. Volvamos a cómo se pueden usar estos códigos. Si quieres representar una aplicación básica italiana, todo lo que necesitas es el código del lenguaje. Si, por otra parte, quieres representar el italiano usado en Suiza, tendrás que indicar que el país es Suiza (si, el código del país es "CH"), y el lenguaje italiano también:


Página 207


2012

El uso de estos dos Locale en una fecha nos daría una salida como esta:

sabato 1 ottobre 2005 sabato, 1. ottobre 2005 Ahora pongámoslo todo junto en algún código que cree un objeto Calendar Calendar,, seleccionemos su fecha y convirtámoslo a Date Date.. Después tomaremos el objeto Date y lo imprimiremos usando locales de todo el mundo:

Esto nos da: US 12/14/10 3:32 PM US full Sunday, December 14, 2010 Italy domenica 14 dicembre 2010 Portugal Domingo, 14 de Dezembro de 2010 Brazil Domingo, 14 de Dezembro de 2010 India ??????, ?? ??????, ???? Japan 2010?12?14?


Página 208


2012

Ops... nuestra maquina no está configurada para soportar locales de la India o Japón, pero como puedes ver que un solo objeto Date puede ser formateado para trabajar con muchos locales. Hay un par de métodos en Locale (getDispayCountry() getDispayCountry() y y getDisplayLanguage() getDisplayLanguage())) que tendrías que conocer. Estos métodos te permiten crear cadenas que representan los Locale dados y el lenguaje en términos de Locale por defecto y cualquier otro Locale Locale::

da como resultado: def loc def loc D>I

Brazil Brasil Danish dansk danese

Dado que nuestra Locale de la JVM (por defecto la que es nuestra) es US, por defecto para Brasil es "Brazil", y por defecto para el danés es "Danish". En Brasil, el país se llama "Brasil", y en Dinamarca la lengua se llama "dansk". Para terminar, solo por diversión, hemos descubierto que en Italia, la lengua danesa se la llama "danese".

Por cuenta propia he comprimido este apartado en un pequeño codigo, donde se usa a excepcion de Calendar , todo lo expuesto aquí:


Página 209


2012

lo que arroja: Date.getTime(): 1317143180202 Date.toString(): Tue Sep 27 19:06:20 CEST 2011 DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.LONG).format(d): martes 27 de septiembre de 2011 19:06:20 CEST Fecha tomada: Tue Sep 27 18:29:12 CEST 2011 La fecha en italiano: martedì 27 settembre 2011 19.06.20 CEST

17.6 La clase NumberFormat Esta clase al igual que DateFormat DateFormat,, es abstracta, así que lo normal es que uses algunas de las ocho versiones de getInstance() o getCurrencyInstance() getCurrencyInstance() para para crear un NumberFormat NumberFormat.. No te sorprendas, el uso de esta clase es para dar formato a los números o a los valores de moneda:


Página 210


2012

Que da la salida: 123.457 123,457 $123.46 123,46 ?

Al igual que con DateFormat DateFormat,, NumberFormat también tiene su pequeña prueba :

lo que arroja: Numero en formato fo rmato español: español : 123,456 Enseñando el simbolo de la moneda: 123,46 €

No te preocupes si al igual que nosotros, no se te aparecen los símbolos de los francos, libras, rupias, baht o dragmas. No se espera que conozcas los símbolos usados para las monedas. Aquí va un pequeño código que usa getMaximumFractionDigits(),, setMaximumFractionDigits() getMaximumFractionDigits() setMaximumFractionDigits(),, parse() parse() y y setParseIntegerOnly() setParseIntegerOnly()::


Página 211


2012

que da como resultado: 3 123.457 123.45678 1234.567 1234

Fíjate que en este caso, el numero inicial de los dígitos de la fracción por defecto en NumberFormat es tres, y que format() que format() redondea el valor de f1 f1,, no lo trunca. Después nf cambia cambia los dígitos de la fracción, el valor es el de f1 f1,, el que se muestra. Luego, fíjate que parse() parse() debe ejecutarse en un try try--catch catch y que el método setParseIntegerOnly() setParseIntegerOnly() toma toma un valor booleano y en este caso, causa llamadas subsecuentes a parse() para devolver únicamente la parte entera de la cadena formateada de números de coma flotante. Tal como hemos visto, este objetivo cubre varias clases abstractas. Además, para todas esas cases, la clave de la funcionalidad para cada instancia está establecida en el tiempo de creación. La siguiente tabla resume los constructores o métodos usados para crear las instancias de todas las clases que hemos visto en esta sección:


Página 212



2012

Página 213


2012

Tema 18 Parseado, tokens y formateado Vamos a empezar con otra descarga de responsabilidad: Esta pequeña sección no va a transformarte de novato a gurú. En esta sección vamos a ver tres ideas básicas: 





Buscando texto. texto. Tienes cantidades enormes de texto, quizás leyendo un archivo o escrito en pantalla. En cualquier caso necesitas encontrar de forma fácil algún texto en el montón. Usaremos java.regex.Matcher Usaremos java.regex.Matcher y y java.util.Scanner java.util.Scanner para encontrar texto. Buscando tokens. Tienes un fichero al que quieres sacarle los datos. Quieres transformar un pedazo de texto como "1500.00,343.77,123.4 " 1500.00,343.77,123.4"" en varios números decimales. Te enseñaremos a usar String.split() String.split() y y java.util.Scanner java.util.Scanner para tokenizar tus datos. Formateando texto. Has texto. Has conseguido un reporte y necesitas tomar en una variable el valor de 32500.000f y transformarlo a una cadena con el valor de "$32,500.00 " $32,500.00". ". Te presentaremos a la clase java.util.Formatter clase java.util.Formatter y y los métodos printf() printf() y y format() format()..

18.1 Un tutorial de búsqueda. Tanto si estás buscando texto o tokens, hay un montón de conceptos iguales, así que vamos a empezar con algunos básicos. No importa que lenguaje estés usando, más tarde o más temprano, probablemente tendrás que encarar la necesidad de buscar entre una ingente cantidad de texto usando algunas de las herramientas específicas. Las expresiones regulares son una clase en el lenguaje diseñada para ayudar a los programadores en las tareas de búsqueda. Cada lenguaje provee de sus motores regex regex.. Los motores regex buscan a través del texto usando instrucciones que son codificadas en expresiones. Una expresión regex es como un programa muy corto o un script. Cuando invoques al motor regex, pasarás un pedazo de texto que quieres procesar (en Java es normalmente una cadena o un stream) y una expresión que quieras usar para buscar a través de los datos. Es divertido pensar que regex sea un lenguaje, y nos referiremos a el en toda la sección. El lenguaje regex se usa para crear expresiones, y como vamos a ver en esta sección, si hablamos de expresiones o sintaxis de expresiones, estamos hablando del lenguaje regex. Ah, un pliego de descargo más, sabemos que pueden presentarse geniales expresiones de regex que las que vamos a presentar. Ten en cuenta que estamos creando estas expresiones solo usando una porción del total de las expresiones que tiene regex. Gracias.


Página 214


2012

18.1.1 Búsquedas simples Para nuestro primer ejemplo, nos gustaría buscar a través de la siguiente fuente:

todas las concurrencias de la expresión:

En todas estas discusiones asumiremos que nuestros datos empiezan con el index cero, asi que aplicando el index a nuestra cadena tenemos:

Podemos ver que tenemos dos concurrencias de la expresión ab ab,, una empezando en la posición cero y la otra en la posición 4. Si enviamos el siguiente dato y la expresión a un motor regex, nos devolvería que ha encontrado concurrencias en las posiciones 0 y 4:

lo que da 0 4

No vamos a explicar el código ahora mismo. En unas pocas páginas te enseñaremos un montón de código regex, pero primero queremos presentarte más sintaxis sobre regex. Una vez que entiendas un poco más de regex, los códigos de ejemplo tendrán mas sentido. Aquí hay un ejemplo más complicado:

Cuantas concurrencias encontramos en este caso? Bien, claramente en la posición 0 hay una, y otra en la posición 4. Pero y la posición 2? En el mundo de regex, la cadena aba que empieza en la posición 2 no será considerada una concurrencia valida.


Página 215


2012

La primera regla de búsqueda de regex es que: una búsqueda comienza desde la izquierda a la derecha y una vez que encuentra un concurrencia, sus caracteres no pueden ser usados en otra concurrencia. Así que en nuestro ejemplo anterior, la primera concurrencia usada en las posiciones 0, 1 y 2 no puede usarse nuevamente estas posiciones para otra concurrencia. Así que la siguiente concurrencia valida se encuentra en el índice 4. Esta es la manera normal en la que un motor regex funciona. Sin embargo, en pocas páginas veremos una excepción a esta regla.

Este código lo hice para buscar la palabra "admin "admin"" en el chat.log del servidor:


Página 216


2012

lo que arroja: Linea: 9435 Texto: [23 Mar 1:09:32] SHOUT [WiSe] con vosotros??? creo que les esta saliendo caro a los admins... Linea: 9475 Texto: [23 Mar 1:13:59] SHOUT [WiSe] lo de donar via sms se lo planteare a los admins ... ... ... El chat contiene 1.269.476 lineas. Tiempo empleado: 4.532 milisegundos.

Es posible que despues de leer el chat.log se os quiten las ganas de seguir pagando los costes del servidor xDDD Así que hemos encontrado un par de coincidencias, pero que pasa si queríamos encontrar algo mas dinámico? Por ejemplo, que tal si queríamos encontrar todas las concurrencias de números hexadecimales o códigos de distritos postales?

18.1.2 Búsqueda usando metacaracteres Regex tiene un poderoso mecanismo para los casos descritos arriba. En el corazón de este mecanismo la idea es el uso de metacaracteres. Como un ejemplo simple, digamos que queremos buscar algunos datos en todas las concurrencias de números. En regex, la siguiente expresión se usa para buscar números:

Si cambiamos el programa anterior y le aplicamos la expresión \d expresión \d a a la siguiente cadena:

regex nos va a decir que ha encontrado dígitos en las posiciones 1, 2, 4, 6, 7 y 8. (Si quieres intentar esto en casa, necesitaras escapar el método \d \d,, o sea, dejarlo asi, \\d \\d,, veremos más en breve). Regex provee de un rico surtido de metacaracteres que puedes encontrar descritos en la documentación del API de java.util.regex.Pattern. No vamos a discutirlos todos ahora, sólo los más importantes:   

\d un digito \s un espacio en blanco (carácter ASCII 32) \w un carácter de tipo palabra ( letras letras,, números números y y _ _ ) )

Así que en ejemplo:


Página 217


2012

regex devolverá las posiciones 0, 2 ,4, 5, 7 y 8. El único carácter en este listado que no encaja con la definición de palabra son los espacios en blanco. Atención, date cuenta en este ejemplo que hemos encerrado el listado entre comillas para indicar que no había espacios en blanco al principio ni al final de la cadena. También puedes especificar una serie de caracteres para buscar usando los corchetes y el rango de caracteres a buscar y un guión:

Además, puedes buscar a través de un rango de una sola vez. La siguiente expresión busca concurrencias en el rango a hasta la f , o A hasta la F, y no está combinando búsquedas fA búsquedas fA::

Así que por ejemplo:

devuelve las posiciones 0, 1, 4, 5, 6 Además de lo descrito, también puedes aplicar los siguientes atributos para seleccionar y dar rango con los corchetes:   

^ para negar el carácter especificado. corchetes anidados para crear una unión de selecciones. && para especificar la inserción de selecciones.

Por cuenta propia he ido a copiar unos ejemplos de dicho API:

Puedes ir a echar un vistazo clicando aquí. e m a i l : b r u j u l a t o @ y ah o o . e s

Página 218


2012

18.1.3 Búsqueda usando cuantificadores Digamos que queremos crear un patrón regex para buscar hexadecimales literales. Como primer paso, tenemos que resolver el problema de los dígitos hexadecimales:

regex devolvería 6 y 11 11.. Fíjate que 0x 0x y y 0xg 0xg no no son números hexadecimales válidos. Como segundo paso, pensemos en otro problema más fácil. Qué pasa si queremos que regex encuentre concurrencias de enteros? Los enteros pueden tener uno o más dígitos en una expresión. Hay una serie de constructores de regex llamados cuantificadores, que nos permite especificar conceptos como "uno "uno o más". más". En efecto, los cuantificadores que representan " uno o más" más" es el carácter "+ "+". Veremos el resto en breve. El otro problema que aparece es que cuando estamos buscando algo de una longitud variable, conseguir solo una posición como valor devuelto tiene una utilidad limitada. Así, además de devolver los valores de índice, otro poco de información que el motor de regex ofrece es el grupo de concurrencias completo de lo que encuentra. Vamos a cambiar la manera en la que hablamos sobre lo que devuelve regex especificando cada return o cada nueva línea, recordando que ahora, en cada devolución de regex vamos a volver a la posición inicial después del grupo concurrente:

Esta expresión se lee como "Encuentra " Encuentra uno o más dígitos por columna". columna". Lo que produce: 0 1 3 12 6 234

Puedes leer esto como "En " En la posición 0 hay un entero con valor 1, luego en la posición 3 hay un entero con valor 12, en la posición 6 hay un entero con valor 234 ". Volviendo ahora con el problema hexadecimal, la última cosa que necesitamos saber es como especificar el uso de cuantificadores para una sola parte de la expresión. En este caso debemos tener exactamente una concurrencia de 0x 0x ó ó 0X pero podemos encontrar ilimitadas concurrencias de dígitos hexadecimales. La siguiente expresión añade paréntesis al límite del cuantificador "+ "+" solo para dígitos hexadecimales:

El paréntesis y el mas de la expresión se lee como " Una vez que hayamos encontrado nuestro 0x o 0X, podemos encontrar una o más concurrencias de dígitos hexadecimales." hexadecimales. " Date cuenta del cuantificador "+ "+" al final de la expresión. Es útil pensar que los cuantificadores siempre cuantifican la parte de la expresión que les precede.


Página 219


2012

Los otros cuantificadores que vamos a mirar son:  

* Ninguna o más concurrencias ? Ninguna o una concurrencia

Digamos que tienes un texto que contiene un delimitador coma para una lista de nombres en un directorio que contiene unos proyectos muy importantes. (O por otra parte, estamos usando nuestros directorios ^^). Quieres crear una lista de todos los ficheros cuyo nombre comiencen con proj1 proj1.. Puedes descubrir ficheros .txt .txt,, .java .java,, .pdf ... ... quién sabe? Qué clase de expresión regex podríamos crear para encontrar estos ficheros? Primero echemos un vistazo a la parte del texto que podría aparecer:

Para resolver este problema vamos a usar el carácter ^ que hemos mencionado antes. El operador regex ^ nos ayudará a crear una solución elegante y limpia a nuestro nuestro problema. El símbolo ^ indica negación. Por ejemplo, si quieres encontrar cualquier cosa exceptuando aes aes,, bes bes y y ces en tus ficheros, podrías poner:

Así, que armados con el operador ^ y * (cero o más) vamos a crear lo siguiente:

Si aplicamos esta expresion a la expresion listada arriba, regex devolveria: 10 proj1sched.pdf 25 proj1 37 proj1.java

La clave de esta expresión es "dame " dame cero o más caracteres que no usen una coma". coma ". El ultimo cuantificador del ejemplo es ? (cero o uno). Digamos que en nuestro trabajo esta vez toca buscar un fichero de texto y cualquier cosa que pueda ser local, un número de teléfono de 7 dígitos. Digamos, arbitrariamente, que si encontramos siete dígitos en una columna o tres dígitos seguidos de un guion, o un espacio seguido de 4 dígitos, que tenemos un candidato. Aquí hay un ejemplo de números de teléfonos validos:

La clave para crear esta expresión es ver que necesitamos "cero " cero o una instancia de un espacio o un guión" guión" en medio de nuestros dígitos:


Página 220


2012

18.1.3.1 El punto predeterminado

Además de \s \s,, \d \d y y \w \w,, también tenemos que conocer ". " .". Cuando veas este carácter en una expresión regex, quiere decir que "cualquier " cualquier carácter puede servir aquí ". ". Por ejemplo, el siguiente ejemplo:

dará como salida: 3 abc 7 a c

El punto hizo posible la concurrencia de que la b y el espacio estuvieran exentos de ser rechazados en el patrón "a " a lo que sea c".

18.1.3.2 Cuantificadores codiciosos

Cuando usas el *, + y ?, puedes afinarlos un poco para producir un comportamiento conocido como "codicioso "codicioso", ", "renuente "renuente", ", o "posesivo "posesivo". ". Aunque necesitarás entender sólo el cuantificador "codicioso", también vamos a explicar los cuantificadores "renuente " renuente"" para servir como base de comparación. Primero la sintaxis:   

? es codicioso, ?? ?? es es renuente, para ninguna o una concurrencia. * es codicioso, *? es renuente, para ninguna o más concurrencias. + es codicioso, +? +? es es renuente, para una o más m ás concurrencias.

Qué pasa cuando tenemos el siguiente patrón? patró n?

Lo primero de todo, vamos a hacer algo un poco distinto aquí buscando caracteres con el prefijo estático (xx) de la expresión. Nosotros pensamos que estamos diciendo algo como "Encuentra una serie de caracteres que terminen con xx". xx ". Después te diremos que pasa, al menos queremos que consideres que hay dos posibles resultados, puedes encontrarlos? Recuerda que te dijimos antes que en general, el motor regex trabaja desde la izquierda a la derecha, y no cuenta los caracteres consumidos para la siguiente coincidencia. Así, que trabajando de izquierda a derecha, podemos predecir que el motor debería de buscar los primeros 4 caracteres (0-3), encontrar xx al principio en la posición 2, y tener su primera coincidencia. Después debería encontrar la siguiente coincidencia en la posición 6. Esto nos lleva a que el resultado sería:


Página 221


2012

Un posible segundo argumento es que pedimos una serie de caracteres que terminen con xx, podríamos obtener un resultado como este: 0 yyxxxyxx

A esto lo llamamos codicia. Para que la segunda respuesta sea correcta, el motor regex tendría que buscar en toda la fuente de datos para determinar el final. Así, que el segundo resultado es correcto porque en el ejemplo usamos un cuantificador codicioso. El resultado que encuentra dos selecciones que pueden ser generadas usando el cuantificador renuente:

que da como resultado: 0 yyxxxyxx

Si cambiamos el patrón a:

estamos usando el cuantificador renuente *? *? y y obtenemos: 0 yyxx 4 xyxx

Los cuantificadores codiciosos leen toda la fuente de datos, y luego comienzan el trabajo desde el final (de derecha a izquierda) hasta que encuentra la concurrencia más a la derecha. En este punto, incluye todo desde el principio del dato fuente hasta el dato concurrente más a la derecha.

18.1.4 Cuando los metacaracteres y las cadenas colisionan Hasta ahora hemos hablado de regex desde una perspectiva teórica. Antes de ponernos a trabajar con regex tenemos que explicar un punto más. Cuando vamos a implementar nuestro código regex, es bastante común que nuestro dato fuente o nuestras expresiones sean guardadas en cadenas. El problema es que los metacaracteres y las cadenas no se mezclan bien. Por ejemplo, digamos que queremos hacer un patrón sencillo que busque dígitos. Podríamos intentar algo como esto:

Esta línea de código no compilará! El compilador ve \ y piensa que es una secuencia de escape, "quizás haya un salto de línea". Pero no, lo que viene es una d y el compilador dice "Jamás he oído de una secuencia de escape d". La manera de satisfacer al compilador es añadir otra barra antes de \d \d..


Página 222


2012

La primera barra invertida le dice al compilador que lo que sea que venga luego deberá ser tomado literalmente, no como una secuencia de escape. Y que pasa con el metacarácter . (punto)? Si queremos un punto como metacarácter en nuestra expresión, no hay problema, pero si estás leyendo algún dato que tenga puntos como delimitadores, se haría de la misma manera. Esto sería una serie de opciones o pciones posibles:

Un problema similar ocurre cuando un metacarácter se introduce a mano como argumento en la línea de comandos. Si quieres pasar un \d \d en en tu programa Java, nuestra JVM hará las cosas bien si le decimos:

Pero tu JVM puede que no. Si tienes problemas para ejecutar los ejemplos, intenta probar añadiendo la segunda barra invertida en la línea de comandos. El lenguaje Java define varias secuencias de escape, incluyendo:   

\n retorno de carro \b espacio \t tabulación

Llegados a este punto, hemos aprendido suficiente sobre el lenguaje regex para empezar a usarlo en nuestros programas Java. Comencemos mirando el uso de las expresiones regex para encontrar datos, y luego iremos a ver tópicos relacionados con el token.

18.1.5 Localizando datos por concurrencias en el patrón Una vez que sepas un poquito de regex, usar Pattern y Matcher es bastante fácil. La clase Pattern se usa para guardar la expresión regex regex,, así que puede ser usada y reusada por instancias de la clase Matcher Matcher.. La clase Matcher se usa para invocar al motor regex regex con la intención de ejecutar las operaciones de concurrencias. El siguiente programa muestra a Pattern y Matcher en acción, y no es mala idea de que hagas tus propios experimentos con regex regex::


Página 223


2012

Este programa usa la línea de argumentos para representar representar la expresión que quieres usar en regex, y el segundo argumento es la fuente que quieres buscar. Aquí hay un ejemplo:

da la siguiente salida: Pattern is \d\w 4 56 7 7a

Recuerda que si quieres usar esta expresión representada en una cadena, tienes que usar la doble barra (\\ (\\). ). Ya que a menudo tendrás caracteres especiales o espacios en blanco como parte de tus argumentes, probablemente vas a querer encerrar estos caracteres entre comillas. Echemos un vistazo a este código en más detalle. Primero de todo, fíjate que no estamos usando new new para para crear un Pattern Pattern,, si miras la API, veras que no hay constructores listados. Usarás el método estático sobrecargado compile() compile() (que (que toma expresiones de cadena) para crear instancias de Pattern Pattern.. Necesitarás saber cómo crear un Matcher Matcher,, que se usa para tomar los datos fuente (Pattern ( Pattern.matcher() .matcher()). ). Un método importante en este programa es find() es find().. Este es el método que manipula el motor regex regex y ejecuta las búsquedas. El método find() find() devuelve devuelve true true si hay coincidencias, y acuérdate de cuál es la posición de comienza en la búsqueda. Si find() find() devuelve devuelve true true,, puedes llamar a start() start() para obtener la posición de la coincidencia, y puedes llamar a group() group() para para obtener la cadena que representa el trozo de dato de la coincidencia. Una razón muy común para usar regex es para hacer búsquedas y reemplazos. Deberías de saber que Matcher provee de métodos para ejecutar reemplazos. Puedes mirar las API de appendReplacement(),, appendTail() appendReplacement() appendTail(),, y replaceAll() para más detalle. La clase Matcher te permite buscar subsecuencias en el dato fuente usando un concepto llamado región. En la vida real, las regiones pueden dotar de mayor rendimiento al programa.


Página 224


2012

18.1.5 Usando Scanner para hacer búsquedas Aunque la clase java.util. clase java.util.Scanner Scanner está pensada para tokenizar datos (lo veremos en seguida), también se puede usar para encontrar cosas, igual que Pattern y Matcher Matcher.. Mientras que Scanner no provee de información sobre donde se encuentra lo que se busca, ni funciones de reemplazo, puedes usarlo para aplicar las expresiones regex al dato fuente para decirle cuantas instancias de una expresión existen en una pieza de dato dada. El siguiente programa usa la línea de comandos como expresión regex, luego pide los datos usando System.in System.in.. Muestra un mensaje cada vez que encuentra una coincidencia:

La invocación y el input: java ScanIn "\d\d" input: 1b2c335f456

dan el siguiente resultado: found 33 found 45 found null

18.2 Tokenizando Tokenizar es un proceso de coger grandes piezas de datos y separarlo en pequeñas piezas, y guardar esas piececitas en variables. Probablemente lo más común es tokenizar un fichero para obtener el contenido del fichero y guardarlo en sitios útiles, como objetos, arrays o colecciones. Veremos las dos clases en el API que provee la tokenización: String (usando el método split() split())) y Scanner Scanner,, que tiene muchos métodos muy útiles para tokenizar.

Tokens y delimitadores Cuando hablamos de tokenizar, estamos diciendo que los datos están compuestos de dos cosas, de tokens y delimitadores. Los tokens son en efecto piezas de dato, y los delimitadores son expresiones que separan esos tokens unos de otros. Cuando la mayoría de la gente piensa e m a i l : b r u j u l a t o @ y ah o o . e s

Página 225


2012

en delimitadores, creen que son caracteres simples, como las comas o las barras, o el espacio. De hecho, ciertamente esos son delimitadores muy comunes, pero estrictamente hablando, pueden ser mucho más dinámicos. Como hemos puntualizando antes hace unas frases, los delimitadores pueden ser cualquier cosa que cualifique una expresión regex. Cojamos una pieza de los datos fuente y vamos a tokenizarla usando un par de delimitadores distintos: source: "ab,cd5b,6x,z4" Si decimos que nuestro delimitador es una coma, entonces nuestros cuatro tokens podrían ser: ab cd5b 6x z4 Pero si en lugar de la coma, usamos \d usamos \d,, entonces obtendremos tres tokens: ab,cd b, x,z Recuerda que la \d \d significa significa digito. Por lo general, cuando tokenizamos un dato fuente, los delimitadores se descartan, y todo lo que nos queda son los tokens, así que en el segundo ejemplo, al definir dígitos como tokens, 5,6 y 4 no aparecen en los tokens.

18.2.1 Tokenizando con String String.split() .split() El método de la clase String String,, split() split(),, toma como expresión su argumento, y devuelve un array de String con los tokens. Se usa para tokenizar datos realmente pequeños. El siguiente programa usa args[0] para contener el dato fuente, y args[1] para contener el patrón regex que usa como delimitador:

Todo ocurre de una sola vez cuando el método split() split() se se invoca. La fuente String String se se divide en piezas, y las piezas se cargan un array de String String por por tokens. Todo el código es para demostrar que la operación de split se ha realizado. La siguiente invocación: % java SplitTest "ab5 ccc 45 @" "\d"


Página 226


2012

da como resultado: count 4 >ab< > ccc < >< > @<

(Nota: Recuerda que para representar \ representar \ en una cadena, necesitas usar la secuencia de escape \\ \\.. Por esto, y dependiendo de tu sistema operativo, tu segundo argumento podría ser \\d \\d o o incluso \\\\d incluso \\\\d.) .) Hemos puesto los tokens entre > < para < para mostrar los espacios en blanco. Fíjate que cada dígito fue usado como delimitador, y que los dígitos contiguos creados tienen un token vacío. Un motivo más para usar String String.split() .split() es que a menudo querrás mirar que es lo que producen los tokens, y posiblemente pares la operación de tokenización prematuramente cuando tengas la cantidad de tokens que necesites. Por ejemplo, podrías buscar en un fichero números de teléfono. Si el número aparece pronto en el fichero, querrías detener la tokenización. La clase Scanner provee de cantidad de APIs para hacer tokenizaciones al vuelo.

18.2.2 Tokenizando con Scanner La clase java.util.Scanner clase java.util.Scanner es el Cadillac del token. Cuando necesites hacer una tokenización seria, no mires otra cosa que no sea Scanner Scanner,, es perfecta en toda su forma. Además de las capacidades básicas que provee String String.split() .split(),, la clase Scanner ofrece las siguientes características:   

Un Scanner puede construirse usando ficheros, streams o cadenas como fuente. El tokenizado se ejecuta en un bucle del que puedes salir en cualquier momento. Los tokens pueden ser convertidos a sus tipos primitivos automáticamente.

Echemos un vistazo a este programa que demuestra varios métodos de Scanner y sus capacidades. Scanner por defecto usa como delimitador el espacio en blanco. El programa crea dos objetos Scanner Scanner,, s1 s1 que que se itinera con el método next() next() mas mas genérico, que devuelve cada token como una cadena, mientras s2 es analizado con varios métodos especializados next Xxx() (donde Xxx() (donde Xxx Xxx es es el tipo primitivo):


Página 227


2012

Si este programa se invoca con: % java ScanNext "1 true 34 hi"

produce hits ssssibis2

Naturalmente no estamos haciendo nada con los tokens una vez que los tenemos, pero puedes ver que los tokens de s2 s2 se se convierten a sus respectivos primitivos. Como clave aquí, cabe señalar que los métodos nombrados como hasNextXxx() hasNextXxx() evalúan evalúan el siguiente token, pero no lo toman, no hacen más que moverse al siguiente token en el dato fuente. El método nextXxx() nextXxx() tiene tiene dos funciones: consiguen el siguiente token y se mueven al siguiente token. La clase Scanner tiene nextXxx() (por ejemplo nextLong() nextLong())) y tiene hasNextXxx() hasNextXxx() (por (por ejemplo hasNextDouble() hasNextDouble())) para cada tipo primitivo excepto para char char.. Además, la clase Scanner usa un useDelimiter() useDelimiter() que te permite seleccionar el delimitador, el cual puede ser cualquier expresión regex valida.


Página 228


2012

18.2.3 Formateando con printf() y format()

Que divertido seria que las cuentas de cobro no tuvieran punto decimal, o los números negativos sin paréntesis! Los métodos format() métodos format() y printf() fueron añadidos a java.oi.PrintStream a java.oi.PrintStream en Java 5. Estos dos métodos se comportan de manera idéntica, así que cualquier cosa que digamos de estos métodos se aplicara a los dos. (Corren rumores de que Java añadió printf() solo para hacer a los programadores de C más felices). Detrás del escenario, el método format() usa la clase java.util.Formatter para hacer el trabajo duro. Puedes usar la clase Formatter directamente si quieres. La documentación para estos argumentos puedes encontrarlas en el API de Formatter Formatter.. Vamos a hacer una visita panorámica de la sintaxis del formateado, que será más que suficiente para permitirte hacer bastantes formatos básicos. Comencemos por parafrasear la documentación del API para el formato de cadenas (una forma más completa de decirlo, veamos el API de java.util.Formatter):

La cadena puede contener información literal no asociada a ningún argumento, y datos como argumento específico para formatear. La clave está en determinar si estás buscando formatear algún dato, el formateo de dato siempre estará precedido del signo %. Veamos un ejemplo, y que no te entre el pánico, cubriremos todo lo que viene después de %:

Esto da: 456 + 123

Veamos lo que ha pasado. Dentro de las comillas dobles hay un formato de cadena, luego un signo + y después otro formato de cadena. Fíjate que hemos mezclado dos literales de formato de cadena. Ahora indaguemos más y miremos la construcción del formato de la cadena:

Los valores entre corchetes son opcionales. En otras palabras, los únicos elementos exigidos para formatear la cadena son el signo % y el carácter a convertir. En el ejemplo anterior sólo los valores opciones que usamos fueron los argumentos para la indexación. El 2$ 2$ representa representa el segundo argumento y el 1$ 1$ representa el primero. Puedes ver que no hay problema en intercambiar el orden de los argumentos. Después de los argumentos, la letra d expresa la conversión del carácter (más o menos el tipo de argumento). Aquí hay una lista de los elementos para formateo de cadena que necesitas saber: arg_index Un Un entero seguido por una $, indica que el argumento debería ser escrito en esta posición.


Página 229


2012

flags Hay flags Hay muchos marcadores disponibles, para el examen tienes que conocer: 









Justifica este argumento a la izquierda + Incluye un signo (+ o -) al argumento 0 Rellena el argumento con ceros , Se usa para separar los números con comas (ejemplo 1,000) ( Encierra los números negativos entre paréntesis

width Este valor indica la cantidad de caracteres mínima para imprimir (si quieres que tus width numeros encajen en columnas, usaras esto masivamente). precision Para el examen solo necesitaras esto cuando el formateo contenga un numero de precision Para coma flotante, la precisión indicia el número de dígitos decimales que se va a mostrar. conversion Al conversion Al tipo de argumento que sera formateado. Necesitaras saber:     

b boolean c char d integer f flotante flotante s string

Veamos algunos de estos formatos de cadena en acción:

Esto da: > (123)< >012,345< >+12345 < >false + -123<

Hemos añadido > < para < para ayudarnos a ver el ancho, el alineamiento y el relleno con ceros. Finalmente es importante recordar que si tienes algún error de comillado conseguirás una excepción en tiempo de ejecución:


Página 230


2012

Producirá algo como: Exception in thread "main" java.util.IllegalFormatConversionException: d != java.lang.Double


Página 231


2012

19.1 Métodos de Object Cualquier objeto de Java posee estos métodos, heredados de Object Object..

En este capítulo veremos hashCode() hashCode(),, equals() equals() y y toString() toString().. Sobrescribiremos estos métodos para nuestra conveniencia, que serán resumidas en seguida.

19.1.1 El método toString() Sobrescribe toString() cuando quieras que un mero mortal sea capaz de leer algo con significado sobre los objetos de tu clase. El código puede llamar al método toString() de tu objeto cuando quiera leer detalles útiles sobre el objeto. Por ejemplo, cuando pasas la referencia del objeto al método System.out.println() System.out.println(),, se invoca el método toString() del objeto, y en este ejemplo se muestra la devolución:

lo que devuelve un encantador y significativo: % java HardToRead HardToRead@a47e0

La salida que obtienes cuando no sobrescribes el método toString() del objeto es esta. Devuelve el nombre de la clase (al menos eso es significativo) seguido del símbolo @, seguido por un numero hexadecimal sin signo en representación del hashCode. Intentar leer esta salida puede motivarte a sobrescribir toString() toString() en en tu clase, por ejemplo:


Página 232


2012

Esto puede ser algo más legible: % java BobTest I am a Bob, but you can call me GoBobGo. My shoe size is 19

Algunas personas se dirigen de manera afectuosa a toString() toString() como como "el método que derrama las entrañas" porque la mayoría de las implementaciones a toString() toString() simplemente simplemente dividen el estado del objeto, en otras palabras, los valores actuales de la instancia. Esto es todo para toString() toString().. Ahora vayamos a por equals() equals() y y hashCode() hashCode()..

19.1.2 Sobrescritura de equals() Has visto en capitulo anteriores el método equals() equals(),, donde vimos cómo funcionaba con las clases envoltorio. Hemos visto como se comparan dos referencias a objetos usando el operador == == que que evalúa a true sólo cuando ambas referencias se refieren al mismo objeto ( porque == == solo solo comprueba los bits en la variable, y verifica si son idénticos o no). Viste que la clase String y las clases envoltorio tienen un método equals() equals() sobrescrito (heredado de la clase Object Object), ), así que puedes comparar dos objetos distintos (del mismo tipo) para ver si sus contenidos son significativos equivalentes (es decir, mismo tipo, distinto objeto). Si dos instancias Integer contienen el número 5, hasta ahora, ellos son iguales (equals ( equals). ). El hecho es que el valor 5 vive en dos objetos distintos y eso, no importa. Cuando quieras realmente saber si dos referencias son idénticas, tienes que usar ==. ==. Pero Pero cuando sólo quieres saber si los objetos en sí mismos (no sus referencias) son iguales, entonces tienes que usar equals() equals().. En cada clase que escribes debes decidir si tiene sentido considerar dos instancias por igual. Para algunas clases, puedes decidir que dos objetos nunca podrían ser iguales. Por ejemplo, imagina una clase Coche Coche que que tiene variables de instancia para cosas como modelo, año, configuracion... realmente no quieres que tu coche de repente sea tratado como el coche de cualquiera. Tu coche es tu coche y no quieres que tu vecino Pepe lo conduzca porque, "oye! es realmente el mismo coche, el método equals() equals() dice dice que sí". Así que dos coches no deberían de ser consideradas la misma cosa. Si dos referencias se refieren a


Página 233


2012

un Coche Coche,, tienes que saber que ambas están hablando de un coche, no de dos coches que tienen los mismos atributos. Así que puedas querer que un Coche Coche no no se use nunca, o quieras sobrescribir el método equals() equals().. Naturalmente, tienes que saber que no es el fin de la historia.

Qué pasa si no sobrescribes equals() Hay una limitación potencial al acecho: si no sobrescribes equals() equals(),, quizás no puedas usar esos objetos como clave en un hashTable y probablemente no puedas precisar Set Set,, así que no habrá duplicados conceptuales. El método equals() equals() en en la clase Object usa solo el operador == == para para las comparaciones, a menos que sobrescribas equals() equals(),, dos objetos son considerados iguales sólo si las dos referencias apuntan al mismo objeto. Veamos lo que significa no poder usar un objeto con su hashTable como clave. Imagina que tienes un coche, un coche muy específico (digamos, que el coche rojo de John es un Subaru, todo lo contrario al coche de Mary, que es un Mini purpura) y quieres ponerlo en un HashMap (un tipo de hashTable que veremos en este capítulo), así que puedes buscar un coche en particular y dárselo al objeto Persona Persona correspondiente, correspondiente, que representa al propietario. Así que añades la instancia del coche como clave para el HashMap (junto con el valor del objeto Persona Persona correspondiente). correspondiente). Pero ahora lo que ocurre cuando quieres hacer la búsqueda. Quieres decirle a HashMap "Aquí está el coche, ahora dame a la persona que va con este coche". Pero ahora tienes un problema, a menos que aun conserves la referencia exacta del objeto que usaste como clave cuando lo añadiste a la Collection Collection.. En otras palabras, no puedes crear un coche idéntico y usarlo para una búsqueda. Al final de la línea queda esto: si quieres objetos que tu clase pueda usar como clave para un hashTable (o como elementos en cualquier estructura de datos que use la misma equivalencia para hacer búsquedas y/o obtener un objeto), entonces tienes que sobrescribir equals() equals(),, de manera que dos instancias distintas pueden ser consideradas la misma. Así que como arreglamos el coche? Tienes que sobrescribir equals() equals() de manera que tenga un único VIN (Vehículo Identificación Número) como comparación básica. De esa manera, puedes usar una instancia cuando quieras añadirla a la Collection Collection,, y esencialmente, recrear una instancia idéntica cuando quieras hacer una búsqueda basada en la clave de los objetos. Naturalmente, la sobrescritura de equals() equals() para para Coche Coche también te permite potencial para que más de un objeto que representa un único Coche Coche pueda pueda existir, lo cual puede ser no muy seguro en tu diseño. Afortunadamente, las clases String y de envoltorio funcionan bien como claves en hashTable -sobrescriben el método equals() equals().. Así que más que usar la actual instancia de Coche como Coche como clave en pares coche/dueño, podrías simplemente usar un String que represente el único identificador para el coche. De esta manera, nunca tendrás más de una instancia representando a un coche especifico, pero puedes usar el coche, o uno de los atributos del coche como clave.


Página 234


2012

Implementado en método equals() método equals() Digamos que decides sobrescribir equals() equals() en en tu clase. Puede parecerse a esto:

Veamos este código en detalle. En el método main() main() de de EqualTest EqualTest,, hemos creado dos instancias de Moof , pasándole el mismo valor, 8, al constructor de Moof . Ahora miremos a la clase Moof y y veamos que hace constructor con el argumento, le asigna el valor de moofValue moofValue a a la variable de instancia. Ahora imagina que has decidido que dos objetos Moof sean sean iguales si sus valores son idénticos. Sobrescribes el método equals() equals() y y comparas los dos moofValues moofValues.. Es simple. Pero veamos que pasa en el método equals() equals()::

Lo principal de todo, tienes que seguir las reglas de la sobrescritura, y en la línea 1 ciertamente estamos declarando una sobrescritura válida para el método equals() que heredamos de Object Object.. En la línea 2 es donde está la acción. Lógicamente tenemos que hacer dos cosas para crear una comparación de igualdad valida. e m a i l : b r u j u l a t o @ y ah o o . e s

Página 235


2012

Lo primero es asegurarse de que el objeto que está siendo testado es del tipo correcto! Esto viene del polimorfismo, como el tipo Object Object,, así que necesitas hacer que instanceof lo lo testee. Tener dos objetos de diferentes tipos de clase se considera igual, y normalmente no es una buena idea, pero eso es un problema de diseño y no vamos a meternos ahí. Por otra parte, todavía tienes que hacer el instanceof para para asegurarte de que se puede castear el argumento del objeto a un tipo correcto al que puedas acceder por sus métodos o variables para hacer la comparación. Recuerda, si el objeto no pasa el test de instanceof , tendrás en tiempo de ejecución ClassCastException ClassCastException.. Por ejemplo:

El casteo (Moof) fallará si no pasa el test ES-UN. Segundo, tendremos cuidado al comparar los atributos (en este caso, solo el valor de moofValue moofValue). ). Solo el desarrollador puede decidir que hace que dos instancias sean iguales. (Para mejor rendimiento, vas a querer comprobar unos pocos números de atributos.) En caso de que ((Moof)o).getMoofValue()) que ((Moof)o).getMoofValue()) te cogiera por sorpresa, lo único que hicimos fue castear el objeto de referencia, o, de otra manera, llamamos al método que tiene la clase Moof , pero no Object Object.. Recuerda, sin el casteo no podrías compilar porque el compilador vería el objeto referenciado por o como un Object Object.. Y ya que la clase Object no tiene el método moofvalue() moofvalue(),, el compilador podría graznar (término técnico). Pero como dijimos antes, incluso con el casteo, el código fallará en tiempo de ejecución si el objeto referenciado por o no es algo que sea casteable a Moof . Así que nunca olvides usar instanceof en en primer lugar. Aquí hay otra razón por la que apreciar el atajo &&, &&, si si instanceof falla, falla, nunca se ejecutará el código del casteo, así que siempre estaremos a salvo en tiempo de ejecución con lo siguiente:

Así que ten cuidado con equals() equals()... ... Whoa... no tan rápido. Si te fijas en la clase Object Object,, la especificación que encontrarás en el API de Java verás que nosotros hacemos un contrato especificado en el método equal() equal().. Un contrato de Java es una serie de reglas que deberían obedecerse si quieres proveer de una correcta implementación como los otros programadores esperan que lo hagas. O ponlo de otra


Página 236


2012

manera, si no obedeces el contrato, tu código podría compilar y ejecutarse, pero tu código (o el de alguien más) podría romperse en tiempo de ejecución de alguna manera inesperada.

El contrato equals() En resumidas cuentas, Java docs dice:  







Es reflexivo. Para cualquier referencia valor x, x , x.equals(x) x.equals(x) debería debería devolver true true.. Es simétrico. Para cualquier referencia valor x e y, x.equals(y) debería ser true true,, si, y sólo si y.equals(x) y.equals(x) devuelve devuelve true true.. Es transitivo. Para cualquier referencia valor x, y, z, si x.equals(y) x.equals(y) devuelve true true e e y.equals(z) devuelve true true,, entonces x.equals(z) tiene que devolver true true.. Es consistente. Para cualquier referencia valor x, e y, múltiples invocaciones de x.equals(y) devolverán siempre true true,, o devolverán siempre false false,, siempre y cuando no se provea de información en las comparaciones de igualdad del objeto modificado. Para cualquier referencia no null, el valor x.equals(null) debería devolver false false..

Y aún no está todo aquí. No hemos visto el método hashCode() hashCode(),, pero equals() equals() y y hashCode() hashCode() están están obligados por un contrato que especifica que si dos objetos son considerados iguales usando el método equals() equals(),, entonces ellos tienen el mismo valor hashCode(). Así que para estar verdaderamente seguros, tu regla de oro debería ser, que si rescribes equals() equals(),, tienes que rescribir hashCode() hashCode() también. también. Ahora vamos a ver hashCode() hashCode() y y cómo se une al método equals() equals()..

19.1.3 Sobrescritura de hashCode() Los hashCode se usan normalmente para incrementar el rendimiento de grandes colecciones de datos. El valor hashCode hashCode de de un objeto se usa por algunas clases de colecciones col ecciones (veremos las colecciones en este capítulo). Aunque puedas pensar que esto es como la ID ID del del objeto, no es necesariamente, única. Las colecciones tales como HashMap HashMap y y HashSet usan el valor hashCode hashCode del del objeto para determinar cómo se debe almacenar el objeto en la colección, y el hashCode hashCode se se usa otra vez para ayudar a localizar el objeto en la colección. Tienes que saber cuáles de las colecciones las usan (pero, uhm, todos to dos tienen "hash" en el nombre así que estaría bien saber algo mas). Debes ser capaz de reconocer una implementación de hashCode() apropiada o correcta. Esto no significa legal ni siquiera eficiente. Es perfectamente legal tener un método ineficiente de hashCode hashCode en en tu clase, mientras no violes el contrato especificado en la clase Object Object (la (la veremos en un momento).

Entender el hashCode() Para entender que es apropiado y correcto, tenemos que echar un vistazo a como usan las colecciones los hashCode hashCode.. Imagina una seria de cubos alineados en el piso de arriba. Alguien coge un trozo de papel con un nombre. Coge el nombre y calcula el numero entero usando, A es 1, B es 2 y así, y añade el e m a i l : b r u j u l a t o @ y ah o o . e s

Página 237


2012

valor numérico a todas las letras del nombre. El mismo nombre dado siempre dará el mismo código.

No introducimos nada al azar, simplemente tenemos un algoritmo que se ejecutará siempre de la misma manera dada una entrada específica, así que la salida será la misma para dos entradas iguales. Todo bien hasta aquí? Ahora la manera de usar ese código (al que llamaremos hashCode hashCode desde desde ahora) es determinar que en que cubo se va a poner el trozo de papel (imagina que cada cubo representa un código distinto). Ahora imagina que alguien viene y te muestra un nombre y dice "Por favor, saque un trozo de papel que tenga este nombre". Así que miras el nombre que te enseñan, y ejecutas el algoritmo. El hashCode hashCode te te dice en que cubo debería estar ese nombre. Seguro que te habrás dado cuenta que puede haber un fallo en este sistema. Dos nombres diferentes pueden tener el mismo valor, por ejemplo, Amy y May. Son nombres distintos con el mismo hashCode hashCode.. Esto es aceptable, pero significa que cuando alguien te pida la pieza de papel de Amy, aun tienes que buscar los nombres que haya en el cubo hasta que encuentres el nombre. El hashCode hashCode te dice en que cubo está el papel, pero no te dice como localizar el nombre en el cubo.

Así que para más eficiencia, tu meta es tener los papeles distribuidos de manera igualitaria a través de todos los cubos. Lo ideal es que tuvieras un nombre por cubo, así que cuando alguien te pregunte por el papel, sólo tuvieras que realizar el cálculo y coger el papel del cubo correcto (sin tener que estar mirando todos los papeles del cubo). El menos eficiente (pero funcional) generador de hashcode hashcode devolverá devolverá el mismo hashcode (digamos 42) sin importar el nombre, así que todos los papeles estarán en el mismo cubo mientras los otros cubos están vacíos. Una vez en el cubo adecuado, hay que rebuscar entre todos los papeles hasta dar con el papel adecuado. Y así es como funciona, puedes pensar en no usar el hashCode hashCode,, pero entonces el cubo seria aún más grande (en realidad, un único cubo).


Página 238


2012

Esta distribución en cubos es una manera similar a la que el hashCode se usa en las colecciones. Cuando pones un objeto en una colecciones que usa hashCode hashCode,, la colección usa el hashCode hashCode del objeto para decidir en qué cubo debería ir. Luego, cuando quieras coger el objeto (o, el objeto asociado al hashCode hashCode), ), tienes que darle a la colección una referencia del objeto que tiene en la colección. Hasta ahora, el objeto (almacenado en la colección, como el papel en el cubo) que estas intentando buscar se hará por su hashCode hashCode.. Pero... imagina que pasaría si, volviendo a nuestro ejemplo de los nombres en el cubo, te muestran un nombre y calculas el código basándote solo en la mitad de las letras en lugar de en todas ellas. Nunca encontrarías el nombre en el cubo! Ahora puedes ver por qué si dos objetos son considerados iguales, sus hashCode hashCode deben deben ser iguales? De otra manera, no podrías encontrar el objeto ya que el método hashCode hashCode por por defecto de la clase Object Object siempre siempre va a otorgar un único hashCode hashCode a a cada objeto, aunque se sobrescriba equals() de tal manera que dos o más objetos sean considerados iguales. No importa como de iguales sean esos objetos si sus hashCodes hashCodes no no dice que lo son. Así que una vez más: si dos objetos son iguales, sus hashcodes hashcodes tienen tienen que serlo también.

Implementado el hashCode() A qué diablos se parece un algoritmo de hashCode? La gente obtiene sus PhDs con el hasheo algorítmico. La parte que nos concierne aquí es si respetas el contrato. Y al seguir el contrato, tienes que pensar lo que hace el método equals() equals().. Comparas atributos. La comparación casi siempre involucra a variables de instancia (acuérdate cuando vimos los dos objetos Moof y considerados iguales si sus valores moofValues eran el mismo). La implementación de tu hashCode() debería usar las mismas variables de instancia. Por ejemplo:

Este método equals() dice que dos objetos son equivalentes si ellos tienen el mismo valor x, así que los objetos con el mismo valor x tendrán el mismo hashCode.


Página 239


2012

Normalmente, vas a ver los métodos de hashCode en combinación de ^-ing (XOR-ing) usado en sus variables de instancia (en otras palabras, haciendo girar sus bits), y quizás multiplicándolos por un numero primo. En cualquier caso, mientras la meta sea conseguir una amplia cantidad de cubos, el contrato, (no importa si el objeto se encuentra o no) exige solo que la igualdad del objeto tengan el mismo hashCode. No espero que puntúes la eficiencia de un hashCode(), pero tienes que saber reconocer cual va a funcionar y cual no (funcionar significa "podrá ser encontrado el objeto en la colección?"). Ahora que sabemos que dos objetos iguales tienen que tener el mismo hashCode, es lo contrario cierto? Dos objetos con idéntico hashCode tienen que ser considerados igual? Piensa en ello, tener un motón de objetos que entren en el mismo cubo porque sus hashCode son idénticos, pero a menos que pasen el test de equals() equals(),, no se mostrarán en la búsqueda de la colección. Esto es exactamente lo que deberías conseguir con nuestro ineficiente "todo el mundo consigue el mismo hashCode". Es legal y correcto, pero extremadamente lento. Así que para que un objeto sea encontrado, la búsqueda del objeto y el objeto en la colección deben tener idénticos hashCode y devolver true a la igualdad (equal() (equal()). ). Así que no hay manera de sobrescribir ambos métodos para que sea absolutamente cierto que tus objetos puedan ser usados en colecciones usando hash.

El contrato de hashCode() Ahora directo desde los fabulosos docs de API de Java para la clase Object Object,, presentamos (redoble de tambor) el contrato de hashCode() hashCode():: 





Si es invocado en el mismo objeto más de una vez durante una ejecución de una aplicación de Java, el método hashCode() hashCode() debe debe devolver siempre el mismo entero, sin proveer información que modifique el resultado de equals() equals().. Este entero no necesita permanecer constante en la ejecución de una aplicación a otra ejecución de la misma aplicación. Si dos objetos son iguales de acuerdo al método equals() método equals(),, entonces el método hashCode() hashCode() en en cada uno de los dos objetos debe producir el mismo resultado de número entero. Si no se requiere que dos objetos sean no equals() (de acuerdo con equals de java.lang.Object de java.lang.Object), ), entonces la llamada a hashCode() hashCode() en cada uno de los objetos debe producir un resultado distinto. Sin embargo el programador debería hacer que se produjeran distintos resultados para un objeto distinto, de manera que mejorase el rendimiento de hashtable hashtable..

Y esto quiere decir...


Página 240


2012

Ahora veamos que más puede hacer que un método hashCode() hashCode() falle. falle. Qué pasa si incluyes una variable transient en tu hashCode() hashCode()?? Aunque es legal (el compilador no dirá nada), bajo algunas circunstancias el objeto de la colección no va a ser encontrado. Como ya sabes, la serialización guarda un objeto, así que puede ser rescatado más tarde mediante la deserialización. Pero peligro Will Robinson, recuerda que las variables transient transient no no se graban cuando se serializa el objeto. Un mal escenario podría parecerse a esto:

Esto es lo que pasaría usando el ejemplo anterior: 1. 2. 3. 4. 5.

Le da al objeto algún estado (o sea, se asignan los valores a la variable de instancia). Pone el objeto en un HashMap HashMap usando usando el objeto como una clave. Graba el objeto a un fichero usando la serialización sin alterar ninguno de sus estados. Recupera el objeto mediante la deserialización. Usa el objeto deserializado para introducirlo al HashMap HashMap (traído (traído a la vida en el heap heap). ).

Oops. El objeto de la colección y supuestamente el mismo objeto devuelto a la vida no son idénticos. El objeto con la variable transient transient vuelve vuelve con un valor por defecto en lugar del valor del que la variable tenía cuando fue grabado (o puesto en el HashMap HashMap). ). Así que al usar el código SaveMe SaveMe,, si el valor de x era 9 cuando se puso en el HashMap HashMap,, y ya que x se usó para calcular el hashCode hashCode,, cuando el valor de x cambia, el hashCode hashCode lo lo hace también. Y cuando la misma instancia de SaveMe es deserializado, entonces x == 0, 0, no importa el valor que tuviera x cuando el objeto fue serializado. Así que el nuevo cálculo de hashCode da un resultado distinto y el método equals() falla también desde el momento en que se ha usado x para calcular el hashCode hashCode..


Página 241


2012

En último lugar, las variables transient puede enredar bastante el uso de equals() equals() y y hashCode() hashCode().Usa .Usa las variables no transient o, si tienen que estar marcadas como transient transient,, no las uses para determinar la igualdad de un hashCode hashCode..

19.2 Colecciones Imagínate intentando escribir una aplicación orientada a objetos sin usar estructuras de datos como hashTable o listas lincadas. Que harías cuando de verdad necesitases mantener un orden, digamos, todos los miembros que son fan de los Simpsons. Obviamente puedes hacerlo tú mismo, Amazon.com tiene miles de libros con algoritmos que puedes comprar. Pero con la clase de agenda que tienen los lo s programadores hoy, sería bastante doloroso de considerar. Las colecciones de Framework en Java, que se mejoraron en el 1.2 y se expandieron en el 1.4 y de nuevo en el 1.5, te dan listas, selecciones, mapas y colas para satisfacer la mayoría de las necesidades de tu código. Han sido probadas, testadas y ajustadas. Escoge la mejor para tu trabajo y conseguirás, por lo menos, un rendimiento razonable. Y cuando necesites algo un poco más personalizado, las colecciones del Framework en java.util.package en java.util.package tiene interfaces y utilidades.

Así que, que hago con una Collection Collection? ? Hay operaciones básicas que se hacen con una colección:     

Añadir objetos a la colección. Borrar objetos de la colección. Averiguar si un objeto o grupo de objetos existe en la colección. Rescatar ese objeto de la colección (sin borrarlo). Itinerar (recorrer para los de la ESO :p) a través de la colección, mirando cada elemento (un objeto) uno por uno.

Interfaces clave y clases de las colecciones en el Framework Para el examen tienes que conocer que colecciones debes elegir basándote en las exigencias del código. Las APIs de las colecciones comienzan con un grupo de interfaces, pero también te da una gran cantidad de clases concretas. El core de las interfaces que necesitas conocer para trabajar (y para la vida en general) son siete:

El core concreto que necesitas saber para implementar las clases son 13 (hay otras, pero no vamos a verlas):


Página 242


2012

No todas las colecciones del Framework Framework implementan implementan la interfaz Collection Collection.. En otras palabras, no todas las colecciones pasan el test ES-UN para Collection Collection.. Especialmente, ninguna de la clase Map hereda nada de Collection Collection.. Así que SortedMap SortedMap,, HashTable HashTable,, HashMap HashMap,, TreeMap y LinkedHashMap son todas colecciones, y ninguna hereda Collection Collection.. Para hacer las cosas c osas más confusas, hay tres usos sobrecargados de la palabra "collection": 





collection (c collection (c minúscula), representa cualquier estructura de datos en la que los objetos se guardan y se itineran. Collection (C mayúscula), la cual es la interfaz de en java.util. en java.util.Collection Collection,, que Set Set,, List y Queue heredan. (Correcto, heredan, no implementan. No hay implementaciones directas de Collection Collection). ). Collections (C Collections (C mayúscula, termina en s) es la clase de java.util. de java.util.Collections Collections que contiene los métodos estáticos para el uso de las colecciones.


Página 243


2012

Las colecciones vienen en cuatro sabores básicos:    

Lists Lista Lists Lista de cosas (clases (c lases que implementan List List). ). Sets Cosa Sets Cosa única (clases que implementan i mplementan Set Set). ). Maps Cosas Maps Cosas con una única ID ID (clases (clases que implementan Map Map). ). Queues Cosas Queues Cosas ordenadas por orden en la que han sido procesadas.

Este esquema representa la estructura de un List List,, un Set y un Map Map..

HashMap:: el producto de salesman (Claves generados desde las IDs) HashMap Y dentro de estos refrescantes sabores existen otros cuatro sub-sabores para las colecciones.

Una implementación en una clase puede ser unsorted unsorted y y unordered unordered,, ordered ordered y y unsorted unsorted,, o ordered ordered y y sorted sorted.. Pero una implementación no puede ser nunca sorted sorted y y unordered unordered,, porque sorting sorting especifica un tipo de orden, como verás en breve. Por ejemplo, HashSet HashSet es es un unordered unordered y y unsorted unsorted,, mientras que LinkedHashSet LinkedHashSet es es ordered ordered y y unsorted unsorted,, que ordena sus elementos en el orden que van siendo insertados. Quizás podríamos ser más explícitos con las diferencias entre sorted sorted y y ordered ordered,, pero primero vamos a discutir la idea de la iteración.


Página 244


2012

Cuando piensas en iteración, podrías pensar en recorrer los elementos usando un array array,, digamos, un for for que que accediera a cada elemento en orden ([0], [1], [2]...). Iterar a través de una colección significa normalmente, recorrer los elementos uno después de otro, después del primero (de un orden establecido). Algunas veces, incluso el concepto de primer elemento es un poco extraño. En un HashTable no hay noción de primero, segundo, tercero... En un HashTable HashTable,, los elementos están dispuestos en un orden caótico dependiendo de su clave hashCode hashCode.. Pero de alguna manera alguien tiene que ser el primero en ser itinerado. Pero hasta ahora lo que puedes decir, es que es completamente arbitrario y que puede cambiar aparentemente de forma aleatoria en la medida de que la colección vaya cambiando. Ordered Cuando una colección es ordered , quiere decir que puedes recorrerla en un orden específico, no aleatorio. Una colección HashTable no está ordenada. Aunque una HashTable tiene un orden lógico para determinar el orden (basada en los hashCode y la implementación de colección en sí), quizás no querrías encontrar un orden cualquiera cuando recorrieses la HashTable HashTable.. Un ArrayList sin embargo mantiene el orden establecido por la indexación de sus elementos (igual que un array array). ). LinkedHashSet mantiene el orden establecido por inserción, así que el último elemento introducido es el último elemento en un LinkedHashSet (lo contrario a un ArrayList ArrayList,, donde puedes insertar un elemento en cualquier posición del índex índex). ). Finalmente, hay algunas colecciones que mantienen un orden referido al orden natural de los elementos, no son ordered , son de tipo sort . Veamos cómo funciona el orden natural de las colecciones sorted sorted.. Sorted Una colección sorted significa significa que el orden de la colección se determina de acuerdo a unas reglas, conocidas como orden de clasificación. Un clasificación. Un orden de clasificación no tiene nada que ver con el momento en que se añade el objeto a la colección, o cuando fue la última vez a la que se tuvo acceso, o en que posición fue añadido. El añadido. El orden de clasificación es creado en base a las propiedades del objeto. Pones el objeto en la colección y la colección averiguará en qué orden debe ponerlo, basado en su clasificación. Una colección que ocupa un orden (tales como una List List)) no se considera realmente sorted sorted a a menos que mantenga alguna regla para clasificar los objetos. La mayoría de las clasificaciones se hacen usando el llamado orden natural. Y esto que significa? Sabes cuál es el orden alfabético, la A viene primero, luego la B,... etc... Para una colección de objetos String String,, para una colección de objetos con números Integer Integer,, el orden natural seria el 1, luego el 2, etc... Y para los objetos Foo Foo,, el orden natural seria... uhmm... no sé. No existe un orden natural para ordenar Foo Foo a a menos, o hasta que el desarrollador nos de uno, a través de una interfaz llamada Comparable que define como las instancias de una clase c lase deben ser comparadas unas a otras (la instancia a viene después de la b, o quizás la b antes que la a?). Si el desarrollador decide que los objetos Foo sean comparados usando el valor de alguna variable de instancia (digamos que hay una que se llama bar bar), ), entonces el orden de la colección será el que marque las reglas de la clase Foo con su variable de instancia bar bar.. Naturalmente la clase Foo podría heredar el orden natural de una superclase en lugar del que define su propio orden en algunos casos.


Página 245


2012

Aparte de su orden natural especificado en la interfaz Comparable Comparable,, también sería posible definir otra clase de orden con otra interfaz: Comparator Comparator.. Veremos cómo usar Comparable Comparable y y Comparator Comparator para crear ordenes más tarde, en este mismo capítulo. Por ahora, ocupémonos de clasificar y ordenar (incluyendo el orden natural) que no es lo mismo ordenar por inserción, por acceso o por indexación. Ahora que sabemos cómo ordenar y clasificar, veremos cada una de las cuatro interfaces y profundizaremos en la implementación.

List (Interface) (Interface) Para una lista lista tiene tiene importancia el índice. Una cosa que las listas listas tienen tienen que otras no tienen, es una serie de métodos relacionados con el índice. Estos métodos claves incluyen cosas como get(int índex), índex), indexOf(Object o), o), add (int índex, Object obj), obj), etc... Las tres implementaciones de List List ordenan ordenan sus elementos mediante su índice. Una posición la puedes determinar explícitamente, cambiado el valor de su índex o añadiéndolo en una posición especifica; o sin ella, en cuyo caso el objeto es añadido al final. Las tres implementaciones de List se describen en la siguiente sección: ArrayList Imagínatelo como un array array dinámico. dinámico. Te da una rápida iteración y acceso aleatorio. Para ser más obvios, es una colección ordenada (por el índice), pero no clasificada (ordered pero no sorted). Podría interesarte que desde la versión 1.4 se implementó una interface de acceso aleatorio, RandomAccess RandomAccess,, una interfaz marcada marcada (significa (significa que no tiene métodos) que dice "esta lista soporta acceso aleatorio de alta velocidad (normalmente tiempo constante)". Elige esta en vez de LinkedList LinkedList cuando cuando necesites recorrer la colección de manera más rápida, pero no si sueles hacer un montón de inserciones o borrados. Vector Vector es un vestigio de los tiempos más tempranos de Java, Vector y HashTable fueron las dos colecciones originales de Java, y el resto de se fueron implementando con las versiones 1.2 y 1.4 de Java. Un Vector es prácticamente lo mismo que un ArrayList ArrayList,, pero los métodos de un Vector son sincronizados, dando seguridad por hilos. Normalmente querrás usar ArrayList en lugar de Vector ya que los métodos sincronizados desmerecen al rendimiento y podría ser que no los necesitases. Y si lo necesitases, hay métodos en la clase Collection Collection que que pueden ayudar. El Vector es la otra clase además de ArrayList que implementa RandomAccess RandomAccess.. LinkedList Un LinkedList esta ordenado por posición del índex índex,, como ArrayList ArrayList,, excepto que los elementos están doblemente unidos el uno al otro. Este linkage proporciona nuevos métodos (más de los que consigues con la interface List List)) para añadir y borrar desde el principio o el final, lo cual facilita una fácil elección para implementar una pila o una cola. Acuérdate, y no lo olvides, que un LinkedList puede itinerar más lento que un ArrayList ArrayList,, pero es una buena elección cuando necesitas insertar y borrar rápidamente.


Página 246


2012

En Java 5, la clase LinkedList ha sido mejorada al implementar la interface java.util.Queue interface java.util.Queue.. Asi que ahora además, soporta los métodos: peek() peek(),, poll() y offer() offer().. Set (Interface) (Interface) Para un Set es importante ser único, no permite duplicados. Tu buen amigo, el método equals() determina si dos objetos son idénticos (en cuyo caso, sólo uno podrá ir al Set Set). ). Las tres implementaciones de Set Set están están descritas en las siguientes secciones. HashSet Un HashSet es un Set unsorted unsorted y y unordered unordered.. Usa el hashCode hashCode del del objeto insertado, así que la mayor eficiencia reside en la implementación que hagas de tu método hashCode() hashCode().. Usa esta clase cuando quieras una colección sin duplicados y que no te importe el orden cuando tengas que itinerarla. LinkedHashSet Un LinkedHashSet es una versión ordered ordered de de HashSet que mantiene un doble linkado en todos los elementos. Usa esta clase en lugar de HashSet cuando sea importante el orden al recorrer los elementos. Cuando recorres un HashSet el orden es predecible, mientras que en un LinkedHashSet LinkedHashSet,, podrás recorrer los objetos en el orden que fueron insertados. TreeSet TreeSet es una de las dos colecciones sorted sorted (la otra es TreeMap TreeMap). ). Usa una estructura de árbol Red-Black Red-Black (pero ya sabias eso), y garantiza que los elementos serán puestos en orden ascendentes de acuerdo a su orden natural. Opcionalmente puedes construir un TreeSet con un constructor que te permite dar a la colección tus propias reglas para el orden que debería tener (en lugar de confiar en el orden definido por la clase del elemento) usando un Comparable Comparable o o Comparator Comparator..


Página 247


2012

Map (Interface Map (Interface)) A un Map Map le le importa que los identificadores de sus elementos sean únicos. Mapeas una única clave (ID (ID)) para especificar valor, donde la clave y el valor, son naturalmente, objetos. Probablemente estés familiarizados con los mapas, ya que muchos lenguajes soportan datos de estructura tipo clave-valor o nombre-valor (Php por ejemplo). La implementación de los mapas te permiten hacer cosas como buscar un valor basado en la clave, preguntarle a la colección solo valores, o preguntarle por solo las claves. Al igual que los Sets Sets,, los Maps confían en el método equals() equals() para para determinar si dos claves son iguales o distintas. HashMap El HashMap te proporciona un Map unsorted unsorted y y unordered unordered.. Cuando necesites un Map y no te importe el orden (cuando vayas a recorrerlo), entonces HashMap es lo correcto, los otros mapas añaden un poco más de carga. HashMap se basa en el hashCode hashCode,, al igual que HashSet HashSet,, donde la eficiencia de tu hashCode mejorara el rendimiento. HashMap te permite una clave null null y y múltiples valores null null en en la colección. HashTable Al igual que Vector Vector,, HashTable ha existido desde tiempos inmemoriales en Java. Por diversión, no olvides anotar la inconsistencia en el nombre: HashMap vs HashTable HashTable.. De cualquier manera, al igual que Vector es el opuesto sincronizado de ArrayList ArrayList,, HashTable es el opuesto sincronizado a HashMap HashMap.. Recuerda que no sincronizas la clase, así que cuando decimos que Vector y HashTable están sincronizados, lo que queremos decir es que los métodos clave de estas clases están sincronizados. Otra diferencia es que, mientras HashMap te permite tener valores nulos y una clave nula, en un HashTable no te permite almacenar nada nulo. LinkedHashMap Como su opuesto es Set (LinkedHashSet LinkedHashSet), ), LinkedHashMap mantiene la colección en orden (o, opcionalmente, en orden de acceso). Quizás es algo más lento que HashMap cuando añades y borras elementos, pero la iteración es más rápida con LinkedHashMap LinkedHashMap.. TreeMap Como probablemente ya has adivinado, un TreeMap es un Map ordenado. Y ya sabes que por defecto, esto significa ordenado en su orden natural de elementos. Al igual que TreeSet TreeSet,, TreeMap te permite organizar el orden a tu gusto, usando Comparable Comparable o o Comparator,, que especifica la manera en que los elementos deberían ser ordenados. Comparator Queue (Interface) Una cola (Queue (Queue)) está diseñada para almacenar una lista de "para-hacer" ( to-do), o cosas para ser procesadas de la misma manera. Aunque otras órdenes son posibles, las colas normalmente van como FIFO FIFO (first-in, (first-in, first-out, primero en entrar, primero en salir). Las colas soportan todos los métodos estándar de las colecciones y también añaden métodos para añadir elementos, quitar elementos y revisar la cola c ola de elementos.


Página 248


2012

PriorityQueue Esta clase es nueva en Java 5. Desde que se mejoró la clase LinkedList implementando la interfaz Queue Queue,, las colas pueden ser manejadas con LinkedList LinkedList.. El propósito de PriorityQueue es que los elementos sean ordenados por su orden natural (por lo que los elementos son almacenados primeros serán accedidos primero) o según lo establecido en Comparator Comparator.. En cualquier caso, el orden de los elementos representa una prioridad relativa. La siguiente tabla resume 11 de las 13 colecciones que tienes que aprender. Los Array y las Collection vienen enseguida!

19.2.1 ArrayList 19.2.1 ArrayList La clase java.util. clase java.util.ArrayList ArrayList es una de las más usadas de todas las colecciones de Framework Framework.. Es como un array array con con vitaminas. Algunas de las ventajas de ArrayList son son::  

Crece dinámicamente Provee de inserciones más poderosas y mejores mecanismos de búsqueda que los arrays.

Echemos un vistazo al uso de ArrayList conteniendo cadenas. Una clave del diseño de las colecciones del Framework Framework es es que proveen de una rica funcionalidad al nivel de las principales interfaces: List List,, Set y Map Map.. En la práctica, normalmente querrás instanciar un ArrayList de forma polifórmica:

Escrito en Java 5 (y en adelante) seria:

Esta clase de declaración sigue el principio de "código a interface", y crea el uso de genéricos. Hablaremos bastante del uso de genéricos en este capítulo, pero por ahora, solo hay que saber que al igual que en Java 5 (y en adelante), la sintaxis es es la manera de declarar el tipo de colección. Antes de Java 5, no había manera de especificar el tipo de una colección, y


Página 249


2012

cuando cubramos los genéricos, hablaremos de la implicación al mezclar Java 5 (tipificado) con las versiones anteriores a Java 5 (sin tipificar) en las colecciones. En muchas maneras, ArrayList ArrayList es muy similar a String[] String[],, declara un contenedor que sólo puede almacenar cadenas, pero es más poderoso que un String[] String[].. Echemos un vistazo a algunas de las capacidades que un ArrayList tiene:

lo que produce: 3 false true 2

Hay un motón de movimiento en este pequeño programa. Fíjate que cuando declaramos el ArrayList no le dimos un tamaño. Luego le preguntamos por su tamaño, le pudimos preguntar si tenía contenido específico, también le borramos el objeto de en medio, y le volvimos a preguntar su tamaño.

Autoboxing con colecciones En general, las colecciones almacenan objetos, pero no primitivos. Antes de Java 5, era muy común el uso de clases de envoltorio para proveer a las clases de una manera de meter un primitivo en una colección. Antes de Java 5, tenías que envolver el primitivo a mano y después podías meterlo en la colección. Con Java 5, los primitivos todavía están envueltos, pero el autoboxing lo hace por ti.

a partir de Java 5, podemos hacer:


Página 250


2012

En este ejemplo, hemos puesto un objeto Integer Integer a a myInts myInts (no (no un primitivo int int), ), sólo que el autoboxing envolvió el primitivo por nosotros.

Clasificando las colecciones y los arrays Las colecciones colecciones y y los arrays arrays pueden pueden ser ordenados y hacer búsquedas usando métodos del API API..

Ordenando colecciones Comencemos por algo simple como ordenar un ArrayList ArrayList de de cadenas alfabéticamente. Podría ser más fácil? Bien, esperaremos un rato mientras vas y buscas el método sort() de ArrayList ArrayList.. Lo tienes? Naturalmente, ArrayList no te da ninguna forma de ordenar su contenido, pero java.util.Collection pero java.util.Collection si: si:

lo que da: unsorted [Denver, Boulder, Vail, Aspen, Telluride] sorted [Aspen, Boulder, Denver, Telluride, Vail]

En la línea #1 se declara un ArrayList de cadena, y en la línea #2 se ordena el ArrayList alfabéticamente. Hablaremos más sobre la clase Collection a lo largo de la clase Array en otra sección, por ahora nos ocuparemos de ordenar cosas. Imaginemos que estamos construyendo una aplicación de un automatismo para una casa. Hoy estamos centrados en el home cinema, y más específicamente, en el control del DVD. Ya tenemos el I/O Software para leer y escribir datos entre el dvdInfo.txt dvdInfo.txt y y las instancias de la clase DVDInfo DVDInfo.. Aquí está la clave del aspecto de la clase:


Página 251


2012

Aqui estan los datos de dvdinfo.txt dvdinfo.txt:: Donnie Darko/sci-fi/Gyllenhall Darko/sci-fi/Gyllenhall, , Jake Raiders of the Lost Ark/action/Ford, Ark/action/Ford, Harrison 2001/sci-fi/?? Caddy Shack/comedy/Murray, Bill Star Wars/sci-fi/Ford, Harrison Lost in Translation/comedy/Murray, Bill Patriot Games/action/Ford, Harrison

En nuestra aplicación, queremos crear una instancia de DVDInfo DVDInfo para para cada línea de datos que leemos del fichero dvdinfo.txt dvdinfo.txt.. Por ejemplo, queremos parsear la línea datos (te acuerdas de String.split() String.split()?) ?) y llenar las tres instancias de DVDInfo DVDInfo.. Finalmente, queremos poner todas las instancias de DVDInfo DVDInfo en en unArrayList unArrayList.. Imagina que el método populateList() populateList() hace hace todo esto. Aquí hay una pequeña pieza de código de nuestra aplicación:

Puedes obtener algo como esto: [Donnie Darko sci-fi Gyllenhall, Jake , Raiders of the Lost Ark action Ford, Harrison , 2001 sci-fi ?? , Caddy Shack comedy Murray, Bill , Star Wars sci-fi Ford, Harrison , Lost in Translation Translation comedy Murray, Bill , Patriot Games action Ford, Harrison ]

Nota: Hemos sobrescrito el método de DVDInfo.toString() DVDInfo.toString(),, así que cuando hemos invocado println() println() en en el ArrayList ArrayList,, se invoca toString() toString() para para cada instancia. Ahora que tenemos ArrayList populado, ordenémoslo:

Oppps! ahora hemos obtenido esto:


Página 252


2012

TestDVD.java:13: TestDVD.java:13: cannot find symbol symbol : method sort(java.util.ArrayList) location: class java.util.Collections Collections.sort(dvdlist);

Que ha pasado aquí? Sabemos que la clase Collection tiene el método sort() sort(),, este error hace pensar que Collection no tiene un método sort() sort() que que pueda tomar un dvdlist dvdlist.. Lo que significa que debe haber algo equivocado en el argumento que le hemos pasado ( dvdinfo dvdinfo). ).

Si ya te lo has imaginado, adivinamos que lo hiciste sin la ayuda del error mostrado arriba... Como demonios ordenas las instancias de DVDInfo DVDInfo?? Por qué pueden ordenarse las cadenas? Cuando miras el API API de de Collection Collection.sort() .sort(),, la primera reacción puede ser pánico. Tranquilo, nuevamente los genéricos te ayudarán con este método que parece estar enloquecido. Si has leído la descripción del método sort() con un argumento, veras que sort() toma como argumento una List List,, y que el objeto List debe implementar una interfaz llamada Comparable Comparable.. Esto nos dice que String implementa Comparable Comparable,, y esa es la razón de por qué pudimos ordenar una lista de cadenas usando el método Collection Collection.sort() .sort()..

La interfaz Comparable La interfaz Comparable se usa en las colecciones con el método Collection Collection.sort() .sort() y y java.utils. java.utils.Array Array.sort() .sort() para ordenar listas listas y y arrays de objetos respectivamente. Para implementar Comparable Comparable,, una clase debe implementar un solo método, compareTo() compareTo().. Un ejemplo de invocación de compareTo() compareTo()::

El método compareTo() compareTo() devuelve devuelve un int con las siguientes características: 





negativo Si esteObjeto < otroObjeto zero Si esteObjeto == otroObjeto positivo Si esteObjeto > otroObjeto

El método usa compareTo() compareTo() para para determinar como la lista lista o o el objeto array array debe debe ser ordenado. Al implementar compareTo() compareTo() en en tus clases, puedes usar cualquier criterio que se te ocurra para ordenar las instancias de tu clase. Volviendo al ejemplo de DVDInfo DVDInfo,, nosotros vamos a coger la manera fácil y vamos a usar la implementación de compareTo() compareTo() de de la clase String String::


Página 253


2012

En la línea #1 declaramos que DVDInfo DVDInfo implementa implementa Comparable Comparable,, de esta manera los objetos DVDInfo podrán ser comparados con otros objetos DVDInfo DVDInfo.. En la línea #2 #2 implementamos implementamos compareTo() compareTo() para comparar los dos objetos título del objeto DVDInfo DVDInfo.. Ya que sabemos que los títulos son cadenas, y que las cadenas implementan Comparable Comparable,, esta es una manera sencilla de ordenar los objetos DVDInfo DVDInfo,, por el título. Antes de que vinieran los genéricos en Java 5, tendríamos que haber implementado Comparable de esta manera:

Esto es todavía legal, pero puedes ver que es una manera dolorosa y arriesgada, ya que tienes que hacer un casteo, y necesitas verificar que el casteo no va a fallar antes de que sea ejecutado.

Ahora cuando invocamos Collections.sort(dvdlist); Collections.sort(dvdlist); obtenemos: obtenemos: [2001 sci-fi ?? , Caddy Shack comedy Murray, Bill , Donnie Darko sci-fi Gyllenhall, Jake , Lost in Translation Translation comedy Murray, Bill , Patriot Games action Ford, Harrison , Raiders of the Lost Ark action Ford, Harrison , Star Wars sci-fi Ford, Harrison ]

Yeehaaa! Nuestro ArrayList ha ordenado esto por título. Naturalmente, si queremos que nuestra automatización sea lo más, probablemente querremos ordenar las colecciones de DVD de diferentes formas. Al implementar el método compareTo() pudimos ordenar. Lo hicimos en


Página 254


2012

una clase, pero como hacemos para que nuestras clases se ordenen de una manera específica a compareTo() compareTo()?? Buena pregunta. Afortunadamente, la respuesta viene ahora.

Ordenando usando Comparator Mientras estabas mirando el método Collections Collections.sort() .sort() podrías podrías haberte dado cuenta de que es una versión sobrecargada de sort() que toma un List List,, y algo llamado Comparator Comparator.. La interfaz Comparator te da la capacidad de ordenar una colección de un millar de maneras distintas. La otra cosa que hace la interfaz Comparator es que te permite ordenar las instancias de cualquier clase, incluso las clases que no puedes modificar, al contrario que Comparable Comparable,, que te obliga a cambiar las instancias de las clases que quieres ordenar. La interface Comparator es también muy fácil de implementar, tiene sólo un método, compare() compare().. Aquí hay una pequeña clase que puede ser usada para ordenar una List de instancias de DVDInfo DVDInfo,, por género.

El método Comparator Comparator.compare() .compare() devuelve devuelve un int int cuyo valor de retorno es el mismo que el de Comparable Comparable.compareTo() .compareTo().. En este caso estamos cogiendo ventaja al pedirle a compareTo() compareTo() que que haga el trabajo de comparación por nosotros. Aquí hay un programa que nos permite testear ambos códigos Comparable y nuestro nuevo código Comparator Comparator::

Ya habias visto las dos primeras salidas, esta es la tercera: [Patriot Games action Ford, Harrison , Raiders of the Lost Ark action Ford, Harrison


Página 255

Curso gratuito de Java en emuladores L2 Java , , , , , ]

2012

Caddy Shack comedy Murray, Bill Lost in Translation comedy Murray, Bill 2001 sci-fi ?? Donnie Darko sci-fi Gyllenhall, Jake Star Wars sci-fi Ford, Harrison

Ya que Comparable y Comparator son similares, podrás confundirte. Por ejemplo, se te puede pasar por la cabeza que implementar el método compareTo() compareTo() en la interface Comparator Comparator.. Memoriza la siguiente tabla para conocer las diferencias entre estas dos interfaces:

Para acabar con este apartado, voy a mostrar un código creado a partir de lo visto hasta aquí. Se trata de una agenda con nombres y números donde se exponen tres maneras de ordenar la agenda. La primera manera, es la natural, el orden creado por indexación. La segunda manera, es el orden creado por el orden alfabético de los nombres. La tercera manera, es el orden creado por los números, que por supuesto, son ficticios, pero sirven para la demostración. Aquí el código:


Página 256


2012

y aquí el resultado obtenido: Orden natural: [Pepe 112.233, Juan 908.978, Vicente 645.720, Bartolo 6.543.599]


Página 257


2012

Orden alfabetico: [Bartolo 6.543.599, Juan 908.978, Pepe 112.233, Vicente 645.720] 645. 720] Ordenado por numeros: [Pepe 112.233, Vicente 645.720, Juan 908.978, Bartolo 6.543.599]

Te acuerdas de format() format()?? lo he usado para añadir el punto a los números, de esta manera se puede ver mejor su valor.

19.2.2 Arrays 19.2.2 Arrays Hemos estado usando java.util. usando java.util.Collections Collections para ordenar colecciones, ahora veamos el uso de java.util. de java.util.Arrays Arrays para ordenar arrays arrays.. La buena noticia es que ordenar objetos con arrays arrays es es como hacerlo con Collections Collections.. El método Arrays Arrays.sort() .sort() esta sobrescrito de la misma manera que lo está en Collections Collections.sort() .sort()..  

Arrays.sort(arrayToSort Arrays.sort( arrayToSort)) Arrays.sort( Arrays .sort(arrayToSort arrayToSort,,Comparator) Comparator)

Además el método Arrays Arrays.sort() .sort() esta esta sobrecargado sobre un millón de veces al proveer de un par de métodos para cada tipo de primitivo primitivo.. El método Arrays Arrays.sort() .sort() ordena los primitivos siempre en su orden natural. No caigas en la trampa de intentar ordenar un array array primitivo primitivo usando un Comparator Comparator.. Finalmente, recuerda que el método sort() sort() para para las colecciones y para los arrays arrays son son métodos estáticos, y que alteran los objetos que contiene en lugar de devolver un tipo de objeto ordenado.

19.3 Búsqueda en Arrays en Arrays y Collections y Collections La clase Collections y la clase Arrays tienen métodos que te permiten buscar un elemento específico. Cuando buscamos a través de las colecciones o de los arrays arrays,, se aplican las siguientes reglas:  







Las búsquedas se usan usando el método binarySearch() binarySearch().. Las búsquedas con éxito devuelven un int int que corresponde al índex del elemento encontrado. Las búsquedas malogradas devuelven un int int que representa el índice de punto de inserción. El punto de inserción es el lugar en la collection collection//array donde el elemento sería insertado para ocupar un sitio apropiado en el orden que le corresponde. Así que los valores positivos y el valor 0 indica una búsqueda exitosa, el método binarySearch() binarySearch() usa usa números negativos para indicar el punto de inserción. Ya que 0 es un resultado valido para una búsqueda, la primera posición de una inserción es -1 es -1.. Así que si el punto de inserción de búsqueda de un elemento es 2, el punto de inserción seria -3 -3.. La búsqueda en una collection collection//array array se hacen después de que los elementos hayan sido ordenados. Si intentas hacer una búsqueda en un array array o o una colección colección que que no ha sido ordenado, los resultados de la búsqueda no son predecibles. e m a i l : b r u j u l a t o @ y ah o o . e s

Página 258




2012

Si la collection collection//array array donde donde quieres hacer la búsqueda ha sido ordenado siguiendo su orden natural, la búsqueda se hará en ese orden. Esto implica que no envía un argumento Comparator para el método binarySearch() binarySearch().. Si la collection collection//array array donde haces la búsqueda fue ordenado usando Comparator Comparator,, la búsqueda se hará usando el mismo Comparator Comparator,, la cual es pasado como segundo argumento al método binarySearch() binarySearch().. Recuerda que los Comparator no pueden ser usados para búsqueda de primitivos primitivos en en los arrays arrays..

Echemos un vistazo al código ejemplo que ejecuta el método binarySearch() binarySearch()::

Lo que produce: four one three two one = 1 now reverse sort two three one four one = -1 one = 2

Que ha pasado: Línea 1: Ordena 1: Ordena el array alfabéticamente (el orden natural). Línea 2: Busca 2: Busca la localización localizac ión del elemento "one", que está el segundo. Línea 3: Crea 3: Crea una instancia Comparator Comparator.. En la siguiente línea se reordena el array usando el Comparator Comparator.. Línea 4: Intenta 4: Intenta buscar el array array.. No pasamos el parámetro rs rs al al método binarySearch() binarySearch() que que usamos en el array array,, así que obtenemos una respuesta (indefinida) incorrecta. Línea 5: Nueva 5: Nueva búsqueda, pasando el parámetro rs rs a a binarySearch() binarySearch().. Esta vez obtenemos la respuesta correcta, 2. Línea 6: Definimos 6: Definimos el Comparator Comparator,, es correcto anidarlo en una clase. Línea 7: Al 7: Al cambiar el uso de los argumentos en la invocación de compareTo() compareTo(),, obtenemos el orden invertido.


Página 259


2012

Resumen de métodos para Arrays para Arrays y y Collections Collections.. Aviso: la sintaxis T[] T[] será será explicada más tarde en este capítulo, por ahora piensa que no se trata de un array array de de primitivos primitivos..

Convirtiendo Arrays Convirtiendo Arrays a lista de Arrays Hay un par de métodos que te permiten convertir Arrays a List List,, y List a Arrays Arrays.. Las clases List y Set tienen métodos toArray() métodos toArray(),, y la clase Arrays tiene un método asList() asList().. El método asList() asList() copia copia un array array dentro dentro de una List List.. El API dice, "Devuelve un lista de un array especificado". Cuando usas el método asList() asList(),, el array array y y la List se unen. Cuando actualizas uno de ellos, el otro se actualiza automáticamente. Veamos un ejemplo:

Esto da: size 4 idx2 three one five three six


Página 260


2012

sl[1] five

Fíjate que cuando imprimimos el estado final del array array y y la List List,, ambas, la lista lista y y el array array,, han actualizado los cambios. Esto tendrás que tenerlo siempre presente. Ahora veamos el método toArray() toArray().. No hay nada más divertido que el método toArray() toArray(),, viene en dos sabores, uno que devuelve un objeto nuevo, y el otro que usa el array array de de envío como array array de de destino:


Página 261


2012

19.4 Listas Recuerda que las listas se usan normalmente para almacenar cosas en alguna clase de orden. Puedes usar una LinkedList para crear una cola. Puedes usar un ArrayList para almacenar las localizaciones en orden. Fíjate que en ambos ejemplos es perfectamente razonable asumir que podría haber un duplicado. Además, las listas te permiten sobrescribir manualmente el orden de los elementos añadiendo o quitando elementos. Antes de Java 5 y sin la actualización de for for,, los elementos se examinaban uno a uno, con el uso de un Iterator Iterator.. Todavía encontraras Iterator en el código de Java. Un Iterator es un objeto que se asocia a una colección. Te permite recorrer la colección paso a paso. Los dos métodos de Iterator que necesitas saber son: 



boolean hasNext() Devuelve true si al menos queda un elemento más en la colección para ser recorrido. Invocar a hasNext() a hasNext() no no significa que pases al siguiente elemento de la colección. object next() Este método devuelve el siguiente objeto de la colección y te pasa al siguiente elemento de la lista.

Echemos un vistazo a como se usa un List con un Iterator Iterator::

esto produce aiko clover magnolia


Página 262


2012

size 3 get1 clover aiko 0 oa aiko oa clover

Primero de todo, hemos usado sintaxis genérica para crear el Iterator (un Iterator de tipo Dog Dog). ). Por eso, cuando hemos usado el método next() next(),, no tuvimos que castear el objeto devuelto por next() next() a a Dog Dog.. Pudimos haber declarado el Iterator de esta manera:

Pero entonces tendríamos que haber hecho esto:

El resto del código demuestra el uso de size() size(),, get() get(),, indexOf() indexOf() y y toArray() toArray().. No deberían haber sorpresas con estos métodos. En breve listaremos todos los métodos de List List,, Set y Map que deberían ser familiares. Como última advertencia, recuerda que List es una interface!

19.5 Set Recuerda que los Set se usan cuando no quieres que haya duplicados en tu colección. Si intentas añadir un elemento a un Set donde ya existe un elemento igual, el duplicado no será añadido y el método add() add() devolverá devolverá false false.. Recuerda HashSet tiende a ser más rápido porque, como dijimos antes, usa hashCode hashCode.. También puedes crear un TreeSet TreeSet,, el cual te permite ordenar los elementos. Debes tener precaución cuando uses un TreeSet (estamos a punto de explicar el motivo): moti vo):

Si insertas la siguiente línea de código, e m a i l : b r u j u l a t o @ y ah o o . e s

Página 263


2012

obtendrás una salida como esta: true true true false true a java.lang.Object@e09713 java.lang.Object@e09713 42 b

Es importante que sepas que el orden de los objetos imprimidos en el segundo bucle for no son predecibles: HashSet y LinkedHashSet no te garantizan ningún orden. También, tienes que saber que la cuarta invocación de add() add() falla, falla, ya que se intenta insertar una entrada duplicada (una cadena con el valor "a") en el Set Set.. Si insertas esta línea de código

conseguirás algo como esto: Exception in thread "main" java.lang.ClassCastException: java. lang.String at java.lang.Integer.compareTo(Integer.java:35) at java.util.TreeMap.compare(TreeMap.java:1093) at java.util.TreeMap.put(TreeMap.java:465) at java.util.TreeSet.add(TreeSet.java:210)

Este problema aparece cuando quieres que una colección sea ordenada, sus elementos deben ser mutuamente comparables. Recuerda que a menos que se especifique otra cosa, los lo s objetos de diferentes tipos, no son mutuamente comparables.

19.6 Map Recuerda que cuando usas una clase que implemente Map Map,, cualquier clase que uses como parte de la clave de Map Map,, debe sobrescribir los métodos hashCode() hashCode() y y equals() equals().. Solo tienes que sobrescribirlos si estás interesado en rescatarlos más tarde de tu mapa. Realmente es legal usar una clase que no sobrescriba equals() equals() y y hashCode() hashCode() como clave en tu mapa mapa.. El código compilará y se ejecutará, tan solo pasará que no podrás encontrar nada. Ejemplo de uso de HashMap HashMap::


Página 264


2012

lo que devuelve: Dog@1c DOG CAT key Dog key null 5

Revisemos la salida. El primer valor recuperado es un objeto Dog Dog (tu (tu valor variará). El segundo valor recuperado es una enumeración (DOG). El tercer valor es una String String,, fíjate que la clave fue un valor de enumeración. Cuestión sorpresa, cual es la implicación del hecho de que fuera posible usar una enumeración como clave? La implicación reside en que la enumeración sobrescribe equals() equals() y y hashCode() hashCode().. Y si miras el API de java.lang. de java.lang.Enum Enum,, veras que en efecto, estos métodos han sido sobrescritos. La cuarta salida es un String String.. El punto importante de esto es que la clave usada para sacar el String fue un objeto Dog Dog.. La quinta salida es un null null.. El punto importante aquí es que el método get() get() falló falló al buscar el objeto Cat Cat que insertamos antes. (La ultima línea de la salida


Página 265


2012

confirma que ciertamente, la clave/valor 5 usa una instancia de Dog Dog como como clave, cuando se usa una instancia de Cat Cat como como es que la clave falla?) Es fácil de ver que Dog Dog sobrescribe sobrescribe equals() y hashCode() mientras que Cat no lo hace. Echemos un vistazo rápido a los hashCode hashCode.. Usábamos un hashCode hashCode increíblemente increíblemente fácil en la clase Dog Dog,, el hashCode hashCode de de Dog era la longitud del nombre. Así que en este ejemplo, el hashCode hashCode era era 4. Comparemos los dos métodos hashCode hashCode::

Hora de otra pregunta sorpresa: son estos dos métodos de hashCode hashCode legales? legales? serán capaces de encontrar el objeto en el mapa? Cual será más rápido? La respuesta para la 1a pregunta es sí y sí. Ninguno de estos hashCode hashCode son son muy eficientes (de hecho ambos son increíblemente ineficientes), pero ambos son válidos y harán su trabajo. La respuesta a la última pregunta es que el hashCode primero será algo más rápido que el segundo. En general, la fórmula ideal sería la que crease un único hashCode hashCode,, logrando la mayor velocidad y eficiencia. El primer hashCode creará un hashCode basado en la longitud del nombre, por ejemplo Pepe Pepe dará dará uno distinto a Antonio Antonio.. La segunda fórmula siempre produce el mismo, así que será más lento que el primero. Nuestro último tópico de este mapa es lo que ocurre cuando un objeto usado como clave tiene su valor cambiado. Si añadimos dos líneas de código al final de Maptest.main() Maptest.main(),,

conseguiríamos algo como esto: Dog@4 DOG CAT key Dog key null 5 null

Antes encontramos al Dog Dog,, pero ahora no. Eso es porque la variable usada para crear el hashCode hashCode,, cambio el valor del nombre y claro, el valor del hashCode hashCode.. Como quid final para los hashCode hashCode,, determinar la salida para las siguientes líneas de código si fueron añadidas al final del MapTest.main() MapTest.main()::


Página 266


2012

Recuerda que el hashCode() hashCode() es es igual a la longitud del nombre. Cuando estudias este problema, tienes que tener en cuenta lo que necesitas para obtener el objeto que buscas: 1. Usar el método hashCode() hashCode() para para encontrar el cubo adecuado. 2. Usar el método equals() equals() para para encontrar el objeto en el cubo. En primer lugar, la llamada a get() get(),, el hashCode hashCode es es 8 (magnolia (magnolia)) y debería ser 6, (clover ( clover), ), así que la obtención falla en el paso 1 y obtendremos un null null.. En el segundo get() get(),, el hashCode hashCode en en ambos es 6, así que la obtención no da error. Una vez que tenemos el cubo correcto, se invoca el método equals() equals(),, y como el método equals() equals() de de Dog Dog compara compara nombres, funciona, y la salida es la clave de Dog Dog.. En la tercera invocación de get() get(),, el test de hashCode hashCode funciona, funciona, pero el test de equals() equals() falla falla porque arthur arthur no no es igual que clover clover.. En breve mostraremos unas tablas que resumen los métodos que deberías conocer.

19.7 Priority Queue La ultima colección que necesitas aprender es PriorityQueue PriorityQueue.. Al contrario que las estructuras básicas de cola, que son por defecto, primero en entrar, primero en salir, un PriorityQueue ordena sus elementos usando la prioridad definida por el usuario. La prioridad puede ser tan simple como el orden natural (por ejemplo, la entrada de 1 podría tener la prioridad más alta frente al 2). Además, PriorityQueue puede ser ordenado usando Comparator Comparator,, lo que te permite definir el orden que quieras. Las colas tienen algunos métodos que no existen en otras colecciones: peek() peek(),, poll() poll() y y offer() offer()..


Página 267


2012

lo que arroja: 1 3 5 6 7 8 9 size 7 peek 9 size 7 poll 9 size 6 8 7 6 5 3 1 null

Miremos en detalle el código. El primer bucle for recorre el array ia ia,, y usa el método offer() offer() para para añadir elementos al PriorityQueue pq1 pq1.. El segundo bucle recorre pq1 pq1 usando el método poll() poll(),, que devuelve la entrada más alta en pq1 pq1 y y elimina la entrada de la cola. Date cuenta que los elementos son devueltos en orden de prioridad (en este caso, el orden natural). Luego creamos un Comparator que ordena los elementos al contrario de su orden natural. Usamos este Comparator para construir un segundo PriorityQueue llamado pq2 pq2,, y lo cargamos en el mismo array que usamos antes. Finalmente comprobamos el tamaño de pq2 pq2 antes y después de la llamada a peek() peek() y y poll() poll().. Esto confirma que peek() devuelve el elemento más alto de la cola sin eliminarlo, y poll() poll()devuelve devuelve el elemento de la cola y lo elimina. Finalmente, revisamos los elementos que quedan en la cola.


Página 268


2012

Resumen de métodos para List , Set , Map y Queue Para estas cuatro interfaces hemos cubierto todos los trucos de los métodos. La siguiente tabla muestra un resumen de los métodos de List List,, Set Set,, y Map de los que deberías guardar cuidado.

19.8 Tipos de genéricos Los Arrays Arrays en en Java siempre son de tipo seguro, un array declarado como tipo String String ( (String String []) []) no puede aceptar Integer Integer (o (o int), Dogs Dogs o o cualquier cosa que no sea String String.. Pero recuerda que antes de Java 5 no había sintaxis para declarar el tipo de colección. Para hacer un ArrayList ArrayList de de String String,, tenías que hacer:

o el polimórfico equivalente:

No había sintaxis a la izquierda para especificar que myList myList tomaría tomaría String y sólo String String.. Y sin manera de especificar el tipo de ArrayList ArrayList,, el compilador no te podía obligar a poner los elementos de tipo específicos en la lista. Al igual que en Java 5, podemos usar genéricos, y no solo sirven para hacer las colecciones seguras, sino que además la mayoría de los


Página 269


2012

desarrolladores usan genéricos. Así que los genéricos no son solo para las colecciones, piensa que las colecciones son la razón principal para añadir genéricos al lenguaje. No fue una decisión fácil, no tuvo una calurosa bienvenida. Ya que todos estaban felices con el tipo seguro, los genéricos vinieron con un montón de equipaje. La mayoría nunca los veras o no querrás verlos, pero hay muchas cosas que pueden sorprendernos con rapidez. Cubriremos los más comunes que muy probablemente usarás en tu propio código, y también los problemas que pueden surgir. El desafío más grande para Sun aparte de añadir genéricos al lenguaje (y la razón principal de por qué les llevo tanto tiempo) fue como lidiar con elegancia el código construido sin los genéricos. Los ingenieros de Java obviamente no querían que nadie pudiera quebrar su código, así que tuvieron que encontrar una manera para que las clases de Java de ambos tipos, genéricos y tipos no seguros, pudiesen trabajar juntos. Su solución no es una lista amiga, pero te permite el uso de los viejos códigos no genéricos, y también el uso de código genérico que permite el uso de código no genérico. Pero date cuenta que dijimos "permite", y no "permite sin problemas". Mientras en Java 5 se te permite integrar genérico con no genérico, las consecuencias pueden ser desastrosas, y desafortunadamente, la mayoría de los desastres ocurren en tiempo de ejecución, no en tiempo de compilación. Afortunadamente, la mayoría de compiladores generaran advertencias para decirte que estas usando colecciones no seguras (no quiere decir que sean no genéricas). Vamos a cubrir los genéricos y no genéricos, y espero que entiendas y veas el problema que puede venir del uso de mezclar genéricos y no genéricos al mismo tiempo. Y como algunos de los tópicos de este manual, se podría llenar un libro completo si realmente quieres cubrir todos los detalles de los genéricos, pero mi propósito, cubre más de lo que los desarrolladores necesitan usar.

19.8.1 Las colecciones al estilo "Legacy" Aquí hay un ejemplo de un ArrayList que tenía la intención de almacenar String String.. (Decimos intención porque es todo lo que había, buenas intenciones, para asegurarse de que el ArrayList solo contenía objetos String String). ).

Una colección no genérica podía almacenar cualquier clase de objeto! Una colección no genérica es feliz almacenando cualquier cosa que no sea un primitivo. Esto significa que cualquier programador tendría que ser bastante... cuidadoso. No había garantías de que la colección fuese programada de manera amigable para que fuese dirigida a un solo tipo de elemento. Solíamos usar el compilador para pararnos, por ejemplo, al asignar


Página 270


2012

un int a una referencia booleana o de cadena, saltaba la advertencia, pero con las colecciones era todo "venga! adentro! Barra libre!" Ya que las colecciones podían almacenar cualquier cosa, los métodos que usaban estas colecciones solo podían tener un tipo de retorno, java.lang. retorno, java.lang.Object Object.. Lo que quiere decir que la cadena devuelta había que castearla:

Y ya que no podías garantizar que lo que venía era un String (ya que se te permite almacenar cualquier cosa en la lista), el casteo fallaba en tiempo de ejecución. Así que los genéricos tomaron parte en el asunto, forzando a las colecciones a aceptar solo un tipo:

Perfecto. Eso es exactamente lo que queremos. Al usar sintaxis de genéricos, lo hicimos al poner entre ángulos String ( ), ), le estamos diciendo al compilador que esta colección solo almacenara objetos String String.. El tipo se especifica dentro de los ángulos, a esto se le llama tipo de parámetro, tipo parametrizado, o naturalmente, como siempre le hemos llamado, tipo. En este capítulo nos referiremos a ambos am bos de las dos maneras. Así que ahora que puedes poner una garantía a lo que entra, también puedes poner una garantía a lo que sale, y eso quiere decir que puedes deshacerte del casteo cuando saques algo de la colección. En lugar de:

donde no se garantiza que el objeto sea un String String,, podemos hacer:

El compilador ya sabe que myList solo contiene cosas que pueden ser referenciadas a variables String String,, así que ahora no necesitas castear. Hasta ahora, todo parece bastante simple. Y con el nuevo for for mejorado, mejorado, puedes recorrer la variable con la garantía de encontrar siempre un String String..


Página 271


2012

Y naturalmente puedes declarar un tipo de parámetro para un argumento del método, que tome el argumento de forma segura:

El método no compilara si lo cambiamos como:

El tipo de devolución obviamente solo puede ser declarado como tipo seguro también:

El compilador parará cualquier retorno no compatible con un Set un Set (aunque (aunque lo que es y no es compatible va a ser muy interesante en un minuto). Y ya que el compilador garantiza que solo un tipo seguro Dog Dog es es lo que va a ser devuelto, esas llamadas a los métodos no necesitan castearse al Set Set::

Antes de Java 5, el código no genérico, getDogList() sería:

y una llamada podría necesitar un casteo:

El casteo del ejemplo se aplica a lo que viene del método get de Set Set,, no estamos casteando lo que devuelve getDogList() getDogList(),, que es un Set Set.. Pero qué hay del beneficio de una colección completamente heterogénea? En otras palabras, que pasa si quisieras meter genéricos en un ArrayList que fuese genérico?


Página 272


2012

es casi idéntico a:

Declarando una lista con el tipo de parámetro Object Object,, hace que la colección funcione en casi de la misma manera que el original anterior a Java 5, puedes poner cualquier clase de colección y colecciones de tipo

Curso Gratuito de Java en Emuladores L2 Java

Recommend Documents