Java alapok

Első teendők

1. Java JDK telepítése saját számítógépre.
2. Fejlesztőkörnyezet telepítése saját számítógépre. Otthon bárki bármit használhat, a kabinetben azonban nincs fent a világ összes fejlesztőkörnyezete, így célszerű otthon is olyat használni, ami a kabinetben is rendelkezésre áll. Mi az IntelliJ IDEA-t ajánljuk.
3. Bíró regisztráció (mindkét Bírón)

Figyelem!

A Bíróhoz való belépés ellenőrzése, szükség esetén a problémák megoldása. Aki nem tette volna meg korábban, az regisztráljon a Bíróba ezen és ezen a linkeken. Mindkettőn! Ha valaki nem biztos abban, hogy már regisztrált, az inkább regisztráljon újra. A Bíróba történő regisztráció nem volt szükséges a Programozás alapjai gyakorlat teljesítéshez!

A Java használatával, telepítésével kapcsolatos, gyakori problémák és megoldásuk angol nyelven. Ha valakinek ezektől eltérő problémája van, az keresse meg a gyakorlatvezetőjét e-mailben, vagy pedig az összevont színtér kurzusfórumán jelezze a problémát.

Videók

A gyakorlatok anyagát megpróbáljuk színesíteni és érthetőbbé tenni azzal, hogy mindaz, ami itt elolvasható, gyakorlatban is látható legyen egy-két példán keresztül, akár több gyakorlatvezető interpretálásában. Természetesen ezek nem helyettesítik az órára járást (a gyakorlatok látogatása kötelező), de segíthet egy-egy téma jobb megértését, illetve betegség esetén is nagy segítség lehet.

• Üdvözlünk a kurzuson: https://youtu.be/dwpRekuonHM.
• Hogy valójában miről is szól a kurzus? Első ránézésre a Java nyelvről, de sokkal inkább az objektumokról, objektumorientált gondolkodásról: https://youtube.com/playlist?list=PLGlj9VbLRrjBoIrYBE410Y3DjzYd-x8EI.

Java nyelvről röviden

• Az Oracle angol nyelvű bevezetője.
• Platformfüggetlen programozási nyelv.
• JVM: Java Virtual Machine - Java virtuális gép
  • A Java virtuális gép minden architektúrán különbözik
• Bájtkód: Egy olyan bájtsorozat, amely a JVM által végrehajtható utasításokat tartalmaz.
• JIT (Just In Time) - Futás idejű "fordítás".
• a nyelv felépítésének koncepciója
• a C-vel ellentétben a Java forrásfájlok tartalmazhatnak Unicode, pl.: UTF-8 karaktereket is

A kép forrása, ahol bővebben olvashatsz a Java virtuális gép működéséről.

JRE/JDK

Ahhoz, hogy Java programokat tudjunk futtatni, illetve fejleszteni, szükségünk lesz egy fordító- és futtatókörnyezetre, valamint egy fordítóprogramra. A kész programunk futtatásához mindösszesen a JRE (Java Runtime Environment) szükséges, ami biztosítja a Java alkalmazások futtatásának minimális követelményeit, mint például a JVM (Java Virtual Machine) vagy például a böngészők számára a Java beépülő modult és a Java Web Startot is.

Azonban a fejlesztéshez szükségünk lesz a JDK-ra (Java Development Kit) is. Ez tartalmazza a Java alkalmazások futtatásához, valamint azok készítéséhez, fordításához szükséges programozói eszközöket is (tehát a JRE-t nem kell külön letölteni, a JDK tartalmazza). A jelenleg elérhető legfrissebb Java disztribúciók már nem kínálnak külön letölthető JRE és JDK csomagokat, ezeket együttesen tudjuk letölteni. A Java beszerzéséről és telepítéséről itt írtunk bővebben.

Első Java nyelvű programunk

A kapcsolódó Oracle oldal.

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!"); //Kiírja, hogy Hello World!
    }
}

Láthatjuk, hogy a main függvény visszatérési értéke void. Ez C-ben egy int volt, amely a program lefutásának helyességéről árulkodott. Javaban a hibakezelés teljesen más koncepción alapul, amit a későbbi órákon részletesen ismertetünk. A main függvény paramétere itt egy String típusokból álló tömb (kicsit hasonlít a C-hez).

