Tanulj Java-t!

1. Lecke - Telepítés, alapozás

Elsőnek is be kell szereznünk a Java SDK J2SE aktuális változatát erről a webcímről: http://java.sun.com/j2se/ Válasszuk ki a gépünknek megfelelő változatot (SDK-t!) és a teljest töltsük le! Az online telepítős mérete kisebb, de nevéből adódóan a netről fogja telepítés közben letölteni a szükséges adatokat. Telepítsük a letöltött SDK-t, majd a letöltött Free Java-t tömörítsük ki például a gyökérkönyvtárba. (A zip fájl már tartalmaz egy FreeJava könyvtárt is) A könnyebb használhatóság kedvéért létrehozhatunk egy parancsikont is, ehhez kattintsunk a jobb egérgombbal a C:\FreeJava könyvtárban lévő FreeJava.jar (vagy FreeJavaJar.bat ha látni akarjuk, hogy működése során mit ír ki a Free Java a konzolra) fájlon az intézőben, és válasszuk a küldés menü Asztal (parancsikon létrehozása) menüpontját. Ha a Free Java nem indulna el, akkor ellenőrizzük, hogy a parancsikon "Kezdet" nevű mezője ki van -e töltve és ha nem, akkor írjuk oda ezt be: C:\FreeJava\

Induláskor a program feldobhat egy figyelmeztetést, ha másmilyen operációs rendszert, vagy más JRE-vel futtatjuk, mint amivel fejlesztve lett. Vegyük ki a pipát az ablak alján, hogy később már ne figyelmeztessen, majd kattintsunk a "Megértettem" gombra. Ezután betöltődik a program, majd a segítség ablaka is. Ezt érdemes átböngészni, mert leírja a Free Java használatát és működését így ezeket most, nem fogom még egyszer megtenni, és ennek a tanfolyamnak nem is ez az elsődleges célja. Induláskor a program létrehozta a C:\javaprog nevű könyvtárat, és a tartalmát meg is, jeleníti a fájlböngészőben. (Erről bővebben Segítség / Fő ablak felépítése / Fájlböngésző) Érdemes munkakönyvtárnak ezt hagyni, ide fognak kerülni majd az elkészítendő Java programjaink.

Viszont elsőnek meg kell mondani a Free Java-nak, hogy hol található a feltelepített SDK. Ehhez válasszuk ki a Beállítások / JDK Beállítások menüpontot, majd a "Mind Beállít" nyomógombot. A feljövő fájlkiválasztó dialógus ablakban pedig válasszuk ki azt a könyvtárat ahová az SDK-t telepítettük
(PL.: C:\j2sdk1.4.2) majd nyomjuk meg a "Set" gombot, majd az "Ok" gombot is.

Hozzunk létre egy új fájlt a Fájl menü Új fájl létrehozása menüpontjával. Válasszuk ki az osztályminták közül a Main.java-t majd az Új fájl nevéhez írjuk be, hogy Proba (ez lesz egyben a Programunk neve is, ezért mindig nagy kezdőbetűvel kell kezdeni). Majd kattintsunk a "Létrehozás" gombra és a mintafájlból elkészül az első Java programunk, ami egyből betöltődik a szövegszerkesztőbe. Egyenlőre elégedjünk meg annyival, hogy ez egy Java program ami a System.out.println(""); paracs hatására a két "idézőjel" közötti szöveget kiírja a kimenetre (konzolra). Próbáljuk ki! Módosítsuk a fenti parancsot valahogy így: System.out.println("Ezt írja ki a programom."); Fordítsuk és futtassuk a programot egyszerre a Futtatás menü javac + java "Proba.java" menüpontjával vagy üssük le az F8-as funkcióbillentyűt. A fordítás hatására létrejön egy Proba.class nevű bytekód amit már bármilyen JVM (Java virtuális gép, akár Linux-on) tud futtatni. Fel is jön alul a programok kimenetét tároló üzenet panel, amin az előbbi módosítás hatására a következő üzenetet olvashatjuk el:

>>C:\j2sdk1.4.2\bin\java.exe Proba >>CLASSPATH=.;C:\javalib; Ezt írja ki a programom. >>0

Amiben minden >> jellel kezdődő sort a Free Java ír bele, az első az a parancs amit ha kiadnánk az adott operációs rendszer konzolján, akkor szintén ezt a hatást érnénk el (futtatnánk a programot). A másodikban látható a CLASSPATH környezeti változó, majd a legutolsó sorban a program visszatérési értéke. (0 jelenti a sikeres program lefutást) A CLASSPATH-ról csak annyit, hogy kezdőként nem nagyon lesz rá szükségünk, csak ha külső (nem a Java saját) előre elkészített osztályokat akarunk használni a programunkban.

