Programozási nyelvek II. (Java) gyakorlat, 2016.09.22.

A korábbiakban már láthattuk, hogy Java nyelvben alkalmazható típusok alapvetően két csoportra bonthatóak: primitív típusokra és objektumtípusokra. Ezek közül az előbbi lényegében néhány előre definiált, beépített eszköz (pl. int az egész számok ábrázolásához), az utóbbi pedig a szabványos könyvtárban definiált típusok halmaza. A objektumtípusok halmazát mi magunk is tudjuk (sőt, tulajdonképpen kell is) bővíteni saját osztályok definiálásával.

Például tegyük fel, hogy szeretnénk kétdimenziós pontokat ábrázolni és megadni a rájuk értelmezhető műveleteket.

// Kétdimenziós pontok ábrázolása
class Point2D {
    // Koordináták mint mezők
    double x;
    double y;

    // Pont eltolása egy vektorral
    void translate(double dx, double dy) {
        x += dx;
        y += dy;
    }

    // Pont középpontos nagyítása egy skalárral
    void scale(double c) {
        x *= c;
        y *= c;
    }

    // Pont forgatása adott szöggel
    void rotate(double phi) {
        double nx = x * Math.cos(phi) - y * Math.sin(phi);
        double ny = x * Math.sin(phi) + y * Math.cos(phi);
        x = nx;
        y = ny;
    }

    // Pont átalakítása szöveggé
    String show() {
        return String.format("{ x = %.3f, y = %.3f }", x, y);
    }

    // Két pont távolsága
    static double distance(Point2D p0, Point2D p1) {
        double xd = p0.x - p1.x;
        double yd = p0.y - p1.y;
        return (Math.sqrt((xd * xd) + (yd * yd)));
    }

    // A második pont tükrözése az elsőre
    static Point2D mirror(Point2D c, Point2D p) {
        Point2D result = new Point2D();
        result.x = (2 * c.x) - p.x;
        result.y = (2 * c.y) - p.y;
        return result;
    }
}

// Szögekkel kapcsolatos segédműveletek
class Angle {
    // Fok -> radián
    static double degreeToRadian(double x) {
        return x * Math.PI / 180;
    }

    // Radián -> fok
    static double radianToDegree(double x) {
        return x * 180 / Math.PI;
    }
}

// "Főprogram"
public class Point2DDemo {
    public static void main(String[] args) {
        Point2D p0 = new Point2D();
        p0.x = Math.E;
        p0.y = Math.PI;
        p0.translate(0.1, 12.34);
        p0.scale(0.78);
        p0.rotate(Angle.degreeToRadian(90));
        System.out.println("p0 = " + p0.show());

        Point2D p1 = new Point2D();
        p1.x = 2 * Math.PI;
        p1.y = Math.E / 2;
        p1.scale(1.445);
        p1.rotate(Angle.degreeToRadian(-33));
        System.out.println("p1 = " + p1.show());

        System.out.println("distance(p0, p1) = " + Point2D.distance(p0, p1));

        Point2D p2 = Point2D.mirror(p1, p0);
        System.out.println("mirror(p1, p0) = " + p2.show());
    }
}

Érdemes megemlíteni, hogy elegendő a főprogramot, vagyis a Point2DDemo osztályt lefordítani. A fordító ennek lefordítása közben ugyanis az összes többi hivatkozott osztályt is megpróbálja lefordítani.

Függvények (metódusok)

Az előbbi kódban láthattuk, hogy az osztályokban szereplő műveleteket függvényekkel, vagy Java terminológia szerint metódusokkal adtuk meg. Ezek általános alakja:

<módosítószavak> <visszatérési érték> <név>( <paraméterek listája> )
        [ throws <kivétel lista> ] {
    <utasítás1>;
    <utasítás2>;
    ...
}

Csomagok

Egy csomag osztályok és interfészek gyűjteménye. Csomagok alkalmazásának általában a következő okai, céljai vannak:

A csomagoknak nevet kell adni, ezeket általában pontokkal tagolt azonosítósorozattal nevezzük el. Általános elnevezési konvenció, hogy a csomagnevek globális (világszinten) egyediek, és az interneten található domain névekhez hasonló felépítés szerint képződnek, pl. org.ietf.jgss.

A Java szabványos csomagjai többnyire a java. előtaggal rendelkeznek, illetve a gyakorlatok során a programjainkban is egyszerűsített csomagelnevezéseket fogunk alkalmazni.

Importálás

A Java nyelv alapvető objektumait és interfészeit (pl. Object, String, stb.) a java.lang csomag tartalmazza, amelynek elemei közvetlenül elérhetőek a forrásszövegekben. Minden más csomag elemeit egy ún. teljesen minősített név ("fully-qualified name") használatával tudjuk elérni. Például java.util.Scanner a java.util csomagban található Scanner osztályt nevezi meg.

public class Simple {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        System.out.print("? ");
        if (sc.hasNextInt()) {
            int x = sc.nextInt();
            System.out.println("x = " + x);
        }
        else System.out.println("No valid input.");
    }
}

