Guía de Java

PID_00273929

David García Solórzano

Tiempo mínimo de dedicación recomendado: 16 horas

© FUOC • PID_00273929 Guía de Java

David García Solórzano

Graduado superior en Ingeniería en

Multimedia e ingeniero en Informá-
tica por la Universitat Ramon Llull
desde 2007 y 2008, respectivamen-
te. Es también doctor por la Uni-
versitat Oberta de Catalunya desde
2013, donde realizó una tesis docto-
ral relacionada con el ámbito del e-
learning. Desde 2008 es profesor de
la Universitat Oberta de Catalunya
en los Estudios de Informática, Mul-
timedia y Telecomunicación.

El encargo y la creación de este recurso de aprendizaje UOC han sido coordinados

por el profesor: David García Solórzano

Primera edición: septiembre 2020

© de esta edición, Fundació Universitat Oberta de Catalunya (FUOC)
Av. Tibidabo, 39-43, 08035 Barcelona
Autoría: David García Solórzano
Producción: FUOC
Todos los derechos reservados

Ninguna parte de esta publicación, incluido el diseño general y la cubierta, puede ser copiada,
reproducida, almacenada o transmitida de ninguna forma, ni por ningún medio, sea este eléctrico,
mecánico, óptico, grabación, fotocopia, o cualquier otro, sin la previa autorización escrita
del titular de los derechos.
© FUOC • PID_00273929 Guía de Java

Índice

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

1. Configuración del entorno.............................................................. 11

1.1. Instalando JDK ............................................................................ 11
1.1.1. OpenJDK frente a Oracle JDK ....................................... 11
1.1.2. Oracle JDK para Windows ............................................. 12
1.1.3. Oracle JDK para Linux ................................................... 17
1.1.4. Oracle JDK para macOS ................................................. 17
1.2. Compilando y ejecutando un programa por línea de
comandos .................................................................................... 18
1.3. Eclipse IDE ................................................................................... 18
1.3.1. Instalación de Eclipse IDE ............................................. 18
1.3.2. Vistas .............................................................................. 21
1.3.3. Menús ............................................................................. 24

2. Fundamentos de Java (como lenguaje imperativo)................... 29

2.1. Comentarios dentro del código .................................................. 29
2.2. Estructura básica de un programa .............................................. 29
2.3. Entrada por teclado y salida por pantalla (I/O) .......................... 32
2.3.1. Métodos de salida .......................................................... 32
2.3.2. Métodos de entrada ....................................................... 34
2.4. Variables ...................................................................................... 34
2.4.1. Nombre .......................................................................... 34
2.4.2. Tipos ............................................................................... 35
2.5. Operadores ................................................................................... 44
2.5.1. Operadores de asignación, aritméticos y unarios .......... 45
2.5.2. Operadores de igualdad, relacionales y condicionales .. 50
2.5.3. Operadores bitwise y shiftado ....................................... 52
2.6. Bloques de flujo de ejecución ..................................................... 53
2.6.1. Bloque secuencial .......................................................... 54
2.6.2. Bloque condicional ........................................................ 54
2.6.3. Bloque iterativo ............................................................. 57
2.6.4. Instrucciones de control de flujo .................................. 60
2.7. String.......................................................................................... 62
2.7.1. Escape sequences............................................................... 62
2.7.2. Concatenar con +........................................................... 63
2.7.3. Algunos métodos interesantes ....................................... 63
2.7.4. Conversiones .................................................................. 65
2.8. Arrays............................................................................................. 66
2.8.1. Declaración y creación en memoria .............................. 67
2.8.2. Tamaño de un array........................................................ 68
© FUOC • PID_00273929 Guía de Java

2.8.3. Copiar el contenido de un array a otro array................. 69

2.8.4. Ordenar un array............................................................. 70
2.9. Métodos (funciones) ................................................................... 71
2.9.1. Definición de un método .............................................. 71
2.9.2. Sobrecarga de un método .............................................. 72
2.9.3. Usando un método ........................................................ 73
2.9.4. Paso por valor y por referencia ..................................... 74
2.9.5. Número variable de parámetros .................................... 75
2.9.6. Cast implícito y explícito en los parámetros ................. 76
2.10. Ámbito de las variables ............................................................... 77

3. Orientación a objetos en Java........................................................ 79

3.1. Definiendo una clase .................................................................. 79
3.1.1. Estructura mínima ......................................................... 79
3.1.2. Miembros de la clase ..................................................... 80
3.1.3. Constructor .................................................................... 83
3.2. Objetos ......................................................................................... 87
3.2.1. Instanciar (creando objetos) .......................................... 87
3.2.2. Usando un objeto (mensajes) ........................................ 88
3.3. Modificadores de acceso ............................................................. 88
3.4. Destructor de una clase .............................................................. 94
3.5. Packages......................................................................................... 95
3.5.1. ¿Qué es un package y cuál es su utilidad? ...................... 95
3.5.2. Creando un package........................................................ 97
3.5.3. Usando los elementos incluidos dentro de un package... 99
3.5.4. Packages importados automáticamente por Java ........... 102
3.6. Modificador static..................................................................... 102
3.6.1. Atributo estático ............................................................ 102
3.6.2. Bloque de inicialización estático ................................... 103
3.6.3. Método estático ............................................................. 104
3.6.4. Clase estática .................................................................. 105
3.7. Modificador abstract................................................................. 105
3.7.1. Clase abstracta ............................................................... 105
3.7.2. Método abstracto ........................................................... 106
3.8. Modificador final....................................................................... 106
3.8.1. Clase final.................................................................... 106
3.8.2. Método final................................................................ 107
3.8.3. Atributo final............................................................... 107
3.9. Herencia ....................................................................................... 108
3.9.1. Concepto y sintaxis ....................................................... 108
3.9.2. La clase Object.............................................................. 109
3.9.3. ¿Qué hereda una subclase? ............................................ 109
3.9.4. El modificador abstract y la herencia ........................ 114
3.9.5. El modificador static y la herencia ............................ 115
3.9.6. El modificador final y la herencia .............................. 115
3.9.7. Ocultación de atributos ................................................. 115
3.10. Interfaces ..................................................................................... 116
© FUOC • PID_00273929 Guía de Java

3.10.1. Concepto y sintaxis ....................................................... 116

3.10.2. Uso de una interfaz ....................................................... 117
3.10.3. ¿Qué elementos puede contener una interfaz? ............. 117
3.11. Polimorfismo ............................................................................... 119
3.12. Excepciones ................................................................................. 123
3.12.1. Concepto ........................................................................ 123
3.12.2. Declarando y lanzando una excepción ......................... 124
3.12.3. Flujo que sigue una excepción ...................................... 125
3.12.4. Tratando/capturando una excepción ............................ 127
3.12.5. Checked y unchecked exceptions........................................ 129
3.12.6. Declarando, lanzando y capturando más de una
excepción ....................................................................... 131
3.12.7. Bloque finally.............................................................. 133
3.12.8. Métodos del exception object............................................ 133
3.12.9. Sentencia try-with-resources.................................. 134
3.13. Enumeraciones ............................................................................ 134
3.13.1. Concepto y sintaxis ....................................................... 134
3.13.2. Diferencia entre usar constantes y un enumeration......... 135
3.13.3. Compatibilidad con switch.......................................... 136
3.13.4. Implementación interna de las constantes (de los
valores) ........................................................................... 137
3.13.5. Herencia de la clase Enum........................................... 137
3.13.6. Constructor y miembros ............................................... 138
3.13.7. Métodos abstractos ........................................................ 138
3.14. Generics.......................................................................................... 139
3.14.1. Concepto ........................................................................ 139
3.14.2. Clase genérica ................................................................ 139
3.14.3. Ventajas de generics......................................................... 140
3.14.4. Interfaz genérica ............................................................ 142
3.14.5. Método genérico ............................................................ 142
3.14.6. Parámetros de tipo ......................................................... 143
3.14.7. Subtipos .......................................................................... 144
3.14.8. Usando tipos parametrizados como parámetro de
tipo ................................................................................. 144
3.14.9. Uso del wildcard ?........................................................... 145
3.14.10. Limitación de tipos ........................................................ 145
3.14.11. Restricciones en el uso de generics.................................. 148
3.15. Colecciones .................................................................................. 149
3.15.1. Interfaz Set..................................................................... 150
3.15.2. Interfaz List................................................................... 151
3.15.3. Interfaz Map..................................................................... 152
3.15.4. Resumen ......................................................................... 154

4. Avanzado.............................................................................................. 156
4.1. La clase String............................................................................ 156
4.1.1. StringBuilder frente a StringBuffer...................... 158
4.1.2. Resumen ......................................................................... 158
© FUOC • PID_00273929 Guía de Java

4.2. Programación funcional (expresiones lambda y Stream API) ..... 159

4.2.1. Expresiones lambda ....................................................... 159
4.2.2. Interfaz funcional .......................................................... 160
4.3. Módulos ....................................................................................... 162
4.4. Clases anidadas ........................................................................... 163
4.4.1. Static nested class............................................................. 164
4.4.2. Inner class........................................................................ 164
4.5. Anotaciones ................................................................................. 165
4.5.1. Creación de una anotación personalizada .................... 166
4.5.2. Uso de una anotación personalizada ............................ 168
4.6. Método requireNonNull........................................................... 168

5. Extras..................................................................................................... 169
5.1. Javadoc ........................................................................................ 169
5.1.1. Generar javadoc por línea de comandos ..................... 170
5.1.2. Generar javadoc con Eclipse ....................................... 171
5.2. JavaFX .......................................................................................... 174
5.2.1. Introducción .................................................................. 174
5.2.2. Configuración de JavaFX en Eclipse IDE ....................... 174
5.2.3. Modelo en JavaFX ......................................................... 178
5.2.4. Vistas en JavaFX (parte visual) ...................................... 178
5.2.5. Vistas en JavaFX (parte interactiva) ............................... 180
5.3. JUnit 5 ......................................................................................... 183
5.3.1. Test unitario ................................................................... 183
5.3.2. Configuración del plugin JUnit ...................................... 184
5.3.3. Usando JUnit ................................................................. 186

Bibliografía................................................................................................. 195
© FUOC • PID_00273929 7 Guía de Java

Introducción

1)�Breve�historia

(1)
El lenguaje de programación Java apareció en 1995 de la mano de James Gos- En inglés, oak.
ling de la empresa Sun Microsystems, que fue adquirida por Oracle en 2010.
Dicen que originalmente iba a llamarse Oak, debido a un árbol de roble1 que
había en el jardín al cual daba el despacho de Gosling. Más tarde fue bautizado
como Green, para finalmente llamarse Java. Dicen que el nombre de Java fue
inspirado por el café de tipo Java que servían en la cafetería a la que solía ir
Gosling con sus compañeros. De ahí que el logo de Java sea una taza humean-
te de café.

2)�Ediciones�de�Java

Java es tanto un lenguaje de programación como una plataforma.

Por plataforma entendemos un entorno concreto en el que se ejecutan

programas desarrollados en lenguaje Java.

(2)
En la actualidad existen cuatro plataformas o ediciones de Java que están des- Acrónimo de application pro-
gramming interface.
tinadas a construir diferentes tipos de aplicaciones. Cada plataforma Java está
compuesta por una máquina virtual, llamada Java Virtual Machine (JVM), y un
conjunto de librerías o API.2

• Java�Virtual�Machine�(JVM): es un programa, para un sistema operativo

concreto, que ejecuta programas desarrollados en Java.

• API: es una colección de librerías que un programador puede usar para

desarrollar un nuevo software.

Así pues, un programa es desarrollado para una plataforma concreta de Java.

Las cuatro plataformas o ediciones de Java que existen en la actualidad son:

a)�Standard�Edition�(SE). Esta edición es el núcleo del lenguaje y la parte que

veremos en esta guía. Su API incluye todo lo relacionado con los tipos básicos,
la orientación a objetos, clases para redes, seguridad, acceso a bases de datos,
parseo de XML, etc.
© FUOC • PID_00273929 8 Guía de Java

b)�Enterprise�Edition�(EE). Esta plataforma es un superconjunto de la Stan-

dard Edition (SE), es decir, incluye la SE proporcionando librerías adicionales.
Se usa para desarrollar aplicaciones de gran tamaño, distribuidas, escalables,
fiables y seguras.

c)�Micro�Edition�(ME). A diferencia de la Enterprise Edition, esta edición es

un subconjunto de la Standard Edition y está diseñada para desarrollar apli-
caciones en dispositivos móviles. Por este motivo, incluye librerías especiales
útiles para el desarrollo de aplicaciones en dispositivos móviles y su máquina
virtual está adaptada a las capacidades de teléfonos inteligentes, relojes inte-
ligentes, etc.

(3)
d)�Java�Card. Esta edición es un subconjunto de la Standard Edition y se usa En inglés, smart cards.
3
para ejecutar aplicaciones de manera segura en tarjetas inteligentes o dispo-
sitivos con pequeña capacidad de almacenamiento. Esta tecnología se utiliza
por ejemplo en tarjetas monedero.

3)�Ciclo�de�vida�de�un�programa�Java

Un programador escribe un programa en Java. Para simplificar, imaginemos

que su programa solo utiliza un fichero llamado Program. Este fichero tendrá
código escrito en Java y su extensión será .java, así pues el nombre completo
del fichero será Program.java. Una vez escrito el fichero Program.java, el
programador lo debe compilar. Para ello llama al Java�Compiler�(javac) de la
siguiente manera mediante la línea de comandos:

Si el programa estuviera formado por más de un fichero .java, entonces po-

dría haber compilado todos los archivos a la vez con el comando siguiente:

Con este paso se consigue convertir el código escrito en Java a un código escrito
en un lenguaje intermedio llamado bytecode. De hecho, Java Compiler crea un
fichero nuevo llamado igual que el fichero .java original, pero con extensión
.class. Gráficamente sería:

Figura 1
© FUOC • PID_00273929 9 Guía de Java

Se podría decir que el código bytecode es similar al código�máquina que los Bytecode
compiladores de otros lenguajes de programación, como C/C++, generan. La
El bytecode no es entendido
diferencia radica en que el código bytecode no está destinado para ejecutarse por ninguna arquitectura hard-
en una arquitectura de hardware concreta (por ejemplo, Intel es diferente a ware, sino por la JVM. Es me-
nos complejo (y más rápido)
Macintosh), sino que está pensado para ejecutarse en una máquina virtual Ja- para la JVM interpretar byteco-
de que directamente código
va concreta (Java Virtual Machine, JVM). Java�Virtual�Machine (JVM) no es Java.
más que un intérprete de bytecode. Esto conlleva a que durante la fase de inter-
pretación exista una ralentización en el rendimiento del programa respecto al
mismo programa escrito en lenguaje máquina que generan los compiladores
de lenguajes como C/C++.

(4)
La JVM solo es dependiente del sistema operativo, pero no de la máquina/or- En español, «Escribe una vez,
ejecuta en cualquier parte».
denador en el que se esté ejecutando. Así pues, lo único que se debe hacer es
tener instalada la JVM del sistema operativo correspondiente. Gracias a esto,
se desarrolla una vez en cualquier dispositivo (ficheros .java), en dicho dis-
positivo se compila/transforma el código Java en un código estándar e inter-
medio llamado bytecode (ficheros .class) y, finalmente, este código se ejecuta
en cualquier dispositivo equipado con la máquina virtual (JVM). De ahí que
el eslogan de Java sea: «Write once, run anywhere».4 Gráficamente este proceso
sería:

Figura 2
¿Java es compilado o
interpretado?

Siempre encontramos la dis-

cusión de si Java es compila-
do o interpretado, ya que exis-
ten las dos fases. En términos
Así pues, si se está ejecutando el archivo .class en Windows, el JVM inter- generales, se dice que es inter-
pretado por la manera en que
pretará el bytecode del fichero .class y utilizará código nativo que Windows la JVM ejecuta el código byte-
entiende para finalmente ejecutar el programa adecuadamente. code.

Para que la JVM ejecute el bytecode de un programa, hay que llamar al fichero Método main
.class cuyo homónimo .java tuviera el método main. Esta llamada se hace
Más adelante veremos qué es
de la manera siguiente: el método especial main de un
programa.

4)�JRE�frente�a�JDK

Independientemente de la plataforma de Java, existen dos paquetes diferentes:

JRE y JDK. ¿Cuál es la diferencia?

El JRE�(Java�Runtime�Enviroment) es un software que proporciona lo míni-

mo indispensable para poder ejecutar una aplicación Java en el dispositivo en
el que se instala. Está formado por la JVM y un conjunto de componentes (por
© FUOC • PID_00273929 10 Guía de Java

ejemplo, librerías de integración, toolkits de interfaz de usuario, etc.). El JRE

debe ser instalado por todo aquel que quiere ejecutar programas en Java, por
ejemplo, un usuario final.

Por su parte, el JDK�(Java�Development�Kit) es un software de desarrollo que

permite crear y ejecutar programas en Java. Este incluye dos elementos:

1) Un conjunto de herramientas necesarias para el desarrollo.

2) El JRE, el cual permite ejecutar un programa Java.

El JDK debe ser instalado por todo aquel que quiera desarrollar programas en
Java.
© FUOC • PID_00273929 11 Guía de Java

1. Configuración del entorno

1.1. Instalando JDK

Como hemos visto, cuando queremos programar en Java debemos instalar el

JDK en nuestro ordenador. En el momento de escribir esta guía, la versión
actual era la 13. Que la versión que exista cuando estés leyendo esta guía sea
una más avanzada no debería suponer un problema, ya que desde hace tiempo
la manera de instalar el JDK sigue siendo la misma.

Antes de ver los pasos generales necesarios para instalar el JDK para Windows,
Linux y macOS, cabe enfatizar que desde la versión 11 del JDK, la licencia de
uso cambió. Si antes era completamente gratuito, desde JDK 11 su utilización
solo es gratuita para uso personal, pero no para desarrollar aplicaciones para
terceros. Asimismo, el soporte por parte de Oracle –como pueden ser actua-
lizaciones–, tampoco es gratuito. Es por esto por lo que desde la versión 11,
muchas personas prefieran instalarse la versión libre llamada OpenJDK.

1.1.1. OpenJDK frente a Oracle JDK

La tabla 1 destaca las similitudes y diferencias entre OpenJDK y Oracle JDK.

Tabla 1. Similitudes y diferencias entre OpenJDK y Oracle JDK

OpenJDK Oracle JDK

Oficialidad Es una implementación de la especificación Es la versión oficial de facto.

oficial de Java. Desde Java SE 7 es la imple-
mentación de referencia usada como base pa-
ra desarrollar Oracle JDK.

Lanzamiento�de�nueva�release�(ver- Cada seis meses. Cada tres años se lanza una versión LTS (long
sión) term support), por ejemplo, JDK 8 y JDK 11,
que añade grandes cambios y recibe soporte
(por ejemplo, actualizaciones, corrección de
bugs, etc.) durante ocho años.
Cada seis meses aparece una versión no-LTS
que añade mejoras sobre la última versión
LTS, pero estas mejoras no impactan en el co-
re. Cada versión no-LTS deja de tener soporte
a los seis meses, es decir, cuando aparece una
nueva versión.

Licencia Libre/gratuita. Gratuita para uso personal (por ejemplo, no

comercial).
De pago para uso comercial (para terceros).

Actualizaciones (por ejemplo, correc- Cada seis meses. Inmediato si se paga una licencia. En caso
ción de bugs) contrario, cada seis meses.

Encargado�del�mantenimiento Comunidad Java, Oracle, Red Hat, IBM, etc. Oracle Corporation.
© FUOC • PID_00273929 12 Guía de Java

OpenJDK Oracle JDK

Instalación Basado en un .tar.gz o .zip. Tiene instaladores para diferentes sistemas

operativos (msi, rpm, deb, etc.).

Rendimiento No hay diferencias significativas.

1.1.2. Oracle JDK para Windows

A continuación vamos a explicar cómo instalar JDK 13 en Windows 10:

1) Descargad la versión de JDK 13.0.2 o superior. Sobre todo, hay que fijarse en
que se trata del JDK y no del JRE. Acceded a través del navegador a la siguiente
dirección: http://java.sun.com/javase/downloads/index.jsp.

Figura 3

Haced clic en uno de los dos botones de «Download» (resaltados con un re-
cuadro en la figura 3). A continuación, aceptad la licencia y escoged la opción
de Windows que deseéis. Os recomendamos que elijáis la opción ejecutable
(*.exe).
© FUOC • PID_00273929 13 Guía de Java

Figura 4
Nota

Si tenéis Windows XP o un
ordenador con CPU de 32
bits, debeis descargar la ver-
sión 8 (8u221), que tiene
opción de 32 bits (x86):
https://www.oracle.com/
technetwork/java/java-
se/downloads/jdk8-down-
loads-2133151.html. En prin-
cipio podréis realizar todas las
actividades iniciales, pero es
importante que consigáis un
ordenador con CPU de 64 bits
y con un sistema operativo
Windows 7 o superior.

2) Una vez descargado el programa de instalación, ejecutadlo�en�modo�ad-

ministrador (por ejemplo, botón derecho del ratón: «Ejecutar como adminis-
trador»). El proceso de instalación acaba de comenzar. Una pantalla de seguri-
dad de control aparece para los usuarios de Windows 7 o superior. Si aparece,
aceptad.

3) A continuación os debe aparecer la pantalla de bienvenida a la instalación,

haced «Next».

Figura 5

4) Aparecerá una pantalla donde se pide la carpeta de instalación. Dejad la que

os recomienda el propio instalador. Haced «Next».
© FUOC • PID_00273929 14 Guía de Java

Figura 6

5) Una vez instalado el JDK aparecerá la siguiente pantalla, donde hay

dos botones. Si pulsáis en «Next Steps», se abrirá la página web https://
docs.oracle.com/en/java/javase/13/ donde encontraréis una gran cantidad de
documentación. Si pulsáis en «Close», se cerrará el Wizard de instalación.

Figura 7

6) Tras haber finalizado la instalación, debéis configurar el PATH. Para ello,

en Windows (cualquier versión), es necesario que vayáis al Panel de control y
escojáis la opción «Sistema y seguridad». A continuación, escoged «Sistema» y
dentro de esta pantalla elegid «Configuración avanzada del sistema» (está en
el lado izquierdo, véase recuadro en la figura 8).
© FUOC • PID_00273929 15 Guía de Java

Figura 8

7) Dentro de esta ventana de configuración escoged la pestaña «Opciones

avanzadas», donde encontraréis un botón que dice «Variables de entorno».

Figura 9

8) Si hacéis clic en «Variables de entorno», aparecerá una ventana para modi-

ficar las diferentes variables definidas en el sistema. En la lista de abajo bus-
cad y seleccionad la variable Path (o PATH), y a continuación pulsad el botón
«Editar...».
© FUOC • PID_00273929 16 Guía de Java

Figura 10

9) Se abrirá una ventana para modificar el valor de la variable Path. Seleccionad

la primera fila vacía que haya y escribid:

JAVADIR es el directorio donde habéis instalado el JDK, por ejemplo, si lo ha-

béis instalado en ’C:\Program Files\Java\jdk-13.0.2’, entonces habrá
que añadir:

Figura 11
Nota

Recordad que el nombre de la

carpeta dependerá de la ver-
sión instalada y la ruta de ins-
talación. Si tenéis varias versio-
nes de JDK instaladas, es im-
portante que la versión que
acabáis de instalar sea la pri-
mera del listado. Para conse-
guir que aparezca antes que
cualquier otra versión, utilizad
los botones «Subir» y «Bajar»
del lado derecho.
© FUOC • PID_00273929 17 Guía de Java

10) Finalmente, para comprobar que JDK está correctamente instalado, podéis
consultar (por línea de comandos, por ejemplo, cmd) las versiones de java y
javac mediante las instrucciones:

Estas instrucciones os deberían devolver respectivamente la versión de java

(JRE) y javac (compilador) que se están usando en el ordenador. Debe coinci-
dir con la que habéis instalado. Si todo es correcto, veréis una pantalla similar
a la que se muestra en la figura 12.

Figura 12

Si aun así no lográis tener instalada la versión 13 (o la que co-

rresponda en el momento de leer esta guía) de JDK, seguid los pa-
sos que aparecen en el manual: Installation of the JDK on Microsoft
Windows Platforms (https://docs.oracle.com/en/java/javase/13/install/insta-
llation-guide.pdf#_OPENTOPIC_TOC_PROCESSING_d127e1987).

1.1.3. Oracle JDK para Linux

Tenemos dos maneras de instalar JDK. La primera, a través de los repositorios

de paquetes de Linux, y la segunda, desde la web de Oracle.

Seguid las instrucciones que encontraréis en la guía Installation of the JDK

on Linux Platforms (https://docs.oracle.com/en/java/javase/13/install/installa-
tion-guide.pdf#_OPENTOPIC_TOC_PROCESSING_d127e1148).

1.1.4. Oracle JDK para macOS

El sistema operativo macOS ya trae por defecto la versión completa del JDK
instalada y preparada para usarla. En el caso de que se tenga una versión vieja
del JDK y se quiera instalar una más nueva, se puede conseguir a través de las
actualizaciones de software y el website de soporte de Apple.
© FUOC • PID_00273929 18 Guía de Java

Si aun así no lográis tener instalada la última versión

de JDK, seguid los pasos de la guía Installation of the
JDK on macOS (https://docs.oracle.com/en/java/javase/13/install/installa-
tion-guide.pdf#_OPENTOPIC_TOC_PROCESSING_d127e1628).

1.2. Compilando y ejecutando un programa por línea de

comandos

En primer lugar vamos a ver cómo se compila un programa Java por línea de
comandos. Es decir, vamos a ejecutar el compilador del JDK para que traduz-
ca de lenguaje Java a bytecode. O, lo que es lo mismo, crearemos un fichero
.class a partir de un fichero .java.

Actividad

Haced la Tarea 1 de la PEC 1 que proporcionamos con esta asignatura.

1.3. Eclipse IDE

(5)
Si habéis hecho la actividad propuesta como Tarea 1 de la PEC 1, os habréis Acrónimo de integrated develop-
ment environment, entorno integra-
dado cuenta de que podemos escribir código con un editor de texto sencillo –
do de desarrollo.
por ejemplo, Notepad– así como compilar y ejecutar programas Java por línea
de comandos usando javac y java, respectivamente. Sin embargo, cuando
los programas se hacen más complejos, este entorno de desarrollo no es prác-
tico. Es por eso por lo que se crearon los IDE,5 que facilitan el desarrollo de
software. IDE hay muchos. Los más utilizados en el ámbito del lenguaje Java
son Eclipse, NetBeans e IntelliJ. Son todos muy similares y usar uno u otro
dependerá de las preferencias de cada desarrollador. En esta guía vamos a op-
tar por Eclipse.

En primer lugar debemos instalar Eclipse IDE. Para ello, debemos seguir los
pasos detallados en el apartado siguiente.

1.3.1. Instalación de Eclipse IDE

La instalación de Eclipse es bastante sencilla, solo debéis seguir los pasos que
se detallan a continuación (para sistemas operativos diferentes a Windows,
quizás es más sencillo bajarse directamente el fichero comprimido de la mo-
dalidad de Eclipse IDE for Java Developers y descomprimirlo en el ordenador).
Algunos aspectos o nombres pueden cambiar entre lo que se explica en este
apartado y lo que podéis encontrar en el entorno de trabajo. En tal caso, debéis
ser capaces de hacer las analogías correspondientes.

1) En primer lugar, debéis tener instalada la versión JDK más actual posible.

2) Ir a la web de descargas de Eclipse: https://www.eclipse.org/down-

loads/eclipse-packages/.
© FUOC • PID_00273929 19 Guía de Java

(6)
3) Una vez en ella, usaremos la manera más sencilla de instalar Eclipse. Es En inglés, Eclipse Installer.
6
decir, mediante el instalador Eclipse (véase recuadro de la figura 13). Hacemos
clic en el enlace de nuestro sistema operativo.

Figura 13

4) La web nos llevará a otra página con un botón en grande que dice «Down-
load». Hacemos clic en él.

Figura 14

5) Guardamos el ejecutable que nos aparecerá.

6) Una vez tenemos el ejecutable en nuestro ordenador, hacemos doble clic

para ejecutarlo. Recordad ejecutarlo como administrador (es decir, en Win-
dows, el usuario con el que estáis autenticados en el sistema operativo debe
tener permisos de administrador, si no, debéis hacer botón derecho sobre el
ejecutable y escoger la opción «Ejecutar como administrador»).
© FUOC • PID_00273929 20 Guía de Java

7) Nos aparecerá una ventana con diferentes modalidades de Eclipse. Antes de

nada es interesante (e importante) actualizar el instalador, si es que hay que
hacerlo. Para saber si necesitamos actualizarlo, miramos el icono con dibujo
de menú (tres rayas) que hay en la parte superior derecha. Si tiene una excla-
mación, lo más seguro es que al clicar, nos aparezca la opción «Update» con
exclamación. Si es así, hacemos clic en «Update» y esperamos a que se actua-
lice el instalador (seguramente se reiniciará).

Figura 15

8) Cuando tengamos el instalador actualizado y estemos en la pantalla de se- Funcionalidades de Eclipse

lección de la modalidad de Eclipse a instalar, escogemos «Eclipse IDE for Java
Si necesitáis añadir alguna fun-
Developers». También nos serviría «Eclipse IDE for Java EE Developers», la cual cionalidad de Java EE a vues-
es una versión más completa destinada para el desarrollo de aplicaciones ba- tro «Eclipse IDE for Java Deve-
lopers», podéis hacerlo insta-
sadas en Java EE. Sin embargo, la versión Java EE ocupa más en el disco duro. lando el plugin correspondien-
te.

9) Una vez escogida la modalidad, nos aparecerá una ventana que nos pedi-
rá dónde queremos guardar Eclipse, si queremos una entrada en el menú de
inicio y un acceso directo en el escritorio. Además, no detecta la versión de
Java que tenemos por defecto en el sistema operativo. En el campo «Product
Version» escoged la versión «Lastest». Cuando tengamos nuestras preferencias
indicadas, decimos «Install».

10) Durante la instalación nos aparecerá una ventana para aceptar la licencia
de uso. Hacemos clic en «Accept». La instalación continuará. También es po-
sible que nos pida aceptar unos certificados. Los aceptamos y la instalación
seguirá su curso.

11) Si todo ha ido bien, nos aparecerá en la pantalla el botón «Launch» en

verde. Hacemos clic en el botón «Launch» para ejecutar Eclipse.

12) Tras cargar librerías, nos aparecerá una ventana en la que nos pide la ubi-
cación (es decir, carpeta) que Eclipse debe usar como directorio de trabajo o
workspace. Es decir, allí donde guardará y buscará los proyectos (es decir, los
programas que creemos), además de guardar nuestras preferencias. Podemos
dejar la ubicación que nos sugiere o escoger otra. También podemos decirle
que la recuerde y no nos pregunte más (recomendamos no marcar esta op-
ción). Una vez tengamos claro dónde ubicar nuestro directorio de trabajo, ha-
cemos clic en el botón «OK».
© FUOC • PID_00273929 21 Guía de Java

Figura 16

13) Eclipse seguirá cargándose hasta que, por fin, se abra.

14) La primera vez nos aparecerá una ventana de bienvenida. A continuación,

cerramos esta ventana mediante la «X» que aparece arriba a la izquierda junto
al nombre «Welcome» y nos aparecerá la perspectiva Java.

Figura 17

15) Si cerramos Eclipse, este guardará nuestra configuración. De este modo,

cuando lo volvamos a abrir, Eclipse se abrirá con las mismas ventanas y pers-
pectivas que había justo antes de cerrarlo. Esto será especialmente útil cuando
estemos desarrollando programas de un cierto tamaño y tengamos abiertos
diferentes ficheros y perspectivas.

A continuación, vamos a describir muy brevemente los elementos más impor-

tantes de Eclipse.

1.3.2. Vistas

Cada una de las ventanas/trozos que se ven en la pantalla de Eclipse es una

vista. Cada vista está asociada a una perspectiva, por lo tanto, según en la
perspectiva en que nos encontramos, habrá vistas que no estarán disponibles.
Todas las vistas tienen unos botones en la parte derecha para maximizar o mi-
nimizar la ventana. Haciendo doble clic sobre la ventana también se puede
© FUOC • PID_00273929 22 Guía de Java

maximizar. Cuando maximizamos una vista, todas las otras vistas se minimi-
zan. Para volver a la configuración normal podemos volver a hacer doble clic
en la barra superior de la vista o bien clicar el botón situado en la parte más
derecha de la barra superior de la vista, que tiene la forma de dos ventanas
sobrepuestas. En la perspectiva de Java, cuando abrimos por primera vez un
nuevo proyecto, nos encontramos con las vistas siguientes:

Figura 18

Explorador de paquetes (package explorer)

Es la ventana que se encuentra en la parte más izquierda (recuadro granate de

la figura 18). Se ven todos los proyectos que tenemos en nuestro directorio de
trabajo. Para cada proyecto se ven en forma de árbol todos los ficheros que
contiene. Los pequeños triángulos que aparecen junto a algunos de los ítems –
como por ejemplo directorios, paquetes, ficheros, etc.– indican que estos ele-
mentos se pueden expandir. Clicando sobre el triángulo, el ítem se expande
revelando los elementos que contiene. En la perspectiva de Java se remarcan
los subdirectorios que forman un paquete y los ficheros .java que contiene
cada uno de los paquetes. Los ficheros Java se pueden expandir mostrándo-
nos las clases, métodos y atributos que contienen. Si hacemos doble clic sobre
algún fichero, este se nos abrirá en el editor, es decir, en la parte central del
aplicativo.

Editor

El editor es la ventana/vista que se encuentra a la parte central de Eclipse (re-

cuadro verde de la figura 18). Todos los ficheros que se abren, ya sea desde el
«Explorador de Paquetes» o desde el menú «Fichero», se muestran en el editor.
La parte superior de la vista es una barra de pestañas donde se nos muestran
los nombres de los ficheros abiertos recientemente. La pestaña activa corres-
© FUOC • PID_00273929 23 Guía de Java

ponde al fichero que se está visualizando en este momento en el editor. En

caso de que abriéramos muchos ficheros, en la parte derecha de la barra de
pestañas aparecería el símbolo >> con el número de ficheros abiertos y que no
se ven en dicha barra. Si clicamos, se nos desplegarán los otros ficheros que
están abiertos.

La vista del editor es la que más usaremos durante la implementación de có-

digo, por lo tanto, suele ser una buena idea maximizar la ventana del editor
mientras trabajamos.

Cuando nos encontramos en la perspectiva de Java y estamos editando un

fichero .java, en el código se nos resaltan las palabras clave en color lila.
Otros elementos como los nombres de los atributos o cadenas de texto se nos
muestran en color azul. Los métodos se pueden ocultar clicando en el símbolo
menos (-) que encontramos en la parte izquierda de la línea de declaración
del método. Si queremos volver a ver su contenido, solo hay que clicar en el
símbolo más (+) que aparecerá junto a la definición del método.

El editor también tiene la función de ir marcando los errores de compilación

que encuentre mientras vamos escribiendo. Los errores salen marcados en la
parte derecha como cuadrados rojos; en la parte izquierda, como cruces; y en
la parte de código incorrecto, subrayada con rojo. Si nos situamos encima de
alguna marca de error nos saldrá un mensaje explicativo del tipo de error.

Otra funcionalidad del editor es el autocompletado de código. El autocomple-

