• 3.2.1. Primitív típusok
  • A short, az int és a long
  • A float és a double
  • 3.2.2. Primitív burkoló osztályok (primitive wrappers)
  • A Byte, a Short, az Integer, a Long, a Float és a Double osztály
  • A Character osztály
  • Közös konstansok
  • 1 Fejlesztői környezetek




    Download 0.7 Mb.
    bet4/8
    Sana07.04.2017
    Hajmi0.7 Mb.
    1   2   3   4   5   6   7   8

    3.2. Típusok


    A Java nyelv - hasonlóan a Pascal és a C/C++ nyelvhez - alapvetően bináris számítógépeken futó programok készítésére használatos: egyszerűbb a mi fogalmainkat használva megírni egy programot, amelyet aztán lefordítunk a számítógép nyelvére (gépi kód), amelyet ugyan meg lehet tanulni, de hatékonyabban tudunk felhasználói igényeket kielégíteni, ha magas szinten programozunk. A bináris számítógépek hatékony kihasználásához nem feltétlen szükséges ismernünk a számítógép magját alkotó CPU által kezelhető adattípusokat, ezt megteszik helyettünk az említett programnyelvek, mégpedig a primitív típusok által.

    3.2.1. Primitív típusok


    Egy bináris (más néven digitális) számítógép számára minden a világon két számból épül fel: 0 és 1, amelyeket bináris számnak (binary digit, vagyis bit) nevezünk. Bármi, amit a számítógépünkön találunk, az mind bináris számok különféle kombinációja és sorozata, s a kettes számrendszer írja le a kombinációk és sorozatok kódolását. A különféle hosszúságú kettes számrendszerben kódolt számoknak a szakma neveket adott, nézzük át őket (a teljesség igénye nélküli):

    • bit (boolean) - bit: a legkisebb egység, értéke lehet 0 vagy 1, illetve igaz (true) vagy hamis (false).

    • byte - bájt: 8 bináris szám által reprezentált szám, értéktartománya 28, vagyis 0 – 255 vagy -128 – 127.

    • char - karakter: egy bájt által reprezentált karakter, kódolása általában ASCII.

    • word - egy gépi szó: két bájt, 16 bit által reprezentált szám, értéktartománya 216, vagyis 0 – 65535 vagy -32768 – 32767.

    • integer - egész szám: egy vagy több gépi szó által reprezentált szám, értéktartománya tipikusan 232, vagyis 0 – 4 milliárd vagy -2 milliárd – 2 milliárd.

    • long (integer) - nagy egész szám: általában négy gépi szó által reprezentált szám, értéktartománya általában 264, vagyis 0 – 16 trillió vagy -8 trillió – 8 trillió.

    • real (float) - valós szám: két gépi szóból álló egyszerű (lebegőpontos) valós szám, értéktartománya előjel nélkül ~1.4-45 – ~3.438.

    • double - nagy valós szám: négy gépi szóból álló (lebegőpontos) valós szám, értéktartománya előjel nélkül: ~4.9-324  ~1.8308.

    A lebegőpontos számok használata során ismernünk kell a trükköt, hiszen nyilvánvaló kell legyen, hogy 32 bitbe nem fér el minden valós szám 1.4-45 és 3.438 között. A megoldás egyszerű: az egész számokat tároló megoldások a szám összes számjegyét tárolják, míg az utóbbi kettő - valós szám tárolására használt számkódolási eljárás - kerekít. A megadott tartományon belül tetszőlegesen nagy számot tudunk tárolni, de csak 7-8 számjegy pontossággal. További trükk, hogy a nulla értéket csak megközelíteni tudjuk, a legkisebb érték és a nulla között mindig lesz egy tartomány, amelyet nem tudunk használni. Az alábbi számegyenesre tekintve láthatjuk, hogy a kék pontok jelentik a kódolás határértékeit, a zöld részen tudunk számokat tárolni 7-8 számjegy pontossággal, és a piros területeket már nem tudjuk tárolni:




    A Java nyelvben a felsorolás sorrendjében a boolean, a byte, a char, a short, az int, a long, a float és a double használatos, ezeket nevezzük primitív típusnak. Fontos tudni, hogy nincs előjel nélküli típus, az összes primitív típus előjeles szám, nézzünk példát ezen típusok használatára.

    Vegyük elő a NetBeans környezetben a már létrehozott Kocsma projektet, és keressük meg benne a kocsma csomagot, majd azon belül a Main osztályt, majd az alábbi programot írjuk bele:



    view plaincopy to clipboardprint?

    1. package kocsma;  

    2.   

    3. public class Main  

    4. {  

    5.   

    6.   public static void main(String[] args)  

    7.   {  

    8.     // Ide fogjuk írni az alábbi programrészleteket  

    9.   }  

    10. }  

    A // kezdetű sor helyére kell írni az alábbiakban megemlített programrészleteket, majd az F6 gomb megnyomásával futtatni tudjul a (helyesen megírt) programot.

    A boolean


    boolean típust akkor használjuk, ha egy eldönthető kérdésekre adott válasz csak igen/igaz vagy nem/hamis lehet, a boolean ugyanis nem képes a talán vagy a nem tudom válaszokat értelmezni. A C/C++ nyelvektől eltérően egy boolean típusú változó értéke csak a truevagy a false értéket veheti fel, a számszerűen jelzett értékeket nem képes értelmezni.

    view plaincopy to clipboardprint?

    1. boolean igaz = true;  

    2. boolean hamis = false;  

    3. boolean válasz;  

    4. válasz = igaz;  

    Vannak olyan műveletek, amelyek természetszerűleg boolean értéket adnak eredményül:

    view plaincopy to clipboardprint?

    1. válasz = 9 < 3;  

    2. System.out.println(válasz);  

    3. válasz = 3 < 10;  

    4. System.out.println(válasz);  

    Az első esetben false (hamis) eredményt kapunk, hiszen a kilenc nem kisebb, mint a három; a második esetben az eredmény true(igaz), hiszen a három kisebb, mint a tíz.

    A példában említett true és false literál, vagyis a nyelvbe épített és értékkel bíró fogalom. Láthatunk továbbá több deklarációt és értékadásokat is - ezekről később több szót ejtek.


    A byte


    byte típust akkor célszerű használnunk, ha nulla közeli egész számokkal számolunk, hiszen értéktartománya mindössze a -128 és a 127 közötti számokra érvényes:

    view plaincopy to clipboardprint?

    1. byte szám;  

    2. szám = 12;  

    3. szám = -12;  

    4. szám = -128;  

    5. szám = 127;  

    A példában láthatunk egy deklarációt és négy értékadást, ahol a szám nevű változónak adunk más-más értéket, s itt már szám literálokat használunk. Fontos tudni, hogy a primitív típusok képesek a csöndes túlcsordulásra:

    view plaincopy to clipboardprint?

    1. byte szám;  

    2. szám = 127;  

    3. szám++;  

    4. System.out.println(szám);  

    A rövidke programrészlet eredménye -128 lesz, nem pedig a matematikailag várható 128. Ennek oka, hogy a változó túlcsordult, túllépte az értékkészlete egyik határát, és ezért értékül az értékkészletének másik határértékét veszi fel. Nagyon oda kell figyelnünk erre a tulajdonságra, mivel a programunk mindezt csöndben teszi, legtöbbször igen keserves és hosszú munkával tudjuk csak megkeresni a hiba okát.

    A short, az int és a long


    short, az int és a long teljesen azonos módon használható, mint a byte, a különbség mindössze az értéktartományban van (illetve abban, hogy a long típus literál használatához a szám mögé egy l karaktert kell írnunk):

    • short: -32768 – 32768

    • int: –2147483648 – 2147483647

    • long: -9223372036854775808l – 9223372036854775807l

    Ha nem adunk meg egy egész szám literál után módosító karaktert, akkor a nyelv szabályai szerint a fordító megpróbálja konvertálni arra a típusra, ami a használt változó típusa, egyéb esetben a literál típusa int lesz.

    A char


    A többi nyelvhez hasonlóan a char egy öszvér adattípus, alapvetően számokat tartalmaz, de ha az értékét kiírjuk, akkor karaktereket kapunk eredményül. A Java nyelv úttörő volt a tekintetben, hogy a char típus alapja nem a 8 bites byte, hanem az 32 bites integer, hiszen a Java nem ASCII alapú, hanem UTF-8 az alapértelmezett karakter kódolása, mivel ismert világ összes karaktere nem fér el 8 biten.

    Nézzük meg ezt a gyakorlatban:



    view plaincopy to clipboardprint?

    1.     char betű = 64;  

    2.     System.out.print(betű);  

    3.     betű = ’\n’;  

    4.     System.out.print(betű);  

    5.     betű = ’a’;  

    6.     System.out.print(betű);  

    7.     betű = ’\t’;  

    8.     System.out.print(betű);  

    9.     betű = ’\\’;  

    10.     System.out.print(betű);  

    11.     betű = ’\’’;  

    12.     System.out.print(betű);  

    13.     betű = ’"’;  

    14.     System.out.print(betű);  

    15.     betű = ’\070’;  

    16.     System.out.print(betű);  

    17.     betű = ’\u003F’;  

    18.     System.out.print(betű);  

    Eredményül az alábbi (ránézésre értelmetlen) karakter halmazt kapjuk:

    view plaincopy to clipboardprint?

    1. @  

    2. a       \’"8?  

    Lássuk a dekódolást:

    • A @ karakter UTF-8 (és ASCII) kódja a 64 szám, ezért a @ az első kiírt karakter.

    • A \n karakter az újsor kódja, ez nem látható karakter, viszont a (szintén nem látható) kurzort a következő sorba teszi.

    • A következő sor elején kiírt a betű egyértelmű kell legyen, hiszen ezt adtuk értékül a betű nevű változónak.

    • A negyedik kiírt karakter ismét egy nem látható karakter (\t), amely egy tabulátor pozícióval jobbra mozgatja a kurzort.

    • Biztos felmerült, hogy a \ karaktert hogy tudjuk kiírni: egyszerűen a \\ karaktert kell használnunk. A \ (backslash vagy visszaper jel) egy speciális karakter, amely az őt követő karakternek is speciális jelentést ad.

    • A szimpla idézőjel kiírásához a \’ karaktereket kell használnunk.

    • A dupla idézőjel kiírható, ha szimpla idézőjelek között van.

    • A \070 kódolás oktális formátumú számot hordoz, a 070 oktális szám azonos az 56 decimális számmal, amely az UTF-8 kódrendszerben a ’8’ karakternek felel meg.

    • A \u003F kódolás hexadecimális formátumú számot jelent, a 003F szám azonos a 63 decimális számmal, amelynek a ’?’ karakter felel meg.

    Mint láthatjuk, eléggé változatos módon tudunk karaktereket megadni, azonban a char kettős természetét az is meghatározza, hogy tudunk vele műveleteket végezni:

    view plaincopy to clipboardprint?

    1. char betű = 64;  

    2. betű++;  

    3. System.out.print(betű);  

    4. betű += 0;  

    5. System.out.print(betű);  

    6. betű += ’0’;  

    7. System.out.print(betű);  

    Az eredmény az AAq karaktersorozat lesz, hiszen a 64 az ’@’ karaktert kódolja, amihez ha hozzáadunk egyet, akkor ’A’ betű lesz, amit a 65 kódol. Ha ehhez hozzáadunk nullát (0), akkor az eredmény továbbra is 65 marad, de ha karakteresen adunk hozzá nullát (’0’), amelynek a számszerű értéke 48, akkor az eredmény 113 lesz (mivel 65+48 az 113), amely szám a ’q’ karaktert kódolja.

    A karakter literálok két szimpla idézőjel közötti karakterek. Általában egy karakter, de ha az első karakter visszaper jel (\), akkor több karakter is lehet a két idézőjel között. Érdemes megtanulni a speciális karakter literálok használatát, mivel használatuk sok esetben szükséges a szövegfeldolgozáshoz.


    A float és a double


    A valós számok használata akkor kerül előtérbe, amikor olyan számolásokat végzünk, amelyek nem végezhetők el könnyedén egész számokon. A valós számok használata lassíthatja a program működését, mivel ezek kezelése néhány processzoron nincsen kellően gyorsítva, ezért csak akkor használjunk valós számokat, amikor feltétlenül szükséges. Nézzük a float típus használatát:

    view plaincopy to clipboardprint?

    1. float szám = 0;  

    2. System.out.println(szám);  

    3. szám = 1/3;  

    4. System.out.println(szám);  

    5. szám = 1f/3f;  

    6. System.out.println(szám);  

    7. szám = -1*0f;  

    8. System.out.println(szám);  

    9. System.out.println(szám == 0f);  

    10. szám = 100000000000000000000000000000000000000f;  

    11. System.out.println(szám);  

    12. szám = 1.0E38f;  

    13. System.out.println(szám);  

    Eredményül nem pont azt kapjuk, amit várnánk:

    view plaincopy to clipboardprint?

    1. 0.0  

    2. 0.0  

    3. 0.33333334  

    4. -0.0  

    5. true  

    6. 1.0E38  

    7. 1.0E38  

    Az első 0.0 érthető, hiszen ezt adtuk értékül a szám nevű változónak. A második 0.0 azonban elgondolkodtató: az egyharmad értéke nem szabadna nulla legyen. Ennek oka az, hogy a Java nyelv két egész számot lát: elosztja az egyet hárommal: hányszor van meg egyben a három? Ugye egyszer sem, ezért kaptunk eredményül nullát. A problémát úgy tudjuk kikerülni, hogy a szám mögé írt f betűvel mondjuk meg, hogy ez a szám nem egész szám, hanem float. A 1f/3f művelet eredménye már 0.33333334, mivel a float csak nyolc számjegy pontosságú, azt követően nincs több értékes számjegy. A -0.0 eredmény a számábrázolás érdekessége, ugyanis van plusz nulla és mínusz nulla is, és ahogy a következő sorban látjuk: a kettő egyenlő egymással. A nagy számokat megadhatjuk a számjegyekkel is, de rövidebb a normálforma: 1.0·1038, amely a program forrásában 1.0E38 formán kódolódik.

    double használata annyiban tér el a float használatától, hogy az f karakter helyett d karaktert kell használnunk a literál megadásakor (amelyet akár el is hagyhatunk, hiszen a double típus az alapértelmezett lebegőpontos típus).


    3.2.2. Primitív burkoló osztályok (primitive wrappers)


    Mindegyik primitív típusnak van egy burkoló osztálya, amely már használható objektum orientált módon, s képes önmagán néhány egyszerű (nem matematikai) műveletet elvégezni.

    A Boolean osztály


    boolean típushoz tartozó burkoló osztály, amelynek leginkább azt a tudását használjuk fel, hogy szövegből képes önmagát legyártani:

    view plaincopy to clipboardprint?

    1.     Boolean válasz= new Boolean("tRuE");  

    2.     System.out.println(válasz);  

    A paraméterben átadott szöveg hatására a válasz nevű változó értéke true lesz. Akkor és csak akkor lesz az eredmény true, ha az átadott szöveg karakterhelyesen "true", azonban a kis és nagybetű nincs megkülönböztetve (case insensitive). Ugyanígy használható a valueOfmetódus is, amely egy picit gyorsabb is:

    view plaincopy to clipboardprint?

    1.     Boolean válasz= Boolean.valueOf("tRuE");  

    2.     System.out.println(válasz);  

    Az eredmény jelen esetben is true lesz. Az 1.5 Java verziótól használhatjuk az automatikus konverziót is:

    view plaincopy to clipboardprint?

    1. Boolean válasz = true;  

    2. boolean érték = válasz;  

    Az 1.5 verzió előtt ezt csak hosszabban tudtuk leírni:

    view plaincopy to clipboardprint?

    1. Boolean válasz = Boolean.valueOf(true);  

    2. boolean érték = válasz.booleanValue();  

    A Byte, a Short, az Integer, a Long, a Float és a Double osztály


    Ezen osztályok mind a Number osztályból származnak, amely a számokat kezelő osztályok őse. A Number őstől örökölt kényszer szerint van hat metódusuk, amely a burkoló osztály által hordozott szám primitív típusát adja vissza:

    view plaincopy to clipboardprint?

    1.     Double szám = new Double(3.141592653589793);  

    2.     System.out.println(szám.doubleValue());  

    3.     System.out.println(szám.floatValue());  

    4.     System.out.println(szám.longValue());  

    5.     System.out.println(szám.intValue());  

    6.     System.out.println(szám.shortValue());  

    7.     System.out.println(szám.byteValue());  

    8.      

    9.     szám = Double.parseDouble("2.718281828459045");  

    10.     System.out.println(szám.doubleValue());  

    11.     System.out.println(szám.floatValue());  

    12.     System.out.println(szám.longValue());  

    13.     System.out.println(szám.intValue());  

    14.     System.out.println(szám.shortValue());  

    15.     System.out.println(szám.byteValue());  

    A fenti programrészlet eredménye:

    view plaincopy to clipboardprint?

    1. 3.141592653589793  

    2. 3.1415927  

    3. 3  

    4. 3  

    5. 3  

    6. 3  

    7. 2.718281828459045  

    8. 2.7182817  

    9. 2  

    10. 2  

    11. 2  

    12. 2  

    Mint látható, a valós számot hordozó Double esetén az egész számra való alakítás is megtörténik, ha egész típusú primitív típust kérek el, azonban az átalakítás során csonkolás történik (eltűnik a tizedespont mögötti számsor), nem pedig kerekítés!

    Ezek az osztályok már több műveletet is lehetővé tesznek, nekünk azonban egyelőre elég a valueOf ismerete, amely szöveges formából alakít számmá, akárcsak a Boolean esetén:



    view plaincopy to clipboardprint?

    1.     szám = Double.valueOf("-2");  

    2.     System.out.println(szám);  

    3.     szám = Double.valueOf("-2.2E3");  

    4.     System.out.println(szám);  

    5.     szám = Double.valueOf("-2.2E3000");  

    6.     System.out.println(szám);  

    7.     System.out.println(szám.isInfinite());  

    Ennek eredménye:

    view plaincopy to clipboardprint?

    1. -2.0  

    2. -2200.0  

    3. -Infinity  

    4. true  

    Fontos, hogy a valós típusoknak lehet negatív és pozitív végtelen értéke - ha túl nagy számot szeretnénk szöveges formából átalakítani vagy a művelet eredménye túl nagy, ezt lekérdezhetjük az isInfinite metódussal.

    A Character osztály


    A karakter ismét kilóg a sorból, hiszen a célja alapvetően nem a számolás, hanem karakterek ábrázolása.

    view plaincopy to clipboardprint?

    1. Character karakter = new Character(’a’);  

    2. System.out.println(karakter);  

    3. System.out.println(Character.isDigit(’0’));  

    4. System.out.println(Character.isDigit(’a’));  

    5. System.out.println(Character.isWhitespace(’\t’));  

    6. System.out.println(Character.isWhitespace(’a’));  

    7. System.out.println(Character.isISOControl(’\t’));  

    8. System.out.println(Character.isISOControl(’a’));  

    9. System.out.println(Character.toLowerCase(’A’));  

    10. System.out.println(Character.toUpperCase(’a’));  

    A futás eredménye:

    view plaincopy to clipboardprint?

    1. a  

    2. true  

    3. false  

    4. true  

    5. false  

    6. true  

    7. false  

    8. a  

    9. A  

    A Character osztálynak van egy rakás statikus metódusa, amely a megadott karakterről döntést hoz. A példában rákérdeztünk párosával arra, hogy az átadott karakter szám-e, helykitöltő karakter-e, valamit ISO vezérlőkarakter-e. Az utolsó két metódus pedig konvertálta az átadott karaktert kis-, illetve nagybetűsre. Ezen túl sok egyéb metódust megtalálunk a Character osztályban (írásirány, tükörírás, stb.), ezeket nem részletezném.

    Közös konstansok


    A Boolean osztályt leszámítva az összes burkoló osztálynak van négy hasznos konstansa:

    • TYPE, amely a primitív típust adja vissza

    • SIZE, amely a primitív típus által elfoglalt bitek számát adja vissza

    • MAX_VALUE, amely a legnagyobb ábrázolható értéket hordozza

    • MIN_VALUE, amely a legkisebb ábrázolható értéket hordozza, lebegőpontos típus esetén a legkisebb ábrázolható pozitív számot

    Lássunk rá példát:

    view plaincopy to clipboardprint?

    1. System.out.println(Byte.TYPE);  

    2. System.out.println(Byte.MAX_VALUE);  

    3. System.out.println(Byte.MIN_VALUE);  

    4. System.out.println(Byte.SIZE);  

    5.   

    6. System.out.println(Short.TYPE);  

    7. System.out.println(Short.MAX_VALUE);  

    8. System.out.println(Short.MIN_VALUE);  

    9. System.out.println(Short.SIZE);  

    10.   

    11. System.out.println(Integer.TYPE);  

    12. System.out.println(Integer.MAX_VALUE);  

    13. System.out.println(Integer.MIN_VALUE);  

    14. System.out.println(Integer.SIZE);  

    15.   

    16. System.out.println(Long.TYPE);  

    17. System.out.println(Long.MAX_VALUE);  

    18. System.out.println(Long.MIN_VALUE);  

    19. System.out.println(Long.SIZE);  

    20.   

    21. System.out.println(Float.TYPE);  

    22. System.out.println(Float.MAX_VALUE);  

    23. System.out.println(Float.MIN_VALUE);  

    24. System.out.println(Float.SIZE);  

    25.   

    26. System.out.println(Double.TYPE);  

    27. System.out.println(Double.MAX_VALUE);  

    28. System.out.println(Double.MIN_VALUE);  

    29. System.out.println(Double.SIZE);  

    30.   

    31. System.out.println(Character.TYPE);  

    32. System.out.println(Character.MAX_VALUE);  

    33. System.out.println(Character.MIN_VALUE);  

    34. System.out.println(Character.SIZE);  

    Az eredményt mindenki nézze meg a saját gépén... :)

    Download 0.7 Mb.
    1   2   3   4   5   6   7   8




    Download 0.7 Mb.

    Bosh sahifa
    Aloqalar

        Bosh sahifa



    1 Fejlesztői környezetek

    Download 0.7 Mb.