# Methoden implementieren, Sichtbarkeiten, Brüche



## OPMajor (14. Nov 2017)

Hi
ich brauche etwas Hilfe bei einer Aufgabe.
Ich soll eine Klasse Fraction erstellen; diese hat als Attribute Zähler und Nenner, die nur in der Klasse sichtbat sind.
Ich soll Methoden schreiben zum
- addieren
- multiplizieren
- umrechnen in eine Fließkomma-Zahl
- Kehrwert bilden
- umrechnen in einen äquivalenen reduzierten Bruch(größter gemeinsamer Teiler-Algorithmus?; soll mit einer while-Schleife implementiert werden)

Den Methoden zum addieren und multiplizieren soll ein Objekt vom Typ Fraction übergeben werden.

Mein Anfang:

```
public class Fraction {
   public static void main(String[] args) {
   double zähler;
   double nenner;
   addieren();

}
   public static void addieren() {
       ergebnis=zähler + nenner //Geht es darum 2 Brüche zu addieren oder Zähler und Nenner?
   }
   public static void multiplizieren() {
       
   }
   public static void umrechnenFließkommaZahl(){
       
   }
   public static void kehrwertbilden() {
       
   }
   public static void umrechnen() {
       
   }
   
   }
```

Muss ich vor den Attributen private schrieben, um sie nur in der Klasse sichtbar zu machen?
Ist das mit dem Addieren so richtig, was ich geschrieben habe?


----------



## SchwarzWeiß (14. Nov 2017)

Attribute sollten (fast) immer private sein, ja. Aber momentan sind das keine Attribute sondern lokale Variablen in der Main-Methode. Ich würde die Main-Methode in eine eigene Klasse machen und dort dann die Fraction-Klasse benutzen. Dann brauchst du noch einen Konstruktor mit zähler und nenner als Parameter bzw. Setter-Methoden. Und die Methoden dann nicht mehr als static definieren.


----------



## Robat (14. Nov 2017)

Ich würde die addieren - Methode so interpretieren, dass ein andere Bruch übergeben wird, welcher zu dem Bruch addiert werden soll.
Steht irgendwo in der Aufgabenstellung, dass die Methoden static sein sollen oder hast du das so gemacht? Diese als static zu deklarieren ergibt in meinen Augen nicht viel Sinn.


----------



## Xyz1 (14. Nov 2017)

Möchtest du, dann lies dich hier mal ein:
https://codereview.stackexchange.com/questions/165219/implementation-of-a-fraction-class-in-java

Die Methoden in Fraction public,
die Methoden brauchen Parameter,
die Methoden brauchen einen Rückgabetyp,
die Methoden brauchen einen Rückgabewert,
den Sinn der Methode umrechnen habe ich noch nicht verstanden.


----------



## OPMajor (14. Nov 2017)

Robat hat gesagt.:


> Ich würde die addieren - Methode so interpretieren, dass ein andere Bruch übergeben wird, welcher zu dem Bruch addiert werden soll.
> Steht irgendwo in der Aufgabenstellung, dass die Methoden static sein sollen oder hast du das so gemacht? Diese als static zu deklarieren ergibt in meinen Augen nicht viel Sinn.


Ich war das.


----------



## OPMajor (14. Nov 2017)

Sieht das schon besser aus?

```
public class A {
   public static void main(String[] args) {
       public class Fraction{
           Fraction f=new Fraction();
   private double zähler;
   private double nenner;
   f.addieren();

}
   public double addieren() {
       ergebnis=zähler/nenner + zähler/nenner
               return;
   }
   public  double multiplizieren() {
       return;
   }
      
   }
   public  double umrechnenFließkommaZahl(){
       return;
   }
   public static double kehrwertbilden() {
       return;
   }
   public static double umrechnen() {
       return;
   }
  
   }
```


----------



## Robat (14. Nov 2017)

Hast du mal versucht das zu compilieren?


----------



## OPMajor (14. Nov 2017)

Robat hat gesagt.:


> Hast du mal versucht das zu compilieren?


Das macht er nicht.
Also ich meine, dass ich eine Fehlermeldung bekomme.


----------



## Robat (14. Nov 2017)

Das ist mir schon klar 
Jetzt bist du an der Reihe zu überlegen warum das so ist. Tipp: Überleg dir noch mal wie so eine Java-Klasse aufgebaut sein muss. Wo Methoden deklariert werden könnten etc.


----------



## OPMajor (14. Nov 2017)

So weit bin ich jetzt:

```
public class Fraction {
   public static void main(String[] args) {}
       public class Fraction1{
           Fraction1 f=new Fraction1();
   
   f.addieren();

}
   public double addieren() {
       private double zähler;
       private double nenner;
       double ergebnis=zähler/nenner + zähler/nenner
               return ergebnis;
   
   public  double multiplizieren() {
       
   }return;
       
   }
   public  double umrechnenFließkommaZahl(){
       return;
   }
   public  double kehrwertbilden() {
       return;
   }
   public  double umrechnen() {
       return nenner;
   }
```


----------



## OPMajor (14. Nov 2017)

Ist das besser:

```
public class Fraction {
   public static void main(String[] args) {}
       public class Fraction1{
           Fraction1 f=new Fraction1();
   
   

}
   public double addieren() {
       private double zähler;
       private double nenner;
       double anderezahl;
       double ergebnis = zähler/nenner + anderezahl;
               return ergebnis;
               
   
   public  double multiplizieren() {
       
   return;
       
   }
   public  double umrechnenFließkommaZahl(){
       double ergebnis1=zähler/nenner;
       return ergebnis1;
   }
   public  double kehrwertbilden() {
       
           
   }
       return;
   }
   public  double umrechnen() {
       return nenner;
   }
   
   }
```


----------



## Robat (14. Nov 2017)

Hier habe mal versucht den Code so zu formatieren wie es üblich ist.. soweit es ging.
Fällt dir nicht selber auch auf dass du tw. Code drin hast der so nicht compilieren kann?

- Befehle außerhalb von Methoden,
- Methodendeklaration außerhalb von Klassen,..
- Fehlende / falsch gesetzte Klammern


```
public class Fraction {

    public static void main(String[] args) {   
    }
       
    public class Fraction1 {
        Fraction1 f=new Fraction1();
   
    }
   
   public double addieren() {
        private double zähler;
        private double nenner;
        double anderezahl;
        double ergebnis = zähler/nenner + anderezahl;
        return ergebnis;
               
   
    public  double multiplizieren() {
       return;   
    }
   
    public  double umrechnenFließkommaZahl(){
       double ergebnis1=zähler/nenner;
       return ergebnis1;
    }
   
    public  double kehrwertbilden() {
    }
       
   return;
}
   
   public  double umrechnen() {
       return nenner;
   }
   
   }
```


----------



## Javinner (14. Nov 2017)

@Robat
- nicht parametrisierte Methoden
Methode addieren liefert so nichts, oder habe ich die Instanzvariablen übersehen?


----------



## Robat (14. Nov 2017)

@Javinner 
Ich weiß, dass einige Methoden so noch nicht richtig sind.
Es bringt allerdings nichts jetzt schon auf so etwas "rumzuhacken" wenn die Formatierung / syntaktische Schreibweise nicht stimmt


----------