tado de código nos permite inspeccionar el código que se puede incluir allá
donde estemos escribiendo. Por ejemplo, si escribimos el nombre de una ins-
tancia de un objeto, podemos inspeccionar los métodos y atributos de este
objeto tan solo con escribir el punto para invocar las llamadas (mensajes). Para
ello escribimos el punto y esperamos a que nos salga la lista de posibles mé-
todos y atributos. Se puede llamar al autocompletado de código en cualquier
momento pulsando la combinación de teclas Ctrl y espacio. Estemos donde
estemos, se nos mostrará una lista de sugerencias con los posibles objetos o
variables que tengamos definidas.

Outline

La vista de outline (recuadro azul de la figura 18) nos permite visualizar los
componentes del fichero Java que tengamos abierto en el editor, de la misma
forma en que se visualizan en el explorador de paquetes. Es decir, se nos mues-
tran las clases, atributos y métodos que haya en el fichero .java actual. Si se
clica en cualquiera de estos elementos en la vista de outline, inmediatamente
se resalta en la ventana del editor. Los botones que hay encima de la vista nos
permiten ocultar o mostrar diferentes elementos, como métodos no públicos,
métodos estáticos, atributos, etc. También nos permite ordenar los elementos
en la vista por orden alfabético.
© FUOC • PID_00273929 24 Guía de Java

Problems

Esta vista (recuadro naranja de la figura 18) se suele encontrar en la parte in-
ferior del editor y nos muestra los errores y avisos que tengamos en cualquier
fichero de los proyectos que tengamos abiertos. Para cada problema nos mues-
tra una descripción y el lugar donde se encuentra (fichero y línea).

Console

Esta vista se suele encontrar también en la parte inferior del editor, en otra
pestaña junto a la de problemas (recuadro naranja de la figura 18). Esta vista
se activa automáticamente cuando se ejecuta una aplicación Java y sirve para
mostrar la salida del programa, así como para pedir la entrada de datos a la
aplicación si hace falta.

1.3.3. Menús

Las funcionalidades de Eclipse se encuentran disponibles a través de la barra

de menú general de la aplicación situada en la parte superior. El menú se en-
cuentra dividido en diferentes submenús: «File», «Edit», «Source», «Refactor»,
«Navigate», «Search», «Project», «Run», «Window» y «Help». Según la perspec-
tiva, estos menús, así como su contenido, pueden variar.

También hay disponible un menú secundario accesible pulsando el botón de-

recho del ratón encima de cualquier selección que hagamos sobre las vistas de
explorador de paquetes o editor. Este menú contextual muestra las opciones
de menú más comunes y adecuadas a la selección que estamos haciendo.

Menú «File»

Desde este menú podemos acceder a los asistentes de creación de nuevas cla-
ses, proyectos, paquetes, interfaces y cualquier otro elemento relacionado con
Java. Para ello solo hay que abrir el submenú «New» y desde allí seleccionar
el asistente que se desee.

Desde el menú «File» tenemos acceso a todas las operaciones sobre los fiche-
ros de nuestro proyecto. Si estamos situados sobre algún fichero en la vista de
explorador de paquetes, podremos mover el fichero o renombrarlo. También
existe la opción de refrescar («Refresh») las carpetas del explorador. Esta fun-
cionalidad se puede realizar también usando el atajo de teclado F5. Tanto si
estamos en esta vista o sobre el editor, podremos cerrar el fichero seleccionado
o guardarlo con otro nombre.
© FUOC • PID_00273929 25 Guía de Java

De este menú hay que destacar también la posibilidad de cambiar de directorio

de trabajo, seleccionando «Switch Workspace», de este modo podemos tener
diferentes directorios de trabajo donde guardar nuestros proyectos. El último
directorio de trabajo seleccionado será con el que se abra Eclipse la próxima
vez que lo pongamos en marcha.

Finalmente, especial atención merecen los apartados de importar y exportar

del menú «File». Estos asistentes son extremadamente importantes para poder
llevarnos nuestros proyectos Eclipse a otras máquinas. Cuando abrimos estos
asistentes se nos muestra una lista de posibles ubicaciones de dónde importar
o a dónde exportar.

Figura 19

En el apartado «General» encontramos las herramientas más utilizadas de los

dos asistentes. En el caso del «Asistente de importación» destacamos:

• La opción «Existing Projects into Workspace» nos permite crear un pro-

yecto en nuestro directorio de trabajo a partir de un fichero comprimido
que contenga un proyecto Eclipse o desde otro directorio de trabajo. El
proyecto se nos abrirá dentro de nuestro directorio de trabajo y, si que-
remos, podremos marcar la opción «Copy projects into workspace» para
guardarlo.

• La opción «Archive File» nos permite guardar ficheros ubicados en un fi-

chero comprimido dentro de un proyecto Eclipse que ya exista en nuestro
directorio de trabajo. Estos ficheros pasarán a formar parte del proyecto
seleccionado.

• La opción «File System» nos permite guardar ficheros que tengamos en

alguna carpeta de nuestro sistema dentro de un proyecto Eclipse que ya
exista en nuestro directorio de trabajo. Estos ficheros pasarán a formar
parte del proyecto seleccionado.
© FUOC • PID_00273929 26 Guía de Java

En el apartado «General» del «Asistente de exportación» destacamos las si-

guientes opciones:

• La opción «Archive File» exporta un proyecto de nuestro directorio de tra-

bajo como un fichero comprimido.

• La opción «File System» exporta un proyecto desde nuestro directorio de

trabajo a otro directorio local de nuestra máquina.

Dentro del asistente de exportación hay que destacar también el apartado «Ja-
va». Tenemos tres opciones:

1) La opción «JAR File» permite generar un fichero JAR de cualquiera de nues-

tros proyectos. Un fichero JAR es un contenedor de clases Java que permite
tener clases Java comprimidas y agrupadas en un único fichero. Esto facilita la
exportación y transmisión de programas/API entre programadores.

2) La opción «Javadoc» que permite generar la documentación Javadoc de cual-

quiera de nuestros proyectos, especificando las opciones que deseamos y el
directorio donde guardar la documentación generada.

3) La opción «Runnable JAR file» crea un fichero JAR autoejecutable, es decir,

como si fuera un .exe.

Menú «Project»

El menú «Project» nos muestra opciones que nos permiten especificar cómo
queremos que se lleve a cabo la compilación del proyecto. La última opción de
todas es la de propiedades del proyecto («Properties»). Desde «Properties» se
puede configurar cualquier aspecto del proyecto. Las opciones más destacadas
son:

1)�«Java�Build�Path»: desde este formulario podemos especificar librerías (por

ejemplo, ficheros JAR) y código que queremos añadir a nuestro proyecto. Es-
te formulario es el mismo que al que se puede acceder desde el asistente de
proyecto nuevo. El «Build Path» es la manera que tiene Eclipse de configurar
el classpath de la máquina virtual de Java, es, por lo tanto, muy importante
que el «Build Path» esté muy bien configurado, puesto que si no, tendremos
errores de compilación.

En el apartado de librerías siempre sale por defecto como mínimo las librerías
de sistema de la máquina virtual que estemos usando. Si se edita esta librería
tendremos la opción de cambiarla por cualquier otra de las máquinas virtuales
de Java que tengamos en nuestro ordenador. Se pueden añadir otras librerías
que hagan falta en nuestro proyecto desde ficheros JAR o desde directorios.
© FUOC • PID_00273929 27 Guía de Java

Además hay las opciones de editar y borrar librerías ya incluidas. En el apar-

tado «Source» sale por defecto el directorio donde se encuentra el código del
proyecto.

2)�«Java�Compiler»: desde este formulario podemos escoger el grado de com-

patibilidad de nuestro código. El grado de compatibilidad (JDK Compliance)
significa hasta qué máquina virtual este código tiene que ser válido. Por ejem-
plo, si ponemos compatibilidad hasta la máquina virtual 1.4, todos los ele-
mentos sintácticos propios de la máquina virtual 1.5, como los genéricos o
las enumeraciones, que haya en nuestro código darán error. Por defecto se co-
gen las propiedades generales especificadas en nuestro directorio de trabajo.
Se puede cambiar la configuración para un proyecto en concreto si activamos
la casilla «Enable project specific settings».

Menú «Run»

Desde este menú podemos ejecutar nuestro código, gestionar diferentes con-
figuraciones de ejecución del proyecto y llamar al debugger.

La opción «Run» ejecutará el proyecto que tengamos seleccionado en el editor

o en el explorador de paquetes. Buscará el método main y lo ejecutará. Los
posibles resultados de salida por consola se verán en la vista «Console». En
caso de no haber ningún método main, saltará un aviso informándonos de
que la selección no contiene ningún método que se pueda ejecutar.

Otros menús

En el menú «Window» encontramos opciones para configurarnos el entorno

de ventanas a nuestro gusto. Podemos abrir vistas, cambiar de perspectiva y
configurarla. También tenemos la opción de restaurar una perspectiva en su
estado por defecto, guardarla o cerrarla.

En el menú «Search» se encuentran las opciones para buscar cadenas de texto

dentro de nuestro código. Además, se pueden hacer otros tipos de búsquedas,
como encontrar las referencias o declaraciones de una variable. Solo hay que
seleccionar en el editor la variable que se desee buscar y elegir la opción ade-
cuada en el menú de búsquedas.

En los menús «Source» y «Refactor» hay toda una serie de opciones con tal de
automatizar ciertas tareas repetitivas a la hora de desarrollar una aplicación.
En el menú «Source» podemos encontrar utilidades como añadir bloques de
comentarios, generar setters y getters automáticamente, añadir de forma auto-
mática los imports que hagan falta en el fichero, crear la indentación del códi-
go de forma automática, etc. En el menú «Refactor» tenemos utilidades para
propagar cambios en el código sobre todos los ficheros .java implicados, co-
mo por ejemplo, cambiar el nombre de una clase o método y cambiar todas
© FUOC • PID_00273929 28 Guía de Java

las referencias y declaraciones que haya en el código. Desde aquí también po-
demos mover una clase de un paquete a otro y propagar los cambios que esto
produzca en las demás clases del proyecto.
© FUOC • PID_00273929 29 Guía de Java

2. Fundamentos de Java (como lenguaje imperativo)

2.1. Comentarios dentro del código

Los comentarios se utilizan para documentar y explicar el código que realiza-

mos. Los comentarios son ignorados por el compilador, sin embargo son im-
portantes para explicar la lógica del programa (y algunas decisiones tomadas)
a terceros (y a uno mismo en el futuro).

Decir que en Java hay dos maneras de escribir comentarios en el código:

Comentario de una línea

Comentario de múltiples líneas

Además de servir para documentar, los comentarios también sirven para «ca-
par» o «inhabilitar» parte de nuestro código. Así pues, en vez de borrar un
trozo de código para siempre, podemos comentarlo y, si fuera necesario, recu-
perarlo más tarde. Una vez sepamos que ese código es descartable, podemos
borrarlo para siempre.

Esto es útil, por ejemplo, cuando estamos probando cosas. También es útil
si estamos encallados escribiendo un algoritmo complejo, pero tenemos un
código base creado que sabemos que funciona. Ese código base podría ser co-
mentado para recuperarlo más tarde si al escribir el algoritmo llegamos a un
callejón sin salida y debemos empezar de nuevo. De esta manera, el código
base sirve como punto de partida desde donde iniciar de nuevo el algoritmo.

2.2. Estructura básica de un programa

Como ya sabemos, Java es un lenguaje pensado para el paradigma de la pro-

gramación orientada a objetos (POO). Por el momento no entraremos en con-
ceptos de POO, pero irremediablemente, por la naturaleza de Java, aparecerán
desde el principio de las explicaciones.

Como consecuencia de ello, algunos elementos POO aparecen cuando anali-

zamos el código mínimo para crear un programa en Java.
© FUOC • PID_00273929 30 Guía de Java

ClassName.java

Analicemos el código anterior:

1) Debido a que Java está orientado a objetos, los programas en Java están
organizados por clases. Cada�clase�tiene�que�ir�en�un�fichero�cuyo�nombre
debe� ser� el� mismo� que� el� de� la� clase. Por una cuestión de convención de
nombres, lo más habitual es que la primera letra de cada palabra que compone
el nombre de la clase empiece por mayúscula. En el caso del ejemplo, la clase
se llama ClassName y el fichero ClassName.java.

2) Un programa de una cierta envergadura estará formado por más de una clase Uso de varargs en el main
(por ejemplo, más de un fichero .java). Esto obliga a que, en como mínimo
Como veremos más adelan-
una de esas clases, haya un método especial llamado main. Dicho método sirve te, String[] args se puede
de punto de entrada al programa. Es decir, el programa se iniciará llamando a cambiar por String...args,
gracias a la nueva sintaxis de
este método. El método main tiene una firma concreta: las varargs.

3) El método main no devuelve nada (por eso su tipo de retorno es void) y

recibe un array de String (es decir, una cadena de caracteres) por parámetros
llamado args (el nombre se puede cambiar, pero lo más habitual es denomi-
narlo así, procedente de la abreviatura de arguments). Este parámetro args
almacena los valores pasados por línea de comandos (es decir, argumentos)
cuando el programa se ejecuta. Como en el código anterior, el método main
se encuentra en la clase ClassName, haremos:

4) En este caso, args tendría dos casillas con los valores "David" y "36", los
dos serían texto (es decir, String). El primer valor estaría en args[0] y el
segundo en args[1].

5) Por ahora olvidémonos de la palabra reservada static. Veremos su signi-

ficado tanto en esta guía como en los materiales teóricos de la asignatura. Eso
sí, si creamos más funciones dentro del fichero ClassName, por�ahora (y solo
por ahora), al no trabajar orientado a objetos (que es para lo que está concebi-
© FUOC • PID_00273929 31 Guía de Java

do Java), las�firmas�de�todas�las�funciones�deberán�tener�la�palabra�static.
Cuando pasemos a programar orientado a objetos, veremos que este requisito
ya no será necesario.

6) A continuación de los dos comentarios en los que pone TODO (del inglés,
to do, es decir, «para hacer», «pendiente», etc.) podríamos escribir el código de
nuestro programa. El código del primer TODO estará formado por instruccio-
nes/sentencias (statements) y bloques (blocks).

• Instrucción/sentencia: es la unidad mínima de programación encargada

de realizar una acción. Cada sentencia debe terminar con un punto y coma
(;).

• Bloque: es un grupo de sentencias agrupadas entre dos llaves { }. Todas las

sentencias ubicadas entre dos llaves son tratadas como una única unidad.
Dentro de dos llaves puede no haber ninguna instrucción.

7) A la hora de escribir nuestro código debemos tener presente algunas con-

venciones de estilo de formato:

• No importa añadir muchos espacios, tabuladores, enters (es decir, nuevas

líneas en blanco) entre dos palabras, puesto que Java los trata como un
único espacio/tabulador/nueva línea.

• Es importante indentar (es decir, sangrar) el código con tabuladores y es-

pacios en blanco, así como usar apropiadamente los espacios en blanco
entre líneas con el fin de facilitar la lectura del código.

• En el caso de las llaves, lo más habitual en Java es poner la primera llave

({) al final de la primera línea. En el caso de la última llave (}) esta se
© FUOC • PID_00273929 32 Guía de Java

pone en una línea después de la última sentencia y alineada con la primera

sentencia del bloque (mirad el código anterior).

2.3. Entrada por teclado y salida por pantalla (I/O)

Java tiene tres streams (flujos) de entrada y salida:

1)�Entrada�estándar�(standard�input�stream): por defecto se refiere al teclado,

aunque se puede redirigir a otra fuente de entrada, por ejemplo, un fichero de
texto. Para acceder a este flujo usaremos System.in.

2)�Salida�estándar�(standard�output�stream): por defecto Java utiliza la pan-

talla de la consola como salida, pero se puede cambiar, por ejemplo, a un fi-
chero de texto. Para acceder a este flujo usaremos System.out.

3)�Salida�de�error�(error�output�stream): este stream se utiliza para mostrar

mensajes de error o con información importante. Por defecto utiliza la pantalla
de la consola, aunque es muy frecuente redireccionarlo hacia un fichero de
log. Para acceder a este flujo usaremos System.err.

La clase System de la API Java nos proporciona acceso a tres atributos públicos Nota
y estáticos llamados in, out y err. Tanto System.in, como System.out
En este apartado solo veremos
y System.err son instanciados e inicializados automáticamente por la JVM los métodos básicos de la en-
cuando esta arranca, así que no hay que hacer nada para tenerlos disponibles. trada y la salida estándares,
obviando la salida de error.

2.3.1. Métodos de salida

La clase System de la API Java nos proporciona acceso a un atributo público

y estático llamado out de tipo PrintStream (otra clase de la API de Java).
Dicho atributo, que es una referencia a un objeto de la clase PrintStream,
nos permite acceder a los métodos públicos de dicha clase, la cual se encarga
de escribir datos en el flujo de salida que se indique. De entre ellos, destaca:
print, println y printf.

Métodos print y println

Estos dos métodos son los más frecuentes. La diferencia entre ellos es que
println imprime el contenido que se le pase y añade un salto de línea (\n).
Es decir, avanza el cursor para escribir en la siguiente línea de la pantalla. Sa-
biendo esto, el siguiente código:
© FUOC • PID_00273929 33 Guía de Java

Imprimiría:

Como vemos, el 8 se imprimiría en la misma línea que el primer 5, porque el

5 ha sido imprimido con un print.

Método printf

Los dos métodos anteriores no permiten especificar un formato para contro-

lar aspectos como, por ejemplo, el número de decimales a mostrar para un
valor de tipo double. El método printf recibe, como mínimo, una cadena
de texto que indica el texto junto con el formato a mostrar. A continuación,
si es necesario, recibe tantos valores (en forma de literales o variables) como
se necesiten para rellenar el texto. Veamos varios ejemplos para entender su
funcionamiento:

La manera de indicar en el texto de salida dónde queremos un formato espe-

cial es mediante el uso de un comodín que tiene un determinado formato:
%[flags][ancho]códigoConversión. Tanto los flags como el ancho son
dos valores opcionales. Los flags sirven para indicar aspectos como la alinea-
ción del texto y el elemento a añadir como padding (relleno), entre otros. Por
su parte, el ancho es un valor que indica cuánto espacio debe ocupar el ele-
mento como mínimo. Finalmente, el código de conversión sirve para indicar
el tipo del valor:

• d para entero,
• f para float o double,
• c para char y
• s para String (cadena de texto).

Veamos algunos ejemplos:

Respecto al salto de línea, este método funciona exactamente igual que print,
es decir, no avanza el cursor a la siguiente línea. Si queremos hacer un salto,
debemos añadir \n al final del texto.
© FUOC • PID_00273929 34 Guía de Java

2.3.2. Métodos de entrada

Como ya hemos dicho, por defecto, el flujo de entrada viene del teclado. En
JDK 5 se introdujo una clase llamada Scanner que facilita la lectura con for-
mato del teclado. De este modo, con Scanner podremos controlar, de manera
sencilla, si queremos leer un int, un double, etc.

2.4. Variables

Una variable se define como una unidad básica de almacenamiento. Se

puede ver como una etiqueta que permite guardar y recuperar un dato
de memoria. Este dato será de un tipo. Así pues una variable tendrá un
nombre, un tipo y guardará un valor.

Se llama variable porque el valor que almacena puede variar (es decir,
cambiar) durante la ejecución del programa.

2.4.1. Nombre

Los nombres de las variables deben ser representativos de aquello que alma-
cenan.

Imaginad que tenemos tres variables con los siguientes tres nombres: n, p1 y vC. ¿Sabéis
qué almacenan? Ni idea, ¿verdad? Así pues, estos nombres tan crípticos no son adecua-
dos, aunque sí correctos sintácticamente (es decir, Java no dará error). Sin embargo, si
cambiamos los nombres de las variables anteriores por estos otros: numberPeople, per-
son1 y viewsCount ahora sí que podríais saber qué guardan. Como podéis ver, escoger
un nombre que sea descriptivo es una buena práctica.

A la hora de asignar un nombre a una variable debemos tener presente que:

• Los nombres de las variables son case-sensitive. Es decir, Java distingue entre
minúsculas y mayúsculas, por lo que numPeople y numpeople no son la
misma variable.

• El nombre de una variable debe empezar o con una letra, o con el símbolo
$, o con el símbolo underscore _. No obstante, se ha generalizado la buena
práctica de que el nombre de las variables empiecen por una letra, no por
$ ni _.
© FUOC • PID_00273929 35 Guía de Java

• El nombre de una variable puede tener cualquier longitud y, a partir de

la primera letra, este puede estar formado por cualquier combinación de
letras Unicode, dígitos, y los símbolos $ y underscore _.

• Para escribir el nombre de una variable en Java se sigue la convención de-

nominada lower� camel� case (o dromedary case). Esta convención indica
que la primera palabra se escribe en minúscula y, si el nombre de la varia-
ble está compuesto por dos o más palabras, entonces a partir de la segun-
da palabra la primera letra de cada una de ellas se escribe en mayúscula,
por ejemplo, lastName (está compuesta de last + name), height, xMin,
resourceNumber, yTopLeft, etc.

• El nombre que se le asigne a una variable no puede coincidir con uno de

los siguientes literales: true, false y null.

• Tampoco se pueden usar como nombres de variable algunas de las siguien-

tes palabras reservadas de Java (también llamadas keywords):

abstract continue for new switch

assert default goto package synchronized

boolean do if private this

break double implements protected throw

byte else import public throws

case enum instanceof return transient

catch extends int short try

char final interface static void

class finally long strictfp volatile

const float native super while

yield (JDK 13+)

2.4.2. Tipos

Como hemos comentado, las variables serán de un tipo. En Java existen dos
tipos: primitivos y referencias. Los primitivos (o básicos) sirven para almace-
nar valores sencillos, mientras que las referencias se utilizan para guardar ele-
mentos complejos como son los objetos de una clase.
© FUOC • PID_00273929 36 Guía de Java

Primitivos

En Java existen ocho tipos primitivos o básicos.

Tabla 2. Primitivos de Java

Tipo Bytes necesarios pa- Intervalo/rango Valor por defecto Utilidad Ejemplos
ra guardar el valor (valores posibles)

boolean 1 bit true o false false Guardar valores dico- true

tómicos «cierto» y «fal-
so».

byte 1 (8 bits) [-128, 127] 0 Guardar datos peque- 56, 83

ños.

short 2 (16 bits) [-32768, 32767] 0 Mismo uso que byte, 32769, 0xffea
pero su tamaño es el
doble.

char 2 (16 bits) [’\u0000’, ’\u0000’ Guardar un símbolo de ‘a’, ‘?’, ‘\101’, ‘\n’
’\uffff’] la codificación Unico-
(internamente se de.
guarda como un
entero [0, 65535])

int 4 (32 bits) [-2147483648, 0 Guardar valores ente- -2, -1, 0, 1, 234,
2147483647] ros. 500

long 8 (64 bits) 63 63

[-2 , 2 -1] 0 Guardar valores ente- -2L, -1L, 0l; 1L, 2L,
ros que no caben den- -64323
tro del rango del int.

float 4 (32 bits) Estándar para arit- 0.0 Guardar valores deci- 1.23e100f,
mética en coma males con 6-7 decima- -0.23e-100f, .5f
flotante de 32 bits les significativos.
(IEEE 754).

double 8 (64 bits) Estándar para arit- 0.0 Guardar valores deci- 1.23456e300d,
mética en coma males con 15 decima- 1e1d
flotante de 64 bits les significativos.
(IEEE 754).

Unicode

El código Unicode es un estándar de la informática para representar texto. Este incluye

alfabetos, símbolos (por ejemplo, $, &, ?, @) y elementos especiales (por ejemplo, £).
Unicode incluye más de 110.000 caracteres.

Para declarar una variable seguiremos uno de los siguientes patrones (y com-
binaciones de ellos):

Por ejemplo:
© FUOC • PID_00273929 37 Guía de Java

Como se puede apreciar en el ejemplo anterior, en el momento de la decla-

ración se puede aprovechar para inicializar la variable con un valor. Si no se
indica un valor, entonces el compilador le asigna el valor por defecto del tipo
con el que se ha declarado. En el caso de la variable grade, esta será iniciali-
zada automáticamente con el valor 0.0, y que la variable numStudents será
inicializada con el valor 0. Asimismo, se puede ver cómo podemos declarar
más de una variable de un mismo tipo a la vez, combinando al mismo tiem-
po la inicialización o no de dichas variables. Hay algunos programadores que
desaconsejan declarar las variables de esta manera y prefieren que cada varia-
ble sea declarada individualmente. Es decir, cambiaríamos la última línea del
ejemplo anterior por:

Por otro lado, en el caso de datos numéricos, Java permite, para facilitar su
lectura, separarlos mediante el símbolo _ (underscore), por ejemplo, 123_456,
12_345, 1_3 (sería el número 13), etc. Es justo lo que se ha hecho en la
variable viewsCount.

Asimismo, los literales de números enteros se pueden expresar en binario (base

2), octal (base 8), decimal (base 10) o hexadecimal (base 16). Por ejemplo:

En este punto hay que tener presente una apreciación con los tipos long y
float. Veamos el ejemplo siguiente:

Las dos declaraciones anteriores lanzarán un error indicando que el valor que
se desea asignar a year y a price es incompatible. ¿Cómo es esto posible
si están dentro del rango/intervalo de valores? Sencillamente porque el com-
© FUOC • PID_00273929 38 Guía de Java

pilador de Java considera los valores 1983 y 9.99 como valores de tipo int
y double, respectivamente. Así pues, para forzar que los considere long y
float, respectivamente, debemos añadir la letra L en el primer caso, y la letra
F en el segundo. En ambos casos la letra puede ser mayúscula o minúscula:

A continuación, veamos un caso de variable de tipo char y otro boolean.

Las variables de tipo char guardan un único carácter. Estos valores se delimi- JDK 10 y posterior
tan con una comilla simple. En el caso de las variables de tipo boolean, los
Desde JDK 10 es posible no in-
valores que pueden aceptar son true o false. dicar el tipo (ya sea primitivo o
referencia) de una variable lo-
cal utilizando la palabra reser-
Cuando declaramos una variable de tipo primitivo, lo que hace el compilador vada var. Una restricción de
usar var es que la variable de-
es asignarle una dirección de memoria del stack a dicha variable. Nosotros be ser inicializada para que el
compilador pueda inferir el ti-
como programadores no tenemos control de en qué dirección de memoria se po de la variable, por ejemplo:
crea esta variable. var v1 = 5;.

En el ejemplo anterior, la variable age se encuentra en la dirección de memoria

1000. A nivel de memoria, el nombre de la variable desaparece y pasa a ser
la dirección 1000. Es decir, a bajo nivel no existen nombres de variables, sino
direcciones de memoria. Por lo tanto, gracias a los lenguajes de alto nivel como
es el caso de Java, el programador no trabaja directamente con direcciones
de memoria, lo cual facilita el desarrollo de software. Así pues, cuando un
programador escribe el siguiente código después de la declaración anterior:
© FUOC • PID_00273929 39 Guía de Java

El compilador traduce esta instrucción de manera que va a la dirección de

memoria 1000, recupera el valor que hay en dicha posición (es decir, 36), le
suma 2 y guarda en la dirección de memoria 1000 el valor 38.

Referencias

Todas las variables que no son declaradas como uno de los ocho tipos primi-
tivos anteriores, son referencias. En el siguiente ejemplo vamos a declarar un
array de int.

La manera de declarar un array es usando []. El modo de inicializar una refe-

rencia no es asignando un valor como en el caso de los tipos primitivos, sino
usando el operador (y palabra reservada) new.

En la última línea del código anterior estamos declarando un array llamado

grades con 5 casillas de tipo primitivo int.

El operador new crea un objeto en una dirección de memoria concreta del heap Stack y heap
y esa dirección de memoria se la asigna a la referencia, la cual se guarda en
Los conceptos de stack y heap
una zona de memoria del stack. Así pues, el valor de una referencia será una se estudian en profundidad en
dirección de memoria. asignaturas relacionadas con
los sistemas operativos.

Así pues, grades es una variable de tipo referencia ubicada en la posición 854
del stack y cuyo valor es la dirección de memoria (valor 1004) de un objeto
array de 5 casillas de tipo int que está en el heap.

Stack frente a Heap

Cuando un programa se ejecuta, la JVM crea un hilo de ejecución (en inglés, thread) con
un stack privado. En el stack se guardan variables locales, variables de referencia, el control
de las invocaciones a métodos, los valores de los parámetros y de retorno de un método,
resultados parciales, etc. Este espacio de memoria se rige por un comportamiento de pila
(stack), es decir, LIFO (acrónimo de Last-In, First-Out).
© FUOC • PID_00273929 40 Guía de Java

En cambio, el heap es un espacio de memoria dinámica que la JVM adquiere solo arran-
carse la JVM y es único. Por lo tanto, el heap es común a todos los threads de ejecución.
En el heap se guardan los objetos.

Por todo lo anterior, el tamaño del stack es mucho menor que el del heap.

Así pues, una vez creado el objeto de tipo array de int, podríamos asignar un
valor a una de sus casillas:

Hemos asignado el valor 10 a la cuarta casilla del array grades. De igual ma-
nera que ocurre en otros lenguajes (por ejemplo, C/C++), la primera casilla de
un array en Java se corresponde con el índice 0.

Para imprimir por pantalla debemos usar el comando System.out.print()

o System.out.prinltn(). Como ya sabemos, el segundo añade un salto de
línea, es decir, un \n. Dicho esto, analicemos el código siguiente:

Si miramos la última línea del código anterior, vemos que lo que se imprime
por pantalla no es ningún valor del array, sino un «texto extraño». Ese «texto
extraño» no es más que la dirección de memoria del heap donde está alojado
el objeto, que es un array de int.

A las variables que como grades guardan una dirección de memoria, en

Java se les llamas variables de tipo referencia o, simplemente, referencias.

A diferencia de lenguajes como C/C++, en Java no existe el tipo puntero (o

apuntador) como tal:

El símbolo * nos está diciendo que agePointer es una variable que almace-
na la dirección de memoria –es decir, un puntero– de otra variable que es de
tipo int. Como agePointer es una variable, el compilador le asignará una
dirección de memoria del stack:
© FUOC • PID_00273929 41 Guía de Java

Al declarar la variable agePointer de tipo puntero de int, el compilador le

ha asignado la posición de memoria 1004. En la última instrucción del código
anterior, le hemos asignado la dirección de memoria de la variable age. Como
podemos ver, el operador & en C/C++ devuelve la dirección de memoria de
una variable.

A partir de aquí, puedo usar tanto age como agePointer para modificar el
valor de age, ya que agePointer sabe en qué dirección de memoria está guar-
dado el valor de la variable age. Así pues:

Las dos instrucciones anteriores harían exactamente lo mismo, es decir, asig-

narían el valor 80 a la variable age. Así pues, con cualquiera de las dos ins-
trucciones anteriores, la memoria en nuestro ejemplo quedaría así:

¿Qué�ventajas�tiene�usar�punteros? La ventaja reside en poder comunicarse

a más bajo nivel con el hardware, haciendo que la ejecución del código sea
más rápida. Por ejemplo, trabajar con estructuras de datos complejas es más
sencillo utilizando punteros que variables. Así pues, pasar direcciones de me-
moria a una función es más rápido que pasar una copia entera de la variable
(por ejemplo, una estructura de datos). Además, el uso de punteros permite
aplicar operaciones aritméticas (por ejemplo, sumar y restar) sobre direcciones
de memoria para llegar a otros datos que están en otras zonas de memoria.
Todo esto es útil en ámbitos como la creación de sistemas operativos.
© FUOC • PID_00273929 42 Guía de Java

Sin embargo, el uso de punteros también trae consigo problemas, tales como:

• Pérdida de robustez y seguridad al intentar acceder a zonas de memoria

prohibidas por el programa.

• Dificulta la liberación automática de memoria.

• Dificulta la defragmentación de memoria.

• Dificulta la programación distribuida de forma clara y eficiente.

Llegados a este punto, ¿cómo se relacionan las referencias y los punteros en

Java? Pues bien, de manera muy informal y superficial, podríamos decir que:

Punteros en Java
Una referencia�en�Java es como un puntero de C/C++ con la sintaxis
de un tipo primitivo y con unas restricciones más fuertes. Java no tiene punteros explíci-
tamente, pero sí implícitamen-
te. Es decir, las referencias es-
tán programadas internamen-
te como punteros, pero estos
A partir de la definición anterior, para declarar una referencia declararemos punteros no son accesibles pa-
ra los programadores.
una variable de la misma manera que hacíamos con los tipos primitivos, pero
ahora el tipo será un array o una clase (ya sea propia de la API de Java o creada
por nosotros).

El hecho de que Java no use el término dirección de memoria o puntero, sino

referencia, es porque el término referencia añade un significado más genérico y
más estricto. De hecho, propiamente dicho, una variable de referencia alma-
cena la dirección de memoria de un objeto.

Cuando se declara una variable de tipo referencia sin usar el operador new,
el valor por defecto es null. Así pues, en el ejemplo anterior, tanto grades
como birthdate y david son tres referencias que no apuntan a ninguna
zona de memoria del heap, es decir, son null. En cambio, la JVM sí ha creado
un objeto de tipo array con 3 elementos Person. La dirección de memoria del
heap de ese objeto se lo ha asignado como valor a la referencia people. Por lo
tanto, people es una referencia a una zona de memoria del heap, por ejemplo,
I@78ab8876. Sin embargo, cada casilla del array people es una referencia
que no apunta a ninguna zona del heap, es decir, son null. En el caso de las
© FUOC • PID_00273929 43 Guía de Java

variables grades, birthdate y david, así como para cada casilla de people,
aún no se les ha asignado un objeto con el operador new (o asignándole otra
referencia) y apuntan a null. Sin embargo, si hacemos:

El código anterior de manera gráfica sería:

Java proporciona al programador referencias y no punteros para evitar los pe-

ligros de estos, por ejemplo, aplicar operaciones aritméticas sobre los punte-
ros o dejar memoria reservada dinámicamente (por ejemplo, usando malloc,
calloc o realloc) sin liberar (sin haber usado free). Como ya hemos co-
mentado, Java es muy estricto con las referencias en comparación a como C/
C++ lo es con los punteros. Algunas de estas restricciones que impone Java a
las referencias son:

• Un programador no puede cambiar explícitamente el valor de una variable

de tipo referencia. El siguiente código sería incorrecto:

• La única manera en la que una variable de tipo referencia obtiene su valor

es mediante la asignación de un objeto. Las siguientes dos instrucciones
son correctas:
© FUOC • PID_00273929 44 Guía de Java

• Como consecuencia de las dos restricciones anteriores, un programador

no puede aplicar operadores aritméticos sobre las referencias.

• El único capaz de manipular directamente las direcciones de memoria es

la JVM.

2.5. Operadores

Una vez ya sabemos cómo declarar e inicializar variables, es hora de hacer

«algo» con ellas. En este apartado vamos a ver los principales operadores de
Java. Pero antes, definamos qué es un operador.

Igual que en las matemáticas, los operadores son símbolos del lenguaje
que indican que debe realizarse una operación específica sobre un cierto
número de operandos y devolver un resultado fruto de aplicar dicha
operación a los operandos. Por su parte, un operando es una entrada
de un operador.

Antes de continuar, cabe definir el concepto expresión.

Expresión es una combinación de valores, funciones que retornan un

valor, operadores y otras expresiones que, utilizando reglas de prece-
dencia de los operadores que las forman, generan un resultado. Dicho
resultado es otra expresión.

Así pues, tres ejemplos de expresión podrían ser:

2 + 7 − add(8,2)
−1
(3 * 2) + 8

Un aspecto clave cuando se trata el tema de los operadores es la precedencia de

