Los 4 pilares de la programacion orientada a objetos

* Encapsulamiento:* Agrupa datos y métodos relacionados en una clase. * Oculta los detalles internos y controla el acceso a los datos. * Ejemplo: Una clase "Coche" que encapsula propiedades como "color" y métodos como "arrancar". * Abstracción:* Simplifica sistemas complejos ocultando detalles innecesarios. * Permite centrarse en las características esenciales de un objeto. * Ejemplo: Una interfaz "Vehículo" con método "mover", sin especificar cómo se implementa. * Herencia:* Permite que una clase (hija) herede propiedades y métodos de otra (padre). * Promueve la reutilización de código y la jerarquía de clases. * Ejemplo: "Coche" y "Moto" heredan de "Vehículo". * Polimorfismo:* Permite que objetos de diferentes clases respondan al mismo método de manera única. * Facilita el uso de una interfaz común para tipos de datos diversos. * Ejemplo: Diferentes tipos de "Vehículo" implementan el método "mover" de forma distinta.

Quisiera felicitar a la profesora por la excelente manera en que abordó el curso, explicando los conceptos de manera magistral. No obstante, los términos de abstracción y polimorfismo no fueron definidos con precisión. La abstracción puede aplicarse tanto a nivel de clases como de métodos. Las clases que heredan de clases abstractas o que contienen métodos abstractos están obligadas a implementar estos métodos, funcionando como un contrato de desarrollo entre equipos de programación. Además, el polimorfismo se apoya en la abstracción para referenciar los métodos implementados en las clases derivadas. Por último, considero que faltó un mayor detalle en la explicación de la sobreescritura de métodos. Buen curso

Carli me parece brillante, de verdad se nota que sabe muchisimo y la admiro por su conocimiento, pero siento que desde hace 3 clases estoy perdida de como emplear ciertas cosas.

```python #Excelente clase! Super dinámica. #Ejercicio Finalizado class Vehicle: def __init__(self,brand,model,price): #Encapsulación self.brand = brand self.model = model self.price = price self.is_available = True def sell(self): if self.is_available: self.is_available = False print(f"El vehiculo {self.brand}. Ha sido vendido.") else: print(f"El vehiculo {self.brand}. No está vendido.") #Abstracción def check_available(self): return self.is_available #Abstracción def get_price(self): return self.price def start_engine(self): raise NotImplementedError("Este método debe ser implementado por la subclase") def stop_engine(self): raise NotImplementedError("Este método debe ser implementado por la subclase") #Herencia class Car(Vehicle): #Polimorfismo def start_engine(self): if not self.is_available: return f"El motor del coche {self.brand} está en marcha." else: return f"El coche {self.brand} no está disponible." #Polimorfismo def stop_engine(self): if not self.is_available: return f"El motor del coche {self.brand} se ha detenido." else: return f"El coche {self.brand} no está disponible." class Bike(Vehicle): def start_engine(self): if not self.is_available: return f"La bicicleta {self.brand} está en marcha." else: return f"La bicicleta {self.brand} no está disponible." def stop_engine(self): if not self.is_available: return f"La bicicleta {self.brand} se ha detenido." else: return f"La bicicleta {self.brand} no está disponible." class Truck(Vehicle): def start_engine(self): if not self.is_available: return f"El motor del camión {self.brand} está en marcha." else: return f"El camión {self.brand} no está disponible." def stop_engine(self): if not self.is_available: return f"El motor del camión {self.brand} se ha detenido." else: return f"El camión {self.brand} no está disponible." class Customer: def __init__(self,name): self.name = name self.purchased_vehicles = [] def buy_vehicle(self, vehicle: Vehicle): if vehicle.check_available(): vehicle.sell() self.purchased_vehicles.append(vehicle) else: print(f"Lo siento, {vehicle.brand} no está disponible.") def inquire_vehicle(self, vehicle: Vehicle): if vehicle.check_available(): availablity = "Disponible" else: availablity = "No disponible" print(f"El {vehicle.brand} está {availablity} y cuesta {vehicle.get_price()}.") class Dealership: def __init__(self): self.inventory = [] self.customers = [] def add_vehicles(self, vehicle: Vehicle): self.inventory.append(vehicle) print(f"El {vehicle.brand} ha sido añadido al inventario.") def register_customers(self, customer: Customer): self.customers.append(customer) print(f"El cliente {customer.name} ha sido añadido.") def show_available_vehicle(self): print("Vehiculos disponibles en la tienda") for vehicle in self.inventory: if vehicle.check_available(): print(f" - {vehicle.brand} por {vehicle.get_price()}.") car1 = Car("Toyota", "Corolla", 20000) bike1 = Bike("Yamaha","MT-07", 7000) truck1 = Truck("Volvo","FH16",80000) customer1 = Customer("Carlos") dealership = Dealership() dealership.add_vehicles(car1) dealership.add_vehicles(bike1) dealership.add_vehicles(truck1) #Mostrar vehiculos disponibles dealership.show_available_vehicle() #Cliente consultar un vehiculo customer1.inquire_vehicle(car1) #Cliente comprar un vehiculo customer1.buy_vehicle(car1) #Mostrar vehiculos disponibles dealership.show_available_vehicle() ```

