b'\n_START_ARTICLE_\nClasse (inform\xc3\xa0tica)\n_START_PARAGRAPH_\nEn programaci\xc3\xb3 orientada a objectes, una classe \xc3\xa9s una construcci\xc3\xb3 d\'un llenguatge de programaci\xc3\xb3 usada per agrupar camps relacionats i m\xc3\xa8todes. Est\xc3\xa0 conceptualment relacionat amb classes de la teoria de conjunts. _NEWLINE_Una classe \xc3\xa9s un paquet cohesionat que consisteix en un tipus concret de metadada. Descriu les regles que marquen el comportament de l\'objecte; les refer\xc3\xa8ncies a aquests objectes s\xc3\xb3n fetes com a inst\xc3\xa0ncies d\'una classe. Una classe t\xc3\xa9 tant una interf\xc3\xadcie com una estructura. La interf\xc3\xadcie descriu com es pot interaccionar amb la classe i la inst\xc3\xa0ncia a trav\xc3\xa9s de m\xc3\xa8todes, mentre l\'estructura descriu com es divideix la dada en camps dintre de la inst\xc3\xa0ncia. Una classe \xc3\xa9s el tipus m\xc3\xa9s espec\xc3\xadfic d\'un objecte en relaci\xc3\xb3 a una capa en concret. Una classe tamb\xc3\xa9 pot tenir una representaci\xc3\xb3 (metaobjecte) en temps d\'execuci\xc3\xb3, que proveeix suport per manipular la metadada relativa a la classe._NEWLINE_Els llenguatges de programaci\xc3\xb3 que donen suport a les classes tenen difer\xc3\xa8ncies subtils en com donen suport a les diferents funcionalitats pr\xc3\xb2pies de les classes. La majoria donen suport a diferents formes d\'her\xc3\xa8ncia. Molts llenguatges tamb\xc3\xa9 donen suport a les funcionalitats que aporta l\'encapsulaci\xc3\xb3, per exemple, els especificadors d\'acc\xc3\xa9s.\n_START_SECTION_\nMotius pels quals usar classes\n_START_PARAGRAPH_\nLes classes quan es fan servir adequadament, poden accelerar el desenvolupament reduint la introducci\xc3\xb3 de codi redundant, el testeig i la resoluci\xc3\xb3 de bugs. Si una classe ha estat testada en profunditat i se la considera com a robusta, la seva reutilitzaci\xc3\xb3 garanteix la no propagaci\xc3\xb3 d\'errors arreu del codi. Si se\'n fa una extensi\xc3\xb3, on se li afegeix nou codi, el mateix nivell de testeig de les noves parts de codi garanteixen el mateix nivell de fiabilitat de la classe resultant._NEWLINE_Una altra ra\xc3\xb3 per fer servir classes \xc3\xa9s la de simplificar les relacions i les dades interrelacionades. Abans que escriure codi que crida repetidament la subrutina que dibuixa una finestra, \xc3\xa9s millor i m\xc3\xa9s intu\xc3\xaftiu tractar la finestra com un objecte i dir-li que es redibuixi quan faci falta. Amb classes, els \xc3\xadtems GUI que s\xc3\xb3n similars a finestres (per exemple, les caixes de di\xc3\xa0leg), poden simplement heretar la majoria de les seves funcionalitats i estructures de dades de la classe de la finestra. El programador nom\xc3\xa9s necessita llavors afegir el codi propi de la nova classe. Efectivament, les GUIs s\xc3\xb3n una possible aplicaci\xc3\xb3 de les classes molt comuna i molt \xc3\xbatil i la programaci\xc3\xb3 GUI acostuma a ser molt m\xc3\xa9s f\xc3\xa0cil amb un bon disseny de classes.\n_START_SECTION_\nInstanciaci\xc3\xb3\n_START_PARAGRAPH_\nUna classe \xc3\xa9s usada per crear-ne inst\xc3\xa0ncies (objectes) per instaciar la classe._NEWLINE_Les inst\xc3\xa0ncies d\'una classe comparteixen el mateix conjunt de propietats, encara que poden ser diferents en el seu contingut (poden tenir estats diferents). Per exemple, una classe "Persona" descriuria les propietats comunes a totes les inst\xc3\xa0ncies de la classe Persona. Les persones s\xc3\xb3n generalment semblants, per\xc3\xb2 varien en certes propietats com l\'al\xc3\xa7ada o l\'amplada. La classe tamb\xc3\xa9 definiria com es realitzen certes opcions: c\xc3\xb3rrer, saltar, dormir, llen\xc3\xa7ar un objecte, etc. Un dels beneficis de programar amb classes \xc3\xa9s que totes les inst\xc3\xa0ncies d\'una classe en particular seguir\xc3\xa0 el comportament definit de la classe que instacien._NEWLINE_En la majoria de llenguatges, les estructures, tal com estan definides per la classe, determinen com s\'ocupa i allibera la mem\xc3\xb2ria ocupada per les seves inst\xc3\xa0ncies. Aquesta t\xc3\xa8cnica \xc3\xa9s coneguda com a model cookie-cutter. L\'alternativa a aquest model \xc3\xa9s la que es fa servir, per exemple, al Python, on els objectes estan estructurats com contenidors clau-valor associatius. I aquests models, objectes que s\xc3\xb3n inst\xc3\xa0ncies de la mateixa classe podrien contenir diferents variables, de manera que l\'estat pot ser din\xc3\xa0micament afegit a l\'objecte. Aix\xc3\xb2 es podria semblar en certes maneres, als llenguatges basats en prototipus, per\xc3\xb2 no \xc3\xa9s equivalent.\n_START_SECTION_\nInterf\xc3\xadcies i m\xc3\xa8todes\n_START_PARAGRAPH_\nEls objectes defineixen la seva interacci\xc3\xb3 amb el m\xc3\xb3n exterior a trav\xc3\xa9s dels m\xc3\xa8todes que exposen. Un m\xc3\xa8tode, \xc3\xa9s una subrutina (funci\xc3\xb3) amb una propietat especial que t\xc3\xa9 el seu acc\xc3\xa9s a dades emmagatzemades en un objecte (inst\xc3\xa0ncia). Els m\xc3\xa8todes que manipulen les dades de l\'objecte i porten a terme tasques s\xc3\xb3n, de vegades, tractades com a comportament._NEWLINE_Els m\xc3\xa8todes formen la interf\xc3\xadcie dels objectes amb el m\xc3\xb3n exterior; els botons del frontal d\'un reproductor de v\xc3\xaddeo, per exemple, s\xc3\xb3n la interf\xc3\xadcie entre els humans i el material el\xc3\xa8ctric, que hi ha dintre de la caixa que forma l\'electrodom\xc3\xa8stic. Es prem el bot\xc3\xb3 d\'"on" per deixar l\'aparell enc\xc3\xa8s o apagat. En aquest exemple, la televisi\xc3\xb3 \xc3\xa9s la inst\xc3\xa0ncia, cada m\xc3\xa8tode \xc3\xa9s representat per un bot\xc3\xb3 i el conjunt de botons compr\xc3\xa8n la interf\xc3\xadcie. En la seva forma m\xc3\xa9s comuna, una interf\xc3\xadcie \xc3\xa9s una especificaci\xc3\xb3 d\'un grup de m\xc3\xa8todes relacionats sense cap implementaci\xc3\xb3 associada dels m\xc3\xa8todes._NEWLINE_Cada classe implementa una interf\xc3\xadcie, proveint d\'estructura (\xc3\xa9s a dir, dada i estat) i implementacions de m\xc3\xa8todes (\xc3\xa9s a dir, proveint de codi que especifica com funcionen els m\xc3\xa8todes). Hi ha una distinci\xc3\xb3 entre la definici\xc3\xb3 d\'una interf\xc3\xadcie i la implementaci\xc3\xb3 d\'aquesta interf\xc3\xadcie. En la majoria de llenguatge, aquesta l\xc3\xadnia acostuma a ser difusa. Alguns llenguatge tanmateix, aporten caracter\xc3\xadstiques que ajuden a separar interf\xc3\xadcies i implementaci\xc3\xb3. Per exemple, una classe abstracta pot definir una interf\xc3\xadcie sense proveir d\'implementaci\xc3\xb3, mentre al llenguatge Dylan, les definicions de classe ni tan sols defineixen interf\xc3\xadcies._NEWLINE_Les interf\xc3\xadcies tamb\xc3\xa9 poden ser definides per incloure un conjunt de funcions auxiliars, anomenades m\xc3\xa8todes est\xc3\xa0tics o m\xc3\xa8todes de classe. Els m\xc3\xa8todes est\xc3\xa0tics, com m\xc3\xa8todes d\'inst\xc3\xa0ncia, estan exclusivament associats amb la classe. La difer\xc3\xa8ncia amb els m\xc3\xa8todes d\'inst\xc3\xa0ncia \xc3\xa9s que no treballen amb inst\xc3\xa0ncies de la classe; aix\xc3\xad, els m\xc3\xa8todes est\xc3\xa0tics, ni requereixen una inst\xc3\xa0ncia de la classe ni poden accedir a les dades de cap inst\xc3\xa0ncia. Per exemple, donar la informaci\xc3\xb3 del fabricant d\'un reproductor pot ser un m\xc3\xa8tode est\xc3\xa0tic. Aquest m\xc3\xa8tode \xc3\xa9st\xc3\xa0 clarament associat a la classe, encara que est\xc3\xa0 fora del domini de cada inst\xc3\xa0ncia individual de la classe._NEWLINE_Els llenguatges que suporten her\xc3\xa8ncia de classe tamb\xc3\xa9 permeten a les classe que heretin interf\xc3\xadcies de les classes de les que deriven. En llenguatges que suporten Classe (inform\xc3\xa0tica)#Amagar i encapsular encapsulaci\xc3\xb3, es considera que la interf\xc3\xadcie d\'una classe \xc3\xa9s el conjunt de m\xc3\xa8todes i atributs p\xc3\xbablics que t\xc3\xa9 (via m\xc3\xa8todes getter i setter); se suposa que cap m\xc3\xa8tode privat o estructura interna de dades s\xc3\xb3n coneguts per qui fa servir la classe i per tant no formen part de la interf\xc3\xadcie._NEWLINE_La metodologia de programaci\xc3\xb3 a objectes est\xc3\xa0 dissenyada de manera que les operacions de qualsevol interf\xc3\xadcie d\'una classe s\xc3\xb3n fetes independents unes de les altres. Aix\xc3\xb2 ens aboca a disseny client-servidor (o per capes) on els servidors no depenen de cap manera dels clients. Una interf\xc3\xadcie no empla\xc3\xa7a els clients a cap requeriment per invocar les operacions de la classe en cap ordre en particular. Aquesta t\xc3\xa8cnica t\xc3\xa9 el benefici que el codi del client pot assumir d\'una interf\xc3\xadcie estan disponibles per ser usades en qualsevol moment en qu\xc3\xa8 l\'objecte apunta a una refer\xc3\xa8ncia v\xc3\xa0lida.\n_START_SECTION_\nEstructura d\'una classe\n_START_PARAGRAPH_\nDonat que t\xc3\xa9 una interf\xc3\xadcie, una classe cont\xc3\xa9 una descripci\xc3\xb3 d\'estructura de dades emmagatzemades a les respectives inst\xc3\xa0ncies de la classe. Les dades estan particionades en atributs (o camps, propietats membres de les dades). Tornant a l\'exemple del televisor, les caracter\xc3\xadstiques visibles, com la mida i si suporta color, tots junts, conformen l\'estructura. Una classe representa la descripci\xc3\xb3 completa d\'un televisor, incloent els seus atributs (estructura) i botons (interf\xc3\xadcie)._NEWLINE_L\'estat de les dades d\'una inst\xc3\xa0ncia est\xc3\xa0 emmagatzemat en algun dispositiu, com la mem\xc3\xb2ria o un fitxer. S\'assumeix que l\'emmagatzematge es troba en un lloc concret, on se\'n pot accedir a la inst\xc3\xa0ncia a trav\xc3\xa9s de refer\xc3\xa8ncies a la identitat de les inst\xc3\xa0ncies. Tanmateix, el lloc on es pot trobar en un moment donat, pot acabar variant. En aquests casos la identitat de l\'objecte no canvia. L\'estat est\xc3\xa0 encapsulat i cada acc\xc3\xa9s a l\'estat es fa a trav\xc3\xa9s dels m\xc3\xa8todes de la classe._NEWLINE_Una classe tamb\xc3\xa9 descriu un conjunt d\'invariants els quals s\xc3\xb3n preservats per tots els seus m\xc3\xa8todes. El prop\xc3\xb2sit principal dels invariants \xc3\xa9s establir. Un invariant \xc3\xa9s una restricci\xc3\xb3 sobre l\'estat d\'una inst\xc3\xa0ncia que ha de ser sempre satisfet. El principal prop\xc3\xb2sit dels invariants \xc3\xa9s dir quins objectes pertanyen a la classe. Un invariant distingeix tipus de dades i classes entre elles; aix\xc3\xb2 \xc3\xa9s, una classe no permet usar tots els possibles valors per l\'estat de la inst\xc3\xa0ncia i al seu lloc nom\xc3\xa9s permet els valors ben definits per la sem\xc3\xa0ntica de l\'\xc3\xbas pel qual el tipus de dades ha estat definit. Els m\xc3\xa8todes (p\xc3\xbablics) suportats sovint estableixen una invariant de forma impl\xc3\xadcita. Alguns llenguatges de programaci\xc3\xb3 suporten l\'especificaci\xc3\xb3 d\'invariants com a part de la definici\xc3\xb3 de la classe i les forcen arreu del tipus. L\'encapsulaci\xc3\xb3 de l\'estat \xc3\xa9s necess\xc3\xa0ria per ser capa\xc3\xa7 de for\xc3\xa7ar les invariants de la classe._NEWLINE_Alguns llenguatges permeten que la implementaci\xc3\xb3 de la classe especifiqui m\xc3\xa8tode constructor i destructor i permeten crear i destruir objectes de la classe. Un constructor que admet par\xc3\xa0metres pot ser usat per crear objectes amb dades. El prop\xc3\xb2sit principal d\'un constructor \xc3\xa9s el d\'establir la invariant de la classe, generant un error si l\'invariant no \xc3\xa9s v\xc3\xa0lid. El prop\xc3\xb2sit principal d\'un destructor \xc3\xa9s el de destruir la identitat de l\'objecte, invalidant qualsevol refer\xc3\xa8ncia cap a ella dintre del proc\xc3\xa9s. En alguns llenguatges, un destructor pot retornar un valor que pot ser usat per obtenir un representaci\xc3\xb3 p\xc3\xbablica (codificaci\xc3\xb3 de transfer\xc3\xa8ncia) d\'un objecte d\'una classe i simult\xc3\xa0niament destruir la c\xc3\xb2pia de l\'objecte emmagatzemat a la mem\xc3\xb2ria de l\'actual fil. Els constructors i els destructors tamb\xc3\xa9 s\xc3\xb3n, de vegades, usats per reservar i alliberar, respectivament, recursos associats amb l\'objecte. De vegades, els constructors i destructors estan especificats com m\xc3\xa8todes est\xc3\xa0tics._NEWLINE_Una classe pot tamb\xc3\xa9 contenir camps est\xc3\xa0tics o camps de classe, que contenen dades que estan especificades respecte a la classe, tot i que a part de qualsevol inst\xc3\xa0ncia. Si la classe en si mateixa \xc3\xa9s tractada com una inst\xc3\xa0ncia d\'una hipot\xc3\xa8tica metaclasse, els camps i m\xc3\xa8todes est\xc3\xa0tics serien camps i m\xc3\xa8todes d\'inst\xc3\xa0ncia d\'aquella metaclasse.\n_START_SECTION_\nRepresentaci\xc3\xb3 d\'una classe en temps d\'execuci\xc3\xb3\n_START_PARAGRAPH_\nCom un tipus de dades, una classe acostuma a ser considerada com una construcci\xc3\xb3, en temps d\'execuci\xc3\xb3. Un llenguatge tamb\xc3\xa9 pot suportar prototipus o metaobjectes factoria que representen informaci\xc3\xb3 en temps d\'execuci\xc3\xb3 sobre classes o fins i tot representen metadades que proveeixen acc\xc3\xa9s a funcionalitats de reflexi\xc3\xb3 per manipular formats d\'estructures de dades. Molts llenguatge distingeixen aquest tipus d\'informaci\xc3\xb3 sobre classes des d\'una classe sobre la base que la informaci\xc3\xb3 no t\xc3\xa9 per qu\xc3\xa8 per qu\xc3\xa8 ser necessitada en temps d\'execuci\xc3\xb3. Alguns llenguatges din\xc3\xa0mics no fan distincions estrictes entre construccions en temps d\'execuci\xc3\xb3 i de compilaci\xc3\xb3 tampoc no distingirien entre metaobjectes ni classes._NEWLINE_Per exemple: si Hum\xc3\xa0 \xc3\xa9s un metaobjecte que representa la classe Persona, les inst\xc3\xa0ncies de Persona poden ser creades usant els recursos el metaobjecte hum\xc3\xa0.\n_START_SECTION_\nAssociacions entre classes\n_START_PARAGRAPH_\nEn disseny orientat a objectes i UML, una associaci\xc3\xb3 entre dues classes \xc3\xa9s un tipusd\'enlla\xc3\xa7 entre els objectes corresponents. Una associaci\xc3\xb3 bidireccional entre classes A i B descriu una relaci\xc3\xb3 entre qualsevol inst\xc3\xa0ncia de la classe A i alguns objectes de la classe B, i viceversa. Les associacions sovint s\xc3\xb3n anomenades amb un verb, com podria ser "pertany a"._NEWLINE_Un tipus de rol d\'associaci\xc3\xb3 descriu el tipus de rol d\'una inst\xc3\xa0ncia d\'una classe quan la inst\xc3\xa0ncia participa en una associaci\xc3\xb3. Un tipus de rol d\'associaci\xc3\xb3 es relaciona amb l\'altre extrem de l\'associaci\xc3\xb3. Un rol descriu una inst\xc3\xa0ncia d\'una classe des del punt de vista d\'una situaci\xc3\xb3 a la qual la inst\xc3\xa0ncia participa en l\'associaci\xc3\xb3. Els tipus de rol s\xc3\xb3n col\xc2\xb7leccions d\'inst\xc3\xa0ncies de rol agrupades per les seves propietats semblants. Per exemple, un rol de tipus "subscriptor" descriu la propietat comuna a inst\xc3\xa0ncies de la classe "Persona" quan participen en una relaci\xc3\xb3 "se susbcriu a" amb la classe "Revista". Tamb\xc3\xa9, una "Revista" t\xc3\xa9 el tipus de rol "revista subscrita" quan els subscriptors s\'hi subscriuen._NEWLINE_La multiplicitat en el rol de l\'associaci\xc3\xb3 descriu quantes inst\xc3\xa0ncies corresponen a cada inst\xc3\xa0ncia de les altres classes de l\'asscociaci\xc3\xb3. Les multiplicitats habituals s\xc3\xb3n: "0..1", "1..1", "1..*" i "0..*", on "*" vol dir qualsevol nombre d\'inst\xc3\xa0ncies. _NEWLINE_Hi ha alguns tipus especials d\'associacions entre classes.\n_START_SECTION_\nComposici\xc3\xb3\n_START_PARAGRAPH_\nLa composici\xc3\xb3 entre la classe A i la classe B descriu una relaci\xc3\xb3 de "part-de" on les inst\xc3\xa0ncies de la classe B tenen un temps de vida m\xc3\xa9s curt que les inst\xc3\xa0ncies corresponents de la classe A. Hom diu que la classe B \xc3\xa9s part de la classe A. Aix\xc3\xb2 sovint \xc3\xa9s implementat en llenguatges de programaci\xc3\xb3 emmagatzemant les dades de la inst\xc3\xa0ncia d\'A de tal manera que ja contenen les dades de B._NEWLINE_L\'agregaci\xc3\xb3 \xc3\xa9s una variant de la composici\xc3\xb3 on les inst\xc3\xa0ncies d\'una classe s\xc3\xb3n part d\'inst\xc3\xa0ncies de l\'altra classe, per\xc3\xb2 sense caler la restricci\xc3\xb3 sobre el temps de vida m\xc3\xa9s curt. La implementaci\xc3\xb3 de l\'agregaci\xc3\xb3 es fa sovint mitjan\xc3\xa7ant un Punter o refer\xc3\xa8ncia a la int\xc3\xa0ncia continguda. En ambd\xc3\xb3s casos, les implementacions dels m\xc3\xa8todes de les classes continents poden invocar m\xc3\xa8todes de la classe continguda. Un exemple habitual de l\'agregaci\xc3\xb3 \xc3\xa9s una llista. Que acabi el temps de vida d\'una llista, no necess\xc3\xa0riament implica que tamb\xc3\xa9 acabi el temps de vida de la classe continguda.\n_START_SECTION_\nLlenguatges sense her\xc3\xa8ncia\n_START_PARAGRAPH_\nTot i que s\'assumeix que els llenguatges basats en classes suporten her\xc3\xa8ncia, aquest no \xc3\xa9s un aspecte intr\xc3\xadnsec al concepte de les classes. Hi ha llenguatges que suporten classes tot i que no suporten hern\xc3\xa8ncia, com ara les primeres versions de Visual Basic. Aquests llenguatges no aporten els beneficis estructurals de les interf\xc3\xadcies de comprovaci\xc3\xb3 de tipus de manera est\xc3\xa0tica. Aix\xc3\xb2 \xc3\xa9s causat perqu\xc3\xa8 en llenguatges basats en objectes, \xc3\xa9s possible usar i estendre estructures de dades i afegir-hi m\xc3\xa8todes en temps d\'execuci\xc3\xb3. Aix\xc3\xb2 prev\xc3\xa9 el compilador o int\xc3\xa8rpret de ser capa\xc3\xa7 de comprovar el tipus d\'informaci\xc3\xb3 especificat al codi font, ja que el tipus \xc3\xa9s constru\xc3\xaft din\xc3\xa0micament i no definit de manera est\xc3\xa0tica.\n_START_SECTION_\nCategories de classes\n_START_PARAGRAPH_\nHi ha moltes categories de classes que depenen de modificadors. Noteu que aquestes categories no necess\xc3\xa0riament categoritzen classes en particions diferents. Per exemple, mentre \xc3\xa9s impossible tenir una classe que \xc3\xa9s tant abstracta com concreta, una classe instanciada \xc3\xa9s impl\xc3\xadcitament una classe concreta i podria ser que una part d\'ella est\xc3\xa8s definida en una classe abstracta.\n_START_SECTION_\nClasse concreta\n_START_PARAGRAPH_\nUna classe concreta \xc3\xa9s una classe que pot ser instanciada. Aix\xc3\xb2 contrasta amb classes abstractes, tal com es descriu a sota.\n_START_SECTION_\nClasse abstracta\n_START_PARAGRAPH_\nUna classe abstracta o classe base abstracta, \xc3\xa9s una classe que no pot ser instanciada. Una classe aix\xc3\xad nom\xc3\xa9s pot tenir significat si el llenguatge suporta her\xc3\xa8ncia. Una classe abstracta nom\xc3\xa9s \xc3\xa9s dissenyada com una classe pare de qui les classes filles podenser derivades. Les classes abstractes s\xc3\xb3n usades sovint per representar conceptes abstractes o entitats. Aquestes caracter\xc3\xadstiques incompletes de la classe abstracta s\xc3\xb3n llavors compartides per un grup de subclasses que afegeixen diferents variacions de les parts que manquen._NEWLINE_Les classes abstractes s\xc3\xb3n superclasses que contenen m\xc3\xa8todes abstractes i s\xc3\xb3n definides de manera que les subclasses concretes les han d\'estendre implementant els seus m\xc3\xa8todes. Els comportaments definits per una classe com aquesta s\xc3\xb3n gen\xc3\xa8rics i romandr\xc3\xa0 sense definir o sense implementar. Abans que una classe derivada d\'una classe abstracta, com ara, una classe que pot ser instanciada, ha d\'implementar m\xc3\xa8todes particulars per tots els m\xc3\xa8todes abstractes de les classe pare._NEWLINE_Quan especifiquem una classe abstracta, el programador es refereix a una classe que t\xc3\xa9 elements que se suposa que han de ser implementats per her\xc3\xa8ncia. L\'abstracci\xc3\xb3 dels m\xc3\xa8todes de la classe que han de ser implementats per les subclasses, est\xc3\xa0 pensada per simplificar el desenvolupament de les aplicacions. Aix\xc3\xb2 tamb\xc3\xa9 permet que el programador se centri en la planificaci\xc3\xb3 i el disseny._NEWLINE_La majoria de llenguatges de programaci\xc3\xb3 orientada a objectes permet que el programador especifiqui quines classes es consideren abstractes i no permetran que aquestes siguin instanciades. Per exemple, en Java es fa servir la paraula marcada abstract per aquest prop\xc3\xb2sit. En C++, una classe abstracta \xc3\xa9s aquella que t\xc3\xa9 almenys un m\xc3\xa8tode abstracte._NEWLINE_Alguns llenguatges, notablement Java, suporten de manera addicional una variant de les classes abstractes, anomenades interf\xc3\xadcies. Aquestes contenen m\xc3\xa8todes accessibles p\xc3\xbablicament. D\'aquesta manera, estan estretament relacionades (per\xc3\xb2 no equivalents) al concepte abstracte d\'interf\xc3\xadcies, descrit en aquest article.\n_START_SECTION_\nClasses sealed\n_START_PARAGRAPH_\nAlguns llenguatges tamb\xc3\xa9 suporten les classes sealed (permeables), que no poden ser usades com classes base, de manera que no poden ser abstractes. B\xc3\xa0sicament es fan servir per evitar la derivaci\xc3\xb3. Afegeixen un nivell addicional d\'estrictesa en temps de compilaci\xc3\xb3, milloren l\'\xc3\xbas de la mem\xc3\xb2ria i impulsen certes optimitzacions que milloren l\'efici\xc3\xa8ncia en temps d\'execuci\xc3\xb3.\n_START_SECTION_\nClasses locals i imbricades\n_START_PARAGRAPH_\nEn alguns llenguatges, les classes poden ser declarades en \xc3\xa0mbits a part del global. N\'hi ha de diversos tipus._NEWLINE_Un tipus habitual \xc3\xa9s una classe imbricada o inner que est\xc3\xa0 definida dintre d\'una altra classe. En implicar dues classes, podem dir que parlem d\'una associaci\xc3\xb3 de classes. Els m\xc3\xa8todes d\'una classe inner poden accedir als m\xc3\xa8todes est\xc3\xa0tics de les que les allotgen. No \xc3\xa9s t\xc3\xadpic que una classe imbricada estigui associada a la classe allotjant. Segons el llenguatge, es pot o no referenciar a aquestes classes des de fora de les que les allotgen. Un concepte relacionat \xc3\xa9s el dels tipus inner (tamb\xc3\xa9 tipus de dades inner, tipus imbricat) que \xc3\xa9s la generalitzaci\xc3\xb3 del concepte de les classes inner. C++ \xc3\xa9s un exemple de llenguatge que ofereix suport a classes i tipus inner (via declaracions typedef)._NEWLINE_Un altre tipus \xc3\xa9s una classe local, que \xc3\xa9s una classe declarada a dintre d\'un m\xc3\xa8tode. Aix\xc3\xb2 limita les refer\xc3\xa8ncies al nom de classe a l\'interior de l\'\xc3\xa0mbit al qual ha estat referenciada la classe. Depenent de les regles sem\xc3\xa0ntiques de la classe, hi poden haver restriccions addicionals per les classes local, que no tenen les que no en s\xc3\xb3n. Una d\'habitual \xc3\xa9s que els m\xc3\xa8todes de la classe local accedeixin a les variables del m\xc3\xa8tode que les allotja. Per exemple, en C++, a una classe local se li permet referenciar variables est\xc3\xa0tiques declarades a dintre del m\xc3\xa8tode que les allotja, per\xc3\xb2 poden accedir a les seves variables autom\xc3\xa0tiques.\n_START_SECTION_\nMetaclasses\n_START_PARAGRAPH_\nLes metaclasses s\xc3\xb3n classes les inst\xc3\xa0ncies de les quals s\xc3\xb3n classes. Una metaclasse descriu una estructura comuna d\'una col\xc2\xb7lecci\xc3\xb3 de classes. Una metaclasse pot implementar un patr\xc3\xb3 de disseny o descriure una alternativa r\xc3\xa0pida per tipus de classes particualrs. Les metaclasses tamb\xc3\xa9 s\xc3\xb3n usades per descriure entorns de treball._NEWLINE_En alguns llenguatges com Python, Ruby, Java i Smalltalk, una classe \xc3\xa9s tamb\xc3\xa9 un objecte, de manera que cada classe \xc3\xa9s una inst\xc3\xa0ncia d\'una \xc3\xbanica metaclasse, constru\xc3\xafda al llenguatge. Per exemple, en Objective-C, cada objecte i classe \xc3\xa9s una inst\xc3\xa0ncia de NSObject. El Sistema d\'objectes de Common Lisp proveeix protocols de metaobjecte] (MOPs) per implementar aquestes classes i metaclasses.\n_START_SECTION_\nClasses parcials\n_START_PARAGRAPH_\nLes classes parcials s\xc3\xb3n classes que poden ser dividides en m\xc3\xbaltiples definicions (t\xc3\xadpicament sobre m\xc3\xbaltiples fitxers), fent m\xc3\xa9s f\xc3\xa0cil aclarir-se amb grans quantitats de codi. En temps de compilaci\xc3\xb3 acaben quedant agrupades, de manera que no hi ha difer\xc3\xa8ncia en el resultat final. Un exemple de l\'\xc3\xbas de classes parcials \xc3\xa9s la separaci\xc3\xb3 de la l\xc3\xb2gica de la interf\xc3\xadcie d\'usuari i el processament l\xc3\xb2gic. Un benefici primari de les classes parcials \xc3\xa9s el de permetre a diferents programadors treballar en diferents parts de la mateixa classe de forma simult\xc3\xa0nia. Tamb\xc3\xa9 generen codi m\xc3\xa9s f\xc3\xa0cil d\'interpretar._NEWLINE_Les classes parcials han estat funcionant a Smalltalk sota el nom d\'Extensions de classes (Class Extensions) durant bastant temps. Amb l\'arribada de l\'entorn de treball .NET2, Microsoft va introduir les classes parcials, suportades tant per C# i Visual Basic 2005.\n_START_SECTION_\nProgramaci\xc3\xb3 a objectes no basada en classes\n_START_PARAGRAPH_\nPer sorpresa de qui est\xc3\xa0 acostumat a usar classes, aquestes no s\xc3\xb3n l\'\xc3\xbanica manera de porta a terme la programaci\xc3\xb3 orientada a objectes. Una altra manera \xc3\xa9s la programaci\xc3\xb3 basada en prototipus. Els llenguatges que suporten programaci\xc3\xb3 no basada en classes acostumen a estar dissenyats amb la idea d\'adre\xc3\xa7ar el problema del fort aparellament entre implementacions i interf\xc3\xadcies a causa de l\'\xc3\xbas de classes. Per exemple, el llenguatge Self, basat en prototipus, fou dissenyat per mostrar que el rol d\'una classe pot ser substitu\xc3\xaft usant un objecte encara existent que serveix com a prototipus d\'un objecte nou i el resultat llenguatge resultant \xc3\xa9s tan expressiu com Smalltalk amb m\xc3\xa9s generalitzaci\xc3\xb3 en la creaci\xc3\xb3 d\'objectes.\n_START_SECTION_\nExemple 1\n_START_PARAGRAPH_\n#include <iostream>#include <string>using namespace std;class Hola{_NEWLINE_ string que;_NEWLINE__NEWLINE_ public:_NEWLINE_ Hola(const string& s)_NEWLINE_ : que(s)_NEWLINE_ {_NEWLINE_ }_NEWLINE__NEWLINE_ void digues()_NEWLINE_ {_NEWLINE_ cout << "Hola " << que << "!" << endl;_NEWLINE_ }};int main( int argc, char** argv ){_NEWLINE_ Hola hola_mon("m\xc3\xb3n");_NEWLINE_ hola_m\xc3\xb3n.digues();_NEWLINE__NEWLINE_ return 0;}_NEWLINE_Aquest exemple mostra com definir una classe en C++ anomenada "Hola". T\xc3\xa9 un atribut de tipus string privat anomenat "que", i un m\xc3\xa8tode p\xc3\xbablic anomenat "digues".\n_START_SECTION_\nExemple 2\n_START_PARAGRAPH_\nclass ClasseAbstracta{public:_NEWLINE_ virtual void MetodeVirtual() = 0;};class ClasseConcrete : public ClasseAbstracta{public:_NEWLINE_ void MetodeVirtual()_NEWLINE_ {_NEWLINE_ //fes el que toqui_NEWLINE_ }};_NEWLINE_Un objecte d\'una classe ClasseAbstracta no pot ser creat perqu\xc3\xa8 la funci\xc3\xb3 MetodeVirtual no ha estat definida (el =0 \xc3\xa9s una sintaxi C++ per una funci\xc3\xb3 virtual pura, una funci\xc3\xb3 que ha de tenir una part d\'una classe concreta que en derivi per\xc3\xb2 que no est\xc3\xa0 definida a la classe base abstraxcta. La classe ClasseConcreta \xc3\xa9s una classe concreta perqu\xc3\xa8 les seves funcipns (en aquest cas, la seva funci\xc3\xb3)ha estat declarada i implementada.\n_START_SECTION_\nExemple 3\n_START_PARAGRAPH_\n#include <string>#include <iostream>using namespace std;class MissatgeInet{_NEWLINE_ string m_assumpte, m_a, m_de;public:_NEWLINE_ MissatgeInet (const string& assumpte,_NEWLINE_ const string& a,_NEWLINE_ const string& de) : m_assumpte(assumpte), m_a(a), m_de(de) { }_NEWLINE_ string assumpte () const { return m_assumpte; }_NEWLINE_ string a () const { return m_a; }_NEWLINE_ string de () const { return m_de; }_NEWLINE_ virtual void escriuA(ostream &out) _NEWLINE_ {_NEWLINE_ out << "Assumpte: " << m_assumpte << endl;_NEWLINE_ out << "A: " << m_de << endl;_NEWLINE_ out << "A: " << m_a << endl;_NEWLINE_ }};\n_START_SECTION_\nExemple 1\n_START_PARAGRAPH_\npublic class Exemple1{_NEWLINE_ // Aquesta \xc3\xa9s una classe Java, de forma autom\xc3\xa0tica ext\xc3\xa8 la classe objecte_NEWLINE_ public static void main (String args[]) _NEWLINE_ {_NEWLINE_ System.out.println("Hola m\xc3\xb3n!");_NEWLINE_ }}_NEWLINE_Aquest exemple mostra un simple hola m\xc3\xb3n.\n_START_SECTION_\nExemple 2\n_START_PARAGRAPH_\npublic class Exemple2 extends Exemple1{_NEWLINE_ // Aquesta classe ext\xc3\xa8 la classe creada a l\'exemple 1._NEWLINE_ protected int dada;_NEWLINE__NEWLINE_ public Exemple2()_NEWLINE_ {_NEWLINE_ // Aquest \xc3\xa9s un cosntructor per la classe. No retorna cap tipus. _NEWLINE_ dada = 1;_NEWLINE_ }_NEWLINE__NEWLINE_ public int getDada()_NEWLINE_ {_NEWLINE_ return dada;_NEWLINE_ }_NEWLINE__NEWLINE_ public void setDada(int d)_NEWLINE_ {_NEWLINE_ dada = d;_NEWLINE_ }}_NEWLINE_Aquest exemple mostra una classe que t\xc3\xa9 un constructor definit, una dada membre, un m\xc3\xa8tode accessor (getDada) i un m\xc3\xa8tode modificador (setDada) per un atribut dada. Ext\xc3\xa8 la classe d\'exemple anterior. Noteu que en Java, totes les classes estenen autom\xc3\xa0ticament la classe Object. Aix\xc3\xb2 permet escriure codi gen\xc3\xa8ric per gestionar objectes de qualsevol tipus.\n_START_SECTION_\nExemple 1\n_START_PARAGRAPH_\nClass Hola_NEWLINE_ Private que as String_NEWLINE__NEWLINE_ Sub New( ByVal s as String )_NEWLINE_ what = s_NEWLINE_ End Sub_NEWLINE__NEWLINE_ Sub Digues()_NEWLINE_ MessageBox.Show("Hola " & que )_NEWLINE_ End SubEnd Class_NEWLINE_ _NEWLINE_Sub Main()_NEWLINE_ Dim h As New Hello( "Foobar" )_NEWLINE_ h.Digues()End Sub_NEWLINE_Aquest exemple \xc3\xa9s un port de l\'exemple C++ de dalt. Ens mostra com fer una classe anomenada Hola amb una propietat privada anomenada que. Tamb\xc3\xa9 ens mostra l\'\xc3\xbas apropiat d\'un constructor, i t\xc3\xa9 un m\xc3\xa8tode p\xc3\xbablic anomenat Digues. Tamb\xc3\xa9 ens mostra com instanciar la classe i cridar el m\xc3\xa8tode Digues.\n_START_SECTION_\nExemple 1\n_START_PARAGRAPH_\n<?phpclass A {_NEWLINE_ public function foo() {_NEWLINE_ if (isset($this)) {_NEWLINE_ echo \'$this est\xc3\xa0 definit (\';_NEWLINE_ echo get_class($this);_NEWLINE_ echo ")\\n";_NEWLINE_ } else {_NEWLINE_ echo "\\$this no est\xc3\xa0 definit.\\n";_NEWLINE_ }_NEWLINE_ }}?>\n_START_SECTION_\nExemple 2\n_START_PARAGRAPH_\n<?php_NEWLINE_class ObjecteDada_NEWLINE_{_NEWLINE_public function getTemps()_NEWLINE_{_NEWLINE_/** Per mode E_STRICT: * * date_default_timezone_set(\'CET\'); */_NEWLINE__NEWLINE_return(time());_NEWLINE_}_NEWLINE__NEWLINE_public function getDada()_NEWLINE_{_NEWLINE_return(date(\'jS F, Y\', $this->getTime());_NEWLINE_}_NEWLINE_}?>\n_START_SECTION_\nExemple 1\n_START_PARAGRAPH_\nusing System;public class Programa{_NEWLINE_ public static void Main(string[] args)_NEWLINE_ {_NEWLINE_ Console.WriteLine("Hola m\xc3\xb3n!");_NEWLINE_ }}_NEWLINE_Aquest exemple ens mostra un tradicional exemple "Hola m\xc3\xb3n!" en el llenguatge C# de Microsoft\'s C. La classe Programa cont\xc3\xa9 un m\xc3\xa8tode est\xc3\xa0tic simple, Main(), que crida System.Console.WriteLine per escriure un text cap a la sortida est\xc3\xa0ndard.\n_START_SECTION_\nExemple 2\n_START_PARAGRAPH_\nusing System;public class Hola{_NEWLINE_ private string que;_NEWLINE_ _NEWLINE_ public Hole(string s)_NEWLINE_ {_NEWLINE_ que = s;_NEWLINE_ }_NEWLINE_ _NEWLINE_ public void Digues()_NEWLINE_ {_NEWLINE_ Console.WriteLine("Hola " + que + "!");_NEWLINE_ }}public class Programa{_NEWLINE_ public static void Main(string[] args)_NEWLINE_ {_NEWLINE_ Hola holaMon = new Hola("m\xc3\xb3n");_NEWLINE_ holaMon.Digues(); // escriu "Hola m\xc3\xb3n!" cap a la sortida est\xc3\xa0ndard_NEWLINE_ }}_NEWLINE_Aquest \xc3\xa9s un altre port de l\'exemple C++ de dalt. Una classe anomenada Hola \xc3\xa9s creada amb un constructor que pern un par\xc3\xa0metre string. Quan s\'invoca el m\xc3\xa8tode Digues(), la inst\xc3\xa0ncia de Hola escriur\xc3\xa0 "Hola {que}!" cap a la sortida est\xc3\xa0ndard. Noteu que el m\xc3\xa8tode Main() (punt d\'entrada) pot ser trobat dintre mateix de la classe.\n_START_SECTION_\nExemple 1\n_START_PARAGRAPH_\nclass Cart {_NEWLINE__NEWLINE_ private var cart:Array;_NEWLINE__NEWLINE_ public function Cart() {_NEWLINE_ this.cart = new Array();_NEWLINE_ }_NEWLINE__NEWLINE_ public function addItem(id:Number, name:String):Void {_NEWLINE_ this.cart.push([id, name]);_NEWLINE_ }_NEWLINE__NEWLINE_ public function removeItemById(id:Number):Void {_NEWLINE_ var ln:Number = this.cart.length;_NEWLINE_ for (var i:Number = 0; i<ln; i++) {_NEWLINE_ var curr:Array = this.cart[i];_NEWLINE_ if (curr[0] == id) this.cart.splice(i, 1);_NEWLINE_ }_NEWLINE_ }_NEWLINE__NEWLINE_ public function removeItemByName(name:String):Void {_NEWLINE_ var ln:Number = this.cart.length;_NEWLINE_ for (var i:Number = 0; i<ln; i++) {_NEWLINE_ var curr:Array = this.cart[i];_NEWLINE_ if (curr[1] == name) this.cart.splice(i, 1 );_NEWLINE_ }_NEWLINE_ }}\n_START_SECTION_\nExemple 1\n_START_PARAGRAPH_\nclass Hola_NEWLINE_ def self.hola_NEWLINE_ string = "Hola m\xc3\xb3n!"_NEWLINE_ return string_NEWLINE_ endend_NEWLINE_Una classe Ruby Hola, amb un m\xc3\xa8tode hola. Aquest m\xc3\xa8tode retorna la variable string, que \xc3\xa9s canviada a "Hola m\xc3\xb3n!".\n_START_SECTION_\nExemple 1\n_START_PARAGRAPH_\nclass Hola:_NEWLINE_ def __init__(self): _NEWLINE_ print "Hola m\xc3\xb3n!"_NEWLINE_Una classe Python Hola, que escriu "Hola M\xc3\xb3n!" durant la seva creaci\xc3\xb3.'