Java Ikasteko

JAVA: APUNTEAK ETA ARIKETAK
Oier Palacios Egiguren

Aurkibidea
1. GAIA: INFORMATIKA-PROGRAMEN ELEMENTUAK............................................................5
1.1. SARRERA.....................................................................................................................................6
1.1.1. ZER DA JAVA.......................................................................................................................6
1.1.2. PROGRAMA BATEN EGITURA OROKORRA.................................................................7
1.1.3. JDK (Java Development Kit).................................................................................................7
1.1.3.1. JDK ESKURATU..........................................................................................................7
1.1.3.2. JDK ERABILI................................................................................................................8
1.2. IDENTIFIKADOREAK ETA ALDAGAIAK.............................................................................12
1.2.1. IDENTIFIKADOREAK......................................................................................................13
1.2.2. HITZ ERRESERBATUAK..................................................................................................14
1.2.3. ALDAGAI MOTAK............................................................................................................14
1.3. DATU MOTAK...........................................................................................................................16
1.3.1. OINARRIZKO DATU MOTAK I.......................................................................................17
1.3.2. OINARRIZKO DATU MOTAK II......................................................................................19
1.3.3. ALDAGAI ETA KONSTANTEAK DEKLARATZEA ETA HASIERATZEA...................19
1.4. ERAGILEAK ETA ADIERAZPENAK......................................................................................21
1.4.1. ERAGILE ARITMETIKOAK.............................................................................................21
1.4.2. ESLEIPEN-ERAGILEAK...................................................................................................22
1.4.3. BALDINTZAZKO ERAGILEA (?:)...................................................................................22
1.4.4. ERLAZIOZKO ERAGILEAK............................................................................................23
1.4.5. ERAGILE LOGIKOAK......................................................................................................24
1.4.6. BIT ERAGILEAK...............................................................................................................25
1.4.7. ERAGILE UNITARIOAK...................................................................................................26
1.5. ERAGILEEN HIERARKIA........................................................................................................27
1.6. DATU MOTEN ARTEKO BIHURKETA (CAST).....................................................................29
1.7. IRUZKINAK...............................................................................................................................30
1.8. SCANNER KLASEA..................................................................................................................31
A ERANSKINA: ECLIPSE JUNO NOLA ERABILI........................................................................35
B ERANSKINA: ARIKETAK...........................................................................................................45
ARIKETA ERRAZAK...................................................................................................................45
ZAILTASUN ERTAINEKO ARIKETAK.....................................................................................46
ARIKETA ZAILAK.......................................................................................................................47
2. GAIA: OBJEKTUEI ZUZENDUTAKO PROGRAMAZIOA. OBJEKTUAK.............................49
2.1. SARRERA...................................................................................................................................50
2.2. OBJEKTUEI ZUZENDUTAKO PROGRAMAZIOAREN OINARRIAK................................51
2.2.1. KONTZEPTUAK................................................................................................................52
2.2.2. ONURAK............................................................................................................................53
2.2.3. EZAUGARRIAK.................................................................................................................53
2.3. KLASEAK ETA OBJEKTUAK..................................................................................................55
2.3.1. OBJEKTUEN PROPIETATEAK ETA METODOAK........................................................55
2.3.2. OBJEKTUEN INTERAKZIOAK.......................................................................................55
2.3.3. KLASEAK...........................................................................................................................56
2.4. OBJEKTUAK SORTU, ERABILI ETA SUNTSITU.................................................................58
2.4.1. OBJEKTUEN BIZIA...........................................................................................................57
2.4.2. OBJEKTUAK DEKLARATZEA ETA SORTZEA.............................................................58
2.4.3. OBJEKTUAK ERABILTZEA.............................................................................................59
2.4.4. OBJEKTUAK SUNTSITZEA.............................................................................................59
2.5. METODOAK ERABILTZEA.....................................................................................................60
2.5.1. PARAMETROAK ETA ITZULITAKO DATUAK.............................................................61
2.5.2. SORTZAILEAK..................................................................................................................62
2.5.3. THIS ERAGILEA................................................................................................................63
2.5.4. METODO ESTATIKOAK...................................................................................................66
2.6. PAKETEAK................................................................................................................................67
2.6.1. IMPORT AGINDUA...........................................................................................................70
2.6.2. JAVA LIBURUTEGIAK......................................................................................................71
A ERANSKINA: ARIKETAK...........................................................................................................72
ARIKETA ERRAZAK...................................................................................................................72
ARIKETA ZAILAK.......................................................................................................................73
ARIKETA OSOA...........................................................................................................................74
3. GAIA: OINARRIZKO KONTROL-EGITURAK.........................................................................77
3.1. SARRERA...................................................................................................................................78
3.2. SENTENTZIAK ETA BLOKEAK.............................................................................................79
3.3. HAUTAZKO EGITURAK..........................................................................................................83
3.3.1. IF ETA IF-ELSE..................................................................................................................84
3.3.2. SWITCH EGITURA............................................................................................................87
3.4. ERREPIKAPEN-EGITURAK....................................................................................................90
3.4.1. FOR EGITURA...................................................................................................................90
3.4.2. WHILE EGITURA..............................................................................................................93
3.5. DO/WHILE EGITURA...............................................................................................................95
3.5. JAUZI EGITURAK................................................................................................................97
3.5.1. BREAK ETA CONTINUE..................................................................................................97
3.5.2. ETIKETAK..........................................................................................................................99
3.5.3. RETURN SENTENTZIA..................................................................................................100
3.6. SALBUESPENAK....................................................................................................................102
3.6.1. SALBUESPENAK HARRAPATZEA...............................................................................103
3.6.2. THROWS...........................................................................................................................106
3.7. SOFTWARE-PROBAK............................................................................................................107
3.7.1. ZEHAZPENAK.................................................................................................................107
3.7.2. PROBA SAKONAK..........................................................................................................108
3.7.3. KUTXA BELTZAREN PROBAK....................................................................................108
3.7.4. KUTXA ZURIAREN PROBAK.......................................................................................108
3.7.5. BESTE PROBA MOTA BATZUK....................................................................................109
3.8. NOLA ERABILI DEBUG MODUA ECLIPSE-n.....................................................................110
3.9. KODEAREN DOKUMENTAZIOA.........................................................................................113
3.9.1. ETIKETAK ERABILI.......................................................................................................114
3.9.2. ETIKETAK ORDENATZEA.............................................................................................115
A ERANSKINA: ARIKETAK.........................................................................................................119
ARIKETA ERRAZAK.................................................................................................................119
ARIKETA ZAILAK.....................................................................................................................120
ARIKETA OSOA.........................................................................................................................122
4. GAIA: KLASEAK GARATZEA.................................................................................................123
4.1. SARRERA.................................................................................................................................124
4.1.1. OBJEKTU BAT ZER DEN ERREPASATZEN.................................................................124
4.2. ZER DA KLASE BAT?.............................................................................................................125
4.2.1. KLASE BAT DEKLARATZEA........................................................................................125
4.2.2 KLASEAREN BURUA......................................................................................................126
4.2.3 KLASEAREN GORPUTZA..............................................................................................127
4.2.4 KIDE ESTATIKOAK.........................................................................................................127
4.3. ATRIBUTUAK..........................................................................................................................128
4.3.1. ATRIBUTUAK DEKLARATZEA....................................................................................128
4.3.1.1. ATRIBUTUEN ALDARAZLEAK............................................................................129
4.3.1.2. ATRIBUTU ESTATIKOAK.......................................................................................131
4.4. METODOAK............................................................................................................................133
4.4.1. METODOAK DEKLARATZEA.......................................................................................133
4.4.2. METODOAREN BURUA................................................................................................134
4.4.3. METODOEN ALDARAZLEAK......................................................................................135
4.4.4. METODOEN PARAMETROAK......................................................................................137
4.4.5. METODOEN GORPUTZA...............................................................................................138
4.4.6. METODOAK GAINKARGATZEA..................................................................................142
4.4.7. THIS ERREFERENTZIA..................................................................................................143
4.4.8 .METODO ESTATIKOAK.................................................................................................144
4.5. ENKAPSULAZIOA, ATZIPEN KONTROLA ETA IKUSGAITASUNA...............................145
4.5.1. ATRIBUTUAK EZKUTATZEA........................................................................................145
4.5.2. METODOAK EZKUTATZEA..........................................................................................147
4.6. METODOAK ETA ATRIBUTUAK ERABILTZEA................................................................151
4.6.1. OBJEKTUAK DEKLARATZEA......................................................................................151
4.6.2. OBJEKTUAK SORTZEA.................................................................................................152
4.6.3. OBJEKTUAK ERABILTZEA...........................................................................................153
4.7. SORTZAILEAK........................................................................................................................155
4.7.1. SORTZAILEAK IDATZI..................................................................................................155
4.7.2. SORTZAILEAK ERABILI...............................................................................................156
4.7.3. KOPIA-SORTZAILEAK...................................................................................................158
4.7.4. OBJEKTUAK SUNTSITU................................................................................................159
4.8. HERENTZIA: SARRERA........................................................................................................160
4.8.1. HERENTZIA ERABILTZEN DUTEN KLASEAK SORTU ETA ERABILI...................161
A ERANSKINA: ARIKETAK.........................................................................................................162
ARIKETA ERRAZAK.................................................................................................................162
ARIKETA ZAILAK.....................................................................................................................163
ARIKETA OSOA.........................................................................................................................164
1. GAIA: INFORMATIKA-PROGRAMEN ELEMENTUAK
1.1. SARRERA
1.1.1. ZER DA JAVA
Java programazio hizkuntza bat da, objektuei zuzendua, eta arrakastatsua. Sun Microsystems
enpresak diseinatu zuen 1990eko hamarkadan, "Write once, run anywhere" filosofian
oinarrituta. Filosofia hori dela eta, Java plataforma anitzeko hizkuntza dela esaten da. Horrek
esan nahi du, Java Virtual Machine (JVM) bat tarteko, programa konpilatuta dagoenean
edozein sistema eragiletan exekutatzen dela.
1.1.2. PROGRAMA BATEN EGITURA OROKORRA
public class KaixoMundua {

/* KaixoMundua programa */
public static void main(String[] args) {
/*programa honek gauza bakarra egiten du: “KaixoMundua” katea pantailan atera*/
System.out.println("Kaixo, mundua!");
}
}
1.1.3. JDK (Java Development Kit)
Java Development kit Java garatzeko tresna-multzo bat da.

Javan programatzeko ez dugu, derrigorrez, garapen-ingurune integraturik behar: nahikoa da
JDK edukita.
JDKk ez dauka ingurune grafikorik programak garatzeko. Kontsolaren bitartez lan egiteko
tresnak dauzka. JDKren barruan JRE (Java Runtime Environment) dago. JREk aplikazio bat
exekutatzeko beharrezkoak diren osagaiak ditu: makina birtuala eta klase-liburutegiak.
1.1.3.1. JDK ESKURATU
http://www.oracle.com/technetwork/java/javase/downloads/index-jsp-138363.html
web-orrialdean aurkituko dugu JDKren azken bertsioa. Dohainik da handik JDK jaistea, baina
adi egon behar dugu gure sistema eragileari dagokion bertsioa aukeratzeko. Gure kasuan, 8u20
bertsioa jaitsi dugu 64 biteko Windows-erako.
1.1.3.2. JDK ERABILI
Instalatu ostean, bin karpeta non dagoen bilatuko dugu. Gure kasuan, helbidea hau da:
C:\Program Files\Java\jdk1.8.0_25\bin
Helbide hori Path ingurune-aldagaiari gehitu behar diogu. Horretarako, Windows 7 erabiltzen
badugu, pauso hauek eman behar ditugu:
Ordenagailua -> Klik eskuineko botoiarekin -> Propietateak -> Sistema-ezarpen aurreratuak ->
Aurreratua -> Ingurune-aldagaiak
Path aldagaia bilatuko dugu, eta Editatu sakatuko dugu. Agertzen den koadroan, testuaren
amaieraraino joango gara, “;” idatziko dugu komatxorik gabe, eta, ostean, gure bin karpetaren
helbidea.
Irudi honen antzeko zer edo zer geratuko da:
Behin helbidea gehituta, kontsola-sesio bat (cmd) zabalduko dugu, eta javac idatziko dugu.
Honelako zer edo zer atera beharko litzateke (Windows 7):
Aurreko irudiaren antzeko zerbait atera bazaizu, Java ondo instalatuta eta konfiguratuta
daukazu. Proba bat egiteko, KaixoMundua programa egin eta exekutatuko dugu.
Ohar-bloka zabalduko dugu, eta kode hau idatziko dugu:
1 class KaixoMundua
2 {
3 public static void main(String[] args)
4 {
5 System.out.println("KaixoMundua!");
6 }
7 }
Fitxategiak klasearen izen bera eduki behar du; beraz, “KaixoMundua.java” izenarekin gordeko
dugu. Nire kasuan, disko gogorreko proba direktorioan; hau da, "D:\proba\KaixoMundua.java".
Programa konpilatzeko, hau egingo dugu:
javac KaixoMundua.java
Horrek KaixoMundua.class fitxategia sortzen du (Javaren makina birtualak ulertzen duena).

Konpilatu dugun kodea exekutatzeko, hau idatziko dugu kontsolan:
java KaixoMundua (ez da fitxategi-luzapenik jartzen).
1.2. IDENTIFIKADOREAK ETA ALDAGAIAK
Programa batek datuak erabiltzen ditu hainbat lan egiteko: kalkuluak egiteko, datuok
inprimagailu edo pantaila bidez aurkeztu edo erabiltzaileari eskatzeko, diskan gordetzeko, etab.
Datu horiek, erabili ahal izateko moduan egon daitezen, programak aldagaietan gordetzen ditu.
Aldagaia: Ordenagailuaren memoriaren zati batean gordetzen den datua, behar denean
programan erabili ahal izateko.
Aldagai bat 3 propietatek definitzen dute:
1. Izenak
2. Datu motak
3. Onartzen dituen balioen heinak
Aldagaiari ematen zaion izenari identifikadore esaten zaio.

1.2.1. IDENTIFIKADOREAK
Javan, identifikadorea programatzaileak programa baten aldagai, konstante, klase, metodo edo
paketeei ematen dien izena da. Identifikadoreak honako ezaugarri hauek bete behar ditu:
- Lehen karakterea letra bat, azpimarra karakterea, _, edo dolar karakterea, $, izan behar da.
- Hurrengo karaktereak letrak edo zenbakiak izan behar dira.
- Ezin da programazio-hizkuntzaren hitz erreserbaturik erabili.
Javak maiuskulen eta minuskulen artean bereizten du, eta hori kontuan hartu behar da
identifikadoreak sortu eta erabiltzean.
Nahiz eta araurik ez egon, emango zaien erabileraren arabera, egon badago mundu osoan
onartzen den hitzarmen bat identifikadoreak izendatzeko:
Identifikadorea Hitzarmena Adibidea
Aldagaiaren izena Minuskulaz hasten dira. Hitz batuketa, ikasleKopurua

batez baino gehiagoz
osatuta badago, elkarren
ondoan eta maiuskulaz
hasita doaz gainerako hitzak.
Konstantearen izena Dena maiuskulatan. Hitzak PI, TAMAINA_MAX

behe-marraz banatzen dira
Klasearen izena Maiuskulaz hasten dira Pertsona, Karratua
Metodoaren izena Minuskulaz hasten dira aldatu_Balioa,

abiadura_Eskuratu
1.2.2. HITZ ERRESERBATUAK
Programazio-hizkuntzan erabiltzeko erreserbatzen dira eta, beraz, ezin dira identifikadore

modura erabili.
Javan, hitz hauek daude erreserbatuta:
1.2.3. ALDAGAI MOTAK.
Programa batean, hainbat aldagai mota aurki ditzakegu: gordetzen duten datu motaren
araberakoak, beren balioa programan zehar aldatu edo berdin mantentzearen araberakoak…
Javan, aldagai mota hauek bereiz daitezke:
a) Oinarrizko datu motak gordetzen dituzten aldagaiak eta erreferentzia-aldagaiak: Aldagai bi

hauek gordetzen dituzten datuen moten arabera sailkatzen dira.
b) Aldagarriak eta konstanteak:
Aldagarria. Datuak gordetzeko erabiltzen da. Datuaren balioa hainbat alditan alda daiteke
programa exekutatzen den bitartean.
Konstanteak edo aldagai finalak. Izenak berak dioenez, hauen balioa ez da aldatzen, jakina,
programa exekutatzen den bitartean.
c) Aldagai klasekideak eta aldagai lokalak, programan sortzen diren tokiaren arabera.
Aldagai klasekideak: Klase jakin baten barruan sortzen diren aldagaiak dira, baina metodoetatik
kanpo.
Aldagai lokalak: Metodo edo beste kode-bloke baten barruan sortu eta erabiltzen direnak.
Metodo edo kode-blokea amaitzean, aldagaia desagertu egiten da.
ADIBIDEA
public class AldagaiAdibidea{
final double PI = 3.1415927; // PI konstantea da

int x // x AldagaiAdibidea klasearen
//aldagai klasekidea da
int eskuratuX (int x){ // x parametro bat da
int balioZaharra = this.x; // balioZaharra aldagai

//lokala da
return balioZaharra;
}
Aldagai hauek dituen klase bat sortu dugu:
PI: Aldagai finala edo konstantea. Balio finkoa du; beraz, ez da haren balioa aldatuko programa
osoan zehar.
x: Aldagai klasekidea. AldagaiAdibidea izeneko klasearen barruan dago eta gordetzen dituen
datuak int motakoak dira. Hainbat balio har ditzake programan zehar, normalean klase berean
sortutako beste metodo baten bidez.
balioZaharra: Aldagai lokala. Aldagai hau lokala da, eskuratuX metodoaren barruan sortuta
dagoelako. Metodo horretatik kanpo, aldagaia ez da existitzen.
1.3. DATU MOTAK
Javan, edozein daturi (konstantea, aldagaia ala adierazpena) datu mota bat dagokio.
Datu motak datuak zer-nolako balioak har ditzakeen mugatzen du, baita datu horiekin zer
eratako eragiketak egin daitezkeen ere. Datu-motek ahalbidetzen dute interprete edo
konpilatzaileek aldez aurretik jakitea aldagai edo konstante batek zer motatako informazioa
gordetzen duen.
Aurrerago ikusiko dugunez, Javak datu moten artean KONBERTSIOA egitea onartzen du.
Datu motak, Javan, 2 kategoriatan sailkatzen dira:
Oinarrizkoak. Datu mota hauek gordetzen dituzten aldagaiek balio sinpleak hartzen dituzte.
Adibidez, zenbaki bat edo karaktere bat.
Erreferentziazkoak. Datu mota hauetan gordetako aldagaiek ez dute gordetzen zuzenean

balioa edo balio multzoa. Memoria-helbide bat gordetzen dute, eta helbide horrek adierazitako
gunean dago balioa. Horrelakoak dira beste atal batean ikusiko ditugun array, klase edo
interfazeak.
1.3.1. OINARRIZKO DATU MOTAK I
Zenbakiak, karaktereak edo balio logikoak (boolearrak) gordetzeko erabiltzen dira. Javan, datu
mota hauek ez dira objektuak.
Adierazitako Heina Azalpena

Datu mota
informazioa
8 bit erabiltzen dira
byte Zenbaki osoak - 128 ------ +127 datua gordetzeko

short Zenbaki osoak - 32768 ------ +32767 datua gordetzeko

int Zenbaki osoak - 2147483648 ------ datua gordetzeko
+2147483647

long Zenbaki osoak - 9223372036854775808
datua gordetzeko
------ +
9223372036854775807
Zenbakiak UNICODE
char UNICODE karaktereak 0 ------ 65535 bidez adierazteko
erabiltzen da.
Koma mugikorreko 7 digituko zehaztasuna Bit 1 zeinurako, 11 bit
float datuak gutxi gorabehera. berretzailerako eta 24
(32 bit) mantisarako.
Koma mugikorreko 16 digituko Bit 1 zeinurako, 11 bit
double datuak zehaztasuna gutxi berretzailerako eta 52
(64 bit) gorabehera. mantisarako.
Adierazpen boolear
boolean Balio logikoak true/false bat egia (true) edo
faltsua (false) den
adierazteko erabiltzen
da.
ADIBIDEA
public class Adibidea {

//aldagaiak deklaratu
byte hil = 12;
int kontagailua = 0;
double pi = 3.1415926535897932384626433832795;
float interesa = 4.25e2F;
char letra = 'Z';
boolean aurkituta = true;
//balioak inprimatu
System.out.println(hil); //12 inprimatuko du
System.out.println(kontagailua); //0 inprimatuko du
System.out.println(pi); //3.141592653589793 inprimatuko du
System.out.println(interesa); //425.0 inprimatuko du
System.out.println(letra); //Z inprimatuko du
System.out.println(aurkituta); //true inprimatuko du
}
}
Kontuan izan behar dugu Java konpilatzaileak char datu mota zenbakizkotzat hartzen duela.
Horren azalpena erraza da: ez du gordetzen karaktere bat, zenbaki bat baizik, karaktere
bakoitzari UNICODE kodean dagokion zenbakia hain zuzen.
Bestalde, oso garrantzitsua da egoki aukeratzea zein datu mota erabiliko dugun. Horretarako,
kontuan hartu beharko dugu zer informazio (zenbakiak, testua...) gorde nahi dugun, eta hartu
ditzakeen balioen heina ere bai. Arrazoi horrengatik, batzuetan, agian, zenbaki errealak
gordetzeko erabiltzen den datu mota erabili beharko dugu, nahiz eta zenbaki osoekin lan egin.
Esate baterako, int mota erabilita ezin da lurraren populazioa adierazi, har dezakeen baliorik
altuena 2.147.483.647 baita (32 bit birako osagarrian). Lurraren populazioa 7.000 milioi
biztanlekoa da, beraz, long motako datua erabili beharko dugu, gutxienez.
1.3.2. OINARRIZKO DATU MOTAK II
Datu mota errealak zenbaki errealak adierazteko erabiltzen dira. Javan, 2 daude: float (32 bit)
eta double (64 bit). Bit gehiago erabilita, bi helburu hauek lortzen dira:
• Zenbaki handiagoak adieraztea

• Zati hamartarra zehatzagoa izatea
Java-programatzaile gehienek double datu mota erabiltzen dute. Horrela eginda, gutxiagotu
egiten dira zenbaki hamartarrak biribiltzean sortzen diren erroreak.
1.3.3. ALDAGAI ETA KONSTANTEAK DEKLARATZEA ETA

HASIERATZEA
Dagoeneko, badakigu zer diren aldagaiak eta konstanteak. Baina hori ez da nahikoa, eta, pare
bat galdera etortzen zaizkigu burura: Nola sortzen dira aldagaiak programa batean? Zer egin
behar da programa batean aldagaiak erabili ahal izateko?
Programa batean aldagaiak erabili ahal izateko, aldagaiak berak sortu behar dira lehendabizi:
izen bat eman eta zer informazio mota gordeko duten adierazi; hau da, aldagaia deklaratu.
Hona hemen adibide bat:
int ikasleKop = 15;

double radio = 3.14, guztira = 102.95;
Aurreko adibidean, 3 aldagai deklaratu ditugu:

ikasleKop int motakoa, eta radio eta guztira double motakoak. Ikusten denez, bi aldagai datu
mota berekoak direnean, aski da behin bakarrik adierazita eta bi aldagaiak koma baten bidez
banatuta.
Gainera, nahiz eta derrigorrezkoa ez izan, aurreko aldagaiak deklarazioan bertan hasieratu
ditugu: 15, 3.14 eta 102.95 hasierako balioak emanda, hurrenez hurren.
Aldagaia, aldaketarik jasango ez badu programa osoan zehar, konstante bezala deklaratuko
dugu. Konstanteak final hitz erreserbatua erabilita deklaratzen dira:
final double PI = 3.1415926536;
Zer gertatzen da aldagai bat hasieratzen ez badugu? Aldagai motaren arabera, bi gauza gerta
litezke:
• Aldagai-klasekideak: automatikoki hasieratzen dira baliorik ematen ez badiegu:

- zenbakizkoak 0 batekin.
- char motakoak null moduan.
- boolearrak false moduan.
- Erreferentziak null moduan.
•Aldagai lokalak ez dira automatikoki hasieratzen. Hurrengo adibidean, p izeneko
aldagaia deklaratzen da, baina hasieratu gabe. Gero, q izeneko aldagaia deklaratzen
da eta p aldagaiaren balioarekin hasieratzen da. Zer gertatzen da orduan? p
aldagaiak baliorik ez daukanez, programa konpilatzean, konpilatzaileak errore bat
erakutsiko digu.
int p;
int q = p; // error
1.4. ERAGILEAK ETA ADIERAZPENAK
Eragileek hainbat ariketa egiten dituzte datuekin edo eragingaiekin. Erabilitako eragingaien
arabera, adierazpenak batarrak, bitarrak edo hirutarrak izan daitezke.
1.4.1. ERAGILE ARITMETIKOAK
Eragile aritmetikoek, eragingaiak konbinatuz, adierazpen aritmetikoak osatzen dituzte.
Eragilea Eragiketa Javan Adierazpena Javan Emaitza
+ Batuketa 1.2 + 9.3 10.5
- Kenketa 312.5 – 12.3 300.2
* Biderketa 1.7 * 1.2 2.04
/ Zatiketa 0.5 / 0.2 2.5
% Hondarra 25 % 3 1
1.4.2. ESLEIPEN-ERAGILEAK
Esleipen-eragileen funtzioa programak aldagai bati balioa ematea da. Esleipen-eragilerik

erabiliena = da. Javak beste esleipen-eragile batzuk ere eskaintzen ditu.
Eragilea Adibidea Javan Adierazpen baliokidea
+= op1 += op2 op1 = op1+op2
-= op1 -= op2 op1 = op1-op2
*= op1 *= op2 op1 = op1*op2
/= op1/= op2 op1 = op1/op2
%= op1 %= op2 op1 = op1%op2
= op1 = op2 op1 = op2
1.4.3. BALDINTZAZKO ERAGILEA (?:)
Baldintza bat ebaluatzen du eta emaitza bat itzultzen du, baldintza hori egia ala gezurra den
ikusita. Eragile hirutar bakarra da; hau da, 3 eragingai behar ditu adierazpen bat sortzeko.
Lehen eragingaia galdera ikurraren ezker aldean kokatzen da, eta adierazpen boolearra izan
behar du (baldintza).
Bigarren eragingaia galdera ikurraren eta bi puntuen artean kokatzen da; eta baldintza egia
bada, eragileak bigarren eragingai horren balioa itzultzen du emaitza moduan.
Hirugarren eragingaia bi puntuen atzean kokatzen da; eta baldintza gezurra bada, hirugarren
eragingai horren balioa itzultzen du eragileak emaitza moduan.
Baldintza ? Emaitza egia : emaitza gezurra
Adibidez:
(x>y) ? x : y
Kasu honetan, lehenengo, x aldagaia y aldagaia baino handiagoa den ebaluatzen da. Hala bada,
eragileak x aldagairen balioa itzuliko du; bestela, y aldagaiarena.
Egia esateko, eragile hau ez da askorik erabiltzen. Normalean, hurrengo atalean ikusiko dugun,
if..then..else sententzia erabiltzen da.
1.4.4. ERLAZIOZKO ERAGILEAK
Erlaziozko eragileak mota sinpleko datuak konparatzeko erabiltzen dira. Adierazpen hauen
emaitza boolear motakoa izango da beti: true ala false.
Eragilea Adibidea Javan Esanahia
< A<B A txikiagoa da B baino
> A>B A handiagoa da B baino
<= A <= B A txikiagoa da B baino

