Programació Orientada a Objectes (OOP)

1. Programació Orientada a Objectes(OOP) (JAVA, J.D.K. 1.2.2)

2. 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_UnvsTé_un

3. 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”

4. 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

5. 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.

6. OOP vs Progr. Estructurada funcions dades A • En la programació estructurada: • La programació orientada a objectes: B classe B classe A

7. 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

8. 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,...

9. nomf: long: mode: ... obrir(){…} llegir(){…} … 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. obj1 nomf: f1.txt obj2 long: 450 classe fitxer mode: nomf: f2.txt ... long: 1243 objn mode:755 obrir(){…} ... nomf: fn.txt llegir(){…} … long: 49 obrir(){…} mode: 777 llegir(){…} … ... obrir(){…} llegir(){…} …

10. 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.

11. Classe (exemple) 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; } } • Definició Java de la classe de punts sobre el pla: • Els objectes “concrets” els anomenem instàncies de la classe: (new Punt()).erase().move(3,5).norm()

12. 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.

13. 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; } }

14. 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)

15. 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.

16. Interface/Classes Abstractes class PuntPolar{ float rho, theta; float norm(){...} PuntPolar erase(){…} PuntPolar move(int dx, int dy){…} } • 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: interfacePunt2D{ float norm(); Punt2D erase(); Punt2D move(int dx, int dy); } class Punt implements Punt2D {……...} class PuntPolar implements Punt2D {………}

17. 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()); }

18. superclasse missatge1: adreça missatge2: adreça ... superclasse missatge1: adreça missatge2: adreça ... 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 ….

19. Problemes (new PuntColor()).erase().isWhite() Punt • Pèrdua d’informació: • No funciona el dinàmic binding amb sobrecàrrega: 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

20. 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ó

21. 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.

22. JAVA, “Write Once Run Anywhere” Wintel prog.java Font JAVA JVM pròpia X A R X A SPARC, Solaris Compilador JAVA JVM pròpia BYTECODE JAVA x86, Linux JVM pròpia prog.class PowerPC, MacOS JVM pròpia

23. 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 (codimò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.

24. 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.

25. 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

26. 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

27. 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.

28. 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: Classe1.class ... javacFitxerfont.java Classen.class javaNom_de_classe

29. 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: jdbNom_de_classe javadocfitxers.java appletviewerapp1.html… appn.html

30. 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/

31. 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

32. JAVA, aplicacions “stand alone” Hola.java • 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(); } } javacHola.java => Hola.class javaHola Hola que tal?!!

33. JAVA, Applets

34. JAVA, Applets AppletSimple.html <!-- Fitxer AppletSimple.html --> <HTML> <HEAD><TITLE>Applet Simple </TITLE></HEAD> <BODY> <APPLET CODE="ApSimp.class" WIDTH=200 HEIGHT=50> </APPLET> </BODY> </HTML> ApSimp.java import java.applet.*; import java.awt.*; public class ApSimp extends Applet { public void paint (Graphics g) { g.drawString(”Hola que tal?!!", 25, 25); } } javacApSimp.java => ApSimp.class appletviewerAppletSimple.html

35. 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.

36. 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.

37. 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.

38. 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.

39. 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++.

40. 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

41. El llenguatge JAVA class 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.

42. 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!!!”);} }

43. 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];

44. 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.

45. OOP a JAVA class 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.

46. 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.

47. OOP a JAVA Punt[] 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.

48. 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ó)

49. 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) { ... } }

50. 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.