Temario curso

Tema 1: Bloques de construcción

• Aprendiendo sobre el medio ambiente
  • Componentes principales de Java
  • Descarga de un JDK
• Comprender la estructura de clases
  • Campos y métodos
  • Comentarios
  • Clases y archivos de código fuente
• Escribir un método main()
  • Creación de un método main()
  • Pasar parámetros a un programa Java
• Descripción de las declaraciones e importaciones de paquetes
  • Paquetes
  • Comodines
  • Importaciones redundantes
  • Conflictos de nombres
  • Creación de un nuevo paquete
  • Compilar y ejecutar código con paquetes
  • Compilar en otro directorio
  • Compilación con archivos JAR
  • Creación de un archivo JAR
  • Ordenar elementos en una clase
• Creación de objetos
  • Llamar a constructores
  • Campos de miembro de lectura y escritura
  • Ejecución de bloques de inicializador de instancia
  • Siguiendo el orden de inicialización
• Descripción de los tipos de datos
  • Uso de tipos primitivos
  • Uso de tipos de referencia
  • Distinguir entre primitivas y tipos de referencia
  • Creación de clases contenedoras
  • Definición de bloques de texto
• Declaración de variables
  • Identificadores de identificación
  • Declaración de varias variables
• Inicialización de variables
  • Creación de variables locales
  • Pasar parámetros de constructor y método
  • Definición de variables de instancia y clase
  • Inferir el tipo con var
• Gestión del alcance de la variable
  • Alcance limitado
  • Ámbito de seguimiento
  • Aplicar el ámbito a las clases
  • Revisión del alcance
• Destrucción de objetos
  • Descripción de la recolección de elementos no utilizados
  • Elegibilidad de rastreo

Tema 2: Operadores

• Descripción de los operadores de Java
  • Tipos de operadores
  • Prioridad del operador
• Aplicación de operadores unarios
  • Operadores de complemento y negación
  • Operadores de incremento y decremento
• Trabajar con operadores aritméticos binarios
  • Operadores aritméticos
  • Promoción numérica
• Asignación de valores
  • Operador de asignación
  • Valores de fundición
  • Operadores de asignación compuesta
  • Valor devuelto de los operadores de asignación
• Comparación de valores
  • Operadores de igualdad
  • Operadores relacionales
  • Operadores lógicos
  • Operadores condicionales
• Tomar decisiones con el operador ternario

Tema 3: Toma de decisiones

• Creación de declaraciones de toma de decisiones
  • Sentencias y bloqueos
  • La sentencia if
  • La sentencia else
  • Acortamiento de código con coincidencia de patrones
• Aplicación de sentencias switch
  • La sentencia switch
  • La expresión switch
• Escribir bucles while
  • La sentencia while
  • La instrucción do/while
  • Bucles infinitos
• Construcción de bucles for
  • El bucle for
  • El bucle for-each
• Control del flujo con ramificación
  • Bucles anidados
  • Adición de etiquetas opcionales
  • La sentencia break
  • La sentencia continue
  • La sentencia de return
  • Código inalcanzable
  • Revisión de la bifurcación

Tema 4: Core APIs

• Creación y manipulación de cadenas
  • Concatenar
  • Métodos de cadena importantes
  • Encadenamiento de métodos
• Uso de la clase StringBuilder
  • Mubilidad y encadenamiento
  • Creación de un StringBuilder
  • Métodos importantes de StringBuilder
• Comprender la igualdad
  • Comparando iguales() y ==
  • El grupo de cadenas
• Descripción de las matrices
  • Creación de una matriz de primitivas
  • Creación de una matriz con variables de referencia
  • Uso de una matriz
  • Ordenación
  • Minucioso
  • Comparar
  • Uso de métodos con Varargs
• Trabajo con matrices multidimensionales
  • Cálculo con API matemáticas
  • Encontrar el mínimo y el máximo
  • Redondeo de números
  • Determinación del techo y el suelo
  • Cálculo de exponentes
  • Generación de números aleatorios
• Trabajar con fechas y horas
  • Creación de fechas y horas
  • Manipulación de fechas y horas
  • Trabajar con períodos
  • Trabajar con duraciones
  • Período vs. duración
  • Trabajar con Instants
  • Contabilización del horario de verano

Tema 5: Métodos