A Java-beli szöveges típusról később lesz bővebben szó, de szerencsére itt már nem karaktömbökkel kell dolgoznunk.

Fordítás, futtatás

Az elkészült fájlt mentsük el HelloWorld.java néven. Fontos, hogy mindig olyan néven mentsük el a fájlt, ami a publikus osztályunk neve (ami a public class után van).

Fordítás

Most már csak maga a fordítás, majd futtatás van hátra. Az elkészült programokat a parancssorból a javac paranccsal fordíthatjuk le (ami a telepített Java fordító binárisa), a következőképp: javac FájlNeve.java, jelen esetben javac HelloWorld.java. (A Java fordítóról, kapcsolóiról bővebben olvashatsz ezen az oldalon). Normál esetben a parancs kiadása után semmilyen válasz sem érkezik, csak visszakapjuk a kurzort egy idő után.

A fordítás befejezése után látnunk kell a HelloWorld.java fájl mellett egy HelloWorld.class nevű fájlt is, ami a fordítás után jött létre. Ez a fájl tartalmazza az elkészült Java bájtkódot, amelyet aztán hordozhatunk, és bármely gépen futtathatjuk, ahol van egy Java virtuális gép (azaz a célszámítógépen telepítve van a JDK).

Futtatás

Az elkészült alkalmazás futtatása a java paranccsal történik, melynek használata a következő: java OsztalyNeve arg1 arg2 arg3 ... argN, jelen esetben java HelloWorld. Fontos, hogy a HelloWorld után nem szerepel a .class kiterjesztés, a JRE automatikusan odateszi. A parancs hatására a JRE megkeresi a megadott osztályt a fájlrendszeren, majd miután betöltötte, a benne található main() metódust kezdi el futtatni. Ha nem találja meg a fájlt, vagy nincs benne main, hibával fog kilépni.

Megjegyzés

A fordítás után elkészült .class kiterjesztésű fájlba belenézhetünk a JDK-ban szereplő javap paranccsal, vagy akár vissza is fejthetjük őket, így a C-vel ellentétben (ahol a fordítás végső eredménye egy bináris fájl), itt erre is figyelnünk kell a későbbiekben.

Normál esetben a program futtatása után megjelenik a konzolon a "Hello World!" szöveg.

Kiíratás, beolvasás

Alapértelmezett kimenetek

Ahogy láthattuk, a Java nyelvben szöveget írhatunk ki a képernyőre a System.out.println() paranccsal. Ez viszont nem feltétlenül mindig a terminált jelenti. A System.out az alapértelmezett kimenet, ami esetünkben a terminálra volt irányítva. Ezt természetesen át is lehet állítani, hogy máshova írjunk vele, például egy fájlba.

A kiíratáshoz több függvény is rendelkezésünkre áll:

System.out.print("Ez egy szoveg");
System.out.println("Ez egy szoveg!");
System.out.printf("Ez %d C-bol ismeros kiiratas\n", 1);
System.out.format("Ez %d C-bol ismeros kiiratas\n", 1);

Kimenet

Ez egy szovegEz egy szoveg!

Ez 1 C-bol ismeros kiiratas

Ez 1 C-bol ismeros kiiratas

A System.out.print és a System.out.println között annyi a különbség, hogy az első nem tesz sortörést a kiíratás végére, míg a println-es változat igen. A sortörő karakter mindig az adott platform sortörő karaktere, sosem egy beégetett karakter, így a legtöbb, sortörést tartalmazó kiíratásnál célszerű ennek használata.

Az alsó kettő kiíratás pedig a C-ből is ismerős formázós kiíratás, Javaban általában nem ezeket használjuk.

A beégetett \n, \r\n karakterek használatát pedig lehetőség szerint mellőzzük, hiszen így a platformfüggetlenség sérülhet. Egy üres sortörés kiíratásához a legegyszerűbb a System.out.println(); utasítást használni. Ha mindenáron szeretnénk használni egy kiíratáson belül sortörtést, akkor a sortörő karakter helyett a System.lineSeparator() utasítással kérhetünk egy adott platformra megfelelő sortörő karaktert.

