Parte 1: Fundamentos

Cómo usar esta parte¶

Esta parte introduce Java desde una lógica late objects: primero se construyen las bases del lenguaje, de las herramientas y del modelo de ejecución; después se profundiza en testing, archivos y memoria.

Orden sugerido de lectura¶

Capítulos nucleares¶

Estos capítulos conviene dominarlos sí o sí antes de avanzar a orientación a objetos:

Repaso y ampliación¶

Estos capítulos cumplen mejor un rol de contexto, consolidación o profundización:

Orígenes e Historia de Java¶

• El Nacimiento de Java: El Green Project

  • El contexto: Sun Microsystems y los años 90

  • El Green Team y el proyecto secreto

  • El Green Team: Los Arquitectos Originales

  • ¿Por qué necesitaban un nuevo lenguaje?

  • El Desafío Tecnológico frente a C/C++

  • Los Cinco Principios de Diseño Originales

• La Máquina Virtual de Java (JVM) y el Bytecode

  • ¿Qué es una máquina virtual?

  • ¿Qué es el bytecode?

  • ¿Cómo funciona el flujo WORA?

  • Estructura Interna de la JVM

  • El Modelo de Seguridad: El Sandbox

• El Salto a la Web (1995)

  • El fracaso comercial inicial

  • La oportunidad de la World Wide Web

  • El lanzamiento y los Applets

  • ¿Qué son exactamente los Applets?

  • Competidores y el Contexto Tecnológico de los 90

  • La Guerra de los Navegadores y Microsoft

• Evolución y la Era de Oracle

  • De Sun Microsystems a Oracle (2010)

  • Jakarta EE: El ecosistema empresarial

  • El Ciclo Moderno de Lanzamientos

  • Línea Temporal de las Versiones Principales

• Impacto y Legado

  • ¿Dónde se usa Java hoy?

  • El Ecosistema de Herramientas

  • Lenguajes sobre la JVM

• Java en la Actualidad y el Futuro

  • Estadísticas de Adopción

  • Proyectos de Innovación Activos

  • GraalVM: El Futuro de la Ejecución

• Referencias Bibliográficas

• Ejercicios

Características del Lenguaje Java¶

• Lenguaje de Propósito General

  • ¿Qué significa “propósito general”?

  • Aplicaciones donde Java es utilizado

  • ¿Significa que Java es la mejor opción para todo?

  • Ventajas de aprender un lenguaje de propósito general

• Tipado Estático y Fuerte

  • ¿Qué es un “tipo” en programación?

  • Tipado Estático: los tipos se verifican ANTES de ejecutar

  • Tipado Fuerte: conversiones explícitas obligatorias

  • Comparación con Tipado Dinámico (Python)

  • Ventajas del tipado estático y fuerte

  • Tabla comparativa de sistemas de tipos

• La Estructura Obligatoria: Clases en Java

  • ¿Por qué todo debe estar en una clase?

  • La clase como “contenedor obligatorio”

  • El programa Java más simple

  • Métodos Estáticos: Funciones sin necesidad de objetos

  • ¿Por qué empezar con métodos estáticos?

• Diferencias Clave entre Java y C

  • Ejemplo lado a lado

• Resumen

• Referencias Bibliográficas

• Ejercicios

Tipos de Datos en Java¶

• Declaración de Variables

  • Ejemplos de Declaración

  • Convención de Nombres

• Tipos Primitivos

  • ¿Qué significa “tipo primitivo”?

  • Portabilidad: Tamaños Garantizados

  • Tabla de Tipos Primitivos

  • ¿Por qué tantos tipos enteros?

  • Comparativa de Tamaños con C

• Tipos Enteros en Detalle

  • byte (8 bits)

  • short (16 bits)

  • int (32 bits) — El Tipo Entero Principal

  • long (64 bits)

  • Literales Enteros en Diferentes Bases

  • Separador de Dígitos (Guión Bajo)

• Tipos de Punto Flotante

  • ¿Qué significa “punto flotante”?

  • float (32 bits) — Precisión Simple

  • double (64 bits) — Precisión Doble — El Tipo Decimal Principal

  • Notación Científica

  • Representación IEEE 754 — Cómo se almacenan los decimales

  • El Problema de la Precisión — ¡Importante!

  • Valores Especiales de Punto Flotante

• El Tipo boolean — Verdadero o Falso

  • Diferencia Crítica con C

  • ¿Por qué Java es tan estricto?

  • Operaciones con boolean

