# Exception Handler wird nicht akzeptiert



## Münchner (19. Dez 2009)

Servus mal wieder

Ich hab eine Klasse für die ich Exceptions einbauen soll für den Fall, dass ein file nicht gefunden, nicht geöffnet und nicht geschlossen werden kann.
Dazu hab ich erstmal folgende Klasse gebaut:
	
	
	
	





```
package A9_3;
public class LimerickException extends Exception {
			
}
```

Aus dieser soll die eigentliche Klasse wissen woher die Exceptions kommen sollen. Die schaut so aus:

```
package A9_3;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Limerick {
	public static void readLimerick(String path) throws  LimerickException {
		File f;
		 f = new File(path);
		FileReader fr;
		try{
			fr = new FileReader(f);
		}
		catch(LimerickException e){
			System.out.println("Datei kann nicht gefunden werden");
		}
		BufferedReader br = new BufferedReader(fr);

		String line = "";
		try{
		while (line != null) {
			System.out.println(line);
				line = br.readLine();	
			}}
		catch(LimerickException e){
			System.out.println("Datei kann nicht gelesen werden werden");
		}
		try{
			fr.close();
		}
		catch(LimerickException e){
			System.out.println("File kann nicht geschlossen werden");
		}
		}	
	public static void main(String[] args) {
		try {
			readLimerick("limerick.txt");
		} catch (LimerickException e) {
			
			e.printStackTrace();
		}
	}

}
```

ich hab eigentlich alles, was da Fehler schmeissen könnte mit try/catch Blöcken umrandet, trotzdem funzt da nix.
Hat wer bitte nen kleinen TIpp?
Gruß
Münchner


----------



## Final_Striker (19. Dez 2009)

Münchner hat gesagt.:


> trotzdem funzt da nix



geht es vielleicht etwas genauer?


----------



## Münchner (19. Dez 2009)

Logo,

ich bekomme beim Compilieren eine Latte von Fehlermeldungen, die ich teils nicht interpretieren kann und auf der anderen Seite würd ich ja gern meine Sytsm.out.println(); Zeilen sehen.
Die Fehlermeldungen schauen folgendermaßen aus 
	
	
	
	





```
Unhandled exception type FileNotFoundException
	Unreachable catch block for LimerickException. This exception is never thrown from the try statement body
	The local variable fr may not have been initialized
	Unhandled exception type IOException
	Unreachable catch block for LimerickException. This exception is never thrown from the try statement body
	The local variable fr may not have been initialized
	Unhandled exception type IOException
	Unreachable catch block for LimerickException. This exception is never thrown from the try statement body

	at A9_3.Limerick.readLimerick(Limerick.java:15)
	at A9_3.Limerick.main(Limerick.java:40)
```


----------



## Final_Striker (19. Dez 2009)

naja, steht ja schon eigentlich da.

in dem try block wird nie die LimerickException geworfen und dadurch wird auch der catch block nie durchlaufen. außerdem musst du noch die FileNotFoundException und IOException exceptions abfangen.


----------



## Münchner (20. Dez 2009)

oder anders, ich hab einfach was falsches mit dem try Block gekastelt.
Ich kann doch jede andere Exception auch einfach mit der LimerickException fangen, oder?
Die Klasse erbt ja von Exception, also muss sie die IOException und die FileNotFoundException auch haben.
Danke dir für die Antwort


----------



## Noctarius (20. Dez 2009)

Wieso sollte eine LimirikException eine Exception fangen? Vererbung funktioniert beim Upcast aber nicht Downcast.


----------



## Münchner (20. Dez 2009)

ah ok, dann probiers ichs mal mit den FileNotFoundExceptions und IOExceptions, die werden ja oben in der Import Zeile aufgeführt...

```
FileReader fr;
			fr = new FileReader(f);			
		BufferedReader br = new BufferedReader(fr);
```
bei new FileReader(f); meckert Eclipse: Unhandled exception type FileNotFoundException

Wenn ich den Ausdruck dann aber mit einem catch und try Block versehe

```
FileReader fr;
			try {
				fr = new FileReader(f);
			} catch (FileNotFoundException e1) {
				System.out.println("File kann nicht gefunden werden werden");
			}			
		BufferedReader br = new BufferedReader(fr);
```
, meckerts wieder, dass _The local variable fr may not have been initialized_

Check ich grad ned


----------



## Noctarius (20. Dez 2009)

Ja klar, weil du die Exception abfängst aber dann außer einer Ausgabe nichts machst.

Der Name der Exception sagt doch, dass das nciht funktionieren kann. Wird das File nicht gefunden, dann kannst du es auch nicht lesen.


----------