System.out.printf("Ez %d C-bol ismeros kiiratas" + System.lineSeparator(), 1);

Az eddig tanult kiíratáshoz hasonló az alapértelmezett (vagy default) hibakimenet, melynek fogalma szintén ismerős lehet. Ez Javaban a System.err, amire a már látott módon írhatunk ki. Ez hibaüzenetek közlésére szolgál. Használata teljesen megegyezik a System.out használatával, egyetlen szemmel látható különbsége, hogy a fejlesztőkörnyezet belső konzolján a System.err-re kiírt szöveg pirossal jelenik meg.

Az egyszerű terminál használatakor ez az alapértelmezett kimenet és hibakimenet megegyezik, így mindkét kimenetet a konzolon látjuk. A két kimenet viszont lehet két különböző helyre is irányítva.

A két kimenet egymáshoz képesti működése aszinkron. Ez azt jelenti, hogy nem feltétlenül pont akkor írja ki a dolgokat, amikor mi utasítjuk rá: ha az alapértelmezett kimenet éppen nem tudja ellátni a feladatát, akkor a kiírandó adat várakozik; miközben lehet, hogy az alapértelmezett hibakemenet szabad, így kódsor szinten hiába írtunk ki előbb az alapértelmezett kimenetre, majd pedig a hibakimenetre, lehet hogy a konzolon előbb jelenik meg az, amit a hibakimenetre írtunk. Tehát a következő kódnak két lehetséges kimenetele lehet:

System.out.println("Most hibaüzenet következik:");
System.err.println("Ez a hibaüzenet.");

Az egyik kimenetel:

Kimenet

Most hibaüzenet következik:

Ez a hibaüzenet.

A másik pedig:

Kimenet

Ez a hibaüzenet.

Most hibaüzenet következik:

Ebből következik, hogy a hibakimenet NEM használható a szöveg egyszerű színezésére, mert összekavarodhat a mondanivalónk. Attól persze nem kell félni, hogy a System.out-ra küldött két üzenet összekeveredik, ezek sorrendben várakoznak.

A gyorsabb munka érdekében az IntelliJ IDEA és az Eclipse is megkönnyíti a kimenetre írást.

• IntelliJ IDEA: A default kimenet eléréséhez egyszerűen beírhatjuk a sout szót, majd Ctrl+Space hatására kiegészíthetjük System.out.println()-né, a serr szót pedig System.err.println()-né.
• Eclipse: A default kimenet eléréséhez egyszerűen beírhatjuk a sysout szót, majd Ctrl+Space hatására kiegészíthetjük System.out.println()-né, a syserr szót pedig System.err.println()-né.

Beolvasás az alapértelmezett inputról

Az alábbiakban bemutatjuk, hogy hogy lehet az alapértelmezett bemenetről beolvasni egy szöveget, számot. Ennek célja, hogy az olvasó elkezdhessen interaktív alkalmazásokat készíteni. Nem célunk, hogy minden részletet megismertessünk, elmagyarázzunk, a részletes ismertetése ennek egyik későbbi gyakorlaton lesz.

import java.util.Scanner;

public class Beolvasas {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Hello! Hogy hívnak?");
        String nev = sc.nextLine();
        System.out.println("Hello " + nev + "! Hany eves vagy?");
        int kor = sc.nextInt();
        System.out.println("Hello " + nev + ", aki " + kor + " eves.");
    }
}

Fejlesztői környezetek

Az IDE (Integrated Development Environment, integrált fejlesztői környezet) célja, hogy megkönnyítse a programozást. Rengeteget segít a munkánkban, többek között tudja a korábbról ismert szintaxis-színezést, támogatja a hibakeresést, vagy például egy gombnyomással elindíthatjuk a fordítást, futtatást is.

Számos fejlesztői környezet létezik, mint például az IntelliJ IDEA, Eclipse vagy a NetBeans. Ebben az anyagban az IntelliJ IDEA-ról, valamint az Eclipseről adunk részletesebb bemutatást, de más fejlesztőkörnyezetek is rendelkeznek az ismertetett dolgok nagy részével, esetleg másképp lehet őket elérni.

Az IntelliJ IDEA használata