## Javinner (14. Nov 2017)

Stach mir ins Auge, mehr nicht


----------



## OPMajor (14. Nov 2017)

Wie sieht es damit aus?

```
public class Fraction {
    double zähler;
     double nenner;

    public static void main(String[] args) {  
       Fraction f=new Fraction();
        f.addieren();
        f.multiplizieren();
        f.umrechnenFließkommaZahl();
        f.kehrwertbilden();
        f.umrechnen();
    }
       
 
   

   public class Fraction1 {
       
       
   
    }
   
   public double addieren() {
       
        double anderezahl = ;
        double ergebnis = zähler/nenner + anderezahl;
        return ergebnis;
   }
               
   
    public double multiplizieren() {
       
         double anderezahl1;
         double ergebnis1 = zähler/nenner + anderezahl1;
       return ergebnis1;
    }
         
   
   
    public  double umrechnenFließkommaZahl(){
       double ergebnis1=zähler/nenner;
       return ergebnis1;
    }
   
    public  double kehrwertbilden() {
       double ergebnis3=nenner/zähler;
   
       
   return ergebnis3;
}
   
    double umrechnen() {
       return ;
   }
   
   }
```


----------



## OPMajor (14. Nov 2017)

Diesen Code kann ich zumindest schon compilieren:

```
public class Fraction {
    double zähler =1;
     double nenner = 3;

    public static void main(String[] args) { 
       Fraction f=new Fraction();
        double x=f.addieren();
        double y=f.multiplizieren();
        f.umrechnenFließkommaZahl();
        f.kehrwertbilden();
       // f.umrechnen();
      
        System.out.println(x);
        System.out.println(y);
    }
      
 
  

   public class Fraction1 {
      
      
  
    }
  
   public double addieren() {
      
        double anderezahl = 2;
        double ergebnis = zähler/nenner + anderezahl;
        return ergebnis;
   }
              
  
    public double multiplizieren() {
      
         double anderezahl1 =2;
         double ergebnis1 = zähler/nenner*anderezahl1;
       return ergebnis1;
    }
        
  
  
    public  double umrechnenFließkommaZahl(){
       double ergebnis1=zähler/nenner;
       return ergebnis1;
    }
  
    public  double kehrwertbilden() {
       double ergebnis3=nenner/zähler;
  
      
   return ergebnis3;
    }
  
}
  
    /**double umrechnen() {
       return ;
   }
  
   }
  
  
*/
Konsole
2.3333333333333335
0.6666666666666666
```


----------



## Meniskusschaden (15. Nov 2017)

Du solltest dir vielleicht auch ein paar Gedanken darüber machen, was man von einer Klasse zur Abbildung von Brüchen eigentlich erwartet. Wie würdest du mit deiner Klasse z.B. die Rechnung `2/3 + 3/4` ausführen? Also wie erzeugst du die Brüche 2/3 und 3/4? Wie rufst du deren Addition auf? Und erwartet man von einer Fraction-Klasse wirklich, dass sie als Ergebnis eine Gleitkommazahl liefert?


----------



## SchwarzWeiß (15. Nov 2017)

Wolltest du nicht die Attribute als private deklarieren? Und wie schon gesagt, die main-Methode gehört nicht in eine Fachklasse. Erstelle eine eigene Main-Klasse dann ist das ganze viel lesbarer. So kann das nicht objektorientiert sein, du brauchst ja am Ende mindestens zwei Fraction-Objekte und da macht das kein Sinn, wenn jede davon eine main-Methode hat. Du darfst den Attributen auch nicht die Werte direkt zuweisen, sonst hat ja jeder Bruch die gleichen Zahlen. Wie gesagt, entweder ein parametrierter Konstruktor oder setter-Methoden. 

Und was soll das sein?



OPMajor hat gesagt.:


> ```
> public class Fraction1 {
> 
> }
> ```


----------



## Robat (15. Nov 2017)

Mal kurz zusammengefasst, was du schon hast:

Du sollst die Attribute `zaehler` und `nenner` die nur in der Klasse sichtbar sind anlegen. Die Attribute hast du zwar angelegt, sind aber noch außerhalb der Klasse sichtbar.
Die Struktur der Klasse sieht jetzt soweit richtig aus. Jetzt gilt es die Methoden richtig anzulegen. 
Überleg dir mal bei welchen Methoden es sind hat etwas zurückzugeben (wenn ja was) oder ob es Methoden gibt die eventuell nur das Objekt, auf dem die Methode aufgerufen wird, verändern und nichts zurückgeben. (Als kleines Beispiel würde ich hier die add-Methode nehmen welche mMn nur das eigentliche Objekt mit dem übergebenen addieren soll).
Versuch also erstmal die Methodensignaturen aufzuschreiben (ohne eigentliche Implementierung). Mach dir klar welche Methode was machen soll.


----------



## temi (15. Nov 2017)

Ich möchte dich nicht verwirren, aber als zusätzliche Information für später in deinem Programmiererleben:
Variablen in Java haben einen Gültigkeitsbereich. Wenn du innerhalb einer Funktion Variablen erzeugst, verlieren diese spätestens am Ende der Funktion ihre Gültigkeit und werden wieder zerstört. Aus diesem Grund ist es nicht notwendig die Variablen für das Ergebnis in unterschiedlichen Funktionen unterschiedlich zu benennen.


```
public double addieren() {
        double anderezahl = 2;
        double ergebnis = zähler/nenner + anderezahl; // Hier wird eine Variable Ergebnis lokal erzeugt
        return ergebnis;
   } // hier verliert sie ihre Gültigkeit

    public double multiplizieren() {
         double anderezahl1 =2;
         double ergebnis1 = zähler/nenner*anderezahl1; // dito lokale Variable Ergebnis1
         return ergebnis1;
    } // Ende der Gültigkeit
 
    public  double kehrwertbilden() {
       double ergebnis3=nenner/zähler; // und Ergebnis3
       return ergebnis3;
    } // Ende der Gültigkeit
```
[/QUOTE]

Aus dem obigen Beispiel: Die Funktion "multiplizieren" "weiß" nichts von der Variablen "ergebnis" aus der Funktion "addieren". Du kannst die Variablen demnach in allen Funktionen gleich benennen. Das erhöht die Lesbarkeit im Gegensatz zu "ergebnis123".

Noch ein kleines Beispiel zur Verdeutlichung:

```
public void doSomething() {
   int foo = 0; // Variable foo deklarieren und initialisieren
   for (int i = 0; i < 10; ++i) {
      foo = foo + i; // foo ist hier bekannt, weil sie in einem höheren Gültigkeitsbereich erzeugt wurde
      int bar = foo; // bar deklarieren und initialisieren
      } // hier endet der Gültigkeitsbereich von bar
   println(foo); // foo ist noch im Gültigkeitsbereich
   println(bar); // Fehler: bar ist hier nicht bekannt
   } // hier endet der Gültigkeitsbereich von foo
```


----------



## OPMajor (15. Nov 2017)

Robat hat gesagt.:


> Mal kurz zusammengefasst, was du schon hast:
> 
> Du sollst die Attribute `zaehler` und `nenner` die nur in der Klasse sichtbar sind anlegen. Die Attribute hast du zwar angelegt, sind aber noch außerhalb der Klasse sichtbar.
> Die Struktur der Klasse sieht jetzt soweit richtig aus. Jetzt gilt es die Methoden richtig anzulegen.
> ...


