Teoría: ¿Qué es la Programación Orientada a Objetos?

• Significa que diferentes objetos pueden tener un mismo método con el mismo nombre (por ejemplo hablar()), pero cada uno lo implementa a su manera.

Abstracción significa mostrar solo lo esencial y ocultar los detalles internos que no son necesarios para quien usa un objeto o sistema.

Es como decir:

“Solo te muestro lo que necesitás saber para usar esto, sin complicarte con cómo está hecho por dentro.”

📦 Ejemplo cotidiano: Una cafetera

🎯 Lo que ves (interfaz):

• Un botón de encendido

• Un botón de preparar café

• Una luz que indica que está listo

🔌 Lo que no ves (complejidad oculta):

• El sistema eléctrico

• Los sensores de temperatura

• Las resistencias y válvulas

• El software que regula el tiempo y la presión

Vos simplemente presionás “Preparar” y esperás tu café. Eso es abstracción: usar algo sin saber cómo está implementado por dentro.

🧑‍💻 Llevado a la programación:

Clase Cafetera (vista desde afuera):

class Cafetera:
    def encender(self):
        pass

    def preparar_cafe(self):
        pass

    def apagar(self):
        pass

Quien usa la clase (usuario = Cafetera()) solo ve esos métodos. No necesita saber cómo se calienta el agua ni cómo se dosifica el café. La lógica interna está “encapsulada” y oculta.

🚪 Otro ejemplo simple: una puerta

• Método público: abrir()

• Lo que no ves: el mecanismo interno de la cerradura, el resorte, la física de la bisagra.

🎯 ¿Por qué es útil la abstracción?

1. Hace tu código más fácil de usar y entender.

2. Permite cambiar la implementación sin romper el código que lo usa.

3. Fomenta el diseño de interfaces claras y coherentes.

📌 Diferencia clave en una frase:

La abstracción te dice qué hace un objeto.
El encapsulamiento te dice cómo lo protege internamente.

🧩 ¿Qué es Abstracción?

• Oculta la complejidad innecesaria y muestra solo lo esencial.

• Te permite usar un objeto sin conocer su implementación.

Ejemplo: Usar un control remoto para cambiar el canal.
No sabés qué pasa dentro del televisor, pero usás el botón cambiar_canal().

🔐 ¿Qué es Encapsulamiento?

• Agrupa datos y comportamientos dentro de una clase.

• Restringe el acceso directo a los datos internos (para protegerlos).

• Permite definir niveles de acceso: público, privado, protegido.

Ejemplo: Una caja fuerte con código.
El contenido está encapsulado y solo se accede mediante un método: abrir(codigo).

🧑‍💻 Ejemplo en código Python:

class CuentaBancaria:
    def __init__(self, titular, saldo):
        self.titular = titular
        self.__saldo = saldo  # atributo privado

    def depositar(self, monto):
        if monto > 0:
            self.__saldo += monto

    def ver_saldo(self):
        return self.__saldo

🔎 ¿Dónde está la abstracción?

• Vos usás depositar() o ver_saldo() sin saber cómo se manejan internamente.

🔐 ¿Dónde está el encapsulamiento?

• __saldo es un atributo privado. No podés modificarlo directamente desde afuera.

cuenta = CuentaBancaria("Ana", 1000)
cuenta.__saldo = 999999  # Esto no funciona

🧠 En resumen:

Actividades Guiadas

Ejercicio 1: Identificando Objetos

Situación: Sistema de una biblioteca

Pregunta: ¿Qué objetos identificás en una biblioteca?

Respuesta esperada:

• Libro: título, autor, ISBN, páginas → prestar(), devolver(), buscar()
• Usuario: nombre, ID → registrarse(), prestar_libro()
• Bibliotecario: nombre, ID, turno → gestionar_prestamos(), registrar_libro()

Ejercicio 2: Pensando en Atributos y Métodos

Situación: Sistema de una tienda online

Completa la siguiente tabla:

Objeto
Atributos
Métodos
Producto
  precio, nombre, stock, ...
  aplicar_descuento(), actualizar_stock(), ...
Cliente
  nombre, ...
  registrarse(), realizar_compra(), ...
