PMOO

0.
gaia
0
gaia
Javaprogramaziolengoaia
Sarrera gisakoa
Sarreragisakoa
Aurkezpenaren eskema
Aurkezpenareneskema
Hi
Historiapixkabat.Java,Interneterakolengoaia.
i i k b J
I
k l
i
Javaingurunea:programaziolengoaia,JVMeta
J k
Javakopaketeak.
k
k
Lengoaiarenoinarriak,ezaugarriorokorrak,
sintaxikontubatzuk...
i t ik t b t k
Bukatzeko
Helbideinteresgarriak,bibliografia.
Historia
SunMicrosystems enpresakgaratua,90.
hamarkadan: WriteOnce,RunAnywhere
Write Once Run Anywhere
Hastapenean,etxetresnaelektrikoak
programatzeko egun ia edozertarako
programatzeko,eguniaedozertarako.
Aplikazio etawebgune asko ezin dira Javainstalatuta
eduki gabe martxan jarri.
jarri
Smartphoneak,superkonputagailuak,bideokontsolak,
Internet...
Internet
Historia
Amaraunahedatuahala,Javaindartuzdoa
webekoaplikazioetarako.1995:Netscape
nabigatzaileakJavasostengatzendu.Hortik
bi
il k J
d H ik
aurreraInterneterakolengoaiatzathartuohida.
Printzipioak
Pi ti i k
Itshouldbe"simple,objectorientedandfamiliar"
It h ld b " b t d
Itshouldbe"robustandsecure"
"
Itshouldbe"architectureneutralandportable"
It should execute with "high
Itshouldexecutewith
highperformance
performance"
Itshouldbe"interpreted,threaded,anddynamic"
Java ingurunea
Javaingurunea
Javainguruneak hiruoinarrizkoelementu
ditu:
di
Javaprogramaziolengoaia.
Javamakinabirtuala(JVM).
Javaklaseenmultzoa.
Java klaseen multzoa
Java programazio lengoaia

Java,programaziolengoaia
Javahelburuorokorrekolengoaiada.
Objektueiorientatua.
CetaC++lengoaienahaidea.
Konpilazioa
Adibide java
Adibide.java
Java kodea
javac
Konpiladorea
Adibide.class
byte-code
Java"makinabirtuala"
(JavaVirtualMachine)
Java"makinabirtuala"(JVM)
EdozeinmakinatanJavaprogramakeginlitezke,
etagerobesteedozeinetan(edo;)exekutatu.
Java JVMrako lengoaia

Java,JVMrakolengoaia
Makina
Makinahorretarakoprogrameibytecode
horretarako programei bytecode deitzen
deitzen
zaie.
Javarekinbateragaratutakolengoaia.
J
ki b t
t t k l
i
Gehienez256agindu.Gauregun220aginduzosatua.
B
Bestelengoaiabatzukerekonpiladaitezke
t l
i b t k
k
il d it k
JVMrako:jgnat(Ada>JVM).
Bi fase: konpilazioa eta interpretazioa

Bifase:konpilazioaetainterpretazioa
Java paketeak (klase bildumak)

Javapaketeak(klasebildumak)
Klasea:oinarrizkounitatesintaktikoa,Adakopaketeen
kidekoa; Javan, kode guztiguztia
kidekoa;Javan,kodeguzti
guztiaklasetanantolatzenda
klasetan antolatzen da
(ohikoadaiaiaestandarra klaseenizenaletralarriaz
hastea)
Paketea:elkarrekinzerikusiestuadutenklaseenmultzoa.
Paketearruntak:
java.lang
java
lang (haubetidagoikusgai,inportatubeharrikgabe)
(hau beti dago ikusgai inportatu beharrik gabe)
java.io
java.util
java.net
java.awt
java.applet
Lengoaiaren ezaugarri orokorrak

Lengoaiarenezaugarriorokorrak
Sinplea
Objektueiorientatua
j
Segurua
Motamekanismozorrotza(ezAdarenabezainzorrotza,halere).
Konpilaziodenborakoegiaztapena(checking).
Interpretazio/exekuziodenborakoegiaztapena(checking).
E k l
Erakusleespliziturikez.
li i ik
Salbuespenentratamendua.
Lengoaiak berak babesten du memoria atzipen ezlegalen
Lengoaiakberakbabestendumemoriaatzipen
ez legalen
aurrean.
Exekutatuaurretikegiaztatuegitenda.
Lengoaiaren ezaugarri orokorrak

Lengoaiarenezaugarriorokorrak
Eramangarria
Edozeinplataformataraeramatekoespezifikatua.
Exekuzioharianitzekoa(multithreaded)
E k i h i it k ( ltith d d)
Prozesuenegikaritzapenkonkurrenterakoaukeraematendu.
Interpretatua
Dinamikoa
Beharrasortuahalakargatzendituklaseakinterpretatzaileak.
Beharra sortu ahala kargatzen ditu klaseak interpretatzaileak
Lengoaia: oinarrizko datu motak

Lengoaia:oinarrizkodatumotak
Oinarrizkodatumotak:
Osoak:byte, short, int, long

Errealak:float, double
Karaktereak:char
Boolearrak:boolean
Arrayak(Ckoenantzera);bestalde,
Vector klaseaerebadago.
String klasea.
Lengoaia: elementuak
Lengoaia:elementuak
C etaC++ lengoaienitxura:
Iruzkinak:
Iruzkinak:
/* ... */ (blokekoak);
// (lerroabukatzendenartekoa)
Identifikadoreak:letrak,zenbakiaketaazpimarra(ezinzenbaki
d ifik d
k l
k
b ki k
i
( i
b ki
batezhasi)
Literalak:'a',"kaixo",345,0.0,true
,
,
,
,
...
Eragileak:= (asignazioa),== (berdin),!=,<,&&,|| ...
Banatzaileak:parentesiak,giltzak,koma,puntuetakoma...
Eragileak
Eragileak, lehentasunaren arabera ordenaturik
Eragileak
Lehentasuna
postfixuak
espr++ espr--
eragigai
g g bakarrekoak
++espr --espr +espr -espr ! (NOT logikoa)
biderkatzaileak
* / %
batutzaileak
+ -
erlazionalak
< > <= >= instanceof
berdintza
== !=
AND logikoa
&&
OR logikoa
||
asignazioa
= +=
+ -= *= /
/= &
&=
Lengoaia:elementuak
Fluxukontrola:
Sententziabakuna; karaktereazbukatzenda:
balioBat = 3; // esleipena
balioBat++; // gehikuntza-sententzia
System.out.println("Kaixo"); // metodo-deia
Auto autoBat = new Auto(); // objektu-eraikuntza
Sententziakonposatua(sekuentzia,blokea)
giltzaarteanbildutakosententziensegida:{}
Baldintzazkoak.
Begiztak.
Lengoaia:elementuak
Baldintzasententziak:
if
if else
switch
Iterazioa:
while (<espresioboolearra>)
(<espresio boolearra>)
<sententziabakunaedokonposatua>
do
<sententzia bakuna edo konposatua>
while (<espresioboolearra>)
for (<hasieratzesententziak>;
<espresio boolearra>;
<espresioboolearra>;
<aldatzeespresioak>)
Lengoaia: if (adibideak)
Lengoaia:if
if (autoBat
(autoBat.abiadura())
abiadura()) > 130
130.00)
00)
System.out.println("Isuna");
if (a.balioa() > b.balioa()) {
//...
//
} else {
//...
//
}
Lengoaia: switch (adibideak)

Lengoaia:switch
switch (eguna) {
case 1: System.out.println("astelehena"); break;
case 2: System.out.println("asteartea"); break;
case 3: System.out.println(
System out println("asteazkena");
asteazkena ); break;
case 4: System.out.println("osteguna"); break;
case 5: System.out.println("ostirala"); break;
case 6: System.out.println("larunbata"); break;
case 7: System.out.println("igandea"); break;
default:
System.out.println("egun-balio desegokia"); break;
}
Lengoaia: while (adibideak)

Lengoaia:while
while (
(autoBat.abiadura()
() <= 120.00)
)
autoBat.abiaduraHanditu(10.00);
while (true) {
// begizta infinitua
}
do {
//...
} while (a > 0);
Lengoaia: for (adibideak)