Az IDEA indításakor a Welcome ablak jelenik meg. Itt kezdetben néhány beállítást testre szabhatunk (pl. világos / sötét téma), illetve a későbbiekben itt láthatjuk a korábban megnyitott projektjeinket.

Amennyiben korábban már használtuk a környezetet, akkor a legutóbbi projektet fogja alapértelmezetten megnyitni, amelyet a File→Close project menüponttal bezárhatunk.

Projekt létrehozásakor választhatunk sok sablon közül, de létrehozhatunk egyszerű Java projektet is. Ha nem választunk ki semmit, akkor ez utóbbit fogja alapból létrehozni.

Ezután a Next gombra kell párszor kattintanunk, majd megadhatjuk a projekt nevét, illetve a lokációt, hogy hova mentse a projektet. Fontos, hogy az elérési útvonalunk tartalmazza a projekt mappáját is, például C:\suli\prog1\elso-projekt, vagy pedig /home/valaki/suli/prog1/elso-projekt.

A projekt létrehozása után a bal oldalon láthatjuk a projekt struktúráját. Innen az src mappa a legfontosabb, ide kerülnek a Java fájlok.

Új fájl létrehozásához kattintsunk jobb klikkel az src mappára, majd new —> Java class. Ide írjuk be az osztály nevét. A jobb oldali ablakba már írhatjuk is a forráskódot.

Ha szeretnénk futtatni a programunkat, akkor először meg kell keresnünk a futtatható osztályunkat (amiben van main függvény), majd a bal oldali menüben jobb klikk az adott osztályra, és ott válasszuk ki a run opciót. Ekkor az alsó sávban megjelenik egy Run menüpont is, ahol a futtatás eredményét láthatjuk. Ha a felhasználótól kérünk be adatot, akkor azt is itt tudjuk megadni, ezeket zöld színnel jelzi a környezet.

Ha már egyszer lefuttattuk a programunkat, akkor a rendszer létrehozott hozzá egy konfigurációt, ezt a jobb felső sarokban látjuk. Ha rákattintunk, akkor tudjuk szerkeszteni is az "Edit configuration" opcióval. Itt argumentumokat is megadhatunk a programnak (a program arguments mezőbe beírva). Futtatni a legutóbbi konfigurációt a jobb felső sarokban található zöld nyíllal, vagy a Shift + F10-zel tudunk.

A rendszer a program írása során folyamatosan ellenőrzi a programkódunkat, és jelzi, ha hiba található benne. 3 féle hibát szokott jelezni:

• Fordítási hiba. Ha ilyen van, akkor a programunkat nem lehet lefordítani. Ezt a környezet pirossal jelzi.
• Warning. Ha ilyen van, akkor a programunk fordítható és futtatható, de nagy valószínűséggel rosszul működik, a javításuk mindenképp megfontolandó. Létezik "weak warning" is, amely általában kódminőséggel kapcsolatos problémákra figyelmeztet. Ilyen lehet, hogy egy adott kódblokk több helyen meg van ismételve, ahelyett, hogy kiszerveztük volna függvénybe; vagy hogy egy if szerkezetben az if és az else ág ugyanazt csinálja.
• Typo: Ha valamit elgépelünk, akkor erre szintén figyelmeztet. Az angol nyelvet ismeri.

A hibákat jelzi a kód színezésével is, illetve a jobb oldali görgetősávban is. Ezekre javításokat is tud javasolni az esetek nagy részében. Ehhez a kurzorral menjünk az adott hibás kódrészletre, majd nyomjuk meg az Alt+Enter billentyű kombinációt. Itt ki is választhatjuk a számunkra szimpatikus javítást (ha van ilyen).

A képernyő jobb felső sarkában jelzi az összesítést is, hogy melyik hibából hány darab van az aktuális osztályunkban.

Debuggolás

Vegyük azt a nagyon egyszerű kis Java programot, amiben kiírjuk a parancssori argumentumait a programnak. Illetve egy kicsit rontsuk is ezt el, így kezdődhet a hibakeresés!

public class Macska {
    public static void main(String[] args) {
        int i=0;
        while (i<=args.length) {
            System.out.println(i + ". argumentum: " + args[i]);
            i++;
        }
    }
}

Futtassuk a programot a következő parancssori argumentumokkal: elso masodik harmadik

A program futásának kimenete a következő lesz:

Breakpoint

A legegyszerűbb lehetőségünk arra, hogy megfigyeljük a programunk működését futás közben, ha egyes sorokra breakpointot teszünk, majd lépdelve a végrehajtás menetén megpróbálunk rájönni, hogy mi is lehet a hiba, ami miatt a programunk nem jól működik.

Ehhez egyszerűen a sor elején, a sorszám melletti üres részre kattintva helyezzük azt el, majd futtassuk a debuggert a felső menüsorban a bogár ikonra kattintva (Shift + F9).

Alul a Debug fülön láthatjuk a program futásának aktuális állapotát. A bal oldalon látjuk, hogy éppen hol jár a programunk futása: most Macska osztály main függvényében vagyunk, a fájl 4. sorában. Ha egy adott függvényben vagyunk, amit más függvényből hívtunk, akkor itt a hívási hely is látszik. A jobb oldalon láthatjuk a változóink aktuális értékét, illetve ezeket módosítani is tudjuk (jobb kilkk). Vagy akár plusz kifejezéseket is hozzáadhatunk a + ikonra kattintva. Ha ide beírjuk pl. azt, hogy "2*i", akkor az folyamatosan az i változó értékének kétszeresét fogja jelezni.

A programban a fenti ikonokkal lépkedhetünk, melyek jelentése rendre:

• Step over (F8): lefuttatja az aktuális sort, majd ugrik a következő sorra. Amennyiben van függvényhívás az aktuális sorban, akkor azt is lefuttatja és ha van benne breakpoint, ott megáll.
• Step into (F7): ha az aktuális sor egy függvényhívás, akkor annak első sorára ugrik
• Force step info (Alt+Shift+F7): akkor is beugrunk az adott függvénybe, ha egyébként kihagynánk azt (általában beépített függvényekről van szó)
• Step out (Shift+F8): végigfuttatja az aktuális függvényt, a hívó helyre ugrik
• Drop frame: Kiugrik az aktuális függvényből, a hívó helyre, de a következő lépésben a függvény újra meg lesz hívva
• Step to cursor (Alt + F9): addig futtatja a programot, míg az el nem éri azt a sort, ahol a kurzor jelenleg áll.

Conditional breakpoint

A breakpointokhoz feltétel is megadható, melynek hatására csak akkor fog megállni a futtatás az adott ponton, ha a feltétel igaz. Ilyen feltétel lehet pl. az, hogy "a > 10". Ahhoz, hogy egy breakpointhoz feltételt írjunk, kattintsunk rá jobb klikkel, majd oda írjuk be a feltételt.

Exception breakpoint

Előfordulhat, hogy akkor szeretnénk megállítani a programunkat, ha abban valahol kivétel keletkezett. Ehhez kattintsunk a breakpointra jobb klikkel, majd válasszuk a "more" opciót. Itt a + ikonra kattintva válasszuk ki a "Java exception breakpoints" opciót, majd kiválaszthatjuk milyen kivételre szeretnénk megállni. Ezután ha futtatjuk a programunkat és ilyen típusú kivételt kapunk, a programunk futása az adott ponton megáll. Ellenőrizhetjük a változók értékeit, és könnyedén kitalálhatjuk mi volt a hiba oka.

Az Eclipse használata

Az Eclipse indításakor mindig a workspace választó ablak nyílik meg, ebben kiválaszthatjuk, hogy melyik könyvtárban szeretnénk dolgozni. Az adott workspace-en belül könnyen és gyorsan el tudjuk érni projektjeinket és ezeken belüli fájljainkat. Ettől persze még lehetséges a workspace-en kívüli fájlok megnyitása is, illetve később másik wokspace kiválasztása.

Indítás után egy részekre tagolt felületet kapunk. Ezen részek számunkra legfontosabbjait tekintjük most át.

A Package Explorer jeleníti meg a kiválasztott workspace tartalmát. Ez annyit jelent, hogy itt láthatjuk sorban a projektjeinket, illetve az azokban felhasznált fájlokat. Minden projektben lesz egy src mappánk, amely a projekt létrehozásakor generálódik. Ebbe írjuk a tényleges programkódot. Itt csomagokban tárolhatunk fájlokat. A gyakorlatban a csomagok is egyszerű könyvtárak, ne ijedjünk meg tőlük. Az src mappa mellett láthatunk egy JRE System Library nevű fájlt. Ez a futtató környezetet tartalmazza, ettől sem kell megijedni.