• El Tipo char — Caracteres Unicode

  • ¿Por qué 16 bits?

  • Secuencias de Escape

  • char como Valor Numérico

  • Diferencia con C: char es sin signo

• Constantes con final

  • ¿Para qué sirven las constantes?

  • Comparativa con C

  • Constantes locales vs constantes de clase

• Operadores

  • Operadores Aritméticos

  • División Entera vs División Real — ¡Cuidado!

  • Operador Módulo (Resto)

  • Operadores de Asignación Compuesta — Prohibidos en el Curso

  • Operadores Relacionales (Comparación)

  • Operadores Lógicos

  • Evaluación en Cortocircuito — Muy Importante

  • Operadores de Bits

  • Operador >>> — Exclusivo de Java

  • Precedencia de Operadores

• Conversiones de Tipo (Casting)

  • Conversiones Implícitas (Promoción Automática / Widening)

  • Conversiones Explícitas (Casting / Narrowing)

  • Truncamiento vs Redondeo

  • Promoción Automática en Expresiones

  • Resumen de Conversiones

  • Conversiones entre String y Tipos Primitivos

  • Comparación con Python

• Ejercicios de Aplicación

• Referencias Bibliográficas

Métodos en Java¶

• ¿Por qué usar métodos?

• Anatomía de un Método

  • Sintaxis General

  • Comparación con C

  • Ejemplos de Declaración

• Invocación de Métodos

  • Invocación Básica

  • El Flujo de Ejecución Durante una Llamada

• Tipos de Retorno

  • Métodos void

  • Métodos con Retorno

• Parámetros y Argumentos

  • Parámetros Múltiples

  • Orden de los Argumentos

  • Compatibilidad de Tipos y Promoción Automática

• Firma de un Método y Sobrecarga

  • ¿Qué es la Firma de un Método?

  • ¿Qué es la Sobrecarga?

  • Ejemplos de Sobrecarga

  • Resolución de Sobrecarga (Overload Resolution)

• Mecanismo de Pasaje de Parámetros

  • Pasaje de Tipos Primitivos

  • Pasaje de Referencias (Tipos no Primitivos)

  • Resumen del Pasaje de Parámetros

• Alcance de Variables (Scope)

  • Variables Locales

  • Variables de Bloque

  • Parámetros como Variables Locales

  • Sombreado de Variables (Shadowing)

• Gestión de la Pila: Stack Frames

  • ¿Qué Contiene un Stack Frame?

  • El Ciclo de Vida de un Frame

  • Ejemplo de Flujo de Ejecución

  • Recursión y StackOverflowError

• Métodos Estáticos vs. de Instancia

  • Comparación Rápida

• Ejercicios

• Buenas Prácticas para Métodos

  • Nombres descriptivos

  • Métodos Cortos y Enfocados (Principio de Responsabilidad Única)

  • Evitar Efectos Secundarios Inesperados

  • Documentación con Javadoc

  • Limitar la Cantidad de Parámetros

• Referencias Bibliográficas

Varargs: Cantidad Variable de Argumentos¶

• Varargs: Cantidad Variable de Argumentos

  • Sintaxis y Uso

  • Implementación Interna

  • Restricciones

Sintaxis de Java: Control de Flujo¶

• Lógica Booleana y Cortocircuito

  • Operadores Relacionales

  • Operadores Lógicos

  • Evaluación en Cortocircuito (Short-circuit Evaluation)

• Estructuras Condicionales

  • La Sentencia if

  • La Sentencia if-else

  • La Sentencia if-else if-else

  • Condicionales Anidados

  • El Operador Ternario ? :

  • La Sentencia switch

• Estructuras de Repetición: Lazos

  • El Lazo for

  • El Lazo while

  • El Lazo do-while

  • Comparación de Lazos

  • Equivalencia entre for y while

  • Lazos Anidados

  • Lazos Infinitos y Cómo Evitarlos

• Sentencias de Control de Flujo: break y continue

  • La Sentencia break

  • La Sentencia continue

  • Uso Permitido de break: en switch

• Comparativa de Seguridad con C

  • 1. Asignación en Condiciones

  • 2. Inicialización Obligatoria

  • 3. Tipo Booleano Estricto

  • 4. Alcance de Variables en Lazos

• Ejercicios de Nivel Universitario

• Referencias Bibliográficas

Entrada y Salida de Datos¶

• ¿Qué es un Stream?

• Arquitectura de los Flujos de Sistema

  • Los Tres Flujos Estándar

  • ¿Qué es un Búfer?