edo berdina
>= A >= B A handiagoa da B baino

edo berdina
!= A != B A eta B desberdinak
== A==B A eta B berdinak

1.4.5. ERAGILE LOGIKOAK
Eragilea Adibidea Esanahia

Javan
! !A Not A. Eragingaia TRUE bada, emaitza FALSE da; eta eragingaia

FALSE bada, emaitza TRUE da.
& A&B A AND B. Bi eragingaiak TRUE badira, emaitza TRUE da. Bestela,
emaitza FALSE da.
| A|B A OR B. Bi eragingaiak FALSE badira, emaitza FALSE da. Bestela,

emaitza TRUE da.
^ A XOR B. Eragingai bat TRUE bada eta bestea FALSE bada,

emaitza TRUE da. Bestela, emaitza FALSE da.
&& A&&B A&B bezalakoa, baina lehenengo eragingaia FALSE bada, ez du

bigarrena balioztatzen.
|| A|B bezalakoa, baina lehenengo eragingaia TRUE bada, ez du

bigarrena balioztatzen.
1.4.6. BIT ERAGILEAK

Javan
| A|B OR eragiketa
& A&B AND eragiketa
^ A^B XOR eragiketa
<< A << B A ren bitak ezkerrera mugitzen ditu, B balioak esaten duen
adina posizio. Eskuinetik zeroak jartzen ditu mugitutako balioen
tokian.
>> A >> B A ren bitak eskuinera mugitzen ditu, B balioak esaten duen
adina posizio. Ezkerretik zeinuaren bita jartzen du mugitutako
balioen tokian.
>>> A >>> B A ren bitak eskuinera mugitzen ditu, B balioak esaten duen
adina posizio. Ezkerretik zeroak jartzen ditu mugitutako balioen
tokian.
1.4.7. ERAGILE UNITARIOAK

Javan
~ ~A A-ren baterako osagarria
- -A Eragingaiaren zeinu aldaketa
-- A-- A gutxitzea
++ A++ A-ren gehikuntza
! !A A-ren ezberdina.
1.5. ERAGILEEN HIERARKIA
Eragileen hierarkiak hau adierazten digu: Eragiketak zein ordenatan egin behar diren hainbat
motatako eragileak daudenean.
Javako arauak aljebrako ohiko arau berberak dira. Adibidez:
- Lehenik eta behin biderketa, zatiketa eta hondarra ebaluatzen dira. Adierazpen batean, era
horietako hainbat eragiketa badago, ezkerretik eskuinera ebaluatuko dira.
- Batuketa eta kenketa aurrekoen atzetik ebaluatzen dira. Adierazpen batean, hainbat batuketa
eta kenketa badago, ezkerretik eskuinera ebaluatuko dira.
Adierazpen bat ebaluatzeko, aintzat hartu behar dira eragingaien elkartze-propietateak.
Elkartze-propietateak zera esaten digu: lehentasun beraren aurrean, zein eragingai ebaluatzen
den lehenen. Esleipen-eragileak, baldintzazko eragilea, eragile inkrementalak (++,--) eta
kasting-a eskuinetik elkartzen dira. Gainontzeko guztiak, ezkerretik; hau da, idatzita dauden
noranzko berberean kalkulatzen dira.
Adibidez:
10 / 2 * 5
Aurreko kasuan, lehenengo 10/2 egiten da, eta gero, emaitza *5. Kasu honetan, bi eragileek
lehentasun bera daukatenez, ezkerretik eskuinera egiten da. Adierazpenaren emaitza 25 da.
Elkarketa eskuinetik egingo balitz, lehenengo 2*5 egingo genuke, eta gero, emaitza zati 10.
Emaitza 1 izango litzateke.
x=y=z=1
Egiten dena x = ( y = ( z = 1 ) ) da. Lehenik eta behin, z aldagaiak 1 balioa hartzen du. Gero y
aldagaiak z aldagaiaren balioa (1), eta azkenik x aldagaiak y aldagaiaren balioa (1).
Elkarketa ezkerretik egingo balitz, lehen pausoan x = y egiten saiatuko ginateke, baina
ezinezkoa izango litzateke, y aldagaia hasieratuta ez dagoelako; hau da, baliorik ez duelako.
Hurrengo taulan, eragileen hierarkia eta elkartzeko modua daude jarrita.
Eragileak lehentasunaren arabera antolatzen dira, handiena duenetik txikiena duenera:
1.6. DATU-MOTEN ARTEKO BIHURKETA (CAST)
Pentsatu bi zenbakiren arteko zatiketa egin nahi dugula. Izango ote du zenbaki hamartarrik
zatiketa horren emaitzak? Baietz pentsatuko dugu zatikizuna zatitzailearen multiploa baldin ez
bada. Eta mundu errealean hala da; baina informatikoan ez dago zertan horrela izan. Javan,
zatikizuna eta zatitzailea zenbaki osoak badira, zatidura ere zenbaki osoa izango da; hau da,
zenbaki hamartarrik gabea, besterik esan ezean.
Emaitzak zenbaki hamartarrak izan ditzan, datu motaren bihurketa bat egin beharra dago; hau
da, emaitza guk nahi dugun motakoa izan dadin, datu moten bihurketa egiten da.
Bi bihurketa mota daude:
1. Berehalako bihurketak: Berehalako bihurketa deritzo datu mota bateko aldagai

bati bit gutxiagoko beste datu mota bateko balio bat esleitzea. Adibidez, double
motako aldagai bati float motako balio bat esleitzen zaionean, balio hori double
datu motara bihurtzen da programatzaileak ezer egin gabe.
2. Bihurketa esplizituak: Programatzaileak espresuki egiten du bihurketa Cast

eragilea erabilita. Cast eragilea batarra da. Bihurtu nahi den datuaren aurrean
kokatzen da, datu mota parentesi artean jarrita. Cast eragilearen lehentasuna
eragile batarrena da, eta ezkerretik eskuinera elkartzen da.
Adibideak:
Okerra
int a;
byte b;
a = 12;
b = a; // errorea, ez dago baimenduta b-ko datu mota a-ko datu mota baino txikiagoa
delako:
Zuzena
int a;
byte b = (byte) a;
1.7. IRUZKINAK
Iruzkinak oso garrantzitsuak dira programa batek zer egiten duen deskribatzeko,
unitatean zehar erabili izan ditugun adibideetan idatzi dugun kodea hobeto
ulertzeko. Normalean, programak iruzkin-lerro batzuekin hasten dira. Lerro
horietan, programak zer egiten duen, nork idatzi duen eta azken aldaketaren data
idatzi ohi dira.
Javan, honako iruzkin mota hauek aurki ditzakegu:
Lerro bateko iruzkinak: // mugatzailea erabiltzen da
// lerro bateko iruzkina
Hainbat lerrotako iruzkinak: /* paragrafoaren hasieran eta */ paragrafoaren

amaieran.
/* hau hainbat lerrotako

iruzkin bat da */
Javadoc iruzkinak: /** eta */ mugatzaileak erabiltzen ditu. Dokumentazio

automatikoa sortzeko erabiltzen dira, javadoc programaren bidez.
1.8. SCANNER KLASEA
Orain arte ikusi ditugun adibideetan, aldagaiak sortu egin ditugu eta balioren
batekin hasieratu ditugu. Modu hori ez da desegokia adibideak ikusteko; baina,
gure programetan, erabiltzaileak sartuko ditu balio horiek normalean. Kasu
horretan, erabiltzaileak parte hartzea nahi dugunez, Scanner klasea erabil
dezakegu.
Oraindik ez dakigu klaseak eta paketeak zer diren. Horrek ez gaitu arduratu behar:
Scanner klasea teklatu bidez sartutako datuak irakurtzeko erabiltzen da, eta erabili
ahal izateko pakete bat inportatu behar da.
Programa batean, Scanner klasea erabiltzeko beharrezkoak diren urratsak hauek

dira:
1. Paketea inportatu
Scanner klasea java.util paketearen barruan dago; beraz, programaren hasieran

hau idatziko dugu:
import java.util.Scanner;
2. Scanner objektu bat sortu
Scanner objektu bat sortu eta sarrerako gailuarekin erlazionatu behar dugu.
Sarrerako gailua teklatua bada, hau idatziko dugu:
Scanner sc = new Scanner(System.in);
Egin dugunarekin sc objektua sortu dugu, eta teklatuarekin erlazionatuta dago

(System.in).
Hemendik aurrera, programak irakurri ditzake teklatu bidez sartutako datuak.
Irakurketa adibideak:
Datuak irakurtzeko erabiliko dugun metodoa hau izango da: nextXxx(). Xxx-k datu
mota adierazten digu: nextInt(), nextDouble()...
Teklatu bidez sartutako zenbaki oso bat irakurtzea:

int n; // n aldagaia sortuko dugu
System.out.print("sartu zenbaki oso bat: "); // pantailan mezu bat aterako dugu
n = sc.nextInt(); // erabiltzaileak sartutako datua n aldagaian gordeko dugu.
Teklatu bidez sartutako zenbaki erreal bat irakurtzea:

double x; // x aldagaia sortuko dugu
System.out.print("Sartu zenbaki erreal bat: "); // pantailan mezu bat aterako dugu
x = sc.nextDouble(); erabiltzaileak sartutako datua n aldagaian gordeko dugu.
Teklatu bidez sartutako karaktere-kate bat irakurtzea:

String s; // s aldagaia sortuko dugu
System.out.print("sartu testua: "); // pantailan mezu bat aterako dugu
s = sc.nextLineDouble; //erabiltzaileak sartutako datua s aldagaian gordeko dugu.
Scanner klasea erabiltzen duen programa oso bat:

Programak pertsona baten izena eskatzen du, eta erabiltzaileak sartzen duen izena
pantailan erakutsiko du. Gero, zirkunferentzia baten erradioa irakurriko du (double
datu motakoa), eta zirkunferentziaren luzera erakutsiko du pantailan. Azkenik,
zenbaki oso bat irakurriko du, eta haren karratua erakutsiko du.
public class Main {
Scanner sc = new Scanner(System.in); //Scanner objektua sortzea
String izena;
double erradioa;
int n;
System.out.print("Tekleatu zure izena: ");
izena = sc.nextLine(); //String bat irakurtzea
System.out.println("Kaixo " + izena + "!!!");
System.out.print("Sartu zirkunferentziaren erradioa: ");
erradioa = sc.nextDouble(); //double bat irakurtzea
System.out.println("Zirkunferentziaren luzera:" + 2*Math.PI*radio);
System.out.print("Sartu zenbaki oso bat: ");
n = sc.nextInt(); //int bat irakurtzea
System.out.println("Zenbakiaren karratua: " + Math.pow(n,2));
}
}
Nola funtzionatzen du Java Scanner klaseak?
Teklatu bidez karaktereak sartzen direnean, Scanner objektuak osorik hartzen du

sartutako katea eta osagaitan zatitzen du: token-ak.
Token-ak banatzen dituen karakterea zuriunea da.
Testu hau sartzen badugu:

Hau adibidea da. Datuak irakurtzea.
Scanner objektuak katea zatituko du, eta token hauek sortuko:
Hau
adibidea
da.
Datuak
irakurtzea.
Dagoeneko ikusi dugu nextXxx() metodoa. Scanner klaseak beste metodo batzuk
ere eskaintzen dizkigu. Erabilienetako batzuk taulan daude:
Metodoa Esanahia
nextXXX() Osteko tokena itzultzen du oinarrizko datu mota moduan.
xxx datu mota da. Adibidez, nextInt() zenbaki oso bat
irakurtzeko, nextDouble double bat irakurtzeko, etab.
next() Hurrengo tokena itzultzen du String moduan.
nextLine() Lerro osoa itzultzen du String moduan. Intro karakterea
garbitzen du.
hasNext() Boolear bat itzultzen du. Irakurtzeko beste tokenik geratzen
den ala ez adierazten du.
hasNextXXX Boolear bat itzultzen du. Irakurtzeko beste tokenik geratzen
den ala ez adierazten du, baina datu mota jakin batekoa.
Adibidez: hasNextDouble()
Kontuz ibiltzeko
Programa batean zenbakiak eta testua irakurtzen direnean, kontuan eduki behar
dugu batzuen eta besteen artean intro tekla sakatzen dugula eta intro hori
bufferrean geratzen dela.
Adibidea:
Sarrerako bufferra, 5 bat sartu ondoren: 5\n
Ondorengo instrukzioa:
n = sc.nextInt();
n-k 5 balio du, baina intro-a bufferrean geratu da.

Sarrerako bufferra, zenbaki osoa irakurri ondoren: \n
Orain String bat sartzeko eskatuko dugu:
System.out.print("Sartu zure izena: ");

izena = sc.nextLine(); //String bat irakurtzea
nextLine() metodoak karaktere guztiak itzultzen ditu intro batera heldu arte, eta
gero, ezabatu egiten du bufferretik intro hori.
Aztertzen ari garen kasuan, izena aldagaiari kate hutsa esleituko genioke eta introa
garbituko luke. Hori eginda, programa geldirik geratuko litzateke.
Konponbidea:
Bufferra garbitu egin behar da String datuak irakurri behar baditugu zenbakizko
datuak irakurri ondoren.
Bufferra garbitzeko erarik errazena:
sc.nextLine();
A ERANSKINA: NOLA ERABILI ECLIPSE JUNO
Eclipsek funtzionatzeko gure ordenagailuan egon behar du, baina ez dago instalatu
beharrik; izan ere, portablea da. Gainera, Eclipse Juno ibili dadin, Java instalatuta izan
behar dugu. Prozedura berdina da sistema eragile guztietan: Windows-en, Linux-en zein
MacOS-en.
Fitxategi konprimatua jaitsi ondoren, gorde nahi dugun tokian kopiatu eta deskonprimatu
egingo dugu.
Eclipse.exe zabalduko dugu, eta programa abiatuko da. Eclipserekin programatutako
proiektuak Workspace izeneko karpeta batean gordeko dira, eta beraz, programak
workspace-ren helbidea eskatuko digu. Karpeta horrek ez dauka eclipseren beraren barruan
egon beharrik.
Nahi dugun karpeta aukeratu, eta onartu egingo dugu.
Programaren hasierako pantaila honelakoa da:
Hasi
gaitezen lehen Java proiektua sortzen. Horretarako, File -> New -> Java Project aukeratu, eta
Project Name aukeran proiektuaren izena idatziko dugu. Gainerako aukerak dauden bezala
utzi daitezke.
Hasteko, Finish aukeratuko dugu, eta aukera gehiago aldatu behar izanez gero, Next
botoia sakatuko genuke. Ezkerreko aldean, karpeta bat agertuko da. Gezia aukeratzen
badugu, barruan dauzkan azpikarpetak ikusiko ditugu. Gure Java programak src (source
iturria da ingelesez) karpetan egongo dira.
src karpeta aukeratuta, eskuineko botoia sakatuko dugu edo File menua aukeratu, eta
gero, New -> Class. Beste aukera bat da biribil berde baten barruan C bat eta batuketa
ikur bat dauzkan botoia sakatzea.
Agertzen den elkarrizketa-koadroan, klasearen izena jarriko dugu. Komeni da azken aukerak
markatuta egotea, “constructors from superclass” izan ezik.
Klasea sortutakoan, hau agertuko zaigu:
Amaitzeko, froga txiki bat egingo dugu: main (exekutatzen den metodoa) metodoaren
barruan testu hau idatziko dugu: System.out.println(“Kaixo Mundua”);
“Play” ikonoa sakatu, eta idatzi dugun kodea exekutatuko da. Konpilazio-errorerik balego,
kodea ez litzateke exekutatuko eta errore mezua aterako litzateke.
“Console” fitxan, aurreko programak bistaratu behar duen mezua agertuko da. Fitxa ez
balitz ikusiko, aukeratu Windows -> Show View -> Console.
Kodea idatzi ahala, erroreak edo abisuak (warning) ager daitezke. Erroreak gorriz
azpimarratuta agertuko dira, eta abisuak, horiz. Programan errorerik badago, ezin izango
dugu hura exekutatu; abisuekin, ordea, bai.
Erroreak eta abisuak “Problems” fitxan agertuko dira.
Proiektuak ezabatzeko hau egin behar da: Aurrena, ezabatu nahi ditugun proiektuak
aukeratu behar ditugu, eta gero, supr botoia sakatu. Gauza berdina lortuko dugu
xaguaren eskuineko botoia sakatzen badugu, eta gero, delete aukeratuta. Ez da
derrigorrezkoa proiektu osoa ezabatzea. Nahi badugu, fitxategi bakarra aukera dezakegu
eta hura bakarrik ezabatu.
OHARRA: garrantzitsua da ezabatzerakoan “delete projects on disk” aukera markatuta

uztea. Horrela ez badugu egiten, proiektua Eklipsetik bakarrik ezabatuko da, baina ez
workspacetik; hau da, ez da ezabatuko disko gogorretik. Proiektua disko gogorrean
geratzen bada, izen bera daukan beste proiektu bat sortu nahi badugu etorkizunean,
Eclipsek ez digu sortzen utziko.
Bestalde, Eclipsek aukera ematen digu fitxategiak kopiatzeko proiektu batetik beste
batera, fitxategiak arrastatuta.
Inportatu eta esportatu kontzeptuak garrantzitsuak dira. Egindako zenbait proiektu beste
leku batetara eramateko, esportatu egingo ditugu. Hori egiteko, File menuan klikatu, eta
Export -> General -> Archive File eta Next botoian klikatuta, nahi ditugun proiektuak
aukeratuko ditugu. “To archive file” aukeran hautatuko dugu proiektuak zein karpetatan
gorde.
Finish aukeratu, eta esportatu egingo da.

Esportazioaren kontrakoa inportazioa da. Hori egiteko, File -> import -> Existing Projects
into Workspace aukeratuko dugu, eta agertuko den pantailan, Select archive file.
Behin Finish aukeratuta, proiektuak gure workspaceren barruan izango ditugu.

B ERANSKINA: ARIKETAK
ARIKETA ERRAZAK
1. Identifikatu programa honen atalak:
package perimetroa;
/* zirkulu baten perimetroa kalkulatzen duen programa*/
/**
*
* @author Administradorea
*/
public class Main {
double erradio=2,emaitza;
final double PI=3.1416; emaitza=2*PI*erradio; System.out.println("Emaitza "+ emaitza);
}
}
2. Zer emaitza lortzen da programa zati hau exekutatuta?
int a=3,b=2;
System.out.println(“Batuketa: “+a+”+”+b+”: “+a+b);
3. a=10 eta b=3 int motako aldagaiak dira. A1=12.5 eta b1=2.0 double motako aldagaiak
dira.
Zeintzuk emaitza lortuko ditugu eragiketa hauek eginda?
a) a/b
b) a%b
d) a1/b1
e) a1%b1
f) a1/b
g) a1%b
ZAILTASUN ERTAINEKO ARIKETAK
1. Egin ezazu programa bat Javan. Programak zenbakizko 4 aldagai deklaratuko eta
hasieratuko ditu. Gero, kalkulu hauek egingo ditu:
a) 4 zenbakien arteko batuketa.

b) Lehenengo zenbakia bider 10.000.
c) Bigarren zenbakia zati hiru eginda lortzen den zatidura, hamartar eta guzti.
d) Hirugarrenaren eta laugarrenaren arteko zatiketaren zatiduraren zati osoa.
e) Lehenengoaren eta bigarrenaren arteko zatiketaren hondarra.
2. Egin aurreko ariketa, baina oraingoan 4 zenbaki errealekin.
3. Idatz ezazu hiru zenbaki osoren batez bestekoa kalkulatuko duen programa bat.
4. Idatz ezazu 5 cm-ko aldea duen karratu baten azalera eta perimetroa kalkulatuko
dituen programa bat.
5. Banketxe batean, 5000 euro sartu ditugu. Banketxe horrek urteko % 6ko interesa
ordaintzen digu. Idatz ezazu urte beteren buruan zenbat diru izango dugun kalkulatuko
duen programa bat.
6. Idatz ezazu radianetan emandako angelu bat graduetara pasatuko duen programa bat.
(180 gradu = ∏ radian). Erabil ezazu ∏ konstante moduan.
7. Programa bat idatzi behar duzu. Programa horrek kalkulatu beharko du zenbat
handituko den 10.000 euroko inbertsio bat hiru urteren buruan, jakinda lehenengo
urtean % 10eko interesa emango digutela, bigarren urtean 500 euro galduko ditugula eta
% 12 handituko dela hirugarren urtean. Erabil itzazu esleipen eragile bereziak.
8. Programa bat idatzi behar duzu. Programa horrek Celsius graduetara pasatuko ditu 86
gradu Farhenheit eta 33 gradu Celsius, berriz, Farhenheit graduetara.
ARIKETA ZAILAK
1. Ikasle batek Programazio moduluan bere azken nota zein izango den jakin nahi du.
Nota, ondorengo batez bestekoen arabera kalkulatzen da:
• Hiru azterketa partzialen batez bestekoaren % 55a.
• Azken azterketan lortutako notaren % 30a.
• Azken lanean lortutako notaren % 15a.
Eskatu itzazu beharrezkoak diren notak, erabiltzaileak teklatuaren bidez sar ditzan eta
idatzi azken nota kalkulatuko duen programa.
2. Irakasle batek talde bateko gizon eta emakumeen ehunekoa jakin nahi du. Talde
horretan 3 emakume eta 22 gizon daude.
3. Ospitale batean hiru gune daude: ginekologia, pediatria eta traumatologia.

Ospitalearen urteko aurrekontua 120.000 eurokoa da, eta era honetan banatzen da:
Gunea Aurrekontuaren portzentaia

Ginekologia % 40
Traumatologia % 30
Pediatria % 30
Gune bakoitzak zenbat diru jasoko duen kalkulatzea eskatzen da.
4. Zenbatean saldu behar du produktu bat % dendari batek 30eko onura jasotzeko?
Erosketa-prezioa teklatu bidez sartu beharko du erabiltzaileak.
5. Saltzaile batek irabazten duen soldata garbia kalkulatuko duen programa egitea
eskatzen da. Horretarako, kontutan hartu behar dira kontzeptu hauek:
• Soldata finkoa.
• Komisioa: Saldutakoaren % 5a
• Kilometroak: Euro bat kilometro bakoitzeko
• Bidaia-sariak: 60 euro bidaia-egun bakoitzeko
• Gizarte Segurantzaren atxikipena: 150 euro
• PFEZ (Pertsona Fisikoen Errentaren Gaineko Zerga): % 18
Deklara itzazu beharrezkoak diren aldagaiak eta eskatu balio guztiak erabiltzaileari.
6. Bi zenbaki emanda, idatz ezazu lehenengoa bigarrenaren multiploa den erabakiko

duen programa bat. Bi zenbakiak teklatu bidez sartuko ditu erabiltzaileak, eta programak
mezu baten bidez esango du emaitza baiezkoa ala ezezkoa den.
7. Idatz ezazu lehen mailako ekuazioak ebatziko dituen programa bat. Ekuazioaren
koefizienteak (K1 eta K2) teklatu bidez sartuko dira.
K1x + K2 = 0
8. Bost zifrako zenbaki bat emanda (teklatu bidez sartuko du erabiltzaileak), zenbakia
zifratan deskonposatuko duen programa bat idatzi behar dugu. Adibidez, 53123 zenbakia
jasota, pantailatik hau da aterako da: 5, 3, 1, 2, 3.
2. GAIA: OBJEKTUEI ZUZENDUTAKO
PROGRAMAZIOA. OBJEKTUAK
2. 1. SARRERA
Gure inguruari erreparatuta, ikusiko dugu objektuak non-nahi daudela. Autoak, eraikinak, aulkiak,
mahaiak, semaforoak... objektuak dira; eta pertsonak eta animaliak ere objektutzat hartuko ditugu.
Objektu guztiek bi elementu hauek izango dituzte: EZAUGARRIAK eta PORTAERAK.
Auto objektua hartuta, ezaugarriak lirateke: marka, kolorea...; eta portaerak: azeleratu, balaztatu,
biratu...
Pertsona objektua hartuta, ezaugarriak lirateke: ilearen kolorea, begien kolorea, garaiera, pisua,
adina...; eta portaerak: jaio, hazi, lo egin, jan, edan...
Objektuei zuzendutako programazioaren (OZP) helburua hau da: mundu errealeko problemak gure
sistema informatikora eramango dituzten teknika batzuk ezartzea.
2. 2. OBJEKTUEI ZUZENDUTAKO PROGRAMAZIOAREN
OINARRIAK
Programatzeko bi era bereizten dira:

Programazio egituratua: Funtzioetan eta Prozeduretan oinarritzen da. Funtzio eta prozedura horiek
definitzen dute zer ekintza egin behar diren, eta ekintza horiek osatzen dituzte programak.
Objektuei zuzendutako programazioa: Programetan objektuak dira garrantzitsuak, eta beste guztia
haien menpe dago.
Hasieran, programazio egituratua erabiltzen zen: Jatorrizko problema bat problema txikiagotan
deskonposatzen zen oinarrizko problema sinpleetara heldu arte, problema sinple horiek
kodifikatzen errazak direlako. Esate baterako, lehen mailako ekuazio bat ebazteko, problema
txikiagotan deskonposatzen dugu jatorrizko problema:
- koefizienteen balioak eskatu.

- ezezagunaren balioa kalkulatu.
- emaitza erakutsi.
Objektuei zuzendutako programazioak, ordea, beste teknika bat erabiltzen du programatzeko:

zatitu eta irabazi. Teknika horrek ere errealitatea zati txikiagotan zatitzen du; baina, ekintzatan
deskonposatu beharrean, objektutan deskonposatzen du. Helburua da mundu erreala gure
programetan islatzea. Horregatik, esaten da objektuei zuzendutako programazioak problemei era
naturalago batean aurre egiten diela.
Objektuei zuzendutako programazioa erabiltzeko, elementu hauek hartu behar ditugu kontuan:
zein objektuk hartzen duten parte, zeintzuk diren objektu horien ezaugarri komunak, eta nolako
ekintzak egin ditzaketen.
Behin ebatzi beharreko benetako problemari (problemaren espazioa) zein objektuk eragiten dioten
identifikatuta, programa informatikora (ebazpenaren espazioa) eraman behar ditugu.
2.2.1. KONTZEPTUAK
Objektuei zuzendutako programazioa ondo ulertzeko, haren eta programazio egituratuaren arteko
ezberdintasun garrantzitsu batzuk aipatuko ditugu:
Programazio egituratuan sortutako programa datuz eta funtzio globalez osatzen da. Zer esan nahi
dugu global hitzarekin kasu honetan? Bada, datuak beti daudela erabilgarri programaren edozein
kode-atalek erabiltzeko.
Funtzioak eta datuak zein bere aldetik zeuden programazio egituratuan, eta erabat
independenteak ziren batzuk besteetatik. Horrek bi arazo eragiten zituen:
- Exekutatuko zituen konputagailuaren arkitekturaren arabera sortu behar ziren programak.
- Funtzioak eta datuak banatuta zeudenez, datuak ikusgai zeuden programa osoan. Horrela,
daturen batean aldaketaren bat egiteak funtzio guztiak aldatzea eragiten zuen.
Objektuei zuzendutako programazioa, ordea, desberdina da. Objektuak erabiltzeak abstrakzio