Alul található egy sáv, melyen több funkciót is elérhetünk. Ebből jelenleg nekünk legfontosabb a konzol, amely a default kimenetet jelenti. Tehát ha kiírunk egy szöveget a már látott módon, akkor azt itt láthatjuk majd.

A középső nagy terület a munkaterület, ahol a tényleges programozást végezhetjük. Ehhez természetesen meg kell nyitnunk egy fájlt, amiben dolgozhatunk.

Új programot általában új projektben szoktunk készíteni. Két ugyanolyan nevű projekt nem lehet egy workspace-en belül.

Ha van egy új projektünk, akkor a tényleges programozáshoz fájlokat kell készítenünk, amiben dolgozhatunk. Ezt jelen esetben úgy tehetjük, ha osztályokat hozunk létre az src mappán belül. Ha nem adunk meg csomagot, akkor az osztály a default package csomagba kerül, amely úgy tekinthető, hogy egyszerűen az src mappában van. Egy csomagban csak egy ugyanolyan nevű osztály létezhet.

Ha bepipáljuk a main függvény generálását, akkor rögtön futtatható osztályt generálunk. Ebből csupán egy sor hozzáadásával készíthető Hello World program. Az Eclipse további segítséget is nyújt, Ctrl + Space billentyűkombinációval automatikusan ki is egészíti megkezdett parancsainkat vagy neveinket.

Futtatni a felső eszköztáron található kis zöld körrel, illetve Ctrl + F11 billentyűkombinációval tudunk.

Amennyiben valami hibát vétünk, a futtatás nem lehetséges. Ezt már korábban is láthatjuk, mivel az Eclipse piros aláhúzással jelzi a hibásan írt neveket, illetve az egyéb hibákat: pl. hiányzó pontosvessző. Ha hosszabb kódunk van, segítséget nyújthatnak a hibák megtalálásában az oldalt elhelyezett piros jelek, amelyekre kattintva a hibás kódrészre ugorhatunk.

Ha nem szintaktikai hibát vétünk, viszont valami egyéb olyan műveletet végzünk, amely az Eclipse szerint nagy valószínűséggel helytelen vagy értelmetlen, akkor ezt sárga aláhúzással jelzi. Ettől még tudjuk futtatni a programot, de az ilyen eseteket érdemes átvizsgálni. Ilyenek lehetnek: felesleges változók (amiket létrehozunk, de nem használjuk semmire), halott kódrészletek (olyan kódrészletek, amelyek nyilvánvalóan nem fognak sosem lefutni, lásd a példákat).

boolean igaz = true;
if (igaz) {
    // mukodes
} else {
    // halott kod
}

Példa halott kódra.

public static int add(int a, int b) {
    return a+b;
    System.out.println("Ez egy halott kodreszlet.");
}

Példa halott kódra.

A képen azért panaszkodik az Eclipse, mert a deklarált változóval nem csináltunk semmit, tehát feleslegesnek ítéli.

Debuggolás

Vegyük azt a nagyon egyszerű kis JAVA programot, amiben kiírjuk a parancssori argumentumait a programnak. Illetve egy kicsit rontsuk is ezt el, így kezdődhet a hibakeresés!

public class HelloWorld {
    public static void main(String[] args) {
        int i=0;
        while (i<=args.length) {
            System.out.println(i + ". argumentum: " + args[i]);
            i++;
        }
    }
}

Futtassuk a programot a következő parancssori argumentumokkal: elso masodik harmadik

A program futásának kimenete a következő lesz:

Breakpoint

A legegyszerűbb lehetőségünk arra, hogy megfigyeljük a programunk működését futás közben, ha egyes sorokra breakpointot teszünk, majd lépdelve a végrehajtás menetén megpróbálunk rájönni, hogy mi is lehet a hiba, ami miatt a programunk nem jól működik.

Ehhez egyszerűen a sor elejére kattintva, ahová a breakpointot tennénk, helyezzük azt el.

Majd futassuk a debuggerünket!