los mismos. Cuando las expresiones son complejas es importante saber cuál es
la precedencia que tiene cada operador dentro de la expresión –es decir, qué
operador se aplica primero– con el objetivo de lograr el resultado esperado.
A continuación, se muestran los operadores de Java ordenados de mayor a
menor precedencia. Es decir, el operador que está más arriba en la tabla se
aplica antes que un operador que está más abajo.
© FUOC • PID_00273929 45 Guía de Java

Tabla 3. Operadores de Java ordenados de mayor a menor precedencia

Operador Precedencia

postfix expr++ expr--

unario ++expr --expr +expr -expr ~ !

multiplicativo * / %

adición + -

shiftado < >> >>>

relacional < > <= >= instanceof

igualdad == !=

bitwise�AND &

bitwise�OR�exclusiva ^

bitwise�OR�inclusiva |

AND�condicional &&

OR�condiconal ||

ternaria ? :

asignación = += -= *= /= %= &= ^= |= <<= >>= >>>=

Los operadores que están en la misma fila en la tabla 3 tienen la misma prece-
dencia. En este caso, la regla que se sigue es que todos los operadores binarios
(es decir, que tienen dos operandos), excepto los de asignación, son evaluados
de izquierda a derecha, mientras que los operadores de asignación (última fila
de la tabla), son evaluados de derecha a izquierda. Asimismo, los paréntesis,
igual que en las matemáticas, tienen la máxima precedencia y se suelen usar
para cambiar el orden de evaluación. Veamos algunos ejemplos de expresiones
para entender las reglas de precedencia:

Ejemplo Equivalente Resultado

1+2-3+4 ((1+2)-3)+4 4

1*2%3/4 ((1*2)%3)/4 0.5

1+2*3-4/5+6%7 1+(2*3)-(4/5)+(6%7) 12.2

A continuación vamos a ver los diferentes tipos de operadores según la fre-

cuencia de uso.

2.5.1. Operadores de asignación, aritméticos y unarios

En este apartado veremos:

© FUOC • PID_00273929 46 Guía de Java

• La asignación simple.
• Los operadores aritméticos.
• Asignaciones aumentadas o compuestas.
• Los operadores unarios.

Asignación simple

Este es uno de los operadores más comunes en cualquier programa. Como su

propio nombre indica, este operador consiste en asignar una expresión (ope-
rando derecho) a una variable (operando izquierdo), ya sea de tipo primitiva
o referencia. Algún ejemplo podría ser:

Operadores aritméticos

Java proporciona los mismos operadores aritméticos que existen en el lenguaje

matemático más uno nuevo, muy común en los lenguajes de programación,
llamado módulo y cuyo símbolo es %. Este nuevo operador lo que hace es dividir
de manera entera (es decir, sin decimales) el operando de la izquierda entre el
operando de la derecha y devolver el resto de dicha división.

Tabla 4. Operadores aritméticos de Java

Operador Descripción Ejemplo Resultado Tipo de resultado

+ Suma 2+3 5 Numérico

- Resta 5-6.5 -1.5 Numérico

* Multiplicación 7*3 21 Numérico

/ División 10/2 5 Numérico

% Módulo 10%7 3 Numérico

Los operadores anteriores se pueden aplicar entre diferentes tipos de

datos primitivos que sean numéricos, es decir, queda excluido el tipo
boolean.
© FUOC • PID_00273929 47 Guía de Java

Por ejemplo, en la tabla anterior para el operador -, hemos realizado la resta

de un int (5) con un float (6.5), siendo el resultado de la operación un
valor numérico de tipo float.

Llegados a este punto hay que tener presente el valor resultante de aplicar un
operador. En este caso debemos distinguir varias casuísticas:

1)�Operandos�del�mismo�tipo�(casos�int,�long,�float�o�double): si los dos

operandos que intervienen en un operador aritmético son del mismo tipo, el
resultado será de ese mismo tipo. Así pues, si miramos la suma: int + int =
int, long + long = long, float + float = float y double + double
= double. Lo mismo ocurriría con la resta, la multiplicación, la división y
el módulo.

La regla anterior afecta a la división entre enteros (int), ya que el resultado Cast explícito
real podría ser un número decimal (es decir, float o double), pero el resul-
Normalmente el cast explíci-
tado obtenido aplicando la regla anterior es que será un entero (es decir, sin to consiste en indicar al com-
decimales). Así pues, 1/2 = 0. Sin embargo, 1.0/2.0 = 0.5. En este caso, pilador que queremos que se
realice una pérdida de pre-
si queremos forzar que el resultado sea un float o un double, debemos ha- cisión (truncado) al pasar de
un tipo a otro más pequeño
cer un cast explícito, es decir, una conversión explícita del tipo, por ejemplo, y que somos completamen-
te conscientes de esta posi-
(float) (1/2) = 0.5. ble pérdida durante la conver-
sión, por ejemplo, int a =
(int)3.5; //a valdrá 3.
2)�Operandos�del�mismo�tipo�(casos�byte,�short�y�char): si los dos ope- Si no hacemos el cast explíci-
to cuando hay posible pérdida
randos son byte o short o char, entonces las operaciones aritméticas son de precisión (por ejemplo, de
realizadas como si los operandos fuesen int (cast implícito porque no hay double, float y long hacia
int), entonces el compilador
pérdida de precisión) siendo el resultado un int. Por ejemplo, byte + byte nos dará un error.
= int + int = int. Si se quiere recuperar el tipo original, hay que hacer
una conversión explícita (es decir, un cast explícito) del resultado:

En el caso del tipo char, el valor int asignado a un carácter será su correspon-
diente número Unicode dentro del rango [0, 65535].

Para estos tres tipos –byte, short y char–, Java siempre hace las ope-
raciones aritméticas como si fuesen int. Es decir, los promociona (les
aplica un casting implícito) a int.
© FUOC • PID_00273929 48 Guía de Java

3)�Operandos�de�tipos�distintos: en este caso, el operando de tipo más peque-

ño es automáticamente promocionado al tipo más grande –es decir, se hace
un casting implícito–, llevándose a cabo la operación en el tipo más grande y
siendo el resultado del tipo más grande. El orden de promoción en Java es el
siguiente: int → long → float → double. Así pues:

1/2.0 → 1.0/2.0 = 0.5 (double)

En este tipo de operaciones debemos tener presente que si queremos asignar

a una variable el resultado de una expresión como 5-6.5, entonces dicha va-
riable debe ser del tipo mayor, en este caso float o double.

Llegados a este punto, cabe resaltar la necesidad de ser consciente de que al

hacer una operación aritmética sobre dos números enteros (int) muy grandes,
el resultado es posible que no se pueda expresar como int (porque se salga
del rango válido de datos), por lo que el resultado será un long. Incluso puede
darse el caso de salirse de los límites inferior o superior de un double.

Finalmente, cabe indicar que el operador + puede usarse para concatenar (es
decir, unir) cadenas de caracteres, que en Java son objetos de la clase String
(lo veremos más adelante). Por ejemplo:

Asignaciones aumentadas o compuestas

Por otro lado, los operadores aritméticos de la tabla 4 permiten combinarse

con el operador de asignación, creando nuevos operadores denominados asig-
naciones aumentadas o compuestas. Estos operadores lo que hacen es asignar
a la variable que hay en el lado izquierdo el resultado de aplicar el operador
aritmético al valor de la variable (operando izquierdo) y a la expresión de la
derecha (operando derecho). Veamos en la tabla 5 estos operadores suponien-
do que el valor de la variable number es 10.

Tabla 5
Azúcar sintáctico
Asignación Ejemplo Equivalente Nuevo valor
aumentada de number El azúcar sintáctico (en inglés,
syntactic sugar) es una nue-
va sintaxis que se añade a un
+= number+=3 number = number + 3 13
lenguaje de programación pa-
ra hacer algunas operaciones
-= number-=6 number = number - 6 4 ya existentes de manera más
sencilla y abreviada. Esta nue-
*= number*=3 number = number * 3 30 va sintaxis hace «más dulce»
el lenguaje. Un ejemplo es el
operador +=.
/= number/=2 number = number / 2 5

%= number%=7 number = number % 7 3

© FUOC • PID_00273929 49 Guía de Java

Existe una pequeña diferencia entre los operadores simples (+, -, *, /, %) y los
compuestos que acabamos de ver:

Operadores unarios

Este tipo de operadores solo utilizan un operando. Los operadores unarios de

Java se muestran en la tabla 6.

Tabla 6. Operadores unarios de Java

Operador Descripción Ejemplo Descripción

+ Signo positivo number = +3; El + indica que el número 3 es positivo.

- Signo negativo number = -3; El - indica que el número 3 es negativo.

++�(sufijo) Incremento int number = 3; Su código equivalente es:

int a = number++; int number = 3;
a = number; //a vale 3
number = number + 1; //number vale 4

++�(prefijo) Incremento int number = 3; Su código equivalente es:

int a = ++number; int number = 3;
number = number + 1; //number vale 4
a = number; //a vale 4

--�(sufijo) Decremento int number = 3; Su código equivalente es:

int a = number--; int number = 3;
a = number; //a vale 3
number = number - 1; //number vale 2

--�(prefijo) Decremento int number = 3; Su código equivalente es:

int a = --number; int number = 3;
number = number - 1; //number vale 2
a = number; //a vale 2

! Negación boolean a = false; La variable b después de la asignación será true (el

boolean b = !a; valor contrario al de a).

Como podemos ver en la tabla 6, una de las particularidades que tienen los
operadores ++ y -- es que pueden aplicarse como prefijo o sufijo. Veamos un
ejemplo más extenso de las diferencias:
© FUOC • PID_00273929 50 Guía de Java

2.5.2. Operadores de igualdad, relacionales y condicionales

Los operadores de este apartado los veremos en tres grupos:

• Operadores de igualdad y relacionales.

• Operadores condicionales.
• Operador instanceof (pertenencia a una clase o interfaz).

Operadores de igualdad y relacionales

Los operadores de estas dos tipologías, también denominados bajo el término

operadores comparativos, permiten comparar dos operandos. El resultado de es-
tos dos operandos será un boolean, es decir, true o false.

Tabla 7. Operadores de igualdad y relacionales

Operador Descripción Ejemplo Resultado

== Igual que 3 == 3.0 true

true == false false

!= Distinto que int b = 5;

b != 10; true
b != 5; false

> Mayor que 15 > 10 true

7 > 10 false

>= Mayor o igual 8 >= 7 true

que 7 >= 8 false

< Menor que -6.5 < 6.5 true

15 < (13.75+1) false

<= Menor o igual 3.2 < 3.3 true

que 10 <= 5 false

Como se puede ver, se pueden comparar expresiones cuyos resultados sean de

tipos numéricos diferentes. El compilador se encarga de realizar las conversio-
nes oportunas antes de hacer la comparación. Asimismo, los operadores == y
!= aceptan también valores de tipo boolean.

Operadores condicionales

En esta categoría solo existen dos operadores: AND condicional y OR condicio-

nal. Estos dos operadores actúan sobre dos expresiones/operandos boolean.

En el caso del AND condicional, este devuelve true si los dos operandos son
true. Mientras que el operador OR condicional devuelve true cuando al me-
nos uno de los dos operandos es true. Estos dos operadores se relacionan con
los operadores lógicos · y + del álgebra de Boole, respectivamente. También se
puede hacer su equivalencia con las puertas lógicas AND y OR, respectivamente.
Por todo lo anterior, una manera sencilla de obtener el resultado de un AND y
un OR es convertir mentalmente los operandos false en 0, los true en 1, el
© FUOC • PID_00273929 51 Guía de Java

AND por una multiplicación y el OR por una suma. Si el resultado de hacer la

multiplicación o la suma es 1, entonces el resultado definitivo es true y, en
caso contrario, es false. Hay que tener presente que en el álgebra de Boole
1+1 = 1.

Tabla 8. Operadores condicionales

Operador Descripción Ejemplo Resultado

&& AND condicional (3 == 3.0) && (50<100) true

false && true false

|| OR condicional (3 == 3.0) || (50<100) true

false || true true
(3>5) || (5<4) false

Los dos operadores anteriores tienen, además, un comportamiento que se de-

nomina de cortocircuito, puesto que el segundo operando es evaluado solo si es
necesario. ¿Cuándo es necesario evaluar la expresión del segundo operando?
Cuando con el resultado del primer operando no se puede determinar con se-
guridad el resultado de la operación AND u OR. Por ejemplo:

Quizás os preguntéis, ¿y por qué es importante saber que AND y OR se compor-

tan como un cortocircuito? Con el siguiente ejemplo esperemos que lo veáis
claro:

Imaginad que la función/método doSomething() hace una serie de operacio-

nes y devuelve true o false en función de esas operaciones. Además, dentro
de esas operaciones que realiza, hay una que es contar las veces que ha sido
llamada esta función. Pues bien, en el ejemplo anterior, dicho contador sería
siempre cero porque jamás se llamaría a doSomething().

Operador instanceof

Este operador compara un objeto con un tipo de clase concreta. Es decir, se Clase e interfaz
usa para saber si una instancia/objeto pertenece a una clase concreta (ya sea
Estos dos conceptos se verán
padre directo o no) o implementa una determinada interfaz. más adelante tanto en esta
guía como en los módulos teó-
ricos de la asignatura.
Un ejemplo de uso de este operador podría ser:
© FUOC • PID_00273929 52 Guía de Java

2.5.3. Operadores bitwise y shiftado

En este apartado veremos operadores que trabajan directamente con los bits.
Estos operadores son mucho menos utilizados que los vistos hasta ahora y se
clasifican en:

• Operadores�bitwise (también conocidos como operadores a nivel de bits).

• Operadores�de�shiftado (u operadores de desplazamiento de bits).

Operadores bitwise

Estos operadores manipulan bits, es decir, 0 y 1.

Tabla 9. Operadores bitwise

Operador Descripción Tipo operandos Ejemplo Resultado

& AND de bits byte, short, int, (3 == 3.0) & (50<100) true
long, char (tratado co- false & true false
mo int) y boolean 60 & 13 12

| OR inclusiva de byte, short, int, (3 == 3.0) & (50<100) true

bits long, char (tratado co- true | false true
mo int) y boolean (3>5) | (5<4) false
60 & 13 61

^ XOR (u OR exclusi- byte, short, int, 5^3 6

va) de bits long, char (tratado co- (3 == 3.0) ^ (50<100) false
mo int) y boolean true ^ false true

~ Complemento a 1 byte, short, int, long ~00000000 (es un byte) 11111111 (byte)
y char ~5 (siendo 5 un int: 0101) -6 (int)

Los operadores AND (&) y OR (|) de bits cuando los operandos son boolean
actúan como hemos comentado con sus homónimos condicionales, pero sin
el comportamiento de «cortocircuito». Es decir, independientemente del valor
de la expresión del primer operando, el segundo operando siempre se evaluará.
Así pues:

El operador XOR (u OR exclusiva) lo que hace es devolver 1 cuando dos bits

de la misma posición son distintos entre los dos operandos. En caso contrario
devuelve 0. De hecho, su equivalente con AND y OR lógicos sería: (A AND !B)
OR (!A AND B). Veamos el ejemplo de la tabla:
© FUOC • PID_00273929 53 Guía de Java

Este operador también se puede aplicar sobre operandos cuyo resultado sea un
boolean. En este caso, cuando los dos operandos coinciden en valor el resulta-
do es false y, en caso contrario, el resultado es true. Así pues: true^true es
false, false^false es false, true^false es true y false^true es true.

El operador complemento a 1 (~) lo que hace es convertir la representación int, short, long y byte
binaria del operando y cambiar los ceros por unos y los unos por cero. En el
Los tipos int, short, long y
ejemplo de la tabla 9 los pasos internos son: byte en Java son números en
complemento a 2.

Operadores de shiftado

Estos operadores manipulan bits desplazándolos hacia la derecha o hacia la

izquierda.

Tabla 10. Operadores de shiftado

Operador Descripción Ejemplo Resultado

<< Desplaza el operando de la izquierda hacia la izquier- 60 << 2

da tantas veces como indica el operando de la dere-
cha, y las posiciones shiftadas son rellenadas con ce-
ros.

>> Desplaza el operando de la izquierda hacia la dere- 60 >> 2

cha tantas veces como indica el operando de la dere-
cha. Preserva el bit de signo original (primer bit por
la izquierda) en las posiciones shiftadas. Así mantiene
el signo del valor original.

>>> Desplaza el operando de la izquierda hacia la dere- 60 >>> 2

cha tantas veces como indica el operando de la de-
recha, y las posiciones shiftadas son rellenadas con
ceros. A diferencia de >>, este operador no tiene en
cuenta el signo del valor original.

2.6. Bloques de flujo de ejecución

Como ya comentamos en el apartado «Estructura básica de un programa», los

bloques son una agrupación de instrucciones que son tratadas como una única
unidad. En Java podemos distinguir tres tipos de bloques que afectan al flujo
de ejecución del programa, es decir, determinan qué instrucciones se ejecutan
y cuáles no: bloque secuencial, bloque condicional y bloque iterativo.
© FUOC • PID_00273929 54 Guía de Java

2.6.1. Bloque secuencial

Un programa, de por sí, es una secuencia de instrucciones. Es decir, las ins-

trucciones se ejecutan en el orden en el que están escritas (siempre de arriba
hacia abajo). Este es el bloque más común.

2.6.2. Bloque condicional

Un bloque condicional es aquel que sirve para ejecutar o no una serie de ins-
trucción según una condición. Dentro de este tipo de bloque, también llama-
do de decisión o selección, existen varias alternativas.

1)�Bloque�if

Este bloque sirve para indicar un conjunto de instrucciones que se deben eje-
cutar si se cumple una expresión lógica, es decir, si dicha expresión es true.
A esta expresión lógica normalmente se le suele llamar condición.

Patrón del bloque Ejemplo

Aunque no es recomendable, si el código que hay dentro de un bloque if es

solo una instrucción, se puede obviar el uso de las llaves. El siguiente código
sería equivalente al anterior:

2)�Bloque�if-else

Este bloque sirve para indicar dos bloques de instrucciones que son excluyen-
tes entre sí. El primer bloque (bloque dentro del if) se ejecutará si se cumple
una expresión lógica, es decir, si dicha expresión es true. En caso contrario,
se ejecutará el segundo bloque (bloque dentro del else).
© FUOC • PID_00273929 55 Guía de Java

Patrón del bloque Ejemplo

3)�Bloque�if�anidado�o�else-if

Dentro de un if o un else se puede escribir/anidar otro bloque condicional,

pero también existe una opción más corta –llamada if anidado– para el caso
en que queramos anidar dentro del else.

Patrón del bloque Ejemplo

Si nos fijamos, este bloque no deja de ser un if-else en el que el else no

tiene la llave { sino un if. El último else no es necesario ponerlo si no se
requiere por la lógica del programa. Es decir, si no queremos hacer nada cuan-
do todas las condiciones son falsas, entonces no hace falta poner un bloque
else, ni tan siquiera vacío (es decir, sin instrucciones).

4)�Operador�ternario

Existe un operador condicional llamado ternario que compacta un if-else

más la devolución de un valor en una única instrucción.
© FUOC • PID_00273929 56 Guía de Java

Patrón del bloque Ejemplo

Este operador es muy utilizado para asignar valores a una variable en función
de una condición.

5)�Bloque�switch

Este bloque es una alternativa a la concatenación de bloques if anidados para

valores fijos (no rangos) de una expresión que hace de selector. Los valores del
selector pueden ser byte, short, int, char o String (es decir, texto/cadena
de caracteres; desde JDK 1.7).

Patrón del bloque Ejemplo

Los casos se evalúan de manera secuencial hasta que su valor coincide con el
del selector y entonces entra en su bloque. Así pues, según nuestro programa,
no será lo mismo poner el case 0 primero que ponerlo después del case 2,
por ejemplo. Una vez se entra en un caso, se irán ejecutando todos los bloques
hasta que uno de ellos contenga un break. Cuando se encuentra el break, el
programa sale del switch. Es decir, en el ejemplo anterior, si number hubiera
sido 1, entonces se ejecutaría el bloque del case 1, pero al no haber break, se
ejecutaría también el bloque del case 2, asignándole el valor 25 a la variable
age. Como el case 2 tiene un break, la ejecución sale del switch y pasa a la
instrucción age -= 5;. Así pues, el programa se comporta de manera idéntica
tanto si el valor de number es 1 como si es 2.
© FUOC • PID_00273929 57 Guía de Java

Asimismo, el caso default no es necesario ponerlo si no se requiere su uso,

cuyo código se ejecuta si ningún caso coincide con el valor del selector.

Desde JDK 13 en adelante se puede usar la palabra reservada yield para de-
volver un valor al terminar un caso y, por consiguiente, terminar el bloque
switch.

2.6.3. Bloque iterativo

Este tipo de bloque, también llamado bloque de bucle, sirve para ejecutar un
conjunto de instrucciones repetidamente hasta que deja de cumplirse una con-
dición. Existen varias alternativas.

1)�Bloque�while

Ejecuta el código que hay dentro de sus llaves mientras su condición sea true.
Cuando la condición sea false, entonces finaliza el bucle y se pasan a ejecu-
tar las instrucciones que hay después del bloque while. Cabe resaltar que la
condición se evalúa en cada iteración.

Patrón del bloque Ejemplo

© FUOC • PID_00273929 58 Guía de Java

2)�Bloque�do-while

Este bloque es similar al anterior pero la condición se evalúa por primera vez
cuando se han ejecutado las instrucciones que hay dentro del bloque. No obs-
tante, a cada iteración se evalúa la condición.

Patrón del bloque Ejemplo

En el ejemplo anterior, se ejecuta una vez el código que hay dentro del bloque
do-while, puesto que la condición no se ha evaluado hasta que se pasa por
la asignación number = 3;. Una vez hecha la asignación se comprueba si la
condición es true. En este caso se ve que es false y se termina el bloque
do-while.

A diferencia del bloque while, el código que se encuentra dentro de las llaves
del do-while siempre se ejecuta como mínimo una vez, mientras que en el
caso del while puede llegar a no ejecutarse nunca.

Finalmente, es importante percatarse de que después de la condición del do-

while debe escribirse un punto y coma (;).

3)�Bloque�for

Este bloque proporciona una manera compacta de iterar sobre un intervalo

de valores.

Patrón del bloque Ejemplo

Cuando se usa este bloque hay que tener en cuenta que:

© FUOC • PID_00273929 59 Guía de Java

• La expresión de inicialización se ejecuta solo la primera vez que se

ejecuta el bloque. Es posible declarar una variable dentro de la expresión
de inicialización. El alcance (scope) o visibilidad de esta variable está
limitada al bloque for donde ha sido declarada. Es decir, dicha variable
solo existe dentro del bloque for. Si la variable que usamos para controlar
el for no se necesita fuera del for, entonces la mejor práctica es declararla
en la expresión de inicialización del propio for y no fuera de este.
De esta manera se limita el tiempo de vida de dicha variable. Los nombres
típicos para estas variables que controlan el bloque for suelen ser i, j y k.

• El bloque (es decir, la iteración) termina cuando la condición es false.

• La expresión de incremento es invocada después de ejecutar el código que

hay dentro de las llaves. En realidad, esta expresión puede ser de incre-
mento o de decremento.

• Tanto en la expresión de inicialización como en la de incremento se pue-

den poner más de una instrucción separándolas con comas.

4)�Bloque�enhanced for

El bloque for anterior tiene otra sintaxis diseñada para iterar sobre colecciones
llamada enhanced for. Por colección nos estamos refiriendo tanto a un array
como a una estructura de datos como puede ser una pila, una cola, etc. que
la propia API de Java proporciona.

Patrón del bloque Ejemplo

En la variable value se almacena el valor actual del array numbers. Es decir,

de por sí, el enhanced for crea un índice interno inicializado a 0 y lo va
incrementando hasta llegar a la longitud (o tamaño) máxima de la colección.

El código anterior con un for simple sería:

© FUOC • PID_00273929 60 Guía de Java

En este tipo de bucles es interesante y útil utilizar la manera de declarar varia-

bles de JDK 10 (var) para que sea el propio compilador quien infiera el tipo
de los objetos de la colección. Por ejemplo:

2.6.4. Instrucciones de control de flujo

En este apartado veremos tres instrucciones que permiten cambiar el flujo de

ejecución de un programa.

1)�Instrucción�break

La instrucción break tiene dos modalidades: etiquetada y sin etiqueta. Esta

última la hemos visto cuando hablábamos del bloque switch. Sin embargo,
también podemos usarla para terminar un bloque iterativo (es decir, while,
do-while y for). Por ejemplo:

Por su parte, un break etiquetado permite finalizar aquel bloque iterativo que
tenga la etiqueta que se indica en el break.
© FUOC • PID_00273929 61 Guía de Java

En el ejemplo anterior, cuando la variable i vale 5 y la variable j vale 3, se

ejecuta el break etiquetado. Lo que hace es finalizar el bucle exterior que ha
sido etiquetado con el nombre etiqueta, lo cual hace que el valor 5 solo se
imprima tres veces y no se impriman los valores del 6 al 9 (es decir, termina
la ejecución de este código).

Si hubiéramos escrito un break sin etiqueta, entonces el bucle que inicializa

la variable j sería el que hubiera terminado, e imprimiría el valor de la i en ese
momento (es decir, 5) tres veces y continuaría con el bucle exterior para seguir
imprimiendo i igual a 6 diez veces hasta llegar a imprimir diez veces el valor 9.

2)�Instrucción�continue

La instrucción continue se utiliza para saltar la iteración actual de un bloque

iterativo (es decir, while, do-while o for). De manera homóloga a la ins-
trucción break, la instrucción continue también tiene su forma etiquetada
y no etiquetada. Un ejemplo de versión no-etiquetada sería:

Igual que con break, un continue etiquetado permite saltar la iteración de

un bucle externo.

En el ejemplo anterior, solo se imprimiría 5 tres veces, en vez de diez veces.

3)�Instrucción�return

La instrucción return se utiliza dentro de funciones/métodos y lo que hace

es salir de la función para seguir el flujo de ejecución a partir de la instrucción
que hay justo después de la llamada de la función/método. El return puede
devolver un valor o no. Si devuelve un valor, el tipo del valor devuelto debe
coincidir con el indicado en la firma de la función/método.
© FUOC • PID_00273929 62 Guía de Java

2.7. String

En este apartado vamos a ver un tipo de referencia muy utilizado en Java:

String. String es una clase que proporciona la API de Java y que nos sirve
para almacenar cadenas/secuencias de caracteres, es decir, textos. Dado que
la manipulación de textos es vital en cualquier programa, la clase String se
ha convertido en un tipo primitivo de facto (aunque no lo es; es una clase, es
decir, un tipo referencia). Cualquier cadena de caracteres está compuesta por
cero o más caracteres todos ellos acotados por comillas dobles ".

Excepcionalmente, en Java para instanciar un objeto de tipo String no es

necesario llamar a su constructor, solo es necesario asignarle una cadena de
caracteres (es decir, un texto). Veremos que también se puede llamar a su cons-
tructor con la palabra reservada new, pero esto lo comentaremos más adelan-
te, cuando veamos la diferencia entre las clases String, StringBuilder y
StringBuffer.

2.7.1. Escape sequences

(7)
Existen diferentes secuencias de escape7 que sirven para indicar alguna ins- En inglés, escape sequences.

trucción de formateo del texto. Por ejemplo:

• \n añade un salto de línea al final del texto poniendo el cursor en la si-

guiente línea.
• \t añade un tabulador allá donde aparece.

¿Qué ocurre si el texto tiene dentro unas comillas dobles o una contrabarra
(o barra invertida)? Pues que el compilador se confundirá porque no sabrá
qué comillas dobles son las del texto y cuáles las que limitan la cadena de
caracteres. Lo mismo con la barra invertida, no sabrá si se trata de un comando
o no. ¿Cómo solucionar este conflicto? Añadiendo una doble invertida delante
de las comillas o de la barra invertida que queremos que sea parte del texto.
© FUOC • PID_00273929 63 Guía de Java

2.7.2. Concatenar con +

Cuando vimos los operadores aritméticos dijimos que el operador + tenía un

comportamiento especial con los String. Concretamente comentamos que
sirve para concatenar una cadena de caracteres –es decir, String–, con otro
elemento (por ejemplo, otro String o un tipo primitivo).

En el caso de concatenar un String con cualquier otro tipo de valor, por

ejemplo, un int, este último se convierte en String y ambos String (es
decir, el original y el int convertido en String) se concatenan dando como
resultado un nuevo String.

2.7.3. Algunos métodos interesantes

La clase String proporciona muchos métodos, los cuales nos facilitan muchas
tareas.

Enlace recomendado

Podéis ver los métodos disponibles en la documentación oficial de la clase String

(https://docs.oracle.com/en/java/javase/13/docs/api/java.base/java/lang/String.html).

Tabla 11. Algunos métodos de la clase String

Firma del método Descripción Ejemplo

char charAt(int index) Devuelve el carácter que

se encuentra en la posi-
ción index

boolean contains(CharSequence c). Dice si una cadena de ca-

racteres está dentro del
String o no.
© FUOC • PID_00273929 64 Guía de Java

Firma del método Descripción Ejemplo

boolean equals(String another). Comprueba si un

String es igual a otro.

boolean equalsIgnoreCase(String Comprueba si un

another). String es igual a otro
ignorando mayúsculas y
minúsculas.

int indexOf(String substring). Devuelve el índice en

el que comienza el
substring dentro del
String. Si no está, de-
vuelve -1.

boolean isEmpty(). Comprueba si el String

es vacío ("").

int length(). Devuelve el número de

caracteres que tiene el
texto incluyendo espa-
cios.

String replace(char old, char Devuelve el String con

new). todas las apariciones del
carácter old reemplaza-
das por el carácter new.

String[] split(String regex). Separa el String origi-

nal en tantos String
que estén separados por
el String regex.

String substring(int beginIndex). Devuelve el subtexto que

hay dentro del texto a
partir del índice indicado.

String substring(int beginIndex, Devuelve el subtexto que

int endIndex). hay dentro del texto des-
de el índice inicial hasta
el índice final (no inclui-
do).
© FUOC • PID_00273929 65 Guía de Java

Firma del método Descripción Ejemplo

String toLowerCase(). Devuelve el String es-

crito todo en minúsculas.

String toUpperCase(). Devuelve el String es-

crito todo en mayúsculas.

String trim(). Elimina los espacios

iniciales y finales del
String.

2.7.4. Conversiones

A menudo necesitamos convertir un valor en formato texto (es decir, String)

en un tipo primitivo para hacer alguna operación. En otras ocasiones, tendre-
mos un valor en formato primitivo y necesitaremos tenerlo en formato texto.
Ambos casos son un tipo de conversión.

1)�De�tipo�primitivo�a�String

Una manera sencilla y rápida de convertir un valor primitivo en un texto es

concatenándole un texto (aunque sea vacío, por ejemplo, ""). Como:

(8)
Otra manera de hacerlo, quizás más explícita y clara a simple vista, es usando Más adelante veremos qué es un
8 método estático.
un método estático llamado valueOf que sirve para todos los primitivos.

Una última forma de convertir un tipo primitivo en un String es usando el (9)

Más adelante veremos qué es
9 una clase wrapper.
método estático toString de cada clase wrapper de los tipos primitivos.
© FUOC • PID_00273929 66 Guía de Java

2)�De�tipo�String�a�tipo�primitivo

Para obtener el valor de tipo primitivo de un texto podemos usar los métodos
estáticos parseXXX que incluyen las clases wrappers de los tipos primitivos
(excepto para char).

En el caso del tipo char, debemos usar el método charAt de la clase String
que hemos visto anteriormente.

2.8. Arrays

Ya hablamos muy superficialmente de los arrays cuando vimos el tipo referen-

cia. En este apartado queremos profundizar en ellos.

Un array es un tipo de dato estructurado que permite almacenar de

manera ordenada un conjunto fijo de elementos homogéneos (una co-
lección), es decir, que son del mismo tipo y están semánticamente rela-
cionados entre sí. El tipo de los elementos almacenados puede ser pri-
mitivo o referencia. Cada elemento dentro del array tiene asignado un
índice numérico (o posición) con el fin de encontrarlo unívocamente.
La primera posición o casilla del array es la número 0. Para acceder a
una casilla hay que usar el operador [].

Cuando el array tiene una única dimensión se le suele llamar array, vector o
arreglo. Cuando el array tiene dos dimensiones se le llama array de dos dimen-
siones, matriz o tabla. Cuando el número de dimensiones es mayor se le llama
array de N dimensiones (siendo N el número de dimensiones), array de arrays
o, simplemente, array multidimensional. También puede darse el caso de que
el número de columnas en un array multidimensional sea desigual, dándose
lo que en inglés se conoce como jagged array.
© FUOC • PID_00273929 67 Guía de Java

2.8.1. Declaración y creación en memoria

Un array será un objeto que estará alojado en el heap. Para poder acceder a
dicho objeto tendremos una variable de tipo referencia. El nombre de un array
suele ser un sustantivo en plural.

Con la declaración anterior no se crea ningún objeto en el heap. Las referencias

grades y ages apuntan a null, es decir, a ninguna dirección de memoria del
heap. Para crear el objeto de tipo array hay que usar la palabra reservada new:

Con el paso anterior, las referencias grades, ages y people apuntan a la

dirección del heap de sus respectivos objetos array. Sin embargo, cada casilla
de las tres arrays son inicializados con el valor por defecto. En el caso de los
tipos primitivos, int y short, el valor por defecto es 0, mientras que en el
caso de un tipo referencia como es un objeto de la clase Person, el valor por
defecto es null.

Por lo que respecta a la referencia people aún faltan por inicializar las dos filas:

La referencia people gráficamente sería:

Figura 20

En Java, los arrays permiten ser inicializados de una manera especial mediante
el uso de llaves ({}). Por ejemplo:
© FUOC • PID_00273929 68 Guía de Java

Con la línea anterior hemos creado un array de cinco casillas de tipo int,
donde el valor de la casilla 0 es 5, el de la casilla 1 es 3, el de la 2 es 6, el de
la 3 es 10 y el de la casilla 4 es 7. La línea anterior es equivalente al código
siguiente:

Para declarar e inicializar a la vez una matriz podríamos hacer:

Como hemos dicho varias veces, un array en Java es un objeto de una clase
interna de Java. Algunos ejemplos de clase interna que Java utiliza para ins-
tanciar el objeto para los arrays de tipo primitivo sería (el símbolo [ indica el
número de dimensiones):

Tabla 12

Tipo de array Clase interna que se le asigna

int[] [I

double[] [D

double[][] [[D

short[] [S

byte[] [B

boolean[] [Z

2.8.2. Tamaño de un array

Como hemos visto, para inicializar un array se debe indicar su tamaño (length)
para ubicarlo en memoria correctamente. Una vez creado en memoria, el ta-
maño no puede ser modificado, es decir, es fijo. Este es uno de los mayores
inconvenientes que tienen los arrays.

(10)
Como un array es un objeto de una clase interna de Java, este pone a dispo- Más adelante veremos qué es
un atributo final.
sición de los programadores atributos públicos, como, por ejemplo, length.
Este atributo de solo lectura (es final)10 permite saber la longitud del array.
© FUOC • PID_00273929 69 Guía de Java

El valor que puede tomar el índice que se le pasa a un array va de 0 hasta el ta-
maño de length-1. En caso de usar un valor incorrecto para acceder a un ele-
mento del array –por ejemplo, un entero negativo o uno mayor a length-1–,
Java lanzará una excepción de tipo ArrayIndexOutOfBoundException, es
decir, Java avisará de que se ha producido un error.

Veamos un ejemplo de matriz:

2.8.3. Copiar el contenido de un array a otro array

Existen diferentes maneras de copiar el contenido de un array. Todas ellas ha-

cen una copia superficial (shallow copy) del contenido. ¿Qué quiere decir esto?
Pues que se copia el contenido tal cual de los elementos del array original. Para
los tipos primitivos, esto no es un problema, pero para los de tipo referencia
sí, puesto que lo que se copia es la dirección de memoria de los objetos. ¿Qué
consecuencias tiene esto? Imaginemos un programa en el que participan dos
arrays de Person. En él, el objeto de tipo Person que hay en la casilla con ín-
dice 2 del array people1 tiene como valor del atributo name el texto "Elena".
A continuación, creamos el array people2 haciendo una copia de people1
con cualquiera de los métodos que explicaremos en este apartado. Si hacemos
lo siguiente:

En el ejemplo anterior no se ha hecho una copia profunda (deep copy) del

contenido. Es decir, al hacer la copia no se ha creado un objeto nuevo de tipo
Person para people2[2] con el mismo estado (es decir, mismos valores para
todos los atributos) que el objeto de people1[2], sino que directamente se
ha copiado la referencia, es decir, la dirección de memoria al objeto.

En este caso, si queremos hacer una copia profunda, deberemos sobrescribir el

método clone de la clase Person (ya lo veremos más adelante).
© FUOC • PID_00273929 70 Guía de Java

1)�Método�clone. Como un array en Java es un objeto de una clase interna

y, como veremos, toda clase en Java hereda implícitamente de la clase raíz
Object, entonces todo array proporciona el método clone que hereda de
Object, que a su vez lo sobrescribe.

2)�Método�arraycopy. La clase propia de Java llamada System proporciona

un método público llamado arraycopy que permite indicar el array de origen,
el elemento a partir del cual se hace la copia, el array de destino, el índice del
array de destino a partir del cual se copia y el número de elementos del array
de origen que queremos copiar.

3)�Método�copyOf. Java proporciona el método estático copyOf dentro de la

clase Arrays. Este utiliza internamente el método anterior, arraycopy. Este
método crea un array nuevo. Así pues, podríamos hacer:

4)�Método�copyOfRange. La misma clase Arrays tiene otro método que crea

un nuevo array a partir de uno de origen con los elementos ubicados dentro
de un rango o intervalo.

2.8.4. Ordenar un array

Para los tipos primitivos, la clase Arrays ofrece el método sort el cual ordena
los elementos del array en orden ascendente, es decir, de menor a mayor.
© FUOC • PID_00273929 71 Guía de Java

Si el tipo de elemento guardado en el array es de tipo referencia (es decir, un Comparator

objeto de una clase), entonces debemos usar una sobrecarga del método sort
Comparator es una interfaz
que tiene como segundo parámetro un objeto de la clase Comparator que que proporciona la API de Java
indica cómo se debe hacer la comparación entre elementos con el fin de or- que además es parametrizada.
Veremos estos conceptos más
denarlos correctamente. adelante.

2.9. Métodos (funciones)

Cuando un programa se hace complejo es muy útil dividir su código en peque-

ñas unidades lógicas, de manera que cada una de estas unidades sea capaz de
hacer una tarea muy concreta del programa. Cada una de esas unidades con-
tendrá parte del código del programa y las llamaremos métodos (en lenguajes
imperativos son llamadas con el nombre de funciones). Esta organización del
código de un programa en métodos facilita su legibilidad y mantenimiento.
Además, en muchas ocasiones hay trozos de código que deben ser llamados
varias veces, por lo que es mejor no repetir estos fragmentos de código, sino
ponerlos en métodos y llamar a dichos métodos cuando sea necesario.

2.9.1. Definición de un método

La sintaxis que define un método es:

Como podemos ver, el primer elemento a indicar es el modificador de acceso

(lo veremos más adelante). Este será public, protected, private o ninguno
(lo que significará package-private).

El segundo conjunto de modificadores será: final, abstract, static, una

combinación permitida de los tres (veremos su significado más adelante) o
ninguno de los tres.

El tercer elemento es el tipo del valor o elemento que devuelve el método.

Este puede ser un tipo primitivo (int, char, etc.), o un tipo referencia (por
ejemplo, un array, un objeto de una clase, etc.) o el tipo void (que significa
que no devuelve nada).
© FUOC • PID_00273929 72 Guía de Java

A continuación se escribe el nombre del método, el cual sigue el convenio de

ser un verbo o sintagma verbal escrito siguiendo el estilo lower camel case (es
decir, la primera palabra en minúscula y las siguientes palabras con la inicial
en mayúscula).

Después viene el listado de parámetros que recibe (puede ser vacío). Para cada
parámetro indicaremos su tipo y su nombre (en lower camel case).

Finalmente, dentro de las llaves {} se escribe el código del método. Para de-
volver un valor (ya sea de tipo primitivo o referencia) se debe usar la palabra
reservada return. Cuando un método encuentra un return, la ejecución del
método finaliza devolviendo el control al punto donde el método ha sido lla-
mado/invocado. En los métodos con tipo de devolución void podemos no
escribir return o escribirlo. Lo más habitual es no escribir return.

Algunos ejemplos de método son:

Estrictamente hablando, en Java solo el conjunto formado por el nombre del

método más los tipos de los parámetros en el orden en que aparecen es cono-
cido como firma�o�signatura�del�método. Así pues, las firmas de los métodos
anteriores son:

2.9.2. Sobrecarga de un método

El lenguaje Java soporta la sobrecarga (overloading) de métodos. Esto significa

que podemos tener dentro de una misma clase dos métodos llamados exacta-
mente igual siempre y cuando sus firmas no coincidan, es decir, se diferencien
en el número y/o en el tipo y/o en el orden de los parámetros.
© FUOC • PID_00273929 73 Guía de Java

Es muy habitual (seguro que alguna vez lo habéis hecho) encontrarse con có-
digo en el que se utilizan nombres diferentes para acciones similares sobre ti-
pos de parámetros diferentes. Por ejemplo:

La práctica anterior es muy engorrosa y nada recomendable. Por eso, lo más

recomendable y elegante en Java es hacer una sobrecarga. Así pues, el ejemplo
anterior con sobrecarga sería:

Gracias a la sobrecarga, en el ejemplo anterior, tenemos cuatro métodos lla-

mados igual –lo que facilita la legibilidad del programa– que reciben paráme-
tros diferentes y pueden incluso tener códigos diferentes. Además, es más fácil
acordarse del nombre add que de cuatro nombres distintos.

Es importante darse cuenta de que Java mira las firmas de los métodos, es decir,
no considera el tipo de retorno (porque en Java estrictamente no es parte de la
firma). Así pues, la siguiente sobrecarga sería incorrecta y el compilador daría
un error:

Para el compilador de Java los dos métodos anteriores son el mismo método
porque tienen la misma firma:

En cambio, la siguiente sobrecarga es correcta porque el orden de los paráme-

tros es diferente. Así pues, para Java son dos métodos distintos:

2.9.3. Usando un método

El proceso para usar un método es el siguiente:

© FUOC • PID_00273929 74 Guía de Java

1) Desde un punto del programa se hace una llamada o invocación al método.

Para ello se utiliza el nombre del método y la lista de valores que utilizarán
los parámetros definidos en la firma. A estos valores que se hacen en la llama-
da/invocación se les llama argumentos.

2) El método es llamado y recibe los argumentos en sus correspondientes pa-

rámetros. Así pues, el primer parámetro vale 8 y el segundo vale el resultado
de 3*2, es decir, 6.

3) El método ejecuta el código que hay en su cuerpo.

4) Devuelve un resultado o no (si es void). En este ejemplo, add devolverá

un valor.

5) El valor es devuelto al punto en donde se ha llamado al método. Es decir, es

como si en este momento se sustituyera el método por el valor devuelto por
este. En el ejemplo, la variable sum vale 14. A partir de ese punto, la ejecución
del programa continúa.

2.9.4. Paso por valor y por referencia

Cuando a un método se le pasa un argumento de tipo primitivo, entonces se

hace una copia de su valor y es esa copia la que se pasa realmente al método. Así
pues, el método que ha sido invocado utiliza el valor copiado, lo que implica
que no puede modificar el valor original. Este proceso es conocido como paso
por�valor.

En el ejemplo anterior el valor de la variable value, en este caso 8, se copia en

el parámetro number1 del método add. Cuando incrementamos una unidad
el valor de number1, no estamos modificando el valor de la variable value.
Así pues, cuando imprimamos por pantalla el valor de value en la tercera
línea del primer código, su valor seguirá siendo 8, mientras que el valor de sum
será 15 (es decir, 9 + 6). Si la variable value se hubiera llamado number1 –
es decir, igual que el primer parámetro del método add–, tampoco se hubiera
modificado el valor de la variable number1 del código desde el que se llama
al método add.
© FUOC • PID_00273929 75 Guía de Java

Así pues, con el paso por valor no podemos modificar, desde el método, el
valor del elemento (es decir, variable) que ha sido pasado como argumento
al método.

En cambio, cuando el argumento pasado a un método es de tipo referencia

(por ejemplo, un array o un objeto de una clase), entonces el paso se hace por
referencia. ¿Qué quiere decir esto? Pues que lo que se le pasa al parámetro del
método es la referencia al objeto, es decir, la dirección de memoria del heap de
ese objeto. Así pues, el parámetro del método es exactamente una referencia
idéntica al objeto que se le ha pasado como argumento, por lo que está real-
mente accediendo al mismo objeto, lo que significa que puede modificarlo.
Este proceso es conocido como paso�por�referencia.

2.9.5. Número variable de parámetros

Desde JDK 1.5 es posible definir un método que no tenga un número fijo de
parámetros. Es decir, unas veces recibe dos argumentos, otras veces tres, etc.
Hasta JDK 1.5 para simular esto lo que se hacía era pasar un array (fijaos que
en los parámetros no se indica el tamaño). Sin embargo, esto obliga a hacer
ciertas tareas adicionales y el código no expresa lo que realmente se quiere
indicar: la variabilidad de argumentos.

Así pues, JDK 1.5 introdujo la posibilidad de añadir argumentos variables (o

también conocido como varargs) gracias a la sintaxis: type... .

Para utilizar parámetros variables existe una restricción: solo el último pará-
metro puede ser definido como variable, es decir, con los tres puntos (...).

Los tres puntos indican que los argumentos correspondientes al último pará-
metro pueden ser pasados como un array o una secuencia de argumentos se-
parados por comas. Sea cual sea el formato, el compilador se encargará de em-
paquetar todos los varargs en un array. Así pues, el último parámetro lo ten-
dremos que tratar como un array para obtener los diferentes argumentos.
© FUOC • PID_00273929 76 Guía de Java

Con el ejemplo anterior vemos que:

• De las sobrecargas de un método, la versión varargs será la última en ser

llamada. Siempre se llama primero a la versión más específica/concreta
que a la más genérica (es decir, varargs).

• Desde JDK 1.5 el parámetro del método main se puede escribir String[]
args o String ... args.

• En el ejemplo anterior no podríamos definir una sobrecarga del método

print con la siguiente firma porque se confundiría con la versión varargs:

2.9.6. Cast implícito y explícito en los parámetros

Un método puede recibir como argumento un tipo primitivo numérico que

sea de rango inferior al declarado para el correspondiente parámetro. Es decir,
si el parámetro es declarado como float, entonces al hacer la llamada se le
puede pasar un argumento de tipo short, int o float.

Sin embargo, el caso contrario no es aceptado por el compilador porque hay

una pérdida de precisión. Si aun así queremos pasar un tipo numérico superior
como argumento a un parámetro de tipo numérico inferior, deberemos hacer
un cast explícito para que el compilador sepa que somos conscientes de la
pérdida de precisión que se va a producir.
© FUOC • PID_00273929 77 Guía de Java

2.10. Ámbito de las variables

Cuando declaramos las variables, estas existen o no –es decir, pueden ser usa-
das o no– en un punto de un programa dependiendo de dónde hayan sido
declaradas dichas variables. Esa parte, área o región del programa en la que la
variable puede ser utilizada recibe el nombre en inglés de scope (en español,
ámbito, alcance o, incluso, visibilidad de una variable).

El ámbito de una variable viene determinado por los bloques de instrucciones.

Recordemos que un bloque de instrucciones está definido por una llave inicial
{ y una final }. Así pues, una variable estará disponible/visible/accesible en
aquel bloque en el que se haya declarado. Es decir, el scope de la variable coin-
cidirá con el bloque en el que se haya declarado.

Una práctica muy común es crear en los bloques de iteración de tipo for
variables locales cuyo scope sea el cuerpo del propio bloque for. Veamos un
ejemplo:

Sin embargo, el siguiente código sí sería correcto:

© FUOC • PID_00273929 78 Guía de Java

Tened en cuenta que el scope de un bloque afecta al scope de los bloques que
tenga anidados. Así pues, si declaramos una variable en un bloque que tiene
anidado un segundo bloque, este segundo bloque no podrá declarar una va-
riable llamada exactamente igual, puesto que las variables del primer bloque
existen dentro del segundo bloque.

Intentad adivinar qué muestra por pantalla el siguiente código:

El código anterior imprimirá los valores de la casilla 0 a la 9 del array numbers

debido al bucle y posteriormente imprimirá el número 50. ¿Por qué? Pues
porque se declara una variable i dentro del for que solo existe dentro del for
y a posteriori, una vez se ha terminado el for y, por lo tanto, se ha destruido
la variable i del for, se declara en el bloque superior (es decir, en el scope del
método/función) una variable i que a partir de ese momento empieza a existir
(no antes).
© FUOC • PID_00273929 79 Guía de Java

3. Orientación a objetos en Java

Antes de seguir leyendo es importante que leáis y entendáis, más o me-

nos, los conceptos explicados en los módulos de teoría, como mínimo,
el titulado «Abstracción y encapsulación». En esta guía no vamos a ex-
plicar qué es una clase, ni un método, ni un modificador de acceso, etc.
Lo que vamos a hacer es ver cómo estos conceptos se ponen en práctica
mediante el lenguaje de programación Java. Obviamente, aparecerán
algunos conceptos teóricos que detallaremos para este lenguaje. El he-
cho de ver cómo los conceptos teóricos se ponen en práctica ayudará a
acabar de entender algunas dudas que podáis tener sobre ellos.

3.1. Definiendo una clase

En este apartado vamos a ver cuál es la sintaxis mínima para declarar una clase
así como los elementos esenciales que definen toda clase: los miembros de la
clase (es decir, atributos y métodos) y constructores.

3.1.1. Estructura mínima

Para definir una clase en Java debemos tener presente que su esqueleto mínimo
es el siguiente:

En Java, public o package-private son los dos únicos modificadores de

acceso que se pueden asignar a una clase principal. Por el momento, haremos
que todas las clases sean public.

Por su parte, los programadores Java deben respetar la siguiente convención

para nombrar las clases:

• El nombre es un sustantivo o un sintagma nominal en singular.

• Nombre escrito en camel case, es decir, todas las palabras que componen
el nombre con la primera inicial en mayúscula, por ejemplo: MemberVip,
Ball, Person, Player, BankAccount, etc.

Así pues, lo mínimo para definir la clase Person en Java sería:

© FUOC • PID_00273929 80 Guía de Java

3.1.2. Miembros de la clase

Como ya sabéis, las clases tienen miembros. Hay dos tipos de miembros de
la clase: los atributos y los métodos. Así pues, hay que definirlos. Lo más ha-
bitual es definir primero los atributos y después los métodos (y en medio, los
constructores). Es decir:

Atributos

Los atributos se definen igual que las variables (incluso respetan las conven- Nomenclatura para los
ciones usadas en las variables para los nombres), pero indicando además su atributos

modificador de acceso. De hecho, podéis pensar en ellos como variables glo- Además del término atributo
bales dentro de la clase. Es decir, todos los atributos de una clase, independien- (attribute), también se emplea
el término campo (field).
temente del modificador de acceso que se les asignen, son visibles en cualquier
parte de la clase en la que están definidos. La única diferencia con las variables
es, como hemos dicho, que a los atributos hay que asignarles un modificador
de acceso y a las variables no. Veamos algunos ejemplos:

Si nos fijamos, antes de la declaración del atributo le indicamos el modificador

de acceso que queremos que se aplique (observad las palabras en rojo). Lo más
habitual es declarar los atributos como private. Si sabemos que la clase va a
participar en una relación de herencia, entonces también puede ser una buena
opción protected (dependerá de nuestro diseño).

¿Qué ocurre si no se indica un modificador de acceso? Entonces se entiende Modificadores de acceso

que el atributo tiene un modificador de acceso default o también llamado
Más adelante prestaremos es-
package-private (un modificador de acceso especial de Java). pecial atención a los diferen-
tes modificadores de acceso
que proporciona Java. Por aho-
Observemos la declaración del atributo age de la clase Person en el ejemplo ra, solo considerad public y
private.
anterior. ¿Veis alguna diferencia con el resto de atributos? Efectivamente, se le
ha asignado un valor, concretamente, cero. Esta inicialización se podría haber
hecho en uno de los constructores de Person (lo veremos más adelante), pero,
© FUOC • PID_00273929 81 Guía de Java

al ser tan simple, la hemos hecho en la propia declaración. Si la inicialización

del atributo age hubiera necesitado alguna lógica (por ejemplo, usar un bucle),
entonces no podríamos haberla hecho en la declaración. La inicialización en
la declaración solo es posible si es simple.

Igualmente, si un atributo no es inicializado en ninguna parte de la

clase (es decir, declaración, constructor, bloque de inicialización, etc.),
entonces el compilador le asignará el valor por defecto del tipo que se
le ha asignado, por ejemplo, 0 para atributos de tipo numérico, false
para boolean y null para tipos referencia.

Finalmente, cabe indicar que los atributos de una clase, a diferencia de las
variables, se crean dentro del objeto. Por consiguiente, a nivel de ubicación en
memoria, los atributos están en el heap (como los objetos), no en el stack.

Métodos

Todo lo que comentamos en el apartado «Métodos (funciones)» sirve ahora

que estamos usando Java orientado a objetos. No obstante, vamos a explicar
algunas cuestiones adicionales que aparecen al usar clases.

La primera de ellas es que el modificador static ya no lo vamos a usar si no es

estrictamente necesario. Hasta ahora usábamos este modificador porque em-
pleábamos Java en un paradigma de programación estructurada y, sin static,
no podíamos llamar a los métodos desde el main.

En segundo lugar, vamos a ver una situación que solo puede darse cuando
usamos atributos dentro de los métodos. Mirad el método setter siguiente:

El método setAge anterior lo primero que hace es comprobar si el parámetro

ageNew es negativo. Si lo es, entonces escribe un mensaje de error por pantalla
y asigna el valor 0 al atributo age. En caso contrario, asigna al atributo age
© FUOC • PID_00273929 82 Guía de Java

el valor del parámetro ageNew. Sin embargo, lo ideal hubiera sido llamar al
parámetro igual que al atributo, para saber que están relacionados. Es decir, el
código «ideal» hubiera sido:

Entonces, ¿cómo sabe el compilador (y nosotros) en cada sentencia escrita en

rojo si age es el atributo o el parámetro? El caso más evidente de confusión
es la asignación del else: age = age. ¿El age del lado izquierdo de la
asignación es el atributo o el parámetro? ¿Y el age de la derecha? Así pues, para
evitar problemas, muchos programadores le ponen al parámetro del método
el mismo nombre del atributo de la clase más una coletilla. De ahí que la
declaración inicial del método setAge fuera:

Es obvio que con esta solución de añadir una coletilla (en el ejemplo, "New")
no hay ninguna duda para el compilador ni para nosotros de qué es que. A
pesar de que podemos usar una solución como la anterior, lo más habitual y
mejor (como hemos comentado) es utilizar como nombres de los parámetros
de los métodos los mismos nombres que los de los atributos de la clase, en
este caso, age. Para resolver el conflicto de nombres, Java nos proporciona una
palabra reservada llamada this. Así pues, dada una versión simplificada del
método setAge como la siguiente:

Su equivalente con this sería:

El this hace de coletilla e indica que aquello que lleva this pertenece al ob-
jeto/clase y no es ni un parámetro ni una variable declarados dentro del méto-
do. Concretamente this hace referencia al objeto (o instancia) que es del tipo
© FUOC • PID_00273929 83 Guía de Java

de la clase. Por lo tanto, gracias a this, estamos diciendo que al atributo age
del objeto (o si os resulta más fácil de entender, de la clase) hay que asignarle
el valor del parámetro age (llamado ageNew en la versión anterior del código).

3.1.3. Constructor

En Java podemos definir tantos constructores como deseemos. Incluso pode-

mos no declarar ningún constructor. En este último caso, el compilador de
Java lo detectará y creará uno por defecto de manera transparente a nosotros
que no hará nada, solo permitir que se puedan instanciar objetos de esa clase.

Así pues, con el código anterior de la clase Person ya tenemos un constructor

por defecto. No estará creado por nosotros, sino que lo hará el compilador. Es
decir, el código anterior es equivalente a haber escrito lo siguiente:

Como os habréis dado cuenta, el constructor, a diferencia de los métodos,

no define un tipo de retorno, ni siquiera void. Gracias a esta diferencia, el
compilador puede saber que se trata de un constructor y no de un método.
Además, obligatoriamente, el nombre del constructor debe coincidir con el
nombre de la clase.

Constructor por defecto

Vamos a ver cómo podríamos rellenar un constructor por defecto.

(11)
El constructor por defecto anterior es correcto. Incluso, no haría falta por qué Recordad lo que comentamos
en el apartado «Protección de los
inicializar todos los atributos (fijaos que hemos eliminado la inicialización en
datos» del módulo «Abstracción y
la declaración de age... no tiene sentido duplicar). Ahora bien, es interesante encapsulación».
© FUOC • PID_00273929 84 Guía de Java

y una buena práctica utilizar los métodos setter y getter dentro de la propia
clase con tal de conseguir la máxima consistencia, estabilidad y robustez de
los atributos.11 Así pues, una mejor codificación del constructor anterior sería:

El hecho de usar los setters nos ayuda a crear un punto común de comproba-
ciones y asignaciones. Como recordaréis, dentro del método setAge se com-
prueba que la edad pasada como argumento no sea inferior a 0. Si lo es, im-
primimos un mensaje de error y asignamos el valor 0 al atributo age. En caso
contrario, asignamos el valor que nos facilitan.

Constructor con argumentos

Como hemos dicho, nuestras clases pueden tener tantos constructores como
necesitemos. Para ello, lo que tendremos que hacer es sobrecargar el construc-
tor. Veamos dos ejemplos de constructor con argumentos (o constructor pa-
rametrizado).
© FUOC • PID_00273929 85 Guía de Java

Si nos fijamos, el primer constructor con argumentos solo tiene tres paráme-
tros, mientras que el segundo tiene cinco (tantos como atributos tiene la cla-
se). ¿Os imagináis qué hubiera pasado si no llamáramos a los métodos setters
en los tres constructores? Pues que en los tres repetiríamos el mismo código
de comprobación que ahora tenemos centralizado en el método setAge. Una
vez más, se ve la importancia de llamar a los getters y setters también desde
dentro de la propia clase. Aun así, podéis ver que los tres constructores tienen
un código común: llamar a los setters de los atributos. ¿Por qué repetir líneas
de código idénticas? Java también se dio cuenta de que esto era muy común,
por lo que creó un par de maneras de reducir la repetición de código en los
constructores.

Método especial this

Java pone a disposición de los programadores un método especial llamado

this. Este método tiene la misma firma que cualquiera de los constructores
que hemos declarado. Este se utiliza en los constructores para llamar a otros
constructores. Tiene la restricción de que, si se quiere utilizar, la llamada al
método this debe ser la primera instrucción que escribamos en el constructor
donde lo utilizaremos. Veamos el código anterior simplificado gracias al uso
del método especial this.

Si nos fijamos, el cambio se ha producido en los dos primeros constructores

(observad las dos instrucciones en rojo). Lo que hemos hecho es llamar al
último constructor (el más genérico) desde los otros dos constructores. Podéis
ver que la firma del método this coincide con la del último constructor con
argumentos.
© FUOC • PID_00273929 86 Guía de Java

Bloque de inicialización de instancia

Para los casos en los que la inicialización de los atributos para los objetos (ins-
tancias) creados en una clase tienen valores conocidos a priori, entonces Java
proporciona lo que se conoce como bloque de inicialización (initializer block).

Imaginad, por ejemplo, que la edad inicial siempre sea 36 para todos los ob-
jetos creados para la clase Person. Entonces podríamos hacer:

Cuando se llame a cualquiera de los tres constructores anteriores, lo primero

que se ejecutará será el bloque de inicialización. Es decir, primero se llamará
al método setAge con el argumento 36 y a continuación el resto de código
del constructor llamado. Podéis observar que el código ha cambiado un poco,
allí donde se han introducido cambios está resaltado en rojo.

Así pues, debe quedar claro que el bloque de inicialización de instancia

de una clase se ejecuta antes que los constructores de dicha clase.

Una clase puede tener tantos bloques de inicialización de instancia como se

requieran. En este caso, el orden de ejecución será top-down, es decir, aquel
que aparezca primero en el código será el primero en ejecutarse, y así sucesi-
vamente.
© FUOC • PID_00273929 87 Guía de Java

En resumen:

• Cada bloque de inicialización de instancia se ejecuta cada vez que se ins-

tancia un objeto nuevo y se ejecuta para ese objeto en creación.

• Si hay más de un bloque de inicialización de instancia, entonces el orden

de ejecución empieza por el que primero aparece en el código de arriba
abajo.

• Si la clase en la que hay un bloque de inicialización hereda de otra clase, Herencia y clase padre
entonces primero se llama a los bloques de inicialización de instancia de la
El concepto de herencia y clase
clase padre, luego al constructor de la clase padre, después los bloques de padre lo veremos más adelante
inicialización de la clase para la que estamos creando el objeto y finalmen- tanto en los apuntes teóricos
como en esta guía.
te, el código del constructor que hemos usado para instanciar el objeto.

• Si un atributo se ha inicializado en la declaración del propio atributo, en-

tonces esta inicialización se hace antes de la llamada al bloque de inicia-
lización de instancia.

3.2. Objetos

3.2.1. Instanciar (creando objetos)

Como ya sabéis, un objeto es un ejemplar de una clase. Así pues, a la hora de

crear un objeto, debemos seguir los siguientes pasos:

1) Declarar una variable o atributo de tipo de la clase (en términos generales

es un tipo referencia):

En este momento la variable/atributo david no apunta a ningún objeto, su

referencia/valor es null.

2) Instanciar el objeto. Es decir, crear un objeto a partir de una clase.

Como habéis visto en el apartado «Tipos» y en el código justo anterior, para

instanciar/crear un objeto nuevo (es decir, un tipo referencia) debemos escri-
bir la palabra reservada new seguida de una llamada a uno de los constructores
© FUOC • PID_00273929 88 Guía de Java

definidos en la clase. En este caso hemos utilizado el constructor por defecto,

pero también podríamos haber usado cualquiera de los dos constructores pa-
rametrizados. Por ejemplo:

En este momento ya tenemos un objeto de tipo Person ubicado en memoria

(heap) y con una variable/atributo de tipo referencia apuntando a este objeto.

Los pasos 1 y 2 se pueden agrupar en un único paso:

Como al segundo paso se le llama instanciar, ahora entenderéis por qué a los
objetos también se les llama instancias.

3.2.2. Usando un objeto (mensajes)

Una vez hemos creado un objeto y este está referenciado por una variable/atri-
buto, lo más lógico es hacer algo con él, normalmente acceder a un atributo
o a un método. Para ello usaremos mensajes. La forma de un mensaje es:

donde referencia puede ser una variable o un atributo, y miembro puede

ser tanto un atributo como un método de la clase a la que pertenece el objeto.

3.3. Modificadores de acceso

Habréis visto que en los ejemplos anteriores los atributos, métodos y construc-
tores tenían la palabra public o private al inicio de su declaración. Como
bien sabéis, tanto public como private son dos modificadores de acceso,
cuya funcionalidad es determinar la accesibilidad/visibilidad de un elemento.
Cuando hablamos del uso de modificadores de acceso, nos estamos refiriendo
a que, si tenemos un objeto de una clase A dentro de otra clase B, según cómo
estén declarados los miembros de la clase A, se podrá acceder a estos directa-
mente mediante un mensaje o no desde B usando el objeto de la clase A.
© FUOC • PID_00273929 89 Guía de Java

Todos los miembros de una clase, independientemente de su modifica-

dor de acceso, son accesibles directamente desde dentro de la propia
clase.

En Java existen 4 modificadores de acceso: public, protected, private y

package-private. Cada uno de estos cuatro modificadores permite que un
elemento sea más o menos accesible desde fuera de la propia clase, siendo
public y private los extremos.

Dependiendo del elemento, a este se le podrá asignar unos modificadores de

acceso u otros. Principalmente los expuestos en la tabla 13.

Tabla 13. Modificadores de acceso aplicables a los diferentes elementos de un programa

Tipo de nivel Tipos de elemento Modificadores de

acceso permitido

Alto�nivel�(o�elemento Clases, interfaces y enumeraciones public

contenedor) (enum) package-private

Miembros Atributos, métodos, constructores, cla- public

ses anidadas y enumeraciones (enum) protected
private
package-private

Modificador package-private

Para asignar este modificador, no hay que escribir ningún modificador al declarar el ele-
mento. Es decir, cuando no se escribe ni public, ni protected ni private, Java en-
tiende que el modificador que se le quiere asignar al elemento es package-private. Así
pues, nunca hay que escribir la palabra compuesta package-private. Por este motivo,
a este modificador también se le conoce como no modifier o default.

Como podemos ver, al declarar, por ejemplo, una clase, solo podemos asignar-
le, o bien el modificador public, o bien el modificador package-private.
Sin embargo, si declaramos una clase dentro de otra clase, es decir, declaramos
una clase anidada (nested class), entonces dicha clase se comporta como un
miembro de la clase contenedora y, por consiguiente, podemos asignarle cual-
quiera de los cuatro modificadores de acceso que proporciona Java.

Llegados a este punto, cabe saber las diferencias entre los cuatro modificadores.
Es decir, qué implicaciones tienen cada uno de ellos. Vamos a comentarlos
suponiendo que dentro de una clase B tenemos un objeto de la clase A con un
miembro al que queremos acceder:
© FUOC • PID_00273929 90 Guía de Java

1)�public: indica que se puede acceder al elemento desde cualquier parte del
programa. Así pues, si dentro de la clase B queremos acceder a un miembro
público de un objeto de la clase A, lo podremos hacer desde B de la manera
siguiente:

2)� private: indica que solo se puede acceder al miembro desde dentro de
la propia clase que lo declara. Así pues, si intentamos acceder a un miembro
privado de la clase A usando un objeto de la clase A perteneciente a la clase B,
entonces obtendremos un error de compilación:

Acabamos de ver los dos modificadores extremos. Es decir, public es el mo-

dificador más permisivo y private el más restrictivo. Nos faltan dos modifi-
cadores de acceso que son muy similares entre sí y que solo difieren en el caso
de que exista una relación de herencia entre las clases implicadas (es decir,
superclase-subclase).

3)�package-private: indica que solo se puede acceder al miembro declara-

do como package-private (o default) desde elementos (por ejemplo, una
clase) que estén dentro del mismo package que el elemento en el que está el
miembro package-private. Dicho de otro modo, lo que nos está diciendo
el modificador package-private es que los elementos declarados como tales
(es decir, sin modificador) son accesibles/visibles directamente para todos los
elementos declarados dentro del mismo package. Así pues, solo si la clase B y
la clase A pertenecen al mismo package, entonces la siguiente sentencia en la
clase B será correcta:

4)�protected: este modificador de acceso además de permitir lo mismo que

el modificador package-private, también permite que los miembros decla-
rados como protected sean visibles/accesibles desde cualquier subclase de
la clase en la que se ha declarado el miembro protected. Eso sí, desde una
subclase ubicada en un package distinto al de su superclase, el miembro decla-
rado como package-private en la superclase solo es accesible a través de
una referencia/objeto que sea como mínimo del mismo tipo que la subclase.
Así pues, protected es un poco menos restrictivo que package-private.
© FUOC • PID_00273929 91 Guía de Java

Tabla 14. Resumen

Modificador Desde el propio con- Desde el mis- Subclase en otro package El resto de
tenedor (p. ej., cla- mo package elementos
se, interfaz o enum)

public Sí Sí Sí Sí

protected Sí Sí Sí (solo usando un objeto de la No

propia subclase o subclase de
esta)

package-private (sin Sí Sí No No
modificador)

private Sí No No No

Como ya hemos comentado y como se puede observar en la columna

«Desde el propio contenedor» de la tabla 14, cualquier miembro (atri-
buto o método) es accesible desde dentro del elemento que lo declara
sin necesidad, obviamente, de instanciar ningún objeto.

Por ejemplo, un atributo declarado en la clase A, independientemente del modificador

Package y subclase
de acceso asignado, siempre es accesible desde cualquier punto de la clase A (por ejem-
plo, cualquier método declarado en la clase A). Así pues, cualquier elemento contenedor
siempre tiene acceso a todos sus miembros. Esto es algo que debe quedar muy claro. Por ahora no tenemos que
preocuparnos por los concep-
tos package y subclase (así co-
En cambio, tal y como indica la tabla 14, una clase B creada dentro del package P1 no
mo superclase y herencia). El
podrá acceder mediante un objeto de la clase A a un miembro private declarado en la primero lo veremos en esta
clase A del mismo package P1. Sin embargo, si el mismo elemento hubiera sido declarado guía y el segundo lo explicare-
como public, protected o package-private, entonces la clase B sí que podría haber mos tanto en los apuntes teóri-
accedido a él y utilizarlo. cos como en esta guía.

Si seguimos analizando la tabla 14, vemos que aquellos miembros declarados

public o protected pueden ser accedidos desde cualquiera de sus subclases,
estén en el mismo package o no. Aquí hay que hacer una apreciación impor-
tante para el caso protected. Cuando la superclase (por ejemplo, A) y la sub-
clase (por ejemplo, B) pertenecen a distintos packages, entonces no podemos
acceder a un miembro protected de la superclase dentro de la subclase con
un objeto de la superclase: objectA.protectedMember;. En cambio, sí po-
dremos acceder usando un objeto de la propia subclase B o de otras subclases
de B. De ahí que hayamos dicho en la columna «Subclase en otro package» de
la tabla 14 que un miembro protected es accesible desde una subclase de la
clase que lo declara a través de una referencia que sea, al menos, del mismo
tipo que la subclase. Esto es así para asegurar que a los miembros de instancia
protected solo se accede por parte de la jerarquía de clases al que pertenecen
(subclase y sus subclases), excluyendo clases hermanas (otras clases que here-
dan de la misma superclase que declara el miembro protected).
© FUOC • PID_00273929 92 Guía de Java

Finalmente, un elemento declarado como public es visible para cualquier

otro elemento del programa. Es decir, si tenemos un método declarado como
public en una clase A, podremos acceder a este desde un objeto A declarado
en otra clase B, independientemente de si A y B están en el mismo package o
no, y de si entre A y B existe una relación de herencia (superclase-subclase).

Veamos algunos ejemplos para afianzar estos conceptos. Usaremos la clase A

siguiente:

Imaginemos que tenemos la siguiente clase B con un objeto de la clase A an-

terior:

Imaginemos que ahora tenemos la siguiente clase C con un objeto de la clase

A anterior:

Ahora imaginemos que la clase D es una subclase (concepto que veremos más
adelante) de la clase A y tiene un objeto de la clase A. Ambas clases pertenecen
al mismo package.
© FUOC • PID_00273929 93 Guía de Java

Finalmente, veamos una clase E que es subclase de A, pero ambas clases per-
tenecen a packages diferentes.

Veamos una variante de la clase E anterior:

© FUOC • PID_00273929 94 Guía de Java

3.4. Destructor de una clase

En Java no existe un destructor como tal. Sin embargo, proporciona un método

llamado finalize que desempeña el rol de destructor. Este método finalize
lo tienen todas las clases, puesto que, como comentaremos más adelante, todas
las clases en Java heredan implícitamente de la clase raíz Object. Así pues,
finalize es un método de la clase Object que cualquier clase hereda, quiera
o no.

El método finalize que proporciona la clase Object no hace nada, por lo

que puede ser sobrescrito (veremos qué significa esto). Básicamente debemos
quedarnos con la idea de que si queremos que el método finalize haga al-
go, debemos escribirlo explícitamente y añadir un código en su cuerpo. Si no
tenemos que hacer nada especial, entonces no es obligatorio sobrescribirlo (es
decir, añadir código). Lo más habitual es no escribir el método finalize.

La manera de explicitar (sobrescribir) el método finalize sería añadir el si-

guiente código en nuestra clase, como si fuera un método más (normalmente
se pone el último para encontrarlo fácilmente):

Algunos motivos por los que podemos utilizar el método finalize son: li-
berar recursos compartidos, cerrar conexiones (por ejemplo, bases de datos,
sockets, etc.), etc. Sin embargo, tened en cuenta que este método es llamado
automáticamente dentro del proceso conocido como garbage collection cuando
la JVM lo estima oportuno. Es decir, cuándo el método finalize es realmente
llamado es algo incierto. Así pues, no debemos depender de este método para
hacer algunas gestiones críticas. Lo que sí debemos tener presente es que el
método finalize no se llamará hasta que un objeto no tenga ninguna varia-
ble/atributo de tipo referencia apuntándole.

Si un objeto no es apuntado por ninguna referencia, entonces se llamará

a su método finalize, ¿cuándo? Es una incógnita.

La JVM tiene un garbage collector que periódicamente libera la memoria usada

por objetos que nunca más están referenciados. El garbage collector hace este
trabajo de manera automática cuando cree que es el momento adecuado.
© FUOC • PID_00273929 95 Guía de Java

Después de la última instrucción del código anterior (p2 = null;), tanto p1

como p2 no apuntan a ningún objeto. El objeto Person creado en la primera
instrucción no está referenciada/apuntada por nadie, así que se llamará auto-
máticamente (como programadores no tenemos que hacer nada) a su método
finalize y se liberará el espacio que ocupa en memoria (heap). ¿Cuándo se
hará esta llamada? Cuando el garbage collector lo crea oportuno.

Como podéis ver, la gestión de la memoria en Java es mucho más sencilla que
en otros lenguajes como puede ser C++, esto también implica menos libertad
a la hora de «jugar» con la memoria del ordenador y poder optimizar procesos.

3.5. Packages

3.5.1. ¿Qué es un package y cuál es su utilidad?

En Java existe un tipo de contenedor abstracto llamado package que permite

organizar elementos de alto nivel (es decir, clases, interfaces y enumeraciones)
que están relacionados entre sí. La manera más sencilla de entender qué es un
package sería haciendo una analogía con un sistema de directorios. Por ejem-
plo, imaginemos que tenemos un proyecto con la estructura de directorios que
muestra la figura 21.

Figura 21

project
database
images
hd
user.png
sd
user.png
views

Si nos fijamos, tanto en las subcarpetas hd como sd, tenemos dos imágenes
llamadas exactamente igual: user.png. ¿Cómo podemos distinguirlas unívo-
camente? A través de su ruta (path): project/images/hd/user.png es dife-
rente a project/images/sd/user.png.
© FUOC • PID_00273929 96 Guía de Java

Pues bien, los packages en Java hacen exactamente esto: organizar nues-
tro código para que sea más fácil encontrar lo que queremos de manera
unívoca y, además, añadir información lógica a nuestro software.

Así pues, lo primero que debemos saber es que en un programa podemos tener
muchas clases escritas y algunas de ellas pueden incluso llamarse igual.

Por ejemplo, la API (Application Programming Interface) de Java (https://

docs.oracle.com/en/java/javase/13/docs/api/allpackages-index.html), la cual
no deja de ser una librería con centenares de clases ya creadas que nos propor-
ciona el propio lenguaje para programar nuestro propio software de manera
más sencilla, está organizada en packages.

En la API de Java hay elementos llamados exactamente igual pero que perte-
necen a packages distintos. Por ejemplo, List existe tanto en java.util co-
mo en java.awt. En este caso concreto, además, se da la circunstancia de que
List es una interfaz en java.util, mientras que en java.awt es una clase,
¡son dos cosas diferentes que se llaman igual! Además, el package java.awt
incluye un conjunto de clases para crear interfaces de usuario, mientras que
java.util contiene un conjunto de elementos relacionados con colecciones
(es decir, estructuras de datos): listas, colas, pilas, tablas de hash, etc.

Para decirle al compilador de Java qué List usar en nuestro programa, debe-
mos indicarlo haciendo un import. Por ejemplo:

Así pues, un package sirve para:

• Empaquetar/agrupar elementos (clases, interfaces y enumeraciones) que

están relacionados.

• Crear namespaces y evitar conflictos cuando dos o más elementos se lla-

man exactamente igual. Al estar los elementos homónimos en packages
diferentes, estos son identificados unívocamente. Por lo tanto, el nom-
© FUOC • PID_00273929 97 Guía de Java

bre completo del elemento está compuesto por el nombre package + el

nombre del elemento en sí. Esto es lo que se conoce como fully qualified
name, el cual permite desambiguar el elemento al que nos referimos. Así
pues, los fully qualified names de los List anteriores son: java.awt.List
y java.util.List.

• Permitir acceso especial entre los elementos que pertenecen a un mismo

package, gracias al modificador de acceso package-private.

3.5.2. Creando un package

Crear un package en un IDE como Eclipse es tan sencillo como hacer botón
derecho con el ratón en el directorio src y escoger la opción New -> Package.
Todos los elementos (clases, interfaces y enumeraciones) que pertenecen a un
package deben tener como primera�línea�de�código la sentencia siguiente:

Donde packageName es el nombre del paquete al que pertenece el elemento

en donde estamos escribiendo dicha sentencia.

Así pues, imaginemos que tenemos dos clases que queremos que pertenezcan
al package mypackage. El código sería:

Con el código anterior estamos diciendo que las clases A y B pertenecen al

package mypackage. En un IDE como Eclipse si añadimos como primera línea
del código de un elemento la sentencia package, el IDE nos dará un error si
el elemento no está dentro del package que acabamos de indicar. El IDE nos
sugerirá como solución crear el package e incluir dentro el elemento. También
podemos crear manualmente un package (New --> Package) y añadir (por
ejemplo, arrastrando) los elementos que pertenecen a dicho package. En este
último caso, el IDE modificará el nombre del package dentro del código de cada
uno de los elementos para que todo sea correcto.

Todos aquellos elementos a los que no escribimos la sentencia package, es

decir, no indicamos explícitamente a qué package pertenecen, son tratados por
Java como elementos pertenecientes a un mismo package llamado default
o unnamed. El uso de un default package es muy común cuando se empieza a
programar en Java o se hacen aplicaciones temporales o muy pequeñas. Sin
embargo, no se recomienda no crear packages para organizar un programa. De
© FUOC • PID_00273929 98 Guía de Java

hecho, un IDE como Eclipse nos crea un package default cuando creamos
un proyecto Java nuevo con la finalidad de tener organizado nuestro código
desde el primer momento.

Si miramos la estructura de directorios de nuestro programa, por ejemplo, en

el workspace de nuestro IDE, veremos que dentro de la carpeta «src» se ha crea-
do una estructura de subcarpetas basada en los packages declarados. Así pues,
los packages a nivel de organización no dejan de ser directorios con los que or-
ganizar nuestro código. De hecho, esta es la forma de crear packages manual-
mente: crear la estructura de directorios, poner los elementos en el directorio
que les corresponda y escribir en cada elemento la línea de código package
packageName. Como podemos ver, un IDE nos ahorra mucho tiempo.

Llegados a este punto, seguramente os estaréis preguntando: ¿Existe alguna

convención para nombrar packages? La respuesta es sí. Hay que respetar lo
máximo posible la convención que explicaremos a continuación para evitar
crear dos packages llamados exactamente igual porque, de lo contrario, no po-
dremos identificar unívocamente dos elementos con el mismo nombre perte-
necientes a packages distintos.

A la hora de nombrar un package debemos tener siempre presente que:

1) El nombre package se escribe, todo él, en minúsculas.

2) Si el programa se está desarrollando dentro de una compañía o para ella,

entonces usamos el nombre invertido del dominio de internet de esa compa-
ñía para crear un prefijo (es decir, una raíz común) a partir del cual colgarán
el resto de packages.

Por ejemplo, si estamos desarrollando un programa en/para la UOC, cuyo dominio en

internet es uoc.edu, entonces todos los packages que vayamos creando irán dentro de
edu.uoc:

3) Si dentro de una compañía (o mismo programa) existe un conflicto entre

dos o más packages, entonces se debe solucionar utilizando convenios internos
de la compañía.

Por ejemplo, imaginemos que los programadores de las sedes de Barcelona y Madrid de
la UOC han creado el package assessment. Esto significaría que ambos equipos tendrían
edu.uoc.assessment pero con contenido (es decir, clases, interfaces, enumeraciones,
etc.) totalmente distintos (podría haber, por ejemplo, una clase llamada igual pero cuya
funcionalidad fuera diferente). Esta situación generaría conflictos si ambos packages se
quieren usar/integrar en un mismo programa. Por lo tanto, hay que buscar alguna ma-
nera de desambiguar. Cómo se desambigua lo decide en estos casos la propia compañía.
Una posibilidad, en este caso, sería añadir la sede: edu.uoc.barcelona.assessment
y edu.uoc.madrid.assessment. Con este pequeño cambio ahora sí que no hay ambi-
güedad posible.
© FUOC • PID_00273929 99 Guía de Java

4) Existen algunos nombres de dominio de internet que no son adecuados

para crear packages o, cuando menos, crean nombres conflictivos que hay que
solventar. Por ejemplo:

Dominio Nombre de prefijo de Nombre de prefijo

de internet package incorrecto de package correcto

eimt.int

uoc.8edu

uoc-eimt.edu

5) Se recomienda no usar ni las palabras java ni javax como primera palabra

del nombre de un package, ya que la API de Java utiliza ambos nombres en la
declaración de sus packages.

3.5.3. Usando los elementos incluidos dentro de un package

(12)
Vamos a ver cómo usar un elemento (clase, interfaz o enumeración) incluido En inglés, package members.
dentro de un package. A los elementos incluidos en un package se les llama
miembros del paquete.12 Hay tres formas de indicar que queremos usar un ele-
mento de un paquete.

1)� Importar� solo� el� elemento� a� usar. Esta manera ya la hemos visto en el
apartado «Modificadores de acceso». Recordemos que consiste en hacer un
import del elemento dentro del código del elemento donde lo queremos usar.

2)�Importar�el�package�entero. Una manera similar a la anterior es importar

todos los elementos incluidos dentro del package (es decir, los package mem-
bers), no solo el elemento que queremos.
© FUOC • PID_00273929 100 Guía de Java

El código anterior hubiera sido «equivalente» a este otro:

Hemos dicho que el código anterior es «equivalente» porque lógicamente no

es exactamente igual a poner simplemente import java.awt.*.

Cuando ponemos import java.awt.Frame e import java.List solo es-

tamos importando los elementos Frame y List del package java.awt, mien-
tras que con java.awt.* estamos importando todos los elementos (clases,
interfaces y enumeraciones) del package java.awt. Así pues, con java.awt.*
también estaríamos importando, por ejemplo, la clase Label –que sirve pa-
ra crear etiquetas (trozos de texto) en una interfaz gráfica–, así como otras
clases e interfaces (por ejemplo, ItemSelectable, Shape, etc.) del package
java.awt.

¿Cuál de las dos formas es mejor? Sin duda, la primera, import

java.awt.Frame e import java.List. Es decir, siempre es mejor importar
aquello que realmente usamos. El primer motivo es que de esta manera queda
claro, para nosotros y otros programadores, qué utilizamos y qué no de un
package. Además, importando todo puede darse alguna situación no deseada
de manera accidental como, por ejemplo, cuando dos packages tienen elemen-
tos que se llaman igual. Imaginemos que tenemos dos packages –package1 y
package2–, donde en el primero (package1) hay dos clases A y B, mientras
que en el package2 tenemos B, C y D. Del package1 usamos la clase A, mien-
tras que del package2 usamos la clase B. Si hacemos:
© FUOC • PID_00273929 101 Guía de Java

¿A qué clase B estamos haciendo referencia, a la del package1 o a la del pac-

kage2? El compilador nos avisará con un mensaje. Por el contrario, si escribi-
mos el código que se muestra a continuación, no hay duda de a qué clase B
nos estamos refiriendo:

Usando el fully qualified name del elemento

Otra manera de indicar qué elemento queremos utilizar es usando el nombre

completo del elemento. Es decir, incluyendo el nombre del paquete más el del
elemento sin necesidad de importar nada.

Aunque el código anterior es correcto, no suele ser habitual ni práctico escribir

todo el tiempo el fully qualified name de los elementos. Es mucho más cómodo
importar el elemento, como en los apartados anteriores. Sin embargo, esta
forma de identificar unívocamente un elemento puede ser útil en casos como
el siguiente:

¿De qué clase B es el fieldB1? ¿Del package1 o del package2? ¿Y el

fieldB2? La manera de solucionar esta ambigüedad es usando el fully quali-
fied name.
© FUOC • PID_00273929 102 Guía de Java

Usando el fully qualified name como en el código anterior, la ambigüedad des-

aparece para el compilador y no nos dirá nada.

3.5.4. Packages importados automáticamente por Java

El compilador de Java importa automáticamente y de manera implícita den-

tro de cualquier elemento el propio package al que pertenece y el package
java.lang. Es decir, no es necesario hacer un import ni del propio package
ni de java.lang.

1)�Importación�implícita�del�propio�package. Cuando usamos una clase A

del package mypackage dentro de una clase B del mismo package, no es nece-
sario importar el package, puesto que ambas clases están en el mismo package
y «se ven» la una a la otra.

2)�Importación�implícita�del�package�java.lang. El compilador de Java in-

cluye automáticamente este package. De hecho, ya hemos visto algunas clases
que están dentro de este package y hasta ahora no habíamos hecho ningún
import. Por ejemplo, la clase String es una de las clases que están incluidas
en java.lang. De igual manera, la clase System con la que mostramos texto
por la consola de comandos también está dentro de este package.

3.6. Modificador static

Como ya habéis leído en los apuntes teóricos, existe la keyword static que
puede ser aplicada a un atributo, método o clase anidada.

3.6.1. Atributo estático

Si aplicamos el modificador static a un atributo, este es compartido por to- (13)

En inglés, static fields.
dos los objetos pertenecientes a una misma clase. Así pues, deja de ser un atri-
buto de la instancia para ser un atributo de la clase. Es por ello por lo que
los atributos con el modificador static son llamados atributos estáticos13 o
© FUOC • PID_00273929 103 Guía de Java

atributos de la clase. Los atributos estáticos ocupan un solo espacio de memoria

para todos los objetos, es decir, no hay memoria reservada para ese atributo
por cada objeto que se instancia.

Cualquier objeto puede acceder y modificar el valor del atributo estático, pero
este atributo también puede ser accedido desde objetos de otras clases, si su
modificador de acceso lo permite, sin necesidad de crear un objeto de la clase
a la que pertenece el atributo estático. Así pues, si tenemos:

Desde otra clase podemos hacer:

Se recomienda acceder a los atributos estáticos a través de la clase, no de un

objeto para facilitar la legibilidad del código.

3.6.2. Bloque de inicialización estático

Para los casos en los que queremos inicializar atributos estáticos, estos pueden Ved también
ser inicializados en la declaración del propio atributo o en un bloque de ini-
El bloque de inicialización se
cialización estático (similar al bloque de inicialización). trató en el apartado «Cons-
tructor» de la presente guía.

Imaginad que tenemos un atributo id que sirve para asignar un identificador

a cada objeto Person creado y que este id debe ser único. Podríamos tener
el código siguiente:
© FUOC • PID_00273929 104 Guía de Java

Es importante entender que el bloque de inicialización estático, a diferencia

del de instancia, solo se ejecuta una vez por programa. ¿Cuándo se hace esa
única llamada? Pues, o bien cuando se crea por primera vez un objeto de la
clase, o bien cuando se accede por primera vez a un miembro (es decir, atributo
o método) estático de la clase. En ambos casos, el bloque de inicialización
estático se llama antes que el constructor o antes de acceder al miembro.

3.6.3. Método estático

Java permite usar la keyword static con métodos. Igual que los atributos,
los métodos estáticos pertenecen a la clase, no a la instancia. Así pues, estos
pueden ser llamados mediante un objeto o mediante el nombre de la clase
(esta forma es la recomendada).

Desde otra clase podemos hacer:

© FUOC • PID_00273929 105 Guía de Java

¿Os habéis fijado que el método especial main es estático? Este se llama ha-
ciendo java NombreClase sin instanciar ningún objeto de la clase.

Es importante saber que existe una limitación al usar este tipo de métodos.

Desde un método estático no podemos acceder a atributos ni métodos

de instancia directamente (necesitamos instanciar un objeto).

Asimismo, un método estático no puede usar la keyword this porque no hay

un objeto al que referirse.

3.6.4. Clase estática

En Java no podemos declarar una clase de nivel superior con el modificador Ved también
static. Solo las clases anidadas pueden ser static.
Para saber más sobre las clases
anidadas (y las static), re-
3.7. Modificador abstract comendamos leer el apartado
«Clases anidadas» de esta guía.

En Java podemos usar la keyword abstract tanto para clases como para mé-
todos, pero no para atributos.

3.7.1. Clase abstracta

En Java, cuando una clase es declarada como abstracta significa que dicha clase
no puede ser instanciada. Es decir, no podemos crear objetos de esa clase.
© FUOC • PID_00273929 106 Guía de Java

3.7.2. Método abstracto

Cuando un método es declarado abstracto estamos diciendo que su codifica-

ción la delegamos en subclases que hereden la clase en la que se ubica el mé-
todo abstracto. Asimismo, cuando�declaramos�un�método�abstracto,�obli-
gatoriamente�su�clase�también�debe�ser�declarada�abstracta.

En el ejemplo anterior, el método run es abstracto. Por consiguiente, no tiene Subclase

código (ni siquiera hemos escrito las llaves que limitan el cuerpo del método).
El concepto subclase lo vere-
Será en una subclase (o subclase de la subclase) donde le proporcionaremos mos tanto en los apuntes teóri-
un código. cos como más adelante en esta
guía.

3.8. Modificador final

En Java existe la keyword final que puede ser aplicada tanto a una clase, un
método como a un atributo.

3.8.1. Clase final

De los apuntes teóricos sabemos que una clase final es aquella de la que no
se puede heredar.

La keyword final puede escribirse antes o después del modificador de acceso.

El siguiente código es equivalente al anterior.

Así pues, hacer lo siguiente provocaría un error en tiempo de compilación.

© FUOC • PID_00273929 107 Guía de Java

3.8.2. Método final

Como ya sabemos de los apuntes teóricos, un método declarado como final

implica que no puede ser sobrescrito en una subclase. Si lo intentamos, obten-
dremos un error de compilación.

Dada la declaración anterior, sería incorrecto hacer lo siguiente:

3.8.3. Atributo final

Por los apuntes teóricos sabemos que un atributo declarado como final ac-
túa como constante. Por lo tanto, solo le podemos asignar un valor una vez
en todo el programa. Así pues, una vez asignando un valor, ya no podemos
modificarlo.

Si intentamos hacer lo siguiente, obtendremos un error de compilación.

Es muy habitual combinar los modificadores static y final para crear cons-
tantes:
© FUOC • PID_00273929 108 Guía de Java

3.9. Herencia

3.9.1. Concepto y sintaxis

La herencia es un mecanismo esencial en la programación orientada a objetos.

Esta consiste en permitir que una clase –llamada subclase– se defina a partir de
la codificación de otra ya existente –llamada superclase–. Parece algo simple,
pero es muy potente. Por ello, es necesario dominarlo, ya que, entre cosas,
facilita la reutilización de código.

En Java solo existe la herencia simple: una clase solo puede heredar directa-
mente de otra clase. Es decir, la clase C no puede heredar directamente de A y
B, a la vez. Sin embargo, existe la transitividad. O sea, si una clase B hereda de
una clase A, y una clase C hereda de B, entonces la clase C hereda de B y hereda
también todo aquello que haya heredado B de A.

Figura 22

La sintaxis para indicar que una clase hereda de otra es la siguiente:

Con el código anterior estaríamos diciendo que la clase B hereda de la clase A.

O, dicho de otro modo, la clase B es una subclase de la clase A y, a su vez, la
clase A es una superclase de la clase B.
© FUOC • PID_00273929 109 Guía de Java

3.9.2. La clase Object

En este punto cabe decir que en Java todas las clases así como los arrays here- Enlace recomendado
dan implícitamente de una superclase llamada Object definida por el propio
En el enlace siguiente po-
lenguaje Java. Es decir, queramos o no, todas las clases y arrays heredan de déis ver cómo se define
Object. la clase Object: https://
docs.oracle.com/en/java/ja-
vase/13/docs/api/java.base/
java/lang/Object.html.
Esta clase define un conjunto de métodos, entre los que destacan: clone,
equals y toString.
Constructores y herencia
3.9.3. ¿Qué hereda una subclase?
Los constructores no son con-
siderados miembros de una
Es clave saber qué hereda la clase B de la clase A. La respuesta es: todos los clase, porque, entre otras co-
sas, no se heredan.
miembros. ¿Todos los miembros? Sí, otra cuestión es si la clase B tiene acceso a
todos los miembros heredados de A como si estos se hubieran declarado en la
propia clase B. Sobre esto último, la respuesta es que una subclase solo tiene
acceso directo a los miembros declarados como public o protected en la
superclase. En el caso de los miembros package-private solo tiene acceso
directo si la superclase y la subclase pertenecen al mismo package.

Hay mucha documentación (incluida la documentación oficial) que mezcla

«lo que hereda la subclase» con «lo que se puede acceder desde la subclase» y,
por ello, es muy habitual leer que en Java no se heredan los miembros privados.
Por este motivo en esta guía pensamos que es más sencillo de entender cómo
funciona la herencia en Java si decimos que se hereda todo de la superclase,
pero que la subclase no puede acceder directamente a los miembros private
de la clase A ni a los miembros package-private si superclase y subclase
pertenecen a packages distintos.

Veamos y analicemos un ejemplo práctico para entender cómo afecta el me-

canismo de herencia a una subclase.
© FUOC • PID_00273929 110 Guía de Java
© FUOC • PID_00273929 111 Guía de Java

El código anterior requiere un análisis en profundidad:

1) La clase Animal es la que menos explicaciones requiere. Hemos asignado

un modificador diferente a los atributos para ejemplificar el comportamiento
de los mismos durante la herencia. Cabe destacar el uso del método especial
this en el primer y segundo constructor para llamar al tercer constructor y,
de esta manera, minimizar el código a escribir.

2) La clase Dog hereda de la clase Animal. Es decir, Dog es una subclase de

Animal y, por consiguiente, Animal es una superclase de la clase Dog.

3) Las subclases no heredan los constructores definidos en su superclase, pues-

to que, como ya sabemos, los constructores (y los destructores) no son consi-
derados miembros de una clase.

4) En el constructor de la clase Dog cabe destacar el uso del método especial

super, el cual se utiliza en la subclase para llamar a uno de los constructores
de la superclase. La firma del método super debe coincidir con alguna de las
definidas en la superclase. Si no se explicita una llamada al método super,
© FUOC • PID_00273929 112 Guía de Java

entonces el compilador llama automáticamente a super(), es decir, llama

al constructor por defecto de la superclase. La llamada al constructor de la
superclase debe ser la primera instrucción del constructor de una subclase.

5) Desde dentro de la subclase Dog, además de tener acceso directo a los mé-
todos setOwner, getOwner, setBreed, getBreed, speak y toString, tam-
bién se tiene acceso directo a los métodos de la superclase Animal declarados
como public o protected. Es decir: getName, setName, setAge, getAge y
speak. Fijaos que no tiene acceso directo a los métodos getNumberOfLegs y
setNumberOfLegs, ya que han sido declarados private en la clase Animal.
Así pues, en el código de la clase Dog no podemos llamar directamente a los
métodos getNumberOfLegs y setNumberOfLegs. En cambio, dentro de la
clase Dog, podremos acceder directamente al atributo vegetarian si Animal
y Dog están en el mismo package.

6) En las subclases podemos cambiar el comportamiento de los métodos defi-

nidos en la superclase. A este proceso de redefinición se le llama sobrescritura
(overriding). Esto es justo lo que hace la clase Dog con el método speak. Si nos
fijamos, hemos vuelto a codificar el método speak en la clase Dog con exac-
tamente la misma firma (si la cambiamos entonces estamos sobrecargando).
De esta forma, le asignamos un comportamiento distinto al de la superclase
Animal. Si no lo hubiéramos sobrescrito, entonces estaría presente en la clase
Dog pero con el comportamiento definido en la superclase Animal.

7) Para avisar al compilador (y a nosotros mismos) que hemos sobrescrito un

método de la superclase, es una buena práctica usar la anotación @Override
justo antes de la firma del método. No es obligatorio su uso, pero sí muy reco-
mendable, ya que el compilador hará comprobaciones extras para avisarnos
de si hemos cometido algún error a la hora de hacer la sobrescritura.

8) En la versión sobrescrita del método speak, es decir, el método speak de la

clase Dog, vemos que llamamos al método speak de la superclase. Para hacer
esto, que no es obligatorio hacer, debemos usar el objeto especial super. De
esta forma, el compilador sabe que estamos llamado al método speak de la
superclase y no al de la propia clase. Así pues, el método speak de un objeto
de tipo Dog además de escribir "My name is " y el nombre del perro, también
escribirá "Woof!!".

9) Démonos cuenta de que el método speak en la subclase Dog tiene un mo-

dificador de acceso menos restrictivo que en la superclase Animal. Ha pasa-
do de protected a public. Esto es correcto, ya que en la subclase podemos
asignarle a un método un modificador menos restrictivo que el que tiene en
la superclase. Al revés no es correcto. Es decir, a un método sobrescrito no le
podemos asignar un modificador de acceso más restrictivo en la subclase que
en la superclase. De esta manera, si en Dog hubiéramos declarado speak como
private, el compilador nos lanzaría un error.
© FUOC • PID_00273929 113 Guía de Java

10) El último método que encontramos es toString. Como vemos, este mé-
todo está sobrescrito, ¿pero de qué superclase lo ha heredado Dog si en Ani-
mal no está? Pues bien, como hemos dicho previamente, todas las clases en
Java heredan implícitamente de la superclase Object definida por el propio
lenguaje Java. Esta clase Object tiene definidos, entre otros métodos, el mé-
todo toString (que ya habíamos visto anteriormente en esta guía). El méto-
do toString se utiliza para dar información sobre el objeto. Su código por
defecto, es decir, lo que codifica la clase Object, es devolver un String con
una representación interna del objeto e información de la referencia del obje-
to (es decir, la posición de memoria que ocupa en el heap).

11) Si miramos el nuevo código que le hemos asignado al método toString

en la clase Dog, vemos que no llamamos al método getNumberOfLegs, ya que
este es private en la superclase Animal y, por tanto, desde la subclase Dog
no tenemos acceso a él. Sin embargo, como el atributo numberOfLegs está
definido como protected en la superclase Animal, sí que podemos acceder
directamente a él dentro de la subclase Dog.

12) Un código alternativo para el método toString con el mínimo número

de llamadas a métodos sería:

Vemos que no podemos acceder al atributo name directamente desde Dog por-
que este atributo fue declarado private en la superclase. Así pues, la única
manera de acceder a él es indirectamente usando un método declarado en la
superclase como public o protected (o package-private si Animal y Dog
están en el mismo package) que nos dé acceso a dicho atributo. En este caso
accedemos a name mediante getName, que es public.

13) Llegados a este punto debemos preguntarnos qué ocurre en la subclase

Dog con el atributo vegetarian de su superclase Animal. Este ha sido decla-
rado sin modificador de acceso, es decir, como package-private. Pues bien,
si la clase Animal y su subclase Dog pertenecen al mismo package, entonces
desde dentro de la clase Dog se puede acceder al atributo vegetarian como
si hubiera sido declarado dentro de Dog. En caso contrario, se comporta como
si fuera private, es decir, no se podría acceder a vegetarian directamente
desde dentro del código de Dog.

Ahora veamos otro código Java que utiliza las clases Animal y Dog:
© FUOC • PID_00273929 114 Guía de Java

3.9.4. El modificador abstract y la herencia

Como ya vimos, en Java existe el modificador abstract, el cual puede ser

aplicado tanto a clases como a métodos. Lo único que afecta en el caso de
la herencia es que en la subclase debemos codificar todos aquellos métodos
declarados como abstract en la superclase. Si no se codifican, entonces es-
tos deben ser abstract en la subclase para que una subclase de la subclase
los codifique. Además, la subclase también tendrá que ser una clase declarada
como abstract.

Una duda que suele surgir con las clases abstractas es si tiene sentido declarar-
les un constructor si una clase abstracta, por definición, no puede ser instan-
ciada. Pues bien, una vez visto cómo se relaciona una subclase con su super-
clase y que en el constructor de la subclase se debe llamar a algún constructor
de la superclase, la respuesta está clara: sí, tiene sentido declarar un construc-
tor en una clase abstracta si esta será superclase de alguna clase. El construc-
© FUOC • PID_00273929 115 Guía de Java

tor de la superclase abstract no tiene por qué ser public, pero puede ser
protected para que así tengan acceso directo los constructores de la subclase
mediante el método especial super.

3.9.5. El modificador static y la herencia

Con este modificador hay que diferenciar tres situaciones:

1)�Método�no�estático�en�la�superclase: si en la subclase sobrescribimos un

método no static de la superclase y, además, lo definimos static en la
subclase, entonces el compilador nos dará un error.

2)�Método�estático�en�la�superclase: si en la subclase lo sobrescribimos pero

sin declararlo static, entonces el compilador nos dará un error.

3)�Método�estático�en�la�superclase: si en la subclase lo sobrescribimos man-

teniendo su cualidad de static, entonces el método de la superclase queda
oculto. De hecho, lo correcto es decir que un método estático en la supercla-
se no puede ser sobrescrito en una subclase, sino que puede ser ocultado. Así
pues, en la subclase en verdad están los dos métodos static y se llamará uno
u otro en función de si dicho método es invocado usando la superclase o la
subclase.

Lo explicado hasta ahora para los métodos también ocurre con los atributos
estáticos. Es decir, en la subclase podemos declarar un atributo llamado exac-
tamente igual que uno de la superclase. En tal caso, lo que hacemos es ocultar
dicho atributo y podremos llamar a uno u a otro en función de si lo llamamos
usando la superclase o la subclase.

3.9.6. El modificador final y la herencia

Como ya vimos, este modificador tiene una afectación directa con la herencia.
Recordemos que si una clase es final entonces no puede ser heredada, por lo
tanto, no podremos definir subclases a partir de la clase final.

En cuanto a los métodos declarados como final, no podrán ser sobrescritos

en las subclases. Es decir, el comportamiento definido en la superclase no po-
drá ser modificado en ninguna de sus subclases.

3.9.7. Ocultación de atributos

En una subclase podemos declarar un atributo con el mismo nombre que un

atributo declarado en la superclase, aunque sus tipos sean distintos. Si desde la
subclase se puede acceder directamente al atributo de la superclase, al declarar
© FUOC • PID_00273929 116 Guía de Java

un atributo en la subclase con el mismo nombre lo que estaríamos haciendo

es ocultar el atributo heredado de la superclase. Así pues, si queremos acceder
al atributo de la superclase tendremos que usar el objeto super.

No se recomienda ocultar atributos de una superclase en sus subclases.

3.10. Interfaces

3.10.1. Concepto y sintaxis

Como ya sabemos, las interfaces son contratos que indican qué métodos de-
ben ser codificados en las clases que las implementan. Las interfaces no pro-
porcionan el código de los métodos, solo sus firmas.

Para definir una interfaz en Java debemos utilizar la siguiente sintaxis:

Como podemos ver, hemos asignado el modificador de acceso public a la

interfaz Movable. Esto quiere decir que cualquier clase o interfaz de cualquier
package de nuestro programa puede usar la interfaz Movable. En caso de no
escribir el modificador de acceso public, entonces la visibilidad de la interfaz
es package-private y solo las clases e interfaces que pertenecen al mismo
package que la interfaz Movable pueden usarla. Otros modificadores no son
posibles a alto nivel. Sin embargo, si la interfaz está anidada dentro de otra
clase, entonces sí puede ser, por ejemplo, private.

En una interfaz no es necesario indicar el modificador de acceso de los méto-

dos. Si no se escribe explícitamente, se entiende que es public. De hecho, los
métodos en una interfaz Java son siempre public y, por defecto, abstract
(veremos que los métodos también pueden ser static o default). Pero no
es necesario escribir ninguno de los dos modificadores porque se sobrentiende
que si no se indica nada, se están declarando como public y abstract.
© FUOC • PID_00273929 117 Guía de Java

3.10.2. Uso de una interfaz

Cualquier clase puede implementar una interfaz mediante la palabra reservada

(keyword) implements. Una clase puede implementar múltiples interfaces a la
vez. Para cada una de ellas, tendrá que proporcionar el código de los métodos
definidos en cada una de las interfaces que implementa. En caso contrario, el
compilador dará un error.

Una interfaz no puede implementar otra interfaz, puesto que no podría pro-
porcionarle su código, pero sí puede heredar una o más interfaces.

3.10.3. ¿Qué elementos puede contener una interfaz?

Esta es una pregunta muy habitual. También cabe decir que la respuesta de-
pende de la versión de Java de la que estemos hablando, puesto que el con-
cepto de interfaz en Java ha ido evolucionando con el paso de los años. Eso sí,
lo que se introdujo en una versión se ha mantenido en las siguientes.

Desde Java SE 7, las interfaces solo permitían constantes (atributos que implí-
citamente son declarados public static final) y métodos abstractos.

(14)
A partir de Java 8, las interfaces fueron capaces de incluir también métodos En inglés, default methods.
14
estáticos y métodos por defecto. La inclusión de estos dos tipos de métodos
nos permite escribir código dentro de un método.
© FUOC • PID_00273929 118 Guía de Java

En el código anterior hemos añadido un método static llamado isFast y

hemos convertido el método up en un método default al que le hemos pro-
porcionado una codificación (el hecho de convertirlo en default nos obliga
a codificarlo). Así pues, cualquier clase que implemente la interfaz Movable
ya tendrá una codificación por defecto (de base) para el método up y no será
necesario, si no quiere, que sobrescriba dicho método. El método isFast, que
es static, no puede ser sobrescrito en las clases que implementen la interfaz
Movable.

En Java 9 se introdujo la posibilidad de definir métodos privados y métodos