Also die Methoden addieren und multiplizieren verändern das Objekt bloß?


----------



## OPMajor (15. Nov 2017)

SchwarzWeiß hat gesagt.:


> Wolltest du nicht die Attribute als private deklarieren? Und wie schon gesagt, die main-Methode gehört nicht in eine Fachklasse. Erstelle eine eigene Main-Klasse dann ist das ganze viel lesbarer. So kann das nicht objektorientiert sein, du brauchst ja am Ende mindestens zwei Fraction-Objekte und da macht das kein Sinn, wenn jede davon eine main-Methode hat. Du darfst den Attributen auch nicht die Werte direkt zuweisen, sonst hat ja jeder Bruch die gleichen Zahlen. Wie gesagt, entweder ein parametrierter Konstruktor oder setter-Methoden.
> 
> Und was soll das sein?


Kann ich nicht einen Scanner verwenden für die Zahlen?
Ich soll jetzt in einem ganz neuen Fenster eine neue Klasse erstellen, oder?


----------



## SchwarzWeiß (15. Nov 2017)

OPMajor hat gesagt.:


> Kann ich nicht einen Scanner verwenden für die Zahlen?
> Ich soll jetzt in einem ganz neuen Fenster eine neue Klasse erstellen, oder?


Du kannst einen Scanner verwenden, ja. Aber trotzdem müssen die Zahlen die du vom Scanner hast auch irgendwie ins Objekt, daher setter oder parametrierter Konstruktor.
Ja genau und da drin ist einfach nur die main-Methode.


----------



## temi (15. Nov 2017)

OPMajor hat gesagt.:


> Ich soll jetzt in einem ganz neuen Fenster eine neue Klasse erstellen, oder?



Genau. Du solltest zwei separate Klassen haben. Eine, die die "static main" enthält und in der du später deine Fraction-Objekte erstellst, addierst, Eingaben verarbeitest, Ausgaben machst usw.
Und eine Klasse Fraction.

Diese beiden Klassen sollten in je einer separaten Quelltext-Datei sein.


----------



## OPMajor (15. Nov 2017)

SchwarzWeiß hat gesagt.:


> Du kannst einen Scanner verwenden, ja. Aber trotzdem müssen die Zahlen die du vom Scanner hast auch irgendwie ins Objekt, daher setter oder parametrierter Konstruktor.
> Ja genau und da drin ist einfach nur die main-Methode.


Kannst du mir sagen wie das mit dem Konstruktor aussieht?


----------



## OPMajor (15. Nov 2017)

So?

```
import java.util.Scanner;


public class Fraction {
    double zähler =1;
     double nenner = 3;

   
   
   public double addieren() {
       
        double anderezahl = 2;
        double ergebnis = zähler/nenner + anderezahl;
        return ergebnis;
   }
               
   
    public double multiplizieren() {
       
         double anderezahl1 =2;
         double ergebnis1 = zähler/nenner*anderezahl1;
       return ergebnis1;
    }
         
   
   
    public  double umrechnenFließkommaZahl(){
       double ergebnis1=zähler/nenner;
       return ergebnis1;
    }
   
    public  double kehrwertbilden() {
       double ergebnis3=nenner/zähler;
   
       
   return ergebnis3;
    }
   
}
   
    /**double umrechnen() {
       return ;
   }
   
   }
   
   
*/
```


```
public class A {
    public static void main(String[] args) {  
           Fraction f=new Fraction();
            double x=f.addieren();
            double y=f.multiplizieren();
            f.umrechnenFließkommaZahl();
            f.kehrwertbilden();
           // f.umrechnen();
           
            System.out.println(x);
            System.out.println(y);
       }
}
```


----------



## SchwarzWeiß (15. Nov 2017)

OPMajor hat gesagt.:


> Kannst du mir sagen wie das mit dem Konstruktor aussieht?




```
public Klassenname(int attributname){
this.attributname = attributname;
}
```


----------



## Robat (15. Nov 2017)

@OPMajor 
Kleiner Rat meiner Seits: Dir dir auf jeden Fall noch mal ein gutes Buch / Tutorial zur Hand nehmen und die Grundlagen durchgehen.

B2T:
Du hast weder einen Konstruktor eingefügt, noch den Methoden Parameter gegeben, noch die Attribute privat gemacht.


----------



## SchwarzWeiß (15. Nov 2017)

OPMajor hat gesagt.:


> So?


Was die Trennung der Main von der Fachklasse betrifft, ja. Jetzt noch den Konstruktor einfügen und Attribute private deklarieren und dann können wir uns der Additions- und der Multiplikationsmethode widmen.


----------



## OPMajor (15. Nov 2017)

```
import java.util.Scanner;


public class Fraction {
   Scanner eingabe= new Scanner (System.in);
   
   
    private double zähler =eingabe.nextDouble();
     private double nenner = eingabe.nextDouble();
   
     

   
   
   
   
public double addieren( double zähler,double nenner ) {
       
        double anderezahl = 2;
        double ergebnis = zähler/nenner + anderezahl;
        return ergebnis;
   }
               
   
    public double multiplizieren(double zähler,double nenner) {
       
         double anderezahl1 =2;
         double ergebnis1 = zähler/nenner*anderezahl1;
       return ergebnis1;
    }
         
   
   
    public  double umrechnenFließkommaZahl(){
       double ergebnis1=zähler/nenner;
       return ergebnis1;
    }
   
    public  double kehrwertbilden() {
       double ergebnis3=nenner/zähler;
   
       
   return ergebnis3;
    }
   
}
   
    /**double umrechnen() {
       return ;
   }
   
   }
   
   
*/
```


```
public class A {
    public static void main(String[] args) {  
           Fraction f=new Fraction();
            f.addieren(0, 0);
            f.multiplizieren(0, 0);
            f.umrechnenFließkommaZahl();
            f.kehrwertbilden();
           // f.umrechnen();
           
           
           
       }
}
```


----------



## OPMajor (15. Nov 2017)

SchwarzWeiß hat gesagt.:


> Was die Trennung der Main von der Fachklasse betrifft, ja. Jetzt noch den Konstruktor einfügen und Attribute private deklarieren und dann können wir uns der Additions- und der Multiplikationsmethode widmen.


Der Konstruktor wird in der Fraction-Klasse eingefügt, richtig?


----------



## SchwarzWeiß (15. Nov 2017)

OPMajor hat gesagt.:


> Der Konstruktor wird in der Fraction-Klasse eingefügt, richtig?


Genau.


----------



## JStein52 (15. Nov 2017)

Ich kenne ja die Aufgabenstellung nicht, die hast du ja nicht so genau gepostet. Aber für mich sind alle deine Methoden (addieren, subtrahieren, multiplizieren und dividieren) im Ansatz falsch. Für mein Begriffe sollst du wahrscheinlich jeweils zwei Brüche addieren, subtrahieren usw. und als Ergebnis jeweils einen neuen Bruch zurückliefern. Schreibst du ja ansatzweise im ersten Post dass addieren einen Bruch als Parameter kriegen soll.


----------



## JStein52 (15. Nov 2017)

