# Darstellung von Brüchen



## Informatikanfänger12 (14. Jan 2018)

Hallo,
ich soll ein Programm schreiben, welches  nichtnegative rationalen Zahlen als Brüche darstellt und diese addiert, multipliziert bzw. auch kürzt.
Dabei geht es mir um die Frage, wie ich es mache, wenn negative Zahlen eingeben werden:
Mein Programm bisher:



```
public class Bruch {
   
   
    int zaehler;
    int  nenner;
   
   
    public Bruch(){
        zaehler=0;          //parameterloser Konstruktor
        nenner=1;
    }
   
    public Bruch(int zaehler, int nenner){
       
        if(zaehler<0 || nenner<0) {
            System.out.println("Positive Werte eingeben");
            return;
        }
        if(nenner==0) {
            this.nenner=1;
        }
         this.zaehler=zaehler;
         this.nenner=nenner;
         kuerze();
         }
   
     public int getZaehler(){
        return zaehler;
    }                                       //getter-Methoden
     public int getNenner(){
            return nenner;
        }

    public void kuerze() {

        int limit = Math.min(zaehler,nenner);
        for(int i=2; i<=limit; i++) {
            if(zaehler%i==0 && nenner%i==0 ) {
                zaehler /=i;
                nenner/=i;
            }
        }
       
     
    }
   
    public String toString()
      {
         return "" + zaehler + " / " + nenner;
      }
```

Dabei gehts mir um die Zeile im 2. Konstruktor, mit Nenner und Zaehler <0.
Kann man das irgendwie besser machen ?


----------



## mrBrown (14. Jan 2018)

Ja - statt einem return eine Exception schmeißen 
Ansonsten bekommt man dabei 0/0 zurück


----------



## Informatikanfänger12 (14. Jan 2018)

Wie geht das. Wir haben das noch nicht behandelt oder gibt es noch eine andere Möglichkeit?


----------



## Blender3D (14. Jan 2018)

```
..
        if (zaehler < 0 || nenner < 0)
            throw new IllegalArgumentException("Negative argumentes are not allowed!");
        ..
```


----------



## Informatikanfänger12 (14. Jan 2018)

Danke 
Ich habe noch eine Frage zu meiner Methode kuerze() . Wenn ich z.b 2 Brüche addiere, soll ich kuerze dann in der Methode addiere gleich anwenden?
In der Aufgabe steht, dass kuerze nich unnötig oft verwendet werden soll. 
Wie würdet ihr es machen:

Hier meine Addition-Methode:


```
public Bruch addiere( Bruch a){
        
        int z1 = zaehler  * a.getNenner();
        int z2 = nenner * a.getZaehler();
        int n= nenner*a.getNenner();
        return new Bruch(z1+z2, n);
      }
```


----------



## Informatikanfänger12 (14. Jan 2018)

Vllt kann mir jmd bitte sagen, wie ich folgende Methode noch programmieren kann:
Soll einen Bruch im Format „123/456“ in ein Objekt des Typs Bruch überführen und zurück geben. Ich habe doch schon die toString-Methode oder was sehe ich falsch?


----------



## Robat (14. Jan 2018)

Zu deiner 1. Frage: Ich würde nach dem addieren den Bruch noch mal kürzen lassen. Kommt aber auch auf die genaue Aufgabenstellung an.
Zu deiner 2. Frage: Das hat nichts mit `toString()` zu tun. Deine neue Methode soll einen String entgegen nehmen in der Form `123/456` und daraus dann ein Bruch-Objekt erstellen.
Diese soll zurückgegeben werden. Du müsstest also die Zahl vor dem Bruchstrich extrahieren und zum Zähler machen und die andere Zahl zum Nenner.


----------



## Informatikanfänger12 (14. Jan 2018)

Danke

Also zu 1.)


```
public Bruch addiere( Bruch a){
        
        int z1 = zaehler  * a.getNenner();
        int z2 = nenner * a.getZaehler();
        int n= nenner*a.getNenner();
       
        Bruch b=new Bruch(z1+z2,n);
        b.kuerze();
        return b;
      }
```

Ok so


Bei 2. weis ich nicht wie das genau gehen soll:

Wie kann ich da etwas extrahieren. Kannst du nochmal bitte weiterhelfen?


----------



## Robat (14. Jan 2018)

Schau dir mal die `String#split()` Methode an und `Integer#parseInt()`


----------



## Informatikanfänger12 (14. Jan 2018)

Also stimmt meine addiere Methode mit dem Kürzen?
Bei 2. woher weis ich, wann der / kommt?


----------



## Robat (14. Jan 2018)

Habs nur überflogen aber sieht gut aus.
2. Du musst nicht wissen wann das "/" kommt. Du kannst einen String an einem Zeichen splitten (in deinem Fall dem Bruchstrich). Dann bekommst du ein String-Array zurück was in einem Fall beide Zahlen enthalten würde. die kannst du dann umwandeln in Zahlen


----------



## Informatikanfänger12 (14. Jan 2018)

Wie kriege ich den formalen Parameter der Methode hin, also was muss die Methode genau entegegennehmen?
Ich versteh das nicht ganz
Aber danke für deine Hilfe bis dahin


