POO Herència - Historial de revisió

Enric a 14:42, 21 oct 2014

2014-10-21T14:42:38Z

Enric: /* Herència bàsica */

2012-10-05T13:37:42Z

Herència bàsica

Enric: /* Herència bàsica */

2012-09-12T23:15:07Z

Herència bàsica

Enric: /* Constructoris i herència: instrucció super() */

2012-09-12T22:12:48Z

Constructoris i herència: instrucció super()

Enric: /* Polimorfisme */

2012-09-12T22:07:14Z

Polimorfisme

Enric: Es crea la pàgina amb «Herència és el mecanisme pel qual podem crear objectes (fills) que adopten les característiques d'un altre (pare) i que les extenen o sobreescriuen amb nous mètodes o…».

2012-09-12T21:54:54Z

Es crea la pàgina amb «Herència és el mecanisme pel qual podem crear objectes (fills) que adopten les característiques d'un altre (pare) i que les extenen o sobreescriuen amb nous mètodes o…».

Pàgina nova

Herència és el mecanisme pel qual podem crear objectes (fills) que adopten les característiques d'un altre (pare) i que les extenen o sobreescriuen amb nous mètodes o atributs.

== Herència bàsica ==
En Python la herència s'introdueix entre parèntesi. En aquest exemple Pilota() no hereda de ningú i PilotaDeTennis hereda les propietats (atributs i mètodes) de Pilota.

<syntaxhighlight lang="python">
class Pilota():
# ...veure definició més amunt...
class PilotaDeTennis(Pilota):
color = "verd"
def accelera(self):
self.velocitat = self.velocitat + 12
</syntaxhighlight>

Tinguem en compte que:
* PilotaDeTenis '''hereda els atributs posx, posy i velocitat''' de Pilota.
* Sobreescrivim el mètode accelera(), i enlloc d'accelerar 5 unitats (el mètode definit en Pilota), la PilotaDeTennis accelerarà 20 unitats.
>>> pelo = Pilota()
>>> ptennis = PilotaDeTennis()
>>> pelo.velocitat
10
>>> pelo.accelera()
>>> pelo.velocitat
15 # Pilota ha accelerat 5 punts
>>> ptennis.velocitat
10
>>> ptennis.accelera()
>>> ptennis.velocitat
22 # PilotaDeTennis ha accelerat 12 punts

<br>

== "Noves classes" de Python ==
Llegir: http://docs.python.org/reference/datamodel.html#new-style-and-classic-classes

A partir de la versió 2.1 tots els objectes els heredem de "object". Es solventen alguns problemes antics. Es podria haver posat per defecte, però s'ha mantingut per la compatibilitat amb les aplicacions anteriors.

L' "estil antic" de classes Python (prèvies a 2.1) es defineixen:
<syntaxhighlight lang="python">
class Pilota():
...
</syntaxhighlight>

Ara, per definir un objecte "a la manera nova": '''OJU! sempre ho farem així en principi'''
<syntaxhighlight lang="python">
class Pilota(object):
...
</syntaxhighlight>

La diferència apreciable més important son els mètodes que heredem de "object":
>>> dir(Pilota)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__',
'__getattribute__', '__hash__', '__init__', '__module__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__', '__weakref__', 'accelera', 'posicio',
'posx', 'posy', 'velocitat']

== Constructoris i herència: instrucció super() ==
Quan creem una classe derivada i sobreescrivim el constructor (mètode __init__ en Python), el constructor del pare no es crida. Per exemple:
<syntaxhighlight lang="Python">
class A(object):
def __init__(self):
print "construint l'objecte..."

class B(A):
def __init__(self):
print "hola què tal?"
</syntaxhighlight>

Ara comprovem què passa:
>>> a = A()
construint l'objecte...
>>>
>>> b = B()
hola què tal?

Com podem veure, el constructor de A() no es crida al crear un objecte B(). Com que molt sovint es necessita cridar-lo, es pot fer amb la instrucció super(). Oju que aquest exemple és per Python 2.x. En Python 3.0 s'ha simplificat a super(), sense arguments, molt més elegant:

<syntaxhighlight lang="Python">
# exemple en Python 2.x
class A(object):
def __init__(self):
print "construint l'objecte..."

class B(A):
def __init__(self):
super(B,self).__init__()
print "hola què tal?"
</syntaxhighlight>

ULL!: si no creem l'objecte base A(object) heredat de "object", l'exemple no funcionarà.