Und ja ich weiss, man kann einen Bruch auch als 3.14/2.09 schreiben aber üblicherweise sind Zähler und Nenner doch ganze Zahlen, d.h. deine Attribute sollten wohl vom Typ int sein ?? Oder wie bestimmst du den ggT bzw. wie wolltest du kürzen ? ggt = 0.001 ??


----------



## OPMajor (15. Nov 2017)

JStein52 hat gesagt.:


> Ich kenne ja die Aufgabenstellung nicht, die hast du ja nicht so genau gepostet. Aber für mich sind alle deine Methoden (addieren, subtrahieren, multiplizieren und dividieren) im Ansatz falsch. Für mein Begriffe sollst du wahrscheinlich jeweils zwei Brüche addieren, subtrahieren usw. und als Ergebnis jeweils einen neuen Bruch zurückliefern. Schreibst du ja ansatzweise im ersten Post dass addieren einen Bruch als Parameter kriegen soll.


Aufgabe:
A03.3: Brüche
Erstellen Sie eine Klasse Fraction, als Attribute hat diese Klasse Zähler und Nenner, die nur in der Klasse sichtbar sind.
Schreiben Sie Methoden zum addieren, multiplizieren, umrechnen in eine Fließkomma-Zahl, kehrwert bilden und zum
umrechnen in einen äquivalenten reduzierten Bruch (benutzen Sie hier den in der Vorlesung vorgestellten Algorithmus,
implementieren Sie diesen mit Hilfe einer while-Schleife). Den Methoden zum addieren und multiplizieren wird dabei
ebenfalls ein Objekt vom Typ Fraction übergeben.
Ziel: Methoden implementieren

Der Algorithmus ist im Anhang.


----------



## OPMajor (15. Nov 2017)

SchwarzWeiß hat gesagt.:


> Genau.


Muss im Konstruktor nicht auch double hin anstatt int?

```
import java.util.Scanner;


public class Fraction {
   Scanner eingabe= new Scanner (System.in);
  
  
    private double zähler =eingabe.nextDouble();
     private double nenner = eingabe.nextDouble();
    
     public Fraction(int zähler, int nenner){
        this.zähler = zähler;
        this.nenner = nenner;
        }
    
    

  
  
  
  
public double addieren( double zähler,double nenner ) {
      
        double anderezahl = 2;
        double ergebnis = zähler/nenner + anderezahl;
        return ergebnis;
   }
              
  
    public double multiplizieren(double zähler,double nenner) {
      
         double anderezahl1 =2;
         double ergebnis1 = zähler/nenner*anderezahl1;
       return ergebnis1;
    }
        
  
  
    public  double umrechnenFließkommaZahl(){
       double ergebnis1=zähler/nenner;
       return ergebnis1;
    }
  
    public  double kehrwertbilden() {
       double ergebnis3=nenner/zähler;
  
      
   return ergebnis3;
    }
  
}
  
    /**double umrechnen() {
       return ;
   }
  
   }
  
  
*/
```


----------



## SchwarzWeiß (15. Nov 2017)

OPMajor hat gesagt.:


> Muss im Konstruktor nicht auch double hin anstatt int?


Das war ja nur ein Beispiel von mir, die Parameter im Konstruktor sollten den selben Datentyp haben wie die Attribute, ja. Mach den Scanner und die Eingaben mal raus, das gehört in die Main-Methode, aber das ist momentan nicht so wichtig.


----------



## JStein52 (15. Nov 2017)

OPMajor hat gesagt.:


> Muss im Konstruktor nicht auch double hin anstatt int?


Im Gegenteil. Deine Attribute sollten int sein ...


----------



## OPMajor (15. Nov 2017)

JStein52 hat gesagt.:


> Im Gegenteil. Deine Attribute sollten int sein ...


okay; habe ich geändert.


----------



## JStein52 (15. Nov 2017)

Dann hast du jetzt einen Konstruktor der Zähler und Nenner als Parameter übergeben kriegt und du weist diese Werte den entsprechenden Attributen zu.


----------



## JStein52 (15. Nov 2017)

Dann geben wir jetzt Gas bevor das Wintersemester um ist. Die Methode addiere sieht dann so aus:


```
public Fraction addiere(Fraction bruch) {
...
...
}
```

Edit: wie addiert man zwei Brüche ??


----------



## OPMajor (15. Nov 2017)

```
public class Fraction {
    private int zähler =x;
     private int nenner = y;
    
     public Fraction(int zähler, int nenner){
      
        this.zähler = zähler;
        this.nenner = nenner;
        }
    
    

  
  
  
  
public Fraction addieren( Fraction zähler/nenner ) { //hier zeigt es mir bei nenner einen Fehler an
      
        double anderezahl = 2;
        double ergebnis = zähler/nenner + anderezahl;
        return ergebnis;
   }
              
  
    public double multiplizieren(double zähler,double nenner) {
      
         double anderezahl1 =2;
         double ergebnis1 = zähler/nenner*anderezahl1;
       return ergebnis1;
    }
        
  
  
    public  double umrechnenFließkommaZahl(){
       double ergebnis1=zähler/nenner;
       return ergebnis1;
    }
  
    public  double kehrwertbilden() {
       double ergebnis3=nenner/zähler;
  
      
   return ergebnis3;
    }
  
}
  
    /**double umrechnen() {
       return ;
   }
  
   }
  
  
*/
```


```
import java.util.Scanner;

public class A {
    public static void main(String[] args) { 
      
      
           Fraction f=new Fraction(0, 0);
           Scanner eingabe= new Scanner (System.in);
            int x =eingabe.nextInt();
             int y = eingabe.nextInt();
          
          
            f.addieren(0, 0);
            f.multiplizieren(0, 0);
            f.umrechnenFließkommaZahl();
            f.kehrwertbilden();
           // f.umrechnen();
          
          
          
       }
}
```


----------



## JStein52 (15. Nov 2017)

Konstruktor ist richtig aber addieren ist falsch. Die soll einen Bruch als Parameter erhalten !!
Und man addiert dann zwei Brueche indem man den Hauptnenner bildet, die Zaehler jeweils erweitert und dann addiert.


----------



## SchwarzWeiß (15. Nov 2017)

Du sollst ein Objekt mitgeben. Also kein "/", kein Nenner, kein Zähler, einfach nur ein Fraction-Objekt wie es JStein52 schon gepostet hat.
Und reduzier mal die große Lücke im Code nach dem Konstruktor.


----------



## JStein52 (15. Nov 2017)

```
public Fraction addiere(Fraction b) {
        // Hauptnenner bilden
        int common = hauptNenner(this.nenner, b.nenner);
        // zwei neue Brüche anlegen die dann passend erweitert werden
        Fraction commonA = new Fraction();
        Fraction commonB = new Fraction();
        commonA = erweitern(common);
        commonB = b.erweitern(common);
        // neuen Bruch anlegen fuer das Ergebnis
        Fraction sum = new Fraction();
        // berechne die Summe
        sum.zaehler = commonA.zaehler + commonB.zaehler;
        sum.nenner = common;
        // hier könnte man jetzt noch kuerzen

        return sum;
    }
```



```
private int hauptNenner(int nenner1, int nenner2) {
        int factor = nenner1;
        while ((nenner1 % nenner2) != 0) {
            nenner1 += factor;
        }
        return nenner1;
    }
```


