Lecciones

Analizamos paso a paso cómo Java inicializa un objeto: valores predeterminados de los campos, inicialización explícita, bloques de inicialización no estáticos y la llamada final al constructor mediante new. Con el ejemplo de la clase Person veremos el orden efectivo de salida, una tabla de valores predeterminados, un diagrama de bloques y errores típicos (duplicación de lógica, expectativas sobre static, trabajo con null, llamada al constructor mediante this(...)).

Cómo encontrar un error sin volverse loco. Aprende a usar el Debugger: puntos de interrupción, ejecución paso a paso, visualización de variables y evaluación de expresiones sobre la marcha.

En esta lección veremos qué es la encapsulación en Java, cómo se implementa mediante campos privados ( private) y una interfaz pública (métodos public), por qué conviene ocultar el estado interno de los objetos y cómo eso aumenta la fiabilidad y la mantenibilidad del código. Verás ejemplos malos y buenos, aplicaciones prácticas, una tabla comparativa de enfoques y errores típicos.

En esta lección analizamos los niveles de acceso en Java: public, protected, package-private y private. Entenderemos dónde y para qué aplicar cada uno, cómo proteger campos (encapsulación), qué reglas elegir para métodos y constructores, veremos ejemplos con paquetes y herencia, así como mejores prácticas y errores típicos.

En esta lección verás cómo, mediante la encapsulación y los métodos get/ set, controlar el acceso a los campos de una clase en Java. Conocerás las convenciones de JavaBeans, las particularidades para campos de tipo boolean con getters isXxx(), verás ejemplos de validación en setters, manejo seguro de campos mutables y la generación automática de accesores en el IDE.

En esta lección verás cómo inicializar campos estáticos ( static) y campos inmutables ( final) en Java: en la declaración, en un bloque de inicialización estático y también en los constructores. Hablaremos del trío de constantes public static final, del acceso correcto a los miembros estáticos, del orden de inicialización y de los errores típicos que conviene evitar.

En esta lección entenderás los bloques de inicialización en Java: en qué se diferencian los bloques no estáticos y los bloques static, en qué orden se ejecutan los campos, los bloques y los constructores, cuándo conviene extraer la lógica común a bloques y cuándo es mejor usar constructores. Veremos ejemplos, sutilezas de la herencia y errores típicos.

Analizaremos las clases internas (non-static inner) en Java: qué son y cómo están vinculadas con la instancia de la clase externa, cómo declararlas y crearlas mediante outer. new Inner(), cómo acceden a los miembros con modificadores private/ public, qué limitaciones tienen (ningún miembro static, salvo constantes), así como opciones de visibilidad y ejemplos prácticos: Backpack.Item, el iterador de tu propia colección y el acceso al objeto externo mediante OuterClassName. this. Al final — errores típicos y cómo evitarlos.

Analizamos las clases anidadas estáticas en Java: qué son, en qué se diferencian de las internas (inner), cómo declararlas con el modificador static, cómo crear instancias sin un objeto de la clase externa y qué reglas de acceso se aplican (nada de OuterClass.this, acceso solo a miembros estáticos). Mostraremos escenarios prácticos — Builder, nodos internos Node en estructuras, utilidades, las compararemos con las clases inner, añadiremos un diagrama y revisaremos errores típicos: confusión con outer.new Inner() y la invocación correcta new Outer.Nested().

En la lección analizamos las clases anónimas en Java: qué son, cómo se declaran y se crean en el lugar de uso, cómo el compilador nombra sus archivos .class, las limitaciones (final/effectively final, ausencia de constructor, bloques de inicialización) y escenarios prácticos de uso. Mostraremos el acceso a los miembros de la clase externa y veremos errores típicos.

Analizamos las clases locales en Java: qué son, cómo declararlas dentro de métodos y bloques, qué restricciones existen para los modificadores y los miembros estáticos, y cómo funciona el acceso a las variables del método (solo final/ effectively final). Las compararemos con las clases anónimas, veremos ejemplos prácticos (comparador, estructura de datos temporal, miniresultado de un test) y errores típicos. Entenderás cuándo una clase local es más adecuada que una anónima y por qué conviene recordar static y public/ private/ protected.

Introducción práctica a Generics (genéricos) en Java: por qué almacenar en Object es peligroso, cómo declarar clases y métodos genéricos, cómo usar Box<T>, pares y métodos genéricos, y qué ventajas ofrece la seguridad de tipos sin conversiones explícitas. Comentaremos las limitaciones (primitivos, borrado de tipos) y veremos ejemplos de uso.