• Salida de Datos: Métodos de Impresión

  • print() - Impresión Sin Salto de Línea

  • println() - Impresión Con Salto de Línea

  • Concatenación de Valores en print/println

  • printf() - Impresión Formateada

  • Comparación con printf() de C

• Formateo Completo con printf

  • Sintaxis General de un Especificador de Formato

  • Especificadores de Conversión

  • Ancho de Campo

  • Precisión

  • Combinación de Ancho y Precisión

  • Banderas de Formato

  • Combinación de Múltiples Banderas

  • Indexación de Argumentos

  • Tablas Formateadas

  • Formateo de Fechas y Horas

• Entrada de Datos con Scanner

  • Creación de un Scanner

  • Métodos de Lectura

  • ¿Qué es un Token?

  • Diferencia entre next() y nextLine()

  • Verificación de Entrada con hasNext

  • El Problema del Salto de Línea Residual

  • Patrón Alternativo: Leer Todo como Línea

  • Localización y Separador Decimal

  • Cierre del Scanner

  • Lectura de Datos en un Lazo

• Comparación de Métodos de Salida

• Secuencias de Escape

• Temas Avanzados (Referencia)

  • System.console() - Interacción con Terminal

  • Rendimiento: Scanner vs. BufferedReader

• Ejercicios

• Referencias Bibliográficas

Guía Práctica de Gradle¶

• Introducción

• ¿Qué es Gradle?

  • Comparación con Make (de C)

  • ¿Qué automatiza Gradle?

• Estructura del Proyecto

  • Visión general

  • Explicación de cada componente

  • El directorio src/ en detalle

  • Comparación con la estructura de C

• Gradle Wrapper: Tu Mejor Amigo

  • ¿Qué es el Wrapper?

  • ¿Por qué usar el Wrapper?

  • Cómo usar el Wrapper

  • La primera ejecución

• Comandos Básicos de Gradle

  • El modelo de tareas de Gradle

  • Compilar el proyecto

  • Ejecutar tests

  • Limpiar archivos generados

  • Ejecutar la aplicación

  • Ver todas las tareas disponibles

  • Combinando tareas

• Trabajando con IntelliJ IDEA

  • Panel de Gradle

  • Ejecutar tests desde el IDE

  • Ejecutar aplicación desde el IDE

• Estructura de un Archivo Java en el Proyecto

  • Aplicaciones (clases con main)

  • Clases de negocio

  • Clases de test

• Ciclo de Trabajo Típico

  • El ciclo Red-Green-Refactor con Gradle

  • Durante el desarrollo de un ejercicio

  • Antes de hacer commit

  • Cuando algo no funciona

  • Flujo completo de un TP

• Comandos de Verificación

  • ¿Qué es el análisis estático?

  • Checkstyle: Verificar estilo de código

  • PMD: Analizar problemas de código

  • SpotBugs: Detectar bugs potenciales

  • JaCoCo: Cobertura de tests

  • Análisis completo

• Reportes Generados

  • Cómo ver los reportes

• Problemas Comunes y Soluciones

  • Error: “Permission denied” al ejecutar gradlew

  • Error: “Cannot find symbol” al compilar

  • Error: “package ar.unrn does not exist”

  • Error: Tests no se encuentran

  • Error: “Gradle daemon disappeared unexpectedly”

  • Error: “Could not resolve all dependencies”

  • Error: “Class has already been declared in this compilation unit”

  • IntelliJ no reconoce las clases

  • Error: “Execution failed for task ‘:checkstyleMain’”

  • Error: “org.gradle.api.GradleException: Spotbugs violations”

  • La compilación es muy lenta

• Trabajando sin IntelliJ (solo terminal)

  • Estructura mínima de trabajo

  • Crear un nuevo archivo Java

  • Plantilla básica de clase

  • Plantilla básica de test

  • Flujo de trabajo en terminal

  • Ver errores de compilación

  • Navegando los archivos del proyecto

• Tips y Trucos

  • Ejecutar tareas en paralelo

  • Ver qué está haciendo Gradle

  • Ejecutar solo tests específicos

  • Excluir tareas

  • Ver dependencias del proyecto

  • Actualizar el wrapper de Gradle

• Entendiendo build.gradle

  • Estructura básica

  • Tipos de dependencias

  • ¿Por qué no modificar build.gradle?

• Configuración Avanzada (Opcional)

  • Configurar Java en el sistema

  • Configurar Gradle Daemon

  • Archivo gradle.properties

