Erstes Programm - Problem mit Exception

[elduderado]

Moinsen,

ich lerne gerade Java an der FH und wir müssen gerade unser erstes Programm schreiben. Dabei geht es um ein simples bearbeiten von Brüchen:

public class Bruch
	{ int zähler;
 	  int nenner;

public Bruch(int z,int n)  throws NennerNullException
	{ nenner = n;
  	  zähler = z;
  	  if(n==0) throw new NennerNullException("Nenner ist 0");
 	}

public Bruch mal(Bruch a) throws NennerNullException					
               { return new Bruch(zähler*a.zähler,nenner*a.nenner);}	 //als Ergebnis neues Bruchobjekt zurückgeben

public Bruch mal(int a) throws NennerNullException	
	{ return this.mal(new Bruch(a,1));
	}

public Bruch plus(Bruch a) throws NennerNullException						
 	{ return new Bruch(zähler*a.nenner+a.zähler*nenner,nenner*a.nenner);
 	}

public Bruch minus(Bruch a) throws NennerNullException
	{ return this.plus(new Bruch(-a.zähler,a.nenner));
  	}
						
public Bruch div(Bruch a) throws NennerNullException
	{ return this.mal(a.kehrwert());
	}

public Bruch kehrwert() throws NennerNullException
	{ return new Bruch(nenner,zähler);
	}

public String toString()					
  	{ if(nenner!=1)
    	  return new String(zähler + "/" + nenner);		//echter Bruch
   	else
     	  return new String(""+zähler);			//ganzzahliger Bruch (Nenner =1)
  	}

class NennerNullException extends Exception
	{
	private static final long serialVersionUID = 1L;
	public NennerNullException(){}         		//Default Konstruktor 
      public NennerNullException(String text){		                //Konstruktor mit Fehlertext
      super(text);
      }
	}

public int compareTo(Bruch q)
	{ double a;
	  double b;
	  a = (double)zähler / nenner;		    // (double) casted auf int zähler -> double int
	  b = (double)q.zähler / q.nenner;
	  if(a == b)
	   return 0;
	  else
	  	if(a>b)
		  return 1;
		else
		  return -1;
	}


public Bruch kürzen() throws NennerNullException
	{ int a;
	  int b;
	  a = zähler;
	  b = nenner;
	  while(a != b) {
	    if( a > b)
	      a = a-b;
	    else 
	      b = b-a;}
	   return new Bruch(zähler/a,nenner/a);
	}
}

import Bruch.NennerNullException;

public class Bruchrechnung 
{public static void main(String [] args)
  { try {
	Bruch c=new Bruch(5,4);			//Referenz auf neues Bruch-Objekt
    System.out.println("Bruch c= " + c);	                                //Ausgabe als String: automatische
    						//Umwandlung mit toString( )
    Bruch e=new Bruch(7,8);			                //leere Referenz auf einen Bruch (für Ergebnis)					
    Bruch r=c.minus(e);				//Bruch c mit Bruch e multiplizieren, Referenz auf
						//Ergebnisobjekt in r speichern
    System.out.println(c+" - "+e+" = "+r);	                                //Ausgabe als String
    Bruch w=r.kürzen();
    System.out.println("Gekürzt: "+c+" - "+e+" = "+w);
    System.out.println(c+" + "+e+" = "+c.plus(e));	                //Ergebnis ist anonymes Objekt
    Bruch h=new Bruch(2,3);		                                //Referenz auf neues Bruch-Objekt
    Bruch i=c.plus(e).mal(h);		                                //Referenz initialisiert auf Ergebnis-Objekt
    i = i.kürzen();
    System.out.println("("+c+" + "+e+") * "+h+" = "+i);
    System.out.println("Vergleich von " + c + " und " + e + " ergibt: " +c.compareTo(e));
  }
    catch(NennerNullException n0){
      System.out.println("fehlerhafter Bruch:"+ n0.getMessage()+ ", Abbruch!\nStackTrace:");
      n0.printStackTrace();
    }
  }
  
}

Warum sagt Eclipse mir in Bruchrechnung:" NennerNullException cannot be resolved to a type"? Und gibt es nicht eine geschicktere Möglichkeit, als immer hinter eine Methode "throws NennerNullException" zu schreiben??

Ich hab mir schon ein paar Beiträge + Websites bezüglich exceptions durchgelesen und es funktioniert doch immer dach dem Prinzip... eine Methode throws eine exception und das catch fängt sie, oder nicht?