### Resumen * **Abstracción**: Simplificación de un sistema complejo mediante la modelación de clases adecuadas. * **Encapsulamiento**: Ocultación de los detalles internos y exposición de una interfaz pública. * **Herencia**: Creación de nuevas clases basadas en clases existentes, heredando sus atributos y métodos. * **Polimorfismo**: Capacidad de tratar diferentes clases como instancias de una misma clase base a través de una interfaz común.

Esto me ayudo a aclarar dudas respecto al polimorfismo, ya que era el pilar mas abstracto para mi. :D ## `Ventajas del Polimorfismo:` 1. `Abstracción y Estructuración del Código``:` * `El polimorfismo permite definir una interfaz común para diferentes clases, lo que facilita la abstracción y la estructuración del código.` * `Las clases pueden compartir una interfaz común (como un método) sin preocuparse por los detalles de implementación.` 2. `Flexibilidad y Extensibilidad``:` * `El polimorfismo permite agregar nuevas clases o subclases sin afectar el código existente.` * `Puedes introducir nuevas funcionalidades sin cambiar el código que utiliza la interfaz común.` 3. `Legibilidad y Mantenibilidad``:` * `El uso de polimorfismo hace que el código sea más legible y fácil de mantener.` * `Las clases que comparten una interfaz común son más intuitivas y coherentes.` ## `Desventajas del Polimorfismo:` 1. `Overhead de Rendimiento``:` * `En algunos casos, el polimorfismo puede tener un pequeño impacto en el rendimiento debido a la resolución dinámica de métodos.` * `Sin embargo, en la mayoría de las aplicaciones, este impacto es insignificante y no debe ser una preocupación.` 2. `Complejidad Adicional``:` * `El polimorfismo puede aumentar la complejidad del código, especialmente cuando se utilizan jerarquías de clases extensas.` * `Es importante diseñar cuidadosamente las relaciones entre clases y métodos para evitar confusiones.` ## `Comparación con el Uso de un Diccionario:` * `Polimorfismo``:` * `Proporciona una estructura más natural y orientada a objetos.` * `Permite que las clases compartan una interfaz común y tengan implementaciones específicas.` * `Es más adecuado cuando las clases tienen comportamientos más complejos y no se pueden reducir a simples pares clave-valor.` * `Diccionario``:` * `Es útil cuando necesitas una asignación directa entre claves y valores.` * `Puede ser más eficiente en términos de acceso a datos (búsqueda por clave).` * `Es menos flexible en términos de comportamiento y no permite la herencia o la abstracción.` `En resumen, el polimorfismo es una herramienta poderosa para diseñar sistemas más flexibles y mantenibles. Siempre debes elegir la opción que mejor se adapte a tus necesidades específicas y al diseño general de tu aplicación.`