• Comandos de Referencia Rápida

• Checklist para Entregar un TP

  • Lista de verificación manual

• Preguntas Frecuentes

  • ¿Tengo que instalar Gradle?

  • ¿Puedo usar otra versión de Java?

  • ¿Por qué tarda tanto la primera vez?

  • ¿Qué hago si Gradle se cuelga?

  • ¿Puedo ejecutar Gradle desde cualquier directorio?

  • ¿Qué significa “FAILED”?

  • ¿Cómo sé si mi código está bien?

• Recursos Adicionales

  • Documentación oficial

  • En el repositorio de la cátedra

  • Videos recomendados

• Resumen

• Ejercicios de Práctica

Testing con JUnit 5¶

• Del Testing Manual en C al Automatizado en Java

• JUnit: Framework de Testing para Java

  • Historia breve

  • Configuración del proyecto

  • Estructura de un proyecto con tests

• Primer Test con JUnit

  • Código de producción

  • Clase de test

  • Anatomía de un test

  • Ejecutar los tests

  • Interpretación de resultados

• Assertions: Verificaciones en JUnit

  • Assertions básicos

  • Assertions para colecciones y arrays

  • Verificación de excepciones

  • Assertions compuestos

  • Mensajes de falla descriptivos

• Ciclo de Vida de los Tests

  • Anotaciones de ciclo de vida

  • Orden completo de ejecución

  • Ejemplo completo del ciclo de vida

• Convenciones de Nombrado

  • Estructura del nombre

  • Ejemplos prácticos

  • Patrones de nombres útiles

  • Nombres descriptivos vs concisos

• Reglas de Estilo para Testing

  • Regla 0x4000: Nomenclatura de la clase de test

  • Regla 0x4001: Estructura AAA

  • Regla 0x4002: Una llamada por test

  • Regla 0x4003: Nombres descriptivos

  • Regla 0x4004: Sin lógica condicional

  • Regla 0x4005: Tests independientes

• Tests Parametrizados

  • Anotación @ParameterizedTest

  • Fuentes de parámetros

  • Nombres personalizados para tests parametrizados

• Tests de Excepciones

  • Verificar que se lanza excepción

  • Verificar mensaje de excepción

  • Verificar causa de excepción

  • Múltiples verificaciones sobre excepción

  • Tests con try-catch

• Casos de Prueba Completos

  • Ejemplo 1: Test de funciones matemáticas

  • Ejemplo 2: Test de validador de emails

  • Ejemplo 3: Test de utilidades de strings

  • Ejemplo 4: Test de procesamiento de arreglos

• Organización de Tests

  • Tests por funcionalidad

  • Clases anidadas con @Nested

• Cobertura de Tests

  • Tipos de cobertura

  • Herramientas de cobertura

  • Interpretación de cobertura

  • Meta razonable

• Buenas Prácticas

  • FIRST: Características de buenos tests

  • Principios adicionales

• Anti-patrones en Testing

  • Tests frágiles

  • Tests que ignoran excepciones

  • Assertions múltiples sin mensajes descriptivos

• Test-Driven Development con JUnit

  • Aplicando TDD con JUnit en la Práctica

  • Tips para TDD con JUnit

• Estrategias de Testing con JUnit

  • Análisis de Valores Límite (Boundary Value Analysis)

  • Particiones de Equivalencia

  • Casos de Prueba Especiales

• Test Smells con JUnit

  • Test interdependiente

  • Test obscuro

  • Test con lógica compleja

  • Test demasiado largo

  • Assertion redundante

  • Test silencioso

• Debugging de Tests Fallidos con JUnit

  • 1. Leer el mensaje de error completo

  • 2. Ejecutar solo ese test

  • 3. Agregar prints temporales

  • 4. Usar el debugger del IDE

  • 5. Simplificar el test

  • 6. Verificar precondiciones

  • 7. Revisar cambios recientes

  • Ejemplo de debugging completo

• Resumen

• Ejercicios

Arreglos en Java¶

• ¿Qué es un Arreglo?

• Características Fundamentales

• Declaración de Arreglos

• Creación de Arreglos

  • Valores por Defecto

  • Creación con Inicialización

  • Separación de Declaración e Inicialización

• Acceso a Elementos

  • Índices Válidos

  • El Atributo length

  • Verificación de Límites

• Recorrido de Arreglos

  • Recorrido con for Clásico

  • Recorrido con for-each

  • Recorrido Parcial

  • Recorrido Inverso

  • Recorrido con while

  • Recorrido con Bandera (Patrón de Búsqueda)