puntu handiagoa ahalbidetzen du. Programazio egituratuarekiko desberdintasun nagusiak hauek
dira:
- Programatzaileak objektuekin antolatzen du bere programa. Objektu horiek mundu
errealaren irudi dira, eta hurbilago daude jendearen pentsatzeko eratik programazio
egituratuko datuak eta funtzioak baino.
- Datuak, eta datu horiek erabiltzen dituzten funtzioak, objektu jakinen parte bat dira, eta
gainerako objektuek ezin dituzte funtzio eta datu horiek erabili. Beraz, datuetan egiten
diren aldaketek ez daukate eraginik programa osoan; bakarrik eragiten diete objektu
horretarako definitu diren funtzioei.
Objektuei zuzendutako programazioa erabilita idazten diren programa guztiak programazio

egituratua erabilita ere idatz daitezke. Hala ere, erabiltzaile-interfaze grafikoak erabiltzen dituzten
programak garatzeko, objektuei zuzendutako programazioak ematen du erraztasun gehien.
2.2.2. ONURAK
Orain arte ikusitakoaren arabera, objektu bat da ikusi edo hauteman dezakegun edozer. Objektuei
zuzendutako programazioaren funtsa objektuak eurak dira. Baina zer onura ditu objektuak
erabiltzeak? Bai. Batez ere, problema errealitatetik hurbilago dagoen era batean planteatzea;
baina, beste abantaila batzuk ere badaude:
- Programa ulertzea: Programaren kodea irakurrita, problema nola ebatzi eta konponbidea
zein izan daitekeen antzematen dugu, problemaren espazioko kontzeptuak programan
bertan daudelako.
- Modularitatea: Objektu bakoitzaren definizioa artxibo bakarrean dago. Horrek aplikazioak
hobeto antolatuta egotea ahalbidetzen du.
- Errazagoa mantentzea: Ekintzetan egindako aldaketak datuetan islatzen dira. Hori dela eta,
askoz errazagoa da aplikazioak mantentzea. Bestalde, aplikazioak hobeto antolatuta
daudenez, askoz errazagoa da aldatu edo zuzendu nahi dugun edozein elementu aurkitzea.
- Ziurtasuna: Txikiagoa da akatsak egoteko probabilitatea, objektu baten datuak zuzenean
aldatzea debekatuta dagoelako. Datuak aldatzeko, objektu horren funtzioak erabili behar
ditugu. Adibidez, demagun ArropaGarbigailu izeneko objektu bat daukagula. Motorra,
danborra, kableak, hodiak... dauzka. Arropa-garbigailua erabiltzean, ez ditugu elementu
horiek guztiak zuzenean erabiltzen. Guk arropa-garbigailuak dauzkan programak erabiltzen
ditugu. Objektuekin, antzeko zerbait gertatzen da: ez ditugu datuak zuzenean erabiltzen,
horretarako definituta dauden funtzioak baizik.
- Berrerabilgarritasuna: Objektua definituta daukagunean, objektu horren definizioa beste
programa batzuetan ere erabil daiteke. Adibidez, Pertsona objektua definitu dugu ikastetxe
bat kudeatzeko aplikazio batean. Gero, beste aplikazio bat egin nahi dugu autoen alokairuak
kudeatzeko. Bigarren aplikazio horretan ere pertsonak erabiliko ditugu. Bada, kasu horretan,
ez dugu Pertsona objektua berriro definitzeko premiarik: aurretik definitutakoa erabili
genezake.
2.2.3. EZAUGARRIAK
Objektuei zuzendutako programazioak bete beharreko ezaugarri batzuk ditu. Ezaugarri

nabarmenenak hauek dira:
- Abstrakzioa: Objektu baten ezaugarriak definitzeko prozedura da. Prozedura honetan, EZ
DIGU ARDURA NOLA KODIFIKATUKO DIREN EZAUGARRI HORIEK PROGRAMAN. Objektuei
zuzendutako programazioan, abstrakzioa lortzeko KLASEA erabiltzen da. Funtsean, klasea
datu mota bat da. Klaseak objektu multzo baten ezaugarriak bateratzen ditu.
Ibilgailu klasea sortzen badugu, klase hori oinarritzat hartuta, auto eta kamioi klaseak sor
ditzakegu. IBILGAILU klasea AUTO eta KAMIOI klaseen ABSTRAKZIOA dela esaten da.
- Modularitatea: Problema objektuak erabilita konponduko dugula esan dugu. Objektuak
klaseetatik abiatuta sortzen dira. Klase bakoitza fitxategi bakarrean idazten da. Hori da
modularitatea. Klase bat aldatu egin dezakegu beste klaseak aldatu gabe.
- Kapsulazioa edo informazioa ezkutatzea: Objektu baten barne informazioak ikusezina izan
behar du gainerako objektuentzat. Hori da kapsulazioa.
Pentsa dezagun programa batek bi objektu dauzkala: Pertsona eta Autoa. Pertsona objektua
Auto objektuarekin komunikatzen da leku batera joateko. Horretarako, Auto klaseak eduki
ditzakeen funtzioak erabiliko ditu (adibidez: gidatu funtzioa). Hau da, Pertsona klaseak Auto
klasea erabiltzen du, baina ez daki nola dagoen Auto klasea barrutik eratuta eta antolatuta.
Hierarkia: Klaseen artean eta objektuen artean sor daitezke hierarkiak. Hierarkia mota
garrantzitsuena hau da:
- Orokortzea: HERENTZIA izenarekin ezagutzen da. Klase berri bat sortzea da, jadanik
existitzen den beste klase bat oinarritzat hartuta. Horri herentzia sinplea esaten zaio, eta,
Javan, herentzia mota hori erabiltzen da. Aniztun-herentzia, ordea, klase berria existitzen
diren beste klase batzuk oinarritzat hartuta sortzea da, baina ez da erabiltzen Javan.
Adibidez, Irakasle klasea sor dezakegu Pertsona klasea oinarritzat hartuta. Era horretan,
irakasleek dauzkaten ezaugarriak soilik definitu beharko ditugu.
- Polimorfismoa: Klase beretik abiatuta sortutako beste hainbat klasek eragiketa bera zeinek
bere eran egitean datza. Esate baterako, pentsa dezagun Animalia klasea eta mintzatu
funtzioa ditugula. Animalia mota bakoitzak bere era dauka komunikatzeko: txakurrek
zaunkaka, katuek miauka, pertsonak berbaz...
2.3. KLASEAK ETA OBJEKTUAK
Software-objektu bat mundu errealean existitzen den objektu baten adierazpena da. Objektuak
ezaugarri batzuk izango ditu, baita portaera jakin batzuk ere.
Baina, zer da, zehazki, objektu bat objektuei zuzendutako programazioaz ari garenean?
Objektu bat datu multzo bat da, eta datu horiekin egin daitezkeen eragiketak. Objektuek egoera
bat eta portaera bat daukate.
Objektuek ezaugarri berezi batzuk dauzkate:
- Identitatea: Bi objektu ezberdintzea ahalbidetzen duen ezaugarria da. Nahiz eta bi objektuk
atributu berdinak izan, objektuak ezberdinak izan daitezke. Adibidez, lantegi batetik atera
diren bi auto berdinak direla eman dezake, baina ezberdintzen dituen kode bat daukate.
- Egoera: Objektu baten egoera bere atributuek dituzten balioek markatzen dute. Adibidez,
autoa objektu bat badugu, markak, modeloak, koloreak... markatuko dute egoera.
- Portaera: Objektuaren gainean egin daitezkeen eragiketak dira. Beste era batera esanda,
objektuak erabili ditzakeen metodoak dira. Autoaren adibidearekin jarraituta, hauek izan
litezke: abiatu(), gelditu(), bizkortu(), balaztatu()...
2.3.1. OBJEKTUEN PROPIETATEAK ETA METODOAK
Objektu batek parte hauek ditu:

- Atributuak (Propietateak): Datuak gordetzen dituen objektuaren atala. Aldagai klasekidea
ere esaten zaie. Datu hauek oinarrizko datu motetakoak izan daitezke (boolean, char, int,
double...) edo beste objektu mota batekoak. Adibidez, Auto motako objektu batek Gurpil
motako objektuak izan ditzake.
- Metodoak (Funtzio klasekideak): Atributuekin eragiketak egiten dituen objektuaren atala.
Objektu batek datuak eta datu horien gainean egin daitezkeen eragiketak bateratzen ditu.
Objektuen datu pribatuak erabiltzeko, metodoak erabili beharko ditugu.
Objektuaren informazioarekin metodoen bitartez bakarrik egin daiteke lan.

Atributuren baten balioa jakin nahi dugunean, atributu horren balioa zein den erakusten duen
metodo bat erabili beharko dugu. Horrela, kanpoko metodoek objektu baten atributuak aldatzea
eragozten dugu. Horregatik, esaten da datuak eta metodoak objektuaren barruan kapsulatuta
daudela.
2.3.2. OBJEKTUEN ARTEKO INTERAKZIOAK
Programa baten barruan, objektu batzuk dei egin ahal die beste objektu batzuen metodoei.
Objektu batek (obj1) beste objektu baten gainean (obj2) aritu nahi duenean, bigarren horren
metodoak erabili beharko ditu. Kasu horretan, obj2-k obj1-en mezua jaso duela esaten da.
Programa bat exekutatzen denean, ekintza hauek gertatzen dira:
- Objektuak sortzea, behar ahala.
- Objektuen artean komunikatzea, mezuen bidez.
- Objektuak suntsitzea, berriz behar ez direnean.
2.3.3. KLASEAK
Gutxi gora behera, badakigu zer den objektu bat; baina, zer harreman daukate objektuek eta
klaseek beren artean?
Klasea da egitura eta portaera berdina daukaten hainbat objekturen deskripzioa. Klasetik abiatuta
sortzen dira beharrezkoak ditugun kopiak edo instantziak. Kopia horiek dira klasearen objektuak.
Klaseek datuak eta metodoak dauzkate. Datu eta metodo horiek objektu multzo batek dituen
ezaugarriak definitzen dituzte. Programa bat klasez osatuta dago, eta klase horietatik abiatuta
eratzen dira objektuak. Objektu horiek, gero, interakzionatu egingo dute elkarren artean.
Beste era batera esateko, klase bat eredu bat da. Bertan zehazten dira:
- Zein atributu diren komunak objektu guztientzat.
- Zein metodo dauden objektu horiek erabiltzeko.
Javan, klase bat sortzeko class hitza erabiltzen da. Klase baten deklarazioa atal hauek osatzen dute:
- Klasearen burua: Funtsean, modifikatzaile batek, class hitzak eta klasearen izenak osatzen
dute, baina konplexuagoa ere izan daiteke.
- Klasearen gorputza: Hemen, klasearen atributuak eta metodoak idazten dira.
Adibidea:
//Klasearen burua
public class Pertsona {
//Klasearen gorputza
String izena;
String abizenak;
int adina;
double garaiera;
double pisua;
public Pertsona() {}
// TODO Auto-generated method stub
}
}
- main() metodoa, programan, behin bakarrik jartzen da, klase nagusian. Metodo horretatik
hasten da programa exekutatzen. Sortzen ari garen klasea ez bada klase nagusia, metodo
hori ez da agertuko.
2.4. OBJEKTUAK SORTU, ERABILI ETA SUNTSITU
Klase bat sortzen dugun unetik aurrera, objektuak sortu ditzakegu klase horretatik abiatuta.
Objektu bat sortzen dugunean, “Klasearen instantzia” bat sortu dugula esaten dugu. Praktikan,
objektu hitzak eta klasearen instantzia esapideak oso-oso esanahi antzekoa dute.
Objektuak klaseetatik abiatuta sortzen dira, eta klase horien banakako kasuak dira.
Objektuaren eta klasearen arteko harremana ondo ulertzeko, irudikatu dezagun galletak egiteko
erabiltzen den molde horietako bat. Moldea bera klasea izango litzateke eta objektuaren
ezaugarriak definituko lituzke: forma, tamaina... Molde horrekin sortutako galletak objektuak edo
instantziak izango lirateke.
Demagun Pertsona klasea sortzen dugula. Haren atributuak izena, abizenak, altuera eta pisua
izango dira, eta egin ditzakeen ekintzak hazi, lo egin, jan... Hori eginda, programan, Langile izeneko
objektu bat sortu dezakegu Pertsona klasean oinarrituta. Langile objektua Pertsona klasearen
instantzia bat dela esango dugu, edo, Pertsona klasea Langile objektuaren abstrakzioa dela ere bai.
2.4.1. OBJEKTUEN BIZIA
Javan, klase nagusi batetik abiatzen da edozein programa. Klase nagusi horrek main() metodoa
dauka. main() metodoak programaren gainerako klaseak erabiliko ditu, objektuak sortuko ditu eta
objektuei mezuak bidaliko dizkie.
Objektuek bizi-ziklo bat daukate. Objektu bat programa batean beharrezkoa ez denean, zabor-
biltzaileak suntsitu egiten du objektu hori, eta, era horretan, baliabideak askatzen dira.
Objektu baten bizi-zikloan etapa hauek bereizi ditzakegu:
- Sortzea: Objektuak beharko duen memoria zatia harentzat gordetzen da eta hasieratu
egiten dira objektuaren atributuak.
- Erabiltzea: Objektuaren atributuekin eta metodoekin egiten da lan.
- Suntsitzea: Objektua ezabatu egiten da eta erabiltzen zituen baliabideak askatu egiten dira.
2.4.2. OBJEKTUAK DEKLARATZEA ETA SORTZEA
Objektu bat sortzeko, urrats hauek eman behar dira:
- Deklaratzea: Objektu mota definitzea.

- Instantziatzea: Objektua sortzea (new eragilea erabilita).
Baina nola egiten dira pauso horiek? Objektu bat deklaratzeko, hau egin behar da:
<klasea> objektuaren izena
Baina hori egitea ez da nahikoa objektua sortzeko. Objektuaren erreferentzia sortu besterik ez
dugu egin; baina erreferentziaren balioa hutsik dago (null balioa dauka).
Behin erreferentzia sortuta daukagunean, erreferentzia horretan gordeko den instantzia edo
objektua sortu behar dugu. Horretarako, new eragilea erabiliko dugu:
objektuaren izena = new <klaseko sortzailea>(parametroak)
Demagun Txoria izeneko klasea sortu dugula:
public class Txoria {

// atributuak
private String kolorea; // txoriaren kolorea, letra batekin adierazita
private int adina; // txoriaren adina
// klasearen metodoak
public Txoria (String k, int a){//sortzailea
this.kolorea = k;
this.adina = a;
}
public void setAdina (int a){
// txoriaren adinari, parametro bidez pasatzen zaion adina esleitzen dio.
this.adina = a;
}
public void printAdina (){ // txoriaren adina pantailan bistaratzen du.
System.out.println (this.adina);
}
public void setkolorea (String k){
// txoriaren koloreari, parametro bidez pasatzen zaion kolorea esleitzen dio.
this.kolorea = k;
}
}
Orain, programaren klase nagusia sortuko dugu:
public class TxoriaNagusia {

Txoria tx1; // tx1 objektuaren erreferentzia sortzen dugu
tx1 = new Txoria(“beltza”,4);// tx1 objektua sortzen dugu sortzailea
//erabilita
tx1.setAdina(6); //tx1 txoriari adina aldatzen diogu setAdina metodoa erabilita
tx1.printAdina(); //tx1 txoriaren adina pantailan erakusten dugu
}
}
Objektuaren erreferentzia sortzea eta objektua bera sortzea. Urrats bakar batean ere egin daiteke:
Txoria tx1 = new Txoria(“beltza”,4);
2.4.3. OBJEKTUAK ERABILTZEA.
Objektuaren atributuak eta metodoak erabiltzeko, aurreko atalean ikusi dugunez, objektuaren
izena jarriko dugu eta gero puntu bat (.), eta horien atzean idatziko dugu erabili nahi dugun
atributuaren edo metodoaren izena. Hori egitean, objektuari mezu bat bidaltzen diogula esaten da:
Adibidez:
tx1.setAdina(6);
2.4.4. OBJEKTUAK SUNTSITZEA.
Zabor-biltzailearen bidez, Javak objektuak automatikoki suntsitzen ditu beharrezkoak ez direnean.

Horrela, programatzailea ez da arduratu behar memoria kudeatzeaz.
2.5. METODOAK ERABILTZEA
Metodoek, atributuekin batera, objektuen egitura osatzen dute. Metodoak era egokian erabiltzeko,
ezinbestekoa da haiek ondo ulertzea.
Metodoek, klaseek bezala, burua eta gorputza daukate.
Buruan jarriko ditugu aldarazleak, metodoak itzultzen duen datu mota, metodoaren izena eta
metodo horrek jasotzen dituen parametroak. Gorputzean, berriz, metodoak egiten duen
ekintzaren kodea idatziko dugu:
Adibidez Txoria klasean metodo hauek izan genitzake:
public void setAdina (int a){

// txoriaren adinari parametro bidez pasatzen zaion adina esleitzen dio.
this.adina = a;
}
public int getAdina (){
// txoriaren adina itzultzen du.
return this.adina;
}
setAdina
Burua:
Aldarazlea(k): public (aurrerago ikusiko da).
Itzultzen duen datu mota: void (ez du ezer itzultzen)
Metodoaren izena: setAdina
Parametroa(k): a izeneko int motako parametro bat jasotzen du.
Gorputza:
a parametroa txoriaren adinari esleitzen dio.
getAdina
Burua:
Aldarazlea(k): public (aurrerago ikusiko da).
Itzultzen duen datu mota: int
Metodoaren izena: getAdina
Parametroa(k): ez dago parametrorik. Metodoak ez du ezer jasotzen.
Gorputza:
txoriaren adina itzultzen du.

2.5.1. PARAMETROAK ETA ITZULITAKO DATUAK
Metodoak objektuaren atributuren baten kontsulta egiteko (getAdina) zein atributu horien balioa
aldatzeko (setAdina) erabil daitezke. Objektuan kontsultatutako informazioa itzulera-balioaren
(return) bidez eskuratzen da. Atributu baten balioa aldatu nahi denean, ordea, parametro-
zerrendaren bidez egiten da; metodoari behar dituen balioak parametro horien bitartez eskainita,
alegia.
Parametro zerrenda hori bi eratara deklaratu daiteke:
- Balioen bidez: Parametroetan egiten den edozein aldaketa baliorik gabe geratzen da
metodoa bukatzean. Metodoari dei egiten zaionean, hark aldagaien kopia bat jasotzen du;
beraz, egindako edozein aldaketa kopien gainean egiten da, ez jatorrizko aldagaien gainean.
- Erreferentzien bidez: Metodoa amaitzean, parametroen gainean egindako aldaketek bere
horretan irauten dute. Kasu honetan, ez diogu kopiarik pasatzen metodoari. Pasatzen
dioguna da aldagaiak memorian daukan helbidea. Hortaz, aldaketak aldagaiaren beraren
gainean gertatzen dira.
Javan, parametro guztiak balioen bidez pasatzen dira metodoetara, objektuak (erreferentziak) izan
ezik.
Metodoak deklaratzeko, bi baldintza hartu behar ditugu kontuan:
- Metodo batek beti itzultzen du balio bat. Balio horri itzulera-balio deitzen diogu. Datu
mota sinplea izan daiteke, erreferentzia bat ala void. void-ek adierazten du metodoak ezer ez
duela itzultzen:
public void setAdina (int a)
- Metodo batek parametro kopuru finkoa dauka. Metodoari dei egiten zaionean, pasatzen
zaizkion parametroek bat egin behar dute metodoa deklaratzean jarritako parametroekin bai
zenbakian, bai ordenan eta bai datu motetan ere.
2.5.2. SORTZAILEAK
Sortzaileak metodo bereziak dira. Klasearen izen berdina izan behar dute, eta ez dute baliorik
itzultzen.
Objektu bat sortzeko, haren instantzia bat egin behar dugu. Horretarako, klasekp sortzailea
erabiltzen da.
Aurretik sortu dugun Txoria klasearekin jarraituko dugu. Pentsa Txoria klaseko objektu bat sortu
nahi dugula. Kasu horretan, Txoria klaseko sortzailea erabili beharko dugu. Klasearen izen berdina
duenez, erraz identifikatuko dugu sortzailea:
public Txoria (String k, int a){

//sortzailea
this.kolorea = k;
this.adina = a;
}
Objektu bat sortzeko, hau egin beharko genuke:
Txoria zozoa = new Txoria (“zozoa”,3);
Ikus daitekeenez, sortzaileen eta metodo arrunten artean ez dago ezberdintasun handirik.
Ezberdintasunik handiena hau da: sortzaileak ez dauka itzulera-baliorik.
Sortzaileak berezitasun hauek dauzka:
- Automatikoki deitzen zaio objektua sortzean, eta ez beste inoiz.

- Ez dira letra txikiz hasten. Klaseen izen berdina daukate, eta, klaseak bezala, letra larriz
hasten dira.
- Klase batek hainbat sortzaile izan ditzake.
- Parametrorik gabeko konstruktoreari sortzaile lehenetsia esaten zaio.
- Klaseek, gutxienez, sortzaile bat izan behar dute. Sortzailerik definitzen ez bada, eta kasu
horretan bakarrik, konpilatzaileak hutsik egongo den sortzaile-lehenetsia sortuko du.
Sortzaile horrek objektuaren atributuak hasieratuko ditu, euren datu moten arabera.
Zenbakizko datuak 0 batekin hasieratuko ditu; boolearrak, false balioarekin; eta karaktere
eta erreferentziak, null balioarekin. Gure sortzaileak definitzean, sortzaile lehenetsirik ez da
existituko. Behar badugu, guk geuk definitu beharko dugu.
2.5.3. THIS ERAGILEA
Aurreko adibideetan, this eragilea erabili izan da. this eragilea kasu honetan erabiltzen da: objektu
baten barruan egonda, objektuaren atributuak erabili nahi ditugunean. Batez ere, parametro baten
eta atributu baten izenen artean anbiguotasuna dagoenean erabiltzen da.
Imajina ezazu hegazkina izeneko klasea daukagula:
3 atributu dauzka: alde batetik, izena, eta bestetik, hegazkinaren posizioa adierazteko bi
koordenatu, xpos eta ypos. Bi metodo sortzaile dauzka, baita heganEgin metodoa ere. Aurretik
esan dugunez, klase batek hainbat sortzaile izan ditzake, erabiltzen dituzten parametroen bidez
bereizten direnak.
Adibidea:
Hegazkina izeneko klase nagusi bat daukagu. Aurreko irudian ageri diren atributuak eta metodoak
definitu behar ditugu. Metodoek ekintza hauek egiten dituzte:
- Hegazkina(): sortzaile lehenetsia. Ez dauka agindurik bere kodean. Atributuak hasieratu

besterik ez du egingo balio lehenetsiak erabilita.
- Hegazkina(String izena, int xpos, int ypos): sortzailea. Parametro bidez, String bat eta bi int
jasoko ditu, objektuaren atributuak hasieratzeko.
- heganEgin(int xpos, int ypos): Bi zenbaki oso jasoko ditu parametro bidez metodo honek,
eta double motako zenbaki bat itzuliko du. Itzulitako zenbakia honako formula erabilita
kalkulatzen da:
tokialdaketa =
Hegazkina izeneko klasea erabiliko duen programa bat sortuko dugu. Programa horrek Hegazkina
klaseko objektu bat sortuko du eta objektu horren metodoak erabiliko ditu.
Lehenik eta behin, hegazkina izeneko klasea sortuko dugu. Eman dizkiguten datuekin, kodea
honako hau litzateke:
public class Hegazkina {

// atributuak
private String izena;
private int xpos,ypos;
// klasearen metodoak
public Hegazkina (){
//sortzailea
}
public Hegazkina (String izena, int xpos, int ypos){
//sortzailea
this.izena = izena;
this.xpos = xpos;
this.ypos = ypos;
}
public double heganEgin (int xpos, int ypos){
double lekualdaketa = Math.sqrt(xpos*xpos+ypos*ypos);
this.xpos = xpos;
this.ypos = ypos;
return lekualdaketa;
}
}
Kontuan izan behar dugu Hegazkina klase nagusi bat dela; beraz, main() metodoa eduki behar du,
eta main() metodoaren barruan gure programaren kodea sartuko dugu. Ariketaren arabera,
klasearen instantzia bat sortu behar dugu, eta horren metodoak erabili. Programak egingo duena
hau izango da:
- Klasearen objektu bat sortu.

- heganEgin metodoari dei egin.
- Hegazkinak egindako distantzia (lekualdaketa) pantailan bistaratu.
Objektua parametroak dituen sortzailea erabiliz sortuko dugu. main metodoaren kodea hau izango
litzateke:

Hegazkina boeing = new Hegazkina ("Boeing 747",50,50);
double lek = boeing.heganEgin(50, 50);
System.out.println("Lekualdaketa hau izan da: "+ lek);
}
Programa exekutatzen badugu, emaitza hau izango da:

2.5.4. METODO ESTATIKOAK
Metodo estatikoen berezitasuna hau da:

ez dago zertan klase baten objekturik sortu, programa batean klase horren metodo estatikoak
erabiltzeko.
Metodo estatiko bati modu honetan egingo diogu dei:
- Metodoaren izena, definituta dagoen klasetik deitzen badiogu.

- Klasearen izena, puntu eragilea (.) eta metodo estatikoaren izena, definituta dagoen
klasearen kanpotik deitzen badiogu.
- Objektuaren izena, puntu eragilea (.) eta metodo estatikoaren izena, definituta dagoen
klaseko objektu bat existitzen denean.
Noiz eta zertarako erabiltzen dira metodo estatikoak? Metodo hauek ez dituzte objektuen
atributuak aldatzen. Klase bateko objektu guztientzat orokorrak diren eragiketetan erabiltzen dira.
Adibidez, klase bateko zenbat objektu sortu diren jakin nahi badugu. Kasu horretan, metodo
estatiko bat egin genezake, eta objektu bat sortzen den bakoitzean metodo horrek unitate bat
gehituko lioke aldagai baten balioari.
Javaren Klaseen Liburutegian, metodo estatikoak dituzten klase ugari dago. Esate baterako,
aurreko ariketan Math klasea erabili dugu erro karratu bat kalkulatzeko, baina ondo aztertzen
badugu, ikusiko dugu ez dugula sortu Math klaseko objekturik. Zer egin dugun? Klasearen izena,
puntu eragilea eta metodo estatikoaren izena jarri ditugu.
2.6. PAKETEAK
Egiten ditugun programak handitzen doazen heinean, haien klase kopurua ere handitu egiten da.
Klase guztiak karpeta bakarrean sartzen baditugu, proiektua hobeto antolatua egongo da.
Pakete bat klase multzo bat da. Multzo berean dauden klaseek harremana izango dute beren
artean.
Pakete bateko klaseek sarbide pribilegiatua daukate pakete berean dauden beste klaseen
atributuetara eta metodoetara.
.java fitxategi bakoitzaren hasieran, posible dugu fitxategi horretan idatzitako klasea zein paketeri
dagokion jartzea. Hori egiteko, package hitz erreserbatua erabiltzen da.
Ikus dezagun nola egiten den lan paketeekin Eclipse-n.
Lehen urratsa proiektu berri bat sortzea da. Nik AdibideProiektua deitu diot.
Bigarren urratsa proiektuaren barruan pakete bat sortzea da. Hori egiteko, proiektuaren gainean
klik egingo dugu eskuineko botoiarekin eta New->Package aukeratuko dugu. Paketeari izena eman,
gure kasuan AdibidePaketea, eta Finish botoia sakatuko dugu.
Hori eginda, paketea sortu dela ikusiko dugu.
Azkenik, klase bat sortuko dugu paketearen barruan. Hori egiteko, paketean klik egin eskuineko
botoiarekin, eta New->Class aukeratuko dugu. Klaseari AdibideKlasea deituko diot.
2.6.1. IMPORT AGINDUA
Batzuetan, beste pakete bateko klase bateko metodo bat erabili nahi dugu. Kasu horietan, import
agindua erabiltzen dugu.
Aurreneko gaian, teklatu bidez sartutako datuak jasotzeko, Scanner klasea erabili genuen. Scanner
klasea java.util paketearen barruan dago; beraz, klasea erabiltzeko, hau jarri behar dugu gure
programan:
Pakete batean dauden klase guztiak agindu bakar bat erabiliz ere inportatu ditzakegu:
import java.util.*;
import agindua klasearen hasieran jartzen da, package aginduaren azpian, baldin eta azken hau
existitzen bada.
Posible da import ez jartzea, baina hau jarri beharko dugu hala egin nahi dugun bakoitzean:
java.util.Scanner teklatua = new java.util.Scanner (System.in);

