# Rationale Zahlen, Exceptions



## David2456 (4. Feb 2016)

Hallo
ich habe folgende Aufgabe und bräuchte Unterstützung.
Als erstes habe ich noch einen Frage. Warum müssen manche Exceptions nicht behandelt werden? Und warum will man Exceptions haben welche man nicht behandeln muss?
Wenn man sie nicht behandelt wird es doch früher oder später zu Fehlern kommen. Wäre es nicht sinnvoller Fehler gleich auszuschließen?

Nun zu meiner eigentlichen Frage. Ich habe bei der Aufgabe mal ein bisschen mit den Scanner etc. rumgespielt (die exceptions lasse ich erstmal beiseite) und es wird alles aus der Text Datei ausgegeben wie ich es wollte. Nun habe ich aber das Problem das ich ja aus der Datei die Werte in eine Array Rational[] speichern soll damit die Konstruktoren die Werte als Zähler und Nenner setzen können. Wie? Wäre nett wenn mir jemand einen Anstatz dafür geben könnte.
Danke schonmal


----------



## VfL_Freak (4. Feb 2016)

Moin,

tja, ohne Code rsp. ein bisschen Eigeninitiative wird das nicht viel werden !

http://www.java-forum.org/forum-faq-beitraege/7407-man-fragen-richtig-stellt.html

Gruß Klaus


----------



## Jardcore (4. Feb 2016)

Wahrscheinlich ist dein Denkansatz bisschen verdreht.

Gehe wie folgt vor.
1. lese Strings aus einer Datei und speichere die Daten in einem Rational Objekt. Dabei musst du natürlich den String noch in einen Integer umwandeln.


```
while(String[] zeile = buffer.next()) != null) {
         Rational rational = new Rational(Integer.valueOf(...), Integer.valueOf());
         ....
    }
```

2. Füge zusätzlich in der Schleife das Rational Objekt in das RationalArray ein.
    rationals[x] = rational;

Die Frage die sich mir gerade noch stellt, weißt du wie groß dein Rational[] Array ist?


----------



## David2456 (4. Feb 2016)

Danke erstmal. Zu der Datei (welche ich vergessen habe beizufügen) steht
1,2
3,4
5,test
6,0
7
kekse,3
drinn. Könnte ich jetzt die größe hardcodieren und auf 11 setzen oder muss ich jede Zeile betrachten und auf 6 setze. Oder anderst?


----------



## Jardcore (4. Feb 2016)

Gibt auch paar Tricks  

```
public Rational[] readRationalsFromFile(String filename) {
        //...    
        String record;
        List<Rational> rationalList = new ArrayList<Rational>();
       
        while((record = reader.readLine()) != null) {
            Rational rational = createRational(record.split(","));
            if(rational != null) {
                rationalList.add(rational);
            }
        }
        return rationalList.toArray(new Rational[rationalList.size()]);
    }
```
Hier hättest du eine dynamische Liste, der einfach die Rational Objekte übergeben werden. Am Ende wandelst du diese dann in dein Rational[] Arrays um. Die Größe bekommst du dann von der dynamischen Liste.


----------



## David2456 (9. Feb 2016)

Danke für die Antworten, aber könnte sich einer kurz die Aufgabenstellung angucken? Gleich der erste Punkt. Ich soll den Konstruktor Rational(int numerator, int denominator)  und  Rational(numerator)  erstellen. Wozu der 2.te numerator?


----------



## Meniskusschaden (9. Feb 2016)

Damit man eine rationale Zahl ohne Angabe des Nenners erzeugen kann. Wäre für ganze Zahlen ja recht praktisch.


----------



## David2456 (9. Feb 2016)

Danke dir. Könnte noch einer über die Konstruktoren gucken bin mir da nicht sicher ob da überhaupt was dran richtig ist



```
public class Rational {
 
    int numerator, denominator;
 
    public Rational(int numerator, int denominator){
     
        this.numerator = numerator;
        this denominator = denominator;
        if (denominator == 0){
            throw new IllegalDenominatorException("Denominator is zero");
            denominator == 1;
        }
    }
 
    public Rational(int numerator){
        if (){
            this.numerator = numerator;
            this.denominator = 1;
        }
    }
 
    public setDenominator(int denominator){
        if (denominator == 0){
            IllegalDenominatorException();
            denominator == 1;
        }
    }
 
    public String toString(){
        return Integer.toString(numerator);
        return Integer.toString(denominator);
        return numerator + "/" + denominator;
    }
```
... main ...


edit Über eine Antwort meiner ersten Frage bezüglich Exceptions würde ich mich sehr freuen


----------



## kneitzel (9. Feb 2016)