A program utasításain vagy a billentyűk, vagy a megfelelő ikonok segítségével haladhatunk végig: F5, F6, F7, F8

Billentyű	Akció
F5	Jelenlegi sor futtatása, majd ugrás a következő utasításra
F6	Metódus átugrása, azaz a metódus végrehajtása a debugger nélkül
F7	Jelenlegi metódus végrehajtásának befejezése és visszalépés a hívó metódusba
F8	A program végrehajtása a következő breakpointig vagy watchpointig

Lépkedjünk a programunk sorain, és figyeljük közben a programban használt változók értékeit!

Ha akarjuk, akár meg is változtathatjuk egyes változók értékét itt, ezzel is közelebb kerülve a hibás működéshez!

Conditional breakpoint

A változók helyenkénti megváltoztatása persze nem minden esetben biztonságos megoldás, viszont például egy sokszor ismétlődő ciklus esetében a ciklusmag állandó végrehajtásától a hajunkat téphetjük. Ilyenkor segít, ha a breakpoint tulajdonságait módosítjuk, és csak bizonyos feltételek mellett áll meg adott helynél a debugger. A breakpoint megadásakor eleve állítsuk be azt úgy, hogy az a ciklusunk utolsó végrehajtására álljon.

Újrafuttatva a debuggert az már csak akkor áll meg, amikor a ciklus feltétele a feltételünknek megfelelő.

Exception breakpoint

Mivel jelen példánkban láttuk, hogy a hiba egy kivétel dobásához kötött, azt is megtehetjük, hogy a kivétel típusának megfelelő breakpointot adunk a programunkhoz. Jelen esetben ez a legjobb megoldás, mert így jutunk a legközelebb a probléma gyökeréhez.

A listából válasszuk ki a hibaüzenetünknek megfelelő kivételt:

Futassuk újra a debugerünket, de csak ezzel az újonnan megadott breakpointtal!

A debugger a hiba keletkezésének pillanatában megáll. Ha figyelmesek vagyunk, a változók egyértelműen mutatják nekünk, hogyan indexeltük túl a tömbünket, és mit kell javítanunk.

Kommentek, javadoc

Egyszerű kommentek

A hagyományos, /* és */ közé írt kommentek ismerősek lehetnek C-ből, teljesen ugyanúgy működnek. Az egysoros komment, amely a kiírástól a sor végéig kommentet fog jelenteni: // komment. Az utóbbi a C újabb szabványai szerint is helyes, azonban C99 szabvány előtt az egysoros kommentek nem működtek C-ben.

Javadoc kommentek

Segítségével a forráskódba írt kommentekből HTML alapú dokumentáció generálható. Egy példa a generált HTML oldalra. Sokféle generátor létezik, a legismertebb a Java JDK-ban is meglévő javadoc nevű alkalmazás, melyről bővebben itt olvashatsz, de ezen kívül számtalan alternatíva létezik: Doc-O-Matic, Doc++, Doxygen Használata egyszerű, a hagyományos kommentezés helyett a /** és */ közé írjuk a kommenteket, majd ezekben használhatunk különféle speciális hivatkozásokat, melyek az elkészült dokumentációban speciálisan jelennek meg.

Néhány példa:

• @author - szerző
• @version - verzió
• @param - paraméter
• @throws - kivételek, amiket dobhat az adott függvény/osztály
• @return - visszatérési érték
• @see - hivatkozás más osztályokra

Az összes speciális hivatkozás és leírásuk elérhető ezen a linken.

/**
 * Hello World program.
 * @author Elso Hallgato
 * @author Masodik Hallgato
 * @version 1.0
 */
public class HelloWorld {

  /**
   * A main fuggveny
   *
   * @param args a parancssori parameterek.
   * @author Elso Hallgato
   * @version 1.0
   */
  public static void main(String[] args) {
    System.out.println("Hello World!");
  }

  /**
   * Osszeadas
   *
   * @param a az elso szam.
   * @param b a masodik szam.
   * @author Masodik Hallgato
   * @version 0.8
   * @return a szamok osszege.
   */
  public static int add(int a, int b) {
    return a+b;
  }
}

