Programació Orientada a Objectes (OOP)
description
Transcript of Programació Orientada a Objectes (OOP)
![Page 1: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/1.jpg)
Programació Orientada a Objectes(OOP)
(JAVA, J.D.K. 1.2.2)
![Page 2: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/2.jpg)
Aspectes a tractar de la OOP
• Què és la Programació Orientada a Objectes?
• Objectes i Classes
– Atributs i mètodes
• Subtipatge i Herència
• Polimorfisme i “Dinamic Binding”
• Relacions entre classes a l’hora de dissenyar:
– És_Un vs Té_un
![Page 3: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/3.jpg)
Aspectes de Java
• Què és i què ofereix Java
• L’entorn del “Java Developement Kit”, JDK
• Aplicacions “Stand Alone” i “Applets”
• De C++ a Java
• De OOP a Java
• Eines per a fer “Applets”
![Page 4: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/4.jpg)
Perquè Programació Orientada a Objectes?
• El Software actual pot requerir diversos milers/milions de línies de codi
• Hom és capaç de controlar uns 7 conceptes
• Necessitem “abstracció” per tal d’enfrontar-nos a problemes de grans dimensions
• Enlloc de pensar en com està fet una determinada cosa, ens interessa centrar-nos en què és aquella cosa i què puc fer amb ella, p. ex. un cotxe…
• Per entendre un sistema complexe, passarem de certs detalls i ens fixarem en d’altres.
• Abstracció procedural: corresponent a la programació estructurada/anàlisi descendent
• Abstracció de dades: ens concentrem en què puc fer amb certes dades=>Objectes
![Page 5: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/5.jpg)
Què és la Programació Orientada a Objectes?
• Consisteix en fer programes que funcionen gràcies a la interacció entre els objectes que hom ha definit.
• Es pretén un major grau d’abstracció a l’hora de dissenyar i implementar aplicacions, per tal d’aproximar-nos a la manera “natural” de resoldre problemes.
• Podem dir que els programes estan construïts “al voltant” dels objectes.
![Page 6: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/6.jpg)
OOP vs Progr. Estructurada
• En la programació estructurada:
• La programació orientada a objectes:
dadesfuncions
A
B
classe A classe B
![Page 7: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/7.jpg)
Objecte
• Un Objecte és una unitat de programació que associa dades amb les operacions que poden utilitzar/afectar aquestes dades.
• Les operacions les anomenarem mètodes i les dades atributs o variables d’instància.
• Amb els objectes es pretén també, “amagar” la implementació concreta de les dades i les operacions: encapsulament.
• Els objectes responen a missatges:destinatari.missatge
– el destinatari és un objecte (o expr. obj)– quan rep el missatge en temps d’exec.
es selecciona el mètode corresponent
![Page 8: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/8.jpg)
Objecte
• Els objectes com a entitats poden
– canviar d’estat, comportar-se de diferents maneres i ser manipulats per diferents estímuls
• Un Objecte existeix (espai), te atributs i diferents funcionalitats
• Per exemple, un fitxer: (ooptranspas.ppt)
– identitat– estat (conj. característiques)
• nom, longitud, contingut, propietari, mode…
– comportament (conj. d’operacions)• obrir, tancar, llegir, escriure,
canviar_mode, canviar_propietari,...
![Page 9: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/9.jpg)
Classes
• Per parlar d’un altre objecte fitxer com ex1.java, n’hauríem de donar també les característiques i funcionalitats…
• La Classe és l’abstracció que ens permet caracteritzar els objectes de la mateixa naturalesa.
nomf: f1.txtlong: 450mode:...obrir(){…}llegir(){…}…
nomf: f2.txtlong: 1243mode:755...obrir(){…}llegir(){…}…
nomf:long:mode:...obrir(){…}llegir(){…}…
nomf: fn.txtlong: 49mode: 777...obrir(){…}llegir(){…}…
obj1
obj2
objn
classe fitxer
![Page 10: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/10.jpg)
Classes
• Les classes fixen els prototipus dels seus objectes:– declara variables d’instància– defineix els mètodes
• La definició de classes és la tasca principal en la OOP.
![Page 11: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/11.jpg)
Classe (exemple)
• Definició Java de la classe de punts sobre el pla:
• Els objectes “concrets” els anomenem instàncies de la classe:
class Punt {
int x, y;
float norm() { return x*x+y*y; }
Punt erase() {
x = y = 0;
return this;
}
Punt move(int dx, int dy){
x += dx; y += dy;
return this;
}
}
(new Punt()).erase().move(3,5).norm()
![Page 12: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/12.jpg)
Jerarquia de classes
• Tenim dues jerarquies de classes:– Herència: seria un mecanisme per a
reutilitzar codi d’una (super)classe especialitzant-la amb una nova (sub)classe.
– Subtipatge: és una mecanisme per relacionar diferents tipus (classes) de manera que es permet la utilització d’un objecte d’una classe (subtipus) quan se n’enspera un d’una altre (supertipus).
• En Java, l’herència (extends) implica també la relació de subtipatge mentre que hi ha llenguatges que a part de subtipar s’ha de rescriure els mètodes de la superclasse si es volen poder fer servir.
![Page 13: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/13.jpg)
Herència (exemple)• Creem una subclasse mitjançant una classe ja
existent, aprofitant-ne els atributs (podem afegir
els que volguem) i els mètodes (canviant i/o afegint
els que ens interessin):
• A la subclasse podem sobreescriure: redefinir els mètodes heretats de la superclasse amb mateixa signatura i mateix tipus de retorn.
class PuntColor extends Punt{
String c;
boolean iswhite() {
return c.equals(“white”);
}
Punt move(int dx, int dy){
x += dx; y += dy;
c= “white”;
return this;
}
}
![Page 14: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/14.jpg)
Sobreescriptura• Els mètodes sobreescrits, són mètodes
heredats. Podem sobreescriure els definits a qualsevol superclasse seguint la jerarquia d’herència.– La signatura (nombre, ordre i tipus dels
paàmetres) del mètode i el tipus de retorn han de ser idèntics (sinó seria
sobrecàrrega)– No podem aplicar la relació de
subtipatge en els tipus dels paràmetres al definir els mètodes.
• D’altra banda, la sobrecàrrega seria tenir dos mètodes que es diuen igual però amb diferent signatura (sense tenir en compte el subtipatge)
![Page 15: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/15.jpg)
Subtipatge vs Herència• Tenim només heretada la classe PuntColor de Punt,
i tenim una funció:boolean isOrigin(Punt p)
{
return (p.norm()==0.0);
}
• un tros de codi com:
…
PuntColor pc = new PuntColor();
eslorigen = isOrigin(pc);
…
• provocaria un error en temps de compilació en el “checkejador” de tipus perque PuntColor no és subtipus de Punt. Notem però que en temps d’execució, es podria dur a terme correctament la crida perquè PuntColor també te implementat el mètode norm() degut a l’herència.
• En el que segueix, d’acord amb JAVA, al parlar d’herència parlarem d’herència + subtipus. Direm que B deriva de A si B hereda de A.
![Page 16: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/16.jpg)
Interface/Classes Abstractes• Si definíssim la classe PuntPolar, no la
volem derivar de Punt tot i que tenen molt en comú:
• Podem crear però una classe abstracta o una interface de manera que tinguin el mateix supertipus:
class PuntPolar{
float rho, theta;
float norm(){...}
PuntPolar erase(){…}
PuntPolar move(int dx, int dy){…}
}
interface Punt2D{
float norm();
Punt2D erase();
Punt2D move(int dx, int dy);
}
class Punt implements Punt2D {……...}
class PuntPolar implements Punt2D {………}
![Page 17: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/17.jpg)
Polimorfisme• La relació de subtipatge ens permet
assignar a una variable d’un cert supertipus, instàncies d’un subtipus. D’això se’n diu polimorfisme.
• Quan cridem mètodes d’una instància sempre es crida al mètode més específic per exemple:
Punt2D punts[] = new Punts2D[3];
punts[0]= new Punt();
punts[1]= new PuntPolar();
punts[2]=new PuntColor();
for(i=0; 1<3; i++){
System.out.println(punts[i].norm());
}
![Page 18: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/18.jpg)
Dynamic bindig
• En temps d’execució es decideix quin és el mètode que cal executar:
• S’ha de trobar l’adreça del mètode a executar; es busca per la seva signatura– primer es busca a la classe del que l’objecte
n’és instància i si no hi és
– es busca successivament a les classes seguint la jerarquia d’herència
És un
Var. d’instància
Var. d’instància
….
superclasse
missatge1: adreça
missatge2: adreça
...
superclasse
missatge1: adreça
missatge2: adreça
...
...
![Page 19: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/19.jpg)
Problemes• Pèrdua d’informació:
• No funciona el dinàmic binding amb sobrecàrrega:
(new PuntColor()).erase().isWhite()
Punt
class Punt{
…
boolean equals(Punt p){
return x=p.x && y=p.y; }
}
class PuntColor{
…
boolean equals(PuntColor p){
return x=p.x && y=p.y && c.equals(p.c); }
}
Punt p = new PuntColor(“white”);
p.equals(new PuntColor(“red”));fa l’equals del pare
![Page 20: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/20.jpg)
Relacions al dissenyar
• Quan dissenyem el nostre conjunt de classes ens interessa analitzar les relacions entre les classes:– és_un ==> Herència– té_un ==> Inclusió
![Page 21: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/21.jpg)
JAVA, història
• JAVA es remunta al 1991, a Sun Microsystems. Llenguatge senzill per a “electrodomèstics”.
• El compilador genera codi per a una màquina virtual: J.V.M. , independent de la CPU.
• Passa a ser un llenguatge de programació a finals del 1995.
• S’inclogué un intèrpret de JAVA al Netscape Navigator 2.0.
• Disposa d’un gran nombre de classes pel desenvolupament d’aplicacions.
![Page 22: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/22.jpg)
JAVA, “Write Once Run Anywhere”
Font JAVA
Compilador JAVA
BYTECODEJAVA
XARXA
Wintel
PowerPC, MacOS
SPARC, Solaris
x86, Linux
prog.java
prog.class
JVM pròpia
JVM pròpia
JVM pròpia
JVM pròpia
![Page 23: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/23.jpg)
JAVA, qualitats• Simple: (+-)60 paraules reservades. Sintaxi similar al
C/C++. Sense redundància.
• Orientat a Objectes: no és un afegitó. Està totalment dissenyat pensant en OOP.
• Preparat per la Web: disposa de classes específiques per això. Accedir a una adreça web obrir un fitxer.
• Interpretat: es compila a Bytecode (codi mòbil, baix nivell) i s’interpreta en la JVM.
• Robust: detecció d’errades ja en compilació: fortament tipat. Et protegeix dels teus errors.
• Segur: en temps d’execució, el “java runtime system” valida el Bytecode, garantint que no viola cap restricció del llenguatge. Et protegeix de les males intencions dels altres.
![Page 24: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/24.jpg)
JAVA, qualitats
• Independent de l’arquitectura: gràcies a la “Java Virtual Machine”, JVM.
• Portable
• D’alt rendiment: tot i ser interpretat, podríem dir que és més ràpid que molts d’altres llenguatges d’alt nivell. D’altra banda es treballa en traducció a codi natiu en temps d’execució: “just in time compiler”.
• Preparat per multi-thread: te classes pel tractament multi-thread i “programació concurrent”. (Semàfors, Mutex, ...)
• Dinàmic: fàcilment adaptable als canvis.
![Page 25: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/25.jpg)
JAVA, característiques del llenguatge
• No té preprocessador, – l'ús de les directives #ifdef i #define
perd sentit– No té variables globals, tot ha d’estar
dins d’una classe, les constants han de ser variables d’instància d’una classe amb public final
– no hi ha la diferència entre declaració i definició: el fitxer que conté la classe, conté la declaració d’interface i la implementació.
– l’#include passa a ser #import que no inclou cap fitxer sinó que indica on és el “package” que te les classes que ens interessen
![Page 26: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/26.jpg)
JAVA, característiques del llenguatge
• Els packages agrupen classes:– JAVA 1.2 te 59 packages– per utilitzar-ne, p.ex: import java.net.* – els noms separats per punts, segueixen
estructura de directoris (en JDK n’hi ha de guardats en fitxers .ZIP)
– per crear-ne podem posar a la primera línia dels fitxers que tenen les classes:
• package nompack;
– els noms dels package en minúscules vs majúscules de classes
– totes les classes d’un package al mateix directori
![Page 27: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/27.jpg)
JAVA, característiques del llenguatge
• No té punters, Java controla la gestió de la memòria pels objectes i no permet fer “castings”, conversions a enters, aritmètica de punters...– els punters són una important font d’errors– també és una possible manera de “burlar”
els sistemes de seguretat de JAVA.– els objectes doncs, sempre es passen com
a referències.– disposa de Garbage Collector, un procés
de baixa prioritat que allibera la memòria que ocupen objectes que ja no s’usen.
![Page 28: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/28.jpg)
J.D.K. 1.2.2Java Development Kit
• Conjunt de programes per a desenvolupar aplicacions JAVA
• javac, el compilador– ens compila el fitxer, creant un fitxer
en Bytecode per a cada classe:
• java, l’intèrpret de bytecode– ens executa el mètode main de la
classe que li passem com a argument:
javac Fitxerfont.javaClasse1.class
Classen.class...
java Nom_de_classe
![Page 29: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/29.jpg)
J.D.K. 1.2.2Java Development Kit
• jdb, el “debugger”– ens permet interpretar una classe en
mode debugger
• javadoc, el generador de documentació per a les classes– ens genera documentació HTML per a
fitxers .java. Utilitza els comentaris de documentació: /** …. */
• appletviewer, el “visualitzador”:– obre finestres pels applets dels fitxers
HTML que li passem com arguments:
jdb Nom_de_classe
appletviewer app1.html … appn.html
javadoc fitxers.java
![Page 30: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/30.jpg)
J.D.K. 1.2.2Java Development Kit
• També disposa d’altres aplicacions com: javah (per a la interacció amb C) i javap (desensamblador).
• Disposa d’una variable d’entorn: CLASSPATH, que indica els directoris on trobar les classes i els packages.
• Està disponible per a moltes plataformes a:– http://java.sun.com/
• Disposeu de Help a la web de bas:– http://eps.udg.es/docs/jdk1.2.2/docs/
![Page 31: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/31.jpg)
JAVA, aplicacions “stand alone” vs Applets
• JAVA ens permet tant fer aplicacions per a executar “soles”:– un programa consta d’una o més
definicions de classes en fitxers .java– una de les classes ha de tenir:
public static void main(String arg[])
• com aplicacions per a executar en una pàgina Web: Applets.– s’executaran desde clients Web
![Page 32: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/32.jpg)
JAVA, aplicacions “stand alone”
• La classe “Hola”:
import java.io.*;public class Hola { public static void main (String[] args)
throws IOException{
System.out.println(”Hola que tal?!!"); int k=System.in.read();
} }
Hola.java
javac Hola.java => Hola.class
java Hola
Hola que tal?!!
![Page 33: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/33.jpg)
JAVA, Applets
![Page 34: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/34.jpg)
JAVA, Applets
ApSimp.java
appletviewer AppletSimple.html
<!-- Fitxer AppletSimple.html --> <HTML> <HEAD><TITLE>Applet Simple </TITLE></HEAD> <BODY> <APPLET CODE="ApSimp.class" WIDTH=200 HEIGHT=50> </APPLET> </BODY> </HTML>
import java.applet.*;import java.awt.*;
public class ApSimp extends Applet { public void paint (Graphics g) { g.drawString(”Hola que tal?!!", 25, 25); } }
AppletSimple.html
javac ApSimp.java => ApSimp.class
![Page 35: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/35.jpg)
JAVA, Applets
• Podríem dir que els applets estan “orientats a events”
• Deriven de la classe Applet i poden redefinir certs mètodes.
• La seqüència d’execució és:– init(), es crida quan comença
– start(), quan comença o recomença.
– paint()– captura d’events i execució dels
mètodes pertinents
– repaint(), per repintar o actualitzar el display.
– stop() i destroy() quan s’acaba.
![Page 36: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/36.jpg)
El llenguatge JAVA
• Els comentaris es fan com amb C, excepte pel javadoc: /**…*/
• Tipus bàsics C++. També hi ha el tipus boolean. Els char permeten caràcters Unicode: 16 bits.
• Disposa de la classe String: “blabla…”:“l\’arrel quadrada de 2 és: “+ Math.sqrt(2)
així, el + crea un objecte String nou.“l\’arrel quadrada de 2 és: 1.4142135623730952”
• Les variables locals dels mètodes s’han d’inicialitzar abans de fer servir.
• Les variables d’instància de tipus bàsic s’inicialitzen per defecte.
![Page 37: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/37.jpg)
El llenguatge JAVA• Les variables de classe o variables
estàtiques són variables d’instància que no pertanyen a les instàncies de la classe sinó que pertany a la classe.
static int numinstancies=0;
o bé:
static int numistancies;
static {numinstancies=0;}
• l’accés als components de les classes venen marcats pels modificadors:– public: accessibles per tothom
– private: accessibles només per la classe
– protected: accessibles per subclasses
– no res: accessibles només al package.
• final no permet cap modificació ni en les subclasses.
![Page 38: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/38.jpg)
El llenguatge JAVA
• Existeix la noció d’àmbit. Els blocs de codi també defineixen àmbits.A b=new A();
{
A c=new A();
…
}
b=c; /* error!!! */
primer es busca en el mateix bloc, després l’àmbit local, el de la classe, superclasses, i si no es troba, es busca a les classes i packages importats.
![Page 39: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/39.jpg)
El llenguatge JAVA
• Els operadors són com en C++.
• L’operador de pertinença a classe:
(objecte) instanceof (tipus de referència)
• Permet fer certs càstings: float f = (float) enter;
– no es poden fer càstings d’un objecte a un tipus bàsic com Object
– es pot fer càsting de subclasse a superclasse
– només es pot fer càsting de superclasse a subclasse si es fa des d’una instància de la subclasse
• Les sentències de control són com en C++.
![Page 40: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/40.jpg)
El llenguatge JAVA
• La creació de classes és com ja hem vist mitjançant la paraula class precedida dels modificadors de classe:– final: la classe no pot tenir subclasses
– abstract: conté mètodes virtuals
– public: la classe es pot usar fora el package
– private: només es put usar dins el fitxer on està definida
– (no res): és accessible des de totes les del mateix package
![Page 41: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/41.jpg)
El llenguatge JAVAclass Punt {
int x, y;
Punt(int xini, int yini) {x = xini; y = yini;} //constructor
float norm() { return x*x + y*y; }
Punt erase() { x = y = 0; return this; }
Punt move(int dx, int dy)
{ x += dx; y += dy;return this; }
}
…
Punt p1; // declaració
p1 = new Punt(); // definició per construct. Defecte
p1.x = p1.y = 10;
Punt p2 = new Punt(5,5); // declaració + definició
{ Punt p3 = (new Punt()).erase().move(7,7); }
p2 = p3; // error, p3 no definit!!!
El new instància la classe, agafant la memòria necessària.
Els constructors no tenen tipus de retorn.
Al acabar l’àmbit es destrueixen els “seus” objectes.
![Page 42: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/42.jpg)
El llenguatge JAVA
• Les variables instàncies de classes, són referències a objectes:
Punt p1, p2;
p1 = new Punt(10,10);
p2 = p1; // p1 i p2 passen a ser el mateix // objecte, no només a
valer el mateix
p1.x = p1.y = 5;
System.out.println(p2.x, p2.y); // resultat= 5 5
• Es pot redefinir el destructor:
class Punt {
…
protected void finalize()
{System.out.println(“Adéu mon cruel!!!”);}
}
![Page 43: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/43.jpg)
El llenguatge JAVA
• Els arrays en JAVA són objectes que tenen un tipus (de contingut) i una dimensió:
Punt[] triangle; // declaració array
triangle = new Punt[3]; // definició array +
// declaració punts
triangle[0] = new Punt(); // definició punts...
triangle[1] = new Punt();
triangle[2] = new Punt();
• Inicialitzacions:String[] animals = {“gat”, “gos”, …};
• Varies dimensions:int[][] trimat = new int[3];
trimat[0] = new int[1];
trimat[1] = new int[2];
trimat[2] = new int[3];
![Page 44: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/44.jpg)
OOP a JAVA• Per derivar una classe hem de fer:
class PuntColor extends Punt {
String c;
boolean iswhite() {return c.equals(“white”); }
Punt move(int dx, int dy)
{ x += dx; y += dy; c= “white”; return this;}
}
Punt ha de ser accessible i derivable. PuntColor contindrà els membres heretables de Punt. Pot afegir-ne i redefinir-ne.
• En les definicions dels mètodes, podem usar this per referir-nos al mateix objecte i super per referir-nos a membres de la superclasse.
![Page 45: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/45.jpg)
OOP a JAVAclass PuntColor extends Punt{
…
PuntColor(int xini, int yini, String cini)
{
super(xini, yini);
c = cini;
}
Punt move(int dx, int dy)
{
super.move(dx,dy);
c= “white”;
return this;
}
}
super ens permet seleccionar mètodes de la superclasse encara que aquests hagin esta redefinits en la classe.
![Page 46: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/46.jpg)
OOP a JAVA
• JAVA només ens permet redefinir (sobreescriure) mètodes conservant la signatura i el tipus de retorn. Només podem redefinir mètodes no estàtics.
• L’accessibilitat dels mètodes redefinits no pot ser més restrictiva.
• Si canviem el tipus de retorn falla al compilar.
• Si canviem la signatura (tipus/nombre/ordre dels paràmetres) es considera sobrecàrrega.
• El polimorfisme funciona sobre els mètodes redefinits.
![Page 47: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/47.jpg)
OOP a JAVAPunt[] triangle;
triangle = new Punt[3];
triangle[0] = new Punt(1,1);
triangle[1] = new PuntColor(2,2);
triangle[2] = new Punt(1,3);
for (int i=1; i<3; i++)
triangle[i].move(1,1);
• En temps d’execució es decideix quin move s’ha de cridar mitjançant dynamic binding. Això és polimorfisme.
![Page 48: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/48.jpg)
OOP a JAVA
• Les classes abstractes són classes que deixen parts sense definir, essent les subclasses les que les hauran de definir totalment.
abstract class P2D{
abstract float norm();
abstract P2D erase();
abstract P2D move();
protected void finalize()
{System.out.println(“Adéu mon cruel!!!”);}
}
• No es poden crear objectes de classes abstractes.
• Es poden redefinir mètodes com a abstractes. (deixar-los a certa branca de la jerarquia sense definició)
![Page 49: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/49.jpg)
OOP a JAVA
• Les derivacions deixen de ser abstractes si no tenen cap mètode abstracte i defineixen tots els abstractes de la superclasse:
class PuntPolar extends P2D {
float rho, theta;
float norm(){...}
PuntPolar erase(){…}
PuntPolar move(int dx, int dy){…}
}
class Punt extends P2D{
int x, y;
Punt(int xini, int yini) {…}
float norm() { ... }
Punt erase() { ... }
Punt move(int dx, int dy) { ... }
}
![Page 50: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/50.jpg)
OOP a JAVA
• Quan només es vol tenir una classe amb constants de classe (static final) i declaracions de mètodes (sense cap definició) es poden definir interfaces:
interface P2D{
float norm();
P2D erase();
P2D move();
}
• Les interfaces es poden “derivar” via implements per les classes i via extends per d’altres interfaces. Estableixen també relacions de subtipus.
![Page 51: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/51.jpg)
OOP a JAVA• Les classes (no abstractes) que implementin
interfaces, han d’implementar tots els mètodes.
class PuntPolar implements P2D {
float rho, theta;
float norm(){...}
PuntPolar erase(){…}
PuntPolar move(int dx, int dy){…}
protected void finalize()
{System.out.println(“Adéu mon cruel-PuntPolar!”);}
}
class Punt implements P2D{
int x, y;
Punt(int xini, int yini) {…}
float norm() { ... }
Punt erase() { ... }
Punt move(int dx, int dy) { ... }
protected void finalize()
{System.out.println(“Adéu mon cruel-Punt!”);}
}
![Page 52: Programació Orientada a Objectes (OOP)](https://reader035.fdocuments.net/reader035/viewer/2022062305/568147eb550346895db522ba/html5/thumbnails/52.jpg)
OOP a JAVA• Una classe pot implementar tants
interfaces com vulgui. Un interface pot derivar de tants interfaces com vulgui: herència múltiple. No provoca conflictes de noms (excepte excepcions i constants).
interface W { }
interface X extends W { }
class Y implements W { }
//interface Y extends W { }
class Z extends Y implements X { }
// class Z implements X, Y { }
W
X Y
Z