Also das ist doch schon ein recht guter Anfang. Ein paar Anmerkungen sind aber hier doch wichtig:
- mit einem throw endet die Ausführung. Code dahinter wird somit nie ausgeführt und kann direkt gelöscht werden. 
- Die Prüfung der Parameter erfolgt normalerweise direkt am Anfang der Funktion. Das ist aber für die Aufgabe erst einmal uninteressant.
- mit return beendest Du eine Funktion. Was dahinter kommt, wird nicht ausgeführt. Du musst Dir also überlegen, was Du ausgeben willst. Evtl. ist es ja etwas wie numerator + " / " + denominator oder so?
- In einem Konstruktor ist noch ein leeres if. Was willst Du da denn prüfen? Wenn es nichts zu prüfen gibt, dann wäre das if heraus zu nehmen.

Dann hättest Du etwas, das erst einmal kompiliert und das Du dann prüfen könntest, ob es die Anforderungen erfüllt. Nicht erfüllt Anforderungen müsstest Du dann nur noch einbauen.


----------



## Bitfehler (9. Feb 2016)

David2456 hat gesagt.:


> *public* String toString(){
> *return* Integer.toString(numerator);
> *return* Integer.toString(denominator);
> *return* numerator + "/" + denominator;
> }



Das sieht inkorrekt aus. Durch das erste return wird die Methode verlassen, sodass die anderen beiden Zeilen gar nicht mehr ausgeführt werden. Diese können nicht erreicht werden und sind daher toter Code. Ich glaube du wolltest sowas machen:

```
return Integer.toString(numerator) + "/" +  Integer.toString(denominator);
```

EDIT: Zu langsam


----------



## Meniskusschaden (9. Feb 2016)

Die Behandlung von negativen Nennern ist noch nicht korrekt.


----------



## David2456 (9. Feb 2016)

Danke euch für die positive Rückmeldung, zu dem leeren if  das steht da momentan so weil ich nicht ganz weiß wie ich damit prüfen ob ein denominator vorhanden ist. Es soll ja falls keiner vorhanden ist durch 1 ersetzt werden


----------



## Bitfehler (9. Feb 2016)

Das bezieht sich daraus, wenn über den Konstruktor kein Wert für denominator übergeben wird. Du brauchst an dieser Stelle keine Prüfung, sondern setzt ihn einfach auf 1, so wie du es bereits machst.


----------



## David2456 (9. Feb 2016)

@Jardcore Könntest du mir deine erste while Schleifen 

```
while(String[] zeile = buffer.next()) != null) {
         Rational rational = new Rational(Integer.valueOf(...), Integer.valueOf());
         ....
    }
```

nochmal erläutern? Was gehört in die (...). Und in die while Schleife , also praktisch bei dem ... , soll  rationals[x] = rational;  hin oder nicht? Woher x? Sollte ich voher x deklarieren oder ist das nur ein Platzhalter? Wenn ja an was hast du gedacht, was da rein soll?
Tut mir leid für die vielen Fragen


----------



## Jardcore (10. Feb 2016)

Mein Zweiter Codeausschnitt war etwas präzisier in der Hinsicht.

```
String line;
         List<Rational> rationalList = new ArrayList<Rational>();
     
         while((line= scanner.nextLine()) != null) {
             Rational rational = createRational(line.split(","));
             if(rational != null) {
                 rationalList.add(rational);
             }
         }
```

Also du bekommst aus deiner Datei eine Zeile die zum Beispiel so aussieht "1,2".
In meine Fall hab ich einen String der "line" heißt. Mit der Methode split() erzeuge ich ein String[] Array, welches z.B. die beiden Werte beinhaltet (also die 1 am index 0 und die 2 am index 1).

Das Erzeugen des Rational Objekts habe ich in einer extra Methode ausgelagert.
Dort wird geprüft ob das String[] überhaupt 2 Werte enthält und weiterhin wird dort mit:
int nominator = Integer.parseInt(line[0]) usw. versucht einen Integer zu erzeugen.

Dort fange ich eine Exception ab falls das Parse Fehlgeschlagen ist und behandle den Fehler entsprechend.

Zu deiner Frage ob Rational[x] = rational hin muss:
Nein in diesem Fall nicht. Man erzeugt ein Rational Objekt und fügt es einer dynamischen Liste hinzu.
Wenn die Liste komplett befüllt wurde, wandelt man die Liste, da es die Aufgabenstellung verlangt, in ein Rational[] um.

```
return rationalList.toArray(new Rational[rationalList.size()]);
```


----------



## Jardcore (10. Feb 2016)

Btw:
Du kannst in deiner Rational Klasse im Konstruktor auch den setDenominator() aufrufen dann musst du den Code zum überprüfen ob der Denominator Null ist nicht doppelt schreiben


----------



## David2456 (10. Feb 2016)

Vielen Danke, aber kannst du mir noch kurz sagen aus welchem Package das "create" kommt? Finde nichts wenn ich danach suche


----------



## Jardcore (11. Feb 2016)

Das ist eine Methode die ich selbst deklariert habe...

```
public Rational createRational(String[] entries) {
    int numinator, denominator;
    // .... hier die Logik
    // ....
    //
    return new Rational(numinator, denominator);
}
```


----------

