Programació Orientada a Objectes (OOP)

Programació Orientada a Objectes(OOP)

(JAVA, J.D.K. 1.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_Un vs Té_un

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”

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

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.

OOP vs Progr. Estructurada

• En la programació estructurada:

• La programació orientada a objectes:

dadesfuncions

A

B

classe A classe B

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

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

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

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.

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()

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.

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;

}

}

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)

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.

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 {………}

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());

}

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

...

...

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

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ó

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.

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

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.

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.

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


• 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


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

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


• 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


• 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/

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

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?!!

JAVA, Applets

JAVA, Applets

ApSimp.java

appletviewer 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

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.

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.

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.

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.

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

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

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.

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

}

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



OOP a JAVA• Per derivar una classe hem de fer:

class PuntColor extends Punt {

String c;

boolean iswhite() {return c.equals(“white”); }


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

OOP a JAVAclass PuntColor extends Punt{

…

PuntColor(int xini, int yini, String cini)

{

super(xini, yini);

c = cini;

}


{

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.

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.

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.

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();


{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ó)

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



}

class Punt extends P2D{

int x, y;

Punt(int xini, int yini) {…}

float norm() { ... }

Punt erase() { ... }

Punt move(int dx, int dy) { ... }

}

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.

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




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


{System.out.println(“Adéu mon cruel-Punt!”);}

}

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

Documents

Programació Orientada a Objectes (OOP)