Page History

...

Helyes azonosítók:

sor  
Sör  
sÖr  
ser  
_sör  
sör2  
egy_sör  
$sör  

Hibás azonosítók:

2sör
egy sör
kis-sör
super sör
sör:
Sört!

A Java nyelv kulcsszavait nem használhatjuk azonosítóként, ezek a következők:

abstract        boolean         break           byte            case              
catch           char            class           const           continue  
default         do              double          else            enum  
extends         false           final           finally         float  
for             goto            if              implements      import  
instanceof      int             interface       long            native  
new             package         private         protected       public  
return          short           static          super           switch  
synchronized    this            throw           throws          transient  
true            try             void            volatile        while  

...

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 Mainosztályt, majd az alábbi programot írjuk bele:

package kocsma;

public class Main
{

  public static void main(String[] args)
  {
    // Ide fogjuk írni az alábbi programrészleteket
  }
}

...

A 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 true vagy a falseértéket veheti fel, a számszerűen jelzett értékeket nem képes értelmezni.

boolean igaz = true;
boolean hamis = false;
boolean válasz;
válasz = igaz;

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

válasz = 9 < 3;
System.out.println(válasz);
válasz = 3 < 10;
System.out.println(válasz);

...

A 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:

byte szám;
szám = 12;
szám = -12;
szám = -128;
szám = 127;

A példában láthatunk egy deklarációt és négy értékadást, ahol a számnevű 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:

byte szám;
szám = 127;
szám++;
System.out.println(szám);

...

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.

char betű = 64;
System.out.print(betű);
betű = '\n';
System.out.print(betű);
betű = 'a';
System.out.print(betű);
betű = '\t';
System.out.print(betű);
betű = '\\';
System.out.print(betű);
betű = '\'';
System.out.print(betű);
betű = '"';
System.out.print(betű);
betű = '\070';
System.out.print(betű);
betű = '\u003F';
System.out.print(betű);

...

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

@
a       \'"8?

Lássuk a dekódolást:

...

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:

char betű = 64;
betű++;
System.out.print(betű);
betű += 0;
System.out.print(betű);
betű += '0';
System.out.print(betű);

...

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:

float szám = 0;
System.out.println(szám);
szám = 1/3;
System.out.println(szám);
szám = 1f/3f;
System.out.println(szám);
szám = -1*0f;
System.out.println(szám);
System.out.println(szám == 0f);
szám = 100000000000000000000000000000000000000f;
System.out.println(szám);
szám = 1.0E38f;
System.out.println(szám);

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

0.0
0.0
0.33333334
-0.0
true
1.0E38
1.0E38

...

A 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:

Boolean válasz= new Boolean("tRuE");
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 valueOf metódus is, amely egy picit gyorsabb is:

Boolean válasz= Boolean.valueOf("tRuE");
System.out.println(válasz);

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

Boolean válasz = true;
boolean érték = válasz;

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

Boolean válasz = Boolean.valueOf(true);
boolean érték = válasz.booleanValue();

...

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:

Double szám = new Double(3.141592653589793);
System.out.println(szám.doubleValue());
System.out.println(szám.floatValue());
System.out.println(szám.longValue());
System.out.println(szám.intValue());
System.out.println(szám.shortValue());
System.out.println(szám.byteValue());

szám = Double.parseDouble("2.718281828459045");
System.out.println(szám.doubleValue());
System.out.println(szám.floatValue());
System.out.println(szám.longValue());
System.out.println(szám.intValue());
System.out.println(szám.shortValue());
System.out.println(szám.byteValue());

A fenti programrészlet eredménye:

3.141592653589793
3.1415927
3
3
3
3
2.718281828459045
2.7182817
2
2
2
2

...

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

szám = Double.valueOf("-2");
System.out.println(szám);
szám = Double.valueOf("-2.2E3");
System.out.println(szám);
szám = Double.valueOf("-2.2E3000");
System.out.println(szám);
System.out.println(szám.isInfinite());

Ennek eredménye:

-2.0
-2200.0
-Infinity
true

...

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.

