objetos

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
'''
OOP o POO programación orientada a objetos es un paradigma de programación
clase: es una abstracción (sustantivo común)
objeto: es un elemento particular de una clase (sustantivo propio). Se
suele decir que un objeto es una instancia de clase

Ej: clase pais, objeto: Argentina
clase perro objeto: mi perro Sultàn

propiedades: son aquellas cosas que definen a un objeto (adjetivos)
Ej: objeto Sultán tiene color, edad, altura, peso (atributos)

acciones: cosas que pueden hacer los objetos (verbos) (métodos)
Ej: Sultán puede ladrar, mover la cola, comer, correr, etc


# 1) defino una clase
class Perro:
    # atributo de clase
    especie = "Canis familiaris"

    def __init__(self,nombre,edad):
        self.nombre = nombre
        self.edad = edad

# creo dos instancias de clase
sultan = Perro("Sultan",7)
firulai = Perro("Firulai",5)

# imprimo el nombre del objeto sultán
print(sultan.nombre)

# los objetos son mutables por default
sultan.especie = "Marca Perro"
print(sultan.especie)
print(firulai.especie)


# 2) Reescribamos la clase perro con métodos
class Perro:
    # atributo de clase
    especie = "Canis familiaris"

    def __init__(self,nombre,edad):
        """Crea los atributos de una instancia"""
        self.nombre = nombre
        self.edad = edad

    def descripcion(self):
        """Crea un método que describe al objeto"""
        return f"{self.nombre} tiene {self.edad} años"

    def ladra(self, sonido):
        """Muestra lo que ladra un perro"""
        return f"{self.nombre} dijo {sonido}"

tronco = Perro("Tronco",4)
print(tronco.descripcion())
print(tronco.ladra("Woof woof"))



# 3) reescribamos con un método mágico
class Perro:
    # atributo de clase
    especie = "Canis familiaris"

    def __init__(self,nombre,edad):
        """Crea los atributos de una instancia"""
        self.nombre = nombre
        self.edad = edad

    def __str__(self):
        """Muestra la descripción que describe al objeto"""
        return f"{self.nombre} tiene {self.edad} años"

    def ladra(self, sonido):
        """Muestra lo que ladra un perro"""
        return f"{self.nombre} dijo {sonido}"


tronco = Perro("Tronco",4)
print(tronco)
print(tronco.ladra("Guau guau"))


# 4) Herencia

# Herencia es el proceso por el cual una clase asume los atributos  y los
# métodos de otra clase denominada padre o principal

# las clases secundarias pueden ampliar y/o modificar las clases primarias
# Ej: un padre que habla español tiene un hijo que solo hable ingles o
# hable inglés y español

# Veamos la necesidad de herencia.
# 4a)Modifico la clase Perro ante la necesidad de añadir la raza
class Perro:
    # atributo de clase
    especie = "Canis familiaris"

    def __init__(self,nombre,edad,raza):
        """Crea los atributos de una instancia"""
        self.nombre = nombre
        self.edad = edad
        self.raza = raza

    def __str__(self):
        """Muestra la descripción que describe al objeto"""
        return f"{self.nombre} tiene {self.edad} años"

    def ladra(self, sonido):
        """Muestra lo que ladra un perro"""
        return f"{self.nombre} dijo {sonido}"

miles = Perro("Miles",4,"Jack Russell Terrier")
buddy = Perro("Buddy",3,"Dachshund")
jack = Perro("Jack",6,"Bulldog")
jim = Perro("Jim",5,"Bulldog")

print(buddy.ladra("Yap"))
print(jack.ladra("Guau"))
print(jim.ladra("Guau")) # repetitivo -> "Guau" es un atributo de una raza



# 4b)reescribo con herencia
class Perro:
    # atributo de clase
    especie = "Canis familiaris"

    def __init__(self,nombre,edad):
        """Crea los atributos de una instancia"""
        self.nombre = nombre
        self.edad = edad

    def __str__(self):
        """Muestra la descripción que describe al objeto"""
        return f"{self.nombre} tiene {self.edad} años"

    def ladra(self, sonido):
        """Muestra lo que ladra un perro"""
        return f"{self.nombre} dijo {sonido}"

# clases hijas:
class Bulldog(Perro):
    def ladra(self, sonido="Guau"):
        # método heredado de la clase padre
        return f"{self.nombre} dijo {sonido}"

class JackRusellTerrier(Perro):
    def ladra(self, sonido="Arf"):
        return f"{self.nombre} dijo {sonido}"

# instanciamos
miles = JackRusellTerrier("Miles",4)
jack = Bulldog("Jack",6)
jim = Bulldog("Jim",5)

print(jack.ladra())
print(jim.ladra())
print(miles.ladra("No soy un bulldog"))



# 4c) Si un mètodo de la clase padre es modificado pueden surgir
# inconsistencias
# Si Perro cambia de
# f"{self.nombre} dijo {sonido}"  --> f"{self.nombre} gritó {sonido}"
# Las razas creadas despuès van a heredar la modificación y las
# creadas antes no, van a estar desactualizadas
# PARA ACTUALIZAR AUTOMATICAMENTE las clases hijas hay que escribirlas asì
class Perro:
    # atributo de clase
    especie = "Canis familiaris"

    def __init__(self,nombre,edad):
        """Crea los atributos de una instancia"""
        self.nombre = nombre
        self.edad = edad

    def __str__(self):
        """Muestra la descripción que describe al objeto"""
        return f"{self.nombre} tiene {self.edad} años"

    def ladra(self, sonido):
        """Muestra lo que ladra un perro"""
        return f"{self.nombre} dijo {sonido}"


class Bulldog(Perro):
    def ladra(self, sonido="Guau"):
        # método heredado de la clase padre
        return super().ladra(sonido)

class JackRusellTerrier(Perro):
    def ladra(self, sonido="Arf"):
        return super().ladra(sonido)


# instanciamos
miles = JackRusellTerrier("Miles",4)
jack = Bulldog("Jack",6)
jim = Bulldog("Jim",5)


print(jack.ladra())
print(jim.ladra())
print(miles.ladra("No soy un bulldog"))

class Perro:
    # atributo de clase
    especie = "Canis familiaris"

    def __init__(self,nombre,edad):
        """Crea los atributos de una instancia"""
        self.nombre = nombre
        self.edad = edad

    def __str__(self):
        """Muestra la descripción que describe al objeto"""
        return f"{self.nombre} tiene {self.edad} años"

    def ladra(self, sonido):
        """Muestra lo que ladra un perro"""
        return f"{self.nombre} GRITA {sonido}"

class Bulldog(Perro):
    def ladra(self, sonido="Guau"):
        # método heredado de la clase padre
        return super().ladra(sonido)

class JackRusellTerrier(Perro):
    def ladra(self, sonido="Arf"):
        return super().ladra(sonido)


miles = JackRusellTerrier("Miles",4)
jack = Bulldog("Jack",6)
jim = Bulldog("Jim",5)


print(jack.ladra())
print(jim.ladra())
print(miles.ladra("No soy un bulldog"))

'''
# POLIMORFISMO
# posibilita invocar un metodo de un objeto y podrá obtener distintos
# resultados según la clase
#