Los cuatro pilares de la Programación Orientada a Objetos (POO) son los principios fundamentales que guían este paradigma de programación. Son esenciales para entender cómo organizar y estructurar programas de manera más eficiente y modular. La abstracción consiste en representar los elementos más importantes de un objeto y ocultar los detalles innecesarios El encapsulamiento es el principio de restringir el acceso directo a los datos de un objeto y permitir interactuar con ellos a través de métodos controlados. La herencia permite crear nuevas clases basadas en clases existentes, heredando sus atributos y métodos. Esto promueve la reutilización de código y hace más fácil extender las funcionalidades sin necesidad de reescribir todo desde cero El polimorfismo es la capacidad de que un mismo método pueda tener diferentes comportamientos según el contexto

**Ejemplo: Sistema de Cuentas Bancarias** Imaginemos que estamos desarrollando un sistema bancario donde tenemos diferentes tipos de cuentas (como cuenta de ahorros y cuenta corriente), y queremos manejar operaciones financieras como depósitos, retiros y transferencias. Vamos a aplicar los cuatro pilares de la POO en este contexto: **1. Encapsulamiento:** * Creamos una clase **CuentaBancaria** que tiene atributos privados como saldo y titular, y solo podemos interactuar con ellos a través de métodos públicos. * Estos métodos pueden ser depositar() y retirar(), los cuales controlan cómo se actualiza el saldo. De esta forma, el **saldo** está protegido y no puede ser modificado directamente desde fuera de la clase.**Ejemplo: Sistema de Cuentas Bancarias**  Aquí, estamos **encapsulando** los datos sensibles (el saldo y el titular), permitiendo que solo se modifiquen a través de los métodos `depositar()` y `retirar()`, asegurando que las reglas de negocio se respeten. \----- ### 2. **Abstracción**: * Podemos crear una clase abstracta **Cuenta** que defina métodos comunes para todas las cuentas bancarias (como `depositar()` y `retirar()`), pero sin implementarlos. * Las clases derivadas, como **CuentaCorriente** y **CuentaDeAhorros**, implementarán estos métodos de manera específica.  La **abstracción** nos permite definir una estructura común sin especificar cómo se implementarán los métodos, dejando esa tarea a las clases hijas. \---- ### 3. **Herencia**: * Usamos herencia para crear clases especializadas como **CuentaCorriente** y **CuentaDeAhorros**, que heredan los atributos y métodos de la clase base **CuentaBancaria**, pero pueden tener comportamientos específicos. * Por ejemplo, una **CuentaCorriente** podría permitir sobregiros, mientras que una **CuentaDeAhorros** podría tener restricciones sobre los retiros.  Aquí, la clase **CuentaCorriente** hereda todo lo de **CuentaBancaria**, pero modifica el método `retirar()` para permitir un sobregiro. \---- ### 4. **Polimorfismo**: * Podemos usar polimorfismo para que ambas clases (CuentaCorriente y CuentaDeAhorros) tengan un método `retirar()`, pero cada uno funcione de forma diferente según el tipo de cuenta. * Por ejemplo, una **CuentaDeAhorros** puede no permitir sobregiros y tener límites de retiros al mes.  Aquí, el **polimorfismo** nos permite tener un mismo método (`retirar()`) con un comportamiento distinto dependiendo de si es una **CuentaCorriente** o una **CuentaDeAhorros**. \---- ### Resumen: * **Encapsulamiento**: Protegemos los datos sensibles (como el saldo) y definimos cómo interactuar con ellos. * **Abstracción**: Definimos métodos generales para todas las cuentas bancarias sin entrar en detalles de la implementación. * **Herencia**: Las cuentas específicas (como corriente y de ahorros) heredan atributos y comportamientos de una clase general (CuentaBancaria). * **Polimorfismo**: Permitimos que métodos como `retirar()` funcionen de manera diferente según el tipo de cuenta. Este ejemplo muestra cómo puedes usar POO para modelar un sistema bancario de manera modular, clara y segura. Aqui les dejo este ejemplo, a mi me ayudo mucho a entender los conceptos con una situacion que la mayoria vivimos en la vida real como lo es una cuenta bancaria. espero les sirva para afianzar estos conceptos. Gracias Carli por la forma como explicas y manejas las clases de verdad he aprendido como nunca.

