Angster Erzsébet: OO tervezés és programozás, Java II. kötet alapján

Gábor Dénes Főiskola (IAI)

Programozási technológia (Java) - I. / 1

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



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



1. Csomagolás, projektkezelés

2. Öröklődés

3. Interfészek, belső osztályok

4. Kivételkezelés



1. Csomagolás, projektkezelés1. Csomagolás

2. Projektkezelés a JBuilderben

3. JAR-állomány készítése

4. Java program futtattása



Csomagolás

Csomag (package) Összetartozó osztályok és interfészek csoportja Logikai és fizikai szintű csoportosítás

csomag1 csomag2

csomag12csomag11

csomag121

Osztaly3

Interfesz

Osztaly1

Osztaly4

Osztaly5

Osztaly2



Könyvtárstruktúra

csomag1 csomag2

csomag11 csomag12

Interfesz.classOsztaly1.classOsztaly2.class

Osztaly4.class

csomag121

Osztaly3.class

Osztaly5.class

classes

CsomagApp

src

csomag1 csomag2

csomag11 csomag12

Interfesz.javaOsztaly2.java

Osztaly4.java

csomag121

Osztaly3.java

Osztaly5.java

Forrásútvonal Célútvonal

Projektfájl

CsomagApp.jpx

Projektkönyvtár



Csomag megadása package csomag1.csomag12.csomag121;

Csomag azonosításaUML: csomag1::csomag12::csomag121

Java: 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

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

Projekt (project)



Projektkezelés JBuilderbenProjekt (project) összetartozó osztályok és interfészek csoportja logikai és fizikai szintű csoportosítás

Tartalompanel

Projektpanel

Struktúrapanel

Üzenetpanel



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.batjavac -sourcepath src -d classes -classpath . @Files.txt



JAR-állomány készítése

JAR fájl összeállítása parancssorbóljar cfm CsomagApp.jar meta-inf\manifest.mf –C classes .

JAR (Java ARchive) Egy Java projekt fájljait tömörítő állomány Manifest (aláírásfájl, manifest.mf)

JAR fájl futtatásajava –jar CsomagApp.jar



2. Öröklődés1. Az öröklődés fogalma2. Mintafeladat – Hengerprogram3. Az objektumreferencia statikus és dinamikus típusa4. Az utódosztály adatai és kapcsolatai5. Metódusok felülírása, dinamikus és statikus kötés6. this és super referenciák7. this és super konstruktorok – konstruktorok láncolása8. Polimorfizmus9. Absztrakt metódus, absztrakt osztály10. Láthatóság11. Ö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

Feladat – HengerprogramKü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

*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+toString(): String

Cso

-falVastagsag: double

+Cso(sugar,magassag,fajsuly,falVastagsag: double)+Cso(sugar,magassag,falVastagsag: double)+getFalVastagsag(): double+terfogat(): double+toString(): String



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!



Automatikus típuskonverzió felfelé (upcasting)String str = "Kakukk";

System.out.println(str.toLowerCase()); // OK

Object obj = str; //

StringObject

//System.out.println(obj.toLowerCase()); Fordítási hiba!

instanceof operátorObject obj = new String("Valami");

if (obj instanceof Object) ... // true

if (obj instanceof String) ... // true

if (obj instanceof Integer) ... // false

if ("Semmi" instanceof String) ... // true



Típuskonverzió lefelé (downcasting)

Object obj = "Kakas"; // String Object

Integer iObj = (Integer)obj; // Object Integer (!)

System.out.println(iObj.intValue());

// ClassCastException!

Object obj = "Szoveg"; // String Object

String str = (String)obj; // Object String

// String str = obj; Fordítási hiba!



Az utódosztály adatai és kapcsolatai

h : Henger

sugar = 1

magassag = 4

r : Rud

sugar = 0.5

magassag = 4

fajsuly = 2

cso : Cso

sugar = 5

magassag = 5

fajsuly = 0.5

falVastagsag = 2

Henger

-sugar: double

-magassag: double

Rud

-fajsuly: double

Cso

-falVastagsag: double

Példányadatok memóriafoglalása



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 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); }}

class C1 { static String s = "C1 "; int a = 1; int b = 10;}

class C2 extends C1 { int a = 2;}



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

m2()

obj2:C2

obj1:C1

m1()

m1()



Az osztálymetódus statikus kötése

C1

m1() {m2()}m2()

C2

m2()

obj2:C2

obj1:C1

m1()

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

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

Minden osztálynak van saját konstruktora A konstruktor nem öröklődik, és nem lehet felülírni



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 :Henger :Cso:Rud

: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 – FaIdomokEgy 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!



Osztálydiagramidomok

*-idomok{Vector}

Hasab

-a,b,magassag: double

+Hasab(a,b,magassag:double)+terfogat(): double+toString(): String

Gomb

-sugar: double

+Gomb(sugar:double)+terfogat(): double+toString(): String

FaIdomok

+FaIdomok()+osszSuly(): double+osszGombSuly(): double+run() +main(...)

java::lang::Comparable

Idom { abstract }

-fajsuly: double = 0.8

+terfogat(): double+suly(): double+compareTo(obj:Object): int

java::lang::Object



3. Interfészek, belső osztályok1. 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



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, QueueAppA 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! 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álydiagramextra::util

«interfész»IQueue

+put(Object)+get(): Object+isEmpty(): boolean

QueueApp

+main(...)+processQueue(ICleverQueue)

«interfész»ICleverQueue

+remove(int)+size(): int

java::lang::Object

Queue

+put(Object)+get(): Object+isEmpty(): boolean

CleverQueue

+remove(int)+size(): int

ForráskódokProjekt: QueueAppCsomaghierarchia:• QueueApp• extra

• util• IQueue• ICleverQueue• Queue• CleverQueue



IQueue.javapackage extra.util;public interface IQueue {

void put(Object o);Object get();boolean isEmpty();

}

ICleverQueue.javapackage extra.util;public interface ICleverQueue extends IQueue {

void remove(int n);int size();

}



Queue.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ámlaKé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 – UdvarAppEgy 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));



}



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

public String toString() {

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 – UdvarApp2Oldjuk 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.classpublic String jellemzo();

}public class NevtelenImplementacio {

// NevtelenImplementacio.classpublic static void main(String[] args) {

Jellemzett jel = new Jellemzett() {public String jellemzo() {

return "Szép";}

}); … // NevtelenImplementacio$1.class}

}



4. Kivételkezelés1. 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

...



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 útjaKeltsü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()...

... ...

Masik.m2()

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ásaIdé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ésetry-catch-finally szerkezet

try { // try blokk <utasítások>

}catch (<Kivételosztály1> <obj1>) { // catch blokk

<utasítások>}…catch (<KivételosztályN> <objn>) { // catch blokk

<utasítások>}finally { // finally blokk

<utasítások>}



try 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ásokmetodusC()...utasítások

main()

utasításokmetodusA()...utasítások...

utasítások IOExceptionutasítások

metodusC()throws IOException

utasításoktry metodusB() ...catch (IOException)

catch (Exception)

finally

Itt keletkezikItt 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;

} // trycatch (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

Angster Erzsébet: OO tervezés és programozás, Java II. kötet alapján

Documents