Carrito
  productos, total, ...
  agregar_producto(), calcular_total(), ...
Pedido
  ...
  ...
Vendedor
  ...
  ...

Ejercicio 3: POO vs Procedural

Código Procedural:

# Variables globales
nombre = "Juan"
edad = 20
notas = [8, 7, 9]

def calcular_promedio(notas):
    return sum(notas) / len(notas)

def mostrar_info(nombre, edad, notas):
    promedio = calcular_promedio(notas)
    print(f"{nombre}, {edad} años, promedio: {promedio}")

¿Problemas que identificás?

• Datos dispersos
• Difícil de mantener con muchos estudiantes
• No hay relación clara entre datos y funciones
• Baja reutilización

Versión POO (conceptual):

class Estudiante:
    def __init__(self, nombre, edad, notas):
        self.nombre = nombre
        self.edad = edad
        self.notas = notas

    def calcular_promedio(self):
        return sum(self.notas)/len(self.notas)

Conceptos Clave de la Semana

Clase vs Objeto

• Clase: El "molde" o "plano" (como el plano de una casa)
• Objeto: La "instancia" específica (la casa construida)

Atributos vs Métodos

• Atributos: Las características o datos (color, tamaño, nombre)
• Métodos: Los comportamientos o acciones (calcular, mostrar, procesar)

Modelado del Mundo Real

La clave está en observar y abstraer:

1. ¿Qué cosas (objetos) hay en mi problema?
2. ¿Qué características (atributos) tienen?
3. ¿Qué acciones (métodos) pueden realizar?

Entregable de la Semana

Práctica: Análisis y Modelado de Sistema

Consigna: Elegí uno de los siguientes sistemas y realizá un análisis completo:

1. Sistema de gestión de un gimnasio
2. Sistema de reservas de un restaurante
3. Sistema de gestión de una veterinaria

Tu entregable debe incluir:

Parte 1: Identificación de Objetos (mínimo 4 objetos)

Objeto: Nombre del objeto
Descripción: Qué representa en el mundo real

Parte 2: Análisis Detallado (para cada objeto)

OBJETO: [Nombre]

ATRIBUTOS:
- atributo1: tipo de dato (descripción)
- atributo2: tipo de dato (descripción)
- ...

MÉTODOS:
- método1(): qué hace
- método2(): qué hace
- ...

RELACIONES:
- Cómo se relaciona con otros objetos

Parte 3: Casos de Uso (mínimo 3)

Caso de Uso: [Nombre]
Descripción: Qué sucede paso a paso
Objetos involucrados: Lista de objetos que participan

Ejemplo de formato esperado:

=== SISTEMA DE GESTIÓN DE GIMNASIO ===

OBJETO: Miembro

ATRIBUTOS:
- id: entero (identificador único)
- nombre: texto (nombre completo)
- email: texto (correo electrónico)
- fecha_inscripcion: fecha (cuándo se inscribió)
- plan: texto (tipo de membresía)
- activo: booleano (si la membresía está activa)

MÉTODOS:
- inscribirse(): registra nuevo miembro
- renovar_plan(): extiende la membresía
- cancelar_membresia(): desactiva la cuenta
- consultar_rutina(): obtiene rutina asignada

RELACIONES:
- Tiene una Rutina asignada
- Puede tener múltiples Pagos
- Usa Equipos del gimnasio

Caso de Uso: Nuevo miembro se inscribe al gimnasio
Descripción: 
1. El miembro llega al gimnasio
2. El recepcionista consulta planes disponibles
3. El miembro elige un plan y proporciona sus datos
4. El recepcionista registra al nuevo miembro
5. Se genera un pago por la inscripción
6. Se asigna una rutina básica al miembro

Objetos involucrados: Miembro, Recepcionista, Plan, Pago, Rutina

Evaluación de la Semana

¿Cómo saber si dominás los conceptos?

Deberías poder responder:

• ¿Qué ventajas tiene POO sobre programación procedural?
• ¿Cómo identificar objetos en un problema del mundo real?
• ¿Cuál es la diferencia entre clase y objeto?
• ¿Qué son los 4 pilares de la POO?

Si podés explicar estos conceptos con tus propias palabras y ejemplos, estás listo para la Semana 2.