[js-mueller]

Hi, da ich kein allgemeines Programmierforum gefunden hab schreib ichs mal hier rein.

Also ich möchte mir gerne eine Klasse zur fehlerverarbeitung bauen und ich wollte gerne mal wissen wie ihr so eine Klasse bei euch aufbaut was sie alles können sollte usw.
Ich hab mir erstma vorgestellt as die KLasse fehler annehmen und ausgeben können sollte.
Aber was gibts noch für sachen die vieleicht wichtig wären? Bin grad erst neu auf dem gebiet vorausschauend Klassen zu entwerfen.

[Xean]

hi, wie wäre es mit einer Klasse, die von Throwable erbt.
Dann kann man im code verwenden:

try{
    //...
}catch(DeineThrowAbleKlasse e){
   //...
}

Und dann kannst du alle exceptions "lokal" behandeln.

[VolkerK]

@Xean: DeineThrowAbleKlasse, weist welchen Vorteil bereits existierenden Klassen gegenüber auf?

@js-mueller: Ich verstehe noch nicht, welchen Nutzen Du Dir von so einer Klasse (oder vielleicht sogar mehreren) versprichst. Bitte genauer darlegen, denn Klassenschreiben ist kein Selbstzweck

[Xean]

ich weiß ja nicht, was js-mueller daraus dann macht, ob er jetzt eine klasse will, die über alle exceptions bescheit weiß oder ob er auf eine exception automatisch reagiert, ohne dass es in der catch-schleife steht (z.B. ein Fenster öffnen, in der die fehlernachricht steht)

[js-mueller]

Also im prinzip soll die Klasse Fehlermeldungen aufnehmen und später ausgeben lassen können.
Also mein Programm schmeißt fehler wie z.B. nen mysql fehler "feld nicht gefundne ...". Das wird dann an die Klasse geschickt und die Klasse speichert das. Und ich kann dann die letzten 25 meldungen oder so abrufen.
Ich hab die klasse grad auch soweit fertig nur ein Problem hab ich grad.

Und zwar wenn ich die letzten 25 meldungen speichere. Kann ja sein das die 25 voll sind und dann die alten gelöscht werden müssen.
Ich hab mir gedacht ich schreib ne for schleife mit der ich die daten im array um einen verschiebe und dann die neue meldungen auf [0] schreibe, aber das ist doch sicher sehr performance lastig oder?

[pago]

Ähm... für sowas verwendet man normalerweise eine Logger-Klasse (z.B. java.util.logging). Wie dem auch sei: Statt mit nem Array zu arbeiten würde ich an deiner Stelle nen Stack oder eine ArrayList verwenden (beide zu finden in java.util).

[js-mueller]

K guck ich mir die beiden sachen mal an.
Was ist denn eine loggerklasse, was macht die?

[Xean]

keine ahnung, aber wenn du mit ArrayList abeitest dann könnte das so aussehen:

PHP-Code:

ArrayList exceptionList = new ArrayList();
int maxEinträge = 20;

public void addException(String msg){
   exceptionList .add(msg);
   if(exceptionList .size() > maxEinträge){
       exceptionList .remove(0);
   }
} 


[pago]

Nehmen wir an, du hast ne hübsche Stack-Klasse (die, die ich jetzt gleich poste, ist effektiver, als die Standard-Klasse

public class ExceptionStack {
	private StackItem head;
	private int limit;
	private int size;
	
	public ExceptionStack() {
		limit = 25;
		size  =  0;
	}
	
	public void push(Throwable t) {
		// we've reached the limit
		if(size == limit) {
			pop();
		} else if(size == 0) {
			head = new StackItem();
			head.item = t;
		} else {
			StackItem last = head;
			// find the last item in Stack
			while(last.next != null) {
				last = last.next;
			}
			// create the new item
			StackItem i = new StackItem();
			i.item = t;
			// set it as next
			last.next = i;
		}
		// increase size
		size++;
	}
	
	public Throwable peek() {
		if(head == null) {
			return null;
		}
		return head.item;
	}
	
	public Throwable pop() {
		if(head == null) {
			return null;
		}
		size--;
		Throwable t = head.item;
		head = head.next;
		return t;
	}
	
	public boolean empty() {
		return size == 0;
	}
	
	private StackItem current;
	public void toHead() {
		current = head;
	}
	
	public Throwable next() {
		current = current.next;
		return current.item;
	}

	private class StackItem {
		private Throwable item;
		private StackItem next;
	}
}

Dann könntest du sie wie folgt verwenden:

// irgendwo in deinem Code ("exStack" ist die globale Instanz der ExceptionStack-Klasse, "exception" ist irgendeine Exception, die du abgefangen hast)
exStack.push(exception);

// und da, wo du die Dinger dann lesen möchtest:
exStack.toHead();
Exception e;
while((e = exStack.next()) != null) {
	e.printStackTrace();
}

Eine Logger-Klasse verwendet man normalerweise immer dann, wenn man irgendwelche Informationen zum Programmablauf speichern/ausgeben möchte.
Ich kann nicht so recht nachvollziehen, warum du überhaupt die Exceptions irgendwo speichern willst. Macht für mich keinen Sinn. Normalerweise gibt man die irgendwo aus (Konsole, Datei) und liest die dann hinterher.

[js-mueller]

Ich hab mir das auch nochmal überlegt mir der Klasse.
Pago hat schon recht das in einer Klasse zu speichern wäre eigentlich nicht sehr sinnig.
Ich hab mir nun einen Logger geschreiben, welcher mir Fehler mir Auftrittsort-, Zeit in eine Datei schreibt.
Danke für die Hilfe

[VolkerK]

Dafür hast Du hoffentlich java.util.logging oder Log4J verwendet?