static privados. Con ellos se facilita la reutilización de código dentro de las
interfaces y su encapsulación. Así pues, los métodos private son útiles si, por
ejemplo, dos métodos default comparten un trozo de código. Gracias a los
métodos privados podríamos compartir código entre métodos sin exponerlo
fuera de la interfaz. Los métodos privados deben cumplir las siguientes reglas:

• Los métodos privados de una interfaz no pueden ser abstractos. O, dicho

de otro modo, los métodos privados de una interfaz deben tener código
en su cuerpo.

• Los métodos privados de una interfaz solo pueden usarse dentro de la in-
terfaz en la que han sido definidos.

• Los métodos privados de una interfaz pueden llamar a métodos default

y a métodos static (sean public o private).

• Los métodos privados static de una interfaz pueden usarse tanto en mé-
todos estáticos como no estáticos de la interfaz.

• Los métodos privados de una interfaz que no sean static no pueden

usarse dentro de métodos privados static.
© FUOC • PID_00273929 119 Guía de Java

En el código anterior usamos un método privado llamado log para hacer un

seguimiento de las llamadas que se hacen a los métodos de la interfaz. Si qui-
siéramos llamar al método log desde isFast, entonces log debería haberse
declarado static (ya sea public o private).

Resumiendo:

Elemento Desde cuándo se puede usar

Atributos�public static final Java 7

Métodos�public abstract Java 7

Métodos�public default Java 8

Métodos�public static Java 8

Métodos�private Java 9

Métodos�private static Java 9

3.11. Polimorfismo

Como comentamos en el módulo teórico «Herencia (relación entre clases)», el

polimorfismo es uno de los pilares del paradigma de la programación orienta-
da a objetos. Por este motivo, es muy importante dominarlo.
© FUOC • PID_00273929 120 Guía de Java

Ya sabemos que el polimorfismo es la capacidad de que un objeto de-

clarado como tipo superclase pueda comportarse como un objeto de
cualquiera de sus subclases.

Veamos esto con código (suponed que todas las clases pertenecen al mismo
package):

Si ahora tuviéramos el siguiente código en otra clase, ¿cómo se comportaría

el programa?

• La línea 1 sería correcta. El tipo estático de la variable animalDog es Ani-

mal, que es superclase del tipo dinámico que se le asigna: objeto de la sub-
clase Dog.

• La línea 2 imprimirá por pantalla el texto propio de la clase Dog, porque

animalDog se comporta como un Dog, al ser su tipo dinámico Dog. Así
pues, imprimirá "Woof!!".
© FUOC • PID_00273929 121 Guía de Java

• En la línea 3 se hace un casting de animalDog a Dog. Ahora la variable

dog1 tiene el objeto Dog que hay en animalDog. Tanto animalDog como
dog1 apuntan a la misma referencia, al mismo objeto.

• La línea 4 imprime "Woof!!", puesto que tanto el tipo estático como di-
námico de la variable dog1 es Dog.

• Tras ejecutar la línea 5, tanto dog1, como dog2 y animalDog apuntan al

mismo objeto, son la misma referencia.

• La línea 6 es errónea. Sin embargo, el error aparece en tiempo de ejecución,

no de compilación. El error se debe a que no podemos hacer un casting
de un objeto Dog a un objeto Cat, o lo que es lo mismo, no podemos
asignarle un objeto Dog a una referencia de tipo Cat.

• La línea 7 es errónea, pero a diferencia de la línea anterior, el error se pro-

duce en tiempo de compilación. Así pues, debemos eliminarla para poder
ejecutar el programa. ¿Por qué es errónea la línea 7? Porque el tipo estático
de animalDog es Animal y no puede ser asignado a una variable Cat.

• La línea 8 es el caso contrario a la línea anterior. Por lo tanto, es correcta,

puesto que Animal es superclase de Cat. Justo esto es el ejemplo más sen-
cillo de polimorfismo.

• La última línea, la 9, imprimiría por pantalla "Meow!!", ya que el tipo

dinámico de la variable animalDog es Cat.

Una de las utilidades del polimorfismo es simplificar el código. Esto se ve claro

en el ejemplo siguiente:

El código anterior ejecutaría en la primera iteración del enhanced for el méto-

do greeting de Dog, puesto que la primera casilla del array animals es un
objeto Dog. Es decir, la casilla 0 de animals tiene como tipo estático Animal,
pero su tipo dinámico es Dog. En la segunda iteración, por la misma razón, se
ejecutaría el método greeting de Cat. De esta manera, en vez de tener dos
arrays (o dos variables), una de tipo Dog y otro Cat, con una única variable
(animals) podemos realizar todas las operaciones según sea su tipo dinámico
en cada caso. Es decir, animals adopta muchas formas (polimorfismo) dentro
del mismo programa.
© FUOC • PID_00273929 122 Guía de Java

El polimorfismo también es interesante cuando usamos interfaces, esto se ve

muy claramente en Java cuando utilizamos, por ejemplo, interfaces que mo-
delan colecciones. Este es el caso de la interfaz List de la API de Java.

Fijémonos en el getter getPeople. Independientemente de cómo inicialice-

mos el atributo lista, como objeto de la clase ArrayList o de la clase Lin-
kedList, el método getPeople será el mismo en ambos casos, ya que devol-
vemos List<Person>, generalizando/abstrayendo el método. Evidentemen-
te los siguientes dos códigos serían correctos:

Sin embargo, los dos códigos anteriores tendrían un peor mantenimiento a

la larga, puesto que al cambiar la inicialización/instanciación, deberíamos
cambiar la firma del método getPeople para adaptarlo a la nueva clase y,
del mismo modo, todo el código donde no generalicemos con el uso de
List<Person>.

Finalmente, el polimorfismo también nos permite relacionar elementos que

no están relacionados por una jerarquía de herencia, sino por una jerarquía de
interfaces (es decir, de capacidades). Dicho de otro modo, gracias al polimor-
fismo podremos relacionar elementos que a priori no están relacionados. Por
ejemplo, si las clases Car y Fish implementan la interfaz Movable, entonces
podríamos hacer:
© FUOC • PID_00273929 123 Guía de Java

3.12. Excepciones

3.12.1. Concepto

Para entender qué es una excepción, imaginemos que un programador quiere

leer datos de un fichero de texto en su programa. Lo habitual en lenguajes
que no incluyen el manejo de excepciones es dejar a juicio del programador el
control de las excepciones (casos anómalos o indeseados). Veamos una posible
solución adoptada por un programador (sin entrar en detalles de código, lo
importante es la estructura):

Si el código anterior estuviera dentro de un método, en vez de escribir mensajes

de error podríamos haber optado por devolver un código de error y desde
donde se invocó escribir un mensaje u otro dependiendo de dicho código.

Como podemos ver, la lógica del programa en sí y la gestión de las excepciones

está mezclada. Esto hace que el código sea más difícil de leer y entender. Es por
eso por lo que Java incluye la gestión de excepciones quitando responsabilidad
a los programadores. Veamos el código anterior en su versión Java:
© FUOC • PID_00273929 124 Guía de Java

Como podemos ver, gracias al bloque try-catch, Java nos permite separar
la lógica del programa de la gestión de las excepciones. El flujo normal del
programa está dentro del bloque try, mientras que cada excepción se trata en
el bloque catch correspondiente. Esta separación realmente facilita mucho la
lectura y entendimiento del código.

3.12.2. Declarando y lanzando una excepción

Continuemos viendo otro código:

En el código anterior, si pasamos como argumento al método setAge de la

clase Person un valor negativo, entonces este método no asigna el valor y
devuelve false para avisar de que ha habido un error (es decir, el intento de
asignar una edad negativa), no pudiéndose realizar la acción esperada correc-
tamente. En la clase Main se comprueba el valor devuelto por setAge del ob-
jeto david para saber si dicho método se ha ejecutado correctamente o no. Si
el método setAge devuelve el valor false, entonces quiere decir que dicho
método no se ha ejecutado bien. Así pues, desde donde se ha hecho la llamada
a setAge gestionamos este caso no deseado advirtiendo al usuario final con
un mensaje por pantalla.

El uso de un boolean (o de devolver un valor numérico conocido que haga

de código de errores, como se hace en el protocolo HTTP con los códigos 404,
500, etc.) es una manera muy habitual de controlar y gestionar los errores o si-
tuaciones anómalas en lenguajes basados en el paradigma de la programación
estructurada. Sin embargo, no es la mejor manera para tratar los errores, ano-
malías o casos excepcionales. Es por ello que lenguajes como Java incluyeron
el concepto de excepción o evento excepcional.

Una excepción es un evento indeseado que ocurre durante la ejecución

de un programa y que interrumpe, de alguna manera, el flujo normal
(o deseado/esperado) de ejecución del programa.
© FUOC • PID_00273929 125 Guía de Java

(15)
Cuando ocurre una excepción, el programa crea un objeto llamado exception En inglés, throwing an exception.
object que incluye información valiosa sobre el error, como por ejemplo, el
tipo de excepción, dónde ha sucedido dicho error, etc. El exception object es
lanzado a la JVM, que lo gestiona. Este proceso de lanzar exception objects es
lo que se conoce como lanzar una excepción.15 Veamos cómo sería el código
anterior usando excepciones.

Vemos que el método setAge de la clase Person ha experimentado algunos

cambios. Para empezar ya no devuelve nada (es void). En segundo lugar, he-
mos añadido throws Exception a su firma. Con esto estamos diciendo que
este método lanza una excepción. ¿Cuándo un método lanza una excepción?
Pues puede haber dos momentos:

1) Cuando dentro del método se llama a otro método que lanza una excep-
ción (es decir, cuando la signatura de este método que se llama tiene throws
Exception) y dentro de él se lanza la excepción.

2) Cuando el programador lo indica explícitamente con la instrucción throw

new Exception("Mensaje de error a mostrar"). En el caso de setAge
sucede el segundo caso. Como podéis ver, en el throw se crea un objeto de la
clase Exception (pertenece al package java.lang.Exception).

En el ejemplo anterior, si el programa ejecuta la línea de código throw new

Exception("..."), entonces el método se parará y saldrá. Es decir, no eje-
cutaría las líneas restantes del método. En el caso de setAge, si este lanzara
la excepción, no se ejecutaría nunca la línea de código this.age = age. Lo
mismo ocurriría si donde ahora tenemos throw new Exception("...")
tuviéramos en su lugar una llamada a otro método que lanza una excepción
y se lanzara dicha excepción.

3.12.3. Flujo que sigue una excepción

Cuando se sale de un método por culpa de una excepción, el programa no se

detiene de golpe, sino que lanza una excepción hacia arriba esperando que en
algún momento se capture esta excepción y se trate. Cuando decimos que la
excepción se lanza hacia arriba, queremos decir que esta va hacia atrás en el
© FUOC • PID_00273929 126 Guía de Java

orden de ejecución del programa. Este orden de ejecución está formado por
una pila –llamada call stack– con los métodos que han sido invocados hasta
que ha ocurrido la excepción.

Así pues, imaginemos que tenemos la clase Person definida anteriormente

cuyo método setAge lanza una excepción cuando la edad pasada como pará-
metros es negativa. Y que además tenemos el código siguiente:

Ahora ejecutamos en la consola de comandos la instrucción java A. Entonces

la ejecución del programa en un formato visual sería:

Figura 23

Vemos que no está la llamada al constructor de Person porque se ejecuta sin

problemas y digamos que desaparece, quizás viéndolo en formato call stack es
más fácil de entender:
© FUOC • PID_00273929 127 Guía de Java

Figura 24

En ambas figuras las flechas discontinuas indican llamada a un método y las

flechas continuas son lanzamientos de la excepción (es decir, el camino que
sigue una excepción hasta que es tratada). Sabiendo esto, vamos a analizar
el programa. En primer lugar, al hacer java A se ejecuta el main de dicha
clase y en él se llama al constructor de la clase A cuando instanciamos un
objeto para la referencia objectA. En el constructor de la clase A se llama
al método doSomething de la clase A que tiene dos instrucciones. Primero
crea un objeto de la clase Person (llamada que al terminar correctamente
desaparece de la call stack) y a continuación llama al método setAge con
un argumento negativo (-10). Al ejecutar el código del método setAge se
lanza una excepción porque el valor pasado como argumento no es correcto
y, por consiguiente, el flujo de ejecución entra en el if que crea (new) un
objeto Exception y lo lanza (throw). Este exception object es enviado hacia
arriba (flecha continua), pues así lo indica la coletilla throws Exception de la
firma del método setAge. Entonces, el objeto Exception creado en setAge
es recibido por el método doSomething, que decide si trata la excepción o no.
En este caso hemos decidido que no la trate (o como se dice informalmente,
que no la capture). Podéis ver que hemos decidido que el método doSomething
no la capture porque la firma del método doSomething tiene añadido throws
Exception. Por lo tanto, el método doSomething está delegando/pasando el
tratamiento de la excepción del método setAge hacia arriba (hacia quien le
ha llamado), en este caso, hacia el constructor de la clase A. Como podemos
ver, el constructor de la clase A también delega hacia arriba el tratamiento del
error. Cabe decir que, en cualquier programa en Java, el método especial main
es el último lugar donde podemos capturar y tratar las excepciones lanzadas.
Si en el main no capturamos y tratamos el error, entonces el programa termina
repentinamente, que es justamente lo que sucederá en este programa.

3.12.4. Tratando/capturando una excepción

Vamos a ahondar en el bloque try-catch que ya hemos visto. Como hemos

explicado, cuando se sale de un método por culpa de una excepción, el pro-
grama no se detiene de golpe, sino que va retrocediendo en el call stack para
© FUOC • PID_00273929 128 Guía de Java

ver si alguien trata/captura la excepción. ¿Cómo indicar en un punto del códi-

go que queremos capturar la excepción? Con un bloque llamado try-catch
que tiene la sintaxis siguiente:

Vamos a seguir con el ejemplo del apartado anterior, pero ligeramente modi-
ficado para introducir un try-catch:

Si nos fijamos, ahora el constructor de la clase ya no propaga/delega la excep-

ción del método doSomething hacia quien le ha llamado (en este caso el mé-
todo main), ya que no está la coletilla throws Exception en la firma del
constructor de la clase A. Ahora en la clase A capturamos o tratamos la excep-
ción generada por doSomething (si se genera). Si el método doSomething
no propaga ninguna excepción, es decir, al llamar a setAge no se lanza una
excepción, entonces se ejecutaría el println con el mensaje "TODO OK!!"
y el constructor de la clase A terminaría. En caso contrario, como sucede en
el ejemplo, debido a que p.setAge(-10) hace que setAge lance una excep-
ción, doSomething propagará esta excepción y será en el constructor de la
clase A donde se tratará. ¿Dónde se tratará? En el trozo de código del bloque
catch. Es decir, al producirse una excepción, todas las sentencias que haya
dentro del bloque try y después del método que ha provocado la excepción
no se ejecutarán. En el ejemplo no se ejecutará la sentencia println con el
texto "TODO OK!!" y el flujo del programa se irá de doSomething al código
que hay en el bloque catch. Es decir, después de doSomething se ejecutará
© FUOC • PID_00273929 129 Guía de Java

el println que imprime la información que hay en el objeto e, en este caso,

el mensaje que tiene el objeto e de tipo Exception asignado en el método
setAge: "Incorrect age!". Toda esta explicación gráficamente sería:

Figura 25

Cuando el diagrama anterior dice «¿Propaga la excepción?» quiere decir si el

método doSomething recibe una excepción lanzado por setAge y esta se ha
propagado hasta el constructor de la clase A. Si hay una excepción se para el
flujo de ejecución del bloque try y el programa sigue en el bloque catch,
por lo que ejecuta el código que hay en dicho bloque, en el caso del ejemplo:
System.out.println(e.getMessage());. Si no hay excepción, la ejecu-
ción continúa de manera normal con el resto del código ubicado dentro del
try.

Cuando usamos el bloque try-catch estamos indicando que en ese punto

queremos capturar una excepción que se produzca dentro del try y tratarla
dentro del catch.

3.12.5. Checked y unchecked exceptions

En Java hay dos categorías de excepciones: las checked y las unchecked. Así pues,
vamos a definir ambos tipos:

Las checked�exceptions (o comprobadas o verificadas) son aquellas para

las que el compilador comprueba que se capturen o se propaguen. En
caso de que una excepción sea checked y ni se capture ni se propague,
entonces obtendremos un error en tiempo de compilación.

Las unchecked� exceptions son aquellas excepciones para las cuales el

compilador no comprueba que sean capturadas o propagadas. Por con-
siguiente, como programadores no tenemos obligación de capturarlas
ni propagarlas.
© FUOC • PID_00273929 130 Guía de Java

¿Por qué unas excepciones son checked y otras unchecked? Java considera que
las unchecked son todas aquellas excepciones en las que el programador poco
puede hacer para lograr que el flujo de ejecución del programa no se vea al-
terado. En otras palabras, Java considera que de las excepciones unchecked es
difícil recuperarse, es decir, encontrar una solución que permita continuar la
ejecución del programa como si no se hubiera dado dicha excepción.

Por ejemplo, cuando dividimos un número entre cero se produce una excepción llamada
ArithmeticException que es de tipo unchecked. Poco podemos hacer, a priori, si hay
una división entre cero, seguramente se debe a una mala lógica del programa ya que antes
de dividir dos números deberíamos comprobar que el denominador sea distinto a cero.
Lo mismo ocurre cuando intentamos acceder a una casilla que no existe de un array. Por
ejemplo, si queremos acceder a la casilla/posición 24 de un array de 5 casillas, la JVM
durante la ejecución del programa (no en tiempo de compilación) lanzará una excepción
de tipo ArrayIndexOutOfBoundException. En este caso, poco podemos hacer. Nueva-
mente se debe a un error en nuestro código: o bien hemos usamos un índice cuyo valor
está mal asignado (un error clásico cuando se empieza a aprender a usar los bloques de
iteración), o bien no hemos comprobado que el índice que se usa para acceder a un ele-
mento del array esté dentro del rango correcto del array.

Las excepciones en Java están organizadas en torno a una jerarquía de clases

y, por lo tanto, basada totalmente en el mecanismo de herencia. Muy resumi-
damente y sin entrar en demasiados detalles veamos una pequeña muestra de
estas clases relacionadas con las excepciones:

Figura 26

Todas las clases en un tono más oscuro son checked, lo que quiere decir que
se deben capturar o propagar obligatoriamente en nuestro código. ¿Por qué?
Porque para este tipo de errores podemos gestionar qué hacer en el programa
para solucionar la aparición de dicha excepción. Por ejemplo, realizar una ac-
ción alternativa, hacer un rollback (deshacer operaciones que se han hecho),
salir del programa avisando amablemente al usuario final (no repentinamen-
te) y cerrando ficheros, sockets, conexiones a bases de datos para dejarlos en
un estado consistente, etc.

En cambio, todas las clases en tono claro son unchecked y no es necesario captu-
rarlas ni propagarlas. Como podéis ver, son errores (de hecho heredan/cuelgan
de la clase Error, excepto RuntimeException y sus subclases) que ocurren
© FUOC • PID_00273929 131 Guía de Java

con poca frecuencia y que poco se puede hacer como programador para solu-
cionar el problema. No obstante, como programadores podemos capturarlas e
intentar tratarlas, aunque, como ya hemos comentado, Java no nos obliga.

3.12.6. Declarando, lanzando y capturando más de una

excepción

Llegados a este punto cabe destacar que, como hemos visto anteriormente,
podemos tener tantos catch como excepciones queramos tratar de manera
diferente, ya que dentro de un bloque try se pueden dar diferentes tipos de
excepciones. Es más, un único método puede lanzar más de una excepción.
Por ejemplo:

Entonces, donde se llama al método read podemos hacer:

Imaginemos que el código anterior lo cambiáramos para hacer esto:

Vemos que tanto si se captura una excepción de tipo FileNotFoundExcep-

tion como IOException, lo que hacemos es lo mismo: llamar al método
printStackTrace del exception object. Para evitar repetir código, desde JDK
7 es posible hacer lo siguiente:
© FUOC • PID_00273929 132 Guía de Java

Como podemos ver, el código se ha reducido facilitando la legibilidad del có-

digo.

Ahora observad el siguiente código que parece similar al que llama al método
printStackTrace por separado, pero su comportamiento no es exactamente
idéntico:

Si os fijáis, lo que hemos cambiado es el orden de los catch, anteponiendo

el catch de IOException al de FileNotFoundException. Este sutil cambio
puede parecer menor y que, por lo tanto, no tenga consecuencias en nuestro
código, pero las tiene. ¿Por qué? Porque nunca se ejecutará el código que hay
dentro del catch de FileNotFoundException. ¿Por qué? Porque, para em-
pezar, los catch se ejecutan en orden de aparición. Además FileNotFoun-
dException es una subclase de la clase IOException y, por consiguiente,
IOException es capaz de capturar tanto las excepciones IOException como
las de todas sus subclases. Dadas estas dos condiciones, es lógico que nunca
se ejecute el catch de la excepción FileNotFoundException. Para que lo
veáis más claro:

El código anterior utiliza en primera instancia un catch de Exception. Co-

mo ya hemos visto, IOException es una subclase de Exception y, como la
clase FileNotFoundException es subclase de IOException, también lo es
de Exception. Así pues, el catch de Exception puede capturar cualquier
exception object que sea de una subclase de Exception. Sabiendo esto, es im-
portante que en caso de necesitar un caso default de captura de excepcio-
nes, es decir, un catch de Exception, este sea el último que escribamos en
nuestro código.

Llegados a este punto quizás os preguntéis ¿y por qué no hacemos un catch de

Exception y así simplificamos el código al máximo? Pues porque nos puede
interesar hacer acciones diferentes en función del tipo de excepción.
© FUOC • PID_00273929 133 Guía de Java

3.12.7. Bloque finally

El bloque try-catch puede completarse con el bloque finally, opcional-

mente. Es decir:

El bloque finally tiene la particularidad de que siempre se ejecuta indepen-

dientemente de lo que ocurra. Es decir, se ejecute correctamente el bloque try
o se lance una excepción que capture un catch, el código ubicado dentro de
finally se ejecutará a continuación del código try o catch. También se eje-
cutará si lanzamos una excepción y la propagamos. Antes de hacer la propa-
gación de la excepción (y salir del método), el bloque finally se ejecutará. El
único caso en que no se ejecuta el bloque finally es si el código que hay den-
tro del catch que ha capturado la excepción finaliza de manera inesperada.

3.12.8. Métodos del exception object

Cualquier objeto que sea de una clase que hereda de Throwable, es decir, to-
das las que usamos para propagar excepciones, tiene métodos que nos propor-
cionan información adicional sobre la excepción. Veamos los tres más intere-
santes:

1)� getMessage(). Devuelve un String con el texto que se haya indi-

cado en el constructor del exception object, por ejemplo, si se ha usado
Exception(String msg) o Throwable(String msg), etc.

2)� toString(). Devuelve un String con una breve descripción del objeto.
Básicamente el nombre de la clase de tipo Throwable seguido del símbolo :
y el texto de getMessage().

3)�printStackTrace(). Imprime a través de System.err el contenido del

método toString seguido por la traza del call stack.
© FUOC • PID_00273929 134 Guía de Java

3.12.9. Sentencia try-with-resources

En JDK 7 se añadió esta sentencia para cerrar recursos de forma automática

y, de este modo, simplificar el código. Aquellas referencias cuyas clases im-
plementan la interfaz AutoCloseable pueden declararse en el bloque try-
with-resources y, así, sus métodos close() serán llamados automática-
mente después del bloque finally.

Veamos un ejemplo de código antes de JDK 7:

El código anterior utilizando la nueva funcionalidad try-with-resources

de JDK 7:

El código anterior implícitamente realiza el mismo código que hacíamos en el

bloque finally, pero nuestro código se ha simplificado.

La mayoría de clases e interfaces relacionadas con entrada y salida implemen-

tan la interfaz AutoCloseable: manipulación de ficheros (FileReader), leer
y escribir datos (InputStream), gestión de flujos de red (DatagramSocket),
conexión a bases de datos (Connection), etc.

3.13. Enumeraciones

3.13.1. Concepto y sintaxis

(16)
Si habéis codificado en C/C++ u otros lenguajes, habréis usado enumeracio- En inglés, enumeration.
16
nes o simplemente enum. Como ya sabréis, los enum son un tipo definido por
el propio programador. Normalmente se utilizan cuando queremos restringir
los posibles valores que puede tomar una variable/atributo o estos valores con-
forman un dominio concreto y conocido. Por ejemplo, días de la semana, me-
ses del año, planetas del sistema solar, etc.
© FUOC • PID_00273929 135 Guía de Java

En Java, no obstante, el tipo�enum (introducido en JDK 1.5) es más potente

que en otros lenguajes, como por ejemplo C. Por defecto, Java define cada
enum como una clase y, de hecho, en su declaración se pueden incluir atributos
y métodos y, a la vez, esta clase incluye por defecto algunos métodos, como
por ejemplo values(), que devuelve todos los valores del enum. Además, la
manera ideal de declarar un enum es poniendo su código dentro de un fichero
.java que tenga el mismo nombre que el enum (igual que se hace con una
clase). No obstante, un enum se puede declarar dentro de una clase ya existente.

La sintaxis básica de un enum en Java es:

Por ejemplo:

Como ya hemos dicho, Java trata los enumeration como clases. Eso sí, son cla-
ses especiales que proporcionan una implementación type-safe (seguridad de
tipos) de datos constantes. Es decir, al declarar una variable del tipo del enu-
meration, solo se le puede asignar los valores del enumeration, ningún otro.

3.13.2. Diferencia entre usar constantes y un enumeration

Vamos a comentar la diferencia que hay entre hacer el enum de HandSign o

utilizar constantes enteras que simulan un enumeration de la siguiente manera:

Usar constantes tiene los siguientes problemas:

© FUOC • PID_00273929 136 Guía de Java

1) Ya que la variable no es de tipo enum, entonces podemos asignarle, por

error, cualquier valor. En el ejemplo, a playerHand se le podría asignar el valor
33 y no daría error en tiempo de compilación. Además, como los valores son
constantes y no enum, se podrían hacer operaciones aritméticas sin sentido,
por ejemplo, PAPER + ROCK. También podríamos mezclar «enumerations»
diferentes que no se pueden comparar: STONE == SUNDAY, donde STONE
y SUNDAY son para el compilador solo el valor 0 (no tienen una semántica
asociada).

2) No crea un namespace. Mientras que los enum siempre crean el namespa-

ce con el nombre del enumeration. Así, para usar el valor SCISSORS debemos
usar HandSign.SCISSORS. ¿Qué sucedería si hubiera otra variable llamada
SCISSORS en otra parte del código? Pues que tendríamos una colisión y debe-
ríamos renombrar una de las dos variables, por ejemplo, HAND_SCISSORS en
vez de simplemente SCISSORS.

(17)
3)�Fragilidad.17 Debido a que las constantes de un dominio (que simularían un En inglés, brittleness.

enumeration) se crean dentro de una clase (o incluso están repetidas en varias

clases), el hecho de cambiar el valor de una constante o añadir alguna nueva
provoca que tengamos que recompilar el/los fichero/s que las contienen. En
cambio, si usamos un enum de Java, solo tenemos que modificar el fichero
donde está declarado el enum y los cambios se verán propagados a toda la
aplicación.

4)�Print's sin información valiosa. Porque las constantes solo son enteros,
al hacer un println este imprime los valores enteros: 0, 1 y 2. Esto no nos
da información sobre lo que representan. En cambio, el enum imprime STONE,
PAPER y SCISSORS.

Como veis, los enumeration introducen muchas ventajas respecto a simular-

los con enteros u otro tipo de datos primitivos (por ejemplo, un char). Pues
bien, si los enumeration ya conllevan ventajas de por sí, en Java aún más, por-
que, como ya hemos comentado, Java trata los enumeration como una clase
y les añade características extra respecto a los enumeration de otros lenguajes
de programación.

3.13.3. Compatibilidad con switch

Los enum pueden usarse con switch como si de un entero u otro tipo básico
se tratara.
© FUOC • PID_00273929 137 Guía de Java

3.13.4. Implementación interna de las constantes (de los valores)

Además el compilador crea una instancia de la clase para cada constante defi-
nida dentro del enum. Estas instancias son public static final. Es decir,
no se pueden modificar (final) y se accede a ellas anteponiendo el nombre
del enum. Por ejemplo: Day.MONDAY. Asimismo, no se puede instanciar nin-
gún objeto de tipo del enum.

3.13.5. Herencia de la clase Enum

Cuando un enum es definido, Java crea una clase que hereda de la clase Enum.
Por este motivo, ningún enum puede heredar de otra clase o enum. Sin embar-
go, podemos hacer que un enum implemente una o más interfaces.

La clase Enum aporta los métodos siguientes:

Veamos su uso:

Además los enum tienen un método muy interesante llamado values() que
devuelve un array con los valores del enum.
© FUOC • PID_00273929 138 Guía de Java

3.13.6. Constructor y miembros

Toda variable de tipo enum es una referencia a una zona de memoria, igual que
una clase, una interfaz o un array. Esta variable es implícitamente final, ya
que sus valores no pueden modificarse. Sin embargo, el enum, al ser como «una
clase especial», puede definir un constructor y miembros del enum (es decir,
atributos y métodos). Esto es precisamente lo que hace al enum de Java más
poderoso en comparación con el enum de otros lenguajes de programación.
Veamos un ejemplo:

Es importante resaltar que el constructor de un enum solo puede ser private

o package-private (por defecto).

3.13.7. Métodos abstractos

En un enum podemos declarar un método abstracto y hacer que cada valor,

que como hemos dicho es una instancia, codifique su implementación/com-
portamiento.
© FUOC • PID_00273929 139 Guía de Java

Su uso podría ser el siguiente:

3.14. Generics

3.14.1. Concepto

Los generics fueron introducidos en JDK 5. Estos permiten la definición y uso

de tipos (es decir, clases e interfaces) y métodos genéricos. Los tipos y méto-
dos genéricos difieren de los tipos y métodos «normales» ya que los primeros
tienen parámetros de tipo.

Así pues, por ejemplo la clase ArrayList<E> es un tipo genérico (más común-
mente llamado tipo parametrizado) que tiene un parámetro de tipo llamado E.
Cuando usamos ArrayList<Person> o ArrayList<Animal>, a estos se les
llama tipos parametrizados, donde Person y Animal son los argumentos de
tipo, respectivamente. Veremos esto con más calma a continuación.

3.14.2. Clase genérica

Con Java podemos crear nuestras propias clases genéricas. Estas clases tienen
uno o más parámetros de tipo, que son tipos genéricos. Su sintaxis más simple
es la siguiente:
© FUOC • PID_00273929 140 Guía de Java

Como podemos ver en el código anterior, al definir la clase GenericClass he-

mos indicado que esta recibe un parámetro�de�tipo llamado T. Esto lo hemos
indicado usando el operador diamante (diamond operator), <>. De esta forma
podemos reutilizar la misma clase para diferentes clases de entrada. Así pues,
gracias a las clases e interfaces genéricas podemos abstraernos de los tipos.

A la hora de instanciar la clase GenericClass podremos hacer, por ejemplo:

En el primer caso, el atributo privado element de la clase GenericClass será

del tipo Animal (es decir, T es Animal en la primera instanciación) y en el
segundo caso será del tipo Person.

Desde la versión 7 de Java no es necesario indicar la clase al llamar al cons-

tructor. Es decir, el código anterior se puede reescribir así:

Gracias a JDK 7 se reduce la verbosidad ya que <> (llamado diamond operator)

infiere el parámetro de tipo a partir del especificado como tipo para el atributo
o variable que se está instanciando.

3.14.3. Ventajas de generics

Llegados a este punto, aunque solo hemos hablado de clases genéricas, vamos
ver qué ventajas tiene el uso de generics:

• Comprueba� los� tipos� en� tiempo� de� compilación. El compilador com-

prueba que el tipo con el que se instancia la clase genérica no viola la se-
guridad de tipos. Si ocurre, el compilador lanzará un error en tiempo de
compilación, lo cual es mucho mejor que en tiempo de ejecución.

• Elimina�la�necesidad�de�hacer�casting. Debido a que durante la instan-

ciación indicamos el tipo de la clase que hace de parámetro en la clase ge-
nérica, no es necesario hacer casting cuando recuperamos el objeto. Esto,
además, mejora la legibilidad de nuestro código.
© FUOC • PID_00273929 141 Guía de Java

• Facilita�a�los�programadores�crear�clases (y sobre todo, algoritmos) que Ved también

sean genéricas. Esto ayuda a reutilizar una gran cantidad de código en di-
Véase apartado «Colecciones»
ferentes programas. Esta ventaja queda de manifiesto claramente en el uso de esta guía.
de clases proporcionadas por Java que conforman el conjunto de coleccio-
nes.

Veamos ahora la ventaja de usar una clase genérica en vez de hacer uso de la
clase Object para la misma finalidad.

Los dos códigos anteriores son dos maneras de codificar la clase A. En el pri-
mero usamos la clase raíz Object de la que heredan todas las clases. En cam-
bio, en el segundo código hemos convertido la clase A en una clase genérica.

A priori puede parecer que son el «mismo» código, pero hay diferencias signi-
ficativas en el uso. En el código anterior, de hecho, no hay muchas ventajas
de usar uno u otro código. La mayor ventaja es que la clase del primero puede
recibir cualquier clase y devolver cualquier clase porque trabajamos siempre
con Object. En cambio, el segundo código permite definir con qué clase tra-
baja la clase genérica y, entonces, el compilador puede detectar errores y que
la clase A no sea usada con clases que no hemos definido al instanciarla.

Por otro lado, ¿qué pasaría si tuviéramos un método en la clase A que hiciera
uso del atributo obj para llamar a uno de sus métodos?
© FUOC • PID_00273929 142 Guía de Java

Como podemos ver, en el primer código aplicando polimorfismo y un down-

casting, el atributo obj puede ser cualquier clase. Sin embargo, no podemos
garantizar la seguridad de tipo porque necesitamos convertir explícitamente
de Object a otra clase, y ya sabemos que al hacer un downcasting es frecuente
crear accidentalmente errores en tiempo de ejecución. Asimismo, ¿qué ocurre
si la clase A también debe servir para la clase Person que también tiene el
método greeting pero no está relacionado con la clase Dog? Pues que el hecho
de tener que hacer un casting explícito no nos permite generalizar el uso de la
clase A. Si la clase A la usáramos exclusivamente para Dog y Cat, entonces con
hacer un downcasting a Animal sería suficiente, y el primer código funcionaría
cuando obj fuera Dog o Cat.

3.14.4. Interfaz genérica

De manera similar a una clase, también podemos definir nuestras propias in-
terfaces genéricas.

Debemos saber que una interfaz de Java que es genérica es Comparable.

3.14.5. Método genérico

Los métodos genéricos son similares conceptualmente a la clase genérica, pero

el parámetro de tipo solo afecta al método, no a toda la clase. Un método
genérico puede estar tanto en una clase o interfaz genérica como normal. El
primer caso lo hemos visto en el subapartado anterior, cuando hemos definido
el método doSomething en la interfaz GenericInterface. Ahora veamos la
definición de un método genérico en una clase normal.
© FUOC • PID_00273929 143 Guía de Java

Como podemos ver, antes de la declaración del tipo de retorno debemos poner
los parámetros de tipo dentro de <>.

Para llamar a este método que encuentra un elemento dado en un array, po-
demos hacer:

Como vemos, al método generic se le puede llamar de dos formas diferentes:

la primera es indicando el argumento de tipo y otra es sin indicarlo (dejando
que el compilador lo infiera).

Veamos dos ejemplos más:

3.14.6. Parámetros de tipo

