Scribd
Upload
75 views4 pages

Laborator 8. Programare Orientata Obiect: Crearea Unei Exceptii. Aruncarea Exceptiei. Prinderea Si Tratarea Exceptiei

The document discusses exceptions in Java programming. It covers: 1. Creating a custom exception class that extends Exception, throwing and catching exceptions. 2. Creating an exception class with a string attribute to pass a message, and demonstrating it in a try-catch block. 3. Using logging to record exception details. 4. Rethrowing exceptions to maintain the stack trace. 5. Chaining exceptions so that the cause of one exception becomes the argument of another.

Uploaded by

Cristina Ungurean
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
75 views4 pages

Laborator 8. Programare Orientata Obiect: Crearea Unei Exceptii. Aruncarea Exceptiei. Prinderea Si Tratarea Exceptiei

The document discusses exceptions in Java programming. It covers: 1. Creating a custom exception class that extends Exception, throwing and catching exceptions. 2. Creating an exception class with a string attribute to pass a message, and demonstrating it in a try-catch block. 3. Using logging to record exception details. 4. Rethrowing exceptions to maintain the stack trace. 5. Chaining exceptions so that the cause of one exception becomes the argument of another.

Uploaded by

Cristina Ungurean
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

Laborator 8.

Programare orientata obiect

1. Crearea unei exceptii. Aruncarea exceptiei. Prinderea si tratarea exceptiei


class SimpleException extends Exception {}

public class InheritingExceptions {


public void f() throws SimpleException { // metoda este susceptibila sa arunce o exceptie
System.out.println("Throw SimpleException from f()");
throw new SimpleException(); // se arunca exceptia
}
public static void main(String[] args) {
InheritingExceptions sed = new InheritingExceptions();
try { // regiune guardata
sed.f();
} catch(SimpleException e) { // exceptia este prinsa si rezolvata
System.err.println("Caught it!");
}
}
}

2. Se doreste crearea unei exceptii proprii care sa fie insotita de un mesaj. Creati o clasa de tip exceptie
cu un atribut de tip String. Scrieti un constructor pentru aceasta clasa care sa preia un argument de
tip String cu care sa se initializeze atributul din clasa exceptie. Scrieti o metoda a clasei de tip
exceptie care sa afiseze stringul agregat. Creati un cod de tip try-catch in care sa demonstrati
functionalitatea creata.

3. Utilizarea logging
import java.util.logging.*;
import java.io.*;
class LoggingException extends Exception {
//asociem un obiect logger cu clasa Exceptie curenta
private static Logger logger = Logger.getLogger("LoggingException");
public LoggingException() { // constructor - se va executa ori de cate ori apare o exceptie
StringWriter trace = new StringWriter();
printStackTrace(new PrintWriter(trace));
logger.severe(trace.toString());
}
}
public class LoggingExceptions {
public static void main(String[] args) {
try {
throw new LoggingException(); //se executa constructorul exceptiei
//executia sare la catch
} catch(LoggingException e) {
System.err.println("Caught " + e);
}
}}
4. Rearuncarea unei exceptii
public class Rethrowing {
public static void f() throws Exception {
System.out.println("originating the exception in f()");
throw new Exception("thrown from f()");
}
public static void g() throws Exception {
try {
f();
} catch(Exception e) {
System.out.println("Inside g(),e.printStackTrace()");
e.printStackTrace(System.out);
throw e; //rearuncarea exceptiei
}
}
public static void h() throws Exception {
try {
f();
} catch(Exception e) {
System.out.println("Inside h(),e.printStackTrace()");
e.printStackTrace(System.out);
throw (Exception)e.fillInStackTrace();
}
}
public static void main(String[] args) {
try {
g();
} catch(Exception e) {
System.out.println("main: printStackTrace()");
e.printStackTrace(System.out);
}
try {
h();
} catch(Exception e) {
System.out.println("main: printStackTrace()");
e.printStackTrace(System.out);
}
}
}

5. Inlantuirea exceptiilor
class DynamicFieldsException extends Exception {}

public class DynamicFields { //simularea adaugarii atributelor dinamice la un obiect


private Object[][] fields; //perechi de tip Object-Object (camp-valoare)
public DynamicFields(int initialSize) { //alocare numar atribute
fields = new Object[initialSize][2];
for(int i = 0; i < initialSize; i++)
fields[i] = new Object[] { null, null };
}
public String toString() { //conversie a obiectului la String
StringBuilder result = new StringBuilder();
for(Object[] obj : fields) {
result.append(obj[0]);
result.append(": ");
result.append(obj[1]);
result.append("\n");
}
return result.toString();
}
private int hasField(String id) { //verifica daca exista atributul in obiect
for(int i = 0; i < fields.length; i++)
if(id.equals(fields[i][0]))
return i; //returneaza pozitia pe care il gaseste
return -1;
}
private int getFieldNumber(String id) throws NoSuchFieldException {
int fieldNum = hasField(id);
if(fieldNum == -1)//daca nu gaseste campul in obiect =>Exceptie
throw new NoSuchFieldException();
return fieldNum;
}
private int makeField(String id) {
//adauga un atribut la obiect daca nu are spatiu alocat
for(int i = 0; i < fields.length; i++)
if(fields[i][0] == null) {
fields[i][0] = id;
return i;
}
// No empty fields. Add one:
//se realoca memorie
Object[][] tmp = new Object[fields.length + 1][2];
for(int i = 0; i < fields.length; i++) //se copiaza atributele existente
tmp[i] = fields[i]; //in noul vector largit
for(int i = fields.length; i < tmp.length; i++)
tmp[i] = new Object[] { null, null }; //se initializeaza spatiile noi
fields = tmp;
// Recursive call with expanded fields –dupa realocare se face apel pentru stocarea noului camp.
return makeField(id);
}
public Object getField(String id) throws NoSuchFieldException {
return fields[getFieldNumber(id)][1];//daca nu gaseste atributul =>Exceptie
}
public Object setField(String id, Object value) throws DynamicFieldsException {
if(value == null) {
// Most exceptions don’t have a "cause" constructor.
// In these cases you must use initCause(),
// available in all Throwable subclasses.
//seteaza valoarea unui atribut
//daca valoarea e null => exceptie
DynamicFieldsException dfe = new DynamicFieldsException();

//se seteaza o exceptia de tip cauza care a determinat aruncarea exceptiei dfe
dfe.initCause(new NullPointerException()); throw dfe;
}
//daca valoarea nu e null
//se atribuie valoarea campului
int fieldNumber = hasField(id);
if(fieldNumber == -1) //daca atributul nu exista se creaza
fieldNumber = makeField(id);

Object result = null;


try {
result = getField(id); // Get old value
} catch(NoSuchFieldException e) { //e este exceptia cauza - ce genereaza aruncarea alteia
// Use constructor that takes "cause":
throw new RuntimeException(e);
}
fields[fieldNumber][1] = value; //setarea valorii
return result;
}

public static void main(String[] args) {


DynamicFields df = new DynamicFields(3);
System.out.println(df);
try {
df.setField("d", "A value for d");
df.setField("number", 47);
df.setField("number2", 48);
System.out.println(df);
df.setField("d", "A new value for d");
df.setField("number3", 11);
System.out.println("df: " + df);
System.out.println("df.getField(\"d\") : " + df.getField("d"));
Object field = df.setField("d", null); // Exception
} catch(NoSuchFieldException e) {
e.printStackTrace(System.out);
} catch(DynamicFieldsException e) {
e.printStackTrace(System.out);
}
}
}

You might also like