• Métodos de diseño
  • Modificadores de acceso
  • Especificadores opcionales
  • Tipo de valor devuelto
  • Nombre del método
  • Lista de parámetros
  • Firma del método
  • Lista de excepciones
  • Cuerpo del método
• Declaración de variables locales y de instancia
  • Modificadores de variables locales
  • Variables finales efectivas
  • Modificadores de variables de instancia
• Trabajar con Varargs
  • Creación de métodos con Varargs
  • Llamar a métodos con Varargs
  • Acceso a elementos de un Vararg
  • Uso de Varargs con otros parámetros de método
• Aplicación de modificadores de acceso
  • Acceso privado
  • Acceso a paquetes
  • Acceso protegido
  • Acceso público
  • Revisión de modificadores de acceso
• Acceso a datos estáticos
  • Diseño de métodos y variables estáticos
  • Acceso a una variable o método estático
  • Pertenencia a clases frente a instancias
  • Modificadores de variables estáticas
  • Inicializadores estáticos
  • Importaciones estáticas
• Pasar datos entre métodos
  • Pasar objetos
  • Devolver objetos
  • Variables de conversión automática y unboxing
• Sobrecargar métodos
  • Tipos de referencia
  • Primitivas
  • Boxeo automático
  • Matrices
  • Varargs
  • Poniéndolo todo junto

Tema 6: Diseño de clases

• Descripción de la herencia
  • Declaring a Subclass
  • Modificadores de clase
  • Herencia única frente a herencia múltiple
  • Heredar Object
• Creación de clases
  • Extender una clase
  • Aplicación de modificadores de acceso a clases
  • Acceso a la referencia this
  • Llamando a la referencia super
• Declaración de Constructores
  • Creación de un constructor
  • El constructor predeterminado
  • Llamar a constructores sobrecargados con this()
  • Llamar a constructores principales con super()
• Inicialización de objetos
  • Inicialización de clases
  • Inicialización de campos finales
  • Inicialización de instancias
• Heredar miembros
  • Anulación de un método
  • Volver a declarar métodos privados
  • Ocultar métodos estáticos
  • Ocultar variables
  • Métodos finales de escritura
• Creación de clases abstractas
  • Introducción a las clases abstractas
  • Métodos de declaración abstracta
  • Creación de una clase concreta
  • Creación de constructores en clases abstractas
  • Detección de declaraciones no válidas
• Creación de objetos inmutables
  • Declaración de una clase inmutable
  • Realización de una copia defensiva

Tema 7: Más allá de las clases

• Implementación de interfaces
  • Declaración y uso de una interfaz
  • Ampliación de una interfaz
  • Heredar una interfaz
  • Insertar modificadores implícitos
  • Declaración de métodos de interfaz concretos
• Trabajar con enumeraciones
  • Creación de enumeraciones simples
  • Uso de enumeraciones en instrucciones switch
  • Agregar constructores, campos y métodos
• Clases de sellado
  • Declaración de una clase sellada
  • Compilación de clases selladas
  • Especificar el modificador de subclase
  • Omitir la cláusula de permisos
  • Interfaces de sellado
  • Revisión de las reglas de la clase sellada
• Encapsulación de datos con registros
  • Descripción de la encapsulación
  • Aplicación de registros
  • Descripción de la inmutabilidad de registros
  • Declaring Constructores
  • Personalización de registros
• Creación de clases anidadas
  • Declarar una clase interna
  • Creación de una clase anidada estática
  • Escribir una clase local
  • Definir una clase anónima
  • Revisión de clases anidadas
• Entendiendo el polimorfismo
  • Objeto vs. Referencia
  • Objetos de fundición
  • La instancia de Operator
  • Polimorfismo y anulación de métodos
  • Anular vs. ocultar miembros

Tema 8: Lambdas e interfaces funcionales

• Escribir lambdas simples
  • Mirando un ejemplo de Lambda
  • Aprender la sintaxis de Lambda
• Codificación de interfaces funcionales
  • Definición de una interfaz funcional
  • Agregar métodos de objeto
• Uso de referencias de métodos
  • Llamar a métodos estáticos
  • Llamar a métodos de instancia en un objeto determinado
  • Llamar a métodos de instancia en un parámetro
  • Llamar a constructores
  • Revisión de referencias de métodos
• Trabajar con interfaces funcionales integradas
  • Proveedor Implementador
  • Implementación de Consumer y BiConsumer
  • Implementación de predicado y bipredicado
  • Implementación de la función y BiFunction
  • Implementación de UnaryOperator y BinaryOperator
  • Comprobación de interfaces funcionales
  • Uso de métodos de conveniencia en interfaces funcionales
  • Aprendiendo las interfaces funcionales para primitivas