Character karakter = new Character('a');
System.out.println(karakter);
System.out.println(Character.isDigit('0'));
System.out.println(Character.isDigit('a'));
System.out.println(Character.isWhitespace('\t'));
System.out.println(Character.isWhitespace('a'));
System.out.println(Character.isISOControl('\t'));
System.out.println(Character.isISOControl('a'));
System.out.println(Character.toLowerCase('A'));
System.out.println(Character.toUpperCase('a'));

A futás eredménye:

a
true
false
true
false
true
false
a
A

...

Lássunk rá példát:

System.out.println(Byte.TYPE);
System.out.println(Byte.MAX_VALUE);
System.out.println(Byte.MIN_VALUE);
System.out.println(Byte.SIZE);

System.out.println(Short.TYPE);
System.out.println(Short.MAX_VALUE);
System.out.println(Short.MIN_VALUE);
System.out.println(Short.SIZE);

System.out.println(Integer.TYPE);
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
System.out.println(Integer.SIZE);

System.out.println(Long.TYPE);
System.out.println(Long.MAX_VALUE);
System.out.println(Long.MIN_VALUE);
System.out.println(Long.SIZE);

System.out.println(Float.TYPE);
System.out.println(Float.MAX_VALUE);
System.out.println(Float.MIN_VALUE);
System.out.println(Float.SIZE);

System.out.println(Double.TYPE);
System.out.println(Double.MAX_VALUE);
System.out.println(Double.MIN_VALUE);
System.out.println(Double.SIZE);

System.out.println(Character.TYPE);
System.out.println(Character.MAX_VALUE);
System.out.println(Character.MIN_VALUE);
System.out.println(Character.SIZE);

...

Eddigi programjaink során már találkoztunk az értékadás műveletével:

int szám;
szám = 2;

...

A legegyszerűbb operátor az előjelváltás:

int szám = 2;
szám = -szám;
System.out.println(szám);
szám = -szám;
System.out.println(szám);

...

A négy alapvető matematikai művelet közül a leginkább használt művelet az összeadás, Java nyelvben is pontosan úgy működik, mintha papírra vetnénk:

int szám;
szám = 3 + 4;
szám = szám + 5;
szám = szám + 1;
System.out.println(szám);

...

Azonos módon értelmezhető, mint az összeadás:

int szám;
szám = 3 - 4;
szám = szám - 5;
szám = szám - 1;
System.out.println(szám);

...

A szorzás is úgy működik, mint az előző két művelet, csak a műveleti jel változik:

int szám;
szám = 3 * 4;
szám = szám * 5;
szám = szám * 1;
System.out.println(szám);

...

Az osztás kilóg az előző három művelet közül, egy kicsit speciális a helyzete. Az egyik buktató - amiről már volt szó, hogy ha egész számok az operandusok, akkor egész osztás fog történni:

int szám;
szám = 30 / 4;
szám = szám / 5;
szám = szám / 1;
System.out.println(szám);

Normál esetben az eredmény másfél lenne, de az egész osztások miatt az 30/4 eredménye 7 lesz, ezt követően a 7/5 eredménye pedig 1, aztán az 1/1 természetesen 1. Ha a valós eredmény érdekel minket, akkor valós számokkal kell számolnunk:

double szám;
szám = 30 / 4;
szám = szám / 5;
szám = szám / 1;
System.out.println(szám);

Az eredményül kapott 1.4 egy kissé gyanús lehet matematikában jártas egyéneknek. A probléma gyökere ott van, hogy a 30/4 még mindig egész osztás marad, attól függetlenül, hogy a szám változó típusa valós. Ennek oka, hogy a Java nyelvben – és más nyelvekben is – az egyenlőség jel jobb oldalán kezdődik a kifejezés végrehajtása, mégpedig balról jobbra. Mivel a 30 egy egész szám és a 4 is egy egész szám, ezért a két számon értelmezett osztás művelet egész osztás lesz: a szám változóba eredményül 7 kerül. A következő sorban az utasítás szerint a szám változó értékét el kell osztani öttel. Itt a szám változó típusa okán már valós osztás lesz, és a 7/5 eredménye az 1.4. A hibát úgy tudjuk kikerülni, hogy jelezzük a 30 és a 4 valós voltát (illetve a többi szám valós voltát is):

double szám;
szám = 30.0 / 4.0;
szám = szám / 5.0;
szám = szám / 1.0;
System.out.println(szám);