Lengoaia:for
for (int i=0; i<5; i++)
System.out.println("Kaixo");
for (int i=0; i<5; i++) {
System out print (i + ": ");
System.out.print
//...;
}
Klaseak:
modulartasunarenoinarriaJavan
Kamioi motaerrepresentatzekoklasea:
p
public class Kamioi {
// objektu motaren ezaugarriak
private
i t i
int
t gurpilKopurua;
ilK
private double pisua;
// etodoa (eragiketak)
//metodoak
(e ag eta )
//eraikitzailea
public Kamioi (int n, double p) {...};
public int zenbatGurpil() {...};
public
bli d
double
bl zenbatekoPisua()
b t k Pi
() {
{...};
}
}
Klaseak:
modulartasunarenoinarriaJavan
Kamioi klasearenerabilera:
Kamioi k1
k1, k2; //objektuen (instantzien) erazagupena
k1 = new Kamioi(8, 10000.00); //objektu-eraikuntza
System out println (k1
System.out.println
(k1.zenbatGurpil()
zenbatGurpil() + " gurpil ditu";
Oharrak:
Besterikezean,parametrorikgabekoeraikitzailea dagoklaseorotan:
eremuakhasieratu,erreferentziabatlortu(erakuslea).
Parametrodun eraikitzaileren bat baldin badago ordea parametrorik
Parametroduneraikitzailerenbatbaldinbadago,ordea,parametrorik
gabekoaezdaautomatikokisortzen,eta,beraz,esplizitukieginbeharkoda.
Erazagupenak:oinarrizkomotak,
erreferentziak,konstanteak
Oinarrizkomotetakoaldagaietakonstanteak:
int i, j;
i
int
k = 300
300; //
//hasieratzea
i
erazagupenean
boolean handiagoa = false;
final double MAX = 1000.00; //konstantea
Erreferentziaaldagaiak(klasebateninstantziak):
String s;
Kamioi
i i k1
k1, k2
k2;
Auto a = new Auto(); //instantzia-eraikuntza
Erreferentziaaldagaiek
Erreferentzia aldagaiekobjektuarenhelbideagordetzen
objektuaren helbidea gordetzen
dute,ezbalioa!
Bektoreak (array ak)

Bektoreak(arrayak)
int[]
i
[] b
bektorea100;
k
100 //
//erazagupen h
hutsa
bektorea100 = new int[100]; //hasieratzea
//hasieratzea, balioak emanez
int[] bektorea5 = {3, 4, 5, 6, 7};
for (int i=0; i<5; i++)
S t
System.out.println(bektorea5[i]);
t
i tl (b kt
5[i])
Vector klaseaerebadago,etanormaleanerosoagodahura
klasea ere badago eta normalean erosoago da hura
erabiltzea.
Programanagusia:
main metodoa
import j
i
java.io.*;
i *
public class Nagusia {
public static void main(String[] args) {
...
}
}
Adibidea: Klase honek

java.io paketeko
klaseak inportatzen
ditu (menpekotza)
main metodoaexekutatukoda,Nagusia
metodoa exekutatuko da Nagusia klaseaJVMk
klasea JVMk
interpretatzenduenean:
> java Nagusia.class
Metodoak:
nolaerazagutu,noladeitu
Funtzioak(emaitzaitzultzenduteetaespresioetatikeginohizaiedei):
i k(
i i l
d
i
ik i hi i d i)
//erazagupenak
public boolean handiago (Zatiki bestea) {...};
public Zatiki gehi (Zatiki bestea) {...};
//deiak (z1 eta z2 Zatiki dira)
if (z1.handiago(z2)) {...}
Zatiki batura = z1.gehi(z2);
Prozedurak(ezduteemaitzarikitzultzenetasententziagisaegitenzaiedei):
//erazagupenak
public void kamioiaHustu() {...};
public void inprimatu(String fitxategiIzena) {...};
//deiak (k1 Kamioi da eta z1 Zatiki da)
k1.kamioaHustu();
z1.inprimatu("emaitzak.txt");
Amarauneko helbide interesgarriak

Amaraunekohelbideinteresgarriak
http://java.sun.com
//
(ingelesez)
http://javaboutique.internet.com/ (ingelesez)
http://www.developer.com/java/ (ingelesez)
http://www.programacion.com/java/ (gaztelaniaz)
http://www.javahispano.com/ (gaztelaniaz)
http://www.monografias.com/trabajos/java/java.shtml
(
(gaztelaniaz)
l
)
Bibliografia
JJava2.IniciacinyReferencia
2 I i i i R f
i (2ed.).J.SnchezAllende,G.HuecasFernndezToribio,B.
(2 d ) J S h All d G H
F d T ibi B
FernndezManjn,P.MorenoDaz.Ed.McGrawHill,2005.
ProgramacinOrientadaaObjetosconJava. F.Durn,F.Gutirrez,E.Pimentel.Thomson,2007.
Program Development in Java B Liskov J Guttag AddisonWesley
ProgramDevelopmentinJava.B.Liskov,J.Guttag.Addison
Wesley,2001.
2001
DescubreJava1.2.M.Morgan(ed.).PrenticeHall.1998.
EllenguajedeprogramacinJava. Arnold,K.etal. AddisonWesley,2001.
Java 2. Manual de usuario y tutorial. A. Froufe. Ra
Ra-Ma,
Ma, 2000.
ProblemasresueltosdeprogramacinenlenguajeJava. PrezMenor,J.M.etal. Thomson,2003.
An introduction to Data Structures and Algorithms with Java. G.W. Rowe. Prentice-Hall, 1998.
EstructurasdedatosenJava. Weiss,M.A.AddisonWesley,2001.
TheJavaTutorial.SecondEdition.ObjectOrientedProgrammingfortheInternet.M.Campione&K.
Walrath.SunMicrosystems,1998.
1. gaia: Sarrera
Erreferentziak:
[Booch, 94] 1. eta 2. gaiak
[Meyer,
[Meyer, 99] 1. gaia
[Booch, 94] 4. gaia
Edukiak
Softwarea garatzeko arazoak

Software-ingeniaritza
2016-01-25
Helburuak eta ezaugarriak

g
Printzipioak
Hurbilpenak
Programazio-lengoaiak
PMOO: Sarrera
Helburuak
Irakasgaiaren zergatia azaldu
Programa handiek planteatzen dituzten
zailtasunak azaldu: softwarearen krisia
Arazo hauek gainditzeko jarraitu behar
diren diseinu-metodoak aurkeztu
2016-01-25
PMOO: Sarrera
Programa edo aplikazio bat egitea ez da, gehienetan,

t k
txakurrarentzako
t k txabola
t b l bat
b t egitea
it bezain
b i erraza...
Txakurrarentzako txabola
egiteko, honako hauek
behar ditugu:
2016-01-25
PMOO: Sarrera
Pertsona bat
Plano txiki bat
Erreminta sinple batzuk
Materiala
...
Antz handiagoa du, maiz, etxe orratz bat egitearekin,

l
lanaren
konplexutasunari
k
l t
i erreparatzen
t
badiogu
b di
behintzat
b hi t t
2016-01-25
Pertsona bat
Plano txiki bat
Erreminta sinple batzuk
Materiala
...
Lantalde oso bat

Plano konplexu eta
xehetasunez betetakoak
Oso tresna eta erreminta
aurreratuak
Material sofistikatua
...
PMOO: Sarrera
SWa garatzeko arazoak

Programa txikiak
Ondo zehaztutako helburuak
Problema ondo ulertzen da
Askotan ez da dokumentazio
handirik behar
Denbora gutxian egin daitezke
Kodea irakurrita erraz uler
daitezke
Egiaztatzeko eta aldatzeko
errazakk
2016-01-25
Programa handiak
Oso problema konplexuak
Dokumentazio konplexua:
betebeharren identifikazioa,
zehaztapena, diseinua...
Talde
T ld bat
b behar
b h da
d
Kode-lerro asko
Aldatzeko zailak
=> Ingeniaritza-proiektu
h di k dit
handiek
dituzten
t arazoen
antzekoak
PMOO: Sarrera

Lantaldea
Komunikazio- eta koordinazio-arazoak
Aldatzeko arazoak (pertsona bakarrak ez du
aplikazio osoa ulertzen)
Dokumentazioaren
D k
i
beharra
b h
Birdiseinatzea ezinezkoa da, erroreak edo
betebehar desberdinak agertzen direnean
2016-01-25
PMOO: Sarrera

Nola koordinatu bost programatzaile, bi
analista eta diseinatzaile bat, aplikazioa hiru
hilabetean bukatzeko?
Banekien ez zela samurra izango ordu

estren kalkulua nominen aplikazioan
txertatzea! Zein moduluri eragiten dio
aldaketak? Zeren mendeko da? Nork
programatuko
k d
du orain atall hau?
h ?
Enpresa kudeatzeko aplikazio berriak

amaitua behar zuen duela hilabete! Ez
dago bukatuta, eta aurrekontua
agortua da dagoeneko...
2016-01-25
PMOO: Sarrera

Softwarearen krisia
Aplikazioak konplexuak direnez, epez kanpo
bukatzen dira,
dira ez dira fidagarriak,
fidagarriak eta ez dute
espezifikazioa betetzen
Aplikazio handiak gero eta zailagoak dira
kudeatzeko eta mantentzeko
Krisi
K i i hau
h gainditzeko
i dit k artisauen
ti
filosofia
fil fi utzi
t i eta
t
ingeniaritza-printzipio sendoak finkatu eta
erabili
bili behar
b h dira
di
2016-01-25
PMOO: Sarrera

Softwarearen krisiaren sintomak
Erantzun eskasa: aplikazioek ez dituzte
erabiltzaileen beharrak betetzen
Fidagarritasun-eza: akatsak
Aldagarritasun-eza:
Ald
it
mantentze garestia
i eta
konplexua
Eramangarritasun-eza: zaila da plataforma
batetik bestera pasatzea
Eraginkortasun-eza: baliabideen erabilpena ez
da hoberena ((optimotik
p
urrun))
2016-01-25
PMOO: Sarrera
10

Softwarearen krisiaren ondorioak
Softwarea hardwarearekin alderatuz garestia da
Proiektu handiak epez kanpo bukatzen dira
(edo erdi-bukatuta geratzen dira maiz)
2016-01-25
PMOO: Sarrera
11
SWaren krisia: grafikoa

2004
18
2000
53
23
1998
49
28
1995
31
28
46
40
1994
29
Porrota
Arazoak
Arrakasta
26
33
53
27
16
Iturria: (Standish Group International, I. (2001). Extreme chaos. &

(2004) Chaos demographics - 2004 third q
(2004).
quarter
arter research report)
2016-01-25
PMOO: Sarrera
12

Softwarearen krisiaren zergatiak:
g
Softwarearen bizitza-zikloa bera eta bere
ondorioak ez dira ondo ulertzen
Jende gutxi dago ondo prestatuta
Arkitektura
A ki k
klasikoek
kl ik k ez dituzte
di
programazioi
teknika berriak eraginkorki exekutatzen
Programazio-lengoaia eta -metodologia
zaharkituak erabiltzen dira
2016-01-25
PMOO: Sarrera
13
SWaren bizitza
bizitza-zikloa
zikloa
Analisia
Moduluak
kodetu eta
integratu
Diseinua
Kodetzea &
Arazketa
(debugging-a)
Softwarea
sisteman
integratu
Probak
Ustiapena
p
eta
mantentzea
2016-01-25
PMOO: Sarrera
14
Bezeroak honela
azaldu du
Honela dokumentatzen
da lana
Proiektu-buruak
honela ulertu du
Analistak honela
diseinatu du
Programatzaileak
honela idatzi du
Marketingekoek
honela saltzen dute
Honela dabil
instalatutako bertsioa
Bezeroari hau
fakturatzen zaio
Hau da aurreikusitako
laguntza zerbitzua
Bezeroak hau behar

zuen!!!
htt // dd d il bl
http://addydavila.blogspot.com.es/2011/08/crisis-del-software.html
t
/2011/08/ i i d l ft
ht l
2016-01-25
PMOO: Sarrera
15

Soluzioak
Ingeniaritzako teknikak aplikatu: metodologia,
lengoaia eta tresna egokiak
Tresnak:
Programazio
P
i egituratuko
it t k teknikak
t k ik k
Datuen fluxu-diagramak
Obj kt t oinarritutako
Objektuetan
i
it t k metodologiak
t d l i k
Garapen-inguruneak
Aukeratutako programazio-lengoaiak
metodologia berriekin bat etorri behar du
2016-01-25
PMOO: Sarrera
16
Software ingeniaritza
Software-ingeniaritza
Programa informatiko handiak garatzeko eta

mantentzeko dauden metodoen aplikazioa
2016-01-25
PMOO: Sarrera
17
Software-ingeniaritza:
programen ezaugarriak
i k
Softwaregintzan aldaketa konstante bat da.
Aldaketen eragina gainditzeko, softwareak
honako ezaugarri hauek eduki behar lituzke:
Aldagarritasuna
Eraginkortasuna
g
Fidagarritasuna
Ulergarritasuna
2016-01-25
Software-ingeniaritzaren
Software
ingeniaritzaren
helburuak
PMOO: Sarrera
18
Aldagarritasuna
Sistemen aldaketa kontrolatua: zati batzuk
ukitu gabe beste batzuk aldatu behar dira
emaitza berriak lortzeko
Arrazoiak:
Eskakizun berriak
Akatsak
Aplikazio aldagarria: aldaketak onartzen

dit
dituena,
j t i k diseinuan
jatorrizko
di i
eragin
i gabe
b
2016-01-25
PMOO: Sarrera
19
Eraginkortasuna
Aplikazioak baliabideak modu hobeezin
batean erabili behar ditu
Denbora
D b
eta
t espazioa
i (memoria)
(
i )
Algoritmo batzuk beste batzuk baino
eraginkorragoak dira
Batzuetan ggehiegi
g zentratzen ggara
eraginkortasunean, diseinua albo batera utziz
Mikroeraginkortasuna vs makroeraginkortasuna
2016-01-25
PMOO: Sarrera
20
Fidagarritasuna
Zuzentasuna,, sendotasuna
Aplikazioak betebeharrak betetzen ditu,
espero den moduan
Errore posibleak aurreikusi eta saihestu,
garapenaren hasiera-hasieratik
Erroreen konponketa, sistema martxan dela
Ohikoak ez diren baldintzetan, aplikazioak
ondo
ondo erantzun behar du
Salbuespenak
2016-01-25
PMOO: Sarrera
21
Ulergarritasuna
Diseinuak eta kodeak ulergarriak izan behar dute
Behe-mailan: kodeketa-estiloa
Goi-mailan: algoritmoak
g
eta datu-egiturak
g
bereizi behar
Programazio-lengoaiaren mendeko alderdi bat

da neurri batean
da,
Programa bat pertsona batek idazten du, baina
beste hainbatek irakurri edota aldatu behar izaten
dute bere bizi-denboran zehar
2016-01-25
PMOO: Sarrera
22
Software-ingeniaritzaren
Software
ingeniaritzaren oinarriak
1.
2.
3
3.
4.
Abstrakzioa
Informazio-ezkutatzea
Modulartasuna eta lokalizazioa
Bestelakoak
2016-01-25
PMOO: Sarrera
23
Abstrakzioa
Funtsezko ezaugarriak
g
hartu eta funtsezko
ez direnak gerorako utzi
Datuetan eta algoritmoetan aplikatzen da
Abstrakzio-maila bakoitzean datu-mota
abstraktu batzuk (DMA) identifikatuko
ditugu; horrela konplexutasuna txikitzen da,
aplikazioa ulergarriagoa eta mantentzeko
errazagoa eginez
2016-01-25
PMOO: Sarrera
24
Abstrakzioa
Abstrakzioa
Ab k i hainbat
h i b
mailatan gauzatzen da
Abstrakzio-maila
Ab t k i
il
bakoitzean DMA
batzuk identifikatuko
ditugu
DMA horien
i l
inplementazioa,
i
xehetasunak...
g
beheragoko
mailetarako utziko
ditugu
2016-01-25
PMOO: Sarrera
25
Informazio ezkutatzea
Modulu bakoitzean, sistemaren gainontzeko moduluek
b h ez dituzten
behar
di
xehetasunak
h
k ezkutatzea
k
da
d informazioi f
i
ezkutatzearen helburua
Adibid
Adibidez, prozedura
d
bbatek
k erabiltzen
bil
dituen
di
aldagai
ld i
lokalak kanpotik ez dira ikusi behar; ezta datu-mota
abstraktu bat nola dagoen inplementatuta (zer datu-egitura
erabiliz) ere
Onurak:
Ulergarritasuna handitu
Aldagarritasuna handitu
Fidagarritasuna handitu
2016-01-25
PMOO: Sarrera
26
2016-01-25
PMOO: Sarrera
27
Abstrakzioa eta
informa io e k tat ea
informazio-ezkutatzea
2016-01-25
PMOO: Sarrera
28

Aplikazio handiak egituratu egin behar ditugu,
beren osagaiak bereiziz
Beheranzko diseinua (top-down): maila bakoitzean,
bakoitzean
geroz eta modulu txikiagoetan deskonposatzen da
aplikazioa
G
Goi-mailan,
i
il abstrakzio
b t k i hhandia:
di ZER EGIN
Behe-mailan, abstrakzio txikiagoa: NOLA EGIN
Goranzko diseinua ((bottom-up):

p) behe mailako
moduluetatik hasi sistema osoa garatzeko (liburutegien
ideia)
Bi teknikok erabiltzen dira benetako aplikazioetan

2016-01-25
PMOO: Sarrera
29
Goranzko eta beheranzko diseinuak
M5
2016-01-25
M3
M6
M4
M7
PMOO: Sarrera
M8
TOP-DO
OWN
M2
BO
OTTOM-U
UP
Abstrakzio
A
oa
M1
M9
30

Moduluak izan daitezke:
Funtzionalak: azpiprogramak
Deklaratiboak: datu-motak, objektuak
Moduluaren interfazea/espezifikazioa ongi

definituta egotea eskatzen du fidagarritasunak
Akoplamendua (coupling): moduluen arteko
interkonexioaren indarra
Ahal den txikiena hobe, moduluak ahalik eta
independenteen izan daitezen
Kohesioa (cohesion): modulu barneko elementuen

arteko lotura eta erlazioen sendotasuna
Kohesio handia interesatzen zaigu
2016-01-25
PMOO: Sarrera
31

Lokalizazioa: hurbiltasun fisikoa;; logikoki
g
erlazionaturik dauden objektuak, fisikoki
modulu berean bildu
Kohesio handia
Akoplamendu txikia

Onurak:
Ulergarritasuna (aplikazioaren egitura ulergarria)
Aldagarritasuna (aldaketak lokalizatzea errazagoa)
Fidagarritasuna (interfaze ondo definituak)
2016-01-25
PMOO: Sarrera
32
Bestelakoak
Uniformetasuna: kodetzean ggida batzuk
erabiliz
Programatzeko estilo ona
Ulergarritasuna
Osotasuna: problemaren elementu guztiak

kontuan hartzea
Egiaztagarritasuna: aplikazioa deskonposa
d it k egiazta
daiteke
i t daitezkeen
d it k
zatietan
ti t
Mota-sistema zorrotza (strong typing)
2016-01-25
PMOO: Sarrera
33
Bestelakoak
Hedagarritasuna
g
Aplikazioa hedatu behar denean, softwareak
modu erraz batean onartu behar ditu aldaketak
Berrerabilgarritasuna
Modulu bat hainbat aplikaziotan erabil
dezakegu
Bateragarritasuna
Software edo plataforma desberdinetarako
baliagarria da egindakoa
2016-01-25
PMOO: Sarrera
34
Bestelakoak
Eramangarritasuna
Aplikazioa beste ingurune batera eramateko gaitasuna
Erabilerraztasuna
Instalatzeko, maneiatzeko eta gainbegiratzeko
erraztasuna
Segurtasuna
Konputagailua erasotzeko ahuleziak ez edukitzea
Arazoak gertatzen badira, informazioa ez galtzea
Sendotasuna
Ustekabekoen aurrean modu egokian erantzutea
2016-01-25
PMOO: Sarrera
35
Softwarearen garapenerako hurbilpenak

Pertsonon mugak
g kontuan hartu behar dira
Gizaki batek zazpi gauza baino gehiago
ezin (omen) ditu aldi berean kontrolatu
Metodoek laguntzen dute gure sistemak
modu egituratu batean sortzen
Metodoak garrantzitsuak dira
Konplexutasuna txikitzeko
Lantaldearen barruko komunikazioa hobetzeko
2016-01-25
PMOO: Sarrera
36
Softwarearen garapenerako hurbilpenak

Diseinu-metodoak:
Funtzionalak
Beheranzko diseinua
Goranzko diseinua
Diseinu mistoa
--------------- Datu-egituretan
Datu egituretan oinarritutako diseinua
Objektuei orientatutako diseinua
2016-01-25
PMOO: Sarrera
37
Beheranzko diseinua
Problema baten abstrakzio-sekuentzia

Prozesuan oinarritzen da, algoritmoetan
P
Pauso
bbakoitzean
k i
modulu
d l bat
b
Goi-mailan
Go
a a ZER EGIN
GN
Behe-mailan NOLA EGIN
2016-01-25
PMOO: Sarrera
38
Datu-egituretan
Datu
egituretan oinarritutako diseinua
Datuetan zentratzen da
dira, eta gero
Lehenbizi datuak definitzen dira
sistemaren arkitektura eta programak garatzen
dira
di
g
Horiei dagozkien
g
eragiketak
g
Datu-egiturak
2016-01-25
PMOO: Sarrera
39
Objektuei orientatutako diseinua

Softwarea garatzeko beste metodo bat
Moduluak sistemak maneiatzen dituen
objektuak izango dira
Datu-motak + eragiketak: DMA-ak
Zer egin behar den pentsatu aurretik,
zein objektuk egin behar duen pentsatu
2016-01-25
PMOO: Sarrera
40
Programazio lengoaiak
Software-ingeniaritzan aritzeko prestaturik daude lengoaia
b i k
berriak
Ada:
Objektuetan oinarritutako programazioa eta objektuei
orientatutako programazioa
Abstrakzioa, modulartasuna, informazio-ezkutatzea...
informazio ezkutatzea...
Software segurua eta denbora errealekoa garatzeko egokia.
Software berrerabilgarria sortzeko egokia
Java:
Objektuei orientatutako programazioa
Abstrakzioa, modulartasuna, informazio-ezkutatzea...
Interneterako erabilgarria izateko sortua: web-aplikazioak
garatzeko erraztasunak
2016-01-25
PMOO: Sarrera
41
Programazio-lengoaia ez da dena,
b i askotan
baina
k
lagun
l
dezake...
d k
M
Mars
Cli t (1999)
Climate
http://en.wikipedia.org/wiki/Mars_Climate_Orbiter
Adibide gehiago:
http://hub4techie.com/wodpress/2012/09/software-crisis/
2016-01-25
PMOO: Sarrera
42
og a a o e goa a historian
sto a zehar
e a
Programazio-lengoaien bilakabidea, modulartasunari
dagozkion zenbait ezaugarriren arabera
Lehen belaunaldia (1954-1968)
FORTRAN I
ALGOL 58
Flowmatic
IPL V
espresio matematikoak
Bigarren belaunaldia (1959-1961)

(1959 1961)
FORTRAN II:
ALGOL 60:
COBOL:
LISP:
azpirrutinak, konpilazio banatua

bloke-egitura, datu-motak
datuen deskribapena, fitxategien maneiua
lista-prozesatzea, erakusleak
2016-01-25
PMOO: Sarrera
44
og a a o e goa a historian
sto a zehar
e a
Hirugarren
g
belaunaldia ((1962-1970))
PL/1:
FORTRAN+ALGOL+COBOL
ALGOL 68: ALGOL 60-ren ondorengoa (zehatz-mehatz)
Pascal:
ALGOL 60-ren ondorengoa (neurri handi batean)
Si l
Simula:
klaseak,
kl
k datu-abstrakzioa
d
b k i
Tarteko belaunaldia (1970-1980)

C
Iraun
I
ez dduten hhainbat
i b lengoaia
l
i
1980ko hamarkada
Ada (1983/1995/2005/2012): paketeak, generikoak, mota pribatuak, mota
etiketatuak herentzia,
etiketatuak,
herentzia dispatching-a
dispatching a
C++: klaseak, template-ak, herentzia anizkoitza
Java: klaseak, paketeak, interfazeak, herentzia, dispatching-a
Eiffel: objektuei orientatutako lengoaia purua
1990etik aurrera (Internet, scripting-a): segurtasuna, fidagarritasuna,

egiaztagarritasuna, datu-baseekiko integrazioa
Perl,, Python,
y
, PHP,, Ruby
y
2016-01-25
PMOO: Sarrera
45
2. gaia: Modulartasuna
Erreferentziak:
[Bell et al.,
al 92] 5
5. kapitulua
[Meyer, 99] 3. kapitulua
[Booch, 94] 11. kapitulua
[C h
[Cohen,
96] 10.,
10 11
11. eta 13
13. kkapituluak
i l k
[Durn et al., 07]
Edukiak
Oinarrizko kontzeptuak: definizioa, kapsulaketa,
informazio-ezkutatzea
Datu-mota
D t
t abstraktuak
b t kt k (DMA)
Egoera-makina abstraktuak (EMA)
UML:
UML klase-diagramak
kl
di
k eta
t klase
kl
arteko
t k d
dependentzia
d t i
Modulartasuna eta kapsulaketa Adan eta Javan
Modulartasuna:
M d l t
paketeak
k t k (Ada)
(Ad ) eta
t klaseak
kl
k (Java)
(J
)
Pribatutasuna
Konpilazio-ereduak:
Konpilazio ereduak: liburutegi-unitateak
liburutegi unitateak Adan
2016-01-28
PMOO: Modulartasuna
Modulartasuna
Modulartasunaren kontzeptua
p
aurkeztu,,
kapsulaketarekin batera. Programa handiak
garatzeko ezinbestekoak dira biak.
g
Aplikazio handiak nola modularizatzen diren
aztertu eta bere abantailak ikusi.
Datu-mota abstraktuen kontzeptua azaldu,
aurreko bi kontzeptuekin
p
lotuz.
Ada eta Java lengoaiek modulartasuna eta
kapsulaketa
p
bermatzeko eskaintzen dituzten
baliabideak aurkeztu.
2016-01-28
PMOO: Modulartasuna
Korrespondentzia zuzena
Problemaren egitura
g
modulu-egituran
g
islatu behar da
Problemaren espazioan
p
agertzen
g
diren
elementuek agertu behar dute soluzioaren
(programaren) espazioan ere
Modulu bakoitzak ahalik eta modulu

gutxienekin komunikatu behar du, bere
autonomia
t
i ahalik
h lik eta
t h
handiena
di
iizan d
dadin
di
Komunikazio-interfazea: azpiprogramak
Parametroak:
P
t k gutxi
t i
2016-01-28
PMOO: Modulartasuna
Moduluen interfazea eta modulu

arteko mendekotasuna
Interfazea:
Modulutik kanpo erabil daitezkeen eragiketen
multzoa
Ondo definituta,, parametroak
p
eta emaitzak
Eragiketen portaera zehaztu behar
Mendekotasuna (dependentzia):
Moduluek beste modulu batzuen beharra dute,
beste modulu batzuen mendeko dira
Modulu arteko dependentzia-erlazio horiek
irudikatuko dute p
programaren
g
arkitektura
2016-01-28
PMOO: Modulartasuna
Interfazea - Dependentziak
p
2016-01-28
PMOO: Modulartasuna
Modulutan banatzeko irizpideak

Tamaina:
Modulua zenbat eta txikiago
txikiago, orduan eta
ulergarriago
Oreka bilatu behar da:
Oso txikiak badira, asko edukiko ditugu
eta maneiatzeko zailak izango dira;
abiadura ere motelduko da
badira, funtzionalitate
Oso handiak badira
gehiegi edukiko dute
2016-01-28
PMOO: Modulartasuna

Konplexutasuna:
Ahalik eta argienak izan behar dute
programek
Garapen-denbora
Garapen denbora txikitzeko
Mantentzea errazteko
Nola
N l llortu
t argitasuna?
it
?
Algoritmorik sinpleenak hobetsi
Iruzkinak idatzi, dokumentatu
Programatzen... dotore izan behar da
2016-01-28
PMOO: Modulartasuna

Datuen araberako banaketa:
Probleman identifikatutako objektu mota
bakoitzeko, modulu bat
Modulu bakoitzak honako hauek bilduko ditu bere
barruan (kapsulaketa):
Motako objektuak errepresentatzeko datu-egiturak

Datuak sortzeko eragiketak (eraikitzaileak)
Datuak atzitzeko eragiketak
Datuak aldatzeko eragiketak
Datuak eragiketa multzo zehatz baten bidez

bakarrik atzituko dira
2016-01-28
PMOO: Modulartasuna
Informazio ezkutatzea
Moduluaren diseinatzaileak aukeratu behar
ditu zein ezaugarri izango diren publikoak

Gainontzeko guztiak (gehienak) pribatuak
izango dira
Funtzionalitatea (publikoa) eta
inplementazioa (pribatua) banatu behar dira
B t moduluek
Beste
d l k ezin
i dit
dituzte
t modulu
d l b
baten
t
ezaugarri pribatuak erabili
2016-01-28
PMOO: Modulartasuna
10
Datu-Mota
Datu
Mota Abstraktuak
DMA bat balio eta eragiketa multzo
bat da. Balio eta eragiketa horiek
espezifikazio independente baten
bitartez definitzen dira
Datu-mota: balio onargarri multzo bat eta
bere eragiketak
Oinarrizkoak: Integer, Character
Egituratuak: array, record
2016-01-28
PMOO: Modulartasuna
11
Datu-Mota
Datu
Mota Abstraktuak
Eredu matematikoa: Motak eta beren eragiketak

Motek balio onargarriak definitzen dituzte beren
aldagaientzat
E
Eragiketak:
ik t k
Eraikitzaileak (sorkuntza)
Atzitzekoak (kontsulta)
Aldatzekoak
Datuen errepresentazioa
p
eta eragiketen
g
inplementazioa ezkutatzen da
Eragiketen inplementazioa azpiprogramen bidez
gauzatzen
t
da
d
2016-01-28
PMOO: Modulartasuna
12
Datu-Mota
Datu
Mota Abstraktuak
DMAen osagaiak:
Motaren zehaztapena
Sintaxia: motaren izena,
izena eragiketen izenak
(parametroak eta emaitzen mota)
Semantika: eragiketen portaera
Inplementazioa
E
Errepresentazioa:
t i
DMA
DMA-aren
egitura,
it
oinarrizko
i
i k
motetan eta beste DMA batzuetan oinarrituta
Algoritmoak: eragiketen inplementazioa
2016-01-28
PMOO: Modulartasuna
13
Datu-Mota
Datu
Mota Abstraktuak
DMA batek abstrakzio bat
errepresentatzen du
Zehaztapenaren detaileak nabarmentzen
dira
di
Inplementazioaren detaileak ezkutatzen
dira
2016-01-28
PMOO: Modulartasuna
14
Datu-Mota
Datu
Mota Abstraktuak
Adibidea: Zenbaki arrunten segida:

g
NATSEG
Zehaztapen sintaktikoa:
2016-01-28
HUTSA:
JARRI: NATSEG x NAT
KATEATU: NATSEG x NATSEG
LEHENENGOA: NATSEG
GAINERAKOA: NATSEG
LUZERA: NATSEG
ALDERANTZIZKOA NATSEG
ALDERANTZIZKOA:
NATSEG
NATSEG
NATSEG
NAT
NATSEG
NAT
NATSEG
PMOO: Modulartasuna
15
Datu-Mota
Datu
Mota Abstraktuak
Zehaztapen semantikoa:
HUTSA: segida hutsa sortzen du
JARRI (S,N): N jartzen du segidaren hasieran
KATEATU (S1, S2): S1 eta S2 segidak kateatzen ditu
LEHENENGOA (S): S segidako lehenengo zenbakia lortzen
du
GAINERAKOA (S): S segida lehenengo zenbakirik gabe
lortzen du
LUZERA (S): S segidaren luzera lortzen du
ALDERANTZIZKOA (S): S segidako elementuak
alderantzizko ordenan jarrita sortutako segida lortzen du
2016-01-28
PMOO: Modulartasuna
16
Datu-Mota
Datu
Mota Abstraktuak
Errepresentazioa: inplementazio
estatikoa
Max: constant Positive := 100;
type Segida is array (1 .. Max) of
Natural;
type Natseg is
i record
d
Elementuak: Segida;
Zenbat: Natural range 0 .. Max;
end record;
2016-01-28
PMOO: Modulartasuna
17
Datu-Mota
Datu
Mota Abstraktuak
Errepresentazioa:
p
inplementazio
p
dinamikoa
(erakusle bidezkoa):
type Nat_Nodo;
type Natseg is access Nat_Nodo;
Nat Nodo;
type Nat_Nodo is record
Elementua: Natural;
Hurrengoa: Natseg;
end record;
2016-01-28
PMOO: Modulartasuna
18
Datu-Mota
Datu
Mota Abstraktuak
Algoritmoak: inplementazioa
errepresentazioaren menpe dago
procedure Hutsa (S: out Natseg);
f
function
i
Hutsa return Natseg;
procedure Jarri (S: in out Natseg;
N: in Natural);
function Jarri (S: in Natseg;
N: in Natural) return Natseg;
2016-01-28
PMOO: Modulartasuna
19
Datu-Mota Abstraktuak: Data

motaren arazoa (adibidea)
t
type
D t is
Data
i record
d
Eguna : Positive range 1 .. 31;
Hila : Positive range 1 .. 12;
Urtea : Positive range 1900 .. 2100;
end
d record;
d
D1, D2 : Data;
--...
D1 :
:= (30, 2, 2016); --ezerk
ezerk ez du eragozten hau egitea!!!
D1.Eguna := 5 * D2.Hila; --hau ere ez; baina... ba ote du zentzurik?
Zergatik
g
g
gertatzen da hori?
Datu-mota lengoaiak eskaintzen dituen record oinarrizko egituraren bidez

errepresentatuta dagoelako, kanpotik atzitzeko moduan (publiko), eta, beraz, erregistroekin
egiten ahal den edozein eragiketa egiten ahal delako, oro har, Data motako erregistroekin
ere.
ere
Soluzioa:
Datu-mota abstraktu gisa inplementatu, errepresentazioa ezkutatuz, eta datekin egitea nahi
dugun eragiketak (soilik) publiko eginez.
2016-01-28
PMOO: Modulartasuna
20
Datu-Mota Abstraktuak: Data

motaren arazoa (adibidea)
package
k
D t k is
Datak
i
subtype Egun is Positive range 1 .. 31;
subtype Hil is Positive range 1 .. 12;
subtype Urte is Positive range 1900 .. 2100;
type Data is private;
procedure Sortu (E : in Egun; H : in Hil; U : in Urte; D : out Data); --eraikitzailea
function Eguna (D : in Data) return Egun; --kontsulta
function Hila (D : in Data) return Hil; --kontsulta
function Urtea (D : in Data) return Urte; --kontsulta
function Tartea (D1, D2 : in Data) return Integer;
-- ... bestelako eragiketak
private
type Data is record
Eguna : Positive range 1 .. 31;
Hila : Positive range 1 .. 12;
Urtea : Positive range 1900 .. 2100;
end record;
end Datak;
datak.ads
--...
D1 := (30, 2, 2016); --konpilazio-errorea!!! => erabili Sortu:
Datak.Sortu (30, 2, 2016, D1); --geuk kontrolatzen dugu zer den data egoki bat!!!;
--kasu honetan, errore bat sorrarazi beharko litzateke
if D1.Urtea = 2011 then -konpilazio-errorea!!! => erabili Urtea funtzioa:
(D1)
) = 2011 then ...
if Datak.Urtea (
2016-01-28
PMOO: Modulartasuna
21
DMA a: adibide osoago bat

DMA-a:
-- Ikasle
Ik l DMA-a
DMA
(d t
(datu-abstrakzioa):
b t k i ) Ikasle
Ik l motako
t k objektuen
bj kt
kl
klasea
with Taldeak, Notak; --inportazioa (mendekotza)
package Ikasleak is
type Ikasle is private;
-- mota esportatzen du
-- eragiketa multzoa (inplementazioak, paketearen gorputzean)
-- eraikitzailea
procedure Sortu
(Izena: in String; Taldea : in Taldeak.Talde; I : out Ikasle);
-- kontsulta
f
function
ti
I
Izena
(I : in
i Ik
Ikasle)
l ) return
t
St i
String;
function Taldea (I : in Ikasle) return Taldeak.Talde;
function Nota (I : in Ikasle) return Notak.Nota;
ikasleak.ads
2016-01-28
PMOO: Modulartasuna
22

DMA-a:
-- aldaketa
ld k t
procedure Aldatu_Taldea (I : in out Ikasle; Taldea : in Taldeak.Talde);
procedure Esleitu_Nota (I : in out Ikasle; N : in Notak.Nota);
private
type Ikasle is --motaren inplementazioa (ezkutuan, pribatua)
record
Izena : String (1 .. 25);
Taldea : Taldeak.Talde;
Nota : Notak.Nota;
end
d record;
d
end Ikasleak;
ikasleak.ads
2016-01-28
PMOO: Modulartasuna
23

DMA-a:
package body Ikasleak is
procedure
d
S t (I
Sortu
(Izena : i
in String;
St i
Taldea : in Taldeak.Talde;
I
: out Ikasle) is
g
begin
if Izena'Last > 25 then
I.Izena := Izena (Izena'First .. Izena'First + 24);
else
I I
I.Izena
(1 .. I
Izena'Last)
'L t) := I
Izena;
for K in Izena'Last + 1 .. 25 loop
I.Izena (K) := ' ';
end loop;
p
end if;
I.Taldea := Taldea;
end Sortu;
function Izena (I : in Ikasle) return String is
begin
return I.Izena;
end Izena;
2016-01-28
PMOO: Modulartasuna
ikasleak.adb
24

DMA-a:
function Taldea (I : in Ikasle) return Taldeak.Talde is
begin
return I.Taldea;
end Taldea;
function Nota (I : in Ikasle) return Notak
Notak.Nota
Nota is
begin
return I.Nota;
end Nota;
procedure Aldatu_Taldea (I : in out Ikasle; Taldea : in Taldeak.Talde)
is
begin
I Taldea := Taldea;
I.Taldea
end Aldatu_Taldea;
procedure Esleitu_Nota (I : in out Ikasle; N : in Notak.Nota) is
begin
ikasleak.adb
I.Nota := N;
end Esleitu_Nota;
end Ikasleak;
2016-01-28
PMOO: Modulartasuna
25

DMA-a:
---------------------------------------------------------------Ikasleak paketearen erabilera-adibidea
--
objektuak,
with Ikasleak, Taldeak, Notak;
procedure Proba
Proba_Ikasleak
Ikasleak is
programa
I1, I2 : Ikasleak.Ikasle;
bezeroan
T : Taldeak.Talde;
N : Notak.Nota;
begin
Taldeak.Sortu ("SIIT46", T);
Notak.Sortu (4.5, N);
Ikasleak.Sortu ("Miriam", T, I1);
Ikasleak Sortu (
Ikasleak.Sortu
("Xabier"
Xabier , T,
T I2);
--...
Ikasleak.Esleitu_Nota (I1, N);
Ada.Text_IO.Put (Ikasleak.Izena (I1) & " ikaslearen nota: ");
Ada Float Text IO Put
Ada.Float_Text_IO.Put
(Ikasleak.Nota (I1), Fore => 2, Aft => 1, Exp => 0);
--...
end Proba_Ikasleak;
proba_ikasleak.adb
2016-01-28
PMOO: Modulartasuna
26
Egoera-Makina
Egoera
Makina Abstraktuak
(singleton)
Objektua bera kapsulatuta dago; ikusezina
da moduluaren erabiltzailearentzat.
Objektuaren egoera (balioa)
(balioa), une konkretu
bakoitzean, moduluan bertan gordetzen da
Eragiketak
E ik t k bakarrik
b k ik esportatzen
t t
di
dira ((motarik
t ik
ez)
2016-01-28
PMOO: Modulartasuna
27
EMA a: adibidea
EMA-a:
-- E
Erasmusekoen
k
ik
ikasgela,
l
objektu-abstrakzioa:
bj kt
b t k i
egoera-makina
ki
abstraktua
b t kt
(EMA)
with Ikasleak, Taldeak, Notak; --inportazioa (mendekotza)
package Erasmus_Ikasgela is
-- ez du motarik esportatzen
-- hasieratzea
procedure Kargatu_Fitxategitik;
-- kontsulta
function Ikaslerik_Onena return Ikasleak.Ikasle;
function Zenbat
Zenbat_Ikasle
Ikasle return Natural;
-- aldaketa
procedure Ikaslea_Gehitu (I : in Ikasleak.Ikasle);
procedure Ordenatu;
end Erasmus_Ikasgela;
erasmus_ikasgela.ads
2016-01-28
PMOO: Modulartasuna
28
EMA a: adibidea
EMA-a:
with Ada.Text_IO; --inplementaziorako premiak
package body Erasmus_Ikasgela is
-- objektu kapsulatua (gehi gainerako barne-aldagaiak,
-- eta beharrezko motak)
type Ikasle50 is array (Positive range 1 .. 50) of Ikasleak.Ikasle;
Ikasleak Ikasle;
type Ikasgela_Mota is
record
Ikasleak : Ikasle50;
Zenbat : Natural range 0 .. 50;
end record;
-- hauxe da pakete honetako objektu kapsulatua:
objektu
j
Ikasgela : Ikasgela_Mota;
kapsulatua
Fitxategi_Izena : String := "erasmus.txt";
--...
erasmus_ikasgela.adb
2016-01-28
PMOO: Modulartasuna
29
EMA a: adibidea
EMA-a:
-- eragiketok objektu kapsulatuaren gainean egiten dute lan
procedure Kargatu_Fitxategitik is
begin
-- eratu Ikasgela erregistroa, datuak fitxategitik irakurriz
-- ordenatu array-a, notaren arabera (adibidez)
-- ... (inplementatzeko dago)
end Kargatu_Fitxategitik;
function Ikaslerik_Onena return Ikasleak.Ikasle is
begin
return Ikasgela.Ikasleak (1); -- ordenatuta dago
end Ikaslerik_Onena;
function Zenbat_Ikasle return Natural is
begin
return Ikasgela.Zenbat;
end Zenbat_Ikasle;
--...
2016-01-28
PMOO: Modulartasuna
30
EMA a: adibidea
EMA-a:
procedure Ikaslea_Gehitu (I : in Ikasleak.Ikasle) is
begin
Ikasgela.Ikasleak (Ikasgela.Zenbat + 1) := I;
Ikasgela Zenbat := Ikasgela
Ikasgela.Zenbat
Ikasgela.Zenbat
Zenbat + 1;
end Ikaslea_Gehitu;
procedure Ordenatu is
begin
-- ordenatu array-a
null;
end Ordenatu;
end Erasmus_Ikasgela;
2016-01-28
PMOO: Modulartasuna
31
EMA a: adibidea
EMA-a:
---------------------------------------------------------------- Erasmus_Ikasgela paketearen erabilera-adibidea
-with Erasmus_Ikasgela, Ikasleak, Taldeak;
with Ada.Text_IO;
procedure Proba_Erasmus_Ikasgela is
I1 : Ikasleak.Ikasle;
T : Taldeak.Talde;
N : Notak.Nota;
begin
-- Erasmus_Ikasgelako eragiketen deietan ez da ageri ikasgela bera
-- errepresentatzen duen objekturik argumentu gisa
Erasmus_Ikasgela.Kargatu_Fitxategitik;
-- ikasle berri bat sortu, eta nota esleitu
Taldeak.Sortu ("SIIT46", T);
Notak.Sortu (8.5, N);
Ikasleak.Sortu ("Miriam", T, I1);
Ikasleak.Esleitu_Nota (I1, N);
Erasmus_Ikasgela.Ikaslea_Gehitu (I1);
Erasmus_Ikasgela.Ordenatu;
Ada.Text_IO.Put_Line (Ikasleak.Izena (Erasmus_Ikasgela.Ikaslerik_Onena));
end
d Proba_Erasmus_Ikasgela;
b
k
l
proba_erasmus_ikasgela.adb
2016-01-28
PMOO: Modulartasuna
32
DMA-ak eta EMA-ak / datu-motak

eta aldagaiak (paralelismoa)
I
I : Integer := 50;
50
I aldagaia da, objektua, balio baten edukiontzia

g , berriz,, mota da (oinarrizkoa):
(
) balioa nolakoa den eta berarekin
Integer,
zer egin daitekeen
Ikasle_Bat : Ikasleak.Ikasle;
Ikasle_Bat
Ikasle
Bat aldagaia da
da, objektua
objektua, balio baten edukiontzia
Ikasleak.Ikasle, berriz, mota da (DMA-a): balioa nolakoa den eta
berarekin zer egin daitekeen (Ikasleak paketeak kapsulatzen ditu
motaren
t
erazagupena eta
t motako
t k objektuekin
bj kt ki egin
i daitezkeen
d it k
eragiketak)
ik t k)
Erasmus_Ikasgela EMA paketea, azkenik, aldagai baten antzera erabil
dezakegu: balio baten edukiontzia da, eta kapsulatzen duen paketeak
ematen dizkigu eragiketak, hau da, objektuarekin zer egin daitekeen
(eragiketak)
2016-01-28
PMOO: Modulartasuna
33
Modulartasuna Adan: kapsulaketa

p
eta informazio-ezkutatzea
Paketeak
Datu
Datu-mota
mota pribatuak eta mugatuak
2016-01-28
PMOO: Modulartasuna
34
Modulartasuna Adan
Paketeak
Izendun programa-unitateak
Osagaiak: datu-motak,
datu motak, azpiprogramak, interfazea
Abantailak:
Garapen azkarra (talde

(talde-lana)
lana)
Konpilazio azkarra
Zuzentzeko erraztasuna
Inplementazioa aldatzen bada, modulu bezeroak
ez dira aldatu behar
2016-01-28
PMOO: Modulartasuna
35
Modulartasuna Adan:
paketeak
Egitura
Espezifikazioa:
Paketearen espezifikazio publikoa: motak,
objektuak eta azpiprogramak
Alde pribatua (ezkutuan)
Gorputza:
G
t
Paketearen gorputza (ezkutuan gelditzen da):
espezifikazioko eragiketa publikoen inplementazioa
azpiprograma lagungarriak
bestelako erazagupen pribatuak (motak
(motak, aldagaiak
aldagaiak...))
2016-01-28
PMOO: Modulartasuna
36
Paketeen sintaxia
package <izena> is
{<erazagupenak: espezifikazioa>}
[p
[private
ate
{< erazagupenak >}]
end [<izena>];
package
k
b
body
d <izena>
i
i
is
{<erazagupenak: inplementazioa>;}
[ g
[begin
{<sententzia sekuentzia>}]
end [<izena>];
2016-01-28
PMOO: Modulartasuna
37
Datu-abstrakzioko
Datu
abstrakzioko paketeak
DMA-ak
DMA ak inplementatzeko
Datu-mota definitzen da, eta bai
h
honekin
ki egin
i d
daitezkeen
it k
eragiketak
ik t k ere
Datu-motaren egitura pribatua da
Prozedurak eta funtzioak erabiltzen dira
DMA-aren eragiketak
g
inplementatzeko
p
Paketearen gorputzean ezkutatzen da
eragiketon inplementazioa
2016-01-28
PMOO: Modulartasuna
38
Datu-abstrakzioko
Datu
abstrakzioko paketeak
package Konplexuak is
type Konplexu is
record
Erreala : Float;
Irudikaria : Float;
end record;
function Berria (R1, R2 : in Float)
return Konplexu;
function Batura (C1, C2 : in Konplexu)
return Konplexu;
function Biderkadura (C1,
(C1 C2 : in Konplexu)
return Konplexu;
-- ...
end Konplexuak;
2016-01-28
PMOO: Modulartasuna
39
package Konplexuak is
type Konplexu
K
l
i private;
is
i
I : constant Konplexu; --konstante diferitua
function Berria (R1, R2 : in Float)
return Konplexu;
function Batura (C1, C2 : in Konplexu)
return Konplexu;
function Biderkadura (C1, C2 : in Konplexu)
ret rn Konplexu;
return
private
type
yp Konplexu
p
is
record
Erreala : Float;
I dik i : Float;
Irudikaria
Fl t
end record;
I : constant Konplexu
p
:= (
(0.0,
, 1.0);
)
end Konplexuak;
konplexuak.ads
2016-01-28
PMOO: Modulartasuna
40
package Pilak is
type Pila is private;
function Berria return Pila;
procedure Pilaratu (P1 : in out Pila; X : in Character);
procedure Despilatu (P1 : in out Pila; X : out Character);
private
i t
Max : constant := 100;
type Taula is array (1 .. Max) of Character;
type Pila is
record
Info : Taula;
Gailurra : Integer range 0 .. Max;
end record;
end Pilak;
pilak.ads
package body Pilak is
end
e
d Pilak;
a ;
eragiketen
inplementazioa
2016-01-28
pilak.adb
PMOO: Modulartasuna
41
Datu-mota pribatuak
eta mugatuak
Datu-mota pribatu eta pribatu mugatuak
erazagutuz, programatzaileak beren
ikusgaitasuna kontrolatzen du
Datu-mota
mota hauek beren inplementazioa
Datu
ezkutatzen dute
private atalean erazagutzen dena
paketean bertan bakarrik erabil daiteke
Ez baditugu objektuak pribatu gisa erazagutzen
erazagutzen,
kanpotik atzi eta alda daitezke arazoak ekar
ditzake honek
2016-01-28
PMOO: Modulartasuna
42
Datu-mota pribatuak eta

mugatuak
type <izena> is [limited] private;
Datu-mota p
pribatuetako objektuekin
j
egin
g
daitezkeenak (kanpoan):
Azpiprogramen parametro gisa erabili

Funtzio baten emaitza izan
Esleipena
= eta /= konparazioak
Esportatzen diren eragiketak (publikoak)

2016-01-28
PMOO: Modulartasuna
43
Datu-mota pribatu mugatuak
Datu-mota p
pribatu mugatuetako
g
objektuekin
j
egin daitezkeenak (kanpoan):
Azpiprogramen
pp g
p
parametro g
gisa erabili
Funtzio baten emaitza izan
Esportatzen diren eragiketak (publikoak)
BAINA EZ: esleipena, = eta /=
Ondorioak
Aldagaiak paketean bakarrik hasieratzen dira
Besterik ezeko baliodun parametroak ez dira
onartzen
Programatzaileak guztiz kontrolatzen du paketea
2016-01-28
PMOO: Modulartasuna
44
bi eragiketa
horiek eskaini
beharra dago,
mota mugatuak
erabiliz gero
package Pilak is
type Pila is limited private;
procedure Sortu_Berria (P : out Pila);
procedure Pilaratu (P1 : in out Pila; X : in Character);
procedure Despilatu (P1 : in out Pila; X : out Character);
function Berdin (P1, P2: in Pila) return Boolean;
procedure Kopiatu (P1: out Pila; P2: in Pila);
private
type Nodo;
type Pila is access Nodo; --dinamikoki inplementatua
type Nodo is
record
Info : Osagai;
Hurrengoa : Pila;
end record;
end Pilak;
pilak.ads
eragiketen
g
inplementazioa
end
d Pilak;
il k
2016-01-28
PMOO: Modulartasuna
pilak.adb
45
Objektu-abstrakzioko
p
paketeak
Egoera-Makina Abstraktuak (EMA)
inplementatzeko
Objektua bera kapsulatuta dago
Objektuaren egoera (balioa) une konkretu bakoitzean
paketean gordetzen da
Eragiketak bakarrik esportatzen dira (motarik ez)
DMAekin ez bezala, EMA bat erabiltzen duen
aplikazioak objektu bakarra erabiliko du; ezin du
mota horretako aldagairik sortu
"mota"
Ikus dezagun beste adibide bat!: Pila EMA-a.
2016-01-28
PMOO: Modulartasuna
46
package Pila
procedure
procedure
procedure
end
d Pila;
i
is
Sortu Berria;
Sortu_Berria;
Pilaratu (X : in Character);
Despilatu (X : out Character);
pila.ads
package body Pila is

Max : constant := 100;
type Taula is array (1 .. Max) of Character;
yp Pila_Mota is record
type
objektu
Info : Taula;
kapsulatua
Gailurra : Natural range 0 .. Max;
end record;
P : Pila_Mota; --estatikoki inplementatua
procedure Sortu_Berria is ...
procedure Pilaratu (X : in Character) is ...
procedure Despilatu (X : out Character) is ...
end Pila;
pila.adb
ikus,, hurrengo
g
transparentzian,
eragiketon
inplementazioa
2016-01-28
PMOO: Modulartasuna
package body Pila is

--...
procedure Sortu_Berria is
p
begin
P.Gailurra := 0;
end Sortu_Berria:
Sortu Berria:
procedure Pilaratu (X : in Character) is
begin
P.Gailurra
i
:= P.Gailurra
i
+ 1;
P.Info (P.Gailurra) := X;
end Pilaratu;
47
eragiketen
inplementazioa,
objektu
kapsulatuaren
gainean
"gainean
eragiten dutela
procedure Despilatu (X : out Character) is

begin
P.Gailurra :
:= P.Gailurra - 1;
X := P.Info (P.Gailurra + 1);
end Despilatu;
end Pila;
2016-01-28
PMOO: Modulartasuna
pila.adb
48
Esparrua eta ikusgaitasuna Adan
Identifikadorearen esparrua: identifikadorea

ikus (erabil) daitekeen programaren zatia
Zer eragin
Z
i d
dute
t Ad
Ada paketeek
k t k
identifikadoreen ikusgaitasunean eta beren
esparruan?
?
2016-01-28
PMOO: Modulartasuna
49

Pp
paketea eta I identifikadorea emanik, eta I
erazagututa P paketearen alde publikoan:
I ikusgai dago pakete osoan, erazagututa dagoen
t kitik bukaeraraino
tokitik
b k
i
Beste unitate batek P inportatzen badu (with
klausula erabiliz) eta use klausula erabiltzen badu
badu, I
erabil dezake kualifikatu gabe (baldin eta bere barruan
I izeneko beste aldagai bat ez badauka)
package P is
I :...;
...
2016-01-28
with P; use P;
procedure P1 ...;
...
I := ...;
...
PMOO: Modulartasuna
50

P paketea eta I identifikadorea emanik, eta I
erazagututa P paketearen alde pribatuan:
I ikusgai dago P paketearen alde pribatuan
eta gorputzean (eta beste inon ez)
2016-01-28
PMOO: Modulartasuna
51

P paketea eta I identifikadorea emanik, eta I
erazagututa P paketearen gorputzean:
II ikusgai dago erazagutzen den tokitik
gorputzaren bukaeraraino
II ezin da ikusi P paketetik kanpo
2016-01-28
PMOO: Modulartasuna
52
with Text_IO; use Text_IO;

procedure Multiply_Matrices is
...
M,N,P : Positive;
begin
G (M)
Get
(M); Get
G (N);
(N) Get
G (P);
(P)
declare
type Matrix is ...;
procedure Get_Matrix (M:out Matrix);
procedure Put_Matrix (M:in Matrix);
p
function Matrix_Product
(M1,M2:Matrix) return Matrix;
A:Matrix (1..M,1..N);
B:Matrix (1..N,1..P);
C:Matrix (1..N, 1..P);
procedure Get_Matrix
Get Matrix
(M:out matrix) is
begin
for I in M'Range(1) loop
for J in M'Range(2) loop
Get (M(I,J));
end loop;
end loop;
end Get_Matrix;
(a)
(b)
(c)
procedure Put_Matrix
(M:in
(M
in Matrix) is
begin
...
end put Matrix;
function Matrix_Product
(Ml,M2:Matrix) return Matrix is
P : Matrix
M t i (...,
(
...);
);
begin
... return P;
end Matrix_Product;
begin
Get_Matrix (A);
Get_Matrix (B);
C:= Matrix_Product (A,B);
Put_Matrix (C);
end;
end Multiply_Matrices;
with Text_IO; use Text_IO;

procedure Izenak_Ordenatu is
subtype Izenak is ...;
;
Izena1 : Izenak;
package Ordenatzeko_Zerbitzua is
...
procedure Sartu
(Izen_Berria : Izenak);
...
end Ordenatzeko_Zerbitzua;
Ordenatzeko Zerbitzua;
...
package body Ordenatzeko_Zerbitzua is
...
Zerrenda : ...
...
procedure Sartu
(Izen Berria : Izenak) is
(Izen_Berria
...
begin
end Sartu;
...
end Ordenatzeko_Zerbitzua;
...
begin
Ordenatzeko_Zerbitzua.Sartu (Izena1);
end Izenak_Ordenatu;
Ikusgaitasunerregelak
g
Lerro etenek adierazten
dute non ez diren
zuzenean ikusgai
identifikadoreak
(a) M-ren ikusgaitasuna
(globala))
(g
(b) Matrix motaren
ikusgaitasuna
(c) Get_Matrix-en
ikusgaitasuna
(a) Ikusgaitasun-
erregelak
(b)
(c)
(a) Izenak-en
ikusgaitasuna
(b) Sartu-ren
ikusgaitasuna
(c) Zerrenda-ren
ik
ikusgaitasuna
i
package A is
...
X-ren erazag.
Y ren erazag.
Y-ren
erazag
...
endd A;
e
;
( )
(a)
(b)
Ikusgaitasunerregelak
package B is
...
Y-ren erazag.
Z ren erazag.
Z-ren
erazag
...
end B;
...
with A,B; use A,B;
Z-ren erazag.
(c)
(d)
(a) X-ren ikusgaitasuna

(A-kk esportatuta)
(A
(b) Y-ren ikusgaitasuna
((A-k esportatuta)
p
)
(c) Y-ren ikusgaitasuna
(B-k esportatuta)
(e)
(d) Z-ren ikusgaitasuna

(B-k esportatuta)
(e) Z-ren ikusgaitasuna
(globala)
Ariketa: diseinatu Zatiki DMA-a

inplementatuko duen Ada paketea
Errepresentazioa:
Zenbakitzailea: zenbaki osoa
Izendatzailea: zenbaki positiboa
limited?
Eragiketak:
eraikitzailea
kontsulta-eragiketak (zenbakitzailea, izendatzailea)
eragiketa aritmetikoak eta
erlazio-eragiketak (+, *, /... =, /=, < ...)
sinplifikatua...
p
2016-01-28
PMOO: Modulartasuna
56
Modulartasuna Javan: kapsulaketa

p
eta informazio-ezkutatzea
Klaseak (Adako
(
paketeen kidekoak))
Informazio-ezkutatzea (ikusgaitasuna, oro
har)) modifikatzaileen bidez gauzatzen
g
da:
private, protected, public...
2016-01-28
PMOO: Modulartasuna
57
Modulartasuna Javan: klasea

Klasea = Javako modulu-unitate nagusia
g
DMA bat edo EMA bat inplementatzeko egokia
Informazio-ezkutatzea gauzatzeko egokia
Objektu
Obj kt edo
d instantzia
i t t i multzo
lt baten
b t abstrakzioa
b t k i errepresentatzen
t t
du
Programa bat hainbat klase erlazionatuk osatzen dute.

Aldagai eta eragiketa oro klase baten barruan erazagutu edo/eta
inplementatu behar dira.
Java programa baten exekuzioa bere klase nagusitik hasten da,
bertako main metodoa exekutatuz.
2016-01-28
PMOO: Modulartasuna
58

Data klasearen atributuak edo
eremuak:
eguna,
g
,
hila
urtea.
Datak maneiatzeko
maneiatzeko, eragiketa
edo metodo batzuk behar
dira:
klaseko objektuak eraiki

(instantziatu)
bi dataren arteko egun
kopurua kalkulatu
data baten urtea zein den
jakin
...
2016-01-28
class Data {
private int eguna;
private int hila;
private int urtea;
//. . .
public Data(int e, int h, int u)
{...}
public int egunKop(Data bestea)
{
{...}
}
public int urtea()
{...}
//
//...
}
Data.java
PMOO: Modulartasuna
59

moduluaren
(klasearen) izena
inplementazioa:
datuak eta eragiketak
(ezkutuan)
class Data {
private int eguna;
private int hila;
private int urtea;
//. . .
public Data(int e, int h, int u)
public int urtea()
//...
}
{...}
{...}
{...}
Data.java
interfazea
(publikoa)
2016-01-28
PMOO: Modulartasuna
60

Klaseak
Eremuak: oinarrizko motetako aldagaiak eta objektualdagaiak
ld
i k ((edo
d erreferentzia-aldagaiak).
f
t i ld
i k)
Metodoak: eragiketak.
Ikusgaitasuna eta atzipen-kontrola (modifikatzaileak):

protected, public, private...
Objektuak: klaseen instantzia.
2016-01-28
PMOO: Modulartasuna
61
Klaseen ikusgaitasuna Javan

public: aplikazioko klase guztietarik ikusgai (beheko Klasea2 eta
Klasea3)
package (besterik ezean, ez da esplizituki adierazten): public

modifikatzailerik ez badago, ikusgaitasunari package esaten zaio:
kl
klasea
b
bere paketeko
k t k kl
klaseetatik
t tik b
bakarrik
k ik ik
ikusiko
ik d
da (b
(beheko
h k
Klasea1)
p1 paketea (src/p1 direktorioan, eskuarki)
package p1;
package p1;
package p1;
class Klasea1 {
public class Klasea2 {
public class Klasea3 {
2016-01-28
PMOO: Modulartasuna
63
Klaseen definizioa: kideak

Klase baten ezaugarriak eta funtzionalitatea
eremu eta metodoen bitartez definitzen dira:
klaseko kideak dira (members).
Eremuak: oinarrizko motetako aldagaiak edo
objektu-erreferentziak (klaseren bateko
instantziak).
instantziak)
<klaseko-kidearen-erazagupena> ::=
<modifikatzailea>*{<eremu erazag > | <metodo-erazag.>}
<modifikatzailea>*{<eremu-erazag.>
<metodo erazag >}
2016-01-28
PMOO: Modulartasuna
64
Klaseen definizioa: kideak

class
l
MotorKlase
l
{
{...}
}
class Kamioi {
private int g
p
gurpilKopurua;
p
p
;
// aldagai osoa; pribatua
private double pisua;
// aldagai erreala; pribatua
protected MotorKlase motorra;
// erreferentzia-aldagaia; babestua
private char[] matrikula;
// karakterezko array-a; pribatua
//...
//
}
Kamioi.java
2016-01-28
PMOO: Modulartasuna
65
Kideen modifikatzaileak: atzipena

<atzipenaren-zehaztapena>::=
public: aldagaia edo metodoa edozein klasetatik ikusgai
dago.
protected: aldagaia edo metodoa bere klasetik, klase
umeetatik eta bere paketeko klase guztietatik dago
ikusgai.
private: aldagaia edo metodoa bere klasean bakarrik dago
ikusgai.
[ ]: package (besterik ezean, ez da esplizituki adierazten):
aldagaia edo metodoa bere paketeko edozein klasetatik
dago ikusgai.
2016-01-28
PMOO: Modulartasuna
67
Kideen modifikatzaileak:
aldagaiak eta konstanteak
<kide-konstantea>::=
final:
eremua bada: konstante bat da.
metodoa bada: ezin da azpiklaseetan birdefinitu
birdefinitu.
[ ] (ez bada zehazten, ez da finala): balioa aldatzen ahal zaio.
Konstante bat klase mailan baino ezin da definitu (ezin

da, beraz, metodoetan).
private final int MAX = 1000;
private final boolean BADAGO = true;
2016-01-28
PMOO: Modulartasuna
68
Informazioaren ezkutatzea:
ikusgaitasuna (laburbilduz...)
Klaseak publiko erazagut daitezke (public) edo
package
k
ik
ikusgaitasun-mailarekin
it
il ki ((pakete
k t b
bereko
k
beste klaseetatik baino ikusten ez direla); klase
pribatuak ere definitzen ahal dira (beste batzuen
barruan, eskuarki).
Aldagai kideak (klaseko aldagaiak) eta metodoak
(eragiketak) public, private, protected edo
package izan daitezke.
2016-01-28
PMOO: Modulartasuna
69
Eremuak: aldagaiak eta objektuak

Eremua: oinarrizko mota bateko aldagaia edo objektu baten
erreferentzia.
<eremu-erazag.>
g ::= {{<mota-izena> | <klase-izena>}}
<eremu-ident.> [= <espresioa>];
mota-izena bada: aldagaia (datu-eremua)
klase-izena
klase
izena bada: klase horretako objektu baten erreferentzia (instantzia)
Datu-eremua
Datu
eremua (aldagaia)
Aldagai oro klase baten baitan erazagutu behar da.
Besterik ezeko hasieratzea: boolean ->

> false; char ->
> \0;
\0 ; ...
Aldagaiak ikusgai daude erazagutu diren blokean.
2016-01-28
PMOO: Modulartasuna
70

Objekt erem a
Objektu-eremua
Eremu bat objektu baten erreferentzia izan dadin nahi
bada objektua new eragilearen bitartez sortu beharko
bada,
da (instantziazioa):
<klase-izena>
<klase
izena> <eremu-ident
<eremu ident.>
>=
new <eraikitzailearen-izena> [<parametroak>]*
Sorkuntzan automatikoki deitzen zaio klaseko eraikitzaileari.
Horrela lortzen da sortu berri den erreferentzia objektu-aldagai

horrek izan dezan.
g
eremu ez-estatiko g
guztien kopia
p bat
Klase horretan erazaguturiko
sortzen da instantzian.
2016-01-28
PMOO: Modulartasuna
71

class Auto {
private String matrikula;
private double abiadura;
private double abiaduraMax;
//...
}
Auto.java
Klasearen ezaugarriek klaseko objektuak nolakoak diren

errepresentatzen dute.
2016-01-28
PMOO: Modulartasuna
72

Auto a = new Auto();
a
Auto@133
matrikula
a.matrikula = "4324 BBD";

a.abiadura = 70.0;
a abiaduraMax = 123
a.abiaduraMax
123.45;
45;
abiadura
abiaduraMax
"4324 BBD" esleitzen du
System.out.println
(
(a.matrikula
t ik l + " autoa
t
" + a.abiadura
bi d
+
abiaduran doa.");
Puntu-notazioa erabiltzen da klase bateko ezaugarriak atzitzeko: ezaugarri

horiek pribatuak direnez, hori ezin da klase kanpotik egin, jakina (kasu
horretan, metodoak eragiketak erabili beharko genituzke)
2016-01-28
PMOO: Modulartasuna
73
Metodoak
Klase bateko metodoek klase horretako objektuek
j
egin
g
ditzaketen eragiketak (funtzionalitatea) definitzen dituzte.
Metodoa: sententzia-sekuentzia bat.
Parametroak: metodoaren argumentuak.
p
balioz beti ((kopia);
p ); baina kontuz,,
Parametro-pasea:
oinarrizko motak ez direnetan (erreferentzia- edo objektumotetan), helbidea da kopiatzen dena!!!
M
Metodoen
t d
barruan
b
ere erazagutt d
daitezke
it k b
barne-klaseak
kl
k
(habiaratuak).
void: "prozedura"
p
dela adierazten du,, ez baitu inongo
g
baliorik itzultzen emaitza gisa (bestela, "funtzioa" da).
2016-01-28
PMOO: Modulartasuna
74
Metodoak: main eta eraikitzaileak

main: metodo
t d b
berezia,
i JVMtik b
bere kl
klasearii d
deii egiten
it zaionean
i
exekutatzen dena.
Eraikitzaileak: klasearen izen bera duten metodo bereziak

bereziak.
Klasea sortzen duen programatzaileak eraikitzaile bat edo gehiago

idatz ditzake (parametro desberdinekin), eta horiek izango dira
objektuak sortzean erabiliko direnak.
Besterik ezean, parametrorik gabeko eraikitzailea dago klase orotan:
eremuak hasieratu
hasieratu, erreferentzia bat lortu (erakuslea)
(erakuslea).
Parametrodun eraikitzaileren bat baldin badago, ordea, parametrorik
gabekoa ez da automatikoki sortzen, eta, beraz, esplizituki egin
b h k d
beharko
da.
2016-01-28
PMOO: Modulartasuna
75
Metodoak
Metodoa "funtzioa" denean, return sententzia
bat izan behar du bere gorputzean.
Metodo bati deitzeko, dagokion objektuaren
izena jjarriko zaio aurretik ((objektu
j
horrek
"jasotzen du mezua"):
<objektuaren-izena>.<bere-klaseko-metodoaren-izena>
j
Klaseko metodoak: static

modifikatzailearekin erazagutuak
erazagutuak, klasearen
izena aurretik jarriz deitzen zaie.
2016-01-28
PMOO: Modulartasuna
76
Metodoak
class Auto {
private String matrikula;
this uneko objektua da, hau da,
private double abiadura;
private double abiaduraMax;
bizkortuMax eragiketa egiten/jasaten ari
// bizkortu topera
dena
void bizkortuMax() {
this abiadura = this
this.abiadura
this.abiaduraMax;
abiaduraMax;
}
Hala ere, kasu honetan ez da
//...
ezinbestekoa this erabiltzea:
}
Auto java
Auto.java
abiadura=abiaduraMax;
Klasearen ezaugarriek klaseko objektuak nolakoak diren errepresentatzen dute.

Metodoek klaseko objektuek zer egiten/jasaten duten adierazten dute (portaera).
2016-01-28
PMOO: Modulartasuna
77
Metodoak
Auto a = new Auto();
a.matrikula = "SS-4324-BD";
a.abiadura = 70.0;
a.abiaduraMax = 123.45;
System.out.println(a.matrikula + " autoa " + a.abiadura +
" abiaduran doa.");
a bizkortuMax();
a.bizkortuMax();
System.out.println(a.matrikula + " autoa " + a.abiadura +
" abiaduran doa.");
Objektuek egoera edo balioa mantentzen dute uneoro.
Metodoak ere puntu (.) eragilearen bidez

atzitzen dira.
2016-01-28
PMOO: Modulartasuna
78
Metodoak: gainkarga
class Puntu {
private double x;
private double y;
void print() {
System.out.println("Puntua: " + this.x + "," + this.y);
}
void print(int n) {
for (int i = 0; i < n; i++) {
System.out.println("(" + this.x + "," + this.y + ")");
}
}
}
Puntu.java
Puntu klaseko bi print metodoak desberdinak dira: print gainkargatuta

(overloaded) dagoela esaten da.
2016-01-28
PMOO: Modulartasuna
79
Kideen modifikatzaileak: partekotza

<partekotzaren definizioa>::=
<partekotzaren-definizioa>::=
static: aldagaia edo metodoa klaseari dagokio soilik (ez da

heredatzen) Klaseko aldagai edo metodo esaten zaie
heredatzen).
zaie.
[ ] (ez bada zehazten, ez dira estatikoak): objektu (instantzia)

bakoitzak aldagaiaren edo metodoaren bere bertsioa izango du
(heredatu egingo du).
g edo metodo estatikoak leku bakar batean

Klase bateko aldagai
gordetzen dira; ez-estatikoak, berriz, dagokion objektuan
gordetzen dira.
Objektu
Obj
kt bat
b t eraikitzean
ikit
(instantzia
(i t t i dinamikoki
di
ik ki sortzean)
t
)
aldagai/metodo ez-estatiko bakoitzaren kopia bat sortzen da
(instantzian, objektuan).
2016-01-28
PMOO: Modulartasuna
80
Adibidea: static
public class K {
private static int zenbatInstantzia = 0;
private char c; //eremu hau instantziek edukiko dute
public K() {
c = '';
;
zenbatInstantzia++;
}
public static int zenbatAle() {return zenbatInstantzia;}
}
K.java
public class Proba {

public
pub
c stat
static
c void
o d main(String[]
a (St
g[] a
args)
gs) {
K k1 = new K();
K k2 = new K();
System.out.println(K.zenbatAle());
}
}
Proba.java
2016-01-28
PMOO: Modulartasuna
81
Kontuz objektuen erreferentziekin!

public class Erabiltzaile
{
public class
Nagusia {
private
i t St
String
i
i
izena;
private Float pisua;
public Erabiltzaile(String
izena,
Erabiltzaile[]
erabTaula =
Float pisua) {
{new
Erabiltzaile
("Idoia", new Float (55.5)),
this izena = izena;
this.izena
this.pisua = pisua; new Erabiltzaile ("Xabi", new Float (75.5))};
}
System.out.println
public String getIzena() {

("1. erabiltzailearen izena: " + erabTaula[0].getIzena());
return izena;
}
System.out.println("1. erabiltzailearen pisua: " +
erabTaula[0].getPisua().toString()); //Idoiaren pisua
public void setIzena(String izena) {

this.izena = izena;
Erabiltzaile e1 = erabTaula[0];
}
e1.setPisua(new Float(89.3));
public Float getPisua() {
return pisua;
System.out.println("1. erabiltzailearen pisua: " +
}
erabTaula[0].getPisua().toString()); //Idoiaren pisua?

public void setPisua(Float
pisua) {
}
this.pisua = pisua;
}
}
}
2016-01-28
PMOO: Modulartasuna
82
DMA a: adibidea Javaz

DMA-a:
/**
* Ikasle DMA-a inplementatzen duen klasea
*/
public class Ikasle {
// klasearen barne-errepresentazioa: eremuak
private String izena; //ikaslearen izena
private Talde taldea;
p
; //
//ikasleari dagokion
g
taldea
private Nota nota; //ikaslearen nota
/**
* Eraikitzailea: ikasle bat sortzen du, izena eta taldea emanik
* @param izena ikaslearen izena
* @param taldea ikasleari dagokion taldea
*/
public Ikasle(String izena, Talde taldea) {
this.izena = izena;
this taldea = taldea;
this.taldea
}
2016-01-28
PMOO: Modulartasuna
Ikasle.java
83

DMA-a:
// k
kontsulta-metodoak
t lt
t d k
public String izena() {
return this.izena;
}
public Talde taldea() {
return this.taldea;
}
public Nota nota() {
return this.nota;
}
// aldaketa-metodoak
public void aldatuTaldea (Talde t) {
this.taldea = t;
}
public void esleituNota (Nota n) {
this.nota = n;
}
}
2016-01-28
PMOO: Modulartasuna
Ikasle.java
84

DMA-a:
/**
* IkasleProba: Ikasle klasea probatzeko programa
*/
objektuak,
j
,
public class IkasleProba {
programa
bezeroan
Ikasle i1, i2;
i1 = new Ikasle("Miriam", new Talde("SIIT46"));
i2 = new Ikasle("Xabier", new Talde("SIIT46"));
//...
i1.esleituNota(new Nota(4.5));
System.out.print(i1.izena() + " ikaslearen nota: ");
i1.nota().put();
System.out.println();
//...
//
}
}
IkasleProba.java
2016-01-28
PMOO: Modulartasuna
85
EMA-ak
EMA
ak Javaz: singleton patroia
DMAek ez bezala, EMA baten eragiketak objektu bakar
baten gainean egiten dira. Ezin dira klase horretako
instantziak egin
egin.
Singleton patroia erabiliz idazten dira EMA-ak Javaz.
Singleton patroia:
Eraikitzaileak pribatua izan behar du (klasearen instantziak
egitea
g
eragozteko)
g
)
Atributuak klase mailakoak izango dira (static)
Metodoek klasearen barruko objektu kapsulatuaren gainean
izango dute eragina
eragina, eta hauek ere estatikoak izango dira
2016-01-28
PMOO: Modulartasuna
86
EMA a (singleton): adibidea Javaz

EMA-a
/**
* Erasmusekoen ikasgela, objektu-abstrakzioa (EMA-a, singleton patroia)
*/
public class ErasmusIkasgela {
objektu
// konstanteak
kapsulatua
private static final int KOP_MAX = 50;
private static final String FITXATEGI_IZENA = "erasmus.txt";
// objektu kapsulatua(k)
// obj. kapsulatu nagusia: ikasleen bektorea
private
i t static
t ti Ikasle[]
Ik l [] ik
ikasgela
l = new Ikasle[KOP_MAX];
Ik l [KOP MAX]
// azken ikaslearen kokapena:
private static int azkena = -1;
ErasmusIkasgela.java
2016-01-28
PMOO: Modulartasuna
87

EMA-a
/**
* eraikitzailea (pribatua, hutsik):
* inork ezin du klase honen instantziarik eraiki
/
*/
private ErasmusIkasgela(){
}
// hasieratzea
/**
* eratu ikasgela, datuak fitxategitik irakurriz;
* ordenatu
d
t array-a, notaren
t
arabera
b
(
(adibidez)
dibid )
*/
public static void kargatuFitxategitik() {//inplementatzeke dago
}
2016-01-28
PMOO: Modulartasuna
88

EMA-a
// k
kontsulta
t lt
public static Ikasle ikaslerikOnena() {
return ikasgela[0]; //ordenatuta dagoela emanik, lehena itzultzen du
}
public static int zenbatIkasle() {
return azkena + 1;
}
// aldaketa
public static void ikasleaGehitu(Ikasle i) {
ikasgela[azkena + 1] = i;
azkena
k
=+
+ 1
1;
}
public static void ordenatu() { //inplementatzeke dago
}
}
2016-01-28
PMOO: Modulartasuna
89

EMA-a
public
bli class
l
E
ErasmusIkasgelaProba
Ik
l P b {
Ikasle i1;
ErasmusIkasgela.kargatuFitxategitik();
// ikasle berri bat sortu, eta nota esleitu
i1 = new Ikasle("Miriam", new Talde("SIIT"));
i1.esleituNota(new Nota(8.5));
// ikaslea ikasgelan sartu eta ikasgela ordenatu
ErasmusIkasgela.ikasleaGehitu(i1);
ErasmusIkasgela.ordenatu();
// ikasgelako onenaren izan inprimatu
System.out.println ("Ikasle onena: " +
ErasmusIkasgela.ikaslerikOnena().izena());
}
}
metodoak
klasearenak
dira, ez
objektu edo
instantzia
batenak
ErasmusIkasgelaProba.java
2016-01-28
PMOO: Modulartasuna
90
Ariketa
EMA bat inplementatu: zenbaki-makina
g
Eragiketak:
hasieratu: zenbaki bat emanik...
hurrengo
g zenbakia
Adaz eta Javaz

Adibidea:
hasieratzen dugu makina 1000 zenbakiarekin
hurrengo zenbakia eragiketari deitzen diogunean,
diogunean
1001, 1002, 1003... zenbakiak lortuko ditugu (aldiro
bat)
2016-01-28
PMOO: Modulartasuna
91
UML, labur-labur
UML,, Modelatzeko Lengoaia
g
Bateratuak ((Unified
Modeling Language) software-sistemen modeloak
sortzeko balio du.
Sistema bat bistaratu, espezifikatu, eraiki eta
g
g
grafiko bat da
dokumentatzeko lengoaia
Software-sistema baten "planoa" (modeloa)
deskribatzeko estandartzat har daiteke
daiteke, eta honako
elementu hauek biltzen ditu, besteak beste: sistemaren
g
eta funtzionalitatea,, datu-baseen ereduak,,
logika
osagai berrerabilgarriak, erabilera-kasuak...
2016-01-28
PMOO: Modulartasuna
95
UML, labur-labur
UML 2.0-n 13 diagrama mota bereizten dira
Sistemaren egitura edo arkitektura deskribatzekoak: klase-,
osagai- eta objektu-diagramak, besteak beste.
Sistemaren portaera deskribatzekoak: sekuentziadiagramak, erabilera-kasuenak eta abar.
Irakasgai honetan klase-diagramak baino ez ditugu

erabiliko:
klaseen ezaugarriak eta egiturak deskribatu
klaseen arteko mendekotasuna (dependentziak) azaldu
klase/azpiklase erlazioak deskribatu
2016-01-28
PMOO: Modulartasuna
96
UML, labur-labur
Klase-diagrama
Klase bat errepresentatzeko hiru ataletan banatutako koadro bat erabiltzen
da:
Klasearen izena
Atributuak,
Atributuak mota definitu edo zehazten dutenak
Eragiketak, motaren portaera deskribatzen duten eragiketa edo metodoak
(eraikitzaileak eta beste)
Atributu
bu u nahiz
a
metodoen
e odoe au
aurretik
e ikur
u ba
bat ja
jarri o
ohi da, be
beren
e ikusgaitasuna
usga asu a
zer-nolakoa den zehazteko: + (publikoa), - (pribatua) eta # (basbestua).
+ p
public
- private
# protected
Klasearen izena
+
+
+
Data
eguna: int
hila: int
urtea: int
Data (int, int, int)
egunKop(Data): int
hila(): int
atributuak
Data.java
eragiketak
2016-01-28
class Data {
private int eguna;
private int hila;
private int urtea;
//. . .
public Data(int d, int m, int y)
{...}
{
{...}
}
public int hila() {...}
//. . .
}
PMOO: Modulartasuna
97
UML, labur-labur
Klase-diagrama
Objektu eta klaseak elkarren artean erlazionatuta egon daitezke
Adibidez, modulu batek beste baten beharra edo dependentzia duela
erakusteko, mendekotza-erlazio orokorraz baliatuko gara (lerro etenezko
gezi bat):
+
+
+
Pertsona
jaiotzeData: Data
izena: String
sexua: String
Pertsona()
urtebetetzea(): Data
sexua(): String
+
+
+
Data
eguna: int
hila: int
urtea: int
Data (int, int, int)
egunak(Data): int
hila(): int
Klase
ase bat beste bate
baten a
azpiklasea
p asea de
dela
a ad
adierazteko,
e a te o, be
berriz,, beste ge
gezi hau
au
erabiliko dugu (aurrerago ikusiko da kontzeptu hau):
2016-01-28
PMOO: Modulartasuna
98
ErasmusIkasgela eta Ikasle:

klase-diagrama, UMLz
eraikitzailea pribatua da:
ezin dira instantziak eraiki
kanpoan
<<singleton>>
ErasmusIkasgela
ErasmusIkasgela objektua
bera maneiatzen da
proba-programa honetan
-ikasgela: Ikasle[]
-azkena: int
-ErasmusIkasgela(): ErasmusIkasgela
+kargatuFitxategitik()
+ikaslerikOnena(): Ikasle
+zenbatIkasle(): int
+ikasleaGehitu(in
( i:Ikasle))
+ordenatu()
ErasmusIkasgelaProba
+main()
eraikitzailea publikoa da
Ikasle motako i1, i2... objektuak
(instantziak) erazagutu, eraiki eta
maneiatzen dira proba-programa honetan
Ikasle
-izena: String
-taldea: Talde
-nota: Nota
+Ikasle(): Ikasle
+izena(): String
+taldea(): Talde
+nota(): Nota
+aldatuTaldea(in t:Talde)
+esleituNota(in n:Nota)
IkasleProba
+main()
Nota
Talde
Geziek modulu arteko
mendekotza (dependentzia)
adierazten dute
dute. Hala ere
ere,
irudian ez daude adierazita
dependentzia guztiak.
2016-01-28
PMOO: Modulartasuna
99
Liburutegi-unitateak
g
Programazio-lengoaia guztietan daude oso helburu desberdineko
funtzio-liburutegiak. Liburutegi horietan, askotan egin behar
izaten diren lanak "eginda" aurkituko ditugu maiz, eta, egokitze
txiki bat eginez (batzuetan ezta hori ere!), geure programetan
txertatu eta baliatu ahal izango ditugu. Askotan zailago da ongi
garatutako
k llengoaia
i b
batek
k duen
d
lib
liburutegi-sistema
i i
ondo
d
ezagutzea lengoaia bera ikastea baino.
Liburutegi unitateak:
Liburutegi-unitateak:
(Berr)erabil daitezke, beste unitate batetik inportatuz (with,
import )
import...)
Hainbat programak partekatzen ahal dituzte
Maila baxuagoko
g
beste liburutegi-unitate
g
batzuen mendeko
izan daitezke.
2016-01-28
PMOO: Modulartasuna
103
Liburutegi unitateak Adan

Programa: konpilazio-unitate multzo bat
p
azpiprograma
pp g
edo p
pakete
Konpilazio-unitatea:
baten erazagupena edo gorputza
Liburutegi-unitatea:
unitatea: kode
kode-zati
zati bat,
Liburutegi
independenteki konpilatua
Pakete
Pakete, azpiprograma edo unitate generikoa
Liburutegi-unitate baten erazagupena eta gorputza,
p
dira
normalean bi konpilazio-unitate
Liburutegi-unitate bat beste batetik erabil daiteke,
with klausula erabiliz
2016-01-28
PMOO: Modulartasuna
104
Liburutegi unitateak Adan

procedure Azpiprograma1 is
...
package Pakete1;
...
package body Pakete1 is
...
with Pakete1, Azpiprograma1;

p p g
procedure Programa_Nagusia is
...
Konpilazio-unitateak
Konpilazio
unitateak
2016-01-28
Liburutegi
unitateak
Programa
PMOO: Modulartasuna
105
Unitateak deskonposatzen
Problema handiak tratatzeko, programak
p
egin
g behar dira:
deskonposatu
Unitate habiaratua: unitate baten barruan
beste unitate bat dago
Unitate umeak
Unitate ume
me bat logikoki pakete baten barr
barruan
an
erazagutzen da, baina fisikoki separatuta dago
Unitate ume bat konpilazio-unitate
konpilazio unitate bat da
2016-01-28
PMOO: Modulartasuna
106
Unitate umeak
package Interfazea is
...
package Interfazea is
...
end Interfazea;
package Sentsoreak is
...
end Sentsoreak;
package Interfazea.Sentsoreak
Interfazea Sentsoreak is
...
end Interfazea.Sentsoreak;
package Alarmak is
...
end Alarmak;
package Interfazea.Alarmak is
...
end Interfazea.Alarmak;
interfazea.ads
interfazea-sentsoreak
interfazea
sentsoreak.ads
ads
interfazea-alarmak.ads
package Argiak is
...
end Argiak;
package Interfazea.Argiak is
...
end Interfazea.Argiak;
interfazea-argiak.ads
end Interfazea;
interfazea.ads
2016-01-28
PMOO: Modulartasuna
107
Unitate umeak
U
Unitate
it t ume b
batek
t k ez du
d with klausularik
kl
l ik
behar bere gurasoak esportatzen dituen
baliabideak erabiltzeko
g
badu with
Beste unitate batek egiten
ume unitatea, orduan erabil ditzake bere
gurasoaren baliabide publikoak ere
with Interfazea.Sentsoreak
with Interfazea,
, Interfazea.Sentsoreak
2016-01-28
PMOO: Modulartasuna
108
Unitate ume publikoak

Erazagupenean gurasoaren izena jarri behar da:
deitura hedatua
package Interfazea.Alarmak
Interfazea Alarmak is
--...
Halako unitate batean,, senideen baliabideak erabiltzeko,,

with klausulan aipatu behar dira
Halako unitate batek ezin ditu bere gurasoaren
gorputzean erazagututako baliabideak erabili
GNAT notazioa, fitxategia izendatzeko:
interfazea-alarmak.ads
2016-01-28
PMOO: Modulartasuna
109
Unitate ume publikoak

package
p
g Interfazea is
...
package Sentsoreak is
...
end Sentsoreak;
package Alarmak is
...
end Alarmak;
package Argiak is
...
end Argiak;
end
d Interfazea;
I t f
p
package
g Interfazea is
...
end Interfazea;
package Interfazea.Sentsoreak is
...
end Interfazea.Sentsoreak;
package Interfazea.Alarmak is
...
end Interfazea.Alarmak;
package Interfazea.Argiak is
...
end Interfazea.Argiak;
unitate umeak gurasoaren

zehaztapenaren bukaeran erazagututa
baleude bezala hartu behar da
2016-01-28
PMOO: Modulartasuna
110
Unitate umeak
Unitate habiaratuekin alderatuta:
U
Unitate
tate u
umeak
ea kanpotik
a pot e
erabiltzeko,
ab t e o, u
unitate
tate
umea aipatu behar da with klausulan
Unitate habiaratu publikoak,
publikoak berriz
berriz, beste
unitate batek erabil ditzake, haien gurasoa
with atalean aipatuta badago
with klausula batean sar daiteke unitate ume
bat; ez,
ez ordea
ordea, unitate habiaratu bat
2016-01-28
PMOO: Modulartasuna
111
Unitate ume pribatuak

private
i
package
k
<izena>
i
i
is
--...
Unitate ume pribatuak logikoki gurasoaren gorputzaren barruan

daude
Gurasoak umea erabil dezake, baldin eta with klausulan zehazten
badu
Unitate ume pribatu bat erabil daiteke bakarrik
bakarrik, with klausularekin,
klausularekin
bere gurasoaren gorputzean, edo hor habiaratuta dagoen beste
unitate batean
Oharra: Sudoku aplikazioan, interfaze grafikoa inplementatzen duten klaseak beste
pakete batzuen ume pribatuak dira: Taula.Interfazea, Joko_Saioa.
I t f
Interfazea
etab
etab.
2016-01-28
PMOO: Modulartasuna
112
Unitate ume pribatuak

package Aita is
...
end Aita ;
package Aita is
...
end Aita;
aita.ads
package body Aita is

package
k
Semea is
i
...
end Semea;
package body
bod Semea
S
is
...
end Semea ;
end Aita;
2016-01-28
aita.ads
aita.adb
private package Aita.Semea is

...
end Aita.Semea ;
aita-semea.ads
package
k
b d Aita.Semea
body
i
i
is
...
end Aita.Semea;
aita-semea.adb
with Aita.Semea;
package body Aita is
...
end Aita;
PMOO: Modulartasuna
aita.adb
113
Unitate umeen onurak

Problema handiak zatitzeko
g
saihesteko
Izen-gatazkak
Batzuetan modulu batek hainbat bezero ditu,
eta bakoitzak eskakizun desberdinak Bezero
bakoitzaren beharrak ume batean
Pakete baten bilakaera inplementatzeko
Programatzaile bakoitzak egin ditzake bere
unitate umeak bere beharretara egokitzeko
2016-01-28
PMOO: Modulartasuna
114
Liburutegi-unitateak Javan
Liburutegia: paketetan antolatua
Paketeak: zerikusia duten klaseak biltzeko

egitura, direktorio-egiturarekin batera etorri ohi
dena
Pakete batean honako hauek erazagutzen dira:

klaseak,, interfazeak,, salbuespenak...
p
java.applet, java.awt, java.lang
Paketeak hierarkiatan antolatzen dira:

java.lang, java.lang.reflect
2016-01-28
PMOO: Modulartasuna
115
Liburutegi-unitateak Javan: klaseak

eta paketeak nola inportatu
Klase publikoak ikusgai daude aplikazioaren edozein gunetatik
Klasearen deitura, baina, import klausula erabiltzeak edo ez
erabiltzeak baldintzatuko du:
import klausulak pakete baten barruko klaseak beren deitura hutsaz
izendatzeko aukera ematen du.
import erabiltzen ez bada
bada, klase publiko bat bere deitura hedatuaz
erreferentzia daiteke (paketearen izenaz kualifikatuz).
import java.io.*
import
java.io.BufferedReader
p
j
lehen kasuan, java.io paketeko klase guztiak inportatzen dira
bigarrenean, java.io.BufferedReader klasea baino ez da inportatzen
Klase
batean,
beraz,
erabil
ditzakegu,
beren d
deitura
hutsaz
baliatuz,
Kl
b t
b
bil dit
k
b
it
h
t
b
li t
import klausularen bidez aipatu diren pakete guztietako klase
publikoak.
2016-01-28
PMOO: Modulartasuna
117
Liburutegi-unitateak Javan: klaseak

eta paketeak nola inportatu
Kl
Klase
b
batt iinportatzeko,
t t k beraz:
b
import java.net.URL;
bli class
l
dibid
{
}
public
Adibidea
{...}
Pakete bateko klase guztiak inportatzeko:

import java.awt.*;
Kontuz!: ez ditu inportatzen azpipaketeetako klaseak
(java.awt.event-ekoak, adibidez)
java.lang ez dago inportatu beharrik, beti dago
zuzenean ikusgai (Adako Standard paketea bezala)
2016-01-28
PMOO: Modulartasuna
118
Klaseak pakete batean definitzeko
Klase b
Kl
bat,
t b
berez, iizengabeko
b k paketekoa
k t k d
da ((pakete
k t llehenetsia,
h
t i b
besterik
t ik
ezekoa).
Aplikazioko klaseak paketetan antolatu nahi badira, iturburu-programak
paketeen
k t
iizen b
bereko
k di
direktorioetan
kt i t kkokatu
k t b
behar
h di
dira, pakete-egitura
k t
it
iislatzen
l t
duen direktorio-egitura bat eratuz (hori dena, gehienetan, programazioinguruneak eginda emango digu).
Klase bat pakete batekoa dela adierazteko
adierazteko, package klausula erabili behar da
(klasearen aurretik).
Java paketeak: zentzu batean, Ada-z pakete umeak erabiliz eratutako paketehierarkien antzekoak dira
dira.
p1 paketea
package p1;
class
l
Klasea1
Kl
1 {
{...}
}
2016-01-28
package p1;
package p1;
public
bli class
l
Klasea2 {...}
class Klasea3 {...}
PMOO: Modulartasuna
119
Erroreen tratamendua. Salbuespenak.
3. gaia: Erroreen tratamendua.

Salbuespenak.
Sarrera
Erroreen tratamendua
Salbuespen motak
Programatzaileak definitutakoak
Programazio-lengoaiak aurredefinituta dituenak
[Meyer 99] 22. kapitulua

[Booch 94] 15. kapitulua
[Cohen 96] 14. kapitulua
[Durn et al., 07] 4. kapitulua
[Liskov & Guttag, 01] 4. kapitulua
Salbuespenen propagazioa
Salbuespenen tratamendua.
Salbuespenen tratamendua Adan eta Javan.
Metodologia pixka bat: nola jokatu erroreen aurrean?
2/15/2016
Helburuak: fidagarritasuna eta sendotasuna

Programek sendoak izan behar dute
Programazio defentsiboa: salbuespen-kasuak
aurreikusi
Softwarearen erabilera desegokia prebenitu
Programa batek ez luke "gaizki" bukatu behar errore
bat gertatzen denean: berriro (beste modu batean)
saiatu, "burua jaso" eta segi, bukaera "duina"...
Helburua: programa sendoak eta fidagarriak

Konpilazio-erroreak: konpilazioan atzematen dira.
Exekuzio-erroreak (salbuespenak): programa
exekuzio-errore batez amaitzen da.
Horrelakoak trata daitezke, salbuespenen mekanismoa
erabiliz.
Errore logikoak: programa ondo exekutatzen da, baina

ez du egiten egin behar duena
PMOO: Erroreen tratamendua. Salbuespenak.
Sarrera
Sarrera
2/15/2016
2/15/2016
Salbuespen motak
Erroreen tratamendua
Programazio-lengoaiak aurredefinituta dituenak
Programa bat egikaritzean sor daitezkeen egoera

bereziak tratatzeko modu desberdinak:
Programazio-lengoaia bakoitzak definituta ditu salbuespen

batzuk, kasu konkretu batzuetan automatikoki sorrarazten
direnak.
Adan, adibidez:
Programaren gorputzean, beste kasu bat bezala.

Salbuespen gisa.
Salbuespenak tratatzeko (maneiatzeko) modu

desberdinak:
Constraint_Error, Program_Error,
Storage_Error...
Salbuespen-egoera onartu eta horretaz informatu programa

deitzaileari.
Salbuespen-egoera aldatu (errorea eman duena konponduz,
sekuentziako hurrengo elementua hartuz, ordezko kode bat
exekutatuz) eta berriz saiatu.
2/15/2016
Javan:
ArithmeticException, NumberFormatException,
IndexOutOfBoundsException...
2/15/2016
Ada: salbuespen aurredefinituak
Aurredefinituak eta
programatzaileak definitutakoak
Constraint_Error:
Salbuespen aurredefinituak
Ez ditu programatzaileak erazagutu behar: Constraint_Error,

adibidez
Automatikoki sorrarazten dira, lege-hauste bat dagoenean
Programatzailearen zeregina salbuespenok aurreikusi eta tratatzea da
procedure P is
N : Positive;
begin
Ada.Integer_Text_IO.Get (N);
-- eta -4 bada teklatutik
-- sartzen dena?
-- => Constraint_Error
Domeinuz kanpoko asignazioan

Zerorekiko zatiketa
Array-en indizeen murriztapenak ez betetzean
Existitzen ez den aldagai dinamiko bat atzitzen saiatzean
(erakuslearen balioa null dela)
Programatzaileak definitutako salbuespenak
Program_Error:
Programatzaileak erazagutu behar ditu

Programatzaileak sorrarazi behar ditu: raise [Ada] / throw [Java]
return-ik gabeko funtzioetan
Programatzaileak tratatu behar ditu
2/15/2016
2/15/2016
Java: salbuespen aurredefinituak
Ada: salbuespen aurredefinituak

Storage_Error: memoria-arazoak
Sarrera/irteerakoak:
Azpiprograma errekurtsibo amaigabeak

Aldagai-erazagupen zentzugabeak
Erakusleen erabilera deskontrolatua
java.io.EOFException: Adako End_Error-en parekoa

java.io.FileNotFoundException: Adako Name_Error-en
parekoa
Bestelakoak:
ArithmeticException: Zatiketa zerorekin egiten denean, adibidez
NumberFormatException: Zenbaki bat irakurtzean, formatu
desegokia
IndexOutOfBoundsException: Array baten mugetatik "ateratzen"
garenean
NegativeArraySize: Array bati neurri negatiboak ematen
dizkiogunean
NullPointerException: Objektu bat eraiki baino lehen erabiltzen
saiatzen garenean
Sarrera/irteerako salbuespenak:
Data_Error: fitxategitik irakurritakoa ez dator bat datua
gorde nahi den aldagaiaren motarekin.
End_Error: fitxategi-bukaerara iritsi gara, eta bertatik
irakurtzen saiatu gara.
Name_Error: fitxategi bat ireki nahi, baina ez da
existitzen.
2/15/2016
2. Tipos de excepciones
Resultado de una operacin numrica que no

puede dar un resultado correcto (divisin por
cero)
Excepciones predefinidas (Java)
No hay suficiente
memoria
java.lang.ArithmeticException
Excepciones ligadas al
tratamiento de arrays:
Almacenamiento
Indices fuera de rango
Talla negativa
java.lang.ArrayStoreException
java.lang.ArrayIndexOutOfBoundsException
java.lang.NegativeArraySizeException
java.lang.IndexOutOfBoundsException
java.lang.StringIndexOutOfBoundsException
java.lang.IllegalArgumentException
java.lang.NumberFormatException
Incompatibilidad en el paso de
parmetros en procedimientos y
funciones
Hemos llegado al final del fichero y se
sigue leyendo de l
java.io.EOFException
java.io.FileNotFoundException
Error fichero no encontrado
java.io.IOException
java.lang.NullPointerException
Error de entrada salida
2/15/2016
10
Zer gertatzen da salbuespen bat

sortzen denean?
Sententzien exekuzioa geratu egiten da.
Kontrola blokeko salbuespen-maneiatzaileari ematen zaio:
salbuespen aurreikusita badago, maneiatzaileko sententziak exekutatu,
salbuespena "eraitsi", eta exekuzioak blokearen bukaeratik jarraitzen du
ez badago aurreikusita, blokea salbuespena "eraitsi" gabe amaitzen da
Beraz, salbuespena maneiaturik edo maneiatu gabe, baina

exekuzioak blokearen bukaeratik jarraitzen du (dei-puntua,
azpiprogramen kasuan).
...
2/15/2016
Acceso a una variable

dinmica no existente
11 11
2/15/2016
12
Salbuespenen propagazio dinamikoa
Zer gertatzen da salbuespen bat

sortzen denean?
Exekuzio-errorea edo salbuespena altxatzea

(aurredefinitua edo raise/throw)
exekuzio normala
eten eta kontrola pasatu salbuespena gertatu den blokeko
salbuespen-maneiatzailera
Salbuespen bat maneiatu (tratatu) gabe iristen bada programa

nagusira, kontrola bertako salbuespen-maneiatzaileari emango
zaio:
salbuespen aurreikusita badago, maneiatzaileko sententziak exekutatuko
dira eta programa "normal" bukatuko da
ez badago aurreikusita, exekuzio-errorea (mezua ingelesez, bukaera
anormala)
Ez
Bai
Tratatzen du?
Bai
Deitzailerik?
Bai
Ez
Errorerik edo
raise/
throw
maneiatzailean
?
Ez
Ez
Deitzailerik?
2/15/2016
13
Deitzaileari eman kontrola

(deia egin den ondorengo
puntura jo, eta segi)
2/15/2016
P1
14
P1
P2
P2
P3
P3
P4
P4
when X => tratatu,
prozesu lokala (sententziak,
azpiprograma-deiak...)
P5
P5
P6
2/15/2016
Programa "ondo"
bukatu da
Salbuespenen propagazioa eta

tratamendua

tratamendua
dei-pila
Bai
Deitzailearen salbuespenmaneiatzaileari eman kontrola
Exekuzioerrorea
X
salbuespena
P6
15
2/15/2016
16

tratamendua

tratamendua
P1
P1
P2
P2
P3
P3
P4
P4
when X => berriro saiatu
P5
P5
X
salbuespena
17
2/15/2016

tratamendua
18

tratamendua
P1
P1
P2
when X => sententziak
exekuzioerrorea!!
P3
when X => sententziak;

raise;
P2
P3
P4
when X => sententziak;

raise;
P5
X
salbuespena
P6
2/15/2016
P6
catch (X e) {berriro saiatu}
P6
2/15/2016
X
salbuespena
when X => berriro saiatu
Nola lor daiteke programa

baten bukaera beti
"normala", errorerik
gabekoa, izatea?
P4
X
salbuespena
P5
P6
19
2/15/2016
20
Salbuespenak Adan:
erazagutu, sorrarrazi eta tratatu
Programatzaileak definitutako salbuespenak erazagutu,
sorrarazi eta tratatu egin behar dira.
Salbuespena erazagutu:
Non? Erazagupen-atalean (blokean edo paketean)
Nola? Lista_Beterik : exception;
Salbuespena sorrarazi (edo altxarazi):

Non? Sententzia-atalean (sententzia baten bidez)
Nola? raise Lista_Beterik; edo raise; soil-soilik
Salbuespena tratatu, maneiatu:

Non? Blokearen amaieran.
Nola?
2/15/2016
begin
--...
exception
when Lista_Beterik => ... [raise;]
end;
21
Sorraraztea (altxatzea)
raise [<salbuespen-izena>];
Tratamendua, salbuespen-maneiatzailean: errorea

gertatuz gero zer egin adierazten duten sententziak
exception
when Salb1 | Salb2... => Sententziak;
when Salb3 => Sententziak;
...;
when others => Sententziak; --edozein salbuespen
--tratatu
end;
2/15/2016
22
Salbuespena erazagupen-atalean altxatzen bada, erazagupen bat

elaboratzen ari denean: ez da tratatuko bloke horren
maneiatzailean, deitzailearenean baino
zatitu1.adb: programaren logikan sartu

salbuespenezko kasua
Ez litzateke logikoa bloke beraren maneiatzailean tratatzea, ezin baita

ziurtatu aldagaiak-eta behar bezala elaboratuta daudenik (horretan ari
zela gertatu baita errorea!).
zatitu2.adb: salbuespen aurredefinitua tratatu

zatitu3.adb: salbuespena erazagutu eta tratatu
zatitu4.adb: salbuespena erazagupen-atalean
altxatzen denean
<salbuespen-izena> : exception;
Salbuespenak sententzia-atal arruntetik

kanpo gertatzen direnean... (Ada)
Adibideak
2/15/2016
Erazagupena
Salbuespen aurredefinitua
Programatzaileak definitutako salbuespena
Salbuespenak Adan
Salbuespena maneiatzailean gertatzen bada: deitzailearen

salbuespen-maneiatzaileari emango zaio kontrola
(salbuespena "altxaturik")
23
2/15/2016
24
Adibidea
Salbuespenak Javan
procedure P is
Errorea : exception;
function F return Natural is
begin
--...
end F;
function Q return Natural is
N : Natural := F; --demagun F-k Errorea ematen duela (adibidea)
begin
--...
exception
when Errorea => --Q-ren salbuespen-maneiatzailea
end Q;
begin
Q; --...
hemen maneiatuko
exception
when Errorea => --P-ren salbuespen-maneiatzailea
end P;
2/15/2016
da
25
Javan ere berdintsu tratatzen ahal dira

salbuespenak.
Programa baten exekuzioan errorea
gertatutakoan, errorea detektatzen duen kodeak
salbuespena jaurtitzen du (sorrarazten du) eta,
gero, errorea harrapatu (tratatu) egiten da.
Salbuespenak Exception klasekoak edo
haren azpiklaseren batekoak dira.
2/15/2016
26
Salbuespenak Javan:
erazagutu, sorrarazi eta tratatu
Programatzaileak definitutako salbuespenak erazagutu, sorrarazi eta tratatu
egin behar dira. Gainera, metodo batek salbuespen bat sorraraz badezake baina
tratatzen ez badu, esplizituki aitortu behar du hala dela (arriskuaz ohartarazi).
Salbuespena erazagutu:
Salbuespenak ere klaseak dira: Exception-en ume, normalean.
Nola?
public class ListaBeterik extends Exception {...}
Salbuespenaren arriskuaz ohartarazi:

Non? Metodo baten erazagupenean, sententzia-blokearen aurretik (throws
klausula).
Nola? public void irakurri() throws IOException {...}
Salbuespena sorrarazi (edo jaurti, bota):

Non? Sententzia-atalean (throw sententziaren bidez)
Nola? throw new ListaBeterik();
Salbuespena tratatu, maneiatu:

Non? try bloke baten catch atalean.
2/15/2016
27
2/15/2016
28
Salbuespenak Javan:
try-catch-finally blokeak
Salbuespenak Javan:
try-catch-finally blokeak
try {//saiatu sententzia hauek exekutatzen:

sententziak;
[throw new Salb*();]
sententziak;
} catch (Salb1 e) {//Salb1 klaseko salbuespena harrapatu (tratatu)
sententziak;
} catch (Salb2 e) {//Salb2 klaseko salbuespena harrapatu (tratatu)
sententziak;
} catch (Exception e) {//edozein salbuespen harrapatu
sententziak;
} finally {//edozein kasutan, exekutatu:
sententziak;
}
2/15/2016
29
Programa batek harrapatzen ahal ditu salbuespenak try,

catch eta finally blokeez baliatuz
try blokea: salbuespena gerta litekeen sententziak biltzen dituen blokea.
catch blokea (salbuespen-maneiatzailea): salbuespen-klase jakin bat
tratatzen duen sententzia-blokea.
finally blokea: beti, errorea gertatzen denean nahiz gertatzen ez
denean, exekutatzen den sententzia-blokea: fitxategiak itxi, garbiketalanak, lerro bat aurrera egin sarreran...
try batean gutxienez catch bloke bat jarri behar da; hainbat
catch jar daitezke, salbuespen desberdinak tratatzeko; azkenik,
finally bloke bat ere ager daiteke.
2/15/2016
Salbuespenak Javan: adibidea
30
Adibidea
Metodo-erazagupenetan: aitortu zer salbuespen "jaurti" dezakeen (eta ez tratatu):
try {//listako lehen zatikia hartu handientzat
public void writeList() throws IOException,

ArrayIndexOutOfBoundsException {...}
zatikiHandiena = ZatikiListaEMA.zatikiaPosizioan(0);
} catch (ZatikiListaEMA.ZatikirikEzPosizioHorretan e) {
Metodoari deitzen zaionean, aurreikusi errorea:
System.err.println(e);
try {//...;
writeList();
0. posizioko zatikia eskuratu nahi da listatik

Zer gertatzen da existitzen ez bada?
//...; }
catch (ArrayIndexOutOfBoundsException e) {
System.err.println
("Array-aren mugak gainditu dira: " + e.getMessage());
ZatikiListaEMA klaseko zatikiaPosizioan metodoak

ZatikirikEzPosizioHorretan salbuespena jaurtiko du
}
catch (IOException e) {
Programa-zati honetan aurreikusi da gerta litekeena, eta

erantzun bat ematen da (errore-mezua inprimatzen da)
System.err.println("S/I-ko errorea: " + e.getMessage());

}
2/15/2016
31
2/15/2016
32
Adibidea
Metodologia pixka bat
Hona hemen salbuespen-klasearen erazagupena, ZatikiListaEMA klasean
Nola erabili salbuespenak?
public static class ZatikirikEzPosizioHorretan
Ez erabili goto inplizituak egiteko.
extends Exception {
public ZatikirikEzPosizioHorretan(String s) {super(s);}
Abstrakzioen diseinuan eta erabileran:
Identifikatu DMA eta EMAen eragiketetan gerta daitezkeen

errore-egoerak
Eragiketon espezifikazioan, zehaztu zer salbuespen sorraraz
daitekeen eta noiz (abstrakzioaren zehaztapenaren parte
garrantzitsua, emaitza eta parametroen mota bezalaxe)
Programa bezeroetan, salbuespenok aurreikusi eta tratatu
Eta jaurtitzea, zatikiaPosizioan metodoan:

if (pos < 0 || pos > KOP_MAX-1) {
throw new ZatikirikEzPosizioHorretan
("Posizioak 0 eta " + (KOP_MAX-1) + "-en artean behar du");
} else if (pos > zenbatZatiki-1) {
throw new
ZatikirikEzPosizioHorretan
("Listako azken zatikiaren posizioa " + (zenbatZatiki-1)
+ " da");
} else ...
2/15/2016
33
2/15/2016
Adibidea: Pila DMA-a
Adibidea: Pila DMA-a
-- Pila DMA-a (datu-abstrakzioa): pila motako objektuen klasea
package Pilak is
--...
function Gailurra (P : in Pila) return ... is
-- eragiketak
begin
--...
if pila hutsik dago then
function Gailurra (P : in Pila) return ...;
raise Pila_Hutsik;
--Sarrera: ...
else
--Irteera: ...
--...
--Salbuespenak: Pila_Hutsik, pilan osagairik ez baldin badago
end if;
end Gailurra;
--...
Pila_Beterik, Pila_Hutsik : exception;
private
--...
type Pila is ... -- motaren inplementazioa

end Pilak;
2/15/2016
34
end Pilak;
35
2/15/2016
programa bezeroaren ardura da, gero,

Gailurra funtzioari deitzen zaionean
errorea gerta daitekeela aurreikusi, eta
taxuz tratatzea:
when Pilak.Pila_Hutsik =>
--...
36
Adibidea: Zatiki DMA-a
Adibidea: Zatiki DMA-a
public class Zatiki {
// zati metodoa, inplementazio eta guzti

public Zatiki zati(Zatiki bestea) throws ZatiketaZerorekin {
// eremuak: ...
// salbuespenak
long z, i;
public class ZatiketaZerorekin extends Exception {
if (bestea.zenbakitzailea == 0) {
public ZatiketaZerorekin(String s) {super(s);}
throw new ZatiketaZerorekin("Ezin da zerorekin zatitu");
} else {
// metodoak...
//...
/**
* @param bestea
programa bezeroaren ardura da, gero, zati metodoari

deitzen zaionean errorea gerta daitekeela aurreikusi, eta taxuz
tratatzea:
try {
f.zati(g).idatzi();
} catch (Zatiki.ZatiketaZerorekin e) {
//e.printStackTrace();
System.out.println(e);
}
* @return zatikia / bestea (zatidura, sinplifikaturik)

* @throws ZatiketaZerorekin, bestea 0 bada
*/
public Zatiki zati(Zatiki bestea) throws ZatiketaZerorekin {...}
//...
2/15/2016
37
38
salbuespen-klaseak erazagutu
jaurti behar direnean jaurti
eta tratatu behar diren tokian tratatu (probaprogrametan, batik bat)
horrez gain, metodoen @exception (metodo barruan
jaurti eta tratatzen diren salbuespenen kasuan) eta
@throws (metodotik kanpo "ateratzen" diren
salbuespenenean) espezifikazio-oharrak ere bete behar
dira, behar bezala
zenbaki-lista dinamikoak, salbuespenekin

Lehen laborategian landutako
Zenbaki_Listak_Din paketean salbuespenak
erazagutu
Salbuespen horiek altxarazi, errore-egoerak
detektatutakoan
Proba-programan, salbuespenok tratatu (modu
desberdinetan)
Ariketa: salbuespenen tratamendua

gehitu zatikien ariketan
Adibideak
2/15/2016
2/15/2016
39
2/15/2016
40
Ada vs Java
Adako edozein sententzia-atal (begin...end) Javako try-catch bloke

"handi" baten parekotzat har daiteke, bukaeran beti idatz baitaiteke salbuespenmaneiatzaile bat (exception) hainbat when-ekin. Hala ere, Javako try batek
ematen duen lokaltasuna eta kontrola [declare]-begin-end bloke batez
lor daitezke.
public void m1 (...) {
//...
try {
//[erazagupenak]
//sententziak
} catch (...) {
//sententziak
} catch (...) {
//sententziak
}
//...
}
2/15/2016
procedure P1 (...) is
begin
--...
[declare
--erazagupenak]
begin
--sententziak
exception
when ... => --sententziak
when ... => --sententziak
end;
--...
exception
...
end P1;
41
Zer egin salbuespen bat gertatzen denean?

Bertan behera utzi unitatearen exekuzioa
Berriro saiatu eragiketa exekutatzen
Ordezko bide bat hartu, alternatiboa
Errorea sorrarazi duena "konpondu" eta segi
2/15/2016
42

Berriro saiatu eragiketa exekutatzen
Bertan behera utzi unitatearen exekuzioa

Normalean ez da ona: zerbait egin baliteke,
egin egin behar da!
Batzuetan ezin da ezer egin, eta, gehienez ere
mezu bat atera eta "duin" bukatzea baino ez
dago.
type Erantzun is (Gora, Behera, Ezkerrera, Eskuinera);

package Erantzun_SI is new Ada.Text_IO.Enumeration_IO (Erantzun);
Erab_Erantzuna : Erantzun;
--...
loop
begin
Ada.Text_IO.Put (">"); --prompt-a
Erantzun_SI.Get (Erab_Erantzuna);
Ada.Text_IO.Skip_Line;
exit; --begiztatik atera
exception
when Ada.Text_IO.Data_Error => erantzuna berriro eskatzeko sartu
end;
end loop;
2/15/2016
43
2/15/2016
44
Ordezko bide bat hartu, alternatiboa
Errorea sorrarazi duena "konpondu" eta

segi
begin
Ada.Text_IO.Open (...); -- gerta liteke Name_Error
-- fitxategia existitzen
-- ez bada
exception
when Ada.Text_IO.Name_Error =>
Ada.Text_IO.Create (...);
end;
2/15/2016
procedure P (K : in out Integer) is

E : exception;
begin
ekintza egiten saiatu
-- litekeena da hemen E altxatzea
exception
when E => K := K / 2;
saiatu berriro ekintza egiten
(dei errekurtsibo baten bitartez, adib.)
end P;
45
EXEKUZIO ERROREA
46
with Ada.Integer_Text_IO, Ada.Text_IO;

procedure Zatiketa is
function Zatitu(Z1,Z2:in Integer) return Integer is
begin
return Z1 / Z2 ;
end Zatitu;

begin
return Z1 / Z2 ;
Z2=0 constraint_error
end Zatitu;
EXEKUZIO ERROREA
Zenb1,Zenb2: Integer;
Emaitza: Integer;
Zenb1,Zenb2: Integer;
Emaitza: Integer;
begin
Ada.Text_IO.Put_Line(Sartu zenbaki bat:");
Ada.Integer_Text_IO.Get(Zenb1);
Ada.Text_IO.Put_Line("Sartu beste zenbaki bat:");
Emaitza:=Zatitu(Zenb1,Zenb2);
Ada.Integer_Text_IO.Put(Emaitza);
end Zatiketa;
a) Programaren beste kasu bat bezala tratatu

2/15/2016
2/15/2016
47
Programaren
kasu normal
gisa tratatzea
begin
if (Zenb2 = 0) then Ada.Text_IO.Put_Line(Zerorekin ezin da
zatitu!");
else Emaitza:=Zatitu(Zenb1,Zenb2);
end if;
end2/15/2016
Zatiketa;
48
b.1.) ADAn definitutako salbuespenak erabiliz

Begin
Adan definitutako
return Z1 / Z2 ;
-- salbuespena tratatu:
salbuespenak baliatu.
exception
I)aitari abisatu
when Constraint_error =>
Ada.Text_IO.Put_Line(Zeroarekin ezin da zatitu);
raise;
end Zatitu;
Zenb1,Zenb2,Emaitza: Integer;
begin
exception
when Constraint_error => null;
2/15/2016
end Zatiketa;
49
c) Programatzaileak definitutako salbuespenak

-- salbuespenaren erazagupena:
Zerorekin_zatitu: exception;
begin
if Z2 = 0 then
-- salbuespena aktibatu:
raise Zerorekin_zatitu;
else return Z1 / Z2 ;
end if;
-- salbuespena tratatu:
exception
when Zerorekin_zatitu =>
Ada.Text_IO.Put_Line(Zerorekin ezin da zatitu);
raise;
end Zatitu;
Salbuespen egoera
identifikatu, eta
horretaz informatu
deitzaileari.
Zenb1,Zenb2,Emaitza: Integer;
begin
exception
when Zeroarekin_zatitu => null;
2/15/2016
end Zatiketa;
51
b.2.) ADAn definitutako salbuespenak erabiliz

with Ada.Text_IO, Ada.Integer_Text_IO;
procedure Irakurri_eta_idatzi is
I: Integer;
Ondo_irakurria : Boolean := False;
procedure Irakurri_Zenb (I : out Integer) is
begin
Ada.Text_IO.Put_Line (Sartu zenbaki bat:);
Ada.Integer_Text_IO.Get(I);
Ondo_irakurria := True;
exception
when Data_Error => Ada.Text_IO.Skip_Line;
Ada.Text_IO.Put_Line (Ez da zenbaki bat);
end Irakurri_Zenb;
Adan definitutako
begin
while not Ondo_irakurria loop
salbuespenak baliatu.
Irakurri_zenb(I);
II) Egoera nolabait aldatu, eta
end loop;
Ada.Integer_Text_IO.Put (I);
berriz saiatu.
2/15/2016
50
end Irakurri_eta_idatzi;
4 gaia: Softwarearen
4.
p
berrerabilpena
Erreferentziak:
[Meyer, 99] 4. eta 10. kapituluak

[Booch, 94] 12. kapitulua
[Ellis, 91] 8. kapitulua
http://java.sun.com/docs/books/tutorial/java/generics/
Edukiak
Sarrera
Generikoak Adan
Erazagupena eta instantziazioa. Erabilera.
Parametro generikoak: mota-, azpiprograma- eta balioparametroak.
Ariketak
Generikoak Javan
Object klaseaz baliatuz.
Erazagupena. Instantziazioa eta erabilera aldagaia
erazagutzean.
erazagutzean
Mota-parametroak.
Ariketak
2016-04-04
PMOO: Generikotasuna
Sarrera
Helburua
Ez ibili beti gurpila asmatzen!
Hainbat aplikaziotan erabili ahal izango diren
software-osagaiak garatzea
Onurak
Produkzioa azkartu
Garapen- eta mantentze-kostuak txikitu
Programazio-maila abstraktuagoa lortu
Eraginkortasuna
Kalitatea hobetu
Kontsistentzia
Fidagarritasuna
2016-04-04
Sarrera
Arazoak
Ez da erraza erabilpen desberdinak izango dituzten
osagaiak garatzea.
Den-dena programatzeko joera dugu, eta ohitura
gutxi "apalera jotzeko" behar dugunaren bila.
Epe laburrerako kostuak:
Mantentzea Osagai berrerabilgarriek sendoak izan behar
dute
Biltegiratzea ("apalak" behar, osagaiok gordetzeko!)
Eskuratzea ((egun
g hor dugu
g amarauna,, Internet))
2016-04-04
Sarrera
Zer berrerabil daiteke?
Norberak egindako softwarea
Programazio-lengoaietako liburutegiek eskaintzen
duten funtzionalitatea
...
Software berrerabilgarria, generikoa:

Datu-egiturak: pilak, ilarak, bildumak...
Algoritmoak: ordenazioa, bilaketa...
Software-katalogoak:
2016-04-04
Booch-en Ada osagaiak
JGA: Generic Algorithms for Java
Sarrera
Generikoen zergatia:
Adibidez:
type Oso_Taula is array (1 .. 100) of Integer;
procedure Ordenatu_OT (T : in out Oso_Taula);
type Erreal_Taula
Erreal Taula is array (1 .. 100) of Float;
procedure Ordenatu_ET (T : in out Erreal_Taula);
Ariketa: egin azpiprograma bat, bi zenbaki errealen

balioak trukatzeko.
2016-04-04
Sarrera
Definizioa:
Helburu berdintsuko edo bereko eragiketak edo
paketeak orokortzeko txantiloi edo plantilla modukoak
dira programa-unitate generikoak.
Unitate g
generikoak p
parametrizatzen ahal dira:
parametro generikoak (txantiloiko "zuloak edo
hutsuneak").
Txantiloi horiek instantziatu egin behar dira behar
desberdinetara egokitzeko ("zuloak edo hutsuneak"
b t )
bete).
Orokortze hori gauzatzeko, molde desberdineko
parametro generikoak daude
daude.
2016-04-04
Unitate generikoak Adan.

Erazagupena.
Adan paketeak eta azpiprogramak izan
daitezke generiko.
g
Generikoen erazagupena Adan:
Nahikoa da generic hitza gehitzea, generikoa egin
nahi den edozein pakete edo azpiprogramaren
zehaztapenaren aurretik.
Parametro generikoak generic hitzaren eta pakete
edo azpiprogramaren goiburukoaren artean definitzen
dira.
2016-04-04
Adibidea
Zehaztapena:
generic
type Edozein_Mota is private; --parametro generikoa
procedure Trukatu (X, Y : in out Edozein_Mota);
Inplementazioa:
procedure Trukatu (X, Y : in out Edozein_Mota) is
Lag : Edozein_Mota;
begin
Lag := X;
X :=
: Y;
Y := Lag;
end Trukatu;
2016-04-04
Instantziazioa
Generikoen instantziazioa:
Txantiloi generiko orokorretik, ale edo instantzia
konkretu bat lortu, zeinetan parametro generikoek
beren balioa (mota bat izan daiteke, adibidez) hartu
baitute.
Instantzian,
I
i
b
beraz,
parametro errealek
l kh
hartuko
k d
dute,
azpiprograma edo pakete generikoaren
erazagupenean parametro generikoek zuten tokia
tokia.
Adibidez (instantziazioa):
procedure Osoak_Trukatu is new Trukatu (Edozein_Mota => Integer);
procedure Errealak_Trukatu is new Trukatu (Edozein_Mota => Float);
2016-04-04
10
Instantziazioa
Generikoen instantziazioa:
Non egin daiteke instantziazio bat? Azpiprograma
edo pakete bat erazagut daitekeen lekuan (instantzia
p hau bertan erazagutuko
g
balitz bezala
edo "kopia"
baita).
Generikoak ikusgai
g egon
g beharko du p
puntu horretan,
noski.
Adibidez (instantziazioa):
with Trukatu;
procedure Proba is
procedure Osoak_Trukatu
Osoak Trukatu is new Trukatu (Edozein_Mota
(Edozein Mota =>
> Integer);
I, J : Integer;
begin
--
Osoak Trukatu (I, J);
Osoak_Trukatu
--
2016-04-04
11
Parametro generikoak Adan
Mota parametro generikoak

Mota-parametro
Balio- eta objektu-parametro generikoak
Azpiprograma-parametro generikoak
Pakete-parametro generikoak
Parametrorik gabeko generikoak
2016-04-04
12
Mota-parametro
p
g
generikoak
Softwarea parametrizatu, datu-moten arabera:
algoritmo edo pakete bera mota desberdineko
objektuekin erabiltzeko aukera
Datu-abstrakzioen
D t b t k i
b
berrerabilgarritasunaren
bil
it
funtsa
Mota-parametro generikoak definitzerakoan,
honako hauek ari gara zehazten:
Instantziazioan onartuko diren mota konkretuak
Mota horretako objektuekin egin daitezkeen
eragiketak (generikoaren inplementazioan).
2016-04-04
13
Mota-parametro
p
g
generikoak
Mota-parametro generiko formalak definitzeko moduak:
type T is limited private;
Instantziazioan: edozein mota onartzen du
garapenean,
p
T motako objektuekin:
j
ezin da eragiketarik
g
Generikoaren g
egin
type T is private;
Instantziazioan: edozein mota ez-mugatu
Generikoaren
G
ik
garapenean, T motako
t k objektuekin:
bj kt ki asignazioa,
i
i
= eta
t
/=, besterik ez
type T is (<>);
Instantziazioan: edozein mota diskretu (enumeratuak
(enumeratuak, osoak,
osoak
karaktereak, boolearrak)
Generikoaren garapenean, T motako objektuekin: mota diskretuen
eragiketak: pos, val, succ, first, <
type T is range <>;
Instantziazioan: edozein mota oso (Integer, Natural...)
Generikoaren garapenean, T motako objektuekin: osoen eragiketak
(aritmetikoak )
(aritmetikoak...)
2016-04-04
14
Mota-parametro
Mota
parametro generikoak
type T is digits <>;
Instantziazioan: koma higikorreko edozein mota (errealak)
Generikoaren garapenean, T motako objektuekin: errealen
eragiketak (aritmetikoak
(aritmetikoak, erlazionalak...)
erlazionalak )
type T is access P;
Instantziazioan: edozein erakusle mota, P motako objektuak
erakusten baldin baditu
Generikoaren garapenean, T motako objektuekin: erakusleen
eragiketak: asignazioa, new
type T is array (Indize) of Osagai;
Instantziazioan: edozein array, indizea Indize motakoa eta
osagaiak Osagai motakoak baldin badira
Generikoaren garapenean, T motako objektuekin: arrayen
eragiketak: indexazioa, agregatuak
2016-04-04
15
Mota-parametro
p
g
generikoak: hierarkia
limited private
private
(<>)
access
digits <>
array
range <>
Zenbat eta gorago hierarkian:

Eragiketa gutxiago eskueran, generikoa programatzeko orduan
Mota
M t gehiagorekin
hi
ki instantziatzeko
i t t i t k aukera
k
Araua: ahal den orokorrena hartu parametro

generikotzat
2016-04-04
16
Mota-parametro
p
g
generikoak
Parametro generiko formala instantziazioan
parametro
t erreall bateragarri
b t
ib
batekin
t ki ((mota
t
batekin!) ezkondu behar da
Mota-parametro generikoak erlazionatuta egon
daitezke, bat beste baten menpeko izan
Adibidez:
Generikoaren definizioa:
generic
type Osagai is (<>);
type Bektore is array (Integer range <>) of Osagai;
procedure Ordenatu (Taula : in out Bektore);
2016-04-04
17
Mota-parametro
p
g
generikoak
Generikoaren instantziazioa:
type Kolore is (Beltza, Berdea, Gorria, Urdina, Zuria);
type Kolore_Taula is array (Integer range <>) of Kolore;
-- instantziazioa:
procedure Ordenatu_Kolore_Taula is new
Ordenatu (Osagai => Kolore,
Bektore => Kolore_Taula);
Instantziaren erabilpena (deia):

procedure Proba is
Kolore_Taula_Bat : Kolore_Taula (1 .. 100);
-- tamaina mugatu behar erazagupenean
begin
--
Ordenatu_Kolore_Taula (Kolore_Taula_Bat);
--
end;
2016-04-04
18
Beste adibide bat:

Pilak pakete orokorra
Zehaztapena:
generic
type Osagai is private; --mota-parametro generikoa
package Pilak is
procedure Sortu_Hutsa (P : out Pila);
procedure Pilaratu (
p
(P1 : in out Pila;
; X : in Osagai);
g );
procedure Despilatu (P1 : in out Pila; X : out Osagai);
function Berdin (P1, P2: in Pila) return Boolean;
procedure Kopiatu (P1: out Pila; P2: in Pila);
--...
private
type Nodo;
type Pila is access Nodo;
type Nodo is record
Info : Osagai;
Hurrengoa : Pila;
end record;
end Pilak;
Inplementazioa:
--Osagai motako objektuak erabili ahal izango ditugu hemen, eragiketen inplementazioan
end
d Pilak;
il k
Instantziazio batzuk:
package Karaktere_Pilak is new Pilak (Osagai => Character);
package Oso_Pilak is new Pilak (Osagai => Integer);
...
with Ikasleak;
package Ikasle_Pilak is new Pilak (Osagai => Ikasleak.Ikasle);
2016-04-04
19
Arazo bat...
bat
egia ote edozein mota
onartuko dela?
generic
type Edozein_Mota is private; --parametro generikoa
procedure Osoak_Trukatu is new Trukatu (Edozein_Mota => Integer);

procedure Errealak_Trukatu is new Trukatu (Edozein_Mota => Float);
H
Honaino,
i
arazorik
ik ez. B
Baina...
i
h
hau egin
i nahi
hi b
badugu
d
((Ikasle_Pilak.Pila
k l
il k il mota
t limited
li i d private
i
i
izanik):
ik)
procedure Ikasle_Pilak_Trukatu is new Trukatu (Edozein_Mota => Ikasle_Pilak.Pila);
Zuzena al da goiko instantziazio hori? Ez!
parametro generikoa limited private gisa erazagutu behar dugu
generikoaren inplementazioan ezingo dugu asignaziorik egin: => eragiketa-parametro generikoak
soluzioa
generic
type Edozein_Mota is limited private; --mota-parametro generikoa
with procedure Kopiatu (X : out Edozein_Mota; Y : in Edozein_Mota);
--azpiprograma-parametro generikoa
procedure Trukatu (
p
(X,
, Y : in out Edozein_Mota);
);
2016-04-04
20
Azpiprograma-parametro
pp g
p
g
generikoak
Parametro generiko formala instantziazioan
parametro
t erreall bateragarri
b t
ib
batekin
t ki
(azpiprograma batekin!) ezkondu behar da
Zehaztapena:
generic
type
yp Edozein_Mota is limited p
private;
; --mota-parametro
p
g
generikoa
--azpiprograma-parametro generikoa:
with procedure Kopiatu (X : out Edozein_Mota; Y : in Edozein_Mota);
Inplementazioa:
procedure Trukatu (X, Y : in out Edozein_Mota) is
Lag
ag : Edozein
do e _Mota;
ota;
begin
Kopiatu (Lag, X);
-- Lag := X
Kopiatu (X, Y);
-- X := Y
Kopiatu
p
(Y,
(
, Lag);
g);
-- Y := Lag
g
end Trukatu;
2016-04-04
21
Instantziazioa (adibideak)
E
Emanik
ik Autoak
k paketea:
k t
package Autoak is
type Auto is limited private;
--...
procedure Kopiatu (A1 : out Auto; A2 : in Auto);
-- ...
private
end Autoak;
hona hemen Trukatu prozedura generikoaren instantziazio bat:

procedure Autoak_Trukatu is new Trukatu
p
(Edozein_Mota => Autoak.Auto,
Kopiatu => Autoak.Kopiatu);
2016-04-04
22
E
Emanik
ik Pilak
il k pakete
k t generikoaren
ik
i t t i hau:
instantzia
h
with Ikasleak;
package Ikasle_Pilak is new Pilak
(Osagai => Ikasleak.Ikasle);
hona hemen Trukatu prozedura generikoaren instantziazio bat:

procedure Ikasle_Pilak_Trukatu
Ikasle Pilak Trukatu is new Trukatu
(Edozein_Mota => Ikasle_Pilak.Pila,
Kopiatu => Ikasle_Pilak.Kopiatu);
2016-04-04
23
Beste adibide bat: osagaiak

ordenagarriak direnean...
generic
i
type Osagai is private;
orain ez da mota
diskretua!
t pe Bektore
type
Bekto e is array
a a (Integer
(Intege range
ange <>) of Osagai;
Osagai
Posible ote da hau behar bezala inplementatzea? Non

dago arazoa? Zein da osagaien arteko ordenazioordenazio
irizpidea? Nola jakin osagai bat beste bat baino
t agoa edo "handiagoa"
a d agoa de
dela,
a, edo, beste
bestela
a esa
esanda,
da,
"txikiagoa"
osagai batek beste baten aurretik behar duela bektore
ordenatuan?
2016-04-04
24
Beste adibide bat: osagaiak

ordenagarriak direnean...
generic
i
yp Bektore is array
y (
(Integer
g
range
g <>)
) of Osagai;
g ;
type
with function Aurretik (E1, E2 : in Osagai) return Boolean;
Unitate generikoari ordenazio-irizpidea

ordenazio irizpidea emateko
modurik egokiena: azpiprograma-parametro baten
bitartez.
Beste edozein parametro generikoren kasuan
parametro hauei p
parametro errealak egokitu
g
bezala, p
behar zaizkie instantziazioan, jakina.
2016-04-04
25
Emanik, Ikasleak paketean:
function Nota_Txikiagoa (I1, I2 : in Ikasle)
return Boolean;
eta honako mota hau ikusgai,

g orobat ((with Ikasleak.Ikasle),
) instantziazioa egin
g
behar denean:
type Ikasle_Taula is
array (Positive range 1 .. 200) of Ikasleak.Ikasle;
hona hemen Ordenatu prozedura generikoaren instantziazio bat :

with Ordenatu, Ikasleak;
procedure Ikasle_Taula_Ordenatu is new Ordenatu
(Osagai => Ikasleak.Ikasle,
Bektore => Ikasle_Taula,
Aurretik => Ikasleak.Nota_Txikiagoa);
Eta hona prozedura beraren beste instantziazio bat,

bat zenbaki errealekin :
procedure Erreal_Taula_Ordenatu is new Ordenatu
(Osagai => Float, --zenbaki erreala, Standard paketean definitua
Bektore => Erreal_Taula, --aurrez definitua, noski
Aurretik => "<"); --Standard paketeko eragiketa
2016-04-04
26
Balio parametro generikoak

Balio-parametro
generic
Kopuru_Max : in Positive;
--...
package K ...
--...
end K;
U
Unitate
it t generikoari
ik i b
balio
li b
batt emateko
t k erabiltzen
bilt
di
dira.
Balioa konstantetzat hartzen da, generikoaren barruan.
Parametro
P
t errealak
l k parametro
t formal
f
l generikoaren
ik
mota
t
bereko espresioa izan behar du.
Normalean muga konstanteak zehazteko erabiltzen dira
dira.
2016-04-04
27
Balio parametroak: adibidea

Balio-parametroak:
generic
i
Max : in Positive;
package
pac
age Ilarak
a a is
s
type Ilara is limited private;
--eragiketak:
procedure Hutsa_Sortu (I : out Ilara);
function ...
private
subtype Ind_1_Max is Integer range 1 .. Max;
s bt pe Ind
subtype
Ind_0_Max
0 Ma is Intege
Integer range
ange 0 .. Max;
Ma
type Taula is array (Ind_1_Max) of Osagai;
type Ilara is record
;
T : Taula;
Zenbat : Ind_0_Max;
end record;
end Ilarak;
2016-04-04
28
Balio parametroak: adibidea

Balio-parametroak:
I
Instantziazioa:
i i
package Mila_Karaktereko_Ilarak is new Ilarak
(Osagai => Character,
Max => 1000);
edo (beste bat):

package Berrogeitahamar_Zenbakiko_Ilarak is new Ilarak
(Osagai => Integer,
Max => 50);
Erabilera:
KI : Mila_Karaktereko_Ilarak.Ilara;
Mila_Karaktereko_Ilarak.Hutsa_Sortu (KI);
-- ...
2016-04-04
29
Balio-parametroak:
p
beste adibide bat
generic
i
Lehena, Azkena: in Character;
function Tartean (S : in String) return Boolean;
--Sarrera: S string-a
--Irteera: True, S string-eko karaktere guztiak Lehena-ren
-eta Azkena-ren artean baldin badaude (ASCII
-karaktere-multzoan); False bestela
Eragina: S string
string-eko
eko karaktere guztiak emandako
--Eragina:
-tartean daudenetz aztertzen du
function Tartean (S : in String) return Boolean
b i
begin
for I in S'Range loop
if S (I) not in Lehena .. Azkena then
return False;
end if;
end loop;
return True;
end Tartean;
2016-04-04
is
Egin orain proba-programatxo bat: 80

karaktereko lerro bat irakurri, eta aztertu ea
karaktere guztiak maiuskula diren, edo
minuskula, edo denak digitu...
30
Balio-parametroak:
p
beste adibide bat
with
ith Tartean,
T t
Ad T t IO
Ada.Text_IO;
procedure Proba is
Lerroa : String (1 .. 80);
N : Natural;
Tartean
funtzioaren
instantziazioak:
funtzio-familia bat
osatzen dute
function Denak_Maiuskula is new Tartean ('A', 'Z');

function Denak_Minuskula is new Tartean ('a', 'z');
function Denak_Zifra is new Tartean ('0', '9');
begin
Ada.Text_IO.Get_Line (Lerroa, N);
if Denak
Denak_Maiuskula
Maiuskula (Lerroa (1 .. N)) then
--...
if Denak_Minuskula (Lerroa (1 .. N)) then
--...
if Denak_Zifra
Denak Zifra (Lerroa (1 .. N)) then
--...
end Proba;
2016-04-04
31
Hedagarritasuna
generikoak erabiliz
generic
package
k
Li
Listak
t k i
is
type Lista is limited private;
procedure Hutsa_Sortu (L : out Lista);
procedure Erantsi_B
Erantsi B (L : in out Lista; E : in Osagai);
--...
private
type Nodo;
type Lista is access Nodo;
type Nodo is
record
Info : Osagai;
Hurrengoa : Lista;
Listak pakete
generikoa (DMA),
dinamikoki
inplementatua
end record;
end Listak;
2016-04-04
35
Hedagarritasuna
generikoak erabiliz
generic
type Ilara_Osagai is private;
package Ilara is
procedure Hutsa_Sortu;
procedure Ilararatu (E : in Ilara_Osagai);
--...
end Ilara;
with Listak;
package body Ilara is
package
p
g Ilara_Listak is new Listak (Osagai
g
=> Ilara_Osagai);
g
Q : Ilara_Listak.Lista; --ilara objektu kapsulatua
procedure Hutsa_Sortu is
Ilara pakete
begin
generikoa (EMA),
Ilara Listak Hutsa Sortu (Q);
Ilara_Listak.Hutsa_Sortu
Listak generikoan
end Hutsa_Sortu;
oinarritua. Ariketa:
//...
inplementatu
end Ilara;
Ilararatu eragiketa
2016-04-04
36
Laburbilduz: generikoen erazagupena,

instantziazioa eta erabilera (Ada)
Unitate
U
i
generikoaren
ik
erazagupena: azpiprograma
i
edo
d pakete
k
orokor bat erazagutzea: txantiloi moduko bat, non bete gabe utzi
diren "zulo edo hutsune" batzuk (parametro generikoak: mota,
azpiprograma edo balioak).
Unitate generikoaren instantziazioa: azpiprograma edo pakete
"normal"
normal bat erazagutzea,
erazagutzea generikoaren ale edo instantzia berri bat
eratorriz (is new); instantziazioan "zuloak" bete egiten dira,
parametro formalen ordez errealak ezarriz.
I t t i
Instantziaren
erabilera:
bil
generikoaren
ik
iinstantzia
t t i unitate
it t normall b
batt
denez, hura da erabiltzen dena (azpiprograma edo pakete arrunt
baten gisan).
2016-04-04
38
Javan lehen ez zegoen generikorik:

Object klasea
Object klaseaz
kl
b
baliatuz
li t egindako
i d k unitateak
it t k ez di
dira
berez generikoak, baina motarekiko generikotasuna
simula daiteke honela.
honela
Object klasea: klase guztien arbasoa, klaseen
hierarkiako goi-goiko
goi goiko klasea
klasea.
Edozein klase Object-ekin bateragarria da (haren ume
baita),
ba
a), e
eta
a horretan
o ea o
oinarritzen
a
e da so
soluzio
u o hau.
au
Javan generikorik ez zegoenean, hauxe zen bidea
g
lortzeko.
motarekiko "generikotasuna"
2016-04-04
39
Pila (EMA): osagaiak

Object motakoak dira
public class PilaEmaArray
PilaEmaArra {
// Atributuak:
private static final int EDUKIERA = 100;
private static Object[] p = new Object[EDUKIERA]; //obj. kapsulatua
private
i t static
t ti int
i t muga = -1;
1
// Eraikitzailea (pribatua, hutsa):
private PilaEmaArray() {
}
// Eragiketak
public static int luzera() {
return (muga + 1);
}
public static boolean hutsaDago() {
return (muga < 0);
}
//...
2016-04-04
Object klaseko osagaiz

eratutako array-a
Oharra: PilaEmaArray
Oh
il
klase hau ez da generikoa
stricto sensu!
40
Pila (EMA): osagaiak

Object motakoak dira
//...
//
public static Object gailurra() {
return p[muga];
}
// Eragiketak:
public static void pilaratu (Object o){
p[++muga] = o;
}
public static Object despilatu() {
Object elem;
elem = p[muga];
p[muga--] = null;
return elem;
}
Object motako
parametroak eta emaitzak
erabiltzen dira metodoetan
2016-04-04
41
Pila (EMA): erabilera,

erabilera Integer klasearekin
public class Proba {
PilaEmaArray.pilaratu (new Integer(5));
Casting-a behar izaten da
emaitzak jasotzerakoan:
Pil E A
PilaEmaArray.pilaratu
il
t (new
(
I t
Integer(50));
(50))
adibidean,
dibid
Object motako
t k
emaitza Integer bihurtzeko
System.out.println ("Luzera: " + PilaEmaArray.luzera());
System.out.println ("Gailurra: " + PilaEmaArray.gailurra());
//pila hustu ahala, zenbakien batura kalkulatu:
Integer batura = 0; //batura metatzeko
Integer osagaia;
int luzera = PilaEmaArray.luzera();
for (int i = 0; i < luzera; i++) {
osagaia = (Integer)PilaEmaArray.despilatu(); //casting-a behar da!
batura += osagaia;
}
System.out.println("Batura: " + batura);
//...
2016-04-04
42
Pila (EMA): erabilera,

erabilera char motarekin
//...
//Beste adibide bat:
//pila bete, esaldi baten karaktereekin
St i
String
s = "Nik enara neraman amaren aranekin";
ki "
for (int i = 0; i < s.length(); i++) {
PilaEmaArray.pilaratu(s.charAt(i));
}
System.out.println("Luzera: " + PilaEmaArray.luzera());
//esaldia alderantziz idatzi, pilatik
//karaktereak banan-banan despilatuz
luzera = PilaEmaArray.luzera();
for (int i = 0; i < luzera; i++) {
System.out.print(PilaEmaArray.despilatu());
//Object klasearen toString() aplikatzen da hemen goian,
//eta horregatik ez da casting espliziturik behar
}
}
2016-04-04
43
Java: motarekiko generikotasuna

Javan (motarekiko) generikotasuna dago,
Java 1.5-etik aurrera.
Klaseak nahiz metodoak izan daitezke
generiko.
generiko
Klase edo metodo bat generiko izango da,
mota-parametro bat edo gehiago baldin
baditu.
2016-04-04
44
Generikoen erazagupena,
instantziazioa eta erabilera (Java)
Unitate
U
i
generikoaren
ik
erazagupena: metodo
d edo
d kl
klase orokor
k b
bat
erazagutzea: txantiloi moduko bat, non bete gabe utzi diren "zulo
edo hutsune" batzuk (parametro generikoak: motak).
Unitate generikoaren instantziazioa: metodo edo klase "normal" bat
erazagutzea, generikoaren ale edo instantzia berri bat eratorriz;
instantziazioan "zuloak"
zuloak bete egiten dira
dira, parametro formalen ordez
errealak ezarriz.
Instantziaren erabilera: generikoaren instantzia unitate normal bat
d
denez,
h
hura d
da erabiltzen
bilt
d
dena ((metodo
t d edo
d kl
klase arruntt b
baten
t
gisan).
Javan ez da beharrezkoa,, Adan bezala,, instantzia aurrez egitea
g
gero erabili ahal izateko: erabiltzeko unean bertan egiten da
instantziazioa.
2016-04-04
45
Adibidea: klase arruntak

package kaxak;
public class Zapata {
package kaxak;
public class ZapataKaxa {
private Zapata z;
public enum Kolore {

GORRIA, BELTZA, URDINA, MARROIA
}
public Zapata eman() {

return z;
}
public void jarri(Zapata pZapata) {
z = pZapata;
}
private int neurria;

private Kolore kolorea;
public Zapata(int n, Kolore k) {
neurria = n;
o o ea = k;
;
kolorea
}
...
//...
//
Zapata nireZapata = new Zapata(41, kaxak.Zapata.Kolore.BELTZA);
System.out.println
(nireZapata.getKolorea().toString() + " " +
nireZapata getNeurria());
nireZapata.getNeurria());
ZapataKaxa nireZapataKaxa = new ZapataKaxa();
nireZapataKaxa.jarri(nireZapata);
System out println(nireZapataKaxa eman() getKolorea());
System.out.println(nireZapataKaxa.eman().getKolorea());
//...
2016-04-04
klase arr
arruntak,
ntak
ez generikoak
erabilera
46
Klase generikoak
g
Era ag pena
Erazagupena:
<modifikatzaileak>* class <ident.> <T+> {}
T parametro generikoa ("zuloa edo hutsunea"): edozein klase (edo
interfaze) izan daiteke (ez mota primitibo bat).
package kaxak;
public class KaxaGeneriko <T> {
private T datua;
klase
generikoa
public T eman() {
return datua;
}
public void jarri(T x) {
datua = x;
}
public String toString () {
return datua.toString();
}
}
2016-04-04
Klase generikoak
47
instantziazioa eta
erabilera aldi berean:
"zuloa" betetzera
d
datorren
mota
zehaztu behar da
package kaxak;
public class KaxaGenProba {
Zapata nireZapata = new Zapata(41, kaxak.Zapata.Kolore.BELTZA);
System.out.println
(nireZapata.getKolorea().toString() + " " +
nireZapata.getNeurria());
KaxaGeneriko<Zapata> nireZapataKaxa = new KaxaGeneriko<Zapata>();

nireZapataKaxa.jarri(nireZapata);
System.out.println(nireZapataKaxa.eman().getKolorea());
//kaxa generikoen beste erabilera bat, Integer klasearekin orain:
KaxaGeneriko<Integer> nireIntegerKaxa = new KaxaGeneriko<Integer>();
nireIntegerKaxa.jarri(new
i I t
K
j
i(
Integer(1365));
I t
(1365))
System.out.println(nireIntegerKaxa.eman());
//...
nireIntegerKaxa.jarri(nireZapata); //hau ezin da egin, jakina!!!
}
2016-04-04
48
Klase generiko aurredefinituak: Vector

Vector klase
kl
generikoa
ik asko
k erabiltzen
bilt
da
d Javan,
J
bektoreekin
b kt
ki lan
l egiteko
it k
array-ek baino erosotasun handiagoa eskaintzen baitu:
public class Vector<E> ... {
public E elementAt(int index) {...}
// index posizioan dagoen osagaia itzultzen du
public
bli void
id add(E
dd(E obj)
bj) {
{...}
}
// bektorearen bukaeran eransten du obj osagaia (bektorearen tamaina handituz)
public void insertElementAt(E obj, int index) {...}
// obj osagaia txertatzen du bektoreko index posizioan,
// bektorea behar bezala egokituz
erabilera: "zuloa"
betetzera datorren mota
Zatiki da
public int size() {...}

// bektorearen osagai kopurua itzultzen du
//...
private Vector<Zatiki> zatikiBektorea;
zatikiBektorea = new Vector<Zatiki>();
zatikiBektorea.add(new Zatiki(3, 4));
2016-04-04
53
PilaGeneriko (DMA),
Vector klasean oinarritua
public void despilatu () throws PilaHutsik {
if (taula.size()
(taula size() == 0) {
throw new PilaHutsik("Pila hutsik dago");
} else {
taula.removeElementAt(taula.size() - 1);
}
}
public E gailurra() throws PilaHutsik {
if (taula.size() == 0) {
throw new PilaHutsik("Pila hutsik dago");
} else {
return taula.elementAt(taula.size()
(
() - 1);
);
}
}
public boolean berdin (PilaGeneriko<E> bestea) {
if (this.taula.size() != bestea.taula.size()) {
return false;
} else {
for (int i=0; i<this.taula.size(); i++) {
if (this.taula.elementAt(i) !=
bestea.taula.elementAt(i)) {
return false;
}
}
return true;
}
}
package pilaGenerikoak;
import java.util.*;
java util *;
public class PilaGeneriko<E> {
private Vector<E> taula; //bektorea
public static class PilaHutsik
extends Exception {
PilaHutsik(String s) {super(s);}
}
public
pub
c PilaGeneriko()
aGe e
o() {
taula = new Vector<E>();
}
public void hustu(){
()
taula.removeAllElements();
}
public void pilaratu (E elem) {
taula.add(elem);
}
2016-04-04
54
PilaGeneriko (DMA): erabilera

package pilaGenerikoak;
public class PilaGenProbatu {
Pil G
PilaGeneriko<Integer>
ik <I t
> p1
1 = new Pil
PilaGeneriko<Integer>();
G
ik <I t
>()
PilaGeneriko<Integer> p2 = new PilaGeneriko<Integer>();
PilaGeneriko<Double> p3 = new PilaGeneriko<Double>();
try {
p1.pilaratu(1);
System.out.println(p1.gailurra()) ;
p1.despilatu();
erabilera: "zuloa"
p1.pilaratu(2);
betetzera datozen motak:
//. . .
Integer Integer,
Integer,
Integer
p2.pilaratu(1);
2
1
p3.pilaratu (4.7);
Double
//. . .
if (p1.berdin(p2)) {
System out println("p1
System.out.println(
p1 eta p2 berdinak dira");
dira );
} else {
System.out.println("p1 eta p2 ezberdinak dira");
}
System.out.println(p1.gailurra()) ;
} catch (PilaGeneriko.PilaHutsik e) {
System.out.println(e.getMessage());
}
}
}
2016-04-04
55
Bukatzeko: generikotasuna eta UML

KarakterePila
-MAX
-taula
-gailurra
+hutsa sortu
+pilaratu
il
+despilatu
+gailurra
+berdin
+...
Klase arrunta: karaktere

motako parametroak
parametroak,
pilaren adierazpidean zein
metodoetan
2016-04-04
parametro generiko
formala (zuloa)
Osagai
PilaGeneriko
-MAX
-taula
-gailurra
+hutsa sortu
+pilaratu
+despilatu
+gailurra
+berdin
+...
Klase generikoa: Osagai

motako parametroak
parametroak,
pilaren adierazpidean zein
metodoetan
59
Bukatzeko: generikotasuna eta UML

Osagai
PilaGeneriko
-MAX
-taula
-gailurra
gailurra
+hutsa sortu
+pilaratu
+despilatu
despilatu
+gailurra
+berdin
+...
Pertsona parametro generiko

erreala, Osagai formalaren
"zuloa betetzera" datorrena
<<bind>> Osagai :: Pertsona

<<bind>> Osagai :: Integer
ZenbakiPila
PertsonaPila
PilaGeneriko moduluaren
instantzia (Integer
motarekin instantziatua)
2016-04-04
PilaGeneriko moduluaren
instantzia (Pertsona
motarekin instantziatua)
60
5 gaia: Objektuei Orientatutako

5.
og a a oa (OOP)
(OO )
Programazioa
Erreferentziak:
[Meyer, 99: 2., 8. eta 14. kap.]
[Cohen, 96]
Objektuei Orientatutako (edo

zuzendutako)
d k ) Programazioa
i
OOParen oinarrizko kontzeptuak.
Mota-hierarkiak
Mota
hierarkiak, mezu
mezu-trukea
trukea, herentzia
herentzia, polimorfismoa
polimorfismoa.
OOPa Javan.
Herentzia: Object klasea eta extends.
Polimorfismo dinamikoa: objektu baten klase estatikoa eta klase dinamikoa.
Klase abstraktuak eta interfazeak.
OOPa Adan.
OO
d .
Aurrekaria: Adako datu-mota eratorriak.
Datu-moten hedakuntza. Datu-mota etiketatuak. Liburutegi-hierarkia.
P li
Polimorfismo
fi
di
dinamikoa
ik
(di
(dispatching-a):
hi
) klase-mailako
kl
il k motak
t k eta
t mota
t
espezifikoak.
Klase abstraktuak eta interfazeak.
2016-05-05
PMOO: Objektuei Orientatutako Programazioa (OOP)
H lb
Helburu
nagusiak
i k
Objektuei orientatutako programazioaren

oinarriak aurkeztea: klaseak, objektuak,
herentzia,, mezu-trukea...
Aurreko
k gaietan
i
ikusitako
ik i k kontzeptuekin
k
ki lotzea:
l
modulartasuna, informazio-ezkutatzea,
berrerabilpena...
2016-05-05
OOP
OOParen
oinarrizko
i
i k ezaugarriak
i k
Datu- eta objektu-abstrakzioak (DMA/EMA):

objektuetan
bj k
oinarritutako
i
i k programazioa
i
Motak eta objektuak beren eragiketekin batera kapsulatu:

moduluak
d l k
Datu-motaren eta eragiketen inplementazioa ezkutatu
Informazioa ezkutatzea ondo dago, baina konpartitu

ere egin behar da
2016-05-05
Objektu-mota desberdinek dituzten antzekotasunak

aprobetxatu
Kl
Klaseak
k eta objektuak
bj k k
Klasea
Datu-mota baten inplementazioa da

Datu-egitura
g
bat zehazten (baina
(
ezkutatzen)) du,,
dagozkion eragiketekin
Estatikoa da ((ez da aldatzen exekuzioan))
Eskaintzen dituen eragiketen interfaze publikoa du
(espezifikazioa); eragiketa horien inplementazioa
ezkutatu egiten da
Eragiketei metodo esan ohi zaie OOPan
2016-05-05
Kl
Klaseak
k eta objektuak
bj k k
Objektua
Izaera propioa (balioa, egoera) duen entitatea.

Exekuzio garaian sortzen den entitate dinamikoa.
Nola sortzen da? Normalean, klase baten instantzia izan ohi
da.
Instantziak eta eraikuntza
2016-05-05
Klase batetik objektu edo instantzia bat sortzea: eraikuntza.

Objektu bat klase baten instantzia denez, klase horren
atributu eta eragiketak izango ditu.
Kl
Klaseak
k eta objektuak
bj k k
Jokalari klasea
Jokalariak.Jokalari mota
Jokalari j1 = new Jokalari();

Jokalari j2 = new Jokalari();
J1 : Jokalariak.Jokalari;
J2 : Jokalariak.Jokalari;
objektuak, instantziak
Nolakoak dira j1 Jokalari klaseko edo J1 Jokalariak.Jokalari motako
objektuak? Klase edo mota jakin batekoak izateak atributu eta eragiketa batzuk
egokitzen dizkie:
Atributuak:
Eragiketa edo metodoak:
Klasea
Mota
NA: 23322332Z
izena: Hodei
helbidea:
...
eraikitzailea
NA-a lortu
izena lortu
helbidea lortu
...
Objektua
Aldagaia
2016-05-05
Klase-hierarkiak eta objektuak

Adibidez:
Zakur
- azalaren kolorea
- begien kolorea
- altuera
+ jan
+ zaunka egin
San Bernardo
At k
Artzakur
+ artaldea zaindu
Xarpax
...
Bulldog
- arriskutsua
Pluto
...
+ zaunka egin
Kl
Klase-hierarkiak
hi
ki k eta objektuak
bj k k
Adibidearekin jarraituz:
Zakur klasea
Atributuak: azalaren kolorea, begien kolorea, altuera...
Metodoak: jan, zaunka egin...
Artzakur klasea
Zakur klase gurasotik atributu eta metodoak heredatzen ditu
artaldea zaindu eragiketa du, gainera (heredatuez gain)
San Bernardo klasea

zaunka egin eragiketa birdefinitzen du: zaunka handia, indartsua egiten du San Bernardo batek
Bulldog klasea
arriskutsua atributua du,
du gainera (heredatuez gain)
Xarpax objektua, Artzakur klasearen instantzia

Artzakur klasearen atributu eta metodo guztiak izango ditu
Eta,
Eta beraz,
beraz bai Zakur klasearenak ere
2016-05-05
Herentzia
is-a erlazioaren bidez eratzen dira klase-hierarkiak; horretan

oinarritzen da herentzia
baldin B is-a A, orduan B-k du eta

egin dezake A-k duen eta
egin dezakeen guztia
Adibid
Adibidez:
Artzakur is-a Zakur

Artzakur klaseak Zakur
klasearen atributu eta eragiketak
heredatzen ditu
Zakur
- azalaren kolorea
- begien
b i kolorea
k l
- altuera
+ jjan
+ zaunka egin
is-a
is
a
Artzakur
+ artaldea zaindu
2016-05-05
10
Herentzia
Espezializazioa:
Birdefinizioa:
Klase
l
batek
b k bere
b klase
kl
gurasoa espezializatzen
l
d bere
du,
b
metodo eta atributu propioekin
Heredatutako edozein eragiketa birdefini edo berridatz

daiteke klase ume batean
Klase hierarkia:
Klase-hierarkia:
2016-05-05
Klaseok osatutako zuhaitzari esaten zaio klase-hierarkia
11
Mezu trukearen metafora

Mezu-trukearen
Objektuak bata bestearekin komunikatzeko modua dira

mezuakk (eragiketen,
(
ik t metodoen
t d
exekuzioa
k i baino
b i ez da!)
d !)
Objektu batek (O1) beste objektu bati (O2) mezu bat
bidaltzen dio (zerbitzu bat eskatzen dio); bigarren
objektuak (O2-k) erantzun egingo dio (zerbitzua
emango dio)
Metodoei deia eginez pasatzen dira mezuak
(programazio-lengoaiaren arabera aldatzen da modua eta
sintaxia)
2016-05-05
12
M
Mezu-trukearen
k
metafora
f
Objektuak beren artean mezuak trukatuz
komunikatzen dira
Objektu igorlea
Mezua
Objektu jasotzailea
Erantzuna
Jasotzen duten mezuaren araberako portaera

(metodoa) dute objektuek
Bi objektuk erantzun desberdina eman diezaiokete
mezu "berari": ppolimorfismoa
2016-05-05
13
M
Mezu-trukea:
k adibidea
dibid
package Ikasleak is
type Ikasle is private;
procedure Eraiki (
p
(Ikaslea : out Ikasle; S : in String);
g)
procedure Adina_Aldatu (Ikaslea : in out Ikasle; A : in Positive);
--...
end Ikasleak;
with Ikasleak;
procedure
d
N
Nagusia
i is
i
I1 : Ikasleak.Ikasle;
A : Positive;
begin
--...
Ikasleak.Eraiki (I1, "Ur",);
Ikasleak.Adina_Aldatu (I1, 35);
--...
endd Nagusia;
N
i
2016-05-05
Instantzia: Ikasle motako I1

objektua sortzen da
Mezuaren jasotzailea: I1
Mezua: Adina_Aldatu
Parametroak: 35
14
M
Mezu-trukea:
k adibidea
dibid
public class Ikasle {
private String izena;
private int adina;
p
public Ikasle (String s) {...};
public void setAdina (int a){...};
//...
}
public static void main (...) {

Ikasle i1 = new Ikasle("Ur");
int a;
//...
i1.setAdina (35);
//...
}
2016-05-05
I t t i Ikasle motako
Instantzia:
t k i1
objektua sortzen da
Mezuaren jasotzailea: i1
Mezua: setAdina
Parametroak: 35
15
Polimorfismoa eta
lotura dinamikoa
Polimorfismoa:
Klase desberdinetako objektuek mezu "berari"

berari erantzuteko duten gaitasuna
Klase desberdinetan izen bereko metodoak egon daitezke (birdefinizioari
esker); objektuaren klasearen arabera, metodo bat edo beste bat
exekutatuko da
Lotura dinamikoa:
2016-05-05
O objektua
bj kt A klasekoa
kl k izan
i
daiteke
d it k (estatikoki
( t tik ki definitua),
d fi it ) baina
b i dinamikoki
di
ik ki
beste B klase batekoa gertatu exekuzioan
Dinamikoki esleitutako B klasearen pportaera hartuko luke O objektuak
j
exekuzioan
16
Polimorfismoa eta
lotura dinamikoa
Irudi
- x, y (koordenatuak)
Puntu
Zirkulu
- erradioa
Karratu
- aldea
Non kokatuko zenuke azalera eragiketa polimorfikoa?

2016-05-05
17
Polimorfismoa eta
lotura dinamikoa
Irudi
(
)
- x,, y (koordenatuak)
+ azalera 0.0
Puntu
Zirkulu
- erradioa
+ azalera
Karratu
- aldea
+ azalera
Zer inplementazio emango diogu goiko klaseko azalera eragiketari?

Demagun, oraingoz, 0.0 itzultzen duela, eta, beraz, Puntu klasean birdefinitu
beharrik ez dago.
dago Baina ez dirudi oso soluzio ona...
ona
2016-05-05
18
Polimorfismoa eta
lotura dinamikoa
Demagun irudi-lista bat daukagula, eta listako irudi guztien
azaleren batura kalkulatu nahi dugula:
azalera_osoa : float <- 0.0

...
for each irudia in irudi_lista loop
azalera_osoa <- azalera_osoa + azalera (irudia)
end loop;
azalera eragiketa hori, zein da? Zirkuluena? Karratuena?

jakin al daiteke, konpilazio-denboran?
exekuzio denboran ebatziko da: horri esaten zaio lotura
exekuzio-denboran
dinamiko edo berantiarra (dispatching-a)
2016-05-05
19
Java, objektuei zuzenduriko

programazio-lengoaia
i l
i
Klaseak
Eremuak: oinarrizko motetako aldagaiak eta objektu-aldagaiak.

Metodoak: eragiketak.
Objektuak: klaseen instantzia.

Ikusgaitasuna eta atzipen-kontrola
atzipen kontrola (modifikatzaileak):
protected, public, private...
Herentzia: Object klase gorena.

Gainkarga (polimorfismo estatikoa).
Klase abstraktuak.
Polimorfismo dinamikoa.
dinamikoa
Interfazeak: askotariko herentzia inplementatzeko modu bat.
2016-05-05
20
Metodoak: gainkarga
class Puntu {
private double x;
private double y;
public void print() {
System.out.println("Puntua: " + this.x + "," + this.y);}
public void print(int n) { //n aldiz inprimatzen du!
for (int i = 0; i < n; i++) {
System.out.println("(" + this.x + "," + this.y + ")");
}
}
}
Puntu klaseko bi print metodoak desberdinak dira: print gainkargatuta

(overloaded) dagoela esaten da.
Polimorfismo estatikoa da hori (konpilazioan ebazten da).
2016-05-05
21
H
Herentzia
i
Klase bat beste batetik eratorrarazten baldin badugu, haren

ezaugarriak (aldagaiak eta metodoak) heredatuko ditu.
ditu Adaz ez
bezala, ordea, Javaz metodo eraikitzaileak ez dira heredatzen.
<klase-definizioa> ::=
[public] class <klase-izena>
[extends <existitzen-den-klase-baten-izena>]{
<klaseko-kidearen-erazag.>
klaseko kidearen erazag. *
}
Klase eratorriak aldagai

g eta metodo berriak ggehi ditzake ((espezializazioa)
p
)
eta/edo heredaturikoak birdefinitu.
Bada klase erro lehenetsi bat, Object, eta horren eratorpena dira beste klase
guztiak.
i k Klase-hierarkiak
Kl
hi
ki k era daitezke
d i k honela.
h l
2016-05-05
22
Adibid klase-hedapena
Adibidea:
kl
h d
class BankuKontu {
protected double vSaldoa;
// aldagaia
ld
i
public double saldoa() {
return vSaldoa;
}
}
class KontuKorronte extends

BankuKontu {
public
bli void
id sartu
t
(double kopurua) {
vSaldoa = kopurua;
}
//...
}
class NireKlasea {
public static void sartuDirua() {
KontuKorronte cc = new KontuKorronte();
cc sartu(125000 00); // k
cc.sartu(125000.00);
k. korrontean sartu
System.out.println("Kontu korrontearen saldoa = " +
cc.saldoa()); // saldoa inprimatu (metodo heredatuari dei eginez)
}
}
2016-05-05
24
Adibidea:
kl
h d
BankuKontu
-vSaldoa
+saldoa
KontuKorronte
+sartu
2016-05-05
25
Adibidea:
kl
h d
KontuKorronte-ak BankuKontu-ak dira (is-a).
Beraz, vSaldoa aldagaia eta saldoa metodoa

h d k di
heredatuko
ditu.
Gainera, sartu metodo berria gehitzen da
(
(espezializazioa).
i li i )
cc objektuak, KontuKorronte klaseko instantzia
b denez,
bat
d
bertako
b
k metodo
d eta aldagaiak
ld i k ditu
di
(heredatuak barne).
2016-05-05
26
H
Herentzia
i eta polimorfismoa
li
fi
Polimorfismoa
2016-05-05
Izen bereko metodo desberdinak idatz daitezke hierarkia

bateko hainbat klase eratorritan (birdefinizioa, overriding).
Exekuzio-denboran
E
ek io denboran erabakiko da zein
ein den exekutatzen
e ek tat en dena
(dispatching edo lotura dinamikoa).
Objektuari (dinamikoki) dagokion metodoa da exekutatuko

dena.
27
Adibid polimorfismoa
Adibidea:
li
fi
BankuKontu {
class BankuKontu {
public void sartu (double

kopurua) {...}
public double saldoa() {

return vSaldoa;
}
public void interesaMetatu() {

if (vSaldoa > 250000)
{vSaldoa += vSaldoa
* 0
0.15;
15; }
else {vSaldoa +=
vSaldoa * 0.10;}
}

vSaldoa
Saldoa +
+= vSaldoa
Saldoa * 0
0.10
10 ;
}
}
//KontuKorronte-ren
//metodo esklusiboak:
//
//...
}
2016-05-05
28
Adibidea:
li
fi
BankuKontu
-vSaldoa
+saldoa
+interesaMetatu
KontuKorronte
+sartu
+interesaMetatu
2016-05-05
29
Adibidea:
li
fi
public class NireKlasea {
public static void funtzioa(BankuKontu
p
(
kontua)
) {
kontua.interesaMetatu(); //dispatching-deia
}
public static void besteFuntzioBat() {
BankuKontu cb = new BankuKontu();
funtzioa(cb); //dei zuzena (egokia)
KontuKorronte cc = new KontuKorronte();
funtzioa(cc); //hau ere zuzena da
}
}
2016-05-05
30
Adibidea:
li
fi
funtzioa-ren lehen deia zuzena (egokia) da: BankuKontuko interesaMetatu exekutatuko da.
da
Bigarren deia ere egokia da, nahiz eta kontua parametroaren

mota
t estatikoa
t tik BankuKontu
B k K t izan
i
eta
t exekuziokoa
k i k (dinamikoa)
(di
ik )
KontuKorronte.
Kasu hauetan, Java exekuzioko motan oinarritzen da

(dispatching-a). Horrela, kontua formala BankuKontu
motakoa izanik ere,
ere funtzioa-ri
funtzioa ri cc parametroarekin deitzean
KontuKorronte-ri dagokion interesaMetatu
exekutatuko da.
2016-05-05
31
Polimorfismoa
Datu-mota estatiko vs datu-mota dinamikoa
Entitate baten datu-mota estatikoa erazagupenean

g p
zehazten da.
Exekuzio-garaian, entitatea beste motako objektu batekin lotzen
bada, mota hori izango da bere datu-mota dinamikoa.
Poligono p = new Poligono();

p-ren datu-mota
d t
t estatikoa:
t tik
P
Poligono
li
p-ren datu-mota dinamikoa: Poligono
Laukizuzen r = new Laukizuzen();
p = r;
p-ren datu-mota estatikoa: Poligono
p-ren datu-mota dinamikoa: Laukizuzen
2016-05-05
32
Adibidea: goiko klaseko

metodoen
d
deia
d i
class BankuKontu {
public double saldoa() { return vSaldoa; }
vSaldoa += vSaldoa * 0.10;
}
}
class KontuKorronte extends BankuKontu {
public void sartu(double kopurua) {...}
public
bli void
id interesaMetatu()
i
{
if (vSaldoa > 250000) { vSaldoa += vSaldoa * 0.15; }
else {// BankuKontu-koari deituz
super.interesaMetatu();
}
}
//KontuKorronte-ren metodo esklusiboak
}
2016-05-05
33
Kl
Klase
eta metodo
d abstraktuak
b k k
Klase abstraktu batek datu-eremu eta metodo zenbait erazagutzen

ditu baina metodoak definitu gabe (inplementaziorik gabe) utz
ditu,
ditzake.
Ezin dira klaseko instantziak sortu.
Abstraktuak klase berriak eratortzeko oinarri izango dira: klase
eratorri ez-abstraktuek klase abstraktuan erazaguturiko
metodo abstraktuak inplementatu behar dituzte.
dituzte
<klase
klase abstraktuaren def.
def.> ::
::= abstract <klase-def.>
klase def.
<metodo abstraktuaren erazag.> ::= abstract
{void | <mota-izena> | <klase-izena>}
p
] );
<metodo-ident.> ( [[<param.-lista>]
2016-05-05
34
Adibidea: klase eta metodo abstraktuak

public abstract class BankuKontu {
Ezin da egin:
//...
public abstract void interesaMetatu (); BankuKontu bk = new BankuKontu();
//
//...
}
Baina egin daiteke, noski:
KontuKorronte cc = new
BankuKontu {
KontuKorronte();
public void interesaMetatu () {
//...
AurrezkiKontu ak = new
}
AurrezkiKontu();
//
//...
}
class AurrezkiKontu extends
Eta hau ere bai:
BankuKontu {
BankuKontu bk = new AurrezkiKontu();
//...
bk.interesaMetatu();
}
//
//...
//AurrezkiKontu ko interesaMetatu
//AurrezkiKontu-ko
}
2016-05-05
35
Adibidea:
dibid klase
kl
eta metodo
d abstraktuak
b k k
interesaMetatu abstraktu egiten dugu, kontumota guztiek beren interesaMetatu izan dezaten
(desberdinak izan daitezke)
daitezke).
2016-05-05
36
Adibidea: datu-egitura heterogeneo

baten prozesamendua
public class NireKlasea {
//kontu guztietako interesak batzen ditugu;
g
dituen
//kontuak BankuKontu motako osagaiak
//array batean gordetzen ditugu
public static void interesaKalkulatu
(BankuKontu[]
(
[] bk,
, int osagaiKop)
g
p) {
BankuKontu
osagaiak dituen
array-a
(h t
(heterogeneoa)
)
int intMetatua = 0;
for (int i = 0; i < osagaiKop; i++) {
intMetatua += bk[i].interesaMetatu();
//eragiketa polimorfikoa: dispatching-a
//inprimatu intMetatua
//...
//
}
}
}
2016-05-05
37
Adibidea: datu-egitura heterogeneo

baten prozesamendua
Taulako osagaia (BankuKontu motakoa)

KontuKorronte motakoa denean (exekuzioan),
(exekuzioan)
KontuKorronte-ko interesaMetatu
exekutatuko da.
da
Taulako osagaia (BankuKontu motakoa)

AurrezkiKontu motakoa denean, berriz,
AurrezkiKontu-ko
AurrezkiKontu
ko interesaMetatu
exekutatuko da.
2016-05-05
38
I
Interfazeak
f
k
Askotariko herentzia simulatzen dute: klase batek gainklase

edo guraso bakar bat izan dezake (extends) eta interfaze bat
edo gehiago inplementatu (implements).
Interfaze bat klase abstraktu berezi bat baino ez da,
da non erazagut
baitaitezke hainbat metodo (emaitzaren mota, izena eta
g
emanez),
) baina inplementatu
p
ggabe utziz.
argumentuak
class Klasea implements Interfazea
Metodo-erazagupenak
g p
ez ezik, konstanteak ((final)) ere defini
daitezke interfazeotan.
2016-05-05
39
I
Interfazeak
f
k
Klaseak inplementatzen dituen interfazeek erazaguturiko metodo

guztien inplementazioa eman behar du.
du
<interfaze-def.> ::= [public] interface <interfaze-izena>
{ <metodo-erazag.>
<metodo erazag > * }
<klase-def.> ::= [public] class <klase-izena>
[extends <existitzen den klase baten izena>]
[implements <interfaze-izena>*]
{ <klaseko kideen erazag.> * }
2016-05-05
40
Adibid interfazeak
Adibidea:
i
f
k
public interface Konparagarri {
public boolean txikiagoaDa (Konparagarri bestea);
public boolean berdinaDa (Konparagarri bestea); }
public class Oso implements Konparagarri {
private int balioa;
public Oso (int z) {balioa = z;} //eraik.
public int getBalioa () {return balioa;}
public boolean berdinaDa (Konparagarri bestea) {
return this.balioa == ((Oso)bestea).balioa; }
public boolean txikiagoaDa (Konparagarri bestea) {
return this.balioa < ((Oso)bestea).balioa; }
}
2016-05-05
41
extends
t d vs implements
i l
t
extends klase bat egiten da
implements interfaze bat edo gehiago

egiten dira
klase batek beste klase bakar bat eratorri

edo hedatzen ahal du (extends)
klase batek hainbat interfaze

inplementatzen ahal ditu (implements)
klase guraso bat eratorri edo hedatzen duen

klase ume batek gurasoaren eremu eta
metodoak (kideak) heredatzen ditu; kideok
birdefini daitezke klase umean, baina ez
da ezinbestekoa
interfaze bat inplementatzen duen klase

batek interfazeko metodo guztien
inplementazioa eskaini behar du,
d i
derrigor:
interfazeko
i
f k metodoak
d k abstraktuak
b k k
dira denak (abstract hitza esplizituki
agertzen ez bada ere)
kl
klase
eratorri
t i ez-abstraktuek
b t kt k guraso
abstraktuan erazaguturiko metodo
abstraktu guztiak inplementatu behar
dituzte
2016-05-05
42
I di ariketa,
Irudien
ik
Javaz
J
klase abstraktua
eraikitzailea (datuak
eskatu
k t eta
t irudia
i di
eraiki)
Puntu
+Puntu
+azalera
2016-05-05
Irudi
-x
-y
+Irudi
+xKoord
y oo d
+yKoord
+azalera
+distantzia
Zirkulu
erradioa
-erradioa
+Zirkulu
+azalera
azalera, eragiketa
abstraktua
(azpiklaseetan
inplementatuko da)
distantzia,
birdefinitu ezin den
eragiketa (final)
Karratu
-aldea
aldea
+Karratu
+azalera
43
I di klasea
Irudi
kl
/**
* Title: Irudien klase nagusia
* @version 1.0
*/
/
import java.util.Scanner;
public abstract class Irudi {
private int x; //eremuak
private int y;
//eraikitzailea
public Irudi(Scanner kontsola) {
System.out.println
("Idatzi x eta y koordenatuak (zenb. osoak, bi lerrotan):");
x = kontsola.nextInt();
y = kontsola.nextInt();
}
2016-05-05
44
I di klasea
Irudi
kl
//behaketa-funtzioak
public int xKoord() {
return x;
}
public int yKoord() {
return
etu
y;
}
//distantzia: inplem. bakarra hierarkia osoan
public final double distantzia() {
return Math.pow((Math.pow(x,
Math pow((Math pow(x 2) + Math
Math.pow(y,
pow(y 2)),
2)) 0.5);
0 5);
}
//azalera: inplem. berezitua klase bakoitzerako
public abstract double azalera();
}
2016-05-05
45
Zi k l klasea
Zirkulu
kl
/**
* Title: Irudi geometrikoak: zirkuluen klasea
* @version 1.0
*/
public
bli class
l
Zi k l extends
Zirkulu
t d Irudi
I di {
private double erradioa;
public Zirkulu(Scanner
p
(
kontsola)
) {
super(kontsola);
System.out.println("Idatzi erradioa (zenb. erreala):");
erradioa = kontsola.nextDouble();
}
public double azalera() {
return Math.pow(erradioa, 2) * Math.PI;
}
}
2016-05-05
46
P t klasea
Puntu
kl
/**
* Title: Irudi geometrikoak: puntuen klasea
* @version 1.0
*/
public class Puntu extends Irudi {
public Puntu(Scanner kontsola) {
super(kontsola);
}
public double azalera() {
return 0.0;
}
}
2016-05-05
47
I diM lt
IrudiMultzoa
kl
klasea
(EMA)
/**
* Title: Irudi-multzoa (egoera-makina abstraktua)
* @version 1.0
*/
import java.util.ArrayList;
public class IrudiMultzoa {
//objektu kapsulatua: multzoa (pribatua)
private static final ArrayList<Irudi> multzoa = new ArrayList<Irudi>();
//eraikitzailea pribatua (kanpotik ikus ez dadin)
private IrudiMultzoa() {
}
//eragiketa estatikoak, klaseari (objektuari)
//soilik dagozkionak
public static void irudiaErantsi(Irudi
p
(
irudia)
) {
multzoa.add(irudia);
}
public static Irudi hurrengoIrudia() {
return multzoa.get(0);
}
public static void irudiaKendu() {
multzoa.remove(0);
}
public static boolean hutsaDa(){
return multzoa.isEmpty();
}
}
2016-05-05
48
N
Nagusia
i klasea
kl
(progr.
(
nagusia)
i )
/**
* Title: Irudi geometrikoak: programa nagusia
* @version 1.0
*/
import java.util.*;
public class Nagusia {
//main: p
prozedura nagusia
g
double a = 0.0; //azaleren batura edukitzeko
int aukera = 1;
Scanner sarreraStandarra = new Scanner (System.in);
while (aukera != 0) {
System.out.println("Hauta ezazu nahi duzun aukera:");
System.out.println("0 : Irten");
System.out.println("1 : Zirkulua sortu");
System out println("2
System.out.println(
2 : Karratua sortu");
sortu );
System.out.println("3 : Puntua sortu");
aukera = sarreraStandarra.nextInt();
//...
2016-05-05
51
N
Nagusia
i klasea
kl
(progr.
(
nagusia)
i )
switch (aukera) {
case 0: break; //exekuzioa bertan behera utzi
case 1: Zirkulu z = new Zirkulu(sarreraStandarra);
IrudiMultzoa.irudiaErantsi(z);
break;
case 2: Karratu k = new Karratu(sarreraStandarra);
IrudiMultzoa.irudiaErantsi(k);
break;
case 3: Puntu p = new Puntu(sarreraStandarra);
IrudiMultzoa.irudiaErantsi(p);
break;
break
default: System.out.println("Aukera okerra!");
}
}
Irudi irudia;
while (!IrudiMultzoa.hutsaDa())
(!IrudiMultzoa hutsaDa()) {
irudia = IrudiMultzoa.hurrengoIrudia();
System.out.println("- IRUDIA (x: " + irudia.xKoord() + "; y: " + irudia.yKoord() + ")");
System.out.println("Azalera: " + irudia.azalera()); //dispatching-a
System.out.println
("Jatorritiko distantzia: " + irudia.distantzia());
a = a + irudia.azalera();
IrudiMultzoa.irudiaKendu();
}
System.out.println("--------------------------------------------------");
System.out.println("AZALERA GUZTIEN BATURA: " + a);
}
}
2016-05-05
52
Java programen antolaketa:

modifikatzaileen
difik
il
laburpena
l b
Klaseen
hedapena
konstanteak
Metodoen
M t d
bi
birdefinizioa
d fi i i
Ikusgaitasuna
Eremu
Kidearen
partekotza
(heredatu ala ez)
packagee (besterik
ezean)
public
protected
private
Klaseak
Eremuak
(aldagaiak)
Metodoak
2016-05-05
final
static
Klase eta metodoen

abstraktutasuna
abstract
X
53

modifikatzaileen
difik
il
laburpena
l b
Klaseen modifikatzaileak:
2016-05-05
package:
k
kl
klasea
definituta
d fi i
dagoen
d
paketeko
k k klaseetatik
kl
ik atzigarria
i
i
public: edozein klasetatik atzigarria
private: beste edozein klasetatik ez da atzigarria
protected: bere azpiklase guztietatik (pakete berekoak izan edo ez)
eta pakete bereko klase guztietatik atzigarri
static: ez da ohikoa klase bat static izatea, non eta ez den barneklase pribatu bat
abstract: klase abstraktu bati dagozkion objektuak ezingo dira sortu,
sortu
baina klase abstraktua hedatu ahal izango dugu
final: klasea ezin da hedatu
54

modifikatzaileen
difik
il
laburpena
l b
Eremuen modifikatzaileak:
2016-05-05
package: klasea definituta dagoen paketeko klaseetatik

public: klasetik kanpora ere erabilgarria
private: soilik erazagututa dagoen klasetik
protected: definituta dagoen klasetik, azpiklase guztietatik (pakete berekoak
izan edo ez) eta pakete bereko klase guztietatik
static: klasearena da eremua: klaseko objektu guztiek eremu bera
konpartituko dute
abstract: eremuak ezin dira abstraktuak izan!
final: konstante bat da eremua
55

modifikatzaileen
difik
il
laburpena
l b
Metodoen modifikatzaileak:
2016-05-05
package: klasea definituta dagoen paketeko klaseetatik

public: klasetik kanpora ere erabilgarria
private: soilik erazagututa dagoen klasetik
protected: definituta dagoen klasetik, azpiklase guztietatik (pakete
berekoak izan edo ez) eta pakete bereko klase guztietatik
static: klaseari dagokio, ez instantziei
abstract: ez dago inplementatuta klasean
final: ezin da birdefinitu edo gain-idatzi
gain idatzi azpiklaseetan
56
A
Aurrekaria:
k i Ad
Adako
k mota eratorriak
i k
Datu-mota eratorriak
Mota berri bat, existitzen den beste mota batean oinarritua

Mota eratorri batek bere gurasoa den motaren eragiketa guztiak heredatzen ditu:
eragiketa primitiboak.
type Mila_Kopuru is new Float;
type Kilometro_Kopuru is new Float;
Heredatutako eragiketak birdefinitzeko aukera dago

Eragiketa berriak gehi daitezke mota eratorria erazagutzean
B t adibide
Beste
dibid bat:
b t
type Karta is
(Bastoiak, Diamanteak, Bihotzak, Ezpatak, Komodinak);
-- Karta motaren datu-mota eratorri bat:
type Palo is new Karta range Bastoiak .. Ezpatak;
-- kontuz, honako hau desberdina da eta:
subtype
yp Palo is Karta range
g Bastoiak .. Ezpatak;
p
2016-05-05
58
Ad k mota eratorriak:
Adako
i k adibidea
dibid
package Lerro_Zenbakiak1 is
subtype Lerro_Zenbaki is Positive;
end Lerro_Zenbakiak1;
Lerro Zenbakiak1;
type Lerro_Zenbaki is new Positive;
-- eragiketa eratorriak birdefinitzeko aukera dago:
overriding
function "+" (LZ1, LZ2 : in Lerro_Zenbaki) return Lerro_Zenbaki;
type Lerro_Zenbaki is private;
-- eraikitzailea
f
function
i
Lerro_Zenbakia
b ki (
(I : in
i Positive)
i i ) return Lerro_Zenbaki;
b ki
function "+" (LZ1, LZ2 : in Lerro_Zenbaki) return Lerro_Zenbaki;
private
type Lerro_Zenbaki is new Positive;
-- inplementazioan (gorputzean) erabil ditzakegu positiboen eragiketak
2016-05-05
59
Ad k mota eratorriak:
Adako
i k adibidea
dibid
with Lerro_Zenbakiak1, Lerro_Zenbakiak2, Lerro_Zenbakiak3;
procedure Proba is
LZ11, LZ12, LZ13 : Lerro_Zenbakiak1.Lerro_Zenbaki;
P : Positive;
begin
--edozein zenbaki positiborekin bezala...
LZ11 := 3;
LZ12 := 7;
LZ13 := LZ11 + LZ12
LZ12;
LZ13 := LZ11 * LZ12 ** 3; --zentzugabea erabat, seguru asko!
LZ12 := P; --zilegi da esleipena
--lerro-zenbakiak zenbaki positiboak dira
--baina
baina ez dira mota bera
LZ21 := 3;
LZ22 := 7;
LZ23 := Lerro_Zenbakiak2."+" (LZ21, LZ22); --eragiketa birdefinitua
LZ23 := Lerro_Zenbakiak2."*" (LZ21, LZ22); --eragiketak paketean eratortzen dira
LZ22 := Lerro_Zenbakiak2.Lerro_Zenbaki (P); --esleitu ahal izateko bihurketa behar da
--lerro-zenbakiak mota pribatua dira:
--paketeko eragiketak baino ez ditugu eskura
--motaren gainean erabateko kontrola du programatzaileak
LZ31 := Lerro_Zenbakiak3.Lerro_Zenbakia (3); --eraikuntza
LZ32 := Lerro_Zenbakiak3.Lerro_Zenbakia (7);
LZ33 := Lerro_Zenbakiak3."+" (LZ31, LZ32);
end Proba;
2016-05-05
60
OOP Ad
OOPa
Adan: mota etiketatuak
ik
k
Datu-moten hedatzea: mota etiketatuak
Mota etiketatuak: mota eratorri bereziak

Eragiketak ez ezik, atributuak ere gehitzeko aukera: hedapena
Erregistro egituraz baliatuko gara datu-mota bat atributu berriak gehituz hedatzeko
tagged hitz erreserbatua erabiliko dugu erregistro mota etiketatuak erazagutzeko
Eragiketa primitiboak: mota erazagutzen den lekuan erazagututako eragiketak,

motako parametroren bat baldin badute edo/eta motako emaitza itzultzen baldin
bad te
badute
Mota etiketatuetako objektuek etiketa (tag) ezkutu bat dute (hortik izena, noski)
<mota etiketatua>::= type <motaren izena> is tagged <record def.>

<mota hedatua>::= type <motaren izena> is new <gurasoaren izena>
with (null record | <record def.>)
2016-05-05
61
OOP Ad
OOPa
Adan: mota etiketatuak
ik
k
Mota etiketatuak:
Mota etiketatu bat hedatzean,

hedatzean atributu berriak gehitzeko aukera dago
Mota etiketatu batetik hedatuak etiketatuak dira (tagged hitza
esplizituki erabiltzen ez bada ere)
Mota etiketatuek programazio polimorfikoa posible egiten dute
Mota etiketatuen pribatutasuna
<mota etik. pribatua>::= type <mota izena> is tagged private;

<hedapen pribatua>::= type <mota izena> is new <gurasoaren izena> with private;
2016-05-05
Mota-hierarkiak inplementatzeko modurik egokiena pakete-hierarkiez

baliatzea da,, mota eta hedapen
p pribatuak
p
erabiliz
62
OOP Ad
OOPa
Adan: sintaxia
i
i
Irudi
-X
Y
-Y
Adibidez (p
(pribatutasunaz baliatu ggabe):
)
type Irudi is tagged record
X Y : Float;
X,
end record;
Zirkulu
-Erradioa
Puntu
type Zirkulu
t
Zi k l is
i new Irudi
I di with
ith record
d
Erradioa : Float;
end record;
type Puntu is new Irudi with null record;
2016-05-05
63
A ik
Ariketa
Pertsonak
Programatzaileak
E
Ezaugarriak:
i k izena,
i
sexua.
Pertsonak dira.
dira
Ezaugarri berezia: lengoaia batean espezialistak.
Idatzi bi mota etiketatu:
2016-05-05
Pertsona eta Programatzaile

Inprimatu eragiketa izango dute biek: inplementatu bi eragiketok.
64
A ik
Ariketa:
soluzioa
l i
type Emakumea_Gizona is (Emakumea, Gizona);
type Pertsona is tagged
record
I
Izena
: Ad
Ada.Strings.Unbounded.Unbounded_String;
St i
U b
d d U b
d d St i
Sexua : Emakumea_Gizona;
end record;
Programatzaile
motak Pertsona
mota hedatzen du
type Lengoaia is (Java, Ada2005, PHP, Perl, Prolog);

yp Programatzaile
g
is new Pertsona with
type
record
Espezialista : Lengoaia;
end record;
procedure Inprimatu (Perts : in Pertsona) is

begin
Ada.Text_IO.Put (Ada.Strings.Unbounded.To_String (Perts.Izena) &
" " &
Emakumea_Gizona'Image (Perts.Sexua));
end Inprimatu;
mota-bihurketa
eragiketa
birdefinituaren
inplementazioa,
gurasoarenaz
baliatuz
procedure Inprimatu (Progr : in Programatzaile) is

begin
Inprimatu (Pertsona (Progr)); -- gurasoaren Inprimatu-ri deitu
Ada.Text_IO.Put (" " & Lengoaia'Image (Progr.Espezialista));
end Inprimatu;
2016-05-05
65
Irudien adibidea, pribatutasuna behar

b l erabiliz
bezala
bili
package Irudiak is
type Irudi is tagged private;
--eragiketak
private
type Irudi is tagged
record
X, Y : Float;
end record;
end Irudiak;
package Irudiak.Zirkuluak is
type Zirkulu is new Irudi with private;
--eragiketak
private
type Zirkulu is new Irudi with record
Erradioa : Float;
end record;
end Irudiak.Zirkuluak;
package Irudiak.Puntuak
Irudiak Puntuak is
type Puntu is new Irudi with private;
--eragiketak
private
end Irudiak.Puntuak;
2016-05-05
irudiak.ads
irudiak-zirkuluak.ads
irudiak-puntuak.ads
66
OOPa Adan:
kl
klase-mailako
il k motakk
Klase-mailako motak (class-wide types):
T mota etiketatu bakoitzerako,

bakoitzerako T
TClass
Class mota inplizitua existitzen da
(mota hori ez dago erazagutu beharrik)
TClass motak barnean hartzen ditu T mota errotzat duten mota etiketatu
guztiak
Mota etiketatu bakoitzaren ezkutuko etiketak mota espezifiko bat
besteetatik bereizteko balio du
Klase-mailako mota deitzen zaie mota hauei, eta mota hauetan oinarritzen
da eragiketa polimorfikoen mekanismoa Adan
TClass motako parametro formal bat definitzen badugu, eragiketaren
parametro erreala T motatik hedapenez eratorritako edozein motatakoa izan
daiteke (bihurketak automatikoak dira)
2016-05-05
68
OOPa Adan:
kl
klase-mailako
il k motakk
Adibidez:
TClass
T1Class
T2Class
T1
T2
T22Class
T21
T22
TClass mota inplizituaren balioak:

T T1,
T,
T1 T2,
T2 T21 eta T22 mota espezifikoen balioen bildura
2016-05-05
69
OOPa Adan:
kl
klase-mailako
il k motakk
Klase-mailako motak (class-wide type):
Klase-mailako motako balio batek bi alderdi ditu:

Balioa zein mota espezifikori
p
dagokion
g
adierazten duen
ezkutuko etiketa (tag)
Balioa bera (etiketa ezkutuak adierazten duen mota
espezifiko horretakoa dena, alegia)
2016-05-05
70
OOPa Adan:
kl
klase-mailako
il k motakk
TClass motako objektuen erazagupena:
T'Class mota mota ez-murriztu

T'Cl
ez murriztu gisa tratatzen da,
da ezin baita jakin zein
izango den benetan beharko duen memoria-espazioa.
TClass motako aldagai bat erazagutu nahi bada, aldi berean hasieratu
beharko da, objektuaren tamaina eta mota espezifikoa (etiketa ezkutua)
finkatuz.
S : String; -- gaizki!
S : String := "Kaixo"; --hasieratzean, luzera finkatzen da
Z : Irudi'Class; -- gaizki!
Z : Irudi'Class := Zirkulu'(X => 3.0, Y => 4.0, Erradioa => 17.5);
--hasieratzean, mota espezifikoa finkatzen da
2016-05-05
72
OOPa Adan:
kl
klase-mailako
il k motakk
Azpiprogramen parametro formal bezala ere erabil daitezke
TClass
T
Class motak:
function Distantzia (O : in Irudi'Class)

Irudi Class) return Float;
-- hau ez da Irudi motako eragiketa primitiboa, kontuz!
Eragiketa horri deitzerakoan, edozein irudi motatako objektuak

erabil ditzakegu parametro erreal gisa
2016-05-05
73
OOPa Adan:
kl
klase-mailako
il k motakk
Ohikoa da TClass motako aldagaien erakusleak erabiltzea:
P
access motako aldagai bat (erakuslea) defini daiteke, TClass bat

seinalatuko duena (horrela,
(horrela erakusleak mota espezifiko desberdinetako
objektuei egin diezaieke erreferentzia):
P.all
type Int_Erak
-- erazagupenak
type Irudi
Irudi_Erakusle
Erakusle is access Irudiak
Irudiak.Irudi
Irudi'Class;
Class;
Irudi_Erak1, Irudi_Erak2 : Irudi_Erakusle;
is access Integer;
P : Int_Erak;
P := new Integer;
P.all := 5;
-- edo, gauza bera dena:

P := new Integer'(5);
2016-05-05
-- erakusleen hasieratzea (objektuen eraikuntza)

Irudi_Erak1 := new Zirkulu'(X => 3.0, Y => 4.0, Erradioa => 17.5);
Irudi_Erak2
i
:= new Puntu;
Irudi_Erak2.all.X := 0.0;
Irudi_Erak2.all.Y := 0.0;
-- erabilera
Ada.Text_IO.Put_Line
("Zirkulua: " &
Float'Image (Irudi_Erak1.all.X) &
...);
74
OOPa Adan:
mota heterogeneoko datu-egiturak
N l iinplementatu
Nola
l
t t mota
t desberdinetako
d b di t k objektuz
bj kt eratutako
t t k datu-egiturak?
d t
it k?
Erakusleez eta klase

klase-mailako
mailako motez baliatuz (datu-egitura
(datu egitura estatikoa):
type Irudi_Erakusle is access Irudiak.Irudi'Class;
package Irudi_Erakusle_Listak is new Lista_Estatikoak (Osagai => Irudi_Erakusle);
-- Lista_Estatikoak pakete generikoa da
-- (array bidez inplementatua
inplementatua, Taula mota esportatzen du)
Irudi_Segida : Irudi_Erakusle_Listak.Taula;
...
Irudi Segida
Irudi_Segida
Aldea
X
Erradioa
X
OOPa Adan :
Nola prozesatu mota desberdinetako objektuz eratutako datu-egitura

heterogeneo horiek?
Adibidez, irudi guztien azaleren batura kalkulatzeko:
Azalera_Osoa := 0.0;
for I in 1 .. Irudi_Erakusle_Listak.Zenbat_Osagai (Irudi_Segida) loop
Azalera_Osoa := Azalera_Osoa +
Irudiak.Azalera (Irudi_Erakusle_Listak.Osagaia_Posizioan (Irudi_Segida, I).all);
-- edo, Ada 2005-etik aurrera erabil daitekeen OOPko notazio "klasikoagoa" erabiliz:
-- Azalera_Osoa := Azalera_Osoa +
-Irudi_Erakusle_Listak.Osagaia_Posizioan
(Irudi_Segida, I).all.Azalera;
end loop;
2016-05-05
76
OOPa Adan:
N l iinplementatu
Nola
l
t t mota
t desberdinetako
d b di t k objektuz
bj kt eratutako
t t k datu-egiturak?
d t
it k?
Erakusleez eta klase-mailako motez baliatuz (datu-egitura dinamikoa):

package Irudi_Erakusle_Listak is new Listak (Osagai => Irudi_Erakusle);
-- Listak pakete generikoa da (inpl. dinamikoa, lista estekatua)
-- (Lista mota esportatzen du)
Irudi_Segida : Irudi_Erakusle_Listak.Lista;
Info
Hurrengoa
Irudi_Segida
Aldea
Erradioa
OOPa Adan :
Nola prozesatu mota desberdinetako objektuz eratutako datu-egitura

heterogeneo horiek?
Adibidez, irudi guztien azaleren batura kalkulatzeko:
Azalera_Osoa := 0.0;
Irudi_Erakusle_Listak.Kopiatu (Irudi_Segida_Lag, Irudi_Segida);
--jatorrizkoa ez suntsitzearren
while not Irudi_Erakusle_Listak.Hutsa_Da (Irudi_Segida_Lag) loop
Irudi_Erakuslea := Irudi_Erakusle_Listak.Lehena (Irudi_Segida_Lag);
Azalera_Osoa := Azalera_Osoa + Irudiak.Azalera (Irudi_Erakuslea.all);
-- edo, Ada 2005-etik aurrera erabil daitekeen OOPko notazio "klasikoa" erabiliz:
-- Azalera_Osoa := Azalera_Osoa + Irudi_Erakuslea.all.Azalera;
Irudi_Erakusle_Listak.Lehena_Kendu (Irudi_Segida_Lag);
end loop;
2016-05-05
78
OOPa Adan: mota heterogeneoko

d
datu-egiturak:
i
k adibidea
dibid
with Dates;
package Transactions is
type Transaction_Type is tagged private;
subtype Account_Number_Type is String (1 .. 16);
type Money_Type is ...;
procedure Put (Item : in Transaction_Type);
--...
private
type Transaction_Type is tagged
record
Date_Part : Dates.Date;
Account_Part : Account_Number_Type;
Amount_Part : Money_Type;
end record;
end Transactions;
2016-05-05
Transaction_Type
Deposit_Type
Check_Type
dispatchingeragiketa
(polimorfikoa)
79

d
datu-egiturak:
i
k adibidea
dibid
with Ada.Strings.Unbounded;
package Transactions.Deposits is
type Deposit_Type is new Transaction_Type with private;
procedure Put (Item : in Deposit_Type);
Deposit Type);
--...
private
type Deposit_Type is new Transaction_Type with
record
Branch_Part : Ada.Strings.Unbounded.Unbounded_String;
end record;
end Transactions.Deposits;
2016-05-05
(polimorfikoa)
80

d
datu-egiturak:
i
k adibidea
dibid
package Transactions.Checks is
type Check_Type is new Transaction_Type with private;
subtype Check_Number_Subtype is Integer range 0 .. 5_000;
procedure Put (Item : in Check_Type);
Check Type);
--...
private
type Check_Type is new Transaction_Type with
record
Check_Number_Part : Check_Number_Subtype;
end record;
end Transactions.Checks;
2016-05-05
(polimorfikoa)
81

d
datu-egiturak:
i
k adibidea
dibid
-- hierarkiako erroaren klase-mailako motaren erakusle mota
type Transaction_Pointer_Type is access Transaction_Type'Class;
-- osagai mota heterogeneoko datu-egitura: erakusle-array-a
type Transaction_Array_Type is
array (Positive range <>) of Transaction_Pointer_Type;
Transaction Pointer Type;
-- osagai mota heterogeneoko datu-egitura: erakusle osagaidun
-- lista estekatua
type Transaction_List_Cell_Type;
type Transaction_List_Type is access Transaction_List_Cell_Type;
type Transaction_List_Cell_Type is
record
Transaction_Part : Transaction_Pointer_Type;
Link_Part : Transaction_List_Type;
end record;
2016-05-05
bi aukera
desberdin
datu-egitura
horiek
inplementatzeko
82
OOPa Adan: mota eta azpiprograma

abstraktuak
Mota eta azpiprograma abstraktuak
Mota abstraktua: mota etiketatu bat abstraktua izan daiteke

Mota abstraktu horretako objekturik ezin da definitu
Mota eratorri etiketatuen gguraso ggisa erabili ahal izango
g da, eta horrek
ezaugarri komunak dituzten motak batzeko balio du
Diseinu-oharra: mota-hierarkien zuhaitzetako hosto ez diren klase guztiak
abstraktuak izatea komeni da
Azpiprograma
pp g
abstraktua: ggorputzik
p
ggabeko azpiprograma.
pp g
Azpiprograma abstraktu bat heredatzen duten mota ez-abstraktuak
behartuta daude azpiprograma hori inplementatzera.
2016-05-05
83
OOPa Adan: mota eta azpiprograma

abstraktuak
b k k
Mota eta azpiprograma abstraktuak

Azpiprograma
pp g
abstrakturen bat daukan mota etiketatuak (edo
(
mota etiketatutik
eratorritakoak) mota abstraktua izan behar du.
Sintaxia eta adibideak:
<mota abstraktua>:=
type <mota-izena> is abstract tagged <record-def.> |
type <mota-izena> is abstract new <mota-izena> <mota-hedatzea>
type Irudi is abstract tagged private;

type Irudi is abstract tagged record...;
type Poligono is abstract new Irudi with private;
<azpiprograma abstraktua>:=
b
k
<azpiprograma-erazagupena> is abstract;
function Azalera (I : in Irudi) return Float is abstract;
2016-05-05
84
OOP Ad
OOPa
Adan: mota abstraktuak
b k k
Mota abstraktuetako objekturik erazagutzerik ez dago:

Irudia : Irudi; -- gaizki!
Baina, klase-mailako motaz baliatuz gero, egiten ahal da honako

hau (Zirkulu ez dela abstraktua emanik,
emanik noski):
Irudia : Irudi'Class :=
Zirkulu'(X => 3.0, Y => 4.0, Erradioa => 17.5);
2016-05-05
85
Polimorfismoa: mota eta

azpiprograma abstraktuak
Irudi
-X
-Y
+Azalera
Puntu
+Azalera
Zirkulu
-Erradioa
+Azalera
Karratu
-Aldea
+Azalera
Zer inplementazio emango diogu goiko klaseko Azalera eragiketari? Batere ez,
metodo abstraktua izango da, dispatching-a bideratzea beste helbururik izango ez
duena.
Eta Irudi klasea bera ere abstraktua izango da: klase horren instantziarik ez da
existitzen puntuak,
existitzen,
puntuak karratuak,
karratuak zirkuluak...
zirkuluak existitzen dira (letra etzanak
abstraktutasuna adierazten du UML klase-diagrametan).
2016-05-05
86
Irudien hierarkia:
nola
l implementatu
i l
Adaz
Ad
Mota bakoitza DMA bat da: pribatutasuna ohiko moduan

erabiliko dugu (datu
(datu-mota
mota etiketatuen sintaxiari egokitua).
egokitua)
DMAen arteko erlazioak (klaseen artekoak) datu-mota
etiketatuen bidez islatuko dira: tagged, is new with.
B t ld Adako
Bestalde,
Ad k pakete-hierarkiak
k t hi
ki k baliatuko
b li t k ditugu
dit
ikusgaitasuna hobeto kontrolatzeko.
Mota eta eragiketa
g
abstraktuak ere erabiliko dira,, hierarkia
hobeto antolatu eta dispatching-a bideratzeko.
Eragiketa polimorfikoak edo dispatching-eragiketak: izen
berekoak klase desberdinetan (klaseari dagozkion
parametroekin).
2016-05-05
87
OOPa Adan: objektua.metodoa notazio

berria (Ada 2005-etik aurrera)
Z : Zirkulu; --mota etiketatuko objektua
"Betiko" notazioa:
Azalera_Osoa := Azalera_Osoa + Azalera (
(Z);
);
objektua.metodoa notazio berria (datu-mota etiketatuetako
objektuekin
bj kt ki erabiltzen
bilt
ahal
h l da
d bakarrik):
b k ik)
Azalera_Osoa := Azalera_Osoa + Z.Azalera;
Notazio berri hau gertuago dago OO programazio-lengoaia
gehienetatik.
2016-05-05
88
Irudiak: Irudi
mota abstraktua
package Irudiak is
erag. abstraktua
type Irudi is abstract tagged private;

function Azalera (O : in Irudi) return Float is abstract;
procedure Eraiki (O : out Irudi);
-- irudi bat "eraikitzen"
eraikitzen du,
du X eta Y erabiltzaileari eskatuz
function Distantzia (O : in Irudi'Class) return Float;
-- hau ez da dispatching-eragiketa, eta ez da Irudi motako
-- eragiketa primitiboa ere
function Zabalago (O1, O2 : in Irudi'Class) return Boolean;
-- hau ezingo genuke egin eragiketa primitibo batekin, honek
-- deian irudi desberdinak konbinatzeko aukera emango baitigu
private
type Irudi is abstract tagged
record
X, Y : Float;
end record;
klase-mailako
parametrodun
eragiketak:
g
ez dira
primitiboak
end Irudiak;
2016-05-05
89
Irudiak (paketearen gorputza)

with Ada.Text_Io;
with Ada.Numerics.Elementary_Functions;
package body Irudiak is
package Erreal_Si is new Ada.Text_Io.Float_Io (Float);
procedure Lortu_Xy
Lortu Xy (X,
(X Y : out Float) is -- barne
barne-eragiketa
eragiketa
begin
Ada.Text_Io.Put_Line
("Koordenatuak eman (bi zenbaki erreal, lerro" &
" berean), eta gero RETURN sakatu");
Erreal Si Get (X);
Erreal_Si.Get
Erreal_Si.Get (Y);
Ada.Text_Io.Skip_Line;
end Lortu_Xy;
eraikuntza: balioak
irakurri
eta objektua
j
procedure Eraiki (O : out Irudi) is
X, Y : Float;
hasieratu
begin
Lortu_Xy (X, Y);
O.X := X;
O Y :=
O.Y
: Y;
end Eraiki;
--...
2016-05-05
90
Irudiak (paketearen gorputza)

--...
function Distantzia (O : in Irudi'Class) return Float is
begin
return
Ada.Numerics.Elementary
y_Functions.Sqrt
q
(
(O.X ** 2 + O.Y ** 2);
);
end Distantzia;
function Zabalago (O1, O2 : in Irudi'Class) return Boolean is
begin
g
-- return Azalera (O1) > Azalera (O2); -- dispatching-deiak
return O1.Azalera > O2.Azalera; -- dispatching-deiak
-- (Ada 2005-etik aurrerako OOP notazioa)
end Zabalago;
g ;
end Irudiak;
dispatching-a: nola jakin
Azalera-ren dei horiek
zein diren zehazki?
2016-05-05
91
Irudiak: Zirkulu
pakete umea
package Irudiak.Zirkuluak is
type Zirkulu is new Irudi with private;
mota etiketatu hedatua

(klase umea)
overriding
function Azalera (Z : Zirkulu) return Float;
overriding
idi
procedure Eraiki (Z : out Zirkulu);
-- zirkulu bat eraikitzen du, irudien eraikitzaileari deituz
-- (X eta Y eskuratzeko), eta, gero, erabiltzaileari erradioaren
-- balioa eskatuz
private
type Zirkulu is new Irudi with
record
Erradioa : Float;
end record;
eragiketa
birdefinituak
2016-05-05
92
Zirkuluak (paketearen gorputza)

with Ada.Text_IO;
with Ada.Numerics;
package body Irudiak.Zirkuluak is
package Erreal_SI
Erreal SI is new Ada.Text_IO.Float_IO
Ada Text IO Float IO (Float);
function Azalera (Z : Zirkulu) return Float is
begin
return Ada.Numerics.Pi * Z.Erradioa ** 2;
end Azalera;
procedure Lortu_Erradioa (R : out Float) is -- barne-eragiketa
begin
Ada.Text_IO.Put_Line ("Erradioa eman (zenbaki erreala)" &
" eta gero RETURN sakatu");
Erreal_SI.Get (R);
end Lortu_Erradioa;
procedure Eraiki (Z : out Zirkulu) is
R : Float;
begin
--Eraiki (Irudi (Z));
Irudi (Z).Eraiki; -- OOP notazioa (Ada 2005-etik aurrera)
Lortu_Erradioa (R);
Z.Erradioa :=
: R;
end Eraiki;
2016-05-05
dispatchingeragiketaren
inplementazioa
eraikuntza klase umean:

(1) gurasoaren
eraikitzaileari deitu;
(2) gainontzeko
atributuak eskuratu eta
ezarri
93
Irudiak: Puntu
package Irudiak.Puntuak is
type Puntu is new Irudi with private;
mota etiketatu hedatua

((klase umea))
overriding
function Azalera (P : in Puntu) return Float;
-- procedure
d
Eraiki
iki (
(P : out Puntu);
)
-- ez dago zertan birdefinitu eragiketa eraikitzailea
-- heredatuarekin aski baita
eragiketa
birdefinitua
f
private
;
end Irudiak.Puntuak;
2016-05-05
94
Puntuak (paketearen gorputza)

package body Irudiak.Puntuak is
function Azalera (P : in Puntu) return Float is
begin
return 0.0;
end Azalera;
end
d Irudiak.Puntuak;
di k
k
dispatchingeragiketaren
inplementazioa
2016-05-05
95
Irudi-lista heterogeneo
b
baten
prozesamendua
d
with Irudiak.Puntuak, Irudiak.Zirkuluak,
Irudiak.Karratuak, Irudiak.Errektangeluak;
with Listak;
with Ada.Text_Io;
erakusle mota:
edozein irudi-mota
seinala
i l d
dezake
k
procedure Irudiak_Prozesatu is
type Irudi_Mota is (Puntua, Zirkulua, Karratua, Errektangelua);
package Irudi_Erakusle_Listak is new
Listak (Osagai => Irudi_Erakusle);
lista-pakete
generikoaren
instantziazioa,
irudi-erakusle
motarekin
package Irudi_Si
Irudi Si is new Ada.Text_Io.Enumeration_Io
Ada Text Io Enumeration Io (Irudi_Mota);
(Irudi Mota);
package Erreal_Si is new Ada.Text_Io.Float_Io (Float);
2016-05-05
96
b
baten
prozesamendua
d
procedure Irakurri_Sortu_Irudia
(O : out Irudiak.Irudi'Class;
O Erakuslea : out Irudi_Erakusle)
O_Erakuslea
Irudi Erakusle) is
begin
--Irudiak.Eraiki (O); -- dispatching deia
O.Eraiki; --dispatching-deia (Ada 2005-etik aurrerako OOP notazioa)
O Erakuslea := new Irudiak.Irudi
O_Erakuslea
Irudiak Irudi'Class'(O);
Class (O);
end Irakurri_Sortu_Irudia;
Irudi_Segida : Irudi_Erakusle_Listak.Lista;
P
Z
K
R
:
:
:
:
Irudiak.Puntuak.Puntu;
Irudiak.Zirkuluak.Zirkulu;
Irudiak.Karratuak.Karratu;
Irudiak
Irudiak.Errektangeluak.Errektangelu;
Errektangeluak Errektangelu;
Forma : Irudi_Mota;
Irudi_Erakuslea : Irudi_Erakusle;
Erantzuna : Character;
2016-05-05
irudien datuak
irakurri eta
eraikitzaileei deitu
irudi erakuslez
irudi-erakuslez
osatutako lista
97
b
baten
prozesamendua
d
begin
Irudi_Erakusle_Listak.Hutsa (Irudi_Segida);
Ada.Text_Io.Put_Line
Ada
Text Io Put Line (
("Irudiak
Irudiak sartu nahi dituzu (B/E)?");
(B/E)? );
Ada.Text_Io.Get (Erantzuna);
while Erantzuna = 'B' loop
Ada.Text_Io.Put_Line ("Zein motatako irudia sartu nahi duzu?");
Ada.Text_Io.Put_Line ("Puntua, Zirkulua, Karratua edo Errektangelua");
Irudi_Si.Get (Forma);
case Forma is
when Puntua =>
(1) irudia irakurri eta
Irakurri_Sortu_Irudia (P, Irudi_Erakuslea);
when Zirkulua =>
sortu;
Irakurri_Sortu_Irudia (Z, Irudi_Erakuslea);
(2)
erakuslea
sartu
when Karratua =>
listan
Irakurri_Sortu_Irudia (K, Irudi_Erakuslea);
when Errektangelua =>
Irakurri_Sortu_Irudia (R, Irudi_Erakuslea);
end case;
Irudi_Erakusle_Listak.Erantsi_B (Irudi_Segida, Irudi_Erakuslea);
Ada.Text_Io.Put_Line ("Irudi gehiago sartu nahi duzu (B/E)?");
Ada.Text_Io.Get
Ada
Text Io Get (Erantzuna);
end loop;
2016-05-05
98
b
baten
prozesamendua
d
declare --irudi-segidaren prozesatzea
Aurrekoaren Erakuslea : Irudi
Aurrekoaren_Erakuslea
Irudi_Erakusle
Erakusle :=
Irudi_Erakusle_Listak.Lehena (Irudi_Segida);
begin
-- listaratutako irudien azalerak, distantziak-eta inprimatu
while not Irudi_Erakusle_Listak.Hutsa_Da
Irudi Erakusle Listak Hutsa Da (Irudi_Segida)
(Irudi Segida) loop
Irudi_Erakuslea := Irudi_Erakusle_Listak.Lehena (Irudi_Segida);
Ada.Text_IO.Put
Ada
Text IO Put ("**
(
Azalera: ");
);
-- Erreal_Si.Put (Irudiak.Azalera (Irudi_Erakuslea.all), 3, 2, 0);
Erreal_Si.Put (Irudi_Erakuslea.all.Azalera, 3, 2, 0);
--(Ada 2005-etik aurrerako OOP notazioa)
-- goikoa Azalera-ren
Azalera ren deia dispatching
dispatching-deia
deia da (polimorfismoa)
Ada.Text_IO.Set_Col (25);
dispatching-a:
uneko irudiaren
azaleraren kalkulua
2016-05-05
99
b
baten
prozesamendua
d
Ada.Text_IO.Put ("Jatorritiko distantzia: ");
-- Erreal_Si.Put (Irudiak.Distantzia (Irudi_Erakuslea.all), 3, 2, 0);
Erreal_Si.Put
(Irudi_Erakuslea.all.Distantzia, 3, 2, 0);
ez dago dispatching-ik
-- (Ada 2005-etik aurrerako OOP notazioa)
-- Distantzia-ren deia: ez da dispatching-a
hor: Distantzia eta
Ada.Text Io.New Line;
Ada.Text_Io.New_Line;
Zabalago ez dira
eragiketa primitiboak
-- if Irudiak.Zabalago -- ez da dispatching-a
-(Irudi_Erakuslea.all, Aurrekoaren_Erakuslea.all) then
if Irudi_Erakuslea.all.Zabalago (Aurrekoaren_Erakuslea.all) then
-- (Ada
(Ad 2005 OOP-etik
OOP tik aurrerako
k OOP notazioa
t i
notazioa)
t i )
Ada.Text_IO.Put_Line ("-- Aurrekoa baino zabalagoa da irudi hau");
end if;
Irudi_Erakusle_Listak.Kopiatu
(Irudi_Erakusle_Listak.Hondarra (Irudi_Segida), Irudi_Segida);
Aurrekoaren_Erakuslea := Irudi_Erakuslea;
end loop;
end;
end Irudiak_Prozesatu;
Irudiak Prozesatu;
2016-05-05
100
OOPa Adan: mota

mota-bihurketak
bihurketak
Mota etiketatuak: bihurketak

type T1 is tagged ...;
-- T1-en osagaiak
Bihurketa
zilegi da
beheko
klaseetatik
ggoikoetarantz
2016-05-05
type T2 is new T1 with ...;

-- T1-en osagaiak
-- T2-ren osagaiak
type
----
T3 is new T2 with ...;

T1-en osagaiak
T2-ren osagaiak
T3-ren osagaiak
Bihurketa EZ da
zilegi goiko
klaseetatik
behekoetarantz
101
OOP Ad
OOPa
Adan: mota-bihurketak
bih k k
Mota-bihurketa mota eratorrien artean: edozein norabidetan egiten ahal da.

type Mila_Kopuru
Mila Kopuru is new Float;
K : Float := 300.00; -- kilometroak, demagun
M : Mila_Kopuru := Mila_Kopuru (K * 0.62);
--...
K := Float (M * 1.6);
Mota-bihurketa mota etiketatuen artean: behetik gorantz.

I : Irudi := (X => 1.0, Y => 0.5);
Z : Zirkulu := (0.0, 0.0, 35.7);
erregistroagregatua:
errregistro-mota
bateko
bate
o ba
balioa
oa
(literala)
--...
I := Irudi (Z); -- zirkulua irudi bihurtu
-- (erradioa galduz, jakina)
Honako hauek, ordea, ez dira mota-bihurketak, agregatu hedatuak baizik:

Z := (I with 41.2);
Z := (I with Erradioa => 41.2);
41 2);
2016-05-05
102
OOP Ad
OOPa
Adan: iinterfazeak
f
k
Interfazeak eragiketa abstraktuz soilik osatutako klase

abstraktuak dira (abstract tagged null record baten
antzekoak).
Interfaze bat guraso moduko bat da: klase batek interfaze bat
"inplementatu" egiten duela esaten da, eta interfazetik
g
abstraktu gguztien bertsio ezheredatzen dituen eragiketa
abstraktu bat eskaintzera behartuta dago.
Askotariko herentzia gauzatzeko modu bat eskaintzen dute:
klase batek guraso bakar bat izan dezake eta interfaze bat
edo gehiago "inplementa" ditzake.
2016-05-05
110
I
Interfazeak:
f
k adibidea
dibid
<<interfazea>>
Pertsona
Inprimagarri
-Izena: Unbounded_String
-Sexua: Sexu
+Eraiki(in
( Izena:String,in
g Sexua:(Emakumea,
(
Gi
Gizona),out
) t P:Pertsona)
PP t
)
+F_Izena(in P:Pertsona): String
+F_Sexua(in P:Pertsona): Sexu
+Inprimatu(in Obj:Inprimagarri)
Programatzaile
-Espezialista: Lengoaia
+Eraiki(in Izena:String,in Sexua:(Emakumea,
Gizona),in
), Espezialista:Lengoaia,
p
g
,
out P:Programatzaile)
PP
il )
+F_Espezializazioa(in P:Pertsona): Lengoaia
+Inprimatu(in P:Programatzaile)
Programatzaile
klasea behartuta
dago Inprimatu
inplementatzera
Sexu: (Emakumea, Gizona)

Lengoaia: (Java, Ada2005, PHP, Perl, Prolog)
2016-05-05
111
Interfazeak (adibidea):
Pertsona klase gurasoa
with Ada.Strings.Unbounded;
with Ada.Text_IO;
package Pertsonak is
type Pertsona is abstract tagged private;
type Emakumea_Gizona is (Emakumea, Gizona);
package
p
g Sexua_IO is new Ada.Text_IO.Enumeration_IO (
(Emakumea_Gizona);
);
procedure Eraiki (Izena : in String;
Sexua : in Emakumea_Gizona;
P : out Pertsona);
function F_Izena (P : in Pertsona) return String;
function F_Sexua (P : in Pertsona) return Emakumea_Gizona;
private
type Pertsona is abstract tagged
record
Izena : Ada.Strings.Unbounded.Unbounded_String;
Sexua : Emakumea_Gizona;
end record;
end Pertsonak;
2016-05-05
112
Inprimagarri interfazea
package Inprimagarriak is
type Inprimagarri is interface;
procedure Inprimatu (Obj : in Inprimagarri) is abstract;
end Inprimagarriak;
2016-05-05
113
Programatzaile klase umea
with Ada.Text_IO;
with Inprimagarriak;
package Pertsonak.Programatzaileak is
type Programatzaile is new Pertsona and Inprimagarriak.Inprimagarri with private;
type Lengoaia is (Java, Ada2005, PHP, Perl, Prolog);
package Lengoaia_IO is new Ada.Text_IO.Enumeration_IO (Lengoaia);
procedure Eraiki (Izena : in String;
Espezialista : in Lengoaia;
P : out Programatzaile);
Programatzaile klasea:
(1) Pertsona klasearen
ume da;
(2) Imprimagarri
interfazea inplementatzen
d
du
function F_Espezializazioa (P : in Programatzaile) return Lengoaia;

procedure Inprimatu (P : in Programatzaile);
private
type Programatzaile is new Pertsona and Inprimagarriak.Inprimagarri with
record
Espezialista : Lengoaia;
end record;
g
;
end Pertsonak.Programatzaileak;
2016-05-05
114
Interfazeak (adibidea): Programatzaile klase

umea (paketearen gorputza)
package body Pertsonak.Programatzaileak is
procedure Eraiki
(I
(Izena
: in
i String;
St i
Espezialista : in Lengoaia;
P : out Programatzaile) is
begin
Eraiki (Izena
(Izena, Sexua
Sexua, Pertsona (P));
--edo, hiru parametrodun Eraiki heredatuari dei eginez: Eraiki (Izena, Sexua, P);
P.Espezialista := Espezialista;
end Eraiki;
--...
procedure Inprimatu (P : in Programatzaile) is
begin
Ada.Text_IO.Put (P.F_Izena & " ");
-- erag. heredatuari deitzen zaio hor, "objektua.metodoa notazioa" erabiliz
Pertsonak.Sexua_IO.Put (P.F_Sexua);
objektua.metodoa notazioa"
notazioa erabiliz
-- erag. heredatuari deitzen zaio hor, "objektua.metodoa
Ada.Text_IO.Put (" ");
Lengoaia_IO.Put (P.Espezialista); -- hemen atributua atzitzen da zuzenean
end Inprimatu;
motabihurketa
eraikitzailearen
inplementazioa,
gurasoaren
eraikitzaileari deituz
g
;
end Pertsonak.Programatzaileak;
s
2016-05-05
115
Nagusia proba-programa
with Pertsonak.Programatzaileak;
with Ada.Text_IO;
procedure Nagusia is
P : P
Pertsonak.Programatzaileak.Programatzaile;
t
k P
t il k P
t il
begin
Pertsonak.Programatzaileak.Eraiki ("Bea",
Pertsonak.Emakumea,
Pertsonak.Programatzaileak.PHP,
P);
-- erag. heredatuari deituz ("betiko" notazioa):
Ada.Text_IO.Put (Pertsonak.Programatzaileak.F_Izena (P) & " ");
-- erag. heredatuari deitzen zaio hemen ere, baina "objektua.notazioa" erabiliz:
Pertsonak.Sexua_IO.Put (P.F_Sexua);
Ada Text IO Put ("
Ada.Text_IO.Put
( ");
);
Pertsonak.Programatzaileak.Lengoaia_IO.Put (P.F_Espezializazioa);
Ada.Text_IO.New_Line (2);
Pertsonak.Programatzaileak.Eraiki ("Mari",
Pertsonak.Emakumea,
Pertsonak.Programatzaileak.Ada2005,
P);
Ada.Text_IO.Put_Line ("Inprimatu eragiketaz baliatuz: ");
P.Inprimatu; -- "objektua.notazioa" erabiliz
g
;
end Nagusia;
2016-05-05
116
UML eta kl
klase-hierarkiak
hi
ki k
<<interfazea>>
Pertsona
Inprimagarri
-Izena: Unbounded_String
-Sexua: Sexu
+Eraiki(in
( Izena:String,in
g Sexua:(Emakumea,
(
Gi
Gizona),out
) t P:Pertsona)
PP t
)
+F_Izena(in P:Pertsona): String
+F_Sexua(in P:Pertsona): Sexu
Klasea bat beste

klase baten ume da
+Inprimatu(in Obj:Inprimagarri)
Programatzaile
-Espezialista: Lengoaia
+Eraiki(in Izena:String,in Sexua:(Emakumea,
Gizona),in
), Espezialista:Lengoaia,
p
g
,
out P:Programatzaile)
PP
il )
+F_Espezializazioa(in P:Pertsona): Lengoaia
+Inprimatu(in P:Programatzaile)
Klasea batek
interfaze bat
inplementatzen du
Sexu: (Emakumea, Gizona)

Lengoaia: (Java, Ada2005, PHP, Perl, Prolog)
2016-05-05
117
J
Java
vs Ada
Ad
Javan "ezin" (omen) dira aldagai globalak erazagutu :-o
Klaseko aldagai kideak klase osotik ikusten dira.

Kl
Klase
bbatetik
t tik kanpo
k
ezin
i dira
di aldagaiak
ld i k erazagutu.
t
Javan erregistrorik ez dago, baina, klase bat bere atributuekin

definitzen denean,, hortxe dago
g erregistroa!
g
Informazioaren ezkutatzea: Adan datu-mota, pakete eta eragiketen

atzipena murriztu daiteke; Javan eremu, klase eta metodoena.
Berrerabilgarritasuna: Javan generikoen mekanismoa sinpleagoa

da Adakoa baino: motarekiko generikotasuna badago,
badago JDK 1.5
1 5-etik
etik
aurrera (2004).
B t ld mota
Bestalde,
t orokorrak
k
k simula
i l daitezke,
d it k Object
Obj t klaseaz
kl
baliatuz.
b li t
2016-05-05
118
J
Java
vs Ada
Ad
Modulartasuna:
Adako paketeak Javako klaseen baliokide dira, modulartasunari

d ki
dagokionez.
Javak ez du klaseen zehaztapena eta inplementazioa bereizten.
Javan paketeak erabiltzen dira klaseak multzokatzeko; Adan,
pakete-hierarkiak.
Herentzia:
Bietan dago herentzia, baina ez batean eta ez bestean askotariko

herentzia. Bai Javan eta bai Adan, interfazeen bitartez simula
daiteke askotariko herentzia.
Klase abstraktuen kontzeptua antzekoa da bietan.
2016-05-05
119

PMOO

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

PMOO

Uploaded by

Copyright:

Available Formats

0.

Java programazio lengoaia

Java JVMrako lengoaia

Bi fase: konpilazioa eta interpretazioa

Java paketeak (klase bildumak)

Lengoaiaren ezaugarri orokorrak

Lengoaiaren ezaugarri orokorrak

Lengoaia: oinarrizko datu motak

Osoak:byte, short, int, long

++espr --espr +espr -espr ! (NOT logikoa)

< > <= >= instanceof

Lengoaia: switch (adibideak)

Lengoaia: while (adibideak)

Lengoaia: for (adibideak)

Bektoreak (array ak)

Adibidea: Klase honek

Amarauneko helbide interesgarriak

Softwarea garatzeko arazoak

Helburuak eta ezaugarriak

Programa edo aplikazio bat egitea ez da, gehienetan,

Antz handiagoa du, maiz, etxe orratz bat egitearekin,

Lantalde oso bat

SWa garatzeko arazoak

SWa garatzeko arazoak

SWa garatzeko arazoak

Banekien ez zela samurra izango ordu

Enpresa kudeatzeko aplikazio berriak

SWa garatzeko arazoak

SWa garatzeko arazoak

SWa garatzeko arazoak

SWaren krisia: grafikoa

Iturria: (Standish Group International, I. (2001). Extreme chaos. &

SWa garatzeko arazoak

Bezeroak hau behar

SWa garatzeko arazoak

Programa informatiko handiak garatzeko eta

Aplikazio aldagarria: aldaketak onartzen

Programazio-lengoaiaren mendeko alderdi bat

Modulartasuna eta lokalizazioa

Goranzko diseinua ((bottom-up):

Bi teknikok erabiltzen dira benetako aplikazioetan

Goranzko eta beheranzko diseinuak

Modulartasuna eta lokalizazioa

Moduluaren interfazea/espezifikazioa ongi

Kohesioa (cohesion): modulu barneko elementuen

Modulartasuna eta lokalizazioa

Modulartasuna eta lokalizazioa

Osotasuna: problemaren elementu guztiak

Softwarearen garapenerako hurbilpenak

Softwarearen garapenerako hurbilpenak

Problema baten abstrakzio-sekuentzia

Objektuei orientatutako diseinua

Bigarren belaunaldia (1959-1961)

azpirrutinak, konpilazio banatua

Tarteko belaunaldia (1970-1980)

1990etik aurrera (Internet, scripting-a): segurtasuna, fidagarritasuna,

Modulu bakoitzak ahalik eta modulu

Moduluen interfazea eta modulu

Modulutan banatzeko irizpideak

Modulutan banatzeko irizpideak

Modulutan banatzeko irizpideak

Motako objektuak errepresentatzeko datu-egiturak

Datuak eragiketa multzo zehatz baten bidez

ditu zein ezaugarri izango diren publikoak