A Java programozási nyelv kivételeket használ a hibák és más kivételes események kezelésére.
A kivétel egy olyan esemény, amely a program végrehajtása során történik, és megzavarja az utasítások normál menetét. A kivételeket a Java-ban explicit módon dobják, és a kivétel dobásának műveletét kivételdobásnak nevezik. A kivétel kezelésének műveletét kivétel elkapásának nevezik.
A Java-ban minden kivétel az Exception osztály alosztálya, amely maga a Throwable alosztálya.
A Java kétféle kivételt különböztet meg:
Az ellenőrzött kivételek olyan kivételes állapotok, amelyekre az alkalmazásnak számítania kell, és amelyekből helyre kell állnia.
Példa ellenőrzött kivételre a FileNotFoundException, amely akkor fordul elő, amikor egy metódus egy nem létező fájlt próbál beolvasni.
Ez a típusú kivétel fordítási időben ellenőrzésre kerül: azoknak a metódusoknak, amelyek ellenőrzött kivételt dobnak, ezt a metódusuk szignatúrájában meg kell adniuk, és az olyan kódnak, amely olyan metódust hív meg, amely ellenőrzött kivételt dobhat, kezelnie kell azt, különben a kód nem fordul le.
Minden ellenőrzött kivétel az Exception olyan alosztálya, amely nem származik a RuntimeException-ból.
A nem ellenőrzött kivételek olyan kivételes állapotok, amelyekre az alkalmazás általában nem tud számítani, és amelyekből nem tud helyreállni.
Példa nem ellenőrzött kivételre a NullPointerException, amely akkor fordul elő, amikor egy metódus nem null értéket vár, de null-t kap.
Ez a típusú kivétel nincs ellenőrizve fordítási időben: azoknak a metódusoknak, amelyek nem ellenőrzött kivételt dobnak, nem kell ezt a metódusuk szignatúrájában megadniuk, és az olyan kódnak, amely olyan metódust hív meg, amely nem ellenőrzött kivételt dobhat, nem kell kezelnie azt.
Minden nem ellenőrzött kivétel a RuntimeException-ból származik, amely maga az Exception kiterjesztése.
Egy metódus a Java-ban a throw utasítás használatával dobhat kivételt.
Amikor egy metódusból ellenőrzött kivételt dobunk, ezt a metódus szignatúrájában a throws kulcsszó használatával meg kell adni, ahogy az alábbi példa mutatja.
Ez arra kényszeríti a hívó kódot, hogy számítson arra, hogy kivétel dobható, és ennek megfelelően kezelje azt.
public class InsufficientBalanceException extends Exception {
}
public class BankAccount {
public void withdraw(double amount) throws InsufficientBalanceException {
if (balance < amount) {
throw new InsufficientBalanceException();
}
// rest of the method implementation
}
}
Amikor egy metódusból nem ellenőrzött kivételt dobunk, nem kötelező ezt a metódus szignatúrájában megadni, bár támogatott.
public class BankAccount {
public void withdraw(double amount) {
if (amount < 0) {
throw new IllegalArgumentException("Cannot withdraw a negative amount");
}
// rest of the method implementation
}
}
A kivételek kezelése a Java-ban a try, catch és finally kulcsszavakkal történik.
try blokkba kell csomagolni.try blokkot egy vagy több catch blokk követi, amelyek elkapják a try blokkban dobott kivételeket.catch blokkokat opcionálisan egy finally blokk követi, amely mindig végrehajtódik a try blokk után, függetlenül attól, hogy történt-e kivétel vagy sem.A következő példa bemutatja, hogyan működnek ezek a kulcsszavak:
public class ATM {
public void withdraw(BankAccount bankAccount, double amount) {
try {
System.out.println("Withdrawing " + amount);
bankAccount.withdraw(amount);
System.out.println("Withdrawal succeeded");
} catch (InsufficientBalanceException) {
System.out.println("Withdrawal failed: insufficient balance");
} catch (RuntimeException e) {
System.out.println("Withdrawal failed: " + e.getMessage());
} finally {
System.out.println("Current balance: " + bankAccount.getBalance());
}
}
}
Ebben a példában, amikor nem dobódik kivétel, a következő kerül kiírásra:
Withdrawing 10.0
Withdrawal succeeded
Current balance: 5.0
Ha azonban a bankAccount.withdraw(amount) utasítás InsufficientBalanceException-t dob, a következő kerül kiírásra:
Withdrawing 10.0
Withdrawal failed: insufficient balance
Current balance: 5.0
Vagy abban az esetben, ha a bankAccount.withdraw(amount) nem ellenőrzött kivételt dob, a következő kerül kiírásra:
Withdrawing -10.0
Withdrawal failed: Cannot withdraw a negative amount
Current balance: 5.0
A Java-nak van egy külön kategóriája is, amelyet hibáknak neveznek; ezek olyan súlyos problémák, amelyek az alkalmazáson kívül vannak.
Példa hibára a OutOfMemoryError, amely akkor fordul elő, amikor egy alkalmazás több memóriát próbál használni, mint amennyi a rendszerben elérhető.
A nem ellenőrzött kivételekhez hasonlóan a hibák sincsenek ellenőrizve fordítási időben. A különbség az, hogy rendszerszintű problémákat képviselnek, és általában a Java virtuális gép vagy a környezet dobja őket, nem az alkalmazás. Az alkalmazásoknak általában nem kell megpróbálniuk elkapni vagy kezelni őket.
A Java-ban minden hiba az Error osztályból származik.
Ebben a feladatban egy egyszerű, egész számokkal dolgozó számológép hibakezelését építed meg. Hogy egyszerűbb legyen a helyzet, az összeadást, a szorzást és az osztást végző metódusokat előre megkaptad.
A cél egy működő számológép, amely a következő formátumú Stringet adja vissza: 16 + 51 = 67, ha a 16, 51 és + argumentumokat kapja.
CalculatorConundrum calculator = new CalculatorConundrum();
calculator.calculate(16, 51, "+");
// => returns "16 + 51 = 67"
calculator.calculate(32, 6, "*");
// => returns "32 * 6 = 192"
calculator.calculate(512, 4, "/");
// => returns "512 / 4 = 128"
Ebben a részfeladatban a fő megvalósítandó metódus a CalculatorConundrum.calculate() lesz.
Három argumentumot vár.
Az első két argumentum, az operand1 és az operand2, egész számok, amelyeken egy műveletet fogunk elvégezni.
A harmadik argumentum, az operation, String típusú, és ebben a feladatban a következő műveleteket kell megvalósítanod:
+ String segítségével* String segítségével/ String segítségévelFrissítsd a CalculatorConundrum.calculate() metódust, hogy kezelje a szabálytalan műveleteket:
operation argumentum null, akkor IllegalArgumentException-t kell dobni a Operation cannot be null üzenettel.operation argumentum "", akkor IllegalArgumentException-t kell dobni a Operation cannot be empty üzenettel.operation argumentum bármi más, mint a +, * vagy /, akkor IllegalOperationException-t kell dobni a Operation '{operation}' does not exist üzenettel.calculator.calculate(10, 1, null);
// => throws IllegalArgumentException with message "Operation cannot be null"
calculator.calculate(10, 1, "");
// => throws IllegalArgumentException with message "Operation cannot be empty"
calculator.calculate(10, 1, "-");
// => throws IllegalOperationException with message "Operation '-' does not exist"
Java-ban a nullával való osztás ArithmeticException kivételt dob.
Frissítsd a CalculatorConundrum.calculate() metódust, hogy elkapja ezt a kivételt, majd dobjon IllegalOperationException-t a Division by zero is not allowed üzenettel, kiváltó okként pedig adja meg az elkapott ArithmeticException-t.
calculator.calculate(512, 0, "/");
// => throws IllegalOperationException with message "Division by zero is not allowed"
Iratkozz fel az Exercism-re, hogy megtanuld és elsajátítsd a(z) Java nyelvet 26 fogalom158 feladat segítségével, valódi emberi mentorálással, mindez ingyen.