Az elkészült forráskódból elkészíthetjük a dokumentációt a beépített javadoc paranccsal, a jelenlegi példában javadoc HelloWorld.java, majd az elkészült fájlok közül nyissuk meg az index.html fájlt.

Online fejlesztői eszközök

Manapság már számos online fejlesztői eszköz közül válogathatunk, amelyek eltérő lehetőségeket, funkciókat kínálnak. Ezek használata hasznos lehet, ha esetleg vendégségben vagyunk vagy olyan számítógép előtt ülünk, ahol nincs Java és nem is telepíthetünk (pl.: nincs adminisztrátori jogosultságunk), esetleg gyorsan, akár tabletről, telefonról szeretnénk egy kódot kipróbálni. Néhány online fejlesztőkörnyezet, melyből válogathatunk: IdeOne, CompileJava, TutorialsPoint Java compiler, CodeChef, Browxy, JDoodle. Otthoni, mindennapos használatra azonban nem javasoljuk őket, mert ezek az eszközök számos limitációval rendelkezhetnek (például a nehézkés/lehetetlen debuggolás).

Videók

• Java környezet beüzemelése, minimális Java program írása, fordítása, futtatása: https://youtu.be/I5N5p7orGBU
• Egyszerű program írása, fordítása, parancssori argumentumok használata: https://youtu.be/012UYS3KBjQ
• IntelliJ használata: https://youtu.be/SVJ3G1UDg4k
• Input adatok beolvasása, projekt létrehozása és programozás IDEA-ban: https://youtu.be/Zx3OsETKT94
• Parancssori argumentumok kezelése IntelliJ-ben-ban: https://youtu.be/KjVGkhuZ8Wg
• Parancssori argumentumok, sztringek, sztringek összehasonlítása: https://youtu.be/_uV-qNMCLvM
• Primitív adattípusok, változók, kommentek, hibakeresés : https://youtu.be/Y9xXVu-rLsU
• Javadoc dokumentáció készítése: https://youtu.be/-oZNKjVPCz4
• Input adatok beolvasása, prímszámok keresése: https://youtu.be/6EubCt3k1H4

Feladatok

1. Írj egy programot, ami százszor kiír egy tetszőleges szöveget, valamint azt, hogy hányadik kiiratásnál jár éppen!

2. Írj egy programot, ami kiírja a parancssori argumentumokat, és azok számát!

3. Írj egy olyan futtatható Java osztályt, amely a parancssori argumentumokat fordított sorrendben írja ki, ráadásul mindet visszafelé!

4. Kommentezd a kódot javadoc kommentekkel, és generáld ki a dokumentációt! És nézd is meg a generált állományokat!

Feladatok (automatikus értékeléssel)

Az itt lévő feladatok szövegei, váza elérhető itt: HaziFeladatUres.java. A függvények törzsét kell elkészíteni! A megoldás tesztelése automatikus, a fájl lefordításával és lefuttatásával bármilyen számítógépen elvégezhető, internet nélkül is!

1. Készíts egy statikus, lustalkodas nevű függvényt. A függvény két paramétert kap: azt, hogy hétköznap van-e, és azt, hogy vakáció van-e. Akkor lustálkodhatunk reggel, ha hétvége van, vagy ha vakáción vagyunk.
2. Készíts egy statikus, utolsoSzamjegyEgyenloseg nevű függvényt. A függvény két számot vár. Térjen vissza igazzal, ha a számok utolsó számjegyei megegyeznek.
3. Készíts egy statikus, utolsoSzamjegyEgyenlosegN nevű függvényt. A függvény három számot vár (a, b, n). Térjen vissza igazzal, ha az első két szám utolsó n számjegyei megegyeznek (az utolsó 3. paraméter).
4. Készíts egy statikus, honap nevű függvényt, ami egy számot vár. A függvény térjen vissza az adott hónappal szövegesen (ékezet nélkül), ha a megadott szám 1-12 között van. Minden más esetben pedig a "nem ismert" szöveggel!
5. Készíts egy statikus, primek nevű függvényt, ami egy számot vár. A függvény térjen vissza azzal, hogy az adott számig (a paraméterként kapott szám is benne van) hány darab prímszám van!

Kapcsolódó linkek

Java 17 API

Részletes leírás a javadocról

---

Utolsó frissítés: 2024-04-11 07:54:27