Hay una confusión entre encapsulamiento y abstracción. **Abstracción:** En palabras simples es lo que hacemos cuando bajamos el problema de negocio a una definición en clases, estamos abstrayendo la funcionalidad a métodos simples. La abstracción NO es que atributos privados de un objeto no puedan verse desde un contexto publico. Abstracción es la reducción de un problema a un contrato con el cual nos comunicamos. **Encapsulamiento:** El encapsulamiento, SI es el ocultamiento de detalles internos de una clase/objeto, el hacer las propiedades de un objeto privadas y definir métodos para acceder o asignar valores a ellas si es encapsulamiento. Por ejemplo en una clase persona, el color de piel podría ser una propiedad publica mientras que el nombre y la edad no, y tendrías que preguntarle a esa persona esos datos, ya que son datos que solo ella conoce. Esto pasado a código es un caso de encapsulamiento.

Nuevamente con respecto a la pregunta de la clase pasada, dices que por el pilar de la Abstracción solo se puede acceder a los atributos por los métodos públicos, pero tu accedes a ellos sin uso del método, por ejemplo en el método show\_available\_vehicle cuando llamas vehicle.brand.

Haber estas ultimas clases con el ejercicio de la concesionaria estuvieron un tanto confusas se entiende q estamos haciendo lo mismo q el ejercicio de la biblioteca pero agregando herencias, y conceptos de POO, abstracción y polimorfismo los cuales creo q se podrían abordar de mejor manera con un poco mas de explicación detallada por ejemplo: En la herencia bicicleta ya no usamos un constructor si no q nos enfocamos en realizar las diferentes funciones q tiene esta clase ya que los atributos como son Marca. Precio y Modelo los tenemos en la clase principal y por lo tanto ya no es necesario volverlos a poner en la clase bicicleta para no redundar datos y así con las demás. Por otro lado creo q se entendería mejor estas ultimas 3 clases si estuvieran en un solo video y mejor estructurado, por lo demás al verlo varias veces y repasar los conceptos de los pilares de la POO ya se entiende muy bien todo el ejercicio y las cosas a las que se refiera la Profesora. No se si me di a entender pero lo explique lo mejor que puede es una sugerencia y disculpen cualquier error cometido en mi explicación gracias por leer

Los tres pilares de la programación orientada a objetos son: 1. **Abstracción**: Permite simplificar la complejidad al enfocarse solo en los aspectos relevantes del objeto, ocultando los detalles innecesarios. 2. **Encapsulamiento**: Protege el estado interno del objeto, permitiendo acceso a los atributos solo a través de métodos definidos, asegurando que la interacción sea controlada. 3. **Polimorfismo**: Permite que diferentes clases respondan a la misma interfaz de métodos, brindando flexibilidad y reutilización del código. Estos pilares son fundamentales para diseñar aplicaciones robustas y mantenibles.

👌🏼 Aplico muy bien el polimorfismo, porque la Bicicleta se convirtio en Motocicleta 🏍️ 😅

El polimorfismo en programación orientada a objetos permite que diferentes clases respondan a la misma acción de maneras distintas. Ejemplo con personas y animales: 1. Clase base: `Animal` con método `hacerSonido()`. 2. Clases derivadas: - `Perro` que implementa `hacerSonido()` como "guau". - `Gato` que implementa `hacerSonido()` como "miau". - `Persona` que implementa `hacerSonido()` como "habla". Al invocar `hacerSonido()` en una instancia de `Animal`, el comportamiento dependerá del tipo de objeto: un perro ladrará, un gato maullará y una persona hablará. Este concepto permite usar el mismo método para diferentes tipos de objetos y obtener resultados específicos.

Este lenguaje de programación no tiene campos/métodos privados/protegidos ¿Donde está la abstracción aquí? 

