Programaci

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 lhora de dissenyar
• És_Un vs Té_un

3
Aspectes de Java

• Què és i què ofereix Java
• Lentorn 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 denfrontar-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 daltres.
• Abstracció procedural corresponent a la
  programació estructurada/anàlisi descendent
• Abstracció de dades ens concentrem en què puc
  fer amb certes dadesgtObjectes

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 dabstracció a lhora de
  dissenyar i implementar aplicacions, per tal
  daproximar-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

• En la programació estructurada
• La programació orientada a objectes

funcions
dades
A
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 dinstà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 dexec. es
  selecciona el mètode corresponent

8
Objecte

• Els objectes com a entitats poden
• canviar destat, 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. doperacions)
• obrir, tancar, llegir, escriure, canviar_mode,
  canviar_propietari,...

9
Classes

• Per parlar dun altre objecte fitxer com
  ex1.java, nhauríem de donar també les
  característiques i funcionalitats
• La Classe és labstracció 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
mode755
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 dinstància
• defineix els mètodes
• La definició de classes és la tasca principal en
  la OOP.

11
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
xxyy 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()
12
Jerarquia de classes

• Tenim dues jerarquies de classes
• Herència seria un mecanisme per a reutilitzar
  codi duna (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ó dun objecte duna classe
  (subtipus) quan se nenspera un duna altre
  (supertipus).
• En Java, lherència (extends) implica també la
  relació de subtipatge mentre que hi ha
  llenguatges que a part de subtipar sha 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 dherè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.
• Daltra 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
  dexecució, es podria dur a terme correctament la
  crida perquè PuntColor també te implementat el
  mètode norm() degut a lherència.
• En el que segueix, dacord amb JAVA, al parlar
  dherència parlarem dherència subtipus. Direm
  que B deriva de A si B hereda de A.

16
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
17
Polimorfisme

• La relació de subtipatge ens permet assignar a
  una variable dun cert supertipus, instàncies
  dun subtipus. Daixò sen diu polimorfisme.
• Quan cridem mètodes duna instància sempre es
  crida al mètode més específic per exemple

Punt2D punts new Punts2D3 punts0 new
Punt() punts1 new PuntPolar() punts2new
PuntColor() for(i0 1lt3 i) System.out.print
ln(puntsi.norm())
18
Dynamic bindig

• En temps dexecució es decideix quin és el mètode
  que cal executar
• Sha de trobar ladreça del mètode a executar es
  busca per la seva signatura
• primer es busca a la classe del que lobjecte
  nés instància i si no hi és
• es busca successivament a les classes seguint la
  jerarquia dherència

...
És un Var. dinstància Var. dinstància .
19
Problemes

• Pèrdua dinformació
• No funciona el dinàmic binding amb sobrecàrrega

(new PuntColor()).erase().isWhite()
Punt
class Punt boolean equals(Punt
p) return xp.x yp.y class
PuntColor boolean equals(PuntColor
p) return xp.x yp.y
c.equals(p.c) Punt p new
PuntColor(white) p.equals(new
PuntColor(red))
fa lequals del pare
20
Relacions al dissenyar

• Quan dissenyem el nostre conjunt de classes ens
  interessa analitzar les relacions entre les
  classes
• és_un gt Herència
• té_un gt 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.
• Sinclogué un intèrpret de JAVA al Netscape
  Navigator 2.0.
• Disposa dun gran nombre de classes pel
  desenvolupament daplicacions.

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 (codi mòbil,
  baix nivell) i sinterpreta en la JVM.
• Robust detecció derrades ja en compilació
  fortament tipat. Et protegeix dels teus errors.
• Segur en temps dexecució, 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 larquitectura gràcies a la Java
  Virtual Machine, JVM.
• Portable
• Dalt rendiment tot i ser interpretat, podríem
  dir que és més ràpid que molts daltres
  llenguatges dalt nivell. Daltra banda es
  treballa en traducció a codi natiu en temps
  dexecució 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 destar dins
  duna classe, les constants han de ser variables
  dinstància duna classe amb public final
• no hi ha la diferència entre declaració i
  definició el fitxer que conté la classe, conté
  la declaració dinterface i la implementació.
• linclude 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 nhi 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 dun 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 derrors
• 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 susen.

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, lintèrpret de bytecode
• ens executa el mètode main de la classe que li
  passem com a argument

Classe1.class
...
javac Fitxerfont.java
Classen.class
java Nom_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

jdb Nom_de_classe
javadoc fitxers.java
appletviewer app1.html appn.html
30
J.D.K. 1.2.2Java Development Kit

• També disposa daltres aplicacions com javah
  (per a la interacció amb C) i javap
  (desensamblador).
• Disposa duna variable dentorn 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 duna 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.
• sexecutaran desde clients Web

32
JAVA, aplicacions stand alone

• La classe Hola

Hola.java
import java.io. public class Hola
public static void main (String args) throws
IOException System.out.println(Hol
a que tal?!!") int kSystem.in.read()

javac Hola.java gt Hola.class
java Hola
Hola que tal?!!
33
JAVA, Applets
34
JAVA, Applets
AppletSimple.html
lt!-- Fitxer AppletSimple.html --gt ltHTMLgt
ltHEADgtltTITLEgtApplet Simple lt/TITLEgtlt/HEADgt
ltBODYgt ltAPPLET CODE"ApSimp.class"
WIDTH200 HEIGHT50gt lt/APPLETgt
lt/BODYgt lt/HTMLgt
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)
javac ApSimp.java gt ApSimp.class
appletviewer AppletSimple.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 dexecució és
• init(), es crida quan comença
• start(), quan comença o recomença.
• paint()
• captura devents i execució dels mètodes
  pertinents
• repaint(), per repintar o actualitzar el display.
• stop() i destroy() quan sacaba.

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 shan
  dinicialitzar abans de fer servir.
• Les variables dinstància de tipus bàsic
  sinicialitzen per defecte.

37
El llenguatge JAVA

• Les variables de classe o variables estàtiques
  són variables dinstància que no pertanyen a les
  instàncies de la classe sinó que pertany a la
  classe.
• static int numinstancies0
• o bé
• static int numistancies
• static numinstancies0
• laccé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 bnew A()
• A cnew A()
• bc / 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.
• Loperador 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 dun 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 duna 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 xx yy
• Punt erase() x y 0 return this
• Punt move(int dx, int dy)
• x dx y dyreturn 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 Punt3 // definició array
• // declaració punts
• triangle0 new Punt() // definició punts...
• triangle1 new Punt()
• triangle2 new Punt()
• Inicialitzacions
• String animals gat, gos,
• Varies dimensions
• int trimat new int3
• trimat0 new int1
• trimat1 new int2
• trimat2 new int3

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.
• Laccessibilitat 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 Punt3
• triangle0 new Punt(1,1)
• triangle1 new PuntColor(2,2)
• triangle2 new Punt(1,3)
• for (int i1 ilt3 i)
• trianglei.move(1,1)
• En temps dexecució es decideix quin move sha 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 daltres
  interfaces. Estableixen també relacions de
  subtipus.

51
OOP a JAVA

• Les classes (no abstractes) que implementin
  interfaces, han dimplementar 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!)

52
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
Y
X
Z