├── .gitignore ├── Readme.md ├── Sesion-01 ├── Ejemplo-01 │ └── Readme.md ├── Ejemplo-02 │ └── Readme.md ├── Ejemplo-03 │ └── Readme.md ├── Ejemplo-04 │ └── Readme.md ├── Imagenes │ ├── Bedu.png │ ├── S00.jpg │ ├── S01.jpg │ └── S01_Fig01.jpg ├── Prework │ └── Readme.md ├── Readme.md ├── Reto-01 │ └── Readme.md └── Reto-02 │ └── Readme.md ├── Sesion-02 ├── Ejemplo-01 │ └── Readme.md ├── Ejemplo-02 │ └── Readme.md ├── Ejemplo-03 │ └── Readme.md ├── Ejemplo-04 │ └── Readme.md ├── Imagenes │ ├── S00.jpg │ ├── S02.jpg │ ├── S02_Fig01.jpg │ └── S02_Fig02.jpg ├── Prework │ └── Readme.md ├── Readme.md ├── Reto-01 │ └── Readme.md └── Reto-02 │ └── Readme.md ├── Sesion-03 ├── Ejemplo-01 │ └── Readme.md ├── Ejemplo-02 │ └── Readme.md ├── Ejemplo-03 │ └── Readme.md ├── Ejemplo-04 │ └── Readme.md ├── Imagenes │ ├── S00.jpg │ ├── S03.jpg │ ├── S03_Fig01.jpg │ ├── S03_Fig02.jpg │ ├── S03_Fig03.jpg │ └── S03_Fig04.jpg ├── Prework │ └── Readme.md ├── Readme.md ├── Reto-01 │ └── Readme.md └── Reto-02 │ └── Readme.md ├── Sesion-04 ├── Ejemplo-01 │ └── Readme.md ├── Ejemplo-02 │ └── Readme.md ├── Ejemplo-03 │ └── Readme.md ├── Ejemplo-04 │ └── Readme.md ├── Imagenes │ ├── S00.jpg │ ├── S04.jpg │ ├── S04_Fig01.png │ ├── S04_Fig02.png │ └── S04_Fig03.png ├── Prework │ └── Readme.md ├── Readme.md ├── Reto-01 │ └── Readme.md └── Reto-02 │ └── Readme.md ├── Sesion-05 ├── Ejemplo-01 │ └── Readme.md ├── Ejemplo-02 │ └── Readme.md ├── Ejemplo-03 │ └── Readme.md ├── Ejemplo-04 │ └── Readme.md ├── Imagenes │ ├── S00.jpg │ ├── S05.jpg │ ├── S05_Fig1.png │ ├── S05_Fig2.png │ ├── S05_Fig3.png │ ├── S05_Fig4.png │ ├── S05_Fig5.png │ └── S05_Fig6.png ├── Prework │ └── Readme.md ├── Readme.md ├── Reto-01 │ └── Readme.md └── Reto-02 │ └── Readme.md ├── Sesion-06 ├── Ejemplo-01 │ └── Readme.md ├── Ejemplo-02 │ └── Readme.md ├── Ejemplo-03 │ └── Readme.md ├── Ejemplo-04 │ └── Readme.md ├── Imagenes │ ├── S00.jpg │ ├── S06.jpg │ ├── S06_Fig1.png │ ├── S06_Fig2.png │ └── S06_Fig3.png ├── Prework │ └── Readme.md ├── Readme.md ├── Reto-01 │ └── Readme.md └── Reto-02 │ └── Readme.md ├── Sesion-07 ├── Ejemplo-01 │ └── Readme.md ├── Ejemplo-02 │ └── Readme.md ├── Ejemplo-03 │ └── Readme.md ├── Ejemplo-04 │ └── Readme.md ├── Imagenes │ ├── S00.jpg │ ├── S07.jpg │ ├── S07_Fig1.png │ ├── S07_Fig2.png │ ├── S07_Fig3.png │ └── S07_Fig4.png ├── Prework │ └── Readme.md ├── Readme.md ├── Reto-01 │ └── Readme.md └── Reto-02 │ └── Readme.md ├── Sesion-08 ├── Ejemplo-01 │ └── Readme.md ├── Ejemplo-02 │ └── Readme.md ├── Ejemplo-03 │ └── Readme.md ├── Ejemplo-04 │ └── Readme.md ├── Ejemplo-05 │ └── Readme.md ├── Imagenes │ ├── S00.jpg │ ├── S08.jpg │ ├── S08_Fig01.jpg │ ├── S08_Fig02.jpg │ ├── S08_Fig03.jpg │ ├── S08_Fig04.jpg │ ├── S08_Fig05.jpg │ ├── S08_Fig06.png │ └── S08_Fig07.jpg ├── Prework │ └── Readme.md ├── Readme.md ├── Reto-01 │ └── Readme.md └── Reto-02 │ └── Readme.md ├── Sesion-09 ├── Imagenes │ └── S00.jpg ├── Prework │ └── Readme.md └── Readme.md └── Sesion-10 ├── Imagenes └── S00.jpg ├── Prework └── Readme.md └── Readme.md /.gitignore: -------------------------------------------------------------------------------- 1 | # Archivos compilados de Java 2 | *.class 3 | 4 | # Configuración de IntelliJ IDEA 5 | .idea/ 6 | *.iml 7 | 8 | # Archivos generados por Java 9 | hs_err_pid* 10 | 11 | # Archivos de logs 12 | *.log 13 | 14 | # Archivos del sistema (Windows y macOS) 15 | .DS_Store 16 | Thumbs.db -------------------------------------------------------------------------------- /Readme.md: -------------------------------------------------------------------------------- 1 |
2 | Sesion_01 3 |
4 | 5 | # 🚀 Curso de Java Standard Edition 1 6 | 7 | ## 🎯 Objetivo del Curso 8 | 🟡 Aprender los fundamentos de Java aplicando programación orientada a objetos (POO), estructuras de datos, manejo de archivos con NIO.2 y buenas prácticas como SOLID y manejo de excepciones, para escribir código limpio y escalable. 9 | 10 | ## 📘 Prework 11 | 12 | | # | Sesión | 13 | |----|--------| 14 | | 01 | 🛠️ [Introducción a la programación orientada a objetos en Java](Sesion-01/Prework/Readme.md) | 15 | | 02 | ➕ [Tipos de datos y sentencias de control](Sesion-02/Prework/Readme.md) | 16 | | 03 | 🧠 [Clases y objetos: crea aplicaciones que permitan el ingreso de información](Sesion-03/Prework/Readme.md) | 17 | | 04 | 🛡️ [Elementos de una clase: implementa validación de datos](Sesion-04/Prework/Readme.md) | 18 | | 05 | 🧱 [Diseño de clases (herencia y polimorfismo): reutiliza código existente por medio de herencia y polimorfismo](Sesion-05/Prework/Readme.md) | 19 | | 06 | 📊 [Colecciones: utiliza diversas estructuras de datos de acuerdo al tipo de aplicación a desarrollar](Sesion-06/Prework/Readme.md) | 20 | | 07 | 💾 [Manejo de archivos: guarda información en un archivo de manera persistente](Sesion-07/Prework/Readme.md) | 21 | | 08 | ⚙️ [Buenas prácticas y manejo de errores en Java](Sesion-08/Prework/Readme.md) | 22 | | 09 | 🧭 [Mentorship 1](Sesion-09/Prework/Readme.md) | 23 | | 10 | 🔄 [Mentorship 2](Sesion-10/Prework/Readme.md) | 24 | 25 | ## 📚 Sesiones 26 | 27 | | # | Sesión | 28 | |----|--------| 29 | | 01 | 🏁 [Introducción a la programación orientada a objetos en Java](Sesion-01/Readme.md) | 30 | | 02 | 🔀 [Tipos de datos y sentencias de control](Sesion-02/Readme.md) | 31 | | 03 | 🏗️ [Clases y objetos: crea aplicaciones que permitan el ingreso de información](Sesion-03/Readme.md) | 32 | | 04 | 📦 [Elementos de una clase: implementa validación de datos](Sesion-04/Readme.md) | 33 | | 05 | 🧬 [Diseño de clases (herencia y polimorfismo): reutiliza código existente por medio de herencia y polimorfismo](Sesion-05/Readme.md) | 34 | | 06 | 📂 [Colecciones: utiliza diversas estructuras de datos de acuerdo al tipo de aplicación a desarrollar](Sesion-06/Readme.md) | 35 | | 07 | 📁 [Manejo de archivos: guarda información en un archivo de manera persistente](Sesion-07/Readme.md) | 36 | | 08 | ✅ [Buenas prácticas y manejo de errores en Java](Sesion-08/Readme.md) | 37 | | 09 | 🔁 [Mentorship 1](Sesion-09/Readme.md) | 38 | | 10 | 🎯 [Mentorship 2](Sesion-10/Readme.md) | 39 | 40 | --- 41 | 42 | 🏆 ¡Mucho éxito! Nos vemos en la siguiente sesión. 43 | 44 | --- 45 | -------------------------------------------------------------------------------- /Sesion-01/Ejemplo-01/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 01**](../Readme.md) ➡️ / 📝 `Ejemplo 01: Mi primer programa en Java` 2 | 3 | ## 🎯 Objetivo 4 | 5 | 🔍 Escribir y ejecutar nuestro primer programa en **Java**, comprendiendo su estructura básica y el proceso de compilación y ejecución, tanto desde la terminal como desde un entorno de desarrollo (IDE). 6 | 7 | --- 8 | 9 | ## 📌 Introducción a Java 10 | 11 | Java es un lenguaje de programación moderno, robusto y multiplataforma, ampliamente utilizado en la industria del software para crear aplicaciones web, móviles, de escritorio y sistemas embebidos. 12 | 13 | > 📘 Nota: En Java, todo gira en torno a las **clases**. En el siguiente ejemplo, aprenderás qué es una clase y qué es un objeto, fundamentos clave de la Programación Orientada a Objetos (POO). 14 | 15 | --- 16 | 17 | ## 🧱 Estructura básica de un programa en Java 18 | 19 | Todo programa en Java debe contener al menos **una clase** con un método `main`, que representa el **punto de entrada** del programa. 20 | 21 | ```java 22 | public class HolaMundo { 23 | public static void main(String[] args) { 24 | System.out.println("¡Hola, Java!"); 25 | } 26 | } 27 | ``` 28 | 29 | ### 🔍 Explicación del código 30 | - `public class HolaMundo` → Define una clase pública llamada `HolaMundo`. El nombre del archivo debe coincidir (`HolaMundo.java`). 31 | - `public static void main(String[] args)` → Método principal desde donde se ejecuta el programa. 32 | - `System.out.println(...)` → Muestra un mensaje en la consola. 33 | 34 | --- 35 | 36 | ## 📦 Compilación y ejecución desde la terminal 37 | 38 | En Java, el código fuente debe **compilarse** antes de ejecutarse. Esto se realiza en dos pasos: 39 | 40 | ### 1️⃣ Compilar el programa 41 | ```sh 42 | javac HolaMundo.java 43 | ``` 44 | Esto generará un archivo llamado `HolaMundo.class`. 45 | 46 | ### 2️⃣ Ejecutar el programa compilado 47 | ```sh 48 | java HolaMundo 49 | ``` 50 | 51 | 📌 **Nota:** No incluyas la extensión `.class` al ejecutar. 52 | 53 | --- 54 | 55 | ## 💻 Ejecución desde IntelliJ IDEA 56 | 57 | Si usas **IntelliJ IDEA**, sigue estos pasos: 58 | 59 | 1. Crea un nuevo proyecto en Java. 60 | 2. Agrega una clase nueva llamada `HolaMundo`. 61 | 3. Copia el código anterior en el archivo. 62 | 4. Haz clic en el botón **Run** ▶ o presiona `Shift + F10`. 63 | 64 | --- 65 | 66 | ## 🧾 Palabras clave usadas en este ejemplo 67 | 68 | | Palabra clave | Significado | 69 | |---------------|-------------| 70 | | `class` | Define una clase en Java. | 71 | | `public` | Permite que el método o clase sea accesible desde cualquier lugar. | 72 | | `static` | El método pertenece a la clase, no a una instancia. | 73 | | `void` | El método no devuelve ningún valor. | 74 | | `main` | Es el punto de entrada del programa. | 75 | 76 | --- 77 | 78 | ## 💡 ¿Sabías que...? 79 | 80 | - Java es un lenguaje **compilado e interpretado**: se transforma a bytecode y luego es ejecutado por la **JVM**. 81 | - El método `main()` es **obligatorio** para ejecutar un programa Java. 82 | - Gracias a la **Máquina Virtual de Java (JVM)**, el mismo programa puede correr en **Windows, Linux o Mac** sin necesidad de cambiar el código. 83 | 84 | --- 85 | 86 | ⬅️ [**Anterior**](../Readme.md) | [**Siguiente**](../Ejemplo-02/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-01/Ejemplo-02/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 01**](../Readme.md) ➡️ / 📝 `Ejemplo 02: Programación orientada a objetos` 2 | 3 | ## 🎯 Objetivo 4 | 5 | 🔍 Comprender los conceptos fundamentales de la **Programación Orientada a Objetos (POO)** en Java mediante la creación de una clase simple y la instancia de objetos. 6 | 7 | --- 8 | 9 | ## 📌 ¿Qué es la programación orientada a objetos? 10 | 11 | La **Programación Orientada a Objetos (POO)** es un estilo de programación que organiza el código en **clases** y **objetos**, inspirándose en el mundo real. 12 | 13 | --- 14 | 15 | ## 📌 ¿Qué es una clase? 16 | 17 | Una **clase** es una plantilla que describe las características (**atributos**) y comportamientos (**métodos**) que puede tener un objeto. 18 | 19 | **1. Crea un archivo tipo `java class` y establece el nombre del archivo como `Estudiante`, una recomendación es organizar tus códigos dentro de paquetes o `package`.** 20 | 21 | ```java 22 | public class Estudiante { 23 | // Caracteristicas del estudiante 24 | String nombre; 25 | int edad; 26 | 27 | // Método que muestra un saludo con los datos del estudiante 28 | public void saludar() { 29 | System.out.println("Hola, mi nombre es " + nombre + " y tengo " + edad + " años."); 30 | } 31 | } 32 | 33 | ``` 34 | 35 | --- 36 | 37 | ## 🧱 ¿Qué es un objeto? 38 | 39 | Un **objeto** es una instancia de una clase, es decir, un ejemplar concreto con valores específicos. 40 | 41 | **2. Crea un archivo tipo `java class` y establece el nombre del archivo como `Principal`, este programa se encargara de ejecutar el código desarrollado dentro del método `main`.** 42 | 43 | ```java 44 | public class Principal { 45 | public static void main(String[] args) { 46 | // Crear un nuevo objeto de tipo Estudiante 47 | Estudiante estudiante1 = new Estudiante(); 48 | 49 | // Asignar valores a los atributos 50 | estudiante1.nombre = "Ana"; 51 | estudiante1.edad = 20; 52 | 53 | // Llamar al método saludar() del objeto 54 | estudiante1.saludar(); 55 | } 56 | } 57 | ``` 58 | 59 | --- 60 | 61 | ## 💡 ¿Sabías que...? 62 | 63 | - Puedes crear **varios objetos** de una misma clase, cada uno con diferentes valores. 64 | - En Java, todo gira en torno a las clases: incluso tipos como `String`, `Scanner` y `System` son clases. 65 | - El **método main** (`public static void main`) es el punto de entrada de todo programa Java. 66 | 67 | --- 68 | 69 | 📘 Recurso adicional para repaso: 70 | 🔗 [POO en Java – W3Schools](https://www.w3schools.com/java/java_oop.asp) 71 | 72 | --- 73 | 74 | ⬅️ [**Anterior**](../Ejemplo-01/Readme.md) | [**Siguiente**](../Reto-01/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-01/Ejemplo-03/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 01**](../Readme.md) ➡️ / 📝 `Ejemplo 03: Definiendo una clase con constructor` 2 | 3 | ## 🎯 Objetivo 4 | 5 | 🔍 Aprender a utilizar **constructores** en Java para inicializar objetos y sus atributos de una forma mucho mas controlada y escalable así como conocer la utilidad de los **modificadores de acceso** en el diseño de clases, y asegurar la integridad de la información en nuestros programas. 6 | 7 | --- 8 | 9 | ## 📌 ¿Qué es un constructor? 10 | 11 | Un **constructor** es un método especial que se ejecuta automáticamente al crear un objeto. Se utiliza para **inicializar los atributos** de una clase con valores definidos. 12 | 13 | ```java 14 | public class Producto { 15 | // Atributos del producto 16 | String nombre; 17 | double precio; 18 | 19 | // Constructor que inicializa el producto con nombre y precio 20 | public Producto(String nombre, double precio) { 21 | this.nombre = nombre; 22 | this.precio = precio; 23 | } 24 | 25 | // Método que muestra la información del producto en consola 26 | public void mostrarInformacion() { 27 | System.out.println("Producto: " + nombre + " - Precio: $" + precio); 28 | } 29 | } 30 | ``` 31 | 32 | ```java 33 | public class Principal { 34 | public static void main(String[] args) { 35 | // Crear un objeto de tipo Producto utilizando el constructor 36 | Producto producto1 = new Producto("Laptop", 12499.99); 37 | 38 | // Llamar al método para mostrar la información del producto 39 | producto1.mostrarInformacion(); 40 | } 41 | } 42 | ``` 43 | 44 | --- 45 | 46 | ## 🔐 ¿Qué es un modificador de acceso? 47 | 48 | Los **modificadores de acceso** determinan la visibilidad de atributos y métodos. Por ahora, solo utilizamos `public`, pero más adelante conocerás `private`, `protected` y el modificador por defecto. 49 | 50 | --- 51 | 52 | ## 🔐 Modificadores de acceso 53 | 54 | | Modificador | Acceso desde la misma clase | Acceso desde otras clases | Acceso desde otras clases en otro paquete | 55 | |-------------|-----------------------------|----------------------------|-------------------------------------------| 56 | | `public` | ✅ | ✅ | ✅ | 57 | | `private` | ✅ | ❌ | ❌ | 58 | | `protected` | ✅ | ✅ (si es subclase) | ✅ (si es subclase y en el mismo paquete) | 59 | | (sin) | ✅ | ✅ | ❌ | 60 | 61 | --- 62 | 63 | ## 💡 ¿Sabías que...? 64 | 65 | - Si no defines un constructor, Java genera uno vacío automáticamente. 66 | - Puedes definir múltiples constructores en una misma clase (esto se llama **sobrecarga**). 67 | - Los constructores permiten escribir clases más limpias y fáciles de usar. 68 | - Puedes dar formato a números en una cadena usando `String.format()`. 69 | Por ejemplo, para mostrar precios con coma y dos decimales: 70 | `System.out.println("Precio: $" + String.format("%,.2f", precio)); output: Precio: $12,499.99` 71 | 72 | --- 73 | 74 | 📘 Recurso adicional para repaso: 75 | 🔗 [Constructores en Java – W3Schools](https://www.w3schools.com/java/java_constructors.asp) 76 | 77 | --- 78 | 79 | ⬅️ [**Anterior**](../Reto-01/Readme.md) | [**Siguiente**](../Ejemplo-04/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-01/Ejemplo-04/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 01**](../Readme.md) ➡️ / 📝 `Ejemplo 04: Uso de record y sealed classes` 2 | 3 | ## 🎯 Objetivo 4 | 5 | 🔍 Explorar dos características modernas de Java: el uso de `record` para crear clases inmutables de manera concisa, y `sealed classes` para restringir la herencia en estructuras más seguras y controladas. 6 | 7 | --- 8 | 9 | ## 📌 ¿Qué es un `record`? 10 | 11 | Un `record` es una forma concisa de declarar clases inmutables en Java. Fueron introducidos en Java 14 como feature preview y estables desde Java 16. Son ideales para representar estructuras simples de datos, como DTOs (Data Transfer Objects). 12 | 13 | ```java 14 | // Un record es una forma concisa de definir una clase inmutable en Java. 15 | public record Producto(String nombre, double precio) { } 16 | ``` 17 | 18 | ✅ Con esta única línea, Java genera automáticamente: 19 | - Constructor 20 | - Getters (`nombre()` y `precio()`) 21 | - `equals()`, `hashCode()` y `toString()` 22 | 23 | ```java 24 | public class Principal { 25 | public static void main(String[] args) { 26 | // Crear un objeto de tipo Producto usando el record 27 | Producto producto = new Producto("Monitor", 3299.99); 28 | 29 | // Muestra el toString() generado automáticamente por el record. 30 | System.out.println(producto); 31 | } 32 | } 33 | ``` 34 | 35 | 🧠 Salida: 36 | ``` 37 | Producto[nombre=Monitor, precio=3299.99] 38 | ``` 39 | 40 | 📝 Esta salida representa el contenido del objeto `producto` impreso automáticamente por el método `toString()` generado por el record. 41 | 42 | --- 43 | 44 | ## 📌 ¿Qué es una `sealed class`? 45 | 46 | Una `sealed class` (introducida en Java 17) permite **restringir qué clases pueden heredar** de ella. Esto mejora la seguridad y el control en jerarquías de clases. 47 | 48 | ```java 49 | // Clase base sellada: solo las clases permitidas pueden extenderla. 50 | // Mejora el control de herencia en jerarquías cerradas. 51 | public sealed class Vehiculo permits Auto, Camion { } 52 | 53 | // Clase Auto que extiende Vehiculo. Se declara como final para no permitir más herencia. 54 | final class Auto extends Vehiculo { } 55 | 56 | // Clase Camion que también extiende Vehiculo y es final. 57 | final class Camion extends Vehiculo { } 58 | ``` 59 | 60 | 📌 En este ejemplo: 61 | - Solo `Auto` y `Camion` pueden extender de `Vehiculo`. 62 | - Cualquier otro intento de herencia será un error de compilación. 63 | 64 | ### ❌ Ejemplo de error al extender `Vehiculo` sin permiso: 65 | 66 | ```java 67 | // Esta clase NO está en la lista de 'permits', por lo tanto, genera un error. 68 | class Moto extends Vehiculo { } 69 | ``` 70 | 71 | 🛑 **Error de compilación esperado:** 72 | ``` 73 | class Moto is not allowed to extend sealed class Vehiculo 74 | ``` 75 | --- 76 | 77 | ## 📌 ¿Qué significa `final`? 78 | 79 | El modificador `final` en una clase indica que **no puede ser heredada**. En el contexto de una `sealed class`, es obligatorio que las clases que extienden de ella sean: 80 | 81 | - `final` → no pueden ser heredadas. 82 | - `sealed` → continúan una jerarquía sellada. 83 | - `non-sealed` → permiten herencia abierta. 84 | 85 | ✅ En el ejemplo anterior, `Auto` y `Camion` son `final` porque no se espera que otras clases hereden de ellas. 86 | 87 | --- 88 | 89 | ## 💡 ¿Sabías que...? 90 | - Los `record` no permiten atributos mutables (no se pueden modificar después de crear el objeto). 91 | - Las `sealed classes` promueven jerarquías cerradas, ideales para modelar flujos de negocio controlados (por ejemplo: tipos de notificaciones, transacciones, permisos). 92 | - Ambas funcionalidades son parte del enfoque moderno de Java hacia un código más **conciso**, **seguro** y **mantenible**. 93 | 94 | --- 95 | 96 | 📘 Recurso adicional para repaso: 97 | 🔗 [Records – Oracle Docs](https://docs.oracle.com/en/java/javase/17/language/records.html) 98 | 🔗 [Sealed Classes – Oracle Docs](https://docs.oracle.com/en/java/javase/17/language/sealed-classes-and-interfaces.html) 99 | 100 | --- 101 | 102 | ⬅️ [**Anterior**](../Ejemplo-03/Readme.md) | [**Siguiente**](../Reto-02/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-01/Imagenes/Bedu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-01/Imagenes/Bedu.png -------------------------------------------------------------------------------- /Sesion-01/Imagenes/S00.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-01/Imagenes/S00.jpg -------------------------------------------------------------------------------- /Sesion-01/Imagenes/S01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-01/Imagenes/S01.jpg -------------------------------------------------------------------------------- /Sesion-01/Imagenes/S01_Fig01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-01/Imagenes/S01_Fig01.jpg -------------------------------------------------------------------------------- /Sesion-01/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../Readme.md) ➡️ / 📖 `Sesión 01` 2 | 3 |
4 | Sesion_01 5 |
6 | 7 | # 🎯 Objetivo 8 | 9 | 10 | ⚒️ Identificar y comprender los conceptos básicos de **Java**, incluyendo **Programación Orientada a Objetos (POO)**, para aplicarlos en la creación de programas sencillos. 11 | 12 | --- 13 | 14 | ## 📂 Temas de la sesión... 15 | 16 | ### 📖 Introducción a Java y primeros pasos 17 | Java es un lenguaje de programación **orientado a objetos** ampliamente utilizado en la industria. En esta sesión, exploraremos sus conceptos básicos y cómo escribir nuestro primer programa en Java. 18 | 19 | 🔹 **Conceptos clave de Java** 20 | 🔹 **Estructura básica de un programa en Java** 21 | 🔹 **Compilación y ejecución de código en Java (Línea de comandos)** 22 | 23 | 📜 **[Ejemplo 01: Mi primer programa en Java](Ejemplo-01/Readme.md)** 24 | 25 | --- 26 | 27 | ### 📖 Fundamentos de la programación orientada a objetos (POO) 28 | La POO es un paradigma de programación basado en la creación y manipulación de **objetos**. Java implementa la POO con los siguientes principios clave: 29 | 30 | 🔹 **Encapsulación**: Control del acceso a los datos dentro de las clases. 31 | 🔹 **Herencia**: Creación de nuevas clases a partir de clases existentes. 32 | 🔹 **Polimorfismo**: Capacidad de los métodos de comportarse de manera diferente según el objeto. 33 | 🔹 **Abstracción**: Ocultamiento de detalles de implementación, enfocándose solo en lo esencial. 34 | 35 | 📜 **[Ejemplo 02: Creando nuestra primera clase en java](Ejemplo-02/Readme.md)** 36 | 🔥 **[Reto 01: Registro de pacientes](Reto-01/Readme.md)** 37 | 38 | --- 39 | 40 | ### 📖 Clases y objetos en java 41 | Las **clases** son plantillas para la creación de **objetos**, que representan entidades en el mundo real con atributos y métodos. 42 | 43 | 🔹 **Definición y uso de clases en Java** 44 | 🔹 **Creación e instanciación de objetos** 45 | 🔹 **Métodos y constructores** 46 | 🔹 **Modificadores de acceso (`public`, `private`, `protected`)** 47 | 48 | 📜 **[Ejemplo 03: Definiendo una clase y creando objetos](Ejemplo-03/Readme.md)** 49 | 50 | --- 51 | 52 | ### 📖 Introducción a `record` y `sealed classes` en java 53 | En versiones modernas de Java, se han introducido nuevas formas de definir clases más concisas y seguras: 54 | 55 | 🔹 **`record`** → Para definir clases inmutables sin necesidad de escribir código repetitivo. 56 | 🔹 **`sealed classes`** → Para restringir qué clases pueden heredar de una clase padre. 57 | 58 | 📜 **[Ejemplo 04: Uso de record y sealed classes](Ejemplo-04/Readme.md)** 59 | 🔥 **[Reto 02: Registro básico de entradas](Reto-02/Readme.md)** 60 | 61 | --- 62 | 63 | ⬅️ [**Anterior**](../Readme.md) | [**Siguiente**](../Sesion-02/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-01/Reto-01/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 01**](../Readme.md) ➡️ / ⚡`Reto 01: Registro básico de pacientes` 2 | 3 | ## 🎯 Objetivo 4 | 5 | ⚒️ Desarrollar un programa en **Java** que registre los datos de un paciente, aplicando los fundamentos de **clases**, **objetos**, **atributos**, **métodos** y la **entrada de datos por consola**. 6 | 7 | --- 8 | 9 | ## 📝 Instrucciones 10 | 11 | 👥 Puedes resolver este reto de manera individual o en equipos. 12 | 13 | 1. 🩺 Crea una **clase** llamada `Paciente`. 14 | 15 | 2. 📥 Utiliza la clase `Scanner` para solicitar los siguientes datos desde la consola: 16 | - Nombre del paciente (`String`) 17 | - Edad del paciente (`int`) 18 | - Número de expediente (`String`) 19 | 20 | 3. 🧱 Declara atributos en la clase `Paciente` para almacenar esta información. 21 | 22 | 4. 📢 Agrega un **método público** llamado `mostrarInformacion()` que imprima el siguiente formato: 23 | ```plaintext 24 | Paciente: Lena Marie 25 | Edad: 25 26 | Expediente: EXP202409 27 | ``` 28 | 29 | 5. 🧪 Crea un archivo llamado `Principal` y dentro del método `main()`: 30 | - Crea un objeto de tipo `Paciente` 31 | - Asigna los valores ingresados por el usuario 32 | - Llama al método `mostrarInformacion()` para mostrar los datos en consola 33 | 34 | --- 35 | 36 | 📘 Recursos útiles: 37 | 🔗 [Entrada de usuario en Java – W3Schools](https://www.w3schools.com/java/java_user_input.asp) 38 | 🔗 [Clases en Java – W3Schools](https://www.w3schools.com/java/java_classes.asp) 39 | 40 | --- 41 | 42 | 🧠 **Nota:** 43 | Este reto está diseñado para reforzar los fundamentos de Java y la Programación Orientada a Objetos (POO), utilizando dos archivos diferentes uno para el objeto Paciente y otro archivo el cual ejecuta el código. 44 | 45 | --- 46 | 47 | 🏆 Nos vemos en el siguiente reto, ¡mucho éxito! 48 | 49 | --- 50 | 51 | ⬅️ [**Anterior**](../Ejemplo-02/Readme.md) | [**Siguiente**](../Ejemplo-03/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-01/Reto-02/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 01**](../Readme.md) ➡️ / ⚡`Reto 02: Registro básico de entradas` 2 | 3 | ## 🎯 Objetivo 4 | 5 | ⚒️ Desarrollar un programa en **Java** que permita registrar la información básica de entradas para eventos, aplicando los fundamentos de **clases**, **objetos**, **atributos**, **métodos** y el uso de **constructores**. 6 | 7 | --- 8 | 9 | ## 📝 Instrucciones 10 | 11 | 👥 Puedes resolver este reto de manera individual o en equipos. 12 | 13 | 1. 🎫 Crea una **clase** llamada `Entrada`. 14 | 15 | 2. 🧱 Declara los siguientes atributos: 16 | - Nombre del evento (`String`) 17 | - Precio de la entrada (`double`) 18 | 19 | 3. 🛠️ Crea un **constructor** que reciba ambos valores al momento de crear el objeto. 20 | 21 | 4. 📢 Agrega un **método público** llamado `mostrarInformacion()` que imprima el siguiente formato: 22 | ```plaintext 23 | Evento: Obra de Teatro | Precio: $450.0 24 | ``` 25 | 26 | 5. 🧪 Crea una clase llamada `Principal` y dentro del método `main()`: 27 | - Crea al menos **dos objetos** de tipo `Entrada` 28 | - Llama al método `mostrarInformacion()` para mostrar los datos en consola 29 | 30 | --- 31 | 32 | ## ✅ Desafío adicional 33 | 34 | 🎁 Como reto extra, convierte la clase `Entrada` en un `record` para ver una forma más compacta de declarar estructuras de datos en Java moderno, genera un nuevo archivo `Entrada_Record` y crea un registro extra. 35 | 36 | --- 37 | 38 | 📘 Recursos útiles: 39 | 🔗 [Clases en Java – W3Schools](https://www.w3schools.com/java/java_classes.asp) 40 | 🔗 [Constructores en Java – W3Schools](https://www.w3schools.com/java/java_constructors.asp) 41 | 🔗 [Records en Java – Oracle Docs](https://docs.oracle.com/en/java/javase/17/language/records.html) 42 | 43 | --- 44 | 45 | 🧠 **Nota:** 46 | Este reto está diseñado para reforzar los conceptos básicos de la Programación Orientada a Objetos (POO) en Java. Utiliza al menos **dos archivos diferentes**: uno para la clase `Entrada` y otro para ejecutar el programa desde `Principal`. 47 | 48 | --- 49 | 50 | 🏆 Nos vemos en el siguiente reto, ¡mucho éxito! 51 | 52 | --- 53 | 54 | ⬅️ [**Anterior**](../Ejemplo-04/Readme.md) | [**Siguiente**](../../Sesion-02/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-02/Ejemplo-01/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 02**](../Readme.md) ➡️ / 📝 `Ejemplo 01: Declaración de variables y uso de var` 2 | 3 | ## 🎯 Objetivo 4 | 5 | 🔍 Comprender cómo declarar variables en Java, diferenciar entre tipos de datos primitivos y de referencia, utilizar `var` para inferencia de tipos y aplicar conversiones de tipos mediante **casting**. 6 | 7 | --- 8 | 9 | ## 📌 ¿Qué es una variable en Java? 10 | 11 | Una **variable** es como una caja donde guardamos un valor. En Java, cada variable debe tener un **tipo de dato**, que indica qué tipo de valor puede guardar. Aunque las versiones modernas permiten inferir el tipo con `var`, seguir definiendo el tipo ayuda a que el código sea más seguro, claro y eficiente. 12 | 13 | --- 14 | 15 | ## 🧩 Tipos de datos primitivos 16 | 17 | Java incluye ocho tipos primitivos que almacenan datos simples: 18 | 19 | | Tipo | Descripción | Ejemplo | 20 | |----------|-------------------------------------|--------------| 21 | | `int` | Números enteros | `int edad = 25;` | 22 | | `double` | Números decimales | `double altura = 1.75;` | 23 | | `boolean`| Valores lógicos `true` o `false` | `boolean activo = true;` | 24 | | `char` | Un solo carácter Unicode | `char inicial = 'A';` | 25 | 26 | ```java 27 | int edad = 30; 28 | double precio = 1299.99; 29 | boolean disponible = true; 30 | char letra = 'J'; 31 | ``` 32 | 33 | --- 34 | 35 | ## 🧩 Inferencia de tipo con `var` 36 | 37 | Desde Java 10, se puede usar `var` para que el compilador infiera el tipo de dato automáticamente: 38 | 39 | ```java 40 | var mensaje = "Hola, mundo"; 41 | var numero = 10; 42 | var activo = true; 43 | ``` 44 | 45 | 📌 El tipo se infiere en tiempo de compilación y **no puede cambiarse**. Aunque `var` hace el código más limpio, el tipo real sigue existiendo y debe ser claro para evitar confusiones. No se recomienda usar `var` cuando el tipo no sea evidente, con `null` o sin inicializar. 46 | 47 | --- 48 | 49 | ## 🔁 Conversión de tipos y casting 50 | 51 | A veces es necesario **convertir un tipo de dato a otro**. Esto puede hacerse de manera **implícita** o **explícita**: 52 | 53 | ```java 54 | int numero = 10; 55 | double resultado = numero; // conversión implícita 56 | 57 | double precio = 19.99; 58 | int precioEntero = (int) precio; // conversión explícita (casting) 59 | ``` 60 | 61 | ⚠️ Al hacer casting, podrías perder precisión (por ejemplo, perder decimales). 62 | 63 | --- 64 | 65 | ## 💻 Ejemplo completo 66 | 67 | ```java 68 | public class EjemploVariables { 69 | public static void main(String[] args) { 70 | int edad = 28; 71 | double salario = 15499.50; 72 | boolean activo = true; 73 | char inicial = 'M'; 74 | var ciudad = "Guadalajara"; 75 | 76 | // Imprimir los valores almacenados en las variables 77 | System.out.println("Edad: " + edad); 78 | System.out.println("Salario: $" + salario); 79 | System.out.println("Activo: " + activo); 80 | System.out.println("Inicial: " + inicial); 81 | System.out.println("Ciudad: " + ciudad); 82 | 83 | // Conversiónes 84 | double precio = 199.99; 85 | int precioRedondeado = (int) precio; 86 | System.out.println("Precio original: " + precio); 87 | System.out.println("Precio redondeado: " + precioRedondeado); 88 | } 89 | } 90 | ``` 91 | 92 | --- 93 | 94 | ## 💡 ¿Sabías que...? 95 | 96 | - El uso de `var` mejora la legibilidad en declaraciones simples, pero no se recomienda en casos ambiguos. 97 | - Java es un **lenguaje fuertemente tipado**, por lo que cada variable mantiene su tipo una vez declarado. 98 | - Los tipos primitivos **no son objetos**, pero pueden convertirse en objetos usando wrappers como `Integer`, `Double`, `Boolean`, etc. 99 | 100 | --- 101 | 102 | 📘 Puedes repasar estos temas con más ejemplos aquí: 103 | 🔗 [Java Data Types – W3Schools](https://www.w3schools.com/java/java_data_types.asp) 104 | 🔗 [Java Data Types – Ionos](https://www.ionos.mx/digitalguide/paginas-web/desarrollo-web/java-data-types/) 105 | 106 | --- 107 | 108 | ⬅️ [**Anterior**](../Readme.md) | [**Siguiente**](../Ejemplo-02/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-02/Ejemplo-02/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 02**](../Readme.md) ➡️ / 📝 `Ejemplo 02: Operaciones y expresiones` 2 | 3 | ## 🎯 Objetivo 4 | 5 | 🔍 Aplicar operadores aritméticos, relacionales, de asignación e incremento usando la regla de precedencia en un ejemplo completo, para entender cómo construir expresiones útiles en Java. 6 | 7 | --- 8 | 9 | ## 📌 Contexto del ejemplo 10 | 11 | Imagina que estás programando un sistema de facturación para una **cafetería**. Un cliente compró varios productos y se desea calcular el **total de su compra**, verificar si **supera cierto límite para aplicar descuento**, y mostrar el **resultado final** de forma clara. 12 | 13 | --- 14 | 15 | ## 🧾 Escenario 16 | 17 | El cliente compró lo siguiente: 18 | 19 | - ☕ 2 cafés a $45.50 cada uno 20 | - 🧁 1 pastel a $80.00 21 | - 💧 1 botella de agua a $20.00 22 | 23 | Hay una **promoción**: 24 | > Si el total supera los **$150**, se aplica un **10% de descuento**. 25 | 26 | --- 27 | 28 | ## 💻 Código en Java 29 | 30 | ```java 31 | public class FacturaCafeteria { 32 | public static void main(String[] args) { 33 | // Precios unitarios 34 | double precioCafe = 45.50; 35 | double precioPastel = 80.00; 36 | double precioAgua = 20.00; 37 | 38 | // Cantidades 39 | int cantidadCafe = 2; 40 | int cantidadPastel = 1; 41 | int cantidadAgua = 1; 42 | 43 | // El cliente decidió agregar otro pastel 🧁 44 | cantidadPastel++; // Incrementamos en 1 45 | 46 | // Cálculo del total (con prioridad de operadores) 47 | double total = (precioCafe * cantidadCafe) + (precioPastel * cantidadPastel) + (precioAgua * cantidadAgua); 48 | 49 | // Descuento si el total supera $150 50 | boolean aplicaDescuento = total > 150; 51 | 52 | // Asignación del descuento (10%) 53 | double descuento = aplicaDescuento ? total * 0.10 : 0; 54 | 55 | // Cálculo final 56 | double totalFinal = total - descuento; 57 | 58 | // Salida formateada 59 | System.out.println("Total de la compra: $" + total); 60 | System.out.println("¿Aplica descuento? " + aplicaDescuento); 61 | System.out.println("Descuento aplicado: $" + descuento); 62 | System.out.println("Total a pagar: $" + totalFinal); 63 | } 64 | } 65 | ``` 66 | 67 | --- 68 | 69 | ## 🧠 ¿Qué conceptos se aplican aquí? 70 | 71 | | Concepto | Aplicación en el código | 72 | |---------------------------|------------------------------------------------------| 73 | | Aritméticos | Suma y multiplicación en el cálculo del total | 74 | | Relacionales | `total > 150` para saber si aplica descuento | 75 | | Asignación | `=`, `+=`, y uso del operador ternario (`? :`) | 76 | | Incremento (`++`) | `cantidadPastel++` al agregar otro pastel | 77 | | Precedencia (PEMDAS) | Paréntesis usados para agrupar operaciones clave | 78 | 79 | --- 80 | 81 | ## 📌 Regla de precedencia (PEMDAS) 82 | 83 | Java sigue esta jerarquía al evaluar expresiones: 84 | 85 | 1. **Paréntesis** `()` 86 | 2. **Exponenciación** (no existe como `**`, pero se puede usar `Math.pow()`) 87 | 3. **Multiplicación**, **División**, **Módulo** (`*`, `/`, `%`) 88 | 4. **Suma y resta** (`+`, `-`) 89 | 5. **Relacionales** (`>`, `<`, `==`, `!=`, etc.) 90 | 6. **Lógicos** (`&&`, `||`, `!`) 91 | 7. **Asignación** (`=`, `+=`, `-=`, etc.) 92 | 93 | 💡 Siempre puedes usar paréntesis para aclarar el orden de evaluación. 94 | 95 | --- 96 | 97 | ## 💡 ¿Sabías que...? 98 | 99 | - Puedes usar `++` o `--`para aumentar disminuir el valor de una variable en uno `Ej: --x, z++`. 100 | - El operador ternario `? :` es una forma abreviada de usar `if-else` para asignar valores y se puede utilizar de la siguiente manera: 101 | `(condition) ? expressionTrue : expressionFalse;`. 102 | - En operaciones largas, es buena práctica **dividir los cálculos en pasos legibles**. 103 | - Aunque no vimos operadores lógicos en este ejemplo, se usan frecuentemente en validaciones más complejas (lo veremos pronto 😉). 104 | 105 | --- 106 | 107 | 📘 Recurso recomendado: 108 | 🔗 [Java Operators – W3Schools](https://www.w3schools.com/java/java_operators.asp) 109 | 110 | --- 111 | 112 | ⬅️ [**Anterior**](../Ejemplo-01/Readme.md) | [**Siguiente**](../Reto-01/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-02/Ejemplo-03/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 02**](../Readme.md) ➡️ / 📝 `Ejemplo 03: Sentencias condicionales` 2 | 3 | ## 🎯 Objetivo 4 | 5 | 🔍 Aprender a utilizar las **estructuras condicionales** en Java para tomar decisiones en función de ciertas condiciones, aplicando `if`, `else if`, `else` y `switch`, incluyendo su forma moderna. 6 | 7 | --- 8 | 9 | ## 📌 ¿Qué son las sentencias condicionales? 10 | 11 | Las **sentencias condicionales** permiten ejecutar diferentes bloques de código dependiendo del valor de una condición lógica (`true` o `false`). Son esenciales para crear programas interactivos y con lógica flexible. 12 | 13 | --- 14 | 15 | ## 💻 Ejemplo: Sistema de envío de paquetes 16 | 17 | Supongamos que trabajas para una empresa de paquetería y quieres determinar el **costo del envío** en función del tipo de paquete seleccionado por el usuario: 18 | 19 | ```java 20 | import java.util.Scanner; 21 | 22 | public class EnvioPaqueteria { 23 | public static void main(String[] args) { 24 | Scanner scanner = new Scanner(System.in); 25 | 26 | System.out.print("Introduce el tipo de paquete (pequeño, mediano, grande): "); 27 | String tipo = scanner.nextLine(); 28 | 29 | double costo = 0; 30 | 31 | // Condicional con if-else 32 | if (tipo.equalsIgnoreCase("pequeño")) { 33 | costo = 49.99; 34 | } else if (tipo.equalsIgnoreCase("mediano")) { 35 | costo = 89.99; 36 | } else if (tipo.equalsIgnoreCase("grande")) { 37 | costo = 149.99; 38 | } else { 39 | System.out.println("Tipo de paquete no válido."); 40 | } 41 | 42 | if (costo > 0) { 43 | System.out.println("Costo del envío: $" + costo); 44 | } 45 | 46 | scanner.close(); 47 | } 48 | } 49 | ``` 50 | 51 | --- 52 | 53 | ## 🔁 Alternativa con `switch` (Java 14+) 54 | 55 | Desde Java 14, `switch` puede utilizarse de forma más expresiva y limpia: 56 | 57 | ```java 58 | String tipo = "mediano"; 59 | 60 | double costo = switch (tipo.toLowerCase()) { 61 | case "pequeño" -> 49.99; 62 | case "mediano" -> 89.99; 63 | case "grande" -> 149.99; 64 | default -> { 65 | System.out.println("Tipo no válido."); 66 | yield 0.0; 67 | } 68 | }; 69 | 70 | System.out.println("Costo del envío: $" + costo); 71 | ``` 72 | 73 | --- 74 | 75 | ### 📌 ¿Por qué usamos `yield`? 76 | 77 | Cuando un `case` en `switch` tiene más de una línea de código (como cuando usamos `{}`), **Java necesita saber qué valor retornar**. Para eso usamos `yield`. 78 | Es similar a `return`, pero se usa dentro de expresiones `switch`. 79 | 80 | 81 | | Situación | ¿Se necesita `yield`? | Ejemplo | 82 | |---------------------------|------------------------|----------------------------------------------------------------| 83 | | `case` de una sola línea | ❌ | `case "mediano" -> 89.99;` | 84 | | `case` con varias líneas | ✅ | `default -> { System.out.println(); yield 0.0; }` | 85 | 86 | 🔎 **Tip:** Usar `yield` mejora el control y claridad cuando necesitas lógica adicional antes de devolver un valor. 87 | 88 | --- 89 | 90 | ## 🧱 Comparativa entre estructuras 91 | 92 | | Estructura | Características principales | 93 | |----------------|----------------------------------------------------------| 94 | | `if / else` | Ideal para condiciones simples o que requieren evaluación lógica | 95 | | `switch` clásico | Más legible para comparar múltiples valores exactos | 96 | | `switch` moderno | Sintaxis más clara, permite retornos directos (`->`) | 97 | 98 | --- 99 | 100 | ## 🧠 ¿Y qué pasa con `break` y `continue`? 101 | 102 | - En el `switch` **clásico**, se usaba `break` para evitar la ejecución del siguiente `case`. 103 | - En el `switch` **moderno**, ya **no se necesita `break`**, lo que mejora la legibilidad. 104 | - `continue` es más común en bucles y se usa para **saltar una iteración** (lo veremos en el siguiente ejemplo). 105 | 106 | --- 107 | 108 | ## 💡 ¿Sabías que...? 109 | - Puedes encadenar múltiples condiciones usando `else if`. 110 | - El `switch` moderno también puede devolver valores, lo que reduce líneas de código. 111 | - `equalsIgnoreCase()` permite comparar cadenas sin importar mayúsculas o minúsculas. 112 | 113 | --- 114 | 115 | 📘 Recursos recomendados: 116 | 🔗 [Java if-else – W3Schools](https://www.w3schools.com/java/java_conditions.asp) 117 | 🔗 [Java switch – Oracle Docs](https://docs.oracle.com/en/java/javase/17/language/switch-expressions.html) 118 | 119 | --- 120 | 121 | ⬅️ [**Anterior**](../Reto-01/Readme.md) | [**Siguiente**](../Ejemplo-04/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-02/Ejemplo-04/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 02**](../Readme.md) ➡️ / 📝 `Ejemplo 04: Repetición con ciclos` 2 | 3 | ## 🎯 Objetivo 4 | 5 | 🔍 Comprender cómo utilizar **estructuras de repetición** en Java para ejecutar bloques de código múltiples veces, aplicando `while`, `do-while`, `for` y `for-each`. También exploraremos el uso de `break` y `continue`. 6 | 7 | --- 8 | 9 | ## 🧠 ¿Qué son los ciclos? 10 | 11 | Los ciclos (o bucles) permiten ejecutar instrucciones de forma **repetitiva** mientras se cumpla una condición. Son muy útiles para procesar datos, validar entradas, repetir cálculos, entre otros usos comunes. 12 | 13 | --- 14 | 15 | ## 💡 Ejemplo 1: Control de intentos con `while` 16 | 17 | ### 🎯 Contexto: Intentos para ingresar una contraseña correcta. 18 | 19 | ```java 20 | import java.util.Scanner; 21 | 22 | public class LoginSistema { 23 | public static void main(String[] args) { 24 | Scanner scanner = new Scanner(System.in); 25 | String contraseñaCorrecta = "admin123"; 26 | String input; 27 | int intentos = 0; 28 | int maxIntentos = 3; 29 | 30 | while (intentos < maxIntentos) { 31 | System.out.print("Ingresa tu contraseña: "); 32 | input = scanner.nextLine(); 33 | 34 | if (input.equals(contraseñaCorrecta)) { 35 | System.out.println("✅ Acceso concedido."); 36 | break; 37 | } else { 38 | System.out.println("❌ Contraseña incorrecta."); 39 | intentos++; 40 | } 41 | } 42 | 43 | if (intentos == maxIntentos) { 44 | System.out.println("🔒 Cuenta bloqueada por demasiados intentos."); 45 | } 46 | 47 | scanner.close(); 48 | } 49 | } 50 | ``` 51 | 52 | --- 53 | 54 | ## 💡 Ejemplo 2: Recorriendo productos con `for` y `for-each` 55 | 56 | ### 🎯 Contexto: Mostrar productos de un carrito de compras. 57 | 58 | ```java 59 | public class CarritoCompras { 60 | public static void main(String[] args) { 61 | String[] productos = {"Laptop", "Mouse", "Teclado", "Pantalla", "Audífonos"}; 62 | 63 | // for clásico 64 | System.out.println("📦 Productos en el carrito:"); 65 | for (int i = 0; i < productos.length; i++) { 66 | System.out.println("- " + productos[i]); 67 | } 68 | 69 | // for-each con control de flujo 70 | System.out.println("\n🔁 Recorriendo con for-each:"); 71 | for (String producto : productos) { 72 | if (producto.equals("Teclado")) continue; // Saltar teclado 73 | if (producto.equals("Pantalla")) break; // Detener en pantalla 74 | System.out.println("Producto válido: " + producto); 75 | } 76 | } 77 | } 78 | ``` 79 | 80 | > 🔎 **Nota**: En este ejemplo usamos un **objeto tipo lista** llamado `array`, que nos permite almacenar y recorrer múltiples elementos del mismo tipo. 81 | > Más adelante exploraremos estructuras más flexibles como `ArrayList`. 82 | 83 | --- 84 | 85 | ## 📌 ¿Qué estructuras vimos? 86 | 87 | | Ciclo | ¿Cuándo usarlo? | 88 | |---------------|------------------------------------------------------| 89 | | `while` | Cuando no sabes cuántas veces se repetirá. | 90 | | `do-while` | Similar a `while`, pero ejecuta **al menos una vez**.| 91 | | `for` | Ideal para contar o recorrer posiciones con índice. | 92 | | `for-each` | Recorre todos los elementos de un array fácilmente. | 93 | | `break` | Sale del ciclo inmediatamente. | 94 | | `continue` | Salta a la siguiente iteración. | 95 | 96 | --- 97 | 98 | ## 💡 Buenas prácticas 99 | 100 | - ⚠️ Asegúrate de actualizar las condiciones para evitar ciclos infinitos. 101 | - ✅ Usa `for-each` cuando no necesites acceder a los índices. 102 | - ❌ No uses `break` y `continue` en exceso, puede dificultar la lectura del código. 103 | 104 | --- 105 | 106 | 📘 Recurso recomendado: 107 | 🔗 [Java Loops – W3Schools](https://www.w3schools.com/java/java_while_loop.asp) 108 | 109 | --- 110 | 111 | ⬅️ [**Anterior**](../Ejemplo-03/Readme.md) | [**Siguiente**](../Reto-02/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-02/Imagenes/S00.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-02/Imagenes/S00.jpg -------------------------------------------------------------------------------- /Sesion-02/Imagenes/S02.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-02/Imagenes/S02.jpg -------------------------------------------------------------------------------- /Sesion-02/Imagenes/S02_Fig01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-02/Imagenes/S02_Fig01.jpg -------------------------------------------------------------------------------- /Sesion-02/Imagenes/S02_Fig02.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-02/Imagenes/S02_Fig02.jpg -------------------------------------------------------------------------------- /Sesion-02/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../Readme.md) ➡️ / 📖 `Sesión 02` 2 | 3 |
4 | Sesion_02 5 |
6 | 7 | # 🎯 Objetivo 8 | 9 | ⚒️ Identificar y comprender los tipos de datos, variables, operadores, estructuras condicionales y ciclos en **Java**, para desarrollar programas con lógica básica mantenible y estructurada. 10 | 11 | --- 12 | 13 | ## 📂 Temas de la sesión... 14 | 15 | ### 📖 Tipos de datos en Java y uso de `var` 16 | En Java, cada variable debe tener un tipo definido. En versiones modernas, también podemos usar `var` para inferencia de tipo. 17 | 18 | 🔹 **Tipos primitivos (`int`, `double`, `boolean`, etc.)** 19 | 🔹 **Inferencia de tipo con `var`** 20 | 🔹 **Conversión de tipos de datos y casting** 21 | 22 | 📜 **[Ejemplo 01: Declaración de variables y uso de `var`](Ejemplo-01/Readme.md)** 23 | 24 | --- 25 | 26 | ### 📖 Operadores y expresiones en Java 27 | Los operadores permiten realizar cálculos y tomar decisiones dentro de nuestros programas. 28 | 29 | 🔹 **Operadores aritméticos (`+`, `-`, `*`, `/`, `%`)** 30 | 🔹 **Operadores relacionales (`==`, `!=`, `>`, `<`, etc.)** 31 | 🔹 **Operadores lógicos (`&&`, `||`, `!`)** 32 | 🔹 **Operadores de asignación (`=`, `+=`, `-=`, etc.)** 33 | 🔹 **Operadores de incremento y decremento (++, --)** 34 | 🔹 **Precedencia de operadores regla (pemdas)** 35 | 36 | 37 | 📜 **[Ejemplo 02: Operaciones y comparaciones](Ejemplo-02/Readme.md)** 38 | 🔥 **[Reto 01: Simulador de farmacia con descuento](Reto-01/Readme.md)** 39 | 40 | --- 41 | 42 | ### 📖 Sentencias condicionales 43 | Las estructuras condicionales permiten ejecutar distintas acciones dependiendo de una condición. 44 | 45 | 🔹 **Uso de `if`, `else if`, `else`** 46 | 🔹 **`switch` tradicional y mejorado** 47 | 🔹 **Buenas prácticas en condiciones anidadas** 48 | 49 | 📜 **[Ejemplo 03: Sentencias condicionales](Ejemplo-03/Readme.md)** 50 | 51 | --- 52 | 53 | ### 📖 Ciclos y estructuras de control 54 | Los ciclos permiten ejecutar bloques de código repetidamente, de manera controlada. 55 | 56 | 🔹 **`while`, `do-while`, `for`, `for-each`** 57 | 🔹 **Control de flujo con `break` y `continue`** 58 | 🔹 **Buenas practicas** 59 | 60 | 📜 **[Ejemplo 04: Repetición con ciclos](Ejemplo-04/Readme.md)** 61 | 🔥 **[Reto 02: Cajero automático simple](Reto-02/Readme.md)** 62 | 63 | --- 64 | 65 | ⬅️ [**Anterior**](../Sesion-01/Readme.md) | [**Siguiente**](../Sesion-03/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-02/Reto-01/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 02**](../Readme.md) ➡️ / ⚡`Reto 01: Simulador de farmacia con descuento` 2 | 3 | ## 🎯 Objetivo 4 | 5 | ⚒️ Desarrollar un programa que calcule el total de una compra en farmacia y aplique un descuento si supera cierta cantidad. Este reto refuerza el uso de **operadores aritméticos**, **asignación**, **entrada por consola**, e **inferencia de tipo con `var`**. 6 | 7 | --- 8 | 9 | ## 📝 Instrucciones 10 | 11 | 👥 Puedes resolver este reto de forma individual o en equipo. 12 | 13 | 1. 💊 Crea una clase llamada `SimuladorFarmacia`. 14 | 15 | 2. Solicita al usuario que introduzca los siguientes datos: 16 | - Nombre del medicamento (tipo `String`) 17 | - Precio unitario (tipo `double`) 18 | - Cantidad de piezas (tipo `int`) 19 | 20 | 3. Calcula el **total sin descuento** multiplicando el precio por la cantidad. 21 | 22 | 4. Supón que si el total supera los **$500.00**, la farmacia ofrece un **15% de descuento**. Aplica el descuento usando el operador ternario (`? :`) sin estructuras `if`. 23 | 24 | 5. Muestra en consola el resumen con el siguiente formato: 25 | 26 | ```plaintext 27 | Medicamento: Amoxicilina 28 | Cantidad: 5 29 | Precio unitario: $120.0 30 | Total sin descuento: $600.0 31 | ¿Aplica descuento?: true 32 | Descuento: $90.0 33 | Total a pagar: $510.0 34 | ``` 35 | 36 | --- 37 | 38 | ### 📌 Consideraciones 39 | 40 | - Utiliza `var` en al menos una línea de tu código. 41 | - No uses `if`, `else` ni `switch`. Solo operadores básicos y ternarios. 42 | - El valor del descuento solo debe calcularse si **el total supera los $500.00**. 43 | 44 | --- 45 | 46 | 🏆 Nos vemos en el siguiente reto, ¡mucho éxito! 47 | 48 | --- 49 | 50 | ⬅️ [**Anterior**](../Ejemplo-02/Readme.md) | [**Siguiente**](../Ejemplo-03/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-02/Reto-02/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 02**](../Readme.md) ➡️ / ⚡`Reto 02: Cajero automático simple` 2 | 3 | ## 🎯 Objetivo 4 | 5 | 💻 Implementar un programa que simule un **cajero automático básico**, aplicando estructuras de control como `while`, `switch`, `break` y `continue` para navegar entre opciones y validar operaciones del usuario. 6 | 7 | --- 8 | 9 | ## 📝 Instrucciones 10 | 11 | 👥 Puedes resolver este reto de forma individual o en equipos. 12 | 13 | 1. 🏗️ Crea una **clase** llamada `CajeroAutomatico`. 14 | 15 | 2. 💸 En el método `main`, define un **saldo inicial** (por ejemplo: `saldo = 1000.0`), dicha variable deberá ser inferida por java. 16 | 17 | 3. 📋 Muestra un **menú interactivo** en consola con las siguientes opciones: 18 | ``` 19 | Bienvenido al cajero automático 20 | 1. Consultar saldo 21 | 2. Depositar dinero 22 | 3. Retirar dinero 23 | 4. Salir 24 | ``` 25 | Puedes usar un `do-while` 26 | 27 | 4. 🔁 El programa debe repetirse usando un `while` hasta que el usuario elija salir (`opción 4`). 28 | 29 | 5. 🧠 Utiliza un `switch` para manejar las opciones: 30 | - ✅ **1. Consultar saldo** → Mostrar el saldo actual. 31 | - 💰 **2. Depositar dinero** → Pedir monto a depositar y sumarlo al saldo. 32 | - 💸 **3. Retirar dinero** → Pedir monto a retirar y: 33 | - ⚠️ Validar si hay saldo suficiente. 34 | - ❌ Si no hay suficiente, mostrar un mensaje y continuar sin restar. 35 | - 👋 **4. Salir** → Mostrar mensaje de despedida y terminar el programa. 36 | 37 | 6. 🧭 Controla el flujo con `break` y `continue` donde sea necesario. 38 | 39 | --- 40 | 41 | ## 🎯 Desafío adicional (opcional) 42 | 43 | 🧠 Si el usuario ingresa una **opción inválida**, muestra un mensaje de error y vuelve a mostrar el menú sin detener el programa. 44 | 45 | --- 46 | 47 | 💡 Este reto te ayudará a practicar el uso de ciclos `while`, control de flujo, validación de condiciones y entradas básicas del usuario en un contexto realista. 48 | 49 | --- 50 | 51 | 🏆 Nos vemos en el siguiente reto, ¡mucho éxito! 🎉 52 | 53 | --- 54 | 55 | ⬅️ [**Anterior**](../Ejemplo-04/Readme.md) | [**Siguiente**](../../Sesion-03/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-03/Ejemplo-01/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 03**](../Readme.md) ➡️ / 📝 `Ejemplo 01: Creación y uso de clases y objetos` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Comprender cómo se **define una clase**, cómo se **crean objetos** a partir de ella, y cómo se **utilizan métodos**, aplicando estos conceptos en un contexto real de desarrollo en Java. 8 | 9 | --- 10 | 11 | ## 📌 Escenario profesional 12 | 13 | Imagina que trabajas como **Java backend developer** para una empresa que gestiona proyectos de software. Necesitas modelar una clase que represente los proyectos activos de los clientes, con sus respectivos atributos y comportamientos. 14 | 15 | --- 16 | 17 | ## 🧱 Clase `Proyecto` 18 | 19 | En esta sección definimos la clase `Proyecto`, que servirá como plantilla para crear proyectos con atributos clave y comportamientos típicos de un entorno profesional. 20 | 21 | ```java 22 | public class Proyecto { 23 | 24 | // Atributos del proyecto 25 | private String nombre; 26 | private String cliente; 27 | private int duracionSemanas; 28 | private boolean estaActivo; 29 | 30 | // static - Atributo estático: número total de proyectos creados 31 | public static int totalProyectos = 0; 32 | 33 | // final - Constante: nombre del sistema 34 | public static final String NOMBRE_SISTEMA = "GestorProyectos v1.0"; 35 | 36 | // Constructor 37 | public Proyecto(String nombre, String cliente, int duracionSemanas, boolean estaActivo) { 38 | this.nombre = nombre; 39 | this.cliente = cliente; 40 | this.duracionSemanas = duracionSemanas; 41 | this.estaActivo = estaActivo; 42 | totalProyectos++; // Se incrementa cada vez que se crea un nuevo proyecto 43 | } 44 | 45 | // Método para mostrar información del proyecto 46 | public void mostrarInformacion() { 47 | System.out.println("📁 Proyecto: " + nombre); 48 | System.out.println("👨‍💼 Cliente: " + cliente); 49 | System.out.println("⏳ Duración: " + duracionSemanas + " semanas"); 50 | System.out.println("✅ ¿Activo?: " + (estaActivo ? "Sí" : "No")); 51 | } 52 | 53 | // Método para marcar el proyecto como inactivo 54 | public void cerrarProyecto() { 55 | estaActivo = false; 56 | System.out.println("🚫 El proyecto '" + nombre + "' ha sido cerrado."); 57 | } 58 | } 59 | 60 | ``` 61 | 62 | --- 63 | 64 | ## 🧪 Uso de la clase `Proyecto` 65 | 66 | Aquí creamos y usamos objetos de la clase `Proyecto`, ejecutando sus métodos y accediendo a atributos estáticos (`static`) y constantes (`final`). 67 | 68 | ```java 69 | public class Principal { 70 | public static void main(String[] args) { 71 | 72 | // Uso de atributo final : Accedemos al nombre del sistema definido como constante 73 | System.out.println("🖥️ Sistema: " + Proyecto.NOMBRE_SISTEMA); 74 | 75 | // Creación de objetos: Instanciamos dos proyectos con datos reales 76 | Proyecto p1 = new Proyecto("Sitio Web Corporativo", "Cliente A", 12, true); 77 | Proyecto p2 = new Proyecto("Aplicación Móvil", "Cliente B", 20, true); 78 | 79 | // Uso de métodos: Mostramos los detalles de cada proyecto 80 | p1.mostrarInformacion(); 81 | System.out.println(); 82 | p2.mostrarInformacion(); 83 | System.out.println(); 84 | 85 | // Simulamos el cierre de un proyecto 86 | p1.cerrarProyecto(); 87 | 88 | // Mostramos nuevamente los datos del proyecto cerrado 89 | System.out.println(); 90 | p1.mostrarInformacion(); 91 | 92 | // Uso de atributo static: Total de proyectos creados 93 | System.out.println("\n📊 Total de proyectos creados: " + Proyecto.totalProyectos); 94 | } 95 | } 96 | ``` 97 | 98 | --- 99 | 100 | ## 🔍 Revisión rápida 101 | 102 | | Concepto | Aplicación en el ejemplo | 103 | |--------------------|-----------------------------------------------| 104 | | Clase | `Proyecto` | 105 | | Atributos | `nombre`, `cliente`, `duracionSemanas`, etc. | 106 | | Atributo `static` | `totalProyectos` | 107 | | Constante `final` | `NOMBRE_SISTEMA` | 108 | | Métodos | `mostrarInformacion()`, `cerrarProyecto()` | 109 | | Objetos | `p1`, `p2` | 110 | 111 | 112 | --- 113 | 114 | ## 💡 ¿Sabías que...? 115 | 116 | 🔹 En Java, los miembros `static` existen **incluso antes** de que se cree algún objeto. Por eso puedes usarlos para contar objetos o acceder a utilidades sin instanciar nada. 117 | 118 | 🔹 El modificador `final` no solo se usa en variables. También puedes tener métodos `final` (que no pueden ser sobrescritos) o clases `final` (que no pueden ser heredadas). ¡Una excelente forma de proteger tu código! 119 | 120 | --- 121 | 122 | ⬅️ [**Anterior**](../Readme.md) | [**Siguiente**](../Ejemplo-02/Readme.md)➡️ 123 | -------------------------------------------------------------------------------- /Sesion-03/Ejemplo-02/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 03**](../Readme.md) ➡️ / 📝 `Ejemplo 02 - Métodos, parámetros y retorno de valores` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Comprender cómo se definen y utilizan los **métodos en Java**, diferenciando entre métodos con o sin parámetros, con o sin retorno de valor. También se explora cómo se comportan los datos al ser pasados a métodos (por valor o por referencia), y cómo aplicar **sobrecarga de métodos**. 8 | 9 | --- 10 | 11 | ## 📖 Introducción 12 | 13 | Los métodos permiten organizar el código en **bloques reutilizables**. 14 | Un método puede: 15 | 16 | - Recibir parámetros para trabajar con datos. 17 | - Devolver un valor al programa principal. 18 | - Ejecutar una acción sin devolver nada. 19 | 20 | --- 21 | 22 | ## 1️⃣ Método sin parámetros y sin retorno 23 | 24 | Un método simple que solo muestra un mensaje. No recibe datos ni devuelve nada. 25 | 26 | ```java 27 | public void mostrarBienvenida() { 28 | System.out.println("👋 Bienvenido al sistema"); 29 | } 30 | ``` 31 | 32 | 🧪 Implementación: 33 | 34 | ```java 35 | mostrarBienvenida(); // Se realiza la llamada al método. 36 | ``` 37 | 38 | --- 39 | 40 | ## 2️⃣ Método con parámetros y sin retorno 41 | 42 | Este método recibe dos valores y **muestra el resultado de una operación**. 43 | 44 | ```java 45 | public void mostrarSuma(int a, int b) { 46 | int resultado = a + b; 47 | System.out.println("➕ La suma es: " + resultado); 48 | } 49 | ``` 50 | 51 | 🧪 Implementación: 52 | 53 | ```java 54 | mostrarSuma(10, 20); // Se establecen dos argumentos. 55 | ``` 56 | 57 | --- 58 | 59 | ## 3️⃣ Método con parámetros y con retorno 60 | 61 | Ahora el método **devuelve el resultado** de la suma en lugar de solo mostrarlo. 62 | 63 | ```java 64 | public int obtenerSuma(int a, int b) { 65 | return a + b; 66 | } 67 | ``` 68 | 69 | 🧪 Implementación: 70 | 71 | ```java 72 | int suma = obtenerSuma(5, 7); 73 | System.out.println("🧮 Resultado: " + suma); 74 | ``` 75 | 76 | --- 77 | 78 | ## 4️⃣ Paso por valor (tipos primitivos) 79 | 80 | Los datos primitivos se pasan **por valor**, es decir, se copia el valor original. 81 | 82 | ```java 83 | public void duplicar(int numero) { 84 | numero = numero * 2; 85 | System.out.println("Dentro del método: " + numero); 86 | } 87 | ``` 88 | 89 | 🧪 Implementación: 90 | 91 | ```java 92 | int x = 10; 93 | duplicar(x); 94 | System.out.println("Fuera del método: " + x); // x no cambia 95 | ``` 96 | 97 | --- 98 | 99 | ## 5️⃣ Paso por referencia (objetos) 100 | 101 | Los objetos se pasan **por referencia**, lo que permite modificar sus atributos. 102 | 103 | ```java 104 | public class Persona { 105 | String nombre; 106 | 107 | public Persona(String nombre) { 108 | this.nombre = nombre; 109 | } 110 | } 111 | ``` 112 | 113 | ```java 114 | public void cambiarNombre(Persona p) { 115 | p.nombre = "Nuevo nombre"; 116 | } 117 | ``` 118 | 119 | 🧪 Implementación: 120 | 121 | ```java 122 | Persona persona = new Persona("Mario"); 123 | cambiarNombre(persona); 124 | System.out.println("Nombre actualizado: " + persona.nombre); 125 | ``` 126 | 127 | --- 128 | 129 | ## 6️⃣ Sobrecarga de métodos 130 | 131 | Puedes definir **varias versiones** del mismo método con diferentes parámetros. 132 | 133 | ```java 134 | public void saludar() { 135 | System.out.println("👋 Hola"); 136 | } 137 | 138 | public void saludar(String nombre) { 139 | System.out.println("👋 Hola, " + nombre); 140 | } 141 | ``` 142 | 143 | 🧪 Implementación: 144 | 145 | ```java 146 | saludar(); // Hola 147 | saludar("Mario"); // Hola, Mario 148 | ``` 149 | 150 | --- 151 | 152 | ## 🧠 Resumen rápido 153 | 154 | | Tipo de método | Ejemplo | 155 | |------------------------|--------------------------------| 156 | | Sin parámetros/retorno | `mostrarBienvenida()` | 157 | | Con parámetros | `mostrarSuma(int, int)` | 158 | | Con retorno | `obtenerSuma(int, int)` | 159 | | Paso por valor | `duplicar(int)` | 160 | | Paso por referencia | `cambiarNombre(Persona)` | 161 | | Sobrecarga | `saludar()` / `saludar(String)`| 162 | 163 | --- 164 | 165 | ## 💡 ¿Sabías que...? 166 | 167 | 🔹 En Java, los métodos `void` se usan para **acciones sin retorno**, como imprimir. 168 | 🔹 Puedes usar métodos con retorno para **calcular resultados** y reutilizarlos en otras operaciones. 169 | 🔹 La **sobrecarga** permite tener múltiples versiones de un método con el mismo nombre, siempre que los parámetros sean distintos. 170 | 🔹 Entender el **paso por valor y por referencia** es clave para trabajar con datos en memoria correctamente. 171 | 172 | --- 173 | 174 | ⬅️ [**Anterior**](../Readme.md) | [**Siguiente**](../Reto-01/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-03/Ejemplo-03/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 03**](../Readme.md) ➡️ / 📝 `Ejemplo 03 - Modificadores de acceso y encapsulación` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Comprender cómo se usan los **modificadores de acceso** (`private`, `protected`, `public`) para controlar la visibilidad de atributos y métodos, y cómo aplicar la **encapsulación** para proteger datos dentro de una clase. 8 | 9 | --- 10 | 11 | ## 📌 Escenario profesional 12 | 13 | Imagina que estás desarrollando una clase `Usuario` en una aplicación bancaria. Necesitas proteger los datos sensibles del usuario como el número de cuenta y su saldo, mientras permites mostrar su nombre públicamente. Para ello, usarás modificadores de acceso. 14 | 15 | --- 16 | 17 | ## 🔒 1. Modificador `private` 18 | 19 | Se usa para proteger atributos internos que no deben ser accesibles directamente desde fuera de la clase. 20 | 21 | ```java 22 | public class Usuario { 23 | private String nombre; 24 | private double saldo; // 🔒 No debe accederse directamente 25 | 26 | public Usuario(String nombre, double saldo) { 27 | this.nombre = nombre; 28 | this.saldo = saldo; 29 | } 30 | } 31 | ``` 32 | 33 | --- 34 | 35 | ## 🔑 2. Métodos `public` para acceder a atributos privados (encapsulación) 36 | 37 | Permitimos acceso indirecto a través de métodos públicos (`getters` y `setters`). 38 | 39 | ```java 40 | public String getNombre() { 41 | return nombre; 42 | } 43 | 44 | public double getSaldo() { 45 | return saldo; 46 | } 47 | 48 | public void depositar(double monto) { 49 | saldo += monto; 50 | } 51 | ``` 52 | 53 | --- 54 | 55 | ## 🚀 3. Clase principal que usa los métodos públicos 56 | 57 | ```java 58 | public class Main { 59 | public static void main(String[] args) { 60 | Usuario u = new Usuario("Mario", 500.0); 61 | 62 | // Accedemos al nombre (método público) 63 | System.out.println("👤 Usuario: " + u.getNombre()); 64 | 65 | // Accedemos al saldo usando método getter 66 | System.out.println("💰 Saldo inicial: $" + u.getSaldo()); 67 | 68 | // Usamos un método público para modificar saldo 69 | u.depositar(250.0); 70 | System.out.println("💰 Saldo después del depósito: $" + u.getSaldo()); 71 | } 72 | } 73 | ``` 74 | 75 | --- 76 | 77 | ## 🧠 ¿Y `protected`? 78 | 79 | Aunque `protected` se usa más en herencia, aquí te mostramos su uso básico: 80 | 81 | ```java 82 | public class Persona { 83 | protected String nacionalidad = "México"; 84 | } 85 | ``` 86 | 87 | ```java 88 | public class Empleado extends Persona { 89 | public void mostrarNacionalidad() { 90 | System.out.println("🌎 Nacionalidad: " + nacionalidad); 91 | } 92 | } 93 | ``` 94 | 95 | --- 96 | 97 | ## 🔍 Revisión rápida 98 | 99 | | Modificador | Accesible desde misma clase | Mismo paquete | Subclases | Otras clases | 100 | |-------------|------------------------------|---------------|-----------|--------------| 101 | | `private` | ✅ | ❌ | ❌ | ❌ | 102 | | `protected` | ✅ | ✅ | ✅ | ❌ | 103 | | `public` | ✅ | ✅ | ✅ | ✅ | 104 | 105 | --- 106 | 107 | ## 💡 ¿Sabías que...? 108 | 109 | 🔐 El uso de `private` junto con métodos `get` y `set` es el corazón de la **encapsulación**: protege tus datos y controla cómo se modifican. 110 | 111 | 🛡️ Un buen diseño orientado a objetos evita que los atributos sean públicos. En cambio, se accede a ellos mediante métodos controlados. 112 | 113 | 🏗️ Encapsular te permite cambiar la lógica interna sin afectar a quienes usan la clase, ideal para **escalabilidad y mantenimiento**. 114 | 115 | --- 116 | 117 | 📘 ¡Recuerda! Encapsular no es ocultar por completo, sino **dar acceso controlado**. 118 | 119 | --- 120 | 121 | ⬅️ [**Anterior**](../Reto-01/Readme.md) | [**Siguiente**](../Ejemplo-04/Readme.md)➡️ 122 | -------------------------------------------------------------------------------- /Sesion-03/Ejemplo-04/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 03**](../Readme.md) ➡️ / 📝 `Ejemplo 04: Optional y manejo seguro de valores nulos` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Evitar errores comunes como `NullPointerException` usando la clase `Optional` de Java para manejar valores que pueden estar ausentes. 8 | 9 | --- 10 | 11 | ## 📌 Escenario profesional 12 | 13 | Estás desarrollando una aplicación de contacto con clientes. Algunos usuarios registran su número telefónico, pero otros no. Necesitas acceder a esa información sin que tu programa se rompa si no hay dato. 14 | 15 | --- 16 | 17 | ## 🧪 1. ¿Qué es `Optional`? 18 | 19 | `Optional` es una clase contenedor que puede tener un valor o estar vacía. Así evitamos acceder directamente a `null`. 20 | 21 | ```java 22 | import java.util.Optional; 23 | 24 | public class Contacto { 25 | private Optional telefono; 26 | 27 | public Contacto(String telefono) { 28 | this.telefono = Optional.ofNullable(telefono); 29 | } 30 | 31 | public Optional getTelefono() { 32 | return telefono; 33 | } 34 | } 35 | ``` 36 | --- 37 | 38 | ## 🛠️ 2. Uso de `isPresent()` y `ifPresent()` 39 | 40 | Detectamos si hay valor, y ejecutamos algo solo si existe. 41 | 42 | ```java 43 | Contacto c1 = new Contacto("555-1234"); 44 | Contacto c2 = new Contacto(null); 45 | 46 | // Usando isPresent (menos recomendado) 47 | if (c1.getTelefono().isPresent()) { 48 | System.out.println("📞 Teléfono: " + c1.getTelefono().get()); 49 | } 50 | 51 | // Mejor: usando ifPresent 52 | c2.getTelefono().ifPresent(tel -> System.out.println("📞 Teléfono: " + tel)); 53 | ``` 54 | --- 55 | 56 | ## ⚙️ 3. Uso de `orElse()` y `orElseThrow()` 57 | 58 | Devolvemos un valor por defecto o lanzamos una excepción si no hay valor. 59 | 60 | ```java 61 | // orElse devuelve el valor si existe, o el alternativo si no 62 | String tel1 = c1.getTelefono().orElse("No registrado"); 63 | String tel2 = c2.getTelefono().orElse("No registrado"); 64 | 65 | System.out.println("📞 Teléfono 1: " + tel1); 66 | System.out.println("📞 Teléfono 2: " + tel2); 67 | 68 | // orElseThrow lanza una excepción si no hay valor 69 | String telSeguro = c1.getTelefono().orElseThrow(() -> new RuntimeException("⚠️ Teléfono obligatorio")); 70 | ``` 71 | --- 72 | 73 | ## 📦 Buenas prácticas 74 | 75 | ✔️ Usa `Optional` como retorno de métodos, no como atributo de clase (este ejemplo es con fines didácticos). 76 | 77 | ✔️ Prefiere `ifPresent()` sobre `isPresent()` + `get()` 78 | 79 | ✔️ Usa `orElseGet()` si el valor alternativo es costoso de calcular. 80 | 81 | --- 82 | 83 | ## 🔍 Revisión rápida 84 | 85 | | Método | ¿Que hace? | 86 | |----------------|---------------------------------------| 87 | | `isPresent()` | ¿Hay valor? Devuelve true o false. | 88 | | `ifPresent()` | Ejecuta código solo si hay valor. | 89 | | `orElse(valor)`| Devuelve el valor o uno por defecto. | 90 | | `orElseThrow()`| Lanza excepción si no hay valor. | 91 | 92 | --- 93 | 94 | ## 💡 ¿Sabías que...? 95 | 96 | 🧠 `Optional` se introdujo en Java 8 para ayudarte a escribir código más seguro y legible. 97 | 🚫 Ya no necesitas llenar tu código de `if (obj != null)`, ahora puedes usar flujos claros y expresivos. 98 | 📚 Muchas APIs modernas de Java y frameworks como Spring usan `Optional` para devolver resultados de forma segura. 99 | 100 | --- 101 | 102 | ⬅️ [**Anterior**](../Ejemplo-03/Readme.md) | [**Siguiente**](../Reto-02/Readme.md)➡️ 103 | 104 | -------------------------------------------------------------------------------- /Sesion-03/Imagenes/S00.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-03/Imagenes/S00.jpg -------------------------------------------------------------------------------- /Sesion-03/Imagenes/S03.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-03/Imagenes/S03.jpg -------------------------------------------------------------------------------- /Sesion-03/Imagenes/S03_Fig01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-03/Imagenes/S03_Fig01.jpg -------------------------------------------------------------------------------- /Sesion-03/Imagenes/S03_Fig02.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-03/Imagenes/S03_Fig02.jpg -------------------------------------------------------------------------------- /Sesion-03/Imagenes/S03_Fig03.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-03/Imagenes/S03_Fig03.jpg -------------------------------------------------------------------------------- /Sesion-03/Imagenes/S03_Fig04.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-03/Imagenes/S03_Fig04.jpg -------------------------------------------------------------------------------- /Sesion-03/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../Readme.md) ➡️ / 📖 `Sesión 03` 2 | 3 |
4 | Sesion_03 5 |
6 | 7 | ## 🎯 Objetivo 8 | 9 | ⚒️ 🔎 Comprender los fundamentos de la **programación orientada a objetos en Java**, enfocándose en la creación y uso de clases y objetos, definición de métodos, control de acceso mediante modificadores y uso de `Optional` para el manejo seguro de valores nulos. 10 | 11 | --- 12 | 13 | 📘 Material del prework: 14 | Antes de comenzar con los ejercicios de esta sesión, recordemos que en el material de prework hemos cubierto los fundamentos teóricos que aplicaremos hoy. A lo largo de esta sesión, pondremos en práctica estos conceptos mediante una serie de ejercicios y retos diseñados para reforzar y validar nuestro entendimiento. 15 | 🔥¡Vamos a comenzar!🔥 16 | 17 | --- 18 | 19 | ## 📂 Temas de la sesión... 20 | 21 | 22 | ### 📖 Creación y uso de clases y objetos 23 | 24 | En Java, una **clase** representa el plano o molde para construir objetos, que son instancias con atributos y comportamientos. Comprender la relación entre clases y objetos es fundamental para modelar soluciones en POO. 25 | 26 | - Atributos y métodos 27 | - Palabras clave `static` y `final` 28 | - Ejemplo práctico de creación de objetos 29 | 30 | ##### 📜 **[Ejemplo 01: Creación y uso de clases y objetos](Ejemplo-01/Readme.md)** 31 | --- 32 | 33 | ### 📖 Métodos, parámetros y retorno de valores 34 | 35 | Los **métodos** permiten organizar el código en bloques reutilizables. Pueden recibir parámetros y devolver valores. 36 | 37 | - Estructura de un método 38 | - Tipos de métodos: con y sin retorno 39 | - Paso de parámetros (por valor y referencia) 40 | - Sobrecarga de métodos 41 | 42 | ##### 📜 **[Ejemplo 02: Métodos, parámetros y retorno de valores](Ejemplo-02/Readme.md)** 43 | ##### 🔥 **[Reto 01: Reserva de vuelos](Reto-01/Readme.md)** 44 | 45 | --- 46 | 47 | ### 📖 Modificadores de acceso 48 | 49 | Los **modificadores de acceso** (`private`, `protected`, `public`) definen la visibilidad de los atributos y métodos, permitiendo **encapsular** y proteger los datos de una clase. 50 | 51 | - Diferencias entre `private`, `protected` y `public` 52 | - Niveles de acceso en Java 53 | - Encapsulación y protección de datos 54 | 55 | ##### 📜 **[Ejemplo 03: Modificadores de acceso](Ejemplo-03/Readme.md)** 56 | 57 | --- 58 | 59 | ### 📖 `Optional` y manejo seguro de valores nulos 60 | 61 | La clase `Optional` permite manejar valores que podrían ser `null`, evitando errores comunes como `NullPointerException`. 62 | 63 | - Qué es `Optional` y por qué usarlo 64 | - Métodos útiles: `isPresent()`, `ifPresent()`, `orElse()`, `orElseThrow()` 65 | - Buenas prácticas con `Optional` 66 | 67 | ##### 📜 **[Ejemplo 04: Optional y manejo seguro de valores nulos](Ejemplo-04/Readme.md)** 68 | ##### 🔥 **[Reto 02: Factura con RFC opcional](Reto-02/Readme.md)** 69 | 70 | --- 71 | 72 | 73 | ⬅️ [**Anterior**](../Readme.md) | [**Siguiente**](../Sesion-04/Readme.md)➡️ 74 | -------------------------------------------------------------------------------- /Sesion-03/Reto-01/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 03**](../Readme.md) ➡️ / ⚡`Reto 01: Reserva de vuelos` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Diseñar un sistema básico de **reservas de vuelo** aplicando los fundamentos de la **Programación Orientada a Objetos** en Java. Practicarás la **creación de clases y objetos**, el uso de **atributos `static` y `final`**, así como la definición de **métodos con parámetros y valores de retorno**. 8 | 9 | --- 10 | 11 | ## 📝 Instrucciones 12 | 13 | ✈️ Tu nuevo desafío es simular un sistema donde un **pasajero** puede reservar un asiento en un **vuelo**, consultar su itinerario y cancelar la reserva si así lo desea. 14 | 15 | --- 16 | 17 | ### 🧱 1. Crear la clase `Vuelo` 18 | 19 | 🔐 **Atributos**: 20 | - `final String codigoVuelo`: código único del vuelo ✈️ 21 | - `String destino`: ciudad destino del vuelo 🗺️ 22 | - `String horaSalida`: hora de salida en formato 24h ⏰ 23 | - `Pasajero asientoReservado`: referencia al pasajero que reservó el asiento (puede ser `null`) 24 | 25 | 🛠️ **Métodos**: 26 | - `Vuelo(String codigo, String destino, String horaSalida)`: constructor del vuelo 27 | - `boolean reservarAsiento(Pasajero p)` → Asigna al pasajero si no hay reserva previa 28 | - `boolean reservarAsiento(String nombre, String pasaporte)` → Método sobrecargado 29 | - `void cancelarReserva()` → Elimina al pasajero asignado 30 | - `String obtenerItinerario()` → Muestra la información del vuelo y el pasajero 31 | 32 | --- 33 | 34 | ### 👤 2. Crear la clase `Pasajero` 35 | 36 | 📋 **Atributos**: 37 | - `String nombre`: nombre del pasajero 👤 38 | - `String pasaporte`: número de pasaporte ✈️ 39 | 40 | 🛠️ **Métodos**: 41 | - `Pasajero(String nombre, String pasaporte)` 42 | - `String getNombre()` 43 | - `String getPasaporte()` 44 | 45 | --- 46 | 47 | ### 🚀 3. En la clase `Principal` 48 | 49 | 📌 Actividades: 50 | - Crear al menos **un pasajero** y **un vuelo** 51 | - Reservar el asiento en el vuelo 52 | - Mostrar el itinerario 53 | - Cancelar la reserva 54 | - Mostrar nuevamente el itinerario 55 | - Reservar un asiento en el vuelo usando un nombre y pasaporte 56 | 57 | --- 58 | 59 | ## 🧩 Salida esperada 60 | 61 | ```plaintext 62 | ✅ Reserva realizada con éxito. 63 | 64 | ✈️ Itinerario del vuelo: 65 | Código: UX123 66 | Destino: París 67 | Salida: 14:30 68 | Pasajero: Ana Martínez 69 | 70 | ❌ Cancelando reserva... 71 | 72 | ✈️ Itinerario del vuelo: 73 | Código: UX123 74 | Destino: París 75 | Salida: 14:30 76 | Pasajero: [Sin reserva] 77 | 78 | ✈️ Itinerario del vuelo: 79 | Código: UX123 80 | Destino: París 81 | Salida: 14:30 82 | Pasajero: Mario Gonzalez 83 | ``` 84 | 85 | --- 86 | 87 | 🏆 Nos vemos en el siguiente reto, ¡mucho éxito! 88 | 89 | --- 90 | 91 | ⬅️ [**Anterior**](../Ejemplo-02/Readme.md) | [**Siguiente**](../Ejemplo-03/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-03/Reto-02/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 04**](../Readme.md) ➡️ / ⚡`Reto 02: Factura con RFC opcional` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Diseñar una clase `Factura` aplicando los principios de **encapsulación con modificadores de acceso** y utilizando la clase **`Optional`** para manejar valores que pueden ser nulos, como el RFC del cliente. 8 | 9 | --- 10 | 11 | ## 📝 Instrucciones 12 | 13 | 🧾 Tu reto será modelar una factura sencilla, que contenga los datos básicos de una compra y, opcionalmente, el RFC del cliente. Se deberá proteger el acceso a los atributos y permitir el uso seguro de `null` a través de `Optional`. 14 | 15 | --- 16 | 17 | ### 🧱 1. Crear la clase `Factura` 18 | 19 | 🔐 **Atributos privados**: 20 | - `double monto`: cantidad total de la factura 💵 21 | - `String descripcion`: breve concepto de lo facturado 🧾 22 | - `Optional rfc`: RFC del cliente (puede estar presente o no) 23 | 24 | 🛠️ **Métodos públicos**: 25 | - `Factura(double monto, String descripcion, String rfc)` 26 | - Si el RFC es `null`, debe almacenarse usando `Optional.empty()` 27 | - `String getResumen()` → Devuelve una cadena con los datos de la factura 28 | - Si el RFC está presente, se muestra 29 | - Si no, se muestra `"RFC: [No proporcionado]"` 30 | 31 | --- 32 | 33 | ### 🚀 2. En la clase `Principal` 34 | 35 | 📌 Actividades: 36 | - Crear al menos **2 facturas**: 37 | - Una **con RFC** 38 | - Otra **sin RFC** (`null`) 39 | - Imprimir el resumen de ambas facturas usando el método `getResumen()` 40 | 41 | --- 42 | 43 | ## 🧩 Salida esperada 44 | 45 | ```plaintext 46 | 📄 Factura generada: 47 | Descripción: Servicio de consultoría 48 | Monto: $2500.0 49 | RFC: ABCC010101XYZ 50 | 51 | 📄 Factura generada: 52 | Descripción: Reparación de equipo 53 | Monto: $1800.0 54 | RFC: [No proporcionado] 55 | ``` 56 | 57 | --- 58 | 59 | 📌 **Nota importante:** 60 | En este reto deberás aplicar: 61 | - Encapsulación (`private` + métodos públicos) 62 | - Uso de `Optional` para evitar errores con valores nulos 63 | 64 | --- 65 | 66 | 🏆 ¡Sigue así! Este reto te ayudará a consolidar buenas prácticas de desarrollo orientado a objetos en Java. 67 | 68 | --- 69 | 70 | ⬅️ [**Anterior**](../Ejemplo-04/Readme.md) | [**Siguiente**](../../Sesion-04/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-04/Ejemplo-01/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 04**](../Readme.md) ➡️ / 📝 `Ejemplo 01: Constructores e inicialización de objetos` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Aplicar de forma práctica el uso de **constructores** en Java (`por defecto`, `con parámetros`, `de copia` y **sobrecarga**), usando un escenario real para modelar una clase de entidad con distintas formas de inicialización. 8 | 9 | --- 10 | 11 | ## 🧠 ¿Que es un constructor? 12 | 13 | En Java, un **constructor** es un método especial que se ejecuta al crear un objeto. Sirve para inicializar sus atributos y garantizar que comience con valores válidos. Existen: 14 | 15 | - **Constructor por defecto:** No recibe parámetros, asigna valores estándar. 16 | - **Constructor con parámetros:** Permite personalizar el objeto desde el inicio. 17 | - **Constructor de copia:** Crea un nuevo objeto a partir de otro existente. 18 | - **Sobrecarga de constructores:** Permite múltiples formas de crear objetos con diferentes datos disponibles. 19 | 20 | --- 21 | 22 | ## 💡 Ejemplo 1 23 | 24 | Imagina que trabajas como **Java Backend Developer** para una empresa que gestiona servicios de soporte técnico. Necesitas implementar una clase que represente **tickets de soporte**, permitiendo diferentes formas de crearlos: con valores por defecto, personalizados, clonando uno existente o usando diferentes combinaciones de información inicial. 25 | 26 | --- 27 | 28 | ## 🧱 Clase `TicketSoporte` 29 | 30 | ```java 31 | public class TicketSoporte { 32 | 33 | // Atributos de instancia 34 | private String titulo; 35 | private String categoria; 36 | private int prioridad; // 1: Alta, 2: Media, 3: Baja 37 | private boolean estaActivo; 38 | 39 | // Constructor por defecto 40 | public TicketSoporte() { 41 | this.titulo = "Sin título"; 42 | this.categoria = "General"; 43 | this.prioridad = 2; 44 | this.estaActivo = true; 45 | } 46 | 47 | // Constructor con parámetros 48 | public TicketSoporte(String titulo, String categoria, int prioridad) { 49 | this.titulo = titulo; 50 | this.categoria = categoria; 51 | this.prioridad = prioridad; 52 | this.estaActivo = true; 53 | } 54 | 55 | // Constructor de copia 56 | public TicketSoporte(TicketSoporte otro) { 57 | this.titulo = otro.titulo; 58 | this.categoria = otro.categoria; 59 | this.prioridad = otro.prioridad; 60 | this.estaActivo = otro.estaActivo; 61 | } 62 | 63 | // Constructor sobrecargado con solo título 64 | public TicketSoporte(String titulo) { 65 | this.titulo = titulo; 66 | this.categoria = "Sin categoría"; 67 | this.prioridad = 3; // Baja 68 | this.estaActivo = true; 69 | } 70 | 71 | // Método para mostrar la información del ticket 72 | public void mostrarInfo() { 73 | System.out.println("🎫 Ticket: " + titulo); 74 | System.out.println("📂 Categoría: " + categoria); 75 | System.out.println("⚠️ Prioridad: " + prioridad); 76 | System.out.println("📌 Estado: " + (estaActivo ? "Activo" : "Cerrado")); 77 | } 78 | 79 | // Método para cerrar el ticket 80 | public void cerrar() { 81 | estaActivo = false; 82 | System.out.println("🔒 El ticket '" + titulo + "' ha sido cerrado."); 83 | } 84 | } 85 | ``` 86 | 87 | --- 88 | 89 | ## 🚀 Ejecución en `Main` 90 | 91 | ```java 92 | public class Main { 93 | public static void main(String[] args) { 94 | 95 | // Constructor por defecto 96 | TicketSoporte ticket1 = new TicketSoporte(); 97 | System.out.println("\n✅ Ticket creado con constructor por defecto:"); 98 | ticket1.mostrarInfo(); 99 | 100 | // Constructor con parámetros 101 | TicketSoporte ticket2 = new TicketSoporte("Error al iniciar sesión", "Accesos", 1); 102 | System.out.println("\n✅ Ticket creado con parámetros:"); 103 | ticket2.mostrarInfo(); 104 | 105 | // Cerrar ticket y mostrar nuevamente 106 | ticket2.cerrar(); 107 | ticket2.mostrarInfo(); 108 | 109 | // Constructor de copia 110 | TicketSoporte ticket3 = new TicketSoporte(ticket2); 111 | System.out.println("\n✅ Ticket copiado desde otro:"); 112 | ticket3.mostrarInfo(); 113 | 114 | // Constructor sobrecargado con solo título 115 | TicketSoporte ticket4 = new TicketSoporte("Consulta sobre facturación"); 116 | System.out.println("\n✅ Ticket con constructor sobrecargado (solo título):"); 117 | ticket4.mostrarInfo(); 118 | } 119 | } 120 | ``` 121 | 122 | --- 123 | 124 | ## 🔍 Revisión rápida 125 | 126 | | Constructor | Descripción | Ejemplo | 127 | |------------------------------|---------------------------------------------------|----------------------------------------| 128 | | Por defecto | Inicializa con valores estándar. | `new TicketSoporte()` | 129 | | Con parámetros | Permite personalización total. | `new TicketSoporte("...", "...", ...)` | 130 | | De copia | Duplica otro ticket existente. | `new TicketSoporte(ticket)` | 131 | | Sobrecargado (solo título) | Permite crear con solo el título. | `new TicketSoporte("Solo título")` | 132 | 133 | --- 134 | 135 | ## 💡 ¿Sabías que...? 136 | 137 | 🔹 Puedes tener **múltiples constructores en una misma clase** siempre que sus firmas (parámetros) sean diferentes. Esto se llama **sobrecarga**. 138 | 139 | 🔹 El uso de constructores ayuda a mantener el código más limpio y seguro, evitando que objetos queden con valores inválidos. 140 | 141 | 🔹 Los **constructores de copia** son útiles cuando necesitas manipular una copia sin afectar el objeto original. 142 | 143 | 🔹 Si no defines ningún constructor, Java agregará uno por defecto sin parámetros automáticamente. 144 | 145 | --- 146 | 147 | ⬅️ [**Anterior**](../Readme.md) | [**Siguiente**](../Ejemplo-02/Readme.md)➡️ 148 | -------------------------------------------------------------------------------- /Sesion-04/Ejemplo-02/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 04**](../Readme.md) ➡️ / 📝 `Ejemplo 02: Métodos equals(), hashCode() y toString()` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Aplicar los métodos especiales `equals()`, `hashCode()` y `toString()` en una clase personalizada para mejorar la comparación, visualización y uso de objetos en estructuras de datos. 8 | 9 | --- 10 | 11 | ## 🧠 Métodos `equals()`, `hashCode()` y `toString()` 12 | 13 | Estos métodos permiten trabajar con objetos de forma más eficiente y comprensible: 14 | 15 | - `equals()` compara el **contenido** de los objetos. 16 | - `hashCode()` genera un código único para cada objeto (clave en colecciones como HashSet o HashMap). 17 | - `toString()` ofrece una representación **legible** del objeto para la consola o logs. 18 | 19 | --- 20 | 21 | ## 📌 Escenario profesional 22 | 23 | Siguiendo el ejemplo anterior: trabajas como **Java Backend Developer** en un sistema de soporte técnico. Cada ticket debe poder ser comparado, identificado en estructuras de datos y mostrado fácilmente para depuración. 24 | 25 | Para ello, implementamos estos tres métodos en la clase `TicketSoporte`. 26 | 27 | --- 28 | 29 | ## 🧱 Clase `TicketSoporte` 30 | 31 | ```java 32 | import java.util.Objects; 33 | 34 | public class TicketSoporte { 35 | 36 | private String titulo; 37 | private String categoria; 38 | private int prioridad; 39 | private boolean estaActivo; 40 | 41 | public TicketSoporte(String titulo, String categoria, int prioridad) { 42 | this.titulo = titulo; 43 | this.categoria = categoria; 44 | this.prioridad = prioridad; 45 | this.estaActivo = true; 46 | } 47 | 48 | // Sobrescribimos equals() para comparar contenido 49 | @Override 50 | public boolean equals(Object obj) { 51 | if (this == obj) return true; // Mismo objeto 52 | if (obj == null || getClass() != obj.getClass()) return false; 53 | 54 | TicketSoporte otro = (TicketSoporte) obj; 55 | return this.titulo.equals(otro.titulo) && 56 | this.categoria.equals(otro.categoria) && 57 | this.prioridad == otro.prioridad && 58 | this.estaActivo == otro.estaActivo; 59 | } 60 | 61 | // hashCode() compatible con equals() 62 | @Override 63 | public int hashCode() { 64 | return Objects.hash(titulo, categoria, prioridad, estaActivo); 65 | } 66 | 67 | // toString() para ver fácilmente la información del ticket 68 | @Override 69 | public String toString() { 70 | return "🎫 TicketSoporte {" + 71 | "titulo='" + titulo + '\'' + 72 | ", categoria='" + categoria + '\'' + 73 | ", prioridad=" + prioridad + 74 | ", estaActivo=" + estaActivo + 75 | '}'; 76 | } 77 | } 78 | ``` 79 | 80 | --- 81 | 82 | ## 🚀 Ejecución en `Main` 83 | 84 | ```java 85 | public class Main { 86 | public static void main(String[] args) { 87 | 88 | // Creamos dos tickets con los mismos valores 89 | TicketSoporte t1 = new TicketSoporte("Error de login", "Accesos", 1); 90 | TicketSoporte t2 = new TicketSoporte("Error de login", "Accesos", 1); 91 | 92 | // Comparación con equals() 93 | System.out.println("¿Son iguales? " + t1.equals(t2)); // true 94 | 95 | // Hash codes 96 | System.out.println("Hash de t1: " + t1.hashCode()); 97 | System.out.println("Hash de t2: " + t2.hashCode()); 98 | 99 | // Representación legible del objeto 100 | System.out.println("Ticket 1:"); 101 | System.out.println(t1); 102 | } 103 | } 104 | ``` 105 | 106 | --- 107 | 108 | ## 💡 No olvides... 109 | 110 | 🔹 Es **obligatorio** sobrescribir `hashCode()` si sobrescribes `equals()` para evitar errores en estructuras como `HashSet` o `HashMap`. 111 | 112 | 🔹 `toString()` es muy útil para mostrar objetos en logs, en lugar de ver direcciones de memoria. 113 | 114 | 🔹 Estas buenas prácticas ayudan a escribir código más limpio, claro y **profesional**. 115 | 116 | --- 117 | 118 | ⬅️ [**Anterior**](../Ejemplo-01/Readme.md) | [**Siguiente**](../Reto-01/Readme.md)➡️ 119 | -------------------------------------------------------------------------------- /Sesion-04/Ejemplo-03/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 04**](../Readme.md) ➡️ / 📝 `Ejemplo 03: Uso de record y Objects.equals()` 2 | 3 | 4 | ## 🎯 Objetivo 5 | 6 | Explorar cómo usar `record` para simplificar clases de solo datos y aplicar `Objects.equals()` para hacer comparaciones seguras, incluso si hay valores `null`. 7 | 8 | --- 9 | 10 | ## 🧠 Recordemos... 11 | 12 | - `record`: Permite crear clases de solo lectura (inmutables) con menos código y métodos útiles generados automáticamente. 13 | - `Objects.equals()`: Compara objetos de manera segura, evitando errores por `null`. 14 | 15 | --- 16 | 17 | ## 📌 Escenario profesional 18 | 19 | Imagina que trabajas como **Java Backend Developer** en una empresa que gestiona empleados. Necesitas almacenar información simple como nombre y edad de cada empleado, compararlos y mostrarlos fácilmente, asegurando que el sistema no se caiga si uno de los valores es `null`. 20 | 21 | --- 22 | 23 | ## 🧱 Creación del record `Empleado` 24 | 25 | ```java 26 | // Definimos un record simple con dos campos 27 | public record Empleado(String nombre, Integer edad) { 28 | } 29 | ``` 30 | 31 | 🧠 Java genera automáticamente: 32 | - Constructor 33 | - Métodos `nombre()`, `edad()` 34 | - `equals()`, `hashCode()`, y `toString()` 35 | 36 | --- 37 | 38 | ## 🧪 Comparación segura con `Objects.equals()` 39 | 40 | ```java 41 | import java.util.Objects; 42 | 43 | public class Main { 44 | public static void main(String[] args) { 45 | // Creamos dos empleados con valores null en el nombre 46 | Empleado e1 = new Empleado(null, 25); 47 | Empleado e2 = new Empleado(null, 25); 48 | 49 | // Usamos Objects.equals() para comparar los nombres (evita NullPointerException) 50 | boolean nombresIguales = Objects.equals(e1.nombre(), e2.nombre()); 51 | 52 | // Mostramos los objetos y la comparación 53 | System.out.println("Empleado 1: " + e1); 54 | System.out.println("Empleado 2: " + e2); 55 | System.out.println("¿Los nombres son iguales?: " + nombresIguales); 56 | } 57 | } 58 | ``` 59 | 60 | --- 61 | 62 | ## 🔍 Revisión rápida 63 | 64 | | Elemento | ¿Qué hace? | 65 | |----------------------|--------------------------------------------------------------| 66 | | `record` | Crea una clase inmutable con constructor, getters y más. | 67 | | `Objects.equals()` | Compara valores sin lanzar excepciones si hay `null`. | 68 | | `toString()` | Ya viene implementado en un `record` para mostrar datos. | 69 | 70 | --- 71 | 72 | ## 💡 ¿Sabías que...? 73 | 74 | - Los `record` son ideales para **representar datos simples** como respuestas de API, formularios, o resultados de base de datos. 75 | - `Objects.equals()` **evita errores comunes** que se dan al comparar campos que podrían ser `null`. 76 | - Los `record` no permiten setters ni herencia, lo que los hace seguros y predecibles. 77 | 78 | --- 79 | 80 | ⬅️ [**Anterior**](../Reto-01/Readme.md) | [**Siguiente**](../Ejemplo-04/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-04/Ejemplo-04/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 04**](../Readme.md) ➡️ / 📝 `Ejemplo 04: Principios de encapsulación e inmutabilidad` 2 | 3 | 4 | 5 | ## 🎯 Objetivo 6 | 7 | Aplicar el principio de **encapsulación** usando `private`, `getters` y `setters` con validación, y demostrar cómo crear una **clase inmutable** usando `final` y sin métodos modificadores. 8 | 9 | --- 10 | 11 | ## 🧠 Antes de empezar, recordemos: 12 | 13 | - **Encapsulación**: Oculta los atributos de una clase para evitar modificaciones no controladas. 14 | - **Inmutabilidad**: Los objetos no cambian después de ser creados. Útil para asegurar estabilidad y evitar errores. 15 | 16 | --- 17 | 18 | ## 📌 Escenario 19 | 20 | Imagina que trabajas como **Java Developer** en un sistema de recursos humanos. Debes implementar una clase `Empleado` que proteja los datos del trabajador y otra clase `Contrato` que, una vez creada, **no se puede modificar**. 21 | 22 | --- 23 | 24 | ## 🧱 Clase `Empleado` (con encapsulación) 25 | 26 | ```java 27 | public class Empleado { 28 | 29 | // Atributos privados (encapsulados) 30 | private String nombre; 31 | private int edad; 32 | 33 | // Constructor vacío 34 | public Empleado() {} 35 | 36 | // Getter para nombre 37 | public String getNombre() { 38 | return nombre; 39 | } 40 | 41 | // Setter con validación para nombre 42 | public void setNombre(String nombre) { 43 | if (nombre != null && !nombre.isEmpty()) { 44 | this.nombre = nombre; 45 | } else { 46 | System.out.println("❌ El nombre no puede estar vacío."); 47 | } 48 | } 49 | 50 | // Getter para edad 51 | public int getEdad() { 52 | return edad; 53 | } 54 | 55 | // Setter con validación para edad 56 | public void setEdad(int edad) { 57 | if (edad > 0) { 58 | this.edad = edad; 59 | } else { 60 | System.out.println("❌ La edad debe ser mayor a 0."); 61 | } 62 | } 63 | 64 | // Método para mostrar información 65 | public void mostrarInfo() { 66 | System.out.println("👨 Empleado: " + nombre + ", Edad: " + edad); 67 | } 68 | } 69 | ``` 70 | 71 | --- 72 | 73 | ## 🧱 Clase `Contrato` (inmutable) 74 | 75 | ```java 76 | public final class Contrato { 77 | 78 | // Atributos privados y finales 79 | private final String tipo; 80 | private final double salario; 81 | 82 | // Constructor que inicializa todos los atributos 83 | public Contrato(String tipo, double salario) { 84 | this.tipo = tipo; 85 | this.salario = salario; 86 | } 87 | 88 | // Solo getters, sin setters 89 | public String getTipo() { 90 | return tipo; 91 | } 92 | 93 | public double getSalario() { 94 | return salario; 95 | } 96 | 97 | // Método para mostrar información 98 | public void mostrarInfo() { 99 | System.out.println("📄 Contrato: " + tipo + ", Salario: $" + salario); 100 | } 101 | } 102 | ``` 103 | 104 | --- 105 | 106 | ## 🚀 Ejecución en `Main` 107 | 108 | ```java 109 | public class Main { 110 | public static void main(String[] args) { 111 | 112 | // Creamos un empleado y asignamos datos de forma segura 113 | Empleado e = new Empleado(); 114 | e.setNombre("Valeria"); 115 | e.setEdad(29); 116 | e.mostrarInfo(); 117 | 118 | // Creamos un contrato que no se puede modificar después 119 | Contrato c = new Contrato("Tiempo completo", 25000.00); 120 | c.mostrarInfo(); 121 | } 122 | } 123 | ``` 124 | 125 | --- 126 | 127 | ## 🔍 Revisión rápida 128 | 129 | | Concepto | Aplicación en el ejemplo | 130 | |-----------------|------------------------------------------------------| 131 | | Encapsulación | Atributos `private`, acceso con `get` y `set` | 132 | | Validación | Se verifica que nombre no sea vacío y edad > 0 | 133 | | Inmutabilidad | Clase `Contrato` con atributos `final` sin setters | 134 | 135 | --- 136 | 137 | ## 💡 ¿Sabías que...? 138 | 139 | - Encapsular ayuda a proteger la lógica del negocio y prevenir errores de usuario. 140 | - Las clases inmutables son especialmente útiles en programación concurrente (threads). 141 | - Aunque los records también son inmutables, una clase tradicional te permite aplicar validaciones en el constructor. 142 | 143 | --- 144 | ⬅️ [**Anterior**](../Ejemplo-03/Readme.md) | [**Siguiente**](../Reto-02/Readme.md)➡️ 145 | -------------------------------------------------------------------------------- /Sesion-04/Imagenes/S00.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-04/Imagenes/S00.jpg -------------------------------------------------------------------------------- /Sesion-04/Imagenes/S04.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-04/Imagenes/S04.jpg -------------------------------------------------------------------------------- /Sesion-04/Imagenes/S04_Fig01.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-04/Imagenes/S04_Fig01.png -------------------------------------------------------------------------------- /Sesion-04/Imagenes/S04_Fig02.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-04/Imagenes/S04_Fig02.png -------------------------------------------------------------------------------- /Sesion-04/Imagenes/S04_Fig03.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-04/Imagenes/S04_Fig03.png -------------------------------------------------------------------------------- /Sesion-04/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../Readme.md) ➡️ / 📖 `Sesión 04` 2 | 3 |
4 | Sesion_04 5 |
6 | 7 | ## 🎯 Objetivo 8 | 9 | ⚒️ Comprender los **elementos fundamentales de una clase en Java**, tales como los constructores, métodos especiales (`equals()`, `hashCode()`, `toString()`), el uso de `record` y `Objects.equals()`, así como los principios de **encapsulación** e **inmutabilidad**, para estructurar clases seguras, limpias y eficientes. 10 | 11 | --- 12 | 13 | 📘 Material del prework: 14 | 15 | Antes de comenzar con los ejercicios de esta sesión, recordemos que en el material de prework hemos cubierto los fundamentos teóricos que aplicaremos hoy. A lo largo de esta sesión, pondremos en práctica estos conceptos mediante una serie de ejercicios y retos diseñados para reforzar y validar nuestro entendimiento. 16 | 🔥¡Vamos a comenzar!🔥 17 | 18 | --- 19 | 20 | ## 📂 Temas de la sesión... 21 | 22 | 23 | ### 📖 Constructores e inicialización de objetos 24 | 25 | Los **constructores** permiten crear e inicializar objetos de forma segura y controlada. Existen diferentes tipos: 26 | 27 | - Constructor por defecto 28 | - Constructor con parámetros 29 | - Constructor de copia 30 | - Sobrecarga de constructores 31 | - Asignación de valores por defecto 32 | 33 | 🧠 Mejora la legibilidad, garantiza estados válidos y personaliza la creación de objetos. 34 | 35 | ##### 📜 **[Ejemplo 01: Constructores e inicialización de objetos](Ejemplo-01/Readme.md)** 36 | 37 | --- 38 | 39 | ### 📖 Métodos `equals()`, `hashCode()` y `toString()` 40 | 41 | Estos **métodos especiales** permiten comparar, identificar y representar objetos de forma efectiva: 42 | 43 | - `equals()` compara el contenido de objetos 44 | - `hashCode()` genera un valor hash único para estructuras como `HashSet` 45 | - `toString()` muestra una representación legible del objeto 46 | 47 | 🧠 Ayudan en la depuración, comparación y organización del código. 48 | 49 | 50 | ##### 📜 **[Ejemplo 02: Métodos equals(), hashCode() y toString()](Ejemplo-02/Readme.md)** 51 | ##### 🔥 **[Reto 01: Registro y comparación de facturas](Reto-01/Readme.md)** 52 | 53 | --- 54 | 55 | ### 📖 Uso de `record` y `Objects.equals()` 56 | 57 | Java introduce nuevas herramientas para simplificar el manejo de datos: 58 | 59 | - `record`: clases inmutables con menos código 60 | - `Objects.equals()`: comparación segura de objetos (maneja `null`) 61 | 62 | 🧠 Permiten crear estructuras de datos limpias, modernas y sin errores de `NullPointerException`. 63 | 64 | 65 | ##### 📜 **[Ejemplo 03: Uso de record y Objects.equals()](Ejemplo-03/Readme.md)** 66 | 67 | --- 68 | 69 | ### 📖 Principios de encapsulación e inmutabilidad 70 | 71 | **Encapsular** atributos protege los datos internos de una clase. La **inmutabilidad** evita que los valores cambien una vez asignados. 72 | 73 | - Uso de `private`, `getters` y `setters` 74 | - Validación de datos 75 | - Clases inmutables con atributos `final` y sin setters 76 | 77 | 🧠 Mejora la seguridad, mantenibilidad y evita errores. 78 | 79 | ##### 📜 **[Ejemplo 04: Principios de encapsulación e inmutabilidad](Ejemplo-04/Readme.md)** 80 | ##### 🔥 **[Reto 02: Comparación de declaraciones de impuestos](Reto-02/Readme.md)** 81 | 82 | --- 83 | 84 | ⬅️ [**Anterior**](../Readme.md) | [**Siguiente**](../Sesion-05/Readme.md)➡️ 85 | -------------------------------------------------------------------------------- /Sesion-04/Reto-01/Readme.md: -------------------------------------------------------------------------------- 1 | 2 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 04**](../Readme.md) ➡️ / ⚡`Reto 01: Registro y comparación de facturas` 3 | 4 | 5 | ## 🎯 Objetivo 6 | 7 | 💼 Modelar facturas emitidas para un sistema contable, reforzando el uso de **constructores**, `equals()`, `hashCode()` y `toString()`. 8 | 9 | --- 10 | 11 | ## 📝 Instrucciones 12 | 13 | 👤 Este reto se puede resolver de forma individual. 14 | 15 | 1. 📄 Crea una clase llamada `Factura`. 16 | 17 | 2. Declara los siguientes atributos: 18 | - `String folio` 19 | - `String cliente` 20 | - `double total` 21 | 22 | 3. Implementa lo siguiente: 23 | - Un constructor con parámetros para inicializar todos los atributos. 24 | - El método `toString()` para mostrar la información de la factura con este formato: 25 | 26 | ```plaintext 27 | 🧾 Factura [folio=..., cliente=..., total=$...] 28 | ``` 29 | - El método `equals()` para que dos facturas se consideren iguales si tienen el **mismo folio**. 30 | - El método `hashCode()` basado en el atributo `folio`. 31 | 32 | 4. 💻 En la clase `Main`: 33 | - Crea dos facturas con el mismo folio pero diferentes clientes o totales. 34 | - Muestra ambas con `toString()`. 35 | - Compara si son iguales con `equals()`. 36 | 37 | --- 38 | 39 | ### 📌 Ejemplo de ejecución 40 | 41 | ```plaintext 42 | 🧾 Factura [folio=FAC001, cliente=Juan Pérez, total=$1450.0] 43 | 🧾 Factura [folio=FAC001, cliente=Comercial XYZ, total=$1450.0] 44 | ¿Las facturas son iguales?: true 45 | ``` 46 | 47 | --- 48 | 49 | ## 💡 ¿Sabías que...? 50 | 51 | - En contabilidad, el **folio fiscal** es único por cada comprobante, por lo que debe usarse como identificador clave. 52 | - Este tipo de modelado se aplica en sistemas de facturación electrónica y contabilidad empresarial. 53 | 54 | --- 55 | 56 | 📊 ¡Una excelente forma de practicar lógica Java con aplicación real en el mundo financiero! 57 | 58 | ⬅️ [**Anterior**](../Ejemplo-02/Readme.md) | [**Siguiente**](../Ejemplo-03/Readme.md)➡️ 59 | -------------------------------------------------------------------------------- /Sesion-04/Reto-02/Readme.md: -------------------------------------------------------------------------------- 1 | 2 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 04**](../Readme.md) ➡️ / ⚡`Reto 02: Comparación de declaraciones de impuestos` 3 | 4 | ## 🎯 Objetivo 5 | 6 | 📄 Modelar una declaración de impuestos con `record` y validarla contra una cuenta fiscal usando encapsulación y comparación segura con `Objects.equals()`. 7 | 8 | --- 9 | 10 | ## 📝 Instrucciones 11 | 12 | 👤 Este reto se puede resolver de forma individual. 13 | 14 | 1. 📄 Crea un `record` llamado `DeclaracionImpuestos` con los siguientes campos: 15 | - `String rfcContribuyente` 16 | - `double montoDeclarado` 17 | 18 | 2. 💼 Crea una clase tradicional llamada `CuentaFiscal` con: 19 | - Un atributo privado `String rfc` (no modificable una vez asignado). 20 | - Un atributo privado `double saldoDisponible`. 21 | 22 | 3. Implementa lo siguiente en `CuentaFiscal`: 23 | - Constructor con validación para que el saldo no sea negativo. 24 | - Getters para ambos atributos. 25 | - Un método `validarRFC(DeclaracionImpuestos d)` que compare el RFC de la cuenta con el de la declaración, usando `Objects.equals()`. 26 | 27 | 4. 💻 En la clase `Main`: 28 | - Crea una declaración de impuestos. 29 | - Crea una cuenta fiscal. 30 | - Muestra la información de ambas. 31 | - Valida si el RFC coincide y muestra el resultado. 32 | 33 | --- 34 | 35 | ### 📌 Ejemplo de ejecución 36 | 37 | ```plaintext 38 | 📄 Declaración enviada por RFC: XAXX010101000 por $8700.0 39 | 🏦 Cuenta fiscal registrada con RFC: XAXX010101000, saldo disponible: $9500.0 40 | ✅ ¿RFC válido para esta cuenta?: true 41 | ``` 42 | 43 | --- 44 | 45 | ## 💡 ¿Sabías que...? 46 | 47 | - En sistemas fiscales, validar el RFC del contribuyente es crucial para evitar fraudes o errores. 48 | - `Objects.equals()` permite comparar campos sin lanzar errores si alguno es `null`. 49 | - Usar clases inmutables y encapsuladas mejora la seguridad de las aplicaciones que manejan datos fiscales. 50 | 51 | --- 52 | 53 | 🧾 ¡Una forma útil de aplicar tus conocimientos Java en el contexto de declaraciones fiscales! 54 | 55 | ⬅️ [**Anterior**](../Ejemplo-04/Readme.md) | [**Siguiente**](../../Sesion-05/Readme.md)➡️ 56 | -------------------------------------------------------------------------------- /Sesion-05/Ejemplo-01/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 05**](../Readme.md) ➡️ / 📝 `Ejemplo 01: Herencia en Java` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | 👨‍💻 Comprender cómo funciona la **herencia** en Java mediante la creación de una clase base y una subclase que hereda sus atributos y métodos. Exploraremos también el uso de `super` para acceder al constructor de la clase padre. 8 | 9 | --- 10 | 11 | ## 🧱 ¿Qué es la herencia? 12 | 13 | La **herencia** permite que una clase (subclase) herede las características (atributos y métodos) de otra clase (superclase). Esto promueve la reutilización de código y favorece una estructura más organizada. 14 | 15 | --- 16 | 17 | ## 🛠️ Ejemplo: sistema de notificaciones 18 | 19 | Imagina que estás desarrollando un sistema que envía diferentes tipos de notificaciones: correos electrónicos, mensajes SMS, y alertas en la app. Todos estos comparten una estructura común, pero tienen comportamientos muy específicos. 20 | 21 | --- 22 | 23 | ## 1️⃣ Clase base: `Notificacion` 24 | 25 | Creamos una clase base que contiene atributos y un método común: 26 | 27 | ```java 28 | public class Notificacion { 29 | String mensaje; 30 | 31 | public Notificacion(String mensaje) { 32 | this.mensaje = mensaje; 33 | } 34 | 35 | public void enviar() { 36 | System.out.println("📢 Enviando notificación: " + mensaje); 37 | } 38 | } 39 | ``` 40 | 41 | --- 42 | 43 | ## 2️⃣ Subclase: `NotificacionEmail` 44 | 45 | Ahora creamos una clase que **hereda** de `Notificacion` usando `extends` y sobrecargamos el comportamiento: 46 | 47 | ```java 48 | public class NotificacionEmail extends Notificacion { 49 | String destinatario; 50 | 51 | public NotificacionEmail(String mensaje, String destinatario) { 52 | super(mensaje); // Llamamos al constructor de la clase base 53 | this.destinatario = destinatario; 54 | } 55 | 56 | public void enviarEmail() { 57 | System.out.println("📧 Enviando email a " + destinatario + ": " + mensaje); 58 | } 59 | } 60 | ``` 61 | 62 | --- 63 | 64 | ## 3️⃣ Clase principal: `Sistema` 65 | 66 | Aquí probamos la herencia creando una instancia de `NotificacionEmail`: 67 | 68 | ```java 69 | public class Sistema { 70 | public static void main(String[] args) { 71 | NotificacionEmail email = new NotificacionEmail("Tu pedido ha sido enviado", "ana@correo.com"); 72 | 73 | // Llamamos a métodos heredados y propios 74 | email.enviar(); // Método heredado 75 | email.enviarEmail(); // Método propio 76 | } 77 | } 78 | ``` 79 | 80 | --- 81 | 82 | ## 📌 Observaciones clave 83 | 84 | - Usamos `extends` para establecer herencia. 85 | - Con `super()` llamamos al constructor de la clase base. 86 | - Podemos acceder a métodos y atributos de la clase base directamente desde la subclase. 87 | 88 | --- 89 | 90 | ## 💡 ¿Sabías que...? 91 | 92 | - Puedes tener múltiples niveles de herencia, aunque Java **no permite herencia múltiple directa** (una clase no puede extender de dos clases). 93 | - Las clases en Java extienden implícitamente de `Object` si no se indica lo contrario. 94 | - El modificador `protected` permite a las subclases acceder a miembros de la superclase desde otro paquete. 95 | 96 | --- 97 | 98 | 📘 Recurso adicional para repaso: 99 | 🔗 [Herencia en Java – W3Schools](https://www.w3schools.com/java/java_inheritance.asp) 100 | 101 | --- 102 | 103 | ⬅️ [**Anterior**](../Readme.md) | [**Siguiente**](../Ejemplo-02/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-05/Ejemplo-02/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 05**](../Readme.md) ➡️ / 📝 `Ejemplo 02: Herencia vs. Composición` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Diferenciar y aplicar los conceptos de **herencia** y **composición** en Java a través de un caso práctico, destacando cómo cada enfoque modela relaciones entre clases y cómo pueden combinarse para lograr sistemas más flexibles y reutilizables. 8 | 9 | --- 10 | 11 | ## 🛠️ Escenario: Vehículo autónomo 12 | 13 | Imagina que trabajas en una empresa de ingeniería que desarrolla vehículos autónomos. Este tipo de vehículo combina las propiedades básicas de un vehículo tradicional con sistemas inteligentes que le permiten conducir sin intervención humana. 14 | 15 | Para modelar este sistema, aplicaremos dos enfoques fundamentales de la programación orientada a objetos: 16 | 17 | ### ⚙️ Herencia: relación **“es un”** 18 | El vehículo autónomo **es un** tipo especial de vehículo, por lo que puede heredar sus atributos y comportamientos generales. Usamos `extends` para establecer esta relación. 19 | 20 | ### 🧩 Composición: relación **“tiene un”** 21 | El vehículo autónomo **tiene** componentes como un sensor GPS, una cámara, un sistema de inteligencia artificial, y un motor. Estos elementos no deberían heredarse, sino **componerse** como objetos internos. Así logramos un diseño más **modular, flexible y fácil de mantener**. 22 | 23 | --- 24 | 25 | ## 1️⃣ Clase base: `Vehiculo` (superclase) 26 | 27 | ```java 28 | public class Vehiculo { 29 | String marca; 30 | 31 | public Vehiculo(String marca) { 32 | this.marca = marca; 33 | } 34 | 35 | public void encender() { 36 | System.out.println("🔑 El vehículo " + marca + " está encendido."); 37 | } 38 | } 39 | ``` 40 | 41 | --- 42 | 43 | ## 2️⃣ Subclase: `AutoAutonomo` hereda de `Vehiculo` y usa composición 44 | 45 | ```java 46 | public class AutoAutonomo extends Vehiculo { 47 | SensorGPS gps; 48 | Camara camara; 49 | SistemaIA ia; 50 | Motor motor; 51 | 52 | public AutoAutonomo(String marca) { 53 | super(marca); 54 | this.gps = new SensorGPS(); 55 | this.camara = new Camara(); 56 | this.ia = new SistemaIA(); 57 | this.motor = new Motor(); 58 | } 59 | 60 | public void iniciarAutonomia() { 61 | System.out.println("🤖 Modo autónomo activado."); 62 | gps.localizar(); 63 | camara.detectarObstaculos(); 64 | ia.tomarDecision(); 65 | motor.arrancar(); 66 | } 67 | } 68 | ``` 69 | 70 | --- 71 | 72 | ## 3️⃣ Clases internas (composición) 73 | 74 | ```java 75 | public class SensorGPS { 76 | public void localizar() { 77 | System.out.println("📍 GPS: posición actual obtenida."); 78 | } 79 | } 80 | 81 | public class Camara { 82 | public void detectarObstaculos() { 83 | System.out.println("📷 Cámara: obstáculos detectados en el camino."); 84 | } 85 | } 86 | 87 | public class SistemaIA { 88 | public void tomarDecision() { 89 | System.out.println("🧠 IA: trayectoria calculada."); 90 | } 91 | } 92 | 93 | public class Motor { 94 | public void arrancar() { 95 | System.out.println("🚗 Motor: velocidad regulada y marcha iniciada."); 96 | } 97 | } 98 | ``` 99 | 100 | --- 101 | 102 | ## 4️⃣ Clase principal: `Simulador` 103 | 104 | ```java 105 | public class Simulador { 106 | public static void main(String[] args) { 107 | AutoAutonomo tesla = new AutoAutonomo("Tesla"); 108 | 109 | tesla.encender(); // Método heredado de Vehiculo 110 | tesla.iniciarAutonomia(); // Método propio con composición 111 | } 112 | } 113 | ``` 114 | 115 | --- 116 | 117 | ## 🤔 Reflexión: ¿cuándo usar herencia y cuándo composición? 118 | 119 | | Característica | Herencia (`extends`) | Composición (`tiene un`) | 120 | |----------------------------------|----------------------------------|----------------------------------| 121 | | Relación semántica | "es un tipo de..." | "tiene un..." | 122 | | Flexibilidad | Menor (más rígida) | Mayor (modular, reemplazable) | 123 | | Acoplamiento | Alto (hereda todo) | Bajo (solo usa lo necesario) | 124 | | Cambios en clase base afectan...| Todas las subclases | Solo si se usan directamente | 125 | 126 | --- 127 | 128 | ## 💡 Buenas prácticas 129 | 130 | - ✅ Usa **herencia** solo cuando la relación sea inequívoca y natural (ej. `Un Gato es un Animal`). 131 | - ✅ Usa **composición** cuando una clase deba tener funcionalidades modulares y puedas reutilizarlas en diferentes contextos (ej. `Un Auto tiene un Motor`). 132 | - ✅ **Prefiere composición sobre herencia** en diseño moderno orientado a objetos, por su bajo acoplamiento y mejor mantenibilidad. 133 | 134 | --- 135 | 136 | 📘 Recurso recomendado: 137 | 🔗 [Preferir Composición sobre Herencia – Clean Code](https://dev.to/rlgino/composicion-vs-herencia-4664) 138 | 139 | --- 140 | 141 | ⬅️ [**Anterior**](../Ejemplo-01/Readme.md) | [**Siguiente**](../Reto-01/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-05/Ejemplo-03/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 05**](../Readme.md) ➡️ / 📝 `Ejemplo 03: Interfaces y Clases Abstractas` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Comprender la diferencia entre una **interfaz** y una **clase abstracta** en Java, aplicando ambos conceptos para estructurar el comportamiento de objetos con jerarquías complejas y funciones específicas. 8 | 9 | --- 10 | 11 | ## 🛠️ Escenario: Sistema de drones multifuncionales 12 | 13 | Estás desarrollando un sistema para gestionar **drones autónomos**. Todos los drones comparten una estructura básica: tienen un identificador, deben despegar y aterrizar, y pueden realizar tareas específicas como vigilancia, entrega de paquetes o mapeo de terreno. 14 | 15 | 🔍 Para modelar este comportamiento, usaremos: 16 | 17 | - Una **clase abstracta** `Drone`, que define la estructura y comportamientos comunes (atributos, métodos concretos y abstractos). 18 | - Una **interfaz** `Vigilancia`, que define un comportamiento especializado opcional que ciertos drones pueden implementar. 19 | - Otra **interfaz** `Entrega`, para drones de paquetería. 20 | 21 | Este diseño nos permite usar **herencia simple con clase abstracta** y **herencia múltiple con interfaces** al mismo tiempo. 22 | 23 | --- 24 | 25 | ## 1️⃣ Clase abstracta: `Drone` 26 | 27 | ```java 28 | public abstract class Drone { 29 | String id; 30 | 31 | public Drone(String id) { 32 | this.id = id; 33 | } 34 | 35 | public void despegar() { 36 | System.out.println("🚁 Drone " + id + " despegando..."); 37 | } 38 | 39 | public void aterrizar() { 40 | System.out.println("🛬 Drone " + id + " aterrizando..."); 41 | } 42 | 43 | // Método abstracto que cada tipo de drone debe implementar 44 | public abstract void ejecutarMision(); 45 | } 46 | ``` 47 | 48 | --- 49 | 50 | ## 2️⃣ Interfaces: `Vigilancia` y `Entrega` 51 | 52 | ```java 53 | public interface Vigilancia { 54 | void escanearArea(); 55 | } 56 | ``` 57 | 58 | ```java 59 | public interface Entrega { 60 | void entregarPaquete(String destino); 61 | } 62 | ``` 63 | 64 | --- 65 | 66 | ## 3️⃣ Clases concretas que implementan los comportamientos 67 | 68 | ### 🛰️ `DroneVigilancia` 69 | 70 | ```java 71 | public class DroneVigilancia extends Drone implements Vigilancia { 72 | 73 | public DroneVigilancia(String id) { 74 | super(id); 75 | } 76 | 77 | @Override 78 | public void ejecutarMision() { 79 | System.out.println("🔍 Drone " + id + " iniciando misión de vigilancia."); 80 | escanearArea(); 81 | } 82 | 83 | @Override 84 | public void escanearArea() { 85 | System.out.println("📷 Escaneando área en 360°..."); 86 | } 87 | } 88 | ``` 89 | 90 | ### 📦 `DroneReparto` 91 | 92 | ```java 93 | public class DroneReparto extends Drone implements Entrega { 94 | 95 | public DroneReparto(String id) { 96 | super(id); 97 | } 98 | 99 | @Override 100 | public void ejecutarMision() { 101 | System.out.println("📦 Drone " + id + " iniciando misión de entrega."); 102 | entregarPaquete("Zona 5B"); 103 | } 104 | 105 | @Override 106 | public void entregarPaquete(String destino) { 107 | System.out.println("📍 Entregando paquete en: " + destino); 108 | } 109 | } 110 | ``` 111 | 112 | --- 113 | 114 | ## 4️⃣ Clase principal: `CentroControl` 115 | 116 | ```java 117 | public class CentroControl { 118 | public static void main(String[] args) { 119 | Drone drone1 = new DroneVigilancia("DR-001"); 120 | Drone drone2 = new DroneReparto("DR-002"); 121 | 122 | drone1.despegar(); 123 | drone1.ejecutarMision(); 124 | drone1.aterrizar(); 125 | 126 | System.out.println(); 127 | 128 | drone2.despegar(); 129 | drone2.ejecutarMision(); 130 | drone2.aterrizar(); 131 | } 132 | } 133 | ``` 134 | 135 | --- 136 | 137 | ## 🤔 ¿Cuándo usar una interfaz y cuándo una clase abstracta? 138 | 139 | | Característica | Clase abstracta | Interfaz | 140 | |-------------------------------------|--------------------------|-----------------------------| 141 | | Define atributos comunes | ✅ Sí | ❌ No | 142 | | Tiene métodos implementados | ✅ Sí | ✅ Desde Java 8 (`default`) | 143 | | Permite herencia múltiple | ❌ No | ✅ Sí | 144 | | Se usa para... | Estructura base común | Contratos de comportamiento | 145 | 146 | --- 147 | 148 | ## 💡 Buenas prácticas 149 | 150 | - ✅ Usa **clases abstractas** para compartir estructura y comportamiento general. 151 | - ✅ Usa **interfaces** cuando diferentes clases deban compartir capacidades específicas pero no estructura. 152 | - ✅ Una clase puede heredar de una clase abstracta **y** implementar múltiples interfaces sin problema. 153 | 154 | --- 155 | 156 | 📘 Recursos adicionales: 157 | 158 | 🔗 [Interfaces – W3Schools](https://www.w3schools.com/java/java_interface.asp) 159 | 🔗 [Abstract Classes – Oracle Docs](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) 160 | 161 | --- 162 | 163 | ⬅️ [**Anterior**](../Ejemplo-02/Readme.md) | [**Siguiente**](../Ejemplo-04/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-05/Ejemplo-04/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 05**](../Readme.md) ➡️ / 📝 `Ejemplo 04: Polimorfismo y uso de @Override` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Comprender el concepto de **polimorfismo** en Java, observando cómo diferentes clases pueden redefinir el mismo método de forma personalizada. También se destaca el uso de la anotación `@Override` para asegurar que la sobrescritura sea válida y clara. 8 | 9 | --- 10 | 11 | ## 🛠️ Escenario: Animales robóticos 12 | 13 | Imagina que estás desarrollando un software para controlar **animales robóticos**. Todos ellos deben responder a una orden común llamada `hacerSonido()`, pero el resultado debe variar según el tipo de robot. 14 | 15 | Para esto: 16 | 17 | - Usamos una **clase base** `AnimalRobot` con un método `hacerSonido()`. 18 | - Creamos subclases como `PerroRobot`, `GatoRobot` y `PajaroRobot` que **sobrescriben** ese método con su propia implementación. 19 | - Usamos el **polimorfismo** para invocar el mismo método sin importar el tipo de objeto. 20 | 21 | --- 22 | 23 | ## 1️⃣ Clase base: `AnimalRobot` 24 | 25 | ```java 26 | public class AnimalRobot { 27 | public void hacerSonido() { 28 | System.out.println("🔊 Sonido genérico de robot animal..."); 29 | } 30 | } 31 | ``` 32 | 33 | --- 34 | 35 | ## 2️⃣ Subclases con sobrescritura de método 36 | 37 | ### 🐶 `PerroRobot` 38 | 39 | ```java 40 | public class PerroRobot extends AnimalRobot { 41 | @Override 42 | public void hacerSonido() { 43 | System.out.println("🐶 PerroRobot: Guau Guau Digital"); 44 | } 45 | } 46 | ``` 47 | 48 | ### 🐱 `GatoRobot` 49 | 50 | ```java 51 | public class GatoRobot extends AnimalRobot { 52 | @Override 53 | public void hacerSonido() { 54 | System.out.println("🐱 GatoRobot: Miau Miau Mecánico"); 55 | } 56 | } 57 | ``` 58 | 59 | ### 🐦 `PajaroRobot` 60 | 61 | ```java 62 | public class PajaroRobot extends AnimalRobot { 63 | @Override 64 | public void hacerSonido() { 65 | System.out.println("🐦 PajaroRobot: Pío Pío Cibernético"); 66 | } 67 | } 68 | ``` 69 | 70 | --- 71 | 72 | ## 3️⃣ Clase principal: `CentroControl` 73 | 74 | ```java 75 | public class CentroControl { 76 | public static void main(String[] args) { 77 | AnimalRobot[] zoologico = { 78 | new PerroRobot(), 79 | new GatoRobot(), 80 | new PajaroRobot() 81 | }; 82 | 83 | for (AnimalRobot robot : zoologico) { 84 | robot.hacerSonido(); // Polimorfismo en acción 85 | } 86 | } 87 | } 88 | ``` 89 | 90 | --- 91 | 92 | ## 🤖 ¿Qué es el polimorfismo? 93 | 94 | Es la capacidad que tiene una **referencia de tipo padre** de ejecutar métodos definidos en una **clase hija sobrescrita**, permitiendo escribir código más **genérico y reutilizable**. 95 | 96 | ### 🔍 ¿Y `@Override`? 97 | 98 | La anotación `@Override`: 99 | 100 | - Garantiza que estamos **realmente sobrescribiendo** un método de la superclase. 101 | - Lanza error si escribimos mal el nombre del método o su firma. 102 | - Mejora la legibilidad del código para otros desarrolladores. 103 | 104 | --- 105 | 106 | ## 💡 Buenas prácticas 107 | 108 | - ✅ Siempre usa `@Override` al sobrescribir métodos. 109 | - ✅ Usa referencias del tipo base (`AnimalRobot`) cuando quieras aplicar polimorfismo. 110 | - ✅ Aprovecha la sobrescritura para adaptar el comportamiento sin duplicar código. 111 | 112 | --- 113 | 114 | 📘 Recurso recomendado: 115 | 🔗 [Polimorfismo – W3Schools](https://www.w3schools.com/java/java_polymorphism.asp) 116 | 117 | --- 118 | 119 | ⬅️ [**Anterior**](../Ejemplo-03/Readme.md) | [**Siguiente**](../Reto-02/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-05/Imagenes/S00.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-05/Imagenes/S00.jpg -------------------------------------------------------------------------------- /Sesion-05/Imagenes/S05.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-05/Imagenes/S05.jpg -------------------------------------------------------------------------------- /Sesion-05/Imagenes/S05_Fig1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-05/Imagenes/S05_Fig1.png -------------------------------------------------------------------------------- /Sesion-05/Imagenes/S05_Fig2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-05/Imagenes/S05_Fig2.png -------------------------------------------------------------------------------- /Sesion-05/Imagenes/S05_Fig3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-05/Imagenes/S05_Fig3.png -------------------------------------------------------------------------------- /Sesion-05/Imagenes/S05_Fig4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-05/Imagenes/S05_Fig4.png -------------------------------------------------------------------------------- /Sesion-05/Imagenes/S05_Fig5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-05/Imagenes/S05_Fig5.png -------------------------------------------------------------------------------- /Sesion-05/Imagenes/S05_Fig6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-05/Imagenes/S05_Fig6.png -------------------------------------------------------------------------------- /Sesion-05/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../Readme.md) ➡️ / 📖 `Sesión 05` 2 | 3 |
4 | Sesion_05 5 |
6 | 7 | ## 🎯 Objetivo 8 | 9 | ⚒️ Explorar los conceptos fundamentales de la programación orientada a objetos en Java: **herencia, composición, interfaces, clases abstractas y polimorfismo**, para escribir código más limpio, reutilizable y flexible. 10 | 11 | --- 12 | 13 | 📘 Material del prework: 14 | 15 | Antes de comenzar con los ejercicios de esta sesión, recordemos que en el material de prework hemos cubierto los fundamentos teóricos que aplicaremos hoy. A lo largo de esta sesión, pondremos en práctica estos conceptos mediante una serie de ejercicios y retos diseñados para reforzar y validar nuestro entendimiento. 16 | 🔥¡Vamos a comenzar!🔥 17 | 18 | --- 19 | 20 | ## 📂 Temas de la sesión... 21 | 22 | 23 | ### 📖 Herencia en Java 24 | 25 | La **herencia** permite que una clase (subclase) herede atributos y métodos de otra (superclase), promoviendo la reutilización de código. 26 | 27 | - Uso de `extends` y `super` 28 | - Herencia simple vs. herencia múltiple 29 | 30 | ##### 📜 **[Ejemplo 01: Herencia en Java](Ejemplo-01/Readme.md)** 31 | --- 32 | 33 | ### 📖 Herencia vs. composición 34 | 35 | La **composición** permite que una clase contenga instancias de otras clases, favoreciendo un diseño más flexible y modular. 36 | 37 | - Cuándo usar herencia (`is-a`) vs. composición (`has-a`) 38 | - Ventajas de la composición 39 | - Buenas prácticas modernas 40 | 41 | ##### 📜 **[Ejemplo 02: Herencia vs. composición](Ejemplo-02/Readme.md)** 42 | ##### 🔥 **[Reto 01: Sistema de emergencia](Reto-01/Readme.md)** 43 | 44 | --- 45 | 46 | ### 📖 Interfaces y clases abstractas 47 | 48 | Las **interfaces** definen contratos de comportamiento, mientras que las **clases abstractas** establecen una estructura base común. 49 | 50 | - Diferencias y casos de uso 51 | - Métodos abstractos y `default` 52 | - Herencia múltiple mediante interfaces 53 | 54 | ##### 📜 **[Ejemplo 03: Interfaces y clases abstractas](Ejemplo-03/Readme.md)** 55 | 56 | --- 57 | 58 | ### 📖 Polimorfismo y uso de `@Override` 59 | 60 | El **polimorfismo** permite que múltiples clases respondan de forma distinta al mismo método. `@Override` garantiza una sobrescritura correcta. 61 | 62 | - Tipos de polimorfismo en Java 63 | - Sobrescritura de métodos (`method overriding`) 64 | - Uso de `@Override` para mayor claridad 65 | 66 | 67 | ##### 📜 **[Ejemplo 04: Polimorfismo y uso de @Override](Ejemplo-04/Readme.md)** 68 | ##### 🔥 **[Reto 02: Sistema de pago con múltiples métodos](Reto-02/Readme.md)** 69 | 70 | --- 71 | 72 | 73 | ⬅️ [**Anterior**](../Sesion-04/Readme.md) | [**Siguiente**](../Sesion-06/Readme.md)➡️ 74 | -------------------------------------------------------------------------------- /Sesion-05/Reto-01/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 05**](../Readme.md) ➡️ / ⚡`Reto 01: Sistema de emergencia` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Construir un sistema que modele diferentes tipos de **unidades de emergencia**, aplicando los principios de **herencia** y **composición** en Java. Reforzarás el uso de `extends`, `super`, y el diseño modular usando clases auxiliares. 8 | 9 | --- 10 | 11 | ## 🛠️ Escenario 12 | 13 | Estás diseñando un sistema que permite registrar y activar diferentes **unidades de respuesta a emergencias**, como ambulancias, patrullas y camiones de bomberos. Aunque todas comparten ciertas funciones (como responder a una emergencia), cada una puede tener un comportamiento específico. 14 | 15 | Además, todas las unidades están equipadas con tecnología como **sistemas GPS**, **sirenas**, y son operadas por personal capacitado. Estos componentes serán modelados mediante composición. 16 | 17 | --- 18 | 19 | ## 📝 Instrucciones 20 | 21 | 1. 🧱 Crea una clase abstracta `UnidadEmergencia` con: 22 | - Un atributo `nombre` (String) 23 | - Un método `responder()` → abstracto 24 | - Un método concreto `activarUnidad()` que imprima un mensaje de activación 25 | 26 | 2. 🚑 Crea las subclases: 27 | - `Ambulancia` 28 | - `Patrulla` 29 | - `UnidadBomberos` 30 | 31 | Cada clase debe: 32 | - Extender `UnidadEmergencia` 33 | - Sobrescribir el método `responder()` con un mensaje propio 34 | 35 | 3. 🧩 Crea las clases auxiliares para composición: 36 | - `SistemaGPS` → método `localizar()` 37 | - `Sirena` → método `activarSirena()` 38 | - `Operador` → atributo `nombre`, método `reportarse()` 39 | 40 | 4. 🔁 En cada subclase (`Ambulancia`, `Patrulla`, `UnidadBomberos`), **agrega los componentes por composición** y un método llamado `iniciarOperacion()` que invoque: 41 | - `activarUnidad()` (heredado) 42 | - `localizar()` 43 | - `activarSirena()` 44 | - `reportarse()` 45 | - `responder()` (implementación propia) 46 | 47 | 5. 🧪 En la clase `CentralEmergencias` (main): 48 | - Crea una instancia de cada tipo de unidad 49 | - Llama al método `iniciarOperacion()` en cada una 50 | 51 | --- 52 | 53 | ## 🧩 Salida esperada 54 | 55 | ```plaintext 56 | 🚨 Activando unidad: Ambulancia 57 | 📍 GPS: Ubicación actual detectada. 58 | 🔊 Sirena: Activada. 59 | 👷 Operador Juan reportándose. 60 | 🩺 Ambulancia en camino al hospital más cercano. 61 | 62 | 🚨 Activando unidad: Patrulla 63 | 📍 GPS: Ubicación actual detectada. 64 | 🔊 Sirena: Activada. 65 | 👮 Operador Laura reportándose. 66 | 🚓 Patrulla atendiendo situación de seguridad ciudadana. 67 | 68 | 🚨 Activando unidad: UnidadBomberos 69 | 📍 GPS: Ubicación actual detectada. 70 | 🔊 Sirena: Activada. 71 | 👨‍🚒 Operador Marco reportándose. 72 | 🔥 Unidad de bomberos respondiendo a incendio estructural. 73 | ``` 74 | 75 | --- 76 | 77 | ## ✅ Conceptos que reforzarás 78 | 79 | - 🔁 Herencia simple (`extends`) y uso de `super` 80 | - 🧩 Composición para estructuras internas (`has-a`) 81 | - 🧠 Uso de clases abstractas y métodos sobrescritos 82 | - 💡 Organización modular y separación de responsabilidades 83 | 84 | --- 85 | 86 | 🏆 ¡Mucho éxito y que comience la misión de rescate! 87 | 88 | --- 89 | 90 | ⬅️ [**Anterior**](../Ejemplo-02/Readme.md) | [**Siguiente**](../Ejemplo-03/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-05/Reto-02/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 05**](../Readme.md) ➡️ / ⚡`Reto 02: Sistema de pago con múltiples métodos` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Diseñar un sistema de pagos en el que distintos métodos de pago (efectivo, tarjeta, transferencia) compartan una estructura común pero tengan comportamientos específicos. Aplicarás el uso de **interfaces**, **clases abstractas**, y **polimorfismo** para modelar un flujo flexible y extensible. 8 | 9 | --- 10 | 11 | ## 🛠️ Escenario 12 | 13 | Estás construyendo un módulo para una tienda en línea. El sistema debe permitir **procesar pagos** mediante diferentes medios: efectivo, tarjeta bancaria o transferencia. 14 | 15 | Cada tipo de pago debe implementar su lógica de validación y confirmación, pero todos siguen un contrato general. Además, se debe permitir que en el futuro puedan agregarse nuevos métodos sin modificar los ya existentes (principio de extensión). 16 | 17 | --- 18 | 19 | ## 📝 Instrucciones 20 | 21 | 1. 🔧 Crea una **interfaz** `Autenticable` con: 22 | - Método `boolean autenticar()` 23 | 24 | 2. 🧱 Crea una **clase abstracta** `MetodoPago` con: 25 | - Atributo `monto` (double) 26 | - Método abstracto `procesarPago()` 27 | - Método concreto `mostrarResumen()` que imprima el tipo de pago y el monto 28 | 29 | 3. 💳 Crea las clases concretas que **extiendan `MetodoPago`** y **implementen `Autenticable`**: 30 | - `PagoEfectivo` → `autenticar()` siempre retorna `true` (no requiere validación) 31 | - `PagoTarjeta` → valida si hay fondos suficientes 32 | - `PagoTransferencia` → simula una validación bancaria externa 33 | 34 | 4. 🧠 Cada clase debe sobrescribir `procesarPago()` y `autenticar()` usando `@Override` 35 | 36 | 5. 🧪 En la clase `CajaRegistradora`: 37 | - Crea un arreglo de tipo `MetodoPago` con instancias mezcladas (polimorfismo) 38 | - Recorre el arreglo, llama a `autenticar()` y si es válido, llama a `procesarPago()` y `mostrarResumen()` 39 | 40 | --- 41 | 42 | ## 🧩 Salida esperada 43 | 44 | ```plaintext 45 | ✅ Autenticación exitosa. 46 | 💵 Procesando pago en efectivo por $150.0 47 | 📄 Tipo: PagoEfectivo - Monto: $150.0 48 | 49 | ✅ Autenticación exitosa. 50 | 💳 Procesando pago con tarjeta por $320.0 51 | 📄 Tipo: PagoTarjeta - Monto: $320.0 52 | 53 | ❌ Fallo de autenticación. Transferencia no válida. 54 | ``` 55 | 56 | --- 57 | 58 | ## ✅ Conceptos aplicados 59 | 60 | - `interface` → Contrato común (`Autenticable`) 61 | - `abstract class` → Base común (`MetodoPago`) 62 | - `@Override` → Reescritura de métodos con validación 63 | - Polimorfismo → Uso genérico de referencias para métodos variados 64 | 65 | --- 66 | 67 | 🏆 ¡Vamos! Conviértete en el arquitecto de tu propio sistema de pagos. 68 | 69 | --- 70 | 71 | ⬅️ [**Anterior**](../Ejemplo-04/Readme.md) | [**Siguiente**](../Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-06/Ejemplo-01/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 06**](../Readme.md) ➡️ / 📝 `Ejemplo 01: Introducción a las colecciones` 2 | 3 | ## 🎯 Objetivo 4 | 5 | Aplicar los conceptos de `List`, `Set` y `Map` en un escenario práctico de control de materiales, identificando cuándo es útil cada tipo de colección en entornos reales de ingeniería industrial. 6 | 7 | --- 8 | 9 | ## 🏭 Ejemplo: Gestión de materiales en línea de producción 10 | 11 | Imagina que trabajas como **industrial engineer** en una planta de manufactura, y necesitas desarrollar una herramienta en Java que te ayude a: 12 | 13 | - Registrar el **orden de llegada** de materiales. 14 | - Validar que no haya **lotes duplicados**. 15 | - Asociar **códigos de pieza con su descripción**. 16 | 17 | Para esto, usaremos colecciones como `List`, `Set` y `Map`, cada una resolviendo un problema distinto de manera eficiente. 18 | 19 | 20 | ## 🧾 Escenario 21 | 22 | El sistema debe cumplir con los siguientes puntos: 23 | 24 | - Guardar los nombres de materiales conforme van llegando. 25 | - Asegurar que cada lote registrado sea **único**. 26 | - Permitir búsquedas rápidas de piezas mediante su **código**. 27 | 28 | --- 29 | 30 | ## 💻 Código en Java 31 | 32 | ```java 33 | import java.util.*; 34 | 35 | public class GestionMateriales { 36 | public static void main(String[] args) { 37 | 38 | // 📦 List: Registrar orden de llegada de materiales 39 | List materialesRecibidos = new ArrayList<>(); 40 | materialesRecibidos.add("Tornillo M6"); 41 | materialesRecibidos.add("Arandela 8mm"); 42 | materialesRecibidos.add("Tornillo M6"); // Llega repetido 43 | materialesRecibidos.add("Tuerca M6"); 44 | 45 | System.out.println("📋 Orden de llegada de materiales:"); 46 | for (String material : materialesRecibidos) { 47 | System.out.println("- " + material); 48 | } 49 | 50 | // 🧪 Set: Validar lotes únicos (sin duplicados) 51 | Set lotesUnicos = new HashSet<>(); 52 | lotesUnicos.add("Lote-001"); 53 | lotesUnicos.add("Lote-002"); 54 | lotesUnicos.add("Lote-001"); // Duplicado que será ignorado 55 | 56 | System.out.println("\n✅ Lotes registrados (sin duplicados):"); 57 | for (String lote : lotesUnicos) { 58 | System.out.println("- " + lote); 59 | } 60 | 61 | // 🗃️ Map: Código de pieza asociado a descripción 62 | Map catalogoPiezas = new HashMap<>(); 63 | catalogoPiezas.put("PZ-1001", "Tornillo M6 x 20mm"); 64 | catalogoPiezas.put("PZ-1002", "Tuerca M6"); 65 | catalogoPiezas.put("PZ-1003", "Arandela 8mm"); 66 | 67 | System.out.println("\n📇 Catálogo de piezas (Código -> Descripción):"); 68 | for (Map.Entry entrada : catalogoPiezas.entrySet()) { 69 | System.out.println(entrada.getKey() + " → " + entrada.getValue()); 70 | } 71 | 72 | // 🔎 Buscar descripción a partir del código 73 | String codigoBuscado = "PZ-1002"; 74 | System.out.println("\n🔍 Descripción de la pieza " + codigoBuscado + ": " + catalogoPiezas.get(codigoBuscado)); 75 | } 76 | } 77 | ``` 78 | 79 | --- 80 | 81 | ## 🧩 ¿Qué es `import java.util.*;`? 82 | 83 | En Java, la instrucción `import` le dice al compilador qué clases o paquetes quieres **usar en tu programa**. 84 | 85 | El paquete `java.util` contiene muchas clases **útiles para trabajar con estructuras de datos**, como: 86 | 87 | - `ArrayList` → Listas dinámicas. 88 | - `HashSet` → Conjuntos sin duplicados. 89 | - `HashMap` → Asociaciones clave-valor. 90 | 91 | También incluye otras herramientas como `Date`, `Collections`, `Scanner`, etc. 92 | 93 | Cuando escribes: 94 | 95 | ```java 96 | import java.util.*; 97 | ``` 98 | 99 | Estás diciendo: 100 | 101 | 👉 *“Quiero importar todas las clases del paquete java.util.”* 102 | 103 | Esto te permite usarlas directamente, sin tener que escribir la ruta completa cada vez 🤓. 104 | 105 | --- 106 | 107 | ## 🤔 y aqui no necesito `main`? 108 | 109 | ✅ Sí, sí necesitas el método `main`, ¡y de hecho ya está incluido en el código! 110 | 111 | En Java, el punto de entrada para que un programa se ejecute es este bloque: 112 | 113 | ```java 114 | public static void main(String[] args) { 115 | // Aquí va el código que se ejecuta 116 | } 117 | ``` 118 | **¿Recuerdas qué hace cada parte?** 119 | 120 | - `public`: permite que el método sea accesible desde fuera de la clase (el sistema lo necesita así). 121 | - `static`: significa que no necesitas crear una instancia (objeto) de la clase para ejecutar este método. 122 | - `void`: indica que el método no devuelve ningún valor. 123 | - `main`: es el nombre obligatorio para que Java lo reconozca como punto de inicio. 124 | - `String[] args`: es un parámetro que permite recibir argumentos desde la línea de comandos (aunque no lo usamos aquí, es obligatorio ponerlo). 125 | 126 | 🔍En resumen: 127 | **sin `main`, el programa no corre**, a menos que estés trabajando con pruebas unitarias (`JUnit`) o frameworks especiales. 128 | 129 | Y como puedes ver en tu código: 130 | 131 | ```java 132 | public class GestionMateriales { 133 | public static void main(String[] args) { 134 | // tu código aquí... 135 | } 136 | } 137 | ``` 138 | --- 139 | 140 | 141 | 142 | ⬅️ [**Anterior**](../Prework/Readme.md) | [**Siguiente**](../Ejemplo-02/Readme.md) ➡️ -------------------------------------------------------------------------------- /Sesion-06/Ejemplo-02/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 06**](../Readme.md) ➡️ / 📝 `Ejemplo 02: Diferencias entre ArrayList, HashSet y HashMap` 2 | 3 | ## 🎯 Objetivo 4 | 5 | Comprender las diferencias prácticas entre `ArrayList`, `HashSet` y `HashMap` al manipular datos en un entorno de control de calidad o inventarios industriales. 6 | 7 | --- 8 | 9 | ## 🏭 Ejemplo 10 | 11 | Imagina que trabajas como **ingeniero industrial** en una planta de manufactura y estás desarrollando un sistema que te ayude a: 12 | 13 | - Registrar el orden de llegada de reportes de materiales defectuosos. 14 | - Identificar los tipos únicos de defectos que han ocurrido. 15 | - Relacionar cada ID de lote con su causa principal de rechazo. 16 | 17 | Este ejemplo te permitirá ver las **diferencias clave entre estas tres estructuras** y cuándo usar cada una de manera efectiva. 18 | 19 | 20 | ## 🧾 Escenario 21 | 22 | Necesitamos: 23 | 24 | - Guardar los reportes en el **orden en que llegan**, incluso si están repetidos. 25 | - Registrar solo los **tipos únicos de defecto**. 26 | - Asociar el **ID del lote con la causa del defecto**. 27 | 28 | --- 29 | 30 | ## 💻 Código en Java 31 | 32 | ```java 33 | import java.util.*; 34 | 35 | public class ControlDefectos { 36 | public static void main(String[] args) { 37 | 38 | // 📝 ArrayList: registrar reportes de defectos (puede haber repetidos) 39 | ArrayList reportes = new ArrayList<>(); 40 | reportes.add("Falla en rosca"); 41 | reportes.add("Golpe en superficie"); 42 | reportes.add("Falla en rosca"); // Repetido 43 | reportes.add("Pintura irregular"); 44 | 45 | System.out.println("🗂️ Reportes de defectos (ordenados, con duplicados):"); 46 | for (int i = 0; i < reportes.size(); i++) { 47 | System.out.println(i + 1 + ". " + reportes.get(i)); 48 | } 49 | 50 | // ✅ HashSet: registrar defectos únicos 51 | HashSet tiposDefecto = new HashSet<>(reportes); // Elimina duplicados 52 | 53 | System.out.println("\n✅ Tipos únicos de defecto encontrados:"); 54 | for (String defecto : tiposDefecto) { 55 | System.out.println("- " + defecto); 56 | } 57 | 58 | // 🗃️ HashMap: asociar ID de lote con la causa del rechazo 59 | HashMap lotesRechazados = new HashMap<>(); 60 | lotesRechazados.put("L-001", "Falla en rosca"); 61 | lotesRechazados.put("L-002", "Golpe en superficie"); 62 | lotesRechazados.put("L-003", "Pintura irregular"); 63 | 64 | System.out.println("\n📇 Lotes rechazados (ID → Causa):"); 65 | for (Map.Entry entry : lotesRechazados.entrySet()) { 66 | System.out.println(entry.getKey() + " → " + entry.getValue()); 67 | } 68 | 69 | // 🔍 Buscar causa de rechazo por ID 70 | String idBuscar = "L-002"; 71 | System.out.println("\n🔍 Causa del rechazo para " + idBuscar + ": " + lotesRechazados.get(idBuscar)); 72 | } 73 | } 74 | ``` 75 | 76 | --- 77 | 78 | ## 🧠 ¿Qué conceptos se aplican aquí? 79 | 80 | | Estructura | Permite duplicados | Mantiene orden | Clave-valor | Ejemplo aplicado | 81 | |-------------|--------------------|----------------|-------------|----------------------------------------------| 82 | | `ArrayList` | ✅ Sí | ✅ Sí | ❌ No | Registro cronológico de defectos | 83 | | `HashSet` | ❌ No | ❌ No | ❌ No | Registro de tipos únicos de defecto | 84 | | `HashMap` | ✅ (en valores) | ❌ No | ✅ Sí | Relación entre ID de lote y causa del defecto | 85 | 86 | --- 87 | 88 | ## 💡 ¿Sabías que...? 89 | 90 | - `ArrayList` es útil cuando necesitas mantener el orden y tener acceso rápido por índice. 91 | - `HashSet` es ideal cuando quieres eliminar duplicados automáticamente. 92 | - `HashMap` permite búsquedas rápidas por clave, ideal para manejar relaciones uno a uno (como ID → dato). 93 | - Puedes convertir fácilmente un `ArrayList` en un `HashSet` si quieres eliminar duplicados. 94 | 95 | --- 96 | 97 | ⬅️ [**Anterior**](../Ejemplo-01/Readme.md) | [**Siguiente**](../Reto-01/Readme.md) ➡️ -------------------------------------------------------------------------------- /Sesion-06/Ejemplo-03/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 06**](../Readme.md) ➡️ / 📝 `Ejemplo 03: Ordenamiento con Comparator y Comparable` 2 | 3 | ## 🎯 Objetivo 4 | 5 | Aplicar las interfaces `Comparable` y `Comparator` para ordenar una colección de objetos en Java, usando criterios como nombre y prioridad en un entorno profesional. 6 | 7 | --- 8 | 9 | ## 🏭 Ejemplo 10 | 11 | Imagina que eres ingeniero industrial y estás desarrollando una aplicación para gestionar **órdenes de producción** en planta. 12 | Cada orden contiene: 13 | 14 | - Un código de orden 15 | - El nombre del producto 16 | - La prioridad de la orden (donde 1 = alta, 2 = media, 3 = baja) 17 | 18 | Necesitas: 19 | 20 | - Ordenar alfabéticamente por nombre del producto (orden natural). 21 | - Ordenar por prioridad, de forma personalizada. 22 | 23 | ## 🧾 Escenario 24 | 25 | La clase `OrdenProduccion` implementa `Comparable` para permitir ordenamiento por **nombre del producto**. 26 | 27 | Además, se aplica un `Comparator` anónimo para ordenar por **prioridad ascendente**. 28 | 29 | --- 30 | 31 | ## 💻 Código en Java 32 | 33 | ```java 34 | import java.util.*; 35 | 36 | // Clase que representa una orden de producción 37 | class OrdenProduccion implements Comparable { 38 | String codigo; 39 | String producto; 40 | int prioridad; 41 | 42 | public OrdenProduccion(String codigo, String producto, int prioridad) { 43 | this.codigo = codigo; 44 | this.producto = producto; 45 | this.prioridad = prioridad; 46 | } 47 | 48 | // Orden natural: por nombre del producto (alfabético) 49 | @Override 50 | public int compareTo(OrdenProduccion otra) { 51 | return this.producto.compareTo(otra.producto); 52 | } 53 | 54 | @Override 55 | public String toString() { 56 | return "Código: " + codigo + " | Producto: " + producto + " | Prioridad: " + prioridad; 57 | } 58 | } 59 | 60 | public class OrdenamientoProduccion { 61 | public static void main(String[] args) { 62 | // Lista de órdenes 63 | List ordenes = new ArrayList<>(); 64 | ordenes.add(new OrdenProduccion("OP-003", "Tornillo M6", 2)); 65 | ordenes.add(new OrdenProduccion("OP-001", "Tuerca M8", 1)); 66 | ordenes.add(new OrdenProduccion("OP-002", "Arandela 10mm", 3)); 67 | 68 | // Orden natural: por producto (Comparable) 69 | Collections.sort(ordenes); 70 | System.out.println("📦 Órdenes ordenadas por producto (orden natural):"); 71 | for (OrdenProduccion op : ordenes) { 72 | System.out.println(op); 73 | } 74 | 75 | // Orden personalizado: por prioridad (Comparator) 76 | ordenes.sort(new Comparator() { 77 | @Override 78 | public int compare(OrdenProduccion a, OrdenProduccion b) { 79 | return Integer.compare(a.prioridad, b.prioridad); 80 | } 81 | }); 82 | 83 | System.out.println("\n🔥 Órdenes ordenadas por prioridad (1 = alta):"); 84 | for (OrdenProduccion op : ordenes) { 85 | System.out.println(op); 86 | } 87 | } 88 | } 89 | ``` 90 | 91 | --- 92 | 93 | ## 🧠 ¿Qué conceptos se aplican aquí? 94 | 95 | | Técnica | Aplicación práctica | 96 | |---------------|-----------------------------------------------| 97 | | `Comparable` | Ordenar por nombre de producto (natural) | 98 | | `Comparator` | Ordenar por prioridad (externo/personalizado) | 99 | 100 | --- 101 | 102 | ## 💡 ¿Sabías que...? 103 | 104 | - Puedes usar `Collections.sort()` directamente si tu clase implementa `Comparable`. 105 | - `Comparator` te permite tener múltiples criterios de ordenamiento sin modificar la clase original. 106 | - También puedes usar expresiones lambda para simplificar comparadores. 107 | 108 | --- 109 | 110 | ⬅️ [**Anterior**](../Reto-01/Readme.md) | [**Siguiente**](../Ejemplo-04/Readme.md) ➡️ -------------------------------------------------------------------------------- /Sesion-06/Ejemplo-04/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 06**](../Readme.md) ➡️ / 📝 `Ejemplo 04: Introducción a colecciones concurrentes` 2 | 3 | ## 🎯 Objetivo 4 | 5 | Introducir el uso de colecciones seguras en entornos multihilo mediante `CopyOnWriteArrayList` y `ConcurrentHashMap`, aplicadas en una simulación simple que puede vivir un desarrollador en una aplicación con múltiples usuarios concurrentes. 6 | 7 | --- 8 | 9 | ## 💼 Escenario profesional: Servidor de monitoreo industrial 10 | 11 | Imagina que trabajas en una planta industrial y estás desarrollando una app que: 12 | 13 | - Registra en tiempo real los **nombres de técnicos conectados** al sistema (pueden entrar/salir en cualquier momento). 14 | 15 | - Guarda y actualiza las **últimas lecturas de temperatura** de distintas máquinas, cada una identificada por su código. 16 | 17 | En una aplicación real, cada lectura podría provenir de un hilo distinto. Por eso, necesitas estructuras seguras para evitar errores de concurrencia. 18 | 19 | --- 20 | 21 | ## 💻 Código en Java 22 | 23 | ```java 24 | import java.util.List; 25 | import java.util.concurrent.CopyOnWriteArrayList; 26 | import java.util.concurrent.ConcurrentHashMap; 27 | 28 | public class MonitoreoConcurrente { 29 | public static void main(String[] args) { 30 | 31 | // Lista concurrente: usuarios conectados 32 | List tecnicosConectados = new CopyOnWriteArrayList<>(); 33 | tecnicosConectados.add("Ana"); 34 | tecnicosConectados.add("Luis"); 35 | tecnicosConectados.add("Carlos"); 36 | 37 | // Simulación de lectura de usuarios conectados desde varios hilos 38 | System.out.println("👥 Técnicos actualmente conectados:"); 39 | for (String tecnico : tecnicosConectados) { 40 | System.out.println("- " + tecnico); 41 | } 42 | 43 | // Mapa concurrente: sensores por máquina 44 | ConcurrentHashMap sensoresTemperatura = new ConcurrentHashMap<>(); 45 | sensoresTemperatura.put("M-01", 68.5); 46 | sensoresTemperatura.put("M-02", 72.3); 47 | sensoresTemperatura.put("M-03", 70.0); 48 | 49 | // Simulación de actualización concurrente (solo un hilo en este caso) 50 | sensoresTemperatura.put("M-01", 69.1); // Nueva lectura 51 | sensoresTemperatura.put("M-04", 65.7); // Nueva máquina 52 | 53 | System.out.println("\n🌡️ Temperaturas por máquina:"); 54 | for (String maquina : sensoresTemperatura.keySet()) { 55 | System.out.println(maquina + " → " + sensoresTemperatura.get(maquina) + " °C"); 56 | } 57 | } 58 | } 59 | ``` 60 | 61 | --- 62 | 63 | ## 🧠 ¿Qué conceptos se aplican aquí? 64 | 65 | | Colección | ¿Qué resuelve? | 66 | |------------------------|-------------------------------------------| 67 | | `CopyOnWriteArrayList` | Lectura segura de usuarios conectados | 68 | | `ConcurrentHashMap` | Escritura segura de sensores en paralelo | 69 | 70 | --- 71 | 72 | ## 💡 ¿Sabías que...? 73 | 74 | - Las colecciones tradicionales (`ArrayList`, `HashMap`) pueden fallar en entornos multihilo. 75 | - `CopyOnWriteArrayList` es ideal cuando hay muchas lecturas y pocas escrituras. 76 | - `ConcurrentHashMap` divide internamente el acceso en segmentos para mayor rendimiento. 77 | 78 | --- 79 | 80 | ⬅️ [**Anterior**](../Ejemplo-03/Readme.md) | [**Siguiente**](../Reto-03/Readme.md) ➡️ -------------------------------------------------------------------------------- /Sesion-06/Imagenes/S00.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-06/Imagenes/S00.jpg -------------------------------------------------------------------------------- /Sesion-06/Imagenes/S06.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-06/Imagenes/S06.jpg -------------------------------------------------------------------------------- /Sesion-06/Imagenes/S06_Fig1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-06/Imagenes/S06_Fig1.png -------------------------------------------------------------------------------- /Sesion-06/Imagenes/S06_Fig2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-06/Imagenes/S06_Fig2.png -------------------------------------------------------------------------------- /Sesion-06/Imagenes/S06_Fig3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-06/Imagenes/S06_Fig3.png -------------------------------------------------------------------------------- /Sesion-06/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../Readme.md) ➡️ / 📖 `Sesión 06` 2 | 3 |
4 | Sesion_06 5 |
6 | 7 | ## 🎯 Objetivo 8 | 9 | ⚒️ Comprender y utilizar las **colecciones en Java** (`List`, `Set`, `Map`), diferenciando sus estructuras (`ArrayList`, `HashSet`, `HashMap`) y aplicando ordenamiento con `Comparable` y `Comparator`, así como una introducción a las **colecciones concurrentes** para entornos multihilo. 10 | 11 | --- 12 | 13 | 📘 Material del prework: 14 | 15 | Antes de comenzar con los ejercicios de esta sesión, recordemos que en el material de prework hemos cubierto los fundamentos teóricos que aplicaremos hoy. A lo largo de esta sesión, pondremos en práctica estos conceptos mediante una serie de ejercicios y retos diseñados para reforzar y validar nuestro entendimiento. 16 | 17 | 🔥¡Vamos a comenzar!🔥 18 | 19 | --- 20 | 21 | ## 📂 Temas de la sesión... 22 | 23 | 24 | ### 📖 Introducción a las colecciones (`List`, `Set`, `Map`) 25 | 26 | Las colecciones permiten almacenar y manipular grupos de datos de manera eficiente. 27 | 28 | - `List`: ordenada y permite duplicados. 29 | - `Set`: no permite duplicados. 30 | - `Map`: maneja pares clave-valor. 31 | 32 | ##### 📜 **[Ejemplo 01: Introducción a las colecciones](Ejemplo-01/Readme.md)** 33 | 34 | --- 35 | 36 | ### 📖 Diferencias entre `ArrayList`, `HashSet` y `HashMap` 37 | 38 | Cada estructura tiene un propósito distinto: 39 | 40 | - `ArrayList`: lista ordenada, acceso por índice, permite duplicados. 41 | - `HashSet`: no ordenada, sin duplicados. 42 | - `HashMap`: clave-valor, clave única. 43 | 44 | ##### 📜 **[Ejemplo 02: Diferencias entre ArrayList, HashSet y HashMap](Ejemplo-02/Readme.md)** 45 | ##### 🔥 **[Reto 01: Registro y análisis de muestras genéticas ](Reto-01/Readme.md)** 46 | 47 | --- 48 | 49 | ### 📖 Ordenamiento con `Comparator` y `Comparable` 50 | 51 | Permiten ordenar colecciones según un criterio: 52 | 53 | - `Comparable`: define orden natural (desde la clase). 54 | - `Comparator`: define orden externo y personalizado. 55 | 56 | ##### 📜 **[Ejemplo 03: Ordenamiento con Comparator y Comparable](Ejemplo-03/Readme.md)** 57 | 58 | --- 59 | 60 | ### 📖 Introducción a colecciones concurrentes 61 | 62 | En entornos multihilo, se requieren estructuras seguras: 63 | 64 | - `CopyOnWriteArrayList`: lista segura para lectura concurrente. 65 | - `ConcurrentHashMap`: mapa con acceso concurrente. 66 | 67 | ##### 📜 **[Ejemplo 04: Introducción a colecciones concurrentes](Ejemplo-04/Readme.md)** 68 | ##### 🔥 **[Reto 02: Planeación de temas y recursos educativos colaborativos ](Reto-02/Readme.md)** 69 | 70 | --- 71 | 72 | 73 | ⬅️ [**Anterior**](../Readme.md) | [**Siguiente**](../Sesion-07/Readme.md)➡️ 74 | -------------------------------------------------------------------------------- /Sesion-06/Reto-01/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 06**](../Readme.md) ➡️ / ⚡ `Reto 01: Registro y análisis de muestras genéticas` 2 | 3 | ## 🎯 Objetivo 4 | 5 | Practicar el uso de `ArrayList`, `HashSet` y `HashMap` en un contexto profesional relacionado con la biotecnología, para registrar muestras, identificar elementos únicos y asociar datos clave. 6 | 7 | --- 8 | 9 | ## 🧬 Escenario 10 | 11 | Estás colaborando como desarrollador Java en un laboratorio de **biotecnología molecular**. Tu tarea es ayudar al equipo de bioinformática a organizar el registro de las muestras genéticas que llegan diariamente al laboratorio. 12 | 13 | Deben llevar el control de: 14 | 15 | 1. 📥 El **orden de llegada** de las muestras (pueden repetirse si se replican). 16 | 2. 🧬 Las **especies únicas** que han sido procesadas. 17 | 3. 🧑‍🔬 El **ID de cada muestra** asociado con el **nombre del investigador** responsable. 18 | 19 | --- 20 | 21 | ## 📌 Instrucciones 22 | 23 | Crea un programa Java que: 24 | 25 | 1. Use un `ArrayList` para registrar el orden en que llegaron las muestras. 26 | Ejemplo de especies: `"Homo sapiens"`, `"Mus musculus"`, `"Arabidopsis thaliana"`, `"Homo sapiens"`. 27 | 28 | 2. Use un `HashSet` para obtener una lista de especies **únicas**. 29 | 30 | 3. Use un `HashMap` para asociar el **ID de muestra** con el **nombre del investigador**. 31 | Ejemplo: `("M-001", "Dra. López")`, `("M-002", "Dr. Hernández")`. 32 | 33 | 4. Muestre en consola: 34 | - La lista completa y ordenada de muestras. 35 | - Las especies únicas procesadas. 36 | - La relación de ID de muestra → investigador. 37 | - Una búsqueda por ID de muestra (`"M-002"` por ejemplo). 38 | 39 | --- 40 | 41 | ## 🧠 Consejos para resolver el reto 42 | 43 | - Utiliza nombres de variables descriptivos y en español. 44 | - Agrega comentarios para explicar cada bloque de código. 45 | - Usa `System.out.println()` para mostrar resultados de forma clara. 46 | 47 | --- 48 | 49 | ## 💻 Estructura sugerida 50 | 51 | ```java 52 | // Paso 1: ArrayList para registrar todas las especies en orden 53 | 54 | // Paso 2: HashSet para filtrar especies únicas 55 | 56 | // Paso 3: HashMap para asociar ID de muestra con investigador 57 | 58 | // Paso 4: Mostrar resultados 59 | ``` 60 | --- 61 | 62 | 🏆 Nos vemos en el siguiente reto, ¡mucho éxito! 63 | 64 | --- 65 | 66 | ⬅️ [**Anterior**](../Ejemplo-02/Readme.md) | [**Siguiente**](../Ejemplo-03/Readme.md) ➡️ -------------------------------------------------------------------------------- /Sesion-06/Reto-02/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 06**](../Readme.md) ➡️ / ⚡ `Reto 02: Planeación de temas y recursos educativos colaborativos` 2 | 3 | ## 🎯 Objetivo 4 | 5 | Practicar el uso de: 6 | 7 | - `Comparable` y `Comparator` para ordenar temas de clase. 8 | - `CopyOnWriteArrayList` para gestionar de forma segura una lista de temas activos. 9 | - `ConcurrentHashMap` para mantener un repositorio de recursos compartidos por tema, accesible de forma segura desde distintos usuarios. 10 | 11 | --- 12 | 13 | ## 👩‍🏫 Escenario 14 | 15 | Eres educadora y estás preparando el temario mensual de clases para un grupo de docentes que colaboran contigo. Cada tema tiene: 16 | 17 | - Un nombre 18 | - Un número de prioridad (1 = urgente, 2 = importante, 3 = opcional) 19 | 20 | Tu equipo también comparte materiales y enlaces digitales por tema, que se almacenan en un repositorio compartido. El sistema debe: 21 | 22 | 1. ✅ Gestionar los temas activos usando una lista concurrente. 23 | 24 | 2. 📊 Ordenar los temas por nombre (alfabético) y por prioridad (orden ascendente). 25 | 26 | 3. 📚 Mantener un repositorio concurrente de materiales asociados a cada tema, donde se guarde el título del tema como clave y el enlace o recurso sugerido como valor. 27 | 28 | --- 29 | 30 | ## 📌 Instrucciones 31 | 32 | 1. Crea una clase `Tema` con: 33 | - `titulo` (String) 34 | - `prioridad` (int) 35 | - Implementa `Comparable` para ordenar por `título`. 36 | 37 | 2. En tu método `main`: 38 | 39 | - Usa `CopyOnWriteArrayList` para gestionar los temas activos. 40 | - Muestra la lista ordenada alfabéticamente (orden natural). 41 | - Luego ordénala por prioridad ascendente (1 → 3) usando `Comparator`. 42 | 43 | 3. Usa `ConcurrentHashMap` como repositorio: 44 | - Clave: título del tema. 45 | - Valor: descripción o enlace del recurso compartido. 46 | 47 | --- 48 | 49 | ## 💡 Ejemplo 50 | 51 | ```java 52 | temas.add(new Tema("Lectura comprensiva", 2)); 53 | temas.add(new Tema("Matemáticas básicas", 1)); 54 | temas.add(new Tema("Cuidado del medio ambiente", 3)); 55 | 56 | recursos.put("Lectura comprensiva", "https://recursos.edu/lectura"); 57 | recursos.put("Matemáticas básicas", "https://recursos.edu/mate"); 58 | ``` 59 | 60 | --- 61 | 62 | ## 🧠 ¿Qué conceptos se aplican aquí? 63 | 64 | | Estructura / Técnica | Aplicación | 65 | |---------------------------|--------------------------------------------| 66 | | `Comparable` | Ordenar los temas por título | 67 | | `Comparator` | Ordenar los temas por prioridad | 68 | | `CopyOnWriteArrayList` | Lista segura de temas activos | 69 | | `ConcurrentHashMap` | Repositorio concurrente de recursos | 70 | 71 | --- 72 | 73 | 🏆 Nos vemos en el siguiente reto, ¡mucho éxito! 74 | 75 | --- 76 | 77 | 78 | ⬅️ [**Anterior**](../Ejemplo-04/Readme.md) | [**Siguiente**](../Sesion-07/Readme.md) ➡️ -------------------------------------------------------------------------------- /Sesion-07/Ejemplo-01/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 07**](../Readme.md) ➡️ / 📝 `Ejemplo 01: Introducción a java.nio.file (NIO.2)` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Comprender los fundamentos del paquete `java.nio.file`, utilizando las clases `Path` y `Files` para trabajar con rutas y archivos de forma más practica, moderna y segura que con la antigua API de `java.io`. 8 | 9 | --- 10 | 11 | ## 📌 ¿Qué es `java.nio.file`? 12 | 13 | A partir de Java 7, se introdujo **NIO.2** (New I/O), una actualización importante del sistema de entrada/salida que permite: 14 | 15 | - Manipular rutas de archivo como objetos (`Path`) 16 | - Realizar operaciones sobre archivos y directorios con utilidades (`Files`) 17 | - Mejorar el manejo de errores, rendimiento y portabilidad entre sistemas 18 | 19 | --- 20 | 21 | ## 📦 Clases clave en este ejemplo 22 | 23 | | Clase | Descripción breve | 24 | |---------------|-------------------------------------------------------------| 25 | | `Path` | Representa rutas en el sistema de archivos | 26 | | `Paths` | Clase de utilidad para construir objetos `Path` | 27 | | `Files` | Métodos estáticos para operaciones con archivos y carpetas | 28 | 29 | --- 30 | 31 | ## 🧪 Código de ejemplo: Creación y verificación de rutas 32 | 33 | ```java 34 | import java.nio.file.Path; 35 | import java.nio.file.Paths; 36 | import java.nio.file.Files; 37 | import java.io.IOException; 38 | 39 | public class ExploradorArchivos { 40 | public static void main(String[] args) { 41 | // 1. Crear un objeto Path que apunte a un archivo 42 | Path rutaArchivo = Paths.get("src/Ejemplo_01/ejemplo.txt"); 43 | 44 | // 2. Imprimir la ruta absoluta del archivo 45 | System.out.println("📁 Ruta absoluta: " + rutaArchivo.toAbsolutePath()); 46 | 47 | // 3. Verificar si el archivo existe 48 | if (Files.exists(rutaArchivo)) { 49 | System.out.println("✅ El archivo existe."); 50 | } else { 51 | System.out.println("❌ El archivo NO existe."); 52 | } 53 | 54 | // 4. Verificar si es un archivo o directorio 55 | if (Files.isDirectory(rutaArchivo)) { 56 | System.out.println("📂 Es un directorio."); 57 | } else { 58 | System.out.println("📄 Es un archivo."); 59 | } 60 | 61 | // 5. Verificar permisos 62 | System.out.println("🔒 ¿Se puede leer?: " + Files.isReadable(rutaArchivo)); 63 | System.out.println("✏️ ¿Se puede escribir?: " + Files.isWritable(rutaArchivo)); 64 | } 65 | } 66 | ``` 67 | 68 | --- 69 | 70 | ## 🧠 Explicación del ejemplo 71 | 72 | - Se construye una ruta relativa usando `Paths.get("documentos/ejemplo.txt")` 73 | - Se imprimen propiedades como: 74 | - Ruta absoluta 75 | - Existencia 76 | - Tipo (archivo o directorio) 77 | - Permisos (lectura y escritura) 78 | 79 | --- 80 | 81 | ## 📦 Recomendaciones al trabajar con rutas 82 | 83 | - Usa `Path` y `Files` en lugar de `File` de `java.io` 84 | - Siempre verifica si el archivo existe antes de manipularlo 85 | - Prefiere rutas **relativas** en desarrollo, y **absolutas** si el archivo no cambia de ubicación 86 | 87 | ✅ Diferencia entre ruta relativa y ruta absoluta 88 | 89 | | Tipo de ruta | Descripción | Ejemplo | 90 | |------------------|-----------------------------------------------------------------------------|---------| 91 | | **Ruta relativa** | Es una ruta que **parte desde la ubicación actual** del programa (proyecto). | `documentos/archivo.txt` | 92 | | **Ruta absoluta** | Es una ruta que **especifica la ubicación completa** del archivo en el sistema operativo. | `C:/Users/mario/Documents/archivo.txt` | 93 | 94 | --- 95 | 96 | ## 💡 ¿Sabías que...? 97 | 98 | - Puedes usar `Paths.get()` con múltiples argumentos: 99 | `Paths.get("carpeta", "subcarpeta", "archivo.txt")` 100 | - `Files.exists(path)` lanza menos excepciones que `File.exists()` (más robusto) 101 | - Con NIO.2 puedes manejar rutas tanto en sistemas Windows como UNIX sin problemas de compatibilidad 102 | 103 | --- 104 | 105 | 📘 Recurso adicional para repaso: 106 | 🔗 [NIO.2 (java.nio.file) – Oracle Docs](https://docs.oracle.com/javase/tutorial/essential/io/fileio.html) 107 | 108 | --- 109 | 110 | ⬅️ [**Anterior**](../Readme.md) | [**Siguiente**](../Ejemplo-02/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-07/Ejemplo-02/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 07**](../Readme.md) ➡️ / 📝 `Ejemplo 02: Lectura y escritura con Files.readString() y Files.write()` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Aprender a utilizar los métodos `Files.readString()` y `Files.write()` para realizar operaciones de lectura y escritura de archivos de texto de forma sencilla, aprovechando las mejoras de la API NIO.2. 8 | 9 | --- 10 | 11 | ## 📌 ¿Por qué usar `Files.readString()` y `Files.write()`? 12 | 13 | Estas funciones introducidas en Java 11 simplifican el manejo de archivos en comparación con versiones anteriores. Son ideales cuando: 14 | 15 | - Solo necesitas leer o escribir texto completo. 16 | - No requieres flujo por líneas ni procesamiento complejo. 17 | 18 | --- 19 | 20 | ## 📚 Métodos clave 21 | 22 | | Método | Descripción | 23 | |---------------------|----------------------------------------------------------------------| 24 | | `Files.readString()`| Lee el contenido completo de un archivo como una cadena (`String`) | 25 | | `Files.write()` | Escribe una cadena en un archivo. Si no existe, lo crea; si existe, lo sobrescribe | 26 | 27 | --- 28 | 29 | ## 🧪 Código de ejemplo: Escribir y luego leer un archivo de texto 30 | 31 | ```java 32 | import java.io.IOException; 33 | import java.nio.file.Files; 34 | import java.nio.file.Path; 35 | import java.nio.file.Paths; 36 | 37 | public class LecturaEscrituraArchivos { 38 | public static void main(String[] args) { 39 | // 1. Definir la ruta del archivo 40 | Path ruta = Paths.get("src/Ejemplo_02/notas.txt"); 41 | 42 | // 2. Contenido a escribir en el archivo 43 | String contenido = "📘 Este es un archivo de prueba.\nAquí aprendemos a escribir y leer en Java."; 44 | 45 | try { 46 | // 3. Escribir contenido en el archivo (crea o sobrescribe) 47 | Files.write(ruta, contenido.getBytes()); 48 | System.out.println("✅ Archivo escrito exitosamente."); 49 | 50 | // 4. Leer el contenido completo como String 51 | String textoLeido = Files.readString(ruta); 52 | System.out.println("📄 Contenido leído:"); 53 | System.out.println(textoLeido); 54 | 55 | } catch (IOException e) { 56 | System.out.println("❌ Error al trabajar con el archivo: " + e.getMessage()); 57 | } 58 | } 59 | } 60 | ``` 61 | 62 | --- 63 | 64 | ## 🧠 ¿Qué se está haciendo? 65 | 66 | - `Files.write()` convierte el texto a bytes y lo guarda en el archivo especificado. 67 | - `Files.readString()` devuelve el contenido completo como una cadena de texto. 68 | - Se usa `try-catch` para capturar errores como permisos o rutas inválidas. 69 | 70 | --- 71 | 72 | ## 📌 Consideraciones importantes 73 | 74 | - Si el archivo **no existe**, `Files.write()` lo crea automáticamente. 75 | - Si **ya existe**, su contenido será reemplazado (¡cuidado!). 76 | - Para evitar sobrescribir, puedes usar una validación previa con `Files.exists(ruta)`. 77 | 78 | --- 79 | 80 | ## 💡 ¿Sabías que...? 81 | 82 | - Puedes usar `StandardOpenOption.APPEND` para **agregar contenido** sin borrar lo anterior: 83 | ```java 84 | Files.write(ruta, "Otra línea\n".getBytes(), StandardOpenOption.APPEND); 85 | ``` 86 | 87 | - `Files.readString()` es ideal para archivos pequeños o medianos. Para archivos grandes, es mejor `BufferedReader`. 88 | 89 | --- 90 | 91 | 📘 Recurso adicional para repaso: 92 | 🔗 [Clase Files – Oracle Docs](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/file/Files.html) 93 | 94 | --- 95 | 96 | ⬅️ [**Anterior**](../Ejemplo-01/Readme.md) | [**Siguiente**](../Reto-01/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-07/Ejemplo-03/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 07**](../Readme.md) ➡️ / 📝 `Ejemplo 03: Manejo avanzado de archivos` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Aprender a usar las funciones avanzadas de la API `java.nio.file` para **copiar, mover, crear carpetas** y **verificar permisos de archivos**. Estas operaciones son esenciales en sistemas automatizados, como aquellos utilizados en entornos de **Industria 4.0** o aplicaciones con dispositivos inteligentes. 8 | 9 | --- 10 | 11 | ## 🧠 Escenario aplicado: robots de inspección en una planta 4.0 12 | 13 | Imagina una **línea de producción automatizada**, donde **robots de inspección** generan reportes de calidad en archivos `.txt`. Tu sistema debe: 14 | 15 | - Mover archivos temporales a carpetas de almacenamiento. 16 | - Crear respaldos de forma organizada. 17 | - Validar permisos de acceso a los archivos. 18 | - Crear nuevas carpetas para clasificar por fecha, turno o tipo de evento. 19 | 20 | Este tipo de tareas es común en entornos donde conviven la automatización, la trazabilidad de datos y la supervisión por inteligencia artificial o sistemas autónomos. 21 | 22 | --- 23 | 24 | ## 🧪 Código de ejemplo: mover, copiar, crear y validar archivos 25 | 26 | ```java 27 | import java.nio.file.Files; 28 | import java.nio.file.Path; 29 | import java.nio.file.Paths; 30 | import java.io.IOException; 31 | import java.nio.file.StandardCopyOption; 32 | import java.nio.charset.StandardCharsets; 33 | 34 | public class GestorDeReportes { 35 | public static void main(String[] args) { 36 | try { 37 | // Crear directorios dentro de este package si no existen 38 | Path base = Paths.get("src/Ejemplo_03"); 39 | Path dirTemporal = base.resolve("temporal"); 40 | Path dirAlmacenamiento = base.resolve("almacenamiento"); 41 | Path dirRespaldo = base.resolve("respaldo"); 42 | Path dirHistoricos = base.resolve("archivos-historicos"); 43 | 44 | Files.createDirectories(dirTemporal); 45 | Files.createDirectories(dirAlmacenamiento); 46 | Files.createDirectories(dirRespaldo); 47 | Files.createDirectories(dirHistoricos); 48 | 49 | // Crear archivo de ejemplo en temporal 50 | Path archivoTemporal = dirTemporal.resolve("reporte_inspeccion.txt"); 51 | 52 | if (!Files.exists(archivoTemporal)) { 53 | Files.writeString(archivoTemporal, "🔍 Reporte de inspección inicial.\nFecha: 2025-03-31", StandardCharsets.UTF_8); 54 | System.out.println("📄 Archivo de reporte creado en carpeta temporal."); 55 | } 56 | 57 | // Mover archivo a almacenamiento 58 | Path archivoAlmacenado = dirAlmacenamiento.resolve("reporte_inspeccion.txt"); 59 | Files.move(archivoTemporal, archivoAlmacenado, StandardCopyOption.REPLACE_EXISTING); 60 | System.out.println("📦 Archivo movido a carpeta de almacenamiento."); 61 | 62 | // Copiar archivo a respaldo 63 | Path archivoRespaldo = dirRespaldo.resolve("reporte_inspeccion.txt"); 64 | Files.copy(archivoAlmacenado, archivoRespaldo, StandardCopyOption.REPLACE_EXISTING); 65 | System.out.println("🗂️ Copia de respaldo creada."); 66 | 67 | // Verificar permisos del archivo de respaldo 68 | System.out.println("✅ ¿Se puede leer?: " + Files.isReadable(archivoRespaldo)); 69 | System.out.println("✏️ ¿Se puede escribir?: " + Files.isWritable(archivoRespaldo)); 70 | 71 | } catch (IOException e) { 72 | System.err.println("❌ Error al manejar archivos: " + e.getMessage()); 73 | } 74 | } 75 | } 76 | ``` 77 | 78 | --- 79 | 80 | 📌 **Importante**: 81 | Este código no utiliza manejo de errores (`try-catch`) porque el tema de excepciones será abordado en el **Ejemplo 04**. Si los archivos o carpetas no existen, se generará un error al ejecutar. 82 | Puedes simular correctamente el ejemplo creando previamente las carpetas `temporal`, `almacenamiento`, y el archivo `reporte-inspeccion.txt`. 83 | 84 | --- 85 | 86 | ## 🧰 Funciones clave utilizadas 87 | 88 | | Método | Función | 89 | |----------------------------------|--------------------------------------------------------------------------| 90 | | `Files.move()` | Mueve un archivo a otra ubicación | 91 | | `Files.copy()` | Copia un archivo | 92 | | `Files.createDirectory()` | Crea una nueva carpeta | 93 | | `Files.isReadable() / isWritable()` | Verifica si el archivo tiene permisos de lectura/escritura | 94 | 95 | --- 96 | 97 | ## 💡 ¿Sabías que...? 98 | 99 | - Puedes usar `Files.createDirectories()` si deseas crear múltiples carpetas anidadas. 100 | - Estas operaciones son muy comunes en software que trabaja con archivos generados automáticamente por sistemas como **robots**, **sensores**, **drones**, o **IA** que produce reportes en tiempo real. 101 | - `java.nio.file` es portable y compatible con Linux, Windows o macOS, por lo que puedes usar estas operaciones en servidores industriales o entornos embebidos. 102 | 103 | --- 104 | 105 | 📘 Recurso adicional para repaso: 106 | 🔗 [Clase Files – Oracle Docs](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/file/Files.html) 107 | 108 | --- 109 | 110 | ⬅️ [**Anterior**](../Reto-01/Readme.md) | [**Siguiente**](../Ejemplo-04/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-07/Ejemplo-04/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 07**](../Readme.md) ➡️ / 📝 `Ejemplo 04: Buenas prácticas en manejo de archivos` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | Aplicar buenas prácticas en el manejo de archivos en Java, usando **excepciones (`try-catch`)**, el bloque `try-with-resources` para liberar recursos automáticamente, y el uso de `BufferedReader` para una lectura más eficiente. 8 | 9 | --- 10 | 11 | ## 📌 ¿Por qué aplicar buenas prácticas? 12 | 13 | Trabajar con archivos puede provocar errores comunes como: 14 | 15 | - El archivo no existe 16 | - No se tienen permisos para leerlo 17 | - El archivo está dañado o vacío 18 | 19 | Para evitar que tu programa se detenga abruptamente, es importante **capturar las excepciones** y manejar los recursos correctamente. 20 | 21 | --- 22 | 23 | ## 1️⃣ Uso básico de `try-catch` para leer un archivo 24 | 25 | ```java 26 | import java.io.IOException; 27 | import java.nio.file.Files; 28 | import java.nio.file.Path; 29 | import java.nio.file.Paths; 30 | 31 | public class LectorBasico { 32 | public static void main(String[] args) { 33 | Path ruta = Paths.get("src/Ejemplo_04/datos.txt"); 34 | 35 | try { 36 | String contenido = Files.readString(ruta); 37 | System.out.println("📄 Contenido del archivo:"); 38 | System.out.println(contenido); 39 | } catch (IOException e) { 40 | System.out.println("❌ No se pudo leer el archivo: " + e.getMessage()); 41 | } 42 | } 43 | } 44 | ``` 45 | 46 | 🔍 Este ejemplo: 47 | 48 | - Intenta leer el contenido completo del archivo `datos.txt`. 49 | - Si no existe o hay un problema, el error se muestra en consola. 50 | - Es una forma segura y sencilla de **evitar que el programa se rompa**. 51 | 52 | --- 53 | 54 | ## 2️⃣ Uso de `try-with-resources` con `BufferedReader` 55 | 56 | Cuando trabajamos con archivos grandes, conviene leer **línea por línea** con `BufferedReader`, y cerrar el recurso automáticamente. 57 | 58 | ```java 59 | import java.io.BufferedReader; 60 | import java.io.IOException; 61 | import java.nio.file.Files; 62 | import java.nio.file.Path; 63 | import java.nio.file.Paths; 64 | 65 | public class LectorEficiente { 66 | public static void main(String[] args) { 67 | Path ruta = Paths.get("log-operaciones.txt"); 68 | 69 | try (BufferedReader lector = Files.newBufferedReader(ruta)) { 70 | String linea; 71 | 72 | while ((linea = lector.readLine()) != null) { 73 | System.out.println("➡️ " + linea); 74 | } 75 | } catch (IOException e) { 76 | System.out.println("❌ Error al procesar el archivo: " + e.getMessage()); 77 | } 78 | } 79 | } 80 | ``` 81 | 82 | 🧠 En este ejemplo: 83 | 84 | - Se abre el archivo con `BufferedReader`, ideal para archivos largos. 85 | - `try-with-resources` garantiza que el lector se cierre automáticamente. 86 | - Se lee cada línea de forma eficiente y segura. 87 | 88 | --- 89 | 90 | ## ✅ Recomendaciones clave 91 | 92 | | Práctica | ¿Por qué se usa? | 93 | |-----------------------------|--------------------------------------------------------------------| 94 | | `try-catch` | Captura errores como archivo no encontrado o sin permisos | 95 | | `BufferedReader` | Optimiza lectura en archivos con muchas líneas | 96 | | `try-with-resources` | Libera el recurso automáticamente (no necesitas cerrar manualmente) | 97 | 98 | --- 99 | 100 | ## 💡 ¿Sabías que...? 101 | 102 | - Si no manejas errores con `try-catch`, tu programa puede fallar por completo. 103 | - `BufferedReader` es muy útil para leer logs, archivos de sensores, bitácoras, etc. 104 | - Estas técnicas son comunes en sistemas industriales o automatizados que generan archivos de forma continua. 105 | 106 | --- 107 | 108 | 📘 Recurso adicional para repaso: 109 | 🔗 [BufferedReader – Oracle Docs](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/BufferedReader.html) 110 | 🔗 [try-with-resources – Baeldung](https://www.baeldung.com/java-try-with-resources) 111 | 112 | --- 113 | 114 | ⬅️ [**Anterior**](../Ejemplo-03/Readme.md) | [**Siguiente**](../Reto-02/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-07/Imagenes/S00.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-07/Imagenes/S00.jpg -------------------------------------------------------------------------------- /Sesion-07/Imagenes/S07.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-07/Imagenes/S07.jpg -------------------------------------------------------------------------------- /Sesion-07/Imagenes/S07_Fig1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-07/Imagenes/S07_Fig1.png -------------------------------------------------------------------------------- /Sesion-07/Imagenes/S07_Fig2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-07/Imagenes/S07_Fig2.png -------------------------------------------------------------------------------- /Sesion-07/Imagenes/S07_Fig3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-07/Imagenes/S07_Fig3.png -------------------------------------------------------------------------------- /Sesion-07/Imagenes/S07_Fig4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-07/Imagenes/S07_Fig4.png -------------------------------------------------------------------------------- /Sesion-07/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../Readme.md) ➡️ / 📖 `Sesión 07` 2 | 3 |
4 | Sesion_07 5 |
6 | 7 | ## 🎯 Objetivo 8 | 9 | ⚒️ Aprender a utilizar la API **java.nio.file (NIO.2)** para manejar archivos y directorios de forma eficiente y segura, comprendiendo desde las operaciones básicas de lectura y escritura hasta funciones avanzadas como copiar, mover, verificar permisos y aplicar buenas prácticas de manejo de archivos en Java. 10 | 11 | --- 12 | 13 | 📘 Material del prework: 14 | 15 | Antes de comenzar con los ejercicios de esta sesión, recordemos que en el material de prework hemos cubierto los fundamentos teóricos que aplicaremos hoy. A lo largo de esta sesión, pondremos en práctica estos conceptos mediante una serie de ejercicios y retos diseñados para reforzar y validar nuestro entendimiento. 16 | 🔥¡Vamos a comenzar!🔥 17 | 18 | --- 19 | 20 | ## 📂 Temas de la sesión... 21 | 22 | 23 | ### 📖 Introducción a `java.nio.file` (NIO.2) 24 | 25 | Las colecciones permiten almacenar y manipular grupos de datos de manera eficiente. 26 | 27 | La API NIO.2 ofrece una forma moderna y potente de trabajar con archivos y rutas en Java, utilizando las clases `Path` y `Files`. 28 | 29 | - Diferencias entre IO y NIO.2 30 | - Estructura del paquete `java.nio.file` 31 | - Conceptos clave: rutas y operaciones 32 | 33 | 34 | ##### 📜 **[Ejemplo 01: Introducción a java.nio.file (NIO.2)](Ejemplo-01/Readme.md)** 35 | --- 36 | 37 | ### 📖 Lectura y escritura con `Files.readString()` y `Files.write()` 38 | 39 | Dos métodos fundamentales para interactuar con archivos de texto: 40 | 41 | - `Files.readString()`: lee todo el contenido de un archivo como `String` 42 | - `Files.write()`: escribe contenido a un archivo, lo crea o sobrescribe 43 | 44 | 45 | ##### 📜 **[Ejemplo 02: Lectura y escritura con Files.readString() y Files.write()](Ejemplo-02/Readme.md)** 46 | ##### 🔥 **[Reto 01: Registro de parámetros de simulación](Reto-01/Readme.md)** 47 | 48 | --- 49 | 50 | ### 📖 Manejo avanzado de archivos 51 | 52 | Con NIO.2 puedes realizar operaciones esenciales para manipular archivos y directorios: 53 | 54 | - `Files.copy()` y `Files.move()` 55 | - Crear carpetas con `createDirectory()` 56 | - Verificar permisos con `Files.isReadable()`, `isWritable()`, etc. 57 | 58 | ##### 📜 **[Ejemplo 03: Manejo avanzado de archivos](Ejemplo-03/Readme.md)** 59 | 60 | --- 61 | 62 | ### 📖 Buenas prácticas en manejo de archivos 63 | 64 | Trabajar con archivos requiere planificación y prevención de errores: 65 | 66 | - Manejo de excepciones con `try-catch` 67 | - Uso de `try-with-resources` 68 | - Mejora el rendimiento en archivos extensos con `BufferedReader` 69 | 70 | ##### 📜 **[Ejemplo 04: Buenas prácticas en manejo de archivos](Ejemplo-04/Readme.md)** 71 | ##### 🔥 **[Reto 02: Procesamiento eficiente de logs de errores](Reto-02/Readme.md)** 72 | 73 | --- 74 | 75 | 76 | ⬅️ [**Anterior**](../Sesion-06/Readme.md) | [**Siguiente**](../Sesion-08/Readme.md)➡️ 77 | -------------------------------------------------------------------------------- /Sesion-07/Reto-01/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 07**](../Readme.md) ➡️ / ⚡`Reto 01: Registro de parámetros de simulación` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | 🧠 Aplicar las clases `Path` y `Files` de la API `java.nio.file` (NIO.2) para crear un archivo de configuración de simulación, verificar su existencia y leer su contenido. Este ejercicio simula una tarea real del rol de **Process Simulation Engineer**, donde se documentan los parámetros antes de ejecutar una corrida de simulación. 8 | 9 | --- 10 | 11 | ## 📝 Instrucciones 12 | 13 | ⚙️ Imagina que estás trabajando como **process simulation engineer** en una planta de manufactura digital. Antes de correr cualquier modelo, debes registrar los parámetros de entrada en un archivo de configuración. 14 | 15 | Tu misión será **crear un programa en Java que genere este archivo, valide su existencia y luego lo lea para su verificación**. 16 | 17 | ### 🧩 Actividades 18 | 19 | 1. Crea una clase principal llamada `RegistroSimulacion`. 20 | 2. Usa `Path` y `Paths.get()` para definir la ruta del archivo `parametros.txt`, dentro de una carpeta `config/`. 21 | 3. Crea un `String` con parámetros como: 22 | - Tiempo de ciclo: 55.8 segundos 23 | - Velocidad de línea: 1.2 m/s 24 | - Número de estaciones: 8 25 | 4. Utiliza `Files.write()` para guardar el contenido en el archivo. Si la carpeta `config/` no existe, créala previamente. 26 | 5. Usa `Files.exists()` para validar que el archivo fue creado correctamente. 27 | 6. Lee el archivo con `Files.readString()` y muestra su contenido en consola. 28 | 29 | --- 30 | 31 | ## 💡 Tip 32 | 33 | ✅ Puedes encapsular la lógica de escritura y lectura en métodos separados como `guardarParametros()` y `leerParametros()` para mejorar la legibilidad. 34 | 35 | --- 36 | 37 | 📘 ¿Quieres repasar cómo funcionan `Path`, `Files.write()` o `Files.readString()`? 38 | 🔗 [Documentación oficial de NIO.2 – Oracle](https://docs.oracle.com/javase/tutorial/essential/io/fileio.html) 39 | 40 | --- 41 | 42 | 🏆 Este reto te acerca a un escenario real en simulación industrial, donde la trazabilidad y correcta documentación de parámetros es clave para garantizar la calidad y reproducibilidad de resultados. 43 | 44 | --- 45 | 46 | ⬅️ [**Anterior**](../Ejemplo-02/Readme.md) | [**Siguiente**](../Ejemplo-03/Readme.md)➡️ 47 | -------------------------------------------------------------------------------- /Sesion-07/Reto-02/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 07**](../Readme.md) ➡️ / ⚡`Reto 02: Procesamiento eficiente de logs de errores` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | 🧠 Aplicar el uso de `BufferedReader`, `try-with-resources` y manejo de excepciones para analizar grandes archivos de logs generados por pruebas automatizadas. Este reto simula una tarea del rol de **Automated Testing Engineer (QA)**, enfocada en el procesamiento eficiente de información y la trazabilidad de errores. 8 | 9 | --- 10 | 11 | ## 📝 Instrucciones 12 | 13 | 🧪 Imagina que eres parte del equipo de QA en una empresa que ejecuta pruebas automáticas durante la madrugada. Al amanecer, debes revisar un archivo `errores.log` que contiene miles de líneas con mensajes de error, advertencia y éxito. 14 | 15 | Tu misión será **analizar el archivo de forma eficiente, detectar la frecuencia de errores y advertencias, y generar un resumen del análisis**. 16 | 17 | ### 🧩 Actividades 18 | 19 | 1. Crea una clase principal llamada `AnalizadorDeLogs`. 20 | 2. Usa `try-with-resources` para abrir el archivo `errores.log` con `BufferedReader`. 21 | 3. Lee el archivo línea por línea y cuenta cuántas veces aparece: 22 | - La palabra `"ERROR"` 23 | - La palabra `"WARNING"` 24 | 4. Al finalizar, imprime un resumen en consola con: 25 | - Total de líneas leídas 26 | - Cantidad de errores 27 | - Cantidad de advertencias 28 | - Porcentaje de líneas con errores y advertencias 29 | 5. Si el archivo no existe o hay algún problema, captura la excepción con `try-catch` y guarda el mensaje de error en un archivo `registro_fallos.txt`. 30 | 31 | --- 32 | 33 | ## 💡 Tip 34 | 35 | ✅ Usa `linea.contains("ERROR")` o `linea.contains("WARNING")` para facilitar el conteo de patrones. 36 | 37 | --- 38 | 39 | 📘 ¿Quieres repasar cómo funciona `BufferedReader` y `try-with-resources`? 40 | 🔗 [BufferedReader – Oracle Docs](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/BufferedReader.html) 41 | 🔗 [try-with-resources – Baeldung](https://www.baeldung.com/java-try-with-resources) 42 | 43 | --- 44 | 45 | 🏆 Este reto pone en práctica habilidades fundamentales para asegurar la calidad en entornos automatizados, mejorando la eficiencia y la gestión de errores en sistemas complejos. 46 | 47 | --- 48 | 49 | ⬅️ [**Anterior**](../Ejemplo-04/Readme.md) | [**Siguiente**](../../Sesion-08/Readme.md)➡️ 50 | -------------------------------------------------------------------------------- /Sesion-08/Ejemplo-01/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 08**](../Readme.md) ➡️ / 📝 `Ejemplo 01: Refactorización y Code Smells` 2 | 3 | --- 4 | 5 | ## 🎯 Objetivo 6 | 7 | 🔍 Aplicar buenas prácticas de refactorización identificando y corrigiendo code smells comunes en un caso profesional sencillo, mejorando la legibilidad y mantenimiento del código en Java. 8 | 9 | --- 10 | 11 | ## 👩‍💻 Contexto del ejemplo 12 | 13 | Imagina que trabajas como Java developer en una empresa fintech. Te asignaron el mantenimiento de una pequeña función que calcula comisiones por ventas de productos financieros. 14 | 15 | Al revisar el código, detectas señales de alerta: funciones muy largas, nombres poco claros y código duplicado 😩. 16 | 17 | Tu tarea es aplicar refactorización para mejorar su estructura y comprensión 🤓💡, pero, sin alterar su comportamiento 🤔. 18 | 19 | --- 20 | 21 | ## 🧠 Un repaso antes... 22 | 23 | Sabemos que: 24 | 25 | - **Refactorizar** es mejorar el diseño interno del código sin cambiar su funcionalidad. 26 | - Un **code smell** es una señal de que algo podría estar mal estructurado. No rompe el código, pero sí puede hacerlo difícil de mantener. 27 | - Algunos **ejemplos comunes** de code smells: 28 | - Código duplicado 29 | - Funciones largas 30 | - Nombres poco descriptivos 31 | - Clases o funciones con muchas responsabilidades 32 | - Código comentado que ya no se usa 33 | 34 | 💡 Refactorizar es como limpiar tu espacio de trabajo: te hace más productivo, evita errores y facilita el trabajo en equipo. 35 | 36 | --- 37 | 38 | ## 💼 Ejemplo 39 | 40 | Veamos este caso realista. Este código se encuentra en un archivo que calcula comisiones de agentes de ventas para un producto financiero. El código original presenta varios problemas: 41 | 42 | ### 💻 Código antes de refactorizar 43 | 44 | ```java 45 | public class ComisionVentas { 46 | 47 | public static void main(String[] args) { 48 | String nombre = "Carlos"; 49 | double ventas = 30000; 50 | double comision; 51 | 52 | if (ventas >= 20000 && ventas <= 40000) { 53 | comision = ventas * 0.10; 54 | System.out.println("Comisión de " + nombre + ": $" + comision); 55 | } else if (ventas > 40000) { 56 | comision = ventas * 0.12; 57 | System.out.println("Comisión de " + nombre + ": $" + comision); 58 | } else { 59 | comision = ventas * 0.05; 60 | System.out.println("Comisión de " + nombre + ": $" + comision); 61 | } 62 | 63 | if (ventas > 25000 && ventas < 30000) { 64 | System.out.println("¡Carlos está cerca del siguiente nivel!"); 65 | } 66 | } 67 | } 68 | ``` 69 | 70 | ### 🚨 Problemas detectados 71 | 72 | | Code Smell | Explicación | 73 | |---------------------------|-------------------------------------------------------------------------------| 74 | | Código duplicado | La línea `System.out.println(...)` se repite en cada condición. | 75 | | Nombres poco descriptivos | `ventas` es aceptable, pero `comision` y `nombre` pueden ser más específicos.| 76 | | Código comentado | Hay una línea que ya no se usa. | 77 | | Lógica mezclada | La lógica de cálculo y de impresión están en el mismo lugar. | 78 | 79 | --- 80 | 81 | ### ✅ Código después de refactorizar 82 | 83 | ```java 84 | public class ComisionVentasRefactor { 85 | 86 | public static void main(String[] args) { 87 | String nombreAgente = "Carlos"; 88 | double montoVentas = 30000; 89 | 90 | double comisionCalculada = calcularComision(montoVentas); 91 | mostrarComision(nombreAgente, comisionCalculada); 92 | 93 | if (estaCercaDelSiguienteNivel(montoVentas)) { 94 | System.out.println("¡" + nombreAgente + " está cerca del siguiente nivel!"); 95 | } 96 | } 97 | 98 | // Esta función se encarga únicamente del cálculo de la comisión 99 | public static double calcularComision(double ventas) { 100 | if (ventas >= 20000 && ventas <= 40000) { 101 | return ventas * 0.10; 102 | } else if (ventas > 40000) { 103 | return ventas * 0.12; 104 | } else { 105 | return ventas * 0.05; 106 | } 107 | } 108 | 109 | // Esta función muestra la comisión 110 | public static void mostrarComision(String nombre, double comision) { 111 | System.out.println("Comisión de " + nombre + ": $" + comision); 112 | } 113 | 114 | // Verifica si el vendedor está cerca del siguiente nivel 115 | public static boolean estaCercaDelSiguienteNivel(double ventas) { 116 | return ventas > 25000 && ventas < 30000; 117 | } 118 | } 119 | ``` 120 | 121 | --- 122 | 123 | ## 🔄 ¿Qué aprendimos? 124 | 125 | ✅ Separar la lógica en funciones mejora la legibilidad y mantenimiento 126 | ✅ Evitar código duplicado facilita cambios futuros 127 | ✅ Usar nombres descriptivos hace que otros (o tú mismo) entiendan el propósito del código 128 | ✅ Eliminar código muerto ayuda a tener un proyecto más limpio y profesional 129 | 130 | --- 131 | 132 | ## 💡 ¿Sabías que...? 133 | 134 | - Existen herramientas como [SonarLint](https://www.sonarlint.org/) y [PMD](https://pmd.github.io/) que detectan code smells automáticamente en tu editor o IDE. 135 | - En muchas entrevistas técnicas, se valora más un código limpio y bien estructurado que uno que simplemente funcione. 136 | - Refactorizar es una práctica continua: incluso grandes empresas como Google, Netflix o Amazon refactorizan código constantemente. 137 | 138 | --- 139 | 140 | 📘 Recurso recomendado: 141 | 🔗 [Refactoring Guru - Code Smells (en español)](https://refactoring.guru/es/smells) 142 | 143 | --- 144 | 145 | 146 | ⬅️ [**Anterior**](../Readme.md) | [**Siguiente**](../Ejemplo-02/Readme.md) ➡️ -------------------------------------------------------------------------------- /Sesion-08/Ejemplo-02/Readme.md: -------------------------------------------------------------------------------- 1 | 2 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 08**](../Readme.md) ➡️ / 📝 `Ejemplo 02: Principios SOLID en Java` 3 | 4 | --- 5 | 6 | ## 🎯 Objetivo 7 | 8 | 🔍 Aplicar los principios SOLID para mejorar el diseño de clases en Java, generando estructuras más limpias, mantenibles y escalables, usando ejemplos del mundo profesional actual. 9 | 10 | --- 11 | 12 | ## 👩‍💻 Contexto 13 | 14 | Trabajas programando en Java dentro de una startup logística enfocada en desarrollar un sistema de tracking de paquetes. El sistema comenzó simple, pero ha ido creciendo, y las clases ya están empezando a mezclarse con múltiples responsabilidades 😖. 15 | 16 | Tu tarea es aplicar los **principios SOLID**✨ para reorganizar el diseño y asegurar que sea más claro y flexible para futuras mejoras. 17 | 18 | --- 19 | 20 | ## 🧠 Recordemos que... 21 | 22 | Los principios **SOLID** te ayudan a mantener el código organizado, modular y fácil de modificar: 23 | 24 | | Letra | Principio | ¿Qué busca? | Ejemplo práctico | 25 | |-------|-----------|-------------|------------------| 26 | | S | **Responsabilidad Única** | Una clase debe hacer solo una cosa. | `Cliente` guarda datos, `ImpresoraCliente` imprime. | 27 | | O | **Abierto/Cerrado** | El código debe permitir extensiones, sin modificar lo existente. | Nuevas reglas de descuento se agregan con nuevas clases. | 28 | | L | **Sustitución de Liskov** | Las subclases deben funcionar igual que sus clases padre. | `Perro` y `Gato` deben comportarse como `Animal`. | 29 | | I | **Segregación de Interfaces** | No obligar a implementar lo que no se necesita. | `Imprimible` solo tiene `imprimir()`. | 30 | | D | **Inversión de Dependencias** | Depender de abstracciones, no implementaciones. | Usar `IMotor` en lugar de una clase `MotorElectrico`. | 31 | 32 | --- 33 | 34 | ## 💼 Ejemplo 35 | 36 | Queremos modelar un sistema de seguimiento de paquetes. Inicialmente, tenemos una clase que **almacena datos del paquete, imprime su estado, y calcula el costo del envío**. Veamos cómo luce: 37 | 38 | ### 💻 Código sin aplicar SOLID 39 | 40 | ```java 41 | public class Paquete { 42 | private String destinatario; 43 | private double peso; 44 | 45 | public Paquete(String destinatario, double peso) { 46 | this.destinatario = destinatario; 47 | this.peso = peso; 48 | } 49 | 50 | public void imprimirEtiqueta() { 51 | System.out.println("Enviando a: " + destinatario); 52 | } 53 | 54 | public double calcularCostoEnvio() { 55 | return peso * 10.5; // tarifa fija por kilo 56 | } 57 | } 58 | ``` 59 | 60 | ### 🚨 Problemas detectados 61 | 62 | - 🔴 Incumple **SRP**: imprime e implementa lógica de negocio. 63 | - 🔴 Incumple **OCP**: si cambian las reglas de costos, hay que modificar esta clase. 64 | - 🔴 Incumple **DIP**: la clase usa lógica concreta de cálculo sin permitir flexibilidad. 65 | 66 | --- 67 | 68 | ### ✅ Código refactorizado aplicando SOLID 69 | 70 | ```java 71 | // SRP: Clase solo para datos 72 | public class Paquete { 73 | private String destinatario; 74 | private double peso; 75 | 76 | public Paquete(String destinatario, double peso) { 77 | this.destinatario = destinatario; 78 | this.peso = peso; 79 | } 80 | 81 | public String getDestinatario() { 82 | return destinatario; 83 | } 84 | 85 | public double getPeso() { 86 | return peso; 87 | } 88 | } 89 | 90 | // ISP: Interfaz específica para impresión 91 | interface Imprimible { 92 | void imprimirEtiqueta(Paquete paquete); 93 | } 94 | 95 | // Clase que imprime el estado del paquete 96 | public class ImpresoraEtiqueta implements Imprimible { 97 | public void imprimirEtiqueta(Paquete paquete) { 98 | System.out.println("📦 Envío a: " + paquete.getDestinatario()); 99 | } 100 | } 101 | 102 | // DIP + OCP: Interfaz para estrategia de costo de envío 103 | interface EstrategiaCostoEnvio { 104 | double calcularCosto(Paquete paquete); 105 | } 106 | 107 | // Implementación concreta de la estrategia estándar 108 | public class CostoEnvioEstandar implements EstrategiaCostoEnvio { 109 | public double calcularCosto(Paquete paquete) { 110 | return paquete.getPeso() * 10.5; 111 | } 112 | } 113 | 114 | // Clase de servicio que aplica inversión de dependencias 115 | public class ServicioEnvio { 116 | private EstrategiaCostoEnvio estrategia; 117 | 118 | public ServicioEnvio(EstrategiaCostoEnvio estrategia) { 119 | this.estrategia = estrategia; 120 | } 121 | 122 | public double obtenerCostoEnvio(Paquete paquete) { 123 | return estrategia.calcularCosto(paquete); 124 | } 125 | } 126 | ``` 127 | 128 | --- 129 | 130 | ### 🧪 Uso en el método `main` 131 | 132 | ```java 133 | public class Main { 134 | public static void main(String[] args) { 135 | Paquete paquete = new Paquete("Fernanda Loera", 2.5); 136 | 137 | Imprimible impresora = new ImpresoraEtiqueta(); 138 | impresora.imprimirEtiqueta(paquete); 139 | 140 | EstrategiaCostoEnvio estrategia = new CostoEnvioEstandar(); 141 | ServicioEnvio servicio = new ServicioEnvio(estrategia); 142 | 143 | double costo = servicio.obtenerCostoEnvio(paquete); 144 | System.out.println("💰 Costo de envío: $" + costo); 145 | } 146 | } 147 | ``` 148 | 149 | --- 150 | 151 | ## 🔄 ¿Qué aprendimos? 152 | 153 | ✅ **Separar responsabilidades** mejora el diseño 154 | ✅ **Abrir a extensión y cerrar a modificación** previene errores futuros 155 | ✅ **Usar interfaces** permite flexibilidad y escalabilidad 156 | ✅ **Invertir dependencias** facilita el cambio de comportamiento sin tocar la lógica principal 157 | 158 | --- 159 | 160 | ## 💡 ¿Sabías que...? 161 | 162 | - Los principios SOLID te ayudan a evitar el “código espagueti 🍝”, facilitando que nuevos desarrolladores entiendan y mantengan tu proyecto desde el primer día. 163 | 164 | - Aplicar SOLID desde etapas tempranas del desarrollo reduce drásticamente el costo de mantenimiento y retrabajo a largo plazo. 💸 165 | 166 | - Empresas como Amazon 🛒 y Google 🌐 suelen evaluar el conocimiento de SOLID en entrevistas técnicas para roles de desarrollo backend y arquitectura de software. 167 | 168 | --- 169 | 170 | 📘 Recurso recomendado: 171 | 🔗 https://www.baeldung.com/solid-principles 172 | 173 | --- 174 | 175 | 176 | ⬅️ [**Anterior**](../Ejemplo-01/Readme.md) | [**Siguiente**](../Reto-01/Readme.md) ➡️ -------------------------------------------------------------------------------- /Sesion-08/Ejemplo-03/Readme.md: -------------------------------------------------------------------------------- 1 | 2 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 08**](../Readme.md) ➡️ / 📖 `Ejemplo 03: Técnicas para mejorar el rendimiento` 3 | 4 | --- 5 | 6 | ## 🎯 Objetivo 7 | 8 | 🚀 Aplicar buenas prácticas para optimizar el rendimiento de programas en Java mediante el uso eficiente de estructuras de datos, simplificación de lógica y correcta gestión de memoria. 9 | 10 | --- 11 | 12 | ## 🧠 No olvidemos 13 | 14 | En el desarrollo profesional, el rendimiento importa tanto como la funcionalidad. No se trata de hacer “trucos mágicos” 🔮 sino de tomar decisiones inteligentes 💡 desde el inicio. 15 | 16 | ### ⚙️ Claves para mejorar el rendimiento 17 | 18 | | Técnica | Qué implica | Ejemplo práctico | 19 | |--------|-------------|------------------| 20 | | ✅ Estructuras eficientes | Usar `HashMap`, `HashSet`, `ArrayList`, según la situación | Buscar usuarios por ID → `HashMap` | 21 | | 🧼 Lógica limpia | Dividir métodos, eliminar bucles innecesarios | Salir temprano de un `for` cuando se cumple la condición | 22 | | 💾 Uso de memoria | Reutilizar objetos, cerrar recursos | Cerrar un archivo con `try-with-resources` | 23 | 24 | --- 25 | 26 | ## 💼 Ejemplo 27 | 28 | Eres parte del equipo de desarrollo que da soporte al área de sostenibilidad en una empresa manufacturera. Como **Sustainability Manager**, tu trabajo implica analizar datos de emisiones de CO₂ generadas por distintos procesos de la planta, y determinar si se repiten registros, si hay valores duplicados o inconsistentes, o si algún proceso excede el límite permitido. 29 | 30 | Tu herramienta se vuelve lenta al procesar los datos diarios de cada línea de producción. Necesitamos optimizar el sistema. 31 | 32 | ### 💻 Código inicial poco eficiente 33 | 34 | ```java 35 | import java.util.ArrayList; 36 | import java.util.List; 37 | 38 | public class RegistroEmisiones { 39 | public static void main(String[] args) { 40 | List emisiones = new ArrayList<>(); 41 | emisiones.add(123.5); 42 | emisiones.add(200.0); 43 | emisiones.add(123.5); // Duplicado 44 | emisiones.add(300.0); 45 | emisiones.add(200.0); // Duplicado 46 | 47 | for (int i = 0; i < emisiones.size(); i++) { 48 | for (int j = i + 1; j < emisiones.size(); j++) { 49 | if (emisiones.get(i).equals(emisiones.get(j))) { 50 | System.out.println("⚠️ Registro duplicado de emisión: " + emisiones.get(i)); 51 | } 52 | } 53 | } 54 | } 55 | } 56 | ``` 57 | 58 | --- 59 | 60 | ### 🚨 Problemas detectados 61 | 62 | - Uso de `ArrayList` para verificar duplicados → complejo y lento. 63 | - Búsquedas O(n²) → **muy costoso** cuando se manejan miles de registros. 64 | - Duplicación de lógica → poco mantenible. 65 | 66 | --- 67 | 68 | ### ✅ Código optimizado usando `HashSet` 69 | 70 | ```java 71 | import java.util.HashSet; 72 | import java.util.Set; 73 | 74 | public class RegistroEmisionesOptimizado { 75 | public static void main(String[] args) { 76 | // Datos simulados de emisiones de CO₂ por línea de producción (kg) 77 | double[] emisiones = {123.5, 200.0, 123.5, 300.0, 200.0}; 78 | 79 | // HashSet evita duplicados y permite búsqueda rápida 80 | Set emisionesRegistradas = new HashSet<>(); 81 | 82 | for (double valor : emisiones) { 83 | if (!emisionesRegistradas.add(valor)) { 84 | System.out.println("⚠️ Duplicado detectado: " + valor + " kg de CO₂"); 85 | } 86 | } 87 | } 88 | } 89 | ``` 90 | 91 | 92 | ### 💡 ¿Qué hicimos mejor? 93 | 94 | - Usamos `HashSet`, que no permite valores duplicados. 95 | - Eliminamos el segundo bucle anidado. 96 | - Ahora el sistema puede escalar fácilmente a **miles de líneas de emisión por día** sin colapsar. 97 | 98 | --- 99 | 100 | ### 🌱 Y en la vida real... 101 | 102 | Como **Sustainability Manager**, tu objetivo es reducir huella de carbono y asegurar calidad de los datos. Tener herramientas optimizadas te permite: 103 | - Detectar inconsistencias rápidamente 104 | - Generar reportes de forma más fluida 105 | - Cumplir con auditorías y certificaciones ambientales sin errores 106 | 107 | --- 108 | 109 | ## 🔄 ¿Qué aprendimos? 110 | 111 | ✅ Usar la estructura adecuada puede mejorar radicalmente el rendimiento 112 | ✅ Menos líneas no significa mejor código: lo importante es que sea **simple y claro** 113 | ✅ Una pequeña decisión (como cambiar un tipo de colección) puede **ahorrar miles de ciclos de CPU** 114 | 115 | --- 116 | 117 | ## 💡 ¿Sabías que...? 118 | 119 | - El uso incorrecto de estructuras de datos es una de las causas más comunes de cuellos de botella en producción. 120 | 121 | - Herramientas como [VisualVM](https://visualvm.github.io/) te permiten ver el consumo de memoria y CPU de tus programas Java. 122 | 123 | --- 124 | 125 | 📘 Recurso extra: 126 | 🔗 https://www.w3schools.com/java/java_hashset.asp 127 | 128 | --- 129 | 130 | ⬅️ [**Anterior**](../Reto-01/Readme.md) | [**Siguiente**](../Ejemplo-04/Readme.md)➡️ 131 | -------------------------------------------------------------------------------- /Sesion-08/Ejemplo-04/Readme.md: -------------------------------------------------------------------------------- 1 | 2 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 08**](../Readme.md) ➡️ / 📖 `Ejemplo 04: Manejo de excepciones con try-catch-finally` 3 | 4 | --- 5 | 6 | ## 🎯 Objetivo 7 | 8 | 🔐 Aprender a manejar errores de forma segura y controlada usando bloques `try-catch-finally` en Java, comprendiendo la diferencia entre excepciones `checked` y `unchecked`. 9 | 10 | --- 11 | 12 | ## 🧠 Repasemos 13 | 14 | Las **excepciones** en Java te permiten evitar que tu programa falle de forma inesperada, dándole al usuario una respuesta clara ante un error. 15 | 16 | ### 🧱 Tipos de excepciones 17 | 18 | | Tipo | ¿Compila sin manejarla? | ¿Se debe manejar? | Ejemplos | 19 | |-------------|--------------------------|--------------------|-----------------------------| 20 | | Checked | ❌ No | ✅ Sí | `IOException`, `SQLException` | 21 | | Unchecked | ✅ Sí | ❌ No (recomendado) | `NullPointerException`, `ArithmeticException` | 22 | 23 | ### 📌 Estructura típica 24 | 25 | ```java 26 | try { 27 | // Código que podría fallar 28 | } catch (Exception e) { 29 | // Qué hacer si falla 30 | } finally { 31 | // Siempre se ejecuta, ideal para cerrar recursos 32 | } 33 | ``` 34 | 35 | --- 36 | 37 | ## 💼 Ejemplo 38 | 39 | Eres **Remote Work Coordinator** en una empresa multinacional. Parte de tu sistema valida los tiempos de conexión remota de los empleados. Sin embargo, a veces los datos ingresados manualmente están en formatos incorrectos o contienen divisiones por cero. 40 | 41 | Necesitas evitar que el sistema falle por errores simples como una división entre 0 o el ingreso de datos no numéricos. 42 | 43 | ### 💻 Código con riesgo (sin manejo de excepciones) 44 | 45 | ```java 46 | import java.util.Scanner; 47 | 48 | public class ValidadorHorasConexion { 49 | public static void main(String[] args) { 50 | Scanner scanner = new Scanner(System.in); 51 | 52 | System.out.print("Total de horas conectadas: "); 53 | int horas = scanner.nextInt(); 54 | 55 | System.out.print("Número de días laborales: "); 56 | int dias = scanner.nextInt(); 57 | 58 | int promedio = horas / dias; 59 | System.out.println("Promedio de horas por día: " + promedio); 60 | } 61 | } 62 | ``` 63 | 64 | ### 🚨 ¿Qué puede salir mal? 65 | 66 | - El usuario ingresa texto en lugar de números → `InputMismatchException` 67 | - Ingresan 0 días → `ArithmeticException` 68 | - Nadie cierra el scanner → mala gestión de recursos 69 | 70 | --- 71 | 72 | ### ✅ Código optimizado con manejo de excepciones 73 | 74 | ```java 75 | import java.util.InputMismatchException; 76 | import java.util.Scanner; 77 | 78 | public class ValidadorHorasConexionSeguro { 79 | public static void main(String[] args) { 80 | Scanner scanner = null; 81 | 82 | try { 83 | scanner = new Scanner(System.in); 84 | 85 | System.out.print("Total de horas conectadas: "); 86 | int horas = scanner.nextInt(); 87 | 88 | System.out.print("Número de días laborales: "); 89 | int dias = scanner.nextInt(); 90 | 91 | int promedio = horas / dias; // Posible división por cero 92 | System.out.println("Promedio de horas por día: " + promedio); 93 | 94 | } catch (InputMismatchException e) { 95 | System.out.println("❌ Error: Debes ingresar un número entero válido."); 96 | } catch (ArithmeticException e) { 97 | System.out.println("❌ Error: No puedes dividir entre cero."); 98 | } catch (Exception e) { 99 | System.out.println("❌ Error inesperado: " + e.getMessage()); 100 | } finally { 101 | if (scanner != null) { 102 | scanner.close(); // Gestión adecuada del recurso 103 | System.out.println("📦 Recurso liberado correctamente."); 104 | } 105 | } 106 | } 107 | } 108 | ``` 109 | 110 | ### 💡 ¿Qué hicimos mejor? 111 | 112 | - Controlamos errores de entrada (`InputMismatchException`) 113 | - Evitamos caídas inesperadas por división entre cero 114 | - Liberamos el recurso `Scanner` con `finally` 115 | 116 | --- 117 | 118 | ## 🔄 ¿Qué aprendimos? 119 | 120 | ✅ Las excepciones permiten que el programa no se detenga bruscamente 121 | ✅ `try-catch-finally` ofrece estructura clara y flexible para manejar errores 122 | ✅ Diferenciar entre errores comunes y graves mejora la experiencia del usuario 123 | 124 | --- 125 | 126 | ## 💡 ¿Sabías que...? 127 | 128 | - En Java, el uso de `try-with-resources` es una evolución moderna que permite cerrar automáticamente ciertos recursos. 129 | - Puedes **encadenar múltiples bloques catch** para manejar diferentes tipos de error de forma específica. 130 | - Las buenas prácticas sugieren **no capturar `Exception` de forma genérica** a menos que sea estrictamente necesario. 131 | 132 | --- 133 | 134 | 📘 Recurso adicional: 135 | 🔗 https://www.w3schools.com/java/java_try_catch.asp 136 | 137 | --- 138 | 139 | ⬅️ [**Anterior**](../Ejemplo-03/Readme.md) | [**Siguiente**](../Ejemplo-05/Readme.md)➡️ 140 | 141 | -------------------------------------------------------------------------------- /Sesion-08/Ejemplo-05/Readme.md: -------------------------------------------------------------------------------- 1 | 2 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 08**](../Readme.md) ➡️ / 📖 `Ejemplo 05: Uso de throw, throws y excepciones personalizadas` 3 | 4 | --- 5 | 6 | ## 🎯 Objetivo 7 | 8 | ⚠️ Aplicar el uso de `throw`, `throws` y la creación de excepciones personalizadas en Java para manejar errores específicos del negocio, mejorando la claridad del código y la experiencia del usuario. 9 | 10 | --- 11 | 12 | ## 🧠 Recordemos 13 | 14 | En Java, puedes **crear y lanzar tus propias excepciones** cuando las situaciones de error no se ajustan a las clases de error predefinidas del lenguaje. 15 | 16 | #### 🔹 `throw` 17 | Se usa para **lanzar una excepción** desde una parte específica del código. 18 | 19 | #### 🔹 `throws` 20 | Se usa para **declarar** que un método puede lanzar una excepción, permitiendo que otro método sea responsable de manejarla. 21 | 22 | #### 🔹 Excepciones personalizadas 23 | Te permiten definir errores específicos para tu lógica de negocio, con nombres y mensajes claros. 24 | 25 | --- 26 | 27 | ## 💼 Ejemplo 28 | 29 | Imagina que trabajas como **Customer Experience (CX) Manager**. Estás desarrollando una herramienta interna que mide la satisfacción del cliente con base en encuestas (puntajes del 1 al 5). Si alguien ingresa un valor fuera de rango, quieres lanzar una excepción personalizada llamada `CalificacionInvalidaException`. 30 | 31 | Esto permite que otros desarrolladores del equipo comprendan de inmediato qué está ocurriendo sin depender de mensajes genéricos o errores del sistema. 32 | 33 | --- 34 | 35 | ### 💻 Código completo 36 | 37 | ```java 38 | // Paso 1: Crear la excepción personalizada 39 | public class CalificacionInvalidaException extends Exception { 40 | public CalificacionInvalidaException(String mensaje) { 41 | super(mensaje); 42 | } 43 | } 44 | ``` 45 | 46 | ```java 47 | // Paso 2: Clase que lanza la excepción 48 | public class EncuestaSatisfaccion { 49 | 50 | // Este método valida que la calificación esté entre 1 y 5 51 | public static void registrarCalificacion(int calificacion) throws CalificacionInvalidaException { 52 | if (calificacion < 1 || calificacion > 5) { 53 | throw new CalificacionInvalidaException("La calificación debe estar entre 1 y 5."); 54 | } 55 | 56 | System.out.println("✅ Calificación registrada: " + calificacion); 57 | } 58 | } 59 | ``` 60 | 61 | ```java 62 | // Paso 3: Clase principal que maneja la excepción 63 | import java.util.Scanner; 64 | 65 | public class CXManagerApp { 66 | public static void main(String[] args) { 67 | Scanner scanner = new Scanner(System.in); 68 | 69 | try { 70 | System.out.print("Ingrese la calificación del cliente (1 a 5): "); 71 | int input = scanner.nextInt(); 72 | 73 | EncuestaSatisfaccion.registrarCalificacion(input); 74 | 75 | } catch (CalificacionInvalidaException e) { 76 | System.out.println("❌ Error de validación: " + e.getMessage()); 77 | 78 | } catch (Exception e) { 79 | System.out.println("❌ Error inesperado: " + e.getMessage()); 80 | 81 | } finally { 82 | scanner.close(); 83 | System.out.println("📦 Recurso liberado correctamente."); 84 | } 85 | } 86 | } 87 | ``` 88 | 89 | ### 🧠 ¿Qué hicimos? 90 | 91 | - Creamos una clase de excepción personalizada para casos específicos 92 | - Lanzamos la excepción con `throw` dentro del método que valida 93 | - Declaramos el uso de `throws` para advertir que ese método puede fallar 94 | - Capturamos y mostramos el error de manera clara y amigable 95 | 96 | --- 97 | 98 | ## 🔄 ¿Qué aprendimos? 99 | 100 | ✅ `throw` sirve para **lanzar** errores personalizados 101 | ✅ `throws` sirve para **declarar** que un método puede lanzar errores 102 | ✅ Las excepciones personalizadas hacen el código más **legible, mantenible y profesional** 103 | 104 | --- 105 | 106 | ## 💡 ¿Sabías que...? 107 | 108 | - Muchas API modernas utilizan excepciones personalizadas para representar errores del negocio como `PagoInvalidoException`, `UsuarioNoAutorizadoException`, etc. 109 | 110 | - Un buen mensaje de error puede ser la diferencia entre una buena y una mala experiencia para otros desarrolladores o usuarios. 111 | 112 | --- 113 | 114 | 📘 Recurso recomendado: 115 | 🔗 https://www.baeldung.com/java-new-custom-exception 116 | 117 | --- 118 | 119 | ⬅️ [**Anterior**](../Ejemplo-04/Readme.md) | [**Siguiente**](../Reto-02/Readme.md)➡️ -------------------------------------------------------------------------------- /Sesion-08/Imagenes/S00.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-08/Imagenes/S00.jpg -------------------------------------------------------------------------------- /Sesion-08/Imagenes/S08.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-08/Imagenes/S08.jpg -------------------------------------------------------------------------------- /Sesion-08/Imagenes/S08_Fig01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-08/Imagenes/S08_Fig01.jpg -------------------------------------------------------------------------------- /Sesion-08/Imagenes/S08_Fig02.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-08/Imagenes/S08_Fig02.jpg -------------------------------------------------------------------------------- /Sesion-08/Imagenes/S08_Fig03.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-08/Imagenes/S08_Fig03.jpg -------------------------------------------------------------------------------- /Sesion-08/Imagenes/S08_Fig04.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-08/Imagenes/S08_Fig04.jpg -------------------------------------------------------------------------------- /Sesion-08/Imagenes/S08_Fig05.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-08/Imagenes/S08_Fig05.jpg -------------------------------------------------------------------------------- /Sesion-08/Imagenes/S08_Fig06.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-08/Imagenes/S08_Fig06.png -------------------------------------------------------------------------------- /Sesion-08/Imagenes/S08_Fig07.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-08/Imagenes/S08_Fig07.jpg -------------------------------------------------------------------------------- /Sesion-08/Readme.md: -------------------------------------------------------------------------------- 1 | 🏠 [**Inicio**](../Readme.md) ➡️ / 📖 `Sesión 08` 2 | 3 |
4 | Sesion_08 5 |
6 | 7 | ## 🎯 Objetivo 8 | 9 | ⚒️ Aprender a **escribir código limpio, robusto y mantenible** en Java aplicando principios SOLID, detectando y eliminando code smells, optimizando rendimiento y utilizando adecuadamente el **manejo de excepciones** (`try-catch`, `throw`, `throws`) y excepciones personalizadas. 10 | 11 | --- 12 | 13 | 📘 Material del prework: 14 | 15 | Antes de comenzar con los ejercicios de esta sesión, recordemos que en el material de prework hemos cubierto los fundamentos teóricos que aplicaremos hoy. A lo largo de esta sesión, pondremos en práctica estos conceptos mediante una serie de ejercicios y retos diseñados para reforzar y validar nuestro entendimiento. 16 | 🔥¡Vamos a comenzar!🔥 17 | 18 | --- 19 | 20 | ## 📂 Temas de la sesión... 21 | 22 | 23 | ### 📖 Refactorización y code smells 24 | 25 | Refactorizar es mejorar la estructura del código sin cambiar su funcionalidad. Los **code smells** son señales de que algo no está bien. 26 | 27 | - Código duplicado, funciones largas, nombres confusos 28 | - Eliminación de código muerto 29 | - Buenas prácticas para simplificar y reutilizar 30 | 31 | ##### 📜 **[Ejemplo 01: Refactorización y code smells](Ejemplo-01/Readme.md)** 32 | 33 | --- 34 | 35 | ### 📖 Principios SOLID en Java 36 | 37 | Los principios **SOLID** son la base para escribir código orientado a objetos que sea escalable y fácil de mantener. 38 | 39 | - SRP, OCP, LSP, ISP, DIP 40 | - Aplicación con ejemplos cotidianos 41 | 42 | ##### 📜 **[Ejemplo 02: Principios SOLID en Java](Ejemplo-02/Readme.md)** 43 | ##### 🔥 **[Reto 01: Motor de lógica narrativa ](Reto-01/Readme.md)** 44 | 45 | --- 46 | 47 | ### 📖 Técnicas para mejorar el rendimiento 48 | 49 | Escribir código eficiente mejora la experiencia del usuario y reduce el consumo de recursos. 50 | 51 | - Uso adecuado de estructuras (`ArrayList`, `HashMap`, `HashSet`) 52 | - Reducción de complejidad en métodos 53 | - Gestión de memoria y recursos 54 | 55 | ##### 📜 **[Ejemplo 03: Técnicas para mejorar el rendimiento](Ejemplo-03/Readme.md)** 56 | 57 | --- 58 | 59 | ### 📖 Manejo de excepciones con `try-catch-finally` 60 | 61 | Las **excepciones** permiten manejar errores de forma segura y controlada. 62 | 63 | - Tipos: `checked` y `unchecked` 64 | - Estructura `try-catch-finally` 65 | - Evitar que el programa se caiga inesperadamente 66 | 67 | ##### 📜 **[Ejemplo 04: Manejo de excepciones con try-catch-finally](Ejemplo-04/Readme.md)** 68 | 69 | --- 70 | 71 | ### 📖 Uso de `throw`, `throws` y excepciones personalizadas 72 | 73 | Cuando las excepciones predefinidas no son suficientes, puedes crear las tuyas propias. 74 | 75 | - `throw`: lanzar una excepción 76 | - `throws`: declarar que un método puede lanzar una excepción 77 | - Excepciones personalizadas 78 | 79 | ##### 📜 **[Ejemplo 05: Uso de throw, throws y excepciones personalizadas](Ejemplo-05/Readme.md)** 80 | ##### 🔥 **[Reto 02: Monitoreo de consumo de recursos en servidores ](Reto-02/Readme.md)** 81 | 82 | --- 83 | 84 | 85 | ⬅️ [**Anterior**](../Readme.md) | [**Siguiente**](../Sesion-09/Readme.md)➡️ 86 | -------------------------------------------------------------------------------- /Sesion-08/Reto-01/Readme.md: -------------------------------------------------------------------------------- 1 | 2 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 08**](../Readme.md) ➡️ / ⚡`Reto 01: Motor de lógica narrativa` 3 | 4 | --- 5 | 6 | ## 🎯 Objetivo 7 | 8 | 🧠 Aplicar **refactorización** y los **principios SOLID** en un caso práctico relacionado con videojuegos narrativos, separando responsabilidades y utilizando interfaces para lograr un sistema escalable y mantenible. 9 | 10 | --- 11 | 12 | ## 📝 Instrucciones 13 | 14 | 🎮 Imagina que formas parte del equipo de desarrollo de un videojuego narrativo. Actualmente, una clase `Narrador` concentra toda la lógica de decisiones, transiciones de historia y los diálogos, lo que dificulta su mantenimiento y evolución. 15 | 16 | Tu misión será **refactorizar este motor narrativo** para aplicar buenas prácticas de diseño orientado a objetos. 17 | 18 | ### 🧩 Actividades 19 | 20 | 1. Crea una clase principal llamada `MainNarrativa` que simule el flujo de una escena narrativa. 21 | 2. Refactoriza el diseño original (una clase gigante llamada `Narrador`) dividiendo responsabilidades en al menos estas tres interfaces: 22 | - `TransicionHistoria`: para definir cómo se pasa de una escena a otra. 23 | - `GestorDialogo`: para imprimir o manejar diálogos. 24 | - `LogicaDecision`: para tomar decisiones según la acción del jugador. 25 | 3. Implementa una clase por cada interfaz que cumpla una responsabilidad específica. Puedes usar nombres como `TransicionSimple`, `DialogoTexto`, `DecisionBinaria`, etc. 26 | 4. Usa inyección de dependencias para que la clase principal dependa solo de las interfaces (DIP). 27 | 5. Aplica también el principio OCP: las clases deben estar abiertas a extenderse (nuevas transiciones, nuevos diálogos) pero cerradas a modificaciones. 28 | 6. Ejecuta una simulación simple donde el usuario toma una decisión y el sistema responde con una transición de historia y un diálogo. 29 | 30 | --- 31 | 32 | ## 💡 Tip 33 | 34 | ✅ Si tienes dudas sobre cómo dividir responsabilidades, piensa en una obra de teatro: 35 | - El **narrador** solo cuenta lo que pasa. 36 | - Los **actores** solo dicen su diálogo. 37 | - El **guión** decide qué sucede según lo que hagan los personajes. 38 | 39 | --- 40 | 41 | 📘 ¿Quieres repasar los principios SOLID antes de resolver el reto? 42 | 🔗 [Guía de SOLID en Baeldung (en inglés)](https://www.baeldung.com/solid-principles) 43 | 44 | --- 45 | 46 | 🏆 ¡Este reto te ayudará a practicar una de las habilidades más valiosas en desarrollo de software profesional: el diseño limpio y mantenible! 47 | 48 | --- 49 | ⬅️ [**Anterior**](../Ejemplo-02/Readme.md) | [**Siguiente**](../Ejemplo-03/Readme.md)➡️ 50 | -------------------------------------------------------------------------------- /Sesion-08/Reto-02/Readme.md: -------------------------------------------------------------------------------- 1 | 2 | 🏠 [**Inicio**](../../Readme.md) ➡️ / 📖 [**Sesión 08**](../Readme.md) ➡️ / ⚡`Reto 02: Monitoreo de consumo de recursos en servidores` 3 | 4 | --- 5 | 6 | ## 🎯 Objetivo 7 | 8 | 🧠 Desarrollar una herramienta en Java que permita leer registros de consumo de CPU por servidor, identifique duplicados, valide entradas numéricas y lance una excepción personalizada si se supera un umbral crítico. Se deben aplicar las buenas prácticas de rendimiento, manejo de errores y excepciones personalizadas. 9 | 10 | --- 11 | 12 | ## 📝 Instrucciones 13 | 14 | 🚀 Imagina que trabajas como **DevOps Engineer** en una empresa de servicios financieros. Tu tarea es crear una utilidad para el monitoreo de servidores. 15 | 16 | ### 🧩 Actividades 17 | 18 | 1. Crea una clase principal llamada `MonitorCPU` donde se ejecuta el flujo general. 19 | 2. Solicita al usuario ingresar el consumo de CPU de varios servidores (valores en porcentaje). 20 | 3. Aplica validación: 21 | - El valor debe ser numérico. 22 | - No se deben permitir registros duplicados (usa `HashSet`). 23 | - No se permiten valores negativos ni mayores a 100%. 24 | 4. Si el valor ingresado es mayor a 95%, lanza una excepción personalizada llamada `ConsumoCriticoException`. 25 | 5. Muestra mensajes informativos en consola si hay errores o si todo marcha correctamente. 26 | 6. Cierra cualquier recurso utilizado adecuadamente (`finally`). 27 | 7. Puedes simular la entrada con datos fijos o usando `Scanner`. 28 | 29 | --- 30 | 31 | ## 💡 Tip 32 | 33 | ✅ Recuerda que una excepción personalizada debe: 34 | - Heredar de `Exception` (checked). 35 | - Tener un constructor que reciba un mensaje. 36 | 37 | --- 38 | 39 | 📘 Recurso de apoyo: 40 | 🔗 [Guía rápida de manejo de excepciones en Java – W3Schools](https://www.w3schools.com/java/java_try_catch.asp) 41 | 42 | --- 43 | 44 | 🏁 Este reto pone a prueba tu capacidad para integrar distintos enfoques de desarrollo limpio y seguro en un contexto real de automatización de infraestructura. 45 | 46 | ⬅️ [**Anterior**](../Ejemplo-05/Readme.md) | [**Siguiente**](../../Sesion-09/Readme.md)➡️ 47 | -------------------------------------------------------------------------------- /Sesion-09/Imagenes/S00.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-09/Imagenes/S00.jpg -------------------------------------------------------------------------------- /Sesion-10/Imagenes/S00.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/beduExpert/Java-Standar-Edition-1-2025/3d635c188c7a9dece32760392421ef202a9d4e6a/Sesion-10/Imagenes/S00.jpg --------------------------------------------------------------------------------