A Java jellemzi Hordozhat platformfggetlen n forrskd s

A Java jellemzői Hordozható, platformfüggetlen n forráskód és bájtkód szinten Tisztán objektumorientált n csak osztályok, illetve objektumok léteznek Szabványos osztálykönyvtár Szintaktikája a C++ -on alapszik.

A Java nyelv alapjai Egyszerű típusok egyszerű típus boolean char byte short int long float double osztály leírás Boolean logikai típus (true, false) Character 16 bites Unicode karakter Integer 8 bites egész szám (-128 - +127) Integer 16 bit, (-32 768 - +32 767) Integer 32 bit (-2 147 483 648 - +2 147 483 647) Long 64 bit (-9 223 372 036 854 775 808 - +. . . ) Float 32 bit (-3, 40292347 E+38 - +3, 40292347 E+38) Double 64 bit (-1, 79769313486231570 E+308 - +. . . ) a szabvány rögzíti az ábrázolási módot és a méretet, nem az implementáció hagyományos típusként és osztályként is használhatók osztályként a MIN_VALUE és a MAX_VALUE konstansok definiálják a határokat a Float és Double esetén van egy POSITIVE_INFINITY, NEGATIVE_INFINITY és egy Na. N (Not a Number) konstans is.

Literálok Logikai értékek: true, false Egész számok: n 0 kezdetű számok oktális (8 -as számrendszer), pl. 0377 n 0 x kezdetű számok hexadecimális (16 -os számrendszer), pl. 0 xff n minden más szám decimális számrendszerben lesz értelmezve, pl. 255 n egy egész szám után írt l vagy L betű long típust deklarál Lebegőpontos számok: n decimális számként adhatók meg tizedesponttal és e vagy E exponenssel n ez önmagában double típust jelent, f vagy F végződéssel lehet float típust deklarálni, pl. 3. 14, -123. 45, 12. 3 e 4 Karakterek: aposztrófok között kell megadni, pl. 'a', 'Z' n escape szekvenciák, mint a C nyelvben, lásd a következő oldalon! Szövegek (String): idézőjelek között kell megadni, pl. “Helló Világ”

Escape szekvenciák Kód Leírás n újsor t tabulátor b egy karakter vissza, törlés r “kocsi” vissza, soremelés nélkül f lapdobás \ karakter ' ' karakter, aposztróf ” “ karakter, idézőjel

Tömbök A C/C++ nyelvvel ellentétben ez igazi típus, nem pointer A tömbök indexelése 0 -val kezdődik Tömb deklarációja a [] jellel történik a típus vagy a változó neve után: int[] Egesz. Tomb, tomb; // mindkettő tömb int egeszszam, tomb[]; // skalár és tömb n ez egy tetszőleges méretű tömböt deklarál, amit a new operátorral fogunk létrehozni: tomb = new int[20]; A tömb ismeri a saját méretét, amit a length mezővel le is lehet kérdezni. System. out. println(tomb. length); Indexeléskor a tömb ellenőrzi az indexet, hiba esetén Index. Out. Of. Bounds. Exception kivétel váltódik ki.

Többdimenziós tömbök Nincsen többdimenziós tömb, de egy tömbnek lehetnek tömb elemei, akár különböző méretűek is. Például: int[][] tomb = new int[3][]; // 3 tömbből álló tömb for (int i = 0; i < tomb. length; i++) { tomb[i] = new int[i+1]; for (int j=0; j < tomb[i]. length; j++) tomb[i][j] = 0; }