Vielen Dank im Vorraus.

 

[ps]

import Bruch.NennerNullException;

Das import statement ist falsch.. es gibt ja kein package "Bruch". Man kann afaik keine inner classes (oder exceptions) importieren. Man importiert die Containerklasse und referenziert von dort:

try {
} catch (Bruch.NennerNullException ex) {
}

Und gibt es nicht eine geschicktere Möglichkeit, als immer hinter eine Methode "throws NennerNullException" zu schreiben??

Es gibt noch die sogenannten unchecked exceptions. Diese müssen nicht mit try{}catch{} gefangen werden sondern treten zur Laufzeit auf. Diese leitet man dann von "RuntimeException" ab anstatt von "Exception".

Es kommt halt immer darauf an was man erreichen möchte... wenn ich definierte Fehlerfälle habe so sollte man schon immer eine checked Exception benutzen. Den Benutzer meiner Schnittstelle/Klasse zu zwingen jede noch so kleine Exception zu fangen ist aber auch nicht zielführend.. in diesem Fall würde ich das einfach so handhaben wie Java selbst:
-> http://java.sun.com/j2se/1.4.2/docs/api/java/lang/ArithmeticException.html

Mein Vorschlag:

public class Bruch {

    int z?hler;
    int nenner;

    public Bruch(int z, int n) {
        nenner = n;
        z?hler = z;
        if (n == 0) {
            throw new ArithmeticException("/ by zero");
        }
    }

    public Bruch mal(Bruch a) {
        return new Bruch(z?hler * a.z?hler, nenner * a.nenner);
    }    //als Ergebnis neues Bruchobjekt zur?ckgeben

    public Bruch mal(int a) {
        return this.mal(new Bruch(a, 1));
    }

    public Bruch plus(Bruch a) {
        return new Bruch(z?hler * a.nenner + a.z?hler * nenner, nenner * a.nenner);
    }

    public Bruch minus(Bruch a) {
        return this.plus(new Bruch(-a.z?hler, a.nenner));
    }

    public Bruch div(Bruch a) {
        return this.mal(a.kehrwert());
    }

    public Bruch kehrwert() {
        return new Bruch(nenner, z?hler);
    }

    public String toString() {
        if (nenner != 1) {
            return new String(z?hler + "/" + nenner);      //echter Bruch
        } else {
            return new String("" + z?hler);         //ganzzahliger Bruch (Nenner =1)
        }
    }

    public int compareTo(Bruch q) {
        double a;
        double b;
        a = (double) z?hler / nenner;          // (double) casted auf int z?hler -> double int
        b = (double) q.z?hler / q.nenner;
        if (a == b) {
            return 0;
        } else if (a > b) {
            return 1;
        } else {
            return -1;
        }
    }

    public Bruch kürzen() {
        int a;
        int b;
        a = z?hler;
        b = nenner;
        while (a != b) {
            if (a > b) {
                a = a - b;
            } else {
                b = b - a;
            }
        }
        return new Bruch(z?hler / a, nenner / a);
    }
}

Du kannst die ArithmeticException natürlich auch durch eine eigene Exception austauschen - so wie es jetzt ist hast du das selbe verhalten wie wenn du java einen integer / 0 rechnen lässt.

 

[elduderado]

Danke ps,

ich hab mich von den Vorschlägen, die Eclipse mir gegeben hat,wohl irreführen lassen. Klar gibt es kein package Bruch und nachdem ich die NennerNullException auf Bruch zugewiesen hab, funktioniert es wunderbar.

Das es die "standart" Exceptions gibt wusste ich, aber nicht, dass ich kein throws dafür setzen muss. Ich versteh nicht, warum ich in allen anderen Methoden, die einen neuen Bruch erstellen ein throw setzen muss... das macht doch shcon der Konstruktor oder nicht?

Vielen Dank,

 

[Murray]

Ich versteh nicht, warum ich in allen anderen Methoden, die einen neuen Bruch erstellen ein throw setzen muss... das macht doch shcon der Konstruktor oder nicht?

Genau das ist ja das Problem - wenn im Konstruktor eine checked exception deklariert wird, dann muss jeder Code, der diesen Konstruktor verwendet, mit dieser Exception rechnen (und sie entweder behandeln oder aber selbst als im Rahmen dieses Codes möglicherweise zu erwartende Exception deklarieren)