class Gato():
    def __init__(self,nombre):
        self.nombre = nombre

    def hablar(self):
        return "Miau"

class Perro():
    def __init__(self,nombre):
        self.nombre = nombre

    def hablar(self):
        return "Guau"

# Polimorfismo (con una función)
def EscucharMascota(animal):
    return animal.hablar()

cacho = Perro("Cacho")
fufu = Gato("Fufu")

print(f"Mi perro dice {EscucharMascota(cacho)}")
print(f"Mi gato dice {EscucharMascota(fufu)}")

# ejercicio: simular polimorfismo declarando primero una clase animal y
# luego otras clases perro y gato que hereden la propiedad de hablar

# HERENCIA MULTIPLE: un hijo hereda de varios padres
class ClaseA:
    def __init__(self):
        self.a = 1

    def mensaje(self):
        print("Soy A")

class ClaseB:
    def __init__(self):
        self.a = 2

    def mensaje(self):
        print("Soy B")


class ClaseC:
    def __init__(self):
        self.a = 3

    def mensaje(self):
        print("Soy C")


class ClaseHija(ClaseA,ClaseB,ClaseC):
    pass

mi_objeto = ClaseHija()
print(mi_objeto.a) # imprime 1: ClaseA sobreescribe a ClaseB y a ClaseC
mi_objeto.mensaje() # imprime Soy A