2.6.2. JAVA LIBURUTEGIAK
Java liburutegiak klase multzo (pakete) ugari eskaintzen dizkigu gure programetan erabiltzeko.
Horregatik, garrantzitsua da haiek zein diren jakitea. Javak eskaintzen dituen paketerik
garrantzitsuenak hauek dira:
- java.io. Sarrerak eta irteerak kudeatzeko klaseak. Fitxategiak erabiltzeko, pantailan idazteko,
memorian irakurri edo idazteko...
- java.lang. Hizkuntzarekin erlazionatutako klaseak. Automatikoki inportatzen da; ez da
beharrezkoa guk inportatzea. Object eta System klaseak pakete honetan daude.
- java.util. Programatzailearentzat erabilera orokorrekoak diren klaseak daude. Adibidez,
Scanner klasea, datekin lan egiteko erabiltzen den Date klasea...
- java.math. Eragiketa matematikoak egiteko klaseak.
- java.awt. Erabiltzaile-interfazeak egiteko klaseak.
- java.swing. Erabiltzaile-interfazeak egiteko klaseak dituen beste pakete bat. awt baino
indartsuagoa da.
- java.net. Sarean programatzeko klaseak.
- java.sql. Datu baseak erabiltzen dituzten aplikazioak programatzeko klaseak.
- java.security. Gure programetan segurtasun neurriak ezartzeko klaseak.
A ERANSKINA: ARIKETAK
ARIKETA ERRAZAK
1. Sortu ezazu NireZenbakia izeneko klase bat. Sortzaileak zenbaki bat jasoko du. Sortzaileaz gain,
klaseak beste lau metodo izango ditu:
- Zenbakiaren bikoitza kalkulatuko duen metodoa.

- Zenbakiaren hirukoitza kalkulatuko duen metodoa.
- Zenbakiaren laukoitza kalkulatuko duen metodoa.
- main() metodoa. Metodo hau beste 3 metodoak frogatzeko erabiliko dugu.
2. Sortu ezazu Zenbakia izeneko klase bat. Klaseak zenbaki oso bat gordeko du, eta metodo hauek
ditu:
- Sortzaile lehenetsia. Zenbakia 0 zenbakiarekin hasieratuko da.

- Zenbakia hasieratuko duen sortzailea.
- batu izeneko metodoa. Metodo honek barne zenbakiari beste zenbaki bat batuko dio.
- kendu izeneko metodoa. Metodo honek barne zenbakiari beste zenbaki bat kenduko dio.
- getBalioa: Barne zenbakia itzultzen du.
- getBikoitza: Barne zenbakiaren bikoitza itzultzen du.
- getHirukoitza: Barne zenbakiaren hirukoitza itzultzen du.
- setBalioa: Barne zenbakiaren balioa aldatzen du.
3. Sortu ezazu bi sortzaile izango dituen Auto klasea. Sortzaileetako batek ez du parametrorik
jasoko, eta besteak, bai. Bi sortzaileek marka eta modelo atributuak hasieratuko dituzte. Sor itzazu
Auto klaseko bi objektu, objektu bakoitza sortzaile bat erabilita, eta froga ezazu egindakoa ondo
dabilela.
4. Sortu ezazu klase bat itsas milien eta kilometroen arteko bihurketak egiteko, eta bi metodo
izango dituena. Metodoek milia edo kilometro kopuruak parametro bidez jasoko dituzte, eta haien
izenak hauek izango dira:
miliakKilometrotara()
kilometroakMiliatara()
Oharra: Itsas milia = 1.852 metro.
5. Jaso produktu baten jatorrizko prezioa eta beherapena egin ondorengo prezioa, eta idatzi ezazu
zer portzentaje deskontatu den itzuliko duen metodo bat.
ARIKETA ZAILAK
1. Sortu ezazu pisua klasea. Klaseak ezaugarri hauek izango ditu:
Objektu baten masa (kilogramotan) gordeko duen atributu bat izango du.
Sortzaileari masa eta unitatea pasatuko zaizkio. Unitateak hauek izan daitezke:
Lb = libra
Li = lingotea
Oz = ontza
P = penny-a
K = kilogramoa
G = gramoa
Ki = kintala
Klaseak metodo hauek izango ditu:
getLibrak: Masa libratan itzuliko du.

getLingoteak: Masa lingotetan itzuliko du.
getPisua: Parametro bidez pasatuko zaion unitatean itzuliko du pisua.
Ariketa egiteko, erabil itzazu balio hauek:
1 libra = 16 ontza = 453 gramo

1 lingote = 32,17 libra = 14,59 kilogramo
1 ontza = 0,0625 libra = 28,35 gramo
1 penny = 0,05 ontza = 1,55 gramo
1 kintal = 100 libra = 45,3 kilogramo
2. Txokolate-taloak egiten dituen jatetxe batek hau jakin nahi du: biltegian daukan arto-irinarekin
eta txokolatearekin zenbat talo egin ditzakeen. Metodo bat egitea eskatu digu jatetxeko
arduradunak: irin eta txokolate kiloen zenbatekoa jaso eta zenbat txokolate-talo egin daitezkeen
itzuliko duen metodoa. 6 txokolate-talo egiteko kilo bat irin eta kilo erdi txokolate erabiltzen dira.
3. Alda ezazu 2. ariketako programa. Egiten duzun klaseak zenbat kilo irin eta zenbat txokolate
dagoen biltegian gordeko du, eta metodo hauek izango ditu:
public void irinaGehitu (int x). Biltegiratuta dagoen irinari x kilo gehitzen dio.
public void txokolateaGehitu (int x). Biltegiratuta dagoen txokolateari x kilo gehitzen dio.
public int zenbatTalo (). Jatetxeak zenbat talo egin ditzakeen itzultzen du (aurreko ariketako
metodoa da).
public void irinaIkusi(). Biltegian zenbat irin kilo dagoen pantailaratzen du.
public void txokolateaIkusi(). Biltegian zenbat txokolate kilo dagoen pantailaratzen du.
ARIKETA OSOA
1. Sortu ezazu pertsona klasea erabiliko duen proiektu berri bat.
public class Pertsona

{
private String izena;
private int adina;
private float garaiera;
public String getIzena(){

return izena;
}
public void setIzena(String izena){

this.izena = izena;
}
}
Klaseak, gainera, metodo nagusi bat ere izango du. Metodo horrek erabiltzaileari izen bat eskatuko
dio teklatu bidez sartu dezan, eta balio hori esleituko dio izena atributuari. Gero, pantailan aterako
du.
2. Sortu itzazu atributu guztiak kontsultatzeko eta eguneratzeko falta diren metodoak. Har itzazu
getIzena() eta setIzena() eredutzat. Alda ezazu programa, metodo berriek funtzionatzen dutela
ziurtatzeko.
3. Idatz ezazu sortzaile berri bat. Sortzaile horrek balio hauek esleituko dizkie sortutako objektu
berriei:
izena = “Karmele Landa”

adina = 22
garaiera = 1,70
Sortu ezazu, jatorrizko programan, objektu berri bat sortzaile berria erabilita, eta erakutsi itzazu
objektu horren atributuen balioak pantailan.
4. Idatzi ezazu atributuen balio guztiak parametro bidez jasoko dituen sortzaile berri bat. Aldatu
programa, aurrekoa ezabatu gabe, sortzaile berria erabili dezan eta frogatu ondo funtzionatzen
duela.
5. Sortu ezazu bi atributu dituen Konplexu izeneko klasea:
- erreala: zenbaki konplexuaren zati erreala.

- irudikaria: zenbaki konplexuaren zati irudikaria.
Konplexu klaseak metodo hauek izango ditu:
- public Konplexu(): Sortzailea. Atributuak zeroekin beteko ditu.
- public Konplexu(double erreal, double irudi): parametroen bidez esleituko zaizkie balioak
objektuaren atributuei.
- public double getErreal(): objektuaren zati erreala itzuliko du.
- public double getIrudi(): objektuaren zati irudikaria itzuliko du.
- public void setErreal (double erreal): parametro bidez ematen den balioa esleituko dio
objektuaren erreala atributuari.
- public void setIrudi (double irudi): parametro bidez ematen den balioa esleituko dio
objektuaren irudikaria atributuari.
- public void batuketa (Konplexu b): objektuaren zati erreala b zenbakiaren zati errealarekin
batzen du, eta zati irudikaria b zenbakiaren zati irudikariarekin.
Sortu ezazu proiektu berri bat Konplexu klasea duena, zenbakiak izeneko pakete batean.
Frogatu itzazu metodo guztiak.
3. GAIA: OINARRIZKO KONTROL EGITURAK
3. 1. SARRERA
Orain arte ikasi duguna ez da nahikoa programa konplexuak egiteko. Egoera askotan, programak
aukerak eskaini beharko ditu, erabakiak hartu, kode zati bat hainbat alditan errepikatu...
Programazio-hizkuntza gehienetan, informazio-fluxua kontrolatzeko, hainbat egitura egoten dira.
Esandako hori ulertzeko, pentsa dezagun iturgin (programatzaile) batean. Iturginak, ohikoan,
urarekin (datuak) egiten du lan, eta ur hori berak nahi duen lekutik (programa) garraiatzea lortzen
du hodiak, giltzak, ukondoak, etab (kontrol-egiturak) erabiliz.
Programatzeko egitura motak hauek dira:
- Sekuentzia: Programan agertzen diren ordena berean exekutatzen dira sententziak.

Egiturarik sinpleena da, eta gainerako egiturak sekuentziatik abiatuta eraikitzen dira.
- Hautazkoak: Erabakitze-sententzia berezi bat dago. Sententzia hori ebaluatzean, emaitza
bat lortuko da (normalean true ala false), eta emaitza horren arabera, sententzia-sekuentzia
jakin bat exekutatuko da ala beste sekuentzia ezberdin bat.
- Errepikapenak: Erabakitze-sententzia berezi bat dago. Sententzia hori ebaluatzean, emaitza
bat lortuko da, eta emaitza hori egokia bada, sententzia-sekuentzia jakin bat errepikatuko
da harik eta emaitza desegokia izan arte.
3.2. SENTENTZIAK ETA BLOKEAK
Aurretik landutako unitateetan, jakintzat eman dira hainbat kontzeptu; orain, kontzeptu horiek
galdera-erantzunen bidez ikusiko ditugu:
- Nola idatziko dugu programa sinple bat? Programa sinple batek sententzia batzuk
exekutatu eta emaitza apropos bat lor dezan nahi badugu, sententzia horiek bata bestearen
atzean jarriko ditugu, exekutatu behar diren ordena berean.
- Jar litezke sententzia guztiak lerro berean, puntu eta komarekin (;) banatuta
elkarrengandik? Jakina baietz, baina ez da komeni. Sententzia bakoitza lerro bakarrean
egotea komeni da, programa ulergarriagoa izan dadin.
- Posible da sententzia bakar bat, programan, lerro batean baino gehiagotan idaztea? Bai;
izan ere, sententzia batzuk luzeak izaten dira eta ez dira lerro bakarrean sartzen. Gogoratu
behar dugu sententzia guztiak puntu eta komarekin amaitzen direla.
- Javan, puntu eta komarekin amaitzen al dira sententzia guztiak? Bai, hala da. Zenbaitetan
baina, programaren fluxua kontrolatzeko egiturak erabiltzen ditugunean, horien buruaren
ostean ez doa puntu eta koma. Kasu horiek aurrerago ikusiko ditugu.
- Zer da Javan sententzia nulua? Ezer egiten ez duen sententzia: puntu eta koma bat beste
ezer gabe.
- Zer da sententzia-bloke bat? Giltzen barruan sartzen den eta sententzia bakarra balitz
bezala funtzionatzen duen sententzia multzoa da.
ADIBIDEA
Erreparatu hiru fitxategi hauei. Hirurek ematen dute emaitza bera, baina sententziak ez daude era
berean idatzita.
1. fitxategia (ordena sekuentziala da).
package sententzien_antolamendua;
/**
*
* Sententzien antolamendu sekuentziala
*/
public class Sententzien_antolamendua_1 {
System.out.println ("Sententzien antolamendu sekuentziala");
int eguna = 12;
System.out.println ("Eguna hau da: " + eguna);
int hila = 11;
System.out.println ("Hila hau da: " + hila);
int urtea = 2011;
System.out.println ("Urtea hau da: " + urtea);
}
}
2. fitxategia (lehenbizi, aldagaiak deklaratzen dira. Javan, aldagaiak edonon deklaratu daitezke;
baina, aldagai bat erabili baino lehen, derrigorrezkoa da deklaratuta egotea).
/**
*
* Sententzien antolamendua, aldagaiak hasieran deklaratuz.
*/
// Aldagaiak deklaratzea
int eguna = 10;
int hila = 11;
int urtea = 2011;
System.out.println ("Sententzien antolamendua, aldagaiak hasieran deklaratuz");
System.out.println ("Eguna hau da: " + eguna);
System.out.println ("Hila hau da: " + hila);
System.out.println ("Urtea hau da: " + urtea);
}
}
3. fitxategia (hainbat zati bereizten dira: aldagaiak deklaratzea, sarrera datuak eskatzea, datuen
prozesua eta irteera idaztea. Horrela antolatuta, programak errazago ulertzen dira).
/**
*
* Egiten dutenaren arabera, sententzia bakoitza dagokion zatian kokatzen da.
*/
// aldagaiak deklaratzea
int eguna;
int hila;
int urtea;
String data;
//Datuak sartzea edo aldagaiak hasieratzea
eguna = 10;
hila = 11;
urtea = 2011;
data = "";
//Datuen prozesua
data = eguna+"/"+hila+"/"+urtea;
//Irteera
System.out.println ("Kodea hainbat zatitan banatzea");
System.out.println ("Data hau da: " + data);
}
}
Erabiltzen duzun antolatzeko era erabiltzen duzula, beti izan behar dituzu kontuan ideia hauek:
- Erabili baino lehen, deklaratu ezazu aldagai bakoitza.
- Lehen aldiz erabili baino lehen, hasieratu ezazu aldagai bakoitza.
3.3. HAUTAZKO EGITURAK
Nola egin gure programek erabakiak hartzea? Hasteko, hautazko egiturekin lortuko dugu. Egitura
hauek hautazko sententzia berezi bat daukate, eta gero sententzia multzo bat.
Funtzionatzeko modua erraza da. Lehendabizi, hautazko sententzia berezia ebaluatzen da eta balio
bat itzultzen du (EGIA ala FALTSUA). Itzulitako balioaren arabera, instrukzio-sekuentzia bat ala
bestea exekutatuko da. Adibidez, aldagai batek 5 edo gehiago balio badu, pantailan GAI hitza
idatziko du programak; bestela, EZ GAI.
Kasu horretan, hautazko sententzia bereziak aldagaiaren balioa ebaluatuko du.
Hautazko egiturak hauek dira:
- Hautazko egitura sinpleak: if.

- Hautazko egitura konposatuak: if-else.
- Baldintzazko eragilean oinarritutako egiturak.
- Aukera anitzeko hautazko egiturak: switch.
Egitura horietako bakoitza erabiltzen ikasiko dugu, adibideen bidez; izan ere, arazo bera hainbat
eratan ebatzi daiteke.
3.3.1. IF ETA IF-ELSE
Adierazpen logiko bat ebaluatzen du, eta emaitzaren arabera, sententzia bat edo sententzia multzo
bat exekutatzen du.
IF IF-ELSE
if (adierazpen logikoa) if (adierazpen logikoa){ if (adierazpen logikoa) if (adierazpen logikoa){
sententzia 1; sententzia 1; sententzia 1; sententzia 1;
sententzia 2; else … ;
… ; sententzia 2; sententzia N;
sententzia N; }else{
} sententzia 1;
… ;
sententzia N;
}
Adierazpen logikoa egia bada, sententzia 1 Adierazpen logikoa egia bada, sententzia 1 edo
exekutatuko da edo dagokion sententzia-blokea. lehenengo sententzia-blokea exekutatuko da.
Faltsua bada, ez da hautazko egiturako Faltsua bada, berriz, sententzia 2 edo bigarren
sententziarik exekutatuko. sententzia-blokea exekutatuko da.
 else zatia ez da nahitaezkoa. Askotan, ez dugu erabiliko; baina beharrezkoa da ekintzaren
bat betetzea nahi badugu adierazpen logikoa betetzen ez denean. else zatia agertzen ez
den kasuetan, adierazpen logikoa faltsua bada, hautazko egituraren ondoren dauden
sententziak exekutatzen jarraituko du programak.
if eta if-else egiturak kateatu egin daitezke. Hau da, sententzia-bloke batean, if edo if-else egitura
bat baino gehiago sar dezakegu. Programatzaileak erabakiko du zenbat mailatan kateatu, baina
maila asko badaude, agian, ez gara egiturarik aproposena erabiltzen ariko.
ADIBIDEA
Honako programak test motako azterketa baten nota kalkulatzen du, eta pantailan letra bidezko
kalifikazioa erakutsiko du. Erreparatu ondo kodean sartuta dauden komentarioei, baita hautazko
egituren erabilerari ere.
package hautazko_egiturak;
/**
*
* Egitura sinpleak eta konposatuak, eta horien arteko kateaketak.
*/
public class Hautazko_egiturak {
/* Test erako azterketa baten nota kalkulatuko dugu. Horretarako, guztira dauden galderak,
igarritakoak eta huts egindakoak, hartuko ditugu kontuan. Bi akatsek igarritako galdera bat
baliogabetzen dute.
Azkenik, pantailan, zenbakizko eta letra bidezko kalifikazioak idazten dira.
Letra bidezko kalifikazioa lortzeko, kateaketa erabiliko dugu
*/
// Aldagaiak deklaratzea eta hasieratzea
int igarritakoak = 12;
int akatsak = 3;
int galderak = 20;
float nota = 0;
String kalifikazioa = "";
//Datuak prozesatzea
nota = ((igarritakoak - (akatsak/2))*10)/galderak;
if (nota < 5)
{
kalifikazioa = "GUTXI";
}
else
{
/* if hauen adierazpenek AND eragilea (&&) erabiltzen dute.
* Adierazpen osoa EGIA izan dadin, bi baldintzek izan behar dute EGIA.
*/
if (nota > = 5 && nota <6)
kalifikazioa = "NAHIKOA";
if (nota > = 6 && nota <7)
kalifikazioa = "ONGI";
if (nota > = 7 && nota <9)
kalifikazioa = "OSO ONGI";
if (nota > = 9 && nota < = 10)
kalifikazioa = "BIKAIN";
}
//Informazioa ateratzea
System.out.println ("Jasotako nota da: " + nota);
System.out.println ("eta jasotako kalifikazioa: " + kalifikazioa);
}
}
3.3.2. SWITCH EGITURA
Zer egin dezakegu gure programak bi aukera baino gehiagoren artean aukeratu behar duenean?
Aukera bat if egiturak kateatzea izan liteke; baina, askotan, aukera hori ez da eraginkorrena. Kasu
horietan, switch egitura erabiliko dugu.
SWITCH
switch (adierazpen logikoa){ - Adierazpena parentesi artean jartzen da.
case balioa1:
sententzia 1_1; - case bakoitzak balio bat izan behar du eta bi
sententzia 1_2; punturekin (:) amaituko da.
… ;
break; - default sententziak break batekin amaitu
daitezke ala ez.
case...
….;
break;
case balioaN:
sententzia N_1;
sententzia N_2;
… ;
break;
default:
default-sententziak;
}
switch egituraren aukera guztiak case baten ostean jartzen dira. Adierazpen logikoaren emaitza eta
case-ren balioa berdinak direnean, case-ren barruko sententziak exekutatu egingo dira.
default atalaren barruan dagoena kasu honetan bakarrik exekutatuko da: adierazpen logikoaren
emaitzak case ataletan dauden balioekin bat egiten ez duenean.
Posible da default atalik ez egotea. case bat bera ere aktibatu ez bada, switch-a ezer egin gabe
amaituko da.
case bakoitzak hainbat sententzia izan ditzake barruan, baina ez da giltzarik ({,}) jarri behar.
Adierazpen logikoak case baten balioarekin bat egiten duenean, sententzia guztiak exekutatuko
dira, break bat agertu arte.
ADIBIDEA
Arazoa aurreko adibidearen berdina da, baina oraingoan SWITCH egitura erabilita ebatziko da.
package hautazko_egiturak;
/**
*
* Egitura sinpleak eta konposatuak, eta horien arteko kateaketak.
*/
public class Hautazko_egiturak_switch {
/* Test erako azterketa baten nota kalkulatuko dugu. Horretarako, guztira dauden galderak,
igarritakoak eta huts egindakoak, hartuko ditugu kontuan. Bi akatsek igarritako galdera bat
baliogabetzen dute.
Azkenik, pantailan, zenbakizko eta letra bidezko kalifikazioak idazten dira.
Letra bidezko kalifikazioa lortzeko, SWITCH erabili dugu
*/
// Aldagaiak deklaratzea eta hasieratzea
int igarritakoak = 12;
int akatsak = 3;
int galderak = 20;
float nota = 0;
String kalifikazioa = "";
//Datuak prozesatzea
nota = ((igarritakoak - (akatsak/2))*10)/galderak
switch (nota) {
case 5: kalifikazioa = "NAHIKOA";
break;
case 6: kalifikazioa = "ONGI";
break;
case 7: kalifikazioa = "OSO ONGI";
break;
case 8: kalifikazioa = "OSO ONGI";
break;
case 9: kalifikazioa = "BIKAIN";
break;
case 10: kalifikazioa = "BIKAIN";
break;
default: kalifikazioa = "GUTXI";
}
System.out.println ("Jasotako nota da: " + nota);
System.out.println ("eta jasotako kalifikazioa: " + kalifikazioa);
}
}
3.4. ERREPIKAPEN-EGITURAK
Orain arte ikusi dugunez, gure programek baldintzak har ditzakete kontuan exekutatzen direnean,
baina oraindik ez dakigu nola egin instrukzio multzo bat errepikatzea. Hori egiteko, errepikapen-
egiturak daude. Egitura hauek instrukzio multzo bat errepikatzen dute baldintza bat kontuan
hartuta.
Egitura hauei errepikapen-egitura, begizta edo iterazio-egitura esaten zaie. Javan, 4 begizta mota
daude:
for begizta
for/in begizta (aurrerago ikusiko da).
while begizta
do/while begizta
for eta for/in kontagailu bidez kontrolatutako begiztak dira. while eta do/while, ordea, gertaera
bidez kontrolatutakoak.
Zein begizta erabili erabakitzeko, galdera hauei erantzungo diegu:
- Ba al dakigu, aldez aurretik, instrukzio multzoa zenbat aldiz errepikatu behar dugun?
- Errepikapen-egitura hasieran exekutatzea, berez egiten da, ala baldintzatuta dago?
- Noiz arte errepikatu behar dugu instrukzio multzoa?
- Baldintza bat betetzen bada, egin behar ote dugu errepikapena?
Begizta bakoitza banan-banan aztertuko dugu:
3.4.1. FOR EGITURA
for kontagailu bidez kontrolatutako begizta da. Begizta honek ezaugarri hauek dauzka:
- Badakigu zenbat bider errepikatuko den.

- Kontagailu-aldagai bat erabiltzen du zenbat iterazio egiten diren kontrolatzeko.
Begizta mota honetan, 3 eragiketa egin ohi dira:

- Kontagailu-aldagaia hasieratzen da.
- Kontagailu-aldagaia ebaluatzen da. Beraren balioa eta ezarritako iterazio kopurua
konparatzen dira.
- Kontagailu-aldagaiaren balioa eguneratzen da, eta handitu edo txikitu egiten da iterazio
bakoitzean.
FOR
for (hasieratzea; baldintza; eguneratze- - Hasieratzea: kontagailu-aldagaia hasieratzen
espresioa) da. Aldagai honek kontrolatuko du begiztaren
sententzia 1_1; eragina noiz amaituko den.
(sententzia bakarreko for egitura) - Baldintza: kontagailu-aldagaia ebaluatzen du.

Baldintza egia den bitartean, begizta
errepikatuko da. Faltsua denean, begizta amaitu
for (hasieratzea; baldintza; eguneratze- egingo da.
espresioa){
sententzia 1; - Eguneratze-espresioa: kontagailu-aldagaiaren
sententzia 2; balioa aldatzen doa begizta exekutatzen den
… bakoitzean. Balio horrek gora edo behera egin
sententzia N; dezake.
}
(sententzia blokea duen for egitura)

ADIBIDEA
Honako programa honek zazpiaren biderkatze-taula ateratzen du pantailan for errepikapen egitura
erabilita. Erreparatu, kontu handiz, kodean sartuta dauden komentarioei.
public class Errepikapenak_for {

/* for egitura erabiliko dugu pantailan zazpiaren taula erakusteko
*/
// Aldagaiak deklaratu eta hasieratu
int zenbakia = 7;
int kontagailua;
int emaitza = 0;
System.out.println (zenbakia+" zenbakiaren biderkatze-taula");
System.out.println (".............................. ");
//for begizta erabiliko dugu
for (kontagailua = 1; kontagailua< = 10;kontagailua++){
/* Begiztaren buruan, aldagai-kontagailua hasieratzen da. Baldintza da errepikapena 1etik

10era egitea, eta aldagaia banan-banan handitzen da iterazio bakoitzean
(kontagailua + +).
*/
emaitza = kontagailua * zenbakia;
System.out.println(zenbakia + " x " + kontagailua + " = " + emaitza);
/* + eragilea erabiliz testuak eta aldagaien balioak kateatzen ditugu.
*/
}
}
}
3.4.2. WHILE EGITURA
while egitura gertaeren bidez kontrolatutako begizta da, ez kontagailuaren bidez. while erabiliko
dugu ez dakigunean kode-bloke bat zenbat aldiz errepikatu behar den, baina jakin dakigunean
errepikatu egin behar dugula baldintza bat betetzen den bitartean.
Lehenik eta behin, while begizta kontrolatzen duen baldintza ebaluatzen da, eta egia bada,
begiztaren gorputza exekutatuko egingo da eta baldintza faltsu bihurtu arte jarraituko du
exekutatzen.
Baldintza faltsua bada ebaluatzen den lehen aldian, begiztaren gorputza ez da exekutatuko.
Derrigorrezkoa da baldintza aldatuko duen sententziaren bat egotea while begiztaren gorputzaren
barruan. Hala ez balitz, begizta infinitu bat izango genuke.
WHILE
while (baldintza) while (baldintza){
sententzia 1; sententzia 1;
sententzia 2;
(sententzia bakarreko while egitura) …
sententzia N;
}
(sententzia-blokea duen while egitura)
Baldintza egia den bitartean, begizta errepikatu egingo da eta gorputzeko sententziak exekutatuko
ditu.
Baldintza faltsua izatera pasatzen den unean, programaren fluxua while begiztaren ostean dagoen
sententziara pasatuko da.
Baldintza hasieran ebaluatuko da beti, eta gerta liteke haren gorputzean dauden aginduak inoiz ez
exekutatzea, hasieratik baldintza faltsua bada.
ADIBIDEA
Honako programa honek zazpiaren biderkatze-taula ateratzen du pantailan while errepikapen-