En primer lugar, es importante resaltar que podemos tener uno o más pará-
metros de tipo. Por ejemplo:

Asimismo, cabe indicar que, por convenio, el nombre del parámetro de tipo
suele ser un único carácter escrito en mayúsculas. Los nombres más habituales
son:
© FUOC • PID_00273929 144 Guía de Java

• E: usado para elementos de una colección. Ved también

Véase apartado «Colecciones»

• T: tipo (es decir, una clase, una interfaz o un tipo parametrizado). de esta guía.

• S, U, V, etc.: para segundo, tercer, cuarto tipo, etc. En una clase genérica
podemos tener más de un parámetro de tipo.

• K: clave (para clases que modelan un clave-valor).

• V: valor.

Por otro lado, los tipos que pueden utilizarse como parámetros de tipo solo
pueden ser clases o interfaces. Así pues, si queremos usar tipos primitivos, no
podemos. La solución será usar las correspondientes clases�wrapper (envolto-
rio). Estas son:

• Para el tipo primitivo byte, su clase wrapper es Byte.

• Para el tipo primitivo short, su clase wrapper es Short.
• Para el tipo primitivo int, su clase wrapper es Integer.
• Para el tipo primitivo long, su clase wrapper es Long.
• Para el tipo primitivo float, su clase wrapper es Float.
• Para el tipo primitivo double, su clase wrapper es Double.
• Para el tipo primitivo char, su clase wrapper es Character.
• Para el tipo primitivo boolean, su clase wrapper es Boolean.

3.14.7. Subtipos

Podemos tener un subtipo de una clase o interfaz genérica heredando de ella

o implementándola, respectivamente:

Con el código anterior estamos creando una interfaz llamada MyList que
hereda de la interfaz Java llamada List (hablaremos de ella en el siguien-
te apartado). Si List fuera List<Integer>, entonces nuestra interfaz My-
List podría ser MyList<Integer,Object>, MyList<Integer,Integer>,
MyList<Integer,Double>, MyList<Integer,String>, etc.

3.14.8. Usando tipos parametrizados como parámetro de tipo

Un parámetro de tipo puede ser una tipo parametrizado. Por ejemplo:

© FUOC • PID_00273929 145 Guía de Java

3.14.9. Uso del wildcard ?

(18)
Con los generics podemos usar el comodín18 ?. Este comodín representa un En inglés, wildcard.

tipo desconocido o, dicho de otro modo, cualquier tipo. Este comodín puede
ser usado como parámetro de tipo, tipo de un atributo o incluso como tipo del
retorno de un método (aunque esto último no es aconsejable). Sin embargo, ?
no puede ser usado para llamar a métodos genéricos ni para instanciar objetos
de clases genéricas.

Otro ejemplo podría ser:

Así pues, el uso del comodín ? sería recomendable cuando:

• pudiéramos usar en su lugar Object.

• los métodos en los que lo utilizamos no dependen del parámetro de tipo,

por ejemplo, list.length, etc.

3.14.10. Limitación de tipos

Hasta ahora hemos visto que los parámetros de tipo podían ser sustituidos
por cualquier clase o interfaz. Sin embargo, esto a veces no es lo deseado y
queremos limitar los tipos que se pueden pasar a un parámetro de tipo.

Un ejemplo claro es si queremos que los tipos que se reciban sean numéricos.
Es decir, Integer, Float o Double, pero no String ni otro tipo. Si tuviéra-
mos el siguiente código, este no funcionaría:
© FUOC • PID_00273929 146 Guía de Java

Con el código anterior el compilador nos daría error porque no sabe que nues-
tra intención es usar la clase Maths solo con tipos numéricos y que, por con-
siguiente, sumar dos elementos es correcto. Así pues, debemos indicarle que
solo usaremos clases que sean numéricas. Es decir, limitaremos los tipos que
puede aceptar el parámetro de tipo T. Esto lo haremos con los bounded types
(es decir, tipos limitados). El código anterior usando bounded types sería:

Como podemos apreciar, hemos usado la palabra reservada extends para de-
cir que todos los tipos que reciba T deben heredar de la clase Number. En es-
te caso, tanto Integer como Float y Double heredan de esta clase. Ahora
podremos hacer:

Otro ejemplo donde indicamos que los tipos pasados al parámetro de tipo
cumplen una condición es el siguiente:

Gracias al uso de extends Comparable le estamos diciendo que todos los

tipos que recibe el parámetro de tipo T deben implementar Comparable.
© FUOC • PID_00273929 147 Guía de Java

Podemos indicar más de una restricción para un mismo parámetro de tipo

usando &:

El uso de extends nos permite indicar una acotación (o límite) superior. De

ahí que a la combinación de extends seguido de una clase se le llame upper
bound. Si en vez de usar un nombre, por ejemplo, T, se usa el comodín ?,
entonces al conjunto se le llama upper bound wildcard. En cualquier caso, el
uso de extends lo que nos permite es decir que lo que está a la izquierda del
extends debe ser un subtipo de la clase/interfaz que escribamos a la derecha
o la misma clase/interfaz. Así pues:

El código anterior nos está diciendo que lo que pongamos en T debe ser o
Number o una subclase de Number (es decir, una clase que herede directa o
indirectamente de Number).

Veamos otro ejemplo usando List. Entre el siguiente código:

Y este:

¿Veis la diferencia? Con el primero elements podría ser cualquier List, es

decir: List<Integer>, List<Double>, etc., mientras que con el segundo có-
digo solo podríamos pasarle como argumentos un List<Number>. Aunque
Integer es un subtipo de Number, List<Integer> y List<Number> no es-
tán relacionados, ya que List<Integer> no es un subtipo de List<Number>.
El elemento común/padre de List<Integer> y List<Number> es List<?>.
© FUOC • PID_00273929 148 Guía de Java

Existe otro limitador llamado super. Con él estamos diciendo que el tipo que
se utiliza (lado izquierdo) debe ser una superclase o superinterfaz del elemento
indicado a la derecha o el propio elemento. Es decir:

Nos está diciendo que lo que usemos (?) debe ser o Animal o una superclase
directa o indirecta de Animal.

Es el momento de enfrentamos a la gran pregunta: ¿cuándo usar extends,

super o ninguno de ellos?

• Usaremos extends cuando solo queramos consultar los valores (es decir,
acceso de lectura).

• Usaremos super cuando solo queramos escribir/añadir valores (es decir,

acceso de escritura).

• No usaremos ni extends ni super si necesitamos tanto leer como escribir.

3.14.11. Restricciones en el uso de generics

Los generics tienen algunas restricciones:

1) No se pueden instanciar tipos genéricos con tipos primitivos.

2) No se pueden crear instancias de los parámetros de tipo.

3) No se pueden declarar atributos static cuyos tipos son parámetros de tipo.

4) No se pueden hacer castings con tipos parametrizados:

© FUOC • PID_00273929 149 Guía de Java

5) No se puede usar instanceof con tipos parametrizados.

6) No se pueden crear arrays de tipos parametrizados.

7) No se pueden crear, capturar o lanzar tipos parametrizados que extiendan

de Throwable.

8) No se puede sobrecargar un método que tenga la misma firma que otro

después del type erasure (es el proceso que sigue Java a la hora de convertir el
código a bytecode).

3.15. Colecciones

En Java existen un conjunto de clases�genéricas/parametrizadas que se com-

portan como una estructura de datos que guardan objetos de cualquier clase.
De este modo, un subconjunto dentro del conjunto de clases que modelan una
estructura de datos son las clases que implementan la interfaz Collection.
Podéis ver una parte del diagrama de clases a continuación.
© FUOC • PID_00273929 150 Guía de Java

Figura 27

Todas las clases representadas eliminan dos restricciones del array:

1) Indicar obligatoriamente cuando se crea/inicializa el número de ítems (es

decir, casillas) que tendrá, y

2) no poder ampliar o reducir el número de casillas (es decir, elementos a

guardar) una vez creado el array.

Como se puede ver en el diagrama de la figura 27, hay tres interfaces (Set,
List y Queue) que heredan de la interfaz Collection. Las clases que imple-
mentan estas tres interfaces permiten añadir un número «infinito» de elemen-
tos (es decir, el asterisco de los diagramas de clases UML).

3.15.1. Interfaz Set

La primera interfaz que trataremos será Set.

Cada una de las clases que implementan Set se comporta como una
estructura de datos que guarda un conjunto de objetos únicos. Es decir,
las clases que implementan Set no permiten elementos duplicados.

No obstante, las diferentes clases que implementan Set añaden funcionalida-

des y comportamientos. Por ejemplo:

1)� Ordenación: HashSet guarda los elementos sin seguir un orden lógico,
mientras que LinkedHashSet guarda los elementos en el orden de inserción
de los mismos y TreeSet los guarda siguiendo, o bien las indicaciones que
codificamos en el método compareTo() (para usar este método, la clase del
objeto que guardamos debe implementar la interfaz Comparable y sobrescri-
bir dicho método), o bien mediante un objeto de una clase que implemente
© FUOC • PID_00273929 151 Guía de Java

la interfaz Comparator y, en consecuencia, sobrescriba el método compare

(dicho objeto se puede pasar como argumento en uno de los constructores de
TreeSet).

2)�Elemento�null: TreeSet no permite insertar el elemento null, mientras

que HashSet y LinkedHashSet sí que permiten el elemento null, pero solo
una vez, puesto que la interfaz Set no permite elementos duplicados.

En líneas generales, de las tres clases se suele usar HashSet, puesto que es
mejor en rendimiento, a no ser que realmente se necesite guardar elementos
únicos (es decir, sin duplicados) en un orden específico. En este caso, se utiliza
LinkedHashSet o TreeSet.

3.15.2. Interfaz List

Cómo podéis ver en el diagrama UML anterior (figura 27), otra rama es la que
empieza con la interfaz List. Como se puede apreciar, hay tres clases (en reali-
dad hay más) que implementan List: ArrayList, Vector y LinkedList.
Estas clases, las más usadas de List, tienen en común que se comportan como
una lista (de ahí que implementen la interfaz List).

Las tres clases permiten insertar objetos duplicados y, además, los obje-
tos insertados están ordenados por índice.

Tanto ArrayList como LinkedList no son sincronizados. Esto quiere decir

que no pueden ser usados directamente en programas con más de un hilo de
ejecución (es decir, más de un thread; multi-threading). Para usarlos con más
de un thread se tienen que sincronizar externamente. El concepto de thread
se estudia, por ejemplo, en las asignaturas «Sistemas operativos» y «Sistemas
distribuidos», así que por ahora no os preocupéis. Por su parte, Vector es
similar a ArrayList, excepto que es sincronizado. Así pues, se prefiere usar
ArrayList cuando no se programa con múltiples hilos.

Tal y como están implementados ArrayList y LinkedList, los requisitos de

memoria son menores para ArrayList. De hecho, ArrayList está basado en
el concepto de array dinámico (dynamic array), mientras que LinkedList en
el concepto de doubly linked list.

Si se hacen muchas inserciones (es decir, add), especialmente en el medio de la

lista, es preferible utilizar LinkedList que ArrayList, pues el coste es menor.
En contra, si las inserciones se hacen al final, entonces ArrayList tiene un
rendimiento un poco mejor, salvo que se pase de la capacidad inicial muy a
menudo y se tenga que aumentar muchas veces el array que lo implementa.
© FUOC • PID_00273929 152 Guía de Java

Por otro lado, si se hacen más consultas de acceso aleatorio (es decir, get)
que inserciones, es preferible usar ArrayList, ya que LinkedList recorre
toda la lista hasta alcanzar la posición/índice indicado. El borrado, sobre todo
si se realiza al comienzo o en el medio de la lista, tiene un mejor coste en
LinkedList, puesto que si se elimina un objeto del medio, no se deben mover
todos los objetos posteriores como sucedería con la ArrayList.

Porque LinkedList también implementa la interfaz Queue, incluye métodos

propios de las colas, como por ejemplo peek (obtener el primer elemento de
la lista) o poll (obtener el primer elemento de la lista y borrarlo de la lista).

Finalmente llegamos a la rama de la interfaz Queue (en español, cola), cuyas (19)
Acrónimo de First-In, First-Out.
19
clases siguen la filosofía FIFO. De hecho, como ya se mencionó, LinkedList
implementa Queue además de la interfaz List, teniendo un comportamiento
híbrido. La otra clase que implementa Queue es PriorityQueue, que se trata
de una cola con prioridad.

3.15.3. Interfaz Map

(20)
Lo que hemos visto hasta ahora son estructuras que, más o menos, conocéis, Acrónimo de Last-In, First-Out.
al menos, conceptualmente: lista, cola y conjunto (set). Nos ha faltado ver la
pila, una estructura que también conocéis y que sigue la filosofía LIFO20 y que
en Java está codificada con la clase Stack que hereda de la clase Vector.

Ahora queremos animaros a conocer unas nuevas estructuras de datos, muy

frecuentes en el mundo de la programación, que se basan en el concepto de
array asociativo. Un array (o matriz) asociativo (también conocido como tabla
hash o tabla de dispersión) es una estructura de datos muy útil que consiste
en un conjunto de pares (clave, valor). Muchos lenguajes de programación,
como PHP y JavaScript, implementan la funcionalidad para trabajar con estas
estructuras. Veamos el ejemplo fácil de JavaScript:

(21)
Si analizamos el código JavaScript anterior, lo que hacemos es crear un array En inglés, key-value pair.
(sin longitud, esto lo permite hacer JavaScript) y a cada casilla en vez de utilizar
los índices 0, 1, 2 y 3, usamos una clave, en este caso de tipo textual (String).
Ahora ya no usamos 0, 1, 2 y 3 para acceder a las casillas del array, sino que
usamos claves. Así pues, en la casilla con clave igual a "9781412902243"
(que no quiere decir que sea ni la casilla 0 ni la casilla ubicada en la posición
9781412902243 del array) está el valor "Terracota Warriors". Por lo tan-
to, estamos usando una estructura basada en un par clave-valor.21 Seguramente
os estaréis preguntando: «¿para qué puede ser útil un array asociativo?» Pues,
© FUOC • PID_00273929 153 Guía de Java

por ejemplo, imaginemos que la clave es el nombre corto utilizado para cada
uno de los equipos (Team) que tenemos en un juego de fútbol y dentro de
la casilla correspondiente guardamos un objeto de la clase Team. Gracias al
array asociativo seremos capaces de acceder de manera directa a todo el objeto
Team sabiendo su nombre corto único. Si usamos otro tipo de estructura, por
ejemplo, una lista, para poder encontrar el ítem con identificador "Barça",
tendríamos que hacer una búsqueda por toda la estructura hasta encontrarlo.
Eso sí, quizás os lo estáis planteando, pero cada objeto guardado en el array
asociativo tiene que tener una clave�única, si no, solo podremos guardar uno
de los dos objetos como valor de aquella clave. Por ejemplo:

En este caso el par clave-valor guardado será "9781412902243"-"Venus de

Milo", es decir, en la casilla "9781412902243" no estará "Terracota Wa-
rriors".

En Java las clases asociativas se modelan, principalmente, con las clases que
implementan la interfaz Map.

Figura 28

Como podéis ver en el diagrama, básicamente se usan cuatro clases: HashMap,

Hashtable, LinkedHashMap y TreeMap, que tienen un comportamiento si-
milar al que hemos comentado, con sus particularidades. En cualquier caso la
clave tiene que ser un objeto (ya sea de una clase wrapper si queremos usar los
tipos básicos –por ejemplo, Integer en vez de int, String, Float en vez de
float, etc.–; o una clase creada por nosotros).
© FUOC • PID_00273929 154 Guía de Java

Ni HashMap ni Hashtable guardan los elementos ordenados, ni por clave ni

por valor. Por el contrario, los elementos dentro de TreeMap están ordenados
por clave usando el método compare de la interfaz Comparator y en Lin-
kedHashMap se ordenan por orden de inserción.

Hashtable es como HashMap pero sincronizado. Esto quiere decir que puede
usarse en programas con más de un hilo de ejecución. Obviamente, esta ca-
racterística le comporta un sobrecoste al programa.

Otra diferencia es que Hashtable no permite valores ni claves null, mientras

que HashMap sí que permite valores null, y solo una clave null. A la vez,
LinkedHashMap sí que permite tener duplicados, del mismo modo en que lo
hace HashMap, pues hereda de esta clase. Por su parte, TreeMap solo permite
valores null, no claves.

3.15.4. Resumen

Con la explicación de las clases que implementan la interfaz Map, parece que
todo son ventajas y lo mejor es usar una estructura de datos de tipo Map, en
vez de tipos List o Set. Bien, pues evidentemente, cada clase tiene su uso.
Por ejemplo:

• Las clases procedentes de List, como por ejemplo ArrayList, son útiles
si necesitamos guardar el orden de los objetos que almacenamos.

• Además, las clases de tipo List consumen menos memoria, pues solo
guardan el objeto que insertamos, mientras las que son de tipo Map guar-
dan dos objetos: la clave y el valor.

• Las clases de tipo List pueden guardar duplicados de valor, mientras que
las de tipo Map solo pueden duplicar valores, no claves. Las clases de tipo
Set no permiten duplicados.

• Las clases de tipo List y Map permiten el valor null. Eso sí, las de tipo
Map solo permiten null una vez como clave.

• A diferencia de las clases que implementan List o Map, las clases que im-
plementan Set no tienen un método para acceder directamente a un ele-
mento guardado (conocido como acceso aleatorio), sino que se debe iterar
sobre toda la colección hasta llegar al elemento deseado.

En la figura 29 facilitamos un diagrama de decisión que os puede ayudar a la

hora de escoger una estructura u otra. Es un diagrama genérico y, por ello, será
el problema a tratar así como vuestro conocimiento de las estructuras lo que
finalmente acaben determinando vuestra decisión.
© FUOC • PID_00273929 155 Guía de Java

Figura 29
© FUOC • PID_00273929 156 Guía de Java

4. Avanzado

4.1. La clase String

A diferencia de otros lenguajes de programación como C o C++ donde un string

es un array de char, el String en Java, como ya sabemos, es una clase que
hereda, como cualquier otra clase en Java, de la clase Object. Sin embargo, la
clase String es especial respecto al resto de clases porque:

1) Podemos asignar un texto con dobles comillas (String literal) a una variable
de tipo String sin necesidad de llamar al constructor para crear una instancia
de la clase String.

Así pues, un objeto String puede crearse como si fuera un tipo primitivo (por
ejemplo, como hace un entero: int a = 5;) o como un objeto:

Cabe decir que lo más habitual es construirlo como si se tratara de un tipo

primitivo, lo que se denomina String literal para diferenciarlo de la segunda
forma llamada String object.

2) El operador + está sobrecargado para poder concatenar dos String. Este

operador no funciona con objetos de otras clases. Así pues:

3) Los String literals son almacenados como objetos en un lugar común llama-
do String common pool dentro del heap. Esto facilita la compartición y eficien-
cia del almacenaje. Por su parte, cuando el String es creado con la llamada
explícita al constructor, se crea un objeto (al que llamaremos String object para
distinguirlo del String literal) que se almacena directamente en el heap. Mirad
este código:
© FUOC • PID_00273929 157 Guía de Java

El código anterior, gráficamente, sería:

Figura 30

Así pues, si dos String literals tienen el mismo contenido, entonces apuntan y
comparten el mismo espacio de memoria en el String common pool. Por su parte,
cada uno de los String creado como objeto (es decir, con new) se comporta
como cualquier objeto de otra clase ocupando su propio espacio en el heap,
aunque el contenido de dos String objects sea el mismo.

4) Debido a que los String literals con idéntico contenido comparten la zona
de memoria en el String common pool, Java define String como inmutable. Es
decir, el contenido no puede ser modificado una vez ha sido creado. Por este
motivo, cuando llamamos a un método como toLowerCase(), este método
no modifica el String que le pasamos, sino que crea uno nuevo con todas
las letras en minúsculas. Esto se hace así para que String se comporte como
inmutable, pero dicho comportamiento puede crearnos problemas:

En el código anterior tendríamos en el String common pool dos String, uno

con el texto "Hola" y otro con el texto "Hola David!". El problema es que
mientras str1 apunta a "Hola", nadie está apuntando a "Hola David!", lo
cual haría que estuviéramos malgastando memoria. Es verdad que Java tiene
un mecanismo especial llamado garbage collector que se encarga de ir borrando
periódica y automáticamente aquellos objetos sin referencia, sin embargo, que
se hagan excesivas llamadas al garbage collector afectará gravemente al rendi-
miento del programa.

Para ver más clara la diferencia entre String literal y String object, veamos el
ejemplo siguiente:
© FUOC • PID_00273929 158 Guía de Java

En el ejemplo anterior se imprimirán por pantalla los dos mensajes, puesto

que str1 y str2 son el mismo objeto en el String common pool, mientras que
str3 es un objecto ubicado en el heap.

Si el contenido de un String tiene que ser modificado frecuentemente, en-

tonces es mejor usar las clases StringBuilder o StringBuffer, que son
mutables (el objeto se crea en el heap general, y cualquier cambio sobre el ob-
jeto modificará el objeto, no creará uno nuevo), aunque no son tan potentes
en cuanto a métodos como String.

Aunque, como hemos comentado, el código anterior no sería la mejor opción

a la hora de trabajar con un texto que es modificado tan frecuentemente, el
compilador de Java es lo suficientemente inteligente para darse cuenta de ello
en la mayoría de casos y sustituir internamente el String del bucle por un
StringBuilder y, posteriormente, asignar el valor resultante en formato de String
literal a la variable original str.

4.1.1. StringBuilder frente a StringBuffer

La principal diferencia entre estas dos clases es que StringBuilder no es sin- (22)
En inglés, thread.
cronizada, mientras que StringBuffer sí lo es. Esto significa que podemos
usar StringBuffer en programas con más de un hilo de ejecución,22 es decir,
cuando estamos haciendo programación paralela. Por este motivo, lo más ha-
bitual es usar StringBuilder porque además su eficiencia, al no ser sincro-
nizado, es mejor que StringBuffer.

Como ambas clases son clases normales, entonces solo se pueden crear a partir
de un constructor, no podemos asignarles directamente un String literal. Tam-
poco se puede usar el operador +, sino los métodos append() o insert().

4.1.2. Resumen

Si tenéis que modificar frecuentemente un texto, utilizad StringBuilder (en

programas single thread) o StringBuffer (en programas multi-thread), aun-
que, como hemos comentado, el compilador de Java es bastante inteligente
© FUOC • PID_00273929 159 Guía de Java

para usar internamente StringBuilder cuando estamos usando String en

situaciones con demasiadas modificaciones. No obstante, siempre que podáis
y preveáis pocas modificaciones, utilizad String porque es más eficiente, ya
que le dais al compilador la posibilidad de optimizar el uso de memoria por
parte del programa mediante el uso del String common pool.

4.2. Programación funcional (expresiones lambda y Stream API)

La versión 8 de Java introdujo la programación funcional. De esta manera, Ja-

va puso de manifiesto que a partir de entonces no hay que pensar en este len-
guaje como exclusivamente orientado a objetos. La programación funcional
está ganando popularidad año tras año. Incluso hay tendencias que muestran
que empieza a ser más popular que el orientado a objetos.

4.2.1. Expresiones lambda

La versión 8 de Java introdujo las expresiones lambda. Básicamente, una ex-

presión lambda es una función anónima. Esto quiere decir que no requiere
ser un método de una clase y, por lo tanto, no necesita un nombre para ser
invocada. Su sintaxis es la siguiente:

Como se puede ver, hay tres partes:

1)�Operador�lambda que está formado por los símbolos matemáticos menos

y mayor que, es decir, ->.

2) La parte izquierda hace referencia a los parámetros de la función. Si solo

hay un parámetro, entonces no es necesario poner los paréntesis. En el caso de
que no haya parámetros o haya más de uno, entonces sí que son obligatorios.
Además, Java puede deducir los tipos de los parámetros que se les pasa y, por
lo tanto, no es necesario indicarlos.

3) La parte derecha hace referencia al cuerpo, es decir, al código en sí de la

función. Si el cuerpo solo tiene una línea, entonces no son necesarias ni las
llaves ni la sentencia return en caso de que devuelva un valor.

Algunos ejemplos de expresión lambda son:

© FUOC • PID_00273929 160 Guía de Java

Las expresiones lambda se basan en la programación funcional, que es un pa-

radigma dentro de la programación�declarativa basada en el uso de funcio-
nes matemáticas. Esto permite una programación más expresiva y elegante.
La programación declarativa nos permite decirle a un programa qué es lo que
queremos/necesitamos, pero sin decirle cómo lo tiene que llevar a cabo. Esta
es la principal diferencia con la programación imperativa, en la que se indica
al programa todos los pasos a seguir para lograr lo que queremos. Por ejemplo,
SQL (usado para manipular bases de datos) es un lenguaje declarativo:

La sentencia anterior (en SQL llamada query) pide a la base de datos que retorne
todos los usuarios de la tabla users cuyo apellido sea Anderson. En este caso
no sabemos si la base de datos internamente usará un for o un while o un
if o un switch o un array u otra estructura. Por así decirlo, nosotros pedimos
lo que queremos, el programa se «busca la vida» para satisfacernos.

4.2.2. Interfaz funcional

Las expresiones lambda van íntimamente ligadas con el concepto de interfaz

funcional, concepto que también fue añadido en Java 8. Una interfaz funcio-
nal es igual que una interfaz Java normal pero añade dos reglas:

1) Tiene un solo método abstracto.

2) El resto de métodos deben ser métodos estáticos o default.

Aunque es opcional, en la declaración de la interfaz funcional se puede aña-

dir la anotación @FunctionalInterface para hacer el código más fácil de
entender. Por ejemplo:
© FUOC • PID_00273929 161 Guía de Java

A continuación utilizamos la interfaz funcional que hemos declarado:

Así pues, las interfaces funcionales se pueden usar para crear un tipo concreto
a partir de la definición de una expresión lambda.

Llegados a este punto puede parecer que muchas veces tengamos que crear
una interfaz funcional si queremos hacer algo complejo. Como hemos visto,
las expresiones lambda pueden trabajar con interfaces funcionales para lograr
la reutilización de su código a lo largo de nuestro programa, pero muchas ve-
ces usaremos una expresión lambda en un contexto concreto una sola vez.
De hecho, Java tiene muchos métodos en sus diferentes clases que aceptan
como parámetro una expresión lambda. Por ejemplo, ahora las clases que im-
plementan la interfaz Iterable tienen el método forEach. Algunas de estas
clases son ArrayList, LinkedList, HashSet, etc. Este método lo que hace es
recorrer (o iterar) una estructura de datos y para cada elemento de la estructura
ejecutar la operación (que será una expresión lambda) pasada por parámetros.
Así pues:

El código anterior imprime los números que hay en lista.

Finalmente, cabe decir que las expresiones lambda se están utilizando mayo- Enlace recomendado
ritariamente con la nueva API Stream que introdujo JDK 8. De manera resu-
En el enlace https://
mida, podemos decir que a través de la API Stream podemos trabajar sobre docs.oracle.com/en/java/ja-
colecciones como si estuviéramos realizando sentencias SQL (gracias a las ex- vase/13/docs/api/java.base/
java/util/stream/packa-
presiones lambda). Esto permite que trabajemos de una manera limpia y cla- ge-summary.html encontra-
réis ejemplos de cómo utili-
ra, evitando bucles y algoritmos que ralentizan los programas e incluso hacen
zar la API Stream.
que el código se torne inmanejable.

Existen tres partes que componen un Stream, que de manera general serían:

1) Un Stream funciona a partir de una lista�o�colección, que también se la

conoce como la fuente de donde se obtienen los datos.
© FUOC • PID_00273929 162 Guía de Java

2)�Operaciones�intermedias como, por ejemplo, el método filter, que per-

mite hacer una selección de los datos a partir de un predicado.

3)�Operaciones�terminales como, por ejemplo, los métodos max, min, sum,

forEach, findFirst, etc.

Así pues, una posible sentencia con Stream sería:

La expresión anterior filtra los empleados que cobran 1000 € o más y suma sus
cantidades. Así sabemos cuál es el coste salarial de los empleados que cobran
1000 € o más.

4.3. Módulos

Si habéis creado proyectos con Eclipse utilizando una versión igual o superior
a JDK 9, os habréis dado cuenta de que os pregunta si queréis crear un fichero
llamado module-info.java. El hecho es que JDK 9 introdujo el concepto de
módulo para mejorar aún más la encapsulación.

En Java, un módulo es un conjunto de clases que pueden contener uno

o varios packages y que define las dependencias con el resto de módu-
los así como la visibilidad de las clases que contiene.

Figura 31

Para definir todo esto, los módulos usan descriptores que se escriben en un
fichero llamado module-info.java que está ubicado en la raíz del código
fuente del módulo. Fijaos que el nombre que tiene este fichero rompe la regla
de nomenclatura de Java, la cual no permite poner un guion como nombre de
fichero. De esta forma, las herramientas (java, javac, IDE, etc.) no lo con-
funden con una clase Java normal.
© FUOC • PID_00273929 163 Guía de Java

Cada módulo definido en el fichero module-info.java tiene esta forma:

Se recomienda que el nombre del módulo no coincida con el de una clase,

interfaz o paquete a fin de evitar confusiones.

Dentro de las llaves podemos usar diferentes sentencias. Las dos más usadas
son:

1)�exports indica que las clases públicas del paquete exportado son visibles
para el resto del mundo.

Para este ejemplo solo las clases públicas que están dentro del paquete
edu.uoc.logging serán visibles fuera del módulo a. Así pues, las clases pú-
blicas de otro paquete del módulo a, por ejemplo, edu.uoc.classroom, no
serán visibles fuera del módulo.

Por lo tanto vemos que, gracias a los módulos, aun siendo pública una clase
en un paquete, esta no lo será para los elementos de fuera del módulo si no
se exporta explícitamente. Así pues, los módulos pueden ocultar visibilidad
pública, lo cual mejora la encapsulación en Java.

2)�requires indica una dependencia a un módulo. Es decir, un módulo ne-

cesita o quiere usar otro módulo.

4.4. Clases anidadas

(23)
En primer lugar, vamos a definir qué es una clase anidada.23 En inglés, nested class.

Una clase�anidada es aquella que está dentro de otra.

La posibilidad de crear clases anidadas se incorporó en Java 1.1. Aunque son un

tema avanzado, son interesantes puesto que hacen referencia a aquellas clases
que se utilizan en un punto concreto de nuestro programa. Además mejoran
la encapsulación y la legibilidad del código.
© FUOC • PID_00273929 164 Guía de Java

Hay dos tipos de clases anidadas: las static nested classes y las inner classes. Vea-
mos cada una de ellas.

4.4.1. Static nested class

Veamos un ejemplo para entender el funcionamiento de este tipo de clase:

La clase anidada estática tiene acceso directo a todos los miembros estáticos de
la clase externa. Si desea acceder a miembros no estáticos, se deberá usar una
referencia a un objeto de la clase externa. Por este motivo, las clases anidadas
estáticas son poco utilizadas.

Desde la clase externa no se puede acceder directamente a los miembros de

la clase anidada estática. La clase anidada estática es un miembro de la clase
externa y, por lo tanto, podemos asignarle el modificador de acceso que crea-
mos oportuno.

Si quisiéramos instanciar un objeto de la clase anidada estática, deberíamos

hacer:

4.4.2. Inner class

Una clase interna (inner class) es una clase anidada no estática. Su uso más ha-
bitual es proporcionar una clase que solo se utiliza dentro de su clase externa.
Se declara de la manera siguiente:

Para crear una instancia de la clase interna, primero se debe crear el objeto de
la clase externa:
© FUOC • PID_00273929 165 Guía de Java

Desde la clase interna se puede acceder directamente a cualquier miembro de

la clase externa.

La clase interna es un miembro de la clase externa y, por lo tanto, podemos

asignarle el modificador de acceso que creamos oportuno.

Dentro de la categoría inner classes, existen dos variantes: las clases internas
locales y las clases internas anónimas. Dejamos en vuestras manos la profun-
dización en estas dos variantes.

4.5. Anotaciones

Una anotación es un elemento que proporciona información extra (metada-

tos) sobre un elemento de nuestro código. Su presencia no tiene un efecto di-
recto en la lógica de nuestro código.

Los usos más habituales de las anotaciones son:

• Proporcionar información al compilador: gracias al uso de una anotación,

el compilador puede ayudarnos a detectar errores o a suprimir avisos (war-
nings) que ya conocemos.

• Algunas herramientas son capaces de procesar la información proporcio-

nada por las anotaciones para generar código, ficheros, etc.

• Algunas anotaciones están disponibles en tiempo de ejecución.

El formato básico de una anotación es el símbolo @ seguido del nombre de la

anotación, por ejemplo, @Override.

La anotación puede ser simplemente su nombre (sin elementos adicionales):

© FUOC • PID_00273929 166 Guía de Java

O incluir elementos:

Podemos asignarle a un mismo elemento más de una anotación:

Java trae consigo un conjunto predefinido de anotaciones que están ubicadas

en los packages java.lang y java.lang.annotation. Por ejemplo:

Anotación Descripción

@Deprecated Indica que el elemento (es decir, método, clase o atribu-

to) marcado no debe ser usado nunca más. El compila-
dor genera un aviso.

@Override Avisa al compilador de que el método con dicha anota-

ción es una sobrescritura de un método de una super-
clase. No es obligatorio usar esta anotación, pero sí nos
ayuda a la hora de detectar errores, ya que el compila-
dor verificará que se haga la sobrescritura correctamen-
te.

@SuppressWarning Pide al compilador que no avise de según qué warnings.

@SafeVarargs Solo se puede usar con métodos con varargs. Sirve para
que no se realicen operaciones inseguras sobre el pará-
metro varargs.

@FunctionalInterface Indica que la interfaz sea considerada funcional.

4.5.1. Creación de una anotación personalizada

Para crear nuestra propia anotación debemos crear un fichero .java con el
nombre de la anotación y usar en él la sintaxis siguiente:

Un ejemplo:
© FUOC • PID_00273929 167 Guía de Java

Como podemos ver:

• Usamos la anotación @interface para crear una anotación.

• Cada elemento es un método sin parámetros ni throws.

• Los tipos de retorno de los métodos son tipos primitivos, String, Class,
enum, anotaciones y arrays de los tipos anteriores.

• Los métodos pueden tener un valor por defecto. Lo indicamos con la pa-
labra clave default.

En la creación de nuestra anotación podemos añadir algunas anotaciones que

vienen en el package java.lang.annotation.

Anotación Descripción

@Retention Indica cuándo se puede acceder a la anotación.

@Documented Indica que la información de la anotación debe ser añadida al ge-

nerar documentación con javadoc.

@Target Especifica el tipo de elemento al que se va a asociar la anotación.

@Inherited Indica que la anotación será heredada automáticamente.

@Repeatable Indica que la anotación puede utilizarse más de una vez para un
mismo elemento.

Veamos un ejemplo:

La anotación @InfoMethod que acabamos de definir solo se puede aplicar a

métodos y se puede acceder a ella en tiempo de ejecución.
© FUOC • PID_00273929 168 Guía de Java

4.5.2. Uso de una anotación personalizada

Vamos a ver cómo usar la anotación @InfoMethod creada en el apartado an-

terior:

Debemos fijarnos que cuando usamos una anotación, los elementos de esta
van ubicados dentro de paréntesis.

4.6. Método requireNonNull

Con JDK 7 se añadió a la clase raíz Object un método estático denominado

requireNonNull que internamente realiza lo siguiente:

Es decir, comprueba que el objeto pasado por parámetros no sea null. Si lo

es, lanza una excepción de tipo NullPointerException. En caso de no ser
null, devuelve el objeto en sí.