• Arreglos como Referencias

  • ¿Qué es una Referencia?

  • Asignación de Referencias (Alias)

  • Comparación de Arreglos

  • Copia de Arreglos

• Arreglos y Métodos

  • Pasaje de Arreglos a Métodos

  • Retorno de Arreglos

  • Patrón: Método que Calcula sin Modificar

  • Reasignación de la Referencia dentro del Método

• Arreglos Multidimensionales

  • Concepto: Arreglo de Arreglos

  • Declaración y Creación de Matrices

  • Inicialización de Matrices

  • Recorrido de Matrices

  • Recorrido con for-each

  • Matrices Irregulares (Jagged Arrays)

• Operaciones Comunes con Arreglos

  • Encontrar Máximo y Mínimo

  • Sumar Elementos

  • Calcular Promedio

  • Contar Elementos que Cumplen una Condición

  • Verificar si Todos/Alguno Cumple una Condición

  • Invertir Arreglo

• Clase Arrays (Utilidades)

  • Métodos Principales

  • Resumen de Métodos de Arrays

• Ejercicios de Aplicación

  • Ejercicios de Comprensión

  • Ejercicios de Programación

• Resumen

  • Comparación Java vs C

• Referencias Bibliográficas

Excepciones en Java¶

• ¿Qué es una excepción?

• El Problema del Manejo de Errores en C

  • Valores de retorno especiales

  • El problema con errno

  • Problemas de este enfoque

• La Solución de Java: Excepciones

  • Analogía con la vida real

  • Código de ejemplo

  • Ventajas del enfoque de excepciones

• Sintaxis Básica: try-catch

  • Estructura Fundamental

  • Ejemplo Práctico: División por Cero

  • Múltiples Bloques catch

  • Captura Múltiple (Java 7+)

• El Bloque finally

  • ¿Por qué necesitamos finally?

  • Flujo de Ejecución con finally

  • finally se ejecuta incluso con return

• Tipos de Excepciones

  • La clase Throwable

  • Jerarquía de Throwable

  • Error vs Exception

  • Excepciones Checked vs Unchecked

  • ¿Por qué esta distinción?

  • Regla para recordar

  • Excepciones Comunes en Java

• Lanzar Excepciones: throw

  • ¿Cuándo lanzar una excepción?

  • Comparación con C

  • Validación de Precondiciones

• Declarar Excepciones: throws

  • throw vs throws

  • ¿Cuándo usar throws?

  • Propagar vs Manejar

  • El método main y las excepciones checked

• El Costo de las Excepciones

  • ¿Por qué son costosas?

  • El stack trace: tu mejor amigo para debugging

  • Cuándo es apropiado usar excepciones

• Información de la Excepción

  • Métodos principales de una excepción

  • ¿Cuándo usar cada método?

• Try-with-resources (Java 7+)

  • Sintaxis básica

  • Comparación con el enfoque manual

  • Múltiples recursos

  • ¿Qué recursos se pueden usar?

• Encadenamiento de Excepciones

  • Preservando la causa

  • Recuperando la causa

  • ¿Por qué encadenar excepciones?

• Buenas Prácticas

  • 1. No Silenciar Excepciones

  • 2. Capturar Excepciones Específicas

  • 3. Mensajes Descriptivos

  • 4. Limpiar Recursos Siempre

  • 5. Prevenir es Mejor que Curar

• Comparativa Final: C vs Java

• Ejercicios de Aplicación

Fundamentos del Testing de Software¶

• Del Testing Manual al Automatizado

  • El Problema con el Testing Manual

  • La Solución: Testing Automatizado

• ¿Por Qué Testeamos?

  • Beneficios del Testing Automatizado

• La Pirámide de Testing

  • Tests Unitarios (Base)

  • Tests de Integración (Medio)

  • Tests End-to-End (Cima)

• Verificación vs Validación

• Taxonomía de Defectos

• Principios F.I.R.S.T.

  • Fast (Rápida)

  • Independent (Independiente)

  • Repeatable (Repetible)

  • Self-validating (Autovalidable)

  • Timely (Oportuno)

• Desarrollo Guiado por Pruebas (TDD)

  • El Ciclo RED-GREEN-REFACTOR

  • ¿Por qué escribir tests primero?

  • Beneficios de TDD

  • Ejemplo Completo: Función Factorial

  • Las Tres Reglas del TDD

  • Patrones de TDD

  • TDD vs Test-After

  • Beneficios y Críticas del TDD

