Programozási technológia Angster Erzsébet: OO tervezés és programozás, Java II. kötet alapján Készítette: Andor Gergely Ellenőrizte: Dr. Szelezsán János Jóváhagyta: Lengyel Zsuzsánna

Programozási technológia I. Objektumorientált technikák II. Grafikus felhasználói interfész III. Állománykezelés IV. Vegyes technológiák V. Adatszerkezetek, kollekciók

I. Objektumorientált technikák 1. Csomagolás, projektkezelés 2. Öröklődés 3. Interfészek, belső osztályok 4. Kivételkezelés

I. Objektumorientált technikák 1. Csomagolás, projektkezelés 1. Csomagolás 2. Projektkezelés a JBuilderben 3. JAR-állomány készítése Java program futtattása

Csomagolás Csomag (package) Összetartozó osztályok és interfészek csoportja Logikai és fizikai szintű csoportosítás csomag1 csomag2 csomag12 csomag11 csomag121 Osztaly3 Interfesz Osztaly1 Osztaly4 Osztaly5 Osztaly2

Könyvtárstruktúra Projektkönyvtár Projektfájl Célútvonal Forrásútvonal csomag1 csomag2 csomag11 csomag12 Interfesz.class Osztaly1.class Osztaly2.class Osztaly4.class csomag121 Osztaly3.class Osztaly5.class classes CsomagApp src Interfesz.java Osztaly2.java Osztaly4.java Osztaly3.java Osztaly5.java Forrásútvonal Célútvonal Projektfájl CsomagApp.jpx Projektkönyvtár

Csomag azonosítása UML: csomag1::csomag12::csomag121 Java: csomag1.csomag12.csomag121 Csomag megadása package csomag1.csomag12.csomag121; Más csomag importálása import csomag1.csomag12.csomag121.Osztaly3; import csomag1.csomag12.csomag121.*;

