Python-Oriented Object Programming OOP Basic - Examples - Clases, Herencia, Polimorfismo

Codigo:

class Lobo():
    especie='salvaje'
    def __init__(self,nombre):
        self.nombre=nombre

    def sonido(self):
        print("Auuuu!!!")

miLobo=Lobo("Solitario")
miLobo.sonido()
print(miLobo.especie)

 Step by Step:

1. Hemos utilizado la palabra "class" esta es una "keyword o reserved word" que sirve para crear una clase en esta caso llamado "Lobo".
2. Tenemos un atributo de objeto de clase (class object attribute) "especie" inicializada como "salvaje" de manera manual en la clase. Esta sera la misma para cualquier instancia de la clase.
3. Un metodo o funcion llamado __init__, el cual es un metodo magico que a su vez en python es el constructor, este inicializa los miembros de una clase
4. El metodo constructor recibe por parametro un atributo llamado "nombre". Normalmente los atributos que tomamos como argumento los inicializamos usando self.nombredelatributo
5. Observamos un metodo llamado "sonido"
6. Inicializamos una variable de tipo objeto llamada "miLobo" enviando como parametro el nombre "Solitario"
7. Invocamos el metodo "sonido" a partir del objeto "miLobo" 
8. Hemos impreso el tipo de especie invocando el objeto y el atributo.

Resumen grafico:

Resultado de la ejecucion del codigo:

Auuuu!!!
salvaje

 Codigo:

class Lobo():
    especie='salvaje'
    def __init__(self,nombre):
        self.nombre=nombre

    def sonido(self):
        print("Auuuu!!!")

    def hablar(self):
        print("Mi nombre es %s"%self.nombre)

miLobo=Lobo("Solitario")
miLobo.sonido()
print(miLobo.especie)
miLobo.hablar()

  Step by Step:

Hemos incluído, el metodo hablar (el lobo dira su nombre), por lo tanto invocamos el metodo
y posteriormente imprime en pantalla su nombre.

Es importante que al imprimir debe detallarse "self.nombre" debido a que el parametro fue inicializado de en el constructor lo que lo vuelve un parametro de tipo objeto.

 Resultado de la ejecucion del codigo:

Auuuu!!!
salvaje
Mi nombre es Solitario

Codigo:

class AumentoSalario():
    aumento=2000
    def __init__(self,sactual=100):
        self.sactual=sactual

    def get_nuevosalario(self):
        return self.sactual + self.aumento

salarioActual=int(input("Digite salario actual: "))
nuevosalario=AumentoSalario(salarioActual)
print(nuevosalario.aumento)
print(nuevosalario.get_nuevosalario())

 Step by Step:

1. Clase posee variable que sera simpre la misma llamada "aumento"
2. Metodo constructor posee una variable inicializada en 10
3. Metodo "get_nuevosalario" retorna el valor de la variable aumento + la variable "sactual"

Que pasa en el codigo que no es parte de la clase:

1. Se solicita al usuario brindar un numero, este se almacena en variable llamada salarioActual
2. Se instancia una variable de tipo objeto llamada "nuevoSalario", notese que como brindamos un parametro ("salarioActual") este ha sobrescrito el valor de la variable "sactual" en la clase.
3. Se imprime la variable del aumento
4. Se imprime el nuevo salario 

 Resultado de la ejecucion del codigo:

Digite salario actual: 3000
2000
5000 

Herencia:

class Animal:
    def __init__(self):
        print("Animal creado")

    def tipo(self):
        print("animal")

    def comer(self):
        print("Estoy comiendo")

class Lobo(Animal):
    def __init__(self):
        Animal.__init__(self)
        print("Lobo creado")

    def tipo(self):
        print("Soy un lobo")

myAnimal=Animal()
myAnimal.comer()
myAnimal.tipo()

miLobo=Lobo()
miLobo.comer()
miLobo.tipo()

 Explicacion:

Basicamente existe una clase Animal, con sus metodos llamados "tipo" y "comer". Sin embargo la clase es muy ambigua ya que existen varios tipos de animales, uno de ellos por ejemplo el lobo.

Si deseo crear un objeto llamado lobo, pensaria que es parte del objeto Animal. Por lo tanto podria heredar los metodos que ya tiene Animal para la creacion del objeto Lobo.

Entonces dentro de la clase Lobo, indico que es parte de la clase Animal, lo inicializo como tal y puedo acceder a los metodos de Animal. Si deseo sobrescribir o no utilizar algun metodo de Animal y que sea especifico para el lobo, recreo el metodo dentro de la clase Lobo con el nombre que ya poseia anteriormente el metodo en la clase Animal.

 Resultado de la ejecucion del codigo:

Animal creado
Estoy comiendo
animal
Animal creado
Lobo creado
Estoy comiendo
Soy un lobo

Polimorfismo:

class Casa:
    def get_valor(self):
        return 100    def comprar(self):
        print("Gracias por comprar casa")

class Carro:
    def get_valor(self):
        return 300    def comprar(self):
        print("Gracias por comprar carro")

#Funcion polimorfica --> no importa que objeto es, la funcion es aplicable

def comprar_bienes(objeto):
    if 200 > objeto.get_valor():
        objeto.comprar()

micasa=Casa()
comprar_bienes(micasa)

miCarro=Carro()
comprar_bienes(miCarro)

 Explicacion:

Tenemos 2 clases, "Casa" y "Carro", sin embargo una funcion que le es indiferente si el objeto es Casa o Carro, simplemente ejecutara el metodo respectivo, obviamente se espera que ese metodo se encuentre dentro del objeto que ha recibido por parametro.

 Resultado de la ejecucion del codigo:

 Gracias por comprar casa

 

 

 Otro ejemplo:

class Lobo():
    def __init__(self,name):
        self.name=name

    def sonido(self):
        return self.name + "...Auuuu!"
class Persona():
    def __init__(self,name):
        self.name=name

    def sonido(self):
        return self.name + "...Hola!"
def saludos(objeto):
    print(objeto.sonido())

miLobo=Lobo("Alfa")
miPersona=Persona("Lalo")

saludos(miLobo)
saludos(miPersona)

 Explicacion:

Existen 2 clases, "Lobo" y "Persona",  la funcion "Saludos" le es indiferente si el objeto que recibe por parametro es de tipo "Lobo" o  "Persona" , esta simplemente invoca el metodo sonido, la cual deberia estar en los objetos los cuales fueron enviados por parametro a la funcion saludos.

Resultado de la ejecucion del codigo:

Alfa...Auuuu!
Lalo...Hola!