egitura erabilita. Erreparatu, kontu handiz, kodean sartuta dauden komentarioei.
public class Errepikapenak_while {

/* while egitura erabiliko dugu pantailan zazpiaren taula erakusteko
*/
int zenbakia = 7;
int kontagailua;
int emaitza = 0;
//while begizta erabiliko dugu
kontagailua = 0;
while (kontagailua<10){
/* Begiztaren baldintza ezarri dugu (kontagailua < 10)
*/
kontagailua ++;
/*Kontagailuaren balioa aldatzen dugu, begizta infiniturik ez sortzeko.*/
}
}
}
3.5. DO/WHILE EGITURA
while egitura bezala, hau ere gertaeren bidez kontrolatutako egitura da. Kasu honetan, begiztaren
gorputzean dagoen kodea gutxienez behin exekutatuko da, eta errepikatzen jarraituko du baldintza
bat betetzen den bitartean.
while eta do/while egituren arteko desberdintasunik handiena hau da : while egituran, hasierako
baldintza betetzen ez bada, begiztaren gorputza ez da sekula exekutatuko, eta do/while egituran,
aldiz, begiztaren gorputzeko kodea gutxienez behin exekutatuko da.
Derrigorrezkoa da baldintza aldatuko duen sententziaren bat egotea do/while begiztaren
gorputzaren barruan. Hala ez balitz, begizta infinitu bat izango genuke.
DO/WHILE
do do{
sententzia 1; sententzia 1;
while (baldintza) sententzia 2;
…
sententzia N;
(sententzia bakarreko do/while egitura) }
while (baldintza)
(sententzia-blokea duen do/while egitura)
Gorputzeko kodea behin exekutatuko da, eta gero, baldintza ebaluatuko da. Baldintza egia den
bitartean, begizta errepikatu egingo da eta gorputzeko sententziak exekutatuko ditu.
Baldintza faltsua izatera pasatzen den unean, programaren fluxua do/while begiztaren ostean
dagoen sententziara pasatuko da.
Gorputza baldintza ebaluatu aurretik exekutatzen da, beraz, ezin liteke gertatu gorputzean dauden
aginduak inoiz ez exekutatzea.
ADIBIDEA
Honako programa honek zazpiaren biderkatze-taula ateratzen du pantailan do/while errepikapen

egitura erabilita. Erreparatu, kontu handiz, kodean sartuta dauden komentarioei.
public class Errepikapenak_do_while {

/* do/while egitura erabiliko dugu pantailan zazpiaren taula erakusteko
*/
int zenbakia = 7;
int kontagailua;
int emaitza = 0;
//do/while begizta erabiliko dugu
kontagailua = 0;
do{
kontagailua ++;
/*Kontagailuaren balioa aldatzen dugu, begizta infiniturik ez sortzeko.*/
}while (kontagailua<10);
/* Begiztaren baldintza ezarri dugu (kontagailua < 10) */
}
}
3.5. JAUZI EGITURAK
Nahiz eta gaitzetsita egon egitura hauek erabiltzea, Javak, badu baldintzarik gabeko jauziak egiteko
egiturarik: break, continue, jauzi etiketak eta return sententzia.
3.5.1. BREAK ETA CONTINUE
break sententziak switch, while, for eta do/while egiturei eragiten die:
Aipatutako edozein egituratan break sententzia bat agertzen bada, egitura hori segituan amaituko
da.
Kateatutako begizta baten barruan agertzen bada break sententzia, barneren dagoen iterazioa
amaituko da, baina gainerakoa era arruntean exekutatuko da.
Hortaz, break sententzia begizta baten kontrol-fluxua eteteko erabiltzen da, nahiz eta begizta
horren baldintza bete ez.
Hurrengo kode zatian break sententzia bat dago for baten barruan.
public class break_sententzia {

int kontagailua;
// informazioa prozesatu eta pantailan atera
for (kontagailua = 1;kontagailua < = 10;kontagailua++){
if (kontagailua = = 7)
break;
System.out.println ("kontagailua: " +kontagailua);
}
System.out.println ("Programa amaitu da");
}
Begizta sei aldiz exekutatuko da, kontagailua izeneko aldagaia zazpi izan arren, programak break
bat aurkituko duelako. break horrek begiztaren fluxua etengo du eta programaren azken sententzia
exekutatuko da.
continue sententziak while, for eta do/while egituren gainean izan dezake eragina:
Aipatutako edozein egituratan continue sententzia bat agertzen bada, begizta hori amaitutzat
ematen da, eta begizta berri bat exekutatzen da (baldintza berriro ebaluatzen da).
continue sententzia kateatutako begizta baten barruan agertzen bada, barneren dagoen iterazioan
bakarrik izango du eragina, eta gainerakoa era arruntean exekutatuko da.
Hurrengo kode-zatian continue sententzia dago for baten barruan. Helburua da pantailan zenbaki
bikoitiak idaztea.
public class continue_sententzia {

int kontagailua;
// informazioa prozesatu eta pantailan atera
for (kontagailua = 1;kontagailua < = 10;kontagailua++){
if (kontagailua%2 ! = 0)
continue;
System.out.println ("kontagailua: " +kontagailua);
}
}
}
3.5.2. ETIKETAK
Nahiz eta baldintzarik gabeko jauziak eta batez ere etiketak ez diren bat ere gomendatzekoak, jakin
behar dugu existitzen direla.
break eta continue sententziek etiketekin egin dezakete lan.
Nola sortu etiketa bat? Etiketa sortzen da identifikatzaile bat eta bi puntu (:) jarrita. Bi puntu horien
ostean, etiketa horri lotutako sententziak idazten dira, giltzen artean sartuta. Etiketa bat sortzea
jauzi-puntu bat sortzea da, hain zuzen programaren beste leku batetik hara jauzi egiteko aukera
ematen duen jauzi-puntua sortzea.
Nola egin jauzia? break edo continue jarri, eta haien atzetik etiketaren izena jarrita.
Sintaxia hau da: break <etiketa>

Ondorengo kodean, begizta baten barruan dauden bi etiketa dauzkagu:
public class Etiketak {

for (int i = 1; i<3;i++){ //begiztaren burua
lehenengo_blokea:{ //lehenengo etiketa
bigarren_blokea:{ //bigarren etiketa
System.out.println("iterazioa: "+i);
if (i = = 1) break lehenengo_blokea; //lehenengo jauzia
if (i = = 2) break bigarren_blokea; //bigarren jauzia
}
System.out.println("Bigarren blokea amaituta");
}
System.out.println("Lehenengo blokea amaituta");
}
System.out.println("Begizta amaituta");
}
}
Aurreko kodea exekutatzen badugu, emaitza hau da:
iterazioa: 1
Lehenengo blokea amaituta
iterazioa: 2
Bigarren blokea amaituta
Lehenengo blokea amaituta
Begizta amaituta
3.5.3. RETURN SENTENTZIA
return sententzia erabilita, metodo bat bere kode osoa exekutatu aurretik amaitzea lortu daiteke.
return sententzia bi eratan erabili daiteke:
- metodo bat amaitzeko. Guk puntu batetik egingo diogu dei metodoari; bada, kontrola
puntu horretara itzuliko da, eta programak hortik aurrera segituko du exekutatzen.
- balio bat itzultzeko.
Orokorrean, return sententzia metodoaren bukaeran egoten da. Hala ere, posible da return
sententzia metodoaren edozein tokitan egotea. Hori gertatzen bada, metodoa return-a dagoen
puntuan amaituko da. Ez da komeni metodo bakoitzean return bat baino gehiago egotea.
Itzulera-balioa egotea hautazkoa da. Egotekotan, metodoaren buruan definitu dugun itzulera-
balioaren mota bereko datua izan behar du. Metodoaren buruan void motako datu bat jartzen
badugu, ez da egongo itzulera-baliorik.
Kode honek bi zenbaki jasotzen ditu teklatu bidez eta haien arteko batuketa egiten du:
import java.io.*;
/**
*
* return metodo batean
*/
public class return_sententzia {
private static BufferedReader stdin = new BufferedReader( new
InputStreamReader(System.in));
public static int batuketa(int batugaia1, int batugaia2)
{
int batura;
batura = batugaia1 + batugaia2;
return batura; //return erabilita batuketaren emaitza itzuliko dugu
}
public static void main(String[] args) throws IOException {
//Aldagaiak deklaratzea
String sarrera; //Aldagai honek teklatu bidez sartutakoa jasoko du
int lehen_zenb, bigarren_zenb; //Aldagai hauek batugaiak gordeko dituzte
// Erabiltzaileari batugaiak eskatuko dizkiogu
System.out.print ("Sar ezazu lehenengo batugaia:");
sarrera = stdin.readLine(); //Sarrera String moduan irakurriko dugu
lehen_zenb = Integer.parseInt(sarrera); //sarrera zenbaki oso bihurtzea
System.out.print (" Sar ezazu bigarren batugaia: ");
sarrera = stdin.readLine();//Sarrera String moduan irakurriko dugu
bigarren_zenb = Integer.parseInt(input);//sarrera zenbaki oso bihurtzea
//Sartutako zenbakiak pantailaratuko ditugu

System.out.println ("Batugaiak: " + lehen_zenb + " eta " + bigarren_zenb);
System.out.println ("Batuketa kalkulatzen... ");
//Batuketa kalkulatzen duen metodoari dei egingo diogu parametro egokiekin
System.out.println ("Batuketaren emaitza: " +
batuketa(lehen_zenb,bigarren_zenb));
}
}
3.6. SALBUESPENAK
Orain arte egin ditugun zenbait programak erroreak izan dituzte seguru asko. Normalean
konpilatzaileak ematen digu errore horien berri: puntu eta koma bat faltan egotea, aldagai baten
izena gaizki idatzita egotea...
Baina, horiek ote dira programa batean egon daitezkeen errore bakarrak? Ez, badaude
konpilazioan agertu ez eta programa exekutatzean agertuko diren erroreak. Errore horiek
salbuespen izena hartzen dute.
Salbuespenak era egokian erabiltzen ikasiko dugu. Javak erroreak kudeatzeko daukan sistema oso
ahaltsua da:
- erroreak kudeatzen dituen kode-zatia oso erraz identifikatzen da programen barruan.

Erroreak kudeatzeko kodea eta aplikazioaren berezko kodea banatuta egon daitezke.
- Javak errore estandar asko dauzka definituta: zatitzailetzat zero duten zatiketak, akatsak
datuak sartzean...
Javan, aurretiaz zehaztu genezake zer egin salbuespenak sor ditzaketen kode-zatiak exekutatzean:
errorea gertatuko balitz, programaren exekuzio fluxua aldatu egingo litzateke, eta salbuespen horri
erantzuna emango dion kode-bloke batetara helduko litzateke. Salbuespena harrapatzen ez
badugu, programa gelditu egingo da kasurik gehienetan.
Javan, salbuespenak klaseen bidez adierazten dira. java.lang.Exception paketeak eta horren
azpipaketeek salbuespen mota guztiak gordetzen dituzte. Salbuespen guztiak Throwable klasearen
azpiklaseak dira. Klase horren azpian, Error eta Exception klaseak daude. Error klaseak makina
birtualean gertatzen diren erroreak kudeatuko ditu; ez gure programetan gertatzen direnak. Guri
benetan interesatzen zaigun klasea Exception da, programetan gertatzen diren erroreak kudeatzen
dituelako.
Errore bat gertatzen denean, salbuespenari lotutako objektu bat sortzen da. Objektu hori
Exception klasekoa edo haren oinordeko baten klasekoa izango da. Objektu hori salbuespena
kudeatuko duen kode-zatiari pasatu behar zaio.
Programatzaileak bere salbuespenak ere sortu eta jaurti ditzake. Salbuespen horiek Exception
klasearen klase-oinordekoen objektuak izango dira. Exception klasearen klase-oinordekoen
hierarkia oso bat dago. Klase horiek bi multzotan sailkatu ditzakegu:
- Programa exekutatzean gertatzen diren salbuespenak, programatzailearen akatsen

ondoriozkoak.
- Ustekaberen bat gertatu dela adierazten duten salbuespenak.
Hona hemen, Javaren salbuespenen hierarkiaren hurbilketa bat:
3.6.1. SALBUESPENAK HARRAPATZEA

Salbuespenak harrapatzeko, try-catch-finally egitura erabiliko dugu. Salbuespena harrapatu ahal
izateko, salbuespen hori eragin dezaketen sententziak try bloke baten barruan sartu behar dira.
Salbuespena gertatzen bada, salbuespen hori jaurti egingo da, eta catch blokeek harrapatu egin
dezakete jaurtitako salbuespen hori. Bloke horien barruan kudeatuko dira salbuespenak.
Erabiltzen den sintaxia hau da:
try {
salbuespena sortu dezakeen kode-zatia
} catch (Salbuespen_mota_1 salbuespen_objektua) {
Salbuespen_mota_1 kudeatzea;
} catch (Salbuespen_mota_2 salbuespen_objektua) {
Salbuespen_mota_2 kudeatzea;
}
...
finally {
Beti exekutatuko den kodea.
}
catch zatia hainbat aldiz errepika daiteke; kudeatu nahi dugun salbuespen mota bakoitzeko catch
bat jarriko dugu.
Finally zatia hautazkoa da, eta, agertzekotan, behin bakarrik agertuko da.
catch bakoitzak salbuespen mota bat kudeatzen du. Salbuespena gertatzen denean, salbuespen-
kudeatzaile egokia daukan catch-a bilatuko du programak, hau da, gertatu den salbuespenaren
mota berekoa dena.
Kontu handiz ibili behar dugu, garrantzi handikoa baita catch-ak zer ordenatan dauden idatzita.
Adibidez, demagun ArithmeticException motako salbuespen bat gertatzen dela, eta lehenengo
postuan kokatuta daukagun catch-ak Exception motako salbuespenak harrapatzen dituela.
ArithmeticException salbuespena Exception superklasearen azpiklase bat da; beraz, lehenengo
catch hori besterik ez da exekutatuko.
Hori dela eta, salbuespen orokorrak kudeatuko dituen catch-a azken tokian kokatu behar dugu eta
salbuespen zehatzagoak kudeatuko dituzten catch-ak, haren aurrean. Hori bai, salbuespen guztiak
era berean kudeatu behar baditugu, nahikoa izango da Exception objektuak harrapatuko dituen
catch bakarra jarrita.
ARIKETA EBATZIA
Programak zenbaki bat sartzeko eskatuko dio erabiltzaileari, teklatu bidez eta 0 eta 100 zenbakien
artean dagoena. Programak zenbakia egokia den kontrolatuko du, eta hala ez balitz, zenbakia
berriro eskatu.
import java.io.*;
public class Salbuespenak_ariketa_ebatzia {
public static void main(String[] args){
int zenbakia = -1;
int saiakerak = 0;
String lerroa;
BufferedReader teklatua = new BufferedReader(new InputStreamReader(System.in));

do{
try{
System.out.print("Sar ezazu zenbaki bat teklatu bidez (0-100):");
lerroa = teklatua.readLine();
zenbakia = Integer.parseInt(lerroa);
}catch(IOException e){
System.out.println("Teklatutik irakurtzean errorea egon da.");
}catch(NumberFormatException e){
System.out.println("Zenbakia sartu behar duzu (0-100)");
}finally{
saiakerak++;
}
}while (zenbakia < 0 || zenbakia > 100);
System.out.println("Sartutako zenbakia hau da: " + zenbakia);

System.out.println("Saiakerak: " + saiakerak);
}
}
Aurreko programan, do/while errepikapen-egitura erabili izan da, erabiltzaileari behin eta berriro
zenbakia sar dezan eskatzeko hein egokiko zenbakirik sartzen ez duen bitartean.
Ager litezkeen erroreak hauek dira:
- Informazioa sartzean: IOException motako salbuespena.

- Datu motak ParseInt metodoa erabilita bihurtzean: NumberFormatException motako
salbuespena.
Salbuespen bat gertatzen denean, begiratzen da gertatutako salbuespena ea bat datorren lehen
catch-eko salbuespen motarekin. Ez badatoz bat, hurrengo catch-eko salbuespenarekin bat
datorren begiratzen da.
Bat badatoz, catch-ak daukan sententzia-blokea exekutatu egingo da.
Bat datorren catch-ik ez badago, salbuespena try-catch-finally egituratik kanpora jaurtiko da.
finally blokea, baldin eta badago, beti exekutatzen da, bai try zatia errorerik gabe exekutatzen
denean, bai salbuespenen bat gertatzen denean.
3.6.2. THROWS
Salbuespen bat metodo baten barruan gertatzen bada, nork kudeatzen du salbuespen hori?
Metodoak, ala metodoari dei egin dion kodeak?
Aukera biak dira posible. Metodo batek salbuespenak jaurti ditzaketen sententziak dauzkanean
baina salbuespena kudeatzeko koderik ez, metodoari dei egin dion kodeari pasatuko zaio
salbuespena. Horri salbuespenak eskuordetzea esaten zaio.
Eskuordetze hori ezartzeko, metodoaren buruan metodoak berak jaurti ditzakeen salbuespen
motak deklaratu beharko dira. Hori egiteko, throws sententzia erabiliko dugu. throws-en atzetik,
metodoak zeintzuk salbuespen jaurti ditzakeen jarriko dugu. Salbuespenen bat gertatuz gero,
kodeak metodoa utzi egiten du eta metodoari dei egin dion kodera abiatzen da salbuespenari
dagokion catch-aren bila.
Sintaxia hau da:
public class Salbuespenen_ordezkaritza {

...
public int urteairakurri(BufferedReader teklatua) throws IOException, NumberFormatException{
String lerroa = teklatua.readLine();
Return Integer.parseInt(lerroa);
}
...
}
3.7. SOFTWARE-PROBAK
Software-probak teknika multzo bat dira, programak bere eginkizuna era egokian egiten duela
ziurtatzeko. Guk probatu egiten ditugu gure programak ea errorerik dagoen jakiteko. Errore bat
antzematen dugunean, errorea non dagoen aurkitu behar dugu, eta errorea konpontzeko egin
beharreko aldaketak gauzatu.
Hala ere, software-probak egiteko teknikek ez dute bermatzen errore guztiak aurkituko ditugunik.
Horrela, bada, sarritan programa oso handiek ere ezkutuko erroreak izango dituzte.
Dena den, sofware-probak oso garrantzitsuak dira. Programa bat garatzeko behar den denbora
osoaren ia erdia probak egiteko erabiltzen da. Erakunde askok eta askok programatzaile adina
probatzaile daukate lan egiten.
Oso zeregin garrantzitsua da programak egiaztatzea. Prozesu horretan, programak espero dena
egiten duela ziurtatzen da; programak bere zehazpenekin bat egiten duela, alegia.
Ikasiko ditugun teknikak hauek dira:
- Kutxa beltzaren probak.

- Kutxa zuriaren probak.
- Berrikuspenak
- Araztaile (debugger) bat erabiltzen programa pausoz pauso exekutatzeko.
Klase bakarra duen programa bat, normalean, bere osotasunean proba daiteke; baina hainbat
klase dituzten programak, sarritan, zatitu egin beharko ditugu probak era egokian egin ahal izateko.
Javan, komeni da programak klasez klase probatzea. Hori egiteari unitate-proba esaten zaio. Zati
guztiak elkartu eta programa osoa probatzeari integrazio-proba esaten zaio.
3.7.1. ZEHAZPENAK
Edozein probaren abiapuntua zehazpenak dira. Sarritan, beharrezkoa izango da bezeroa edo
programaren erabiltzailea izango dena berriro elkarrizketatzea.
Pentsa ezazu zehazpen hau daukagula:
Testu kutxen bidez, programak erabiltzaileari zenbakiak eskatuko dizkio. Ondoren, sartutako
zenbaki horiek batu egingo ditu programak, eta emaitza erakutsiko du.
Lehenengo begirada batean, zehazpenak sinplea eta argia dirudi. Ez da hala. Ikus dezagun:
1. Osoak ala errealak izango dira zenbakiak?

2. Zein izango da zenbakien heina eta zehaztasuna?
3. Erabiliko da zenbaki negatiborik, ala ez?
Programatzen hasi aurretik galdera horien erantzunak argi ez badaude, arazoak egon daitezke
programa idaztean.
Hona hemen aurreko programaren zehazpen argi bat.

Testu kutxen bidez, programak erabiltzaileari zenbaki osoak eskatuko dizkio. Zenbaki horiek 0ren
eta 10.000ren artean egon behar dira. Ondoren, sartutako zenbaki horiek batu egingo ditu
programak, eta emaitza erakutsiko du.
3.7.2. PROBA SAKONAK
Aukera guztiak probatu behar ote dira? Hori egiteari, hau da sarreran erabili daitezkeen balio
guztiak eta horien arteko konbinazio guztiak probatzeari, proba sakona esaten zaio. Baina, sarreran
int motako zenbaki guztiak onartuko balira, urteak eman genitzake mota honetako proba bat
egiteko.
Proba sakonak, beraz, ez dira eraginkorrak, eta, ondorioz, beste teknika batzuk erabili beharko
ditugu.
3.7.3. KUTXA BELTZAREN PROBAK
Sartu daitezkeen datu guztien lagin bat hartzen da. Datu horiekin probatzen da programa, eta ea
zer gertatzen den aztertzen da.
Zergatik deitzen dira kutxa beltzaren probak? Ez dagoelako jakin beharrik programak nola
funtzionatzen duen barrutik. Sartzen diren datuak eta irteten direnak besterik ez dira aztertzen.
Programa kutxa beltz baten antzekoa dela imajinatzen dugu: sarreran datu batzuk jasotzen ditu eta
emaitza batzuk atera.
Hasteko, probaren sarrera-datuak eta aurreikusitako emaitzak idazten dira proba exekutatu
aurretik. Gero, idatzitako datuekin programa exekutatzen da eta aurreikusitako emaitzekin ea
alderik dagoen aztertzen da.
3.7.4. KUTXA ZURIAREN PROBAK
Proba hauek egiteko programa barrutik ezagutu behar da. Probek programaren zati guztiak
exekutatu behar dituzte. Horretarako baldintzak, begiztak... kontuan hartu behar dira.
Oso garrantzitsua da zer datu sartuko diren hautatzea, datu horiekin exekuzio-adar guztiak probatu
behar baitira.
3.7.5. BESTE PROBA MOTA BATZUK
Kutxa zuri eta kutxa beltzez aparte, badaude beste proba mota batzuk ere:
a) Berrikuspenak
Ez da ordenagailua erabiltzen. Komeni da berrikuspena egiten duen pertsona programa garatu

duen pertsona bera ez izatea. Askotan ez gara gai guk geuk egin dugun programa batean dagoen
akats bat antzemateko; ordea, gure programa ezagutzen ez duen norbaitek berehala aurkitzen du
akatsa begiratu batean.
Proba mota hau gauzatzeko, beharrezkoa da paperean izatea, alde batetik, programaren
zehazpenak, eta bestetik, iturburu-kodea. Honako hauek aztertu behar dira: aldagaiak nola
hasieratu diren, metodoei nola egin zaien dei, metodoen buruak nola definitu diren, parametroak
egokiak diren, etab. Ondoren, kodea exekutatuko dugu, gu ordenagailua bagina bezala.
b) Pausoz pauso kodearen analisia egin.
Garapen-ingurune askok kodea pausoz pauso exekutatzea ahalbidetzen dute. Horrela, posible da
programa nondik nora doan ikustea, baita aldagaiek zeintzuk balio hartzen dituzten aztertzea ere.
3.8. NOLA ERABILI DEBUG MODUA ECLIPSE-n
Debug moduak gure kodea nola exekutatzen den pausoz pauso jarraitzen laguntzen digu. Hori
egiteari kodea araztea esaten zaio.
Debug modua abiarazteko, programa ixteko botoiaren azpian dagoen ikono hau sakatuko dugu:
eta pantaila hau agertuko zaigu:

Debug aukeratuko dugu, eta, gero, OK sakatu. Hasieran sakatu dugun botoitik oso gertu, beste
botoi bat agertuko da:
Eclipse-ren itxura aldatu egin da. Hurrengo pausoa breakpoint-ak kokatzea izango da. Lehenengo
breakpoint-ean hasiko da programa pausoz pauso exekutatzen. Breakpoint bat jartzeko, klik
bikoitza egingo dugu programaren kodea dagoen leihoaren ezker aldean, zati urdinean,
interesatzen zaigun lerroaren ondoan.
Horrela geratuko da:
Proba jarraitzeko, menuan Run-> Debug aukeratuko dugu. Hori eginda bagaude, Debug moduan.
Goiko eskuineko aldean, aldagaiak eta horien balioak ikusiko ditugu leiho batean:
Eta, leihoaren erdi partean, programa pausoz pauso exekutatzen.
Lerroa berde dagoenean, oraindik exekutatu gabe dago. Lerro bat aurrera egiteko, F5 tekla
sakatuko dugu. Metodo baten deiarekin topo egiten badu, metodoaren barruan sartuko da. F6
teklak F5 teklaren berdina egiten du, baina ez da metodoen barruan sartzen.
Nahi adina breakpoint jar daitezke. Normalean errorea egon daitekeela sumatzen dugun tokietan
jarriko ditugu.
3.9. KODEAREN DOKUMENTAZIOA
Galdera batzuk erantzuten hasiko gara:
- Nork erabiliko du kodearen dokumentazioa? Normalean, kode horren egileak edo beste
programatzaile batzuek.
- Zergatik dokumentatu behar dugu kodea? Izugarri errazten delako programa mantentzea
eta berrerabiltzea.
- Zer dokumentatu behar dugu? Derrigorrean, klaseak, paketeak, sortzaileak, metodoak eta
atributuak. Aukeran, begiztak, algoritmoen zati konplexuak...
Askotan gertatzen da beste programatzaile baten kodea irakurri eta kode horrek zer egiten duen ez
ulertzea. Arrazoi horiek eta beste batzuk direla-eta, oso garrantzitsua da dokumentazio on bat
idaztea.
API-a ikusten badugu, dokumentazio guztiak egitura bera daukala ohartuko dugu. Arrazoia hau da:
dokumentazio hori egiteko Javadoc deituriko tresna erabili da; beraz, geuk ere gure programak
Javadoc erabilita dokumentatuko ditugu. Nola egiten da? Dokumentazioaren iruzkinak deitzen
diren iruzkin berezi batzuei esker. Javadoc-ek iruzkin horiek hartuta, HTML motako hainbat
fitxategi sortuko ditu, eta hortik aurrera, edozein nabigatzaile erabilita, posible da dokumentazioa
erabiltzea.
Dokumentazioaren iruzkinen hasiera marka /**da, eta amaiera marka, */. Bi zati ezberdin
aurkituko ditugu: lehenengoan, deskribapen bat egingo dugu, eta bigarrenean, hainbat etiketa
erabiliko ditugu.
- Deskribapenen atala: Programatzaileak klaseari, metodoari, sortzaileari edo atributuari