----------



## Robat (14. Jan 2018)

Hier mal ein Beispiel 

```
String input = "12;4;3";
String[] inputArr = input.split(";");
for(int i = 0; i < inputArr.length; i++) {
    System.out.println(Integer.toString(inputArr[i]);
}
```
Das musst du jetzt nur noch auf dein Beispiel anpassen


----------



## Informatikanfänger12 (14. Jan 2018)

Was macht genau das 
Integer.toString(inputArr_



Habe es bis jetzt so:



		Java:In die Zwischenablage kopieren


public static  Bruch liesBruch(String input) {
       
        String[] inputArr = input.split("/");
       
        for(int i = 0; i < inputArr.length; i++) {
            System.out.println(Integer.toString(inputArr[i]);
        }
       
    }

_


----------



## Robat (14. Jan 2018)

Sorry .. da war ich beim schreiben wohl woanders. 
Das soll natürlich die `Integer.parseInt(String s)` Methode sein.
Diese nimmt einen String und wandelt ihn in ein int um.


----------



## Informatikanfänger12 (14. Jan 2018)

Kein Problem

Also ich splitte den String an der Stelle \.
Dann wandle ich ihn in eine Zahl um. Aber kriege daraus jetzt meine 2 Zahlen?


----------



## Robat (14. Jan 2018)

Informatikanfänger12 hat gesagt.:


> Dann wandle ich ihn in eine Zahl um


Du wandelst nicht *ihn* in eine Zahl um.

Nach dem split solltest du ein String-Array mit 2 Zahlen haben.

Die erste wandelst du in eine Zahl und wird zu deinem Zähler.
Die zweite wandelst du in eine Zahl und wird zu deinem Nenner.


----------



## Informatikanfänger12 (14. Jan 2018)

Schau mal, vllt so:


```
public static  Bruch liesBruch(String input) {
       
        String[] inputArr = input.split("/");
       
       
            int neuerZaehler=(Integer.parseInt(inputArr[0]));
            int neuerNenner=(Integer.parseInt(inputArr[1]));
           return new Bruch(neuerZaehler, neuerNenner);
           
        }
```

Da brauch ich keine for Schleife egtl?


----------



## Robat (14. Jan 2018)

Passt.


----------



## Informatikanfänger12 (14. Jan 2018)

Danke
Vllt nochmal zur Methode kuerze:
Man soll eine Klasse programmieren, welche eine nicht negative rationale Zahl mittels Bruchschreibweise korrekt darstellt.
Also soll ich kuerze in addiere und multipliziere reinnehmen oder nicht?
Man soll kuerze laut Aufgabe nicht unnötig oft verwenden?


----------



## Blender3D (14. Jan 2018)

Robat hat gesagt.:


> Zu deiner 1. Frage: Ich würde nach dem addieren den Bruch noch mal kürzen lassen. Kommt aber auch auf die genaue Aufgabenstellung an.





Informatikanfänger12 hat gesagt.:


> *public* Bruch addiere( Bruch a){
> 
> *int* z1 = zaehler  * a.getNenner();
> *int* z2 = nenner * a.getZaehler();
> ...


Macht die Methode addiere bereits da sie den Konstruktor Bruch( int, int ) mittels new aufruft. Dieser beinhaltet bereits das Kürzen.



Informatikanfänger12 hat gesagt.:


> *public* Bruch(*int* zaehler, *int* nenner){
> 
> *if*(zaehler<0 || nenner<0) {
> System.out.println("Positive Werte eingeben");
> ...


----------



## Informatikanfänger12 (14. Jan 2018)

Aha 
Dann hatte ich es schon die ganze Zeit, auch wenn ich es nichtmal wusste 
Danke euch für eure Hilfe


----------



## Bobi (15. Jan 2018)

Hallo! wie Prüfe ich diese Methode mit Junit in eclipse ?

```
public Bruch addiere( Bruch a){
       
        int z1 = zaehler  * a.getNenner();
        int z2 = nenner * a.getZaehler();
        int n= nenner*a.getNenner();
      
        Bruch b=new Bruch(z1+z2,n);
        b.kuerze();
        return b;
      }
```
Wie übergebe diese Bruch hier also

```
@Test
    public void testAddiere() {
        // Erzeuge einen Bruch zum Testen.
        Bruch einBruch = new Bruch();

        // Teste den Zaehler des Bruchs.
        assertThat("getNenner arbeitet nicht korrekt.",
               einBruch.addiere(new Bruch(1/2)), // so was funktioniert nicht
                is(equalTo(1)));
  
    }
```


----------



## mrBrown (15. Jan 2018)

Du musst schon einen existierenden Konstruktor aufrufen.
Einen, der *einen int* (der in deinem Test auch 0 wäre) entgegen nimmt, wird es nicht geben.


----------



## Bobi (15. Jan 2018)

Wie mache ich das?


----------



## truesoul (15. Jan 2018)

Bobi hat gesagt.:


> Wie mache ich das?



Hallo.

In dem du einen passenden Konstruktor dafür schreibst?

Grüße


----------