## Münchner (20. Dez 2009)

also muss ich in dem Fall dann auch alle anderen Exceptions so behandeln, sprich:
Es ist nicht da und ich kann nicht lesen. Und wenn ichs nicht lesen kann kann ichs auch nicht wieder schließen.

```
package A9_3;


import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Limerick {
	public static void readLimerick(String path) throws  LimerickException {
		File f;
		 f = new File(path);
		FileReader fr;		
				try {fr = new FileReader(f);}
			 catch (FileNotFoundException e1) {System.out.println("File kann nicht gefunden  werden");}
								
		try{BufferedReader br = new BufferedReader(fr);}
		catch(IOException e){}
		String line = "";
		while (line != null) {
			System.out.println(line);
			try{line = br.readLine();}
		catch(IOException e){System.out.println("File kann nicht gelesen  werden");}
		}
		try{fr.close();}
		catch(IOException e){System.out.println("File kann nicht geschlossen werden");}	
		}		
	public static void main(String[] args) throws LimerickException {
		
			readLimerick("limerick.txt");	
		}
	}
```

Aber hier hab ich doch jetzt eigentlich alles, was nicht gehen kann in den try catch Blöcken???

```
try{line = br.readLine();}
```
 Hier meckert er wieder, aber ich habs doch eigentlich abgefangen??


----------



## Noctarius (20. Dez 2009)

Wieso tust du nicht alles, was mit dem File lesen zu tun hat in einen großen try/catch Block?
Abgesehen davon schmeisst dein Code niemals diese LimerikException


----------



## Münchner (20. Dez 2009)

Ich bin schon einen Schritt weiter, leider kann aber fr immer noch nicht erkannt werden.
Könnte mit bitte jemand den Fehler sagen?

```
package A9_3;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Limerick {
	public static void readLimerick(String path) throws  LimerickException {
		File f = new File(path);
		FileReader fr;		
				try {fr = new FileReader(f);
				throw new LimerickException("File nicht gefunden");}
			 catch (FileNotFoundException e) {System.out.print(e.getMessage());}	
						
		try{
			BufferedReader br = new BufferedReader(fr);
		String line = "";
		while (line != null) {
			System.out.println(line);
			line = br.readLine();}
		throw new LimerickException("Einlesefehler aufgetreten");
		}
		catch(IOException e){System.out.print(e.getMessage());}
		
		
		try{fr.close();
		throw new LimerickException("File schliessen fehlgeschlagen");}
		catch(IOException e){System.out.println("File kann nicht geschlossen werden");}	
		}		
	public static void main(String[] args) throws LimerickException {
	
			readLimerick("limerick.txt");	
			
	}
}
```

und ExceptionsKlasse

```
package A9_3;
public class LimerickException extends Exception {
	
	public LimerickException(){
		
	}	
			public LimerickException(String e){
				super(e);
			}
}
```


----------



## Münchner (20. Dez 2009)

Habs nun folgendermaßen gelöst (zumindest wirds kompiliert..., obs die Korrektoren auch cool finden wird sich ja noch zeigen :applaus

```
package A9_3;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Limerick {
	public static void readLimerick(String path) throws  LimerickException {
		File f = new File(path);
		FileReader fr;		
				try {fr = new FileReader(f);
	
			BufferedReader br = new BufferedReader(fr);
		String line = "";
		while (line != null) {
			System.out.println(line);
			line = br.readLine();}

	fr.close();

	throw new LimerickException("File nicht gefunden");}
				catch(FileNotFoundException e){System.out.print(e.getMessage());}
				catch(LimerickException e){System.out.print("also kann es die Nachricht auch nicht lesen");}
				catch(IOException e){System.out.print(e.getMessage());}
				
	}			
	public static void main(String[] args) throws LimerickException {
	try{
			readLimerick("limerick.txt");	
			throw new LimerickException("");}
	catch(LimerickException e){System.out.println("\n"+e.getStackTrace()+"\n "+ e.getMessage());}
	
	finally{System.out.println(" Das System konnte die Datei nicht finden,\n " +
			"also kann sie sie auch nicht öffnen um sie zu lesen\n und auch nicht wieder schließen ");}
}}
```

Vielen Dank für Eure Antworten


----------



## Final_Striker (20. Dez 2009)

anstatt


```
FileReader fr;
```

das hier


```
FileReader fr = null;
```


----------



## Noctarius (20. Dez 2009)

Jetzt schmeisst du am Ende jedes Lesevorgangs eine Exception. Ist doch klar, dass wenn du eine FileNotFoundException fängst, dass du dann auch da erst deine Fehlermeldung schmeisst, oder nicht?


```
try {
  ... dein Code
} catch (FileNotFoundException e) {
  throw new LimerickException("File nicht gefunden", e);
} catch (IOException e) {
  throw new LimerickException("Lese-Fehler", e);
}
```


----------



## Münchner (20. Dez 2009)

@Noctarius:
Da kann ich dir jetzt nicht ganz folgen ehrlich gesagt...

@FinalStriker
Macht man das so, dass man die mit null initialisiert?


----------



## Gast2 (20. Dez 2009)

Münchner hat gesagt.:


> oder anders, ich hab einfach was falsches mit dem try Block gekastelt.
> Ich kann doch jede andere Exception auch einfach mit der LimerickException fangen, oder?
> Die Klasse erbt ja von Exception, also muss sie die IOException und die FileNotFoundException auch haben.


indirekt ja

```
try
{
    // TODO something
} catch(Exception ex) // alles abfangen
{
    throw new LimerickException(ex);
}
```

mit


```
public class LimerickException extends Exception {
    public LimerickException(Exception ex) { super(ex); }            
}
```

macht aber nicht wirklich Sinn was Du da willst

hand, mogel


----------



## Münchner (20. Dez 2009)

warum?


----------



## Noctarius (20. Dez 2009)

Wenn dein Code ordentlich formatiert wäre, könntest du das ;-)