• Trabajar con variables en Lambdas
  • Parámetros de listado
  • Uso de variables locales dentro de un cuerpo de Lambda
  • Hacer referencia a variables desde el cuerpo de Lambda

Tema 9: Colecciones y genéricos

• Uso de API de recopilación comunes
  • Uso del operador Diamond
  • Agregar datos
  • Eliminación de datos
  • Elementos de conteo
  • Limpiar la colección
  • Comprobar contenido
  • Eliminación con condiciones
  • Iterar
  • Determinación de la igualdad
• Uso de la interfaz de lista
  • Comparación de implementaciones de listas
  • Crear una lista con una fábrica
  • Crear una lista con un constructor
  • Trabajar con métodos de lista
  • Conversión de lista a matriz
• Uso de la interfaz Set
  • Comparación de implementaciones de conjuntos
  • Trabajar con métodos de conjunto
• Uso de las interfaces Queue y Deque
  • Comparación de implementaciones de Deque
  • Trabajar con métodos Queue y Deque
• Uso de la interfaz de map
  • Comparación de implementaciones de mapas
  • Trabajar con métodos de mapa
  • Llamar a métodos básicos
  • Iteración a través de un mapa
  • Obtención de valores de forma segura
  • Sustitución de valores
  • Poner si está ausente
  • Fusión de datos
• Comparación de tipos de colección
• Clasificación de datos
  • Creación de una clase comparable
  • Comparación de datos con un comparador
  • Comparación de comparables y comparadores
  • Comparación de varios campos
  • Clasificación y búsqueda
  • Ordenar una lista
• Trabajar con genéricos
  • Creación de clases genéricas
  • Descripción del borrado de tipos
  • Implementación de interfaces genéricas
  • Escribir métodos genéricos
  • Creación de un registro genérico
  • Tipos genéricos delimitadores
  • Poniéndolo todo junto

Tema 10: Streams

• Devolución de un Opcional
  • Crear un opcional
  • Tratar con un opcional vacío
• Uso de secuencias
  • Descripción del flujo de canalización
  • Creación de orígenes de transmisión
  • Uso de operaciones de terminal comunes
  • Uso de operaciones intermedias comunes
  • Armando el pipeline
• Trabajar con secuencias primitivas
  • Creación de secuencias primitivas
  • Mapeo de flujos
  • Uso de opcional con secuencias primitivas
  • Resumen de estadísticas
• Trabajar con conceptos avanzados de canalización de flujos
  • Vinculación de flujos a los datos subyacentes
  • Encadenamiento de opcionales
  • Uso de un divisor
  • Recopilación de resultados

Tema 11: Excepciones y localización

• Descripción de las excepciones
  • El papel de las excepciones
  • Descripción de los tipos de excepción
  • Iniciar una excepción
  • Llamar a métodos que producen excepciones
  • Anulación de métodos con excepciones
  • Impresión de una excepción
• Reconocimiento de clases de excepción
  • Clases RuntimeException
  • Clases de excepción activadas
  • Clases de error
• Manejo de excepciones
  • Uso de instrucciones try and catch
  • Bloqueo de encadenamiento de bloques
  • Aplicación de un bloque de captura múltiple
  • Adición de un bloque finally
• Automatización de la gestión de recursos
  • Presentación de Try-with-Resources
  • Conceptos básicos de Probar con recursos
  • Aplicación efectiva de la versión final
  • Descripción de las excepciones suprimidas
• Valores de formato
  • Dar formato a los números
  • Formato de fechas y horas
  • Personalización del formato de fecha/hora
• Apoyo a la internacionalización y la localización
  • Recolección local
  • Localización de números
  • Localización de fechas
  • Especificación de una categoría de configuración regional
• Carga de propiedades con agrupaciones de recursos
  • Creación de un paquete de recursos
  • Elegir un paquete de recursos
  • Selección de valores de agrupación de recursos
  • Dar formato a los mensajes
  • Uso de la clase Properties

Tema 12: Módulos

• Introducción a los módulos
  • Explorando un módulo
  • Beneficios de los módulos
• Creación y ejecución de un programa modular
  • Creación de los archivos
  • Compilando nuestro primer módulo
  • Ejecución de nuestro primer módulo
  • Empaquetando nuestro primer módulo
