angster erzsébet: oo tervezés és programozás, java ii ...angster erzsébet: oo tervezés és...

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és

1. 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áscsomag1 csomag2

csomag12csomag11

csomag121

Osztaly3

Interfesz

Osztaly1

Osztaly4

Osztaly5

Osztaly2


Könyvtárstruktúra

csomag1 csomag2

csomag11 csomag12

Interfesz.class

Osztaly1.class

Osztaly2.class

Osztaly4.class

csomag121

Osztaly3.class

Osztaly5.class

classes

CsomagApp

src

csomag1 csomag2

csomag11 csomag12

Interfesz.java

Osztaly2.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ása

UML: 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 JBuilderben

Projekt (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.bat

javac -sourcepath src -d classes -classpath .

@Files.txt


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

JAR fájl összeállítása parancssorból

jar 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ása

java –jar CsomagApp.jar


2. Öröklődés1. 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

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


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;

}


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

}


C2(int a, int b) {super(a);}

C2(int a) {this(a,1);}

C2() {this(2);}

}


C3(int a, int b) { }

C3(int a) {this(a,3);}

}

Példa



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()

terfogat()

toString()

terfogat()

toString()

Zsolt

Szövegdoboz

Polimorfizmus azt jelenti, hogy ugyanarra az üzenetre különböző objektumok különbözőképpen reagálnak. Minden objektum, a saját osztályának megfelelő metódust hajt végre.


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!


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

Csomaghierarchia:

• QueueApp

• extra

• util

• IQueue

• ICleverQueue

• Queue

• CleverQueue


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

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 {


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



}


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



}

…

} // 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évelclass Ember { … } // Ember.class

public class NevtelenKiterjesztes {

// NevtelenKiterjesztes.class


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ávalinterface Jellemzett { // Jellemzett.class

public String jellemzo();

}

public class NevtelenImplementacio {

// NevtelenImplementacio.class


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, melyekosztá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öbbiException)


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


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ése

try-catch-finally szerkezettry { // 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 IOExceptionmetodusA()

utasítások

metodusC()

...

utasítások

main()

utasítások

metodusA()

...

utasítások

...

utasítások

IOException

utasítások

metodusC()

throws IOException

utasítások

try

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;

} // try

catch (NumberFormatException ex) {

System.out.println("Illegális karakter!");

}

catch (OutOfRangeException ex) {

System.out.println(ex.getMessage());

}

} // while


} // readSzam


int lottoSzam = readSzam(1,90);

System.out.println("OK");

} // main

} // SajatKivetel

angster erzsébet: oo tervezés és programozás, java ii ...angster erzsébet: oo tervezés és...

Documents