Amennyiben nem akarjuk a külső neveket a programunkat minden alkalommal teljesen kiírni, úgy import utasítások segítségével beemelhetjük a csomagunk névterébe más csomagok neveit.

import java.util.Scanner;   // Egy konkrét típus esetén
import java.math.*;         // A csomag minden elemének láthatóvá tétele

import java.util.Scanner;

public class Simple {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        System.out.println("x = " + x);
    }
}

Saját csomagok készítése

Csomagokon keresztül természetesen a saját programunkat is tudjuk strukturálni. Ennek két fontos lépése van:

Mindezek szemléltetéséhez a korábban elkészített, kétdimenziós pontokkal foglalkozó programunkat bontsuk csomagokra! A Point2D osztályt tegyük a geo.basics csomagba, az Angle osztályt a geo.utils csomagba, végül a főprogramként szolgáló Point2DDemo osztályt a main csomagba!

Ehhez először ki kell alakítanunk a megfelelő könyvtárszerkezetet, majd elhelyeznünk benne a forráskódokat:

Ezt követően pedig mindegyik forrásszöveg tetejére be kell illeszteni a neki megfelelő csomag azonosítóját. Például a Point2D.java elejére ezt kell odatenni:

package geo.basics;

package geo.utils;

package main;

import geo.basics.Point2D;
import geo.utils.Angle;

Valamint az osztályokat és a bennük szereplő összes tagot (mezőt, metódust) a public módosítóval kell ellátni. Ez engedélyezi, hogy kívülről is el lehessen érni ezeket. Alapértelmezés szerint ugyanis ezek láthatósága csak a csomagon belülre terjed ki.

Fordítás és futtatás

A fordító nem támogatja a források rekurzív fordítását, viszont megadható neki egy állomány a @ karakterrel, amelyben a fordítani kívánt állományokat lehet felsorolni.

A több csomagból álló alkalmazásunkat ezután a csomagtőböl tudjuk futtatni, a főosztály (Point2DDemo) teljesen minősített nevének megadásával.

Programok nyomkövetése

A programokban olykor hibát kell keresnünk, vagy meg kell értenünk, pontosan miként is működik. Ezt a folyamatot debuggolásnak, esetleg trace-elésnek ("trészelés"), magyarosabban pedig nyom(on)követésnek nevezik.

A program nyomonkövethetőségéhez a forráskódot a -g kapcsolódóval kell fordítani, a javac segítségével. Ez fogja engedélyezni az összes szükséges segédinformáció elhelyezését a létrehozott tárgykódban.

Sikeres fordítást követően a jdb (mint "Java DeBugger") nevű segédprogrammal tudjuk a programban elhelyezett nyomkövetési segédinformációkat felhasználni. Ehhez el kell indítanunk a parancssorból, amelyre válaszul másik egy interaktív paranccsort kapunk.

A nyomkövető programban, vagyis a debuggerben használható parancsokat a help parancs segítségével lehet listázni. Ezek közül most csak a legfontosabbakat fogjuk áttekinteni.

Az első, és talán megfontosabb parancs a stop at, amellyel a program futását majd meg tudjuk állítani egy ponton. Ennek segítségével ún. töréspontokat ("breakpoint") lehet a program kódjában elhelyezni. Amikor a program futása (a debuggeren belül) elér egy aktív töréspontot, akkor megáll és a visszakapjuk a debugger parancssorát.

A töréspontokat az osztály betöltődése nélkül is be lehet állítani, aktiválódni akkor fognak, amikor az osztály adott részére adódik a vezérlés. A betöltött osztály main() metódusának futtását a run paranccsal tudjuk kérni.

A töréspont elérésekor a debugger meg is mutatja az érintett sort, annak sorszámával együtt. Ilyenkor a program futása felfüggesztődik. Ekkor van lehetőségünk megvizsgálni például az éppen elérhető (scope-ban levő) változók értékeit, illetve ezekhez kifejezéseket kiértékeltetni.

Látható, hogy ezen a ponton még csak a parancssori paramétereket tároló args változó érthető el. Ezt a print paranccsal tudjuk megvizsgálni.

A forráskódban szereplő p0 változó csak akkor fog létrejönni, ha engedjük lefutni azt a sort. A soronkénti egyenkénti futtatását léptetésnek ("step") hívjuk, ezért ezt a step paranccsal tudjuk megtenni.

Ekkor a vezérlés a Point2D osztály példányának inicializálására adódik, mivel a példányosítás során ennek is le kell futnia. Léptessük addig a végrehajtást, amíg a p0 valóban létre nem jön:

Szükség esetén a programban szereplő változók értékei meg is változtathatóak. Ez leginkább akkor hasznos, ha valamilyen rossznak vélt értéket akarunk helyreállítani, vagy csak kísérletezni akarunk velük.

Ha folytatni szeretnénk a program futtatását a megszokott tempóban, akkor a cont parancssal tudjuk továbbengedni. Így a program futni fog normál módban egészen addig, amíg el nem ér egy újabb töréspontot, vagy be nem fejeződik.

Programozási nyelvek II. (Java) gyakorlat, 2016.09.22.

Emlékeztető

Osztályok definiálása és példányosítása