buruzko informazioa jarriko du atal honetan. Beharrezkoa den testu guztia sar daiteke, eta,
nahi izanez gero, HTML etiketak ere gehitu daitezke testuari formatua emateko.
- Etiketen atala: Etiketa bakoitzak esanahi berezi bat dauka, eta aurrerago ikusiko ditugu.
/** Elementu bat bilatzen du Vector klaseko objektu batean. Aurkitzen badu, elementua
* zein posiziotan aurkitu den itzuliko du. Aurkitzen ez badu, -1 itzuliko du.
*
*
* @param el. Zein elementu bilatu behar den
* @param. hasiera. Objektuaren zein posiziotik aurrera hasiko den bilatzen
* @return. Objektuaren barruan elementua zein posiziotan dagoen
* @throws IndexOutOfBoundsException. Hasierako parametroa negatiboa bada
*/
public int indexOf (Object el, int hasiera){

3.9.1. ETIKETAK ERABILI
Hauek dira etiketarik ohikoenak eta zer esanahi duten:
- @autor izena: Klaseetan eta interfazeetan onartzen da. Mota honetako behar beste etiketa
jar ditzakegu.
- @version bertsioa: Komeni da bertsioaren zenbakia jartzea, baita data ere. Bata bestearen
atzetik mota honetako hainbat etiketa sar ditzakegu.
- @deprecated testua: Adierazten du ez dela komeni erabiltzea. Testuak zergatia azalduko du.
Dokumentazioaren edozein ataletan ager daiteke.
- @exception salbuespenaren izena: @throws bezalakoa da.
- @param atributuaren izena: Sortzaile eta metodoen parametroak deskribatzen ditu. Mota
honetako etiketa bakoitzaren atzean, parametroaren izena jarriko da eta deskribapen bat
ere bai.
- @return testua: void itzultzen duten metodoetan ez dugu etiketa hau jarri behar. Gainerako
metodoetan agertuko da, eta itzulera-balioa zer motakoa den eta zeintzuk balio har
ditzakeen adieraziko du.
- @see erreferentzia: Dokumentazioaren beste atal batera joateko estekak jartzeko erabiltzen
da. Adibidez:
* @see "Patroien diseinua”

* @see <a href = "http://www.w3.org/WAI/">Web Accessibility Initiative</a>
* @see String#equals(Object) equals
- @throws salbuespenaren izena: Salbuespenaren izen osoa idatzi beharko dugu. Salbuespen
bat baino gehiago badago, alfabetikoki ordenatuta jarri beharko dira. Sortzaileetan eta
metodoetan erabil daiteke.
3.9.2. ETIKETAK ORDENATZEA
Etiketek ordena egoki bat daukate:
Etiketa Non erabiltzen dira

@autor Klase eta interfazeetan. Hainbat jar daitezke.
@version Klase eta interfazeetan.
@param Metodo eta sortzaileetan.
@return Metodoetan.
@exception Metodo eta sortzaileetan.
@throws Metodo eta sortzaileetan.
@see
@deprecated
ADIBIDEA
/**
* Klasearen deskribapen orokorra
*
* @author Oier Palacios
* @version 1.0
*/
public class JavadocAdibidea {
/** atributu1 zer egiten duen azalduko dugu hemen */

public String atributu1;
private int atributu2;
/**
* Sortzailearen deskribapena
**
* @param atributu1 Lehen parametroaren deskribapena
* @param atributu2 Bigarren parametroaren deskribapena
*/
JavadocAdibidea(String atributu1, int atributu2) {
this.atributu1 = atributu1;
this.atributu2 = atributu2;
}
/**
* metodo1 metodoaren deskribapena
*
* @param parametro3 Parametro bidez pasatuko den balioaren deskribapena
* @return Metodoak itzuliko duen balioaren deskribapena
*/
public int metodo1(int parametro3) {
return 1;
}
}
Eklipsen, Javadoc erabili eta HTML dokumentazioa sortzeko, Generate->Javadoc aukera erabiliko
dugu. Aurreko adibidearen dokumentazioa hau da:
ARIKETA ERRAZAK
1. Sortu ezazu honako begiztaren gauza bera egingo duen while begizta:
for (i = 5; i<15; i++){

System.out.println(i);
}
2. Idatz ezazu programa bat, begiztak erabilita, pantailan irudi hau erakutsiko duena:
*
***
*****
3. Idatz ezazu pantailan lehenengo 5 zenbaki bikoitiak idatziko dituen programa.
4. Idatz ezazu pantailan 200en eta 300en artean dauden zenbakiak idatziko dituen programa.
5. Idatz ezazu pantailan lehenengo hamar zenbakiak letraz idatzita aterako dituen programa. Erabil
ezazu default bat edukiko duen switch egitura.
6. Sortu ezazu teklatu bidez hiru zenbaki jasoko dituen programa bat, eta zenbaki handiena eta
txikiena pantailan aterako dituena.
ARIKETA ZAILAK
1. Idatz ezazu programa bat, hiru zifrako zenbaki bat jasota zenbaki hori Armstrong zenbakia den
ala ez aztertuko duena.
Zenbaki bat Armstrong den ala ez jakiteko, hau egin behar da. Lehenengo zenbakiaren zifra
bakoitza ber zenbakiaren zifra kopurua egingo dugu, eta, ondoren, emaitza guztiak batuko ditugu.
Batuketan lortzen den zenbakia eta jatorrizko zenbakia berdinak badira, zenbaki hori Armstrong
zenbaki bat da.
Adibidea:
153 = 13+53+33 (ber hiru egiten da jatorrizko zenbakiak hiru zifra dauzkalako).
2. Sortu ezazu letra bat gorde eta maiuskula bihurtuko duen Letrak izeneko klasea. Klaseak metodo
hauek izango ditu:
getLetra(): gordetako letra itzuliko du.

printLetra(): letra pantailan idatziko du.
Programak letrak bakarrik har ditzala zainduko dugu (a-z A-Z). Bestela, programak mezu bat
aterako du printLetra() metodoari dei egiten zaionean.
3. Idatz ezazu pertsona baten zorte oneko zenbakia kalkulatuko duen programa bat. Zorte oneko
zenbakia kalkulatzeko jaiotze eguna, hila eta urtea batu behar dira lehenengo. Ondoren,
emaitzaren zifrak batu behar dira behin eta berriz, zifra bakar bat lortu arte.
Adibidez:
1973-08-16 -> 1973 + 8 + 16 = 1997

1997 -> 1 + 9 + 9 + 7 = 26
26 -> 2 + 6 = 8
4. Idatz ezazu programa bat, begiztak erabilita, pantailan irudi hau erakutsiko duena:
*
***
*****
*******
*****
***
*
5. Programa bat idatziko dugu. Programak notak irakurriko ditu teklatu bidez (notak zenbakizkoak
izango dira eta hamartarrak izan ditzakete). Zenbaki negatibo bat sartuta ez da beste notarik
eskatuko. Azkenean programak zenbat gainditu eta zenbat suspentso dagoen aterako du pantailan,
baita ikasleen bataz besteko nota ere.
Notaren bat baliozkoa ez balitz, programak berriro eskatu beharko luke.
6. Idatz ezazu kalkulagailu baten antzera funtzionatu behar duen programa bat. Programaren
hasierako pantailak honen antzekoa izan behar du:
1. Oinarrizko eragiketak
2. Eragiketa konplexuak
3. Programa amaitu
Erabiltzaileak 1 zenbakia sartzen badu, hau agertuko da:
a. Batuketa
b. Kenketa
c. Biderketa
d. Zatiketa
Hasierako pantailan erabiltzaileak 2 zenbakia sartzen badu, hau agertuko da:
a. Berreketa
b. Erro karratua
Behin erabiltzaileak egin nahi duen eragiketa aukeratuta, programak beharrezkoak dituen datuak
eskatuko ditu pantaila bidez, eta erabiltzaileak teklatu bidez sartuko ditu. Datuak sartuta
daudenean, pantailan, eragiketaren emaitza agertuko da.
Programak gerta daitezkeen errore guztiak kontrolatu beharko ditu, eta beharrezkoa balitz, datuak
berriro eskatu.
ARIKETA OSOA
Sor ezazu, Liburutegi paketearen barruan, Liburu eta Nagusia izeneko klaseak izango dituen
proiektu berri bat, eta proba itzazu metodo guztiak.
Liburutegi klaseak hiru atributu izango ditu, String motakoak:
- izenburua: liburuaren izenburua.

- egilea: liburuaren egilea.
- isbn: liburuaren ISBN kodea.
Eta metodo hauek:
- public Liburu (String izenburua, String egilea, String isbn):

Klasearen sortzailea. Objektuaren atributuak hasieratzen ditu jasotako parametroekin.
Jasotako ISBN kodea baliozkoa ez bada, IllegalArgumentException salbuespena jaurtiko du.
Salbuespena jaurtitzeko hau jarri behar da:
throw new IllegalArgumentException(“ISBN horrek ez du balio”);
- get eta set metodo bana klasearen atributu bakoitzeko. setISBN metodoak ISBN kodea
baliozkoa dela ziurtatu beharko du. Hala ez balitz, IllegalArgumentException salbuespena
jaurtiko litzateke.
- private boolean egiaztatuIsbn10(String isbn): Metodo hau bai sortzaileak bai setISBN
metodoak erabiliko dute ISBN kodea zuzena den ala ez egiaztatzeko: true itzuliko du kodea
zuzena bada, eta false hala ez bada.
Nagusi klaseak main metodo bat izango du eta Liburu klasearen metodo publikoak erabiliko ditu.
main metodoan harrapatuko dugu sortzaileak eta setISBN metodoek jaurti dezaketen
IllegalArgumentException salbuespena.
Jar itzazu programa osoan beharrezkoak diren Javadoc etiketak, programa ondo dokumentatuta
gera dadin.
Nola egiaztatu ISBN kode bat zuzena den
ISBN kodeak 10 edo 13 karaktere izan ditzake (ariketan 10 karaktereko kodea baino ez dugu
erabiliko).
Zifra bakoitza zenbakian daukan posizioagatik biderkatuko dugu eta lortutako emaitzak batuko
ditugu. Emaitza hori 11 zenbakiaren multiploa bada, ISBN kodea zuzena da.
Adibidea: Frogatu 84-481-2231-3 ISBN kodea zuzena dela
Batuketa: 8*1 + 4*2 + 4*3 + 8*4 + 1*5 + 2*6 + 2*7 + 3*8 + 1*9 + 3*10 = 154
Zatiketa: 154/11 = 14. Hondarra 0 da, beraz ISBN kodea zuzena da.
4. GAIA: KLASEAK GARATZEA
4.1. SARRERA
Dagoeneko ikasi dugu atributuek eta metodoek osatzen dituztela klaseak, baita klase batek
zehazten dituela objektu multzo baten ezaugarri komunak ere.
Idatziko ditugun programak klasez osatuta egongo dira. Klase horiek instantziatuta, objektuak
sortuko ditugu, eta objektu horiek elkarrekin erlazionatuko dira.
4.1.1. OBJEKTU BAT ZER DEN ERREPASATZEN
Objektua informazioa gordetzen duen entitatea da, informazio horrekin hainbat eragiketa egin
dezakeena. Informazioak dauzkan balioen arabera, objektuak portaera bat edo beste izango du, eta
egin ditzakeen eragiketek definituko dute objektuak nola jokatuko duen.
Hauek dira objektuak:
- Auto gorri bat, SEAT markakoa, Ibiza modeloa, 2003. urtean egindakoa. Objektu horren
atributuak kolorea, marka, modeloa eta urtea dira. Beste hainbat atributu ere izan litzake:
geratzen zaion gasolina, guztira egindako kilometroak...
- Auto hori bat, OPEL markakoa, Astra modeloa, 2002. urtean egindakoa.
- Beste auto hori bat, OPEL markakoa, Astra modeloa, 2002. urtean egindakoa. Aurreko
objektuaren propietate berdinak dituen objektu bat da, baina ez da objektu bera.
- Luzeran 4 metro duen 20 urteko krokodiloa.
- Zirkulu bat, erradioa 2 cm-koa duena, zentroa (0,0) puntuan daukana eta horiz margotuta
dagoena.
- Zirkulu bat, erradioa 3 cm-koa duena, zentroa (1,2) puntuan daukana eta berdez margotuta
dagoena.
Aurreko adibideari erreparatzen badiogu, erraz bereiziko ditugu 3 objektu-familia desberdin, beren
artean harremanik ez dutenak.
- Autoak
- Zirkuluak
- Krokodiloak
Erraz pentsatu genezake objektu bakoitzak portaera zehatz jakin bat izango duela −hau da,
eragiketak edo metodoak−, dagokion familiaren arabera.
Autoen kasuan, adibidez, imajina ditzakegun eragiketak hauek izan daitezke: martxan jarri, gelditu,
balaztatu, martxa aldatu, azeleratu...
Krokodiloen kasuan, ordea, imajina ditzakegun eragiketak hauek izan daitezke: mugitu, jan, lo egin,
ehizatu...
Eta zirkuluen kasuan, hauek izan daitezke: azalera kalkulatu, perimetroaren luzera kalkulatu...
Erraz imajina daiteke, gainera, atributu batzuk ere aldatu egin daitezkeela, objektuaren gainean
egindako eragiketak direla eta. Autoa non dagoen (koordenatuak), autoak ibilitako kilometroak,
autoari zenbat gasolina geratzen zaion, krokodiloaren pisua, krokodiloak zenbat hortz eta hagin
dauzkan, krokodiloak zenbat harrapakin ehizatu dituen...
Objektu bat atributuen eta eragiketen (ekintzen) bidez definitu daitekeen edozein gauza da.
4.2. ZER DA KLASE BAT?
Programa batean, hainbat objektu erabil ditzakegu. Batzuen artean ez da batere antzik egongo,
baina ohartuko gara beste batzuek antz handia daukatela, portaera eta atributu berdinak
dituztelako. Objektu askok ezberdintasun bakarra izango dute: atributuetan hartzen dituzten
balioak.
Oso neketsua litzateke objektu bakoitzaren atributuak eta portaera definitzea programa batean
erabili nahi ditugun bakoitzean. Hori ekiditeko sortzen da klase kontzeptua. Ideia nagusia txantiloi
bat edukitzea da familia bereko objektuak definitzeko.
Azken finean, klasea hau da: Objektu mota baten definizio zehatza. Klase horretako objektuek zer
informazio izango duten (atributuak) eta nola portatuko diren (metodoak) esango digun
deskribapena.
Aurreko gaietan ikasi dugunez, klase bat deklaratzeko class hitz erreserbatua erabiltzen da.
Deklarazio horrek bi atal dauzka:
- Klasearen burua: Atzipen-aldarazleak class hitza eta klasearen izena dauzka.
- Klasearen gorputza: Atributuak eta metodoak dauzka.
4.2.1 KLASE BAT DEKLARATZEA
Klase baten deklarazioak honako egitura dauka:
[atzipen-aldarazleak] class <KlasearenIzena> [herentzia] [interfazeak] { // Klasearen burua

// Klasearen gorputza
Atributuen deklarazioa
Metodoen deklarazioa
}
Hau da oinarrizko adibide bat:
/**
*
* Puntu klasea
*/
class Puntu {
// Atributuak
int x,y;
// Metodoak
int getX () { return x; }
int getY() {return y;}
void setX (int vx) { x = vx; };
void set (int vy) { y = vy; };
}
Aurreko adibide horretan, klase bat deklaratzeko beharrezkoak diren gutxieneko atalak aipatu
ditugu. Informazio gehiago ematea ere badago: aldarazleak erabilita; superklasearen izena jarrita
azpiklase bat deklaratzean (herentzia); interfazeren bat inplementatzen duen edo ez; eta beste
hainbat gauza -pixkanaka ikasiko ditugu-.
Klase bat idazteko, puntu hauek izango ditugu kontuan:
- Klaseen izenak maiuskulaz hasiko dira. Klasearen izena hitz bat baino gehiagoz osatuta
badago, horietako bakoitzak ere bere lehen letra maiuskulaz izango du.
- Klaseen izen batzuk hauek izan daitezke: Zuzena, Zirkulua, Autoa, Jokalaria, FutbolJokalaria,
Animalia, ItsasAnimalia, etab.
- Klasea daukan fitxategiak klasearen izen bera edukiko du.
4.2.2. KLASEAREN BURUA
Klasearen deklarazioak atal hauek izan ditzake, eta ordena honetan:
- Aldarazleak: adibidez, public, abstract edo final.

- Klasearen izena (lehenengo letra maiuskulaz).
- Bere superklasearen izena extends hitza erabilita.
- Klaseak inplementatzen dituen interfazeen zerrenda bat, komaz banatuta. Hori egiteko,
implements hitza erabiliko da.
- Klasearen gorputza, giltzen artean.
Klase-buru baten sintaxi osoa hau da:
[aldarazleak] class <KlasearenIzena> [extends <SuperKlasearenIzena>][implements

<LehenInterfazearenIzena>],[[<BigarrenInterfazearenIzena>] …] {
Lehenago ikasi dugun Puntu klasearen burua hau izan da:
class Puntu {
Kasu horretan, ez dago aldarazlerik, ez herentzia adierazlerik, ezta interfazeen inplementaziorik

ere.
Herentzia eta interfazeak aurrerago ikasiko ditugu. Orain aldarazleak azalduko dira:
- public aldarazlea: klase publikoa beste edozein klasek ikus dezakeela adierazten du. Hau da,
beste edozein klasek sor ditzake klase horretako objektuak. Aldarazle hau jartzen ez bada,
pakete bereko klaseentzat bakarrik egongo da ikusgai klasea. Fitxategi batean public
aldarazlea daukan klase bakarra egon daiteke (klase nagusia).
- abstract aldarazlea: klasea abstraktua dela adierazten du. Klase abstraktu bat ezin da
instantziatu, hau da, ezin da klase horretako objekturik sortu. Zertarako erabili orduan?
Batzuetan, klaseen hierarkia bat sortzen dugu eta ez zaigu interesatzen hierarkiaren goiko
klaseak instantziatzea, baina bai beheko mailetan daudenak. Kasu horretan, goiko mailetako
klaseak abstract izango lirateke.
- final aldarazlea: klase horrek ez du klase-semerik izango. final eta abstract ezin dira
elkarrekin jarri.
Puntu klasea bere pakete berean dauden klaseek bakarrik ikusiko lukete. Paketetik kanpo egon
litezkeen klaseek ikustea nahi bagenu, public aldarazlea gehitu beharko genioke: public class
Puntu.
4.2.3. KLASEAREN GORPUTZA
Giltzen artean sartzen da, eta bertan dauden atalak atributuak eta metodoak dira. Egon daiteke
atributurik edo metodorik ez daukan klaserik, baina bietako bat eduki behar dute: ezin dira hutsik
egon.
4.2.4. KIDE ESTATIKOAK
Klase bateko objektu bat sortzen den bakoitzean, objektu horrek memorian behar duen tokia
esleitzeko, zenbait ekintza gertatzen dira.
Batzuetan, klase baten atributu eta metodoek ez daukate zentzurik objektu baten parte bezala,
baina bai klasearen parte bezala. Imajinatu Auto klasea sortzen dugula eta atributu bat nahi dugula
klasearen izena gordetzeko: String motako atributua sortuko dugu eta “Auto” balioa esleituko
diogu. Ez dauka zentzu handirik klase horretako objektu guztiek atributu hori edukitzea, guztientzat
izango baitu balio bera. Gerta liteke klase horretako objekturik ez sortzea, baina atributu hori
erabilgarri egongo da beti.
Kide estatikoak sortzeko static aldarazlea erabiltzen da. Aldarazle hori daukaten atributuek zein
metodoek kide estatiko izena daukate. Aurrerago ikasiko dugu bai atributu estatikoak bai metodo
estatikoak sortzen.
4.3. ATRIBUTUAK
Atributuak objektuek gordetzen dituzten datuak dira. Objektuaren baitan bakarrik existitzen dira;
ez daukate zentzurik objekturik gabe. Objektua suntsitzen denean, atributuak ere suntsitu egiten
dira. Batzuetan, atributuei aldagai klasekideak edo objektu-aldagaiak deritze.
Atributuen datu motak edozein aldagairenak bezalakoak izan daitezke: int, boolean, float, array,
String, beste objektu bat...
Datu motaz eta izenaz gain, atributuen deklarazioan adierazleak ere egon daitezke (adibidez public,
private, protected edo static).
Erabili dugun Puntu klasean atributuak modu honetan deklara zitezkeen:
public int x;
public int y;
Modu horretan, adierazten dugu atributu horiek biak publikoak direla; hau da, programan klase
horretako objektu bat erabil dezakeen edozein kode-atalerentzat atributu horiek ere erabilgarri
egongo direla.
Normalena, atributu guztiak pribatuak (private) izatea da. Horrela, atributuak ezin izango dira
zuzenean erabili: metodoen bidez erabili beharko ditugu atributuak. Hori aurrerago ikusiko dugun
enkapsulazio kontzeptuarekin dago lotuta.
4.3.1. ATRIBUTUAK DEKLARATZEA
Klase batean atributuak deklaratzeko sintaxia hau da:
[aldarazleak] <datu mota><atributuarenIzena>;
Adibideak:
int x;
public int x, y;
private int x, y, z;
static double deskontuOrokorra;
final bool ezkondua;
Atributuak beste edozein aldagai deklaratzen den modu berean deklaratzen dira. Erabiltzen ari
garen adibidean, Puntu klasearen objektu bat sortzen den bakoitzean, int motako x eta y atributuak
ere sortuko dira, eta objektu horren baitan egongo dira.
Ondoren, klase bereko beste objektu bat sortzen badugu, beste x eta y atributu pare bat sortuko
da objektu berriaren baitan. Atributu berri baten deklarazioan hiru atal bereiz daitezke:
- Aldarazleak: Hitz erreserbatuak dira eta atributua nola erabiliko den adierazten dute.
Aurrerago ikusiko ditugu banan-banan.
- Datu mota: Atributuaren datu mota adierazteko. Datu mota sinplea izan daiteke (int, char,
boolean, double...), edo erreferentzia motakoa (objektua, array...).
- Atributuaren izena: letra xeheak erabiltzen dira. Hitz bat baino gehiagokoa bada, bigarren
hitzetik aurrera hitzaren lehenengo letra larriz jarriko da.
4.3.1.1. ATRIBUTUEN ALDARAZLEAK
3 aldarazle mota daude:
- Atzipen-aldarazleak: Beste klaseek atributua erabili dezaketen ala ez adierazten dute.

Baztertzaileak dira, eta, horregatik, bakarra jar daiteke atributu bakoitzeko.
- Eduki-aldarazleak: Hainbat ager daitezke. Ez dira baztertzaileak.
- Beste aldarazle batzuk (transient eta volatile): aurrenekoak atributua iragankorra dela
adierazten du, eta bigarrenak atributu horren gainean konpilatzaileak optimizaziorik ez
duela egin behar. Ez dugu hauetan batere sakonduko, kurtso honetan ez baitira erabiliko.
Hau da atributuen deklarazioaren sintaxia:
[private | protected | public] [static] [final] [transient] [volatile] <datu mota><atributuarenIzena>;
Jarraian, banan-banan aztertuko ditugu aldarazle horiek guztiak:
a) ATZIPEN-ALDARAZLEAK
- Ez aipatutakoa: Atributua deklaratzen denean, ez bada aldarazlerik jartzen, atzipen mota

hau erabiliko da. Aldarazle hau erabiltzen duen atributua pakete berean dauden klaseek
erabili ahal izango dute.
- public: Edozein klasek erabil dezake atributua. Ez da normala public aldarazlea duen
atributurik egotea.
- private: Klasetik bertatik bakarrik erabil daiteke atributua. Atributua ezkutatuta egongo da
kodearen beste edozein atalentzat.
- protected: Klasetik bertatik eta haren azpiklaseetatik erabil daiteke atributua, baita
pakete bereko klaseetatik ere.
Hona hemen aldarazleek baimentzen dituzten sarbide moten taula bat:
Klase bera Azpiklasea Pakete bera Beste paketeak

Ez aipatutakoa x x
public x x x x
private x
protected x x x
ARIKETA EBATZIA
Plano batean laukizuzen bat irudikatuko duen klase bat idatzi nahi dugu. Hori egiteko, atributu
hauek erabiltzea pentsatu dugu:
- x1 eta y1 atributuak: double motakoak. Laukizuzenaren ezkerreko beheko erpinaren

koordenatuak adierazteko.
- x2 eta y2 atributuak: double motakoak. Laukizuzenaren eskuineko goiko erpinaren

koordenatuak adierazteko.
Bi puntu horiekin, (x1,y1) eta (x2,y2), arazorik gabe adieraz dezakegu laukizuzen baten posizioa
plano batean.
Idatz ezazu atributu horiek edukiko dituen klase bat, jakinda klasea eta haren atributuak
programaren edozein kode-atalerentzat ikusgai eta erabilgarri izatea nahi dugula.
Erantzuna:
Klaseak edozein kode-atalerentzat ikusgai egon behar duenez, public aldarazlea erabiliko dugu; eta
atributuekin ere, erabilgarri egon behar dutenez edozein tokitatik, public aldarazlea erabiliko dugu
horiekin ere:
public class Laukizuzena {

public double x1, y1; // Ezkerreko beheko erpina
public double x2, y2; // Eskuineko goiko erpina
}
B) EDUKI ALDARAZLEAK
- static aldarazlea: Klase bereko objektu guztientzat atributua berbera izatea ahalbidetzen du.
Atributu horrek balio berdina gordeko du objektu guztientzat.
- final aldarazlea: Atributua konstante bat dela adierazten du. Beraren balioa aldagaitza da.
Atributu hauen izena letra larriz idazten da.
Ikus dezagun final aldarazlea erabiltzen duen adibide bat:
Adierazpen geometrikoekin lan egiteko erabiliko dituzun klaseak sortzen ari gara, eta, halakoetan,
sarritan erabiliko dugu pi konstantea. Gainera, 8 hamartarrekin egin behar dugu lan. Programan pi
erabili behar dugun bakoitzean 3.14159265 idaztea nahiko nekeza da, eta, gainera, etorkizunean 8
hamartar erabili beharrean 5 erabili beharko bagenitu, programan idatzitako leku guztietan aldatu
beharko genuke balio hori.
Askoz errazagoa da final motako atributu bat deklaratzea eta atributu horri 3.14159265 balioa
esleitzea. Izenik aproposena PI izango litzateke.
Horrela geratuko litzateke:
class claseGeometria {
// Konstanteak deklaratzea
public final float PI = 3.14159265;
4.3.1.2. ATRIBUTU ESTATIKOAK
static aldarazleak hau egiten du: Klase bateko objektu guztientzat atributu bakarra existitzea. Kasu
honetan, atributuak badauka zentzua objektutik at. Atributuak balio bera izango du objektu
guztientzat. Nahiz eta klase horretako objekturik sortu ez, atributu estatikoak existitu egingo dira.
Adibide erabilienetako bat objektuen kontagailuarena da. Kontagailu horrek klase bateko zenbat
objektu sortu diren zenbatzen du.
Beste adibide bat klasearen izena gordetzen duen atributu bat izan liteke:
class Puntu {
// Puntuaren koordenatuak
private int x,y;
// Atributu estatikoak
public static zenbatPuntu;
public static final IZENA;
ARIKETA EBATZIA
Hartu ezazu aurretik egin dugun Laukizuzena klasea, eta gehitu atributu hauek:
- zenbatLaukizuzen: Zenbat laukizuzen sortu diren gordeko du.

- izena: Laukizuzen bakoitzaren izena gordeko du.
- irudiIzena: Klasearen izena gordeko du.
- PI: PI konstantearen balioa gordeko du, 4 zifra hamartarrekin.
zenbatLaukizuzen eta izena ez dira erabilgarriak izan behar klasetik kanpo. Klasea bere paketetik
bakarrik izan behar da ikusgai.
Erantzuna:
zenbatLaukizuzen, irudiIzena eta PI atributuak estatikoak izango dira, eta, gainera, irudiIzena eta PI
finalak ere bai, konstanteak baitira.
zenbatLaukizuzen eta izena atributuak private motakoak izango dira.
Klasea bere paketetik bakarrik ikusgai izatea eskatzen da. Aldarazlerik jartzen ez badugu, baldintza
hori bete egingo da.
Klasea honela geratuko da:
class Laukizuzen { // aldarazlerik gabe

private static int zenbatLaukizuzen; // Zenbat laukizuzen sortu den
public static final String irudiIzena = “Laukizuzena”; // klasearen izena
public static final double PI = 3.1416; // PI konstantea
// Objektuaren atributuak
private String izena; // Laukizuzen bakoitzaren izena
public double x1, y1; // Ezkerreko beheko erpina
public double x2, y2; // Eskuineko goiko erpina
}
4.4. METODOAK
Objektu baten portaera definitzen dute metodoek. Atributuekin batera, objektuaren barne egitura
osatzen dute.
Metodoak klasearen gorputzean egongo dira, atributuekin batera. Normalean, metodoak
atributuen ostetik deklaratzen dira. Txandakatu ere egin litezke; baina, horrela eginda programa,
askoz ulergaitzagoa izango litzateke. Metodoak objektuek beren artean komunikatzeko dauzkaten
tresnak dira. Tresna hauek erabiltzen dituzte datuak eskatzeko, eragiketa bat egin dezaten
eskatzeko...
4.4.1. METODOAK DEKLARATZEA
Metodo baten definizioak bi atal dauzka:
- Metodoaren burua: Metodoaren izenak, itzultzen duen emaitzaren datu motak, aldarazle
sorta batek eta parametro multzoak osatzen dute.
- Metodoaren gorputza: Metodoaren portaera inplementatzen duten sententziek osatzen
dute.
Metodoaren deklarazioan, gutxienez, elementu hauek egon behar dira:
- metodoak itzultzen duen datu mota.

- metodoaren izena.
- parentesiak.
- metodoaren gorputza (giltzen artean).
Aurretik lantzen egon garen Puntu klasean, metodo hau ager liteke:
int getX()
{
//metodoaren gorputza
...
}
Azalpena
- metodoak itzultzen duen datu mota int da.
- metodoaren izena getX da.
- ez du parametrorik jasotzen: parentesien artean ez dago ezer.
- metodoaren gorputza giltzen artean sartutako guztia da.
Metodoaren gorputzaren barruan era guztietako sententziak ager daitezke: aldagaiak deklaratzen
dituztenak, esleipenak, era guztietako kontrol egiturak...
Hala ere, metodoaren deklarazioak beste hainbat elementu ere izan ditzake.
4.4.2. METODOAREN BURUA
Metodo baten deklarazioak elementu guzti hauek izan ditzake:
1. Aldarazleak: Aurrerago ikusiko dugu zeintzuk diren. Ez dago zertan aldarazlerik jarri
deklarazioan.
2. Itzulitako datu mota: Metodoa exekutatzen denean itzultzen duen balioaren datu mota.
void jarriko dugu metodoak ezer itzultzen ez duenean.
3. Metodoaren izena.
4. Parametroen zerrenda: Komekin banatuta eta parentesi artean sartuta egongo dira.
Parametro bakoitzaren aurretik horren datu mota idatziko da. Metodoak parametrorik
jasotzen ez badu, zerrenda hutsik egongo da eta parentesiak besterik ez dira agertuko.
5. Salbuespenen zerrenda: Metodoak jaurti ditzakeen salbuespenen zerrenda. throws
hitzaren atzean salbuespenen izenak jarriko dira, komekin banatuta. Ez da beharrezkoa
salbuespenen zerrenda egotea, baina askotan komeni izango da.
Metodo baten buruaren sintaxi orokorra hau izango litzateke:
[private | protected | public] [static] [abstract] [final] [native] [synchronized]

<itzulitako datu mota><metodoarenIzena> ([<parametroen_zerrenda>])
[throws<salbuespenen_zerrenda>]
Metodoak izendatzeko hau adostu da: lehen hitza minuskulaz idatzitako aditz bat izatea, eta haren
osteko hitzen lehen letra larriz idaztea.
Puntu klasearen getX() eta getY() metodoek izendatzeko era hori betetzen dute, int motako datu
bat itzultzen dute, ez dute parametrorik jasotzen eta ez dute salbuespenik jaurtitzen.
4.4.3. METODOEN ALDARAZLEAK
Aurretik esan dugunez, metodoen deklarazioan posible da aldarazleak jartzea nahiz eta
derrigorrezkoa ez izan. Metodo batek aldarazle hauek izan ditzake:
- Atzipen-aldarazleak: Atributuetan erabilitako berak dira (ez aipatutakoa, public, private eta
protected), eta esanahia ere bera da.
- Eduki-aldarazleak: Atributuetan erabilitako berak dira (static eta final), baina esanahia ez da
berdina.
- Beste aldarazle batzuk (bakarrik metodoetarako): (abstract, synchronized eta native).
- static motako aldarazleak zera esan nahi du: static aldarazlea duen metodoa berdina da
klaseko objektu guztientzat, eta bakarrik erabil ditzake klasearen atributu estatikoak. Hori
dela eta, metodo horiei dei egiteko ez da beharrezkoa klasearen objektu berri bat sortzea.
Javan, static motako metodoen ohiko adibide bat Math klasean daukagu. Estatikoak dira klase
horrek dauzkan metodo guztiak: Math.abs, Math.sin, Math.cos... Ikusten denez, metodoak
erabiltzeko klasearen izena jartzen da puntuaren aurrean eta ez objektuaren izena (ez baitago
objekturik sortu beharrik). Dena den, objektuek ere onartzen dute metodo estatikoei dei egitea.
final motako metodo bat ezin da berridatzi klase baten azpiklaseetan.
native aldarazleak zera esan nahi du: metodoa makina-hizkuntzara konpilatu den hizkuntza batean
egina dagoela. Halakoetan, metodoaren burua besterik ez da ipintzen, metodoaren gorputza ez
baitago Javan idatzita.
abstract motako metodoek hutsik daukate gorputza. Klasearen azpiklaseek idatzi behar dute
gorputza. abstract motako metodoak abstract motako klaseetan soilik egon daitezke.
Prozesu bat synchronized motako metodo bat exekutatzen ari denean, metodo horri deia egin nahi
dion beste edozein prozesuk itxaron egin beharko du jatorrizko prozesua amaitu arte. Oso
erabilgarria da metodo bat aldi berean deitzen denean hainbat lekutatik.
Azken atal hauetan aldarazle ugari ikusi ditugunez, hona hemen laburpen taula bat, kontzeptuak
pixka bat argiago ikusteko.
Klasea Atributua Metodoa
ez aipatutakoa X X X
Public X X X
private X X
protected X X X
static X X
final X X X
synchronized X
native X
abstract X X
4.4.4. METODOEN PARAMETROAK
Parametroen zerrenda metodoaren izenaren atzean jartzen da. Sintaxia hau da:
<datu mota> metodoarenIzena ( <datu mota-1><parametroarenIzena-1>, <datu

mota2><parametroarenIzena-2>, …, <datu mota-n><parametroarenIzena_n> )
Parametroen zerrenda hutsik badago, parentesiak besterik ez dira agertuko.
<datu mota> metodoarenIzena ()
Hauek dira kontuan hartu beharrekoak:
- Nahi beste parametro jaso ditzake metodo batek. Programatzailearen erabakia izango da.
- Parametroen datu mota edozein izan daiteke: sinplea, erreferentziazkoa...
- Metodoaren aldagai lokalek eta parametroek ezin dute izen bera eduki.
- Ezin dira egon izen bera daukaten bi parametro.
- Parametro batek klasearen atributu baten izen bera badauka, metodoaren barruan izena
erabiltzean parametroa erabiltzen ariko gara. Atributua erabili ahal izateko, aurrerago
ikusiko dugun this eragilea erabili beharko dugu.
- Parametroak balio bidez pasatzen dira, erreferentzia motako datuetan izan ezik.
4.4.5. METODOEN GORPUTZA
Metodo baten gorputza hainbat sententziak osatuko dute:
- Metodoaren aldagai lokalak deklaratzen dituzten sententziek.

- Metodoaren logika osatzen duten sententziek: begiztek, baldintzek, eragiketa
matematikoek, objektu berriak sortzeak...
- Itzulera-balioa bueltatzen duen sententziak: Metodoaren amaieran agertuko da eta
metodoari dei egin dion kode-zatiarekin komunikatzeko era da. Metodoak void itzultzen
badu, sententzia hau ez da agertuko.
Puntu klasean getX eta getY metodoak izan ditugu. Azter dezagun horietako bat:
int getX()
{
return x;
}
Metodoak egiten duen gauza bakarra da return sententziaren bidez x atributuaren balioa itzuli. Ez
du parametrorik jasotzen, ez du kalkulurik egiten... Metodo sinpleenetako bat da. Metodo mota
honek getter izena hartzen du.
Puntu klaseak beste bi metodo ere baditu: setX eta setY. Metodo horiek getter metodoen
kontrakoa egiten dute; hau da, balioa ematen diote atributu bati eta setter izena hartzen dute.
Azter dezagun horietako bat:
void setX (int kx)
{
x = kx;
}
Metodoak kx parametroa jasoko du eta parametro horren balioa x atributuari esleituko dio. Ez da
baliorik itzultzen (itzulitako datu mota void da, eta ez dago return sententziarik).
Normalean metodo gehienak aurreko horiek baino konplexuagoak izango dira. Ikus dezagun
adibide bat.
ARIKETA EBATZIA
Laukizuzen klasearekin lanean jarraituko dugu. Ondoko metodo publiko hauek gehituko dizkiogu:
- getIzena eta setIzena: Objektuaren izena atributua eskuratu eta aldatzeko.

- kalkulatuAzalera: Laukizuzenaren azalera kalkulatzeko.
- kalkulatuPerimetroa: Laukizuzenaren perimetroa kalkulatzeko.
- higitu: Laukizuzenaren posizioa aldatuko du. Bi parametro jasoko ditu. Lehenengoa, x
ardatzeko desplazamendua adierazteko, eta bigarrena, y ardatzeko desplazamendua
adierazteko.
- getZenbatLaukizuzen: Zenbat laukizuzen sortu den eskuratzeko.
Erantzuna:
getIzena metodoak izena atributua itzuli besterik ez du egin behar:
public String getIzena () {

return izena;
}
setIzena metodoa, ere, oso erraza da. Parametro bidez jasotako balioa esleitu behar zaio izena
atributuari:
public void setIzena (String ize) {

izena = ize;
}
Azalera eta perimetroa kalkulatzeko metodoek ez dute parametorik jasoko. Egin beharreko
kalkuluak egiteko nahikoa da objektuek atributuetan gordeta daukaten informazioa.
Azalera eta perimetroa kalkulatzeko, laukizuzenaren oinaren eta altueraren luzerak lortu beharko
ditugu gordetako bi erpinez baliatuta: ezkerreko beheko erpina (x1,y1) eta eskuineko goiko erpina
(x2,y2).
Laukizuzenaren oinaren luzera x2-x1 izango da, eta laukizuzenaren altuera (y2-y1).
Azalera kalkulatzeko, oina x altuera egin beharko dugu.
Perimetroa kalkulatzeko, 2 x oina + 2 x altuera egin beharko dugu.
Bi metodo horietan emaitza kalkulatuta daukagunean, itzuli egin beharko dugu return
sententziaren bidez.
public double kalkulatuAzalera () {
double azalera, oina, altuera; // Aldagai lokalak
// Oina kalkulatu
oina = x2-x1;
// Altuera kalkulatu
altuera = y2-y1;
// Azalera kalkulatu
azalera = oina * altuera;
// Itzulera-balioa
return azalera;
}
public double kalkulatuPerimetroa () {
double perimetroa, oina, altuera; // Aldagai lokalak
// Oina kalkulatu
oina = x2-x1;
// Altuera kalkulatu
altuera = y2-y1;
// Perimetroa kalkulatu
azalera = 2*oina + 2*altuera;
// Itzulera-balioa
return perimetroa;
}
higitu metodoaren kasuan hau egin behar da:
x1 eta x2 atributuei X parametroa gehitu.

y1 eta y2 atributuei Y parametroa gehitu.
public void higitu (double X, double Y) {

// Desplazamendua X ardatzean
x1 = x1 + X;
x2 = x2 + X;
// Desplazamendua Y ardatzean
y1 = y1 + Y;
y2 = y2 + Y;
}
Ikus daitekeenez ez du baliorik itzultzen.
getZenbatLaukizuzen metodoak zenbatLaukizuzen izeneko atributua itzuliko du. Atributu hori

estatikoa da; beraz, metodoa ere klase-metodo bat izatea komeni da, eta ez objektu-metodo bat.
Horretarako static aldarazlea erabiliko dugu.
public static int getZenbatLaukizuzen () {

return zenbatLaukizuzen;
}
4.4.6. METODOAK GAINKARGATZEA
Klase batean, metodo bat behin bakarrik agertzen da normalean, baina posible da izen bera
daukaten bi metodo ezberdin egotea klase batean. Hori egiteari metodoak gainkargatzea esaten
zaio.
Metodo bat gainkargatzea metodo horren hainbat bertsio sortzea da.
Nola ezberdinduko dira metodo horiek izen bera badaukate? Oso erraz: metodo bakoitzak bere
parametro-zerrenda izango du.
Pentsa dezagun paper batean idatziko duen programa bat idatzi nahi dugula. Programa horrek
hainbat tipografia erabiliko ditu, betiere idatzi behar duen datu motaren arabera. Programak
hainbat metodo erabiliko du: zenbaki osoak idazteko, zenbaki errealak idazteko, testua idazteko...
Aukera bat metodoei izen ezberdinak esleitzea izan liteke:
idatziOsoa (int osoa).

IdatziErreala (double erreala).
idatziTestua (String testua).
idatziOsoaTestua (int osoa, String testua).
Aurreko metodo horiek guztiek idatzi besterik ez dute egiten; beraz, ez litzateke arraroa izango izen
bera izatea. Izen bera erabiltzeko gainkarga erabiliko dugu. Metodoak ez dira guztiz berdinak
izango, parametroak ezberdinak izango direlako:
idatzi (int osoa).

Idatzi (double erreala).
idatzi (String testua).
idatzi (int osoa, String testua).
4.4.7. THIS ERREFERENTZIA
Erabiltzen ari garen objektuari erreferentzia egiteko erabiltzen da. Askotan, anbiguotasuna
gertatzen da atributu batek eta parametro batek izen berdina daukatenean. Kasu horietan,
parametroak atributua ezkutatzen du, hau da, ezin dugu atributua zuzenean erabili. Horrelako
kasuetan, this erreferentzia erabiltzen da atributuak erabili ahal izateko.
this hitz erreserbatuak erabiltzen ari garen klaseari egiten dio erreferentzia, eta atributu bat
erabiltzeko hau idatziko dugu:
this.atributuaren_izena
Era horretan, konpilatzaileak atributuari buruz ari garela jakingo du eta anbiguotasunik ez da
egongo atributuen eta parametroen artean.
Puntu klasean, adibidez, setX metodoa honelakoa izan liteke:
void setX (int x)

{
this.x = x;
}
Aurreko adibidean, ezinbestekoa da this erabiltzea. Nola jakingo genuke, bestela, noiz erabiltzen ari
garen x atributua eta noiz x parametroa?
Askotan, egokia izaten da this erabiltzea, nahiz eta derrigorrezkoa ez izan, kodea ulertzea errazten
baitu.
ARIKETA EBATZIA
Alda ezazu Laukizuzen klasearen getIzena metodoa this erreferentzia erabil dezan.
Erantzuna:
this erreferentzia erabiltzen badugu, parametroak eta atributuak identifikadore bera izan dezakete
(izena). Nahi ez badugu, ez da beharrezkoa izen bera edukitzea.
public void setIzena (String izena) {

this.izena = izena;
}
4.4.8. METODO ESTATIKOAK
Metodo estatikoak, klasetik bertatik erabil daitezke objekturik sortu gabe. Klaseko metodo
izenarekin ere ezagunak dira. Metodo hauek atributu estatikoak bakarrik erabil ditzakete; ez
atributu klasekideak. Metodo estatikoak erabiliz egin ohi diren eragiketa batzuk hauek dira:
- Klase jakin bateko zenbat objektu sortu diren zenbatuko duen kontagailu bat kudeatzea.
- Klasearekin harremana duten eragiketa orokorrak. Adibidez, NAN izeneko klase batean
NAN zenbakiaren 8 zifrak jaso eta dagokion letra kalkulatuko duen metodo bat idaztea. Oso
interesgarria izan liteke metodo hori NAN klasetik kanpo ere erabilgarri egotea, nahiz eta
NAN motako objekturik ez erabili.
Java liburutegian (API), oso normala da metodo estatikoak aurkitzea: kalkuluak egiteko, datu-
moten arteko konbertsioak egiteko... java.lang paketearen klase gehienak estatikoak dira.
Hona hemen hainbat adibide:
- static String valueOf (int i): int motako datu bat String bezala itzultzen du. Ez da
beharrezkoa String klaseko objektuak sortzea, metodoa erabili ahal izateko. Metodoaren
aurretik klasearen izena eta puntu bat jarriko genuke, besterik gabe:
String osoaKatea = String.valueOf (23);
- static String valueOf (int i): Aurrekoaren oso antzekoa. float motako datu bat String bezala
itzultzen du.
String errealaKatea = String.valueOf (23.023);
- static int parseInt (String s): Parametro bidez jasotako katea (String) int motako datu
bihurtzen du:
int kateaOsoa = Integer.parseInt(“43”);
Normalean metodo hauek publikoak izaten dira kodearen edozein ataletik erabili ahal izateko.
4.5. ENKAPSULAZIOA, ATZIPEN KONTROLA ETA
IKUSGAITASUNA
Enkapsulazioarekin posible da klase baten hainbat atal ezkutatzea. Dagoeneko ikasi dugu nola
ezkutatu klasearen hainbat atal edo nola mugatu haien erabilera, modu desegokian ez erabiltzeko.
Atzipen-aldarazleak erabilita, klase bateko kideen ikusgaitasun-eremua zehazten dugu.
4.5.1. ATRIBUTUAK EZKUTATZEA
Klase baten atributuak pribatu moduan deklaratzen dira normalean, edo, gehienez, protected
moduan (azpiklaseentzat erabilgarri). Horrela, ezabatu egiten da objektuaren kanpotik erabiltzeko
aukera.
Normalean hau egiten da: atributu pribatuak deklaratu, eta atributu horiek atzitzea baimenduko
diguten metodo publikoak sortu. Adibidez getter eta setter metodoak.
Puntu klasean horrelako zer edo zer egin genuen:
class Puntu {
// Atributuak
int x,y;
// Metodoak
int getX () { return x; }
int getY() {return y;}
void setX (int vx) { x = vx; };
void setY (int vy) { y = vy; };
}
Orain dakigunarekin, atributuak private moduan jarriko genituzke eta metodoak public moduan:
class Puntu {
// Atributuak
private int x;
private int y;
// Metodoak
public int getX () { return x; }
public int getY() {return y;}
public void setX (int x) { this.x = x; };
public setY (int y) { this.y = y; };
}
Hala eginda, objektu baten x atributua jasotzeko getX metodoa erabili beharko dugu; ezingo da
zuzenean atributua erabili.
Zergatik egiten da hori? Imajina ezazu, klase batean, atributu bat daukagula, NAN zenbakia eta
letra gordetzen dituena. Atributua zuzenean erabili ahal bada, posible izango da objektuei NAN
zenbaki desegokiak esleitzea. setNAN metodo publikoa erabiltzera behartzen badugu, ordea,
metodo horren barruan NAN zenbakia eta letrak balioztatuko direnez, datu egokiak bakarrik
esleituko zaizkio atributuari.
4.5.2. METODOAK EZKUTATZEA
Normalean klase bateko metodoak public motakoak izango dira, programa guztian erabilgarriak
izan daitezen; baina kasu gutxi batzuetan, metodo nagusiek bakarrik erabiliko dituzten beste
metodo batzuk egon daitezke klaseetan; adibidez, bitarteko kalkuluak egiteko. Metodo horiek
pribatuak izango dira, ez baitzaigu interesatzen klasetik kanpora inon erabiltzerik.
ARIKETA EBATZIA
NAN klasea idatziko dugu eta ezaugarri hauek izango ditu:
- NAN zenbakia int motakoa izango da. Ez dugu letra gordeko, kalkulatu egingo dugu.
Atributua pribatua izango da.
- getNAN eta getIFZ metodoak idatziko ditugu. getNAN metodoak zenbakia bakarrik itzuliko
du eta getIFZ metodoak zenbakia eta letra.
- setKarneta metodoa gainkargatuta egongo da. Metodo batek zenbakiak bakarrik jasoko
ditu, eta besteak, zenbakiak eta letra. Jasotako datuak egokiak ez badira, salbuespen bat
jaurtiko du.
- Klaseak barne-metodo batzuk edukiko ditu bitarteko kalkuluak egiteko. Metodo horien
formatua hau izango da:
private static char kalkulatuLetraIFZ (int nan).

private boolean balioztatuIFZ (String ifz).
private static char lortuLetraIFZ (String ifz).
private static int lortuZenbakiakIFZ (String ifz).
Erantzuna:
/**----------------------------------------------------------------
* NAN Klasea
----------------------------------------------------------------*/
public class NAN {
// Letra kalkulatzeko erabiliko dugun katea

private static final String NAN_LETRAK = "TRWAGMYFPDXBNJZSQVHLCKE";
// Objektuaren atributuak
private int zenbakiaNAN;
// Metodoak
public String getIFZ () {

// Aldagai lokalak
String kateaIFZ; // itzuliko den IFZ
char letraIFZ; // kalkulatu den IFZ-ren letra
// IFZ-ren letra kalkulatu

letraIFZ = kalkulatuLetraIFZ (zenbakiaNAN);
// zenbakia + letra (IFZ) dituen katea eraiki

kateaIFZ = Integer.toString(zenbakiaNAN) + String.valueOf(letraIFZ);
// Emaitza itzuli
return kateaIFZ;
}
public int getNAN () {
return zenbakiaNAN;
}
public void setKarneta (String ifz) throws Exception {

if (NAN.balioztatuIFZ (ifz)) { // Baliozkoa: gorde
this.zenbakiaNAN = NAN.lortuZenbakiakIFZ(ifz);
}
else { // Ez da baliozkoa: salbuespena jaurti
throw new Exception ("IFZ ez baliozkoa: " + ifz);
}
}
public void setKarneta (int nan) throws Exception {

//Heinak konprobatu
if (nan>999999 && nan<99999999) {
this.zenbakiaNAN = nan; // Baliozkoa: gorde
}
else { // Ez da baliozkoa: salbuespena jaurti
throw new Exception ("NAN ez baliozkoa: " + String.valueOf(nan));
}
}
private static char kalkulatuLetraIFZ (int nan) {

char letra;
// IFZ-ren letra kalkulatu
letra = NAN_LETRAK.charAt(nan % 23);
// IFZ-reb letra itzuli
return letra;
}
private static char lortuLetraIFZ (String ifz) {

char letra = ifz.charAt(ifz.length()-1);
return letra;
}
private static int lortuZenbakiakIFZ (String ifz) {

int zenbakia = Integer.parseInt(ifz.substring(0, ifz.length()-1));
return zenbakia;
}
private static boolean balioztatuIFZ (String ifz) {

boolean baliozkoa = true;
char kalkulatutako_letra;
char irakurritako_letra;
int irakurritako_nan;
if (ifz = = null) { // parametroa hutsik dago
baliozkoa = false;
}
else if (ifz.length()<8 || ifz.length()>9) {
baliozkoa = false;
}
else {
irakurritako_letra = NAN.lortuLetraIFZ (ifz);
irakurritako_nan = NAN.lortuZenbakiakIFZ(ifz);
kalkulatutako_letra = NAN.kalkulatuLetraIFZ(irakurritako_nan);
if (irakurritako_letra = = kalkulatutako_letra) {
// IFZ baliozkoa da.
baliozkoa = true;
}
else {
baliozkoa = false;
}
}
return baliozkoa;
}
}
4.6. METODOAK ETA ATRIBUTUAK ERABILTZEA
Klase bat osatzen dugunean, dagozkion metodo eta atributu guztiekin, hurrengo urratsa klase hori
erabiltzea da, hau da, objektuak sortzea eta objektu horiek erabiltzea. Bigarren gaian ikasi dugu
klase bateko objektuak deklaratzen, objektua instantziatzen new eragilearekin eta objektu horren
metodo eta atributuak erabiltzen.
4.6.1. OBJEKTUAK DEKLARATZEA
Objektu bat deklaratzea beste edozein aldagai deklaratzea bezalakoa da:
<datu mota> aldagaiarenIzena;
Adibidez:
Puntu p1;
Laukizuzen l1, l2;
Auto autoBerria;
Aldagai horiek (p1, l1, l2 eta autoBerria) erreferentziak dira, memoria-helbideak. Erreferentzia
horiek objektura apuntatzen dute. Objektua deklaratzen denean, oraindik ez du inora apuntatzen;
eta halakoetan, erreferentzia hutsik dagoela edo nulua dela (aldagaiak null balio duela) esaten da.
Aldagaia existitzen da eta objektua gordeko duen memoria-helbidea gordetzeko prest dago, baina
objektua ez da oraindik existitzen.
Objektua sortzeko new eragilea erabiltzen da.
ARIKETA EBATZIA
Deklara itzazu aurretik sortu dugun Laukizuzen klaseko 3 objektu. Objektu horien izenak l1, l2 eta
l3 izango dira.
Erantzuna:
Edozein aldagai deklaratzen den bezala deklaratuko ditugu objektuak:
Laukizuzen l1;
Laukizuzen l2;
Laukizuzen l3;
Sententzia berean ere deklara litezke hiru objektuak:
Laukizuzen l1, l2, l3;

4.6.2. OBJEKTUAK SORTZEA
Objektuak sortzeko new eragilea erabiltzen da. Sintaxia honako hau da:
objektuarenIzena = new <KlasekoSortzailea> ([Parametroen_zerrenda]);
Metodo sortzailea klase guztiek daukaten metodo berezi bat da. Klasearen izen bera dauka eta
berak sortzen ditu objektuak, beharrezkoa den memoria erreserbatzen du, eta, behar izanez gero,
objektuaren atributuak hasieratzen ditu.
Klase berri bat sortzen dugunean, ez da beharrezkoa metodo sortzailerik idaztea. Javak sortzaile
bat sortzen du programatzaileak egiten ez badu (sortzaile lehenetsia). Sortzaile horrek memoria
erreserbatu besterik ez du egingo. Sortzaileak gauza gehiago egin ditzan, programatzaileak berak
idatzi beharko du. Sortzaile lehenetsiak ez du parametrorik erabiltzen.
Hauek dira objektuak sortzeko eraren adibide batzuk:
p1 = new Puntu ();

l1 = new Laukizuzen ();
l2 = new Laukizuzen;
autoBerria = new Auto();
Sortzaileak parametrorik ez badu, ez dago parentesiak idatzi beharrik.

Objektu bat lerro berean deklaratu eta sortu daiteke:
Puntu p1 = new Puntu ();
ARIKETA EBATZIA
Aurreko ataleko ariketa osatu. Horretarako, sortzaile lehenetsia erabilita sortuko ditugu l1, l2 eta l3
objektuak.
Erantzuna
Laukizuzen l1, l2, l3;

4.6.3. OBJEKTUAK ERABILTZEA
Objektua deklaratu eta sortu dugunean, objektua existitu egiten da, eta orduan erabili daiteke
programan haren metodo eta atributuekin lan egiteko.
Objektu baten kide bat erabiltzeko puntu eragilea (.) erabiltzen da:
<objektuarenIzena>.<kidearenIzena>
Puntu klasearen objektu bat sortzen eta erabiltzen duen kode-zati bat hau da:
Puntu p1, p2, p3;

p1 = new Puntu();
p1.x = 5;
p1.y = 6;
System.out.printf ("p1.x: %d\np1.y: %d\n", p1.x, p1.y);
System.out.printf ("p1.x: %d\np1.y: %d\n", p1.getX(), p1.getY());
p1.setX(25);
p1.setY(30);
System.out.printf ("p1.x: %d\np1.y: %d\n", p1.getX(), p1.getY());
ARIKETA EBATZIA
Laukizuzen klasea erabili l1 izeneko laukizuzena sortzeko. Atributuen balioak x1 = 0, y1 = 0, x2 = 10

eta y2 = 10 izango dira. Kalkulatu laukizuzenaren azalera eta perimetroa, eta atera itzazu pantailan.
Erantzuna:
/*
Laukizuzen klasea erabiltzeko adibidea
*/
package laukizuzenak01;
/**
*
* Programa Nagusia (klase nagusia)
*/
public class LaukizuzenAdibidea {
Laukizuzen l1, l2;

l1.x1 = 0;
l1.y1 = 0;
l1.x2 = 10;
l1.y2 = 10;
l1.setIzena ("laukizuzen1");
System.out.println ("LAUKIZUZEN KLASEAREN FROGA\n");
System.out.printf ("------------------------------------\n\n");
System.out.printf ("l1.x1: %4.2f\nl1.y1: %4.2f\n", l1.x1, l1.y1);
System.out.printf ("Perimetroa: %4.2f\nAzalera: %4.2f\n",
l1.kalkulatuPerimetroa(),
l1.kalkulatuAzalera());
System.out.printf ("Laukizuzena higituko dugu X = 3, Y = 3\n");
l1.higitu (3,3);
}
}
4.7. SORTZAILEAK
Orain arteko adibideetan, sortzaile lehenetsiak erabili ditugu objektuak sortzeko. Orain, sortzaileak
programatzen ikasiko dugu.
Sortzaileak klasearen izen berdina dauka eta ez dauka itzulera-baliorik. Beraren zeregina objektuak
sortzea besterik ez da.
Zer egiten dugu new eragilea erabiltzean? Sortzaileari deitu, eta, ondorioz, objektu bat
ordenagailuaren memorian sortu.
Sortzaileak, funtsean, metodoak dira. Orduan, posible ote da sortzaileak gainkargatzea? Hau da,
posible ote da klase batek sortzaile bat baino gehiago edukitzea? Erantzuna baietz da.
Klase batek nahitaez izan behar du sortzaile bat. Programatzaileak sortzailerik idazten ez badu,
konpilatzaileak hutsik egongo den sortzaile lehenetsia sortuko du. Sortzaile horrek atributuak
hasieratuko ditu: zenbakizkoak 0 batekin, erreferentziak null balioarekin, boolearrak false
moduan...
Programatzaileak sortzaileren bat idazten badu, konpilatzaileak ez du sortzaile lehenetsirik sortuko.
Hortik aurrera, parametrorik gabeko sortzaile bat erabili nahiko bagenu, geuk idatzi beharko
genuke sortzaile hori.
4.7.1. SORTZAILEAK IDATZI
Klase bat idazten dugunean, klase horretako objektuak era zehatz batean sortu nahi dugu.
Horretarako, sortzaile bat edo gehiago idazten dira. Sortzaile baten definizioan, honako hauek
hartzen dira kontuan:
- atzipen mota.
- klasearen izena. Sortzaileak klasearen izen bera dauka.
- parametroen zerrenda.
- salbuespenak jaurtitzen dituen ala ez.
- sortzailearen gorputza.
Ikus daitekeenez, sortzaileen egitura edozein metodorenaren oso antzekoa da, baina ez dauka
itzulera-baliorik eta beraren izena klasearena izan behar du.
Puntu klasearen sortzaile bat hau izan liteke:
public Puntu (int x, int y)

{
this.x = x;
this.y = y;
zenbatPuntu++;
}
Sortzaile honek bi parametro jasotzen ditu, objektuarentzat espazioa gordetzen da (Javak

automatikoki egiten du), objektuaren x eta y atributuak jasotako parametroen balioekin
hasieratzen dira, eta, azkenik, zenbatPuntu atributu estatikoa eguneratzen du.
4.7.2. SORTZAILEAK ERABILI
Behin sortzaileak eginda dauzkagunean, new eragilea erabiliko dugu haiei dei egiteko. Aurreko
atalean egindako Puntu klaseko sortzaileari, honela deituko genioke:
Puntu p1;
p1 = new Puntu (10, 7);
Aurreko adibidean ez dugu sortzaile lehenetsia erabili, geuk idatzitakoa baizik. Bertan, atributu
batzuk hasieratu ditugu.
ARIKETA EBATZIA
Gehitu Laukizuzen klaseari sortzaile hauek:
- Parametrorik gabeko sortzailea. Laukizuzenaren erpinen hasierako balioak (0,0) eta (1,1)
izango dira.
- Lau parametro jasoko dituen sortzailea. Atributuen hasierako balioak parametroek
emandakoak izango dira.
- Bi parametro jasoko dituen sortzailea: oinarria eta altuera. Ezkerreko beheko erpina (0,0)
puntuan egongo da, eta laukizuzenaren oinarria eta altuera parametroek emandakoak
izango dira.
Erantzuna:
Lehenengo sortzaileak atributuak hasieratuko ditu balio finkoekin:
public Laukizuzena ()
{
x1 = 0.0;
y1 = 0.0;
x2 = 1.0;
y2 = 1.0;
}
Bigarren sortzaileak ere objektuaren atributuak hasieratuko ditu; baina, kasu horretan, balioak
parametro bidez jasota:
public Laukizuzena (double x1, double y1, double x2, double y2)
{
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
}
Hirugarren sortzailean, lehenengo puntua (0,0) izango da, eta bigarrena (oinarria, altuera):
public Laukizuzena (double oinarria, double altuera)
{
this.x1 = 0.0;
this.y1 = 0.0;
this.x2 = oinarria;
this.y2 = altuera;
}
Ondorengo kodean, idatzi ditugun hiru sortzaile horiek erabiltzen dira:
package LaukizuzenAdibidea02;
/**
*
* Programa Nagusia
*/
public class LaukizuzenAdibidea {

Laukizuzen r1, r2, r3;
System.out.printf ("LAUKIZUZEN KLASEA ERABILTZEA\n");

System.out.printf ("------------------------------------\n\n");
System.out.printf ("Laukizuzenak sortzen...\n\n");
l1 = new Laukizuzen (); //Parametrorik gabeko sortzailea
r2 = new Laukizuzen (1,1, 3,3);//Bi erpinen koordenatuak jasotzen ditu
r3 = new Laukizuzen (10, 5);//Laukizuzenaren oinarria eta altuera jasotzen //ditu
System.out.printf ("Laukizuzena l1: \n");

System.out.printf ("Perimetroa: %4.2f\nAzalera: %4.2f\n", l1.kalkulatuPerimetroa(),


}
}
4.7.3. KOPIA-SORTZAILEAK
Imajina ezazu hainbat objektu berdin behar dituzula eta horietako bat ongi konfiguratuta
daukazula. Ondo legoke objektu horren kopiak egingo lituzkeen sortzaile bat izatea.
Bada, posiblea da objektu baten kopiak egingo dituen sortzaile bat edukitzea. Sortzaile horri kopia-
sortzaile esaten zaio.
Sortzaile hauek parametro bezala kopiatu nahi den objektuaren erreferentzia jasotzen dute.
Sortzaileak objektuaren atributu bakoitzak zenbat balio duen aztertzen du, eta sortzen ari den
objektuari esleitzen dio atributu horietako bakoitza.
Puntu klaseko kopia-sortzailea hau izan liteke:
public Puntu (Puntu p)

{
this.x = p.getX();
this.y = p.getY();
}
Aurreko adibide horretan, sortzaileak Puntu motako objektu bat jaso du parametro bezala, eta
jasotako parametroaren atributuak esleitu dizkio objektu berriari.
Aurreko sortzailearen erabilera hau izango litzateke:
Puntu p1, p2;

p1 = new Puntu (10, 7);
p2 = new Puntu (p1);
Aurreko kasuan, p2 puntua p1 puntuaren kopia bat da.

ARIKETA EBATZIA
Idatz ezazu kopia-sortzaile bat Laukizuzen klasean erabiltzeko.
Erantzuna:
Aurretik dauzkagun hiru sortzaileei honako hau gehituko diegu:
// Kopia-sortzailea
public Laukizuzen (Laukizuzen l) {
this.x1 = l.x1;
this.y1 = l.y1;
this.x2 = l.x2;
this.y2 = l.y2;
}
Kopia-sortzailea erabiltzeko, oinarritzat erabiliko dugun Laukizuzen motako beste objekturen bat
existitu behar da aurretiaz.
Laukizuzen l1, l2;

l1 = new Laukizuzen (0,0,2,2);
l2 = new Laukizuzen (l1);
4.7.4. OBJEKTUAK SUNTSITU
Objektu bat erabiltzen amaitzen dugunean, hari esleitu zaizkion baliabideak (memoria, datu-
baseetarako konexioak...) askatu egin beharko lirateke.
Sortzaileek objektuak sortzen dituzte; objektuak suntsitu, ordea, zabor-biltzaileak (garbage
collector) egiten du. Zabor-biltzaileak erreferentziatuta ez dauden objektuak bilatzen ditu eta
suntsitu egiten ditu.
Badago zabor-biltzaileari dei egiterik geuk nahi dugunean. Hori egiteko finalize metodoa erabiltzen
da. Mementoren batean finalize metodoa exekuta dadila behar badugu, honela egingo diogu dei:
System.runFinalization ();
Normalean ez da metodo suntsitzailerik egiten, baina behar izanez gero, posible da egitea.
4.8. HERENTZIA: SARRERA
Herentzia funtsezko kontzeptua da objektuei zuzendutako programazioan (OZP). Ideia nagusia da

klase berriak sortzea aurretiaz existitzen diren klaseetatik abiatuta, existitzen diren klase horien
ezaugarriak (atributuak eta metodoak) berrerabiliz.
Beste klase batetik heredatzen duen klase bati azpiklase esaten zaio, eta azpiklase baten aitari
superklase. Herentzia dagoenean, azpiklaseak superklasearen atributuak eta metodoak heredatzen
ditu, nahiz eta horietako batzuk moldatu eta berridatzi egin daitezkeen azpiklasean. Horri
espezializazio esaten zaio.
Azpiklaseek goiko klase guztien ezaugarriak bereganatzen dituzte, ez bakarrik bere aitarenak.
Imajina ezazu ibilgailuekin lan egingo duen programa bat idatzi nahi duzula. Hasteko, Ibilgailu
klasea idatziko duzu. Klase horren atributuak hauek izan litezke: uneko posizioa, uneko abiadura
eta ibilgailuak har dezakeen gehienezko abiadura. Metodoak ondorengoak izan litezke: gelditu,
bizkortu, balaztatu, norabideaEzarri, norantzaEzarri.
Hainbat ibilgailu mota behar ditugu programan, eta pentsatutako ezaugarriekin ez dugu nahikoa
izango. Hortaz, beste klase batzuk ere idatzi beharko ditugu. Idatziko ditugun klase horiek Ibilgailu
klasearen ezaugarriak izango dituzte; beraz, ibilgailu bakoitzaren berezko ezaugarriak bakarrik
idatzi beharko ditugu gainerakoak Ibilgailu klasetik heredatuko baitituzte.
Hiru ibilgailu mota egongo dira gure programan: uretakoak, lurrekoak eta airekoak.
LurrekoIbilgailu izeneko klasea idatziko bagenu, Ibilgailu klasetik heredatuko lituzke ezaugarriak;
baina, gero, beste atributu batzuk ere gehituko genizkioke: zenbat gurpil dituen, ibilgailuaren
altuera... Azken klase honetatik abiatuta ere klase berriak sor litezke. Adibidez, Auto klasea
LurrekoIbilgailu klasearen semea izango litzateke.
4.8.1. HERENTZIA ERABILTZEN DUTEN KLASEAK SORTU ETA ERABILI
Nola esaten da Javan klase batek beste batetik heredatzen duela? extends hitz erreserbatua
erabilita. Sintaxia hau da:
class<KlasearenIzena> extends <SuperKlasearenIzena> {

...
}
LurrekoIbilgailu klasearen kasua honelakoa izango litzateke:
class LurrekoIbilgailu extends Ibilgailu {

...
}
eta Auto klasearen kasua:
class Auto extends LurrekoIbilgailu {

...
}
ARIKETA ERRAZAK
1. Sor ezazu Arraina izeneko klasea. String motako atributu bat izango du, izena izendatuko
duguna, eta atributu hori azpiklaseek heredatu ahal izango dute. Idatz itzazu getIzena eta setIzena
metodoak, eta erabil ezazu this erreferentzia metodo horietan. Idatz ezazu programa bat aurrekoa
probatzeko.
2. Aurreko ariketan sortu duzun Arraina klasean, sor ezazu atributu pribatu bat zenbatArrain
izenekoa. Atributu hori berdina izango da Arrain motako objektu guztientzat. Egin ezazu egin
beharreko guztia aldagai horri unitate bat gehi dakion Arrain motako objektu bat sortzen den
bakoitzean.
3. Sor ezazu Arraina klasean kopia-sortzaile bat, eta frogatu, programa batekin, funtzionatzen
duela.
4. Sor ezazu Froga izeneko klase bat. Klase horrek bi metodo izango ditu: lehenengoa eta
bigarrena. Bigarrena metodoak birritan deituko dio lehenengoa metodoari. Lehenengoan ez da
this erreferentzia erabiliko, eta bigarrenean, bai. Baliokideak al dira bi deiak? Froga ezazu.
5. Zer aterako da pantailan ondorengo kodea exekutatzean?
public class Umetxoa {
Umetxoa (int i) {
this ("Umetxo bat naiz");
System.out.println ("Kaixo, " + i + " hilabete daukat");
}
Umetxoa (String s) {
System.out.println (s);
}
void garrasiEgin (){
System.out.println ("Buaaaaa");
}
public static void main (String[] args) {

Umetxoa u1;
u1 = new Umetxoa (8);
u1.garrasiEgin();
}
}
ARIKETA ZAILAK
1. Sor ezazu filmak adierazteko klase bat, Film izenekoa. Klaseak sortzaile bat izango du parametro
bidez atributu guztiak jasoko dituena.
Atributu hauek izango ditu klaseak:
- izena
- zuzendaria
- mota
- luzapena
- laburpena
Metodoak hauek izango dira:
- atributu guztientzat getter eta setter metodoak.

- erakutsiFilma: Pantailan ateratzen du filmaren deskribapen osoa (atributu guztiak).
- thrillerDa: egia (true) itzuliko du filma mota horretakoa bada.
- erakutsiLuzapena: Pantailan filmaren luzapena ateratzen du.
Sor ezazu beste klase bat klase nagusia izango dena. Metodo nagusiak (main) film baten datu
guztiak teklatu bidez sartzeko eskatuko digu; datu horiekin Film motako objektu bat sortuko du;
eta, sortutako objektua erabilita, egindako metodo guztiak probatuko dira.
2. Sortu Ikaslea izeneko klasea:
- Sortzaileak ikaslearen matrikula eta ikaslearen izena jasotzen ditu eta dagozkien atributuei
esleitzen dizkie datu horiek.
- Egin beharreko metodoak hauek dira:

1. setNota: double motako bi parametro jasotzen ditu (bi nota). Metodoak bi atribututan
gordetzen ditu nota horiek.
2. getBatazbestekoa: noten batez bestekoa itzultzen du.
3. erakutsiIkaslea: ikaslearen matrikula, izena eta batez besteko nota ateratzen ditu
pantailan.
- Sor ezazu klase nagusi bat, eta froga ezazu ariketan egindako guztia ondo dabilela.
3. Sor ezazu Elikagai izeneko klase bat. Atributuak hauek izango dira: elikagaiaren izena, lipidoen
ehunekoa, karbohidratoen ehunekoa, proteinen ehunekoa, jatorri animalia duen ala ez, zenbat
bitamina daukan (A-asko, N-normala, G-gutxi), zenbat mineral daukan (A-asko, N-normala, G-
gutxi).
Klaseak bi sortzaile dauzka: batek elikagaiaren izena jasotzen du, eta besteak atributu guztiak
jasotzen ditu.
Klasearen metodoak hauek dira:
- dietarakoDa: egia itzultzen du elikagaiaren lipidoak % 20 baino gutxiago badira eta

bitamina kantitatea txikia ez bada.
- erakutsiElikagaia: Pantailan ateratzen du elikagaiaren deskribapena.
- kalkulatuEnergia: Elikagaiaren gramo baten kalorien zenbatekoa itzultzen du, ondokoa
jakinda: lipido gramo batek 9,4 kcal dauzka, proteina gramo batek 5,3 kcal eta karbohidrato
gramo batek 4,1 kcal.
- kirolarientzatDa: egia itzuliko du proteinak % 10 - % 15 badira, lipidoak % 30 - % 35 eta
karbohidratoak % 55 - % 65.
Sor ezazu aplikazio bat (klase nagusian) erabiltzaileari elikagai baten datuak eskatuko dizkiona.
Jasotako datuekin, Elikagai motako objektu bat sortuko du, eta objektuaren datuak eta energia
pantailan erakutsiko ditu, baita dietakoa eta kirolarientzat den ala ez.
ARIKETA OSOA
Bankuko kontu-korronte bat kudeatuko duen aplikazioa garatu behar da. Aplikazioak hasierako
pantailan honelako menu bat erakutsiko du:
1- Kontu korrontearen zenbaki osoa ikusi

2- Kontuaren jabearen izena ikusi
3- Finantza erakundearen kodea ikusi
4- Bulegoaren kodea ikusi
5- Kontuaren zenbakia ikusi (finantza erakundearen eta bulegoaren koderik gabe)
6- Kontuaren kontrol zenbakiak ikusi
7- Diru sarrera bat egin (erabiltzaileak teklatu bidez adieraziko du zenbat diru sartu nahi
duen)
8- Dirua atera (erabiltzaileak teklatu bidez adieraziko du zenbat diru sartu nahi duen)
9- Saldoaren kontsulta egin
10- Aplikazioa amaitu
Eclipse-n proiektu berri bat sortuko dugu eta bi klase sortuko ditugu proiektu horren barruan:
KontuKorronte.java eta KontuKorronteAplikazioa.java. Horietatik lehenengoak kontu
korronteekin lan egiteko beharrezkoak diren atributu eta metodo guztiak gordeko ditu. Bigarrena,
aldiz, klase nagusia izango da eta aplikazioa kudeatuko duen main metodo nagusia izango du.
KontuKorronte.java klasea
Kontu korronte batek honako elementuak izaten ditu: kontuaren jabea, kontuaren saldoa
(eurotan), eta bezeroaren kontu-kodea (BKK). Bezeroaren kontu-kodeak 20 zifra dauzka: 4 zifra
finantza erakundea adierazteko, 4 zifra bulegoa adierazteko, 2 kontrol-zifra eta 10 zifra kontu
korrontearen zenbakirako. Kontrol zifrak kalkulatzeko gainerako 18 zifrak erabiltzen dira; beraz, ez
ditugu bi zifra horiek gordeko. Kontuaren jabearen izenak gehienez 100 letra izango ditu eta
gutxienez 10 letra. Hortaz, klasearen diseinuak eredu honi jarraituko dio:
- Atributu pribatuak: jabea, saldoa, erakundea, bulegoa eta kontu korrontearen zenbakia.
- Atributu estatiko publikoak: jabearen izenaren gutxieneko eta gehieneko luzera zehazteko
konstante bi.
- Metodo publikoak:
1. Parametro bidez kontu korrontearen datuak jasoko dituen sortzailea.

Parametroren bat eta/edo BKK egokiak ez badira, salbuespen bat jaurtiko du.
public KontuKorronte(String jabea, String erakundea, String bulegoa, String KZ, String
kontuZenbakia);
2. Jabea eta deskonposatu gabeko BKK jasoko dituen sortzailea. Sortzaile honek
BKK kodea deskonposatuko du eta beste sortzaileari egingo dio dei.
public KontuKorronte (String jabea, String BKK);
3. Atributu guztientzat getter metodoak.
4. jabea atributuarentzat setter metodoa. Izena egokia ez bada, salbuespen bat

jaurtiko dugu.
5. diruaSartu metodoa: Kontu korronteak daukan saldoari dirua gehituko dio.

Parametro bidez pasatutako datua positiboa izango da; bestela, salbuespen bat
jaurtiko da.
public void diruaSartu (double zenbatDiru)

6. diruaAtera metodoa: Kontu korronteak daukan saldoari dirua kenduko dio.
Parametro bidez pasatutako datua positiboa izango da eta kontuan dagoen saldoa
baino txikiagoa; bestela, salbuespen bat jaurtiko da.
public void diruaAtera (double zenbatDiru)
7. frogatuBKK metodoa: true ala false itzuliko du BKK egokia den ala ez frogatu
ondoren.
public static boolean frogatuBKK(String BKK);
8. kontrolZifrakKalkulatu metodoa: metodoak bi kontrol zifrak itzuliko ditu.
public static String kontrolZifrakKalkulatu(String erakundea, String bulegoa, String

kontuZenbakia)
9. toString metodoa: jabearen datuek, BKK-k eta saldoak osatutako String bat
itzuliko du.
Behar adina metodo pribatu sor ditzakezu, kodea hobetsi eta bikoiztasunak saihesteko.
Dokumentazioa ere egin behar duzu Javadoc erabiliz eta metodoen barruan lagungarriak izan
daitezkeen iruzkinak idatzi.
NOLA KALKULATU BKK BATEN KONTROL ZIFRAK
Lehenengo zifra kalkulatzeko erakundearen eta bulegoaren 8 zifrak hartuko ditugu. Imajina ezazu 8
zifra horiek 12345678 direla.
Zifra horiek beste zenbaki batekin biderkatzen dira, daukaten posizioaren araberakoa. Posizioaren
araberako pisuak hauek dira: 1,2,4,8,5,10,9,7,3,6.
Lehenengo digitua kalkulatzeko, gure zenbakiak 8 zifra besterik ez daukanez, ezkerretik bi zero
jarriko dizkiogu: 0012345678.
Ondoren, faktoreen arteko biderketa egiten da eta emaitza guztiak batzen dira:
0 0 1 2 3 4 5 6 7 8
1 2 4 8 5 10 9 7 3 6
0 0 4 16 15 40 45 42 21 48
4+16+15+40+45+42+21+48 = 231
Emaitza 11 zenbakiarekin zatituko dugu eta hondarrarekin geratuko gara. Gero, 11ri hondarra
kenduko diogu eta hori izango da lehenengo kontrol zifra. Emaitza 10 izango balitz, kontrol zifra 1
izango litzateke, eta 11 balitz, kontrol zifra 0 izango litzateke.
231%11 = 0
11 – 0 = 11. Beraz, lehenengo kontrol zifra 0 izango da.
Bigarren kontrol zifra berdin kalkulatuko da, baina kontu korrontearen 10 zifrak hartuta.
KontuKorronteAplikazioa.java klasea
Klase honetatik eskatuko zaizkio beharrezko datuak erabiltzaileari eta bertatik kudeatuko da
pantailan erakutsiko den menua. Erroreak eta salbuespenak kontrolatu behar dira, programa
ustekabean ez amaitzeko.

Java Ikasteko

Uploaded by

Document Information

Original Title

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

Java Ikasteko

Uploaded by

Copyright:

Available Formats

JAVA: APUNTEAK ETA ARIKETAK

Oier Palacios Egiguren

1.1.1. ZER DA JAVA

public class KaixoMundua {

1.1.3. JDK (Java Development Kit)

Java Development kit Java garatzeko tresna-multzo bat da.

1.1.3.1. JDK ESKURATU

Ohar-bloka zabalduko dugu, eta kode hau idatziko dugu:

Horrek KaixoMundua.class fitxategia sortzen du (Javaren makina birtualak ulertzen duena).

java KaixoMundua (ez da fitxategi-luzapenik jartzen).

1.2. IDENTIFIKADOREAK ETA ALDAGAIAK

3. Onartzen dituen balioen heinak

Aldagaiari ematen zaion izenari identifikadore esaten zaio.

- Hurrengo karaktereak letrak edo zenbakiak izan behar dira.

- Ezin da programazio-hizkuntzaren hitz erreserbaturik erabili.

Identifikadorea Hitzarmena Adibidea

Aldagaiaren izena Minuskulaz hasten dira. Hitz batuketa, ikasleKopurua

Konstantearen izena Dena maiuskulatan. Hitzak PI, TAMAINA_MAX

Klasearen izena Maiuskulaz hasten dira Pertsona, Karratua

Metodoaren izena Minuskulaz hasten dira aldatu_Balioa,

Programazio-hizkuntzan erabiltzeko erreserbatzen dira eta, beraz, ezin dira identifikadore

Javan, hitz hauek daude erreserbatuta:

1.2.3. ALDAGAI MOTAK.

a) Oinarrizko datu motak gordetzen dituzten aldagaiak eta erreferentzia-aldagaiak: Aldagai bi

b) Aldagarriak eta konstanteak:

public class AldagaiAdibidea{

final double PI = 3.1415927; // PI konstantea da

int eskuratuX (int x){ // x parametro bat da

int balioZaharra = this.x; // balioZaharra aldagai

Aldagai hauek dituen klase bat sortu dugu:

Erreferentziazkoak. Datu mota hauetan gordetako aldagaiek ez dute gordetzen zuzenean

Adierazitako Heina Azalpena

16 bit erabiltzen dira

32 bit erabiltzen dira

64 bit erabiltzen dira

public class Adibidea {

• Zenbaki handiagoak adieraztea

1.3.3. ALDAGAI ETA KONSTANTEAK DEKLARATZEA ETA

Hona hemen adibide bat:

int ikasleKop = 15;

Aurreko adibidean, 3 aldagai deklaratu ditugu:

final double PI = 3.1415926536;

• Aldagai-klasekideak: automatikoki hasieratzen dira baliorik ematen ez badiegu:

1.4.1. ERAGILE ARITMETIKOAK

Eragile aritmetikoek, eragingaiak konbinatuz, adierazpen aritmetikoak osatzen dituzte.

Eragilea Eragiketa Javan Adierazpena Javan Emaitza

+ Batuketa 1.2 + 9.3 10.5

- Kenketa 312.5 – 12.3 300.2

* Biderketa 1.7 * 1.2 2.04

/ Zatiketa 0.5 / 0.2 2.5

Esleipen-eragileen funtzioa programak aldagai bati balioa ematea da. Esleipen-eragilerik

Eragilea Adibidea Javan Adierazpen baliokidea

+= op1 += op2 op1 = op1+op2

-= op1 -= op2 op1 = op1-op2

*= op1 *= op2 op1 = op1*op2

/= op1/= op2 op1 = op1/op2

%= op1 %= op2 op1 = op1%op2

= op1 = op2 op1 = op2

1.4.3. BALDINTZAZKO ERAGILEA (?:)

1.4.4. ERLAZIOZKO ERAGILEAK

Eragilea Adibidea Javan Esanahia

< A<B A txikiagoa da B baino

> A>B A handiagoa da B baino

= op1 = op2 op1 = op1*op2