Eredményül most már másfelet fogunk kapni. A nullával való osztásban is vannak különbségek. Ha valós számot osztunk nullával, akkor eredményül végtelent(Infinity) kapunk:

double szám;
szám = 30.0 / 4.0;
szám = szám / 5.0;
szám = szám / 0;
System.out.println(szám);

Ellenben egész szám esetén a program futása megszakad:

int szám;
szám = 30 / 4;
szám = szám / 5;
szám = szám / 0;
System.out.println(szám);

Egy kivétel (Exception) keletkezik, hogy nullával próbáltunk meg osztani:

Exception in thread "main" java.lang.ArithmeticException: / by zero  
        at kocsma.Main.main(Main.java:11)

...

Az egész osztás párja a maradékképzés, amikor nem arra vagyunk kíváncsiak az osztás során, hogy mennyi az eredmény, hanem arra, hogy mennyi a maradék:

int szám;
szám = 30 % 4;
System.out.println(szám);

Az eredményül kapott 2 nem okozhat meglepetést, ha vissza tudunk emlékezni az általános iskola második osztályában tanultakra: harmincban a négy megvan hétszer, maradék kettő. Mivel a maradékképzés is osztás, itt is kaphatunk kivételt, ha nullával szeretnénk osztani: például 30 % 0. Néhány nyelvben a maradékképzés csak egész számokra használható, ám Java nyelvben a művelet elvégezhető valós számokon is:

double szám;
szám = 30.0 % 4.1;
System.out.println(szám);
szám = 30.0 / 4.1;
System.out.println(szám);
szám = 7.0*4.1;
System.out.println(szám);
szám = 30.0 - szám;
System.out.println(szám);

Eredményül az alábbi számokat kapjuk:

1.3000000000000025
7.317073170731708
28.699999999999996
1.3000000000000043

...

Gyakori feladat, hogy egy változó értékét növeljük vagy csökkentsük egyel. Ez normál esetben így nézne ki:

int szám = 2;
szám = szám + 1;
System.out.println(szám);
szám = szám - 1;
System.out.println(szám);

Mivel ez a forma hosszú és összetett, a C nyelvből kölcsönzött ++ és -- operátort tudjuk használni, azonban ezek lehetnek prefix és postfix operátorok is:

int szám = 2;
System.out.println(szám++);
System.out.println(++szám);
System.out.println(szám--);
System.out.println(--szám);

Az eredmény:

2
4
4
2

Ami nem meglepő, hiszen az első esetben a kiírás után növekedett a változó értéke, a második esetben a kiírás előtt, aztán a harmadik esetben a kiírás után csökkentettük a változó értékét, majd pedig a kiírás előtt.

...

Két érték összehasonlítása relációs jelekkel történik, s eredményképpen boolean típust kapunk, amely lehet igaz vagy hamis. Szaladjunk gyorsan át ezeken a műveleteken:

int szám = 10;
int másikszám = 20;
System.out.println(szám < másikszám);
System.out.println(szám <= másikszám);
System.out.println(szám > másikszám);
System.out.println(szám >= másikszám);
System.out.println(szám == másikszám);
System.out.println(szám != másikszám);

...

A relációs műveletekkel nem tudjuk kifejezni azt az egyszerű matematikai képletet, hogy 4 < szám < 10, amely akkor igaz, ha a számértéke nagyobb, mint négy, és kisebb, mint tíz:

int szám = 10;
System.out.println(4 < szám < 10);

Ha mégis megpróbáljuk, akkor fordítási hibát kapunk eredményül (a fordítási hibákról később):

/home/work/JavaSuli/Kocsma/src/kocsma/Main.java:9: operator < cannot be applied to boolean,int  
    System.out.println(4 < szám < 10);

...

A megoldáshoz a matematikai képletet szét kell választanunk két részre: 4 < szám ÉS szám < 10, vagyis a szám értéke legyen nagyobb, mint négy és legyen kisebb, mint tíz:

int szám = 10;
System.out.println(4 < szám && szám < 10);

...

Ha két relációs művelet közül elég, ha az egyik teljesül, akkor össze tudjuk kapcsolni őket egy VAGYművelettel:

int szám = 4;
System.out.println(szám % 2 == 0);
System.out.println(szám % 3 == 0);
System.out.println(szám % 2 == 0 || szám % 3 == 0);

...

Sokszor előfordul, hogy a kiszámolt boolean eredmény ellentéte kell valamilyen okból kifolyólag, ekkor a NEM(más néven tagadás) műveletet kell használnunk:

boolean válasz = true;
System.out.println(!válasz);

...

Mivel számítógépeink egyelőre bitek alapján működnek, ezért célszerű beépíteni egy programnyelvbe a bitműveleteket. A bitműveletek alapja a kettes számrendszer, és minden primitív típus alapvetően kettes számrendszerben tárolt szám, ezért - a valós számokat leszámítva - értelmezhető rajtuk az összes bitművelet. Induljunk ki egy szép kerek számból, azaz nézzük meg, hogy a decimális 10 hogy néz ki kettes számrendszerben 8 biten:

00001010

Keressünk egy másik számot is, például nézzük meg a 57-es számot kettes számrendszerben, szintén 8 biten:

00111001

Ezzel a két számmal fogunk bitműveleteket végezni.

...

A balra léptetés során a bitek balra mozognak el, és jobb oldalon 0 értékek jönnek be, a bal oldalon kieső bitek pedig elvesznek:

int szám = 10;
System.out.println( Integer.toBinaryString( szám << 0 ));
System.out.println( Integer.toBinaryString( szám << 1 ));
System.out.println( Integer.toBinaryString( szám << 2 ));
System.out.println( Integer.toBinaryString( szám << 3 ));
System.out.println( Integer.toBinaryString( szám << 28 ));
System.out.println( Integer.toBinaryString( szám << 29 ));
System.out.println( Integer.toBinaryString( szám << 30 ));
System.out.println( Integer.toBinaryString( szám << 31 ));

Az eredmény magáért beszél, a bitek elkezdenek balra mozogni, jobb oldalon pedig 0 értékek jönnek be:

1010
10100
101000
1010000
10100000000000000000000000000000
1000000000000000000000000000000
10000000000000000000000000000000

...

A jobbra léptetés azonos módon működik, mint a balra léptetés:

int szám = 10;
System.out.println( Integer.toBinaryString( szám >>> 0 ));
System.out.println( Integer.toBinaryString( szám >>> 1 ));
System.out.println( Integer.toBinaryString( szám >>> 2 ));
System.out.println( Integer.toBinaryString( szám >>> 3 ));
System.out.println( Integer.toBinaryString( szám >>> 28 ));
System.out.println( Integer.toBinaryString( szám >>> 29 ));
System.out.println( Integer.toBinaryString( szám >>> 30 ));
System.out.println( Integer.toBinaryString( szám >>> 31 ));

Az eredmény itt is magáért beszél:

1010
101
10
1
0
0
0
0

Előjeles bitléptetés jobbra

A jobbra léptetés esetén létezik előjeles léptetés, amikor a bináris szám bal szélén nem 0 érték jön be, hanem az előjelbit ismétlődik:

int szám = -10;
System.out.println( Integer.toBinaryString( szám >> 0 ));
System.out.println( Integer.toBinaryString( szám >> 1 ));
System.out.println( Integer.toBinaryString( szám >> 2 ));
System.out.println( Integer.toBinaryString( szám >> 3 ));
System.out.println( Integer.toBinaryString( szám >> 28 ));
System.out.println( Integer.toBinaryString( szám >> 29 ));
System.out.println( Integer.toBinaryString( szám >> 30 ));
System.out.println( Integer.toBinaryString( szám >> 31 ));

Mint látható, bal oldalon alapból egy egyes érték van, és ezzel töltődik fel a bithalmaz:

11111111111111111111111111110110
11111111111111111111111111111011
11111111111111111111111111111101
11111111111111111111111111111110
11111111111111111111111111111111
11111111111111111111111111111111
11111111111111111111111111111111
11111111111111111111111111111111

...

Ha a kapott bitek mindegyikét negálni szeretnénk, akkor a ~ operátort kell használnunk:

byte szám = 10;
System.out.println(~szám);

...

A bitenkénti és művelethez már kettő operandus kell:

byte szám = 10;
byte másikSzám = 57;
System.out.println(szám & másikSzám);

