Página inmutable History Adjuntos

Cursos/Principiantes/Parte6

Nombre de la página: Cursos / Principiantes / Parte6



Programación orientada a objetos

Luego de ver en la Parte5 todo lo básico que concierne a la orientación a objetos, ahora vamos a adentrarnos a algunas propiedades del paradigma así como la forma de hacerlo en python.

Herencia

La herencia es una de las propiedades más apreciadas de la programación orientada a objetos, permite a partir de clases básicas realizar construcciones de clases con funcionalidad adicional, siendo cada una de las clases hijas una especialización de la clase padre.

La forma de representar la herencia en python, se realiza de la siguiente forma:

   1 class Padre(objecto):
   2    
   3     def __init__(self, nombre):
   4          self.nombre = nombre
   5 
   6     def camina(self, direccion):
   7         print("El " + self.__class__.__name__ + " esta caminando.")
   8         
   9     
  10 class Hijo(Padre):
  11 
  12     def nada(self, direccion):
  13         print("El " + self.__class__.__name__ " esta nadando.")
  14       

Ahora la clase Hijo puede nadar y caminar, el padre nunca aprendió a nadar, lo importante a notar es que la herencia bien aplicada puede ofrecer muchos beneficios, estos son algunos: evitar repetir código, definir interfaces, especializar a funcionalidades inusuales en clases hijas en vez de contaminar la implementación original

En el caso anterior solamente se agrego un método no se sobre escribió ninguno, la sobre carga de métodos es una de las formas más comunes para construir sistemas complejos a partir de la herencia de clases, en python existe una función llama super, la cual regresa un objeto "Proxy" a las clases superiores de la instancia que se le indica.

Anteriormente o simplemente de hacia llamando a la clase padre y el la instancia como primer argumento, esto es un ejemplo:

   1 class Padre(objecto):
   2    
   3     def __init__(self, nombre):
   4          self.nombre = nombre
   5 
   6     def duerme(self):
   7         print("ZZZzzz...")
   8 
   9     def camina(self, direccion):
  10         print("El " + self.__class__.__name__ + " esta caminando.")
  11         
  12     
  13 class Hijo(Padre):
  14 
  15     def _ronca(self):
  16         print("uhnjjjjjj")
  17 
  18     def duerme(self):
  19         self._ronca()
  20         super(Hijo, self).duerme()
  21         # anteriormente se necesitaria hacer
  22         #Padre.duerme(self)
  23         self._ronca()
  24 
  25     def nada(self, direccion):
  26         print("El " + self.__class__.__name__ " esta nadando.")

Herencia múltiple

En python existe el soporte para heredar de múltiples clases simultáneamente, por ejemplo siguiendo el ejemplo anterior:

   1 class Persona(object):
   2     def __init__(self, nombre):
   3          self.nombre = nombre
   4 
   5 class Padre(Persona):
   6    
   7     def __init__(self, nombre):
   8          self.nombre = nombre
   9 
  10     def duerme(self):
  11         print("ZZZzzz...")
  12 
  13     def camina(self, direccion):
  14         print("El " + self.__class__.__name__ + " esta caminando.")
  15 
  16 class Madre(Persona):
  17 
  18      def cocina(self,):
  19         print("El " + self.__class__.__name__ + " esta cocinando.")
  20         
  21 class Hijo(Padre, Madre):
  22 
  23     def _ronca(self):
  24         print("uhnjjjjjj")
  25 
  26     def _arruina_la_comida(self):
  27         print("Cocinando de forma mediocre...")
  28 
  29     def cocina(self):
  30         super(Hijo, self).cocina()
  31         self._arruina_la_comida()
  32 
  33     def duerme(self):
  34         self._ronca()
  35         super(Hijo, self).duerme()
  36         # anteriormente se necesitaria hacer
  37         #Padre.duerme(self)
  38         self._ronca()
  39 
  40     def nada(self, direccion):
  41         print("El " + self.__class__.__name__ + " esta nadando.")
  42 
  43 h = Hijo('Joel')
  44 h.cocina()
  45 h.duerme()
  46 h.nada('derecho')

Encapsulamiento

La propiedad de encapsulamiento o encapsualación refiere a la propiedad de ceder la responsabilidad del manejo de las propiedades de un objeto de forma privada con interfaces bien definidas para interaccionar con el resto de los objetos.

La encapsulación solo es un termino que refiere a esa peculiaridad sobre el diseño de las clases, se dice que una clase esta bien encapsulada, cuando sus métodos y propiedades tienen la nomenclatura adecuada así como los parámetros adecuados para aprovechar toda las funcionalidad del objeto en si; sin necesidad de recurrir a hacer introspección en el objeto mismo.

En python a diferencia de otros lenguajes, no existe un método eficaz para garantizar que otros objetos no puedan llegar a propiedades no deseadas, más sin embargo existen convenciones de la nomenclatura de las propiedades, con las cuales indica la funcionalidad de esa propiedad/método.

Clases abstractas

Así como en el caso de la encapsulación, la misma naturaleza dinámica de python en conjunto con la filosofía de permitir al programador que sea responsable de su código, en python no hay una forma exactamente similar a las clases abstractas que se obtienen con lenguajes compilados, dicho lo anterior existen forma de agregar "contratos" entre una clase abstracta y sus instancias.

Interfaces

Sobre carga de operadores