9.

5 Throwing an Exception with 1

“throw”
esperaría hacer algo al respecto. Por ejemplo, si un fragmento de código intentara
a colocar un ilegal valor para a Curso constructor, él debería ser hecho Consciente
de ello para que se pudiera corregir el error. En muchos casos, la información
sobre la excepción quería necesidad a ser propagado todo el forma atrás a el
usuario interfaz, entonces que el usuario podría corregir el error.
Vimos en nuestro primer ejemplo que un método puede delegar la
responsabilidad de un excepción por simplemente relanzando él en el firma de el
Encerrando método. Nosotros saber, para ejemplo, eso el " leer " métodos de
[Link] tirar Excepción IO. Si usamos este método dentro de otro método,
simplemente podríamos agregar la cláusula “ throws IOException ” al método
adjunto.
público carbonizarse leerChar() lanza Excepción de E/S
{
devolver (char)[Link]();
}

Cualquier código que llame al método readChar ahora debe manejar la

IOException. A asegurar eso un excepción es recibió por todo regiones de el
sistema eso necesidad a ser
Si somos conscientes de ello, podemos gestionar una excepción y volver a
generarla. Esto nos permite, por ejemplo, registrar la excepción en el punto en el
que se produce, pero también notificar la excepción al código que la llama. Aquí,
atrapar una IOException y luego volver a lanzar él.
público carbonizarse leerChar() lanza Excepción de E/S
{
intentar
{
devolver (char)[Link]();
}
atrapar (Excepción de E/S mi)
{
[Link](
); lanzar e;
}
}

Tú podría también crear y tirar a diferente excepción dentro el atrapar bloquear.

Por ejemplo, puede tener un bloque catch que capture una excepción no
controlada, pero que cree y lance una excepción controlada. Veremos un ejemplo
de esto al final de la siguiente sección.
Ejercicio 9.2
• Modificar el “ setNombre ” método de el Curso clase entonces eso él
lanza una NullPointerException si el parámetro que se le pasa es nulo.
• Escribir a " principal " método a prueba su excepción manejo.
• El “ lanza ” palabra clave en a método firma puede ser seguido por más que
Un tipo de excepción, en una lista separada por comas. Por ejemplo:
2 9 Exception
Handling

público carbonizarse
readCharFromKeyboard() lanza
IOException, Excepción
{
} …

Modificar el firma de el parametrizado constructor de el Curso clase entonces

que lanza tanto IllegalArgumentException como NullPointerException.

• Modificar su " principal " método, entonces él poder atrapar ambos tipos
de excepciones. Utilice diferentes constructores en bloques “ try … catch ”
separados.

9.2 Escribiendo y el uso personalizado Excepciones

Hasta ahora, solo hemos analizado el manejo de los tipos de excepciones que ya
ofrecen las bibliotecas de Java, pero también podemos escribir nuestras propias
excepciones personalizadas que sean específicas para nuestras propias
aplicaciones. Por ejemplo, es posible que queramos validar procesos. eso nuestro
programas llevar a cabo, y tirar excepciones eso son único a esos procesos, en
lugar de utilizar excepciones genéricas de Java. Otro problema es que algunas
excepciones de Java no están marcadas, lo que significa que el compilador no
insistirá en que estén marcadas. manejado. Nosotros podría preferir a tirar a
comprobado excepción, cual medio ellos Deben ser subclases de Excepción.
Para tomar un ejemplo simple, supongamos que queremos crear una clase
BankAccount, en la que se pueden registrar varios tipos de transacciones.
Podríamos aplicar una regla de negocio que establezca que no se puede debitar
una cuenta por encima de lo que tiene actualmente. Además, podríamos querer
que esto sea una excepción controlada, de modo que se requiera que el código del
cliente pueda manejar la excepción, lo que significa que una excepción no
controlada como IllegalArgumentException no será suficiente.
A administrar este requisito, nosotros voluntad usar herencia a escribir a
costumbre Clase de excepción. Puede crear su propia clase de excepción
controlada mediante la subclasificación de [Link] .
público clase Excepción de transacción se extiende Excepción
{
. . .
}

Escribiendo a costumbre excepción es muy simple. Todo nosotros tener a hacer es a

escribir a
subclase de [Link]. La clase Exception tiene cuatro constructores con
varias combinaciones de parámetros. Si crea una subclase de Exception pero no
anular cualquier de estos, el solo uno eso voluntad ser disponible voluntad ser el
por defecto (cero argumentos) constructor. Por lo tanto, a menudo optamos por
anular algunos o todos los demás constructores. Eclipse ofrece cierta ayuda para
anular constructores. En la Fig. 9.4 , el " Nuevo Java Clase " diálogo es ser
9.5 Throwing an Exception with 3
“throw”
usado a crear a nuevo clase como a
4 9 Exception
Handling

Higo. 9.4 De cheques el “ Constructores de Superclase ” botón cuando

creando a subclase de excepción

subclase de Excepción. Si los “ Constructores de la superclase ” la casilla de

verificación está marcada, entonces talones de todo el heredado constructores
voluntad ser agregado a el recién creado clase. Si creamos la
TransactionException con todos sus constructores heredados, los cuatro serán ser
agregado a el clase. Nota eso no solo son el talones generado pero lo
necesario llamadas a " súper " son también agregado. El constructores que toman
a “ Throwable ” como parámetro permite encadenar una serie de excepciones de
distintos tipos. Esto significa que nosotros poder crear Un objeto de excepción
como un resultado De algún otro tipo ser
9.6 Writing and Using Custom 241
Exceptions
arrojado y agrega el anterior como parámetro a este. Toda la cadena de Las
excepciones aparecerán en el seguimiento de la pila.
paquete [Link].capitulo9;
público clase Excepción de transacción se extiende Excepción
{
público Excepción de transacción () {
// HACER Generado automáticamente constructor talón
}
público TransactionException(Cadena mensaje) {
super(mensaje);
// HACER Generado automáticamente constructor talón
}
público TransactionException(Arrancable) causa) {
super(causa);
// HACER Generado automáticamente constructor talón
}
público TransactionException(Cadena mensaje, Arrojable causa)
{
super(mensaje, causa);
// HACER Generado automáticamente constructor talón
}
}

Las excepciones personalizadas pueden tener un conjunto de métodos más

interesante que solo constructores. Para Por ejemplo, nosotros poder poblar el
excepción objeto con Otros datos sobre el contexto de la excepción, pero en
muchos casos esto no es necesario.

9.2.1 Lanzamiento a Costumbre Excepción

Lanzamiento a costumbre excepción es justo como lanzamiento uno de a Java

excepción clase. Crea una instancia de la excepción y utiliza la palabra clave “
throw ” . En este ejemplo, el método “ debit ” lanza una TransactionException.
En el cuerpo del método, si el atentado débito es mayor que que el disponible
balance, el excepción es lanzado.

público vacío débito(doble cantidad) lanza Excepción de

transacción
{
si([Link]() < cantidad)
{
tirar nuevo TransactionException("insuficiente fondos");
}
// si DE ACUERDO entonces llevar en
}

9.2.2 "finalmente" Bloques

En el ejemplos de " intentar " bloques, nosotros tener visto entonces lejos en
este capítulo, " intentar " siempre ha estado seguido por a " atrapar "
bloquear. Allá es también el opción de usando a
242 9 Exception
Handling
“ Finalmente ” bloque, que puede seguir al último bloque catch o incluso
reemplazarlo. El bloque “ finalmente ” bloquear es opcional, pero cuando
presente, es código es siempre ejecutado, independientemente de si o no un
excepción es arrojado en el " intentar " bloquear. El excepción a este es si un
bloque catch ha llamado “ [Link] ” , en cuyo caso el “ finalmente ” El
bloque no se ejecutará. La secuencia de bloques es:
intentar
{
// alguno código eso nosotros intentar a ejecutar
}
atrapar (Excepción ex)
{
// alguno código eso voluntad solo ser ejecutado
// si el excepción es arrojado
}
finalmente
{
// alguno código eso voluntad siempre ser ejecutado,
// lo que sucede en el 'intentar' y 'atrapar' bloques
}

Alternativamente, nosotros poder omitir el atrapar bloque(s) en total y simplemente tener

a " intentar "
y a “ Finalmente ”

intentar
{
// alguno código eso nosotros intentar a ejecutar
}
finalmente
{
// alguno código eso voluntad siempre ser ejecutado,
// lo que sucede en el 'intentar' bloquear
}

“ Finalmente ” bloques son generalmente usado cuando él es necesario a limpio

arriba alguno
recursos independientemente de si nuestro código tuvo éxito o no. Por ejemplo,
podemos tener abierto a conexión a a archivo o a base de datos en el " intentar "
bloquear. Si O no todo obras, nosotros debería aún intentar a cerca estos
Conexiones. En alguno casos, este poder conseguir complejo si el código en el “
Finalmente ” bloquear también requiere alguno manejo de excepciones, por lo que
un bloque “ finalmente ” puede contener bloques “ try ” . Al final, si se producen
excepciones continuar a ser arrojado, nosotros puede no ser capaz a hacer qué
nosotros son intentando hacer en el bloque “ finalmente ” .

9.2.3 “Prueba con recursos”

En casos semejante como aquellos esbozado arriba, dónde recursos tener estado
abierto y Necesitar ser cerrado a pesar de todo de si un excepción tiene estado
arrojado, allá es el “ try-with-resources ” (probar con recursos)
declaración. Nosotros hacer no de hecho escribir “ prueba con recursos ” , en
9.6 Writing and Using Custom 243
Exceptions
En realidad, es solo un “ intento ” bloquear, pero “ intentar ” Va seguido de un
código que abre algún tipo de recurso, como un archivo o una conexión de base de
datos, en el siguiente formato.
prueba( código a abierto recurso aquí)
{
//…
}
// No requisito para "atrapar" o "finalmente" –
// estos son opcional
El recurso que se abre en la declaración “ try-with-resources ” puede ser
cualquier objeto que implemente [Link]. “ try-with-resources ”
intentará automáticamente cerrar el recurso si se lanza una excepción sin la
necesidad de un “ catch ” bloque o un “ finalmente ” bloque, aunque también se
pueden agregar para otro excepción manejo código. Nosotros voluntad ver
alguno código ejemplos de la declaración “ try-with-resources ” en capítulos
posteriores donde el código Java se conecta a recursos externos.
Ejercicio 9.3
• Crear a Cuenta bancaria clase con a " balance " campo y asociado “ captadores ” y
“ configuradores ” .
• Implemente el método “ débito ” para debitar el saldo o lanzar una
TransactionException.
• Escriba un método “ principal ” para probar su método de débito. En un bloque
“ try ” , establezca el saldo original de la cuenta y luego realice algunos débitos
hasta que se lance la excepción.
• Agregar a “ Finalmente ” bloquear después su “ Intenta atrapar ” bloquear eso
simplemente muestra a mensaje en el consola, demostrando eso el “
Finalmente ” bloquear voluntad ser ejecutado incluso si Se ha lanzado una
excepción.

9.2.4 Re-lanzando Costumbre Excepciones

En la sección anterior, sugerimos la posibilidad de volver a lanzar una excepción

diferente en un bloque “ catch ” , quizás reemplazando una excepción no
verificada con una excepción verificada. En este ejemplo, la clase CourseManager
tiene un método “ addCourse ” que intenta crear un objeto Course a partir de sus
argumentos de parámetros y agregar el curso a un formación. Allá son tres posible
excepciones eso podría ser arrojados por este código, dos desde el propio
constructor y uno desde la matriz. En este código, cada bloque “ catch ” arroja
una instancia de una excepción personalizada llamada
CourseConstructorException, cual es a comprobado excepción (a subclase de
Excepción). En En cada caso, el constructor utilizado es el que toma como
argumentos un String (un mensaje de error) y el objeto de excepción original.
244 9 Exception
Handling