Csomag elemeinek láthatósága Osztály vagy interfész láthatósága publikus (public) csomagszintű Osztálytagok (adatok, metódusok) láthatósága publikus (public , +) védett (protected , #) privát (private , -) csomagszintű Az öröklési ágon az osztálytagok láthatósága csak bővíthető!

Projektkezelés a JBuilderben Projekt (project) Egy adott szoftver fejlesztéséhez használt, logikailag összetartozó állományok és környezeti beállítások gyűjteménye Projektállomány projektelemek (állományok) listája projekt tulajdonságai

Projektkezelés JBuilderben Tartalompanel Projektpanel Struktúrapanel Üzenetpanel Projektkezelés JBuilderben Projekt (project) összetartozó osztályok és interfészek csoportja logikai és fizikai szintű csoportosítás

Java fordítóprogram Alapútvonalak kimeneti útvonal – output path osztályútvonal – class path forrásútvonal – source path Példák 02Oroklodes\HengerProgram\src\compile1.bat: javac -g -nowarn Henger.java 01Projekt\CsomagApp\make.bat javac -sourcepath src -d classes -classpath . @Files.txt

JAR-állomány készítése JAR (Java ARchive) Egy Java projekt fájljait tömörítő állomány Manifest (aláírásfájl, manifest.mf) JAR fájl összeállítása parancssorból jar cfm CsomagApp.jar meta-inf\manifest.mf –C classes . JAR fájl futtatása java –jar CsomagApp.jar

I. Objektumorientált technikák 2. Öröklődés 1. Az öröklődés fogalma 2. Mintafeladat – Hengerprogram 3. Az objektumreferencia statikus és dinamikus típusa 4. Az utódosztály adatai és kapcsolatai 5. Metódusok felülírása, dinamikus és statikus kötés 6. this és super referenciák 7. this és super konstruktorok – konstruktorok láncolása 8. Polimorfizmus 9. Absztrakt metódus, absztrakt osztály 10. Láthatóság 11. Összefoglalás – metódusok nyomkövetése

Öröklődés Öröklődés(inheritance), kiterjesztés(extension) Egy meglévő osztály kiterjesztése, továbbfejlesztése Ősosztály, utódosztály Egyszeres / többszörös öröklés Az öröklés szabályai Egy osztályból több osztály is származtatható Az osztályhierarchia mélysége tetszőleges Az öröklés tranzitív A Javában minden osztály implicit őse az Object, és csak egyszeres öröklés van.

Mintafeladat – Hengerprogram Különböző hengereket szeretnénk nyilvántartani: vannak olyan hengerek, amelyek csupán mértani testek. Ezeknek van sugaruk és magasságuk; vannak rudak (tömör hengerek), melyeknek súlyuk is van; végül vannak csövek: valamekkora falvastagságú tömör, lyukas hengerek. Készítsük el a megadott hengerek osztályait! Inicializáláskor a hengereknek értelemszerűen megadhatók a következő adatok: sugár, magasság, fajsúly és falvastagság. A fajsúlyt nem kötelező megadni, az alapértelmezésben legyen 1!

Minden henger legyen képes visszaadni alapadatait, térfogatát és esetleges súlyát! A toString() metódus adja meg az adott henger szöveges reprezentációját! A fent leírt osztályokból példányosítsunk néhányat, és tegyük bele őket egy konténerbe! Végezzük el a következő feladatokat: Írjuk ki a hengerek számát, és listázzuk ki a hengerek adatait! Számítsuk ki a konténerben található összes henger átlag térfogatát! Listázzuk ki a csövek adatait, adjuk meg a csövek számát és összsúlyukat! Számoljuk és a program végén írjuk ki a program futása közben született hengerek számát!

Osztálydiagram Henger -szuletesSzamlalo: int -sugar, magassag: double * hengerek {Vector} HengerProgram +HengerProgram() +atlagTerfogat(): double +lista(vektor: Vector) +run() +main(...) Henger -szuletesSzamlalo: int -sugar, magassag: double +Henger(sugar,magassag: double) +getSzuletesSzamlalo: int +getSugar(): double +getMagassag(): double +terfogat(): double +toString(): String Rud -fajsuly: double +Rud(sugar,magassag,fajsuly: double) +Rud(sugar,magassag: double) +getFajsuly(): double +suly(): double Cso -falVastagsag: double +Cso(sugar,magassag,fajsuly,falVastagsag: double) +Cso(sugar,magassag,falVastagsag: double) +getFalVastagsag(): double

class Henger { //... } class Rud extends Henger { class Cso extends Rud { public class HengerProgram {

Az objektumreferencia statikus és dinamikus típusa Statikus típus: deklarált osztály Dinamikus típus: mutatott objektum valódi osztálya Object Henger Rud Cso :Object :Henger :Rud :Cso r : Rud Helytelen!

instanceof operátor Object obj = new String("Valami"); if (obj instanceof Object) ... // true if (obj instanceof String) ... // true if (obj instanceof Integer) ... // false if ("Semmi" instanceof String) ... // true Automatikus típuskonverzió felfelé (upcasting) String str = "Kakukk"; System.out.println(str.toLowerCase()); // OK Object obj = str; // StringObject //System.out.println(obj.toLowerCase()); Fordítási hiba!

Típuskonverzió lefelé (downcasting) Object obj = "Szoveg"; // String  Object String str = (String)obj; // Object  String // String str = obj; Fordítási hiba! Object obj = "Kakas"; // String  Object Integer iObj = (Integer)obj; // Object  Integer (!) System.out.println(iObj.intValue()); // ClassCastException!

Az utódosztály adatai és kapcsolatai Példányadatok memóriafoglalása Henger -sugar: double -magassag: double Rud -fajsuly: double Cso -falVastagsag: double h : Henger sugar = 1 magassag = 4 r : Rud sugar = 0.5 fajsuly = 2 cso : Cso sugar = 5 magassag = 5 fajsuly = 0.5 falVastagsag = 2

Hivatkozás az adatokra Hivatkozás kívülről: publikus, nem takart példányadatokra, illetve osztályadatokra Hivatkozás osztályból: publikus vagy védett ősadatokra Adatok takarása Adatot nem lehet felülírni! Adat takarása = ugyanolyan nevű másik adat deklarálása

class C1 { static String s = "C1 "; int a = 1; int b = 10; } class C2 extends C1 { int a = 2; } class C3 extends C2 { static String s = "C3 "; int b = 30; public void kiir1() { System.out.println(C1.s+C2.s+s);} //public void kiir2() { System.out.println(C1.a+C2.a+C3.a);} public void kiir3() { System.out.println(super.a+a); } public void kiir4() { System.out.println(super.b+b); } }

Metódus felülírása, dinamikus és statikus kötés Példánymetódus felülírása (overriding) Egy metódus az utódosztályban felülírható, ha az nem private nem final nem static (példánymetódus) Dinamikus kötés, futás alatti kötés, késői kötés Osztálymetódus Az osztály sajátja, nem írható felül Statikus kötés

A példánymetódus dinamikus kötése C1 m1() {m2()} m2() C2 obj2:C2 obj1:C1 m1()

Az osztálymetódus statikus kötése C1 m1() {m2()} m2() C2 obj2:C2 obj1:C1 m1()

this és super referenciák A megszólított objektum referenciái Példánydeklarációk takarása esetén használatosak Hivatkozás saját (eltakart) adatra this.adat Hivatkozás ős (eltakart) adatra / metódusra super.adat super.metódus()

Konstruktorok láncolása Minden osztálynak van saját konstruktora A konstruktor nem öröklődik, és nem lehet felülírni Konstruktorhívási lánc Konstruktorok láncolásának szabályai Osztályon belül másik konstruktor hívása: this(paraméterek) A közvetlen ős konstruktor hívása: super(paraméterek) Minden konstruktorban pontosan egy this() vagy super() hívás legelső utasításként

Példa class C1 { C1(int a) { } } class C2 extends C1 { C2(int a, int b) {super(a);} C2(int a) {this(a,1);} C2() {this(2);} class C3 extends C2 { C3(int a, int b) { } C3(int a) {this(a,3);} Példa

class C4 extends C3 { int a; //C4() {super();} // hiba: C3-ban nincs C3() //C4() { } // hiba: C3-ban nincs C3() //C4() {a=1; super(a);} // hiba: super nem első! //C4() {this(); super(5);} // hiba: kettő nem lehet! } public class KonstruktorProba { public static void main (String args[]) { new C3(1);

Polimorfizmus :Henger :Rud :Cso :HengerProgram terfogat() toString()

Absztrakt metódus, absztrakt osztály Absztrakt metódus: üres metódus, mely csak örökítési célt szolgál Absztrakt osztály: absztrakt metódust tartalmazó, nem példányosítható osztály Jelölés UML: dőlt betűvel Java: abstract class <OsztályAzonosító> { … abstract <metódusAz>(paraméterek); … }

Feladat – FaIdomok Egy fajátékokat tartalmazó dobozban két féle idom van: gömb és hasáb, különböző méretekben. Készítsünk olyan programot, amellyel nyilvántart-hatjuk különböző idomok adatait! Írjuk ki a következőket: az összes idom adatait a felvitel sorrendjében; az idomok összsúlyát; a gömbök összsúlyát; a legkisebb és a legnagyobb térfogatú idom típusát és adatait!

java::lang::Comparable Osztálydiagram idomok * -idomok {Vector} Hasab -a,b,magassag: double +Hasab(a,b,magassag:double) +terfogat(): double +toString(): String Gomb -sugar: double +Gomb(sugar:double) FaIdomok +FaIdomok() +osszSuly(): double +osszGombSuly(): double +run() +main(...) java::lang::Comparable Idom { abstract } -fajsuly: double = 0.8 +suly(): double +compareTo(obj:Object): int java::lang::Object

I. Objektumorientált technikák 3. Interfészek, belső osztályok 1. Interfész 2. Belső osztály 3. Névtelen osztály

Interfész Konstansokat és metódusfejeket definiál Implementáló osztály: a metódusokat implementálja Deklarációja: [public] interface <InterfészAzon> [extends <InterfészAzon,...>] { <konstansok, metódusfejek> } Abstract, nem példányosítható Egyetlen lehetséges módosítója: public Konstansok módosítói: public, static, final Metódusfejek módosítói: public, abstract

Az interfész implementálása Implementáló osztály: speciális utódja az interfésznek Nem abstract osztály  összes metódust meg kell írni Abstract osztály  az utódban befejezhető az implementálás Egy osztály akárhány interfészt implementálhat! Az interfész egyes metódusait az implementáló osztály örökölheti is

Értékadási kompatibilitás Az interfész öröklése Az interfészek örökíthetők Az utód interfész örökli az ős interfész deklarációit Az utód interfész implementálásakor implementálnunk kell az ős interfész metódusait is Egy interfész akárhány interfészt örökölhet! Értékadási kompatibilitás Az objektum statikus referenciája lehet interfész típusú Az implementáló osztály objektuma értékül, illetve paraméterül adható az interfész típusú statikus referenciának

Feladat – Sorok feldolgozása, QueueApp A sor szekvenciális, csak sorban feldolgozható konténer; csak a végére lehet új elemet tenni, s csak a legelsőnek betett elemet lehet kivenni belőle. Készítsünk két interfészt: Az IQueue olyan sor, amely képes a következőkre: Betesz egy új objektumot a sor végére; Kiveszi, és rendelkezésre bocsátja a sor legelső objektumát; Megmondja, hogy a sor üres-e. Az ICleverQueue okos sor (clever queue), s az előbbieken túl a következőket is tudja: Kiveszi és megszünteti a sor első n objektumát; Megadja a sorban álló objektumok számát.

Készítsünk mindkét interfészből egy-egy osztályt Készítsünk mindkét interfészből egy-egy osztályt! Az ICleverQueue implementációja legyen leszármazottja az IQueue implementációjának. Az interfészeket és az osztályokat tegyük be az extra.util csomagba, hogy később is használhassuk őket! Végül készítsünk egy programot, amely menüvezérelten végzi a következő funkciókat: betesz a sorba egy szöveget; kivesz a sorból egy szöveget (ha van) és ki is írja; kitöröl a sorból három szöveget, ha van benne annyi!

Osztálydiagram Forráskódok Projekt: QueueApp Csomaghierarchia: extra::util «interfész» IQueue +put(Object) +get(): Object +isEmpty(): boolean QueueApp +main(...) +processQueue(ICleverQueue) ICleverQueue +remove(int) +size(): int java::lang::Object Queue CleverQueue Forráskódok Projekt: QueueApp Csomaghierarchia: QueueApp extra util IQueue ICleverQueue Queue CleverQueue

IQueue.java ICleverQueue.java package extra.util; public interface IQueue { void put(Object o); Object get(); boolean isEmpty(); } ICleverQueue.java package extra.util; public interface ICleverQueue extends IQueue { void remove(int n); int size(); }

Queue.java CleverQueue.java ... public class Queue implements IQueue { protected Vector v = new Vector(); public void put(Object o) { v.add(o); } CleverQueue.java ... public class CleverQueue extends Queue implements ICleverQueue { }

Konstans az interfészben Feladat – Számla Kérjünk be egy forintösszeget, majd írjuk ki az értékét euróban! ... interface Euro { int ARFOLYAM = 230; String NEV = "EURO"; } public class Szamla implements Euro { public static void main (String args[]) { int ftOsszeg = Console.readInt("Összeg (Ft): "); System.out.println((ftOsszeg/ARFOLYAM)+" "+NEV);

Belső osztály Osztályon belül deklarált másik osztály: class <KulsoOsztályAzon> ... { ... class <BelsoOsztályAzon> ... { ... } } Csak az őt deklaráló külső osztály ismeri Példányosítás: külső osztály példánymetódusából

Belső osztály (folyt.) Példánya ismeri az őt létrehozó külső objektumot implicit referencia hivatkozás takarásnál: KülsőOsztály.this Nem lehetnek statikus deklarációi Nem kötelező azonosítani (névtelen belső osztály) Fordítóprogram különálló külső osztállyá alakítja: KülsőOsztályAzon$BelsőOsztályAzon.class KülsőOsztályAzon$n.class (n=1,2,…)

Feladat – UdvarApp Egy udvaron különböző négyzetes oszlopok vannak elhelyezve. Tartsuk nyilván az udvar és az oszlopok adatait, majd készítsünk róluk jelentést! Ne engedjünk olyan oszlopot létrehozni, amely az udvaron kívülre esik!

import java.util.*; class Udvar { //  Udvar.class private int szel=100, hossz=50; private Vector oszlopok = new Vector(); public Udvar() { oszlopok.add(new Oszlop(25,30)); oszlopok.add(new Oszlop(40,5)); oszlopok.add(new Oszlop(97,10)); }

class Oszlop { //  Udvar$Oszlop.class private int x, y; private int szel=5; public Oszlop(int x, int y) { if (x>=0 && x<=Udvar.this.szel-szel && y>=0 && y<=hossz-szel) { this.x = x; this.y = y; } else { this.x = 0; this.y = 0;

public String toString() { return x+"-"+y; } } // Oszlop return Udvar:"+szel+"x"+hossz+ ",Oszlopok:"+oszlopok; } // Udvar

public class UdvarApp { //  UdvarApp.class public static void main(String[] args) { Udvar udvar = new Udvar(); System.out.println(udvar); }

Feladat – UdvarApp2 Oldjuk meg az előző feladatot belső osztály nélkül! ... class Oszlop { //  Oszlop.class public Oszlop(Udvar udvar,int x, int y) { if (x>=0 && x<=udvar.szel-szel && y>=0 && y<=udvar.hossz-szel) { … } } // Oszlop

class Udvar { //  Udvar.class … public Udvar() { oszlopok.add(new Oszlop(this,25,30)); oszlopok.add(new Oszlop(this,40,5)); oszlopok.add(new Oszlop(this,97,10)); } } // Udvar public class UdvarApp2 { //  UdvarApp2.class

Névtelen osztály Nincs neve  Máshol nem lehet rá hivatkozni   Egyszer példányosítható Az objektum létrehozásával egyidőben deklaráljuk Névtelen osztályú objektum létrehozása Osztály kiterjesztésével Interfész implementálásával Nincs konstruktora

Névtelen osztály példányosítása osztály kiterjesztésével class Ember { … } //  Ember.class public class NevtelenKiterjesztes { //  NevtelenKiterjesztes.class public static void main(String[] args) { Vector emberek = new Vector(); emberek.add(new Ember("Zoli") { public String jellemzo() { return "Kövér"; } }); … //  NevtelenKiterjesztes$1.class

Névtelen osztály példányosítása interfész implementálásával interface Jellemzett { //  Jellemzett.class public String jellemzo(); } public class NevtelenImplementacio { //  NevtelenImplementacio.class public static void main(String[] args) { Jellemzett jel = new Jellemzett() { public String jellemzo() { return "Szép"; }); … //  NevtelenImplementacio$1.class

I. Objektumorientált technikák 4. Kivételkezelés 1. Kivételek, hibák 2. Kivételek keletkezése és szándékos kiváltása – throw 3. A kivétel továbbadása – throws 4. A kivétel elkapása, kezelése 5. Saját kivételek használata

Rendszerhibák és kivételek Programot leállító események: objektumok, melyek osztályai a Throwable osztály leszármazottai A „dobható” események két csoportja: Rendszerhiba (Error): a programot leállítja Kivétel (Exception): hibakezelés után a program folytatódhat Nem ellenőrzött kivétel: nem kötelező kezelni (futási hibák, RuntimeException és annak leszármazottai) Ellenőrzött kivétel: kötelező kezelni (többi Exception)

Object java.lang Throwable java.lang Error java.lang LinkageError java.lang VirtualMachineError java.lang ThreadDeath java.lang AWTError java.lang Exception java.lang RuntimeException java.lang ArrayIndexOutOfBoundsException java.lang ArithmeticException java.lang ClassCastException java.lang IllegalArgumentException java.lang NumberFormatException java.lang ... NegativeArraySizeException java.lang NoSuchElementException java.util NullPointerException java.lang IOException java.io EOFException java.io FileNotFoundException java.io AWTException java.awt

A kivételosztályok deklarációi +RuntimeException() +RuntimeException(m: String) java::lang::RuntimeException IOException() IOException(m: String) java::io::IOException +Exception() +Exception(m: String) java.lang::Exception -detailMessage: String +Throwable() +Throwable(message: String) +getMessage():String +getLocalizedMessage(): String +printStackTrace() +toString(): String ... java::lang::Throwable A kivételosztályok deklarációi

Kivételek keletkezése és szándékos előidézése – throw Kivétel kiváltása: kivételobjektum létrehozása és bedobása (throw) a program vérkeringésébe Ki váltja ki? API metódus programozó Szintaktika: throw new <Kivételosztály>(<információs szöveg>); throw new ArithmeticException("Osztás nullával!"); throw new TulNagyException("Túl nagy szám!");

Feladat – Kivétel útja Keltsünk szándékosan futási hibát az ábrán látható módon! Kövessük a kivétel kiszállásának útját! KivetelUtja.m1() ... Masik.m2() KivetelUtja.main(...) m1()  A program futása: java.lang.RuntimeException: Rosszalkodas at Masik.m2(KivetelUtja.java:4) at KivetelUtja.m1(KivetelUtja.java:10) at KivetelUtja.main(KivetelUtja.java:13) Exception in thread "main"

class Masik { static void m2() { throw new RuntimeException("Rosszalkodas"); } public class KivetelUtja { static void m1() { Masik.m2(); public static void main(String[] args) { m1();

A kivétel továbbadása – throws Ellenőrzött kivételekkel a metódushívási lánc minden metódusában foglalkoznunk kell Két lehetőségünk van: a metódusban kezeljük a kivételt a kivételt továbbadjuk a hívó metódusnak Kivétel továbbadásának jelzése a metódusfejben: throws <Kivételosztály1, Kivételosztály2,... > throws Exception A kivételosztályok továbbadáskor nem szűkíthetők!

Feladat – Ellenőrzött kivétel továbbadása Idézzünk elő egy main által hívott metódusban egy ellenőrzött, IOException típusú kivételt. import java.io.*; public class EllenorzottDobas { static void metodusA() throws IOException { throw new IOException("Számot kérek!"); } public static void main (String args[]) throws IOException { metodusA(); A program futása: java.io.IOException: Számot kérek! at EllenorzottDobas.metodusA(EllenorzottDobas.java:5) at EllenorzottDobas.main(EllenorzottDobas.java:9) Exception in thread "main"

A kivétel elkapása, kezelése try-catch-finally szerkezet try { // try blokk <utasítások> } catch (<Kivételosztály1> <obj1>) { // catch blokk … catch (<KivételosztályN> <objn>) { // catch blokk finally { // finally blokk

try blokk catch blokk finally blokk Kivételek keletkezésének feltételezett helye catch blokk Kivétel kezelése az érkező kivételobjektum alapján Aktuális (érkező) kivételobjektum értékadási kompatibilitás: formális kivételobjektum = aktuális kivételobjektum manipulálható, a blokk végén elpusztul Működése legfeljebb egy catch blokk hajtódik végre sorrend: egyre általánosabb kivételek definiálandók nincs kezelve  továbbadódik a hívó metódusnak finally blokk Minden körülmények között végrehajtódik

A kivétel elkapásának útja metodusB() throws IOException metodusA() utasítások metodusC() ... main() IOException try catch (IOException) catch (Exception) finally Itt keletkezik Itt kezeljük Itt már nem kell throws, mert kezeljük a kivételt

Saját kivételek Feladat – Saját kivétel alkalmazása Írjunk egy readSzam(tol,ig) függvényt, amely bekér egy egész számot valamilyen megadott zárt tartományból (tol lehet nagyobb is, mint ig)! Addig kérjünk számot, ameddig az végre a megadott tartományba esik. Ha a szám kívül esik rajta, akkor a metódus ejtsen egy saját (vagyis nem API-beli) OutOfRangeException kivételt és az abba foglalt információs szöveg közölje a megkövetelt határokat!

import extra.*; class OutOfRangeException extends RuntimeException { OutOfRangeException(String s) { super(s); } public class SajatKivetel { static int readSzam(int tol, int ig) { if (tol > ig) { int seged=tol; tol=ig; ig=seged; } int szam;

while (true) { try { szam = Integer.parseInt(Console.readLine("Szám: ")); if (szam < tol || szam > ig) throw new OutOfRangeException(tol+"-től "+ig+"-ig!"); return szam; } // try catch (NumberFormatException ex) { System.out.println("Illegális karakter!"); } catch (OutOfRangeException ex) { System.out.println(ex.getMessage()); } // while

} // readSzam public static void main (String args[]) { int lottoSzam = readSzam(1,90); System.out.println("OK"); } // main } // SajatKivetel