Comprovem-ho:
>>> a = A()
construint l'objecte...
>>> b = B()
construint l'objecte...
hola què tal?

<br>

== Herència múltiple ==
...

<br>

== Polimorfisme ==
El polimorfisme és una important propietat de la POO, molt rellevant sobretot en llenguatges on no hi ha tipus dinàmics com el C++ o el Java. El què significa és que una referència (punter) a un objecte genèric (pare), al cridar a una funció que està sobrescrita per un objecte derivat, executarà la funció més "nova", és a dir, la de l'objecte instanciat realment.

El cas típic és tenir un array de punters a objectes pare que no sabem de quin tipus derivat exactament son, per exemple, un array de Pilotes. Segons com l'haguem creat, el punters apuntaran a objectes dels tiups PilotaDeTennis, PilotaDeFutbol i PilotaDeBasket, però no tenim perquè saber-ho, tot i que sabem segur que tots hereden de Pilota. Quan cridem al mètode accelera() s'executarà el de l'objecte derivat, no el del pare genèric, encara que el punter apunti a Pilota.

En el cas del Python no ens resulta molt rellevant ja que tenim tipus dinàmics amb total introspecció. Això vol dir que en tot moment sabem de quin tipus és cada objecte. A sobre, en Python podem tenir arrays d'objectes heterogenis, cosa que no es pot fer amb Java o C++. Així, el polimorfisme no en aquests llenguates és molt important, però no en Python.

Per saber més podeu llegir:
* [http://es.wikipedia.org/wiki/Polimorfismo_%28programaci%C3%B3n_orientada_a_objetos%29 l'article sobre ''polimorfisme''] a la Wikipèdia.
* [[POO: Polimorfisme]] a cacauet.

<br>

← Versió més antiga		Revisió del 14:42, 21 oct 2014
Línia 1:		Línia 1:
	Herència és el mecanisme pel qual podem crear objectes (fills) que adopten les característiques d'un altre (pare) i que les extenen o sobreescriuen amb nous mètodes o atributs.		Herència és el mecanisme pel qual podem crear objectes (fills) que adopten les característiques d'un altre (pare) i que les extenen o sobreescriuen amb nous mètodes o atributs.
		+
		+	Podeu fer una ullada a aquest [http://www.javaranch.com/campfire/StoryPoly.jsp article arxiconegut sobre animals i herència].

	== Herència bàsica ==		== Herència bàsica ==

@@ Línia 12: / Línia 12: @@
     # mètodes
     def accelera(self):
-       self.velocitat = self.velocitat + 5class Pilota():
+       self.velocitat = self.velocitat + 5
 class PilotaDeTennis(Pilota):
     color = "verd"

← Versió més antiga		Revisió del 22:07, 12 set 2012
Línia 119:		Línia 119:

	<br>		<br>
		+
		+	== Mètodes i classes virtuals ==
		+	En Python tampoc és molt rellevant aquest aparat ja que està relacionat amb el Polimorfisme.
		+
		+	Un '''mètode virtual''' és aquell que, en ser cridat, intentarà cridar al de la classe derivada en cas que existeixi. Si no definim com a virtual un mètode es cridarà al de la classe del punter referenciat. Podeu veure l'exemple en C++ a [[POO: Polimorfisme]].
		+
		+	Un '''mètode virtual pur''' és aquell mètode virtual que no s'ha definit. '''En C++''':
		+	<syntaxhighlight lang="cpp">
		+	class Pilota {
		+	...
		+	virtual int accelera()=0;
		+	...
		+	}
		+	</syntaxhighlight>
		+
		+	Una '''classe virtual''' és aquella que al menys té un mètode virtual pur. <u>Una classe virtual no es pot instanciar</u>. Cal crear una classe derivada que implementi el/s mètode/s virtual/s per poder ser instanciada.

@@ Línia 6: / Línia 6: @@
 <syntaxhighlight lang="python">
 class Pilota():
-    # ...veure definició més amunt...
+    # atributs
 class PilotaDeTennis(Pilota):
     color = "verd"

@@ Línia 57: / Línia 57: @@
-== Constructoris i herència: instrucció super() ==
+== Constructors i herència: instrucció super() ==
 Quan creem una classe derivada i sobreescrivim el constructor (mètode __init__ en Python), el constructor del pare no es crida. Per exemple:
 <syntaxhighlight lang="Python">
@@ Línia 100: / Línia 100: @@
 <br>
 == Herència múltiple ==