paquete
[Link].chapter9;
clase pública CourseManager
{
privado Curso[] cursos = nuevo
Curso[10]; int privado contadorDeCursos
= 0;
público vacío agregarCurso(Cadena nombre, entero
días, doble costo) lanza
CourseConstructorException
{
intentar
{
cursos[número de cursos] = nuevo Curso(nombre, días,
costo); cursoCount++;
}
captura(IllegalArgumentException mi)
{
[Link]();
tirar nuevo CourseConstructorException
("Duración debe ser 1-10 días", mi);
}
captura(NullPointerException mi)
{

[Link]();
tirar nuevo
CourseConstructorException
("Curso nombre no puedo ser
nulo", mi);
}
captura(ArrayIndexOutOfBoundsException mi)
{
[Link]();
lanzar una nueva
CourseConstructorException ("No se
puede agregar cualquier más
cursos", mi);
}
}
}

En el siguiente " principal " método, allá son tres separado " intentar " bloques
que contiene llamadas al método “ addCourse ” . Cada una provoca
deliberadamente una de las tres excepciones a ser arrojado, pero en cada caso, el
recibió excepción voluntad sea una CourseConstructorException.
9.6 Writing and Using Custom 245
Exceptions

público estático vacío principal(Cadena[] argumentos)

{
Administrador de cursos Administrador de cursos = nuevo
Administrador de cursos();
// intentar con a nulo
curso nombre prueba
{
[Link](nulo, 3, 1000.0);
}
atrapar (Excepción del constructor del curso mi)
{
[Link]();
}
// intentar con
cero días intenta
{
[Link]("Java", 0, 1000.0);

}
atrapar (Excepción del constructor del curso mi)
{
[Link]();
}
// intentar a agregar más que
10 cursos de prueba
{
para(int i = 0; i < 11; yo++)
{
[Link]("Un curso", 3, 1000.0);
}
}
atrapar (Excepción del constructor del curso mi)
{
[Link]();
}
}
Los diversos seguimientos de pila que se generan mediante este “ principal ”
El método muestra tanto la CourseConstructorException como la excepción
subyacente que se lanzó originalmente. Este es el seguimiento de la excepción al
intentar crear un curso con un nombre de curso nulo. La NullPointerException
subyacente activa una CourseConstructorException.
246 9 Exception
Handling

[Link]: Curso nombre es nulo

en
[Link]([Link]
a:72) en
[Link].<init>([Link]
a:42) en
[Link]
([Link])
en [Link]
([Link])
[Link]:
Curso El nombre no puede ser nulo
en [Link]
([Link])
en
[Link](CourseManage
[Link]
)
Causado por: [Link]: Curso
nombre es nulo en
[Link]([Link]
)
en
[Link].<init>([Link]
:42) en
[Link](CourseMa
[Link] va:12)
... 1 más

Este es el pila rastro Producido cuando intentando a crear a curso con cero
como el número de días. Esta vez es una IllegalArgumentException la que activa
la CourseConstructorException.
[Link]: 0 es afuera el
válido rango de 1 - 10
en
[Link](Course.
java:93) en
[Link].<init>([Link])
en [Link]
([Link])
en [Link]
([Link])
[Link]:
Duración debe ser 1-10 días
en [Link]
([Link])
en [Link]
([Link])
Causado por: [Link]: 0 es
afuera El rango válido es de 1 a 10
9.6 Writing and Using Custom 247
Exceptions
en
[Link](Course.
java:93) en
[Link].<init>([Link])
en [Link]
([Link])
... 1 más

Finalmente, este es el seguimiento de excepción que se muestra cuando

intentamos agregar demasiados cursos a la matriz, donde
CourseConstructorException es activada por ArrayIndexOutOfBoundsException.
248 9 Exception
Handling

Excepción [Link]: 10
en [Link]
([Link])
en [Link]
([Link])
[Link]: No
puedo Añade más cursos
en [Link]
([Link])
en [Link]
([Link])
Causado por: Excepción
[Link]: 10 en
[Link]
([Link])
... 1 más

Ejercicio 9.4
• En Cap. 7 , nosotros creado a Módulo clase. A Curso sostiene a referencia a un
formación de objetos de módulo. Potencialmente, esto podría generar una
excepción ArrayIndexOutOfBounds. Agregue algún código de manejo de
excepciones a la clase Course para que intentar agregar demasiados módulos a
un curso no provoque el bloqueo del programa.
• Escribir a prueba " principal " método a prueba afuera su excepción manejo código.

Ejercicio 9.5
• Crear un Excepción clase llamado “ Excepción de módulo ” como a subclase de
Excepción.
• Integre esto en su respuesta al Ejercicio 9.4 para que ArrayIndexOutOf
BoundsException se vuelva a generar como ModuleException.

9.3 Opcional: Un Alternativa a "nulo"

En la década de 1990, cuando los patrones de diseño estaban muy de moda, Bobby
Woolf publicó el " Nulo Objeto " patrón. El básico concepto detrás este patrón era
Que a veces cuando uno objeto es colaborando con otro; él hace no siempre
Requerir que ese colaborador haga algo. Por ejemplo, podríamos tener una
colección de objetos de Cliente y buscar para un segundo nombre específico. Si
consultamos a uno de esos clientes por el segundo nombre y el cliente no tiene
uno, simplemente ignoramos él y mover en a el próximo Cliente. En típico Java
código, nosotros Podría hacerlo este por de cheques a ver si a referencia a un
objeto (en este caso a Cadena que contiene el segundo nombre) es “ nulo ” . Sin
embargo, sería mejor si el código pudiera tratar a un colaborador que no hace nada
de la misma manera que trata a uno que proporciona algún comportamiento.
Relación comercial con el Excepciones de puntero nulo eso puede ocurrir en a
9.6 Writing and Using Custom 249
Exceptions
sistema eso
250 9 Exception
Handling
tiene muchos capas de objetos poder dirigir a complejo codificación. Para
ejemplo, dejar a nosotros Supongamos que nosotros son de cheques el nombres de
empleados en a departamento. Allá podría ser Un código que se parece a esto:
Cadena siguienteSegundoNombre =
obtenerDepartamento(dept).obtenerEmpleados().
siguiente().obtenerSegundoNombre().obtenerNombre();

El problema es que el primer segundo nombre de un empleado puede ser nulo,

por lo que una NullPointerException se propagará hacia arriba a través de las
capas de objetos. Uso de [Link] clase marcas el código Más simple
porque él elimina el necesidad para La declaración condicional que verifica si hay
una referencia nula. Si bien no es exactamente una implementación de el Nulo
Objeto patrón, el Opcional clase, introducido con Java 8, ofrece características
similares.
Nota
La clase Opcional es una clase “ basada en valores ” , lo que significa que la
igualdad de dos objetos Opcional se basa únicamente en su estado, no en su
identidad de objeto .
Aquí es el comienzo de a simple Empleado clase, cual justo contiene
campos relacionados con el nombre. El aspecto clave a tener en cuenta aquí es que
“ SeniorName ” es un campo “ Opcional ”. objeto. Este código utiliza genéricos,
que cubriremos con más detalle en el Capítulo 1. 12 , pero en este caso, "
Opcional <Cadena> ” medio eso este Opcional objeto es de tipo String.
paquete
[Link].chapter9;
importar [Link];
clase pública Empleado
{
privado Cadena nombre de pila;
privado Opcional<Cadena>
segundoNombre; cadena privada
nombreDeFamilia;

El captadores y establecedores para el otro campos son como aquellos nosotros

tener visto antes, Así que aquí sólo mostramos los relacionados con el campo “
medioNombre ” :
público Cadena obtenerSegundoNombre()
{
devolver [Link](" ");
}
público vacío establecerSegundoNombre(Cadena segundo nombre)
{
[Link] = [Link](segundoNombre);
}
El “ obtenerSegundoNombre ” método usos el “ o si no ” método de el Opcional objeto
para configurar un valor alternativo si el valor de “ middleName ” es “ nulo ” .
En este caso, devuelve a Cadena que contiene a espacio. El “
establecerSegundoNombre ” método conjuntos el valor del Opcional a ser “ deNo
9.6 Writing and Using Custom 251
Exceptions
nulo ” . Este método permite el valor de el Opcional ser
252 Opcional: Un Alternativa a “ nulo ”
9.7 9 Exception 249
Handling

“ null ” . Este breve código de prueba muestra el Opcional en acción. Aunque uno
de los empleados tiene un segundo nombre que está configurado como “ null ” ,
no se lanza ninguna NullPointerException debido al uso del Opcional:
paquete
[Link].chapter9;
clase pública
DepartmentRunner
{
público estático vacío principal(Cadena[] argumentos)
{
Departamento departamento = nuevo Departamento();
[Link](new
Employee("Martin","Luther","King"));
[Link](new Employee("Malcolm",null,"X"));
para(Empleado e1 : [Link]())
{
carbonizarse mediadosInicial =
[Link]().charAt(0);
[Link](midInitial);
}
}
}

Aquí es el producción de correr el código. Nota eso No excepción es arrojado.

El medio nombre para el segundo empleado tiene estado reemplazado por a
espacio por el Objeto opcional, entonces todo nosotros ver es el “ Yo ” , cual es el
primero carta de el primero empleados segundo nombre.

9.4 Resumen

Este capítulo tiene Exploramos varios aspectos del manejo de excepciones en

Java, incluidas las palabras clave; “ throws ” , “ try ” , “ catch ” , “ finally ” y “
throw ” . Para entender cómo usar estas palabras clave en nuestro código, hemos
visto cómo la jerarquía de excepciones divide los tipos de excepción en
excepciones controladas, que son controladas por el compilador y requerir código
a manejar a ellos, y desenfrenado excepciones, dónde El compilador no impone el
código de manejo de excepciones (aunque puede ser muy útil incluirlo). Vimos
que, aunque el entorno de ejecución de Java incluye muchos tipos de excepciones,
también nos resultará útil crear nuestras propias subclases de Exception para
representar excepciones personalizadas, estas personalizadas para negocios
específicos del dominio. normas eso nosotros puede necesidad a hacer cumplir en
un solicitud. Excepciones proporcionar Nos ofrece un método robusto y flexible
para abordar estos problemas. Concluimos el capítulo con un breve ejemplo de uso
de la clase Opcional, que puede limitar la probabilidad de que una aplicación
genere excepciones NullPointerException.
Unidad Pruebas con JUnit
10

Las pruebas siempre han sido una parte importante del desarrollo de software,
pero en los últimos años, él tiene convertirse más de a programador actividad,
particularmente con el crecimiento En la popularidad de los métodos ágiles, se
espera que los programadores puedan escribir y ejecutar pruebas unitarias. contra
su código. La prueba unitaria es Diseñado para probar un unidad única de código,
por ejemplo, una sola clase o parte de una clase.
Una prueba es binaria: pasa o falla. Esto significa que debemos saber cuáles
son nuestros criterios para " pasar " y " fallar " antes de poder escribir una
prueba. Una prueba también debe ser automatizada tanto como sea posible; no
debe requerir interacción humana para ejecutarse, debe evaluar sus propios
resultados y notificar al programador solo cuando falla. Esto es no a decir eso allá
es No necesidad para manual pruebas; este es aún muy Importante. Sin embargo,
cuanto más pruebas podamos automatizar, más podremos centrar nuestros
esfuerzos de prueba manual en aquellos aspectos del sistema que realmente
requieren la imaginación humana de pruebas exploratorias.
Las pruebas unitarias se centran en los componentes más pequeños del código
orientado a objetos, donde el comportamiento de cada clase se expone a través de
métodos, probando tanto la interfaz de la clase (prueba de caja negra) como su
implementación (prueba de caja blanca). Esto las distingue, por ejemplo, de las
pruebas de aceptación o integración, donde las pruebas cubren Más grande
regiones de a sistema y puede involucrar muchos componentes y Capas
arquitectónicas. Las pruebas unitarias brindan claridad de propósito durante el
diseño detallado, la eliminación temprana de defectos (es decir, antes de la
integración) y nos ayudan a " aceptar el cambio " cuando las especificaciones
evolucionan.
Las pruebas unitarias fomentan un acuerdo temprano sobre el formato o los
valores de los argumentos. Por ejemplo, ¿cómo definiría un instrumento de
inversión para un sistema financiero? Un estándar internacional como el Número
Internacional de Identificación de Valores (Código ISIN), o un interno compañía
Nombramiento ¿sistema? Igualmente en tono rimbombante, bajo qué condiciones
son excepciones ¿lanzado? Y qué tipos de excepciones son arrojado

© Saltador Naturaleza Suiza Estado 2020 D. Parsons,

Foundational Java , Textos en Ciencias de la 251
Computación, [Link]
54518-5_10
252 10 Unit Testing with
JUnit
¿Por diferentes métodos? Las pruebas unitarias también se relacionan con el “
Diseño por contrato ” de Bertrand Meyer . dónde condiciones previas debe ser
Conocí por el llamador y post-condiciones debe ser Garantizado por métodos
desde unidad pruebas necesidad a colocar arriba específico condiciones previas y
prueba eso post-condiciones encontrarse esperanzas de heredar. Unidad pruebas
asegura eso semejante asuntos se abordan temprano en el proceso de diseño.
Por adoptando un automatizado unidad pruebas estructura, semejante como
JUnit, a apoyo Al crear sus pruebas unitarias, puede crear pruebas de manera
rápida y sencilla y ejecutarlas repetidamente como pruebas de regresión para
garantizar que los cambios en el código no hayan dañado partes del software que
se escribieron anteriormente. Los marcos de prueba permiten la refactorización
(cambio de el diseño de código sin cambio es comportamiento). Ellos poder
también Proporcionar métricas valiosas sobre el estado del proyecto y una
indicación de la estabilidad del código.
Unidad pruebas poder apoyo el ágil práctica de Basado en pruebas desarrollo,
dónde Las primeras pruebas se escriben antes de la unidad que se está probando.
Esto proporciona más apoyo para pensar en las pruebas como un componente del
diseño. Escribir las pruebas por adelantado permite centrarse más en las
condiciones previas, las condiciones posteriores y el formato y los valores de los
argumentos.
El general proceso es a alternar entre codificación y pruebas, bastante que
haciendo todo el código y luego escribiendo todas las pruebas (o, de hecho,
escribiendo todas las pruebas y luego escribiendo todo el código). Nosotros
desarrollar unidad pruebas en paralelo con el clases ser Las pruebas unitarias
deben probarse, incluso si se escribe la primera prueba antes de la clase si se
utiliza un enfoque basado en pruebas, lo que ayuda a aclarar los requisitos de la
clase antes de su desarrollo. Las pruebas unitarias deben estar bajo control de
versiones en paralelo con lo que prueban. Una clase no debe integrarse con otro
código hasta que haya pasado todas sus pruebas unitarias, y las pruebas unitarias
deben ser integrado con un automatizado construir proceso y usado como
regresión pruebas.

10.1 El JUnit Prueba Estructura

JUnit es un marco de pruebas unitarias de Java disponible públicamente escrito

por Kent Beck (también conocido como JUnit). Bueno conocido para ser el autor
de extremo Programación) y Erich Gamma (quizás más conocido por ser el autor
del libro de patrones de diseño “ Gang of Four ” ). El software de código abierto y
la documentación se pueden descargar desde [Link] . Existen
muchas herramientas y extensiones adicionales para JUnit, para ejemplo, para
pruebas web Componentes. Como es popularidad tiene crecido, Hay estado otro
similar unidad pruebas marcos creado para otro idiomas, que en conjunto se
conocen como la familia xUnit de marcos de prueba.
10.1El JUnit Prueba Marco 253

10.1.1 Usando JUnit con Eclipse

JUnit tiene a simple API eso (desde versión 4) usos anotaciones a permitir tú a
enchufar el estructura clases en su propio prueba código. Desde JUnit 5, allá tener
estado Tres subproyectos diferentes que componen el marco general: JUnit
Platform, JUnit Jupiter y JUnit Vintage. Para el desarrollador que escribe pruebas
unitarias, JUnit Jupiter es el más importante de estos. Junit 5 requiere Java 8 o más
tarde a correr. Muchos " frasco " archivos deben estar disponibles en “
modulepath ” para que podamos usar el marco. Para simplificar este, JUnit es
proporcionó como un Eclipse biblioteca pero es no automáticamente añadido a el
ruta del módulo de a proyecto. A agregar JUnit a a proyecto, seleccionar es
propiedades (seleccione “ Propiedades ” de la opción de menú “ Proyecto ” ) y
seleccione “ Ruta de compilación de Java ” , “ Bibliotecas ” pestaña. Prensa el
" Agregar Biblioteca …" botón y entonces elegir “ JUnit ” (Fig. 10.1 ). Hacer
clic el " Próximo " botón, y en el próximo diálogo (Higo. 10.2 ) seleccionar

Higo. 10.1 Añadiendo el JUnit biblioteca en el " Java Construir Camino " Proyecto
propiedades en Eclipse
254 10 Unit Testing with
JUnit

Higo. 10.2 Seleccionando JUnit 5 de El JUnit biblioteca lista desplegable

“ Junit 5 ” de la lista desplegable (las versiones anteriores, 3 y 4, también están

disponibles) y luego haga clic en “ Finalizar ” . Debería ver que la biblioteca
JUnit 5 se ha agregado a la ruta del módulo del proyecto (Fig. 10.3 ).

10.2 Prueba Casos y Unidades Bajo Prueba

A clase eso contiene unidad pruebas es conocido como a prueba caso . En orden a
comenzar usando JUnit, necesitamos un código para probar, conocido como la
unidad bajo prueba . En este capítulo, comenzaremos escribiendo algunas pruebas
para una clase simple destinada a representar documentos ISO 216. YO ASI 216
es el internacional estándar eso define el " A " y " B " Serie de tamaños de papel,
incluidos A3 y A4. Una clase como esta podría usarse, por ejemplo, como parte
de un solicitud eso Envía datos en documento formato a a impresora. El
10.2 Test Cases and Units 255
Under Test

Higo. 10.3 JUnit 5 agregado a el Java Construir Camino en el Proyecto Propiedades

diálogo

El ejemplo que se muestra aquí tiene muy pocos métodos, pero tiene un par de
constructores, incluido uno que establecerá el ancho y la altura del papel a partir
del nombre del formato, que se pasa como argumento de cadena al constructor.
Dado que todas las medidas en ISO 216 están en milímetros enteros, podemos
usar el “ int ” Tipo de datos para representar la altura y el ancho del documento.
Solo dos de los muchos “ A ” y “ B ” Los tamaños de papel son incluido aquí,
A4 (210 mm 297 mm) y A3 (297 mm 420 (mm).
256 10 Unit Testing with
JUnit
10.2 Test Cases and Units 257
Under Test

10.2.1 Creando a JUnit Prueba Caso

En es más simple, a escribir a JUnit prueba caso, nosotros escribir a clase eso
importaciones el [Link], junto con al menos un método de la
clase “ Assertions ” clase y tiene al menos un método con una anotación @Test.
Las pruebas son autónomas y se ejecutan de la misma manera, mediante ejecutores
de pruebas JUnit. Eclipse tiene un ejecutor de pruebas integrado que es fácil de
usar. En esta sección, repasaremos los pasos básicos para crear y ejecutar una
clase de caso de prueba simple con un solo método de prueba.
Puede agregar un nuevo “ caso de prueba JUnit ” a un proyecto de
Eclipse seleccionando “ Nuevo ” ! “ Junit ” Prueba Caso ” de el " Archivo "
! Menú “ Nuevo ” artículo. Este voluntad mostrar el " Nuevo JUnit Prueba caso
" diálogo (Figura 10.4 ). En este ejemplo, nosotros son creando a caso de prueba
llamado “ ISO216DocumentTestCase ” . Para usar JUnit 5, asegúrese de que “
New JUnit Júpiter prueba " es seleccionado.
258 10 Unit Testing with
JUnit

Higo. 10.4 Creando a JUnit prueba caso con el " Nuevo JUnit Prueba Caso " diálogo

Con el por defecto ajustes, el " Nuevo JUnit Prueba Caso " diálogo voluntad
generar a clase con las importaciones más importantes y un método con una
respuesta " fail " predeterminada.
10.2 Test Cases and Units 259
Under Test

Si tú desear a generar a talón eso es Dirigido hacia a específico clase a ser

Probado, el " Nuevo JUnit Prueba Caso " diálogo incluye un opción a elegir el "
Clase bajo prueba ” (Fig. 10.4 ). Esta opción le permite buscar la clase que se va a
evaluar y, en la siguiente diálogo (el " Próximo " botón voluntad ser activado si tú
elegir a clase bajo prueba), puede seleccionar los métodos que se van a probar.
Figura 10.5 muestra los dos constructores que se están seleccionando. Puede elegir
tantos métodos disponibles como desee.
El siguiente código quería ser generado de el diálogo selección en Higo. 10.5 .
260 10 Unit Testing with
JUnit

La siguiente sección explica las distintas características del código. La llamada

a la función “ fail ” El método debe eliminarse cuando se escribe el cuerpo del
método de prueba, ya que se hace deliberadamente. marcas el prueba fallar hasta
tú tener implementado él (nosotros conversar el método de “ falla ” Más tarde en
este capítulo). Deberías soportar En mente que configurar solo una prueba para a
método es no suficiente, entonces tú quería necesidad a a mano agregar otro
prueba métodos para el caso de prueba para obtener una cobertura de prueba
adecuada.
10.2 Test Cases and Units 261
Under Test

Higo. 10.5 Seleccionando métodos a prueba cuando creando a nuevo JUnit prueba caso

10.2.2 Requerido Importaciones

Como demuestra el código auxiliar de clase generado, un caso de prueba de JUnit

necesita importar clases desde el marco de trabajo JUnit Jupiter. Muchas de las
clases que usamos directamente están en “ [Link] ”. paquete.
Primero, importamos los métodos estáticos de la clase
[Link]. La tarea principal de una prueba es hacer
afirmaciones que comparen el resultado esperado de un fragmento de código con
lo que obtenemos. Los métodos que hacen estas afirmaciones en JUnit se
especifican como métodos estáticos de la clase [Link].
Debido a que todos los métodos son estáticos, deben invocarse. en el clase,
bastante que en un objeto. A permitir a nosotros a hacer este sin
262 10 Unit Testing with
JUnit
constantemente teniendo a referirse a el Afirmar clase, nosotros poder usar a
estático importar, cual es Un poco diferente de las importaciones que conocemos
de los capítulos anteriores. Tenga en cuenta la usar de el “ estático ” palabra
clave y el comodín eso aparece después el clase nombre

Esto importa todos los métodos estáticos de la clase Assertions. Por supuesto,
puede importar los métodos requeridos individualmente en lugar de usar el
comodín, y la opción “ organizar importaciones ” de Eclipse reemplazará el
comodín con los métodos específicos que use. Por ejemplo, esta línea importa solo
el método estático “ asserteEquals ” de la clase Assertions.

También necesitamos importar cualquier clase de anotación necesaria (cada

anotación se implementa por a clase). El básico anotación es " @Prueba " ,
entonces nosotros necesidad a Importe la clase [Link].

10.2.3 Escribiendo Prueba Métodos

Nosotros debe proporcionar en el menos uno prueba método para el clase para él a
correr cualquier pruebas. Todo Los métodos de prueba deben ir precedidos de una
anotación “ @Test ” , de lo contrario, JUnit los ignorará en tiempo de ejecución.
Un método de prueba debe devolver “ void ” y no aceptar parámetros, por
ejemplo,

El método nombre es no importante. Él hace no tener a comenzar con " prueba

" (aunque solía ser así en versiones anteriores de JUnit).
Nosotros también necesidad a asegurar eso cada prueba método tiene en el
menos uno afirmación en él ya que simplemente correr código es no suficiente a
prueba él. Nosotros debe comparar el actual resultados de la prueba con lo que
esperamos que sean. Las afirmaciones comparan dos valores para ver si son son el
mismo. Si ellos son no, falla es señalado a el prueba estructura. Allá Hay varios
métodos “ assert …” sobrecargados en la clase Assertions que podemos usar para
probar el código. En este ejemplo, usamos el método “ assertEquals ” para
comparar dos valores enteros, que en este caso representan los valores esperados y
reales devueltos por el método “ getWidth ” de un objeto ISO216Document.
10.2 Test Cases and Units 263
Under Test

El método “ asertEquals ” compara el resultado esperado (el primer argumento

del parámetro) con el actual resultado (el segundo argumento). Si ellos son no
igual, él banderas una error a el prueba estructura en tiempo de ejecución. El
método es sobrecargado a trabajar con Todos los tipos de datos.

10.2.4 El Eclipse Prueba Corredor

A JUnit prueba caso es correr usando a prueba corredor. Eclipse tiene es propio
gráfico prueba Ejecutor que se puede ejecutar con cualquier clase de caso de
prueba JUnit. Todo lo que necesita hacer es hacer clic derecho en la prueba clase
y seleccione “ Ejecutar como …” ! “ JUnit Test ” para invocar el ejecutor de
pruebas gráfico, cual aparece como a pestaña o poder ser separado como a
flotando ventana. Cifra 10.6 muestra el gráfico prueba corredor después correr el
Caso de prueba de documento ISO216. Cuando se ejecuta una prueba utilizando
un ejecutor de pruebas gráfico, se muestra la cantidad de métodos de prueba
ejecutados junto con una barra de progreso roja o verde (dependiendo del éxito de
las pruebas).
Intentemos agregar otro método de prueba que rompa deliberadamente el
código. Escribir pruebas para romper la implementación actual es un enfoque
estándar en el desarrollo basado en pruebas. Cada vez que rompemos el código
con una prueba, nos da la oportunidad a hacer el código sí mismo más robusto.
Aquí, nosotros agregar a “ pruebaA4Altura ” método de prueba, pero pasa “ a4 ”
como argumento del parámetro.
264 10 Unit Testing with
JUnit

Desde el actual constructor solo reconoce “ A4 ” como a válido cadena, él falla

a Establece el valor del campo de altura para el documento, de modo que el valor
predeterminado sea cero.
10.2 Test Cases and Units 265
Under Test

Higo. 10.6 A exitoso prueba indicado en el Eclipse JUnit prueba corredor

Este es un buen ejemplo de la necesidad de acordar los formatos y valores de

los argumentos de los métodos, que este tipo de proceso de prueba pone de relieve
para que podamos tomar estas decisiones de diseño de manera temprana, antes de
que se conviertan en errores más adelante en el proceso de desarrollo.
Cuando el modificado prueba caso es correr, a lista de todo prueba fallas
voluntad aparecer en el ventana principal de el prueba corredor. Seleccionando a
falla en el superior cristal voluntad mostrar el Mensaje de error completo en el
panel inferior (Fig. 10.7 ). En esta ejecución de prueba, debido a la segunda
prueba fallida, aparece una barra roja en la ventana del ejecutor de pruebas.
También muestra que el “ testA4Width ” método aprobado el prueba, pero todo
pruebas debe aprobar para el bar a ser verde.
266 10 Unit Testing with
JUnit

Higo. 10.7 Fallas en las pruebas indicado en el Eclipse JUnit corredor de pruebas

Ahora necesitamos corregir el error actual en la unidad bajo prueba, para que
pueda manejar letras minúsculas. El método String “ equalsIgnoreCase ” nos
permitirá aceptar cadenas donde la letra puede estar en mayúsculas o minúsculas:
10.2 Test Cases and Units 267
Under Test

Este podría no ser el completo (o solo) solución a el asunto de diferente Los

formatos de cadena se pasan al constructor pero hacen que el código pase el
conjunto actual de pruebas, que es lo importante. Si queremos exponer otras
debilidades en la implementación, por ejemplo, no tener un tamaño de papel
predeterminado razonable, necesitamos escribir otro pruebas a romper el código,
arreglar el código de nuevo, y mantener yendo hasta nosotros han corrido afuera
de ideas acerca de cómo a romper el código. Una vez nosotros tener hecho este
arreglar, si nosotros Ejecute el caso de prueba nuevamente, entonces las pruebas
pasarán y la barra será verde (Fig. 10.8 ).
Ejercicio 10.1

• Agregar “ pruebaA3Ancho ” y “ pruebaA3Altura ” métodos a el

Documento ISO216 Clase mentTestCase.
• Correr el pruebas y asegurar eso ellos aprobar.
• Modifique la clase ISO216Document para que el tamaño del papel se
establezca en A4 de forma predeterminada.
• Escribir a prueba método a controlar eso si el constructor es aprobado un vacío
cadena, que la altura y el ancho del papel estén configurados correctamente
según los valores predeterminados.
• Hacer seguro eso su actualizado clase pasa todo el pruebas.
268 10 Unit Testing with
JUnit
10.3 Tipos de Afirmaciones

En los métodos de prueba de ejemplo que hemos visto hasta ahora, hemos estado
utilizando el método “ asser - tEquals ” . Este método está sobrecargado tanto por
los tipos de parámetros como por la cantidad de parámetros. Para los primitivos,
hay dos métodos “ asser-tEquals ” para cada tipo de primitivo, uno con dos
parámetros (los valores que se comparan) y otro con un parámetro de mensaje
adicional.
10.3 Types of 265
Assertions

Higo. 10.8 El Eclipse JUnit prueba corredor después todo pruebas en a prueba caso tener
estado aprobado

El versión nosotros tener estado usando acepta dos entero parámetros, el

esperado valor y el valor real. La otra versión del método toma tres parámetros;
los dos valores que se comparan y un parámetro de mensaje String adicional, es
decir,

La versión del método que tiene el parámetro “ mensaje ” simplemente usa

esta cadena como parte de el producción si el afirmación falla. Allá son muchos
similar métodos sobrecargados para probar otros tipos de datos.
266 10 Unit Testing with
JUnit
10.3.1 Afirmando Punto flotante Igualdad

Para valores de punto flotante ( flotante o doble), existe un “ delta ” argumento

(lo permisible margen de error). Desde punto flotante aritmética en avena
flotante o dobles poder dirigir demasiado pequeño errores, nosotros debe llevar
este en cuenta cuando escribiendo pruebas. El delta Aparece el argumento después
el dos punto flotante valores en el argumento lista. Si allá es a mensaje String,
aparece como último argumento.

Por ejemplo, si quisiéramos probar el “ getArea ” método de la clase

Rectángulo del Cap. 8 , necesitaríamos proporcionar un valor delta.

El delta valor poder ser cero si el prueba requiere 100% exactitud.

10.3.2 Objeto Igualdad

Como Bueno como prueba primitivo valores, los El método “ asertEquals ”

puede También comparar objetos (utilizando el método “ igual ” ).

El “ afirmar lo mismo ” métodos controlar si dos referencias punto a el mismo

objeto. Esto puede tener a diferente significado que usando “ afirmarIgual ” si el
“ es igual a ” método Se ha anulado para la clase de objetos que se están
probando.

Para ejemplo, nosotros podría desear a controlar si dos referencias punto a el mismo
objeto.

Mientras en otro circunstancias, nosotros podría desear a ver si dos objetos de

10.3 Types of 267
Assertions
el misma clase tener el mismo estado (arrogante “ es igual a ” tiene estado
anulado a permitir este).
268 10 Unit Testing with
JUnit
10.3.3 Otro Afirmaciones

Además de “ asertEquals ” y “ assertSame ” , que comprueban la igualdad, hay

varios otro tipos de afirmación. Este sección introduce alguno de estos pero hay
otros. Tú son recomendado a leer el JUnit documentación para lleno detalles de las
afirmaciones disponibles.
Las afirmaciones con condiciones booleanas comprueban si una condición es
verdadera o falsa. Estas afirmaciones son hecho con el “ afirmarVerdadero ” o “
afirmarFalso ” métodos, cual de nuevo se sobrecargan para permitir un parámetro
de mensaje opcional, además de la condición booleana requerida. Dado que
cualquier declaración condicional se puede verificar con este tipo de afirmación,
brindan una gran flexibilidad sobre lo que queremos probar.
Atrás en Cap. 4 , allá era alguno código escrito a prueba si el simulado rollo de
a morir fue dentro el rango 1 – 6, pero eso código hizo no usar cualquier objetos o
a prueba marco. Esta versión de la prueba utiliza el método “ assertTrue ” para
comprobar que el método “ getRoll ” de el Morir clase de Cap. 6 hace en efecto
generar a número entre 1 y 6.

Objeto referencias poder ser comprobado a ver si o no ellos son " nulo " , utilizando el
“ afirmarNull ” y “ afirmarNoNull ” métodos:
10.3 Types of 269
Assertions
Puede resultar útil utilizar estas afirmaciones cuando un objeto tiene otro objeto
como campo. Es posible que queramos asegurarnos de que un campo apunte a “
null ” , o a un objeto agregado, según su estado esperado. En este ejemplo,
utilizamos la clase Location del capítulo 8. Dado que tiene un constructor de cero
argumentos, esperamos la cadena “ address ”. campo a ser " nulo " cuando un
objeto es primero creado. Sin embargo, si el
270 10 Unit Testing with
JUnit
“ setAddress ” y este campo ya no debería ser “ nulo ” . Los métodos de prueba
del siguiente caso de prueba comprueban que estas suposiciones sean correctas.

Nota
Incluso cuando se utiliza un objeto opcional como campo, pueden ser necesarias
pruebas de “ nulo ” ya que los objetos opcionales pueden configurarse para
permitir que se devuelvan valores nulos.
Ejercicio 10.2
En el muestra ejercicio código disponible para este libro, tú voluntad encontrar a
Clase RectangularArea para probar. Cree un caso de prueba JUnit para esta clase y
agregue métodos de prueba según corresponda a la clase, por ejemplo,

• Área de prueba
• pruebaPerímetro
• Orientación de la prueba
• pruebaEsCuadrado
• etc.

En el espíritu del desarrollo basado en pruebas, estas pruebas requieren un

enfoque de “ caja blanca ” . Es necesario conocer el código de implementación,
no solo la interfaz externa de los métodos desde una perspectiva de “ caja negra ”
.
10.4Excepciones y Tiempos muertos 269

10.4 Excepciones y Tiempos de espera

No todo pruebas es acerca de esperando código a producir el correcto resultados.

A veces Nosotros esperamos código a tirar un excepción. Pruebas eso esperado
excepciones hacer ocurrir es precisamente como importante como pruebas código
dónde nosotros hacer no esperar cualquier excepciones. JUnit proporciona una “
afirmarLanzamientos ” método eso permite a nosotros a especificar un esperado
excepción basado en código expresado en una expresión lambda ejecutable.

El prueba voluntad fallar cualquiera si No excepción es arrojado o a diferente

excepción tipo es lanzado. El constructor de nuestro Curso clase poder tirar a
pareja de excepciones. Uno de estos es el Excepción de argumento ilegal eso
voluntad ser arrojado si el número de días esta afuera el rango 1 – 10. En este
prueba método nosotros aprobar cero como el número de días y esperar que se
lance la IllegalArgumentException.

Como largo como el esperado excepción de hecho obtiene arrojado, el prueba voluntad
aprobar.
Otra aserción que incluye una expresión lambda ejecutable es “ AssertTimeout
” , que hace que una prueba falle si tarda más de un tiempo especificado en
milisegundos en completarse. Esto es útil para probar requisitos no funcionales
relacionados con el rendimiento, así como para evitar que un conjunto completo
de otras pruebas en la misma suite de pruebas de regresión se detengan esperando
una respuesta en particular. ejemplo prueba (cual hace no hacer cualquier cosa
útil, justo ejecuta un El bucle vacío muchas veces fallará si no se completa en
menos de un milisegundo.
272 10 Unit Testing with
JUnit
270 10 Unit Testing with
JUnit
10.5 Forzando Fallas

La mayoría de las veces, los fallos de las pruebas se deben al marco JUnit. Sin
embargo, en ocasiones, nosotros puede desear a desencadenar a prueba falla
nosotros mismos, basado en alguno falla de una regla de negocio o una excepción
inesperada. Esto se puede hacer con el método " fail " , que, como afirmaciones,
llega en varios versiones, incluido uno con a mensaje y argumentos " Throwable "
:

Estos métodos son particularmente útil cuando tú desear a fuerza fallas en

Bloques “ catch ” dentro de los métodos de prueba; por ejemplo, podríamos poner
un “ try-catch ” Bloquee nuestro código de prueba y esté preparado para detectar
cualquier excepción arbitraria e inesperada que pueda ocurrir.

La razón para hacer esto es que si permitimos que ocurran excepciones

inesperadas en el código de prueba, el entero prueba voluntad terminar y No otro
prueba métodos voluntad ser ejecutado. Si Capturamos la excepción y activamos
el " error ". método, los demás métodos de prueba en el caso de prueba
continuarán ejecutándose (aunque, por supuesto, el ejecutor de pruebas señalará la
falla de la prueba). Este es un ejemplo un tanto artificial, ya que sabemos que
intentar acceder al índice del módulo 100 generará una excepción.
10.5 Forcing 27
Failures 1

Higo. 10.9 Prueba corredor producción demostración el desencadenante de a

método de “ falla ” de a atrapar bloque, que permite ejecutar pruebas posteriores

Figura 10.9 muestra que el desencadenamiento del “ fallo ” del método “

generalExceptionTest ” causas eso prueba a fallar pero permite el restante prueba
métodos en el prueba caso a ejecutar.
 272 10 Unit Testing with
JUnit
10.6 Organizar una Prueba con @AntesDeCada y Métodos
@AfterEach

Además de sus métodos de prueba, una clase de prueba también puede incluir “
BeforeEach ” y “ AfterEach ”. métodos. Estos métodos son útiles para crear un
dispositivo de prueba, inicializar datos y liberar recursos respectivamente.
@AntesDeCada métodos inicializar datos para a prueba

@DespuésDeCada es para liberador arriba recursos después a prueba

Tenga en cuenta que estos métodos se ejecutan antes y después de cada método
de prueba, no antes y después de todo el conjunto de pruebas en el caso de prueba,
porque las pruebas individuales no deben interferir entre sí. Por ejemplo, si el
método “ BeforeEach ” inicializa prueba datos él debe hacer entonces antes cada
prueba método, no justo antes el primero.

10.6.1 El 3A Patrón

Pruebas tener a común patrón, descrito por Factura Despertar como “ Organizar-
Actuar-Afirmar ” (a menudo abreviado como “ 3A ” )

1. Organizar - crear Algunos objetos

2. Actuar — estimular a ellos
3. Afirmar — comprobar el resultados

El primer paso (organizar) suele ser el mismo de una prueba a otra. Por lo
general, es una buena idea restringir los métodos de prueba a una única afirmación
para cada prueba. Esto garantiza eso cada prueba método es solo pruebas uno
aspecto de el unidad bajo prueba, entonces que cuando una prueba falla es fácil
aislar la afirmación que ha fallado. Si un método contiene varios Afirmaciones y
el primero uno falla, el otros voluntad no conseguir Probado hasta el primero
afirmación tiene éxito A consecuencia de este es eso nosotros puede desear a
colocar arriba Un objeto en a repetible forma y entonces correr muchos pruebas
contra eso mismo objeto estado. Si nosotros hacer este en cada soltero prueba
método, entonces nosotros conseguir lotes de código duplicación, con El potencial
para errores eso Esto se presentará aquí. para ejemplo, es a método de prueba que
10.5 Forcing 27
Failures 1
podría ser usado con el Curso clase. Mayoría de el método es tomado arriba con
configuración Levante el objeto a probar.
10.6 Arranging a Test with @BeforeEach and 273
@AfterEach Methods

Este objeto puede ser útil para ejecutar muchas pruebas diferentes, pero no
queremos todo este código de configuración en cada método de prueba. Aquí es
donde resulta útil un método “ BeforeEach ” . Solo necesitamos escribir el código
de configuración una vez, en lugar de en cada prueba.
Cuando crea un caso de prueba JUnit en Eclipse, el “ Nuevo caso de prueba
JUnit ” El diálogo tiene varios opciones de casilla de verificación (Figura 10.10 ).
En Este diálogo, " configuración " voluntad generar el stub de un método “
@BeforeEach ” , y “ tearDown ” generará el stub para un método “ @AfterEach
”.
Nota
Los nombres “ setUp ” y " derribar " son nombres de los métodos equivalentes
utilizados en versiones anteriores del marco JUnit.
El código auxiliar del método “ setUp ” se generará de la siguiente manera. El
nombre del método no es importante, solo la anotación.
274 10 Unit Testing with
JUnit

Nosotros poder poner el configuración código en este método, y entonces el

prueba método solo necesita contener el afirmación. Nosotros debe, sin embargo,
hacer seguro eso el objeto ser Probado está disponible a lo largo de el clase,
entonces a referencia a él necesidades a ser declarado como a campo del caso de
prueba. De esta manera, el “ BeforeEach ” El método y los métodos de prueba
pueden acceder al mismo campo que hace referencia al objeto Curso.
10.6 Arranging a Test with @BeforeEach and 275
@AfterEach Methods

Higo. 10.10 Generando un “ BeforeEach ” método utilizando el Eclipse “ Nuevo Caso de

prueba JUnit ” diálogo

En el “ BeforeEach ” Método, utilizamos el “ curso ” campo para hacer

referencia al objeto Curso que se va a probar.
276 10 Unit Testing with
JUnit

El prueba métodos voluntad también usar el " curso " campo a acceso el
prueba objeto. Nosotros También puede agregar métodos que cambien el estado
del objeto y ejecuten pruebas contra él. Dado que el método “ BeforeEach ” se
ejecuta antes de cada prueba, el Curso y sus Módulos se volverán a crear para cada
prueba, por lo que no existe el peligro de que las pruebas separadas interfieran
entre sí. Aquí, se ejecutan tres métodos de prueba separados contra el Curso
objeto. Dos de estos modificar su propio versiones de el objeto pero voluntad no
afecta a los objetos creados para otras pruebas.
10.6 Arranging a Test with @BeforeEach and 277
@AfterEach Methods
278 10 Unit Testing with
JUnit
10.6.2 @AntesDeTodo y @DespuésDeTodo Métodos

Mientras que los métodos “ BeforeEach ” y “ AfterEach ” se ejecutan antes y

después de cada individual prueba método, él es también posible a ejecutar alguno
código una vez, antes o después de todos los métodos de prueba en un solo caso
de prueba, utilizando las anotaciones “ @BeforeAll ” y “ @AfterAll ” . Los
métodos “ @BeforeAll ” inicializan datos para un conjunto de pruebas:

@DespuésDeTodo es para liberador arriba recursos después a colocar de pruebas:

A diferencia de “ BeforeEach ” y “ AfterEach ” , los métodos que utilizan

estas anotaciones deben ser estáticos (aunque hay algunas configuraciones
avanzadas en JUnit que pueden anular esto). Cuidado es requerido cuando usando
estos anotaciones desde él es básico a hacer seguro que cada prueba es aislado de
otro pruebas. Si a recurso es creado en “ Antes de todo ” y modificado por una
prueba, entonces eso podría afectar a todas las pruebas posteriores. Sin embargo,
existen algunas buenas razones por las que puede querer que se ejecute algún
código de configuración una vez antes de una serie de pruebas. Por ejemplo, es
posible que queramos abrir una conexión a un recurso externo como una base de
datos de prueba. Sería muy ineficiente abrir y cerrar una base de datos. conexión
para cada soltero prueba método, entonces apertura el conexión antes de todas las
pruebas y luego cerrarlo al final sería mejor. En otros casos, es posible que
queramos a inicializar a grande y complejo objeto para pruebas pero solo leer
datos de él en una serie de pruebas. Como esto no cambiaría el estado del objeto ,
podríamos crearlo una vez (usando un campo estático) y luego ejecutar una serie
completa de métodos de prueba que interactúan con el objeto sin cambio él. A
garantizar eso nosotros hacer no cambiar El objeto, nosotros podría crear un
interfaz para el clase eso expone solo el métodos que no cambian el objeto y usan
esa interfaz en el código de prueba.
Ejercicio 10.3

• Pendiente a a cambiar en requisitos, el Documento ISO216 ahora necesidades a

afrontar con el A NOSOTROS T a m a ñ o “ carta ” . Bastante
inconvenientemente este medidas 8½ por 11 pulgadas (215,9 mm 279,4
mm) y no forma parte de la norma ISO216.
• Escribir a prueba caso para a adecuadamente renombrado clase eso poder crear
un instancia en tamaño de letra y mantener es Medidas en punto flotante
milímetro valores como Bueno como pulgadas.
• Agregar todo el métodos a el prueba caso eso tú pensar son necesario a prueba " Carta
"
10.6 Arranging a Test with @BeforeEach and 279
@AfterEach Methods
dimensionado documentos.
• Una vez tú tener escrito el prueba caso, volver a escribir el clase a aprobar todo el
pruebas.
10.7
280 Escribiendo a Prueba Suite 277
10 Unit Testing with
JUnit
10.7 Escribiendo a Prueba Suite

Uno de los aspectos importantes de las pruebas unitarias automatizadas es la

capacidad de volver a ejecutar las pruebas cada vez que se integra un nuevo
código, para garantizar que no se haya roto nada en el código existente. código por
reciente cambios. Este proceso es conocido como “ regresión prueba ” . Una
forma de ayudar a crear pruebas de regresión es mediante la creación de conjuntos
de pruebas. Un conjunto de pruebas comprende una o más pruebas, agrupándolas
para que puedan ejecutarse juntas. Puede crear un conjunto de pruebas utilizando
las anotaciones “ @RunWith ” y “ @SelectClasses ” (y/o “ @SelectPackages ”
). Las clases actuales para crear un conjunto de pruebas se basan en algún código
JUnit 4 que admite la anotación “ @RunWith ” del módulo “ vintage ” . (Para
cuando lea esto, es posible que ya esté disponible un ejecutor Junit 5 completo).
Las “ SelectClasses ” La anotación especifica qué casos de prueba se deben
agregar al conjunto. Una sola clase de prueba aparece entre paréntesis, por
ejemplo:

Si se va a probar más de una clase, lo que es más probable para un conjunto de

pruebas, La lista de clases separadas por comas está rodeada por llaves:

Seleccionando paquetes acepta a similar forma, para ejemplo:

Este ejemplo clase, “ ShapeSuite ” , corre dos otro prueba clases, Prueba de
rectángulo y CircleTest.

Tú poder agregar como muchos prueba clases a a suite como tú como, incluido
otro prueba clases de suite, Permitiendo tú a construir arriba a grande colocar de
regresión pruebas encima tiempo eso poder ejecutarse desde un único conjunto de
pruebas.
278 10 Unit Testing with
JUnit
Ejercicio 10.4
Escriba un conjunto de pruebas que ejecute todas las clases de casos de prueba que
ha creado para los ejercicios anteriores.

10.8 Resumen

En este capítulo se presentó el concepto de pruebas unitarias que, como parte de

una estrategia de pruebas general, no solo ayuda a mejorar la calidad del código,
sino que también puede ayudar a impulsar el diseño del código. Los ejemplos de
este capítulo utilizaron el marco de pruebas JUnit 5, que marcas él fácil a crear y
correr unidad pruebas eso hacer Afirmaciones contra código (en unidades bajo
prueba) para garantizar que se comporte como se espera. Se demostraron varios
tipos diferentes de aserción en ejemplos de código, incluidos aquellos que tratan
con excepciones. manejo, tiempos de espera y forzado fracasos. Nosotros sierra
cómo JUnit es incluido como una biblioteca de Eclipse que se puede agregar a la
ruta de compilación de un proyecto y cómo se pueden crear casos de prueba
fácilmente ser creado y correr usando el integrado gráfico prueba corredor. El
Capítulo explicado cómo individual prueba casos son creado, a lo largo de con el
requerido Anotaciones para ejecutar pruebas y configurar el código para las
pruebas. También introdujo la creación de conjuntos de pruebas. eso permitir
múltiple prueba casos a ser correr juntos. Alguno relacionado asuntos semejante
También se discutieron el desarrollo basado en pruebas, las “ 3A ” y las
pruebas de regresión.
Explorador el Java Bibliotecas
11

En este capítulo, analizaremos brevemente algunas de las clases más utilizadas en

el Java bibliotecas. El ejemplos cubierto aquí son destinado a ser justo a pequeño
Ejemplo de un posible conjunto de clases que podrías querer usar. El objetivo
principal de este capítulo es alentarte a reutilizar las clases existentes tanto como
sea posible en tu programación. no a “ reinventar el rueda " . Uno de el
llave cosas Lo que ofrece la programación orientada a objetos es la capacidad de
reutilizar clases existentes. La reutilización tiene dos ventajas principales. En
primer lugar, ahorra su propio tiempo al no tener que implementar el código.
Segundo, código en estándar bibliotecas tiene ya estado Probado extensamente
entonces allá es No necesidad a prueba él tú mismo. Si tú encontrar tú mismo
Necesitando a realizar un proceso particular o crear un tipo particular de objeto,
entonces es posible que ya exista una implementación adecuada en Java,
particularmente si el proceso o la clase podrían ser consideró a ser a de propósito
general uno bastante que ser dominio específico. Lo más importante es
acostumbrarse a utilizar Javadoc como un recurso frecuente, comprobando qué
clases hay en la biblioteca que se puedan reutilizar antes de escribir cualquier
código nuevo.
Este capítulo sólo cubre una pequeña cantidad de paquetes en el entorno de
ejecución estándar de Java. Por supuesto, hay muchos más paquetes y clases que
no se tratan aquí, por no mencionar la enorme cantidad de otras bibliotecas
disponibles, ya sea comercialmente o a través de proyectos de código abierto, que
puede utilizar en su propio código. De hecho, el arte de la programación en Java
consiste en ensamblar componentes de otras fuentes de una manera útil y robusta,
en lugar de escribir código desde cero.

11.1 Frecuentemente Usado Clases en el “[Link]” Paquete

Nosotros voluntad comenzar este capítulo con a breve descripción general de

alguno de el clases en el “ [Link] ” paquete, casi todo de cual nosotros tener ya
usado a alguno medida en capítulos anteriores .

© Saltador Naturaleza Suiza Estado 2020 279

D. Parsons, Foundational Java , Textos en
Ciencias de la Computación,
[Link]
280 11 Exploring the Java
Libraries
• [Link]
• [Link]áticas
• [Link]
• [Link]
• Envoltura clases — [Link], etc.

11.1.1 El [Link] Clase

Nosotros sierra en Cap. 8 eso Objeto es en el raíz de el Java clase jerarquía,

entonces hechos como una superclase para todo otro clases. Este medio eso cada
clase hereda el métodos que son definido en el Objeto clase. El Objeto clase define
el por defecto comportamiento para todos los objetos a través de los métodos que
hemos utilizado en capítulos anteriores:
es igual a ([Link]) //
devuelve un booleano getClass() //
devuelve un objeto de clase
toString() // devuelve una representación de
cadena del objeto hashCode() // devuelve un
entero para indexar tablas hash

El objeto también proporciona la “ espera ” , “ notificar ”. y “ notificar a

todos ” métodos relacionados con subprocesamiento múltiple. Estos métodos se
tratarán en el capítulo 16. Los únicos otros métodos de la clase Object son “
finalize ” y “ clone ” .

protegido vacío finalizar() lanza Arrojable

protegido Objeto clon() lanza Excepción CloneNotSupported

[Link] El "finalizar" Método

El “ finalizar ” método obtiene llamado en un objeto si él es basura coleccionado.
Desde hay No garantizar eso a dado objeto voluntad alguna vez ser basura
coleccionado durante el tiempo de ejecución de a programa, allá es similarmente
No garantizar eso este método voluntad alguna vez ser llamado. Su papel es a
proporcionar un oportunidad para un objeto a liberar cualquier recursos eso él
puede se debe mantener antes de que se descarte. Por ejemplo, se puede usar para
garantizar que un archivo que el objeto ha abierto se cierre antes de que el objeto
sea recolectado como basura.
Tanto el método “ finalize ” como el método “ clone ” tienen visibilidad “
protegida ” en la clase Object, por lo que no están disponibles automáticamente
como métodos públicos de las subclases. Es poco probable que desee que “
finalize ” sea un método público. Sin embargo, es posible que desee que el
método “ clone ” sea público.

[Link] El "clon" Método

11.1 Frequently Used Classes in the 281
“[Link]” Package
“ clonar ” hace una copia del objeto actual. De manera predeterminada, solo hace
una copia superficial . cual medio eso cualquier objeto o formación referenciado
en el copiado objeto voluntad
282 11 Exploring the Java
Libraries
punto a el mismo objetos como el unos ser copiado. En eso sentido, el “ clon ”
método es, por por defecto, equivalente a usando el asignación operador, eso es,

Objeto objeto2 = objeto1;

por por defecto, es igual a

Objeto objeto2 = [Link]();

Esto es como los “ iguales ” método, que por defecto tiene el mismo
comportamiento que el operador de igualdad. Como vimos en el Cap. 5 , el
problema con copiar referencias es que los cambios realizados a un objeto
utilizando una referencia también afectarán a la otra referencia, porque apuntan al
mismo objeto. Como " igual " , Sin embargo, “ clon ” Puede ser anulado a dar a
diferente comportamiento. Nosotros generalmente anular “ clon ” en orden
Proporcionar una copia profunda de un objeto. Hacer una copia profunda significa
cambiar cualquier referencia campos de el Copiar voluntad no afectar el referencia
campos de el original objeto, y viceversa. Al igual que sucede con la anulación de
“ equals ” , debemos proporcionar una implementación que anule la versión de la
superclase. La implementación básica siempre debe devolver “ [Link] ” .
@Anular
público Objeto clon() lanza Excepción CloneNotSupported
{
devolver [Link]();
}

Además, la clase que se va a clonar también debe implementar la función “

Clonable ”. interfaz. De lo contrario, se lanzará la excepción
CloneNotSupportedException.
público clase Ejemplo de clonación implementos Clonable
{…

De este modo lejos, nosotros tener hecho el clase Clonable, pero vocación el “
clon ” método solo hará una copia superficial de un objeto. Para hacer una copia
profunda, todos los campos de referencia a objetos o matrices deben copiarse
manualmente y el clon debe hacerse para que haga referencia a a estos copias
bastante que el originalmente referenciado objetos. Aquí, para Por ejemplo, un
clase tiene a campo cual es un formación de números enteros. En el “ clon ”
método, nosotros comenzar llamando “ [Link] ” a conseguir el clonado
objeto. Nosotros entonces a mano Copiar todo el valores en el clon matriz (para
esto ejemplo, nosotros asumir esto es accesible a través de a método de esta clase
llamada “ getArray ” ) en una nueva matriz. Luego, se hace que el clon haga
referencia a la nueva matriz, que contiene los datos copiados. Dado que las
matrices admiten automáticamente la interfaz Cloneable, este ejemplo es
razonablemente simple.
11.1 Frequently Used Classes in the 283
“[Link]” Package

@Anular
público Objeto clon() lanza Excepción CloneNotSupported
{
CloneExample clone =
(CloneExample)[Link](); int[]
clonedArray = getArray();
int[] matrizcopiada = new
int[[Link]]; para(int i =
0; i < [Link]; i++)
{
copiaArray[i] = clonadoArray[i];
}
[Link](copiedArray
); devolver clon;
}

Ahora, si se clona un objeto de la clase, el clon tendrá un campo de matriz

completamente separado del objeto original.
Nota
Debes tener cuidado al hacer copias profundas si encadenas demasiados objetos.
Es posible que las copias sean muy grandes.
Ejercicio 11.1
• Anular el “ clon ” método para el Curso clase entonces eso él marcas a
profundo Copiar de su gama de módulos.
• Escriba un caso de prueba JUnit que muestre que su método de clonación, de
hecho, está realizando una copia profunda (esto implicará clonar un curso,
cambiar los módulos del curso original y probar que el clon permanece sin
cambios).

11.1.2 El [Link]áticas Clase

Todo el métodos en el Matemáticas clase son estático métodos. Estos métodos

permitir a usuario para construir y evaluar expresiones matemáticas. Para
proporcionar el máximo rango de valores y flexibilidad al trabajar con diferentes
tipos de datos, se sobrecargan a afrontar con todo importante parámetro
(primitivo) tipos o asumir eso Todos los parámetros y tipos de retorno son de tipo
double. Cualquier otro tipo de datos numéricos que utilicen estos métodos
simplemente se convierten al tipo double. Tabla 11.1 Muestra algunos ejemplos
que funcionan con dobles.
284 11 Exploring the Java
Libraries
Mesa 11.1 Alguno ejemplo métodos de el Clase de matemáticas

Método Uso Ejemplo

doubleMath : pow ð doublex ; Devoluciones Matemáticas :
doblemente Þ el valor de pow ð 2 ; 3Þ == ¼ 8
incógnita
aumentó a el
fuerza de y
doubleMath : ceil ð doublex Þ Devuelve el Matemáticas :
más pequeño ceil ð 5 : 2 Þ == ¼
entero 6
mayor que
que o igual a x
doubleMath : sqrt ð doblex Devuelve el Matemáticas :
ÞÞ cuadrado raíz raíz cuadrada ð
de incógnita 9 Þ == ¼ 3

Mesa 11.2 El (aproximado) valores para Matemáticas.E y Matemá[Link] como

especificado en El Javadoc

java : lang : Matemáticas

publicstaticfinaldouble mi 2.718281828459045
publicstaticfinaldouble PI 3.141592653589793

Mesa 11.2 muestra cómo el valores de mi y PI son especificado en el Clase

[Link]. Ambos valores son, por supuesto, aproximaciones, limitadas a 15
decimales.
El Matemáticas clase incluye dos público constantes, “ Mi ” y “ Personalizado ”

público estático final doble MI;

// el base de el natural logaritmos.

público estático final doble PI;

// el relación de el circunferencia de a círculo
// a es diámetro.

Ejercicio 11.2
Utilice el “ [Link] ” y “ [Link] ” Métodos para calcular la hipotenusa
(lado más largo) de un triángulo rectángulo.

De acuerdo a a Pitágoras, el cuadrado de el hipotenusa es igual a el suma de los

cuadrados de los otros dos lados. Tu código debe:

• Calcular el cuadrícula de el dos Más corto lados.

11.1 Frequently Used Classes in the 285
“[Link]” Package
• Agregar estos cuadrícula juntos.
• Encontrar el cuadrado raíz de este valor; este voluntad ser el longitud de el más largo
lado.

Utilice un enfoque de “ prueba primero ” . Comience por escribir un caso de

prueba JUnit que espere una respuesta correcta, por ejemplo, la hipotenusa de un
triángulo rectángulo con longitudes de lados de 12 y 5 es 13. Una vez tú tener
escrito el pruebas, escribir el unidad bajo prueba.
286 11 Exploring the Java
Libraries
11.1.3 El [Link] Clase

Al igual que la clase Math, todos los métodos de la clase System son métodos
estáticos. Estos métodos proporcionar independiente de la plataforma acceso a
subyacente sistema funciones. La clase System también tiene los campos estáticos
“ in ” , “ out ” y “ err ” para representar la entrada estándar, la salida estándar y
la salida de error estándar respectivamente. Hemos utilizado “ [Link] ”. y “
[Link] ” En los ejemplos anteriores, “ [Link] ” Se utiliza a menudo para
separar normal producción de error producción. El siguiente corto programa lanza
deliberadamente un Excepción aritmética por divisor un entero por cero. El "
intentar " bloquear utiliza “ [Link] ” mientras que el bloque “ catch ” utiliza
“ [Link] ” . Tenga en cuenta que el bloque “ printStackTrace ” El método
puede tomar un objeto PrintStream (la clase que contienen tanto “ [Link] ”
como “ [Link] ” pertenecen a) como parámetro. Aquí, usamos explícitamente
“ [Link] ” , aunque esta es, de hecho, la opción predeterminada para los
seguimientos de pila.

paquete [Link].capitulo11;

público clase Dividir por cero

{
público estático vacío principal(Cadena[] argumentos)
{
intentar
{
[Link]("Estoy a punto de
hacer algunos cálculos aritméticos");
int x = 1;
entero y = x/0;
}
captura(Excepción aritmética mi)
{
[Link]("Oh querido...");
[Link]([Link]);
}
}
}

Cuando el programa es correr en Eclipse, tú debería ver eso el estándar

producción es en texto negro, pero la salida de error está en texto rojo. El orden de
los mensajes también puede variar, ya que la salida se envía a través de diferentes
flujos.
Acerca de a hacer
alguno aritmética Oh
querido...
[Link] : / por cero
en [Link] (
11.1 Frequently Used Classes in the 287
“[Link]” Package
[Link] )

La idea de tener flujos separados para la salida estándar y de error es que

podrían potencialmente ser Dirigido a separado lugares. Tú podría, para ejemplo,
elegir escribir error producción a uno registro archivo y estándar producción a
otro. El sistema clase
288 11 Exploring the Java
Libraries
incluye el métodos “ establecerse ” y “ establecerErr ” a hacer este; tú poder
aprobar estos métodos un objeto PrintStream diferente al que utilizan de forma
predeterminada.
Nota
Si bien puede utilizar salidas estándar y de error para el registro, ahora es
preferible utilizar el sistema de registro dedicado introducido en Java 1.4
(consulte el paquete [Link]. logging) o utilizar un sistema de registro de
terceros. Esto proporcionará un conjunto de servicios de registro mucho más
amplio y configurable que simplemente escribir en PrintStreams.

11.1.4 Envoltura Clases

Como sabemos, Java tiene objetos y tipos primitivos (int, double, etc.). Para
proporcionar un puente entre ellos, Java proporciona un conjunto de clases
contenedoras para todos los objetos integrados. tipos Permitiendo a nosotros a
convertir primitivos a objetos y vicio viceversa. Allá son clases coincidentes para
todos los tipos primitivos: Byte, Short, Character, Integer, Long, Float, Double y
Boolean. En la mayoría de los casos, el nombre del contenedor es el mismo que el
nombre del primitivo (aunque con los nombres de clase en el caso de Pascal)
excepto para Integer (envuelve “ int ” ) y Character (envuelve “ char ” ). Estas
clases permiten a Java construir un objeto cuyo estado refleja el valor de un tipo
de datos primitivo dado. también atender a envoltura el valor en un objeto eso
permite métodos a ser agregado a su representación. Estos métodos son no el
mismo para todo Envoltorios pero son apropiados para los tipos de datos que
encapsulan. Por ejemplo, la clase Boolean incluye campos finales estáticos para
VERDADERO y FALSO que pueden usarse para representar objetos booleanos
en sus dos estados posibles.
Booleano aBoolean = [Link];
[Link](new Boolean(true)); //
verdadero

La clase character tiene muchos métodos que nos permiten conocer el carácter
que contiene. Por ejemplo, el método “ isDigit ” El método devuelve “ verdadero
” Si el carácter es un dígito numérico.

Carácter aCharacter = new

Character('c');
[Link](); // falso

Como vimos en el Capítulo 9 , cuando usamos la clase Integer para convertir

caracteres ingresados en el teclado en números, las clases contenedoras para
valores numéricos tienen un “ análisis ” estático. métodos que convierten
cadenas en números; por ejemplo, la clase Integer tiene un método “ parseInt ”

entero año = [Link]("1066");

11.1 Frequently Used Classes in the 289
“[Link]” Package
Además de proporcionar varios métodos de utilidad útiles, los wrappers
proporcionan una herramienta importante en el uso del marco de Colecciones, que
analizamos en el próximo capítulo. Mientras matrices poder contener cualquiera
objeto referencias o primitivos, Java
290 11 Exploring the Java
Libraries
Las clases de colección, como ArrayList, solo pueden contener objetos. Si desea
almacenar un tipo de datos primitivo en una colección, los valores primitivos
deben colocarse en objetos contenedor antes ser agregado, como en este ejemplo,
cual usos el “ valorDe ” método de la clase Integer:

int myInt = 25; // no se puede agregar a

una colección Java Integer myInteger =
[Link](myInt);
// miEntero poder ser agregado a a recopilación

Mientras este poder ser hecho automáticamente usando a técnica llamado “

boxeo automático ” , él Es importante entender que las clases contenedoras
siempre se utilizan para colocar primitivas en una colección, ya sea que lo
hagamos explícitamente o no.
Todo el envoltura clases tener sobrecargado “ valorDe ” métodos eso permitir
objetos ser creado de cualquiera primitivo valores de el adecuado tipo o
Instrumentos de cuerda, aparte de la clase Character, que solo tiene un método “
valueOf ” que toma un “ char ” como argumento.

11.2 Clases en el “[Link]” Paquete

Las clases que hemos visto hasta ahora pertenecen al paquete [Link]. El paquete
[Link], que contiene clases de utilidad genéricas, también contiene muchas
clases de utilidad comúnmente utilizadas. usado clases incluido el Recopilación
clases eso nosotros voluntad mirar en en el próximo capítulo. Allá son a pocos
otros clases en [Link] Eso puede ser de interés, incluidas las clases Locale y
Currency, que presentamos en las siguientes secciones.

11.2.1 Fábrica Métodos

En los ejemplos de código que siguen, hay varios ejemplos de métodos de fábrica
. A fábrica método es a común diseño patrón para creando objetos sin vocación
un constructor. Los métodos de fábrica son estáticos y similares en sintaxis a los
métodos estáticos que nosotros tener visto en más temprano ejemplos en eso ellos
son llamado en a clase bastante que en un objeto. Sin embargo, ellos tener el
específico role de regresando a recién creado objeto. Esto se hace a menudo
cuando la clase tiene más información sobre el tipo de objeto que queremos crear
que nosotros mismos. Los métodos de fábrica a menudo devuelven un objeto de a
subclase de el uno eso implementos el método. A bien ejemplo de Aquí es donde
la configuración de un objeto recién creado puede variar dependiendo de la
normativa internacional. “ localidad ” en cual el objeto es ser creado. El Lugar y
Clases de moneda descrito en el siguiente Secciones poder usar el por defecto
lugar para el sistema actual y crear objetos apropiados para esa configuración
regional.
11.2 Clases en el “ [Link] ” Paquete 287

11.2.2 La clase Locale

Muchos elementos de los datos varían según su configuración regional

internacional. Las características que varían en todo el mundo incluyen el idioma
(y los conjuntos de caracteres que admiten un idioma determinado), las líneas de
fecha y las zonas horarias, y el formato de números y monedas. Esto significa que
algunas operaciones en un programa son " sensibles a la configuración regional " .
La función de la clase Locale es permitir que la información se adapte al usuario,
en función de su región, para respaldar la internacionalización de las aplicaciones.
Allá a varios Diferentes maneras de creando una Objeto de configuración
regional, pero el más simple es para utilizar el método de fábrica “
forLanguageTag ” . El conjunto posible de etiquetas de idioma se define en el
estándar IETF BCP 47. La etiqueta de idioma para inglés de Estados Unidos, por
ejemplo, es “ en-US ” , que se utiliza aquí con el método “ forLanguageTag ”.
Método para crear una configuración regional para esa región.

Lugar EE. UU. Local = [Link]("en- US");

Para algunas configuraciones regionales, la clase Locale proporciona varias

constantes que se pueden utilizar en lugar de tener que crear un objeto Locale.
Para mayor comodidad, existen constantes basadas en en ambos país y idioma.
Para ejemplo, [Link] es el constante para el país de Francia
mientras que [Link] es la constante para el idioma francés (cual de
curso es también usado en países otro que Francia). Nosotros voluntad Vea un
ejemplo de configuraciones regionales en uso en la siguiente sección.

11.2.3 El Divisa Clase

El Divisa clase representa información acerca de internacional Monedas. Creando

una Divisa objeto es hecho a través de el “ obtenerInstancia ” fábrica método,
cual requiere un objeto Locale como argumento. Por ejemplo, podemos crear un
objeto Locale y pasarlo al método “ getInstance ” :

Configuración regional USLocale =

[Link]("en-US"); Moneda
USCurrency =
[Link](usLocale);

Alternativamente, nosotros poder usar uno de el Lugar constantes, para ejemplo:

Divisa Moneda del Reino Unido = [Link]([Link]);

La información disponible de un objeto Moneda incluye la moneda ISO 4217

código (a texto cadena el representa a divisa), el YO ASI 4217 divisa número, el
símbolo de moneda y el Número de fracción dígitos. Se puede acceder a estos
valores a través de varios métodos en la clase Moneda, por ejemplo:
288 11 Exploring the Java
Libraries

[Link](MonedaReino [Link]ódigoNumerico());
[Link](MonedaReino
[Link]());
[Link](MonedaReino [Link]ímbolo());
[Link](MonedaReino [Link]ódigoDeMoneda());

El producción de estos métodos en a Reino Unido Lugar es como Sigue.

826
británico Libra
£
GB
P

Ejercicio 11.3
Cree una clase “ Dinero ” que pueda representar una cantidad de dinero en una
moneda específica. Utilice los servicios de la clase Moneda para ayudar a
implementar su clase Dinero. Agregue una instancia estática sobrecargada “
getInstance ” métodos de fábrica para su clase, uno que toma un argumento (y una
cantidad de dinero) y tiene como valor predeterminado la configuración regional
actual y otro que toma un objeto Locale como segundo argumento.
Agregar a “ aCadena ” método a su Dinero clase Eso vuelve el cantidad de
dinero utilizando el símbolo de moneda en el frente y el código de moneda al
final, por ejemplo:
$250 USD

Escriba un método “ principal ” que cree objetos Money desde

diferentes configuraciones regionales y muestre sus cantidades.

11.3 Formato de número Clases en el “[Link]” Paquete

El Formato de número clases en el “ [Link] ” paquete proporcionar a

herramienta para formatear números como cadenas y convertir cadenas en
números. Estas clases incluyen métodos de “ formato ” que facilitan la
personalización del formato de números. Las mismas clases tener métodos de “
analizar ” a convertir Instrumentos de cuerda a objetos o primitivo tipos (Fig.
11.1 ).

analizar gramaticalmente

Object NumberFormat String

format
11.3 NumberFormat Classes in the 289
“[Link]” Package

Higo. 11.1 Formato de número clases en el [Link] paquete analizar

gramaticalmente Instrumentos de cuerda en Número objetos y formatear objetos
numéricos en cadenas
290 11 Exploring the Java
Libraries
11.3.1 Formato Números

Fábrica métodos de el Formato de número clase semejante como “

obtenerNumberInstance ” son Se utiliza para crear objetos de formato.

Formato de número formatonumérico =

[Link]();

El objeto NumberFormat tendrá como valor predeterminado la configuración

regional actual si no se pasa ningún argumento al método “ getNumberInstance ”
, o se puede proporcionar una configuración regional como argumento. Tendrá
algunos comportamientos predeterminados al formatear números (o variables
numéricas) pasados como argumentos al método “ format ” .
Para ejemplo, él voluntad tener a por defecto número de decimal lugares eso él
exhibiciones, y redondeará el resultado:
Cadena s1 = [Link](1234.56789); // s1 = "1.234.568"

Otro comportamiento predeterminado es eliminar los ceros finales del número

después del punto decimal, por ejemplo:
Cadena s2 = [Link](1234.00); // s2 = "1.234"

Estos comportamientos poder, sin embargo, ser configurado en varios Maneras.

Para ejemplo, Podemos especificar cuántos dígitos queremos que aparezcan
después del punto decimal, utilizando el método “ setMaximumFractionDigits ” :

[Link](2);
s1 = [Link](1234.56789); // s1 = "1.234,57"

Nota
Los métodos de formato de la clase NumberFormat deben recibir algo que pueda
formatearse como un número. Si no se puede formatear el argumento, se lanzará
una excepción java. [Link] en tiempo de ejecución.

11.3.2 Formato Monedas

Se puede crear una instancia especial de la clase NumberFormat para permitir el

formato de valores que representan una moneda.
Formato de número localFormat =
Formato de
nú[Link]();

El método de fábrica “ getCurrencyInstance ” , cuando se utiliza sin ningún

argumento, utiliza la configuración regional actual para determinar el tipo de
moneda y el formato de la salida. Aquí, por ejemplo, formateamos un doble en una
cadena de moneda (la salida aquí asume una configuración regional en dólares).
11.3 NumberFormat Classes in the 291
“[Link]” Package

valor doble = 1234.5;

[Link]([Link](valor));//
”$1,234.50”

Si tú desear a formato Monedas de específico lugares, estos poder ser aprobado

como Un argumento a el “ obtenerInstanciaDeMoneda ” fábrica método. Aquí,
nosotros crear un ejemplo en “ ALEMANIA ” configuración regional, por lo que
el valor se formatea en euros pasando una constante de la clase Locale como
argumento:
FormatoDeNúmero euroFormat =
FormatoDeNú[Link]([Link]);
[Link]([Link](1234.0));
// ”1.234,00 €”

En este ejemplo, el “ JAPÓN ” lugar es usado, entonces el valor es formateado en Yen.

Formato de número yenFormat = Formato de

nú[Link]([Link]);
[Link]([Link](1234.0)); // ”¥1,234.00”

Por supuesto, este uso de locales se refiere únicamente al formato de las

monedas, no a su valor real. valores; ellos hacer nada a convertir entre Monedas.
En suma, el salida de un “ formato ” El método es una cadena, no un objeto de
moneda, por lo que no contiene más información sobre las monedas que se están
formateando. También es posible que su computadora no admita todos los
conjuntos de caracteres necesarios para mostrar las monedas para todas las
configuraciones regionales disponibles.

11.3.3 Analizando Números

El “ analizar ” Los métodos de la clase NumberFormat pueden analizar cadenas

que contienen Las representaciones de números y devuelven instancias de la
Número clase, que es La superclase de el número envoltura clases semejante como
Entero y Doble. El La clase Number tiene varios métodos para devolver números
primitivos; “ byteValue ” , “ doubleValue ” , “ intValue ” , etc. Dado que el
número original puede no coincidir exactamente con el tipo devuelto por el
método, es posible algún elemento de truncamiento o redondeo. El método “ parse
” lanza la excepción comprobada “ [Link] ” , por lo que
el método “parse” genera la excepción “ [Link] ”. código
necesita manejar este. Aquí, Nosotros analizamos a Cadena representando a
número de punto flotante. El “ dobleValor ” es el completo punto flotante número
como a doble, pero el “ intValue ” se trunca para devolver un int.
292 11 Exploring the Java
Libraries

NumberFormat numParser =
[Link](); intentar
{
Número num = [Link]("1234.5");
[Link]([Link]()); // 1234.5
[Link]([Link]()); // 1234
}
atrapar (Excepción de análisis mi)
{
[Link]();
}

11.3.4 Analizando Monedas

Instrumentos de cuerda representando divisa valores poder también ser analizado

en Número objetos, que puede entonces ser usado a devolver primitivo valores. En
este ejemplo, nosotros analizar gramaticalmente a Cadena en La moneda formato
de el Reino Unido lugar en a Número y entonces devolver el “ doubleValue ” . Se
lanzará una ParseException si la cadena de moneda está formateada para la
configuración regional incorrecta.

parseCurrency de NumberFormat =
[Link]([Link]);
intentar
{
// debe ser a analizable cadena en el divisa
// de el actual
Configuración
regional var
currencyValue =
[Link]("£5,432.10").doubl
eValue();
[Link](currencyValue); //
5432.1
}
atrapar (Excepción de análisis mi)
{
[Link]();
}

Ejercicio 11.4
Agregue un método a la clase BankAccount (la que creó en el Ejercicio 9.3) para
devolver un saldo formateado. Utilice una instancia de moneda de la clase
NumberFormat.
11.3 NumberFormat Classes in the 293
“[Link]” Package
Ejercicio 11.5
Actualice su clase Money para que el “ toString ” El método utiliza una instancia de moneda
de NumberFormat clase a formato el cantidad. Añadir el divisa código a el fin.
Ejercicio 11.6
En su clase BankAccount, reemplace el campo doble que representa el saldo de la
cuenta. cuenta con a [Link]. Usar el Javadoc a encontrar afuera
cómo a usar
294 11 Exploring the Java
Libraries
Esta clase en tu código para que los métodos sigan funcionando. Escribe un caso
de prueba JUnit para tu clase BankAccount.

11.4 Fechas y Veces en el “[Link]” Paquete

En el cap. 5 Presentamos la clase [Link]. Aunque esta clase no ha quedado

obsoleta, desde Java 8 existe un paquete más nuevo llamado “ [Link] ” que
contiene a nuevo colocar de fecha y relacionado con el tiempo clases eso superar
alguno de el Problemas con las representaciones de fecha y hora anteriores en
Java. Las clases de este paquete son seguras para subprocesos, con API más
consistentes que siguen un estilo de programación funcional. Las clases del
paquete hacen un uso extensivo de Métodos de fábrica, que crean objetos
inmutables con métodos que frecuentemente devuelven copias modificadas de
ellos mismos. entonces método llamadas poder ser encadenado juntos. En el
próximo pocos secciones, nosotros Proporciona una breve introducción a las
características básicas de las clases LocalDate, LocalTime y LocalDateTime. Estas
clases abarcan mucho más que los métodos descritos. aquí, entonces referirse a el
Javadoc si tú necesidad a encontrar afuera más acerca de usando Fechas y horas en
Java.

11.4.1 El Fecha local Clase

La clase de fecha principal es LocalDate, que devuelve la fecha actual en la zona

horaria local. A Fecha local hace no contener cualquier relacionado con el
tiempo datos pero hace Contiene campos relacionados con la fecha como por
ejemplo “ día del año ” , “ día de la semana ” y “ semana del año ” . Aquí, se
crea una fecha local utilizando el método de fábrica “ ahora ” .

FechaLocal hoy =
[Link]();
[Link](hoy);

Por por defecto, “ aCadena ” devoluciones el fecha en AAAA-MM-DD formato, para

ejemplo:

01-04-2020

Una LocalDate es inmutable y es una clase basada en valores, lo que significa

que los objetos LocalDate deben compararse utilizando el método “ equals ” , no
el operador “ == ” . el objeto es inmutable, varios métodos poder ser llamado a
crear copias modificadas de la fecha, por ejemplo, “ minsDays ” .

Fecha local ayer = [Link]().minusDays(1);

También se pueden crear fechas para una fecha específica pasando argumentos
de año, mes y día al “ de ”. método. El mes se puede pasar como un entero en el
rango 1 – 12 o uno de el enumeraciones (enumerado tipos) definido en el Mes
11.3 NumberFormat Classes in the 295
“[Link]” Package
clase eso
11.4 Dates and Times in the 293
“[Link]” Package
Utiliza los nombres de los meses en lugar de sus números. Los tipos enumerados
son básicamente conjuntos de constantes relacionadas. Este ejemplo utiliza una
enumeración para el mes:
Fecha local fecha de nacimiento = Fecha [Link](2012,
[Link], 1);

De nuevo, más métodos poder ser llamado a crear modificado copias de el

fecha inmutable
Fecha local Veintiuno = fechaDeNacimiento.másAños(21);

11.4.2 El Hora local Clase

La clase LocalTime representa una hora sin información de fecha. Al igual que la
clase Local-Date, él tiene un " ahora " método Eso crea una objeto que representa
el momento de su creación. y un método “ of ” que permite establecer su hora
mediante argumentos, por ejemplo:
Hora local tiempo = Hora [Link]();
Hora local tiempo especificado = [Link](12,15);

El " de " método usado arriba especifica el horas y minutos, pero allá son Otras
versiones que aceptan diferentes cantidades de argumentos. Este es el resultado de
los objetos LocalTime de ejemplo (observe cómo la hora actual incluye los
segundos y nanosegundos):
20:10:37.441414200
12:15

11.4.3 El Fecha y hora local Clase

Habiendo cubierto brevemente los aspectos clave de las clases LocalDate y

LocalTime, Finalmente mirar en el Fecha y hora local clase cual, Como era de
esperar, combina ambos una fecha y una hora. La sintaxis es similar a la que ya
hemos visto, por ejemplo:
LocalDateTime dateTimeNow =
[Link](); LocalDateTime
pastDateTime =
Fecha y hora [Link](1970, 1, 1, 0, 0);

El producción debería también venir como No sorpresa:

2 de abril de 2020 a las 20:19:06.498307

294 11 Exploring the Java
Libraries
1 de enero de 1970 a las 00:00
11.4 Dates and Times in the 295
“[Link]” Package
11.4.4 Formato Fechas y Veces

De vuelta en el capítulo 5 Usamos la clase [Link] para formatear

objetos [Link] usando formato Instrumentos de cuerda. Formato fechas y
veces en el “ [Link] ” El formato del paquete es mucho más sencillo si se
utilizan las clases del paquete “ [Link] ” . La clase DateTimeFormatter
proporciona muchas opciones de formato tanto para fechas como para horas. Uno
de el más simple de estos es el “ deFechaLocalizada ” método, cual crea una
Formateador de fecha y hora objeto eso ofertas solo con el fecha (no el tiempo) y
poder ser pasado uno de el FormatoEstilo constantes de CORTO, MEDIO,
LARGO o LLENO para especificar el formato de salida
DateTimeFormatter formateador =
[Link]([Link])
;

Paso a Formateador de fecha y hora objeto a el “ formato ” método de el fecha

devoluciones una cadena que contiene la fecha formateada:
Cadena fechaTexto = [Link](formateador);

Cuando impreso afuera él tiene este formato:

31/03/20

Si no te gusta este formato corto, puedes elegir uno de los otros formatos
integrados. definido por constantes (MEDIO, LARGO y LLENO). Para ejemplo,
este creará un formateador utilizando el estilo de formato COMPLETO:
Formateador DateTimeFormatter =
[Link]([Link]);

Mostrando el mismo fecha en LLENO formato voluntad mirar como este:

Jueves, 1 Enero 1970

A mostrar elementos de el tiempo, bastante que el fecha, usar el Fábrica “

ofLocalizedTime ” método. Nota eso en este ejemplo solo el CORTO y MEDIO
Los formatos funcionarán porque los formatos LARGO y COMPLETO requieren
más detalles que los incluidos en un LocalTime.
Hora local hora = Hora
[Link](); DateTimeFormatter
Formateador de tiempo =
[Link](FormatStyle
.MEDIUM); String textoDeTiempo =
[Link](formatoDeTiempo);
[Link](textoDeTiempo);
296 11 Exploring the Java
Libraries
La salida de este código, que muestra la hora en formato MEDIO, se parece a
esto:
11.4 Dates and Times in the 297
“[Link]” Package

11:04:05 p.m

Para los formatos más largos que incluyen información de zona horaria, se debe
utilizar un objeto ZonedDateTime, ya que esta es la única clase que maneja zonas
horarias.
ZonedDateTime zonedTime = [Link]();
FormatoDateTime zonedTimeFormatter =
[Link](FormatStyl
[Link]); Cadena zonedTimeText =
[Link](zonedTimeFormatter);
[Link](zonedTimeText);

Este es el producción de el lleno formato de el Fecha y hora zonificadas:

Jueves, 2 Abril 2020 en 8:31:25 p.m Nuevo

Zelanda Hora de verano

Además de los cuatro formatos estándar, DateTimeFormatter tiene un “

ofPattern ” método eso permite tú a especificar exactamente cómo tú desear el
fecha y/o tiempo de aparición utilizando caracteres especiales. En este ejemplo,
aplicamos un patrón para que el fecha aparece en el orden día, mes, año, apartado
por adelante barras (caso es significativo aquí).

Fecha Local fecha = Fecha

[Link](1970,1,1);
DateTimeFormatter formatoDate
personalizado =
[Link]("dd/MM/
aa"); Cadena dateText =
[Link](customDateFormat);
[Link](dateText);

Este patrón dirige a el fecha ser formateado como el siguiente Cadena:

01/01/70

El parámetro de cadena de patrones determina la forma en que se formatea la

fecha, según la tabla de patrones que se muestra en la Tabla 11.3 . No puede
utilizar ninguna letra distinta a estas, pero puede utilizar cualquier símbolo de
puntuación.
Además de que los personajes en sí son importantes, el número de ellos
también afecta cómo eso elemento de el fecha es formateado. En general, si el
número de Las letras de patrón son cuatro o más, el lleno forma es usado; de lo
contrario, a corto o Se utiliza la forma abreviada (si está disponible). Aquí hay una
versión ligeramente diferente de nuestro último ejemplo (el cambio en puntuación
hace no afectar el fecha valores, pero el número de caracteres hace):
298 11 Exploring the Java
Libraries
DateTimeFormatter customDateFormat =
[Link]("dd-
MMMM-aaaa");

Esta es la cadena que se devuelve. El uso de tres caracteres “ M ” muestra el

nombre abreviado del mes.
11.4 Dates and Times in the 299
“[Link]” Package
Mesa 11.3 Fecha y el tiempo patrones como ellos aparecer en el Javadoc

Carta Fecha u hora Presentación Ejemplos

Componente
GRAM era texto ANUNCIO; Año Dominio; A
O
tú año año 2004; 04
y año de era año 2004; 04
D día del año número 189
M/L mes del año número/texto 7; 07; Jul; Julio; Yo
d día del mes número 10
gramo día juliano modificado número 2451334
Q/q trimestre del año número/texto 3; 03; Q3; 3º cuarto
Y basado en semana- año año 1996; 96
el año basado en semana a número 27
semana
Yo semana del mes número 4
mi día de la semana texto Mar; Martes; yo
CE localizado día de la número/texto 2; 02; Mar; Martes; yo
semana
F día de la semana en el número 3
mes
a am-pm-del -día texto P.M
yo reloj-hora-de-am-pm (1 número 12
–
12)
K hora-de-am-pm (0 – 11) número 0
a reloj-hora-del-dia (1 – número 24
24)
yo hora del día (0 – 23) número 0
metro minuto de hora número 30
s segundo de minuto número 55
S fracción de segundo fracción 978
A mili-de- día número 1234
norte nano de segundo número 987654321
norte nano-del -día número 1234000000
V zona horaria id de zona América/Los_Ángeles; O; - 08:30
IDENTIFICACIÓN
en genérico zona horaria nombre de la Pacífico Tiempo; En
nombre zona
el zona horaria nombre nombre de la Pacífico Estándar Tiempo; Hora
zona estándar del Pacífico
Oh localizado desplazamien GMT + 8; GMT + 08:00; UTC-
desplazamiento de zona to -O 08:00
incógnit desplazamiento de zona desplazamien O; − 08; - 0830; − 08:30; −
a ' Z ' para cero to- X 083015;
- 08:30:15
incógnit desplazamiento de zona desplazamien +0000; − 08; - 0830; − 08:30;
a to- x − 083015; - 08:30:15
O desplazamiento de zona desplazamien +0000; − 0800; - 08:00
to -Z
pag almohadilla próximo almohadil 1
la
300 11 Exploring the Java
Libraries
modifica
dor
' escapar para texto delimitador
" soltero cita literal '
[ opcional sección
comenzar
] opcional sección fin
(continuado)
11.4 Dates and Times in the 301
“[Link]” Package
Mesa 11.3 (continuado)

Carta Fecha u hora Presentación Ejemplos

Componente
# reservado para futuro
usar
{ reservado para futuro
usar
} reservado para futuro
usar

01 de enero de 1970

Usando cuatro Caracteres “ M ” para el mes quería dirigir a la siguiente

salida, con el nombre completo del mes:
01 de enero de 1970

Aquí es a final ejemplo, cual también incluye el lleno día nombre.

DateTimeFormatter customDateFormat =
[Link]("EEEE dd MMMM,
aaaa");

El resultante cadena quería ser

Jueves 01 Enero, 1970

11.4.5 Analizando Fechas

El método “ parse ” de LocalDate se puede utilizar para convertir cadenas en

fechas. En este caso, el patrón de cadena utilizado en el método “ ofPattern ” El
método de DateTimeFormatter determina la forma en que se analizan las fechas
(se pasa como argumento al método “ parse ” ). El datos aprobado como el
Cadena argumento debe ser en el esperado formato para que el análisis tenga
éxito, por lo que, siempre que sea posible, cuanto más simple, mejor. Sin embargo,
la cantidad de caracteres no es importante al analizar, solo al formatear. En este
caso, solo uno personaje para cada elemento de el fecha es necesario cuando
especificando la cadena de patrón.

DateTimeFormatter dateFormat =
[Link]("M/d/a");
FechaLocal parsedDate =
[Link] ("22/10/2012",
formatoDate);
[Link](fechaanalizada);
302 11 Exploring the Java
Libraries
El producción de este ejemplo es el estándar “ aCadena ” producción de
el objeto LocalDate.
22 de octubre de 2012
Ejercicio 11.7
Inde 303
x
• Usar a Fecha local y el " de " método a crear y colocar a específico fecha.
• Formato el Fecha usando a coherente separación personaje ([Link] “ / ” ).
• Usar el " dividir " método de el Cadena clase a dividir el formateado fecha en
separar valores y mostrarlos.

El método “ split ” se puede utilizar para dividir una cadena utilizando una
cadena separadora. Devuelve una matriz de cadenas, por ejemplo, en este ejemplo
se utiliza un espacio como cadena separadora:
Cadena st = new String("esto es
una prueba"); Cadena[] split =
[Link](" ");

11.5 Resumen

Este capítulo cubrió una pequeña muestra de clases de algunos de los paquetes de
las bibliotecas de Java. Comenzamos con una cobertura de la clase Object y el
método “ clone ” , antes de ver otras clases en el paquete “ [Link] ” (Math,
System y las clases contenedoras). A esto le siguió la cobertura de dos clases del
paquete “ [Link] ” (Locale y Currency). A continuación, vimos las clases del
paquete “ [Link] ” que nos ayudan a formatear y analizar números y monedas.
El último paquete cubierto en este capítulo fue “ [Link] ” , que proporciona
clases para representar fechas y horas, así como el paquete “ [Link] ”.
paquete que contiene clases para formatear los datos de estos objetos.
Con un poco de suerte, estos ejemplos voluntad alentar tú a reutilizar existente
biblioteca clases tanto como como posible y convertirse familiar con usando el
Javadoc a explorar el clases y métodos que pueden evitar que escribas código
nuevo innecesariamente, para que puedas concentrarte en el código que realmente
necesita escribirse.