• Actualización de nuestro ejemplo para varios módulos
  • Actualización del módulo de alimentación
  • Creación de un módulo de atención
  • Creación del módulo de charlas
  • Creación del módulo de personal
• Profundizando en la Declaración del Módulo
  • Exportación de un paquete
  • Requerir un módulo de forma transitiva
  • Abrir un paquete
• Creación de un servicio
  • Declaración de la interfaz del proveedor de servicios
  • Creación de un localizador de servicios
  • Invocación de un consumidor
  • Adición de un proveedor de servicios
  • Revisión de directivas y servicios
• Descubriendo módulos
  • Identificación de módulos integrados
  • Obtención de detalles con java
  • Describir con jar
  • Aprender sobre las dependencias con jdeps
  • Usando el indicador - -j dk- internals
  • Uso de archivos de módulo con jmod
  • Creación de tiempos de ejecución de Java con jlink
  • Revisión de las opciones de la línea de comandos
• Comparación de tipos de módulos
  • Módulos con nombre
  • Módulos automáticos
  • Módulos sin nombre
  • Revisión de los tipos de módulos
• Migración de una aplicación
  • Determinación de la orden
  • Exploración de una estrategia de migración ascendente
  • Explorando una estrategia de migración de arriba hacia abajo
  • Dividir un proyecto grande en módulos
  • No compilar con una dependencia cíclica

Tema 13: Concurrencia

• Introducción a los hilos
  • Descripción de la simultaneidad de subprocesos
  • Creación de un hilo
  • Distinción de los tipos de roscas
  • Administrar el ciclo de vida de un subproceso
  • Sondeo con suspensión
  • Interrumpir un hilo
• Creación de subprocesos con la API de simultaneidad
  • Presentación del ejecutor de un solo subproceso
  • Cierre de un ejecutor de subprocesos
  • Envío de tareas
  • A la espera de los resultados
  • Programación de tareas
  • Aumento de la simultaneidad con grupos
• Escribir código seguro para subprocesos
  • Descripción de la seguridad de los subprocesos
  • Acceso a datos con volátiles
  • Protección de datos con clases atómicas
  • Mejorar el acceso con bloques sincronizados
  • Sincronización en métodos
  • Descripción del marco de bloqueo
  • Orquestación de tareas con CyclicBarrier
• Uso de colecciones simultáneas
  • Descripción de los errores de coherencia de memoria
  • Trabajar con clases simultáneas
  • Obtención de colecciones sincronizadas
• Identificación de problemas de subprocesos
  • Comprender la vida
  • Gestión de las condiciones de carrera
• Trabajar con secuencias paralelas
  • Creación de secuencias paralelas
  • Realización de una descomposición paralela
  • Procesamiento de reducciones paralelas

Tema 14: E/S

• Hacer referencia a archivos y directorios
  • Conceptualización del sistema de archivos
  • Creación de un archivo o una ruta de acceso
• Funcionamiento en archivo y ruta de acceso
  • Uso de la funcionalidad compartida
  • Control de métodos que declaran IOException
  • Proporcionar parámetros opcionales NIO.2
  • Interacción con las rutas de NIO.2
  • Crear, mover y eliminar archivos y directorios
  • Comparación de archivos con isSameFile() y mismatch()
• Presentación de flujos de E/S
  • Descripción de los fundamentos de la transmisión de E/S
  • Aprendizaje de la nomenclatura de flujo de E/S
• Lectura y escritura de archivos
  • Uso de flujos de E/S
  • Mejorar con archivos
  • Combinación con newBufferedReader() y newBufferedWriter()
  • Revisión de métodos comunes de lectura y escritura
• Serialización de datos
  • Aplicación de la interfaz serializable
  • Marcado de datos transitorios
  • Asegurarse de que una clase es serializable
  • Almacenamiento de datos con ObjectOutputStream y ObjectInputStream
  • Descripción del proceso de creación de la deserialización
• Interacción con los usuarios
  • Impresión de datos al usuario
  • Lectura de la entrada como una secuencia de E/S
  • Cierre de flujos del sistema
  • Adquisición de entradas con la consola
• Trabajar con API avanzadas
  • Manipulación de flujos de entrada
  • Detección de atributos de archivo
  • Recorrer un árbol de directorios
  • Búsqueda en un directorio
• Revisión de las API clave