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
Most pedig a deklarációkat(létrehozásukat):
[ezeknek a megadása nem kötelező]
[, ... több is megadható vesszővel elválasztva]

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...