```
private Fraction erweitern(int common) {
        Fraction result = new Fraction();
        int factor = common / this.nenner;
        result.zaehler = this.zaehler * factor;
        result.nenner = common;
        return result;
    }
```

Das wäre jetzt der Code zum addieren.


----------



## OPMajor (15. Nov 2017)

```
import java.util.Scanner;


public class Fraction {
    private int zähler =x;
     private int nenner = y;
     
     public Fraction(int zähler, int nenner){
       
        this.zähler = zähler;
        this.nenner = nenner;
        }
     
public Fraction addieren( Fraction bruch  ) {
        int zähler1=z;
        int nenner1=v;
        int ergebnis = (zähler*nenner2)/(nenner*nenner2)+ (zähler1*nenner)/(nenner1*nenner);
        return ergebnis;
   }
               
    public double multiplizieren(double zähler,double nenner) {
       
         double anderezahl1 =2;
         double ergebnis1 = zähler/nenner*anderezahl1;
       return ergebnis1;
    }
         
     public  double umrechnenFließkommaZahl(){
       double ergebnis1=zähler/nenner;
       return ergebnis1;
    }
   
    public  double kehrwertbilden() {
       double ergebnis3=nenner/zähler;
   
       
   return ergebnis3;
    }
   
}
   
    /**double umrechnen() {
       return ;
   }
   
   }
   
   
*/
```


```
import java.util.Scanner;

public class A {
    public static void main(String[] args) {  
       
       
           Fraction f=new Fraction(0, 0);
           Scanner eingabe= new Scanner (System.in);
            int x =eingabe.nextInt();
             int y = eingabe.nextInt();
           
           
            f.addieren(0, 0);
            f.multiplizieren(0, 0);
            f.umrechnenFließkommaZahl();
            f.kehrwertbilden();
           // f.umrechnen();
           
           
           
       }
}
```


----------



## SchwarzWeiß (15. Nov 2017)

Der Datentyp der Rückgabe ist Fraction, du willst aber ein int zurückgeben...


----------



## JStein52 (15. Nov 2017)

OPMajor hat gesagt.:


> *private* *int* zähler =x;
> *private* *int* nenner = y;


Da gehts schon los. Setze einfach auf Initialwert 0; die Dinger kriegen ja ihre Werte dann im Konstruktor.


OPMajor hat gesagt.:


