Introducció a la programació orientada a objectes
-
Vicent Moncho Mas
Llicenciat en Ciències Matemàtiques i enginyer tècnic d'Informàtica. Professor associat de Matemàtica aplicada a la Universitat de València i director de Sistemes i Tecnologies de la Informació de l'Hospital de Dénia.
Índex
- 1.Introducció
- 1.1.La programació
- 1.2.Models de desenvolupament
- 1.2.1.Programació imperativa
- 1.2.2.Programació funcional
- 1.2.3.Programació lògica
- 1.2.4.Programació orientada a objectes
- 2.Conceptes i característiques principals
- 3.POO en els diversos llenguatges de programació
- 3.1.Smalltalk
- 3.2.Eiffel
- 3.3.C++
- 3.4.ActionScript 3.0
- 3.5.Ada
- 3.6.Perl
- 3.7.PHP
- 3.8.C#
- 3.9.Java
- 3.10.JavaScript
1.Introducció
1.1.La programació
1.2.Models de desenvolupament
-
Programació imperativa.
-
Programació funcional.
-
Programació lògica.
-
Programació orientada a objectes.
1.2.1.Programació imperativa
1.2.2.Programació funcional
1.2.3.Programació lògica
-
Sistemes experts. El programa imita les recomanacions d'un expert sobre algun domini de coneixement.
-
Demostració automàtica de teoremes. El programa genera teoremes nous sobre una teoria existent.
-
Reconeixement de llenguatge natural. El programa és capaç de comprendre (amb limitacions) la informació que conté una expressió lingüística humana.
1.2.4.Programació orientada a objectes
2.Conceptes i característiques principals
-
El foment de la reutilització i extensió del codi.
-
L'elaboració de sistemes més complexos.
-
La relació del sistema amb el món real.
-
La creació de programes visuals.
-
La construcció de prototips.
-
L'agilitació del desenvolupament de programari.
-
La facilitació del treball en equip.
-
El manteniment més senzill del programari.
2.1.El model orientat a objectes
-
Classes.
-
Objectes.
-
Herència.
-
Tramesa de missatges.
2.1.1.Classes
class elMeuPunt {
}class Nom_De_Classe {
tipus_de_variable nom_de_propietat1;
tipus_de_variable nom_de_propietat2;
// . . .
tipus_retornat nom_de_metode1( llista_de_parametres ) {
cos_del_metode1;
}
tipus_retornat nom_de_metode2( llista_de_parametres ) {
cos_del_metode2;
}
// . . .
}class elMeuPunt {
int x, y;
}int metodeSuma( int paramX, int paramY ) {
return ( paramX + paramY );
}void metodeBuit( ) { };void inicia( int paramX, int paramY ) {
x = paramX;
y = paramY;
}-
La classe modelitza un punt d'espai i, per tant, disposa de dues propietats que defineixen les coordenades que té.
-
La classe disposa de dos mètodes: el primer fa la suma de les dues coordenades i torna el valor, i el segon calcula la distància entre el punt propi i les coordenades del punt passat com a paràmetre.
//Definim una classe elmeuPunt amb:
//un mètode metodeSuma que ens retorna la suma de les dues coordenades que es passen com a paràmetres
//un mètode distancia que calcula la distància entre el punt passat com a paràmetre i el punt de
//l'objecte
//un mètode metodeBuit que no fa res!
class elmeuPunt{
//Definim dos propietats x e y, que defineixen les coordenades de l'objecte punt
int x, y;
//Definim un mètode que torna el valor de la suma dels dos valors enters que se li passen com a
//paràmetres
int metodeSuma( int paramX, int paramY ) {
return ( paramX + paramY );
}
//Definim una funció que ens torna la distància entre el punt objecte i el que és passat per paràmetre
double distancia( int x, int y ) {
//Assignem a la variable dx la diferència entre la coordenada x de l'objecte (this.x) i la
//coordenada x passada pel paràmetre
int dx= this.x - x;
//Assignem a la variable dy la diferència entre la coordenada y de l'objecte (this.y) i la
//coordenada y passada pel paràmetre
int dy = this.y - y;
//Tornem el resultat de l'arrel quadrada de la suma de dx i dy, per tant la distància entre dos punts
return Math.sqrt( dx*dx + dy*dy );
}
//Definim un mètode buit que no fa res.
void metodeBuit( ) { }
//Definim un mètode que inicialitza l'objecte amb els valors que es passen com a paràmetre
//de forma que ja tenim el primer objecte elmeuPunt amb les coordenades definides
void inicia( int paramX, int paramY ) {
x = paramX;
y = paramY;
}
//Definim un nou mètode inicialitzador, però al no ficar la paraula this, no s'està assignant a
//la variable d'instancia, sino a la mateixa que tenim al mètode, per lo que en aquest mètode
//realment sols es modifica la variable y
void inicia2( int x, int y ) {
x = x;
this.y = y;
}
//Definim un mètode constructor elmeuPunt, on tenim dos paràmetres que s'assignen a les
//propietats de la instància x e y
elmeuPunt( int paramX, int paramY ) {
this.x = paramX; // En aquesta línia this es pot obviar, ja que x correspon
// a la variable de la funció però com que es tracta
// del constructor es la pròpia instància de la classe
y = paramY; // Aquesta línia es equivalent a l'anterior
}
//Definim un mètode constructor elmeuPunt, on com no rebem cap paràmetre s'inicialitza amb les
//coordenades (-1,-1)
elmeuPunt() {
inicia(-1,-1);
}
}2.1.2.Objectes
elmeuPunt p;
elmeuPunt( ) {
inicia( -1, -1 );
}elmeuPunt( int paraX, int paraY ) {
inicia( paraX, paraY );
}elmeuPunt p2 = new elmeuPunt(2,3);
elmeuPunt p3 = p2;
p2 = null; // p3 encara apunta l'objecte creat amb new
referencia_a_objecte.nom_de_variable_d_instancia; referencia_a_objecte.nom_de_metode( llista-de-parametres );
elmeuPunt p3 = new elmeuPunt( 100, 200 ); p3.inicia( 300, 400 );
2.1.3.Herència
-
L'herència simple es produeix quan el llenguatge només permet que una classe derivi d'una classe. En l'exemple següent es veu com la classe punt hereta de la classe posició:
Figura 2
-
L'herència múltiple es produeix quan una classe es pot derivar de més d'una classe. L'exemple següent mostra com a partir de dues classes que defineixen objectes de so i imatge es pot crear una classe nova que hereti de les dues anteriors:
Figura 3
public class SubClasse extends SuperClasse {
// Contingut de la classe
}class elmeuPunt3D extends elmeuPunt {
int z;
elmeuPunt3D( ) {
x = 0; // Heretat del elmeuPunt
y = 0; // Heretat del elmeuPunt
z = 0; // Nova propietat
}
}-
public boolean equals( Object obj ): s'utilitza per a comparar, en valor, dos objectes. Torna true si l'objecte que rep per paràmetre és igual, en valor, que l'objecte des del qual es crida el mètode. Si es volen comparar dues referències a objecte es poden utilitzar els operadors de comparació (==) i (!=).
-
public int hashCode(): torna un codi hash per a aquest objecte, per a poder-lo emmagatzemar en una Hashtable.
-
protected Object clone() throws CloneNotSupportedException: torna una còpia d'aquest objecte.
-
public final Class getClass(): torna l'objecte concret, de tipus Class, que representa la classe d'aquest objecte.
-
protected void finalize() throws Trowable: fa accions durant la recuperació de memòria.
2.2.Característiques de la programació orientada a objectes
2.2.1.Abstracció
abstract class classeA {
abstract void metodeAbstracte();
void metodeConcret() {
//El mètode concret de classeA;
}
}
class classeB extends classeA {
void metodeAbstract(){
//El mètode abstracte de classeB;
}
}2.2.2.Ocultament o encapsulació
-
Restringir l'ús de la classe: hi ha cert comportament privat de la classe a què no poden accedir altres classes.
-
Controlar l'ús de la classe: hi ha certs mecanismes per a modificar l'estat de la classe i és amb aquests mecanismes que es valida que algunes condicions es compleixin.
-
Public: les propietats o els mètodes declarats amb public són accessibles des de qualsevol lloc en què sigui accessible la classe, i els hereten les subclasses.
-
Private: les propietats o els mètodes declarats private només són accessibles des de la classe.
-
Protected: les propietats o els mètodes declarats protected només són accessibles per a les seves subclasses.
class Pare { // Hereta d'Object
// Atributs
private int numeroFavorit, nascutFa, dinersDisponibles;
// Mètodes
public int getAposta() {
return numeroFavorit;
}
protected int getEdat() {
return nascutFa;
}
private int getSaldo() {
return dinersDisponibles;
}
}
class Filla extends Pare {
// Definició
}
class Visita {
// Definició
}2.2.3.Polimorfisme
class classeA {
void metodeDinamic() {
// El mètode dinàmic de classeA;
}
}
class classeB extends classeA {
void metodeDinamic() {
// El mètode dinàmic de classeB;
}
}classeA referenciaA = new classeB(); referenciaA.metodeDinamic();
class elmeuPunt3D extends elmeuPunt {
int x,y,z;
double distancia(int pX, int pY) { // Sobreescriptura
int retorn=0;
retorn += ((x/z)-pX)*((x/z)-pX);
retorn += ((y/z)-pY)*((y/z)-pY);
return Math.sqrt( retorn );
}
}elmeuPunt p3 = new elmeuPunt(1,1); elmeuPunt p4 = new elmeuPunt3D(2,2);
p3.distancia(3,3); //Mètode elmeuPunt.distancia(pX,pY) p4.distancia(4,4); //Mètode elmeuPunt3D.distancia(pX,pY)
elmeuPunt( ) { //Constructor per defecte
inicia( -1, -1 );
}
elmeuPunt( int paramX, int paramY ) { // Parametritzat
this.x = paramX;
y = paramY;
}elmeuPunt p1 = new elmeuPunt(); // Constructor per defecte elmeuPunt p2 = new elmeuPunt( 5, 6 ); // Constructor parametritzat
2.2.4.Destrucció d'objectes
class ClasseFinalitzada{
ClasseFinalitzada() { // Constructor
// Reserva del recurs no Java o recurs compartit
}
protected void finalize() {
// Alliberament del recurs no Java o recurs compartit
}
}2.2.5.Anàlisi i disseny orientat a objectes
3.POO en els diversos llenguatges de programació
3.1.Smalltalk
-
Orientació a objectes pura.
-
Tipus dinàmics.
-
Herència simple.
-
Compilació en temps d'execució o interpretat.
-
Un llenguatge.
-
Un model d'objecte, que defineix com actuen els objectes i implementa l'herència, el comportament de classes i instàncies, l'associació dinàmica, el maneig de missatges i les col·leccions.
-
Un conjunt de classes reutilitzables, que disposa d'una bona quantitat de classes que es poden fer servir en qualsevol programa. Aquestes classes proveeixen les funcions bàsiques en el llenguatge, a més del suport per a la portabilitat a diferents plataformes, inclosa la portabilitat de les interfícies gràfiques d'usuari.
-
Un conjunt d'eines de desenvolupament, que habiliten els programadors per mirar i modificar les classes que ja hi ha, i també per rebatejar, agregar i esborrar classes. També proveeixen de detecció d'errors, inclosa l'habilitat d'agregar parades en l'execució, veure els valors de les variables, modificar el valor de variables en execució i fer canvis en el codi en temps d'execució d'un programa.
-
Un entorn en temps d'execució, que permet als usuaris posar fi al cicle "compilar-enllaçar-executar" d'un programa. Això permet als usuaris executar un programa a Smalltalk mentre es canvia el codi font, de manera que els canvis que s'han fet en el codi font són reflectits a l'acte en l'aplicació que s'executa.
3.2.Eiffel
-
Una llista de característiques exportables.
-
Una llista de les classes antecessores: classes de què aquesta hereta.
-
Una llista de declaracions de característiques.
-
Es tracta d'un llenguatge orientat a objectes pur.
-
És un llenguatge de programació orientat a dissenyar grans aplicacions. Les propietats anteriors fan que vagi molt bé per a dissenyar aplicacions en grups de treball.
-
El pas intermedi a codi C es pot considerar un avantatge i no un inconvenient, ja que les seccions que són difícils de tractar amb Eiffel es poden elaborar a partir de codi C. La compatibilitat amb C assegura també la portabilitat cap a altres sistemes operatius.
-
El maneig de la memòria, un punt delicat en tots els llenguatges orientats a objectes, no és transparent com en el cas de Smalltalk.
-
Les biblioteques de classes són reduïdes.
-
El rendiment és més gran que el de Smalltalk, però, davant de la necessitat d'incloure un mòdul Run-time dins de l'executable, la mida creix i el rendiment baixa.
3.3.C++
-
Constructor predeterminat. És el constructor que no rep cap paràmetre en la funció. Si no es defineix cap constructor, el sistema en proporciona un de predeterminat.
-
Constructor de còpia. És un constructor que rep un objecte de la mateixa classe i fa una còpia dels atributs que té. Igual que el predeterminat, si no es defineix, el sistema en proporciona un.
-
Constructor de conversió. Aquest constructor rep com a únic paràmetre un objecte o una variable d'un altre tipus diferent que el seu. És a dir, converteix un objecte d'un tipus determinat en un altre objecte del tipus que genera.
-
Públics: es poden cridar des de qualsevol part del programa.
-
Privats: quan no es permet que l'usuari destrucció de l'objecte per part de l'usuari.
-
Herència pública: amb aquest tipus d'herència es respecten els comportaments originals de les visibilitats de la classe pare en la classe filla.
-
Herència privada: amb aquest tipus d'herència tot component de la classe pare és privat en la classe filla.
-
Herència protegida: amb aquest tipus d'herència tot component públic i protegit de la classe base és protegit en la classe derivada, i els components privats continuen essent privats.
Bruce Eckel és autor de llibres i articles sobre programació. Les seves obres més conegudes són Thinking in Java i Thinking in C++, adreçades a programadors amb poca experiència en la programació orientada a objectes.
Hi ha un web oficial en què es porta a cap la traducció al castellà del llibre de Bruce Eckel Thinking in C++.
3.4.ActionScript 3.0
-
Disposa d'una màquina virtual que és l'encarregada d'interpretar el codi, independentment de la plataforma en què s'executa aquest codi.
-
Té una sintaxi del llenguatge que s'ajusta a l'estàndard ECMAScript (ECMA-262).
-
Disposa d'una interfície de programació que permet un control de baix nivell dels objectes que componen les pel·lícules Flash.
-
Té una API XML basada en l'especificació d'ECMAScript per a XML (E4X) (ECMA-357, edició 2). E4X és una extensió del llenguatge ECMAScript que afegeix l'XML com un tipus de dades natiu del llenguatge.
-
Disposa d'un model d'esdeveniments basat en l'especificació d'esdeveniments DOM (model d'objectes de document) de nivell 3.
3.5.Ada
-
Té una sintaxi inspirada en Pascal que es llegeix fàcilment.
-
És un llenguatge case insensitive, és a dir, els identificadors i les paraules clau són equivalents amb independència de l'ús de majúscules i minúscules.
-
És un llenguatge amb tipificació forta: assigna a cada objecte un conjunt de valors clarament definit, cosa que impedeix la confusió entre conceptes lògicament diferents. Això fa que el compilador detecti més errors que en altres llenguatges.
-
Està preparat per a construir grans programes. Per a crear programes sostenibles i transportables, de qualsevol mida, fan falta mecanismes d'encapsulació per a compilar separadament i per a gestionar biblioteques.
-
Disposa de mecanismes que permeten manejar excepcions. D'aquesta manera, els programes es construeixen per capes i es limiten les conseqüències dels errors en qualsevol de les parts.
-
Se separen, amb l'abstracció de dades, els detalls de la representació de les dades i les especificacions de les operacions lògiques sobre aquestes dades per a obtenir més portabilitat i més bon manteniment.
-
Disposa de la capacitat de processament paral·lel i, així, evita que s'hagin d'afegir aquests mecanismes per mitjà de crides al sistema operatiu, de manera que aconsegueix més fiabilitat i portabilitat.
-
Disposa de l'opció de crear unitats genèriques; aquestes unitats són necessàries, ja que una part d'un programa pot ser independent del tipus de valors que s'han de manipular. Per a això, cal que s'utilitzi aquest mecanisme que permet crear parts d'un programa semblants a partir d'una plantilla.
3.6.Perl
3.7.PHP
-
Es tracta d'un llenguatge multiplataforma.
-
Està completament orientat al Web.
-
Té capacitat de connexió amb la majoria dels motors de base de dades que s'utilitzen en l'actualitat; en aquest sentit, en destaca la connectivitat amb MySQL i PostgreSQL.
-
Té capacitat d'expandir el seu potencial utilitzant la quantitat enorme de mòduls de què disposa.
-
És programari lliure, de manera que es presenta com una alternativa fàcil d'accedir-hi.
-
Implementa el paradigma de la Programació Orientada a Objectes.
-
Disposa d'una biblioteca nativa de funcions summament àmplia i inclosa.
-
No requereix definició de tipus de variables, encara que les variables que té es poden avaluar també pel tipus que manegen en temps d'execució.
-
Implementa la capacitat de manejar excepcions.
-
L'ofuscació de codi és l'única manera d'ocultar les fonts.
3.8.C#
3.9.Java
-
Permet un rendiment més bo, ja que una bona part del procés de traducció del codi font a les instruccions d'una CPU específica ja està fet.
-
Permet mantenir en secret el codi font original, cosa que pot ser important en cert tipus de programes en què el que es vol és que siguin portables i alhora difícils de manipular, tafanejar, copiar, etc. També se'n pot extrapolar una altra idea important: a qualsevol lloc (navegadors) es pot executar codi Java (miniaplicacions) sense haver de pensar d'on ve, ja que no hi ha gaires perills de seguretat (com ara virus o programes que atemptin contra la privacitat).