Existe una sobrecarga de este método que permite indicarle el mensaje de error
a mostrar si se lanza la excepción de tipo NullPointerException.

Así pues el siguiente código:

Puede ser simplificado usando requireNonNull:

© FUOC • PID_00273929 169 Guía de Java

5. Extras

5.1. Javadoc

En los archivos Java se pueden poner comentarios en un formato especial que

permite mediante el comando javadoc generar de forma automática docu-
mentación de los paquetes, clases, interfaces, atributos y métodos de nuestro
proyecto. La sintaxis de Javadoc es:

En el caso de los comentarios normales (es decir, // y /* */), Eclipse los

colorea en verde. Sin embargo, los comentarios en formato Javadoc los colorea
en azul. Así podemos distinguir visualmente entre comentarios normales y de
Javadoc.

Para las clases se suele hacer una breve descripción de esta y usar las etiquetas
@author y @version. La primera indica el nombre del autor que ha realizado
la clase (si hay más de uno, se pueden usar tantas etiquetas @author como
autores). Por su parte, la segunda etiqueta informa de la versión de la clase
(una clase puede verse modificada en el tiempo y, en un momento concreto,
se puede considerar que es una nueva versión).

En el caso de los métodos (incluidos los constructores), la primera parte del

comentario Javadoc es una descripción de lo que hace el método (de forma
breve), y las siguientes líneas consisten en un conjunto de etiquetas Javadoc.
Las etiquetas más usadas en los métodos son:

Etiqueta Descripción

@param Descripción de un parámetro. Cada parámetro tiene su etiqueta @param.

@return Descripción de lo que devuelve el método si el retorno no es void.

@throws Descripción de la excepción que puede propagar. Habrá una etiqueta throws
por cada tipo de excepción.

@see Enlace a la documentación de otra clase, ya sea de Java, del mismo proyecto o
de otro.

@since Indica desde cuándo existe este método. Puede ser cualquier texto, pero nor-
malmente es el número de versión de la clase.
© FUOC • PID_00273929 170 Guía de Java

Etiqueta Descripción

@depreca- Marca el método como obsoleto. Solo se mantiene por compatibilidad y, por lo
ted tanto, aún se puede usar. Es posible que en futuras versiones de la clase el méto-
do desaparezca definitivamente y no se pueda usar.

En el caso de los atributos de una clase, simplemente se pone su descripción

con /** */ justo antes de su declaración. Veamos un ejemplo:

Una vez escritos los comentarios, existen varias maneras de crear la documen-
tación. Vamos a ver dos de ellas.

5.1.1. Generar javadoc por línea de comandos

Podemos crear la documentación por línea de comandos, es decir, sin usar

ningún IDE como Eclipse. Para ello, tenemos que abrir un consola de coman-
dos (cmd) y ubicarnos donde tengamos los ficheros .java. A partir de aquí
podemos:

1) Generar la documentación de una clase concreta (por ejemplo,

Program.java):

2) O, lo más habitual, generar la documentación de todos los .java que haya

en el directorio:
© FUOC • PID_00273929 171 Guía de Java

Es decir, de este segundo modo generaremos la documentación de toda la apli-

cación (o programa).

En cualquiera de las dos versiones podemos indicar que nos genere toda la
documentación en un directorio específico (si no existe, lo crea) mediante el
comando -d nombreDirectorio:

Una vez ejecutado correctamente el comando javadoc, solo tenemos que

abrir el archivo index.html con un navegador web para ver la documenta-
ción.

Finalmente, cabe indicar que cuando se llama al comando javadoc por línea
de comandos, solo genera la documentación para los atributos y métodos que
son públicos y protegidos. Si queremos que incluya también los privados, se
lo debemos indicar de la manera siguiente:

Dar información sobre los atributos y métodos privados es útil si estamos com-
partiendo información con alguien que debe programar aquella clase por den-
tro. En caso contrario, ¡no se deben dar detalles de los atributos y métodos
privados! ¡Esta es la gracia de la encapsulación!

5.1.2. Generar javadoc con Eclipse

Para generar la documentación con javadoc en Eclipse, debemos seguir los Nota
pasos siguientes:
Es importante seleccionar el
proyecto, ya que si tenemos
1) Ir al menú superior de Eclipse y escoger «Project → Generate Javadoc...». seleccionada una clase, solo
nos hará el Javadoc de esa cla-
se.
Figura 32
© FUOC • PID_00273929 172 Guía de Java

2) Nos aparecerá una ventana como la que se muestra en la figura 33.

Figura 33

3) Si el campo «Javadoc command» está vacío, debemos indicar pulsando el

botón «Configure...», la ruta de nuestro javadoc.exe, que se encuentra en la
carpeta de nuestro JDK (p. ej., C:\Program Files\Java\jdk-13.0.2\bin
\javadoc.exe).

4) Indicamos para qué proyectos deseamos generar la documentación (véase

recuadro granate en la figura 33) y en qué carpeta queremos guardar la docu-
mentación generada (véase recuadro verde en la figura 33).

5) Eclipse permite indicar para qué atributos y métodos se genera la documen-

tación (véase recuadro azul de la figura 33).

6) Una vez tenemos todo configurado, pulsamos el botón «Finish». Obviamen-

te, podemos clicar en el botón «Next» para personalizar el comportamiento
de javadoc.

7) Si dejamos la opción estándar, es posible que la primera vez nos aparezca

la ventana de diálogo que se muestra en la siguiente figura. Clicamos «Yes To
All».
© FUOC • PID_00273929 173 Guía de Java

Figura 34

8) Si hacemos «F5» (o botón derecho «Refresh») sobre el proyecto (no siempre

hace falta), veremos que ha aparecido una nueva carpeta llamada doc. Esta
carpeta contiene varios ficheros .html, que es el formato en que Javadoc ge-
nera la documentación.

9) Para ver correctamente la documentación generada, debemos ir a la carpeta

doc en el propio Eclipse, hacer botón derecho sobre el fichero index.html y
escoger la opción «Open With → Web browser». En la web que aparecerá, es-
cogemos la opción «Package» del menú superior y luego escogemos cualquier
clase para ver sus detalles. También podemos abrir este fichero con el navega-
dor web desde el workspace, es decir, sin usar Eclipse.

Como podemos imaginar, Eclipse hace por nosotros las llamadas al comando
javadoc explicadas en el apartado «Generar javadoc por línea de comandos»
según sea la configuración que le hemos indicado.

A continuación podemos ver cómo se muestra la documentación generada

con Javadoc en Eclipse para una clase llamada Tank.
© FUOC • PID_00273929 174 Guía de Java

Figura 35

5.2. JavaFX

5.2.1. Introducción

(24)
Las interfaces�gráficas�(GUI)24 son un elemento básico hoy en día. Java tie- Acrónimo de graphical user in-
terface, en inglés.
ne tres bibliotecas para hacer interfaces gráficas: AWT, Swing y JavaFX. Resu-
miendo mucho, se podría decir que Swing es más avanzado que AWT y que Ja-
vaFX ha llegado para ser el sustituto de Swing. Hasta hace relativamente poco,
Swing era la librería predominante, pero JavaFX está comenzando a ganarle
terreno. No obstante, en un programa podéis combinar componentes (es de-
cir, botón, campo de texto, desplegable, etc.) de ambas librerías, aunque no es
muy recomendable. Oracle no ha dado por obsoleto a Swing, pero parece ser
que no le va a incorporar mejoras en el futuro. Es por esto por lo que en esta
guía nos centraremos en JavaFX. Asimismo, con JDK 11 Oracle ha decidido
quitar del núcleo del JDK la librería JavaFX para que esta sea independiente y
tenga su propio ritmo de desarrollo, liberando así su evolución. Esto, eviden-
temente, conlleva algunos cambios, especialmente a la hora de configurar el
entorno de trabajo (por ejemplo, Eclipse).

Swing y JavaFX comparten muchas cosas, como es el uso de componentes

(también conocidos como widgets), pero tienen cosas totalmente diferentes
como, por ejemplo, la forma de trabajar, además de sus capacidades.

5.2.2. Configuración de JavaFX en Eclipse IDE

En este apartado vamos explicar, paso a paso, cómo configurar JavaFX en Eclip-
se.
© FUOC • PID_00273929 175 Guía de Java

1) Hay que asegurarse de tener instalado JDK 11 o superior y, además, que

lo tenemos establecido como compilador a usar en Eclipse (o en el proyecto
donde queramos usar JavaFX).

2) Como ahora JavaFX está fuera del núcleo de JDK, hay que ir a la siguiente
página web: https://gluonhq.com/products/javafx/.

3) En dicha página web instalaremos JavaFX�11 (Long Term Support) o versión

posterior. Aquí presentamos los pasos para Windows. Así pues, descargamos
la opción «JavaFX Windows SDK».

4) Descomprimimos el fichero donde creamos conveniente, por ejemplo, den-

tro de «Archivos de programa/Java».

5) Dentro de Eclipse vamos a la opción «Window» del menú superior y esco-

gemos la opción «Preferences».

6) Se abrirá una ventana y escogemos del menú de la izquierda la opción «Java

→ Build Path → User Libraries». Hacemos clic en el botón «New...».

Figura 36

6) En la nueva pantalla nos pide un nombre para la librería. Escribimos un

nombre que nos ayude a identificar la librería como, por ejemplo, «JavaFX11»
y hacemos clic en el botón «OK».
© FUOC • PID_00273929 176 Guía de Java

7) A continuación hacemos clic en el botón «Add External JARs...», buscamos

la ruta hasta el directorio de JavaFX11 que hemos descomprimido anterior-
mente. En ella hay tres subdirectorios. Hay que entrar en «lib» y escoger todos
los ficheros «jar» y no seleccionar el fichero «src.zip». Una vez seleccionados,
clicamos en «Abrir».

Figura 37

8) El resultado de hacer los pasos anteriores debe ser el que se muestra en la

figura 38. Si es así, hacemos clic en el botón «Apply and Close».

Figura 38

9) Después clicamos en el botón derecho sobre el proyecto y escogemos la

opción «Properties». En la ventana que se abrirá elegimos la opción «Java Build
Path» del menú izquierdo. En la parte central escogemos la pestaña «Libraries»
© FUOC • PID_00273929 177 Guía de Java

y a continuación «Modulepath». Después clicamos en «Add Library...» Luego

elegimos «User Libraries» de la ventana flotante, clicamos «Next», escogemos
«JavaFX11» y finalmente «Finish». Después clicamos en «Apply and Close».

10) Para que Eclipse, es decir JDK, detecte la librería JavaFX, hay que ir impor- Ved también
tando los paquetes que usemos de JavaFX en el fichero module-info.java. Si
Se ha hablado del fichero es-
no estamos usando este fichero para nada, lo más sencillo, entonces, es hacer pecial module-info.java
lo siguiente: vamos al fichero module-info.java y comentamos el código: en el apartado «Módulos» de
esta guía.

11) En este punto los errores relacionados con el uso de clases de la librería
JavaFX deberían desaparecer.

12) No obstante, aún no podemos ejecutar correctamente la aplicación, pues-

to que hay que configurar la ejecución. Para ello, vamos a «Run configurations
→ Arguments» y escribimos en «VM arguments» lo que se muestra a conti-
nuación.

Lo resaltado en rojo se debe cambiar por la ruta donde se ha descomprimido

JavaFX.

13) Ahora vamos al menú superior «Help → Install New Software...».

En el campo «Work with» de la ventana que aparecerá escribimos la di-
rección: https://download.eclipse.org/efxclipse/updates-released/3.5.0/site/ y
pulsamos «enter» para que Eclipse busque paquetes en esta dirección. Una
vez terminada la búsqueda, marcamos tanto «e(fx)clipse – install» como
«e(fx)clipse – single components».

13) Clicamos en el botón «Next». Aparecerá otra ventana donde también de-
bemos hacer clic en el botón «Next».

14) A continuación aparecerá una pantalla para que aceptemos la licencia.

Marcamos «I accept the terms...» y pulsamos en «Finish».

15) Eclipse instalará los paquetes. Cuando termine es posible que nos pida
reiniciar el IDE. Si este es el caso, lo hacemos.

16) A partir de ahora podremos crear proyectos que usen JavaFX. Al hacer «File
→ New → Other» nos aparecerá una carpeta llamada «JavaFX» con plantillas.
© FUOC • PID_00273929 178 Guía de Java

5.2.3. Modelo en JavaFX

Una de las ventajas de JavaFX es que usa el patrón MVC (Modelo-Vista-Con-

trolador) para crear los programas, lo cual es muy interesante. En esta guía (y
asignatura) no trabajaremos la parte «modelo» al estilo JavaFX, es decir, para
sacarle partido a todo el potencial de JavaFX. Esto os lo dejamos a vosotros,
por si queréis indagar en JavaFX. Si estáis interesados o interesadas, buscad los
conceptos properties y binding de JavaFX.

5.2.4. Vistas en JavaFX (parte visual)

En cuanto a las vistas, cabe señalar que estas, o bien se crean programando en
Java, o bien se crean mediante unos ficheros llamados FXML, que no dejan
de ser unos ficheros que contienen un código XML ad hoc para JavaFX. La
primera opción solo debe usarse para crear componentes (o toda la vista si
fuera necesario) en tiempo de ejecución (por ejemplo, mostrar un botón tras
marcar un checkbox). La segunda forma, la más habitual, se asemeja a otros
tipos de desarrollo, como es la creación de apps en Android (donde la parte
visual de la vista es un fichero XML y la parte de interacción de la vista es una
clase codificada en Java) o el front-end de una web (la parte visual hecha con
HTML+CSS y la parte interactiva que se comunica con el controlador hecha
en JavaScript).

Para que se vea más claro, pensad que cada pantalla/vista de vuestro programa
será un fichero FXML (parte visual) más un fichero Java (parte interactiva y
de comunicación con el controlador). Gracias a esto se logra separar/desaco-
plar lo visual (es decir, forma, estilo y ubicación de un botón) de la lógica (es
decir, funcionamiento/comportamiento del programa al hacer clic en un bo-
tón). Asimismo, como cada vista tiene un fichero Java para la parte interactiva,
desde él podremos añadir, mediante código, componentes a la vista si fuera
necesario, combinando así los dos modos de creación de componentes (esto
es, vía código y vía FXML).

(25)
Seguro que estáis pensando en que debe de ser muy laborioso hacer una inter- http://gluonhq.com/pro-
ducts/scene-builder/
faz si la tenemos que hacer escribiendo código FXML (que es un XML ad hoc).
Tenéis toda la razón, es muy arduo crear interfaces visuales mediante código
FXML y además «a ciegas». Por eso existen programas que ayudan a realizar
los ficheros FXML. Uno de estos programas es SceneBuilder.25 SceneBuilder
permite crear cada pantalla/vista de nuestro programa de manera visual, es
decir, arrastrando y soltando componentes en la escena. Una vez tengamos
la pantalla/vista con la apariencia que deseemos, solo tenemos que pedirle a
SceneBuilder que genere el fichero FXML que codifica la pantalla/vista que
hemos creado. ¡Así de simple!
© FUOC • PID_00273929 179 Guía de Java

Para instalar Scenebuilder, vamos a la siguiente web: https://gluonhq.com/

products/scene-builder/#download e instalamos SceneBuilder for Java 11 (sir-
ve para JDK 11 y superiores). En Windows recomendamos usar la versión ins-
talador, no el .jar.

Podemos trabajar con SceneBuilder en paralelo con Eclipse. Es decir, creamos

los ficheros FXML con SceneBuilder y luego los copiamos en nuestro proyecto
de Eclipse. Pero también podemos hacer algo mejor, que SceneBuilder y Eclipse
se entiendan. Es decir, que desde Eclipse creemos un fichero FXML nuevo,
lo abramos y modifiquemos con SceneBuilder desde Eclipse, y los cambios se
vean reflejados automáticamente en el proyecto. Para lograr que SceneBuilder
y Eclipse trabajen colaborativamente, hay que seguir los pasos que detallamos
a continuación:

1) Dentro de Eclipse vamos a la opción «Window» del menú superior y esco-

gemos la opción «Preferences».

2) En la ventana que aparecerá, buscamos en el listado de la izquierda la opción

«JavaFX».

3) La seleccionamos. A la derecha debería aparecer un único campo donde

podemos indicar dónde está ubicado el ejecutable de SceneBuilder (véase la
figura 39). Lo indicamos y hacemos clic en el botón «Apply and Close».

Figura 39

Gracias a esta configuración podremos hacer botón derecho sobre cualquier

fichero FXML en Eclipse y escoger la opción «Open with SceneBuilder» para
que se abra dicho fichero en el software de edición SceneBuilder. Además, si
guardamos los cambios en SceneBuilder, estos se verán reflejados en nuestro
© FUOC • PID_00273929 180 Guía de Java

proyecto Eclipse. A veces hay que refrescar el proyecto (por ejemplo, haciendo
F5 en Eclipse). Si en vez de abrir un fichero FXML con SceneBuilder, lo abrimos
haciendo doble clic, entonces veremos el código FXML en el editor de Eclipse.

(26)
Las vistas, es decir, cada FXML, puede ser personalizada mediante un fichero Acrónimo de cascade style
sheet.
CSS (o incluso varios FXML pueden compartir un mismo fichero CSS). Un fi-
chero CSS26 es un documento en el que se especifican diferentes estilos, desde
generales hasta concretos (por ejemplo, para un botón determinado). Estos
ficheros son esenciales cuando se programan webs, ya que facilitan la escala-
bilidad, el mantenimiento y la gestión de posibles cambios. JavaFX usa CSS
aunque utiliza sus propias propiedades, a pesar de que muchas son similares a
las propiedades web, por lo que es sencillo usarlas si se sabe CSS web. Nosotros
esto no lo trataremos aquí.

Si en un fichero FXML seleccionamos en SceneBuilder un elemento a través del

lateral izquierda («Document → Hierarchy») y luego miramos el panel «Pro-
perties» que hay a la derecha del programa (véase figura 40), dentro encontra-
remos un apartado llamado «JavaFX CSS». Este apartado permite indicar estilos
directamente (apartado «Style»), asignarle una clase de un fichero CSS y añadir
un fichero CSS. Justo en el apartado «Stylesheets», hemos puesto «app.css»,
que es el nombre del fichero CSS de la aplicación. En el caso del color y el
tamaño de un texto (por ejemplo, label) o un botón (por ejemplo, button),
SceneBuilder ya trae un apartado para ellos dentro de «Properties» sin necesi-
dad de usar propiedades CSS.

Figura 40

5.2.5. Vistas en JavaFX (parte interactiva)

Hasta ahora solo hemos visto cómo crear la parte visual de una interfaz/vis-
ta/pantalla, pero ¿cómo le damos vida? ¿Cómo interactúa el usuario con ella?
Pues bien, esto se hace mediante eventos (tanto en JavaFX como en Swing y
AWT). Esto implica una nueva forma de programar que es denominada pro-
gramación�orientada�a�eventos�(POE). En la POE, el flujo de ejecución del
programa viene definido por las acciones/eventos (por ejemplo, clic, doble
clic, presionar una tecla, etc.) realizados por un agente externo al programa,
© FUOC • PID_00273929 181 Guía de Java

por ejemplo, un usuario, otro programa, etc. La POE no es incompatible con la

POO. De hecho, con Java, seguiremos trabajando con objetos que son capaces
de responder a eventos. Así pues, POO y POE se complementan. Por ejemplo,
tendremos un objeto de tipo Button que estará escuchando (con lo que se
denomina un Listener) que ocurra un evento. Cuando ocurra un evento con-
creto, como puede ser hacer clic en el botón, si tiene codificado un método
asociado a «hacer clic», dicho método se ejecutará al producirse el evento. Es
decir el Listener invocará al método asociado.

Como ya hemos dicho, una pantalla/interfaz/vista tendrá, por un lado, su fi-

chero que define la parte visual (es decir, un fichero FXML) y, por otro, un
fichero Java que será el encargado de gestionar los eventos producidos sobre
la vista (es decir, fichero FXML) y seguir la lógica del programa según estos
eventos. Normalmente, a los ficheros Java encargados de la parte interactiva
de un fichero visual FXML, se les suele llamar igual que al fichero FXML al que
«dan vida», pero finalizados con la coletilla Controller. Así sabemos que el
fichero Java encargado de la parte interactiva de un fichero FXML se llama
igual que el fichero FXML pero con la coletilla Controller. A partir de ahora
llamaremos controladores a estos ficheros.

Es importante destacar que SceneBuilder solo detecta/encuentra las cla-

ses (es decir, ficheros Java) que están en el mismo paquete que el fichero
FXML que se está editando.

Como ya habréis podido intuir, es esencial vincular un controlador/parte in-

teractiva (fichero Java) a una vista (fichero FXML). Esto se puede hacer de dos
formas:

1)�Editando�directamente�el�código�XML�del�fichero�FXML: abrimos el fi-

chero FXML con Eclipse. En el tag/etiqueta raíz se puede añadir un campo/atri-
buto llamado «fx:controller», cuyo valor es el nombre de la clase controladora
(incluyendo el paquete en el que está ubicado).

2)� Usando� SceneBuilder: abrimos el fichero FXML con SceneBuilder. Hay

una opción llamada «Controller» dentro de la opción «Document» del menú
izquierdo (véase figura 41). En ella hay un campo denominado «Controller
class» en el que podemos asignarle la clase controladora. SceneBuilder detec-
tará todas aquellas clases que estén en el mismo paquete que el fichero FXML
que se está editando. Para cada FXML debemos escoger del desplegable la op-
ción (es decir, controlador) que corresponda.
© FUOC • PID_00273929 182 Guía de Java

Figura 41

En la clase controladora crearemos todos los métodos y atributos que quere-

mos que interactúen con la parte visual de la vista. Es una buena práctica pre-
ceder a todos los atributos y métodos del controlador que queramos que sean
accesibles desde las vistas con la anotación @FXML. Los atributos y métodos
precedidos con @FMXL, aunque sean privados, serán visibles para la vista don-
de usemos el controlador que los contiene. Si un atributo o método es público,
no es necesario usar @FXML, pero sí recomendable.

Imaginad que creamos un método llamado handleReturn que sirve para volver a la vis-
ta/pantalla anterior a la que estamos. En este momento debemos vincular un elemento
de la interfaz con el método handleReturn. Para hacer esta asignación/vinculación, lo
más cómodo es usar SceneBuilder. Abrimos el fichero FXML con SceneBuilder, seleccio-
namos un Button que hayáis puesto en la interfaz y en el apartado «Code» del lateral
derecho buscamos la opción «On Mouse Released» (véase figura 42). Allí hemos escri-
to/seleccionado el nombre de método a ejecutar, en este caso, handleReturn. Esta asig-
nación también la podéis ver reflejada, obviamente, en el código FXML.

Figura 42

Finalmente, si queremos que un elemento de la interfaz sea accesible desde un

controlador (es decir, código Java), entonces debemos asignarle un identifica-
dor. Para ello, en SceneBuilder seleccionamos uno de los elementos de la in-
terfaz gráfica, y en el menú derecho, en la opción «Code», encontraremos un
© FUOC • PID_00273929 183 Guía de Java

campo llamado «fx:id». Lo habitual es ponerle como nombre uno que también
usemos como atributo en el controlador (precedido de @FXML). De esta forma,
el controlador puede acceder a este componente para modificarlo o consul-
tarlo, y la vista a la información del atributo de la clase de tipo controladora.
O dicho de otro modo, el atributo de la clase controladora hace referencia al
componente de la vista porque tienen el mismo nombre y porque en la clase
controladora hemos puesto @FXML delante del atributo.

Figura 43

En el ejemplo que podemos ver en la figura anterior, el nombre que le hemos

dado a la ListView es squadList. En el código Java del controlador tendre-
mos un atributo llamado squadList de tipo ListView y precedido por la
anotación @FXML.

5.3. JUnit 5

La librería JUnit permite a los desarrolladores hacer test unitarios. En este apar-
tado veremos qué es un test unitario y cómo usar JUnit con Eclipse.

5.3.1. Test unitario

Antes de nada, vamos a definir qué es un test unitario.

Los test�unitarios (unit tests) son las pruebas de más bajo nivel en la
programación. Con ellas se comprueba el funcionamiento de las uni-
dades lógicas independientes, normalmente los métodos. Son pruebas
muy rápidas de llevar a cabo y son las que los desarrolladores están
constantemente pasando para verificar que su software funciona ade-
cuadamente.

Estos son los test más importantes. Cada test unitario es un paso que andamos
en el camino de la implementación correcta del software. Los desarrolladores
utilizan los test unitarios para asegurarse de que el código funciona como es-
© FUOC • PID_00273929 184 Guía de Java

peran que funcione, al igual que el cliente usa los test de aceptación/cliente
para asegurarse de que los requisitos de negocio se cumplan con el software
como se espera que lo haga. Todo test unitario debe ser:

• Atómico: significa que el test unitario prueba la mínima cantidad de fun-

cionalidad posible. Esto es, probará un único comportamiento de un mé-
todo de una clase. Como ya sabéis, un método puede presentar distintas
respuestas ante distintas entradas o distinto contexto. El test unitario se
ocupará exclusivamente de uno de esos comportamientos, es decir, de un
único camino de ejecución.

• Independiente: significa que un test no puede depender de otros para

producir un resultado satisfactorio. No puede ser parte de una secuencia
de test que se deba ejecutar en un determinado orden. Debe funcionar
siempre igual independientemente de que se ejecuten otros test o no.

• Inocuo: esta propiedad significa que no altera el estado del sistema. Al

ejecutarlo una vez, produce exactamente el mismo resultado que al ejecu-
tarlo veinte veces. Además, no altera la base de datos, ni envía e-mails ni
borra ficheros, ni los crea (y si los tiene que crear, los debe borrar). Un test,
una vez ejecutado, debe comportarse como si no se hubiera ejecutado.

• Rápido: puesto que ejecutamos un gran número de test cada pocos mi-
nutos, resultaría muy poco productivo tener que esperar unos cuantos se-
gundos cada vez. Un único test tiene que ejecutarse en una pequeña frac-
ción de segundo.

5.3.2. Configuración del plugin JUnit

Al instalar Eclipse IDE se realiza la instalación de JUnit, una biblioteca que

viene por defecto en Eclipse. No obstante, a continuación se ilustran los pasos
necesarios para configurar un entorno de trabajo con pruebas. Algunos aspec-
tos o nombres pueden cambiar entre lo que se explica en este tutorial y lo
que os podéis encontrar en vuestro entorno de trabajo. En tal caso, debéis ser
capaces de hacer las analogías pertinentes.

1) Imaginemos que tenemos un proyecto ya creado llamado «JUnitTest» que

está vacío, es decir, no contiene ningún fichero .java. Si ahora queremos in-
dicar que este proyecto debe permitir JUnit, entonces debemos hacer botón
derecho sobre el nombre del proyecto en el «Package Explorer» y escoger «Pro-
perties». En la ventana que nos aparecerá debemos ir a la opción «Java Build
Path» del menú de la izquierda y, seguidamente, escoger la pestaña «Libraries»
en la zona central y seleccionar «Classpath». A continuación hacemos clic en
el botón «Add Library» (véase figura 44).
© FUOC • PID_00273929 185 Guía de Java

Figura 44

2) En la ventana que nos aparecerá seleccionamos «JUnit» del listado y pulsa-

mos en «Next» (véase figura 45).

Figura 45

(27)
3) En la siguiente pantalla escogemos la versión más alta de JUnit27 y decimos En el momento de la creación
de esta guía, versión 5.
«Finish» (véase figura 46). A continuación vemos la pantalla de la figura 44 con
JUnit añadida. Pulsamos en «Apply and Close». Ahora en el «Package Explorer»
vemos que se ha añadido la librería JUnit 5. A partir de aquí ya podemos usar
JUnit para hacer test unitarios.
© FUOC • PID_00273929 186 Guía de Java

Figura 46

5.3.3. Usando JUnit

Vamos a ver un ejemplo dentro del proyecto «JUnitTest» mencionado en el

apartado anterior.

1) Ahora añadimos una nueva clase llamada MainApplication que conten-

drá un método main. El código del fichero MainApplication.java es el que
se muestra en la figura 60.

Figura 47

2) Ahora añadimos una nueva clase llamada Person. Una vez creado el fichero
Person.java, escribimos los atributos, como se muestra en la figura 48.
© FUOC • PID_00273929 187 Guía de Java

Figura 48

3) Para generar los getters y setters de la clase Person usaremos un atajo de

Eclipse. Estando activado el fichero Person.java en el editor de código, va-
mos a la opción «Source» del menú superior de Eclipse y seleccionamos la op-
ción «Generate Getters and Setters...» (véase figura 49). En la ventana que nos
aparecerá marcamos todos los atributos y pulsamos en «OK». Rápido, ¿verdad?

Figura 49

4) El resultado es el que se muestra en la figura 50.

© FUOC • PID_00273929 188 Guía de Java

Figura 50

5) Añadimos código en el constructor por defecto, añadimos un constructor

con argumentos y cambiamos el código de setAge tal y como se muestra en
la figura 51.

Figura 51

6) También cambiamos el código de MainApplication para que capture la

excepción de Person (véase la figura 52).

Figura 52
© FUOC • PID_00273929 189 Guía de Java

7) Ahora, en la ventana «Package Explorer», hacemos botón derecho con el

ratón encima de Person.java y hacemos «New → JUnit Test Case» (véase
figura 53).

Figura 53

8) De este modo, nos solicita los métodos del código para los cuales se quiere
generar la plantilla de pruebas (véase figura 54). En esta ventana hacemos clic
en «Next» (la opción «New JUnit Jupiter Test» es lo mismo que decir «JUnit 5»).

Figura 54
© FUOC • PID_00273929 190 Guía de Java

9) En la ventana que nos aparecerá seleccionamos los métodos que queremos

testear. Por ejemplo, seleccionamos la clase Person para así seleccionar, de
una vez, todos sus métodos (véase figura 55). Una vez lo tengamos, hacemos
clic en el botón «Finish».

Figura 55

10) Ahora en el «Package Explorer» nos ha aparecido una nueva clase llamada
PersonTest.java (véase figura 56) con el aviso de error. Una forma de quitar
los errores es eliminando el fichero module-info.java. Si miramos el códi-
go de PersonTest.java, veremos que son pruebas relacionadas 1:1 con los
métodos de la clase Person y que inicialmente serán fallidas para recordarnos
que deben ser implementadas. De hecho, sale el texto "Not yet implemen-
ted!". Podremos añadir más métodos de prueba anteponiendo la anotación
@Test delante de la firma de dicho método. Gracias a @Test ese método es
considerado prueba unitaria. Fijaos que si un método está sobrecargado, como
puede ser el constructor, para diferenciarlo le añade como coletilla los tipos de
los argumentos que recibe. Por ejemplo, testPersonIntStringString es el
método de testeo que crea JUnit para el constructor con argumentos, Person
(int age, String name, String surname).
© FUOC • PID_00273929 191 Guía de Java

Figura 56

11) A continuación se deben ejecutar las pruebas para comprobar que NO se

han superado (lo cual es lógico ahora mismo). En este caso se debe marcar el
fichero de test (en nuestro ejemplo PersonTest.java) y con el botón dere-
cho del ratón pulsar «Run As → JUnit Test» (véase figura 57).

Figura 57
© FUOC • PID_00273929 192 Guía de Java

12) Ahora nos aparece una pantalla en la que se muestra los test que NO se han
superado y el número de test que han fallado. En este caso hemos configurado
ocho test para ocho métodos de los que queríamos comprobar su funcionali-
dad y todas son fallidas (véase figura 58). Es posible que en Windows 10 os
salte una pantalla de aviso del Firewall que deberéis aceptar.

Figura 58

13) Ahora vamos a codificar el método testSetAge (véase figura 59).

Figura 59

14) Mirando el código de la figura 59, se puede ver que el primer paso consiste
en cambiar la firma del método para que lance/propague las excepciones que
recibe su código, en este caso, el método setAge lanza Exception. Ya en el
cuerpo del método, lo primero es crear un objeto que disponga del método que
se quiere comprobar. Por consiguiente, se crea un objeto de la clase Person.
© FUOC • PID_00273929 193 Guía de Java

Una vez se dispone de un objeto Person válido, se comienza a invocar los

métodos que se quieren comprobar para chequear que los valores de que dis-
pone son correctos. Observamos que sobre un objeto (instance) de la clase
Person se invoca el método setAge (el cual se quiere testear). En este caso se
ha invocado con un valor de diez años.

Nuestra persona por consiguiente debería tener una edad de diez años. Para
comprobar que es así, el framework JUnit aporta métodos especiales denomi-
nados asserts que nos deben devolver valores booleanos (true o false) para
poder comprobar que los métodos funcionan adecuadamente. Por ejemplo, se
hace uso del método assertEquals, el cual está comprobando que el valor
10 es igual que el valor obtenido por instance.getAge().

Más adelante se quiere comprobar si el método setAge lanza la excepción que

tiene programada cuando el valor introducido es negativo. Para especificar
dicha operación en JUnit 5 se hace uso del nuevo método assertThrows que
devuelve un objeto de tipo Exception cuyo mensaje se puede comparar con
el método assertEquals que ya hemos visto.

Observamos que el primer parámetro de assertThrows es el tipo de excep-

ción que se espera. En este ejemplo, esperamos la clase Exception.class. En
caso de que se disponga de una clase específica para excepciones (por ejemplo,
PersonException), bastaría con especificar ahí la clase de la excepción que
se espera (por ejemplo, PersonException.class). El segundo parámetro es
una expresión lambda. Finalmente, en la segunda sentencia, la excepción de-
vuelta por assertThrows es comparada mediante su mensaje (getMessage)
con el mensaje esperado. Para que esto funcione hay que añadir el correspon-
diente import:

15) Si volvemos a ejecutar «Run As → JUnit Test», veremos que ahora solo
tenemos siete test fallidos, en vez de ocho. En el listado, testSetAge aparece
con un visto/check verde, lo que significa que ha pasado la prueba correcta-
mente.
© FUOC • PID_00273929 194 Guía de Java

Figura 60

16) Si hacemos clic en alguno de los métodos fallidos en la ventana JUnit que
se muestra en la figura 58, en la parte inferior llamada «Failure Trace», se nos
indica dónde ha fallado dicho método/test. Cuando todos los métodos de test
de la clase PersonTest superen las pruebas, la franja roja se volverá verde y
todos los métodos tendrán el visto/check verde al lado. Además pondrá Runs:
8/8, Errors: 0, Failures: 0. Gracias al uso de los test sabemos que
las clases se comportan como se espera que lo hagan. Si vamos codificando
y pasamos los test y uno que no fallaba ahora falla, podremos detectarlo a
tiempo.
© FUOC • PID_00273929 195 Guía de Java

Bibliografía
Java Tutorials Learning Paths [en línea] [consulta: 3 de septiembre de 2020]. Disponible en:
https://docs.oracle.com/javase/tutorial/tutorialLearningPaths.html.

Niemeyer, Patrick; Knudsen, Jonathan (2002). Learning Java (Java Series) (2.ª ed.). Esta-
dos Unidos: O’Reilly Media, Inc.

Niemeyer, Patrick; Knudsen, Jonathan (2013). Learning Java (Java Series) (4.ª ed.). Esta-
dos Unidos: O’Reilly Media, Inc.

Sierra, Kathy; Bates, Bert (2009). Head First Java. A Brain-Friendly Guide (2.ª ed.). Estados
Unidos: O’Reilly Media, Inc.

Van der Linden, Peter (2004). Just Java 2 (6.ª ed.). Estados Unidos: Prentice Hall, PTG.