CC 1002: Introducción a la Programación Clase 22 Nelson Baloian, José A. Pino

Interfaces Una interfaz es una especificación de como usar un modulo, sin especificar su implementación. Esto esta basado en un principio de separar interfaces de sus implementaciones. Ej: math de Python tiene una interfaz bien definida: conjunto de funciones (math.sqrt(x), math.cos(x), etc ...) y de constantes (math.pi, ...). Sin embargo, la documentación (disponible en http://docs.python.org/2/library/math.html), no dice nada sobre cómo están implementadas las funciones Los usuarios de un modulo se llaman sus clientes, mientras que el módulo mismo corresponde al proveedor de funcionalidad basado en esta interfaz. En el caso de la programación orientada al objeto, la interfaz de un objeto es el conjunto de métodos que provee, es decir, el conjunto de métodos que uno puede ejecutar sobre el objeto.

Ejemplo: animales Si estamos implementando una simulación de una granja, necesitamos varios animales: cabras, vacas, cerdos, gallos, etc. Cada tipo de animal tiene un comportamiento distinto: cada animal tiene un grito, tiene o no plumas, un número distinto de patas, etc. Podemos definir una interfaz general de nuestros animales: # un animal de granja es un objeto que tiene las siguientes operaciones : # grito : -> string # devuelve una representacion textual del sonido que hace un animal # plumas : -> bool # devuelve True si el animal tiene plumas # pelo : -> bool # devuelve True si el animal tiene pelo # patas : -> int # devuelve el numero de patas del animal # cola : -> bool # devuelve si el animal tiene una cola o no # nombre : -> string # devuelve el nombre de la especie de animal . . . .

¿Qué es el polimorfismo? Propiedad de OOP que permite interactuar con distintos objetos de manera uniforme. Objetos de distinta clase tienen una implementación distintas de la misma interfaz, El cliente los “procesa” de la misma manera, sin saber que varían. Ejemplo de sumar patas en una lista de animales sin polimorfismo:

Cerdos, Patos, etc… class Cerdo : # ... # patas : -> int En OOP. cada objeto es dueño de su comportamiento, Cada animal sabe cuantas patas tiene (la información está en el objeto de la clase). : class Cerdo : # ... # patas : -> int def patas ( self ): return 4 class Pato : return 2 p = Pato () c = Cerdo () assert p. patas () == 2 assert c. patas () == 4

Contando patas con polimorfismo Dos objetos de distinta clase pueden responder al mismo mensaje con una implementación distinta. Durante la ejecución Python determina cual es la clase de cada objeto, y ejecuta la implementación relevante Esto ahorra varios if/else, el interprete de Python se encarga de decidir usando el polimorfismo: cada animal va a ejecutar la versión apropiada del método patas según su clase; Restricción: cada animal DEBE tener una implementación de patas. Si no, el programa va a producir un error de tipo AttributeError.

Ventajas del polimorfismo El código de contar patas se simplifica, -> más abstracto, más entendible Código fácilmente extensible. Para un nuevo animal no es necesario cambiar la implementación de contar patas, basta con agregar la función patas() al nuevo animal. No tenemos que escribir la instrucción condicional -> evitar errores. Mientras más clases más importante son los beneficios: se ahorra código (cadenas de instrucciones if/else)

Desventajas del polimorfismo El polimorfismo no es una solución perfecta. Hay varias consecuencias negativas que hay que tener en cuenta. En particular: Si uno esta interesado en entender como funciona el comportamiento del método patas, uno tiene ahora que revisar múltiples ubicaciones en el código fuente, y no solamente una única ubicación como antes. Si uno quiere extender la interfaz de los animales (agregando el método grito, por ejemplo), es necesario modificar cada clase de animales, en ver de hacer el cambio en un único lugar.

Otro ejemplo: puntos y líneas En el caso de los animales el uso del polimorfismo no es tan necesario: basta agregar atributos a cada animal y devolver el atributo. Hay casos en que esto no es posible: representación de coordenadas en forma cartesiana (x, y) y polar (r, Ɵ) El polimorfismo nos permite unificar estos dos tipos de puntos detrás de una misma interfaz. Un usuario puede usar cartesianos o polares de la misma forma, y es más fácil cambiar la implementación si es necesario.

Cartesianos (1)

Cartesianos (2)

Polares (1)

Polares(2)

Uso de las clases Cada clase tiene la misma interfaz, pero los comportamientos en cada casos son muy distintos: Cuando una clase hace un acceso a un atributo, la otra hace un calculo, pero las interfaces son iguales. Otra clase, la clase Linea, puede ocupar cualquier tipo de puntos como atributos, dado que se conforman a la misma interfaz.

Además… La definición de los métodos __add__ y otras, que permite a Python usar el operador + para los puntos. Hay varios operadores que funcionan similarmente. Esto también es uso de polimorfismo: todas las clases que tienen el método __add__ se invocan con el operador +, todas las que tienen __str__ van retornar un string al usar la función str(), etc. .

Herencia La otra alternativa es definir una clase más general que contiene el comportamiento común, y ver las clases de puntos cartesianos y polares como casos específicos de esta clase general. Muchos lenguajes orientados al objeto (incluyendo Python) permiten hacer esto. En este caso, seria natural tener una clase general de puntos, y casos específicos de puntos cartesianos y polares. El mecanismo de herencia nos permite hacer eso. La clase para punto va a ser llamada la superclase, y las clases de puntos cartesiano y polares van a ser las subclases, que hereden de la clase punto. El conjunto de clases forma una jerarquía de clases, con las clases las más generales arriba y las clases las más especificas abajo.

Ej. de jerarquía de clases

Clase 8: Herencia J.Alvarez

import math class Circulo: def __init__(self,x): if x<=0: exit("radio<=0”) self.r=x def perimetro(self): return 2*math.pi*self.r def area(self): return math.pi*self.r**2 class Cuadrado: if x<=0: exit(“lado<=0”) self.a=x def perimetro(self): return 4*self.a def area(self): return self.a**2 Nota. Constructores son similares

Solución 2. Con Herencia import math class Figura: def __init__(self,x): #constructor único if x<=0: exit(“nº<=0") self.x=x #significado de x depende de figura class Circulo(Figura): def area(self): return math.pi*self.x**2 def perimetro(self): return 2*math.pi*self.x class Cuadrado(Figura): def area(self): return self.x**2 def perimetro(self): return 4*self.x

Otras figuras? class Rectangulo(Figura): Clase 8: Herencia Otras figuras? class Rectangulo(Figura): def __init__(self,x,y): #constructor Figura.__init__(self,x) #ctor clase Figura self.y=y #ancho if y<=0: exit(“nº<=0") def area(self): return self.x*self.y def perimetro(self): return 2*(self.x+self.y) Uso? r=Rectangulo(nº,nº) J.Alvarez

Triangulo (s-self.z)) Uso? t=Triangulo(nº,nº,nº) class Triangulo(Figura): def __init__(self,x,y,z): if x<=0 or y<=0 or z<=0 \ #continua… or x+y<=z or x+z<=y or y+z<=x: exit("no forman triangulo") self.x=x; self.y=y; self.z=z def perimetro(self): return self.x+self.y+self.z def area(self): s=(self.x+self.y+self.z)/2; return math.sqrt(s*(s-self.x)*(s-self.y)*\ (s-self.z)) Uso? t=Triangulo(nº,nº,nº)

r=raw_input(“circulo,cuadrado,rectangulo o ” + \ “triangulo?").lower() if r=="circulo": f=Circulo(input("radio?")) elif r=="cuadrado": f=Cuadrado(input("lado?")) elif r=="rectangulo": f=Rectangulo(input("largo?"),\ input("ancho?")) elif r=="triangulo": f=Triangulo(input("lado1?"),\ input("lado2?"),\ input("lado3?")) else: exit("figura incorrecta") print "area=",f.area() print "perimetro=",f.perimetro()

Herencia “transitiva” (“sucesiva”) class A: def __init__(self,x): self.a=x def f(self): return self.a class B(A): #hereda de A def __init__(self,x,y): A.__init__(self,x) self.b=y def g(self): return self.b class C(B): #hereda de B def __init__(self,x,y,z): B.__init__(self,x,y) self.c=z def h(self): return self.c Uso? >>>c=C(1,2,3) >>>c.f()+c.g()+c.h() 6 A B C

def f(self): return self.a class B: self.b=x #una variable Herencia “múltiple” class A: def __init__(self,x): self.a=x #una variable def f(self): return self.a class B: self.b=x #una variable def g(self): return self.b class C(A,B): #C hereda de clases A y B def __init__(self,x,y,z): A.__init__(self,x) B.__init__(self,y) self.c=z #tres variables pq a y b se heredan def h(self): return self.c Uso? >>>c=C(1,2,3) >>>c.f()+c.g()+c.h() 6 A B C