```
package A9_3;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
 
public class Limerick {
	public static void readLimerick(String path) throws  LimerickException {
		File f = new File(path);
		FileReader fr;      
		try {
			fr = new FileReader(f);
    
			BufferedReader br = new BufferedReader(fr);
			String line = "";
			while (line != null) {
				System.out.println(line);
				line = br.readLine();
			}
 
			fr.close();
 
			throw new LimerickException("File nicht gefunden"); // Hier schmeisst du deine eigene Exception
		} catch(FileNotFoundException e) { // Hier wird der Fehler abgefangen
			System.out.print(e.getMessage());
			throw new LimerickException("File nicht gefunden"); // Hier sollte die Exception erst geworfen werden, nämlich im Fehler
		} catch(LimerickException e) {
			System.out.print("also kann es die Nachricht auch nicht lesen");
		} catch(IOException e) {
			System.out.print(e.getMessage());
		}
	}    
	
	public static void main(String[] args) throws LimerickException {
		try {
			readLimerick("limerick.txt");   
			throw new LimerickException("");}
		catch(LimerickException e) {
			System.out.println("\n"+e.getStackTrace()+"\n "+ e.getMessage());
		} finally {
			System.out.println(" Das System konnte die Datei nicht finden,\n " +
			"also kann sie sie auch nicht öffnen um sie zu lesen\n und auch nicht wieder schließen ");
		}
	}
}
```

Deswegen ist Einrückung wichtig und darum sind sogenannte OneLiner (alles in eine Zeile stopfen) nicht nur unschöner Stil, sondern können auch zu Verwirrung (sowohl von dir als auch von Anderen) führen.

Leerzeilen kosten nichts, nicht mal Speed und sorgen für deutlich bessere Übersicht!


----------



## Münchner (20. Dez 2009)

Cool, merci Dir.
Das muss einem halt auch alles erstmal jemand sagen :rtfm:


----------



## Noctarius (20. Dez 2009)

Ist ja nicht schlimm, tun wir ja :-D


----------



## Münchner (20. Dez 2009)

@Final Striker
Habs nochmal anders probiert, bekomme aber lauter NullPointerExceptions, wenn ich fr und br zunächst mit null initialisiere.
Aber wenn ich sie gar nicht initialisiere bekomme ich auch Fehler.
Hast du einen Vorschlag, wie man das wegbekommt?

```
package A9_3;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Limerick {
	public static void readLimerick(String path) throws  LimerickException {
		File f = new File(path);
		FileReader fr=null;
		
				try 
				{fr = new FileReader(f);
				throw new LimerickException();
				}
				catch(FileNotFoundException e){
					System.out.println(e.getMessage());}
				BufferedReader br=null;
			try{	
			 br = new BufferedReader(fr);
			
		String line = "";
		while (line != null) {
			System.out.println(line);
			line = br.readLine();}
		throw new LimerickException();
			}
			catch(LimerickException e){}
			catch(IOException e){}
	try{		
	fr.close();
	throw new LimerickException();}
	catch(IOException e){}
	}
		       
	
	public static void main(String[] args) throws LimerickException {
	
		try{
			readLimerick("limerick.txt");	
			throw new LimerickException("");}
	catch(LimerickException e){System.out.println("\n"+e.getMessage()+"\n"+e.getStackTrace());}
	

}}
```


----------



## Michael... (21. Dez 2009)

