Java
¡Esta es la guía práctica y actualizada sobre Java que estabas buscando! Tanto si eres principiante, como si estás pasando a Java desde otro lenguaje o simplemente quieres refrescar tus conocimientos de Java, este es el único libro que necesitas. Obtendrás una base sólida sobre los fundamentos del lenguaje Java, incluyendo clases, objetos, matrices, cadenas y excepciones. También aprenderás temas más avanzados: subprocesos, algoritmos, XML, pruebas JUnit y mucho más. ¡Este libro no puede faltar en la estantería de ningún programador Java!
- Guía completa de Java Platform, Standard Edition 17
- Comprender el lenguaje Java, desde los principios básicos hasta los conceptos avanzados.
- Trabaja con expresiones, declaraciones, clases, objetos y mucho más.
- Descarga y consulta ejemplos prácticos de código.
Aprenderás sobre:
- Conceptos básicos de Java:
Conoce el funcionamiento interno de Java, desde clases y objetos hasta estructuras de datos y algoritmos. ¡Este libro está actualizado para Java SE 17!
- Temas avanzados:
¿Ya dominas los conceptos básicos? Descubre todo lo que Java puede hacer, desde aritmética de punto flotante hasta marcos de pruebas, subprocesos, gestión de bases de datos y mucho más.
- Ejemplos prácticos:
Adquiera experiencia práctica con Java utilizando programas descargables probados y comprobados. Estos ejemplos de código le permiten avanzar en el libro, poniendo a prueba sus nuevas habilidades y conocimientos a lo largo del camino.
Aspectos Destacados:
- Clases y objetos
- Matrices
- Manejo de excepciones
- Programación orientada a objetos
- Caracteres y cadenas
- Genéricos
- Biblioteca de clases
- Programación concurrente
- Estructuras de datos
- Expresiones lambda
- Pruebas JUnit
- Herramientas JDK
Ver Tabla de Contenidos Completa
- Prefacio
- Grupo destinatario
- Lo que este libro no es
- Mi vida y Java, o «¿Por qué un libro sobre Java?»
- Software y versiones
- ¿Qué versión de Java utilizar?
- Cómo utilizar este libro para aprender
- Estrategias de aprendizaje personal
- Centrarse en lo esencial
- Secciones especiales
- Tareas
- Estructura de este libro
- Convenciones
- Listado de programas
- Documentación sobre la interfaz de programación de aplicaciones en este libro
- Programas ejecutables
- Agradecimientos
- Recursos para este libro
- Comentarios
- 1 Introducción
- 1.1 Antecedentes históricos
- 1.2 Sobre la popularidad de Java: las características clave
- 1.2.1 Código de bytes
- 1.2.2 Ejecución del código de bytes a través de una máquina virtual
- 1.2.3 Independencia de la plataforma
- 1.2.4 Java como lenguaje, entorno de ejecución y biblioteca estándar
- 1.2.5 Orientación a objetos en Java
- 1.2.6 Java está muy extendido y es muy conocido
- 1.2.7 Java es rápido: optimización y compilación justo a tiempo
- 1.2.8 Punteros y referencias
- 1.2.9 ¡Saca la basura, recolector de basura!
- 1.2.10 Manejo de excepciones
- 1.2.11 La gama de bibliotecas y herramientas
- 1.2.12 Sintaxis relativamente sencilla
- 1.2.13 Abandonar conceptos controvertidos
- 1.2.14 Java es código abierto
- 1.2.15 Para qué Java es menos adecuado
- 1.3 Java frente a otros lenguajes*
- 1.3.1 Java y C(++)
- 1.3.2 Java y JavaScript
- 1.3.3 Unas palabras sobre Microsoft, Java y J++
- 1.3.4 Java y C#/.NET
- 1.4 Desarrollo posterior y pérdidas
- 1.4.1 El desarrollo de Java y sus perspectivas de futuro
- 1.4.2 Funciones, mejoras y solicitudes de especificaciones
- 1.4.3 Applets
- 1.4.4 JavaFX
- 1.5 Plataformas Java
- 1.5.1 Plataforma Java, Edición Estándar
- 1.5.2 Plataforma Java, Micro Edition: Java para los más pequeños
- 1.5.3 Java para los más, más pequeños
- 1.5.4 Java para los grandes: Jakarta EE (antes Java Platform, Enterprise Edition)
- 1.5.5 Java en tiempo real
- 1.6 Plataforma Java, Edición Estándar, Implementaciones
- 1.6.1 OpenJDK
- 1.6.2 Oracle JDK
- 1.7 Instalación del kit de desarrollo Java
- 1.7.1 Instalación de Oracle JDK en Windows
- 1.8 Compilación y prueba del primer programa
- 1.8.1 Un programa de números cuadrados
- 1.8.2 La ejecución del compilador
- 1.8.3 El entorno de tiempo de ejecución
- 1.8.4 Problemas comunes con compiladores e intérpretes
- 1.9 Entornos de desarrollo
- 1.9.1 IntelliJ IDEA
- 1.9.2 Entorno de desarrollo integrado Eclipse
- 1.9.3 NetBeans
- 1.10 Lecturas complementarias
- 2 Conceptos lingüísticos imperativos
- 2.1 Elementos del lenguaje de programación Java
- 2.1.1 Fichas
- 2.1.2 Codificación de texto mediante caracteres Unicode
- 2.1.3 Identificadores
- 2.1.4 Literales
- 2.1.5 Palabras clave (reservadas)
- 2.1.6 Resumen del análisis léxico
- 2.1.7 Comentarios
- 2.2 De las clases a las declaraciones
- 2.2.1 ¿Qué son las declaraciones?
- 2.2.2 Declaración de clase
- 2.2.3 El viaje comienza con main(String[])
- 2.2.4 La primera llamada al método: println(...)
- 2.2.5 Instrucciones atómicas y secuencias de instrucciones
- 2.2.6 Más información sobre print(...), println(...), y printf(...) para la salida en pantalla
- 2.2.7 Documentación de la interfaz de programación de aplicaciones
- 2.2.8 Expresiones
- 2.2.9 Declaraciones de expresión
- 2.2.10 Primeras ideas sobre la orientación a objetos
- 2.2.11 Modificadores
- 2.2.12 Agrupación de sentencias con bloques
- 2.3 Tipos de datos, tipificación, variables y asignaciones
- 2.3.1 Descripción general de los tipos de datos primitivos
- 2.3.2 Declaraciones de variables
- 2.3.3 Detección automática de tipos con var
- 2.3.4 Variables finales y el modificador final
- 2.3.5 Entradas de la consola
- 2.3.6 Valores de verdad
- 2.3.7 Tipos de datos enteros
- 2.3.8 Guiones bajos en números
- 2.3.9 Caracteres alfanuméricos
- 2.3.10 Los tipos de datos float y double
- 2.3.11 Nombres buenos, nombres malos
- 2.3.12 No hay inicialización automática de variables locales
- 2.4 Expresiones, operandos y operadores
- 2.4.1 Operador de asignación
- 2.4.2 Operadores aritméticos
- 2.4.3 Menos y más unarios
- 2.4.4 Incremento y decremento prefijo o posfijo
- 2.4.5 Asignación con operación (operador de asignación compuesta)
- 2.4.6 Operadores relacionales y operadores de igualdad
- 2.4.7 Operadores lógicos: NOT, AND, OR y XOR
- 2.4.8 Operadores de cortocircuito
- 2.4.9 El rango de los operadores en el orden de evaluación
- 2.4.10 Tipificación (Casting)
- 2.4.11 Plus sobrecargado para cadenas
- 2.4.12 Operadores que faltan*
- 2.5 Instrucciones condicionales o distinciones de casos
- 2.5.1 Ramificación con la instrucción if
- 2.5.2 Elegir la alternativa con una instrucción if-else
- 2.5.3 El operador de condición
- 2.5.4 La instrucción switch ofrece una alternativa
- 2.5.5 Expresiones de cambio
- 2.6 Siempre lo mismo con los bucles
- 2.6.1 El bucle while
- 2.6.2 El bucle do-while
- 2.6.3 El bucle for
- 2.6.4 Condiciones de bucle y comparaciones con ==*
- 2.6.5 Finalización del bucle con break y vuelta a Test con continue
- 2.6.6 Interrumpir y continuar con etiquetas*
- 2.7 Métodos de una clase
- 2.7.1 Componentes de un método
- 2.7.2 Descripción de la firma en la documentación de la interfaz de programación de aplicaciones Java
- 2.7.3 Llamar a un método
- 2.7.4 Declaración de métodos sin parámetros
- 2.7.5 Métodos estáticos (métodos de clase)
- 2.7.6 Parámetros, argumentos y transferencias de valores
- 2.7.7 Finalización prematura de los métodos con return
- 2.7.8 Código fuente inaccesible para métodos*
- 2.7.9 Métodos con retornos
- 2.7.10 Métodos de sobrecarga
- 2.7.11 Alcance
- 2.7.12 Valores predeterminados para argumentos no enumerados*
- 2.7.13 Métodos recursivos*
- 2.7.14 Torres de Hanoi*
- 2.8 Lecturas complementarias
- 3 Clases y objetos
- 3.1 Programación orientada a objetos
- 3.1.1 ¿Por qué utilizar la programación orientada a objetos?
- 3.1.2 Cuando pienso en Java, pienso en reutilización
- 3.2 Miembros de una clase
- 3.3 Modelado natural utilizando el lenguaje de modelado unificado*
- 3.4 Creación de nuevos objetos
- 3.4.1 Creación de una instancia de una clase utilizando la palabra clave new
- 3.4.2 Declaración de variables de referencia
- 3.4.3 Vamos al grano: acceso a variables y métodos de objetos
- 3.4.4 La conexión entre new, el montón y el recolector de basura
- 3.4.5 Descripción general de los métodos de puntos
- 3.4.6 Uso de constructores
- 3.5 ZZZZZnake
- 3.6 Paquetes vinculantes, importaciones y unidades de compilación
- 3.6.1 Paquetes Java
- 3.6.2 Paquetes de la biblioteca estándar
- 3.6.3 Declaración completa de calificación e importación
- 3.6.4 Acceso a todos los tipos de un paquete con Type-Import-on-Demand
- 3.6.5 Estructuras jerárquicas entre paquetes y duplicación en el sistema de archivos
- 3.6.6 La declaración del paquete
- 3.6.7 Paquete sin nombre (paquete predeterminado)
- 3.6.8 Unidad de compilación
- 3.6.9 Importación estática*
- 3.7 Uso de referencias, diversidad, identidad e igualdad
- 3.7.1 Las referencias nulas y la cuestión de la filosofía
- 3.7.2 ¿Todo a nulo? Pruebas de referencias
- 3.7.3 Asignaciones con referencias
- 3.7.4 Métodos con tipos de referencia como parámetros
- 3.7.5 Identidad de los objetos
- 3.7.6 Equivalencia y el método equals(...)
- 3.8 Lecturas complementarias
- 4 Matrices y sus áreas de uso
- 4.1 Trabajo de campo sencillo
- 4.1.1 Componentes básicos
- 4.1.2 Declaración de variables de matriz
- 4.1.3 Creación de objetos de matriz con new
- 4.1.4 Matrices con {contenido}
- 4.1.5 Lectura de la longitud de una matriz mediante la variable de objeto Length
- 4.1.6 Acceso a los elementos a través del índice
- 4.1.7 Errores típicos en las matrices
- 4.1.8 Pasar matrices a métodos
- 4.1.9 Valores de retorno múltiples*
- 4.1.10 Matrices preinicializadas
- 4.2 El bucle for extendido
- 4.2.1 Uso de matrices anónimas en el bucle for extendido
- 4.2.2 Ejemplo: Búsqueda en matrices con cadenas
- 4.2.3 Creación de posiciones aleatorias para los jugadores
- 4.3 Un método con un número variable de argumentos
- 4.3.1 System.out.printf(...) acepta cualquier número de argumentos
- 4.3.2 Hallar el promedio de argumentos variables
- 4.3.3 Consejos de diseño de Vararg*
- 4.4 Matrices multidimensionales*
- 4.4.1 Matrices no rectangulares*
- 4.5 Soporte de biblioteca para matrices
- 4.5.1 La clonación puede ser útil: propagación de matrices
- 4.5.2 ¿Por qué las matrices pueden «hacer» tan poco?
- 4.5.3 Copiar el contenido de una matriz
- 4.6 Uso de la clase Arrays para comparar, rellenar, buscar y ordenar
- 4.6.1 Representación de una matriz como cadena
- 4.6.2 Clasificación
- 4.6.3 Clasificación paralela
- 4.6.4 Comparación de matrices de primitivas con Arrays.equals(...) y Arrays.deepEquals(...)*
- 4.6.5 Comparación de matrices de objetos mediante Arrays.equals(...) y Arrays.deepEquals(...)*
- 4.6.6 Búsqueda de diferencias utilizando Mismatch (...)*
- 4.6.7 Llenado de matrices*
- 4.6.8 Copiar secciones de matriz*
- 4.6.9 Búsqueda binaria*
- 4.6.10 Comparaciones de matrices lexicográficas utilizando compare(...) y compareUnsigned(...)
- 4.6.11 Matrices para listas con Arrays.asList(...): prácticas para buscar y comparar*
- 4.6.12 Una serpiente larga
- 4.7 El punto de entrada del sistema de tiempo de ejecución: main(...)
- 4.7.1 Declaración correcta del método Start
- 4.7.2 Procesamiento de argumentos de la línea de comandos
- 4.7.3 El tipo de retorno de main(...) y System.exit(int)*
- 4.8 Lecturas complementarias
- 5 Manejo de caracteres y cadenas
- 5.1 De ASCII a Unicode pasando por ISO-8859-1
- 5.1.1 ASCII
- 5.1.2 ISO/IEC 8859-1
- 5.1.3 Unicode
- 5.1.4 Codificación de caracteres Unicode
- 5.1.5 Secuencias de escape
- 5.1.6 Notación para caracteres Unicode y escapes Unicode
- 5.1.7 Las versiones de Java van de la mano con el estándar Unicode*
- 5.2 Tipos de datos para caracteres y cadenas
- 5.3 La clase de personaje
- 5.3.1 ¿Es así?
- 5.3.2 Conversión de caracteres a mayúsculas/minúsculas
- 5.3.3 De carácter a cadena
- 5.3.4 De char a int: De carácter a número*
- 5.4 Cuerdas
- 5.5 La clase String y sus métodos
- 5.5.1 Literales de cadena como objetos de cadena para cadenas constantes
- 5.5.2 Concatenación con +
- 5.5.3 Bloques de texto multilínea con «»»
- 5.5.4 Longitud de las cadenas y comprobación de cadenas vacías
- 5.5.5 Acceso a un carácter específico con charAt(int)
- 5.5.6 Búsqueda de caracteres y cadenas contenidos
- 5.5.7 El juego del ahorcado
- 5.5.8 Es bueno que hayamos comparado
- 5.5.9 Extracción de secciones de cadenas
- 5.5.10 Añadir cadenas, fusionar cadenas, distinción entre mayúsculas y minúsculas y espacios en blanco
- 5.5.11 Buscado, encontrado y reemplazado
- 5.5.12 Creación de objetos de cadena con constructores y a partir de repeticiones*
- 5.6 Cadenas mutables con StringBuilder y StringBuffer
- 5.6.1 Creación de objetos StringBuilder
- 5.6.2 Conversión de StringBuilder a otros formatos de cadena
- 5.6.3 Solicitud de caracteres o cadenas
- 5.6.4 Añadir datos
- 5.6.5 Configuración, eliminación y reversión de caracteres y cadenas
- 5.6.6 Longitud y capacidad de un objeto StringBuilder*
- 5.6.7 Comparación de instancias de StringBuilder y cadenas con StringBuilder
- 5.6.8 hashCode() con StringBuilder*
- 5.7 CharSequence como tipo base
- 5.7.1 Operaciones básicas de la interfaz
- 5.7.2 Método estático compare(...) en CharSequence
- 5.7.3 Métodos predeterminados en la interfaz CharSequence*
- 5.8 Conversión de primitivas y cadenas
- 5.8.1 Conversión de diferentes tipos a representaciones de cadena
- 5.8.2 Conversión del contenido de una cadena en un valor primitivo
- 5.8.3 Representación de cadenas en formatos binario, hexadecimal y octal*
- 5.8.4 Métodos parse*(...) y print*() en DatatypeConverter*
- 5.9 Concatenar cadenas
- 5.9.1 Concatenar cadenas con StringJoiner
- 5.10 Descomposición de cadenas
- 5.10.1 Dividir cadenas mediante split(...)
- 5.10.2 Sí podemos, sí escaneamos: la clase Scanner
- 5.11 Formateo de salidas
- 5.11.1 Formateo y salida mediante format()
- 5.12 Lecturas complementarias
- 6 Escribir clases personalizadas
- 6.1 Declaración de clases personalizadas con miembros
- 6.1.1 Clase mínima
- 6.1.2 Declaración de variables de objeto
- 6.1.3 Métodos de declaración
- 6.1.4 Variables sombreadas
- 6.1.5 La presente referencia
- 6.2 Privacidad y visibilidad
- 6.2.1 Para el público: público
- 6.2.2 No público: las contraseñas son privadas
- 6.2.3 ¿Por qué no métodos y variables libres para todos?
- 6.2.4 Lo privado no es del todo privado: depende de quién lo vea*
- 6.2.5 Declaración de métodos de acceso para variables de objeto
- 6.2.6 Setters y Getters según la especificación JavaBeans
- 6.2.7 Visibilidad de los paquetes
- 6.2.8 Resumen de visibilidad
- 6.3 Uno para todos: métodos estáticos y variables de clase
- 6.3.1 Por qué son útiles los miembros estáticos
- 6.3.2 Miembros estáticos con static
- 6.3.3 ¿Usar miembros estáticos a través de referencias?*
- 6.3.4 Por qué es importante distinguir entre mayúsculas y minúsculas*
- 6.3.5 Variables estáticas para el intercambio de datos*
- 6.3.6 Miembros estáticos y miembros de objetos*
- 6.4 Constantes y enumeraciones
- 6.4.1 Constantes mediante variables estáticas finales
- 6.4.2 Enumeraciones sin seguridad de tipos
- 6.4.3 Tipos de enumeración: enumeraciones seguras con enum
- 6.5 Creación y destrucción de objetos
- 6.5.1 Escribir constructores
- 6.5.2 Relación entre método y constructor
- 6.5.3 El constructor predeterminado
- 6.5.4 Constructores parametrizados y sobrecargados
- 6.5.5 Constructores de copia
- 6.5.6 Llamar a otro constructor de la misma clase mediante this(...)
- 6.5.7 Objetos inmutables y métodos wither
- 6.5.8 No te extrañamos: el recolector de basura
- 6.6 Inicialización de clases y objetos*
- 6.6.1 Inicialización de variables de objeto
- 6.6.2 Bloques estáticos como inicializadores de clase
- 6.6.3 Inicialización de variables de clase
- 6.6.4 Asignaciones compiladas de las variables de clase
- 6.6.5 Inicializador de instancia
- 6.6.6 Establecimiento de valores finales en el constructor y en los bloques estáticos
- 6.7 Conclusión
- 7 Relación orientada a objetos
- 7.1 Asociaciones entre objetos
- 7.1.1 Tipos de asociación
- 7.1.2 Relación unidireccional 1 a 1
- 7.1.3 Convertirse en amigos: relaciones bidireccionales uno a uno
- 7.1.4 Relaciones unidireccionales 1 a n
- 7.2 Herencia
- 7.2.1 Herencia en Java
- 7.2.2 Modelización de eventos
- 7.2.3 La clase base implícita java.lang.Object
- 7.2.4 Herencia simple y múltiple*
- 7.2.5 ¿Los niños lo ven todo? La visibilidad protegida
- 7.2.6 Constructores en herencia y super(...)
- 7.3 Tipos en jerarquías
- 7.3.1 Conversión automática y explícita de tipos
- 7.3.2 El principio de sustitución
- 7.3.3 Comprobación de tipos con el operador instanceof
- 7.3.4 Coincidencia de patrones para instanceof
- 7.4 Métodos de anulación
- 7.4.1 Proporcionar métodos en subclases con un nuevo comportamiento
- 7.4.2 Con super a los padres
- 7.5 Prueba de enlaces dinámicos
- 7.5.1 Vinculado a toString()
- 7.5.2 Implementación de System.out.println(Objeto)
- 7.6 Clases finales y métodos finales
- 7.6.1 Clases finales
- 7.6.2 Métodos no sobrescribibles (finales)
- 7.7 Clases abstractas y métodos abstractos
- 7.7.1 Clases abstractas
- 7.7.2 Métodos abstractos
- 7.8 Más información sobre la sobreescritura y el enlace dinámico
- 7.8.1 Sin enlace dinámico para métodos privados, estáticos y finales
- 7.8.2 Tipos de retorno covariantes
- 7.8.3 Tipos de matrices y covarianza*
- 7.8.4 Enlace dinámico incluso con llamadas al constructor*
- 7.8.5 Sin enlace dinámico para variables de objetos cubiertos*
- 7.9 Una tarea de programación
- 8 Interfaces, enumeraciones, clases selladas, registros
- 8.1 Interfaces
- 8.1.1 Las interfaces son nuevos tipos
- 8.1.2 Declaración de interfaces
- 8.1.3 Métodos abstractos en interfaces
- 8.1.4 Implementación de interfaces
- 8.1.5 Un ejemplo de polimorfismo con interfaces
- 8.1.6 Herencia múltiple con interfaces
- 8.1.7 Sin riesgo de colisión con la herencia múltiple*
- 8.1.8 Ampliación de interfaces: subinterfaces
- 8.1.9 Declaraciones constantes para interfaces
- 8.1.10 Implementación posterior de interfaces*
- 8.1.11 Métodos estáticos programados en interfaces
- 8.1.12 Ampliación y modificación de interfaces
- 8.1.13 Métodos predeterminados
- 8.1.14 Declaración y uso de interfaces extendidas
- 8.1.15 Métodos de interfaz públicos y privados
- 8.1.16 Interfaces extendidas, herencia múltiple y ambigüedades*
- 8.1.17 Creación de bloques de construcción con métodos predeterminados*
- 8.1.18 Interfaces de marcadores*
- 8.1.19 (Resumen) Comparación entre clases e interfaces
- 8.2 Tipos de enumeración
- 8.2.1 Métodos en objetos Enum
- 8.2.2 Enumeraciones con métodos, constructores e inicializadores personalizados*
- 8.3 Clases e interfaces selladas
- 8.3.1 Clases e interfaces selladas
- 8.3.2 Las subclases son finales, selladas y no selladas
- 8.3.3 Notaciones abreviadas
- 8.4 Registros
- 8.4.1 Registros simples
- 8.4.2 Registros con métodos
- 8.4.3 Personalización de los constructores de registros
- 8.4.4 Adición de constructores
- 8.4.5 Interfaces y registros sellados
- 8.4.6 Registros: Resumen
- 9 Debe haber excepciones
- 9.1 Cercar las áreas problemáticas
- 9.1.1 Excepciones en Java con try y catch
- 9.1.2 Excepciones verificadas y no verificadas
- 9.1.3 Una excepción NumberFormatException (excepción no verificada)
- 9.1.4 Añadir una fecha/marca de tiempo a un archivo de texto (excepción verificada)
- 9.1.5 Repetición de secciones canceladas*
- 9.1.6 Bloques de captura vacíos
- 9.1.7 Captura de múltiples excepciones
- 9.1.8 Combinación de bloques catch idénticos con Multi-Catch
- 9.2 Redireccionamiento de excepciones y lanzamientos al inicio de métodos/constructores
- 9.2.1 Excepciones en constructores y métodos
- 9.3 La jerarquía de clases de excepciones
- 9.3.1 Miembros del objeto Excepción
- 9.3.2 Tipo base lanzable
- 9.3.3 La jerarquía de excepciones
- 9.3.4 Captura de superexcepciones
- 9.3.5 ¿Ya te han atrapado?
- 9.3.6 Procedimiento en situaciones excepcionales
- 9.3.7 ¡Prohibido pescar con red!
- 9.3.8 Clases conocidas de RuntimeException
- 9.3.9 La interceptación es posible, pero no obligatoria
- 9.4 Manejo final utilizando finally
- 9.4.1 La versión ignorante
- 9.4.2 El intento bienintencionado
- 9.4.3 A partir de ahora, el cierre forma parte de la agenda
- 9.4.4 Resumen
- 9.4.5 Un intento sin éxito, pero un intento finalmente
- 9.5 Activación de excepciones personalizadas
- 9.5.1 Activación de excepciones mediante throw
- 9.5.2 Conocer y utilizar los tipos de excepciones de tiempo de ejecución existentes
- 9.5.3 Parámetros de prueba y mensajes de error adecuados
- 9.5.4 Declaración de nuevas clases de excepción
- 9.5.5 ¿Excepciones personalizadas como subclases de Exception o RuntimeException?
- 9.5.6 Captura y redirección de excepciones*
- 9.5.7 Cambio de la pila de llamadas de excepciones*
- 9.5.8 Excepciones anidadas*
- 9.6 Prueba con Recursos (Administración automática de recursos)
- 9.6.1 Prueba con Recursos
- 9.6.2 La interfaz AutoCloseable
- 9.6.3 Excepciones a close()
- 9.6.4 Tipos que son AutoCloseable y Closeable
- 9.6.5 Uso de múltiples recursos
- 9.6.6 Excepciones suprimidas*
- 9.7 Características especiales del manejo de excepciones*
- 9.7.1 Valores de retorno para excepciones lanzadas
- 9.7.2 Desaparición de excepciones y devoluciones: El dúo regresa y finalmente
- 9.7.3 Excepciones en métodos sobrescritos
- 9.7.4 Cláusulas catch inaccesibles
- 9.8 Errores graves: Error*
- 9.9 Afirmaciones*
- 9.9.1 Uso de aserciones en programas personalizados
- 9.9.2 Habilitación de aserciones y errores de tiempo de ejecución
- 9.9.3 Activación o desactivación de aserciones Más detallado
- 9.10 Conclusión
- 10 Tipos anidados
- 10.1 Clases anidadas, interfaces y enumeraciones
- 10.2 Tipos anidados estáticos
- 10.2.1 Modificadores y visibilidad
- 10.2.2 Los registros como contenedores
- 10.2.3 Implementación de tipos anidados estáticos*
- 10.3 Tipos anidados no estáticos
- 10.3.1 Creación de instancias de clases internas
- 10.3.2 La presente referencia
- 10.3.3 Archivos de clase generados por el compilador*
- 10.4 Clases locales
- 10.4.1 Ejemplo con una declaración personalizada
- 10.4.2 Uso de una clase local para un temporizador
- 10.5 Clases internas anónimas
- 10.5.1 Uso de una clase interna anónima para el temporizador
- 10.5.2 Implementación de clases internas anónimas*
- 10.5.3 Constructores de clases internas anónimas
- 10.5.4 Acceso a variables locales desde clases locales y anónimas*
- 10.5.5 Clases anidadas Acceso a miembros privados
- 10.6 Nidos
- 10.7 Conclusión
- 11 tipos especiales de Java SE
- 11.1 El objeto es la madre de todas las clases
- 11.1.1 Objetos de clase
- 11.1.2 Identificación de objetos con toString()
- 11.1.3 Equivalencia de objetos con equals(...) e identidad
- 11.1.4 Clonar un objeto utilizando clone()*
- 11.1.5 Devolución de valores hash mediante hashCode()*
- 11.1.6 System.identityHashCode(...) y el problema de las referencias a objetos no únicas*
- 11.1.7 Sincronización*
- 11.2 Referencias débiles y limpiadores
- 11.3 La clase de utilidad java.util.Objects
- 11.3.1 Pruebas nulas integradas para equals(...)/hashCode()
- 11.3.2 Objects.toString(…)
- 11.3.3 Comprobaciones nulas con manejo de excepciones integrado
- 11.3.4 Pruebas para nulo
- 11.3.5 Verificación de la corrección de los argumentos del programa relacionados con el índice
- 11.4 Comparar objetos y establecer un orden
- 11.4.1 ¿Orden natural o no?
- 11.4.2 Método compare*() de las interfaces Comparable y Comparator
- 11.4.3 Valores de retorno Codificar el pedido
- 11.4.4 Clasificación de dulces por calorías utilizando un comparador de muestras
- 11.4.5 Consejos para implementaciones de comparadores y comparables
- 11.4.6 Métodos estáticos y predeterminados en Comparator
- 11.5 Clases envolventes y autoboxing
- 11.5.1 Creación de objetos envoltura
- 11.5.2 Conversiones a una representación de cadena
- 11.5.3 Análisis sintáctico a partir de una representación de cadena
- 11.5.4 La clase base numérica para objetos envolventes numéricos
- 11.5.5 Realización de comparaciones con compare*(...), compareTo(...), equals(...) y valores hash
- 11.5.6 Métodos de reducción estática en clases envolventes
- 11.5.7 Constantes para el tamaño de un tipo primitivo*
- 11.5.8 Manejo de números sin signo*
- 11.5.9 Las clases Integer y Long
- 11.5.10 Las clases Double y Float para flotantes
- 11.5.11 La clase Boolean
- 11.5.12 Autoboxing: boxing y unboxing
- 11.6 Iterador, iterable*
- 11.6.1 La interfaz iteradora
- 11.6.2 El proveedor del iterador
- 11.6.3 La interfaz iterable
- 11.6.4 Extendido para e iterable
- 11.6.5 Iteración interna
- 11.6.6 Implementación de un iterable personalizado*
- 11.7 Anotaciones en Java Platform, Standard Edition
- 11.7.1 Lugares para anotaciones
- 11.7.2 Tipos de anotaciones de java.lang
- 11.7.3 @Obsoleto
- 11.7.4 Anotaciones con información adicional
- 11.7.5 @SuppressWarnings
- 11.8 Lecturas complementarias
- 12 Genéricos<T>
- 12.1 Introducción a los genéricos de Java
- 12.1.1 El hombre contra la máquina: verificación de tipos del compilador y del entorno de ejecución
- 12.1.2 Cohetes
- 12.1.3 Declaración de tipos genéricos
- 12.1.4 Uso de genéricos
- 12.1.5 Los diamantes son para siempre
- 12.1.6 Interfaces genéricas
- 12.1.7 Métodos genéricos/constructores e inferencia de tipos
- 12.2 Implementación de genéricos, borrado de tipos y tipos sin procesar
- 12.2.1 Opciones de implementación
- 12.2.2 Eliminación de tipos
- 12.2.3 Problemas con la eliminación de tipos
- 12.2.4 Tipos sin procesar
- 12.3 Restricción de tipos mediante límites
- 12.3.1 Restricciones simples con extends
- 12.3.2 Otros supertipos con &
- 12.4 Parámetros de tipo en la cláusula throws*
- 12.4.1 Declaración de una clase con variable de tipo <E extiende Exception>
- 12.4.2 Tipo parametrizado para variable de tipo <E extiende Excepción>
- 12.5 Herencia e invariancia con genéricos
- 12.5.1 Las matrices son covariantes
- 12.5.2 Los genéricos no son covariantes, sino invariantes
- 12.5.3 Comodines con ?
- 12.5.4 Comodines limitados
- 12.5.5 Tipos comodín acotados y variables de tipo acotadas
- 12.5.6 El principio PECS
- 12.6 Consecuencias de la eliminación de tipos: tokens de tipo, matrices*
- 12.6.1 Fichas de tipo
- 12.6.2 Fichas de supertipo
- 12.6.3 Genéricos y matrices
- 12.7 Lecturas complementarias
- 13 Expresiones lambda y programación funcional
- 13.1 Interfaces funcionales y expresiones lambda
- 13.1.1 Las clases implementan interfaces
- 13.1.2 Las expresiones lambda implementan interfaces
- 13.1.3 Interfaces funcionales
- 13.1.4 El tipo de una expresión lambda depende del tipo de destino
- 13.1.5 Anotaciones @FunctionalInterface
- 13.1.6 Sintaxis para expresiones lambda
- 13.1.7 El entorno de las expresiones lambda y los accesos a variables
- 13.1.8 Excepciones en expresiones lambda
- 13.1.9 ¿Clases con un método abstracto como interfaz funcional?*
- 13.2 Referencias de métodos
- 13.2.1 Motivación
- 13.2.2 Referencias de método con ::
- 13.2.3 Variaciones de las referencias de métodos
- 13.3 Referencias al constructor
- 13.3.1 Escribir referencias al constructor
- 13.3.2 Constructores sin parámetros y parametrizados
- 13.3.3 Interfaces predefinidas útiles para referencias de constructores
- 13.4 Programación funcional
- 13.4.1 Código = Datos
- 13.4.2 Paradigmas de programación: imperativo o declarativo
- 13.4.3 Principios de la programación funcional
- 13.4.4 Programación imperativa y programación funcional
- 13.4.5 El comparador como ejemplo de funciones de orden superior
- 13.4.6 Visualización de expresiones lambda como mapeos o funciones
- 13.5 Interfaces funcionales del paquete java.util.function
- 13.5.1 Bloques con código y el consumidor de la interfaz funcional
- 13.5.2 Proveedor
- 13.5.3 Predicados y java.util.function.Predicate
- 13.5.4 Funciones a través de la interfaz funcional java.util.function.Function
- 13.5.5 Tomo dos
- 13.5.6 Interfaces funcionales con primitivas
- 13.6 Opcional no significa imposible
- 13.6.1 Uso de null
- 13.6.2 El tipo opcional
- 13.6.3 Inicio de interfaces funcionales con opcional
- 13.6.4 Primitivo opcional con clases opcionales especiales*
- 13.7 ¿Qué es lo que resulta tan funcional ahora?
- 13.7.1 Reciclabilidad
- 13.7.2 Sin estado, inmutable
- 13.8 Lecturas complementarias
- 14 Arquitectura, diseño y orientación a objetos aplicada
- 14.1 Modelado SÓLIDO
- 14.1.1 Tres reglas
- 14.1.2 SÓLIDO
- 14.1.3 No seas ESTÚPIDO
- 14.2 Arquitectura, diseño e implementación
- 14.3 Patrones de diseño
- 14.3.1 Motivación para los patrones de diseño
- 14.3.2 Singleton
- 14.3.3 Métodos de fábrica
- 14.3.4 Implementación del patrón observador con oyentes
- 14.4 Lecturas complementarias
- 15 Sistema de módulos de la plataforma Java
- 15.1 Cargador de clases y módulo/ruta de clases
- 15.1.1 Clases de carga por solicitud
- 15.1.2 Observación del funcionamiento del cargador de clases
- 15.1.3 Archivos JMOD y archivos JAR
- 15.1.4 De dónde provienen las clases: ubicaciones de búsqueda y cargadores de clases especiales
- 15.1.5 Configuración de la ruta de búsqueda
- 15.2 Importación de módulos
- 15.2.1 ¿Quién ve a quién?
- 15.2.2 Módulos de la plataforma y un ejemplo de JMOD
- 15.2.3 Uso de las funciones internas de la plataforma: –add-exports
- 15.2.4 Integración de nuevos módulos
- 15.3 Desarrollo de módulos personalizados
- 15.3.1 Módulo com.tutego.candytester
- 15.3.2 Declaración de módulos con module-info.java y exportaciones
- 15.3.3 Módulo com.tutego.main
- 15.3.4 Archivo de información del módulo con requiere
- 15.3.5 Insertadores de módulos de escritura: Opciones de la máquina virtual Java -p y -m
- 15.3.6 Experimentos con el archivo de información del módulo
- 15.3.7 Módulos automáticos
- 15.3.8 Módulos sin nombre
- 15.3.9 Legibilidad y accesibilidad
- 15.3.10 Migración de módulos
- 15.4 Lecturas complementarias
- 16 La biblioteca de clases
- 16.1 La filosofía de las clases Java
- 16.1.1 Módulos, paquetes y tipos
- 16.1.2 Descripción general de los paquetes de la biblioteca estándar
- 16.2 Medición de tiempo y perfilado sencillos*
- 16.3 La clase La clase
- 16.3.1 Obtención de un objeto de clase
- 16.3.2 Una clase es un tipo
- 16.4 El sistema de clases de utilidad y sus miembros
- 16.4.1 Memoria de la máquina virtual Java
- 16.4.2 Número de CPU o núcleos
- 16.4.3 Propiedades del sistema del entorno Java
- 16.4.4 Configuración de propiedades personalizadas desde la consola*
- 16.4.5 Caracteres de nueva línea y separador de línea
- 16.4.6 Variables de entorno del sistema operativo
- 16.5 Los idiomas de diferentes países
- 16.5.1 Idiomas regionales a través de objetos de configuración regional
- 16.6 Resumen de clases de fechas importantes
- 16.6.1 Hora Unix: 1 de enero de 1970
- 16.6.2 System.currentTimeMillis()
- 16.6.3 Conversiones de tiempo simples mediante TimeUnit
- 16.7 API de fecha y hora
- 16.7.1 Descripción general inicial
- 16.7.2 Tiempo humano y tiempo de máquina
- 16.7.3 La clase de fecha LocalDate
- 16.8 Registro con Java
- 16.8.1 Interfaces de programación de aplicaciones de registro
- 16.8.2 Registro con java.util.logging
- 16.9 Maven: resolución de la gestión de compilaciones y dependencias
- 16.9.1 Dependencia que se aceptará
- 16.9.2 Repositorio local y remoto
- 16.9.3 Ciclos de vida, etapas y complementos de Maven
- 16.10 Lecturas complementarias
- 17 Introducción a la programación concurrente
- 17.1 Concurrencia y paralelismo
- 17.1.1 Multitarea, procesos y subprocesos
- 17.1.2 Hilos y procesos
- 17.1.3 Cómo los programas concurrentes pueden aumentar la velocidad
- 17.1.4 Cómo Java puede proporcionar concurrencia
- 17.2 Generación de subprocesos existentes y nuevos subprocesos
- 17.2.1 Hilo principal
- 17.2.2 ¿Quién soy yo?
- 17.2.3 Implementación de la interfaz Runnable
- 17.2.4 Inicio de subprocesos con Runnable
- 17.2.5 Parametrización de Runnable
- 17.2.6 Ampliación de la clase Thread*
- 17.3 Miembros y Estados del hilo
- 17.3.1 El nombre de un hilo
- 17.3.2 Los estados de un hilo*
- 17.3.3 Se buscan durmientes
- 17.3.4 Cuando se terminan los hilos
- 17.3.5 Terminar un hilo de forma educada utilizando interrupciones
- 17.3.6 Excepciones no controladas, fin del hilo y UncaughtExceptionHandler
- 17.3.7 El stop() desde el exterior y el rescate con ThreadDeath*
- 17.3.8 Suspensión y reanudación del trabajo*
- 17.3.9 Prioridad*
- 17.4 Ingresar al Ejecutor
- 17.4.1 La interfaz del ejecutor
- 17.4.2 Felices como grupo: los grupos de subprocesos
- 17.4.3 Hilos con retorno mediante Callable
- 17.4.4 Recuerdos del futuro: El retorno del futuro
- 17.4.5 Procesamiento de múltiples objetos invocables
- 17.4.6 CompletionService y ExecutorCompletionService
- 17.4.7 ScheduledExecutorService: tareas repetitivas y controles de tiempo
- 17.4.8 Programación asíncrona con CompletableFuture (CompletionStage)
- 17.5 Lecturas complementarias
- 18 Introducción a las estructuras de datos y los algoritmos
- 18.1 Listas
- 18.1.1 Primer ejemplo de lista
- 18.1.2 Criterio de selección ArrayList o LinkedList
- 18.1.3 La interfaz de lista
- 18.1.4 Lista de elementos
- 18.1.5 Lista enlazada
- 18.1.6 El adaptador de matriz Arrays.asList(...)
- 18.1.7 ListIterator*
- 18.1.8 Comprensión de toArray(...) de Collection: reconocimiento de trampas
- 18.1.9 Administración de elementos primitivos en estructuras de datos
- 18.2 Conjuntos
- 18.2.1 Primer ejemplo de un conjunto
- 18.2.2 Métodos de la interfaz Set
- 18.2.3 HashSet
- 18.2.4 TreeSet: el conjunto ordenado
- 18.2.5 Las interfaces NavigableSet y SortedSet
- 18.2.6 LinkedHashSet
- 18.3 Memoria asociativa
- 18.3.1 Las clases HashMap y TreeMap y los métodos estáticos de mapas
- 18.3.2 Inserción y consulta de la memoria asociativa
- 18.4 La API Stream
- 18.4.1 Programación declarativa
- 18.4.2 Iteración interna frente a iteracion externa
- 18.4.3 ¿Qué es un flujo?
- 18.5 Creación de un flujo
- 18.5.1 Flujo.de*(…)
- 18.5.2 Stream.generate(…)
- 18.5.3 Stream.iterate(…)
- 18.5.4 Flujos paralelos o secuenciales
- 18.6 Operaciones de la terminal
- 18.6.1 Número de elementos
- 18.6.2 Y ahora todos: forEach*(…)
- 18.6.3 Obtención de elementos individuales del flujo
- 18.6.4 Pruebas de existencia con predicados
- 18.6.5 Reducir un flujo a su elemento más pequeño o más grande
- 18.6.6 Reducir un flujo con sus propias funciones
- 18.6.7 Escribir resultados en un contenedor, parte 1: collect(...)
- 18.6.8 Escribir resultados en un contenedor, parte 2: recolector y recolectores
- 18.6.9 Escribir resultados en un contenedor, parte 3: agrupaciones
- 18.6.10 Transferencia de elementos de flujo a una matriz o un iterador
- 18.7 Operaciones de intermediación
- 18.7.1 Vista previa de elementos
- 18.7.2 Elementos de filtrado
- 18.7.3 Operaciones de intermediario con estado
- 18.7.4 Operaciones con prefijos
- 18.7.5 Imágenes
- 18.8 Lecturas complementarias
- 19 Archivos y flujos de datos
- 19.1 El viejo y el nuevo mundo en java.io y java.nio
- 19.1.1 Paquete java.io con la clase File
- 19.1.2 NIO.2 y el paquete java.nio
- 19.2 Sistemas de archivos y rutas
- 19.2.1 Sistema de archivos y ruta
- 19.2.2 La clase de utilidad Files
- 19.3 Archivos de acceso aleatorio
- 19.3.1 Apertura de un RandomAccessFile para lectura y escritura
- 19.3.2 Lectura desde RandomAccessFile
- 19.3.3 Escribir con RandomAccessFile
- 19.3.4 La longitud del RandomAccessFile
- 19.3.5 Avanzar y retroceder dentro del archivo
- 19.4 Clases base para entrada/salida
- 19.4.1 Las cuatro clases base abstractas
- 19.4.2 La clase base abstracta OutputStream
- 19.4.3 La clase base abstracta InputStream
- 19.4.4 El escritor de clases base abstractas
- 19.4.5 La interfaz apendible*
- 19.4.6 El lector de clases base abstractas
- 19.4.7 Las interfaces Closeable, AutoCloseable y Flushable
- 19.5 Lectura y escritura en archivos
- 19.5.1 Obtención de flujos de datos orientados a bytes a través de archivos
- 19.5.2 Obtención de flujos de datos orientados a caracteres a través de archivos
- 19.5.3 La función de OpenOption en los métodos Files.new*(...)
- 19.5.4 Carga de recursos desde la ruta del módulo y desde archivos JAR
- 19.6 Lecturas complementarias
- 20 Introducción a la administración de bases de datos con JDBC
- 20.1 Bases de datos relacionales y Java Access
- 20.1.1 El modelo relacional
- 20.1.2 Interfaces de programación de aplicaciones Java para acceder a bases de datos relacionales
- 20.1.3 La API JDBC y sus implementaciones: el controlador JDBC
- 20.1.4 H2 es la herramienta en Java
- 20.2 Una consulta de muestra
- 20.2.1 Pasos para consultar la base de datos
- 20.2.2 Acceso a la base de datos relacional con Java
- 20.3 Lecturas complementarias
- 21 Bits y bytes, matemáticas y dinero
- 21.1 Bits y bytes
- 21.1.1 Los operadores bit a bit: complemento, AND, OR y XOR
- 21.1.2 Representación de números enteros en Java: complemento a dos
- 21.1.3 Los sistemas de valor posicional binario, octal y hexadecimal
- 21.1.4 Efecto del moldeado de tipos en los patrones de bits
- 21.1.5 Trabajar sin señales
- 21.1.6 Los operadores de cambio
- 21.1.7 Configuración, borrado, inversión y prueba de un bit
- 21.1.8 Métodos de bits de las clases Integer y Long
- 21.2 Aritmética de punto flotante en Java
- 21.2.1 Valores especiales para infinito, cero y no es un número
- 21.2.2 Notación estándar y notación científica para números flotantes*
- 21.2.3 Mantisas y exponentes*
- 21.3 Los miembros de la clase de matemáticas
- 21.3.1 Variables de objeto de la clase Math
- 21.3.2 Valores absolutos y signos
- 21.3.3 Máximos/Mínimos
- 21.3.4 Redondeo de valores
- 21.3.5 Resto de una división entera*
- 21.3.6 División con redondeo hacia infinito negativo y restos alternativos*
- 21.3.7 Multiplicar-Acumular
- 21.3.8 Métodos de raíz cuadrada y exponencial
- 21.3.9 El logaritmo*
- 21.3.10 Métodos angulares*
- 21.3.11 Números aleatorios
- 21.4 Precisión y rango de valores del control de tipo y desbordamiento*
- 21.4.1 Los valores más grandes y más pequeños
- 21.4.2 Desbordamiento y todo lo que es totalmente exacto
- 21.4.3 ¿Qué hace exactamente el método ulp?
- 21.5 Números aleatorios: Random, ThreadLocalRandom y SecureRandom
- 21.5.1 La clase aleatoria
- 21.5.2 ThreadLocalRandom
- 21.5.3 La clase SecureRandom*
- 21.6 Números grandes*
- 21.6.1 La clase BigInteger
- 21.6.2 Ejemplo: factoriales bastante largos con BigInteger
- 21.6.3 Flotantes grandes con BigDecimal
- 21.6.4 Configuración conveniente de la precisión de cálculo mediante MathContext
- 21.6.5 Cálculos aún más rápidos con implementaciones mutables
- 21.7 Dinero y moneda
- 21.7.1 Representación de cantidades de dinero
- 21.7.2 ISO 4217
- 21.7.3 Representación de monedas en Java
- 21.8 Lecturas complementarias
- 22 Pruebas con JUnit
- 22.1 Pruebas de software
- 22.1.1 Procedimiento para redactar casos de prueba
- 22.2 El marco de pruebas JUnit
- 22.2.1 Versiones de JUnit
- 22.2.2 Integración de JUnit
- 22.2.3 Desarrollo basado en pruebas y enfoque «prueba primero»
- 22.2.4 Prueba, implementa, prueba, implementa, prueba, disfruta.
- 22.2.5 Ejecución de pruebas JUnit
- 22.2.6 Métodos assert*(...) de la clase Assertions
- 22.2.7 Prueba de excepciones
- 22.2.8 Establecimiento de límites para los tiempos de ejecución
- 22.2.9 Etiquetas con @DisplayName
- 22.2.10 Pruebas anidadas
- 22.2.11 Ignorar pruebas
- 22.2.12 Cancelación de pruebas con métodos de la clase Assumptions
- 22.2.13 Pruebas parametrizadas
- 22.3 Bibliotecas de aserciones Java y AssertJ
- 22.4 Estructura de casos de prueba grandes
- 22.4.1 Accesorios
- 22.4.2 Colecciones de clases de prueba y organización de clases
- 22.5 Un buen diseño permite realizar pruebas eficaces
- 22.6 Dummy, falso, stub y simulacro
- 22.7 Extensiones de JUnit y complementos de pruebas
- 22.7.1 Pruebas web
- 22.7.2 Prueba de la interfaz de la base de datos
- 22.8 Lecturas complementarias
- 23 Las herramientas del JDK
- 23.1 Resumen general
- 23.1.1 Estructura y conmutadores comunes
- 23.2 Traducción de fuentes Java
- 23.2.1 El compilador Java del kit de desarrollo Java
- 23.2.2 Compiladores nativos
- 23.3 El entorno de ejecución Java
- 23.3.1 Interruptores de la máquina virtual Java
- 23.3.2 La diferencia entre java.exe y javaw.exe
- 23.4 Comentarios de documentación con Javadoc
- 23.4.1 Configuración de un comentario de documentación
- 23.4.2 Creación de documentación con la herramienta javadoc
- 23.4.3 Etiquetas HTML en comentarios de documentación*
- 23.4.4 Archivos generados
- 23.4.5 Comentarios sobre la documentación de un vistazo*
- 23.4.6 Javadoc y Doclets*
- 23.4.7 Tipos y miembros obsoletos
- 23.4.8 Verificación de Javadoc con DocLint
- 23.5 El formato de archivo JAR
- 23.5.1 Uso de la utilidad jar
- 23.5.2 El manifiesto
- 23.5.3 Inicio de aplicaciones en archivos Java: archivos JAR ejecutables
- 23.6 Lecturas complementarias
- El autor
- Índice
Java
This is the up-to-date, practical guide to Java you’ve been looking for! Whether you’re a beginner, you’re switching to Java from another language, or you’re just looking to brush up on your Java skills, this is the only book you need. You’ll get a thorough grounding in the basics of the Java language, including classes, objects, arrays, strings, and exceptions. You'll also learn about more advanced topics: threads, algorithms, XML, JUnit testing, and much more. This book belongs on every Java programmer's shelf!
- Your complete guide to the Java Platform, Standard Edition 17
- Understand the Java language, from basic principles to advanced concepts
- Work with expressions, statements, classes, objects, and much more
- Download and consult practical code examples
You'll learn about:
- Java Basics:
Get to know the inner workings of Java, from classes and objects to data structures and algorithms. This book is up to date for Java SE 17!
- Advanced Topics:
Already mastered the basics? Explore what else Java can do, from floating point arithmetic to testing frameworks, threads, database management, and beyond.
- Practical Examples:
Gain hands-on experience with Java using tried and tested downloadable programs. These code examples allow you to work your way through the book, testing your newfound skills and knowledge along the journey.
Key Highlights:
- Classes and objects
- Arrays
- Exception handling
- Object-oriented programming
- Characters and strings
- Generics
- Class library
- Concurrent programming
- Data structures
- Lambda expressions
- JUnit testing
- JDK tools
View Full Table of Contents
- Preface
- Target Group
- What This Book Is Not
- My Life and Java, Or “Why a Java Book?”
- Software and Versions
- Which Java Version to Use
- Using This Book to Learn
- Personal Learning Strategies
- Focusing on the Essentials
- Special Sections
- Tasks
- Structure of This Book
- Conventions
- Program Listings
- Application Programming Interface Documentation in This Book
- Executable Programs
- Acknowledgments
- Resources for This Book
- Feedback
- 1 Introduction
- 1.1 Historical Background
- 1.2 On the Popularity of Java: The Key Features
- 1.2.1 Bytecode
- 1.2.2 Executing the Bytecode via a Virtual Machine
- 1.2.3 Platform Independence
- 1.2.4 Java as a Language, Runtime Environment, and Standard Library
- 1.2.5 Object Orientation in Java
- 1.2.6 Java Is Widespread and Well Known
- 1.2.7 Java Is Fast: Optimization and Just-In-Time Compilation
- 1.2.8 Pointers and References
- 1.2.9 Take Out the Trash, Garbage Collector!
- 1.2.10 Exception Handling
- 1.2.11 The Range of Libraries and Tools
- 1.2.12 Comparably Simple Syntax
- 1.2.13 Abandoning Controversial Concepts
- 1.2.14 Java Is Open Source
- 1.2.15 What Java Is Less Suitable for
- 1.3 Java versus Other Languages*
- 1.3.1 Java and C(++)
- 1.3.2 Java and JavaScript
- 1.3.3 A Word about Microsoft, Java, and J++
- 1.3.4 Java and C#/.NET
- 1.4 Further Development and Losses
- 1.4.1 The Development of Java and Its Future Prospects
- 1.4.2 Features, Enhancements, and Specification Requests
- 1.4.3 Applets
- 1.4.4 JavaFX
- 1.5 Java Platforms
- 1.5.1 Java Platform, Standard Edition
- 1.5.2 Java Platform, Micro Edition: Java for the Little Ones
- 1.5.3 Java for the Very, Very Little Ones
- 1.5.4 Java for the Big Ones: Jakarta EE (Formerly Java Platform, Enterprise Edition)
- 1.5.5 Real-Time Java
- 1.6 Java Platform, Standard Edition, Implementations
- 1.6.1 OpenJDK
- 1.6.2 Oracle JDK
- 1.7 Installing the Java Development Kit
- 1.7.1 Installing Oracle JDK on Windows
- 1.8 Compiling and Testing the First Program
- 1.8.1 A Square Numbers Program
- 1.8.2 The Compiler Run
- 1.8.3 The Runtime Environment
- 1.8.4 Common Compiler and Interpreter Issues
- 1.9 Development Environments
- 1.9.1 IntelliJ IDEA
- 1.9.2 Eclipse Integrated Development Environment
- 1.9.3 NetBeans
- 1.10 Further Reading
- 2 Imperative Language Concepts
- 2.1 Elements of the Java Programming Language
- 2.1.1 Tokens
- 2.1.2 Text Encoding by Unicode Characters
- 2.1.3 Identifiers
- 2.1.4 Literals
- 2.1.5 (Reserved) Keywords
- 2.1.6 Summary of the Lexical Analysis
- 2.1.7 Comments
- 2.2 From Classes to Statements
- 2.2.1 What Are Statements?
- 2.2.2 Class Declaration
- 2.2.3 The Journey Begins with main(String[])
- 2.2.4 The First Method Call: println(...)
- 2.2.5 Atomic Statements and Statement Sequences
- 2.2.6 More about print(...), println(...), and printf(...) for Screen Output
- 2.2.7 Application Programming Interface Documentation
- 2.2.8 Expressions
- 2.2.9 Expression Statements
- 2.2.10 First Insights into Object Orientation
- 2.2.11 Modifiers
- 2.2.12 Grouping Statements with Blocks
- 2.3 Data Types, Typing, Variables, and Assignments
- 2.3.1 Overview of Primitive Data Types
- 2.3.2 Variable Declarations
- 2.3.3 Automatic Type Detection with var
- 2.3.4 Final Variables and the final Modifier
- 2.3.5 Console Inputs
- 2.3.6 Truth Values
- 2.3.7 Integer Data Types
- 2.3.8 Underscores in Numbers
- 2.3.9 Alphanumeric Characters
- 2.3.10 The float and double Data Types
- 2.3.11 Good Names, Bad Names
- 2.3.12 No Automatic Initialization of Local Variables
- 2.4 Expressions, Operands, and Operators
- 2.4.1 Assignment Operator
- 2.4.2 Arithmetic Operators
- 2.4.3 Unary Minus and Plus
- 2.4.4 Prefix or Postfix Increment and Decrement
- 2.4.5 Assignment with Operation (Compound Assignment Operator)
- 2.4.6 Relational Operators and Equality Operators
- 2.4.7 Logical Operators: NOT, AND, OR, and XOR
- 2.4.8 Short-Circuit Operators
- 2.4.9 The Rank of Operators in Evaluation Order
- 2.4.10 Typecasting (Casting)
- 2.4.11 Overloaded Plus for Strings
- 2.4.12 Operators Missing*
- 2.5 Conditional Statements or Case Distinctions
- 2.5.1 Branching with the if Statement
- 2.5.2 Choosing the Alternative with an if-else Statement
- 2.5.3 The Condition Operator
- 2.5.4 The Switch Statement Provides an Alternative
- 2.5.5 Switch Expressions
- 2.6 Always the Same with Loops
- 2.6.1 The while Loop
- 2.6.2 The do-while Loop
- 2.6.3 The for Loop
- 2.6.4 Loop Conditions and Comparisons with ==*
- 2.6.5 Loop Termination with break and back to Test with continue
- 2.6.6 break and continue with Labels*
- 2.7 Methods of a Class
- 2.7.1 Components of a Method
- 2.7.2 Signature Description in the Java Application Programming Interface Documentation
- 2.7.3 Calling a Method
- 2.7.4 Declaring Methods without Parameters
- 2.7.5 Static Methods (Class Methods)
- 2.7.6 Parameters, Arguments, and Value Transfers
- 2.7.7 Ending Methods Prematurely with return
- 2.7.8 Unreachable Source Code for Methods*
- 2.7.9 Methods with Returns
- 2.7.10 Overloading Methods
- 2.7.11 Scope
- 2.7.12 Default Values for Unlisted Arguments*
- 2.7.13 Recursive Methods*
- 2.7.14 Towers of Hanoi*
- 2.8 Further Reading
- 3 Classes and Objects
- 3.1 Object-Oriented Programming
- 3.1.1 Why Object-Oriented Programming at All?
- 3.1.2 When I Think of Java, I Think of Reusability
- 3.2 Members of a Class
- 3.3 Natural Modeling Using Unified Modeling Language*
- 3.4 Creating New Objects
- 3.4.1 Creating an Instance of a Class Using the new Keyword
- 3.4.2 Declaring Reference Variables
- 3.4.3 Let’s Get to the Point: Accessing Object Variables and Methods
- 3.4.4 The Connection between new, the Heap, and the Garbage Collector
- 3.4.5 Overview of Point Methods
- 3.4.6 Using Constructors
- 3.5 ZZZZZnake
- 3.6 Tying Packages, Imports, and Compilation Units
- 3.6.1 Java Packages
- 3.6.2 Packages in the Standard Library
- 3.6.3 Full Qualification and Import Declaration
- 3.6.4 Reaching All Types of a Package with Type-Import-on-Demand
- 3.6.5 Hierarchical Structures across Packages and Mirroring in the File System
- 3.6.6 The Package Declaration
- 3.6.7 Unnamed Package (Default Package)
- 3.6.8 Compilation Unit
- 3.6.9 Static Import*
- 3.7 Using References, Diversity, Identity, and Equality
- 3.7.1 null References and the Question of Philosophy
- 3.7.2 Everything to null? Testing References
- 3.7.3 Assignments with References
- 3.7.4 Methods with Reference Types as Parameters
- 3.7.5 Identity of Objects
- 3.7.6 Equivalence and the equals(...) Method
- 3.8 Further Reading
- 4 Arrays and Their Areas of Use
- 4.1 Simple Field Work
- 4.1.1 Basic Components
- 4.1.2 Declaring Array Variables
- 4.1.3 Creating Array Objects with new
- 4.1.4 Arrays with { contents }
- 4.1.5 Reading the Length of an Array via the Object Variable Length
- 4.1.6 Accessing the Elements via the Index
- 4.1.7 Typical Array Errors
- 4.1.8 Passing Arrays to Methods
- 4.1.9 Multiple Return Values*
- 4.1.10 Preinitialized Arrays
- 4.2 The Extended for Loop
- 4.2.1 Using Anonymous Arrays in the Extended for Loop
- 4.2.2 Example: Searching Arrays with Strings
- 4.2.3 Creating Random Player Positions
- 4.3 A Method with a Variable Number of Arguments
- 4.3.1 System.out.printf(...) Accepts Any Number of Arguments
- 4.3.2 Finding the Average of Variable Arguments
- 4.3.3 Vararg Design Tips*
- 4.4 Multidimensional Arrays*
- 4.4.1 Nonrectangular Arrays*
- 4.5 Library Support for Arrays
- 4.5.1 Cloning Can Be Worthwhile: Propagating Arrays
- 4.5.2 Why Can Arrays “Do” So Little?
- 4.5.3 Copying Array Contents
- 4.6 Using the Arrays Class for Comparing, Filling, Searching, and Sorting
- 4.6.1 String Representation of an Array
- 4.6.2 Sorting
- 4.6.3 Parallel Sorting
- 4.6.4 Comparing Arrays of Primitives with Arrays.equals(...) and Arrays.deepEquals(...)*
- 4.6.5 Comparing Object Arrays Using Arrays.equals(...) and Arrays.deepEquals(...)*
- 4.6.6 Searching Differences Using Mismatch (...)*
- 4.6.7 Filling Arrays*
- 4.6.8 Copying Array Sections*
- 4.6.9 Binary Search*
- 4.6.10 Lexicographic Array Comparisons Using compare(...) and compareUnsigned(...)
- 4.6.11 Arrays for Lists with Arrays.asList(...): Convenient for Searching and Comparing*
- 4.6.12 A Long Snake
- 4.7 The Entry Point for the Runtime System: main(...)
- 4.7.1 Correct Declaration of the Start Method
- 4.7.2 Processing Command Line Arguments
- 4.7.3 The Return Type of main(...) and System.exit(int)*
- 4.8 Further Reading
- 5 Handling Characters and Strings
- 5.1 From ASCII via ISO-8859-1 to Unicode
- 5.1.1 ASCII
- 5.1.2 ISO/IEC 8859-1
- 5.1.3 Unicode
- 5.1.4 Unicode Character Encoding
- 5.1.5 Escape Sequences
- 5.1.6 Notation for Unicode Characters and Unicode Escapes
- 5.1.7 Java Versions Go Hand in Hand with the Unicode Standard*
- 5.2 Data Types for Characters and Strings
- 5.3 The Character Class
- 5.3.1 Is That So?
- 5.3.2 Converting Characters to Uppercase/Lowercase
- 5.3.3 From Character to String
- 5.3.4 From char to int: From Character to Number*
- 5.4 Strings
- 5.5 The String Class and Its Methods
- 5.5.1 String Literals as String Objects for Constant Strings
- 5.5.2 Concatenation with +
- 5.5.3 Multiline Text Blocks with “””
- 5.5.4 String Length and Testing for Empty Strings
- 5.5.5 Accessing a Specific Character with charAt(int)
- 5.5.6 Searching for Contained Characters and Strings
- 5.5.7 The Hangman Game
- 5.5.8 Good That We Have Compared
- 5.5.9 Extracting String Sections
- 5.5.10 Appending Strings, Merging Strings, Case Sensitivity, and Whitespace
- 5.5.11 Searched, Found, and Replaced
- 5.5.12 Creating String Objects with Constructors and from Repeats*
- 5.6 Mutable Strings with StringBuilder and StringBuffer
- 5.6.1 Creating StringBuilder Objects
- 5.6.2 Converting StringBuilder to Other String Formats
- 5.6.3 Requesting Characters or Strings
- 5.6.4 Appending Data
- 5.6.5 Setting, Deleting, and Reversing Characters and Strings
- 5.6.6 Length and Capacity of a StringBuilder Object*
- 5.6.7 Comparison of StringBuilder Instances and Strings with StringBuilder
- 5.6.8 hashCode() with StringBuilder*
- 5.7 CharSequence as Base Type
- 5.7.1 Basic Operations of the Interface
- 5.7.2 Static compare(...) Method in CharSequence
- 5.7.3 Default Methods in the CharSequence Interface*
- 5.8 Converting Primitives and Strings
- 5.8.1 Converting Different Types to String Representations
- 5.8.2 Converting String Contents to a Primitive Value
- 5.8.3 String Representation in Binary, Hex, and Octal Formats*
- 5.8.4 parse*(...) and print*() Methods in DatatypeConverter*
- 5.9 Concatenating Strings
- 5.9.1 Concatenating Strings with StringJoiner
- 5.10 Decomposing Strings
- 5.10.1 Splitting Strings via split(...)
- 5.10.2 Yes We Can, Yes We Scan: The Scanner Class
- 5.11 Formatting Outputs
- 5.11.1 Formatting and Outputting via format()
- 5.12 Further Reading
- 6 Writing Custom Classes
- 6.1 Declaring Custom Classes with Members
- 6.1.1 Minimum Class
- 6.1.2 Declaring Object Variables
- 6.1.3 Declaring Methods
- 6.1.4 Shadowed Variables
- 6.1.5 The this Reference
- 6.2 Privacy and Visibility
- 6.2.1 For the Public: public
- 6.2.2 Not Public: Passwords Are private
- 6.2.3 Why Not Free Methods and Variables for All?
- 6.2.4 private Is Not Quite Private: It Depends on Who Sees It*
- 6.2.5 Declaring Access Methods for Object Variables
- 6.2.6 Setters and Getters according to the JavaBeans Specification
- 6.2.7 Package-Visibility
- 6.2.8 Visibility Summary
- 6.3 One for All: Static Methods and Class Variables
- 6.3.1 Why Static Members Are Useful
- 6.3.2 Static Members with static
- 6.3.3 Using Static Members via References?*
- 6.3.4 Why Case Sensitivity Is Important*
- 6.3.5 Static Variables for Data Exchange*
- 6.3.6 Static Members and Object Members*
- 6.4 Constants and Enumerations
- 6.4.1 Constants via Static Final Variables
- 6.4.2 Type-Unsafe Enumerations
- 6.4.3 Enumeration Types: Type-Safe Enumerations with enum
- 6.5 Creating and Destroying Objects
- 6.5.1 Writing Constructors
- 6.5.2 Relationship of Method and Constructor
- 6.5.3 The Default Constructor
- 6.5.4 Parameterized and Overloaded Constructors
- 6.5.5 Copy Constructors
- 6.5.6 Calling Another Constructor of the Same Class via this(...)
- 6.5.7 Immutable Objects and Wither Methods
- 6.5.8 We Don’t Miss You: The Garbage Collector
- 6.6 Class and Object Initialization*
- 6.6.1 Initializing Object Variables
- 6.6.2 Static Blocks as Class Initializers
- 6.6.3 Initializing Class Variables
- 6.6.4 Compiled Assignments of the Class Variables
- 6.6.5 Instance Initializer
- 6.6.6 Setting Final Values in the Constructor and Static Blocks
- 6.7 Conclusion
- 7 Object-Oriented Relationship
- 7.1 Associations between Objects
- 7.1.1 Association Types
- 7.1.2 Unidirectional 1-to-1 Relationship
- 7.1.3 Becoming Friends: Bidirectional 1-to-1 Relationships
- 7.1.4 Unidirectional 1-to-n Relationships
- 7.2 Inheritance
- 7.2.1 Inheritance in Java
- 7.2.2 Modeling Events
- 7.2.3 The Implicit Base Class java.lang.Object
- 7.2.4 Single and Multiple Inheritance*
- 7.2.5 Do Children See Everything? The Protected Visibility
- 7.2.6 Constructors in Inheritance and super(...)
- 7.3 Types in Hierarchies
- 7.3.1 Automatic and Explicit Typecasting
- 7.3.2 The Substitution Principle
- 7.3.3 Testing Types with the instanceof Operator
- 7.3.4 Pattern Matching for instanceof
- 7.4 Overriding Methods
- 7.4.1 Providing Methods in Subclasses with a New Behavior
- 7.4.2 With super to the Parents
- 7.5 Testing Dynamic Bindings
- 7.5.1 Bound to toString()
- 7.5.2 Implementing System.out.println(Object)
- 7.6 Final Classes and Final Methods
- 7.6.1 Final Classes
- 7.6.2 Non-Overridable (final) Methods
- 7.7 Abstract Classes and Abstract Methods
- 7.7.1 Abstract Classes
- 7.7.2 Abstract Methods
- 7.8 Further Information on Overriding and Dynamic Binding
- 7.8.1 No Dynamic Binding for Private, Static, and final Methods
- 7.8.2 Covariant Return Types
- 7.8.3 Array Types and Covariance*
- 7.8.4 Dynamic Binding even with Constructor Calls*
- 7.8.5 No Dynamic Binding for Covered Object Variables*
- 7.9 A Programming Task
- 8 Interfaces, Enumerations, Sealed Classes, Records
- 8.1 Interfaces
- 8.1.1 Interfaces Are New Types
- 8.1.2 Declaring Interfaces
- 8.1.3 Abstract Methods in Interfaces
- 8.1.4 Implementing Interfaces
- 8.1.5 A Polymorphism Example with Interfaces
- 8.1.6 Multiple Inheritance with Interfaces
- 8.1.7 No Risk of Collision with Multiple Inheritance*
- 8.1.8 Extending Interfaces: Subinterfaces
- 8.1.9 Constant Declarations for Interfaces
- 8.1.10 Subsequent Implementation of Interfaces*
- 8.1.11 Static Programmed Methods in Interfaces
- 8.1.12 Extending and Modifying Interfaces
- 8.1.13 Default Methods
- 8.1.14 Declaring and Using Extended Interfaces
- 8.1.15 Public and Private Interface Methods
- 8.1.16 Extended Interfaces, Multiple Inheritance, and Ambiguities*
- 8.1.17 Creating Building Blocks with Default Methods*
- 8.1.18 Marker Interfaces*
- 8.1.19 (Abstract) Classes and Interfaces in Comparison
- 8.2 Enumeration Types
- 8.2.1 Methods on Enum Objects
- 8.2.2 Enumerations with Custom Methods, Constructors, and Initializers*
- 8.3 Sealed Classes and Interfaces
- 8.3.1 Sealed Classes and Interfaces
- 8.3.2 Subclasses Are Final, Sealed, and Non-Sealed
- 8.3.3 Abbreviated Notations
- 8.4 Records
- 8.4.1 Simple Records
- 8.4.2 Records with Methods
- 8.4.3 Customizing Record Constructors
- 8.4.4 Adding Constructors
- 8.4.5 Sealed Interfaces and Records
- 8.4.6 Records: Summary
- 9 There Must Be Exceptions
- 9.1 Fencing In Problem Areas
- 9.1.1 Exceptions in Java with try and catch
- 9.1.2 Checked and Unchecked Exceptions
- 9.1.3 A NumberFormatException (Unchecked Exception)
- 9.1.4 Appending a Date/Timestamp to a Text File (Checked Exception)
- 9.1.5 Repeating Canceled Sections*
- 9.1.6 Empty catch Blocks
- 9.1.7 Catching Multiple Exceptions
- 9.1.8 Combining Identical catch Blocks with Multi-Catch
- 9.2 Redirecting Exceptions and throws at the Head of Methods/Constructors
- 9.2.1 throws in Constructors and Methods
- 9.3 The Class Hierarchy of Exceptions
- 9.3.1 Members of the Exception Object
- 9.3.2 Base Type Throwable
- 9.3.3 The Exception Hierarchy
- 9.3.4 Catching Super-Exceptions
- 9.3.5 Already Caught?
- 9.3.6 Procedure of an Exceptional Situation
- 9.3.7 No General Catching!
- 9.3.8 Known RuntimeException Classes
- 9.3.9 Interception Is Possible, but Not Mandatory
- 9.4 Final Handling Using finally
- 9.4.1 The Ignorant Version
- 9.4.2 The Well-Intentioned Attempt
- 9.4.3 From Now On, Closing Is Part of the Agenda
- 9.4.4 Summary
- 9.4.5 A try without a catch, but a try-finally
- 9.5 Triggering Custom Exceptions
- 9.5.1 Triggering Exceptions via throw
- 9.5.2 Knowing and Using Existing Runtime Exception Types
- 9.5.3 Testing Parameters and Good Error Messages
- 9.5.4 Declaring New Exception Classes
- 9.5.5 Custom Exceptions as Subclasses of Exception or RuntimeException?
- 9.5.6 Catching and Redirecting Exceptions*
- 9.5.7 Changing the Call Stack of Exceptions*
- 9.5.8 Nested Exceptions*
- 9.6 try with Resources (Automatic Resource Management)
- 9.6.1 try with Resources
- 9.6.2 The AutoCloseable Interface
- 9.6.3 Exceptions to close()
- 9.6.4 Types That Are AutoCloseable and Closeable
- 9.6.5 Using Multiple Resources
- 9.6.6 Suppressed Exceptions*
- 9.7 Special Features of Exception Handling*
- 9.7.1 Return Values for Thrown Exceptions
- 9.7.2 Exceptions and Returns Disappear: The Duo return and finally
- 9.7.3 throws on Overridden Methods
- 9.7.4 Unreachable catch Clauses
- 9.8 Hard Errors: Error*
- 9.9 Assertions*
- 9.9.1 Using Assertions in Custom Programs
- 9.9.2 Enabling Assertions and Runtime Errors
- 9.9.3 Enabling or Disabling Assertions More Detailed
- 9.10 Conclusion
- 10 Nested Types
- 10.1 Nested Classes, Interfaces, and Enumerations
- 10.2 Static Nested Types
- 10.2.1 Modifiers and Visibility
- 10.2.2 Records as Containers
- 10.2.3 Implementing Static Nested Types*
- 10.3 Non-Static Nested Types
- 10.3.1 Creating Instances of Inner Classes
- 10.3.2 The this Reference
- 10.3.3 Class Files Generated by the Compiler*
- 10.4 Local Classes
- 10.4.1 Example with a Custom Declaration
- 10.4.2 Using a Local Class for a Timer
- 10.5 Anonymous Inner Classes
- 10.5.1 Using an Anonymous Inner Class for the Timer
- 10.5.2 Implementing Anonymous Inner Classes*
- 10.5.3 Constructors of Anonymous Inner Classes
- 10.5.4 Accessing Local Variables from Local and Anonymous Classes*
- 10.5.5 Nested Classes Access Private Members
- 10.6 Nests
- 10.7 Conclusion
- 11 Special Types of Java SE
- 11.1 Object Is the Mother of All Classes
- 11.1.1 Class Objects
- 11.1.2 Object Identification with toString()
- 11.1.3 Object Equivalence with equals(...) and Identity
- 11.1.4 Cloning an Object Using clone()*
- 11.1.5 Returning Hash Values via hashCode()*
- 11.1.6 System.identityHashCode(...) and the Problem of Non-Unique Object References*
- 11.1.7 Synchronization*
- 11.2 Weak References and Cleaners
- 11.3 The java.util.Objects Utility Class
- 11.3.1 Built-In Null Tests for equals(...)/hashCode()
- 11.3.2 Objects.toString(…)
- 11.3.3 null Checks with Built-In Exception Handling
- 11.3.4 Tests for null
- 11.3.5 Checking Index-Related Program Arguments for Correctness
- 11.4 Comparing Objects and Establishing Order
- 11.4.1 Naturally Ordered or Not?
- 11.4.2 compare*() Method of the Comparable and Comparator Interfaces
- 11.4.3 Return Values Encode the Order
- 11.4.4 Sorting Candy by Calories Using a Sample Comparator
- 11.4.5 Tips for Comparator and Comparable Implementations
- 11.4.6 Static and Default Methods in Comparator
- 11.5 Wrapper Classes and Autoboxing
- 11.5.1 Creating Wrapper Objects
- 11.5.2 Conversions to a String Representation
- 11.5.3 Parsing from a String Representation
- 11.5.4 The Number Base Class for Numeric Wrapper Objects
- 11.5.5 Performing Comparisons with compare*(...), compareTo(...), equals(...), and Hash Values
- 11.5.6 Static Reduction Methods in Wrapper Classes
- 11.5.7 Constants for the Size of a Primitive Type*
- 11.5.8 Handling Unsigned Numbers*
- 11.5.9 The Integer and Long Classes
- 11.5.10 The Double and Float Classes for Floats
- 11.5.11 The Boolean Class
- 11.5.12 Autoboxing: Boxing and Unboxing
- 11.6 Iterator, Iterable*
- 11.6.1 The Iterator Interface
- 11.6.2 The Supplier of the Iterator
- 11.6.3 The Iterable Interface
- 11.6.4 Extended for and Iterable
- 11.6.5 Internal Iteration
- 11.6.6 Implementing a Custom Iterable*
- 11.7 Annotations in Java Platform, Standard Edition
- 11.7.1 Places for Annotations
- 11.7.2 Annotation Types from java.lang
- 11.7.3 @Deprecated
- 11.7.4 Annotations with Additional Information
- 11.7.5 @SuppressWarnings
- 11.8 Further Reading
- 12 Generics<T>
- 12.1 Introduction to Java Generics
- 12.1.1 Man versus Machine: Type Checking of the Compiler and the Runtime Environment
- 12.1.2 Rockets
- 12.1.3 Declaring Generic Types
- 12.1.4 Using Generics
- 12.1.5 Diamonds Are Forever
- 12.1.6 Generic Interfaces
- 12.1.7 Generic Methods/Constructors and Type Inference
- 12.2 Implementing Generics, Type Erasure, and Raw Types
- 12.2.1 Implementation Options
- 12.2.2 Type Erasure
- 12.2.3 Problems with Type Erasure
- 12.2.4 Raw Types
- 12.3 Restricting Types via Bounds
- 12.3.1 Simple Restrictions with extends
- 12.3.2 Other Supertypes with &
- 12.4 Type Parameters in the throws Clause*
- 12.4.1 Declaring a Class with Type Variable <E extends Exception>
- 12.4.2 Parameterized Type for Type Variable <E extends Exception>
- 12.5 Inheritance and Invariance with Generics
- 12.5.1 Arrays Are Covariant
- 12.5.2 Generics Aren’t Covariant, but Invariant
- 12.5.3 Wildcards with ?
- 12.5.4 Bounded Wildcards
- 12.5.5 Bounded Wildcard Types and Bounded Type Variables
- 12.5.6 The PECS Principle
- 12.6 Consequences of Type Erasure: Type Tokens, Arrays*
- 12.6.1 Type Tokens
- 12.6.2 Supertype Tokens
- 12.6.3 Generics and Arrays
- 12.7 Further Reading
- 13 Lambda Expressions and Functional Programming
- 13.1 Functional Interfaces and Lambda Expressions
- 13.1.1 Classes Implement Interfaces
- 13.1.2 Lambda Expressions Implement Interfaces
- 13.1.3 Functional Interfaces
- 13.1.4 The Type of a Lambda Expression Depends on the Target Type
- 13.1.5 @FunctionalInterface Annotations
- 13.1.6 Syntax for Lambda Expressions
- 13.1.7 The Environment of Lambda Expressions and Variable Accesses
- 13.1.8 Exceptions in Lambda Expressions
- 13.1.9 Classes with an Abstract Method as a Functional Interface?*
- 13.2 Method References
- 13.2.1 Motivation
- 13.2.2 Method References with ::
- 13.2.3 Variations of Method References
- 13.3 Constructor References
- 13.3.1 Writing Constructor References
- 13.3.2 Parameterless and Parameterized Constructors
- 13.3.3 Useful Predefined Interfaces for Constructor References
- 13.4 Functional Programming
- 13.4.1 Code = Data
- 13.4.2 Programming Paradigms: Imperative or Declarative
- 13.4.3 Principles of Functional Programming
- 13.4.4 Imperative Programming and Functional Programming
- 13.4.5 Comparator as an Example of Higher-Order Functions
- 13.4.6 Viewing Lambda Expressions as Mappings or Functions
- 13.5 Functional Interfaces from the java.util.function Package
- 13.5.1 Blocks with Code and the Functional Interface Consumer
- 13.5.2 Supplier
- 13.5.3 Predicates and java.util.function.Predicate
- 13.5.4 Functions via the Functional Interface java.util.function.Function
- 13.5.5 I Take Two
- 13.5.6 Functional Interfaces with Primitives
- 13.6 Optional Is Not a Non-Starter
- 13.6.1 Using null
- 13.6.2 The Optional Type
- 13.6.3 Starting Functional Interfaces with Optional
- 13.6.4 Primitive-Optional with Special Optional* Classes
- 13.7 What Is So Functional Now?
- 13.7.1 Recyclability
- 13.7.2 Stateless, Immutable
- 13.8 Further Reading
- 14 Architecture, Design, and Applied Object Orientation
- 14.1 SOLID Modeling
- 14.1.1 Three Rules
- 14.1.2 SOLID
- 14.1.3 Don’t Be STUPID
- 14.2 Architecture, Design, and Implementation
- 14.3 Design Patterns
- 14.3.1 Motivation for Design Patterns
- 14.3.2 Singleton
- 14.3.3 Factory Methods
- 14.3.4 Implementing the Observer Pattern with Listeners
- 14.4 Further Reading
- 15 Java Platform Module System
- 15.1 Class Loader and Module/Classpath
- 15.1.1 Loading Classes per Request
- 15.1.2 Watching the Class Loader at Work
- 15.1.3 JMOD Files and JAR Files
- 15.1.4 Where the Classes Come from: Search Locations and Special Class Loaders
- 15.1.5 Setting the Search Path
- 15.2 Importing Modules
- 15.2.1 Who Sees Whom?
- 15.2.2 Platform Modules and a JMOD Example
- 15.2.3 Using Internal Platform Features: –add-exports
- 15.2.4 Integrating New Modules
- 15.3 Developing Custom Modules
- 15.3.1 Module com.tutego.candytester
- 15.3.2 Module Declaration with module-info.java and Exports
- 15.3.3 Module com.tutego.main
- 15.3.4 Module info File with requires
- 15.3.5 Writing Module Inserters: Java Virtual Machine Switches -p and -m
- 15.3.6 Experiments with the Module Info File
- 15.3.7 Automatic Modules
- 15.3.8 Unnamed Modules
- 15.3.9 Readability and Accessibility
- 15.3.10 Module Migration
- 15.4 Further Reading
- 16 The Class Library
- 16.1 The Java Class Philosophy
- 16.1.1 Modules, Packages, and Types
- 16.1.2 Overview of the Packages of the Standard Library
- 16.2 Simple Time Measurement and Profiling*
- 16.3 The Class Class
- 16.3.1 Obtaining a Class Object
- 16.3.2 A Class Is a Type
- 16.4 The Utility Classes System and Members
- 16.4.1 Memory of the Java Virtual Machine
- 16.4.2 Number of CPUs or Cores
- 16.4.3 System Properties of the Java Environment
- 16.4.4 Setting Custom Properties from the Console*
- 16.4.5 Newline Characters and line.separator
- 16.4.6 Environment Variables of the Operating System
- 16.5 The Languages of Different Countries
- 16.5.1 Regional Languages via Locale Objects
- 16.6 Overview of Important Date Classes
- 16.6.1 Unix Time: January 1, 1970
- 16.6.2 System.currentTimeMillis()
- 16.6.3 Simple Time Conversions via TimeUnit
- 16.7 Date-Time API
- 16.7.1 Initial Overview
- 16.7.2 Human Time and Machine Time
- 16.7.3 The LocalDate Date Class
- 16.8 Logging with Java
- 16.8.1 Logging Application Programming Interfaces
- 16.8.2 Logging with java.util.logging
- 16.9 Maven: Resolving Build Management and Dependencies
- 16.9.1 Dependency to Be Accepted
- 16.9.2 Local and the Remote Repository
- 16.9.3 Lifecycles, Stages, and Maven Plugins
- 16.10 Further Reading
- 17 Introduction to Concurrent Programming
- 17.1 Concurrency and Parallelism
- 17.1.1 Multitasking, Processes, and Threads
- 17.1.2 Threads and Processes
- 17.1.3 How Concurrent Programs Can Increase Speed
- 17.1.4 How Java Can Provide for Concurrency
- 17.2 Generating Existing Threads and New Threads
- 17.2.1 Main Thread
- 17.2.2 Who Am I?
- 17.2.3 Implementing the Runnable Interface
- 17.2.4 Starting Thread with Runnable
- 17.2.5 Parameterizing Runnable
- 17.2.6 Extending the Thread Class*
- 17.3 Thread Members and States
- 17.3.1 The Name of a Thread
- 17.3.2 The States of a Thread*
- 17.3.3 Sleepers Wanted
- 17.3.4 When Threads Are Finished
- 17.3.5 Terminating a Thread Politely Using Interrupts
- 17.3.6 Unhandled Exceptions, Thread End, and UncaughtExceptionHandler
- 17.3.7 The stop() from the Outside and the Rescue with ThreadDeath*
- 17.3.8 Stopping and Resuming the Work*
- 17.3.9 Priority*
- 17.4 Enter the Executor
- 17.4.1 The Executor Interface
- 17.4.2 Happy as a Group: The Thread Pools
- 17.4.3 Threads with return via Callable
- 17.4.4 Memories of the Future: The Future Return
- 17.4.5 Processing Multiple Callable Objects
- 17.4.6 CompletionService and ExecutorCompletionService
- 17.4.7 ScheduledExecutorService: Repetitive Tasks and Time Controls
- 17.4.8 Asynchronous Programming with CompletableFuture (CompletionStage)
- 17.5 Further Reading
- 18 Introduction to Data Structures and Algorithms
- 18.1 Lists
- 18.1.1 First List Example
- 18.1.2 Selection Criterion ArrayList or LinkedList
- 18.1.3 The List Interface
- 18.1.4 ArrayList
- 18.1.5 LinkedList
- 18.1.6 The Array Adapter Arrays.asList(...)
- 18.1.7 ListIterator*
- 18.1.8 Understanding toArray(...) of Collection: Recognizing Traps
- 18.1.9 Managing Primitive Elements in Data Structures
- 18.2 Sets
- 18.2.1 A First Example of a Set
- 18.2.2 Methods of the Set Interface
- 18.2.3 HashSet
- 18.2.4 TreeSet: The Sorted Set
- 18.2.5 The Interfaces NavigableSet and SortedSet
- 18.2.6 LinkedHashSet
- 18.3 Associative Memory
- 18.3.1 The HashMap and TreeMap Classes and Static Map Methods
- 18.3.2 Inserting and Querying the Associative Memory
- 18.4 The Stream API
- 18.4.1 Declarative Programming
- 18.4.2 Internal versus External Iteration
- 18.4.3 What Is a Stream?
- 18.5 Creating a Stream
- 18.5.1 Stream.of*(…)
- 18.5.2 Stream.generate(…)
- 18.5.3 Stream.iterate(…)
- 18.5.4 Parallel or Sequential Streams
- 18.6 Terminal Operations
- 18.6.1 Number of Elements
- 18.6.2 And Now All: forEach*(…)
- 18.6.3 Getting Individual Elements from the Stream
- 18.6.4 Existence Tests with Predicates
- 18.6.5 Reducing a Stream to Its Smallest or Largest Element
- 18.6.6 Reducing a Stream with Its Own Functions
- 18.6.7 Writing Results to a Container, Part 1: collect(...)
- 18.6.8 Writing Results to a Container, Part 2: Collector and Collectors
- 18.6.9 Writing Results to a Container, Part 3: Groupings
- 18.6.10 Transferring Stream Elements to an Array or an Iterator
- 18.7 Intermediary Operations
- 18.7.1 Element Previews
- 18.7.2 Filtering Elements
- 18.7.3 Stateful Intermediary Operations
- 18.7.4 Prefix Operations
- 18.7.5 Images
- 18.8 Further Reading
- 19 Files and Data Streams
- 19.1 Old and New Worlds in java.io and java.nio
- 19.1.1 java.io Package with the File Class
- 19.1.2 NIO.2 and the java.nio Package
- 19.2 File Systems and Paths
- 19.2.1 FileSystem and Path
- 19.2.2 The Files Utility Class
- 19.3 Random Access Files
- 19.3.1 Opening a RandomAccessFile for Reading and Writing
- 19.3.2 Reading from RandomAccessFile
- 19.3.3 Writing with RandomAccessFile
- 19.3.4 The Length of the RandomAccessFile
- 19.3.5 Back and Forth within the File
- 19.4 Base Classes for Input/Output
- 19.4.1 The Four Abstract Base Classes
- 19.4.2 The Abstract Base Class OutputStream
- 19.4.3 The Abstract Base Class InputStream
- 19.4.4 The Abstract Base Class Writer
- 19.4.5 The Appendable Interface*
- 19.4.6 The Abstract Base Class Reader
- 19.4.7 The Interfaces Closeable, AutoCloseable, and Flushable
- 19.5 Reading from Files and Writing to Files
- 19.5.1 Obtaining Byte-Oriented Data Streams via Files
- 19.5.2 Obtaining Character-Oriented Data Streams via Files
- 19.5.3 The Function of OpenOption in the Files.new*(...) Methods
- 19.5.4 Loading Resources from the Module Path and from JAR Files
- 19.6 Further Reading
- 20 Introduction to Database Management with JDBC
- 20.1 Relational Databases and Java Access
- 20.1.1 The Relational Model
- 20.1.2 Java Application Programming Interfaces for Accessing Relational Databases
- 20.1.3 The JDBC API and Implementations: The JDBC Driver
- 20.1.4 H2 Is the Tool in Java
- 20.2 A Sample Query
- 20.2.1 Steps to Query the Database
- 20.2.2 Accessing the Relational Database with Java
- 20.3 Further Reading
- 21 Bits and Bytes, Mathematics and Money
- 21.1 Bits and Bytes
- 21.1.1 The Bit Operators: Complement, AND, OR, and XOR
- 21.1.2 Representation of Integers in Java: Two’s Complement
- 21.1.3 The Binary, Octal, and Hexadecimal Place Value Systems
- 21.1.4 Effect of Typecasting on Bit Patterns
- 21.1.5 Working without Signs
- 21.1.6 The Shift Operators
- 21.1.7 Setting, Clearing, Reversing, and Testing a Bit
- 21.1.8 Bit Methods of the Integer and Long Classes
- 21.2 Floating Point Arithmetic in Java
- 21.2.1 Special Values for Infinity, Zero, and Not a Number
- 21.2.2 Standard Notation and Scientific Notation for Floats*
- 21.2.3 Mantissas and Exponents*
- 21.3 The Members of the Math Class
- 21.3.1 Object Variables of the Math Class
- 21.3.2 Absolute Values and Signs
- 21.3.3 Maximums/Minimums
- 21.3.4 Rounding Values
- 21.3.5 Remainder of an Integer Division*
- 21.3.6 Division with Rounding toward Negative Infinity and Alternative Remainders*
- 21.3.7 Multiply-Accumulate
- 21.3.8 Square Root and Exponential Methods
- 21.3.9 The Logarithm*
- 21.3.10 Angle Methods*
- 21.3.11 Random Numbers
- 21.4 Accuracy and the Value Range of Type and Overflow Control*
- 21.4.1 The Largest and Smallest Values
- 21.4.2 Overflow and Everything Entirely Exact
- 21.4.3 What in the World Does the ulp Method Do?
- 21.5 Random Numbers: Random, ThreadLocalRandom, and SecureRandom
- 21.5.1 The Random Class
- 21.5.2 ThreadLocalRandom
- 21.5.3 The SecureRandom Class*
- 21.6 Large Numbers*
- 21.6.1 The BigInteger Class
- 21.6.2 Example: Quite Long Factorials with BigInteger
- 21.6.3 Large Floats with BigDecimal
- 21.6.4 Conveniently Setting the Calculation Accuracy via MathContext
- 21.6.5 Calculating even Faster with Mutable Implementations
- 21.7 Money and Currency
- 21.7.1 Representing Amounts of Money
- 21.7.2 ISO 4217
- 21.7.3 Representing Currencies in Java
- 21.8 Further Reading
- 22 Testing with JUnit
- 22.1 Software Tests
- 22.1.1 Procedure for Writing Test Cases
- 22.2 The JUnit Testing Framework
- 22.2.1 JUnit Versions
- 22.2.2 Integrating JUnit
- 22.2.3 Test-Driven Development and the Test-First Approach
- 22.2.4 Test, Implement, Test, Implement, Test, Rejoice
- 22.2.5 Running JUnit Tests
- 22.2.6 assert*(...) Methods of the Assertions Class
- 22.2.7 Testing Exceptions
- 22.2.8 Setting Limits for Execution Times
- 22.2.9 Labels with @DisplayName
- 22.2.10 Nested Tests
- 22.2.11 Ignoring Tests
- 22.2.12 Canceling Tests with Methods of the Assumptions Class
- 22.2.13 Parameterized Tests
- 22.3 Java Assertion Libraries and AssertJ
- 22.4 Structure of Large Test Cases
- 22.4.1 Fixtures
- 22.4.2 Collections of Test Classes and Class Organization
- 22.5 Good Design Enables Effective Testing
- 22.6 Dummy, Fake, Stub, and Mock
- 22.7 JUnit Extensions and Testing Add-Ons
- 22.7.1 Web Tests
- 22.7.2 Testing the Database Interface
- 22.8 Further Reading
- 23 The Tools of the JDK
- 23.1 Overview
- 23.1.1 Structure and Common Switches
- 23.2 Translating Java Sources
- 23.2.1 The Java Compiler of the Java Development Kit
- 23.2.2 Native Compilers
- 23.3 The Java Runtime Environment
- 23.3.1 Switches of the Java Virtual Machine
- 23.3.2 The Difference between java.exe and javaw.exe
- 23.4 Documentation Comments with Javadoc
- 23.4.1 Setting a Documentation Comment
- 23.4.2 Creating Documentation with the javadoc Tool
- 23.4.3 HTML Tags in Documentation Comments*
- 23.4.4 Generated Files
- 23.4.5 Documentation Comments at a Glance*
- 23.4.6 Javadoc and Doclets*
- 23.4.7 Deprecated Types and Members
- 23.4.8 Javadoc Verification with DocLint
- 23.5 The JAR Archive Format
- 23.5.1 Using the jar Utility
- 23.5.2 The Manifest
- 23.5.3 Launching Applications in Java Archives: Executable JAR Files
- 23.6 Further Reading
- The Author
- Index