Ez eddig szép mondhatnánk, de még mindig semmit sem tudunk a Java nyelv szintaxisáról, vagyis arról, hogy milyen szabályokat betartva kell megírnunk a programunkat.

Első a külalak. A példaprogramban is jól látható, hogy az egyes {blokkal} közrezárt részekben a további szövegek beljebb kezdődnek, ez jelen esetben két szóközt jelent. (a tabulátor leütése is szóközök beszúrását jelenti).

Másodikként ismerkedjünk meg a megjegyzésekkel, ezeket a Java fordító nem értelmezi, vagyis így bármilyen szöveget hozzáfűzhetünk a programunkhoz:

• a két // karakter azt jelenti, hogy az utána következő szöveg a sor végéig megjegyzés
• a /* jel pár elindítja és a */ lezárja a megjegyzést, így az több soros is lehet
• van még egy hasonló Java kóddokumentáló /** megjegyzés */ ezek a megjegyzések bekerülnek a program dokumentációjába.

Most pedig vegyük át a Java lényegét. A Java objektum orientált programozási nyelv, vagyis mindig objektumokban kell gondolkodnunk, egy objektumot PL.: téglatest(annak leírását) osztállyal adhatjuk meg. Na igen, amit most leírok, nem biztos, hogy mindenkinek tetszeni fog, de talán könnyebb lesz az elején így megtanulni: Az osztály, amit voltaképp megírunk egy objektum, vagyis az lesz, amikor már futtatni fogjuk.

Ez alól csak az osztályszintű (static) láthatósággal rendelkező változók, metódusok a kivételek, mert ezek az objektum létrehozása nélkül is elérhetőek.

Vegyük át a most fontos módosítókat:

• static - osztály szintre emeli az utána következő elemet
• public - publikus, mindenki számára elérhetővé teszi az utána következő elemet
• protected - védi, csak az osztály közvetlen őse számára látható
• private - letiltja, az osztályon kívül más nem látja ezt az elemet
• (ha semmit nem írunk be) - package / csomagszintű lesz, az egy csomagban (könyvtárban) lévő osztályok (objektumok) számára látható lesz

Osztály:

[módosítók] class Név [extends származtatott.osztály] [implements megvalósított.interfészek [, ...]] { }

Példa:

import javax.swing.*; // javax.swing osztálykönyvtár hozzáadása a programunkhoz /** Az osztály neve és, hogy miből származtatjuk. A JFrame valósítja meg Java-ban az ablakot. */ public class Elso extends JFrame { /* A program belépési pontja.*/ public static void main(String[] args) { new Elso(); // létrehozunk egy objektumot az osztályból } /** Az objektum konstruktora, inicializálása, alaphelyzetbe hozása. Meg kell egyezzen az osztály nevével, valamint nem kell megadni visszatérési értéket, mert az maga a létrejövő Elso objektum lesz. */ public Elso(){ setVisible(true); // láthatóvá teszi az ablakot } }

Interfész:

[módosítók] interface Név [extends származtatott.interfészek [, ...]] { }

Példa:

interface Programozas { // az interfész neve /** Egy metódus minta, amit minden olyan osztálynak, ami implementálja ezt az interfészt, meg kell valósítania. */ public void programIras(); }

Változó:

[módosítók] típus név [, ...] ;
Változó típusok:
Egész számok, mind lehet negatív előjeles is:
byte 8bit, short 16bit, int 32bit, long 64bit

byte bajt; int intSzam, masodikInt; long nagySzam=12345;

Valós számok:
float 32bit, double 64bit

double valos=123.22;

Karakter:
char 16bit

char c='g', karakter='\u0906';

Logikai:
boolean (igaz vagy hamis)

boolean igaz=true, hamis=false;

Objektumok:
Referencia típusú mutató, ami lehet null is - ez jelenti, hogy nem mutat sehová.

JFrame Ablak=new JFrame();

Sztring, szöveg:
Java-ban a szövegek objektumok, viszont a Java ad némi könnyítést a használatához.

String szoveg="Ez a szöveg egy objektum, ezért nincs korlátozva méretileg."; String text=szoveg+" Így kapcsolhatunk össze két szöveget."; text=text+" Vagy bármit "+karakter+valos;

Tömbök:
Mindegyik típusból lehet tömböt is csinálni, csupán a deklarációnál a típus után vagy a név után egy [] jelet kell elhelyezni. Mivel a tömb is egy objektum ezért hasonlóan kell kezelni, de itt is vannak könnyítések.

String[] szovegek={"a tömb első eleme","a második"};

Az egyes elemeket indexeléssel lehet elérni, az index 0-tól kezdődik. A tömb nagyságát magától a tömbtől lehet megkérdezni a szovegek.length; mezővel.
Példa:

System.out.println("a tömb első eleme: "+szovegek[0]); System.out.println("a tömb összesen "+szovegek.length+" elemet tartalmaz");

Metódus:

[módosítók] visszatérési.típus Név([paraméter.változó.típus neve [, ...]]) { [return visszatérési.érték]<> }

Az objektumokat metódusokon keresztül szólíthatjuk meg, a metódusokon keresztül lehetőség van változók (akár objektumok) átadására, amivel a metódus dolgozhat. A metódus lefutása után visszaadhat egy visszatérési értéket, ha ilyen nincs akkor a metódusnak a fejrészében a visszatérési típust void -nak kell deklarálni.

Példa: privát visszatérési érték nélküli, egy paraméteres metódus

private void konzolraIr(String szoveg){ System.out.println(szoveg); }

A metódus egy lehetséges meghívása:
Azt azért vegyük figyelembe, hogyha a main metódusból akarjuk meghívni, akkor a metódusokat emeljük osztály szintre a static módosítóval.

konzolraIr("Ez most látható a konzolon.");

2 Példa: csomagszintű egész szám visszatérési értékű, több paraméteres metódus

int osszead(int a, int b){ int c; c=a+b; return c; }

A metódus egy lehetséges meghívása:

int eredmeny; eredmeny=osszead(12,8); System.out.println(eredmeny);

Vagy

System.out.println(osszead(12,8));

Vagy kombinálva az előző metódussal

konzolraIr(""+osszead(12,8));

Itt megfigyelhetjük azt is, hogyan alakíthatunk számot Sztringé, de talán elegánsabb ha külön metódust írunk erre, valahogy így:

private void konzolraIr(int szam){ System.out.println(szam); }

Mindjárt felvetődik sokakban a kérdés, hogyan lehet egy programban ugyanazon névvel több metódus is. A válasz egyszerű: Java-ban a metódust nem (csak) a neve azonosítja, hanem az egész fejrésze visszatérési értéke, paramétere összesítve.

Tekintsük ezeket építőkockáknak, amikből össze lehet rakni egy programot. Van néhány szabály, ami viszont kötött:

• az osztályok neveit mindig Nagy kezdőbetűvel kezdjük
• egy fájl csak egy publikus osztályt tartalmazhat, aminek a Neve meg kell egyezzen a fájl nevével
• a program belépési (indulási) pontja minden esetben a public static void main(String[] args) { } nevű metódus
• a változók neveit mindig kis kezdőbetűvel írjuk

Ha mindezeket megemésztettük, akkor tekintsük át ennek az egésznek a működési filozófiáját.
Elsőnek is ahhoz, hogy használhassunk egy már létező osztályt, hozzáférhetővé kell azt tenni a programunk számára, vagyis importálni kell azt. Itt megjegyzem, hogy a Java alapjait tartalmazó osztály könyvtárat (java.lang) nem kell importálni, mert azt ettől függetlenül megteszi helyettünk a Java fordító. Ugyan ez vonatkozik az osztályok származtatására is, vagyis ha nem örökítjük semmiből egy adott osztályt, akkor az automatikusan a [java.lang.]Object osztályból fog származni.

És ez az egésznek az alapja, ha egy osztályunkat leörökítjük például a JFrame- ből, akkor onnéttól fogva rendelkezünk minden tulajdonságával, metódusai segítségével beállíthatjuk, illetve lekérdezhetjük aktuális állapotát. Tehát azt is mondhatnám, hogy ha Java-ban programot akarunk írni, akkor elsőnek a Java által biztosított (vagyis előre elkészített, megírt) osztályokkal, program építő elemekkel, kell tisztában lennünk, a többi csak ez után következik.

De egy kicsit előre szaladtunk, már remélhetőleg körvonalozódig, hogy miként is működik a Java, de konkrétan a vezérlési elemeket még nem ismerjük.

Ezt a következő leckében fogjuk átnézni...