• Estrategias de Diseño de Casos de Prueba

  • Técnicas de Caja Negra

  • Técnicas de Caja Blanca

  • Casos Especiales a Considerar

• Cobertura de Código

  • Tipos de Cobertura

  • Herramientas

  • Meta Razonable

• Antipatrones de Testing

  • Tests Frágiles

  • Tests que Prueban la Implementación

  • Tests sin Aserciones

• Ejercicios Conceptuales

• Referencias Bibliográficas

Manejo de Archivos en Java¶

• ¿Por qué necesitamos archivos?

  • Memoria RAM vs. Disco

• Conceptos Fundamentales: Cómo funcionan los archivos

  • El Sistema de Archivos

  • Rutas Absolutas vs. Relativas

  • Bytes vs. Caracteres: Una distinción crucial

  • El concepto de “Flujo” (Stream)

  • El Buffering: Por qué es importante

• NIO.2: La API Moderna de Java

  • La Clase Path: Representando Rutas

  • Obteniendo información de un Path

  • La Clase Files: Operaciones con Archivos

  • Comparación con C

• Lectura de Archivos de Texto

  • Método Simple: Leer Todas las Líneas de Una Vez

  • Lectura Línea por Línea con BufferedReader

  • Lectura de Todo el Contenido como un Solo String

• Escritura de Archivos de Texto

  • Método Simple: Escribir una Lista de Líneas

  • Escribir un Único String

  • Escritura con BufferedWriter (Mayor Control)

  • Agregar al Final de un Archivo (Append)

• Operaciones con Archivos y Directorios

  • Crear Directorios y Archivos Vacíos

  • Copiar y Mover Archivos

  • Eliminar Archivos y Directorios

• Manejo de Excepciones en I/O

  • Jerarquía de Excepciones de I/O

  • Captura Específica de Excepciones

  • Excepciones Múltiples con Pipe

• Gestión de Recursos: El Problema de Cerrar Archivos

  • El Problema: ¿Qué pasa si hay una excepción?

  • Solución Clásica: try-finally

  • Solución Moderna: try-with-resources (Java 7+)

  • Múltiples Recursos en try-with-resources

  • ¿Qué recursos se pueden usar con try-with-resources?

• Codificación de Caracteres (Charset)

  • ¿Por qué importa la codificación?

  • La solución: Especificar siempre UTF-8

  • Codificaciones Comunes

• Eficiencia: La Importancia del Buffering

  • El costo de acceder al disco

  • Sin buffer vs. Con buffer

  • Impacto real en tiempos

  • ¿Cuándo necesitás pensar en buffering?

• Ejemplo Completo: Procesar Archivo CSV

• Resumen: Mejores Prácticas

  • Comparación final con C

• Ejercicios de Aplicación

• Testing de Archivos con JUnit

  • El Problema

  • La Solución: @TempDir de JUnit 5

  • Testing de Excepciones

  • Patrón Arrange-Act-Assert con Archivos

• Referencias Bibliográficas

Memoria, Referencias y Mutabilidad¶

• Modelo de Memoria de la JVM

  • Stack (Pila de Ejecución)

  • Heap (Montículo)

  • Visualización del Modelo

  • ¿Qué pasa cuando termina un método?

• Referencias: Los “Punteros Seguros” de Java

  • Tipos Primitivos vs Tipos Referencia

• El Valor null

  • Valores por defecto

  • NullPointerException

  • Prevenir NullPointerException

• Comparación de Referencias: == vs equals()

  • Comparar contenido de arreglos

• Pasaje de Argumentos a Métodos

  • Pasaje de Primitivos

  • Pasaje de Referencias

  • Visualización del Pasaje de Referencias

  • Comparación con C

• Efectos Secundarios (Side Effects)

  • Funciones Puras vs Métodos con Efectos

• Inmutabilidad

  • La Palabra Clave final

  • Estrategias para Prevenir Modificaciones

• Strings: Inmutabilidad especial

  • ¿Por qué los Strings son inmutables?

  • String Pool

  • Métodos de String NO Modifican el Original

  • Métodos Comunes de String

  • Comparación de Strings

  • Concatenación de Strings

• StringBuilder: Strings Mutables

  • El Problema de la Concatenación en Lazos

  • La Solución: StringBuilder

  • Métodos de StringBuilder

  • ¿Cuándo usar String vs StringBuilder?

• Resumen: Reglas Clave

• Ejercicios de Aplicación

• Referencias Bibliográficas