Nach Catch-Klausel Programm weiter laufen lassen

[Christofer]

Hy hab mal wieder ein kleines Problem! Es geht um ein Programm names Fraction das Berechnungen von Brüchen erlaubt, darin kann ein Fehler auftreten wenn man z.B. für den Nenner 0 übergibt im Konstruktor dann soll der auftretende Fehler ArithmeticExceptions in einer Catch-Klausel aufgefangen werden. Soweit so gut. Das alles funktioniert nur wird das Programm nach der Behandlung beendet und nicht mehr weiter ausgeführt.

Da im Try Block noch weitere Methoden sind die aufgerufen werden wäre es recht nützlich dass das Programm danach noch weiter läuft, aber wie macht man das? mit finally? hab ich auch schon versucht aber ich hab keine Ahnung was ich dann in den finally-Block reinschreiben könnte.

package esop.ueb10;

import esop.simpleIO.*;

class Fraction { // Version 0.5
	private int num = 0;
	private int den = 1;
	static int nFractions = 0;
	
	public Fraction (int n, int d) {
		
		if (d == 0)
			throw new Div0Exception (d);
		
		if (n != 0) { // sonst passt Initialisierung bereits…
			boolean neg = (n<0 && d>0) || (n>0 && d<0); //Prüfung ob n oder d negativ ist
		
		if (n < 0) 
			n = -n;		//wandelt n in positive zahl um
		
		if (d < 0) 
			d = -d;		//wandelt d in positive zahl um
		
		int k = gcd(n, d); // Hilfsfunktion f. ggT
		num = n / k;
		den = d / k;
		
		if (neg) //wenn neg = false (also negativ)
			num = -num;		//erfolgt die Umwandlung in eine positive Zahl
		}
		
		nFractions = nFractions + 1;
		Out.println("Fraction #" +nFractions + ": " + this);
	
	}
	
	public Fraction (int n) { 
		this(n, 1); 
	}
	
	public Fraction () { 
		this(0, 1);
	}
	
	public int getNum () { 
		return num; 
	}
	
	public int getDen () { 
		return den; 
	}
	
	public String toString () {
		return num + (den > 1 ? "/" + den : "");
	}
	
	public double toDouble () {
			return (double) num / den;
	}
		
	public Fraction mult (Fraction f) {
		//erzeugt neues Objekt mit this*f
		Fraction result = new Fraction(num*f.num, den*f.den);
		return result;
	}
	
	public Fraction div (Fraction f) {
		return new Fraction(num*f.den, den*f.num);
	}
	
	public Fraction add (Fraction f) {
		return new Fraction(num*f.den + den*f.num, den*f.den);
	}
		
	public Fraction sub (Fraction f) {
		return	new Fraction(num*f.den - den*f.num,	den*f.den);
	}
	
	public static int gcd (int n, int m) {
		while (n != m) {
			if (n > m) {
			n = n - m;
			}
			else {
				m = m - n;
			}
		}
		return n;
	}
	
	public static void main(String[] args) {
				
				try {
				Fraction eins = new Fraction(1);
				Out.println(eins.getDen());
				Fraction zero = new Fraction();
				Out.println(zero.getNum());
				Fraction einDrittel = new Fraction(1, 3);
				Out.println(einDrittel.add(einDrittel));
				Out.println(einDrittel.div(einDrittel));
				Fraction einHalb = new Fraction(1, 2);
				Fraction siebenSechstel = new Fraction(7, 6);
				Fraction nullDrittel = new Fraction(3, 0);
				Out.println(nullDrittel.toString());
				Fraction summe = einHalb.add(siebenSechstel);
				Out.println(summe.getNum() + "/" + summe.getDen());
				Out.println(Fraction.gcd(15134,56));
				}
				catch (Div0Exception d) {
				Out.println(d.getMessage());
				}
			
		}
	}	

	class Div0Exception extends ArithmeticException {
		int dividend;

		public Div0Exception(int d) {
			super("Division durch NULL!");
			dividend = d;
		}
		
			
	}

so hier der gesamte Code, wie gesagt funktioniert nur nach der Catch-Klausel ist das Programm zu Ende und folgende Methoden werden nicht mehr ausgeführt!

Out.println(nullDrittel.toString());
				Fraction summe = einHalb.add(siebenSechstel);
				Out.println(summe.getNum() + "/" + summe.getDen());
				Out.println(Fraction.gcd(15134,56));

wäre ganz nett wenn ihr mir einen kleinen Denkanstoss geben könntet

greetz Christofer

 

[dsv fritz]

Wie wär's, wenn du jede Methode in einem separaten try-catch Block setzts?

 

[The_S]

Du musst für jede Funktion, die eine Exception auslösen könnte und nach welcher das Programm aufjedenfall - egal ob excpetion oder nicht - weiterlaufen soll, einen eigenen try-catch-block verwenden.

[edit] zu langsam ...

 

[Leroy42]

Das Problem ist, das auch in einem eventuellen finally-Block Exceptions
auftreten können, die du sicher anzeigen möchtest.

Vorschlag: Schreib' dir ein Interface das du jeweils in einem try-catch-Block aufrufst:

interface FTest {
  public void run();
}

...

static void test(FTest ftest) {
  try {
    ftest.run();
  } catch (Div0Exception e) {
    System.out.println(e);
  }
}

...

test(new FTest() {public void run() {
  Fraction eins = new Fraction(1); 
  Out.println(eins.getDen());
}});
test(new FTest() {public void run() {
  Fraction dreiNulltel = new Fraction(3, 0); 
  Out.println(dreiNulltel.toString());
}});
test(new FTest() {public void run() {
  Fraction siebenSechstel = new Fraction(7, 6); 
  Fraction summe = einHalb.add(siebenSechstel); 
  Out.println(summe.getNum() + "/" + summe.getDen());
}});

Edit: Obwohl die Ersparnis gegenüber separaten try-catch-Blöcken auch
nicht gerade berauschend ist. :shock:

 

[Christofer]

Danke für die Antworten! Ich habs jetzt einfach mal so gelöst, dass ich die try-catch-Klausel nur um die eine Methode gelegt habe, die durch null dividiert. Ist zwar nicht perfekt, aber auf die Schnelle :roll:

 

[The_S]

Was wäre denn in deinen augen perfekt? Einen try-catch block legt man nur um code, der auch eine excption auslösen könnte und evtl. noch um die Methoden, die bei einer exception nicht ausgeführt werden sollen.