Az eredmény 8 lesz, amelynek az oka, hogy a két számnak csak a negyedik pozícióban van azonosan 1 értéke:

00001010
00111001
00001000

...

A bitenkénti vagy művelethez is kettő operandus kell:

byte szám = 10;
byte másikSzám = 57;
System.out.println(szám | másikSzám);

Az eredmény 59, ami binárisan 00111011, mivel ott tartalmaz 1 értéket, ahol a megadott két operandusnál legalább egy darab 1 érték volt:

00001010
00111001
00111011

...

A kizáró vagy hasonlít a vagy művelethez, viszont csak akkor lesz az eredmény is 1 érték, ha a megadott két operandusban azonos pozíción csak egy 1 érték van:

byte szám = 10;
byte másikSzám = 57;
System.out.println(szám ^ másikSzám);

Amelynek eredménye 51, hiszen:

00001010
00111001
00110011

...

Gyakori eset, hogy egy változó értéke az előző értékéhez képest változik meg:

int szám = 10;
szám = szám + 2;
System.out.println(szám);

A változó = változó műveleti jel kifejezés további részejellegű kifejezéseket rövidíteni tudjuk:

int szám = 10;
szám += 2;
System.out.println(szám);

...

Ha egy eldöntendő kérdés alapján szeretnénk értéket adni egy változónak, akkor ezt a feltétles értékadással tudjuk megtenni. Nézzünk egy példát az abszolút érték képzésére:

int szám = -10;
szám = szám < 0 ? -szám : szám;
System.out.println(szám);

...

A + jel használható szövegek összefűzésére is, ekkor két kisebb szövegből egy nagyobb szöveg lesz:

String egy= "egy";
String kettő = "kettő";
String egykettő = egy + kettő;
System.out.println(egykettő.length());

...

Az összetett kifejezésektöbb operátorból és operandusból állnak, és a megszokott matematikai kiértékelési sorrend szerint kell írnunk a kívánalmainkat:

int szám = 1 + 2 + 3;
System.out.println(szám);

A kifejezés értéke 6 lesz, ahogy azt várjuk, a kifejezése kiértékelése során a számítógép pont úgy viselkedik, ahogy azt annak idején tanultuk: veszi az első két számot, összeadja őket, majd az eredményt és a harmadik számot újfent összeadja. Ebben az esetben nem számít a kiértékelés sorrendje, hiszen teljesen mindegy, hogy a számokat milyen sorrendben adjuk össze, ettől függetlenül a számítógép mindig balról-jobbra haladvavégzi el az egyes műveleteket. A kiértékelés sorrendje változhat a műveleti jelek függvényében, hiszen a szorzás előnyt élvez az összeadással szemben:

int szám = 1 + 2 * 3;
System.out.println(szám);

 A számítógép először a szorzás műveletét végzi el, majd a kapott eredményhez hozzáad egyet, így a végső eredmény 7lesz. Zárójelezéssel ez a kiértékelési sorrend felülbírálható:

int szám = (1 + 2) * 3;
System.out.println(szám);

Ebben az esetben a számítógép először a zárójelben lévő műveletet végzi el, majd a kapott eredményt megszorozza hárommal, így kapjuk meg az eredményt, ami 9.

3.4.1. Precedencia - kiértékelési sorrend

...

A prefix (++szám vagy ++szám) és a postfix (szám++ vagy szám--) operátorok használata mindig kockázatos, mivel a kifejezés kiértékelés során változik a változó értéke, vessünk egy pillantást az alábbi programrészletre és próbáljuk meghatározni az eredményt:

int szám = 10;
System.out.println(szám++ + ++szám * ++szám + szám++);

Nos, az eredmény 179, mégpedig azért, mert az unáris operátorok az elsők a precedencia táblázatban, és kiértékelésük az elsők között történik, ebből adódóan a kifejezés a következő lesz az unáris operátorok feloldása után:

System.out.println(10 + 12 * 13 + 13);

...

{
}

int i = 10;
{
  int j = 10;
}
System.out.println(j);

int j = 10;
{
  int i = 10;
  System.out.println(i);
  System.out.println(j);
}
{
  int i = 20;
  System.out.println(i);
  System.out.println(j);
}
System.out.println(j);