> *public* Fraction addieren( Fraction bruch  ) {
> *int* zähler1=z;
> *int* nenner1=v;
> *int* ergebnis = (zähler*nenner2)/(nenner*nenner2)+ (zähler1*nenner)/(nenner1*nenner);
> ...


Und was ist hier z und v ? und nenner2 und warum ist das Ergebnis eine Integerzahl ? Du willst doch einen neuen Bruch (den Summenbruch) zurückgeben.


----------



## OPMajor (15. Nov 2017)

So?

```
public Fraction addieren( Fraction bruch  ) {
        Fraction zähler1=0;
        int nenner1=0;
        Fraction ergebnis = (zähler*nenner1)/(nenner*nenner1)+ (zähler1*nenner)/(nenner1*nenner);
        return ergebnis;
```


----------



## SchwarzWeiß (15. Nov 2017)

Nein, du kannst Fraction nicht einfach eine Zahl zuweisen. Du musst eine neue Instanz von Fraction erzeugen, das geschieht in dem du den Konstruktor aufrufst, dem du Zähler und Nenner mitgeben musst.


----------



## JStein52 (15. Nov 2017)

Ach so, du hast Probleme meine Lösung mit deiner zu vergleichen weil die auch noch einen parameterlosen Konstruktor hat ??


----------



## SchwarzWeiß (15. Nov 2017)

JStein52 hat gesagt.:


> ```
> sum.zaehler = commonA.zaehler + commonB.zaehler;
> sum.nenner = common;
> ```


Das funktioniert ja nur, wenn die Attribute nicht als private deklariert wurden.

EDIT: Fehler meinerseits, es funktioniert doch, wir befinden uns ja in der Fraction-Klasse. Dann brauchst du um die Lösung von JStein52 zu übernehmen noch einen parameterlosen Konstruktor.


----------



## JStein52 (15. Nov 2017)

SchwarzWeiß hat gesagt.:


> wir befinden uns ja in der Fraction-Klasse


Jepp. Genau


----------



## OPMajor (15. Nov 2017)

JStein52 hat gesagt.:


> Ach so, du hast Probleme meine Lösung mit deiner zu vergleichen weil die auch noch einen parameterlosen Konstruktor hat ??


Also mir zeigt es einen Fehler an,wenn ich den Konstruktor parameterlos lasse.

Und wie kann ich testen(kompilieren), um zu sehen, ob die Methode jetzt das macht, was verlangt wird?
Mit System.out.println(sum)? Wenn ja, wo müsste ich das einfügen?


----------



## JStein52 (15. Nov 2017)

OPMajor hat gesagt.:


> Also mir zeigt es einen Fehler an,wenn ich den Konstruktor parameterlos lasse.


In dem parameterlosen Konstruktor musst du dann die Attribute (zähler, nenner einfach auf 0 setzen.
Und testen kannst du es am besten indem du deiner Klasse noch eine toString() - Methode gibst die ewta so aussieht:

```
public String toString() {
        String buffer = zaehler + "/" + nenner;
        return buffer;
    }
```
dann kannst du in deiner main-Methode schreiben:

```
Fraction bruch1 = new Fraction(2,3);  // 2/3
Fraction bruch2 = new Fraction(3,4);  // 3/4
Fraction summe = bruch1.addieren(bruch2);
System.out.println("Die Summe ergibt "+summe);
```

Edit: damit keine Missverständnisse entstehen: den Konstruktor mit den beiden Parametern brauchst du schon auch noch


----------



## JStein52 (15. Nov 2017)

Übrigens, um noch mal auf deinen Lösungsversuch einzugehen: du kannst schon auch einfach über Kreuz mit den beiden Nennern multiplizieren und dann die Zähler addieren. Dann aber richtig:

```
public Fraction addiere(Fraction b) {
           int num1 = (this.zaehler * b.nenner) + (b.zaehler * this.nenner);
           int num2 = this.nenner * b.nenner;
           return new Fraction(num1, num2);
    }
```
Und das Ergebnis ist dann richtig aber in der Schule lernt man ja den Hauptnenner als kleinstes gemeinsames Vielfaches von Nenner1 und Nenner2 zu bilden.


----------



## OPMajor (15. Nov 2017)

Bei mir gibt es keine Ausgabe bzw. es heißt, es wird ausgeführt(endlos).

```
public class Fraction {
    private int zähler =0;
     private int nenner = 0;
    
     public String toString() {
         String buffer = zähler + "/" + nenner;
         return buffer;
     }
 
     public Fraction(int zähler, int nenner){
      
        this.zähler = zähler;
        this.nenner = nenner;
     }
    
public Fraction addiere(Fraction b) {
    // Hauptnenner bilden
    int common = hauptNenner(this.nenner, b.nenner);
    // zwei neue Brüche anlegen die dann passend erweitert werden
    Fraction commonA = new Fraction(0,0);
    Fraction commonB = new Fraction(0,0);
    commonA = erweitern(common);
    commonB = b.erweitern(common);
    // neuen Bruch anlegen fuer das Ergebnis
    Fraction sum = new Fraction(0,0);
    // berechne die Summe
    sum.zähler = commonA.zähler + commonB.zähler;
    sum.nenner = common;
    // hier könnte man jetzt noch kuerzen

    return sum;
}
private int hauptNenner(int nenner1, int nenner2) {
    int factor = nenner1;
    while ((nenner1 % nenner2) != 0) {
        nenner1 += factor;
    }
    return nenner1;
}
private Fraction erweitern(int common) {
    Fraction result = new Fraction(1,2);
    int factor = common / this.nenner;
    result.zähler = this.zähler * factor;
    result.nenner = common;
    return result;
}
              
    public double multiplizieren(double zähler,double nenner) {
      
         double anderezahl1 =2;
         double ergebnis1 = zähler/nenner*anderezahl1;
       return ergebnis1;
    }
        
     public  double umrechnenFließkommaZahl(){
       double ergebnis1=zähler/nenner;
       return ergebnis1;
    }
  
    public  double kehrwertbilden() {
       double ergebnis3=nenner/zähler;
  
      
   return ergebnis3;
    }

}  

  
    /**double umrechnen() {
       return ;
   }
   }
  
  
*/
```


```
import java.util.Scanner;

public class A {
    public static void main(String[] args) { 
      
      
           Fraction f=new Fraction(1,2);
           @SuppressWarnings("resource")
           Scanner eingabe= new Scanner (System.in);
            eingabe.nextInt();
            eingabe.nextInt();
          
          
            f.addiere(f);
            Fraction bruch1 = new Fraction(2,3);  // 2/3
            Fraction bruch2 = new Fraction(3,4);  // 3/4
            Fraction summe = bruch1.addiere(bruch2);
            System.out.println("Die Summe ergibt "+summe);
            f.multiplizieren(0, 0);
            f.umrechnenFließkommaZahl();
            f.kehrwertbilden();
           // f.umrechnen();
```


----------



## JStein52 (15. Nov 2017)

OPMajor hat gesagt.:


> Bei mir gibt es keine Ausgabe bzw. es heißt, es wird ausgeführt(endlos).


Zeig mal deine main


----------



## JStein52 (15. Nov 2017)

Ah ok, da ist sie aj. Du wartest da mit eingabe.nextInt() auf die Eingabe von zwei Zahlen. Deshalb geht es nicht weiter


----------



## OPMajor (15. Nov 2017)

Die Summe ergibt 17/12. Egal was ich eingebe.


----------



## JStein52 (15. Nov 2017)

OPMajor hat gesagt.:


> Egal was ich eingebe.


Ja, weil du immer 2/3 und 3/4 addierst. Du verwendest ja die eingabe gar nicht ...


----------



## JStein52 (15. Nov 2017)

```
Scanner eingabe= new Scanner (System.in);
            int zaehler1 = eingabe.nextInt();
            int nenner1 = eingabe.nextInt();
            int zaehler2 = eingabe.nextInt();
            int nenner2 = eingabe.nextInt();

          
          
            f.addiere(f);
            Fraction bruch1 = new Fraction(zaehler1,nenner1);
            Fraction bruch2 = new Fraction(zaehler2,nenner2);
```
Wenn du es so änderst muss du 4 Zahlen eingeben und erhältst dann ein passendes Ergebnis


----------



## OPMajor (15. Nov 2017)

Danke, das habe ich jetzt gemacht.
Und wie mache ich das mit dem Multiplizieren?

Ich muss zugeben, dass ich die addiere-Methode noch nicht ganz nachvollziehen kann, wie und warum sie das macht, was sie macht.


----------



## JStein52 (15. Nov 2017)

Analog zu addieren. Die Methode hat den gleichen Parameter und den gleichen return-Typ (Fraction). Dann berechnest du darin den Zaehler und Nenner des Ergebnis-Bruchs, erstellst mit diesen Werten per new Fraction(neuerZaehler, neuerNenner) und returnst dieses Ergebnis.


----------



## JStein52 (15. Nov 2017)

Und zum Kürzen eines Bruches kommst du ja noch, damit kannst du jeweils die Ergebnisse von addieren und multiplizieren noch "nachbehandeln"


----------



## OPMajor (15. Nov 2017)

So?

```
public Fraction multiplizieren(Fraction b) {
  
         Fraction Produkt =  this.zähler / this.nenner; * b.zähler/b.nenner;
       return Produkt;
    }
```


----------



## Robat (15. Nov 2017)

OPMajor hat gesagt.:


> Fraction Produkt = *this*.zähler / *this*.nenner; * b.zähler/b.nenner;


Schau dir noch mal die Anzahl der Semikolons an...


----------



## JStein52 (15. Nov 2017)

OPMajor hat gesagt.:


> Fraction Produkt = *this*.zähler / *this*.nenner; * b.zähler/b.nenner;


Diese Zeile ist völlig falsch. Wie erstellst du denn wenn du zaehler und nenner hast daraus ein neues Fraction-Objekt ?


----------



## SchwarzWeiß (16. Nov 2017)

Das habe ich ja hier schon geschrieben


SchwarzWeiß hat gesagt.:


> Nein, du kannst Fraction nicht einfach eine Zahl zuweisen. Du musst eine neue Instanz von Fraction erzeugen, das geschieht in dem du den Konstruktor aufrufst, dem du Zähler und Nenner mitgeben musst.


Du solltest dir vielleicht nochmal genau anschauen, was komplexe Datentypen sind und wie man sie verwendet.

Und in Java ist es Konvention, nur Klassen großzuschreiben, daher solltest du Produkt kleinschreiben.


----------



## OPMajor (16. Nov 2017)

Ich glaube, ich schaffe die Aufgabe rechtzeitig nicht mehr.


----------



## JStein52 (16. Nov 2017)

OPMajor hat gesagt.:


> Ich glaube, ich schaffe die Aufgabe rechtzeitig nicht mehr


Warum nicht ? Wo hast du das Problem ? Du hast ja die addieren(...)  und genau analog machst du dir eine multiplizieren. Dann schreibst du dir auf wie du zwei Brüche multiplizierst (neuer Zähler ?? neuer Nenner ??),
dann schreibst du das "in Java" hin und erstellst mit diesem neuenZaehler und neuenNenner einen neuen Bruch, analog wie bei addieren !!  Ist im Prinzip nix neues. Und diesen neuen Bruch return'st du.  Und auch der Test in main geht genau analog zum addieren !


----------



## SchwarzWeiß (16. Nov 2017)

OPMajor hat gesagt.:


> Ich glaube, ich schaffe die Aufgabe rechtzeitig nicht mehr.


Wann musst du es denn abgeben?


----------



## OPMajor (16. Nov 2017)

So?

```
public Fraction multiplizieren(Fraction b) {                  
       Fraction commonA = new Fraction(0,0);
        Fraction commonB = new Fraction(0,0);
        Fraction produkt = new Fraction(0,0);
        produkt.zähler = commonA.zähler * commonB.zähler;
        produkt.nenner = commonA.nenner  * commonB.nenner;
 
       return produkt;
    }
```


```
Fraction bruch1 = new Fraction(x,y);  // 2/3
            Fraction bruch2 = new Fraction(v,z);  // 3/4
            Fraction summe = bruch1.addiere(bruch2);
            System.out.println("Die Summe ergibt "+summe);
            Fraction bruch3 = new Fraction(x,y);  // 2/3
            Fraction bruch4 = new Fraction(v,z);  // 3/4
            Fraction produkt = bruch3.addiere(bruch4);
            System.out.println("Die Produkt ist "+pro);
```


----------



## SchwarzWeiß (16. Nov 2017)

Nein. Du gibst b als Parameter mit, also brauchst du kein commonB neu erzeugen. Und commonA auch nicht, dafür benutzt du this.


----------



## OPMajor (16. Nov 2017)

SchwarzWeiß hat gesagt.:


> Nein. Du gibst b als Parameter mit, also brauchst du kein commonB neu erzeugen. Und commonA auch nicht, dafür benutzt du this.


Hier ist auch noch ein Fehler drin, oder?

```
public Fraction multiplizieren(Fraction b) {                   
    /*raction commonA = new Fraction(0,0);
        Fraction commonB = new Fraction(0,0);
 */     Fraction produkt = new Fraction(0,0);
        produkt.zähler = this.zähler *b.zähler;
        produkt.nenner = this.nenner     *      b.nenner;
 
       return produkt;
    }
```


----------



## JStein52 (16. Nov 2017)

So:

```
public Fraction multipliziere(Fraction b) {
        // create new fraction to return as product
        Fraction produkt = new Fraction();
        // calculate product
        produkt.zaehler = zaehler * b.zaehler;
        produkt.nenner = nenner * b.nenner;
        return produkt;
    }
```

Edit: ok, bei dir heisst der Zähler "zähler" ansonsten passt es glaube ich


----------



## OPMajor (16. Nov 2017)

Jetzt geht es:

```
public Fraction multiplizieren(Fraction b) {                   

     Fraction produkt = new Fraction(0,0);
        produkt.zähler = this.zähler *b.zähler;
        produkt.nenner = this.nenner * b.nenner;
 
       return produkt;
    }
```


```
Fraction bruch1 = new Fraction(x,y);  // 2/3
            Fraction bruch2 = new Fraction(v,z);  // 3/4
            Fraction summe = bruch1.addiere(bruch2);
            System.out.println("Die Summe ergibt "+summe);
            Fraction bruch3 = new Fraction(x,y);  // 2/3
            Fraction bruch4 = new Fraction(v,z);  // 3/4
            Fraction pro = bruch3.multiplizieren(bruch4);
            System.out.println("Die Produkt ist "+pro);
```


----------



## JStein52 (16. Nov 2017)

Na also, geht doch


----------



## SchwarzWeiß (16. Nov 2017)

Kleine Anmerkung, du hast "die" Produkt geschrieben  und es ist Konvention, zur Lesbarkeit vor und nach dem Plus ein Leerzeichen zu machen.

Hast du dann alle Methoden?


----------



## JStein52 (16. Nov 2017)

SchwarzWeiß hat gesagt.:


> Hast du dann alle Methoden?


Nein hat er nicht.  Es fehlen:
- public double umrechnen()
- public Fraction kehrwert()
- public Fraction kuerzen()


----------



## OPMajor (16. Nov 2017)

SchwarzWeiß hat gesagt.:


> Kleine Anmerkung, du hast "die" Produkt geschrieben  und es ist Konvention, zur Lesbarkeit vor und nach dem Plus ein Leerzeichen zu machen.
> 
> Hast du dann alle Methoden?


Nein, es fehlen noch drei.
- Umrechnen in Fließkommazahl
- kehrwert
- ggt


----------



## JStein52 (16. Nov 2017)

OPMajor hat gesagt.:


> - ggt


Nun ja, die Aufgabe sagt umrechnen in einen reduzierten Bruch, also kuerzen() und dazu brauchst du intern den ggT


----------



## JStein52 (16. Nov 2017)

JStein52 hat gesagt.:


> public double umrechnen()


Wie geht die ?

Edit: ein Tip, es ist ein Einzeiler


----------



## OPMajor (16. Nov 2017)

JStein52 hat gesagt.:


> Wie geht die ?
> 
> Edit: ein Tip, es ist ein Einzeiler


So?

```
public  double umrechnenFließkommaZahl(Fraction b) {
    double    umrechnung = this.zähler / this.nenner;  
   
       return umrechnung;
    }
```


----------



## JStein52 (16. Nov 2017)

OPMajor hat gesagt.:


> So?


Fast. Du musst bedenken dass zähler und nenner Integers sind und die Integerdivision 3/5 ergibt 0 !
Oder 5/3 ergibt 1

Edit: und einen Parameter braucht diese Methode auch nicht. Die arbeitet ja nur mit this


----------



## JStein52 (16. Nov 2017)

Das Zauberwort ist casten. Du musst dem Compiler bei der Division sagen dass es sich um double-Werte handeln soll die er dividiert.

```
public  double umrechnenFließkommaZahl() {
    double    umrechnung = (double)this.zähler / (double)this.nenner;  
   
       return umrechnung;
    }
```


----------



## OPMajor (16. Nov 2017)

```
public  Fraction kehrwert() {
        Fraction k = new Fraction(0,0);
        k.zähler = this.nenner;
        k.nenner = this.zähler;
        return k;
   
    }
```


----------



## JStein52 (16. Nov 2017)

kehrwert stimmt !!


----------



## JStein52 (16. Nov 2017)

und für die public Fraction kuerzen() solltest du dir zunächst mal eine
private int ggT(int a, int b)
machen die den grössten gemeinsamen Teiler zweier Zahlen berechnet.
Und in kuerzen rufst du dir dann zuächst mal die ggT auf mit zähler und nenner als Parameter.
Dann dividierst du Zähler und Nenner durch das Ergebnis des ggT und machst daraus wieder einen neuen Bruch den du return'st


----------



## OPMajor (16. Nov 2017)

```
private int ggT(int a, int b) {
    int r;
   
    do{
       r=a%b;
       a=b;
       b=r;
       }while (r!=0);
    }
```


----------



## OPMajor (16. Nov 2017)

```
prublic Fraction kürzen() {
    Fraction c= new Fraction(0,0);
    ggT(int a, int b);
    c.zähler = this.zähler / a;
    c.nenner = this.nenner / a;
    return c;
```


----------



## JStein52 (16. Nov 2017)

Das hier ist eine Standard-ggT die du üerall im Netz findest:

```
private int ggT(int a, int b) {
        while (a != 0 && b != 0) {
            a = a % b;
            if (a == 0) {
                return b;
            }
            b = b % a;
            if (b == 0) {
                return a;
            }
        }
        return 1;
    }
```

Ich habe deine ggT mal getestet, ich nehme an in r soll das Ergebnis stehen, da fehlte ein return ! Aber das Ergebnis der ggT ist bei dir falsch


----------



## SchwarzWeiß (16. Nov 2017)

1. du hast im Methodenkopf von ggT() als Rückgabewert int definiert, es wird jedoch kein int zurückgegeben
2. das Aufrufen von ggT() in kürzen() reicht nicht, du musst den Rückgabewert auch in einer Variable speichern


----------



## JStein52 (16. Nov 2017)

Und die kürzen ist auch falsch. Du musst die ggT mit zähler und nenner als Parameter aufrufen, und zwar mit dem Absolutwert derselben


----------



## OPMajor (16. Nov 2017)

JStein52 hat gesagt.:


> Das hier ist eine Standard-ggT die du üerall im Netz findest:
> 
> ```
> private int ggT(int a, int b) {
> ...



r = Rest der ganzzahligen Division von a/b.

Aber mir ist es egal, welcher Algorithmus, solange es funktioniert


----------



## JStein52 (16. Nov 2017)

Ich habe jetzt mal deine ggT so verstanden dass in a am Ende das Ergebnis steht und dann passt es. Also fehlt return a;


----------



## JStein52 (16. Nov 2017)

kürzen:


```
public Fraction kürzen() {
    Fraction c= new Fraction(0,0);
    int ggt = ggT(Math.abs(zähler), Math.abs(nenner));
    c.zähler = this.zähler / ggt;
    c.nenner = this.nenner / ggt;
    return c;
```


----------



## JStein52 (16. Nov 2017)

Und jetzt bist du fertig

Edit: in main noch Testfälle für umrechnen, kehrwert und kuerzen einbauen


----------



## OPMajor (16. Nov 2017)

SchwarzWeiß hat gesagt.:


> 1. du hast im Methodenkopf von ggT() als Rückgabewert int definiert, es wird jedoch kein int zurückgegeben
> 2. das Aufrufen von ggT() in kürzen() reicht nicht, du musst den Rückgabewert auch in einer Variable speichern


Wie mache ich das zweite?


----------



## SchwarzWeiß (16. Nov 2017)

Ich meinte diese Zeile:



JStein52 hat gesagt.:


> ```
> int ggt = ggT(Math.abs(zähler), Math.abs(nenner));
> ```


----------



## OPMajor (16. Nov 2017)

JStein52 hat gesagt.:


> Und jetzt bist du fertig
> 
> Edit: in main noch Testfälle für umrechnen, kehrwert und kuerzen einbauen


Danke. Was meinst du mit Testfälle?


----------



## JStein52 (16. Nov 2017)

Na ja so wie du es mit Addition und so gemacht hast


----------



## OPMajor (16. Nov 2017)

Ohne eure Hilfe hätte ich das niemals geschafft. Dankeschön.


```
public class Fraction {
    private int zähler =0;
     private int nenner = 0;
   
     public String toString() {
         String buffer = zähler + "/" + nenner;
         return buffer;
     }
 
     public Fraction(int zähler, int nenner){
     
        this.zähler = zähler;
        this.nenner = nenner;
     }
   
public Fraction addiere(Fraction b) {
    // Hauptnenner bilden
    int common = hauptNenner(this.nenner, b.nenner);
    // zwei neue Brüche anlegen die dann passend erweitert werden
    Fraction commonA = new Fraction(0,0);
    Fraction commonB = new Fraction(0,0);
    commonA = erweitern(common);
    commonB = b.erweitern(common);
    // neuen Bruch anlegen fuer das Ergebnis
    Fraction sum = new Fraction(0,0);
    // berechne die Summe
    sum.zähler = commonA.zähler + commonB.zähler;
    sum.nenner = common;
    // hier könnte man jetzt noch kuerzen

    return sum;
}
private int hauptNenner(int nenner1, int nenner2) {
    int factor = nenner1;
    while ((nenner1 % nenner2) != 0) {
        nenner1 += factor;
    }
    return nenner1;
}
private Fraction erweitern(int common) {
    Fraction result = new Fraction(1,2);
    int factor = common / this.nenner;
    result.zähler = this.zähler * factor;
    result.nenner = common;
    return result;
}
             
    public Fraction multiplizieren(Fraction b) {                 

     Fraction produkt = new Fraction(0,0);
        produkt.zähler = this.zähler *b.zähler;
        produkt.nenner = this.nenner * b.nenner;
 
       return produkt;
    }
       
     public  double umrechnenFließkommaZahl() {
    double    umrechnung = (double)this.zähler / (double) this.nenner;
 
       return umrechnung;
    }
 
    public  Fraction kehrwert() {
        Fraction k = new Fraction(0,0);
        k.zähler = this.nenner;
        k.nenner = this.zähler;
        return k;
 
    }
    private int ggT(int a, int b) {
    int r;
 
    do{
       r=a%b;
       a=b;
       b=r;
       }while (r!=0);
 
    return a;
    }
 public Fraction kürzen() {
    Fraction c= new Fraction(0,0);
    int ggt = ggT(Math.abs(zähler), Math.abs(nenner));
    c.zähler = this.zähler / ggt;
    c.nenner = this.nenner / ggt;
    return c;
 }
 
 
 }
```


```
import java.util.Scanner;

public class A {
    public static void main(String[] args) {
     
     
           @SuppressWarnings("resource")
           Scanner eingabe= new Scanner (System.in);
           System.out.println("Geben Sie bitte den Zähler des ersten Bruchs ein.");
            int x=eingabe.nextInt();
            System.out.println("Geben Sie bitte den Nenner des ersten Bruchs ein.");
            int y=eingabe.nextInt();
            System.out.println("Geben Sie bitte den Zähler des zweiten Bruchs ein.");
            int v=eingabe.nextInt();
            System.out.println("Geben Sie bitte den Nenner des zweiten Bruchs ein.");
            int z=eingabe.nextInt();
                 
         
         
 
            Fraction bruch1 = new Fraction(x,y);
            Fraction bruch2 = new Fraction(v,z);
            Fraction summe = bruch1.addiere(bruch2);
            System.out.println("Die Summe ergibt "+summe);
            Fraction bruch3 = new Fraction(x,y);
            Fraction bruch4 = new Fraction(v,z);
            Fraction pro = bruch3.multiplizieren(bruch4);
            System.out.println("Das Produkt ist "+pro);
            Fraction bruch5 = new Fraction(x,y);
            double umrechnen = bruch5.umrechnenFließkommaZahl();
            System.out.println("Die Fließkommazahl ist "+umrechnen);
            Fraction bruch6 = new Fraction(x,y);
            Fraction kehrwert = bruch6.kehrwert();
            System.out.println("Der Kehrwert ist "+kehrwert);
            Fraction bruch7 = new Fraction(x,y);
            Fraction kürzen= bruch7.kürzen();
            System.out.println("Der äquivalente Bruch lautet " +kürzen);
         
         
         
       }
}
```

Konsole

```
Geben Sie bitte den Zähler des ersten Bruchs ein.
3
Geben Sie bitte den Nenner des ersten Bruchs ein.
9
Geben Sie bitte den Zähler des zweiten Bruchs ein.
1
Geben Sie bitte den Nenner des zweiten Bruchs ein.
2
Die Summe ergibt 15/18
Das Produkt ist 3/18
Die Fließkommazahl ist 0.3333333333333333
Der Kehrwert ist 9/3
Der äquivalente Bruch lautet 1/3
```


----------



## SchwarzWeiß (16. Nov 2017)

Jetzt nur noch ein Leerzeichen nach dem "lautet" 
Gut, ich hoffe du hast alles verstanden was wir hier gemacht haben und wenn nicht, kannst du jederzeit nachfragen.


----------