Hola, me costó un poco entender los 4 pilares de la POO, así que dejaré este comentario por si le sirve a alguien: 1. Herencia: Las clases hijas heredan todos los atributos y métodos de la clase padre, entonces si tengo la clase padre Animal((self, raza, peso, nombre, edad), las hijas Perro, Gato, Tigre, Hamster, etc también tendrán los atributos de Animal: self, raza, peso, nombre, edad 2. Encapsulamiento: Básicamente se definen variables privadas con "\_\_" antes del nombre de la variable. Si bien esta variable es privada y no puedo acceder a ella directamente con un print() por ejemplo, si puedo utilizarla en los métodos de la clase, y por ende, también puedo acceder a su valor, pero a través de un método, como sería obtener\_saldo. 3. Polimorfismo: En los métodos de la clase padre (abstractos) puedo indicar pass o tambien return "algo" para asignar valores por defecto, es decir, las clases hija PUEDEN O NO sobreescribir los métodos de la clase padre. Y puedo crear objetos de la clase padre 4. Abstracción: Es muy similar al polimorfismo, pero en los métodos debo si o si indicar pass porque su comportamiento es propio de cada clase hija. Además En las clases hija, DEBO SI O SI definir el comportamiento de los métodos que están en la clase padre, cada uno a su manera, pero es obligatorio, es decir, las clases hijas DEBEN implementar TODOS los métodos abstractos. Espero les sirva! (el otro comentario me quedó con un formato feisimo por eso lo reescribi)

Hola, me costó un poco entender los 4 pilares de la POO, así que dejaré este comentario por si le sirve a alguien: Herencia: Las clases hijas heredan todos los atributos y métodos de la clase padre, entonces si tengo la clase padre Animal, las hijas Perro, Gato, Tigre, Hamster, etc también tendrán los atributos de Animal (self, raza, peso, nombre, edad)```js class Animal: def __init__(self, raza, peso, nombre, edad) ```2. Polimorfismo: Si en la clase padre defino un método abstracto (ej: def hacer sonido(self):), indico que todos los animales PUEDEN hacer un sonido, pero no es obligatorio, por ende lo sigo de un pass o return, en caso de usar return sería un valor de saida por defecto. Las clases hijas puedne o no sobreescribir los métodos de la clase padre (en el ejemplo hacer sonido, puedo dejar el valor defecto o especificarlo). Puedo crear objetos de la clase padre 1.

Encapsulamiento en Python (Copilot) En Python, el encapsulamiento no es tan estricto como en Java o C++. Python utiliza convenciones de nombres para indicar que un atributo es privado, pero no impide completamente el acceso a estos atributos. Se utiliza un guion bajo doble (\_\_) para indicar que un atributo es privado, y Python aplica un renombramiento de atributos (name mangling) para dificultar el acceso directo. En el siguiente ejemplo se podria acceder al atributo privado utilizando un nombre renombrado. \# class Ejemplo: def \_\_init\_\_(self): self.publico = "Soy público" self.\_protegido = "Soy protegido" self.\_\_privado = "Soy privado" def mostrar\_privado(self): return self.\_\_privado obj = Ejemplo() print(obj.publico) # Soy público print(obj.\_protegido) # Soy protegido \#print(obj.\_\_privado) # AttributeError: 'Ejemplo' object has no attribute '\_\_privado' print(obj.mostrar\_privado()) # Soy privado

Mi aporte de estos conceptos en mis propias palabras: * **Herencia**: Una subclase hereda los atributos y métodos de la superclase. * **Encapsulamiento**: Hace privados los atributos de una clase, de tal manera que solo esa clase pueda acceder o modificarlos. * **Abstracción**: Mostrar solo los métodos más importantes de un objeto y ocultar detalles complicados de su implementación. * **Polimorfismo**: Permite que un mismo método actúe de manera diferente según el objeto que lo implemente.

Creo que se ha olvidado de registrar al cliente

fue algo complicado comprender el encapsulamiento en python, sobretodo si lo aprendiste en otro lenguaje, pero por lo que lei en python no existe el encansulamiento como tal, solo se puede ocultar los metodos y atributos usando un doble guion bajo (\_\_nombre\_metodo), para volverlo privado y que solo sea accesible para la clase que lo contiene

Debo admitir yo ya conocia estos 4 pace mucho tiempo y los entendia, pero la manera en la cual la profesora los explica, la hace entender super facil.

Me encanta la manera en que haz explicado, fue mucho más fácil entenderlo como lo explicaste tu a la forma que me enseñaron en la universidad. Muchas gracias!