Uma excepção (Exception) é um sinal gerado pelo interpretador do JAVA em tempo de execução (runtime) que é comunicado ao programa como sendo um erro recuperável;
Um erro em JAVA surge quando não existe recuperação possível levando a aplicação a terminar com a indicação do erro.
As excepções e erros são subclasses da classe java.lang.Throwable;
São as classes de topo das respectivas hierarquia
Fluxo de uma excepção
1. Quando um erro ocorre num método JAVA, o interpretador cria um objecto da classe exception e entrega-o ao runtime (chama-se fazer o throw da exception);
2. O objecto exception contém:
2.1. O tipo de excepção
2.2. O estado do programa quando o erro ocorreu
3. O runtime tem então de encontrar o código que deve ser aplicado quando ocorre um erro deste tipo;
4. O runtime procura para a frente, a partir do método corrente, até encontrar um tratador da excepção;
Manipulação de excepções
A manipulação de excepções no JAVA é efectuada através do uso de cinco palavras reservadas:
* try: precede o código crítico;
* catch: “apanha” uma excepção;
* throw: despoleta uma excepção;
* throws: indica que um método despoleta uma excepção;
* finally: código sempre executado.
Estrutura de um try-catch:
try {
//bloco de código
} catch(ExceptionType1 e1) {
//código para gerir a excepção de tipo ExceptionType1
} catch(ExceptionType2 e2) {
//código para gerir a excepção de tipo ExceptionType2
} …
finally{
//código para a finalização
}
Sobre o finally
* É uma zona de código de “limpeza”;
* Evita repetição de código de “limpeza”;
* É executado quando:
* Tudo funciona bem;
* Uma excepção (não) é “apanhada” por um catch;
* Não é obrigatório colocar.
Criação de excepções
Para despoletar excepções de situações diversas pode-se
usar a classe Exception.
Ex:
throw new Exception(“Erro na leitura do ficheiro”);
Além das excepções do JAVA existe a possibilidade do
programador criar as suas.
Ex:
public class ExceptionFicheiro extends Exception{
public ExceptionFicheiro() { super()};
public ExceptionFicheiro(String msg) { super(msg);}
}
Uma excepção é uma classe “normal”!
Vantagens das excepções
* Separar código normal do código de gestão de erros;
* Permitir a propagação de erros pela aplicação;
* Re-aproveitar excepções já existentes;
* Agrupar erros por tipos.
Onde é Utilizado algumas excepções..
Para este projecto criei 2 package o Room e o rooms.exceptions (onde coloquei as Excepções)
No pakage Room...
/*
* class Room
*/
package rooms;
public class Room {
private int number;
private boolean occupied;
public Room(int number) {
this.number=number;
this.occupied=false;
}
public int getNumber() {
return number;
}
public boolean isOccupied() {
return occupied;
}
public void setOccupied(boolean occupied) {
this.occupied = occupied;
}
public String toString() {
return "Room number: " + number + ", Occupied: " + occupied;
}
}
/*
*class Hotel
*/
package rooms;
import java.util.ArrayList;
import rooms.exceptions.HotelException;
import rooms.exceptions.RoomNotFoundException;
import rooms.exceptions.RoomUnavailableException;
import rooms.exceptions.SizeException;
public class Hotel extends ArrayList<Room>{
private int roomNumbers;
private String hotelName;
public Hotel() {
this("N/A", 10);
}
public Hotel(String name, int size){
super();
this.hotelName=name;
this.roomNumbers=size;
}
public void add(Room ... rooms) throws SizeException {
for (Room e : rooms) {
if (this.size() < roomNumbers)
this.add(e);
else throw new SizeException();
}
}
public Room getRoom(int roomNumber) throws RoomNotFoundException {
for (int i=0; i<roomNumbers; i++)
if (((Room)this.get(i)).getNumber()==roomNumber) return this.get(i);
throw new RoomNotFoundException("Room: " + roomNumber + " not found.");
}
public void reservaRoom(int roomNumber) throws HotelException {
Room r = getRoom(roomNumber);
if (r.isOccupied()) throw new RoomUnavailableException("Room: " + roomNumber + " occupied.");
else r.setOccupied(true);
}
public void cancelReservation(int roomNumber) throws RoomNotFoundException {
Room r = getRoom(roomNumber);
r.setOccupied(false);
}
public void checkOut(int roomNumber) throws RoomNotFoundException {
cancelReservation(roomNumber);
}
public String toString() {
String exit="Hotel " + hotelName + ", Capacity: " + roomNumbers + "\n";
for (int i=0; i<roomNumbers; i++)
exit+= ((Room)this.get(i)).toString() + "\n";
return exit;
}
}
* class HotelMain
*/
package rooms;
import rooms.exceptions.HotelException;
import rooms.exceptions.RoomNotFoundException;
import rooms.exceptions.SizeException;
public class HotelMain {
public static void main(String[] args) {
int hotelSize=5;
Hotel h=new Hotel("Alg@rve", hotelSize);
for (int i=0; i<hotelSize - 2; i++)
h.add(new Room(100+i));
Room r=new Room(103);
Room r1=new Room(104);
try {
h.add(r, r1);
}
catch(SizeException s) {
System.out.println(s);
}
System.out.println(h);
try {
// vamos provocar uma excepção: substituir 100 por 110
h.reservaRoom(100);
System.out.println(h);
h.reservaRoom(102);
// vamos reservar o mesmo quarto: qual a excepção despoletada?
// h.reservaRoom(102);
System.out.println(h);
h.cancelReservation(100);
h.checkOut(102);
}
catch(RoomNotFoundException re) {
System.out.println(re);
}
catch(HotelException e) {
System.out.println(e);
}
System.out.println(h);
}
}
/*
* class HotelException
*/
package rooms.exceptions;
public class HotelException extends Exception {
public HotelException() {
super();
}
public HotelException(String msg) {
super(msg);
}
}
/*
*class RoomException
*/
package rooms.exceptions;
public class RoomException extends HotelException {
public RoomException() {
super();
}
public RoomException(String msg) {
super(msg);
}
}
/*
* Class RoomNotFoundException
*/
package rooms.exceptions;
public class RoomNotFoundException extends RoomException {
public RoomNotFoundException() {
super();
}
public RoomNotFoundException(String msg) {
super(msg);
}
}
/*
* class RoomUnavailableException
*/
package rooms.exceptions;
public class RoomUnavailableException extends RoomException {
public RoomUnavailableException() {
super();
}
public RoomUnavailableException(String msg) {
super(msg);
}
}
/*
* class SizeException
*/
package rooms.exceptions;
public class SizeException extends HotelException {
public SizeException() {
super("Invalid size.");
}
}
Download project
Download by speedyshare
