Fiókos szekrény szilíciumból. A számítógép mindent képes tárolni, csak mi nem felejtsük el, mit hová tettünk: a változók. Fiókméretek és adattípusok. Két egyszerû adattípus, az egész és a lebegõpontos. Néhány alapmûvelet kezdetnek.
A számítógép olyan, mint a mamátok fiókos szekrénye. Ez egy nagyon jó hasonlat, magamtól nem is tudtam volna kitalálni, Roger Kaufman örökbecsû FORTRAN képeskönyvébõl vettem. FORTRAN-t ma már kevesen használnak, de a könyv még ma is a legjobb bevezetõ kezdõknek a számítógépes programozásba. De vissza a fiókos szekrényhez! A szekrénynek, akarom mondani a gépnek rengeteg fiókja van a legkülönbözõbb cuccok tárolására. A gép persze nem zoknikat vagy több éves villanyszámlákat tárol, hanem adatokat. Hogy a sok fiók között ne vesszünk el, megcímkézzük a fiókokat, egyszerû és találó neveket adunk nekik. Egy ilyen fióknév egy változó neve, tartalma pedig a változóban tárolt érték.
A változó egy igen fontos fogalom, ezért lássunk néhány hasonlatot. Pénztárcánkban levõ pénz változó mennyiség, ez megfelel a változó értékének. Egy konkrét pénztárca megfelel a változónak magának, holott pénztárcák általában nincsenek felcímkézve. Vagy vegyünk egy teherautót: a rajta levõ sóder mennyisége változó érték, a teherautó rendszáma pedig azonosítja, melyik értéket keressük.
A változó egy analógia, ami lehetõvé teszi nekünk, hogy a gép sok milliónyi memóriarekeszébõl kiválasszuk a minket érdeklõt. Egy változó mindig egy adag memóriarekeszre vonatkozik (hogy mennyire, azt majd az adattípusok tárgyalásánál meglátjuk) és a Jáva nyelv azt a kényelmességet adja nekünk, hogy erre az adag memóriarekeszre egy általunk választott névvel hivatkozhatunk. A névnek egyedinek kell lennie és betûvel kezdõdnie, a további karakterei lehetnek betûk, számok vagy aláhúzásjel. Néhány példa érvényes változónevekre:
Itt van három érvénytelen is:
A Jáva nyelv különbözõnek veszi a kis- és nagybetûket, így a pi és a PI két külön változót jelöl.
Mint ahogy a fiók kiválasztásánál is fontos, hogy cetliket tárolunk-e benne vagy lábosokat, úgy a számítógépnek is tudnia kell, mennyi memóriát kell egy változóhoz rendelnie. Ezt az határozza meg, milyen típusú adatokat tárolunk a fiókban, akarom mondani a memóriarekeszben. A tárolni kívánt adat típusát a változó adattípusának megadásával kell meghatároznunk, hasonló módon, mint ahogy a változó nevét is a változónévvel. A Jáva nyelvnek van néhány beépített adattípusa továbbá a képessége, hogy új adattípusokat hozhasson létre a programozó. Most csak két adattípus vizsgálunk meg, az egész és a lebegõpontos típust.
Az egész típus a számítógépünk legalapvetõbb típusa, leginkább ezzel szeret számolni a gép, ezért mi is használjuk, ahol csak lehet. Az egész típusú szám 0-tól nagyjából 2 milliárdig nõhet és csökkenhet pozitív és negatív irányban egyaránt és nevéhez illõen törtrésze nem lehet. A típust az int kulcsszó leírásával deklaráljuk. Pl.:
int i;
int K,nagyon_hosszu_valtozonev;
A deklaráció a Jáva nyelvben kötelezõ. Minden változót elõbb deklarálni kell és csak aztán lehet használni. Deklarálás bárhol lehet a programban a változó felhasználása elõtt, tehát akár a program közepén is. A deklarálás hatására a változóhoz hozzárendelõdik a tárterület, ahol a változó értékét tárolja gépünk, de a változó értékérõl semmit sem tudunk. Sõt mi több, a Jáva fordító, ha felderíti, hogy olyan változót használtunk, aminek az értékérõl még nem rendelkeztünk, hibaüzenetet küld.
De mit beszélek én itt a változó értékének megadásáról és a változó felhasználásáról, amikor még csak a deklarálást ismerjük? Ha egy változót már deklaráltunk, következõ lépésben adjunk neki gyorsan értéket. Pl.:
i = 3;
K = -10;
Ez az értékadó utasítás. Fontos, hogy ne tekintsd az értékadó utasítást a matematikából ismert egyenlõség teljes szinonímájának. A matematikai egyenlõség azt fejezi ki, hogy két kifejezés a levezetés teljes idõtartamára bizonyos feltételek mellett megegyezik. Ha tehát y = 2x, akkor ez így van bármilyen x-re a megadott peremfeltételek mellett. Az értékadó utasítás azonban, hogy a FORTRAN képeskönyvbõl orozzak megint, egy "bemén" jel, tehát abban a pillanatban, amikor kiértékelõdik, a jobb oldalán egy szám lesz, ami beleíródik, "bemén" a változó mögött meghúzódó memóriába csak egyszer és akkor, amikor az utasítás végrehajtódik. Ha késõbb frissíteni akarjuk a változó értékét, újra végre kell hajtanunk egy értékadó utasítást. Ha tehát én azt mondom, hogy y = 2*x, akkor a gép veszi az x változó értékét, megszorozza kettõvel és beteszi az y változóba (figyelj, mostantól slamposabban fogalmazok! eddig mindig hangsúlyoztam, hogy a változónév mögött hozzárendelt memória húzódik meg, de remélhetõleg ez már jól a fejedbe vésõdött. Mostantól csak azt mondom, hogy, beleíródik a változóba). Ez csak egyszer és az x aktuális értékével történik meg, ha x késõbb megváltozik és fontos, hogy ezt y is kövesse, újra végre kell hajtani az értékadást.
Suttyomban megint elõreszaladtam egy kicsit és leírtam egy Jáva kifejezést. Végre is erre tartjuk a számítógépet, számoljon gyorsan. A Jáva program is mindent képes kiszámolni, ami leírható egy véges mûveletsorozattal, azaz algoritmussal. A Jáva program jónéhány mûveletet képes számokkal elvégezni, ezek közül nézzük most a négy alapmûveletet.
A mûveletek a matematikában megszokott módon precedenciával rendelkeznek, tehát zárójelek nélkül a szorzás és az osztás "erõsebb" az összeadásnál és a kivonásnál. Ezen (szokásos módon) zárójelekkel változtathatunk. Pl. a 5+2*10 értéke 25, míg az (5+2)*10 értéke 70. Zárójeleket tetszõleges mélységben ágyazhatunk egymásba, csak párosan legyenek. A kifejezésekben a konstansokat, esetünkben egész számokat és a változókat egyenértékûen használhatjuk. Ha tehát az y változóba az x változó kétszeresét akarnád tenni, a helyes válasz: y = x*2. Lássuk ezt egy mûködõ programban is!
public class Szamit1{
public void prog( String args[] ) {
int x,y;
x = 5;
y = x*2;
System.out.println( "Eredmeny: "+y
);
}
public static void main( String args[] ) {
Szamit1 e = new Szamit1();
e.prog( args );
}
}
Nem hiszem, hogy a System.out.println során kívül bármi is magyarázatot igényelne. A már megismert karaktersorozat-konstanshoz (az idézõjelek között levõ részhez) hozzáfûztük az y változót, ami egy egész. Ekkor a Jáva fordító automatikusan olyan kódot fordít, ami az y-ban levõ értéket karaktersorozattá alakítja és hozzáfûzi a karaktersorozat-konstanshoz. Tehát az eredmény:
Eredmeny: 10
írj egy olyan programot, ami kiírja
2 elsõ nyolc hatványát. A kiírási kép
legyen tehát:
2^0 = 1
2^1 = 2
...
2^7 = ....
Oldd meg a feladatot önállóan, majd a saját programodat hasonlítsd össze a megoldással .
Ugye nem ért váratlanul az elõzõ feladatban az n=n+1 típusú értékadás? Matematikailag ez egy teljes csõd, de számítógépül annál több értelme van: vedd az n értékét, adj hozzá egyet, majd tárold vissza n-be, vagyis növeld meg n-t eggyel.
Most csavarjunk egyet a dolgon es 0-tol kezdve negatív irányba
haladjunk kettõ hatványaival. Vagyis a kiírási
kép legyen:
2^0 = 1
2^-1 = 0.5
...
(Ugye emlékszel: valaminek a negatív hatványa megegyezik a pozitív hatvány reciprokával. Vagyis: 2-4 = 1/24 ).
Ha programunkat lelkesen megmódosítanánk úgy,
hogy az összes n = n + 1-et n = n - 1-re és az összes
x = x * 2-t x = x / 2-re cserélnénk, szomorú nyomtatási
kép fogadna.
2^0 = 1
2^-1 = 0
2^-2 = 0
...
ami egyértelmûen helytelen. A baj okára magad is rájöhetsz:
egész számok osztása során elvesznek a törtrészek
és a 1/2 osztás 0.5 eredménye mint 0 tárolódik
vissza x-be. Egészekkel ezt a problémát nem tudod
megoldani, szükségünk lesz a Jáva egy másik
alaptípusára, a lebegõpontos típusra. A lebegõpontos
változót így deklarálod:
double pi;
double z0,z1;
és így adhatsz neki értéket:
pi = 3.1415927;
A lebegõpontos szám már elég nagy ahhoz, hogy nagyobb számokat írjál le vele, mint amit kényelmesen be tudsz csépelni egy sorba, ezért jól jöhet a tudományos számábrázolás. Ha emlékszel, ekkor a számot egy 0-10 közötti szám és egy 10 hatvány szorzataként írjuk le. Pl: 2500 = 2.5*1000 = 2.5*103. Jávában ezt úgy kell leírni: 2.5E3. Tehát:
z0 = 2.5e3;
Persze ha nem akarod ezt a kis számot exponenciális ábrázolásban leírni, nem kell.
z1 = 2500;
A double-ban leírható maximális szám kb. 10308 , a legkisebb 10-308, ugyanez persze negatív irányban is. Ekkora számokkal a gép persze jóval lassabban számol, mint egészekkel, így double-t csak akkor használjunk, ha szükséges.
Írjuk meg most az elõzõ, balsikerû feladványunkat a kettõ negatív hatványaival úgy, hogy x-et egész helyett double-nak deklaráljuk. Próbáld meg magad megírni, majd ellenõrizd a megoldást .
Ennyit elsõ közelítésben a számokról és a velük való mûveletekrõl. A Jáva persze jóval több adattípussal és mûvelettel rendelkezik, mint amit eddig láttunk, de a következõ részben inkább a program végrehajtását befolyásoló szerkezetekkel foglalkozunk.