In Zeile 22 und 33 kann fr null sein.
Ansonsten ist das ganze ziemliche wüst. Du bist Dir sicher Du weisst was Du da tust?


----------



## Noctarius (21. Dez 2009)

Münchner du solltest dir dringendst überlegen ob du deinen Code wirklich nicht sauberer Formatieren möchtest. Mit der aktuellen Art ist es (gerade für Anfänger) nahezu nicht möglich die Scopes von Variablen zu erkennen.


----------



## Münchner (21. Dez 2009)

Nein, so ganz klar ist mir das immer nicht, was ich da tue, da muss ich mich schon als voller Java Noob outen.
Auch mit der sauberen Code Formatierung haperts noch, aber wenn mans nur im Nebenfach macht, spielt halt der Stil keine Rolle (leider).
Wei du schon richtig sagst würde des wahrsccheinlich manches übersichtlicher machen.
Ich wart noch auf die Besprechung, dann post ich hier auch die vorgeschlagene Lösung der Korrektoren, falls es noch mehr Noobs mit demselben Problem gibt


----------



## Noctarius (21. Dez 2009)

Also bei vielen Entwicklungsumgebungen gibt es fertige Code-Formatter. Diese haben grundlegend schon einen recht übersichtlichen Stil voreingestellt (welcher meist nur an einen firmenspezifischen Stil angepasst wird). Als Lösung für Zuhause ist dieser aber total ok. Wenn du Eclipse benutzt kannst du z.B. im Codefenster STRG+SHIFT+F drücken und dein Code wird automatisch formatiert.
Du solltest, gerade wenn der Lehrer nicht darauf drängt, zu deinem eigenen besten gar keinen schlechten Codestil anfangen. Alles was einmal drin ist wird man total schwer wieder los. Also gerade am Anfang lieber etwas übersauber arbeiten und mal eine Minute mehr in Codestil investieren. Tritt ein Fehler auf, wirst du es dir danken sofort die einzelnen Codebereiche zu erkennen


----------



## Münchner (21. Dez 2009)

Merci für die Tipps.
Ich benutze Eclipse, den Befehl kannt ich noch ned.
Hier kommt noch die erwartete Lösung, wurde heute besprochen:


```
public class LimerickException extends Exception {
	/**
	 * den leeren Konstruktor braucht ma ned
	 */
	public LimerickException(){
		
	}	
			public LimerickException(String e){
				super(e);
			}
}
```

sowie die Hauptklasse

```
package A9_3;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Limerick {
	public static void readLimerick(String path) throws LimerickException {

		File f = new File(path);
		FileReader fr; // hier Variable deklarieren, damit die im Block nicht
						// verschluckt wird
		try {
			fr = new FileReader(f);
		} catch (FileNotFoundException e) {
			throw new LimerickException("Datei nicht gefunden");
		}
		BufferedReader br = new BufferedReader(fr);
		String line = "";
		while (line != null) {
			System.out.println(line);
			try {
				line = br.readLine();
			} catch (IOException e) {
				throw new LimerickException("Fehler beim Lesen");
			}
		}
		try {
			fr.close();
		} catch (IOException e) {
			throw new LimerickException("File kamma ned schleißen");
		}
	}

	public static void main(String[] args) {
		try {
			readLimerick("limerick.txt");
		} catch (LimerickException e) {
			System.out.println(e.getMessage());
			e.printStackTrace();
		}
	}
}
```


----------



## Gast2 (21. Dez 2009)

Münchner hat gesagt.:


> ```
> /**
> * den leeren Konstruktor braucht ma ned
> */
> ...



wenn Ihr den Konstruktor nicht verwendet - wieso steht er dann da? ... der wird vom Compiler auch nicht erzeugt wenn ein anderer Konstruktor da ist

hand, mogel


----------



## Noctarius (21. Dez 2009)

Und immer noch die Aussage:
Steck alles was mit Datei lesen zu tun hat, also File öffnen, Leseversuche, File schließen, usw., zusammen in einen try / catch Block und fang einfach alle Exceptions ab. Diese kannst du dann wunderbar in deine LimerickException wrappen.


----------



## Münchner (25. Dez 2009)

So hab ichs ja anfänglich auch gemacht, aber die Aufgabe hat eben verlangt, für jedes der drei ein einzelnes try/catch zu bauen, und beim ersten das Programm zu verlassen.

Schöne Weihnachtstage


----------



## Noctarius (25. Dez 2009)

Zeig mal die Aufgabenstellung. Das wäre die dümmste Idee die ich je gehört hab. Wer sowas vorgibt gehört gesteinigt und hat einfach keine Ahnung von praxisbezogenem Softwaredesign.


----------

