Diferència entre revisions de la pàgina «POO Classes»

De Cacauet Wiki
Salta a la navegació Salta a la cerca
 
(Hi ha 11 revisions intermèdies del mateix usuari que no es mostren)
Línia 24: Línia 24:
 
       self.posy = y
 
       self.posy = y
 
</syntaxhighlight>
 
</syntaxhighlight>
De fet, la versió més elemental seria canviant la 1a linia per '''class Pilota():'''. A partir de la v2.1 de Python sempre heredem de la classe '''object'''. Llegiu l'apartat d'[[POO_Classes#.22noves_classes.22_de_Python|herència i "noves classes"]] més avall per més detalls.
+
De fet, la versió més elemental seria canviant la 1a linia per '''class Pilota():'''. A partir de la v2.1 de Python sempre heredem de la classe '''object'''. Llegiu l'apartat d'[[POO_Her%C3%A8ncia#.22Noves_classes.22_de_Python|herència i "noves classes"]] més avall per més detalls.
  
 
Creem la instància "p" i accedim als atributs (distingiu entre l'accés i la assignació):
 
Creem la instància "p" i accedim als atributs (distingiu entre l'accés i la assignació):
Línia 49: Línia 49:
 
  30
 
  30
  
=== Introspecció ===
+
== Introspecció ==
 
Podem conèixer els atributs i mètodes d'una classe a través de la sentència '''dir''' (ho podem fer sobre una instància o sobre una classe):
 
Podem conèixer els atributs i mètodes d'una classe a través de la sentència '''dir''' (ho podem fer sobre una instància o sobre una classe):
 
  >>> dir(Pilota)
 
  >>> dir(Pilota)
Línia 93: Línia 93:
 
Python (a diferència d'altres llenguates com C++) disposa de '''recol·lecció automàtica de basura'''. Això vol dir que quan un objecte no està referenciat per ningú més el sistema l'esborra de memòria. Resulta molt còmode per evitar "memory leaks", però té un cert impacte en el rendiment, raó pel qual alguns llenguatges no ho implementen.
 
Python (a diferència d'altres llenguates com C++) disposa de '''recol·lecció automàtica de basura'''. Això vol dir que quan un objecte no està referenciat per ningú més el sistema l'esborra de memòria. Resulta molt còmode per evitar "memory leaks", però té un cert impacte en el rendiment, raó pel qual alguns llenguatges no ho implementen.
  
NOTA PER CLASSES HEREDADES: el constructor de la subclasse sobreescriu el de la superclasse. Per controlar si el cridem es pot fer servir la sentència "super", veure en l'apartat d'herència més avall.
+
NOTA PER CLASSES HEREDADES: el constructor de la subclasse sobreescriu el de la superclasse. Per controlar si el cridem es pot fer servir la sentència "super", veure en [[POO Herència#Constructors i herència:instrucció super()]]
  
 
<br>
 
<br>
  
== Herència ==
+
== Atributs estàtics ==
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.
+
Els atributs estàtics (o també funcions estàtiques) son valors que es defineixen per la classe sencera i no per una instància. Així, totes les instàncies tindran el mateix valor per aquella variable.
 +
* En Java o C++ es defineixen amb la sentència "static". En C++ tenen algunes utilitzacions particulars com les ''callback functions''.
 +
* En Pyton es defineixen en el cos de l'objecte.
  
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.
+
Hem de ser curosos ja que en molts casos ens poden portar problemes, com per exemple a l'utilitzar llistes. Prenem l'exemple:
 
+
<syntaxhighlight lang="Python">
<syntaxhighlight lang="python">
+
class Dades():
class Pilota():
+
   # atributs
   # ...veure definició més amunt...
+
  nombres = []
class PilotaDeTennis(Pilota):
+
  noms = {}
   color = "verd"
+
   id = 0
   def accelera(self):
+
  # mètodes
       self.velocitat = self.velocitat + 12
+
   def __init__(self):
 +
       pass
 
</syntaxhighlight>
 
</syntaxhighlight>
  
Tinguem en comtpe que:
+
En aquest cas ens trobariem un problema: tant la llista "nombres" com el diccionari "noms" son estàtics i comuns a totes les classes. Ho podem veure en aquest exemple:
* PilotaDeTenis '''hereda els atributs posx, posy i velocitat''' de Pilota.
+
  >>> a = Dades()
* Sobreescrivim el mètode accelera(), i enlloc d'accelerar 5 unitats (el mètode definit en Pilota), la PilotaDeTennis accelerarà 20 unitats.
+
  >>> b = Dades()
  >>> pelo = Pilota()
+
  >>>  
  >>> ptennis = PilotaDeTennis()
+
>>> a.nombres.append(10)    #afegim un element a la llista "nombres" de la instància "a"
  >>> pelo.velocitat
+
  >>>
  10
+
  >>> a.nombres
  >>> pelo.accelera()
+
[10]
  >>> pelo.velocitat
+
  >>> b.nombres
  15                          # Pilota ha accelerat 5 punts
+
  [10]                        #sorpresa: la llista ''nombres'' de "b" és com la de "a", sense haver-la tocat
  >>> ptennis.velocitat
+
>>>
  10
+
  >>> a.id = 3
  >>> ptennis.accelera()
+
  >>>
  >>> ptennis.velocitat
+
  >>> a.id
  22                          # PilotaDeTennis ha accelerat 12 punts
+
3
 
+
  >>> b.id
<br>
+
  0                          #aqui no hi ha sorpresa: cada instància té el seu id propi
 +
>>>  
  
=== super (constructor del pare) ===
+
IMPORTANT: podem veure diferent comportament pel membre ''integer'' (id) que el de la llista (nombres):
...cridant al constructor pare... (super)
+
* Pel membre "id" funciona correctament. Això és perquè hem canviat el valor de l'atribut i li hem assignat un altre (3 enlloc de 0).
...
+
* Per la llista no ens funciona bé perquè volem una la llista de "b" independent de la de "a", i en canvi, quan afegim un element a la llista d'una instància "a" afecta també a la de l'altra instància "b". Al ser membre estàtic, és compartit per les 2 instàncies.
 +
* Pel diccionari "noms" passaria el mateix.
  
 +
La diferència entre el nombre (id) i la llista (nombres) és que al id li assignem un nou nombre. En canvi a la llista no li assignem una altra llista, sinó que agafem la que tenim i utiltizem un mètode propi (append).
  
=== "noves classes" de Python ===
+
Per solventar aquest problema inicialitzem els atributs en el constructor:
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.
+
<syntaxhighlight lang="Python">
 
+
class Dades():
L' "estil antic" de classes Python (prèvies a 2.1) es defineixen:
+
   # atributs
<syntaxhighlight lang="python">
+
  nombres = None    # com que l'inicialitzem al constructor no cal posar-ho aquí
class Pilota():
+
  noms = None      # només ho fem per clarificar que tenim un atribut
   ...
+
  id = 0
</syntaxhighlight>
+
  # mètodes
 
+
  def __init__(self):
Ara, per definir un objecte "a la manera nova": '''OJU! sempre ho farem així en principi'''
+
      self.nombres = []
<syntaxhighlight lang="python">
+
      self.noms = {}
class Pilota(object):
 
  ...
 
 
</syntaxhighlight>
 
</syntaxhighlight>
 +
En aquest cas sí que assignem una nova llista a cada instància.
  
La diferència apreciable més important son els mètodes que heredem de "object":
+
I ara sí que es comporta com volem:
  >>> dir(Pilota)
+
  >>> a = Dades()
  ['__class__', '__delattr__', '__dict__', '__doc__', '__format__',
+
  >>> b = Dades()
  '__getattribute__', '__hash__', '__init__', '__module__', '__new__',
+
>>>
  '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
+
>>> a.nombres.append(33)
  '__str__', '__subclasshook__', '__weakref__', 'accelera', 'posicio',
+
>>>
  'posx', 'posy', 'velocitat']
+
>>> a.nombres
 
+
[33]
=== Herència múltiple ===
+
>>> b.nombres
...
+
[]
 
+
>>>
<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.
+
<div class="exercici">
 +
=== Conclusió ===
 +
Aquest comportament no només passa per les llistes i diccionaris, també per qualsevol objecte. Per tant:
  
Per saber més podeu llegir:
+
'''Els objectes dintre d'objectes cal inicialitzar-los en el constructor!'''
* [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.
 
  
 +
Com a norma d'estil podem efectuar la declaració dels atributs amb ''None'''s com a l'exemple anterior per tal que d'un cop de vista puguem veure quins atributs té una classe. Però no és estrictament necessari, només una convenció.
 +
</div>
 
<br>
 
<br>
  
== Sobrecàrrega ==
+
== Visibilitat ==
...
+
La visibilitat d'un atribut, mètode o classe determina qui pot accedir-hi. Per exemple, en C++ i Java, si volem que un atribut no sigui accessible el podem ocultar als altres objectes amb la clàusula "private".
  
== Operadors ==
+
=== Visibilitat en C++ i Java ===
...
+
Hi ha 3 nivells de visibilitat:
 +
* '''public''': qualsevol hi pot accedir.
 +
* '''protected''': només hi pot accedir la pròpia classe i les seves classes derivades.
 +
* '''private''': només es pot accedir des d'un mètode de la pròpia classe.
  
== Visibilitat ==
+
Per exemple:
...
+
<syntaxhighlight lang="cpp">
 +
class A
 +
{
 +
  private:  // atributs ocults a les altres classes
 +
      int a;
 +
      int b;
 +
  public:  // funcions accessibles per tothom
 +
      void set_a(int val) {
 +
        a = val;
 +
      }
 +
      void set_b(int val) {
 +
        b = val;
 +
      }
 +
  protected: // funcions disponibles només per les classes derivades
 +
      ...
 +
}     
 +
</syntaxhighlight>
  
== Classes i mètodes virtuals ==
+
=== Visibilitat en Python ===
...
+
De nou, és una característica que no és gaire rellevant. '''En Python tots els atributs i mètodes son públics'''. Es pot "marcar" com a privat un atribut si el comencem amb un ''underscore'', per exemple:
 +
<syntaxhighlight lang="python">
 +
class Bicicleta(object):
 +
  _velocitat = 0
 +
  def accelera(self):
 +
      self._velocitat = self.velocitat + 5
 +
</syntaxhighlight>
 +
El fet de posar el ''underscore'' no afecta a la visibilitat, però és una "convenció" de que si trobem un atribut d'aquest tipus, no convé accedir-hi directament (per obtenir el valor potser sí, per canviar-lo no).

Revisió de 15:33, 22 nov 2012

Anem a revisar els aspectes més pràctics dels fonaments de la POO: com crear classes, instanciar objectes i interactuar amb ells.

Per Python disposem del següent link de referència sobre les classes: http://docs.python.org/reference/datamodel.html


Classe i instància[modifica]

  • Una classe defineix un tipus de dades, però no la crea.
  • Una instància és un objecte real creat a partir del model d'una classe.
  • Els atributs (variables internes) els creem inicialitzant-los a un valor dins de la classe.
  • Els mètodes (funcions internes) es creen amb def i TOTES tenen com a primer argument self (= la instància que el crida).

Creem la classe:

class Pilota(object):
   # atributs
   velocitat = 10
   posx = 10
   posy = 12
   # mètodes
   def accelera(self):
      self.velocitat = self.velocitat + 5
   def posicio(self,x,y):
      self.posx = x
      self.posy = y

De fet, la versió més elemental seria canviant la 1a linia per class Pilota():. A partir de la v2.1 de Python sempre heredem de la classe object. Llegiu l'apartat d'herència i "noves classes" més avall per més detalls.

Creem la instància "p" i accedim als atributs (distingiu entre l'accés i la assignació):

>>> p = Pilota()
>>> p.velocitat
10
>>> p.posy
12
>>> p.posy = 8
>>> p.posy
8

Per executar una funció s'han de posar els parèntesis ():

>>> p.accelera()
>>> p.velocitat
15

Quan els mètodes tenen paràmetres cal tenir en compte que el primer sempre serà self. Aquest és necessari per accedir als atributs de la instància que crida l'objecte. Però quan cridem la funció s'ha d'obviar el "self". Per exemple, en el nostre cas tenim posicio(self,x,y) , però per cridar la funció posició ho fem només amb la x i la y:

>>> p.posicio(40,30)
>>> p.posx
40
>>> p.posy
30

Introspecció[modifica]

Podem conèixer els atributs i mètodes d'una classe a través de la sentència dir (ho podem fer sobre una instància o sobre una classe):

>>> dir(Pilota)
['__doc__', '__module__', 'accelera', 'posicio', 'posx', 'posy', 'velocitat']

Ull, aquest resultat és d'una classe no heredada de "object". Si heu heredat d'object us sortiran uns quants mètodes més.

Si féssim dir(p) (instància) tindria el mateix resultat:

>>> p = Pilota()
>>> dir(p)
['__doc__', '__module__', 'accelera', 'posicio', 'posx', 'posy', 'velocitat']

La introspecció és una important característica d'un llenguatge orientat a objecte. No tots els llenguatges en disposen i és molt útil al treballar amb la consola d'instruccions i per depurar (debug).


Constructors i destructors[modifica]

  • El constructor és un mètode que es crida al crear l'objecte. En Python és __init__.
  • El destructor es crida al destruïr l'objecte. En Python és __del__, ja que per destruïr un objecte s'utiltiza la sentència "del".

Exemple:

class A():
   def __init__(self):
      print "construint l'objecte..."
   def __del__(self):
      print "destruim-lo!"

Comprovem que realment els mètodes son cridats:

>>> a = A()
construint l'objecte...
>>> a
<__main__.A instance at 0xb6ebba2c>
>>> del a
destruim-lo!
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

Queda't amb què per destruïr un objecte utiltizem del.

Python (a diferència d'altres llenguates com C++) disposa de recol·lecció automàtica de basura. Això vol dir que quan un objecte no està referenciat per ningú més el sistema l'esborra de memòria. Resulta molt còmode per evitar "memory leaks", però té un cert impacte en el rendiment, raó pel qual alguns llenguatges no ho implementen.

NOTA PER CLASSES HEREDADES: el constructor de la subclasse sobreescriu el de la superclasse. Per controlar si el cridem es pot fer servir la sentència "super", veure en POO Herència#Constructors i herència:instrucció super()


Atributs estàtics[modifica]

Els atributs estàtics (o també funcions estàtiques) son valors que es defineixen per la classe sencera i no per una instància. Així, totes les instàncies tindran el mateix valor per aquella variable.

  • En Java o C++ es defineixen amb la sentència "static". En C++ tenen algunes utilitzacions particulars com les callback functions.
  • En Pyton es defineixen en el cos de l'objecte.

Hem de ser curosos ja que en molts casos ens poden portar problemes, com per exemple a l'utilitzar llistes. Prenem l'exemple:

class Dades():
   # atributs
   nombres = []
   noms = {}
   id = 0
   # mètodes
   def __init__(self):
      pass

En aquest cas ens trobariem un problema: tant la llista "nombres" com el diccionari "noms" son estàtics i comuns a totes les classes. Ho podem veure en aquest exemple:

>>> a = Dades()
>>> b = Dades()
>>> 
>>> a.nombres.append(10)    #afegim un element a la llista "nombres" de la instància "a"
>>>
>>> a.nombres
[10]
>>> b.nombres
[10]                        #sorpresa: la llista nombres de "b" és com la de "a", sense haver-la tocat
>>> 
>>> a.id = 3
>>> 
>>> a.id
3
>>> b.id
0                           #aqui no hi ha sorpresa: cada instància té el seu id propi
>>> 

IMPORTANT: podem veure diferent comportament pel membre integer (id) que el de la llista (nombres):

  • Pel membre "id" funciona correctament. Això és perquè hem canviat el valor de l'atribut i li hem assignat un altre (3 enlloc de 0).
  • Per la llista no ens funciona bé perquè volem una la llista de "b" independent de la de "a", i en canvi, quan afegim un element a la llista d'una instància "a" afecta també a la de l'altra instància "b". Al ser membre estàtic, és compartit per les 2 instàncies.
  • Pel diccionari "noms" passaria el mateix.

La diferència entre el nombre (id) i la llista (nombres) és que al id li assignem un nou nombre. En canvi a la llista no li assignem una altra llista, sinó que agafem la que tenim i utiltizem un mètode propi (append).

Per solventar aquest problema inicialitzem els atributs en el constructor:

class Dades():
   # atributs
   nombres = None    # com que l'inicialitzem al constructor no cal posar-ho aquí
   noms = None       # només ho fem per clarificar que tenim un atribut
   id = 0
   # mètodes
   def __init__(self):
      self.nombres = []
      self.noms = {}

En aquest cas sí que assignem una nova llista a cada instància.

I ara sí que es comporta com volem:

>>> a = Dades()
>>> b = Dades()
>>> 
>>> a.nombres.append(33)
>>> 
>>> a.nombres
[33]
>>> b.nombres
[]
>>> 

Conclusió[modifica]

Aquest comportament no només passa per les llistes i diccionaris, també per qualsevol objecte. Per tant:

Els objectes dintre d'objectes cal inicialitzar-los en el constructor!

Com a norma d'estil podem efectuar la declaració dels atributs amb None's com a l'exemple anterior per tal que d'un cop de vista puguem veure quins atributs té una classe. Però no és estrictament necessari, només una convenció.


Visibilitat[modifica]

La visibilitat d'un atribut, mètode o classe determina qui pot accedir-hi. Per exemple, en C++ i Java, si volem que un atribut no sigui accessible el podem ocultar als altres objectes amb la clàusula "private".

Visibilitat en C++ i Java[modifica]

Hi ha 3 nivells de visibilitat:

  • public: qualsevol hi pot accedir.
  • protected: només hi pot accedir la pròpia classe i les seves classes derivades.
  • private: només es pot accedir des d'un mètode de la pròpia classe.

Per exemple:

class A
{
   private:  // atributs ocults a les altres classes
      int a;
      int b;
   public:   // funcions accessibles per tothom
      void set_a(int val) {
         a = val;
      }
      void set_b(int val) {
         b = val;
      }
   protected: // funcions disponibles només per les classes derivades
      ...
}

Visibilitat en Python[modifica]

De nou, és una característica que no és gaire rellevant. En Python tots els atributs i mètodes son públics. Es pot "marcar" com a privat un atribut si el comencem amb un underscore, per exemple:

class Bicicleta(object):
   _velocitat = 0
   def accelera(self):
      self._velocitat = self.velocitat + 5

El fet de posar el underscore no afecta a la visibilitat, però és una "convenció" de que si trobem un atribut d'aquest tipus, no convé accedir-hi directament (per obtenir el valor potser sí, per canviar-lo no).