Példa többdimenziós tömbre public class tomb { public static void main(String[] args) { int[][] tomb = new int[10][]; // 10 tömbből álló tömb int szamlalo = 9; for (int i = 0; i < tomb. length; i++) { tomb[i] = new int[i+1]; for (int j = 0; j < tomb[i]. length; j++) tomb[i][j] = ++szamlalo; } for (int i = 0; i < tomb. length; i++) { for (int j = 0; j < tomb[i]. length; j++) System. out. print( tomb[i][j] + " " ); System. out. println( ); } } }

Operátorok +, -, *, /, % +, -, *, /, maradék ++, -prefix és postfix formában +, - előjel >, >=, <, <=, ==, != relációs operátorok &&, || logikai ÉS, VAGY, a második operandust csak szükség esetén értékeli ki &, | logikai ÉS, VAGY, mindkét operandust mindig kiértékeli ! logikai NEM ^ logikai kizáró VAGY, (XOR) <<, >> bitenkénti léptetés balra, jobbra (előjelbittel) >>> bitenkénti léptetés jobbra (0 lép be) &, |, ^, ! bitenkénti ÉS, VAGY, Kizáró VAGY, NEM =, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>>=

String osztály Konstans sztringek kezelésére szolgál. Egyszeri értékadás után nem lehet módosítani. String objektum létrehozása, különböző konstruktorokkal: n Explicit konstruktor hívással: String s 1 = new String(); String s 2 = new String("Ez " + 1 + " sztring!"); n Implicit konstruktor hívással: String s 1 = „NYF"; String s 2 = s 1 + " MAT. INT " + 2007; n Karaktertömbből: char[] String karaktertomb = {‘N', ‘y', ‘F'}; s 3 = new String(karaktertomb); //„Ny. F" s 4 = new String(karaktertomb, 1, 2); //„y. F"

String osztály - Konverziók String. value. Of metódus: n boolean, char, double, float, int, long típusoknál értelemszerűen n Például: boolean log = false; char ch = 'X'; double pi = 3. 14; String s 5 = String. value. Of(log) + String. value. Of(ch) + String. value. Of(pi); // s 5 = "false. X 3. 14"

String osztály A tartalom elérése Egy karakter elérése: char. At metódus char ch = s 3. char. At(2); // ch ch 2 = „Ny. F". char. At(0); // ch 2 = = ‘F' (s 3=„Ny. F") ‘ N' Két sztring összehasonlítása: equals, equals. Ignore. Case metódus boolean b 1 = "alma". equals("ALMA"); boolean b 2 = "alma". equals. Ignore. Case("ALMA"); // false // true Az == a referenciákat hasonlítja össze, nem a tartalmat! Két sztring lexikografikus sorrendje: compare. To metódus 0 ha a két sztring azonos negatív ha az aktuális példány a kisebb pozitív ha az aktuális példány a nagyobb n int i = "Gyár". compare. To("Győr"); // i = -2 (lehetne!) n de az abszolút érték nem definiált (+0, -0)!

String osztály Keresés Karakter vagy sztring keresése: index. Of metódus int index 1 = int index 2 = // a 2. int index 3 = int index 4 = 1 "kukuriku". index. Of('u'); "kukuriku". index. Of('u', 2); indexű elemtől indul a keresés "kukuriku". index. Of("ku"); "kukuriku". index. Of("ka"); // 1 // 3 // 0 // - Keresés hátulról: last. Index. Of metódus int index 5 = "kukuriku". last. Index. Of("ku"); // 6 Így kezdődik-e a sztring: starts. With metódus boolean start = "file. java". starts. With("fi"); // true Így végződik-e a sztring: ends. With metódus boolean vege = "file. java". ends. With(". jav"); false //

String osztály Egyéb műveletek A sztring hossza: length metódus int len = „Nyíregyháza". length(); // len = 11 Kis-, nagybetű váltás: to. Lower. Case, to. Upper. Case metódus String vegyes = "Kicsi És n. Ag. Yb. EtŰk Vegyesen"; kicsi = vegyes. to. Lower. Case(); nagy = vegyes. to. Upper. Case(); Betűcsere: replace metódus Részsztring: substring metódus (tól, ig, az ig. karakter már nem lesz benne) String kacsa = kicsi. substring(0, 5). replace('i', 'a'); Vezető és záró white space-ek eltávolítása: trim metódus String s = " abcd "; String lenyeg = s. trim(); // lenyeg = "abcd" A kiinduló sztring ezekkel a metódusokkal sem változik meg!

Változók A változó deklaráció formája: n [módosítók] típus változó [inicializáció] vesszővel felsorolhatunk több változót is Fontos módosítók: n final: konstanst hoz létre értékadással nem változtatható meg beállítása: inicializáció helyben, konstruktorok, inicializáló blokk n n static: osztályváltozó Hozzáférés: public, protected, private, üres egyetlen példányban létezik az osztályban Változók használata n n önmagában minősített hivatkozás: (objektum v. osztály). változó

Metódusok A metódus definíció formája: n [módosítók] típus Név([paraméterek]) {törzs} Fontos módosítók: n Hozzáférés: public, protected, private, üres Metódusok használata n n önmagában minősített hivatkozás: (objektum v. osztály). metódus A metódusnevek túlterhelhetők, a szignatúra egyedi n n szignatúra: név + paraméterek típusa, száma a metódus neve megegyezhet egy változóéval is!

Egy egyszerű osztály public class Auto 1 { private String rendszam; private String tipus; private int ajtoszam; private int hengerszam; private int ev; private int suly; private int kilometer; private float fogyasztas; // folytatás a következő dián

Egy egyszerű osztály, folyt. // folytatás az előző diáról public Auto 1() { rendszam = ""; tipus = ""; ajtoszam = hengerszam = ev = suly = kilometer = 0; fogyasztas = 0. 0 f; } // folytatás a következő dián

Egy egyszerű osztály, folyt. // folytatás az előző diáról public void ajtoszam( int a ) { ajtoszam = a; } public int ajtoszam() { return ajtoszam; } public void hengerszam( int h ) { hengerszam = h; } public int hengerszam() { return hengerszam; } } // az osztály vége

Az osztály használata public class Auto. Test { public static void main( String[] args ) { Auto 1 kocsi = new Auto 1(); kocsi. ajtoszam( 5 ); kocsi. hengerszam ( 4 ); System. out. println( "kocsi. ajtoszam: " + kocsi. ajtoszam() ); System. out. println( "kocsi. hengerszam: " + kocsi. hengerszam() ); } }

Konstruktorok A konstruktor a példányosításkor automatikusan lefutó programkód. Miben különbözik a metódusoktól? n neve megegyezik az osztály nevével n nincs visszatérési érték, void sincs! n módosítóként csak a hozzáférés módosítók használhatók Több konstruktort is definiálhatunk különböző szignatúrával Ha nem definiálunk konstruktort, akkor a fordító létrehoz egyet, ami public, paraméter nélküli és a törzse üres. A this kulcsszóval hivatkozhatunk az aktuális példányra. Így elérhetjük az elfedett változó neveket, és más konstruktorokat is.

Az Auto osztály újra public class Auto 2 { String rendszam; String tipus; int ajtoszam; int hengerszam; int ev; int suly; int kilometer; float fogyasztas; // folytatás a következő dián

Az Auto 2 konstruktorai 1 public Auto 2( String rendszam, String tipus, int ajtoszam, int hengerszam, int ev, int suly, int kilometer, float fogyasztas) { this. rendszam = rendszam; this. tipus = tipus; this. ajtoszam = ajtoszam; this. hengerszam = hengerszam; this. ev = ev; this. suly = suly; this. kilometer = kilometer; this. fogyasztas = fogyasztas; }

Az Auto 2 konstruktorai 2 public Auto 2() { this( "", 0, 0, 0, 0. 0 f ); } public Auto 2( String rendszam, String tipus) { this( rendszam, tipus, 0, 0, 0. 0 f ); }