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:

Java:

package A9_3;
public class LimerickException extends Exception {
			
}

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

Java:

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

Java:

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...

Java:

	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

Java:

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.

Java:

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???

Java:

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?

Java:

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

Java:

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

Java:

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

Java:

   FileReader fr;

das hier

Java:

   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?

Java:

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

Java:

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

mit

Java:

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 ;-)

Java:

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?

Java:

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:

Java:

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

sowie die Hauptklasse

Java:

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.:
Java:

/** * den leeren Konstruktor braucht ma ned */ public LimerickException(){

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.

Exception Handler wird nicht akzeptiert

Aktives Mitglied

Top Contributor

Aktives Mitglied

Top Contributor

Aktives Mitglied

Top Contributor

Aktives Mitglied

Top Contributor

Aktives Mitglied

Top Contributor

Aktives Mitglied

Aktives Mitglied

Top Contributor

Top Contributor

Aktives Mitglied

Gast2

Gast

Aktives Mitglied

Top Contributor

Aktives Mitglied

Top Contributor

Aktives Mitglied

Top Contributor

Top Contributor

Aktives Mitglied

Top Contributor

Aktives Mitglied

Gast2

Gast

Top Contributor

Aktives Mitglied

Top Contributor