> For the complete documentation index, see [llms.txt](https://chubu.gitbook.io/chubu/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://chubu.gitbook.io/chubu/less-than.-coding-greater-than/programacion-orientada-a-objetos-pt1.md).

# Programación orientada a objetos (pt1)

pequeña explicacion de los principios basicos:

<mark style="color:$warning;">**Herencia**</mark>**:** En Python, la herencia permite crear una clase nueva a partir de otra clase existente. La nueva clase hereda atributos y métodos de la clase original, lo que evita repetir código y facilita ampliar funcionalidades. Por ejemplo, una clase `Perro` puede heredar de `Animal` y reutilizar sus características básicas.

<mark style="color:$warning;">**Cohesión**</mark>**:** En una clase de Python, la cohesión significa que todos sus atributos y métodos deben estar relacionados con una sola responsabilidad. Por ejemplo, una clase `Usuario` debería encargarse de datos y acciones del usuario, no de procesar pagos o enviar reportes. Esto hace el código más claro y ordenado.

<mark style="color:$warning;">**Abstracción**</mark>**:** En Python, la abstracción consiste en diseñar clases mostrando solo lo importante para usarlas, mientras se ocultan detalles internos. Por ejemplo, una clase `Auto` puede tener un método `arrancar()` sin que el usuario necesite saber cómo funciona internamente el motor.

<mark style="color:$warning;">**Polimorfismo**</mark>**:** En Python, el polimorfismo permite que diferentes clases usen el mismo método con comportamientos distintos. Por ejemplo, las clases `Perro` y `Gato` pueden tener el método `hacer_sonido()`, pero cada una devolverá un resultado diferente.

<mark style="color:$warning;">**Acoplamiento**</mark>**:** En Python, el acoplamiento mide cuánto depende una clase de otra. Si una clase necesita demasiados detalles de otra para funcionar, el acoplamiento es alto. Lo ideal es que las clases interactúen lo necesario, pero manteniendo independencia para facilitar cambios futuros.

<mark style="color:$warning;">**Encapsulamiento**</mark>**:** En Python, el encapsulamiento consiste en proteger los atributos internos de una clase y controlar su acceso mediante métodos. Por ejemplo, un atributo como `__saldo` puede mantenerse privado y modificarse solo mediante métodos como `depositar()` o `retirar()`.

### Herencia:

```python
class Animal:
    def hablar(self):
        print("Hace un sonido")

class Perro(Animal):
    def ladrar(self):
        print("Guau")

p = Perro()
p.hablar()   # heredado de Animal
p.ladrar()
```

### Cohesión:

```py
class Calculadora:
    def sumar(self, a, b):
        return a + b

    def restar(self, a, b):
        return a - b
```

> Esta clase tiene cohesión porque todos sus métodos están relacionados con cálculos matemáticos.

### Abstracción:

```py
class Auto:
    def arrancar(self):
        print("El auto arrancó")

mi_auto = Auto()
mi_auto.arrancar()
```

> El usuario usa `arrancar()` sin conocer cómo funciona internamente el motor.

### Polimorfismo:

```python
class Perro:
    def sonido(self):
        print("Guau")

class Gato:
    def sonido(self):
        print("Miau")

def hacer_sonar(animal):
    animal.sonido()

hacer_sonar(Perro())
hacer_sonar(Gato())
```

### Acoplamiento:

```py
class Motor:
    def encender(self):
        print("Motor encendido")

class Auto:
    def __init__(self, motor):
        self.motor = motor

    def arrancar(self):
        self.motor.encender()

motor = Motor()
auto = Auto(motor)
auto.arrancar()
```

> Hay bajo acoplamiento porque `Auto` recibe el motor desde afuera.

### Encapsulamiento:

```py
class CuentaBancaria:
    def __init__(self):
        self.__saldo = 0

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

    def ver_saldo(self):
        return self.__saldo

cuenta = CuentaBancaria()
cuenta.depositar(100)
print(cuenta.ver_saldo())
```

> `__saldo` está protegido y no debe modificarse directamente desde fuera de la clase.

En resumen, la programación orientada a objetos (POO) se basa en principios que ayudan a organizar y reutilizar código de forma eficiente. **La herencia** permite que una clase tome atributos y métodos de otra, evitando repetir código. **La cohesión** busca que cada clase tenga una responsabilidad clara y relacionada. **La abstracción** consiste en mostrar solo lo necesario y ocultar la complejidad interna. **El polimorfismo** permite usar una misma interfaz para diferentes comportamientos según el objeto. **El acoplamiento** mide qué tanto dependen unas clases de otras, siendo mejor mantener dependencias bajas. **El encapsulamiento** protege los datos internos de un objeto y controla su acceso mediante métodos definidos.